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"
28 #include "fold-const.h"
29 #include "stringpool.h"
30 #include "stor-layout.h"
34 #include "cp/cp-tree.h"
40 #include "c-family/c-common.h"
41 #include "c-family/c-objc.h"
42 #include "c-family/c-pragma.h"
43 #include "c-family/c-format.h"
45 #include "langhooks.h"
48 #include "hard-reg-set.h"
52 #include "c-family/c-target.h"
53 #include "diagnostic-core.h"
56 #include "tree-iterator.h"
57 #include "langhooks-def.h"
58 /* Different initialization, code gen and meta data generation for each
60 #include "objc-runtime-hooks.h"
61 /* Routines used mainly by the runtimes. */
62 #include "objc-runtime-shared-support.h"
63 /* For default_tree_printer (). */
64 #include "tree-pretty-print.h"
66 /* For enum gimplify_status */
67 #include "gimple-expr.h"
70 /* For encode_method_prototype(). */
71 #include "objc-encoding.h"
73 static unsigned int should_call_super_dealloc
= 0;
75 /* When building Objective-C++, we are not linking against the C front-end
76 and so need to replicate the C tree-construction functions in some way. */
78 #define OBJCP_REMAP_FUNCTIONS
79 #include "objcp-decl.h"
82 /* This is the default way of generating a method name. */
83 /* This has the problem that "test_method:argument:" and
84 "test:method_argument:" will generate the same name
85 ("_i_Test__test_method_argument_" for an instance method of the
86 class "Test"), so you can't have them both in the same class!
87 Moreover, the demangling (going from
88 "_i_Test__test_method_argument" back to the original name) is
89 undefined because there are two correct ways of demangling the
91 #ifndef OBJC_GEN_METHOD_LABEL
92 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
95 sprintf ((BUF), "_%s_%s_%s_%s", \
96 ((IS_INST) ? "i" : "c"), \
98 ((CAT_NAME)? (CAT_NAME) : ""), \
100 for (temp = (BUF); *temp; temp++) \
101 if (*temp == ':') *temp = '_'; \
105 /* These need specifying. */
106 #ifndef OBJC_FORWARDING_STACK_OFFSET
107 #define OBJC_FORWARDING_STACK_OFFSET 0
110 #ifndef OBJC_FORWARDING_MIN_OFFSET
111 #define OBJC_FORWARDING_MIN_OFFSET 0
114 /*** Private Interface (procedures) ***/
117 static void synth_module_prologue (void);
119 /* Code generation. */
121 static tree
start_class (enum tree_code
, tree
, tree
, tree
, tree
);
122 static tree
continue_class (tree
);
123 static void finish_class (tree
);
124 static void start_method_def (tree
, tree
);
126 static tree
start_protocol (enum tree_code
, tree
, tree
, tree
);
127 static tree
build_method_decl (enum tree_code
, tree
, tree
, tree
, bool);
128 static tree
objc_add_method (tree
, tree
, int, bool);
129 static tree
add_instance_variable (tree
, objc_ivar_visibility_kind
, tree
);
130 static tree
build_ivar_reference (tree
);
131 static tree
is_ivar (tree
, tree
);
133 /* We only need the following for ObjC; ObjC++ will use C++'s definition
134 of DERIVED_FROM_P. */
136 static bool objc_derived_from_p (tree
, tree
);
137 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
141 static void objc_gen_property_data (tree
, tree
);
142 static void objc_synthesize_getter (tree
, tree
, tree
);
143 static void objc_synthesize_setter (tree
, tree
, tree
);
144 static tree
lookup_property (tree
, tree
);
145 static tree
lookup_property_in_list (tree
, tree
);
146 static tree
lookup_property_in_protocol_list (tree
, tree
);
147 static void build_common_objc_property_accessor_helpers (void);
149 static void objc_xref_basetypes (tree
, tree
);
151 static tree
get_class_ivars (tree
, bool);
153 static void build_fast_enumeration_state_template (void);
156 static void objc_generate_cxx_cdtors (void);
160 static void objc_decl_method_attributes (tree
*, tree
, int);
161 static tree
build_keyword_selector (tree
);
163 static void hash_init (void);
165 /* Hash tables to manage the global pool of method prototypes. Each
166 of these maps map a method name (selector) identifier to either a
167 single tree (for methods with a single method prototype) or a
168 TREE_VEC (for methods with multiple method prototypes). */
169 static GTY(()) objc_map_t instance_method_map
= 0;
170 static GTY(()) objc_map_t class_method_map
= 0;
172 /* Hash tables to manage the global pool of class names. */
174 static GTY(()) objc_map_t class_name_map
= 0;
175 static GTY(()) objc_map_t alias_name_map
= 0;
177 static tree
lookup_method (tree
, tree
);
178 static tree
lookup_method_static (tree
, tree
, int);
180 static void interface_hash_init (void);
181 static tree
add_interface (tree
, tree
);
182 static void add_category (tree
, tree
);
183 static inline tree
lookup_category (tree
, tree
);
187 static tree
lookup_protocol (tree
, bool, bool);
188 static tree
lookup_and_install_protocols (tree
, bool);
191 static void really_start_method (tree
, tree
);
193 static void really_start_method (tree
, struct c_arg_info
*);
195 static int comp_proto_with_proto (tree
, tree
, int);
196 static tree
objc_decay_parm_type (tree
);
198 /* Utilities for debugging and error diagnostics. */
200 static char *gen_type_name (tree
);
201 static char *gen_type_name_0 (tree
);
202 static char *gen_method_decl (tree
);
203 static char *gen_declaration (tree
);
205 /* Everything else. */
207 static void generate_struct_by_value_array (void) ATTRIBUTE_NORETURN
;
209 static void mark_referenced_methods (void);
210 static bool objc_type_valid_for_messaging (tree type
, bool allow_classes
);
211 static tree
check_duplicates (tree
, int, int);
213 /*** Private Interface (data) ***/
214 /* Flags for lookup_method_static(). */
216 /* Look for class methods. */
217 #define OBJC_LOOKUP_CLASS 1
218 /* Do not examine superclasses. */
219 #define OBJC_LOOKUP_NO_SUPER 2
220 /* Disable returning an instance method of a root class when a class
221 method can't be found. */
222 #define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4
224 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
225 tree objc_global_trees
[OCTI_MAX
];
227 struct imp_entry
*imp_list
= 0;
228 int imp_count
= 0; /* `@implementation' */
229 int cat_count
= 0; /* `@category' */
231 objc_ivar_visibility_kind objc_ivar_visibility
, objc_default_ivar_visibility
;
233 /* Use to generate method labels. */
234 static int method_slot
= 0;
236 /* Flag to say whether methods in a protocol are optional or
238 static bool objc_method_optional_flag
= false;
240 static int objc_collecting_ivars
= 0;
242 /* Flag that is set to 'true' while we are processing a class
243 extension. Since a class extension just "reopens" the main
244 @interface, this can be used to determine if we are in the main
245 @interface, or in a class extension. */
246 static bool objc_in_class_extension
= false;
248 static char *errbuf
; /* Buffer for error diagnostics */
250 /* An array of all the local variables in the current function that
251 need to be marked as volatile. */
252 vec
<tree
, va_gc
> *local_variables_to_volatilize
= NULL
;
254 /* Store all constructed constant strings in a hash table so that
255 they get uniqued properly. */
257 struct GTY((for_user
)) string_descriptor
{
258 /* The literal argument . */
261 /* The resulting constant string. */
265 struct objc_string_hasher
: ggc_ptr_hash
<string_descriptor
>
267 static hashval_t
hash (string_descriptor
*);
268 static bool equal (string_descriptor
*, string_descriptor
*);
271 static GTY(()) hash_table
<objc_string_hasher
> *string_htab
;
273 FILE *gen_declaration_file
;
275 /* Hooks for stuff that differs between runtimes. */
276 objc_runtime_hooks runtime
;
278 /* Create a temporary variable of type 'type'. If 'name' is set, uses
279 the specified name, else use no name. Returns the declaration of
280 the type. The 'name' is mostly useful for debugging.
283 objc_create_temporary_var (tree type
, const char *name
)
289 decl
= build_decl (input_location
,
290 VAR_DECL
, get_identifier (name
), type
);
294 decl
= build_decl (input_location
,
295 VAR_DECL
, NULL_TREE
, type
);
297 TREE_USED (decl
) = 1;
298 DECL_ARTIFICIAL (decl
) = 1;
299 DECL_IGNORED_P (decl
) = 1;
300 DECL_CONTEXT (decl
) = current_function_decl
;
305 /* Some platforms pass small structures through registers versus
306 through an invisible pointer. Determine at what size structure is
307 the transition point between the two possibilities. */
310 generate_struct_by_value_array (void)
315 int aggregate_in_mem
[32];
318 /* Presumably no platform passes 32 byte structures in a register. */
319 /* ??? As an example, m64/ppc/Darwin can pass up to 8*long+13*double
321 for (i
= 1; i
< 32; i
++)
326 /* Create an unnamed struct that has `i' character components */
327 type
= objc_start_struct (NULL_TREE
);
329 strcpy (buffer
, "c1");
330 decls
= add_field_decl (char_type_node
, buffer
, &chain
);
332 for (j
= 1; j
< i
; j
++)
334 sprintf (buffer
, "c%d", j
+ 1);
335 add_field_decl (char_type_node
, buffer
, &chain
);
337 objc_finish_struct (type
, decls
);
339 aggregate_in_mem
[i
] = aggregate_value_p (type
, 0);
340 if (!aggregate_in_mem
[i
])
344 /* We found some structures that are returned in registers instead of memory
345 so output the necessary data. */
348 for (i
= 31; i
>= 0; i
--)
349 if (!aggregate_in_mem
[i
])
351 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n", i
);
362 if (cxx_init () == false)
364 if (c_objc_common_init () == false)
368 /* print_struct_values is triggered by -print-runtime-info (used
369 when building libobjc, with an empty file as input). It does not
370 require any ObjC setup, and it never returns.
372 -fcompare-debug is used to check the compiler output; we are
373 executed twice, once with flag_compare_debug set, and once with
374 it not set. If the flag is used together with
375 -print-runtime-info, we want to print the runtime info only once,
376 else it would be output in duplicate. So we check
377 flag_compare_debug to output it in only one of the invocations.
379 As a side effect, this also that means -fcompare-debug
380 -print-runtime-info will run the compiler twice, and compare the
381 generated assembler file; the first time the compiler exits
382 immediately (producing no file), and the second time it compiles
383 an empty file. This checks, as a side effect, that compiling an
384 empty file produces no assembler output. */
385 if (print_struct_values
&& !flag_compare_debug
)
386 generate_struct_by_value_array ();
388 /* Set up stuff used by FE parser and all runtimes. */
389 errbuf
= XNEWVEC (char, 1024 * 10);
390 interface_hash_init ();
392 objc_encoding_init ();
393 /* ... and then check flags and set-up for the selected runtime ... */
394 if (flag_next_runtime
&& flag_objc_abi
>= 2)
395 ok
= objc_next_runtime_abi_02_init (&runtime
);
396 else if (flag_next_runtime
)
397 ok
= objc_next_runtime_abi_01_init (&runtime
);
399 ok
= objc_gnu_runtime_abi_01_init (&runtime
);
401 /* If that part of the setup failed - bail out immediately. */
405 /* Determine the default visibility for instance variables. */
406 switch (default_ivar_visibility
)
408 case IVAR_VISIBILITY_PRIVATE
:
409 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PRIVATE
;
411 case IVAR_VISIBILITY_PUBLIC
:
412 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PUBLIC
;
414 case IVAR_VISIBILITY_PACKAGE
:
415 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PACKAGE
;
418 objc_default_ivar_visibility
= OBJC_IVAR_VIS_PROTECTED
;
421 /* Generate general types and push runtime-specific decls to file scope. */
422 synth_module_prologue ();
427 /* This is called at the end of parsing by the C/C++ parsers. */
429 objc_write_global_declarations (void)
431 mark_referenced_methods ();
433 /* A missing @end might not be detected by the parser. */
434 if (objc_implementation_context
)
436 warning (0, "%<@end%> missing in implementation context");
437 finish_class (objc_implementation_context
);
438 objc_ivar_chain
= NULL_TREE
;
439 objc_implementation_context
= NULL_TREE
;
444 objc_map_iterator_t i
;
446 objc_map_iterator_initialize (class_method_map
, &i
);
447 while (objc_map_iterator_move_to_next (class_method_map
, &i
))
448 check_duplicates (objc_map_iterator_current_value (class_method_map
, i
), 0, 1);
450 objc_map_iterator_initialize (instance_method_map
, &i
);
451 while (objc_map_iterator_move_to_next (instance_method_map
, &i
))
452 check_duplicates (objc_map_iterator_current_value (instance_method_map
, i
), 0, 0);
455 /* TODO: consider an early exit here if either errorcount or sorrycount
456 is non-zero. Not only is it wasting time to generate the metadata,
457 it needlessly imposes need to re-check for things that are already
458 determined to be errors. */
460 /* Finalize Objective-C runtime data. No need to generate tables
461 and code if only checking syntax, or if generating a PCH file. */
462 if (!flag_syntax_only
&& !pch_file
)
464 location_t saved_location
;
466 /* If gen_declaration desired, open the output file. */
467 if (flag_gen_declaration
)
469 char * const dumpname
= concat (dump_base_name
, ".decl", NULL
);
470 gen_declaration_file
= fopen (dumpname
, "w");
471 if (gen_declaration_file
== 0)
472 fatal_error (input_location
, "can%'t open %s: %m", dumpname
);
476 /* Set the input location to BUILTINS_LOCATION. This is good
477 for error messages, in case any is generated while producing
478 the metadata, but it also silences warnings that would be
479 produced when compiling with -Wpadded in case when padding is
480 automatically added to the built-in runtime data structure
481 declarations. We know about this padding, and it is fine; we
482 don't want users to see any warnings about it if they use
484 saved_location
= input_location
;
485 input_location
= BUILTINS_LOCATION
;
487 /* Compute and emit the meta-data tables for this runtime. */
488 (*runtime
.generate_metadata
) ();
490 /* Restore the original location, just in case it mattered. */
491 input_location
= saved_location
;
493 /* ... and then close any declaration file we opened. */
494 if (gen_declaration_file
)
495 fclose (gen_declaration_file
);
499 /* Return the first occurrence of a method declaration corresponding
500 to sel_name in rproto_list. Search rproto_list recursively.
501 If is_class is 0, search for instance methods, otherwise for class
504 lookup_method_in_protocol_list (tree rproto_list
, tree sel_name
,
509 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
511 p
= TREE_VALUE (rproto
);
514 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
516 /* First, search the @required protocol methods. */
518 m
= lookup_method (PROTOCOL_CLS_METHODS (p
), sel_name
);
520 m
= lookup_method (PROTOCOL_NST_METHODS (p
), sel_name
);
525 /* If still not found, search the @optional protocol methods. */
527 m
= lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p
), sel_name
);
529 m
= lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p
), sel_name
);
534 /* If still not found, search the attached protocols. */
535 if (PROTOCOL_LIST (p
))
536 m
= lookup_method_in_protocol_list (PROTOCOL_LIST (p
),
543 ; /* An identifier...if we could not find a protocol. */
551 lookup_protocol_in_reflist (tree rproto_list
, tree lproto
)
555 /* Make sure the protocol is supported by the object on the rhs. */
556 if (TREE_CODE (lproto
) == PROTOCOL_INTERFACE_TYPE
)
559 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
561 p
= TREE_VALUE (rproto
);
563 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
568 else if (PROTOCOL_LIST (p
))
569 fnd
= lookup_protocol_in_reflist (PROTOCOL_LIST (p
), lproto
);
578 ; /* An identifier...if we could not find a protocol. */
585 objc_start_class_interface (tree klass
, tree super_class
,
586 tree protos
, tree attributes
)
588 if (flag_objc1_only
&& attributes
)
589 error_at (input_location
, "class attributes are not available in Objective-C 1.0");
591 objc_interface_context
593 = start_class (CLASS_INTERFACE_TYPE
, klass
, super_class
, protos
, attributes
);
594 objc_ivar_visibility
= objc_default_ivar_visibility
;
598 objc_start_category_interface (tree klass
, tree categ
,
599 tree protos
, tree attributes
)
604 error_at (input_location
, "category attributes are not available in Objective-C 1.0");
606 warning_at (input_location
, OPT_Wattributes
,
607 "category attributes are not available in this version"
608 " of the compiler, (ignored)");
610 if (categ
== NULL_TREE
)
613 error_at (input_location
, "class extensions are not available in Objective-C 1.0");
616 /* Iterate over all the classes and categories implemented
617 up to now in this compilation unit. */
620 for (t
= imp_list
; t
; t
= t
->next
)
622 /* If we find a class @implementation with the same name
623 as the one we are extending, produce an error. */
624 if (TREE_CODE (t
->imp_context
) == CLASS_IMPLEMENTATION_TYPE
625 && IDENTIFIER_POINTER (CLASS_NAME (t
->imp_context
)) == IDENTIFIER_POINTER (klass
))
626 error_at (input_location
,
627 "class extension for class %qE declared after its %<@implementation%>",
632 objc_interface_context
633 = start_class (CATEGORY_INTERFACE_TYPE
, klass
, categ
, protos
, NULL_TREE
);
635 = continue_class (objc_interface_context
);
639 objc_start_protocol (tree name
, tree protos
, tree attributes
)
641 if (flag_objc1_only
&& attributes
)
642 error_at (input_location
, "protocol attributes are not available in Objective-C 1.0");
644 objc_interface_context
645 = start_protocol (PROTOCOL_INTERFACE_TYPE
, name
, protos
, attributes
);
646 objc_method_optional_flag
= false;
650 objc_continue_interface (void)
653 = continue_class (objc_interface_context
);
657 objc_finish_interface (void)
659 finish_class (objc_interface_context
);
660 objc_interface_context
= NULL_TREE
;
661 objc_method_optional_flag
= false;
662 objc_in_class_extension
= false;
666 objc_start_class_implementation (tree klass
, tree super_class
)
668 objc_implementation_context
670 = start_class (CLASS_IMPLEMENTATION_TYPE
, klass
, super_class
, NULL_TREE
,
672 objc_ivar_visibility
= objc_default_ivar_visibility
;
676 objc_start_category_implementation (tree klass
, tree categ
)
678 objc_implementation_context
679 = start_class (CATEGORY_IMPLEMENTATION_TYPE
, klass
, categ
, NULL_TREE
,
682 = continue_class (objc_implementation_context
);
686 objc_continue_implementation (void)
689 = continue_class (objc_implementation_context
);
693 objc_finish_implementation (void)
696 if (flag_objc_call_cxx_cdtors
)
697 objc_generate_cxx_cdtors ();
700 if (objc_implementation_context
)
702 finish_class (objc_implementation_context
);
703 objc_ivar_chain
= NULL_TREE
;
704 objc_implementation_context
= NULL_TREE
;
707 warning (0, "%<@end%> must appear in an @implementation context");
711 objc_set_visibility (objc_ivar_visibility_kind visibility
)
713 if (visibility
== OBJC_IVAR_VIS_PACKAGE
)
716 error ("%<@package%> is not available in Objective-C 1.0");
718 warning (0, "%<@package%> presently has the same effect as %<@public%>");
720 objc_ivar_visibility
= visibility
;
724 objc_set_method_opt (bool optional
)
729 error_at (input_location
, "%<@optional%> is not available in Objective-C 1.0");
731 error_at (input_location
, "%<@required%> is not available in Objective-C 1.0");
734 objc_method_optional_flag
= optional
;
735 if (!objc_interface_context
736 || TREE_CODE (objc_interface_context
) != PROTOCOL_INTERFACE_TYPE
)
739 error ("%<@optional%> is allowed in @protocol context only");
741 error ("%<@required%> is allowed in @protocol context only");
742 objc_method_optional_flag
= false;
746 /* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or
749 lookup_property_in_list (tree chain
, tree property
)
752 for (x
= CLASS_PROPERTY_DECL (chain
); x
; x
= TREE_CHAIN (x
))
753 if (PROPERTY_NAME (x
) == property
)
758 /* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */
759 static tree
lookup_property_in_protocol_list (tree rproto_list
, tree property
)
762 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
764 tree p
= TREE_VALUE (rproto
);
765 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
767 if ((x
= lookup_property_in_list (p
, property
)))
769 if (PROTOCOL_LIST (p
))
770 return lookup_property_in_protocol_list (PROTOCOL_LIST (p
), property
);
774 ; /* An identifier...if we could not find a protocol. */
780 /* This routine looks up the PROPERTY in current INTERFACE, its categories and up the
781 chain of interface hierarchy. */
783 lookup_property (tree interface_type
, tree property
)
785 tree inter
= interface_type
;
789 if ((x
= lookup_property_in_list (inter
, property
)))
791 /* Failing that, look for the property in each category of the class. */
793 while ((category
= CLASS_CATEGORY_LIST (category
)))
795 if ((x
= lookup_property_in_list (category
, property
)))
798 /* When checking a category, also check the protocols
799 attached with the category itself. */
800 if (CLASS_PROTOCOL_LIST (category
)
801 && (x
= lookup_property_in_protocol_list
802 (CLASS_PROTOCOL_LIST (category
), property
)))
806 /* Failing to find in categories, look for property in protocol list. */
807 if (CLASS_PROTOCOL_LIST (inter
)
808 && (x
= lookup_property_in_protocol_list
809 (CLASS_PROTOCOL_LIST (inter
), property
)))
812 /* Failing that, climb up the inheritance hierarchy. */
813 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
818 /* This routine is called by the parser when a
819 @property... declaration is found. 'decl' is the declaration of
820 the property (type/identifier), and the other arguments represent
821 property attributes that may have been specified in the Objective-C
822 declaration. 'parsed_property_readonly' is 'true' if the attribute
823 'readonly' was specified, and 'false' if not; similarly for the
824 other bool parameters. 'parsed_property_getter_ident' is NULL_TREE
825 if the attribute 'getter' was not specified, and is the identifier
826 corresponding to the specified getter if it was; similarly for
827 'parsed_property_setter_ident'. */
829 objc_add_property_declaration (location_t location
, tree decl
,
830 bool parsed_property_readonly
, bool parsed_property_readwrite
,
831 bool parsed_property_assign
, bool parsed_property_retain
,
832 bool parsed_property_copy
, bool parsed_property_nonatomic
,
833 tree parsed_property_getter_ident
, tree parsed_property_setter_ident
)
837 /* 'property_readonly' and 'property_assign_semantics' are the final
838 attributes of the property after all parsed attributes have been
839 considered (eg, if we parsed no 'readonly' and no 'readwrite', ie
840 parsed_property_readonly = false and parsed_property_readwrite =
841 false, then property_readonly will be false because the default
843 bool property_readonly
= false;
844 objc_property_assign_semantics property_assign_semantics
= OBJC_PROPERTY_ASSIGN
;
845 bool property_extension_in_class_extension
= false;
848 error_at (input_location
, "%<@property%> is not available in Objective-C 1.0");
850 if (parsed_property_readonly
&& parsed_property_readwrite
)
852 error_at (location
, "%<readonly%> attribute conflicts with %<readwrite%> attribute");
853 /* In case of conflicting attributes (here and below), after
854 producing an error, we pick one of the attributes and keep
856 property_readonly
= false;
860 if (parsed_property_readonly
)
861 property_readonly
= true;
863 if (parsed_property_readwrite
)
864 property_readonly
= false;
867 if (parsed_property_readonly
&& parsed_property_setter_ident
)
869 error_at (location
, "%<readonly%> attribute conflicts with %<setter%> attribute");
870 property_readonly
= false;
873 if (parsed_property_assign
&& parsed_property_retain
)
875 error_at (location
, "%<assign%> attribute conflicts with %<retain%> attribute");
876 property_assign_semantics
= OBJC_PROPERTY_RETAIN
;
878 else if (parsed_property_assign
&& parsed_property_copy
)
880 error_at (location
, "%<assign%> attribute conflicts with %<copy%> attribute");
881 property_assign_semantics
= OBJC_PROPERTY_COPY
;
883 else if (parsed_property_retain
&& parsed_property_copy
)
885 error_at (location
, "%<retain%> attribute conflicts with %<copy%> attribute");
886 property_assign_semantics
= OBJC_PROPERTY_COPY
;
890 if (parsed_property_assign
)
891 property_assign_semantics
= OBJC_PROPERTY_ASSIGN
;
893 if (parsed_property_retain
)
894 property_assign_semantics
= OBJC_PROPERTY_RETAIN
;
896 if (parsed_property_copy
)
897 property_assign_semantics
= OBJC_PROPERTY_COPY
;
900 if (!objc_interface_context
)
902 error_at (location
, "property declaration not in @interface or @protocol context");
906 /* At this point we know that we are either in an interface, a
907 category, or a protocol. */
909 /* We expect a FIELD_DECL from the parser. Make sure we didn't get
910 something else, as that would confuse the checks below. */
911 if (TREE_CODE (decl
) != FIELD_DECL
)
913 error_at (location
, "invalid property declaration");
917 /* Do some spot-checks for the most obvious invalid types. */
919 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
921 error_at (location
, "property can not be an array");
925 /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when
926 parsing, while the C/ObjC parser accepts it and gives us a
927 FIELD_DECL with a DECL_INITIAL set. So we use the DECL_INITIAL
928 to check for a bitfield when doing ObjC. */
930 if (DECL_INITIAL (decl
))
932 /* A @property is not an actual variable, but it is a way to
933 describe a pair of accessor methods, so its type (which is
934 the type of the return value of the getter and the first
935 argument of the setter) can't be a bitfield (as return values
936 and arguments of functions can not be bitfields). The
937 underlying instance variable could be a bitfield, but that is
938 a different matter. */
939 error_at (location
, "property can not be a bit-field");
944 /* TODO: Check that the property type is an Objective-C object or a
947 /* Implement -Wproperty-assign-default (which is enabled by default). */
948 if (warn_property_assign_default
949 /* If garbage collection is not being used, then 'assign' is
950 valid for objects (and typically used for delegates) but it
951 is wrong in most cases (since most objects need to be
952 retained or copied in setters). Warn users when 'assign' is
954 && property_assign_semantics
== OBJC_PROPERTY_ASSIGN
955 /* Read-only properties are never assigned, so the assignment
956 semantics do not matter in that case. */
957 && !property_readonly
960 /* Please note that it would make sense to default to 'assign'
961 for non-{Objective-C objects}, and to 'retain' for
962 Objective-C objects. But that would break compatibility with
964 if (!parsed_property_assign
&& !parsed_property_retain
&& !parsed_property_copy
)
966 /* Use 'false' so we do not warn for Class objects. */
967 if (objc_type_valid_for_messaging (TREE_TYPE (decl
), false))
969 warning_at (location
,
971 "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>",
974 "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it");
979 if (property_assign_semantics
== OBJC_PROPERTY_RETAIN
980 && !objc_type_valid_for_messaging (TREE_TYPE (decl
), true))
981 error_at (location
, "%<retain%> attribute is only valid for Objective-C objects");
983 if (property_assign_semantics
== OBJC_PROPERTY_COPY
984 && !objc_type_valid_for_messaging (TREE_TYPE (decl
), true))
985 error_at (location
, "%<copy%> attribute is only valid for Objective-C objects");
987 /* Now determine the final property getter and setter names. They
988 will be stored in the PROPERTY_DECL, from which they'll always be
989 extracted and used. */
991 /* Adjust, or fill in, setter and getter names. We overwrite the
992 parsed_property_setter_ident and parsed_property_getter_ident
993 with the final setter and getter identifiers that will be
995 if (parsed_property_setter_ident
)
997 /* The setter should be terminated by ':', but the parser only
998 gives us an identifier without ':'. So, we need to add ':'
1000 const char *parsed_setter
= IDENTIFIER_POINTER (parsed_property_setter_ident
);
1001 size_t length
= strlen (parsed_setter
);
1002 char *final_setter
= (char *)alloca (length
+ 2);
1004 sprintf (final_setter
, "%s:", parsed_setter
);
1005 parsed_property_setter_ident
= get_identifier (final_setter
);
1009 if (!property_readonly
)
1010 parsed_property_setter_ident
= get_identifier (objc_build_property_setter_name
1011 (DECL_NAME (decl
)));
1014 if (!parsed_property_getter_ident
)
1015 parsed_property_getter_ident
= DECL_NAME (decl
);
1017 /* Check for duplicate property declarations. We first check the
1018 immediate context for a property with the same name. Any such
1019 declarations are an error, unless this is a class extension and
1020 we are extending a property from readonly to readwrite. */
1021 for (x
= CLASS_PROPERTY_DECL (objc_interface_context
); x
; x
= TREE_CHAIN (x
))
1023 if (PROPERTY_NAME (x
) == DECL_NAME (decl
))
1025 if (objc_in_class_extension
1026 && property_readonly
== 0
1027 && PROPERTY_READONLY (x
) == 1)
1029 /* This is a class extension, and we are extending an
1030 existing readonly property to a readwrite one.
1032 property_extension_in_class_extension
= true;
1037 location_t original_location
= DECL_SOURCE_LOCATION (x
);
1039 error_at (location
, "redeclaration of property %qD", decl
);
1041 if (original_location
!= UNKNOWN_LOCATION
)
1042 inform (original_location
, "originally specified here");
1048 /* If x is not NULL_TREE, we must be in a class extension and we're
1049 extending a readonly property. In that case, no point in
1050 searching for another declaration. */
1053 /* We now need to check for existing property declarations (in
1054 the superclass, other categories or protocols) and check that
1055 the new declaration is not in conflict with existing
1058 /* Search for a previous, existing declaration of a property
1059 with the same name in superclasses, protocols etc. If one is
1060 found, it will be in the 'x' variable. */
1062 /* Note that, for simplicity, the following may search again the
1063 local context. That's Ok as nothing will be found (else we'd
1064 have thrown an error above); it's only a little inefficient,
1065 but the code is simpler. */
1066 switch (TREE_CODE (objc_interface_context
))
1068 case CLASS_INTERFACE_TYPE
:
1069 /* Look up the property in the current @interface (which
1070 will find nothing), then its protocols and categories and
1072 x
= lookup_property (objc_interface_context
, DECL_NAME (decl
));
1074 case CATEGORY_INTERFACE_TYPE
:
1075 /* Look up the property in the main @interface, then
1076 protocols and categories (one of them is ours, and will
1077 find nothing) and superclasses. */
1078 x
= lookup_property (lookup_interface (CLASS_NAME (objc_interface_context
)),
1081 case PROTOCOL_INTERFACE_TYPE
:
1082 /* Looks up the property in any protocols attached to the
1083 current protocol. */
1084 if (PROTOCOL_LIST (objc_interface_context
))
1086 x
= lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context
),
1097 /* An existing property was found; check that it has the same
1098 types, or it is compatible. */
1099 location_t original_location
= DECL_SOURCE_LOCATION (x
);
1101 if (PROPERTY_NONATOMIC (x
) != parsed_property_nonatomic
)
1103 warning_at (location
, 0,
1104 "'nonatomic' attribute of property %qD conflicts with previous declaration", decl
);
1106 if (original_location
!= UNKNOWN_LOCATION
)
1107 inform (original_location
, "originally specified here");
1111 if (PROPERTY_GETTER_NAME (x
) != parsed_property_getter_ident
)
1113 warning_at (location
, 0,
1114 "'getter' attribute of property %qD conflicts with previous declaration", decl
);
1116 if (original_location
!= UNKNOWN_LOCATION
)
1117 inform (original_location
, "originally specified here");
1121 /* We can only compare the setter names if both the old and new property have a setter. */
1122 if (!property_readonly
&& !PROPERTY_READONLY(x
))
1124 if (PROPERTY_SETTER_NAME (x
) != parsed_property_setter_ident
)
1126 warning_at (location
, 0,
1127 "'setter' attribute of property %qD conflicts with previous declaration", decl
);
1129 if (original_location
!= UNKNOWN_LOCATION
)
1130 inform (original_location
, "originally specified here");
1135 if (PROPERTY_ASSIGN_SEMANTICS (x
) != property_assign_semantics
)
1137 warning_at (location
, 0,
1138 "assign semantics attributes of property %qD conflict with previous declaration", decl
);
1140 if (original_location
!= UNKNOWN_LOCATION
)
1141 inform (original_location
, "originally specified here");
1145 /* It's ok to have a readonly property that becomes a readwrite, but not vice versa. */
1146 if (PROPERTY_READONLY (x
) == 0 && property_readonly
== 1)
1148 warning_at (location
, 0,
1149 "'readonly' attribute of property %qD conflicts with previous declaration", decl
);
1151 if (original_location
!= UNKNOWN_LOCATION
)
1152 inform (original_location
, "originally specified here");
1156 /* We now check that the new and old property declarations have
1157 the same types (or compatible one). In the Objective-C
1158 tradition of loose type checking, we do type-checking but
1159 only generate warnings (not errors) if they do not match.
1160 For non-readonly properties, the types must match exactly;
1161 for readonly properties, it is allowed to use a "more
1162 specialized" type in the new property declaration. Eg, the
1163 superclass has a getter returning (NSArray *) and the
1164 subclass a getter returning (NSMutableArray *). The object's
1165 getter returns an (NSMutableArray *); but if you cast the
1166 object to the superclass, which is allowed, you'd still
1167 expect the getter to return an (NSArray *), which works since
1168 an (NSMutableArray *) is an (NSArray *) too. So, the set of
1169 objects belonging to the type of the new @property should be
1170 a subset of the set of objects belonging to the type of the
1171 old @property. This is what "specialization" means. And the
1172 reason it only applies to readonly properties is that for a
1173 readwrite property the setter would have the opposite
1174 requirement - ie that the superclass type is more specialized
1175 then the subclass one; hence the only way to satisfy both
1176 constraints is that the types match. */
1178 /* If the types are not the same in the C sense, we warn ... */
1179 if (!comptypes (TREE_TYPE (x
), TREE_TYPE (decl
))
1180 /* ... unless the property is readonly, in which case we
1181 allow a new, more specialized, declaration. */
1182 && (!property_readonly
1183 || !objc_compare_types (TREE_TYPE (x
),
1184 TREE_TYPE (decl
), -5, NULL_TREE
)))
1186 warning_at (location
, 0,
1187 "type of property %qD conflicts with previous declaration", decl
);
1188 if (original_location
!= UNKNOWN_LOCATION
)
1189 inform (original_location
, "originally specified here");
1193 /* If we are in a class extension and we're extending a readonly
1194 property in the main @interface, we'll just update the
1195 existing property with the readwrite flag and potentially the
1197 if (property_extension_in_class_extension
)
1199 PROPERTY_READONLY (x
) = 0;
1200 PROPERTY_SETTER_NAME (x
) = parsed_property_setter_ident
;
1205 /* Create a PROPERTY_DECL node. */
1206 property_decl
= make_node (PROPERTY_DECL
);
1208 /* Copy the basic information from the original decl. */
1209 TREE_TYPE (property_decl
) = TREE_TYPE (decl
);
1210 DECL_SOURCE_LOCATION (property_decl
) = DECL_SOURCE_LOCATION (decl
);
1211 TREE_DEPRECATED (property_decl
) = TREE_DEPRECATED (decl
);
1213 /* Add property-specific information. */
1214 PROPERTY_NAME (property_decl
) = DECL_NAME (decl
);
1215 PROPERTY_GETTER_NAME (property_decl
) = parsed_property_getter_ident
;
1216 PROPERTY_SETTER_NAME (property_decl
) = parsed_property_setter_ident
;
1217 PROPERTY_READONLY (property_decl
) = property_readonly
;
1218 PROPERTY_NONATOMIC (property_decl
) = parsed_property_nonatomic
;
1219 PROPERTY_ASSIGN_SEMANTICS (property_decl
) = property_assign_semantics
;
1220 PROPERTY_IVAR_NAME (property_decl
) = NULL_TREE
;
1221 PROPERTY_DYNAMIC (property_decl
) = 0;
1223 /* Remember the fact that the property was found in the @optional
1224 section in a @protocol, or not. */
1225 if (objc_method_optional_flag
)
1226 PROPERTY_OPTIONAL (property_decl
) = 1;
1228 PROPERTY_OPTIONAL (property_decl
) = 0;
1230 /* Note that PROPERTY_GETTER_NAME is always set for all
1231 PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all
1232 PROPERTY_DECLs where PROPERTY_READONLY == 0. Any time we deal
1233 with a getter or setter, we should get the PROPERTY_DECL and use
1234 PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct
1237 /* Add the PROPERTY_DECL to the list of properties for the class. */
1238 TREE_CHAIN (property_decl
) = CLASS_PROPERTY_DECL (objc_interface_context
);
1239 CLASS_PROPERTY_DECL (objc_interface_context
) = property_decl
;
1242 /* This is a subroutine of objc_maybe_build_component_ref. Search the
1243 list of methods in the interface (and, failing that, the local list
1244 in the implementation, and failing that, the protocol list)
1245 provided for a 'setter' or 'getter' for 'component' with default
1246 names (ie, if 'component' is "name", then search for "name" and
1247 "setName:"). It is also possible to specify a different
1248 'getter_name' (this is used for @optional readonly properties). If
1249 any is found, then create an artificial property that uses them.
1250 Return NULL_TREE if 'getter' or 'setter' could not be found. */
1252 maybe_make_artificial_property_decl (tree interface
, tree implementation
,
1253 tree protocol_list
, tree component
, bool is_class
,
1256 tree setter_name
= get_identifier (objc_build_property_setter_name (component
));
1257 tree getter
= NULL_TREE
;
1258 tree setter
= NULL_TREE
;
1260 if (getter_name
== NULL_TREE
)
1261 getter_name
= component
;
1263 /* First, check the @interface and all superclasses. */
1268 /* Using instance methods of the root class as accessors is most
1269 likely unwanted and can be extremely confusing (and, most
1270 importantly, other Objective-C 2.0 compilers do not do it).
1273 flags
= OBJC_LOOKUP_CLASS
| OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS
;
1275 getter
= lookup_method_static (interface
, getter_name
, flags
);
1276 setter
= lookup_method_static (interface
, setter_name
, flags
);
1279 /* Second, check the local @implementation context. */
1280 if (!getter
&& !setter
)
1286 getter
= lookup_method (CLASS_CLS_METHODS (implementation
), getter_name
);
1287 setter
= lookup_method (CLASS_CLS_METHODS (implementation
), setter_name
);
1291 getter
= lookup_method (CLASS_NST_METHODS (implementation
), getter_name
);
1292 setter
= lookup_method (CLASS_NST_METHODS (implementation
), setter_name
);
1297 /* Try the protocol_list if we didn't find anything in the
1298 @interface and in the @implementation. */
1299 if (!getter
&& !setter
)
1301 getter
= lookup_method_in_protocol_list (protocol_list
, getter_name
, is_class
);
1302 setter
= lookup_method_in_protocol_list (protocol_list
, setter_name
, is_class
);
1305 /* There needs to be at least a getter or setter for this to be a
1306 valid 'object.component' syntax. */
1307 if (getter
|| setter
)
1309 /* Yes ... determine the type of the expression. */
1314 type
= TREE_VALUE (TREE_TYPE (getter
));
1316 type
= TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter
)));
1318 /* Create an artificial property declaration with the
1319 information we collected on the type and getter/setter
1321 property_decl
= make_node (PROPERTY_DECL
);
1323 TREE_TYPE (property_decl
) = type
;
1324 DECL_SOURCE_LOCATION (property_decl
) = input_location
;
1325 TREE_DEPRECATED (property_decl
) = 0;
1326 DECL_ARTIFICIAL (property_decl
) = 1;
1328 /* Add property-specific information. Note that one of
1329 PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a
1330 non-existing method; this will generate an error when the
1331 expression is later compiled. At this stage we don't know if
1332 the getter or setter will be used, so we can't generate an
1334 PROPERTY_NAME (property_decl
) = component
;
1335 PROPERTY_GETTER_NAME (property_decl
) = getter_name
;
1336 PROPERTY_SETTER_NAME (property_decl
) = setter_name
;
1337 PROPERTY_READONLY (property_decl
) = 0;
1338 PROPERTY_NONATOMIC (property_decl
) = 0;
1339 PROPERTY_ASSIGN_SEMANTICS (property_decl
) = 0;
1340 PROPERTY_IVAR_NAME (property_decl
) = NULL_TREE
;
1341 PROPERTY_DYNAMIC (property_decl
) = 0;
1342 PROPERTY_OPTIONAL (property_decl
) = 0;
1345 PROPERTY_HAS_NO_GETTER (property_decl
) = 1;
1347 /* The following is currently unused, but it's nice to have
1348 there. We may use it if we need in the future. */
1350 PROPERTY_HAS_NO_SETTER (property_decl
) = 1;
1352 return property_decl
;
1358 /* This hook routine is invoked by the parser when an expression such
1359 as 'xxx.yyy' is parsed. We get a chance to process these
1360 expressions in a way that is specified to Objective-C (to implement
1361 the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars).
1362 If the expression is not an Objective-C specified expression, we
1363 should return NULL_TREE; else we return the expression.
1365 At the moment this only implements dot-syntax and properties (not
1366 non-fragile ivars yet), ie 'object.property' or 'object.component'
1367 where 'component' is not a declared property, but a valid getter or
1368 setter for it could be found. */
1370 objc_maybe_build_component_ref (tree object
, tree property_ident
)
1375 /* If we are in Objective-C 1.0 mode, dot-syntax and properties are
1377 if (flag_objc1_only
)
1380 /* Try to determine if 'object' is an Objective-C object or not. If
1382 if (object
== NULL_TREE
|| object
== error_mark_node
1383 || (rtype
= TREE_TYPE (object
)) == NULL_TREE
)
1386 if (property_ident
== NULL_TREE
|| property_ident
== error_mark_node
1387 || TREE_CODE (property_ident
) != IDENTIFIER_NODE
)
1390 /* The following analysis of 'object' is similar to the one used for
1391 the 'receiver' of a method invocation. We need to determine what
1392 'object' is and find the appropriate property (either declared,
1393 or artificial) for it (in the same way as we need to find the
1394 appropriate method prototype for a method invocation). There are
1395 some simplifications here though: "object.property" is invalid if
1396 "object" has a type of "id" or "Class"; it must at least have a
1397 protocol attached to it, and "object" is never a class name as
1398 that is done by objc_build_class_component_ref. Finally, we
1399 don't know if this really is a dot-syntax expression, so we want
1400 to make a quick exit if it is not; for this reason, we try to
1401 postpone checks after determining that 'object' looks like an
1402 Objective-C object. */
1404 if (objc_is_id (rtype
))
1406 /* This is the case that the 'object' is of type 'id' or
1409 /* Check if at least it is of type 'id <Protocol>' or 'Class
1410 <Protocol>'; if so, look the property up in the
1412 if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype
)))
1414 tree rprotos
= TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype
));
1418 /* No point looking up declared @properties if we are
1419 dealing with a class. Classes have no declared
1421 if (!IS_CLASS (rtype
))
1422 x
= lookup_property_in_protocol_list (rprotos
, property_ident
);
1426 /* Ok, no property. Maybe it was an
1427 object.component dot-syntax without a declared
1428 property (this is valid for classes too). Look
1429 for getter/setter methods and internally declare
1430 an artificial property based on them if found. */
1431 x
= maybe_make_artificial_property_decl (NULL_TREE
,
1438 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1440 /* This is a special, complicated case. If the
1441 property is optional, and is read-only, then the
1442 property is always used for reading, but an
1443 eventual existing non-property setter can be used
1444 for writing. We create an artificial property
1445 decl copying the getter from the optional
1446 property, and looking up the setter in the
1448 x
= maybe_make_artificial_property_decl (NULL_TREE
,
1453 PROPERTY_GETTER_NAME (x
));
1457 else if (objc_method_context
)
1459 /* Else, if we are inside a method it could be the case of
1460 'super' or 'self'. */
1461 tree interface_type
= NULL_TREE
;
1463 while (TREE_CODE (t
) == COMPOUND_EXPR
1464 || TREE_CODE (t
) == MODIFY_EXPR
1465 || CONVERT_EXPR_P (t
)
1466 || TREE_CODE (t
) == COMPONENT_REF
)
1467 t
= TREE_OPERAND (t
, 0);
1469 if (t
== UOBJC_SUPER_decl
)
1470 interface_type
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
1471 else if (t
== self_decl
)
1472 interface_type
= lookup_interface (CLASS_NAME (implementation_template
));
1476 if (TREE_CODE (objc_method_context
) != CLASS_METHOD_DECL
)
1477 x
= lookup_property (interface_type
, property_ident
);
1481 /* Try the dot-syntax without a declared property.
1482 If this is an access to 'self', it is possible
1483 that they may refer to a setter/getter that is
1484 not declared in the interface, but exists locally
1485 in the implementation. In that case, get the
1486 implementation context and use it. */
1487 tree implementation
= NULL_TREE
;
1490 implementation
= objc_implementation_context
;
1492 x
= maybe_make_artificial_property_decl
1493 (interface_type
, implementation
, NULL_TREE
,
1495 (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
),
1498 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1500 tree implementation
= NULL_TREE
;
1503 implementation
= objc_implementation_context
;
1505 x
= maybe_make_artificial_property_decl (interface_type
,
1510 PROPERTY_GETTER_NAME (x
));
1517 /* This is the case where we have more information on 'rtype'. */
1518 tree basetype
= TYPE_MAIN_VARIANT (rtype
);
1520 /* Skip the pointer - if none, it's not an Objective-C object or
1522 if (basetype
!= NULL_TREE
&& TREE_CODE (basetype
) == POINTER_TYPE
)
1523 basetype
= TREE_TYPE (basetype
);
1527 /* Traverse typedefs. */
1528 while (basetype
!= NULL_TREE
1529 && TREE_CODE (basetype
) == RECORD_TYPE
1530 && OBJC_TYPE_NAME (basetype
)
1531 && TREE_CODE (OBJC_TYPE_NAME (basetype
)) == TYPE_DECL
1532 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype
)))
1533 basetype
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype
));
1535 if (basetype
!= NULL_TREE
&& TYPED_OBJECT (basetype
))
1537 tree interface_type
= TYPE_OBJC_INTERFACE (basetype
);
1538 tree protocol_list
= TYPE_OBJC_PROTOCOL_LIST (basetype
);
1541 && (TREE_CODE (interface_type
) == CLASS_INTERFACE_TYPE
1542 || TREE_CODE (interface_type
) == CATEGORY_INTERFACE_TYPE
1543 || TREE_CODE (interface_type
) == PROTOCOL_INTERFACE_TYPE
))
1545 /* Not sure 'rtype' could ever be a class here! Just
1546 for safety we keep the checks. */
1547 if (!IS_CLASS (rtype
))
1549 x
= lookup_property (interface_type
, property_ident
);
1552 x
= lookup_property_in_protocol_list (protocol_list
,
1558 /* Try the dot-syntax without a declared property.
1559 If we are inside a method implementation, it is
1560 possible that they may refer to a setter/getter
1561 that is not declared in the interface, but exists
1562 locally in the implementation. In that case, get
1563 the implementation context and use it. */
1564 tree implementation
= NULL_TREE
;
1566 if (objc_implementation_context
1567 && CLASS_NAME (objc_implementation_context
)
1568 == OBJC_TYPE_NAME (interface_type
))
1569 implementation
= objc_implementation_context
;
1571 x
= maybe_make_artificial_property_decl (interface_type
,
1578 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1580 tree implementation
= NULL_TREE
;
1582 if (objc_implementation_context
1583 && CLASS_NAME (objc_implementation_context
)
1584 == OBJC_TYPE_NAME (interface_type
))
1585 implementation
= objc_implementation_context
;
1587 x
= maybe_make_artificial_property_decl (interface_type
,
1592 PROPERTY_GETTER_NAME (x
));
1602 tree deprecated_method_prototype
= NULL_TREE
;
1604 /* We have an additional nasty problem here; if this
1605 PROPERTY_REF needs to become a 'getter', then the conversion
1606 from PROPERTY_REF into a getter call happens in gimplify,
1607 after the selector table has already been generated and when
1608 it is too late to add another selector to it. To work around
1609 the problem, we always create the getter call at this stage,
1610 which puts the selector in the table. Note that if the
1611 PROPERTY_REF becomes a 'setter' instead of a 'getter', then
1612 we have added a selector too many to the selector table.
1613 This is a little inefficient.
1615 Also note that method calls to 'self' and 'super' require the
1616 context (self_decl, UOBJS_SUPER_decl,
1617 objc_implementation_context etc) to be built correctly; this
1618 is yet another reason why building the call at the gimplify
1619 stage (when this context has been lost) is not very
1620 practical. If we build it at this stage, we know it will
1621 always be built correctly.
1623 If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial
1624 property decl created to deal with a dotsyntax not really
1625 referring to an existing property) then do not try to build a
1626 call to the getter as there is no getter. */
1627 if (PROPERTY_HAS_NO_GETTER (x
))
1628 getter_call
= NULL_TREE
;
1630 getter_call
= objc_finish_message_expr
1631 (object
, PROPERTY_GETTER_NAME (x
), NULL_TREE
,
1632 /* Disable the immediate deprecation warning if the getter
1633 is deprecated, but record the fact that the getter is
1634 deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to
1635 the method prototype. */
1636 &deprecated_method_prototype
);
1638 expression
= build4 (PROPERTY_REF
, TREE_TYPE(x
), object
, x
, getter_call
,
1639 deprecated_method_prototype
);
1640 SET_EXPR_LOCATION (expression
, input_location
);
1641 TREE_SIDE_EFFECTS (expression
) = 1;
1649 /* This hook routine is invoked by the parser when an expression such
1650 as 'xxx.yyy' is parsed, and 'xxx' is a class name. This is the
1651 Objective-C 2.0 dot-syntax applied to classes, so we need to
1652 convert it into a setter/getter call on the class. */
1654 objc_build_class_component_ref (tree class_name
, tree property_ident
)
1659 if (flag_objc1_only
)
1660 error_at (input_location
, "the dot syntax is not available in Objective-C 1.0");
1662 if (class_name
== NULL_TREE
|| class_name
== error_mark_node
1663 || TREE_CODE (class_name
) != IDENTIFIER_NODE
)
1664 return error_mark_node
;
1666 if (property_ident
== NULL_TREE
|| property_ident
== error_mark_node
1667 || TREE_CODE (property_ident
) != IDENTIFIER_NODE
)
1670 object
= objc_get_class_reference (class_name
);
1673 /* We know that 'class_name' is an Objective-C class name as the
1674 parser won't call this function if it is not. This is only a
1675 double-check for safety. */
1676 error_at (input_location
, "could not find class %qE", class_name
);
1677 return error_mark_node
;
1680 rtype
= lookup_interface (class_name
);
1683 /* Again, this should never happen, but we do check. */
1684 error_at (input_location
, "could not find interface for class %qE", class_name
);
1685 return error_mark_node
;
1689 if (TREE_DEPRECATED (rtype
))
1690 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated", class_name
);
1693 x
= maybe_make_artificial_property_decl (rtype
, NULL_TREE
, NULL_TREE
,
1701 tree deprecated_method_prototype
= NULL_TREE
;
1703 if (PROPERTY_HAS_NO_GETTER (x
))
1704 getter_call
= NULL_TREE
;
1706 getter_call
= objc_finish_message_expr
1707 (object
, PROPERTY_GETTER_NAME (x
), NULL_TREE
,
1708 &deprecated_method_prototype
);
1710 expression
= build4 (PROPERTY_REF
, TREE_TYPE(x
), object
, x
, getter_call
,
1711 deprecated_method_prototype
);
1712 SET_EXPR_LOCATION (expression
, input_location
);
1713 TREE_SIDE_EFFECTS (expression
) = 1;
1719 error_at (input_location
, "could not find setter/getter for %qE in class %qE",
1720 property_ident
, class_name
);
1721 return error_mark_node
;
1729 /* This is used because we don't want to expose PROPERTY_REF to the
1730 C/C++ frontends. Maybe we should! */
1732 objc_is_property_ref (tree node
)
1734 if (node
&& TREE_CODE (node
) == PROPERTY_REF
)
1740 /* This function builds a setter call for a PROPERTY_REF (real, for a
1741 declared property, or artificial, for a dot-syntax accessor which
1742 is not corresponding to a property). 'lhs' must be a PROPERTY_REF
1743 (the caller must check this beforehand). 'rhs' is the value to
1744 assign to the property. A plain setter call is returned, or
1745 error_mark_node if the property is readonly. */
1748 objc_build_setter_call (tree lhs
, tree rhs
)
1750 tree object_expr
= PROPERTY_REF_OBJECT (lhs
);
1751 tree property_decl
= PROPERTY_REF_PROPERTY_DECL (lhs
);
1753 if (PROPERTY_READONLY (property_decl
))
1755 error ("readonly property can not be set");
1756 return error_mark_node
;
1760 tree setter_argument
= build_tree_list (NULL_TREE
, rhs
);
1763 /* TODO: Check that the setter return type is 'void'. */
1765 /* TODO: Decay arguments in C. */
1766 setter
= objc_finish_message_expr (object_expr
,
1767 PROPERTY_SETTER_NAME (property_decl
),
1768 setter_argument
, NULL
);
1772 /* Unreachable, but the compiler may not realize. */
1773 return error_mark_node
;
1776 /* This hook routine is called when a MODIFY_EXPR is being built. We
1777 check what is being modified; if it is a PROPERTY_REF, we need to
1778 generate a 'setter' function call for the property. If this is not
1779 a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go
1780 on creating their MODIFY_EXPR.
1782 This is used for example if you write
1786 where 'count' is a property. The left-hand side creates a
1787 PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR
1788 to assign something to it. We intercept that here, and generate a
1789 call to the 'setter' method instead. */
1791 objc_maybe_build_modify_expr (tree lhs
, tree rhs
)
1793 if (lhs
&& TREE_CODE (lhs
) == PROPERTY_REF
)
1795 /* Building a simple call to the setter method would work for cases such as
1799 but wouldn't work for cases such as
1801 count = object2.count = 1;
1803 to get these to work with very little effort, we build a
1804 compound statement which does the setter call (to set the
1805 property to 'rhs'), but which can also be evaluated returning
1806 the 'rhs'. If the 'rhs' has no side effects, we can simply
1807 evaluate it twice, building
1809 ([object setProperty: rhs]; rhs)
1811 If it has side effects, we put it in a temporary variable first,
1812 so we create the following:
1814 (temp = rhs; [object setProperty: temp]; temp)
1816 setter_argument is rhs in the first case, and temp in the second
1819 tree setter_argument
;
1821 /* s1, s2 and s3 are the tree statements that we need in the
1822 compound expression. */
1823 tree s1
, s2
, s3
, compound_expr
;
1825 if (TREE_SIDE_EFFECTS (rhs
))
1829 /* Declare __objc_property_temp in a local bind. */
1830 setter_argument
= objc_create_temporary_var (TREE_TYPE (rhs
), "__objc_property_temp");
1831 DECL_SOURCE_LOCATION (setter_argument
) = input_location
;
1832 bind
= build3 (BIND_EXPR
, void_type_node
, setter_argument
, NULL
, NULL
);
1833 SET_EXPR_LOCATION (bind
, input_location
);
1834 TREE_SIDE_EFFECTS (bind
) = 1;
1838 s1
= build_modify_expr (input_location
, setter_argument
, NULL_TREE
,
1840 input_location
, rhs
, NULL_TREE
);
1841 SET_EXPR_LOCATION (s1
, input_location
);
1846 setter_argument
= rhs
;
1850 /* Now build the compound statement. */
1852 /* s2: [object setProperty: x] */
1853 s2
= objc_build_setter_call (lhs
, setter_argument
);
1855 /* This happens if building the setter failed because the
1856 property is readonly. */
1857 if (s2
== error_mark_node
)
1858 return error_mark_node
;
1860 SET_EXPR_LOCATION (s2
, input_location
);
1863 s3
= convert (TREE_TYPE (lhs
), setter_argument
);
1865 /* Now build the compound statement (s1, s2, s3) or (s2, s3) as
1868 compound_expr
= build_compound_expr (input_location
, build_compound_expr (input_location
, s1
, s2
), s3
);
1870 compound_expr
= build_compound_expr (input_location
, s2
, s3
);
1872 /* Without this, with -Wall you get a 'valued computed is not
1873 used' every time there is a "object.property = x" where the
1874 value of the resulting MODIFY_EXPR is not used. That is
1875 correct (maybe a more sophisticated implementation could
1876 avoid generating the compound expression if not needed), but
1877 we need to turn it off. */
1878 TREE_NO_WARNING (compound_expr
) = 1;
1879 return compound_expr
;
1885 /* This hook is called by the frontend when one of the four unary
1886 expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR,
1887 PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an
1888 argument which is a PROPERTY_REF. For example, this happens if you have
1892 where 'count' is a property. We need to use the 'getter' and
1893 'setter' for the property in an appropriate way to build the
1894 appropriate expression. 'code' is the code for the expression (one
1895 of the four mentioned above); 'argument' is the PROPERTY_REF, and
1896 'increment' is how much we need to add or subtract. */
1898 objc_build_incr_expr_for_property_ref (location_t location
,
1899 enum tree_code code
,
1900 tree argument
, tree increment
)
1902 /* Here are the expressions that we want to build:
1904 For PREINCREMENT_EXPR / PREDECREMENT_EXPR:
1905 (temp = [object property] +/- increment, [object setProperty: temp], temp)
1907 For POSTINCREMENT_EXPR / POSTECREMENT_EXPR:
1908 (temp = [object property], [object setProperty: temp +/- increment], temp) */
1910 tree temp_variable_decl
, bind
;
1911 /* s1, s2 and s3 are the tree statements that we need in the
1912 compound expression. */
1913 tree s1
, s2
, s3
, compound_expr
;
1916 if (!argument
|| TREE_CODE (argument
) != PROPERTY_REF
)
1917 return error_mark_node
;
1919 /* Declare __objc_property_temp in a local bind. */
1920 temp_variable_decl
= objc_create_temporary_var (TREE_TYPE (argument
), "__objc_property_temp");
1921 DECL_SOURCE_LOCATION (temp_variable_decl
) = location
;
1922 bind
= build3 (BIND_EXPR
, void_type_node
, temp_variable_decl
, NULL
, NULL
);
1923 SET_EXPR_LOCATION (bind
, location
);
1924 TREE_SIDE_EFFECTS (bind
) = 1;
1927 /* Now build the compound statement. */
1929 /* Note that the 'getter' is generated at gimplify time; at this
1930 time, we can simply put the property_ref (ie, argument) wherever
1931 we want the getter ultimately to be. */
1933 /* s1: __objc_property_temp = [object property] <+/- increment> */
1936 case PREINCREMENT_EXPR
:
1937 /* __objc_property_temp = [object property] + increment */
1938 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1940 location
, build2 (PLUS_EXPR
, TREE_TYPE (argument
),
1941 argument
, increment
), NULL_TREE
);
1943 case PREDECREMENT_EXPR
:
1944 /* __objc_property_temp = [object property] - increment */
1945 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1947 location
, build2 (MINUS_EXPR
, TREE_TYPE (argument
),
1948 argument
, increment
), NULL_TREE
);
1950 case POSTINCREMENT_EXPR
:
1951 case POSTDECREMENT_EXPR
:
1952 /* __objc_property_temp = [object property] */
1953 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1955 location
, argument
, NULL_TREE
);
1961 /* s2: [object setProperty: __objc_property_temp <+/- increment>] */
1964 case PREINCREMENT_EXPR
:
1965 case PREDECREMENT_EXPR
:
1966 /* [object setProperty: __objc_property_temp] */
1967 s2
= objc_build_setter_call (argument
, temp_variable_decl
);
1969 case POSTINCREMENT_EXPR
:
1970 /* [object setProperty: __objc_property_temp + increment] */
1971 s2
= objc_build_setter_call (argument
,
1972 build2 (PLUS_EXPR
, TREE_TYPE (argument
),
1973 temp_variable_decl
, increment
));
1975 case POSTDECREMENT_EXPR
:
1976 /* [object setProperty: __objc_property_temp - increment] */
1977 s2
= objc_build_setter_call (argument
,
1978 build2 (MINUS_EXPR
, TREE_TYPE (argument
),
1979 temp_variable_decl
, increment
));
1985 /* This happens if building the setter failed because the property
1987 if (s2
== error_mark_node
)
1988 return error_mark_node
;
1990 SET_EXPR_LOCATION (s2
, location
);
1992 /* s3: __objc_property_temp */
1993 s3
= convert (TREE_TYPE (argument
), temp_variable_decl
);
1995 /* Now build the compound statement (s1, s2, s3) */
1996 compound_expr
= build_compound_expr (location
, build_compound_expr (location
, s1
, s2
), s3
);
1998 /* Prevent C++ from warning with -Wall that "right operand of comma
1999 operator has no effect". */
2000 TREE_NO_WARNING (compound_expr
) = 1;
2001 return compound_expr
;
2005 objc_build_method_signature (bool is_class_method
, tree rettype
, tree selector
,
2006 tree optparms
, bool ellipsis
)
2008 if (is_class_method
)
2009 return build_method_decl (CLASS_METHOD_DECL
, rettype
, selector
,
2010 optparms
, ellipsis
);
2012 return build_method_decl (INSTANCE_METHOD_DECL
, rettype
, selector
,
2013 optparms
, ellipsis
);
2017 objc_add_method_declaration (bool is_class_method
, tree decl
, tree attributes
)
2019 if (!objc_interface_context
)
2021 /* PS: At the moment, due to how the parser works, it should be
2022 impossible to get here. But it's good to have the check in
2023 case the parser changes.
2025 fatal_error (input_location
,
2026 "method declaration not in @interface context");
2029 if (flag_objc1_only
&& attributes
)
2030 error_at (input_location
, "method attributes are not available in Objective-C 1.0");
2032 objc_decl_method_attributes (&decl
, attributes
, 0);
2033 objc_add_method (objc_interface_context
,
2036 objc_method_optional_flag
);
2039 /* Return 'true' if the method definition could be started, and
2040 'false' if not (because we are outside an @implementation context).
2041 EXPR is NULL or an expression that needs to be evaluated for the
2042 side effects of array size expressions in the parameters.
2045 objc_start_method_definition (bool is_class_method
, tree decl
, tree attributes
,
2048 if (!objc_implementation_context
)
2050 error ("method definition not in @implementation context");
2054 if (decl
!= NULL_TREE
&& METHOD_SEL_NAME (decl
) == error_mark_node
)
2058 /* Indicate no valid break/continue context by setting these variables
2059 to some non-null, non-label value. We'll notice and emit the proper
2060 error message in c_finish_bc_stmt. */
2061 c_break_label
= c_cont_label
= size_zero_node
;
2065 warning_at (input_location
, 0, "method attributes can not be specified in @implementation context");
2067 objc_decl_method_attributes (&decl
, attributes
, 0);
2069 objc_add_method (objc_implementation_context
,
2072 /* is optional */ false);
2073 start_method_def (decl
, expr
);
2078 objc_add_instance_variable (tree decl
)
2080 (void) add_instance_variable (objc_ivar_context
,
2081 objc_ivar_visibility
,
2085 /* Construct a C struct with same name as KLASS, a base struct with tag
2086 SUPER_NAME (if any), and FIELDS indicated. */
2089 objc_build_struct (tree klass
, tree fields
, tree super_name
)
2091 tree name
= CLASS_NAME (klass
);
2092 tree s
= objc_start_struct (name
);
2093 tree super
= (super_name
? xref_tag (RECORD_TYPE
, super_name
) : NULL_TREE
);
2095 vec
<tree
> objc_info
= vNULL
;
2100 /* Prepend a packed variant of the base class into the layout. This
2101 is necessary to preserve ObjC ABI compatibility. */
2102 tree base
= build_decl (input_location
,
2103 FIELD_DECL
, NULL_TREE
, super
);
2104 tree field
= TYPE_FIELDS (super
);
2106 while (field
&& DECL_CHAIN (field
)
2107 && TREE_CODE (DECL_CHAIN (field
)) == FIELD_DECL
)
2108 field
= DECL_CHAIN (field
);
2110 /* For ObjC ABI purposes, the "packed" size of a base class is
2111 the sum of the offset and the size (in bits) of the last field
2114 = (field
&& TREE_CODE (field
) == FIELD_DECL
2115 ? size_binop (PLUS_EXPR
,
2116 size_binop (PLUS_EXPR
,
2119 convert (bitsizetype
,
2120 DECL_FIELD_OFFSET (field
)),
2121 bitsize_int (BITS_PER_UNIT
)),
2122 DECL_FIELD_BIT_OFFSET (field
)),
2124 : bitsize_zero_node
);
2125 DECL_SIZE_UNIT (base
)
2126 = size_binop (FLOOR_DIV_EXPR
, convert (sizetype
, DECL_SIZE (base
)),
2127 size_int (BITS_PER_UNIT
));
2128 DECL_ARTIFICIAL (base
) = 1;
2129 DECL_ALIGN (base
) = 1;
2130 DECL_FIELD_CONTEXT (base
) = s
;
2132 DECL_FIELD_IS_BASE (base
) = 1;
2135 TREE_NO_WARNING (fields
) = 1; /* Suppress C++ ABI warnings -- we */
2136 #endif /* are following the ObjC ABI here. */
2137 DECL_CHAIN (base
) = fields
;
2141 /* NB: Calling finish_struct() may cause type TYPE_OBJC_INFO
2142 information in all variants of this RECORD_TYPE to be destroyed
2143 (this is because the C frontend manipulates TYPE_LANG_SPECIFIC
2144 for something else and then will change all variants to use the
2145 same resulting TYPE_LANG_SPECIFIC, ignoring the fact that we use
2146 it for ObjC protocols and that such propagation will make all
2147 variants use the same objc_info), but it is therein that we store
2148 protocol conformance info (e.g., 'NSObject <MyProtocol>').
2149 Hence, we must save the ObjC-specific information before calling
2150 finish_struct(), and then reinstate it afterwards. */
2152 for (t
= TYPE_MAIN_VARIANT (s
); t
; t
= TYPE_NEXT_VARIANT (t
))
2154 INIT_TYPE_OBJC_INFO (t
);
2155 objc_info
.safe_push (TYPE_OBJC_INFO (t
));
2158 s
= objc_finish_struct (s
, fields
);
2160 for (i
= 0, t
= TYPE_MAIN_VARIANT (s
); t
; t
= TYPE_NEXT_VARIANT (t
), i
++)
2162 /* We now want to restore the different TYPE_OBJC_INFO, but we
2163 have the additional problem that the C frontend doesn't just
2164 copy TYPE_LANG_SPECIFIC from one variant to the other; it
2165 actually makes all of them the *same* TYPE_LANG_SPECIFIC. As
2166 we need a different TYPE_OBJC_INFO for each (and
2167 TYPE_OBJC_INFO is a field in TYPE_LANG_SPECIFIC), we need to
2168 make a copy of each TYPE_LANG_SPECIFIC before we modify
2170 if (TYPE_LANG_SPECIFIC (t
))
2172 /* Create a copy of TYPE_LANG_SPECIFIC. */
2173 struct lang_type
*old_lang_type
= TYPE_LANG_SPECIFIC (t
);
2174 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t
);
2175 memcpy (TYPE_LANG_SPECIFIC (t
), old_lang_type
,
2176 SIZEOF_OBJC_TYPE_LANG_SPECIFIC
);
2180 /* Just create a new one. */
2181 ALLOC_OBJC_TYPE_LANG_SPECIFIC (t
);
2183 /* Replace TYPE_OBJC_INFO with the saved one. This restores any
2184 protocol information that may have been associated with the
2186 TYPE_OBJC_INFO (t
) = objc_info
[i
];
2187 /* Replace the IDENTIFIER_NODE with an actual @interface now
2189 TYPE_OBJC_INTERFACE (t
) = klass
;
2191 objc_info
.release ();
2193 /* Use TYPE_BINFO structures to point at the super class, if any. */
2194 objc_xref_basetypes (s
, super
);
2196 /* Mark this struct as a class template. */
2197 CLASS_STATIC_TEMPLATE (klass
) = s
;
2202 /* Mark DECL as being 'volatile' for purposes of Darwin
2203 _setjmp()/_longjmp() exception handling. Called from
2204 objc_mark_locals_volatile(). */
2206 objc_volatilize_decl (tree decl
)
2208 /* Do not mess with variables that are 'static' or (already)
2210 if (!TREE_THIS_VOLATILE (decl
) && !TREE_STATIC (decl
)
2211 && (TREE_CODE (decl
) == VAR_DECL
2212 || TREE_CODE (decl
) == PARM_DECL
))
2214 if (local_variables_to_volatilize
== NULL
)
2215 vec_alloc (local_variables_to_volatilize
, 8);
2217 vec_safe_push (local_variables_to_volatilize
, decl
);
2221 /* Called when parsing of a function completes; if any local variables
2222 in the function were marked as variables to volatilize, change them
2223 to volatile. We do this at the end of the function when the
2224 warnings about discarding 'volatile' have already been produced.
2225 We are making the variables as volatile just to force the compiler
2226 to preserve them between setjmp/longjmp, but we don't want warnings
2227 for them as they aren't really volatile. */
2229 objc_finish_function (void)
2231 /* If there are any local variables to volatilize, volatilize them. */
2232 if (local_variables_to_volatilize
)
2236 FOR_EACH_VEC_ELT (*local_variables_to_volatilize
, i
, decl
)
2238 tree t
= TREE_TYPE (decl
);
2240 t
= build_qualified_type (t
, TYPE_QUALS (t
) | TYPE_QUAL_VOLATILE
);
2241 TREE_TYPE (decl
) = t
;
2242 TREE_THIS_VOLATILE (decl
) = 1;
2243 TREE_SIDE_EFFECTS (decl
) = 1;
2244 DECL_REGISTER (decl
) = 0;
2246 C_DECL_REGISTER (decl
) = 0;
2250 /* Now we delete the vector. This sets it to NULL as well. */
2251 vec_free (local_variables_to_volatilize
);
2255 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
2256 (including its categories and superclasses) or by object type TYP.
2257 Issue a warning if PROTO is not adopted anywhere and WARN is set. */
2260 objc_lookup_protocol (tree proto
, tree cls
, tree typ
, bool warn
)
2262 bool class_type
= (cls
!= NULL_TREE
);
2268 /* Check protocols adopted by the class and its categories. */
2269 for (c
= cls
; c
; c
= CLASS_CATEGORY_LIST (c
))
2271 if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c
), proto
))
2275 /* Repeat for superclasses. */
2276 cls
= lookup_interface (CLASS_SUPER_NAME (cls
));
2279 /* Check for any protocols attached directly to the object type. */
2280 if (TYPE_HAS_OBJC_INFO (typ
))
2282 if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ
), proto
))
2289 gen_type_name_0 (class_type
? typ
: TYPE_POINTER_TO (typ
));
2290 /* NB: Types 'id' and 'Class' cannot reasonably be described as
2291 "implementing" a given protocol, since they do not have an
2294 warning (0, "class %qs does not implement the %qE protocol",
2295 identifier_to_locale (errbuf
), PROTOCOL_NAME (proto
));
2297 warning (0, "type %qs does not conform to the %qE protocol",
2298 identifier_to_locale (errbuf
), PROTOCOL_NAME (proto
));
2304 /* Check if class RCLS and instance struct type RTYP conform to at least the
2305 same protocols that LCLS and LTYP conform to. */
2308 objc_compare_protocols (tree lcls
, tree ltyp
, tree rcls
, tree rtyp
, bool warn
)
2311 bool have_lproto
= false;
2315 /* NB: We do _not_ look at categories defined for LCLS; these may or
2316 may not get loaded in, and therefore it is unreasonable to require
2317 that RCLS/RTYP must implement any of their protocols. */
2318 for (p
= CLASS_PROTOCOL_LIST (lcls
); p
; p
= TREE_CHAIN (p
))
2322 if (!objc_lookup_protocol (TREE_VALUE (p
), rcls
, rtyp
, warn
))
2326 /* Repeat for superclasses. */
2327 lcls
= lookup_interface (CLASS_SUPER_NAME (lcls
));
2330 /* Check for any protocols attached directly to the object type. */
2331 if (TYPE_HAS_OBJC_INFO (ltyp
))
2333 for (p
= TYPE_OBJC_PROTOCOL_LIST (ltyp
); p
; p
= TREE_CHAIN (p
))
2337 if (!objc_lookup_protocol (TREE_VALUE (p
), rcls
, rtyp
, warn
))
2342 /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
2343 vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get
2344 away with simply checking for 'id' or 'Class' (!RCLS), since this
2345 routine will not get called in other cases. */
2346 return have_lproto
|| (rcls
!= NULL_TREE
);
2349 /* Given two types TYPE1 and TYPE2, return their least common ancestor.
2350 Both TYPE1 and TYPE2 must be pointers, and already determined to be
2351 compatible by objc_compare_types() below. */
2354 objc_common_type (tree type1
, tree type2
)
2356 tree inner1
= TREE_TYPE (type1
), inner2
= TREE_TYPE (type2
);
2358 while (POINTER_TYPE_P (inner1
))
2360 inner1
= TREE_TYPE (inner1
);
2361 inner2
= TREE_TYPE (inner2
);
2364 /* If one type is derived from another, return the base type. */
2365 if (DERIVED_FROM_P (inner1
, inner2
))
2367 else if (DERIVED_FROM_P (inner2
, inner1
))
2370 /* If both types are 'Class', return 'Class'. */
2371 if (objc_is_class_id (inner1
) && objc_is_class_id (inner2
))
2372 return objc_class_type
;
2374 /* Otherwise, return 'id'. */
2375 return objc_object_type
;
2378 /* Determine if it is permissible to assign (if ARGNO is greater than -3)
2379 an instance of RTYP to an instance of LTYP or to compare the two
2380 (if ARGNO is equal to -3), per ObjC type system rules. Before
2381 returning 'true', this routine may issue warnings related to, e.g.,
2382 protocol conformance. When returning 'false', the routine must
2383 produce absolutely no warnings; the C or C++ front-end will do so
2384 instead, if needed. If either LTYP or RTYP is not an Objective-C
2385 type, the routine must return 'false'.
2387 The ARGNO parameter is encoded as follows:
2388 >= 1 Parameter number (CALLEE contains function being called);
2392 -3 Comparison (LTYP and RTYP may match in either direction);
2393 -4 Silent comparison (for C++ overload resolution);
2394 -5 Silent "specialization" comparison for RTYP to be a "specialization"
2395 of LTYP (a specialization means that RTYP is LTYP plus some constraints,
2396 so that each object of type RTYP is also of type LTYP). This is used
2397 when comparing property types. */
2400 objc_compare_types (tree ltyp
, tree rtyp
, int argno
, tree callee
)
2402 tree lcls
, rcls
, lproto
, rproto
;
2403 bool pointers_compatible
;
2405 /* We must be dealing with pointer types */
2406 if (!POINTER_TYPE_P (ltyp
) || !POINTER_TYPE_P (rtyp
))
2411 ltyp
= TREE_TYPE (ltyp
); /* Remove indirections. */
2412 rtyp
= TREE_TYPE (rtyp
);
2414 while (POINTER_TYPE_P (ltyp
) && POINTER_TYPE_P (rtyp
));
2416 /* We must also handle function pointers, since ObjC is a bit more
2417 lenient than C or C++ on this. */
2418 if (TREE_CODE (ltyp
) == FUNCTION_TYPE
&& TREE_CODE (rtyp
) == FUNCTION_TYPE
)
2420 function_args_iterator liter
, riter
;
2422 /* Return types must be covariant. */
2423 if (!comptypes (TREE_TYPE (ltyp
), TREE_TYPE (rtyp
))
2424 && !objc_compare_types (TREE_TYPE (ltyp
), TREE_TYPE (rtyp
),
2428 /* Argument types must be contravariant. */
2429 function_args_iter_init (&liter
, ltyp
);
2430 function_args_iter_init (&riter
, rtyp
);
2434 ltyp
= function_args_iter_cond (&liter
);
2435 rtyp
= function_args_iter_cond (&riter
);
2437 /* If we've exhaused both lists simulateously, we're done. */
2438 if (ltyp
== NULL_TREE
&& rtyp
== NULL_TREE
)
2441 /* If one list is shorter than the other, they fail to match. */
2442 if (ltyp
== NULL_TREE
|| rtyp
== NULL_TREE
)
2445 if (!comptypes (rtyp
, ltyp
)
2446 && !objc_compare_types (rtyp
, ltyp
, argno
, callee
))
2449 function_args_iter_next (&liter
);
2450 function_args_iter_next (&riter
);
2456 /* Past this point, we are only interested in ObjC class instances,
2457 or 'id' or 'Class'. */
2458 if (TREE_CODE (ltyp
) != RECORD_TYPE
|| TREE_CODE (rtyp
) != RECORD_TYPE
)
2461 if (!objc_is_object_id (ltyp
) && !objc_is_class_id (ltyp
)
2462 && !TYPE_HAS_OBJC_INFO (ltyp
))
2465 if (!objc_is_object_id (rtyp
) && !objc_is_class_id (rtyp
)
2466 && !TYPE_HAS_OBJC_INFO (rtyp
))
2469 /* Past this point, we are committed to returning 'true' to the caller
2470 (unless performing a silent comparison; see below). However, we can
2471 still warn about type and/or protocol mismatches. */
2473 if (TYPE_HAS_OBJC_INFO (ltyp
))
2475 lcls
= TYPE_OBJC_INTERFACE (ltyp
);
2476 lproto
= TYPE_OBJC_PROTOCOL_LIST (ltyp
);
2479 lcls
= lproto
= NULL_TREE
;
2481 if (TYPE_HAS_OBJC_INFO (rtyp
))
2483 rcls
= TYPE_OBJC_INTERFACE (rtyp
);
2484 rproto
= TYPE_OBJC_PROTOCOL_LIST (rtyp
);
2487 rcls
= rproto
= NULL_TREE
;
2489 /* If we could not find an @interface declaration, we must have
2490 only seen a @class declaration; for purposes of type comparison,
2491 treat it as a stand-alone (root) class. */
2493 if (lcls
&& TREE_CODE (lcls
) == IDENTIFIER_NODE
)
2496 if (rcls
&& TREE_CODE (rcls
) == IDENTIFIER_NODE
)
2499 /* If either type is an unqualified 'id', we're done. This is because
2500 an 'id' can be assigned to or from any type with no warnings. */
2503 if ((!lproto
&& objc_is_object_id (ltyp
))
2504 || (!rproto
&& objc_is_object_id (rtyp
)))
2509 /* For property checks, though, an 'id' is considered the most
2510 general type of object, hence if you try to specialize an
2511 'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need
2513 if (!lproto
&& objc_is_object_id (ltyp
))
2517 pointers_compatible
= (TYPE_MAIN_VARIANT (ltyp
) == TYPE_MAIN_VARIANT (rtyp
));
2519 /* If the underlying types are the same, and at most one of them has
2520 a protocol list, we do not need to issue any diagnostics. */
2521 if (pointers_compatible
&& (!lproto
|| !rproto
))
2524 /* If exactly one of the types is 'Class', issue a diagnostic; any
2525 exceptions of this rule have already been handled. */
2526 if (objc_is_class_id (ltyp
) ^ objc_is_class_id (rtyp
))
2527 pointers_compatible
= false;
2528 /* Otherwise, check for inheritance relations. */
2531 if (!pointers_compatible
)
2533 /* Again, if any of the two is an 'id', we're satisfied,
2534 unless we're comparing properties, in which case only an
2535 'id' on the left-hand side (old property) is good
2539 = (objc_is_object_id (ltyp
) || objc_is_object_id (rtyp
));
2541 pointers_compatible
= objc_is_object_id (ltyp
);
2544 if (!pointers_compatible
)
2545 pointers_compatible
= DERIVED_FROM_P (ltyp
, rtyp
);
2547 if (!pointers_compatible
&& (argno
== -3 || argno
== -4))
2548 pointers_compatible
= DERIVED_FROM_P (rtyp
, ltyp
);
2551 /* If the pointers match modulo protocols, check for protocol conformance
2553 if (pointers_compatible
)
2555 pointers_compatible
= objc_compare_protocols (lcls
, ltyp
, rcls
, rtyp
,
2558 if (!pointers_compatible
&& argno
== -3)
2559 pointers_compatible
= objc_compare_protocols (rcls
, rtyp
, lcls
, ltyp
,
2563 if (!pointers_compatible
)
2565 /* The two pointers are not exactly compatible. Issue a warning, unless
2566 we are performing a silent comparison, in which case return 'false'
2568 /* NB: For the time being, we shall make our warnings look like their
2569 C counterparts. In the future, we may wish to make them more
2578 warning (0, "comparison of distinct Objective-C types lacks a cast");
2582 warning (0, "initialization from distinct Objective-C type");
2586 warning (0, "assignment from distinct Objective-C type");
2590 warning (0, "distinct Objective-C type in return");
2594 warning (0, "passing argument %d of %qE from distinct "
2595 "Objective-C type", argno
, callee
);
2603 /* This routine is similar to objc_compare_types except that function-pointers are
2604 excluded. This is because, caller assumes that common types are of (id, Object*)
2605 variety and calls objc_common_type to obtain a common type. There is no commonolty
2606 between two function-pointers in this regard. */
2609 objc_have_common_type (tree ltyp
, tree rtyp
, int argno
, tree callee
)
2611 if (objc_compare_types (ltyp
, rtyp
, argno
, callee
))
2613 /* exclude function-pointer types. */
2616 ltyp
= TREE_TYPE (ltyp
); /* Remove indirections. */
2617 rtyp
= TREE_TYPE (rtyp
);
2619 while (POINTER_TYPE_P (ltyp
) && POINTER_TYPE_P (rtyp
));
2620 return !(TREE_CODE (ltyp
) == FUNCTION_TYPE
&& TREE_CODE (rtyp
) == FUNCTION_TYPE
);
2626 /* Determine if CHILD is derived from PARENT. The routine assumes that
2627 both parameters are RECORD_TYPEs, and is non-reflexive. */
2630 objc_derived_from_p (tree parent
, tree child
)
2632 parent
= TYPE_MAIN_VARIANT (parent
);
2634 for (child
= TYPE_MAIN_VARIANT (child
);
2635 TYPE_BINFO (child
) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child
));)
2637 child
= TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
2638 (TYPE_BINFO (child
),
2641 if (child
== parent
)
2650 objc_build_component_ref (tree datum
, tree component
)
2652 /* If COMPONENT is NULL, the caller is referring to the anonymous
2653 base class field. */
2656 tree base
= TYPE_FIELDS (TREE_TYPE (datum
));
2658 return build3 (COMPONENT_REF
, TREE_TYPE (base
), datum
, base
, NULL_TREE
);
2661 /* The 'build_component_ref' routine has been removed from the C++
2662 front-end, but 'finish_class_member_access_expr' seems to be
2663 a worthy substitute. */
2665 return finish_class_member_access_expr (datum
, component
, false,
2666 tf_warning_or_error
);
2668 return build_component_ref (input_location
, datum
, component
);
2672 /* Recursively copy inheritance information rooted at BINFO. To do this,
2673 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */
2676 objc_copy_binfo (tree binfo
)
2678 tree btype
= BINFO_TYPE (binfo
);
2679 tree binfo2
= make_tree_binfo (BINFO_N_BASE_BINFOS (binfo
));
2683 BINFO_TYPE (binfo2
) = btype
;
2684 BINFO_OFFSET (binfo2
) = BINFO_OFFSET (binfo
);
2685 BINFO_BASE_ACCESSES (binfo2
) = BINFO_BASE_ACCESSES (binfo
);
2687 /* Recursively copy base binfos of BINFO. */
2688 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2690 tree base_binfo2
= objc_copy_binfo (base_binfo
);
2692 BINFO_INHERITANCE_CHAIN (base_binfo2
) = binfo2
;
2693 BINFO_BASE_APPEND (binfo2
, base_binfo2
);
2699 /* Record superclass information provided in BASETYPE for ObjC class REF.
2700 This is loosely based on cp/decl.c:xref_basetypes(). */
2703 objc_xref_basetypes (tree ref
, tree basetype
)
2706 tree binfo
= make_tree_binfo (basetype
? 1 : 0);
2707 TYPE_BINFO (ref
) = binfo
;
2708 BINFO_OFFSET (binfo
) = size_zero_node
;
2709 BINFO_TYPE (binfo
) = ref
;
2711 gcc_assert (TYPE_MAIN_VARIANT (ref
) == ref
);
2712 for (variant
= ref
; variant
; variant
= TYPE_NEXT_VARIANT (variant
))
2713 TYPE_BINFO (variant
) = binfo
;
2717 tree base_binfo
= objc_copy_binfo (TYPE_BINFO (basetype
));
2719 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
2720 vec_alloc (BINFO_BASE_ACCESSES (binfo
), 1);
2721 BINFO_BASE_APPEND (binfo
, base_binfo
);
2722 BINFO_BASE_ACCESS_APPEND (binfo
, access_public_node
);
2726 /* Called from finish_decl. */
2729 objc_check_decl (tree decl
)
2731 tree type
= TREE_TYPE (decl
);
2733 if (TREE_CODE (type
) != RECORD_TYPE
)
2735 if (OBJC_TYPE_NAME (type
) && (type
= objc_is_class_name (OBJC_TYPE_NAME (type
))))
2736 error ("statically allocated instance of Objective-C class %qE",
2741 objc_check_global_decl (tree decl
)
2743 tree id
= DECL_NAME (decl
);
2744 if (objc_is_class_name (id
) && global_bindings_p())
2745 error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id
));
2748 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where
2749 INTERFACE may either name an Objective-C class, or refer to the
2750 special 'id' or 'Class' types. If INTERFACE is not a valid ObjC
2751 type, just return it unchanged. This function is often called when
2752 PROTOCOLS is NULL_TREE, in which case we simply look up the
2753 appropriate INTERFACE. */
2756 objc_get_protocol_qualified_type (tree interface
, tree protocols
)
2758 /* If INTERFACE is not provided, default to 'id'. */
2759 tree type
= (interface
? objc_is_id (interface
) : objc_object_type
);
2760 bool is_ptr
= (type
!= NULL_TREE
);
2764 type
= objc_is_class_name (interface
);
2768 /* If looking at a typedef, retrieve the precise type it
2770 if (TREE_CODE (interface
) == IDENTIFIER_NODE
)
2771 interface
= identifier_global_value (interface
);
2773 type
= ((interface
&& TREE_CODE (interface
) == TYPE_DECL
2774 && DECL_ORIGINAL_TYPE (interface
))
2775 ? DECL_ORIGINAL_TYPE (interface
)
2776 : xref_tag (RECORD_TYPE
, type
));
2780 /* This case happens when we are given an 'interface' which
2781 is not a valid class name. For example if a typedef was
2782 used, and 'interface' really is the identifier of the
2783 typedef, but when you resolve it you don't get an
2784 Objective-C class, but something else, such as 'int'.
2785 This is an error; protocols make no sense unless you use
2786 them with Objective-C objects. */
2787 error_at (input_location
, "only Objective-C object types can be qualified with a protocol");
2789 /* Try to recover. Ignore the invalid class name, and treat
2790 the object as an 'id' to silence further warnings about
2792 type
= objc_object_type
;
2799 type
= build_variant_type_copy (type
);
2801 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
2805 tree orig_pointee_type
= TREE_TYPE (type
);
2806 TREE_TYPE (type
) = build_variant_type_copy (orig_pointee_type
);
2808 /* Set up the canonical type information. */
2809 TYPE_CANONICAL (type
)
2810 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type
));
2812 TYPE_POINTER_TO (TREE_TYPE (type
)) = type
;
2813 type
= TREE_TYPE (type
);
2816 /* Look up protocols and install in lang specific list. */
2817 DUP_TYPE_OBJC_INFO (type
, TYPE_MAIN_VARIANT (type
));
2818 TYPE_OBJC_PROTOCOL_LIST (type
) = lookup_and_install_protocols
2819 (protocols
, /* definition_required */ false);
2821 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
2822 return the pointer to the new pointee variant. */
2824 type
= TYPE_POINTER_TO (type
);
2826 TYPE_OBJC_INTERFACE (type
)
2827 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type
));
2833 /* Check for circular dependencies in protocols. The arguments are
2834 PROTO, the protocol to check, and LIST, a list of protocol it
2838 check_protocol_recursively (tree proto
, tree list
)
2842 for (p
= list
; p
; p
= TREE_CHAIN (p
))
2844 tree pp
= TREE_VALUE (p
);
2846 if (TREE_CODE (pp
) == IDENTIFIER_NODE
)
2847 pp
= lookup_protocol (pp
, /* warn if deprecated */ false,
2848 /* definition_required */ false);
2851 fatal_error (input_location
, "protocol %qE has circular dependency",
2852 PROTOCOL_NAME (pp
));
2854 check_protocol_recursively (proto
, PROTOCOL_LIST (pp
));
2858 /* Look up PROTOCOLS, and return a list of those that are found. If
2859 none are found, return NULL. Note that this function will emit a
2860 warning if a protocol is found and is deprecated. If
2861 'definition_required', then warn if the protocol is found but is
2862 not defined (ie, if we only saw a forward-declaration of the
2863 protocol (as in "@protocol NSObject;") not a real definition with
2864 the list of methods). */
2866 lookup_and_install_protocols (tree protocols
, bool definition_required
)
2869 tree return_value
= NULL_TREE
;
2871 if (protocols
== error_mark_node
)
2874 for (proto
= protocols
; proto
; proto
= TREE_CHAIN (proto
))
2876 tree ident
= TREE_VALUE (proto
);
2877 tree p
= lookup_protocol (ident
, /* warn_if_deprecated */ true,
2878 definition_required
);
2881 return_value
= chainon (return_value
,
2882 build_tree_list (NULL_TREE
, p
));
2883 else if (ident
!= error_mark_node
)
2884 error ("cannot find protocol declaration for %qE",
2888 return return_value
;
2892 build_common_objc_exception_stuff (void)
2894 tree noreturn_list
, nothrow_list
, temp_type
;
2896 noreturn_list
= tree_cons (get_identifier ("noreturn"), NULL
, NULL
);
2897 nothrow_list
= tree_cons (get_identifier ("nothrow"), NULL
, NULL
);
2899 /* void objc_exception_throw(id) __attribute__((noreturn)); */
2900 /* void objc_sync_enter(id); */
2901 /* void objc_sync_exit(id); */
2902 temp_type
= build_function_type_list (void_type_node
,
2905 objc_exception_throw_decl
2906 = add_builtin_function (TAG_EXCEPTIONTHROW
, temp_type
, 0, NOT_BUILT_IN
, NULL
,
2908 /* Make sure that objc_exception_throw (id) claims that it may throw an
2910 TREE_NOTHROW (objc_exception_throw_decl
) = 0;
2912 objc_sync_enter_decl
2913 = add_builtin_function (TAG_SYNCENTER
, temp_type
, 0, NOT_BUILT_IN
,
2914 NULL
, nothrow_list
);
2917 = add_builtin_function (TAG_SYNCEXIT
, temp_type
, 0, NOT_BUILT_IN
,
2918 NULL
, nothrow_list
);
2921 /* Purpose: "play" parser, creating/installing representations
2922 of the declarations that are required by Objective-C.
2926 type_spec--------->sc_spec
2927 (tree_list) (tree_list)
2930 identifier_node identifier_node */
2933 synth_module_prologue (void)
2936 enum debug_info_type save_write_symbols
= write_symbols
;
2937 const struct gcc_debug_hooks
*const save_hooks
= debug_hooks
;
2939 /* Suppress outputting debug symbols, because
2940 dbxout_init hasn't been called yet. */
2941 write_symbols
= NO_DEBUG
;
2942 debug_hooks
= &do_nothing_debug_hooks
;
2945 push_lang_context (lang_name_c
); /* extern "C" */
2948 /* The following are also defined in <objc/objc.h> and friends. */
2950 objc_object_id
= get_identifier (TAG_OBJECT
);
2951 objc_class_id
= get_identifier (TAG_CLASS
);
2953 objc_object_reference
= xref_tag (RECORD_TYPE
, objc_object_id
);
2954 objc_class_reference
= xref_tag (RECORD_TYPE
, objc_class_id
);
2956 objc_object_type
= build_pointer_type (objc_object_reference
);
2957 objc_class_type
= build_pointer_type (objc_class_reference
);
2959 objc_object_name
= get_identifier (OBJECT_TYPEDEF_NAME
);
2960 objc_class_name
= get_identifier (CLASS_TYPEDEF_NAME
);
2962 /* Declare the 'id' and 'Class' typedefs. */
2963 type
= lang_hooks
.decls
.pushdecl (build_decl (input_location
,
2967 TREE_NO_WARNING (type
) = 1;
2969 type
= lang_hooks
.decls
.pushdecl (build_decl (input_location
,
2973 TREE_NO_WARNING (type
) = 1;
2975 /* Forward-declare '@interface Protocol'. */
2976 type
= get_identifier (PROTOCOL_OBJECT_CLASS_NAME
);
2977 objc_declare_class (type
);
2978 objc_protocol_type
= build_pointer_type (xref_tag (RECORD_TYPE
, type
));
2980 /* Declare receiver type used for dispatching messages to 'super'. */
2981 /* `struct objc_super *' */
2982 objc_super_type
= build_pointer_type (xref_tag (RECORD_TYPE
,
2983 get_identifier (TAG_SUPER
)));
2985 /* Declare pointers to method and ivar lists. */
2986 objc_method_list_ptr
= build_pointer_type
2987 (xref_tag (RECORD_TYPE
,
2988 get_identifier (UTAG_METHOD_LIST
)));
2989 objc_method_proto_list_ptr
2990 = build_pointer_type (xref_tag (RECORD_TYPE
,
2991 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
)));
2992 objc_ivar_list_ptr
= build_pointer_type
2993 (xref_tag (RECORD_TYPE
,
2994 get_identifier (UTAG_IVAR_LIST
)));
2996 build_common_objc_exception_stuff ();
2998 /* Set-up runtime-specific templates, message and exception stuff. */
2999 (*runtime
.initialize
) ();
3001 /* Declare objc_getProperty, object_setProperty and other property
3002 accessor helpers. */
3003 build_common_objc_property_accessor_helpers ();
3005 /* Forward declare constant_string_id and constant_string_type. */
3006 if (!constant_string_class_name
)
3007 constant_string_class_name
= runtime
.default_constant_string_class_name
;
3008 constant_string_id
= get_identifier (constant_string_class_name
);
3009 objc_declare_class (constant_string_id
);
3011 /* Pre-build the following entities - for speed/convenience. */
3012 self_id
= get_identifier ("self");
3013 ucmd_id
= get_identifier ("_cmd");
3015 /* Declare struct _objc_fast_enumeration_state { ... }; */
3016 build_fast_enumeration_state_template ();
3018 /* void objc_enumeration_mutation (id) */
3019 type
= build_function_type_list (void_type_node
,
3020 objc_object_type
, NULL_TREE
);
3021 objc_enumeration_mutation_decl
3022 = add_builtin_function (TAG_ENUMERATION_MUTATION
, type
, 0, NOT_BUILT_IN
,
3024 TREE_NOTHROW (objc_enumeration_mutation_decl
) = 0;
3027 pop_lang_context ();
3030 write_symbols
= save_write_symbols
;
3031 debug_hooks
= save_hooks
;
3034 /* --- const strings --- */
3036 /* Ensure that the ivar list for NSConstantString/NXConstantString
3037 (or whatever was specified via `-fconstant-string-class')
3038 contains fields at least as large as the following three, so that
3039 the runtime can stomp on them with confidence:
3041 struct STRING_OBJECT_CLASS_NAME
3045 unsigned int length;
3049 check_string_class_template (void)
3051 tree field_decl
= objc_get_class_ivars (constant_string_id
);
3053 #define AT_LEAST_AS_LARGE_AS(F, T) \
3054 (F && TREE_CODE (F) == FIELD_DECL \
3055 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
3056 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
3058 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
3061 field_decl
= DECL_CHAIN (field_decl
);
3062 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
3065 field_decl
= DECL_CHAIN (field_decl
);
3066 return AT_LEAST_AS_LARGE_AS (field_decl
, unsigned_type_node
);
3068 #undef AT_LEAST_AS_LARGE_AS
3071 /* Avoid calling `check_string_class_template ()' more than once. */
3072 static GTY(()) int string_layout_checked
;
3074 /* Construct an internal string layout to be used as a template for
3075 creating NSConstantString/NXConstantString instances. */
3078 objc_build_internal_const_str_type (void)
3080 tree type
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3081 tree fields
= build_decl (input_location
,
3082 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
3083 tree field
= build_decl (input_location
,
3084 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
3086 DECL_CHAIN (field
) = fields
; fields
= field
;
3087 field
= build_decl (input_location
,
3088 FIELD_DECL
, NULL_TREE
, unsigned_type_node
);
3089 DECL_CHAIN (field
) = fields
; fields
= field
;
3090 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
3092 finish_builtin_struct (type
, "__builtin_ObjCString",
3098 /* Custom build_string which sets TREE_TYPE! */
3101 my_build_string (int len
, const char *str
)
3103 return fix_string_type (build_string (len
, str
));
3106 /* Build a string with contents STR and length LEN and convert it to a
3110 my_build_string_pointer (int len
, const char *str
)
3112 tree string
= my_build_string (len
, str
);
3113 tree ptrtype
= build_pointer_type (TREE_TYPE (TREE_TYPE (string
)));
3114 return build1 (ADDR_EXPR
, ptrtype
, string
);
3118 objc_string_hasher::hash (string_descriptor
*ptr
)
3120 const_tree
const str
= ptr
->literal
;
3121 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3122 int i
, len
= TREE_STRING_LENGTH (str
);
3125 for (i
= 0; i
< len
; i
++)
3126 h
= ((h
* 613) + p
[i
]);
3132 objc_string_hasher::equal (string_descriptor
*ptr1
, string_descriptor
*ptr2
)
3134 const_tree
const str1
= ptr1
->literal
;
3135 const_tree
const str2
= ptr2
->literal
;
3136 int len1
= TREE_STRING_LENGTH (str1
);
3138 return (len1
== TREE_STRING_LENGTH (str2
)
3139 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3143 /* Given a chain of STRING_CST's, build a static instance of
3144 NXConstantString which points at the concatenation of those
3145 strings. We place the string object in the __string_objects
3146 section of the __OBJC segment. The Objective-C runtime will
3147 initialize the isa pointers of the string objects to point at the
3148 NXConstantString class object. */
3151 objc_build_string_object (tree string
)
3153 tree constant_string_class
;
3156 struct string_descriptor
*desc
, key
;
3158 /* We should be passed a STRING_CST. */
3159 gcc_checking_assert (TREE_CODE (string
) == STRING_CST
);
3160 length
= TREE_STRING_LENGTH (string
) - 1;
3162 /* The target may have different ideas on how to construct an ObjC string
3163 literal. On Darwin (Mac OS X), for example, we may wish to obtain a
3164 constant CFString reference instead.
3165 At present, this is only supported for the NeXT runtime. */
3166 if (flag_next_runtime
3167 && targetcm
.objc_construct_string_object
)
3169 tree constructor
= (*targetcm
.objc_construct_string_object
) (string
);
3171 return build1 (NOP_EXPR
, objc_object_type
, constructor
);
3174 /* Check whether the string class being used actually exists and has the
3175 correct ivar layout. */
3176 if (!string_layout_checked
)
3178 string_layout_checked
= -1;
3179 constant_string_class
= lookup_interface (constant_string_id
);
3180 internal_const_str_type
= objc_build_internal_const_str_type ();
3182 if (!constant_string_class
3183 || !(constant_string_type
3184 = CLASS_STATIC_TEMPLATE (constant_string_class
)))
3185 error ("cannot find interface declaration for %qE",
3186 constant_string_id
);
3187 /* The NSConstantString/NXConstantString ivar layout is now known. */
3188 else if (!check_string_class_template ())
3189 error ("interface %qE does not have valid constant string layout",
3190 constant_string_id
);
3191 /* If the runtime can generate a literal reference to the string class,
3192 don't need to run a constructor. */
3193 else if (!(*runtime
.setup_const_string_class_decl
)())
3194 error ("cannot find reference tag for class %qE", constant_string_id
);
3197 string_layout_checked
= 1; /* Success! */
3198 add_class_reference (constant_string_id
);
3202 if (string_layout_checked
== -1)
3203 return error_mark_node
;
3205 /* Perhaps we already constructed a constant string just like this one? */
3206 key
.literal
= string
;
3207 string_descriptor
**loc
= string_htab
->find_slot (&key
, INSERT
);
3212 *loc
= desc
= ggc_alloc
<string_descriptor
> ();
3213 desc
->literal
= string
;
3215 (*runtime
.build_const_string_constructor
) (input_location
, string
, length
);
3218 addr
= convert (build_pointer_type (constant_string_type
),
3219 build_unary_op (input_location
,
3220 ADDR_EXPR
, desc
->constructor
, 1));
3225 /* Build a static constant CONSTRUCTOR
3226 with type TYPE and elements ELTS. */
3229 objc_build_constructor (tree type
, vec
<constructor_elt
, va_gc
> *elts
)
3231 tree constructor
= build_constructor (type
, elts
);
3233 TREE_CONSTANT (constructor
) = 1;
3234 TREE_STATIC (constructor
) = 1;
3235 TREE_READONLY (constructor
) = 1;
3238 /* Adjust for impedance mismatch. We should figure out how to build
3239 CONSTRUCTORs that consistently please both the C and C++ gods. */
3240 if (!(*elts
)[0].index
)
3241 TREE_TYPE (constructor
) = init_list_type_node
;
3247 /* Return the DECL of the string IDENT in the SECTION. */
3250 get_objc_string_decl (tree ident
, enum string_section section
)
3257 chain
= class_names_chain
;
3259 case meth_var_names
:
3260 chain
= meth_var_names_chain
;
3262 case meth_var_types
:
3263 chain
= meth_var_types_chain
;
3265 case prop_names_attr
:
3266 chain
= prop_names_attr_chain
;
3272 for (; chain
!= 0; chain
= TREE_CHAIN (chain
))
3273 if (TREE_VALUE (chain
) == ident
)
3274 return (TREE_PURPOSE (chain
));
3276 /* We didn't find the entry. */
3280 /* Create a class reference, but don't create a variable to reference
3284 add_class_reference (tree ident
)
3288 if ((chain
= cls_ref_chain
))
3293 if (ident
== TREE_VALUE (chain
))
3297 chain
= TREE_CHAIN (chain
);
3301 /* Append to the end of the list */
3302 TREE_CHAIN (tail
) = tree_cons (NULL_TREE
, ident
, NULL_TREE
);
3305 cls_ref_chain
= tree_cons (NULL_TREE
, ident
, NULL_TREE
);
3308 /* Get a class reference, creating it if necessary. Also create the
3309 reference variable. */
3311 objc_get_class_reference (tree ident
)
3313 tree orig_ident
= (DECL_P (ident
)
3316 ? OBJC_TYPE_NAME (ident
)
3318 bool local_scope
= false;
3321 if (processing_template_decl
)
3322 /* Must wait until template instantiation time. */
3323 return build_min_nt_loc (UNKNOWN_LOCATION
, CLASS_REFERENCE_EXPR
, ident
);
3326 if (TREE_CODE (ident
) == TYPE_DECL
)
3327 ident
= (DECL_ORIGINAL_TYPE (ident
)
3328 ? DECL_ORIGINAL_TYPE (ident
)
3329 : TREE_TYPE (ident
));
3333 && CP_TYPE_CONTEXT (ident
) != global_namespace
)
3337 if (local_scope
|| !(ident
= objc_is_class_name (ident
)))
3339 error ("%qE is not an Objective-C class name or alias",
3341 return error_mark_node
;
3344 return (*runtime
.get_class_reference
) (ident
);
3348 objc_declare_alias (tree alias_ident
, tree class_ident
)
3350 tree underlying_class
;
3353 if (current_namespace
!= global_namespace
) {
3354 error ("Objective-C declarations may only appear in global scope");
3356 #endif /* OBJCPLUS */
3358 if (!(underlying_class
= objc_is_class_name (class_ident
)))
3359 warning (0, "cannot find class %qE", class_ident
);
3360 else if (objc_is_class_name (alias_ident
))
3361 warning (0, "class %qE already exists", alias_ident
);
3364 /* Implement @compatibility_alias as a typedef. */
3366 push_lang_context (lang_name_c
); /* extern "C" */
3368 lang_hooks
.decls
.pushdecl (build_decl
3372 xref_tag (RECORD_TYPE
, underlying_class
)));
3374 pop_lang_context ();
3376 objc_map_put (alias_name_map
, alias_ident
, underlying_class
);
3381 objc_declare_class (tree identifier
)
3384 if (current_namespace
!= global_namespace
) {
3385 error ("Objective-C declarations may only appear in global scope");
3387 #endif /* OBJCPLUS */
3389 if (! objc_is_class_name (identifier
))
3391 tree record
= lookup_name (identifier
), type
= record
;
3395 if (TREE_CODE (record
) == TYPE_DECL
)
3396 type
= DECL_ORIGINAL_TYPE (record
)
3397 ? DECL_ORIGINAL_TYPE (record
)
3398 : TREE_TYPE (record
);
3400 if (!TYPE_HAS_OBJC_INFO (type
)
3401 || !TYPE_OBJC_INTERFACE (type
))
3403 error ("%qE redeclared as different kind of symbol",
3405 error ("previous declaration of %q+D",
3410 record
= xref_tag (RECORD_TYPE
, identifier
);
3411 INIT_TYPE_OBJC_INFO (record
);
3412 /* In the case of a @class declaration, we store the ident in
3413 the TYPE_OBJC_INTERFACE. If later an @interface is found,
3414 we'll replace the ident with the interface. */
3415 TYPE_OBJC_INTERFACE (record
) = identifier
;
3416 objc_map_put (class_name_map
, identifier
, NULL_TREE
);
3421 objc_is_class_name (tree ident
)
3423 if (ident
&& TREE_CODE (ident
) == IDENTIFIER_NODE
)
3425 tree t
= identifier_global_value (ident
);
3430 while (ident
&& TREE_CODE (ident
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (ident
))
3431 ident
= OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident
));
3433 if (ident
&& TREE_CODE (ident
) == RECORD_TYPE
)
3434 ident
= OBJC_TYPE_NAME (ident
);
3436 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
3438 tree type
= TREE_TYPE (ident
);
3439 if (type
&& TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
3441 ident
= DECL_NAME (ident
);
3444 if (!ident
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
3447 if (lookup_interface (ident
))
3453 target
= objc_map_get (class_name_map
, ident
);
3454 if (target
!= OBJC_MAP_NOT_FOUND
)
3457 target
= objc_map_get (alias_name_map
, ident
);
3458 if (target
!= OBJC_MAP_NOT_FOUND
)
3465 /* Check whether TYPE is either 'id' or 'Class'. */
3468 objc_is_id (tree type
)
3470 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
)
3472 tree t
= identifier_global_value (type
);
3477 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
3478 type
= TREE_TYPE (type
);
3480 /* NB: This function may be called before the ObjC front-end has
3481 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
3482 return (objc_object_type
&& type
3483 && (IS_ID (type
) || IS_CLASS (type
) || IS_SUPER (type
))
3488 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3489 class instance. This is needed by other parts of the compiler to
3490 handle ObjC types gracefully. */
3493 objc_is_object_ptr (tree type
)
3497 type
= TYPE_MAIN_VARIANT (type
);
3498 if (!POINTER_TYPE_P (type
))
3501 ret
= objc_is_id (type
);
3503 ret
= objc_is_class_name (TREE_TYPE (type
));
3509 objc_is_gcable_type (tree type
, int or_strong_p
)
3515 if (objc_is_id (TYPE_MAIN_VARIANT (type
)))
3517 if (or_strong_p
&& lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type
)))
3519 if (TREE_CODE (type
) != POINTER_TYPE
&& TREE_CODE (type
) != INDIRECT_REF
)
3521 type
= TREE_TYPE (type
);
3522 if (TREE_CODE (type
) != RECORD_TYPE
)
3524 name
= TYPE_NAME (type
);
3525 return (objc_is_class_name (name
) != NULL_TREE
);
3529 objc_substitute_decl (tree expr
, tree oldexpr
, tree newexpr
)
3531 if (expr
== oldexpr
)
3534 switch (TREE_CODE (expr
))
3537 return objc_build_component_ref
3538 (objc_substitute_decl (TREE_OPERAND (expr
, 0),
3541 DECL_NAME (TREE_OPERAND (expr
, 1)));
3543 return build_array_ref (input_location
,
3544 objc_substitute_decl (TREE_OPERAND (expr
, 0),
3547 TREE_OPERAND (expr
, 1));
3549 return build_indirect_ref (input_location
,
3550 objc_substitute_decl (TREE_OPERAND (expr
, 0),
3552 newexpr
), RO_ARROW
);
3559 objc_build_ivar_assignment (tree outervar
, tree lhs
, tree rhs
)
3562 /* The LHS parameter contains the expression 'outervar->memberspec';
3563 we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3564 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3567 = objc_substitute_decl
3568 (lhs
, outervar
, convert (TREE_TYPE (outervar
), integer_zero_node
));
3570 = (flag_objc_direct_dispatch
3571 ? objc_assign_ivar_fast_decl
3572 : objc_assign_ivar_decl
);
3574 offs
= convert (integer_type_node
, build_unary_op (input_location
,
3575 ADDR_EXPR
, offs
, 0));
3577 func_params
= tree_cons (NULL_TREE
,
3578 convert (objc_object_type
, rhs
),
3579 tree_cons (NULL_TREE
, convert (objc_object_type
, outervar
),
3580 tree_cons (NULL_TREE
, offs
,
3583 return build_function_call (input_location
, func
, func_params
);
3587 objc_build_global_assignment (tree lhs
, tree rhs
)
3589 tree func_params
= tree_cons (NULL_TREE
,
3590 convert (objc_object_type
, rhs
),
3591 tree_cons (NULL_TREE
, convert (build_pointer_type (objc_object_type
),
3592 build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0)),
3595 return build_function_call (input_location
,
3596 objc_assign_global_decl
, func_params
);
3600 objc_build_strong_cast_assignment (tree lhs
, tree rhs
)
3602 tree func_params
= tree_cons (NULL_TREE
,
3603 convert (objc_object_type
, rhs
),
3604 tree_cons (NULL_TREE
, convert (build_pointer_type (objc_object_type
),
3605 build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0)),
3608 return build_function_call (input_location
,
3609 objc_assign_strong_cast_decl
, func_params
);
3613 objc_is_gcable_p (tree expr
)
3615 return (TREE_CODE (expr
) == COMPONENT_REF
3616 ? objc_is_gcable_p (TREE_OPERAND (expr
, 1))
3617 : TREE_CODE (expr
) == ARRAY_REF
3618 ? (objc_is_gcable_p (TREE_TYPE (expr
))
3619 || objc_is_gcable_p (TREE_OPERAND (expr
, 0)))
3620 : TREE_CODE (expr
) == ARRAY_TYPE
3621 ? objc_is_gcable_p (TREE_TYPE (expr
))
3623 ? objc_is_gcable_type (expr
, 1)
3624 : (objc_is_gcable_p (TREE_TYPE (expr
))
3626 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr
)))));
3630 objc_is_ivar_reference_p (tree expr
)
3632 return (TREE_CODE (expr
) == ARRAY_REF
3633 ? objc_is_ivar_reference_p (TREE_OPERAND (expr
, 0))
3634 : TREE_CODE (expr
) == COMPONENT_REF
3635 ? TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
3640 objc_is_global_reference_p (tree expr
)
3642 return (TREE_CODE (expr
) == INDIRECT_REF
|| TREE_CODE (expr
) == PLUS_EXPR
3643 ? objc_is_global_reference_p (TREE_OPERAND (expr
, 0))
3645 ? (DECL_FILE_SCOPE_P (expr
) || TREE_STATIC (expr
))
3650 objc_generate_write_barrier (tree lhs
, enum tree_code modifycode
, tree rhs
)
3652 tree result
= NULL_TREE
, outer
;
3653 int strong_cast_p
= 0, outer_gc_p
= 0, indirect_p
= 0;
3655 /* This function is currently only used with the next runtime with
3656 garbage collection enabled (-fobjc-gc). */
3657 gcc_assert (flag_next_runtime
);
3659 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts
3660 will have been transformed to the form '*(type *)&expr'. */
3661 if (TREE_CODE (lhs
) == INDIRECT_REF
)
3663 outer
= TREE_OPERAND (lhs
, 0);
3665 while (!strong_cast_p
3666 && (CONVERT_EXPR_P (outer
)
3667 || TREE_CODE (outer
) == NON_LVALUE_EXPR
))
3669 tree lhstype
= TREE_TYPE (outer
);
3671 /* Descend down the cast chain, and record the first objc_gc
3673 if (POINTER_TYPE_P (lhstype
))
3676 = lookup_attribute ("objc_gc",
3677 TYPE_ATTRIBUTES (TREE_TYPE (lhstype
)));
3683 outer
= TREE_OPERAND (outer
, 0);
3687 /* If we have a __strong cast, it trumps all else. */
3690 if (modifycode
!= NOP_EXPR
)
3691 goto invalid_pointer_arithmetic
;
3693 if (warn_assign_intercept
)
3694 warning (0, "strong-cast assignment has been intercepted");
3696 result
= objc_build_strong_cast_assignment (lhs
, rhs
);
3701 /* the lhs must be of a suitable type, regardless of its underlying
3703 if (!objc_is_gcable_p (lhs
))
3709 && (TREE_CODE (outer
) == COMPONENT_REF
3710 || TREE_CODE (outer
) == ARRAY_REF
))
3711 outer
= TREE_OPERAND (outer
, 0);
3713 if (TREE_CODE (outer
) == INDIRECT_REF
)
3715 outer
= TREE_OPERAND (outer
, 0);
3719 outer_gc_p
= objc_is_gcable_p (outer
);
3721 /* Handle ivar assignments. */
3722 if (objc_is_ivar_reference_p (lhs
))
3724 /* if the struct to the left of the ivar is not an Objective-C object (__strong
3725 doesn't cut it here), the best we can do here is suggest a cast. */
3726 if (!objc_is_gcable_type (TREE_TYPE (outer
), 0))
3728 /* We may still be able to use the global write barrier... */
3729 if (!indirect_p
&& objc_is_global_reference_p (outer
))
3730 goto global_reference
;
3733 if (modifycode
== NOP_EXPR
)
3735 if (warn_assign_intercept
)
3736 warning (0, "strong-cast may possibly be needed");
3742 if (modifycode
!= NOP_EXPR
)
3743 goto invalid_pointer_arithmetic
;
3745 if (warn_assign_intercept
)
3746 warning (0, "instance variable assignment has been intercepted");
3748 result
= objc_build_ivar_assignment (outer
, lhs
, rhs
);
3753 /* Likewise, intercept assignment to global/static variables if their type is
3755 if (objc_is_global_reference_p (outer
))
3761 if (modifycode
!= NOP_EXPR
)
3763 invalid_pointer_arithmetic
:
3765 warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3770 if (warn_assign_intercept
)
3771 warning (0, "global/static variable assignment has been intercepted");
3773 result
= objc_build_global_assignment (lhs
, rhs
);
3776 /* In all other cases, fall back to the normal mechanism. */
3781 /* Implementation of the table mapping a class name (as an identifier)
3782 to a class node. The two public functions for it are
3783 lookup_interface() and add_interface(). add_interface() is only
3784 used in this file, so we can make it static. */
3786 static GTY(()) objc_map_t interface_map
;
3789 interface_hash_init (void)
3791 interface_map
= objc_map_alloc_ggc (200);
3795 add_interface (tree class_name
, tree name
)
3797 /* Put interfaces on list in reverse order. */
3798 TREE_CHAIN (class_name
) = interface_chain
;
3799 interface_chain
= class_name
;
3801 /* Add it to the map. */
3802 objc_map_put (interface_map
, name
, class_name
);
3804 return interface_chain
;
3808 lookup_interface (tree ident
)
3811 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
3812 ident
= DECL_NAME (ident
);
3815 if (ident
== NULL_TREE
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
3819 tree interface
= objc_map_get (interface_map
, ident
);
3821 if (interface
== OBJC_MAP_NOT_FOUND
)
3830 /* Implement @defs (<classname>) within struct bodies. */
3833 objc_get_class_ivars (tree class_name
)
3835 tree interface
= lookup_interface (class_name
);
3838 return get_class_ivars (interface
, true);
3840 error ("cannot find interface declaration for %qE",
3843 return error_mark_node
;
3847 /* Functions used by the hashtable for field duplicates in
3848 objc_detect_field_duplicates(). Ideally, we'd use a standard
3849 key-value dictionary hashtable , and store as keys the field names,
3850 and as values the actual declarations (used to print nice error
3851 messages with the locations). But, the hashtable we are using only
3852 allows us to store keys in the hashtable, without values (it looks
3853 more like a set). So, we store the DECLs, but define equality as
3854 DECLs having the same name, and hash as the hash of the name. */
3856 struct decl_name_hash
: nofree_ptr_hash
<tree_node
>
3858 static inline hashval_t
hash (const tree_node
*);
3859 static inline bool equal (const tree_node
*, const tree_node
*);
3863 decl_name_hash::hash (const tree_node
*q
)
3865 return (hashval_t
) ((intptr_t)(DECL_NAME (q
)) >> 3);
3869 decl_name_hash::equal (const tree_node
*a
, const tree_node
*b
)
3871 return DECL_NAME (a
) == DECL_NAME (b
);
3874 /* Called when checking the variables in a struct. If we are not
3875 doing the ivars list inside an @interface context, then return
3876 false. Else, perform the check for duplicate ivars, then return
3877 true. The check for duplicates checks if an instance variable with
3878 the same name exists in the class or in a superclass. If
3879 'check_superclasses_only' is set to true, then it is assumed that
3880 checks for instance variables in the same class has already been
3881 performed (this is the case for ObjC++) and only the instance
3882 variables of superclasses are checked. */
3884 objc_detect_field_duplicates (bool check_superclasses_only
)
3886 if (!objc_collecting_ivars
|| !objc_interface_context
3887 || TREE_CODE (objc_interface_context
) != CLASS_INTERFACE_TYPE
)
3890 /* We have two ways of doing this check:
3892 "direct comparison": we iterate over the instance variables and
3893 compare them directly. This works great for small numbers of
3894 instance variables (such as 10 or 20), which are extremely common.
3895 But it will potentially take forever for the pathological case with
3896 a huge number (eg, 10k) of instance variables.
3898 "hashtable": we use a hashtable, which requires a single sweep
3899 through the list of instances variables. This is much slower for a
3900 small number of variables, and we only use it for large numbers.
3902 To decide which one to use, we need to get an idea of how many
3903 instance variables we have to compare. */
3905 unsigned int number_of_ivars_to_check
= 0;
3908 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
);
3909 ivar
; ivar
= DECL_CHAIN (ivar
))
3911 /* Ignore anonymous ivars. */
3912 if (DECL_NAME (ivar
))
3913 number_of_ivars_to_check
++;
3917 /* Exit if there is nothing to do. */
3918 if (number_of_ivars_to_check
== 0)
3921 /* In case that there are only 1 or 2 instance variables to check,
3922 we always use direct comparison. If there are more, it is
3923 worth iterating over the instance variables in the superclass
3924 to count how many there are (note that this has the same cost
3925 as checking 1 instance variable by direct comparison, which is
3926 why we skip this check in the case of 1 or 2 ivars and just do
3927 the direct comparison) and then decide if it worth using a
3929 if (number_of_ivars_to_check
> 2)
3931 unsigned int number_of_superclass_ivars
= 0;
3934 for (interface
= lookup_interface (CLASS_SUPER_NAME (objc_interface_context
));
3935 interface
; interface
= lookup_interface (CLASS_SUPER_NAME (interface
)))
3938 for (ivar
= CLASS_RAW_IVARS (interface
);
3939 ivar
; ivar
= DECL_CHAIN (ivar
))
3940 number_of_superclass_ivars
++;
3944 /* We use a hashtable if we have over 10k comparisons. */
3945 if (number_of_ivars_to_check
* (number_of_superclass_ivars
3946 + (number_of_ivars_to_check
/ 2))
3949 /* First, build the hashtable by putting all the instance
3950 variables of superclasses in it. */
3951 hash_table
<decl_name_hash
> htab (37);
3953 for (interface
= lookup_interface (CLASS_SUPER_NAME
3954 (objc_interface_context
));
3955 interface
; interface
= lookup_interface
3956 (CLASS_SUPER_NAME (interface
)))
3959 for (ivar
= CLASS_RAW_IVARS (interface
); ivar
;
3960 ivar
= DECL_CHAIN (ivar
))
3962 if (DECL_NAME (ivar
) != NULL_TREE
)
3964 tree_node
**slot
= htab
.find_slot (ivar
, INSERT
);
3965 /* Do not check for duplicate instance
3966 variables in superclasses. Errors have
3967 already been generated. */
3973 /* Now, we go through all the instance variables in the
3974 class, and check that they are not in the
3976 if (check_superclasses_only
)
3979 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
); ivar
;
3980 ivar
= DECL_CHAIN (ivar
))
3982 if (DECL_NAME (ivar
) != NULL_TREE
)
3984 tree duplicate_ivar
= htab
.find (ivar
);
3985 if (duplicate_ivar
!= HTAB_EMPTY_ENTRY
)
3987 error_at (DECL_SOURCE_LOCATION (ivar
),
3988 "duplicate instance variable %q+D",
3990 inform (DECL_SOURCE_LOCATION (duplicate_ivar
),
3991 "previous declaration of %q+D",
3993 /* FIXME: Do we need the following ? */
3994 /* DECL_NAME (ivar) = NULL_TREE; */
4001 /* If we're checking for duplicates in the class as
4002 well, we insert variables in the hashtable as we
4003 check them, so if a duplicate follows, it will be
4006 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
); ivar
;
4007 ivar
= DECL_CHAIN (ivar
))
4009 if (DECL_NAME (ivar
) != NULL_TREE
)
4011 tree_node
**slot
= htab
.find_slot (ivar
, INSERT
);
4014 tree duplicate_ivar
= (tree
)(*slot
);
4015 error_at (DECL_SOURCE_LOCATION (ivar
),
4016 "duplicate instance variable %q+D",
4018 inform (DECL_SOURCE_LOCATION (duplicate_ivar
),
4019 "previous declaration of %q+D",
4021 /* FIXME: Do we need the following ? */
4022 /* DECL_NAME (ivar) = NULL_TREE; */
4033 /* This is the "direct comparison" approach, which is used in most
4034 non-pathological cases. */
4036 /* Walk up to class hierarchy, starting with this class (this is
4037 the external loop, because lookup_interface() is expensive, and
4038 we want to do it few times). */
4039 tree interface
= objc_interface_context
;
4041 if (check_superclasses_only
)
4042 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
4044 for ( ; interface
; interface
= lookup_interface
4045 (CLASS_SUPER_NAME (interface
)))
4047 tree ivar_being_checked
;
4049 for (ivar_being_checked
= CLASS_RAW_IVARS (objc_interface_context
);
4051 ivar_being_checked
= DECL_CHAIN (ivar_being_checked
))
4055 /* Ignore anonymous ivars. */
4056 if (DECL_NAME (ivar_being_checked
) == NULL_TREE
)
4059 /* Note how we stop when we find the ivar we are checking
4060 (this can only happen in the main class, not
4061 superclasses), to avoid comparing things twice
4062 (otherwise, for each ivar, you'd compare A to B then B
4063 to A, and get duplicated error messages). */
4064 for (decl
= CLASS_RAW_IVARS (interface
);
4065 decl
&& decl
!= ivar_being_checked
;
4066 decl
= DECL_CHAIN (decl
))
4068 if (DECL_NAME (ivar_being_checked
) == DECL_NAME (decl
))
4070 error_at (DECL_SOURCE_LOCATION (ivar_being_checked
),
4071 "duplicate instance variable %q+D",
4072 ivar_being_checked
);
4073 inform (DECL_SOURCE_LOCATION (decl
),
4074 "previous declaration of %q+D",
4076 /* FIXME: Do we need the following ? */
4077 /* DECL_NAME (ivar_being_checked) = NULL_TREE; */
4086 /* Used by: build_private_template, continue_class,
4087 and for @defs constructs. */
4090 get_class_ivars (tree interface
, bool inherited
)
4092 tree ivar_chain
= copy_list (CLASS_RAW_IVARS (interface
));
4094 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
4095 by the current class (i.e., they do not include super-class ivars).
4096 However, the CLASS_IVARS list will be side-effected by a call to
4097 finish_struct(), which will fill in field offsets. */
4098 if (!CLASS_IVARS (interface
))
4099 CLASS_IVARS (interface
) = ivar_chain
;
4104 while (CLASS_SUPER_NAME (interface
))
4106 /* Prepend super-class ivars. */
4107 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
4108 ivar_chain
= chainon (copy_list (CLASS_RAW_IVARS (interface
)),
4116 objc_maybe_warn_exceptions (location_t loc
)
4118 /* -fobjc-exceptions is required to enable Objective-C exceptions.
4119 For example, on Darwin, ObjC exceptions require a sufficiently
4120 recent version of the runtime, so the user must ask for them
4121 explicitly. On other platforms, at the moment -fobjc-exceptions
4122 triggers -fexceptions which again is required for exceptions to
4124 if (!flag_objc_exceptions
)
4126 /* Warn only once per compilation unit. */
4127 static bool warned
= false;
4131 error_at (loc
, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax");
4137 static struct objc_try_context
*cur_try_context
;
4139 /* Called just after parsing the @try and its associated BODY. We now
4140 must prepare for the tricky bits -- handling the catches and finally. */
4143 objc_begin_try_stmt (location_t try_locus
, tree body
)
4145 struct objc_try_context
*c
= XCNEW (struct objc_try_context
);
4146 c
->outer
= cur_try_context
;
4148 c
->try_locus
= try_locus
;
4149 c
->end_try_locus
= input_location
;
4150 cur_try_context
= c
;
4152 /* Collect the list of local variables. We'll mark them as volatile
4153 at the end of compilation of this function to prevent them being
4154 clobbered by setjmp/longjmp. */
4155 if (flag_objc_sjlj_exceptions
)
4156 objc_mark_locals_volatile (NULL
);
4159 /* Called just after parsing "@catch (parm)". Open a binding level,
4160 enter DECL into the binding level, and initialize it. Leave the
4161 binding level open while the body of the compound statement is
4162 parsed. If DECL is NULL_TREE, then we are compiling "@catch(...)"
4163 which we compile as "@catch(id tmp_variable)". */
4166 objc_begin_catch_clause (tree decl
)
4168 tree compound
, type
, t
;
4169 bool ellipsis
= false;
4171 /* Begin a new scope that the entire catch clause will live in. */
4172 compound
= c_begin_compound_stmt (true);
4174 /* Create the appropriate declaration for the argument. */
4175 if (decl
== error_mark_node
)
4176 type
= error_mark_node
;
4179 if (decl
== NULL_TREE
)
4181 /* If @catch(...) was specified, create a temporary variable of
4182 type 'id' and use it. */
4183 decl
= objc_create_temporary_var (objc_object_type
, "__objc_generic_catch_var");
4184 DECL_SOURCE_LOCATION (decl
) = input_location
;
4185 /* ... but allow the runtime to differentiate between ellipsis and the
4186 case of @catch (id xyz). */
4191 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
4192 decl
= build_decl (input_location
,
4193 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
4195 lang_hooks
.decls
.pushdecl (decl
);
4197 /* Mark the declaration as used so you never any warnings whether
4198 you use the exception argument or not. TODO: Implement a
4199 -Wunused-exception-parameter flag, which would cause warnings
4200 if exception parameter is not used. */
4201 TREE_USED (decl
) = 1;
4202 DECL_READ_P (decl
) = 1;
4204 type
= TREE_TYPE (decl
);
4207 /* Verify that the type of the catch is valid. It must be a pointer
4208 to an Objective-C class, or "id" (which is catch-all). */
4209 if (type
== error_mark_node
)
4211 ;/* Just keep going. */
4213 else if (!objc_type_valid_for_messaging (type
, false))
4215 error ("@catch parameter is not a known Objective-C class type");
4216 type
= error_mark_node
;
4218 else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type
))
4219 && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type
)))
4221 error ("@catch parameter can not be protocol-qualified");
4222 type
= error_mark_node
;
4224 else if (POINTER_TYPE_P (type
) && objc_is_object_id (TREE_TYPE (type
)))
4225 /* @catch (id xyz) or @catch (...) but we note this for runtimes that
4230 /* If 'type' was built using typedefs, we need to get rid of
4231 them and get a simple pointer to the class. */
4232 bool is_typedef
= false;
4233 tree x
= TYPE_MAIN_VARIANT (type
);
4235 /* Skip from the pointer to the pointee. */
4236 if (TREE_CODE (x
) == POINTER_TYPE
)
4239 /* Traverse typedef aliases */
4240 while (TREE_CODE (x
) == RECORD_TYPE
&& OBJC_TYPE_NAME (x
)
4241 && TREE_CODE (OBJC_TYPE_NAME (x
)) == TYPE_DECL
4242 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x
)))
4245 x
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x
));
4248 /* If it was a typedef, build a pointer to the final, original
4251 type
= build_pointer_type (x
);
4253 if (cur_try_context
->catch_list
)
4255 /* Examine previous @catch clauses and see if we've already
4256 caught the type in question. */
4257 tree_stmt_iterator i
= tsi_start (cur_try_context
->catch_list
);
4258 for (; !tsi_end_p (i
); tsi_next (&i
))
4260 tree stmt
= tsi_stmt (i
);
4261 t
= CATCH_TYPES (stmt
);
4262 if (t
== error_mark_node
)
4264 if (!t
|| DERIVED_FROM_P (TREE_TYPE (t
), TREE_TYPE (type
)))
4266 warning (0, "exception of type %<%T%> will be caught",
4268 warning_at (EXPR_LOCATION (stmt
), 0, " by earlier handler for %<%T%>",
4269 TREE_TYPE (t
? t
: objc_object_type
));
4276 t
= (*runtime
.begin_catch
) (&cur_try_context
, type
, decl
, compound
, ellipsis
);
4280 /* Called just after parsing the closing brace of a @catch clause. Close
4281 the open binding level, and record a CATCH_EXPR for it. */
4284 objc_finish_catch_clause (void)
4286 tree c
= cur_try_context
->current_catch
;
4287 cur_try_context
->current_catch
= NULL
;
4288 cur_try_context
->end_catch_locus
= input_location
;
4290 CATCH_BODY (c
) = c_end_compound_stmt (input_location
, CATCH_BODY (c
), 1);
4292 (*runtime
.finish_catch
) (&cur_try_context
, c
);
4295 /* Called after parsing a @finally clause and its associated BODY.
4296 Record the body for later placement. */
4299 objc_build_finally_clause (location_t finally_locus
, tree body
)
4301 cur_try_context
->finally_body
= body
;
4302 cur_try_context
->finally_locus
= finally_locus
;
4303 cur_try_context
->end_finally_locus
= input_location
;
4306 /* Called to finalize a @try construct. */
4309 objc_finish_try_stmt (void)
4311 struct objc_try_context
*c
= cur_try_context
;
4314 if (c
->catch_list
== NULL
&& c
->finally_body
== NULL
)
4315 error ("%<@try%> without %<@catch%> or %<@finally%>");
4317 stmt
= (*runtime
.finish_try_stmt
) (&cur_try_context
);
4320 cur_try_context
= c
->outer
;
4326 objc_build_throw_stmt (location_t loc
, tree throw_expr
)
4328 bool rethrown
= false;
4330 objc_maybe_warn_exceptions (loc
);
4332 /* Don't waste time trying to build something if we're already dead. */
4333 if (throw_expr
== error_mark_node
)
4334 return error_mark_node
;
4336 if (throw_expr
== NULL
)
4338 /* If we're not inside a @catch block, there is no "current
4339 exception" to be rethrown. */
4340 if (cur_try_context
== NULL
4341 || cur_try_context
->current_catch
== NULL
)
4343 error_at (loc
, "%<@throw%> (rethrow) used outside of a @catch block");
4344 return error_mark_node
;
4347 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
4348 value that we get from the runtime. */
4349 throw_expr
= (*runtime
.build_exc_ptr
) (&cur_try_context
);
4354 if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr
), true))
4356 error_at (loc
, "%<@throw%> argument is not an object");
4357 return error_mark_node
;
4361 return (*runtime
.build_throw_stmt
) (loc
, throw_expr
, rethrown
);
4365 objc_build_synchronized (location_t start_locus
, tree object_expr
, tree body
)
4367 /* object_expr should never be NULL; but in case it is, convert it to
4369 if (object_expr
== NULL
)
4370 object_expr
= error_mark_node
;
4372 /* Validate object_expr. If not valid, set it to error_mark_node. */
4373 if (object_expr
!= error_mark_node
)
4375 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr
), true))
4377 error_at (start_locus
, "%<@synchronized%> argument is not an object");
4378 object_expr
= error_mark_node
;
4382 if (object_expr
== error_mark_node
)
4384 /* If we found an error, we simply ignore the '@synchronized'.
4385 Compile the body so we can keep going with minimal
4387 return add_stmt (body
);
4394 /* objc_sync_enter (object_expr); */
4395 object_expr
= save_expr (object_expr
);
4396 args
= tree_cons (NULL
, object_expr
, NULL
);
4397 call
= build_function_call (input_location
,
4398 objc_sync_enter_decl
, args
);
4399 SET_EXPR_LOCATION (call
, start_locus
);
4402 /* Build "objc_sync_exit (object_expr);" but do not add it yet;
4403 it goes inside the @finalize() clause. */
4404 args
= tree_cons (NULL
, object_expr
, NULL
);
4405 call
= build_function_call (input_location
,
4406 objc_sync_exit_decl
, args
);
4407 SET_EXPR_LOCATION (call
, input_location
);
4409 /* @try { body; } */
4410 objc_begin_try_stmt (start_locus
, body
);
4412 /* @finally { objc_sync_exit (object_expr); } */
4413 objc_build_finally_clause (input_location
, call
);
4415 /* End of try statement. */
4416 return objc_finish_try_stmt ();
4420 /* Construct a C struct corresponding to ObjC class CLASS, with the same
4423 struct <classname> {
4424 struct _objc_class *isa;
4429 build_private_template (tree klass
)
4431 if (!CLASS_STATIC_TEMPLATE (klass
))
4433 tree record
= objc_build_struct (klass
,
4434 get_class_ivars (klass
, false),
4435 CLASS_SUPER_NAME (klass
));
4437 /* Set the TREE_USED bit for this struct, so that stab generator
4438 can emit stabs for this struct type. */
4439 if (flag_debug_only_used_symbols
&& TYPE_STUB_DECL (record
))
4440 TREE_USED (TYPE_STUB_DECL (record
)) = 1;
4442 /* Copy the attributes from the class to the type. */
4443 if (TREE_DEPRECATED (klass
))
4444 TREE_DEPRECATED (record
) = 1;
4448 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
4452 objc_generate_cxx_ctor_or_dtor (bool dtor
)
4454 tree fn
, body
, compound_stmt
, ivar
;
4456 /* - (id) .cxx_construct { ... return self; } */
4457 /* - (void) .cxx_construct { ... } */
4459 objc_start_method_definition
4460 (false /* is_class_method */,
4461 objc_build_method_signature (false /* is_class_method */,
4462 build_tree_list (NULL_TREE
,
4465 : objc_object_type
),
4466 get_identifier (dtor
4468 : TAG_CXX_CONSTRUCT
),
4469 make_node (TREE_LIST
),
4470 false), NULL
, NULL_TREE
);
4471 body
= begin_function_body ();
4472 compound_stmt
= begin_compound_stmt (0);
4474 ivar
= CLASS_IVARS (implementation_template
);
4475 /* Destroy ivars in reverse order. */
4477 ivar
= nreverse (copy_list (ivar
));
4479 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
4481 if (TREE_CODE (ivar
) == FIELD_DECL
)
4483 tree type
= TREE_TYPE (ivar
);
4485 /* Call the ivar's default constructor or destructor. Do not
4486 call the destructor unless a corresponding constructor call
4487 has also been made (or is not needed). */
4488 if (MAYBE_CLASS_TYPE_P (type
)
4490 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4491 && (!TYPE_NEEDS_CONSTRUCTING (type
)
4492 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4493 : (TYPE_NEEDS_CONSTRUCTING (type
)
4494 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))))
4496 (build_special_member_call
4497 (build_ivar_reference (DECL_NAME (ivar
)),
4498 dtor
? complete_dtor_identifier
: complete_ctor_identifier
,
4499 NULL
, type
, LOOKUP_NORMAL
, tf_warning_or_error
));
4503 /* The constructor returns 'self'. */
4505 finish_return_stmt (self_decl
);
4507 finish_compound_stmt (compound_stmt
);
4508 finish_function_body (body
);
4509 fn
= current_function_decl
;
4511 objc_finish_method_definition (fn
);
4514 /* The following routine will examine the current @interface for any
4515 non-POD C++ ivars requiring non-trivial construction and/or
4516 destruction, and then synthesize special '- .cxx_construct' and/or
4517 '- .cxx_destruct' methods which will run the appropriate
4518 construction or destruction code. Note that ivars inherited from
4519 super-classes are _not_ considered. */
4521 objc_generate_cxx_cdtors (void)
4523 bool need_ctor
= false, need_dtor
= false;
4526 /* Error case, due to possibly an extra @end. */
4527 if (!objc_implementation_context
)
4530 /* We do not want to do this for categories, since they do not have
4533 if (TREE_CODE (objc_implementation_context
) != CLASS_IMPLEMENTATION_TYPE
)
4536 /* First, determine if we even need a constructor and/or destructor. */
4538 for (ivar
= CLASS_IVARS (implementation_template
); ivar
;
4539 ivar
= TREE_CHAIN (ivar
))
4541 if (TREE_CODE (ivar
) == FIELD_DECL
)
4543 tree type
= TREE_TYPE (ivar
);
4545 if (MAYBE_CLASS_TYPE_P (type
))
4547 if (TYPE_NEEDS_CONSTRUCTING (type
)
4548 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4549 /* NB: If a default constructor is not available, we will not
4550 be able to initialize this ivar; the add_instance_variable()
4551 routine will already have warned about this. */
4554 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4555 && (!TYPE_NEEDS_CONSTRUCTING (type
)
4556 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4557 /* NB: If a default constructor is not available, we will not
4558 call the destructor either, for symmetry. */
4564 /* Generate '- .cxx_construct' if needed. */
4567 objc_generate_cxx_ctor_or_dtor (false);
4569 /* Generate '- .cxx_destruct' if needed. */
4572 objc_generate_cxx_ctor_or_dtor (true);
4574 /* The 'imp_list' variable points at an imp_entry record for the current
4575 @implementation. Record the existence of '- .cxx_construct' and/or
4576 '- .cxx_destruct' methods therein; it will be included in the
4577 metadata for the class if the runtime needs it. */
4578 imp_list
->has_cxx_cdtors
= (need_ctor
|| need_dtor
);
4583 error_with_ivar (const char *message
, tree decl
)
4585 error_at (DECL_SOURCE_LOCATION (decl
), "%s %qs",
4586 message
, identifier_to_locale (gen_declaration (decl
)));
4591 check_ivars (tree inter
, tree imp
)
4593 tree intdecls
= CLASS_RAW_IVARS (inter
);
4594 tree impdecls
= CLASS_RAW_IVARS (imp
);
4601 if (intdecls
&& TREE_CODE (intdecls
) == TYPE_DECL
)
4602 intdecls
= TREE_CHAIN (intdecls
);
4604 if (intdecls
== 0 && impdecls
== 0)
4606 if (intdecls
== 0 || impdecls
== 0)
4608 error ("inconsistent instance variable specification");
4612 t1
= TREE_TYPE (intdecls
); t2
= TREE_TYPE (impdecls
);
4614 if (!comptypes (t1
, t2
)
4615 || !tree_int_cst_equal (DECL_INITIAL (intdecls
),
4616 DECL_INITIAL (impdecls
)))
4618 if (DECL_NAME (intdecls
) == DECL_NAME (impdecls
))
4620 error_with_ivar ("conflicting instance variable type",
4622 error_with_ivar ("previous declaration of",
4625 else /* both the type and the name don't match */
4627 error ("inconsistent instance variable specification");
4632 else if (DECL_NAME (intdecls
) != DECL_NAME (impdecls
))
4634 error_with_ivar ("conflicting instance variable name",
4636 error_with_ivar ("previous declaration of",
4640 intdecls
= DECL_CHAIN (intdecls
);
4641 impdecls
= DECL_CHAIN (impdecls
);
4647 mark_referenced_methods (void)
4649 struct imp_entry
*impent
;
4652 for (impent
= imp_list
; impent
; impent
= impent
->next
)
4654 chain
= CLASS_CLS_METHODS (impent
->imp_context
);
4657 cgraph_node::get_create (METHOD_DEFINITION (chain
))->mark_force_output ();
4658 chain
= DECL_CHAIN (chain
);
4661 chain
= CLASS_NST_METHODS (impent
->imp_context
);
4664 cgraph_node::get_create (METHOD_DEFINITION (chain
))->mark_force_output ();
4665 chain
= DECL_CHAIN (chain
);
4670 /* If type is empty or only type qualifiers are present, add default
4671 type of id (otherwise grokdeclarator will default to int). */
4673 adjust_type_for_id_default (tree type
)
4676 type
= make_node (TREE_LIST
);
4678 if (!TREE_VALUE (type
))
4679 TREE_VALUE (type
) = objc_object_type
;
4680 else if (TREE_CODE (TREE_VALUE (type
)) == RECORD_TYPE
4681 && TYPED_OBJECT (TREE_VALUE (type
)))
4682 error ("can not use an object as parameter to a method");
4687 /* Return a KEYWORD_DECL built using the specified key_name, arg_type,
4688 arg_name and attributes. (TODO: Rename KEYWORD_DECL to
4689 OBJC_METHOD_PARM_DECL ?)
4691 A KEYWORD_DECL is a tree representing the declaration of a
4692 parameter of an Objective-C method. It is produced when parsing a
4693 fragment of Objective-C method declaration of the form
4696 selector ':' '(' typename ')' identifier
4698 For example, take the Objective-C method
4700 -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type;
4702 the two fragments "pathForResource:(NSString *)resource" and
4703 "ofType:(NSString *)type" will generate a KEYWORD_DECL each. The
4704 KEYWORD_DECL stores the 'key_name' (eg, identifier for
4705 "pathForResource"), the 'arg_type' (eg, tree representing a
4706 NSString *), the 'arg_name' (eg identifier for "resource") and
4707 potentially some attributes (for example, a tree representing
4708 __attribute__ ((unused)) if such an attribute was attached to a
4709 certain parameter). You can access this information using the
4710 TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name),
4711 KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes).
4713 'key_name' is an identifier node (and is optional as you can omit
4714 it in Objective-C methods).
4715 'arg_type' is a tree list (and is optional too if no parameter type
4717 'arg_name' is an identifier node and is required.
4718 'attributes' is an optional tree containing parameter attributes. */
4720 objc_build_keyword_decl (tree key_name
, tree arg_type
,
4721 tree arg_name
, tree attributes
)
4725 if (flag_objc1_only
&& attributes
)
4726 error_at (input_location
, "method argument attributes are not available in Objective-C 1.0");
4728 /* If no type is specified, default to "id". */
4729 arg_type
= adjust_type_for_id_default (arg_type
);
4731 keyword_decl
= make_node (KEYWORD_DECL
);
4733 TREE_TYPE (keyword_decl
) = arg_type
;
4734 KEYWORD_ARG_NAME (keyword_decl
) = arg_name
;
4735 KEYWORD_KEY_NAME (keyword_decl
) = key_name
;
4736 DECL_ATTRIBUTES (keyword_decl
) = attributes
;
4738 return keyword_decl
;
4741 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
4743 build_keyword_selector (tree selector
)
4746 tree key_chain
, key_name
;
4749 /* Scan the selector to see how much space we'll need. */
4750 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
4752 switch (TREE_CODE (selector
))
4755 key_name
= KEYWORD_KEY_NAME (key_chain
);
4758 key_name
= TREE_PURPOSE (key_chain
);
4765 len
+= IDENTIFIER_LENGTH (key_name
) + 1;
4767 /* Just a ':' arg. */
4771 buf
= (char *) alloca (len
+ 1);
4772 /* Start the buffer out as an empty string. */
4775 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
4777 switch (TREE_CODE (selector
))
4780 key_name
= KEYWORD_KEY_NAME (key_chain
);
4783 key_name
= TREE_PURPOSE (key_chain
);
4784 /* The keyword decl chain will later be used as a function
4785 argument chain. Unhook the selector itself so as to not
4786 confuse other parts of the compiler. */
4787 TREE_PURPOSE (key_chain
) = NULL_TREE
;
4794 strcat (buf
, IDENTIFIER_POINTER (key_name
));
4798 return get_identifier_with_length (buf
, len
);
4801 /* Used for declarations and definitions. */
4804 build_method_decl (enum tree_code code
, tree ret_type
, tree selector
,
4805 tree add_args
, bool ellipsis
)
4809 /* If no type is specified, default to "id". */
4810 ret_type
= adjust_type_for_id_default (ret_type
);
4812 /* Note how a method_decl has a TREE_TYPE which is not the function
4813 type of the function implementing the method, but only the return
4814 type of the method. We may want to change this, and store the
4815 entire function type in there (eg, it may be used to simplify
4816 dealing with attributes below). */
4817 method_decl
= make_node (code
);
4818 TREE_TYPE (method_decl
) = ret_type
;
4820 /* If we have a keyword selector, create an identifier_node that
4821 represents the full selector name (`:' included)... */
4822 if (TREE_CODE (selector
) == KEYWORD_DECL
)
4824 METHOD_SEL_NAME (method_decl
) = build_keyword_selector (selector
);
4825 METHOD_SEL_ARGS (method_decl
) = selector
;
4826 METHOD_ADD_ARGS (method_decl
) = add_args
;
4827 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl
) = ellipsis
;
4831 METHOD_SEL_NAME (method_decl
) = selector
;
4832 METHOD_SEL_ARGS (method_decl
) = NULL_TREE
;
4833 METHOD_ADD_ARGS (method_decl
) = NULL_TREE
;
4839 /* This routine processes objective-c method attributes. */
4842 objc_decl_method_attributes (tree
*node
, tree attributes
, int flags
)
4844 /* TODO: Replace the hackery below. An idea would be to store the
4845 full function type in the method declaration (for example in
4846 TREE_TYPE) and then expose ObjC method declarations to c-family
4847 and they could deal with them by simply treating them as
4850 /* Because of the dangers in the hackery below, we filter out any
4851 attribute that we do not know about. For the ones we know about,
4852 we know that they work with the hackery. For the other ones,
4853 there is no guarantee, so we have to filter them out. */
4854 tree filtered_attributes
= NULL_TREE
;
4859 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
4861 tree name
= TREE_PURPOSE (attribute
);
4863 if (is_attribute_p ("deprecated", name
)
4864 || is_attribute_p ("sentinel", name
)
4865 || is_attribute_p ("noreturn", name
))
4867 /* An attribute that we support; add it to the filtered
4869 filtered_attributes
= chainon (filtered_attributes
,
4870 copy_node (attribute
));
4872 else if (is_attribute_p ("format", name
))
4874 /* "format" is special because before adding it to the
4875 filtered attributes we need to adjust the specified
4876 format by adding the hidden function parameters for
4877 an Objective-C method (self, _cmd). */
4878 tree new_attribute
= copy_node (attribute
);
4880 /* Check the arguments specified with the attribute, and
4881 modify them adding 2 for the two hidden arguments.
4882 Note how this differs from C++; according to the
4883 specs, C++ does not do it so you have to add the +1
4884 yourself. For Objective-C, instead, the compiler
4885 adds the +2 for you. */
4887 /* The attribute arguments have not been checked yet, so
4888 we need to be careful as they could be missing or
4889 invalid. If anything looks wrong, we skip the
4890 process and the compiler will complain about it later
4891 when it validates the attribute. */
4892 /* Check that we have at least three arguments. */
4893 if (TREE_VALUE (new_attribute
)
4894 && TREE_CHAIN (TREE_VALUE (new_attribute
))
4895 && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute
))))
4897 tree second_argument
= TREE_CHAIN (TREE_VALUE (new_attribute
));
4898 tree third_argument
= TREE_CHAIN (second_argument
);
4901 /* This is the second argument, the "string-index",
4902 which specifies the index of the format string
4904 number
= TREE_VALUE (second_argument
);
4906 && TREE_CODE (number
) == INTEGER_CST
4907 && !wi::eq_p (number
, 0))
4908 TREE_VALUE (second_argument
)
4909 = wide_int_to_tree (TREE_TYPE (number
),
4910 wi::add (number
, 2));
4912 /* This is the third argument, the "first-to-check",
4913 which specifies the index of the first argument to
4914 check. This could be 0, meaning it is not available,
4915 in which case we don't need to add 2. Add 2 if not
4917 number
= TREE_VALUE (third_argument
);
4919 && TREE_CODE (number
) == INTEGER_CST
4920 && !wi::eq_p (number
, 0))
4921 TREE_VALUE (third_argument
)
4922 = wide_int_to_tree (TREE_TYPE (number
),
4923 wi::add (number
, 2));
4925 filtered_attributes
= chainon (filtered_attributes
,
4928 else if (is_attribute_p ("nonnull", name
))
4930 /* We need to fixup all the argument indexes by adding 2
4931 for the two hidden arguments of an Objective-C method
4932 invocation, similat to what we do above for the
4933 "format" attribute. */
4934 /* FIXME: This works great in terms of implementing the
4935 functionality, but the warnings that are produced by
4936 nonnull do mention the argument index (while the
4937 format ones don't). For example, you could get
4938 "warning: null argument where non-null required
4939 (argument 3)". Now in that message, "argument 3"
4940 includes the 2 hidden arguments; it would be much
4941 more friendly to call it "argument 1", as that would
4942 be consistent with __attribute__ ((nonnnull (1))).
4943 To do this, we'd need to have the C family code that
4944 checks the arguments know about adding/removing 2 to
4945 the argument index ... or alternatively we could
4946 maybe store the "printable" argument index in
4947 addition to the actual argument index ? Some
4948 refactoring is needed to do this elegantly. */
4949 tree new_attribute
= copy_node (attribute
);
4950 tree argument
= TREE_VALUE (attribute
);
4951 while (argument
!= NULL_TREE
)
4953 /* Get the value of the argument and add 2. */
4954 tree number
= TREE_VALUE (argument
);
4955 if (number
&& TREE_CODE (number
) == INTEGER_CST
4956 && !wi::eq_p (number
, 0))
4957 TREE_VALUE (argument
)
4958 = wide_int_to_tree (TREE_TYPE (number
),
4959 wi::add (number
, 2));
4960 argument
= TREE_CHAIN (argument
);
4963 filtered_attributes
= chainon (filtered_attributes
,
4967 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
4971 if (filtered_attributes
)
4973 /* This hackery changes the TREE_TYPE of the ObjC method
4974 declaration to be a function type, so that decl_attributes
4975 will treat the ObjC method as if it was a function. Some
4976 attributes (sentinel, format) will be applied to the function
4977 type, changing it in place; so after calling decl_attributes,
4978 we extract the function type attributes and store them in
4979 METHOD_TYPE_ATTRIBUTES. Some other attributes (noreturn,
4980 deprecated) are applied directly to the method declaration
4981 (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there
4982 is nothing to do. */
4983 tree saved_type
= TREE_TYPE (*node
);
4985 = build_function_type_for_method (TREE_VALUE (saved_type
), *node
,
4987 decl_attributes (node
, filtered_attributes
, flags
);
4988 METHOD_TYPE_ATTRIBUTES (*node
) = TYPE_ATTRIBUTES (TREE_TYPE (*node
));
4989 TREE_TYPE (*node
) = saved_type
;
4994 objc_method_decl (enum tree_code opcode
)
4996 return opcode
== INSTANCE_METHOD_DECL
|| opcode
== CLASS_METHOD_DECL
;
4999 /* Return a function type for METHOD with RETURN_TYPE. CONTEXT is
5000 either METHOD_DEF or METHOD_REF, indicating whether we are defining a
5001 method or calling one. SUPER_FLAG indicates whether this is a send
5002 to super; this makes a difference for the NeXT calling sequence in
5003 which the lookup and the method call are done together. If METHOD is
5004 NULL, user-defined arguments (i.e., beyond self and _cmd) shall be
5005 represented as varargs. */
5008 build_function_type_for_method (tree return_type
, tree method
,
5009 int context
, bool super_flag
)
5011 vec
<tree
, va_gc
> *argtypes
= make_tree_vector ();
5013 bool is_varargs
= false;
5015 (*runtime
.get_arg_type_list_base
) (&argtypes
, method
, context
, super_flag
);
5017 /* No actual method prototype given; remaining args passed as varargs. */
5018 if (method
== NULL_TREE
)
5024 for (t
= METHOD_SEL_ARGS (method
); t
; t
= DECL_CHAIN (t
))
5026 tree arg_type
= TREE_VALUE (TREE_TYPE (t
));
5028 /* Decay argument types for the underlying C function as
5030 arg_type
= objc_decay_parm_type (arg_type
);
5032 vec_safe_push (argtypes
, arg_type
);
5035 if (METHOD_ADD_ARGS (method
))
5037 for (t
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
5038 t
; t
= TREE_CHAIN (t
))
5040 tree arg_type
= TREE_TYPE (TREE_VALUE (t
));
5042 arg_type
= objc_decay_parm_type (arg_type
);
5044 vec_safe_push (argtypes
, arg_type
);
5047 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
5053 ftype
= build_varargs_function_type_vec (return_type
, argtypes
);
5055 ftype
= build_function_type_vec (return_type
, argtypes
);
5057 release_tree_vector (argtypes
);
5061 /* The 'method' argument is a tree; this tree could either be a single
5062 method, which is returned, or could be a TREE_VEC containing a list
5063 of methods. In that case, the first one is returned, and warnings
5064 are issued as appropriate. */
5066 check_duplicates (tree method
, int methods
, int is_class
)
5071 if (method
== NULL_TREE
)
5074 if (TREE_CODE (method
) != TREE_VEC
)
5077 /* We have two or more methods with the same name but different
5079 first_method
= TREE_VEC_ELT (method
, 0);
5081 /* But just how different are those types? If
5082 -Wno-strict-selector-match is specified, we shall not complain if
5083 the differences are solely among types with identical size and
5085 if (!warn_strict_selector_match
)
5087 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (method
); i
++)
5088 if (!comp_proto_with_proto (first_method
, TREE_VEC_ELT (method
, i
), 0))
5091 return first_method
;
5097 bool type
= TREE_CODE (first_method
) == INSTANCE_METHOD_DECL
;
5099 warning_at (input_location
, 0,
5100 "multiple methods named %<%c%E%> found",
5101 (is_class
? '+' : '-'),
5102 METHOD_SEL_NAME (first_method
));
5103 inform (DECL_SOURCE_LOCATION (first_method
), "using %<%c%s%>",
5105 identifier_to_locale (gen_method_decl (first_method
)));
5109 bool type
= TREE_CODE (first_method
) == INSTANCE_METHOD_DECL
;
5111 warning_at (input_location
, 0,
5112 "multiple selectors named %<%c%E%> found",
5113 (is_class
? '+' : '-'),
5114 METHOD_SEL_NAME (first_method
));
5115 inform (DECL_SOURCE_LOCATION (first_method
), "found %<%c%s%>",
5117 identifier_to_locale (gen_method_decl (first_method
)));
5120 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (method
); i
++)
5122 bool type
= TREE_CODE (TREE_VEC_ELT (method
, i
)) == INSTANCE_METHOD_DECL
;
5124 inform (DECL_SOURCE_LOCATION (TREE_VEC_ELT (method
, i
)), "also found %<%c%s%>",
5126 identifier_to_locale (gen_method_decl (TREE_VEC_ELT (method
, i
))));
5129 return first_method
;
5132 /* If RECEIVER is a class reference, return the identifier node for
5133 the referenced class. RECEIVER is created by objc_get_class_reference,
5134 so we check the exact form created depending on which runtimes are
5138 receiver_is_class_object (tree receiver
, int self
, int super
)
5142 /* The receiver is 'self' or 'super' in the context of a class method. */
5143 if (objc_method_context
5144 && TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
5147 ? CLASS_SUPER_NAME (implementation_template
)
5148 : CLASS_NAME (implementation_template
));
5150 /* The runtime might encapsulate things its own way. */
5151 exp
= (*runtime
.receiver_is_class_object
) (receiver
);
5155 /* The receiver is a function call that returns an id. Check if
5156 it is a call to objc_getClass, if so, pick up the class name.
5158 This is required by the GNU runtime, which compiles
5164 [objc_get_class ("NSObject") alloc];
5166 and then, to check that the receiver responds to the +alloc
5167 method, needs to be able to determine that the objc_get_class()
5168 call returns the NSObject class and not just a generic Class
5171 But, traditionally this is enabled for all runtimes, not just the
5172 GNU one, which means that the compiler is smarter than you'd
5173 expect when dealing with objc_getClass(). For example, with the
5174 Apple runtime, in the code
5176 [objc_getClass ("NSObject") alloc];
5178 the compiler will recognize the objc_getClass() call as special
5179 (due to the code below) and so will know that +alloc is called on
5180 the 'NSObject' class, and can perform the corresponding checks.
5182 Programmers can disable this behaviour by casting the results of
5183 objc_getClass() to 'Class' (this may seem weird because
5184 objc_getClass() is already declared to return 'Class', but the
5185 compiler treats it as a special function). This may be useful if
5186 the class is never declared, and the compiler would complain
5187 about a missing @interface for it. Then, you can do
5189 [(Class)objc_getClass ("MyClassNeverDeclared") alloc];
5191 to silence the warnings. */
5192 if (TREE_CODE (receiver
) == CALL_EXPR
5193 && (exp
= CALL_EXPR_FN (receiver
))
5194 && TREE_CODE (exp
) == ADDR_EXPR
5195 && (exp
= TREE_OPERAND (exp
, 0))
5196 && TREE_CODE (exp
) == FUNCTION_DECL
5197 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
5198 prototypes for objc_get_class(). Thankfully, they seem to share the
5199 same function type. */
5200 && TREE_TYPE (exp
) == TREE_TYPE (objc_get_class_decl
)
5201 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp
)), runtime
.tag_getclass
)
5202 /* We have a call to objc_get_class/objc_getClass! */
5203 && (arg
= CALL_EXPR_ARG (receiver
, 0)))
5206 if (TREE_CODE (arg
) == ADDR_EXPR
5207 && (arg
= TREE_OPERAND (arg
, 0))
5208 && TREE_CODE (arg
) == STRING_CST
)
5209 /* Finally, we have the class name. */
5210 return get_identifier (TREE_STRING_POINTER (arg
));
5215 /* If we are currently building a message expr, this holds
5216 the identifier of the selector of the message. This is
5217 used when printing warnings about argument mismatches. */
5219 static tree current_objc_message_selector
= 0;
5222 objc_message_selector (void)
5224 return current_objc_message_selector
;
5227 /* Construct an expression for sending a message.
5228 MESS has the object to send to in TREE_PURPOSE
5229 and the argument list (including selector) in TREE_VALUE.
5231 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
5232 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
5235 objc_build_message_expr (tree receiver
, tree message_args
)
5239 tree args
= TREE_PURPOSE (message_args
);
5241 tree args
= message_args
;
5243 tree method_params
= NULL_TREE
;
5245 if (TREE_CODE (receiver
) == ERROR_MARK
|| TREE_CODE (args
) == ERROR_MARK
)
5246 return error_mark_node
;
5248 /* Obtain the full selector name. */
5249 switch (TREE_CODE (args
))
5251 case IDENTIFIER_NODE
:
5252 /* A unary selector. */
5256 sel_name
= build_keyword_selector (args
);
5262 /* Build the parameter list to give to the method. */
5263 if (TREE_CODE (args
) == TREE_LIST
)
5265 method_params
= chainon (args
, TREE_VALUE (message_args
));
5268 tree chain
= args
, prev
= NULL_TREE
;
5270 /* We have a keyword selector--check for comma expressions. */
5273 tree element
= TREE_VALUE (chain
);
5275 /* We have a comma expression, must collapse... */
5276 if (TREE_CODE (element
) == TREE_LIST
)
5279 TREE_CHAIN (prev
) = element
;
5284 chain
= TREE_CHAIN (chain
);
5286 method_params
= args
;
5291 if (processing_template_decl
)
5292 /* Must wait until template instantiation time. */
5293 return build_min_nt_loc (UNKNOWN_LOCATION
, MESSAGE_SEND_EXPR
, receiver
,
5294 sel_name
, method_params
);
5297 return objc_finish_message_expr (receiver
, sel_name
, method_params
, NULL
);
5300 /* Look up method SEL_NAME that would be suitable for receiver
5301 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
5302 nonzero), and report on any duplicates. */
5305 lookup_method_in_hash_lists (tree sel_name
, int is_class
)
5307 tree method_prototype
= OBJC_MAP_NOT_FOUND
;
5310 method_prototype
= objc_map_get (instance_method_map
, sel_name
);
5312 if (method_prototype
== OBJC_MAP_NOT_FOUND
)
5314 method_prototype
= objc_map_get (class_method_map
, sel_name
);
5317 if (method_prototype
== OBJC_MAP_NOT_FOUND
)
5321 return check_duplicates (method_prototype
, 1, is_class
);
5324 /* The 'objc_finish_message_expr' routine is called from within
5325 'objc_build_message_expr' for non-template functions. In the case of
5326 C++ template functions, it is called from 'build_expr_from_tree'
5327 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded.
5329 If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn
5330 if the method being used is deprecated. If it is not NULL, instead
5331 of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method
5332 prototype that was used and is deprecated. This is useful for
5333 getter calls that are always generated when compiling dot-syntax
5334 expressions, even if they may not be used. In that case, we don't
5335 want the warning immediately; we produce it (if needed) at gimplify
5336 stage when we are sure that the deprecated getter is being
5339 objc_finish_message_expr (tree receiver
, tree sel_name
, tree method_params
,
5340 tree
*deprecated_method_prototype
)
5342 tree method_prototype
= NULL_TREE
, rprotos
= NULL_TREE
, rtype
;
5343 tree retval
, class_tree
;
5344 int self
, super
, have_cast
;
5346 /* We have used the receiver, so mark it as read. */
5347 mark_exp_read (receiver
);
5349 /* Extract the receiver of the message, as well as its type
5350 (where the latter may take the form of a cast or be inferred
5351 from the implementation context). */
5353 while (TREE_CODE (rtype
) == COMPOUND_EXPR
5354 || TREE_CODE (rtype
) == MODIFY_EXPR
5355 || CONVERT_EXPR_P (rtype
)
5356 || TREE_CODE (rtype
) == COMPONENT_REF
)
5357 rtype
= TREE_OPERAND (rtype
, 0);
5359 /* self is 1 if this is a message to self, 0 otherwise */
5360 self
= (rtype
== self_decl
);
5362 /* super is 1 if this is a message to super, 0 otherwise. */
5363 super
= (rtype
== UOBJC_SUPER_decl
);
5365 /* rtype is the type of the receiver. */
5366 rtype
= TREE_TYPE (receiver
);
5368 /* have_cast is 1 if the receiver is casted. */
5369 have_cast
= (TREE_CODE (receiver
) == NOP_EXPR
5370 || (TREE_CODE (receiver
) == COMPOUND_EXPR
5371 && !IS_SUPER (rtype
)));
5373 /* If we are calling [super dealloc], reset our warning flag. */
5374 if (super
&& !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name
)))
5375 should_call_super_dealloc
= 0;
5377 /* If the receiver is a class object, retrieve the corresponding
5378 @interface, if one exists. class_tree is the class name
5379 identifier, or NULL_TREE if this is not a class method or the
5380 class name could not be determined (as in the case "Class c; [c
5382 class_tree
= receiver_is_class_object (receiver
, self
, super
);
5384 /* Now determine the receiver type (if an explicit cast has not been
5390 /* We are here when we have no cast, and we have a class
5391 name. So, this is a plain method to a class object, as
5392 in [NSObject alloc]. Find the interface corresponding to
5394 rtype
= lookup_interface (class_tree
);
5396 if (rtype
== NULL_TREE
)
5398 /* If 'rtype' is NULL_TREE at this point it means that
5399 we have seen no @interface corresponding to that
5400 class name, only a @class declaration (alternatively,
5401 this was a call such as [objc_getClass("SomeClass")
5402 alloc], where we've never seen the @interface of
5403 SomeClass). So, we have a class name (class_tree)
5404 but no actual details of the class methods. We won't
5405 be able to check that the class responds to the
5406 method, and we will have to guess the method
5407 prototype. Emit a warning, then keep going (this
5408 will use any method with a matching name, as if the
5409 receiver was of type 'Class'). */
5410 warning (0, "@interface of class %qE not found", class_tree
);
5413 /* Handle `self' and `super'. */
5416 if (!CLASS_SUPER_NAME (implementation_template
))
5418 error ("no super class declared in @interface for %qE",
5419 CLASS_NAME (implementation_template
));
5420 return error_mark_node
;
5422 rtype
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
5425 rtype
= lookup_interface (CLASS_NAME (implementation_template
));
5428 if (objc_is_id (rtype
))
5430 /* The receiver is of type 'id' or 'Class' (with or without some
5431 protocols attached to it). */
5433 /* We set class_tree to the identifier for 'Class' if this is a
5434 class method, and to NULL_TREE if not. */
5435 class_tree
= (IS_CLASS (rtype
) ? objc_class_name
: NULL_TREE
);
5437 /* 'rprotos' is the list of protocols that the receiver
5439 rprotos
= (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype
))
5440 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype
))
5443 /* We have no information on the type, and we set it to
5447 /* If there are any protocols, check that the method we are
5448 calling appears in the protocol list. If there are no
5449 protocols, this is a message to 'id' or 'Class' and we accept
5450 any method that exists. */
5453 /* If messaging 'id <Protos>' or 'Class <Proto>', first
5454 search in protocols themselves for the method
5457 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5458 class_tree
!= NULL_TREE
);
5460 /* If messaging 'Class <Proto>' but did not find a class
5461 method prototype, search for an instance method instead,
5462 and warn about having done so. */
5463 if (!method_prototype
&& !rtype
&& class_tree
!= NULL_TREE
)
5466 = lookup_method_in_protocol_list (rprotos
, sel_name
, 0);
5468 if (method_prototype
)
5469 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
5470 sel_name
, sel_name
);
5476 /* We have a receiver type which is more specific than 'id' or
5478 tree orig_rtype
= rtype
;
5480 if (TREE_CODE (rtype
) == POINTER_TYPE
)
5481 rtype
= TREE_TYPE (rtype
);
5482 /* Traverse typedef aliases */
5483 while (TREE_CODE (rtype
) == RECORD_TYPE
&& OBJC_TYPE_NAME (rtype
)
5484 && TREE_CODE (OBJC_TYPE_NAME (rtype
)) == TYPE_DECL
5485 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype
)))
5486 rtype
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype
));
5487 if (TYPED_OBJECT (rtype
))
5489 rprotos
= TYPE_OBJC_PROTOCOL_LIST (rtype
);
5490 rtype
= TYPE_OBJC_INTERFACE (rtype
);
5492 if (!rtype
|| TREE_CODE (rtype
) == IDENTIFIER_NODE
)
5494 /* If we could not find an @interface declaration, we must
5495 have only seen a @class declaration; so, we cannot say
5496 anything more intelligent about which methods the
5497 receiver will understand. Note that this only happens
5498 for instance methods; for class methods to a class where
5499 we have only seen a @class declaration,
5500 lookup_interface() above would have set rtype to
5504 /* We could not find an @interface declaration, yet, if
5505 there are protocols attached to the type, we can
5506 still look up the method in the protocols. Ie, we
5507 are in the following case:
5510 MyClass<MyProtocol> *x;
5513 If 'MyProtocol' has the method 'method', we can check
5514 and retrieve the method prototype. */
5516 = lookup_method_in_protocol_list (rprotos
, sel_name
, 0);
5518 /* At this point, if we have found the method_prototype,
5519 we are quite happy. The details of the class are
5520 irrelevant. If we haven't found it, a warning will
5521 have been produced that the method could not be found
5522 in the protocol, and we won't produce further
5523 warnings (please note that this means that "@class
5524 MyClass; MyClass <MyProtocol> *x;" is exactly
5525 equivalent to "id <MyProtocol> x", which isn't too
5526 satisfactory but it's not easy to see how to do
5533 /* We could not find an @interface declaration, and
5534 there are no protocols attached to the receiver,
5535 so we can't complete the check that the receiver
5536 responds to the method, and we can't retrieve the
5537 method prototype. But, because the receiver has
5538 a well-specified class, the programmer did want
5539 this check to be performed. Emit a warning, then
5540 keep going as if it was an 'id'. To remove the
5541 warning, either include an @interface for the
5542 class, or cast the receiver to 'id'. Note that
5543 rtype is an IDENTIFIER_NODE at this point. */
5544 warning (0, "@interface of class %qE not found", rtype
);
5550 else if (TREE_CODE (rtype
) == CLASS_INTERFACE_TYPE
5551 || TREE_CODE (rtype
) == CLASS_IMPLEMENTATION_TYPE
)
5553 /* We have a valid ObjC class name with an associated
5554 @interface. Look up the method name in the published
5555 @interface for the class (and its superclasses). */
5557 = lookup_method_static (rtype
, sel_name
, class_tree
!= NULL_TREE
);
5559 /* If the method was not found in the @interface, it may still
5560 exist locally as part of the @implementation. */
5561 if (!method_prototype
&& objc_implementation_context
5562 && CLASS_NAME (objc_implementation_context
)
5563 == OBJC_TYPE_NAME (rtype
))
5567 ? CLASS_CLS_METHODS (objc_implementation_context
)
5568 : CLASS_NST_METHODS (objc_implementation_context
)),
5571 /* If we haven't found a candidate method by now, try looking for
5572 it in the protocol list. */
5573 if (!method_prototype
&& rprotos
)
5575 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5576 class_tree
!= NULL_TREE
);
5580 /* We have a type, but it's not an Objective-C type (!). */
5581 warning (0, "invalid receiver type %qs",
5582 identifier_to_locale (gen_type_name (orig_rtype
)));
5583 /* After issuing the "invalid receiver" warning, perform method
5584 lookup as if we were messaging 'id'. */
5585 rtype
= rprotos
= NULL_TREE
;
5588 /* Note that rtype could also be NULL_TREE. This happens if we are
5589 messaging a class by name, but the class was only
5590 forward-declared using @class. */
5592 /* For 'id' or 'Class' receivers, search in the global hash table as
5593 a last resort. For all receivers, warn if protocol searches have
5595 if (!method_prototype
)
5598 warning (0, "%<%c%E%> not found in protocol(s)",
5599 (class_tree
? '+' : '-'),
5604 = lookup_method_in_hash_lists (sel_name
, class_tree
!= NULL_TREE
);
5607 if (!method_prototype
)
5609 static bool warn_missing_methods
= false;
5612 warning (0, "%qE may not respond to %<%c%E%>",
5613 OBJC_TYPE_NAME (rtype
),
5614 (class_tree
? '+' : '-'),
5616 /* If we are messaging an 'id' or 'Class' object and made it here,
5617 then we have failed to find _any_ instance or class method,
5620 warning (0, "no %<%c%E%> method found",
5621 (class_tree
? '+' : '-'),
5624 if (!warn_missing_methods
)
5626 warning_at (input_location
,
5627 0, "(Messages without a matching method signature");
5628 warning_at (input_location
,
5629 0, "will be assumed to return %<id%> and accept");
5630 warning_at (input_location
,
5631 0, "%<...%> as arguments.)");
5632 warn_missing_methods
= true;
5637 /* Warn if the method is deprecated, but not if the receiver is
5638 a generic 'id'. 'id' is used to cast an object to a generic
5639 object of an unspecified class; in that case, we'll use
5640 whatever method prototype we can find to get the method
5641 argument and return types, but it is not appropriate to
5642 produce deprecation warnings since we don't know the class
5643 that the object will be of at runtime. The @interface(s) for
5644 that class may not even be available to the compiler right
5645 now, and it is perfectly possible that the method is marked
5646 as non-deprecated in such @interface(s).
5648 In practice this makes sense since casting an object to 'id'
5649 is often used precisely to turn off warnings associated with
5650 the object being of a particular class. */
5651 if (TREE_DEPRECATED (method_prototype
) && rtype
!= NULL_TREE
)
5653 if (deprecated_method_prototype
)
5654 *deprecated_method_prototype
= method_prototype
;
5656 warn_deprecated_use (method_prototype
, NULL_TREE
);
5660 /* Save the selector name for printing error messages. */
5661 current_objc_message_selector
= sel_name
;
5663 /* Build the method call.
5664 TODO: Get the location from somewhere that will work for delayed
5667 retval
= (*runtime
.build_objc_method_call
) (input_location
, method_prototype
,
5668 receiver
, rtype
, sel_name
,
5669 method_params
, super
);
5671 current_objc_message_selector
= 0;
5677 /* This routine creates a static variable used to implement @protocol(MyProtocol)
5678 expression. This variable will be initialized to global protocol_t meta-data
5681 /* This function is called by the parser when (and only when) a
5682 @protocol() expression is found, in order to compile it. */
5684 objc_build_protocol_expr (tree protoname
)
5686 tree p
= lookup_protocol (protoname
, /* warn if deprecated */ true,
5687 /* definition_required */ false);
5691 error ("cannot find protocol declaration for %qE", protoname
);
5692 return error_mark_node
;
5695 return (*runtime
.get_protocol_reference
) (input_location
, p
);
5698 /* This function is called by the parser when a @selector() expression
5699 is found, in order to compile it. It is only called by the parser
5700 and only to compile a @selector(). LOC is the location of the
5703 objc_build_selector_expr (location_t loc
, tree selnamelist
)
5707 /* Obtain the full selector name. */
5708 switch (TREE_CODE (selnamelist
))
5710 case IDENTIFIER_NODE
:
5711 /* A unary selector. */
5712 selname
= selnamelist
;
5715 selname
= build_keyword_selector (selnamelist
);
5721 /* If we are required to check @selector() expressions as they
5722 are found, check that the selector has been declared. */
5723 if (warn_undeclared_selector
)
5725 /* Look the selector up in the list of all known class and
5726 instance methods (up to this line) to check that the selector
5730 /* First try with instance methods. */
5731 method
= objc_map_get (instance_method_map
, selname
);
5733 /* If not found, try with class methods. */
5734 if (method
== OBJC_MAP_NOT_FOUND
)
5736 method
= objc_map_get (class_method_map
, selname
);
5738 /* If still not found, print out a warning. */
5739 if (method
== OBJC_MAP_NOT_FOUND
)
5740 warning (0, "undeclared selector %qE", selname
);
5744 /* The runtimes do this differently, most particularly, GNU has typed
5745 selectors, whilst NeXT does not. */
5746 return (*runtime
.build_selector_reference
) (loc
, selname
, NULL_TREE
);
5750 build_ivar_reference (tree id
)
5753 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
)
5755 /* Historically, a class method that produced objects (factory
5756 method) would assign `self' to the instance that it
5757 allocated. This would effectively turn the class method into
5758 an instance method. Following this assignment, the instance
5759 variables could be accessed. That practice, while safe,
5760 violates the simple rule that a class method should not refer
5761 to an instance variable. It's better to catch the cases
5762 where this is done unknowingly than to support the above
5764 warning (0, "instance variable %qE accessed in class method",
5766 self_decl
= convert (objc_instance_type
, self_decl
); /* cast */
5769 base
= build_indirect_ref (input_location
, self_decl
, RO_ARROW
);
5770 return (*runtime
.build_ivar_reference
) (input_location
, base
, id
);
5776 instance_method_map
= objc_map_alloc_ggc (1000);
5777 class_method_map
= objc_map_alloc_ggc (1000);
5779 class_name_map
= objc_map_alloc_ggc (200);
5780 alias_name_map
= objc_map_alloc_ggc (200);
5782 /* Initialize the hash table used to hold the constant string objects. */
5783 string_htab
= hash_table
<objc_string_hasher
>::create_ggc (31);
5786 /* Use the following to add a method to class_method_map or
5787 instance_method_map. It will add the method, keyed by the
5788 METHOD_SEL_NAME. If the method already exists, but with one or
5789 more different prototypes, it will store a TREE_VEC in the map,
5790 with the method prototypes in the vector. */
5792 insert_method_into_method_map (bool class_method
, tree method
)
5794 tree method_name
= METHOD_SEL_NAME (method
);
5795 tree existing_entry
;
5799 map
= class_method_map
;
5801 map
= instance_method_map
;
5803 /* Check if the method already exists in the map. */
5804 existing_entry
= objc_map_get (map
, method_name
);
5806 /* If not, we simply add it to the map. */
5807 if (existing_entry
== OBJC_MAP_NOT_FOUND
)
5808 objc_map_put (map
, method_name
, method
);
5813 /* If an entry already exists, it's more complicated. We'll
5814 have to check whether the method prototype is the same or
5816 if (TREE_CODE (existing_entry
) != TREE_VEC
)
5818 /* If the method prototypes are the same, there is nothing
5820 if (comp_proto_with_proto (method
, existing_entry
, 1))
5823 /* If not, create a vector to store both the method already
5824 in the map, and the new one that we are adding. */
5825 new_entry
= make_tree_vec (2);
5827 TREE_VEC_ELT (new_entry
, 0) = existing_entry
;
5828 TREE_VEC_ELT (new_entry
, 1) = method
;
5832 /* An entry already exists, and it's already a vector. This
5833 means that at least 2 different method prototypes were
5834 already found, and we're considering registering yet
5838 /* Check all the existing prototypes. If any matches the
5839 one we need to add, there is nothing to do because it's
5841 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (existing_entry
); i
++)
5842 if (comp_proto_with_proto (method
, TREE_VEC_ELT (existing_entry
, i
), 1))
5845 /* Else, create a new, bigger vector and add the new method
5846 at the end of it. This is inefficient but extremely
5847 rare; in any sane program most methods have a single
5848 prototype, and very few, if any, will have more than
5850 new_entry
= make_tree_vec (TREE_VEC_LENGTH (existing_entry
) + 1);
5852 /* Copy the methods from the existing vector. */
5853 for (i
= 0; i
< (size_t) TREE_VEC_LENGTH (existing_entry
); i
++)
5854 TREE_VEC_ELT (new_entry
, i
) = TREE_VEC_ELT (existing_entry
, i
);
5856 /* Add the new method at the end. */
5857 TREE_VEC_ELT (new_entry
, i
) = method
;
5860 /* Store the new vector in the map. */
5861 objc_map_put (map
, method_name
, new_entry
);
5867 lookup_method (tree mchain
, tree method
)
5871 if (TREE_CODE (method
) == IDENTIFIER_NODE
)
5874 key
= METHOD_SEL_NAME (method
);
5878 if (METHOD_SEL_NAME (mchain
) == key
)
5881 mchain
= DECL_CHAIN (mchain
);
5886 /* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance
5887 method in INTERFACE, along with any categories and protocols
5888 attached thereto. If method is not found, and the
5889 OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the
5890 INTERFACE's superclass. If OBJC_LOOKUP_CLASS is set,
5891 OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could
5892 be found in INTERFACE or any of its superclasses, look for an
5893 _instance_ method of the same name in the root class as a last
5894 resort. This behaviour can be turned off by using
5895 OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS.
5897 If a suitable method cannot be found, return NULL_TREE. */
5900 lookup_method_static (tree interface
, tree ident
, int flags
)
5902 tree meth
= NULL_TREE
, root_inter
= NULL_TREE
;
5903 tree inter
= interface
;
5904 int is_class
= (flags
& OBJC_LOOKUP_CLASS
);
5905 int no_superclasses
= (flags
& OBJC_LOOKUP_NO_SUPER
);
5906 int no_instance_methods_of_root_class
= (flags
& OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS
);
5910 tree chain
= is_class
? CLASS_CLS_METHODS (inter
) : CLASS_NST_METHODS (inter
);
5911 tree category
= inter
;
5913 /* First, look up the method in the class itself. */
5914 if ((meth
= lookup_method (chain
, ident
)))
5917 /* Failing that, look for the method in each category of the class. */
5918 while ((category
= CLASS_CATEGORY_LIST (category
)))
5920 chain
= is_class
? CLASS_CLS_METHODS (category
) : CLASS_NST_METHODS (category
);
5922 /* Check directly in each category. */
5923 if ((meth
= lookup_method (chain
, ident
)))
5926 /* Failing that, check in each category's protocols. */
5927 if (CLASS_PROTOCOL_LIST (category
))
5929 if ((meth
= (lookup_method_in_protocol_list
5930 (CLASS_PROTOCOL_LIST (category
), ident
, is_class
))))
5935 /* If not found in categories, check in protocols of the main class. */
5936 if (CLASS_PROTOCOL_LIST (inter
))
5938 if ((meth
= (lookup_method_in_protocol_list
5939 (CLASS_PROTOCOL_LIST (inter
), ident
, is_class
))))
5943 /* If we were instructed not to look in superclasses, don't. */
5944 if (no_superclasses
)
5947 /* Failing that, climb up the inheritance hierarchy. */
5949 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
5953 if (is_class
&& !no_instance_methods_of_root_class
)
5955 /* If no class (factory) method was found, check if an _instance_
5956 method of the same name exists in the root class. This is what
5957 the Objective-C runtime will do. */
5958 return lookup_method_static (root_inter
, ident
, 0);
5962 /* If an instance method was not found, return 0. */
5968 objc_add_method (tree klass
, tree method
, int is_class
, bool is_optional
)
5970 tree existing_method
= NULL_TREE
;
5972 /* The first thing we do is look up the method in the list of
5973 methods already defined in the interface (or implementation). */
5975 existing_method
= lookup_method (CLASS_CLS_METHODS (klass
), method
);
5977 existing_method
= lookup_method (CLASS_NST_METHODS (klass
), method
);
5979 /* In the case of protocols, we have a second list of methods to
5980 consider, the list of optional ones. */
5981 if (TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
)
5983 /* @required methods are added to the protocol's normal list.
5984 @optional methods are added to the protocol's OPTIONAL lists.
5985 Note that adding the methods to the optional lists disables
5986 checking that the methods are implemented by classes
5987 implementing the protocol, since these checks only use the
5988 CLASS_CLS_METHODS and CLASS_NST_METHODS. */
5990 /* First of all, if the method to add is @optional, and we found
5991 it already existing as @required, emit an error. */
5992 if (is_optional
&& existing_method
)
5994 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
5995 (is_class
? '+' : '-'),
5996 METHOD_SEL_NAME (existing_method
));
5997 inform (DECL_SOURCE_LOCATION (existing_method
),
5998 "previous declaration of %<%c%E%> as %<@required%>",
5999 (is_class
? '+' : '-'),
6000 METHOD_SEL_NAME (existing_method
));
6003 /* Now check the list of @optional methods if we didn't find the
6004 method in the @required list. */
6005 if (!existing_method
)
6008 existing_method
= lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass
), method
);
6010 existing_method
= lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass
), method
);
6012 if (!is_optional
&& existing_method
)
6014 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
6015 (is_class
? '+' : '-'),
6016 METHOD_SEL_NAME (existing_method
));
6017 inform (DECL_SOURCE_LOCATION (existing_method
),
6018 "previous declaration of %<%c%E%> as %<@optional%>",
6019 (is_class
? '+' : '-'),
6020 METHOD_SEL_NAME (existing_method
));
6025 /* If the method didn't exist already, add it. */
6026 if (!existing_method
)
6032 /* Put the method on the list in reverse order. */
6033 TREE_CHAIN (method
) = PROTOCOL_OPTIONAL_CLS_METHODS (klass
);
6034 PROTOCOL_OPTIONAL_CLS_METHODS (klass
) = method
;
6038 TREE_CHAIN (method
) = PROTOCOL_OPTIONAL_NST_METHODS (klass
);
6039 PROTOCOL_OPTIONAL_NST_METHODS (klass
) = method
;
6046 DECL_CHAIN (method
) = CLASS_CLS_METHODS (klass
);
6047 CLASS_CLS_METHODS (klass
) = method
;
6051 DECL_CHAIN (method
) = CLASS_NST_METHODS (klass
);
6052 CLASS_NST_METHODS (klass
) = method
;
6058 /* The method was already defined. Check that the types match
6059 for an @interface for a class or category, or for a
6060 @protocol. Give hard errors on methods with identical
6061 selectors but differing argument and/or return types. We do
6062 not do this for @implementations, because C/C++ will do it
6063 for us (i.e., there will be duplicate function definition
6065 if ((TREE_CODE (klass
) == CLASS_INTERFACE_TYPE
6066 || TREE_CODE (klass
) == CATEGORY_INTERFACE_TYPE
6067 /* Starting with GCC 4.6, we emit the same error for
6068 protocols too. The situation is identical to
6069 @interfaces as there is no possible meaningful reason
6070 for defining the same method with different signatures
6071 in the very same @protocol. If that was allowed,
6072 whenever the protocol is used (both at compile and run
6073 time) there wouldn't be any meaningful way to decide
6074 which of the two method signatures should be used. */
6075 || TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
)
6076 && !comp_proto_with_proto (method
, existing_method
, 1))
6078 error ("duplicate declaration of method %<%c%E%> with conflicting types",
6079 (is_class
? '+' : '-'),
6080 METHOD_SEL_NAME (existing_method
));
6081 inform (DECL_SOURCE_LOCATION (existing_method
),
6082 "previous declaration of %<%c%E%>",
6083 (is_class
? '+' : '-'),
6084 METHOD_SEL_NAME (existing_method
));
6089 insert_method_into_method_map (true, method
);
6092 insert_method_into_method_map (false, method
);
6094 /* Instance methods in root classes (and categories thereof)
6095 may act as class methods as a last resort. We also add
6096 instance methods listed in @protocol declarations to
6097 the class hash table, on the assumption that @protocols
6098 may be adopted by root classes or categories. */
6099 if (TREE_CODE (klass
) == CATEGORY_INTERFACE_TYPE
6100 || TREE_CODE (klass
) == CATEGORY_IMPLEMENTATION_TYPE
)
6101 klass
= lookup_interface (CLASS_NAME (klass
));
6103 if (TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
6104 || !CLASS_SUPER_NAME (klass
))
6105 insert_method_into_method_map (true, method
);
6112 add_category (tree klass
, tree category
)
6114 /* Put categories on list in reverse order. */
6115 tree cat
= lookup_category (klass
, CLASS_SUPER_NAME (category
));
6119 warning (0, "duplicate interface declaration for category %<%E(%E)%>",
6121 CLASS_SUPER_NAME (category
));
6125 CLASS_CATEGORY_LIST (category
) = CLASS_CATEGORY_LIST (klass
);
6126 CLASS_CATEGORY_LIST (klass
) = category
;
6131 /* A flexible array member is a C99 extension where you can use
6132 "type[]" at the end of a struct to mean a variable-length array.
6134 In Objective-C, instance variables are fundamentally members of a
6135 struct, but the struct can always be extended by subclassing; hence
6136 we need to detect and forbid all instance variables declared using
6137 flexible array members.
6139 No check for this is needed in Objective-C++, since C++ does not
6140 have flexible array members. */
6142 /* Determine whether TYPE is a structure with a flexible array member,
6143 a union containing such a structure (possibly recursively) or an
6144 array of such structures or unions. These are all invalid as
6145 instance variable. */
6147 flexible_array_type_p (tree type
)
6150 switch (TREE_CODE (type
))
6153 x
= TYPE_FIELDS (type
);
6156 while (DECL_CHAIN (x
) != NULL_TREE
)
6158 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
6159 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
6160 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
6161 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
6165 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
6167 if (flexible_array_type_p (TREE_TYPE (x
)))
6171 /* Note that we also check for arrays of something that uses a flexible array member. */
6173 if (flexible_array_type_p (TREE_TYPE (type
)))
6182 /* Produce a printable version of an ivar name. This is only used
6183 inside add_instance_variable. */
6185 printable_ivar_name (tree field_decl
)
6187 if (DECL_NAME (field_decl
))
6188 return identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl
)));
6190 return _("<unnamed>");
6193 /* Called after parsing each instance variable declaration. Necessary to
6194 preserve typedefs and implement public/private...
6196 VISIBILITY is 1 for public, 0 for protected, and 2 for private. */
6199 add_instance_variable (tree klass
, objc_ivar_visibility_kind visibility
,
6202 tree field_type
= TREE_TYPE (field_decl
);
6205 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
6207 error ("illegal reference type specified for instance variable %qs",
6208 printable_ivar_name (field_decl
));
6209 /* Return class as is without adding this ivar. */
6214 if (field_type
== error_mark_node
|| !TYPE_SIZE (field_type
)
6215 || TYPE_SIZE (field_type
) == error_mark_node
)
6216 /* 'type[0]' is allowed, but 'type[]' is not! */
6218 error ("instance variable %qs has unknown size",
6219 printable_ivar_name (field_decl
));
6220 /* Return class as is without adding this ivar. */
6225 /* Also, in C reject a struct with a flexible array member. Ie,
6227 struct A { int x; int[] y; };
6231 struct A instance_variable;
6235 is not valid because if the class is subclassed, we wouldn't be able
6236 to calculate the offset of the next instance variable. */
6237 if (flexible_array_type_p (field_type
))
6239 error ("instance variable %qs uses flexible array member",
6240 printable_ivar_name (field_decl
));
6241 /* Return class as is without adding this ivar. */
6247 /* Check if the ivar being added has a non-POD C++ type. If so, we will
6248 need to either (1) warn the user about it or (2) generate suitable
6249 constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct'
6250 methods (if '-fobjc-call-cxx-cdtors' was specified). */
6251 if (MAYBE_CLASS_TYPE_P (field_type
)
6252 && (TYPE_NEEDS_CONSTRUCTING (field_type
)
6253 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
)
6254 || TYPE_POLYMORPHIC_P (field_type
)))
6256 tree type_name
= OBJC_TYPE_NAME (field_type
);
6258 if (flag_objc_call_cxx_cdtors
)
6260 /* Since the ObjC runtime will be calling the constructors and
6261 destructors for us, the only thing we can't handle is the lack
6262 of a default constructor. */
6263 if (TYPE_NEEDS_CONSTRUCTING (field_type
)
6264 && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type
))
6266 warning (0, "type %qE has no default constructor to call",
6269 /* If we cannot call a constructor, we should also avoid
6270 calling the destructor, for symmetry. */
6271 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6272 warning (0, "destructor for %qE shall not be run either",
6278 static bool warn_cxx_ivars
= false;
6280 if (TYPE_POLYMORPHIC_P (field_type
))
6282 /* Vtable pointers are Real Bad(tm), since Obj-C cannot
6284 error ("type %qE has virtual member functions", type_name
);
6285 error ("illegal aggregate type %qE specified "
6286 "for instance variable %qs",
6287 type_name
, printable_ivar_name (field_decl
));
6288 /* Return class as is without adding this ivar. */
6292 /* User-defined constructors and destructors are not known to Obj-C
6293 and hence will not be called. This may or may not be a problem. */
6294 if (TYPE_NEEDS_CONSTRUCTING (field_type
))
6295 warning (0, "type %qE has a user-defined constructor", type_name
);
6296 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6297 warning (0, "type %qE has a user-defined destructor", type_name
);
6299 if (!warn_cxx_ivars
)
6301 warning (0, "C++ constructors and destructors will not "
6302 "be invoked for Objective-C fields");
6303 warn_cxx_ivars
= true;
6309 /* Overload the public attribute, it is not used for FIELD_DECLs. */
6312 case OBJC_IVAR_VIS_PROTECTED
:
6313 TREE_PUBLIC (field_decl
) = 0;
6314 TREE_PRIVATE (field_decl
) = 0;
6315 TREE_PROTECTED (field_decl
) = 1;
6318 case OBJC_IVAR_VIS_PACKAGE
:
6319 /* TODO: Implement the package variant. */
6320 case OBJC_IVAR_VIS_PUBLIC
:
6321 TREE_PUBLIC (field_decl
) = 1;
6322 TREE_PRIVATE (field_decl
) = 0;
6323 TREE_PROTECTED (field_decl
) = 0;
6326 case OBJC_IVAR_VIS_PRIVATE
:
6327 TREE_PUBLIC (field_decl
) = 0;
6328 TREE_PRIVATE (field_decl
) = 1;
6329 TREE_PROTECTED (field_decl
) = 0;
6334 CLASS_RAW_IVARS (klass
) = chainon (CLASS_RAW_IVARS (klass
), field_decl
);
6339 /* True if the ivar is private and we are not in its implementation. */
6342 is_private (tree decl
)
6344 return (TREE_PRIVATE (decl
)
6345 && ! is_ivar (CLASS_IVARS (implementation_template
),
6349 /* Searches all the instance variables of 'klass' and of its
6350 superclasses for an instance variable whose name (identifier) is
6351 'ivar_name_ident'. Return the declaration (DECL) of the instance
6352 variable, if found, or NULL_TREE, if not found. */
6354 ivar_of_class (tree klass
, tree ivar_name_ident
)
6356 /* First, look up the ivar in CLASS_RAW_IVARS. */
6357 tree decl_chain
= CLASS_RAW_IVARS (klass
);
6359 for ( ; decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
6360 if (DECL_NAME (decl_chain
) == ivar_name_ident
)
6363 /* If not found, search up the class hierarchy. */
6364 while (CLASS_SUPER_NAME (klass
))
6366 klass
= lookup_interface (CLASS_SUPER_NAME (klass
));
6368 decl_chain
= CLASS_RAW_IVARS (klass
);
6370 for ( ; decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
6371 if (DECL_NAME (decl_chain
) == ivar_name_ident
)
6378 /* We have an instance variable reference;, check to see if it is public. */
6381 objc_is_public (tree expr
, tree identifier
)
6383 tree basetype
, decl
;
6386 if (processing_template_decl
)
6390 if (TREE_TYPE (expr
) == error_mark_node
)
6393 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
6395 if (basetype
&& TREE_CODE (basetype
) == RECORD_TYPE
)
6397 if (TYPE_HAS_OBJC_INFO (basetype
) && TYPE_OBJC_INTERFACE (basetype
))
6399 tree klass
= lookup_interface (OBJC_TYPE_NAME (basetype
));
6403 error ("cannot find interface declaration for %qE",
6404 OBJC_TYPE_NAME (basetype
));
6408 if ((decl
= ivar_of_class (klass
, identifier
)))
6410 if (TREE_PUBLIC (decl
))
6413 /* Important difference between the Stepstone translator:
6414 all instance variables should be public within the context
6415 of the implementation. */
6416 if (objc_implementation_context
6417 && ((TREE_CODE (objc_implementation_context
)
6418 == CLASS_IMPLEMENTATION_TYPE
)
6419 || (TREE_CODE (objc_implementation_context
)
6420 == CATEGORY_IMPLEMENTATION_TYPE
)))
6422 tree curtype
= TYPE_MAIN_VARIANT
6423 (CLASS_STATIC_TEMPLATE
6424 (implementation_template
));
6426 if (basetype
== curtype
6427 || DERIVED_FROM_P (basetype
, curtype
))
6429 int priv
= is_private (decl
);
6432 error ("instance variable %qE is declared private",
6439 /* The 2.95.2 compiler sometimes allowed C functions to access
6440 non-@public ivars. We will let this slide for now... */
6441 if (!objc_method_context
)
6443 warning (0, "instance variable %qE is %s; "
6444 "this will be a hard error in the future",
6446 TREE_PRIVATE (decl
) ? "@private" : "@protected");
6450 error ("instance variable %qE is declared %s",
6452 TREE_PRIVATE (decl
) ? "private" : "protected");
6461 /* Make sure all methods in CHAIN (a list of method declarations from
6462 an @interface or a @protocol) are in IMPLEMENTATION (the
6463 implementation context). This is used to check for example that
6464 all methods declared in an @interface were implemented in an
6467 Some special methods (property setters/getters) are special and if
6468 they are not found in IMPLEMENTATION, we look them up in its
6472 check_methods (tree chain
, tree implementation
, int mtype
)
6477 if (mtype
== (int)'+')
6478 list
= CLASS_CLS_METHODS (implementation
);
6480 list
= CLASS_NST_METHODS (implementation
);
6484 /* If the method is associated with a dynamic property, then it
6485 is Ok not to have the method implementation, as it will be
6486 generated dynamically at runtime. To decide if the method is
6487 associated with a @dynamic property, we search the list of
6488 @synthesize and @dynamic for this implementation, and look
6489 for any @dynamic property with the same setter or getter name
6492 for (x
= IMPL_PROPERTY_DECL (implementation
); x
; x
= TREE_CHAIN (x
))
6493 if (PROPERTY_DYNAMIC (x
)
6494 && (PROPERTY_GETTER_NAME (x
) == METHOD_SEL_NAME (chain
)
6495 || PROPERTY_SETTER_NAME (x
) == METHOD_SEL_NAME (chain
)))
6500 chain
= TREE_CHAIN (chain
); /* next method... */
6504 if (!lookup_method (list
, chain
))
6506 /* If the method is a property setter/getter, we'll still
6507 allow it to be missing if it is implemented by
6508 'interface' or any of its superclasses. */
6509 tree property
= METHOD_PROPERTY_CONTEXT (chain
);
6512 /* Note that since this is a property getter/setter, it
6513 is obviously an instance method. */
6514 tree interface
= NULL_TREE
;
6516 /* For a category, first check the main class
6518 if (TREE_CODE (implementation
) == CATEGORY_IMPLEMENTATION_TYPE
)
6520 interface
= lookup_interface (CLASS_NAME (implementation
));
6522 /* If the method is found in the main class, it's Ok. */
6523 if (lookup_method (CLASS_NST_METHODS (interface
), chain
))
6525 chain
= DECL_CHAIN (chain
);
6529 /* Else, get the superclass. */
6530 if (CLASS_SUPER_NAME (interface
))
6531 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
6533 interface
= NULL_TREE
;
6536 /* Get the superclass for classes. */
6537 if (TREE_CODE (implementation
) == CLASS_IMPLEMENTATION_TYPE
)
6539 if (CLASS_SUPER_NAME (implementation
))
6540 interface
= lookup_interface (CLASS_SUPER_NAME (implementation
));
6542 interface
= NULL_TREE
;
6545 /* Now, interface is the superclass, if any; go check it. */
6548 if (lookup_method_static (interface
, chain
, 0))
6550 chain
= DECL_CHAIN (chain
);
6554 /* Else, fall through - warn. */
6558 switch (TREE_CODE (implementation
))
6560 case CLASS_IMPLEMENTATION_TYPE
:
6561 warning (0, "incomplete implementation of class %qE",
6562 CLASS_NAME (implementation
));
6564 case CATEGORY_IMPLEMENTATION_TYPE
:
6565 warning (0, "incomplete implementation of category %qE",
6566 CLASS_SUPER_NAME (implementation
));
6574 warning (0, "method definition for %<%c%E%> not found",
6575 mtype
, METHOD_SEL_NAME (chain
));
6578 chain
= DECL_CHAIN (chain
);
6584 /* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */
6587 conforms_to_protocol (tree klass
, tree protocol
)
6589 if (TREE_CODE (protocol
) == PROTOCOL_INTERFACE_TYPE
)
6591 tree p
= CLASS_PROTOCOL_LIST (klass
);
6592 while (p
&& TREE_VALUE (p
) != protocol
)
6597 tree super
= (CLASS_SUPER_NAME (klass
)
6598 ? lookup_interface (CLASS_SUPER_NAME (klass
))
6600 int tmp
= super
? conforms_to_protocol (super
, protocol
) : 0;
6609 /* Make sure all methods in CHAIN are accessible as MTYPE methods in
6610 CONTEXT. This is one of two mechanisms to check protocol integrity. */
6613 check_methods_accessible (tree chain
, tree context
, int mtype
)
6617 tree base_context
= context
;
6621 /* If the method is associated with a dynamic property, then it
6622 is Ok not to have the method implementation, as it will be
6623 generated dynamically at runtime. Search for any @dynamic
6624 property with the same setter or getter name as this
6625 method. TODO: Use a hashtable lookup. */
6627 for (x
= IMPL_PROPERTY_DECL (base_context
); x
; x
= TREE_CHAIN (x
))
6628 if (PROPERTY_DYNAMIC (x
)
6629 && (PROPERTY_GETTER_NAME (x
) == METHOD_SEL_NAME (chain
)
6630 || PROPERTY_SETTER_NAME (x
) == METHOD_SEL_NAME (chain
)))
6635 chain
= TREE_CHAIN (chain
); /* next method... */
6639 context
= base_context
;
6643 list
= CLASS_CLS_METHODS (context
);
6645 list
= CLASS_NST_METHODS (context
);
6647 if (lookup_method (list
, chain
))
6650 switch (TREE_CODE (context
))
6652 case CLASS_IMPLEMENTATION_TYPE
:
6653 case CLASS_INTERFACE_TYPE
:
6654 context
= (CLASS_SUPER_NAME (context
)
6655 ? lookup_interface (CLASS_SUPER_NAME (context
))
6658 case CATEGORY_IMPLEMENTATION_TYPE
:
6659 case CATEGORY_INTERFACE_TYPE
:
6660 context
= (CLASS_NAME (context
)
6661 ? lookup_interface (CLASS_NAME (context
))
6669 if (context
== NULL_TREE
)
6673 switch (TREE_CODE (objc_implementation_context
))
6675 case CLASS_IMPLEMENTATION_TYPE
:
6676 warning (0, "incomplete implementation of class %qE",
6677 CLASS_NAME (objc_implementation_context
));
6679 case CATEGORY_IMPLEMENTATION_TYPE
:
6680 warning (0, "incomplete implementation of category %qE",
6681 CLASS_SUPER_NAME (objc_implementation_context
));
6688 warning (0, "method definition for %<%c%E%> not found",
6689 mtype
, METHOD_SEL_NAME (chain
));
6692 chain
= TREE_CHAIN (chain
); /* next method... */
6697 /* Check whether the current interface (accessible via
6698 'objc_implementation_context') actually implements protocol P, along
6699 with any protocols that P inherits. */
6702 check_protocol (tree p
, const char *type
, tree name
)
6704 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
6708 /* Ensure that all protocols have bodies! */
6711 f1
= check_methods (PROTOCOL_CLS_METHODS (p
),
6712 objc_implementation_context
,
6714 f2
= check_methods (PROTOCOL_NST_METHODS (p
),
6715 objc_implementation_context
,
6720 f1
= check_methods_accessible (PROTOCOL_CLS_METHODS (p
),
6721 objc_implementation_context
,
6723 f2
= check_methods_accessible (PROTOCOL_NST_METHODS (p
),
6724 objc_implementation_context
,
6729 warning (0, "%s %qE does not fully implement the %qE protocol",
6730 type
, name
, PROTOCOL_NAME (p
));
6733 /* Check protocols recursively. */
6734 if (PROTOCOL_LIST (p
))
6736 tree subs
= PROTOCOL_LIST (p
);
6738 lookup_interface (CLASS_SUPER_NAME (implementation_template
));
6742 tree sub
= TREE_VALUE (subs
);
6744 /* If the superclass does not conform to the protocols
6745 inherited by P, then we must! */
6746 if (!super_class
|| !conforms_to_protocol (super_class
, sub
))
6747 check_protocol (sub
, type
, name
);
6748 subs
= TREE_CHAIN (subs
);
6753 /* Check whether the current interface (accessible via
6754 'objc_implementation_context') actually implements the protocols listed
6758 check_protocols (tree proto_list
, const char *type
, tree name
)
6760 for ( ; proto_list
; proto_list
= TREE_CHAIN (proto_list
))
6762 tree p
= TREE_VALUE (proto_list
);
6764 check_protocol (p
, type
, name
);
6768 /* Make sure that the class CLASS_NAME is defined CODE says which kind
6769 of thing CLASS_NAME ought to be. It can be CLASS_INTERFACE_TYPE,
6770 CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or
6771 CATEGORY_IMPLEMENTATION_TYPE. For a CATEGORY_INTERFACE_TYPE,
6772 SUPER_NAME is the name of the category. For a class extension,
6773 CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE. */
6775 start_class (enum tree_code code
, tree class_name
, tree super_name
,
6776 tree protocol_list
, tree attributes
)
6778 tree klass
= NULL_TREE
;
6782 if (current_namespace
!= global_namespace
)
6784 error ("Objective-C declarations may only appear in global scope");
6786 #endif /* OBJCPLUS */
6788 if (objc_implementation_context
)
6790 warning (0, "%<@end%> missing in implementation context");
6791 finish_class (objc_implementation_context
);
6792 objc_ivar_chain
= NULL_TREE
;
6793 objc_implementation_context
= NULL_TREE
;
6796 /* If this is a class extension, we'll be "reopening" the existing
6797 CLASS_INTERFACE_TYPE, so in that case there is no need to create
6799 if (code
!= CATEGORY_INTERFACE_TYPE
|| super_name
!= NULL_TREE
)
6801 klass
= make_node (code
);
6802 TYPE_LANG_SLOT_1 (klass
) = make_tree_vec (CLASS_LANG_SLOT_ELTS
);
6805 /* Check for existence of the super class, if one was specified. Note
6806 that we must have seen an @interface, not just a @class. If we
6807 are looking at a @compatibility_alias, traverse it first. */
6808 if ((code
== CLASS_INTERFACE_TYPE
|| code
== CLASS_IMPLEMENTATION_TYPE
)
6811 tree super
= objc_is_class_name (super_name
);
6812 tree super_interface
= NULL_TREE
;
6815 super_interface
= lookup_interface (super
);
6817 if (!super_interface
)
6819 error ("cannot find interface declaration for %qE, superclass of %qE",
6820 super
? super
: super_name
,
6822 super_name
= NULL_TREE
;
6826 if (TREE_DEPRECATED (super_interface
))
6827 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated",
6833 if (code
!= CATEGORY_INTERFACE_TYPE
|| super_name
!= NULL_TREE
)
6835 CLASS_NAME (klass
) = class_name
;
6836 CLASS_SUPER_NAME (klass
) = super_name
;
6837 CLASS_CLS_METHODS (klass
) = NULL_TREE
;
6840 if (! objc_is_class_name (class_name
)
6841 && (decl
= lookup_name (class_name
)))
6843 error ("%qE redeclared as different kind of symbol",
6845 error ("previous declaration of %q+D",
6851 case CLASS_IMPLEMENTATION_TYPE
:
6855 for (chain
= implemented_classes
; chain
; chain
= TREE_CHAIN (chain
))
6856 if (TREE_VALUE (chain
) == class_name
)
6858 error ("reimplementation of class %qE",
6860 /* TODO: error message saying where it was previously
6864 if (chain
== NULL_TREE
)
6865 implemented_classes
= tree_cons (NULL_TREE
, class_name
,
6866 implemented_classes
);
6869 /* Reset for multiple classes per file. */
6872 objc_implementation_context
= klass
;
6874 /* Lookup the interface for this implementation. */
6876 if (!(implementation_template
= lookup_interface (class_name
)))
6878 warning (0, "cannot find interface declaration for %qE",
6880 add_interface (implementation_template
= objc_implementation_context
,
6884 /* If a super class has been specified in the implementation,
6885 insure it conforms to the one specified in the interface. */
6888 && (super_name
!= CLASS_SUPER_NAME (implementation_template
)))
6890 tree previous_name
= CLASS_SUPER_NAME (implementation_template
);
6891 error ("conflicting super class name %qE",
6894 error ("previous declaration of %qE", previous_name
);
6896 error ("previous declaration");
6899 else if (! super_name
)
6901 CLASS_SUPER_NAME (objc_implementation_context
)
6902 = CLASS_SUPER_NAME (implementation_template
);
6906 case CLASS_INTERFACE_TYPE
:
6907 if (lookup_interface (class_name
))
6909 error ("duplicate interface declaration for class %qE", class_name
);
6911 warning (0, "duplicate interface declaration for class %qE", class_name
);
6914 add_interface (klass
, class_name
);
6917 CLASS_PROTOCOL_LIST (klass
)
6918 = lookup_and_install_protocols (protocol_list
, /* definition_required */ true);
6923 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
6925 tree name
= TREE_PURPOSE (attribute
);
6927 /* TODO: Document what the objc_exception attribute is/does. */
6928 /* We handle the 'deprecated' and (undocumented) 'objc_exception'
6930 if (is_attribute_p ("deprecated", name
))
6931 TREE_DEPRECATED (klass
) = 1;
6932 else if (is_attribute_p ("objc_exception", name
))
6933 CLASS_HAS_EXCEPTION_ATTR (klass
) = 1;
6935 /* Warn about and ignore all others for now, but store them. */
6936 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
6938 TYPE_ATTRIBUTES (klass
) = attributes
;
6942 case CATEGORY_INTERFACE_TYPE
:
6944 tree class_category_is_assoc_with
;
6946 /* For a category, class_name is really the name of the class that
6947 the following set of methods will be associated with. We must
6948 find the interface so that can derive the objects template. */
6949 if (!(class_category_is_assoc_with
= lookup_interface (class_name
)))
6951 error ("cannot find interface declaration for %qE",
6953 exit (FATAL_EXIT_CODE
);
6957 if (TREE_DEPRECATED (class_category_is_assoc_with
))
6958 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated",
6961 if (super_name
== NULL_TREE
)
6963 /* This is a class extension. Get the original
6964 interface, and continue working on it. */
6965 objc_in_class_extension
= true;
6966 klass
= class_category_is_assoc_with
;
6970 /* Append protocols to the original protocol
6972 CLASS_PROTOCOL_LIST (klass
)
6973 = chainon (CLASS_PROTOCOL_LIST (klass
),
6974 lookup_and_install_protocols
6976 /* definition_required */ true));
6981 add_category (class_category_is_assoc_with
, klass
);
6984 CLASS_PROTOCOL_LIST (klass
)
6985 = lookup_and_install_protocols
6986 (protocol_list
, /* definition_required */ true);
6992 case CATEGORY_IMPLEMENTATION_TYPE
:
6993 /* Reset for multiple classes per file. */
6996 objc_implementation_context
= klass
;
6998 /* For a category, class_name is really the name of the class that
6999 the following set of methods will be associated with. We must
7000 find the interface so that can derive the objects template. */
7002 if (!(implementation_template
= lookup_interface (class_name
)))
7004 error ("cannot find interface declaration for %qE",
7006 exit (FATAL_EXIT_CODE
);
7016 continue_class (tree klass
)
7018 switch (TREE_CODE (klass
))
7020 case CLASS_IMPLEMENTATION_TYPE
:
7021 case CATEGORY_IMPLEMENTATION_TYPE
:
7023 struct imp_entry
*imp_entry
;
7025 /* Check consistency of the instance variables. */
7027 if (CLASS_RAW_IVARS (klass
))
7028 check_ivars (implementation_template
, klass
);
7030 /* code generation */
7032 push_lang_context (lang_name_c
);
7034 build_private_template (implementation_template
);
7035 uprivate_record
= CLASS_STATIC_TEMPLATE (implementation_template
);
7036 objc_instance_type
= build_pointer_type (uprivate_record
);
7038 imp_entry
= ggc_alloc
<struct imp_entry
> ();
7040 imp_entry
->next
= imp_list
;
7041 imp_entry
->imp_context
= klass
;
7042 imp_entry
->imp_template
= implementation_template
;
7043 ucls_super_ref
= uucls_super_ref
= NULL
;
7044 if (TREE_CODE (klass
) == CLASS_IMPLEMENTATION_TYPE
)
7046 imp_entry
->class_decl
= (*runtime
.class_decl
) (klass
);
7047 imp_entry
->meta_decl
= (*runtime
.metaclass_decl
) (klass
);
7051 imp_entry
->class_decl
= (*runtime
.category_decl
) (klass
);
7052 imp_entry
->meta_decl
= NULL
;
7054 imp_entry
->has_cxx_cdtors
= 0;
7056 /* Append to front and increment count. */
7057 imp_list
= imp_entry
;
7058 if (TREE_CODE (klass
) == CLASS_IMPLEMENTATION_TYPE
)
7063 pop_lang_context ();
7064 #endif /* OBJCPLUS */
7066 return get_class_ivars (implementation_template
, true);
7069 case CLASS_INTERFACE_TYPE
:
7071 if (objc_in_class_extension
)
7074 push_lang_context (lang_name_c
);
7075 #endif /* OBJCPLUS */
7076 objc_collecting_ivars
= 1;
7077 build_private_template (klass
);
7078 objc_collecting_ivars
= 0;
7080 pop_lang_context ();
7081 #endif /* OBJCPLUS */
7086 return error_mark_node
;
7090 /* This routine builds name of the setter synthesized function. */
7092 objc_build_property_setter_name (tree ident
)
7094 /* TODO: Use alloca to allocate buffer of appropriate size. */
7095 static char string
[BUFSIZE
];
7096 sprintf (string
, "set%s:", IDENTIFIER_POINTER (ident
));
7097 string
[3] = TOUPPER (string
[3]);
7101 /* This routine prepares the declarations of the property accessor
7102 helper functions (objc_getProperty(), etc) that are used when
7103 @synthesize is used.
7105 runtime-specific routines are built in the respective runtime
7106 initialize functions. */
7108 build_common_objc_property_accessor_helpers (void)
7112 /* Declare the following function:
7114 objc_getProperty (id self, SEL _cmd,
7115 ptrdiff_t offset, BOOL is_atomic); */
7116 type
= build_function_type_list (objc_object_type
,
7122 objc_getProperty_decl
= add_builtin_function ("objc_getProperty",
7123 type
, 0, NOT_BUILT_IN
,
7125 TREE_NOTHROW (objc_getProperty_decl
) = 0;
7127 /* Declare the following function:
7129 objc_setProperty (id self, SEL _cmd,
7130 ptrdiff_t offset, id new_value,
7131 BOOL is_atomic, BOOL should_copy); */
7132 type
= build_function_type_list (void_type_node
,
7140 objc_setProperty_decl
= add_builtin_function ("objc_setProperty",
7141 type
, 0, NOT_BUILT_IN
,
7143 TREE_NOTHROW (objc_setProperty_decl
) = 0;
7146 /* This looks up an ivar in a class (including superclasses). */
7148 lookup_ivar (tree interface
, tree instance_variable_name
)
7154 for (decl_chain
= CLASS_IVARS (interface
); decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
7155 if (DECL_NAME (decl_chain
) == instance_variable_name
)
7158 /* Not found. Search superclass if any. */
7159 if (CLASS_SUPER_NAME (interface
))
7160 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
7166 /* This routine synthesizes a 'getter' method. This is only called
7167 for @synthesize properties. */
7169 objc_synthesize_getter (tree klass
, tree class_methods ATTRIBUTE_UNUSED
, tree property
)
7171 location_t location
= DECL_SOURCE_LOCATION (property
);
7176 /* If user has implemented a getter with same name then do nothing. */
7177 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context
),
7178 PROPERTY_GETTER_NAME (property
)))
7181 /* Find declaration of the property getter in the interface (or
7182 superclass, or protocol). There must be one. */
7183 decl
= lookup_method_static (klass
, PROPERTY_GETTER_NAME (property
), 0);
7185 /* If one not declared in the interface, this condition has already
7186 been reported as user error (because property was not declared in
7191 /* Adapt the 'decl'. Use the source location of the @synthesize
7192 statement for error messages. */
7193 decl
= copy_node (decl
);
7194 DECL_SOURCE_LOCATION (decl
) = location
;
7196 objc_start_method_definition (false /* is_class_method */, decl
, NULL_TREE
,
7198 body
= c_begin_compound_stmt (true);
7200 /* Now we need to decide how we build the getter. There are three
7203 for 'copy' or 'retain' properties we need to use the
7204 objc_getProperty() accessor helper which knows about retain and
7205 copy. It supports both 'nonatomic' and 'atomic' access.
7207 for 'nonatomic, assign' properties we can access the instance
7208 variable directly. 'nonatomic' means we don't have to use locks,
7209 and 'assign' means we don't have to worry about retain or copy.
7210 If you combine the two, it means we can just access the instance
7213 for 'atomic, assign' properties we use objc_copyStruct() (for the
7214 next runtime) or objc_getPropertyStruct() (for the GNU runtime). */
7215 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
7217 case OBJC_PROPERTY_RETAIN
:
7218 case OBJC_PROPERTY_COPY
:
7220 /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);" */
7221 tree cmd
, ivar
, offset
, is_atomic
;
7222 cmd
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
7224 /* Find the ivar to compute the offset. */
7225 ivar
= lookup_ivar (klass
, PROPERTY_IVAR_NAME (property
));
7226 if (!ivar
|| is_private (ivar
))
7228 /* This should never happen. */
7230 "can not find instance variable associated with property");
7231 ret_val
= error_mark_node
;
7234 offset
= byte_position (ivar
);
7236 if (PROPERTY_NONATOMIC (property
))
7237 is_atomic
= boolean_false_node
;
7239 is_atomic
= boolean_true_node
;
7241 ret_val
= build_function_call
7243 /* Function prototype. */
7244 objc_getProperty_decl
,
7246 tree_cons
/* self */
7247 (NULL_TREE
, self_decl
,
7248 tree_cons
/* _cmd */
7250 tree_cons
/* offset */
7252 tree_cons
/* is_atomic */
7253 (NULL_TREE
, is_atomic
, NULL_TREE
)))));
7256 case OBJC_PROPERTY_ASSIGN
:
7257 if (PROPERTY_NONATOMIC (property
))
7259 /* We build "return self->PROPERTY_IVAR_NAME;" */
7260 ret_val
= objc_lookup_ivar (NULL_TREE
, PROPERTY_IVAR_NAME (property
));
7266 <property type> __objc_property_temp;
7267 objc_getPropertyStruct (&__objc_property_temp,
7268 &(self->PROPERTY_IVAR_NAME),
7269 sizeof (type of self->PROPERTY_IVAR_NAME),
7272 return __objc_property_temp;
7274 For the NeXT runtime, we need to use objc_copyStruct
7275 instead of objc_getPropertyStruct. */
7276 tree objc_property_temp_decl
, function_decl
, function_call
;
7277 tree size_of
, is_atomic
;
7279 objc_property_temp_decl
= objc_create_temporary_var (TREE_TYPE (property
), "__objc_property_temp");
7280 DECL_SOURCE_LOCATION (objc_property_temp_decl
) = location
;
7281 objc_property_temp_decl
= lang_hooks
.decls
.pushdecl (objc_property_temp_decl
);
7283 /* sizeof (ivar type). Since the ivar and the property have
7284 the same type, there is no need to lookup the ivar. */
7285 size_of
= c_sizeof_or_alignof_type (location
, TREE_TYPE (property
),
7286 true /* is_sizeof */,
7287 false /* min_alignof */,
7288 false /* complain */);
7290 if (PROPERTY_NONATOMIC (property
))
7291 is_atomic
= boolean_false_node
;
7293 is_atomic
= boolean_true_node
;
7295 if (objc_copyStruct_decl
)
7296 function_decl
= objc_copyStruct_decl
;
7298 function_decl
= objc_getPropertyStruct_decl
;
7300 function_call
= build_function_call
7302 /* Function prototype. */
7305 tree_cons
/* &__objc_property_temp_decl */
7306 /* Warning: note that using build_fold_addr_expr_loc()
7307 here causes invalid code to be generated. */
7308 (NULL_TREE
, build_unary_op (location
, ADDR_EXPR
, objc_property_temp_decl
, 0),
7309 tree_cons
/* &(self->PROPERTY_IVAR_NAME); */
7310 (NULL_TREE
, build_fold_addr_expr_loc (location
,
7312 (NULL_TREE
, PROPERTY_IVAR_NAME (property
))),
7313 tree_cons
/* sizeof (PROPERTY_IVAR) */
7314 (NULL_TREE
, size_of
,
7315 tree_cons
/* is_atomic */
7316 (NULL_TREE
, is_atomic
,
7317 /* TODO: This is currently ignored by the GNU
7318 runtime, but what about the next one ? */
7319 tree_cons
/* has_strong */
7320 (NULL_TREE
, boolean_true_node
, NULL_TREE
))))));
7322 add_stmt (function_call
);
7324 ret_val
= objc_property_temp_decl
;
7331 gcc_assert (ret_val
);
7334 finish_return_stmt (ret_val
);
7336 c_finish_return (location
, ret_val
, NULL_TREE
);
7339 add_stmt (c_end_compound_stmt (location
, body
, true));
7340 fn
= current_function_decl
;
7344 objc_finish_method_definition (fn
);
7347 /* This routine synthesizes a 'setter' method. */
7350 objc_synthesize_setter (tree klass
, tree class_methods ATTRIBUTE_UNUSED
, tree property
)
7352 location_t location
= DECL_SOURCE_LOCATION (property
);
7355 tree new_value
, statement
;
7357 /* If user has implemented a setter with same name then do nothing. */
7358 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context
),
7359 PROPERTY_SETTER_NAME (property
)))
7362 /* Find declaration of the property setter in the interface (or
7363 superclass, or protocol). There must be one. */
7364 decl
= lookup_method_static (klass
, PROPERTY_SETTER_NAME (property
), 0);
7366 /* If one not declared in the interface, this condition has already
7367 been reported as user error (because property was not declared in
7372 /* Adapt the 'decl'. Use the source location of the @synthesize
7373 statement for error messages. */
7374 decl
= copy_node (decl
);
7375 DECL_SOURCE_LOCATION (decl
) = DECL_SOURCE_LOCATION (property
);
7377 objc_start_method_definition (false /* is_class_method */, decl
, NULL_TREE
,
7380 body
= c_begin_compound_stmt (true);
7382 /* The 'new_value' is the only argument to the method, which is the
7383 3rd argument of the function, after self and _cmd. We use twice
7384 TREE_CHAIN to move forward two arguments. */
7385 new_value
= TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
)));
7387 /* This would presumably happen if the user has specified a
7388 prototype for the setter that does not have an argument! */
7389 if (new_value
== NULL_TREE
)
7391 /* TODO: This should be caught much earlier than this. */
7392 error_at (DECL_SOURCE_LOCATION (decl
), "invalid setter, it must have one argument");
7393 /* Try to recover somehow. */
7394 new_value
= error_mark_node
;
7397 /* Now we need to decide how we build the setter. There are three
7400 for 'copy' or 'retain' properties we need to use the
7401 objc_setProperty() accessor helper which knows about retain and
7402 copy. It supports both 'nonatomic' and 'atomic' access.
7404 for 'nonatomic, assign' properties we can access the instance
7405 variable directly. 'nonatomic' means we don't have to use locks,
7406 and 'assign' means we don't have to worry about retain or copy.
7407 If you combine the two, it means we can just access the instance
7410 for 'atomic, assign' properties we use objc_copyStruct() (for the
7411 next runtime) or objc_setPropertyStruct() (for the GNU runtime). */
7412 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
7414 case OBJC_PROPERTY_RETAIN
:
7415 case OBJC_PROPERTY_COPY
:
7417 /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);" */
7418 tree cmd
, ivar
, offset
, is_atomic
, should_copy
;
7419 cmd
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
7421 /* Find the ivar to compute the offset. */
7422 ivar
= lookup_ivar (klass
, PROPERTY_IVAR_NAME (property
));
7423 if (!ivar
|| is_private (ivar
))
7426 "can not find instance variable associated with property");
7427 statement
= error_mark_node
;
7430 offset
= byte_position (ivar
);
7432 if (PROPERTY_NONATOMIC (property
))
7433 is_atomic
= boolean_false_node
;
7435 is_atomic
= boolean_true_node
;
7437 if (PROPERTY_ASSIGN_SEMANTICS (property
) == OBJC_PROPERTY_COPY
)
7438 should_copy
= boolean_true_node
;
7440 should_copy
= boolean_false_node
;
7442 statement
= build_function_call
7444 /* Function prototype. */
7445 objc_setProperty_decl
,
7447 tree_cons
/* self */
7448 (NULL_TREE
, self_decl
,
7449 tree_cons
/* _cmd */
7451 tree_cons
/* offset */
7453 tree_cons
/* new_value */
7454 (NULL_TREE
, new_value
,
7455 tree_cons
/* is_atomic */
7456 (NULL_TREE
, is_atomic
,
7457 tree_cons
/* should_copy */
7458 (NULL_TREE
, should_copy
, NULL_TREE
)))))));
7461 case OBJC_PROPERTY_ASSIGN
:
7462 if (PROPERTY_NONATOMIC (property
))
7464 /* We build "self->PROPERTY_IVAR_NAME = new_value;" */
7465 statement
= build_modify_expr
7467 objc_lookup_ivar (NULL_TREE
, PROPERTY_IVAR_NAME (property
)),
7468 NULL_TREE
, NOP_EXPR
,
7469 location
, new_value
, NULL_TREE
);
7475 objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME),
7477 sizeof (type of self->PROPERTY_IVAR_NAME),
7481 For the NeXT runtime, we need to use objc_copyStruct
7482 instead of objc_getPropertyStruct. */
7483 tree function_decl
, size_of
, is_atomic
;
7485 /* sizeof (ivar type). Since the ivar and the property have
7486 the same type, there is no need to lookup the ivar. */
7487 size_of
= c_sizeof_or_alignof_type (location
, TREE_TYPE (property
),
7488 true /* is_sizeof */,
7489 false /* min_alignof */,
7490 false /* complain */);
7492 if (PROPERTY_NONATOMIC (property
))
7493 is_atomic
= boolean_false_node
;
7495 is_atomic
= boolean_true_node
;
7497 if (objc_copyStruct_decl
)
7498 function_decl
= objc_copyStruct_decl
;
7500 function_decl
= objc_setPropertyStruct_decl
;
7502 statement
= build_function_call
7504 /* Function prototype. */
7507 tree_cons
/* &(self->PROPERTY_IVAR_NAME); */
7508 (NULL_TREE
, build_fold_addr_expr_loc (location
,
7510 (NULL_TREE
, PROPERTY_IVAR_NAME (property
))),
7511 tree_cons
/* &new_value */
7512 (NULL_TREE
, build_fold_addr_expr_loc (location
, new_value
),
7513 tree_cons
/* sizeof (PROPERTY_IVAR) */
7514 (NULL_TREE
, size_of
,
7515 tree_cons
/* is_atomic */
7516 (NULL_TREE
, is_atomic
,
7517 /* TODO: This is currently ignored by the GNU
7518 runtime, but what about the next one ? */
7519 tree_cons
/* has_strong */
7520 (NULL_TREE
, boolean_true_node
, NULL_TREE
))))));
7526 gcc_assert (statement
);
7528 add_stmt (statement
);
7529 add_stmt (c_end_compound_stmt (location
, body
, true));
7530 fn
= current_function_decl
;
7534 objc_finish_method_definition (fn
);
7537 /* This function is a sub-routine of objc_add_synthesize_declaration.
7538 It is called for each property to synthesize once we have
7539 determined that the context is Ok. */
7541 objc_add_synthesize_declaration_for_property (location_t location
, tree interface
,
7542 tree property_name
, tree ivar_name
)
7544 /* Find the @property declaration. */
7548 /* Check that synthesize or dynamic has not already been used for
7549 the same property. */
7550 for (property
= IMPL_PROPERTY_DECL (objc_implementation_context
); property
; property
= TREE_CHAIN (property
))
7551 if (PROPERTY_NAME (property
) == property_name
)
7553 location_t original_location
= DECL_SOURCE_LOCATION (property
);
7555 if (PROPERTY_DYNAMIC (property
))
7556 error_at (location
, "property %qs already specified in %<@dynamic%>",
7557 IDENTIFIER_POINTER (property_name
));
7559 error_at (location
, "property %qs already specified in %<@synthesize%>",
7560 IDENTIFIER_POINTER (property_name
));
7562 if (original_location
!= UNKNOWN_LOCATION
)
7563 inform (original_location
, "originally specified here");
7567 /* Check that the property is declared in the interface. It could
7568 also be declared in a superclass or protocol. */
7569 property
= lookup_property (interface
, property_name
);
7573 error_at (location
, "no declaration of property %qs found in the interface",
7574 IDENTIFIER_POINTER (property_name
));
7579 /* We have to copy the property, because we want to chain it to
7580 the implementation context, and we want to store the source
7581 location of the @synthesize, not of the original
7583 property
= copy_node (property
);
7584 DECL_SOURCE_LOCATION (property
) = location
;
7587 /* Determine PROPERTY_IVAR_NAME. */
7588 if (ivar_name
== NULL_TREE
)
7589 ivar_name
= property_name
;
7591 /* Check that the instance variable exists. You can only use an
7592 instance variable from the same class, not one from the
7593 superclass (this makes sense as it allows us to check that an
7594 instance variable is only used in one synthesized property). */
7596 tree ivar
= is_ivar (CLASS_IVARS (interface
), ivar_name
);
7600 error_at (location
, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar",
7601 IDENTIFIER_POINTER (property_name
));
7605 if (DECL_BIT_FIELD_TYPE (ivar
))
7606 type_of_ivar
= DECL_BIT_FIELD_TYPE (ivar
);
7608 type_of_ivar
= TREE_TYPE (ivar
);
7610 /* If the instance variable has a different C type, we throw an error ... */
7611 if (!comptypes (TREE_TYPE (property
), type_of_ivar
)
7612 /* ... unless the property is readonly, in which case we allow
7613 the instance variable to be more specialized (this means we
7614 can generate the getter all right and it works). */
7615 && (!PROPERTY_READONLY (property
)
7616 || !objc_compare_types (TREE_TYPE (property
),
7617 type_of_ivar
, -5, NULL_TREE
)))
7619 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7621 error_at (location
, "property %qs is using instance variable %qs of incompatible type",
7622 IDENTIFIER_POINTER (property_name
),
7623 IDENTIFIER_POINTER (ivar_name
));
7625 if (original_location
!= UNKNOWN_LOCATION
)
7626 inform (original_location
, "originally specified here");
7629 /* If the instance variable is a bitfield, the property must be
7630 'assign', 'nonatomic' because the runtime getter/setter helper
7631 do not work with bitfield instance variables. */
7632 if (DECL_BIT_FIELD_TYPE (ivar
))
7634 /* If there is an error, we return and not generate any
7635 getter/setter because trying to set up the runtime
7636 getter/setter helper calls with bitfields is at high risk
7639 if (PROPERTY_ASSIGN_SEMANTICS (property
) != OBJC_PROPERTY_ASSIGN
)
7641 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7643 error_at (location
, "'assign' property %qs is using bit-field instance variable %qs",
7644 IDENTIFIER_POINTER (property_name
),
7645 IDENTIFIER_POINTER (ivar_name
));
7647 if (original_location
!= UNKNOWN_LOCATION
)
7648 inform (original_location
, "originally specified here");
7652 if (!PROPERTY_NONATOMIC (property
))
7654 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7656 error_at (location
, "'atomic' property %qs is using bit-field instance variable %qs",
7657 IDENTIFIER_POINTER (property_name
),
7658 IDENTIFIER_POINTER (ivar_name
));
7660 if (original_location
!= UNKNOWN_LOCATION
)
7661 inform (original_location
, "originally specified here");
7667 /* Check that no other property is using the same instance
7669 for (x
= IMPL_PROPERTY_DECL (objc_implementation_context
); x
; x
= TREE_CHAIN (x
))
7670 if (PROPERTY_IVAR_NAME (x
) == ivar_name
)
7672 location_t original_location
= DECL_SOURCE_LOCATION (x
);
7674 error_at (location
, "property %qs is using the same instance variable as property %qs",
7675 IDENTIFIER_POINTER (property_name
),
7676 IDENTIFIER_POINTER (PROPERTY_NAME (x
)));
7678 if (original_location
!= UNKNOWN_LOCATION
)
7679 inform (original_location
, "originally specified here");
7681 /* We keep going on. This won't cause the compiler to fail;
7682 the failure would most likely be at runtime. */
7685 /* Note that a @synthesize (and only a @synthesize) always sets
7686 PROPERTY_IVAR_NAME to a non-NULL_TREE. You can recognize a
7687 @synthesize by that. */
7688 PROPERTY_IVAR_NAME (property
) = ivar_name
;
7690 /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the
7691 original declaration; they are always set (with the exception of
7692 PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1). */
7694 /* Add the property to the list of properties for current implementation. */
7695 TREE_CHAIN (property
) = IMPL_PROPERTY_DECL (objc_implementation_context
);
7696 IMPL_PROPERTY_DECL (objc_implementation_context
) = property
;
7698 /* Note how we don't actually synthesize the getter/setter here; it
7699 would be very natural, but we may miss the fact that the user has
7700 implemented his own getter/setter later on in the @implementation
7701 (in which case we shouldn't generate getter/setter). We wait
7702 until we have parsed it all before generating the code. */
7705 /* This function is called by the parser after a @synthesize
7706 expression is parsed. 'location' is the location of the
7707 @synthesize expression, and 'property_and_ivar_list' is a chained
7708 list of the property and ivar names. */
7710 objc_add_synthesize_declaration (location_t location
, tree property_and_ivar_list
)
7712 tree interface
, chain
;
7714 if (flag_objc1_only
)
7715 error_at (input_location
, "%<@synthesize%> is not available in Objective-C 1.0");
7717 if (property_and_ivar_list
== error_mark_node
)
7720 if (!objc_implementation_context
)
7722 /* We can get here only in Objective-C; the Objective-C++ parser
7723 detects the problem while parsing, outputs the error
7724 "misplaced '@synthesize' Objective-C++ construct" and skips
7726 error_at (location
, "%<@synthesize%> not in @implementation context");
7730 if (TREE_CODE (objc_implementation_context
) == CATEGORY_IMPLEMENTATION_TYPE
)
7732 error_at (location
, "%<@synthesize%> can not be used in categories");
7736 interface
= lookup_interface (CLASS_NAME (objc_implementation_context
));
7739 /* I can't see how this could happen, but it is good as a safety check. */
7741 "%<@synthesize%> requires the @interface of the class to be available");
7745 /* Now, iterate over the properties and do each of them. */
7746 for (chain
= property_and_ivar_list
; chain
; chain
= TREE_CHAIN (chain
))
7748 objc_add_synthesize_declaration_for_property (location
, interface
, TREE_VALUE (chain
),
7749 TREE_PURPOSE (chain
));
7753 /* This function is a sub-routine of objc_add_dynamic_declaration. It
7754 is called for each property to mark as dynamic once we have
7755 determined that the context is Ok. */
7757 objc_add_dynamic_declaration_for_property (location_t location
, tree interface
,
7760 /* Find the @property declaration. */
7763 /* Check that synthesize or dynamic has not already been used for
7764 the same property. */
7765 for (property
= IMPL_PROPERTY_DECL (objc_implementation_context
); property
; property
= TREE_CHAIN (property
))
7766 if (PROPERTY_NAME (property
) == property_name
)
7768 location_t original_location
= DECL_SOURCE_LOCATION (property
);
7770 if (PROPERTY_DYNAMIC (property
))
7771 error_at (location
, "property %qs already specified in %<@dynamic%>",
7772 IDENTIFIER_POINTER (property_name
));
7774 error_at (location
, "property %qs already specified in %<@synthesize%>",
7775 IDENTIFIER_POINTER (property_name
));
7777 if (original_location
!= UNKNOWN_LOCATION
)
7778 inform (original_location
, "originally specified here");
7782 /* Check that the property is declared in the interface. It could
7783 also be declared in a superclass or protocol. */
7784 property
= lookup_property (interface
, property_name
);
7788 error_at (location
, "no declaration of property %qs found in the interface",
7789 IDENTIFIER_POINTER (property_name
));
7794 /* We have to copy the property, because we want to chain it to
7795 the implementation context, and we want to store the source
7796 location of the @synthesize, not of the original
7798 property
= copy_node (property
);
7799 DECL_SOURCE_LOCATION (property
) = location
;
7802 /* Note that a @dynamic (and only a @dynamic) always sets
7803 PROPERTY_DYNAMIC to 1. You can recognize a @dynamic by that.
7804 (actually, as explained above, PROPERTY_DECL generated by
7805 @property and associated with a @dynamic property are also marked
7806 as PROPERTY_DYNAMIC). */
7807 PROPERTY_DYNAMIC (property
) = 1;
7809 /* Add the property to the list of properties for current implementation. */
7810 TREE_CHAIN (property
) = IMPL_PROPERTY_DECL (objc_implementation_context
);
7811 IMPL_PROPERTY_DECL (objc_implementation_context
) = property
;
7814 /* This function is called by the parser after a @dynamic expression
7815 is parsed. 'location' is the location of the @dynamic expression,
7816 and 'property_list' is a chained list of all the property
7819 objc_add_dynamic_declaration (location_t location
, tree property_list
)
7821 tree interface
, chain
;
7823 if (flag_objc1_only
)
7824 error_at (input_location
, "%<@dynamic%> is not available in Objective-C 1.0");
7826 if (property_list
== error_mark_node
)
7829 if (!objc_implementation_context
)
7831 /* We can get here only in Objective-C; the Objective-C++ parser
7832 detects the problem while parsing, outputs the error
7833 "misplaced '@dynamic' Objective-C++ construct" and skips the
7835 error_at (location
, "%<@dynamic%> not in @implementation context");
7839 /* @dynamic is allowed in categories. */
7840 switch (TREE_CODE (objc_implementation_context
))
7842 case CLASS_IMPLEMENTATION_TYPE
:
7843 interface
= lookup_interface (CLASS_NAME (objc_implementation_context
));
7845 case CATEGORY_IMPLEMENTATION_TYPE
:
7846 interface
= lookup_category (implementation_template
,
7847 CLASS_SUPER_NAME (objc_implementation_context
));
7855 /* I can't see how this could happen, but it is good as a safety check. */
7857 "%<@dynamic%> requires the @interface of the class to be available");
7861 /* Now, iterate over the properties and do each of them. */
7862 for (chain
= property_list
; chain
; chain
= TREE_CHAIN (chain
))
7864 objc_add_dynamic_declaration_for_property (location
, interface
, TREE_VALUE (chain
));
7868 /* Main routine to generate code/data for all the property information for
7869 current implementation (class or category). CLASS is the interface where
7870 ivars are declared. CLASS_METHODS is where methods are found which
7871 could be a class or a category depending on whether we are implementing
7872 property of a class or a category. */
7875 objc_gen_property_data (tree klass
, tree class_methods
)
7879 for (x
= IMPL_PROPERTY_DECL (objc_implementation_context
); x
; x
= TREE_CHAIN (x
))
7881 /* @dynamic property - nothing to check or synthesize. */
7882 if (PROPERTY_DYNAMIC (x
))
7885 /* @synthesize property - need to synthesize the accessors. */
7886 if (PROPERTY_IVAR_NAME (x
))
7888 objc_synthesize_getter (klass
, class_methods
, x
);
7890 if (PROPERTY_READONLY (x
) == 0)
7891 objc_synthesize_setter (klass
, class_methods
, x
);
7900 /* This is called once we see the "@end" in an interface/implementation. */
7903 finish_class (tree klass
)
7905 switch (TREE_CODE (klass
))
7907 case CLASS_IMPLEMENTATION_TYPE
:
7909 /* All metadata generation is done in runtime.generate_metadata(). */
7911 /* Generate what needed for property; setters, getters, etc. */
7912 objc_gen_property_data (implementation_template
, implementation_template
);
7914 if (implementation_template
!= objc_implementation_context
)
7916 /* Ensure that all method listed in the interface contain bodies. */
7917 check_methods (CLASS_CLS_METHODS (implementation_template
),
7918 objc_implementation_context
, '+');
7919 check_methods (CLASS_NST_METHODS (implementation_template
),
7920 objc_implementation_context
, '-');
7922 if (CLASS_PROTOCOL_LIST (implementation_template
))
7923 check_protocols (CLASS_PROTOCOL_LIST (implementation_template
),
7925 CLASS_NAME (objc_implementation_context
));
7929 case CATEGORY_IMPLEMENTATION_TYPE
:
7931 tree category
= lookup_category (implementation_template
, CLASS_SUPER_NAME (klass
));
7935 /* Generate what needed for property; setters, getters, etc. */
7936 objc_gen_property_data (implementation_template
, category
);
7938 /* Ensure all method listed in the interface contain bodies. */
7939 check_methods (CLASS_CLS_METHODS (category
),
7940 objc_implementation_context
, '+');
7941 check_methods (CLASS_NST_METHODS (category
),
7942 objc_implementation_context
, '-');
7944 if (CLASS_PROTOCOL_LIST (category
))
7945 check_protocols (CLASS_PROTOCOL_LIST (category
),
7947 CLASS_SUPER_NAME (objc_implementation_context
));
7951 case CLASS_INTERFACE_TYPE
:
7952 case CATEGORY_INTERFACE_TYPE
:
7953 case PROTOCOL_INTERFACE_TYPE
:
7955 /* Process properties of the class. */
7957 for (x
= CLASS_PROPERTY_DECL (objc_interface_context
); x
; x
= TREE_CHAIN (x
))
7959 /* Now we check that the appropriate getter is declared,
7960 and if not, we declare one ourselves. */
7961 tree getter_decl
= lookup_method (CLASS_NST_METHODS (klass
),
7962 PROPERTY_GETTER_NAME (x
));
7966 /* TODO: Check that the declaration is consistent with the property. */
7971 /* Generate an instance method declaration for the
7972 getter; for example "- (id) name;". In general it
7974 -(type)property_getter_name; */
7975 tree rettype
= build_tree_list (NULL_TREE
, TREE_TYPE (x
));
7976 getter_decl
= build_method_decl (INSTANCE_METHOD_DECL
,
7977 rettype
, PROPERTY_GETTER_NAME (x
),
7979 if (PROPERTY_OPTIONAL (x
))
7980 objc_add_method (objc_interface_context
, getter_decl
, false, true);
7982 objc_add_method (objc_interface_context
, getter_decl
, false, false);
7983 TREE_DEPRECATED (getter_decl
) = TREE_DEPRECATED (x
);
7984 METHOD_PROPERTY_CONTEXT (getter_decl
) = x
;
7987 if (PROPERTY_READONLY (x
) == 0)
7989 /* Now we check that the appropriate setter is declared,
7990 and if not, we declare on ourselves. */
7991 tree setter_decl
= lookup_method (CLASS_NST_METHODS (klass
),
7992 PROPERTY_SETTER_NAME (x
));
7996 /* TODO: Check that the declaration is consistent with the property. */
8001 /* The setter name is something like 'setName:'.
8002 We need the substring 'setName' to build the
8003 method declaration due to how the declaration
8004 works. TODO: build_method_decl() will then
8005 generate back 'setName:' from 'setName'; it
8006 would be more efficient to hook into there. */
8007 const char *full_setter_name
= IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x
));
8008 size_t length
= strlen (full_setter_name
);
8009 char *setter_name
= (char *) alloca (length
);
8010 tree ret_type
, selector
, arg_type
, arg_name
;
8012 strcpy (setter_name
, full_setter_name
);
8013 setter_name
[length
- 1] = '\0';
8014 ret_type
= build_tree_list (NULL_TREE
, void_type_node
);
8015 arg_type
= build_tree_list (NULL_TREE
, TREE_TYPE (x
));
8016 arg_name
= get_identifier ("_value");
8017 selector
= objc_build_keyword_decl (get_identifier (setter_name
),
8018 arg_type
, arg_name
, NULL
);
8019 setter_decl
= build_method_decl (INSTANCE_METHOD_DECL
,
8021 build_tree_list (NULL_TREE
, NULL_TREE
),
8023 if (PROPERTY_OPTIONAL (x
))
8024 objc_add_method (objc_interface_context
, setter_decl
, false, true);
8026 objc_add_method (objc_interface_context
, setter_decl
, false, false);
8027 TREE_DEPRECATED (setter_decl
) = TREE_DEPRECATED (x
);
8028 METHOD_PROPERTY_CONTEXT (setter_decl
) = x
;
8041 add_protocol (tree protocol
)
8043 /* Put protocol on list in reverse order. */
8044 TREE_CHAIN (protocol
) = protocol_chain
;
8045 protocol_chain
= protocol
;
8046 return protocol_chain
;
8049 /* Check that a protocol is defined, and, recursively, that all
8050 protocols that this protocol conforms to are defined too. */
8052 check_that_protocol_is_defined (tree protocol
)
8054 if (!PROTOCOL_DEFINED (protocol
))
8055 warning (0, "definition of protocol %qE not found",
8056 PROTOCOL_NAME (protocol
));
8058 /* If the protocol itself conforms to other protocols, check them
8059 too, recursively. */
8060 if (PROTOCOL_LIST (protocol
))
8064 for (p
= PROTOCOL_LIST (protocol
); p
; p
= TREE_CHAIN (p
))
8065 check_that_protocol_is_defined (TREE_VALUE (p
));
8069 /* Looks up a protocol. If 'warn_if_deprecated' is true, a warning is
8070 emitted if the protocol is deprecated. If 'definition_required' is
8071 true, a warning is emitted if a full @protocol definition has not
8074 lookup_protocol (tree ident
, bool warn_if_deprecated
, bool definition_required
)
8078 for (chain
= protocol_chain
; chain
; chain
= TREE_CHAIN (chain
))
8079 if (ident
== PROTOCOL_NAME (chain
))
8081 if (warn_if_deprecated
&& TREE_DEPRECATED (chain
))
8083 /* It would be nice to use warn_deprecated_use() here, but
8084 we are using TREE_CHAIN (which is supposed to be the
8085 TYPE_STUB_DECL for a TYPE) for something different. */
8086 warning (OPT_Wdeprecated_declarations
, "protocol %qE is deprecated",
8087 PROTOCOL_NAME (chain
));
8090 if (definition_required
)
8091 check_that_protocol_is_defined (chain
);
8099 /* This function forward declares the protocols named by NAMES. If
8100 they are already declared or defined, the function has no effect. */
8103 objc_declare_protocol (tree name
, tree attributes
)
8105 bool deprecated
= false;
8108 if (current_namespace
!= global_namespace
) {
8109 error ("Objective-C declarations may only appear in global scope");
8111 #endif /* OBJCPLUS */
8113 /* Determine if 'deprecated', the only attribute we recognize for
8114 protocols, was used. Ignore all other attributes. */
8118 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
8120 tree name
= TREE_PURPOSE (attribute
);
8122 if (is_attribute_p ("deprecated", name
))
8125 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
8129 if (lookup_protocol (name
, /* warn if deprecated */ false,
8130 /* definition_required */ false) == NULL_TREE
)
8132 tree protocol
= make_node (PROTOCOL_INTERFACE_TYPE
);
8134 TYPE_LANG_SLOT_1 (protocol
)
8135 = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS
);
8136 PROTOCOL_NAME (protocol
) = name
;
8137 PROTOCOL_LIST (protocol
) = NULL_TREE
;
8138 add_protocol (protocol
);
8139 PROTOCOL_DEFINED (protocol
) = 0;
8140 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
8144 /* TODO: Do we need to store the attributes here ? */
8145 TYPE_ATTRIBUTES (protocol
) = attributes
;
8147 TREE_DEPRECATED (protocol
) = 1;
8153 start_protocol (enum tree_code code
, tree name
, tree list
, tree attributes
)
8156 bool deprecated
= false;
8159 if (current_namespace
!= global_namespace
) {
8160 error ("Objective-C declarations may only appear in global scope");
8162 #endif /* OBJCPLUS */
8164 /* Determine if 'deprecated', the only attribute we recognize for
8165 protocols, was used. Ignore all other attributes. */
8169 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
8171 tree name
= TREE_PURPOSE (attribute
);
8173 if (is_attribute_p ("deprecated", name
))
8176 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
8180 protocol
= lookup_protocol (name
, /* warn_if_deprecated */ false,
8181 /* definition_required */ false);
8185 protocol
= make_node (code
);
8186 TYPE_LANG_SLOT_1 (protocol
) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS
);
8188 PROTOCOL_NAME (protocol
) = name
;
8189 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
, /* definition_required */ false);
8190 add_protocol (protocol
);
8191 PROTOCOL_DEFINED (protocol
) = 1;
8192 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
8194 check_protocol_recursively (protocol
, list
);
8196 else if (! PROTOCOL_DEFINED (protocol
))
8198 PROTOCOL_DEFINED (protocol
) = 1;
8199 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
, /* definition_required */ false);
8201 check_protocol_recursively (protocol
, list
);
8205 warning (0, "duplicate declaration for protocol %qE",
8211 TYPE_ATTRIBUTES (protocol
) = attributes
;
8213 TREE_DEPRECATED (protocol
) = 1;
8219 /* Decay array and function parameters into pointers. */
8222 objc_decay_parm_type (tree type
)
8224 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == FUNCTION_TYPE
)
8225 type
= build_pointer_type (TREE_CODE (type
) == ARRAY_TYPE
8232 static GTY(()) tree objc_parmlist
= NULL_TREE
;
8234 /* Append PARM to a list of formal parameters of a method, making a necessary
8235 array-to-pointer adjustment along the way. */
8238 objc_push_parm (tree parm
)
8242 if (TREE_TYPE (parm
) == error_mark_node
)
8244 objc_parmlist
= chainon (objc_parmlist
, parm
);
8248 /* Decay arrays and functions into pointers. */
8249 type
= objc_decay_parm_type (TREE_TYPE (parm
));
8251 /* If the parameter type has been decayed, a new PARM_DECL needs to be
8253 if (type
!= TREE_TYPE (parm
))
8254 parm
= build_decl (input_location
, PARM_DECL
, DECL_NAME (parm
), type
);
8256 DECL_ARG_TYPE (parm
)
8257 = lang_hooks
.types
.type_promotes_to (TREE_TYPE (parm
));
8259 /* Record constancy and volatility. */
8260 c_apply_type_quals_to_decl
8261 ((TYPE_READONLY (TREE_TYPE (parm
)) ? TYPE_QUAL_CONST
: 0)
8262 | (TYPE_RESTRICT (TREE_TYPE (parm
)) ? TYPE_QUAL_RESTRICT
: 0)
8263 | (TYPE_ATOMIC (TREE_TYPE (parm
)) ? TYPE_QUAL_ATOMIC
: 0)
8264 | (TYPE_VOLATILE (TREE_TYPE (parm
)) ? TYPE_QUAL_VOLATILE
: 0), parm
);
8266 objc_parmlist
= chainon (objc_parmlist
, parm
);
8269 /* Retrieve the formal parameter list constructed via preceding calls to
8270 objc_push_parm(). */
8274 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED
,
8275 tree expr ATTRIBUTE_UNUSED
)
8277 tree parm_info
= objc_parmlist
;
8278 objc_parmlist
= NULL_TREE
;
8284 objc_get_parm_info (int have_ellipsis
, tree expr
)
8286 tree parm_info
= objc_parmlist
;
8287 struct c_arg_info
*arg_info
;
8288 /* The C front-end requires an elaborate song and dance at
8291 declare_parm_level ();
8294 tree next
= DECL_CHAIN (parm_info
);
8296 DECL_CHAIN (parm_info
) = NULL_TREE
;
8297 parm_info
= pushdecl (parm_info
);
8298 finish_decl (parm_info
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
8301 arg_info
= get_parm_info (have_ellipsis
, expr
);
8303 objc_parmlist
= NULL_TREE
;
8308 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
8309 method definitions. In the case of instance methods, we can be more
8310 specific as to the type of 'self'. */
8313 synth_self_and_ucmd_args (void)
8317 if (objc_method_context
8318 && TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
)
8319 self_type
= objc_instance_type
;
8321 /* Really a `struct objc_class *'. However, we allow people to
8322 assign to self, which changes its type midstream. */
8323 self_type
= objc_object_type
;
8326 objc_push_parm (build_decl (input_location
,
8327 PARM_DECL
, self_id
, self_type
));
8330 objc_push_parm (build_decl (input_location
,
8331 PARM_DECL
, ucmd_id
, objc_selector_type
));
8334 /* Transform an Objective-C method definition into a static C function
8335 definition, synthesizing the first two arguments, "self" and "_cmd",
8336 in the process. EXPR is NULL or an expression that needs to be
8337 evaluated for the side effects of array size expressions in the
8341 start_method_def (tree method
, tree expr
)
8347 struct c_arg_info
*parm_info
;
8349 int have_ellipsis
= 0;
8351 /* If we are defining a "dealloc" method in a non-root class, we
8352 will need to check if a [super dealloc] is missing, and warn if
8354 if(CLASS_SUPER_NAME (objc_implementation_context
)
8355 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method
))))
8356 should_call_super_dealloc
= 1;
8358 should_call_super_dealloc
= 0;
8360 /* Required to implement _msgSuper. */
8361 objc_method_context
= method
;
8362 UOBJC_SUPER_decl
= NULL_TREE
;
8364 /* Generate prototype declarations for arguments..."new-style". */
8365 synth_self_and_ucmd_args ();
8367 /* Generate argument declarations if a keyword_decl. */
8368 parmlist
= METHOD_SEL_ARGS (method
);
8371 /* parmlist is a KEYWORD_DECL. */
8372 tree type
= TREE_VALUE (TREE_TYPE (parmlist
));
8375 parm
= build_decl (input_location
,
8376 PARM_DECL
, KEYWORD_ARG_NAME (parmlist
), type
);
8377 decl_attributes (&parm
, DECL_ATTRIBUTES (parmlist
), 0);
8378 objc_push_parm (parm
);
8379 parmlist
= DECL_CHAIN (parmlist
);
8382 if (METHOD_ADD_ARGS (method
))
8386 for (akey
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
8387 akey
; akey
= TREE_CHAIN (akey
))
8389 objc_push_parm (TREE_VALUE (akey
));
8392 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
8396 parm_info
= objc_get_parm_info (have_ellipsis
, expr
);
8398 really_start_method (objc_method_context
, parm_info
);
8401 /* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method
8404 objc_types_are_equivalent (tree type1
, tree type2
)
8409 /* Strip away indirections. */
8410 while ((TREE_CODE (type1
) == ARRAY_TYPE
|| TREE_CODE (type1
) == POINTER_TYPE
)
8411 && (TREE_CODE (type1
) == TREE_CODE (type2
)))
8412 type1
= TREE_TYPE (type1
), type2
= TREE_TYPE (type2
);
8413 if (TYPE_MAIN_VARIANT (type1
) != TYPE_MAIN_VARIANT (type2
))
8416 /* Compare the protocol lists. */
8417 type1
= (TYPE_HAS_OBJC_INFO (type1
)
8418 ? TYPE_OBJC_PROTOCOL_LIST (type1
)
8420 type2
= (TYPE_HAS_OBJC_INFO (type2
)
8421 ? TYPE_OBJC_PROTOCOL_LIST (type2
)
8424 /* If there are no protocols (most common case), the types are
8426 if (type1
== NULL_TREE
&& type2
== NULL_TREE
)
8429 /* If one has protocols, and the other one hasn't, they are not
8431 if ((type1
== NULL_TREE
&& type2
!= NULL_TREE
)
8432 || (type1
!= NULL_TREE
&& type2
== NULL_TREE
))
8436 /* Else, both have protocols, and we need to do the full
8437 comparison. It is possible that either type1 or type2
8438 contain some duplicate protocols in the list, so we can't
8439 even just compare list_length as a first check. */
8442 for (t
= type2
; t
; t
= TREE_CHAIN (t
))
8443 if (!lookup_protocol_in_reflist (type1
, TREE_VALUE (t
)))
8446 for (t
= type1
; t
; t
= TREE_CHAIN (t
))
8447 if (!lookup_protocol_in_reflist (type2
, TREE_VALUE (t
)))
8454 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */
8457 objc_types_share_size_and_alignment (tree type1
, tree type2
)
8459 return (simple_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
))
8460 && TYPE_ALIGN (type1
) == TYPE_ALIGN (type2
));
8463 /* Return 1 if PROTO1 is equivalent to PROTO2
8464 for purposes of method overloading. Ordinarily, the type signatures
8465 should match up exactly, unless STRICT is zero, in which case we
8466 shall allow differences in which the size and alignment of a type
8470 comp_proto_with_proto (tree proto1
, tree proto2
, int strict
)
8474 /* The following test is needed in case there are hashing
8476 if (METHOD_SEL_NAME (proto1
) != METHOD_SEL_NAME (proto2
))
8479 /* Compare return types. */
8480 type1
= TREE_VALUE (TREE_TYPE (proto1
));
8481 type2
= TREE_VALUE (TREE_TYPE (proto2
));
8483 if (!objc_types_are_equivalent (type1
, type2
)
8484 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8487 /* Compare argument types. */
8489 /* The first argument (objc_object_type) is always the same, no need
8492 /* The second argument (objc_selector_type) is always the same, no
8495 /* Compare the other arguments. */
8499 /* Compare METHOD_SEL_ARGS. */
8500 for (arg1
= METHOD_SEL_ARGS (proto1
), arg2
= METHOD_SEL_ARGS (proto2
);
8502 arg1
= DECL_CHAIN (arg1
), arg2
= DECL_CHAIN (arg2
))
8504 type1
= TREE_VALUE (TREE_TYPE (arg1
));
8505 type2
= TREE_VALUE (TREE_TYPE (arg2
));
8507 /* FIXME: Do we need to decay argument types to compare them ? */
8508 type1
= objc_decay_parm_type (type1
);
8509 type2
= objc_decay_parm_type (type2
);
8511 if (!objc_types_are_equivalent (type1
, type2
)
8512 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8516 /* The loop ends when arg1 or arg2 are NULL. Make sure they are
8521 /* Compare METHOD_ADD_ARGS. */
8522 if ((METHOD_ADD_ARGS (proto1
) && !METHOD_ADD_ARGS (proto2
))
8523 || (METHOD_ADD_ARGS (proto2
) && !METHOD_ADD_ARGS (proto1
)))
8526 if (METHOD_ADD_ARGS (proto1
))
8528 for (arg1
= TREE_CHAIN (METHOD_ADD_ARGS (proto1
)), arg2
= TREE_CHAIN (METHOD_ADD_ARGS (proto2
));
8530 arg1
= TREE_CHAIN (arg1
), arg2
= TREE_CHAIN (arg2
))
8532 type1
= TREE_TYPE (TREE_VALUE (arg1
));
8533 type2
= TREE_TYPE (TREE_VALUE (arg2
));
8535 /* FIXME: Do we need to decay argument types to compare them ? */
8536 type1
= objc_decay_parm_type (type1
);
8537 type2
= objc_decay_parm_type (type2
);
8539 if (!objc_types_are_equivalent (type1
, type2
)
8540 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8545 /* The loop ends when arg1 or arg2 are NULL. Make sure they are
8550 /* Compare METHOD_ADD_ARGS_ELLIPSIS_P. */
8551 if (METHOD_ADD_ARGS_ELLIPSIS_P (proto1
) != METHOD_ADD_ARGS_ELLIPSIS_P (proto2
))
8559 /* This routine returns true if TYPE is a valid objc object type,
8560 suitable for messaging; false otherwise. If 'accept_class' is
8561 'true', then a Class object is considered valid for messaging and
8562 'true' is returned if 'type' refers to a Class. If 'accept_class'
8563 is 'false', then a Class object is not considered valid for
8564 messaging and 'false' is returned in that case. */
8567 objc_type_valid_for_messaging (tree type
, bool accept_classes
)
8569 if (!POINTER_TYPE_P (type
))
8572 /* Remove the pointer indirection; don't remove more than one
8573 otherwise we'd consider "NSObject **" a valid type for messaging,
8575 type
= TREE_TYPE (type
);
8577 if (TREE_CODE (type
) != RECORD_TYPE
)
8580 if (objc_is_object_id (type
))
8583 if (objc_is_class_id (type
))
8584 return accept_classes
;
8586 if (TYPE_HAS_OBJC_INFO (type
))
8593 objc_start_function (tree name
, tree type
, tree attrs
,
8597 struct c_arg_info
*params
8601 tree fndecl
= build_decl (input_location
,
8602 FUNCTION_DECL
, name
, type
);
8605 DECL_ARGUMENTS (fndecl
) = params
;
8606 DECL_INITIAL (fndecl
) = error_mark_node
;
8607 DECL_EXTERNAL (fndecl
) = 0;
8608 TREE_STATIC (fndecl
) = 1;
8609 retrofit_lang_decl (fndecl
);
8610 cplus_decl_attributes (&fndecl
, attrs
, 0);
8611 start_preparsed_function (fndecl
, attrs
, /*flags=*/SF_DEFAULT
);
8613 current_function_returns_value
= 0; /* Assume, until we see it does. */
8614 current_function_returns_null
= 0;
8615 decl_attributes (&fndecl
, attrs
, 0);
8616 announce_function (fndecl
);
8617 DECL_INITIAL (fndecl
) = error_mark_node
;
8618 DECL_EXTERNAL (fndecl
) = 0;
8619 TREE_STATIC (fndecl
) = 1;
8620 current_function_decl
= pushdecl (fndecl
);
8622 declare_parm_level ();
8623 DECL_RESULT (current_function_decl
)
8624 = build_decl (input_location
,
8625 RESULT_DECL
, NULL_TREE
,
8626 TREE_TYPE (TREE_TYPE (current_function_decl
)));
8627 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl
)) = 1;
8628 DECL_IGNORED_P (DECL_RESULT (current_function_decl
)) = 1;
8629 start_fname_decls ();
8630 store_parm_decls_from (params
);
8633 TREE_USED (current_function_decl
) = 1;
8636 /* - Generate an identifier for the function. the format is "_n_cls",
8637 where 1 <= n <= nMethods, and cls is the name the implementation we
8639 - Install the return type from the method declaration.
8640 - If we have a prototype, check for type consistency. */
8643 really_start_method (tree method
,
8647 struct c_arg_info
*parmlist
8651 tree ret_type
, meth_type
;
8653 const char *sel_name
, *class_name
, *cat_name
;
8656 /* Synth the storage class & assemble the return type. */
8657 ret_type
= TREE_VALUE (TREE_TYPE (method
));
8659 sel_name
= IDENTIFIER_POINTER (METHOD_SEL_NAME (method
));
8660 class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
));
8661 cat_name
= ((TREE_CODE (objc_implementation_context
)
8662 == CLASS_IMPLEMENTATION_TYPE
)
8664 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
)));
8667 /* Make sure this is big enough for any plausible method label. */
8668 buf
= (char *) alloca (50 + strlen (sel_name
) + strlen (class_name
)
8669 + (cat_name
? strlen (cat_name
) : 0));
8671 OBJC_GEN_METHOD_LABEL (buf
, TREE_CODE (method
) == INSTANCE_METHOD_DECL
,
8672 class_name
, cat_name
, sel_name
, method_slot
);
8674 method_id
= get_identifier (buf
);
8677 /* Objective-C methods cannot be overloaded, so we don't need
8678 the type encoding appended. It looks bad anyway... */
8679 push_lang_context (lang_name_c
);
8682 meth_type
= build_function_type_for_method (ret_type
, method
, METHOD_DEF
, 0);
8683 objc_start_function (method_id
, meth_type
, NULL_TREE
, parmlist
);
8685 /* Set self_decl from the first argument. */
8686 self_decl
= DECL_ARGUMENTS (current_function_decl
);
8688 /* Suppress unused warnings. */
8689 TREE_USED (self_decl
) = 1;
8690 DECL_READ_P (self_decl
) = 1;
8691 TREE_USED (DECL_CHAIN (self_decl
)) = 1;
8692 DECL_READ_P (DECL_CHAIN (self_decl
)) = 1;
8694 pop_lang_context ();
8697 METHOD_DEFINITION (method
) = current_function_decl
;
8699 /* Check consistency...start_function, pushdecl, duplicate_decls. */
8701 if (implementation_template
!= objc_implementation_context
)
8704 = lookup_method_static (implementation_template
,
8705 METHOD_SEL_NAME (method
),
8706 ((TREE_CODE (method
) == CLASS_METHOD_DECL
)
8707 | OBJC_LOOKUP_NO_SUPER
));
8711 if (!comp_proto_with_proto (method
, proto
, 1))
8713 bool type
= TREE_CODE (method
) == INSTANCE_METHOD_DECL
;
8715 warning_at (DECL_SOURCE_LOCATION (method
), 0,
8716 "conflicting types for %<%c%s%>",
8718 identifier_to_locale (gen_method_decl (method
)));
8719 inform (DECL_SOURCE_LOCATION (proto
),
8720 "previous declaration of %<%c%s%>",
8722 identifier_to_locale (gen_method_decl (proto
)));
8726 /* If the method in the @interface was deprecated, mark
8727 the implemented method as deprecated too. It should
8728 never be used for messaging (when the deprecation
8729 warnings are produced), but just in case. */
8730 if (TREE_DEPRECATED (proto
))
8731 TREE_DEPRECATED (method
) = 1;
8733 /* If the method in the @interface was marked as
8734 'noreturn', mark the function implementing the method
8735 as 'noreturn' too. */
8736 TREE_THIS_VOLATILE (current_function_decl
) = TREE_THIS_VOLATILE (proto
);
8741 /* We have a method @implementation even though we did not
8742 see a corresponding @interface declaration (which is allowed
8743 by Objective-C rules). Go ahead and place the method in
8744 the @interface anyway, so that message dispatch lookups
8746 tree interface
= implementation_template
;
8748 if (TREE_CODE (objc_implementation_context
)
8749 == CATEGORY_IMPLEMENTATION_TYPE
)
8750 interface
= lookup_category
8752 CLASS_SUPER_NAME (objc_implementation_context
));
8755 objc_add_method (interface
, copy_node (method
),
8756 TREE_CODE (method
) == CLASS_METHOD_DECL
,
8757 /* is_optional= */ false);
8762 static void *UOBJC_SUPER_scope
= 0;
8764 /* _n_Method (id self, SEL sel, ...)
8766 struct objc_super _S;
8767 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
8771 get_super_receiver (void)
8773 if (objc_method_context
)
8775 tree super_expr
, super_expr_list
, class_expr
;
8777 if (!UOBJC_SUPER_decl
)
8779 UOBJC_SUPER_decl
= build_decl (input_location
,
8780 VAR_DECL
, get_identifier (TAG_SUPER
),
8781 objc_super_template
);
8782 /* This prevents `unused variable' warnings when compiling with -Wall. */
8783 TREE_USED (UOBJC_SUPER_decl
) = 1;
8784 DECL_READ_P (UOBJC_SUPER_decl
) = 1;
8785 lang_hooks
.decls
.pushdecl (UOBJC_SUPER_decl
);
8786 finish_decl (UOBJC_SUPER_decl
, input_location
, NULL_TREE
, NULL_TREE
,
8788 UOBJC_SUPER_scope
= objc_get_current_scope ();
8791 /* Set receiver to self. */
8792 super_expr
= objc_build_component_ref (UOBJC_SUPER_decl
, self_id
);
8793 super_expr
= build_modify_expr (input_location
, super_expr
, NULL_TREE
,
8794 NOP_EXPR
, input_location
, self_decl
,
8796 super_expr_list
= super_expr
;
8798 /* Set class to begin searching. */
8799 /* Get the ident for the superclass class field & build a ref to it.
8800 ??? maybe we should just name the field the same for all runtimes. */
8801 super_expr
= (*runtime
.super_superclassfield_ident
) ();
8802 super_expr
= objc_build_component_ref (UOBJC_SUPER_decl
, super_expr
);
8804 gcc_assert (imp_list
->imp_context
== objc_implementation_context
8805 && imp_list
->imp_template
== implementation_template
);
8806 inst_meth
= (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
);
8808 if (TREE_CODE (objc_implementation_context
) == CLASS_IMPLEMENTATION_TYPE
)
8809 class_expr
= (*runtime
.get_class_super_ref
) (input_location
,
8810 imp_list
, inst_meth
);
8812 /* We have a category. */
8814 tree super_name
= CLASS_SUPER_NAME (imp_list
->imp_template
);
8817 /* Barf if super used in a category of a root object. */
8820 error ("no super class declared in interface for %qE",
8821 CLASS_NAME (imp_list
->imp_template
));
8822 return error_mark_node
;
8825 super_class
= (*runtime
.get_category_super_ref
) (input_location
,
8826 imp_list
, inst_meth
);
8827 class_expr
= build_c_cast (input_location
,
8828 TREE_TYPE (super_expr
), super_class
);
8831 super_expr
= build_modify_expr (input_location
, super_expr
, NULL_TREE
,
8833 input_location
, class_expr
, NULL_TREE
);
8835 super_expr_list
= build_compound_expr (input_location
,
8836 super_expr_list
, super_expr
);
8838 super_expr
= build_unary_op (input_location
,
8839 ADDR_EXPR
, UOBJC_SUPER_decl
, 0);
8840 super_expr_list
= build_compound_expr (input_location
,
8841 super_expr_list
, super_expr
);
8843 return super_expr_list
;
8847 error ("[super ...] must appear in a method context");
8848 return error_mark_node
;
8852 /* When exiting a scope, sever links to a 'super' declaration (if any)
8853 therein contained. */
8856 objc_clear_super_receiver (void)
8858 if (objc_method_context
8859 && UOBJC_SUPER_scope
== objc_get_current_scope ())
8861 UOBJC_SUPER_decl
= 0;
8862 UOBJC_SUPER_scope
= 0;
8867 objc_finish_method_definition (tree fndecl
)
8869 /* We cannot validly inline ObjC methods, at least not without a language
8870 extension to declare that a method need not be dynamically
8871 dispatched, so suppress all thoughts of doing so. */
8872 DECL_UNINLINABLE (fndecl
) = 1;
8875 /* The C++ front-end will have called finish_function() for us. */
8879 METHOD_ENCODING (objc_method_context
)
8880 = encode_method_prototype (objc_method_context
);
8882 /* Required to implement _msgSuper. This must be done AFTER finish_function,
8883 since the optimizer may find "may be used before set" errors. */
8884 objc_method_context
= NULL_TREE
;
8886 if (should_call_super_dealloc
)
8887 warning (0, "method possibly missing a [super dealloc] call");
8890 /* Given a tree DECL node, produce a printable description of it in the given
8891 buffer, overwriting the buffer. */
8894 gen_declaration (tree decl
)
8900 gen_type_name_0 (TREE_TYPE (decl
));
8902 if (DECL_NAME (decl
))
8904 if (!POINTER_TYPE_P (TREE_TYPE (decl
)))
8905 strcat (errbuf
, " ");
8907 strcat (errbuf
, IDENTIFIER_POINTER (DECL_NAME (decl
)));
8910 if (DECL_INITIAL (decl
)
8911 && TREE_CODE (DECL_INITIAL (decl
)) == INTEGER_CST
)
8912 sprintf (errbuf
+ strlen (errbuf
), ": " HOST_WIDE_INT_PRINT_DEC
,
8913 TREE_INT_CST_LOW (DECL_INITIAL (decl
)));
8919 /* Given a tree TYPE node, produce a printable description of it in the given
8920 buffer, overwriting the buffer. */
8923 gen_type_name_0 (tree type
)
8925 tree orig
= type
, proto
;
8927 if (TYPE_P (type
) && TYPE_NAME (type
))
8928 type
= TYPE_NAME (type
);
8929 else if (POINTER_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
8931 tree inner
= TREE_TYPE (type
);
8933 while (TREE_CODE (inner
) == ARRAY_TYPE
)
8934 inner
= TREE_TYPE (inner
);
8936 gen_type_name_0 (inner
);
8938 if (!POINTER_TYPE_P (inner
))
8939 strcat (errbuf
, " ");
8941 if (POINTER_TYPE_P (type
))
8942 strcat (errbuf
, "*");
8944 while (type
!= inner
)
8946 strcat (errbuf
, "[");
8948 if (TYPE_DOMAIN (type
))
8952 sprintf (sz
, HOST_WIDE_INT_PRINT_DEC
,
8954 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) + 1));
8955 strcat (errbuf
, sz
);
8958 strcat (errbuf
, "]");
8959 type
= TREE_TYPE (type
);
8965 if (TREE_CODE (type
) == TYPE_DECL
&& DECL_NAME (type
))
8966 type
= DECL_NAME (type
);
8968 strcat (errbuf
, TREE_CODE (type
) == IDENTIFIER_NODE
8969 ? IDENTIFIER_POINTER (type
)
8972 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
8973 if (objc_is_id (orig
))
8974 orig
= TREE_TYPE (orig
);
8976 proto
= TYPE_HAS_OBJC_INFO (orig
) ? TYPE_OBJC_PROTOCOL_LIST (orig
) : NULL_TREE
;
8980 strcat (errbuf
, " <");
8984 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto
))));
8985 proto
= TREE_CHAIN (proto
);
8986 strcat (errbuf
, proto
? ", " : ">");
8995 gen_type_name (tree type
)
8999 return gen_type_name_0 (type
);
9002 /* Given a method tree, put a printable description into the given
9003 buffer (overwriting) and return a pointer to the buffer. */
9006 gen_method_decl (tree method
)
9010 strcpy (errbuf
, "("); /* NB: Do _not_ call strcat() here. */
9011 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method
)));
9012 strcat (errbuf
, ")");
9013 chain
= METHOD_SEL_ARGS (method
);
9017 /* We have a chain of keyword_decls. */
9020 if (KEYWORD_KEY_NAME (chain
))
9021 strcat (errbuf
, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain
)));
9023 strcat (errbuf
, ":(");
9024 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain
)));
9025 strcat (errbuf
, ")");
9027 strcat (errbuf
, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain
)));
9028 if ((chain
= DECL_CHAIN (chain
)))
9029 strcat (errbuf
, " ");
9033 if (METHOD_ADD_ARGS (method
))
9035 chain
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
9037 /* Know we have a chain of parm_decls. */
9040 strcat (errbuf
, ", ");
9041 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain
)));
9042 chain
= TREE_CHAIN (chain
);
9045 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
9046 strcat (errbuf
, ", ...");
9051 /* We have a unary selector. */
9052 strcat (errbuf
, IDENTIFIER_POINTER (METHOD_SEL_NAME (method
)));
9060 /* Dump an @interface declaration of the supplied class CHAIN to the
9061 supplied file FP. Used to implement the -gen-decls option (which
9062 prints out an @interface declaration of all classes compiled in
9063 this run); potentially useful for debugging the compiler too. */
9065 dump_interface (FILE *fp
, tree chain
)
9067 /* FIXME: A heap overflow here whenever a method (or ivar)
9068 declaration is so long that it doesn't fit in the buffer. The
9069 code and all the related functions should be rewritten to avoid
9070 using fixed size buffers. */
9071 const char *my_name
= IDENTIFIER_POINTER (CLASS_NAME (chain
));
9072 tree ivar_decls
= CLASS_RAW_IVARS (chain
);
9073 tree nst_methods
= CLASS_NST_METHODS (chain
);
9074 tree cls_methods
= CLASS_CLS_METHODS (chain
);
9076 fprintf (fp
, "\n@interface %s", my_name
);
9078 /* CLASS_SUPER_NAME is used to store the superclass name for
9079 classes, and the category name for categories. */
9080 if (CLASS_SUPER_NAME (chain
))
9082 const char *name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain
));
9084 switch (TREE_CODE (chain
))
9086 case CATEGORY_IMPLEMENTATION_TYPE
:
9087 case CATEGORY_INTERFACE_TYPE
:
9088 fprintf (fp
, " (%s)\n", name
);
9091 fprintf (fp
, " : %s\n", name
);
9098 /* FIXME - the following doesn't seem to work at the moment. */
9101 fprintf (fp
, "{\n");
9104 fprintf (fp
, "\t%s;\n", gen_declaration (ivar_decls
));
9105 ivar_decls
= TREE_CHAIN (ivar_decls
);
9108 fprintf (fp
, "}\n");
9113 fprintf (fp
, "- %s;\n", gen_method_decl (nst_methods
));
9114 nst_methods
= TREE_CHAIN (nst_methods
);
9119 fprintf (fp
, "+ %s;\n", gen_method_decl (cls_methods
));
9120 cls_methods
= TREE_CHAIN (cls_methods
);
9123 fprintf (fp
, "@end\n");
9127 /* Produce the pretty printing for an Objective-C method. This is
9128 currently unused, but could be handy while reorganizing the pretty
9129 printing to be more robust. */
9131 objc_pretty_print_method (bool is_class_method
,
9132 const char *class_name
,
9133 const char *category_name
,
9134 const char *selector
)
9138 char *result
= XNEWVEC (char, strlen (class_name
) + strlen (category_name
)
9139 + strlen (selector
) + 7);
9141 if (is_class_method
)
9142 sprintf (result
, "+[%s(%s) %s]", class_name
, category_name
, selector
);
9144 sprintf (result
, "-[%s(%s) %s]", class_name
, category_name
, selector
);
9150 char *result
= XNEWVEC (char, strlen (class_name
)
9151 + strlen (selector
) + 5);
9153 if (is_class_method
)
9154 sprintf (result
, "+[%s %s]", class_name
, selector
);
9156 sprintf (result
, "-[%s %s]", class_name
, selector
);
9163 /* Demangle function for Objective-C. Attempt to demangle the
9164 function name associated with a method (eg, going from
9165 "_i_NSObject__class" to "-[NSObject class]"); usually for the
9166 purpose of pretty printing or error messages. Return the demangled
9167 name, or NULL if the string is not an Objective-C mangled method
9170 Because of how the mangling is done, any method that has a '_' in
9171 its original name is at risk of being demangled incorrectly. In
9172 some cases there are multiple valid ways to demangle a method name
9173 and there is no way we can decide.
9175 TODO: objc_demangle() can't always get it right; the right way to
9176 get this correct for all method names would be to store the
9177 Objective-C method name somewhere in the function decl. Then,
9178 there is no demangling to do; we'd just pull the method name out of
9179 the decl. As an additional bonus, when printing error messages we
9180 could check for such a method name, and if we find it, we know the
9181 function is actually an Objective-C method and we could print error
9182 messages saying "In method '+[NSObject class]" instead of "In
9183 function '+[NSObject class]" as we do now. */
9185 objc_demangle (const char *mangled
)
9187 char *demangled
, *cp
;
9189 /* First of all, if the name is too short it can't be an Objective-C
9190 mangled method name. */
9191 if (mangled
[0] == '\0' || mangled
[1] == '\0' || mangled
[2] == '\0')
9194 /* If the name looks like an already demangled one, return it
9195 unchanged. This should only happen on Darwin, where method names
9196 are mangled differently into a pretty-print form (such as
9197 '+[NSObject class]', see darwin.h). In that case, demangling is
9198 a no-op, but we need to return the demangled name if it was an
9199 ObjC one, and return NULL if not. We should be safe as no C/C++
9200 function can start with "-[" or "+[". */
9201 if ((mangled
[0] == '-' || mangled
[0] == '+')
9202 && (mangled
[1] == '['))
9205 if (mangled
[0] == '_' &&
9206 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
9209 cp
= demangled
= XNEWVEC (char, strlen(mangled
) + 2);
9210 if (mangled
[1] == 'i')
9211 *cp
++ = '-'; /* for instance method */
9213 *cp
++ = '+'; /* for class method */
9214 *cp
++ = '['; /* opening left brace */
9215 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
9216 while (*cp
&& *cp
== '_')
9217 cp
++; /* skip any initial underbars in class name */
9218 cp
= strchr(cp
, '_'); /* find first non-initial underbar */
9221 free(demangled
); /* not mangled name */
9224 if (cp
[1] == '_') /* easy case: no category name */
9226 *cp
++ = ' '; /* replace two '_' with one ' ' */
9227 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
9231 *cp
++ = '('; /* less easy case: category name */
9232 cp
= strchr(cp
, '_');
9235 free(demangled
); /* not mangled name */
9239 *cp
++ = ' '; /* overwriting 1st char of method name... */
9240 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
9242 /* Now we have the method name. We need to generally replace
9243 '_' with ':' but trying to preserve '_' if it could only have
9244 been in the mangled string because it was already in the
9245 original name. In cases where it's ambiguous, we assume that
9246 any '_' originated from a ':'. */
9248 /* Initial '_'s in method name can't have been generating by
9249 converting ':'s. Skip them. */
9250 while (*cp
&& *cp
== '_')
9253 /* If the method name does not end with '_', then it has no
9254 arguments and there was no replacement of ':'s with '_'s
9255 during mangling. Check for that case, and skip any
9256 replacement if so. This at least guarantees that methods
9257 with no arguments are always demangled correctly (unless the
9258 original name ends with '_'). */
9259 if (*(mangled
+ strlen (mangled
) - 1) != '_')
9261 /* Skip to the end. */
9267 /* Replace remaining '_' with ':'. This may get it wrong if
9268 there were '_'s in the original name. In most cases it
9269 is impossible to disambiguate. */
9274 *cp
++ = ']'; /* closing right brace */
9275 *cp
++ = 0; /* string terminator */
9279 return NULL
; /* not an objc mangled name */
9282 /* Try to pretty-print a decl. If the 'decl' is an Objective-C
9283 specific decl, return the printable name for it. If not, return
9286 objc_maybe_printable_name (tree decl
, int v ATTRIBUTE_UNUSED
)
9288 switch (TREE_CODE (decl
))
9291 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl
)));
9294 /* The following happens when we are printing a deprecation
9295 warning for a method. The warn_deprecation() will end up
9296 trying to print the decl for INSTANCE_METHOD_DECL or
9297 CLASS_METHOD_DECL. It would be nice to be able to print
9298 "-[NSObject autorelease] is deprecated", but to do that, we'd
9299 need to store the class and method name in the method decl,
9300 which we currently don't do. For now, just return the name
9301 of the method. We don't return NULL, because that may
9302 trigger further attempts to pretty-print the decl in C/C++,
9303 but they wouldn't know how to pretty-print it. */
9304 case INSTANCE_METHOD_DECL
:
9305 case CLASS_METHOD_DECL
:
9306 return IDENTIFIER_POINTER (DECL_NAME (decl
));
9308 /* This happens when printing a deprecation warning for a
9309 property. We may want to consider some sort of pretty
9310 printing (eg, include the class name where it was declared
9313 return IDENTIFIER_POINTER (PROPERTY_NAME (decl
));
9321 /* Return a printable name for 'decl'. This first tries
9322 objc_maybe_printable_name(), and if that fails, it returns the name
9323 in the decl. This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for
9324 Objective-C; in Objective-C++, setting the hook is not enough
9325 because lots of C++ Front-End code calls cxx_printable_name,
9326 dump_decl and other C++ functions directly. So instead we have
9327 modified dump_decl to call objc_maybe_printable_name directly. */
9329 objc_printable_name (tree decl
, int v
)
9331 const char *demangled_name
= objc_maybe_printable_name (decl
, v
);
9333 if (demangled_name
!= NULL
)
9334 return demangled_name
;
9336 return IDENTIFIER_POINTER (DECL_NAME (decl
));
9339 /* Routine is called to issue diagnostic when reference to a private
9340 ivar is made and no other variable with same name is found in
9343 objc_diagnose_private_ivar (tree id
)
9346 if (!objc_method_context
)
9348 ivar
= is_ivar (objc_ivar_chain
, id
);
9349 if (ivar
&& is_private (ivar
))
9351 error ("instance variable %qs is declared private",
9352 IDENTIFIER_POINTER (id
));
9358 /* Look up ID as an instance variable. OTHER contains the result of
9359 the C or C++ lookup, which we may want to use instead. */
9360 /* To use properties inside an instance method, use self.property. */
9362 objc_lookup_ivar (tree other
, tree id
)
9366 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
9367 if (!objc_method_context
)
9370 if (!strcmp (IDENTIFIER_POINTER (id
), "super"))
9371 /* We have a message to super. */
9372 return get_super_receiver ();
9374 /* In a class method, look up an instance variable only as a last
9376 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
9377 && other
&& other
!= error_mark_node
)
9380 /* Don't look up the ivar if the user has explicitly advised against
9381 it with -fno-local-ivars. */
9383 if (!flag_local_ivars
)
9386 /* Look up the ivar, but do not use it if it is not accessible. */
9387 ivar
= is_ivar (objc_ivar_chain
, id
);
9389 if (!ivar
|| is_private (ivar
))
9392 /* In an instance method, a local variable (or parameter) may hide the
9393 instance variable. */
9394 if (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
9395 && other
&& other
!= error_mark_node
9397 && CP_DECL_CONTEXT (other
) != global_namespace
)
9399 && !DECL_FILE_SCOPE_P (other
))
9402 if (warn_shadow_ivar
== 1 || (warn_shadow
&& warn_shadow_ivar
!= 0)) {
9403 warning (warn_shadow_ivar
? OPT_Wshadow_ivar
: OPT_Wshadow
,
9404 "local declaration of %qE hides instance variable", id
);
9410 /* At this point, we are either in an instance method with no obscuring
9411 local definitions, or in a class method with no alternate definitions
9413 return build_ivar_reference (id
);
9416 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This
9417 needs to be done if we are calling a function through a cast. */
9420 objc_rewrite_function_call (tree function
, tree first_param
)
9422 if (TREE_CODE (function
) == NOP_EXPR
9423 && TREE_CODE (TREE_OPERAND (function
, 0)) == ADDR_EXPR
9424 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function
, 0), 0))
9427 function
= build3 (OBJ_TYPE_REF
, TREE_TYPE (function
),
9428 TREE_OPERAND (function
, 0),
9429 first_param
, size_zero_node
);
9435 /* This is called to "gimplify" a PROPERTY_REF node. It builds the
9436 corresponding 'getter' function call. Note that we assume the
9437 PROPERTY_REF to be valid since we generated it while parsing. */
9439 objc_gimplify_property_ref (tree
*expr_p
)
9441 tree getter
= PROPERTY_REF_GETTER_CALL (*expr_p
);
9444 if (getter
== NULL_TREE
)
9446 tree property_decl
= PROPERTY_REF_PROPERTY_DECL (*expr_p
);
9447 /* This can happen if DECL_ARTIFICIAL (*expr_p), but
9448 should be impossible for real properties, which always
9450 error_at (EXPR_LOCATION (*expr_p
), "no %qs getter found",
9451 IDENTIFIER_POINTER (PROPERTY_NAME (property_decl
)));
9452 /* Try to recover from the error to prevent an ICE. We take
9453 zero and cast it to the type of the property. */
9454 *expr_p
= convert (TREE_TYPE (property_decl
),
9459 if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p
))
9461 /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype
9462 that is deprecated. */
9463 warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p
),
9469 /* In C++, a getter which returns an aggregate value results in a
9470 target_expr which initializes a temporary to the call
9472 if (TREE_CODE (getter
) == TARGET_EXPR
)
9474 gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter
)));
9475 gcc_assert (TREE_CODE (TREE_OPERAND (getter
, 0)) == VAR_DECL
);
9476 call_exp
= TREE_OPERAND (getter
, 1);
9479 gcc_assert (TREE_CODE (call_exp
) == CALL_EXPR
);
9484 /* This is called when "gimplifying" the trees. We need to gimplify
9485 the Objective-C/Objective-C++ specific trees, then hand over the
9486 process to C/C++. */
9488 objc_gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
9490 enum tree_code code
= TREE_CODE (*expr_p
);
9493 /* Look for the special case of OBJC_TYPE_REF with the address
9494 of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend
9495 or one of its cousins). */
9497 if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p
)) == ADDR_EXPR
9498 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p
), 0))
9501 enum gimplify_status r0
, r1
;
9503 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
9504 value of the OBJ_TYPE_REF, so force them to be emitted
9505 during subexpression evaluation rather than after the
9506 OBJ_TYPE_REF. This permits objc_msgSend calls in
9507 Objective C to use direct rather than indirect calls when
9508 the object expression has a postincrement. */
9509 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
, NULL
,
9510 is_gimple_val
, fb_rvalue
);
9511 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
, post_p
,
9512 is_gimple_val
, fb_rvalue
);
9514 return MIN (r0
, r1
);
9518 objc_gimplify_property_ref (expr_p
);
9519 /* Do not return yet; let C/C++ gimplify the resulting expression. */
9526 return (enum gimplify_status
) cp_gimplify_expr (expr_p
, pre_p
, post_p
);
9528 return (enum gimplify_status
) c_gimplify_expr (expr_p
, pre_p
, post_p
);
9532 /* --- FAST ENUMERATION --- */
9533 /* Begin code generation for fast enumeration (foreach) ... */
9537 struct __objcFastEnumerationState
9539 unsigned long state;
9541 unsigned long *mutationsPtr;
9542 unsigned long extra[5];
9545 Confusingly enough, NSFastEnumeration is then defined by libraries
9546 to be the same structure.
9550 build_fast_enumeration_state_template (void)
9552 tree decls
, *chain
= NULL
;
9555 objc_fast_enumeration_state_template
= objc_start_struct (get_identifier
9556 (TAG_FAST_ENUMERATION_STATE
));
9558 /* unsigned long state; */
9559 decls
= add_field_decl (long_unsigned_type_node
, "state", &chain
);
9562 add_field_decl (build_pointer_type (objc_object_type
),
9563 "itemsPtr", &chain
);
9565 /* unsigned long *mutationsPtr; */
9566 add_field_decl (build_pointer_type (long_unsigned_type_node
),
9567 "mutationsPtr", &chain
);
9569 /* unsigned long extra[5]; */
9570 add_field_decl (build_sized_array_type (long_unsigned_type_node
, 5),
9574 objc_finish_struct (objc_fast_enumeration_state_template
, decls
);
9578 'objc_finish_foreach_loop()' generates the code for an Objective-C
9579 foreach loop. The 'location' argument is the location of the 'for'
9580 that starts the loop. The 'object_expression' is the expression of
9581 the 'object' that iterates; the 'collection_expression' is the
9582 expression of the collection that we iterate over (we need to make
9583 sure we evaluate this only once); the 'for_body' is the set of
9584 statements to be executed in each iteration; 'break_label' and
9585 'continue_label' are the break and continue labels which we need to
9586 emit since the <statements> may be jumping to 'break_label' (if they
9587 contain 'break') or to 'continue_label' (if they contain
9592 for (<object expression> in <collection expression>)
9595 which is compiled into the following blurb:
9598 id __objc_foreach_collection;
9599 __objc_fast_enumeration_state __objc_foreach_enum_state;
9600 unsigned long __objc_foreach_batchsize;
9601 id __objc_foreach_items[16];
9602 __objc_foreach_collection = <collection expression>;
9603 __objc_foreach_enum_state = { 0 };
9604 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
9606 if (__objc_foreach_batchsize == 0)
9607 <object expression> = nil;
9610 unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr;
9613 unsigned long __objc_foreach_index;
9614 __objc_foreach_index = 0;
9617 if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>);
9618 <object expression> = enumState.itemsPtr[__objc_foreach_index];
9619 <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label]
9622 __objc_foreach_index++;
9623 if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object;
9624 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
9626 if (__objc_foreach_batchsize != 0) goto next_batch;
9627 <object expression> = nil;
9632 'statements' may contain a 'continue' or 'break' instruction, which
9633 the user expects to 'continue' or 'break' the entire foreach loop.
9634 We are provided the labels that 'break' and 'continue' jump to, so
9635 we place them where we want them to jump to when they pick them.
9637 Optimization TODO: we could cache the IMP of
9638 countByEnumeratingWithState:objects:count:.
9641 /* If you need to debug objc_finish_foreach_loop(), uncomment the following line. */
9642 /* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */
9644 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
9645 #include "tree-pretty-print.h"
9649 objc_finish_foreach_loop (location_t location
, tree object_expression
, tree collection_expression
, tree for_body
,
9650 tree break_label
, tree continue_label
)
9652 /* A tree representing the __objcFastEnumerationState struct type,
9653 or NSFastEnumerationState struct, whatever we are using. */
9654 tree objc_fast_enumeration_state_type
;
9656 /* The trees representing the declarations of each of the local variables. */
9657 tree objc_foreach_collection_decl
;
9658 tree objc_foreach_enum_state_decl
;
9659 tree objc_foreach_items_decl
;
9660 tree objc_foreach_batchsize_decl
;
9661 tree objc_foreach_mutations_pointer_decl
;
9662 tree objc_foreach_index_decl
;
9664 /* A tree representing the selector countByEnumeratingWithState:objects:count:. */
9667 /* A tree representing the local bind. */
9670 /* A tree representing the external 'if (__objc_foreach_batchsize)' */
9673 /* A tree representing the 'else' part of 'first_if' */
9676 /* A tree representing the 'next_batch' label. */
9677 tree next_batch_label_decl
;
9679 /* A tree representing the binding after the 'next_batch' label. */
9680 tree next_batch_bind
;
9682 /* A tree representing the 'next_object' label. */
9683 tree next_object_label_decl
;
9685 /* Temporary variables. */
9689 if (flag_objc1_only
)
9690 error_at (location
, "fast enumeration is not available in Objective-C 1.0");
9692 if (object_expression
== error_mark_node
)
9695 if (collection_expression
== error_mark_node
)
9698 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression
), true))
9700 error_at (location
, "iterating variable in fast enumeration is not an object");
9704 if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression
), true))
9706 error_at (location
, "collection in fast enumeration is not an object");
9710 /* TODO: Check that object_expression is either a variable
9711 declaration, or an lvalue. */
9713 /* This kludge is an idea from apple. We use the
9714 __objcFastEnumerationState struct implicitly defined by the
9715 compiler, unless a NSFastEnumerationState struct has been defined
9716 (by a Foundation library such as GNUstep Base) in which case, we
9719 objc_fast_enumeration_state_type
= objc_fast_enumeration_state_template
;
9721 tree objc_NSFastEnumeration_type
= lookup_name (get_identifier ("NSFastEnumerationState"));
9723 if (objc_NSFastEnumeration_type
)
9725 /* TODO: We really need to check that
9726 objc_NSFastEnumeration_type is the same as ours! */
9727 if (TREE_CODE (objc_NSFastEnumeration_type
) == TYPE_DECL
)
9729 /* If it's a typedef, use the original type. */
9730 if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type
))
9731 objc_fast_enumeration_state_type
= DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type
);
9733 objc_fast_enumeration_state_type
= TREE_TYPE (objc_NSFastEnumeration_type
);
9739 /* Done by c-parser.c. */
9742 /* Done by c-parser.c. */
9744 /* Disable warnings that 'object' is unused. For example the code
9746 for (id object in collection)
9749 which can be used to count how many objects there are in the
9750 collection is fine and should generate no warnings even if
9751 'object' is technically unused. */
9752 TREE_USED (object_expression
) = 1;
9753 if (DECL_P (object_expression
))
9754 DECL_READ_P (object_expression
) = 1;
9756 /* id __objc_foreach_collection */
9757 objc_foreach_collection_decl
= objc_create_temporary_var (objc_object_type
, "__objc_foreach_collection");
9759 /* __objcFastEnumerationState __objc_foreach_enum_state; */
9760 objc_foreach_enum_state_decl
= objc_create_temporary_var (objc_fast_enumeration_state_type
, "__objc_foreach_enum_state");
9761 TREE_CHAIN (objc_foreach_enum_state_decl
) = objc_foreach_collection_decl
;
9763 /* id __objc_foreach_items[16]; */
9764 objc_foreach_items_decl
= objc_create_temporary_var (build_sized_array_type (objc_object_type
, 16), "__objc_foreach_items");
9765 TREE_CHAIN (objc_foreach_items_decl
) = objc_foreach_enum_state_decl
;
9767 /* unsigned long __objc_foreach_batchsize; */
9768 objc_foreach_batchsize_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_batchsize");
9769 TREE_CHAIN (objc_foreach_batchsize_decl
) = objc_foreach_items_decl
;
9771 /* Generate the local variable binding. */
9772 bind
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_batchsize_decl
, NULL
, NULL
);
9773 SET_EXPR_LOCATION (bind
, location
);
9774 TREE_SIDE_EFFECTS (bind
) = 1;
9776 /* __objc_foreach_collection = <collection expression>; */
9777 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_collection_decl
, collection_expression
);
9778 SET_EXPR_LOCATION (t
, location
);
9779 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9780 /* We have used 'collection_expression'. */
9781 mark_exp_read (collection_expression
);
9783 /* __objc_foreach_enum_state.state = 0; */
9784 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9785 get_identifier ("state")),
9786 build_int_cst (long_unsigned_type_node
, 0));
9787 SET_EXPR_LOCATION (t
, location
);
9788 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9790 /* __objc_foreach_enum_state.itemsPtr = NULL; */
9791 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9792 get_identifier ("itemsPtr")),
9794 SET_EXPR_LOCATION (t
, location
);
9795 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9797 /* __objc_foreach_enum_state.mutationsPtr = NULL; */
9798 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9799 get_identifier ("mutationsPtr")),
9801 SET_EXPR_LOCATION (t
, location
);
9802 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9804 /* __objc_foreach_enum_state.extra[0] = 0; */
9805 /* __objc_foreach_enum_state.extra[1] = 0; */
9806 /* __objc_foreach_enum_state.extra[2] = 0; */
9807 /* __objc_foreach_enum_state.extra[3] = 0; */
9808 /* __objc_foreach_enum_state.extra[4] = 0; */
9809 for (i
= 0; i
< 5 ; i
++)
9811 t
= build2 (MODIFY_EXPR
, void_type_node
,
9812 build_array_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9813 get_identifier ("extra")),
9814 build_int_cst (NULL_TREE
, i
)),
9815 build_int_cst (long_unsigned_type_node
, 0));
9816 SET_EXPR_LOCATION (t
, location
);
9817 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9820 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
9821 selector_name
= get_identifier ("countByEnumeratingWithState:objects:count:");
9823 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9825 tree_cons
/* &__objc_foreach_enum_state */
9826 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
9827 tree_cons
/* __objc_foreach_items */
9828 (NULL_TREE
, objc_foreach_items_decl
,
9830 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
9832 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
9834 struct c_expr array
;
9835 array
.value
= objc_foreach_items_decl
;
9836 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9838 tree_cons
/* &__objc_foreach_enum_state */
9839 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
9840 tree_cons
/* __objc_foreach_items */
9841 (NULL_TREE
, default_function_array_conversion (location
, array
).value
,
9843 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
9846 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_batchsize_decl
,
9847 convert (long_unsigned_type_node
, t
));
9848 SET_EXPR_LOCATION (t
, location
);
9849 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9851 /* if (__objc_foreach_batchsize == 0) */
9852 first_if
= build3 (COND_EXPR
, void_type_node
,
9855 (c_common_truthvalue_conversion
9857 build_binary_op (location
,
9859 objc_foreach_batchsize_decl
,
9860 build_int_cst (long_unsigned_type_node
, 0), 1)),
9862 /* Then block (we fill it in later). */
9864 /* Else block (we fill it in later). */
9866 SET_EXPR_LOCATION (first_if
, location
);
9867 append_to_statement_list (first_if
, &BIND_EXPR_BODY (bind
));
9869 /* then <object expression> = nil; */
9870 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
, convert (objc_object_type
, null_pointer_node
));
9871 SET_EXPR_LOCATION (t
, location
);
9872 COND_EXPR_THEN (first_if
) = t
;
9874 /* Now we build the 'else' part of the if; once we finish building
9875 it, we attach it to first_if as the 'else' part. */
9880 /* unsigned long __objc_foreach_mutations_pointer; */
9881 objc_foreach_mutations_pointer_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_mutations_pointer");
9883 /* Generate the local variable binding. */
9884 first_else
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_mutations_pointer_decl
, NULL
, NULL
);
9885 SET_EXPR_LOCATION (first_else
, location
);
9886 TREE_SIDE_EFFECTS (first_else
) = 1;
9888 /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */
9889 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_mutations_pointer_decl
,
9890 build_indirect_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9891 get_identifier ("mutationsPtr")),
9893 SET_EXPR_LOCATION (t
, location
);
9894 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
9897 next_batch_label_decl
= create_artificial_label (location
);
9898 t
= build1 (LABEL_EXPR
, void_type_node
, next_batch_label_decl
);
9899 SET_EXPR_LOCATION (t
, location
);
9900 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
9904 /* unsigned long __objc_foreach_index; */
9905 objc_foreach_index_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_index");
9907 /* Generate the local variable binding. */
9908 next_batch_bind
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_index_decl
, NULL
, NULL
);
9909 SET_EXPR_LOCATION (next_batch_bind
, location
);
9910 TREE_SIDE_EFFECTS (next_batch_bind
) = 1;
9911 append_to_statement_list (next_batch_bind
, &BIND_EXPR_BODY (first_else
));
9913 /* __objc_foreach_index = 0; */
9914 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_index_decl
,
9915 build_int_cst (long_unsigned_type_node
, 0));
9916 SET_EXPR_LOCATION (t
, location
);
9917 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9920 next_object_label_decl
= create_artificial_label (location
);
9921 t
= build1 (LABEL_EXPR
, void_type_node
, next_object_label_decl
);
9922 SET_EXPR_LOCATION (t
, location
);
9923 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9925 /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); */
9926 t
= build3 (COND_EXPR
, void_type_node
,
9929 (c_common_truthvalue_conversion
9934 objc_foreach_mutations_pointer_decl
,
9935 build_indirect_ref (location
,
9936 objc_build_component_ref (objc_foreach_enum_state_decl
,
9937 get_identifier ("mutationsPtr")),
9938 RO_UNARY_STAR
), 1)),
9941 build_function_call (input_location
,
9942 objc_enumeration_mutation_decl
,
9943 tree_cons (NULL
, collection_expression
, NULL
)),
9946 SET_EXPR_LOCATION (t
, location
);
9947 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9949 /* <object expression> = enumState.itemsPtr[__objc_foreach_index]; */
9950 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
,
9951 build_array_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9952 get_identifier ("itemsPtr")),
9953 objc_foreach_index_decl
));
9954 SET_EXPR_LOCATION (t
, location
);
9955 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9957 /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
9958 append_to_statement_list (for_body
, &BIND_EXPR_BODY (next_batch_bind
));
9960 /* continue_label: */
9963 t
= build1 (LABEL_EXPR
, void_type_node
, continue_label
);
9964 SET_EXPR_LOCATION (t
, location
);
9965 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9968 /* __objc_foreach_index++; */
9969 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_index_decl
,
9970 build_binary_op (location
,
9972 objc_foreach_index_decl
,
9973 build_int_cst (long_unsigned_type_node
, 1), 1));
9974 SET_EXPR_LOCATION (t
, location
);
9975 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9977 /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */
9978 t
= build3 (COND_EXPR
, void_type_node
,
9981 (c_common_truthvalue_conversion
9983 build_binary_op (location
,
9985 objc_foreach_index_decl
,
9986 objc_foreach_batchsize_decl
, 1)),
9989 build1 (GOTO_EXPR
, void_type_node
, next_object_label_decl
),
9992 SET_EXPR_LOCATION (t
, location
);
9993 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9995 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
9997 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9999 tree_cons
/* &__objc_foreach_enum_state */
10000 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
10001 tree_cons
/* __objc_foreach_items */
10002 (NULL_TREE
, objc_foreach_items_decl
,
10004 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
10006 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
10008 struct c_expr array
;
10009 array
.value
= objc_foreach_items_decl
;
10010 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
10012 tree_cons
/* &__objc_foreach_enum_state */
10013 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
10014 tree_cons
/* __objc_foreach_items */
10015 (NULL_TREE
, default_function_array_conversion (location
, array
).value
,
10017 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
10020 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_batchsize_decl
,
10021 convert (long_unsigned_type_node
, t
));
10022 SET_EXPR_LOCATION (t
, location
);
10023 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
10027 /* if (__objc_foreach_batchsize != 0) goto next_batch; */
10028 t
= build3 (COND_EXPR
, void_type_node
,
10031 (c_common_truthvalue_conversion
10033 build_binary_op (location
,
10035 objc_foreach_batchsize_decl
,
10036 build_int_cst (long_unsigned_type_node
, 0), 1)),
10039 build1 (GOTO_EXPR
, void_type_node
, next_batch_label_decl
),
10042 SET_EXPR_LOCATION (t
, location
);
10043 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10045 /* <object expression> = nil; */
10046 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
, convert (objc_object_type
, null_pointer_node
));
10047 SET_EXPR_LOCATION (t
, location
);
10048 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10053 t
= build1 (LABEL_EXPR
, void_type_node
, break_label
);
10054 SET_EXPR_LOCATION (t
, location
);
10055 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10059 COND_EXPR_ELSE (first_if
) = first_else
;
10061 /* Do the whole thing. */
10064 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
10065 /* This will print to stderr the whole blurb generated by the
10066 compiler while compiling (assuming the compiler doesn't crash
10067 before getting here).
10069 debug_generic_stmt (bind
);
10073 /* Done by c-parser.c */
10076 /* --- SUPPORT FOR FORMAT ARG CHECKING --- */
10077 /* Return true if we have an NxString object pointer. */
10080 objc_string_ref_type_p (tree strp
)
10083 if (!strp
|| TREE_CODE (strp
) != POINTER_TYPE
)
10086 tmv
= TYPE_MAIN_VARIANT (TREE_TYPE (strp
));
10087 tmv
= OBJC_TYPE_NAME (tmv
);
10089 && TREE_CODE (tmv
) == IDENTIFIER_NODE
10090 && IDENTIFIER_POINTER (tmv
)
10091 && !strncmp (IDENTIFIER_POINTER (tmv
), "NSString", 8));
10094 /* At present the behavior of this is undefined and it does nothing. */
10096 objc_check_format_arg (tree
ARG_UNUSED (format_arg
),
10097 tree
ARG_UNUSED (args_list
))
10102 objc_common_init_ts (void)
10104 c_common_init_ts ();
10106 MARK_TS_DECL_NON_COMMON (CLASS_METHOD_DECL
);
10107 MARK_TS_DECL_NON_COMMON (INSTANCE_METHOD_DECL
);
10108 MARK_TS_DECL_NON_COMMON (KEYWORD_DECL
);
10109 MARK_TS_DECL_NON_COMMON (PROPERTY_DECL
);
10111 MARK_TS_COMMON (CLASS_INTERFACE_TYPE
);
10112 MARK_TS_COMMON (PROTOCOL_INTERFACE_TYPE
);
10113 MARK_TS_COMMON (CLASS_IMPLEMENTATION_TYPE
);
10115 MARK_TS_TYPED (MESSAGE_SEND_EXPR
);
10116 MARK_TS_TYPED (PROPERTY_REF
);
10120 objc_common_tree_size (enum tree_code code
)
10124 case CLASS_METHOD_DECL
:
10125 case INSTANCE_METHOD_DECL
:
10127 case PROPERTY_DECL
:
10128 return sizeof (struct tree_decl_non_common
);
10130 gcc_unreachable ();
10136 #include "gt-objc-objc-act.h"