Initial checkin of GCC 4.9.0 from trunk (r208799).

Change-Id: I48a3c08bb98542aa215912a75f03c0890e497dba

19 files changed, 26199 insertions, 0 deletions

diff --git a/gcc-4.9/gcc/objc/ChangeLog b/gcc-4.9/gcc/objc/ChangeLog
new file mode 100644
index 000000000..ca9841eed
--- /dev/null
+++ b/gcc-4.9/gcc/objc/ChangeLog
@@ -0,0 +1,3463 @@
+2014-01-31  Marek Polacek  <polacek@redhat.com>
+
+	PR c/59963
+	* objc-next-runtime-abi-02.c (build_throw_stmt): Pass vNULL to
+	build_function_call_vec.
+	(finish_catch): Likewise.
+	(next_runtime_abi_02_get_class_reference): Likewise.
+	* objc-next-runtime-abi-01.c (build_objc_method_call): Pass vNULL to
+	build_function_call_vec.
+	(build_throw_stmt): Likewise.
+	* objc-gnu-runtime-abi-01.c: (build_objc_method_call): Pass vNULL to
+	build_function_call_vec.
+	(build_throw_stmt): Likewise.
+
+2014-01-02  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	Update copyright years
+
+2013-12-04  Joseph Myers  <joseph@codesourcery.com>
+
+	PR c/52023
+	* objc-act.c (objc_synthesize_getter): Update calls to
+	c_sizeof_or_alignof_type.
+
+2013-11-22  Andrew MacLeod  <amacleod@redhat.com>
+
+	* objc/objc-act.c: Add required include files from gimple.h.
+
+2013-11-18  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* objc-encoding.c: Replace tree_low_cst (..., 1) with tree_to_uhwi
+	throughout.
+
+2013-11-18  Richard Sandiford  <rdsandiford@googlemail.com>
+
+	* objc-next-runtime-abi-02.c: Replace tree_low_cst (..., 0) with
+	tree_to_shwi throughout.
+
+2013-11-14  Andrew MacLeod  <amacleod@redhat.com>
+
+	* objc-act.c: Include only gimplify.h and gimple.h as needed.
+
+2013-11-14  Diego Novillo  <dnovillo@google.com>
+
+	* objc-act.c: Include stringpool.h.
+	Include stor-layout.h.
+	Include attribs.h.
+	* objc-encoding.c: Include stringpool.h.
+	Include stor-layout.h.
+	* objc-gnu-runtime-abi-01.c: Include stringpool.h.
+	* objc-next-runtime-abi-01.c:
+	Include stringpool.h.
+	* objc-next-runtime-abi-02.c: Include stringpool.h.
+	* objc-runtime-shared-support.c: Include stringpool.h.
+
+2013-11-12  Andrew MacLeod  <amacleod@redhat.com>
+
+	* objc-act.c: Include gimplify.h.
+
+2013-11-07  Andrew MacLeod  <amacleod@redhat.com>
+
+	* objc-act.c (objc_push_parm): Handle atomic qualifier.
+
+2013-09-25  Tom Tromey  <tromey@redhat.com>
+
+	* Make-lang.in (START_HDRS, cc1obj-checksum.o, objc/objc-lang.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/objc-act.o)
+	(objc/objc-encoding.o, objc/objc-map.o): Remove.
+
+2013-09-14  Iain Sandoe  <iain@codesourcery.com>
+
+	PR target/48094
+	* objc-next-runtime-abi-01.c (generate_objc_image_info): Remove.
+	(objc_generate_v1_next_metadata): Remove generation of ImageInfo.
+	* objc-next-runtime-abi-02.c (generate_v2_objc_image_info): Remove.
+	(objc_generate_v2_next_metadata): Remove generation of ImageInfo.
+
+2013-07-21   Ondřej Bílka  <neleai@seznam.cz>
+
+	* objc-act.c: Fix typos.
+	* objc-encoding.c: Likewise.
+	* objc-gnu-runtime-abi-01.c: Likewise.
+	* objc-next-runtime-abi-01.c: Likewise.
+	* objc-next-runtime-abi-02.c: Likewise.
+
+2013-05-22  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	* objc-next-runtime-abi-02.c (build_v2_build_objc_method_call):
+	Fix build_conditional_expr call.
+
+2013-05-16  Jason Merrill  <jason@redhat.com>
+
+	* Make-lang.in (cc1obj$(exeext)): Use link mutex.
+
+2012-11-20  Diego Novillo  <dnovillo@google.com>
+
+	* objc-act.c: Replace all vec<T, A>() initializers with vNULL.
+
+2012-11-16  Diego Novillo  <dnovillo@google.com>
+
+	Adjust for new vec API (http://gcc.gnu.org/wiki/cxx-conversion/cxx-vec)
+
+	* objc-act.c: Use new vec API in vec.h.
+	* objc-act.h: Likewise.
+	* objc-gnu-runtime-abi-01.c: Likewise.
+	* objc-next-runtime-abi-01.c: Likewise.
+	* objc-next-runtime-abi-02.c: Likewise.
+	* objc-runtime-hooks.h: Likewise.
+	* objc-runtime-shared-support.c: Likewise.
+	* objc-runtime-shared-support.h: Likewise.
+
+2012-10-01  Lawrence Crowl  <crowl@google.com>
+
+	* Make-lang.in (OBJC_OBJS): Add dependence on hash-table.o.
+	(objc-act.o): Add dependence on hash-table.h.
+	* objc-act.c (objc_detect_field_duplicates): Change to new type-safe
+	hash table.
+
+2012-06-29  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* Make-ang.in: Adjust for move of C front-end files.
+	* config-lang.in: Likewise.
+	* objc-encoding.c: Look for cp-tree.h in cp/, and for c-tree.h
+	and c-lang.h in c/.
+	* objc-runtime-shared-support.c: Likewise.
+	* objc-next-runtime-abi-01.c: Likewise.
+	* objc-next-runtime-abi-02.c: Likewise.
+	* objc-gnu-runtime-abi-01.c: Likewise.
+	* objc-act.c: Likewise.
+	* objc-lang.c: Likewise.
+
+2012-06-19  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* objc-next-runtime-abi-01.c: Do not include tm.h and output.h.
+	Include c-family/c-target.h.
+	(handle_next_class_ref): Rewrite to emit top-level asm statements.
+	(handle_next_impent): Likewise.
+	* objc/Make-lang.in: Fix dependencies for objc-next-runtime-abi-01.o.
+
+2012-05-31  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* objc-act.c: Do not include output.h.
+
+2012-05-17  Paolo Carlini  <paolo.carlini@oracle.com>
+
+	PR objc++/53388
+	* objc-act.c (objc_get_class_reference, objc_build_message_expr):
+	Use build_min_nt_loc.
+
+2012-04-20  Jan Hubicka  <jh@suse.cz>
+
+	* objc-act.c (mark_referenced_methods); Use
+	cgraph_mark_force_output_node.
+
+2012-03-21  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* objc-act (objc_build_ivar_assignment): Do not call assemble_external.
+	(objc_build_global_assignment): Likewise.
+	(objc_build_strong_cast_assignment): Likewise.
+	* objc-next-runtime-abi-01.c: Cleanup commented-out assemble_external.
+	* objc-next-runtime-abi-02.c: Likewise.
+	* objc-gnu-runtime-abi-01.c: Likewise.
+
+2012-03-05  Jason Merrill  <jason@redhat.com>
+
+	* objc-map.c (objc_map_private_resize, objc_map_alloc_ggc): Don't
+	call _stat functions without MEM_STAT_INFO.
+
+2011-11-12  Iain Sandoe  <iains@gcc.gnu.org>
+
+	* objc-next-runtime-abi-01.c (objc_eh_personality): Use gcc personality
+	for Objective-C m32.
+
+2011-10-29  Iain Sandoe  <iains@gcc.gnu.org>
+
+	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-10-18  Mikael Pettersson  <mikpe@it.uu.se>
+
+	PR objc/50743
+	* objc-act.c (check_duplicates): Cast TREE_VEC_LENGTH result to
+	size_t to avoid signed/unsigned
+	comparison.
+	(insert_method_into_method_map): Likewise.
+
+2011-10-14  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-map.h: New file.
+	* objc-map.c: New file.	
+	* config-lang.in (gtfiles): Added objc-map.h.
+	* Make-lang.in (OBJC_OBJS): Added objc-map.o.
+	(objc/objc-map.o): New rule.
+	(objc/objc-act.o): Depend on objc/objc-map.h.
+	* objc-next-runtime-abi-02.c: Added a TODO comment.
+	* objc-act.c: Include objc-map.h.
+	(nst_method_hash_list, cls_method_hash_list): Removed.
+	(instance_method_map, class_method_map): New.
+	(cls_name_hash_list, als_name_hash_list): Removed.
+	(class_name_map, alias_name_map): Removed.
+	(ivar_offset_hash_list): Removed.
+	(hash_class_name_enter, hash_class_name_lookup, hash_enter,
+	hash_lookup, hash_add_attr, add_method_to_hash_list): Removed.
+	(interface_hash_init): New.
+	(objc_init): Call interface_hash_init.
+	(objc_write_global_declarations): Iterate over class_method_map
+	and instance_method_map instead of cls_method_hash_list and
+	nst_method_hash_list.
+	(objc_declare_alias): Use alias_name_map instead of
+	cls_name_hash_list.
+	(objc_is_class_name): Use class_name_map and alias_name_map
+	instead of cls_name_hash_list and als_name_hash_list.
+	(interface_tuple, interface_htab, hash_interface, eq_interface):
+	Removed.
+	(interface_map): New.
+	(add_class): Renamed to add_interface.  Use interface_map instead
+	of interface_htab.
+	(lookup_interface): Use interface_map instead of interface_htab.
+	(check_duplicates): Changed first argument to be a tree,
+	potentially a TREE_VEC, instead of a hash.  Changed implementation
+	to match.
+	(lookup_method_in_hash_lists): Use class_method_map and
+	instance_method_map instead of cls_method_hash_list and
+	nst_method_hash_list.
+	(objc_build_selector_expr): Likewise.
+	(hash_func): Removed.
+	(hash_init): Create instance_method_map, class_method_map,
+	class_name_map, and alias_name_map.  Do not create
+	nst_method_hash_list, cls_method_hash_list, cls_name_hash_list,
+	als_name_hash_list, and ivar_offset_hash_list.
+	(insert_method_into_method_map): New.
+	(objc_add_method): Use insert_method_into_method_map instead of
+	add_method_to_hash_list.
+	(start_class): Call add_interface instead of add_class.
+	* objc-act.h (cls_name_hash_list, als_name_hash_list,
+	nst_method_hash_list, cls_method_hash_list): Removed.
+
+2011-10-11  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+	* objc-next-runtime-abi-01.c (objc_build_exc_ptr): Delete old
+	interface with two parallel arrays to hold standard builtin
+	declarations, and replace it with a function based interface that
+	can support creating builtins on the fly in the future.  Change
+	all uses, and poison the old names.  Make sure 0 is not a
+	legitimate builtin index.
+	* objc-next-runtime-abi-02.c (objc_build_exc_ptr): Ditto.
+	* objc-gnu-runtime-abi-01.c (objc_build_exc_ptr): Ditto.
+
+2011-07-19  Richard Guenther  <rguenther@suse.de>
+
+	* objc-next-runtime-abi-02.c (objc_v2_build_ivar_ref):
+	Use fold_build_pointer_plus.
+	(objc2_build_ehtype_initializer): Likewise.
+
+2011-07-11  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-encoding.h (obstack.h): Do not include.
+	(util_obstack, util_firstobj): Do not declare.
+	(encode_field_decl): Updated prototype to return a tree and take a
+	single tree argument.  Updated comments.
+	* objc-encoding.c (util_obstack, util_firstobj): Made static.
+	(objc_encoding_init): New.
+	(encode_field_decl): Existing function renamed to encode_field and
+	made static.  New encode_field_decl wrapper function added.
+	(encode_aggregate_fields): Update call to encode_field_decl to
+	call encode_field.
+	* objc-next-runtime-abi-02.c (obstack.h): Do not include.
+	(util_obstack, util_firstobj): Do not declare.
+	(build_v2_ivar_list_initializer): Updated call to
+	encode_field_decl.
+	* objc-runtime-shared-support.c (obstack.h): Do not include.
+	(util_obstack, util_firstobj): Do not declare.
+	(build_ivar_list_initializer): Updated call to encode_field_decl.
+	* objc-act.c (objc_init): Use objc_encoding_init.
+	* Make-lang.in (objc/objc-runtime-shared-support.o): Do not depend
+	on OBSTACK_H.
+	(objc/objc-gnu-runtime-abi-01.o): Likewise.
+	(objc/objc-next-runtime-abi-01.o): Likewise.
+	(objc/objc-next-runtime-abi-02.o): Likewise.
+	(objc/objc-act.o): Likewise.
+	
+2011-07-04  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	Refactored encoding code into objc-encoding.h and objc-encoding.c.
+	* objc-act.c (util_obstack, util_firstobj, encode_type_qualifiers,
+	encode_type, generating_instance_variables, objc_method_parm_type,
+	objc_encoded_type_size, encode_method_prototype,
+	objc_build_encode_expr, pointee_is_readonly, encode_pointer,
+	encode_array, encode_vector, encode_aggregate_fields,
+	encode_aggregate_within, encode_next_bitfield,
+	encode_gnu_bitfield, encode_field_decl,
+	objc_v2_encode_property_attr): Moved to objc-encoding.h and
+	objc-encoding.c.  No change in the actual code.
+	Include objc-encoding.h.
+	(objc_init): Added TODO.
+	(objc_build_property_setter_name): Made non-static so it can be
+	called from objc-encoding.c.
+	* objc-act.h (OBJC_ENCODE_INLINE_DEFS,
+	OBJC_ENCODE_DONT_INLINE_DEFS): Moved to objc-encoding.h.
+	* objc-runtime-shared-support.h (objc_v2_encode_property_attr,
+	encode_method_prototype, encode_field_decl,
+	generating_instance_variables): Moved to objc-encoding.h.	
+	(objc_build_property_setter_name): Declare.
+	* objc-encoding.c: New.
+	* objc-encoding.h: New.
+	* objc-gnu-runtime-abi-01.c: Include objc-encoding.h.
+	* objc-next-runtime-abi-01.c: Likewise.
+	* objc-next-runtime-abi-02.c: Likewise.	
+	* objc-runtime-shared-support.c: Likewise.
+	* Make-lang.in (OBJC_OBJS): Added objc-encoding.o.
+	(objc/objc-lang.o): Reordered dependencies.
+	(objc/objc-runtime-shared-support.o): Reordered dependencies.
+	Added dependencies on objc-encoding.h and on $(GGC_H),
+	$(DIAGNOSTIC_CORE_H), $(FLAGS_H) and input.h.
+	(objc/objc-gnu-runtime-abi-01.o): Likewise.
+	(objc/objc-next-runtime-abi-01.o): Likewise.
+	(objc/objc-next-runtime-abi-02.o): Likewise.
+	(objc/objc-act.o): Reordered dependencies.  Added dependency on
+	objc-encoding.h.
+	(objc/objc-encoding.o): New rule.
+
+	* objc-encoding.c (encode_type): Use "%<%T%>" format when printing
+	warning "unknown type %<%T%> found during Objective-C encoding"
+	instead of using gen_type_name.
+	
+2011-06-05  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (receiver_is_class_object): Expanded comment.
+	(objc_finish_message_expr): Likewise.
+
+2011-06-02  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	PR objc/48539
+	* objc-act.c (objc_finish_message_expr): Warn if messaging a class
+	that was only declared using @class without an @interface.  Warn
+	if messaging an instance of a class that was only declared using
+	@class without an @interface, unless the receiver was also typed
+	with a protocol list.
+
+2011-06-01  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_decl_method_attributes): Implement nonnull
+	attribute for Objective-C methods.
+
+2011-05-21  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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-05-20  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* objc-act.c (objc_compare_types): Use function_args_iterator
+	instead of TYPE_ARG_TYPES to compare function argument types.
+
+2011-05-13  Toon Moene  <toon@moene.org>
+
+	* objc-next-runtime-abi-02.c (newabi_append_ro):
+	Add const qualifier to constant variable pointer declaration.
+
+2011-05-11  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* objc-act.h (CLASS_NAME, CLASS_SUPER_NAME): Use proper accessors.
+	(CLASS_NST_METHODS, CLASS_CLS_METHODS): Likewise.
+	(PROTOCOL_NAME, PROTOCOL_NST_METHODS, PROTOCOL_CLS_METHODS): Likewise.
+
+2011-05-05  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* objc-runtime-shared-support.h (get_arg_type_list): Delete.
+	(build_function_type_for_method): Declare.
+	* objc-runtime-hooks.h (struct _objc_runtime_hooks_r): Change
+	type of get_arg_type_base_list field.
+	* objc-act.h (OBJC_VOID_AT_END): Delete.
+	* objc-act.c (get_arg_type_list): Delete.
+	(build_function_type_for_method): New function.
+	(objc_decl_method_attributes): Call build_function_type_for_method.
+	(really_start_method): Likewise.
+	* objc-gnu-runtime-abi-01.c
+	(gnu_runtime_abi_01_get_type_arg_list_base): Change prototype and
+	adjust function accordingly.  Update header comment.
+	(build_objc_method_call): Call build_function_type_for_method.
+	* objc-next-runtime-abi-01.c
+	(next_runtime_abi_01_get_type_arg_list_base): Change prototype and
+	adjust function accordingly.  Update header comment.
+	(build_objc_method_call): Call build_function_type_for_method.
+	* objc-next-runtime-abi-02.c
+	(next_runtime_abi_02_get_type_arg_list_base): Change prototype and
+	adjust function accordingly.  Update header comment.
+	(objc_copy_to_temp_side_effect_params): Take fntype instead of a
+	typelist.  Use function_args_iterator for traversing fntype.
+	(build_v2_build_objc_method_call): Adjust call to it.
+	Call build_function_type_for_method
+
+2011-05-05  Joseph Myers  <joseph@codesourcery.com>
+
+	* objc-act.c (objc_start_method_definition): Add parameter expr.
+	Update call to start_method_def.
+	(objc_generate_cxx_ctor_or_dtor, objc_synthesize_getter,
+	objc_synthesize_setter) Update calls to
+	objc_start_method_definition.
+	(objc_get_parm_info): Add parameter expr.  Update call to
+	get_parm_info.
+	(start_method_def): Add parameter expr.  Update call to
+	objc_get_parm_info.
+	* objc-gnu-runtime-abi-01.c (build_module_initializer_routine):
+	Update call to objc_get_parm_info.
+	* objc-runtime-shared-support.h (objc_get_parm_info): Add extra
+	parameter.
+
+2011-04-26  Jason Merrill  <jason@redhat.com>
+
+	* objc-act.c (objc_fold_objc_type_ref): Remove.
+	* objc-act.h: Remove prototype.
+
+2011-04-21  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* objc-act.c (synth_module_prologue): Call build_function_type_list
+	instead of build_function_type.
+	* objc-next-runtime-abi-02.c (next_runtime_02_initialize):
+	Likewise.
+
+2011-04-15  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (ivar_of_class): New.
+	(objc_is_public): Use ivar_of_class.
+
+2011-04-15  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_get_interface_ivars): Removed.
+	(objc_detect_field_duplicates): New.
+	(hash_instance_variable): New.
+	(eq_instance_variable): New.
+
+2011-04-14  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_declare_protocols): Renamed to
+	objc_declare_protocol.  Changed first argument to be an identifier
+	instead of a tree chain of identifiers, so that callers don't have
+	to create a temporary tree chain.
+
+2011-04-14  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_declare_class): Changed to take a single
+	identifier as argument instead of a tree list.  This means callers
+	don't have to build temporary tree lists to call this function.
+	(synth_module_prologue): Updated calls to objc_declare_class.
+
+2011-04-13  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (build_keyword_selector): Use get_identifier_with_length
+	instead of get_identifier.
+
+2011-04-12  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* objc-lang.c (objc_init_ts): Move code for this function...
+	* objc-act.c (objc_common_init_ts): ...here. Define.
+	* objc-act.h (objc_common_init_ts): Declare.
+
+2011-04-12  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_build_message_expr): Accept two arguments
+	instead of one so that callers can simply pass the arguments
+	without having to create a temporary chain to hold them.
+
+2011-04-12  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (comp_proto_with_proto): Do not create and use
+	inefficient temporary argument lists.  Compare the arguments
+	directly.  (match_proto_with_proto): Removed; incorporated into
+	comp_proto_with_proto ().
+
+2011-04-12  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (printable_ivar_name): New.
+	(add_instance_variable): Call printable_ivar_name() when an error
+	message needs to be printed.  Do not prepare the instance variable
+	for printing unless there is an actual error.
+
+2011-04-12  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_is_class_name, objc_is_id): For efficiency,
+	avoid calling identifier_global_value() multiple times.
+
+2011-04-12  Martin Jambor  <mjambor@suse.cz>
+
+	* objc-act.c (mark_referenced_methods): Call cgraph_get_create_node
+	instead of cgraph_node.
+
+2011-04-06  Joseph Myers  <joseph@codesourcery.com>
+
+	* objc-act.c: Include c-target.h instead of target.h.
+	* Make-lang.in (objc/objc-act.o): Update dependencies.
+
+2011-03-06  Joseph Myers  <joseph@codesourcery.com>
+
+	* lang-specs.h: Match -save-temps* instead of -save-temps.
+
+2011-02-26  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_v2_encode_prop_attr): Rewritten.
+
+2011-02-23  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <mikestump@comcast.net>
+
+	* Make-lang.in (check_objc_parallelize): Refine for 4 processor
+	machines.
+
+2011-02-20  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* objc-next-runtime-abi-01.c: Updated comments.
+	* objc-next-runtime-abi-02.c: Same.
+
+2011-01-19  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_init, generate_struct_by_value_array): Updated
+	comments.
+
+2011-01-19  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <iains@gcc.gnu.org>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <bje@au.ibm.com>
+
+	PR 19162
+	* objc-act.c (generate_struct_by_value_array): Do not output a
+	definition for struct_forward_array.
+
+2011-01-08  Iain Sandoe  <iains@gcc.gnu.org>
+
+	* objc-act.c (objc_finish_foreach_loop): Mark collection expression
+	as read.
+
+2011-01-02  H.J. Lu  <hongjiu.lu@intel.com>
+
+	* objc-act.c (check_that_protocol_is_defined): Fix a typo.
+
+2011-01-02  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (check_that_protocol_is_defined): New.
+	(lookup_protocol): Call check_that_protocol_is_defined.
+
+2010-12-30  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* config-lang.in (gtfiles): Added c-family/c-cppbuiltin.c.
+
+2010-12-22  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* objc-act.c (next_sjlj_build_enter_and_setjmp): Use prototype_p.
+
+2010-12-18  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <iains@gcc.gnu.org>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_finish_foreach_loop): Mark the
+	object_expression as used.
+
+2010-12-06  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	* lang-specs.h: Don't handle -ftraditional.
+
+2010-12-02  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+	    Mike Stump  <mikestump@comcast.net>
+
+	Allow 'make check-objc -j2'
+	* Make-lang.in (lang_checks_parallelized): New.
+	(check_objc_parallelize): New.
+
+2010-11-29  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_maybe_build_component_ref): Removed TODO.
+
+2010-11-29  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <joseph@codesourcery.com>
+
+	* objc-act.c (write_symbols): Don't declare here.
+
+2010-11-22  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	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  <jakub@redhat.com>
+
+	PR c/46547
+	* objc-act.c (in_late_binary_op): Remove.
+
+2010-11-19  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	* objc-act.c (objc_init): Use %' in diagnostic.
+	(objc_set_method_opt): Remove trailing '.' from diagnostic.
+
+2010-11-10  Joseph Myers  <joseph@codesourcery.com>
+
+	* objc-act.c (dump_base_name): Don't declare here.
+
+2010-11-08  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <iains@gcc.gnu.org>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <iains@gcc.gnu.org>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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 <fjahanian@apple.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (lookup_and_install_protocols): Return NULL if passed
+	error_mark_node.
+
+2010-10-18  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2006-03-10  Fariborz Jahanian <fjahanian@apple.com>
+
+        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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-11-08  Fariborz Jahanian <fjahanian@apple.com>
+
+	Radar 4330422
+	* objc/objc-act.c (objc_non_volatilized_type): New
+
+	2005-10-07  Fariborz Jahanian <fjahanian@apple.com>
+
+        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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2006-03-27 Fariborz Jahanian <fjahanian@apple.com>
+
+	Radar 4133425
+	* objc-act.c (objc_diagnose_private_ivar): New.
+
+2010-10-17  Iain Sandoe  <iains@gcc.gnu.org>
+
+	* 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  <iains@gcc.gnu.org>
+
+	merge from FSF apple 'trunk' branch.
+	2006 Fariborz Jahanian <fjahanian@apple.com>
+
+	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  <rth@redhat.com>
+
+	* objc-act.c (objc_eh_personality): Update call to
+	build_personality_function.
+
+2010-10-13  Iain Sandoe  <iains@gcc.gnu.org>
+
+	merge from FSF apple 'trunk' branch.
+
+	2006-04-26 Fariborz Jahanian <fjahanian@apple.com>
+	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  <ak@linux.intel.com>
+
+	* Make-lang.in (cc1obj-dummy): Remove.
+	(cc1obj-checksum): Change to run checksum over object files
+        and options only.
+
+2010-10-07  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	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  <iains@gcc.gnu.org>
+
+	* 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  <iains@gcc.gnu.org>
+
+	* objc-act.c (objc_build_message_expr):  Call mark_exp_read () to
+	signal that the receiver has been used.
+
+2010-10-06  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* README: Obsolete file removed.
+
+2010-10-06  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	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 <fjahanian@apple.com>
+
+        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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-10-17  Fariborz Jahanian <fjahanian@apple.com>
+
+        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 <ak@linux.intel.com>
+
+	* Make-lang.in (cc1obj-dummy, cc1obj): Add + to build rule.
+
+2010-09-30  Iain Sandoe  <iains@gcc.gnu.org>
+
+	merge from FSF 'apple/trunk' branch.
+	2006-01-30  Fariborz Jahanian <fjahanian@apple.com>
+
+       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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-10-04  Fariborz Jahanian <fjahanian@apple.com>
+
+	Radar 4278236
+	* objc-act.c (objc_declare_class): Pick the right
+	type tree.
+
+2010-09-29  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-10-04  Fariborz Jahanian <fjahanian@apple.com>
+
+	Radar 4281748
+	* objc-act.c (objc_check_global_decl): New
+
+2010-09-29  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (objc_is_reserved_word): Removed.
+
+2010-09-28  Iain Sandoe  <iains@gcc.gnu.org>
+
+	* 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  <rth@redhat.com>
+
+	* objc-act.c (objc_eh_personality): Use targetm.except_unwind_info.
+
+2010-09-28  Iain Sandoe  <iains@gcc.gnu.org>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-08-23  Stuart Hastings <stuart@apple.com>
+	            Ziemowit Laski  <zlaski@apple.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c (encode_type): Fixed encoding enums with the next
+	runtime.
+
+2010-09-28  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-07-18  Ziemowit Laski  <zlaski@apple.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	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 <fjahanian@apple.com>
+
+        Radar 4301047
+
+	* objc-act.c (encode_type): Remove the hack.
+
+	2005-07-20  Ziemowit Laski  <zlaski@apple.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2005-12-15  Fariborz Jahanian <fjahanian@apple.com>
+
+	Radar 4229905
+	* objc-act.c (objc_have_common_types): New function.
+
+	2005-06-22  Ziemowit Laski  <zlaski@apple.com>
+
+	Radar 4154928
+	* objc-act.c (objc_common_type): New function.
+
+2010-09-27  Richard Guenther  <rguenther@suse.de>
+
+	* 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  <nicola.pero@meta-innovation.com>
+
+	* objc-act.c: Removed historical, obsolete comment at the top of
+	the file.
+
+2010-09-21  Nicola Pero  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	Merge from 'apple/trunk' branch on FSF servers.
+
+	2006-03-09 Fariborz Jahanian <fjahanian@apple.com>
+
+        Radar 4457381
+	* objc/objc-act.c (objc_finish_message_expr): Look for message in
+	@class's protocol list.
+
+	2006-02-07  Fariborz Jahanian <fjahanian@apple.com>
+
+	Radar 4219590
+	* objc/objc-act.c (objc_start_method_definition): Initialize
+	break/continue labels.
+
+	2005-08-22  Ziemowit Laski  <zlaski@apple.com>
+
+	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  <zlaski@apple.com>
+
+	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  <nicola.pero@meta-innovation.com>
+
+	* 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  <froydnj@codesourcery.com>
+
+	* objc-act.c: Carefully replace TREE_CHAIN with DECL_CHAIN.
+
+2010-07-10  Iain Sandoe  <iains@gcc.gnu.org>
+
+	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  <froydnj@codesourcery.com>
+
+	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  <steven@gcc.gnu.org>
+
+	* objc-act.c: Do not include except.h.
+
+2010-06-08  Laurynas Biveinis  <laurynas.biveinis@gmail.com>
+
+	* 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  <steven@gcc.gnu.org>
+
+	* 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  <froydnj@codesourcery.com>
+
+	* objc-act.c (build_next_objc_exception_stuff): Give setjmp a
+	varargs type instead of a zero-argument type.
+
+2010-05-30  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	* 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  <steven@gcc.gnu.org>
+
+	* 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  <froydnj@codesourcery.com>
+
+	* objc-act.c (objc_build_constructor): Adjust OBJCPLUS impedance
+	mismatch code for VECs.
+
+2010-05-25  Nathan Froyd  <froydnj@codesourcery.com>
+
+	* 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  <iains@gcc.gnu.org>
+
+	PR objc++/32052
+	* objc-act.c (encode_aggregate_within): Encode structure tags
+	with template args for ObjC++.
+
+2010-04-30  Steven Bosscher  <steven@gcc.gnu.org>
+
+	* objc-act.c: Do not include varray.h.
+
+2010-04-07  Jakub Jelinek  <jakub@redhat.com>
+
+	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 <iains@gcc.gnu.org>
+
+	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 <iains@gcc.gnu.org>
+
+	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 <iain.sandoe@sandoe-acoustics.co.uk>
+	    Mike Stump  <mikestump@comcast.net>
+
+	PR objc/43061
+	* objc-act.c (finish_var_decl): Set the generated symbols as "used".
+
+2009-12-17  Shujing Zhao  <pearly.zhao@oracle.com>
+
+	* objc-act.c (objc_substitute_decl, build_ivar_reference,
+	get_super_receiver): Update build_indirect_ref calls.
+
+2009-11-28  Jakub Jelinek  <jakub@redhat.com>
+
+	* 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  <jh@suse.cz>
+
+	* objc-act.c (objc_add_static_instance): Do not set DECL_COMMON.
+
+2009-09-14  Richard Henderson  <rth@redhat.com>
+
+	* 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  <rguenther@suse.de>
+	Rafael Avila de Espindola  <espindola@google.com>
+
+	* 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  <dnovillo@google.com>
+
+	* objc-lang.c (lang_hooks): Remove const qualifier.
+
+2009-08-20  Richard Guenther  <rguenther@suse.de>
+
+	* objc-act.c: Include c-lang.h
+	* Make-lang.in (objc/objc-act.o): Add c-lang.h dependency.
+
+2009-07-17  Aldy Hernandez  <aldyh@redhat.com>
+	    Manuel López-Ibáñez  <manu@gcc.gnu.org>
+
+	PR 40435
+	* objc-act.c: Add location argument to all calls to
+	build_fold_addr_expr.
+
+2009-07-14  Taras Glek  <tglek@mozilla.com>
+	    Rafael Espindola  <espindola@google.com>
+
+	* Make-lang.in (objc.install-plugin): New target for
+	installing plugin headers.
+
+2009-07-07  Manuel López-Ibáñez  <manu@gcc.gnu.org>
+
+	* objc-act.c (next_sjlj_build_catch_list): Replace EXPR_LOCUS by
+	EXPR_LOCATION.
+
+2009-07-07  Manuel López-Ibáñez  <manu@gcc.gnu.org>
+
+	* objc-act.c: Replace %J by an explicit location. Update all
+	calls.
+
+2009-07-07  Manuel López-Ibáñez  <manu@gcc.gnu.org>
+
+	* objc-act.c: Replace %H by an explicit location. Update all
+	calls.
+
+2009-06-22  Steven Bosscher  <steven@gcc.gnu.org>
+
+	PR objc/28050
+	* objc-act.c (objc_build_message_args): Return if ARGS is the
+	error_mark_node.
+
+2009-06-19  Ian Lance Taylor  <iant@google.com>
+
+	* 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  <iant@google.com>
+
+	* objc-act.c (objc_start_function): Don't set
+	label_context_stack_se or label_context_stack_vm.
+
+2009-06-12  Aldy Hernandez  <aldyh@redhat.com>
+
+	* 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  <iant@google.com>
+
+	* objc-act.c (objc_gimplify_expr): Change return type to int.
+	* objc-act.h: Update declaration.
+
+2009-06-08  Alexandre Oliva  <aoliva@redhat.com>
+
+	* objc-act.c (objc_init): Skip print_struct_values during
+	-fcompare-debug-second.
+
+2009-06-03  Ian Lance Taylor  <iant@google.com>
+
+	* Make-lang.in (cc1obj-checksum.o): Depend upon $(CONFIG_H) and
+	$(SYSTEM_H).
+
+2009-05-27  Ian Lance Taylor  <iant@google.com>
+
+	* Make-lang.in (cc1obj-dummy$(exeext)): Change $(COMPILER) to
+	$(LINKER).
+	(cc1obj$(exeext)): Likewise.
+
+2009-05-26  Ian Lance Taylor  <iant@google.com>
+
+	* Make-lang.in (cc1obj-dummy$(exeext)): Use $(COMPILER).
+	(cc1obj$(exeext)): Likewise.
+
+2009-05-20  Ian Lance Taylor  <iant@google.com>
+
+	* 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  <iant@google.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	* 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  <iant@google.com>
+
+	* objc-act.c (objc_gimplify_expr): Add casts to enum type.
+
+2009-04-24  Ian Lance Taylor  <iant@google.com>
+
+	* objc-act.c (get_super_receiver): Update calls to
+	build_modify_expr to pass new argument.
+
+2009-04-21  Taras Glek <tglek@mozilla.com>
+
+	* objc-act.c: Update GTY annotations to new syntax
+	* objc-act.h: Likewise
+
+2009-04-21  Joseph Myers  <joseph@codesourcery.com>
+
+	* ChangeLog: Add copyright and license notices.
+
+2009-04-20  Ian Lance Taylor  <iant@google.com>
+
+	* objc-act.c (objc_rewrite_function_call): Change parameter from
+	params to first_param.  Change all callers.
+
+2009-03-30  Dominique d'Humieres  <dominiq@lps.ens.fr>
+
+	PR bootstrap/39583
+	* objc-act.c (in_late_binary_op): Define for Objective-C++.
+
+2009-03-29  Joseph Myers  <joseph@codesourcery.com>
+
+	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  <sebastian.pop@amd.com>
+
+	PR bootstrap/38262
+	* Make-lang.in (cc1obj-dummy, cc1obj): Add BACKENDLIBS,
+	remove GMPLIBS.
+
+2008-10-06  Aldy Hernandez  <aldyh@redhat.com>
+
+	* 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  <aldyh@redhat.com>
+
+	* 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  <andrew_pinski@playstation.sony.com>
+
+	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  <jh@suse.cz>
+
+	PR c++/18071
+	* objc/objc-act.c (objc_finish_method_definition): Do not set
+	DECL_INLINE.
+
+2008-09-01  Aldy Hernandez  <aldyh@redhat.com>
+
+	* 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  <rguenther@suse.de>
+
+	Merge from gimple-tuples-branch.
+
+	2008-07-18  Aldy Hernandez  <aldyh@redhat.com>
+
+	* 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  <aldyh@redhat.com>
+
+	* 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  <Ralf.Wildenhues@gmx.de>
+
+	* objc-act.c: Fix comment typos.
+
+2008-07-18  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* 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  <jason@redhat.com>
+
+	PR objc++/36723
+	* objc-act.c (objc_build_constructor): Update C++ tweak.
+
+2007-07-14  Rafael Ávila de Espíndola  <espindola@google.com>
+
+	* objc-act.c (synth_module_prologue): Use TREE_NO_WARNING instead
+	of DECL_IN_SYSTEM_HEADER.
+
+2008-07-11  Ian Lance Taylor  <iant@google.com>
+
+	* 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  <ghazi@caip.rutgers.edu>
+
+	* 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  <tbily@suse.cz>
+
+        * objc-act.c (objc_generate_write_barrier, objc_finish_message_expr):
+        Use CONVERT_EXPR_P.
+
+2008-04-23  Paolo Bonzini  <bonzini@gnu.org>
+
+	* objc-act.c (objc_build_string_object): Don't set TREE_INVARIANT.
+
+2008-04-03  Tom Tromey  <tromey@redhat.com>
+
+	* Make-lang.in (objc_OBJS): New variable.
+
+2008-03-27  Tom Tromey  <tromey@redhat.com>
+
+	* Make-lang.in: Revert automatic dependency patch.
+
+2008-03-27  Douglas Gregor  <doug.gregor@gmail.com>
+
+	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  <pinskia@gmail.com>
+
+	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  <tromey@redhat.com>
+
+	* Make-lang.in (objc_OBJS): New variable.
+	(cc1obj-checksum.o, objc/objc-lang.o, objc/objc-act.o): Remove.
+
+2008-03-21  Andreas Tobler  <a.tobler@schweiz.org>
+
+	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  <tromey@redhat.com>
+
+	* objc-act.c (objc_init): Remove old location code.
+
+2008-02-06  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	PR other/35107
+	* Make-lang.in (cc1obj-dummy, cc1obj): Add $(GMPLIBS).
+
+2007-07-30  Nick Clifton  <nickc@redhat.com>
+
+	* 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  <ghazi@caip.rutgers.edu>
+
+	* objc-act.c (objc_get_callee_fndecl): Constify.
+	* objc-act.h (objc_get_callee_fndecl): Likewise.
+
+2007-07-25  Kaveh R. Ghazi  <ghazi@caip.rutgers.edu>
+
+	* objc-act.c (volatilized_hash, volatilized_eq, string_hash,
+	string_eq): Constify.
+
+2007-04-04  Stuart Hastings  <stuart@apple.com>
+
+	PR 31281
+	* objc/objc-act.c (next_sjlj_build_catch_list): Delete volatile from rethrow decl.
+
+2007-03-01  Brooks Moses  <brooks.moses@codesourcery.com>
+
+	* Make-lang.in: Add dummy lang.install-pdf target.
+
+2007-02-18  Kazu Hirata  <kazu@codesourcery.com>
+
+	* objc/objc-act.c: Fix comment typos.
+
+2007-02-15  Sandra Loosemore  <sandra@codesourcery.com>
+	    Brooks Moses  <brooks.moses@codesourcery.com>
+	    Lee Millward  <lee.millward@codesourcery.com>
+
+	* objc-act.c (receiver_is_class_object): Use new CALL_EXPR accessors.
+	(objc_get_callee_fndecl): Likewise.
+
+2007-01-23  Andrew Pinski  <pinskia@gmail.com>
+
+	PR objc/27438
+	* objc-act.c (objc_add_static_instance): Mark the decl as
+	TREE_USED.
+
+2007-01-20  Andrew Pinski  <pinskia@gmail.com>
+
+	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  <doug.gregor@gmail.com>
+
+	* objc-act.c (objc_build_volatilized_type): Keep track of
+	canonical types.
+	(objc_get_protocol_qualified_type): Ditto.
+
+2006-11-02  Andreas Tobler  <a.tobler@schweiz.org>
+
+	* 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  <rafael.espindola@gmail.com>
+
+	* 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  <bmoses@stanford.edu>
+
+	* Make-lang.in: Added empty "objc.pdf" target.
+
+2006-09-26  Andrew Pinski  <pinskia@physics.uc.edu>
+
+	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  <echristo@apple.com>
+
+	* objc-act.c (JBLEN): Rename to OBJC_JBLEN,
+	default to something innocuous.
+	(build_next_objc_exception_stuff): Rename JBLEN.
+
+2006-07-28  Volker Reichelt  <reichelt@igpm.rwth-aachen.de>
+
+	* Make-lang.in: Use $(HEADER_H) instead of header.h in dependencies.
+
+2006-07-19  Volker Reichelt  <reichelt@igpm.rwth-aachen.de>
+
+	PR obj-c++/28434
+	* objc-act.c (lookup_and_install_protocols): Skip error_mark_nodes.
+
+2006-06-06  Mike Stump  <mrs@apple.com>
+
+	* objc-act.c: Remove prototype for objc_build_volatilized_type.
+
+2006-05-24  Mike Stump  <mrs@apple.com>
+
+	* objc-act.c (build_next_objc_exception_stuff): Use JBLEN instead of _JBLEN.
+
+2006-05-05  Volker Reichelt  <reichelt@igpm.rwth-aachen.de>
+
+	PR objc/27240
+	* objc-act.c (objc_is_public): Return early on invalid type.
+
+2006-03-02 Fariborz Jahanian <fjahanian@apple.com>
+
+	* 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 <rafael.espindola@gmail.com>
+	* Make-lang.in (OBJC): Remove
+	(OBJECTIVE-C): Remove
+	(objective-c): Remove
+	(.PHONY): Remove objective-c and ObjC
+
+2005-12-14  Andrew Pinski  <pinskia@physics.uc.edu>
+
+	PR objc/25360
+	* objc/objc-act.c (encode_type): Encode Complex types as 'j' followed
+	by the inner type.
+
+2005-12-12  Andrew Pinski  <pinskia@physics.uc.edu>
+
+	PR objc/25348
+	* objc-act.c (encode_array): Handle arrays to zero sized types.
+
+2005-12-07  Rafael Ávila de Espíndola  <rafael.espindola@gmail.com>
+
+	* Make-lang.in (objc.all.build, objc.install-normal): Remove.
+
+2005-12-07  Rafael Ávila de Espíndola  <rafael.espindola@gmail.com>
+
+	* Make-lang.in: Remove all dependencies on s-gtype.
+
+2005-12-02  Richard Guenther  <rguenther@suse.de>
+
+	* 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  <geoffk@apple.com>
+
+	* objc-act.c (synth_module_prologue): Clear TREE_NOTHROW
+	on objc_msgSend and like builtin functions.
+
+2005-10-17  Andreas Krebbel  <krebbel1@de.ibm.com>
+
+	* 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  <pinskia@physics.uc.edu>
+
+	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  <pinskia@physics.uc.edu>
+
+	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  <pinskia@physics.uc.edu>
+
+	part of PR objc/21992
+	* objc-act.c (handle_class_ref): The ref decl is always referenced.
+
+2005-07-20  Giovanni Bajo  <giovannibajo@libero.it>
+
+	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  <dberlin@dberlin.org>
+
+	* 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  <zlaski@apple.com>
+
+	* 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  <zlaski@apple.com>
+
+	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  <kazu@codesourcery.com>
+
+	* Make-lang.in (cc1plus-checksum.c): Use
+	build/genchecksum$(build_exeext), not build/genchecksum$(exeext).
+
+2005-07-02  Joseph S. Myers  <joseph@codesourcery.com>
+
+	* objc-act.c: Use %q to quote in diagnostics.
+
+2005-07-02  Joseph S. Myers  <joseph@codesourcery.com>
+
+	* objc-act.c: Use '+' flag instead of %J.  Use 'q' flag for
+	quoting.
+
+2005-06-30  Ziemowit Laski  <zlaski@apple.com>
+
+	* 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  <zlaski@apple.com>
+
+	* 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  <paul@codesourcery.com>
+
+	* objc-act.c (objc_init_exceptions): Call
+	default_init_unwind_resume_libfunc.
+
+2005-06-27  Ziemowit Laski  <zlaski@apple.com>
+
+	* 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  <kcook@gcc.gnu.org>
+
+	* all files: Update FSF address in copyright headers.
+
+2005-06-15  Joseph S. Myers  <joseph@codesourcery.com>
+
+	* 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  <mrs@mrs.kithrup.com>
+
+	* objc-act.c (volatilized_hash): Avoid warnings on 64-bit
+	machines.
+
+2005-05-24  Ziemowit Laski  <zlaski@apple.com>
+
+	* 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  <geoffk@apple.com>
+
+	* Make-lang.in (cc1obj-dummy): New.
+	(cc1obj-checksum.c): New.
+	(cc1obj-checksum.o): New.
+	(cc1obj): Add cc1obj-checksum.o.
+
+2005-05-18  Mike Stump  <mrs@apple.com>
+
+	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  <zlaski@apple.com>
+	    Mike Stump  <mrs@apple.com>
+
+	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  <dj@redhat.com>
+
+	* objc-act.c: Adjust warning() callers.
+
+2005-04-21  Roger Sayle  <roger@eyesopen.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	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  <joseph@codesourcery.com>
+
+	PR c/772
+	PR c/17913
+	* objc-act.c (objc_start_function): Push context on
+	label_context_stack.
+
+2005-03-23  Joseph S. Myers  <joseph@codesourcery.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	* 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  <kazu@cs.umass.edu>
+
+	* lang-specs.h, objc-act.c, objc-act.h, objc-lang.c: Update
+	copyright.
+
+2005-01-27  Matt Austern  <austern@apple.com>
+
+	* objc-act.c (objc_finish_file): In ObjC++ mode, set at_eof before
+	calling instantiate_pending_templates.
+
+2005-01-26  Alexander Malmberg  <alexander@malmberg.org>
+
+	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  <alexander@malmberg.org>
+
+	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  <zlaski@apple.com>
+
+	* objc-act.c (objc_push_parm): Call c_type_promotes_to()
+	via a lang-hook.
+
+2005-01-15  Ziemowit Laski  <zlaski@apple.com>
+
+	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  <mrs@apple.com>
+
+	* lang-specs.h ("@objective-c"): Use cc1obj when -E is used so
+	that -fobjc-exceptions is accepted.
+
+2004-12-30  Ziemowit Laski  <zlaski@apple.com>
+
+	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  <zlaski@apple.com>
+
+	* 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  <joseph@codesourcery.com>
+
+	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  <pinskia@physics.uc.edu>
+
+	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  <joseph@codesourcery.com>
+
+	* objc-act.c: Use %q, %< and %> for quoting in diagnostics.
+
+2004-11-08  Andrew Pinski  <pinskia@physics.uc.edu>
+
+	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  <zlaski@apple.com>
+
+	* 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  <zlaski@apple.com>
+
+	* objc-act.c (finish_class): Do not synthesize bogus
+	'extern objc_object *_Foo;' declarations for @interface Foo.
+
+2004-10-25  Ziemowit Laski  <zlaski@apple.com>
+	    David Ayers  <d.ayers@inode.at>
+
+	* objc-act.c (objc_comptypes): Use IS_PROTOCOL_QUALIFIED_UNTYPED
+	instead of IS_PROTOCOL_QUALIFIED_ID; add comparisons for:
+	'Class <Protocol> != id <Protocol>'; 'Class <Protocol> != <class> *';
+	'Class <Protocol> == id' and 'Class <Protocol> == Class'.
+	(objc_is_id): Add test for 'super'.
+	(objc_finish_message_expr): Allow for messaging of 'Class <Proto>'
+	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 <Proto>', 'Class <Proto>' 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 <Proto>' in
+	addition to 'id <Proto>'.
+
+2004-10-21  Andrew Pinski  <pinskia@physics.uc.edu>
+
+	PR objc/17923
+	* objc-act.c (objc_build_string_object): Create a CONST_DECL
+	for the NeXT runtime case.
+
+2004-10-02  Kazu Hirata  <kazu@cs.umass.edu>
+
+	* objc-act.c: Fix comment typos.
+
+2004-09-24  Ziemowit Laski  <zlaski@apple.com>
+
+	* 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  <zack@codesourcery.com>
+
+	* 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  <zlaski@apple.com>
+
+	* 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  <jsm@polyomino.org.uk>
+
+	* 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  <zlaski@apple.com>
+
+	* 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  <zlaski@apple.com>
+
+	* config-lang.in: Update copyright notice.
+	(lang_requires): Indicate that ObjC requires C to be built first.
+
+2004-09-01  Ziemowit Laski  <zlaski@apple.com>
+
+	* 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  <zlaski@apple.com>
+
+	* 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  <zlaski@apple.com>
+
+	* objc-act.c (objc_is_reserved_word): New function.
+
+2004-08-15  Ziemowit Laski  <zlaski@apple.com>
+
+	* 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-2014 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-4.9/gcc/objc/Make-lang.in b/gcc-4.9/gcc/objc/Make-lang.in
new file mode 100644
index 000000000..cd1fdb628
--- /dev/null
+++ b/gcc-4.9/gcc/objc/Make-lang.in
@@ -0,0 +1,138 @@
+# Top level -*- makefile -*- fragment for GNU Objective-C
+#   Copyright (C) 1997-2014 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
+# <http://www.gnu.org/licenses/>.
+
+
+# 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
+
+# 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 hash-table.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/objc-encoding.o \
+   objc/objc-map.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$(exeext): $(OBJC_OBJS) $(C_AND_OBJC_OBJS) cc1obj-checksum.o $(BACKEND) $(LIBDEPS)
+	+$(LLINKER) $(ALL_LINKERFLAGS) $(LDFLAGS) -o $@ \
+	      $(OBJC_OBJS) $(C_AND_OBJC_OBJS) cc1obj-checksum.o \
+	      $(BACKEND) $(LIBS) $(BACKENDLIBS)
+
+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-4.9/gcc/objc/config-lang.in b/gcc-4.9/gcc/objc/config-lang.in
new file mode 100644
index 000000000..4acbb60ed
--- /dev/null
+++ b/gcc-4.9/gcc/objc/config-lang.in
@@ -0,0 +1,38 @@
+# Top level configure fragment for GNU Objective-C
+#   Copyright (C) 1997-2014 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
+# <http://www.gnu.org/licenses/>.
+
+# 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)/objc/objc-map.h \$(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/c-parser.c \$(srcdir)/c/c-tree.h \$(srcdir)/c/c-decl.c \$(srcdir)/c/c-lang.h \$(srcdir)/c/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-4.9/gcc/objc/lang-specs.h b/gcc-4.9/gcc/objc/lang-specs.h
new file mode 100644
index 000000000..a3c9a54fc
--- /dev/null
+++ b/gcc-4.9/gcc/objc/lang-specs.h
@@ -0,0 +1,57 @@
+/* Definitions for specs for Objective-C.
+   Copyright (C) 1998-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+
+/* 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-4.9/gcc/objc/objc-act.c b/gcc-4.9/gcc/objc/objc-act.c
new file mode 100644
index 000000000..cb0b5ac6a
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-act.c
@@ -0,0 +1,10099 @@
+/* Implement classes and message passing for Objective C.
+   Copyright (C) 1992-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "stringpool.h"
+#include "stor-layout.h"
+#include "attribs.h"
+
+#ifdef OBJCPLUS
+#include "cp/cp-tree.h"
+#else
+#include "c/c-tree.h"
+#include "c/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 "objc-map.h"
+#include "input.h"
+#include "function.h"
+#include "toplev.h"
+#include "debug.h"
+#include "c-family/c-target.h"
+#include "diagnostic-core.h"
+#include "intl.h"
+#include "cgraph.h"
+#include "tree-iterator.h"
+#include "hash-table.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-expr.h"
+#include "gimplify.h"
+
+/* For encode_method_prototype().  */
+#include "objc-encoding.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
+
+/*** 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, 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 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);
+
+static void hash_init (void);
+
+/* Hash tables to manage the global pool of method prototypes.  Each
+   of these maps map a method name (selector) identifier to either a
+   single tree (for methods with a single method prototype) or a
+   TREE_VEC (for methods with multiple method prototypes).  */
+static GTY(()) objc_map_t instance_method_map = 0;
+static GTY(()) objc_map_t class_method_map = 0;
+
+/* Hash tables to manage the global pool of class names.  */
+
+static GTY(()) objc_map_t class_name_map = 0;
+static GTY(()) objc_map_t alias_name_map = 0;
+
+static tree lookup_method (tree, tree);
+static tree lookup_method_static (tree, tree, int);
+
+static void interface_hash_init (void);
+static tree add_interface (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);
+
+#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 (tree, 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, va_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;
+
+/* 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);
+  interface_hash_init ();
+  hash_init ();
+  objc_encoding_init ();
+  /* ... 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)
+    {
+      objc_map_iterator_t i;
+
+      objc_map_iterator_initialize (class_method_map, &i);
+      while (objc_map_iterator_move_to_next (class_method_map, &i))
+	check_duplicates (objc_map_iterator_current_value (class_method_map, i), 0, 1);
+
+      objc_map_iterator_initialize (instance_method_map, &i);
+      while (objc_map_iterator_move_to_next (instance_method_map, &i))
+	check_duplicates (objc_map_iterator_current_value (instance_method_map, i), 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, "%<readonly%> attribute conflicts with %<readwrite%> 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, "%<readonly%> attribute conflicts with %<setter%> attribute");
+      property_readonly = false;
+    }
+
+  if (parsed_property_assign && parsed_property_retain)
+    {
+      error_at (location, "%<assign%> attribute conflicts with %<retain%> attribute");
+      property_assign_semantics = OBJC_PROPERTY_RETAIN;
+    }
+  else if (parsed_property_assign && parsed_property_copy)
+    {
+      error_at (location, "%<assign%> attribute conflicts with %<copy%> attribute");
+      property_assign_semantics = OBJC_PROPERTY_COPY;
+    }
+  else if (parsed_property_retain && parsed_property_copy)
+    {
+      error_at (location, "%<retain%> attribute conflicts with %<copy%> 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 %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>",
+			  decl);
+	      inform (location,
+		      "%<assign%> 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, "%<retain%> 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, "%<copy%> 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 <Protocol>' or 'Class
+	 <Protocol>'; 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 artificial 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).
+   EXPR is NULL or an expression that needs to be evaluated for the
+   side effects of array size expressions in the parameters.
+*/
+bool
+objc_start_method_definition (bool is_class_method, tree decl, tree attributes,
+			      tree expr)
+{
+  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, expr);
+  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> objc_info = vNULL;
+  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 <MyProtocol>').
+     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);
+      objc_info.safe_push (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) = objc_info[i];
+      /* Replace the IDENTIFIER_NODE with an actual @interface now
+	 that we have it.  */
+      TYPE_OBJC_INTERFACE (t) = klass;
+    }
+  objc_info.release ();
+
+  /* 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)
+	vec_alloc (local_variables_to_volatilize, 8);
+
+      vec_safe_push (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 (*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 (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)
+    {
+      function_args_iterator liter, riter;
+
+      /* 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.  */
+      function_args_iter_init (&liter, ltyp);
+      function_args_iter_init (&riter, rtyp);
+
+      while (1)
+	{
+	  ltyp = function_args_iter_cond (&liter);
+	  rtyp = function_args_iter_cond (&riter);
+
+	  /* If we've exhaused both lists simulateously, we're done.  */
+	  if (ltyp == NULL_TREE && rtyp == NULL_TREE)
+	    break;
+
+	  /* If one list is shorter than the other, they fail to match.  */
+	  if (ltyp == NULL_TREE || rtyp == NULL_TREE)
+	    return false;
+
+	  if (!comptypes (rtyp, ltyp)
+	      && !objc_compare_types (rtyp, ltyp, argno, callee))
+	    return false;
+
+	  function_args_iter_next (&liter);
+	  function_args_iter_next (&riter);
+	}
+
+      return true;
+    }
+
+  /* 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;
+      vec_alloc (BINFO_BASE_ACCESSES (binfo), 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 <objc/objc.h> 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 (type);
+  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 (constant_string_id);
+
+  /* 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_list (void_type_node,
+				   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, va_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 (!(*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_loc (UNKNOWN_LOCATION, 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
+      objc_map_put (alias_name_map, alias_ident, underlying_class);
+    }
+}
+
+void
+objc_declare_class (tree identifier)
+{
+#ifdef OBJCPLUS
+  if (current_namespace != global_namespace) {
+    error ("Objective-C declarations may only appear in global scope");
+  }
+#endif /* OBJCPLUS */
+
+  if (! objc_is_class_name (identifier))
+    {
+      tree record = lookup_name (identifier), 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",
+		     identifier);
+	      error ("previous declaration of %q+D",
+		     record);
+	    }
+	}
+
+      record = xref_tag (RECORD_TYPE, identifier);
+      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) = identifier;
+      objc_map_put (class_name_map, identifier, NULL_TREE);
+    }
+}
+
+tree
+objc_is_class_name (tree ident)
+{
+  if (ident && TREE_CODE (ident) == IDENTIFIER_NODE)
+    {
+      tree t = identifier_global_value (ident);
+      if (t)
+	ident = t;
+    }
+
+  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;
+
+  {
+    tree target;
+
+    target = objc_map_get (class_name_map, ident);
+    if (target != OBJC_MAP_NOT_FOUND)
+      return ident;
+
+    target = objc_map_get (alias_name_map, ident);
+    if (target != OBJC_MAP_NOT_FOUND)
+      return target;
+  }
+
+  return 0;
+}
+
+/* Check whether TYPE is either 'id' or 'Class'.  */
+
+tree
+objc_is_id (tree type)
+{
+  if (type && TREE_CODE (type) == IDENTIFIER_NODE)
+    {
+      tree t = identifier_global_value (type);
+      if (t)
+	type = t;
+    }
+
+  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)));
+
+  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));
+
+  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));
+
+  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;
+}
+
+/* Implementation of the table mapping a class name (as an identifier)
+   to a class node.  The two public functions for it are
+   lookup_interface() and add_interface().  add_interface() is only
+   used in this file, so we can make it static.  */
+
+static GTY(()) objc_map_t interface_map;
+
+static void
+interface_hash_init (void)
+{
+  interface_map = objc_map_alloc_ggc (200);  
+}
+
+static tree
+add_interface (tree class_name, tree name)
+{
+  /* Put interfaces on list in reverse order.  */
+  TREE_CHAIN (class_name) = interface_chain;
+  interface_chain = class_name;
+
+  /* Add it to the map.  */
+  objc_map_put (interface_map, name, class_name);
+
+  return interface_chain;
+}
+
+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;
+
+  {
+    tree interface = objc_map_get (interface_map, ident);
+
+    if (interface == OBJC_MAP_NOT_FOUND)
+      return NULL_TREE;
+    else
+      return interface;
+  }
+}
+
+
+
+/* Implement @defs (<classname>) 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;
+}
+
+
+/* Functions used by the hashtable for field duplicates in
+   objc_detect_field_duplicates().  Ideally, we'd use a standard
+   key-value dictionary hashtable , and store as keys the field names,
+   and as values the actual declarations (used to print nice error
+   messages with the locations).  But, the hashtable we are using only
+   allows us to store keys in the hashtable, without values (it looks
+   more like a set).  So, we store the DECLs, but define equality as
+   DECLs having the same name, and hash as the hash of the name.  */
+
+struct decl_name_hash : typed_noop_remove <tree_node>
+{
+  typedef tree_node value_type;
+  typedef tree_node compare_type;
+  static inline hashval_t hash (const value_type *);
+  static inline bool equal (const value_type *, const compare_type *);
+};
+
+inline hashval_t
+decl_name_hash::hash (const value_type *q)
+{
+  return (hashval_t) ((intptr_t)(DECL_NAME (q)) >> 3);
+}
+
+inline bool
+decl_name_hash::equal (const value_type *a, const compare_type *b)
+{
+  return DECL_NAME (a) == DECL_NAME (b);
+}
+
+/* Called when checking the variables in a struct.  If we are not
+   doing the ivars list inside an @interface context, then return
+   false.  Else, perform the check for duplicate ivars, then return
+   true.  The check for duplicates checks if an instance variable with
+   the same name exists in the class or in a superclass.  If
+   'check_superclasses_only' is set to true, then it is assumed that
+   checks for instance variables in the same class has already been
+   performed (this is the case for ObjC++) and only the instance
+   variables of superclasses are checked.  */
+bool
+objc_detect_field_duplicates (bool check_superclasses_only)
+{
+  if (!objc_collecting_ivars || !objc_interface_context
+      || TREE_CODE (objc_interface_context) != CLASS_INTERFACE_TYPE)
+    return false;
+
+  /* We have two ways of doing this check:
+
+  "direct comparison": we iterate over the instance variables and
+  compare them directly.  This works great for small numbers of
+  instance variables (such as 10 or 20), which are extremely common.
+  But it will potentially take forever for the pathological case with
+  a huge number (eg, 10k) of instance variables.
+
+  "hashtable": we use a hashtable, which requires a single sweep
+  through the list of instances variables.  This is much slower for a
+  small number of variables, and we only use it for large numbers.
+
+  To decide which one to use, we need to get an idea of how many
+  instance variables we have to compare.  */
+  {
+    unsigned int number_of_ivars_to_check = 0;
+    {
+      tree ivar;
+      for (ivar = CLASS_RAW_IVARS (objc_interface_context);
+	   ivar; ivar = DECL_CHAIN (ivar))
+	{
+	  /* Ignore anonymous ivars.  */
+	  if (DECL_NAME (ivar))
+	    number_of_ivars_to_check++;
+	}
+    }
+
+    /* Exit if there is nothing to do.  */
+    if (number_of_ivars_to_check == 0)
+      return true;
+
+    /* In case that there are only 1 or 2 instance variables to check,
+       we always use direct comparison.  If there are more, it is
+       worth iterating over the instance variables in the superclass
+       to count how many there are (note that this has the same cost
+       as checking 1 instance variable by direct comparison, which is
+       why we skip this check in the case of 1 or 2 ivars and just do
+       the direct comparison) and then decide if it worth using a
+       hashtable.  */
+    if (number_of_ivars_to_check > 2)
+      {
+	unsigned int number_of_superclass_ivars = 0;
+	{
+	  tree interface;
+	  for (interface = lookup_interface (CLASS_SUPER_NAME (objc_interface_context));
+	       interface; interface = lookup_interface (CLASS_SUPER_NAME (interface)))
+	    {
+	      tree ivar;
+	      for (ivar = CLASS_RAW_IVARS (interface);
+		   ivar; ivar = DECL_CHAIN (ivar))
+		number_of_superclass_ivars++;
+	    }
+	}
+
+	/* We use a hashtable if we have over 10k comparisons.  */
+	if (number_of_ivars_to_check * (number_of_superclass_ivars
+					+ (number_of_ivars_to_check / 2))
+	    > 10000)
+	  {
+	    /* First, build the hashtable by putting all the instance
+	       variables of superclasses in it.  */
+	    hash_table <decl_name_hash> htab;
+	    htab.create (37);
+	    tree interface;
+	    for (interface = lookup_interface (CLASS_SUPER_NAME
+					       (objc_interface_context));
+		 interface; interface = lookup_interface
+		   (CLASS_SUPER_NAME (interface)))
+	      {
+		tree ivar;
+		for (ivar = CLASS_RAW_IVARS (interface); ivar;
+		     ivar = DECL_CHAIN (ivar))
+		  {
+		    if (DECL_NAME (ivar) != NULL_TREE)
+		      {
+			tree_node **slot = htab.find_slot (ivar, INSERT);
+			/* Do not check for duplicate instance
+			   variables in superclasses.  Errors have
+			   already been generated.  */
+			*slot = ivar;
+		      }
+		  }
+	      }
+
+	    /* Now, we go through all the instance variables in the
+	       class, and check that they are not in the
+	       hashtable.  */
+	    if (check_superclasses_only)
+	      {
+		tree ivar;
+		for (ivar = CLASS_RAW_IVARS (objc_interface_context); ivar;
+		     ivar = DECL_CHAIN (ivar))
+		  {
+		    if (DECL_NAME (ivar) != NULL_TREE)
+		      {
+			tree duplicate_ivar = htab.find (ivar);
+			if (duplicate_ivar != HTAB_EMPTY_ENTRY)
+			  {
+			    error_at (DECL_SOURCE_LOCATION (ivar),
+				      "duplicate instance variable %q+D",
+				      ivar);
+			    inform (DECL_SOURCE_LOCATION (duplicate_ivar),
+				    "previous declaration of %q+D",
+				    duplicate_ivar);
+			    /* FIXME: Do we need the following ?  */
+			    /* DECL_NAME (ivar) = NULL_TREE; */
+			  }
+		      }
+		  }
+	      }
+	    else
+	      {
+		/* If we're checking for duplicates in the class as
+		   well, we insert variables in the hashtable as we
+		   check them, so if a duplicate follows, it will be
+		   caught.  */
+		tree ivar;
+		for (ivar = CLASS_RAW_IVARS (objc_interface_context); ivar;
+		     ivar = DECL_CHAIN (ivar))
+		  {
+		    if (DECL_NAME (ivar) != NULL_TREE)
+		      {
+			tree_node **slot = htab.find_slot (ivar, INSERT);
+			if (*slot)
+			  {
+			    tree duplicate_ivar = (tree)(*slot);
+			    error_at (DECL_SOURCE_LOCATION (ivar),
+				      "duplicate instance variable %q+D",
+				      ivar);
+			    inform (DECL_SOURCE_LOCATION (duplicate_ivar),
+				    "previous declaration of %q+D",
+				    duplicate_ivar);
+			    /* FIXME: Do we need the following ?  */
+			    /* DECL_NAME (ivar) = NULL_TREE; */
+			  }
+			*slot = ivar;
+		      }
+		  }
+	      }
+	    htab.dispose ();
+	    return true;
+	  }
+      }
+  }
+
+  /* This is the "direct comparison" approach, which is used in most
+     non-pathological cases.  */
+  {
+    /* Walk up to class hierarchy, starting with this class (this is
+       the external loop, because lookup_interface() is expensive, and
+       we want to do it few times).  */
+    tree interface = objc_interface_context;
+
+    if (check_superclasses_only)
+      interface = lookup_interface (CLASS_SUPER_NAME (interface));
+
+    for ( ; interface; interface = lookup_interface
+	    (CLASS_SUPER_NAME (interface)))
+      {
+	tree ivar_being_checked;
+
+	for (ivar_being_checked = CLASS_RAW_IVARS (objc_interface_context);
+	     ivar_being_checked;
+	     ivar_being_checked = DECL_CHAIN (ivar_being_checked))
+	  {
+	    tree decl;
+
+	    /* Ignore anonymous ivars.  */
+	    if (DECL_NAME (ivar_being_checked) == NULL_TREE)
+	      continue;
+
+	    /* Note how we stop when we find the ivar we are checking
+	       (this can only happen in the main class, not
+	       superclasses), to avoid comparing things twice
+	       (otherwise, for each ivar, you'd compare A to B then B
+	       to A, and get duplicated error messages).  */
+	    for (decl = CLASS_RAW_IVARS (interface);
+		 decl && decl != ivar_being_checked;
+		 decl = DECL_CHAIN (decl))
+	      {
+		if (DECL_NAME (ivar_being_checked) == DECL_NAME (decl))
+		  {
+		    error_at (DECL_SOURCE_LOCATION (ivar_being_checked),
+			      "duplicate instance variable %q+D",
+			      ivar_being_checked);
+		    inform (DECL_SOURCE_LOCATION (decl),
+			    "previous declaration of %q+D",
+			    decl);
+		    /* FIXME: Do we need the following ?  */
+		    /* DECL_NAME (ivar_being_checked) = NULL_TREE; */
+		  }
+	      }
+	  }
+      }
+  }
+  return 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 <classname> {
+     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;
+    }
+}
+
+/* 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, NULL_TREE);
+  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_force_output_node (
+			   cgraph_get_create_node (METHOD_DEFINITION (chain)));
+	  chain = DECL_CHAIN (chain);
+	}
+
+      chain = CLASS_NST_METHODS (impent->imp_context);
+      while (chain)
+	{
+	  cgraph_mark_force_output_node (
+			   cgraph_get_create_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_with_length (buf, len);
+}
+
+/* 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 if (is_attribute_p ("nonnull", name))
+	    {
+	      /* We need to fixup all the argument indexes by adding 2
+		 for the two hidden arguments of an Objective-C method
+		 invocation, similat to what we do above for the
+		 "format" attribute.  */
+	      /* FIXME: This works great in terms of implementing the
+		 functionality, but the warnings that are produced by
+		 nonnull do mention the argument index (while the
+		 format ones don't).  For example, you could get
+		 "warning: null argument where non-null required
+		 (argument 3)".  Now in that message, "argument 3"
+		 includes the 2 hidden arguments; it would be much
+		 more friendly to call it "argument 1", as that would
+		 be consistent with __attribute__ ((nonnnull (1))).
+		 To do this, we'd need to have the C family code that
+		 checks the arguments know about adding/removing 2 to
+		 the argument index ... or alternatively we could
+		 maybe store the "printable" argument index in
+		 addition to the actual argument index ?  Some
+		 refactoring is needed to do this elegantly.  */
+	      tree new_attribute = copy_node (attribute);
+	      tree argument = TREE_VALUE (attribute);
+	      while (argument != NULL_TREE)
+		{
+		  /* Get the value of the argument and add 2.  */
+		  tree number = TREE_VALUE (argument);
+		  if (number
+		      && TREE_CODE (number) == INTEGER_CST
+		      && TREE_INT_CST_HIGH (number) == 0
+		      && TREE_INT_CST_LOW (number) != 0)
+		    {
+		      TREE_VALUE (argument)
+			= build_int_cst (integer_type_node,
+					 TREE_INT_CST_LOW (number) + 2);
+		    }
+		  argument = TREE_CHAIN (argument);
+		}
+
+	      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_for_method (TREE_VALUE (saved_type), *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;
+}
+
+/* Return a function type for METHOD with RETURN_TYPE.  CONTEXT is
+   either METHOD_DEF or METHOD_REF, indicating whether we are defining a
+   method or calling one.  SUPER_FLAG indicates whether this is 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 METHOD is
+   NULL, user-defined arguments (i.e., beyond self and _cmd) shall be
+   represented as varargs.  */
+
+tree
+build_function_type_for_method (tree return_type, tree method,
+				int context, bool super_flag)
+{
+  vec<tree, va_gc> *argtypes = make_tree_vector ();
+  tree t, ftype;
+  bool is_varargs = false;
+
+  (*runtime.get_arg_type_list_base) (&argtypes, method, context, super_flag);
+
+  /* No actual method prototype given; remaining args passed as varargs.  */
+  if (method == NULL_TREE)
+    {
+      is_varargs = true;
+      goto build_ftype;
+    }
+
+  for (t = METHOD_SEL_ARGS (method); t; t = DECL_CHAIN (t))
+    {
+      tree arg_type = TREE_VALUE (TREE_TYPE (t));
+
+      /* Decay argument types for the underlying C function as
+         appropriate.  */
+      arg_type = objc_decay_parm_type (arg_type);
+
+      vec_safe_push (argtypes, arg_type);
+    }
+
+  if (METHOD_ADD_ARGS (method))
+    {
+      for (t = TREE_CHAIN (METHOD_ADD_ARGS (method));
+	   t; t = TREE_CHAIN (t))
+	{
+	  tree arg_type = TREE_TYPE (TREE_VALUE (t));
+
+	  arg_type = objc_decay_parm_type (arg_type);
+
+	  vec_safe_push (argtypes, arg_type);
+	}
+
+      if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
+	is_varargs = true;
+    }
+
+ build_ftype:
+  if (is_varargs)
+    ftype = build_varargs_function_type_vec (return_type, argtypes);
+  else
+    ftype = build_function_type_vec (return_type, argtypes);
+
+  release_tree_vector (argtypes);
+  return ftype;
+}
+
+/* The 'method' argument is a tree; this tree could either be a single
+   method, which is returned, or could be a TREE_VEC containing a list
+   of methods.  In that case, the first one is returned, and warnings
+   are issued as appropriate.  */
+static tree
+check_duplicates (tree method, int methods, int is_class)
+{
+  tree first_method;
+  size_t i;
+
+  if (method == NULL_TREE)
+    return NULL_TREE;
+
+  if (TREE_CODE (method) != TREE_VEC)
+    return method;
+
+  /* We have two or more methods with the same name but different
+     types.  */
+  first_method = TREE_VEC_ELT (method, 0);
+  
+  /* 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 (i = 0; i < (size_t) TREE_VEC_LENGTH (method); i++)
+	if (!comp_proto_with_proto (first_method, TREE_VEC_ELT (method, i), 0))
+	  goto issue_warning;
+      
+      return first_method;
+    }
+    
+ issue_warning:
+  if (methods)
+    {
+      bool type = TREE_CODE (first_method) == INSTANCE_METHOD_DECL;
+      
+      warning_at (input_location, 0,
+		  "multiple methods named %<%c%E%> found",
+		  (is_class ? '+' : '-'),
+		  METHOD_SEL_NAME (first_method));
+      inform (DECL_SOURCE_LOCATION (first_method), "using %<%c%s%>",
+	      (type ? '-' : '+'),
+	      identifier_to_locale (gen_method_decl (first_method)));
+    }
+  else
+    {
+      bool type = TREE_CODE (first_method) == INSTANCE_METHOD_DECL;
+      
+      warning_at (input_location, 0,
+		  "multiple selectors named %<%c%E%> found",
+		  (is_class ? '+' : '-'),
+		  METHOD_SEL_NAME (first_method));
+      inform (DECL_SOURCE_LOCATION (first_method), "found %<%c%s%>",
+	      (type ? '-' : '+'),
+	      identifier_to_locale (gen_method_decl (first_method)));
+    }
+  
+  for (i = 0; i < (size_t) TREE_VEC_LENGTH (method); i++)
+    {
+      bool type = TREE_CODE (TREE_VEC_ELT (method, i)) == INSTANCE_METHOD_DECL;
+      
+      inform (DECL_SOURCE_LOCATION (TREE_VEC_ELT (method, i)), "also found %<%c%s%>",
+	      (type ? '-' : '+'),
+	      identifier_to_locale (gen_method_decl (TREE_VEC_ELT (method, i))));
+    }
+
+  return first_method;
+}
+
+/* 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.
+
+     This is required by the GNU runtime, which compiles
+
+       [NSObject alloc]
+
+     into
+
+       [objc_get_class ("NSObject") alloc];
+
+     and then, to check that the receiver responds to the +alloc
+     method, needs to be able to determine that the objc_get_class()
+     call returns the NSObject class and not just a generic Class
+     pointer.
+
+     But, traditionally this is enabled for all runtimes, not just the
+     GNU one, which means that the compiler is smarter than you'd
+     expect when dealing with objc_getClass().  For example, with the
+     Apple runtime, in the code
+
+       [objc_getClass ("NSObject")  alloc];
+
+     the compiler will recognize the objc_getClass() call as special
+     (due to the code below) and so will know that +alloc is called on
+     the 'NSObject' class, and can perform the corresponding checks.
+
+     Programmers can disable this behaviour by casting the results of
+     objc_getClass() to 'Class' (this may seem weird because
+     objc_getClass() is already declared to return 'Class', but the
+     compiler treats it as a special function).  This may be useful if
+     the class is never declared, and the compiler would complain
+     about a missing @interface for it.  Then, you can do
+
+       [(Class)objc_getClass ("MyClassNeverDeclared")  alloc];
+
+     to silence the warnings.  */
+  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.
+
+   (*(<abstract_decl>(*)())_msg)(receiver, selTransTbl[n], ...);
+   (*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...);  */
+
+tree
+objc_build_message_expr (tree receiver, tree message_args)
+{
+  tree sel_name;
+#ifdef OBJCPLUS
+  tree args = TREE_PURPOSE (message_args);
+#else
+  tree args = message_args;
+#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 (message_args));
+#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_loc (UNKNOWN_LOCATION, 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)
+{
+  tree method_prototype = OBJC_MAP_NOT_FOUND;
+
+  if (!is_class)
+    method_prototype = objc_map_get (instance_method_map, sel_name);
+  
+  if (method_prototype == OBJC_MAP_NOT_FOUND)
+    {
+      method_prototype = objc_map_get (class_method_map, sel_name);
+      is_class = 1;
+
+      if (method_prototype == OBJC_MAP_NOT_FOUND)
+	return NULL_TREE;
+    }
+
+  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 is 1 if this is a message to self, 0 otherwise  */
+  self = (rtype == self_decl);
+
+  /* super is 1 if this is a message to super, 0 otherwise.  */
+  super = (rtype == UOBJC_SUPER_decl);
+
+  /* rtype is the type of the receiver.  */
+  rtype = TREE_TYPE (receiver);
+
+  /* have_cast is 1 if the receiver is casted.  */
+  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 is the class name
+     identifier, or NULL_TREE if this is not a class method or the
+     class name could not be determined (as in the case "Class c; [c
+     method];").  */
+  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)
+	{
+	  /* We are here when we have no cast, and we have a class
+	     name.  So, this is a plain method to a class object, as
+	     in [NSObject alloc].  Find the interface corresponding to
+	     the class name.  */
+	  rtype = lookup_interface (class_tree);
+
+	  if (rtype == NULL_TREE)
+	    {
+	      /* If 'rtype' is NULL_TREE at this point it means that
+		 we have seen no @interface corresponding to that
+		 class name, only a @class declaration (alternatively,
+		 this was a call such as [objc_getClass("SomeClass")
+		 alloc], where we've never seen the @interface of
+		 SomeClass).  So, we have a class name (class_tree)
+		 but no actual details of the class methods.  We won't
+		 be able to check that the class responds to the
+		 method, and we will have to guess the method
+		 prototype.  Emit a warning, then keep going (this
+		 will use any method with a matching name, as if the
+		 receiver was of type 'Class').  */
+	      warning (0, "@interface of class %qE not found", 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 (objc_is_id (rtype))
+    {
+      /* The receiver is of type 'id' or 'Class' (with or without some
+	 protocols attached to it).  */
+
+      /* We set class_tree to the identifier for 'Class' if this is a
+	 class method, and to NULL_TREE if not.  */
+      class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE);
+      
+      /* 'rprotos' is the list of protocols that the receiver
+	 supports.  */
+      rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
+		 ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
+		 : NULL_TREE);
+
+      /* We have no information on the type, and we set it to
+	 NULL_TREE.  */
+      rtype = NULL_TREE;
+
+      /* If there are any protocols, check that the method we are
+	 calling appears in the protocol list.  If there are no
+	 protocols, this is a message to 'id' or 'Class' and we accept
+	 any method that exists.  */
+      if (rprotos)
+	{
+	  /* If messaging 'id <Protos>' or 'Class <Proto>', 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 <Proto>' 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)
+    {
+      /* We have a receiver type which is more specific than 'id' or
+	 'Class'.  */
+      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 (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
+	{
+	  /* 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.  Note that this only happens
+	     for instance methods; for class methods to a class where
+	     we have only seen a @class declaration,
+	     lookup_interface() above would have set rtype to
+	     NULL_TREE.  */
+	  if (rprotos)
+	    {
+	      /* We could not find an @interface declaration, yet, if
+		 there are protocols attached to the type, we can
+		 still look up the method in the protocols.  Ie, we
+		 are in the following case:
+	     
+		 @class MyClass;
+		 MyClass<MyProtocol> *x;
+		 [x method];
+		 
+		 If 'MyProtocol' has the method 'method', we can check
+		 and retrieve the method prototype.  */
+	      method_prototype
+		= lookup_method_in_protocol_list (rprotos, sel_name, 0);
+
+	      /* At this point, if we have found the method_prototype,
+		 we are quite happy.  The details of the class are
+		 irrelevant.  If we haven't found it, a warning will
+		 have been produced that the method could not be found
+		 in the protocol, and we won't produce further
+		 warnings (please note that this means that "@class
+		 MyClass; MyClass <MyProtocol> *x;" is exactly
+		 equivalent to "id <MyProtocol> x", which isn't too
+		 satisfactory but it's not easy to see how to do
+		 better).  */
+	    }
+	  else
+	    {
+	      if (rtype)
+		{
+		  /* We could not find an @interface declaration, and
+		     there are no protocols attached to the receiver,
+		     so we can't complete the check that the receiver
+		     responds to the method, and we can't retrieve the
+		     method prototype.  But, because the receiver has
+		     a well-specified class, the programmer did want
+		     this check to be performed.  Emit a warning, then
+		     keep going as if it was an 'id'.  To remove the
+		     warning, either include an @interface for the
+		     class, or cast the receiver to 'id'.  Note that
+		     rtype is an IDENTIFIER_NODE at this point.  */
+		  warning (0, "@interface of class %qE not found", rtype);
+		}
+	    }
+
+	  rtype = NULL_TREE;
+	}
+      else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
+	  || TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
+	{
+	  /* We have a valid ObjC class name with an associated
+	     @interface.  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
+	{
+	  /* We have a type, but it's not an Objective-C type (!).  */
+	  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;
+	}
+    }
+  /* Note that rtype could also be NULL_TREE.  This happens if we are
+     messaging a class by name, but the class was only
+     forward-declared using @class.  */
+
+  /* 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 %<id%> 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.  */
+      tree method;
+
+      /* First try with instance methods.  */
+      method = objc_map_get (instance_method_map, selname);
+
+      /* If not found, try with class methods.  */
+      if (method == OBJC_MAP_NOT_FOUND)
+	{
+	  method = objc_map_get (class_method_map, selname);
+
+	  /* If still not found, print out a warning.  */
+	  if (method == OBJC_MAP_NOT_FOUND)
+	    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);
+}
+
+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);
+}
+
+static void
+hash_init (void)
+{
+  instance_method_map = objc_map_alloc_ggc (1000);
+  class_method_map = objc_map_alloc_ggc (1000);
+
+  class_name_map = objc_map_alloc_ggc (200);
+  alias_name_map = objc_map_alloc_ggc (200);
+
+  /* Initialize the hash table used to hold the constant string objects.  */
+  string_htab = htab_create_ggc (31, string_hash,
+				   string_eq, NULL);
+}
+
+/* Use the following to add a method to class_method_map or
+   instance_method_map.  It will add the method, keyed by the
+   METHOD_SEL_NAME.  If the method already exists, but with one or
+   more different prototypes, it will store a TREE_VEC in the map,
+   with the method prototypes in the vector.  */
+static void
+insert_method_into_method_map (bool class_method, tree method)
+{
+  tree method_name = METHOD_SEL_NAME (method);
+  tree existing_entry;
+  objc_map_t map;
+
+  if (class_method)
+    map = class_method_map;
+  else
+    map = instance_method_map;
+
+  /* Check if the method already exists in the map.  */
+  existing_entry = objc_map_get (map, method_name);
+
+  /* If not, we simply add it to the map.  */
+  if (existing_entry == OBJC_MAP_NOT_FOUND)
+    objc_map_put (map, method_name, method);
+  else
+    {
+      tree new_entry;
+      
+      /* If an entry already exists, it's more complicated.  We'll
+	 have to check whether the method prototype is the same or
+	 not.  */
+      if (TREE_CODE (existing_entry) != TREE_VEC)
+	{
+	  /* If the method prototypes are the same, there is nothing
+	     to do.  */
+	  if (comp_proto_with_proto (method, existing_entry, 1))
+	    return;
+
+	  /* If not, create a vector to store both the method already
+	     in the map, and the new one that we are adding.  */
+	  new_entry = make_tree_vec (2);
+	  
+	  TREE_VEC_ELT (new_entry, 0) = existing_entry;
+	  TREE_VEC_ELT (new_entry, 1) = method;
+	}
+      else
+	{
+	  /* An entry already exists, and it's already a vector.  This
+	     means that at least 2 different method prototypes were
+	     already found, and we're considering registering yet
+	     another one.  */
+	  size_t i;
+
+	  /* Check all the existing prototypes.  If any matches the
+	     one we need to add, there is nothing to do because it's
+	     already there.  */
+	  for (i = 0; i < (size_t) TREE_VEC_LENGTH (existing_entry); i++)
+	    if (comp_proto_with_proto (method, TREE_VEC_ELT (existing_entry, i), 1))
+	      return;
+
+	  /* Else, create a new, bigger vector and add the new method
+	     at the end of it.  This is inefficient but extremely
+	     rare; in any sane program most methods have a single
+	     prototype, and very few, if any, will have more than
+	     2!  */
+	  new_entry = make_tree_vec (TREE_VEC_LENGTH (existing_entry) + 1);
+	  
+	  /* Copy the methods from the existing vector.  */
+	  for (i = 0; i < (size_t) TREE_VEC_LENGTH (existing_entry); i++)
+	    TREE_VEC_ELT (new_entry, i) = TREE_VEC_ELT (existing_entry, i);
+	  
+	  /* Add the new method at the end.  */
+	  TREE_VEC_ELT (new_entry, i) = method;
+	}
+
+      /* Store the new vector in the map.  */
+      objc_map_put (map, method_name, new_entry);
+    }
+}
+
+
+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;
+    }
+}
+
+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)
+    insert_method_into_method_map (true, method);
+  else
+    {
+      insert_method_into_method_map (false, 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))
+	insert_method_into_method_map (true, method);
+    }
+
+  return method;
+}
+
+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
+
+/* Produce a printable version of an ivar name.  This is only used
+   inside add_instance_variable.  */
+static const char *
+printable_ivar_name (tree field_decl)
+{
+  if (DECL_NAME (field_decl))
+    return identifier_to_locale (IDENTIFIER_POINTER (DECL_NAME (field_decl)));
+  else
+    return _("<unnamed>");
+}
+
+/* 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);
+
+#ifdef OBJCPLUS
+  if (TREE_CODE (field_type) == REFERENCE_TYPE)
+    {
+      error ("illegal reference type specified for instance variable %qs",
+	     printable_ivar_name (field_decl));
+      /* 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",
+	     printable_ivar_name (field_decl));
+      /* 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",
+	     printable_ivar_name (field_decl));
+      /* 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, printable_ivar_name (field_decl));
+	      /* 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)));
+}
+
+/* Searches all the instance variables of 'klass' and of its
+   superclasses for an instance variable whose name (identifier) is
+   'ivar_name_ident'.  Return the declaration (DECL) of the instance
+   variable, if found, or NULL_TREE, if not found.  */
+static inline tree
+ivar_of_class (tree klass, tree ivar_name_ident)
+{
+  /* First, look up the ivar in CLASS_RAW_IVARS.  */
+  tree decl_chain = CLASS_RAW_IVARS (klass);
+
+  for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain))
+    if (DECL_NAME (decl_chain) == ivar_name_ident)
+      return decl_chain;
+
+  /* If not found, search up the class hierarchy.  */
+  while (CLASS_SUPER_NAME (klass))
+    {
+      klass = lookup_interface (CLASS_SUPER_NAME (klass));
+
+      decl_chain = CLASS_RAW_IVARS (klass);
+
+      for ( ; decl_chain; decl_chain = DECL_CHAIN (decl_chain))
+	if (DECL_NAME (decl_chain) == ivar_name_ident)
+	  return decl_chain;
+    }
+
+  return NULL_TREE;
+}
+
+/* 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 = ivar_of_class (klass, 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_interface (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_interface (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. */
+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,
+				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
+	       <property type> __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 /* min_alignof */,
+					      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,
+				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 /* min_alignof */,
+					      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_protocol (tree name, tree attributes)
+{
+  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);
+	}
+    }
+
+  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)
+	{
+	  /* TODO: Do we need to store the attributes here ? */
+	  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_ATOMIC (TREE_TYPE (parm)) ? TYPE_QUAL_ATOMIC : 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 expr 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 expr)
+{
+  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, expr);
+  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.  EXPR is NULL or an expression that needs to be
+   evaluated for the side effects of array size expressions in the
+   parameters.  */
+
+static void
+start_method_def (tree method, tree expr)
+{
+  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, expr);
+
+  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)
+{
+  tree type1, type2;
+
+  /* The following test is needed in case there are hashing
+     collisions.  */
+  if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2))
+    return 0;
+
+  /* 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.  */
+
+  /* The first argument (objc_object_type) is always the same, no need
+     to compare.  */
+
+  /* The second argument (objc_selector_type) is always the same, no
+     need to compare.  */
+
+  /* Compare the other arguments.  */
+  {
+    tree arg1, arg2;
+
+    /* Compare METHOD_SEL_ARGS.  */
+    for (arg1 = METHOD_SEL_ARGS (proto1), arg2 = METHOD_SEL_ARGS (proto2);
+	 arg1 && arg2;
+	 arg1 = DECL_CHAIN (arg1), arg2 = DECL_CHAIN (arg2))
+      {
+	type1 = TREE_VALUE (TREE_TYPE (arg1));
+	type2 = TREE_VALUE (TREE_TYPE (arg2));
+
+	/* FIXME: Do we need to decay argument types to compare them ?  */
+	type1 = objc_decay_parm_type (type1);
+	type2 = objc_decay_parm_type (type2);
+
+	if (!objc_types_are_equivalent (type1, type2)
+	    && (strict || !objc_types_share_size_and_alignment (type1, type2)))
+	  return 0;
+      }
+
+    /* The loop ends when arg1 or arg2 are NULL.  Make sure they are
+       both NULL.  */
+    if (arg1 != arg2)
+      return 0;
+
+    /* Compare METHOD_ADD_ARGS.  */
+    if ((METHOD_ADD_ARGS (proto1) && !METHOD_ADD_ARGS (proto2))
+	|| (METHOD_ADD_ARGS (proto2) && !METHOD_ADD_ARGS (proto1)))
+      return 0;
+
+    if (METHOD_ADD_ARGS (proto1))
+      {
+	for (arg1 = TREE_CHAIN (METHOD_ADD_ARGS (proto1)), arg2 = TREE_CHAIN (METHOD_ADD_ARGS (proto2));
+	     arg1 && arg2;
+	     arg1 = TREE_CHAIN (arg1), arg2 = TREE_CHAIN (arg2))
+	  {
+	    type1 = TREE_TYPE (TREE_VALUE (arg1));
+	    type2 = TREE_TYPE (TREE_VALUE (arg2));
+
+	    /* FIXME: Do we need to decay argument types to compare them ?  */
+	    type1 = objc_decay_parm_type (type1);
+	    type2 = objc_decay_parm_type (type2);
+
+	    if (!objc_types_are_equivalent (type1, type2)
+		&& (strict || !objc_types_share_size_and_alignment (type1, type2)))
+	      return 0;
+	  }
+      }
+
+    /* The loop ends when arg1 or arg2 are NULL.  Make sure they are
+       both NULL.  */
+    if (arg1 != arg2)
+      return 0;
+
+    /* Compare METHOD_ADD_ARGS_ELLIPSIS_P.  */
+    if (METHOD_ADD_ARGS_ELLIPSIS_P (proto1) != METHOD_ADD_ARGS_ELLIPSIS_P (proto2))
+      return 0;
+  }
+
+  /* Success.  */
+  return 1;
+}
+
+/* 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;
+}
+
+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_for_method (ret_type, 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 <statements> may be jumping to 'break_label' (if they
+  contain 'break') or to 'continue_label' (if they contain
+  'continue').
+
+  The syntax is
+
+  for (<object expression> in <collection expression>)
+    <statements>
+
+  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 = <collection expression>;
+    __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)
+      <object expression> = 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 (<collection expression>);
+	    <object expression> = enumState.itemsPtr[__objc_foreach_index];
+	    <statements> [PS: inside <statments>, '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;
+       <object expression> = 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 = <collection expression>; */
+  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 <object expression> = 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 (<collection expression>); */
+  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));
+
+  /* <object expression> = 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));
+
+  /* <statements> [PS: in <statments>, '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));
+
+  /* <object expression> = 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))
+{
+}
+
+void
+objc_common_init_ts (void)
+{
+  c_common_init_ts ();
+
+  MARK_TS_DECL_NON_COMMON (CLASS_METHOD_DECL);
+  MARK_TS_DECL_NON_COMMON (INSTANCE_METHOD_DECL);
+  MARK_TS_DECL_NON_COMMON (KEYWORD_DECL);
+  MARK_TS_DECL_NON_COMMON (PROPERTY_DECL);
+
+  MARK_TS_COMMON (CLASS_INTERFACE_TYPE);
+  MARK_TS_COMMON (PROTOCOL_INTERFACE_TYPE);
+  MARK_TS_COMMON (CLASS_IMPLEMENTATION_TYPE);
+
+  MARK_TS_TYPED (MESSAGE_SEND_EXPR);
+  MARK_TS_TYPED (PROPERTY_REF);
+}
+
+#include "gt-objc-objc-act.h"
diff --git a/gcc-4.9/gcc/objc/objc-act.h b/gcc-4.9/gcc/objc/objc-act.h
new file mode 100644
index 000000000..0c7fa0456
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-act.h
@@ -0,0 +1,733 @@
+/* Declarations for objc-act.c.
+   Copyright (C) 1990-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+
+#ifndef GCC_OBJC_ACT_H
+#define GCC_OBJC_ACT_H
+
+/*** Language hooks ***/
+
+bool objc_init (void);
+const char *objc_printable_name (tree, int);
+int objc_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
+void objc_common_init_ts (void);
+
+/* 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) (TYPE_NAME (CLASS))
+/* 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_CONTEXT (CLASS))
+#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) (TYPE_MINVAL (CLASS))
+#define CLASS_CLS_METHODS(CLASS) (TYPE_MAXVAL (CLASS))
+#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) (TYPE_NAME (CLASS))
+#define PROTOCOL_LIST(CLASS) TREE_VEC_ELT (TYPE_LANG_SLOT_1 (CLASS), 0)
+#define PROTOCOL_NST_METHODS(CLASS) (TYPE_MINVAL (CLASS))
+#define PROTOCOL_CLS_METHODS(CLASS) (TYPE_MAXVAL (CLASS))
+#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
+
+/* An array of all the local variables in the current function that
+   need to be marked as volatile.  */
+extern GTY(()) vec<tree, va_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_<my_name>; */
+  tree meta_decl;		/* _OBJC[_v2]_METACLASS_<my_name>; */
+  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
+
+#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
+
+/* 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-4.9/gcc/objc/objc-encoding.c b/gcc-4.9/gcc/objc/objc-encoding.c
new file mode 100644
index 000000000..70c2a6858
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-encoding.c
@@ -0,0 +1,951 @@
+/* Routines dealing with ObjC encoding of types
+   Copyright (C) 1992-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "stringpool.h"
+#include "stor-layout.h"
+
+#ifdef OBJCPLUS
+#include "cp/cp-tree.h"
+#else
+#include "c/c-tree.h"
+#include "c/c-lang.h"
+#endif
+
+#include "c-family/c-common.h"
+#include "c-family/c-objc.h"
+
+#include "objc-encoding.h"
+#include "objc-act.h"
+
+/* For my_build_string().  */
+#include "objc-runtime-shared-support.h"
+
+/* For BITS_PER_UNIT.  */
+#include "tm.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 */
+
+/* Set up for use of obstacks.  */
+#include "obstack.h"
+
+/* This obstack is used to accumulate the encoding of a data type.  */
+static struct obstack util_obstack;
+
+/* This points to the beginning of obstack contents, so we can free
+   the whole contents.  */
+static char *util_firstobj;
+
+void objc_encoding_init (void)
+{
+  gcc_obstack_init (&util_obstack);
+  util_firstobj = (char *) obstack_finish (&util_obstack);
+}
+
+int generating_instance_variables = 0;
+
+static void encode_type_qualifiers (tree);
+static void encode_type (tree, int, int);
+static void encode_field (tree field_decl, int curtype, int format);
+
+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.  */
+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;
+}
+
+/* This is used to implement @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;
+}
+
+/* "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,<code>] where xx is the vector_size, yy is the
+     alignment of the vector, and <code> 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 (<vector>).
+	      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__
+	      (<vector>).  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 (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 compatibility 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 %<%T%> found during Objective-C encoding",
+	       TREE_TYPE (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));
+}
+
+static void
+encode_field (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_to_uhwi (DECL_SIZE (field_decl));
+
+      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);
+}
+
+tree
+encode_field_decl (tree field_decl)
+{
+  tree result;
+
+  encode_field (field_decl,
+		obstack_object_size (&util_obstack),
+		OBJC_ENCODE_DONT_INLINE_DEFS);
+  
+  /* Null terminate string.  */
+  obstack_1grow (&util_obstack, 0);
+
+  /* Get identifier for the string.  */
+  result = get_identifier (XOBFINISH (&util_obstack, char *));
+  obstack_free (&util_obstack, util_firstobj);
+
+  return result;
+}
+
+/* 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);
+}
diff --git a/gcc-4.9/gcc/objc/objc-encoding.h b/gcc-4.9/gcc/objc/objc-encoding.h
new file mode 100644
index 000000000..0bc333977
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-encoding.h
@@ -0,0 +1,59 @@
+/* Routines dealing with ObjC encoding of types
+   Copyright (C) 1992-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#ifndef GCC_OBJC_ENCODING_H
+#define GCC_OBJC_ENCODING_H
+
+/* This is used to initialize the obstacks used by encoding.  It
+   should be called before any encoding function is used.  It is
+   usually done in objc_init().  */
+extern void objc_encoding_init (void);
+
+/* Encode a method prototype.  The format is described in
+   gcc/doc/objc.texi, section 'Method signatures'.  */
+extern tree encode_method_prototype (tree method_decl);
+
+/* This is used to implement @encode().  See gcc/doc/objc.texi,
+   section '@encode'.  */
+extern tree objc_build_encode_expr (tree type);
+
+/* (Decide if these can ever be validly changed.)  */
+#define OBJC_ENCODE_INLINE_DEFS		0
+#define OBJC_ENCODE_DONT_INLINE_DEFS	1
+
+/* Encode the attributes of a property.  */
+extern tree objc_v2_encode_prop_attr (tree property);
+
+/* Encode the type of a field.  Return an identifier with the type
+   encoding for the field.  The type encoding is a null-terminated
+   string.  */
+extern tree encode_field_decl (tree field_decl);
+
+/* 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).
+
+   TODO: Replace this global variable with an argument that is passed
+   to the various encode() functions.
+
+   TODO: Change it to a 'bool'.  */
+extern int generating_instance_variables;
+
+#endif /* GCC_OBJC_ENCODING_H */
diff --git a/gcc-4.9/gcc/objc/objc-gnu-runtime-abi-01.c b/gcc-4.9/gcc/objc/objc-gnu-runtime-abi-01.c
new file mode 100644
index 000000000..8cfa1f87d
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-gnu-runtime-abi-01.c
@@ -0,0 +1,2270 @@
+/* GNU Runtime ABI version 8
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "stringpool.h"
+
+#ifdef OBJCPLUS
+#include "cp/cp-tree.h"
+#else
+#include "c/c-tree.h"
+#include "c/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"
+#include "objc-encoding.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
+   following 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 void gnu_runtime_abi_01_get_arg_type_list_base (vec<tree, va_gc> **,
+						       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 + identifiers --- */
+
+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_<mumble>; */
+  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)));
+
+  return build_function_call (input_location, objc_get_class_decl, params);
+}
+
+/* Used by build_function_type_for_method.  Append the types for
+   receiver & _cmd at the start of a method argument list to ARGTYPES.
+   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 void
+gnu_runtime_abi_01_get_arg_type_list_base (vec<tree, va_gc> **argtypes,
+					   tree meth, int context,
+					   int superflag ATTRIBUTE_UNUSED)
+{
+  tree receiver_type;
+
+  if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
+    receiver_type = objc_instance_type;
+  else
+    receiver_type = objc_object_type;
+
+  vec_safe_push (*argtypes, receiver_type);
+  /* Selector type - will eventually change to `int'.  */
+  vec_safe_push (*argtypes, objc_selector_type);
+}
+
+/* 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, va_gc> *parms;
+  vec<tree, va_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 ftype
+    = build_function_type_for_method (ret_type, method_prototype,
+				      METHOD_REF, super_flag);
+  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.  */
+  vec_alloc (parms, nparm + 2);
+  vec_alloc (tv, 2);
+
+  /* First, call the lookup function to get a pointer to the method,
+     then cast the pointer, then call it with the method arguments.  */
+  tv->quick_push (lookup_object);
+  tv->quick_push (selector);
+  method = build_function_call_vec (loc, vNULL, sender, tv, NULL);
+  vec_free (tv);
+
+  /* Pass the appropriate object to the method.  */
+  parms->quick_push ((super_flag ? self_decl : lookup_object));
+
+  /* Pass the selector to the method.  */
+  parms->quick_push (selector);
+  /* Now append the remainder of the parms.  */
+  if (nparm)
+    for (; method_params; method_params = TREE_CHAIN (method_params))
+      parms->quick_push (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, vNULL, t, parms, NULL);
+  vec_free (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);
+  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, va_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, NULL_TREE));
+#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, va_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, va_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, va_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_<mumble>; */
+      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, va_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, va_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_<name> = { ... };  */
+
+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, va_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, va_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, va_gc> *inits = NULL;
+  vec<constructor_elt, va_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, va_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, va_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, va_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, va_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, va_gc> *parms;
+  vec_alloc (parms, 1);
+  /* A throw is just a call to the runtime throw function with the
+     object as a parameter.  */
+  parms->quick_push (throw_expr);
+  t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl, parms,
+			       NULL);
+  vec_free (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 = builtin_decl_explicit (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-4.9/gcc/objc/objc-lang.c b/gcc-4.9/gcc/objc/objc-lang.c
new file mode 100644
index 000000000..c9c5a293a
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-lang.c
@@ -0,0 +1,59 @@
+/* Language-dependent hooks for Objective-C.
+   Copyright (C) 2001-2014 Free Software Foundation, Inc.
+   Contributed by Ziemowit Laski  <zlaski@apple.com>
+
+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
+<http://www.gnu.org/licenses/>.  */
+
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "c/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/c-objc-common.h"
+#include "c/c-lang.h"
+
+enum c_language_kind c_language = clk_objc;
+
+/* 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_common_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.  */
+
+#include "gtype-objc.h"
diff --git a/gcc-4.9/gcc/objc/objc-map.c b/gcc-4.9/gcc/objc/objc-map.c
new file mode 100644
index 000000000..386d2c5f6
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-map.c
@@ -0,0 +1,161 @@
+/* objc-map.c -- Implementation of map data structures for ObjC compiler
+   Copyright (C) 2011-2014 Free Software Foundation, Inc.
+   Written by Nicola Pero <nicola.pero@meta-innovation.com>
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU Lesser Public License as published by the
+Free Software Foundation; either version 3, or (at your option) any
+later version.
+
+This program 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 Lesser Public License for more details.
+
+You should have received a copy of the GNU Lesser Public License
+along with this program; if not, write to the Free Software
+Foundation, 51 Franklin Street - Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tree.h"
+#include "ggc.h"
+#include "objc-map.h"
+
+#define OUT_OF_MEMORY { fprintf (stderr, "Out of memory\n"); abort (); }
+
+static
+size_t
+ATTRIBUTE_PURE
+next_power_of_two (size_t x)
+{
+  size_t result = 1;
+
+  if (x < 2)
+    return 2;
+
+  /* Avoid the long calculation if x is already a power of two.  Since
+     we internally always increase/shrink tables by powers of 2, the
+     calculation should only be done once, when the table is first
+     set up.  */
+  if ((x & (x - 1)) == 0)
+    return x;
+
+  /* Calculate log_2 by counting how many times we can divide by 2
+     before reaching 0.  */
+  while (x > 0)
+    {
+      x = x >> 1;
+      result = result << 1;
+    }
+  return result;
+}
+
+objc_map_t
+objc_map_alloc_ggc (size_t initial_capacity)
+{
+  objc_map_t map = (objc_map_t) ggc_internal_cleared_vec_alloc (1, sizeof (struct objc_map_private));
+  if (map == NULL)
+    OUT_OF_MEMORY;
+  
+  initial_capacity = next_power_of_two (initial_capacity);
+  
+  map->number_of_slots = initial_capacity;
+  map->mask = initial_capacity - 1;
+  map->maximum_load_factor = 70;
+  map->max_number_of_non_empty_slots = (initial_capacity * map->maximum_load_factor) / 100;
+
+  map->slots = (tree *)ggc_internal_cleared_vec_alloc (initial_capacity, sizeof (tree));
+  map->values = (tree *)ggc_internal_cleared_vec_alloc (initial_capacity, sizeof (tree));
+
+  if (map->slots == NULL)
+    OUT_OF_MEMORY;
+  
+  if (map->values == NULL)
+    OUT_OF_MEMORY;
+
+  return map;
+}
+
+void
+objc_map_set_maximum_load_factor (objc_map_t map, int number_between_zero_and_one_hundred)
+{
+  if (map->number_of_non_empty_slots != 0)
+    return;
+
+  map->maximum_load_factor = number_between_zero_and_one_hundred;
+  map->max_number_of_non_empty_slots = (map->number_of_slots * number_between_zero_and_one_hundred) / 100;
+}
+
+int
+objc_map_maximum_load_factor (objc_map_t map)
+{
+  return map->maximum_load_factor;
+}
+
+static void
+objc_map_private_resize (objc_map_t map, size_t new_number_of_slots)
+{
+  tree *old_slots = map->slots;
+  tree *old_values = map->values;
+  size_t i, old_number_of_slots = map->number_of_slots;
+  
+  if (new_number_of_slots < (map->number_of_non_empty_slots))
+    new_number_of_slots = 2 * map->number_of_non_empty_slots;
+
+  new_number_of_slots = next_power_of_two (new_number_of_slots);
+  
+  map->number_of_slots = new_number_of_slots;
+  map->mask = map->number_of_slots - 1;
+  map->max_number_of_non_empty_slots = (map->number_of_slots * map->maximum_load_factor) / 100;
+
+
+  map->slots = (tree *)ggc_internal_cleared_vec_alloc (map->number_of_slots, sizeof (tree));
+  map->values = (tree *)ggc_internal_cleared_vec_alloc (map->number_of_slots, sizeof (tree));
+
+  if (map->slots == NULL)
+    OUT_OF_MEMORY;
+
+  if (map->values == NULL)
+    OUT_OF_MEMORY;
+
+  for (i = 0; i < old_number_of_slots; i++)
+    if (old_slots[i] != OBJC_MAP_PRIVATE_EMPTY_SLOT)
+      {
+	size_t k = IDENTIFIER_HASH_VALUE (old_slots[i]) & map->mask;
+	
+	if (map->slots[k] == OBJC_MAP_PRIVATE_EMPTY_SLOT)
+	  {
+	    map->slots[k] = old_slots[i];
+	    map->values[k] = old_values[i];
+	  }
+	else
+	  {
+	    size_t j = 1;
+	    while (1)
+	      {
+		k = (k + j) & map->mask;
+		if (map->slots[k] == OBJC_MAP_PRIVATE_EMPTY_SLOT)
+		  {
+		    map->slots[k] = old_slots[i];
+		    map->values[k] = old_values[i];
+		    break;
+		  }
+		j++;
+	      }
+	  }
+      }
+
+  ggc_free (old_slots);
+  ggc_free (old_values);
+}
+
+void
+objc_map_private_grow (struct objc_map_private *map)
+{
+  objc_map_private_resize (map, map->number_of_slots * 2);
+}
+
+#include "gt-objc-objc-map.h"
diff --git a/gcc-4.9/gcc/objc/objc-map.h b/gcc-4.9/gcc/objc/objc-map.h
new file mode 100644
index 000000000..c621ea0e5
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-map.h
@@ -0,0 +1,309 @@
+/* objc-map.h -- Implementation of map data structures for ObjC compiler
+   Copyright (C) 2011-2014 Free Software Foundation, Inc.
+   Written by Nicola Pero <nicola.pero@meta-innovation.com>
+
+This program is free software; you can redistribute it and/or modify it
+under the terms of the GNU Lesser Public License as published by the
+Free Software Foundation; either version 3, or (at your option) any
+later version.
+
+This program 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 Lesser Public License for more details.
+
+You should have received a copy of the GNU Lesser Public License
+along with this program; if not, write to the Free Software
+Foundation, 51 Franklin Street - Fifth Floor,
+Boston, MA 02110-1301, USA.  */
+
+#ifndef OBJC_MAP_H
+#define OBJC_MAP_H
+
+/* A map is a data structure that maps a key to a value.  In this file
+   we currently have maps that can map a GCC identifier (a tree) to
+   some other GCC tree.  This is what the ObjC frontend mostly needs:
+   being able to look up an identifier into an ObjC data structure.  A
+   typical usage is mapping ObjC class names (as identifiers) to a
+   tree representing the class.
+
+   This implementation is fast.  :-) */
+
+/**
+ ** Private definitions.
+ **/
+
+/* We include private declaration and definitions that are required to
+   provide the implementation of inline functions.  You should ignore
+   these definitions (and the implementation of the inline functions)
+   as they are not part of the public API and may change.  */
+typedef unsigned int objc_map_private_hash_t;
+
+/* This is used as sentinel.  */
+#define OBJC_MAP_PRIVATE_EMPTY_SLOT (tree)0
+
+struct GTY(()) objc_map_private {
+  /* Total number of slots.  This is the maximum number of elements
+     that can be currently stored in the map before resizing.  This is
+     the number of slots in the C array.  Important: this is
+     guaranteed to be a power of 2.  When we create (or resize) the
+     map, we round up the size to the next power of 2.  This allows us
+     to convert a hash to a position in the hashtable by simply doing
+     "position = hash & mask", where mask is number_of_slots - 1
+     instead of using a modulo (which requires a division).  */
+  size_t number_of_slots;
+
+  /* This is number_of_slots - 1, precomputed.  */
+  size_t mask;
+
+  /* Number of slots that are not empty (ie, that are active).  We
+     keep counts using this variable which can easily be checked
+     against max_number_of_non_empty_slots.  */
+  size_t number_of_non_empty_slots;
+
+  /* This is the load factor limit.  When the number of non empty
+     slots equals this number, we need to resize the array.  This is
+     calculated once, when the slots are resized, and then kept cached
+     so it can be compared quickly when elements are added.  */
+  size_t max_number_of_non_empty_slots;
+
+  /* The maximum load factor.  */
+  int maximum_load_factor;
+
+  /* These are the keys.  */
+  tree * GTY ((length ("%h.number_of_slots"))) slots;
+
+  /* These are the values.  values[i] is the the value corresponding
+     to slots[i].  */
+  tree * GTY ((length ("%h.number_of_slots"))) values;
+};
+
+/* Private functions used to resize the map.  They may be called by
+   the inline functions when adding elements.  */
+extern void
+objc_map_private_grow (struct objc_map_private *map);
+
+
+/**
+ ** The definition of a map.
+ **/
+typedef struct objc_map_private *objc_map_t;
+
+
+/**
+ ** Creating a map.
+ **/
+
+/* objc_map_alloc_ggc() creates a new map which is under GGC.  The initial
+   capacity must be specified as an argument; this is used to size the map
+   when it is created.  */
+objc_map_t objc_map_alloc_ggc (size_t initial_capacity);
+
+/**
+ ** Performance tuning.
+ **/
+
+/* Set a maximum load factor for the data structure.  This is the main
+   tuning parameter to improve performance (at the expense of
+   memory).  */
+void objc_map_set_maximum_load_factor (objc_map_t map, int number_between_zero_and_one_hundred);
+
+/* Read the maximum load factor.  */
+int objc_map_maximum_load_factor (objc_map_t map);
+
+
+/**
+ ** Getting the value corresponding to a key.
+ **/
+
+/* This is the value returned by objc_map_get() when the value
+   corresponding to a key is not found.  */
+#define OBJC_MAP_NOT_FOUND (tree)1
+
+/* objc_map_get() returns the value associated with a certain key,
+   or OBJC_MAP_NOT_FOUND if there is no value associated with that key.
+   Note that you can also use it to simply check if the map contains a
+   pair with a certain key; just compare the result of calling
+   objc_map_get() to OBJC_MAP_NOT_FOUND.
+
+   It is essential to always check the results of the call to make
+   sure it is not OBJC_MAP_NOT_FOUND.
+
+   NULL is a valid value, so a key can be inserted into a map with
+   value NULL, and objc_map_get() will return NULL in that case.
+   So a result of NULL means that they key *was* found, and the value
+   associated with it was NULL.  */
+static inline tree
+objc_map_get (objc_map_t map, /* struct tree_identifier * */tree key)
+{
+  /* The inline implementation is private and may change without notice.  */
+  objc_map_private_hash_t hash = IDENTIFIER_HASH_VALUE (key);
+  size_t i = hash & map->mask;
+  size_t j = 1;
+
+  if (map->slots[i] == OBJC_MAP_PRIVATE_EMPTY_SLOT)
+    return OBJC_MAP_NOT_FOUND;
+
+  if (map->slots[i] == key)
+    return map->values[i];
+  
+  while (1)
+    {
+      i = (i + j) & map->mask;
+      
+      if (map->slots[i] == OBJC_MAP_PRIVATE_EMPTY_SLOT)
+	return OBJC_MAP_NOT_FOUND;
+      
+      if (map->slots[i] == key)
+	return map->values[i];
+
+      j++;
+    }
+}
+
+/* objc_map_put() puts a key/value pair into the map.  If the map does
+   not contain the key, it is added to it with the specified value.
+   If the map already contains the key, the previous value is replaced
+   with the new one.
+
+   You can use any identifier as key, with the exception of NULL.
+
+   You can use any tree as value, including NULL.  */
+static inline
+void objc_map_put (objc_map_t map, /*struct tree_identifier * */tree key, tree value)
+{
+  /* The inline implementation is private and may change without notice.  */
+  objc_map_private_hash_t hash = IDENTIFIER_HASH_VALUE (key);
+  size_t i, j = 0;
+
+  if (map->number_of_non_empty_slots == map->max_number_of_non_empty_slots)
+    objc_map_private_grow (map);
+
+  i = hash & map->mask;
+    
+  while (1)
+    {
+      if (map->slots[i] == OBJC_MAP_PRIVATE_EMPTY_SLOT)
+	{
+	  map->number_of_non_empty_slots++;
+	  map->slots[i] = key;
+	  map->values[i] = value;
+	  return;
+	}
+      if (map->slots[i] == key)
+	{
+	  map->values[i] = value;
+	  return;
+	}
+
+      j++;
+      i = (i + j) & map->mask;
+    }
+}
+
+/**
+ ** Iterating over a map using an iterator.
+ **/
+
+/* When using iterators you can iterate directly on the elements in
+   the map, and take an action over each one.
+
+   Here is how you iterate over a hmap_pointer using iterators:
+
+   objc_map_iterator_t i;
+
+   objc_map_iterator_initialize (map, &i);
+
+   while (objc_map_iterator_move_to_next (map, &i))
+     {
+       tree p = objc_map_iterator_current_key (map, i);
+       tree q = objc_map_iterator_current_value (map, i);
+
+       ... do something with p and q ...
+     }
+
+   You'll notice that the functions that modify the iterator (to
+   initialize it, or move it to the next element) take a pointer to it
+   as argument (as in "&i"), while the functions that only read its
+   state (to read the current key/value, or remove the current
+   key/value from the map) take it as a direct argument (as in "i").
+
+   Note that all the objc_map_iterator_*() functions are inline and if
+   you follow the pattern above, the compiler should be able to inline
+   everything into a very efficient loop, roughly equivalent to
+   hand-writing a C loop that iterates directly onto the hmap_pointer
+   internal data structures.  */
+
+/* A objc_map_iterator_t variable encapsulates the state of an
+   iteration.  The fact that this is actually a size_t (pointing to
+   the index of the slot that we return next) is an internal, private
+   detail of the implementation and may change without notice.  */
+typedef size_t objc_map_iterator_t;
+
+/* Initialize an iterator to iterate over the specified objc_map.  You
+   must use this before starting the iteration, to get a working
+   iterator.  */
+static inline
+void
+objc_map_iterator_initialize (objc_map_t map ATTRIBUTE_UNUSED, objc_map_iterator_t *i)
+{
+  /* The inline implementation is private and may change without notice.  */
+  /* This is trivial, but the same API would work to initialize more
+     complicated iterators.  */
+  *i = 0;
+}
+
+#define OBJC_MAP_FAILURE 0
+#define OBJC_MAP_SUCCESS 1
+
+/* Move the iterator to the next key/value pair, and return
+   OBJC_MAP_SUCCESS if there is such a key/value pair, and
+   OBJC_MAP_FAILURE if there are no more ones.  The iterator must have
+   been initialized using objc_map_iterator_initialize().  Note that
+   because this function is modifying the iterator, you need to pass a
+   pointer to it.  */
+static inline
+int
+objc_map_iterator_move_to_next (objc_map_t map, objc_map_iterator_t *i)
+{
+  /* The inline implementation is private and may change without notice.  */
+  while (1)
+    {
+      void *slot;
+      if (*i == map->number_of_slots)
+	return OBJC_MAP_FAILURE;
+      
+      slot = map->slots[*i];
+      *i = *i + 1;
+      if (slot != OBJC_MAP_PRIVATE_EMPTY_SLOT)
+	return OBJC_MAP_SUCCESS;
+    }
+}
+
+/* Return the current key.  You can only call it after you have called
+   objc_map_iterator_move_to_next() at least once (to move to the
+   first element), and only if the last call returned
+   OBJC_MAP_SUCCESS.  The behaviour is otherwise undefined, probably a
+   segmentation fault.  */
+static inline
+tree
+objc_map_iterator_current_key (objc_map_t map, objc_map_iterator_t i)
+{
+  /* The inline implementation is private and may change without notice.  */
+  return map->slots[i - 1];
+}
+
+/* Return the current value.  You can only call it after you have
+   called objc_map_iterator_move_to_next() at least once (to move to
+   the first element), and only if the last call returned
+   OBJC_MAP_SUCCESS.  The behaviour is otherwise undefined, probably a
+   segmentation fault.  */
+static inline
+tree
+objc_map_iterator_current_value (objc_map_t map, objc_map_iterator_t i)
+{
+  /* The inline implementation is private and may change without notice.  */
+  return map->values[i - 1];
+}
+
+#endif /* OBJC_MAP_H */
diff --git a/gcc-4.9/gcc/objc/objc-next-metadata-tags.h b/gcc-4.9/gcc/objc/objc-next-metadata-tags.h
new file mode 100644
index 000000000..e16eb635b
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-next-metadata-tags.h
@@ -0,0 +1,172 @@
+/* Declarations for meta-data attribute tags.
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+/* 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-4.9/gcc/objc/objc-next-runtime-abi-01.c b/gcc-4.9/gcc/objc/objc-next-runtime-abi-01.c
new file mode 100644
index 000000000..1879d1033
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-next-runtime-abi-01.c
@@ -0,0 +1,2955 @@
+/* Next Runtime (ABI-0/1) private.
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+/* 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 "tree.h"
+#include "stringpool.h"
+
+#ifdef OBJCPLUS
+#include "cp/cp-tree.h"
+#else
+#include "c/c-tree.h"
+#include "c/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 "c-family/c-target.h"
+#include "tree-iterator.h"
+
+#include "objc-runtime-hooks.h"
+#include "objc-runtime-shared-support.h"
+#include "objc-encoding.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 void next_runtime_abi_01_get_arg_type_list_base (vec<tree, va_gc> **,
+							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 identifiers --- */
+
+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_<mumble>; */
+
+  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 build_function_type_for_method.  Append the types for
+   receiver & _cmd at the start of a method argument list to ARGTYPES.
+   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 void
+next_runtime_abi_01_get_arg_type_list_base (vec<tree, va_gc> **argtypes,
+					    tree meth, int context,
+					    int superflag)
+{
+  tree receiver_type;
+
+  if (superflag)
+    receiver_type = objc_super_type;
+  else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
+    receiver_type = objc_instance_type;
+  else
+    receiver_type = objc_object_type;
+
+  vec_safe_push (*argtypes, receiver_type);
+  /* Selector type - will eventually change to `int'.  */
+  vec_safe_push (*argtypes, objc_selector_type);
+}
+
+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, va_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 ftype = build_function_type_for_method (ret_type, method_prototype,
+					       METHOD_REF, super_flag);
+
+  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.  */
+  vec_alloc (parms, 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.  */
+  parms->quick_push (lookup_object);
+  /* Pass the selector to the method.  */
+  parms->quick_push (selector);
+  /* Now append the remainder of the parms.  */
+  if (nparm)
+    for (; method_params; method_params = TREE_CHAIN (method_params))
+      parms->quick_push (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, vNULL, t, parms, NULL);
+  vec_free (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);
+  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, va_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, va_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, va_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, va_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, va_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, va_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, va_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, va_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_<mumble>; */
+      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, va_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, va_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_<name> = { ... }; */
+/* 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, va_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, va_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, va_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, va_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, va_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)));
+}
+
+/* Any target implementing NeXT ObjC m32 ABI has to ensure that objects
+   refer to, and define, symbols that enforce linkage of classes into the
+   executable image, preserving unix archive semantics.
+
+   At present (4.8), the only targets implementing this are Darwin; these
+   use top level asms to implement a scheme (see config/darwin-c.c).  The
+   latter method is a hack, but compatible with LTO see also PR48109 for
+   further discussion and other possible methods.  */
+
+static void
+handle_next_class_ref (tree chain ATTRIBUTE_UNUSED)
+{
+  if (targetcm.objc_declare_unresolved_class_reference)
+    {
+      const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
+      char *string = (char *) alloca (strlen (name) + 30);
+      sprintf (string, ".objc_class_name_%s", name);
+      targetcm.objc_declare_unresolved_class_reference (string);
+    }
+}
+
+static void
+handle_next_impent (struct imp_entry *impent ATTRIBUTE_UNUSED)
+{
+  if (targetcm.objc_declare_class_definition)
+    {
+      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;
+	}
+      targetcm.objc_declare_class_definition (buf);
+    }
+}
+
+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;
+}
+
+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);
+
+  /* Dump the class references.  This forces the appropriate classes
+     to be linked into the executable image, preserving unix archive
+     semantics.  */
+  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
+   <setjmp.h> 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 <setjmp.h>, 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, va_gc> *parms;
+  vec_alloc (parms, 1);
+  /* A throw is just a call to the runtime throw function with the
+     object as a parameter.  */
+  parms->quick_push (throw_expr);
+  t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl, parms,
+			       NULL);
+  vec_free (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 = builtin_decl_explicit (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-4.9/gcc/objc/objc-next-runtime-abi-02.c b/gcc-4.9/gcc/objc/objc-next-runtime-abi-02.c
new file mode 100644
index 000000000..ee43d2d0c
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-next-runtime-abi-02.c
@@ -0,0 +1,3736 @@
+/* Next Runtime (ABI-2) private.
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+/* 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"
+#include "stringpool.h"
+
+#ifdef OBJCPLUS
+#include "cp/cp-tree.h"
+#else
+#include "c/c-tree.h"
+#include "c/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 "tree-iterator.h"
+
+#include "objc-runtime-hooks.h"
+#include "objc-runtime-shared-support.h"
+#include "objc-encoding.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 void next_runtime_abi_02_get_arg_type_list_base (vec<tree, va_gc> **,
+							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 **);
+
+/* TODO: Use an objc-map.  */
+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_list (ptr_type_node,
+				   ptr_type_node, NULL_TREE);
+
+  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_list (void_type_node, NULL_TREE);
+  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) */
+  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 <type> <name>;"
+   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_<mumble>; */
+  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 ;
+
+/* 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, va_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 (*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.  */
+    vec_alloc (classrefs, 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 (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, va_gc> *v;
+      vec_alloc (v, 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));
+      v->quick_push (t);
+      t = build_function_call_vec (input_location, vNULL, objc_get_class_decl,
+				   v, 0);
+      vec_free (v);
+      return t;
+    }
+}
+
+/* Used by build_function_type_for_method.  Append the types for
+   receiver & _cmd at the start of a method argument list to ARGTYPES.
+   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 void
+next_runtime_abi_02_get_arg_type_list_base (vec<tree, va_gc> **argtypes,
+					    tree meth, int context,
+					    int superflag)
+{
+  tree receiver_type;
+
+  if (superflag)
+    receiver_type = objc_super_type;
+  else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
+    receiver_type = objc_instance_type;
+  else
+    receiver_type = objc_object_type;
+
+  vec_safe_push (*argtypes, receiver_type);
+  /* Selector type - will eventually change to `int'.  */
+  vec_safe_push (*argtypes,
+		 superflag ? objc_v2_super_selector_type
+		           : objc_v2_selector_type);
+}
+
+/* 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;
+
+static GTY (()) vec<msgref_entry, va_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 (*msgrefs, count, ref)
+	if (ref->func == message_func_decl && ref->selname == sel_name)
+	  return ref->refdecl;
+    }
+  else
+    /* Somewhat arbitrary initial provision.  */
+    vec_alloc (msgrefs, 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 (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;
+static GTY (()) vec<prot_list_entry, va_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 (*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.  */
+    vec_alloc (protrefs, 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 (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_build_pointer_plus_loc (input_location, 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 <protocol> ).  */
+  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 structure.  */
+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, va_gc> *class_super_refs;
+static GTY (()) vec<ident_data_tuple, va_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, va_gc> *list = inst_meth  ? class_super_refs
+						: metaclass_super_refs;
+
+  if (list)
+    {
+      int count;
+      ident_data_tuple *ref;
+      FOR_EACH_VEC_ELT (*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)
+	{
+	  vec_alloc (class_super_refs, 16);
+	  list = class_super_refs;
+	}
+      else
+	{
+	  vec_alloc (metaclass_super_refs, 16);
+	  list = metaclass_super_refs;
+	}
+    }
+  /* 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 (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);
+  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))
+      && vec_safe_length (classrefs))
+    {
+      int count;
+      ident_data_tuple *ref;
+      /* The receiver is a variable created by build_class_reference_decl.  */
+      FOR_EACH_VEC_ELT (*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. The
+   arguments will be passed to a function with FNTYPE.  */
+
+static tree
+objc_copy_to_temp_side_effect_params (tree fntype, tree values)
+{
+  tree valtail;
+  function_args_iterator iter;
+
+  /* Skip over receiver and the &_msf_ref types.  */
+  function_args_iter_init (&iter, fntype);
+  function_args_iter_next (&iter);
+  function_args_iter_next (&iter);
+
+  for (valtail = values; valtail;
+       valtail = TREE_CHAIN (valtail), function_args_iter_next (&iter))
+    {
+      tree value = TREE_VALUE (valtail);
+      tree type = function_args_iter_cond (&iter);
+      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 ftype = build_function_type_for_method (ret_type, method_prototype,
+					       METHOD_REF, super_flag);
+  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 (ftype,
+							  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, va_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 (input_location,
+					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, va_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)
+{
+  const 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 (!vec_safe_length (msgrefs))
+    return;
+
+  FOR_EACH_VEC_ELT (*msgrefs, count, ref)
+    {
+      vec<constructor_elt, va_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 (!vec_safe_length (classrefs))
+    return;
+
+  FOR_EACH_VEC_ELT (*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, va_gc> *list = metaclass  ? metaclass_super_refs
+						: class_super_refs;
+
+  if (!vec_safe_length (list))
+    return;
+
+  FOR_EACH_VEC_ELT (*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, va_gc> *class_list;
+
+static void
+objc_v2_add_to_class_list (tree global_class_decl)
+{
+  vec_safe_push (class_list, global_class_decl);
+}
+
+static GTY(()) vec<tree, va_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)
+{
+  vec_safe_push (nonlazy_class_list, global_class_decl);
+}
+
+static GTY(()) vec<tree, va_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)
+{
+  vec_safe_push (category_list, decl);
+}
+
+static GTY(()) vec<tree, va_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)
+{
+  vec_safe_push (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, va_gc> *src, const char *nam, tree attr)
+{
+  int count=0;
+  tree type, decl, expr;
+  vec<constructor_elt, va_gc> *initlist = NULL;
+
+  if (!vec_safe_length (src))
+    return;
+
+  FOR_EACH_VEC_ELT (*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 (*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, va_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.  */
+    vec_alloc (protlist, 32);
+  e.id = protocol_interface_decl;
+  e.refdecl = protocol_decl;
+  vec_safe_push (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 (!vec_safe_length (protlist))
+    return;
+
+  FOR_EACH_VEC_ELT (*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 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, va_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
+   consistent 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, va_gc> *initlist = NULL;
+  do
+    {
+      vec<constructor_elt, va_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, va_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, va_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, va_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, va_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, va_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_<mumble>; */
+      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, va_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, va_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_$_<name> = { ... }; */
+
+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;
+
+static GTY (()) vec<ivarref_entry, va_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 (*ivar_offset_refs, count, ref)
+	if (DECL_NAME (ref->decl) == field_decl_id)
+	  return ref->decl;
+    }
+  else
+    /* Somewhat arbitrary initial provision.  */
+    vec_alloc (ivar_offset_refs, 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 (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, va_gc> *inits = NULL;
+
+  do
+    {
+      vec<constructor_elt, va_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.  */
+      id = add_objc_string (encode_field_decl (field_decl),
+                            meth_var_types);
+      CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
+
+      /* 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, va_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, va_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, va_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, va_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 (*ehtype_list, count, ref)
+	if (ref->ident == name)
+	  return; /* Already entered.  */
+     }
+  else
+    /* Arbitrary initial count.  */
+    vec_alloc (ehtype_list, 8);
+
+  /* Not found, or new list.  */
+  e.ident = name;
+  e.data = NULL_TREE;
+  vec_safe_push (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_$_<my_root_int>
+         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_$_<interface>...  */
+      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_$_<interface>.  */
+      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_to_shwi (DECL_SIZE (field));
+  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 (!vec_safe_length (ivar_offset_refs))
+    return;
+
+  FOR_EACH_VEC_ELT (*ivar_offset_refs, count, ref)
+    finish_var_decl (ref->decl, ref->offset);
+}
+
+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);
+
+  /* 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, va_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_build_pointer_plus (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 (!vec_safe_length (ehtype_list))
+    return;
+
+  FOR_EACH_VEC_ELT (*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 (!vec_safe_length (ehtype_list))
+    return NULL_TREE;
+
+  FOR_EACH_VEC_ELT (*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_<Class>.  */
+  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, vNULL, objc_rethrow_exception_decl,
+				 NULL, NULL);
+  else
+    {
+      /* Throw like the others...  */
+      vec<tree, va_gc> *parms;
+      vec_alloc (parms, 1);
+      parms->quick_push (throw_expr);
+      t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl,
+				   parms, 0);
+      vec_free (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 = builtin_decl_explicit (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, vNULL, 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-4.9/gcc/objc/objc-runtime-hooks.h b/gcc-4.9/gcc/objc/objc-runtime-hooks.h
new file mode 100644
index 000000000..826d2ae41
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-runtime-hooks.h
@@ -0,0 +1,111 @@
+/* Hooks to abstract the runtime meta-data generation for Objective C.
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#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).  */
+  void (*get_arg_type_list_base) (vec<tree, va_gc> **, 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-4.9/gcc/objc/objc-runtime-shared-support.c b/gcc-4.9/gcc/objc/objc-runtime-shared-support.c
new file mode 100644
index 000000000..bfdbb4d7d
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-runtime-shared-support.c
@@ -0,0 +1,725 @@
+/* Support routines shared by all runtimes.
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#include "config.h"
+#include "system.h"
+#include "coretypes.h"
+#include "tm.h"
+#include "tree.h"
+#include "stringpool.h"
+
+#ifdef OBJCPLUS
+#include "cp/cp-tree.h"
+#else
+#include "c/c-tree.h"
+#include "c/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 */
+
+/* Hooks for string decls etc.  */
+#include "objc-runtime-hooks.h"
+
+#include "objc-runtime-shared-support.h"
+#include "objc-encoding.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, va_gc> *inits = NULL;
+
+  do
+    {
+      vec<constructor_elt, va_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, va_gc> *inits = NULL;
+
+  do
+    {
+      vec<constructor_elt, va_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, va_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, va_gc> *inits = NULL;
+
+  do
+    {
+      vec<constructor_elt, va_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.  */
+      id = add_objc_string (encode_field_decl (field_decl),
+                            meth_var_types);
+      CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
+
+      /* 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-4.9/gcc/objc/objc-runtime-shared-support.h b/gcc-4.9/gcc/objc/objc-runtime-shared-support.h
new file mode 100644
index 000000000..1ea4da9cd
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-runtime-shared-support.h
@@ -0,0 +1,87 @@
+/* Support routines shared by all runtimes.
+   Copyright (C) 2011-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+#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, va_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, tree);
+#else
+extern void objc_start_function (tree, tree, tree, struct c_arg_info *);
+extern struct c_arg_info *objc_get_parm_info (int, tree);
+#endif
+extern void objc_push_parm (tree);
+
+extern tree build_function_type_for_method (tree, tree, int, bool);
+
+extern char *objc_build_property_setter_name (tree);
+
+/* 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 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);
+
+/* 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 FILE *gen_declaration_file;
+
+#endif /* _OBJC_RUNTIME_SHARED_SUPPORT_H_ */
diff --git a/gcc-4.9/gcc/objc/objc-tree.def b/gcc-4.9/gcc/objc/objc-tree.def
new file mode 100644
index 000000000..5dc7df371
--- /dev/null
+++ b/gcc-4.9/gcc/objc/objc-tree.def
@@ -0,0 +1,76 @@
+/* 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-2014 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
+<http://www.gnu.org/licenses/>.  */
+
+
+/* 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:
+*/