From 554fd8c5195424bdbcabf5de30fdc183aba391bd Mon Sep 17 00:00:00 2001 From: upstream source tree Date: Sun, 15 Mar 2015 20:14:05 -0400 Subject: obtained gcc-4.6.4.tar.bz2 from upstream website; verified gcc-4.6.4.tar.bz2.sig; imported gcc-4.6.4 source tree from verified upstream tarball. downloading a git-generated archive based on the 'upstream' tag should provide you with a source tree that is binary identical to the one extracted from the above tarball. if you have obtained the source via the command 'git clone', however, do note that line-endings of files in your working directory might differ from line-endings of the respective files in the upstream repository. --- gcc/objc/ChangeLog | 3011 +++++++++ gcc/objc/Make-lang.in | 171 + gcc/objc/config-lang.in | 39 + gcc/objc/lang-specs.h | 58 + gcc/objc/objc-act.c | 10575 +++++++++++++++++++++++++++++++ gcc/objc/objc-act.h | 746 +++ gcc/objc/objc-gnu-runtime-abi-01.c | 2269 +++++++ gcc/objc/objc-lang.c | 90 + gcc/objc/objc-next-metadata-tags.h | 172 + gcc/objc/objc-next-runtime-abi-01.c | 2984 +++++++++ gcc/objc/objc-next-runtime-abi-02.c | 3778 +++++++++++ gcc/objc/objc-runtime-hooks.h | 111 + gcc/objc/objc-runtime-shared-support.c | 736 +++ gcc/objc/objc-runtime-shared-support.h | 90 + gcc/objc/objc-tree.def | 77 + 15 files changed, 24907 insertions(+) create mode 100644 gcc/objc/ChangeLog create mode 100644 gcc/objc/Make-lang.in create mode 100644 gcc/objc/config-lang.in create mode 100644 gcc/objc/lang-specs.h create mode 100644 gcc/objc/objc-act.c create mode 100644 gcc/objc/objc-act.h create mode 100644 gcc/objc/objc-gnu-runtime-abi-01.c create mode 100644 gcc/objc/objc-lang.c create mode 100644 gcc/objc/objc-next-metadata-tags.h create mode 100644 gcc/objc/objc-next-runtime-abi-01.c create mode 100644 gcc/objc/objc-next-runtime-abi-02.c create mode 100644 gcc/objc/objc-runtime-hooks.h create mode 100644 gcc/objc/objc-runtime-shared-support.c create mode 100644 gcc/objc/objc-runtime-shared-support.h create mode 100644 gcc/objc/objc-tree.def (limited to 'gcc/objc') diff --git a/gcc/objc/ChangeLog b/gcc/objc/ChangeLog new file mode 100644 index 000000000..8069b6918 --- /dev/null +++ b/gcc/objc/ChangeLog @@ -0,0 +1,3011 @@ +2013-04-12 Release Manager + + * GCC 4.6.4 released. + +2012-03-01 Release Manager + + * GCC 4.6.3 released. + +2011-11-12 Iain Sandoe + + Backport from mainline + 2011-10-29 Iain Sandoe + + PR target/47997 + * objc-act.c (objc_build_string_object): Remove redundant second + call to fix_string_type (). Add a checking assert that we are, + indeed, passed a STRING_CST. + +2011-11-12 Iain Sandoe + + * objc-next-runtime-abi-01.c (objc_eh_personality): Use gcc personality + for Objective-C m32. + +2011-10-26 Release Manager + + * GCC 4.6.2 released. + +2011-06-27 Release Manager + + * GCC 4.6.1 released. + +2011-05-21 Nicola Pero + + Backport from mainline + 2011-05-21 Nicola Pero + + * config-lang.in (gtfiles): Updated order of files to fix building + when the gcc/cp directory is missing, as in the case of some + release tarballs. + +2011-03-25 Release Manager + + * GCC 4.6.0 released. + +2011-03-06 Joseph Myers + + * lang-specs.h: Match -save-temps* instead of -save-temps. + +2011-02-26 Nicola Pero + + * objc-act.c (objc_v2_encode_prop_attr): Rewritten. + +2011-02-23 Nicola Pero + + * objc-act.c (build_private_template): Do not copy the + CLASS_HAS_EXCEPTION_ATTR from the class to the struct. + * objc-act.h (CLASS_HAS_EXCEPTION_ATTR): Define using + TYPE_LANG_SLOT_0. + +2011-02-22 Nicola Pero + + PR objc/47832 + * objc-act.c (flexible_array_type_p): New. + (add_instance_variable): Produce an error if an instance variable + uses flexible array members. + (encode_array): Do not emit an error if encoding a flexible array + type while generating instance variables. + +2011-02-21 Mike Stump + + * Make-lang.in (check_objc_parallelize): Refine for 4 processor + machines. + +2011-02-20 Nicola Pero + + * objc-gnu-runtime-abi-01.c (TARGET_64BIT): Removed. Removed + usage of padding fields. Do not include tm.h. + * objc-act.c (objc_write_global_declaration): Set input_location + to BUILTINS_LOCATION while generating runtime metadata. + +2011-01-20 Nicola Pero + + PR objc/47784 + * objc-act.c (objc_maybe_build_modify_expr): If 'rhs' has side + effects, do not use a temporary variable. + +2011-01-19 Nicola Pero + + * objc-next-runtime-abi-01.c: Updated comments. + * objc-next-runtime-abi-02.c: Same. + +2011-01-19 Nicola Pero + + * objc-act.c (objc_init, generate_struct_by_value_array): Updated + comments. + +2011-01-19 Nicola Pero + + * objc-act.c: Updated comments. + * objc-next-runtime-abi-02.c: Same. + * objc-runtime-shared-support.c: Same. + * objc-runtime-hooks.h: Same. + * objc-act.h: Same. + * objc-gnu-runtime-abi-01.c: Same. + +2011-01-19 Nicola Pero + + * objc-gnu-runtime-abi-01.c (objc_generate_v1_gnu_metadata): Do + not generate metadata if there is nothing to put into it. + +2011-02-17 Iain Sandoe + + * config-lang.in (gtfiles): Updated. + * Make-lang.in (START_HDRS): New. + (OBJC_OBJS): Added new object files. + (objc/objc-act.o): Updated prerequisites. + (objc/objc-lang.o): Updated prerequisites. + (objc/objc-runtime-shared-support.o): New. + (objc/objc-gnu-runtime-abi-01.o): New. + (objc/objc-next-runtime-abi-01.o): New. + (objc/objc-next-runtime-abi-02.o): New. + * objc-runtime-hooks.h: New. + * objc-runtime-shared-support.h: New. + * objc-runtime-shared-support.c: New. + * objc-gnu-runtime-abi-01.c: New. + * objc-next-metadata-tags.h: New. + * objc-next-runtime-abi-01.c: New. + * objc-next-runtime-abi-02.c: New. + * objc-lang.c: Include c-lang.h. + (LANG_HOOKS_EH_PERSONALITY): Removed. + * objc-act.h: Moved many declarations and code from objc-act.c + into objc-act.h to make them available outside objc-act.c. + (objc_eh_runtime_type): Removed. + (objc_eh_personality): Removed. + (CLASS_HAS_EXCEPTION_ATTR): New. + (OCTI_SUPER_SUPERFIELD_ID): New. + (OCTI_V1_PROP_LIST_TEMPL): New. + (OCTI_V1_PROP_NAME_ATTR_CHAIN): New. + (super_superclassfield_id): New. + (objc_prop_list_ptr): New. + (prop_names_attr_chain): New. + * objc-act.c: Include new runtime headers. Moved many #defines + and declarations into objc-act.h and + objc-runtime-shared-support.h. Made some corresponding functions + non-static, and moved some others into + objc-runtime-shared-support.c. Moved metadata generation code + into the new runtime hook files. + (ivar_offset_hash_list): New. + (objc_init): Call generate_struct_value_by_array() before doing + any runtime initialization. Create the appropriate runtime hook + structures. + (init_objc): Removed. Code moved directly into objc_init. + (finish_objc): Removed. Code moved directly into + objc_write_global_declarations. + (objc_write_global_declarations): Do the warn_selector checks + before emitting metadata. Use a runtime hook to emit the + metadata. Do not emit the metadata or do -gen-decls processing if + -fsyntax-only or we are producing a PCH. + (build_objc_exception_stuff): Renamed to + build_common_objc_exception_stuff. Remove TREE_NOTHROW flag from + objc_exception_throw_decl. + (synth_module_prologue): Call runtime initialize hook instead of + building runtime declarations here. Use the + default_constant_string_class_name runtime hook to set the + constant string class name. + (objc_build_string_object): Call the setup_const_string_class_decl + runtime hook instead of setup_string_decl. Call the + build_const_string_constructor runtime hook instead of building + the string object here. + (get_objc_string_decl): Added prop_names_attr case. Removed + gcc_unreachable() at the end. + (objc_begin_catch_clause): Distinguish between @catch (...) and + @catch (id x). Call the begin_catch runtime hook instead of + building the CATCH_EXPR here. + (objc_finish_catch_clause): Call the finish_catch runtime hook + instead of adding the catch here. + (objc_finish_try_stmt): Call the finish_try_stmt runtime hook + instead of doing it here. + (objc_build_throw_stmt): Bail out early for error_mark_node. Call + the build_exc_ptr runtime hook instead of objc_build_exc_ptr. + Call the build_throw_stmt runtime hook instead of building the + throw call here. + (objc_generate_cxx_cdtors): Set has_cxx_cdtors for the GNU runtime + as well. + (get_arg_type_list): Call the get_arg_type_list_base runtime hook + instead of building the list of arguments here. + (receiver_is_class_object): Call the receiver_is_class_object + runtime hook instead of doing the check here. Call the + tag_getclass runtime hook instead of using TAG_GETCLASS. + (objc_finish_message_expr): Call the build_objc_method_call + runtime hook. + (objc_build_protocol_expr): Call the get_protocol_reference + runtime hook. + (objc_build_selector_expr): Call the build_selector_reference + runtime hook. + (build_ivar_reference): Call the build_ivar_reference runtime + hook. + (hash_init): Set up ivar_offset_hash_list. + (start_class): Recognize the objc_exception attribute and store + it. + (continue_class): Use the class_decl and metaclass_decl runtime + hooks. + (build_objc_property_accessor_helpers): Renamed to + build_common_objc_property_accessor_helpers. Do not build + objc_copyStruct_decl, objc_getPropertyStruct_decl and + objc_setPropertyStruct_decl. + (objc_synthesize_getter): Check what struct setter/getter helper + is available instead of checking the type of runtime. + (get_super_receiver): Use the super_superclassfield_ident runtime + hook. Added assert. Use the get_class_super_ref and + get_category_super_ref runtime hooks. + (objc_v2_encode_prop_attr): New. + +2011-01-17 Nicola Pero + + PR objc/47314 + * objc-act.c (finish_objc): When calling check_duplicates to check + duplicated instance methods, set 'is_class' to 0, not 1. + +2011-01-14 Ben Elliston + + PR 19162 + * objc-act.c (generate_struct_by_value_array): Do not output a + definition for struct_forward_array. + +2011-01-08 Iain Sandoe + + * objc-act.c (objc_finish_foreach_loop): Mark collection expression + as read. + +2011-01-02 H.J. Lu + + * objc-act.c (check_that_protocol_is_defined): Fix a typo. + +2011-01-02 Nicola Pero + + * objc-act.c (check_that_protocol_is_defined): New. + (lookup_protocol): Call check_that_protocol_is_defined. + +2010-12-30 Nicola Pero + + * objc-act.c (objc_types_are_equivalent): Fixed comparing protocol + lists. Check them two-ways to fix comparisons when one protocol + implements the other one, or when one list contains duplicated + protocols. + +2010-12-30 Nicola Pero + + * objc-act.c (objc_add_method): When emitting an error because a + method with the same name but conflicting types is found in the + same class or category interface, print a note with the location + of the original method. Also, improved the error message to + clearly state that the conflict is due to conflicting types, and + produce it for protocols as well. Emit an error if two identical + methods are declared in a protocol, but one is @required and the + other one is @optional. + +2010-12-30 Nicola Pero + + * objc-act.c (start_class): Warn when a class attribute is + ignored. + (objc_declare_protocols): Warn when a protocol attribute in a + protocol forward-declaration is ignored. + (start_protocol): Warn when a protocol attribute is ignored. + +2010-12-30 Nicola Pero + + * objc-act.c (objc_set_method_opt): Tidy up error messages. In + particular, explicitly mention whether the error is due to the + @optional or @required keyword instead of mentioning + "@optional/@required". + +2010-12-29 Nicola Pero + + PR objc/47118 + * objc-act.c (objc_build_synchronized): Check the argument of + @synchronized and emit an appropriate error if it is not a valid + Objective-C object. Deal gracefully with that case. Updated + comments and variable names. + +2010-12-29 Nicola Pero + + PR objc/47075 + * objc-act.h (PROPERTY_REF_DEPRECATED_GETTER): New. + * objc-tree.def (PROPERTY_REF): Increased the number of operands + from 3 to 4. + * objc-act.c (objc_finish_message_expr): Added optional argument + allowing to return the deprecated method prototype for deprecated + methods, instead of immediately emitting the deprecation warning. + (objc_maybe_build_component_ref): Do not warn for a deprecated + property. When building the getter call, get the deprecated + method prototype from objc_finish_message_expr() and put it into + the PROPERTY_REF. + (objc_build_class_component_ref): Same change. + (finish_class): Mark the getter and setter as deprecated if they + are generated from a deprecated property. + (objc_gimplify_property_ref): If the getter is deprecated, emit a + deprecation warning. + (objc_build_setter_call, objc_build_message_expr, + objc_finish_foreach_loop): Updated call to + objc_finish_message_expr. + +2010-12-28 Nicola Pero + + PR objc/47076 + * objc-act.c (lookup_protocol): Added 'definition_required' + argument. If 'definition_required', and the protocol is not + defined, emit a warning. + (objc_declare_protocols): Updated call to lookup_protocol. + (start_protocol): Same change. + (check_protocol_recursively): Same change. + (objc_build_protocol_expr): Same change. + (lookup_and_install_protocols): Added definition_required argument. + Pass it to lookup_protocol. + (objc_get_protocol_qualified_type): Updated call to + lookup_and_install_protocols. + (start_class): Updated calls to lookup_and_install_protocols; pass + true to 'definition_required' to get the warnings. + (start_protocol): Updated calls to lookup_and_install_protocols. + +2010-12-28 Nicola Pero + + * objc-act.c (objc_start_category_interface): Produce an error if + a class extension is found after the class @implementation. + +2010-12-28 Nicola Pero + + PR objc/47073 + * objc-act.c (encode_method_prototype): Fixed both location and + format string of error "type %qT does not have a known size". + +2010-12-26 Nicola Pero + + * config-lang.in (gtfiles): Added c-family/c-cppbuiltin.c. + +2010-12-22 Nathan Froyd + + * objc-act.c (next_sjlj_build_enter_and_setjmp): Use prototype_p. + +2010-12-18 Nicola Pero + + * objc-act.c (objc_init): Call using_eh_for_cleanups. + (objc_init_exceptions): Renamed to objc_maybe_warn_exceptions. Do + not call using_eh_for_cleanups. + (objc_begin_try_stmt): Do not call objc_init_exceptions. + (objc_build_throw_stmt): Updated call to + objc_maybe_warn_exceptions. + +2010-12-18 Iain Sandoe + + * objc/objc-act.c (objc_eh_personality): Select personality name on + runtime. + (objc_init_exceptions): New. + (objc_begin_try_stmt): Use objc_init_exceptions. + (objc_build_throw_stmt): Likewise. + +2010-12-10 Nicola Pero + + * objc-act.c (objc_in_class_extension): New. + (objc_start_category_interface): If -fobjc-std=objc1 + was specified, produce an error if a class extension is used. + (objc_finish_interface): Reset objc_in_class_extension to false. + (objc_add_property_declaration): Allow a class extension to extend + readonly properties in the main @interface to be readwrite. + (start_class): Added code to deal with class extensions. In that + case, return the existing interface after adding any additional + protocols to it and setting objc_in_class_extension to true. + (continue_class): If in a class extension, do not generate the + instance variable template. + +2010-12-08 Nicola Pero + + * objc-act.c (objc_build_throw_stmt): Check that the argument of + @throw is an object and emit an error if not. + +2010-12-08 Nicola Pero + + * objc-act.c (objc_finish_foreach_loop): Use error_at() instead of + error() when printing an error about the iterating variable or + collection not being an object. + +2010-12-06 Nicola Pero + + * objc-act.c (objc_finish_foreach_loop): Mark the + object_expression as used. + +2010-12-06 Nicola Pero + + * objc-act.c: Include c-family/c-objc.h. + * objc-lang.c: Same change. + * Make-lang.in (objc/objc-act.o): Depend on + c-family/c-objc.h. + (objc/objc-lang.o): Same change. + * config-lang.in (gtfiles): Added c-family/c-objc.h. + +2010-12-02 Joseph Myers + + * lang-specs.h: Don't handle -ftraditional. + +2010-12-02 Nicola Pero + + * objc-act.c (objc_build_throw_stmt): Return error_mark_node and + not NULL_TREE when a @throw is used outside of a @catch block. + +2010-11-30 Nicola Pero + + * objc-act.c (objc_build_volatilized_type): Removed. + (objc_non_volatilized_type): Removed. + (objc_type_quals_match): Removed. + (local_variables_to_volatilize): New. + (objc_volatilize_decl): Add the decl to volatilize to + local_variables_to_volatilize, but don't volatilize it yet. + (objc_finish_function): New. + * objc-act.h (local_variables_to_volatilize): New. + +2010-11-29 Nicola Pero + Mike Stump + + Allow 'make check-objc -j2' + * Make-lang.in (lang_checks_parallelized): New. + (check_objc_parallelize): New. + +2010-11-29 Nicola Pero + + * objc-act.c (start_class): When a class is reimplemented, + generate an error and avoid adding the class to the list of + implemented classes again, but do not return error_mark_node. + +2010-11-29 Nicola Pero + + * objc-act.c (objc_maybe_build_component_ref): Removed TODO. + +2010-11-29 Nicola Pero + + * objc-act.c (objc_eh_runtime_type): Avoid ICE if error_mark_node + is passed as argument. + (objc_begin_catch_clause): Added code to deal with an + error_mark_node or NULL_TREE argument. Improved checks for + invalid arguments. Added code to traverse typedefs. + +2010-11-29 Nicola Pero + + * objc-act.c (objc_demangle): Return immediately if the string is + too short. Detect names that do not need demangling, and return + them unchanged. + +2010-11-27 Nicola Pero + + Implemented optional properties. + * objc-act.h (PROPERTY_OPTIONAL): New. + * objc-act.c (objc_add_property_declaration): Set + PROPERTY_OPTIONAL if appropriate. + (finish_class): When generating definitions of setter and getter + methods associated with a property for a protocol, mark them as + optional if the property is optional. + (maybe_make_artificial_property_decl): Added 'getter_name' + argument. Set PROPERTY_OPTIONAL. + (objc_maybe_build_component_ref): Updated calls to + maybe_make_artificial_property_decl. Added code for optional, + readonly properties. + (objc_build_class_component_ref): Updated call to + maybe_make_artificial_property_decl. + +2010-11-27 Nicola Pero + + * objc-act.c (objc_build_struct): Fixed loops that save and + restore TYPE_OBJC_INFO to iterate over all variants of the type; a + special case for the current type is then no longer required. + Duplicate TYPE_LANG_SPECIFIC for each type before restoring + TYPE_OBJC_INFO. + (objc_get_protocol_qualified_type): Updated comments. + +2010-11-25 Nicola Pero + + * objc-act.c (objc_build_struct): Install TYPE_OBJC_INTERFACE + after finish_struct, not before, otherwise it may be wiped out by + it. This fixes spurious warnings when a class has more than 15 + instance variables. + +2010-11-23 Nicola Pero + + PR objc/24358 + * lang-specs.h: Added objective-c-cpp-output. Mapped .mi to + objective-c-cpp-output instead of objc-cpp-output. Print a + deprecation note every time objc-cpp-output is requested. + +2010-11-22 Joseph Myers + + * objc-act.c (write_symbols): Don't declare here. + +2010-11-22 Nicola Pero + + PR objc/41108 + * objc-act.c (objc_generate_write_barrier): Added assert to make sure + this function is only called with the next runtime. + +2010-11-20 Jakub Jelinek + + PR c/46547 + * objc-act.c (in_late_binary_op): Remove. + +2010-11-19 Nicola Pero + + * objc-act.c (objc_start_class_interface): Do not warn that class + attributes are unimplemented. Pass the attributes to start_class. + (objc_start_category_interface): Updated call to start_class. + (objc_start_class_implementation): Same change. + (objc_start_category_implementation): Same change. + (objc_build_class_component_ref): Warn if the class is deprecated. + (build_private_template): Mark the template as deprecated if the + class is deprecated. + (start_class): Added 'attributes' argument. Emit a warning if + using a deprecated class as superclass of a class, or original + class of a category. Recognize the 'deprecated' attribute when + starting and interface, and mark the interface with + TREE_DEPRECATED if present. Store attributes in the interface. + +2010-11-19 Nicola Pero + + * objc-act.c (lookup_protocol): Added 'warn_if_deprecated' + argument. If it is 'true' and the protocol is deprecated, emit a + deprecation warning. + (objc_start_protocol): Do not warn that protocol attributes are + unimplemented. Pass the attributes to start_protocol. + (start_protocol): Added attributes argument. Recognize the + 'deprecated' attribute and mark the protocols with TREE_DEPRECATED + if present. Store attributes in the protocol. + (objc_declare_protocols): Added 'attributes' argument. Recognize + the 'deprecated' attribute and mark the protocols with + TREE_DEPRECATED if present. Store attributes in the protocol. + Updated call to lookup_protocol. + (objc_build_protocol_expr): Updated call to lookup_protocol. + (check_protocol_recursively): Same change. + (lookup_and_install_protocols): Same change. + * objc-act.h: Updated comments. + +2010-11-17 Nicola Pero + + * objc-act.c (lookup_method_in_protocol_list): Search methods in + PROTOCOL_OPTIONAL_CLS_METHODS / PROTOCOL_OPTIONAL_NST_METHODS if + they are not found in PROTOCOL_CLS_METHODS / PROTOCOL_NST_METHODS. + +2010-11-15 Nicola Pero + + * objc-act.c (objc_build_setter_call): New. + (objc_maybe_build_modify_expr): Rewritten to build a compound + statement. + (objc_build_incr_expr_for_property_ref): Updated calls to + objc_maybe_build_modify_expr to call objc_build_setter_call + instead. Use build_modify_expr () instead of build2 (MODIFY_EXPR, + ...). Use convert () instead of build1 (NOP_EXPR, ...). Use + TREE_NO_WARNING on the final compound statement to silence C++ + warnings. + +2010-11-15 Nicola Pero + + * objc-act.c (objc_build_incr_expr_for_property_ref): New. + (objc_create_temporary_var): Moved it towards the beginning of the + file so that objc_build_incr_expr_for_property_ref can use it. + +2010-11-14 Nicola Pero + + * objc-act.c (objc_add_property_declaration): Check that the decl + we received from the parser is a FIELD_DECL; reject array and + bitfield properties. Convert the warning when a property is + readonly and a setter is specified into an error. Convert errors + when a property declaration does not match a property declaration + in a superclass into warnings. + (objc_add_synthesize_declaration_for_property): Use + DECL_BIT_FIELD_TYPE to determine the type of an instance variable + if it is a bitfield. Throw an error if we are asked to synthesize + setters/getters for a bitfield instance variable but the property + is not appropriate - it must be assign and nonatomic. If the + property is readonly, allow the instance variable type to be a + specialization of the property type. + (objc_type_valid_for_messaging): Fixed returning 'false' for a + Class qualified with a protocol when the 'accept_classes' argument + is 'false'. + +2010-11-13 Nicola Pero + + * objc-act.c (objc_get_protocol_qualified_type): detect cases + where we are asked to attach a protocol to something which is not + an Objective-C object type, and produce an error. + +2010-11-11 Nicola Pero + + * objc-act.c (objc_add_property_declaration): Check that the type + of a property and of an inherited property match. + (objc_maybe_build_component_ref): Tidied up indentation and + comments. + (objc_common_type): Added new type of check (-5). + (objc_add_synthesize_declaration_for_property): Check that the + property to synthesize and the instance variable to use have the + same type. + +2010-11-10 Joseph Myers + + * objc-act.c (objc_init): Use %' in diagnostic. + (objc_set_method_opt): Remove trailing '.' from diagnostic. + +2010-11-10 Joseph Myers + + * objc-act.c (dump_base_name): Don't declare here. + +2010-11-08 Nicola Pero + + * objc-act.c (objc_add_dynamic_declaration_for_property): Do not + search for the @property declation only in the current context, + but also in inherited properties. Do not mark the original + PROPERTY_DECL in the @interface or @protocol with + PROPERTY_DYNAMIC. + (check_methods): To check if a method is associated with a + @dynamic property, search for the property in IMPL_PROPERTY_DECL. + (check_accessible_methods): Same change. + * objc-act.h: Updated comment. + +2010-11-08 Nicola Pero + + * objc-act.c (objc_add_synthesize_declaration_for_property): + Iterate over IMPL_PROPERTY_DECL, not CLASS_PROPERTY_DECL, when + checking for an existing @synthesize or @dynamic declaration. + Search for an inherited @property declaration if none is found in + the local interface. If the required instance variable does not + exist, return instead of trying to continue to prevent a compiler + crash later. Check that the instance variable is not already + being used by another @synthesize. + (objc_add_dynamic_declaration_for_property): Iterate over + IMPL_PROPERTY_DECL, not CLASS_PROPERTY_DECL, when checking for an + existing @synthesize or @dynamic declaration. + (objc_synthesize_getter): Search for the getter declaration in + protocols and superclasses as well. + (objc_synthesize_setter): Search for the setter declaration in + protocols and superclasses as well. + +2010-11-08 Nicola Pero + + * objc-act.c (lookup_property): When checking categories, also + check the protocols attached to each. + (objc_add_property_declaration): Determine the + PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME here. Tidied up + error message. Search for an existing property declaration with + the same name which would be inherited from the class hiearchy, + and produce an error if it has incompatible attributes. + (check_methods): Changed second parameter. If the method is a + getter or setter for a property, do not warn if it is inherited as + opposed to implemented directly in the class. + (check_protocol): Updated calls to check_methods. + (finish_class): Do not determine the PROPERTY_SETTER_NAME and + PROPERTY_GETTER_NAME here; this is now done earlier, in + objc_add_property_declaration. + * objc-act.h (CLASS_NAME, CLASS_SUPER_NAME): Added comments. + +2010-11-06 Nicola Pero + + Fixed using the Objective-C 2.0 dot-syntax with self and super. + * objc-act.c (OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS): New. + (maybe_make_artificial_property_decl): Added 'implementation' + argument. Use OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS when + looking up getters or setters for a class. If an implementation + is specified, search it as well for a getter or setter. + (objc_maybe_build_component_ref): Updated calls to + maybe_make_artificial_property_decl; added code to deal with + 'self' and 'super' and with methods declared locally in the + implementation. Store the getter call expression in the + PROPERTY_REF instead of throwing it away. + (objc_build_class_component_ref): Updated calls to + maybe_make_artificial_property_decl, and store the getter call + expression in PROPERTY_REF instead of throwing it away. + (lookup_method_static): Implemented + OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS option. + (objc_gimplify_property_ref): Do not build the getter method call + here; instead use the one stored in the PROPERTY_REF. If it's not + there, produce helpful error messages. + * objc-tree.def (PROPERTY_REF): Increased the number of operands + from 2 to 3. Updated comments. + * objc-act.h (PROPERTY_REF_GETTER_CALL): New. + +2010-11-06 Iain Sandoe + + PR target/44981 + * objc-act.c (objc_build_string_object): Amend for renamed hook. + (objc_string_ref_type_p): New. + (objc_check_format_arg): New. + +2010-11-04 Nicola Pero + + Fixed using the Objective-C 2.0 dot-syntax with class names. + * objc-act.c (objc_build_class_component_ref): New. + +2010-11-03 Nicola Pero + + * objc-act.c (objc_add_dynamic_declaration): Allow @dynamic in a + category. + (objc_type_valid_for_messaging): Added 'accept_classes' argument; + if set to 'true', return 'true' for Class objects. Do not remove + more than on pointer indirection. + (objc_add_property_declaration): Only warn about 'assign' + semantics for Objective-C objects if warn_property_assign_default; + and do not warn if the property is readonly or if the type is a Class. + (objc_finish_foreach_loop): Updated calls to + objc_type_valid_for_messaging. + +2010-11-03 Nicola Pero + + Implemented -fobjc-std=objc1 flag. + * objc-act.c (objc_start_class_interface): If attributes are + specified when flag_objc1_only is set, print an error. + (objc_start_category_interface): Same change. + (objc_start_protocol): Same change. + (objc_add_method_declaration): Same change. + (objc_start_method_definition): Same change. + (objc_build_keyword_decl): Same change. + (objc_set_visibility): If OBJC_IVAR_VIS_PACKAGE is used when + flag_objc1_set is set, print an error. + (objc_set_method_opt): If flag_objc1_only is set, print an error. + (objc_add_property_declaration): Same change. + (objc_add_synthesize_declaration): Same change. + (objc_add_dynamic_declaration): Same change. + (objc_finish_foreach_loop): Same change. + (objc_maybe_build_component_ref): If flag_objc1_only is set, + return immediately. + +2010-11-03 Nicola Pero + + * objc-act.c (maybe_make_artificial_property_decl): New. + (objc_maybe_build_component_ref): Call + maybe_make_artificial_property_decl if a property can not be + found. Do not call objc_finish_message_expr if + PROPERTY_HAS_NO_GETTER. + * objc-act.h Updated comments. + (PROPERTY_HAS_NO_GETTER): New. + (PROPERTY_HAS_NO_SETTER): New. + * objc-tree.def: Updated comment. + +2010-11-01 Nicola Pero + + Implemented format and noreturn attributes for Objective-C methods. + * objc-act.c (objc_start_method_definition): If method attributes + are specified emit a warning and ignore them. + (build_objc_method_call): Moved deprecation warnings from here ... + (objc_finish_message_expr): to here. Do not emit deprecation + warnings if the receiver is of type 'id'. + (really_start_method): Install 'deprecation' and 'noreturn' + attributes. + (objc_decl_method_attributes): Carefully filter out the list of + attributes, allowing only "noreturn", "format", "sentinel" and + "deprecated". In the case of "format", adjust the arguments. + Always process the attributes in the same way no matter if + "sentinel" is in the list or not. + +2010-11-01 Nicola Pero + + * objc-act.c (objc_maybe_build_component_ref): Warn about using + deprecated properties. + (objc_maybe_printable_name): Support PROPERTY_DECL. + +2010-11-01 Nicola Pero + + Implemented Objective-C 2.0 property accessors. + * objc-act.h (enum objc_tree_index): Added OCTI_GET_PROPERTY_DECL, + OCTI_SET_PROPERTY_DECL, OCTI_COPY_STRUCT_DECL, + OCTI_GET_PROPERTY_STRUCT_DECL and OCTI_SET_PROPERTY_STRUCT_DECL. + (objc_getProperty_decl): New. + (objc_setProperty_decl): New. + (objc_copyStruct_decl): New. + (objc_getPropertyStruct_decl): New. + (objc_setPropertyStruct_decl): New. + * objc-act.c (build_objc_property_accessor_helpers): New. + (synth_module_prologue): Call + build_objc_property_accessor_helpers. + (lookup_ivar): New. + (objc_synthesize_getter): Implemented synthesizing getters that + work with properties that are not nonatomic, assign properties. + (objc_synthesize_setter): Implemented synthesizing setters that + work with properties that are not nonatomic, assign properties. + +2010-10-30 Nicola Pero + + Implemented Objective-C 2.0 @property, @synthesize and @dynamic. + * objc-tree.def (PROPERTY_REF): New. + * objc-act.h: Added comments for all the PROPERTY_ macros. + (PROPERTY_NAME): Use DECL_NAME. + (PROPERTY_COPIES): Removed. + (PROPERTY_READONLY): Use DECL_LANG_FLAG_0 for it. + (PROPERTY_NONATOMIC): New. + (objc_property_assign_semantics): Make it a typedef. + (PROPERTY_ASSIGN_SEMANTICS): New. + (PROPERTY_DYNAMIC): New. + (PROPERTY_REF_OBJECT): New. + (PROPERTY_REF_PROPERTY_DECL): New. + * objc-act.c (CALL_EXPR_OBJC_PROPERTY_GETTER): Removed. + (in_objc_property_setter_name_context): Removed. + (objc_add_property_declaration): Removed copies and ivar arguments + and code supporting them. Fixed recovering when readonly and + setter attributes are specified. Removed support for @property in + @implementation context. Updated error message. Double-check + that a property does not have a DECL_INITIAL. Validate the + property assign semantics and emit appropriate errors and + warnings. Check for duplicate property declarations. Set + DECL_SOURCE_LOCATION, TREE_DEPRECATED, PROPERTY_NONATOMIC, + PROPERTY_ASSIGN_SEMANTICS and PROPERTY_DYNAMIC of the new + PROPERTY_DECL. Do not set PROPERTY_COPIES. Set + PROPERTY_IVAR_NAME to NULL_TREE. + (objc_build_getter_call): Renamed to + objc_maybe_build_component_ref. If the property is not found in + the interface, search in the protocol list. Do not generate the + getter call; instead, build and return a PROPERTY_REF. + (objc_is_property_ref): New. + (objc_setter_func_call): Removed. + (get_selector_from_reference): Removed. + (is_property): Removed. + (objc_build_setter_call): Renamed to objc_maybe_build_modify_expr. + Updated to work on a PROPERTY_REF and use the PROPERTY_DECL from + the PROPERTY_REF. Generate an error if the property is read-only. + (build_property_reference): Removed. + (objc_finish_message_expr): Removed check to produce "readonly + property can not be set" error when + in_objc_property_setter_name_context. We now generate the error + earlier, in objc_maybe_build_modify_expr, which will only generate + the setter call if the property is readwrite. + (check_methods): Recognize dynamic properties. + (check_methods_accessible): Same change. + (objc_build_property_ivar_name): Removed. + (objc_build_property_setter_name): Dropped bool argument. Always + add the ':' at the end. + (objc_gen_one_property_datum): Removed. + (objc_process_getter_setter): Removed. + (objc_synthesize_getter): Mark 'klass' argument as unused. Use + PROPERTY_GETTER_NAME instead of PROPERTY_NAME. Set the + DECL_SOURCE_LOCATION of the new method to be the same as the one + for the @synthesize. Always use PROPERTY_IVAR_NAME as it is + instead of trying to guess what it should be. Removed use of + CLASS_IVARS. Use the location of @synthesize for c_finish_return + and c_end_compound_statement. + (objc_synthesize_setter): Mark 'klass' argument as unused. Use + PROPERTY_SETTER_NAME instead of trying to guess what it should be. + Set the DECL_SOURCE_LOCATION of the new method to be the same as + the one for the @synthesize. Always use PROPERTY_IVAR_NAME as it + is instead of trying to guess what it should be. Removed use of + CLASS_IVARS. Use the location of @synthesize for c_finish_return + and c_end_compound_statement. Emit an error and keep going, + instead of aborting, if the setter prototype does not have the + expected argument. + (objc_add_synthesize_declaration_for_property): New. + (objc_add_synthesize_declaration): Removed ATTRIBUTE_UNUSED from + all arguments. Improved error message. Filled in the rest of the + function, which used to be a placeholder, with an actual + implementation. + (objc_add_dynamic_declaration_for_property): New. + (objc_add_dynamic_declaration): Removed ATTRIBUTE_UNUSED from all + arguments. Improved error message. Filled in the rest of the + function, which used to be a placeholder, with an actual + implementation. + (objc_gen_property_data): Rewritten. + (finish_class): Added explicit switch cases for + CLASS_INTERFACE_TYPE, CATEGORY_INTERFACE_TYPE and + PROTOCOL_INTERFACE_TYPE. Added a default switch case which is + gcc_unreachable. Rewritten the processing of properties, in + particular to not synthesize prototypes for getters and setters if + they already exist and to install the getter and setter names into + PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME. Do not generate + warnings about setter, getter and ivar property attributes. + (objc_lookup_ivar): Removed support for properties. + (objc_gimplify_property_ref): New. + (objc_gimplify_expr): Use a switch. In case of a PROPERTY_REF, call + objc_gimplify_property_ref. + +2010-10-27 Nicola Pero + + * objc-act.c (objc_add_property_declaration): Added arguments to + pass the various property attributes that were parsed with the + property declaration. Process arguments to determine the final + property attributes and produce error messages as appropriate. + Added temporary code to keep the compiler silent about variables + set but not used - for new attributes that are only checked but + have no effect yet. + (property_readonly): Removed. + (property_setter): Removed. + (property_getter): Removed. + (property_ivar): Removed. + (property_copies): Removed. + (objc_set_property_attr): Removed. + * objc-act.h (enum property_assign_semantics): New. + +2010-10-27 Nicola Pero + + * objc-act.c (objc_add_property_variable): Renamed to + objc_add_property_declaration. Added location argument. Updated + warnings and errors to use it. Use error, not fatal_error, if a + property declaration is found outside an interface or + implementation context. + +2010-10-24 Nicola Pero + + * objc-act.c (objc_build_keyword_decl): Updated comments. Do not + emit a warning that method parameter attributes are unimplemented. + Instead, store them into DECL_ATTRIBUTES of the KEYWORD_DECL. + (start_method_def): Copy attributes from each KEYWORD_DECL into + the corresponding PARM_DECL. + (objc_warn_deprecated_use): Removed. + (build_objc_method_call): Call warn_deprecated_use, not + objc_warn_deprecated_use. + (objc_maybe_printable_name): Do not try to get the identifier name + of DECLs that we don't recognize. Immediately return NULL for them. + (objc_printable_name): Removed C++-specific case, which is no + longer used. Updated comments. + +2010-10-23 Nicola Pero + + * objc-act.c (OBJC_GEN_METHOD_LABEL): Updated comments. + (objc_demangle): Return NULL if demangling can not be done because + the string to demangle is not an Objective-C mangled method name. + Be smarter in demangling method names so that at least for methods + with no arguments we are able to almost always demangle '_' correctly. + Updated comments. + (objc_maybe_printable_name): New. + (objc_printable_name): Call objc_maybe_printable_name. If it + returns NULL, call cxx_printable_name in Objective-C++. + +2010-10-21 Iain Sandoe + + Based on the CFString implementation in FSF apple/trunk branch. + + * objc/objc-act.c (objc_build_string_object): Handle CFStrings. + +2010-10-21 Nicola Pero + + * objc-act.c (get_objc_string_decl): Use a switch instead of a + chain of ifs. Use gcc_unreachable instead of abort. + (add_objc_string): Same change. + (generate_protocol_list): Same change - twice. + (synth_id_with_class_suffix): Same change. + (build_keyword_selector): Same change - twice. + (objc_build_message_expr): Same change. + (objc_build_selector_expr): Same change. + (check_methods): Same change - and added missing gcc_unreachable + for default case. + (check_methods_accessible): Same change - twice, and added missing + gcc_unreachable for default case in one of them. + (start_class): Same change - and added missing gcc_unreachable for + default case. + (continue_class): Same change. + (objc_gen_property_data): Same change. + (finish_class): Same change. + (encode_type_qualifiers): Added missing gcc_unreachable. + (encode_type): Small code tidy up to reduce duplicated code. Use + gcc_unreachable instead of abort - twice. + (encode_gnu_bitfield): Use a switch instead of a chain of ifs - + twice. Added missing gcc_unreachable for default case - twice. + (dump_interface): Use a switch instead of a chain of ifs. + (handle_impent): Same change. + +2010-10-20 Nicola Pero + + * objc-act.h (objc_inherit_code): Removed. + * objc-act.c (objc_inherit_code): Removed. + (objc_set_method_type): Removed. + (objc_build_method_signature): Added is_class_method argument. + Use it instead of the global objc_inherit_code variable. + (objc_add_method_declaration): Same change. + (objc_start_method_definition): Same change. + (objc_generate_cxx_ctor_or_dtor): Updated call to + objc_start_method_definition. Do not call objc_set_method_type. + (adjust_type_for_id_default): Mark as inline. + (objc_synthesize_getter): Updated call to + objc_start_method_definition. Do not set objc_inherit_code. + (objc_synthesize_setter): Updated call to + objc_start_method_definition. Do not set objc_inherit_code. + +2010-10-20 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. Obvious updates + to gcc_alloc_xxx calls in hash_init and hash_class_name_enter to + get it to compile in the current trunk. + + 2006-01-27 Fariborz Jahanian + + Radar 4345837 + * objc/objc-act.c (hash_class_name_enter): New. + (hash_class_name_lookup): New. + (objc_declare_alias): Enter alias name into hash table. + (objc_declare_class): Enter class name into hash table. + (objc_is_class_name): Do a hash look up of class name. + (hash_init): Initialize the two new hash tables. + * objc-act.h: Added cls_name_hash_list and als_name_hash_list + declarations, removed class_chain and alias_chain. + +2010-10-20 Nicola Pero + + * objc-lang.c (finish_file): Removed. + * objc-act.c (objc_finish_file): Renamed to + objc_write_global_declarations. Do not try to instantiate C++ + templates when compiling Objective-C++ as this is now + automatically done before this function is called. Do not check + for syntax-only run or PCH generation as this is done by the + callers. + * objc-act.h (objc_finish_file): Removed. + +2010-10-18 Nicola Pero + + Implemented parsing @synthesize and @dynamic for + Objective-C/Objective-C++. + * objc-act.c (objc_add_synthesize_declaration): New. + (objc_add_dynamic_declaration): New. + +2010-10-18 Nicola Pero + + * objc-act.c (lookup_and_install_protocols): Return NULL if passed + error_mark_node. + +2010-10-18 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2006-03-10 Fariborz Jahanian + + Radar 4407151 + * objc/objc-act.c (objc_is_class_name): template parameter is not + an objective class name. + (objc_generate_cxx_cdtors): Check for the null + objc_implementation_context. + +2010-10-18 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-11-08 Fariborz Jahanian + + Radar 4330422 + * objc/objc-act.c (objc_non_volatilized_type): New + + 2005-10-07 Fariborz Jahanian + + Radar 4204796 + * objc-act.c (objc_build_volatilized_type): Build 'volatilzed' + types with proper attribute set and correctly. + (objc_volatilize_decl): Remove unneeded code. + (objc_type_quals_match): Use the new attribute to check on + 'volatilzed' type. + (hash_init): removed unneeded code. + +2010-10-17 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2006-03-27 Fariborz Jahanian + + Radar 4133425 + * objc-act.c (objc_diagnose_private_ivar): New. + +2010-10-17 Iain Sandoe + + * objc-act.c: Rename 'objc_public_flag' to objc_ivar_visibility and + make its type 'objc_ivar_visibility_kind'. + (objc_start_class_interface): Update to use visibility enum. + (objc_start_class_implementation): Likewise. + (objc_set_visibility): Update to use visibility enum, warn that + @package is handle as per @public. + (add_instance_variable): Handle OBJC_IVAR_VIS_PACKAGE. + * objc-act.h: Rename 'objc_public_flag' to objc_ivar_visibility and + make its type 'objc_ivar_visibility_kind'. + +2010-10-14 Iain Sandoe + + merge from FSF apple 'trunk' branch. + 2006 Fariborz Jahanian + + Radars 4436866, 4505126, 4506903, 4517826 + * objc-act.c (CALL_EXPR_OBJC_PROPERTY_GETTER): New. + property_readonly, property_getter, property_setter, property_ivar, + property_copies, in_objc_property_setter_name_context: New vars. + (objc_set_property_attr): New. + (objc_add_property_variable): New. + (lookup_property_in_list): New. + (lookup_property): New. + (objc_build_getter_call): New. + (objc_setter_func_call): New. + (get_selector_from_reference): New. + (objc_build_setter_call): New. + (is_property): New. + (build_property_reference): New. + (objc_finish_message_expr): Detect readonly property and warn. + (objc_build_property_ivar_name): New. + (objc_build_property_setter_name): New. + (objc_gen_one_property_datum): New. + (objc_process_getter_setter): New. + (objc_synthesize_getter): New. + (objc_synthesize_setter): New. + (objc_gen_property_data): New. + (finish_class): Generate property data. + (comp_proto_with_proto): Separated from ... + (match_proto_with_proto): ... New. + (objc_lookup_ivar): Handle properties. + * objc-tree.def (PROPERTY_DECL): New tree code. + * objc-act.h: CLASS_LANG_SLOT_ELTS, PROTOCOL_LANG_SLOT_ELTS update size. + (METHOD_PROPERTY_CONTEXT): New. + (PROPERTY_NAME): New. + (PROPERTY_GETTER_NAME): New. + (PROPERTY_SETTER_NAME): New. + (PROPERTY_IVAR_NAME): New. + (PROPERTY_READONLY): New. + (PROPERTY_COPIES): New. + (TOTAL_CLASS_RAW_IVARS): New. + (CLASS_PROPERTY_DECL): New. + (IMPL_PROPERTY_DECL): New. + * objc-lang.c (objc_init_ts): Update fields for property_decl. + +2010-10-13 Richard Henderson + + * objc-act.c (objc_eh_personality): Update call to + build_personality_function. + +2010-10-13 Iain Sandoe + + merge from FSF apple 'trunk' branch. + + 2006-04-26 Fariborz Jahanian + Radar 3803157 (method attributes) + * objc/objc-act.h (METHOD_TYPE_ATTRIBUTES): New macro. + * objc/objc-act.c (objc_decl_method_attributes): New. + (objc_add_method_declaration): Process method's attribute. + (objc_start_method_definition): Ditto. + (build_objc_method_call): Inject method attribute into + built function type. + (objc_method_decl): New. + (objc_warn_deprecated)use): New. + +2010-10-07 Andi Kleen + + * Make-lang.in (cc1obj-dummy): Remove. + (cc1obj-checksum): Change to run checksum over object files + and options only. + +2010-10-07 Nicola Pero + + PR objc/45925 + * objc-act.c (objc_finish_foreach_loop): Convert return value of + countByEnumeratingWithState:objects:count: to long unsigned int. + +2010-10-07 Iain Sandoe + + * objc-act.c (build_objc_method_call): Replace calls to + build_function_call () with the VEC equivalent. Construct parameter + lists as VECs. + +2010-10-07 Iain Sandoe + + * objc-act.c (objc_build_message_expr): Call mark_exp_read () to + signal that the receiver has been used. + +2010-10-06 Nicola Pero + + * README: Obsolete file removed. + +2010-10-06 Nicola Pero + + Implemented fast enumeration for Objective-C. + * objc-act.c (build_fast_enumeration_state_template): New. + (TAG_ENUMERATION_MUTATION): New. + (TAG_FAST_ENUMERATION_STATE): New. + (synth_module_prologue): Call build_fast_enumeration_state_template() and set up + objc_enumeration_mutation_decl. + (objc_create_temporary_var): Allow providing a name to temporary + variables. + (objc_build_exc_ptr): Updated calls to + objc_create_temporary_var(). + (next_sjlj_build_try_catch_finally): Same change. + (objc_finish_foreach_loop): New. + * objc-act.h: Added OCTI_FAST_ENUM_STATE_TEMP, + OCTI_ENUM_MUTATION_DECL, objc_fast_enumeration_state_template, + objc_enumeration_mutation_decl. + + Merge from 'apple/trunk' branch on FSF servers. + + 2006-04-12 Fariborz Jahanian + + Radar 4507230 + * objc-act.c (objc_type_valid_for_messaging): New routine to check + for valid objc object types. + (objc_finish_foreach_loop): Check for invalid objc objects in + foreach header. + +2010-10-05 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-10-17 Fariborz Jahanian + + Radar 4290840 + * objc-act.c (objc_start_method_definition): Check for + error_mark_node for the selector name and make a quick exit. + +2010-10-04 Andi Kleen + + * Make-lang.in (cc1obj-dummy, cc1obj): Add + to build rule. + +2010-09-30 Iain Sandoe + + merge from FSF 'apple/trunk' branch. + 2006-01-30 Fariborz Jahanian + + Radar 4386773 + * objc/objc-act.c (objc_set_method_opt): New function. + (objc_start_protocol, objc_finish_interface): Reset + objc_method_optional_flag flag. + (objc_add_method_declaration): Pass on the new + flag to objc_add_method. + (objc_add_method): Add optional methods to new chain in + the protocol class. + * objc/objc-act.h (CLASS_OPTIONAL_CLS_METHODS, + CLASS_OPTIONAL_NST_METHODS): New macros accessing a protocol + class's optional method chains. + +2010-09-30 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-10-04 Fariborz Jahanian + + Radar 4278236 + * objc-act.c (objc_declare_class): Pick the right + type tree. + +2010-09-29 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-10-04 Fariborz Jahanian + + Radar 4281748 + * objc-act.c (objc_check_global_decl): New + +2010-09-29 Nicola Pero + + * objc-act.c (objc_is_reserved_word): Removed. + +2010-09-28 Iain Sandoe + + * objc-act.c (objc_add_method_declaration): Handle and ignore + attributes. + (objc_start_method_definition): Likewise. + (objc_generate_cxx_ctor_or_dtor): Pass NULL attributes to ctor/dtor. + (objc_build_keyword_decl): Handle and ignore attributes. + +2010-09-28 Richard Henderson + + * objc-act.c (objc_eh_personality): Use targetm.except_unwind_info. + +2010-09-28 Iain Sandoe + + * objc-act.c (objc_start_class_interface): Handle and ignore attributes. + (objc_start_category_interface): Likewise. + (objc_start_protocol): Likewise. + +2010-09-28 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-08-23 Stuart Hastings + Ziemowit Laski + + Radar 4209854 + * objc-act.c (objc_decay_parm_type): New function. + (get_arg_type_list): Decay types for all named arguments. + (objc_push_parm): Rebuild the PARM_DECL if its type has + been decayed. + +2010-09-28 Nicola Pero + + * objc-act.c (encode_type): Fixed encoding enums with the next + runtime. + +2010-09-28 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-07-18 Ziemowit Laski + + Radar 4175534 + * objc-act.c (objc_compare_types): A new silent comparison + mode (-4), differing from regular comparison (-3) in that + 'false' is returned instead of issuing warnings. + +2010-09-28 Nicola Pero + + * objc-act.c (encode_type): Do not add 'r' with the next runtime. + (encode_aggregate_within): Reorganized code to be more readable. + (encode_aggregate_fields): Updated second argument to be 'bool' + instead of 'int'. + +2010-09-27 Nicola Pero + + PR objc/45763 + PR objc/25450 + PR objc/25464 + * objc-act.c: Improved comments for encoding functions. + (encode_aggregate_within): For the GNU runtime, rewritten some + obsfuscated code to clarify the various cases. + (encode_aggregate): Function removed. + (encode_array): Generate an error if asked to encode an incomplete + array as part of generating instance variables. Else, when + encoding an incomplete array inside a structure, encode it as an + array of zero size. + (encode_pointer): For the GNU runtime, fixed encoding 'BOOL *' as + '^c' instead of '*'. + (encode_gnu_bitfield): Encode enumerated types exactly in the same + type as integer types instead of using a hardcoded 'i'. If asked + to encode a non-integer type as a bitfield, do not abort + compilation immediately; instead generate an error, then skip the + type. + (encode_type): Use a 'switch' instead of a sequence of 'if's. + Added a 'default' clause that gets executed if the type can not be + matched, and that encodes it as '?' (unknown) and produces a + warning. For the GNU runtime, encode enumerated types exactly in + the same way as integer types instead of using a hardcoded 'i'. + Encode long double as 'D'. Encode 128-bit integers as 'T' or 't'. + Encode C++ reference types as pointers. Call encode_vector to + encode vectors. + (encode_vector): New function. + +2010-09-27 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. I modified the + changes to be used only when compiling for the NeXT runtime. + + 2005-10-10 Fariborz Jahanian + + Radar 4301047 + + * objc-act.c (encode_type): Remove the hack. + + 2005-07-20 Ziemowit Laski + + Radar 4136935 + * objc-act.c (pointee_is_readonly): New function. + (encode_pointer, encode_aggregate_within, encode_type): + Attempt to emulate GCC 3.3 when generating type encodings. + +2010-09-27 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2005-12-15 Fariborz Jahanian + + Radar 4229905 + * objc-act.c (objc_have_common_types): New function. + + 2005-06-22 Ziemowit Laski + + Radar 4154928 + * objc-act.c (objc_common_type): New function. + +2010-09-27 Richard Guenther + + * objc-act.c (objc_get_class_reference): Use CP_TYPE_CONTEXT. + (objc_is_global_reference_p): Use DECL_FILE_SCOPE_P. + +2010-09-26 Nicola Pero + + * objc-act.c: Removed historical, obsolete comment at the top of + the file. + +2010-09-21 Nicola Pero + + PR objc/23710 + * objc-act.c (objc_start_method_definition): Do not abort upon a + 'method definition not in @implementation context' error. Return + 'false' instead. + +2010-09-21 Nicola Pero + + PR objc/25965 + * objc-act.c (objc_get_interface_ivars): New function. + (objc_collecting_ivars): New variable. + (continue_class): Set and reset objc_collecting_ivars for context. + +2010-09-15 Nicola Pero + + Merge from 'apple/trunk' branch on FSF servers. + + 2006-03-09 Fariborz Jahanian + + Radar 4457381 + * objc/objc-act.c (objc_finish_message_expr): Look for message in + @class's protocol list. + + 2006-02-07 Fariborz Jahanian + + Radar 4219590 + * objc/objc-act.c (objc_start_method_definition): Initialize + break/continue labels. + + 2005-08-22 Ziemowit Laski + + Radar 4174166 + * objc-act.c (objc_compare_types): Compare function + pointers; indicate success if the right-hand side has + a return type that is covariant, and the argument types + contravariant, with those of the left side. + + 2005-08-22 Ziemowit Laski + + Radar 4216500 + * objc-act.c (objc_get_protocol_qualified_type): When looking + at a typedef, retrieve the precise type it describes (rather + than merely looking up a class by name). + +2010-09-10 Nicola Pero + + * objc/objc-act.c (objc_begin_try_stmt): Generate an error if + -fobjc-exceptions was not used. (objc_build_throw_stmt): Same + change. + +2010-07-15 Nathan Froyd + + * objc-act.c: Carefully replace TREE_CHAIN with DECL_CHAIN. + +2010-07-10 Iain Sandoe + + PR objc/44140 + * objc-act.c: build_objc_string_decl() remove declaration. + (finish_var_decl): Remove forcing of var output and marking + as "Used". + (init_def_list): Use integer_zero_node. + (init_objc_symtab): Use integer_zero_node, make the short + integer type specific on relevant nodes. + (generate_objc_symtab_decl): Remove call to + forward_declare_categories(). Use null_pointer_node where + appropriate. + (build_module_descriptor): Comment and mark this item as + DECL_PRESERVE_P. + (generate_static_references): Use gcc_unreachable instead of + abort (). + (diagnose_missing_method): New. + (build_next_selector_translation_table): New. + (build_gnu_selector_translation_table): New. + (add_objc_string): Merge code from build_objc_string_decl... + ... and delete build_objc_string_decl(). + (generate_dispatch_table): Make integer types explicit. + (generate_category): Pass implent and arrange for the data + to be extracted within the routine. Do not start new vars, + but finish the ones collcted during parsing. + (generate_shared_structures): Likewise. + (finish_objc): Reorder code so that we finish variables before + referencing them. Save the global data before calling meta-data + creation routines, and pass the current reference to the two + main routines. Only call generate_objc_image_info () for the + NeXT runtime. + (generate_classref_translation_entry): Comment on and make this + item DECL_PRESERVE_P. + (handle_class_ref): Use varpool interfaces, comment on and make + this item DECL_PRESERVE_P. + (handle_impent): Likewise. + (generate_objc_image_info): Only generate when the content is + non-zero. Make integer types explict. + +2010-07-03 Nathan Froyd + + PR objc/24867 + * objc-act.c (build_sized_array_type): New function. + (add_objc_string): Use it. + (generate_protocol_list): Likewise. + (generate_objc_image_info): Likewise. + (add_field_decl): New function. + (objc_build_struct): Use a VEC rather than building a TREE_LIST. + (generate_struct_by_value_array): Use add_field_decl. + (build_objc_symtab_template): Likewise. + (build_module_descriptor): Likewise. + (build_objc_exception_stuff): Likewise. + (build_protocol_template): Likewise. + (build_method_prototype_list_template): Likewise. + (build_method_prototype_template): Likewise. + (build_category_template): Likewise. + (build_selector_template): Likewise. + (build_class_template): Likewise. + (build_super_template): Likewise. + (build_ivar_template): Likewise. + (build_ivar_list_template): Likewise. + (build_method_list_template): Likewise. + (build_method_template): Likewise. + +2010-06-28 Steven Bosscher + + * objc-act.c: Do not include except.h. + +2010-06-08 Laurynas Biveinis + + * objc-act.h (ALLOC_OBJC_TYPE_LANG_SPECIFIC): Use typed GC + allocation. + + * objc-act.c (objc_volatilize_decl): Likewise. + (objc_build_string_object): Likewise. + (hash_init): Likewise. + (hash_enter): Likewise. + (hash_add_attr): Likewise. + (add_class): Likewise. + (start_class): Likewise. + +2010-06-05 Steven Bosscher + + * objc-act.c: Update include path for moved files. + * objc-lang.c: Likewise. + * config-lang.in: Update paths in gtfiles for files in c-family/. + +2010-06-01 Nathan Froyd + + * objc-act.c (build_next_objc_exception_stuff): Give setjmp a + varargs type instead of a zero-argument type. + +2010-05-30 Nathan Froyd + + * objc-act.c (synth_module_prologue): Use build_function_type_list + instead of build_function_type. + (build_module_initializer_routine): Likewise. + (build_next_objc_exception_stuff): Likewise. + (build_objc_exception_stuff): Likewise. + +2010-05-27 Joseph Myers + + * objc-act.c: Include diagnostic-core.h instead of diagnostic.h. + * Make-lang.in (objc/objc-act.o): Update dependencies. + +2010-05-25 Steven Bosscher + + * objc-act.h: Do not include gimple.h. + * objc-act.c: Do not include rtl.h, expr.h, libfuncs.h, and tm_p.h. + Include gimple.h. Explain why except.h has to be included. + * objc-lang.c: Do not include diagnostics.h. + * Make-lang.in: Update dependencies. + +2010-05-25 Nathan Froyd + + * objc-act.c (objc_build_constructor): Adjust OBJCPLUS impedance + mismatch code for VECs. + +2010-05-25 Nathan Froyd + + * objc-act.c (objc_build_constructor): Take a VEC instead of a tree. + Use build_constructor instead of build_constructor_from_list. + (objc_build_string_object): Build a VEC argument for + objc_build_constructor. + (init_def_list): Likewise. + (init_objc_symtab): Likewise. + (init_module_descriptor): Likewise. + (generate_static_references): Likewise. + (build_selector_translation_table): Likewise. + (build_descriptor_table_initializer): Likewise. + (generate_descriptor_table): Likewise. + (build_protocol_initializer): Likewise. + (build_ivar_list_initializer): Likewise. + (generate_ivars_list): Likewise. + (build_dispatch_table_initializer): Likewise. + (generate_dispatch_table): Likewise. + (generate_protocol_list): Likewise. + (build_category_initializer): Likewise. + (build_shared_structure_initializer): Likewise. + (generate_objc_image_info): Likewise. + +2010-04-30 Iain Sandoe + + PR objc++/32052 + * objc-act.c (encode_aggregate_within): Encode structure tags + with template args for ObjC++. + +2010-04-30 Steven Bosscher + + * objc-act.c: Do not include varray.h. + +2010-04-07 Jakub Jelinek + + PR c/18624 + * objc-act.c (finish_var_decl, objc_begin_catch_clause, + really_start_method, get_super_receiver, handle_class_ref): Set + DECL_READ_P in addition to TREE_USED. + +2010-04-07 Iain Sandoe + + PR objc/35996 + * objc-act.c (objc_init): Warn that -fobjc-gc is ignored for + -fgnu-runtime and set flag_objc_gc to zero. + +2010-04-07 Iain Sandoe + + PR objc++/23716 + * objc-act.c (build_module_initializer_routine): Make the argument + to objc_start_function NULL_TREE when compiling ObjC++. + +2010-02-18 Iain Sandoe + Mike Stump + + PR objc/43061 + * objc-act.c (finish_var_decl): Set the generated symbols as "used". + +2009-12-17 Shujing Zhao + + * objc-act.c (objc_substitute_decl, build_ivar_reference, + get_super_receiver): Update build_indirect_ref calls. + +2009-11-28 Jakub Jelinek + + * objc-act.c (generate_shared_structures): Remove unused sc_spec and + decl_specs variables. + (objc_build_message_expr): Remove unused loc variable. + (objc_finish_message_expr): Remove unused saved_rtype variable. + (encode_field_decl): Remove unused type variable. + + PR obj-c++/42156 + * objc-act.c (objc_build_struct): INIT_TYPE_OBJC_INFO for + type variants that don't have it initialized yet. + +2009-09-14 Jan Hubicka + + * objc-act.c (objc_add_static_instance): Do not set DECL_COMMON. + +2009-09-14 Richard Henderson + + * objc-act.c (objc_init_exceptions): Don't call + default_init_unwind_resume_libfunc. + (objc_build_exc_ptr): Use __builtin_eh_pointer. + +2009-09-13 Richard Guenther + Rafael Avila de Espindola + + * objc-act.c (objc_eh_runtime_type): Export. + (objc_init_exceptions): Remove. Move warning code ... + (objc_begin_try_stmt): ... here + (objc_build_throw_stmt): ... and here. + (objc_eh_personality_decl): New. + (objc_eh_personality): New function. + * objc-act.h (objc_eh_runtime_type): Declare. + (objc_eh_personality): Likewise. + * objc-lang.c (LANG_HOOKS_EH_RUNTIME_TYPE): Define. + (LANG_HOOKS_EH_PERSONALITY): Likewise. + +2009-09-03 Diego Novillo + + * objc-lang.c (lang_hooks): Remove const qualifier. + +2009-08-20 Richard Guenther + + * objc-act.c: Include c-lang.h + * Make-lang.in (objc/objc-act.o): Add c-lang.h dependency. + +2009-07-17 Aldy Hernandez + Manuel López-Ibáñez + + PR 40435 + * objc-act.c: Add location argument to all calls to + build_fold_addr_expr. + +2009-07-14 Taras Glek + Rafael Espindola + + * Make-lang.in (objc.install-plugin): New target for + installing plugin headers. + +2009-07-07 Manuel López-Ibáñez + + * objc-act.c (next_sjlj_build_catch_list): Replace EXPR_LOCUS by + EXPR_LOCATION. + +2009-07-07 Manuel López-Ibáñez + + * objc-act.c: Replace %J by an explicit location. Update all + calls. + +2009-07-07 Manuel López-Ibáñez + + * objc-act.c: Replace %H by an explicit location. Update all + calls. + +2009-06-22 Steven Bosscher + + PR objc/28050 + * objc-act.c (objc_build_message_args): Return if ARGS is the + error_mark_node. + +2009-06-19 Ian Lance Taylor + + * objc-act.c (objc_in_struct, objc_struct_types): Remove. + (objc_struct_info): New static variable. + (objc_start_struct): Pass &objc_struct_info, not &objc_in_struct + and &objc_struct_types, to start_struct. + (objc_finish_struct): Likewise for finish_struct. + +2009-06-15 Ian Lance Taylor + + * objc-act.c (objc_start_function): Don't set + label_context_stack_se or label_context_stack_vm. + +2009-06-12 Aldy Hernandez + + * objc-act.c (finish_var_decl): Pass location to finish_decl. + (objc_get_parm_info): Same. + (get_super_receiver): Same. + * objc-act.c (objc_build_component_ref): Pass location to + build_compound_ref. + (build_module_initializer_routine): Pass location to + c_end_compound_stmt. + (objc_generate_static_init_call): Pass location to build_stmt. + (build_typed_selector_reference): New location argument. + (build_selector_reference): Same. + (objc_substitute_decl): Pass location to build_array_ref. + (next_sjlj_build_try_catch_finally): Pass location to build_stmt. + (objc_begin_catch_clause): Same. + (objc_finish_try_stmt): Same. + (objc_finish_catch_clause): Pass location to c_end_compound_stmt. + (objc_build_throw_stmt): New argument. + (generate_shared_structures): Pass location to build_c_cast. + (objc_build_message_expr): Use local location. + (objc_finish_message_expr): Use input_location. + (build_objc_method_call): New argument. + (objc_build_selector_expr): Same. + (get_super_receiver): Pass location to build_c_cast, + build_modify_expr, build_compound_expr. + * objc-act.c: Add location to all calls to start_struct, build_decl, + finish_struct. + +2009-06-09 Ian Lance Taylor + + * objc-act.c (objc_gimplify_expr): Change return type to int. + * objc-act.h: Update declaration. + +2009-06-08 Alexandre Oliva + + * objc-act.c (objc_init): Skip print_struct_values during + -fcompare-debug-second. + +2009-06-03 Ian Lance Taylor + + * Make-lang.in (cc1obj-checksum.o): Depend upon $(CONFIG_H) and + $(SYSTEM_H). + +2009-05-27 Ian Lance Taylor + + * Make-lang.in (cc1obj-dummy$(exeext)): Change $(COMPILER) to + $(LINKER). + (cc1obj$(exeext)): Likewise. + +2009-05-26 Ian Lance Taylor + + * Make-lang.in (cc1obj-dummy$(exeext)): Use $(COMPILER). + (cc1obj$(exeext)): Likewise. + +2009-05-20 Ian Lance Taylor + + * objc-act.c (objc_generate_cxx_ctor_or_dtor): Pass NULL rather + than NULL_TREE to build_special_member_call. + +2009-05-10 Ian Lance Taylor + + * objc-act.c (objc_building_struct): New static variable. + (objc_in_struct, objc_struct_types): New static variables. + (objc_start_struct, objc_finish_struct): New static functions. + (generate_struct_by_value_array): Call objc_start_struct instead + of start_struct, and call objc_finish_struct instead of + finish_struct. + (objc_build_struct, build_objc_symtab_template): Likewise. + (build_module_descriptor): Likewise. + (build_next_objc_exception_stuff): Likewise. + (build_protocol_template): Likewise. + (build_method_prototype_list_template): Likewise. + (build_method_prototype_template): Likewise. + (build_category_template, build_selector_template): Likewise. + (build_class_template, build_super_template): Likewise. + (build_ivar_template, build_ivar_list_template): Likewise. + (build_method_list_template): Likewise. + (build_method_template): Likewise. + +2009-05-10 Joseph Myers + + * objc-act.c: Include intl.h. + (objc_lookup_protocol): Use complete sentences for diagnostics + with %qE for identifiers and translating results of + gen_type_name_0 to locale character set. + (objc_check_decl, check_protocol_recursively, + lookup_and_install_protocols, objc_build_string_object, + objc_get_class_reference, objc_declare_alias, objc_declare_class, + objc_get_class_ivars, error_with_ivar, check_duplicates, + objc_finish_message_expr, objc_build_protocol_expr, + objc_build_selector_expr, build_ivar_reference, objc_add_method, + add_category, add_instance_variable, objc_is_public, + check_methods, check_methods_accessible, check_protocol, + start_class, finish_class, start_protocol, really_start_method, + get_super_receiver, objc_lookup_ivar): Use %E and %qE for + identifiers in diagnostics. Translate generated text to locale + character set as needed. + (check_protocol, check_protocols): Change name parameter to type + tree. + (lang_report_error_function): Remove. + +2009-04-27 Ian Lance Taylor + + * objc-act.c (objc_gimplify_expr): Add casts to enum type. + +2009-04-24 Ian Lance Taylor + + * objc-act.c (get_super_receiver): Update calls to + build_modify_expr to pass new argument. + +2009-04-21 Taras Glek + + * objc-act.c: Update GTY annotations to new syntax + * objc-act.h: Likewise + +2009-04-21 Joseph Myers + + * ChangeLog: Add copyright and license notices. + +2009-04-20 Ian Lance Taylor + + * objc-act.c (objc_rewrite_function_call): Change parameter from + params to first_param. Change all callers. + +2009-03-30 Dominique d'Humieres + + PR bootstrap/39583 + * objc-act.c (in_late_binary_op): Define for Objective-C++. + +2009-03-29 Joseph Myers + + PR c/456 + PR c/5675 + PR c/19976 + PR c/29116 + PR c/31871 + PR c/35198 + * objc-act.c (objc_finish_try_stmt): Set in_late_binary_op. + +2008-12-05 Sebastian Pop + + PR bootstrap/38262 + * Make-lang.in (cc1obj-dummy, cc1obj): Add BACKENDLIBS, + remove GMPLIBS. + +2008-10-06 Aldy Hernandez + + * objc-act.c (objc_build_string_object): Pass location to + build_unary_op. + (init_def_list): Same. + (init_objc_symtab): Same. + (init_module_descriptor): Same. + (build_module_initializer_routine): Same. + (generate_static_references): Same. + (build_typed_selector_reference): Same. + (add_objc_string): Same. + (objc_substitute_decl): Same. + (objc_build_ivar_assignment): Same. + (objc_build_global_assignment): Same. + (objc_build_strong_cast_assignment): Same. + (generate_protocols): Same. + (build_protocol_initializer): Same. + (build_dispatch_table_initializer): Same. + (generate_protocol_list): Same. + (build_category_initializer): Same. + (build_shared_structure_initializer): Same. + (generate_shared_structures): Same. + (objc_build_protocol_expr): Same. + (build_ivar_reference): Same. + (get_super_receiver): Same. + +2008-09-23 Aldy Hernandez + + * objc-act.c (next_sjlj_build_enter_and_setjmp): Call + c_common_truthvalue_conversion with location. + (next_sjlj_build_catch_list): Same. + (next_sjlj_build_try_catch_finally): Same. + +2008-09-17 Andrew Pinski + + PR objc/37460 + * objc-lang.c (LANG_HOOKS_GET_CALLEE_FNDECL): Don't define. + * objc-act.h (objc_get_callee_fndecl): Remove prototype. + * objc-act.c (objc_get_callee_fndecl): Kill. + +2008-09-17 Jan Hubicka + + PR c++/18071 + * objc/objc-act.c (objc_finish_method_definition): Do not set + DECL_INLINE. + +2008-09-01 Aldy Hernandez + + * objc-act.c (build_typed_selector_reference): Pass input_location to + build_unary_op calls. + (build_selector_reference): Same, but to build_array_ref. + (objc_substitute_decl): Same. + (build_ivar_reference): Same, but to build_indirect_ref. + (get_super_receiver): Same. + +2008-07-28 Richard Guenther + + Merge from gimple-tuples-branch. + + 2008-07-18 Aldy Hernandez + + * Make-lang.in (objc-lang.o): Depend on GIMPLE_H. + (objc-act.o): Rename TREE_GIMPLE_H to GIMPLE_H. + * objc-act.h: Include gimple.h instead of tree-gimple.h. + * ipa-reference.c: Same. + + 2007-11-10 Aldy Hernandez + + * objc-act.c (objc_gimplify_expr): Change pre and post to sequences. + * objc-act.h (objc_gimplify_expr): Change prototype accordingly. + +2008-07-21 Ralf Wildenhues + + * objc-act.c: Fix comment typos. + +2008-07-18 Kaveh R. Ghazi + + * objc-act.c (objc_start_class_interface, + objc_start_category_interface, objc_start_class_implementation, + objc_start_category_implementation, objc_build_struct, + generate_static_references, build_private_template, + lookup_category, objc_add_method, add_category, + add_instance_variable, objc_is_public, conforms_to_protocol, + start_class, continue_class, finish_class): Avoid C++ keywords. + +2008-07-14 Jason Merrill + + PR objc++/36723 + * objc-act.c (objc_build_constructor): Update C++ tweak. + +2007-07-14 Rafael Ávila de Espíndola + + * objc-act.c (synth_module_prologue): Use TREE_NO_WARNING instead + of DECL_IN_SYSTEM_HEADER. + +2008-07-11 Ian Lance Taylor + + * objc-act.c (objc_is_reserved_word): Always check for RID_CLASS, + etc., not just when OBJCPLUS is defined. + +2008-06-19 Kaveh R. Ghazi + + * objc-act.c (setup_string_decl, objc_build_string_object, + hash_interface, eq_interface, objc_begin_try_stmt, + encode_method_prototype, build_ivar_list_initializer, + objc_build_encode_expr): Fix for -Wc++-compat. + +2008-05-12 Tomas Bily + + * objc-act.c (objc_generate_write_barrier, objc_finish_message_expr): + Use CONVERT_EXPR_P. + +2008-04-23 Paolo Bonzini + + * objc-act.c (objc_build_string_object): Don't set TREE_INVARIANT. + +2008-04-03 Tom Tromey + + * Make-lang.in (objc_OBJS): New variable. + +2008-03-27 Tom Tromey + + * Make-lang.in: Revert automatic dependency patch. + +2008-03-27 Douglas Gregor + + PR obj-c++/35704 + * objc-act.c (objc_build_component_ref): Fix call to + finish_class_member_access_expr. + (objc_generate_cxx_ctor_or_dtor): Fix call to + build_special_member_call. + +2008-03-25 Andrew Pinski + + PR objc/29197 + * objc-act.c (encode_type): Handle when type is error_mark_node. + (objc_push_parm): Handle when the type of parm is error_mark_node. + +2008-03-25 Tom Tromey + + * Make-lang.in (objc_OBJS): New variable. + (cc1obj-checksum.o, objc/objc-lang.o, objc/objc-act.o): Remove. + +2008-03-21 Andreas Tobler + + PR bootstrap/35660 + * objc-act.c (objc_generate_cxx_ctor_or_dtor): Rename IS_AGGR_TYPE to + MAYBE_CLASS_TYPE_P. + (objc_generate_cxx_cdtors): Likewise. + (add_instance_variable): Likewise. + +2008-02-26 Tom Tromey + + * objc-act.c (objc_init): Remove old location code. + +2008-02-06 Kaveh R. Ghazi + + PR other/35107 + * Make-lang.in (cc1obj-dummy, cc1obj): Add $(GMPLIBS). + +2007-07-30 Nick Clifton + + * Make-lang.in: Change copyright header to refer to version 3 of + the GNU General Public License and to point readers at the + COPYING3 file and the FSF's license web page. + * lang-specs.h, objc-act.c, objc-tree.def, objc-act.h, + config-lang.in, objc-lang.c: Likewise. + +2007-07-29 Kaveh R. Ghazi + + * objc-act.c (objc_get_callee_fndecl): Constify. + * objc-act.h (objc_get_callee_fndecl): Likewise. + +2007-07-25 Kaveh R. Ghazi + + * objc-act.c (volatilized_hash, volatilized_eq, string_hash, + string_eq): Constify. + +2007-04-04 Stuart Hastings + + PR 31281 + * objc/objc-act.c (next_sjlj_build_catch_list): Delete volatile from rethrow decl. + +2007-03-01 Brooks Moses + + * Make-lang.in: Add dummy lang.install-pdf target. + +2007-02-18 Kazu Hirata + + * objc/objc-act.c: Fix comment typos. + +2007-02-15 Sandra Loosemore + Brooks Moses + Lee Millward + + * objc-act.c (receiver_is_class_object): Use new CALL_EXPR accessors. + (objc_get_callee_fndecl): Likewise. + +2007-01-23 Andrew Pinski + + PR objc/27438 + * objc-act.c (objc_add_static_instance): Mark the decl as + TREE_USED. + +2007-01-20 Andrew Pinski + + PR objc/30479 + * objc-act.c (hash_interface): Use IDENTIFIER_HASH_VALUE instead + of htab_hash_pointer. + (lookup_interface): Likewise. + (add_class): Likewise. + +2007-01-02 Douglas Gregor + + * objc-act.c (objc_build_volatilized_type): Keep track of + canonical types. + (objc_get_protocol_qualified_type): Ditto. + +2006-11-02 Andreas Tobler + + * objc-act.c (objc_finish_file): Remove ifdef clause for OBJCPLUS and + content where we called cp_finish_file. + +2006-10-23 Rafael Ávila de Espíndola + + * objc-act.c (synth_module_prologue): Replace calls to + builtin_function with add_builtin_function. + (build_next_objc_exception_stuff): Replace calls to + builtin_function with add_builtin_function. + (build_objc_exception_stuff): Replace calls to + builtin_function with add_builtin_function. + +2006-10-10 Brooks Moses + + * Make-lang.in: Added empty "objc.pdf" target. + +2006-09-26 Andrew Pinski + + PR objc/29195 + * objc-act.c (objc_push_parm): If we change the type of the + decl, relayout the decl. + +2006-09-19 Eric Christopher + + * objc-act.c (JBLEN): Rename to OBJC_JBLEN, + default to something innocuous. + (build_next_objc_exception_stuff): Rename JBLEN. + +2006-07-28 Volker Reichelt + + * Make-lang.in: Use $(HEADER_H) instead of header.h in dependencies. + +2006-07-19 Volker Reichelt + + PR obj-c++/28434 + * objc-act.c (lookup_and_install_protocols): Skip error_mark_nodes. + +2006-06-06 Mike Stump + + * objc-act.c: Remove prototype for objc_build_volatilized_type. + +2006-05-24 Mike Stump + + * objc-act.c (build_next_objc_exception_stuff): Use JBLEN instead of _JBLEN. + +2006-05-05 Volker Reichelt + + PR objc/27240 + * objc-act.c (objc_is_public): Return early on invalid type. + +2006-03-02 Fariborz Jahanian + + * objc-act.c (init_module_descriptor): Remove file name from + module descriptor. + (gen_type_name_0): Fix ICE when issuing warning. + +2006-02-20 Rafael Ávila de Espíndola + * Make-lang.in (OBJC): Remove + (OBJECTIVE-C): Remove + (objective-c): Remove + (.PHONY): Remove objective-c and ObjC + +2005-12-14 Andrew Pinski + + PR objc/25360 + * objc/objc-act.c (encode_type): Encode Complex types as 'j' followed + by the inner type. + +2005-12-12 Andrew Pinski + + PR objc/25348 + * objc-act.c (encode_array): Handle arrays to zero sized types. + +2005-12-07 Rafael Ávila de Espíndola + + * Make-lang.in (objc.all.build, objc.install-normal): Remove. + +2005-12-07 Rafael Ávila de Espíndola + + * Make-lang.in: Remove all dependencies on s-gtype. + +2005-12-02 Richard Guenther + + * objc-act.c (objc_build_exc_ptr, next_sjlj_build_enter_and_setjmp + next_sjlj_build_exc_extract, next_sjlj_build_catch_list, + next_sjlj_build_try_catch_finally, objc_begin_catch_clause, + build_objc_method_call, objc_rewrite_function_call): Use buildN + instead of build. + +2005-10-20 Geoffrey Keating + + * objc-act.c (synth_module_prologue): Clear TREE_NOTHROW + on objc_msgSend and like builtin functions. + +2005-10-17 Andreas Krebbel + + * objc-act.c (objc_build_component_ref): Adjust call to + finish_class_member_access_expr due to a changed prototype. + +2005-08-31 Andrew Pinski + + PR objc/23306 + * objc-act.c (generate_strings): Remove and move code to + finish decl to ... + (add_objc_string): here when creating a new string decl. + (finish_objc): Don't call generate_strings. + +2005-08-31 Andrew Pinski + + PR objc/23381 + * objc-act.c (next_sjlj_build_try_catch_finally): Set + TREE_SIDE_EFFECTS on catch_seq after building it. + +2005-08-09 Andrew Pinski + + part of PR objc/21992 + * objc-act.c (handle_class_ref): The ref decl is always referenced. + +2005-07-20 Giovanni Bajo + + Make CONSTRUCTOR use VEC to store initializers. + * objc-act.c (objc_build_constructor): Use build_constructor_from_list + instead of build_constructor. + +2005-07-08 Daniel Berlin + + * objc-act.c (objc_push_parm): DECL_ARG_TYPE_AS_WRITTEN is + removed. + * objc-act.h (KEYWORD_ARG_NAME): Use decl_non_common. + (KEYWORD_KEY_NAME): Use decl_minimal. + (METHOD_SEL_NAME): Ditto.. + (METHOD_SEL_ARGS): Use decl_non_common. + (METHOD_ADD_ARGS): Ditto. + (METHOD_ADD_ARGS_ELLIPSIS_P): Use decl_common. + (METHOD_DEFINITION): Ditto. + (METHOD_ENCODING): Ditto. + * objc-lang.c: (objc_init_ts): New function. + +2005-07-07 Ziemowit Laski + + * objc-act.c (objc_build_struct): Pass in an actual @interface + instead of its name, and annotate the struct created (and all + existing variants thereof) with the @interface. + (objc_compare_types): Treat forward-declared ObjC classes + as stand-alone (root) classes for purposes of type comparisons. + (build_private_template): Move some code to objc_build_struct(). + +2005-07-07 Ziemowit Laski + + PR objc/22274 + * objc-act.c (objc_build_string_object): For GNU-style constants, + use the @interface type rather than the built-in type. + +2005-07-03 Kazu Hirata + + * Make-lang.in (cc1plus-checksum.c): Use + build/genchecksum$(build_exeext), not build/genchecksum$(exeext). + +2005-07-02 Joseph S. Myers + + * objc-act.c: Use %q to quote in diagnostics. + +2005-07-02 Joseph S. Myers + + * objc-act.c: Use '+' flag instead of %J. Use 'q' flag for + quoting. + +2005-06-30 Ziemowit Laski + + * objc-act.c (objc_build_volatilized_type): New function. + (objc_volatilize_decl): Call objc_build_volatilized_type() + instead of build_qualified_type(). + +2005-06-29 Ziemowit Laski + + * objc-act.c (objc_build_internal_const_str_type): New function. + (check_string_class_template): Use objc_get_class_ivars() instead + of TYPE_FIELDS() to retrieve ivar list. + (AT_LEAST_AS_LARGE_AS): Check the size of each field's type rather + than the field itself. + (objc_build_string_object): Synthesize a "__builtin_ObjCString" + type and use it to lay out compile-time string objects. + * objc-act.h (OCTI_INTERNAL_CNST_STR_TYPE, internal_const_str_type): + New. + +2005-06-28 Paul Brook + + * objc-act.c (objc_init_exceptions): Call + default_init_unwind_resume_libfunc. + +2005-06-27 Ziemowit Laski + + * objc-act.c (objc_build_struct): Save the TYPE_OBJC_INFO + portion of TYPE_LANG_SPECIFIC info for all variants of + a class before calling finish_struct(), and restore + same TYPE_OBJC_INFO afterwards. + +2005-06-25 Kelley Cook + + * all files: Update FSF address in copyright headers. + +2005-06-15 Joseph S. Myers + + * objc-act.c (my_build_string_pointer): New. + (objc_get_class_reference, get_super_receiver): Call + my_build_string_pointer instead of my_build_string when building + function arguments. + +2005-05-25 Mike Stump + + * objc-act.c (volatilized_hash): Avoid warnings on 64-bit + machines. + +2005-05-24 Ziemowit Laski + + * objc-act.c (objc_build_struct): New function. + (objc_derived_from_p): Likewise. + (objc_build_component_ref): Likewise. + (objc_copy_binfo): Likewise. + (objc_xref_basetypes): Likewise. + (objc_lookup_protocol): Likewise. + (objc_compare_protocols): Likewise. + (objc_volatilize_decl): Likewise. + (encode_aggregate_fields): Likewise. + (volatilized_hash): Likewise. + (volatilized_eq): Likewise. + (objc_compare_types): Likewise. + (objc_type_quals_match): Likewise. + (DERIVED_FROM_P): New ObjC macro, corresponding to C++ macro + of same name. + (get_class_ivars): Add second parameter indicating if entire + hierarchy is desired. + (struct volatilized_type): New type. + (volatilized_htab): New hash table. + (objc_types_compatible_p, objc_comptypes): Remove functions. + (synth_module_prologue): Do not initialize 'unused_list'. + (objc_get_class_reference): Fix ObjC++ impedance mismatches. + (objc_declare_alias): Implement as a typedef. + (objc_substitute_decl, objc_gimplify_expr): Reformat. + (objc_get_class_ivars): Adjust call to get_class_ivars(). + (next_sjlj_build_enter_and_setjmp, synth_forward_declarations, + build_ivar_reference, get_super_receiver): Call + objc_build_component_ref() instead of build_component_ref(). + (objc_begin_catch_clause): Use DERIVED_FROM_P() instead of + objc_comptypes(). + (build_private_template): Call objc_build_struct() instead of + start_struct() and finish_struct(). + (hash_init): Initialize volatilized_htab. + (objc_is_public): Adjust calls to objc_get_ivars(); adjust + ObjC++ impedance mismatches. + (encode_aggregate_within): Streamline by calling + encode_aggregate_fields(). + * objc-act.h (objc_types_compatible_p): Remove prototype. + (OCTI_UNUSED_LIST, unused_list): Remove slot. + * objc-lang.c (LANG_HOOKS_TYPES_COMPATIBLE_P): Remove. + +2005-05-18 Geoffrey Keating + + * Make-lang.in (cc1obj-dummy): New. + (cc1obj-checksum.c): New. + (cc1obj-checksum.o): New. + (cc1obj): Add cc1obj-checksum.o. + +2005-05-18 Mike Stump + + PR objc/21641 + * objc-act.c (struct interface_tuple): Mark it up for GC. + (interface_htab): It is really a struct interface_tuple. + +2005-05-17 Ziemowit Laski + Mike Stump + + Yet more Objective-C++... + + * objc-act.c (objc_finish_try_stmt): Add return value. + (objc_build_synchronized): Likewise. + + * objc-act.c (objc_is_gcable_type): Add. + (objc_substitute_decl): Add. + (objc_build_ivar_assignment): Add. + (objc_build_global_assignment): Add. + (objc_build_strong_cast_assignment): Add. + (objc_is_ivar_reference_p): Add. + (objc_is_global_reference_p): Add. + (objc_generate_write_barrier): Add. + (objc_rewrite_function_call): Add. + (objc_gimplify_expr): Add Objective-C++ support. + * objc-act.h (ALLOC_OBJC_TYPE_LANG_SPECIFIC): Likewise. + (SIZEOF_OBJC_TYPE_LANG_SPECIFIC): Add. + (INIT_TYPE_OBJC_INFO): Add Objective-C++ support. + (DUP_TYPE_OBJC_INFO): Likewise. + (struct imp_entry): Add field has_cxx_cdtors. + (struct imp_entry *imp_list): Add OCTI_UMSG_FAST_DECL, + OCTI_METH_LIST_TEMPL, OCTI_METH_PROTO_LIST_TEMPL, + OCTI_IVAR_LIST_TEMPL, OCTI_ASSIGN_IVAR_DECL, + OCTI_ASSIGN_IVAR_FAST_DECL, OCTI_ASSIGN_GLOBAL_DECL, + OCTI_ASSIGN_STRONGCAST_DECL. + (umsg_fast_decl): Add. + (objc_assign_ivar_decl): Add. + (objc_assign_ivar_fast_decl): Add. + (objc_assign_global_decl): Add. + (objc_assign_strong_cast_decl): Add. + (objc_method_list_ptr): Add. + (objc_method_proto_list_ptr): Add. + (objc_ivar_list_ptr): Add. + + * objc-act.c (should_call_super_dealloc): Add. + (OBJC_VERSION): Bump to 6. + (objc_is_gcable_type): Add. + (objc_substitute_decl): Add. + (objc_build_ivar_assignment): Add. + (objc_build_global_assignment): Add. + (objc_build_strong_cast_assignment): Add. + (objc_is_gcable_p): Add. + (objc_is_ivar_reference_p): Add. + (objc_is_global_reference_p): Add. + (generate_shared_structures): Add flags parameter. + (objc_generate_cxx_ctor_or_dtor): Add. + (objc_generate_cxx_cdtors): Add. + (add_class): Add name parameter. + (objc_types_share_size_and_alignment): Add. + (comp_proto_with_proto): Add strict parameter. + (CLS_HAS_CXX_STRUCTORS): Add. + (TAG_ASSIGNIVAR): Add. + (TAG_ASSIGNGLOBAL): Add. + (TAG_ASSIGNSTRONGCAST): Add. + (TAG_MSGSEND_FAST): Add. + (TAG_ASSIGNIVAR_FAST): Add. + (TAG_CXX_CONSTRUCT): Add. + (TAG_CXX_DESTRUCT): Add. + (OBJC_LOOKUP_CLASS): Add. + (OBJC_LOOKUP_NO_SUPER): Add. + (objc_finish_file): Add pch support. + (objc_finish_implementation): Add Objective-C++ support. + (synth_module_prologue): Likewise. + (synth_module_prologue): Add fast dispatching. + (objc_get_class_reference): Add Objective-C++ support. + (objc_generate_write_barrier): Likewise. + (next_sjlj_build_enter_and_setjmp): Likewise. + (objc_begin_try_stmt): Likewise. + (build_next_objc_exception_stuff): Add fast ivar support. + (build_private_template): Mark the record as used so debug + information is generated. + (build_protocol_template): Add Objective-C++ support. + (objc_method_parm_type) Likewise. + (objc_generate_cxx_ctor_or_dtor): Likewise. + (objc_generate_cxx_cdtors): Likewise. + (build_protocol_initializer): Likewise. + (build_category_template): Likewise. + (build_class_template): Likewise. + (build_method_list_template): Likewise. + (build_category_initializer): Likewise. + (build_shared_structure_initializer): Likewise. + (objc_finish_message_expr): Likewise. + (build_objc_method_call): Add fast dispatch support. + (lookup_method_static): Add support to end search at superclasses. + (add_method_to_hash_list): Add strict parameter to + comp_proto_with_proto. + (objc_add_method): Likewise. + (objc_add_method): Also set the interface_value. + (add_instance_variable): Add Objective-C++ support. + (objc_is_public): Likewise. + (start_class): Likewise. + (continue_class): Likewise. + (encode_aggregate_within): Likewise. + (start_method_def): Likewise. + (objc_start_function): Clear current_function_returns_value + and current_function_returns_null. + (really_start_method): Add Objective-C++ support. + (objc_finish_method_definition): Add warning for missing + [super dealloc]. + (finish_objc): Add Objective-C++ support. + (generate_objc_image_info): Likewise. + (objc_lookup_ivar): Likewise. + * objc-act.h (TYPE_HAS_OBJC_INFO): Likewise. + (INIT_TYPE_OBJC_INFO): Likewise. + (DUP_TYPE_OBJC_INFO): Likewise. + +2005-04-23 DJ Delorie + + * objc-act.c: Adjust warning() callers. + +2005-04-21 Roger Sayle + + * objc-act.h (METHOD_ADD_ARGS_ELLIPSIS_P): New macro for accessing + this field of an objc method decl. + * objc-act.c (build_method_decl): Take an additional "ellipsis" + argument, and set METHOD_ADD_ARGS_ELLIPSIS_P as appropriate. + (objc_build_method_signature): Accept additional "ellipsis" + argument and pass it to build_method_decl. + (get_arg_type_list, start_method_def, gen_method_decl): Use + the new METHOD_ADD_ARGS_ELLIPSIS_P instead of examining the + TREE_OVERFLOW field of a TREE_LIST node. + +2005-04-20 Joseph S. Myers + + PR c/12913 + * objc-act.c (objc_start_function): Create stack level for context + of identifiers with variably modified type. + +2005-03-30 Joseph S. Myers + + PR c/772 + PR c/17913 + * objc-act.c (objc_start_function): Push context on + label_context_stack. + +2005-03-23 Joseph S. Myers + + * objc-act.c (next_sjlj_build_enter_and_setjmp, + next_sjlj_build_catch_list, next_sjlj_build_try_catch_finally): + Call c_common_truthvalue_conversion. + +2005-02-25 Joseph S. Myers + + * Make-lang.in (objc/objc-parse.o-warn, objc/objc-parse.o, + objc/objc-parse.c, objc/objc-parse.y): Remove + (OBJC_OBJS, objc.srcextra, objc.tags, objc.mostlyclean, + objc.distclean, objc.maintainer-clean): Update for new parser. + * config-lang.in (gtfiles): Update for new parser. + +2005-01-29 Kazu Hirata + + * lang-specs.h, objc-act.c, objc-act.h, objc-lang.c: Update + copyright. + +2005-01-27 Matt Austern + + * objc-act.c (objc_finish_file): In ObjC++ mode, set at_eof before + calling instantiate_pending_templates. + +2005-01-26 Alexander Malmberg + + PR objc/18862 + * objc-act.c (build_selector_translation_table): Use + input_location in the diagnostic for the GNU runtime or if + TREE_PURPOSE (chain) is NULL. + +2005-01-25 Alexander Malmberg + + PR objc/18408 + * objc-act.c (objc_types_compatible_p): New function. + * objc-act.h (objc_types_compatible_p): Declare. + * objc-lang.c (LANG_HOOKS_TYPES_COMPATIBLE_P): Define. + +2005-01-16 Ziemowit Laski + + * objc-act.c (objc_push_parm): Call c_type_promotes_to() + via a lang-hook. + +2005-01-15 Ziemowit Laski + + PR objc/19321 + * objc-act.c (get_arg_type_list): Decay function arguments into + pointers. + (objc_push_parm): Likewise; bring PARM_DECL construction closer + in line with what the C front-end does. + (objc_get_parm_info): Call pushdecl() and finish_decl() on + each PARM_DECL, like the C front-end does. + (start_method_def): Remove redundant ARRAY_TYPE decay. + (objc_start_function): Bring closer in line with what the + C front-end does for functions. + +2005-01-14 Mike Stump + + * lang-specs.h ("@objective-c"): Use cc1obj when -E is used so + that -fobjc-exceptions is accepted. + +2004-12-30 Ziemowit Laski + + PR objc/18971 + * objc-act.c (get_arg_type_list, start_method_def): Decay + array arguments into pointers. + (gen_type_name_0): Learn to pretty-print array types. + +2004-12-15 Ziemowit Laski + + * objc-act.c (build_private_template): Change to return 'void'; do + not set ivar_context, uprivate_record or objc_instance_type. + (objc_comptypes, gen_type_name_0): For types 'id' and 'Class', + retrieve protocol list from the pointee rather than the pointer itself; + check TYPE_HAS_OBJC_INFO(...) precondition before accessing + TYPE_OBJC_PROTOCOL_LIST. + (objc_get_protocol_qualified_type): For types 'id' and 'Class', + construct a variant of the pointee as well as the pointer, and + store protocol information in the former. When creating variants + of RECORD_TYPEs, clone their TYPE_LANG_SPECIFIC fields and propagate + TYPE_OBJC_INTERFACE information. + (objc_declare_class): If a TYPE_DECL is looked up, retrieve the + underlying RECORD_TYPE to check for presence of TYPE_OBJC_INTERFACE; + for newly-created RECORD_TYPEs, create a tentative TYPE_OBJC_INTERFACE + holding an IDENTIFIER_NODE. + (objc_finish_message_expr): Check TYPE_HAS_OBJC_INFO(...) before + accessing TYPE_OBJC_PROTOCOL_LIST; Use TYPE_OBJC_INTERFACE instead + of calling lookup_interface(); allow for TYPE_OBJC_INTERFACE holding + an IDENTIFIER_NODE (meaning a @class forward-declaration only). + (objc_is_public): Check TYPE_OBJC_INTERFACE instead of calling + lookup_interface(). + (continue_class): For @implementations, set ivar_context, + uprivate_record and objc_instance_type, for @interfaces, call + build_private_template(). + (encode_pointer): Check TYPE_HAS_OBJC_INFO(...) before accessing + TYPE_OBJC_INTERFACE. + (objc_types_are_equivalent): Check TYPE_HAS_OBJC_INFO(...) before + accessing TYPE_OBJC_PROTOCOL_LIST. + * objc-act.h (OBJC_INFO_SLOT_ELTS, TYPE_OBJC_INFO, INIT_TYPE_OBJC_INFO, + DUP_TYPE_OBJC_INFO, ALLOC_OBJC_TYPE_LANG_SPECIFIC, + SIZEOF_OBJC_TYPE_LANG_SPECIFIC): New macros. + (TYPE_OBJC_INTERFACE): Replaces TREE_STATIC_INSTANCE and now points + to an actual @interface; stored in TYPE_LANG_SPECIFIC(...). + (TYPE_OBJC_PROTOCOL_LIST): Replaces TYPE_PROTOCOL_LIST; stored in + TYPE_LANG_SPECIFIC(...). + (TREE_STATIC_INSTANCE, TYPE_PROTOCOL_LIST): Delete. + (IS_ID, IS_CLASS, IS_PROTOCOL_QUALIFIED_UNTYPED, IS_SUPER, + TYPED_OBJECT): Check for POINTER_TYPE rather than POINTER_TYPE_P; + adjust for use of TYPE_OBJC_INTERFACE and TYPE_OBJC_PROTOCOL_LIST + instead of TREE_STATIC_INSTANCE and TYPE_PROTOCOL_LIST. + +2004-11-29 Joseph Myers + + PR c/7544 + * Make-lang.in (objc/objc-act.o): Update dependencies. + * objc-act.c (objc_finish_file): Call + maybe_apply_pending_pragma_weaks if not OBJCPLUS. + +2004-11-09 Andrew Pinski + + PR objc/18406 + * obj-act.c (encode_type): 96bits doubles are encoded the + same way as 64bit and 128bit doubles are. + +2004-11-09 Joseph S. Myers + + * objc-act.c: Use %q, %< and %> for quoting in diagnostics. + +2004-11-08 Andrew Pinski + + PR objc/16546 + * objc-act.c (generate_method_descriptors): Remove setting + the new decls' type to variable_length_type. + (generate_ivar_lists): Likewise. + (generate_dispatch_tables): Likewise. + +2004-10-30 Ziemowit Laski + + * objc-act.c (objc_lookup_ivar): The new OTHER parameter + contains the result of the ID lookup by the C or C++ + front-end; in class methods, use OTHER if it exists; + in instance methods, use OTHER only if it is locally + declared. + +2004-10-26 Ziemowit Laski + + * objc-act.c (finish_class): Do not synthesize bogus + 'extern objc_object *_Foo;' declarations for @interface Foo. + +2004-10-25 Ziemowit Laski + David Ayers + + * objc-act.c (objc_comptypes): Use IS_PROTOCOL_QUALIFIED_UNTYPED + instead of IS_PROTOCOL_QUALIFIED_ID; add comparisons for: + 'Class != id '; 'Class != *'; + 'Class == id' and 'Class == Class'. + (objc_is_id): Add test for 'super'. + (objc_finish_message_expr): Allow for messaging of 'Class ' + receivers; if class methods are not found in protocol lists, search + for instance methods therein and warn if one is found. Look in + global hash tables for suitable method as a last resort when messaging + 'id ', 'Class ' and invalid receiver types. + (objc_add_method): Insert instance methods listed in protocols into + the global class method hash table. + * objc-act.h (IS_PROTOCOL_QUALIFIED_ID): Rename to + IS_PROTOCOL_QUALIFIED_UNTYPED and allow for 'Class ' in + addition to 'id '. + +2004-10-21 Andrew Pinski + + PR objc/17923 + * objc-act.c (objc_build_string_object): Create a CONST_DECL + for the NeXT runtime case. + +2004-10-02 Kazu Hirata + + * objc-act.c: Fix comment typos. + +2004-09-24 Ziemowit Laski + + * objc-act.c (init_objc_symtab, init_module_descriptor, + build_shared_structure_initializer): When initializing 'long' + fields, ensure that the initializer value is also 'long'. + +2004-09-24 Zack Weinberg + + * objc-act.c: Change annotate_with_locus to SET_EXPR_LOCATION + throughout. + (objc_init): Only set input_line to 0 #ifndef USE_MAPPED_LOCATION. + (build_selector_translation_table): Use %J in diagnostic + instead of diddling input_line. Fix spelling. + +2004-09-21 Ziemowit Laski + + * objc-act.c (objc_fold_objc_type_ref): New function. + * objc-act.h (objc_fold_objc_type_ref): New prototype. + +2004-09-09 Joseph S. Myers + + * objc-act.c (objc_start_function, really_start_method, + objc_get_parm_info, start_method_def): Update to new arg_info + structures. + +2004-09-07 Ziemowit Laski + + * Make-lang.in (objc/objc-parse.o): Depend on $(C_COMMON_H) instead of + objc/objc-act.h. + (objc/objc-act.o): Depend on $(HASHTAB_H). + * objc-act.c: Include hashtab.h; in ObjC++ mode, include cp-tree.h and + objcp-decl.h instead of c-tree.h. + (build_module_descriptor, get_class_ivars, synth_id_with_class_suffix, + error_with_ivar, gen_method_decl, gen_declaration, setup_string_decl, + build_protocol_template): Adjust prototypes. + (build_module_initializer_routine, start_class, continue_class, + finish_class, start_method_def, objc_start_function, start_protocol, + build_method_decl, objc_add_method, add_instance_variable, + build_ivar_reference, is_ivar, is_private, get_super_receiver, + build_selector_table_decl, objc_push_parm, objc_get_parm_info, + gen_type_name, gen_type_name_0, start_var_decl, finish_var_decl, + create_field_decl): New prototypes. + (objc_expand_function_end, comp_method_with_proto, objc_expr_last, + gen_declaration_1, gen_declarator, is_complex_decl, adorn_decl, + define_decl, create_builtin_decl, gen_declspecs): Remove prototypes. + (TYPE_ID): Rename to OBJECT_TYPEDEF_NAME. + (CLASS_TYPEDEF_NAME): New. + (TAG_EXECCLASS): Change from a global variable to a #define. + (TAG_RETURN_STRUCT): Delete. + (TAG_GNUINIT): New, holds '__objc_gnu_init' name. + (objc_inherit_code, objc_public_flag): New, moved from c-parse.in. + (string_descriptor): New struct. + (string_htab): New hash table. + (string_hash, string_eq): New prototypes. + (generate_struct_by_value_array): Call create_field_decl() instead of + create_builtin_decl(). + (objc_init): Do not initialize objc_ellipsis_node or TAG_EXECCLASS; + In ObjC++ mode, call cxx_init() instead of c_objc_common_init(). + (objc_finish_file): In ObjC++, call instantiate_pending_templates() + and cp_finish_file(). + (define_decl, get_static_reference, get_protocol_reference, + create_builtin_decl): Remove functions. + (objc_start_class_interface, objc_start_category_interface, + objc_start_protocol, objc_continue_interface, objc_finish_interface, + objc_start_class_implementation, objc_start_category_implementation, + objc_continue_implementation, objc_finish_implementation, + objc_set_visibility, objc_set_method_type, + objc_build_method_signature, objc_add_method_declaration, + objc_start_method_definition, objc_add_instance_variable, + objc_get_protocol_qualified_type, create_field_decl, + start_var_decl, finish_var_decl): New functions. + (setup_string_decl): Simplify since it is only called once. + (synth_module_prologue): Call build_class_template(); predefine 'id' + and 'Class' as typedefs; rename 'temp_type' to 'type'; disable debug + hooks for duration of function; fix GNU runtime messenger signatures + to correspond to reality; forward-declare '__objc_exec_class' for the + GNU runtime; call build_selector_table_decl(); in ObjC++ mode, generate + 'extern "C" { ... }' wrappers around synthesized declarations; call + build_protocol_template() and build_category_template(). + (string_hash, string_eq): New functions. + (objc_build_string_object): Check metaclass correctness only once; + store string literals in hash table. + (objc_build_constructor): Do not convert initializer elements; + adjust for ObjC++ impedance mismatch. + (build_objc_symtab_template): Call create_field_decl() instead of + create_builtin_decl(). + (init_objc_symtab): Add missing conversion to initializer element. + (build_metadata_decl): Call start_var_decl() instead of define_decl(). + (generate_objc_symtab_decl): Do not call build_category_template(); + call start_var_decl() and finish_var_decl() instead of start_decl() + and finish_decl(). + (build_module_descriptor): Call create_field_decl() instead of + grokfield(); call start_var_decl() and finish_var_decl() instead of + start_decl() and finish_decl(); always mark module descriptor as + used; move GNU runtime-specific functionality to + build_module_initializer_routine(). + (build_module_initializer_routine): New function, broken off of + build_module_descriptor(). + (objc_static_init_needed_p, objc_generate_static_init_call): New + functions. + (generate_static_references, generate_strings, + build_selector_translation_table, generate_descriptor_table, + generate_ivars_list, generate_dispatch_table, generate_category): Call + start_var_decl() and finish_var_decl() instead of start_decl() and + finish_decl(); build a type directly instead of via groktypename(). + (build_selector_reference_decl, build_selector_table_decl, + build_class_reference_decl, build_protocol_reference, + generate_objc_image_info): Call start_var_decl() instead of + build_decl(). + (build_selector_reference): For GNU runtime, do not call + build_selector_reference_decl(). + (build_selector, build_typed_selector_reference): Always convert + result to the selector type. + (add_objc_string): Cast return value to 'char *'. + (build_method_prototype_template, build_selector_template, + build_method_template): Use actual selector type for fields + pointing to selectors. + (finish_objc): For GNU runtime, call + build_module_initializer_routine() after build_module_descriptor(). + (generate_protocol_list, generate_shared_structures): Call + start_var_decl() and finish_var_decl() instead of start_decl() and + finish_decl(); build a type directly instead of via + groktypename(). + (synth_id_with_class_suffix): Return a string. + (get_arg_type_list): For instance methods, use the instance type for + 'self'; do not call groktypename_in_parm_context(). + (build_objc_string_decl): Squash redeclaration errors in ObjC++. + (objc_is_class_name): Use OBJC_TYPE_NAME instead of TYPE_NAME; + handle RECORD_TYPEs in ObjC as well as ObjC++. + (objc_is_id): New function. + (objc_is_object_ptr): Return the canonical type node. + (objc_get_class_ivars): Simplify using get_class_ivars(). + (get_class_ivars): Remove second parameter; create a fresh copy + of the ivar list for each call; do not check for existence of + super class. + (objc_eh_runtime_type): Mark #ifndef OBJCPLUS. + (objc_init_exceptions): When using SJLJ-style exceptions, require + the use of '-fobjc-exceptions' flag; do not require it for DWARF-style + exceptions. + (objc_build_exc_ptr, next_sjlj_build_try_catch_finally): Use + objc_object_type instead of objc_id_type. + (objc_begin_catch_clause): Convert the incoming PARM_DECL into + a VAR_DECL before placing it in the appropriate scope; do not + call define_decl(); adjust call to c_begin_compound_stmt(); + use objc_object_type instead of objc_id_type. + (build_next_objc_exception_stuff): Call create_field_decl() instead + of create_builtin_decl(); construct type directly instead of calling + groktypename(); use OBJC_VOID_AT_END to mark end of function parameters. + (build_private_template): Adjust call to get_class_ivars(); build + a type directly instead of via groktypename(). + (build_protocol_template, build_method_prototype_list_template, + build_method_prototype_template, build_category_template, + build_selector_template, build_class_template, build_super_template, + build_ivar_template, build_ivar_list_template, + build_method_list_template, build_method_template): + Call create_field_decl() instead of grokfield(). + (objc_method_parm_type): Do not call groktypename(). + (generate_descriptor_table): Call start_var_decl() and + finish_var_decl() instead of start_decl() and finish_decl(). + (generate_method_descriptors, build_protocol_initializer, + generate_dispatch_tables, build_category_initializer, + build_shared_structure_initializer): Do not call groktypename(). + (generate_protocols): Call start_var_decl() and finish_var_decl() + instead of start_decl() and finish_decl(); do not call groktypename(). + (error_with_ivar): Remove last parameter. + (check_ivars): Do not iterate ovar CLASS_RAW_IVARS lists in addition + to CLASS_IVARS lists; adjust calls to error_with_ivar(). + (generate_ivar_lists): Convert one of the initializer elements; do + not call groktypename(). + (get_arg_type_list, start_method_def, gen_method_def): Account for + new representation of variable arguments and '...' in Objective-C + methods; add Objective-C++ impedance matching code. + (is_objc_type_qualifier): Remove function. + (adjust_type_for_id_default): Simplify; there is no longer a need to + wade through declspecs. + (lookup_interface, start_class, continue_class, + finish_class, start_method_def, start_protocol, build_method_decl, + objc_add_method, add_instance_variable, build_ivar_reference, + is_ivar, is_private, get_super_receiver, objc_build_finally_epilogue): + Make into static functions. + (receiver_is_class_object): Use new IS_CLASS() macro. + (objc_build_message_expr): Tweak ObjC++ message argument handling; + call objc_finish_message_expr() instead of finish_message_expr(). + (finish_message_expr): Rename to objc_finish_message_expr(); use + OBJC_TYPE_NAME and OBJC_SET_TYPE_NAME macros instead of TYPE_NAME. + call gen_type_name() instead of gen_declaration(); call objc_is_id() + instead of using IS_ID and IS_CLASS; Use objc_class_name instead of + calling get_identifier("Class"); handle CONVERT_EXPRs in receiver. + (build_objc_method_call, warn_with_method): Do not call groktypename(). + (build_ivar_reference): Call convert() instead of clobbering in a + type. + (hash_init): Initialize string_htab hash table. + (add_instance_variable): Simplify parameter list; do not call grokfield(); + do not populate CLASS_IVARS list. + (start_class): Check for the existence of super class, if one was specified. + (continue_class): Use CLASS_RAW_IVARS rather than CLASS_IVARS; do not + call build_class_template(); adjust call to get_class_ivars(); call + build_decl(), pushdecl() and finish_decl() instead of define_decl(). + (finish_class): Call build_decl(), pushdecl() and finish_decl() instead + of define_decl(). + (add_protocols): Use PROTOCOL_BINFO_ELTS for the tree vector size. + (start_protocol): Do not call build_protocol_template(); use + PROTOCOL_BINFO_ELTS for the tree vector size. + (encode_type_qualifiers): Do not handle the 'const' qualifier here. + (encode_pointer): Encode 'const char *' as 'r*', for backwards + compatibility. + (encode_array): Use HOST_WIDE_INT_PRINT_DEC instead of "%ld". + (encode_type): Handle the 'const' qualifier here. + (objc_parmlist): New global variable, sued by objc_push_parm and + objc_get_parm_info(). + (objc_push_parm, objc_get_parm_info): New functions. + (objc_expr_last): Remove function. + (synth_self_and_ucmd_args): For instance methods, use the instance + type for 'self'; call objc_push_parm() instead of push_parm_decl(). + (start_method_def): Do not call push_scope(), declare_parm_level(), + pop_scope(), push_parm_decl(), store_parm_decls() or objc_expr_last(); + just use objc_push_parm() and objc_get_parm_info(). + (comp_method_with_proto): Remove function. + (objc_types_are_equivalent): Strip away indirections before comparing + underlying types. + (comp_proto_with_proto): Do not call groktypename(); types are no + longer in raw declspec format. + (objc_start_function): New function. + (really_start_method): Call comp_proto_with_proto() instead of + comp_method_with_proto(); call objc_start_function() instead of + hand-crafting a function declarator. + (continue_method_def, objc_expand_function_end): Remove functions. + (get_super_receiver): Call objc_get_current_scope() instead of + get_current_scope(); reference 'super_class' field (instead of + 'class'). + (finish_method_def): Rename to objc_finish_method_definition() and + add a function decl parameter; move method encoding call from + objc_expand_function_end(). + (is_complex_decl, adorn_decl, gen_declarator, gen_declspecs, + gen_declaration_1): Remove functions. + (tmpbuf, RAW_DECLSPEC): Remove. + (gen_declaration): Remove second parameter; simplify to deal + with TYPE_P nodes instead of raw declspecs. + (gen_type_name, gen_type_name_0): New functions. + (gen_method_decl): Remove second parameter; call gen_type_name() + instead of gen_declaration_1(). + (dump_interface): Adjust calls to gen_declaration() and + gen_method_decl(); do not allocate a separate string buffer. + (init_objc): Allocate a larger string buffer to accommodate + dump_interface(); adjust call to build_module_descriptor(); + add call to build_module_initializer_routine() for the GNU + runtime. + (generate_classref_translation_entry): Do not call start_decl(); call + finish_var_decl() instead of finish_decl(); call convert() instead of + build_c_cast(). + * objc-act.h (CLASS_OWN_IVARS): Remove accessor. + (CLASS_BINFO_ELTS): Reduce from 6 to 5, now that CLASS_OWN_IVARS is + gone. + (OCTI_GNU_INIT_DECL, GNU_INIT_decl): New. + (OCTI_ELLIPSIS_NODE, objc_ellipsis_node): Remove. + (OCTI_ID_ID, id_type, objc_id_id): Rename to OCTI_ID_NAME, + objc_object_type and objc_object_name, respectively. + (OCTI_CLS_REF, OCTI_CLASS_NAME, objc_class_reference, + objc_class_name): New. + (IS_CLASS): New macro. + (IS_ID, IS_SUPER): Robustify. + (OCTI_EXECCLASS_DECL, execclass_decl): New. + (finish_file, start_class, continue_class, finish_class, + start_method_def, continue_method_def, finish_method_def, + start_protocol, finish_protocol, objc_build_throw_stmt, + objc_build_try_catch_finally_stmt, objc_build_synchronized_prologue, + objc_build_synchronized_epilogue, objc_build_try_prologue, + objc_build_try_epilogue, objc_build_catch_stmt, objc_build_catch_epilogue, + objc_build_finally_prologue, objc_build_finally_epilogue, + is_ivar, is_private, is_public, add_instance_variable, objc_add_method, + get_super_receiver, objc_clear_super_receiver, get_class_ivars_from_name, + get_class_reference, get_static_reference, get_object_reference, + build_message_expr, finish_message_expr, build_selector_expr, + build_ivar_reference, build_keyword_decl, build_method_decl, + build_protocol_expr, build_objc_string_object, objc_declare_alias, + objc_declare_class, objc_declare_protocols, objc_comptypes, + objc_check_decl, build_encode_expr): Remove prototypes. + (imp_count, cat_count): Make GGC-aware. + (OBJC_SET_TYPE_NAME): New macro. + +2004-09-03 Ziemowit Laski + + * config-lang.in: Update copyright notice. + (lang_requires): Indicate that ObjC requires C to be built first. + +2004-09-01 Ziemowit Laski + + * objc-act.c (objc_check_decl): Use OBJC_TYPE_NAME macro instead of + TYPE_NAME. + (build_objc_string_object): Rename to objc_build_string_object(). + (get_class_reference): Rename to objc_get_class_reference(). + (get_class_ivars_from_name): Rename to objc_get_class_ivars(). + (next_sjlj_build_catch_list, get_super_receiver): Call + objc_get_class_reference() instead of get_class_reference(). + (build_keyword_decl): Rename to objc_build_keyword_decl(). + (build_message_expr): Rename to objc_build_message_expr(). + (build_protocol_expr): Rename to objc_build_protocol_expr(). + (build_selector_expr): Rename to objc_build_selector_expr(). + (build_encode_expr): Rename to objc_build_encode_expr(). + * objc-act.h (get_class_ivars_from_name): Rename prototype to + objc_get_class_ivars(). + (get_class_reference): Rename prototype to objc_get_class_reference(). + (build_message_expr): Rename prototype to objc_build_message_expr(). + (build_selector_expr): Rename prototype to objc_build_selector_expr(). + (build_keyword_decl): Rename prototype to objc_build_keyword_decl(). + (build_protocol_expr): Rename prototype to objc_build_prototype_expr(). + (build_objc_string_object): Rename prototype to + objc_build_string_object(). + +2004-09-01 Ziemowit Laski + + * objc-act.c (lookup_interface): Make function 'static' and add a + local prototype. + (objc_check_decl, get_class_reference, objc_declare_alias, + objc_declare_class, objc_is_object_ptr): Call objc_is_class_name() + instead of is_class_name(). + (get_super_receiver, objc_clear_super_receiver): Call + objc_get_current_scope() instead of get_current_scope(). + (is_class_name): Rename to objc_is_class_name. + (lookup_objc_ivar): Rename to objc_lookup_ivar. + +2004-08-28 Ziemowit Laski + + * objc-act.c (objc_is_reserved_word): New function. + +2004-08-15 Ziemowit Laski + + * Make-lang.in (objc/objc-lang.o): Depend on $(C_PRETTY_PRINT_H), + $(DIAGNOSTIC_H), c-objc-common.h and gtype-objc.h, but not on toplev.h. + (objc/objc-parse.o): Do not depend on gtype-objc.h. + * objc-act.c: Do not include gtype-objc.h. + (finish_file): Rename to objc_finish_file(). + * objc-act.h (finish_file): Update copyright notice; remove prototype. + * objc-lang.c: Update copyright notice; include diagnostic.h, + c-objc-common.h, c-pretty-print.h and gtype-objc.h; do not include + toplev.h. + (finish_file): New hook routine. + (LANG_HOOKS_FINISH, LANG_HOOKS_INIT_OPTIONS, + LANG_HOOKS_INITIALIZE_DIAGNOSTICS, LANG_HOOKS_HANDLE_OPTION, + LANG_HOOKS_MISSING_ARGUMENT, LANG_HOOKS_POST_OPTIONS, + LANG_HOOKS_GET_ALIAS_SET, LANG_HOOKS_SAFE_FROM_P, + LANG_HOOKS_EXPAND_EXPR, LANG_HOOKS_MARK_ADDRESSABLE, + LANG_HOOKS_PARSE_FILE, LANG_HOOKS_TRUTHVALUE_CONVERSION, + LANG_HOOKS_FINISH_INCOMPLETE_DECL, LANG_HOOKS_UNSAFE_FOR_REEVAL, + LANG_HOOKS_STATICP, LANG_HOOKS_SET_DECL_ASSEMBLER_NAME, + LANG_HOOKS_NO_BODY_BLOCKS, LANG_HOOKS_WARN_UNUSED_GLOBAL_DECL, + LANG_HOOKS_PRINT_IDENTIFIER, LANG_HOOKS_FUNCTION_ENTER_NESTED, + LANG_HOOKS_FUNCTION_LEAVE_NESTED, LANG_HOOKS_DUP_LANG_SPECIFIC_DECL, + LANG_HOOKS_DECL_UNINIT, LANG_HOOKS_RTL_EXPAND_STMT, + LANG_HOOKS_COMMON_ATTRIBUTE_TABLE, LANG_HOOKS_FORMAT_ATTRIBUTE_TABLE, + LANG_HOOKS_TREE_INLINING_CANNOT_INLINE_TREE_FN, + LANG_HOOKS_TREE_INLINING_DISREGARD_INLINE_LIMITS, + LANG_HOOKS_TREE_INLINING_ANON_AGGR_TYPE_P, + LANG_HOOKS_TREE_INLINING_CONVERT_PARM_FOR_INLINING, + LANG_HOOKS_TREE_INLINING_ESTIMATE_NUM_INSNS, + LANG_HOOKS_TREE_DUMP_DUMP_TREE_FN, + LANG_HOOKS_CALLGRAPH_EXPAND_FUNCTION, LANG_HOOKS_TYPE_FOR_MODE, + LANG_HOOKS_TYPE_FOR_SIZE, LANG_HOOKS_SIGNED_TYPE, + LANG_HOOKS_UNSIGNED_TYPE, LANG_HOOKS_SIGNED_OR_UNSIGNED_TYPE, + LANG_HOOKS_INCOMPLETE_TYPE_ERROR, LANG_HOOKS_TYPE_PROMOTES_TO, + LANG_HOOKS_REGISTER_BUILTIN_TYPE, LANG_HOOKS_WRITE_GLOBALS): + Move to c-objc-common.h. + + +Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 +Free Software Foundation, Inc. + +Copying and distribution of this file, with or without modification, +are permitted in any medium without royalty provided the copyright +notice and this notice are preserved. diff --git a/gcc/objc/Make-lang.in b/gcc/objc/Make-lang.in new file mode 100644 index 000000000..6544bcc3e --- /dev/null +++ b/gcc/objc/Make-lang.in @@ -0,0 +1,171 @@ +# Top level -*- makefile -*- fragment for GNU Objective-C +# Copyright (C) 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2007, +# 2008, 2009, 2010, 2011 Free Software Foundation, Inc. + +#This file is part of GCC. + +#GCC is free software; you can redistribute it and/or modify +#it under the terms of the GNU General Public License as published by +#the Free Software Foundation; either version 3, or (at your option) +#any later version. + +#GCC is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# . + + +# This file provides the language dependent support in the main Makefile. +# Each language makefile fragment must provide the following targets: +# +# foo.all.cross, foo.start.encap, foo.rest.encap, +# foo.install-common, foo.install-man, foo.install-info, foo.install-pdf, +# foo.install-html, foo.info, foo.dvi, foo.pdf, foo.html, foo.uninstall, +# foo.mostlyclean, foo.clean, foo.distclean, +# foo.maintainer-clean, foo.stage1, foo.stage2, foo.stage3, foo.stage4 +# +# where `foo' is the name of the language. +# +# It should also provide rules for: +# +# - making any compiler driver (eg: g++) +# - the compiler proper (eg: cc1plus) +# - define the names for selecting the language in LANGUAGES. + +# +# Define the names for selecting Objective-C in LANGUAGES. +objc: cc1obj$(exeext) + +# Tell GNU make to ignore these if they exist. +.PHONY: objc + +START_HDRS = $(CONFIG_H) $(SYSTEM_H) coretypes.h $(TM_H) $(TREE_H) $(C_TREE_H) \ + c-lang.h langhooks.h c-family/c-objc.h objc/objc-act.h + +# Use maximal warnings for this front end. +objc-warn = $(STRICT_WARN) + +# Language-specific object files for Objective C. +OBJC_OBJS = objc/objc-lang.o objc/objc-act.o \ + objc/objc-runtime-shared-support.o \ + objc/objc-gnu-runtime-abi-01.o \ + objc/objc-next-runtime-abi-01.o \ + objc/objc-next-runtime-abi-02.o \ + +objc_OBJS = $(OBJC_OBJS) cc1obj-checksum.o + +cc1obj-checksum.c : build/genchecksum$(build_exeext) checksum-options \ + $(OBJC_OBJS) $(C_AND_OBJC_OBJS) $(BACKEND) $(LIBDEPS) + build/genchecksum$(build_exeext) $(OBJC_OBJS) $(C_AND_OBJC_OBJS) \ + $(BACKEND) $(LIBDEPS) checksum-options > cc1obj-checksum.c.tmp && \ + $(srcdir)/../move-if-change cc1obj-checksum.c.tmp cc1obj-checksum.c + +cc1obj-checksum.o : cc1obj-checksum.c $(CONFIG_H) $(SYSTEM_H) + +cc1obj$(exeext): $(OBJC_OBJS) $(C_AND_OBJC_OBJS) cc1obj-checksum.o $(BACKEND) $(LIBDEPS) + +$(LINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) -o $@ \ + $(OBJC_OBJS) $(C_AND_OBJC_OBJS) cc1obj-checksum.o \ + $(BACKEND) $(LIBS) $(BACKENDLIBS) + +# Objective C language specific files. + +objc/objc-lang.o : objc/objc-lang.c $(START_HDRS) \ + $(GGC_H) $(LANGHOOKS_DEF_H) $(C_COMMON_H) gtype-objc.h \ + c-objc-common.h + +objc/objc-runtime-shared-support.o : objc/objc-runtime-shared-support.c \ + $(START_HDRS) objc/objc-runtime-shared-support.h $(OBSTACK_H) \ + objc/objc-next-metadata-tags.h gt-objc-objc-runtime-shared-support.h + +objc/objc-gnu-runtime-abi-01.o: objc/objc-gnu-runtime-abi-01.c $(START_HDRS) \ + objc/objc-runtime-hooks.h $(GGC_H) \ + objc/objc-runtime-shared-support.h gt-objc-objc-gnu-runtime-abi-01.h toplev.h + +objc/objc-next-runtime-abi-01.o: objc/objc-next-runtime-abi-01.c $(START_HDRS) \ + $(GGC_H) objc/objc-runtime-hooks.h \ + objc/objc-next-metadata-tags.h gt-objc-objc-next-runtime-abi-01.h output.h \ + objc/objc-runtime-shared-support.h $(TARGET_H) + +objc/objc-next-runtime-abi-02.o: objc/objc-next-runtime-abi-02.c $(START_HDRS) \ + $(GGC_H) objc/objc-runtime-hooks.h \ + objc/objc-next-metadata-tags.h gt-objc-objc-next-runtime-abi-02.h $(TARGET_H) \ + objc/objc-runtime-shared-support.h $(OBSTACK_H) + +objc/objc-act.o : objc/objc-act.c $(START_HDRS) $(GGC_H) \ + $(DIAGNOSTIC_CORE_H) toplev.h $(FLAGS_H) input.h $(FUNCTION_H) output.h debug.h \ + $(LANGHOOKS_DEF_H) $(HASHTAB_H) $(C_PRAGMA_H) gt-objc-objc-act.h $(OBSTACK_H) \ + $(GIMPLE_H) objc/objc-runtime-shared-support.h objc/objc-runtime-hooks.h + +objc.srcextra: + +# +# Build hooks: + +objc.all.cross: +objc.start.encap: +objc.rest.encap: +objc.info: +objc.install-info: +objc.dvi: +objc.pdf: +objc.install-pdf: +objc.html: +objc.install-html: +objc.man: +objc.srcinfo: +objc.srcman: +objc.install-plugin: + +objc.tags: force + cd $(srcdir)/objc; etags -o TAGS.sub *.c *.h; \ + etags --include TAGS.sub --include ../TAGS.sub + +lang_checks += check-objc + +# The following allows you to do 'make check-objc -j2'. The +# execute.exp tests will be run in parallel with all the other ones. +lang_checks_parallelized += check-objc +check_objc_parallelize = gnu-encoding.exp execute.exp exceptions.exp + +# +# Install hooks: +# cc1obj is installed elsewhere as part of $(COMPILERS). + +objc.install-common: + +objc.install-man: + +objc.uninstall: +# +# Clean hooks: +# A lot of the ancillary files are deleted by the main makefile. +# We just have to delete files specific to us. +objc.mostlyclean: + -rm -f objc/*$(objext) objc/xforward objc/fflags + -rm -f objc/*$(coverageexts) +objc.clean: objc.mostlyclean + -rm -rf objc-headers +objc.distclean: + -rm -f objc/Makefile objc/Make-host objc/Make-target + -rm -f objc/config.status objc/config.cache +objc.maintainer-clean: + +# +# Stage hooks: + +objc.stage1: stage1-start + -mv objc/*$(objext) stage1/objc +objc.stage2: stage2-start + -mv objc/*$(objext) stage2/objc +objc.stage3: stage3-start + -mv objc/*$(objext) stage3/objc +objc.stage4: stage4-start + -mv objc/*$(objext) stage4/objc +objc.stageprofile: stageprofile-start + -mv objc/*$(objext) stageprofile/objc +objc.stagefeedback: stagefeedback-start + -mv objc/*$(objext) stagefeedback/objc diff --git a/gcc/objc/config-lang.in b/gcc/objc/config-lang.in new file mode 100644 index 000000000..0de0650c0 --- /dev/null +++ b/gcc/objc/config-lang.in @@ -0,0 +1,39 @@ +# Top level configure fragment for GNU Objective-C +# Copyright (C) 1997, 1998, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2010, +# 2011 Free Software Foundation, Inc. + +#This file is part of GCC. + +#GCC is free software; you can redistribute it and/or modify +#it under the terms of the GNU General Public License as published by +#the Free Software Foundation; either version 3, or (at your option) +#any later version. + +#GCC is distributed in the hope that it will be useful, +#but WITHOUT ANY WARRANTY; without even the implied warranty of +#MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +#GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GCC; see the file COPYING3. If not see +# . + +# Configure looks for the existence of this file to auto-config each language. +# We define several parameters used by configure: +# +# language - name of language as it would appear in $(LANGUAGES) +# compilers - value to add to $(COMPILERS) + +language="objc" + +compilers="cc1obj\$(exeext)" + +target_libs=target-libobjc + +# Most of the object files for cc1obj actually come from C. +lang_requires="c" + +# Order is important. If you change this list, make sure you test +# building without C++ as well; that is, remove the gcc/cp directory, +# and build with --enable-languages=c,objc. +gtfiles="\$(srcdir)/c-family/c-objc.h \$(srcdir)/objc/objc-act.h \$(srcdir)/objc/objc-act.c \$(srcdir)/objc/objc-runtime-shared-support.c \$(srcdir)/objc/objc-gnu-runtime-abi-01.c \$(srcdir)/objc/objc-next-runtime-abi-01.c \$(srcdir)/objc/objc-next-runtime-abi-02.c \$(srcdir)/c-parser.c \$(srcdir)/c-tree.h \$(srcdir)/c-decl.c \$(srcdir)/c-lang.h \$(srcdir)/c-objc-common.c \$(srcdir)/c-family/c-common.c \$(srcdir)/c-family/c-common.h \$(srcdir)/c-family/c-cppbuiltin.c \$(srcdir)/c-family/c-pragma.h \$(srcdir)/c-family/c-pragma.c" diff --git a/gcc/objc/lang-specs.h b/gcc/objc/lang-specs.h new file mode 100644 index 000000000..8eac47b71 --- /dev/null +++ b/gcc/objc/lang-specs.h @@ -0,0 +1,58 @@ +/* Definitions for specs for Objective-C. + Copyright (C) 1998, 1999, 2002, 2002, 2003, 2005, 2007, 2010, 2011 + Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + + +/* This is the contribution to the `default_compilers' array in gcc.c + for objc. */ + + {".m", "@objective-c", 0, 0, 0}, + {"@objective-c", + "%{E|M|MM:cc1obj -E %{traditional|traditional-cpp:-traditional-cpp}\ + %(cpp_options) %(cpp_debug_options)}\ + %{!E:%{!M:%{!MM:\ + %{traditional|traditional-cpp:\ +%eGNU Objective C no longer supports traditional compilation}\ + %{save-temps*|no-integrated-cpp:cc1obj -E %(cpp_options) -o %{save-temps*:%b.mi} %{!save-temps*:%g.mi} \n\ + cc1obj -fpreprocessed %{save-temps*:%b.mi} %{!save-temps*:%g.mi} %(cc1_options) %{print-objc-runtime-info} %{gen-decls}}\ + %{!save-temps*:%{!no-integrated-cpp:\ + cc1obj %(cpp_unique_options) %(cc1_options) %{print-objc-runtime-info} %{gen-decls}}}\ + %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0}, + {"@objective-c-header", + "%{E|M|MM:cc1obj -E %{traditional|traditional-cpp:-traditional-cpp}\ + %(cpp_options) %(cpp_debug_options)}\ + %{!E:%{!M:%{!MM:\ + %{traditional|traditional-cpp:\ +%eGNU Objective C no longer supports traditional compilation}\ + %{save-temps*|no-integrated-cpp:cc1obj -E %(cpp_options) -o %{save-temps*:%b.mi} %{!save-temps*:%g.mi} \n\ + cc1obj -fpreprocessed %b.mi %(cc1_options) %{print-objc-runtime-info} %{gen-decls}\ + -o %g.s %{!o*:--output-pch=%i.gch}\ + %W{o*:--output-pch=%*}%V}\ + %{!save-temps*:%{!no-integrated-cpp:\ + cc1obj %(cpp_unique_options) %(cc1_options) %{print-objc-runtime-info} %{gen-decls}\ + -o %g.s %{!o*:--output-pch=%i.gch}\ + %W{o*:--output-pch=%*}%V}}}}}", 0, 0, 0}, + {".mi", "@objective-c-cpp-output", 0, 0, 0}, + {"@objective-c-cpp-output", + "%{!M:%{!MM:%{!E:cc1obj -fpreprocessed %i %(cc1_options) %{print-objc-runtime-info} %{gen-decls}\ + %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0}, + {"@objc-cpp-output", + "%nobjc-cpp-output is deprecated; please use objective-c-cpp-output instead\n\ + %{!M:%{!MM:%{!E:cc1obj -fpreprocessed %i %(cc1_options) %{print-objc-runtime-info} %{gen-decls}\ + %{!fsyntax-only:%(invoke_as)}}}}", 0, 0, 0}, diff --git a/gcc/objc/objc-act.c b/gcc/objc/objc-act.c new file mode 100644 index 000000000..cca60a071 --- /dev/null +++ b/gcc/objc/objc-act.c @@ -0,0 +1,10575 @@ +/* Implement classes and message passing for Objective C. + Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001, + 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Steve Naroff. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" + +#ifdef OBJCPLUS +#include "cp-tree.h" +#else +#include "c-tree.h" +#include "c-lang.h" +#endif + +#include "c-family/c-common.h" +#include "c-family/c-objc.h" +#include "c-family/c-pragma.h" +#include "c-family/c-format.h" +#include "flags.h" +#include "langhooks.h" +#include "objc-act.h" +#include "input.h" +#include "function.h" +#include "output.h" +#include "toplev.h" +#include "ggc.h" +#include "debug.h" +#include "target.h" +#include "diagnostic-core.h" +#include "intl.h" +#include "cgraph.h" +#include "tree-iterator.h" +#include "hashtab.h" +#include "langhooks-def.h" +/* Different initialization, code gen and meta data generation for each + runtime. */ +#include "objc-runtime-hooks.h" +/* Routines used mainly by the runtimes. */ +#include "objc-runtime-shared-support.h" +/* For default_tree_printer (). */ +#include "tree-pretty-print.h" + +/* For enum gimplify_status */ +#include "gimple.h" + +static unsigned int should_call_super_dealloc = 0; + +/* When building Objective-C++, we are not linking against the C front-end + and so need to replicate the C tree-construction functions in some way. */ +#ifdef OBJCPLUS +#define OBJCP_REMAP_FUNCTIONS +#include "objcp-decl.h" +#endif /* OBJCPLUS */ + +/* This is the default way of generating a method name. */ +/* This has the problem that "test_method:argument:" and + "test:method_argument:" will generate the same name + ("_i_Test__test_method_argument_" for an instance method of the + class "Test"), so you can't have them both in the same class! + Moreover, the demangling (going from + "_i_Test__test_method_argument" back to the original name) is + undefined because there are two correct ways of demangling the + name. */ +#ifndef OBJC_GEN_METHOD_LABEL +#define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \ + do { \ + char *temp; \ + sprintf ((BUF), "_%s_%s_%s_%s", \ + ((IS_INST) ? "i" : "c"), \ + (CLASS_NAME), \ + ((CAT_NAME)? (CAT_NAME) : ""), \ + (SEL_NAME)); \ + for (temp = (BUF); *temp; temp++) \ + if (*temp == ':') *temp = '_'; \ + } while (0) +#endif + +/* These need specifying. */ +#ifndef OBJC_FORWARDING_STACK_OFFSET +#define OBJC_FORWARDING_STACK_OFFSET 0 +#endif + +#ifndef OBJC_FORWARDING_MIN_OFFSET +#define OBJC_FORWARDING_MIN_OFFSET 0 +#endif + +/* Set up for use of obstacks. */ + +#include "obstack.h" + +/* This obstack is used to accumulate the encoding of a data type. */ +struct obstack util_obstack; + +/* This points to the beginning of obstack contents, so we can free + the whole contents. */ +char *util_firstobj; + +/*** Private Interface (procedures) ***/ + +/* Init stuff. */ +static void synth_module_prologue (void); + +/* Code generation. */ + +static tree start_class (enum tree_code, tree, tree, tree, tree); +static tree continue_class (tree); +static void finish_class (tree); +static void start_method_def (tree); + +static tree start_protocol (enum tree_code, tree, tree, tree); +static tree build_method_decl (enum tree_code, tree, tree, tree, bool); +static tree objc_add_method (tree, tree, int, bool); +static tree add_instance_variable (tree, objc_ivar_visibility_kind, tree); +static tree build_ivar_reference (tree); +static tree is_ivar (tree, tree); + +/* We only need the following for ObjC; ObjC++ will use C++'s definition + of DERIVED_FROM_P. */ +#ifndef OBJCPLUS +static bool objc_derived_from_p (tree, tree); +#define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD) +#endif + +/* Property. */ +static void objc_gen_property_data (tree, tree); +static void objc_synthesize_getter (tree, tree, tree); +static void objc_synthesize_setter (tree, tree, tree); +static char *objc_build_property_setter_name (tree); +static int match_proto_with_proto (tree, tree, int); +static tree lookup_property (tree, tree); +static tree lookup_property_in_list (tree, tree); +static tree lookup_property_in_protocol_list (tree, tree); +static void build_common_objc_property_accessor_helpers (void); + +static void objc_xref_basetypes (tree, tree); + +static tree get_class_ivars (tree, bool); + +static void build_fast_enumeration_state_template (void); + +#ifdef OBJCPLUS +static void objc_generate_cxx_cdtors (void); +#endif + +/* objc attribute */ +static void objc_decl_method_attributes (tree*, tree, int); +static tree build_keyword_selector (tree); + +/* Hash tables to manage the global pool of method prototypes. */ +static void hash_init (void); + +hash *nst_method_hash_list = 0; +hash *cls_method_hash_list = 0; + +/* Hash tables to manage the global pool of class names. */ + +hash *cls_name_hash_list = 0; +hash *als_name_hash_list = 0; + +hash *ivar_offset_hash_list = 0; + +static void hash_class_name_enter (hash *, tree, tree); +static hash hash_class_name_lookup (hash *, tree); + +static hash hash_lookup (hash *, tree); +static tree lookup_method (tree, tree); +static tree lookup_method_static (tree, tree, int); + +static tree add_class (tree, tree); +static void add_category (tree, tree); +static inline tree lookup_category (tree, tree); + +/* Protocols. */ + +static tree lookup_protocol (tree, bool, bool); +static tree lookup_and_install_protocols (tree, bool); + +/* Type encoding. */ + +static void encode_type_qualifiers (tree); +static void encode_type (tree, int, int); + +#ifdef OBJCPLUS +static void really_start_method (tree, tree); +#else +static void really_start_method (tree, struct c_arg_info *); +#endif +static int comp_proto_with_proto (tree, tree, int); +static tree objc_decay_parm_type (tree); + +/* Utilities for debugging and error diagnostics. */ + +static char *gen_type_name (tree); +static char *gen_type_name_0 (tree); +static char *gen_method_decl (tree); +static char *gen_declaration (tree); + +/* Everything else. */ + +static void generate_struct_by_value_array (void) ATTRIBUTE_NORETURN; + +static void mark_referenced_methods (void); +static bool objc_type_valid_for_messaging (tree type, bool allow_classes); +static tree check_duplicates (hash, int, int); + +/*** Private Interface (data) ***/ +/* Flags for lookup_method_static(). */ + +/* Look for class methods. */ +#define OBJC_LOOKUP_CLASS 1 +/* Do not examine superclasses. */ +#define OBJC_LOOKUP_NO_SUPER 2 +/* Disable returning an instance method of a root class when a class + method can't be found. */ +#define OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS 4 + +/* The OCTI_... enumeration itself is in objc/objc-act.h. */ +tree objc_global_trees[OCTI_MAX]; + +struct imp_entry *imp_list = 0; +int imp_count = 0; /* `@implementation' */ +int cat_count = 0; /* `@category' */ + +objc_ivar_visibility_kind objc_ivar_visibility; + +/* Use to generate method labels. */ +static int method_slot = 0; + +/* Flag to say whether methods in a protocol are optional or + required. */ +static bool objc_method_optional_flag = false; + +static int objc_collecting_ivars = 0; + +/* Flag that is set to 'true' while we are processing a class + extension. Since a class extension just "reopens" the main + @interface, this can be used to determine if we are in the main + @interface, or in a class extension. */ +static bool objc_in_class_extension = false; + +static char *errbuf; /* Buffer for error diagnostics */ + +/* An array of all the local variables in the current function that + need to be marked as volatile. */ +VEC(tree,gc) *local_variables_to_volatilize = NULL; + +/* Store all constructed constant strings in a hash table so that + they get uniqued properly. */ + +struct GTY(()) string_descriptor { + /* The literal argument . */ + tree literal; + + /* The resulting constant string. */ + tree constructor; +}; + +static GTY((param_is (struct string_descriptor))) htab_t string_htab; + +FILE *gen_declaration_file; + +/* Tells "encode_pointer/encode_aggregate" whether we are generating + type descriptors for instance variables (as opposed to methods). + Type descriptors for instance variables contain more information + than methods (for static typing and embedded structures). */ + +int generating_instance_variables = 0; + +/* Hooks for stuff that differs between runtimes. */ +objc_runtime_hooks runtime; + +/* Create a temporary variable of type 'type'. If 'name' is set, uses + the specified name, else use no name. Returns the declaration of + the type. The 'name' is mostly useful for debugging. +*/ +tree +objc_create_temporary_var (tree type, const char *name) +{ + tree decl; + + if (name != NULL) + { + decl = build_decl (input_location, + VAR_DECL, get_identifier (name), type); + } + else + { + decl = build_decl (input_location, + VAR_DECL, NULL_TREE, type); + } + TREE_USED (decl) = 1; + DECL_ARTIFICIAL (decl) = 1; + DECL_IGNORED_P (decl) = 1; + DECL_CONTEXT (decl) = current_function_decl; + + return decl; +} + +/* Some platforms pass small structures through registers versus + through an invisible pointer. Determine at what size structure is + the transition point between the two possibilities. */ + +static void +generate_struct_by_value_array (void) +{ + tree type; + tree decls; + int i, j; + int aggregate_in_mem[32]; + int found = 0; + + /* Presumably no platform passes 32 byte structures in a register. */ + /* ??? As an example, m64/ppc/Darwin can pass up to 8*long+13*double + in registers. */ + for (i = 1; i < 32; i++) + { + char buffer[5]; + tree *chain = NULL; + + /* Create an unnamed struct that has `i' character components */ + type = objc_start_struct (NULL_TREE); + + strcpy (buffer, "c1"); + decls = add_field_decl (char_type_node, buffer, &chain); + + for (j = 1; j < i; j++) + { + sprintf (buffer, "c%d", j + 1); + add_field_decl (char_type_node, buffer, &chain); + } + objc_finish_struct (type, decls); + + aggregate_in_mem[i] = aggregate_value_p (type, 0); + if (!aggregate_in_mem[i]) + found = 1; + } + + /* We found some structures that are returned in registers instead of memory + so output the necessary data. */ + if (found) + { + for (i = 31; i >= 0; i--) + if (!aggregate_in_mem[i]) + break; + printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n", i); + } + + exit (0); +} + +bool +objc_init (void) +{ + bool ok; +#ifdef OBJCPLUS + if (cxx_init () == false) +#else + if (c_objc_common_init () == false) +#endif + return false; + + /* print_struct_values is triggered by -print-runtime-info (used + when building libobjc, with an empty file as input). It does not + require any ObjC setup, and it never returns. + + -fcompare-debug is used to check the compiler output; we are + executed twice, once with flag_compare_debug set, and once with + it not set. If the flag is used together with + -print-runtime-info, we want to print the runtime info only once, + else it would be output in duplicate. So we check + flag_compare_debug to output it in only one of the invocations. + + As a side effect, this also that means -fcompare-debug + -print-runtime-info will run the compiler twice, and compare the + generated assembler file; the first time the compiler exits + immediately (producing no file), and the second time it compiles + an empty file. This checks, as a side effect, that compiling an + empty file produces no assembler output. */ + if (print_struct_values && !flag_compare_debug) + generate_struct_by_value_array (); + + /* Set up stuff used by FE parser and all runtimes. */ + errbuf = XNEWVEC (char, 1024 * 10); + hash_init (); + gcc_obstack_init (&util_obstack); + util_firstobj = (char *) obstack_finish (&util_obstack); + + /* ... and then check flags and set-up for the selected runtime ... */ + if (flag_next_runtime && flag_objc_abi >= 2) + ok = objc_next_runtime_abi_02_init (&runtime); + else if (flag_next_runtime) + ok = objc_next_runtime_abi_01_init (&runtime); + else + ok = objc_gnu_runtime_abi_01_init (&runtime); + + /* If that part of the setup failed - bail out immediately. */ + if (!ok) + return false; + + /* Generate general types and push runtime-specific decls to file scope. */ + synth_module_prologue (); + + return true; +} + +/* This is called automatically (at the very end of compilation) by + c_write_global_declarations and cp_write_global_declarations. */ +void +objc_write_global_declarations (void) +{ + mark_referenced_methods (); + + /* A missing @end might not be detected by the parser. */ + if (objc_implementation_context) + { + warning (0, "%<@end%> missing in implementation context"); + finish_class (objc_implementation_context); + objc_ivar_chain = NULL_TREE; + objc_implementation_context = NULL_TREE; + } + + if (warn_selector) + { + int slot; + hash hsh; + + /* Run through the selector hash tables and print a warning for any + selector which has multiple methods. */ + + for (slot = 0; slot < SIZEHASHTABLE; slot++) + { + for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next) + check_duplicates (hsh, 0, 1); + for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next) + check_duplicates (hsh, 0, 0); + } + } + + /* TODO: consider an early exit here if either errorcount or sorrycount + is non-zero. Not only is it wasting time to generate the metadata, + it needlessly imposes need to re-check for things that are already + determined to be errors. */ + + /* Finalize Objective-C runtime data. No need to generate tables + and code if only checking syntax, or if generating a PCH file. */ + if (!flag_syntax_only && !pch_file) + { + location_t saved_location; + + /* If gen_declaration desired, open the output file. */ + if (flag_gen_declaration) + { + char * const dumpname = concat (dump_base_name, ".decl", NULL); + gen_declaration_file = fopen (dumpname, "w"); + if (gen_declaration_file == 0) + fatal_error ("can%'t open %s: %m", dumpname); + free (dumpname); + } + + /* Set the input location to BUILTINS_LOCATION. This is good + for error messages, in case any is generated while producing + the metadata, but it also silences warnings that would be + produced when compiling with -Wpadded in case when padding is + automatically added to the built-in runtime data structure + declarations. We know about this padding, and it is fine; we + don't want users to see any warnings about it if they use + -Wpadded. */ + saved_location = input_location; + input_location = BUILTINS_LOCATION; + + /* Compute and emit the meta-data tables for this runtime. */ + (*runtime.generate_metadata) (); + + /* Restore the original location, just in case it mattered. */ + input_location = saved_location; + + /* ... and then close any declaration file we opened. */ + if (gen_declaration_file) + fclose (gen_declaration_file); + } +} + +/* Return the first occurrence of a method declaration corresponding + to sel_name in rproto_list. Search rproto_list recursively. + If is_class is 0, search for instance methods, otherwise for class + methods. */ +static tree +lookup_method_in_protocol_list (tree rproto_list, tree sel_name, + int is_class) +{ + tree rproto, p, m; + + for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto)) + { + p = TREE_VALUE (rproto); + m = NULL_TREE; + + if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) + { + /* First, search the @required protocol methods. */ + if (is_class) + m = lookup_method (PROTOCOL_CLS_METHODS (p), sel_name); + else + m = lookup_method (PROTOCOL_NST_METHODS (p), sel_name); + + if (m) + return m; + + /* If still not found, search the @optional protocol methods. */ + if (is_class) + m = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (p), sel_name); + else + m = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (p), sel_name); + + if (m) + return m; + + /* If still not found, search the attached protocols. */ + if (PROTOCOL_LIST (p)) + m = lookup_method_in_protocol_list (PROTOCOL_LIST (p), + sel_name, is_class); + if (m) + return m; + } + else + { + ; /* An identifier...if we could not find a protocol. */ + } + } + + return 0; +} + +static tree +lookup_protocol_in_reflist (tree rproto_list, tree lproto) +{ + tree rproto, p; + + /* Make sure the protocol is supported by the object on the rhs. */ + if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE) + { + tree fnd = 0; + for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto)) + { + p = TREE_VALUE (rproto); + + if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) + { + if (lproto == p) + fnd = lproto; + + else if (PROTOCOL_LIST (p)) + fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto); + } + + if (fnd) + return fnd; + } + } + else + { + ; /* An identifier...if we could not find a protocol. */ + } + + return 0; +} + +void +objc_start_class_interface (tree klass, tree super_class, + tree protos, tree attributes) +{ + if (flag_objc1_only && attributes) + error_at (input_location, "class attributes are not available in Objective-C 1.0"); + + objc_interface_context + = objc_ivar_context + = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos, attributes); + objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED; +} + +void +objc_start_category_interface (tree klass, tree categ, + tree protos, tree attributes) +{ + if (attributes) + { + if (flag_objc1_only) + error_at (input_location, "category attributes are not available in Objective-C 1.0"); + else + warning_at (input_location, OPT_Wattributes, + "category attributes are not available in this version" + " of the compiler, (ignored)"); + } + if (categ == NULL_TREE) + { + if (flag_objc1_only) + error_at (input_location, "class extensions are not available in Objective-C 1.0"); + else + { + /* Iterate over all the classes and categories implemented + up to now in this compilation unit. */ + struct imp_entry *t; + + for (t = imp_list; t; t = t->next) + { + /* If we find a class @implementation with the same name + as the one we are extending, produce an error. */ + if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE + && IDENTIFIER_POINTER (CLASS_NAME (t->imp_context)) == IDENTIFIER_POINTER (klass)) + error_at (input_location, + "class extension for class %qE declared after its %<@implementation%>", + klass); + } + } + } + objc_interface_context + = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos, NULL_TREE); + objc_ivar_chain + = continue_class (objc_interface_context); +} + +void +objc_start_protocol (tree name, tree protos, tree attributes) +{ + if (flag_objc1_only && attributes) + error_at (input_location, "protocol attributes are not available in Objective-C 1.0"); + + objc_interface_context + = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos, attributes); + objc_method_optional_flag = false; +} + +void +objc_continue_interface (void) +{ + objc_ivar_chain + = continue_class (objc_interface_context); +} + +void +objc_finish_interface (void) +{ + finish_class (objc_interface_context); + objc_interface_context = NULL_TREE; + objc_method_optional_flag = false; + objc_in_class_extension = false; +} + +void +objc_start_class_implementation (tree klass, tree super_class) +{ + objc_implementation_context + = objc_ivar_context + = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE, + NULL_TREE); + objc_ivar_visibility = OBJC_IVAR_VIS_PROTECTED; +} + +void +objc_start_category_implementation (tree klass, tree categ) +{ + objc_implementation_context + = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE, + NULL_TREE); + objc_ivar_chain + = continue_class (objc_implementation_context); +} + +void +objc_continue_implementation (void) +{ + objc_ivar_chain + = continue_class (objc_implementation_context); +} + +void +objc_finish_implementation (void) +{ +#ifdef OBJCPLUS + if (flag_objc_call_cxx_cdtors) + objc_generate_cxx_cdtors (); +#endif + + if (objc_implementation_context) + { + finish_class (objc_implementation_context); + objc_ivar_chain = NULL_TREE; + objc_implementation_context = NULL_TREE; + } + else + warning (0, "%<@end%> must appear in an @implementation context"); +} + +void +objc_set_visibility (objc_ivar_visibility_kind visibility) +{ + if (visibility == OBJC_IVAR_VIS_PACKAGE) + { + if (flag_objc1_only) + error ("%<@package%> is not available in Objective-C 1.0"); + else + warning (0, "%<@package%> presently has the same effect as %<@public%>"); + } + objc_ivar_visibility = visibility; +} + +void +objc_set_method_opt (bool optional) +{ + if (flag_objc1_only) + { + if (optional) + error_at (input_location, "%<@optional%> is not available in Objective-C 1.0"); + else + error_at (input_location, "%<@required%> is not available in Objective-C 1.0"); + } + + objc_method_optional_flag = optional; + if (!objc_interface_context + || TREE_CODE (objc_interface_context) != PROTOCOL_INTERFACE_TYPE) + { + if (optional) + error ("%<@optional%> is allowed in @protocol context only"); + else + error ("%<@required%> is allowed in @protocol context only"); + objc_method_optional_flag = false; + } +} + +/* This routine looks for a given PROPERTY in a list of CLASS, CATEGORY, or + PROTOCOL. */ +static tree +lookup_property_in_list (tree chain, tree property) +{ + tree x; + for (x = CLASS_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x)) + if (PROPERTY_NAME (x) == property) + return x; + return NULL_TREE; +} + +/* This routine looks for a given PROPERTY in the tree chain of RPROTO_LIST. */ +static tree lookup_property_in_protocol_list (tree rproto_list, tree property) +{ + tree rproto, x; + for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto)) + { + tree p = TREE_VALUE (rproto); + if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) + { + if ((x = lookup_property_in_list (p, property))) + return x; + if (PROTOCOL_LIST (p)) + return lookup_property_in_protocol_list (PROTOCOL_LIST (p), property); + } + else + { + ; /* An identifier...if we could not find a protocol. */ + } + } + return NULL_TREE; +} + +/* This routine looks up the PROPERTY in current INTERFACE, its categories and up the + chain of interface hierarchy. */ +static tree +lookup_property (tree interface_type, tree property) +{ + tree inter = interface_type; + while (inter) + { + tree x, category; + if ((x = lookup_property_in_list (inter, property))) + return x; + /* Failing that, look for the property in each category of the class. */ + category = inter; + while ((category = CLASS_CATEGORY_LIST (category))) + { + if ((x = lookup_property_in_list (category, property))) + return x; + + /* When checking a category, also check the protocols + attached with the category itself. */ + if (CLASS_PROTOCOL_LIST (category) + && (x = lookup_property_in_protocol_list + (CLASS_PROTOCOL_LIST (category), property))) + return x; + } + + /* Failing to find in categories, look for property in protocol list. */ + if (CLASS_PROTOCOL_LIST (inter) + && (x = lookup_property_in_protocol_list + (CLASS_PROTOCOL_LIST (inter), property))) + return x; + + /* Failing that, climb up the inheritance hierarchy. */ + inter = lookup_interface (CLASS_SUPER_NAME (inter)); + } + return inter; +} + +/* This routine is called by the parser when a + @property... declaration is found. 'decl' is the declaration of + the property (type/identifier), and the other arguments represent + property attributes that may have been specified in the Objective-C + declaration. 'parsed_property_readonly' is 'true' if the attribute + 'readonly' was specified, and 'false' if not; similarly for the + other bool parameters. 'parsed_property_getter_ident' is NULL_TREE + if the attribute 'getter' was not specified, and is the identifier + corresponding to the specified getter if it was; similarly for + 'parsed_property_setter_ident'. */ +void +objc_add_property_declaration (location_t location, tree decl, + bool parsed_property_readonly, bool parsed_property_readwrite, + bool parsed_property_assign, bool parsed_property_retain, + bool parsed_property_copy, bool parsed_property_nonatomic, + tree parsed_property_getter_ident, tree parsed_property_setter_ident) +{ + tree property_decl; + tree x; + /* 'property_readonly' and 'property_assign_semantics' are the final + attributes of the property after all parsed attributes have been + considered (eg, if we parsed no 'readonly' and no 'readwrite', ie + parsed_property_readonly = false and parsed_property_readwrite = + false, then property_readonly will be false because the default + is readwrite). */ + bool property_readonly = false; + objc_property_assign_semantics property_assign_semantics = OBJC_PROPERTY_ASSIGN; + bool property_extension_in_class_extension = false; + + if (flag_objc1_only) + error_at (input_location, "%<@property%> is not available in Objective-C 1.0"); + + if (parsed_property_readonly && parsed_property_readwrite) + { + error_at (location, "% attribute conflicts with % attribute"); + /* In case of conflicting attributes (here and below), after + producing an error, we pick one of the attributes and keep + going. */ + property_readonly = false; + } + else + { + if (parsed_property_readonly) + property_readonly = true; + + if (parsed_property_readwrite) + property_readonly = false; + } + + if (parsed_property_readonly && parsed_property_setter_ident) + { + error_at (location, "% attribute conflicts with % attribute"); + property_readonly = false; + } + + if (parsed_property_assign && parsed_property_retain) + { + error_at (location, "% attribute conflicts with % attribute"); + property_assign_semantics = OBJC_PROPERTY_RETAIN; + } + else if (parsed_property_assign && parsed_property_copy) + { + error_at (location, "% attribute conflicts with % attribute"); + property_assign_semantics = OBJC_PROPERTY_COPY; + } + else if (parsed_property_retain && parsed_property_copy) + { + error_at (location, "% attribute conflicts with % attribute"); + property_assign_semantics = OBJC_PROPERTY_COPY; + } + else + { + if (parsed_property_assign) + property_assign_semantics = OBJC_PROPERTY_ASSIGN; + + if (parsed_property_retain) + property_assign_semantics = OBJC_PROPERTY_RETAIN; + + if (parsed_property_copy) + property_assign_semantics = OBJC_PROPERTY_COPY; + } + + if (!objc_interface_context) + { + error_at (location, "property declaration not in @interface or @protocol context"); + return; + } + + /* At this point we know that we are either in an interface, a + category, or a protocol. */ + + /* We expect a FIELD_DECL from the parser. Make sure we didn't get + something else, as that would confuse the checks below. */ + if (TREE_CODE (decl) != FIELD_DECL) + { + error_at (location, "invalid property declaration"); + return; + } + + /* Do some spot-checks for the most obvious invalid types. */ + + if (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE) + { + error_at (location, "property can not be an array"); + return; + } + + /* The C++/ObjC++ parser seems to reject the ':' for a bitfield when + parsing, while the C/ObjC parser accepts it and gives us a + FIELD_DECL with a DECL_INITIAL set. So we use the DECL_INITIAL + to check for a bitfield when doing ObjC. */ +#ifndef OBJCPLUS + if (DECL_INITIAL (decl)) + { + /* A @property is not an actual variable, but it is a way to + describe a pair of accessor methods, so its type (which is + the type of the return value of the getter and the first + argument of the setter) can't be a bitfield (as return values + and arguments of functions can not be bitfields). The + underlying instance variable could be a bitfield, but that is + a different matter. */ + error_at (location, "property can not be a bit-field"); + return; + } +#endif + + /* TODO: Check that the property type is an Objective-C object or a + "POD". */ + + /* Implement -Wproperty-assign-default (which is enabled by default). */ + if (warn_property_assign_default + /* If garbage collection is not being used, then 'assign' is + valid for objects (and typically used for delegates) but it + is wrong in most cases (since most objects need to be + retained or copied in setters). Warn users when 'assign' is + used implicitly. */ + && property_assign_semantics == OBJC_PROPERTY_ASSIGN + /* Read-only properties are never assigned, so the assignment + semantics do not matter in that case. */ + && !property_readonly + && !flag_objc_gc) + { + /* Please note that it would make sense to default to 'assign' + for non-{Objective-C objects}, and to 'retain' for + Objective-C objects. But that would break compatibility with + other compilers. */ + if (!parsed_property_assign && !parsed_property_retain && !parsed_property_copy) + { + /* Use 'false' so we do not warn for Class objects. */ + if (objc_type_valid_for_messaging (TREE_TYPE (decl), false)) + { + warning_at (location, + 0, + "object property %qD has no %, % or % attribute; assuming %", + decl); + inform (location, + "% can be unsafe for Objective-C objects; please state explicitly if you need it"); + } + } + } + + if (property_assign_semantics == OBJC_PROPERTY_RETAIN + && !objc_type_valid_for_messaging (TREE_TYPE (decl), true)) + error_at (location, "% attribute is only valid for Objective-C objects"); + + if (property_assign_semantics == OBJC_PROPERTY_COPY + && !objc_type_valid_for_messaging (TREE_TYPE (decl), true)) + error_at (location, "% attribute is only valid for Objective-C objects"); + + /* Now determine the final property getter and setter names. They + will be stored in the PROPERTY_DECL, from which they'll always be + extracted and used. */ + + /* Adjust, or fill in, setter and getter names. We overwrite the + parsed_property_setter_ident and parsed_property_getter_ident + with the final setter and getter identifiers that will be + used. */ + if (parsed_property_setter_ident) + { + /* The setter should be terminated by ':', but the parser only + gives us an identifier without ':'. So, we need to add ':' + at the end. */ + const char *parsed_setter = IDENTIFIER_POINTER (parsed_property_setter_ident); + size_t length = strlen (parsed_setter); + char *final_setter = (char *)alloca (length + 2); + + sprintf (final_setter, "%s:", parsed_setter); + parsed_property_setter_ident = get_identifier (final_setter); + } + else + { + if (!property_readonly) + parsed_property_setter_ident = get_identifier (objc_build_property_setter_name + (DECL_NAME (decl))); + } + + if (!parsed_property_getter_ident) + parsed_property_getter_ident = DECL_NAME (decl); + + /* Check for duplicate property declarations. We first check the + immediate context for a property with the same name. Any such + declarations are an error, unless this is a class extension and + we are extending a property from readonly to readwrite. */ + for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x)) + { + if (PROPERTY_NAME (x) == DECL_NAME (decl)) + { + if (objc_in_class_extension + && property_readonly == 0 + && PROPERTY_READONLY (x) == 1) + { + /* This is a class extension, and we are extending an + existing readonly property to a readwrite one. + That's fine. :-) */ + property_extension_in_class_extension = true; + break; + } + else + { + location_t original_location = DECL_SOURCE_LOCATION (x); + + error_at (location, "redeclaration of property %qD", decl); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + } + } + + /* If x is not NULL_TREE, we must be in a class extension and we're + extending a readonly property. In that case, no point in + searching for another declaration. */ + if (x == NULL_TREE) + { + /* We now need to check for existing property declarations (in + the superclass, other categories or protocols) and check that + the new declaration is not in conflict with existing + ones. */ + + /* Search for a previous, existing declaration of a property + with the same name in superclasses, protocols etc. If one is + found, it will be in the 'x' variable. */ + + /* Note that, for simplicity, the following may search again the + local context. That's Ok as nothing will be found (else we'd + have thrown an error above); it's only a little inefficient, + but the code is simpler. */ + switch (TREE_CODE (objc_interface_context)) + { + case CLASS_INTERFACE_TYPE: + /* Look up the property in the current @interface (which + will find nothing), then its protocols and categories and + superclasses. */ + x = lookup_property (objc_interface_context, DECL_NAME (decl)); + break; + case CATEGORY_INTERFACE_TYPE: + /* Look up the property in the main @interface, then + protocols and categories (one of them is ours, and will + find nothing) and superclasses. */ + x = lookup_property (lookup_interface (CLASS_NAME (objc_interface_context)), + DECL_NAME (decl)); + break; + case PROTOCOL_INTERFACE_TYPE: + /* Looks up the property in any protocols attached to the + current protocol. */ + if (PROTOCOL_LIST (objc_interface_context)) + { + x = lookup_property_in_protocol_list (PROTOCOL_LIST (objc_interface_context), + DECL_NAME (decl)); + } + break; + default: + gcc_unreachable (); + } + } + + if (x != NULL_TREE) + { + /* An existing property was found; check that it has the same + types, or it is compatible. */ + location_t original_location = DECL_SOURCE_LOCATION (x); + + if (PROPERTY_NONATOMIC (x) != parsed_property_nonatomic) + { + warning_at (location, 0, + "'nonatomic' attribute of property %qD conflicts with previous declaration", decl); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + if (PROPERTY_GETTER_NAME (x) != parsed_property_getter_ident) + { + warning_at (location, 0, + "'getter' attribute of property %qD conflicts with previous declaration", decl); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + /* We can only compare the setter names if both the old and new property have a setter. */ + if (!property_readonly && !PROPERTY_READONLY(x)) + { + if (PROPERTY_SETTER_NAME (x) != parsed_property_setter_ident) + { + warning_at (location, 0, + "'setter' attribute of property %qD conflicts with previous declaration", decl); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + } + + if (PROPERTY_ASSIGN_SEMANTICS (x) != property_assign_semantics) + { + warning_at (location, 0, + "assign semantics attributes of property %qD conflict with previous declaration", decl); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + /* It's ok to have a readonly property that becomes a readwrite, but not vice versa. */ + if (PROPERTY_READONLY (x) == 0 && property_readonly == 1) + { + warning_at (location, 0, + "'readonly' attribute of property %qD conflicts with previous declaration", decl); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + /* We now check that the new and old property declarations have + the same types (or compatible one). In the Objective-C + tradition of loose type checking, we do type-checking but + only generate warnings (not errors) if they do not match. + For non-readonly properties, the types must match exactly; + for readonly properties, it is allowed to use a "more + specialized" type in the new property declaration. Eg, the + superclass has a getter returning (NSArray *) and the + subclass a getter returning (NSMutableArray *). The object's + getter returns an (NSMutableArray *); but if you cast the + object to the superclass, which is allowed, you'd still + expect the getter to return an (NSArray *), which works since + an (NSMutableArray *) is an (NSArray *) too. So, the set of + objects belonging to the type of the new @property should be + a subset of the set of objects belonging to the type of the + old @property. This is what "specialization" means. And the + reason it only applies to readonly properties is that for a + readwrite property the setter would have the opposite + requirement - ie that the superclass type is more specialized + then the subclass one; hence the only way to satisfy both + constraints is that the types match. */ + + /* If the types are not the same in the C sense, we warn ... */ + if (!comptypes (TREE_TYPE (x), TREE_TYPE (decl)) + /* ... unless the property is readonly, in which case we + allow a new, more specialized, declaration. */ + && (!property_readonly + || !objc_compare_types (TREE_TYPE (x), + TREE_TYPE (decl), -5, NULL_TREE))) + { + warning_at (location, 0, + "type of property %qD conflicts with previous declaration", decl); + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + /* If we are in a class extension and we're extending a readonly + property in the main @interface, we'll just update the + existing property with the readwrite flag and potentially the + new setter name. */ + if (property_extension_in_class_extension) + { + PROPERTY_READONLY (x) = 0; + PROPERTY_SETTER_NAME (x) = parsed_property_setter_ident; + return; + } + } + + /* Create a PROPERTY_DECL node. */ + property_decl = make_node (PROPERTY_DECL); + + /* Copy the basic information from the original decl. */ + TREE_TYPE (property_decl) = TREE_TYPE (decl); + DECL_SOURCE_LOCATION (property_decl) = DECL_SOURCE_LOCATION (decl); + TREE_DEPRECATED (property_decl) = TREE_DEPRECATED (decl); + + /* Add property-specific information. */ + PROPERTY_NAME (property_decl) = DECL_NAME (decl); + PROPERTY_GETTER_NAME (property_decl) = parsed_property_getter_ident; + PROPERTY_SETTER_NAME (property_decl) = parsed_property_setter_ident; + PROPERTY_READONLY (property_decl) = property_readonly; + PROPERTY_NONATOMIC (property_decl) = parsed_property_nonatomic; + PROPERTY_ASSIGN_SEMANTICS (property_decl) = property_assign_semantics; + PROPERTY_IVAR_NAME (property_decl) = NULL_TREE; + PROPERTY_DYNAMIC (property_decl) = 0; + + /* Remember the fact that the property was found in the @optional + section in a @protocol, or not. */ + if (objc_method_optional_flag) + PROPERTY_OPTIONAL (property_decl) = 1; + else + PROPERTY_OPTIONAL (property_decl) = 0; + + /* Note that PROPERTY_GETTER_NAME is always set for all + PROPERTY_DECLs, and PROPERTY_SETTER_NAME is always set for all + PROPERTY_DECLs where PROPERTY_READONLY == 0. Any time we deal + with a getter or setter, we should get the PROPERTY_DECL and use + PROPERTY_GETTER_NAME and PROPERTY_SETTER_NAME to know the correct + names. */ + + /* Add the PROPERTY_DECL to the list of properties for the class. */ + TREE_CHAIN (property_decl) = CLASS_PROPERTY_DECL (objc_interface_context); + CLASS_PROPERTY_DECL (objc_interface_context) = property_decl; +} + +/* This is a subroutine of objc_maybe_build_component_ref. Search the + list of methods in the interface (and, failing that, the local list + in the implementation, and failing that, the protocol list) + provided for a 'setter' or 'getter' for 'component' with default + names (ie, if 'component' is "name", then search for "name" and + "setName:"). It is also possible to specify a different + 'getter_name' (this is used for @optional readonly properties). If + any is found, then create an artificial property that uses them. + Return NULL_TREE if 'getter' or 'setter' could not be found. */ +static tree +maybe_make_artificial_property_decl (tree interface, tree implementation, + tree protocol_list, tree component, bool is_class, + tree getter_name) +{ + tree setter_name = get_identifier (objc_build_property_setter_name (component)); + tree getter = NULL_TREE; + tree setter = NULL_TREE; + + if (getter_name == NULL_TREE) + getter_name = component; + + /* First, check the @interface and all superclasses. */ + if (interface) + { + int flags = 0; + + /* Using instance methods of the root class as accessors is most + likely unwanted and can be extremely confusing (and, most + importantly, other Objective-C 2.0 compilers do not do it). + Turn it off. */ + if (is_class) + flags = OBJC_LOOKUP_CLASS | OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS; + + getter = lookup_method_static (interface, getter_name, flags); + setter = lookup_method_static (interface, setter_name, flags); + } + + /* Second, check the local @implementation context. */ + if (!getter && !setter) + { + if (implementation) + { + if (is_class) + { + getter = lookup_method (CLASS_CLS_METHODS (implementation), getter_name); + setter = lookup_method (CLASS_CLS_METHODS (implementation), setter_name); + } + else + { + getter = lookup_method (CLASS_NST_METHODS (implementation), getter_name); + setter = lookup_method (CLASS_NST_METHODS (implementation), setter_name); + } + } + } + + /* Try the protocol_list if we didn't find anything in the + @interface and in the @implementation. */ + if (!getter && !setter) + { + getter = lookup_method_in_protocol_list (protocol_list, getter_name, is_class); + setter = lookup_method_in_protocol_list (protocol_list, setter_name, is_class); + } + + /* There needs to be at least a getter or setter for this to be a + valid 'object.component' syntax. */ + if (getter || setter) + { + /* Yes ... determine the type of the expression. */ + tree property_decl; + tree type; + + if (getter) + type = TREE_VALUE (TREE_TYPE (getter)); + else + type = TREE_VALUE (TREE_TYPE (METHOD_SEL_ARGS (setter))); + + /* Create an artificial property declaration with the + information we collected on the type and getter/setter + names. */ + property_decl = make_node (PROPERTY_DECL); + + TREE_TYPE (property_decl) = type; + DECL_SOURCE_LOCATION (property_decl) = input_location; + TREE_DEPRECATED (property_decl) = 0; + DECL_ARTIFICIAL (property_decl) = 1; + + /* Add property-specific information. Note that one of + PROPERTY_GETTER_NAME or PROPERTY_SETTER_NAME may refer to a + non-existing method; this will generate an error when the + expression is later compiled. At this stage we don't know if + the getter or setter will be used, so we can't generate an + error. */ + PROPERTY_NAME (property_decl) = component; + PROPERTY_GETTER_NAME (property_decl) = getter_name; + PROPERTY_SETTER_NAME (property_decl) = setter_name; + PROPERTY_READONLY (property_decl) = 0; + PROPERTY_NONATOMIC (property_decl) = 0; + PROPERTY_ASSIGN_SEMANTICS (property_decl) = 0; + PROPERTY_IVAR_NAME (property_decl) = NULL_TREE; + PROPERTY_DYNAMIC (property_decl) = 0; + PROPERTY_OPTIONAL (property_decl) = 0; + + if (!getter) + PROPERTY_HAS_NO_GETTER (property_decl) = 1; + + /* The following is currently unused, but it's nice to have + there. We may use it if we need in the future. */ + if (!setter) + PROPERTY_HAS_NO_SETTER (property_decl) = 1; + + return property_decl; + } + + return NULL_TREE; +} + +/* This hook routine is invoked by the parser when an expression such + as 'xxx.yyy' is parsed. We get a chance to process these + expressions in a way that is specified to Objective-C (to implement + the Objective-C 2.0 dot-syntax, properties, or non-fragile ivars). + If the expression is not an Objective-C specified expression, we + should return NULL_TREE; else we return the expression. + + At the moment this only implements dot-syntax and properties (not + non-fragile ivars yet), ie 'object.property' or 'object.component' + where 'component' is not a declared property, but a valid getter or + setter for it could be found. */ +tree +objc_maybe_build_component_ref (tree object, tree property_ident) +{ + tree x = NULL_TREE; + tree rtype; + + /* If we are in Objective-C 1.0 mode, dot-syntax and properties are + not available. */ + if (flag_objc1_only) + return NULL_TREE; + + /* Try to determine if 'object' is an Objective-C object or not. If + not, return. */ + if (object == NULL_TREE || object == error_mark_node + || (rtype = TREE_TYPE (object)) == NULL_TREE) + return NULL_TREE; + + if (property_ident == NULL_TREE || property_ident == error_mark_node + || TREE_CODE (property_ident) != IDENTIFIER_NODE) + return NULL_TREE; + + /* The following analysis of 'object' is similar to the one used for + the 'receiver' of a method invocation. We need to determine what + 'object' is and find the appropriate property (either declared, + or artificial) for it (in the same way as we need to find the + appropriate method prototype for a method invocation). There are + some simplifications here though: "object.property" is invalid if + "object" has a type of "id" or "Class"; it must at least have a + protocol attached to it, and "object" is never a class name as + that is done by objc_build_class_component_ref. Finally, we + don't know if this really is a dot-syntax expression, so we want + to make a quick exit if it is not; for this reason, we try to + postpone checks after determining that 'object' looks like an + Objective-C object. */ + + if (objc_is_id (rtype)) + { + /* This is the case that the 'object' is of type 'id' or + 'Class'. */ + + /* Check if at least it is of type 'id ' or 'Class + '; if so, look the property up in the + protocols. */ + if (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))) + { + tree rprotos = TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype)); + + if (rprotos) + { + /* No point looking up declared @properties if we are + dealing with a class. Classes have no declared + properties. */ + if (!IS_CLASS (rtype)) + x = lookup_property_in_protocol_list (rprotos, property_ident); + + if (x == NULL_TREE) + { + /* Ok, no property. Maybe it was an + object.component dot-syntax without a declared + property (this is valid for classes too). Look + for getter/setter methods and internally declare + an artifical property based on them if found. */ + x = maybe_make_artificial_property_decl (NULL_TREE, + NULL_TREE, + rprotos, + property_ident, + IS_CLASS (rtype), + NULL_TREE); + } + else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x)) + { + /* This is a special, complicated case. If the + property is optional, and is read-only, then the + property is always used for reading, but an + eventual existing non-property setter can be used + for writing. We create an artificial property + decl copying the getter from the optional + property, and looking up the setter in the + interface. */ + x = maybe_make_artificial_property_decl (NULL_TREE, + NULL_TREE, + rprotos, + property_ident, + false, + PROPERTY_GETTER_NAME (x)); + } + } + } + else if (objc_method_context) + { + /* Else, if we are inside a method it could be the case of + 'super' or 'self'. */ + tree interface_type = NULL_TREE; + tree t = object; + while (TREE_CODE (t) == COMPOUND_EXPR + || TREE_CODE (t) == MODIFY_EXPR + || CONVERT_EXPR_P (t) + || TREE_CODE (t) == COMPONENT_REF) + t = TREE_OPERAND (t, 0); + + if (t == UOBJC_SUPER_decl) + interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template)); + else if (t == self_decl) + interface_type = lookup_interface (CLASS_NAME (implementation_template)); + + if (interface_type) + { + if (TREE_CODE (objc_method_context) != CLASS_METHOD_DECL) + x = lookup_property (interface_type, property_ident); + + if (x == NULL_TREE) + { + /* Try the dot-syntax without a declared property. + If this is an access to 'self', it is possible + that they may refer to a setter/getter that is + not declared in the interface, but exists locally + in the implementation. In that case, get the + implementation context and use it. */ + tree implementation = NULL_TREE; + + if (t == self_decl) + implementation = objc_implementation_context; + + x = maybe_make_artificial_property_decl + (interface_type, implementation, NULL_TREE, + property_ident, + (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL), + NULL_TREE); + } + else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x)) + { + tree implementation = NULL_TREE; + + if (t == self_decl) + implementation = objc_implementation_context; + + x = maybe_make_artificial_property_decl (interface_type, + implementation, + NULL_TREE, + property_ident, + false, + PROPERTY_GETTER_NAME (x)); + } + } + } + } + else + { + /* This is the case where we have more information on 'rtype'. */ + tree basetype = TYPE_MAIN_VARIANT (rtype); + + /* Skip the pointer - if none, it's not an Objective-C object or + class. */ + if (basetype != NULL_TREE && TREE_CODE (basetype) == POINTER_TYPE) + basetype = TREE_TYPE (basetype); + else + return NULL_TREE; + + /* Traverse typedefs. */ + while (basetype != NULL_TREE + && TREE_CODE (basetype) == RECORD_TYPE + && OBJC_TYPE_NAME (basetype) + && TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL + && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype))) + basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)); + + if (basetype != NULL_TREE && TYPED_OBJECT (basetype)) + { + tree interface_type = TYPE_OBJC_INTERFACE (basetype); + tree protocol_list = TYPE_OBJC_PROTOCOL_LIST (basetype); + + if (interface_type + && (TREE_CODE (interface_type) == CLASS_INTERFACE_TYPE + || TREE_CODE (interface_type) == CATEGORY_INTERFACE_TYPE + || TREE_CODE (interface_type) == PROTOCOL_INTERFACE_TYPE)) + { + /* Not sure 'rtype' could ever be a class here! Just + for safety we keep the checks. */ + if (!IS_CLASS (rtype)) + { + x = lookup_property (interface_type, property_ident); + + if (x == NULL_TREE) + x = lookup_property_in_protocol_list (protocol_list, + property_ident); + } + + if (x == NULL_TREE) + { + /* Try the dot-syntax without a declared property. + If we are inside a method implementation, it is + possible that they may refer to a setter/getter + that is not declared in the interface, but exists + locally in the implementation. In that case, get + the implementation context and use it. */ + tree implementation = NULL_TREE; + + if (objc_implementation_context + && CLASS_NAME (objc_implementation_context) + == OBJC_TYPE_NAME (interface_type)) + implementation = objc_implementation_context; + + x = maybe_make_artificial_property_decl (interface_type, + implementation, + protocol_list, + property_ident, + IS_CLASS (rtype), + NULL_TREE); + } + else if (PROPERTY_OPTIONAL (x) && PROPERTY_READONLY (x)) + { + tree implementation = NULL_TREE; + + if (objc_implementation_context + && CLASS_NAME (objc_implementation_context) + == OBJC_TYPE_NAME (interface_type)) + implementation = objc_implementation_context; + + x = maybe_make_artificial_property_decl (interface_type, + implementation, + protocol_list, + property_ident, + false, + PROPERTY_GETTER_NAME (x)); + } + } + } + } + + if (x) + { + tree expression; + tree getter_call; + tree deprecated_method_prototype = NULL_TREE; + + /* We have an additional nasty problem here; if this + PROPERTY_REF needs to become a 'getter', then the conversion + from PROPERTY_REF into a getter call happens in gimplify, + after the selector table has already been generated and when + it is too late to add another selector to it. To work around + the problem, we always create the getter call at this stage, + which puts the selector in the table. Note that if the + PROPERTY_REF becomes a 'setter' instead of a 'getter', then + we have added a selector too many to the selector table. + This is a little inefficient. + + Also note that method calls to 'self' and 'super' require the + context (self_decl, UOBJS_SUPER_decl, + objc_implementation_context etc) to be built correctly; this + is yet another reason why building the call at the gimplify + stage (when this context has been lost) is not very + practical. If we build it at this stage, we know it will + always be built correctly. + + If the PROPERTY_HAS_NO_GETTER() (ie, it is an artificial + property decl created to deal with a dotsyntax not really + referring to an existing property) then do not try to build a + call to the getter as there is no getter. */ + if (PROPERTY_HAS_NO_GETTER (x)) + getter_call = NULL_TREE; + else + getter_call = objc_finish_message_expr + (object, PROPERTY_GETTER_NAME (x), NULL_TREE, + /* Disable the immediate deprecation warning if the getter + is deprecated, but record the fact that the getter is + deprecated by setting PROPERTY_REF_DEPRECATED_GETTER to + the method prototype. */ + &deprecated_method_prototype); + + expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call, + deprecated_method_prototype); + SET_EXPR_LOCATION (expression, input_location); + TREE_SIDE_EFFECTS (expression) = 1; + + return expression; + } + + return NULL_TREE; +} + +/* This hook routine is invoked by the parser when an expression such + as 'xxx.yyy' is parsed, and 'xxx' is a class name. This is the + Objective-C 2.0 dot-syntax applied to classes, so we need to + convert it into a setter/getter call on the class. */ +tree +objc_build_class_component_ref (tree class_name, tree property_ident) +{ + tree x = NULL_TREE; + tree object, rtype; + + if (flag_objc1_only) + error_at (input_location, "the dot syntax is not available in Objective-C 1.0"); + + if (class_name == NULL_TREE || class_name == error_mark_node + || TREE_CODE (class_name) != IDENTIFIER_NODE) + return error_mark_node; + + if (property_ident == NULL_TREE || property_ident == error_mark_node + || TREE_CODE (property_ident) != IDENTIFIER_NODE) + return NULL_TREE; + + object = objc_get_class_reference (class_name); + if (!object) + { + /* We know that 'class_name' is an Objective-C class name as the + parser won't call this function if it is not. This is only a + double-check for safety. */ + error_at (input_location, "could not find class %qE", class_name); + return error_mark_node; + } + + rtype = lookup_interface (class_name); + if (!rtype) + { + /* Again, this should never happen, but we do check. */ + error_at (input_location, "could not find interface for class %qE", class_name); + return error_mark_node; + } + else + { + if (TREE_DEPRECATED (rtype)) + warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", class_name); + } + + x = maybe_make_artificial_property_decl (rtype, NULL_TREE, NULL_TREE, + property_ident, + true, NULL_TREE); + + if (x) + { + tree expression; + tree getter_call; + tree deprecated_method_prototype = NULL_TREE; + + if (PROPERTY_HAS_NO_GETTER (x)) + getter_call = NULL_TREE; + else + getter_call = objc_finish_message_expr + (object, PROPERTY_GETTER_NAME (x), NULL_TREE, + &deprecated_method_prototype); + + expression = build4 (PROPERTY_REF, TREE_TYPE(x), object, x, getter_call, + deprecated_method_prototype); + SET_EXPR_LOCATION (expression, input_location); + TREE_SIDE_EFFECTS (expression) = 1; + + return expression; + } + else + { + error_at (input_location, "could not find setter/getter for %qE in class %qE", + property_ident, class_name); + return error_mark_node; + } + + return NULL_TREE; +} + + + +/* This is used because we don't want to expose PROPERTY_REF to the + C/C++ frontends. Maybe we should! */ +bool +objc_is_property_ref (tree node) +{ + if (node && TREE_CODE (node) == PROPERTY_REF) + return true; + else + return false; +} + +/* This function builds a setter call for a PROPERTY_REF (real, for a + declared property, or artificial, for a dot-syntax accessor which + is not corresponding to a property). 'lhs' must be a PROPERTY_REF + (the caller must check this beforehand). 'rhs' is the value to + assign to the property. A plain setter call is returned, or + error_mark_node if the property is readonly. */ + +static tree +objc_build_setter_call (tree lhs, tree rhs) +{ + tree object_expr = PROPERTY_REF_OBJECT (lhs); + tree property_decl = PROPERTY_REF_PROPERTY_DECL (lhs); + + if (PROPERTY_READONLY (property_decl)) + { + error ("readonly property can not be set"); + return error_mark_node; + } + else + { + tree setter_argument = build_tree_list (NULL_TREE, rhs); + tree setter; + + /* TODO: Check that the setter return type is 'void'. */ + + /* TODO: Decay arguments in C. */ + setter = objc_finish_message_expr (object_expr, + PROPERTY_SETTER_NAME (property_decl), + setter_argument, NULL); + return setter; + } + + /* Unreachable, but the compiler may not realize. */ + return error_mark_node; +} + +/* This hook routine is called when a MODIFY_EXPR is being built. We + check what is being modified; if it is a PROPERTY_REF, we need to + generate a 'setter' function call for the property. If this is not + a PROPERTY_REF, we return NULL_TREE and the C/C++ frontend will go + on creating their MODIFY_EXPR. + + This is used for example if you write + + object.count = 1; + + where 'count' is a property. The left-hand side creates a + PROPERTY_REF, and then the compiler tries to generate a MODIFY_EXPR + to assign something to it. We intercept that here, and generate a + call to the 'setter' method instead. */ +tree +objc_maybe_build_modify_expr (tree lhs, tree rhs) +{ + if (lhs && TREE_CODE (lhs) == PROPERTY_REF) + { + /* Building a simple call to the setter method would work for cases such as + + object.count = 1; + + but wouldn't work for cases such as + + count = object2.count = 1; + + to get these to work with very little effort, we build a + compound statement which does the setter call (to set the + property to 'rhs'), but which can also be evaluated returning + the 'rhs'. If the 'rhs' has no side effects, we can simply + evaluate it twice, building + + ([object setProperty: rhs]; rhs) + + If it has side effects, we put it in a temporary variable first, + so we create the following: + + (temp = rhs; [object setProperty: temp]; temp) + + setter_argument is rhs in the first case, and temp in the second + case. + */ + tree setter_argument; + + /* s1, s2 and s3 are the tree statements that we need in the + compound expression. */ + tree s1, s2, s3, compound_expr; + + if (TREE_SIDE_EFFECTS (rhs)) + { + tree bind; + + /* Declare __objc_property_temp in a local bind. */ + setter_argument = objc_create_temporary_var (TREE_TYPE (rhs), "__objc_property_temp"); + DECL_SOURCE_LOCATION (setter_argument) = input_location; + bind = build3 (BIND_EXPR, void_type_node, setter_argument, NULL, NULL); + SET_EXPR_LOCATION (bind, input_location); + TREE_SIDE_EFFECTS (bind) = 1; + add_stmt (bind); + + /* s1: x = rhs */ + s1 = build_modify_expr (input_location, setter_argument, NULL_TREE, + NOP_EXPR, + input_location, rhs, NULL_TREE); + SET_EXPR_LOCATION (s1, input_location); + } + else + { + /* No s1. */ + setter_argument = rhs; + s1 = NULL_TREE; + } + + /* Now build the compound statement. */ + + /* s2: [object setProperty: x] */ + s2 = objc_build_setter_call (lhs, setter_argument); + + /* This happens if building the setter failed because the + property is readonly. */ + if (s2 == error_mark_node) + return error_mark_node; + + SET_EXPR_LOCATION (s2, input_location); + + /* s3: x */ + s3 = convert (TREE_TYPE (lhs), setter_argument); + + /* Now build the compound statement (s1, s2, s3) or (s2, s3) as + appropriate. */ + if (s1) + compound_expr = build_compound_expr (input_location, build_compound_expr (input_location, s1, s2), s3); + else + compound_expr = build_compound_expr (input_location, s2, s3); + + /* Without this, with -Wall you get a 'valued computed is not + used' every time there is a "object.property = x" where the + value of the resulting MODIFY_EXPR is not used. That is + correct (maybe a more sophisticated implementation could + avoid generating the compound expression if not needed), but + we need to turn it off. */ + TREE_NO_WARNING (compound_expr) = 1; + return compound_expr; + } + else + return NULL_TREE; +} + +/* This hook is called by the frontend when one of the four unary + expressions PREINCREMENT_EXPR, POSTINCREMENT_EXPR, + PREDECREMENT_EXPR and POSTDECREMENT_EXPR is being built with an + argument which is a PROPERTY_REF. For example, this happens if you have + + object.count++; + + where 'count' is a property. We need to use the 'getter' and + 'setter' for the property in an appropriate way to build the + appropriate expression. 'code' is the code for the expression (one + of the four mentioned above); 'argument' is the PROPERTY_REF, and + 'increment' is how much we need to add or subtract. */ +tree +objc_build_incr_expr_for_property_ref (location_t location, + enum tree_code code, + tree argument, tree increment) +{ + /* Here are the expressions that we want to build: + + For PREINCREMENT_EXPR / PREDECREMENT_EXPR: + (temp = [object property] +/- increment, [object setProperty: temp], temp) + + For POSTINCREMENT_EXPR / POSTECREMENT_EXPR: + (temp = [object property], [object setProperty: temp +/- increment], temp) */ + + tree temp_variable_decl, bind; + /* s1, s2 and s3 are the tree statements that we need in the + compound expression. */ + tree s1, s2, s3, compound_expr; + + /* Safety check. */ + if (!argument || TREE_CODE (argument) != PROPERTY_REF) + return error_mark_node; + + /* Declare __objc_property_temp in a local bind. */ + temp_variable_decl = objc_create_temporary_var (TREE_TYPE (argument), "__objc_property_temp"); + DECL_SOURCE_LOCATION (temp_variable_decl) = location; + bind = build3 (BIND_EXPR, void_type_node, temp_variable_decl, NULL, NULL); + SET_EXPR_LOCATION (bind, location); + TREE_SIDE_EFFECTS (bind) = 1; + add_stmt (bind); + + /* Now build the compound statement. */ + + /* Note that the 'getter' is generated at gimplify time; at this + time, we can simply put the property_ref (ie, argument) wherever + we want the getter ultimately to be. */ + + /* s1: __objc_property_temp = [object property] <+/- increment> */ + switch (code) + { + case PREINCREMENT_EXPR: + /* __objc_property_temp = [object property] + increment */ + s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE, + NOP_EXPR, + location, build2 (PLUS_EXPR, TREE_TYPE (argument), + argument, increment), NULL_TREE); + break; + case PREDECREMENT_EXPR: + /* __objc_property_temp = [object property] - increment */ + s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE, + NOP_EXPR, + location, build2 (MINUS_EXPR, TREE_TYPE (argument), + argument, increment), NULL_TREE); + break; + case POSTINCREMENT_EXPR: + case POSTDECREMENT_EXPR: + /* __objc_property_temp = [object property] */ + s1 = build_modify_expr (location, temp_variable_decl, NULL_TREE, + NOP_EXPR, + location, argument, NULL_TREE); + break; + default: + gcc_unreachable (); + } + + /* s2: [object setProperty: __objc_property_temp <+/- increment>] */ + switch (code) + { + case PREINCREMENT_EXPR: + case PREDECREMENT_EXPR: + /* [object setProperty: __objc_property_temp] */ + s2 = objc_build_setter_call (argument, temp_variable_decl); + break; + case POSTINCREMENT_EXPR: + /* [object setProperty: __objc_property_temp + increment] */ + s2 = objc_build_setter_call (argument, + build2 (PLUS_EXPR, TREE_TYPE (argument), + temp_variable_decl, increment)); + break; + case POSTDECREMENT_EXPR: + /* [object setProperty: __objc_property_temp - increment] */ + s2 = objc_build_setter_call (argument, + build2 (MINUS_EXPR, TREE_TYPE (argument), + temp_variable_decl, increment)); + break; + default: + gcc_unreachable (); + } + + /* This happens if building the setter failed because the property + is readonly. */ + if (s2 == error_mark_node) + return error_mark_node; + + SET_EXPR_LOCATION (s2, location); + + /* s3: __objc_property_temp */ + s3 = convert (TREE_TYPE (argument), temp_variable_decl); + + /* Now build the compound statement (s1, s2, s3) */ + compound_expr = build_compound_expr (location, build_compound_expr (location, s1, s2), s3); + + /* Prevent C++ from warning with -Wall that "right operand of comma + operator has no effect". */ + TREE_NO_WARNING (compound_expr) = 1; + return compound_expr; +} + +tree +objc_build_method_signature (bool is_class_method, tree rettype, tree selector, + tree optparms, bool ellipsis) +{ + if (is_class_method) + return build_method_decl (CLASS_METHOD_DECL, rettype, selector, + optparms, ellipsis); + else + return build_method_decl (INSTANCE_METHOD_DECL, rettype, selector, + optparms, ellipsis); +} + +void +objc_add_method_declaration (bool is_class_method, tree decl, tree attributes) +{ + if (!objc_interface_context) + { + /* PS: At the moment, due to how the parser works, it should be + impossible to get here. But it's good to have the check in + case the parser changes. + */ + fatal_error ("method declaration not in @interface context"); + } + + if (flag_objc1_only && attributes) + error_at (input_location, "method attributes are not available in Objective-C 1.0"); + + objc_decl_method_attributes (&decl, attributes, 0); + objc_add_method (objc_interface_context, + decl, + is_class_method, + objc_method_optional_flag); +} + +/* Return 'true' if the method definition could be started, and + 'false' if not (because we are outside an @implementation context). +*/ +bool +objc_start_method_definition (bool is_class_method, tree decl, tree attributes) +{ + if (!objc_implementation_context) + { + error ("method definition not in @implementation context"); + return false; + } + + if (decl != NULL_TREE && METHOD_SEL_NAME (decl) == error_mark_node) + return false; + +#ifndef OBJCPLUS + /* Indicate no valid break/continue context by setting these variables + to some non-null, non-label value. We'll notice and emit the proper + error message in c_finish_bc_stmt. */ + c_break_label = c_cont_label = size_zero_node; +#endif + + if (attributes) + warning_at (input_location, 0, "method attributes can not be specified in @implementation context"); + else + objc_decl_method_attributes (&decl, attributes, 0); + + objc_add_method (objc_implementation_context, + decl, + is_class_method, + /* is optional */ false); + start_method_def (decl); + return true; +} + +void +objc_add_instance_variable (tree decl) +{ + (void) add_instance_variable (objc_ivar_context, + objc_ivar_visibility, + decl); +} + +/* Construct a C struct with same name as KLASS, a base struct with tag + SUPER_NAME (if any), and FIELDS indicated. */ + +static tree +objc_build_struct (tree klass, tree fields, tree super_name) +{ + tree name = CLASS_NAME (klass); + tree s = objc_start_struct (name); + tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE); + tree t; + VEC(tree,heap) *objc_info = NULL; + int i; + + if (super) + { + /* Prepend a packed variant of the base class into the layout. This + is necessary to preserve ObjC ABI compatibility. */ + tree base = build_decl (input_location, + FIELD_DECL, NULL_TREE, super); + tree field = TYPE_FIELDS (super); + + while (field && DECL_CHAIN (field) + && TREE_CODE (DECL_CHAIN (field)) == FIELD_DECL) + field = DECL_CHAIN (field); + + /* For ObjC ABI purposes, the "packed" size of a base class is + the sum of the offset and the size (in bits) of the last field + in the class. */ + DECL_SIZE (base) + = (field && TREE_CODE (field) == FIELD_DECL + ? size_binop (PLUS_EXPR, + size_binop (PLUS_EXPR, + size_binop + (MULT_EXPR, + convert (bitsizetype, + DECL_FIELD_OFFSET (field)), + bitsize_int (BITS_PER_UNIT)), + DECL_FIELD_BIT_OFFSET (field)), + DECL_SIZE (field)) + : bitsize_zero_node); + DECL_SIZE_UNIT (base) + = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)), + size_int (BITS_PER_UNIT)); + DECL_ARTIFICIAL (base) = 1; + DECL_ALIGN (base) = 1; + DECL_FIELD_CONTEXT (base) = s; +#ifdef OBJCPLUS + DECL_FIELD_IS_BASE (base) = 1; + + if (fields) + TREE_NO_WARNING (fields) = 1; /* Suppress C++ ABI warnings -- we */ +#endif /* are following the ObjC ABI here. */ + DECL_CHAIN (base) = fields; + fields = base; + } + + /* NB: Calling finish_struct() may cause type TYPE_OBJC_INFO + information in all variants of this RECORD_TYPE to be destroyed + (this is because the C frontend manipulates TYPE_LANG_SPECIFIC + for something else and then will change all variants to use the + same resulting TYPE_LANG_SPECIFIC, ignoring the fact that we use + it for ObjC protocols and that such propagation will make all + variants use the same objc_info), but it is therein that we store + protocol conformance info (e.g., 'NSObject '). + Hence, we must save the ObjC-specific information before calling + finish_struct(), and then reinstate it afterwards. */ + + for (t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t)) + { + INIT_TYPE_OBJC_INFO (t); + VEC_safe_push (tree, heap, objc_info, TYPE_OBJC_INFO (t)); + } + + s = objc_finish_struct (s, fields); + + for (i = 0, t = TYPE_MAIN_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t), i++) + { + /* We now want to restore the different TYPE_OBJC_INFO, but we + have the additional problem that the C frontend doesn't just + copy TYPE_LANG_SPECIFIC from one variant to the other; it + actually makes all of them the *same* TYPE_LANG_SPECIFIC. As + we need a different TYPE_OBJC_INFO for each (and + TYPE_OBJC_INFO is a field in TYPE_LANG_SPECIFIC), we need to + make a copy of each TYPE_LANG_SPECIFIC before we modify + TYPE_OBJC_INFO. */ + if (TYPE_LANG_SPECIFIC (t)) + { + /* Create a copy of TYPE_LANG_SPECIFIC. */ + struct lang_type *old_lang_type = TYPE_LANG_SPECIFIC (t); + ALLOC_OBJC_TYPE_LANG_SPECIFIC (t); + memcpy (TYPE_LANG_SPECIFIC (t), old_lang_type, + SIZEOF_OBJC_TYPE_LANG_SPECIFIC); + } + else + { + /* Just create a new one. */ + ALLOC_OBJC_TYPE_LANG_SPECIFIC (t); + } + /* Replace TYPE_OBJC_INFO with the saved one. This restores any + protocol information that may have been associated with the + type. */ + TYPE_OBJC_INFO (t) = VEC_index (tree, objc_info, i); + /* Replace the IDENTIFIER_NODE with an actual @interface now + that we have it. */ + TYPE_OBJC_INTERFACE (t) = klass; + } + VEC_free (tree, heap, objc_info); + + /* Use TYPE_BINFO structures to point at the super class, if any. */ + objc_xref_basetypes (s, super); + + /* Mark this struct as a class template. */ + CLASS_STATIC_TEMPLATE (klass) = s; + + return s; +} + +/* Mark DECL as being 'volatile' for purposes of Darwin + _setjmp()/_longjmp() exception handling. Called from + objc_mark_locals_volatile(). */ +void +objc_volatilize_decl (tree decl) +{ + /* Do not mess with variables that are 'static' or (already) + 'volatile'. */ + if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl) + && (TREE_CODE (decl) == VAR_DECL + || TREE_CODE (decl) == PARM_DECL)) + { + if (local_variables_to_volatilize == NULL) + local_variables_to_volatilize = VEC_alloc (tree, gc, 8); + + VEC_safe_push (tree, gc, local_variables_to_volatilize, decl); + } +} + +/* Called when parsing of a function completes; if any local variables + in the function were marked as variables to volatilize, change them + to volatile. We do this at the end of the function when the + warnings about discarding 'volatile' have already been produced. + We are making the variables as volatile just to force the compiler + to preserve them between setjmp/longjmp, but we don't want warnings + for them as they aren't really volatile. */ +void +objc_finish_function (void) +{ + /* If there are any local variables to volatilize, volatilize them. */ + if (local_variables_to_volatilize) + { + int i; + tree decl; + FOR_EACH_VEC_ELT (tree, local_variables_to_volatilize, i, decl) + { + tree t = TREE_TYPE (decl); + + t = build_qualified_type (t, TYPE_QUALS (t) | TYPE_QUAL_VOLATILE); + TREE_TYPE (decl) = t; + TREE_THIS_VOLATILE (decl) = 1; + TREE_SIDE_EFFECTS (decl) = 1; + DECL_REGISTER (decl) = 0; +#ifndef OBJCPLUS + C_DECL_REGISTER (decl) = 0; +#endif + } + + /* Now we delete the vector. This sets it to NULL as well. */ + VEC_free (tree, gc, local_variables_to_volatilize); + } +} + +/* Check if protocol PROTO is adopted (directly or indirectly) by class CLS + (including its categories and superclasses) or by object type TYP. + Issue a warning if PROTO is not adopted anywhere and WARN is set. */ + +static bool +objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn) +{ + bool class_type = (cls != NULL_TREE); + + while (cls) + { + tree c; + + /* Check protocols adopted by the class and its categories. */ + for (c = cls; c; c = CLASS_CATEGORY_LIST (c)) + { + if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto)) + return true; + } + + /* Repeat for superclasses. */ + cls = lookup_interface (CLASS_SUPER_NAME (cls)); + } + + /* Check for any protocols attached directly to the object type. */ + if (TYPE_HAS_OBJC_INFO (typ)) + { + if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto)) + return true; + } + + if (warn) + { + *errbuf = 0; + gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ)); + /* NB: Types 'id' and 'Class' cannot reasonably be described as + "implementing" a given protocol, since they do not have an + implementation. */ + if (class_type) + warning (0, "class %qs does not implement the %qE protocol", + identifier_to_locale (errbuf), PROTOCOL_NAME (proto)); + else + warning (0, "type %qs does not conform to the %qE protocol", + identifier_to_locale (errbuf), PROTOCOL_NAME (proto)); + } + + return false; +} + +/* Check if class RCLS and instance struct type RTYP conform to at least the + same protocols that LCLS and LTYP conform to. */ + +static bool +objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn) +{ + tree p; + bool have_lproto = false; + + while (lcls) + { + /* NB: We do _not_ look at categories defined for LCLS; these may or + may not get loaded in, and therefore it is unreasonable to require + that RCLS/RTYP must implement any of their protocols. */ + for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p)) + { + have_lproto = true; + + if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn)) + return warn; + } + + /* Repeat for superclasses. */ + lcls = lookup_interface (CLASS_SUPER_NAME (lcls)); + } + + /* Check for any protocols attached directly to the object type. */ + if (TYPE_HAS_OBJC_INFO (ltyp)) + { + for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p)) + { + have_lproto = true; + + if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn)) + return warn; + } + } + + /* NB: If LTYP and LCLS have no protocols to search for, return 'true' + vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get + away with simply checking for 'id' or 'Class' (!RCLS), since this + routine will not get called in other cases. */ + return have_lproto || (rcls != NULL_TREE); +} + +/* Given two types TYPE1 and TYPE2, return their least common ancestor. + Both TYPE1 and TYPE2 must be pointers, and already determined to be + compatible by objc_compare_types() below. */ + +tree +objc_common_type (tree type1, tree type2) +{ + tree inner1 = TREE_TYPE (type1), inner2 = TREE_TYPE (type2); + + while (POINTER_TYPE_P (inner1)) + { + inner1 = TREE_TYPE (inner1); + inner2 = TREE_TYPE (inner2); + } + + /* If one type is derived from another, return the base type. */ + if (DERIVED_FROM_P (inner1, inner2)) + return type1; + else if (DERIVED_FROM_P (inner2, inner1)) + return type2; + + /* If both types are 'Class', return 'Class'. */ + if (objc_is_class_id (inner1) && objc_is_class_id (inner2)) + return objc_class_type; + + /* Otherwise, return 'id'. */ + return objc_object_type; +} + +/* Determine if it is permissible to assign (if ARGNO is greater than -3) + an instance of RTYP to an instance of LTYP or to compare the two + (if ARGNO is equal to -3), per ObjC type system rules. Before + returning 'true', this routine may issue warnings related to, e.g., + protocol conformance. When returning 'false', the routine must + produce absolutely no warnings; the C or C++ front-end will do so + instead, if needed. If either LTYP or RTYP is not an Objective-C + type, the routine must return 'false'. + + The ARGNO parameter is encoded as follows: + >= 1 Parameter number (CALLEE contains function being called); + 0 Return value; + -1 Assignment; + -2 Initialization; + -3 Comparison (LTYP and RTYP may match in either direction); + -4 Silent comparison (for C++ overload resolution); + -5 Silent "specialization" comparison for RTYP to be a "specialization" + of LTYP (a specialization means that RTYP is LTYP plus some constraints, + so that each object of type RTYP is also of type LTYP). This is used + when comparing property types. */ + +bool +objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee) +{ + tree lcls, rcls, lproto, rproto; + bool pointers_compatible; + + /* We must be dealing with pointer types */ + if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp)) + return false; + + do + { + ltyp = TREE_TYPE (ltyp); /* Remove indirections. */ + rtyp = TREE_TYPE (rtyp); + } + while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp)); + + /* We must also handle function pointers, since ObjC is a bit more + lenient than C or C++ on this. */ + if (TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE) + { + /* Return types must be covariant. */ + if (!comptypes (TREE_TYPE (ltyp), TREE_TYPE (rtyp)) + && !objc_compare_types (TREE_TYPE (ltyp), TREE_TYPE (rtyp), + argno, callee)) + return false; + + /* Argument types must be contravariant. */ + for (ltyp = TYPE_ARG_TYPES (ltyp), rtyp = TYPE_ARG_TYPES (rtyp); + ltyp && rtyp; ltyp = TREE_CHAIN (ltyp), rtyp = TREE_CHAIN (rtyp)) + { + if (!comptypes (TREE_VALUE (rtyp), TREE_VALUE (ltyp)) + && !objc_compare_types (TREE_VALUE (rtyp), TREE_VALUE (ltyp), + argno, callee)) + return false; + } + + return (ltyp == rtyp); + } + + /* Past this point, we are only interested in ObjC class instances, + or 'id' or 'Class'. */ + if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE) + return false; + + if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp) + && !TYPE_HAS_OBJC_INFO (ltyp)) + return false; + + if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp) + && !TYPE_HAS_OBJC_INFO (rtyp)) + return false; + + /* Past this point, we are committed to returning 'true' to the caller + (unless performing a silent comparison; see below). However, we can + still warn about type and/or protocol mismatches. */ + + if (TYPE_HAS_OBJC_INFO (ltyp)) + { + lcls = TYPE_OBJC_INTERFACE (ltyp); + lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp); + } + else + lcls = lproto = NULL_TREE; + + if (TYPE_HAS_OBJC_INFO (rtyp)) + { + rcls = TYPE_OBJC_INTERFACE (rtyp); + rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp); + } + else + rcls = rproto = NULL_TREE; + + /* If we could not find an @interface declaration, we must have + only seen a @class declaration; for purposes of type comparison, + treat it as a stand-alone (root) class. */ + + if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE) + lcls = NULL_TREE; + + if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE) + rcls = NULL_TREE; + + /* If either type is an unqualified 'id', we're done. This is because + an 'id' can be assigned to or from any type with no warnings. */ + if (argno != -5) + { + if ((!lproto && objc_is_object_id (ltyp)) + || (!rproto && objc_is_object_id (rtyp))) + return true; + } + else + { + /* For property checks, though, an 'id' is considered the most + general type of object, hence if you try to specialize an + 'NSArray *' (ltyp) property with an 'id' (rtyp) one, we need + to warn. */ + if (!lproto && objc_is_object_id (ltyp)) + return true; + } + + pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp)); + + /* If the underlying types are the same, and at most one of them has + a protocol list, we do not need to issue any diagnostics. */ + if (pointers_compatible && (!lproto || !rproto)) + return true; + + /* If exactly one of the types is 'Class', issue a diagnostic; any + exceptions of this rule have already been handled. */ + if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp)) + pointers_compatible = false; + /* Otherwise, check for inheritance relations. */ + else + { + if (!pointers_compatible) + { + /* Again, if any of the two is an 'id', we're satisfied, + unless we're comparing properties, in which case only an + 'id' on the left-hand side (old property) is good + enough. */ + if (argno != -5) + pointers_compatible + = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp)); + else + pointers_compatible = objc_is_object_id (ltyp); + } + + if (!pointers_compatible) + pointers_compatible = DERIVED_FROM_P (ltyp, rtyp); + + if (!pointers_compatible && (argno == -3 || argno == -4)) + pointers_compatible = DERIVED_FROM_P (rtyp, ltyp); + } + + /* If the pointers match modulo protocols, check for protocol conformance + mismatches. */ + if (pointers_compatible) + { + pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp, + argno != -3); + + if (!pointers_compatible && argno == -3) + pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp, + argno != -3); + } + + if (!pointers_compatible) + { + /* The two pointers are not exactly compatible. Issue a warning, unless + we are performing a silent comparison, in which case return 'false' + instead. */ + /* NB: For the time being, we shall make our warnings look like their + C counterparts. In the future, we may wish to make them more + ObjC-specific. */ + switch (argno) + { + case -5: + case -4: + return false; + + case -3: + warning (0, "comparison of distinct Objective-C types lacks a cast"); + break; + + case -2: + warning (0, "initialization from distinct Objective-C type"); + break; + + case -1: + warning (0, "assignment from distinct Objective-C type"); + break; + + case 0: + warning (0, "distinct Objective-C type in return"); + break; + + default: + warning (0, "passing argument %d of %qE from distinct " + "Objective-C type", argno, callee); + break; + } + } + + return true; +} + +/* This routine is similar to objc_compare_types except that function-pointers are + excluded. This is because, caller assumes that common types are of (id, Object*) + variety and calls objc_common_type to obtain a common type. There is no commonolty + between two function-pointers in this regard. */ + +bool +objc_have_common_type (tree ltyp, tree rtyp, int argno, tree callee) +{ + if (objc_compare_types (ltyp, rtyp, argno, callee)) + { + /* exclude function-pointer types. */ + do + { + ltyp = TREE_TYPE (ltyp); /* Remove indirections. */ + rtyp = TREE_TYPE (rtyp); + } + while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp)); + return !(TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE); + } + return false; +} + +#ifndef OBJCPLUS +/* Determine if CHILD is derived from PARENT. The routine assumes that + both parameters are RECORD_TYPEs, and is non-reflexive. */ + +static bool +objc_derived_from_p (tree parent, tree child) +{ + parent = TYPE_MAIN_VARIANT (parent); + + for (child = TYPE_MAIN_VARIANT (child); + TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));) + { + child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO + (TYPE_BINFO (child), + 0))); + + if (child == parent) + return true; + } + + return false; +} +#endif + +tree +objc_build_component_ref (tree datum, tree component) +{ + /* If COMPONENT is NULL, the caller is referring to the anonymous + base class field. */ + if (!component) + { + tree base = TYPE_FIELDS (TREE_TYPE (datum)); + + return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE); + } + + /* The 'build_component_ref' routine has been removed from the C++ + front-end, but 'finish_class_member_access_expr' seems to be + a worthy substitute. */ +#ifdef OBJCPLUS + return finish_class_member_access_expr (datum, component, false, + tf_warning_or_error); +#else + return build_component_ref (input_location, datum, component); +#endif +} + +/* Recursively copy inheritance information rooted at BINFO. To do this, + we emulate the song and dance performed by cp/tree.c:copy_binfo(). */ + +static tree +objc_copy_binfo (tree binfo) +{ + tree btype = BINFO_TYPE (binfo); + tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo)); + tree base_binfo; + int ix; + + BINFO_TYPE (binfo2) = btype; + BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo); + BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo); + + /* Recursively copy base binfos of BINFO. */ + for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++) + { + tree base_binfo2 = objc_copy_binfo (base_binfo); + + BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2; + BINFO_BASE_APPEND (binfo2, base_binfo2); + } + + return binfo2; +} + +/* Record superclass information provided in BASETYPE for ObjC class REF. + This is loosely based on cp/decl.c:xref_basetypes(). */ + +static void +objc_xref_basetypes (tree ref, tree basetype) +{ + tree binfo = make_tree_binfo (basetype ? 1 : 0); + + TYPE_BINFO (ref) = binfo; + BINFO_OFFSET (binfo) = size_zero_node; + BINFO_TYPE (binfo) = ref; + + if (basetype) + { + tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype)); + + BINFO_INHERITANCE_CHAIN (base_binfo) = binfo; + BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1); + BINFO_BASE_APPEND (binfo, base_binfo); + BINFO_BASE_ACCESS_APPEND (binfo, access_public_node); + } +} + +/* Called from finish_decl. */ + +void +objc_check_decl (tree decl) +{ + tree type = TREE_TYPE (decl); + + if (TREE_CODE (type) != RECORD_TYPE) + return; + if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type)))) + error ("statically allocated instance of Objective-C class %qE", + type); +} + +void +objc_check_global_decl (tree decl) +{ + tree id = DECL_NAME (decl); + if (objc_is_class_name (id) && global_bindings_p()) + error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id)); +} + +/* Construct a PROTOCOLS-qualified variant of INTERFACE, where + INTERFACE may either name an Objective-C class, or refer to the + special 'id' or 'Class' types. If INTERFACE is not a valid ObjC + type, just return it unchanged. This function is often called when + PROTOCOLS is NULL_TREE, in which case we simply look up the + appropriate INTERFACE. */ + +tree +objc_get_protocol_qualified_type (tree interface, tree protocols) +{ + /* If INTERFACE is not provided, default to 'id'. */ + tree type = (interface ? objc_is_id (interface) : objc_object_type); + bool is_ptr = (type != NULL_TREE); + + if (!is_ptr) + { + type = objc_is_class_name (interface); + + if (type) + { + /* If looking at a typedef, retrieve the precise type it + describes. */ + if (TREE_CODE (interface) == IDENTIFIER_NODE) + interface = identifier_global_value (interface); + + type = ((interface && TREE_CODE (interface) == TYPE_DECL + && DECL_ORIGINAL_TYPE (interface)) + ? DECL_ORIGINAL_TYPE (interface) + : xref_tag (RECORD_TYPE, type)); + } + else + { + /* This case happens when we are given an 'interface' which + is not a valid class name. For example if a typedef was + used, and 'interface' really is the identifier of the + typedef, but when you resolve it you don't get an + Objective-C class, but something else, such as 'int'. + This is an error; protocols make no sense unless you use + them with Objective-C objects. */ + error_at (input_location, "only Objective-C object types can be qualified with a protocol"); + + /* Try to recover. Ignore the invalid class name, and treat + the object as an 'id' to silence further warnings about + the class. */ + type = objc_object_type; + is_ptr = true; + } + } + + if (protocols) + { + type = build_variant_type_copy (type); + + /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s) + to the pointee. */ + if (is_ptr) + { + tree orig_pointee_type = TREE_TYPE (type); + TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type); + + /* Set up the canonical type information. */ + TYPE_CANONICAL (type) + = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type)); + + TYPE_POINTER_TO (TREE_TYPE (type)) = type; + type = TREE_TYPE (type); + } + + /* Look up protocols and install in lang specific list. */ + DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type)); + TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols + (protocols, /* definition_required */ false); + + /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class', + return the pointer to the new pointee variant. */ + if (is_ptr) + type = TYPE_POINTER_TO (type); + else + TYPE_OBJC_INTERFACE (type) + = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type)); + } + + return type; +} + +/* Check for circular dependencies in protocols. The arguments are + PROTO, the protocol to check, and LIST, a list of protocol it + conforms to. */ + +static void +check_protocol_recursively (tree proto, tree list) +{ + tree p; + + for (p = list; p; p = TREE_CHAIN (p)) + { + tree pp = TREE_VALUE (p); + + if (TREE_CODE (pp) == IDENTIFIER_NODE) + pp = lookup_protocol (pp, /* warn if deprecated */ false, + /* definition_required */ false); + + if (pp == proto) + fatal_error ("protocol %qE has circular dependency", + PROTOCOL_NAME (pp)); + if (pp) + check_protocol_recursively (proto, PROTOCOL_LIST (pp)); + } +} + +/* Look up PROTOCOLS, and return a list of those that are found. If + none are found, return NULL. Note that this function will emit a + warning if a protocol is found and is deprecated. If + 'definition_required', then warn if the protocol is found but is + not defined (ie, if we only saw a forward-declaration of the + protocol (as in "@protocol NSObject;") not a real definition with + the list of methods). */ +static tree +lookup_and_install_protocols (tree protocols, bool definition_required) +{ + tree proto; + tree return_value = NULL_TREE; + + if (protocols == error_mark_node) + return NULL; + + for (proto = protocols; proto; proto = TREE_CHAIN (proto)) + { + tree ident = TREE_VALUE (proto); + tree p = lookup_protocol (ident, /* warn_if_deprecated */ true, + definition_required); + + if (p) + return_value = chainon (return_value, + build_tree_list (NULL_TREE, p)); + else if (ident != error_mark_node) + error ("cannot find protocol declaration for %qE", + ident); + } + + return return_value; +} + +static void +build_common_objc_exception_stuff (void) +{ + tree noreturn_list, nothrow_list, temp_type; + + noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL); + nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL); + + /* void objc_exception_throw(id) __attribute__((noreturn)); */ + /* void objc_sync_enter(id); */ + /* void objc_sync_exit(id); */ + temp_type = build_function_type_list (void_type_node, + objc_object_type, + NULL_TREE); + objc_exception_throw_decl + = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL, + noreturn_list); + /* Make sure that objc_exception_throw (id) claims that it may throw an + exception. */ + TREE_NOTHROW (objc_exception_throw_decl) = 0; + + objc_sync_enter_decl + = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN, + NULL, nothrow_list); + + objc_sync_exit_decl + = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN, + NULL, nothrow_list); +} + +/* Purpose: "play" parser, creating/installing representations + of the declarations that are required by Objective-C. + + Model: + + type_spec--------->sc_spec + (tree_list) (tree_list) + | | + | | + identifier_node identifier_node */ + +static void +synth_module_prologue (void) +{ + tree type; + enum debug_info_type save_write_symbols = write_symbols; + const struct gcc_debug_hooks *const save_hooks = debug_hooks; + + /* Suppress outputting debug symbols, because + dbxout_init hasn't been called yet. */ + write_symbols = NO_DEBUG; + debug_hooks = &do_nothing_debug_hooks; + +#ifdef OBJCPLUS + push_lang_context (lang_name_c); /* extern "C" */ +#endif + + /* The following are also defined in and friends. */ + + objc_object_id = get_identifier (TAG_OBJECT); + objc_class_id = get_identifier (TAG_CLASS); + + objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id); + objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id); + + objc_object_type = build_pointer_type (objc_object_reference); + objc_class_type = build_pointer_type (objc_class_reference); + + objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME); + objc_class_name = get_identifier (CLASS_TYPEDEF_NAME); + + /* Declare the 'id' and 'Class' typedefs. */ + type = lang_hooks.decls.pushdecl (build_decl (input_location, + TYPE_DECL, + objc_object_name, + objc_object_type)); + TREE_NO_WARNING (type) = 1; + + type = lang_hooks.decls.pushdecl (build_decl (input_location, + TYPE_DECL, + objc_class_name, + objc_class_type)); + TREE_NO_WARNING (type) = 1; + + /* Forward-declare '@interface Protocol'. */ + type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME); + objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE)); + objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE, type)); + + /* Declare receiver type used for dispatching messages to 'super'. */ + /* `struct objc_super *' */ + objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (TAG_SUPER))); + + /* Declare pointers to method and ivar lists. */ + objc_method_list_ptr = build_pointer_type + (xref_tag (RECORD_TYPE, + get_identifier (UTAG_METHOD_LIST))); + objc_method_proto_list_ptr + = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_METHOD_PROTOTYPE_LIST))); + objc_ivar_list_ptr = build_pointer_type + (xref_tag (RECORD_TYPE, + get_identifier (UTAG_IVAR_LIST))); + + build_common_objc_exception_stuff (); + + /* Set-up runtime-specific templates, message and exception stuff. */ + (*runtime.initialize) (); + + /* Declare objc_getProperty, object_setProperty and other property + accessor helpers. */ + build_common_objc_property_accessor_helpers (); + + /* Forward declare constant_string_id and constant_string_type. */ + if (!constant_string_class_name) + constant_string_class_name = runtime.default_constant_string_class_name; + constant_string_id = get_identifier (constant_string_class_name); + objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE)); + + /* Pre-build the following entities - for speed/convenience. */ + self_id = get_identifier ("self"); + ucmd_id = get_identifier ("_cmd"); + + /* Declare struct _objc_fast_enumeration_state { ... }; */ + build_fast_enumeration_state_template (); + + /* void objc_enumeration_mutation (id) */ + type = build_function_type (void_type_node, + tree_cons (NULL_TREE, objc_object_type, NULL_TREE)); + objc_enumeration_mutation_decl + = add_builtin_function (TAG_ENUMERATION_MUTATION, type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_enumeration_mutation_decl) = 0; + +#ifdef OBJCPLUS + pop_lang_context (); +#endif + + write_symbols = save_write_symbols; + debug_hooks = save_hooks; +} + +/* --- const strings --- */ + +/* Ensure that the ivar list for NSConstantString/NXConstantString + (or whatever was specified via `-fconstant-string-class') + contains fields at least as large as the following three, so that + the runtime can stomp on them with confidence: + + struct STRING_OBJECT_CLASS_NAME + { + Object isa; + char *cString; + unsigned int length; + }; */ + +static int +check_string_class_template (void) +{ + tree field_decl = objc_get_class_ivars (constant_string_id); + +#define AT_LEAST_AS_LARGE_AS(F, T) \ + (F && TREE_CODE (F) == FIELD_DECL \ + && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \ + >= TREE_INT_CST_LOW (TYPE_SIZE (T)))) + + if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node)) + return 0; + + field_decl = DECL_CHAIN (field_decl); + if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node)) + return 0; + + field_decl = DECL_CHAIN (field_decl); + return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node); + +#undef AT_LEAST_AS_LARGE_AS +} + +/* Avoid calling `check_string_class_template ()' more than once. */ +static GTY(()) int string_layout_checked; + +/* Construct an internal string layout to be used as a template for + creating NSConstantString/NXConstantString instances. */ + +static tree +objc_build_internal_const_str_type (void) +{ + tree type = (*lang_hooks.types.make_type) (RECORD_TYPE); + tree fields = build_decl (input_location, + FIELD_DECL, NULL_TREE, ptr_type_node); + tree field = build_decl (input_location, + FIELD_DECL, NULL_TREE, ptr_type_node); + + DECL_CHAIN (field) = fields; fields = field; + field = build_decl (input_location, + FIELD_DECL, NULL_TREE, unsigned_type_node); + DECL_CHAIN (field) = fields; fields = field; + /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in + reverse order! */ + finish_builtin_struct (type, "__builtin_ObjCString", + fields, NULL_TREE); + + return type; +} + +/* Custom build_string which sets TREE_TYPE! */ + +tree +my_build_string (int len, const char *str) +{ + return fix_string_type (build_string (len, str)); +} + +/* Build a string with contents STR and length LEN and convert it to a + pointer. */ + +tree +my_build_string_pointer (int len, const char *str) +{ + tree string = my_build_string (len, str); + tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string))); + return build1 (ADDR_EXPR, ptrtype, string); +} + +static hashval_t +string_hash (const void *ptr) +{ + const_tree const str = ((const struct string_descriptor *)ptr)->literal; + const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str); + int i, len = TREE_STRING_LENGTH (str); + hashval_t h = len; + + for (i = 0; i < len; i++) + h = ((h * 613) + p[i]); + + return h; +} + +static int +string_eq (const void *ptr1, const void *ptr2) +{ + const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal; + const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal; + int len1 = TREE_STRING_LENGTH (str1); + + return (len1 == TREE_STRING_LENGTH (str2) + && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2), + len1)); +} + +/* Given a chain of STRING_CST's, build a static instance of + NXConstantString which points at the concatenation of those + strings. We place the string object in the __string_objects + section of the __OBJC segment. The Objective-C runtime will + initialize the isa pointers of the string objects to point at the + NXConstantString class object. */ + +tree +objc_build_string_object (tree string) +{ + tree constant_string_class; + int length; + tree addr; + struct string_descriptor *desc, key; + void **loc; + + /* We should be passed a STRING_CST. */ + gcc_checking_assert (TREE_CODE (string) == STRING_CST); + length = TREE_STRING_LENGTH (string) - 1; + + /* The target may have different ideas on how to construct an ObjC string + literal. On Darwin (Mac OS X), for example, we may wish to obtain a + constant CFString reference instead. + At present, this is only supported for the NeXT runtime. */ + if (flag_next_runtime + && targetcm.objc_construct_string_object) + { + tree constructor = (*targetcm.objc_construct_string_object) (string); + if (constructor) + return build1 (NOP_EXPR, objc_object_type, constructor); + } + + /* Check whether the string class being used actually exists and has the + correct ivar layout. */ + if (!string_layout_checked) + { + string_layout_checked = -1; + constant_string_class = lookup_interface (constant_string_id); + internal_const_str_type = objc_build_internal_const_str_type (); + + if (!constant_string_class + || !(constant_string_type + = CLASS_STATIC_TEMPLATE (constant_string_class))) + error ("cannot find interface declaration for %qE", + constant_string_id); + /* The NSConstantString/NXConstantString ivar layout is now known. */ + else if (!check_string_class_template ()) + error ("interface %qE does not have valid constant string layout", + constant_string_id); + /* If the runtime can generate a literal reference to the string class, + don't need to run a constructor. */ + else if (!(*runtime.setup_const_string_class_decl)()) + error ("cannot find reference tag for class %qE", constant_string_id); + else + { + string_layout_checked = 1; /* Success! */ + add_class_reference (constant_string_id); + } + } + + if (string_layout_checked == -1) + return error_mark_node; + + /* Perhaps we already constructed a constant string just like this one? */ + key.literal = string; + loc = htab_find_slot (string_htab, &key, INSERT); + desc = (struct string_descriptor *) *loc; + + if (!desc) + { + *loc = desc = ggc_alloc_string_descriptor (); + desc->literal = string; + desc->constructor = + (*runtime.build_const_string_constructor) (input_location, string, length); + } + + addr = convert (build_pointer_type (constant_string_type), + build_unary_op (input_location, + ADDR_EXPR, desc->constructor, 1)); + + return addr; +} + +/* Build a static constant CONSTRUCTOR + with type TYPE and elements ELTS. */ + +tree +objc_build_constructor (tree type, VEC(constructor_elt,gc) *elts) +{ + tree constructor = build_constructor (type, elts); + + TREE_CONSTANT (constructor) = 1; + TREE_STATIC (constructor) = 1; + TREE_READONLY (constructor) = 1; + +#ifdef OBJCPLUS + /* Adjust for impedance mismatch. We should figure out how to build + CONSTRUCTORs that consistently please both the C and C++ gods. */ + if (!VEC_index (constructor_elt, elts, 0)->index) + TREE_TYPE (constructor) = init_list_type_node; +#endif + + return constructor; +} + +/* Return the DECL of the string IDENT in the SECTION. */ + +tree +get_objc_string_decl (tree ident, enum string_section section) +{ + tree chain; + + switch (section) + { + case class_names: + chain = class_names_chain; + break; + case meth_var_names: + chain = meth_var_names_chain; + break; + case meth_var_types: + chain = meth_var_types_chain; + break; + case prop_names_attr: + chain = prop_names_attr_chain; + break; + default: + gcc_unreachable (); + } + + for (; chain != 0; chain = TREE_CHAIN (chain)) + if (TREE_VALUE (chain) == ident) + return (TREE_PURPOSE (chain)); + + /* We didn't find the entry. */ + return NULL_TREE; +} + +/* Create a class reference, but don't create a variable to reference + it. */ + +void +add_class_reference (tree ident) +{ + tree chain; + + if ((chain = cls_ref_chain)) + { + tree tail; + do + { + if (ident == TREE_VALUE (chain)) + return; + + tail = chain; + chain = TREE_CHAIN (chain); + } + while (chain); + + /* Append to the end of the list */ + TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE); + } + else + cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE); +} + +/* Get a class reference, creating it if necessary. Also create the + reference variable. */ +tree +objc_get_class_reference (tree ident) +{ + tree orig_ident = (DECL_P (ident) + ? DECL_NAME (ident) + : TYPE_P (ident) + ? OBJC_TYPE_NAME (ident) + : ident); + bool local_scope = false; + +#ifdef OBJCPLUS + if (processing_template_decl) + /* Must wait until template instantiation time. */ + return build_min_nt (CLASS_REFERENCE_EXPR, ident); +#endif + + if (TREE_CODE (ident) == TYPE_DECL) + ident = (DECL_ORIGINAL_TYPE (ident) + ? DECL_ORIGINAL_TYPE (ident) + : TREE_TYPE (ident)); + +#ifdef OBJCPLUS + if (TYPE_P (ident) + && CP_TYPE_CONTEXT (ident) != global_namespace) + local_scope = true; +#endif + + if (local_scope || !(ident = objc_is_class_name (ident))) + { + error ("%qE is not an Objective-C class name or alias", + orig_ident); + return error_mark_node; + } + + return (*runtime.get_class_reference) (ident); +} + +void +objc_declare_alias (tree alias_ident, tree class_ident) +{ + tree underlying_class; + +#ifdef OBJCPLUS + if (current_namespace != global_namespace) { + error ("Objective-C declarations may only appear in global scope"); + } +#endif /* OBJCPLUS */ + + if (!(underlying_class = objc_is_class_name (class_ident))) + warning (0, "cannot find class %qE", class_ident); + else if (objc_is_class_name (alias_ident)) + warning (0, "class %qE already exists", alias_ident); + else + { + /* Implement @compatibility_alias as a typedef. */ +#ifdef OBJCPLUS + push_lang_context (lang_name_c); /* extern "C" */ +#endif + lang_hooks.decls.pushdecl (build_decl + (input_location, + TYPE_DECL, + alias_ident, + xref_tag (RECORD_TYPE, underlying_class))); +#ifdef OBJCPLUS + pop_lang_context (); +#endif + hash_class_name_enter (als_name_hash_list, alias_ident, + underlying_class); + } +} + +void +objc_declare_class (tree ident_list) +{ + tree list; +#ifdef OBJCPLUS + if (current_namespace != global_namespace) { + error ("Objective-C declarations may only appear in global scope"); + } +#endif /* OBJCPLUS */ + + for (list = ident_list; list; list = TREE_CHAIN (list)) + { + tree ident = TREE_VALUE (list); + + if (! objc_is_class_name (ident)) + { + tree record = lookup_name (ident), type = record; + + if (record) + { + if (TREE_CODE (record) == TYPE_DECL) + type = DECL_ORIGINAL_TYPE (record) + ? DECL_ORIGINAL_TYPE (record) + : TREE_TYPE (record); + + if (!TYPE_HAS_OBJC_INFO (type) + || !TYPE_OBJC_INTERFACE (type)) + { + error ("%qE redeclared as different kind of symbol", + ident); + error ("previous declaration of %q+D", + record); + } + } + + record = xref_tag (RECORD_TYPE, ident); + INIT_TYPE_OBJC_INFO (record); + /* In the case of a @class declaration, we store the ident + in the TYPE_OBJC_INTERFACE. If later an @interface is + found, we'll replace the ident with the interface. */ + TYPE_OBJC_INTERFACE (record) = ident; + hash_class_name_enter (cls_name_hash_list, ident, NULL_TREE); + } + } +} + +tree +objc_is_class_name (tree ident) +{ + hash target; + + if (ident && TREE_CODE (ident) == IDENTIFIER_NODE + && identifier_global_value (ident)) + ident = identifier_global_value (ident); + while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident)) + ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident)); + + if (ident && TREE_CODE (ident) == RECORD_TYPE) + ident = OBJC_TYPE_NAME (ident); +#ifdef OBJCPLUS + if (ident && TREE_CODE (ident) == TYPE_DECL) + { + tree type = TREE_TYPE (ident); + if (type && TREE_CODE (type) == TEMPLATE_TYPE_PARM) + return NULL_TREE; + ident = DECL_NAME (ident); + } +#endif + if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE) + return NULL_TREE; + + if (lookup_interface (ident)) + return ident; + + target = hash_class_name_lookup (cls_name_hash_list, ident); + if (target) + return target->key; + + target = hash_class_name_lookup (als_name_hash_list, ident); + if (target) + { + gcc_assert (target->list && target->list->value); + return target->list->value; + } + + return 0; +} + +/* Check whether TYPE is either 'id' or 'Class'. */ + +tree +objc_is_id (tree type) +{ + if (type && TREE_CODE (type) == IDENTIFIER_NODE + && identifier_global_value (type)) + type = identifier_global_value (type); + + if (type && TREE_CODE (type) == TYPE_DECL) + type = TREE_TYPE (type); + + /* NB: This function may be called before the ObjC front-end has + been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */ + return (objc_object_type && type + && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type)) + ? type + : NULL_TREE); +} + +/* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC + class instance. This is needed by other parts of the compiler to + handle ObjC types gracefully. */ + +tree +objc_is_object_ptr (tree type) +{ + tree ret; + + type = TYPE_MAIN_VARIANT (type); + if (!POINTER_TYPE_P (type)) + return 0; + + ret = objc_is_id (type); + if (!ret) + ret = objc_is_class_name (TREE_TYPE (type)); + + return ret; +} + +static int +objc_is_gcable_type (tree type, int or_strong_p) +{ + tree name; + + if (!TYPE_P (type)) + return 0; + if (objc_is_id (TYPE_MAIN_VARIANT (type))) + return 1; + if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type))) + return 1; + if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF) + return 0; + type = TREE_TYPE (type); + if (TREE_CODE (type) != RECORD_TYPE) + return 0; + name = TYPE_NAME (type); + return (objc_is_class_name (name) != NULL_TREE); +} + +static tree +objc_substitute_decl (tree expr, tree oldexpr, tree newexpr) +{ + if (expr == oldexpr) + return newexpr; + + switch (TREE_CODE (expr)) + { + case COMPONENT_REF: + return objc_build_component_ref + (objc_substitute_decl (TREE_OPERAND (expr, 0), + oldexpr, + newexpr), + DECL_NAME (TREE_OPERAND (expr, 1))); + case ARRAY_REF: + return build_array_ref (input_location, + objc_substitute_decl (TREE_OPERAND (expr, 0), + oldexpr, + newexpr), + TREE_OPERAND (expr, 1)); + case INDIRECT_REF: + return build_indirect_ref (input_location, + objc_substitute_decl (TREE_OPERAND (expr, 0), + oldexpr, + newexpr), RO_ARROW); + default: + return expr; + } +} + +static tree +objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs) +{ + tree func_params; + /* The LHS parameter contains the expression 'outervar->memberspec'; + we need to transform it into '&((typeof(outervar) *) 0)->memberspec', + where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]'). + */ + tree offs + = objc_substitute_decl + (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node)); + tree func + = (flag_objc_direct_dispatch + ? objc_assign_ivar_fast_decl + : objc_assign_ivar_decl); + + offs = convert (integer_type_node, build_unary_op (input_location, + ADDR_EXPR, offs, 0)); + offs = fold (offs); + func_params = tree_cons (NULL_TREE, + convert (objc_object_type, rhs), + tree_cons (NULL_TREE, convert (objc_object_type, outervar), + tree_cons (NULL_TREE, offs, + NULL_TREE))); + + assemble_external (func); + return build_function_call (input_location, func, func_params); +} + +static tree +objc_build_global_assignment (tree lhs, tree rhs) +{ + tree func_params = tree_cons (NULL_TREE, + convert (objc_object_type, rhs), + tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type), + build_unary_op (input_location, ADDR_EXPR, lhs, 0)), + NULL_TREE)); + + assemble_external (objc_assign_global_decl); + return build_function_call (input_location, + objc_assign_global_decl, func_params); +} + +static tree +objc_build_strong_cast_assignment (tree lhs, tree rhs) +{ + tree func_params = tree_cons (NULL_TREE, + convert (objc_object_type, rhs), + tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type), + build_unary_op (input_location, ADDR_EXPR, lhs, 0)), + NULL_TREE)); + + assemble_external (objc_assign_strong_cast_decl); + return build_function_call (input_location, + objc_assign_strong_cast_decl, func_params); +} + +static int +objc_is_gcable_p (tree expr) +{ + return (TREE_CODE (expr) == COMPONENT_REF + ? objc_is_gcable_p (TREE_OPERAND (expr, 1)) + : TREE_CODE (expr) == ARRAY_REF + ? (objc_is_gcable_p (TREE_TYPE (expr)) + || objc_is_gcable_p (TREE_OPERAND (expr, 0))) + : TREE_CODE (expr) == ARRAY_TYPE + ? objc_is_gcable_p (TREE_TYPE (expr)) + : TYPE_P (expr) + ? objc_is_gcable_type (expr, 1) + : (objc_is_gcable_p (TREE_TYPE (expr)) + || (DECL_P (expr) + && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr))))); +} + +static int +objc_is_ivar_reference_p (tree expr) +{ + return (TREE_CODE (expr) == ARRAY_REF + ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0)) + : TREE_CODE (expr) == COMPONENT_REF + ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL + : 0); +} + +static int +objc_is_global_reference_p (tree expr) +{ + return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR + ? objc_is_global_reference_p (TREE_OPERAND (expr, 0)) + : DECL_P (expr) + ? (DECL_FILE_SCOPE_P (expr) || TREE_STATIC (expr)) + : 0); +} + +tree +objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs) +{ + tree result = NULL_TREE, outer; + int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0; + + /* This function is currently only used with the next runtime with + garbage collection enabled (-fobjc-gc). */ + gcc_assert (flag_next_runtime); + + /* See if we have any lhs casts, and strip them out. NB: The lvalue casts + will have been transformed to the form '*(type *)&expr'. */ + if (TREE_CODE (lhs) == INDIRECT_REF) + { + outer = TREE_OPERAND (lhs, 0); + + while (!strong_cast_p + && (CONVERT_EXPR_P (outer) + || TREE_CODE (outer) == NON_LVALUE_EXPR)) + { + tree lhstype = TREE_TYPE (outer); + + /* Descend down the cast chain, and record the first objc_gc + attribute found. */ + if (POINTER_TYPE_P (lhstype)) + { + tree attr + = lookup_attribute ("objc_gc", + TYPE_ATTRIBUTES (TREE_TYPE (lhstype))); + + if (attr) + strong_cast_p = 1; + } + + outer = TREE_OPERAND (outer, 0); + } + } + + /* If we have a __strong cast, it trumps all else. */ + if (strong_cast_p) + { + if (modifycode != NOP_EXPR) + goto invalid_pointer_arithmetic; + + if (warn_assign_intercept) + warning (0, "strong-cast assignment has been intercepted"); + + result = objc_build_strong_cast_assignment (lhs, rhs); + + goto exit_point; + } + + /* the lhs must be of a suitable type, regardless of its underlying + structure. */ + if (!objc_is_gcable_p (lhs)) + goto exit_point; + + outer = lhs; + + while (outer + && (TREE_CODE (outer) == COMPONENT_REF + || TREE_CODE (outer) == ARRAY_REF)) + outer = TREE_OPERAND (outer, 0); + + if (TREE_CODE (outer) == INDIRECT_REF) + { + outer = TREE_OPERAND (outer, 0); + indirect_p = 1; + } + + outer_gc_p = objc_is_gcable_p (outer); + + /* Handle ivar assignments. */ + if (objc_is_ivar_reference_p (lhs)) + { + /* if the struct to the left of the ivar is not an Objective-C object (__strong + doesn't cut it here), the best we can do here is suggest a cast. */ + if (!objc_is_gcable_type (TREE_TYPE (outer), 0)) + { + /* We may still be able to use the global write barrier... */ + if (!indirect_p && objc_is_global_reference_p (outer)) + goto global_reference; + + suggest_cast: + if (modifycode == NOP_EXPR) + { + if (warn_assign_intercept) + warning (0, "strong-cast may possibly be needed"); + } + + goto exit_point; + } + + if (modifycode != NOP_EXPR) + goto invalid_pointer_arithmetic; + + if (warn_assign_intercept) + warning (0, "instance variable assignment has been intercepted"); + + result = objc_build_ivar_assignment (outer, lhs, rhs); + + goto exit_point; + } + + /* Likewise, intercept assignment to global/static variables if their type is + GC-marked. */ + if (objc_is_global_reference_p (outer)) + { + if (indirect_p) + goto suggest_cast; + + global_reference: + if (modifycode != NOP_EXPR) + { + invalid_pointer_arithmetic: + if (outer_gc_p) + warning (0, "pointer arithmetic for garbage-collected objects not allowed"); + + goto exit_point; + } + + if (warn_assign_intercept) + warning (0, "global/static variable assignment has been intercepted"); + + result = objc_build_global_assignment (lhs, rhs); + } + + /* In all other cases, fall back to the normal mechanism. */ + exit_point: + return result; +} + +struct GTY(()) interface_tuple { + tree id; + tree class_name; +}; + +static GTY ((param_is (struct interface_tuple))) htab_t interface_htab; + +static hashval_t +hash_interface (const void *p) +{ + const struct interface_tuple *d = (const struct interface_tuple *) p; + return IDENTIFIER_HASH_VALUE (d->id); +} + +static int +eq_interface (const void *p1, const void *p2) +{ + const struct interface_tuple *d = (const struct interface_tuple *) p1; + return d->id == p2; +} + +tree +lookup_interface (tree ident) +{ +#ifdef OBJCPLUS + if (ident && TREE_CODE (ident) == TYPE_DECL) + ident = DECL_NAME (ident); +#endif + + if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE) + return NULL_TREE; + + { + struct interface_tuple **slot; + tree i = NULL_TREE; + + if (interface_htab) + { + slot = (struct interface_tuple **) + htab_find_slot_with_hash (interface_htab, ident, + IDENTIFIER_HASH_VALUE (ident), + NO_INSERT); + if (slot && *slot) + i = (*slot)->class_name; + } + return i; + } +} + +/* Implement @defs () within struct bodies. */ + +tree +objc_get_class_ivars (tree class_name) +{ + tree interface = lookup_interface (class_name); + + if (interface) + return get_class_ivars (interface, true); + + error ("cannot find interface declaration for %qE", + class_name); + + return error_mark_node; +} + +/* Called when checking the variables in a struct. If we are not + doing the ivars list inside an @interface context, then returns + fieldlist unchanged. Else, returns the list of class ivars. +*/ +tree +objc_get_interface_ivars (tree fieldlist) +{ + if (!objc_collecting_ivars || !objc_interface_context + || TREE_CODE (objc_interface_context) != CLASS_INTERFACE_TYPE + || CLASS_SUPER_NAME (objc_interface_context) == NULL_TREE) + return fieldlist; + + return get_class_ivars (objc_interface_context, true); +} + +/* Used by: build_private_template, continue_class, + and for @defs constructs. */ + +static tree +get_class_ivars (tree interface, bool inherited) +{ + tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface)); + + /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared + by the current class (i.e., they do not include super-class ivars). + However, the CLASS_IVARS list will be side-effected by a call to + finish_struct(), which will fill in field offsets. */ + if (!CLASS_IVARS (interface)) + CLASS_IVARS (interface) = ivar_chain; + + if (!inherited) + return ivar_chain; + + while (CLASS_SUPER_NAME (interface)) + { + /* Prepend super-class ivars. */ + interface = lookup_interface (CLASS_SUPER_NAME (interface)); + ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)), + ivar_chain); + } + + return ivar_chain; +} + +void +objc_maybe_warn_exceptions (location_t loc) +{ + /* -fobjc-exceptions is required to enable Objective-C exceptions. + For example, on Darwin, ObjC exceptions require a sufficiently + recent version of the runtime, so the user must ask for them + explicitly. On other platforms, at the moment -fobjc-exceptions + triggers -fexceptions which again is required for exceptions to + work. */ + if (!flag_objc_exceptions) + { + /* Warn only once per compilation unit. */ + static bool warned = false; + + if (!warned) + { + error_at (loc, "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax"); + warned = true; + } + } +} + +static struct objc_try_context *cur_try_context; + +/* Called just after parsing the @try and its associated BODY. We now + must prepare for the tricky bits -- handling the catches and finally. */ + +void +objc_begin_try_stmt (location_t try_locus, tree body) +{ + struct objc_try_context *c = XCNEW (struct objc_try_context); + c->outer = cur_try_context; + c->try_body = body; + c->try_locus = try_locus; + c->end_try_locus = input_location; + cur_try_context = c; + + /* Collect the list of local variables. We'll mark them as volatile + at the end of compilation of this function to prevent them being + clobbered by setjmp/longjmp. */ + if (flag_objc_sjlj_exceptions) + objc_mark_locals_volatile (NULL); +} + +/* Called just after parsing "@catch (parm)". Open a binding level, + enter DECL into the binding level, and initialize it. Leave the + binding level open while the body of the compound statement is + parsed. If DECL is NULL_TREE, then we are compiling "@catch(...)" + which we compile as "@catch(id tmp_variable)". */ + +void +objc_begin_catch_clause (tree decl) +{ + tree compound, type, t; + bool ellipsis = false; + + /* Begin a new scope that the entire catch clause will live in. */ + compound = c_begin_compound_stmt (true); + + /* Create the appropriate declaration for the argument. */ + if (decl == error_mark_node) + type = error_mark_node; + else + { + if (decl == NULL_TREE) + { + /* If @catch(...) was specified, create a temporary variable of + type 'id' and use it. */ + decl = objc_create_temporary_var (objc_object_type, "__objc_generic_catch_var"); + DECL_SOURCE_LOCATION (decl) = input_location; + /* ... but allow the runtime to differentiate between ellipsis and the + case of @catch (id xyz). */ + ellipsis = true; + } + else + { + /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */ + decl = build_decl (input_location, + VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl)); + } + lang_hooks.decls.pushdecl (decl); + + /* Mark the declaration as used so you never any warnings whether + you use the exception argument or not. TODO: Implement a + -Wunused-exception-parameter flag, which would cause warnings + if exception parameter is not used. */ + TREE_USED (decl) = 1; + DECL_READ_P (decl) = 1; + + type = TREE_TYPE (decl); + } + + /* Verify that the type of the catch is valid. It must be a pointer + to an Objective-C class, or "id" (which is catch-all). */ + if (type == error_mark_node) + { + ;/* Just keep going. */ + } + else if (!objc_type_valid_for_messaging (type, false)) + { + error ("@catch parameter is not a known Objective-C class type"); + type = error_mark_node; + } + else if (TYPE_HAS_OBJC_INFO (TREE_TYPE (type)) + && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (type))) + { + error ("@catch parameter can not be protocol-qualified"); + type = error_mark_node; + } + else if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) + /* @catch (id xyz) or @catch (...) but we note this for runtimes that + identify 'id'. */ + ; + else + { + /* If 'type' was built using typedefs, we need to get rid of + them and get a simple pointer to the class. */ + bool is_typedef = false; + tree x = TYPE_MAIN_VARIANT (type); + + /* Skip from the pointer to the pointee. */ + if (TREE_CODE (x) == POINTER_TYPE) + x = TREE_TYPE (x); + + /* Traverse typedef aliases */ + while (TREE_CODE (x) == RECORD_TYPE && OBJC_TYPE_NAME (x) + && TREE_CODE (OBJC_TYPE_NAME (x)) == TYPE_DECL + && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x))) + { + is_typedef = true; + x = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (x)); + } + + /* If it was a typedef, build a pointer to the final, original + class. */ + if (is_typedef) + type = build_pointer_type (x); + + if (cur_try_context->catch_list) + { + /* Examine previous @catch clauses and see if we've already + caught the type in question. */ + tree_stmt_iterator i = tsi_start (cur_try_context->catch_list); + for (; !tsi_end_p (i); tsi_next (&i)) + { + tree stmt = tsi_stmt (i); + t = CATCH_TYPES (stmt); + if (t == error_mark_node) + continue; + if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type))) + { + warning (0, "exception of type %<%T%> will be caught", + TREE_TYPE (type)); + warning_at (EXPR_LOCATION (stmt), 0, " by earlier handler for %<%T%>", + TREE_TYPE (t ? t : objc_object_type)); + break; + } + } + } + } + + t = (*runtime.begin_catch) (&cur_try_context, type, decl, compound, ellipsis); + add_stmt (t); +} + +/* Called just after parsing the closing brace of a @catch clause. Close + the open binding level, and record a CATCH_EXPR for it. */ + +void +objc_finish_catch_clause (void) +{ + tree c = cur_try_context->current_catch; + cur_try_context->current_catch = NULL; + cur_try_context->end_catch_locus = input_location; + + CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1); + + (*runtime.finish_catch) (&cur_try_context, c); +} + +/* Called after parsing a @finally clause and its associated BODY. + Record the body for later placement. */ + +void +objc_build_finally_clause (location_t finally_locus, tree body) +{ + cur_try_context->finally_body = body; + cur_try_context->finally_locus = finally_locus; + cur_try_context->end_finally_locus = input_location; +} + +/* Called to finalize a @try construct. */ + +tree +objc_finish_try_stmt (void) +{ + struct objc_try_context *c = cur_try_context; + tree stmt; + + if (c->catch_list == NULL && c->finally_body == NULL) + error ("%<@try%> without %<@catch%> or %<@finally%>"); + + stmt = (*runtime.finish_try_stmt) (&cur_try_context); + add_stmt (stmt); + + cur_try_context = c->outer; + free (c); + return stmt; +} + +tree +objc_build_throw_stmt (location_t loc, tree throw_expr) +{ + bool rethrown = false; + + objc_maybe_warn_exceptions (loc); + + /* Don't waste time trying to build something if we're already dead. */ + if (throw_expr == error_mark_node) + return error_mark_node; + + if (throw_expr == NULL) + { + /* If we're not inside a @catch block, there is no "current + exception" to be rethrown. */ + if (cur_try_context == NULL + || cur_try_context->current_catch == NULL) + { + error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block"); + return error_mark_node; + } + + /* Otherwise the object is still sitting in the EXC_PTR_EXPR + value that we get from the runtime. */ + throw_expr = (*runtime.build_exc_ptr) (&cur_try_context); + rethrown = true; + } + else + { + if (!objc_type_valid_for_messaging (TREE_TYPE (throw_expr), true)) + { + error_at (loc, "%<@throw%> argument is not an object"); + return error_mark_node; + } + } + + return (*runtime.build_throw_stmt) (loc, throw_expr, rethrown); +} + +tree +objc_build_synchronized (location_t start_locus, tree object_expr, tree body) +{ + /* object_expr should never be NULL; but in case it is, convert it to + error_mark_node. */ + if (object_expr == NULL) + object_expr = error_mark_node; + + /* Validate object_expr. If not valid, set it to error_mark_node. */ + if (object_expr != error_mark_node) + { + if (!objc_type_valid_for_messaging (TREE_TYPE (object_expr), true)) + { + error_at (start_locus, "%<@synchronized%> argument is not an object"); + object_expr = error_mark_node; + } + } + + if (object_expr == error_mark_node) + { + /* If we found an error, we simply ignore the '@synchronized'. + Compile the body so we can keep going with minimal + casualties. */ + return add_stmt (body); + } + else + { + tree call; + tree args; + + /* objc_sync_enter (object_expr); */ + object_expr = save_expr (object_expr); + args = tree_cons (NULL, object_expr, NULL); + call = build_function_call (input_location, + objc_sync_enter_decl, args); + SET_EXPR_LOCATION (call, start_locus); + add_stmt (call); + + /* Build "objc_sync_exit (object_expr);" but do not add it yet; + it goes inside the @finalize() clause. */ + args = tree_cons (NULL, object_expr, NULL); + call = build_function_call (input_location, + objc_sync_exit_decl, args); + SET_EXPR_LOCATION (call, input_location); + + /* @try { body; } */ + objc_begin_try_stmt (start_locus, body); + + /* @finally { objc_sync_exit (object_expr); } */ + objc_build_finally_clause (input_location, call); + + /* End of try statement. */ + return objc_finish_try_stmt (); + } +} + +/* Construct a C struct corresponding to ObjC class CLASS, with the same + name as the class: + + struct { + struct _objc_class *isa; + ... + }; */ + +static void +build_private_template (tree klass) +{ + if (!CLASS_STATIC_TEMPLATE (klass)) + { + tree record = objc_build_struct (klass, + get_class_ivars (klass, false), + CLASS_SUPER_NAME (klass)); + + /* Set the TREE_USED bit for this struct, so that stab generator + can emit stabs for this struct type. */ + if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record)) + TREE_USED (TYPE_STUB_DECL (record)) = 1; + + /* Copy the attributes from the class to the type. */ + if (TREE_DEPRECATED (klass)) + TREE_DEPRECATED (record) = 1; + } +} + +/* Begin code generation for protocols... */ + +static tree +objc_method_parm_type (tree type) +{ + type = TREE_VALUE (TREE_TYPE (type)); + if (TREE_CODE (type) == TYPE_DECL) + type = TREE_TYPE (type); + return type; +} + +static int +objc_encoded_type_size (tree type) +{ + int sz = int_size_in_bytes (type); + + /* Make all integer and enum types at least as large + as an int. */ + if (sz > 0 && INTEGRAL_TYPE_P (type)) + sz = MAX (sz, int_size_in_bytes (integer_type_node)); + /* Treat arrays as pointers, since that's how they're + passed in. */ + else if (TREE_CODE (type) == ARRAY_TYPE) + sz = int_size_in_bytes (ptr_type_node); + return sz; +} + +/* Encode a method prototype. + + The format is described in gcc/doc/objc.texi, section 'Method + signatures'. + */ + +tree +encode_method_prototype (tree method_decl) +{ + tree parms; + int parm_offset, i; + char buf[40]; + tree result; + + /* ONEWAY and BYCOPY, for remote object are the only method qualifiers. */ + encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl))); + + /* Encode return type. */ + encode_type (objc_method_parm_type (method_decl), + obstack_object_size (&util_obstack), + OBJC_ENCODE_INLINE_DEFS); + + /* Stack size. */ + /* The first two arguments (self and _cmd) are pointers; account for + their size. */ + i = int_size_in_bytes (ptr_type_node); + parm_offset = 2 * i; + for (parms = METHOD_SEL_ARGS (method_decl); parms; + parms = DECL_CHAIN (parms)) + { + tree type = objc_method_parm_type (parms); + int sz = objc_encoded_type_size (type); + + /* If a type size is not known, bail out. */ + if (sz < 0) + { + error_at (DECL_SOURCE_LOCATION (method_decl), + "type %qT does not have a known size", + type); + /* Pretend that the encoding succeeded; the compilation will + fail nevertheless. */ + goto finish_encoding; + } + parm_offset += sz; + } + + sprintf (buf, "%d@0:%d", parm_offset, i); + obstack_grow (&util_obstack, buf, strlen (buf)); + + /* Argument types. */ + parm_offset = 2 * i; + for (parms = METHOD_SEL_ARGS (method_decl); parms; + parms = DECL_CHAIN (parms)) + { + tree type = objc_method_parm_type (parms); + + /* Process argument qualifiers for user supplied arguments. */ + encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms))); + + /* Type. */ + encode_type (type, obstack_object_size (&util_obstack), + OBJC_ENCODE_INLINE_DEFS); + + /* Compute offset. */ + sprintf (buf, "%d", parm_offset); + parm_offset += objc_encoded_type_size (type); + + obstack_grow (&util_obstack, buf, strlen (buf)); + } + + finish_encoding: + obstack_1grow (&util_obstack, '\0'); + result = get_identifier (XOBFINISH (&util_obstack, char *)); + obstack_free (&util_obstack, util_firstobj); + return result; +} + +/* Generate either '- .cxx_construct' or '- .cxx_destruct' for the + current class. */ +#ifdef OBJCPLUS +static void +objc_generate_cxx_ctor_or_dtor (bool dtor) +{ + tree fn, body, compound_stmt, ivar; + + /* - (id) .cxx_construct { ... return self; } */ + /* - (void) .cxx_construct { ... } */ + + objc_start_method_definition + (false /* is_class_method */, + objc_build_method_signature (false /* is_class_method */, + build_tree_list (NULL_TREE, + dtor + ? void_type_node + : objc_object_type), + get_identifier (dtor + ? TAG_CXX_DESTRUCT + : TAG_CXX_CONSTRUCT), + make_node (TREE_LIST), + false), NULL); + body = begin_function_body (); + compound_stmt = begin_compound_stmt (0); + + ivar = CLASS_IVARS (implementation_template); + /* Destroy ivars in reverse order. */ + if (dtor) + ivar = nreverse (copy_list (ivar)); + + for (; ivar; ivar = TREE_CHAIN (ivar)) + { + if (TREE_CODE (ivar) == FIELD_DECL) + { + tree type = TREE_TYPE (ivar); + + /* Call the ivar's default constructor or destructor. Do not + call the destructor unless a corresponding constructor call + has also been made (or is not needed). */ + if (MAYBE_CLASS_TYPE_P (type) + && (dtor + ? (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) + && (!TYPE_NEEDS_CONSTRUCTING (type) + || TYPE_HAS_DEFAULT_CONSTRUCTOR (type))) + : (TYPE_NEEDS_CONSTRUCTING (type) + && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))) + finish_expr_stmt + (build_special_member_call + (build_ivar_reference (DECL_NAME (ivar)), + dtor ? complete_dtor_identifier : complete_ctor_identifier, + NULL, type, LOOKUP_NORMAL, tf_warning_or_error)); + } + } + + /* The constructor returns 'self'. */ + if (!dtor) + finish_return_stmt (self_decl); + + finish_compound_stmt (compound_stmt); + finish_function_body (body); + fn = current_function_decl; + finish_function (); + objc_finish_method_definition (fn); +} + +/* The following routine will examine the current @interface for any + non-POD C++ ivars requiring non-trivial construction and/or + destruction, and then synthesize special '- .cxx_construct' and/or + '- .cxx_destruct' methods which will run the appropriate + construction or destruction code. Note that ivars inherited from + super-classes are _not_ considered. */ +static void +objc_generate_cxx_cdtors (void) +{ + bool need_ctor = false, need_dtor = false; + tree ivar; + + /* Error case, due to possibly an extra @end. */ + if (!objc_implementation_context) + return; + + /* We do not want to do this for categories, since they do not have + their own ivars. */ + + if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE) + return; + + /* First, determine if we even need a constructor and/or destructor. */ + + for (ivar = CLASS_IVARS (implementation_template); ivar; + ivar = TREE_CHAIN (ivar)) + { + if (TREE_CODE (ivar) == FIELD_DECL) + { + tree type = TREE_TYPE (ivar); + + if (MAYBE_CLASS_TYPE_P (type)) + { + if (TYPE_NEEDS_CONSTRUCTING (type) + && TYPE_HAS_DEFAULT_CONSTRUCTOR (type)) + /* NB: If a default constructor is not available, we will not + be able to initialize this ivar; the add_instance_variable() + routine will already have warned about this. */ + need_ctor = true; + + if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type) + && (!TYPE_NEEDS_CONSTRUCTING (type) + || TYPE_HAS_DEFAULT_CONSTRUCTOR (type))) + /* NB: If a default constructor is not available, we will not + call the destructor either, for symmetry. */ + need_dtor = true; + } + } + } + + /* Generate '- .cxx_construct' if needed. */ + + if (need_ctor) + objc_generate_cxx_ctor_or_dtor (false); + + /* Generate '- .cxx_destruct' if needed. */ + + if (need_dtor) + objc_generate_cxx_ctor_or_dtor (true); + + /* The 'imp_list' variable points at an imp_entry record for the current + @implementation. Record the existence of '- .cxx_construct' and/or + '- .cxx_destruct' methods therein; it will be included in the + metadata for the class if the runtime needs it. */ + imp_list->has_cxx_cdtors = (need_ctor || need_dtor); +} +#endif + +static void +error_with_ivar (const char *message, tree decl) +{ + error_at (DECL_SOURCE_LOCATION (decl), "%s %qs", + message, identifier_to_locale (gen_declaration (decl))); + +} + +static void +check_ivars (tree inter, tree imp) +{ + tree intdecls = CLASS_RAW_IVARS (inter); + tree impdecls = CLASS_RAW_IVARS (imp); + + while (1) + { + tree t1, t2; + +#ifdef OBJCPLUS + if (intdecls && TREE_CODE (intdecls) == TYPE_DECL) + intdecls = TREE_CHAIN (intdecls); +#endif + if (intdecls == 0 && impdecls == 0) + break; + if (intdecls == 0 || impdecls == 0) + { + error ("inconsistent instance variable specification"); + break; + } + + t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls); + + if (!comptypes (t1, t2) + || !tree_int_cst_equal (DECL_INITIAL (intdecls), + DECL_INITIAL (impdecls))) + { + if (DECL_NAME (intdecls) == DECL_NAME (impdecls)) + { + error_with_ivar ("conflicting instance variable type", + impdecls); + error_with_ivar ("previous declaration of", + intdecls); + } + else /* both the type and the name don't match */ + { + error ("inconsistent instance variable specification"); + break; + } + } + + else if (DECL_NAME (intdecls) != DECL_NAME (impdecls)) + { + error_with_ivar ("conflicting instance variable name", + impdecls); + error_with_ivar ("previous declaration of", + intdecls); + } + + intdecls = DECL_CHAIN (intdecls); + impdecls = DECL_CHAIN (impdecls); + } +} + + +static void +mark_referenced_methods (void) +{ + struct imp_entry *impent; + tree chain; + + for (impent = imp_list; impent; impent = impent->next) + { + chain = CLASS_CLS_METHODS (impent->imp_context); + while (chain) + { + cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain))); + chain = DECL_CHAIN (chain); + } + + chain = CLASS_NST_METHODS (impent->imp_context); + while (chain) + { + cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain))); + chain = DECL_CHAIN (chain); + } + } +} + +/* If type is empty or only type qualifiers are present, add default + type of id (otherwise grokdeclarator will default to int). */ +static inline tree +adjust_type_for_id_default (tree type) +{ + if (!type) + type = make_node (TREE_LIST); + + if (!TREE_VALUE (type)) + TREE_VALUE (type) = objc_object_type; + else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE + && TYPED_OBJECT (TREE_VALUE (type))) + error ("can not use an object as parameter to a method"); + + return type; +} + +/* Return a KEYWORD_DECL built using the specified key_name, arg_type, + arg_name and attributes. (TODO: Rename KEYWORD_DECL to + OBJC_METHOD_PARM_DECL ?) + + A KEYWORD_DECL is a tree representing the declaration of a + parameter of an Objective-C method. It is produced when parsing a + fragment of Objective-C method declaration of the form + + keyworddecl: + selector ':' '(' typename ')' identifier + + For example, take the Objective-C method + + -(NSString *)pathForResource:(NSString *)resource ofType:(NSString *)type; + + the two fragments "pathForResource:(NSString *)resource" and + "ofType:(NSString *)type" will generate a KEYWORD_DECL each. The + KEYWORD_DECL stores the 'key_name' (eg, identifier for + "pathForResource"), the 'arg_type' (eg, tree representing a + NSString *), the 'arg_name' (eg identifier for "resource") and + potentially some attributes (for example, a tree representing + __attribute__ ((unused)) if such an attribute was attached to a + certain parameter). You can access this information using the + TREE_TYPE (for arg_type), KEYWORD_ARG_NAME (for arg_name), + KEYWORD_KEY_NAME (for key_name), DECL_ATTRIBUTES (for attributes). + + 'key_name' is an identifier node (and is optional as you can omit + it in Objective-C methods). + 'arg_type' is a tree list (and is optional too if no parameter type + was specified). + 'arg_name' is an identifier node and is required. + 'attributes' is an optional tree containing parameter attributes. */ +tree +objc_build_keyword_decl (tree key_name, tree arg_type, + tree arg_name, tree attributes) +{ + tree keyword_decl; + + if (flag_objc1_only && attributes) + error_at (input_location, "method argument attributes are not available in Objective-C 1.0"); + + /* If no type is specified, default to "id". */ + arg_type = adjust_type_for_id_default (arg_type); + + keyword_decl = make_node (KEYWORD_DECL); + + TREE_TYPE (keyword_decl) = arg_type; + KEYWORD_ARG_NAME (keyword_decl) = arg_name; + KEYWORD_KEY_NAME (keyword_decl) = key_name; + DECL_ATTRIBUTES (keyword_decl) = attributes; + + return keyword_decl; +} + +/* Given a chain of keyword_decl's, synthesize the full keyword selector. */ +static tree +build_keyword_selector (tree selector) +{ + int len = 0; + tree key_chain, key_name; + char *buf; + + /* Scan the selector to see how much space we'll need. */ + for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain)) + { + switch (TREE_CODE (selector)) + { + case KEYWORD_DECL: + key_name = KEYWORD_KEY_NAME (key_chain); + break; + case TREE_LIST: + key_name = TREE_PURPOSE (key_chain); + break; + default: + gcc_unreachable (); + } + + if (key_name) + len += IDENTIFIER_LENGTH (key_name) + 1; + else + /* Just a ':' arg. */ + len++; + } + + buf = (char *) alloca (len + 1); + /* Start the buffer out as an empty string. */ + buf[0] = '\0'; + + for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain)) + { + switch (TREE_CODE (selector)) + { + case KEYWORD_DECL: + key_name = KEYWORD_KEY_NAME (key_chain); + break; + case TREE_LIST: + key_name = TREE_PURPOSE (key_chain); + /* The keyword decl chain will later be used as a function + argument chain. Unhook the selector itself so as to not + confuse other parts of the compiler. */ + TREE_PURPOSE (key_chain) = NULL_TREE; + break; + default: + gcc_unreachable (); + } + + if (key_name) + strcat (buf, IDENTIFIER_POINTER (key_name)); + strcat (buf, ":"); + } + + return get_identifier (buf); +} + +/* Used for declarations and definitions. */ + +static tree +build_method_decl (enum tree_code code, tree ret_type, tree selector, + tree add_args, bool ellipsis) +{ + tree method_decl; + + /* If no type is specified, default to "id". */ + ret_type = adjust_type_for_id_default (ret_type); + + /* Note how a method_decl has a TREE_TYPE which is not the function + type of the function implementing the method, but only the return + type of the method. We may want to change this, and store the + entire function type in there (eg, it may be used to simplify + dealing with attributes below). */ + method_decl = make_node (code); + TREE_TYPE (method_decl) = ret_type; + + /* If we have a keyword selector, create an identifier_node that + represents the full selector name (`:' included)... */ + if (TREE_CODE (selector) == KEYWORD_DECL) + { + METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector); + METHOD_SEL_ARGS (method_decl) = selector; + METHOD_ADD_ARGS (method_decl) = add_args; + METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis; + } + else + { + METHOD_SEL_NAME (method_decl) = selector; + METHOD_SEL_ARGS (method_decl) = NULL_TREE; + METHOD_ADD_ARGS (method_decl) = NULL_TREE; + } + + return method_decl; +} + +/* This routine processes objective-c method attributes. */ + +static void +objc_decl_method_attributes (tree *node, tree attributes, int flags) +{ + /* TODO: Replace the hackery below. An idea would be to store the + full function type in the method declaration (for example in + TREE_TYPE) and then expose ObjC method declarations to c-family + and they could deal with them by simply treating them as + functions. */ + + /* Because of the dangers in the hackery below, we filter out any + attribute that we do not know about. For the ones we know about, + we know that they work with the hackery. For the other ones, + there is no guarantee, so we have to filter them out. */ + tree filtered_attributes = NULL_TREE; + + if (attributes) + { + tree attribute; + for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) + { + tree name = TREE_PURPOSE (attribute); + + if (is_attribute_p ("deprecated", name) + || is_attribute_p ("sentinel", name) + || is_attribute_p ("noreturn", name)) + { + /* An attribute that we support; add it to the filtered + attributes. */ + filtered_attributes = chainon (filtered_attributes, + copy_node (attribute)); + } + else if (is_attribute_p ("format", name)) + { + /* "format" is special because before adding it to the + filtered attributes we need to adjust the specified + format by adding the hidden function parameters for + an Objective-C method (self, _cmd). */ + tree new_attribute = copy_node (attribute); + + /* Check the arguments specified with the attribute, and + modify them adding 2 for the two hidden arguments. + Note how this differs from C++; according to the + specs, C++ does not do it so you have to add the +1 + yourself. For Objective-C, instead, the compiler + adds the +2 for you. */ + + /* The attribute arguments have not been checked yet, so + we need to be careful as they could be missing or + invalid. If anything looks wrong, we skip the + process and the compiler will complain about it later + when it validates the attribute. */ + /* Check that we have at least three arguments. */ + if (TREE_VALUE (new_attribute) + && TREE_CHAIN (TREE_VALUE (new_attribute)) + && TREE_CHAIN (TREE_CHAIN (TREE_VALUE (new_attribute)))) + { + tree second_argument = TREE_CHAIN (TREE_VALUE (new_attribute)); + tree third_argument = TREE_CHAIN (second_argument); + tree number; + + /* This is the second argument, the "string-index", + which specifies the index of the format string + argument. Add 2. */ + number = TREE_VALUE (second_argument); + if (number + && TREE_CODE (number) == INTEGER_CST + && TREE_INT_CST_HIGH (number) == 0) + { + TREE_VALUE (second_argument) + = build_int_cst (integer_type_node, + TREE_INT_CST_LOW (number) + 2); + } + + /* This is the third argument, the "first-to-check", + which specifies the index of the first argument to + check. This could be 0, meaning it is not available, + in which case we don't need to add 2. Add 2 if not + 0. */ + number = TREE_VALUE (third_argument); + if (number + && TREE_CODE (number) == INTEGER_CST + && TREE_INT_CST_HIGH (number) == 0 + && TREE_INT_CST_LOW (number) != 0) + { + TREE_VALUE (third_argument) + = build_int_cst (integer_type_node, + TREE_INT_CST_LOW (number) + 2); + } + } + filtered_attributes = chainon (filtered_attributes, + new_attribute); + } + else + warning (OPT_Wattributes, "%qE attribute directive ignored", name); + } + } + + if (filtered_attributes) + { + /* This hackery changes the TREE_TYPE of the ObjC method + declaration to be a function type, so that decl_attributes + will treat the ObjC method as if it was a function. Some + attributes (sentinel, format) will be applied to the function + type, changing it in place; so after calling decl_attributes, + we extract the function type attributes and store them in + METHOD_TYPE_ATTRIBUTES. Some other attributes (noreturn, + deprecated) are applied directly to the method declaration + (by setting TREE_DEPRECATED and TREE_THIS_VOLATILE) so there + is nothing to do. */ + tree saved_type = TREE_TYPE (*node); + TREE_TYPE (*node) = build_function_type + (TREE_VALUE (saved_type), get_arg_type_list (*node, METHOD_REF, 0)); + decl_attributes (node, filtered_attributes, flags); + METHOD_TYPE_ATTRIBUTES (*node) = TYPE_ATTRIBUTES (TREE_TYPE (*node)); + TREE_TYPE (*node) = saved_type; + } +} + +bool +objc_method_decl (enum tree_code opcode) +{ + return opcode == INSTANCE_METHOD_DECL || opcode == CLASS_METHOD_DECL; +} + +/* Used by `build_objc_method_call' and `comp_proto_with_proto'. Return + an argument list for method METH. CONTEXT is either METHOD_DEF or + METHOD_REF, saying whether we are trying to define a method or call + one. SUPERFLAG says this is for a send to super; this makes a + difference for the NeXT calling sequence in which the lookup and + the method call are done together. If METH is null, user-defined + arguments (i.e., beyond self and _cmd) shall be represented by `...'. */ + +tree +get_arg_type_list (tree meth, int context, int superflag) +{ + tree arglist, akey; + + /* Receiver & _cmd types are runtime-dependent. */ + arglist = (*runtime.get_arg_type_list_base) (meth, context, superflag); + + /* No actual method prototype given -- assume that remaining arguments + are `...'. */ + if (!meth) + return arglist; + + /* Build a list of argument types. */ + for (akey = METHOD_SEL_ARGS (meth); akey; akey = DECL_CHAIN (akey)) + { + tree arg_type = TREE_VALUE (TREE_TYPE (akey)); + + /* Decay argument types for the underlying C function as appropriate. */ + arg_type = objc_decay_parm_type (arg_type); + + chainon (arglist, build_tree_list (NULL_TREE, arg_type)); + } + + if (METHOD_ADD_ARGS (meth)) + { + for (akey = TREE_CHAIN (METHOD_ADD_ARGS (meth)); + akey; akey = TREE_CHAIN (akey)) + { + tree arg_type = TREE_TYPE (TREE_VALUE (akey)); + + arg_type = objc_decay_parm_type (arg_type); + + chainon (arglist, build_tree_list (NULL_TREE, arg_type)); + } + + if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth)) + goto lack_of_ellipsis; + } + else + { + lack_of_ellipsis: + chainon (arglist, OBJC_VOID_AT_END); + } + + return arglist; +} + +static tree +check_duplicates (hash hsh, int methods, int is_class) +{ + tree meth = NULL_TREE; + + if (hsh) + { + meth = hsh->key; + + if (hsh->list) + { + /* We have two or more methods with the same name but + different types. */ + attr loop; + + /* But just how different are those types? If + -Wno-strict-selector-match is specified, we shall not + complain if the differences are solely among types with + identical size and alignment. */ + if (!warn_strict_selector_match) + { + for (loop = hsh->list; loop; loop = loop->next) + if (!comp_proto_with_proto (meth, loop->value, 0)) + goto issue_warning; + + return meth; + } + + issue_warning: + if (methods) + { + bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL; + + warning_at (input_location, 0, + "multiple methods named %<%c%E%> found", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (meth)); + inform (DECL_SOURCE_LOCATION (meth), "using %<%c%s%>", + (type ? '-' : '+'), + identifier_to_locale (gen_method_decl (meth))); + } + else + { + bool type = TREE_CODE (meth) == INSTANCE_METHOD_DECL; + + warning_at (input_location, 0, + "multiple selectors named %<%c%E%> found", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (meth)); + inform (DECL_SOURCE_LOCATION (meth), "found %<%c%s%>", + (type ? '-' : '+'), + identifier_to_locale (gen_method_decl (meth))); + } + + for (loop = hsh->list; loop; loop = loop->next) + { + bool type = TREE_CODE (loop->value) == INSTANCE_METHOD_DECL; + + inform (DECL_SOURCE_LOCATION (loop->value), "also found %<%c%s%>", + (type ? '-' : '+'), + identifier_to_locale (gen_method_decl (loop->value))); + } + } + } + return meth; +} + +/* If RECEIVER is a class reference, return the identifier node for + the referenced class. RECEIVER is created by objc_get_class_reference, + so we check the exact form created depending on which runtimes are + used. */ + +static tree +receiver_is_class_object (tree receiver, int self, int super) +{ + tree exp, arg; + + /* The receiver is 'self' or 'super' in the context of a class method. */ + if (objc_method_context + && TREE_CODE (objc_method_context) == CLASS_METHOD_DECL + && (self || super)) + return (super + ? CLASS_SUPER_NAME (implementation_template) + : CLASS_NAME (implementation_template)); + + /* The runtime might encapsulate things its own way. */ + exp = (*runtime.receiver_is_class_object) (receiver); + if (exp) + return exp; + + /* The receiver is a function call that returns an id. Check if + it is a call to objc_getClass, if so, pick up the class name. */ + if (TREE_CODE (receiver) == CALL_EXPR + && (exp = CALL_EXPR_FN (receiver)) + && TREE_CODE (exp) == ADDR_EXPR + && (exp = TREE_OPERAND (exp, 0)) + && TREE_CODE (exp) == FUNCTION_DECL + /* For some reason, we sometimes wind up with multiple FUNCTION_DECL + prototypes for objc_get_class(). Thankfully, they seem to share the + same function type. */ + && TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl) + && !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), runtime.tag_getclass) + /* We have a call to objc_get_class/objc_getClass! */ + && (arg = CALL_EXPR_ARG (receiver, 0))) + { + STRIP_NOPS (arg); + if (TREE_CODE (arg) == ADDR_EXPR + && (arg = TREE_OPERAND (arg, 0)) + && TREE_CODE (arg) == STRING_CST) + /* Finally, we have the class name. */ + return get_identifier (TREE_STRING_POINTER (arg)); + } + return 0; +} + +/* If we are currently building a message expr, this holds + the identifier of the selector of the message. This is + used when printing warnings about argument mismatches. */ + +static tree current_objc_message_selector = 0; + +tree +objc_message_selector (void) +{ + return current_objc_message_selector; +} + +/* Construct an expression for sending a message. + MESS has the object to send to in TREE_PURPOSE + and the argument list (including selector) in TREE_VALUE. + + (*((*)())_msg)(receiver, selTransTbl[n], ...); + (*((*)())_msgSuper)(receiver, selTransTbl[n], ...); */ + +tree +objc_build_message_expr (tree mess) +{ + tree receiver = TREE_PURPOSE (mess); + tree sel_name; +#ifdef OBJCPLUS + tree args = TREE_PURPOSE (TREE_VALUE (mess)); +#else + tree args = TREE_VALUE (mess); +#endif + tree method_params = NULL_TREE; + + if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK) + return error_mark_node; + + /* Obtain the full selector name. */ + switch (TREE_CODE (args)) + { + case IDENTIFIER_NODE: + /* A unary selector. */ + sel_name = args; + break; + case TREE_LIST: + sel_name = build_keyword_selector (args); + break; + default: + gcc_unreachable (); + } + + /* Build the parameter list to give to the method. */ + if (TREE_CODE (args) == TREE_LIST) +#ifdef OBJCPLUS + method_params = chainon (args, TREE_VALUE (TREE_VALUE (mess))); +#else + { + tree chain = args, prev = NULL_TREE; + + /* We have a keyword selector--check for comma expressions. */ + while (chain) + { + tree element = TREE_VALUE (chain); + + /* We have a comma expression, must collapse... */ + if (TREE_CODE (element) == TREE_LIST) + { + if (prev) + TREE_CHAIN (prev) = element; + else + args = element; + } + prev = chain; + chain = TREE_CHAIN (chain); + } + method_params = args; + } +#endif + +#ifdef OBJCPLUS + if (processing_template_decl) + /* Must wait until template instantiation time. */ + return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name, + method_params); +#endif + + return objc_finish_message_expr (receiver, sel_name, method_params, NULL); +} + +/* Look up method SEL_NAME that would be suitable for receiver + of type 'id' (if IS_CLASS is zero) or 'Class' (if IS_CLASS is + nonzero), and report on any duplicates. */ + +static tree +lookup_method_in_hash_lists (tree sel_name, int is_class) +{ + hash method_prototype = NULL; + + if (!is_class) + method_prototype = hash_lookup (nst_method_hash_list, + sel_name); + + if (!method_prototype) + { + method_prototype = hash_lookup (cls_method_hash_list, + sel_name); + is_class = 1; + } + + return check_duplicates (method_prototype, 1, is_class); +} + +/* The 'objc_finish_message_expr' routine is called from within + 'objc_build_message_expr' for non-template functions. In the case of + C++ template functions, it is called from 'build_expr_from_tree' + (in decl2.c) after RECEIVER and METHOD_PARAMS have been expanded. + + If the DEPRECATED_METHOD_PROTOTYPE argument is NULL, then we warn + if the method being used is deprecated. If it is not NULL, instead + of deprecating, we set *DEPRECATED_METHOD_PROTOTYPE to the method + prototype that was used and is deprecated. This is useful for + getter calls that are always generated when compiling dot-syntax + expressions, even if they may not be used. In that case, we don't + want the warning immediately; we produce it (if needed) at gimplify + stage when we are sure that the deprecated getter is being + used. */ +tree +objc_finish_message_expr (tree receiver, tree sel_name, tree method_params, + tree *deprecated_method_prototype) +{ + tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype; + tree retval, class_tree; + int self, super, have_cast; + + /* We have used the receiver, so mark it as read. */ + mark_exp_read (receiver); + + /* Extract the receiver of the message, as well as its type + (where the latter may take the form of a cast or be inferred + from the implementation context). */ + rtype = receiver; + while (TREE_CODE (rtype) == COMPOUND_EXPR + || TREE_CODE (rtype) == MODIFY_EXPR + || CONVERT_EXPR_P (rtype) + || TREE_CODE (rtype) == COMPONENT_REF) + rtype = TREE_OPERAND (rtype, 0); + + self = (rtype == self_decl); + super = (rtype == UOBJC_SUPER_decl); + rtype = TREE_TYPE (receiver); + + have_cast = (TREE_CODE (receiver) == NOP_EXPR + || (TREE_CODE (receiver) == COMPOUND_EXPR + && !IS_SUPER (rtype))); + + /* If we are calling [super dealloc], reset our warning flag. */ + if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name))) + should_call_super_dealloc = 0; + + /* If the receiver is a class object, retrieve the corresponding + @interface, if one exists. */ + class_tree = receiver_is_class_object (receiver, self, super); + + /* Now determine the receiver type (if an explicit cast has not been + provided). */ + if (!have_cast) + { + if (class_tree) + rtype = lookup_interface (class_tree); + /* Handle `self' and `super'. */ + else if (super) + { + if (!CLASS_SUPER_NAME (implementation_template)) + { + error ("no super class declared in @interface for %qE", + CLASS_NAME (implementation_template)); + return error_mark_node; + } + rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template)); + } + else if (self) + rtype = lookup_interface (CLASS_NAME (implementation_template)); + } + + /* If receiver is of type `id' or `Class' (or if the @interface for a + class is not visible), we shall be satisfied with the existence of + any instance or class method. */ + if (objc_is_id (rtype)) + { + class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE); + rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype)) + ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype)) + : NULL_TREE); + rtype = NULL_TREE; + + if (rprotos) + { + /* If messaging 'id ' or 'Class ', first search + in protocols themselves for the method prototype. */ + method_prototype + = lookup_method_in_protocol_list (rprotos, sel_name, + class_tree != NULL_TREE); + + /* If messaging 'Class ' but did not find a class method + prototype, search for an instance method instead, and warn + about having done so. */ + if (!method_prototype && !rtype && class_tree != NULL_TREE) + { + method_prototype + = lookup_method_in_protocol_list (rprotos, sel_name, 0); + + if (method_prototype) + warning (0, "found %<-%E%> instead of %<+%E%> in protocol(s)", + sel_name, sel_name); + } + } + } + else if (rtype) + { + tree orig_rtype = rtype; + + if (TREE_CODE (rtype) == POINTER_TYPE) + rtype = TREE_TYPE (rtype); + /* Traverse typedef aliases */ + while (TREE_CODE (rtype) == RECORD_TYPE && OBJC_TYPE_NAME (rtype) + && TREE_CODE (OBJC_TYPE_NAME (rtype)) == TYPE_DECL + && DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype))) + rtype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (rtype)); + if (TYPED_OBJECT (rtype)) + { + rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype); + rtype = TYPE_OBJC_INTERFACE (rtype); + } + /* If we could not find an @interface declaration, we must have + only seen a @class declaration; so, we cannot say anything + more intelligent about which methods the receiver will + understand. */ + if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE) + { + rtype = NULL_TREE; + /* We could not find an @interface declaration, yet Message maybe in a + @class's protocol. */ + if (!method_prototype && rprotos) + method_prototype + = lookup_method_in_protocol_list (rprotos, sel_name, 0); + } + else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE + || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE) + { + /* We have a valid ObjC class name. Look up the method name + in the published @interface for the class (and its + superclasses). */ + method_prototype + = lookup_method_static (rtype, sel_name, class_tree != NULL_TREE); + + /* If the method was not found in the @interface, it may still + exist locally as part of the @implementation. */ + if (!method_prototype && objc_implementation_context + && CLASS_NAME (objc_implementation_context) + == OBJC_TYPE_NAME (rtype)) + method_prototype + = lookup_method + ((class_tree + ? CLASS_CLS_METHODS (objc_implementation_context) + : CLASS_NST_METHODS (objc_implementation_context)), + sel_name); + + /* If we haven't found a candidate method by now, try looking for + it in the protocol list. */ + if (!method_prototype && rprotos) + method_prototype + = lookup_method_in_protocol_list (rprotos, sel_name, + class_tree != NULL_TREE); + } + else + { + warning (0, "invalid receiver type %qs", + identifier_to_locale (gen_type_name (orig_rtype))); + /* After issuing the "invalid receiver" warning, perform method + lookup as if we were messaging 'id'. */ + rtype = rprotos = NULL_TREE; + } + } + + + /* For 'id' or 'Class' receivers, search in the global hash table + as a last resort. For all receivers, warn if protocol searches + have failed. */ + if (!method_prototype) + { + if (rprotos) + warning (0, "%<%c%E%> not found in protocol(s)", + (class_tree ? '+' : '-'), + sel_name); + + if (!rtype) + method_prototype + = lookup_method_in_hash_lists (sel_name, class_tree != NULL_TREE); + } + + if (!method_prototype) + { + static bool warn_missing_methods = false; + + if (rtype) + warning (0, "%qE may not respond to %<%c%E%>", + OBJC_TYPE_NAME (rtype), + (class_tree ? '+' : '-'), + sel_name); + /* If we are messaging an 'id' or 'Class' object and made it here, + then we have failed to find _any_ instance or class method, + respectively. */ + else + warning (0, "no %<%c%E%> method found", + (class_tree ? '+' : '-'), + sel_name); + + if (!warn_missing_methods) + { + warning_at (input_location, + 0, "(Messages without a matching method signature"); + warning_at (input_location, + 0, "will be assumed to return % and accept"); + warning_at (input_location, + 0, "%<...%> as arguments.)"); + warn_missing_methods = true; + } + } + else + { + /* Warn if the method is deprecated, but not if the receiver is + a generic 'id'. 'id' is used to cast an object to a generic + object of an unspecified class; in that case, we'll use + whatever method prototype we can find to get the method + argument and return types, but it is not appropriate to + produce deprecation warnings since we don't know the class + that the object will be of at runtime. The @interface(s) for + that class may not even be available to the compiler right + now, and it is perfectly possible that the method is marked + as non-deprecated in such @interface(s). + + In practice this makes sense since casting an object to 'id' + is often used precisely to turn off warnings associated with + the object being of a particular class. */ + if (TREE_DEPRECATED (method_prototype) && rtype != NULL_TREE) + { + if (deprecated_method_prototype) + *deprecated_method_prototype = method_prototype; + else + warn_deprecated_use (method_prototype, NULL_TREE); + } + } + + /* Save the selector name for printing error messages. */ + current_objc_message_selector = sel_name; + + /* Build the method call. + TODO: Get the location from somewhere that will work for delayed + expansion. */ + + retval = (*runtime.build_objc_method_call) (input_location, method_prototype, + receiver, rtype, sel_name, + method_params, super); + + current_objc_message_selector = 0; + + return retval; +} + + +/* This routine creates a static variable used to implement @protocol(MyProtocol) + expression. This variable will be initialized to global protocol_t meta-data + pointer. */ + +/* This function is called by the parser when (and only when) a + @protocol() expression is found, in order to compile it. */ +tree +objc_build_protocol_expr (tree protoname) +{ + tree p = lookup_protocol (protoname, /* warn if deprecated */ true, + /* definition_required */ false); + + if (!p) + { + error ("cannot find protocol declaration for %qE", protoname); + return error_mark_node; + } + + return (*runtime.get_protocol_reference) (input_location, p); +} + +/* This function is called by the parser when a @selector() expression + is found, in order to compile it. It is only called by the parser + and only to compile a @selector(). LOC is the location of the + @selector. */ +tree +objc_build_selector_expr (location_t loc, tree selnamelist) +{ + tree selname; + + /* Obtain the full selector name. */ + switch (TREE_CODE (selnamelist)) + { + case IDENTIFIER_NODE: + /* A unary selector. */ + selname = selnamelist; + break; + case TREE_LIST: + selname = build_keyword_selector (selnamelist); + break; + default: + gcc_unreachable (); + } + + /* If we are required to check @selector() expressions as they + are found, check that the selector has been declared. */ + if (warn_undeclared_selector) + { + /* Look the selector up in the list of all known class and + instance methods (up to this line) to check that the selector + exists. */ + hash hsh; + + /* First try with instance methods. */ + hsh = hash_lookup (nst_method_hash_list, selname); + + /* If not found, try with class methods. */ + if (!hsh) + { + hsh = hash_lookup (cls_method_hash_list, selname); + } + + /* If still not found, print out a warning. */ + if (!hsh) + { + warning (0, "undeclared selector %qE", selname); + } + } + + /* The runtimes do this differently, most particularly, GNU has typed + selectors, whilst NeXT does not. */ + return (*runtime.build_selector_reference) (loc, selname, NULL_TREE); +} + +/* This is used to implement @encode(). See gcc/doc/objc.texi, + section '@encode'. */ +tree +objc_build_encode_expr (tree type) +{ + tree result; + const char *string; + + encode_type (type, obstack_object_size (&util_obstack), + OBJC_ENCODE_INLINE_DEFS); + obstack_1grow (&util_obstack, 0); /* null terminate string */ + string = XOBFINISH (&util_obstack, const char *); + + /* Synthesize a string that represents the encoded struct/union. */ + result = my_build_string (strlen (string) + 1, string); + obstack_free (&util_obstack, util_firstobj); + return result; +} + +static tree +build_ivar_reference (tree id) +{ + tree base; + if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL) + { + /* Historically, a class method that produced objects (factory + method) would assign `self' to the instance that it + allocated. This would effectively turn the class method into + an instance method. Following this assignment, the instance + variables could be accessed. That practice, while safe, + violates the simple rule that a class method should not refer + to an instance variable. It's better to catch the cases + where this is done unknowingly than to support the above + paradigm. */ + warning (0, "instance variable %qE accessed in class method", + id); + self_decl = convert (objc_instance_type, self_decl); /* cast */ + } + + base = build_indirect_ref (input_location, self_decl, RO_ARROW); + return (*runtime.build_ivar_reference) (input_location, base, id); +} + +/* Compute a hash value for a given method SEL_NAME. */ + +static size_t +hash_func (tree sel_name) +{ + const unsigned char *s + = (const unsigned char *)IDENTIFIER_POINTER (sel_name); + size_t h = 0; + + while (*s) + h = h * 67 + *s++ - 113; + return h; +} + +static void +hash_init (void) +{ + nst_method_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE); + cls_method_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE); + + cls_name_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE); + als_name_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE); + + ivar_offset_hash_list = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE); + + /* Initialize the hash table used to hold the constant string objects. */ + string_htab = htab_create_ggc (31, string_hash, + string_eq, NULL); +} + +/* This routine adds sel_name to the hash list. sel_name is a class or alias + name for the class. If alias name, then value is its underlying class. + If class, the value is NULL_TREE. */ + +static void +hash_class_name_enter (hash *hashlist, tree sel_name, tree value) +{ + hash obj; + int slot = hash_func (sel_name) % SIZEHASHTABLE; + + obj = ggc_alloc_hashed_entry (); + if (value != NULL_TREE) + { + /* Save the underlying class for the 'alias' in the hash table */ + attr obj_attr = ggc_alloc_hashed_attribute (); + obj_attr->value = value; + obj->list = obj_attr; + } + else + obj->list = 0; + obj->next = hashlist[slot]; + obj->key = sel_name; + + hashlist[slot] = obj; /* append to front */ + +} + +/* + Searches in the hash table looking for a match for class or alias name. +*/ + +static hash +hash_class_name_lookup (hash *hashlist, tree sel_name) +{ + hash target; + + target = hashlist[hash_func (sel_name) % SIZEHASHTABLE]; + + while (target) + { + if (sel_name == target->key) + return target; + + target = target->next; + } + return 0; +} + +/* WARNING!!!! hash_enter is called with a method, and will peek + inside to find its selector! But hash_lookup is given a selector + directly, and looks for the selector that's inside the found + entry's key (method) for comparison. */ + +static void +hash_enter (hash *hashlist, tree method) +{ + hash obj; + int slot = hash_func (METHOD_SEL_NAME (method)) % SIZEHASHTABLE; + + obj = ggc_alloc_hashed_entry (); + obj->list = 0; + obj->next = hashlist[slot]; + obj->key = method; + + hashlist[slot] = obj; /* append to front */ +} + +static hash +hash_lookup (hash *hashlist, tree sel_name) +{ + hash target; + + target = hashlist[hash_func (sel_name) % SIZEHASHTABLE]; + + while (target) + { + if (sel_name == METHOD_SEL_NAME (target->key)) + return target; + + target = target->next; + } + return 0; +} + +static void +hash_add_attr (hash entry, tree value) +{ + attr obj; + + obj = ggc_alloc_hashed_attribute (); + obj->next = entry->list; + obj->value = value; + + entry->list = obj; /* append to front */ +} + +static tree +lookup_method (tree mchain, tree method) +{ + tree key; + + if (TREE_CODE (method) == IDENTIFIER_NODE) + key = method; + else + key = METHOD_SEL_NAME (method); + + while (mchain) + { + if (METHOD_SEL_NAME (mchain) == key) + return mchain; + + mchain = DECL_CHAIN (mchain); + } + return NULL_TREE; +} + +/* Look up a class (if OBJC_LOOKUP_CLASS is set in FLAGS) or instance + method in INTERFACE, along with any categories and protocols + attached thereto. If method is not found, and the + OBJC_LOOKUP_NO_SUPER is _not_ set in FLAGS, recursively examine the + INTERFACE's superclass. If OBJC_LOOKUP_CLASS is set, + OBJC_LOOKUP_NO_SUPER is clear, and no suitable class method could + be found in INTERFACE or any of its superclasses, look for an + _instance_ method of the same name in the root class as a last + resort. This behaviour can be turned off by using + OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS. + + If a suitable method cannot be found, return NULL_TREE. */ + +static tree +lookup_method_static (tree interface, tree ident, int flags) +{ + tree meth = NULL_TREE, root_inter = NULL_TREE; + tree inter = interface; + int is_class = (flags & OBJC_LOOKUP_CLASS); + int no_superclasses = (flags & OBJC_LOOKUP_NO_SUPER); + int no_instance_methods_of_root_class = (flags & OBJC_LOOKUP_NO_INSTANCE_METHODS_OF_ROOT_CLASS); + + while (inter) + { + tree chain = is_class ? CLASS_CLS_METHODS (inter) : CLASS_NST_METHODS (inter); + tree category = inter; + + /* First, look up the method in the class itself. */ + if ((meth = lookup_method (chain, ident))) + return meth; + + /* Failing that, look for the method in each category of the class. */ + while ((category = CLASS_CATEGORY_LIST (category))) + { + chain = is_class ? CLASS_CLS_METHODS (category) : CLASS_NST_METHODS (category); + + /* Check directly in each category. */ + if ((meth = lookup_method (chain, ident))) + return meth; + + /* Failing that, check in each category's protocols. */ + if (CLASS_PROTOCOL_LIST (category)) + { + if ((meth = (lookup_method_in_protocol_list + (CLASS_PROTOCOL_LIST (category), ident, is_class)))) + return meth; + } + } + + /* If not found in categories, check in protocols of the main class. */ + if (CLASS_PROTOCOL_LIST (inter)) + { + if ((meth = (lookup_method_in_protocol_list + (CLASS_PROTOCOL_LIST (inter), ident, is_class)))) + return meth; + } + + /* If we were instructed not to look in superclasses, don't. */ + if (no_superclasses) + return NULL_TREE; + + /* Failing that, climb up the inheritance hierarchy. */ + root_inter = inter; + inter = lookup_interface (CLASS_SUPER_NAME (inter)); + } + while (inter); + + if (is_class && !no_instance_methods_of_root_class) + { + /* If no class (factory) method was found, check if an _instance_ + method of the same name exists in the root class. This is what + the Objective-C runtime will do. */ + return lookup_method_static (root_inter, ident, 0); + } + else + { + /* If an instance method was not found, return 0. */ + return NULL_TREE; + } +} + +/* Add the method to the hash list if it doesn't contain an identical + method already. */ + +static void +add_method_to_hash_list (hash *hash_list, tree method) +{ + hash hsh; + + if (!(hsh = hash_lookup (hash_list, METHOD_SEL_NAME (method)))) + { + /* Install on a global chain. */ + hash_enter (hash_list, method); + } + else + { + /* Check types against those; if different, add to a list. */ + attr loop; + int already_there = comp_proto_with_proto (method, hsh->key, 1); + for (loop = hsh->list; !already_there && loop; loop = loop->next) + already_there |= comp_proto_with_proto (method, loop->value, 1); + if (!already_there) + hash_add_attr (hsh, method); + } +} + +static tree +objc_add_method (tree klass, tree method, int is_class, bool is_optional) +{ + tree existing_method = NULL_TREE; + + /* The first thing we do is look up the method in the list of + methods already defined in the interface (or implementation). */ + if (is_class) + existing_method = lookup_method (CLASS_CLS_METHODS (klass), method); + else + existing_method = lookup_method (CLASS_NST_METHODS (klass), method); + + /* In the case of protocols, we have a second list of methods to + consider, the list of optional ones. */ + if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE) + { + /* @required methods are added to the protocol's normal list. + @optional methods are added to the protocol's OPTIONAL lists. + Note that adding the methods to the optional lists disables + checking that the methods are implemented by classes + implementing the protocol, since these checks only use the + CLASS_CLS_METHODS and CLASS_NST_METHODS. */ + + /* First of all, if the method to add is @optional, and we found + it already existing as @required, emit an error. */ + if (is_optional && existing_method) + { + error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (existing_method)); + inform (DECL_SOURCE_LOCATION (existing_method), + "previous declaration of %<%c%E%> as %<@required%>", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (existing_method)); + } + + /* Now check the list of @optional methods if we didn't find the + method in the @required list. */ + if (!existing_method) + { + if (is_class) + existing_method = lookup_method (PROTOCOL_OPTIONAL_CLS_METHODS (klass), method); + else + existing_method = lookup_method (PROTOCOL_OPTIONAL_NST_METHODS (klass), method); + + if (!is_optional && existing_method) + { + error ("method %<%c%E%> declared %<@optional%> and %<@required%> at the same time", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (existing_method)); + inform (DECL_SOURCE_LOCATION (existing_method), + "previous declaration of %<%c%E%> as %<@optional%>", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (existing_method)); + } + } + } + + /* If the method didn't exist already, add it. */ + if (!existing_method) + { + if (is_optional) + { + if (is_class) + { + /* Put the method on the list in reverse order. */ + TREE_CHAIN (method) = PROTOCOL_OPTIONAL_CLS_METHODS (klass); + PROTOCOL_OPTIONAL_CLS_METHODS (klass) = method; + } + else + { + TREE_CHAIN (method) = PROTOCOL_OPTIONAL_NST_METHODS (klass); + PROTOCOL_OPTIONAL_NST_METHODS (klass) = method; + } + } + else + { + if (is_class) + { + DECL_CHAIN (method) = CLASS_CLS_METHODS (klass); + CLASS_CLS_METHODS (klass) = method; + } + else + { + DECL_CHAIN (method) = CLASS_NST_METHODS (klass); + CLASS_NST_METHODS (klass) = method; + } + } + } + else + { + /* The method was already defined. Check that the types match + for an @interface for a class or category, or for a + @protocol. Give hard errors on methods with identical + selectors but differing argument and/or return types. We do + not do this for @implementations, because C/C++ will do it + for us (i.e., there will be duplicate function definition + errors). */ + if ((TREE_CODE (klass) == CLASS_INTERFACE_TYPE + || TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE + /* Starting with GCC 4.6, we emit the same error for + protocols too. The situation is identical to + @interfaces as there is no possible meaningful reason + for defining the same method with different signatures + in the very same @protocol. If that was allowed, + whenever the protocol is used (both at compile and run + time) there wouldn't be any meaningful way to decide + which of the two method signatures should be used. */ + || TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE) + && !comp_proto_with_proto (method, existing_method, 1)) + { + error ("duplicate declaration of method %<%c%E%> with conflicting types", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (existing_method)); + inform (DECL_SOURCE_LOCATION (existing_method), + "previous declaration of %<%c%E%>", + (is_class ? '+' : '-'), + METHOD_SEL_NAME (existing_method)); + } + } + + if (is_class) + add_method_to_hash_list (cls_method_hash_list, method); + else + { + add_method_to_hash_list (nst_method_hash_list, method); + + /* Instance methods in root classes (and categories thereof) + may act as class methods as a last resort. We also add + instance methods listed in @protocol declarations to + the class hash table, on the assumption that @protocols + may be adopted by root classes or categories. */ + if (TREE_CODE (klass) == CATEGORY_INTERFACE_TYPE + || TREE_CODE (klass) == CATEGORY_IMPLEMENTATION_TYPE) + klass = lookup_interface (CLASS_NAME (klass)); + + if (TREE_CODE (klass) == PROTOCOL_INTERFACE_TYPE + || !CLASS_SUPER_NAME (klass)) + add_method_to_hash_list (cls_method_hash_list, method); + } + + return method; +} + +static tree +add_class (tree class_name, tree name) +{ + struct interface_tuple **slot; + + /* Put interfaces on list in reverse order. */ + TREE_CHAIN (class_name) = interface_chain; + interface_chain = class_name; + + if (interface_htab == NULL) + interface_htab = htab_create_ggc (31, hash_interface, eq_interface, NULL); + slot = (struct interface_tuple **) + htab_find_slot_with_hash (interface_htab, name, + IDENTIFIER_HASH_VALUE (name), + INSERT); + if (!*slot) + { + *slot = ggc_alloc_cleared_interface_tuple (); + (*slot)->id = name; + } + (*slot)->class_name = class_name; + + return interface_chain; +} + +static void +add_category (tree klass, tree category) +{ + /* Put categories on list in reverse order. */ + tree cat = lookup_category (klass, CLASS_SUPER_NAME (category)); + + if (cat) + { + warning (0, "duplicate interface declaration for category %<%E(%E)%>", + CLASS_NAME (klass), + CLASS_SUPER_NAME (category)); + } + else + { + CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (klass); + CLASS_CATEGORY_LIST (klass) = category; + } +} + +#ifndef OBJCPLUS +/* A flexible array member is a C99 extension where you can use + "type[]" at the end of a struct to mean a variable-length array. + + In Objective-C, instance variables are fundamentally members of a + struct, but the struct can always be extended by subclassing; hence + we need to detect and forbid all instance variables declared using + flexible array members. + + No check for this is needed in Objective-C++, since C++ does not + have flexible array members. */ + +/* Determine whether TYPE is a structure with a flexible array member, + a union containing such a structure (possibly recursively) or an + array of such structures or unions. These are all invalid as + instance variable. */ +static bool +flexible_array_type_p (tree type) +{ + tree x; + switch (TREE_CODE (type)) + { + case RECORD_TYPE: + x = TYPE_FIELDS (type); + if (x == NULL_TREE) + return false; + while (DECL_CHAIN (x) != NULL_TREE) + x = DECL_CHAIN (x); + if (TREE_CODE (TREE_TYPE (x)) == ARRAY_TYPE + && TYPE_SIZE (TREE_TYPE (x)) == NULL_TREE + && TYPE_DOMAIN (TREE_TYPE (x)) != NULL_TREE + && TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (x))) == NULL_TREE) + return true; + return false; + case UNION_TYPE: + for (x = TYPE_FIELDS (type); x != NULL_TREE; x = DECL_CHAIN (x)) + { + if (flexible_array_type_p (TREE_TYPE (x))) + return true; + } + return false; + /* Note that we also check for arrays of something that uses a flexible array member. */ + case ARRAY_TYPE: + if (flexible_array_type_p (TREE_TYPE (type))) + return true; + return false; + default: + return false; + } +} +#endif + +/* Called after parsing each instance variable declaration. Necessary to + preserve typedefs and implement public/private... + + VISIBILITY is 1 for public, 0 for protected, and 2 for private. */ + +static tree +add_instance_variable (tree klass, objc_ivar_visibility_kind visibility, + tree field_decl) +{ + tree field_type = TREE_TYPE (field_decl); + const char *ivar_name = DECL_NAME (field_decl) + ? identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl))) + : _(""); + +#ifdef OBJCPLUS + if (TREE_CODE (field_type) == REFERENCE_TYPE) + { + error ("illegal reference type specified for instance variable %qs", + ivar_name); + /* Return class as is without adding this ivar. */ + return klass; + } +#endif + + if (field_type == error_mark_node || !TYPE_SIZE (field_type) + || TYPE_SIZE (field_type) == error_mark_node) + /* 'type[0]' is allowed, but 'type[]' is not! */ + { + error ("instance variable %qs has unknown size", ivar_name); + /* Return class as is without adding this ivar. */ + return klass; + } + +#ifndef OBJCPLUS + /* Also, in C reject a struct with a flexible array member. Ie, + + struct A { int x; int[] y; }; + + @interface X + { + struct A instance_variable; + } + @end + + is not valid because if the class is subclassed, we wouldn't be able + to calculate the offset of the next instance variable. */ + if (flexible_array_type_p (field_type)) + { + error ("instance variable %qs uses flexible array member", ivar_name); + /* Return class as is without adding this ivar. */ + return klass; + } +#endif + +#ifdef OBJCPLUS + /* Check if the ivar being added has a non-POD C++ type. If so, we will + need to either (1) warn the user about it or (2) generate suitable + constructor/destructor call from '- .cxx_construct' or '- .cxx_destruct' + methods (if '-fobjc-call-cxx-cdtors' was specified). */ + if (MAYBE_CLASS_TYPE_P (field_type) + && (TYPE_NEEDS_CONSTRUCTING (field_type) + || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type) + || TYPE_POLYMORPHIC_P (field_type))) + { + tree type_name = OBJC_TYPE_NAME (field_type); + + if (flag_objc_call_cxx_cdtors) + { + /* Since the ObjC runtime will be calling the constructors and + destructors for us, the only thing we can't handle is the lack + of a default constructor. */ + if (TYPE_NEEDS_CONSTRUCTING (field_type) + && !TYPE_HAS_DEFAULT_CONSTRUCTOR (field_type)) + { + warning (0, "type %qE has no default constructor to call", + type_name); + + /* If we cannot call a constructor, we should also avoid + calling the destructor, for symmetry. */ + if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)) + warning (0, "destructor for %qE shall not be run either", + type_name); + } + } + else + { + static bool warn_cxx_ivars = false; + + if (TYPE_POLYMORPHIC_P (field_type)) + { + /* Vtable pointers are Real Bad(tm), since Obj-C cannot + initialize them. */ + error ("type %qE has virtual member functions", type_name); + error ("illegal aggregate type %qE specified " + "for instance variable %qs", + type_name, ivar_name); + /* Return class as is without adding this ivar. */ + return klass; + } + + /* User-defined constructors and destructors are not known to Obj-C + and hence will not be called. This may or may not be a problem. */ + if (TYPE_NEEDS_CONSTRUCTING (field_type)) + warning (0, "type %qE has a user-defined constructor", type_name); + if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)) + warning (0, "type %qE has a user-defined destructor", type_name); + + if (!warn_cxx_ivars) + { + warning (0, "C++ constructors and destructors will not " + "be invoked for Objective-C fields"); + warn_cxx_ivars = true; + } + } + } +#endif + + /* Overload the public attribute, it is not used for FIELD_DECLs. */ + switch (visibility) + { + case OBJC_IVAR_VIS_PROTECTED: + TREE_PUBLIC (field_decl) = 0; + TREE_PRIVATE (field_decl) = 0; + TREE_PROTECTED (field_decl) = 1; + break; + + case OBJC_IVAR_VIS_PACKAGE: + /* TODO: Implement the package variant. */ + case OBJC_IVAR_VIS_PUBLIC: + TREE_PUBLIC (field_decl) = 1; + TREE_PRIVATE (field_decl) = 0; + TREE_PROTECTED (field_decl) = 0; + break; + + case OBJC_IVAR_VIS_PRIVATE: + TREE_PUBLIC (field_decl) = 0; + TREE_PRIVATE (field_decl) = 1; + TREE_PROTECTED (field_decl) = 0; + break; + + } + + CLASS_RAW_IVARS (klass) = chainon (CLASS_RAW_IVARS (klass), field_decl); + + return klass; +} + +/* True if the ivar is private and we are not in its implementation. */ + +static int +is_private (tree decl) +{ + return (TREE_PRIVATE (decl) + && ! is_ivar (CLASS_IVARS (implementation_template), + DECL_NAME (decl))); +} + +/* We have an instance variable reference;, check to see if it is public. */ + +int +objc_is_public (tree expr, tree identifier) +{ + tree basetype, decl; + +#ifdef OBJCPLUS + if (processing_template_decl) + return 1; +#endif + + if (TREE_TYPE (expr) == error_mark_node) + return 1; + + basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); + + if (basetype && TREE_CODE (basetype) == RECORD_TYPE) + { + if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype)) + { + tree klass = lookup_interface (OBJC_TYPE_NAME (basetype)); + + if (!klass) + { + error ("cannot find interface declaration for %qE", + OBJC_TYPE_NAME (basetype)); + return 0; + } + + if ((decl = is_ivar (get_class_ivars (klass, true), identifier))) + { + if (TREE_PUBLIC (decl)) + return 1; + + /* Important difference between the Stepstone translator: + all instance variables should be public within the context + of the implementation. */ + if (objc_implementation_context + && ((TREE_CODE (objc_implementation_context) + == CLASS_IMPLEMENTATION_TYPE) + || (TREE_CODE (objc_implementation_context) + == CATEGORY_IMPLEMENTATION_TYPE))) + { + tree curtype = TYPE_MAIN_VARIANT + (CLASS_STATIC_TEMPLATE + (implementation_template)); + + if (basetype == curtype + || DERIVED_FROM_P (basetype, curtype)) + { + int priv = is_private (decl); + + if (priv) + error ("instance variable %qE is declared private", + DECL_NAME (decl)); + + return !priv; + } + } + + /* The 2.95.2 compiler sometimes allowed C functions to access + non-@public ivars. We will let this slide for now... */ + if (!objc_method_context) + { + warning (0, "instance variable %qE is %s; " + "this will be a hard error in the future", + identifier, + TREE_PRIVATE (decl) ? "@private" : "@protected"); + return 1; + } + + error ("instance variable %qE is declared %s", + identifier, + TREE_PRIVATE (decl) ? "private" : "protected"); + return 0; + } + } + } + + return 1; +} + +/* Make sure all methods in CHAIN (a list of method declarations from + an @interface or a @protocol) are in IMPLEMENTATION (the + implementation context). This is used to check for example that + all methods declared in an @interface were implemented in an + @implementation. + + Some special methods (property setters/getters) are special and if + they are not found in IMPLEMENTATION, we look them up in its + superclasses. */ + +static int +check_methods (tree chain, tree implementation, int mtype) +{ + int first = 1; + tree list; + + if (mtype == (int)'+') + list = CLASS_CLS_METHODS (implementation); + else + list = CLASS_NST_METHODS (implementation); + + while (chain) + { + /* If the method is associated with a dynamic property, then it + is Ok not to have the method implementation, as it will be + generated dynamically at runtime. To decide if the method is + associated with a @dynamic property, we search the list of + @synthesize and @dynamic for this implementation, and look + for any @dynamic property with the same setter or getter name + as this method. */ + tree x; + for (x = IMPL_PROPERTY_DECL (implementation); x; x = TREE_CHAIN (x)) + if (PROPERTY_DYNAMIC (x) + && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain) + || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain))) + break; + + if (x != NULL_TREE) + { + chain = TREE_CHAIN (chain); /* next method... */ + continue; + } + + if (!lookup_method (list, chain)) + { + /* If the method is a property setter/getter, we'll still + allow it to be missing if it is implemented by + 'interface' or any of its superclasses. */ + tree property = METHOD_PROPERTY_CONTEXT (chain); + if (property) + { + /* Note that since this is a property getter/setter, it + is obviously an instance method. */ + tree interface = NULL_TREE; + + /* For a category, first check the main class + @interface. */ + if (TREE_CODE (implementation) == CATEGORY_IMPLEMENTATION_TYPE) + { + interface = lookup_interface (CLASS_NAME (implementation)); + + /* If the method is found in the main class, it's Ok. */ + if (lookup_method (CLASS_NST_METHODS (interface), chain)) + { + chain = DECL_CHAIN (chain); + continue; + } + + /* Else, get the superclass. */ + if (CLASS_SUPER_NAME (interface)) + interface = lookup_interface (CLASS_SUPER_NAME (interface)); + else + interface = NULL_TREE; + } + + /* Get the superclass for classes. */ + if (TREE_CODE (implementation) == CLASS_IMPLEMENTATION_TYPE) + { + if (CLASS_SUPER_NAME (implementation)) + interface = lookup_interface (CLASS_SUPER_NAME (implementation)); + else + interface = NULL_TREE; + } + + /* Now, interface is the superclass, if any; go check it. */ + if (interface) + { + if (lookup_method_static (interface, chain, 0)) + { + chain = DECL_CHAIN (chain); + continue; + } + } + /* Else, fall through - warn. */ + } + if (first) + { + switch (TREE_CODE (implementation)) + { + case CLASS_IMPLEMENTATION_TYPE: + warning (0, "incomplete implementation of class %qE", + CLASS_NAME (implementation)); + break; + case CATEGORY_IMPLEMENTATION_TYPE: + warning (0, "incomplete implementation of category %qE", + CLASS_SUPER_NAME (implementation)); + break; + default: + gcc_unreachable (); + } + first = 0; + } + + warning (0, "method definition for %<%c%E%> not found", + mtype, METHOD_SEL_NAME (chain)); + } + + chain = DECL_CHAIN (chain); + } + + return first; +} + +/* Check if KLASS, or its superclasses, explicitly conforms to PROTOCOL. */ + +static int +conforms_to_protocol (tree klass, tree protocol) +{ + if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE) + { + tree p = CLASS_PROTOCOL_LIST (klass); + while (p && TREE_VALUE (p) != protocol) + p = TREE_CHAIN (p); + + if (!p) + { + tree super = (CLASS_SUPER_NAME (klass) + ? lookup_interface (CLASS_SUPER_NAME (klass)) + : NULL_TREE); + int tmp = super ? conforms_to_protocol (super, protocol) : 0; + if (!tmp) + return 0; + } + } + + return 1; +} + +/* Make sure all methods in CHAIN are accessible as MTYPE methods in + CONTEXT. This is one of two mechanisms to check protocol integrity. */ + +static int +check_methods_accessible (tree chain, tree context, int mtype) +{ + int first = 1; + tree list; + tree base_context = context; + + while (chain) + { + /* If the method is associated with a dynamic property, then it + is Ok not to have the method implementation, as it will be + generated dynamically at runtime. Search for any @dynamic + property with the same setter or getter name as this + method. TODO: Use a hashtable lookup. */ + tree x; + for (x = IMPL_PROPERTY_DECL (base_context); x; x = TREE_CHAIN (x)) + if (PROPERTY_DYNAMIC (x) + && (PROPERTY_GETTER_NAME (x) == METHOD_SEL_NAME (chain) + || PROPERTY_SETTER_NAME (x) == METHOD_SEL_NAME (chain))) + break; + + if (x != NULL_TREE) + { + chain = TREE_CHAIN (chain); /* next method... */ + continue; + } + + context = base_context; + while (context) + { + if (mtype == '+') + list = CLASS_CLS_METHODS (context); + else + list = CLASS_NST_METHODS (context); + + if (lookup_method (list, chain)) + break; + + switch (TREE_CODE (context)) + { + case CLASS_IMPLEMENTATION_TYPE: + case CLASS_INTERFACE_TYPE: + context = (CLASS_SUPER_NAME (context) + ? lookup_interface (CLASS_SUPER_NAME (context)) + : NULL_TREE); + break; + case CATEGORY_IMPLEMENTATION_TYPE: + case CATEGORY_INTERFACE_TYPE: + context = (CLASS_NAME (context) + ? lookup_interface (CLASS_NAME (context)) + : NULL_TREE); + break; + default: + gcc_unreachable (); + } + } + + if (context == NULL_TREE) + { + if (first) + { + switch (TREE_CODE (objc_implementation_context)) + { + case CLASS_IMPLEMENTATION_TYPE: + warning (0, "incomplete implementation of class %qE", + CLASS_NAME (objc_implementation_context)); + break; + case CATEGORY_IMPLEMENTATION_TYPE: + warning (0, "incomplete implementation of category %qE", + CLASS_SUPER_NAME (objc_implementation_context)); + break; + default: + gcc_unreachable (); + } + first = 0; + } + warning (0, "method definition for %<%c%E%> not found", + mtype, METHOD_SEL_NAME (chain)); + } + + chain = TREE_CHAIN (chain); /* next method... */ + } + return first; +} + +/* Check whether the current interface (accessible via + 'objc_implementation_context') actually implements protocol P, along + with any protocols that P inherits. */ + +static void +check_protocol (tree p, const char *type, tree name) +{ + if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE) + { + int f1, f2; + + /* Ensure that all protocols have bodies! */ + if (warn_protocol) + { + f1 = check_methods (PROTOCOL_CLS_METHODS (p), + objc_implementation_context, + '+'); + f2 = check_methods (PROTOCOL_NST_METHODS (p), + objc_implementation_context, + '-'); + } + else + { + f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p), + objc_implementation_context, + '+'); + f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p), + objc_implementation_context, + '-'); + } + + if (!f1 || !f2) + warning (0, "%s %qE does not fully implement the %qE protocol", + type, name, PROTOCOL_NAME (p)); + } + + /* Check protocols recursively. */ + if (PROTOCOL_LIST (p)) + { + tree subs = PROTOCOL_LIST (p); + tree super_class = + lookup_interface (CLASS_SUPER_NAME (implementation_template)); + + while (subs) + { + tree sub = TREE_VALUE (subs); + + /* If the superclass does not conform to the protocols + inherited by P, then we must! */ + if (!super_class || !conforms_to_protocol (super_class, sub)) + check_protocol (sub, type, name); + subs = TREE_CHAIN (subs); + } + } +} + +/* Check whether the current interface (accessible via + 'objc_implementation_context') actually implements the protocols listed + in PROTO_LIST. */ + +static void +check_protocols (tree proto_list, const char *type, tree name) +{ + for ( ; proto_list; proto_list = TREE_CHAIN (proto_list)) + { + tree p = TREE_VALUE (proto_list); + + check_protocol (p, type, name); + } +} + +/* Make sure that the class CLASS_NAME is defined CODE says which kind + of thing CLASS_NAME ought to be. It can be CLASS_INTERFACE_TYPE, + CLASS_IMPLEMENTATION_TYPE, CATEGORY_INTERFACE_TYPE, or + CATEGORY_IMPLEMENTATION_TYPE. For a CATEGORY_INTERFACE_TYPE, + SUPER_NAME is the name of the category. For a class extension, + CODE is CATEGORY_INTERFACE_TYPE and SUPER_NAME is NULL_TREE. */ +static tree +start_class (enum tree_code code, tree class_name, tree super_name, + tree protocol_list, tree attributes) +{ + tree klass = NULL_TREE; + tree decl; + +#ifdef OBJCPLUS + if (current_namespace != global_namespace) + { + error ("Objective-C declarations may only appear in global scope"); + } +#endif /* OBJCPLUS */ + + if (objc_implementation_context) + { + warning (0, "%<@end%> missing in implementation context"); + finish_class (objc_implementation_context); + objc_ivar_chain = NULL_TREE; + objc_implementation_context = NULL_TREE; + } + + /* If this is a class extension, we'll be "reopening" the existing + CLASS_INTERFACE_TYPE, so in that case there is no need to create + a new node. */ + if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE) + { + klass = make_node (code); + TYPE_LANG_SLOT_1 (klass) = make_tree_vec (CLASS_LANG_SLOT_ELTS); + } + + /* Check for existence of the super class, if one was specified. Note + that we must have seen an @interface, not just a @class. If we + are looking at a @compatibility_alias, traverse it first. */ + if ((code == CLASS_INTERFACE_TYPE || code == CLASS_IMPLEMENTATION_TYPE) + && super_name) + { + tree super = objc_is_class_name (super_name); + tree super_interface = NULL_TREE; + + if (super) + super_interface = lookup_interface (super); + + if (!super_interface) + { + error ("cannot find interface declaration for %qE, superclass of %qE", + super ? super : super_name, + class_name); + super_name = NULL_TREE; + } + else + { + if (TREE_DEPRECATED (super_interface)) + warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", + super); + super_name = super; + } + } + + if (code != CATEGORY_INTERFACE_TYPE || super_name != NULL_TREE) + { + CLASS_NAME (klass) = class_name; + CLASS_SUPER_NAME (klass) = super_name; + CLASS_CLS_METHODS (klass) = NULL_TREE; + } + + if (! objc_is_class_name (class_name) + && (decl = lookup_name (class_name))) + { + error ("%qE redeclared as different kind of symbol", + class_name); + error ("previous declaration of %q+D", + decl); + } + + switch (code) + { + case CLASS_IMPLEMENTATION_TYPE: + { + tree chain; + + for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain)) + if (TREE_VALUE (chain) == class_name) + { + error ("reimplementation of class %qE", + class_name); + /* TODO: error message saying where it was previously + implemented. */ + break; + } + if (chain == NULL_TREE) + implemented_classes = tree_cons (NULL_TREE, class_name, + implemented_classes); + } + + /* Reset for multiple classes per file. */ + method_slot = 0; + + objc_implementation_context = klass; + + /* Lookup the interface for this implementation. */ + + if (!(implementation_template = lookup_interface (class_name))) + { + warning (0, "cannot find interface declaration for %qE", + class_name); + add_class (implementation_template = objc_implementation_context, + class_name); + } + + /* If a super class has been specified in the implementation, + insure it conforms to the one specified in the interface. */ + + if (super_name + && (super_name != CLASS_SUPER_NAME (implementation_template))) + { + tree previous_name = CLASS_SUPER_NAME (implementation_template); + error ("conflicting super class name %qE", + super_name); + if (previous_name) + error ("previous declaration of %qE", previous_name); + else + error ("previous declaration"); + } + + else if (! super_name) + { + CLASS_SUPER_NAME (objc_implementation_context) + = CLASS_SUPER_NAME (implementation_template); + } + break; + + case CLASS_INTERFACE_TYPE: + if (lookup_interface (class_name)) +#ifdef OBJCPLUS + error ("duplicate interface declaration for class %qE", class_name); +#else + warning (0, "duplicate interface declaration for class %qE", class_name); +#endif + else + add_class (klass, class_name); + + if (protocol_list) + CLASS_PROTOCOL_LIST (klass) + = lookup_and_install_protocols (protocol_list, /* definition_required */ true); + + if (attributes) + { + tree attribute; + for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) + { + tree name = TREE_PURPOSE (attribute); + + /* TODO: Document what the objc_exception attribute is/does. */ + /* We handle the 'deprecated' and (undocumented) 'objc_exception' + attributes. */ + if (is_attribute_p ("deprecated", name)) + TREE_DEPRECATED (klass) = 1; + else if (is_attribute_p ("objc_exception", name)) + CLASS_HAS_EXCEPTION_ATTR (klass) = 1; + else + /* Warn about and ignore all others for now, but store them. */ + warning (OPT_Wattributes, "%qE attribute directive ignored", name); + } + TYPE_ATTRIBUTES (klass) = attributes; + } + break; + + case CATEGORY_INTERFACE_TYPE: + { + tree class_category_is_assoc_with; + + /* For a category, class_name is really the name of the class that + the following set of methods will be associated with. We must + find the interface so that can derive the objects template. */ + if (!(class_category_is_assoc_with = lookup_interface (class_name))) + { + error ("cannot find interface declaration for %qE", + class_name); + exit (FATAL_EXIT_CODE); + } + else + { + if (TREE_DEPRECATED (class_category_is_assoc_with)) + warning (OPT_Wdeprecated_declarations, "class %qE is deprecated", + class_name); + + if (super_name == NULL_TREE) + { + /* This is a class extension. Get the original + interface, and continue working on it. */ + objc_in_class_extension = true; + klass = class_category_is_assoc_with; + + if (protocol_list) + { + /* Append protocols to the original protocol + list. */ + CLASS_PROTOCOL_LIST (klass) + = chainon (CLASS_PROTOCOL_LIST (klass), + lookup_and_install_protocols + (protocol_list, + /* definition_required */ true)); + } + } + else + { + add_category (class_category_is_assoc_with, klass); + + if (protocol_list) + CLASS_PROTOCOL_LIST (klass) + = lookup_and_install_protocols + (protocol_list, /* definition_required */ true); + } + } + } + break; + + case CATEGORY_IMPLEMENTATION_TYPE: + /* Reset for multiple classes per file. */ + method_slot = 0; + + objc_implementation_context = klass; + + /* For a category, class_name is really the name of the class that + the following set of methods will be associated with. We must + find the interface so that can derive the objects template. */ + + if (!(implementation_template = lookup_interface (class_name))) + { + error ("cannot find interface declaration for %qE", + class_name); + exit (FATAL_EXIT_CODE); + } + break; + default: + gcc_unreachable (); + } + return klass; +} + +static tree +continue_class (tree klass) +{ + switch (TREE_CODE (klass)) + { + case CLASS_IMPLEMENTATION_TYPE: + case CATEGORY_IMPLEMENTATION_TYPE: + { + struct imp_entry *imp_entry; + + /* Check consistency of the instance variables. */ + + if (CLASS_RAW_IVARS (klass)) + check_ivars (implementation_template, klass); + + /* code generation */ +#ifdef OBJCPLUS + push_lang_context (lang_name_c); +#endif + build_private_template (implementation_template); + uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template); + objc_instance_type = build_pointer_type (uprivate_record); + + imp_entry = ggc_alloc_imp_entry (); + + imp_entry->next = imp_list; + imp_entry->imp_context = klass; + imp_entry->imp_template = implementation_template; + ucls_super_ref = uucls_super_ref = NULL; + if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE) + { + imp_entry->class_decl = (*runtime.class_decl) (klass); + imp_entry->meta_decl = (*runtime.metaclass_decl) (klass); + } + else + { + imp_entry->class_decl = (*runtime.category_decl) (klass); + imp_entry->meta_decl = NULL; + } + imp_entry->has_cxx_cdtors = 0; + + /* Append to front and increment count. */ + imp_list = imp_entry; + if (TREE_CODE (klass) == CLASS_IMPLEMENTATION_TYPE) + imp_count++; + else + cat_count++; +#ifdef OBJCPLUS + pop_lang_context (); +#endif /* OBJCPLUS */ + + return get_class_ivars (implementation_template, true); + break; + } + case CLASS_INTERFACE_TYPE: + { + if (objc_in_class_extension) + return NULL_TREE; +#ifdef OBJCPLUS + push_lang_context (lang_name_c); +#endif /* OBJCPLUS */ + objc_collecting_ivars = 1; + build_private_template (klass); + objc_collecting_ivars = 0; +#ifdef OBJCPLUS + pop_lang_context (); +#endif /* OBJCPLUS */ + return NULL_TREE; + break; + } + default: + return error_mark_node; + } +} + +/* This routine builds name of the setter synthesized function. */ +static char * +objc_build_property_setter_name (tree ident) +{ + /* TODO: Use alloca to allocate buffer of appropriate size. */ + static char string[BUFSIZE]; + sprintf (string, "set%s:", IDENTIFIER_POINTER (ident)); + string[3] = TOUPPER (string[3]); + return string; +} + +/* This routine prepares the declarations of the property accessor + helper functions (objc_getProperty(), etc) that are used when + @synthesize is used. + + runtime-specific routines are built in the respective runtime + initialize functions. */ +static void +build_common_objc_property_accessor_helpers (void) +{ + tree type; + + /* Declare the following function: + id + objc_getProperty (id self, SEL _cmd, + ptrdiff_t offset, BOOL is_atomic); */ + type = build_function_type_list (objc_object_type, + objc_object_type, + objc_selector_type, + ptrdiff_type_node, + boolean_type_node, + NULL_TREE); + objc_getProperty_decl = add_builtin_function ("objc_getProperty", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_getProperty_decl) = 0; + + /* Declare the following function: + void + objc_setProperty (id self, SEL _cmd, + ptrdiff_t offset, id new_value, + BOOL is_atomic, BOOL should_copy); */ + type = build_function_type_list (void_type_node, + objc_object_type, + objc_selector_type, + ptrdiff_type_node, + objc_object_type, + boolean_type_node, + boolean_type_node, + NULL_TREE); + objc_setProperty_decl = add_builtin_function ("objc_setProperty", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_setProperty_decl) = 0; +} + +/* This looks up an ivar in a class (including superclasses). */ +static tree +lookup_ivar (tree interface, tree instance_variable_name) +{ + while (interface) + { + tree decl_chain; + + for (decl_chain = CLASS_IVARS (interface); decl_chain; decl_chain = DECL_CHAIN (decl_chain)) + if (DECL_NAME (decl_chain) == instance_variable_name) + return decl_chain; + + /* Not found. Search superclass if any. */ + if (CLASS_SUPER_NAME (interface)) + interface = lookup_interface (CLASS_SUPER_NAME (interface)); + } + + return NULL_TREE; +} + +/* This routine synthesizes a 'getter' method. This is only called + for @synthesize properties. */ +static void +objc_synthesize_getter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property) +{ + location_t location = DECL_SOURCE_LOCATION (property); + tree fn, decl; + tree body; + tree ret_val; + + /* If user has implemented a getter with same name then do nothing. */ + if (lookup_method (CLASS_NST_METHODS (objc_implementation_context), + PROPERTY_GETTER_NAME (property))) + return; + + /* Find declaration of the property getter in the interface (or + superclass, or protocol). There must be one. */ + decl = lookup_method_static (klass, PROPERTY_GETTER_NAME (property), 0); + + /* If one not declared in the interface, this condition has already + been reported as user error (because property was not declared in + the interface). */ + if (!decl) + return; + + /* Adapt the 'decl'. Use the source location of the @synthesize + statement for error messages. */ + decl = copy_node (decl); + DECL_SOURCE_LOCATION (decl) = location; + + objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE); + body = c_begin_compound_stmt (true); + + /* Now we need to decide how we build the getter. There are three + cases: + + for 'copy' or 'retain' properties we need to use the + objc_getProperty() accessor helper which knows about retain and + copy. It supports both 'nonatomic' and 'atomic' access. + + for 'nonatomic, assign' properties we can access the instance + variable directly. 'nonatomic' means we don't have to use locks, + and 'assign' means we don't have to worry about retain or copy. + If you combine the two, it means we can just access the instance + variable directly. + + for 'atomic, assign' properties we use objc_copyStruct() (for the + next runtime) or objc_getPropertyStruct() (for the GNU runtime). */ + switch (PROPERTY_ASSIGN_SEMANTICS (property)) + { + case OBJC_PROPERTY_RETAIN: + case OBJC_PROPERTY_COPY: + { + /* We build "return objc_getProperty (self, _cmd, offset, is_atomic);" */ + tree cmd, ivar, offset, is_atomic; + cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)); + + /* Find the ivar to compute the offset. */ + ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property)); + if (!ivar || is_private (ivar)) + { + /* This should never happen. */ + error_at (location, + "can not find instance variable associated with property"); + ret_val = error_mark_node; + break; + } + offset = byte_position (ivar); + + if (PROPERTY_NONATOMIC (property)) + is_atomic = boolean_false_node; + else + is_atomic = boolean_true_node; + + ret_val = build_function_call + (location, + /* Function prototype. */ + objc_getProperty_decl, + /* Parameters. */ + tree_cons /* self */ + (NULL_TREE, self_decl, + tree_cons /* _cmd */ + (NULL_TREE, cmd, + tree_cons /* offset */ + (NULL_TREE, offset, + tree_cons /* is_atomic */ + (NULL_TREE, is_atomic, NULL_TREE))))); + } + break; + case OBJC_PROPERTY_ASSIGN: + if (PROPERTY_NONATOMIC (property)) + { + /* We build "return self->PROPERTY_IVAR_NAME;" */ + ret_val = objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property)); + break; + } + else + { + /* We build + __objc_property_temp; + objc_getPropertyStruct (&__objc_property_temp, + &(self->PROPERTY_IVAR_NAME), + sizeof (type of self->PROPERTY_IVAR_NAME), + is_atomic, + false) + return __objc_property_temp; + + For the NeXT runtime, we need to use objc_copyStruct + instead of objc_getPropertyStruct. */ + tree objc_property_temp_decl, function_decl, function_call; + tree size_of, is_atomic; + + objc_property_temp_decl = objc_create_temporary_var (TREE_TYPE (property), "__objc_property_temp"); + DECL_SOURCE_LOCATION (objc_property_temp_decl) = location; + objc_property_temp_decl = lang_hooks.decls.pushdecl (objc_property_temp_decl); + + /* sizeof (ivar type). Since the ivar and the property have + the same type, there is no need to lookup the ivar. */ + size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property), + true /* is_sizeof */, + false /* complain */); + + if (PROPERTY_NONATOMIC (property)) + is_atomic = boolean_false_node; + else + is_atomic = boolean_true_node; + + if (objc_copyStruct_decl) + function_decl = objc_copyStruct_decl; + else + function_decl = objc_getPropertyStruct_decl; + + function_call = build_function_call + (location, + /* Function prototype. */ + function_decl, + /* Parameters. */ + tree_cons /* &__objc_property_temp_decl */ + /* Warning: note that using build_fold_addr_expr_loc() + here causes invalid code to be generated. */ + (NULL_TREE, build_unary_op (location, ADDR_EXPR, objc_property_temp_decl, 0), + tree_cons /* &(self->PROPERTY_IVAR_NAME); */ + (NULL_TREE, build_fold_addr_expr_loc (location, + objc_lookup_ivar + (NULL_TREE, PROPERTY_IVAR_NAME (property))), + tree_cons /* sizeof (PROPERTY_IVAR) */ + (NULL_TREE, size_of, + tree_cons /* is_atomic */ + (NULL_TREE, is_atomic, + /* TODO: This is currently ignored by the GNU + runtime, but what about the next one ? */ + tree_cons /* has_strong */ + (NULL_TREE, boolean_true_node, NULL_TREE)))))); + + add_stmt (function_call); + + ret_val = objc_property_temp_decl; + } + break; + default: + gcc_unreachable (); + } + + gcc_assert (ret_val); + +#ifdef OBJCPLUS + finish_return_stmt (ret_val); +#else + c_finish_return (location, ret_val, NULL_TREE); +#endif + + add_stmt (c_end_compound_stmt (location, body, true)); + fn = current_function_decl; +#ifdef OBJCPLUS + finish_function (); +#endif + objc_finish_method_definition (fn); +} + +/* This routine synthesizes a 'setter' method. */ + +static void +objc_synthesize_setter (tree klass, tree class_methods ATTRIBUTE_UNUSED, tree property) +{ + location_t location = DECL_SOURCE_LOCATION (property); + tree fn, decl; + tree body; + tree new_value, statement; + + /* If user has implemented a setter with same name then do nothing. */ + if (lookup_method (CLASS_NST_METHODS (objc_implementation_context), + PROPERTY_SETTER_NAME (property))) + return; + + /* Find declaration of the property setter in the interface (or + superclass, or protocol). There must be one. */ + decl = lookup_method_static (klass, PROPERTY_SETTER_NAME (property), 0); + + /* If one not declared in the interface, this condition has already + been reported as user error (because property was not declared in + the interface). */ + if (!decl) + return; + + /* Adapt the 'decl'. Use the source location of the @synthesize + statement for error messages. */ + decl = copy_node (decl); + DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (property); + + objc_start_method_definition (false /* is_class_method */, decl, NULL_TREE); + + body = c_begin_compound_stmt (true); + + /* The 'new_value' is the only argument to the method, which is the + 3rd argument of the function, after self and _cmd. We use twice + TREE_CHAIN to move forward two arguments. */ + new_value = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl))); + + /* This would presumably happen if the user has specified a + prototype for the setter that does not have an argument! */ + if (new_value == NULL_TREE) + { + /* TODO: This should be caught much earlier than this. */ + error_at (DECL_SOURCE_LOCATION (decl), "invalid setter, it must have one argument"); + /* Try to recover somehow. */ + new_value = error_mark_node; + } + + /* Now we need to decide how we build the setter. There are three + cases: + + for 'copy' or 'retain' properties we need to use the + objc_setProperty() accessor helper which knows about retain and + copy. It supports both 'nonatomic' and 'atomic' access. + + for 'nonatomic, assign' properties we can access the instance + variable directly. 'nonatomic' means we don't have to use locks, + and 'assign' means we don't have to worry about retain or copy. + If you combine the two, it means we can just access the instance + variable directly. + + for 'atomic, assign' properties we use objc_copyStruct() (for the + next runtime) or objc_setPropertyStruct() (for the GNU runtime). */ + switch (PROPERTY_ASSIGN_SEMANTICS (property)) + { + case OBJC_PROPERTY_RETAIN: + case OBJC_PROPERTY_COPY: + { + /* We build "objc_setProperty (self, _cmd, new_value, offset, is_atomic, should_copy);" */ + tree cmd, ivar, offset, is_atomic, should_copy; + cmd = TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)); + + /* Find the ivar to compute the offset. */ + ivar = lookup_ivar (klass, PROPERTY_IVAR_NAME (property)); + if (!ivar || is_private (ivar)) + { + error_at (location, + "can not find instance variable associated with property"); + statement = error_mark_node; + break; + } + offset = byte_position (ivar); + + if (PROPERTY_NONATOMIC (property)) + is_atomic = boolean_false_node; + else + is_atomic = boolean_true_node; + + if (PROPERTY_ASSIGN_SEMANTICS (property) == OBJC_PROPERTY_COPY) + should_copy = boolean_true_node; + else + should_copy = boolean_false_node; + + statement = build_function_call + (location, + /* Function prototype. */ + objc_setProperty_decl, + /* Parameters. */ + tree_cons /* self */ + (NULL_TREE, self_decl, + tree_cons /* _cmd */ + (NULL_TREE, cmd, + tree_cons /* offset */ + (NULL_TREE, offset, + tree_cons /* new_value */ + (NULL_TREE, new_value, + tree_cons /* is_atomic */ + (NULL_TREE, is_atomic, + tree_cons /* should_copy */ + (NULL_TREE, should_copy, NULL_TREE))))))); + } + break; + case OBJC_PROPERTY_ASSIGN: + if (PROPERTY_NONATOMIC (property)) + { + /* We build "self->PROPERTY_IVAR_NAME = new_value;" */ + statement = build_modify_expr + (location, + objc_lookup_ivar (NULL_TREE, PROPERTY_IVAR_NAME (property)), + NULL_TREE, NOP_EXPR, + location, new_value, NULL_TREE); + break; + } + else + { + /* We build + objc_setPropertyStruct (&(self->PROPERTY_IVAR_NAME), + &new_value, + sizeof (type of self->PROPERTY_IVAR_NAME), + is_atomic, + false) + + For the NeXT runtime, we need to use objc_copyStruct + instead of objc_getPropertyStruct. */ + tree function_decl, size_of, is_atomic; + + /* sizeof (ivar type). Since the ivar and the property have + the same type, there is no need to lookup the ivar. */ + size_of = c_sizeof_or_alignof_type (location, TREE_TYPE (property), + true /* is_sizeof */, + false /* complain */); + + if (PROPERTY_NONATOMIC (property)) + is_atomic = boolean_false_node; + else + is_atomic = boolean_true_node; + + if (objc_copyStruct_decl) + function_decl = objc_copyStruct_decl; + else + function_decl = objc_setPropertyStruct_decl; + + statement = build_function_call + (location, + /* Function prototype. */ + function_decl, + /* Parameters. */ + tree_cons /* &(self->PROPERTY_IVAR_NAME); */ + (NULL_TREE, build_fold_addr_expr_loc (location, + objc_lookup_ivar + (NULL_TREE, PROPERTY_IVAR_NAME (property))), + tree_cons /* &new_value */ + (NULL_TREE, build_fold_addr_expr_loc (location, new_value), + tree_cons /* sizeof (PROPERTY_IVAR) */ + (NULL_TREE, size_of, + tree_cons /* is_atomic */ + (NULL_TREE, is_atomic, + /* TODO: This is currently ignored by the GNU + runtime, but what about the next one ? */ + tree_cons /* has_strong */ + (NULL_TREE, boolean_true_node, NULL_TREE)))))); + } + break; + default: + gcc_unreachable (); + } + gcc_assert (statement); + + add_stmt (statement); + add_stmt (c_end_compound_stmt (location, body, true)); + fn = current_function_decl; +#ifdef OBJCPLUS + finish_function (); +#endif + objc_finish_method_definition (fn); +} + +/* This function is a sub-routine of objc_add_synthesize_declaration. + It is called for each property to synthesize once we have + determined that the context is Ok. */ +static void +objc_add_synthesize_declaration_for_property (location_t location, tree interface, + tree property_name, tree ivar_name) +{ + /* Find the @property declaration. */ + tree property; + tree x; + + /* Check that synthesize or dynamic has not already been used for + the same property. */ + for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property)) + if (PROPERTY_NAME (property) == property_name) + { + location_t original_location = DECL_SOURCE_LOCATION (property); + + if (PROPERTY_DYNAMIC (property)) + error_at (location, "property %qs already specified in %<@dynamic%>", + IDENTIFIER_POINTER (property_name)); + else + error_at (location, "property %qs already specified in %<@synthesize%>", + IDENTIFIER_POINTER (property_name)); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + /* Check that the property is declared in the interface. It could + also be declared in a superclass or protocol. */ + property = lookup_property (interface, property_name); + + if (!property) + { + error_at (location, "no declaration of property %qs found in the interface", + IDENTIFIER_POINTER (property_name)); + return; + } + else + { + /* We have to copy the property, because we want to chain it to + the implementation context, and we want to store the source + location of the @synthesize, not of the original + @property. */ + property = copy_node (property); + DECL_SOURCE_LOCATION (property) = location; + } + + /* Determine PROPERTY_IVAR_NAME. */ + if (ivar_name == NULL_TREE) + ivar_name = property_name; + + /* Check that the instance variable exists. You can only use an + instance variable from the same class, not one from the + superclass (this makes sense as it allows us to check that an + instance variable is only used in one synthesized property). */ + { + tree ivar = is_ivar (CLASS_IVARS (interface), ivar_name); + tree type_of_ivar; + if (!ivar) + { + error_at (location, "ivar %qs used by %<@synthesize%> declaration must be an existing ivar", + IDENTIFIER_POINTER (property_name)); + return; + } + + if (DECL_BIT_FIELD_TYPE (ivar)) + type_of_ivar = DECL_BIT_FIELD_TYPE (ivar); + else + type_of_ivar = TREE_TYPE (ivar); + + /* If the instance variable has a different C type, we throw an error ... */ + if (!comptypes (TREE_TYPE (property), type_of_ivar) + /* ... unless the property is readonly, in which case we allow + the instance variable to be more specialized (this means we + can generate the getter all right and it works). */ + && (!PROPERTY_READONLY (property) + || !objc_compare_types (TREE_TYPE (property), + type_of_ivar, -5, NULL_TREE))) + { + location_t original_location = DECL_SOURCE_LOCATION (ivar); + + error_at (location, "property %qs is using instance variable %qs of incompatible type", + IDENTIFIER_POINTER (property_name), + IDENTIFIER_POINTER (ivar_name)); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + } + + /* If the instance variable is a bitfield, the property must be + 'assign', 'nonatomic' because the runtime getter/setter helper + do not work with bitfield instance variables. */ + if (DECL_BIT_FIELD_TYPE (ivar)) + { + /* If there is an error, we return and not generate any + getter/setter because trying to set up the runtime + getter/setter helper calls with bitfields is at high risk + of ICE. */ + + if (PROPERTY_ASSIGN_SEMANTICS (property) != OBJC_PROPERTY_ASSIGN) + { + location_t original_location = DECL_SOURCE_LOCATION (ivar); + + error_at (location, "'assign' property %qs is using bit-field instance variable %qs", + IDENTIFIER_POINTER (property_name), + IDENTIFIER_POINTER (ivar_name)); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + if (!PROPERTY_NONATOMIC (property)) + { + location_t original_location = DECL_SOURCE_LOCATION (ivar); + + error_at (location, "'atomic' property %qs is using bit-field instance variable %qs", + IDENTIFIER_POINTER (property_name), + IDENTIFIER_POINTER (ivar_name)); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + } + } + + /* Check that no other property is using the same instance + variable. */ + for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x)) + if (PROPERTY_IVAR_NAME (x) == ivar_name) + { + location_t original_location = DECL_SOURCE_LOCATION (x); + + error_at (location, "property %qs is using the same instance variable as property %qs", + IDENTIFIER_POINTER (property_name), + IDENTIFIER_POINTER (PROPERTY_NAME (x))); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + + /* We keep going on. This won't cause the compiler to fail; + the failure would most likely be at runtime. */ + } + + /* Note that a @synthesize (and only a @synthesize) always sets + PROPERTY_IVAR_NAME to a non-NULL_TREE. You can recognize a + @synthesize by that. */ + PROPERTY_IVAR_NAME (property) = ivar_name; + + /* PROPERTY_SETTER_NAME and PROPERTY_GETTER_NAME are copied from the + original declaration; they are always set (with the exception of + PROPERTY_SETTER_NAME not being set if PROPERTY_READONLY == 1). */ + + /* Add the property to the list of properties for current implementation. */ + TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context); + IMPL_PROPERTY_DECL (objc_implementation_context) = property; + + /* Note how we don't actually synthesize the getter/setter here; it + would be very natural, but we may miss the fact that the user has + implemented his own getter/setter later on in the @implementation + (in which case we shouldn't generate getter/setter). We wait + until we have parsed it all before generating the code. */ +} + +/* This function is called by the parser after a @synthesize + expression is parsed. 'location' is the location of the + @synthesize expression, and 'property_and_ivar_list' is a chained + list of the property and ivar names. */ +void +objc_add_synthesize_declaration (location_t location, tree property_and_ivar_list) +{ + tree interface, chain; + + if (flag_objc1_only) + error_at (input_location, "%<@synthesize%> is not available in Objective-C 1.0"); + + if (property_and_ivar_list == error_mark_node) + return; + + if (!objc_implementation_context) + { + /* We can get here only in Objective-C; the Objective-C++ parser + detects the problem while parsing, outputs the error + "misplaced '@synthesize' Objective-C++ construct" and skips + the declaration. */ + error_at (location, "%<@synthesize%> not in @implementation context"); + return; + } + + if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE) + { + error_at (location, "%<@synthesize%> can not be used in categories"); + return; + } + + interface = lookup_interface (CLASS_NAME (objc_implementation_context)); + if (!interface) + { + /* I can't see how this could happen, but it is good as a safety check. */ + error_at (location, + "%<@synthesize%> requires the @interface of the class to be available"); + return; + } + + /* Now, iterate over the properties and do each of them. */ + for (chain = property_and_ivar_list; chain; chain = TREE_CHAIN (chain)) + { + objc_add_synthesize_declaration_for_property (location, interface, TREE_VALUE (chain), + TREE_PURPOSE (chain)); + } +} + +/* This function is a sub-routine of objc_add_dynamic_declaration. It + is called for each property to mark as dynamic once we have + determined that the context is Ok. */ +static void +objc_add_dynamic_declaration_for_property (location_t location, tree interface, + tree property_name) +{ + /* Find the @property declaration. */ + tree property; + + /* Check that synthesize or dynamic has not already been used for + the same property. */ + for (property = IMPL_PROPERTY_DECL (objc_implementation_context); property; property = TREE_CHAIN (property)) + if (PROPERTY_NAME (property) == property_name) + { + location_t original_location = DECL_SOURCE_LOCATION (property); + + if (PROPERTY_DYNAMIC (property)) + error_at (location, "property %qs already specified in %<@dynamic%>", + IDENTIFIER_POINTER (property_name)); + else + error_at (location, "property %qs already specified in %<@synthesize%>", + IDENTIFIER_POINTER (property_name)); + + if (original_location != UNKNOWN_LOCATION) + inform (original_location, "originally specified here"); + return; + } + + /* Check that the property is declared in the interface. It could + also be declared in a superclass or protocol. */ + property = lookup_property (interface, property_name); + + if (!property) + { + error_at (location, "no declaration of property %qs found in the interface", + IDENTIFIER_POINTER (property_name)); + return; + } + else + { + /* We have to copy the property, because we want to chain it to + the implementation context, and we want to store the source + location of the @synthesize, not of the original + @property. */ + property = copy_node (property); + DECL_SOURCE_LOCATION (property) = location; + } + + /* Note that a @dynamic (and only a @dynamic) always sets + PROPERTY_DYNAMIC to 1. You can recognize a @dynamic by that. + (actually, as explained above, PROPERTY_DECL generated by + @property and associated with a @dynamic property are also marked + as PROPERTY_DYNAMIC). */ + PROPERTY_DYNAMIC (property) = 1; + + /* Add the property to the list of properties for current implementation. */ + TREE_CHAIN (property) = IMPL_PROPERTY_DECL (objc_implementation_context); + IMPL_PROPERTY_DECL (objc_implementation_context) = property; +} + +/* This function is called by the parser after a @dynamic expression + is parsed. 'location' is the location of the @dynamic expression, + and 'property_list' is a chained list of all the property + names. */ +void +objc_add_dynamic_declaration (location_t location, tree property_list) +{ + tree interface, chain; + + if (flag_objc1_only) + error_at (input_location, "%<@dynamic%> is not available in Objective-C 1.0"); + + if (property_list == error_mark_node) + return; + + if (!objc_implementation_context) + { + /* We can get here only in Objective-C; the Objective-C++ parser + detects the problem while parsing, outputs the error + "misplaced '@dynamic' Objective-C++ construct" and skips the + declaration. */ + error_at (location, "%<@dynamic%> not in @implementation context"); + return; + } + + /* @dynamic is allowed in categories. */ + switch (TREE_CODE (objc_implementation_context)) + { + case CLASS_IMPLEMENTATION_TYPE: + interface = lookup_interface (CLASS_NAME (objc_implementation_context)); + break; + case CATEGORY_IMPLEMENTATION_TYPE: + interface = lookup_category (implementation_template, + CLASS_SUPER_NAME (objc_implementation_context)); + break; + default: + gcc_unreachable (); + } + + if (!interface) + { + /* I can't see how this could happen, but it is good as a safety check. */ + error_at (location, + "%<@dynamic%> requires the @interface of the class to be available"); + return; + } + + /* Now, iterate over the properties and do each of them. */ + for (chain = property_list; chain; chain = TREE_CHAIN (chain)) + { + objc_add_dynamic_declaration_for_property (location, interface, TREE_VALUE (chain)); + } +} + +/* Main routine to generate code/data for all the property information for + current implementation (class or category). CLASS is the interface where + ivars are declared. CLASS_METHODS is where methods are found which + could be a class or a category depending on whether we are implementing + property of a class or a category. */ + +static void +objc_gen_property_data (tree klass, tree class_methods) +{ + tree x; + + for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x)) + { + /* @dynamic property - nothing to check or synthesize. */ + if (PROPERTY_DYNAMIC (x)) + continue; + + /* @synthesize property - need to synthesize the accessors. */ + if (PROPERTY_IVAR_NAME (x)) + { + objc_synthesize_getter (klass, class_methods, x); + + if (PROPERTY_READONLY (x) == 0) + objc_synthesize_setter (klass, class_methods, x); + + continue; + } + + gcc_unreachable (); + } +} + +/* This is called once we see the "@end" in an interface/implementation. */ + +static void +finish_class (tree klass) +{ + switch (TREE_CODE (klass)) + { + case CLASS_IMPLEMENTATION_TYPE: + { + /* All metadata generation is done in runtime.generate_metadata(). */ + + /* Generate what needed for property; setters, getters, etc. */ + objc_gen_property_data (implementation_template, implementation_template); + + if (implementation_template != objc_implementation_context) + { + /* Ensure that all method listed in the interface contain bodies. */ + check_methods (CLASS_CLS_METHODS (implementation_template), + objc_implementation_context, '+'); + check_methods (CLASS_NST_METHODS (implementation_template), + objc_implementation_context, '-'); + + if (CLASS_PROTOCOL_LIST (implementation_template)) + check_protocols (CLASS_PROTOCOL_LIST (implementation_template), + "class", + CLASS_NAME (objc_implementation_context)); + } + break; + } + case CATEGORY_IMPLEMENTATION_TYPE: + { + tree category = lookup_category (implementation_template, CLASS_SUPER_NAME (klass)); + + if (category) + { + /* Generate what needed for property; setters, getters, etc. */ + objc_gen_property_data (implementation_template, category); + + /* Ensure all method listed in the interface contain bodies. */ + check_methods (CLASS_CLS_METHODS (category), + objc_implementation_context, '+'); + check_methods (CLASS_NST_METHODS (category), + objc_implementation_context, '-'); + + if (CLASS_PROTOCOL_LIST (category)) + check_protocols (CLASS_PROTOCOL_LIST (category), + "category", + CLASS_SUPER_NAME (objc_implementation_context)); + } + break; + } + case CLASS_INTERFACE_TYPE: + case CATEGORY_INTERFACE_TYPE: + case PROTOCOL_INTERFACE_TYPE: + { + /* Process properties of the class. */ + tree x; + for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x)) + { + /* Now we check that the appropriate getter is declared, + and if not, we declare one ourselves. */ + tree getter_decl = lookup_method (CLASS_NST_METHODS (klass), + PROPERTY_GETTER_NAME (x)); + + if (getter_decl) + { + /* TODO: Check that the declaration is consistent with the property. */ + ; + } + else + { + /* Generate an instance method declaration for the + getter; for example "- (id) name;". In general it + will be of the form + -(type)property_getter_name; */ + tree rettype = build_tree_list (NULL_TREE, TREE_TYPE (x)); + getter_decl = build_method_decl (INSTANCE_METHOD_DECL, + rettype, PROPERTY_GETTER_NAME (x), + NULL_TREE, false); + if (PROPERTY_OPTIONAL (x)) + objc_add_method (objc_interface_context, getter_decl, false, true); + else + objc_add_method (objc_interface_context, getter_decl, false, false); + TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x); + METHOD_PROPERTY_CONTEXT (getter_decl) = x; + } + + if (PROPERTY_READONLY (x) == 0) + { + /* Now we check that the appropriate setter is declared, + and if not, we declare on ourselves. */ + tree setter_decl = lookup_method (CLASS_NST_METHODS (klass), + PROPERTY_SETTER_NAME (x)); + + if (setter_decl) + { + /* TODO: Check that the declaration is consistent with the property. */ + ; + } + else + { + /* The setter name is something like 'setName:'. + We need the substring 'setName' to build the + method declaration due to how the declaration + works. TODO: build_method_decl() will then + generate back 'setName:' from 'setName'; it + would be more efficient to hook into there. */ + const char *full_setter_name = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x)); + size_t length = strlen (full_setter_name); + char *setter_name = (char *) alloca (length); + tree ret_type, selector, arg_type, arg_name; + + strcpy (setter_name, full_setter_name); + setter_name[length - 1] = '\0'; + ret_type = build_tree_list (NULL_TREE, void_type_node); + arg_type = build_tree_list (NULL_TREE, TREE_TYPE (x)); + arg_name = get_identifier ("_value"); + selector = objc_build_keyword_decl (get_identifier (setter_name), + arg_type, arg_name, NULL); + setter_decl = build_method_decl (INSTANCE_METHOD_DECL, + ret_type, selector, + build_tree_list (NULL_TREE, NULL_TREE), + false); + if (PROPERTY_OPTIONAL (x)) + objc_add_method (objc_interface_context, setter_decl, false, true); + else + objc_add_method (objc_interface_context, setter_decl, false, false); + TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x); + METHOD_PROPERTY_CONTEXT (setter_decl) = x; + } + } + } + break; + } + default: + gcc_unreachable (); + break; + } +} + +static tree +add_protocol (tree protocol) +{ + /* Put protocol on list in reverse order. */ + TREE_CHAIN (protocol) = protocol_chain; + protocol_chain = protocol; + return protocol_chain; +} + +/* Check that a protocol is defined, and, recursively, that all + protocols that this protocol conforms to are defined too. */ +static void +check_that_protocol_is_defined (tree protocol) +{ + if (!PROTOCOL_DEFINED (protocol)) + warning (0, "definition of protocol %qE not found", + PROTOCOL_NAME (protocol)); + + /* If the protocol itself conforms to other protocols, check them + too, recursively. */ + if (PROTOCOL_LIST (protocol)) + { + tree p; + + for (p = PROTOCOL_LIST (protocol); p; p = TREE_CHAIN (p)) + check_that_protocol_is_defined (TREE_VALUE (p)); + } +} + +/* Looks up a protocol. If 'warn_if_deprecated' is true, a warning is + emitted if the protocol is deprecated. If 'definition_required' is + true, a warning is emitted if a full @protocol definition has not + been seen. */ +static tree +lookup_protocol (tree ident, bool warn_if_deprecated, bool definition_required) +{ + tree chain; + + for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain)) + if (ident == PROTOCOL_NAME (chain)) + { + if (warn_if_deprecated && TREE_DEPRECATED (chain)) + { + /* It would be nice to use warn_deprecated_use() here, but + we are using TREE_CHAIN (which is supposed to be the + TYPE_STUB_DECL for a TYPE) for something different. */ + warning (OPT_Wdeprecated_declarations, "protocol %qE is deprecated", + PROTOCOL_NAME (chain)); + } + + if (definition_required) + check_that_protocol_is_defined (chain); + + return chain; + } + + return NULL_TREE; +} + +/* This function forward declares the protocols named by NAMES. If + they are already declared or defined, the function has no effect. */ + +void +objc_declare_protocols (tree names, tree attributes) +{ + tree list; + bool deprecated = false; + +#ifdef OBJCPLUS + if (current_namespace != global_namespace) { + error ("Objective-C declarations may only appear in global scope"); + } +#endif /* OBJCPLUS */ + + /* Determine if 'deprecated', the only attribute we recognize for + protocols, was used. Ignore all other attributes. */ + if (attributes) + { + tree attribute; + for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) + { + tree name = TREE_PURPOSE (attribute); + + if (is_attribute_p ("deprecated", name)) + deprecated = true; + else + warning (OPT_Wattributes, "%qE attribute directive ignored", name); + } + } + + for (list = names; list; list = TREE_CHAIN (list)) + { + tree name = TREE_VALUE (list); + + if (lookup_protocol (name, /* warn if deprecated */ false, + /* definition_required */ false) == NULL_TREE) + { + tree protocol = make_node (PROTOCOL_INTERFACE_TYPE); + + TYPE_LANG_SLOT_1 (protocol) + = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS); + PROTOCOL_NAME (protocol) = name; + PROTOCOL_LIST (protocol) = NULL_TREE; + add_protocol (protocol); + PROTOCOL_DEFINED (protocol) = 0; + PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE; + + if (attributes) + { + TYPE_ATTRIBUTES (protocol) = attributes; + if (deprecated) + TREE_DEPRECATED (protocol) = 1; + } + } + } +} + +static tree +start_protocol (enum tree_code code, tree name, tree list, tree attributes) +{ + tree protocol; + bool deprecated = false; + +#ifdef OBJCPLUS + if (current_namespace != global_namespace) { + error ("Objective-C declarations may only appear in global scope"); + } +#endif /* OBJCPLUS */ + + /* Determine if 'deprecated', the only attribute we recognize for + protocols, was used. Ignore all other attributes. */ + if (attributes) + { + tree attribute; + for (attribute = attributes; attribute; attribute = TREE_CHAIN (attribute)) + { + tree name = TREE_PURPOSE (attribute); + + if (is_attribute_p ("deprecated", name)) + deprecated = true; + else + warning (OPT_Wattributes, "%qE attribute directive ignored", name); + } + } + + protocol = lookup_protocol (name, /* warn_if_deprecated */ false, + /* definition_required */ false); + + if (!protocol) + { + protocol = make_node (code); + TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS); + + PROTOCOL_NAME (protocol) = name; + PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false); + add_protocol (protocol); + PROTOCOL_DEFINED (protocol) = 1; + PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE; + + check_protocol_recursively (protocol, list); + } + else if (! PROTOCOL_DEFINED (protocol)) + { + PROTOCOL_DEFINED (protocol) = 1; + PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, /* definition_required */ false); + + check_protocol_recursively (protocol, list); + } + else + { + warning (0, "duplicate declaration for protocol %qE", + name); + } + + if (attributes) + { + TYPE_ATTRIBUTES (protocol) = attributes; + if (deprecated) + TREE_DEPRECATED (protocol) = 1; + } + + return protocol; +} + +/* Decay array and function parameters into pointers. */ + +static tree +objc_decay_parm_type (tree type) +{ + if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == FUNCTION_TYPE) + type = build_pointer_type (TREE_CODE (type) == ARRAY_TYPE + ? TREE_TYPE (type) + : type); + + return type; +} + +static GTY(()) tree objc_parmlist = NULL_TREE; + +/* Append PARM to a list of formal parameters of a method, making a necessary + array-to-pointer adjustment along the way. */ + +void +objc_push_parm (tree parm) +{ + tree type; + + if (TREE_TYPE (parm) == error_mark_node) + { + objc_parmlist = chainon (objc_parmlist, parm); + return; + } + + /* Decay arrays and functions into pointers. */ + type = objc_decay_parm_type (TREE_TYPE (parm)); + + /* If the parameter type has been decayed, a new PARM_DECL needs to be + built as well. */ + if (type != TREE_TYPE (parm)) + parm = build_decl (input_location, PARM_DECL, DECL_NAME (parm), type); + + DECL_ARG_TYPE (parm) + = lang_hooks.types.type_promotes_to (TREE_TYPE (parm)); + + /* Record constancy and volatility. */ + c_apply_type_quals_to_decl + ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0) + | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0) + | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm); + + objc_parmlist = chainon (objc_parmlist, parm); +} + +/* Retrieve the formal parameter list constructed via preceding calls to + objc_push_parm(). */ + +#ifdef OBJCPLUS +tree +objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED) +{ + tree parm_info = objc_parmlist; + objc_parmlist = NULL_TREE; + + return parm_info; +} +#else +struct c_arg_info * +objc_get_parm_info (int have_ellipsis) +{ + tree parm_info = objc_parmlist; + struct c_arg_info *arg_info; + /* The C front-end requires an elaborate song and dance at + this point. */ + push_scope (); + declare_parm_level (); + while (parm_info) + { + tree next = DECL_CHAIN (parm_info); + + DECL_CHAIN (parm_info) = NULL_TREE; + parm_info = pushdecl (parm_info); + finish_decl (parm_info, input_location, NULL_TREE, NULL_TREE, NULL_TREE); + parm_info = next; + } + arg_info = get_parm_info (have_ellipsis); + pop_scope (); + objc_parmlist = NULL_TREE; + return arg_info; +} +#endif + +/* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC + method definitions. In the case of instance methods, we can be more + specific as to the type of 'self'. */ + +static void +synth_self_and_ucmd_args (void) +{ + tree self_type; + + if (objc_method_context + && TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL) + self_type = objc_instance_type; + else + /* Really a `struct objc_class *'. However, we allow people to + assign to self, which changes its type midstream. */ + self_type = objc_object_type; + + /* id self; */ + objc_push_parm (build_decl (input_location, + PARM_DECL, self_id, self_type)); + + /* SEL _cmd; */ + objc_push_parm (build_decl (input_location, + PARM_DECL, ucmd_id, objc_selector_type)); +} + +/* Transform an Objective-C method definition into a static C function + definition, synthesizing the first two arguments, "self" and "_cmd", + in the process. */ + +static void +start_method_def (tree method) +{ + tree parmlist; +#ifdef OBJCPLUS + tree parm_info; +#else + struct c_arg_info *parm_info; +#endif + int have_ellipsis = 0; + + /* If we are defining a "dealloc" method in a non-root class, we + will need to check if a [super dealloc] is missing, and warn if + it is. */ + if(CLASS_SUPER_NAME (objc_implementation_context) + && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method)))) + should_call_super_dealloc = 1; + else + should_call_super_dealloc = 0; + + /* Required to implement _msgSuper. */ + objc_method_context = method; + UOBJC_SUPER_decl = NULL_TREE; + + /* Generate prototype declarations for arguments..."new-style". */ + synth_self_and_ucmd_args (); + + /* Generate argument declarations if a keyword_decl. */ + parmlist = METHOD_SEL_ARGS (method); + while (parmlist) + { + /* parmlist is a KEYWORD_DECL. */ + tree type = TREE_VALUE (TREE_TYPE (parmlist)); + tree parm; + + parm = build_decl (input_location, + PARM_DECL, KEYWORD_ARG_NAME (parmlist), type); + decl_attributes (&parm, DECL_ATTRIBUTES (parmlist), 0); + objc_push_parm (parm); + parmlist = DECL_CHAIN (parmlist); + } + + if (METHOD_ADD_ARGS (method)) + { + tree akey; + + for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method)); + akey; akey = TREE_CHAIN (akey)) + { + objc_push_parm (TREE_VALUE (akey)); + } + + if (METHOD_ADD_ARGS_ELLIPSIS_P (method)) + have_ellipsis = 1; + } + + parm_info = objc_get_parm_info (have_ellipsis); + + really_start_method (objc_method_context, parm_info); +} + +/* Return 1 if TYPE1 is equivalent to TYPE2 for purposes of method + overloading. */ +static int +objc_types_are_equivalent (tree type1, tree type2) +{ + if (type1 == type2) + return 1; + + /* Strip away indirections. */ + while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE) + && (TREE_CODE (type1) == TREE_CODE (type2))) + type1 = TREE_TYPE (type1), type2 = TREE_TYPE (type2); + if (TYPE_MAIN_VARIANT (type1) != TYPE_MAIN_VARIANT (type2)) + return 0; + + /* Compare the protocol lists. */ + type1 = (TYPE_HAS_OBJC_INFO (type1) + ? TYPE_OBJC_PROTOCOL_LIST (type1) + : NULL_TREE); + type2 = (TYPE_HAS_OBJC_INFO (type2) + ? TYPE_OBJC_PROTOCOL_LIST (type2) + : NULL_TREE); + + /* If there are no protocols (most common case), the types are + identical. */ + if (type1 == NULL_TREE && type2 == NULL_TREE) + return 1; + + /* If one has protocols, and the other one hasn't, they are not + identical. */ + if ((type1 == NULL_TREE && type2 != NULL_TREE) + || (type1 != NULL_TREE && type2 == NULL_TREE)) + return 0; + else + { + /* Else, both have protocols, and we need to do the full + comparison. It is possible that either type1 or type2 + contain some duplicate protocols in the list, so we can't + even just compare list_length as a first check. */ + tree t; + + for (t = type2; t; t = TREE_CHAIN (t)) + if (!lookup_protocol_in_reflist (type1, TREE_VALUE (t))) + return 0; + + for (t = type1; t; t = TREE_CHAIN (t)) + if (!lookup_protocol_in_reflist (type2, TREE_VALUE (t))) + return 0; + + return 1; + } +} + +/* Return 1 if TYPE1 has the same size and alignment as TYPE2. */ + +static int +objc_types_share_size_and_alignment (tree type1, tree type2) +{ + return (simple_cst_equal (TYPE_SIZE (type1), TYPE_SIZE (type2)) + && TYPE_ALIGN (type1) == TYPE_ALIGN (type2)); +} + +/* Return 1 if PROTO1 is equivalent to PROTO2 + for purposes of method overloading. Ordinarily, the type signatures + should match up exactly, unless STRICT is zero, in which case we + shall allow differences in which the size and alignment of a type + is the same. */ + +static int +comp_proto_with_proto (tree proto1, tree proto2, int strict) +{ + /* The following test is needed in case there are hashing + collisions. */ + if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2)) + return 0; + + return match_proto_with_proto (proto1, proto2, strict); +} + +static int +match_proto_with_proto (tree proto1, tree proto2, int strict) +{ + tree type1, type2; + + /* Compare return types. */ + type1 = TREE_VALUE (TREE_TYPE (proto1)); + type2 = TREE_VALUE (TREE_TYPE (proto2)); + + if (!objc_types_are_equivalent (type1, type2) + && (strict || !objc_types_share_size_and_alignment (type1, type2))) + return 0; + + /* Compare argument types. */ + for (type1 = get_arg_type_list (proto1, METHOD_REF, 0), + type2 = get_arg_type_list (proto2, METHOD_REF, 0); + type1 && type2; + type1 = TREE_CHAIN (type1), type2 = TREE_CHAIN (type2)) + { + if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2)) + && (strict + || !objc_types_share_size_and_alignment (TREE_VALUE (type1), + TREE_VALUE (type2)))) + return 0; + } + + return (!type1 && !type2); +} + +/* This routine returns true if TYPE is a valid objc object type, + suitable for messaging; false otherwise. If 'accept_class' is + 'true', then a Class object is considered valid for messaging and + 'true' is returned if 'type' refers to a Class. If 'accept_class' + is 'false', then a Class object is not considered valid for + messaging and 'false' is returned in that case. */ + +static bool +objc_type_valid_for_messaging (tree type, bool accept_classes) +{ + if (!POINTER_TYPE_P (type)) + return false; + + /* Remove the pointer indirection; don't remove more than one + otherwise we'd consider "NSObject **" a valid type for messaging, + which it isn't. */ + type = TREE_TYPE (type); + + if (TREE_CODE (type) != RECORD_TYPE) + return false; + + if (objc_is_object_id (type)) + return true; + + if (objc_is_class_id (type)) + return accept_classes; + + if (TYPE_HAS_OBJC_INFO (type)) + return true; + + return false; +} + +/* Fold an OBJ_TYPE_REF expression for ObjC method dispatches, where + this occurs. ObjC method dispatches are _not_ like C++ virtual + member function dispatches, and we account for the difference here. */ +tree +#ifdef OBJCPLUS +objc_fold_obj_type_ref (tree ref, tree known_type) +#else +objc_fold_obj_type_ref (tree ref ATTRIBUTE_UNUSED, + tree known_type ATTRIBUTE_UNUSED) +#endif +{ +#ifdef OBJCPLUS + tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type)); + + /* If the receiver does not have virtual member functions, there + is nothing we can (or need to) do here. */ + if (!v) + return NULL_TREE; + + /* Let C++ handle C++ virtual functions. */ + return cp_fold_obj_type_ref (ref, known_type); +#else + /* For plain ObjC, we currently do not need to do anything. */ + return NULL_TREE; +#endif +} + +void +objc_start_function (tree name, tree type, tree attrs, +#ifdef OBJCPLUS + tree params +#else + struct c_arg_info *params +#endif + ) +{ + tree fndecl = build_decl (input_location, + FUNCTION_DECL, name, type); + +#ifdef OBJCPLUS + DECL_ARGUMENTS (fndecl) = params; + DECL_INITIAL (fndecl) = error_mark_node; + DECL_EXTERNAL (fndecl) = 0; + TREE_STATIC (fndecl) = 1; + retrofit_lang_decl (fndecl); + cplus_decl_attributes (&fndecl, attrs, 0); + start_preparsed_function (fndecl, attrs, /*flags=*/SF_DEFAULT); +#else + current_function_returns_value = 0; /* Assume, until we see it does. */ + current_function_returns_null = 0; + decl_attributes (&fndecl, attrs, 0); + announce_function (fndecl); + DECL_INITIAL (fndecl) = error_mark_node; + DECL_EXTERNAL (fndecl) = 0; + TREE_STATIC (fndecl) = 1; + current_function_decl = pushdecl (fndecl); + push_scope (); + declare_parm_level (); + DECL_RESULT (current_function_decl) + = build_decl (input_location, + RESULT_DECL, NULL_TREE, + TREE_TYPE (TREE_TYPE (current_function_decl))); + DECL_ARTIFICIAL (DECL_RESULT (current_function_decl)) = 1; + DECL_IGNORED_P (DECL_RESULT (current_function_decl)) = 1; + start_fname_decls (); + store_parm_decls_from (params); +#endif + + TREE_USED (current_function_decl) = 1; +} + +/* - Generate an identifier for the function. the format is "_n_cls", + where 1 <= n <= nMethods, and cls is the name the implementation we + are processing. + - Install the return type from the method declaration. + - If we have a prototype, check for type consistency. */ + +static void +really_start_method (tree method, +#ifdef OBJCPLUS + tree parmlist +#else + struct c_arg_info *parmlist +#endif + ) +{ + tree ret_type, meth_type; + tree method_id; + const char *sel_name, *class_name, *cat_name; + char *buf; + + /* Synth the storage class & assemble the return type. */ + ret_type = TREE_VALUE (TREE_TYPE (method)); + + sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method)); + class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context)); + cat_name = ((TREE_CODE (objc_implementation_context) + == CLASS_IMPLEMENTATION_TYPE) + ? NULL + : IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context))); + method_slot++; + + /* Make sure this is big enough for any plausible method label. */ + buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name) + + (cat_name ? strlen (cat_name) : 0)); + + OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL, + class_name, cat_name, sel_name, method_slot); + + method_id = get_identifier (buf); + +#ifdef OBJCPLUS + /* Objective-C methods cannot be overloaded, so we don't need + the type encoding appended. It looks bad anyway... */ + push_lang_context (lang_name_c); +#endif + + meth_type + = build_function_type (ret_type, + get_arg_type_list (method, METHOD_DEF, 0)); + objc_start_function (method_id, meth_type, NULL_TREE, parmlist); + + /* Set self_decl from the first argument. */ + self_decl = DECL_ARGUMENTS (current_function_decl); + + /* Suppress unused warnings. */ + TREE_USED (self_decl) = 1; + DECL_READ_P (self_decl) = 1; + TREE_USED (DECL_CHAIN (self_decl)) = 1; + DECL_READ_P (DECL_CHAIN (self_decl)) = 1; +#ifdef OBJCPLUS + pop_lang_context (); +#endif + + METHOD_DEFINITION (method) = current_function_decl; + + /* Check consistency...start_function, pushdecl, duplicate_decls. */ + + if (implementation_template != objc_implementation_context) + { + tree proto + = lookup_method_static (implementation_template, + METHOD_SEL_NAME (method), + ((TREE_CODE (method) == CLASS_METHOD_DECL) + | OBJC_LOOKUP_NO_SUPER)); + + if (proto) + { + if (!comp_proto_with_proto (method, proto, 1)) + { + bool type = TREE_CODE (method) == INSTANCE_METHOD_DECL; + + warning_at (DECL_SOURCE_LOCATION (method), 0, + "conflicting types for %<%c%s%>", + (type ? '-' : '+'), + identifier_to_locale (gen_method_decl (method))); + inform (DECL_SOURCE_LOCATION (proto), + "previous declaration of %<%c%s%>", + (type ? '-' : '+'), + identifier_to_locale (gen_method_decl (proto))); + } + else + { + /* If the method in the @interface was deprecated, mark + the implemented method as deprecated too. It should + never be used for messaging (when the deprecation + warnings are produced), but just in case. */ + if (TREE_DEPRECATED (proto)) + TREE_DEPRECATED (method) = 1; + + /* If the method in the @interface was marked as + 'noreturn', mark the function implementing the method + as 'noreturn' too. */ + TREE_THIS_VOLATILE (current_function_decl) = TREE_THIS_VOLATILE (proto); + } + } + else + { + /* We have a method @implementation even though we did not + see a corresponding @interface declaration (which is allowed + by Objective-C rules). Go ahead and place the method in + the @interface anyway, so that message dispatch lookups + will see it. */ + tree interface = implementation_template; + + if (TREE_CODE (objc_implementation_context) + == CATEGORY_IMPLEMENTATION_TYPE) + interface = lookup_category + (interface, + CLASS_SUPER_NAME (objc_implementation_context)); + + if (interface) + objc_add_method (interface, copy_node (method), + TREE_CODE (method) == CLASS_METHOD_DECL, + /* is_optional= */ false); + } + } +} + +static void *UOBJC_SUPER_scope = 0; + +/* _n_Method (id self, SEL sel, ...) + { + struct objc_super _S; + _msgSuper ((_S.self = self, _S.class = _cls, &_S), ...); + } */ + +static tree +get_super_receiver (void) +{ + if (objc_method_context) + { + tree super_expr, super_expr_list, class_expr; + bool inst_meth; + if (!UOBJC_SUPER_decl) + { + UOBJC_SUPER_decl = build_decl (input_location, + VAR_DECL, get_identifier (TAG_SUPER), + objc_super_template); + /* This prevents `unused variable' warnings when compiling with -Wall. */ + TREE_USED (UOBJC_SUPER_decl) = 1; + DECL_READ_P (UOBJC_SUPER_decl) = 1; + lang_hooks.decls.pushdecl (UOBJC_SUPER_decl); + finish_decl (UOBJC_SUPER_decl, input_location, NULL_TREE, NULL_TREE, + NULL_TREE); + UOBJC_SUPER_scope = objc_get_current_scope (); + } + + /* Set receiver to self. */ + super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id); + super_expr = build_modify_expr (input_location, super_expr, NULL_TREE, + NOP_EXPR, input_location, self_decl, + NULL_TREE); + super_expr_list = super_expr; + + /* Set class to begin searching. */ + /* Get the ident for the superclass class field & build a ref to it. + ??? maybe we should just name the field the same for all runtimes. */ + super_expr = (*runtime.super_superclassfield_ident) (); + super_expr = objc_build_component_ref (UOBJC_SUPER_decl, super_expr); + + gcc_assert (imp_list->imp_context == objc_implementation_context + && imp_list->imp_template == implementation_template); + inst_meth = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL); + + if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE) + class_expr = (*runtime.get_class_super_ref) (input_location, + imp_list, inst_meth); + else + /* We have a category. */ + { + tree super_name = CLASS_SUPER_NAME (imp_list->imp_template); + tree super_class; + + /* Barf if super used in a category of a root object. */ + if (!super_name) + { + error ("no super class declared in interface for %qE", + CLASS_NAME (imp_list->imp_template)); + return error_mark_node; + } + + super_class = (*runtime.get_category_super_ref) (input_location, + imp_list, inst_meth); + class_expr = build_c_cast (input_location, + TREE_TYPE (super_expr), super_class); + } + + super_expr = build_modify_expr (input_location, super_expr, NULL_TREE, + NOP_EXPR, + input_location, class_expr, NULL_TREE); + + super_expr_list = build_compound_expr (input_location, + super_expr_list, super_expr); + + super_expr = build_unary_op (input_location, + ADDR_EXPR, UOBJC_SUPER_decl, 0); + super_expr_list = build_compound_expr (input_location, + super_expr_list, super_expr); + + return super_expr_list; + } + else + { + error ("[super ...] must appear in a method context"); + return error_mark_node; + } +} + +/* When exiting a scope, sever links to a 'super' declaration (if any) + therein contained. */ + +void +objc_clear_super_receiver (void) +{ + if (objc_method_context + && UOBJC_SUPER_scope == objc_get_current_scope ()) + { + UOBJC_SUPER_decl = 0; + UOBJC_SUPER_scope = 0; + } +} + +void +objc_finish_method_definition (tree fndecl) +{ + /* We cannot validly inline ObjC methods, at least not without a language + extension to declare that a method need not be dynamically + dispatched, so suppress all thoughts of doing so. */ + DECL_UNINLINABLE (fndecl) = 1; + +#ifndef OBJCPLUS + /* The C++ front-end will have called finish_function() for us. */ + finish_function (); +#endif + + METHOD_ENCODING (objc_method_context) + = encode_method_prototype (objc_method_context); + + /* Required to implement _msgSuper. This must be done AFTER finish_function, + since the optimizer may find "may be used before set" errors. */ + objc_method_context = NULL_TREE; + + if (should_call_super_dealloc) + warning (0, "method possibly missing a [super dealloc] call"); +} + +/* Given a tree DECL node, produce a printable description of it in the given + buffer, overwriting the buffer. */ + +static char * +gen_declaration (tree decl) +{ + errbuf[0] = '\0'; + + if (DECL_P (decl)) + { + gen_type_name_0 (TREE_TYPE (decl)); + + if (DECL_NAME (decl)) + { + if (!POINTER_TYPE_P (TREE_TYPE (decl))) + strcat (errbuf, " "); + + strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl))); + } + + if (DECL_INITIAL (decl) + && TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST) + sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC, + TREE_INT_CST_LOW (DECL_INITIAL (decl))); + } + + return errbuf; +} + +/* Given a tree TYPE node, produce a printable description of it in the given + buffer, overwriting the buffer. */ + +static char * +gen_type_name_0 (tree type) +{ + tree orig = type, proto; + + if (TYPE_P (type) && TYPE_NAME (type)) + type = TYPE_NAME (type); + else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE) + { + tree inner = TREE_TYPE (type); + + while (TREE_CODE (inner) == ARRAY_TYPE) + inner = TREE_TYPE (inner); + + gen_type_name_0 (inner); + + if (!POINTER_TYPE_P (inner)) + strcat (errbuf, " "); + + if (POINTER_TYPE_P (type)) + strcat (errbuf, "*"); + else + while (type != inner) + { + strcat (errbuf, "["); + + if (TYPE_DOMAIN (type)) + { + char sz[20]; + + sprintf (sz, HOST_WIDE_INT_PRINT_DEC, + (TREE_INT_CST_LOW + (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1)); + strcat (errbuf, sz); + } + + strcat (errbuf, "]"); + type = TREE_TYPE (type); + } + + goto exit_function; + } + + if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type)) + type = DECL_NAME (type); + + strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE + ? IDENTIFIER_POINTER (type) + : ""); + + /* For 'id' and 'Class', adopted protocols are stored in the pointee. */ + if (objc_is_id (orig)) + orig = TREE_TYPE (orig); + + proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE; + + if (proto) + { + strcat (errbuf, " <"); + + while (proto) { + strcat (errbuf, + IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto)))); + proto = TREE_CHAIN (proto); + strcat (errbuf, proto ? ", " : ">"); + } + } + + exit_function: + return errbuf; +} + +static char * +gen_type_name (tree type) +{ + errbuf[0] = '\0'; + + return gen_type_name_0 (type); +} + +/* Given a method tree, put a printable description into the given + buffer (overwriting) and return a pointer to the buffer. */ + +static char * +gen_method_decl (tree method) +{ + tree chain; + + strcpy (errbuf, "("); /* NB: Do _not_ call strcat() here. */ + gen_type_name_0 (TREE_VALUE (TREE_TYPE (method))); + strcat (errbuf, ")"); + chain = METHOD_SEL_ARGS (method); + + if (chain) + { + /* We have a chain of keyword_decls. */ + do + { + if (KEYWORD_KEY_NAME (chain)) + strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain))); + + strcat (errbuf, ":("); + gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain))); + strcat (errbuf, ")"); + + strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain))); + if ((chain = DECL_CHAIN (chain))) + strcat (errbuf, " "); + } + while (chain); + + if (METHOD_ADD_ARGS (method)) + { + chain = TREE_CHAIN (METHOD_ADD_ARGS (method)); + + /* Know we have a chain of parm_decls. */ + while (chain) + { + strcat (errbuf, ", "); + gen_type_name_0 (TREE_TYPE (TREE_VALUE (chain))); + chain = TREE_CHAIN (chain); + } + + if (METHOD_ADD_ARGS_ELLIPSIS_P (method)) + strcat (errbuf, ", ..."); + } + } + + else + /* We have a unary selector. */ + strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method))); + + return errbuf; +} + +/* Debug info. */ + + +/* Dump an @interface declaration of the supplied class CHAIN to the + supplied file FP. Used to implement the -gen-decls option (which + prints out an @interface declaration of all classes compiled in + this run); potentially useful for debugging the compiler too. */ +void +dump_interface (FILE *fp, tree chain) +{ + /* FIXME: A heap overflow here whenever a method (or ivar) + declaration is so long that it doesn't fit in the buffer. The + code and all the related functions should be rewritten to avoid + using fixed size buffers. */ + const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain)); + tree ivar_decls = CLASS_RAW_IVARS (chain); + tree nst_methods = CLASS_NST_METHODS (chain); + tree cls_methods = CLASS_CLS_METHODS (chain); + + fprintf (fp, "\n@interface %s", my_name); + + /* CLASS_SUPER_NAME is used to store the superclass name for + classes, and the category name for categories. */ + if (CLASS_SUPER_NAME (chain)) + { + const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain)); + + switch (TREE_CODE (chain)) + { + case CATEGORY_IMPLEMENTATION_TYPE: + case CATEGORY_INTERFACE_TYPE: + fprintf (fp, " (%s)\n", name); + break; + default: + fprintf (fp, " : %s\n", name); + break; + } + } + else + fprintf (fp, "\n"); + + /* FIXME - the following doesn't seem to work at the moment. */ + if (ivar_decls) + { + fprintf (fp, "{\n"); + do + { + fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls)); + ivar_decls = TREE_CHAIN (ivar_decls); + } + while (ivar_decls); + fprintf (fp, "}\n"); + } + + while (nst_methods) + { + fprintf (fp, "- %s;\n", gen_method_decl (nst_methods)); + nst_methods = TREE_CHAIN (nst_methods); + } + + while (cls_methods) + { + fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods)); + cls_methods = TREE_CHAIN (cls_methods); + } + + fprintf (fp, "@end\n"); +} + +#if 0 +/* Produce the pretty printing for an Objective-C method. This is + currently unused, but could be handy while reorganizing the pretty + printing to be more robust. */ +static const char * +objc_pretty_print_method (bool is_class_method, + const char *class_name, + const char *category_name, + const char *selector) +{ + if (category_name) + { + char *result = XNEWVEC (char, strlen (class_name) + strlen (category_name) + + strlen (selector) + 7); + + if (is_class_method) + sprintf (result, "+[%s(%s) %s]", class_name, category_name, selector); + else + sprintf (result, "-[%s(%s) %s]", class_name, category_name, selector); + + return result; + } + else + { + char *result = XNEWVEC (char, strlen (class_name) + + strlen (selector) + 5); + + if (is_class_method) + sprintf (result, "+[%s %s]", class_name, selector); + else + sprintf (result, "-[%s %s]", class_name, selector); + + return result; + } +} +#endif + +/* Demangle function for Objective-C. Attempt to demangle the + function name associated with a method (eg, going from + "_i_NSObject__class" to "-[NSObject class]"); usually for the + purpose of pretty printing or error messages. Return the demangled + name, or NULL if the string is not an Objective-C mangled method + name. + + Because of how the mangling is done, any method that has a '_' in + its original name is at risk of being demangled incorrectly. In + some cases there are multiple valid ways to demangle a method name + and there is no way we can decide. + + TODO: objc_demangle() can't always get it right; the right way to + get this correct for all method names would be to store the + Objective-C method name somewhere in the function decl. Then, + there is no demangling to do; we'd just pull the method name out of + the decl. As an additional bonus, when printing error messages we + could check for such a method name, and if we find it, we know the + function is actually an Objective-C method and we could print error + messages saying "In method '+[NSObject class]" instead of "In + function '+[NSObject class]" as we do now. */ +static const char * +objc_demangle (const char *mangled) +{ + char *demangled, *cp; + + /* First of all, if the name is too short it can't be an Objective-C + mangled method name. */ + if (mangled[0] == '\0' || mangled[1] == '\0' || mangled[2] == '\0') + return NULL; + + /* If the name looks like an already demangled one, return it + unchanged. This should only happen on Darwin, where method names + are mangled differently into a pretty-print form (such as + '+[NSObject class]', see darwin.h). In that case, demangling is + a no-op, but we need to return the demangled name if it was an + ObjC one, and return NULL if not. We should be safe as no C/C++ + function can start with "-[" or "+[". */ + if ((mangled[0] == '-' || mangled[0] == '+') + && (mangled[1] == '[')) + return mangled; + + if (mangled[0] == '_' && + (mangled[1] == 'i' || mangled[1] == 'c') && + mangled[2] == '_') + { + cp = demangled = XNEWVEC (char, strlen(mangled) + 2); + if (mangled[1] == 'i') + *cp++ = '-'; /* for instance method */ + else + *cp++ = '+'; /* for class method */ + *cp++ = '['; /* opening left brace */ + strcpy(cp, mangled+3); /* tack on the rest of the mangled name */ + while (*cp && *cp == '_') + cp++; /* skip any initial underbars in class name */ + cp = strchr(cp, '_'); /* find first non-initial underbar */ + if (cp == NULL) + { + free(demangled); /* not mangled name */ + return NULL; + } + if (cp[1] == '_') /* easy case: no category name */ + { + *cp++ = ' '; /* replace two '_' with one ' ' */ + strcpy(cp, mangled + (cp - demangled) + 2); + } + else + { + *cp++ = '('; /* less easy case: category name */ + cp = strchr(cp, '_'); + if (cp == 0) + { + free(demangled); /* not mangled name */ + return NULL; + } + *cp++ = ')'; + *cp++ = ' '; /* overwriting 1st char of method name... */ + strcpy(cp, mangled + (cp - demangled)); /* get it back */ + } + /* Now we have the method name. We need to generally replace + '_' with ':' but trying to preserve '_' if it could only have + been in the mangled string because it was already in the + original name. In cases where it's ambiguous, we assume that + any '_' originated from a ':'. */ + + /* Initial '_'s in method name can't have been generating by + converting ':'s. Skip them. */ + while (*cp && *cp == '_') + cp++; + + /* If the method name does not end with '_', then it has no + arguments and there was no replacement of ':'s with '_'s + during mangling. Check for that case, and skip any + replacement if so. This at least guarantees that methods + with no arguments are always demangled correctly (unless the + original name ends with '_'). */ + if (*(mangled + strlen (mangled) - 1) != '_') + { + /* Skip to the end. */ + for (; *cp; cp++) + ; + } + else + { + /* Replace remaining '_' with ':'. This may get it wrong if + there were '_'s in the original name. In most cases it + is impossible to disambiguate. */ + for (; *cp; cp++) + if (*cp == '_') + *cp = ':'; + } + *cp++ = ']'; /* closing right brace */ + *cp++ = 0; /* string terminator */ + return demangled; + } + else + return NULL; /* not an objc mangled name */ +} + +/* Try to pretty-print a decl. If the 'decl' is an Objective-C + specific decl, return the printable name for it. If not, return + NULL. */ +const char * +objc_maybe_printable_name (tree decl, int v ATTRIBUTE_UNUSED) +{ + switch (TREE_CODE (decl)) + { + case FUNCTION_DECL: + return objc_demangle (IDENTIFIER_POINTER (DECL_NAME (decl))); + break; + + /* The following happens when we are printing a deprecation + warning for a method. The warn_deprecation() will end up + trying to print the decl for INSTANCE_METHOD_DECL or + CLASS_METHOD_DECL. It would be nice to be able to print + "-[NSObject autorelease] is deprecated", but to do that, we'd + need to store the class and method name in the method decl, + which we currently don't do. For now, just return the name + of the method. We don't return NULL, because that may + trigger further attempts to pretty-print the decl in C/C++, + but they wouldn't know how to pretty-print it. */ + case INSTANCE_METHOD_DECL: + case CLASS_METHOD_DECL: + return IDENTIFIER_POINTER (DECL_NAME (decl)); + break; + /* This happens when printing a deprecation warning for a + property. We may want to consider some sort of pretty + printing (eg, include the class name where it was declared + ?). */ + case PROPERTY_DECL: + return IDENTIFIER_POINTER (PROPERTY_NAME (decl)); + break; + default: + return NULL; + break; + } +} + +/* Return a printable name for 'decl'. This first tries + objc_maybe_printable_name(), and if that fails, it returns the name + in the decl. This is used as LANG_HOOKS_DECL_PRINTABLE_NAME for + Objective-C; in Objective-C++, setting the hook is not enough + because lots of C++ Front-End code calls cxx_printable_name, + dump_decl and other C++ functions directly. So instead we have + modified dump_decl to call objc_maybe_printable_name directly. */ +const char * +objc_printable_name (tree decl, int v) +{ + const char *demangled_name = objc_maybe_printable_name (decl, v); + + if (demangled_name != NULL) + return demangled_name; + else + return IDENTIFIER_POINTER (DECL_NAME (decl)); +} + +/* Routine is called to issue diagnostic when reference to a private + ivar is made and no other variable with same name is found in + current scope. */ +bool +objc_diagnose_private_ivar (tree id) +{ + tree ivar; + if (!objc_method_context) + return false; + ivar = is_ivar (objc_ivar_chain, id); + if (ivar && is_private (ivar)) + { + error ("instance variable %qs is declared private", + IDENTIFIER_POINTER (id)); + return true; + } + return false; +} + +/* Look up ID as an instance variable. OTHER contains the result of + the C or C++ lookup, which we may want to use instead. */ +/* To use properties inside an instance method, use self.property. */ +tree +objc_lookup_ivar (tree other, tree id) +{ + tree ivar; + + /* If we are not inside of an ObjC method, ivar lookup makes no sense. */ + if (!objc_method_context) + return other; + + if (!strcmp (IDENTIFIER_POINTER (id), "super")) + /* We have a message to super. */ + return get_super_receiver (); + + /* In a class method, look up an instance variable only as a last + resort. */ + if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL + && other && other != error_mark_node) + return other; + + /* Look up the ivar, but do not use it if it is not accessible. */ + ivar = is_ivar (objc_ivar_chain, id); + + if (!ivar || is_private (ivar)) + return other; + + /* In an instance method, a local variable (or parameter) may hide the + instance variable. */ + if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL + && other && other != error_mark_node +#ifdef OBJCPLUS + && CP_DECL_CONTEXT (other) != global_namespace) +#else + && !DECL_FILE_SCOPE_P (other)) +#endif + { + warning (0, "local declaration of %qE hides instance variable", id); + + return other; + } + + /* At this point, we are either in an instance method with no obscuring + local definitions, or in a class method with no alternate definitions + at all. */ + return build_ivar_reference (id); +} + +/* Possibly rewrite a function CALL into an OBJ_TYPE_REF expression. This + needs to be done if we are calling a function through a cast. */ + +tree +objc_rewrite_function_call (tree function, tree first_param) +{ + if (TREE_CODE (function) == NOP_EXPR + && TREE_CODE (TREE_OPERAND (function, 0)) == ADDR_EXPR + && TREE_CODE (TREE_OPERAND (TREE_OPERAND (function, 0), 0)) + == FUNCTION_DECL) + { + function = build3 (OBJ_TYPE_REF, TREE_TYPE (function), + TREE_OPERAND (function, 0), + first_param, size_zero_node); + } + + return function; +} + +/* This is called to "gimplify" a PROPERTY_REF node. It builds the + corresponding 'getter' function call. Note that we assume the + PROPERTY_REF to be valid since we generated it while parsing. */ +static void +objc_gimplify_property_ref (tree *expr_p) +{ + tree getter = PROPERTY_REF_GETTER_CALL (*expr_p); + tree call_exp; + + if (getter == NULL_TREE) + { + tree property_decl = PROPERTY_REF_PROPERTY_DECL (*expr_p); + /* This can happen if DECL_ARTIFICIAL (*expr_p), but + should be impossible for real properties, which always + have a getter. */ + error_at (EXPR_LOCATION (*expr_p), "no %qs getter found", + IDENTIFIER_POINTER (PROPERTY_NAME (property_decl))); + /* Try to recover from the error to prevent an ICE. We take + zero and cast it to the type of the property. */ + *expr_p = convert (TREE_TYPE (property_decl), + integer_zero_node); + return; + } + + if (PROPERTY_REF_DEPRECATED_GETTER (*expr_p)) + { + /* PROPERTY_REF_DEPRECATED_GETTER contains the method prototype + that is deprecated. */ + warn_deprecated_use (PROPERTY_REF_DEPRECATED_GETTER (*expr_p), + NULL_TREE); + } + + call_exp = getter; +#ifdef OBJCPLUS + /* In C++, a getter which returns an aggregate value results in a + target_expr which initializes a temporary to the call + expression. */ + if (TREE_CODE (getter) == TARGET_EXPR) + { + gcc_assert (MAYBE_CLASS_TYPE_P (TREE_TYPE (getter))); + gcc_assert (TREE_CODE (TREE_OPERAND (getter, 0)) == VAR_DECL); + call_exp = TREE_OPERAND (getter, 1); + } +#endif + gcc_assert (TREE_CODE (call_exp) == CALL_EXPR); + + *expr_p = call_exp; +} + +/* This is called when "gimplifying" the trees. We need to gimplify + the Objective-C/Objective-C++ specific trees, then hand over the + process to C/C++. */ +int +objc_gimplify_expr (tree *expr_p, gimple_seq *pre_p, gimple_seq *post_p) +{ + enum tree_code code = TREE_CODE (*expr_p); + switch (code) + { + /* Look for the special case of OBJC_TYPE_REF with the address + of a function in OBJ_TYPE_REF_EXPR (presumably objc_msgSend + or one of its cousins). */ + case OBJ_TYPE_REF: + if (TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR + && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0)) + == FUNCTION_DECL) + { + enum gimplify_status r0, r1; + + /* Postincrements in OBJ_TYPE_REF_OBJECT don't affect the + value of the OBJ_TYPE_REF, so force them to be emitted + during subexpression evaluation rather than after the + OBJ_TYPE_REF. This permits objc_msgSend calls in + Objective C to use direct rather than indirect calls when + the object expression has a postincrement. */ + r0 = gimplify_expr (&OBJ_TYPE_REF_OBJECT (*expr_p), pre_p, NULL, + is_gimple_val, fb_rvalue); + r1 = gimplify_expr (&OBJ_TYPE_REF_EXPR (*expr_p), pre_p, post_p, + is_gimple_val, fb_rvalue); + + return MIN (r0, r1); + } + break; + case PROPERTY_REF: + objc_gimplify_property_ref (expr_p); + /* Do not return yet; let C/C++ gimplify the resulting expression. */ + break; + default: + break; + } + +#ifdef OBJCPLUS + return (enum gimplify_status) cp_gimplify_expr (expr_p, pre_p, post_p); +#else + return (enum gimplify_status) c_gimplify_expr (expr_p, pre_p, post_p); +#endif +} + +/* --- FAST ENUMERATION --- */ +/* Begin code generation for fast enumeration (foreach) ... */ + +/* Defines + + struct __objcFastEnumerationState + { + unsigned long state; + id *itemsPtr; + unsigned long *mutationsPtr; + unsigned long extra[5]; + }; + + Confusingly enough, NSFastEnumeration is then defined by libraries + to be the same structure. +*/ + +static void +build_fast_enumeration_state_template (void) +{ + tree decls, *chain = NULL; + + /* { */ + objc_fast_enumeration_state_template = objc_start_struct (get_identifier + (TAG_FAST_ENUMERATION_STATE)); + + /* unsigned long state; */ + decls = add_field_decl (long_unsigned_type_node, "state", &chain); + + /* id *itemsPtr; */ + add_field_decl (build_pointer_type (objc_object_type), + "itemsPtr", &chain); + + /* unsigned long *mutationsPtr; */ + add_field_decl (build_pointer_type (long_unsigned_type_node), + "mutationsPtr", &chain); + + /* unsigned long extra[5]; */ + add_field_decl (build_sized_array_type (long_unsigned_type_node, 5), + "extra", &chain); + + /* } */ + objc_finish_struct (objc_fast_enumeration_state_template, decls); +} + +/* + 'objc_finish_foreach_loop()' generates the code for an Objective-C + foreach loop. The 'location' argument is the location of the 'for' + that starts the loop. The 'object_expression' is the expression of + the 'object' that iterates; the 'collection_expression' is the + expression of the collection that we iterate over (we need to make + sure we evaluate this only once); the 'for_body' is the set of + statements to be executed in each iteration; 'break_label' and + 'continue_label' are the break and continue labels which we need to + emit since the may be jumping to 'break_label' (if they + contain 'break') or to 'continue_label' (if they contain + 'continue'). + + The syntax is + + for ( in ) + + + which is compiled into the following blurb: + + { + id __objc_foreach_collection; + __objc_fast_enumeration_state __objc_foreach_enum_state; + unsigned long __objc_foreach_batchsize; + id __objc_foreach_items[16]; + __objc_foreach_collection = ; + __objc_foreach_enum_state = { 0 }; + __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; + + if (__objc_foreach_batchsize == 0) + = nil; + else + { + unsigned long __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; + next_batch: + { + unsigned long __objc_foreach_index; + __objc_foreach_index = 0; + + next_object: + if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (); + = enumState.itemsPtr[__objc_foreach_index]; + [PS: inside , 'break' jumps to break_label and 'continue' jumps to continue_label] + + continue_label: + __objc_foreach_index++; + if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; + __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; + } + if (__objc_foreach_batchsize != 0) goto next_batch; + = nil; + break_label: + } + } + + 'statements' may contain a 'continue' or 'break' instruction, which + the user expects to 'continue' or 'break' the entire foreach loop. + We are provided the labels that 'break' and 'continue' jump to, so + we place them where we want them to jump to when they pick them. + + Optimization TODO: we could cache the IMP of + countByEnumeratingWithState:objects:count:. +*/ + +/* If you need to debug objc_finish_foreach_loop(), uncomment the following line. */ +/* #define DEBUG_OBJC_FINISH_FOREACH_LOOP 1 */ + +#ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP +#include "tree-pretty-print.h" +#endif + +void +objc_finish_foreach_loop (location_t location, tree object_expression, tree collection_expression, tree for_body, + tree break_label, tree continue_label) +{ + /* A tree representing the __objcFastEnumerationState struct type, + or NSFastEnumerationState struct, whatever we are using. */ + tree objc_fast_enumeration_state_type; + + /* The trees representing the declarations of each of the local variables. */ + tree objc_foreach_collection_decl; + tree objc_foreach_enum_state_decl; + tree objc_foreach_items_decl; + tree objc_foreach_batchsize_decl; + tree objc_foreach_mutations_pointer_decl; + tree objc_foreach_index_decl; + + /* A tree representing the selector countByEnumeratingWithState:objects:count:. */ + tree selector_name; + + /* A tree representing the local bind. */ + tree bind; + + /* A tree representing the external 'if (__objc_foreach_batchsize)' */ + tree first_if; + + /* A tree representing the 'else' part of 'first_if' */ + tree first_else; + + /* A tree representing the 'next_batch' label. */ + tree next_batch_label_decl; + + /* A tree representing the binding after the 'next_batch' label. */ + tree next_batch_bind; + + /* A tree representing the 'next_object' label. */ + tree next_object_label_decl; + + /* Temporary variables. */ + tree t; + int i; + + if (flag_objc1_only) + error_at (location, "fast enumeration is not available in Objective-C 1.0"); + + if (object_expression == error_mark_node) + return; + + if (collection_expression == error_mark_node) + return; + + if (!objc_type_valid_for_messaging (TREE_TYPE (object_expression), true)) + { + error_at (location, "iterating variable in fast enumeration is not an object"); + return; + } + + if (!objc_type_valid_for_messaging (TREE_TYPE (collection_expression), true)) + { + error_at (location, "collection in fast enumeration is not an object"); + return; + } + + /* TODO: Check that object_expression is either a variable + declaration, or an lvalue. */ + + /* This kludge is an idea from apple. We use the + __objcFastEnumerationState struct implicitly defined by the + compiler, unless a NSFastEnumerationState struct has been defined + (by a Foundation library such as GNUstep Base) in which case, we + use that one. + */ + objc_fast_enumeration_state_type = objc_fast_enumeration_state_template; + { + tree objc_NSFastEnumeration_type = lookup_name (get_identifier ("NSFastEnumerationState")); + + if (objc_NSFastEnumeration_type) + { + /* TODO: We really need to check that + objc_NSFastEnumeration_type is the same as ours! */ + if (TREE_CODE (objc_NSFastEnumeration_type) == TYPE_DECL) + { + /* If it's a typedef, use the original type. */ + if (DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type)) + objc_fast_enumeration_state_type = DECL_ORIGINAL_TYPE (objc_NSFastEnumeration_type); + else + objc_fast_enumeration_state_type = TREE_TYPE (objc_NSFastEnumeration_type); + } + } + } + + /* { */ + /* Done by c-parser.c. */ + + /* type object; */ + /* Done by c-parser.c. */ + + /* Disable warnings that 'object' is unused. For example the code + + for (id object in collection) + i++; + + which can be used to count how many objects there are in the + collection is fine and should generate no warnings even if + 'object' is technically unused. */ + TREE_USED (object_expression) = 1; + if (DECL_P (object_expression)) + DECL_READ_P (object_expression) = 1; + + /* id __objc_foreach_collection */ + objc_foreach_collection_decl = objc_create_temporary_var (objc_object_type, "__objc_foreach_collection"); + + /* __objcFastEnumerationState __objc_foreach_enum_state; */ + objc_foreach_enum_state_decl = objc_create_temporary_var (objc_fast_enumeration_state_type, "__objc_foreach_enum_state"); + TREE_CHAIN (objc_foreach_enum_state_decl) = objc_foreach_collection_decl; + + /* id __objc_foreach_items[16]; */ + objc_foreach_items_decl = objc_create_temporary_var (build_sized_array_type (objc_object_type, 16), "__objc_foreach_items"); + TREE_CHAIN (objc_foreach_items_decl) = objc_foreach_enum_state_decl; + + /* unsigned long __objc_foreach_batchsize; */ + objc_foreach_batchsize_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_batchsize"); + TREE_CHAIN (objc_foreach_batchsize_decl) = objc_foreach_items_decl; + + /* Generate the local variable binding. */ + bind = build3 (BIND_EXPR, void_type_node, objc_foreach_batchsize_decl, NULL, NULL); + SET_EXPR_LOCATION (bind, location); + TREE_SIDE_EFFECTS (bind) = 1; + + /* __objc_foreach_collection = ; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_collection_decl, collection_expression); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + /* We have used 'collection_expression'. */ + mark_exp_read (collection_expression); + + /* __objc_foreach_enum_state.state = 0; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("state")), + build_int_cst (long_unsigned_type_node, 0)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + + /* __objc_foreach_enum_state.itemsPtr = NULL; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("itemsPtr")), + null_pointer_node); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + + /* __objc_foreach_enum_state.mutationsPtr = NULL; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("mutationsPtr")), + null_pointer_node); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + + /* __objc_foreach_enum_state.extra[0] = 0; */ + /* __objc_foreach_enum_state.extra[1] = 0; */ + /* __objc_foreach_enum_state.extra[2] = 0; */ + /* __objc_foreach_enum_state.extra[3] = 0; */ + /* __objc_foreach_enum_state.extra[4] = 0; */ + for (i = 0; i < 5 ; i++) + { + t = build2 (MODIFY_EXPR, void_type_node, + build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("extra")), + build_int_cst (NULL_TREE, i)), + build_int_cst (long_unsigned_type_node, 0)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + } + + /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */ + selector_name = get_identifier ("countByEnumeratingWithState:objects:count:"); +#ifdef OBJCPLUS + t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, + /* Parameters. */ + tree_cons /* &__objc_foreach_enum_state */ + (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), + tree_cons /* __objc_foreach_items */ + (NULL_TREE, objc_foreach_items_decl, + tree_cons /* 16 */ + (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); +#else + /* In C, we need to decay the __objc_foreach_items array that we are passing. */ + { + struct c_expr array; + array.value = objc_foreach_items_decl; + t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, + /* Parameters. */ + tree_cons /* &__objc_foreach_enum_state */ + (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), + tree_cons /* __objc_foreach_items */ + (NULL_TREE, default_function_array_conversion (location, array).value, + tree_cons /* 16 */ + (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); + } +#endif + t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl, + convert (long_unsigned_type_node, t)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + + /* if (__objc_foreach_batchsize == 0) */ + first_if = build3 (COND_EXPR, void_type_node, + /* Condition. */ + c_fully_fold + (c_common_truthvalue_conversion + (location, + build_binary_op (location, + EQ_EXPR, + objc_foreach_batchsize_decl, + build_int_cst (long_unsigned_type_node, 0), 1)), + false, NULL), + /* Then block (we fill it in later). */ + NULL_TREE, + /* Else block (we fill it in later). */ + NULL_TREE); + SET_EXPR_LOCATION (first_if, location); + append_to_statement_list (first_if, &BIND_EXPR_BODY (bind)); + + /* then = nil; */ + t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node)); + SET_EXPR_LOCATION (t, location); + COND_EXPR_THEN (first_if) = t; + + /* Now we build the 'else' part of the if; once we finish building + it, we attach it to first_if as the 'else' part. */ + + /* else */ + /* { */ + + /* unsigned long __objc_foreach_mutations_pointer; */ + objc_foreach_mutations_pointer_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_mutations_pointer"); + + /* Generate the local variable binding. */ + first_else = build3 (BIND_EXPR, void_type_node, objc_foreach_mutations_pointer_decl, NULL, NULL); + SET_EXPR_LOCATION (first_else, location); + TREE_SIDE_EFFECTS (first_else) = 1; + + /* __objc_foreach_mutations_pointer = *__objc_foreach_enum_state.mutationsPtr; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_mutations_pointer_decl, + build_indirect_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("mutationsPtr")), + RO_UNARY_STAR)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); + + /* next_batch: */ + next_batch_label_decl = create_artificial_label (location); + t = build1 (LABEL_EXPR, void_type_node, next_batch_label_decl); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); + + /* { */ + + /* unsigned long __objc_foreach_index; */ + objc_foreach_index_decl = objc_create_temporary_var (long_unsigned_type_node, "__objc_foreach_index"); + + /* Generate the local variable binding. */ + next_batch_bind = build3 (BIND_EXPR, void_type_node, objc_foreach_index_decl, NULL, NULL); + SET_EXPR_LOCATION (next_batch_bind, location); + TREE_SIDE_EFFECTS (next_batch_bind) = 1; + append_to_statement_list (next_batch_bind, &BIND_EXPR_BODY (first_else)); + + /* __objc_foreach_index = 0; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl, + build_int_cst (long_unsigned_type_node, 0)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* next_object: */ + next_object_label_decl = create_artificial_label (location); + t = build1 (LABEL_EXPR, void_type_node, next_object_label_decl); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* if (__objc_foreach_mutation_pointer != *__objc_foreach_enum_state.mutationsPtr) objc_enumeration_mutation (); */ + t = build3 (COND_EXPR, void_type_node, + /* Condition. */ + c_fully_fold + (c_common_truthvalue_conversion + (location, + build_binary_op + (location, + NE_EXPR, + objc_foreach_mutations_pointer_decl, + build_indirect_ref (location, + objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("mutationsPtr")), + RO_UNARY_STAR), 1)), + false, NULL), + /* Then block. */ + build_function_call (input_location, + objc_enumeration_mutation_decl, + tree_cons (NULL, collection_expression, NULL)), + /* Else block. */ + NULL_TREE); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* = enumState.itemsPtr[__objc_foreach_index]; */ + t = build2 (MODIFY_EXPR, void_type_node, object_expression, + build_array_ref (location, objc_build_component_ref (objc_foreach_enum_state_decl, + get_identifier ("itemsPtr")), + objc_foreach_index_decl)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* [PS: in , 'break' jumps to break_label and 'continue' jumps to continue_label] */ + append_to_statement_list (for_body, &BIND_EXPR_BODY (next_batch_bind)); + + /* continue_label: */ + if (continue_label) + { + t = build1 (LABEL_EXPR, void_type_node, continue_label); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + } + + /* __objc_foreach_index++; */ + t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_index_decl, + build_binary_op (location, + PLUS_EXPR, + objc_foreach_index_decl, + build_int_cst (long_unsigned_type_node, 1), 1)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* if (__objc_foreach_index < __objc_foreach_batchsize) goto next_object; */ + t = build3 (COND_EXPR, void_type_node, + /* Condition. */ + c_fully_fold + (c_common_truthvalue_conversion + (location, + build_binary_op (location, + LT_EXPR, + objc_foreach_index_decl, + objc_foreach_batchsize_decl, 1)), + false, NULL), + /* Then block. */ + build1 (GOTO_EXPR, void_type_node, next_object_label_decl), + /* Else block. */ + NULL_TREE); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* __objc_foreach_batchsize = [__objc_foreach_collection countByEnumeratingWithState: &__objc_foreach_enum_state objects: __objc_foreach_items count: 16]; */ +#ifdef OBJCPLUS + t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, + /* Parameters. */ + tree_cons /* &__objc_foreach_enum_state */ + (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), + tree_cons /* __objc_foreach_items */ + (NULL_TREE, objc_foreach_items_decl, + tree_cons /* 16 */ + (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); +#else + /* In C, we need to decay the __objc_foreach_items array that we are passing. */ + { + struct c_expr array; + array.value = objc_foreach_items_decl; + t = objc_finish_message_expr (objc_foreach_collection_decl, selector_name, + /* Parameters. */ + tree_cons /* &__objc_foreach_enum_state */ + (NULL_TREE, build_fold_addr_expr_loc (location, objc_foreach_enum_state_decl), + tree_cons /* __objc_foreach_items */ + (NULL_TREE, default_function_array_conversion (location, array).value, + tree_cons /* 16 */ + (NULL_TREE, build_int_cst (NULL_TREE, 16), NULL_TREE))), NULL); + } +#endif + t = build2 (MODIFY_EXPR, void_type_node, objc_foreach_batchsize_decl, + convert (long_unsigned_type_node, t)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (next_batch_bind)); + + /* } */ + + /* if (__objc_foreach_batchsize != 0) goto next_batch; */ + t = build3 (COND_EXPR, void_type_node, + /* Condition. */ + c_fully_fold + (c_common_truthvalue_conversion + (location, + build_binary_op (location, + NE_EXPR, + objc_foreach_batchsize_decl, + build_int_cst (long_unsigned_type_node, 0), 1)), + false, NULL), + /* Then block. */ + build1 (GOTO_EXPR, void_type_node, next_batch_label_decl), + /* Else block. */ + NULL_TREE); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); + + /* = nil; */ + t = build2 (MODIFY_EXPR, void_type_node, object_expression, convert (objc_object_type, null_pointer_node)); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); + + /* break_label: */ + if (break_label) + { + t = build1 (LABEL_EXPR, void_type_node, break_label); + SET_EXPR_LOCATION (t, location); + append_to_statement_list (t, &BIND_EXPR_BODY (first_else)); + } + + /* } */ + COND_EXPR_ELSE (first_if) = first_else; + + /* Do the whole thing. */ + add_stmt (bind); + +#ifdef DEBUG_OBJC_FINISH_FOREACH_LOOP + /* This will print to stderr the whole blurb generated by the + compiler while compiling (assuming the compiler doesn't crash + before getting here). + */ + debug_generic_stmt (bind); +#endif + + /* } */ + /* Done by c-parser.c */ +} + +/* --- SUPPORT FOR FORMAT ARG CHECKING --- */ +/* Return true if we have an NxString object pointer. */ + +bool +objc_string_ref_type_p (tree strp) +{ + tree tmv; + if (!strp || TREE_CODE (strp) != POINTER_TYPE) + return false; + + tmv = TYPE_MAIN_VARIANT (TREE_TYPE (strp)); + tmv = OBJC_TYPE_NAME (tmv); + return (tmv + && TREE_CODE (tmv) == IDENTIFIER_NODE + && IDENTIFIER_POINTER (tmv) + && !strncmp (IDENTIFIER_POINTER (tmv), "NSString", 8)); +} + +/* At present the behavior of this is undefined and it does nothing. */ +void +objc_check_format_arg (tree ARG_UNUSED (format_arg), + tree ARG_UNUSED (args_list)) +{ +} + +/* --- Encode --- */ +/* "Encode" a data type into a string, which grows in util_obstack. + + The format is described in gcc/doc/objc.texi, section 'Type + encoding'. + + Most of the encode_xxx functions have a 'type' argument, which is + the type to encode, and an integer 'curtype' argument, which is the + index in the encoding string of the beginning of the encoding of + the current type, and allows you to find what characters have + already been written for the current type (they are the ones in the + current encoding string starting from 'curtype'). + + For example, if we are encoding a method which returns 'int' and + takes a 'char **' argument, then when we get to the point of + encoding the 'char **' argument, the encoded string already + contains 'i12@0:4' (assuming a pointer size of 4 bytes). So, + 'curtype' will be set to 7 when starting to encode 'char **'. + During the whole of the encoding of 'char **', 'curtype' will be + fixed at 7, so the routine encoding the second pointer can find out + that it's actually encoding a pointer to a pointer by looking + backwards at what has already been encoded for the current type, + and seeing there is a "^" (meaning a pointer) in there. +*/ + + +/* Encode type qualifiers encodes one of the "PQ" Objective-C + keywords, ie 'in', 'out', 'inout', 'bycopy', 'byref', 'oneway'. + 'const', instead, is encoded directly as part of the type. + */ + +static void +encode_type_qualifiers (tree declspecs) +{ + tree spec; + + for (spec = declspecs; spec; spec = TREE_CHAIN (spec)) + { + /* FIXME: Shouldn't we use token->keyword here ? */ + if (ridpointers[(int) RID_IN] == TREE_VALUE (spec)) + obstack_1grow (&util_obstack, 'n'); + else if (ridpointers[(int) RID_INOUT] == TREE_VALUE (spec)) + obstack_1grow (&util_obstack, 'N'); + else if (ridpointers[(int) RID_OUT] == TREE_VALUE (spec)) + obstack_1grow (&util_obstack, 'o'); + else if (ridpointers[(int) RID_BYCOPY] == TREE_VALUE (spec)) + obstack_1grow (&util_obstack, 'O'); + else if (ridpointers[(int) RID_BYREF] == TREE_VALUE (spec)) + obstack_1grow (&util_obstack, 'R'); + else if (ridpointers[(int) RID_ONEWAY] == TREE_VALUE (spec)) + obstack_1grow (&util_obstack, 'V'); + else + gcc_unreachable (); + } +} + +/* Determine if a pointee is marked read-only. Only used by the NeXT + runtime to be compatible with gcc-3.3. */ + +static bool +pointee_is_readonly (tree pointee) +{ + while (POINTER_TYPE_P (pointee)) + pointee = TREE_TYPE (pointee); + + return TYPE_READONLY (pointee); +} + +/* Encode a pointer type. */ + +static void +encode_pointer (tree type, int curtype, int format) +{ + tree pointer_to = TREE_TYPE (type); + + if (flag_next_runtime) + { + /* This code is used to be compatible with gcc-3.3. */ + /* For historical/compatibility reasons, the read-only qualifier + of the pointee gets emitted _before_ the '^'. The read-only + qualifier of the pointer itself gets ignored, _unless_ we are + looking at a typedef! Also, do not emit the 'r' for anything + but the outermost type! */ + if (!generating_instance_variables + && (obstack_object_size (&util_obstack) - curtype <= 1) + && (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL + ? TYPE_READONLY (type) + : pointee_is_readonly (pointer_to))) + obstack_1grow (&util_obstack, 'r'); + } + + if (TREE_CODE (pointer_to) == RECORD_TYPE) + { + if (OBJC_TYPE_NAME (pointer_to) + && TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE) + { + const char *name = IDENTIFIER_POINTER (OBJC_TYPE_NAME (pointer_to)); + + if (strcmp (name, TAG_OBJECT) == 0) /* '@' */ + { + obstack_1grow (&util_obstack, '@'); + return; + } + else if (TYPE_HAS_OBJC_INFO (pointer_to) + && TYPE_OBJC_INTERFACE (pointer_to)) + { + if (generating_instance_variables) + { + obstack_1grow (&util_obstack, '@'); + obstack_1grow (&util_obstack, '"'); + obstack_grow (&util_obstack, name, strlen (name)); + obstack_1grow (&util_obstack, '"'); + return; + } + else + { + obstack_1grow (&util_obstack, '@'); + return; + } + } + else if (strcmp (name, TAG_CLASS) == 0) /* '#' */ + { + obstack_1grow (&util_obstack, '#'); + return; + } + else if (strcmp (name, TAG_SELECTOR) == 0) /* ':' */ + { + obstack_1grow (&util_obstack, ':'); + return; + } + } + } + else if (TREE_CODE (pointer_to) == INTEGER_TYPE + && TYPE_MODE (pointer_to) == QImode) + { + tree pname = TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE + ? OBJC_TYPE_NAME (pointer_to) + : DECL_NAME (OBJC_TYPE_NAME (pointer_to)); + + /* (BOOL *) are an exception and are encoded as ^c, while all + other pointers to char are encoded as *. */ + if (strcmp (IDENTIFIER_POINTER (pname), "BOOL")) + { + if (!flag_next_runtime) + { + /* The NeXT runtime adds the 'r' before getting here. */ + + /* It appears that "r*" means "const char *" rather than + "char *const". "char *const" is encoded as "*", + which is identical to "char *", so the "const" is + unfortunately lost. */ + if (TYPE_READONLY (pointer_to)) + obstack_1grow (&util_obstack, 'r'); + } + + obstack_1grow (&util_obstack, '*'); + return; + } + } + + /* We have a normal pointer type that does not get special treatment. */ + obstack_1grow (&util_obstack, '^'); + encode_type (pointer_to, curtype, format); +} + +static void +encode_array (tree type, int curtype, int format) +{ + tree an_int_cst = TYPE_SIZE (type); + tree array_of = TREE_TYPE (type); + char buffer[40]; + + if (an_int_cst == NULL) + { + /* We are trying to encode an incomplete array. An incomplete + array is forbidden as part of an instance variable; but it + may occur if the instance variable is a pointer to such an + array. */ + + /* So the only case in which an incomplete array could occur + (without being pointed to) is if we are encoding the + arguments or return value of a method. In that case, an + incomplete array argument or return value (eg, + -(void)display: (char[])string) is treated like a pointer + because that is how the compiler does the function call. A + special, more complicated case, is when the incomplete array + is the last member of a struct (eg, if we are encoding + "struct { unsigned long int a;double b[];}"), which is again + part of a method argument/return value. In that case, we + really need to communicate to the runtime that there is an + incomplete array (not a pointer!) there. So, we detect that + special case and encode it as a zero-length array. + + Try to detect that we are part of a struct. We do this by + searching for '=' in the type encoding for the current type. + NB: This hack assumes that you can't use '=' as part of a C + identifier. + */ + { + char *enc = obstack_base (&util_obstack) + curtype; + if (memchr (enc, '=', + obstack_object_size (&util_obstack) - curtype) == NULL) + { + /* We are not inside a struct. Encode the array as a + pointer. */ + encode_pointer (type, curtype, format); + return; + } + } + + /* Else, we are in a struct, and we encode it as a zero-length + array. */ + sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0); + } + else if (TREE_INT_CST_LOW (TYPE_SIZE (array_of)) == 0) + sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0); + else + sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, + TREE_INT_CST_LOW (an_int_cst) + / TREE_INT_CST_LOW (TYPE_SIZE (array_of))); + + obstack_grow (&util_obstack, buffer, strlen (buffer)); + encode_type (array_of, curtype, format); + obstack_1grow (&util_obstack, ']'); + return; +} + +/* Encode a vector. The vector type is a GCC extension to C. */ +static void +encode_vector (tree type, int curtype, int format) +{ + tree vector_of = TREE_TYPE (type); + char buffer[40]; + + /* Vectors are like simple fixed-size arrays. */ + + /* Output ![xx,yy,] where xx is the vector_size, yy is the + alignment of the vector, and is the base type. Eg, int + __attribute__ ((vector_size (16))) gets encoded as ![16,32,i] + assuming that the alignment is 32 bytes. We include size and + alignment in bytes so that the runtime does not have to have any + knowledge of the actual types. + */ + sprintf (buffer, "![" HOST_WIDE_INT_PRINT_DEC ",%d", + /* We want to compute the equivalent of sizeof (). + Code inspired by c_sizeof_or_alignof_type. */ + ((TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type)) + / (TYPE_PRECISION (char_type_node) / BITS_PER_UNIT))), + /* We want to compute the equivalent of __alignof__ + (). Code inspired by + c_sizeof_or_alignof_type. */ + TYPE_ALIGN_UNIT (type)); + obstack_grow (&util_obstack, buffer, strlen (buffer)); + encode_type (vector_of, curtype, format); + obstack_1grow (&util_obstack, ']'); + return; +} + +static void +encode_aggregate_fields (tree type, bool pointed_to, int curtype, int format) +{ + tree field = TYPE_FIELDS (type); + + for (; field; field = DECL_CHAIN (field)) + { +#ifdef OBJCPLUS + /* C++ static members, and things that are not field at all, + should not appear in the encoding. */ + if (TREE_CODE (field) != FIELD_DECL || TREE_STATIC (field)) + continue; +#endif + + /* Recursively encode fields of embedded base classes. */ + if (DECL_ARTIFICIAL (field) && !DECL_NAME (field) + && TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE) + { + encode_aggregate_fields (TREE_TYPE (field), + pointed_to, curtype, format); + continue; + } + + if (generating_instance_variables && !pointed_to) + { + tree fname = DECL_NAME (field); + + obstack_1grow (&util_obstack, '"'); + + if (fname && TREE_CODE (fname) == IDENTIFIER_NODE) + obstack_grow (&util_obstack, + IDENTIFIER_POINTER (fname), + strlen (IDENTIFIER_POINTER (fname))); + + obstack_1grow (&util_obstack, '"'); + } + + encode_field_decl (field, curtype, format); + } +} + +static void +encode_aggregate_within (tree type, int curtype, int format, int left, + int right) +{ + tree name; + /* NB: aggregates that are pointed to have slightly different encoding + rules in that you never encode the names of instance variables. */ + int ob_size = obstack_object_size (&util_obstack); + bool inline_contents = false; + bool pointed_to = false; + + if (flag_next_runtime) + { + if (ob_size > 0 && *(obstack_next_free (&util_obstack) - 1) == '^') + pointed_to = true; + + if ((format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables) + && (!pointed_to || ob_size - curtype == 1 + || (ob_size - curtype == 2 + && *(obstack_next_free (&util_obstack) - 2) == 'r'))) + inline_contents = true; + } + else + { + /* c0 and c1 are the last two characters in the encoding of the + current type; if the last two characters were '^' or '^r', + then we are encoding an aggregate that is "pointed to". The + comment above applies: in that case we should avoid encoding + the names of instance variables. + */ + char c1 = ob_size > 1 ? *(obstack_next_free (&util_obstack) - 2) : 0; + char c0 = ob_size > 0 ? *(obstack_next_free (&util_obstack) - 1) : 0; + + if (c0 == '^' || (c1 == '^' && c0 == 'r')) + pointed_to = true; + + if (format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables) + { + if (!pointed_to) + inline_contents = true; + else + { + /* Note that the check (ob_size - curtype < 2) prevents + infinite recursion when encoding a structure which is + a linked list (eg, struct node { struct node *next; + }). Each time we follow a pointer, we add one + character to ob_size, and curtype is fixed, so after + at most two pointers we stop inlining contents and + break the loop. + + The other case where we don't inline is "^r", which + is a pointer to a constant struct. + */ + if ((ob_size - curtype <= 2) && !(c0 == 'r')) + inline_contents = true; + } + } + } + + /* Traverse struct aliases; it is important to get the + original struct and its tag name (if any). */ + type = TYPE_MAIN_VARIANT (type); + name = OBJC_TYPE_NAME (type); + /* Open parenth/bracket. */ + obstack_1grow (&util_obstack, left); + + /* Encode the struct/union tag name, or '?' if a tag was + not provided. Typedef aliases do not qualify. */ +#ifdef OBJCPLUS + /* For compatibility with the NeXT runtime, ObjC++ encodes template + args as a composite struct tag name. */ + if (name && TREE_CODE (name) == IDENTIFIER_NODE + /* Did this struct have a tag? */ + && !TYPE_WAS_ANONYMOUS (type)) + obstack_grow (&util_obstack, + decl_as_string (type, TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME), + strlen (decl_as_string (type, TFF_DECL_SPECIFIERS | TFF_UNQUALIFIED_NAME))); +#else + if (name && TREE_CODE (name) == IDENTIFIER_NODE) + obstack_grow (&util_obstack, + IDENTIFIER_POINTER (name), + strlen (IDENTIFIER_POINTER (name))); +#endif + else + obstack_1grow (&util_obstack, '?'); + + /* Encode the types (and possibly names) of the inner fields, + if required. */ + if (inline_contents) + { + obstack_1grow (&util_obstack, '='); + encode_aggregate_fields (type, pointed_to, curtype, format); + } + /* Close parenth/bracket. */ + obstack_1grow (&util_obstack, right); +} + +/* Encode a bitfield NeXT-style (i.e., without a bit offset or the underlying + field type. */ + +static void +encode_next_bitfield (int width) +{ + char buffer[40]; + sprintf (buffer, "b%d", width); + obstack_grow (&util_obstack, buffer, strlen (buffer)); +} + +/* Encodes 'type', ignoring type qualifiers (which you should encode + beforehand if needed) with the exception of 'const', which is + encoded by encode_type. See above for the explanation of + 'curtype'. 'format' can be OBJC_ENCODE_INLINE_DEFS or + OBJC_ENCODE_DONT_INLINE_DEFS. +*/ +static void +encode_type (tree type, int curtype, int format) +{ + enum tree_code code = TREE_CODE (type); + + /* Ignore type qualifiers other than 'const' when encoding a + type. */ + + if (type == error_mark_node) + return; + + if (!flag_next_runtime) + { + if (TYPE_READONLY (type)) + obstack_1grow (&util_obstack, 'r'); + } + + switch (code) + { + case ENUMERAL_TYPE: + if (flag_next_runtime) + { + /* Kludge for backwards-compatibility with gcc-3.3: enums + are always encoded as 'i' no matter what type they + actually are (!). */ + obstack_1grow (&util_obstack, 'i'); + break; + } + /* Else, they are encoded exactly like the integer type that is + used by the compiler to store them. */ + case INTEGER_TYPE: + { + char c; + switch (GET_MODE_BITSIZE (TYPE_MODE (type))) + { + case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break; + case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break; + case 32: + { + tree int_type = type; + if (flag_next_runtime) + { + /* Another legacy kludge for compatiblity with + gcc-3.3: 32-bit longs are encoded as 'l' or 'L', + but not always. For typedefs, we need to use 'i' + or 'I' instead if encoding a struct field, or a + pointer! */ + int_type = ((!generating_instance_variables + && (obstack_object_size (&util_obstack) + == (unsigned) curtype)) + ? TYPE_MAIN_VARIANT (type) + : type); + } + if (int_type == long_unsigned_type_node + || int_type == long_integer_type_node) + c = TYPE_UNSIGNED (type) ? 'L' : 'l'; + else + c = TYPE_UNSIGNED (type) ? 'I' : 'i'; + } + break; + case 64: c = TYPE_UNSIGNED (type) ? 'Q' : 'q'; break; + case 128: c = TYPE_UNSIGNED (type) ? 'T' : 't'; break; + default: gcc_unreachable (); + } + obstack_1grow (&util_obstack, c); + break; + } + case REAL_TYPE: + { + char c; + /* Floating point types. */ + switch (GET_MODE_BITSIZE (TYPE_MODE (type))) + { + case 32: c = 'f'; break; + case 64: c = 'd'; break; + case 96: + case 128: c = 'D'; break; + default: gcc_unreachable (); + } + obstack_1grow (&util_obstack, c); + break; + } + case VOID_TYPE: + obstack_1grow (&util_obstack, 'v'); + break; + + case BOOLEAN_TYPE: + obstack_1grow (&util_obstack, 'B'); + break; + + case ARRAY_TYPE: + encode_array (type, curtype, format); + break; + + case POINTER_TYPE: +#ifdef OBJCPLUS + case REFERENCE_TYPE: +#endif + encode_pointer (type, curtype, format); + break; + + case RECORD_TYPE: + encode_aggregate_within (type, curtype, format, '{', '}'); + break; + + case UNION_TYPE: + encode_aggregate_within (type, curtype, format, '(', ')'); + break; + + case FUNCTION_TYPE: /* '?' means an unknown type. */ + obstack_1grow (&util_obstack, '?'); + break; + + case COMPLEX_TYPE: + /* A complex is encoded as 'j' followed by the inner type (eg, + "_Complex int" is encoded as 'ji'). */ + obstack_1grow (&util_obstack, 'j'); + encode_type (TREE_TYPE (type), curtype, format); + break; + + case VECTOR_TYPE: + encode_vector (type, curtype, format); + break; + + default: + warning (0, "unknown type %s found during Objective-C encoding", + gen_type_name (type)); + obstack_1grow (&util_obstack, '?'); + break; + } + + if (flag_next_runtime) + { + /* Super-kludge. Some ObjC qualifier and type combinations need + to be rearranged for compatibility with gcc-3.3. */ + if (code == POINTER_TYPE && obstack_object_size (&util_obstack) >= 3) + { + char *enc = obstack_base (&util_obstack) + curtype; + + /* Rewrite "in const" from "nr" to "rn". */ + if (curtype >= 1 && !strncmp (enc - 1, "nr", 2)) + strncpy (enc - 1, "rn", 2); + } + } +} + +static void +encode_gnu_bitfield (int position, tree type, int size) +{ + enum tree_code code = TREE_CODE (type); + char buffer[40]; + char charType = '?'; + + /* This code is only executed for the GNU runtime, so we can ignore + the NeXT runtime kludge of always encoding enums as 'i' no matter + what integers they actually are. */ + if (code == INTEGER_TYPE || code == ENUMERAL_TYPE) + { + if (integer_zerop (TYPE_MIN_VALUE (type))) + /* Unsigned integer types. */ + { + switch (TYPE_MODE (type)) + { + case QImode: + charType = 'C'; break; + case HImode: + charType = 'S'; break; + case SImode: + { + if (type == long_unsigned_type_node) + charType = 'L'; + else + charType = 'I'; + break; + } + case DImode: + charType = 'Q'; break; + default: + gcc_unreachable (); + } + } + else + /* Signed integer types. */ + { + switch (TYPE_MODE (type)) + { + case QImode: + charType = 'c'; break; + case HImode: + charType = 's'; break; + case SImode: + { + if (type == long_integer_type_node) + charType = 'l'; + else + charType = 'i'; + break; + } + case DImode: + charType = 'q'; break; + default: + gcc_unreachable (); + } + } + } + else + { + /* Do not do any encoding, produce an error and keep going. */ + error ("trying to encode non-integer type as a bitfield"); + return; + } + + sprintf (buffer, "b%d%c%d", position, charType, size); + obstack_grow (&util_obstack, buffer, strlen (buffer)); +} + +void +encode_field_decl (tree field_decl, int curtype, int format) +{ +#ifdef OBJCPLUS + /* C++ static members, and things that are not fields at all, + should not appear in the encoding. */ + if (TREE_CODE (field_decl) != FIELD_DECL || TREE_STATIC (field_decl)) + return; +#endif + + /* Generate the bitfield typing information, if needed. Note the difference + between GNU and NeXT runtimes. */ + if (DECL_BIT_FIELD_TYPE (field_decl)) + { + int size = tree_low_cst (DECL_SIZE (field_decl), 1); + + if (flag_next_runtime) + encode_next_bitfield (size); + else + encode_gnu_bitfield (int_bit_position (field_decl), + DECL_BIT_FIELD_TYPE (field_decl), size); + } + else + encode_type (TREE_TYPE (field_decl), curtype, format); +} + +/* This routine encodes the attribute of the input PROPERTY according + to following formula: + + Property attributes are stored as a comma-delimited C string. + Simple attributes such as readonly are encoded as single + character. The parametrized attributes, getter=name and + setter=name, are encoded as a single character followed by an + identifier. Property types are also encoded as a parametrized + attribute. The characters used to encode these attributes are + defined by the following enumeration: + + enum PropertyAttributes { + kPropertyReadOnly = 'R', + kPropertyBycopy = 'C', + kPropertyByref = '&', + kPropertyDynamic = 'D', + kPropertyGetter = 'G', + kPropertySetter = 'S', + kPropertyInstanceVariable = 'V', + kPropertyType = 'T', + kPropertyWeak = 'W', + kPropertyStrong = 'P', + kPropertyNonAtomic = 'N' + }; */ +tree +objc_v2_encode_prop_attr (tree property) +{ + const char *string; + tree type = TREE_TYPE (property); + + obstack_1grow (&util_obstack, 'T'); + encode_type (type, obstack_object_size (&util_obstack), + OBJC_ENCODE_INLINE_DEFS); + + if (PROPERTY_READONLY (property)) + obstack_grow (&util_obstack, ",R", 2); + + switch (PROPERTY_ASSIGN_SEMANTICS (property)) + { + case OBJC_PROPERTY_COPY: + obstack_grow (&util_obstack, ",C", 2); + break; + case OBJC_PROPERTY_RETAIN: + obstack_grow (&util_obstack, ",&", 2); + break; + case OBJC_PROPERTY_ASSIGN: + default: + break; + } + + if (PROPERTY_DYNAMIC (property)) + obstack_grow (&util_obstack, ",D", 2); + + if (PROPERTY_NONATOMIC (property)) + obstack_grow (&util_obstack, ",N", 2); + + /* Here we want to encode the getter name, but only if it's not the + standard one. */ + if (PROPERTY_GETTER_NAME (property) != PROPERTY_NAME (property)) + { + obstack_grow (&util_obstack, ",G", 2); + string = IDENTIFIER_POINTER (PROPERTY_GETTER_NAME (property)); + obstack_grow (&util_obstack, string, strlen (string)); + } + + if (!PROPERTY_READONLY (property)) + { + /* Here we want to encode the setter name, but only if it's not + the standard one. */ + tree standard_setter = get_identifier (objc_build_property_setter_name (PROPERTY_NAME (property))); + if (PROPERTY_SETTER_NAME (property) != standard_setter) + { + obstack_grow (&util_obstack, ",S", 2); + string = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (property)); + obstack_grow (&util_obstack, string, strlen (string)); + } + } + + /* TODO: Encode strong ('P'), weak ('W') for garbage collection. */ + + if (!PROPERTY_DYNAMIC (property)) + { + obstack_grow (&util_obstack, ",V", 2); + if (PROPERTY_IVAR_NAME (property)) + string = IDENTIFIER_POINTER (PROPERTY_IVAR_NAME (property)); + else + string = IDENTIFIER_POINTER (PROPERTY_NAME (property)); + obstack_grow (&util_obstack, string, strlen (string)); + } + + /* NULL-terminate string. */ + obstack_1grow (&util_obstack, 0); + string = XOBFINISH (&util_obstack, char *); + obstack_free (&util_obstack, util_firstobj); + return get_identifier (string); +} + +#include "gt-objc-objc-act.h" diff --git a/gcc/objc/objc-act.h b/gcc/objc/objc-act.h new file mode 100644 index 000000000..3983d4b1a --- /dev/null +++ b/gcc/objc/objc-act.h @@ -0,0 +1,746 @@ +/* Declarations for objc-act.c. + Copyright (C) 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2009, + 2010, 2011 Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + + +#ifndef GCC_OBJC_ACT_H +#define GCC_OBJC_ACT_H + +/*** Language hooks ***/ + +bool objc_init (void); +const char *objc_printable_name (tree, int); +tree objc_fold_obj_type_ref (tree, tree); +int objc_gimplify_expr (tree *, gimple_seq *, gimple_seq *); + +/* NB: The remaining public functions are prototyped in c-common.h, for the + benefit of stub-objc.c and objc-act.c. */ + +/* Objective-C structures */ + +#define CLASS_LANG_SLOT_ELTS 7 +#define PROTOCOL_LANG_SLOT_ELTS 7 +#define OBJC_INFO_SLOT_ELTS 2 + +/* KEYWORD_DECL */ +#define KEYWORD_KEY_NAME(DECL) ((DECL)->decl_minimal.name) +#define KEYWORD_ARG_NAME(DECL) ((DECL)->decl_non_common.arguments) + +/* INSTANCE_METHOD_DECL, CLASS_METHOD_DECL */ +#define METHOD_SEL_NAME(DECL) ((DECL)->decl_minimal.name) +#define METHOD_SEL_ARGS(DECL) ((DECL)->decl_non_common.arguments) +#define METHOD_ADD_ARGS(DECL) ((DECL)->decl_non_common.result) +#define METHOD_ADD_ARGS_ELLIPSIS_P(DECL) ((DECL)->decl_common.lang_flag_0) +#define METHOD_DEFINITION(DECL) ((DECL)->decl_common.initial) +#define METHOD_ENCODING(DECL) ((DECL)->decl_minimal.context) +#define METHOD_TYPE_ATTRIBUTES(DECL) ((DECL)->decl_common.abstract_origin) +#define METHOD_PROPERTY_CONTEXT(DECL) ((DECL)->decl_common.size_unit) + + +/* PROPERTY_DECL. A PROPERTY_DECL repesents a @property declaration + (when attached to the list of properties of an interface) or a + @synthesize or @dynamic declaration (when attached to the list of + properties of an implementation). */ + +/* TREE_TYPE is the type (int, float, etc) of the property. */ + +/* DECL_ARTIFICIAL is set to 1 if the PROPERTY_DECL is an artificial + property declaration created when the dot-syntax object.component + is used with no actual @property matching the component, but a + valid getter/setter. */ + +/* PROPERTY_NAME is the name of the property. */ +#define PROPERTY_NAME(DECL) DECL_NAME(DECL) + +/* PROPERTY_GETTER_NAME is the identifier of the getter method. */ +#define PROPERTY_GETTER_NAME(DECL) ((DECL)->decl_non_common.arguments) + +/* PROPERTY_SETTER_NAME is the identifier of the setter method. */ +#define PROPERTY_SETTER_NAME(DECL) ((DECL)->decl_non_common.result) + +/* PROPERTY_READONLY can be 0 or 1. */ +#define PROPERTY_READONLY(DECL) DECL_LANG_FLAG_0 (DECL) + +/* PROPERTY_NONATOMIC can be 0 or 1. */ +#define PROPERTY_NONATOMIC(DECL) DECL_LANG_FLAG_1 (DECL) + +typedef enum objc_property_assign_semantics { + OBJC_PROPERTY_ASSIGN = 1, + OBJC_PROPERTY_RETAIN = 2, + OBJC_PROPERTY_COPY = 3 +} objc_property_assign_semantics; + +/* PROPERTY_ASSIGN_SEMANTICS can be OBJC_PROPERTY_ASSIGN, + OBJC_PROPERTY_RETAIN or OBJC_PROPERTY_COPY. We need an integer to + store it, so we hijack the alignment, that properties don't + have. */ +#define PROPERTY_ASSIGN_SEMANTICS(DECL) ((DECL)->decl_common.align) + +/* PROPERTY_IVAR_NAME is the identifier of the instance variable. + This is set only if the PROPERTY_DECL represents a @synthesize; + otherwise, it is set to TREE_NULL. */ +#define PROPERTY_IVAR_NAME(DECL) ((DECL)->decl_common.initial) + +/* PROPERTY_DYNAMIC can be 0 or 1. This is 1 if the PROPERTY_DECL + represents a @dynamic; otherwise, it is set to 0. */ +#define PROPERTY_DYNAMIC(DECL) DECL_LANG_FLAG_2 (DECL) + +/* PROPERTY_HAS_NO_GETTER can be 0 or 1. Normally it is 0, but if + this is an artificial PROPERTY_DECL that we generate even without a + getter, it is set to 1. */ +#define PROPERTY_HAS_NO_GETTER(DECL) DECL_LANG_FLAG_3 (DECL) + +/* PROPERTY_HAS_NO_SETTER can be 0 or 1. Normally it is 0, but if + this is an artificial PROPERTY_DECL that we generate even without a + setter, it is set to 1. */ +#define PROPERTY_HAS_NO_SETTER(DECL) DECL_LANG_FLAG_4 (DECL) + +/* PROPERTY_OPTIONAL can be 0 or 1. Normally it is 0, but if this is + a property declared as @optional in a @protocol, then it is set to + 1. */ +#define PROPERTY_OPTIONAL(DECL) DECL_LANG_FLAG_5 (DECL) + +/* PROPERTY_REF. A PROPERTY_REF represents an 'object.property' + expression. It is normally used for property access, but when + the Objective-C 2.0 "dot-syntax" (object.component) is used + with no matching property, a PROPERTY_REF is still created to + represent it, with an artificial PROPERTY_DECL. */ + +/* PROPERTY_REF_OBJECT is the object whose property we are + accessing. */ +#define PROPERTY_REF_OBJECT(NODE) TREE_OPERAND (PROPERTY_REF_CHECK (NODE), 0) + +/* PROPERTY_REF_PROPERTY_DECL is the PROPERTY_DECL for the property + used in the expression. From it, you can get the property type, + and the getter/setter names. This PROPERTY_DECL could be artificial + if we are processing an 'object.component' syntax with no matching + declared property. */ +#define PROPERTY_REF_PROPERTY_DECL(NODE) TREE_OPERAND (PROPERTY_REF_CHECK (NODE), 1) + +/* PROPERTY_REF_GETTER_CALL is the getter call expression, ready to + use at gimplify time if needed. Generating the getter call + requires modifying the selector table, and, in the case of + self/super, requires the context to be generated correctly. The + gimplify stage is too late to do these things, so we generate the + getter call earlier instead, and keep it here in case we need to + use it. */ +#define PROPERTY_REF_GETTER_CALL(NODE) TREE_OPERAND (PROPERTY_REF_CHECK (NODE), 2) + +/* PROPERTY_REF_DEPRECATED_GETTER is normally set to NULL_TREE. If + the property getter is deprecated, it is set to the method + prototype for it, which is used to generate the deprecation warning + when the getter is used. */ +#define PROPERTY_REF_DEPRECATED_GETTER(NODE) TREE_OPERAND (PROPERTY_REF_CHECK (NODE), 3) + +/* CLASS_INTERFACE_TYPE, CLASS_IMPLEMENTATION_TYPE, + CATEGORY_INTERFACE_TYPE, CATEGORY_IMPLEMENTATION_TYPE, + PROTOCOL_INTERFACE_TYPE */ +/* CLASS_NAME is the name of the class. */ +#define CLASS_NAME(CLASS) ((CLASS)->type.name) +/* CLASS_SUPER_NAME is the name of the superclass, or, in the case of + categories, it is the name of the category itself. */ +#define CLASS_SUPER_NAME(CLASS) (TYPE_CHECK (CLASS)->type.context) +#define CLASS_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0) +#define CLASS_RAW_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 1) +#define CLASS_NST_METHODS(CLASS) ((CLASS)->type.minval) +#define CLASS_CLS_METHODS(CLASS) ((CLASS)->type.maxval) +#define CLASS_STATIC_TEMPLATE(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 2) +#define CLASS_CATEGORY_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 3) +#define CLASS_PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 4) +#define TOTAL_CLASS_RAW_IVARS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 5) +#define CLASS_HAS_EXCEPTION_ATTR(CLASS) (TYPE_LANG_FLAG_0 (CLASS)) + +#define PROTOCOL_NAME(CLASS) ((CLASS)->type.name) +#define PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0) +#define PROTOCOL_NST_METHODS(CLASS) ((CLASS)->type.minval) +#define PROTOCOL_CLS_METHODS(CLASS) ((CLASS)->type.maxval) +#define PROTOCOL_FORWARD_DECL(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 1) +#define PROTOCOL_DEFINED(CLASS) TREE_USED (CLASS) +#define PROTOCOL_OPTIONAL_CLS_METHODS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 2) +#define PROTOCOL_OPTIONAL_NST_METHODS(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 3) + +/* For CATEGORY_INTERFACE_TYPE, CLASS_INTERFACE_TYPE or PROTOCOL_INTERFACE_TYPE */ +#define CLASS_PROPERTY_DECL(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 6) +/* For CLASS_IMPLEMENTATION_TYPE or CATEGORY_IMPLEMENTATION_TYPE. */ +#define IMPL_PROPERTY_DECL(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 6) + +/* TREE_DEPRECATED is used for a CLASS_INTERFACE_TYPE or PROTOCOL_INTERFACE_TYPE. */ + +/* TYPE_ATTRIBUTES is used for a CLASS_INTERFACE_TYPE or PROTOCOL_INTERFACE_TYPE. */ + +/* ObjC-specific information pertaining to RECORD_TYPEs are stored in + the LANG_SPECIFIC structures, which may itself need allocating first. */ + +/* The following three macros must be overridden (in objcp/objcp-decl.h) + for Objective-C++. */ +#define TYPE_OBJC_INFO(TYPE) TYPE_LANG_SPECIFIC (TYPE)->objc_info +#define SIZEOF_OBJC_TYPE_LANG_SPECIFIC sizeof (struct lang_type) +#define ALLOC_OBJC_TYPE_LANG_SPECIFIC(NODE) \ + do { \ + TYPE_LANG_SPECIFIC (NODE) \ + = ggc_alloc_cleared_lang_type (sizeof (struct lang_type)); \ + } while (0) + +#define TYPE_HAS_OBJC_INFO(TYPE) \ + (TYPE_LANG_SPECIFIC (TYPE) && TYPE_OBJC_INFO (TYPE)) +#define TYPE_OBJC_INTERFACE(TYPE) TREE_VEC_ELT (TYPE_OBJC_INFO (TYPE), 0) +#define TYPE_OBJC_PROTOCOL_LIST(TYPE) TREE_VEC_ELT (TYPE_OBJC_INFO (TYPE), 1) + + +#define INIT_TYPE_OBJC_INFO(TYPE) \ + do \ + { \ + if (!TYPE_LANG_SPECIFIC (TYPE)) \ + ALLOC_OBJC_TYPE_LANG_SPECIFIC(TYPE); \ + if (!TYPE_OBJC_INFO (TYPE)) \ + TYPE_OBJC_INFO (TYPE) \ + = make_tree_vec (OBJC_INFO_SLOT_ELTS); \ + } \ + while (0) + +#define DUP_TYPE_OBJC_INFO(DST, SRC) \ + do \ + { \ + ALLOC_OBJC_TYPE_LANG_SPECIFIC(DST); \ + if (TYPE_LANG_SPECIFIC (SRC)) \ + memcpy (TYPE_LANG_SPECIFIC (DST), \ + TYPE_LANG_SPECIFIC (SRC), \ + SIZEOF_OBJC_TYPE_LANG_SPECIFIC); \ + TYPE_OBJC_INFO (DST) \ + = make_tree_vec (OBJC_INFO_SLOT_ELTS); \ + } \ + while (0) + +#define TYPED_OBJECT(TYPE) \ + (TREE_CODE (TYPE) == RECORD_TYPE \ + && TYPE_HAS_OBJC_INFO (TYPE) \ + && TYPE_OBJC_INTERFACE (TYPE)) +#define OBJC_TYPE_NAME(TYPE) TYPE_NAME(TYPE) +#define OBJC_SET_TYPE_NAME(TYPE, NAME) (TYPE_NAME (TYPE) = NAME) + +/* Hash tables to manage the global pool of method prototypes. */ + +typedef struct hashed_entry *hash; +typedef struct hashed_attribute *attr; + +struct GTY(()) hashed_attribute { + attr next; + tree value; +}; + +struct GTY(()) hashed_entry { + attr list; + hash next; + tree key; +}; + +#define SIZEHASHTABLE 257 + +extern GTY ((length ("SIZEHASHTABLE"))) hash *nst_method_hash_list; +extern GTY ((length ("SIZEHASHTABLE"))) hash *cls_method_hash_list; + +extern GTY ((length ("SIZEHASHTABLE"))) hash *cls_name_hash_list; +extern GTY ((length ("SIZEHASHTABLE"))) hash *als_name_hash_list; + +/* An array of all the local variables in the current function that + need to be marked as volatile. */ +extern GTY(()) VEC(tree,gc) *local_variables_to_volatilize; + +/* Objective-C/Objective-C++ @implementation list. */ + +struct GTY(()) imp_entry { + struct imp_entry *next; + tree imp_context; + tree imp_template; + tree class_decl; /* _OBJC[_v2]_CLASS/CATEGORY_; */ + tree meta_decl; /* _OBJC[_v2]_METACLASS_; */ + BOOL_BITFIELD has_cxx_cdtors : 1; +}; + +extern GTY(()) struct imp_entry *imp_list; +extern GTY(()) int imp_count; /* `@implementation' */ +extern GTY(()) int cat_count; /* `@category' */ + +extern GTY(()) objc_ivar_visibility_kind objc_ivar_visibility; + +/* Objective-C/Objective-C++ global tree enumeration. */ + +enum objc_tree_index +{ + OCTI_STATIC_NST, + OCTI_STATIC_NST_DECL, + OCTI_SELF_ID, + OCTI_UCMD_ID, + + OCTI_SELF_DECL, + OCTI_UMSG_DECL, + OCTI_UMSG_FAST_DECL, + OCTI_UMSG_SUPER_DECL, + OCTI_UMSG_STRET_DECL, + OCTI_UMSG_SUPER_STRET_DECL, + OCTI_GET_CLASS_DECL, + OCTI_GET_MCLASS_DECL, + OCTI_SUPER_TYPE, + OCTI_SEL_TYPE, + OCTI_ID_TYPE, + OCTI_CLS_TYPE, + OCTI_NST_TYPE, + OCTI_PROTO_TYPE, + + OCTI_INTF_CHAIN, + OCTI_PROTO_CHAIN, + OCTI_IMPL_CHAIN, + OCTI_CLS_REF_CHAIN, + OCTI_SEL_REF_CHAIN, + OCTI_IVAR_CHAIN, + OCTI_CLS_NAMES_CHAIN, + OCTI_METH_VAR_NAMES_CHAIN, + OCTI_METH_VAR_TYPES_CHAIN, + + OCTI_SYMBOLS_DECL, + OCTI_NST_VAR_DECL, + OCTI_CLS_VAR_DECL, + OCTI_NST_METH_DECL, + OCTI_CLS_METH_DECL, + OCTI_CLS_DECL, + OCTI_MCLS_DECL, + OCTI_SEL_TABLE_DECL, + OCTI_MODULES_DECL, + OCTI_GNU_INIT_DECL, + + OCTI_INTF_CTX, + OCTI_IMPL_CTX, + OCTI_METH_CTX, + OCTI_IVAR_CTX, + + OCTI_IMPL_TEMPL, + OCTI_CLS_TEMPL, + OCTI_CAT_TEMPL, + OCTI_UPRIV_REC, + OCTI_PROTO_TEMPL, + OCTI_SEL_TEMPL, + OCTI_UCLS_SUPER_REF, + OCTI_UUCLS_SUPER_REF, + OCTI_METH_TEMPL, + OCTI_IVAR_TEMPL, + OCTI_METH_LIST_TEMPL, + OCTI_METH_PROTO_LIST_TEMPL, + OCTI_IVAR_LIST_TEMPL, + OCTI_SYMTAB_TEMPL, + OCTI_MODULE_TEMPL, + OCTI_SUPER_TEMPL, + OCTI_OBJ_REF, + OCTI_CLS_REF, + OCTI_METH_PROTO_TEMPL, + OCTI_FUNCTION1_TEMPL, + OCTI_FUNCTION2_TEMPL, + + OCTI_OBJ_ID, + OCTI_CLS_ID, + OCTI_ID_NAME, + OCTI_CLASS_NAME, + OCTI_CNST_STR_ID, + OCTI_CNST_STR_TYPE, + OCTI_CNST_STR_GLOB_ID, + OCTI_STRING_CLASS_DECL, + OCTI_INTERNAL_CNST_STR_TYPE, + OCTI_SUPER_DECL, + OCTI_SUPER_SUPERFIELD_ID, + OCTI_UMSG_NONNIL_DECL, + OCTI_UMSG_NONNIL_STRET_DECL, + OCTI_STORAGE_CLS, + OCTI_EXCEPTION_EXTRACT_DECL, + OCTI_EXCEPTION_TRY_ENTER_DECL, + OCTI_EXCEPTION_TRY_EXIT_DECL, + OCTI_EXCEPTION_MATCH_DECL, + OCTI_EXCEPTION_THROW_DECL, + OCTI_SYNC_ENTER_DECL, + OCTI_SYNC_EXIT_DECL, + OCTI_SETJMP_DECL, + OCTI_EXCDATA_TEMPL, + OCTI_STACK_EXCEPTION_DATA_DECL, + OCTI_LOCAL_EXCEPTION_DECL, + OCTI_RETHROW_EXCEPTION_DECL, + OCTI_EVAL_ONCE_DECL, + OCTI_CATCH_TYPE, + OCTI_EXECCLASS_DECL, + + OCTI_ASSIGN_IVAR_DECL, + OCTI_ASSIGN_IVAR_FAST_DECL, + OCTI_ASSIGN_GLOBAL_DECL, + OCTI_ASSIGN_STRONGCAST_DECL, + + OCTI_FAST_ENUM_STATE_TEMP, + OCTI_ENUM_MUTATION_DECL, + + OCTI_GET_PROPERTY_DECL, + OCTI_SET_PROPERTY_DECL, + OCTI_COPY_STRUCT_DECL, + OCTI_GET_PROPERTY_STRUCT_DECL, + OCTI_SET_PROPERTY_STRUCT_DECL, + + /* TODO: Add comment. */ + /* "V1" stuff. */ + OCTI_V1_PROP_LIST_TEMPL, + OCTI_V1_PROP_NAME_ATTR_CHAIN, + + OCTI_MAX +}; + +extern GTY(()) tree objc_global_trees[OCTI_MAX]; + +/* List of classes with list of their static instances. */ +#define objc_static_instances objc_global_trees[OCTI_STATIC_NST] + +/* The declaration of the array administrating the static instances. */ +#define static_instances_decl objc_global_trees[OCTI_STATIC_NST_DECL] + +/* Some commonly used instances of "identifier_node". */ + +#define self_id objc_global_trees[OCTI_SELF_ID] +#define ucmd_id objc_global_trees[OCTI_UCMD_ID] + +#define self_decl objc_global_trees[OCTI_SELF_DECL] +#define umsg_decl objc_global_trees[OCTI_UMSG_DECL] +#define umsg_fast_decl objc_global_trees[OCTI_UMSG_FAST_DECL] +#define umsg_super_decl objc_global_trees[OCTI_UMSG_SUPER_DECL] +#define umsg_stret_decl objc_global_trees[OCTI_UMSG_STRET_DECL] +#define umsg_super_stret_decl objc_global_trees[OCTI_UMSG_SUPER_STRET_DECL] +#define objc_get_class_decl objc_global_trees[OCTI_GET_CLASS_DECL] +#define objc_get_meta_class_decl \ + objc_global_trees[OCTI_GET_MCLASS_DECL] + +#define objc_super_type objc_global_trees[OCTI_SUPER_TYPE] +#define objc_selector_type objc_global_trees[OCTI_SEL_TYPE] +#define objc_object_type objc_global_trees[OCTI_ID_TYPE] +#define objc_class_type objc_global_trees[OCTI_CLS_TYPE] +#define objc_instance_type objc_global_trees[OCTI_NST_TYPE] +#define objc_protocol_type objc_global_trees[OCTI_PROTO_TYPE] + +/* Type checking macros. */ + +#define IS_ID(TYPE) \ + (TREE_CODE (TYPE) == POINTER_TYPE \ + && (TYPE_MAIN_VARIANT (TREE_TYPE (TYPE)) \ + == TREE_TYPE (objc_object_type))) + +#define IS_CLASS(TYPE) \ + (TREE_CODE (TYPE) == POINTER_TYPE \ + && (TYPE_MAIN_VARIANT (TREE_TYPE (TYPE)) \ + == TREE_TYPE (objc_class_type))) + +#define IS_PROTOCOL_QUALIFIED_UNTYPED(TYPE) \ + ((IS_ID (TYPE) || IS_CLASS (TYPE)) \ + && TYPE_HAS_OBJC_INFO (TREE_TYPE (TYPE)) \ + && TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (TYPE))) + +#define IS_SUPER(TYPE) \ + (TREE_CODE (TYPE) == POINTER_TYPE \ + && TREE_TYPE (TYPE) == objc_super_template) + +#define interface_chain objc_global_trees[OCTI_INTF_CHAIN] +#define protocol_chain objc_global_trees[OCTI_PROTO_CHAIN] +#define implemented_classes objc_global_trees[OCTI_IMPL_CHAIN] + +/* Chains to manage selectors that are referenced and defined in the + module. */ + +#define cls_ref_chain objc_global_trees[OCTI_CLS_REF_CHAIN] /* Classes referenced. */ +#define sel_ref_chain objc_global_trees[OCTI_SEL_REF_CHAIN] /* Selectors referenced. */ +#define objc_ivar_chain objc_global_trees[OCTI_IVAR_CHAIN] + +/* Chains to manage uniquing of strings. */ + +#define class_names_chain objc_global_trees[OCTI_CLS_NAMES_CHAIN] +#define meth_var_names_chain objc_global_trees[OCTI_METH_VAR_NAMES_CHAIN] +#define meth_var_types_chain objc_global_trees[OCTI_METH_VAR_TYPES_CHAIN] + + +/* Backend data declarations. */ + +#define UOBJC_SYMBOLS_decl objc_global_trees[OCTI_SYMBOLS_DECL] +#define UOBJC_INSTANCE_VARIABLES_decl objc_global_trees[OCTI_NST_VAR_DECL] +#define UOBJC_CLASS_VARIABLES_decl objc_global_trees[OCTI_CLS_VAR_DECL] +#define UOBJC_INSTANCE_METHODS_decl objc_global_trees[OCTI_NST_METH_DECL] +#define UOBJC_CLASS_METHODS_decl objc_global_trees[OCTI_CLS_METH_DECL] +#define UOBJC_CLASS_decl objc_global_trees[OCTI_CLS_DECL] +#define UOBJC_METACLASS_decl objc_global_trees[OCTI_MCLS_DECL] +#define UOBJC_SELECTOR_TABLE_decl objc_global_trees[OCTI_SEL_TABLE_DECL] +#define UOBJC_MODULES_decl objc_global_trees[OCTI_MODULES_DECL] +#define GNU_INIT_decl objc_global_trees[OCTI_GNU_INIT_DECL] + +/* The following are used when compiling a class implementation. + implementation_template will normally be an interface, however if + none exists this will be equal to objc_implementation_context...it is + set in start_class. */ + +#define objc_interface_context objc_global_trees[OCTI_INTF_CTX] +#define objc_implementation_context objc_global_trees[OCTI_IMPL_CTX] +#define objc_method_context objc_global_trees[OCTI_METH_CTX] +#define objc_ivar_context objc_global_trees[OCTI_IVAR_CTX] + +#define implementation_template objc_global_trees[OCTI_IMPL_TEMPL] +#define objc_class_template objc_global_trees[OCTI_CLS_TEMPL] +#define objc_category_template objc_global_trees[OCTI_CAT_TEMPL] +#define uprivate_record objc_global_trees[OCTI_UPRIV_REC] +#define objc_protocol_template objc_global_trees[OCTI_PROTO_TEMPL] +#define objc_selector_template objc_global_trees[OCTI_SEL_TEMPL] +#define ucls_super_ref objc_global_trees[OCTI_UCLS_SUPER_REF] +#define uucls_super_ref objc_global_trees[OCTI_UUCLS_SUPER_REF] + +#define umsg_nonnil_decl objc_global_trees[OCTI_UMSG_NONNIL_DECL] +#define umsg_nonnil_stret_decl objc_global_trees[OCTI_UMSG_NONNIL_STRET_DECL] +#define objc_storage_class objc_global_trees[OCTI_STORAGE_CLS] +#define objc_exception_extract_decl \ + objc_global_trees[OCTI_EXCEPTION_EXTRACT_DECL] +#define objc_exception_try_enter_decl \ + objc_global_trees[OCTI_EXCEPTION_TRY_ENTER_DECL] +#define objc_exception_try_exit_decl \ + objc_global_trees[OCTI_EXCEPTION_TRY_EXIT_DECL] +#define objc_exception_match_decl \ + objc_global_trees[OCTI_EXCEPTION_MATCH_DECL] +#define objc_exception_throw_decl \ + objc_global_trees[OCTI_EXCEPTION_THROW_DECL] +#define objc_sync_enter_decl objc_global_trees[OCTI_SYNC_ENTER_DECL] +#define objc_sync_exit_decl objc_global_trees[OCTI_SYNC_EXIT_DECL] +#define objc_exception_data_template \ + objc_global_trees[OCTI_EXCDATA_TEMPL] +#define objc_setjmp_decl objc_global_trees[OCTI_SETJMP_DECL] +#define objc_stack_exception_data \ + objc_global_trees[OCTI_STACK_EXCEPTION_DATA_DECL] +#define objc_caught_exception objc_global_trees[OCTI_LOCAL_EXCEPTION_DECL] +#define objc_rethrow_exception objc_global_trees[OCTI_RETHROW_EXCEPTION_DECL] +#define objc_eval_once objc_global_trees[OCTI_EVAL_ONCE_DECL] +#define objc_catch_type objc_global_trees[OCTI_CATCH_TYPE] + +#define execclass_decl objc_global_trees[OCTI_EXECCLASS_DECL] + +#define objc_assign_ivar_decl objc_global_trees[OCTI_ASSIGN_IVAR_DECL] +#define objc_assign_ivar_fast_decl \ + objc_global_trees[OCTI_ASSIGN_IVAR_FAST_DECL] +#define objc_assign_global_decl objc_global_trees[OCTI_ASSIGN_GLOBAL_DECL] +#define objc_assign_strong_cast_decl \ + objc_global_trees[OCTI_ASSIGN_STRONGCAST_DECL] + +#define objc_method_template objc_global_trees[OCTI_METH_TEMPL] +#define objc_ivar_template objc_global_trees[OCTI_IVAR_TEMPL] +#define objc_method_list_ptr objc_global_trees[OCTI_METH_LIST_TEMPL] +#define objc_method_proto_list_ptr \ + objc_global_trees[OCTI_METH_PROTO_LIST_TEMPL] +#define objc_ivar_list_ptr objc_global_trees[OCTI_IVAR_LIST_TEMPL] +#define objc_symtab_template objc_global_trees[OCTI_SYMTAB_TEMPL] +#define objc_module_template objc_global_trees[OCTI_MODULE_TEMPL] +#define objc_super_template objc_global_trees[OCTI_SUPER_TEMPL] +#define objc_object_reference objc_global_trees[OCTI_OBJ_REF] +#define objc_class_reference objc_global_trees[OCTI_CLS_REF] +#define objc_method_prototype_template \ + objc_global_trees[OCTI_METH_PROTO_TEMPL] +#define function1_template objc_global_trees[OCTI_FUNCTION1_TEMPL] +#define function2_template objc_global_trees[OCTI_FUNCTION2_TEMPL] + +#define objc_object_id objc_global_trees[OCTI_OBJ_ID] +#define objc_class_id objc_global_trees[OCTI_CLS_ID] +#define objc_object_name objc_global_trees[OCTI_ID_NAME] +#define objc_class_name objc_global_trees[OCTI_CLASS_NAME] + +/* Constant string classes. */ +#define constant_string_id objc_global_trees[OCTI_CNST_STR_ID] +#define constant_string_type objc_global_trees[OCTI_CNST_STR_TYPE] +#define constant_string_global_id \ + objc_global_trees[OCTI_CNST_STR_GLOB_ID] +#define string_class_decl objc_global_trees[OCTI_STRING_CLASS_DECL] +#define internal_const_str_type objc_global_trees[OCTI_INTERNAL_CNST_STR_TYPE] + +#define UOBJC_SUPER_decl objc_global_trees[OCTI_SUPER_DECL] +#define super_superclassfield_id \ + objc_global_trees[OCTI_SUPER_SUPERFIELD_ID] + +#define objc_fast_enumeration_state_template \ + objc_global_trees[OCTI_FAST_ENUM_STATE_TEMP] +#define objc_enumeration_mutation_decl \ + objc_global_trees[OCTI_ENUM_MUTATION_DECL] + +/* Declarations of functions used when synthesizing property + accessors. */ +#define objc_getProperty_decl objc_global_trees[OCTI_GET_PROPERTY_DECL] +#define objc_setProperty_decl objc_global_trees[OCTI_SET_PROPERTY_DECL] +#define objc_copyStruct_decl objc_global_trees[OCTI_COPY_STRUCT_DECL] +#define objc_getPropertyStruct_decl \ + objc_global_trees[OCTI_GET_PROPERTY_STRUCT_DECL] +#define objc_setPropertyStruct_decl \ + objc_global_trees[OCTI_SET_PROPERTY_STRUCT_DECL] + +/* TODO: Add comment. */ +/* V1 stuff. */ +#define objc_prop_list_ptr objc_global_trees[OCTI_V1_PROP_LIST_TEMPL] +#define prop_names_attr_chain objc_global_trees[OCTI_V1_PROP_NAME_ATTR_CHAIN] + +/* Reserved tag definitions. */ + +#define OBJECT_TYPEDEF_NAME "id" +#define CLASS_TYPEDEF_NAME "Class" + +#define TAG_OBJECT "objc_object" +#define TAG_CLASS "objc_class" +#define TAG_SUPER "objc_super" +#define TAG_SELECTOR "objc_selector" + +#define UTAG_CLASS "_objc_class" +#define UTAG_IVAR "_objc_ivar" +#define UTAG_IVAR_LIST "_objc_ivar_list" +#define UTAG_METHOD "_objc_method" +#define UTAG_METHOD_LIST "_objc_method_list" +#define UTAG_CATEGORY "_objc_category" +#define UTAG_MODULE "_objc_module" +#define UTAG_SYMTAB "_objc_symtab" +#define UTAG_SUPER "_objc_super" +#define UTAG_SELECTOR "_objc_selector" + +#define UTAG_PROTOCOL "_objc_protocol" +#define UTAG_METHOD_PROTOTYPE "_objc_method_prototype" +#define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list" + +#define PROTOCOL_OBJECT_CLASS_NAME "Protocol" + +#define TAG_EXCEPTIONTHROW "objc_exception_throw" +#define TAG_SYNCENTER "objc_sync_enter" +#define TAG_SYNCEXIT "objc_sync_exit" + +/* Really should be NeXT private. */ +#define UTAG_EXCDATA "_objc_exception_data" + +#define TAG_CXX_CONSTRUCT ".cxx_construct" +#define TAG_CXX_DESTRUCT ".cxx_destruct" + +#define TAG_ENUMERATION_MUTATION "objc_enumerationMutation" +#define TAG_FAST_ENUMERATION_STATE "__objcFastEnumerationState" + +typedef enum string_section +{ + class_names, /* class, category, protocol, module names */ + meth_var_names, /* method and variable names */ + meth_var_types, /* method and variable type descriptors */ + prop_names_attr /* property names and their attributes. */ +} string_section; + +#define METHOD_DEF 0 +#define METHOD_REF 1 + +/* (Decide if these can ever be validly changed.) */ +#define OBJC_ENCODE_INLINE_DEFS 0 +#define OBJC_ENCODE_DONT_INLINE_DEFS 1 + +#define BUFSIZE 1024 + +#define CLS_FACTORY 0x0001L +#define CLS_META 0x0002L + +/* Runtime metadata flags - ??? apparently unused. */ + +#define OBJC_MODIFIER_STATIC 0x00000001 +#define OBJC_MODIFIER_FINAL 0x00000002 +#define OBJC_MODIFIER_PUBLIC 0x00000004 +#define OBJC_MODIFIER_PRIVATE 0x00000008 +#define OBJC_MODIFIER_PROTECTED 0x00000010 +#define OBJC_MODIFIER_NATIVE 0x00000020 +#define OBJC_MODIFIER_SYNCHRONIZED 0x00000040 +#define OBJC_MODIFIER_ABSTRACT 0x00000080 +#define OBJC_MODIFIER_VOLATILE 0x00000100 +#define OBJC_MODIFIER_TRANSIENT 0x00000200 +#define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000 + +#define OBJC_VOID_AT_END void_list_node + +/* Exception handling constructs. We begin by having the parser do most + of the work and passing us blocks. + This allows us to handle different exceptions implementations. */ + +/* Stack of open try blocks. */ + +struct objc_try_context +{ + struct objc_try_context *outer; + + /* Statements (or statement lists) as processed by the parser. */ + tree try_body; + tree finally_body; + + /* Some file position locations. */ + location_t try_locus; + location_t end_try_locus; + location_t end_catch_locus; + location_t finally_locus; + location_t end_finally_locus; + + /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1 + of a TRY_CATCH_EXPR. Even when doing Darwin setjmp. */ + tree catch_list; + + /* The CATCH_EXPR of an open @catch clause. */ + tree current_catch; + + /* The VAR_DECL holding __builtin_eh_pointer (or equivalent). */ + tree caught_decl; + tree stack_decl; + tree rethrow_decl; +}; + +/* A small number of routines used by the FE parser and the runtime code + generators. Put here as inlines for efficiency in non-lto builds rather + than making them externs. */ + +extern tree objc_create_temporary_var (tree, const char *); + +#define objc_is_object_id(TYPE) (OBJC_TYPE_NAME (TYPE) == objc_object_id) +#define objc_is_class_id(TYPE) (OBJC_TYPE_NAME (TYPE) == objc_class_id) + +/* Retrieve category interface CAT_NAME (if any) associated with CLASS. */ +static inline tree +lookup_category (tree klass, tree cat_name) +{ + tree category = CLASS_CATEGORY_LIST (klass); + + while (category && CLASS_SUPER_NAME (category) != cat_name) + category = CLASS_CATEGORY_LIST (category); + return category; +} + +/* Count only the fields occurring in T. */ +static inline int +ivar_list_length (tree t) +{ + int count = 0; + + for (; t; t = DECL_CHAIN (t)) + if (TREE_CODE (t) == FIELD_DECL) + ++count; + + return count; +} + +static inline tree +is_ivar (tree decl_chain, tree ident) +{ + for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain)) + if (DECL_NAME (decl_chain) == ident) + return decl_chain; + return NULL_TREE; +} + +#endif /* GCC_OBJC_ACT_H */ diff --git a/gcc/objc/objc-gnu-runtime-abi-01.c b/gcc/objc/objc-gnu-runtime-abi-01.c new file mode 100644 index 000000000..7fb87611d --- /dev/null +++ b/gcc/objc/objc-gnu-runtime-abi-01.c @@ -0,0 +1,2269 @@ +/* GNU Runtime ABI version 8 + Copyright (C) 2011 Free Software Foundation, Inc. + Contributed by Iain Sandoe (split from objc-act.c) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tree.h" + +#ifdef OBJCPLUS +#include "cp-tree.h" +#else +#include "c-tree.h" +#include "c-lang.h" +#endif + +#include "langhooks.h" +#include "c-family/c-objc.h" +#include "objc-act.h" + +/* When building Objective-C++, we are not linking against the C front-end + and so need to replicate the C tree-construction functions in some way. */ +#ifdef OBJCPLUS +#define OBJCP_REMAP_FUNCTIONS +#include "objcp-decl.h" +#endif /* OBJCPLUS */ + +#include "toplev.h" +#include "ggc.h" +#include "tree-iterator.h" + +#include "objc-runtime-hooks.h" +#include "objc-runtime-shared-support.h" + +/* GNU runtime private definitions. */ +#define DEF_CONSTANT_STRING_CLASS_NAME "NXConstantString" + +#define TAG_GETCLASS "objc_get_class" +#define TAG_GETMETACLASS "objc_get_meta_class" + +#define TAG_MSGSEND "objc_msg_lookup" +#define TAG_MSGSENDSUPER "objc_msg_lookup_super" + +/* GNU-specific tags. */ + +#define TAG_EXECCLASS "__objc_exec_class" +#define TAG_GNUINIT "__objc_gnu_init" + +/* The version identifies which language generation and runtime + the module (file) was compiled for, and is recorded in the + module descriptor. */ +#define OBJC_VERSION 8 + +#define PROTOCOL_VERSION 2 + +/* This macro provides a method of removing ambiguity between runtimes + when LTO is in use on targets supporting multiple runtimes. + + For example, at present, any target that includes an implementation of + the NeXT runtime needs to place Objective-C meta-data into specific + named sections. This should _not_ be done for the GNU runtime, and the + folowing macro is used to attach Objective-C private attributes that may + be used to identify the runtime for which the meta-data are intended. */ + +#define OBJCMETA(DECL,VERS,KIND) \ + if (VERS) \ + DECL_ATTRIBUTES (DECL) = build_tree_list ((VERS), (KIND)); + +static void gnu_runtime_01_initialize (void); + +static void build_selector_template (void); + +static tree gnu_runtime_abi_01_super_superclassfield_id (void); + +static tree gnu_runtime_abi_01_class_decl (tree); +static tree gnu_runtime_abi_01_metaclass_decl (tree); +static tree gnu_runtime_abi_01_category_decl (tree); +static tree gnu_runtime_abi_01_protocol_decl (tree); +static tree gnu_runtime_abi_01_string_decl (tree, const char *, string_section); + +static tree gnu_runtime_abi_01_get_class_reference (tree); +static tree gnu_runtime_abi_01_build_typed_selector_reference (location_t, tree, + tree); +static tree gnu_runtime_abi_01_get_protocol_reference (location_t, tree); +static tree gnu_runtime_abi_01_build_ivar_ref (location_t, tree, tree); +static tree gnu_runtime_abi_01_get_class_super_ref (location_t, struct imp_entry *, bool); +static tree gnu_runtime_abi_01_get_category_super_ref (location_t, struct imp_entry *, bool); + +static tree gnu_runtime_abi_01_receiver_is_class_object (tree); +static tree gnu_runtime_abi_01_get_arg_type_list_base (tree, int, int); +static tree gnu_runtime_abi_01_build_objc_method_call (location_t, tree, tree, + tree, tree, tree, int); + +static bool gnu_runtime_abi_01_setup_const_string_class_decl (void); +static tree gnu_runtime_abi_01_build_const_string_constructor (location_t, tree,int); + +static void objc_generate_v1_gnu_metadata (void); + +static tree objc_eh_runtime_type (tree type); +static tree objc_eh_personality (void); +static tree objc_build_exc_ptr (struct objc_try_context **); +static tree build_throw_stmt (location_t, tree, bool); +static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool); +static void finish_catch (struct objc_try_context **, tree); +static tree finish_try_stmt (struct objc_try_context **); + +bool +objc_gnu_runtime_abi_01_init (objc_runtime_hooks *rthooks) +{ + /* GNU runtime does not need the compiler to change code in order to do GC. */ + if (flag_objc_gc) + { + warning_at (0, 0, "%<-fobjc-gc%> is ignored for %<-fgnu-runtime%>"); + flag_objc_gc = 0; + } + + /* Although I guess we could, we don't currently support SJLJ exceptions for the + GNU runtime. */ + if (flag_objc_sjlj_exceptions) + { + inform (UNKNOWN_LOCATION, "%<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>"); + flag_objc_sjlj_exceptions = 0; + } + + /* TODO: Complain if -fobjc-abi-version=N was used. */ + + /* TODO: Complain if -fobj-nilcheck was used. */ + + rthooks->initialize = gnu_runtime_01_initialize; + rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME; + rthooks->tag_getclass = TAG_GETCLASS; + rthooks->super_superclassfield_ident = gnu_runtime_abi_01_super_superclassfield_id; + + rthooks->class_decl = gnu_runtime_abi_01_class_decl; + rthooks->metaclass_decl = gnu_runtime_abi_01_metaclass_decl; + rthooks->category_decl = gnu_runtime_abi_01_category_decl; + rthooks->protocol_decl = gnu_runtime_abi_01_protocol_decl; + rthooks->string_decl = gnu_runtime_abi_01_string_decl; + + rthooks->get_class_reference = gnu_runtime_abi_01_get_class_reference; + rthooks->build_selector_reference = gnu_runtime_abi_01_build_typed_selector_reference; + rthooks->get_protocol_reference = gnu_runtime_abi_01_get_protocol_reference; + rthooks->build_ivar_reference = gnu_runtime_abi_01_build_ivar_ref; + rthooks->get_class_super_ref = gnu_runtime_abi_01_get_class_super_ref; + rthooks->get_category_super_ref = gnu_runtime_abi_01_get_category_super_ref; + + rthooks->receiver_is_class_object = gnu_runtime_abi_01_receiver_is_class_object; + rthooks->get_arg_type_list_base = gnu_runtime_abi_01_get_arg_type_list_base; + rthooks->build_objc_method_call = gnu_runtime_abi_01_build_objc_method_call; + + rthooks->setup_const_string_class_decl = + gnu_runtime_abi_01_setup_const_string_class_decl; + rthooks->build_const_string_constructor = + gnu_runtime_abi_01_build_const_string_constructor; + + rthooks->build_throw_stmt = build_throw_stmt; + rthooks->build_exc_ptr = objc_build_exc_ptr; + rthooks->begin_catch = begin_catch; + rthooks->finish_catch = finish_catch; + rthooks->finish_try_stmt = finish_try_stmt; + + rthooks->generate_metadata = objc_generate_v1_gnu_metadata; + return true; +} + +static void build_selector_table_decl (void); +static void build_class_template (void); +static void build_category_template (void); +static void build_protocol_template (void); + +static GTY(()) tree objc_meta; +static GTY(()) tree meta_base; + +static void gnu_runtime_01_initialize (void) +{ + tree type, ftype, IMP_type; + + /* We do not need to mark GNU ObjC metadata for different sections, + however, we do need to make sure that it is not mistaken for NeXT + metadata. */ + objc_meta = get_identifier ("OBJC1METG"); + meta_base = get_identifier ("NONE"); + + /* Declare type of selector-objects that represent an operation name. */ + /* `const struct objc_selector *' */ + type = xref_tag (RECORD_TYPE, get_identifier (TAG_SELECTOR)); + type = build_qualified_type (type, TYPE_QUAL_CONST); + objc_selector_type = build_pointer_type (type); + + /* typedef id (*IMP)(id, SEL, ...); */ + ftype = build_varargs_function_type_list (objc_object_type, + objc_object_type, + objc_selector_type, + NULL_TREE); + + IMP_type = build_pointer_type (ftype); + + build_class_template (); + build_super_template (); + build_protocol_template (); + build_category_template (); + + /* GNU runtime messenger entry points. */ + /* TREE_NOTHROW is cleared for the message-sending functions, + because the function that gets called can throw in Obj-C++, or + could itself call something that can throw even in Obj-C. */ + + /* IMP objc_msg_lookup (id, SEL); */ + type = build_function_type_list (IMP_type, + objc_object_type, + objc_selector_type, + NULL_TREE); + + umsg_decl = add_builtin_function (TAG_MSGSEND, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_decl) = 0; + + /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */ + type = build_function_type_list (IMP_type, + objc_super_type, + objc_selector_type, + NULL_TREE); + + umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_super_decl) = 0; + + /* The following GNU runtime entry point is called to initialize + each module: + + __objc_exec_class (void *); */ + type = build_function_type_list (void_type_node, + ptr_type_node, + NULL_TREE); + + execclass_decl = add_builtin_function (TAG_EXECCLASS, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + type = build_function_type_list (objc_object_type, + const_string_type_node, + NULL_TREE); + + /* id objc_getClass (const char *); */ + objc_get_class_decl + = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + /* id objc_getMetaClass (const char *); */ + objc_get_meta_class_decl = add_builtin_function (TAG_GETMETACLASS, type, + 0, NOT_BUILT_IN, NULL, + NULL_TREE); + + /* static SEL _OBJC_SELECTOR_TABLE[]; */ + build_selector_table_decl (); + + /* Stuff for properties. + The codegen relies on this being NULL for GNU. */ + objc_copyStruct_decl = NULL_TREE; + + /* This is the type of all of the following functions + bjc_getPropertyStruct() and objc_setPropertyStruct(). */ + type = build_function_type_list (void_type_node, + ptr_type_node, + const_ptr_type_node, + ptrdiff_type_node, + boolean_type_node, + boolean_type_node, + NULL_TREE); + + /* Declare the following function: + void + objc_getPropertyStruct (void *destination, const void *source, + ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ + objc_getPropertyStruct_decl = add_builtin_function ("objc_getPropertyStruct", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_getPropertyStruct_decl) = 0; + /* Declare the following function: + void + objc_setPropertyStruct (void *destination, const void *source, + ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ + objc_setPropertyStruct_decl = add_builtin_function ("objc_setPropertyStruct", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_setPropertyStruct_decl) = 0; + + using_eh_for_cleanups (); + lang_hooks.eh_runtime_type = objc_eh_runtime_type; + lang_hooks.eh_personality = objc_eh_personality; +} + +/* --- templates --- */ +/* struct _objc_selector { + SEL sel_id; + char *sel_type; + }; */ + +static void +build_selector_template (void) +{ + tree decls, *chain = NULL; + + objc_selector_template = objc_start_struct (get_identifier (UTAG_SELECTOR)); + + /* SEL sel_id; */ + decls = add_field_decl (objc_selector_type, "sel_id", &chain); + + /* char *sel_type; */ + add_field_decl (string_type_node, "sel_type", &chain); + + objc_finish_struct (objc_selector_template, decls); +} + +/* struct _objc_class { + struct _objc_class *isa; + struct _objc_class *super_class; + char *name; + long version; + long info; + long instance_size; + struct _objc_ivar_list *ivars; + struct _objc_method_list *methods; + struct sarray *dtable; + struct _objc_class *subclass_list; + struct _objc_class *sibling_class; + struct _objc_protocol_list *protocols; + void *gc_object_type; + }; */ + +static void +build_class_template (void) +{ + tree ptype, decls, *chain = NULL; + + objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS)); + + /* struct _objc_class *isa; */ + decls = add_field_decl (build_pointer_type (objc_class_template), + "isa", &chain); + + /* struct _objc_class *super_class; */ + add_field_decl (build_pointer_type (objc_class_template), + "super_class", &chain); + + /* char *name; */ + add_field_decl (string_type_node, "name", &chain); + + /* long version; */ + add_field_decl (long_integer_type_node, "version", &chain); + + /* long info; */ + add_field_decl (long_integer_type_node, "info", &chain); + + /* long instance_size; */ + add_field_decl (long_integer_type_node, "instance_size", &chain); + + /* struct _objc_ivar_list *ivars; */ + add_field_decl (objc_ivar_list_ptr,"ivars", &chain); + + /* struct _objc_method_list *methods; */ + add_field_decl (objc_method_list_ptr, "methods", &chain); + + /* struct sarray *dtable; */ + ptype = build_pointer_type(xref_tag (RECORD_TYPE, + get_identifier ("sarray"))); + add_field_decl (ptype, "dtable", &chain); + + /* struct objc_class *subclass_list; */ + ptype = build_pointer_type (objc_class_template); + add_field_decl (ptype, "subclass_list", &chain); + + /* struct objc_class *sibling_class; */ + ptype = build_pointer_type (objc_class_template); + add_field_decl (ptype, "sibling_class", &chain); + + /* struct _objc_protocol **protocol_list; */ + ptype = build_pointer_type (build_pointer_type + (xref_tag (RECORD_TYPE, + get_identifier (UTAG_PROTOCOL)))); + add_field_decl (ptype, "protocol_list", &chain); + + /* void *gc_object_type; */ + add_field_decl (build_pointer_type (void_type_node), + "gc_object_type", &chain); + + objc_finish_struct (objc_class_template, decls); +} + +/* struct _objc_category { + char *category_name; + char *class_name; + struct _objc_method_list *instance_methods; + struct _objc_method_list *class_methods; + struct _objc_protocol_list *protocols; + }; */ + +static void +build_category_template (void) +{ + tree ptype, decls, *chain = NULL; + + objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY)); + + /* char *category_name; */ + decls = add_field_decl (string_type_node, "category_name", &chain); + + /* char *class_name; */ + add_field_decl (string_type_node, "class_name", &chain); + + /* struct _objc_method_list *instance_methods; */ + add_field_decl (objc_method_list_ptr, "instance_methods", &chain); + + /* struct _objc_method_list *class_methods; */ + add_field_decl (objc_method_list_ptr, "class_methods", &chain); + + /* struct _objc_protocol **protocol_list; */ + ptype = build_pointer_type (build_pointer_type (objc_protocol_template)); + add_field_decl (ptype, "protocol_list", &chain); + + objc_finish_struct (objc_category_template, decls); +} + +/* struct _objc_protocol { + struct _objc_class *isa; + char *protocol_name; + struct _objc_protocol **protocol_list; + struct _objc__method_prototype_list *instance_methods; + struct _objc__method_prototype_list *class_methods; + }; */ + +static void +build_protocol_template (void) +{ + tree ptype, decls, *chain = NULL; + + objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL)); + + /* struct _objc_class *isa; */ + ptype = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_CLASS))); + decls = add_field_decl (ptype, "isa", &chain); + + /* char *protocol_name; */ + add_field_decl (string_type_node, "protocol_name", &chain); + + /* struct _objc_protocol **protocol_list; */ + ptype = build_pointer_type (build_pointer_type (objc_protocol_template)); + add_field_decl (ptype, "protocol_list", &chain); + + /* struct _objc__method_prototype_list *instance_methods; */ + add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain); + + /* struct _objc__method_prototype_list *class_methods; */ + add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain); + + objc_finish_struct (objc_protocol_template, decls); +} + +/* --- names, decls + identifers --- */ + +static void +build_selector_table_decl (void) +{ + tree temp; + + build_selector_template (); + temp = build_array_type (objc_selector_template, NULL_TREE); + + UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE"); + OBJCMETA (UOBJC_SELECTOR_TABLE_decl, objc_meta, meta_base); +} + + +static tree +gnu_runtime_abi_01_super_superclassfield_id (void) +{ + if (!super_superclassfield_id) + super_superclassfield_id = get_identifier ("super_class"); + return super_superclassfield_id; +} + + +static tree +gnu_runtime_abi_01_class_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_Class_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_class_template, buf); + OBJCMETA (decl, objc_meta, meta_base); + return decl; +} + +static tree +gnu_runtime_abi_01_metaclass_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_MetaClass_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_class_template, buf); + OBJCMETA (decl, objc_meta, meta_base); + return decl; +} + +static tree +gnu_runtime_abi_01_category_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s", + IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)), + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_category_template, buf); + OBJCMETA (decl, objc_meta, meta_base); + return decl; +} + +static tree +gnu_runtime_abi_01_protocol_decl (tree p) +{ + tree decl; + char buf[BUFSIZE]; + + /* static struct _objc_protocol _OBJC_Protocol_; */ + snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (p))); + decl = start_var_decl (objc_protocol_template, buf); + OBJCMETA (decl, objc_meta, meta_base); + return decl; +} + +static tree +gnu_runtime_abi_01_string_decl (tree type, const char *name, + string_section where ATTRIBUTE_UNUSED) +{ + tree decl = start_var_decl (type, name); + OBJCMETA (decl, objc_meta, meta_base); + return decl; +} + +/* --- entry --- */ + +static tree +gnu_runtime_abi_01_get_class_reference (tree ident) +{ + tree params; + + add_class_reference (ident); + + params = build_tree_list (NULL_TREE, my_build_string_pointer + (IDENTIFIER_LENGTH (ident) + 1, + IDENTIFIER_POINTER (ident))); + + /* FIXME: Do we need this assemble_external() ? */ + /* assemble_external (objc_get_class_decl);*/ + return build_function_call (input_location, objc_get_class_decl, params); +} + +/* Used by get_arg_type_list. + Return the types for receiver & _cmd at the start of a method argument list. + context is either METHOD_DEF or METHOD_REF, saying whether we are trying + to define a method or call one. superflag says this is for a send to super. + meth may be NULL, in the case that there is no prototype. */ + +static tree +gnu_runtime_abi_01_get_arg_type_list_base (tree meth, int context, + int superflag ATTRIBUTE_UNUSED) +{ + tree arglist; + + /* Receiver type. */ + if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL) + arglist = build_tree_list (NULL_TREE, objc_instance_type); + else + arglist = build_tree_list (NULL_TREE, objc_object_type); + + /* Selector type - will eventually change to `int'. */ + chainon (arglist, build_tree_list (NULL_TREE, objc_selector_type)); + return arglist; +} + +/* Unused for GNU runtime. */ +static tree +gnu_runtime_abi_01_receiver_is_class_object (tree a ATTRIBUTE_UNUSED) +{ + return NULL_TREE; +} + +/* sel_ref_chain is a list whose "value" fields will be instances of + identifier_node that represent the selector. LOC is the location of + the @selector. */ + +static tree +gnu_runtime_abi_01_build_typed_selector_reference (location_t loc, tree ident, + tree prototype) +{ + tree *chain = &sel_ref_chain; + tree expr; + int index = 0; + + while (*chain) + { + /* When we do a lookup for @selector () we have no idea of the + prototype - so match the first we find. */ + if (TREE_VALUE (*chain) == ident + && (!prototype || TREE_PURPOSE (*chain) == prototype)) + goto return_at_index; + + index++; + chain = &TREE_CHAIN (*chain); + } + + *chain = tree_cons (prototype, ident, NULL_TREE); + + /* TODO: Use a vec and keep this in it to (a) avoid re-creating and + (b) provide better diagnostics for the first time an undefined + selector is used. */ + return_at_index: + expr = build_unary_op (loc, ADDR_EXPR, + build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl, + build_int_cst (NULL_TREE, index)), + 1); + return convert (objc_selector_type, expr); +} + +/* Build a tree expression to send OBJECT the operation SELECTOR, + looking up the method on object LOOKUP_OBJECT (often same as OBJECT), + assuming the method has prototype METHOD_PROTOTYPE. + (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.) + LOC is the location of the expression to build. + Use METHOD_PARAMS as list of args to pass to the method. + If SUPER_FLAG is nonzero, we look up the superclass's method. */ + +static tree +build_objc_method_call (location_t loc, int super_flag, tree method_prototype, + tree lookup_object, tree selector, + tree method_params) +{ + tree sender = (super_flag ? umsg_super_decl + : (flag_objc_direct_dispatch ? umsg_fast_decl + : umsg_decl)); + tree rcv_p = (super_flag ? objc_super_type : objc_object_type); + VEC(tree, gc) *parms; + VEC(tree, gc) *tv; + unsigned nparm = (method_params ? list_length (method_params) : 0); + + /* If a prototype for the method to be called exists, then cast + the sender's return type and arguments to match that of the method. + Otherwise, leave sender as is. */ + tree ret_type + = (method_prototype + ? TREE_VALUE (TREE_TYPE (method_prototype)) + : objc_object_type); + + tree method_param_types = + get_arg_type_list (method_prototype, METHOD_REF, super_flag); + tree ftype = build_function_type (ret_type, method_param_types); + tree sender_cast; + tree method, t; + + if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype)) + ftype = build_type_attribute_variant (ftype, + METHOD_TYPE_ATTRIBUTES + (method_prototype)); + + sender_cast = build_pointer_type (ftype); + + lookup_object = build_c_cast (loc, rcv_p, lookup_object); + + /* Use SAVE_EXPR to avoid evaluating the receiver twice. */ + lookup_object = save_expr (lookup_object); + + /* Param list + 2 slots for object and selector. */ + parms = VEC_alloc (tree, gc, nparm + 2); + tv = VEC_alloc (tree, gc, 2); + + /* First, call the lookup function to get a pointer to the method, + then cast the pointer, then call it with the method arguments. */ + VEC_quick_push (tree, tv, lookup_object); + VEC_quick_push (tree, tv, selector); + method = build_function_call_vec (loc, sender, tv, NULL); + VEC_free (tree, gc, tv); + + /* Pass the appropriate object to the method. */ + VEC_quick_push (tree, parms, (super_flag ? self_decl : lookup_object)); + + /* Pass the selector to the method. */ + VEC_quick_push (tree, parms, selector); + /* Now append the remainder of the parms. */ + if (nparm) + for (; method_params; method_params = TREE_CHAIN (method_params)) + VEC_quick_push (tree, parms, TREE_VALUE (method_params)); + + /* Build an obj_type_ref, with the correct cast for the method call. */ + t = build3 (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node); + t = build_function_call_vec (loc, t, parms, NULL); + VEC_free (tree, gc, parms); + return t; +} + +static tree +gnu_runtime_abi_01_build_objc_method_call (location_t loc, + tree method_prototype, + tree receiver, + tree rtype ATTRIBUTE_UNUSED, + tree sel_name, + tree method_params, + int super ATTRIBUTE_UNUSED) +{ + tree selector = + gnu_runtime_abi_01_build_typed_selector_reference (loc, + sel_name, + method_prototype); + + return build_objc_method_call (loc, super, method_prototype, receiver, + selector, method_params); +} + +static tree +gnu_runtime_abi_01_get_protocol_reference (location_t loc, tree p) +{ + tree expr, protocol_struct_type, *chain; + if (!PROTOCOL_FORWARD_DECL (p)) + PROTOCOL_FORWARD_DECL (p) = gnu_runtime_abi_01_protocol_decl (p); + + expr = build_unary_op (loc, ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0); + + /* ??? Ideally we'd build the reference with objc_protocol_type directly, + if we have it, rather than converting it here. */ + expr = convert (objc_protocol_type, expr); + + /* The @protocol() expression is being compiled into a pointer to a + statically allocated instance of the Protocol class. To become + usable at runtime, the 'isa' pointer of the instance need to be + fixed up at runtime by the runtime library, to point to the + actual 'Protocol' class. */ + + /* For the GNU runtime, put the static Protocol instance in the list + of statically allocated instances, so that we make sure that its + 'isa' pointer is fixed up at runtime by the GNU runtime library + to point to the Protocol class (at runtime, when loading the + module, the GNU runtime library loops on the statically allocated + instances (as found in the defs field in objc_symtab) and fixups + all the 'isa' pointers of those objects). */ + + /* This type is a struct containing the fields of a Protocol + object. (Cfr. objc_protocol_type instead is the type of a pointer + to such a struct). */ + protocol_struct_type = xref_tag (RECORD_TYPE, + get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); + + /* Look for the list of Protocol statically allocated instances + to fixup at runtime. Create a new list to hold Protocol + statically allocated instances, if the list is not found. At + present there is only another list, holding NSConstantString + static instances to be fixed up at runtime. */ + + for (chain = &objc_static_instances; + *chain && TREE_VALUE (*chain) != protocol_struct_type; + chain = &TREE_CHAIN (*chain)); + + if (!*chain) + { + *chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE); + add_objc_string (OBJC_TYPE_NAME (protocol_struct_type), + class_names); + } + + /* Add this statically allocated instance to the Protocol list. */ + TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, + PROTOCOL_FORWARD_DECL (p), + TREE_PURPOSE (*chain)); + return expr; +} + +/* For ABI 8 an IVAR is just a fixed offset in the class struct. */ + +static tree +gnu_runtime_abi_01_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED, + tree base, tree id) +{ + return objc_build_component_ref (base, id); +} + +/* We build super class references as we need them (but keep them once + built for the sake of efficiency). */ + +static tree +gnu_runtime_abi_01_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED, + struct imp_entry *imp, bool inst_meth) +{ + if (inst_meth) + { + if (!ucls_super_ref) + ucls_super_ref = + objc_build_component_ref (imp->class_decl, + get_identifier ("super_class")); + return ucls_super_ref; + } + else + { + if (!uucls_super_ref) + uucls_super_ref = + objc_build_component_ref (imp->meta_decl, + get_identifier ("super_class")); + return uucls_super_ref; + } +} + +static tree +gnu_runtime_abi_01_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED, + struct imp_entry *imp, bool inst_meth) +{ + tree super_name = CLASS_SUPER_NAME (imp->imp_template); + tree super_class; + + add_class_reference (super_name); + super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl); + /* FIXME: Do we need this assemble_external() ? */ + /* assemble_external (super_class);*/ + super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1, + IDENTIFIER_POINTER (super_name)); + /* super_class = get_{meta_}class("CLASS_SUPER_NAME"); */ + return build_function_call (input_location, + super_class, + build_tree_list (NULL_TREE, super_name)); +} + +static bool +gnu_runtime_abi_01_setup_const_string_class_decl (void) +{ + /* Do nothing, and create no error. */ + return true; +} + +/* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */ + +static GTY(()) int num_static_inst; + +static tree +objc_add_static_instance (tree constructor, tree class_decl) +{ + tree *chain, decl; + char buf[BUFSIZE]; + + /* Find the list of static instances for the CLASS_DECL. Create one if + not found. */ + for (chain = &objc_static_instances; + *chain && TREE_VALUE (*chain) != class_decl; + chain = &TREE_CHAIN (*chain)); + if (!*chain) + { + *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE); + add_objc_string (OBJC_TYPE_NAME (class_decl), class_names); + } + + snprintf (buf, BUFSIZE, "_OBJC_INSTANCE_%d", num_static_inst++); + decl = build_decl (input_location, + VAR_DECL, get_identifier (buf), class_decl); + TREE_STATIC (decl) = 1; + DECL_ARTIFICIAL (decl) = 1; + TREE_USED (decl) = 1; + DECL_INITIAL (decl) = constructor; + DECL_CONTEXT (decl) = NULL; + OBJCMETA (decl, objc_meta, meta_base); + + /* We may be writing something else just now. + Postpone till end of input. */ + DECL_DEFER_OUTPUT (decl) = 1; + pushdecl_top_level (decl); + rest_of_decl_compilation (decl, 1, 0); + + /* Add the DECL to the head of this CLASS' list. */ + TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain)); + + return decl; +} + +static tree +gnu_runtime_abi_01_build_const_string_constructor (location_t loc, tree string, + int length) +{ + tree constructor, fields; + VEC(constructor_elt,gc) *v = NULL; + + /* GNU: (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length }) */ + fields = TYPE_FIELDS (internal_const_str_type); + CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, 0)); + + fields = DECL_CHAIN (fields); + CONSTRUCTOR_APPEND_ELT (v, fields, build_unary_op (loc, + ADDR_EXPR, string, 1)); + + fields = DECL_CHAIN (fields); + CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length)); + constructor = objc_build_constructor (internal_const_str_type, v); + + constructor = objc_add_static_instance (constructor, constant_string_type); + return constructor; +} + +/* --- metadata - module initializer --- */ + +/* The GNU runtime requires us to provide a static initializer function + for each module: + + static void __objc_gnu_init (void) { + __objc_exec_class (&L_OBJC_MODULES); + } */ + + +static void +build_module_initializer_routine (void) +{ + tree body; + +#ifdef OBJCPLUS + push_lang_context (lang_name_c); /* extern "C" */ +#endif + + objc_push_parm (build_decl (input_location, + PARM_DECL, NULL_TREE, void_type_node)); +#ifdef OBJCPLUS + objc_start_function (get_identifier (TAG_GNUINIT), + build_function_type_list (void_type_node, NULL_TREE), + NULL_TREE, NULL_TREE); +#else + objc_start_function (get_identifier (TAG_GNUINIT), + build_function_type_list (void_type_node, NULL_TREE), + NULL_TREE, objc_get_parm_info (0)); +#endif + body = c_begin_compound_stmt (true); + add_stmt (build_function_call + (input_location, + execclass_decl, + build_tree_list + (NULL_TREE, + build_unary_op (input_location, ADDR_EXPR, + UOBJC_MODULES_decl, 0)))); + add_stmt (c_end_compound_stmt (input_location, body, true)); + + TREE_PUBLIC (current_function_decl) = 0; + +#ifndef OBJCPLUS + /* For Objective-C++, we will need to call __objc_gnu_init + from objc_generate_static_init_call() below. */ + DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1; +#endif + + GNU_INIT_decl = current_function_decl; + finish_function (); + +#ifdef OBJCPLUS + pop_lang_context (); +#endif +} + +#ifdef OBJCPLUS +/* Return 1 if the __objc_gnu_init function has been synthesized and needs + to be called by the module initializer routine. */ + +int +objc_static_init_needed_p (void) +{ + return (GNU_INIT_decl != NULL_TREE); +} + +/* Generate a call to the __objc_gnu_init initializer function. */ + +tree +objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED) +{ + add_stmt (build_stmt (input_location, EXPR_STMT, + build_function_call (input_location, + GNU_INIT_decl, NULL_TREE))); + + return ctors; +} +#endif /* OBJCPLUS */ + +/* --- Output GNU Meta-data --- */ + +static void +generate_classref_translation_entry (tree chain) +{ + tree expr, decl, type; + + decl = TREE_PURPOSE (chain); + type = TREE_TYPE (decl); + + expr = add_objc_string (TREE_VALUE (chain), class_names); + expr = convert (type, expr); /* cast! */ + + /* This is a class reference. It is re-written by the runtime, + but will be optimized away unless we force it. */ + DECL_PRESERVE_P (decl) = 1; + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, expr); + return; +} + + +static void +handle_impent (struct imp_entry *impent) +{ + char *string; + +/* objc_implementation_context = impent->imp_context; + implementation_template = impent->imp_template;*/ + + switch (TREE_CODE (impent->imp_context)) + { + case CLASS_IMPLEMENTATION_TYPE: + { + const char *const class_name = + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)); + + string = (char *) alloca (strlen (class_name) + 30); + + sprintf (string, "__objc_class_name_%s", class_name); + break; + } + case CATEGORY_IMPLEMENTATION_TYPE: + { + const char *const class_name = + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)); + const char *const class_super_name = + IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context)); + + string = (char *) alloca (strlen (class_name) + + strlen (class_super_name) + 30); + + /* Do the same for categories. Even though no references to + these symbols are generated automatically by the compiler, + it gives you a handle to pull them into an archive by + hand. */ + sprintf (string, "*__objc_category_name_%s_%s", class_name, class_super_name); + break; + } + default: + return; + } + + { + tree decl, init; + + init = integer_zero_node; + decl = build_decl (input_location, + VAR_DECL, get_identifier (string), TREE_TYPE (init)); + TREE_PUBLIC (decl) = 1; + TREE_READONLY (decl) = 1; + TREE_USED (decl) = 1; + TREE_CONSTANT (decl) = 1; + DECL_CONTEXT (decl) = NULL_TREE; + DECL_ARTIFICIAL (decl) = 1; + TREE_STATIC (decl) = 1; + DECL_INITIAL (decl) = error_mark_node; /* A real initializer is coming... */ + /* We must force the reference. */ + DECL_PRESERVE_P (decl) = 1; + + finish_var_decl(decl, init) ; + } +} + +tree +build_protocol_initializer (tree type, tree protocol_name, tree protocol_list, + tree inst_methods, tree class_methods) +{ + tree expr, ttyp; + location_t loc; + VEC(constructor_elt,gc) *inits = NULL; + + /* TODO: pass the loc in or find it from args. */ + loc = input_location; + ttyp = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_CLASS))); + /* Filling the "isa" in with a version allows the runtime system to + detect this ... */ + expr = build_int_cst (ttyp, PROTOCOL_VERSION); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list); + + ttyp = objc_method_proto_list_ptr; + if (inst_methods) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + if (class_methods) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + return objc_build_constructor (type, inits); +} + +static tree +generate_protocol_list (tree i_or_p, tree klass_ctxt) +{ + tree array_type, ptype, refs_decl, lproto, e, plist; + VEC(constructor_elt,gc) *v = NULL; + char buf[BUFSIZE]; + int size = 0; + + switch (TREE_CODE (i_or_p)) + { + case CLASS_INTERFACE_TYPE: + case CATEGORY_INTERFACE_TYPE: + plist = CLASS_PROTOCOL_LIST (i_or_p); + break; + case PROTOCOL_INTERFACE_TYPE: + plist = PROTOCOL_LIST (i_or_p); + break; + default: + gcc_unreachable (); + } + + /* Compute size. */ + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto))) + size++; + + /* Build initializer. */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + e = build_int_cst (build_pointer_type (objc_protocol_template), size); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e); + + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + { + tree pval = TREE_VALUE (lproto); + + if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_FORWARD_DECL (pval)) + { + tree fwref = PROTOCOL_FORWARD_DECL (pval); + location_t loc = DECL_SOURCE_LOCATION (fwref) ; + e = build_unary_op (loc, ADDR_EXPR, fwref, 0); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e); + } + } + + /* static struct objc_protocol *refs[n]; */ + + switch (TREE_CODE (i_or_p)) + { + case PROTOCOL_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p))); + break; + case CLASS_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s", + IDENTIFIER_POINTER (CLASS_NAME (i_or_p))); + break; + case CATEGORY_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt))); + break; + default: + gcc_unreachable (); + } + + ptype = build_pointer_type (objc_protocol_template); + array_type = build_sized_array_type (ptype, size + 3); + refs_decl = start_var_decl (array_type, buf); + OBJCMETA (refs_decl, objc_meta, meta_base); + finish_var_decl (refs_decl, + objc_build_constructor (TREE_TYPE (refs_decl), v)); + + return refs_decl; +} + +static tree +generate_v1_meth_descriptor_table (tree chain, tree protocol, const char *prefix) +{ + tree method_list_template, initlist, decl; + int size; + VEC(constructor_elt,gc) *v = NULL; + char buf[BUFSIZE]; + + if (!chain || !prefix) + return NULL_TREE; + + if (!objc_method_prototype_template) + objc_method_prototype_template = build_method_prototype_template (); + + size = list_length (chain); + method_list_template = + build_method_prototype_list_template (objc_method_prototype_template, + size); + snprintf (buf, BUFSIZE, "%s_%s", prefix, + IDENTIFIER_POINTER (PROTOCOL_NAME (protocol))); + + decl = start_var_decl (method_list_template, buf); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); + initlist = + build_descriptor_table_initializer (objc_method_prototype_template, + chain); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, objc_build_constructor (method_list_template, v)); + return decl; +} + +/* For each protocol which was referenced either from a @protocol() + expression, or because a class/category implements it (then a + pointer to the protocol is stored in the struct describing the + class/category), we create a statically allocated instance of the + Protocol class. The code is written in such a way as to generate + as few Protocol objects as possible; we generate a unique Protocol + instance for each protocol, and we don't generate a Protocol + instance if the protocol is never referenced (either from a + @protocol() or from a class/category implementation). These + statically allocated objects can be referred to via the static + (that is, private to this module) symbols _OBJC_PROTOCOL_n. + + The statically allocated Protocol objects that we generate here + need to be fixed up at runtime in order to be used: the 'isa' + pointer of the objects need to be set up to point to the 'Protocol' + class, as known at runtime. + + The GNU runtime fixes up all protocols before user code from the module + is executed; it requires pointers to those symbols + to be put in the objc_symtab (which is then passed as argument to + the function __objc_exec_class() which the compiler sets up to be + executed automatically when the module is loaded); setup of those + Protocol objects happen in two ways in the GNU runtime: all + Protocol objects referred to by a class or category implementation + are fixed up when the class/category is loaded; all Protocol + objects referred to by a @protocol() expression are added by the + compiler to the list of statically allocated instances to fixup + (the same list holding the statically allocated constant string + objects). Because, as explained above, the compiler generates as + few Protocol objects as possible, some Protocol object might end up + being referenced multiple times when compiled with the GNU runtime, + and end up being fixed up multiple times at runtime initialization. + But that doesn't hurt, it's just a little inefficient. */ + +static void +generate_protocols (void) +{ + tree p, encoding; + tree decl; + tree initlist, protocol_name_expr, refs_decl, refs_expr; + + /* If a protocol was directly referenced, pull in indirect references. */ + for (p = protocol_chain; p; p = TREE_CHAIN (p)) + if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p)) + generate_protocol_references (PROTOCOL_LIST (p)); + + for (p = protocol_chain; p; p = TREE_CHAIN (p)) + { + tree nst_methods = PROTOCOL_NST_METHODS (p); + tree cls_methods = PROTOCOL_CLS_METHODS (p); + + /* If protocol wasn't referenced, don't generate any code. */ + decl = PROTOCOL_FORWARD_DECL (p); + + if (!decl) + continue; + + /* Make sure we link in the Protocol class. */ + add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); + + while (nst_methods) + { + if (! METHOD_ENCODING (nst_methods)) + { + encoding = encode_method_prototype (nst_methods); + METHOD_ENCODING (nst_methods) = encoding; + } + nst_methods = DECL_CHAIN (nst_methods); + } + + UOBJC_INSTANCE_METHODS_decl = + generate_v1_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p, + "_OBJC_PROTOCOL_INSTANCE_METHODS"); + + while (cls_methods) + { + if (! METHOD_ENCODING (cls_methods)) + { + encoding = encode_method_prototype (cls_methods); + METHOD_ENCODING (cls_methods) = encoding; + } + + cls_methods = DECL_CHAIN (cls_methods); + } + + UOBJC_CLASS_METHODS_decl = + generate_v1_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p, + "_OBJC_PROTOCOL_CLASS_METHODS"); +/* generate_method_descriptors (p);*/ + + if (PROTOCOL_LIST (p)) + refs_decl = generate_protocol_list (p, NULL_TREE); + else + refs_decl = 0; + + /* static struct objc_protocol _OBJC_PROTOCOL_; */ + protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names); + + if (refs_decl) + refs_expr = convert (build_pointer_type (build_pointer_type + (objc_protocol_template)), + build_unary_op (input_location, + ADDR_EXPR, refs_decl, 0)); + else + refs_expr = build_int_cst (NULL_TREE, 0); + + /* UOBJC_INSTANCE_METHODS_decl/UOBJC_CLASS_METHODS_decl are set + by generate_method_descriptors, which is called above. */ + initlist = build_protocol_initializer (TREE_TYPE (decl), + protocol_name_expr, refs_expr, + UOBJC_INSTANCE_METHODS_decl, + UOBJC_CLASS_METHODS_decl); + finish_var_decl (decl, initlist); + } +} + +static tree +generate_dispatch_table (tree chain, const char *name) +{ + tree decl, method_list_template, initlist; + VEC(constructor_elt,gc) *v = NULL; + int size = list_length (chain); + + if (!objc_method_template) + objc_method_template = build_method_template (); + + method_list_template = build_method_list_template (objc_method_template, + size); + initlist = build_dispatch_table_initializer (objc_method_template, chain); + + decl = start_var_decl (method_list_template, name); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (integer_type_node, size)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); + + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, + objc_build_constructor (TREE_TYPE (decl), v)); + + return decl; +} + +/* Init a category. */ +static tree +build_category_initializer (tree type, tree cat_name, tree class_name, + tree inst_methods, tree class_methods, + tree protocol_list) +{ + tree expr, ltyp; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + + /* TODO: pass the loc in or find it from args. */ + /* TODO: pass the loc in or find it from args. */ + loc = UNKNOWN_LOCATION; + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name); + + ltyp = objc_method_list_ptr; + if (inst_methods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + if (class_methods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* protocol_list = */ + ltyp = build_pointer_type (build_pointer_type (objc_protocol_template)); + if (protocol_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + return objc_build_constructor (type, v); +} + +/* static struct objc_category _OBJC_CATEGORY_ = { ... }; */ + +static void +generate_category (struct imp_entry *impent) +{ + tree initlist, cat_name_expr, class_name_expr; + tree protocol_decl, category, cat_decl; + tree inst_methods = NULL_TREE, class_methods = NULL_TREE; + tree cat = impent->imp_context; + char buf[BUFSIZE]; + + cat_decl = impent->class_decl; + + add_class_reference (CLASS_NAME (cat)); + cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names); + + class_name_expr = add_objc_string (CLASS_NAME (cat), class_names); + + category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat)); + + if (category && CLASS_PROTOCOL_LIST (category)) + { + generate_protocol_references (CLASS_PROTOCOL_LIST (category)); + protocol_decl = generate_protocol_list (category, cat); + } + else + protocol_decl = 0; + + if (CLASS_NST_METHODS (cat)) + { + snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (cat)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); + inst_methods = generate_dispatch_table (CLASS_NST_METHODS (cat), buf); + } + + if (CLASS_CLS_METHODS (cat)) + { + snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (cat)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); + class_methods = generate_dispatch_table (CLASS_CLS_METHODS (cat), buf); + } + + initlist = build_category_initializer (TREE_TYPE (cat_decl), + cat_name_expr, class_name_expr, + inst_methods, class_methods, + protocol_decl); + /* Finish and initialize the forward decl. */ + finish_var_decl (cat_decl, initlist); + impent->class_decl = cat_decl; +} + +/* struct _objc_class { + struct objc_class *isa; + struct objc_class *super_class; + char *name; + long version; + long info; + long instance_size; + struct objc_ivar_list *ivars; + struct objc_method_list *methods; + struct sarray *dtable; + struct objc_class *subclass_list; + struct objc_class *sibling_class; + struct objc_protocol_list *protocols; + void *gc_object_type; + }; */ + +static tree +build_shared_structure_initializer (tree type, tree isa, tree super, + tree name, tree size, int status, + tree dispatch_table, tree ivar_list, + tree protocol_list) +{ + tree expr, ltyp; + VEC(constructor_elt,gc) *v = NULL; + + /* isa = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, isa); + + /* super_class = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, super); + + /* name = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, default_conversion (name)); + + /* version = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (long_integer_type_node, 0)); + + /* info = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (long_integer_type_node, status)); + + /* instance_size = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + convert (long_integer_type_node, size)); + + /* objc_ivar_list = */ + if (!ivar_list) + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (objc_ivar_list_ptr, 0)); + else + { + expr = convert (objc_ivar_list_ptr, + build_unary_op (input_location, ADDR_EXPR, + ivar_list, 0)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + + /* objc_method_list = */ + if (!dispatch_table) + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + convert (objc_method_list_ptr, null_pointer_node)); + else + { + expr = convert (objc_method_list_ptr, + build_unary_op (input_location, ADDR_EXPR, + dispatch_table, 0)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + + /* FIXME: Remove NeXT runtime code. */ + if (flag_next_runtime) + { + ltyp = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("objc_cache"))); + /* method_cache = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, convert (ltyp, null_pointer_node)); + } + else + { + /* dtable = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + + /* subclass_list = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + + /* sibling_class = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + } + + /* protocol_list = */ + ltyp = build_pointer_type (build_pointer_type (objc_protocol_template)); + if (! protocol_list) + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (ltyp, 0)); + else + { + expr = convert (ltyp, + build_unary_op (input_location, ADDR_EXPR, + protocol_list, 0)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + + /* FIXME: Remove NeXT runtime code. */ + if (flag_next_runtime) + /* sel_id = NULL */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + + /* gc_object_type = NULL */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + + return objc_build_constructor (type, v); +} + + +static tree +generate_ivars_list (tree chain, const char *name) +{ + tree initlist, ivar_list_template, decl; + int size; + VEC(constructor_elt,gc) *inits = NULL; + + if (!chain) + return NULL_TREE; + + if (!objc_ivar_template) + objc_ivar_template = build_ivar_template (); + + size = ivar_list_length (chain); + + generating_instance_variables = 1; + ivar_list_template = build_ivar_list_template (objc_ivar_template, size); + initlist = build_ivar_list_initializer (objc_ivar_template, chain); + generating_instance_variables = 0; + + decl = start_var_decl (ivar_list_template, name); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); + + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, + objc_build_constructor (TREE_TYPE (decl), inits)); + + return decl; +} + +/* static struct objc_class _OBJC_METACLASS_Foo={ ... }; + static struct objc_class _OBJC_CLASS_Foo={ ... }; */ + +static void +generate_class_structures (struct imp_entry *impent) +{ + tree name_expr, super_expr, root_expr, class_decl, meta_decl; + tree my_root_id, my_super_id; + tree cast_type, initlist, protocol_decl; + tree inst_methods = NULL_TREE, class_methods = NULL_TREE; + tree chain, inst_ivars = NULL_TREE, class_ivars = NULL_TREE; + location_t loc; + char buf[BUFSIZE]; + int cls_flags = 0 ; + +/* objc_implementation_context = impent->imp_context; + implementation_template = impent->imp_template;*/ + class_decl = impent->class_decl; + meta_decl = impent->meta_decl; +/* UOBJC_CLASS_decl = impent->class_decl; + UOBJC_METACLASS_decl = impent->meta_decl;*/ + + loc = DECL_SOURCE_LOCATION (impent->class_decl); + + my_super_id = CLASS_SUPER_NAME (impent->imp_template); + if (my_super_id) + { + add_class_reference (my_super_id); + + /* Compute "my_root_id" - this is required for code generation. + the "isa" for all meta class structures points to the root of + the inheritance hierarchy (e.g. "__Object")... */ + my_root_id = my_super_id; + do + { + tree my_root_int = lookup_interface (my_root_id); + + if (my_root_int && CLASS_SUPER_NAME (my_root_int)) + my_root_id = CLASS_SUPER_NAME (my_root_int); + else + break; + } + while (1); + } + else + /* No super class. */ + my_root_id = CLASS_NAME (impent->imp_template); + + cast_type = build_pointer_type (objc_class_template); + name_expr = add_objc_string (CLASS_NAME (impent->imp_template), + class_names); + + /* Install class `isa' and `super' pointers at runtime. */ + if (my_super_id) + super_expr = add_objc_string (my_super_id, class_names); + else + super_expr = null_pointer_node; + + super_expr = build_c_cast (loc, cast_type, super_expr); + + root_expr = add_objc_string (my_root_id, class_names); + root_expr = build_c_cast (loc, cast_type, root_expr); + + if (CLASS_PROTOCOL_LIST (impent->imp_template)) + { + generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template)); + protocol_decl = generate_protocol_list (impent->imp_template, + impent->imp_context); + } + else + protocol_decl = NULL_TREE; + + if (CLASS_CLS_METHODS (impent->imp_context)) + { + snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + class_methods = generate_dispatch_table (CLASS_CLS_METHODS (impent->imp_context), + buf); + } + + if (CLASS_SUPER_NAME (impent->imp_template) == NULL_TREE + && (chain = TYPE_FIELDS (objc_class_template))) + { + snprintf (buf, BUFSIZE, "_OBJC_ClassIvars_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + class_ivars = generate_ivars_list (chain, buf); + } + + /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */ + + initlist = + build_shared_structure_initializer + (TREE_TYPE (meta_decl), + root_expr, super_expr, name_expr, + convert (integer_type_node, + TYPE_SIZE_UNIT (objc_class_template)), + CLS_META, class_methods, class_ivars, + protocol_decl); + + finish_var_decl (meta_decl, initlist); + impent->meta_decl = meta_decl; + + /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */ + if (CLASS_NST_METHODS (impent->imp_context)) + { + snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + inst_methods = generate_dispatch_table (CLASS_NST_METHODS (impent->imp_context), + buf); + } + + if ((chain = CLASS_IVARS (impent->imp_template))) + { + snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + inst_ivars = generate_ivars_list (chain, buf); + } + + initlist = + build_shared_structure_initializer + (TREE_TYPE (class_decl), + build_unary_op (loc, ADDR_EXPR, meta_decl, 0), + super_expr, name_expr, + convert (integer_type_node, + TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE + (impent->imp_template))), + CLS_FACTORY | cls_flags, inst_methods, inst_ivars, + protocol_decl); + + finish_var_decl (class_decl, initlist); + impent->class_decl = class_decl; +} + +/* --- Output GNU Metadata --- */ + +/* TODO: Make this into an array of refs. */ +static void +handle_class_ref (tree chain) +{ + const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain)); + char *string = (char *) alloca (strlen (name) + 30); + tree decl; + tree exp; + + sprintf (string, "__objc_class_name_%s", name); + + /* Make a decl for this name, so we can use its address in a tree. */ + decl = build_decl (input_location, + VAR_DECL, get_identifier (string), TREE_TYPE (integer_zero_node)); + DECL_EXTERNAL (decl) = 1; + TREE_PUBLIC (decl) = 1; + DECL_CONTEXT (decl) = NULL_TREE; + finish_var_decl (decl, 0); + + /* Make a decl for the address. */ + sprintf (string, "__objc_class_ref_%s", name); + exp = build1 (ADDR_EXPR, string_type_node, decl); + decl = build_decl (input_location, + VAR_DECL, get_identifier (string), string_type_node); + TREE_STATIC (decl) = 1; + TREE_USED (decl) = 1; + DECL_READ_P (decl) = 1; + DECL_ARTIFICIAL (decl) = 1; + DECL_INITIAL (decl) = error_mark_node; + + /* We must force the reference. */ + DECL_PRESERVE_P (decl) = 1; + + DECL_CONTEXT (decl) = NULL_TREE; + finish_var_decl (decl, exp); +} + +static tree +get_proto_encoding (tree proto) +{ + tree encoding; + if (proto) + { + if (! METHOD_ENCODING (proto)) + { + encoding = encode_method_prototype (proto); + METHOD_ENCODING (proto) = encoding; + } + else + encoding = METHOD_ENCODING (proto); + + return add_objc_string (encoding, meth_var_types); + } + else + return build_int_cst (NULL_TREE, 0); +} + +static void +build_gnu_selector_translation_table (void) +{ + tree chain, expr; + VEC(constructor_elt,gc) *inits = NULL; + VEC(constructor_elt,gc) *v ; + + /* Cause the selector table (previously forward-declared) + to be actually output. */ + + for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain)) + { + tree encoding; + if (warn_selector) + { + /* TODO: improve on the location for the diagnostic. */ + location_t loc = input_location; + diagnose_missing_method (TREE_VALUE (chain), loc); + } + + v = NULL; + expr = build_selector (TREE_VALUE (chain)); + encoding = get_proto_encoding (TREE_PURPOSE (chain)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, encoding); + expr = objc_build_constructor (objc_selector_template, v); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + } /* each element in the chain */ + + /* List terminator. */ + v = NULL; + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); + expr = objc_build_constructor (objc_selector_template, v); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + expr = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl), + inits); + finish_var_decl (UOBJC_SELECTOR_TABLE_decl, expr); +} + +/* Output references to all statically allocated objects. Return the DECL + for the array built. */ + +static void +generate_static_references (void) +{ + tree expr = NULL_TREE; + tree class_name, klass, decl; + tree cl_chain, in_chain, type + = build_array_type (build_pointer_type (void_type_node), NULL_TREE); + int num_inst, num_class; + char buf[BUFSIZE]; + VEC(constructor_elt,gc) *decls = NULL; + + /* FIXME: Remove NeXT runtime code. */ + if (flag_next_runtime) + gcc_unreachable (); + + for (cl_chain = objc_static_instances, num_class = 0; + cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++) + { + VEC(constructor_elt,gc) *v = NULL; + + for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain); + in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain)); + + snprintf (buf, BUFSIZE, "_OBJC_STATIC_INSTANCES_%d", num_class); + decl = start_var_decl (type, buf); + + /* Output {class_name, ...}. */ + klass = TREE_VALUE (cl_chain); + class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_unary_op (input_location, + ADDR_EXPR, class_name, 1)); + + /* Output {..., instance, ...}. */ + for (in_chain = TREE_PURPOSE (cl_chain); + in_chain; in_chain = TREE_CHAIN (in_chain)) + { + expr = build_unary_op (input_location, + ADDR_EXPR, TREE_VALUE (in_chain), 1); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + + /* Output {..., NULL}. */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + + expr = objc_build_constructor (TREE_TYPE (decl), v); + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, expr); + CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE, + build_unary_op (input_location, + ADDR_EXPR, decl, 1)); + } + + CONSTRUCTOR_APPEND_ELT (decls, NULL_TREE, build_int_cst (NULL_TREE, 0)); + expr = objc_build_constructor (type, decls); + static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES"); + OBJCMETA (static_instances_decl, objc_meta, meta_base); + finish_var_decl (static_instances_decl, expr); +} + +/* Create the initial value for the `defs' field of _objc_symtab. + This is a CONSTRUCTOR. */ + +static tree +init_def_list (tree type) +{ + tree expr; + struct imp_entry *impent; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + + if (imp_count) + for (impent = imp_list; impent; impent = impent->next) + { + if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) + { + loc = DECL_SOURCE_LOCATION (impent->class_decl); + expr = build_unary_op (loc, + ADDR_EXPR, impent->class_decl, 0); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + } + + if (cat_count) + for (impent = imp_list; impent; impent = impent->next) + { + if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE) + { + loc = DECL_SOURCE_LOCATION (impent->class_decl); + expr = build_unary_op (loc, + ADDR_EXPR, impent->class_decl, 0); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + } + + loc = UNKNOWN_LOCATION; + /* statics = { ..., _OBJC_STATIC_INSTANCES, ... } */ + if (static_instances_decl) + expr = build_unary_op (loc, ADDR_EXPR, static_instances_decl, 0); + else + expr = integer_zero_node; + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + return objc_build_constructor (type, v); +} + +/* Take care of defining and initializing _OBJC_SYMBOLS. */ + +/* Predefine the following data type: + + struct _objc_symtab + { + long sel_ref_cnt; + SEL *refs; + short cls_def_cnt; + short cat_def_cnt; + void *defs[cls_def_cnt + cat_def_cnt]; + }; */ + +static void +build_objc_symtab_template (void) +{ + tree fields, array_type, *chain = NULL; + int index; + + objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB)); + + /* long sel_ref_cnt; */ + fields = add_field_decl (long_integer_type_node, "sel_ref_cnt", &chain); + + /* SEL *refs; */ + add_field_decl (build_pointer_type (objc_selector_type), "refs", &chain); + + /* short cls_def_cnt; */ + add_field_decl (short_integer_type_node, "cls_def_cnt", &chain); + + /* short cat_def_cnt; */ + add_field_decl (short_integer_type_node, "cat_def_cnt", &chain); + + /* Note that padding will be added here on LP64. */ + + /* void *defs[imp_count + cat_count (+ 1)]; */ + /* NB: The index is one less than the size of the array. */ + index = imp_count + cat_count; + array_type = build_sized_array_type (ptr_type_node, index + 1); + add_field_decl (array_type, "defs", &chain); + + objc_finish_struct (objc_symtab_template, fields); +} +/* Construct the initial value for all of _objc_symtab. */ + +static tree +init_objc_symtab (tree type) +{ + tree field, expr, ltyp; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + + loc = UNKNOWN_LOCATION; + + /* sel_ref_cnt = { ..., 5, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (long_integer_type_node, 0)); + + /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */ + + ltyp = build_pointer_type (objc_selector_type); + if (sel_ref_chain) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, + UOBJC_SELECTOR_TABLE_decl, 1)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* cls_def_cnt = { ..., 5, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (short_integer_type_node, imp_count)); + + /* cat_def_cnt = { ..., 5, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (short_integer_type_node, cat_count)); + + /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */ + + field = TYPE_FIELDS (type); + field = DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (field)))); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init_def_list (TREE_TYPE (field))); + + return objc_build_constructor (type, v); +} + +/* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab' + and initialized appropriately. */ + +static void +generate_objc_symtab_decl (void) +{ + build_objc_symtab_template (); + UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS"); + OBJCMETA (UOBJC_SYMBOLS_decl, objc_meta, meta_base); + finish_var_decl (UOBJC_SYMBOLS_decl, + init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl))); +} + +static void +objc_generate_v1_gnu_metadata (void) +{ + struct imp_entry *impent; + tree chain; + + /* Process the static instances here because initialization of objc_symtab + depends on them. */ + if (objc_static_instances) + generate_static_references (); + + objc_implementation_context = + implementation_template = + UOBJC_CLASS_decl = + UOBJC_METACLASS_decl = NULL_TREE; + + for (impent = imp_list; impent; impent = impent->next) + { + /* If -gen-decls is present, Dump the @interface of each class. + TODO: Dump the classes in the order they were found, rather than in + reverse order as we are doing now. */ + if (flag_gen_declaration) + dump_interface (gen_declaration_file, impent->imp_context); + + /* all of the following reference the string pool... */ + if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) + generate_class_structures (impent); + else + generate_category (impent); + } + + /* If we are using an array of selectors, we must always + finish up the array decl even if no selectors were used. */ + build_gnu_selector_translation_table (); + + if (protocol_chain) + generate_protocols (); + + /* Arrange for ObjC data structures to be initialized at run time. */ + /* FIXME: Have some more elegant way to determine if we need to + generate objc_symtab_decl or not, instead of checking these + global symbols. */ + if (imp_list || class_names_chain + || meth_var_names_chain || meth_var_types_chain || sel_ref_chain + || prop_names_attr_chain) + generate_objc_symtab_decl (); + + if (imp_list || class_names_chain || objc_static_instances + || meth_var_names_chain || meth_var_types_chain || sel_ref_chain) + { + /* Make sure that the meta-data are identified as being + GNU-runtime. */ + build_module_descriptor (OBJC_VERSION, + build_tree_list (objc_meta, meta_base)); + build_module_initializer_routine (); + } + + /* Dump the class references. This forces the appropriate classes + to be linked into the executable image, preserving unix archive + semantics. This can be removed when we move to a more dynamically + linked environment. */ + + for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain)) + { + handle_class_ref (chain); + if (TREE_PURPOSE (chain)) + generate_classref_translation_entry (chain); + } + + for (impent = imp_list; impent; impent = impent->next) + handle_impent (impent); + + generate_strings (); +} + +/* --- exceptions --- */ + +static GTY(()) tree objc_eh_personality_decl; + +static tree +objc_eh_runtime_type (tree type) +{ + tree ident, eh_id, decl, str; + + if (type == error_mark_node + || errorcount || sorrycount) + { + /* Use 'ErrorMarkNode' as class name when error_mark_node is found + to prevent an ICE. Note that we know that the compiler will + terminate with an error and this 'ErrorMarkNode' class name will + never be actually used. */ + ident = get_identifier ("ErrorMarkNode"); + goto make_err_class; + } + + if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) + /* We don't want to identify 'id' for GNU. Instead, build a 0 + entry in the exceptions table. */ + return null_pointer_node; + + if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type))) + { +#ifdef OBJCPLUS + /* This routine is also called for c++ catch clauses; in which case, + we use the c++ typeinfo decl. */ + return build_eh_type_type (type); +#else + error ("non-objective-c type '%T' cannot be caught", type); + ident = get_identifier ("ErrorMarkNode"); + goto make_err_class; +#endif + } + else + ident = OBJC_TYPE_NAME (TREE_TYPE (type)); + +make_err_class: + /* If this class was already referenced, then it will be output during + meta-data emission, so we don't need to do it here. */ + decl = get_objc_string_decl (ident, class_names); + eh_id = add_objc_string (ident, class_names); + if (!decl) + { + /* Not found ... so we need to build it - from the freshly-entered id. */ + decl = get_objc_string_decl (ident, class_names); + str = my_build_string (IDENTIFIER_LENGTH (ident) + 1, + IDENTIFIER_POINTER (ident)); + /* We have to finalize this var here, because this might be called after + all the other metadata strings have been emitted. */ + finish_var_decl (decl, str); + } + return eh_id; +} + +static tree +objc_eh_personality (void) +{ + if (!objc_eh_personality_decl) +#ifndef OBJCPLUS + objc_eh_personality_decl = build_personality_function ("gnu_objc"); +#else + objc_eh_personality_decl = build_personality_function ("gxx"); +#endif + return objc_eh_personality_decl; +} + +/* -- interfaces --- */ + +static tree +build_throw_stmt (location_t loc, tree throw_expr, bool rethrown ATTRIBUTE_UNUSED) +{ + tree t; + VEC(tree, gc) *parms = VEC_alloc (tree, gc, 1); + /* A throw is just a call to the runtime throw function with the + object as a parameter. */ + VEC_quick_push (tree, parms, throw_expr); + t = build_function_call_vec (loc, objc_exception_throw_decl, parms, NULL); + VEC_free (tree, gc, parms); + return add_stmt (t); +} + +/* Build __builtin_eh_pointer. */ + +static tree +objc_build_exc_ptr (struct objc_try_context **x ATTRIBUTE_UNUSED) +{ + tree t; + t = built_in_decls[BUILT_IN_EH_POINTER]; + t = build_call_expr (t, 1, integer_zero_node); + return fold_convert (objc_object_type, t); +} + +static tree +begin_catch (struct objc_try_context **cur_try_context, tree type, + tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED) +{ + tree t; + /* Record the data for the catch in the try context so that we can + finalize it later. */ + if (ellipsis) + t = build_stmt (input_location, CATCH_EXPR, NULL, compound); + else + t = build_stmt (input_location, CATCH_EXPR, type, compound); + (*cur_try_context)->current_catch = t; + + /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */ + t = objc_build_exc_ptr (cur_try_context); + t = convert (TREE_TYPE (decl), t); + return build2 (MODIFY_EXPR, void_type_node, decl, t); +} + +static void +finish_catch (struct objc_try_context **cur_try_context, tree current_catch) +{ + append_to_statement_list (current_catch, &((*cur_try_context)->catch_list)); +} + +static tree +finish_try_stmt (struct objc_try_context **cur_try_context) +{ + struct objc_try_context *c = *cur_try_context; + tree stmt = c->try_body; + if (c->catch_list) + stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list); + if (c->finally_body) + stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body); + return stmt; +} + +#include "gt-objc-objc-gnu-runtime-abi-01.h" diff --git a/gcc/objc/objc-lang.c b/gcc/objc/objc-lang.c new file mode 100644 index 000000000..fd6577659 --- /dev/null +++ b/gcc/objc/objc-lang.c @@ -0,0 +1,90 @@ +/* Language-dependent hooks for Objective-C. + Copyright 2001, 2002, 2003, 2004, 2005, 2007, 2008, 2010, 2011 + Free Software Foundation, Inc. + Contributed by Ziemowit Laski + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" +#include "c-tree.h" +#include "c-family/c-common.h" +#include "c-family/c-objc.h" +#include "ggc.h" +#include "objc-act.h" +#include "langhooks.h" +#include "langhooks-def.h" +#include "c-objc-common.h" +#include "c-lang.h" + +enum c_language_kind c_language = clk_objc; +static void objc_init_ts (void); + +/* Lang hooks common to C and ObjC are declared in c-objc-common.h; + consequently, there should be very few hooks below. */ + +#undef LANG_HOOKS_NAME +#define LANG_HOOKS_NAME "GNU Objective-C" +#undef LANG_HOOKS_INIT +#define LANG_HOOKS_INIT objc_init +#undef LANG_HOOKS_DECL_PRINTABLE_NAME +#define LANG_HOOKS_DECL_PRINTABLE_NAME objc_printable_name +#undef LANG_HOOKS_GIMPLIFY_EXPR +#define LANG_HOOKS_GIMPLIFY_EXPR objc_gimplify_expr +#undef LANG_HOOKS_INIT_TS +#define LANG_HOOKS_INIT_TS objc_init_ts + +/* Each front end provides its own lang hook initializer. */ +struct lang_hooks lang_hooks = LANG_HOOKS_INITIALIZER; + +/* Lang hook routines common to C and ObjC appear in c-objc-common.c; + there should be very few (if any) routines below. */ + +static void +objc_init_ts (void) +{ + tree_contains_struct[CLASS_METHOD_DECL][TS_DECL_NON_COMMON] = 1; + tree_contains_struct[INSTANCE_METHOD_DECL][TS_DECL_NON_COMMON] = 1; + tree_contains_struct[KEYWORD_DECL][TS_DECL_NON_COMMON] = 1; + tree_contains_struct[PROPERTY_DECL][TS_DECL_NON_COMMON] = 1; + + tree_contains_struct[CLASS_METHOD_DECL][TS_DECL_WITH_VIS] = 1; + tree_contains_struct[INSTANCE_METHOD_DECL][TS_DECL_WITH_VIS] = 1; + tree_contains_struct[KEYWORD_DECL][TS_DECL_WITH_VIS] = 1; + tree_contains_struct[PROPERTY_DECL][TS_DECL_WITH_VIS] = 1; + + tree_contains_struct[CLASS_METHOD_DECL][TS_DECL_WRTL] = 1; + tree_contains_struct[INSTANCE_METHOD_DECL][TS_DECL_WRTL] = 1; + tree_contains_struct[KEYWORD_DECL][TS_DECL_WRTL] = 1; + tree_contains_struct[PROPERTY_DECL][TS_DECL_WRTL] = 1; + + tree_contains_struct[CLASS_METHOD_DECL][TS_DECL_MINIMAL] = 1; + tree_contains_struct[INSTANCE_METHOD_DECL][TS_DECL_MINIMAL] = 1; + tree_contains_struct[KEYWORD_DECL][TS_DECL_MINIMAL] = 1; + tree_contains_struct[PROPERTY_DECL][TS_DECL_MINIMAL] = 1; + + tree_contains_struct[CLASS_METHOD_DECL][TS_DECL_COMMON] = 1; + tree_contains_struct[INSTANCE_METHOD_DECL][TS_DECL_COMMON] = 1; + tree_contains_struct[KEYWORD_DECL][TS_DECL_COMMON] = 1; + tree_contains_struct[PROPERTY_DECL][TS_DECL_COMMON] = 1; +} + +#include "gtype-objc.h" diff --git a/gcc/objc/objc-next-metadata-tags.h b/gcc/objc/objc-next-metadata-tags.h new file mode 100644 index 000000000..db0026ec6 --- /dev/null +++ b/gcc/objc/objc-next-metadata-tags.h @@ -0,0 +1,172 @@ +/* Declarations for meta-data attribute tags. + Copyright (C) 2011 Free Software Foundation, Inc. + Contributed by Iain Sandoe + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +/* These are identifiers used to flag meta-data attributes such that they + survive LTO and might be placed in correct sections for the target. */ + +enum objc_runtime_tree_index +{ + OCTI_RT_OBJC_META, + OCTI_RT_META_BASE, + + OCTI_RT_META_CLASS, + OCTI_RT_META_METACLASS, + OCTI_RT_META_CATEGORY, + OCTI_RT_META_PROTOCOL, + + OCTI_RT_META_CLASS_CLS_VARS, + OCTI_RT_META_CLASS_NST_VARS, + + OCTI_RT_META_CLASS_CLS_METH, + OCTI_RT_META_CLASS_NST_METH, + OCTI_RT_META_CATEG_CLS_METH, + OCTI_RT_META_CATEG_NST_METH, + OCTI_RT_META_PROTO_CLS_METH, + OCTI_RT_META_PROTO_NST_METH, + + OCTI_RT_META_CLASS_PROT, + OCTI_RT_META_CATEG_PROT, + OCTI_RT_META_PROT_REFS, + + OCTI_RT_META_MSG_REFS, + OCTI_RT_META_SEL_REFS, + + OCTI_RT_META_CLSLST_REFS, + OCTI_RT_META_CLASS_REF, + OCTI_RT_META_SUPER_REF, + OCTI_RT_META_CLSLST_NLZY_LAB, + OCTI_RT_META_CLSLST_LAB, + OCTI_RT_META_LAB_PROTOLIST, + OCTI_RT_META_LAB_NLZY_CAT, + OCTI_RT_META_LAB_CAT, + + OCTI_RT_META_PROPERTY_LIST, + OCTI_RT_META_PROTOCOL_EXT, + OCTI_RT_META_CLASS_EXT, + + OCTI_RT_META_CLASS_NAME, + OCTI_RT_META_METHD_NAME, + OCTI_RT_META_METHD_TYPE, + OCTI_RT_META_PROPN_ATTR, + + OCTI_RT_META_MODULES, + OCTI_RT_META_SYMTAB, + OCTI_RT_META_INFO, + + OCTI_RT_META_EHTYPE, + + OCTI_RT_META_CONST_STR, + + OCTI_RT_META_MAX +}; + +/* Tags for the META data so that the backend can put them in the correct + sections for targets/runtimes (Darwin/NeXT) that require this. + This information also survives LTO - which might produce mixed language + output. */ + +/* Objective-C meta data attribute tag */ +#define objc_meta objc_rt_trees[OCTI_RT_OBJC_META] +/* Attribute values, base = default section. */ +#define meta_base objc_rt_trees[OCTI_RT_META_BASE] + + /* CLASS. */ +#define meta_class objc_rt_trees[OCTI_RT_META_CLASS] + /* METACLASS. */ +#define meta_metaclass objc_rt_trees[OCTI_RT_META_METACLASS] + /* CLASS. */ +#define meta_category objc_rt_trees[OCTI_RT_META_CATEGORY] + /* PROTOCOL. */ +#define meta_protocol objc_rt_trees[OCTI_RT_META_PROTOCOL] + + /* Class class vars section. */ +#define meta_clac_vars objc_rt_trees[OCTI_RT_META_CLASS_CLS_VARS] + /* Class instance vars section. */ +#define meta_clai_vars objc_rt_trees[OCTI_RT_META_CLASS_NST_VARS] + /* Class class methods section. */ +#define meta_clac_meth objc_rt_trees[OCTI_RT_META_CLASS_CLS_METH] + /* Class instance methods section. */ +#define meta_clai_meth objc_rt_trees[OCTI_RT_META_CLASS_NST_METH] + /* Category class methods section. */ +#define meta_catc_meth objc_rt_trees[OCTI_RT_META_CATEG_CLS_METH] + /* Category instance methods section. */ +#define meta_cati_meth objc_rt_trees[OCTI_RT_META_CATEG_NST_METH] +#define meta_proto_cls_meth \ + objc_rt_trees[OCTI_RT_META_PROTO_CLS_METH] +#define meta_proto_nst_meth \ + objc_rt_trees[OCTI_RT_META_PROTO_NST_METH] + + /* Class protocols. */ +#define meta_clas_prot objc_rt_trees[OCTI_RT_META_CLASS_PROT] + /* Category protocols. */ +#define meta_catg_prot objc_rt_trees[OCTI_RT_META_CATEG_PROT] + /* Protocol references. */ +#define meta_proto_ref objc_rt_trees[OCTI_RT_META_PROT_REFS] + + /* Message refs. */ +#define meta_mref objc_rt_trees[OCTI_RT_META_MSG_REFS] + /* Selector refs. */ +#define meta_sel_refs objc_rt_trees[OCTI_RT_META_SEL_REFS] + + /* Class list refs. */ +#define meta_class_ref objc_rt_trees[OCTI_RT_META_CLSLST_REFS] +#define meta_class_reference \ + objc_rt_trees[OCTI_RT_META_CLASS_REF] +#define meta_superclass_ref \ + objc_rt_trees[OCTI_RT_META_SUPER_REF] + /* Class list Label. */ +#define meta_label_classlist \ + objc_rt_trees[OCTI_RT_META_CLSLST_LAB] + /* Class list Label (non lazy). */ +#define meta_label_nonlazy_classlist \ + objc_rt_trees[OCTI_RT_META_CLSLST_NLZY_LAB] +#define meta_label_categorylist \ + objc_rt_trees[OCTI_RT_META_LAB_CAT] +#define meta_label_nonlazy_categorylist \ + objc_rt_trees[OCTI_RT_META_LAB_NLZY_CAT] + +#define meta_label_protocollist \ + objc_rt_trees[OCTI_RT_META_LAB_PROTOLIST] + + +/* V1 - property list. */ +#define meta_proplist objc_rt_trees[OCTI_RT_META_PROPERTY_LIST] +#define meta_protocol_extension \ + objc_rt_trees[OCTI_RT_META_PROTOCOL_EXT] +#define meta_class_extension \ + objc_rt_trees[OCTI_RT_META_CLASS_EXT] + /* String sections. */ +#define meta_class_name objc_rt_trees[OCTI_RT_META_CLASS_NAME] +#define meta_meth_name objc_rt_trees[OCTI_RT_META_METHD_NAME] +#define meta_meth_type objc_rt_trees[OCTI_RT_META_METHD_TYPE] +#define meta_prop_name_attr \ + objc_rt_trees[OCTI_RT_META_PROPN_ATTR] + +#define meta_modules objc_rt_trees[OCTI_RT_META_MODULES] +#define meta_symtab objc_rt_trees[OCTI_RT_META_SYMTAB] +#define meta_info objc_rt_trees[OCTI_RT_META_INFO] + +#define meta_ehtype objc_rt_trees[OCTI_RT_META_EHTYPE] + +#define meta_const_str objc_rt_trees[OCTI_RT_META_CONST_STR] + +#define OBJCMETA(DECL,VERS,KIND) \ + if (VERS) \ + DECL_ATTRIBUTES (DECL) = build_tree_list ((VERS), (KIND)); diff --git a/gcc/objc/objc-next-runtime-abi-01.c b/gcc/objc/objc-next-runtime-abi-01.c new file mode 100644 index 000000000..84626b3bc --- /dev/null +++ b/gcc/objc/objc-next-runtime-abi-01.c @@ -0,0 +1,2984 @@ +/* Next Runtime (ABI-0/1) private. + Copyright (C) 2011 Free Software Foundation, Inc. + Contributed by Iain Sandoe (split from objc-act.c) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +/* This implements the original NeXT ABI (0) used for m32 code and + indicated by module version 6. It also implements the small number + of additions made for properties and optional protocol methods as + ABI=1 (module version 7). */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" + +#ifdef OBJCPLUS +#include "cp-tree.h" +#else +#include "c-tree.h" +#include "c-lang.h" +#endif +#include "langhooks.h" +#include "c-family/c-objc.h" +#include "objc-act.h" + +/* When building Objective-C++, we are not linking against the C + front-end and so need to replicate the C tree-construction + functions in some way. */ +#ifdef OBJCPLUS +#define OBJCP_REMAP_FUNCTIONS +#include "objcp-decl.h" +#endif /* OBJCPLUS */ + +#include "ggc.h" +#include "target.h" +#include "output.h" +#include "tree-iterator.h" + +#include "objc-runtime-hooks.h" +#include "objc-runtime-shared-support.h" + +/* NeXT ABI 0 and 1 private definitions. */ +#define DEF_CONSTANT_STRING_CLASS_NAME "NSConstantString" + +#define TAG_GETCLASS "objc_getClass" +#define TAG_GETMETACLASS "objc_getMetaClass" + +#define TAG_MSGSEND "objc_msgSend" +#define TAG_MSGSENDSUPER "objc_msgSendSuper" +#define TAG_MSGSEND_STRET "objc_msgSend_stret" +#define TAG_MSGSENDSUPER_STRET "objc_msgSendSuper_stret" + +/* NeXT-specific tags. */ + +#define TAG_MSGSEND_NONNIL "objc_msgSendNonNil" +#define TAG_MSGSEND_NONNIL_STRET "objc_msgSendNonNil_stret" +#define TAG_EXCEPTIONEXTRACT "objc_exception_extract" +#define TAG_EXCEPTIONTRYENTER "objc_exception_try_enter" +#define TAG_EXCEPTIONTRYEXIT "objc_exception_try_exit" +#define TAG_EXCEPTIONMATCH "objc_exception_match" +#define TAG_SETJMP "_setjmp" + +#define TAG_ASSIGNIVAR "objc_assign_ivar" +#define TAG_ASSIGNGLOBAL "objc_assign_global" +#define TAG_ASSIGNSTRONGCAST "objc_assign_strongCast" + +/* Branch entry points. All that matters here are the addresses; + functions with these names do not really exist in libobjc. */ + +#define TAG_MSGSEND_FAST "objc_msgSend_Fast" +#define TAG_ASSIGNIVAR_FAST "objc_assign_ivar_Fast" + +/* The version identifies which language generation and runtime the + module (file) was compiled for, and is recorded in the module + descriptor. */ +#define OBJC_VERSION (flag_objc_abi >= 1 ? 7 : 6) + +#define UTAG_CLASS_EXT "_objc_class_ext" +#define UTAG_PROPERTY_LIST "_prop_list_t" +#define UTAG_PROTOCOL_EXT "_objc_protocol_extension" + +#define CLS_HAS_CXX_STRUCTORS 0x2000L + +/* rt_trees identifiers - shared between NeXT implementations. These + allow the FE to tag meta-data in a manner that survives LTO and can + be used when the runtime requires that certain meta-data items + appear in particular named sections. */ + +#include "objc-next-metadata-tags.h" +extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX]; + +static void next_runtime_01_initialize (void); + +static tree next_runtime_abi_01_super_superclassfield_id (void); + +static tree next_runtime_abi_01_class_decl (tree); +static tree next_runtime_abi_01_metaclass_decl (tree); +static tree next_runtime_abi_01_category_decl (tree); +static tree next_runtime_abi_01_protocol_decl (tree); +static tree next_runtime_abi_01_string_decl (tree, const char *, string_section); + +static tree next_runtime_abi_01_get_class_reference (tree); +static tree next_runtime_abi_01_build_selector_reference (location_t, tree, tree); +static tree next_runtime_abi_01_get_protocol_reference (location_t, tree); +static tree next_runtime_abi_01_build_ivar_ref (location_t, tree, tree); +static tree next_runtime_abi_01_get_class_super_ref (location_t, struct imp_entry *, bool); +static tree next_runtime_abi_01_get_category_super_ref (location_t, struct imp_entry *, bool); + +static tree next_runtime_abi_01_receiver_is_class_object (tree); +static tree next_runtime_abi_01_get_arg_type_list_base (tree, int, int); +static tree next_runtime_abi_01_build_objc_method_call (location_t, tree, tree, + tree, tree, tree, int); +static bool next_runtime_abi_01_setup_const_string_class_decl (void); +static tree next_runtime_abi_01_build_const_string_constructor (location_t, tree, int); + +static void objc_generate_v1_next_metadata (void); + +static void build_next_objc_exception_stuff (void); +static tree objc_eh_runtime_type (tree type); +static tree objc_eh_personality (void); +static tree build_throw_stmt (location_t, tree, bool); +static tree objc_build_exc_ptr (struct objc_try_context **); +static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool); +static void finish_catch (struct objc_try_context **, tree); +static tree finish_try_stmt (struct objc_try_context **); + +bool +objc_next_runtime_abi_01_init (objc_runtime_hooks *rthooks) +{ + if (flag_objc_exceptions + && !flag_objc_sjlj_exceptions) + { + warning_at (UNKNOWN_LOCATION, OPT_Wall, + "%<-fobjc-sjlj-exceptions%> is the only supported exceptions " + "system for %<-fnext-runtime%> with %<-fobjc-abi-version%> < 2"); + } + + rthooks->initialize = next_runtime_01_initialize; + rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME; + rthooks->tag_getclass = TAG_GETCLASS; + rthooks->super_superclassfield_ident = next_runtime_abi_01_super_superclassfield_id; + + rthooks->class_decl = next_runtime_abi_01_class_decl; + rthooks->metaclass_decl = next_runtime_abi_01_metaclass_decl; + rthooks->category_decl = next_runtime_abi_01_category_decl; + rthooks->protocol_decl = next_runtime_abi_01_protocol_decl; + rthooks->string_decl = next_runtime_abi_01_string_decl; + + rthooks->get_class_reference = next_runtime_abi_01_get_class_reference; + rthooks->build_selector_reference = next_runtime_abi_01_build_selector_reference; + rthooks->get_protocol_reference = next_runtime_abi_01_get_protocol_reference; + rthooks->build_ivar_reference = next_runtime_abi_01_build_ivar_ref; + rthooks->get_class_super_ref = next_runtime_abi_01_get_class_super_ref; + rthooks->get_category_super_ref = next_runtime_abi_01_get_category_super_ref; + + rthooks->receiver_is_class_object = next_runtime_abi_01_receiver_is_class_object; + rthooks->get_arg_type_list_base = next_runtime_abi_01_get_arg_type_list_base; + rthooks->build_objc_method_call = next_runtime_abi_01_build_objc_method_call; + + rthooks->setup_const_string_class_decl = + next_runtime_abi_01_setup_const_string_class_decl; + rthooks->build_const_string_constructor = + next_runtime_abi_01_build_const_string_constructor; + + rthooks->build_throw_stmt = build_throw_stmt; + rthooks->build_exc_ptr = objc_build_exc_ptr; + rthooks->begin_catch = begin_catch; + rthooks->finish_catch = finish_catch; + rthooks->finish_try_stmt = finish_try_stmt; + + rthooks->generate_metadata = objc_generate_v1_next_metadata; + return true; +} + +/* We need a way to convey what kind of meta-data are represented by a + given variable, since each type is expected (by the runtime) to be + found in a specific named section. The solution must be usable + with LTO. + + The scheme used for NeXT ABI 0/1 (partial matching of variable + names) is not satisfactory for LTO & ABI-2. We now tag ObjC + meta-data with identification attributes in the front end. The + back-end may choose to act on these as it requires. */ + +static void +next_runtime_abi_01_init_metadata_attributes (void) +{ + if (!objc_meta) + objc_meta = get_identifier ("OBJC1META"); + + if (!meta_base) + meta_base = get_identifier ("V1_BASE"); + + meta_class = get_identifier ("V1_CLAS"); + meta_metaclass = get_identifier ("V1_META"); + meta_category = get_identifier ("V1_CATG"); + meta_protocol = get_identifier ("V1_PROT"); + + meta_clac_vars = get_identifier ("V1_CLCV"); + meta_clai_vars = get_identifier ("V1_CLIV"); + + meta_clac_meth = get_identifier ("V1_CLCM"); + meta_clai_meth = get_identifier ("V1_CLIM"); + meta_catc_meth = get_identifier ("V1_CACM"); + meta_cati_meth = get_identifier ("V1_CAIM"); + meta_proto_cls_meth = get_identifier ("V1_PCLM"); + meta_proto_nst_meth = get_identifier ("V1_PNSM"); + + meta_clas_prot = get_identifier ("V1_CLPR"); + meta_catg_prot = get_identifier ("V1_CAPR"); + + meta_class_reference = get_identifier ("V1_CLRF"); + meta_proto_ref = get_identifier ("V1_PRFS"); + meta_sel_refs = get_identifier ("V1_SRFS"); + + meta_class_name = get_identifier ("V1_CLSN"); + meta_meth_name = get_identifier ("V1_METN"); + meta_meth_type = get_identifier ("V1_METT"); + meta_prop_name_attr = get_identifier ("V1_STRG"); + + meta_modules = get_identifier ("V1_MODU"); + meta_symtab = get_identifier ("V1_SYMT"); + meta_info = get_identifier ("V1_INFO"); + + meta_proplist = get_identifier ("V1_PLST"); + meta_protocol_extension = get_identifier ("V1_PEXT"); + meta_class_extension = get_identifier ("V1_CEXT"); + + meta_const_str = get_identifier ("V1_CSTR"); +} + +static void build_v1_class_template (void); +static void build_v1_category_template (void); +static void build_v1_protocol_template (void); + +static void next_runtime_01_initialize (void) +{ + tree type; + +#ifdef OBJCPLUS + /* For all NeXT objc ABIs -fobjc-call-cxx-cdtors is on by + default. */ + if (!global_options_set.x_flag_objc_call_cxx_cdtors) + global_options.x_flag_objc_call_cxx_cdtors = 1; +#endif + + /* Set up attributes to be attached to the meta-data so that they + will be placed in the correct sections. */ + next_runtime_abi_01_init_metadata_attributes (); + + if (flag_objc_abi >= 1) + objc_prop_list_ptr = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("_prop_list_t"))); + + /* Declare type of selector-objects that represent an operation + name. */ + /* `struct objc_selector *' */ + objc_selector_type = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (TAG_SELECTOR))); + + build_v1_class_template (); + build_super_template (); + build_v1_protocol_template (); + build_v1_category_template (); + + /* NB: In order to call one of the ..._stret (struct-returning) + functions, the function *MUST* first be cast to a signature that + corresponds to the actual ObjC method being invoked. This is + what is done by the build_objc_method_call() routine below. */ + + /* id objc_msgSend (id, SEL, ...); */ + /* id objc_msgSendNonNil (id, SEL, ...); */ + /* id objc_msgSend_stret (id, SEL, ...); */ + /* id objc_msgSendNonNil_stret (id, SEL, ...); */ + type = build_varargs_function_type_list (objc_object_type, + objc_object_type, + objc_selector_type, + NULL_TREE); + + umsg_decl = add_builtin_function (TAG_MSGSEND, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + /* These can throw, because the function that gets called can throw + in Obj-C++, or could itself call something that can throw even in + Obj-C. */ + TREE_NOTHROW (umsg_decl) = 0; + TREE_NOTHROW (umsg_nonnil_decl) = 0; + TREE_NOTHROW (umsg_stret_decl) = 0; + TREE_NOTHROW (umsg_nonnil_stret_decl) = 0; + + /* id objc_msgSend_Fast (id, SEL, ...) + __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */ +#ifdef OFFS_MSGSEND_FAST + umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_fast_decl) = 0; + DECL_ATTRIBUTES (umsg_fast_decl) + = tree_cons (get_identifier ("hard_coded_address"), + build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST), + NULL_TREE); +#else + /* No direct dispatch available. */ + umsg_fast_decl = umsg_decl; +#endif + + /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */ + /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */ + type = build_varargs_function_type_list (objc_object_type, + objc_super_type, + objc_selector_type, + NULL_TREE); + umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET, + type, 0, NOT_BUILT_IN, 0, + NULL_TREE); + TREE_NOTHROW (umsg_super_decl) = 0; + TREE_NOTHROW (umsg_super_stret_decl) = 0; + + type = build_function_type_list (objc_object_type, + const_string_type_node, + NULL_TREE); + + /* id objc_getClass (const char *); */ + objc_get_class_decl + = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + /* id objc_getMetaClass (const char *); */ + objc_get_meta_class_decl + = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE); + + /* This is the type of all of the following functions + objc_copyStruct(). */ + type = build_function_type_list (void_type_node, + ptr_type_node, + const_ptr_type_node, + ptrdiff_type_node, + boolean_type_node, + boolean_type_node, + NULL_TREE); + /* Declare the following function: + void + objc_copyStruct (void *destination, const void *source, + ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ + objc_copyStruct_decl = add_builtin_function ("objc_copyStruct", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_copyStruct_decl) = 0; + objc_getPropertyStruct_decl = NULL_TREE; + objc_setPropertyStruct_decl = NULL_TREE; + + build_next_objc_exception_stuff (); + if (flag_objc_exceptions && !flag_objc_sjlj_exceptions) + using_eh_for_cleanups (); + lang_hooks.eh_runtime_type = objc_eh_runtime_type; + lang_hooks.eh_personality = objc_eh_personality; +} + +/* --- templates --- */ + +/* struct _objc_class + { + struct _objc_class *isa; + struct _objc_class *super_class; + char *name; + long version; + long info; + long instance_size; + struct _objc_ivar_list *ivars; + struct _objc_method_list *methods; + struct objc_cache *cache; + struct _objc_protocol_list *protocols; + #if ABI=1 + const char *ivar_layout; + struct _objc_class_ext *ext; + #else + void *sel_id; + void *gc_object_type; + #endif + }; */ + +/* The 'sel_id' & 'gc_object_type' fields are not used by the NeXT + runtime. We generate them for ABI==0 to maintain backward binary + compatibility. */ + +static void +build_v1_class_template (void) +{ + tree ptype, decls, *chain = NULL; + + objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS)); + + /* struct _objc_class *isa; */ + decls = add_field_decl (build_pointer_type (objc_class_template), + "isa", &chain); + + /* struct _objc_class *super_class; */ + add_field_decl (build_pointer_type (objc_class_template), + "super_class", &chain); + + /* char *name; */ + add_field_decl (string_type_node, "name", &chain); + + /* long version; */ + add_field_decl (long_integer_type_node, "version", &chain); + + /* long info; */ + add_field_decl (long_integer_type_node, "info", &chain); + + /* long instance_size; */ + add_field_decl (long_integer_type_node, "instance_size", &chain); + + /* struct _objc_ivar_list *ivars; */ + add_field_decl (objc_ivar_list_ptr,"ivars", &chain); + + /* struct _objc_method_list *methods; */ + add_field_decl (objc_method_list_ptr, "methods", &chain); + + /* struct objc_cache *cache; */ + ptype = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("objc_cache"))); + add_field_decl (ptype, "cache", &chain); + + /* struct _objc_protocol **protocol_list; */ + ptype = build_pointer_type (build_pointer_type + (xref_tag (RECORD_TYPE, + get_identifier (UTAG_PROTOCOL)))); + add_field_decl (ptype, "protocol_list", &chain); + + if (flag_objc_abi >= 1) + { + /* const char *ivar_layout; */ + add_field_decl (const_string_type_node, "ivar_layout", &chain); + + /* struct _objc_class_ext *ext; */ + ptype = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_CLASS_EXT))); + add_field_decl (ptype, "ext", &chain); + } + else + { + /* void *sel_id; */ + add_field_decl (build_pointer_type (void_type_node), "sel_id", &chain); + /* void *gc_object_type; */ + add_field_decl (build_pointer_type (void_type_node), "gc_object_type", + &chain); + } + + objc_finish_struct (objc_class_template, decls); +} + +/* struct _objc_category + { + char *category_name; + char *class_name; + struct _objc_method_list *instance_methods; + struct _objc_method_list *class_methods; + struct _objc_protocol_list *protocols; + #if ABI=1 + uint32_t size; // sizeof (struct _objc_category) + struct _objc_property_list *instance_properties; // category's own @property decl. + #endif + }; */ + +static void +build_v1_category_template (void) +{ + tree ptype, decls, *chain = NULL; + + objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY)); + + /* char *category_name; */ + decls = add_field_decl (string_type_node, "category_name", &chain); + + /* char *class_name; */ + add_field_decl (string_type_node, "class_name", &chain); + + /* struct _objc_method_list *instance_methods; */ + add_field_decl (objc_method_list_ptr, "instance_methods", &chain); + + /* struct _objc_method_list *class_methods; */ + add_field_decl (objc_method_list_ptr, "class_methods", &chain); + + /* struct _objc_protocol **protocol_list; */ + ptype = build_pointer_type (build_pointer_type (objc_protocol_template)); + add_field_decl (ptype, "protocol_list", &chain); + + if (flag_objc_abi >= 1) + { + add_field_decl (integer_type_node, "size", &chain); + + /* struct _objc_property_list *instance_properties; + This field describes a category's @property declarations. + Properties from inherited protocols are not included. */ + ptype = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_PROPERTY_LIST))); + add_field_decl (ptype, "instance_properties", &chain); + } + objc_finish_struct (objc_category_template, decls); +} + +/* Begin code generation for protocols... + Modified for ObjC #1 extensions. */ + +/* struct _objc_protocol + { + #if ABI=1 + struct _objc_protocol_extension *isa; + #else + struct _objc_class *isa; + #endif + + char *protocol_name; + struct _objc_protocol **protocol_list; + struct _objc__method_prototype_list *instance_methods; + struct _objc__method_prototype_list *class_methods; + }; */ + +static void +build_v1_protocol_template (void) +{ + tree ptype, decls, *chain = NULL; + + objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL)); + + if (flag_objc_abi >= 1) + /* struct _objc_protocol_extension *isa; */ + ptype = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_PROTOCOL_EXT))); + else + /* struct _objc_class *isa; */ + ptype = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_CLASS))); + + decls = add_field_decl (ptype, "isa", &chain); + + /* char *protocol_name; */ + add_field_decl (string_type_node, "protocol_name", &chain); + + /* struct _objc_protocol **protocol_list; */ + ptype = build_pointer_type (build_pointer_type (objc_protocol_template)); + add_field_decl (ptype, "protocol_list", &chain); + + /* struct _objc__method_prototype_list *instance_methods; */ + add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain); + + /* struct _objc__method_prototype_list *class_methods; */ + add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain); + + objc_finish_struct (objc_protocol_template, decls); +} + +/* --- names, decls identifers --- */ + +static tree +next_runtime_abi_01_super_superclassfield_id (void) +{ + if (!super_superclassfield_id) + super_superclassfield_id = get_identifier ("super_class"); + return super_superclassfield_id; +} + +static tree +next_runtime_abi_01_class_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_Class_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_class_template, buf); + OBJCMETA (decl, objc_meta, meta_class); + return decl; +} + +static tree +next_runtime_abi_01_metaclass_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_MetaClass_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_class_template, buf); + OBJCMETA (decl, objc_meta, meta_metaclass); + return decl; +} + +static tree +next_runtime_abi_01_category_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s", + IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)), + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_category_template, buf); + OBJCMETA (decl, objc_meta, meta_category); + return decl; +} + +static tree +next_runtime_abi_01_protocol_decl (tree p) +{ + tree decl; + char buf[BUFSIZE]; + + /* static struct _objc_protocol _OBJC_Protocol_; */ + + snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (p))); + decl = start_var_decl (objc_protocol_template, buf); + OBJCMETA (decl, objc_meta, meta_protocol); + return decl; +} + +static tree +next_runtime_abi_01_string_decl (tree type, const char *name, string_section where) +{ + tree var = start_var_decl (type, name); + switch (where) + { + case class_names: + OBJCMETA (var, objc_meta, meta_class_name); + break; + case meth_var_names: + OBJCMETA (var, objc_meta, meta_meth_name); + break; + case meth_var_types: + OBJCMETA (var, objc_meta, meta_meth_type); + break; + case prop_names_attr: + OBJCMETA (var, objc_meta, meta_prop_name_attr); + break; + default: + OBJCMETA (var, objc_meta, meta_base); + break; + } + return var; +} + +/* --- entry --- */ + +static GTY(()) int class_reference_idx; + +static tree +build_class_reference_decl (void) +{ + tree decl; + char buf[BUFSIZE]; + + sprintf (buf, "_OBJC_ClassRefs_%d", class_reference_idx++); + decl = start_var_decl (objc_class_type, buf); + + return decl; +} + +static tree +next_runtime_abi_01_get_class_reference (tree ident) +{ + if (!flag_zero_link) + { + tree *chain; + tree decl; + + for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain)) + if (TREE_VALUE (*chain) == ident) + { + if (! TREE_PURPOSE (*chain)) + TREE_PURPOSE (*chain) = build_class_reference_decl (); + + return TREE_PURPOSE (*chain); + } + + decl = build_class_reference_decl (); + *chain = tree_cons (decl, ident, NULL_TREE); + return decl; + } + else + { + tree params; + + add_class_reference (ident); + + params = build_tree_list (NULL_TREE, + my_build_string_pointer + (IDENTIFIER_LENGTH (ident) + 1, + IDENTIFIER_POINTER (ident))); + + return build_function_call (input_location, objc_get_class_decl, params); + } +} + +/* Used by get_arg_type_list. + Return the types for receiver & _cmd at the start of a method argument list. + context is either METHOD_DEF or METHOD_REF, saying whether we are trying + to define a method or call one. superflag says this is for a send to super. + meth may be NULL, in the case that there is no prototype. */ + +static tree +next_runtime_abi_01_get_arg_type_list_base (tree meth, int context, int superflag) +{ + tree arglist; + + /* Receiver type. */ + if (superflag) + arglist = build_tree_list (NULL_TREE, objc_super_type); + else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL) + arglist = build_tree_list (NULL_TREE, objc_instance_type); + else + arglist = build_tree_list (NULL_TREE, objc_object_type); + + /* Selector type - will eventually change to `int'. */ + chainon (arglist, build_tree_list (NULL_TREE, objc_selector_type)); + return arglist; +} + +static tree +next_runtime_abi_01_receiver_is_class_object (tree receiver) +{ + if (TREE_CODE (receiver) == VAR_DECL + && IS_CLASS (TREE_TYPE (receiver))) + { + /* The receiver is a variable created by build_class_reference_decl. */ + tree chain = cls_ref_chain ; + /* Look up the identifier in the relevant chain. */ + for (; chain; chain = TREE_CHAIN (chain)) + if (TREE_PURPOSE (chain) == receiver) + return TREE_VALUE (chain); + } + return NULL_TREE; +} + +static tree +build_selector_reference_decl (tree ident) +{ + tree decl; + char *t, buf[BUFSIZE]; + + snprintf (buf, BUFSIZE, "_OBJC_SelRef_%s", IDENTIFIER_POINTER (ident)); + t = buf; + while (*t) + { + if (*t==':') + *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */ + t++; + } + decl = start_var_decl (objc_selector_type, buf); + OBJCMETA (decl, objc_meta, meta_sel_refs); + return decl; +} + +static tree +next_runtime_abi_01_build_selector_reference (location_t loc ATTRIBUTE_UNUSED, + tree ident, + tree proto ATTRIBUTE_UNUSED) +{ + tree *chain = &sel_ref_chain; + tree expr; + + while (*chain) + { + if (TREE_VALUE (*chain) == ident) + return TREE_PURPOSE (*chain); + + chain = &TREE_CHAIN (*chain); + } + + expr = build_selector_reference_decl (ident); + + *chain = tree_cons (expr, ident, NULL_TREE); + + return expr; +} + +/* Build a tree expression to send OBJECT the operation SELECTOR, + looking up the method on object LOOKUP_OBJECT (often same as OBJECT), + assuming the method has prototype METHOD_PROTOTYPE. + (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.) + LOC is the location of the expression to build. + Use METHOD_PARAMS as list of args to pass to the method. + If SUPER_FLAG is nonzero, we look up the superclass's method. */ + +static tree +build_objc_method_call (location_t loc, int super_flag, tree method_prototype, + tree lookup_object, tree selector, + tree method_params) +{ + tree sender, sender_cast, method, t; + tree rcv_p = (super_flag ? objc_super_type : objc_object_type); + VEC(tree, gc) *parms; + unsigned nparm = (method_params ? list_length (method_params) : 0); + + /* If a prototype for the method to be called exists, then cast + the sender's return type and arguments to match that of the method. + Otherwise, leave sender as is. */ + tree ret_type + = (method_prototype + ? TREE_VALUE (TREE_TYPE (method_prototype)) + : objc_object_type); + + tree method_param_types = + get_arg_type_list (method_prototype, METHOD_REF, super_flag); + tree ftype = build_function_type (ret_type, method_param_types); + + if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype)) + ftype = build_type_attribute_variant (ftype, + METHOD_TYPE_ATTRIBUTES + (method_prototype)); + + sender_cast = build_pointer_type (ftype); + + lookup_object = build_c_cast (loc, rcv_p, lookup_object); + + /* Use SAVE_EXPR to avoid evaluating the receiver twice. */ + lookup_object = save_expr (lookup_object); + + /* Param list + 2 slots for object and selector. */ + parms = VEC_alloc (tree, gc, nparm + 2); + + /* If we are returning a struct in memory, and the address + of that memory location is passed as a hidden first + argument, then change which messenger entry point this + expr will call. NB: Note that sender_cast remains + unchanged (it already has a struct return type). */ + if (!targetm.calls.struct_value_rtx (0, 0) + && (TREE_CODE (ret_type) == RECORD_TYPE + || TREE_CODE (ret_type) == UNION_TYPE) + && targetm.calls.return_in_memory (ret_type, 0)) + sender = (super_flag ? umsg_super_stret_decl + : flag_nil_receivers ? umsg_stret_decl + : umsg_nonnil_stret_decl); + else + sender = (super_flag ? umsg_super_decl + : (flag_nil_receivers ? (flag_objc_direct_dispatch + ? umsg_fast_decl + : umsg_decl) + : umsg_nonnil_decl)); + method = build_fold_addr_expr_loc (loc, sender); + + /* Pass the object to the method. */ + VEC_quick_push (tree, parms, lookup_object); + /* Pass the selector to the method. */ + VEC_quick_push (tree, parms, selector); + /* Now append the remainder of the parms. */ + if (nparm) + for (; method_params; method_params = TREE_CHAIN (method_params)) + VEC_quick_push (tree, parms, TREE_VALUE (method_params)); + + /* Build an obj_type_ref, with the correct cast for the method call. */ + t = build3 (OBJ_TYPE_REF, sender_cast, method, + lookup_object, size_zero_node); + t = build_function_call_vec (loc, t, parms, NULL); + VEC_free (tree, gc, parms); + return t; +} + +static tree +next_runtime_abi_01_build_objc_method_call (location_t loc, + tree method_prototype, + tree receiver, + tree rtype ATTRIBUTE_UNUSED, + tree sel_name, + tree method_params, + int super) +{ + tree selector = next_runtime_abi_01_build_selector_reference (loc, sel_name, + NULL_TREE); + + return build_objc_method_call (loc, super, method_prototype, + receiver, selector, method_params); +} + +static tree +next_runtime_abi_01_get_protocol_reference (location_t loc, tree p) +{ + tree expr; + + if (!PROTOCOL_FORWARD_DECL (p)) + PROTOCOL_FORWARD_DECL (p) = next_runtime_abi_01_protocol_decl (p); + + expr = build_unary_op (loc, ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0); + return convert (objc_protocol_type, expr); +} + +/* For ABI 0/1 and IVAR is just a fixed offset in the class struct. */ + +static tree +next_runtime_abi_01_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED, + tree base, tree id) +{ + return objc_build_component_ref (base, id); +} + +/* We build super class references as we need them (but keep them once + built for the sake of efficiency). */ + +static tree +next_runtime_abi_01_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED, + struct imp_entry *imp, bool inst_meth) +{ + if (inst_meth) + { + if (!ucls_super_ref) + ucls_super_ref = + objc_build_component_ref (imp->class_decl, + get_identifier ("super_class")); + return ucls_super_ref; + } + else + { + if (!uucls_super_ref) + uucls_super_ref = + objc_build_component_ref (imp->meta_decl, + get_identifier ("super_class")); + return uucls_super_ref; + } +} + +static tree +next_runtime_abi_01_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED, + struct imp_entry *imp, bool inst_meth) +{ + tree super_name = CLASS_SUPER_NAME (imp->imp_template); + tree super_class; + + if (!flag_zero_link) + { + super_class = objc_get_class_reference (super_name); + + if (!inst_meth) + + /* If we are in a class method, we must retrieve the + _metaclass_ for the current class, pointed at by + the class's "isa" pointer. The following assumes that + "isa" is the first ivar in a class (which it must be). */ + super_class = + build_indirect_ref (input_location, + build_c_cast (input_location, + build_pointer_type (objc_class_type), + super_class), + RO_UNARY_STAR); + return super_class; + } + + /* else do it the slow way. */ + add_class_reference (super_name); + super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl); +/* assemble_external (super_class);*/ + super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1, + IDENTIFIER_POINTER (super_name)); + /* super_class = objc_get{Meta}Class("CLASS_SUPER_NAME"); */ + return build_function_call (input_location, + super_class, + build_tree_list (NULL_TREE, super_name)); +} + +static bool +next_runtime_abi_01_setup_const_string_class_decl (void) +{ + if (!constant_string_global_id) + { + /* Hopefully, this should not represent a serious limitation. */ + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_%sClassReference", constant_string_class_name); + constant_string_global_id = get_identifier (buf); + } + + string_class_decl = lookup_name (constant_string_global_id); + + return (string_class_decl != NULL_TREE); +} + +static tree +next_runtime_abi_01_build_const_string_constructor (location_t loc, tree string, + int length) +{ + tree constructor, fields, var; + VEC(constructor_elt,gc) *v = NULL; + + /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */ + fields = TYPE_FIELDS (internal_const_str_type); + CONSTRUCTOR_APPEND_ELT (v, fields, + build_unary_op (loc, ADDR_EXPR, string_class_decl, 0)); + + fields = DECL_CHAIN (fields); + CONSTRUCTOR_APPEND_ELT (v, fields, + build_unary_op (loc, ADDR_EXPR, string, 1)); + + /* ??? check if this should be long. */ + fields = DECL_CHAIN (fields); + CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length)); + constructor = objc_build_constructor (internal_const_str_type, v); + + var = build_decl (input_location, CONST_DECL, NULL, TREE_TYPE (constructor)); + DECL_INITIAL (var) = constructor; + TREE_STATIC (var) = 1; + DECL_CONTEXT (var) = NULL; + OBJCMETA (var, objc_meta, meta_const_str); + return var; +} + +/* --- metadata templates --- */ + +/* This routine builds the following type: + struct _prop_t { + const char * const name; // property name + const char * const attributes; // comma-delimited, encoded, + // property attributes + }; +*/ + +static GTY(()) tree objc_v1_property_template; + +static tree +build_v1_property_template (void) +{ + tree prop_record; + tree decls, *chain = NULL; + + prop_record = objc_start_struct (get_identifier ("_prop_t")); + /* const char * name */ + decls = add_field_decl (string_type_node, "name", &chain); + + /* const char * attribute */ + add_field_decl (string_type_node, "attribute", &chain); + + objc_finish_struct (prop_record, decls); + return prop_record; +} + +/* Build the following type: + + struct _objc_protocol_extension + { + uint32_t size; // sizeof (struct _objc_protocol_extension) + struct objc_method_list *optional_instance_methods; + struct objc_method_list *optional_class_methods; + struct objc_prop_list *instance_properties; + } +*/ + +static GTY(()) tree objc_protocol_extension_template; + +static void +build_v1_objc_protocol_extension_template (void) +{ + tree decls, *chain = NULL; + + objc_protocol_extension_template = + objc_start_struct (get_identifier (UTAG_PROTOCOL_EXT)); + + /* uint32_t size; */ + decls = add_field_decl (integer_type_node, "size", &chain); + + /* struct objc_method_list *optional_instance_methods; */ + add_field_decl (objc_method_list_ptr, "optional_instance_methods", &chain); + + /* struct objc_method_list *optional_class_methods; */ + add_field_decl (objc_method_list_ptr, "optional_class_methods", &chain); + + /* struct objc_prop_list *instance_properties; */ + add_field_decl (objc_prop_list_ptr, "instance_properties", &chain); + + objc_finish_struct (objc_protocol_extension_template, decls); +} + +/* This routine build following struct type: + struct _objc_class_ext + { + uint32_t size; // sizeof(struct _objc_class_ext) + const char *weak_ivar_layout; + struct _prop_list_t *properties; + } +*/ + +static GTY(()) tree objc_class_ext_template; + +static void +build_objc_class_ext_template (void) +{ + tree ptrt, decls, *chain = NULL; + + objc_class_ext_template = objc_start_struct (get_identifier (UTAG_CLASS_EXT)); + + /* uint32_t size; */ + decls = add_field_decl (integer_type_node, "size", &chain); + + /* const char *weak_ivar_layout; */ + add_field_decl (const_string_type_node, "weak_ivar_layout", &chain); + + /* struct _prop_list_t *properties; */ + ptrt = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier(UTAG_PROPERTY_LIST))); + add_field_decl (ptrt, "properties", &chain); + + objc_finish_struct (objc_class_ext_template, decls); +} + +static void +build_metadata_templates (void) +{ + + if (!objc_method_template) + objc_method_template = build_method_template (); + + + +} + +/* --- emit metadata --- */ + +static tree +generate_v1_meth_descriptor_table (tree chain, tree protocol, + const char *prefix, tree attr) +{ + tree method_list_template, initlist, decl; + int size; + VEC(constructor_elt,gc) *v = NULL; + char buf[BUFSIZE]; + + if (!chain || !prefix) + return NULL_TREE; + + if (!objc_method_prototype_template) + objc_method_prototype_template = build_method_prototype_template (); + + size = list_length (chain); + method_list_template = + build_method_prototype_list_template (objc_method_prototype_template, + size); + snprintf (buf, BUFSIZE, "%s_%s", prefix, + IDENTIFIER_POINTER (PROTOCOL_NAME (protocol))); + + decl = start_var_decl (method_list_template, buf); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); + initlist = + build_descriptor_table_initializer (objc_method_prototype_template, + chain); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); + /* Get into the right section. */ + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, objc_build_constructor (method_list_template, v)); + return decl; +} + +/* Build protocol ext = + {size, opt_instance_meth, opt_class_meth, instance_props}; + or NULL_TREE if none are present. */ + +static tree +generate_v1_objc_protocol_extension (tree proto_interface, + tree opt_instance_meth, + tree opt_class_meth, + tree instance_props) +{ + int size; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + tree decl, expr; + char buf[BUFSIZE]; + + /* If there are no extensions, then don't bother... */ + if (!opt_instance_meth && !opt_class_meth && !instance_props) + return NULL_TREE; + + if (!objc_protocol_extension_template) + build_v1_objc_protocol_extension_template (); + + /* uint32_t size */ + size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_protocol_extension_template)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); + + /* Try for meaningful diagnostics. */ + loc = DECL_SOURCE_LOCATION (PROTOCOL_FORWARD_DECL (proto_interface)); + + /* struct objc_method_list *optional_instance_methods; */ + if (opt_instance_meth) + expr = convert (objc_method_list_ptr, + build_unary_op (loc, ADDR_EXPR, opt_instance_meth, 0)); + else + expr = convert (objc_method_list_ptr, null_pointer_node); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* struct objc_method_list *optional_class_methods; */ + if (opt_class_meth) + expr = convert (objc_method_list_ptr, + build_unary_op (loc, ADDR_EXPR, opt_class_meth, 0)); + else + expr = convert (objc_method_list_ptr, null_pointer_node); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + /* struct objc_prop_list *instance_properties; */ + if (instance_props) + expr = convert (objc_prop_list_ptr, + build_unary_op (loc, ADDR_EXPR, instance_props, 0)); + else + expr = convert (objc_prop_list_ptr, null_pointer_node); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + snprintf (buf, BUFSIZE, "_OBJC_ProtocolExt_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (proto_interface))); + + decl = start_var_decl (objc_protocol_extension_template, buf); + expr = objc_build_constructor (TREE_TYPE (decl), v); + OBJCMETA (decl, objc_meta, meta_protocol_extension); + finish_var_decl (decl, expr); + return decl; +} + +/* This routine builds the following type: + struct _prop_list_t { + uint32_t entsize; // sizeof (struct _prop_t) + uint32_t prop_count; + struct _prop_t prop_list [prop_count]; + } +*/ + +static tree +build_v1_property_list_template (tree list_type, int size) +{ + tree property_list_t_record; + tree array_type, decls, *chain = NULL; + + /* anonymous. */ + property_list_t_record = objc_start_struct (NULL_TREE); + + /* uint32_t const entsize */ + decls = add_field_decl (integer_type_node, "entsize", &chain); + + /* int prop_count */ + add_field_decl (integer_type_node, "prop_count", &chain); + + /* struct _prop_t prop_list[]; */ + array_type = build_sized_array_type (list_type, size); + add_field_decl (array_type, "prop_list", &chain); + + objc_finish_struct (property_list_t_record, decls); + return property_list_t_record; +} + +/* This routine builds the initializer list to initialize the + 'struct _prop_t prop_list[]' field of 'struct _prop_list_t' meta-data. */ + +static tree +build_v1_property_table_initializer (tree type, tree context) +{ + tree x; + VEC(constructor_elt,gc) *inits = NULL; + + if (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE) + x = CLASS_PROPERTY_DECL (context); + else + x = IMPL_PROPERTY_DECL (context); + + for (; x; x = TREE_CHAIN (x)) + { + VEC(constructor_elt,gc) *elemlist = NULL; + tree attribute, name_ident = PROPERTY_NAME (x); + + CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE, + add_objc_string (name_ident, prop_names_attr)); + + attribute = objc_v2_encode_prop_attr (x); + CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE, + add_objc_string (attribute, prop_names_attr)); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + objc_build_constructor (type, elemlist)); + } + + return objc_build_constructor (build_array_type (type, 0),inits); +} + +/* This routine builds the 'struct _prop_list_t' variable declaration and + initializes it with its initializer list. TYPE is 'struct _prop_list_t', + NAME is the internal name of this variable, SIZE is number of properties + for this class and LIST is the initializer list for its 'prop_list' field. */ + +static tree +generate_v1_property_table (tree context, tree klass_ctxt) +{ + tree x, decl, initlist, property_list_template; + bool is_proto = false; + VEC(constructor_elt,gc) *inits = NULL; + int init_val, size = 0; + char buf[BUFSIZE]; + + if (context) + { + gcc_assert (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE); + x = CLASS_PROPERTY_DECL (context); + is_proto = true; + } + else + x = IMPL_PROPERTY_DECL (klass_ctxt); + + for (; x; x = TREE_CHAIN (x)) + size++; + + if (size == 0) + return NULL_TREE; + + if (!objc_v1_property_template) + objc_v1_property_template = build_v1_property_template (); + + property_list_template = + build_v1_property_list_template (objc_v1_property_template, + size); + initlist = build_v1_property_table_initializer (objc_v1_property_template, + is_proto ? context + : klass_ctxt); + + init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v1_property_template)); + if (is_proto) + snprintf (buf, BUFSIZE, "_OBJC_ProtocolPropList_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (context))); + else + snprintf (buf, BUFSIZE, "_OBJC_ClassPropList_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt))); + + decl = start_var_decl (property_list_template, buf); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, init_val)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); + x = objc_build_constructor (TREE_TYPE (decl), inits); + OBJCMETA (decl, objc_meta, meta_proplist); + finish_var_decl (decl, x); + return decl; +} + +static tree +generate_v1_protocol_list (tree i_or_p, tree klass_ctxt) +{ + tree array_type, ptype, refs_decl, lproto, e, plist, attr; + int size = 0; + VEC(constructor_elt,gc) *v = NULL; + char buf[BUFSIZE]; + + switch (TREE_CODE (i_or_p)) + { + case CLASS_INTERFACE_TYPE: + case CATEGORY_INTERFACE_TYPE: + plist = CLASS_PROTOCOL_LIST (i_or_p); + break; + case PROTOCOL_INTERFACE_TYPE: + plist = PROTOCOL_LIST (i_or_p); + break; + default: + gcc_unreachable (); + } + + /* Compute size. */ + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto))) + size++; + + /* Build initializer. */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0)); + e = build_int_cst (build_pointer_type (objc_protocol_template), size); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e); + + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + { + tree pval = TREE_VALUE (lproto); + + if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_FORWARD_DECL (pval)) + { + tree fwref = PROTOCOL_FORWARD_DECL (pval); + location_t loc = DECL_SOURCE_LOCATION (fwref) ; + e = build_unary_op (loc, ADDR_EXPR, fwref, 0); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e); + } + } + + /* static struct objc_protocol *refs[n]; */ + switch (TREE_CODE (i_or_p)) + { + case PROTOCOL_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p))); + attr = meta_proto_ref; + break; + case CLASS_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s", + IDENTIFIER_POINTER (CLASS_NAME (i_or_p))); + attr = meta_clas_prot; + break; + case CATEGORY_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt))); + attr = meta_catg_prot; + break; + default: + gcc_unreachable (); + } + + ptype = build_pointer_type (objc_protocol_template); + array_type = build_sized_array_type (ptype, size + 3); + refs_decl = start_var_decl (array_type, buf); + + OBJCMETA (refs_decl, objc_meta, attr); + finish_var_decl (refs_decl, + objc_build_constructor (TREE_TYPE (refs_decl), v)); + + return refs_decl; +} + +static tree +build_v1_protocol_initializer (tree type, tree protocol_name, tree protocol_list, + tree inst_methods, tree class_methods, + tree protocol_ext) +{ + tree expr, ttyp; + location_t loc; + VEC(constructor_elt,gc) *inits = NULL; + + if (!objc_protocol_extension_template) + build_v1_objc_protocol_extension_template (); + + /* TODO: find a better representation of location from the inputs. */ + loc = UNKNOWN_LOCATION; + ttyp = build_pointer_type (objc_protocol_extension_template); + /* Instead of jamming the protocol version number into the isa, we pass + either a pointer to the protocol extension - or NULL. */ + if (protocol_ext) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, protocol_ext, 0)); + else + expr = convert (ttyp, null_pointer_node); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list); + + ttyp = objc_method_proto_list_ptr; + if (inst_methods) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + if (class_methods) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + return objc_build_constructor (type, inits); +} + +/* An updated version of generate_protocols () that emit the protocol + extension for ABI=1. */ + +/* For each protocol which was referenced either from a @protocol() + expression, or because a class/category implements it (then a + pointer to the protocol is stored in the struct describing the + class/category), we create a statically allocated instance of the + Protocol class. The code is written in such a way as to generate + as few Protocol objects as possible; we generate a unique Protocol + instance for each protocol, and we don't generate a Protocol + instance if the protocol is never referenced (either from a + @protocol() or from a class/category implementation). These + statically allocated objects can be referred to via the static + (that is, private to this module) symbols _OBJC_PROTOCOL_n. + + The statically allocated Protocol objects that we generate here + need to be fixed up at runtime in order to be used: the 'isa' + pointer of the objects need to be set up to point to the 'Protocol' + class, as known at runtime. + + The NeXT runtime fixes up all protocols at program startup time, + before main() is entered. It uses a low-level trick to look up all + those symbols, then loops on them and fixes them up. */ + +/* TODO: finish getting rid of passing stuff around in globals. */ + +static GTY(()) tree V1_Protocol_OPT_NST_METHODS_decl; +static GTY(()) tree V1_Protocol_OPT_CLS_METHODS_decl; +static GTY(()) tree V1_ProtocolExt_decl; +static GTY(()) tree V1_Property_decl; + +static void +generate_v1_protocols (void) +{ + tree p; + + /* If a protocol was directly referenced, pull in indirect references. */ + for (p = protocol_chain; p; p = TREE_CHAIN (p)) + if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p)) + generate_protocol_references (PROTOCOL_LIST (p)); + + for (p = protocol_chain; p; p = TREE_CHAIN (p)) + { + tree decl, encoding, initlist, protocol_name_expr; + tree refs_type, refs_decl, refs_expr; + location_t loc; + tree nst_methods = PROTOCOL_NST_METHODS (p); + tree cls_methods = PROTOCOL_CLS_METHODS (p); + + /* If protocol wasn't referenced, don't generate any code. */ + decl = PROTOCOL_FORWARD_DECL (p); + + if (!decl) + continue; + + /* Make sure we link in the Protocol class. */ + add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); + + while (nst_methods) + { + if (! METHOD_ENCODING (nst_methods)) + { + encoding = encode_method_prototype (nst_methods); + METHOD_ENCODING (nst_methods) = encoding; + } + nst_methods = TREE_CHAIN (nst_methods); + } + + UOBJC_INSTANCE_METHODS_decl = + generate_v1_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p, + "_OBJC_ProtocolInstanceMethods", + meta_proto_nst_meth); + + while (cls_methods) + { + if (! METHOD_ENCODING (cls_methods)) + { + encoding = encode_method_prototype (cls_methods); + METHOD_ENCODING (cls_methods) = encoding; + } + + cls_methods = TREE_CHAIN (cls_methods); + } + + UOBJC_CLASS_METHODS_decl = + generate_v1_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p, + "_OBJC_ProtocolClassMethods", + meta_proto_cls_meth); + + /* There should be no optional methods for ABI-0 - but we need to + check all this here before the lists are made. */ + nst_methods = PROTOCOL_OPTIONAL_NST_METHODS (p); + while (nst_methods) + { + if (! METHOD_ENCODING (nst_methods)) + { + encoding = encode_method_prototype (nst_methods); + METHOD_ENCODING (nst_methods) = encoding; + } + nst_methods = TREE_CHAIN (nst_methods); + } + + V1_Protocol_OPT_NST_METHODS_decl = + generate_v1_meth_descriptor_table (PROTOCOL_OPTIONAL_NST_METHODS (p), p, + "_OBJC_OptionalProtocolInstanceMethods", + meta_proto_nst_meth); + + cls_methods = PROTOCOL_OPTIONAL_CLS_METHODS (p); + while (cls_methods) + { + if (! METHOD_ENCODING (cls_methods)) + { + encoding = encode_method_prototype (cls_methods); + METHOD_ENCODING (cls_methods) = encoding; + } + + cls_methods = TREE_CHAIN (cls_methods); + } + + V1_Protocol_OPT_CLS_METHODS_decl = + generate_v1_meth_descriptor_table (PROTOCOL_OPTIONAL_CLS_METHODS (p), p, + "_OBJC_OptionalProtocolClassMethods", + meta_proto_cls_meth); + + if (PROTOCOL_LIST (p)) + refs_decl = generate_v1_protocol_list (p, objc_implementation_context); + else + refs_decl = 0; + + /* static struct objc_protocol _OBJC_PROTOCOL_; */ + protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names); + /* TODO: more locations to be fixed up... */ + loc = UNKNOWN_LOCATION; + refs_type = + build_pointer_type (build_pointer_type (objc_protocol_template)); + if (refs_decl) + refs_expr = convert (refs_type, + build_unary_op (loc, ADDR_EXPR, refs_decl, 0)); + else + refs_expr = convert (refs_type, null_pointer_node); + + if (flag_objc_abi < 1) + { + /* Original ABI. */ + initlist = + build_protocol_initializer (TREE_TYPE (decl), + protocol_name_expr, refs_expr, + UOBJC_INSTANCE_METHODS_decl, + UOBJC_CLASS_METHODS_decl); + finish_var_decl (decl, initlist); + continue; + } + + /* else - V1 extensions. */ + + V1_Property_decl = + generate_v1_property_table (p, NULL_TREE); + + V1_ProtocolExt_decl = + generate_v1_objc_protocol_extension (p, + V1_Protocol_OPT_NST_METHODS_decl, + V1_Protocol_OPT_CLS_METHODS_decl, + V1_Property_decl); + + initlist = build_v1_protocol_initializer (TREE_TYPE (decl), + protocol_name_expr, refs_expr, + UOBJC_INSTANCE_METHODS_decl, + UOBJC_CLASS_METHODS_decl, + V1_ProtocolExt_decl); + finish_var_decl (decl, initlist); + } +} + +static tree +generate_dispatch_table (tree chain, const char *name, tree attr) +{ + tree decl, method_list_template, initlist; + VEC(constructor_elt,gc) *v = NULL; + int size;; + + if (!chain || !name || !(size = list_length (chain))) + return NULL_TREE; + + if (!objc_method_template) + objc_method_template = build_method_template (); + + method_list_template = build_method_list_template (objc_method_template, + size); + initlist = build_dispatch_table_initializer (objc_method_template, chain); + + decl = start_var_decl (method_list_template, name); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (integer_type_node, size)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); + + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, + objc_build_constructor (TREE_TYPE (decl), v)); + + return decl; +} + +/* Init a category. */ +static tree +build_v1_category_initializer (tree type, tree cat_name, tree class_name, + tree inst_methods, tree class_methods, + tree protocol_list, tree property_list, + location_t loc) +{ + tree expr, ltyp; + VEC(constructor_elt,gc) *v = NULL; + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name); + + ltyp = objc_method_list_ptr; + if (inst_methods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + if (class_methods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* protocol_list = */ + ltyp = build_pointer_type (build_pointer_type (objc_protocol_template)); + if (protocol_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + if (flag_objc_abi >= 1) + { + int val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_category_template)); + expr = build_int_cst (NULL_TREE, val); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + ltyp = objc_prop_list_ptr; + if (property_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + + return objc_build_constructor (type, v); +} + +/* static struct objc_category _OBJC_CATEGORY_ = { ... }; */ +/* TODO: get rid of passing stuff around in globals. */ +static void +generate_v1_category (struct imp_entry *impent) +{ + tree initlist, cat_name_expr, class_name_expr; + tree protocol_decl, category, cat_decl; + tree inst_methods = NULL_TREE, class_methods = NULL_TREE; + tree cat = impent->imp_context; + location_t loc; + char buf[BUFSIZE]; + + cat_decl = impent->class_decl; + loc = DECL_SOURCE_LOCATION (cat_decl); + + add_class_reference (CLASS_NAME (cat)); + cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names); + class_name_expr = add_objc_string (CLASS_NAME (cat), class_names); + + category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat)); + + if (category && CLASS_PROTOCOL_LIST (category)) + { + generate_protocol_references (CLASS_PROTOCOL_LIST (category)); + protocol_decl = generate_v1_protocol_list (category, cat); + } + else + protocol_decl = 0; + + if (flag_objc_abi >= 1) + V1_Property_decl = generate_v1_property_table (NULL_TREE, cat); + else + V1_Property_decl = NULL_TREE; + + if (CLASS_NST_METHODS (cat)) + { + snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (cat)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); + inst_methods = generate_dispatch_table (CLASS_NST_METHODS (cat), buf, + meta_cati_meth); + } + + if (CLASS_CLS_METHODS (cat)) + { + snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (cat)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); + class_methods = generate_dispatch_table (CLASS_CLS_METHODS (cat), buf, + meta_catc_meth); + } + + initlist = build_v1_category_initializer (TREE_TYPE (cat_decl), + cat_name_expr, class_name_expr, + inst_methods, class_methods, + protocol_decl, V1_Property_decl, + loc); + + finish_var_decl (cat_decl, initlist); + impent->class_decl = cat_decl; +} + +/* This routine builds the class extension used by v1 NeXT. */ + +static tree +generate_objc_class_ext (tree property_list, tree context) +{ + tree decl, expr, ltyp; + tree weak_ivar_layout_tree; + int size; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + char buf[BUFSIZE]; + + /* TODO: pass the loc in or find it from args. */ + loc = UNKNOWN_LOCATION; + + /* const char *weak_ivar_layout + TODO: Figure the ivar layouts out... */ + weak_ivar_layout_tree = NULL_TREE; + + if (!property_list && !weak_ivar_layout_tree) + return NULL_TREE; + + if (!objc_class_ext_template) + build_objc_class_ext_template (); + + /* uint32_t size */ + size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_class_ext_template)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); + + ltyp = const_string_type_node; + if (weak_ivar_layout_tree) + expr = convert (ltyp, weak_ivar_layout_tree); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* struct _prop_list_t *properties; */ + ltyp = objc_prop_list_ptr; + if (property_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + snprintf (buf, BUFSIZE, "_OBJC_ClassExt_%s", + IDENTIFIER_POINTER (CLASS_NAME (context))); + decl = start_var_decl (objc_class_ext_template, buf); + expr = objc_build_constructor (TREE_TYPE (decl), v); + OBJCMETA (decl, objc_meta, meta_class_extension); + finish_var_decl (decl, expr); + return decl; +} + +/* struct _objc_class { + struct objc_class *isa; + struct objc_class *super_class; + char *name; + long version; + long info; + long instance_size; + struct objc_ivar_list *ivars; + struct objc_method_list *methods; + struct objc_cache *cache; + struct objc_protocol_list *protocols; + #if ABI >= 1 + const char *ivar_layout; + struct _objc_class_ext *ext; + #else + void *sel_id; + void *gc_object_type; + #endif + }; */ + +static tree +build_v1_shared_structure_initializer (tree type, tree isa, tree super, + tree name, tree size, int status, + tree dispatch_table, tree ivar_list, + tree protocol_list, tree class_ext) +{ + tree expr, ltyp; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + + /* TODO: fish the location out of the input data. */ + loc = UNKNOWN_LOCATION; + + /* isa = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, isa); + + /* super_class = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, super); + + /* name = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, default_conversion (name)); + + /* version = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (long_integer_type_node, 0)); + + /* info = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (long_integer_type_node, status)); + + /* instance_size = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + convert (long_integer_type_node, size)); + + /* objc_ivar_list = */ + ltyp = objc_ivar_list_ptr; + if (ivar_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, ivar_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* objc_method_list = */ + ltyp = objc_method_list_ptr; + if (dispatch_table) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, dispatch_table, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + ltyp = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("objc_cache"))); + /* method_cache = */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, convert (ltyp, null_pointer_node)); + + /* protocol_list = */ + ltyp = build_pointer_type (build_pointer_type (objc_protocol_template)); + if (protocol_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + if (flag_objc_abi >= 1) + { + /* TODO: figure out the ivar_layout stuff. */ + expr = convert (const_string_type_node, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + if (!objc_class_ext_template) + build_objc_class_ext_template (); + ltyp = build_pointer_type (objc_class_ext_template); + if (class_ext) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_ext, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + else + { + /* sel_id = NULL */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_pointer_node); + + /* gc_object_type = NULL */ + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_pointer_node); + } + return objc_build_constructor (type, v); +} + +static tree +generate_ivars_list (tree chain, const char *name, tree attr) +{ + tree initlist, ivar_list_template, decl; + int size; + VEC(constructor_elt,gc) *inits = NULL; + + if (!chain) + return NULL_TREE; + + if (!objc_ivar_template) + objc_ivar_template = build_ivar_template (); + + size = ivar_list_length (chain); + + generating_instance_variables = 1; + ivar_list_template = build_ivar_list_template (objc_ivar_template, size); + initlist = build_ivar_list_initializer (objc_ivar_template, chain); + generating_instance_variables = 0; + + decl = start_var_decl (ivar_list_template, name); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); + + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, + objc_build_constructor (TREE_TYPE (decl), inits)); + + return decl; +} + +/* static struct objc_class _OBJC_METACLASS_Foo={ ... }; + static struct objc_class _OBJC_CLASS_Foo={ ... }; */ + +static void +generate_v1_class_structs (struct imp_entry *impent) +{ + tree name_expr, super_expr, root_expr, class_decl, meta_decl; + tree my_root_id, my_super_id; + tree cast_type, initlist, protocol_decl; + tree class_ext_decl = NULL_TREE, props = NULL_TREE; + tree inst_methods = NULL_TREE, class_methods = NULL_TREE; + tree chain, inst_ivars = NULL_TREE, class_ivars = NULL_TREE; + int cls_flags; + location_t loc; + char buf[BUFSIZE]; + +/* objc_implementation_context = impent->imp_context; + implementation_template = impent->imp_template;*/ + class_decl = impent->class_decl; + meta_decl = impent->meta_decl; + cls_flags = impent->has_cxx_cdtors ? CLS_HAS_CXX_STRUCTORS : 0 ; + + loc = DECL_SOURCE_LOCATION (impent->class_decl); + + if (flag_objc_abi >= 1) + { + /* ABI=1 additions. */ + props = generate_v1_property_table (NULL_TREE, impent->imp_context); + class_ext_decl = generate_objc_class_ext (props, impent->imp_context); + } + + my_super_id = CLASS_SUPER_NAME (impent->imp_template); + if (my_super_id) + { + add_class_reference (my_super_id); + + /* Compute "my_root_id" - this is required for code generation. + the "isa" for all meta class structures points to the root of + the inheritance hierarchy (e.g. "__Object")... */ + my_root_id = my_super_id; + do + { + tree my_root_int = lookup_interface (my_root_id); + + if (my_root_int && CLASS_SUPER_NAME (my_root_int)) + my_root_id = CLASS_SUPER_NAME (my_root_int); + else + break; + } + while (1); + super_expr = add_objc_string (my_super_id, class_names); + } + else + { + /* No super class. */ + my_root_id = CLASS_NAME (impent->imp_template); + super_expr = null_pointer_node; + } + + /* Install class `isa' and `super' pointers at runtime. */ + cast_type = build_pointer_type (objc_class_template); + super_expr = build_c_cast (loc, cast_type, super_expr); + + root_expr = add_objc_string (my_root_id, class_names); + root_expr = build_c_cast (loc, cast_type, root_expr); + + if (CLASS_PROTOCOL_LIST (impent->imp_template)) + { + generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template)); + protocol_decl = generate_v1_protocol_list (impent->imp_template, + impent->imp_context); + } + else + protocol_decl = NULL_TREE; + + if (CLASS_CLS_METHODS (impent->imp_context)) + { + snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + class_methods = generate_dispatch_table (CLASS_CLS_METHODS (impent->imp_context), + buf, meta_clac_meth); + } + + if (CLASS_SUPER_NAME (impent->imp_template) == NULL_TREE + && (chain = TYPE_FIELDS (objc_class_template))) + { + snprintf (buf, BUFSIZE, "_OBJC_ClassIvars_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + class_ivars = generate_ivars_list (chain, buf, meta_clac_vars); + } + /* TODO: get rid of hidden passing of stuff in globals. */ + /* UOBJC_INSTANCE/CLASS_Variables_decl made in generate_ivarlists(). */ + + name_expr = add_objc_string (CLASS_NAME (impent->imp_template), class_names); + + /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */ + + initlist = build_v1_shared_structure_initializer + (TREE_TYPE (meta_decl), + root_expr, super_expr, name_expr, + convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)), + CLS_META, class_methods, class_ivars, + protocol_decl, NULL_TREE); + + finish_var_decl (meta_decl, initlist); + impent->meta_decl = meta_decl; + + /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */ + if (CLASS_NST_METHODS (impent->imp_context)) + { + snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + inst_methods = generate_dispatch_table (CLASS_NST_METHODS (impent->imp_context), + buf, meta_clai_meth); + } + + if ((chain = CLASS_IVARS (impent->imp_template))) + { + snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + inst_ivars = generate_ivars_list (chain, buf, meta_clai_vars); + } + + initlist = build_v1_shared_structure_initializer + (TREE_TYPE (class_decl), + build_unary_op (loc, ADDR_EXPR, meta_decl, 0), + super_expr, name_expr, + convert (integer_type_node, + TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE (impent->imp_template))), + CLS_FACTORY | cls_flags, inst_methods, inst_ivars, + protocol_decl, class_ext_decl); + + finish_var_decl (class_decl, initlist); + impent->class_decl = class_decl; +} + +/* --- Output NeXT V1 Metadata --- */ + +/* Create the initial value for the `defs' field of _objc_symtab. + This is a CONSTRUCTOR. */ + +static tree +init_def_list (tree type) +{ + tree expr; + location_t loc; + struct imp_entry *impent; + VEC(constructor_elt,gc) *v = NULL; + + if (imp_count) + for (impent = imp_list; impent; impent = impent->next) + { + if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) + { + loc = DECL_SOURCE_LOCATION (impent->class_decl); + expr = build_unary_op (loc, + ADDR_EXPR, impent->class_decl, 0); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + } + + if (cat_count) + for (impent = imp_list; impent; impent = impent->next) + { + if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE) + { + loc = DECL_SOURCE_LOCATION (impent->class_decl); + expr = build_unary_op (loc, + ADDR_EXPR, impent->class_decl, 0); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + } + } + + return objc_build_constructor (type, v); +} + +/* Take care of defining and initializing _OBJC_SYMBOLS. */ + +/* Predefine the following data type: + + struct _objc_symtab + { + long sel_ref_cnt; + SEL *refs; + short cls_def_cnt; + short cat_def_cnt; + void *defs[cls_def_cnt + cat_def_cnt]; + }; */ + +static void +build_objc_symtab_template (void) +{ + tree fields, *chain = NULL; + + objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB)); + + /* long sel_ref_cnt; */ + fields = add_field_decl (long_integer_type_node, "sel_ref_cnt", &chain); + + /* SEL *refs; */ + add_field_decl (build_pointer_type (objc_selector_type), "refs", &chain); + + /* short cls_def_cnt; */ + add_field_decl (short_integer_type_node, "cls_def_cnt", &chain); + + /* short cat_def_cnt; */ + add_field_decl (short_integer_type_node, "cat_def_cnt", &chain); + + if (imp_count || cat_count) + { + /* void *defs[imp_count + cat_count (+ 1)]; */ + /* NB: The index is one less than the size of the array. */ + int index = imp_count + cat_count; + tree array_type = build_sized_array_type (ptr_type_node, index); + add_field_decl (array_type, "defs", &chain); + } + + objc_finish_struct (objc_symtab_template, fields); +} +/* Construct the initial value for all of _objc_symtab. */ + +static tree +init_objc_symtab (tree type) +{ + VEC(constructor_elt,gc) *v = NULL; + + /* sel_ref_cnt = { ..., 5, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (long_integer_type_node, 0)); + + /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + convert (build_pointer_type (objc_selector_type), + integer_zero_node)); + + /* cls_def_cnt = { ..., 5, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (short_integer_type_node, imp_count)); + + /* cat_def_cnt = { ..., 5, ... } */ + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (short_integer_type_node, cat_count)); + + /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */ + + if (imp_count || cat_count) + { + tree field = TYPE_FIELDS (type); + field = DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (field)))); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init_def_list (TREE_TYPE (field))); + } + + return objc_build_constructor (type, v); +} + +/* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab' + and initialized appropriately. */ + +static void +generate_objc_symtab_decl (void) +{ + build_objc_symtab_template (); + UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_Symbols"); + /* Allow the runtime to mark meta-data such that it can be assigned to target + specific sections by the back-end. */ + OBJCMETA (UOBJC_SYMBOLS_decl, objc_meta, meta_symtab); + finish_var_decl (UOBJC_SYMBOLS_decl, + init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl))); +} + + +static void +handle_next_class_ref (tree chain) +{ + const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain)); + char *string = (char *) alloca (strlen (name) + 30); + + sprintf (string, ".objc_class_name_%s", name); + +#ifdef ASM_DECLARE_UNRESOLVED_REFERENCE + ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string); +#else + return ; /* NULL build for targets other than Darwin. */ +#endif +} + +static void +handle_next_impent (struct imp_entry *impent) +{ + char buf[BUFSIZE]; + + switch (TREE_CODE (impent->imp_context)) + { + case CLASS_IMPLEMENTATION_TYPE: + snprintf (buf, BUFSIZE, ".objc_class_name_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + break; + case CATEGORY_IMPLEMENTATION_TYPE: + snprintf (buf, BUFSIZE, "*.objc_category_name_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context))); + break; + default: + return; + } + +#ifdef ASM_DECLARE_CLASS_REFERENCE + ASM_DECLARE_CLASS_REFERENCE (asm_out_file, buf); +#else + return ; /* NULL build for targets other than Darwin. */ +#endif +} + +static void +generate_classref_translation_entry (tree chain) +{ + tree expr, decl, type; + + decl = TREE_PURPOSE (chain); + type = TREE_TYPE (decl); + + expr = add_objc_string (TREE_VALUE (chain), class_names); + expr = convert (type, expr); /* cast! */ + + /* This is a class reference. It is re-written by the runtime, + but will be optimized away unless we force it. */ + DECL_PRESERVE_P (decl) = 1; + OBJCMETA (decl, objc_meta, meta_class_reference); + finish_var_decl (decl, expr); + return; +} + + +/* The Fix-and-Continue functionality available in Mac OS X 10.3 and + later requires that ObjC translation units participating in F&C be + specially marked. The following routine accomplishes this. */ + +/* static int _OBJC_IMAGE_INFO[2] = { 0, 1 }; */ + +static void +generate_objc_image_info (void) +{ + tree decl; + int flags + = ((flag_replace_objc_classes && imp_count ? 1 : 0) + | (flag_objc_gc ? 2 : 0)); + VEC(constructor_elt,gc) *v = NULL; + tree array_type; + + array_type = build_sized_array_type (integer_type_node, 2); + + decl = start_var_decl (array_type, "_OBJC_ImageInfo"); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (integer_type_node, flags)); + /* The runtime wants this and refers to it in a manner hidden from the compiler. + So we must force the output. */ + DECL_PRESERVE_P (decl) = 1; + OBJCMETA (decl, objc_meta, meta_info); + finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), v)); +} + +static void +objc_generate_v1_next_metadata (void) +{ + struct imp_entry *impent; + tree chain, attr; + long vers; + + /* FIXME: Make sure that we generate no metadata if there is nothing + to put into it. */ + + if (objc_static_instances) + gcc_unreachable (); /* Not for NeXT */ + + build_metadata_templates (); + objc_implementation_context = + implementation_template = + UOBJC_CLASS_decl = + UOBJC_METACLASS_decl = NULL_TREE; + + for (impent = imp_list; impent; impent = impent->next) + { + + /* If -gen-decls is present, Dump the @interface of each class. + TODO: Dump the classes in the order they were found, rather than in + reverse order as we are doing now. */ + if (flag_gen_declaration) + dump_interface (gen_declaration_file, impent->imp_context); + + /* all of the following reference the string pool... */ + if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) + generate_v1_class_structs (impent); + else + generate_v1_category (impent); + } + + /* If we are using an array of selectors, we must always + finish up the array decl even if no selectors were used. */ + build_next_selector_translation_table (); + + if (protocol_chain) + generate_v1_protocols (); + + /* Pass summary information to the runtime. */ + if (imp_count || cat_count) + generate_objc_symtab_decl (); + + vers = OBJC_VERSION; + attr = build_tree_list (objc_meta, meta_modules); + build_module_descriptor (vers, attr); + + /* This conveys information on GC usage and zero-link. */ + generate_objc_image_info (); + + /* Dump the class references. This forces the appropriate classes + to be linked into the executable image, preserving unix archive + semantics. This can be removed when we move to a more dynamically + linked environment. */ + + for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain)) + { + handle_next_class_ref (chain); + if (TREE_PURPOSE (chain)) + generate_classref_translation_entry (chain); + } + + for (impent = imp_list; impent; impent = impent->next) + handle_next_impent (impent); + + /* Emit the strings tables. */ + generate_strings (); +} + +/* --- exceptions stuff --- */ + +/* Predefine the following data type: + + struct _objc_exception_data + { + int buf[OBJC_JBLEN]; + void *pointers[4]; + }; */ + +/* The following yuckiness should prevent users from having to #include + in their code... */ + +/* Define to a harmless positive value so the below code doesn't die. */ +#ifndef OBJC_JBLEN +#define OBJC_JBLEN 18 +#endif + +static void +build_next_objc_exception_stuff (void) +{ + tree decls, temp_type, *chain = NULL; + + objc_exception_data_template + = objc_start_struct (get_identifier (UTAG_EXCDATA)); + + /* int buf[OBJC_JBLEN]; */ + + temp_type = build_sized_array_type (integer_type_node, OBJC_JBLEN); + decls = add_field_decl (temp_type, "buf", &chain); + + /* void *pointers[4]; */ + + temp_type = build_sized_array_type (ptr_type_node, 4); + add_field_decl (temp_type, "pointers", &chain); + + objc_finish_struct (objc_exception_data_template, decls); + + /* int _setjmp(...); */ + /* If the user includes , this shall be superseded by + 'int _setjmp(jmp_buf);' */ + temp_type = build_varargs_function_type_list (integer_type_node, NULL_TREE); + objc_setjmp_decl + = add_builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE); + + /* id objc_exception_extract(struct _objc_exception_data *); */ + temp_type + = build_function_type_list (objc_object_type, + build_pointer_type (objc_exception_data_template), + NULL_TREE); + objc_exception_extract_decl + = add_builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL, + NULL_TREE); + /* void objc_exception_try_enter(struct _objc_exception_data *); */ + /* void objc_exception_try_exit(struct _objc_exception_data *); */ + temp_type + = build_function_type_list (void_type_node, + build_pointer_type (objc_exception_data_template), + NULL_TREE); + objc_exception_try_enter_decl + = add_builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL, + NULL_TREE); + objc_exception_try_exit_decl + = add_builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL, + NULL_TREE); + + /* int objc_exception_match(id, id); */ + temp_type + = build_function_type_list (integer_type_node, + objc_object_type, objc_object_type, NULL_TREE); + objc_exception_match_decl + = add_builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL, + NULL_TREE); + + /* id objc_assign_ivar (id, id, unsigned int); */ + /* id objc_assign_ivar_Fast (id, id, unsigned int) + __attribute__ ((hard_coded_address (OFFS_ASSIGNIVAR_FAST))); */ + temp_type + = build_function_type_list (objc_object_type, + objc_object_type, + objc_object_type, + unsigned_type_node, + NULL_TREE); + objc_assign_ivar_decl + = add_builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); +#ifdef OFFS_ASSIGNIVAR_FAST + objc_assign_ivar_fast_decl + = add_builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0, + NOT_BUILT_IN, NULL, NULL_TREE); + DECL_ATTRIBUTES (objc_assign_ivar_fast_decl) + = tree_cons (get_identifier ("hard_coded_address"), + build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST), + NULL_TREE); +#else + /* Default to slower ivar method. */ + objc_assign_ivar_fast_decl = objc_assign_ivar_decl; +#endif + + /* id objc_assign_global (id, id *); */ + /* id objc_assign_strongCast (id, id *); */ + temp_type = build_function_type_list (objc_object_type, + objc_object_type, + build_pointer_type (objc_object_type), + NULL_TREE); + objc_assign_global_decl + = add_builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL, + NULL_TREE); + objc_assign_strong_cast_decl + = add_builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL, + NULL_TREE); +} + +/* --- NeXT V1 SJLJ Exceptions --- */ + +/* Build "objc_exception_try_exit(&_stack)". */ + +static tree +next_sjlj_build_try_exit (struct objc_try_context **ctcp) +{ + tree t; + t = build_fold_addr_expr_loc (input_location, (*ctcp)->stack_decl); + t = tree_cons (NULL, t, NULL); + t = build_function_call (input_location, + objc_exception_try_exit_decl, t); + return t; +} + +/* Build + objc_exception_try_enter (&_stack); + if (_setjmp(&_stack.buf)) + ; + else + ; + Return the COND_EXPR. Note that the THEN and ELSE fields are left + empty, ready for the caller to fill them in. */ + +static tree +next_sjlj_build_enter_and_setjmp (struct objc_try_context **ctcp) +{ + tree t, enter, sj, cond; + + t = build_fold_addr_expr_loc (input_location, (*ctcp)->stack_decl); + t = tree_cons (NULL, t, NULL); + enter = build_function_call (input_location, + objc_exception_try_enter_decl, t); + + t = objc_build_component_ref ((*ctcp)->stack_decl, + get_identifier ("buf")); + t = build_fold_addr_expr_loc (input_location, t); +#ifdef OBJCPLUS + /* Convert _setjmp argument to type that is expected. */ + if (prototype_p (TREE_TYPE (objc_setjmp_decl))) + t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t); + else + t = convert (ptr_type_node, t); +#else + t = convert (ptr_type_node, t); +#endif + t = tree_cons (NULL, t, NULL); + sj = build_function_call (input_location, + objc_setjmp_decl, t); + + cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj); + cond = c_common_truthvalue_conversion (input_location, cond); + + return build3 (COND_EXPR, void_type_node, cond, NULL, NULL); +} + +/* Build: + + DECL = objc_exception_extract(&_stack); */ + +static tree +next_sjlj_build_exc_extract (struct objc_try_context **ctcp, tree decl) +{ + tree t; + + t = build_fold_addr_expr_loc (input_location, (*ctcp)->stack_decl); + t = tree_cons (NULL, t, NULL); + t = build_function_call (input_location, + objc_exception_extract_decl, t); + t = convert (TREE_TYPE (decl), t); + t = build2 (MODIFY_EXPR, void_type_node, decl, t); + + return t; +} + +/* Build + if (objc_exception_match(obj_get_class(TYPE), _caught) + BODY + else if (...) + ... + else + { + _rethrow = _caught; + objc_exception_try_exit(&_stack); + } + from the sequence of CATCH_EXPRs in the current try context. */ + +static tree +next_sjlj_build_catch_list (struct objc_try_context **ctcp) +{ + tree_stmt_iterator i = tsi_start ((*ctcp)->catch_list); + tree catch_seq, t; + tree *last = &catch_seq; + bool saw_id = false; + + for (; !tsi_end_p (i); tsi_next (&i)) + { + tree stmt = tsi_stmt (i); + tree type = CATCH_TYPES (stmt); + tree body = CATCH_BODY (stmt); + + if (type != error_mark_node + && objc_is_object_id (TREE_TYPE (type))) + { + *last = body; + saw_id = true; + break; + } + else + { + tree args, cond; + + if (type == error_mark_node) + cond = error_mark_node; + else + { + args = tree_cons (NULL, (*ctcp)->caught_decl, NULL); + t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type))); + args = tree_cons (NULL, t, args); + t = build_function_call (input_location, + objc_exception_match_decl, args); + cond = c_common_truthvalue_conversion (input_location, t); + } + t = build3 (COND_EXPR, void_type_node, cond, body, NULL); + SET_EXPR_LOCATION (t, EXPR_LOCATION (stmt)); + + *last = t; + last = &COND_EXPR_ELSE (t); + } + } + + if (!saw_id) + { + t = build2 (MODIFY_EXPR, void_type_node, (*ctcp)->rethrow_decl, + (*ctcp)->caught_decl); + SET_EXPR_LOCATION (t, (*ctcp)->end_catch_locus); + append_to_statement_list (t, last); + + t = next_sjlj_build_try_exit (ctcp); + SET_EXPR_LOCATION (t, (*ctcp)->end_catch_locus); + append_to_statement_list (t, last); + } + + return catch_seq; +} + +/* Build a complete @try-@catch-@finally block for legacy Darwin setjmp + exception handling. We aim to build: + + { + struct _objc_exception_data _stack; + id _rethrow = 0; + try + { + objc_exception_try_enter (&_stack); + if (_setjmp(&_stack.buf)) + { + id _caught = objc_exception_extract(&_stack); + objc_exception_try_enter (&_stack); + if (_setjmp(&_stack.buf)) + _rethrow = objc_exception_extract(&_stack); + else + CATCH-LIST + } + else + TRY-BLOCK + } + finally + { + if (!_rethrow) + objc_exception_try_exit(&_stack); + FINALLY-BLOCK + if (_rethrow) + objc_exception_throw(_rethrow); + } + } + + If CATCH-LIST is empty, we can omit all of the block containing + "_caught" except for the setting of _rethrow. Note the use of + a real TRY_FINALLY_EXPR here, which is not involved in EH per-se, + but handles goto and other exits from the block. */ + +static tree +next_sjlj_build_try_catch_finally (struct objc_try_context **ctcp) +{ + tree rethrow_decl, stack_decl, t; + tree catch_seq, try_fin, bind; + struct objc_try_context *cur_try_context = *ctcp; + + /* Create the declarations involved. */ + t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA)); + stack_decl = objc_create_temporary_var (t, NULL); + cur_try_context->stack_decl = stack_decl; + + rethrow_decl = objc_create_temporary_var (objc_object_type, NULL); + cur_try_context->rethrow_decl = rethrow_decl; + TREE_CHAIN (rethrow_decl) = stack_decl; + + /* Build the outermost variable binding level. */ + bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL); + SET_EXPR_LOCATION (bind, cur_try_context->try_locus); + TREE_SIDE_EFFECTS (bind) = 1; + + /* Initialize rethrow_decl. */ + t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl, + convert (objc_object_type, null_pointer_node)); + SET_EXPR_LOCATION (t, cur_try_context->try_locus); + append_to_statement_list (t, &BIND_EXPR_BODY (bind)); + + /* Build the outermost TRY_FINALLY_EXPR. */ + try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL); + SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus); + TREE_SIDE_EFFECTS (try_fin) = 1; + append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind)); + + /* Create the complete catch sequence. */ + if (cur_try_context->catch_list) + { + tree caught_decl = objc_build_exc_ptr (ctcp); + catch_seq = build_stmt (input_location, BIND_EXPR, caught_decl, NULL, NULL); + TREE_SIDE_EFFECTS (catch_seq) = 1; + + t = next_sjlj_build_exc_extract (ctcp, caught_decl); + append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq)); + + t = next_sjlj_build_enter_and_setjmp (ctcp); + COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (ctcp, rethrow_decl); + COND_EXPR_ELSE (t) = next_sjlj_build_catch_list (ctcp); + append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq)); + } + else + catch_seq = next_sjlj_build_exc_extract (ctcp, rethrow_decl); + SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus); + + /* Build the main register-and-try if statement. */ + t = next_sjlj_build_enter_and_setjmp (ctcp); + SET_EXPR_LOCATION (t, cur_try_context->try_locus); + COND_EXPR_THEN (t) = catch_seq; + COND_EXPR_ELSE (t) = cur_try_context->try_body; + TREE_OPERAND (try_fin, 0) = t; + + /* Build the complete FINALLY statement list. */ + t = next_sjlj_build_try_exit (ctcp); + t = build_stmt (input_location, COND_EXPR, + c_common_truthvalue_conversion + (input_location, rethrow_decl), + NULL, t); + SET_EXPR_LOCATION (t, cur_try_context->finally_locus); + append_to_statement_list (t, &TREE_OPERAND (try_fin, 1)); + + append_to_statement_list (cur_try_context->finally_body, + &TREE_OPERAND (try_fin, 1)); + + t = tree_cons (NULL, rethrow_decl, NULL); + t = build_function_call (input_location, + objc_exception_throw_decl, t); + t = build_stmt (input_location, COND_EXPR, + c_common_truthvalue_conversion (input_location, + rethrow_decl), + t, NULL); + SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus); + append_to_statement_list (t, &TREE_OPERAND (try_fin, 1)); + + return bind; +} + +/* We do not expect this to be used at the moment. + If (a) it is possible to implement unwinder exceptions. + (b) we do it... then it might be possibly useful. +*/ +static GTY(()) tree objc_eh_personality_decl; + +static tree +objc_eh_runtime_type (tree type) +{ + tree ident, eh_id, decl, str; + + gcc_unreachable (); + if (type == error_mark_node) + { + /* Use 'ErrorMarkNode' as class name when error_mark_node is found + to prevent an ICE. Note that we know that the compiler will + terminate with an error and this 'ErrorMarkNode' class name will + never be actually used. */ + ident = get_identifier ("ErrorMarkNode"); + goto make_err_class; + } + + if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) + { + ident = get_identifier ("id"); + goto make_err_class; + } + + if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type))) + { +#ifdef OBJCPLUS + /* This routine is also called for c++'s catch clause; in which case, + we use c++'s typeinfo decl. */ + return build_eh_type_type (type); +#else + error ("non-objective-c type '%T' cannot be caught", type); + ident = get_identifier ("ErrorMarkNode"); + goto make_err_class; +#endif + } + else + ident = OBJC_TYPE_NAME (TREE_TYPE (type)); + +make_err_class: + /* If this class was already referenced, then it will be output during + meta-data emission, so we don't need to do it here. */ + decl = get_objc_string_decl (ident, class_names); + eh_id = add_objc_string (ident, class_names); + if (!decl) + { + /* Not found ... so we need to build it - from the freshly-entered id. */ + decl = get_objc_string_decl (ident, class_names); + str = my_build_string (IDENTIFIER_LENGTH (ident) + 1, + IDENTIFIER_POINTER (ident)); + /* We have to finalize this var here, because this might be called after + all the other metadata strings have been emitted. */ + finish_var_decl (decl, str); + } + return eh_id; +} + +/* For NeXT ABI 0 and 1, the personality routines are just those of the + underlying language. */ + +static tree +objc_eh_personality (void) +{ + if (!objc_eh_personality_decl) +#ifndef OBJCPLUS + objc_eh_personality_decl = build_personality_function ("gcc"); +#else + objc_eh_personality_decl = build_personality_function ("gxx"); +#endif + return objc_eh_personality_decl; +} + +/* --- interfaces --- */ + +static tree +build_throw_stmt (location_t loc, tree throw_expr, bool rethrown ATTRIBUTE_UNUSED) +{ + tree t; + VEC(tree, gc) *parms = VEC_alloc (tree, gc, 1); + /* A throw is just a call to the runtime throw function with the + object as a parameter. */ + VEC_quick_push (tree, parms, throw_expr); + t = build_function_call_vec (loc, objc_exception_throw_decl, parms, NULL); + VEC_free (tree, gc, parms); + return add_stmt (t); +} + +/* Build __builtin_eh_pointer, or the moral equivalent. In the case + of Darwin, we'll arrange for it to be initialized (and associated + with a binding) later. */ + +static tree +objc_build_exc_ptr (struct objc_try_context **cur_try_context) +{ + if (flag_objc_sjlj_exceptions) + { + tree var = (*cur_try_context)->caught_decl; + if (!var) + { + var = objc_create_temporary_var (objc_object_type, NULL); + (*cur_try_context)->caught_decl = var; + } + return var; + } + else + { + tree t; + t = built_in_decls[BUILT_IN_EH_POINTER]; + t = build_call_expr (t, 1, integer_zero_node); + return fold_convert (objc_object_type, t); + } +} + +static tree +begin_catch (struct objc_try_context **cur_try_context, tree type, + tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED) +{ + tree t; + /* Record the data for the catch in the try context so that we can + finalize it later. We treat ellipsis the same way as catching + with 'id xyz'. */ + t = build_stmt (input_location, CATCH_EXPR, type, compound); + (*cur_try_context)->current_catch = t; + + /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */ + t = objc_build_exc_ptr (cur_try_context); + t = convert (TREE_TYPE (decl), t); + return build2 (MODIFY_EXPR, void_type_node, decl, t); +} + +static void +finish_catch (struct objc_try_context **cur_try_context, tree current_catch) +{ + append_to_statement_list (current_catch, &((*cur_try_context)->catch_list)); +} + +static tree +finish_try_stmt (struct objc_try_context **cur_try_context) +{ + tree stmt; + struct objc_try_context *c = *cur_try_context; + /* If we're doing Darwin setjmp exceptions, build the big nasty. */ + if (flag_objc_sjlj_exceptions) + { + bool save = in_late_binary_op; + in_late_binary_op = true; + if (!c->finally_body) + { + c->finally_locus = input_location; + c->end_finally_locus = input_location; + } + stmt = next_sjlj_build_try_catch_finally (cur_try_context); + in_late_binary_op = save; + } + else + /* This doesn't happen at the moment... but maybe one day... */ + { + /* Otherwise, nest the CATCH inside a FINALLY. */ + stmt = c->try_body; + if (c->catch_list) + stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list); + if (c->finally_body) + stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body); + } + return stmt; +} + +#include "gt-objc-objc-next-runtime-abi-01.h" diff --git a/gcc/objc/objc-next-runtime-abi-02.c b/gcc/objc/objc-next-runtime-abi-02.c new file mode 100644 index 000000000..3de0d05bf --- /dev/null +++ b/gcc/objc/objc-next-runtime-abi-02.c @@ -0,0 +1,3778 @@ +/* Next Runtime (ABI-2) private. + Copyright (C) 2011 Free Software Foundation, Inc. + + Contributed by Iain Sandoe and based, in part, on an implementation in + 'branches/apple/trunk' contributed by Apple Computer Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +/* The NeXT ABI2 is used for m64 implementations on Darwin/OSX machines. + + This version is intended to match (logically) the output of Apple's + 4.2.1 compiler. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" + +#ifdef OBJCPLUS +#include "cp-tree.h" +#else +#include "c-tree.h" +#include "c-lang.h" +#endif +#include "langhooks.h" +#include "c-family/c-objc.h" +#include "objc-act.h" + +/* When building Objective-C++, we are not linking against the C front-end + and so need to replicate the C tree-construction functions in some way. */ +#ifdef OBJCPLUS +#define OBJCP_REMAP_FUNCTIONS +#include "objcp-decl.h" +#endif /* OBJCPLUS */ + +#include "ggc.h" +#include "target.h" +#include "obstack.h" +#include "tree-iterator.h" + +/* These are only used for encoding ivars. */ +extern struct obstack util_obstack; +extern char *util_firstobj; + +#include "objc-runtime-hooks.h" + +#include "objc-runtime-shared-support.h" + +/* ABI 2 Private definitions. */ +#define DEF_CONSTANT_STRING_CLASS_NAME "NSConstantString" + +#define TAG_GETCLASS "objc_getClass" +#define TAG_GETMETACLASS "objc_getMetaClass" + +#define TAG_MSGSEND "objc_msgSend" +#define TAG_MSGSENDSUPER "objc_msgSendSuper" +#define TAG_MSGSEND_STRET "objc_msgSend_stret" +#define TAG_MSGSENDSUPER_STRET "objc_msgSendSuper_stret" + +#define TAG_NEXT_EHVTABLE_NAME "objc_ehtype_vtable" +#define TAG_V2_EH_TYPE "objc_ehtype_t" + +#define UTAG_V2_CLASS "_class_t" +#define UTAG_V2_CLASS_RO "_class_ro_t" +#define UTAG_V2_PROTOCOL "_protocol_t" +#define UTAG_V2_PROTOCOL_LIST "_protocol_list_t" + +#define UTAG_V2_EH_TYPE "_objc_ehtype_t" + +#define OBJC2_CLS_HAS_CXX_STRUCTORS 0x0004L + +enum objc_v2_tree_index +{ + /* Templates. */ + OCTI_V2_CLS_TEMPL, + OCTI_V2_CAT_TEMPL, + OCTI_V2_CLS_RO_TEMPL, + OCTI_V2_PROTO_TEMPL, + OCTI_V2_IVAR_TEMPL, + OCTI_V2_IVAR_LIST_TEMPL, + OCTI_V2_MESSAGE_REF_TEMPL, + OCTI_V2_SUPER_MESSAGE_REF_TEMPL, + + OCTI_V2_MESSAGE_SELECTOR_TYPE, + OCTI_V2_SUPER_MESSAGE_SELECTOR_TYPE, + OCTI_V2_IMP_TYPE, + OCTI_V2_SUPER_IMP_TYPE, + + OCTI_V2_CACHE_DECL, + OCTI_V2_VTABLE_DECL, + + OCTI_V2_PROPERTY_TEMPL, + + /* V2 messaging. */ + OCTI_V2_UMSG_FIXUP_DECL, + OCTI_V2_UMSG_STRET_FIXUP_DECL, + OCTI_V2_UMSG_ID_FIXUP_DECL, + OCTI_V2_UMSG_ID_STRET_FIXUP_DECL, + OCTI_V2_UMSG_SUPER2_FIXUP_DECL, + OCTI_V2_UMSG_SUPER2_STRET_FIXUP_DECL, + + /* Exceptions - related. */ + OCTI_V2_BEGIN_CATCH_DECL, + OCTI_V2_END_CATCH_DECL, + OCTI_V2_RETHROW_DECL, + + OCTI_V2_MAX +}; + +#define objc_v2_class_template objc_v2_global_trees[OCTI_V2_CLS_TEMPL] +#define objc_v2_class_ro_template \ + objc_v2_global_trees[OCTI_V2_CLS_RO_TEMPL] +#define objc_v2_category_template \ + objc_v2_global_trees[OCTI_V2_CAT_TEMPL] +#define objc_v2_protocol_template \ + objc_v2_global_trees[OCTI_V2_PROTO_TEMPL] + +/* struct message_ref_t */ +#define objc_v2_message_ref_template \ + objc_v2_global_trees[OCTI_V2_MESSAGE_REF_TEMPL] + +#define objc_v2_ivar_list_ptr objc_v2_global_trees[OCTI_V2_IVAR_LIST_TEMPL] + +/* struct super_message_ref_t */ +#define objc_v2_super_message_ref_template \ + objc_v2_global_trees[OCTI_V2_SUPER_MESSAGE_REF_TEMPL] + +/* struct message_ref_t* */ +#define objc_v2_selector_type objc_v2_global_trees[OCTI_V2_MESSAGE_SELECTOR_TYPE] +/* struct super_super_message_ref_t */ +#define objc_v2_super_selector_type \ + objc_v2_global_trees[OCTI_V2_SUPER_MESSAGE_SELECTOR_TYPE] +#define objc_v2_imp_type objc_v2_global_trees[OCTI_V2_IMP_TYPE] +#define objc_v2_super_imp_type objc_v2_global_trees[OCTI_V2_SUPER_IMP_TYPE] + +#define UOBJC_V2_CACHE_decl objc_v2_global_trees[OCTI_V2_CACHE_DECL] +#define UOBJC_V2_VTABLE_decl objc_v2_global_trees[OCTI_V2_VTABLE_DECL] + +#define objc_v2_ivar_template objc_v2_global_trees[OCTI_V2_IVAR_TEMPL] +#define objc_v2_property_template \ + objc_v2_global_trees[OCTI_V2_PROPERTY_TEMPL] + +/* V2 Messaging */ + +/* objc_msgSend_fixup_rtp */ +#define umsg_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_FIXUP_DECL] +/* objc_msgSend_stret_fixup_rtp */ +#define umsg_stret_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_STRET_FIXUP_DECL] +/* objc_msgSendId_fixup_rtp */ +#define umsg_id_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_ID_FIXUP_DECL] +/* objc_msgSendId_stret_fixup_rtp */ +#define umsg_id_stret_fixup_decl \ + objc_v2_global_trees[OCTI_V2_UMSG_ID_STRET_FIXUP_DECL] +/* objc_msgSendSuper2_fixup_rtp */ +#define umsg_id_super2_fixup_decl \ + objc_v2_global_trees[OCTI_V2_UMSG_SUPER2_FIXUP_DECL] +/* objc_msgSendSuper2_stret_fixup_rtp */ +#define umsg_id_super2_stret_fixup_decl \ + objc_v2_global_trees[OCTI_V2_UMSG_SUPER2_STRET_FIXUP_DECL] + +#define objc2_begin_catch_decl objc_v2_global_trees[OCTI_V2_BEGIN_CATCH_DECL] +#define objc2_end_catch_decl objc_v2_global_trees[OCTI_V2_END_CATCH_DECL] +#define objc_rethrow_exception_decl \ + objc_v2_global_trees[OCTI_V2_RETHROW_DECL] + +/* rt_trees identifiers - shared between NeXT implementations. These allow + the FE to tag meta-data in a manner that survives LTO and can be used when + the runtime requires that certain meta-data items appear in particular + named sections. */ + +#include "objc-next-metadata-tags.h" +extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX]; + +/* The OCTI_V2_... enumeration itself is in above. */ +static GTY(()) tree objc_v2_global_trees[OCTI_V2_MAX]; + +static void next_runtime_02_initialize (void); + +static void build_v2_message_ref_templates (void); +static void build_v2_class_templates (void); +static void build_v2_super_template (void); +static void build_v2_category_template (void); +static void build_v2_protocol_template (void); + +static tree next_runtime_abi_02_super_superclassfield_id (void); + +static tree next_runtime_abi_02_class_decl (tree); +static tree next_runtime_abi_02_metaclass_decl (tree); +static tree next_runtime_abi_02_category_decl (tree); +static tree next_runtime_abi_02_protocol_decl (tree); +static tree next_runtime_abi_02_string_decl (tree, const char *, string_section); + +static tree next_runtime_abi_02_get_class_reference (tree); +static tree next_runtime_abi_02_build_selector_reference (location_t, tree, tree); +static tree next_runtime_abi_02_get_protocol_reference (location_t, tree); +static tree next_runtime_abi_02_build_ivar_ref (location_t, tree, tree); +static tree next_runtime_abi_02_get_class_super_ref (location_t, struct imp_entry *, bool); +static tree next_runtime_abi_02_get_category_super_ref (location_t, struct imp_entry *, bool); + +static tree next_runtime_abi_02_receiver_is_class_object (tree); +static tree next_runtime_abi_02_get_arg_type_list_base (tree, int, int); +static tree next_runtime_abi_02_build_objc_method_call (location_t, tree, tree, + tree, tree, tree, int); +static bool next_runtime_abi_02_setup_const_string_class_decl (void); +static tree next_runtime_abi_02_build_const_string_constructor (location_t, tree, int); + +static tree create_extern_decl (tree, const char *); + +static void objc_generate_v2_next_metadata (void); +static bool objc2_objc_exception_attr (tree); + +/* void build_v2_protocol_reference (tree);*/ +static void build_v2_ehtype_template (void); +static void build_v2_eh_catch_objects (void); +static tree next_runtime_02_eh_type (tree); +static tree objc_eh_personality (void); +static tree build_throw_stmt (location_t, tree, bool); +static tree objc_build_exc_ptr (struct objc_try_context **); +static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool); +static void finish_catch (struct objc_try_context **, tree); +static tree finish_try_stmt (struct objc_try_context **); + +static GTY ((length ("SIZEHASHTABLE"))) hash *extern_names; + +bool +objc_next_runtime_abi_02_init (objc_runtime_hooks *rthooks) +{ + extern_names = ggc_alloc_cleared_vec_hash (SIZEHASHTABLE); + + if (flag_objc_exceptions && flag_objc_sjlj_exceptions) + { + inform (UNKNOWN_LOCATION, "%<-fobjc-sjlj-exceptions%> is ignored for " + "%<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2"); + flag_objc_sjlj_exceptions = 0; + } + + rthooks->initialize = next_runtime_02_initialize; + rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME; + rthooks->tag_getclass = TAG_GETCLASS; + rthooks->super_superclassfield_ident = next_runtime_abi_02_super_superclassfield_id; + + rthooks->class_decl = next_runtime_abi_02_class_decl; + rthooks->metaclass_decl = next_runtime_abi_02_metaclass_decl; + rthooks->category_decl = next_runtime_abi_02_category_decl; + rthooks->protocol_decl = next_runtime_abi_02_protocol_decl; + rthooks->string_decl = next_runtime_abi_02_string_decl; + + rthooks->get_class_reference = next_runtime_abi_02_get_class_reference; + rthooks->build_selector_reference = next_runtime_abi_02_build_selector_reference; + rthooks->get_protocol_reference = next_runtime_abi_02_get_protocol_reference; + rthooks->build_ivar_reference = next_runtime_abi_02_build_ivar_ref; + rthooks->get_class_super_ref = next_runtime_abi_02_get_class_super_ref; + rthooks->get_category_super_ref = next_runtime_abi_02_get_category_super_ref; + + rthooks->receiver_is_class_object = next_runtime_abi_02_receiver_is_class_object; + rthooks->get_arg_type_list_base = next_runtime_abi_02_get_arg_type_list_base; + rthooks->build_objc_method_call = next_runtime_abi_02_build_objc_method_call; + + rthooks->setup_const_string_class_decl = + next_runtime_abi_02_setup_const_string_class_decl; + rthooks->build_const_string_constructor = + next_runtime_abi_02_build_const_string_constructor; + + rthooks->build_throw_stmt = build_throw_stmt; + rthooks->build_exc_ptr = objc_build_exc_ptr; + rthooks->begin_catch = begin_catch; + rthooks->finish_catch = finish_catch; + rthooks->finish_try_stmt = finish_try_stmt; + + rthooks->generate_metadata = objc_generate_v2_next_metadata; + return true; +} + +/* We need a way to convey what kind of meta-data are represented by a given + variable, since each type is expected (by the runtime) to be found in a + specific named section. The solution must be usable with LTO. + + The scheme used for NeXT ABI 0/1 (partial matching of variable names) is not + satisfactory when LTO is used with ABI-2. We now tag ObjC meta-data with + identification attributes in the front end. The back-end may choose to act + on these as it requires. */ + +static void +next_runtime_abi_02_init_metadata_attributes (void) +{ + if (!objc_meta) + objc_meta = get_identifier ("OBJC2META"); + + if (!meta_base) + meta_base = get_identifier ("V2_BASE"); + + meta_class = get_identifier ("G2_CLAS"); + meta_metaclass = get_identifier ("G2_META"); + meta_category = + meta_protocol = meta_base; + + meta_clac_vars = + meta_clai_vars = meta_base; + + meta_clac_meth = + meta_clai_meth = + meta_catc_meth = + meta_cati_meth = + meta_proto_cls_meth = + meta_proto_nst_meth = meta_base; + + meta_clas_prot = + meta_catg_prot = meta_base; + + meta_sel_refs = get_identifier ("V2_SRFS"); + + meta_class_name = + meta_meth_name = + meta_meth_type = + meta_prop_name_attr = get_identifier ("V2_STRG"); + + meta_mref = get_identifier ("V2_MREF"); + meta_class_ref = get_identifier ("V2_CLRF"); + meta_superclass_ref = get_identifier ("V2_SURF"); + + meta_label_classlist = get_identifier ("V2_CLAB"); + meta_label_nonlazy_classlist = get_identifier ("V2_NLCL"); + meta_label_categorylist = get_identifier ("V2_CALA"); + meta_label_nonlazy_categorylist = get_identifier ("V2_NLCA"); + + meta_label_protocollist = get_identifier ("V2_PLST"); + meta_proto_ref = get_identifier ("V2_PRFS"); + + meta_info = get_identifier ("V2_INFO"); + + meta_ehtype = get_identifier ("V2_EHTY"); + + meta_const_str = get_identifier ("V2_CSTR"); +} + +static void next_runtime_02_initialize (void) +{ + tree type; +#ifdef OBJCPLUS + /* For all NeXT objc ABIs -fobjc-call-cxx-cdtors is on by + default. */ + if (!global_options_set.x_flag_objc_call_cxx_cdtors) + global_options.x_flag_objc_call_cxx_cdtors = 1; +#endif + + /* Set up attributes to be attached to the meta-data so that they + will be placed in the correct sections. */ + next_runtime_abi_02_init_metadata_attributes (); + + /* `struct objc_selector *' */ + objc_selector_type = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (TAG_SELECTOR))); + + /* IMP : id (*) (id, _message_ref_t*, ...) + SUPER_IMP : id (*) ( super_t*, _super_message_ref_t*, ...) + objc_v2_selector_type. */ + build_v2_message_ref_templates (); + + objc_v2_ivar_list_ptr = + build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("_ivar_list_t"))); + + objc_prop_list_ptr = + build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("_prop_list_t"))); + + build_v2_class_templates (); + build_v2_super_template (); + build_v2_protocol_template (); + build_v2_category_template (); + + /* id objc_msgSend_fixup_rtp (id, struct message_ref_t*, ...); */ + type = build_varargs_function_type_list (objc_object_type, + objc_object_type, + objc_v2_selector_type, + NULL_TREE); + umsg_fixup_decl = add_builtin_function ("objc_msgSend_fixup", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_fixup_decl) = 0; + + /* id objc_msgSend_stret_fixup_rtp (id, struct message_ref_t*, ...); */ + umsg_stret_fixup_decl = add_builtin_function ("objc_msgSend_stret_fixup", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_stret_fixup_decl) = 0; + + /* id objc_msgSendId_fixup_rtp (id, struct message_ref_t*, ...); */ + umsg_id_fixup_decl = add_builtin_function ("objc_msgSendId_fixup", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_id_fixup_decl) = 0; + + /* id objc_msgSendId_stret_fixup_rtp + (id, struct message_ref_t*, ...); */ + umsg_id_stret_fixup_decl = add_builtin_function ("objc_msgSendId_stret_fixup", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_id_stret_fixup_decl) = 0; + + /* id objc_msgSendSuper2_fixup_rtp + (struct objc_super *, struct message_ref_t*, ...); */ + type = build_varargs_function_type_list (objc_object_type, + objc_super_type, + objc_v2_super_selector_type, + NULL_TREE); + umsg_id_super2_fixup_decl = add_builtin_function ("objc_msgSendSuper2_fixup", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_id_super2_fixup_decl) = 0; + + /* id objc_msgSendSuper2_stret_fixup_rtp + (struct objc_super *, struct message_ref_t*, ...); */ + umsg_id_super2_stret_fixup_decl = + add_builtin_function ("objc_msgSendSuper2_stret_fixup", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (umsg_id_super2_stret_fixup_decl) = 0; + + /* Present in the library, but unused by the FE. */ + /* Protocol *objc_getProtocol (const char *) + type = build_function_type_list (objc_protocol_type, + const_string_type_node, + NULL_TREE); + objc_v2_getprotocol_decl = add_builtin_function ("objc_getProtocol", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_v2_getprotocol_decl) = 0;*/ + + UOBJC_V2_CACHE_decl = create_extern_decl (ptr_type_node, + "_objc_empty_cache"); + + UOBJC_V2_VTABLE_decl = create_extern_decl (objc_v2_imp_type, + "_objc_empty_vtable"); + + /* id objc_getClass (const char *); */ + type = build_function_type_list (objc_object_type, + const_string_type_node, + NULL_TREE); + objc_get_class_decl = add_builtin_function (TAG_GETCLASS, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + /* id objc_getMetaClass (const char *); */ + objc_get_meta_class_decl = add_builtin_function (TAG_GETMETACLASS, + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + + /* This is the type of all of the following functions + objc_copyStruct(). */ + type = build_function_type_list (void_type_node, + ptr_type_node, + const_ptr_type_node, + ptrdiff_type_node, + boolean_type_node, + boolean_type_node, + NULL_TREE); + /* Declare the following function: + void + objc_copyStruct (void *destination, const void *source, + ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ + objc_copyStruct_decl = add_builtin_function ("objc_copyStruct", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_copyStruct_decl) = 0; + objc_getPropertyStruct_decl = NULL_TREE; + objc_setPropertyStruct_decl = NULL_TREE; + + gcc_assert (!flag_objc_sjlj_exceptions); + + /* Although we warn that fobjc-exceptions is required for exceptions + code, we carry on and create it anyway. */ + + /* This can be required, even when exceptions code is not present, + when an __attribute__((objc_exception)) is applied to a + class. */ + build_v2_ehtype_template (); + + /* void * objc_begin_catch (void *) */ + type = build_function_type (ptr_type_node, + tree_cons (NULL_TREE, ptr_type_node, + OBJC_VOID_AT_END)); + + objc2_begin_catch_decl = add_builtin_function ("objc_begin_catch", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc2_begin_catch_decl) = 0; + + /* void objc_end_catch () */ + type = build_function_type (void_type_node, OBJC_VOID_AT_END); + objc2_end_catch_decl = add_builtin_function ("objc_end_catch", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc2_end_catch_decl) = 0; + + /* void objc_exception_rethrow (void) */ + type = build_function_type (void_type_node, OBJC_VOID_AT_END); + objc_rethrow_exception_decl = + add_builtin_function ("objc_exception_rethrow", + type, 0, NOT_BUILT_IN, + NULL, NULL_TREE); + TREE_NOTHROW (objc_rethrow_exception_decl) = 0; + using_eh_for_cleanups (); + lang_hooks.eh_runtime_type = next_runtime_02_eh_type; + lang_hooks.eh_personality = objc_eh_personality; +} + +/* NOTE --- templates --- */ + +/* Set 'objc_v2_message_ref_template' to the data type node for + 'struct _message_ref_t'. This needs to be done just once per + compilation. Also Set 'objc_v2_super_message_ref_template' to data + type node for 'struct _super_message_ref_t'. */ + +/* struct _message_ref_t + { + IMP messenger; + SEL name; + }; + where IMP is: id (*) (id, _message_ref_t*, ...) +*/ + +/* struct _super_message_ref_t + { + SUPER_IMP messenger; + SEL name; + }; + where SUPER_IMP is: id (*) ( super_t*, _super_message_ref_t*, ...) +*/ + +static void +build_v2_message_ref_templates (void) +{ + tree ptr_message_ref_t; + tree decls, *chain = NULL; + + /* struct _message_ref_t {...} */ + objc_v2_message_ref_template = + objc_start_struct (get_identifier ("_message_ref_t")); + + /* IMP messenger; */ + ptr_message_ref_t = + build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier ("_message_ref_t"))); + + objc_v2_imp_type = + build_pointer_type (build_function_type_list + (objc_object_type, + objc_object_type, + ptr_message_ref_t, + NULL_TREE)); + + decls = add_field_decl (objc_v2_imp_type, "messenger", &chain); + + /* SEL name; */ + add_field_decl (objc_selector_type, "name", &chain); + + objc_finish_struct (objc_v2_message_ref_template, decls); + + objc_v2_selector_type = build_pointer_type (objc_v2_message_ref_template); + + chain = NULL; + /* struct _super_message_ref_t {...} */ + objc_v2_super_message_ref_template = + objc_start_struct (get_identifier ("_super_message_ref_t")); + + /* SUPER_IMP messenger; */ + ptr_message_ref_t = build_pointer_type + (xref_tag (RECORD_TYPE, + get_identifier ("_super_message_ref_t"))); + + objc_v2_super_imp_type = + build_pointer_type (build_function_type_list + (objc_object_type, + objc_super_type, + ptr_message_ref_t, + NULL_TREE)); + + add_field_decl (objc_v2_super_imp_type, "messenger", &chain); + + /* SEL name; */ + add_field_decl (objc_selector_type, "name", &chain); + + objc_finish_struct (objc_v2_super_message_ref_template, decls); + objc_v2_super_selector_type = + build_pointer_type (objc_v2_super_message_ref_template); +} + +/* Build following types which represent each class implementation. + +struct class_ro_t +{ + uint32_t const flags; + uint32_t const instanceStart; + uint32_t const instanceSize; +#ifdef __LP64__ + uint32_t const reserved; +#endif + const uint8_t * const ivarLayout; + const char *const name; + const struct method_list_t * const baseMethods; + const struct objc_protocol_list *const baseProtocols; + const struct ivar_list_t *const ivars; + const uint8_t * const weakIvarLayout; + const struct _prop_list_t * const properties; +}; + +struct class_t +{ + struct class_t *isa; + struct class_t *superclass; + void *cache; + IMP *vtable; + + ...When this is active - it will point to a rw version, but + when we build the meta-data we point it to the ro... + struct class_ro_t *data; +}; + +*/ + +static void +build_v2_class_templates (void) +{ + tree cnst_strg_type; + tree decls, *chain = NULL; + + /* struct class_ro_t {...} */ + objc_v2_class_ro_template = + objc_start_struct (get_identifier (UTAG_V2_CLASS_RO)); + + /* uint32_t const flags; */ + decls = add_field_decl (integer_type_node, "flags", &chain); + + /* uint32_t const instanceStart; */ + add_field_decl (integer_type_node, "instanceStart", &chain); + + /* uint32_t const instanceSize; */ + add_field_decl (integer_type_node, "instanceSize", &chain); + + /* This ABI is currently only used on m64 NeXT. We always + explicitly declare the alignment padding. */ + /* uint32_t const reserved; */ + add_field_decl (integer_type_node, "reserved", &chain); + + /* const uint8_t * const ivarLayout; */ + cnst_strg_type = build_pointer_type (unsigned_char_type_node); + add_field_decl (cnst_strg_type, "ivarLayout", &chain); + + /* const char *const name; */ + add_field_decl (string_type_node, "name", &chain); + + /* const struct method_list_t * const baseMethods; */ + add_field_decl (objc_method_list_ptr, "baseMethods", &chain); + + /* const struct objc_protocol_list *const baseProtocols; */ + add_field_decl (build_pointer_type + (xref_tag (RECORD_TYPE, + get_identifier (UTAG_V2_PROTOCOL_LIST))), + "baseProtocols", &chain); + + /* const struct ivar_list_t *const ivars; */ + add_field_decl (objc_v2_ivar_list_ptr, "ivars", &chain); + + /* const uint8_t * const weakIvarLayout; */ + add_field_decl (cnst_strg_type, "weakIvarLayout", &chain); + + /* struct _prop_list_t * baseProperties; */ + add_field_decl (objc_prop_list_ptr, "baseProperties", &chain); + + objc_finish_struct (objc_v2_class_ro_template, decls); + + chain = NULL; + /* struct class_t {...} */ + objc_v2_class_template = + objc_start_struct (get_identifier (UTAG_V2_CLASS)); + + /* struct class_t *isa; */ + decls = add_field_decl (build_pointer_type (objc_v2_class_template), + "isa", &chain); + + /* struct class_t * const superclass; */ + add_field_decl (build_pointer_type (objc_v2_class_template), + "superclass", &chain); + + /* void *cache; */ + add_field_decl (build_pointer_type (void_type_node), "cache", &chain); + + /* IMP *vtable; */ + add_field_decl (build_pointer_type (objc_v2_imp_type), "vtable", &chain); + + /* struct class_ro_t *ro; */ + add_field_decl (build_pointer_type (objc_v2_class_ro_template), "ro", &chain); + + objc_finish_struct (objc_v2_class_template, decls); +} + +/* struct _objc_super + { + struct _objc_object *self; + Class cls; + }; */ +void +build_v2_super_template (void) +{ + tree decls, *chain = NULL; + + objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER)); + + /* struct _objc_object *self; */ + decls = add_field_decl (objc_object_type, "self", &chain); + + /* Class cls; */ + add_field_decl (objc_class_type, "cls", &chain); + + objc_finish_struct (objc_super_template, decls); +} + +/* struct protocol_t + { + Class isa; + const char * const protocol_name; + const struct protocol_list_t * const protocol_list; + const struct method_list_t * const instance_methods; + const struct method_list_t * const class_methods; + const struct method_list_t * optionalInstanceMethods; + const struct method_list_t * optionalClassMethod + const struct _prop_list_t * const properties; + const uint32_t size; + const uint32_t flags; + } +*/ +static void +build_v2_protocol_template (void) +{ + tree decls, *chain = NULL; + + objc_v2_protocol_template = + objc_start_struct (get_identifier (UTAG_V2_PROTOCOL)); + + /* Class isa; */ + decls = add_field_decl (objc_object_type, "isa", &chain); + + /* char *protocol_name; */ + add_field_decl (string_type_node, "protocol_name", &chain); + + /* const struct protocol_list_t * const protocol_list; */ + add_field_decl (build_pointer_type (objc_v2_protocol_template), + "protocol_list", &chain); + + /* const struct method_list_t * const instance_methods; */ + add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain); + + /* const struct method_list_t * const class_methods; */ + add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain); + + /* const struct method_list_t * optionalInstanceMethods; */ + add_field_decl (objc_method_proto_list_ptr, "optionalInstanceMethods", &chain); + + /* const struct method_list_t * optionalClassMethods; */ + add_field_decl (objc_method_proto_list_ptr, "optionalClassMethods", &chain); + + /* struct _prop_list_t * properties; */ + add_field_decl (objc_prop_list_ptr, "properties", &chain); + + /* const uint32_t size; */ + add_field_decl (integer_type_node, "size", &chain); + + /* const uint32_t flags; */ + add_field_decl (integer_type_node, "flags", &chain); + + objc_finish_struct (objc_v2_protocol_template, decls); +} + +/* Build type for a category: + struct category_t + { + const char * const name; + struct class_t *const cls; + const struct method_list_t * const instance_methods; + const struct method_list_t * const class_methods; + const struct protocol_list_t * const protocols; + const struct _prop_list_t * const properties; + } +*/ + +static void +build_v2_category_template (void) +{ + tree decls, *chain = NULL; + + objc_v2_category_template = + objc_start_struct (get_identifier ("_category_t")); + + /* char *name; */ + decls = add_field_decl (string_type_node, "name", &chain); + + /* struct class_t *const cls; */ + add_field_decl (build_pointer_type (objc_v2_class_template), "cls", &chain); + + /* struct method_list_t *instance_methods; */ + add_field_decl (objc_method_list_ptr, "instance_methods", &chain); + + /* struct method_list_t *class_methods; */ + add_field_decl (objc_method_list_ptr, "class_methods", &chain); + + /* struct protocol_list_t *protocol_list; */ + add_field_decl (build_pointer_type (objc_v2_protocol_template), + "protocol_list", &chain ); + + /* struct _prop_list_t * properties; */ + add_field_decl (objc_prop_list_ptr, "properties", &chain); + + objc_finish_struct (objc_v2_category_template, decls); +} + +/* NOTE --- Decls, Identifiers, Names etc. --- */ + +/* This routine is given a name and returns a matching extern variable + if one is found. */ + +static tree +hash_name_lookup (hash *hashlist, tree name) +{ + hash target; + + target = hashlist[IDENTIFIER_HASH_VALUE (name) % SIZEHASHTABLE]; + + while (target) + { + if (name == DECL_NAME (target->key)) + return target->key; + + target = target->next; + } + return 0; +} + +/* This routine is given an extern variable and enters it in its hash + table. Note that hashing is done on its inner IDENTIFIER_NODE + node. */ + +static void +hash_name_enter (hash *hashlist, tree id) +{ + hash obj; + int slot = IDENTIFIER_HASH_VALUE (DECL_NAME (id)) % SIZEHASHTABLE; + + obj = ggc_alloc_hashed_entry (); + obj->list = 0; + obj->next = hashlist[slot]; + obj->key = id; + + hashlist[slot] = obj; /* append to front */ +} + +/* Create a declaration "extern ;" + The var will need to be finalized (e.g. by calling finish_var_decl()). */ + +static tree +create_extern_decl (tree type, const char *name) +{ + tree id = get_identifier (name); + tree var = hash_name_lookup (extern_names, id); + if (var) + return var; + /* New name. */ + var = start_var_decl (type, name); + TREE_STATIC (var) = 0; + DECL_EXTERNAL (var) = 1; + TREE_PUBLIC (var) = 1; + hash_name_enter (extern_names, var); + return var; +} + +/* Create a globally visible definition for variable NAME of a given TYPE. The + finish_var_decl() routine will need to be called on it afterwards. */ + +static tree +create_global_decl (tree type, const char *name) +{ + tree id = get_identifier (name); + tree var = hash_name_lookup (extern_names, id); + if (var) + { + DECL_EXTERNAL (var) = 0; + TREE_STATIC (var) = 1; + } + else + { + var = start_var_decl (type, name); + hash_name_enter (extern_names, var); + } + TREE_PUBLIC (var) = 1; + return var; +} + +/* Create a symbol with __attribute__ ((visibility ("hidden"))) + attribute (private extern). */ + +static tree +create_hidden_decl (tree type, const char *name) +{ + tree decl = create_global_decl (type, name); + DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; + DECL_VISIBILITY_SPECIFIED (decl) = 1; + return decl; +} + +/* Irritatingly, we have a different superclass field name for ABI=2. */ +/* PS/TODO: The field name does not matter, it is only used internally + by the compiler. We can rename it to whatever we want. ;-) */ + +static tree +next_runtime_abi_02_super_superclassfield_id (void) +{ + /* TODO: Simplify. Just always return get_identifier ("cls"), or at + most look it once at startup then always return it. */ + if (!super_superclassfield_id) + super_superclassfield_id = get_identifier ("cls"); + return super_superclassfield_id; +} + +static tree +next_runtime_abi_02_class_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass))); + /* ObjC2 classes are extern visible. */ + decl = create_global_decl (objc_v2_class_template, buf); + OBJCMETA (decl, objc_meta, meta_class); + return decl; +} + +static tree +next_runtime_abi_02_metaclass_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass))); + /* ObjC2 classes are extern visible. */ + decl = create_global_decl (objc_v2_class_template, buf); + OBJCMETA (decl, objc_meta, meta_metaclass); + return decl; +} + +static tree +next_runtime_abi_02_category_decl (tree klass) +{ + tree decl; + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s", + IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)), + IDENTIFIER_POINTER (CLASS_NAME (klass))); + decl = start_var_decl (objc_v2_category_template, buf); + OBJCMETA (decl, objc_meta, meta_category); + return decl; +} + +static tree +next_runtime_abi_02_protocol_decl (tree p) +{ + tree decl; + char buf[BUFSIZE]; + + /* static struct _objc_protocol _OBJC_Protocol_; */ + snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (p))); + decl = start_var_decl (objc_v2_protocol_template, buf); + OBJCMETA (decl, objc_meta, meta_protocol); + return decl; +} + +static tree +next_runtime_abi_02_string_decl (tree type, const char *name, string_section where) +{ + tree var = start_var_decl (type, name); + switch (where) + { + case class_names: + OBJCMETA (var, objc_meta, meta_class_name); + break; + case meth_var_names: + OBJCMETA (var, objc_meta, meta_meth_name); + break; + case meth_var_types: + OBJCMETA (var, objc_meta, meta_meth_type); + break; + case prop_names_attr: + OBJCMETA (var, objc_meta, meta_prop_name_attr); + break; + default: + OBJCMETA (var, objc_meta, meta_base); + break; + } + return var; +} + +/* NOTE --- entry --- */ + +typedef struct GTY(()) ident_data_tuple { + tree ident; + tree data; +} ident_data_tuple ; +DEF_VEC_O(ident_data_tuple); +DEF_VEC_ALLOC_O(ident_data_tuple, gc); + +/* This routine creates a file scope static variable of type 'Class' + to hold the address of a class. */ + +static tree +build_v2_class_reference_decl (tree ident) +{ + tree decl; + char buf[BUFSIZE]; + + snprintf (buf, BUFSIZE, "_OBJC_ClassRef_%s", IDENTIFIER_POINTER (ident)); + decl = start_var_decl (objc_class_type, buf); + OBJCMETA (decl, objc_meta, meta_class_ref); + return decl; +} + +/* This routine builds a class refs entry for each class name used. + Initially, a (static-ref, IDENT) tuple is added to the list. The + ident is replaced with address of the class metadata (of type + 'Class') in the output routine. */ + +static GTY (()) VEC (ident_data_tuple, gc) * classrefs; + +static tree +objc_v2_get_class_reference (tree ident) +{ + tree decl; + ident_data_tuple e; + if (classrefs) + { + int count; + ident_data_tuple *ref; + FOR_EACH_VEC_ELT (ident_data_tuple, classrefs, count, ref) + { + if (ref->ident == ident) + { + if (!ref->data) + ref->data = build_v2_class_reference_decl (ident); + return ref->data; + } + } + } + else + /* Somewhat arbitrary initial provision. */ + classrefs = VEC_alloc (ident_data_tuple, gc, 16); + + /* We come here if we don't find the entry - or if the table was yet + to be created. */ + decl = build_v2_class_reference_decl (ident); + e.ident = ident; + e.data = decl; + VEC_safe_push (ident_data_tuple, gc, classrefs, &e); + return decl; +} + +static tree +next_runtime_abi_02_get_class_reference (tree ident) +{ + if (!flag_zero_link) + return objc_v2_get_class_reference (ident); + else + { + /* We fall back to using objc_getClass (). */ + VEC(tree,gc) *vec = VEC_alloc (tree, gc, 1); + tree t; + /* ??? add_class_reference (ident); - is pointless, since the + system lib does not export the equivalent symbols. Maybe we + need to build a class ref anyway. */ + t = my_build_string_pointer (IDENTIFIER_LENGTH (ident) + 1, + IDENTIFIER_POINTER (ident)); + VEC_quick_push (tree, vec, t); + t = build_function_call_vec (input_location, objc_get_class_decl, + vec, NULL); + VEC_free (tree, gc, vec); + return t; + } +} + +/* Used by get_arg_type_list. + Return the types for receiver & _cmd at the start of a method + argument list. context is either METHOD_DEF or METHOD_REF, saying + whether we are trying to define a method or call one. superflag + says this is for a send to super. meth may be NULL, in the case + that there is no prototype. */ + +static tree +next_runtime_abi_02_get_arg_type_list_base (tree meth, int context, int superflag) +{ + tree arglist; + + /* Receiver type. */ + if (superflag) + arglist = build_tree_list (NULL_TREE, objc_super_type); + else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL) + arglist = build_tree_list (NULL_TREE, objc_instance_type); + else + arglist = build_tree_list (NULL_TREE, objc_object_type); + + /* Selector type - will eventually change to `int'. */ + chainon (arglist, build_tree_list (NULL_TREE, + (superflag ? objc_v2_super_selector_type + : objc_v2_selector_type))); + return arglist; +} + +/* TODO: Merge this with the message refs. */ +static tree +build_selector_reference_decl (tree ident) +{ + tree decl; + char *t, buf[BUFSIZE]; + + snprintf (buf, BUFSIZE, "_OBJC_SelRef_%s", IDENTIFIER_POINTER (ident)); + t = buf; + while (*t) + { + if (*t==':') + *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */ + t++; + } + decl = start_var_decl (objc_selector_type, buf); + OBJCMETA (decl, objc_meta, meta_sel_refs); + return decl; +} + +static tree +next_runtime_abi_02_build_selector_reference (location_t loc ATTRIBUTE_UNUSED, + tree ident, + tree proto ATTRIBUTE_UNUSED) +{ + tree *chain = &sel_ref_chain; + tree expr; + + while (*chain) + { + if (TREE_VALUE (*chain) == ident) + return TREE_PURPOSE (*chain); + + chain = &TREE_CHAIN (*chain); + } + + expr = build_selector_reference_decl (ident); + *chain = tree_cons (expr, ident, NULL_TREE); + + return expr; +} + +/* Declare a variable of type 'struct message_ref_t'. */ +/* This will be finished in build_v2_message_ref_translation_table (). + We take an idea from LLVM in making the names a bit more connected + and thus the asm more readable. */ + +static tree +build_v2_message_reference_decl (tree sel_name, tree message_func_ident) +{ + tree decl; + char buf[BUFSIZE], *t; + int offset = 12; + + /* Skip past the objc_msgSend it's the same for all... */ + if (IDENTIFIER_POINTER (message_func_ident)[offset] == '_') + offset++; + + snprintf (buf, BUFSIZE, "_OBJC_MsgRef_%s_%s", + &(IDENTIFIER_POINTER (message_func_ident)[offset]), + IDENTIFIER_POINTER (sel_name)); + t = buf; + while (*t) + { + if (*t==':') + *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */ + t++; + } + decl = start_var_decl (objc_v2_message_ref_template, buf); + OBJCMETA (decl, objc_meta, meta_mref); + return decl; +} + +typedef struct GTY(()) msgref_entry { + tree func; + tree selname; + tree refdecl; +} msgref_entry; +DEF_VEC_O(msgref_entry); +DEF_VEC_ALLOC_O(msgref_entry, gc); + +static GTY (()) VEC (msgref_entry, gc) * msgrefs; + +/* Build the list of (objc_msgSend_fixup_xxx, selector name), used + later on to initialize the table of 'struct message_ref_t' + elements. */ + +static tree +build_v2_selector_messenger_reference (tree sel_name, tree message_func_decl) +{ + tree decl; + msgref_entry e; + if (msgrefs) + { + int count; + msgref_entry *ref; + FOR_EACH_VEC_ELT (msgref_entry, msgrefs, count, ref) + if (ref->func == message_func_decl && ref->selname == sel_name) + return ref->refdecl; + } + else + /* Somewhat arbitrary initial provision. */ + msgrefs = VEC_alloc (msgref_entry, gc, 32); + + /* We come here if we don't find a match or at the start. */ + decl = build_v2_message_reference_decl (sel_name, + DECL_NAME (message_func_decl)); + e.func = message_func_decl; + e.selname = sel_name; + e.refdecl = decl; + VEC_safe_push (msgref_entry, gc, msgrefs, &e); + return decl; +} + +static tree +build_v2_protocollist_ref_decl (tree protocol) +{ + tree decl; + tree protocol_ident = PROTOCOL_NAME (protocol); + char buf[BUFSIZE]; + + snprintf (buf, BUFSIZE, "_OBJC_ProtocolRef_%s", + IDENTIFIER_POINTER (protocol_ident)); + /* TODO: other compiler versions make these hidden & weak. */ + decl = create_global_decl (objc_protocol_type, buf); + /* Let optimizer know that this decl is not removable. */ + DECL_PRESERVE_P (decl) = 1; + OBJCMETA (decl, objc_meta, meta_proto_ref); + return decl; +} + +typedef struct GTY(()) prot_list_entry { + tree id; + tree refdecl; +} prot_list_entry; +DEF_VEC_O(prot_list_entry); +DEF_VEC_ALLOC_O(prot_list_entry, gc); +static GTY (()) VEC (prot_list_entry, gc) * protrefs; + +static tree +objc_v2_get_protocol_reference (tree ident) +{ + tree decl; + prot_list_entry e; + if (protrefs) + { + int count; + prot_list_entry *ref; + FOR_EACH_VEC_ELT (prot_list_entry, protrefs, count, ref) + { + if (ref->id == ident) + { + if (!ref->refdecl) + ref->refdecl = build_v2_protocollist_ref_decl (ident); + return ref->refdecl; + } + } + } + else + /* Somewhat arbitrary initial provision. */ + protrefs = VEC_alloc (prot_list_entry, gc, 32); + + /* We come here if we don't find the entry - or if the table was yet + to be created. */ + decl = build_v2_protocollist_ref_decl (ident); + e.id = ident; + e.refdecl = decl; + VEC_safe_push (prot_list_entry, gc, protrefs, &e); + return decl; +} + +static tree +next_runtime_abi_02_get_protocol_reference (location_t loc ATTRIBUTE_UNUSED, + tree p) +{ + if (!PROTOCOL_FORWARD_DECL (p)) + PROTOCOL_FORWARD_DECL (p) = next_runtime_abi_02_protocol_decl (p); + + return objc_v2_get_protocol_reference (p); +} + +/* This routine returns the ivar declaration, if component is a valid + ivar field; NULL_TREE otherwise. On finding an ivar, it also + returns the class name in CLASS. */ + +static tree +objc_is_ivar (tree expr, tree component, tree *klass) +{ + tree field = NULL_TREE; + tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); + + if (TREE_CODE (basetype) == RECORD_TYPE + && TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype)) + { + *klass = lookup_interface (OBJC_TYPE_NAME (basetype)); + if (*klass) + { + do + { + tree ivar_chain = CLASS_RAW_IVARS (*klass); + if (ivar_chain) + { + field = is_ivar (ivar_chain, component); + if (field != NULL_TREE) + break; + } + *klass = lookup_interface (CLASS_SUPER_NAME (*klass)); + } + while (*klass); + } + } + return field; +} + +static void +create_ivar_offset_name (char *buf, tree class_name, tree field_decl) +{ + tree fname = DECL_NAME (field_decl); + + sprintf (buf, "OBJC_IVAR_$_%s.%s", IDENTIFIER_POINTER (class_name), + IDENTIFIER_POINTER (fname)); + return; +} + +/* This routine generates new abi's ivar reference tree. It amounts + to generating *(TYPE*)((char*)pObj + OFFSET_IVAR) when we normally + generate pObj->IVAR. OFFSET_IVAR is an 'extern' variable holding + the offset for 'IVAR' field. TYPE is type of IVAR field. */ + +static tree +objc_v2_build_ivar_ref (tree datum, tree component) +{ + tree field, ref, class_name, offset, ftype, expr; + char var_offset_name[512]; + + field = objc_is_ivar (datum, component, &class_name); + if (!field) + return NULL_TREE; + + /* This routine only handles non-bitfield fields */ + /* DECL_INITIAL macro is set to width of bitfield and can be relied + on to check for bitfield ivars. Note that I cannot rely on + DECL_BIT_FIELD macro because it is only set when the whole struct + is seen (at finish_struct) and not when the ivar chain is + built. */ + if (DECL_INITIAL (field)) + return NULL_TREE; + + create_ivar_offset_name (var_offset_name, CLASS_NAME (class_name), field); + + offset = create_extern_decl (TREE_TYPE (size_zero_node), var_offset_name); + + ftype = TREE_TYPE (field); + + /* (char*)datum */ + expr = build_c_cast (input_location, + string_type_node, build_fold_addr_expr (datum)); + + /* (char*)datum + offset */ + expr = fold_build2_loc (input_location, + POINTER_PLUS_EXPR, string_type_node, expr, offset); + + /* (ftype*)((char*)datum + offset) */ + expr = build_c_cast (input_location, build_pointer_type (ftype), expr); + + /* Finally: *(ftype*)((char*)datum + offset) */ + ref = build_indirect_ref (input_location, expr, RO_UNARY_STAR); + + /* We must set type of the resulting expression to be the same as + the field type. This is because, build_indirect_ref (...) + rebuilds the type which may result in lost information; as in the + case of protocol-qualified types (id ). */ + TREE_TYPE (ref) = ftype; + + if (TREE_READONLY (datum) || TREE_READONLY (field)) + TREE_READONLY (ref) = 1; + + if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field)) + TREE_THIS_VOLATILE (ref) = 1; + + if (TREE_DEPRECATED (field)) + warn_deprecated_use (field, NULL_TREE); + + return ref; +} + +/* IVAR refs are made via an externally referenceable offset and built + on the fly. That is, unless they refer to (private) fields in the + class stucture. */ +static tree +next_runtime_abi_02_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED, + tree base, tree id) +{ + tree ivar; + if ((ivar = objc_v2_build_ivar_ref (base, id))) + return ivar; + return objc_build_component_ref (base, id); +} + +/* [super ...] references are listed here (and built into a table at + meta -data emit time). */ +static tree +build_v2_superclass_ref_decl (tree ident, bool inst) +{ + tree decl; + char buf[BUFSIZE]; + + snprintf (buf, BUFSIZE, "_OBJC_%sSuperRef_%s", (inst?"":"Meta"), + IDENTIFIER_POINTER (ident)); + decl = start_var_decl (objc_class_type, buf); + OBJCMETA (decl, objc_meta, meta_superclass_ref); + return decl; +} + +static GTY (()) VEC (ident_data_tuple, gc) * class_super_refs; +static GTY (()) VEC (ident_data_tuple, gc) * metaclass_super_refs; + +static tree +next_runtime_abi_02_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED, + struct imp_entry *imp, bool inst_meth) +{ + tree decl; + ident_data_tuple e; + tree id = CLASS_NAME (imp->imp_context); + VEC (ident_data_tuple, gc) *list = inst_meth ? class_super_refs + : metaclass_super_refs; + + if (list) + { + int count; + ident_data_tuple *ref; + FOR_EACH_VEC_ELT (ident_data_tuple, list, count, ref) + { + if (ref->ident == id) + { + if (!ref->data) + ref->data = build_v2_superclass_ref_decl (id, inst_meth); + return ref->data; + } + } + } + else + { + /* Somewhat arbitrary initial provision. */ + if (inst_meth) + list = class_super_refs = VEC_alloc (ident_data_tuple, gc, 16); + else + list = metaclass_super_refs = VEC_alloc (ident_data_tuple, gc, 16); + } + /* We come here if we don't find the entry - or if the table was yet + to be created. */ + decl = build_v2_superclass_ref_decl (id, inst_meth); + e.ident = id; + e.data = decl; + VEC_safe_push (ident_data_tuple, gc, list, &e); + return decl; +} + +static tree +next_runtime_abi_02_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED, + struct imp_entry *imp, bool inst_meth) +{ + /* ??? is this OK when zero-link = true? */ + tree super_name = CLASS_SUPER_NAME (imp->imp_template); + tree super_class; + + if (!flag_zero_link) + { + super_class = objc_get_class_reference (CLASS_NAME (imp->imp_template)); + + if (!inst_meth) + + /* If we are in a class method, we must retrieve the + _metaclass_ for the current class, pointed at by the + class's "isa" pointer. The following assumes that "isa" is + the first ivar in a class (which it must be). */ + super_class = + build_indirect_ref (input_location, + build_c_cast (input_location, + build_pointer_type (objc_class_type), + super_class), + RO_UNARY_STAR); + return super_class; + } + /* ??? Do we need to add the class ref anway for zero-link? */ + /* else do it the slow way. */ + super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl); + /* assemble_external (super_class); */ + super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1, + IDENTIFIER_POINTER (super_name)); + /* super_class = objc_get{Meta}Class("CLASS_SUPER_NAME"); */ + return build_function_call (input_location, + super_class, + build_tree_list (NULL_TREE, super_name)); +} + +static tree +next_runtime_abi_02_receiver_is_class_object (tree receiver) +{ + if (TREE_CODE (receiver) == VAR_DECL + && IS_CLASS (TREE_TYPE (receiver)) + && classrefs + && VEC_length (ident_data_tuple, classrefs)) + { + int count; + ident_data_tuple *ref; + /* The receiver is a variable created by build_class_reference_decl. */ + FOR_EACH_VEC_ELT (ident_data_tuple, classrefs, count, ref) + if (ref->data == receiver) + return ref->ident; + } + return NULL_TREE; +} + +/* Assign all arguments in VALUES which have side-effect to a + temporary and replaced that argument in VALUES list with the + temporary. TYPELIST is the list of argument types. */ + +static tree +objc_copy_to_temp_side_effect_params (tree typelist, tree values) +{ + tree valtail, typetail; + /* Skip over receiver and the &_msf_ref types. */ + gcc_assert (TREE_CHAIN (typelist)); + typetail = TREE_CHAIN (TREE_CHAIN (typelist)); + + for (valtail = values; valtail; + valtail = TREE_CHAIN (valtail), typetail = TREE_CHAIN (typetail)) + { + tree value = TREE_VALUE (valtail); + tree type = typetail ? TREE_VALUE (typetail) : NULL_TREE; + if (type == NULL_TREE) + break; + if (!TREE_SIDE_EFFECTS (value)) + continue; + /* To prevent re-evaluation. */ + value = save_expr (value); + add_stmt (value); + TREE_VALUE (valtail) = value; + } + return values; +} + +/* Build the new abi's messaging library call. It looks like: + (*_msg.messenger) (receiver, &_msg, ...) */ + +static tree +build_v2_build_objc_method_call (int super_flag, tree method_prototype, + tree lookup_object, tree selector, + tree method_params, + bool check_for_nil) +{ + tree ret_val; + tree sender, rcv_p, t; + tree ret_type + = (method_prototype + ? TREE_VALUE (TREE_TYPE (method_prototype)) + : objc_object_type); + tree method_param_types = get_arg_type_list (method_prototype, + METHOD_REF, super_flag); + + tree ftype = build_function_type (ret_type, method_param_types); + tree sender_cast; + + if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype)) + ftype = build_type_attribute_variant ( + ftype, METHOD_TYPE_ATTRIBUTES (method_prototype)); + + sender_cast = build_pointer_type (ftype); + + if (check_for_nil) + method_params = objc_copy_to_temp_side_effect_params (method_param_types, + method_params); + + /* Get &message_ref_t.messenger. */ + sender = build_c_cast (input_location, + build_pointer_type (super_flag + ? objc_v2_super_imp_type + : objc_v2_imp_type), + selector); + + sender = build_indirect_ref (input_location, sender, RO_UNARY_STAR); + + rcv_p = (super_flag ? objc_super_type : objc_object_type); + + lookup_object = build_c_cast (input_location, rcv_p, lookup_object); + + /* Use SAVE_EXPR to avoid evaluating the receiver twice. */ + lookup_object = save_expr (lookup_object); + + method_params = tree_cons (NULL_TREE, lookup_object, + tree_cons (NULL_TREE, selector, + method_params)); + t = build3 (OBJ_TYPE_REF, sender_cast, sender, lookup_object, size_zero_node); + ret_val = build_function_call (input_location, t, method_params); + if (check_for_nil) + { + /* receiver != nil ? ret_val : 0 */ + tree ftree; + tree ifexp; + + if (TREE_CODE (ret_type) == RECORD_TYPE + || TREE_CODE (ret_type) == UNION_TYPE) + { + VEC(constructor_elt,gc) *rtt = NULL; + /* ??? CHECKME. hmmm..... think we need something more + here. */ + CONSTRUCTOR_APPEND_ELT (rtt, NULL_TREE, NULL_TREE); + ftree = objc_build_constructor (ret_type, rtt); + } + else + ftree = fold_convert (ret_type, integer_zero_node); + + ifexp = build_binary_op (input_location, NE_EXPR, + lookup_object, + fold_convert (rcv_p, integer_zero_node), 1); + +#ifdef OBJCPLUS + ret_val = build_conditional_expr (ifexp, ret_val, ftree, tf_warning_or_error); +#else + /* ??? CHECKME. */ + ret_val = build_conditional_expr (input_location, + ifexp, 1, + ret_val, NULL_TREE, + ftree, NULL_TREE); +#endif + } + return ret_val; +} + +static tree +next_runtime_abi_02_build_objc_method_call (location_t loc, + tree method_prototype, + tree receiver, + tree rtype, + tree sel_name, + tree method_params, + int super) +{ + tree ret_type, selector; + tree message_func_decl; + bool check_for_nil = flag_objc_nilcheck; + + ret_type = (method_prototype ? + TREE_VALUE (TREE_TYPE (method_prototype)) : + objc_object_type); + + /* Do we need to check for nil receivers ? */ + /* For now, message sent to classes need no nil check. In the + future, class declaration marked as weak_import must be nil + checked. */ + if (super + || (TREE_CODE (receiver) == VAR_DECL + && TREE_TYPE (receiver) == objc_class_type)) + check_for_nil = false; + + if (!targetm.calls.struct_value_rtx (0, 0) + && (TREE_CODE (ret_type) == RECORD_TYPE + || TREE_CODE (ret_type) == UNION_TYPE) + && targetm.calls.return_in_memory (ret_type, 0)) + { + if (super) + message_func_decl = umsg_id_super2_stret_fixup_decl; + else + message_func_decl = objc_is_id (rtype) + ? umsg_id_stret_fixup_decl + : umsg_stret_fixup_decl; + } + else + { + if (super) + message_func_decl = umsg_id_super2_fixup_decl; + else + message_func_decl = objc_is_id (rtype) + ? umsg_id_fixup_decl + : umsg_fixup_decl; + } + + selector = build_v2_selector_messenger_reference (sel_name, + message_func_decl); + + /* selector = &_msg; */ + selector = build_unary_op (loc, ADDR_EXPR, selector, 0); + + selector = build_c_cast (loc, (super ? objc_v2_super_selector_type + : objc_v2_selector_type), + selector); + + /* (*_msg.messenger) (receiver, &_msg, ...); */ + return build_v2_build_objc_method_call (super, method_prototype, + receiver, selector, + method_params, check_for_nil); +} + +/* NOTE --- Constant String Class Stuff --- */ + +static bool +next_runtime_abi_02_setup_const_string_class_decl (void) +{ + if (!constant_string_global_id) + { + /* Hopefully, this should not represent a serious limitation. */ + char buf[BUFSIZE]; + snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", constant_string_class_name); + constant_string_global_id = get_identifier (buf); + } + + string_class_decl = lookup_name (constant_string_global_id); + + /* In OBJC2 abi, constant string class reference refers to class + name for NSConstantString class. This declaration may not be + available yet (in fact it is not in most cases). So, declare an + extern OBJC_CLASS_$_NSConstantString in its place. */ + if (!string_class_decl) + string_class_decl = + create_extern_decl (objc_v2_class_template, + IDENTIFIER_POINTER (constant_string_global_id)); + + return (string_class_decl != NULL_TREE); +} + +static tree +next_runtime_abi_02_build_const_string_constructor (location_t loc, tree string, + int length) +{ + tree constructor, fields, var; + VEC(constructor_elt,gc) *v = NULL; + + /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */ + fields = TYPE_FIELDS (internal_const_str_type); + CONSTRUCTOR_APPEND_ELT (v, fields, + build_unary_op (loc, ADDR_EXPR, string_class_decl, 0)); + + fields = DECL_CHAIN (fields); + CONSTRUCTOR_APPEND_ELT (v, fields, + build_unary_op (loc, ADDR_EXPR, string, 1)); + + /* ??? check if this should be long. */ + fields = DECL_CHAIN (fields); + CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length)); + constructor = objc_build_constructor (internal_const_str_type, v); + + var = build_decl (input_location, CONST_DECL, NULL, TREE_TYPE (constructor)); + DECL_INITIAL (var) = constructor; + TREE_STATIC (var) = 1; + DECL_CONTEXT (var) = NULL; + OBJCMETA (var, objc_meta, meta_const_str); + return var; +} + +/* NOTE --- NeXT V2 Metadata templates --- */ + +/* This routine builds the following type: + struct _prop_t + { + const char * const name; // property name + const char * const attributes; // comma-delimited, encoded, + // property attributes + }; +*/ + +static tree +build_v2_property_template (void) +{ + tree prop_record; + tree decls, *chain = NULL; + + prop_record = objc_start_struct (get_identifier ("_prop_t")); + /* const char * name */ + decls = add_field_decl (string_type_node, "name", &chain); + + /* const char * attribute */ + add_field_decl (string_type_node, "attribute", &chain); + + objc_finish_struct (prop_record, decls); + return prop_record; +} + +/* struct ivar_t + { + unsigned long int *offset; + char *name; + char *type; + uint32_t alignment; + uint32_t size; + }; +*/ + +static tree +build_v2_ivar_t_template (void) +{ + tree objc_ivar_id, objc_ivar_record; + tree decls, *chain = NULL; + + objc_ivar_id = get_identifier ("_ivar_t"); + objc_ivar_record = objc_start_struct (objc_ivar_id); + + /* unsigned long int *offset; */ + decls = add_field_decl (build_pointer_type + (TREE_TYPE (size_zero_node)), "offset", &chain); + + /* char *name; */ + add_field_decl (string_type_node, "name", &chain); + + /* char *type; */ + add_field_decl (string_type_node, "type", &chain); + + /* uint32_t alignment; */ + add_field_decl (integer_type_node, "alignment", &chain); + + /* uint32_t size; */ + add_field_decl (integer_type_node, "size", &chain); + + objc_finish_struct (objc_ivar_record, decls); + return objc_ivar_record; +} + +static void +build_metadata_templates (void) +{ + + if (!objc_method_template) + objc_method_template = build_method_template (); + + if (!objc_v2_property_template) + objc_v2_property_template = build_v2_property_template (); + + if (!objc_v2_ivar_template) + objc_v2_ivar_template = build_v2_ivar_t_template (); + +} + +/* NOTE --- Output NeXT V2 Metadata --- */ + +/* Routine builds name of Interface's main meta-data of type class_t. */ + +static char * +objc_build_internal_classname (tree ident, bool metaclass) +{ + static char string[512]; + snprintf (string, 512, "%s_%s", metaclass ? "OBJC_METACLASS_$" + : "OBJC_CLASS_$", + IDENTIFIER_POINTER (ident)); + return string; +} + +/* Build the name for object of type struct class_ro_t */ + +static const char * +newabi_append_ro (const char *name) +{ + char *dollar; + char *p; + static char string[BUFSIZE]; + dollar = strchr (name, '$'); + gcc_assert (dollar); + p = string; + *p = '_'; p++; + strncpy (p, name, (int)(dollar - name)); + p += (int)(dollar - name); + sprintf (p, "RO_%s", dollar); + return string; +} + +/* Build the struct message_ref_t msg = + {objc_msgSend_fixup_xxx, @selector(func)} + table. */ + +static +void build_v2_message_ref_translation_table (void) +{ + int count; + msgref_entry *ref; + + if (!msgrefs || !VEC_length (msgref_entry,msgrefs)) + return; + + FOR_EACH_VEC_ELT (msgref_entry, msgrefs, count, ref) + { + VEC(constructor_elt,gc) *initializer; + tree expr, constructor; + tree struct_type = TREE_TYPE (ref->refdecl); + location_t loc = DECL_SOURCE_LOCATION (ref->refdecl); + + initializer = NULL; + /* First 'IMP messenger' field... */ + expr = build_unary_op (loc, ADDR_EXPR, ref->func, 0); + expr = convert (objc_v2_imp_type, expr); + CONSTRUCTOR_APPEND_ELT (initializer, NULL_TREE, expr); + + /* ... then 'SEL name' field. */ + expr = build_selector (ref->selname); + CONSTRUCTOR_APPEND_ELT (initializer, NULL_TREE, expr); + constructor = objc_build_constructor (struct_type, initializer); + finish_var_decl (ref->refdecl, constructor); + } +} + +/* Build decl = initializer; for each externally visible class + reference. */ + +static void +build_v2_classrefs_table (void) +{ + int count; + ident_data_tuple *ref; + + if (!classrefs || !VEC_length (ident_data_tuple, classrefs)) + return; + + FOR_EACH_VEC_ELT (ident_data_tuple, classrefs, count, ref) + { + tree expr = ref->ident; + tree decl = ref->data; + /* Interface with no implementation and yet one of its messages + has been used. Need to generate a full address-of tree for it + here. */ + if (TREE_CODE (expr) == IDENTIFIER_NODE) + { + const char *name = objc_build_internal_classname (expr, false); + expr = create_extern_decl (objc_v2_class_template, name); + expr = convert (objc_class_type, build_fold_addr_expr (expr)); + } + /* The runtime wants this, even if it appears unused, so we must force the + output. + DECL_PRESERVE_P (decl) = 1; */ + finish_var_decl (decl, expr); + } +} + +/* Build decl = initializer; for each externally visible super class + reference. */ + +static void +build_v2_super_classrefs_table (bool metaclass) +{ + int count; + ident_data_tuple *ref; + VEC (ident_data_tuple, gc) *list = metaclass ? metaclass_super_refs + : class_super_refs; + + if (!list || !VEC_length (ident_data_tuple, list)) + return; + + FOR_EACH_VEC_ELT (ident_data_tuple, list, count, ref) + { + tree expr = ref->ident; + tree decl = ref->data; + /* Interface with no implementation and yet one of its messages + has been used. Need to generate a full address-of tree for it + here. */ + if (TREE_CODE (expr) == IDENTIFIER_NODE) + { + const char * name = objc_build_internal_classname (expr, metaclass); + expr = create_extern_decl (objc_v2_class_template, name); + expr = convert (objc_class_type, build_fold_addr_expr (expr)); + } + finish_var_decl (decl, expr); + } +} + +/* Add the global class meta-data declaration to the list which later + on ends up in the __class_list section. */ + +static GTY(()) VEC(tree,gc) *class_list; + +static void +objc_v2_add_to_class_list (tree global_class_decl) +{ + if (!class_list) + class_list = VEC_alloc (tree, gc, imp_count?imp_count:1); + VEC_safe_push (tree, gc, class_list, global_class_decl); +} + +static GTY(()) VEC(tree,gc) *nonlazy_class_list; + +/* Add the global class meta-data declaration to the list which later + on ends up in the __nonlazy_class section. */ + +static void +objc_v2_add_to_nonlazy_class_list (tree global_class_decl) +{ + if (!nonlazy_class_list) + nonlazy_class_list = VEC_alloc (tree, gc, imp_count?imp_count:1); + VEC_safe_push (tree, gc, nonlazy_class_list, global_class_decl); +} + +static GTY(()) VEC(tree,gc) *category_list; + +/* Add the category meta-data declaration to the list which later on + ends up in the __nonlazy_category section. */ + +static void +objc_v2_add_to_category_list (tree decl) +{ + if (!category_list) + category_list = VEC_alloc (tree, gc, cat_count?cat_count:1); + VEC_safe_push (tree, gc, category_list, decl); +} + +static GTY(()) VEC(tree,gc) *nonlazy_category_list; + +/* Add the category meta-data declaration to the list which later on + ends up in the __category_list section. */ + +static void +objc_v2_add_to_nonlazy_category_list (tree decl) +{ + if (!nonlazy_category_list) + nonlazy_category_list = VEC_alloc (tree, gc, cat_count?cat_count:1); + VEC_safe_push (tree, gc, nonlazy_category_list, decl); +} + +static bool +has_load_impl (tree clsmeth) +{ + while (clsmeth) + { + tree id = METHOD_SEL_NAME (clsmeth); + if (IDENTIFIER_LENGTH (id) == 4 + && strncmp (IDENTIFIER_POINTER (id), "load", 4) == 0) + return true; + clsmeth = DECL_CHAIN (clsmeth); + } + + return false; +} + +/* Build a __{class,category}_list section table containing address of + all @implemented {class,category} meta-data. */ + +static void +build_v2_address_table (VEC(tree,gc) *src, const char *nam, tree attr) +{ + int count=0; + tree type, decl, expr; + VEC(constructor_elt,gc) *initlist = NULL; + + if (!src || !VEC_length(tree,src)) + return; + + FOR_EACH_VEC_ELT (tree, src, count, decl) + { +#ifndef OBJCPLUS + tree purpose = build_int_cst (NULL_TREE, count); +#else + tree purpose = NULL_TREE; +#endif + expr = convert (objc_class_type, build_fold_addr_expr (decl)); + CONSTRUCTOR_APPEND_ELT (initlist, purpose, expr); + } + gcc_assert (count > 0); + type = build_array_type (objc_class_type, + build_index_type (build_int_cst (NULL_TREE, count - 1))); + decl = start_var_decl (type, nam); + /* The runtime wants this, even if it appears unused, so we must + force the output. */ + DECL_PRESERVE_P (decl) = 1; + expr = objc_build_constructor (type, initlist); + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, expr); +} + +/* Build decl = initializer; for each protocol referenced in + @protocol(MyProt) expression. Refs as built in the entry section + above. */ + +static void +build_v2_protocol_list_translation_table (void) +{ + int count; + prot_list_entry *ref; + + if (!protrefs) + return; + + FOR_EACH_VEC_ELT (prot_list_entry, protrefs, count, ref) + { + char buf[BUFSIZE]; + tree expr; + gcc_assert (TREE_CODE (ref->id) == PROTOCOL_INTERFACE_TYPE); + snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (ref->id))); + expr = start_var_decl (objc_v2_protocol_template, buf); + expr = convert (objc_protocol_type, build_fold_addr_expr (expr)); + finish_var_decl (ref->refdecl, expr); + } + /* TODO: Maybe we could explicitly delete the vec. now? */ +} + +static GTY (()) VEC (prot_list_entry, gc) * protlist; + +/* Add the local protocol meta-data declaration to the list which + later on ends up in the __protocol_list section. */ + +static void +objc_add_to_protocol_list (tree protocol_interface_decl, tree protocol_decl) +{ + prot_list_entry e; + if (!protlist) + /* Arbitrary init count. */ + protlist = VEC_alloc (prot_list_entry, gc, 32); + e.id = protocol_interface_decl; + e.refdecl = protocol_decl; + VEC_safe_push (prot_list_entry, gc, protlist, &e); +} + +/* Build the __protocol_list section table containing address of all + generate protocol_t meta-data. */ + +static void +build_v2_protocol_list_address_table (void) +{ + int count; + prot_list_entry *ref; + if (!protlist || !VEC_length (prot_list_entry, protlist)) + return; + + FOR_EACH_VEC_ELT (prot_list_entry, protlist, count, ref) + { + tree decl, expr; + char buf[BUFSIZE]; + gcc_assert (ref->id && TREE_CODE (ref->id) == PROTOCOL_INTERFACE_TYPE); + snprintf (buf, BUFSIZE, "_OBJC_LabelProtocol_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (ref->id))); + decl = create_global_decl (objc_protocol_type, buf); + expr = convert (objc_protocol_type, build_fold_addr_expr (ref->refdecl)); + OBJCMETA (decl, objc_meta, meta_label_protocollist); + finish_var_decl (decl, expr); + } + + /* TODO: delete the vec. */ + /* TODO: upgrade to the the clang/llvm hidden version. */ +} + +/* This routine declares a variable to hold meta data for 'struct + protocol_list_t'. */ + +static tree +generate_v2_protocol_list (tree i_or_p, tree klass_ctxt) +{ + tree refs_decl, lproto, e, plist, ptempl_p_t; + int size = 0; + VEC(constructor_elt,gc) *initlist = NULL; + char buf[BUFSIZE]; + + if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE + || TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE) + plist = CLASS_PROTOCOL_LIST (i_or_p); + else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE) + plist = PROTOCOL_LIST (i_or_p); + else + gcc_unreachable (); + + /* Compute size. */ + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto))) + size++; + + /* Build initializer. */ + + ptempl_p_t = build_pointer_type (objc_v2_protocol_template); + e = build_int_cst (ptempl_p_t, size); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, e); + + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + { + tree pval = TREE_VALUE (lproto); + + if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_FORWARD_DECL (pval)) + { + tree fwref = PROTOCOL_FORWARD_DECL (pval); + location_t loc = DECL_SOURCE_LOCATION (fwref) ; + e = build_unary_op (loc, ADDR_EXPR, fwref, 0); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, e); + } + } + + /* static struct protocol_list_t *list[size]; */ + + switch (TREE_CODE (i_or_p)) + { + case PROTOCOL_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p))); + break; + case CLASS_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s", + IDENTIFIER_POINTER (CLASS_NAME (i_or_p))); + break; + case CATEGORY_INTERFACE_TYPE: + snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt))); + break; + default: + gcc_unreachable (); + } + + refs_decl = start_var_decl (build_sized_array_type (ptempl_p_t, size+1), + buf); + /* ObjC2 puts all these in the base section. */ + OBJCMETA (refs_decl, objc_meta, meta_base); + DECL_PRESERVE_P (refs_decl) = 1; + finish_var_decl (refs_decl, + objc_build_constructor (TREE_TYPE (refs_decl),initlist)); + return refs_decl; +} + +/* This routine builds one 'struct method_t' initializer list. Note + that the old ABI is supposed to build 'struct objc_method' which + has 3 fields, but it does not build the initialization expression + for 'method_imp' which for protocols is NULL any way. To be + consistant with declaration of 'struct method_t', in the new ABI we + set the method_t.imp to NULL. */ + +static tree +build_v2_descriptor_table_initializer (tree type, tree entries) +{ + VEC(constructor_elt,gc) *initlist = NULL; + do + { + VEC(constructor_elt,gc) *eltlist = NULL; + CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, + build_selector (METHOD_SEL_NAME (entries))); + CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, + add_objc_string (METHOD_ENCODING (entries), + meth_var_types)); + CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, null_pointer_node); + + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, + objc_build_constructor (type, eltlist)); + entries = TREE_CHAIN (entries); + } + while (entries); + + return objc_build_constructor (build_array_type (type, 0), initlist); +} + +/* struct method_list_t + { + uint32_t entsize; + uint32_t method_count; + struct objc_method method_list[method_count]; + }; */ + +static tree +build_v2_method_list_template (tree list_type, int size) +{ + tree method_list_t_record; + tree array_type, decls, *chain = NULL; + + method_list_t_record = objc_start_struct (NULL_TREE); + + /* uint32_t const entsize; */ + decls = add_field_decl (integer_type_node, "entsize", &chain); + + /* int method_count; */ + add_field_decl (integer_type_node, "method_count", &chain); + + /* struct objc_method method_list[]; */ + array_type = build_sized_array_type (list_type, size); + add_field_decl (array_type, "method_list", &chain); + + objc_finish_struct (method_list_t_record, decls); + return method_list_t_record; +} + +/* Note, as above that we are building to the objc_method_template + which has the *imp field. ABI0/1 build with + objc_method_prototype_template which is missing this field. */ +static tree +generate_v2_meth_descriptor_table (tree chain, tree protocol, + const char *prefix, tree attr) +{ + tree method_list_template, initlist, decl, methods; + int size, entsize; + VEC(constructor_elt,gc) *v = NULL; + char buf[BUFSIZE]; + + if (!chain || !prefix) + return NULL_TREE; + + methods = chain; + size = 0; + while (methods) + { + if (! METHOD_ENCODING (methods)) + METHOD_ENCODING (methods) = encode_method_prototype (methods); + methods = TREE_CHAIN (methods); + size++; + } + + gcc_assert (size); + method_list_template = build_v2_method_list_template (objc_method_template, + size); + snprintf (buf, BUFSIZE, "%s_%s", prefix, + IDENTIFIER_POINTER (PROTOCOL_NAME (protocol))); + + decl = start_var_decl (method_list_template, buf); + + entsize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, entsize)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); + initlist = + build_v2_descriptor_table_initializer (objc_method_template, + chain); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); + /* Get into the right section. */ + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, objc_build_constructor (method_list_template, v)); + return decl; +} + +/* This routine builds the initializer list to initialize the 'struct + _prop_t prop_list[]' field of 'struct _prop_list_t' meta-data. */ + +static tree +build_v2_property_table_initializer (tree type, tree context) +{ + tree x; + VEC(constructor_elt,gc) *inits = NULL; + if (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE) + x = CLASS_PROPERTY_DECL (context); + else + x = IMPL_PROPERTY_DECL (context); + + for (; x; x = TREE_CHAIN (x)) + { + VEC(constructor_elt,gc) *elemlist = NULL; + /* NOTE! sections where property name/attribute go MUST change + later. */ + tree attribute, name_ident = PROPERTY_NAME (x); + + CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE, + add_objc_string (name_ident, prop_names_attr)); + + attribute = objc_v2_encode_prop_attr (x); + CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE, + add_objc_string (attribute, prop_names_attr)); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + objc_build_constructor (type, elemlist)); + } + + return objc_build_constructor (build_array_type (type, 0),inits); +} + +/* This routine builds the following type: + struct _prop_list_t + { + uint32_t entsize; // sizeof (struct _prop_t) + uint32_t prop_count; + struct _prop_t prop_list [prop_count]; + } +*/ + +static tree +build_v2_property_list_template (tree list_type, int size) +{ + tree property_list_t_record; + tree array_type, decls, *chain = NULL; + + /* anonymous. */ + property_list_t_record = objc_start_struct (NULL_TREE); + + /* uint32_t const entsize; */ + decls = add_field_decl (integer_type_node, "entsize", &chain); + + /* int prop_count; */ + add_field_decl (integer_type_node, "prop_count", &chain); + + /* struct _prop_t prop_list[]; */ + array_type = build_sized_array_type (list_type, size); + add_field_decl (array_type, "prop_list", &chain); + + objc_finish_struct (property_list_t_record, decls); + return property_list_t_record; +} + +/* Top-level routine to generate property tables for each + implementation. */ + +static tree +generate_v2_property_table (tree context, tree klass_ctxt) +{ + tree x, decl, initlist, property_list_template; + bool is_proto = false; + VEC(constructor_elt,gc) *inits = NULL; + int init_val, size = 0; + char buf[BUFSIZE]; + + if (context) + { + gcc_assert (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE); + x = CLASS_PROPERTY_DECL (context); + is_proto = true; + } + else + x = IMPL_PROPERTY_DECL (klass_ctxt); + + for (; x; x = TREE_CHAIN (x)) + size++; + + if (size == 0) + return NULL_TREE; + + property_list_template = + build_v2_property_list_template (objc_v2_property_template, + size); + + initlist = build_v2_property_table_initializer (objc_v2_property_template, + is_proto ? context + : klass_ctxt); + + init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_property_template)); + if (is_proto) + snprintf (buf, BUFSIZE, "_OBJC_ProtocolPropList_%s", + IDENTIFIER_POINTER (PROTOCOL_NAME (context))); + else + snprintf (buf, BUFSIZE, "_OBJC_ClassPropList_%s", + IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt))); + + decl = start_var_decl (property_list_template, buf); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + build_int_cst (NULL_TREE, init_val)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + build_int_cst (NULL_TREE, size)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); + + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), inits)); + return decl; +} + +static tree +build_v2_protocol_initializer (tree type, tree protocol_name, tree protocol_list, + tree inst_methods, tree class_methods, + tree opt_ins_meth, tree opt_cls_meth, + tree property_list) +{ + tree expr, ttyp; + location_t loc; + VEC(constructor_elt,gc) *inits = NULL; + + /* TODO: find a better representation of location from the inputs. */ + loc = UNKNOWN_LOCATION; + + /* This is NULL for the new ABI. */ + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + convert (objc_object_type, null_pointer_node)); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list); + + ttyp = objc_method_proto_list_ptr; + if (inst_methods) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + if (class_methods) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + if (opt_ins_meth) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, opt_ins_meth, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + if (opt_cls_meth) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, opt_cls_meth, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + ttyp = objc_prop_list_ptr; + if (property_list) + expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); + else + expr = convert (ttyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + + /* const uint32_t size; = sizeof(struct protocol_t) */ + expr = build_int_cst (integer_type_node, + TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_protocol_template))); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); + /* const uint32_t flags; = 0 */ + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, integer_zero_node); + + return objc_build_constructor (type, inits); +} + +/* Main routine to build all meta data for all protocols used in a + translation unit. */ + +static void +generate_v2_protocols (void) +{ + tree p ; + bool some = false; + + if (!protocol_chain) + return ; + + /* If a protocol was directly referenced, pull in indirect + references. */ + for (p = protocol_chain; p; p = TREE_CHAIN (p)) + if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p)) + generate_protocol_references (PROTOCOL_LIST (p)); + + for (p = protocol_chain; p; p = TREE_CHAIN (p)) + { + location_t loc; + tree inst_meth, class_meth, opt_inst_meth, opt_class_meth, props; + tree decl, initlist, protocol_name_expr, refs_decl, refs_expr; + + /* If protocol wasn't referenced, don't generate any code. */ + decl = PROTOCOL_FORWARD_DECL (p); + + if (!decl) + continue; + + loc = DECL_SOURCE_LOCATION (decl); + some = true; + + inst_meth = + generate_v2_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p, + "_OBJC_ProtocolInstanceMethods", + meta_proto_nst_meth); + + class_meth = + generate_v2_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p, + "_OBJC_ProtocolClassMethods", + meta_proto_cls_meth); + + opt_inst_meth = + generate_v2_meth_descriptor_table (PROTOCOL_OPTIONAL_NST_METHODS (p), p, + "_OBJC_OptProtocolInstMethods", + meta_proto_nst_meth); + + opt_class_meth = + generate_v2_meth_descriptor_table (PROTOCOL_OPTIONAL_CLS_METHODS (p), p, + "_OBJC_OptProtocolClassMethods", + meta_proto_cls_meth); + + if (PROTOCOL_LIST (p)) + refs_decl = generate_v2_protocol_list (p, NULL_TREE); + else + refs_decl = 0; + + /* static struct objc_protocol _OBJC_Protocol_; */ + protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names); + + if (refs_decl) + refs_expr = convert (build_pointer_type (objc_v2_protocol_template), + build_unary_op (loc, ADDR_EXPR, refs_decl, 0)); + else + refs_expr = build_int_cst (NULL_TREE, 0); + + props = generate_v2_property_table (p, NULL_TREE); + + initlist = build_v2_protocol_initializer (TREE_TYPE (decl), + protocol_name_expr, refs_expr, + inst_meth, class_meth, + opt_inst_meth, opt_class_meth, + props); + finish_var_decl (decl, initlist); + objc_add_to_protocol_list (p, decl); + } + + if (some) + { + /* Make sure we get the Protocol class linked in - reference + it... */ + p = objc_v2_get_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); + /* ... but since we don't specifically use the reference... we + need to force it. */ + DECL_PRESERVE_P (p) = 1; + } +} + +static tree +generate_v2_dispatch_table (tree chain, const char *name, tree attr) +{ + tree decl, method_list_template, initlist; + VEC(constructor_elt,gc) *v = NULL; + int size, init_val; + + if (!chain || !name || !(size = list_length (chain))) + return NULL_TREE; + + method_list_template + = build_v2_method_list_template (objc_method_template, size); + initlist + = build_dispatch_table_initializer (objc_method_template, chain); + + decl = start_var_decl (method_list_template, name); + + init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (integer_type_node, init_val)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, + build_int_cst (integer_type_node, size)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); + + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, + objc_build_constructor (TREE_TYPE (decl), v)); + return decl; +} + +/* Init a category. */ +static tree +build_v2_category_initializer (tree type, tree cat_name, tree class_name, + tree inst_methods, tree class_methods, + tree protocol_list, tree property_list, + location_t loc) +{ + tree expr, ltyp; + VEC(constructor_elt,gc) *v = NULL; + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name); + + ltyp = objc_method_list_ptr; + if (inst_methods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + if (class_methods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* protocol_list = */ + ltyp = build_pointer_type (objc_v2_protocol_template); + if (protocol_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + ltyp = objc_prop_list_ptr; + if (property_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + return objc_build_constructor (type, v); +} + +/* static struct category_t _OBJC_CATEGORY_$_ = { ... }; */ + +static void +generate_v2_category (struct imp_entry *impent) +{ + tree initlist, cat_name_expr, class_name_expr; + tree protocol_decl, category, props, t; + tree inst_methods = NULL_TREE, class_methods = NULL_TREE; + tree cat = impent->imp_context; + tree cat_decl = impent->class_decl; + location_t loc; + char buf[BUFSIZE]; + + loc = DECL_SOURCE_LOCATION (cat_decl); + + /* ??? not sure this is really necessary, the following references should + force appropriate linkage linkage... + -- but ... ensure a reference to the class... */ + t = objc_v2_get_class_reference (CLASS_NAME (cat)); + /* ... which we ignore so force it out.. */ + DECL_PRESERVE_P (t) = 1; + + snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", IDENTIFIER_POINTER (CLASS_NAME (cat))); + class_name_expr = create_extern_decl (objc_v2_class_template, buf); + class_name_expr = build_fold_addr_expr (class_name_expr); + + cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names); + category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat)); + + if (category && CLASS_PROTOCOL_LIST (category)) + { + generate_protocol_references (CLASS_PROTOCOL_LIST (category)); + protocol_decl = generate_v2_protocol_list (category, cat); + } + else + protocol_decl = NULL_TREE; + +/* decl = update_var_decl(impent->class_decl); */ + + props = generate_v2_property_table (NULL_TREE, cat); + + if (CLASS_NST_METHODS (cat)) + { + snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (cat)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); + inst_methods = generate_v2_dispatch_table (CLASS_NST_METHODS (cat), buf, + meta_cati_meth); + } + + if (CLASS_CLS_METHODS (cat)) + { + snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s", + IDENTIFIER_POINTER (CLASS_NAME (cat)), + IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); + class_methods = generate_v2_dispatch_table (CLASS_CLS_METHODS (cat), buf, + meta_catc_meth); + } + + initlist = build_v2_category_initializer (TREE_TYPE (cat_decl), + cat_name_expr, class_name_expr, + inst_methods, class_methods, + protocol_decl, props, loc); + + finish_var_decl (cat_decl, initlist); + impent->class_decl = cat_decl; + + /* Add to list of pointers in __category_list section. */ + objc_v2_add_to_category_list (cat_decl); + if (has_load_impl (CLASS_CLS_METHODS (impent->imp_context))) + objc_v2_add_to_nonlazy_category_list (cat_decl); +} + +/* This routine declares a variable to hold the offset for ivar + FIELD_DECL. Variable name is .objc_ivar.ClassName.IvarName. */ + +typedef struct GTY(()) ivarref_entry +{ + tree decl; + tree offset; +} ivarref_entry; +DEF_VEC_O(ivarref_entry); +DEF_VEC_ALLOC_O(ivarref_entry, gc); + +static GTY (()) VEC (ivarref_entry, gc) * ivar_offset_refs; + +static tree +ivar_offset_ref (tree class_name, tree field_decl) +{ + tree decl, field_decl_id; + ivarref_entry e; + bool global_var; + char buf[512]; + + create_ivar_offset_name (buf, class_name, field_decl); + field_decl_id = get_identifier (buf); + + if (ivar_offset_refs) + { + int count; + ivarref_entry *ref; + FOR_EACH_VEC_ELT (ivarref_entry, ivar_offset_refs, count, ref) + if (DECL_NAME (ref->decl) == field_decl_id) + return ref->decl; + } + else + /* Somewhat arbitrary initial provision. */ + ivar_offset_refs = VEC_alloc (ivarref_entry, gc, 32); + + /* We come here if we don't find a match or at the start. */ + global_var = (TREE_PUBLIC (field_decl) || TREE_PROTECTED (field_decl)); + if (global_var) + decl = create_global_decl (TREE_TYPE (size_zero_node), buf); + else + decl = create_hidden_decl (TREE_TYPE (size_zero_node), buf); + + /* Make sure it ends up in an ObjC section. */ + OBJCMETA (decl, objc_meta, meta_base); + + e.decl = decl; + e.offset = byte_position (field_decl); + VEC_safe_push (ivarref_entry, gc, ivar_offset_refs, &e); + return decl; +} + +/* This routine builds initializer-list needed to initialize 'struct + ivar_t list[count] of 'struct ivar_list_t' meta data. TYPE is + 'struct ivar_t' and FIELD_DECL is list of ivars for the target + class. */ + +static tree +build_v2_ivar_list_initializer (tree class_name, tree type, tree field_decl) +{ + VEC(constructor_elt,gc) *inits = NULL; + + do + { + VEC(constructor_elt,gc) *ivar = NULL; + int val; + tree id; + + /* Unnamed bitfields are ignored. */ + if (!DECL_NAME (field_decl)) + { + field_decl = DECL_CHAIN (field_decl); + continue; + } + + /* Set offset. */ + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, + build_unary_op (input_location, + ADDR_EXPR, + ivar_offset_ref (class_name, + field_decl), 0)); + + /* Set name. */ + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, + add_objc_string (DECL_NAME (field_decl), + meth_var_names)); + + /* Set type. */ + encode_field_decl (field_decl, + obstack_object_size (&util_obstack), + OBJC_ENCODE_DONT_INLINE_DEFS); + /* Null terminate string. */ + obstack_1grow (&util_obstack, 0); + id = add_objc_string (get_identifier (XOBFINISH (&util_obstack, char *)), + meth_var_types); + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id); + obstack_free (&util_obstack, util_firstobj); + + /* Set alignment. */ + val = DECL_ALIGN_UNIT (field_decl); + val = exact_log2 (val); + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, + build_int_cst (integer_type_node, val)); + + /* Set size. */ + val = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl)); + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, + build_int_cst (integer_type_node, val)); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + objc_build_constructor (type, ivar)); + + do + field_decl = DECL_CHAIN (field_decl); + while (field_decl && TREE_CODE (field_decl) != FIELD_DECL); + } + while (field_decl); + + return objc_build_constructor (build_array_type (type, 0), inits); +} + +/* + struct ivar_list_t + { + uint32 entsize; + uint32 count; + struct iver_t list[count]; + }; +*/ + +static tree +build_v2_ivar_list_t_template (tree list_type, int size) +{ + tree objc_ivar_list_record; + tree decls, *chain = NULL; + + /* Anonymous. */ + objc_ivar_list_record = objc_start_struct (NULL_TREE); + + /* uint32 entsize; */ + decls = add_field_decl (integer_type_node, "entsize", &chain); + + /* uint32 count; */ + add_field_decl (integer_type_node, "count", &chain); + + /* struct objc_ivar ivar_list[]; */ + add_field_decl (build_sized_array_type (list_type, size), + "list", &chain); + + objc_finish_struct (objc_ivar_list_record, decls); + return objc_ivar_list_record; +} + +/* This routine declares a static variable of type 'struct + ivar_list_t' and initializes it. chain is the source of the data, + name is the name for the var. attr is the meta-data section tag + attribute. templ is the implementation template for the class. */ + +static tree +generate_v2_ivars_list (tree chain, const char *name, tree attr, tree templ) +{ + tree decl, initlist, ivar_list_template; + VEC(constructor_elt,gc) *inits = NULL; + int size, ivar_t_size; + + if (!chain || !name || !(size = ivar_list_length (chain))) + return NULL_TREE; + + generating_instance_variables = 1; + ivar_list_template = build_v2_ivar_list_t_template (objc_v2_ivar_template, + size); + + initlist = build_v2_ivar_list_initializer (CLASS_NAME (templ), + objc_v2_ivar_template, chain); + ivar_t_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_ivar_template)); + + decl = start_var_decl (ivar_list_template, name); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + build_int_cst (integer_type_node, ivar_t_size)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + build_int_cst (integer_type_node, size)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); + OBJCMETA (decl, objc_meta, attr); + finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), inits)); + generating_instance_variables = 0; + return decl; +} + +/* Routine to build initializer list to initialize objects of type + struct class_t; */ + +static tree +build_v2_class_t_initializer (tree type, tree isa, tree superclass, + tree ro, tree cache, tree vtable) +{ + VEC(constructor_elt,gc) *initlist = NULL; + + /* isa */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, isa); + + /* superclass */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, superclass); + + /* cache */ + if (cache) + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, cache); + else + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, null_pointer_node); + + /* vtable */ + if (vtable) + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, vtable); + else + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, null_pointer_node); + + /* ro */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, ro); + + return objc_build_constructor (type, initlist); +} + +/* Routine to build object of struct class_ro_t { ... }; */ + +static tree +build_v2_class_ro_t_initializer (tree type, tree name, + unsigned int flags, unsigned int instanceStart, + unsigned int instanceSize, + tree ivarLayout, + tree baseMethods, tree baseProtocols, + tree ivars, tree property_list) +{ + tree expr, unsigned_char_star, ltyp; + location_t loc; + VEC(constructor_elt,gc) *initlist = NULL; + + /* TODO: fish out the real location from somewhere. */ + loc = UNKNOWN_LOCATION; + + /* flags */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, + build_int_cst (integer_type_node, flags)); + + /* instanceStart */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, + build_int_cst (integer_type_node, instanceStart)); + + /* instanceSize */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, + build_int_cst (integer_type_node, instanceSize)); + + /* This ABI is currently only used on m64 NeXT. We always + explicitly declare the alignment padding. */ + /* reserved, pads alignment. */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, + build_int_cst (integer_type_node, 0)); + + /* ivarLayout */ + unsigned_char_star = build_pointer_type (unsigned_char_type_node); + if (ivarLayout) + expr = ivarLayout; + else + expr = convert (unsigned_char_star, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); + + /* name */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, default_conversion (name)); + + /* baseMethods */ + ltyp = objc_method_list_ptr; + if (baseMethods) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, baseMethods, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); + + /* baseProtocols */ + ltyp = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_V2_PROTOCOL_LIST))); + if (baseProtocols) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, baseProtocols, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); + + /* ivars */ + ltyp = objc_v2_ivar_list_ptr; + if (ivars) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, ivars, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); + + /* TODO: We don't yet have the weak/strong stuff... */ + /* weakIvarLayout */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, + convert (unsigned_char_star, null_pointer_node)); + + /* property list */ + ltyp = objc_prop_list_ptr; + if (property_list) + expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); + return objc_build_constructor (type, initlist); +} + +static GTY (()) VEC (ident_data_tuple, gc) * ehtype_list; + +/* Record a name as needing a catcher. */ +static void +objc_v2_add_to_ehtype_list (tree name) +{ + ident_data_tuple e; + if (ehtype_list) + { + int count = 0; + ident_data_tuple *ref; + + FOR_EACH_VEC_ELT (ident_data_tuple, ehtype_list, count, ref) + if (ref->ident == name) + return; /* Already entered. */ + } + else + /* Arbitrary initial count. */ + ehtype_list = VEC_alloc (ident_data_tuple, gc, 8); + + /* Not found, or new list. */ + e.ident = name; + e.data = NULL_TREE; + VEC_safe_push (ident_data_tuple, gc, ehtype_list, &e); +} + +static void +generate_v2_class_structs (struct imp_entry *impent) +{ + tree decl, name_expr, initlist, protocol_decl, metaclass_decl, class_decl; + tree field, firstIvar, chain; + tree class_superclass_expr, metaclass_superclass_expr, props; + /* TODO: figure out how to compute this. */ + tree ivarLayout = NULL_TREE; + tree my_super_id = NULL_TREE, root_expr = NULL_TREE; + tree inst_methods = NULL_TREE, class_methods = NULL_TREE; + tree inst_ivars = NULL_TREE, class_ivars = NULL_TREE; + location_t loc; + char buf[BUFSIZE]; + unsigned int instanceStart, instanceSize; + unsigned int flags = 0x01; /* RO_META */ + int cls_flags = impent->has_cxx_cdtors ? OBJC2_CLS_HAS_CXX_STRUCTORS + : 0 ; + + class_decl = impent->class_decl; + metaclass_decl = impent->meta_decl; + loc = DECL_SOURCE_LOCATION (class_decl); + + DECL_EXTERNAL (class_decl) = DECL_EXTERNAL (metaclass_decl) = 0; + TREE_PUBLIC (class_decl) = TREE_PUBLIC (metaclass_decl) = 1; +#ifdef OBJCPLUS + gcc_assert (!CP_DECL_CONTEXT (class_decl) || CP_DECL_CONTEXT (class_decl) == global_namespace); + gcc_assert (!CP_DECL_CONTEXT (metaclass_decl) || CP_DECL_CONTEXT (metaclass_decl) == global_namespace); +#endif + + /* Generation of data for meta class. */ + my_super_id = CLASS_SUPER_NAME (impent->imp_template); + if (my_super_id) + { + /* Compute reference to root's name. For a meta class, "isa" is + a reference to the root class name. */ + tree my_root_id = my_super_id; + tree my_root_int, interface; + do + { + my_root_int = lookup_interface (my_root_id); + + if (my_root_int && CLASS_SUPER_NAME (my_root_int)) + my_root_id = CLASS_SUPER_NAME (my_root_int); + else + break; + } + while (1); + + /* {extern} struct class_t OBJC_METACLASS_$_ + create extern if not already declared. */ + snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s", + IDENTIFIER_POINTER (CLASS_NAME (my_root_int))); + root_expr = create_extern_decl (objc_v2_class_template, buf); + root_expr = build_fold_addr_expr (root_expr); + + /* Install class `isa' and `super' pointers at runtime. */ + interface = lookup_interface (my_super_id); + gcc_assert (interface); + /* Similarly, for OBJC_CLASS_$_... */ + snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", + IDENTIFIER_POINTER (CLASS_NAME (interface))); + class_superclass_expr = create_extern_decl (objc_v2_class_template, buf); + class_superclass_expr = build_fold_addr_expr (class_superclass_expr); + /* ... and for OBJC_METACLASS_$_. */ + snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s", + IDENTIFIER_POINTER (CLASS_NAME (interface))); + metaclass_superclass_expr = create_extern_decl (objc_v2_class_template, buf); + metaclass_superclass_expr = build_fold_addr_expr (metaclass_superclass_expr); + } + else + { + /* Root class. */ + root_expr = build_unary_op (loc, ADDR_EXPR, metaclass_decl, 0); + metaclass_superclass_expr = build_unary_op (loc, ADDR_EXPR, class_decl, 0); + class_superclass_expr = build_int_cst (NULL_TREE, 0); + flags |= 0x02; /* RO_ROOT: it is also a root meta class. */ + } + + if (CLASS_PROTOCOL_LIST (impent->imp_template)) + { + generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template)); + protocol_decl = generate_v2_protocol_list (impent->imp_template, + impent->imp_context); + } + else + protocol_decl = 0; + + name_expr = add_objc_string (CLASS_NAME (impent->imp_template), + class_names); + + if (CLASS_CLS_METHODS (impent->imp_context)) + { + snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + class_methods = + generate_v2_dispatch_table (CLASS_CLS_METHODS (impent->imp_context), + buf, meta_clac_meth); + } + + instanceStart = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template)); + + /* Currently there are no class ivars and generation of class + variables for the root of the inheritance has been removed. It + causes multiple defines if there are two root classes in the + link, because each will define its own identically-named offset + variable. */ + + class_ivars = NULL_TREE; + /* TODO: Add total size of class variables when implemented. */ + instanceSize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template)); + + /* So now build the META CLASS structs. */ + /* static struct class_ro_t _OBJC_METACLASS_Foo = { ... }; */ + + decl = start_var_decl (objc_v2_class_ro_template, + newabi_append_ro (IDENTIFIER_POINTER + (DECL_NAME (metaclass_decl)))); + + /* TODO: ivarLayout needs t be built. */ + initlist = + build_v2_class_ro_t_initializer (TREE_TYPE (decl), name_expr, + (flags | cls_flags), instanceStart, + instanceSize, ivarLayout, + class_methods, protocol_decl, + class_ivars, NULL_TREE); + /* The ROs sit in the default const section. */ + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, initlist); + + /* static struct class_t _OBJC_METACLASS_Foo = { ... }; */ + initlist = + build_v2_class_t_initializer (TREE_TYPE (metaclass_decl), + root_expr, + metaclass_superclass_expr, + build_fold_addr_expr (decl), + build_fold_addr_expr (UOBJC_V2_CACHE_decl), + build_fold_addr_expr (UOBJC_V2_VTABLE_decl)); + /* The class section attributes are set when they are created. */ + finish_var_decl (metaclass_decl, initlist); + impent->meta_decl = metaclass_decl; + + /* So now build the CLASS structs. */ + + flags = 0x0; /* ... */ + if (!my_super_id) + flags |= 0x02; /* RO_ROOT: this is a root class */ + + if (DECL_VISIBILITY (class_decl) == VISIBILITY_HIDDEN) + flags |= 0x10; /* RO_HIDDEN, OBJC2_CLS_HIDDEN; */ + + if (objc2_objc_exception_attr (impent->imp_template)) + flags |= 0x20; /* RO_EXCEPTION */ + + if (CLASS_NST_METHODS (impent->imp_context)) + { + snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + inst_methods = + generate_v2_dispatch_table (CLASS_NST_METHODS (impent->imp_context), + buf, meta_clai_meth); + } + + /* Sort out the ivars before we try to compute the class sizes. */ + if ((chain = CLASS_IVARS (impent->imp_template))) + { + snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s", + IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); + inst_ivars = generate_v2_ivars_list (chain, buf, meta_clai_vars, + impent->imp_template); + } + + /* Compute instanceStart. */ + gcc_assert (CLASS_STATIC_TEMPLATE (impent->imp_template)); + field = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (impent->imp_template)); + if (my_super_id && field && TREE_CHAIN (field)) + field = TREE_CHAIN (field); + + firstIvar = field; + + while (firstIvar && TREE_CODE (firstIvar) != FIELD_DECL) + firstIvar = TREE_CHAIN (firstIvar); + + gcc_assert (inst_ivars? (firstIvar != NULL_TREE): true); + + /* Compute instanceSize. */ + while (field && TREE_CHAIN (field) + && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL) + field = TREE_CHAIN (field); + + if (field && TREE_CODE (field) == FIELD_DECL) + instanceSize = int_byte_position (field) * BITS_PER_UNIT + + tree_low_cst (DECL_SIZE (field), 0); + else + instanceSize = 0; + instanceSize /= BITS_PER_UNIT; + + props = generate_v2_property_table (NULL_TREE, impent->imp_context); + + /* If the class has no ivars, instanceStart should be set to the + superclass's instanceSize. */ + instanceStart = + (inst_ivars != NULL_TREE) ? (unsigned) int_byte_position (firstIvar) + : instanceSize; + + /* static struct class_ro_t _OBJC_CLASS_Foo = { ... }; */ + decl = start_var_decl (objc_v2_class_ro_template, + newabi_append_ro (IDENTIFIER_POINTER + (DECL_NAME (class_decl)))); + + initlist = + build_v2_class_ro_t_initializer (TREE_TYPE (decl), name_expr, + (flags | cls_flags), instanceStart, + instanceSize, ivarLayout, + inst_methods, protocol_decl, + inst_ivars, props); + /* The ROs sit in the default const section. */ + OBJCMETA (decl, objc_meta, meta_base); + finish_var_decl (decl, initlist); + + /* static struct class_t _OBJC_CLASS_Foo = { ... }; */ + initlist = build_v2_class_t_initializer (TREE_TYPE (class_decl), + build_fold_addr_expr (metaclass_decl), + class_superclass_expr, + build_fold_addr_expr (decl), + build_fold_addr_expr (UOBJC_V2_CACHE_decl), + build_fold_addr_expr (UOBJC_V2_VTABLE_decl)); + + /* The class section attributes are set when they are created. */ + finish_var_decl (class_decl, initlist); + impent->class_decl = class_decl; + + objc_v2_add_to_class_list (class_decl); + if (has_load_impl (CLASS_CLS_METHODS (impent->imp_context))) + objc_v2_add_to_nonlazy_class_list (class_decl); + + if (flags & 0x20) /* RO_EXCEPTION */ + objc_v2_add_to_ehtype_list (CLASS_NAME (impent->imp_template)); +} + +/* This routine outputs the (ivar_reference_offset, offset) + tuples. */ + +static void +build_v2_ivar_offset_ref_table (void) +{ + int count; + ivarref_entry *ref; + + if (!ivar_offset_refs || !VEC_length (ivarref_entry, ivar_offset_refs)) + return; + + FOR_EACH_VEC_ELT (ivarref_entry, ivar_offset_refs, count, ref) + finish_var_decl (ref->decl, ref->offset); +} + +/* static int _OBJC_IMAGE_INFO[2] = { 0, 16 | flags }; */ + +static void +generate_v2_objc_image_info (void) +{ + tree decl, array_type; + VEC(constructor_elt,gc) *v = NULL; + int flags = + ((flag_replace_objc_classes && imp_count ? 1 : 0) + | (flag_objc_gc ? 2 : 0)); + + flags |= 16; + + array_type = build_sized_array_type (integer_type_node, 2); + + decl = start_var_decl (array_type, "_OBJC_ImageInfo"); + + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (integer_type_node, flags)); + /* The Runtime wants this. */ + DECL_PRESERVE_P (decl) = 1; + OBJCMETA (decl, objc_meta, meta_info); + finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), v)); +} + +static void +objc_generate_v2_next_metadata (void) +{ + struct imp_entry *impent; + + /* FIXME: Make sure that we generate no metadata if there is nothing + to put into it. */ + + gcc_assert (!objc_static_instances); /* Not for NeXT */ + + build_metadata_templates (); + + for (impent = imp_list; impent; impent = impent->next) + { + /* If -gen-decls is present, Dump the @interface of each class. + TODO: Dump the classes in the order they were found, rather + than in reverse order as we are doing now. */ + if (flag_gen_declaration) + dump_interface (gen_declaration_file, impent->imp_context); + + /* all of the following reference the string pool... */ + if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) + generate_v2_class_structs (impent); + else + generate_v2_category (impent); + } + + build_next_selector_translation_table (); + build_v2_message_ref_translation_table (); + + /* This will add "Protocol" to the class refs. */ + generate_v2_protocols (); + + build_v2_classrefs_table (); + build_v2_super_classrefs_table (/*metaclass= */false); + build_v2_super_classrefs_table (/*metaclass= */true); + + build_v2_ivar_offset_ref_table (); + + build_v2_protocol_list_translation_table (); + build_v2_protocol_list_address_table (); + + build_v2_address_table (class_list, "_OBJC_ClassList$", + meta_label_classlist); + build_v2_address_table (category_list, "_OBJC_CategoryList$", + meta_label_categorylist); + build_v2_address_table (nonlazy_class_list, "_OBJC_NonLazyClassList$", + meta_label_nonlazy_classlist); + build_v2_address_table (nonlazy_category_list, "_OBJC_NonLazyCategoryList$", + meta_label_nonlazy_categorylist); + + /* This conveys information on GC usage and zero-link. */ + generate_v2_objc_image_info (); + + /* Generate catch objects for eh, if any are needed. */ + build_v2_eh_catch_objects (); + + /* Emit the string table last. */ + generate_strings (); +} + +/* NOTE --- Output NeXT V2 Exceptions --- */ + +static GTY(()) tree objc_v2_ehtype_template; +static GTY(()) tree next_v2_ehvtable_decl; +static GTY(()) tree next_v2_EHTYPE_id_decl; + +static void +build_v2_ehtype_template (void) +{ + tree decls, *chain = NULL; + objc_v2_ehtype_template = objc_start_struct (get_identifier (UTAG_V2_EH_TYPE)); + + /* void *_objc_ehtype_vtable; */ + decls = add_field_decl (ptr_type_node, "_objc_ehtype_vtable_ptr", &chain); + + /* const char *className; */ + add_field_decl (string_type_node, "className", &chain); + + /* struct class_t *const cls; */ + add_field_decl (build_pointer_type (objc_v2_class_template), "cls", &chain); + + objc_finish_struct (objc_v2_ehtype_template, decls); +} + +/* Template for the Objective-C family typeinfo type for ABI=2. This + starts off the same as the gxx/cxx eh typeinfo. + + struct _objc_ehtype_t + { + void *_objc_ehtype_vtable_ptr; - as per c++ + const char *className; - as per c++ + struct class_t *const cls; + } +*/ + +/* This routine builds initializer list for object of type struct _objc_ehtype_t. +*/ + +static tree +objc2_build_ehtype_initializer (tree name, tree cls) +{ + VEC(constructor_elt,gc) *initlist = NULL; + tree addr, offs; + + /* This is done the same way as c++, missing the two first entries + in the parent vtable. NOTE: there is a fix-me in the Apple/NeXT + runtime source about this so, perhaps, this will change at some + point. */ + /* _objc_ehtype_vtable + 2*sizeof(void*) */ + if (!next_v2_ehvtable_decl) + { + next_v2_ehvtable_decl = + start_var_decl (ptr_type_node, TAG_NEXT_EHVTABLE_NAME); + TREE_STATIC (next_v2_ehvtable_decl) = 0; + DECL_EXTERNAL (next_v2_ehvtable_decl) = 1; + TREE_PUBLIC (next_v2_ehvtable_decl) = 1; + } + addr = build_fold_addr_expr_with_type (next_v2_ehvtable_decl, ptr_type_node); + offs = size_int (2 * int_cst_value (TYPE_SIZE_UNIT (ptr_type_node))); + addr = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, addr, offs); + + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, addr); + + /* className */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, name); + + /* cls */ + CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, cls); + + return objc_build_constructor (objc_v2_ehtype_template, initlist); +} + +static tree +build_ehtype (tree name, const char *eh_name, bool weak) +{ + tree name_expr, class_name_expr, ehtype_decl, inits; + + name_expr = add_objc_string (name, class_names); + /* Extern ref. for the class. ??? Maybe we can look this up + somewhere. */ + class_name_expr = + create_extern_decl (objc_v2_class_template, + objc_build_internal_classname (name, false)); + class_name_expr = build_fold_addr_expr (class_name_expr); + ehtype_decl = create_global_decl (objc_v2_ehtype_template, eh_name); + if (weak) + DECL_WEAK (ehtype_decl) = 1; + inits = objc2_build_ehtype_initializer (name_expr, class_name_expr); + OBJCMETA (ehtype_decl, objc_meta, meta_ehtype); + finish_var_decl (ehtype_decl, inits); + return ehtype_decl; +} + +/* This routine returns TRUE if CLS or any of its super classes has + __attribute__ ((objc_exception)). */ + +static bool +objc2_objc_exception_attr (tree cls) +{ + while (cls) + { + if (CLASS_HAS_EXCEPTION_ATTR (cls)) + return true; + cls = lookup_interface (CLASS_SUPER_NAME (cls)); + } + + return false; +} + +static bool +is_implemented (tree name) +{ + struct imp_entry *t; + for (t = imp_list; t; t = t->next) + if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE + && CLASS_NAME (t->imp_template) == name) + return true; + + return false; +} + +/* We will build catch objects: + for any type implemented here. + for any type used in a catch that has no exception attribute. */ +static void build_v2_eh_catch_objects (void) +{ + int count=0; + ident_data_tuple *ref; + + if (!ehtype_list || !VEC_length (ident_data_tuple, ehtype_list)) + return; + + FOR_EACH_VEC_ELT (ident_data_tuple, ehtype_list, count, ref) + { + char buf[BUFSIZE]; + bool impl = is_implemented (ref->ident); + bool excpt = objc2_objc_exception_attr (lookup_interface (ref->ident)); + snprintf (buf, BUFSIZE, "OBJC_EHTYPE_$_%s", IDENTIFIER_POINTER (ref->ident)); + if (!impl && excpt) + /* The User says this class has a catcher already. */ + ref->data = create_extern_decl (objc_v2_ehtype_template, buf); + else + /* Create a catcher, weak if it wasn't marked. */ + ref->data = build_ehtype (ref->ident, buf, !excpt); + } +} + +static tree +lookup_ehtype_ref (tree id) +{ + int count=0; + ident_data_tuple *ref; + + if (!ehtype_list || !VEC_length (ident_data_tuple, ehtype_list)) + return NULL_TREE; + + FOR_EACH_VEC_ELT (ident_data_tuple, ehtype_list, count, ref) + if (ref->ident == id) + return ref->data; + return NULL_TREE; +} + +/* This hook, called via lang_eh_runtime_type, generates a runtime + object which is either the address of the 'OBJC_EHTYPE_$_class' + object or address of external OBJC_EHTYPE_id object. */ +static tree +next_runtime_02_eh_type (tree type) +{ + tree t; + + if (type == error_mark_node + /*|| errorcount || sorrycount*/) + goto err_mark_in; + + if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) + { + if (!next_v2_EHTYPE_id_decl) + { + /* This is provided by the Apple/NeXT libobjc.dylib so we + need only to reference it. */ + next_v2_EHTYPE_id_decl = + start_var_decl (objc_v2_ehtype_template, "OBJC_EHTYPE_id"); + DECL_EXTERNAL (next_v2_EHTYPE_id_decl) = 1; + TREE_PUBLIC (next_v2_EHTYPE_id_decl) = 1; + TREE_STATIC (next_v2_EHTYPE_id_decl) = 0; + } + return build_fold_addr_expr (next_v2_EHTYPE_id_decl); + } + + if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type))) + { +#ifdef OBJCPLUS + /* This routine is also called for c++'s catch clause; in which + case, we use c++'s typeinfo decl. */ + return build_eh_type_type (type); +#else + error ("non-objective-c type '%T' cannot be caught", type); + goto err_mark_in; +#endif + } + else + t = OBJC_TYPE_NAME (TREE_TYPE (type)); + + /* We have to build a reference to the OBJC_EHTYPE_. */ + t = lookup_ehtype_ref (t); + if (!t) + goto err_mark_in; + + return build_fold_addr_expr (t); + +err_mark_in: + return error_mark_node; +} + +static GTY(()) tree objc_eh_personality_decl; + +static tree +objc_eh_personality (void) +{ + if (!objc_eh_personality_decl) + objc_eh_personality_decl = build_personality_function ("objc"); + return objc_eh_personality_decl; +} + +/* NOTE --- interfaces --- */ + +static tree +build_throw_stmt (location_t loc, tree throw_expr, bool rethrown) +{ + tree t; + if (rethrown) + /* We have a separate re-throw entry. */ + t = build_function_call_vec (loc, objc_rethrow_exception_decl, NULL, NULL); + else + { + /* Throw like the others... */ + VEC(tree, gc) *parms = VEC_alloc (tree, gc, 1); + VEC_quick_push (tree, parms, throw_expr); + t = build_function_call_vec (loc, objc_exception_throw_decl, parms, NULL); + VEC_free (tree, gc, parms); + } + return add_stmt (t); +} + +/* Build __builtin_eh_pointer. */ + +static tree +objc_build_exc_ptr (struct objc_try_context **x ATTRIBUTE_UNUSED) +{ + tree t; + t = built_in_decls[BUILT_IN_EH_POINTER]; + t = build_call_expr (t, 1, integer_zero_node); + return fold_convert (objc_object_type, t); +} + +static tree begin_catch (struct objc_try_context **cur_try_context, tree type, + tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED) +{ + tree t; + + /* Record the data for the catch in the try context so that we can + finalize it later. Ellipsis is signalled by a NULL entry. */ + if (ellipsis) + t = build_stmt (input_location, CATCH_EXPR, NULL_TREE, compound); + else + t = build_stmt (input_location, CATCH_EXPR, type, compound); + (*cur_try_context)->current_catch = t; + + /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */ + t = objc_build_exc_ptr (cur_try_context); + t = convert (TREE_TYPE (decl), t); + /* FIXME: location. */ + if (type && type != error_mark_node) + { + t = build1(NOP_EXPR, ptr_type_node, t); + t = build_function_call (input_location, objc2_begin_catch_decl, + tree_cons (NULL_TREE, t, NULL_TREE)); + + /* We might want to build a catch object for this (if it's not + id). */ + if (POINTER_TYPE_P (type) + && !objc_is_object_id (TREE_TYPE (type)) + && TYPED_OBJECT (TREE_TYPE (type))) + objc_v2_add_to_ehtype_list (OBJC_TYPE_NAME (TREE_TYPE (type))); + } + return build2 (MODIFY_EXPR, void_type_node, decl, t); +} + +/* try { catch-body } finally { objc_end_catch (); } */ +static void +finish_catch (struct objc_try_context **cur_try_context, tree curr_catch) +{ + struct objc_try_context *ct; + tree try_exp, func, *l, t ; + location_t loc = (*cur_try_context)->try_locus; + + if (!curr_catch || curr_catch == error_mark_node) + return; + + t = CATCH_BODY (curr_catch); + if (TREE_CODE (t) == BIND_EXPR) + { + /* Usual case of @catch (objc-expr). */ + objc_begin_try_stmt (loc, BIND_EXPR_BODY (t)); + BIND_EXPR_BODY (t) = NULL_TREE; + l = &BIND_EXPR_BODY (t); + } + else + { + /* NULL entry, meaning @catch (...). */ + objc_begin_try_stmt (loc, t); + CATCH_BODY (curr_catch) = NULL_TREE; + l = &CATCH_BODY (curr_catch); + } + + /* Pick up the new context we made in begin_try above... */ + ct = *cur_try_context; + func = build_function_call_vec (loc, objc2_end_catch_decl, NULL, NULL); + append_to_statement_list (func, &ct->finally_body); + try_exp = build_stmt (loc, TRY_FINALLY_EXPR, ct->try_body, ct->finally_body); + *cur_try_context = ct->outer; + free (ct); + append_to_statement_list (try_exp, l); + append_to_statement_list (curr_catch, &((*cur_try_context)->catch_list)); +} + +static tree +finish_try_stmt (struct objc_try_context **cur_try_context) +{ + struct objc_try_context *c = *cur_try_context; + tree stmt = c->try_body; + if (c->catch_list) + stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list); + if (c->finally_body) + stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body); + return stmt; +} + +#include "gt-objc-objc-next-runtime-abi-02.h" diff --git a/gcc/objc/objc-runtime-hooks.h b/gcc/objc/objc-runtime-hooks.h new file mode 100644 index 000000000..b325e75f9 --- /dev/null +++ b/gcc/objc/objc-runtime-hooks.h @@ -0,0 +1,111 @@ +/* Hooks to abstract the runtime meta-data generation for Objective C. + Copyright (C) 2011 Free Software Foundation, Inc. + Contributed by Iain Sandoe + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#ifndef _OBJC_RUNTIME_HOOKS_H_ +#define _OBJC_RUNTIME_HOOKS_H_ + +/* A set of hooks for the front end to obtain runtime-specific actions. */ + +/* Objective-C supports several runtime library variants: + + "GNU" runtime selected by -fgnu-runtime (currently at ABI version 8). + "NeXT" runtime (selected by -fnext-runtime) and installed on OSX/Darwin + systems at API version 1 (for m32 code) and version 2 (for m64 code). + + The runtimes require different data types/layouts, method call mechanisms + and so on, and the purpose of this interface is to abstract such + differences from the parser's perspective. */ + +/* TODO: Do we want the initial underscore ? */ +typedef struct _objc_runtime_hooks_r +{ + /* TODO: Expand comments in this file. */ + + /* Initialize for this runtime. */ + void (*initialize) (void); + const char *default_constant_string_class_name; + + /* FIXME: Having to check this name should not be necessary. */ + const char *tag_getclass; + /* id for superclass class field - named differently in the existing + runtimes. */ + tree (*super_superclassfield_ident) (void); + + /* Obtain a class decl for the identifier. */ + tree (*class_decl) (tree); + /* Obtain a metaclass decl for the identifier. */ + tree (*metaclass_decl) (tree); + /* Obtain a category decl for the identifier. */ + tree (*category_decl) (tree); + /* Obtain a protocol decl for the identifier. */ + tree (*protocol_decl) (tree); + /* Obtain a string decl, to be placed in the nominated string-section. */ + tree (*string_decl) (tree, const char *, string_section); + + /* Obtain a class reference, generating the fwd def. if necessary. */ + tree (*get_class_reference) (tree); + /* build/get selector reference. */ + tree (*build_selector_reference) (location_t, tree, tree); + /* Get a protocol reference, generating the forward def. if necessary. */ + tree (*get_protocol_reference) (location_t, tree); + /* Get an ivar ref. re the base. */ + tree (*build_ivar_reference) (location_t, tree, tree); + /* Get a reference to {meta}class' super. */ + tree (*get_class_super_ref) (location_t, struct imp_entry *, bool); + /* Get a reference to Category {meta}class' super. */ + tree (*get_category_super_ref) (location_t, struct imp_entry *, bool); + + /* Receiver is class Object, check runtime-specific. */ + tree (*receiver_is_class_object) (tree); + /* Get the start of a method argument type list (receiver, _cmd). */ + tree (*get_arg_type_list_base) (tree, int, int); + /* Build method call. */ + tree (*build_objc_method_call) (location_t, tree, tree, tree, tree, tree, int); + + /* Check for or otherwise handle a request to check that the constant + string class reference is set-up & OK. */ + bool (*setup_const_string_class_decl) (void); + /* Return the tree reprenting a const string constructor for the arg. + Most of the data are in global trees. */ + tree (*build_const_string_constructor) (location_t, tree, int); + + /* Exceptions. */ + tree (*build_throw_stmt) (location_t, tree, bool); + tree (*build_exc_ptr) (struct objc_try_context **); + tree (*begin_catch) (struct objc_try_context **, tree, tree, tree, bool); + void (*finish_catch) (struct objc_try_context **, tree); + tree (*finish_try_stmt) (struct objc_try_context **); + + /* Emit all the metadata required by the runtime - based on the tables built + during parsing. */ + void (*generate_metadata) (void); + +} objc_runtime_hooks; + +/* For shared support that needs to access these. */ +extern objc_runtime_hooks runtime; + +/* One per runtime at present. + TODO: Make into some kind of configury-generated table. */ +extern bool objc_gnu_runtime_abi_01_init (objc_runtime_hooks *); +extern bool objc_next_runtime_abi_01_init (objc_runtime_hooks *); +extern bool objc_next_runtime_abi_02_init (objc_runtime_hooks *); + +#endif /* _OBJC_RUNTIME_HOOKS_H_ */ diff --git a/gcc/objc/objc-runtime-shared-support.c b/gcc/objc/objc-runtime-shared-support.c new file mode 100644 index 000000000..8dca6ccae --- /dev/null +++ b/gcc/objc/objc-runtime-shared-support.c @@ -0,0 +1,736 @@ +/* Support routines shared by all runtimes. + Copyright (C) 2011 Free Software Foundation, Inc. + Contributed by Iain Sandoe (partially split from objc-act.c) + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#include "config.h" +#include "system.h" +#include "coretypes.h" +#include "tm.h" +#include "tree.h" + +#ifdef OBJCPLUS +#include "cp-tree.h" +#else +#include "c-tree.h" +#include "c-lang.h" +#endif +#include "langhooks.h" +#include "c-family/c-objc.h" +#include "objc-act.h" + +/* When building Objective-C++, we are not linking against the C front-end + and so need to replicate the C tree-construction functions in some way. */ +#ifdef OBJCPLUS +#define OBJCP_REMAP_FUNCTIONS +#include "objcp-decl.h" +#endif /* OBJCPLUS */ + +#include "obstack.h" + +/* These are only used for encoding ivars. */ +extern struct obstack util_obstack; +extern char *util_firstobj; + +/* Hooks for string decls etc. */ +#include "objc-runtime-hooks.h" + +#include "objc-runtime-shared-support.h" + +/* rt_trees identifiers - shared between NeXT implementations. These allow + the FE to tag meta-data in a manner that survives LTO and can be used when + the runtime requires that certain meta-data items appear in particular + named sections. */ +#include "objc-next-metadata-tags.h" +extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX]; + +/* Rather than repeatedly looking up the identifiers, we save them here. */ +tree objc_rt_trees[OCTI_RT_META_MAX]; + +/* For building an objc struct. These might not be used when this file + is compiled as part of obj-c++. */ + +static bool objc_building_struct; +static struct c_struct_parse_info *objc_struct_info ATTRIBUTE_UNUSED; + +/* Start building a struct for objc. */ + +tree +objc_start_struct (tree name) +{ + gcc_assert (!objc_building_struct); + objc_building_struct = true; + return start_struct (input_location, RECORD_TYPE, name, &objc_struct_info); +} + +/* Finish building a struct for objc. */ + +tree +objc_finish_struct (tree type, tree fieldlist) +{ + gcc_assert (objc_building_struct); + objc_building_struct = false; + return finish_struct (input_location, type, fieldlist, NULL_TREE, + objc_struct_info); +} + +tree +build_sized_array_type (tree base_type, int size) +{ + tree index_type = build_index_type (build_int_cst (NULL_TREE, size - 1)); + return build_array_type (base_type, index_type); +} + +/* Create a declaration for field NAME of a given TYPE. */ + +static tree +create_field_decl (tree type, const char *name) +{ + return build_decl (input_location, + FIELD_DECL, get_identifier (name), type); +} + +tree +add_field_decl (tree type, const char *name, tree **chain) +{ + tree field = create_field_decl (type, name); + + if (*chain != NULL) + **chain = field; + *chain = &DECL_CHAIN (field); + + return field; +} + +/* Create a global, static declaration for variable NAME of a given TYPE. The + finish_var_decl() routine will need to be called on it afterwards. */ + +tree +start_var_decl (tree type, const char *name) +{ + tree var = build_decl (input_location, + VAR_DECL, get_identifier (name), type); + TREE_STATIC (var) = 1; + DECL_INITIAL (var) = error_mark_node; /* A real initializer is coming... */ + DECL_IGNORED_P (var) = 1; + DECL_ARTIFICIAL (var) = 1; + DECL_CONTEXT (var) = NULL_TREE; +#ifdef OBJCPLUS + DECL_THIS_STATIC (var) = 1; /* squash redeclaration errors */ +#endif + return var; +} + +/* Finish off the variable declaration created by start_var_decl(). */ + +void +finish_var_decl (tree var, tree initializer) +{ + finish_decl (var, input_location, initializer, NULL_TREE, NULL_TREE); +} + +/* Just a handy wrapper for add_objc_string. */ + +tree +build_selector (tree ident) +{ + return convert (objc_selector_type, add_objc_string (ident, meth_var_names)); +} + +/* --- templates --- */ + +/* Set 'objc_super_template' to the data type node for 'struct _objc_super'. + This needs to be done just once per compilation. */ + +/* struct _objc_super { + struct _objc_object *self; + struct _objc_class *super_class; + [or Class cls; for the abi v2] + }; */ + +void +build_super_template (void) +{ + tree decls, *chain = NULL; + + objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER)); + + /* struct _objc_object *self; */ + decls = add_field_decl (objc_object_type, "self", &chain); + + /* struct _objc_class *super_class; */ + add_field_decl (build_pointer_type (objc_class_template), + "super_class", &chain); + + objc_finish_struct (objc_super_template, decls); +} + +/* To accomplish method prototyping without generating all kinds of + inane warnings, the definition of the dispatch table entries were + changed from: + + struct objc_method { SEL _cmd; ...; id (*_imp)(); }; + to: + struct objc_method { SEL _cmd; ...; void *_imp; }; */ + +tree +build_method_template (void) +{ + tree _SLT_record; + tree decls, *chain = NULL; + + _SLT_record = objc_start_struct (get_identifier (UTAG_METHOD)); + + /* SEL _cmd; */ + decls = add_field_decl (objc_selector_type, "_cmd", &chain); + + /* char *method_types; */ + add_field_decl (string_type_node, "method_types", &chain); + + /* void *_imp; */ + add_field_decl (build_pointer_type (void_type_node), "_imp", &chain); + + objc_finish_struct (_SLT_record, decls); + + return _SLT_record; +} + +tree +build_method_prototype_template (void) +{ + tree proto_record; + tree decls, *chain = NULL; + + proto_record = objc_start_struct (get_identifier (UTAG_METHOD_PROTOTYPE)); + + /* SEL _cmd; */ + decls = add_field_decl (objc_selector_type, "_cmd", &chain); + + /* char *method_types; */ + add_field_decl (string_type_node, "method_types", &chain); + + objc_finish_struct (proto_record, decls); + + return proto_record; +} + +/* struct { + struct _objc__method_prototype_list *method_next; + int method_count; + struct objc_method method_list[method_count]; + }; */ + +tree +build_method_list_template (tree list_type, int size) +{ + tree objc_ivar_list_record; + tree array_type, decls, *chain = NULL; + + objc_ivar_list_record = objc_start_struct (NULL_TREE); + + /* struct _objc__method_prototype_list *method_next; */ + decls = add_field_decl (objc_method_proto_list_ptr, "method_next", &chain); + + /* int method_count; */ + add_field_decl (integer_type_node, "method_count", &chain); + + /* struct objc_method method_list[]; */ + array_type = build_sized_array_type (list_type, size); + add_field_decl (array_type, "method_list", &chain); + + objc_finish_struct (objc_ivar_list_record, decls); + + return objc_ivar_list_record; +} + +/* struct objc_method_prototype_list { + int count; + struct objc_method_prototype { + SEL name; + char *types; + } list[1]; + }; */ + +tree +build_method_prototype_list_template (tree list_type, int size) +{ + tree objc_ivar_list_record; + tree array_type, decls, *chain = NULL; + + /* Generate an unnamed struct definition. */ + + objc_ivar_list_record = objc_start_struct (NULL_TREE); + + /* int method_count; */ + decls = add_field_decl (integer_type_node, "method_count", &chain); + + /* struct objc_method method_list[]; */ + array_type = build_sized_array_type (list_type, size); + add_field_decl (array_type, "method_list", &chain); + + objc_finish_struct (objc_ivar_list_record, decls); + + return objc_ivar_list_record; +} + +/* --- names, decls entry --- */ + +/* For each string section we have a chain which maps identifier nodes + to decls for the strings. */ + +static GTY(()) int meth_var_names_idx; +static GTY(()) int meth_var_types_idx; +static GTY(()) int property_name_attr_idx; + +tree +add_objc_string (tree ident, string_section section) +{ + tree *chain, decl, type; + char buf[BUFSIZE]; + + switch (section) + { + case class_names: + chain = &class_names_chain; + snprintf (buf, BUFSIZE, "_OBJC_ClassName_%s", IDENTIFIER_POINTER (ident)); + break; + case meth_var_names: + chain = &meth_var_names_chain; + snprintf (buf, BUFSIZE, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++); + break; + case meth_var_types: + chain = &meth_var_types_chain; + snprintf (buf, BUFSIZE, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++); + break; + case prop_names_attr: + chain = &prop_names_attr_chain; + snprintf (buf, BUFSIZE, "_OBJC_PropertyAttributeOrName_%d", property_name_attr_idx++); + break; + default: + gcc_unreachable (); + } + + while (*chain) + { + if (TREE_VALUE (*chain) == ident) + return convert (string_type_node, + build_unary_op (input_location, + ADDR_EXPR, TREE_PURPOSE (*chain), 1)); + + chain = &TREE_CHAIN (*chain); + } + + type = build_sized_array_type (char_type_node, IDENTIFIER_LENGTH (ident) + 1); + /* Get a runtime-specific string decl which will be finish_var()'ed in + generate_strings (). */ + decl = (*runtime.string_decl) (type, buf, section); + TREE_CONSTANT (decl) = 1; + *chain = tree_cons (decl, ident, NULL_TREE); + + return convert (string_type_node, + build_unary_op (input_location, ADDR_EXPR, decl, 1)); +} + +/* --- shared metadata routines --- */ + +tree +build_descriptor_table_initializer (tree type, tree entries) +{ + VEC(constructor_elt,gc) *inits = NULL; + + do + { + VEC(constructor_elt,gc) *elts = NULL; + + CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE, + build_selector (METHOD_SEL_NAME (entries))); + CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE, + add_objc_string (METHOD_ENCODING (entries), + meth_var_types)); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + objc_build_constructor (type, elts)); + + entries = DECL_CHAIN (entries); + } + while (entries); + + return objc_build_constructor (build_array_type (type, 0), inits); +} + +tree +build_dispatch_table_initializer (tree type, tree entries) +{ + VEC(constructor_elt,gc) *inits = NULL; + + do + { + VEC(constructor_elt,gc) *elems = NULL; + tree expr; + + CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, + build_selector (METHOD_SEL_NAME (entries))); + + /* Generate the method encoding if we don't have one already. */ + if (! METHOD_ENCODING (entries)) + METHOD_ENCODING (entries) = + encode_method_prototype (entries); + + CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, + add_objc_string (METHOD_ENCODING (entries), + meth_var_types)); + + expr = convert (ptr_type_node, + build_unary_op (input_location, ADDR_EXPR, + METHOD_DEFINITION (entries), 1)); + CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, expr); + + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + objc_build_constructor (type, elems)); + + entries = DECL_CHAIN (entries); + } + while (entries); + + return objc_build_constructor (build_array_type (type, 0), inits); +} + +/* Used only by build_*_selector_translation_table (). */ +void +diagnose_missing_method (tree meth, location_t here) +{ + tree method_chain; + bool found = false; + for (method_chain = meth_var_names_chain; + method_chain; + method_chain = TREE_CHAIN (method_chain)) + { + if (TREE_VALUE (method_chain) == meth) + { + found = true; + break; + } + } + + if (!found) + warning_at (here, 0, "creating selector for nonexistent method %qE", + meth); +} + + +static tree +init_module_descriptor (tree type, long vers) +{ + tree expr, ltyp; + location_t loc; + VEC(constructor_elt,gc) *v = NULL; + + /* No really useful place to point to. */ + loc = UNKNOWN_LOCATION; + + /* version = { 1, ... } */ + + expr = build_int_cst (long_integer_type_node, vers); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* size = { ..., sizeof (struct _objc_module), ... } */ + + expr = convert (long_integer_type_node, + size_in_bytes (objc_module_template)); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* Don't provide any file name for security reasons. */ + /* name = { ..., "", ... } */ + + expr = add_objc_string (get_identifier (""), class_names); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + /* symtab = { ..., _OBJC_SYMBOLS, ... } */ + + ltyp = build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_SYMTAB))); + if (UOBJC_SYMBOLS_decl) + expr = convert (ltyp, build_unary_op (loc, + ADDR_EXPR, UOBJC_SYMBOLS_decl, 0)); + else + expr = convert (ltyp, null_pointer_node); + CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); + + return objc_build_constructor (type, v); +} + +/* Write out the data structures to describe Objective C classes defined. + + struct _objc_module { ... } _OBJC_MODULE = { ... }; */ + +void +build_module_descriptor (long vers, tree attr) +{ + tree decls, *chain = NULL; + +#ifdef OBJCPLUS + push_lang_context (lang_name_c); /* extern "C" */ +#endif + + objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE)); + + /* long version; */ + decls = add_field_decl (long_integer_type_node, "version", &chain); + + /* long size; */ + add_field_decl (long_integer_type_node, "size", &chain); + + /* char *name; */ + add_field_decl (string_type_node, "name", &chain); + + /* struct _objc_symtab *symtab; */ + add_field_decl (build_pointer_type (xref_tag (RECORD_TYPE, + get_identifier (UTAG_SYMTAB))), + "symtab", &chain); + + objc_finish_struct (objc_module_template, decls); + + /* Create an instance of "_objc_module". */ + UOBJC_MODULES_decl = start_var_decl (objc_module_template, + /* FIXME - why the conditional + if the symbol is the + same. */ + flag_next_runtime ? "_OBJC_Module" : "_OBJC_Module"); + + /* This is the root of the metadata for defined classes and categories, it + is referenced by the runtime and, therefore, needed. */ + DECL_PRESERVE_P (UOBJC_MODULES_decl) = 1; + + /* Allow the runtime to mark meta-data such that it can be assigned to target + specific sections by the back-end. */ + if (attr) + DECL_ATTRIBUTES (UOBJC_MODULES_decl) = attr; + + finish_var_decl (UOBJC_MODULES_decl, + init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl), + vers)); + +#ifdef OBJCPLUS + pop_lang_context (); +#endif +} + +tree +build_ivar_list_initializer (tree type, tree field_decl) +{ + VEC(constructor_elt,gc) *inits = NULL; + + do + { + VEC(constructor_elt,gc) *ivar = NULL; + tree id; + + /* Set name. */ + if (DECL_NAME (field_decl)) + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, + add_objc_string (DECL_NAME (field_decl), + meth_var_names)); + else + /* Unnamed bit-field ivar (yuck). */ + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, build_int_cst (NULL_TREE, 0)); + + /* Set type. */ + encode_field_decl (field_decl, + obstack_object_size (&util_obstack), + OBJC_ENCODE_DONT_INLINE_DEFS); + + /* Null terminate string. */ + obstack_1grow (&util_obstack, 0); + id = add_objc_string (get_identifier (XOBFINISH (&util_obstack, char *)), + meth_var_types); + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id); + obstack_free (&util_obstack, util_firstobj); + + /* Set offset. */ + CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, byte_position (field_decl)); + CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, + objc_build_constructor (type, ivar)); + do + field_decl = DECL_CHAIN (field_decl); + while (field_decl && TREE_CODE (field_decl) != FIELD_DECL); + } + while (field_decl); + + return objc_build_constructor (build_array_type (type, 0), inits); +} + +/* struct { + int ivar_count; + struct objc_ivar ivar_list[ivar_count]; + }; */ + +tree +build_ivar_list_template (tree list_type, int size) +{ + tree objc_ivar_list_record; + tree array_type, decls, *chain = NULL; + + objc_ivar_list_record = objc_start_struct (NULL_TREE); + + /* int ivar_count; */ + decls = add_field_decl (integer_type_node, "ivar_count", &chain); + + /* struct objc_ivar ivar_list[]; */ + array_type = build_sized_array_type (list_type, size); + add_field_decl (array_type, "ivar_list", &chain); + + objc_finish_struct (objc_ivar_list_record, decls); + + return objc_ivar_list_record; +} + +/* struct _objc_ivar { + char *ivar_name; + char *ivar_type; + int ivar_offset; + }; */ + +tree +build_ivar_template (void) +{ + tree objc_ivar_id, objc_ivar_record; + tree decls, *chain = NULL; + + objc_ivar_id = get_identifier (UTAG_IVAR); + objc_ivar_record = objc_start_struct (objc_ivar_id); + + /* char *ivar_name; */ + decls = add_field_decl (string_type_node, "ivar_name", &chain); + + /* char *ivar_type; */ + add_field_decl (string_type_node, "ivar_type", &chain); + + /* int ivar_offset; */ + add_field_decl (integer_type_node, "ivar_offset", &chain); + + objc_finish_struct (objc_ivar_record, decls); + + return objc_ivar_record; +} + +/* Used by NeXT ABI=0..2 */ +void +build_next_selector_translation_table (void) +{ + tree chain; + for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain)) + { + tree expr; + tree decl = TREE_PURPOSE (chain); + if (warn_selector) + { + location_t loc; + if (decl) + loc = DECL_SOURCE_LOCATION (decl); + else + loc = UNKNOWN_LOCATION; + diagnose_missing_method (TREE_VALUE (chain), loc); + } + + expr = build_selector (TREE_VALUE (chain)); + + if (decl) + { + /* Entries of this form are used for references to methods. + The runtime re-writes these on start-up, but the compiler can't see + that and optimizes it away unless we force it. */ + DECL_PRESERVE_P (decl) = 1; + finish_var_decl (decl, expr); + } + } +} + +void +generate_protocol_references (tree plist) +{ + tree lproto; + + /* Forward declare protocols referenced. */ + for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) + { + tree proto = TREE_VALUE (lproto); + + if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE + && PROTOCOL_NAME (proto)) + { + if (! PROTOCOL_FORWARD_DECL (proto)) + PROTOCOL_FORWARD_DECL (proto) = (*runtime.protocol_decl) (proto); + + if (PROTOCOL_LIST (proto)) + generate_protocol_references (PROTOCOL_LIST (proto)); + } + } +} + +/* --- new routines --- */ + +/* Output all strings. */ + +/* FIXME: don't use global vars for all this... */ + +/* This emits all the meta-data string tables (and finalizes each var + as it goes). */ +void +generate_strings (void) +{ + tree chain, string_expr; + tree string, decl; /* , type;*/ + + for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain)) + { + string = TREE_VALUE (chain); + decl = TREE_PURPOSE (chain); + string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1, + IDENTIFIER_POINTER (string)); + finish_var_decl (decl, string_expr); + } + + for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain)) + { + string = TREE_VALUE (chain); + decl = TREE_PURPOSE (chain); + string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1, + IDENTIFIER_POINTER (string)); + finish_var_decl (decl, string_expr); + } + + for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain)) + { + string = TREE_VALUE (chain); + decl = TREE_PURPOSE (chain); + string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1, + IDENTIFIER_POINTER (string)); + finish_var_decl (decl, string_expr); + } + + for (chain = prop_names_attr_chain; chain; chain = TREE_CHAIN (chain)) + { + string = TREE_VALUE (chain); + decl = TREE_PURPOSE (chain); + string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1, + IDENTIFIER_POINTER (string)); + finish_var_decl (decl, string_expr); + } +} + +#include "gt-objc-objc-runtime-shared-support.h" diff --git a/gcc/objc/objc-runtime-shared-support.h b/gcc/objc/objc-runtime-shared-support.h new file mode 100644 index 000000000..8e4693d6f --- /dev/null +++ b/gcc/objc/objc-runtime-shared-support.h @@ -0,0 +1,90 @@ +/* Support routines shared by all runtimes. + Copyright (C) 2011 Free Software Foundation, Inc. + Contributed by Iain Sandoe + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + +#ifndef _OBJC_RUNTIME_SHARED_SUPPORT_H_ +#define _OBJC_RUNTIME_SHARED_SUPPORT_H_ + +/* Left in obj-act.c for now... */ + +extern tree objc_start_struct (tree); +extern tree objc_finish_struct (tree, tree); +extern tree add_field_decl (tree, const char *, tree **); +extern tree build_sized_array_type (tree, int); + +extern tree lookup_interface (tree); +extern tree objc_build_constructor (tree, VEC(constructor_elt,gc) *); + +extern tree start_var_decl (tree, const char *); +extern void finish_var_decl (tree, tree); + +extern tree my_build_string (int, const char *); +extern tree my_build_string_pointer (int, const char *); +extern tree add_objc_string (tree ident, string_section); +extern tree get_objc_string_decl (tree, string_section); + +extern void add_class_reference (tree); + +#ifdef OBJCPLUS +extern void objc_start_function (tree, tree, tree, tree); +extern tree objc_get_parm_info (int); +#else +extern void objc_start_function (tree, tree, tree, struct c_arg_info *); +extern struct c_arg_info *objc_get_parm_info (int); +#endif +extern void objc_push_parm (tree); +extern tree get_arg_type_list (tree, int, int); + +/* Stuff that should be migrated to shared support (or some v1-only file). */ +extern void build_super_template (void); + +extern tree objc_build_component_ref (tree, tree); + +extern tree objc_v2_encode_prop_attr (tree); +extern tree build_descriptor_table_initializer (tree, tree); +extern tree build_method_prototype_list_template (tree, int); +extern tree build_protocol_initializer (tree, tree, tree, tree, tree); + +/* Stuff that should be migrated to shared encode. */ +extern tree encode_method_prototype (tree); +extern void encode_field_decl (tree, int, int); + +/* Moved or new routines in objc-runtime-shared-support.c */ + +extern tree build_selector (tree); +extern tree build_method_template (void); +extern tree build_method_prototype_template (void); +extern tree build_method_list_template (tree, int); + +extern tree build_dispatch_table_initializer (tree, tree); +extern void diagnose_missing_method (tree, location_t); +extern void build_next_selector_translation_table (void); +extern void generate_protocol_references (tree); +extern void build_module_descriptor (long, tree); +extern tree build_ivar_list_initializer (tree, tree); +extern tree build_ivar_list_template (tree, int); +extern tree build_ivar_template (void); + +extern void generate_strings (void); + +extern void dump_interface (FILE *, tree); +extern int generating_instance_variables; +extern FILE *gen_declaration_file; + +#endif /* _OBJC_RUNTIME_SHARED_SUPPORT_H_ */ diff --git a/gcc/objc/objc-tree.def b/gcc/objc/objc-tree.def new file mode 100644 index 000000000..5833e6ae7 --- /dev/null +++ b/gcc/objc/objc-tree.def @@ -0,0 +1,77 @@ +/* This file contains the definitions and documentation for the + additional tree codes used in the Objective C front end (see tree.def + for the standard codes). + Copyright (C) 1990, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2007, 2010 + Free Software Foundation, Inc. + +This file is part of GCC. + +GCC is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 3, or (at your option) +any later version. + +GCC is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GCC; see the file COPYING3. If not see +. */ + + +/* Objective-C types. */ +DEFTREECODE (CLASS_INTERFACE_TYPE, "class_interface_type", tcc_type, 0) +DEFTREECODE (CLASS_IMPLEMENTATION_TYPE, "class_implementation_type", + tcc_type, 0) +DEFTREECODE (CATEGORY_INTERFACE_TYPE, "category_interface_type", tcc_type, 0) +DEFTREECODE (CATEGORY_IMPLEMENTATION_TYPE,"category_implementation_type", + tcc_type, 0) +DEFTREECODE (PROTOCOL_INTERFACE_TYPE, "protocol_interface_type", tcc_type, 0) + +/* Objective-C decls. */ +DEFTREECODE (KEYWORD_DECL, "keyword_decl", tcc_declaration, 0) +DEFTREECODE (INSTANCE_METHOD_DECL, "instance_method_decl", tcc_declaration, 0) +DEFTREECODE (CLASS_METHOD_DECL, "class_method_decl", tcc_declaration, 0) +DEFTREECODE (PROPERTY_DECL, "property_decl", tcc_declaration, 0) + +/* Objective-C expressions. */ +DEFTREECODE (MESSAGE_SEND_EXPR, "message_send_expr", tcc_expression, 3) +DEFTREECODE (CLASS_REFERENCE_EXPR, "class_reference_expr", tcc_expression, 1) + +/* This tree is used to represent the expression 'object.property', + where 'object' is an Objective-C object and 'property' is an + Objective-C property. Operand 0 is the object (the tree + representing the expression), and Operand 1 is the property (the + PROPERTY_DECL). Operand 2 is the 'getter' call, ready to be used; + we pregenerate it because it is hard to generate it properly later + on. Operand 3 records whether using the 'getter' call should + generate a deprecation warning or not. + + A PROPERTY_REF tree needs to be transformed into 'setter' and + 'getter' calls at some point; at the moment this happens in two + places: + + * if we detect that a modify expression is being applied to a + PROPERTY_REF, then we transform that into a 'getter' call (this + happens in build_modify_expr() or cp_build_modify_expr()). + + * else, it will remain as a PROPERTY_REF until we get to + gimplification; at that point, we convert each PROPERTY_REF into + a 'getter' call during ObjC/ObjC++ gimplify. At that point, it + is quite hard to build a 'getter' call, but we have already built + it and we just need to swap Operand 2 in, and emit the deprecation + warnings from Operand 3 if needed. + + Please note that when the Objective-C 2.0 "dot-syntax" 'object.component' + is encountered, where 'component' is not a property but there are valid + setter/getter methods for it, an artificial PROPERTY_DECL is generated + and used in the PROPERTY_REF. */ +DEFTREECODE (PROPERTY_REF, "property_ref", tcc_expression, 4) + +/* +Local variables: +mode:c +End: +*/ -- cgit v1.2.3