1 /* Implement classes and message passing for Objective C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5 Contributed by Steve Naroff.
7 This file is part of GCC.
9 GCC is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
14 GCC is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GCC; see the file COPYING3. If not see
21 <http://www.gnu.org/licenses/>. */
25 #include "coretypes.h"
36 #include "c-family/c-common.h"
37 #include "c-family/c-objc.h"
38 #include "c-family/c-pragma.h"
39 #include "c-family/c-format.h"
41 #include "langhooks.h"
49 #include "c-family/c-target.h"
50 #include "diagnostic-core.h"
53 #include "tree-iterator.h"
55 #include "langhooks-def.h"
56 /* Different initialization, code gen and meta data generation for each
58 #include "objc-runtime-hooks.h"
59 /* Routines used mainly by the runtimes. */
60 #include "objc-runtime-shared-support.h"
61 /* For default_tree_printer (). */
62 #include "tree-pretty-print.h"
64 /* For enum gimplify_status */
67 static unsigned int should_call_super_dealloc
= 0;
69 /* When building Objective-C++, we are not linking against the C front-end
70 and so need to replicate the C tree-construction functions in some way. */
72 #define OBJCP_REMAP_FUNCTIONS
73 #include "objcp-decl.h"
76 /* This is the default way of generating a method name. */
77 /* This has the problem that "test_method:argument:" and
78 "test:method_argument:" will generate the same name
79 ("_i_Test__test_method_argument_" for an instance method of the
80 class "Test"), so you can't have them both in the same class!
81 Moreover, the demangling (going from
82 "_i_Test__test_method_argument" back to the original name) is
83 undefined because there are two correct ways of demangling the
85 #ifndef OBJC_GEN_METHOD_LABEL
86 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
89 sprintf ((BUF), "_%s_%s_%s_%s", \
90 ((IS_INST) ? "i" : "c"), \
92 ((CAT_NAME)? (CAT_NAME) : ""), \
94 for (temp = (BUF); *temp; temp++) \
95 if (*temp == ':') *temp = '_'; \
99 /* These need specifying. */
100 #ifndef OBJC_FORWARDING_STACK_OFFSET
101 #define OBJC_FORWARDING_STACK_OFFSET 0
104 #ifndef OBJC_FORWARDING_MIN_OFFSET
105 #define OBJC_FORWARDING_MIN_OFFSET 0
108 /* Set up for use of obstacks. */
112 /* This obstack is used to accumulate the encoding of a data type. */
113 struct obstack util_obstack
;
115 /* This points to the beginning of obstack contents, so we can free
116 the whole contents. */
119 /*** Private Interface (procedures) ***/
122 static void synth_module_prologue (void);
124 /* Code generation. */
126 static tree
start_class (enum tree_code
, tree
, tree
, tree
, tree
);
127 static tree
continue_class (tree
);
128 static void finish_class (tree
);
129 static void start_method_def (tree
);
131 static tree
start_protocol (enum tree_code
, tree
, tree
, tree
);
132 static tree
build_method_decl (enum tree_code
, tree
, tree
, tree
, bool);
133 static tree
objc_add_method (tree
, tree
, int, bool);
134 static tree
add_instance_variable (tree
, objc_ivar_visibility_kind
, tree
);
135 static tree
build_ivar_reference (tree
);
136 static tree
is_ivar (tree
, tree
);
138 /* We only need the following for ObjC; ObjC++ will use C++'s definition
139 of DERIVED_FROM_P. */
141 static bool objc_derived_from_p (tree
, tree
);
142 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
146 static void objc_gen_property_data (tree
, tree
);
147 static void objc_synthesize_getter (tree
, tree
, tree
);
148 static void objc_synthesize_setter (tree
, tree
, tree
);
149 static char *objc_build_property_setter_name (tree
);
150 static tree
lookup_property (tree
, tree
);
151 static tree
lookup_property_in_list (tree
, tree
);
152 static tree
lookup_property_in_protocol_list (tree
, tree
);
153 static void build_common_objc_property_accessor_helpers (void);
155 static void objc_xref_basetypes (tree
, tree
);
157 static tree
get_class_ivars (tree
, bool);
159 static void build_fast_enumeration_state_template (void);
162 static void objc_generate_cxx_cdtors (void);
166 static void objc_decl_method_attributes (tree
*, tree
, int);
167 static tree
build_keyword_selector (tree
);
169 /* Hash tables to manage the global pool of method prototypes. */
170 static void hash_init (void);
172 hash
*nst_method_hash_list
= 0;
173 hash
*cls_method_hash_list
= 0;
175 /* Hash tables to manage the global pool of class names. */
177 hash
*cls_name_hash_list
= 0;
178 hash
*als_name_hash_list
= 0;
180 hash
*ivar_offset_hash_list
= 0;
182 static void hash_class_name_enter (hash
*, tree
, tree
);
183 static hash
hash_class_name_lookup (hash
*, tree
);
185 static hash
hash_lookup (hash
*, tree
);
186 static tree
lookup_method (tree
, tree
);
187 static tree
lookup_method_static (tree
, tree
, int);
189 static tree
add_class (tree
, tree
);
190 static void add_category (tree
, tree
);
191 static inline tree
lookup_category (tree
, tree
);
195 static tree
lookup_protocol (tree
, bool, bool);
196 static tree
lookup_and_install_protocols (tree
, bool);
200 static void encode_type_qualifiers (tree
);
201 static void encode_type (tree
, int, int);
204 static void really_start_method (tree
, tree
);
206 static void really_start_method (tree
, struct c_arg_info
*);
208 static int comp_proto_with_proto (tree
, tree
, int);
209 static tree
objc_decay_parm_type (tree
);
211 /* Utilities for debugging and error diagnostics. */
213 static char *gen_type_name (tree
);
214 static char *gen_type_name_0 (tree
);
215 static char *gen_method_decl (tree
);
216 static char *gen_declaration (tree
);
218 /* Everything else. */
220 static void generate_struct_by_value_array (void) ATTRIBUTE_NORETURN
;
222 static void mark_referenced_methods (void);
223 static bool objc_type_valid_for_messaging (tree type
, bool allow_classes
);
224 static tree
check_duplicates (hash
, int, int);
226 /*** Private Interface (data) ***/
227 /* Flags for lookup_method_static(). */
229 /* Look for class methods. */
230 #define OBJC_LOOKUP_CLASS 1
231 /* Do not examine superclasses. */
232 #define OBJC_LOOKUP_NO_SUPER 2
233 /* Disable returning an instance method of a root class when a class
234 method can't be found. */
235 #define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4
237 /* The OCTI_... enumeration itself is in objc/objc-act.h. */
238 tree objc_global_trees
[OCTI_MAX
];
240 struct imp_entry
*imp_list
= 0;
241 int imp_count
= 0; /* `@implementation' */
242 int cat_count
= 0; /* `@category' */
244 objc_ivar_visibility_kind objc_ivar_visibility
;
246 /* Use to generate method labels. */
247 static int method_slot
= 0;
249 /* Flag to say whether methods in a protocol are optional or
251 static bool objc_method_optional_flag
= false;
253 static int objc_collecting_ivars
= 0;
255 /* Flag that is set to 'true' while we are processing a class
256 extension. Since a class extension just "reopens" the main
257 @interface, this can be used to determine if we are in the main
258 @interface, or in a class extension. */
259 static bool objc_in_class_extension
= false;
261 static char *errbuf
; /* Buffer for error diagnostics */
263 /* An array of all the local variables in the current function that
264 need to be marked as volatile. */
265 VEC(tree
,gc
) *local_variables_to_volatilize
= NULL
;
267 /* Store all constructed constant strings in a hash table so that
268 they get uniqued properly. */
270 struct GTY(()) string_descriptor
{
271 /* The literal argument . */
274 /* The resulting constant string. */
278 static GTY((param_is (struct string_descriptor
))) htab_t string_htab
;
280 FILE *gen_declaration_file
;
282 /* Tells "encode_pointer/encode_aggregate" whether we are generating
283 type descriptors for instance variables (as opposed to methods).
284 Type descriptors for instance variables contain more information
285 than methods (for static typing and embedded structures). */
287 int generating_instance_variables
= 0;
289 /* Hooks for stuff that differs between runtimes. */
290 objc_runtime_hooks runtime
;
292 /* Create a temporary variable of type 'type'. If 'name' is set, uses
293 the specified name, else use no name. Returns the declaration of
294 the type. The 'name' is mostly useful for debugging.
297 objc_create_temporary_var (tree type
, const char *name
)
303 decl
= build_decl (input_location
,
304 VAR_DECL
, get_identifier (name
), type
);
308 decl
= build_decl (input_location
,
309 VAR_DECL
, NULL_TREE
, type
);
311 TREE_USED (decl
) = 1;
312 DECL_ARTIFICIAL (decl
) = 1;
313 DECL_IGNORED_P (decl
) = 1;
314 DECL_CONTEXT (decl
) = current_function_decl
;
319 /* Some platforms pass small structures through registers versus
320 through an invisible pointer. Determine at what size structure is
321 the transition point between the two possibilities. */
324 generate_struct_by_value_array (void)
329 int aggregate_in_mem
[32];
332 /* Presumably no platform passes 32 byte structures in a register. */
333 /* ??? As an example, m64/ppc/Darwin can pass up to 8*long+13*double
335 for (i
= 1; i
< 32; i
++)
340 /* Create an unnamed struct that has `i' character components */
341 type
= objc_start_struct (NULL_TREE
);
343 strcpy (buffer
, "c1");
344 decls
= add_field_decl (char_type_node
, buffer
, &chain
);
346 for (j
= 1; j
< i
; j
++)
348 sprintf (buffer
, "c%d", j
+ 1);
349 add_field_decl (char_type_node
, buffer
, &chain
);
351 objc_finish_struct (type
, decls
);
353 aggregate_in_mem
[i
] = aggregate_value_p (type
, 0);
354 if (!aggregate_in_mem
[i
])
358 /* We found some structures that are returned in registers instead of memory
359 so output the necessary data. */
362 for (i
= 31; i
>= 0; i
--)
363 if (!aggregate_in_mem
[i
])
365 printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n", i
);
376 if (cxx_init () == false)
378 if (c_objc_common_init () == false)
382 /* print_struct_values is triggered by -print-runtime-info (used
383 when building libobjc, with an empty file as input). It does not
384 require any ObjC setup, and it never returns.
386 -fcompare-debug is used to check the compiler output; we are
387 executed twice, once with flag_compare_debug set, and once with
388 it not set. If the flag is used together with
389 -print-runtime-info, we want to print the runtime info only once,
390 else it would be output in duplicate. So we check
391 flag_compare_debug to output it in only one of the invocations.
393 As a side effect, this also that means -fcompare-debug
394 -print-runtime-info will run the compiler twice, and compare the
395 generated assembler file; the first time the compiler exits
396 immediately (producing no file), and the second time it compiles
397 an empty file. This checks, as a side effect, that compiling an
398 empty file produces no assembler output. */
399 if (print_struct_values
&& !flag_compare_debug
)
400 generate_struct_by_value_array ();
402 /* Set up stuff used by FE parser and all runtimes. */
403 errbuf
= XNEWVEC (char, 1024 * 10);
405 gcc_obstack_init (&util_obstack
);
406 util_firstobj
= (char *) obstack_finish (&util_obstack
);
408 /* ... and then check flags and set-up for the selected runtime ... */
409 if (flag_next_runtime
&& flag_objc_abi
>= 2)
410 ok
= objc_next_runtime_abi_02_init (&runtime
);
411 else if (flag_next_runtime
)
412 ok
= objc_next_runtime_abi_01_init (&runtime
);
414 ok
= objc_gnu_runtime_abi_01_init (&runtime
);
416 /* If that part of the setup failed - bail out immediately. */
420 /* Generate general types and push runtime-specific decls to file scope. */
421 synth_module_prologue ();
426 /* This is called automatically (at the very end of compilation) by
427 c_write_global_declarations and cp_write_global_declarations. */
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
;
447 /* Run through the selector hash tables and print a warning for any
448 selector which has multiple methods. */
450 for (slot
= 0; slot
< SIZEHASHTABLE
; slot
++)
452 for (hsh
= cls_method_hash_list
[slot
]; hsh
; hsh
= hsh
->next
)
453 check_duplicates (hsh
, 0, 1);
454 for (hsh
= nst_method_hash_list
[slot
]; hsh
; hsh
= hsh
->next
)
455 check_duplicates (hsh
, 0, 0);
459 /* TODO: consider an early exit here if either errorcount or sorrycount
460 is non-zero. Not only is it wasting time to generate the metadata,
461 it needlessly imposes need to re-check for things that are already
462 determined to be errors. */
464 /* Finalize Objective-C runtime data. No need to generate tables
465 and code if only checking syntax, or if generating a PCH file. */
466 if (!flag_syntax_only
&& !pch_file
)
468 location_t saved_location
;
470 /* If gen_declaration desired, open the output file. */
471 if (flag_gen_declaration
)
473 char * const dumpname
= concat (dump_base_name
, ".decl", NULL
);
474 gen_declaration_file
= fopen (dumpname
, "w");
475 if (gen_declaration_file
== 0)
476 fatal_error ("can%'t open %s: %m", dumpname
);
480 /* Set the input location to BUILTINS_LOCATION. This is good
481 for error messages, in case any is generated while producing
482 the metadata, but it also silences warnings that would be
483 produced when compiling with -Wpadded in case when padding is
484 automatically added to the built-in runtime data structure
485 declarations. We know about this padding, and it is fine; we
486 don't want users to see any warnings about it if they use
488 saved_location
= input_location
;
489 input_location
= BUILTINS_LOCATION
;
491 /* Compute and emit the meta-data tables for this runtime. */
492 (*runtime
.generate_metadata
) ();
494 /* Restore the original location, just in case it mattered. */
495 input_location
= saved_location
;
497 /* ... and then close any declaration file we opened. */
498 if (gen_declaration_file
)
499 fclose (gen_declaration_file
);
503 /* Return the first occurrence of a method declaration corresponding
504 to sel_name in rproto_list. Search rproto_list recursively.
505 If is_class is 0, search for instance methods, otherwise for class
508 lookup_method_in_protocol_list (tree rproto_list
, tree sel_name
,
513 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
515 p
= TREE_VALUE (rproto
);
518 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
520 /* First, search the @required protocol methods. */
522 m
= lookup_method (PROTOCOL_CLS_METHODS (p
), sel_name
);
524 m
= lookup_method (PROTOCOL_NST_METHODS (p
), sel_name
);
529 /* If still not found, search the @optional protocol methods. */
531 m
= lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p
), sel_name
);
533 m
= lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p
), sel_name
);
538 /* If still not found, search the attached protocols. */
539 if (PROTOCOL_LIST (p
))
540 m
= lookup_method_in_protocol_list (PROTOCOL_LIST (p
),
547 ; /* An identifier...if we could not find a protocol. */
555 lookup_protocol_in_reflist (tree rproto_list
, tree lproto
)
559 /* Make sure the protocol is supported by the object on the rhs. */
560 if (TREE_CODE (lproto
) == PROTOCOL_INTERFACE_TYPE
)
563 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
565 p
= TREE_VALUE (rproto
);
567 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
572 else if (PROTOCOL_LIST (p
))
573 fnd
= lookup_protocol_in_reflist (PROTOCOL_LIST (p
), lproto
);
582 ; /* An identifier...if we could not find a protocol. */
589 objc_start_class_interface (tree klass
, tree super_class
,
590 tree protos
, tree attributes
)
592 if (flag_objc1_only
&& attributes
)
593 error_at (input_location
, "class attributes are not available in Objective-C 1.0");
595 objc_interface_context
597 = start_class (CLASS_INTERFACE_TYPE
, klass
, super_class
, protos
, attributes
);
598 objc_ivar_visibility
= OBJC_IVAR_VIS_PROTECTED
;
602 objc_start_category_interface (tree klass
, tree categ
,
603 tree protos
, tree attributes
)
608 error_at (input_location
, "category attributes are not available in Objective-C 1.0");
610 warning_at (input_location
, OPT_Wattributes
,
611 "category attributes are not available in this version"
612 " of the compiler, (ignored)");
614 if (categ
== NULL_TREE
)
617 error_at (input_location
, "class extensions are not available in Objective-C 1.0");
620 /* Iterate over all the classes and categories implemented
621 up to now in this compilation unit. */
624 for (t
= imp_list
; t
; t
= t
->next
)
626 /* If we find a class @implementation with the same name
627 as the one we are extending, produce an error. */
628 if (TREE_CODE (t
->imp_context
) == CLASS_IMPLEMENTATION_TYPE
629 && IDENTIFIER_POINTER (CLASS_NAME (t
->imp_context
)) == IDENTIFIER_POINTER (klass
))
630 error_at (input_location
,
631 "class extension for class %qE declared after its %<@implementation%>",
636 objc_interface_context
637 = start_class (CATEGORY_INTERFACE_TYPE
, klass
, categ
, protos
, NULL_TREE
);
639 = continue_class (objc_interface_context
);
643 objc_start_protocol (tree name
, tree protos
, tree attributes
)
645 if (flag_objc1_only
&& attributes
)
646 error_at (input_location
, "protocol attributes are not available in Objective-C 1.0");
648 objc_interface_context
649 = start_protocol (PROTOCOL_INTERFACE_TYPE
, name
, protos
, attributes
);
650 objc_method_optional_flag
= false;
654 objc_continue_interface (void)
657 = continue_class (objc_interface_context
);
661 objc_finish_interface (void)
663 finish_class (objc_interface_context
);
664 objc_interface_context
= NULL_TREE
;
665 objc_method_optional_flag
= false;
666 objc_in_class_extension
= false;
670 objc_start_class_implementation (tree klass
, tree super_class
)
672 objc_implementation_context
674 = start_class (CLASS_IMPLEMENTATION_TYPE
, klass
, super_class
, NULL_TREE
,
676 objc_ivar_visibility
= OBJC_IVAR_VIS_PROTECTED
;
680 objc_start_category_implementation (tree klass
, tree categ
)
682 objc_implementation_context
683 = start_class (CATEGORY_IMPLEMENTATION_TYPE
, klass
, categ
, NULL_TREE
,
686 = continue_class (objc_implementation_context
);
690 objc_continue_implementation (void)
693 = continue_class (objc_implementation_context
);
697 objc_finish_implementation (void)
700 if (flag_objc_call_cxx_cdtors
)
701 objc_generate_cxx_cdtors ();
704 if (objc_implementation_context
)
706 finish_class (objc_implementation_context
);
707 objc_ivar_chain
= NULL_TREE
;
708 objc_implementation_context
= NULL_TREE
;
711 warning (0, "%<@end%> must appear in an @implementation context");
715 objc_set_visibility (objc_ivar_visibility_kind visibility
)
717 if (visibility
== OBJC_IVAR_VIS_PACKAGE
)
720 error ("%<@package%> is not available in Objective-C 1.0");
722 warning (0, "%<@package%> presently has the same effect as %<@public%>");
724 objc_ivar_visibility
= visibility
;
728 objc_set_method_opt (bool optional
)
733 error_at (input_location
, "%<@optional%> is not available in Objective-C 1.0");
735 error_at (input_location
, "%<@required%> is not available in Objective-C 1.0");
738 objc_method_optional_flag
= optional
;
739 if (!objc_interface_context
740 || TREE_CODE (objc_interface_context
) != PROTOCOL_INTERFACE_TYPE
)
743 error ("%<@optional%> is allowed in @protocol context only");
745 error ("%<@required%> is allowed in @protocol context only");
746 objc_method_optional_flag
= false;
750 /* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or
753 lookup_property_in_list (tree chain
, tree property
)
756 for (x
= CLASS_PROPERTY_DECL (chain
); x
; x
= TREE_CHAIN (x
))
757 if (PROPERTY_NAME (x
) == property
)
762 /* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */
763 static tree
lookup_property_in_protocol_list (tree rproto_list
, tree property
)
766 for (rproto
= rproto_list
; rproto
; rproto
= TREE_CHAIN (rproto
))
768 tree p
= TREE_VALUE (rproto
);
769 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
771 if ((x
= lookup_property_in_list (p
, property
)))
773 if (PROTOCOL_LIST (p
))
774 return lookup_property_in_protocol_list (PROTOCOL_LIST (p
), property
);
778 ; /* An identifier...if we could not find a protocol. */
784 /* This routine looks up the PROPERTY in current INTERFACE, its categories and up the
785 chain of interface hierarchy. */
787 lookup_property (tree interface_type
, tree property
)
789 tree inter
= interface_type
;
793 if ((x
= lookup_property_in_list (inter
, property
)))
795 /* Failing that, look for the property in each category of the class. */
797 while ((category
= CLASS_CATEGORY_LIST (category
)))
799 if ((x
= lookup_property_in_list (category
, property
)))
802 /* When checking a category, also check the protocols
803 attached with the category itself. */
804 if (CLASS_PROTOCOL_LIST (category
)
805 && (x
= lookup_property_in_protocol_list
806 (CLASS_PROTOCOL_LIST (category
), property
)))
810 /* Failing to find in categories, look for property in protocol list. */
811 if (CLASS_PROTOCOL_LIST (inter
)
812 && (x
= lookup_property_in_protocol_list
813 (CLASS_PROTOCOL_LIST (inter
), property
)))
816 /* Failing that, climb up the inheritance hierarchy. */
817 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
822 /* This routine is called by the parser when a
823 @property... declaration is found. 'decl' is the declaration of
824 the property (type/identifier), and the other arguments represent
825 property attributes that may have been specified in the Objective-C
826 declaration. 'parsed_property_readonly' is 'true' if the attribute
827 'readonly' was specified, and 'false' if not; similarly for the
828 other bool parameters. 'parsed_property_getter_ident' is NULL_TREE
829 if the attribute 'getter' was not specified, and is the identifier
830 corresponding to the specified getter if it was; similarly for
831 'parsed_property_setter_ident'. */
833 objc_add_property_declaration (location_t location
, tree decl
,
834 bool parsed_property_readonly
, bool parsed_property_readwrite
,
835 bool parsed_property_assign
, bool parsed_property_retain
,
836 bool parsed_property_copy
, bool parsed_property_nonatomic
,
837 tree parsed_property_getter_ident
, tree parsed_property_setter_ident
)
841 /* 'property_readonly' and 'property_assign_semantics' are the final
842 attributes of the property after all parsed attributes have been
843 considered (eg, if we parsed no 'readonly' and no 'readwrite', ie
844 parsed_property_readonly = false and parsed_property_readwrite =
845 false, then property_readonly will be false because the default
847 bool property_readonly
= false;
848 objc_property_assign_semantics property_assign_semantics
= OBJC_PROPERTY_ASSIGN
;
849 bool property_extension_in_class_extension
= false;
852 error_at (input_location
, "%<@property%> is not available in Objective-C 1.0");
854 if (parsed_property_readonly
&& parsed_property_readwrite
)
856 error_at (location
, "%<readonly%> attribute conflicts with %<readwrite%> attribute");
857 /* In case of conflicting attributes (here and below), after
858 producing an error, we pick one of the attributes and keep
860 property_readonly
= false;
864 if (parsed_property_readonly
)
865 property_readonly
= true;
867 if (parsed_property_readwrite
)
868 property_readonly
= false;
871 if (parsed_property_readonly
&& parsed_property_setter_ident
)
873 error_at (location
, "%<readonly%> attribute conflicts with %<setter%> attribute");
874 property_readonly
= false;
877 if (parsed_property_assign
&& parsed_property_retain
)
879 error_at (location
, "%<assign%> attribute conflicts with %<retain%> attribute");
880 property_assign_semantics
= OBJC_PROPERTY_RETAIN
;
882 else if (parsed_property_assign
&& parsed_property_copy
)
884 error_at (location
, "%<assign%> attribute conflicts with %<copy%> attribute");
885 property_assign_semantics
= OBJC_PROPERTY_COPY
;
887 else if (parsed_property_retain
&& parsed_property_copy
)
889 error_at (location
, "%<retain%> attribute conflicts with %<copy%> attribute");
890 property_assign_semantics
= OBJC_PROPERTY_COPY
;
894 if (parsed_property_assign
)
895 property_assign_semantics
= OBJC_PROPERTY_ASSIGN
;
897 if (parsed_property_retain
)
898 property_assign_semantics
= OBJC_PROPERTY_RETAIN
;
900 if (parsed_property_copy
)
901 property_assign_semantics
= OBJC_PROPERTY_COPY
;
904 if (!objc_interface_context
)
906 error_at (location
, "property declaration not in @interface or @protocol context");
910 /* At this point we know that we are either in an interface, a
911 category, or a protocol. */
913 /* We expect a FIELD_DECL from the parser. Make sure we didn't get
914 something else, as that would confuse the checks below. */
915 if (TREE_CODE (decl
) != FIELD_DECL
)
917 error_at (location
, "invalid property declaration");
921 /* Do some spot-checks for the most obvious invalid types. */
923 if (TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
925 error_at (location
, "property can not be an array");
929 /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when
930 parsing, while the C/ObjC parser accepts it and gives us a
931 FIELD_DECL with a DECL_INITIAL set. So we use the DECL_INITIAL
932 to check for a bitfield when doing ObjC. */
934 if (DECL_INITIAL (decl
))
936 /* A @property is not an actual variable, but it is a way to
937 describe a pair of accessor methods, so its type (which is
938 the type of the return value of the getter and the first
939 argument of the setter) can't be a bitfield (as return values
940 and arguments of functions can not be bitfields). The
941 underlying instance variable could be a bitfield, but that is
942 a different matter. */
943 error_at (location
, "property can not be a bit-field");
948 /* TODO: Check that the property type is an Objective-C object or a
951 /* Implement -Wproperty-assign-default (which is enabled by default). */
952 if (warn_property_assign_default
953 /* If garbage collection is not being used, then 'assign' is
954 valid for objects (and typically used for delegates) but it
955 is wrong in most cases (since most objects need to be
956 retained or copied in setters). Warn users when 'assign' is
958 && property_assign_semantics
== OBJC_PROPERTY_ASSIGN
959 /* Read-only properties are never assigned, so the assignment
960 semantics do not matter in that case. */
961 && !property_readonly
964 /* Please note that it would make sense to default to 'assign'
965 for non-{Objective-C objects}, and to 'retain' for
966 Objective-C objects. But that would break compatibility with
968 if (!parsed_property_assign
&& !parsed_property_retain
&& !parsed_property_copy
)
970 /* Use 'false' so we do not warn for Class objects. */
971 if (objc_type_valid_for_messaging (TREE_TYPE (decl
), false))
973 warning_at (location
,
975 "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>",
978 "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it");
983 if (property_assign_semantics
== OBJC_PROPERTY_RETAIN
984 && !objc_type_valid_for_messaging (TREE_TYPE (decl
), true))
985 error_at (location
, "%<retain%> attribute is only valid for Objective-C objects");
987 if (property_assign_semantics
== OBJC_PROPERTY_COPY
988 && !objc_type_valid_for_messaging (TREE_TYPE (decl
), true))
989 error_at (location
, "%<copy%> attribute is only valid for Objective-C objects");
991 /* Now determine the final property getter and setter names. They
992 will be stored in the PROPERTY_DECL, from which they'll always be
993 extracted and used. */
995 /* Adjust, or fill in, setter and getter names. We overwrite the
996 parsed_property_setter_ident and parsed_property_getter_ident
997 with the final setter and getter identifiers that will be
999 if (parsed_property_setter_ident
)
1001 /* The setter should be terminated by ':', but the parser only
1002 gives us an identifier without ':'. So, we need to add ':'
1004 const char *parsed_setter
= IDENTIFIER_POINTER (parsed_property_setter_ident
);
1005 size_t length
= strlen (parsed_setter
);
1006 char *final_setter
= (char *)alloca (length
+ 2);
1008 sprintf (final_setter
, "%s:", parsed_setter
);
1009 parsed_property_setter_ident
= get_identifier (final_setter
);
1013 if (!property_readonly
)
1014 parsed_property_setter_ident
= get_identifier (objc_build_property_setter_name
1015 (DECL_NAME (decl
)));
1018 if (!parsed_property_getter_ident
)
1019 parsed_property_getter_ident
= DECL_NAME (decl
);
1021 /* Check for duplicate property declarations. We first check the
1022 immediate context for a property with the same name. Any such
1023 declarations are an error, unless this is a class extension and
1024 we are extending a property from readonly to readwrite. */
1025 for (x
= CLASS_PROPERTY_DECL (objc_interface_context
); x
; x
= TREE_CHAIN (x
))
1027 if (PROPERTY_NAME (x
) == DECL_NAME (decl
))
1029 if (objc_in_class_extension
1030 && property_readonly
== 0
1031 && PROPERTY_READONLY (x
) == 1)
1033 /* This is a class extension, and we are extending an
1034 existing readonly property to a readwrite one.
1036 property_extension_in_class_extension
= true;
1041 location_t original_location
= DECL_SOURCE_LOCATION (x
);
1043 error_at (location
, "redeclaration of property %qD", decl
);
1045 if (original_location
!= UNKNOWN_LOCATION
)
1046 inform (original_location
, "originally specified here");
1052 /* If x is not NULL_TREE, we must be in a class extension and we're
1053 extending a readonly property. In that case, no point in
1054 searching for another declaration. */
1057 /* We now need to check for existing property declarations (in
1058 the superclass, other categories or protocols) and check that
1059 the new declaration is not in conflict with existing
1062 /* Search for a previous, existing declaration of a property
1063 with the same name in superclasses, protocols etc. If one is
1064 found, it will be in the 'x' variable. */
1066 /* Note that, for simplicity, the following may search again the
1067 local context. That's Ok as nothing will be found (else we'd
1068 have thrown an error above); it's only a little inefficient,
1069 but the code is simpler. */
1070 switch (TREE_CODE (objc_interface_context
))
1072 case CLASS_INTERFACE_TYPE
:
1073 /* Look up the property in the current @interface (which
1074 will find nothing), then its protocols and categories and
1076 x
= lookup_property (objc_interface_context
, DECL_NAME (decl
));
1078 case CATEGORY_INTERFACE_TYPE
:
1079 /* Look up the property in the main @interface, then
1080 protocols and categories (one of them is ours, and will
1081 find nothing) and superclasses. */
1082 x
= lookup_property (lookup_interface (CLASS_NAME (objc_interface_context
)),
1085 case PROTOCOL_INTERFACE_TYPE
:
1086 /* Looks up the property in any protocols attached to the
1087 current protocol. */
1088 if (PROTOCOL_LIST (objc_interface_context
))
1090 x
= lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context
),
1101 /* An existing property was found; check that it has the same
1102 types, or it is compatible. */
1103 location_t original_location
= DECL_SOURCE_LOCATION (x
);
1105 if (PROPERTY_NONATOMIC (x
) != parsed_property_nonatomic
)
1107 warning_at (location
, 0,
1108 "'nonatomic' attribute of property %qD conflicts with previous declaration", decl
);
1110 if (original_location
!= UNKNOWN_LOCATION
)
1111 inform (original_location
, "originally specified here");
1115 if (PROPERTY_GETTER_NAME (x
) != parsed_property_getter_ident
)
1117 warning_at (location
, 0,
1118 "'getter' attribute of property %qD conflicts with previous declaration", decl
);
1120 if (original_location
!= UNKNOWN_LOCATION
)
1121 inform (original_location
, "originally specified here");
1125 /* We can only compare the setter names if both the old and new property have a setter. */
1126 if (!property_readonly
&& !PROPERTY_READONLY(x
))
1128 if (PROPERTY_SETTER_NAME (x
) != parsed_property_setter_ident
)
1130 warning_at (location
, 0,
1131 "'setter' attribute of property %qD conflicts with previous declaration", decl
);
1133 if (original_location
!= UNKNOWN_LOCATION
)
1134 inform (original_location
, "originally specified here");
1139 if (PROPERTY_ASSIGN_SEMANTICS (x
) != property_assign_semantics
)
1141 warning_at (location
, 0,
1142 "assign semantics attributes of property %qD conflict with previous declaration", decl
);
1144 if (original_location
!= UNKNOWN_LOCATION
)
1145 inform (original_location
, "originally specified here");
1149 /* It's ok to have a readonly property that becomes a readwrite, but not vice versa. */
1150 if (PROPERTY_READONLY (x
) == 0 && property_readonly
== 1)
1152 warning_at (location
, 0,
1153 "'readonly' attribute of property %qD conflicts with previous declaration", decl
);
1155 if (original_location
!= UNKNOWN_LOCATION
)
1156 inform (original_location
, "originally specified here");
1160 /* We now check that the new and old property declarations have
1161 the same types (or compatible one). In the Objective-C
1162 tradition of loose type checking, we do type-checking but
1163 only generate warnings (not errors) if they do not match.
1164 For non-readonly properties, the types must match exactly;
1165 for readonly properties, it is allowed to use a "more
1166 specialized" type in the new property declaration. Eg, the
1167 superclass has a getter returning (NSArray *) and the
1168 subclass a getter returning (NSMutableArray *). The object's
1169 getter returns an (NSMutableArray *); but if you cast the
1170 object to the superclass, which is allowed, you'd still
1171 expect the getter to return an (NSArray *), which works since
1172 an (NSMutableArray *) is an (NSArray *) too. So, the set of
1173 objects belonging to the type of the new @property should be
1174 a subset of the set of objects belonging to the type of the
1175 old @property. This is what "specialization" means. And the
1176 reason it only applies to readonly properties is that for a
1177 readwrite property the setter would have the opposite
1178 requirement - ie that the superclass type is more specialized
1179 then the subclass one; hence the only way to satisfy both
1180 constraints is that the types match. */
1182 /* If the types are not the same in the C sense, we warn ... */
1183 if (!comptypes (TREE_TYPE (x
), TREE_TYPE (decl
))
1184 /* ... unless the property is readonly, in which case we
1185 allow a new, more specialized, declaration. */
1186 && (!property_readonly
1187 || !objc_compare_types (TREE_TYPE (x
),
1188 TREE_TYPE (decl
), -5, NULL_TREE
)))
1190 warning_at (location
, 0,
1191 "type of property %qD conflicts with previous declaration", decl
);
1192 if (original_location
!= UNKNOWN_LOCATION
)
1193 inform (original_location
, "originally specified here");
1197 /* If we are in a class extension and we're extending a readonly
1198 property in the main @interface, we'll just update the
1199 existing property with the readwrite flag and potentially the
1201 if (property_extension_in_class_extension
)
1203 PROPERTY_READONLY (x
) = 0;
1204 PROPERTY_SETTER_NAME (x
) = parsed_property_setter_ident
;
1209 /* Create a PROPERTY_DECL node. */
1210 property_decl
= make_node (PROPERTY_DECL
);
1212 /* Copy the basic information from the original decl. */
1213 TREE_TYPE (property_decl
) = TREE_TYPE (decl
);
1214 DECL_SOURCE_LOCATION (property_decl
) = DECL_SOURCE_LOCATION (decl
);
1215 TREE_DEPRECATED (property_decl
) = TREE_DEPRECATED (decl
);
1217 /* Add property-specific information. */
1218 PROPERTY_NAME (property_decl
) = DECL_NAME (decl
);
1219 PROPERTY_GETTER_NAME (property_decl
) = parsed_property_getter_ident
;
1220 PROPERTY_SETTER_NAME (property_decl
) = parsed_property_setter_ident
;
1221 PROPERTY_READONLY (property_decl
) = property_readonly
;
1222 PROPERTY_NONATOMIC (property_decl
) = parsed_property_nonatomic
;
1223 PROPERTY_ASSIGN_SEMANTICS (property_decl
) = property_assign_semantics
;
1224 PROPERTY_IVAR_NAME (property_decl
) = NULL_TREE
;
1225 PROPERTY_DYNAMIC (property_decl
) = 0;
1227 /* Remember the fact that the property was found in the @optional
1228 section in a @protocol, or not. */
1229 if (objc_method_optional_flag
)
1230 PROPERTY_OPTIONAL (property_decl
) = 1;
1232 PROPERTY_OPTIONAL (property_decl
) = 0;
1234 /* Note that PROPERTY_GETTER_NAME is always set for all
1235 PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all
1236 PROPERTY_DECLs where PROPERTY_READONLY == 0. Any time we deal
1237 with a getter or setter, we should get the PROPERTY_DECL and use
1238 PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct
1241 /* Add the PROPERTY_DECL to the list of properties for the class. */
1242 TREE_CHAIN (property_decl
) = CLASS_PROPERTY_DECL (objc_interface_context
);
1243 CLASS_PROPERTY_DECL (objc_interface_context
) = property_decl
;
1246 /* This is a subroutine of objc_maybe_build_component_ref. Search the
1247 list of methods in the interface (and, failing that, the local list
1248 in the implementation, and failing that, the protocol list)
1249 provided for a 'setter' or 'getter' for 'component' with default
1250 names (ie, if 'component' is "name", then search for "name" and
1251 "setName:"). It is also possible to specify a different
1252 'getter_name' (this is used for @optional readonly properties). If
1253 any is found, then create an artificial property that uses them.
1254 Return NULL_TREE if 'getter' or 'setter' could not be found. */
1256 maybe_make_artificial_property_decl (tree interface
, tree implementation
,
1257 tree protocol_list
, tree component
, bool is_class
,
1260 tree setter_name
= get_identifier (objc_build_property_setter_name (component
));
1261 tree getter
= NULL_TREE
;
1262 tree setter
= NULL_TREE
;
1264 if (getter_name
== NULL_TREE
)
1265 getter_name
= component
;
1267 /* First, check the @interface and all superclasses. */
1272 /* Using instance methods of the root class as accessors is most
1273 likely unwanted and can be extremely confusing (and, most
1274 importantly, other Objective-C 2.0 compilers do not do it).
1277 flags
= OBJC_LOOKUP_CLASS
| OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS
;
1279 getter
= lookup_method_static (interface
, getter_name
, flags
);
1280 setter
= lookup_method_static (interface
, setter_name
, flags
);
1283 /* Second, check the local @implementation context. */
1284 if (!getter
&& !setter
)
1290 getter
= lookup_method (CLASS_CLS_METHODS (implementation
), getter_name
);
1291 setter
= lookup_method (CLASS_CLS_METHODS (implementation
), setter_name
);
1295 getter
= lookup_method (CLASS_NST_METHODS (implementation
), getter_name
);
1296 setter
= lookup_method (CLASS_NST_METHODS (implementation
), setter_name
);
1301 /* Try the protocol_list if we didn't find anything in the
1302 @interface and in the @implementation. */
1303 if (!getter
&& !setter
)
1305 getter
= lookup_method_in_protocol_list (protocol_list
, getter_name
, is_class
);
1306 setter
= lookup_method_in_protocol_list (protocol_list
, setter_name
, is_class
);
1309 /* There needs to be at least a getter or setter for this to be a
1310 valid 'object.component' syntax. */
1311 if (getter
|| setter
)
1313 /* Yes ... determine the type of the expression. */
1318 type
= TREE_VALUE (TREE_TYPE (getter
));
1320 type
= TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter
)));
1322 /* Create an artificial property declaration with the
1323 information we collected on the type and getter/setter
1325 property_decl
= make_node (PROPERTY_DECL
);
1327 TREE_TYPE (property_decl
) = type
;
1328 DECL_SOURCE_LOCATION (property_decl
) = input_location
;
1329 TREE_DEPRECATED (property_decl
) = 0;
1330 DECL_ARTIFICIAL (property_decl
) = 1;
1332 /* Add property-specific information. Note that one of
1333 PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a
1334 non-existing method; this will generate an error when the
1335 expression is later compiled. At this stage we don't know if
1336 the getter or setter will be used, so we can't generate an
1338 PROPERTY_NAME (property_decl
) = component
;
1339 PROPERTY_GETTER_NAME (property_decl
) = getter_name
;
1340 PROPERTY_SETTER_NAME (property_decl
) = setter_name
;
1341 PROPERTY_READONLY (property_decl
) = 0;
1342 PROPERTY_NONATOMIC (property_decl
) = 0;
1343 PROPERTY_ASSIGN_SEMANTICS (property_decl
) = 0;
1344 PROPERTY_IVAR_NAME (property_decl
) = NULL_TREE
;
1345 PROPERTY_DYNAMIC (property_decl
) = 0;
1346 PROPERTY_OPTIONAL (property_decl
) = 0;
1349 PROPERTY_HAS_NO_GETTER (property_decl
) = 1;
1351 /* The following is currently unused, but it's nice to have
1352 there. We may use it if we need in the future. */
1354 PROPERTY_HAS_NO_SETTER (property_decl
) = 1;
1356 return property_decl
;
1362 /* This hook routine is invoked by the parser when an expression such
1363 as 'xxx.yyy' is parsed. We get a chance to process these
1364 expressions in a way that is specified to Objective-C (to implement
1365 the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars).
1366 If the expression is not an Objective-C specified expression, we
1367 should return NULL_TREE; else we return the expression.
1369 At the moment this only implements dot-syntax and properties (not
1370 non-fragile ivars yet), ie 'object.property' or 'object.component'
1371 where 'component' is not a declared property, but a valid getter or
1372 setter for it could be found. */
1374 objc_maybe_build_component_ref (tree object
, tree property_ident
)
1379 /* If we are in Objective-C 1.0 mode, dot-syntax and properties are
1381 if (flag_objc1_only
)
1384 /* Try to determine if 'object' is an Objective-C object or not. If
1386 if (object
== NULL_TREE
|| object
== error_mark_node
1387 || (rtype
= TREE_TYPE (object
)) == NULL_TREE
)
1390 if (property_ident
== NULL_TREE
|| property_ident
== error_mark_node
1391 || TREE_CODE (property_ident
) != IDENTIFIER_NODE
)
1394 /* The following analysis of 'object' is similar to the one used for
1395 the 'receiver' of a method invocation. We need to determine what
1396 'object' is and find the appropriate property (either declared,
1397 or artificial) for it (in the same way as we need to find the
1398 appropriate method prototype for a method invocation). There are
1399 some simplifications here though: "object.property" is invalid if
1400 "object" has a type of "id" or "Class"; it must at least have a
1401 protocol attached to it, and "object" is never a class name as
1402 that is done by objc_build_class_component_ref. Finally, we
1403 don't know if this really is a dot-syntax expression, so we want
1404 to make a quick exit if it is not; for this reason, we try to
1405 postpone checks after determining that 'object' looks like an
1406 Objective-C object. */
1408 if (objc_is_id (rtype
))
1410 /* This is the case that the 'object' is of type 'id' or
1413 /* Check if at least it is of type 'id <Protocol>' or 'Class
1414 <Protocol>'; if so, look the property up in the
1416 if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype
)))
1418 tree rprotos
= TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype
));
1422 /* No point looking up declared @properties if we are
1423 dealing with a class. Classes have no declared
1425 if (!IS_CLASS (rtype
))
1426 x
= lookup_property_in_protocol_list (rprotos
, property_ident
);
1430 /* Ok, no property. Maybe it was an
1431 object.component dot-syntax without a declared
1432 property (this is valid for classes too). Look
1433 for getter/setter methods and internally declare
1434 an artifical property based on them if found. */
1435 x
= maybe_make_artificial_property_decl (NULL_TREE
,
1442 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1444 /* This is a special, complicated case. If the
1445 property is optional, and is read-only, then the
1446 property is always used for reading, but an
1447 eventual existing non-property setter can be used
1448 for writing. We create an artificial property
1449 decl copying the getter from the optional
1450 property, and looking up the setter in the
1452 x
= maybe_make_artificial_property_decl (NULL_TREE
,
1457 PROPERTY_GETTER_NAME (x
));
1461 else if (objc_method_context
)
1463 /* Else, if we are inside a method it could be the case of
1464 'super' or 'self'. */
1465 tree interface_type
= NULL_TREE
;
1467 while (TREE_CODE (t
) == COMPOUND_EXPR
1468 || TREE_CODE (t
) == MODIFY_EXPR
1469 || CONVERT_EXPR_P (t
)
1470 || TREE_CODE (t
) == COMPONENT_REF
)
1471 t
= TREE_OPERAND (t
, 0);
1473 if (t
== UOBJC_SUPER_decl
)
1474 interface_type
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
1475 else if (t
== self_decl
)
1476 interface_type
= lookup_interface (CLASS_NAME (implementation_template
));
1480 if (TREE_CODE (objc_method_context
) != CLASS_METHOD_DECL
)
1481 x
= lookup_property (interface_type
, property_ident
);
1485 /* Try the dot-syntax without a declared property.
1486 If this is an access to 'self', it is possible
1487 that they may refer to a setter/getter that is
1488 not declared in the interface, but exists locally
1489 in the implementation. In that case, get the
1490 implementation context and use it. */
1491 tree implementation
= NULL_TREE
;
1494 implementation
= objc_implementation_context
;
1496 x
= maybe_make_artificial_property_decl
1497 (interface_type
, implementation
, NULL_TREE
,
1499 (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
),
1502 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1504 tree implementation
= NULL_TREE
;
1507 implementation
= objc_implementation_context
;
1509 x
= maybe_make_artificial_property_decl (interface_type
,
1514 PROPERTY_GETTER_NAME (x
));
1521 /* This is the case where we have more information on 'rtype'. */
1522 tree basetype
= TYPE_MAIN_VARIANT (rtype
);
1524 /* Skip the pointer - if none, it's not an Objective-C object or
1526 if (basetype
!= NULL_TREE
&& TREE_CODE (basetype
) == POINTER_TYPE
)
1527 basetype
= TREE_TYPE (basetype
);
1531 /* Traverse typedefs. */
1532 while (basetype
!= NULL_TREE
1533 && TREE_CODE (basetype
) == RECORD_TYPE
1534 && OBJC_TYPE_NAME (basetype
)
1535 && TREE_CODE (OBJC_TYPE_NAME (basetype
)) == TYPE_DECL
1536 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype
)))
1537 basetype
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype
));
1539 if (basetype
!= NULL_TREE
&& TYPED_OBJECT (basetype
))
1541 tree interface_type
= TYPE_OBJC_INTERFACE (basetype
);
1542 tree protocol_list
= TYPE_OBJC_PROTOCOL_LIST (basetype
);
1545 && (TREE_CODE (interface_type
) == CLASS_INTERFACE_TYPE
1546 || TREE_CODE (interface_type
) == CATEGORY_INTERFACE_TYPE
1547 || TREE_CODE (interface_type
) == PROTOCOL_INTERFACE_TYPE
))
1549 /* Not sure 'rtype' could ever be a class here! Just
1550 for safety we keep the checks. */
1551 if (!IS_CLASS (rtype
))
1553 x
= lookup_property (interface_type
, property_ident
);
1556 x
= lookup_property_in_protocol_list (protocol_list
,
1562 /* Try the dot-syntax without a declared property.
1563 If we are inside a method implementation, it is
1564 possible that they may refer to a setter/getter
1565 that is not declared in the interface, but exists
1566 locally in the implementation. In that case, get
1567 the implementation context and use it. */
1568 tree implementation
= NULL_TREE
;
1570 if (objc_implementation_context
1571 && CLASS_NAME (objc_implementation_context
)
1572 == OBJC_TYPE_NAME (interface_type
))
1573 implementation
= objc_implementation_context
;
1575 x
= maybe_make_artificial_property_decl (interface_type
,
1582 else if (PROPERTY_OPTIONAL (x
) && PROPERTY_READONLY (x
))
1584 tree implementation
= NULL_TREE
;
1586 if (objc_implementation_context
1587 && CLASS_NAME (objc_implementation_context
)
1588 == OBJC_TYPE_NAME (interface_type
))
1589 implementation
= objc_implementation_context
;
1591 x
= maybe_make_artificial_property_decl (interface_type
,
1596 PROPERTY_GETTER_NAME (x
));
1606 tree deprecated_method_prototype
= NULL_TREE
;
1608 /* We have an additional nasty problem here; if this
1609 PROPERTY_REF needs to become a 'getter', then the conversion
1610 from PROPERTY_REF into a getter call happens in gimplify,
1611 after the selector table has already been generated and when
1612 it is too late to add another selector to it. To work around
1613 the problem, we always create the getter call at this stage,
1614 which puts the selector in the table. Note that if the
1615 PROPERTY_REF becomes a 'setter' instead of a 'getter', then
1616 we have added a selector too many to the selector table.
1617 This is a little inefficient.
1619 Also note that method calls to 'self' and 'super' require the
1620 context (self_decl, UOBJS_SUPER_decl,
1621 objc_implementation_context etc) to be built correctly; this
1622 is yet another reason why building the call at the gimplify
1623 stage (when this context has been lost) is not very
1624 practical. If we build it at this stage, we know it will
1625 always be built correctly.
1627 If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial
1628 property decl created to deal with a dotsyntax not really
1629 referring to an existing property) then do not try to build a
1630 call to the getter as there is no getter. */
1631 if (PROPERTY_HAS_NO_GETTER (x
))
1632 getter_call
= NULL_TREE
;
1634 getter_call
= objc_finish_message_expr
1635 (object
, PROPERTY_GETTER_NAME (x
), NULL_TREE
,
1636 /* Disable the immediate deprecation warning if the getter
1637 is deprecated, but record the fact that the getter is
1638 deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to
1639 the method prototype. */
1640 &deprecated_method_prototype
);
1642 expression
= build4 (PROPERTY_REF
, TREE_TYPE(x
), object
, x
, getter_call
,
1643 deprecated_method_prototype
);
1644 SET_EXPR_LOCATION (expression
, input_location
);
1645 TREE_SIDE_EFFECTS (expression
) = 1;
1653 /* This hook routine is invoked by the parser when an expression such
1654 as 'xxx.yyy' is parsed, and 'xxx' is a class name. This is the
1655 Objective-C 2.0 dot-syntax applied to classes, so we need to
1656 convert it into a setter/getter call on the class. */
1658 objc_build_class_component_ref (tree class_name
, tree property_ident
)
1663 if (flag_objc1_only
)
1664 error_at (input_location
, "the dot syntax is not available in Objective-C 1.0");
1666 if (class_name
== NULL_TREE
|| class_name
== error_mark_node
1667 || TREE_CODE (class_name
) != IDENTIFIER_NODE
)
1668 return error_mark_node
;
1670 if (property_ident
== NULL_TREE
|| property_ident
== error_mark_node
1671 || TREE_CODE (property_ident
) != IDENTIFIER_NODE
)
1674 object
= objc_get_class_reference (class_name
);
1677 /* We know that 'class_name' is an Objective-C class name as the
1678 parser won't call this function if it is not. This is only a
1679 double-check for safety. */
1680 error_at (input_location
, "could not find class %qE", class_name
);
1681 return error_mark_node
;
1684 rtype
= lookup_interface (class_name
);
1687 /* Again, this should never happen, but we do check. */
1688 error_at (input_location
, "could not find interface for class %qE", class_name
);
1689 return error_mark_node
;
1693 if (TREE_DEPRECATED (rtype
))
1694 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated", class_name
);
1697 x
= maybe_make_artificial_property_decl (rtype
, NULL_TREE
, NULL_TREE
,
1705 tree deprecated_method_prototype
= NULL_TREE
;
1707 if (PROPERTY_HAS_NO_GETTER (x
))
1708 getter_call
= NULL_TREE
;
1710 getter_call
= objc_finish_message_expr
1711 (object
, PROPERTY_GETTER_NAME (x
), NULL_TREE
,
1712 &deprecated_method_prototype
);
1714 expression
= build4 (PROPERTY_REF
, TREE_TYPE(x
), object
, x
, getter_call
,
1715 deprecated_method_prototype
);
1716 SET_EXPR_LOCATION (expression
, input_location
);
1717 TREE_SIDE_EFFECTS (expression
) = 1;
1723 error_at (input_location
, "could not find setter/getter for %qE in class %qE",
1724 property_ident
, class_name
);
1725 return error_mark_node
;
1733 /* This is used because we don't want to expose PROPERTY_REF to the
1734 C/C++ frontends. Maybe we should! */
1736 objc_is_property_ref (tree node
)
1738 if (node
&& TREE_CODE (node
) == PROPERTY_REF
)
1744 /* This function builds a setter call for a PROPERTY_REF (real, for a
1745 declared property, or artificial, for a dot-syntax accessor which
1746 is not corresponding to a property). 'lhs' must be a PROPERTY_REF
1747 (the caller must check this beforehand). 'rhs' is the value to
1748 assign to the property. A plain setter call is returned, or
1749 error_mark_node if the property is readonly. */
1752 objc_build_setter_call (tree lhs
, tree rhs
)
1754 tree object_expr
= PROPERTY_REF_OBJECT (lhs
);
1755 tree property_decl
= PROPERTY_REF_PROPERTY_DECL (lhs
);
1757 if (PROPERTY_READONLY (property_decl
))
1759 error ("readonly property can not be set");
1760 return error_mark_node
;
1764 tree setter_argument
= build_tree_list (NULL_TREE
, rhs
);
1767 /* TODO: Check that the setter return type is 'void'. */
1769 /* TODO: Decay arguments in C. */
1770 setter
= objc_finish_message_expr (object_expr
,
1771 PROPERTY_SETTER_NAME (property_decl
),
1772 setter_argument
, NULL
);
1776 /* Unreachable, but the compiler may not realize. */
1777 return error_mark_node
;
1780 /* This hook routine is called when a MODIFY_EXPR is being built. We
1781 check what is being modified; if it is a PROPERTY_REF, we need to
1782 generate a 'setter' function call for the property. If this is not
1783 a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go
1784 on creating their MODIFY_EXPR.
1786 This is used for example if you write
1790 where 'count' is a property. The left-hand side creates a
1791 PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR
1792 to assign something to it. We intercept that here, and generate a
1793 call to the 'setter' method instead. */
1795 objc_maybe_build_modify_expr (tree lhs
, tree rhs
)
1797 if (lhs
&& TREE_CODE (lhs
) == PROPERTY_REF
)
1799 /* Building a simple call to the setter method would work for cases such as
1803 but wouldn't work for cases such as
1805 count = object2.count = 1;
1807 to get these to work with very little effort, we build a
1808 compound statement which does the setter call (to set the
1809 property to 'rhs'), but which can also be evaluated returning
1810 the 'rhs'. If the 'rhs' has no side effects, we can simply
1811 evaluate it twice, building
1813 ([object setProperty: rhs]; rhs)
1815 If it has side effects, we put it in a temporary variable first,
1816 so we create the following:
1818 (temp = rhs; [object setProperty: temp]; temp)
1820 setter_argument is rhs in the first case, and temp in the second
1823 tree setter_argument
;
1825 /* s1, s2 and s3 are the tree statements that we need in the
1826 compound expression. */
1827 tree s1
, s2
, s3
, compound_expr
;
1829 if (TREE_SIDE_EFFECTS (rhs
))
1833 /* Declare __objc_property_temp in a local bind. */
1834 setter_argument
= objc_create_temporary_var (TREE_TYPE (rhs
), "__objc_property_temp");
1835 DECL_SOURCE_LOCATION (setter_argument
) = input_location
;
1836 bind
= build3 (BIND_EXPR
, void_type_node
, setter_argument
, NULL
, NULL
);
1837 SET_EXPR_LOCATION (bind
, input_location
);
1838 TREE_SIDE_EFFECTS (bind
) = 1;
1842 s1
= build_modify_expr (input_location
, setter_argument
, NULL_TREE
,
1844 input_location
, rhs
, NULL_TREE
);
1845 SET_EXPR_LOCATION (s1
, input_location
);
1850 setter_argument
= rhs
;
1854 /* Now build the compound statement. */
1856 /* s2: [object setProperty: x] */
1857 s2
= objc_build_setter_call (lhs
, setter_argument
);
1859 /* This happens if building the setter failed because the
1860 property is readonly. */
1861 if (s2
== error_mark_node
)
1862 return error_mark_node
;
1864 SET_EXPR_LOCATION (s2
, input_location
);
1867 s3
= convert (TREE_TYPE (lhs
), setter_argument
);
1869 /* Now build the compound statement (s1, s2, s3) or (s2, s3) as
1872 compound_expr
= build_compound_expr (input_location
, build_compound_expr (input_location
, s1
, s2
), s3
);
1874 compound_expr
= build_compound_expr (input_location
, s2
, s3
);
1876 /* Without this, with -Wall you get a 'valued computed is not
1877 used' every time there is a "object.property = x" where the
1878 value of the resulting MODIFY_EXPR is not used. That is
1879 correct (maybe a more sophisticated implementation could
1880 avoid generating the compound expression if not needed), but
1881 we need to turn it off. */
1882 TREE_NO_WARNING (compound_expr
) = 1;
1883 return compound_expr
;
1889 /* This hook is called by the frontend when one of the four unary
1890 expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR,
1891 PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an
1892 argument which is a PROPERTY_REF. For example, this happens if you have
1896 where 'count' is a property. We need to use the 'getter' and
1897 'setter' for the property in an appropriate way to build the
1898 appropriate expression. 'code' is the code for the expression (one
1899 of the four mentioned above); 'argument' is the PROPERTY_REF, and
1900 'increment' is how much we need to add or subtract. */
1902 objc_build_incr_expr_for_property_ref (location_t location
,
1903 enum tree_code code
,
1904 tree argument
, tree increment
)
1906 /* Here are the expressions that we want to build:
1908 For PREINCREMENT_EXPR / PREDECREMENT_EXPR:
1909 (temp = [object property] +/- increment, [object setProperty: temp], temp)
1911 For POSTINCREMENT_EXPR / POSTECREMENT_EXPR:
1912 (temp = [object property], [object setProperty: temp +/- increment], temp) */
1914 tree temp_variable_decl
, bind
;
1915 /* s1, s2 and s3 are the tree statements that we need in the
1916 compound expression. */
1917 tree s1
, s2
, s3
, compound_expr
;
1920 if (!argument
|| TREE_CODE (argument
) != PROPERTY_REF
)
1921 return error_mark_node
;
1923 /* Declare __objc_property_temp in a local bind. */
1924 temp_variable_decl
= objc_create_temporary_var (TREE_TYPE (argument
), "__objc_property_temp");
1925 DECL_SOURCE_LOCATION (temp_variable_decl
) = location
;
1926 bind
= build3 (BIND_EXPR
, void_type_node
, temp_variable_decl
, NULL
, NULL
);
1927 SET_EXPR_LOCATION (bind
, location
);
1928 TREE_SIDE_EFFECTS (bind
) = 1;
1931 /* Now build the compound statement. */
1933 /* Note that the 'getter' is generated at gimplify time; at this
1934 time, we can simply put the property_ref (ie, argument) wherever
1935 we want the getter ultimately to be. */
1937 /* s1: __objc_property_temp = [object property] <+/- increment> */
1940 case PREINCREMENT_EXPR
:
1941 /* __objc_property_temp = [object property] + increment */
1942 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1944 location
, build2 (PLUS_EXPR
, TREE_TYPE (argument
),
1945 argument
, increment
), NULL_TREE
);
1947 case PREDECREMENT_EXPR
:
1948 /* __objc_property_temp = [object property] - increment */
1949 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1951 location
, build2 (MINUS_EXPR
, TREE_TYPE (argument
),
1952 argument
, increment
), NULL_TREE
);
1954 case POSTINCREMENT_EXPR
:
1955 case POSTDECREMENT_EXPR
:
1956 /* __objc_property_temp = [object property] */
1957 s1
= build_modify_expr (location
, temp_variable_decl
, NULL_TREE
,
1959 location
, argument
, NULL_TREE
);
1965 /* s2: [object setProperty: __objc_property_temp <+/- increment>] */
1968 case PREINCREMENT_EXPR
:
1969 case PREDECREMENT_EXPR
:
1970 /* [object setProperty: __objc_property_temp] */
1971 s2
= objc_build_setter_call (argument
, temp_variable_decl
);
1973 case POSTINCREMENT_EXPR
:
1974 /* [object setProperty: __objc_property_temp + increment] */
1975 s2
= objc_build_setter_call (argument
,
1976 build2 (PLUS_EXPR
, TREE_TYPE (argument
),
1977 temp_variable_decl
, increment
));
1979 case POSTDECREMENT_EXPR
:
1980 /* [object setProperty: __objc_property_temp - increment] */
1981 s2
= objc_build_setter_call (argument
,
1982 build2 (MINUS_EXPR
, TREE_TYPE (argument
),
1983 temp_variable_decl
, increment
));
1989 /* This happens if building the setter failed because the property
1991 if (s2
== error_mark_node
)
1992 return error_mark_node
;
1994 SET_EXPR_LOCATION (s2
, location
);
1996 /* s3: __objc_property_temp */
1997 s3
= convert (TREE_TYPE (argument
), temp_variable_decl
);
1999 /* Now build the compound statement (s1, s2, s3) */
2000 compound_expr
= build_compound_expr (location
, build_compound_expr (location
, s1
, s2
), s3
);
2002 /* Prevent C++ from warning with -Wall that "right operand of comma
2003 operator has no effect". */
2004 TREE_NO_WARNING (compound_expr
) = 1;
2005 return compound_expr
;
2009 objc_build_method_signature (bool is_class_method
, tree rettype
, tree selector
,
2010 tree optparms
, bool ellipsis
)
2012 if (is_class_method
)
2013 return build_method_decl (CLASS_METHOD_DECL
, rettype
, selector
,
2014 optparms
, ellipsis
);
2016 return build_method_decl (INSTANCE_METHOD_DECL
, rettype
, selector
,
2017 optparms
, ellipsis
);
2021 objc_add_method_declaration (bool is_class_method
, tree decl
, tree attributes
)
2023 if (!objc_interface_context
)
2025 /* PS: At the moment, due to how the parser works, it should be
2026 impossible to get here. But it's good to have the check in
2027 case the parser changes.
2029 fatal_error ("method declaration not in @interface context");
2032 if (flag_objc1_only
&& attributes
)
2033 error_at (input_location
, "method attributes are not available in Objective-C 1.0");
2035 objc_decl_method_attributes (&decl
, attributes
, 0);
2036 objc_add_method (objc_interface_context
,
2039 objc_method_optional_flag
);
2042 /* Return 'true' if the method definition could be started, and
2043 'false' if not (because we are outside an @implementation context).
2046 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
);
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
,heap
) *objc_info
= NULL
;
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 VEC_safe_push (tree
, heap
, objc_info
, 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
) = VEC_index (tree
, objc_info
, i
);
2187 /* Replace the IDENTIFIER_NODE with an actual @interface now
2189 TYPE_OBJC_INTERFACE (t
) = klass
;
2191 VEC_free (tree
, heap
, objc_info
);
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 local_variables_to_volatilize
= VEC_alloc (tree
, gc
, 8);
2217 VEC_safe_push (tree
, gc
, 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 (tree
, 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 (tree
, gc
, 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 /* Return types must be covariant. */
2421 if (!comptypes (TREE_TYPE (ltyp
), TREE_TYPE (rtyp
))
2422 && !objc_compare_types (TREE_TYPE (ltyp
), TREE_TYPE (rtyp
),
2426 /* Argument types must be contravariant. */
2427 for (ltyp
= TYPE_ARG_TYPES (ltyp
), rtyp
= TYPE_ARG_TYPES (rtyp
);
2428 ltyp
&& rtyp
; ltyp
= TREE_CHAIN (ltyp
), rtyp
= TREE_CHAIN (rtyp
))
2430 if (!comptypes (TREE_VALUE (rtyp
), TREE_VALUE (ltyp
))
2431 && !objc_compare_types (TREE_VALUE (rtyp
), TREE_VALUE (ltyp
),
2436 return (ltyp
== rtyp
);
2439 /* Past this point, we are only interested in ObjC class instances,
2440 or 'id' or 'Class'. */
2441 if (TREE_CODE (ltyp
) != RECORD_TYPE
|| TREE_CODE (rtyp
) != RECORD_TYPE
)
2444 if (!objc_is_object_id (ltyp
) && !objc_is_class_id (ltyp
)
2445 && !TYPE_HAS_OBJC_INFO (ltyp
))
2448 if (!objc_is_object_id (rtyp
) && !objc_is_class_id (rtyp
)
2449 && !TYPE_HAS_OBJC_INFO (rtyp
))
2452 /* Past this point, we are committed to returning 'true' to the caller
2453 (unless performing a silent comparison; see below). However, we can
2454 still warn about type and/or protocol mismatches. */
2456 if (TYPE_HAS_OBJC_INFO (ltyp
))
2458 lcls
= TYPE_OBJC_INTERFACE (ltyp
);
2459 lproto
= TYPE_OBJC_PROTOCOL_LIST (ltyp
);
2462 lcls
= lproto
= NULL_TREE
;
2464 if (TYPE_HAS_OBJC_INFO (rtyp
))
2466 rcls
= TYPE_OBJC_INTERFACE (rtyp
);
2467 rproto
= TYPE_OBJC_PROTOCOL_LIST (rtyp
);
2470 rcls
= rproto
= NULL_TREE
;
2472 /* If we could not find an @interface declaration, we must have
2473 only seen a @class declaration; for purposes of type comparison,
2474 treat it as a stand-alone (root) class. */
2476 if (lcls
&& TREE_CODE (lcls
) == IDENTIFIER_NODE
)
2479 if (rcls
&& TREE_CODE (rcls
) == IDENTIFIER_NODE
)
2482 /* If either type is an unqualified 'id', we're done. This is because
2483 an 'id' can be assigned to or from any type with no warnings. */
2486 if ((!lproto
&& objc_is_object_id (ltyp
))
2487 || (!rproto
&& objc_is_object_id (rtyp
)))
2492 /* For property checks, though, an 'id' is considered the most
2493 general type of object, hence if you try to specialize an
2494 'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need
2496 if (!lproto
&& objc_is_object_id (ltyp
))
2500 pointers_compatible
= (TYPE_MAIN_VARIANT (ltyp
) == TYPE_MAIN_VARIANT (rtyp
));
2502 /* If the underlying types are the same, and at most one of them has
2503 a protocol list, we do not need to issue any diagnostics. */
2504 if (pointers_compatible
&& (!lproto
|| !rproto
))
2507 /* If exactly one of the types is 'Class', issue a diagnostic; any
2508 exceptions of this rule have already been handled. */
2509 if (objc_is_class_id (ltyp
) ^ objc_is_class_id (rtyp
))
2510 pointers_compatible
= false;
2511 /* Otherwise, check for inheritance relations. */
2514 if (!pointers_compatible
)
2516 /* Again, if any of the two is an 'id', we're satisfied,
2517 unless we're comparing properties, in which case only an
2518 'id' on the left-hand side (old property) is good
2522 = (objc_is_object_id (ltyp
) || objc_is_object_id (rtyp
));
2524 pointers_compatible
= objc_is_object_id (ltyp
);
2527 if (!pointers_compatible
)
2528 pointers_compatible
= DERIVED_FROM_P (ltyp
, rtyp
);
2530 if (!pointers_compatible
&& (argno
== -3 || argno
== -4))
2531 pointers_compatible
= DERIVED_FROM_P (rtyp
, ltyp
);
2534 /* If the pointers match modulo protocols, check for protocol conformance
2536 if (pointers_compatible
)
2538 pointers_compatible
= objc_compare_protocols (lcls
, ltyp
, rcls
, rtyp
,
2541 if (!pointers_compatible
&& argno
== -3)
2542 pointers_compatible
= objc_compare_protocols (rcls
, rtyp
, lcls
, ltyp
,
2546 if (!pointers_compatible
)
2548 /* The two pointers are not exactly compatible. Issue a warning, unless
2549 we are performing a silent comparison, in which case return 'false'
2551 /* NB: For the time being, we shall make our warnings look like their
2552 C counterparts. In the future, we may wish to make them more
2561 warning (0, "comparison of distinct Objective-C types lacks a cast");
2565 warning (0, "initialization from distinct Objective-C type");
2569 warning (0, "assignment from distinct Objective-C type");
2573 warning (0, "distinct Objective-C type in return");
2577 warning (0, "passing argument %d of %qE from distinct "
2578 "Objective-C type", argno
, callee
);
2586 /* This routine is similar to objc_compare_types except that function-pointers are
2587 excluded. This is because, caller assumes that common types are of (id, Object*)
2588 variety and calls objc_common_type to obtain a common type. There is no commonolty
2589 between two function-pointers in this regard. */
2592 objc_have_common_type (tree ltyp
, tree rtyp
, int argno
, tree callee
)
2594 if (objc_compare_types (ltyp
, rtyp
, argno
, callee
))
2596 /* exclude function-pointer types. */
2599 ltyp
= TREE_TYPE (ltyp
); /* Remove indirections. */
2600 rtyp
= TREE_TYPE (rtyp
);
2602 while (POINTER_TYPE_P (ltyp
) && POINTER_TYPE_P (rtyp
));
2603 return !(TREE_CODE (ltyp
) == FUNCTION_TYPE
&& TREE_CODE (rtyp
) == FUNCTION_TYPE
);
2609 /* Determine if CHILD is derived from PARENT. The routine assumes that
2610 both parameters are RECORD_TYPEs, and is non-reflexive. */
2613 objc_derived_from_p (tree parent
, tree child
)
2615 parent
= TYPE_MAIN_VARIANT (parent
);
2617 for (child
= TYPE_MAIN_VARIANT (child
);
2618 TYPE_BINFO (child
) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child
));)
2620 child
= TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
2621 (TYPE_BINFO (child
),
2624 if (child
== parent
)
2633 objc_build_component_ref (tree datum
, tree component
)
2635 /* If COMPONENT is NULL, the caller is referring to the anonymous
2636 base class field. */
2639 tree base
= TYPE_FIELDS (TREE_TYPE (datum
));
2641 return build3 (COMPONENT_REF
, TREE_TYPE (base
), datum
, base
, NULL_TREE
);
2644 /* The 'build_component_ref' routine has been removed from the C++
2645 front-end, but 'finish_class_member_access_expr' seems to be
2646 a worthy substitute. */
2648 return finish_class_member_access_expr (datum
, component
, false,
2649 tf_warning_or_error
);
2651 return build_component_ref (input_location
, datum
, component
);
2655 /* Recursively copy inheritance information rooted at BINFO. To do this,
2656 we emulate the song and dance performed by cp/tree.c:copy_binfo(). */
2659 objc_copy_binfo (tree binfo
)
2661 tree btype
= BINFO_TYPE (binfo
);
2662 tree binfo2
= make_tree_binfo (BINFO_N_BASE_BINFOS (binfo
));
2666 BINFO_TYPE (binfo2
) = btype
;
2667 BINFO_OFFSET (binfo2
) = BINFO_OFFSET (binfo
);
2668 BINFO_BASE_ACCESSES (binfo2
) = BINFO_BASE_ACCESSES (binfo
);
2670 /* Recursively copy base binfos of BINFO. */
2671 for (ix
= 0; BINFO_BASE_ITERATE (binfo
, ix
, base_binfo
); ix
++)
2673 tree base_binfo2
= objc_copy_binfo (base_binfo
);
2675 BINFO_INHERITANCE_CHAIN (base_binfo2
) = binfo2
;
2676 BINFO_BASE_APPEND (binfo2
, base_binfo2
);
2682 /* Record superclass information provided in BASETYPE for ObjC class REF.
2683 This is loosely based on cp/decl.c:xref_basetypes(). */
2686 objc_xref_basetypes (tree ref
, tree basetype
)
2688 tree binfo
= make_tree_binfo (basetype
? 1 : 0);
2690 TYPE_BINFO (ref
) = binfo
;
2691 BINFO_OFFSET (binfo
) = size_zero_node
;
2692 BINFO_TYPE (binfo
) = ref
;
2696 tree base_binfo
= objc_copy_binfo (TYPE_BINFO (basetype
));
2698 BINFO_INHERITANCE_CHAIN (base_binfo
) = binfo
;
2699 BINFO_BASE_ACCESSES (binfo
) = VEC_alloc (tree
, gc
, 1);
2700 BINFO_BASE_APPEND (binfo
, base_binfo
);
2701 BINFO_BASE_ACCESS_APPEND (binfo
, access_public_node
);
2705 /* Called from finish_decl. */
2708 objc_check_decl (tree decl
)
2710 tree type
= TREE_TYPE (decl
);
2712 if (TREE_CODE (type
) != RECORD_TYPE
)
2714 if (OBJC_TYPE_NAME (type
) && (type
= objc_is_class_name (OBJC_TYPE_NAME (type
))))
2715 error ("statically allocated instance of Objective-C class %qE",
2720 objc_check_global_decl (tree decl
)
2722 tree id
= DECL_NAME (decl
);
2723 if (objc_is_class_name (id
) && global_bindings_p())
2724 error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id
));
2727 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where
2728 INTERFACE may either name an Objective-C class, or refer to the
2729 special 'id' or 'Class' types. If INTERFACE is not a valid ObjC
2730 type, just return it unchanged. This function is often called when
2731 PROTOCOLS is NULL_TREE, in which case we simply look up the
2732 appropriate INTERFACE. */
2735 objc_get_protocol_qualified_type (tree interface
, tree protocols
)
2737 /* If INTERFACE is not provided, default to 'id'. */
2738 tree type
= (interface
? objc_is_id (interface
) : objc_object_type
);
2739 bool is_ptr
= (type
!= NULL_TREE
);
2743 type
= objc_is_class_name (interface
);
2747 /* If looking at a typedef, retrieve the precise type it
2749 if (TREE_CODE (interface
) == IDENTIFIER_NODE
)
2750 interface
= identifier_global_value (interface
);
2752 type
= ((interface
&& TREE_CODE (interface
) == TYPE_DECL
2753 && DECL_ORIGINAL_TYPE (interface
))
2754 ? DECL_ORIGINAL_TYPE (interface
)
2755 : xref_tag (RECORD_TYPE
, type
));
2759 /* This case happens when we are given an 'interface' which
2760 is not a valid class name. For example if a typedef was
2761 used, and 'interface' really is the identifier of the
2762 typedef, but when you resolve it you don't get an
2763 Objective-C class, but something else, such as 'int'.
2764 This is an error; protocols make no sense unless you use
2765 them with Objective-C objects. */
2766 error_at (input_location
, "only Objective-C object types can be qualified with a protocol");
2768 /* Try to recover. Ignore the invalid class name, and treat
2769 the object as an 'id' to silence further warnings about
2771 type
= objc_object_type
;
2778 type
= build_variant_type_copy (type
);
2780 /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
2784 tree orig_pointee_type
= TREE_TYPE (type
);
2785 TREE_TYPE (type
) = build_variant_type_copy (orig_pointee_type
);
2787 /* Set up the canonical type information. */
2788 TYPE_CANONICAL (type
)
2789 = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type
));
2791 TYPE_POINTER_TO (TREE_TYPE (type
)) = type
;
2792 type
= TREE_TYPE (type
);
2795 /* Look up protocols and install in lang specific list. */
2796 DUP_TYPE_OBJC_INFO (type
, TYPE_MAIN_VARIANT (type
));
2797 TYPE_OBJC_PROTOCOL_LIST (type
) = lookup_and_install_protocols
2798 (protocols
, /* definition_required */ false);
2800 /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
2801 return the pointer to the new pointee variant. */
2803 type
= TYPE_POINTER_TO (type
);
2805 TYPE_OBJC_INTERFACE (type
)
2806 = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type
));
2812 /* Check for circular dependencies in protocols. The arguments are
2813 PROTO, the protocol to check, and LIST, a list of protocol it
2817 check_protocol_recursively (tree proto
, tree list
)
2821 for (p
= list
; p
; p
= TREE_CHAIN (p
))
2823 tree pp
= TREE_VALUE (p
);
2825 if (TREE_CODE (pp
) == IDENTIFIER_NODE
)
2826 pp
= lookup_protocol (pp
, /* warn if deprecated */ false,
2827 /* definition_required */ false);
2830 fatal_error ("protocol %qE has circular dependency",
2831 PROTOCOL_NAME (pp
));
2833 check_protocol_recursively (proto
, PROTOCOL_LIST (pp
));
2837 /* Look up PROTOCOLS, and return a list of those that are found. If
2838 none are found, return NULL. Note that this function will emit a
2839 warning if a protocol is found and is deprecated. If
2840 'definition_required', then warn if the protocol is found but is
2841 not defined (ie, if we only saw a forward-declaration of the
2842 protocol (as in "@protocol NSObject;") not a real definition with
2843 the list of methods). */
2845 lookup_and_install_protocols (tree protocols
, bool definition_required
)
2848 tree return_value
= NULL_TREE
;
2850 if (protocols
== error_mark_node
)
2853 for (proto
= protocols
; proto
; proto
= TREE_CHAIN (proto
))
2855 tree ident
= TREE_VALUE (proto
);
2856 tree p
= lookup_protocol (ident
, /* warn_if_deprecated */ true,
2857 definition_required
);
2860 return_value
= chainon (return_value
,
2861 build_tree_list (NULL_TREE
, p
));
2862 else if (ident
!= error_mark_node
)
2863 error ("cannot find protocol declaration for %qE",
2867 return return_value
;
2871 build_common_objc_exception_stuff (void)
2873 tree noreturn_list
, nothrow_list
, temp_type
;
2875 noreturn_list
= tree_cons (get_identifier ("noreturn"), NULL
, NULL
);
2876 nothrow_list
= tree_cons (get_identifier ("nothrow"), NULL
, NULL
);
2878 /* void objc_exception_throw(id) __attribute__((noreturn)); */
2879 /* void objc_sync_enter(id); */
2880 /* void objc_sync_exit(id); */
2881 temp_type
= build_function_type_list (void_type_node
,
2884 objc_exception_throw_decl
2885 = add_builtin_function (TAG_EXCEPTIONTHROW
, temp_type
, 0, NOT_BUILT_IN
, NULL
,
2887 /* Make sure that objc_exception_throw (id) claims that it may throw an
2889 TREE_NOTHROW (objc_exception_throw_decl
) = 0;
2891 objc_sync_enter_decl
2892 = add_builtin_function (TAG_SYNCENTER
, temp_type
, 0, NOT_BUILT_IN
,
2893 NULL
, nothrow_list
);
2896 = add_builtin_function (TAG_SYNCEXIT
, temp_type
, 0, NOT_BUILT_IN
,
2897 NULL
, nothrow_list
);
2900 /* Purpose: "play" parser, creating/installing representations
2901 of the declarations that are required by Objective-C.
2905 type_spec--------->sc_spec
2906 (tree_list) (tree_list)
2909 identifier_node identifier_node */
2912 synth_module_prologue (void)
2915 enum debug_info_type save_write_symbols
= write_symbols
;
2916 const struct gcc_debug_hooks
*const save_hooks
= debug_hooks
;
2918 /* Suppress outputting debug symbols, because
2919 dbxout_init hasn't been called yet. */
2920 write_symbols
= NO_DEBUG
;
2921 debug_hooks
= &do_nothing_debug_hooks
;
2924 push_lang_context (lang_name_c
); /* extern "C" */
2927 /* The following are also defined in <objc/objc.h> and friends. */
2929 objc_object_id
= get_identifier (TAG_OBJECT
);
2930 objc_class_id
= get_identifier (TAG_CLASS
);
2932 objc_object_reference
= xref_tag (RECORD_TYPE
, objc_object_id
);
2933 objc_class_reference
= xref_tag (RECORD_TYPE
, objc_class_id
);
2935 objc_object_type
= build_pointer_type (objc_object_reference
);
2936 objc_class_type
= build_pointer_type (objc_class_reference
);
2938 objc_object_name
= get_identifier (OBJECT_TYPEDEF_NAME
);
2939 objc_class_name
= get_identifier (CLASS_TYPEDEF_NAME
);
2941 /* Declare the 'id' and 'Class' typedefs. */
2942 type
= lang_hooks
.decls
.pushdecl (build_decl (input_location
,
2946 TREE_NO_WARNING (type
) = 1;
2948 type
= lang_hooks
.decls
.pushdecl (build_decl (input_location
,
2952 TREE_NO_WARNING (type
) = 1;
2954 /* Forward-declare '@interface Protocol'. */
2955 type
= get_identifier (PROTOCOL_OBJECT_CLASS_NAME
);
2956 objc_declare_class (type
);
2957 objc_protocol_type
= build_pointer_type (xref_tag (RECORD_TYPE
, type
));
2959 /* Declare receiver type used for dispatching messages to 'super'. */
2960 /* `struct objc_super *' */
2961 objc_super_type
= build_pointer_type (xref_tag (RECORD_TYPE
,
2962 get_identifier (TAG_SUPER
)));
2964 /* Declare pointers to method and ivar lists. */
2965 objc_method_list_ptr
= build_pointer_type
2966 (xref_tag (RECORD_TYPE
,
2967 get_identifier (UTAG_METHOD_LIST
)));
2968 objc_method_proto_list_ptr
2969 = build_pointer_type (xref_tag (RECORD_TYPE
,
2970 get_identifier (UTAG_METHOD_PROTOTYPE_LIST
)));
2971 objc_ivar_list_ptr
= build_pointer_type
2972 (xref_tag (RECORD_TYPE
,
2973 get_identifier (UTAG_IVAR_LIST
)));
2975 build_common_objc_exception_stuff ();
2977 /* Set-up runtime-specific templates, message and exception stuff. */
2978 (*runtime
.initialize
) ();
2980 /* Declare objc_getProperty, object_setProperty and other property
2981 accessor helpers. */
2982 build_common_objc_property_accessor_helpers ();
2984 /* Forward declare constant_string_id and constant_string_type. */
2985 if (!constant_string_class_name
)
2986 constant_string_class_name
= runtime
.default_constant_string_class_name
;
2987 constant_string_id
= get_identifier (constant_string_class_name
);
2988 objc_declare_class (constant_string_id
);
2990 /* Pre-build the following entities - for speed/convenience. */
2991 self_id
= get_identifier ("self");
2992 ucmd_id
= get_identifier ("_cmd");
2994 /* Declare struct _objc_fast_enumeration_state { ... }; */
2995 build_fast_enumeration_state_template ();
2997 /* void objc_enumeration_mutation (id) */
2998 type
= build_function_type_list (void_type_node
,
2999 objc_object_type
, NULL_TREE
);
3000 objc_enumeration_mutation_decl
3001 = add_builtin_function (TAG_ENUMERATION_MUTATION
, type
, 0, NOT_BUILT_IN
,
3003 TREE_NOTHROW (objc_enumeration_mutation_decl
) = 0;
3006 pop_lang_context ();
3009 write_symbols
= save_write_symbols
;
3010 debug_hooks
= save_hooks
;
3013 /* --- const strings --- */
3015 /* Ensure that the ivar list for NSConstantString/NXConstantString
3016 (or whatever was specified via `-fconstant-string-class')
3017 contains fields at least as large as the following three, so that
3018 the runtime can stomp on them with confidence:
3020 struct STRING_OBJECT_CLASS_NAME
3024 unsigned int length;
3028 check_string_class_template (void)
3030 tree field_decl
= objc_get_class_ivars (constant_string_id
);
3032 #define AT_LEAST_AS_LARGE_AS(F, T) \
3033 (F && TREE_CODE (F) == FIELD_DECL \
3034 && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
3035 >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
3037 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
3040 field_decl
= DECL_CHAIN (field_decl
);
3041 if (!AT_LEAST_AS_LARGE_AS (field_decl
, ptr_type_node
))
3044 field_decl
= DECL_CHAIN (field_decl
);
3045 return AT_LEAST_AS_LARGE_AS (field_decl
, unsigned_type_node
);
3047 #undef AT_LEAST_AS_LARGE_AS
3050 /* Avoid calling `check_string_class_template ()' more than once. */
3051 static GTY(()) int string_layout_checked
;
3053 /* Construct an internal string layout to be used as a template for
3054 creating NSConstantString/NXConstantString instances. */
3057 objc_build_internal_const_str_type (void)
3059 tree type
= (*lang_hooks
.types
.make_type
) (RECORD_TYPE
);
3060 tree fields
= build_decl (input_location
,
3061 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
3062 tree field
= build_decl (input_location
,
3063 FIELD_DECL
, NULL_TREE
, ptr_type_node
);
3065 DECL_CHAIN (field
) = fields
; fields
= field
;
3066 field
= build_decl (input_location
,
3067 FIELD_DECL
, NULL_TREE
, unsigned_type_node
);
3068 DECL_CHAIN (field
) = fields
; fields
= field
;
3069 /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
3071 finish_builtin_struct (type
, "__builtin_ObjCString",
3077 /* Custom build_string which sets TREE_TYPE! */
3080 my_build_string (int len
, const char *str
)
3082 return fix_string_type (build_string (len
, str
));
3085 /* Build a string with contents STR and length LEN and convert it to a
3089 my_build_string_pointer (int len
, const char *str
)
3091 tree string
= my_build_string (len
, str
);
3092 tree ptrtype
= build_pointer_type (TREE_TYPE (TREE_TYPE (string
)));
3093 return build1 (ADDR_EXPR
, ptrtype
, string
);
3097 string_hash (const void *ptr
)
3099 const_tree
const str
= ((const struct string_descriptor
*)ptr
)->literal
;
3100 const unsigned char *p
= (const unsigned char *) TREE_STRING_POINTER (str
);
3101 int i
, len
= TREE_STRING_LENGTH (str
);
3104 for (i
= 0; i
< len
; i
++)
3105 h
= ((h
* 613) + p
[i
]);
3111 string_eq (const void *ptr1
, const void *ptr2
)
3113 const_tree
const str1
= ((const struct string_descriptor
*)ptr1
)->literal
;
3114 const_tree
const str2
= ((const struct string_descriptor
*)ptr2
)->literal
;
3115 int len1
= TREE_STRING_LENGTH (str1
);
3117 return (len1
== TREE_STRING_LENGTH (str2
)
3118 && !memcmp (TREE_STRING_POINTER (str1
), TREE_STRING_POINTER (str2
),
3122 /* Given a chain of STRING_CST's, build a static instance of
3123 NXConstantString which points at the concatenation of those
3124 strings. We place the string object in the __string_objects
3125 section of the __OBJC segment. The Objective-C runtime will
3126 initialize the isa pointers of the string objects to point at the
3127 NXConstantString class object. */
3130 objc_build_string_object (tree string
)
3132 tree constant_string_class
;
3135 struct string_descriptor
*desc
, key
;
3138 /* Prep the string argument. */
3139 string
= fix_string_type (string
);
3140 TREE_SET_CODE (string
, STRING_CST
);
3141 length
= TREE_STRING_LENGTH (string
) - 1;
3143 /* The target may have different ideas on how to construct an ObjC string
3144 literal. On Darwin (Mac OS X), for example, we may wish to obtain a
3145 constant CFString reference instead.
3146 At present, this is only supported for the NeXT runtime. */
3147 if (flag_next_runtime
3148 && targetcm
.objc_construct_string_object
)
3150 tree constructor
= (*targetcm
.objc_construct_string_object
) (string
);
3152 return build1 (NOP_EXPR
, objc_object_type
, constructor
);
3155 /* Check whether the string class being used actually exists and has the
3156 correct ivar layout. */
3157 if (!string_layout_checked
)
3159 string_layout_checked
= -1;
3160 constant_string_class
= lookup_interface (constant_string_id
);
3161 internal_const_str_type
= objc_build_internal_const_str_type ();
3163 if (!constant_string_class
3164 || !(constant_string_type
3165 = CLASS_STATIC_TEMPLATE (constant_string_class
)))
3166 error ("cannot find interface declaration for %qE",
3167 constant_string_id
);
3168 /* The NSConstantString/NXConstantString ivar layout is now known. */
3169 else if (!check_string_class_template ())
3170 error ("interface %qE does not have valid constant string layout",
3171 constant_string_id
);
3172 /* If the runtime can generate a literal reference to the string class,
3173 don't need to run a constructor. */
3174 else if (!(*runtime
.setup_const_string_class_decl
)())
3175 error ("cannot find reference tag for class %qE", constant_string_id
);
3178 string_layout_checked
= 1; /* Success! */
3179 add_class_reference (constant_string_id
);
3183 if (string_layout_checked
== -1)
3184 return error_mark_node
;
3186 /* Perhaps we already constructed a constant string just like this one? */
3187 key
.literal
= string
;
3188 loc
= htab_find_slot (string_htab
, &key
, INSERT
);
3189 desc
= (struct string_descriptor
*) *loc
;
3193 *loc
= desc
= ggc_alloc_string_descriptor ();
3194 desc
->literal
= string
;
3196 (*runtime
.build_const_string_constructor
) (input_location
, string
, length
);
3199 addr
= convert (build_pointer_type (constant_string_type
),
3200 build_unary_op (input_location
,
3201 ADDR_EXPR
, desc
->constructor
, 1));
3206 /* Build a static constant CONSTRUCTOR
3207 with type TYPE and elements ELTS. */
3210 objc_build_constructor (tree type
, VEC(constructor_elt
,gc
) *elts
)
3212 tree constructor
= build_constructor (type
, elts
);
3214 TREE_CONSTANT (constructor
) = 1;
3215 TREE_STATIC (constructor
) = 1;
3216 TREE_READONLY (constructor
) = 1;
3219 /* Adjust for impedance mismatch. We should figure out how to build
3220 CONSTRUCTORs that consistently please both the C and C++ gods. */
3221 if (!VEC_index (constructor_elt
, elts
, 0)->index
)
3222 TREE_TYPE (constructor
) = init_list_type_node
;
3228 /* Return the DECL of the string IDENT in the SECTION. */
3231 get_objc_string_decl (tree ident
, enum string_section section
)
3238 chain
= class_names_chain
;
3240 case meth_var_names
:
3241 chain
= meth_var_names_chain
;
3243 case meth_var_types
:
3244 chain
= meth_var_types_chain
;
3246 case prop_names_attr
:
3247 chain
= prop_names_attr_chain
;
3253 for (; chain
!= 0; chain
= TREE_CHAIN (chain
))
3254 if (TREE_VALUE (chain
) == ident
)
3255 return (TREE_PURPOSE (chain
));
3257 /* We didn't find the entry. */
3261 /* Create a class reference, but don't create a variable to reference
3265 add_class_reference (tree ident
)
3269 if ((chain
= cls_ref_chain
))
3274 if (ident
== TREE_VALUE (chain
))
3278 chain
= TREE_CHAIN (chain
);
3282 /* Append to the end of the list */
3283 TREE_CHAIN (tail
) = tree_cons (NULL_TREE
, ident
, NULL_TREE
);
3286 cls_ref_chain
= tree_cons (NULL_TREE
, ident
, NULL_TREE
);
3289 /* Get a class reference, creating it if necessary. Also create the
3290 reference variable. */
3292 objc_get_class_reference (tree ident
)
3294 tree orig_ident
= (DECL_P (ident
)
3297 ? OBJC_TYPE_NAME (ident
)
3299 bool local_scope
= false;
3302 if (processing_template_decl
)
3303 /* Must wait until template instantiation time. */
3304 return build_min_nt (CLASS_REFERENCE_EXPR
, ident
);
3307 if (TREE_CODE (ident
) == TYPE_DECL
)
3308 ident
= (DECL_ORIGINAL_TYPE (ident
)
3309 ? DECL_ORIGINAL_TYPE (ident
)
3310 : TREE_TYPE (ident
));
3314 && CP_TYPE_CONTEXT (ident
) != global_namespace
)
3318 if (local_scope
|| !(ident
= objc_is_class_name (ident
)))
3320 error ("%qE is not an Objective-C class name or alias",
3322 return error_mark_node
;
3325 return (*runtime
.get_class_reference
) (ident
);
3329 objc_declare_alias (tree alias_ident
, tree class_ident
)
3331 tree underlying_class
;
3334 if (current_namespace
!= global_namespace
) {
3335 error ("Objective-C declarations may only appear in global scope");
3337 #endif /* OBJCPLUS */
3339 if (!(underlying_class
= objc_is_class_name (class_ident
)))
3340 warning (0, "cannot find class %qE", class_ident
);
3341 else if (objc_is_class_name (alias_ident
))
3342 warning (0, "class %qE already exists", alias_ident
);
3345 /* Implement @compatibility_alias as a typedef. */
3347 push_lang_context (lang_name_c
); /* extern "C" */
3349 lang_hooks
.decls
.pushdecl (build_decl
3353 xref_tag (RECORD_TYPE
, underlying_class
)));
3355 pop_lang_context ();
3357 hash_class_name_enter (als_name_hash_list
, alias_ident
,
3363 objc_declare_class (tree identifier
)
3366 if (current_namespace
!= global_namespace
) {
3367 error ("Objective-C declarations may only appear in global scope");
3369 #endif /* OBJCPLUS */
3371 if (! objc_is_class_name (identifier
))
3373 tree record
= lookup_name (identifier
), type
= record
;
3377 if (TREE_CODE (record
) == TYPE_DECL
)
3378 type
= DECL_ORIGINAL_TYPE (record
)
3379 ? DECL_ORIGINAL_TYPE (record
)
3380 : TREE_TYPE (record
);
3382 if (!TYPE_HAS_OBJC_INFO (type
)
3383 || !TYPE_OBJC_INTERFACE (type
))
3385 error ("%qE redeclared as different kind of symbol",
3387 error ("previous declaration of %q+D",
3392 record
= xref_tag (RECORD_TYPE
, identifier
);
3393 INIT_TYPE_OBJC_INFO (record
);
3394 /* In the case of a @class declaration, we store the ident in
3395 the TYPE_OBJC_INTERFACE. If later an @interface is found,
3396 we'll replace the ident with the interface. */
3397 TYPE_OBJC_INTERFACE (record
) = identifier
;
3398 hash_class_name_enter (cls_name_hash_list
, identifier
, NULL_TREE
);
3403 objc_is_class_name (tree ident
)
3407 if (ident
&& TREE_CODE (ident
) == IDENTIFIER_NODE
)
3409 tree t
= identifier_global_value (ident
);
3414 while (ident
&& TREE_CODE (ident
) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (ident
))
3415 ident
= OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident
));
3417 if (ident
&& TREE_CODE (ident
) == RECORD_TYPE
)
3418 ident
= OBJC_TYPE_NAME (ident
);
3420 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
3422 tree type
= TREE_TYPE (ident
);
3423 if (type
&& TREE_CODE (type
) == TEMPLATE_TYPE_PARM
)
3425 ident
= DECL_NAME (ident
);
3428 if (!ident
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
3431 if (lookup_interface (ident
))
3434 target
= hash_class_name_lookup (cls_name_hash_list
, ident
);
3438 target
= hash_class_name_lookup (als_name_hash_list
, ident
);
3441 gcc_assert (target
->list
&& target
->list
->value
);
3442 return target
->list
->value
;
3448 /* Check whether TYPE is either 'id' or 'Class'. */
3451 objc_is_id (tree type
)
3453 if (type
&& TREE_CODE (type
) == IDENTIFIER_NODE
)
3455 tree t
= identifier_global_value (type
);
3460 if (type
&& TREE_CODE (type
) == TYPE_DECL
)
3461 type
= TREE_TYPE (type
);
3463 /* NB: This function may be called before the ObjC front-end has
3464 been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
3465 return (objc_object_type
&& type
3466 && (IS_ID (type
) || IS_CLASS (type
) || IS_SUPER (type
))
3471 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3472 class instance. This is needed by other parts of the compiler to
3473 handle ObjC types gracefully. */
3476 objc_is_object_ptr (tree type
)
3480 type
= TYPE_MAIN_VARIANT (type
);
3481 if (!POINTER_TYPE_P (type
))
3484 ret
= objc_is_id (type
);
3486 ret
= objc_is_class_name (TREE_TYPE (type
));
3492 objc_is_gcable_type (tree type
, int or_strong_p
)
3498 if (objc_is_id (TYPE_MAIN_VARIANT (type
)))
3500 if (or_strong_p
&& lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type
)))
3502 if (TREE_CODE (type
) != POINTER_TYPE
&& TREE_CODE (type
) != INDIRECT_REF
)
3504 type
= TREE_TYPE (type
);
3505 if (TREE_CODE (type
) != RECORD_TYPE
)
3507 name
= TYPE_NAME (type
);
3508 return (objc_is_class_name (name
) != NULL_TREE
);
3512 objc_substitute_decl (tree expr
, tree oldexpr
, tree newexpr
)
3514 if (expr
== oldexpr
)
3517 switch (TREE_CODE (expr
))
3520 return objc_build_component_ref
3521 (objc_substitute_decl (TREE_OPERAND (expr
, 0),
3524 DECL_NAME (TREE_OPERAND (expr
, 1)));
3526 return build_array_ref (input_location
,
3527 objc_substitute_decl (TREE_OPERAND (expr
, 0),
3530 TREE_OPERAND (expr
, 1));
3532 return build_indirect_ref (input_location
,
3533 objc_substitute_decl (TREE_OPERAND (expr
, 0),
3535 newexpr
), RO_ARROW
);
3542 objc_build_ivar_assignment (tree outervar
, tree lhs
, tree rhs
)
3545 /* The LHS parameter contains the expression 'outervar->memberspec';
3546 we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3547 where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3550 = objc_substitute_decl
3551 (lhs
, outervar
, convert (TREE_TYPE (outervar
), integer_zero_node
));
3553 = (flag_objc_direct_dispatch
3554 ? objc_assign_ivar_fast_decl
3555 : objc_assign_ivar_decl
);
3557 offs
= convert (integer_type_node
, build_unary_op (input_location
,
3558 ADDR_EXPR
, offs
, 0));
3560 func_params
= tree_cons (NULL_TREE
,
3561 convert (objc_object_type
, rhs
),
3562 tree_cons (NULL_TREE
, convert (objc_object_type
, outervar
),
3563 tree_cons (NULL_TREE
, offs
,
3566 assemble_external (func
);
3567 return build_function_call (input_location
, func
, func_params
);
3571 objc_build_global_assignment (tree lhs
, tree rhs
)
3573 tree func_params
= tree_cons (NULL_TREE
,
3574 convert (objc_object_type
, rhs
),
3575 tree_cons (NULL_TREE
, convert (build_pointer_type (objc_object_type
),
3576 build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0)),
3579 assemble_external (objc_assign_global_decl
);
3580 return build_function_call (input_location
,
3581 objc_assign_global_decl
, func_params
);
3585 objc_build_strong_cast_assignment (tree lhs
, tree rhs
)
3587 tree func_params
= tree_cons (NULL_TREE
,
3588 convert (objc_object_type
, rhs
),
3589 tree_cons (NULL_TREE
, convert (build_pointer_type (objc_object_type
),
3590 build_unary_op (input_location
, ADDR_EXPR
, lhs
, 0)),
3593 assemble_external (objc_assign_strong_cast_decl
);
3594 return build_function_call (input_location
,
3595 objc_assign_strong_cast_decl
, func_params
);
3599 objc_is_gcable_p (tree expr
)
3601 return (TREE_CODE (expr
) == COMPONENT_REF
3602 ? objc_is_gcable_p (TREE_OPERAND (expr
, 1))
3603 : TREE_CODE (expr
) == ARRAY_REF
3604 ? (objc_is_gcable_p (TREE_TYPE (expr
))
3605 || objc_is_gcable_p (TREE_OPERAND (expr
, 0)))
3606 : TREE_CODE (expr
) == ARRAY_TYPE
3607 ? objc_is_gcable_p (TREE_TYPE (expr
))
3609 ? objc_is_gcable_type (expr
, 1)
3610 : (objc_is_gcable_p (TREE_TYPE (expr
))
3612 && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr
)))));
3616 objc_is_ivar_reference_p (tree expr
)
3618 return (TREE_CODE (expr
) == ARRAY_REF
3619 ? objc_is_ivar_reference_p (TREE_OPERAND (expr
, 0))
3620 : TREE_CODE (expr
) == COMPONENT_REF
3621 ? TREE_CODE (TREE_OPERAND (expr
, 1)) == FIELD_DECL
3626 objc_is_global_reference_p (tree expr
)
3628 return (TREE_CODE (expr
) == INDIRECT_REF
|| TREE_CODE (expr
) == PLUS_EXPR
3629 ? objc_is_global_reference_p (TREE_OPERAND (expr
, 0))
3631 ? (DECL_FILE_SCOPE_P (expr
) || TREE_STATIC (expr
))
3636 objc_generate_write_barrier (tree lhs
, enum tree_code modifycode
, tree rhs
)
3638 tree result
= NULL_TREE
, outer
;
3639 int strong_cast_p
= 0, outer_gc_p
= 0, indirect_p
= 0;
3641 /* This function is currently only used with the next runtime with
3642 garbage collection enabled (-fobjc-gc). */
3643 gcc_assert (flag_next_runtime
);
3645 /* See if we have any lhs casts, and strip them out. NB: The lvalue casts
3646 will have been transformed to the form '*(type *)&expr'. */
3647 if (TREE_CODE (lhs
) == INDIRECT_REF
)
3649 outer
= TREE_OPERAND (lhs
, 0);
3651 while (!strong_cast_p
3652 && (CONVERT_EXPR_P (outer
)
3653 || TREE_CODE (outer
) == NON_LVALUE_EXPR
))
3655 tree lhstype
= TREE_TYPE (outer
);
3657 /* Descend down the cast chain, and record the first objc_gc
3659 if (POINTER_TYPE_P (lhstype
))
3662 = lookup_attribute ("objc_gc",
3663 TYPE_ATTRIBUTES (TREE_TYPE (lhstype
)));
3669 outer
= TREE_OPERAND (outer
, 0);
3673 /* If we have a __strong cast, it trumps all else. */
3676 if (modifycode
!= NOP_EXPR
)
3677 goto invalid_pointer_arithmetic
;
3679 if (warn_assign_intercept
)
3680 warning (0, "strong-cast assignment has been intercepted");
3682 result
= objc_build_strong_cast_assignment (lhs
, rhs
);
3687 /* the lhs must be of a suitable type, regardless of its underlying
3689 if (!objc_is_gcable_p (lhs
))
3695 && (TREE_CODE (outer
) == COMPONENT_REF
3696 || TREE_CODE (outer
) == ARRAY_REF
))
3697 outer
= TREE_OPERAND (outer
, 0);
3699 if (TREE_CODE (outer
) == INDIRECT_REF
)
3701 outer
= TREE_OPERAND (outer
, 0);
3705 outer_gc_p
= objc_is_gcable_p (outer
);
3707 /* Handle ivar assignments. */
3708 if (objc_is_ivar_reference_p (lhs
))
3710 /* if the struct to the left of the ivar is not an Objective-C object (__strong
3711 doesn't cut it here), the best we can do here is suggest a cast. */
3712 if (!objc_is_gcable_type (TREE_TYPE (outer
), 0))
3714 /* We may still be able to use the global write barrier... */
3715 if (!indirect_p
&& objc_is_global_reference_p (outer
))
3716 goto global_reference
;
3719 if (modifycode
== NOP_EXPR
)
3721 if (warn_assign_intercept
)
3722 warning (0, "strong-cast may possibly be needed");
3728 if (modifycode
!= NOP_EXPR
)
3729 goto invalid_pointer_arithmetic
;
3731 if (warn_assign_intercept
)
3732 warning (0, "instance variable assignment has been intercepted");
3734 result
= objc_build_ivar_assignment (outer
, lhs
, rhs
);
3739 /* Likewise, intercept assignment to global/static variables if their type is
3741 if (objc_is_global_reference_p (outer
))
3747 if (modifycode
!= NOP_EXPR
)
3749 invalid_pointer_arithmetic
:
3751 warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3756 if (warn_assign_intercept
)
3757 warning (0, "global/static variable assignment has been intercepted");
3759 result
= objc_build_global_assignment (lhs
, rhs
);
3762 /* In all other cases, fall back to the normal mechanism. */
3767 struct GTY(()) interface_tuple
{
3772 static GTY ((param_is (struct interface_tuple
))) htab_t interface_htab
;
3775 hash_interface (const void *p
)
3777 const struct interface_tuple
*d
= (const struct interface_tuple
*) p
;
3778 return IDENTIFIER_HASH_VALUE (d
->id
);
3782 eq_interface (const void *p1
, const void *p2
)
3784 const struct interface_tuple
*d
= (const struct interface_tuple
*) p1
;
3789 lookup_interface (tree ident
)
3792 if (ident
&& TREE_CODE (ident
) == TYPE_DECL
)
3793 ident
= DECL_NAME (ident
);
3796 if (ident
== NULL_TREE
|| TREE_CODE (ident
) != IDENTIFIER_NODE
)
3800 struct interface_tuple
**slot
;
3805 slot
= (struct interface_tuple
**)
3806 htab_find_slot_with_hash (interface_htab
, ident
,
3807 IDENTIFIER_HASH_VALUE (ident
),
3810 i
= (*slot
)->class_name
;
3818 /* Implement @defs (<classname>) within struct bodies. */
3821 objc_get_class_ivars (tree class_name
)
3823 tree interface
= lookup_interface (class_name
);
3826 return get_class_ivars (interface
, true);
3828 error ("cannot find interface declaration for %qE",
3831 return error_mark_node
;
3835 /* Functions used by the hashtable for field duplicates in
3836 objc_detect_field_duplicates(). Ideally, we'd use a standard
3837 key-value dictionary hashtable , and store as keys the field names,
3838 and as values the actual declarations (used to print nice error
3839 messages with the locations). But, the hashtable we are using only
3840 allows us to store keys in the hashtable, without values (it looks
3841 more like a set). So, we store the DECLs, but define equality as
3842 DECLs having the same name, and hash as the hash of the name. */
3844 hash_instance_variable (const PTR p
)
3846 const_tree q
= (const_tree
)p
;
3847 return (hashval_t
) ((intptr_t)(DECL_NAME (q
)) >> 3);
3851 eq_instance_variable (const PTR p1
, const PTR p2
)
3853 const_tree a
= (const_tree
)p1
;
3854 const_tree b
= (const_tree
)p2
;
3855 return DECL_NAME (a
) == DECL_NAME (b
);
3858 /* Called when checking the variables in a struct. If we are not
3859 doing the ivars list inside an @interface context, then return
3860 false. Else, perform the check for duplicate ivars, then return
3861 true. The check for duplicates checks if an instance variable with
3862 the same name exists in the class or in a superclass. If
3863 'check_superclasses_only' is set to true, then it is assumed that
3864 checks for instance variables in the same class has already been
3865 performed (this is the case for ObjC++) and only the instance
3866 variables of superclasses are checked. */
3868 objc_detect_field_duplicates (bool check_superclasses_only
)
3870 if (!objc_collecting_ivars
|| !objc_interface_context
3871 || TREE_CODE (objc_interface_context
) != CLASS_INTERFACE_TYPE
)
3874 /* We have two ways of doing this check:
3876 "direct comparison": we iterate over the instance variables and
3877 compare them directly. This works great for small numbers of
3878 instance variables (such as 10 or 20), which are extremely common.
3879 But it will potentially take forever for the pathological case with
3880 a huge number (eg, 10k) of instance variables.
3882 "hashtable": we use a hashtable, which requires a single sweep
3883 through the list of instances variables. This is much slower for a
3884 small number of variables, and we only use it for large numbers.
3886 To decide which one to use, we need to get an idea of how many
3887 instance variables we have to compare. */
3889 unsigned int number_of_ivars_to_check
= 0;
3892 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
);
3893 ivar
; ivar
= DECL_CHAIN (ivar
))
3895 /* Ignore anonymous ivars. */
3896 if (DECL_NAME (ivar
))
3897 number_of_ivars_to_check
++;
3901 /* Exit if there is nothing to do. */
3902 if (number_of_ivars_to_check
== 0)
3905 /* In case that there are only 1 or 2 instance variables to check,
3906 we always use direct comparison. If there are more, it is
3907 worth iterating over the instance variables in the superclass
3908 to count how many there are (note that this has the same cost
3909 as checking 1 instance variable by direct comparison, which is
3910 why we skip this check in the case of 1 or 2 ivars and just do
3911 the direct comparison) and then decide if it worth using a
3913 if (number_of_ivars_to_check
> 2)
3915 unsigned int number_of_superclass_ivars
= 0;
3918 for (interface
= lookup_interface (CLASS_SUPER_NAME (objc_interface_context
));
3919 interface
; interface
= lookup_interface (CLASS_SUPER_NAME (interface
)))
3922 for (ivar
= CLASS_RAW_IVARS (interface
);
3923 ivar
; ivar
= DECL_CHAIN (ivar
))
3924 number_of_superclass_ivars
++;
3928 /* We use a hashtable if we have over 10k comparisons. */
3929 if (number_of_ivars_to_check
* (number_of_superclass_ivars
3930 + (number_of_ivars_to_check
/ 2))
3933 /* First, build the hashtable by putting all the instance
3934 variables of superclasses in it. */
3935 htab_t htab
= htab_create (37, hash_instance_variable
,
3936 eq_instance_variable
, NULL
);
3938 for (interface
= lookup_interface (CLASS_SUPER_NAME
3939 (objc_interface_context
));
3940 interface
; interface
= lookup_interface
3941 (CLASS_SUPER_NAME (interface
)))
3944 for (ivar
= CLASS_RAW_IVARS (interface
); ivar
;
3945 ivar
= DECL_CHAIN (ivar
))
3947 if (DECL_NAME (ivar
) != NULL_TREE
)
3949 void **slot
= htab_find_slot (htab
, ivar
, INSERT
);
3950 /* Do not check for duplicate instance
3951 variables in superclasses. Errors have
3952 already been generated. */
3958 /* Now, we go through all the instance variables in the
3959 class, and check that they are not in the
3961 if (check_superclasses_only
)
3964 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
); ivar
;
3965 ivar
= DECL_CHAIN (ivar
))
3967 if (DECL_NAME (ivar
) != NULL_TREE
)
3969 tree duplicate_ivar
= (tree
)(htab_find (htab
, ivar
));
3970 if (duplicate_ivar
!= HTAB_EMPTY_ENTRY
)
3972 error_at (DECL_SOURCE_LOCATION (ivar
),
3973 "duplicate instance variable %q+D",
3975 inform (DECL_SOURCE_LOCATION (duplicate_ivar
),
3976 "previous declaration of %q+D",
3978 /* FIXME: Do we need the following ? */
3979 /* DECL_NAME (ivar) = NULL_TREE; */
3986 /* If we're checking for duplicates in the class as
3987 well, we insert variables in the hashtable as we
3988 check them, so if a duplicate follows, it will be
3991 for (ivar
= CLASS_RAW_IVARS (objc_interface_context
); ivar
;
3992 ivar
= DECL_CHAIN (ivar
))
3994 if (DECL_NAME (ivar
) != NULL_TREE
)
3996 void **slot
= htab_find_slot (htab
, ivar
, INSERT
);
3999 tree duplicate_ivar
= (tree
)(*slot
);
4000 error_at (DECL_SOURCE_LOCATION (ivar
),
4001 "duplicate instance variable %q+D",
4003 inform (DECL_SOURCE_LOCATION (duplicate_ivar
),
4004 "previous declaration of %q+D",
4006 /* FIXME: Do we need the following ? */
4007 /* DECL_NAME (ivar) = NULL_TREE; */
4019 /* This is the "direct comparison" approach, which is used in most
4020 non-pathological cases. */
4022 /* Walk up to class hierarchy, starting with this class (this is
4023 the external loop, because lookup_interface() is expensive, and
4024 we want to do it few times). */
4025 tree interface
= objc_interface_context
;
4027 if (check_superclasses_only
)
4028 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
4030 for ( ; interface
; interface
= lookup_interface
4031 (CLASS_SUPER_NAME (interface
)))
4033 tree ivar_being_checked
;
4035 for (ivar_being_checked
= CLASS_RAW_IVARS (objc_interface_context
);
4037 ivar_being_checked
= DECL_CHAIN (ivar_being_checked
))
4041 /* Ignore anonymous ivars. */
4042 if (DECL_NAME (ivar_being_checked
) == NULL_TREE
)
4045 /* Note how we stop when we find the ivar we are checking
4046 (this can only happen in the main class, not
4047 superclasses), to avoid comparing things twice
4048 (otherwise, for each ivar, you'd compare A to B then B
4049 to A, and get duplicated error messages). */
4050 for (decl
= CLASS_RAW_IVARS (interface
);
4051 decl
&& decl
!= ivar_being_checked
;
4052 decl
= DECL_CHAIN (decl
))
4054 if (DECL_NAME (ivar_being_checked
) == DECL_NAME (decl
))
4056 error_at (DECL_SOURCE_LOCATION (ivar_being_checked
),
4057 "duplicate instance variable %q+D",
4058 ivar_being_checked
);
4059 inform (DECL_SOURCE_LOCATION (decl
),
4060 "previous declaration of %q+D",
4062 /* FIXME: Do we need the following ? */
4063 /* DECL_NAME (ivar_being_checked) = NULL_TREE; */
4072 /* Used by: build_private_template, continue_class,
4073 and for @defs constructs. */
4076 get_class_ivars (tree interface
, bool inherited
)
4078 tree ivar_chain
= copy_list (CLASS_RAW_IVARS (interface
));
4080 /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
4081 by the current class (i.e., they do not include super-class ivars).
4082 However, the CLASS_IVARS list will be side-effected by a call to
4083 finish_struct(), which will fill in field offsets. */
4084 if (!CLASS_IVARS (interface
))
4085 CLASS_IVARS (interface
) = ivar_chain
;
4090 while (CLASS_SUPER_NAME (interface
))
4092 /* Prepend super-class ivars. */
4093 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
4094 ivar_chain
= chainon (copy_list (CLASS_RAW_IVARS (interface
)),
4102 objc_maybe_warn_exceptions (location_t loc
)
4104 /* -fobjc-exceptions is required to enable Objective-C exceptions.
4105 For example, on Darwin, ObjC exceptions require a sufficiently
4106 recent version of the runtime, so the user must ask for them
4107 explicitly. On other platforms, at the moment -fobjc-exceptions
4108 triggers -fexceptions which again is required for exceptions to
4110 if (!flag_objc_exceptions
)
4112 /* Warn only once per compilation unit. */
4113 static bool warned
= false;
4117 error_at (loc
, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax");
4123 static struct objc_try_context
*cur_try_context
;
4125 /* Called just after parsing the @try and its associated BODY. We now
4126 must prepare for the tricky bits -- handling the catches and finally. */
4129 objc_begin_try_stmt (location_t try_locus
, tree body
)
4131 struct objc_try_context
*c
= XCNEW (struct objc_try_context
);
4132 c
->outer
= cur_try_context
;
4134 c
->try_locus
= try_locus
;
4135 c
->end_try_locus
= input_location
;
4136 cur_try_context
= c
;
4138 /* Collect the list of local variables. We'll mark them as volatile
4139 at the end of compilation of this function to prevent them being
4140 clobbered by setjmp/longjmp. */
4141 if (flag_objc_sjlj_exceptions
)
4142 objc_mark_locals_volatile (NULL
);
4145 /* Called just after parsing "@catch (parm)". Open a binding level,
4146 enter DECL into the binding level, and initialize it. Leave the
4147 binding level open while the body of the compound statement is
4148 parsed. If DECL is NULL_TREE, then we are compiling "@catch(...)"
4149 which we compile as "@catch(id tmp_variable)". */
4152 objc_begin_catch_clause (tree decl
)
4154 tree compound
, type
, t
;
4155 bool ellipsis
= false;
4157 /* Begin a new scope that the entire catch clause will live in. */
4158 compound
= c_begin_compound_stmt (true);
4160 /* Create the appropriate declaration for the argument. */
4161 if (decl
== error_mark_node
)
4162 type
= error_mark_node
;
4165 if (decl
== NULL_TREE
)
4167 /* If @catch(...) was specified, create a temporary variable of
4168 type 'id' and use it. */
4169 decl
= objc_create_temporary_var (objc_object_type
, "__objc_generic_catch_var");
4170 DECL_SOURCE_LOCATION (decl
) = input_location
;
4171 /* ... but allow the runtime to differentiate between ellipsis and the
4172 case of @catch (id xyz). */
4177 /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
4178 decl
= build_decl (input_location
,
4179 VAR_DECL
, DECL_NAME (decl
), TREE_TYPE (decl
));
4181 lang_hooks
.decls
.pushdecl (decl
);
4183 /* Mark the declaration as used so you never any warnings whether
4184 you use the exception argument or not. TODO: Implement a
4185 -Wunused-exception-parameter flag, which would cause warnings
4186 if exception parameter is not used. */
4187 TREE_USED (decl
) = 1;
4188 DECL_READ_P (decl
) = 1;
4190 type
= TREE_TYPE (decl
);
4193 /* Verify that the type of the catch is valid. It must be a pointer
4194 to an Objective-C class, or "id" (which is catch-all). */
4195 if (type
== error_mark_node
)
4197 ;/* Just keep going. */
4199 else if (!objc_type_valid_for_messaging (type
, false))
4201 error ("@catch parameter is not a known Objective-C class type");
4202 type
= error_mark_node
;
4204 else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type
))
4205 && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type
)))
4207 error ("@catch parameter can not be protocol-qualified");
4208 type
= error_mark_node
;
4210 else if (POINTER_TYPE_P (type
) && objc_is_object_id (TREE_TYPE (type
)))
4211 /* @catch (id xyz) or @catch (...) but we note this for runtimes that
4216 /* If 'type' was built using typedefs, we need to get rid of
4217 them and get a simple pointer to the class. */
4218 bool is_typedef
= false;
4219 tree x
= TYPE_MAIN_VARIANT (type
);
4221 /* Skip from the pointer to the pointee. */
4222 if (TREE_CODE (x
) == POINTER_TYPE
)
4225 /* Traverse typedef aliases */
4226 while (TREE_CODE (x
) == RECORD_TYPE
&& OBJC_TYPE_NAME (x
)
4227 && TREE_CODE (OBJC_TYPE_NAME (x
)) == TYPE_DECL
4228 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x
)))
4231 x
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x
));
4234 /* If it was a typedef, build a pointer to the final, original
4237 type
= build_pointer_type (x
);
4239 if (cur_try_context
->catch_list
)
4241 /* Examine previous @catch clauses and see if we've already
4242 caught the type in question. */
4243 tree_stmt_iterator i
= tsi_start (cur_try_context
->catch_list
);
4244 for (; !tsi_end_p (i
); tsi_next (&i
))
4246 tree stmt
= tsi_stmt (i
);
4247 t
= CATCH_TYPES (stmt
);
4248 if (t
== error_mark_node
)
4250 if (!t
|| DERIVED_FROM_P (TREE_TYPE (t
), TREE_TYPE (type
)))
4252 warning (0, "exception of type %<%T%> will be caught",
4254 warning_at (EXPR_LOCATION (stmt
), 0, " by earlier handler for %<%T%>",
4255 TREE_TYPE (t
? t
: objc_object_type
));
4262 t
= (*runtime
.begin_catch
) (&cur_try_context
, type
, decl
, compound
, ellipsis
);
4266 /* Called just after parsing the closing brace of a @catch clause. Close
4267 the open binding level, and record a CATCH_EXPR for it. */
4270 objc_finish_catch_clause (void)
4272 tree c
= cur_try_context
->current_catch
;
4273 cur_try_context
->current_catch
= NULL
;
4274 cur_try_context
->end_catch_locus
= input_location
;
4276 CATCH_BODY (c
) = c_end_compound_stmt (input_location
, CATCH_BODY (c
), 1);
4278 (*runtime
.finish_catch
) (&cur_try_context
, c
);
4281 /* Called after parsing a @finally clause and its associated BODY.
4282 Record the body for later placement. */
4285 objc_build_finally_clause (location_t finally_locus
, tree body
)
4287 cur_try_context
->finally_body
= body
;
4288 cur_try_context
->finally_locus
= finally_locus
;
4289 cur_try_context
->end_finally_locus
= input_location
;
4292 /* Called to finalize a @try construct. */
4295 objc_finish_try_stmt (void)
4297 struct objc_try_context
*c
= cur_try_context
;
4300 if (c
->catch_list
== NULL
&& c
->finally_body
== NULL
)
4301 error ("%<@try%> without %<@catch%> or %<@finally%>");
4303 stmt
= (*runtime
.finish_try_stmt
) (&cur_try_context
);
4306 cur_try_context
= c
->outer
;
4312 objc_build_throw_stmt (location_t loc
, tree throw_expr
)
4314 bool rethrown
= false;
4316 objc_maybe_warn_exceptions (loc
);
4318 /* Don't waste time trying to build something if we're already dead. */
4319 if (throw_expr
== error_mark_node
)
4320 return error_mark_node
;
4322 if (throw_expr
== NULL
)
4324 /* If we're not inside a @catch block, there is no "current
4325 exception" to be rethrown. */
4326 if (cur_try_context
== NULL
4327 || cur_try_context
->current_catch
== NULL
)
4329 error_at (loc
, "%<@throw%> (rethrow) used outside of a @catch block");
4330 return error_mark_node
;
4333 /* Otherwise the object is still sitting in the EXC_PTR_EXPR
4334 value that we get from the runtime. */
4335 throw_expr
= (*runtime
.build_exc_ptr
) (&cur_try_context
);
4340 if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr
), true))
4342 error_at (loc
, "%<@throw%> argument is not an object");
4343 return error_mark_node
;
4347 return (*runtime
.build_throw_stmt
) (loc
, throw_expr
, rethrown
);
4351 objc_build_synchronized (location_t start_locus
, tree object_expr
, tree body
)
4353 /* object_expr should never be NULL; but in case it is, convert it to
4355 if (object_expr
== NULL
)
4356 object_expr
= error_mark_node
;
4358 /* Validate object_expr. If not valid, set it to error_mark_node. */
4359 if (object_expr
!= error_mark_node
)
4361 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr
), true))
4363 error_at (start_locus
, "%<@synchronized%> argument is not an object");
4364 object_expr
= error_mark_node
;
4368 if (object_expr
== error_mark_node
)
4370 /* If we found an error, we simply ignore the '@synchronized'.
4371 Compile the body so we can keep going with minimal
4373 return add_stmt (body
);
4380 /* objc_sync_enter (object_expr); */
4381 object_expr
= save_expr (object_expr
);
4382 args
= tree_cons (NULL
, object_expr
, NULL
);
4383 call
= build_function_call (input_location
,
4384 objc_sync_enter_decl
, args
);
4385 SET_EXPR_LOCATION (call
, start_locus
);
4388 /* Build "objc_sync_exit (object_expr);" but do not add it yet;
4389 it goes inside the @finalize() clause. */
4390 args
= tree_cons (NULL
, object_expr
, NULL
);
4391 call
= build_function_call (input_location
,
4392 objc_sync_exit_decl
, args
);
4393 SET_EXPR_LOCATION (call
, input_location
);
4395 /* @try { body; } */
4396 objc_begin_try_stmt (start_locus
, body
);
4398 /* @finally { objc_sync_exit (object_expr); } */
4399 objc_build_finally_clause (input_location
, call
);
4401 /* End of try statement. */
4402 return objc_finish_try_stmt ();
4406 /* Construct a C struct corresponding to ObjC class CLASS, with the same
4409 struct <classname> {
4410 struct _objc_class *isa;
4415 build_private_template (tree klass
)
4417 if (!CLASS_STATIC_TEMPLATE (klass
))
4419 tree record
= objc_build_struct (klass
,
4420 get_class_ivars (klass
, false),
4421 CLASS_SUPER_NAME (klass
));
4423 /* Set the TREE_USED bit for this struct, so that stab generator
4424 can emit stabs for this struct type. */
4425 if (flag_debug_only_used_symbols
&& TYPE_STUB_DECL (record
))
4426 TREE_USED (TYPE_STUB_DECL (record
)) = 1;
4428 /* Copy the attributes from the class to the type. */
4429 if (TREE_DEPRECATED (klass
))
4430 TREE_DEPRECATED (record
) = 1;
4434 /* Begin code generation for protocols... */
4437 objc_method_parm_type (tree type
)
4439 type
= TREE_VALUE (TREE_TYPE (type
));
4440 if (TREE_CODE (type
) == TYPE_DECL
)
4441 type
= TREE_TYPE (type
);
4446 objc_encoded_type_size (tree type
)
4448 int sz
= int_size_in_bytes (type
);
4450 /* Make all integer and enum types at least as large
4452 if (sz
> 0 && INTEGRAL_TYPE_P (type
))
4453 sz
= MAX (sz
, int_size_in_bytes (integer_type_node
));
4454 /* Treat arrays as pointers, since that's how they're
4456 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4457 sz
= int_size_in_bytes (ptr_type_node
);
4461 /* Encode a method prototype.
4463 The format is described in gcc/doc/objc.texi, section 'Method
4468 encode_method_prototype (tree method_decl
)
4475 /* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */
4476 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl
)));
4478 /* Encode return type. */
4479 encode_type (objc_method_parm_type (method_decl
),
4480 obstack_object_size (&util_obstack
),
4481 OBJC_ENCODE_INLINE_DEFS
);
4484 /* The first two arguments (self and _cmd) are pointers; account for
4486 i
= int_size_in_bytes (ptr_type_node
);
4487 parm_offset
= 2 * i
;
4488 for (parms
= METHOD_SEL_ARGS (method_decl
); parms
;
4489 parms
= DECL_CHAIN (parms
))
4491 tree type
= objc_method_parm_type (parms
);
4492 int sz
= objc_encoded_type_size (type
);
4494 /* If a type size is not known, bail out. */
4497 error_at (DECL_SOURCE_LOCATION (method_decl
),
4498 "type %qT does not have a known size",
4500 /* Pretend that the encoding succeeded; the compilation will
4501 fail nevertheless. */
4502 goto finish_encoding
;
4507 sprintf (buf
, "%d@0:%d", parm_offset
, i
);
4508 obstack_grow (&util_obstack
, buf
, strlen (buf
));
4510 /* Argument types. */
4511 parm_offset
= 2 * i
;
4512 for (parms
= METHOD_SEL_ARGS (method_decl
); parms
;
4513 parms
= DECL_CHAIN (parms
))
4515 tree type
= objc_method_parm_type (parms
);
4517 /* Process argument qualifiers for user supplied arguments. */
4518 encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms
)));
4521 encode_type (type
, obstack_object_size (&util_obstack
),
4522 OBJC_ENCODE_INLINE_DEFS
);
4524 /* Compute offset. */
4525 sprintf (buf
, "%d", parm_offset
);
4526 parm_offset
+= objc_encoded_type_size (type
);
4528 obstack_grow (&util_obstack
, buf
, strlen (buf
));
4532 obstack_1grow (&util_obstack
, '\0');
4533 result
= get_identifier (XOBFINISH (&util_obstack
, char *));
4534 obstack_free (&util_obstack
, util_firstobj
);
4538 /* Generate either '- .cxx_construct' or '- .cxx_destruct' for the
4542 objc_generate_cxx_ctor_or_dtor (bool dtor
)
4544 tree fn
, body
, compound_stmt
, ivar
;
4546 /* - (id) .cxx_construct { ... return self; } */
4547 /* - (void) .cxx_construct { ... } */
4549 objc_start_method_definition
4550 (false /* is_class_method */,
4551 objc_build_method_signature (false /* is_class_method */,
4552 build_tree_list (NULL_TREE
,
4555 : objc_object_type
),
4556 get_identifier (dtor
4558 : TAG_CXX_CONSTRUCT
),
4559 make_node (TREE_LIST
),
4561 body
= begin_function_body ();
4562 compound_stmt
= begin_compound_stmt (0);
4564 ivar
= CLASS_IVARS (implementation_template
);
4565 /* Destroy ivars in reverse order. */
4567 ivar
= nreverse (copy_list (ivar
));
4569 for (; ivar
; ivar
= TREE_CHAIN (ivar
))
4571 if (TREE_CODE (ivar
) == FIELD_DECL
)
4573 tree type
= TREE_TYPE (ivar
);
4575 /* Call the ivar's default constructor or destructor. Do not
4576 call the destructor unless a corresponding constructor call
4577 has also been made (or is not needed). */
4578 if (MAYBE_CLASS_TYPE_P (type
)
4580 ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4581 && (!TYPE_NEEDS_CONSTRUCTING (type
)
4582 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4583 : (TYPE_NEEDS_CONSTRUCTING (type
)
4584 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))))
4586 (build_special_member_call
4587 (build_ivar_reference (DECL_NAME (ivar
)),
4588 dtor
? complete_dtor_identifier
: complete_ctor_identifier
,
4589 NULL
, type
, LOOKUP_NORMAL
, tf_warning_or_error
));
4593 /* The constructor returns 'self'. */
4595 finish_return_stmt (self_decl
);
4597 finish_compound_stmt (compound_stmt
);
4598 finish_function_body (body
);
4599 fn
= current_function_decl
;
4601 objc_finish_method_definition (fn
);
4604 /* The following routine will examine the current @interface for any
4605 non-POD C++ ivars requiring non-trivial construction and/or
4606 destruction, and then synthesize special '- .cxx_construct' and/or
4607 '- .cxx_destruct' methods which will run the appropriate
4608 construction or destruction code. Note that ivars inherited from
4609 super-classes are _not_ considered. */
4611 objc_generate_cxx_cdtors (void)
4613 bool need_ctor
= false, need_dtor
= false;
4616 /* Error case, due to possibly an extra @end. */
4617 if (!objc_implementation_context
)
4620 /* We do not want to do this for categories, since they do not have
4623 if (TREE_CODE (objc_implementation_context
) != CLASS_IMPLEMENTATION_TYPE
)
4626 /* First, determine if we even need a constructor and/or destructor. */
4628 for (ivar
= CLASS_IVARS (implementation_template
); ivar
;
4629 ivar
= TREE_CHAIN (ivar
))
4631 if (TREE_CODE (ivar
) == FIELD_DECL
)
4633 tree type
= TREE_TYPE (ivar
);
4635 if (MAYBE_CLASS_TYPE_P (type
))
4637 if (TYPE_NEEDS_CONSTRUCTING (type
)
4638 && TYPE_HAS_DEFAULT_CONSTRUCTOR (type
))
4639 /* NB: If a default constructor is not available, we will not
4640 be able to initialize this ivar; the add_instance_variable()
4641 routine will already have warned about this. */
4644 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type
)
4645 && (!TYPE_NEEDS_CONSTRUCTING (type
)
4646 || TYPE_HAS_DEFAULT_CONSTRUCTOR (type
)))
4647 /* NB: If a default constructor is not available, we will not
4648 call the destructor either, for symmetry. */
4654 /* Generate '- .cxx_construct' if needed. */
4657 objc_generate_cxx_ctor_or_dtor (false);
4659 /* Generate '- .cxx_destruct' if needed. */
4662 objc_generate_cxx_ctor_or_dtor (true);
4664 /* The 'imp_list' variable points at an imp_entry record for the current
4665 @implementation. Record the existence of '- .cxx_construct' and/or
4666 '- .cxx_destruct' methods therein; it will be included in the
4667 metadata for the class if the runtime needs it. */
4668 imp_list
->has_cxx_cdtors
= (need_ctor
|| need_dtor
);
4673 error_with_ivar (const char *message
, tree decl
)
4675 error_at (DECL_SOURCE_LOCATION (decl
), "%s %qs",
4676 message
, identifier_to_locale (gen_declaration (decl
)));
4681 check_ivars (tree inter
, tree imp
)
4683 tree intdecls
= CLASS_RAW_IVARS (inter
);
4684 tree impdecls
= CLASS_RAW_IVARS (imp
);
4691 if (intdecls
&& TREE_CODE (intdecls
) == TYPE_DECL
)
4692 intdecls
= TREE_CHAIN (intdecls
);
4694 if (intdecls
== 0 && impdecls
== 0)
4696 if (intdecls
== 0 || impdecls
== 0)
4698 error ("inconsistent instance variable specification");
4702 t1
= TREE_TYPE (intdecls
); t2
= TREE_TYPE (impdecls
);
4704 if (!comptypes (t1
, t2
)
4705 || !tree_int_cst_equal (DECL_INITIAL (intdecls
),
4706 DECL_INITIAL (impdecls
)))
4708 if (DECL_NAME (intdecls
) == DECL_NAME (impdecls
))
4710 error_with_ivar ("conflicting instance variable type",
4712 error_with_ivar ("previous declaration of",
4715 else /* both the type and the name don't match */
4717 error ("inconsistent instance variable specification");
4722 else if (DECL_NAME (intdecls
) != DECL_NAME (impdecls
))
4724 error_with_ivar ("conflicting instance variable name",
4726 error_with_ivar ("previous declaration of",
4730 intdecls
= DECL_CHAIN (intdecls
);
4731 impdecls
= DECL_CHAIN (impdecls
);
4737 mark_referenced_methods (void)
4739 struct imp_entry
*impent
;
4742 for (impent
= imp_list
; impent
; impent
= impent
->next
)
4744 chain
= CLASS_CLS_METHODS (impent
->imp_context
);
4747 cgraph_mark_needed_node (
4748 cgraph_get_create_node (METHOD_DEFINITION (chain
)));
4749 chain
= DECL_CHAIN (chain
);
4752 chain
= CLASS_NST_METHODS (impent
->imp_context
);
4755 cgraph_mark_needed_node (
4756 cgraph_get_create_node (METHOD_DEFINITION (chain
)));
4757 chain
= DECL_CHAIN (chain
);
4762 /* If type is empty or only type qualifiers are present, add default
4763 type of id (otherwise grokdeclarator will default to int). */
4765 adjust_type_for_id_default (tree type
)
4768 type
= make_node (TREE_LIST
);
4770 if (!TREE_VALUE (type
))
4771 TREE_VALUE (type
) = objc_object_type
;
4772 else if (TREE_CODE (TREE_VALUE (type
)) == RECORD_TYPE
4773 && TYPED_OBJECT (TREE_VALUE (type
)))
4774 error ("can not use an object as parameter to a method");
4779 /* Return a KEYWORD_DECL built using the specified key_name, arg_type,
4780 arg_name and attributes. (TODO: Rename KEYWORD_DECL to
4781 OBJC_METHOD_PARM_DECL ?)
4783 A KEYWORD_DECL is a tree representing the declaration of a
4784 parameter of an Objective-C method. It is produced when parsing a
4785 fragment of Objective-C method declaration of the form
4788 selector ':' '(' typename ')' identifier
4790 For example, take the Objective-C method
4792 -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type;
4794 the two fragments "pathForResource:(NSString *)resource" and
4795 "ofType:(NSString *)type" will generate a KEYWORD_DECL each. The
4796 KEYWORD_DECL stores the 'key_name' (eg, identifier for
4797 "pathForResource"), the 'arg_type' (eg, tree representing a
4798 NSString *), the 'arg_name' (eg identifier for "resource") and
4799 potentially some attributes (for example, a tree representing
4800 __attribute__ ((unused)) if such an attribute was attached to a
4801 certain parameter). You can access this information using the
4802 TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name),
4803 KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes).
4805 'key_name' is an identifier node (and is optional as you can omit
4806 it in Objective-C methods).
4807 'arg_type' is a tree list (and is optional too if no parameter type
4809 'arg_name' is an identifier node and is required.
4810 'attributes' is an optional tree containing parameter attributes. */
4812 objc_build_keyword_decl (tree key_name
, tree arg_type
,
4813 tree arg_name
, tree attributes
)
4817 if (flag_objc1_only
&& attributes
)
4818 error_at (input_location
, "method argument attributes are not available in Objective-C 1.0");
4820 /* If no type is specified, default to "id". */
4821 arg_type
= adjust_type_for_id_default (arg_type
);
4823 keyword_decl
= make_node (KEYWORD_DECL
);
4825 TREE_TYPE (keyword_decl
) = arg_type
;
4826 KEYWORD_ARG_NAME (keyword_decl
) = arg_name
;
4827 KEYWORD_KEY_NAME (keyword_decl
) = key_name
;
4828 DECL_ATTRIBUTES (keyword_decl
) = attributes
;
4830 return keyword_decl
;
4833 /* Given a chain of keyword_decl's, synthesize the full keyword selector. */
4835 build_keyword_selector (tree selector
)
4838 tree key_chain
, key_name
;
4841 /* Scan the selector to see how much space we'll need. */
4842 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
4844 switch (TREE_CODE (selector
))
4847 key_name
= KEYWORD_KEY_NAME (key_chain
);
4850 key_name
= TREE_PURPOSE (key_chain
);
4857 len
+= IDENTIFIER_LENGTH (key_name
) + 1;
4859 /* Just a ':' arg. */
4863 buf
= (char *) alloca (len
+ 1);
4864 /* Start the buffer out as an empty string. */
4867 for (key_chain
= selector
; key_chain
; key_chain
= TREE_CHAIN (key_chain
))
4869 switch (TREE_CODE (selector
))
4872 key_name
= KEYWORD_KEY_NAME (key_chain
);
4875 key_name
= TREE_PURPOSE (key_chain
);
4876 /* The keyword decl chain will later be used as a function
4877 argument chain. Unhook the selector itself so as to not
4878 confuse other parts of the compiler. */
4879 TREE_PURPOSE (key_chain
) = NULL_TREE
;
4886 strcat (buf
, IDENTIFIER_POINTER (key_name
));
4890 return get_identifier_with_length (buf
, len
);
4893 /* Used for declarations and definitions. */
4896 build_method_decl (enum tree_code code
, tree ret_type
, tree selector
,
4897 tree add_args
, bool ellipsis
)
4901 /* If no type is specified, default to "id". */
4902 ret_type
= adjust_type_for_id_default (ret_type
);
4904 /* Note how a method_decl has a TREE_TYPE which is not the function
4905 type of the function implementing the method, but only the return
4906 type of the method. We may want to change this, and store the
4907 entire function type in there (eg, it may be used to simplify
4908 dealing with attributes below). */
4909 method_decl
= make_node (code
);
4910 TREE_TYPE (method_decl
) = ret_type
;
4912 /* If we have a keyword selector, create an identifier_node that
4913 represents the full selector name (`:' included)... */
4914 if (TREE_CODE (selector
) == KEYWORD_DECL
)
4916 METHOD_SEL_NAME (method_decl
) = build_keyword_selector (selector
);
4917 METHOD_SEL_ARGS (method_decl
) = selector
;
4918 METHOD_ADD_ARGS (method_decl
) = add_args
;
4919 METHOD_ADD_ARGS_ELLIPSIS_P (method_decl
) = ellipsis
;
4923 METHOD_SEL_NAME (method_decl
) = selector
;
4924 METHOD_SEL_ARGS (method_decl
) = NULL_TREE
;
4925 METHOD_ADD_ARGS (method_decl
) = NULL_TREE
;
4931 /* This routine processes objective-c method attributes. */
4934 objc_decl_method_attributes (tree
*node
, tree attributes
, int flags
)
4936 /* TODO: Replace the hackery below. An idea would be to store the
4937 full function type in the method declaration (for example in
4938 TREE_TYPE) and then expose ObjC method declarations to c-family
4939 and they could deal with them by simply treating them as
4942 /* Because of the dangers in the hackery below, we filter out any
4943 attribute that we do not know about. For the ones we know about,
4944 we know that they work with the hackery. For the other ones,
4945 there is no guarantee, so we have to filter them out. */
4946 tree filtered_attributes
= NULL_TREE
;
4951 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
4953 tree name
= TREE_PURPOSE (attribute
);
4955 if (is_attribute_p ("deprecated", name
)
4956 || is_attribute_p ("sentinel", name
)
4957 || is_attribute_p ("noreturn", name
))
4959 /* An attribute that we support; add it to the filtered
4961 filtered_attributes
= chainon (filtered_attributes
,
4962 copy_node (attribute
));
4964 else if (is_attribute_p ("format", name
))
4966 /* "format" is special because before adding it to the
4967 filtered attributes we need to adjust the specified
4968 format by adding the hidden function parameters for
4969 an Objective-C method (self, _cmd). */
4970 tree new_attribute
= copy_node (attribute
);
4972 /* Check the arguments specified with the attribute, and
4973 modify them adding 2 for the two hidden arguments.
4974 Note how this differs from C++; according to the
4975 specs, C++ does not do it so you have to add the +1
4976 yourself. For Objective-C, instead, the compiler
4977 adds the +2 for you. */
4979 /* The attribute arguments have not been checked yet, so
4980 we need to be careful as they could be missing or
4981 invalid. If anything looks wrong, we skip the
4982 process and the compiler will complain about it later
4983 when it validates the attribute. */
4984 /* Check that we have at least three arguments. */
4985 if (TREE_VALUE (new_attribute
)
4986 && TREE_CHAIN (TREE_VALUE (new_attribute
))
4987 && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute
))))
4989 tree second_argument
= TREE_CHAIN (TREE_VALUE (new_attribute
));
4990 tree third_argument
= TREE_CHAIN (second_argument
);
4993 /* This is the second argument, the "string-index",
4994 which specifies the index of the format string
4996 number
= TREE_VALUE (second_argument
);
4998 && TREE_CODE (number
) == INTEGER_CST
4999 && TREE_INT_CST_HIGH (number
) == 0)
5001 TREE_VALUE (second_argument
)
5002 = build_int_cst (integer_type_node
,
5003 TREE_INT_CST_LOW (number
) + 2);
5006 /* This is the third argument, the "first-to-check",
5007 which specifies the index of the first argument to
5008 check. This could be 0, meaning it is not available,
5009 in which case we don't need to add 2. Add 2 if not
5011 number
= TREE_VALUE (third_argument
);
5013 && TREE_CODE (number
) == INTEGER_CST
5014 && TREE_INT_CST_HIGH (number
) == 0
5015 && TREE_INT_CST_LOW (number
) != 0)
5017 TREE_VALUE (third_argument
)
5018 = build_int_cst (integer_type_node
,
5019 TREE_INT_CST_LOW (number
) + 2);
5022 filtered_attributes
= chainon (filtered_attributes
,
5026 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
5030 if (filtered_attributes
)
5032 /* This hackery changes the TREE_TYPE of the ObjC method
5033 declaration to be a function type, so that decl_attributes
5034 will treat the ObjC method as if it was a function. Some
5035 attributes (sentinel, format) will be applied to the function
5036 type, changing it in place; so after calling decl_attributes,
5037 we extract the function type attributes and store them in
5038 METHOD_TYPE_ATTRIBUTES. Some other attributes (noreturn,
5039 deprecated) are applied directly to the method declaration
5040 (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there
5041 is nothing to do. */
5042 tree saved_type
= TREE_TYPE (*node
);
5043 TREE_TYPE (*node
) = build_function_type
5044 (TREE_VALUE (saved_type
), get_arg_type_list (*node
, METHOD_REF
, 0));
5045 decl_attributes (node
, filtered_attributes
, flags
);
5046 METHOD_TYPE_ATTRIBUTES (*node
) = TYPE_ATTRIBUTES (TREE_TYPE (*node
));
5047 TREE_TYPE (*node
) = saved_type
;
5052 objc_method_decl (enum tree_code opcode
)
5054 return opcode
== INSTANCE_METHOD_DECL
|| opcode
== CLASS_METHOD_DECL
;
5057 /* Used by `build_objc_method_call'. Return an argument list for
5058 method METH. CONTEXT is either METHOD_DEF or METHOD_REF, saying
5059 whether we are trying to define a method or call one. SUPERFLAG
5060 says this is for a send to super; this makes a difference for the
5061 NeXT calling sequence in which the lookup and the method call are
5062 done together. If METH is null, user-defined arguments (i.e.,
5063 beyond self and _cmd) shall be represented by `...'. */
5066 get_arg_type_list (tree meth
, int context
, int superflag
)
5070 /* Receiver & _cmd types are runtime-dependent. */
5071 arglist
= (*runtime
.get_arg_type_list_base
) (meth
, context
, superflag
);
5073 /* No actual method prototype given -- assume that remaining arguments
5078 /* Build a list of argument types. */
5079 for (akey
= METHOD_SEL_ARGS (meth
); akey
; akey
= DECL_CHAIN (akey
))
5081 tree arg_type
= TREE_VALUE (TREE_TYPE (akey
));
5083 /* Decay argument types for the underlying C function as appropriate. */
5084 arg_type
= objc_decay_parm_type (arg_type
);
5086 chainon (arglist
, build_tree_list (NULL_TREE
, arg_type
));
5089 if (METHOD_ADD_ARGS (meth
))
5091 for (akey
= TREE_CHAIN (METHOD_ADD_ARGS (meth
));
5092 akey
; akey
= TREE_CHAIN (akey
))
5094 tree arg_type
= TREE_TYPE (TREE_VALUE (akey
));
5096 arg_type
= objc_decay_parm_type (arg_type
);
5098 chainon (arglist
, build_tree_list (NULL_TREE
, arg_type
));
5101 if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth
))
5102 goto lack_of_ellipsis
;
5107 chainon (arglist
, OBJC_VOID_AT_END
);
5114 check_duplicates (hash hsh
, int methods
, int is_class
)
5116 tree meth
= NULL_TREE
;
5124 /* We have two or more methods with the same name but
5128 /* But just how different are those types? If
5129 -Wno-strict-selector-match is specified, we shall not
5130 complain if the differences are solely among types with
5131 identical size and alignment. */
5132 if (!warn_strict_selector_match
)
5134 for (loop
= hsh
->list
; loop
; loop
= loop
->next
)
5135 if (!comp_proto_with_proto (meth
, loop
->value
, 0))
5144 bool type
= TREE_CODE (meth
) == INSTANCE_METHOD_DECL
;
5146 warning_at (input_location
, 0,
5147 "multiple methods named %<%c%E%> found",
5148 (is_class
? '+' : '-'),
5149 METHOD_SEL_NAME (meth
));
5150 inform (DECL_SOURCE_LOCATION (meth
), "using %<%c%s%>",
5152 identifier_to_locale (gen_method_decl (meth
)));
5156 bool type
= TREE_CODE (meth
) == INSTANCE_METHOD_DECL
;
5158 warning_at (input_location
, 0,
5159 "multiple selectors named %<%c%E%> found",
5160 (is_class
? '+' : '-'),
5161 METHOD_SEL_NAME (meth
));
5162 inform (DECL_SOURCE_LOCATION (meth
), "found %<%c%s%>",
5164 identifier_to_locale (gen_method_decl (meth
)));
5167 for (loop
= hsh
->list
; loop
; loop
= loop
->next
)
5169 bool type
= TREE_CODE (loop
->value
) == INSTANCE_METHOD_DECL
;
5171 inform (DECL_SOURCE_LOCATION (loop
->value
), "also found %<%c%s%>",
5173 identifier_to_locale (gen_method_decl (loop
->value
)));
5180 /* If RECEIVER is a class reference, return the identifier node for
5181 the referenced class. RECEIVER is created by objc_get_class_reference,
5182 so we check the exact form created depending on which runtimes are
5186 receiver_is_class_object (tree receiver
, int self
, int super
)
5190 /* The receiver is 'self' or 'super' in the context of a class method. */
5191 if (objc_method_context
5192 && TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
5195 ? CLASS_SUPER_NAME (implementation_template
)
5196 : CLASS_NAME (implementation_template
));
5198 /* The runtime might encapsulate things its own way. */
5199 exp
= (*runtime
.receiver_is_class_object
) (receiver
);
5203 /* The receiver is a function call that returns an id. Check if
5204 it is a call to objc_getClass, if so, pick up the class name. */
5205 if (TREE_CODE (receiver
) == CALL_EXPR
5206 && (exp
= CALL_EXPR_FN (receiver
))
5207 && TREE_CODE (exp
) == ADDR_EXPR
5208 && (exp
= TREE_OPERAND (exp
, 0))
5209 && TREE_CODE (exp
) == FUNCTION_DECL
5210 /* For some reason, we sometimes wind up with multiple FUNCTION_DECL
5211 prototypes for objc_get_class(). Thankfully, they seem to share the
5212 same function type. */
5213 && TREE_TYPE (exp
) == TREE_TYPE (objc_get_class_decl
)
5214 && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp
)), runtime
.tag_getclass
)
5215 /* We have a call to objc_get_class/objc_getClass! */
5216 && (arg
= CALL_EXPR_ARG (receiver
, 0)))
5219 if (TREE_CODE (arg
) == ADDR_EXPR
5220 && (arg
= TREE_OPERAND (arg
, 0))
5221 && TREE_CODE (arg
) == STRING_CST
)
5222 /* Finally, we have the class name. */
5223 return get_identifier (TREE_STRING_POINTER (arg
));
5228 /* If we are currently building a message expr, this holds
5229 the identifier of the selector of the message. This is
5230 used when printing warnings about argument mismatches. */
5232 static tree current_objc_message_selector
= 0;
5235 objc_message_selector (void)
5237 return current_objc_message_selector
;
5240 /* Construct an expression for sending a message.
5241 MESS has the object to send to in TREE_PURPOSE
5242 and the argument list (including selector) in TREE_VALUE.
5244 (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
5245 (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
5248 objc_build_message_expr (tree receiver
, tree message_args
)
5252 tree args
= TREE_PURPOSE (message_args
);
5254 tree args
= message_args
;
5256 tree method_params
= NULL_TREE
;
5258 if (TREE_CODE (receiver
) == ERROR_MARK
|| TREE_CODE (args
) == ERROR_MARK
)
5259 return error_mark_node
;
5261 /* Obtain the full selector name. */
5262 switch (TREE_CODE (args
))
5264 case IDENTIFIER_NODE
:
5265 /* A unary selector. */
5269 sel_name
= build_keyword_selector (args
);
5275 /* Build the parameter list to give to the method. */
5276 if (TREE_CODE (args
) == TREE_LIST
)
5278 method_params
= chainon (args
, TREE_VALUE (message_args
));
5281 tree chain
= args
, prev
= NULL_TREE
;
5283 /* We have a keyword selector--check for comma expressions. */
5286 tree element
= TREE_VALUE (chain
);
5288 /* We have a comma expression, must collapse... */
5289 if (TREE_CODE (element
) == TREE_LIST
)
5292 TREE_CHAIN (prev
) = element
;
5297 chain
= TREE_CHAIN (chain
);
5299 method_params
= args
;
5304 if (processing_template_decl
)
5305 /* Must wait until template instantiation time. */
5306 return build_min_nt (MESSAGE_SEND_EXPR
, receiver
, sel_name
,
5310 return objc_finish_message_expr (receiver
, sel_name
, method_params
, NULL
);
5313 /* Look up method SEL_NAME that would be suitable for receiver
5314 of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is
5315 nonzero), and report on any duplicates. */
5318 lookup_method_in_hash_lists (tree sel_name
, int is_class
)
5320 hash method_prototype
= NULL
;
5323 method_prototype
= hash_lookup (nst_method_hash_list
,
5326 if (!method_prototype
)
5328 method_prototype
= hash_lookup (cls_method_hash_list
,
5333 return check_duplicates (method_prototype
, 1, is_class
);
5336 /* The 'objc_finish_message_expr' routine is called from within
5337 'objc_build_message_expr' for non-template functions. In the case of
5338 C++ template functions, it is called from 'build_expr_from_tree'
5339 (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded.
5341 If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn
5342 if the method being used is deprecated. If it is not NULL, instead
5343 of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method
5344 prototype that was used and is deprecated. This is useful for
5345 getter calls that are always generated when compiling dot-syntax
5346 expressions, even if they may not be used. In that case, we don't
5347 want the warning immediately; we produce it (if needed) at gimplify
5348 stage when we are sure that the deprecated getter is being
5351 objc_finish_message_expr (tree receiver
, tree sel_name
, tree method_params
,
5352 tree
*deprecated_method_prototype
)
5354 tree method_prototype
= NULL_TREE
, rprotos
= NULL_TREE
, rtype
;
5355 tree retval
, class_tree
;
5356 int self
, super
, have_cast
;
5358 /* We have used the receiver, so mark it as read. */
5359 mark_exp_read (receiver
);
5361 /* Extract the receiver of the message, as well as its type
5362 (where the latter may take the form of a cast or be inferred
5363 from the implementation context). */
5365 while (TREE_CODE (rtype
) == COMPOUND_EXPR
5366 || TREE_CODE (rtype
) == MODIFY_EXPR
5367 || CONVERT_EXPR_P (rtype
)
5368 || TREE_CODE (rtype
) == COMPONENT_REF
)
5369 rtype
= TREE_OPERAND (rtype
, 0);
5371 self
= (rtype
== self_decl
);
5372 super
= (rtype
== UOBJC_SUPER_decl
);
5373 rtype
= TREE_TYPE (receiver
);
5375 have_cast
= (TREE_CODE (receiver
) == NOP_EXPR
5376 || (TREE_CODE (receiver
) == COMPOUND_EXPR
5377 && !IS_SUPER (rtype
)));
5379 /* If we are calling [super dealloc], reset our warning flag. */
5380 if (super
&& !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name
)))
5381 should_call_super_dealloc
= 0;
5383 /* If the receiver is a class object, retrieve the corresponding
5384 @interface, if one exists. */
5385 class_tree
= receiver_is_class_object (receiver
, self
, super
);
5387 /* Now determine the receiver type (if an explicit cast has not been
5392 rtype
= lookup_interface (class_tree
);
5393 /* Handle `self' and `super'. */
5396 if (!CLASS_SUPER_NAME (implementation_template
))
5398 error ("no super class declared in @interface for %qE",
5399 CLASS_NAME (implementation_template
));
5400 return error_mark_node
;
5402 rtype
= lookup_interface (CLASS_SUPER_NAME (implementation_template
));
5405 rtype
= lookup_interface (CLASS_NAME (implementation_template
));
5408 /* If receiver is of type `id' or `Class' (or if the @interface for a
5409 class is not visible), we shall be satisfied with the existence of
5410 any instance or class method. */
5411 if (objc_is_id (rtype
))
5413 class_tree
= (IS_CLASS (rtype
) ? objc_class_name
: NULL_TREE
);
5414 rprotos
= (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype
))
5415 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype
))
5421 /* If messaging 'id <Protos>' or 'Class <Proto>', first search
5422 in protocols themselves for the method prototype. */
5424 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5425 class_tree
!= NULL_TREE
);
5427 /* If messaging 'Class <Proto>' but did not find a class method
5428 prototype, search for an instance method instead, and warn
5429 about having done so. */
5430 if (!method_prototype
&& !rtype
&& class_tree
!= NULL_TREE
)
5433 = lookup_method_in_protocol_list (rprotos
, sel_name
, 0);
5435 if (method_prototype
)
5436 warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)",
5437 sel_name
, sel_name
);
5443 tree orig_rtype
= rtype
;
5445 if (TREE_CODE (rtype
) == POINTER_TYPE
)
5446 rtype
= TREE_TYPE (rtype
);
5447 /* Traverse typedef aliases */
5448 while (TREE_CODE (rtype
) == RECORD_TYPE
&& OBJC_TYPE_NAME (rtype
)
5449 && TREE_CODE (OBJC_TYPE_NAME (rtype
)) == TYPE_DECL
5450 && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype
)))
5451 rtype
= DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype
));
5452 if (TYPED_OBJECT (rtype
))
5454 rprotos
= TYPE_OBJC_PROTOCOL_LIST (rtype
);
5455 rtype
= TYPE_OBJC_INTERFACE (rtype
);
5457 /* If we could not find an @interface declaration, we must have
5458 only seen a @class declaration; so, we cannot say anything
5459 more intelligent about which methods the receiver will
5461 if (!rtype
|| TREE_CODE (rtype
) == IDENTIFIER_NODE
)
5464 /* We could not find an @interface declaration, yet Message maybe in a
5465 @class's protocol. */
5466 if (!method_prototype
&& rprotos
)
5468 = lookup_method_in_protocol_list (rprotos
, sel_name
, 0);
5470 else if (TREE_CODE (rtype
) == CLASS_INTERFACE_TYPE
5471 || TREE_CODE (rtype
) == CLASS_IMPLEMENTATION_TYPE
)
5473 /* We have a valid ObjC class name. Look up the method name
5474 in the published @interface for the class (and its
5477 = lookup_method_static (rtype
, sel_name
, class_tree
!= NULL_TREE
);
5479 /* If the method was not found in the @interface, it may still
5480 exist locally as part of the @implementation. */
5481 if (!method_prototype
&& objc_implementation_context
5482 && CLASS_NAME (objc_implementation_context
)
5483 == OBJC_TYPE_NAME (rtype
))
5487 ? CLASS_CLS_METHODS (objc_implementation_context
)
5488 : CLASS_NST_METHODS (objc_implementation_context
)),
5491 /* If we haven't found a candidate method by now, try looking for
5492 it in the protocol list. */
5493 if (!method_prototype
&& rprotos
)
5495 = lookup_method_in_protocol_list (rprotos
, sel_name
,
5496 class_tree
!= NULL_TREE
);
5500 warning (0, "invalid receiver type %qs",
5501 identifier_to_locale (gen_type_name (orig_rtype
)));
5502 /* After issuing the "invalid receiver" warning, perform method
5503 lookup as if we were messaging 'id'. */
5504 rtype
= rprotos
= NULL_TREE
;
5509 /* For 'id' or 'Class' receivers, search in the global hash table
5510 as a last resort. For all receivers, warn if protocol searches
5512 if (!method_prototype
)
5515 warning (0, "%<%c%E%> not found in protocol(s)",
5516 (class_tree
? '+' : '-'),
5521 = lookup_method_in_hash_lists (sel_name
, class_tree
!= NULL_TREE
);
5524 if (!method_prototype
)
5526 static bool warn_missing_methods
= false;
5529 warning (0, "%qE may not respond to %<%c%E%>",
5530 OBJC_TYPE_NAME (rtype
),
5531 (class_tree
? '+' : '-'),
5533 /* If we are messaging an 'id' or 'Class' object and made it here,
5534 then we have failed to find _any_ instance or class method,
5537 warning (0, "no %<%c%E%> method found",
5538 (class_tree
? '+' : '-'),
5541 if (!warn_missing_methods
)
5543 warning_at (input_location
,
5544 0, "(Messages without a matching method signature");
5545 warning_at (input_location
,
5546 0, "will be assumed to return %<id%> and accept");
5547 warning_at (input_location
,
5548 0, "%<...%> as arguments.)");
5549 warn_missing_methods
= true;
5554 /* Warn if the method is deprecated, but not if the receiver is
5555 a generic 'id'. 'id' is used to cast an object to a generic
5556 object of an unspecified class; in that case, we'll use
5557 whatever method prototype we can find to get the method
5558 argument and return types, but it is not appropriate to
5559 produce deprecation warnings since we don't know the class
5560 that the object will be of at runtime. The @interface(s) for
5561 that class may not even be available to the compiler right
5562 now, and it is perfectly possible that the method is marked
5563 as non-deprecated in such @interface(s).
5565 In practice this makes sense since casting an object to 'id'
5566 is often used precisely to turn off warnings associated with
5567 the object being of a particular class. */
5568 if (TREE_DEPRECATED (method_prototype
) && rtype
!= NULL_TREE
)
5570 if (deprecated_method_prototype
)
5571 *deprecated_method_prototype
= method_prototype
;
5573 warn_deprecated_use (method_prototype
, NULL_TREE
);
5577 /* Save the selector name for printing error messages. */
5578 current_objc_message_selector
= sel_name
;
5580 /* Build the method call.
5581 TODO: Get the location from somewhere that will work for delayed
5584 retval
= (*runtime
.build_objc_method_call
) (input_location
, method_prototype
,
5585 receiver
, rtype
, sel_name
,
5586 method_params
, super
);
5588 current_objc_message_selector
= 0;
5594 /* This routine creates a static variable used to implement @protocol(MyProtocol)
5595 expression. This variable will be initialized to global protocol_t meta-data
5598 /* This function is called by the parser when (and only when) a
5599 @protocol() expression is found, in order to compile it. */
5601 objc_build_protocol_expr (tree protoname
)
5603 tree p
= lookup_protocol (protoname
, /* warn if deprecated */ true,
5604 /* definition_required */ false);
5608 error ("cannot find protocol declaration for %qE", protoname
);
5609 return error_mark_node
;
5612 return (*runtime
.get_protocol_reference
) (input_location
, p
);
5615 /* This function is called by the parser when a @selector() expression
5616 is found, in order to compile it. It is only called by the parser
5617 and only to compile a @selector(). LOC is the location of the
5620 objc_build_selector_expr (location_t loc
, tree selnamelist
)
5624 /* Obtain the full selector name. */
5625 switch (TREE_CODE (selnamelist
))
5627 case IDENTIFIER_NODE
:
5628 /* A unary selector. */
5629 selname
= selnamelist
;
5632 selname
= build_keyword_selector (selnamelist
);
5638 /* If we are required to check @selector() expressions as they
5639 are found, check that the selector has been declared. */
5640 if (warn_undeclared_selector
)
5642 /* Look the selector up in the list of all known class and
5643 instance methods (up to this line) to check that the selector
5647 /* First try with instance methods. */
5648 hsh
= hash_lookup (nst_method_hash_list
, selname
);
5650 /* If not found, try with class methods. */
5653 hsh
= hash_lookup (cls_method_hash_list
, selname
);
5656 /* If still not found, print out a warning. */
5659 warning (0, "undeclared selector %qE", selname
);
5663 /* The runtimes do this differently, most particularly, GNU has typed
5664 selectors, whilst NeXT does not. */
5665 return (*runtime
.build_selector_reference
) (loc
, selname
, NULL_TREE
);
5668 /* This is used to implement @encode(). See gcc/doc/objc.texi,
5669 section '@encode'. */
5671 objc_build_encode_expr (tree type
)
5676 encode_type (type
, obstack_object_size (&util_obstack
),
5677 OBJC_ENCODE_INLINE_DEFS
);
5678 obstack_1grow (&util_obstack
, 0); /* null terminate string */
5679 string
= XOBFINISH (&util_obstack
, const char *);
5681 /* Synthesize a string that represents the encoded struct/union. */
5682 result
= my_build_string (strlen (string
) + 1, string
);
5683 obstack_free (&util_obstack
, util_firstobj
);
5688 build_ivar_reference (tree id
)
5691 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
)
5693 /* Historically, a class method that produced objects (factory
5694 method) would assign `self' to the instance that it
5695 allocated. This would effectively turn the class method into
5696 an instance method. Following this assignment, the instance
5697 variables could be accessed. That practice, while safe,
5698 violates the simple rule that a class method should not refer
5699 to an instance variable. It's better to catch the cases
5700 where this is done unknowingly than to support the above
5702 warning (0, "instance variable %qE accessed in class method",
5704 self_decl
= convert (objc_instance_type
, self_decl
); /* cast */
5707 base
= build_indirect_ref (input_location
, self_decl
, RO_ARROW
);
5708 return (*runtime
.build_ivar_reference
) (input_location
, base
, id
);
5711 /* Compute a hash value for a given method SEL_NAME. */
5714 hash_func (tree sel_name
)
5716 const unsigned char *s
5717 = (const unsigned char *)IDENTIFIER_POINTER (sel_name
);
5721 h
= h
* 67 + *s
++ - 113;
5728 nst_method_hash_list
= ggc_alloc_cleared_vec_hash (SIZEHASHTABLE
);
5729 cls_method_hash_list
= ggc_alloc_cleared_vec_hash (SIZEHASHTABLE
);
5731 cls_name_hash_list
= ggc_alloc_cleared_vec_hash (SIZEHASHTABLE
);
5732 als_name_hash_list
= ggc_alloc_cleared_vec_hash (SIZEHASHTABLE
);
5734 ivar_offset_hash_list
= ggc_alloc_cleared_vec_hash (SIZEHASHTABLE
);
5736 /* Initialize the hash table used to hold the constant string objects. */
5737 string_htab
= htab_create_ggc (31, string_hash
,
5741 /* This routine adds sel_name to the hash list. sel_name is a class or alias
5742 name for the class. If alias name, then value is its underlying class.
5743 If class, the value is NULL_TREE. */
5746 hash_class_name_enter (hash
*hashlist
, tree sel_name
, tree value
)
5749 int slot
= hash_func (sel_name
) % SIZEHASHTABLE
;
5751 obj
= ggc_alloc_hashed_entry ();
5752 if (value
!= NULL_TREE
)
5754 /* Save the underlying class for the 'alias' in the hash table */
5755 attr obj_attr
= ggc_alloc_hashed_attribute ();
5756 obj_attr
->value
= value
;
5757 obj
->list
= obj_attr
;
5761 obj
->next
= hashlist
[slot
];
5762 obj
->key
= sel_name
;
5764 hashlist
[slot
] = obj
; /* append to front */
5769 Searches in the hash table looking for a match for class or alias name.
5773 hash_class_name_lookup (hash
*hashlist
, tree sel_name
)
5777 target
= hashlist
[hash_func (sel_name
) % SIZEHASHTABLE
];
5781 if (sel_name
== target
->key
)
5784 target
= target
->next
;
5789 /* WARNING!!!! hash_enter is called with a method, and will peek
5790 inside to find its selector! But hash_lookup is given a selector
5791 directly, and looks for the selector that's inside the found
5792 entry's key (method) for comparison. */
5795 hash_enter (hash
*hashlist
, tree method
)
5798 int slot
= hash_func (METHOD_SEL_NAME (method
)) % SIZEHASHTABLE
;
5800 obj
= ggc_alloc_hashed_entry ();
5802 obj
->next
= hashlist
[slot
];
5805 hashlist
[slot
] = obj
; /* append to front */
5809 hash_lookup (hash
*hashlist
, tree sel_name
)
5813 target
= hashlist
[hash_func (sel_name
) % SIZEHASHTABLE
];
5817 if (sel_name
== METHOD_SEL_NAME (target
->key
))
5820 target
= target
->next
;
5826 hash_add_attr (hash entry
, tree value
)
5830 obj
= ggc_alloc_hashed_attribute ();
5831 obj
->next
= entry
->list
;
5834 entry
->list
= obj
; /* append to front */
5838 lookup_method (tree mchain
, tree method
)
5842 if (TREE_CODE (method
) == IDENTIFIER_NODE
)
5845 key
= METHOD_SEL_NAME (method
);
5849 if (METHOD_SEL_NAME (mchain
) == key
)
5852 mchain
= DECL_CHAIN (mchain
);
5857 /* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance
5858 method in INTERFACE, along with any categories and protocols
5859 attached thereto. If method is not found, and the
5860 OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the
5861 INTERFACE's superclass. If OBJC_LOOKUP_CLASS is set,
5862 OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could
5863 be found in INTERFACE or any of its superclasses, look for an
5864 _instance_ method of the same name in the root class as a last
5865 resort. This behaviour can be turned off by using
5866 OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS.
5868 If a suitable method cannot be found, return NULL_TREE. */
5871 lookup_method_static (tree interface
, tree ident
, int flags
)
5873 tree meth
= NULL_TREE
, root_inter
= NULL_TREE
;
5874 tree inter
= interface
;
5875 int is_class
= (flags
& OBJC_LOOKUP_CLASS
);
5876 int no_superclasses
= (flags
& OBJC_LOOKUP_NO_SUPER
);
5877 int no_instance_methods_of_root_class
= (flags
& OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS
);
5881 tree chain
= is_class
? CLASS_CLS_METHODS (inter
) : CLASS_NST_METHODS (inter
);
5882 tree category
= inter
;
5884 /* First, look up the method in the class itself. */
5885 if ((meth
= lookup_method (chain
, ident
)))
5888 /* Failing that, look for the method in each category of the class. */
5889 while ((category
= CLASS_CATEGORY_LIST (category
)))
5891 chain
= is_class
? CLASS_CLS_METHODS (category
) : CLASS_NST_METHODS (category
);
5893 /* Check directly in each category. */
5894 if ((meth
= lookup_method (chain
, ident
)))
5897 /* Failing that, check in each category's protocols. */
5898 if (CLASS_PROTOCOL_LIST (category
))
5900 if ((meth
= (lookup_method_in_protocol_list
5901 (CLASS_PROTOCOL_LIST (category
), ident
, is_class
))))
5906 /* If not found in categories, check in protocols of the main class. */
5907 if (CLASS_PROTOCOL_LIST (inter
))
5909 if ((meth
= (lookup_method_in_protocol_list
5910 (CLASS_PROTOCOL_LIST (inter
), ident
, is_class
))))
5914 /* If we were instructed not to look in superclasses, don't. */
5915 if (no_superclasses
)
5918 /* Failing that, climb up the inheritance hierarchy. */
5920 inter
= lookup_interface (CLASS_SUPER_NAME (inter
));
5924 if (is_class
&& !no_instance_methods_of_root_class
)
5926 /* If no class (factory) method was found, check if an _instance_
5927 method of the same name exists in the root class. This is what
5928 the Objective-C runtime will do. */
5929 return lookup_method_static (root_inter
, ident
, 0);
5933 /* If an instance method was not found, return 0. */
5938 /* Add the method to the hash list if it doesn't contain an identical
5942 add_method_to_hash_list (hash
*hash_list
, tree method
)
5946 if (!(hsh
= hash_lookup (hash_list
, METHOD_SEL_NAME (method
))))
5948 /* Install on a global chain. */
5949 hash_enter (hash_list
, method
);
5953 /* Check types against those; if different, add to a list. */
5955 int already_there
= comp_proto_with_proto (method
, hsh
->key
, 1);
5956 for (loop
= hsh
->list
; !already_there
&& loop
; loop
= loop
->next
)
5957 already_there
|= comp_proto_with_proto (method
, loop
->value
, 1);
5959 hash_add_attr (hsh
, method
);
5964 objc_add_method (tree klass
, tree method
, int is_class
, bool is_optional
)
5966 tree existing_method
= NULL_TREE
;
5968 /* The first thing we do is look up the method in the list of
5969 methods already defined in the interface (or implementation). */
5971 existing_method
= lookup_method (CLASS_CLS_METHODS (klass
), method
);
5973 existing_method
= lookup_method (CLASS_NST_METHODS (klass
), method
);
5975 /* In the case of protocols, we have a second list of methods to
5976 consider, the list of optional ones. */
5977 if (TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
)
5979 /* @required methods are added to the protocol's normal list.
5980 @optional methods are added to the protocol's OPTIONAL lists.
5981 Note that adding the methods to the optional lists disables
5982 checking that the methods are implemented by classes
5983 implementing the protocol, since these checks only use the
5984 CLASS_CLS_METHODS and CLASS_NST_METHODS. */
5986 /* First of all, if the method to add is @optional, and we found
5987 it already existing as @required, emit an error. */
5988 if (is_optional
&& existing_method
)
5990 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
5991 (is_class
? '+' : '-'),
5992 METHOD_SEL_NAME (existing_method
));
5993 inform (DECL_SOURCE_LOCATION (existing_method
),
5994 "previous declaration of %<%c%E%> as %<@required%>",
5995 (is_class
? '+' : '-'),
5996 METHOD_SEL_NAME (existing_method
));
5999 /* Now check the list of @optional methods if we didn't find the
6000 method in the @required list. */
6001 if (!existing_method
)
6004 existing_method
= lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass
), method
);
6006 existing_method
= lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass
), method
);
6008 if (!is_optional
&& existing_method
)
6010 error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time",
6011 (is_class
? '+' : '-'),
6012 METHOD_SEL_NAME (existing_method
));
6013 inform (DECL_SOURCE_LOCATION (existing_method
),
6014 "previous declaration of %<%c%E%> as %<@optional%>",
6015 (is_class
? '+' : '-'),
6016 METHOD_SEL_NAME (existing_method
));
6021 /* If the method didn't exist already, add it. */
6022 if (!existing_method
)
6028 /* Put the method on the list in reverse order. */
6029 TREE_CHAIN (method
) = PROTOCOL_OPTIONAL_CLS_METHODS (klass
);
6030 PROTOCOL_OPTIONAL_CLS_METHODS (klass
) = method
;
6034 TREE_CHAIN (method
) = PROTOCOL_OPTIONAL_NST_METHODS (klass
);
6035 PROTOCOL_OPTIONAL_NST_METHODS (klass
) = method
;
6042 DECL_CHAIN (method
) = CLASS_CLS_METHODS (klass
);
6043 CLASS_CLS_METHODS (klass
) = method
;
6047 DECL_CHAIN (method
) = CLASS_NST_METHODS (klass
);
6048 CLASS_NST_METHODS (klass
) = method
;
6054 /* The method was already defined. Check that the types match
6055 for an @interface for a class or category, or for a
6056 @protocol. Give hard errors on methods with identical
6057 selectors but differing argument and/or return types. We do
6058 not do this for @implementations, because C/C++ will do it
6059 for us (i.e., there will be duplicate function definition
6061 if ((TREE_CODE (klass
) == CLASS_INTERFACE_TYPE
6062 || TREE_CODE (klass
) == CATEGORY_INTERFACE_TYPE
6063 /* Starting with GCC 4.6, we emit the same error for
6064 protocols too. The situation is identical to
6065 @interfaces as there is no possible meaningful reason
6066 for defining the same method with different signatures
6067 in the very same @protocol. If that was allowed,
6068 whenever the protocol is used (both at compile and run
6069 time) there wouldn't be any meaningful way to decide
6070 which of the two method signatures should be used. */
6071 || TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
)
6072 && !comp_proto_with_proto (method
, existing_method
, 1))
6074 error ("duplicate declaration of method %<%c%E%> with conflicting types",
6075 (is_class
? '+' : '-'),
6076 METHOD_SEL_NAME (existing_method
));
6077 inform (DECL_SOURCE_LOCATION (existing_method
),
6078 "previous declaration of %<%c%E%>",
6079 (is_class
? '+' : '-'),
6080 METHOD_SEL_NAME (existing_method
));
6085 add_method_to_hash_list (cls_method_hash_list
, method
);
6088 add_method_to_hash_list (nst_method_hash_list
, method
);
6090 /* Instance methods in root classes (and categories thereof)
6091 may act as class methods as a last resort. We also add
6092 instance methods listed in @protocol declarations to
6093 the class hash table, on the assumption that @protocols
6094 may be adopted by root classes or categories. */
6095 if (TREE_CODE (klass
) == CATEGORY_INTERFACE_TYPE
6096 || TREE_CODE (klass
) == CATEGORY_IMPLEMENTATION_TYPE
)
6097 klass
= lookup_interface (CLASS_NAME (klass
));
6099 if (TREE_CODE (klass
) == PROTOCOL_INTERFACE_TYPE
6100 || !CLASS_SUPER_NAME (klass
))
6101 add_method_to_hash_list (cls_method_hash_list
, method
);
6108 add_class (tree class_name
, tree name
)
6110 struct interface_tuple
**slot
;
6112 /* Put interfaces on list in reverse order. */
6113 TREE_CHAIN (class_name
) = interface_chain
;
6114 interface_chain
= class_name
;
6116 if (interface_htab
== NULL
)
6117 interface_htab
= htab_create_ggc (31, hash_interface
, eq_interface
, NULL
);
6118 slot
= (struct interface_tuple
**)
6119 htab_find_slot_with_hash (interface_htab
, name
,
6120 IDENTIFIER_HASH_VALUE (name
),
6124 *slot
= ggc_alloc_cleared_interface_tuple ();
6127 (*slot
)->class_name
= class_name
;
6129 return interface_chain
;
6133 add_category (tree klass
, tree category
)
6135 /* Put categories on list in reverse order. */
6136 tree cat
= lookup_category (klass
, CLASS_SUPER_NAME (category
));
6140 warning (0, "duplicate interface declaration for category %<%E(%E)%>",
6142 CLASS_SUPER_NAME (category
));
6146 CLASS_CATEGORY_LIST (category
) = CLASS_CATEGORY_LIST (klass
);
6147 CLASS_CATEGORY_LIST (klass
) = category
;
6152 /* A flexible array member is a C99 extension where you can use
6153 "type[]" at the end of a struct to mean a variable-length array.
6155 In Objective-C, instance variables are fundamentally members of a
6156 struct, but the struct can always be extended by subclassing; hence
6157 we need to detect and forbid all instance variables declared using
6158 flexible array members.
6160 No check for this is needed in Objective-C++, since C++ does not
6161 have flexible array members. */
6163 /* Determine whether TYPE is a structure with a flexible array member,
6164 a union containing such a structure (possibly recursively) or an
6165 array of such structures or unions. These are all invalid as
6166 instance variable. */
6168 flexible_array_type_p (tree type
)
6171 switch (TREE_CODE (type
))
6174 x
= TYPE_FIELDS (type
);
6177 while (DECL_CHAIN (x
) != NULL_TREE
)
6179 if (TREE_CODE (TREE_TYPE (x
)) == ARRAY_TYPE
6180 && TYPE_SIZE (TREE_TYPE (x
)) == NULL_TREE
6181 && TYPE_DOMAIN (TREE_TYPE (x
)) != NULL_TREE
6182 && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x
))) == NULL_TREE
)
6186 for (x
= TYPE_FIELDS (type
); x
!= NULL_TREE
; x
= DECL_CHAIN (x
))
6188 if (flexible_array_type_p (TREE_TYPE (x
)))
6192 /* Note that we also check for arrays of something that uses a flexible array member. */
6194 if (flexible_array_type_p (TREE_TYPE (type
)))
6203 /* Produce a printable version of an ivar name. This is only used
6204 inside add_instance_variable. */
6206 printable_ivar_name (tree field_decl
)
6208 if (DECL_NAME (field_decl
))
6209 return identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl
)));
6211 return _("<unnamed>");
6214 /* Called after parsing each instance variable declaration. Necessary to
6215 preserve typedefs and implement public/private...
6217 VISIBILITY is 1 for public, 0 for protected, and 2 for private. */
6220 add_instance_variable (tree klass
, objc_ivar_visibility_kind visibility
,
6223 tree field_type
= TREE_TYPE (field_decl
);
6226 if (TREE_CODE (field_type
) == REFERENCE_TYPE
)
6228 error ("illegal reference type specified for instance variable %qs",
6229 printable_ivar_name (field_decl
));
6230 /* Return class as is without adding this ivar. */
6235 if (field_type
== error_mark_node
|| !TYPE_SIZE (field_type
)
6236 || TYPE_SIZE (field_type
) == error_mark_node
)
6237 /* 'type[0]' is allowed, but 'type[]' is not! */
6239 error ("instance variable %qs has unknown size",
6240 printable_ivar_name (field_decl
));
6241 /* Return class as is without adding this ivar. */
6246 /* Also, in C reject a struct with a flexible array member. Ie,
6248 struct A { int x; int[] y; };
6252 struct A instance_variable;
6256 is not valid because if the class is subclassed, we wouldn't be able
6257 to calculate the offset of the next instance variable. */
6258 if (flexible_array_type_p (field_type
))
6260 error ("instance variable %qs uses flexible array member",
6261 printable_ivar_name (field_decl
));
6262 /* Return class as is without adding this ivar. */
6268 /* Check if the ivar being added has a non-POD C++ type. If so, we will
6269 need to either (1) warn the user about it or (2) generate suitable
6270 constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct'
6271 methods (if '-fobjc-call-cxx-cdtors' was specified). */
6272 if (MAYBE_CLASS_TYPE_P (field_type
)
6273 && (TYPE_NEEDS_CONSTRUCTING (field_type
)
6274 || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
)
6275 || TYPE_POLYMORPHIC_P (field_type
)))
6277 tree type_name
= OBJC_TYPE_NAME (field_type
);
6279 if (flag_objc_call_cxx_cdtors
)
6281 /* Since the ObjC runtime will be calling the constructors and
6282 destructors for us, the only thing we can't handle is the lack
6283 of a default constructor. */
6284 if (TYPE_NEEDS_CONSTRUCTING (field_type
)
6285 && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type
))
6287 warning (0, "type %qE has no default constructor to call",
6290 /* If we cannot call a constructor, we should also avoid
6291 calling the destructor, for symmetry. */
6292 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6293 warning (0, "destructor for %qE shall not be run either",
6299 static bool warn_cxx_ivars
= false;
6301 if (TYPE_POLYMORPHIC_P (field_type
))
6303 /* Vtable pointers are Real Bad(tm), since Obj-C cannot
6305 error ("type %qE has virtual member functions", type_name
);
6306 error ("illegal aggregate type %qE specified "
6307 "for instance variable %qs",
6308 type_name
, printable_ivar_name (field_decl
));
6309 /* Return class as is without adding this ivar. */
6313 /* User-defined constructors and destructors are not known to Obj-C
6314 and hence will not be called. This may or may not be a problem. */
6315 if (TYPE_NEEDS_CONSTRUCTING (field_type
))
6316 warning (0, "type %qE has a user-defined constructor", type_name
);
6317 if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type
))
6318 warning (0, "type %qE has a user-defined destructor", type_name
);
6320 if (!warn_cxx_ivars
)
6322 warning (0, "C++ constructors and destructors will not "
6323 "be invoked for Objective-C fields");
6324 warn_cxx_ivars
= true;
6330 /* Overload the public attribute, it is not used for FIELD_DECLs. */
6333 case OBJC_IVAR_VIS_PROTECTED
:
6334 TREE_PUBLIC (field_decl
) = 0;
6335 TREE_PRIVATE (field_decl
) = 0;
6336 TREE_PROTECTED (field_decl
) = 1;
6339 case OBJC_IVAR_VIS_PACKAGE
:
6340 /* TODO: Implement the package variant. */
6341 case OBJC_IVAR_VIS_PUBLIC
:
6342 TREE_PUBLIC (field_decl
) = 1;
6343 TREE_PRIVATE (field_decl
) = 0;
6344 TREE_PROTECTED (field_decl
) = 0;
6347 case OBJC_IVAR_VIS_PRIVATE
:
6348 TREE_PUBLIC (field_decl
) = 0;
6349 TREE_PRIVATE (field_decl
) = 1;
6350 TREE_PROTECTED (field_decl
) = 0;
6355 CLASS_RAW_IVARS (klass
) = chainon (CLASS_RAW_IVARS (klass
), field_decl
);
6360 /* True if the ivar is private and we are not in its implementation. */
6363 is_private (tree decl
)
6365 return (TREE_PRIVATE (decl
)
6366 && ! is_ivar (CLASS_IVARS (implementation_template
),
6370 /* Searches all the instance variables of 'klass' and of its
6371 superclasses for an instance variable whose name (identifier) is
6372 'ivar_name_ident'. Return the declaration (DECL) of the instance
6373 variable, if found, or NULL_TREE, if not found. */
6375 ivar_of_class (tree klass
, tree ivar_name_ident
)
6377 /* First, look up the ivar in CLASS_RAW_IVARS. */
6378 tree decl_chain
= CLASS_RAW_IVARS (klass
);
6380 for ( ; decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
6381 if (DECL_NAME (decl_chain
) == ivar_name_ident
)
6384 /* If not found, search up the class hierarchy. */
6385 while (CLASS_SUPER_NAME (klass
))
6387 klass
= lookup_interface (CLASS_SUPER_NAME (klass
));
6389 decl_chain
= CLASS_RAW_IVARS (klass
);
6391 for ( ; decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
6392 if (DECL_NAME (decl_chain
) == ivar_name_ident
)
6399 /* We have an instance variable reference;, check to see if it is public. */
6402 objc_is_public (tree expr
, tree identifier
)
6404 tree basetype
, decl
;
6407 if (processing_template_decl
)
6411 if (TREE_TYPE (expr
) == error_mark_node
)
6414 basetype
= TYPE_MAIN_VARIANT (TREE_TYPE (expr
));
6416 if (basetype
&& TREE_CODE (basetype
) == RECORD_TYPE
)
6418 if (TYPE_HAS_OBJC_INFO (basetype
) && TYPE_OBJC_INTERFACE (basetype
))
6420 tree klass
= lookup_interface (OBJC_TYPE_NAME (basetype
));
6424 error ("cannot find interface declaration for %qE",
6425 OBJC_TYPE_NAME (basetype
));
6429 if ((decl
= ivar_of_class (klass
, identifier
)))
6431 if (TREE_PUBLIC (decl
))
6434 /* Important difference between the Stepstone translator:
6435 all instance variables should be public within the context
6436 of the implementation. */
6437 if (objc_implementation_context
6438 && ((TREE_CODE (objc_implementation_context
)
6439 == CLASS_IMPLEMENTATION_TYPE
)
6440 || (TREE_CODE (objc_implementation_context
)
6441 == CATEGORY_IMPLEMENTATION_TYPE
)))
6443 tree curtype
= TYPE_MAIN_VARIANT
6444 (CLASS_STATIC_TEMPLATE
6445 (implementation_template
));
6447 if (basetype
== curtype
6448 || DERIVED_FROM_P (basetype
, curtype
))
6450 int priv
= is_private (decl
);
6453 error ("instance variable %qE is declared private",
6460 /* The 2.95.2 compiler sometimes allowed C functions to access
6461 non-@public ivars. We will let this slide for now... */
6462 if (!objc_method_context
)
6464 warning (0, "instance variable %qE is %s; "
6465 "this will be a hard error in the future",
6467 TREE_PRIVATE (decl
) ? "@private" : "@protected");
6471 error ("instance variable %qE is declared %s",
6473 TREE_PRIVATE (decl
) ? "private" : "protected");
6482 /* Make sure all methods in CHAIN (a list of method declarations from
6483 an @interface or a @protocol) are in IMPLEMENTATION (the
6484 implementation context). This is used to check for example that
6485 all methods declared in an @interface were implemented in an
6488 Some special methods (property setters/getters) are special and if
6489 they are not found in IMPLEMENTATION, we look them up in its
6493 check_methods (tree chain
, tree implementation
, int mtype
)
6498 if (mtype
== (int)'+')
6499 list
= CLASS_CLS_METHODS (implementation
);
6501 list
= CLASS_NST_METHODS (implementation
);
6505 /* If the method is associated with a dynamic property, then it
6506 is Ok not to have the method implementation, as it will be
6507 generated dynamically at runtime. To decide if the method is
6508 associated with a @dynamic property, we search the list of
6509 @synthesize and @dynamic for this implementation, and look
6510 for any @dynamic property with the same setter or getter name
6513 for (x
= IMPL_PROPERTY_DECL (implementation
); x
; x
= TREE_CHAIN (x
))
6514 if (PROPERTY_DYNAMIC (x
)
6515 && (PROPERTY_GETTER_NAME (x
) == METHOD_SEL_NAME (chain
)
6516 || PROPERTY_SETTER_NAME (x
) == METHOD_SEL_NAME (chain
)))
6521 chain
= TREE_CHAIN (chain
); /* next method... */
6525 if (!lookup_method (list
, chain
))
6527 /* If the method is a property setter/getter, we'll still
6528 allow it to be missing if it is implemented by
6529 'interface' or any of its superclasses. */
6530 tree property
= METHOD_PROPERTY_CONTEXT (chain
);
6533 /* Note that since this is a property getter/setter, it
6534 is obviously an instance method. */
6535 tree interface
= NULL_TREE
;
6537 /* For a category, first check the main class
6539 if (TREE_CODE (implementation
) == CATEGORY_IMPLEMENTATION_TYPE
)
6541 interface
= lookup_interface (CLASS_NAME (implementation
));
6543 /* If the method is found in the main class, it's Ok. */
6544 if (lookup_method (CLASS_NST_METHODS (interface
), chain
))
6546 chain
= DECL_CHAIN (chain
);
6550 /* Else, get the superclass. */
6551 if (CLASS_SUPER_NAME (interface
))
6552 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
6554 interface
= NULL_TREE
;
6557 /* Get the superclass for classes. */
6558 if (TREE_CODE (implementation
) == CLASS_IMPLEMENTATION_TYPE
)
6560 if (CLASS_SUPER_NAME (implementation
))
6561 interface
= lookup_interface (CLASS_SUPER_NAME (implementation
));
6563 interface
= NULL_TREE
;
6566 /* Now, interface is the superclass, if any; go check it. */
6569 if (lookup_method_static (interface
, chain
, 0))
6571 chain
= DECL_CHAIN (chain
);
6575 /* Else, fall through - warn. */
6579 switch (TREE_CODE (implementation
))
6581 case CLASS_IMPLEMENTATION_TYPE
:
6582 warning (0, "incomplete implementation of class %qE",
6583 CLASS_NAME (implementation
));
6585 case CATEGORY_IMPLEMENTATION_TYPE
:
6586 warning (0, "incomplete implementation of category %qE",
6587 CLASS_SUPER_NAME (implementation
));
6595 warning (0, "method definition for %<%c%E%> not found",
6596 mtype
, METHOD_SEL_NAME (chain
));
6599 chain
= DECL_CHAIN (chain
);
6605 /* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */
6608 conforms_to_protocol (tree klass
, tree protocol
)
6610 if (TREE_CODE (protocol
) == PROTOCOL_INTERFACE_TYPE
)
6612 tree p
= CLASS_PROTOCOL_LIST (klass
);
6613 while (p
&& TREE_VALUE (p
) != protocol
)
6618 tree super
= (CLASS_SUPER_NAME (klass
)
6619 ? lookup_interface (CLASS_SUPER_NAME (klass
))
6621 int tmp
= super
? conforms_to_protocol (super
, protocol
) : 0;
6630 /* Make sure all methods in CHAIN are accessible as MTYPE methods in
6631 CONTEXT. This is one of two mechanisms to check protocol integrity. */
6634 check_methods_accessible (tree chain
, tree context
, int mtype
)
6638 tree base_context
= context
;
6642 /* If the method is associated with a dynamic property, then it
6643 is Ok not to have the method implementation, as it will be
6644 generated dynamically at runtime. Search for any @dynamic
6645 property with the same setter or getter name as this
6646 method. TODO: Use a hashtable lookup. */
6648 for (x
= IMPL_PROPERTY_DECL (base_context
); x
; x
= TREE_CHAIN (x
))
6649 if (PROPERTY_DYNAMIC (x
)
6650 && (PROPERTY_GETTER_NAME (x
) == METHOD_SEL_NAME (chain
)
6651 || PROPERTY_SETTER_NAME (x
) == METHOD_SEL_NAME (chain
)))
6656 chain
= TREE_CHAIN (chain
); /* next method... */
6660 context
= base_context
;
6664 list
= CLASS_CLS_METHODS (context
);
6666 list
= CLASS_NST_METHODS (context
);
6668 if (lookup_method (list
, chain
))
6671 switch (TREE_CODE (context
))
6673 case CLASS_IMPLEMENTATION_TYPE
:
6674 case CLASS_INTERFACE_TYPE
:
6675 context
= (CLASS_SUPER_NAME (context
)
6676 ? lookup_interface (CLASS_SUPER_NAME (context
))
6679 case CATEGORY_IMPLEMENTATION_TYPE
:
6680 case CATEGORY_INTERFACE_TYPE
:
6681 context
= (CLASS_NAME (context
)
6682 ? lookup_interface (CLASS_NAME (context
))
6690 if (context
== NULL_TREE
)
6694 switch (TREE_CODE (objc_implementation_context
))
6696 case CLASS_IMPLEMENTATION_TYPE
:
6697 warning (0, "incomplete implementation of class %qE",
6698 CLASS_NAME (objc_implementation_context
));
6700 case CATEGORY_IMPLEMENTATION_TYPE
:
6701 warning (0, "incomplete implementation of category %qE",
6702 CLASS_SUPER_NAME (objc_implementation_context
));
6709 warning (0, "method definition for %<%c%E%> not found",
6710 mtype
, METHOD_SEL_NAME (chain
));
6713 chain
= TREE_CHAIN (chain
); /* next method... */
6718 /* Check whether the current interface (accessible via
6719 'objc_implementation_context') actually implements protocol P, along
6720 with any protocols that P inherits. */
6723 check_protocol (tree p
, const char *type
, tree name
)
6725 if (TREE_CODE (p
) == PROTOCOL_INTERFACE_TYPE
)
6729 /* Ensure that all protocols have bodies! */
6732 f1
= check_methods (PROTOCOL_CLS_METHODS (p
),
6733 objc_implementation_context
,
6735 f2
= check_methods (PROTOCOL_NST_METHODS (p
),
6736 objc_implementation_context
,
6741 f1
= check_methods_accessible (PROTOCOL_CLS_METHODS (p
),
6742 objc_implementation_context
,
6744 f2
= check_methods_accessible (PROTOCOL_NST_METHODS (p
),
6745 objc_implementation_context
,
6750 warning (0, "%s %qE does not fully implement the %qE protocol",
6751 type
, name
, PROTOCOL_NAME (p
));
6754 /* Check protocols recursively. */
6755 if (PROTOCOL_LIST (p
))
6757 tree subs
= PROTOCOL_LIST (p
);
6759 lookup_interface (CLASS_SUPER_NAME (implementation_template
));
6763 tree sub
= TREE_VALUE (subs
);
6765 /* If the superclass does not conform to the protocols
6766 inherited by P, then we must! */
6767 if (!super_class
|| !conforms_to_protocol (super_class
, sub
))
6768 check_protocol (sub
, type
, name
);
6769 subs
= TREE_CHAIN (subs
);
6774 /* Check whether the current interface (accessible via
6775 'objc_implementation_context') actually implements the protocols listed
6779 check_protocols (tree proto_list
, const char *type
, tree name
)
6781 for ( ; proto_list
; proto_list
= TREE_CHAIN (proto_list
))
6783 tree p
= TREE_VALUE (proto_list
);
6785 check_protocol (p
, type
, name
);
6789 /* Make sure that the class CLASS_NAME is defined CODE says which kind
6790 of thing CLASS_NAME ought to be. It can be CLASS_INTERFACE_TYPE,
6791 CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or
6792 CATEGORY_IMPLEMENTATION_TYPE. For a CATEGORY_INTERFACE_TYPE,
6793 SUPER_NAME is the name of the category. For a class extension,
6794 CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE. */
6796 start_class (enum tree_code code
, tree class_name
, tree super_name
,
6797 tree protocol_list
, tree attributes
)
6799 tree klass
= NULL_TREE
;
6803 if (current_namespace
!= global_namespace
)
6805 error ("Objective-C declarations may only appear in global scope");
6807 #endif /* OBJCPLUS */
6809 if (objc_implementation_context
)
6811 warning (0, "%<@end%> missing in implementation context");
6812 finish_class (objc_implementation_context
);
6813 objc_ivar_chain
= NULL_TREE
;
6814 objc_implementation_context
= NULL_TREE
;
6817 /* If this is a class extension, we'll be "reopening" the existing
6818 CLASS_INTERFACE_TYPE, so in that case there is no need to create
6820 if (code
!= CATEGORY_INTERFACE_TYPE
|| super_name
!= NULL_TREE
)
6822 klass
= make_node (code
);
6823 TYPE_LANG_SLOT_1 (klass
) = make_tree_vec (CLASS_LANG_SLOT_ELTS
);
6826 /* Check for existence of the super class, if one was specified. Note
6827 that we must have seen an @interface, not just a @class. If we
6828 are looking at a @compatibility_alias, traverse it first. */
6829 if ((code
== CLASS_INTERFACE_TYPE
|| code
== CLASS_IMPLEMENTATION_TYPE
)
6832 tree super
= objc_is_class_name (super_name
);
6833 tree super_interface
= NULL_TREE
;
6836 super_interface
= lookup_interface (super
);
6838 if (!super_interface
)
6840 error ("cannot find interface declaration for %qE, superclass of %qE",
6841 super
? super
: super_name
,
6843 super_name
= NULL_TREE
;
6847 if (TREE_DEPRECATED (super_interface
))
6848 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated",
6854 if (code
!= CATEGORY_INTERFACE_TYPE
|| super_name
!= NULL_TREE
)
6856 CLASS_NAME (klass
) = class_name
;
6857 CLASS_SUPER_NAME (klass
) = super_name
;
6858 CLASS_CLS_METHODS (klass
) = NULL_TREE
;
6861 if (! objc_is_class_name (class_name
)
6862 && (decl
= lookup_name (class_name
)))
6864 error ("%qE redeclared as different kind of symbol",
6866 error ("previous declaration of %q+D",
6872 case CLASS_IMPLEMENTATION_TYPE
:
6876 for (chain
= implemented_classes
; chain
; chain
= TREE_CHAIN (chain
))
6877 if (TREE_VALUE (chain
) == class_name
)
6879 error ("reimplementation of class %qE",
6881 /* TODO: error message saying where it was previously
6885 if (chain
== NULL_TREE
)
6886 implemented_classes
= tree_cons (NULL_TREE
, class_name
,
6887 implemented_classes
);
6890 /* Reset for multiple classes per file. */
6893 objc_implementation_context
= klass
;
6895 /* Lookup the interface for this implementation. */
6897 if (!(implementation_template
= lookup_interface (class_name
)))
6899 warning (0, "cannot find interface declaration for %qE",
6901 add_class (implementation_template
= objc_implementation_context
,
6905 /* If a super class has been specified in the implementation,
6906 insure it conforms to the one specified in the interface. */
6909 && (super_name
!= CLASS_SUPER_NAME (implementation_template
)))
6911 tree previous_name
= CLASS_SUPER_NAME (implementation_template
);
6912 error ("conflicting super class name %qE",
6915 error ("previous declaration of %qE", previous_name
);
6917 error ("previous declaration");
6920 else if (! super_name
)
6922 CLASS_SUPER_NAME (objc_implementation_context
)
6923 = CLASS_SUPER_NAME (implementation_template
);
6927 case CLASS_INTERFACE_TYPE
:
6928 if (lookup_interface (class_name
))
6930 error ("duplicate interface declaration for class %qE", class_name
);
6932 warning (0, "duplicate interface declaration for class %qE", class_name
);
6935 add_class (klass
, class_name
);
6938 CLASS_PROTOCOL_LIST (klass
)
6939 = lookup_and_install_protocols (protocol_list
, /* definition_required */ true);
6944 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
6946 tree name
= TREE_PURPOSE (attribute
);
6948 /* TODO: Document what the objc_exception attribute is/does. */
6949 /* We handle the 'deprecated' and (undocumented) 'objc_exception'
6951 if (is_attribute_p ("deprecated", name
))
6952 TREE_DEPRECATED (klass
) = 1;
6953 else if (is_attribute_p ("objc_exception", name
))
6954 CLASS_HAS_EXCEPTION_ATTR (klass
) = 1;
6956 /* Warn about and ignore all others for now, but store them. */
6957 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
6959 TYPE_ATTRIBUTES (klass
) = attributes
;
6963 case CATEGORY_INTERFACE_TYPE
:
6965 tree class_category_is_assoc_with
;
6967 /* For a category, class_name is really the name of the class that
6968 the following set of methods will be associated with. We must
6969 find the interface so that can derive the objects template. */
6970 if (!(class_category_is_assoc_with
= lookup_interface (class_name
)))
6972 error ("cannot find interface declaration for %qE",
6974 exit (FATAL_EXIT_CODE
);
6978 if (TREE_DEPRECATED (class_category_is_assoc_with
))
6979 warning (OPT_Wdeprecated_declarations
, "class %qE is deprecated",
6982 if (super_name
== NULL_TREE
)
6984 /* This is a class extension. Get the original
6985 interface, and continue working on it. */
6986 objc_in_class_extension
= true;
6987 klass
= class_category_is_assoc_with
;
6991 /* Append protocols to the original protocol
6993 CLASS_PROTOCOL_LIST (klass
)
6994 = chainon (CLASS_PROTOCOL_LIST (klass
),
6995 lookup_and_install_protocols
6997 /* definition_required */ true));
7002 add_category (class_category_is_assoc_with
, klass
);
7005 CLASS_PROTOCOL_LIST (klass
)
7006 = lookup_and_install_protocols
7007 (protocol_list
, /* definition_required */ true);
7013 case CATEGORY_IMPLEMENTATION_TYPE
:
7014 /* Reset for multiple classes per file. */
7017 objc_implementation_context
= klass
;
7019 /* For a category, class_name is really the name of the class that
7020 the following set of methods will be associated with. We must
7021 find the interface so that can derive the objects template. */
7023 if (!(implementation_template
= lookup_interface (class_name
)))
7025 error ("cannot find interface declaration for %qE",
7027 exit (FATAL_EXIT_CODE
);
7037 continue_class (tree klass
)
7039 switch (TREE_CODE (klass
))
7041 case CLASS_IMPLEMENTATION_TYPE
:
7042 case CATEGORY_IMPLEMENTATION_TYPE
:
7044 struct imp_entry
*imp_entry
;
7046 /* Check consistency of the instance variables. */
7048 if (CLASS_RAW_IVARS (klass
))
7049 check_ivars (implementation_template
, klass
);
7051 /* code generation */
7053 push_lang_context (lang_name_c
);
7055 build_private_template (implementation_template
);
7056 uprivate_record
= CLASS_STATIC_TEMPLATE (implementation_template
);
7057 objc_instance_type
= build_pointer_type (uprivate_record
);
7059 imp_entry
= ggc_alloc_imp_entry ();
7061 imp_entry
->next
= imp_list
;
7062 imp_entry
->imp_context
= klass
;
7063 imp_entry
->imp_template
= implementation_template
;
7064 ucls_super_ref
= uucls_super_ref
= NULL
;
7065 if (TREE_CODE (klass
) == CLASS_IMPLEMENTATION_TYPE
)
7067 imp_entry
->class_decl
= (*runtime
.class_decl
) (klass
);
7068 imp_entry
->meta_decl
= (*runtime
.metaclass_decl
) (klass
);
7072 imp_entry
->class_decl
= (*runtime
.category_decl
) (klass
);
7073 imp_entry
->meta_decl
= NULL
;
7075 imp_entry
->has_cxx_cdtors
= 0;
7077 /* Append to front and increment count. */
7078 imp_list
= imp_entry
;
7079 if (TREE_CODE (klass
) == CLASS_IMPLEMENTATION_TYPE
)
7084 pop_lang_context ();
7085 #endif /* OBJCPLUS */
7087 return get_class_ivars (implementation_template
, true);
7090 case CLASS_INTERFACE_TYPE
:
7092 if (objc_in_class_extension
)
7095 push_lang_context (lang_name_c
);
7096 #endif /* OBJCPLUS */
7097 objc_collecting_ivars
= 1;
7098 build_private_template (klass
);
7099 objc_collecting_ivars
= 0;
7101 pop_lang_context ();
7102 #endif /* OBJCPLUS */
7107 return error_mark_node
;
7111 /* This routine builds name of the setter synthesized function. */
7113 objc_build_property_setter_name (tree ident
)
7115 /* TODO: Use alloca to allocate buffer of appropriate size. */
7116 static char string
[BUFSIZE
];
7117 sprintf (string
, "set%s:", IDENTIFIER_POINTER (ident
));
7118 string
[3] = TOUPPER (string
[3]);
7122 /* This routine prepares the declarations of the property accessor
7123 helper functions (objc_getProperty(), etc) that are used when
7124 @synthesize is used.
7126 runtime-specific routines are built in the respective runtime
7127 initialize functions. */
7129 build_common_objc_property_accessor_helpers (void)
7133 /* Declare the following function:
7135 objc_getProperty (id self, SEL _cmd,
7136 ptrdiff_t offset, BOOL is_atomic); */
7137 type
= build_function_type_list (objc_object_type
,
7143 objc_getProperty_decl
= add_builtin_function ("objc_getProperty",
7144 type
, 0, NOT_BUILT_IN
,
7146 TREE_NOTHROW (objc_getProperty_decl
) = 0;
7148 /* Declare the following function:
7150 objc_setProperty (id self, SEL _cmd,
7151 ptrdiff_t offset, id new_value,
7152 BOOL is_atomic, BOOL should_copy); */
7153 type
= build_function_type_list (void_type_node
,
7161 objc_setProperty_decl
= add_builtin_function ("objc_setProperty",
7162 type
, 0, NOT_BUILT_IN
,
7164 TREE_NOTHROW (objc_setProperty_decl
) = 0;
7167 /* This looks up an ivar in a class (including superclasses). */
7169 lookup_ivar (tree interface
, tree instance_variable_name
)
7175 for (decl_chain
= CLASS_IVARS (interface
); decl_chain
; decl_chain
= DECL_CHAIN (decl_chain
))
7176 if (DECL_NAME (decl_chain
) == instance_variable_name
)
7179 /* Not found. Search superclass if any. */
7180 if (CLASS_SUPER_NAME (interface
))
7181 interface
= lookup_interface (CLASS_SUPER_NAME (interface
));
7187 /* This routine synthesizes a 'getter' method. This is only called
7188 for @synthesize properties. */
7190 objc_synthesize_getter (tree klass
, tree class_methods ATTRIBUTE_UNUSED
, tree property
)
7192 location_t location
= DECL_SOURCE_LOCATION (property
);
7197 /* If user has implemented a getter with same name then do nothing. */
7198 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context
),
7199 PROPERTY_GETTER_NAME (property
)))
7202 /* Find declaration of the property getter in the interface (or
7203 superclass, or protocol). There must be one. */
7204 decl
= lookup_method_static (klass
, PROPERTY_GETTER_NAME (property
), 0);
7206 /* If one not declared in the interface, this condition has already
7207 been reported as user error (because property was not declared in
7212 /* Adapt the 'decl'. Use the source location of the @synthesize
7213 statement for error messages. */
7214 decl
= copy_node (decl
);
7215 DECL_SOURCE_LOCATION (decl
) = location
;
7217 objc_start_method_definition (false /* is_class_method */, decl
, NULL_TREE
);
7218 body
= c_begin_compound_stmt (true);
7220 /* Now we need to decide how we build the getter. There are three
7223 for 'copy' or 'retain' properties we need to use the
7224 objc_getProperty() accessor helper which knows about retain and
7225 copy. It supports both 'nonatomic' and 'atomic' access.
7227 for 'nonatomic, assign' properties we can access the instance
7228 variable directly. 'nonatomic' means we don't have to use locks,
7229 and 'assign' means we don't have to worry about retain or copy.
7230 If you combine the two, it means we can just access the instance
7233 for 'atomic, assign' properties we use objc_copyStruct() (for the
7234 next runtime) or objc_getPropertyStruct() (for the GNU runtime). */
7235 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
7237 case OBJC_PROPERTY_RETAIN
:
7238 case OBJC_PROPERTY_COPY
:
7240 /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);" */
7241 tree cmd
, ivar
, offset
, is_atomic
;
7242 cmd
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
7244 /* Find the ivar to compute the offset. */
7245 ivar
= lookup_ivar (klass
, PROPERTY_IVAR_NAME (property
));
7246 if (!ivar
|| is_private (ivar
))
7248 /* This should never happen. */
7250 "can not find instance variable associated with property");
7251 ret_val
= error_mark_node
;
7254 offset
= byte_position (ivar
);
7256 if (PROPERTY_NONATOMIC (property
))
7257 is_atomic
= boolean_false_node
;
7259 is_atomic
= boolean_true_node
;
7261 ret_val
= build_function_call
7263 /* Function prototype. */
7264 objc_getProperty_decl
,
7266 tree_cons
/* self */
7267 (NULL_TREE
, self_decl
,
7268 tree_cons
/* _cmd */
7270 tree_cons
/* offset */
7272 tree_cons
/* is_atomic */
7273 (NULL_TREE
, is_atomic
, NULL_TREE
)))));
7276 case OBJC_PROPERTY_ASSIGN
:
7277 if (PROPERTY_NONATOMIC (property
))
7279 /* We build "return self->PROPERTY_IVAR_NAME;" */
7280 ret_val
= objc_lookup_ivar (NULL_TREE
, PROPERTY_IVAR_NAME (property
));
7286 <property type> __objc_property_temp;
7287 objc_getPropertyStruct (&__objc_property_temp,
7288 &(self->PROPERTY_IVAR_NAME),
7289 sizeof (type of self->PROPERTY_IVAR_NAME),
7292 return __objc_property_temp;
7294 For the NeXT runtime, we need to use objc_copyStruct
7295 instead of objc_getPropertyStruct. */
7296 tree objc_property_temp_decl
, function_decl
, function_call
;
7297 tree size_of
, is_atomic
;
7299 objc_property_temp_decl
= objc_create_temporary_var (TREE_TYPE (property
), "__objc_property_temp");
7300 DECL_SOURCE_LOCATION (objc_property_temp_decl
) = location
;
7301 objc_property_temp_decl
= lang_hooks
.decls
.pushdecl (objc_property_temp_decl
);
7303 /* sizeof (ivar type). Since the ivar and the property have
7304 the same type, there is no need to lookup the ivar. */
7305 size_of
= c_sizeof_or_alignof_type (location
, TREE_TYPE (property
),
7306 true /* is_sizeof */,
7307 false /* complain */);
7309 if (PROPERTY_NONATOMIC (property
))
7310 is_atomic
= boolean_false_node
;
7312 is_atomic
= boolean_true_node
;
7314 if (objc_copyStruct_decl
)
7315 function_decl
= objc_copyStruct_decl
;
7317 function_decl
= objc_getPropertyStruct_decl
;
7319 function_call
= build_function_call
7321 /* Function prototype. */
7324 tree_cons
/* &__objc_property_temp_decl */
7325 /* Warning: note that using build_fold_addr_expr_loc()
7326 here causes invalid code to be generated. */
7327 (NULL_TREE
, build_unary_op (location
, ADDR_EXPR
, objc_property_temp_decl
, 0),
7328 tree_cons
/* &(self->PROPERTY_IVAR_NAME); */
7329 (NULL_TREE
, build_fold_addr_expr_loc (location
,
7331 (NULL_TREE
, PROPERTY_IVAR_NAME (property
))),
7332 tree_cons
/* sizeof (PROPERTY_IVAR) */
7333 (NULL_TREE
, size_of
,
7334 tree_cons
/* is_atomic */
7335 (NULL_TREE
, is_atomic
,
7336 /* TODO: This is currently ignored by the GNU
7337 runtime, but what about the next one ? */
7338 tree_cons
/* has_strong */
7339 (NULL_TREE
, boolean_true_node
, NULL_TREE
))))));
7341 add_stmt (function_call
);
7343 ret_val
= objc_property_temp_decl
;
7350 gcc_assert (ret_val
);
7353 finish_return_stmt (ret_val
);
7355 c_finish_return (location
, ret_val
, NULL_TREE
);
7358 add_stmt (c_end_compound_stmt (location
, body
, true));
7359 fn
= current_function_decl
;
7363 objc_finish_method_definition (fn
);
7366 /* This routine synthesizes a 'setter' method. */
7369 objc_synthesize_setter (tree klass
, tree class_methods ATTRIBUTE_UNUSED
, tree property
)
7371 location_t location
= DECL_SOURCE_LOCATION (property
);
7374 tree new_value
, statement
;
7376 /* If user has implemented a setter with same name then do nothing. */
7377 if (lookup_method (CLASS_NST_METHODS (objc_implementation_context
),
7378 PROPERTY_SETTER_NAME (property
)))
7381 /* Find declaration of the property setter in the interface (or
7382 superclass, or protocol). There must be one. */
7383 decl
= lookup_method_static (klass
, PROPERTY_SETTER_NAME (property
), 0);
7385 /* If one not declared in the interface, this condition has already
7386 been reported as user error (because property was not declared in
7391 /* Adapt the 'decl'. Use the source location of the @synthesize
7392 statement for error messages. */
7393 decl
= copy_node (decl
);
7394 DECL_SOURCE_LOCATION (decl
) = DECL_SOURCE_LOCATION (property
);
7396 objc_start_method_definition (false /* is_class_method */, decl
, NULL_TREE
);
7398 body
= c_begin_compound_stmt (true);
7400 /* The 'new_value' is the only argument to the method, which is the
7401 3rd argument of the function, after self and _cmd. We use twice
7402 TREE_CHAIN to move forward two arguments. */
7403 new_value
= TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
)));
7405 /* This would presumably happen if the user has specified a
7406 prototype for the setter that does not have an argument! */
7407 if (new_value
== NULL_TREE
)
7409 /* TODO: This should be caught much earlier than this. */
7410 error_at (DECL_SOURCE_LOCATION (decl
), "invalid setter, it must have one argument");
7411 /* Try to recover somehow. */
7412 new_value
= error_mark_node
;
7415 /* Now we need to decide how we build the setter. There are three
7418 for 'copy' or 'retain' properties we need to use the
7419 objc_setProperty() accessor helper which knows about retain and
7420 copy. It supports both 'nonatomic' and 'atomic' access.
7422 for 'nonatomic, assign' properties we can access the instance
7423 variable directly. 'nonatomic' means we don't have to use locks,
7424 and 'assign' means we don't have to worry about retain or copy.
7425 If you combine the two, it means we can just access the instance
7428 for 'atomic, assign' properties we use objc_copyStruct() (for the
7429 next runtime) or objc_setPropertyStruct() (for the GNU runtime). */
7430 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
7432 case OBJC_PROPERTY_RETAIN
:
7433 case OBJC_PROPERTY_COPY
:
7435 /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);" */
7436 tree cmd
, ivar
, offset
, is_atomic
, should_copy
;
7437 cmd
= TREE_CHAIN (DECL_ARGUMENTS (current_function_decl
));
7439 /* Find the ivar to compute the offset. */
7440 ivar
= lookup_ivar (klass
, PROPERTY_IVAR_NAME (property
));
7441 if (!ivar
|| is_private (ivar
))
7444 "can not find instance variable associated with property");
7445 statement
= error_mark_node
;
7448 offset
= byte_position (ivar
);
7450 if (PROPERTY_NONATOMIC (property
))
7451 is_atomic
= boolean_false_node
;
7453 is_atomic
= boolean_true_node
;
7455 if (PROPERTY_ASSIGN_SEMANTICS (property
) == OBJC_PROPERTY_COPY
)
7456 should_copy
= boolean_true_node
;
7458 should_copy
= boolean_false_node
;
7460 statement
= build_function_call
7462 /* Function prototype. */
7463 objc_setProperty_decl
,
7465 tree_cons
/* self */
7466 (NULL_TREE
, self_decl
,
7467 tree_cons
/* _cmd */
7469 tree_cons
/* offset */
7471 tree_cons
/* new_value */
7472 (NULL_TREE
, new_value
,
7473 tree_cons
/* is_atomic */
7474 (NULL_TREE
, is_atomic
,
7475 tree_cons
/* should_copy */
7476 (NULL_TREE
, should_copy
, NULL_TREE
)))))));
7479 case OBJC_PROPERTY_ASSIGN
:
7480 if (PROPERTY_NONATOMIC (property
))
7482 /* We build "self->PROPERTY_IVAR_NAME = new_value;" */
7483 statement
= build_modify_expr
7485 objc_lookup_ivar (NULL_TREE
, PROPERTY_IVAR_NAME (property
)),
7486 NULL_TREE
, NOP_EXPR
,
7487 location
, new_value
, NULL_TREE
);
7493 objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME),
7495 sizeof (type of self->PROPERTY_IVAR_NAME),
7499 For the NeXT runtime, we need to use objc_copyStruct
7500 instead of objc_getPropertyStruct. */
7501 tree function_decl
, size_of
, is_atomic
;
7503 /* sizeof (ivar type). Since the ivar and the property have
7504 the same type, there is no need to lookup the ivar. */
7505 size_of
= c_sizeof_or_alignof_type (location
, TREE_TYPE (property
),
7506 true /* is_sizeof */,
7507 false /* complain */);
7509 if (PROPERTY_NONATOMIC (property
))
7510 is_atomic
= boolean_false_node
;
7512 is_atomic
= boolean_true_node
;
7514 if (objc_copyStruct_decl
)
7515 function_decl
= objc_copyStruct_decl
;
7517 function_decl
= objc_setPropertyStruct_decl
;
7519 statement
= build_function_call
7521 /* Function prototype. */
7524 tree_cons
/* &(self->PROPERTY_IVAR_NAME); */
7525 (NULL_TREE
, build_fold_addr_expr_loc (location
,
7527 (NULL_TREE
, PROPERTY_IVAR_NAME (property
))),
7528 tree_cons
/* &new_value */
7529 (NULL_TREE
, build_fold_addr_expr_loc (location
, new_value
),
7530 tree_cons
/* sizeof (PROPERTY_IVAR) */
7531 (NULL_TREE
, size_of
,
7532 tree_cons
/* is_atomic */
7533 (NULL_TREE
, is_atomic
,
7534 /* TODO: This is currently ignored by the GNU
7535 runtime, but what about the next one ? */
7536 tree_cons
/* has_strong */
7537 (NULL_TREE
, boolean_true_node
, NULL_TREE
))))));
7543 gcc_assert (statement
);
7545 add_stmt (statement
);
7546 add_stmt (c_end_compound_stmt (location
, body
, true));
7547 fn
= current_function_decl
;
7551 objc_finish_method_definition (fn
);
7554 /* This function is a sub-routine of objc_add_synthesize_declaration.
7555 It is called for each property to synthesize once we have
7556 determined that the context is Ok. */
7558 objc_add_synthesize_declaration_for_property (location_t location
, tree interface
,
7559 tree property_name
, tree ivar_name
)
7561 /* Find the @property declaration. */
7565 /* Check that synthesize or dynamic has not already been used for
7566 the same property. */
7567 for (property
= IMPL_PROPERTY_DECL (objc_implementation_context
); property
; property
= TREE_CHAIN (property
))
7568 if (PROPERTY_NAME (property
) == property_name
)
7570 location_t original_location
= DECL_SOURCE_LOCATION (property
);
7572 if (PROPERTY_DYNAMIC (property
))
7573 error_at (location
, "property %qs already specified in %<@dynamic%>",
7574 IDENTIFIER_POINTER (property_name
));
7576 error_at (location
, "property %qs already specified in %<@synthesize%>",
7577 IDENTIFIER_POINTER (property_name
));
7579 if (original_location
!= UNKNOWN_LOCATION
)
7580 inform (original_location
, "originally specified here");
7584 /* Check that the property is declared in the interface. It could
7585 also be declared in a superclass or protocol. */
7586 property
= lookup_property (interface
, property_name
);
7590 error_at (location
, "no declaration of property %qs found in the interface",
7591 IDENTIFIER_POINTER (property_name
));
7596 /* We have to copy the property, because we want to chain it to
7597 the implementation context, and we want to store the source
7598 location of the @synthesize, not of the original
7600 property
= copy_node (property
);
7601 DECL_SOURCE_LOCATION (property
) = location
;
7604 /* Determine PROPERTY_IVAR_NAME. */
7605 if (ivar_name
== NULL_TREE
)
7606 ivar_name
= property_name
;
7608 /* Check that the instance variable exists. You can only use an
7609 instance variable from the same class, not one from the
7610 superclass (this makes sense as it allows us to check that an
7611 instance variable is only used in one synthesized property). */
7613 tree ivar
= is_ivar (CLASS_IVARS (interface
), ivar_name
);
7617 error_at (location
, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar",
7618 IDENTIFIER_POINTER (property_name
));
7622 if (DECL_BIT_FIELD_TYPE (ivar
))
7623 type_of_ivar
= DECL_BIT_FIELD_TYPE (ivar
);
7625 type_of_ivar
= TREE_TYPE (ivar
);
7627 /* If the instance variable has a different C type, we throw an error ... */
7628 if (!comptypes (TREE_TYPE (property
), type_of_ivar
)
7629 /* ... unless the property is readonly, in which case we allow
7630 the instance variable to be more specialized (this means we
7631 can generate the getter all right and it works). */
7632 && (!PROPERTY_READONLY (property
)
7633 || !objc_compare_types (TREE_TYPE (property
),
7634 type_of_ivar
, -5, NULL_TREE
)))
7636 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7638 error_at (location
, "property %qs is using instance variable %qs of incompatible type",
7639 IDENTIFIER_POINTER (property_name
),
7640 IDENTIFIER_POINTER (ivar_name
));
7642 if (original_location
!= UNKNOWN_LOCATION
)
7643 inform (original_location
, "originally specified here");
7646 /* If the instance variable is a bitfield, the property must be
7647 'assign', 'nonatomic' because the runtime getter/setter helper
7648 do not work with bitfield instance variables. */
7649 if (DECL_BIT_FIELD_TYPE (ivar
))
7651 /* If there is an error, we return and not generate any
7652 getter/setter because trying to set up the runtime
7653 getter/setter helper calls with bitfields is at high risk
7656 if (PROPERTY_ASSIGN_SEMANTICS (property
) != OBJC_PROPERTY_ASSIGN
)
7658 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7660 error_at (location
, "'assign' property %qs is using bit-field instance variable %qs",
7661 IDENTIFIER_POINTER (property_name
),
7662 IDENTIFIER_POINTER (ivar_name
));
7664 if (original_location
!= UNKNOWN_LOCATION
)
7665 inform (original_location
, "originally specified here");
7669 if (!PROPERTY_NONATOMIC (property
))
7671 location_t original_location
= DECL_SOURCE_LOCATION (ivar
);
7673 error_at (location
, "'atomic' property %qs is using bit-field instance variable %qs",
7674 IDENTIFIER_POINTER (property_name
),
7675 IDENTIFIER_POINTER (ivar_name
));
7677 if (original_location
!= UNKNOWN_LOCATION
)
7678 inform (original_location
, "originally specified here");
7684 /* Check that no other property is using the same instance
7686 for (x
= IMPL_PROPERTY_DECL (objc_implementation_context
); x
; x
= TREE_CHAIN (x
))
7687 if (PROPERTY_IVAR_NAME (x
) == ivar_name
)
7689 location_t original_location
= DECL_SOURCE_LOCATION (x
);
7691 error_at (location
, "property %qs is using the same instance variable as property %qs",
7692 IDENTIFIER_POINTER (property_name
),
7693 IDENTIFIER_POINTER (PROPERTY_NAME (x
)));
7695 if (original_location
!= UNKNOWN_LOCATION
)
7696 inform (original_location
, "originally specified here");
7698 /* We keep going on. This won't cause the compiler to fail;
7699 the failure would most likely be at runtime. */
7702 /* Note that a @synthesize (and only a @synthesize) always sets
7703 PROPERTY_IVAR_NAME to a non-NULL_TREE. You can recognize a
7704 @synthesize by that. */
7705 PROPERTY_IVAR_NAME (property
) = ivar_name
;
7707 /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the
7708 original declaration; they are always set (with the exception of
7709 PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1). */
7711 /* Add the property to the list of properties for current implementation. */
7712 TREE_CHAIN (property
) = IMPL_PROPERTY_DECL (objc_implementation_context
);
7713 IMPL_PROPERTY_DECL (objc_implementation_context
) = property
;
7715 /* Note how we don't actually synthesize the getter/setter here; it
7716 would be very natural, but we may miss the fact that the user has
7717 implemented his own getter/setter later on in the @implementation
7718 (in which case we shouldn't generate getter/setter). We wait
7719 until we have parsed it all before generating the code. */
7722 /* This function is called by the parser after a @synthesize
7723 expression is parsed. 'location' is the location of the
7724 @synthesize expression, and 'property_and_ivar_list' is a chained
7725 list of the property and ivar names. */
7727 objc_add_synthesize_declaration (location_t location
, tree property_and_ivar_list
)
7729 tree interface
, chain
;
7731 if (flag_objc1_only
)
7732 error_at (input_location
, "%<@synthesize%> is not available in Objective-C 1.0");
7734 if (property_and_ivar_list
== error_mark_node
)
7737 if (!objc_implementation_context
)
7739 /* We can get here only in Objective-C; the Objective-C++ parser
7740 detects the problem while parsing, outputs the error
7741 "misplaced '@synthesize' Objective-C++ construct" and skips
7743 error_at (location
, "%<@synthesize%> not in @implementation context");
7747 if (TREE_CODE (objc_implementation_context
) == CATEGORY_IMPLEMENTATION_TYPE
)
7749 error_at (location
, "%<@synthesize%> can not be used in categories");
7753 interface
= lookup_interface (CLASS_NAME (objc_implementation_context
));
7756 /* I can't see how this could happen, but it is good as a safety check. */
7758 "%<@synthesize%> requires the @interface of the class to be available");
7762 /* Now, iterate over the properties and do each of them. */
7763 for (chain
= property_and_ivar_list
; chain
; chain
= TREE_CHAIN (chain
))
7765 objc_add_synthesize_declaration_for_property (location
, interface
, TREE_VALUE (chain
),
7766 TREE_PURPOSE (chain
));
7770 /* This function is a sub-routine of objc_add_dynamic_declaration. It
7771 is called for each property to mark as dynamic once we have
7772 determined that the context is Ok. */
7774 objc_add_dynamic_declaration_for_property (location_t location
, tree interface
,
7777 /* Find the @property declaration. */
7780 /* Check that synthesize or dynamic has not already been used for
7781 the same property. */
7782 for (property
= IMPL_PROPERTY_DECL (objc_implementation_context
); property
; property
= TREE_CHAIN (property
))
7783 if (PROPERTY_NAME (property
) == property_name
)
7785 location_t original_location
= DECL_SOURCE_LOCATION (property
);
7787 if (PROPERTY_DYNAMIC (property
))
7788 error_at (location
, "property %qs already specified in %<@dynamic%>",
7789 IDENTIFIER_POINTER (property_name
));
7791 error_at (location
, "property %qs already specified in %<@synthesize%>",
7792 IDENTIFIER_POINTER (property_name
));
7794 if (original_location
!= UNKNOWN_LOCATION
)
7795 inform (original_location
, "originally specified here");
7799 /* Check that the property is declared in the interface. It could
7800 also be declared in a superclass or protocol. */
7801 property
= lookup_property (interface
, property_name
);
7805 error_at (location
, "no declaration of property %qs found in the interface",
7806 IDENTIFIER_POINTER (property_name
));
7811 /* We have to copy the property, because we want to chain it to
7812 the implementation context, and we want to store the source
7813 location of the @synthesize, not of the original
7815 property
= copy_node (property
);
7816 DECL_SOURCE_LOCATION (property
) = location
;
7819 /* Note that a @dynamic (and only a @dynamic) always sets
7820 PROPERTY_DYNAMIC to 1. You can recognize a @dynamic by that.
7821 (actually, as explained above, PROPERTY_DECL generated by
7822 @property and associated with a @dynamic property are also marked
7823 as PROPERTY_DYNAMIC). */
7824 PROPERTY_DYNAMIC (property
) = 1;
7826 /* Add the property to the list of properties for current implementation. */
7827 TREE_CHAIN (property
) = IMPL_PROPERTY_DECL (objc_implementation_context
);
7828 IMPL_PROPERTY_DECL (objc_implementation_context
) = property
;
7831 /* This function is called by the parser after a @dynamic expression
7832 is parsed. 'location' is the location of the @dynamic expression,
7833 and 'property_list' is a chained list of all the property
7836 objc_add_dynamic_declaration (location_t location
, tree property_list
)
7838 tree interface
, chain
;
7840 if (flag_objc1_only
)
7841 error_at (input_location
, "%<@dynamic%> is not available in Objective-C 1.0");
7843 if (property_list
== error_mark_node
)
7846 if (!objc_implementation_context
)
7848 /* We can get here only in Objective-C; the Objective-C++ parser
7849 detects the problem while parsing, outputs the error
7850 "misplaced '@dynamic' Objective-C++ construct" and skips the
7852 error_at (location
, "%<@dynamic%> not in @implementation context");
7856 /* @dynamic is allowed in categories. */
7857 switch (TREE_CODE (objc_implementation_context
))
7859 case CLASS_IMPLEMENTATION_TYPE
:
7860 interface
= lookup_interface (CLASS_NAME (objc_implementation_context
));
7862 case CATEGORY_IMPLEMENTATION_TYPE
:
7863 interface
= lookup_category (implementation_template
,
7864 CLASS_SUPER_NAME (objc_implementation_context
));
7872 /* I can't see how this could happen, but it is good as a safety check. */
7874 "%<@dynamic%> requires the @interface of the class to be available");
7878 /* Now, iterate over the properties and do each of them. */
7879 for (chain
= property_list
; chain
; chain
= TREE_CHAIN (chain
))
7881 objc_add_dynamic_declaration_for_property (location
, interface
, TREE_VALUE (chain
));
7885 /* Main routine to generate code/data for all the property information for
7886 current implementation (class or category). CLASS is the interface where
7887 ivars are declared. CLASS_METHODS is where methods are found which
7888 could be a class or a category depending on whether we are implementing
7889 property of a class or a category. */
7892 objc_gen_property_data (tree klass
, tree class_methods
)
7896 for (x
= IMPL_PROPERTY_DECL (objc_implementation_context
); x
; x
= TREE_CHAIN (x
))
7898 /* @dynamic property - nothing to check or synthesize. */
7899 if (PROPERTY_DYNAMIC (x
))
7902 /* @synthesize property - need to synthesize the accessors. */
7903 if (PROPERTY_IVAR_NAME (x
))
7905 objc_synthesize_getter (klass
, class_methods
, x
);
7907 if (PROPERTY_READONLY (x
) == 0)
7908 objc_synthesize_setter (klass
, class_methods
, x
);
7917 /* This is called once we see the "@end" in an interface/implementation. */
7920 finish_class (tree klass
)
7922 switch (TREE_CODE (klass
))
7924 case CLASS_IMPLEMENTATION_TYPE
:
7926 /* All metadata generation is done in runtime.generate_metadata(). */
7928 /* Generate what needed for property; setters, getters, etc. */
7929 objc_gen_property_data (implementation_template
, implementation_template
);
7931 if (implementation_template
!= objc_implementation_context
)
7933 /* Ensure that all method listed in the interface contain bodies. */
7934 check_methods (CLASS_CLS_METHODS (implementation_template
),
7935 objc_implementation_context
, '+');
7936 check_methods (CLASS_NST_METHODS (implementation_template
),
7937 objc_implementation_context
, '-');
7939 if (CLASS_PROTOCOL_LIST (implementation_template
))
7940 check_protocols (CLASS_PROTOCOL_LIST (implementation_template
),
7942 CLASS_NAME (objc_implementation_context
));
7946 case CATEGORY_IMPLEMENTATION_TYPE
:
7948 tree category
= lookup_category (implementation_template
, CLASS_SUPER_NAME (klass
));
7952 /* Generate what needed for property; setters, getters, etc. */
7953 objc_gen_property_data (implementation_template
, category
);
7955 /* Ensure all method listed in the interface contain bodies. */
7956 check_methods (CLASS_CLS_METHODS (category
),
7957 objc_implementation_context
, '+');
7958 check_methods (CLASS_NST_METHODS (category
),
7959 objc_implementation_context
, '-');
7961 if (CLASS_PROTOCOL_LIST (category
))
7962 check_protocols (CLASS_PROTOCOL_LIST (category
),
7964 CLASS_SUPER_NAME (objc_implementation_context
));
7968 case CLASS_INTERFACE_TYPE
:
7969 case CATEGORY_INTERFACE_TYPE
:
7970 case PROTOCOL_INTERFACE_TYPE
:
7972 /* Process properties of the class. */
7974 for (x
= CLASS_PROPERTY_DECL (objc_interface_context
); x
; x
= TREE_CHAIN (x
))
7976 /* Now we check that the appropriate getter is declared,
7977 and if not, we declare one ourselves. */
7978 tree getter_decl
= lookup_method (CLASS_NST_METHODS (klass
),
7979 PROPERTY_GETTER_NAME (x
));
7983 /* TODO: Check that the declaration is consistent with the property. */
7988 /* Generate an instance method declaration for the
7989 getter; for example "- (id) name;". In general it
7991 -(type)property_getter_name; */
7992 tree rettype
= build_tree_list (NULL_TREE
, TREE_TYPE (x
));
7993 getter_decl
= build_method_decl (INSTANCE_METHOD_DECL
,
7994 rettype
, PROPERTY_GETTER_NAME (x
),
7996 if (PROPERTY_OPTIONAL (x
))
7997 objc_add_method (objc_interface_context
, getter_decl
, false, true);
7999 objc_add_method (objc_interface_context
, getter_decl
, false, false);
8000 TREE_DEPRECATED (getter_decl
) = TREE_DEPRECATED (x
);
8001 METHOD_PROPERTY_CONTEXT (getter_decl
) = x
;
8004 if (PROPERTY_READONLY (x
) == 0)
8006 /* Now we check that the appropriate setter is declared,
8007 and if not, we declare on ourselves. */
8008 tree setter_decl
= lookup_method (CLASS_NST_METHODS (klass
),
8009 PROPERTY_SETTER_NAME (x
));
8013 /* TODO: Check that the declaration is consistent with the property. */
8018 /* The setter name is something like 'setName:'.
8019 We need the substring 'setName' to build the
8020 method declaration due to how the declaration
8021 works. TODO: build_method_decl() will then
8022 generate back 'setName:' from 'setName'; it
8023 would be more efficient to hook into there. */
8024 const char *full_setter_name
= IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x
));
8025 size_t length
= strlen (full_setter_name
);
8026 char *setter_name
= (char *) alloca (length
);
8027 tree ret_type
, selector
, arg_type
, arg_name
;
8029 strcpy (setter_name
, full_setter_name
);
8030 setter_name
[length
- 1] = '\0';
8031 ret_type
= build_tree_list (NULL_TREE
, void_type_node
);
8032 arg_type
= build_tree_list (NULL_TREE
, TREE_TYPE (x
));
8033 arg_name
= get_identifier ("_value");
8034 selector
= objc_build_keyword_decl (get_identifier (setter_name
),
8035 arg_type
, arg_name
, NULL
);
8036 setter_decl
= build_method_decl (INSTANCE_METHOD_DECL
,
8038 build_tree_list (NULL_TREE
, NULL_TREE
),
8040 if (PROPERTY_OPTIONAL (x
))
8041 objc_add_method (objc_interface_context
, setter_decl
, false, true);
8043 objc_add_method (objc_interface_context
, setter_decl
, false, false);
8044 TREE_DEPRECATED (setter_decl
) = TREE_DEPRECATED (x
);
8045 METHOD_PROPERTY_CONTEXT (setter_decl
) = x
;
8058 add_protocol (tree protocol
)
8060 /* Put protocol on list in reverse order. */
8061 TREE_CHAIN (protocol
) = protocol_chain
;
8062 protocol_chain
= protocol
;
8063 return protocol_chain
;
8066 /* Check that a protocol is defined, and, recursively, that all
8067 protocols that this protocol conforms to are defined too. */
8069 check_that_protocol_is_defined (tree protocol
)
8071 if (!PROTOCOL_DEFINED (protocol
))
8072 warning (0, "definition of protocol %qE not found",
8073 PROTOCOL_NAME (protocol
));
8075 /* If the protocol itself conforms to other protocols, check them
8076 too, recursively. */
8077 if (PROTOCOL_LIST (protocol
))
8081 for (p
= PROTOCOL_LIST (protocol
); p
; p
= TREE_CHAIN (p
))
8082 check_that_protocol_is_defined (TREE_VALUE (p
));
8086 /* Looks up a protocol. If 'warn_if_deprecated' is true, a warning is
8087 emitted if the protocol is deprecated. If 'definition_required' is
8088 true, a warning is emitted if a full @protocol definition has not
8091 lookup_protocol (tree ident
, bool warn_if_deprecated
, bool definition_required
)
8095 for (chain
= protocol_chain
; chain
; chain
= TREE_CHAIN (chain
))
8096 if (ident
== PROTOCOL_NAME (chain
))
8098 if (warn_if_deprecated
&& TREE_DEPRECATED (chain
))
8100 /* It would be nice to use warn_deprecated_use() here, but
8101 we are using TREE_CHAIN (which is supposed to be the
8102 TYPE_STUB_DECL for a TYPE) for something different. */
8103 warning (OPT_Wdeprecated_declarations
, "protocol %qE is deprecated",
8104 PROTOCOL_NAME (chain
));
8107 if (definition_required
)
8108 check_that_protocol_is_defined (chain
);
8116 /* This function forward declares the protocols named by NAMES. If
8117 they are already declared or defined, the function has no effect. */
8120 objc_declare_protocol (tree name
, tree attributes
)
8122 bool deprecated
= false;
8125 if (current_namespace
!= global_namespace
) {
8126 error ("Objective-C declarations may only appear in global scope");
8128 #endif /* OBJCPLUS */
8130 /* Determine if 'deprecated', the only attribute we recognize for
8131 protocols, was used. Ignore all other attributes. */
8135 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
8137 tree name
= TREE_PURPOSE (attribute
);
8139 if (is_attribute_p ("deprecated", name
))
8142 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
8146 if (lookup_protocol (name
, /* warn if deprecated */ false,
8147 /* definition_required */ false) == NULL_TREE
)
8149 tree protocol
= make_node (PROTOCOL_INTERFACE_TYPE
);
8151 TYPE_LANG_SLOT_1 (protocol
)
8152 = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS
);
8153 PROTOCOL_NAME (protocol
) = name
;
8154 PROTOCOL_LIST (protocol
) = NULL_TREE
;
8155 add_protocol (protocol
);
8156 PROTOCOL_DEFINED (protocol
) = 0;
8157 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
8161 /* TODO: Do we need to store the attributes here ? */
8162 TYPE_ATTRIBUTES (protocol
) = attributes
;
8164 TREE_DEPRECATED (protocol
) = 1;
8170 start_protocol (enum tree_code code
, tree name
, tree list
, tree attributes
)
8173 bool deprecated
= false;
8176 if (current_namespace
!= global_namespace
) {
8177 error ("Objective-C declarations may only appear in global scope");
8179 #endif /* OBJCPLUS */
8181 /* Determine if 'deprecated', the only attribute we recognize for
8182 protocols, was used. Ignore all other attributes. */
8186 for (attribute
= attributes
; attribute
; attribute
= TREE_CHAIN (attribute
))
8188 tree name
= TREE_PURPOSE (attribute
);
8190 if (is_attribute_p ("deprecated", name
))
8193 warning (OPT_Wattributes
, "%qE attribute directive ignored", name
);
8197 protocol
= lookup_protocol (name
, /* warn_if_deprecated */ false,
8198 /* definition_required */ false);
8202 protocol
= make_node (code
);
8203 TYPE_LANG_SLOT_1 (protocol
) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS
);
8205 PROTOCOL_NAME (protocol
) = name
;
8206 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
, /* definition_required */ false);
8207 add_protocol (protocol
);
8208 PROTOCOL_DEFINED (protocol
) = 1;
8209 PROTOCOL_FORWARD_DECL (protocol
) = NULL_TREE
;
8211 check_protocol_recursively (protocol
, list
);
8213 else if (! PROTOCOL_DEFINED (protocol
))
8215 PROTOCOL_DEFINED (protocol
) = 1;
8216 PROTOCOL_LIST (protocol
) = lookup_and_install_protocols (list
, /* definition_required */ false);
8218 check_protocol_recursively (protocol
, list
);
8222 warning (0, "duplicate declaration for protocol %qE",
8228 TYPE_ATTRIBUTES (protocol
) = attributes
;
8230 TREE_DEPRECATED (protocol
) = 1;
8236 /* Decay array and function parameters into pointers. */
8239 objc_decay_parm_type (tree type
)
8241 if (TREE_CODE (type
) == ARRAY_TYPE
|| TREE_CODE (type
) == FUNCTION_TYPE
)
8242 type
= build_pointer_type (TREE_CODE (type
) == ARRAY_TYPE
8249 static GTY(()) tree objc_parmlist
= NULL_TREE
;
8251 /* Append PARM to a list of formal parameters of a method, making a necessary
8252 array-to-pointer adjustment along the way. */
8255 objc_push_parm (tree parm
)
8259 if (TREE_TYPE (parm
) == error_mark_node
)
8261 objc_parmlist
= chainon (objc_parmlist
, parm
);
8265 /* Decay arrays and functions into pointers. */
8266 type
= objc_decay_parm_type (TREE_TYPE (parm
));
8268 /* If the parameter type has been decayed, a new PARM_DECL needs to be
8270 if (type
!= TREE_TYPE (parm
))
8271 parm
= build_decl (input_location
, PARM_DECL
, DECL_NAME (parm
), type
);
8273 DECL_ARG_TYPE (parm
)
8274 = lang_hooks
.types
.type_promotes_to (TREE_TYPE (parm
));
8276 /* Record constancy and volatility. */
8277 c_apply_type_quals_to_decl
8278 ((TYPE_READONLY (TREE_TYPE (parm
)) ? TYPE_QUAL_CONST
: 0)
8279 | (TYPE_RESTRICT (TREE_TYPE (parm
)) ? TYPE_QUAL_RESTRICT
: 0)
8280 | (TYPE_VOLATILE (TREE_TYPE (parm
)) ? TYPE_QUAL_VOLATILE
: 0), parm
);
8282 objc_parmlist
= chainon (objc_parmlist
, parm
);
8285 /* Retrieve the formal parameter list constructed via preceding calls to
8286 objc_push_parm(). */
8290 objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED
)
8292 tree parm_info
= objc_parmlist
;
8293 objc_parmlist
= NULL_TREE
;
8299 objc_get_parm_info (int have_ellipsis
)
8301 tree parm_info
= objc_parmlist
;
8302 struct c_arg_info
*arg_info
;
8303 /* The C front-end requires an elaborate song and dance at
8306 declare_parm_level ();
8309 tree next
= DECL_CHAIN (parm_info
);
8311 DECL_CHAIN (parm_info
) = NULL_TREE
;
8312 parm_info
= pushdecl (parm_info
);
8313 finish_decl (parm_info
, input_location
, NULL_TREE
, NULL_TREE
, NULL_TREE
);
8316 arg_info
= get_parm_info (have_ellipsis
);
8318 objc_parmlist
= NULL_TREE
;
8323 /* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
8324 method definitions. In the case of instance methods, we can be more
8325 specific as to the type of 'self'. */
8328 synth_self_and_ucmd_args (void)
8332 if (objc_method_context
8333 && TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
)
8334 self_type
= objc_instance_type
;
8336 /* Really a `struct objc_class *'. However, we allow people to
8337 assign to self, which changes its type midstream. */
8338 self_type
= objc_object_type
;
8341 objc_push_parm (build_decl (input_location
,
8342 PARM_DECL
, self_id
, self_type
));
8345 objc_push_parm (build_decl (input_location
,
8346 PARM_DECL
, ucmd_id
, objc_selector_type
));
8349 /* Transform an Objective-C method definition into a static C function
8350 definition, synthesizing the first two arguments, "self" and "_cmd",
8354 start_method_def (tree method
)
8360 struct c_arg_info
*parm_info
;
8362 int have_ellipsis
= 0;
8364 /* If we are defining a "dealloc" method in a non-root class, we
8365 will need to check if a [super dealloc] is missing, and warn if
8367 if(CLASS_SUPER_NAME (objc_implementation_context
)
8368 && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method
))))
8369 should_call_super_dealloc
= 1;
8371 should_call_super_dealloc
= 0;
8373 /* Required to implement _msgSuper. */
8374 objc_method_context
= method
;
8375 UOBJC_SUPER_decl
= NULL_TREE
;
8377 /* Generate prototype declarations for arguments..."new-style". */
8378 synth_self_and_ucmd_args ();
8380 /* Generate argument declarations if a keyword_decl. */
8381 parmlist
= METHOD_SEL_ARGS (method
);
8384 /* parmlist is a KEYWORD_DECL. */
8385 tree type
= TREE_VALUE (TREE_TYPE (parmlist
));
8388 parm
= build_decl (input_location
,
8389 PARM_DECL
, KEYWORD_ARG_NAME (parmlist
), type
);
8390 decl_attributes (&parm
, DECL_ATTRIBUTES (parmlist
), 0);
8391 objc_push_parm (parm
);
8392 parmlist
= DECL_CHAIN (parmlist
);
8395 if (METHOD_ADD_ARGS (method
))
8399 for (akey
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
8400 akey
; akey
= TREE_CHAIN (akey
))
8402 objc_push_parm (TREE_VALUE (akey
));
8405 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
8409 parm_info
= objc_get_parm_info (have_ellipsis
);
8411 really_start_method (objc_method_context
, parm_info
);
8414 /* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method
8417 objc_types_are_equivalent (tree type1
, tree type2
)
8422 /* Strip away indirections. */
8423 while ((TREE_CODE (type1
) == ARRAY_TYPE
|| TREE_CODE (type1
) == POINTER_TYPE
)
8424 && (TREE_CODE (type1
) == TREE_CODE (type2
)))
8425 type1
= TREE_TYPE (type1
), type2
= TREE_TYPE (type2
);
8426 if (TYPE_MAIN_VARIANT (type1
) != TYPE_MAIN_VARIANT (type2
))
8429 /* Compare the protocol lists. */
8430 type1
= (TYPE_HAS_OBJC_INFO (type1
)
8431 ? TYPE_OBJC_PROTOCOL_LIST (type1
)
8433 type2
= (TYPE_HAS_OBJC_INFO (type2
)
8434 ? TYPE_OBJC_PROTOCOL_LIST (type2
)
8437 /* If there are no protocols (most common case), the types are
8439 if (type1
== NULL_TREE
&& type2
== NULL_TREE
)
8442 /* If one has protocols, and the other one hasn't, they are not
8444 if ((type1
== NULL_TREE
&& type2
!= NULL_TREE
)
8445 || (type1
!= NULL_TREE
&& type2
== NULL_TREE
))
8449 /* Else, both have protocols, and we need to do the full
8450 comparison. It is possible that either type1 or type2
8451 contain some duplicate protocols in the list, so we can't
8452 even just compare list_length as a first check. */
8455 for (t
= type2
; t
; t
= TREE_CHAIN (t
))
8456 if (!lookup_protocol_in_reflist (type1
, TREE_VALUE (t
)))
8459 for (t
= type1
; t
; t
= TREE_CHAIN (t
))
8460 if (!lookup_protocol_in_reflist (type2
, TREE_VALUE (t
)))
8467 /* Return 1 if TYPE1 has the same size and alignment as TYPE2. */
8470 objc_types_share_size_and_alignment (tree type1
, tree type2
)
8472 return (simple_cst_equal (TYPE_SIZE (type1
), TYPE_SIZE (type2
))
8473 && TYPE_ALIGN (type1
) == TYPE_ALIGN (type2
));
8476 /* Return 1 if PROTO1 is equivalent to PROTO2
8477 for purposes of method overloading. Ordinarily, the type signatures
8478 should match up exactly, unless STRICT is zero, in which case we
8479 shall allow differences in which the size and alignment of a type
8483 comp_proto_with_proto (tree proto1
, tree proto2
, int strict
)
8487 /* The following test is needed in case there are hashing
8489 if (METHOD_SEL_NAME (proto1
) != METHOD_SEL_NAME (proto2
))
8492 /* Compare return types. */
8493 type1
= TREE_VALUE (TREE_TYPE (proto1
));
8494 type2
= TREE_VALUE (TREE_TYPE (proto2
));
8496 if (!objc_types_are_equivalent (type1
, type2
)
8497 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8500 /* Compare argument types. */
8502 /* The first argument (objc_object_type) is always the same, no need
8505 /* The second argument (objc_selector_type) is always the same, no
8508 /* Compare the other arguments. */
8512 /* Compare METHOD_SEL_ARGS. */
8513 for (arg1
= METHOD_SEL_ARGS (proto1
), arg2
= METHOD_SEL_ARGS (proto2
);
8515 arg1
= DECL_CHAIN (arg1
), arg2
= DECL_CHAIN (arg2
))
8517 type1
= TREE_VALUE (TREE_TYPE (arg1
));
8518 type2
= TREE_VALUE (TREE_TYPE (arg2
));
8520 /* FIXME: Do we need to decay argument types to compare them ? */
8521 type1
= objc_decay_parm_type (type1
);
8522 type2
= objc_decay_parm_type (type2
);
8524 if (!objc_types_are_equivalent (type1
, type2
)
8525 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8529 /* The loop ends when arg1 or arg2 are NULL. Make sure they are
8534 /* Compare METHOD_ADD_ARGS. */
8535 if ((METHOD_ADD_ARGS (proto1
) && !METHOD_ADD_ARGS (proto2
))
8536 || (METHOD_ADD_ARGS (proto2
) && !METHOD_ADD_ARGS (proto1
)))
8539 if (METHOD_ADD_ARGS (proto1
))
8541 for (arg1
= TREE_CHAIN (METHOD_ADD_ARGS (proto1
)), arg2
= TREE_CHAIN (METHOD_ADD_ARGS (proto2
));
8543 arg1
= TREE_CHAIN (arg1
), arg2
= TREE_CHAIN (arg2
))
8545 type1
= TREE_TYPE (TREE_VALUE (arg1
));
8546 type2
= TREE_TYPE (TREE_VALUE (arg2
));
8548 /* FIXME: Do we need to decay argument types to compare them ? */
8549 type1
= objc_decay_parm_type (type1
);
8550 type2
= objc_decay_parm_type (type2
);
8552 if (!objc_types_are_equivalent (type1
, type2
)
8553 && (strict
|| !objc_types_share_size_and_alignment (type1
, type2
)))
8558 /* The loop ends when arg1 or arg2 are NULL. Make sure they are
8563 /* Compare METHOD_ADD_ARGS_ELLIPSIS_P. */
8564 if (METHOD_ADD_ARGS_ELLIPSIS_P (proto1
) != METHOD_ADD_ARGS_ELLIPSIS_P (proto2
))
8572 /* This routine returns true if TYPE is a valid objc object type,
8573 suitable for messaging; false otherwise. If 'accept_class' is
8574 'true', then a Class object is considered valid for messaging and
8575 'true' is returned if 'type' refers to a Class. If 'accept_class'
8576 is 'false', then a Class object is not considered valid for
8577 messaging and 'false' is returned in that case. */
8580 objc_type_valid_for_messaging (tree type
, bool accept_classes
)
8582 if (!POINTER_TYPE_P (type
))
8585 /* Remove the pointer indirection; don't remove more than one
8586 otherwise we'd consider "NSObject **" a valid type for messaging,
8588 type
= TREE_TYPE (type
);
8590 if (TREE_CODE (type
) != RECORD_TYPE
)
8593 if (objc_is_object_id (type
))
8596 if (objc_is_class_id (type
))
8597 return accept_classes
;
8599 if (TYPE_HAS_OBJC_INFO (type
))
8606 objc_start_function (tree name
, tree type
, tree attrs
,
8610 struct c_arg_info
*params
8614 tree fndecl
= build_decl (input_location
,
8615 FUNCTION_DECL
, name
, type
);
8618 DECL_ARGUMENTS (fndecl
) = params
;
8619 DECL_INITIAL (fndecl
) = error_mark_node
;
8620 DECL_EXTERNAL (fndecl
) = 0;
8621 TREE_STATIC (fndecl
) = 1;
8622 retrofit_lang_decl (fndecl
);
8623 cplus_decl_attributes (&fndecl
, attrs
, 0);
8624 start_preparsed_function (fndecl
, attrs
, /*flags=*/SF_DEFAULT
);
8626 current_function_returns_value
= 0; /* Assume, until we see it does. */
8627 current_function_returns_null
= 0;
8628 decl_attributes (&fndecl
, attrs
, 0);
8629 announce_function (fndecl
);
8630 DECL_INITIAL (fndecl
) = error_mark_node
;
8631 DECL_EXTERNAL (fndecl
) = 0;
8632 TREE_STATIC (fndecl
) = 1;
8633 current_function_decl
= pushdecl (fndecl
);
8635 declare_parm_level ();
8636 DECL_RESULT (current_function_decl
)
8637 = build_decl (input_location
,
8638 RESULT_DECL
, NULL_TREE
,
8639 TREE_TYPE (TREE_TYPE (current_function_decl
)));
8640 DECL_ARTIFICIAL (DECL_RESULT (current_function_decl
)) = 1;
8641 DECL_IGNORED_P (DECL_RESULT (current_function_decl
)) = 1;
8642 start_fname_decls ();
8643 store_parm_decls_from (params
);
8646 TREE_USED (current_function_decl
) = 1;
8649 /* - Generate an identifier for the function. the format is "_n_cls",
8650 where 1 <= n <= nMethods, and cls is the name the implementation we
8652 - Install the return type from the method declaration.
8653 - If we have a prototype, check for type consistency. */
8656 really_start_method (tree method
,
8660 struct c_arg_info
*parmlist
8664 tree ret_type
, meth_type
;
8666 const char *sel_name
, *class_name
, *cat_name
;
8669 /* Synth the storage class & assemble the return type. */
8670 ret_type
= TREE_VALUE (TREE_TYPE (method
));
8672 sel_name
= IDENTIFIER_POINTER (METHOD_SEL_NAME (method
));
8673 class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context
));
8674 cat_name
= ((TREE_CODE (objc_implementation_context
)
8675 == CLASS_IMPLEMENTATION_TYPE
)
8677 : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context
)));
8680 /* Make sure this is big enough for any plausible method label. */
8681 buf
= (char *) alloca (50 + strlen (sel_name
) + strlen (class_name
)
8682 + (cat_name
? strlen (cat_name
) : 0));
8684 OBJC_GEN_METHOD_LABEL (buf
, TREE_CODE (method
) == INSTANCE_METHOD_DECL
,
8685 class_name
, cat_name
, sel_name
, method_slot
);
8687 method_id
= get_identifier (buf
);
8690 /* Objective-C methods cannot be overloaded, so we don't need
8691 the type encoding appended. It looks bad anyway... */
8692 push_lang_context (lang_name_c
);
8696 = build_function_type (ret_type
,
8697 get_arg_type_list (method
, METHOD_DEF
, 0));
8698 objc_start_function (method_id
, meth_type
, NULL_TREE
, parmlist
);
8700 /* Set self_decl from the first argument. */
8701 self_decl
= DECL_ARGUMENTS (current_function_decl
);
8703 /* Suppress unused warnings. */
8704 TREE_USED (self_decl
) = 1;
8705 DECL_READ_P (self_decl
) = 1;
8706 TREE_USED (DECL_CHAIN (self_decl
)) = 1;
8707 DECL_READ_P (DECL_CHAIN (self_decl
)) = 1;
8709 pop_lang_context ();
8712 METHOD_DEFINITION (method
) = current_function_decl
;
8714 /* Check consistency...start_function, pushdecl, duplicate_decls. */
8716 if (implementation_template
!= objc_implementation_context
)
8719 = lookup_method_static (implementation_template
,
8720 METHOD_SEL_NAME (method
),
8721 ((TREE_CODE (method
) == CLASS_METHOD_DECL
)
8722 | OBJC_LOOKUP_NO_SUPER
));
8726 if (!comp_proto_with_proto (method
, proto
, 1))
8728 bool type
= TREE_CODE (method
) == INSTANCE_METHOD_DECL
;
8730 warning_at (DECL_SOURCE_LOCATION (method
), 0,
8731 "conflicting types for %<%c%s%>",
8733 identifier_to_locale (gen_method_decl (method
)));
8734 inform (DECL_SOURCE_LOCATION (proto
),
8735 "previous declaration of %<%c%s%>",
8737 identifier_to_locale (gen_method_decl (proto
)));
8741 /* If the method in the @interface was deprecated, mark
8742 the implemented method as deprecated too. It should
8743 never be used for messaging (when the deprecation
8744 warnings are produced), but just in case. */
8745 if (TREE_DEPRECATED (proto
))
8746 TREE_DEPRECATED (method
) = 1;
8748 /* If the method in the @interface was marked as
8749 'noreturn', mark the function implementing the method
8750 as 'noreturn' too. */
8751 TREE_THIS_VOLATILE (current_function_decl
) = TREE_THIS_VOLATILE (proto
);
8756 /* We have a method @implementation even though we did not
8757 see a corresponding @interface declaration (which is allowed
8758 by Objective-C rules). Go ahead and place the method in
8759 the @interface anyway, so that message dispatch lookups
8761 tree interface
= implementation_template
;
8763 if (TREE_CODE (objc_implementation_context
)
8764 == CATEGORY_IMPLEMENTATION_TYPE
)
8765 interface
= lookup_category
8767 CLASS_SUPER_NAME (objc_implementation_context
));
8770 objc_add_method (interface
, copy_node (method
),
8771 TREE_CODE (method
) == CLASS_METHOD_DECL
,
8772 /* is_optional= */ false);
8777 static void *UOBJC_SUPER_scope
= 0;
8779 /* _n_Method (id self, SEL sel, ...)
8781 struct objc_super _S;
8782 _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
8786 get_super_receiver (void)
8788 if (objc_method_context
)
8790 tree super_expr
, super_expr_list
, class_expr
;
8792 if (!UOBJC_SUPER_decl
)
8794 UOBJC_SUPER_decl
= build_decl (input_location
,
8795 VAR_DECL
, get_identifier (TAG_SUPER
),
8796 objc_super_template
);
8797 /* This prevents `unused variable' warnings when compiling with -Wall. */
8798 TREE_USED (UOBJC_SUPER_decl
) = 1;
8799 DECL_READ_P (UOBJC_SUPER_decl
) = 1;
8800 lang_hooks
.decls
.pushdecl (UOBJC_SUPER_decl
);
8801 finish_decl (UOBJC_SUPER_decl
, input_location
, NULL_TREE
, NULL_TREE
,
8803 UOBJC_SUPER_scope
= objc_get_current_scope ();
8806 /* Set receiver to self. */
8807 super_expr
= objc_build_component_ref (UOBJC_SUPER_decl
, self_id
);
8808 super_expr
= build_modify_expr (input_location
, super_expr
, NULL_TREE
,
8809 NOP_EXPR
, input_location
, self_decl
,
8811 super_expr_list
= super_expr
;
8813 /* Set class to begin searching. */
8814 /* Get the ident for the superclass class field & build a ref to it.
8815 ??? maybe we should just name the field the same for all runtimes. */
8816 super_expr
= (*runtime
.super_superclassfield_ident
) ();
8817 super_expr
= objc_build_component_ref (UOBJC_SUPER_decl
, super_expr
);
8819 gcc_assert (imp_list
->imp_context
== objc_implementation_context
8820 && imp_list
->imp_template
== implementation_template
);
8821 inst_meth
= (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
);
8823 if (TREE_CODE (objc_implementation_context
) == CLASS_IMPLEMENTATION_TYPE
)
8824 class_expr
= (*runtime
.get_class_super_ref
) (input_location
,
8825 imp_list
, inst_meth
);
8827 /* We have a category. */
8829 tree super_name
= CLASS_SUPER_NAME (imp_list
->imp_template
);
8832 /* Barf if super used in a category of a root object. */
8835 error ("no super class declared in interface for %qE",
8836 CLASS_NAME (imp_list
->imp_template
));
8837 return error_mark_node
;
8840 super_class
= (*runtime
.get_category_super_ref
) (input_location
,
8841 imp_list
, inst_meth
);
8842 class_expr
= build_c_cast (input_location
,
8843 TREE_TYPE (super_expr
), super_class
);
8846 super_expr
= build_modify_expr (input_location
, super_expr
, NULL_TREE
,
8848 input_location
, class_expr
, NULL_TREE
);
8850 super_expr_list
= build_compound_expr (input_location
,
8851 super_expr_list
, super_expr
);
8853 super_expr
= build_unary_op (input_location
,
8854 ADDR_EXPR
, UOBJC_SUPER_decl
, 0);
8855 super_expr_list
= build_compound_expr (input_location
,
8856 super_expr_list
, super_expr
);
8858 return super_expr_list
;
8862 error ("[super ...] must appear in a method context");
8863 return error_mark_node
;
8867 /* When exiting a scope, sever links to a 'super' declaration (if any)
8868 therein contained. */
8871 objc_clear_super_receiver (void)
8873 if (objc_method_context
8874 && UOBJC_SUPER_scope
== objc_get_current_scope ())
8876 UOBJC_SUPER_decl
= 0;
8877 UOBJC_SUPER_scope
= 0;
8882 objc_finish_method_definition (tree fndecl
)
8884 /* We cannot validly inline ObjC methods, at least not without a language
8885 extension to declare that a method need not be dynamically
8886 dispatched, so suppress all thoughts of doing so. */
8887 DECL_UNINLINABLE (fndecl
) = 1;
8890 /* The C++ front-end will have called finish_function() for us. */
8894 METHOD_ENCODING (objc_method_context
)
8895 = encode_method_prototype (objc_method_context
);
8897 /* Required to implement _msgSuper. This must be done AFTER finish_function,
8898 since the optimizer may find "may be used before set" errors. */
8899 objc_method_context
= NULL_TREE
;
8901 if (should_call_super_dealloc
)
8902 warning (0, "method possibly missing a [super dealloc] call");
8905 /* Given a tree DECL node, produce a printable description of it in the given
8906 buffer, overwriting the buffer. */
8909 gen_declaration (tree decl
)
8915 gen_type_name_0 (TREE_TYPE (decl
));
8917 if (DECL_NAME (decl
))
8919 if (!POINTER_TYPE_P (TREE_TYPE (decl
)))
8920 strcat (errbuf
, " ");
8922 strcat (errbuf
, IDENTIFIER_POINTER (DECL_NAME (decl
)));
8925 if (DECL_INITIAL (decl
)
8926 && TREE_CODE (DECL_INITIAL (decl
)) == INTEGER_CST
)
8927 sprintf (errbuf
+ strlen (errbuf
), ": " HOST_WIDE_INT_PRINT_DEC
,
8928 TREE_INT_CST_LOW (DECL_INITIAL (decl
)));
8934 /* Given a tree TYPE node, produce a printable description of it in the given
8935 buffer, overwriting the buffer. */
8938 gen_type_name_0 (tree type
)
8940 tree orig
= type
, proto
;
8942 if (TYPE_P (type
) && TYPE_NAME (type
))
8943 type
= TYPE_NAME (type
);
8944 else if (POINTER_TYPE_P (type
) || TREE_CODE (type
) == ARRAY_TYPE
)
8946 tree inner
= TREE_TYPE (type
);
8948 while (TREE_CODE (inner
) == ARRAY_TYPE
)
8949 inner
= TREE_TYPE (inner
);
8951 gen_type_name_0 (inner
);
8953 if (!POINTER_TYPE_P (inner
))
8954 strcat (errbuf
, " ");
8956 if (POINTER_TYPE_P (type
))
8957 strcat (errbuf
, "*");
8959 while (type
!= inner
)
8961 strcat (errbuf
, "[");
8963 if (TYPE_DOMAIN (type
))
8967 sprintf (sz
, HOST_WIDE_INT_PRINT_DEC
,
8969 (TYPE_MAX_VALUE (TYPE_DOMAIN (type
))) + 1));
8970 strcat (errbuf
, sz
);
8973 strcat (errbuf
, "]");
8974 type
= TREE_TYPE (type
);
8980 if (TREE_CODE (type
) == TYPE_DECL
&& DECL_NAME (type
))
8981 type
= DECL_NAME (type
);
8983 strcat (errbuf
, TREE_CODE (type
) == IDENTIFIER_NODE
8984 ? IDENTIFIER_POINTER (type
)
8987 /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
8988 if (objc_is_id (orig
))
8989 orig
= TREE_TYPE (orig
);
8991 proto
= TYPE_HAS_OBJC_INFO (orig
) ? TYPE_OBJC_PROTOCOL_LIST (orig
) : NULL_TREE
;
8995 strcat (errbuf
, " <");
8999 IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto
))));
9000 proto
= TREE_CHAIN (proto
);
9001 strcat (errbuf
, proto
? ", " : ">");
9010 gen_type_name (tree type
)
9014 return gen_type_name_0 (type
);
9017 /* Given a method tree, put a printable description into the given
9018 buffer (overwriting) and return a pointer to the buffer. */
9021 gen_method_decl (tree method
)
9025 strcpy (errbuf
, "("); /* NB: Do _not_ call strcat() here. */
9026 gen_type_name_0 (TREE_VALUE (TREE_TYPE (method
)));
9027 strcat (errbuf
, ")");
9028 chain
= METHOD_SEL_ARGS (method
);
9032 /* We have a chain of keyword_decls. */
9035 if (KEYWORD_KEY_NAME (chain
))
9036 strcat (errbuf
, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain
)));
9038 strcat (errbuf
, ":(");
9039 gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain
)));
9040 strcat (errbuf
, ")");
9042 strcat (errbuf
, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain
)));
9043 if ((chain
= DECL_CHAIN (chain
)))
9044 strcat (errbuf
, " ");
9048 if (METHOD_ADD_ARGS (method
))
9050 chain
= TREE_CHAIN (METHOD_ADD_ARGS (method
));
9052 /* Know we have a chain of parm_decls. */
9055 strcat (errbuf
, ", ");
9056 gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain
)));
9057 chain
= TREE_CHAIN (chain
);
9060 if (METHOD_ADD_ARGS_ELLIPSIS_P (method
))
9061 strcat (errbuf
, ", ...");
9066 /* We have a unary selector. */
9067 strcat (errbuf
, IDENTIFIER_POINTER (METHOD_SEL_NAME (method
)));
9075 /* Dump an @interface declaration of the supplied class CHAIN to the
9076 supplied file FP. Used to implement the -gen-decls option (which
9077 prints out an @interface declaration of all classes compiled in
9078 this run); potentially useful for debugging the compiler too. */
9080 dump_interface (FILE *fp
, tree chain
)
9082 /* FIXME: A heap overflow here whenever a method (or ivar)
9083 declaration is so long that it doesn't fit in the buffer. The
9084 code and all the related functions should be rewritten to avoid
9085 using fixed size buffers. */
9086 const char *my_name
= IDENTIFIER_POINTER (CLASS_NAME (chain
));
9087 tree ivar_decls
= CLASS_RAW_IVARS (chain
);
9088 tree nst_methods
= CLASS_NST_METHODS (chain
);
9089 tree cls_methods
= CLASS_CLS_METHODS (chain
);
9091 fprintf (fp
, "\n@interface %s", my_name
);
9093 /* CLASS_SUPER_NAME is used to store the superclass name for
9094 classes, and the category name for categories. */
9095 if (CLASS_SUPER_NAME (chain
))
9097 const char *name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain
));
9099 switch (TREE_CODE (chain
))
9101 case CATEGORY_IMPLEMENTATION_TYPE
:
9102 case CATEGORY_INTERFACE_TYPE
:
9103 fprintf (fp
, " (%s)\n", name
);
9106 fprintf (fp
, " : %s\n", name
);
9113 /* FIXME - the following doesn't seem to work at the moment. */
9116 fprintf (fp
, "{\n");
9119 fprintf (fp
, "\t%s;\n", gen_declaration (ivar_decls
));
9120 ivar_decls
= TREE_CHAIN (ivar_decls
);
9123 fprintf (fp
, "}\n");
9128 fprintf (fp
, "- %s;\n", gen_method_decl (nst_methods
));
9129 nst_methods
= TREE_CHAIN (nst_methods
);
9134 fprintf (fp
, "+ %s;\n", gen_method_decl (cls_methods
));
9135 cls_methods
= TREE_CHAIN (cls_methods
);
9138 fprintf (fp
, "@end\n");
9142 /* Produce the pretty printing for an Objective-C method. This is
9143 currently unused, but could be handy while reorganizing the pretty
9144 printing to be more robust. */
9146 objc_pretty_print_method (bool is_class_method
,
9147 const char *class_name
,
9148 const char *category_name
,
9149 const char *selector
)
9153 char *result
= XNEWVEC (char, strlen (class_name
) + strlen (category_name
)
9154 + strlen (selector
) + 7);
9156 if (is_class_method
)
9157 sprintf (result
, "+[%s(%s) %s]", class_name
, category_name
, selector
);
9159 sprintf (result
, "-[%s(%s) %s]", class_name
, category_name
, selector
);
9165 char *result
= XNEWVEC (char, strlen (class_name
)
9166 + strlen (selector
) + 5);
9168 if (is_class_method
)
9169 sprintf (result
, "+[%s %s]", class_name
, selector
);
9171 sprintf (result
, "-[%s %s]", class_name
, selector
);
9178 /* Demangle function for Objective-C. Attempt to demangle the
9179 function name associated with a method (eg, going from
9180 "_i_NSObject__class" to "-[NSObject class]"); usually for the
9181 purpose of pretty printing or error messages. Return the demangled
9182 name, or NULL if the string is not an Objective-C mangled method
9185 Because of how the mangling is done, any method that has a '_' in
9186 its original name is at risk of being demangled incorrectly. In
9187 some cases there are multiple valid ways to demangle a method name
9188 and there is no way we can decide.
9190 TODO: objc_demangle() can't always get it right; the right way to
9191 get this correct for all method names would be to store the
9192 Objective-C method name somewhere in the function decl. Then,
9193 there is no demangling to do; we'd just pull the method name out of
9194 the decl. As an additional bonus, when printing error messages we
9195 could check for such a method name, and if we find it, we know the
9196 function is actually an Objective-C method and we could print error
9197 messages saying "In method '+[NSObject class]" instead of "In
9198 function '+[NSObject class]" as we do now. */
9200 objc_demangle (const char *mangled
)
9202 char *demangled
, *cp
;
9204 /* First of all, if the name is too short it can't be an Objective-C
9205 mangled method name. */
9206 if (mangled
[0] == '\0' || mangled
[1] == '\0' || mangled
[2] == '\0')
9209 /* If the name looks like an already demangled one, return it
9210 unchanged. This should only happen on Darwin, where method names
9211 are mangled differently into a pretty-print form (such as
9212 '+[NSObject class]', see darwin.h). In that case, demangling is
9213 a no-op, but we need to return the demangled name if it was an
9214 ObjC one, and return NULL if not. We should be safe as no C/C++
9215 function can start with "-[" or "+[". */
9216 if ((mangled
[0] == '-' || mangled
[0] == '+')
9217 && (mangled
[1] == '['))
9220 if (mangled
[0] == '_' &&
9221 (mangled
[1] == 'i' || mangled
[1] == 'c') &&
9224 cp
= demangled
= XNEWVEC (char, strlen(mangled
) + 2);
9225 if (mangled
[1] == 'i')
9226 *cp
++ = '-'; /* for instance method */
9228 *cp
++ = '+'; /* for class method */
9229 *cp
++ = '['; /* opening left brace */
9230 strcpy(cp
, mangled
+3); /* tack on the rest of the mangled name */
9231 while (*cp
&& *cp
== '_')
9232 cp
++; /* skip any initial underbars in class name */
9233 cp
= strchr(cp
, '_'); /* find first non-initial underbar */
9236 free(demangled
); /* not mangled name */
9239 if (cp
[1] == '_') /* easy case: no category name */
9241 *cp
++ = ' '; /* replace two '_' with one ' ' */
9242 strcpy(cp
, mangled
+ (cp
- demangled
) + 2);
9246 *cp
++ = '('; /* less easy case: category name */
9247 cp
= strchr(cp
, '_');
9250 free(demangled
); /* not mangled name */
9254 *cp
++ = ' '; /* overwriting 1st char of method name... */
9255 strcpy(cp
, mangled
+ (cp
- demangled
)); /* get it back */
9257 /* Now we have the method name. We need to generally replace
9258 '_' with ':' but trying to preserve '_' if it could only have
9259 been in the mangled string because it was already in the
9260 original name. In cases where it's ambiguous, we assume that
9261 any '_' originated from a ':'. */
9263 /* Initial '_'s in method name can't have been generating by
9264 converting ':'s. Skip them. */
9265 while (*cp
&& *cp
== '_')
9268 /* If the method name does not end with '_', then it has no
9269 arguments and there was no replacement of ':'s with '_'s
9270 during mangling. Check for that case, and skip any
9271 replacement if so. This at least guarantees that methods
9272 with no arguments are always demangled correctly (unless the
9273 original name ends with '_'). */
9274 if (*(mangled
+ strlen (mangled
) - 1) != '_')
9276 /* Skip to the end. */
9282 /* Replace remaining '_' with ':'. This may get it wrong if
9283 there were '_'s in the original name. In most cases it
9284 is impossible to disambiguate. */
9289 *cp
++ = ']'; /* closing right brace */
9290 *cp
++ = 0; /* string terminator */
9294 return NULL
; /* not an objc mangled name */
9297 /* Try to pretty-print a decl. If the 'decl' is an Objective-C
9298 specific decl, return the printable name for it. If not, return
9301 objc_maybe_printable_name (tree decl
, int v ATTRIBUTE_UNUSED
)
9303 switch (TREE_CODE (decl
))
9306 return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl
)));
9309 /* The following happens when we are printing a deprecation
9310 warning for a method. The warn_deprecation() will end up
9311 trying to print the decl for INSTANCE_METHOD_DECL or
9312 CLASS_METHOD_DECL. It would be nice to be able to print
9313 "-[NSObject autorelease] is deprecated", but to do that, we'd
9314 need to store the class and method name in the method decl,
9315 which we currently don't do. For now, just return the name
9316 of the method. We don't return NULL, because that may
9317 trigger further attempts to pretty-print the decl in C/C++,
9318 but they wouldn't know how to pretty-print it. */
9319 case INSTANCE_METHOD_DECL
:
9320 case CLASS_METHOD_DECL
:
9321 return IDENTIFIER_POINTER (DECL_NAME (decl
));
9323 /* This happens when printing a deprecation warning for a
9324 property. We may want to consider some sort of pretty
9325 printing (eg, include the class name where it was declared
9328 return IDENTIFIER_POINTER (PROPERTY_NAME (decl
));
9336 /* Return a printable name for 'decl'. This first tries
9337 objc_maybe_printable_name(), and if that fails, it returns the name
9338 in the decl. This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for
9339 Objective-C; in Objective-C++, setting the hook is not enough
9340 because lots of C++ Front-End code calls cxx_printable_name,
9341 dump_decl and other C++ functions directly. So instead we have
9342 modified dump_decl to call objc_maybe_printable_name directly. */
9344 objc_printable_name (tree decl
, int v
)
9346 const char *demangled_name
= objc_maybe_printable_name (decl
, v
);
9348 if (demangled_name
!= NULL
)
9349 return demangled_name
;
9351 return IDENTIFIER_POINTER (DECL_NAME (decl
));
9354 /* Routine is called to issue diagnostic when reference to a private
9355 ivar is made and no other variable with same name is found in
9358 objc_diagnose_private_ivar (tree id
)
9361 if (!objc_method_context
)
9363 ivar
= is_ivar (objc_ivar_chain
, id
);
9364 if (ivar
&& is_private (ivar
))
9366 error ("instance variable %qs is declared private",
9367 IDENTIFIER_POINTER (id
));
9373 /* Look up ID as an instance variable. OTHER contains the result of
9374 the C or C++ lookup, which we may want to use instead. */
9375 /* To use properties inside an instance method, use self.property. */
9377 objc_lookup_ivar (tree other
, tree id
)
9381 /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
9382 if (!objc_method_context
)
9385 if (!strcmp (IDENTIFIER_POINTER (id
), "super"))
9386 /* We have a message to super. */
9387 return get_super_receiver ();
9389 /* In a class method, look up an instance variable only as a last
9391 if (TREE_CODE (objc_method_context
) == CLASS_METHOD_DECL
9392 && other
&& other
!= error_mark_node
)
9395 /* Look up the ivar, but do not use it if it is not accessible. */
9396 ivar
= is_ivar (objc_ivar_chain
, id
);
9398 if (!ivar
|| is_private (ivar
))
9401 /* In an instance method, a local variable (or parameter) may hide the
9402 instance variable. */
9403 if (TREE_CODE (objc_method_context
) == INSTANCE_METHOD_DECL
9404 && other
&& other
!= error_mark_node
9406 && CP_DECL_CONTEXT (other
) != global_namespace
)
9408 && !DECL_FILE_SCOPE_P (other
))
9411 warning (0, "local declaration of %qE hides instance variable", id
);
9416 /* At this point, we are either in an instance method with no obscuring
9417 local definitions, or in a class method with no alternate definitions
9419 return build_ivar_reference (id
);
9422 /* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This
9423 needs to be done if we are calling a function through a cast. */
9426 objc_rewrite_function_call (tree function
, tree first_param
)
9428 if (TREE_CODE (function
) == NOP_EXPR
9429 && TREE_CODE (TREE_OPERAND (function
, 0)) == ADDR_EXPR
9430 && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function
, 0), 0))
9433 function
= build3 (OBJ_TYPE_REF
, TREE_TYPE (function
),
9434 TREE_OPERAND (function
, 0),
9435 first_param
, size_zero_node
);
9441 /* This is called to "gimplify" a PROPERTY_REF node. It builds the
9442 corresponding 'getter' function call. Note that we assume the
9443 PROPERTY_REF to be valid since we generated it while parsing. */
9445 objc_gimplify_property_ref (tree
*expr_p
)
9447 tree getter
= PROPERTY_REF_GETTER_CALL (*expr_p
);
9450 if (getter
== NULL_TREE
)
9452 tree property_decl
= PROPERTY_REF_PROPERTY_DECL (*expr_p
);
9453 /* This can happen if DECL_ARTIFICIAL (*expr_p), but
9454 should be impossible for real properties, which always
9456 error_at (EXPR_LOCATION (*expr_p
), "no %qs getter found",
9457 IDENTIFIER_POINTER (PROPERTY_NAME (property_decl
)));
9458 /* Try to recover from the error to prevent an ICE. We take
9459 zero and cast it to the type of the property. */
9460 *expr_p
= convert (TREE_TYPE (property_decl
),
9465 if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p
))
9467 /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype
9468 that is deprecated. */
9469 warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p
),
9475 /* In C++, a getter which returns an aggregate value results in a
9476 target_expr which initializes a temporary to the call
9478 if (TREE_CODE (getter
) == TARGET_EXPR
)
9480 gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter
)));
9481 gcc_assert (TREE_CODE (TREE_OPERAND (getter
, 0)) == VAR_DECL
);
9482 call_exp
= TREE_OPERAND (getter
, 1);
9485 gcc_assert (TREE_CODE (call_exp
) == CALL_EXPR
);
9490 /* This is called when "gimplifying" the trees. We need to gimplify
9491 the Objective-C/Objective-C++ specific trees, then hand over the
9492 process to C/C++. */
9494 objc_gimplify_expr (tree
*expr_p
, gimple_seq
*pre_p
, gimple_seq
*post_p
)
9496 enum tree_code code
= TREE_CODE (*expr_p
);
9499 /* Look for the special case of OBJC_TYPE_REF with the address
9500 of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend
9501 or one of its cousins). */
9503 if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p
)) == ADDR_EXPR
9504 && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p
), 0))
9507 enum gimplify_status r0
, r1
;
9509 /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the
9510 value of the OBJ_TYPE_REF, so force them to be emitted
9511 during subexpression evaluation rather than after the
9512 OBJ_TYPE_REF. This permits objc_msgSend calls in
9513 Objective C to use direct rather than indirect calls when
9514 the object expression has a postincrement. */
9515 r0
= gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p
), pre_p
, NULL
,
9516 is_gimple_val
, fb_rvalue
);
9517 r1
= gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p
), pre_p
, post_p
,
9518 is_gimple_val
, fb_rvalue
);
9520 return MIN (r0
, r1
);
9524 objc_gimplify_property_ref (expr_p
);
9525 /* Do not return yet; let C/C++ gimplify the resulting expression. */
9532 return (enum gimplify_status
) cp_gimplify_expr (expr_p
, pre_p
, post_p
);
9534 return (enum gimplify_status
) c_gimplify_expr (expr_p
, pre_p
, post_p
);
9538 /* --- FAST ENUMERATION --- */
9539 /* Begin code generation for fast enumeration (foreach) ... */
9543 struct __objcFastEnumerationState
9545 unsigned long state;
9547 unsigned long *mutationsPtr;
9548 unsigned long extra[5];
9551 Confusingly enough, NSFastEnumeration is then defined by libraries
9552 to be the same structure.
9556 build_fast_enumeration_state_template (void)
9558 tree decls
, *chain
= NULL
;
9561 objc_fast_enumeration_state_template
= objc_start_struct (get_identifier
9562 (TAG_FAST_ENUMERATION_STATE
));
9564 /* unsigned long state; */
9565 decls
= add_field_decl (long_unsigned_type_node
, "state", &chain
);
9568 add_field_decl (build_pointer_type (objc_object_type
),
9569 "itemsPtr", &chain
);
9571 /* unsigned long *mutationsPtr; */
9572 add_field_decl (build_pointer_type (long_unsigned_type_node
),
9573 "mutationsPtr", &chain
);
9575 /* unsigned long extra[5]; */
9576 add_field_decl (build_sized_array_type (long_unsigned_type_node
, 5),
9580 objc_finish_struct (objc_fast_enumeration_state_template
, decls
);
9584 'objc_finish_foreach_loop()' generates the code for an Objective-C
9585 foreach loop. The 'location' argument is the location of the 'for'
9586 that starts the loop. The 'object_expression' is the expression of
9587 the 'object' that iterates; the 'collection_expression' is the
9588 expression of the collection that we iterate over (we need to make
9589 sure we evaluate this only once); the 'for_body' is the set of
9590 statements to be executed in each iteration; 'break_label' and
9591 'continue_label' are the break and continue labels which we need to
9592 emit since the <statements> may be jumping to 'break_label' (if they
9593 contain 'break') or to 'continue_label' (if they contain
9598 for (<object expression> in <collection expression>)
9601 which is compiled into the following blurb:
9604 id __objc_foreach_collection;
9605 __objc_fast_enumeration_state __objc_foreach_enum_state;
9606 unsigned long __objc_foreach_batchsize;
9607 id __objc_foreach_items[16];
9608 __objc_foreach_collection = <collection expression>;
9609 __objc_foreach_enum_state = { 0 };
9610 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
9612 if (__objc_foreach_batchsize == 0)
9613 <object expression> = nil;
9616 unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr;
9619 unsigned long __objc_foreach_index;
9620 __objc_foreach_index = 0;
9623 if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>);
9624 <object expression> = enumState.itemsPtr[__objc_foreach_index];
9625 <statements> [PS: inside <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label]
9628 __objc_foreach_index++;
9629 if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object;
9630 __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16];
9632 if (__objc_foreach_batchsize != 0) goto next_batch;
9633 <object expression> = nil;
9638 'statements' may contain a 'continue' or 'break' instruction, which
9639 the user expects to 'continue' or 'break' the entire foreach loop.
9640 We are provided the labels that 'break' and 'continue' jump to, so
9641 we place them where we want them to jump to when they pick them.
9643 Optimization TODO: we could cache the IMP of
9644 countByEnumeratingWithState:objects:count:.
9647 /* If you need to debug objc_finish_foreach_loop(), uncomment the following line. */
9648 /* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */
9650 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
9651 #include "tree-pretty-print.h"
9655 objc_finish_foreach_loop (location_t location
, tree object_expression
, tree collection_expression
, tree for_body
,
9656 tree break_label
, tree continue_label
)
9658 /* A tree representing the __objcFastEnumerationState struct type,
9659 or NSFastEnumerationState struct, whatever we are using. */
9660 tree objc_fast_enumeration_state_type
;
9662 /* The trees representing the declarations of each of the local variables. */
9663 tree objc_foreach_collection_decl
;
9664 tree objc_foreach_enum_state_decl
;
9665 tree objc_foreach_items_decl
;
9666 tree objc_foreach_batchsize_decl
;
9667 tree objc_foreach_mutations_pointer_decl
;
9668 tree objc_foreach_index_decl
;
9670 /* A tree representing the selector countByEnumeratingWithState:objects:count:. */
9673 /* A tree representing the local bind. */
9676 /* A tree representing the external 'if (__objc_foreach_batchsize)' */
9679 /* A tree representing the 'else' part of 'first_if' */
9682 /* A tree representing the 'next_batch' label. */
9683 tree next_batch_label_decl
;
9685 /* A tree representing the binding after the 'next_batch' label. */
9686 tree next_batch_bind
;
9688 /* A tree representing the 'next_object' label. */
9689 tree next_object_label_decl
;
9691 /* Temporary variables. */
9695 if (flag_objc1_only
)
9696 error_at (location
, "fast enumeration is not available in Objective-C 1.0");
9698 if (object_expression
== error_mark_node
)
9701 if (collection_expression
== error_mark_node
)
9704 if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression
), true))
9706 error_at (location
, "iterating variable in fast enumeration is not an object");
9710 if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression
), true))
9712 error_at (location
, "collection in fast enumeration is not an object");
9716 /* TODO: Check that object_expression is either a variable
9717 declaration, or an lvalue. */
9719 /* This kludge is an idea from apple. We use the
9720 __objcFastEnumerationState struct implicitly defined by the
9721 compiler, unless a NSFastEnumerationState struct has been defined
9722 (by a Foundation library such as GNUstep Base) in which case, we
9725 objc_fast_enumeration_state_type
= objc_fast_enumeration_state_template
;
9727 tree objc_NSFastEnumeration_type
= lookup_name (get_identifier ("NSFastEnumerationState"));
9729 if (objc_NSFastEnumeration_type
)
9731 /* TODO: We really need to check that
9732 objc_NSFastEnumeration_type is the same as ours! */
9733 if (TREE_CODE (objc_NSFastEnumeration_type
) == TYPE_DECL
)
9735 /* If it's a typedef, use the original type. */
9736 if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type
))
9737 objc_fast_enumeration_state_type
= DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type
);
9739 objc_fast_enumeration_state_type
= TREE_TYPE (objc_NSFastEnumeration_type
);
9745 /* Done by c-parser.c. */
9748 /* Done by c-parser.c. */
9750 /* Disable warnings that 'object' is unused. For example the code
9752 for (id object in collection)
9755 which can be used to count how many objects there are in the
9756 collection is fine and should generate no warnings even if
9757 'object' is technically unused. */
9758 TREE_USED (object_expression
) = 1;
9759 if (DECL_P (object_expression
))
9760 DECL_READ_P (object_expression
) = 1;
9762 /* id __objc_foreach_collection */
9763 objc_foreach_collection_decl
= objc_create_temporary_var (objc_object_type
, "__objc_foreach_collection");
9765 /* __objcFastEnumerationState __objc_foreach_enum_state; */
9766 objc_foreach_enum_state_decl
= objc_create_temporary_var (objc_fast_enumeration_state_type
, "__objc_foreach_enum_state");
9767 TREE_CHAIN (objc_foreach_enum_state_decl
) = objc_foreach_collection_decl
;
9769 /* id __objc_foreach_items[16]; */
9770 objc_foreach_items_decl
= objc_create_temporary_var (build_sized_array_type (objc_object_type
, 16), "__objc_foreach_items");
9771 TREE_CHAIN (objc_foreach_items_decl
) = objc_foreach_enum_state_decl
;
9773 /* unsigned long __objc_foreach_batchsize; */
9774 objc_foreach_batchsize_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_batchsize");
9775 TREE_CHAIN (objc_foreach_batchsize_decl
) = objc_foreach_items_decl
;
9777 /* Generate the local variable binding. */
9778 bind
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_batchsize_decl
, NULL
, NULL
);
9779 SET_EXPR_LOCATION (bind
, location
);
9780 TREE_SIDE_EFFECTS (bind
) = 1;
9782 /* __objc_foreach_collection = <collection expression>; */
9783 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_collection_decl
, collection_expression
);
9784 SET_EXPR_LOCATION (t
, location
);
9785 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9786 /* We have used 'collection_expression'. */
9787 mark_exp_read (collection_expression
);
9789 /* __objc_foreach_enum_state.state = 0; */
9790 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9791 get_identifier ("state")),
9792 build_int_cst (long_unsigned_type_node
, 0));
9793 SET_EXPR_LOCATION (t
, location
);
9794 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9796 /* __objc_foreach_enum_state.itemsPtr = NULL; */
9797 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9798 get_identifier ("itemsPtr")),
9800 SET_EXPR_LOCATION (t
, location
);
9801 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9803 /* __objc_foreach_enum_state.mutationsPtr = NULL; */
9804 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9805 get_identifier ("mutationsPtr")),
9807 SET_EXPR_LOCATION (t
, location
);
9808 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9810 /* __objc_foreach_enum_state.extra[0] = 0; */
9811 /* __objc_foreach_enum_state.extra[1] = 0; */
9812 /* __objc_foreach_enum_state.extra[2] = 0; */
9813 /* __objc_foreach_enum_state.extra[3] = 0; */
9814 /* __objc_foreach_enum_state.extra[4] = 0; */
9815 for (i
= 0; i
< 5 ; i
++)
9817 t
= build2 (MODIFY_EXPR
, void_type_node
,
9818 build_array_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9819 get_identifier ("extra")),
9820 build_int_cst (NULL_TREE
, i
)),
9821 build_int_cst (long_unsigned_type_node
, 0));
9822 SET_EXPR_LOCATION (t
, location
);
9823 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9826 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
9827 selector_name
= get_identifier ("countByEnumeratingWithState:objects:count:");
9829 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9831 tree_cons
/* &__objc_foreach_enum_state */
9832 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
9833 tree_cons
/* __objc_foreach_items */
9834 (NULL_TREE
, objc_foreach_items_decl
,
9836 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
9838 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
9840 struct c_expr array
;
9841 array
.value
= objc_foreach_items_decl
;
9842 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
9844 tree_cons
/* &__objc_foreach_enum_state */
9845 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
9846 tree_cons
/* __objc_foreach_items */
9847 (NULL_TREE
, default_function_array_conversion (location
, array
).value
,
9849 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
9852 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_batchsize_decl
,
9853 convert (long_unsigned_type_node
, t
));
9854 SET_EXPR_LOCATION (t
, location
);
9855 append_to_statement_list (t
, &BIND_EXPR_BODY (bind
));
9857 /* if (__objc_foreach_batchsize == 0) */
9858 first_if
= build3 (COND_EXPR
, void_type_node
,
9861 (c_common_truthvalue_conversion
9863 build_binary_op (location
,
9865 objc_foreach_batchsize_decl
,
9866 build_int_cst (long_unsigned_type_node
, 0), 1)),
9868 /* Then block (we fill it in later). */
9870 /* Else block (we fill it in later). */
9872 SET_EXPR_LOCATION (first_if
, location
);
9873 append_to_statement_list (first_if
, &BIND_EXPR_BODY (bind
));
9875 /* then <object expression> = nil; */
9876 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
, convert (objc_object_type
, null_pointer_node
));
9877 SET_EXPR_LOCATION (t
, location
);
9878 COND_EXPR_THEN (first_if
) = t
;
9880 /* Now we build the 'else' part of the if; once we finish building
9881 it, we attach it to first_if as the 'else' part. */
9886 /* unsigned long __objc_foreach_mutations_pointer; */
9887 objc_foreach_mutations_pointer_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_mutations_pointer");
9889 /* Generate the local variable binding. */
9890 first_else
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_mutations_pointer_decl
, NULL
, NULL
);
9891 SET_EXPR_LOCATION (first_else
, location
);
9892 TREE_SIDE_EFFECTS (first_else
) = 1;
9894 /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */
9895 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_mutations_pointer_decl
,
9896 build_indirect_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9897 get_identifier ("mutationsPtr")),
9899 SET_EXPR_LOCATION (t
, location
);
9900 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
9903 next_batch_label_decl
= create_artificial_label (location
);
9904 t
= build1 (LABEL_EXPR
, void_type_node
, next_batch_label_decl
);
9905 SET_EXPR_LOCATION (t
, location
);
9906 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
9910 /* unsigned long __objc_foreach_index; */
9911 objc_foreach_index_decl
= objc_create_temporary_var (long_unsigned_type_node
, "__objc_foreach_index");
9913 /* Generate the local variable binding. */
9914 next_batch_bind
= build3 (BIND_EXPR
, void_type_node
, objc_foreach_index_decl
, NULL
, NULL
);
9915 SET_EXPR_LOCATION (next_batch_bind
, location
);
9916 TREE_SIDE_EFFECTS (next_batch_bind
) = 1;
9917 append_to_statement_list (next_batch_bind
, &BIND_EXPR_BODY (first_else
));
9919 /* __objc_foreach_index = 0; */
9920 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_index_decl
,
9921 build_int_cst (long_unsigned_type_node
, 0));
9922 SET_EXPR_LOCATION (t
, location
);
9923 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9926 next_object_label_decl
= create_artificial_label (location
);
9927 t
= build1 (LABEL_EXPR
, void_type_node
, next_object_label_decl
);
9928 SET_EXPR_LOCATION (t
, location
);
9929 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9931 /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (<collection expression>); */
9932 t
= build3 (COND_EXPR
, void_type_node
,
9935 (c_common_truthvalue_conversion
9940 objc_foreach_mutations_pointer_decl
,
9941 build_indirect_ref (location
,
9942 objc_build_component_ref (objc_foreach_enum_state_decl
,
9943 get_identifier ("mutationsPtr")),
9944 RO_UNARY_STAR
), 1)),
9947 build_function_call (input_location
,
9948 objc_enumeration_mutation_decl
,
9949 tree_cons (NULL
, collection_expression
, NULL
)),
9952 SET_EXPR_LOCATION (t
, location
);
9953 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9955 /* <object expression> = enumState.itemsPtr[__objc_foreach_index]; */
9956 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
,
9957 build_array_ref (location
, objc_build_component_ref (objc_foreach_enum_state_decl
,
9958 get_identifier ("itemsPtr")),
9959 objc_foreach_index_decl
));
9960 SET_EXPR_LOCATION (t
, location
);
9961 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9963 /* <statements> [PS: in <statments>, 'break' jumps to break_label and 'continue' jumps to continue_label] */
9964 append_to_statement_list (for_body
, &BIND_EXPR_BODY (next_batch_bind
));
9966 /* continue_label: */
9969 t
= build1 (LABEL_EXPR
, void_type_node
, continue_label
);
9970 SET_EXPR_LOCATION (t
, location
);
9971 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9974 /* __objc_foreach_index++; */
9975 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_index_decl
,
9976 build_binary_op (location
,
9978 objc_foreach_index_decl
,
9979 build_int_cst (long_unsigned_type_node
, 1), 1));
9980 SET_EXPR_LOCATION (t
, location
);
9981 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
9983 /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */
9984 t
= build3 (COND_EXPR
, void_type_node
,
9987 (c_common_truthvalue_conversion
9989 build_binary_op (location
,
9991 objc_foreach_index_decl
,
9992 objc_foreach_batchsize_decl
, 1)),
9995 build1 (GOTO_EXPR
, void_type_node
, next_object_label_decl
),
9998 SET_EXPR_LOCATION (t
, location
);
9999 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
10001 /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */
10003 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
10005 tree_cons
/* &__objc_foreach_enum_state */
10006 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
10007 tree_cons
/* __objc_foreach_items */
10008 (NULL_TREE
, objc_foreach_items_decl
,
10010 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
10012 /* In C, we need to decay the __objc_foreach_items array that we are passing. */
10014 struct c_expr array
;
10015 array
.value
= objc_foreach_items_decl
;
10016 t
= objc_finish_message_expr (objc_foreach_collection_decl
, selector_name
,
10018 tree_cons
/* &__objc_foreach_enum_state */
10019 (NULL_TREE
, build_fold_addr_expr_loc (location
, objc_foreach_enum_state_decl
),
10020 tree_cons
/* __objc_foreach_items */
10021 (NULL_TREE
, default_function_array_conversion (location
, array
).value
,
10023 (NULL_TREE
, build_int_cst (NULL_TREE
, 16), NULL_TREE
))), NULL
);
10026 t
= build2 (MODIFY_EXPR
, void_type_node
, objc_foreach_batchsize_decl
,
10027 convert (long_unsigned_type_node
, t
));
10028 SET_EXPR_LOCATION (t
, location
);
10029 append_to_statement_list (t
, &BIND_EXPR_BODY (next_batch_bind
));
10033 /* if (__objc_foreach_batchsize != 0) goto next_batch; */
10034 t
= build3 (COND_EXPR
, void_type_node
,
10037 (c_common_truthvalue_conversion
10039 build_binary_op (location
,
10041 objc_foreach_batchsize_decl
,
10042 build_int_cst (long_unsigned_type_node
, 0), 1)),
10045 build1 (GOTO_EXPR
, void_type_node
, next_batch_label_decl
),
10048 SET_EXPR_LOCATION (t
, location
);
10049 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10051 /* <object expression> = nil; */
10052 t
= build2 (MODIFY_EXPR
, void_type_node
, object_expression
, convert (objc_object_type
, null_pointer_node
));
10053 SET_EXPR_LOCATION (t
, location
);
10054 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10059 t
= build1 (LABEL_EXPR
, void_type_node
, break_label
);
10060 SET_EXPR_LOCATION (t
, location
);
10061 append_to_statement_list (t
, &BIND_EXPR_BODY (first_else
));
10065 COND_EXPR_ELSE (first_if
) = first_else
;
10067 /* Do the whole thing. */
10070 #ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP
10071 /* This will print to stderr the whole blurb generated by the
10072 compiler while compiling (assuming the compiler doesn't crash
10073 before getting here).
10075 debug_generic_stmt (bind
);
10079 /* Done by c-parser.c */
10082 /* --- SUPPORT FOR FORMAT ARG CHECKING --- */
10083 /* Return true if we have an NxString object pointer. */
10086 objc_string_ref_type_p (tree strp
)
10089 if (!strp
|| TREE_CODE (strp
) != POINTER_TYPE
)
10092 tmv
= TYPE_MAIN_VARIANT (TREE_TYPE (strp
));
10093 tmv
= OBJC_TYPE_NAME (tmv
);
10095 && TREE_CODE (tmv
) == IDENTIFIER_NODE
10096 && IDENTIFIER_POINTER (tmv
)
10097 && !strncmp (IDENTIFIER_POINTER (tmv
), "NSString", 8));
10100 /* At present the behavior of this is undefined and it does nothing. */
10102 objc_check_format_arg (tree
ARG_UNUSED (format_arg
),
10103 tree
ARG_UNUSED (args_list
))
10107 /* --- Encode --- */
10108 /* "Encode" a data type into a string, which grows in util_obstack.
10110 The format is described in gcc/doc/objc.texi, section 'Type
10113 Most of the encode_xxx functions have a 'type' argument, which is
10114 the type to encode, and an integer 'curtype' argument, which is the
10115 index in the encoding string of the beginning of the encoding of
10116 the current type, and allows you to find what characters have
10117 already been written for the current type (they are the ones in the
10118 current encoding string starting from 'curtype').
10120 For example, if we are encoding a method which returns 'int' and
10121 takes a 'char **' argument, then when we get to the point of
10122 encoding the 'char **' argument, the encoded string already
10123 contains 'i12@0:4' (assuming a pointer size of 4 bytes). So,
10124 'curtype' will be set to 7 when starting to encode 'char **'.
10125 During the whole of the encoding of 'char **', 'curtype' will be
10126 fixed at 7, so the routine encoding the second pointer can find out
10127 that it's actually encoding a pointer to a pointer by looking
10128 backwards at what has already been encoded for the current type,
10129 and seeing there is a "^" (meaning a pointer) in there.
10133 /* Encode type qualifiers encodes one of the "PQ" Objective-C
10134 keywords, ie 'in', 'out', 'inout', 'bycopy', 'byref', 'oneway'.
10135 'const', instead, is encoded directly as part of the type.
10139 encode_type_qualifiers (tree declspecs
)
10143 for (spec
= declspecs
; spec
; spec
= TREE_CHAIN (spec
))
10145 /* FIXME: Shouldn't we use token->keyword here ? */
10146 if (ridpointers
[(int) RID_IN
] == TREE_VALUE (spec
))
10147 obstack_1grow (&util_obstack
, 'n');
10148 else if (ridpointers
[(int) RID_INOUT
] == TREE_VALUE (spec
))
10149 obstack_1grow (&util_obstack
, 'N');
10150 else if (ridpointers
[(int) RID_OUT
] == TREE_VALUE (spec
))
10151 obstack_1grow (&util_obstack
, 'o');
10152 else if (ridpointers
[(int) RID_BYCOPY
] == TREE_VALUE (spec
))
10153 obstack_1grow (&util_obstack
, 'O');
10154 else if (ridpointers
[(int) RID_BYREF
] == TREE_VALUE (spec
))
10155 obstack_1grow (&util_obstack
, 'R');
10156 else if (ridpointers
[(int) RID_ONEWAY
] == TREE_VALUE (spec
))
10157 obstack_1grow (&util_obstack
, 'V');
10159 gcc_unreachable ();
10163 /* Determine if a pointee is marked read-only. Only used by the NeXT
10164 runtime to be compatible with gcc-3.3. */
10167 pointee_is_readonly (tree pointee
)
10169 while (POINTER_TYPE_P (pointee
))
10170 pointee
= TREE_TYPE (pointee
);
10172 return TYPE_READONLY (pointee
);
10175 /* Encode a pointer type. */
10178 encode_pointer (tree type
, int curtype
, int format
)
10180 tree pointer_to
= TREE_TYPE (type
);
10182 if (flag_next_runtime
)
10184 /* This code is used to be compatible with gcc-3.3. */
10185 /* For historical/compatibility reasons, the read-only qualifier
10186 of the pointee gets emitted _before_ the '^'. The read-only
10187 qualifier of the pointer itself gets ignored, _unless_ we are
10188 looking at a typedef! Also, do not emit the 'r' for anything
10189 but the outermost type! */
10190 if (!generating_instance_variables
10191 && (obstack_object_size (&util_obstack
) - curtype
<= 1)
10192 && (TYPE_NAME (type
) && TREE_CODE (TYPE_NAME (type
)) == TYPE_DECL
10193 ? TYPE_READONLY (type
)
10194 : pointee_is_readonly (pointer_to
)))
10195 obstack_1grow (&util_obstack
, 'r');
10198 if (TREE_CODE (pointer_to
) == RECORD_TYPE
)
10200 if (OBJC_TYPE_NAME (pointer_to
)
10201 && TREE_CODE (OBJC_TYPE_NAME (pointer_to
)) == IDENTIFIER_NODE
)
10203 const char *name
= IDENTIFIER_POINTER (OBJC_TYPE_NAME (pointer_to
));
10205 if (strcmp (name
, TAG_OBJECT
) == 0) /* '@' */
10207 obstack_1grow (&util_obstack
, '@');
10210 else if (TYPE_HAS_OBJC_INFO (pointer_to
)
10211 && TYPE_OBJC_INTERFACE (pointer_to
))
10213 if (generating_instance_variables
)
10215 obstack_1grow (&util_obstack
, '@');
10216 obstack_1grow (&util_obstack
, '"');
10217 obstack_grow (&util_obstack
, name
, strlen (name
));
10218 obstack_1grow (&util_obstack
, '"');
10223 obstack_1grow (&util_obstack
, '@');
10227 else if (strcmp (name
, TAG_CLASS
) == 0) /* '#' */
10229 obstack_1grow (&util_obstack
, '#');
10232 else if (strcmp (name
, TAG_SELECTOR
) == 0) /* ':' */
10234 obstack_1grow (&util_obstack
, ':');
10239 else if (TREE_CODE (pointer_to
) == INTEGER_TYPE
10240 && TYPE_MODE (pointer_to
) == QImode
)
10242 tree pname
= TREE_CODE (OBJC_TYPE_NAME (pointer_to
)) == IDENTIFIER_NODE
10243 ? OBJC_TYPE_NAME (pointer_to
)
10244 : DECL_NAME (OBJC_TYPE_NAME (pointer_to
));
10246 /* (BOOL *) are an exception and are encoded as ^c, while all
10247 other pointers to char are encoded as *. */
10248 if (strcmp (IDENTIFIER_POINTER (pname
), "BOOL"))
10250 if (!flag_next_runtime
)
10252 /* The NeXT runtime adds the 'r' before getting here. */
10254 /* It appears that "r*" means "const char *" rather than
10255 "char *const". "char *const" is encoded as "*",
10256 which is identical to "char *", so the "const" is
10257 unfortunately lost. */
10258 if (TYPE_READONLY (pointer_to
))
10259 obstack_1grow (&util_obstack
, 'r');
10262 obstack_1grow (&util_obstack
, '*');
10267 /* We have a normal pointer type that does not get special treatment. */
10268 obstack_1grow (&util_obstack
, '^');
10269 encode_type (pointer_to
, curtype
, format
);
10273 encode_array (tree type
, int curtype
, int format
)
10275 tree an_int_cst
= TYPE_SIZE (type
);
10276 tree array_of
= TREE_TYPE (type
);
10279 if (an_int_cst
== NULL
)
10281 /* We are trying to encode an incomplete array. An incomplete
10282 array is forbidden as part of an instance variable; but it
10283 may occur if the instance variable is a pointer to such an
10286 /* So the only case in which an incomplete array could occur
10287 (without being pointed to) is if we are encoding the
10288 arguments or return value of a method. In that case, an
10289 incomplete array argument or return value (eg,
10290 -(void)display: (char[])string) is treated like a pointer
10291 because that is how the compiler does the function call. A
10292 special, more complicated case, is when the incomplete array
10293 is the last member of a struct (eg, if we are encoding
10294 "struct { unsigned long int a;double b[];}"), which is again
10295 part of a method argument/return value. In that case, we
10296 really need to communicate to the runtime that there is an
10297 incomplete array (not a pointer!) there. So, we detect that
10298 special case and encode it as a zero-length array.
10300 Try to detect that we are part of a struct. We do this by
10301 searching for '=' in the type encoding for the current type.
10302 NB: This hack assumes that you can't use '=' as part of a C
10306 char *enc
= obstack_base (&util_obstack
) + curtype
;
10307 if (memchr (enc
, '=',
10308 obstack_object_size (&util_obstack
) - curtype
) == NULL
)
10310 /* We are not inside a struct. Encode the array as a
10312 encode_pointer (type
, curtype
, format
);
10317 /* Else, we are in a struct, and we encode it as a zero-length
10319 sprintf (buffer
, "[" HOST_WIDE_INT_PRINT_DEC
, (HOST_WIDE_INT
)0);
10321 else if (TREE_INT_CST_LOW (TYPE_SIZE (array_of
)) == 0)
10322 sprintf (buffer
, "[" HOST_WIDE_INT_PRINT_DEC
, (HOST_WIDE_INT
)0);
10324 sprintf (buffer
, "[" HOST_WIDE_INT_PRINT_DEC
,
10325 TREE_INT_CST_LOW (an_int_cst
)
10326 / TREE_INT_CST_LOW (TYPE_SIZE (array_of
)));
10328 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
10329 encode_type (array_of
, curtype
, format
);
10330 obstack_1grow (&util_obstack
, ']');
10334 /* Encode a vector. The vector type is a GCC extension to C. */
10336 encode_vector (tree type
, int curtype
, int format
)
10338 tree vector_of
= TREE_TYPE (type
);
10341 /* Vectors are like simple fixed-size arrays. */
10343 /* Output ![xx,yy,<code>] where xx is the vector_size, yy is the
10344 alignment of the vector, and <code> is the base type. Eg, int
10345 __attribute__ ((vector_size (16))) gets encoded as ![16,32,i]
10346 assuming that the alignment is 32 bytes. We include size and
10347 alignment in bytes so that the runtime does not have to have any
10348 knowledge of the actual types.
10350 sprintf (buffer
, "![" HOST_WIDE_INT_PRINT_DEC
",%d",
10351 /* We want to compute the equivalent of sizeof (<vector>).
10352 Code inspired by c_sizeof_or_alignof_type. */
10353 ((TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type
))
10354 / (TYPE_PRECISION (char_type_node
) / BITS_PER_UNIT
))),
10355 /* We want to compute the equivalent of __alignof__
10356 (<vector>). Code inspired by
10357 c_sizeof_or_alignof_type. */
10358 TYPE_ALIGN_UNIT (type
));
10359 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
10360 encode_type (vector_of
, curtype
, format
);
10361 obstack_1grow (&util_obstack
, ']');
10366 encode_aggregate_fields (tree type
, bool pointed_to
, int curtype
, int format
)
10368 tree field
= TYPE_FIELDS (type
);
10370 for (; field
; field
= DECL_CHAIN (field
))
10373 /* C++ static members, and things that are not field at all,
10374 should not appear in the encoding. */
10375 if (TREE_CODE (field
) != FIELD_DECL
|| TREE_STATIC (field
))
10379 /* Recursively encode fields of embedded base classes. */
10380 if (DECL_ARTIFICIAL (field
) && !DECL_NAME (field
)
10381 && TREE_CODE (TREE_TYPE (field
)) == RECORD_TYPE
)
10383 encode_aggregate_fields (TREE_TYPE (field
),
10384 pointed_to
, curtype
, format
);
10388 if (generating_instance_variables
&& !pointed_to
)
10390 tree fname
= DECL_NAME (field
);
10392 obstack_1grow (&util_obstack
, '"');
10394 if (fname
&& TREE_CODE (fname
) == IDENTIFIER_NODE
)
10395 obstack_grow (&util_obstack
,
10396 IDENTIFIER_POINTER (fname
),
10397 strlen (IDENTIFIER_POINTER (fname
)));
10399 obstack_1grow (&util_obstack
, '"');
10402 encode_field_decl (field
, curtype
, format
);
10407 encode_aggregate_within (tree type
, int curtype
, int format
, int left
,
10411 /* NB: aggregates that are pointed to have slightly different encoding
10412 rules in that you never encode the names of instance variables. */
10413 int ob_size
= obstack_object_size (&util_obstack
);
10414 bool inline_contents
= false;
10415 bool pointed_to
= false;
10417 if (flag_next_runtime
)
10419 if (ob_size
> 0 && *(obstack_next_free (&util_obstack
) - 1) == '^')
10422 if ((format
== OBJC_ENCODE_INLINE_DEFS
|| generating_instance_variables
)
10423 && (!pointed_to
|| ob_size
- curtype
== 1
10424 || (ob_size
- curtype
== 2
10425 && *(obstack_next_free (&util_obstack
) - 2) == 'r')))
10426 inline_contents
= true;
10430 /* c0 and c1 are the last two characters in the encoding of the
10431 current type; if the last two characters were '^' or '^r',
10432 then we are encoding an aggregate that is "pointed to". The
10433 comment above applies: in that case we should avoid encoding
10434 the names of instance variables.
10436 char c1
= ob_size
> 1 ? *(obstack_next_free (&util_obstack
) - 2) : 0;
10437 char c0
= ob_size
> 0 ? *(obstack_next_free (&util_obstack
) - 1) : 0;
10439 if (c0
== '^' || (c1
== '^' && c0
== 'r'))
10442 if (format
== OBJC_ENCODE_INLINE_DEFS
|| generating_instance_variables
)
10445 inline_contents
= true;
10448 /* Note that the check (ob_size - curtype < 2) prevents
10449 infinite recursion when encoding a structure which is
10450 a linked list (eg, struct node { struct node *next;
10451 }). Each time we follow a pointer, we add one
10452 character to ob_size, and curtype is fixed, so after
10453 at most two pointers we stop inlining contents and
10456 The other case where we don't inline is "^r", which
10457 is a pointer to a constant struct.
10459 if ((ob_size
- curtype
<= 2) && !(c0
== 'r'))
10460 inline_contents
= true;
10465 /* Traverse struct aliases; it is important to get the
10466 original struct and its tag name (if any). */
10467 type
= TYPE_MAIN_VARIANT (type
);
10468 name
= OBJC_TYPE_NAME (type
);
10469 /* Open parenth/bracket. */
10470 obstack_1grow (&util_obstack
, left
);
10472 /* Encode the struct/union tag name, or '?' if a tag was
10473 not provided. Typedef aliases do not qualify. */
10475 /* For compatibility with the NeXT runtime, ObjC++ encodes template
10476 args as a composite struct tag name. */
10477 if (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
10478 /* Did this struct have a tag? */
10479 && !TYPE_WAS_ANONYMOUS (type
))
10480 obstack_grow (&util_obstack
,
10481 decl_as_string (type
, TFF_DECL_SPECIFIERS
| TFF_UNQUALIFIED_NAME
),
10482 strlen (decl_as_string (type
, TFF_DECL_SPECIFIERS
| TFF_UNQUALIFIED_NAME
)));
10484 if (name
&& TREE_CODE (name
) == IDENTIFIER_NODE
)
10485 obstack_grow (&util_obstack
,
10486 IDENTIFIER_POINTER (name
),
10487 strlen (IDENTIFIER_POINTER (name
)));
10490 obstack_1grow (&util_obstack
, '?');
10492 /* Encode the types (and possibly names) of the inner fields,
10494 if (inline_contents
)
10496 obstack_1grow (&util_obstack
, '=');
10497 encode_aggregate_fields (type
, pointed_to
, curtype
, format
);
10499 /* Close parenth/bracket. */
10500 obstack_1grow (&util_obstack
, right
);
10503 /* Encode a bitfield NeXT-style (i.e., without a bit offset or the underlying
10507 encode_next_bitfield (int width
)
10510 sprintf (buffer
, "b%d", width
);
10511 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
10514 /* Encodes 'type', ignoring type qualifiers (which you should encode
10515 beforehand if needed) with the exception of 'const', which is
10516 encoded by encode_type. See above for the explanation of
10517 'curtype'. 'format' can be OBJC_ENCODE_INLINE_DEFS or
10518 OBJC_ENCODE_DONT_INLINE_DEFS.
10521 encode_type (tree type
, int curtype
, int format
)
10523 enum tree_code code
= TREE_CODE (type
);
10525 /* Ignore type qualifiers other than 'const' when encoding a
10528 if (type
== error_mark_node
)
10531 if (!flag_next_runtime
)
10533 if (TYPE_READONLY (type
))
10534 obstack_1grow (&util_obstack
, 'r');
10539 case ENUMERAL_TYPE
:
10540 if (flag_next_runtime
)
10542 /* Kludge for backwards-compatibility with gcc-3.3: enums
10543 are always encoded as 'i' no matter what type they
10544 actually are (!). */
10545 obstack_1grow (&util_obstack
, 'i');
10548 /* Else, they are encoded exactly like the integer type that is
10549 used by the compiler to store them. */
10553 switch (GET_MODE_BITSIZE (TYPE_MODE (type
)))
10555 case 8: c
= TYPE_UNSIGNED (type
) ? 'C' : 'c'; break;
10556 case 16: c
= TYPE_UNSIGNED (type
) ? 'S' : 's'; break;
10559 tree int_type
= type
;
10560 if (flag_next_runtime
)
10562 /* Another legacy kludge for compatiblity with
10563 gcc-3.3: 32-bit longs are encoded as 'l' or 'L',
10564 but not always. For typedefs, we need to use 'i'
10565 or 'I' instead if encoding a struct field, or a
10567 int_type
= ((!generating_instance_variables
10568 && (obstack_object_size (&util_obstack
)
10569 == (unsigned) curtype
))
10570 ? TYPE_MAIN_VARIANT (type
)
10573 if (int_type
== long_unsigned_type_node
10574 || int_type
== long_integer_type_node
)
10575 c
= TYPE_UNSIGNED (type
) ? 'L' : 'l';
10577 c
= TYPE_UNSIGNED (type
) ? 'I' : 'i';
10580 case 64: c
= TYPE_UNSIGNED (type
) ? 'Q' : 'q'; break;
10581 case 128: c
= TYPE_UNSIGNED (type
) ? 'T' : 't'; break;
10582 default: gcc_unreachable ();
10584 obstack_1grow (&util_obstack
, c
);
10590 /* Floating point types. */
10591 switch (GET_MODE_BITSIZE (TYPE_MODE (type
)))
10593 case 32: c
= 'f'; break;
10594 case 64: c
= 'd'; break;
10596 case 128: c
= 'D'; break;
10597 default: gcc_unreachable ();
10599 obstack_1grow (&util_obstack
, c
);
10603 obstack_1grow (&util_obstack
, 'v');
10607 obstack_1grow (&util_obstack
, 'B');
10611 encode_array (type
, curtype
, format
);
10616 case REFERENCE_TYPE
:
10618 encode_pointer (type
, curtype
, format
);
10622 encode_aggregate_within (type
, curtype
, format
, '{', '}');
10626 encode_aggregate_within (type
, curtype
, format
, '(', ')');
10629 case FUNCTION_TYPE
: /* '?' means an unknown type. */
10630 obstack_1grow (&util_obstack
, '?');
10634 /* A complex is encoded as 'j' followed by the inner type (eg,
10635 "_Complex int" is encoded as 'ji'). */
10636 obstack_1grow (&util_obstack
, 'j');
10637 encode_type (TREE_TYPE (type
), curtype
, format
);
10641 encode_vector (type
, curtype
, format
);
10645 warning (0, "unknown type %s found during Objective-C encoding",
10646 gen_type_name (type
));
10647 obstack_1grow (&util_obstack
, '?');
10651 if (flag_next_runtime
)
10653 /* Super-kludge. Some ObjC qualifier and type combinations need
10654 to be rearranged for compatibility with gcc-3.3. */
10655 if (code
== POINTER_TYPE
&& obstack_object_size (&util_obstack
) >= 3)
10657 char *enc
= obstack_base (&util_obstack
) + curtype
;
10659 /* Rewrite "in const" from "nr" to "rn". */
10660 if (curtype
>= 1 && !strncmp (enc
- 1, "nr", 2))
10661 strncpy (enc
- 1, "rn", 2);
10667 encode_gnu_bitfield (int position
, tree type
, int size
)
10669 enum tree_code code
= TREE_CODE (type
);
10671 char charType
= '?';
10673 /* This code is only executed for the GNU runtime, so we can ignore
10674 the NeXT runtime kludge of always encoding enums as 'i' no matter
10675 what integers they actually are. */
10676 if (code
== INTEGER_TYPE
|| code
== ENUMERAL_TYPE
)
10678 if (integer_zerop (TYPE_MIN_VALUE (type
)))
10679 /* Unsigned integer types. */
10681 switch (TYPE_MODE (type
))
10684 charType
= 'C'; break;
10686 charType
= 'S'; break;
10689 if (type
== long_unsigned_type_node
)
10696 charType
= 'Q'; break;
10698 gcc_unreachable ();
10702 /* Signed integer types. */
10704 switch (TYPE_MODE (type
))
10707 charType
= 'c'; break;
10709 charType
= 's'; break;
10712 if (type
== long_integer_type_node
)
10719 charType
= 'q'; break;
10721 gcc_unreachable ();
10727 /* Do not do any encoding, produce an error and keep going. */
10728 error ("trying to encode non-integer type as a bitfield");
10732 sprintf (buffer
, "b%d%c%d", position
, charType
, size
);
10733 obstack_grow (&util_obstack
, buffer
, strlen (buffer
));
10737 encode_field_decl (tree field_decl
, int curtype
, int format
)
10740 /* C++ static members, and things that are not fields at all,
10741 should not appear in the encoding. */
10742 if (TREE_CODE (field_decl
) != FIELD_DECL
|| TREE_STATIC (field_decl
))
10746 /* Generate the bitfield typing information, if needed. Note the difference
10747 between GNU and NeXT runtimes. */
10748 if (DECL_BIT_FIELD_TYPE (field_decl
))
10750 int size
= tree_low_cst (DECL_SIZE (field_decl
), 1);
10752 if (flag_next_runtime
)
10753 encode_next_bitfield (size
);
10755 encode_gnu_bitfield (int_bit_position (field_decl
),
10756 DECL_BIT_FIELD_TYPE (field_decl
), size
);
10759 encode_type (TREE_TYPE (field_decl
), curtype
, format
);
10762 /* This routine encodes the attribute of the input PROPERTY according
10763 to following formula:
10765 Property attributes are stored as a comma-delimited C string.
10766 Simple attributes such as readonly are encoded as single
10767 character. The parametrized attributes, getter=name and
10768 setter=name, are encoded as a single character followed by an
10769 identifier. Property types are also encoded as a parametrized
10770 attribute. The characters used to encode these attributes are
10771 defined by the following enumeration:
10773 enum PropertyAttributes {
10774 kPropertyReadOnly = 'R',
10775 kPropertyBycopy = 'C',
10776 kPropertyByref = '&',
10777 kPropertyDynamic = 'D',
10778 kPropertyGetter = 'G',
10779 kPropertySetter = 'S',
10780 kPropertyInstanceVariable = 'V',
10781 kPropertyType = 'T',
10782 kPropertyWeak = 'W',
10783 kPropertyStrong = 'P',
10784 kPropertyNonAtomic = 'N'
10787 objc_v2_encode_prop_attr (tree property
)
10789 const char *string
;
10790 tree type
= TREE_TYPE (property
);
10792 obstack_1grow (&util_obstack
, 'T');
10793 encode_type (type
, obstack_object_size (&util_obstack
),
10794 OBJC_ENCODE_INLINE_DEFS
);
10796 if (PROPERTY_READONLY (property
))
10797 obstack_grow (&util_obstack
, ",R", 2);
10799 switch (PROPERTY_ASSIGN_SEMANTICS (property
))
10801 case OBJC_PROPERTY_COPY
:
10802 obstack_grow (&util_obstack
, ",C", 2);
10804 case OBJC_PROPERTY_RETAIN
:
10805 obstack_grow (&util_obstack
, ",&", 2);
10807 case OBJC_PROPERTY_ASSIGN
:
10812 if (PROPERTY_DYNAMIC (property
))
10813 obstack_grow (&util_obstack
, ",D", 2);
10815 if (PROPERTY_NONATOMIC (property
))
10816 obstack_grow (&util_obstack
, ",N", 2);
10818 /* Here we want to encode the getter name, but only if it's not the
10820 if (PROPERTY_GETTER_NAME (property
) != PROPERTY_NAME (property
))
10822 obstack_grow (&util_obstack
, ",G", 2);
10823 string
= IDENTIFIER_POINTER (PROPERTY_GETTER_NAME (property
));
10824 obstack_grow (&util_obstack
, string
, strlen (string
));
10827 if (!PROPERTY_READONLY (property
))
10829 /* Here we want to encode the setter name, but only if it's not
10830 the standard one. */
10831 tree standard_setter
= get_identifier (objc_build_property_setter_name (PROPERTY_NAME (property
)));
10832 if (PROPERTY_SETTER_NAME (property
) != standard_setter
)
10834 obstack_grow (&util_obstack
, ",S", 2);
10835 string
= IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (property
));
10836 obstack_grow (&util_obstack
, string
, strlen (string
));
10840 /* TODO: Encode strong ('P'), weak ('W') for garbage collection. */
10842 if (!PROPERTY_DYNAMIC (property
))
10844 obstack_grow (&util_obstack
, ",V", 2);
10845 if (PROPERTY_IVAR_NAME (property
))
10846 string
= IDENTIFIER_POINTER (PROPERTY_IVAR_NAME (property
));
10848 string
= IDENTIFIER_POINTER (PROPERTY_NAME (property
));
10849 obstack_grow (&util_obstack
, string
, strlen (string
));
10852 /* NULL-terminate string. */
10853 obstack_1grow (&util_obstack
, 0);
10854 string
= XOBFINISH (&util_obstack
, char *);
10855 obstack_free (&util_obstack
, util_firstobj
);
10856 return get_identifier (string
);
10860 objc_common_init_ts (void)
10862 c_common_init_ts ();
10864 MARK_TS_DECL_NON_COMMON (CLASS_METHOD_DECL
);
10865 MARK_TS_DECL_NON_COMMON (INSTANCE_METHOD_DECL
);
10866 MARK_TS_DECL_NON_COMMON (KEYWORD_DECL
);
10867 MARK_TS_DECL_NON_COMMON (PROPERTY_DECL
);
10869 MARK_TS_COMMON (CLASS_INTERFACE_TYPE
);
10870 MARK_TS_COMMON (PROTOCOL_INTERFACE_TYPE
);
10871 MARK_TS_COMMON (CLASS_IMPLEMENTATION_TYPE
);
10873 MARK_TS_TYPED (MESSAGE_SEND_EXPR
);
10874 MARK_TS_TYPED (PROPERTY_REF
);
10877 #include "gt-objc-objc-act.h"