/* Implement classes and message passing for Objective C.
Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003 Free Software Foundation, Inc.
+ 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
Contributed by Steve Naroff.
This file is part of GCC.
You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING. If not, write to
-the Free Software Foundation, 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
/* Purpose: This module implements the Objective-C 4.0 language.
#include "rtl.h"
#include "tm_p.h"
#include "expr.h"
+
+#ifdef OBJCPLUS
+#include "cp-tree.h"
+#else
#include "c-tree.h"
+#endif
+
#include "c-common.h"
+#include "c-pragma.h"
#include "flags.h"
#include "langhooks.h"
#include "objc-act.h"
#include "target.h"
#include "diagnostic.h"
#include "cgraph.h"
+#include "tree-iterator.h"
+#include "libfuncs.h"
+#include "hashtab.h"
+#include "langhooks-def.h"
+
+#define OBJC_VOID_AT_END void_list_node
-#define OBJC_VOID_AT_END build_tree_list (NULL_TREE, void_type_node)
+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. */
/* I am not sure it is really correct.
the module (file) was compiled for, and is recorded in the
module descriptor. */
-#define OBJC_VERSION (flag_next_runtime ? 5 : 8)
+#define OBJC_VERSION (flag_next_runtime ? 6 : 8)
#define PROTOCOL_VERSION 2
/* (Decide if these can ever be validly changed.) */
/* Code generation. */
-static void synth_module_prologue (void);
static tree objc_build_constructor (tree, tree);
-static rtx build_module_descriptor (void);
-static tree init_module_descriptor (tree);
static tree build_objc_method_call (int, tree, tree, tree, tree);
-static void generate_strings (void);
static tree get_proto_encoding (tree);
-static void build_selector_translation_table (void);
-
+static tree lookup_interface (tree);
static tree objc_add_static_instance (tree, tree);
+static tree start_class (enum tree_code, tree, tree, tree);
+static tree continue_class (tree);
+static void finish_class (tree);
+static void start_method_def (tree);
+#ifdef OBJCPLUS
+static void objc_start_function (tree, tree, tree, tree);
+#else
+static void objc_start_function (tree, tree, tree, struct c_arg_info *);
+#endif
+static tree start_protocol (enum tree_code, tree, tree);
+static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
+static tree objc_add_method (tree, tree, int);
+static tree add_instance_variable (tree, int, tree);
+static tree build_ivar_reference (tree);
+static tree is_ivar (tree, tree);
+
static void build_objc_exception_stuff (void);
-static tree objc_declare_variable (enum rid, tree, tree, tree);
-static tree objc_enter_block (void);
-static tree objc_exit_block (void);
-static void objc_build_try_enter_fragment (void);
-static void objc_build_try_exit_fragment (void);
-static void objc_build_extract_fragment (void);
-static tree objc_build_extract_expr (void);
-
-static tree build_ivar_template (void);
-static tree build_method_template (void);
-static tree build_private_template (tree);
+static void build_next_objc_exception_stuff (void);
+
+/* 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
+static void objc_xref_basetypes (tree, tree);
+
static void build_class_template (void);
static void build_selector_template (void);
static void build_category_template (void);
-static tree lookup_method_in_hash_lists (tree, int);
static void build_super_template (void);
-static tree build_category_initializer (tree, tree, tree, tree, tree, tree);
static tree build_protocol_initializer (tree, tree, tree, tree, tree);
-static void synth_forward_declarations (void);
-static int ivar_list_length (tree);
-static tree get_class_ivars (tree, int);
-static void generate_ivar_lists (void);
-static void generate_dispatch_tables (void);
-static void generate_shared_structures (void);
+static tree get_class_ivars (tree, bool);
static tree generate_protocol_list (tree);
-static void generate_forward_declaration_to_string_table (void);
static void build_protocol_reference (tree);
+static tree objc_build_volatilized_type (tree);
-static tree build_keyword_selector (tree);
-static tree synth_id_with_class_suffix (const char *, tree);
+#ifdef OBJCPLUS
+static void objc_generate_cxx_cdtors (void);
+#endif
-static void generate_static_references (void);
-static int check_methods_accessible (tree, tree, int);
-static void encode_aggregate_within (tree, int, int, int, int);
-static const char *objc_demangle (const char *);
-static void objc_expand_function_end (void);
+static const char *synth_id_with_class_suffix (const char *, tree);
/* Hash tables to manage the global pool of method prototypes. */
hash *nst_method_hash_list = 0;
hash *cls_method_hash_list = 0;
-static size_t hash_func (tree);
-static void hash_init (void);
-static void hash_enter (hash *, tree);
static hash hash_lookup (hash *, tree);
-static void hash_add_attr (hash, tree);
static tree lookup_method (tree, tree);
static tree lookup_method_static (tree, tree, int);
-static void add_method_to_hash_list (hash *, tree);
-static tree add_class (tree);
-static void add_category (tree, tree);
-static inline tree lookup_category (tree, tree);
enum string_section
{
};
static tree add_objc_string (tree, enum string_section);
-static tree get_objc_string_decl (tree, enum string_section);
static tree build_objc_string_decl (enum string_section);
-static tree build_selector_reference_decl (void);
+static void build_selector_table_decl (void);
/* Protocol additions. */
-static tree add_protocol (tree);
static tree lookup_protocol (tree);
-static void check_protocol_recursively (tree, tree);
static tree lookup_and_install_protocols (tree);
/* Type encoding. */
static void encode_type_qualifiers (tree);
-static void encode_pointer (tree, int, int);
-static void encode_array (tree, int, int);
-static void encode_aggregate (tree, int, int);
-static void encode_next_bitfield (int);
-static void encode_gnu_bitfield (int, tree, int);
static void encode_type (tree, int, int);
static void encode_field_decl (tree, int, int);
+#ifdef OBJCPLUS
static void really_start_method (tree, tree);
-static int comp_method_with_proto (tree, tree);
-static int objc_types_are_equivalent (tree, tree);
-static int comp_proto_with_proto (tree, tree);
-static tree get_arg_type_list (tree, int, int);
-static tree objc_expr_last (tree);
-static void synth_self_and_ucmd_args (void);
+#else
+static void really_start_method (tree, struct c_arg_info *);
+#endif
+static int comp_proto_with_proto (tree, tree, int);
+static void objc_push_parm (tree);
+#ifdef OBJCPLUS
+static tree objc_get_parm_info (int);
+#else
+static struct c_arg_info *objc_get_parm_info (int);
+#endif
/* Utilities for debugging and error diagnostics. */
static void warn_with_method (const char *, int, tree);
-static void error_with_ivar (const char *, tree, tree);
-static char *gen_method_decl (tree, char *);
-static char *gen_declaration (tree, char *);
-static void gen_declaration_1 (tree, char *);
-static char *gen_declarator (tree, char *, const char *);
-static int is_complex_decl (tree);
-static void adorn_decl (tree, char *);
-static void dump_interface (FILE *, tree);
+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 tree define_decl (tree, tree);
-static tree lookup_method_in_protocol_list (tree, tree, int);
-static tree lookup_protocol_in_reflist (tree, tree);
-static tree create_builtin_decl (enum tree_code, tree, const char *);
-static void setup_string_decl (void);
-static int check_string_class_template (void);
-static tree my_build_string (int, const char *);
-static void build_objc_symtab_template (void);
-static tree init_def_list (tree);
-static tree init_objc_symtab (tree);
-static tree build_metadata_decl (const char *, tree);
-static void forward_declare_categories (void);
-static void generate_objc_symtab_decl (void);
-static tree build_selector (tree);
-static tree build_typed_selector_reference (tree, tree);
-static tree build_selector_reference (tree);
-static tree build_class_reference_decl (void);
+static tree create_field_decl (tree, const char *);
static void add_class_reference (tree);
-static tree build_protocol_template (void);
-static tree build_descriptor_table_initializer (tree, tree);
-static tree build_method_prototype_list_template (tree, int);
-static tree build_method_prototype_template (void);
-static tree objc_method_parm_type (tree);
-static int objc_encoded_type_size (tree);
+static void build_protocol_template (void);
static tree encode_method_prototype (tree);
-static tree generate_descriptor_table (tree, const char *, int, tree, tree);
-static void generate_method_descriptors (tree);
-static void generate_protocol_references (tree);
-static void generate_protocols (void);
-static void check_ivars (tree, tree);
-static tree build_ivar_list_template (tree, int);
-static tree build_method_list_template (tree, int);
-static tree build_ivar_list_initializer (tree, tree);
-static tree generate_ivars_list (tree, const char *, int, tree);
-static tree build_dispatch_table_initializer (tree, tree);
-static tree generate_dispatch_table (tree, const char *, int, tree);
-static tree build_shared_structure_initializer (tree, tree, tree, tree,
- tree, int, tree, tree, tree);
-static void generate_category (tree);
-static int is_objc_type_qualifier (tree);
-static tree adjust_type_for_id_default (tree);
-static tree check_duplicates (hash, int, int);
-static tree receiver_is_class_object (tree, int, int);
-static int check_methods (tree, tree, int);
-static int conforms_to_protocol (tree, tree);
-static void check_protocol (tree, const char *, const char *);
-static void check_protocols (tree, const char *, const char *);
-static void gen_declspecs (tree, char *, int);
static void generate_classref_translation_entry (tree);
static void handle_class_ref (tree);
static void generate_struct_by_value_array (void)
/* Reserved tag definitions. */
-#define TYPE_ID "id"
-#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 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"
/* Note that the string object global name is only needed for the
NeXT runtime. */
-#define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
+#define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
-#define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
+#define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
static const char *TAG_GETCLASS;
static const char *TAG_GETMETACLASS;
when returning a structure. */
static const char *TAG_MSGSEND_STRET;
static const char *TAG_MSGSENDSUPER_STRET;
-static const char *TAG_EXECCLASS;
static const char *default_constant_string_class_name;
/* Runtime metadata flags. */
#define CLS_FACTORY 0x0001L
#define CLS_META 0x0002L
+#define CLS_HAS_CXX_STRUCTORS 0x2000L
#define OBJC_MODIFIER_STATIC 0x00000001
#define OBJC_MODIFIER_FINAL 0x00000002
#define OBJC_MODIFIER_TRANSIENT 0x00000200
#define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000
+/* 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_SYNCENTER "objc_sync_enter"
#define TAG_SYNCEXIT "objc_sync_exit"
#define TAG_SETJMP "_setjmp"
-#define TAG_RETURN_STRUCT "objc_return_struct"
-
#define UTAG_EXCDATA "_objc_exception_data"
-#define UTAG_EXCDATA_VAR "_stackExceptionData"
-#define UTAG_CAUGHTEXC_VAR "_caughtException"
-#define UTAG_RETHROWEXC_VAR "_rethrowException"
-#define UTAG_EVALONCE_VAR "_eval_once"
-
-struct val_stack {
- long val;
- struct val_stack *next;
-};
-static struct val_stack *catch_count_stack, *exc_binding_stack;
-/* useful for debugging */
-static int if_nesting_count;
-static int blk_nesting_count;
+#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"
+
+#define TAG_CXX_CONSTRUCT ".cxx_construct"
+#define TAG_CXX_DESTRUCT ".cxx_destruct"
+
+/* GNU-specific tags. */
-static void val_stack_push (struct val_stack **, long);
-static void val_stack_pop (struct val_stack **);
+#define TAG_EXECCLASS "__objc_exec_class"
+#define TAG_GNUINIT "__objc_gnu_init"
+
+/* Flags for lookup_method_static(). */
+#define OBJC_LOOKUP_CLASS 1 /* Look for class methods. */
+#define OBJC_LOOKUP_NO_SUPER 2 /* Do not examine superclasses. */
/* The OCTI_... enumeration itself is in objc/objc-act.h. */
tree objc_global_trees[OCTI_MAX];
int imp_count = 0; /* `@implementation' */
int cat_count = 0; /* `@category' */
+enum tree_code objc_inherit_code;
+int objc_public_flag;
+
/* Use to generate method labels. */
static int method_slot = 0;
\f
static int flag_typed_selectors;
+/* Store all constructed constant strings in a hash table so that
+ they get uniqued properly. */
+
+struct string_descriptor GTY(())
+{
+ /* The literal argument . */
+ tree literal;
+
+ /* The resulting constant string. */
+ tree constructor;
+};
+
+static GTY((param_is (struct string_descriptor))) htab_t string_htab;
+
+/* Store the EH-volatilized types in a hash table, for easy retrieval. */
+struct volatilized_type GTY(())
+{
+ tree type;
+};
+
+static GTY((param_is (struct volatilized_type))) htab_t volatilized_htab;
+
FILE *gen_declaration_file;
/* Tells "encode_pointer/encode_aggregate" whether we are generating
type = start_struct (RECORD_TYPE, NULL_TREE);
strcpy (buffer, "c1");
- field_decl = create_builtin_decl (FIELD_DECL,
- char_type_node,
- buffer);
+ field_decl = create_field_decl (char_type_node,
+ buffer);
field_decl_chain = field_decl;
for (j = 1; j < i; j++)
{
sprintf (buffer, "c%d", j + 1);
- field_decl = create_builtin_decl (FIELD_DECL,
- char_type_node,
- buffer);
+ field_decl = create_field_decl (char_type_node,
+ buffer);
chainon (field_decl_chain, field_decl);
}
finish_struct (type, field_decl_chain, NULL_TREE);
bool
objc_init (void)
{
+#ifdef OBJCPLUS
+ if (cxx_init () == false)
+#else
if (c_objc_common_init () == false)
+#endif
return false;
+#ifndef USE_MAPPED_LOCATION
/* Force the line number back to 0; check_newline will have
raised it to 1, which will make the builtin functions appear
not to be built in. */
input_line = 0;
+#endif
/* If gen_declaration desired, open the output file. */
if (flag_gen_declaration)
TAG_MSGSENDSUPER = "objc_msgSendSuper";
TAG_MSGSEND_STRET = "objc_msgSend_stret";
TAG_MSGSENDSUPER_STRET = "objc_msgSendSuper_stret";
- TAG_EXECCLASS = "__objc_execClass";
default_constant_string_class_name = "NSConstantString";
}
else
TAG_MSGSENDSUPER = "objc_msg_lookup_super";
/* GNU runtime does not provide special functions to support
structure-returning methods. */
- TAG_EXECCLASS = "__objc_exec_class";
default_constant_string_class_name = "NXConstantString";
flag_typed_selectors = 1;
}
- objc_ellipsis_node = make_node (ERROR_MARK);
-
init_objc ();
if (print_struct_values)
}
void
-finish_file (void)
+objc_finish_file (void)
{
mark_referenced_methods ();
- c_objc_common_finish_file ();
+
+#ifdef OBJCPLUS
+ /* We need to instantiate templates _before_ we emit ObjC metadata;
+ if we do not, some metadata (such as selectors) may go missing. */
+ at_eof = 1;
+ instantiate_pending_templates (0);
+#endif
/* Finalize Objective-C runtime data. No need to generate tables
- and code if only checking syntax. */
- if (!flag_syntax_only)
+ and code if only checking syntax, or if generating a PCH file. */
+ if (!flag_syntax_only && !pch_file)
finish_objc ();
if (gen_declaration_file)
fclose (gen_declaration_file);
+
+#ifdef OBJCPLUS
+ cp_finish_file ();
+#endif
}
\f
-static tree
-define_decl (tree declarator, tree declspecs)
-{
- tree decl = start_decl (declarator, declspecs, 0, NULL_TREE);
- finish_decl (decl, NULL_TREE, NULL_TREE);
- return decl;
-}
-
+/* 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 class_meth)
+ int is_class)
{
tree rproto, p;
tree fnd = 0;
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
- if ((fnd = lookup_method (class_meth
+ if ((fnd = lookup_method (is_class
? PROTOCOL_CLS_METHODS (p)
: PROTOCOL_NST_METHODS (p), sel_name)))
;
else if (PROTOCOL_LIST (p))
fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
- sel_name, class_meth);
+ sel_name, is_class);
}
else
{
return 0;
}
-/* Return 1 if LHS and RHS are compatible types for assignment or
- various other operations. Return 0 if they are incompatible, and
- return -1 if we choose to not decide (because the types are really
- just C types, not ObjC specific ones). When the operation is
- REFLEXIVE (typically comparisons), check for compatibility in
- either direction; when it's not (typically assignments), don't.
-
- This function is called in two cases: when both lhs and rhs are
- pointers to records (in which case we check protocols too), and
- when both lhs and rhs are records (in which case we check class
- inheritance only).
-
- Warnings about classes/protocols not implementing a protocol are
- emitted here (multiple of those warnings might be emitted for a
- single line!); generic warnings about incompatible assignments and
- lacks of casts in comparisons are/must be emitted by the caller if
- we return 0.
-*/
-
-int
-objc_comptypes (tree lhs, tree rhs, int reflexive)
+void
+objc_start_class_interface (tree class, tree super_class, tree protos)
{
- /* New clause for protocols. */
+ objc_interface_context
+ = objc_ivar_context
+ = start_class (CLASS_INTERFACE_TYPE, class, super_class, protos);
+ objc_public_flag = 0;
+}
- /* Here we manage the case of a POINTER_TYPE = POINTER_TYPE. We only
- manage the ObjC ones, and leave the rest to the C code. */
- if (TREE_CODE (lhs) == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (lhs)) == RECORD_TYPE
- && TREE_CODE (rhs) == POINTER_TYPE
- && TREE_CODE (TREE_TYPE (rhs)) == RECORD_TYPE)
- {
- int lhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (lhs);
- int rhs_is_proto = IS_PROTOCOL_QUALIFIED_ID (rhs);
+void
+objc_start_category_interface (tree class, tree categ, tree protos)
+{
+ objc_interface_context
+ = start_class (CATEGORY_INTERFACE_TYPE, class, categ, protos);
+ objc_ivar_chain
+ = continue_class (objc_interface_context);
+}
- if (lhs_is_proto)
- {
- tree lproto, lproto_list = TYPE_PROTOCOL_LIST (lhs);
- tree rproto, rproto_list;
- tree p;
+void
+objc_start_protocol (tree name, tree protos)
+{
+ objc_interface_context
+ = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos);
+}
- /* <Protocol> = <Protocol> */
- if (rhs_is_proto)
- {
- rproto_list = TYPE_PROTOCOL_LIST (rhs);
+void
+objc_continue_interface (void)
+{
+ objc_ivar_chain
+ = continue_class (objc_interface_context);
+}
- if (!reflexive)
- {
- /* An assignment between objects of type 'id
- <Protocol>'; make sure the protocol on the lhs is
- supported by the object on the rhs. */
- for (lproto = lproto_list; lproto;
- lproto = TREE_CHAIN (lproto))
- {
- p = TREE_VALUE (lproto);
- rproto = lookup_protocol_in_reflist (rproto_list, p);
+void
+objc_finish_interface (void)
+{
+ finish_class (objc_interface_context);
+ objc_interface_context = NULL_TREE;
+}
- if (!rproto)
- warning
- ("object does not conform to the `%s' protocol",
- IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
- }
- return 1;
- }
- else
- {
- /* Obscure case - a comparison between two objects
- of type 'id <Protocol>'. Check that either the
- protocol on the lhs is supported by the object on
- the rhs, or viceversa. */
-
- /* Check if the protocol on the lhs is supported by the
- object on the rhs. */
- for (lproto = lproto_list; lproto;
- lproto = TREE_CHAIN (lproto))
- {
- p = TREE_VALUE (lproto);
- rproto = lookup_protocol_in_reflist (rproto_list, p);
-
- if (!rproto)
- {
- /* Check failed - check if the protocol on the rhs
- is supported by the object on the lhs. */
- for (rproto = rproto_list; rproto;
- rproto = TREE_CHAIN (rproto))
- {
- p = TREE_VALUE (rproto);
- lproto = lookup_protocol_in_reflist (lproto_list,
- p);
-
- if (!lproto)
- {
- /* This check failed too: incompatible */
- return 0;
- }
- }
- return 1;
- }
- }
- return 1;
- }
- }
- /* <Protocol> = <class> * */
- else if (TYPED_OBJECT (TREE_TYPE (rhs)))
- {
- tree rname = OBJC_TYPE_NAME (TREE_TYPE (rhs));
- tree rinter;
+void
+objc_start_class_implementation (tree class, tree super_class)
+{
+ objc_implementation_context
+ = objc_ivar_context
+ = start_class (CLASS_IMPLEMENTATION_TYPE, class, super_class, NULL_TREE);
+ objc_public_flag = 0;
+}
- /* Make sure the protocol is supported by the object on
- the rhs. */
- for (lproto = lproto_list; lproto; lproto = TREE_CHAIN (lproto))
- {
- p = TREE_VALUE (lproto);
- rproto = 0;
- rinter = lookup_interface (rname);
+void
+objc_start_category_implementation (tree class, tree categ)
+{
+ objc_implementation_context
+ = start_class (CATEGORY_IMPLEMENTATION_TYPE, class, categ, NULL_TREE);
+ objc_ivar_chain
+ = continue_class (objc_implementation_context);
+}
- while (rinter && !rproto)
- {
- tree cat;
-
- rproto_list = CLASS_PROTOCOL_LIST (rinter);
- rproto = lookup_protocol_in_reflist (rproto_list, p);
- /* If the underlying ObjC class does not have
- the protocol we're looking for, check for "one-off"
- protocols (e.g., `NSObject<MyProt> *foo;') attached
- to the rhs. */
- if (!rproto)
- {
- rproto_list = TYPE_PROTOCOL_LIST (TREE_TYPE (rhs));
- rproto = lookup_protocol_in_reflist (rproto_list, p);
- }
-
- /* Check for protocols adopted by categories. */
- cat = CLASS_CATEGORY_LIST (rinter);
- while (cat && !rproto)
- {
- rproto_list = CLASS_PROTOCOL_LIST (cat);
- rproto = lookup_protocol_in_reflist (rproto_list, p);
- cat = CLASS_CATEGORY_LIST (cat);
- }
-
- rinter = lookup_interface (CLASS_SUPER_NAME (rinter));
- }
+void
+objc_continue_implementation (void)
+{
+ objc_ivar_chain
+ = continue_class (objc_implementation_context);
+}
- if (!rproto)
- warning ("class `%s' does not implement the `%s' protocol",
- IDENTIFIER_POINTER (OBJC_TYPE_NAME (TREE_TYPE (rhs))),
- IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
- }
- return 1;
- }
- /* <Protocol> = id */
- else if (OBJC_TYPE_NAME (TREE_TYPE (rhs)) == objc_object_id)
- {
- return 1;
- }
- /* <Protocol> = Class */
- else if (OBJC_TYPE_NAME (TREE_TYPE (rhs)) == objc_class_id)
- {
- return 0;
- }
- /* <Protocol> = ?? : let comptypes decide. */
- return -1;
- }
- else if (rhs_is_proto)
- {
- /* <class> * = <Protocol> */
- if (TYPED_OBJECT (TREE_TYPE (lhs)))
- {
- if (reflexive)
- {
- tree rname = OBJC_TYPE_NAME (TREE_TYPE (lhs));
- tree rinter;
- tree rproto, rproto_list = TYPE_PROTOCOL_LIST (rhs);
-
- /* Make sure the protocol is supported by the object on
- the lhs. */
- for (rproto = rproto_list; rproto;
- rproto = TREE_CHAIN (rproto))
- {
- tree p = TREE_VALUE (rproto);
- tree lproto = 0;
- rinter = lookup_interface (rname);
-
- while (rinter && !lproto)
- {
- tree cat;
-
- tree lproto_list = CLASS_PROTOCOL_LIST (rinter);
- lproto = lookup_protocol_in_reflist (lproto_list, p);
- /* If the underlying ObjC class does not
- have the protocol we're looking for,
- check for "one-off" protocols (e.g.,
- `NSObject<MyProt> *foo;') attached to the
- lhs. */
- if (!lproto)
- {
- lproto_list = TYPE_PROTOCOL_LIST
- (TREE_TYPE (lhs));
- lproto = lookup_protocol_in_reflist
- (lproto_list, p);
- }
-
- /* Check for protocols adopted by categories. */
- cat = CLASS_CATEGORY_LIST (rinter);
- while (cat && !lproto)
- {
- lproto_list = CLASS_PROTOCOL_LIST (cat);
- lproto = lookup_protocol_in_reflist (lproto_list,
- p);
- cat = CLASS_CATEGORY_LIST (cat);
- }
-
- rinter = lookup_interface (CLASS_SUPER_NAME
- (rinter));
- }
-
- if (!lproto)
- warning ("class `%s' does not implement the `%s' protocol",
- IDENTIFIER_POINTER (OBJC_TYPE_NAME
- (TREE_TYPE (lhs))),
- IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
- }
- return 1;
- }
- else
- return 0;
- }
- /* id = <Protocol> */
- else if (OBJC_TYPE_NAME (TREE_TYPE (lhs)) == objc_object_id)
- {
- return 1;
- }
- /* Class = <Protocol> */
- else if (OBJC_TYPE_NAME (TREE_TYPE (lhs)) == objc_class_id)
- {
- return 0;
- }
- /* ??? = <Protocol> : let comptypes decide */
- else
- {
- return -1;
- }
- }
- else
- {
- /* Attention: we shouldn't defer to comptypes here. One bad
- side effect would be that we might loose the REFLEXIVE
- information.
- */
- lhs = TREE_TYPE (lhs);
- rhs = TREE_TYPE (rhs);
- }
- }
+void
+objc_finish_implementation (void)
+{
+#ifdef OBJCPLUS
+ if (flag_objc_call_cxx_cdtors)
+ objc_generate_cxx_cdtors ();
+#endif
- if (TREE_CODE (lhs) != RECORD_TYPE || TREE_CODE (rhs) != RECORD_TYPE)
+ if (objc_implementation_context)
{
- /* Nothing to do with ObjC - let immediately comptypes take
- responsibility for checking. */
- return -1;
+ 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");
+}
- /* `id' = `<class> *' `<class> *' = `id': always allow it.
- Please note that
- 'Object *o = [[Object alloc] init]; falls
- in the case <class> * = `id'.
- */
- if ((OBJC_TYPE_NAME (lhs) == objc_object_id && TYPED_OBJECT (rhs))
- || (OBJC_TYPE_NAME (rhs) == objc_object_id && TYPED_OBJECT (lhs)))
- return 1;
-
- /* `id' = `Class', `Class' = `id' */
+void
+objc_set_visibility (int visibility)
+{
+ objc_public_flag = visibility;
+}
- else if ((OBJC_TYPE_NAME (lhs) == objc_object_id
- && OBJC_TYPE_NAME (rhs) == objc_class_id)
- || (OBJC_TYPE_NAME (lhs) == objc_class_id
- && OBJC_TYPE_NAME (rhs) == objc_object_id))
- return 1;
+void
+objc_set_method_type (enum tree_code type)
+{
+ objc_inherit_code = (type == PLUS_EXPR
+ ? CLASS_METHOD_DECL
+ : INSTANCE_METHOD_DECL);
+}
- /* `<class> *' = `<class> *' */
+tree
+objc_build_method_signature (tree rettype, tree selector,
+ tree optparms, bool ellipsis)
+{
+ return build_method_decl (objc_inherit_code, rettype, selector,
+ optparms, ellipsis);
+}
- else if (TYPED_OBJECT (lhs) && TYPED_OBJECT (rhs))
- {
- tree lname = OBJC_TYPE_NAME (lhs);
- tree rname = OBJC_TYPE_NAME (rhs);
- tree inter;
+void
+objc_add_method_declaration (tree decl)
+{
+ if (!objc_interface_context)
+ fatal_error ("method declaration not in @interface context");
- if (lname == rname)
- return 1;
+ objc_add_method (objc_interface_context,
+ decl,
+ objc_inherit_code == CLASS_METHOD_DECL);
+}
- /* If the left hand side is a super class of the right hand side,
- allow it. */
- for (inter = lookup_interface (rname); inter;
- inter = lookup_interface (CLASS_SUPER_NAME (inter)))
- if (lname == CLASS_SUPER_NAME (inter))
- return 1;
+void
+objc_start_method_definition (tree decl)
+{
+ if (!objc_implementation_context)
+ fatal_error ("method definition not in @implementation context");
- /* Allow the reverse when reflexive. */
- if (reflexive)
- for (inter = lookup_interface (lname); inter;
- inter = lookup_interface (CLASS_SUPER_NAME (inter)))
- if (rname == CLASS_SUPER_NAME (inter))
- return 1;
+ objc_add_method (objc_implementation_context,
+ decl,
+ objc_inherit_code == CLASS_METHOD_DECL);
+ start_method_def (decl);
+}
- return 0;
- }
- else
- /* Not an ObjC type - let comptypes do the check. */
- return -1;
+void
+objc_add_instance_variable (tree decl)
+{
+ (void) add_instance_variable (objc_ivar_context,
+ objc_public_flag,
+ decl);
}
-/* Called from finish_decl. */
+/* Return 1 if IDENT is an ObjC/ObjC++ reserved keyword in the context of
+ an '@'. */
-void
-objc_check_decl (tree decl)
+int
+objc_is_reserved_word (tree ident)
{
- tree type = TREE_TYPE (decl);
+ unsigned char code = C_RID_CODE (ident);
- if (TREE_CODE (type) != RECORD_TYPE)
- return;
- if (TYPE_NAME (type) && (type = is_class_name (TYPE_NAME (type))))
- error ("statically allocated instance of Objective-C class `%s'",
- IDENTIFIER_POINTER (type));
+ return (OBJC_IS_AT_KEYWORD (code)
+#ifdef OBJCPLUS
+ || code == RID_CLASS || code == RID_PUBLIC
+ || code == RID_PROTECTED || code == RID_PRIVATE
+ || code == RID_TRY || code == RID_THROW || code == RID_CATCH
+#endif
+ );
}
-/* Implement static typing. At this point, we know we have an interface. */
+/* Return true if TYPE is 'id'. */
-tree
-get_static_reference (tree interface, tree protocols)
+static bool
+objc_is_object_id (tree type)
{
- tree type = xref_tag (RECORD_TYPE, interface);
+ return OBJC_TYPE_NAME (type) == objc_object_id;
+}
- if (protocols)
- {
- tree t, m = TYPE_MAIN_VARIANT (type);
+static bool
+objc_is_class_id (tree type)
+{
+ return OBJC_TYPE_NAME (type) == objc_class_id;
+}
- t = copy_node (type);
+/* Construct a C struct with same name as CLASS, a base struct with tag
+ SUPER_NAME (if any), and FIELDS indicated. */
- /* Add this type to the chain of variants of TYPE. */
- TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
- TYPE_NEXT_VARIANT (m) = t;
+static tree
+objc_build_struct (tree class, tree fields, tree super_name)
+{
+ tree name = CLASS_NAME (class);
+ tree s = start_struct (RECORD_TYPE, name);
+ tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE);
+ tree t, objc_info = NULL_TREE;
+
+ 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 (FIELD_DECL, NULL_TREE, super);
+ tree field = TYPE_FIELDS (super);
+
+ while (field && TREE_CHAIN (field)
+ && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
+ field = TREE_CHAIN (field);
+
+ /* For ObjC ABI purposes, the "packed" size of a base class is the
+ 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;
- /* Look up protocols and install in lang specific list. Note
- that the protocol list can have a different lifetime than T! */
- SET_TYPE_PROTOCOL_LIST (t, lookup_and_install_protocols (protocols));
+ if (fields)
+ TREE_NO_WARNING (fields) = 1; /* Suppress C++ ABI warnings -- we */
+#endif /* are following the ObjC ABI here. */
+ TREE_CHAIN (base) = fields;
+ fields = base;
+ }
- /* This forces a new pointer type to be created later
- (in build_pointer_type)...so that the new template
- we just created will actually be used...what a hack! */
- if (TYPE_POINTER_TO (t))
- TYPE_POINTER_TO (t) = NULL_TREE;
+ /* NB: Calling finish_struct() may cause type TYPE_LANG_SPECIFIC fields
+ in all variants of this RECORD_TYPE to be clobbered, but it is therein
+ that we store protocol conformance info (e.g., 'NSObject <MyProtocol>').
+ Hence, we must squirrel away the ObjC-specific information before calling
+ finish_struct(), and then reinstate it afterwards. */
- type = t;
- }
+ for (t = TYPE_NEXT_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t))
+ objc_info
+ = chainon (objc_info,
+ build_tree_list (NULL_TREE, TYPE_OBJC_INFO (t)));
- return type;
-}
+ /* Point the struct at its related Objective-C class. */
+ INIT_TYPE_OBJC_INFO (s);
+ TYPE_OBJC_INTERFACE (s) = class;
-tree
-get_object_reference (tree protocols)
-{
- tree type_decl = lookup_name (objc_id_id);
- tree type;
+ s = finish_struct (s, fields, NULL_TREE);
- if (type_decl && TREE_CODE (type_decl) == TYPE_DECL)
- {
- type = TREE_TYPE (type_decl);
- if (TYPE_MAIN_VARIANT (type) != id_type)
- warning ("unexpected type for `id' (%s)",
- gen_declaration (type, errbuf));
- }
- else
+ for (t = TYPE_NEXT_VARIANT (s); t;
+ t = TYPE_NEXT_VARIANT (t), objc_info = TREE_CHAIN (objc_info))
{
- error ("undefined type `id', please import <objc/objc.h>");
- return error_mark_node;
+ TYPE_OBJC_INFO (t) = TREE_VALUE (objc_info);
+ /* Replace the IDENTIFIER_NODE with an actual @interface. */
+ TYPE_OBJC_INTERFACE (t) = class;
}
- /* This clause creates a new pointer type that is qualified with
- the protocol specification...this info is used later to do more
- elaborate type checking. */
+ /* Use TYPE_BINFO structures to point at the super class, if any. */
+ objc_xref_basetypes (s, super);
- if (protocols)
- {
- tree t, m = TYPE_MAIN_VARIANT (type);
+ /* Mark this struct as a class template. */
+ CLASS_STATIC_TEMPLATE (class) = s;
- t = copy_node (type);
+ return s;
+}
- /* Add this type to the chain of variants of TYPE. */
- TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
- TYPE_NEXT_VARIANT (m) = t;
+/* Build a type differing from TYPE only in that TYPE_VOLATILE is set.
+ Unlike tree.c:build_qualified_type(), preserve TYPE_LANG_SPECIFIC in the
+ process. */
+static tree
+objc_build_volatilized_type (tree type)
+{
+ tree t;
- /* Look up protocols...and install in lang specific list */
- SET_TYPE_PROTOCOL_LIST (t, lookup_and_install_protocols (protocols));
+ /* Check if we have not constructed the desired variant already. */
+ for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
+ {
+ /* The type qualifiers must (obviously) match up. */
+ if (!TYPE_VOLATILE (t)
+ || (TYPE_READONLY (t) != TYPE_READONLY (type))
+ || (TYPE_RESTRICT (t) != TYPE_RESTRICT (type)))
+ continue;
- /* This forces a new pointer type to be created later
- (in build_pointer_type)...so that the new template
- we just created will actually be used...what a hack! */
- if (TYPE_POINTER_TO (t))
- TYPE_POINTER_TO (t) = NULL_TREE;
+ /* For pointer types, the pointees (and hence their TYPE_LANG_SPECIFIC
+ info, if any) must match up. */
+ if (POINTER_TYPE_P (t)
+ && (TREE_TYPE (t) != TREE_TYPE (type)))
+ continue;
- type = t;
+ /* Everything matches up! */
+ return t;
}
- 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. */
+ /* Ok, we could not re-use any of the pre-existing variants. Create
+ a new one. */
+ t = build_variant_type_copy (type);
+ TYPE_VOLATILE (t) = 1;
+
+ return t;
+}
-static void
-check_protocol_recursively (tree proto, tree list)
+/* 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)
{
- tree p;
-
- for (p = list; p; p = TREE_CHAIN (p))
+ /* 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))
{
- tree pp = TREE_VALUE (p);
+ tree t = TREE_TYPE (decl);
+ struct volatilized_type key;
+ void **loc;
- if (TREE_CODE (pp) == IDENTIFIER_NODE)
- pp = lookup_protocol (pp);
+ t = objc_build_volatilized_type (t);
+ key.type = t;
+ loc = htab_find_slot (volatilized_htab, &key, INSERT);
- if (pp == proto)
- fatal_error ("protocol `%s' has circular dependency",
- IDENTIFIER_POINTER (PROTOCOL_NAME (pp)));
- if (pp)
- check_protocol_recursively (proto, PROTOCOL_LIST (pp));
+ if (!*loc)
+ {
+ *loc = ggc_alloc (sizeof (key));
+ ((struct volatilized_type *) *loc)->type = t;
+ }
+
+ 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
}
}
-/* Look up PROTOCOLS, and return a list of those that are found.
- If none are found, return NULL. */
+/* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
+ (including its categoreis and superclasses) or by object type TYP.
+ Issue a warning if PROTO is not adopted anywhere and WARN is set. */
-static tree
-lookup_and_install_protocols (tree protocols)
+static bool
+objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
{
- tree proto;
- tree return_value = NULL_TREE;
+ bool class_type = (cls != NULL_TREE);
- for (proto = protocols; proto; proto = TREE_CHAIN (proto))
+ while (cls)
{
- tree ident = TREE_VALUE (proto);
- tree p = lookup_protocol (ident);
+ tree c;
- if (!p)
- error ("cannot find protocol declaration for `%s'",
- IDENTIFIER_POINTER (ident));
- else
- return_value = chainon (return_value,
- build_tree_list (NULL_TREE, p));
+ /* 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));
}
- return return_value;
+ /* 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)
+ {
+ strcpy (errbuf, class_type ? "class \'" : "type \'");
+ gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
+ strcat (errbuf, "\' does not ");
+ /* NB: Types 'id' and 'Class' cannot reasonably be described as
+ "implementing" a given protocol, since they do not have an
+ implementation. */
+ strcat (errbuf, class_type ? "implement" : "conform to");
+ strcat (errbuf, " the \'");
+ strcat (errbuf, IDENTIFIER_POINTER (PROTOCOL_NAME (proto)));
+ strcat (errbuf, "\' protocol");
+ warning (0, errbuf);
+ }
+
+ return false;
}
-/* Create and push a decl for a built-in external variable or field NAME.
- CODE says which.
- TYPE is its data type. */
+/* Check if class RCLS and instance struct type RTYP conform to at least the
+ same protocols that LCLS and LTYP conform to. */
-static tree
-create_builtin_decl (enum tree_code code, tree type, const char *name)
+static bool
+objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
{
- tree decl = build_decl (code, get_identifier (name), type);
+ tree p;
+ bool have_lproto = false;
- if (code == VAR_DECL)
+ while (lcls)
{
- TREE_STATIC (decl) = 1;
- make_decl_rtl (decl, 0);
- pushdecl (decl);
- DECL_ARTIFICIAL (decl) = 1;
+ /* 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));
}
- return decl;
+ /* 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);
}
-/* Find the decl for the constant string class. */
+/* 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). */
+
+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));
+
+ /* 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.
+ 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. */
+ if ((!lproto && objc_is_object_id (ltyp))
+ || (!rproto && objc_is_object_id (rtyp)))
+ 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)
+ pointers_compatible
+ = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp));
+
+ if (!pointers_compatible)
+ pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
+
+ if (!pointers_compatible && argno == -3)
+ 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)
+ {
+ /* 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 -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;
+}
+
+/* Check if LTYP and RTYP have the same type qualifiers. If either type
+ lives in the volatilized hash table, ignore the 'volatile' bit when
+ making the comparison. */
+
+bool
+objc_type_quals_match (tree ltyp, tree rtyp)
+{
+ int lquals = TYPE_QUALS (ltyp), rquals = TYPE_QUALS (rtyp);
+ struct volatilized_type key;
+
+ key.type = ltyp;
+
+ if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
+ lquals &= ~TYPE_QUAL_VOLATILE;
+
+ key.type = rtyp;
+
+ if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
+ rquals &= ~TYPE_QUAL_VOLATILE;
+
+ return (lquals == rquals);
+}
+
+#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
+
+static 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);
+#else
+ return build_component_ref (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
-setup_string_decl (void)
+objc_xref_basetypes (tree ref, tree basetype)
+{
+ tree binfo = make_tree_binfo (basetype ? 1 : 0);
+
+ TYPE_BINFO (ref) = binfo;
+ BINFO_OFFSET (binfo) = size_zero_node;
+ BINFO_TYPE (binfo) = ref;
+
+ if (basetype)
+ {
+ tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype));
+
+ BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
+ BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1);
+ BINFO_BASE_APPEND (binfo, base_binfo);
+ BINFO_BASE_ACCESS_APPEND (binfo, access_public_node);
+ }
+}
+
+static hashval_t
+volatilized_hash (const void *ptr)
+{
+ tree typ = ((struct volatilized_type *)ptr)->type;
+
+ return htab_hash_pointer(typ);
+}
+
+static int
+volatilized_eq (const void *ptr1, const void *ptr2)
+{
+ tree typ1 = ((struct volatilized_type *)ptr1)->type;
+ tree typ2 = ((struct volatilized_type *)ptr2)->type;
+
+ return typ1 == typ2;
+}
+
+/* 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 %qs",
+ IDENTIFIER_POINTER (type));
+}
+
+/* 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. */
+
+tree
+objc_get_protocol_qualified_type (tree interface, tree protocols)
{
- if (!string_class_decl)
+ /* 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)
{
- if (!constant_string_global_id)
+ type = objc_is_class_name (interface);
+
+ if (type)
+ type = xref_tag (RECORD_TYPE, type);
+ else
+ return interface;
+ }
+
+ 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)
{
- char *name;
- size_t length;
- /* %s in format will provide room for terminating null */
- length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
- + strlen (constant_string_class_name);
- name = xmalloc (length);
- sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
- constant_string_class_name);
- constant_string_global_id = get_identifier (name);
+ TREE_TYPE (type) = build_variant_type_copy (TREE_TYPE (type));
+ TYPE_POINTER_TO (TREE_TYPE (type)) = type;
+ type = TREE_TYPE (type);
}
- string_class_decl = lookup_name (constant_string_global_id);
+
+ /* 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);
+
+ /* 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);
+
+ if (pp == proto)
+ fatal_error ("protocol %qs has circular dependency",
+ IDENTIFIER_POINTER (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. */
+
+static tree
+lookup_and_install_protocols (tree protocols)
+{
+ tree proto;
+ tree return_value = NULL_TREE;
+
+ for (proto = protocols; proto; proto = TREE_CHAIN (proto))
+ {
+ tree ident = TREE_VALUE (proto);
+ tree p = lookup_protocol (ident);
+
+ if (!p)
+ error ("cannot find protocol declaration for %qs",
+ IDENTIFIER_POINTER (ident));
+ else
+ return_value = chainon (return_value,
+ build_tree_list (NULL_TREE, p));
}
+
+ return return_value;
+}
+
+/* Create a declaration for field NAME of a given TYPE. */
+
+static tree
+create_field_decl (tree type, const char *name)
+{
+ return build_decl (FIELD_DECL, get_identifier (name), type);
+}
+
+/* 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. */
+
+static tree
+start_var_decl (tree type, const char *name)
+{
+ tree var = build_decl (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(). */
+
+static void
+finish_var_decl (tree var, tree initializer)
+{
+ finish_decl (var, initializer, NULL_TREE);
+ /* Ensure that the variable actually gets output. */
+ mark_decl_referenced (var);
+ /* Mark the decl to avoid "defined but not used" warning. */
+ TREE_USED (var) = 1;
+}
+
+/* Find the decl for the constant string class reference. This is only
+ used for the NeXT runtime. */
+
+static tree
+setup_string_decl (void)
+{
+ char *name;
+ size_t length;
+
+ /* %s in format will provide room for terminating null */
+ length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
+ + strlen (constant_string_class_name);
+ name = xmalloc (length);
+ sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
+ constant_string_class_name);
+ constant_string_global_id = get_identifier (name);
+ string_class_decl = lookup_name (constant_string_global_id);
+
+ return string_class_decl;
}
/* Purpose: "play" parser, creating/installing representations
static void
synth_module_prologue (void)
{
- tree temp_type;
+ tree type;
+ enum debug_info_type save_write_symbols = write_symbols;
+ const struct gcc_debug_hooks *const save_hooks = debug_hooks;
- /* Defined in `objc.h' */
- objc_object_id = get_identifier (TAG_OBJECT);
+ /* Suppress outputting debug symbols, because
+ dbxout_init hasn'r been called yet. */
+ write_symbols = NO_DEBUG;
+ debug_hooks = &do_nothing_debug_hooks;
- objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c); /* extern "C" */
+#endif
- id_type = build_pointer_type (objc_object_reference);
+ /* The following are also defined in <objc/objc.h> and friends. */
- objc_id_id = get_identifier (TYPE_ID);
+ objc_object_id = get_identifier (TAG_OBJECT);
objc_class_id = get_identifier (TAG_CLASS);
- objc_class_type = build_pointer_type (xref_tag (RECORD_TYPE, objc_class_id));
- temp_type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
- objc_declare_class (tree_cons (NULL_TREE, temp_type, NULL_TREE));
- protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
- temp_type));
-
- /* Declare type of selector-objects that represent an operation name. */
-
- /* `struct objc_selector *' */
- selector_type
- = build_pointer_type (xref_tag (RECORD_TYPE,
- get_identifier (TAG_SELECTOR)));
+ 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);
- /* Forward declare type, or else the prototype for msgSendSuper will
- complain. */
+ objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
+ objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
- /* `struct objc_super *' */
- super_type = build_pointer_type (xref_tag (RECORD_TYPE,
- get_identifier (TAG_SUPER)));
+ /* Declare the 'id' and 'Class' typedefs. */
+ type = lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+ objc_object_name,
+ objc_object_type));
+ DECL_IN_SYSTEM_HEADER (type) = 1;
+ type = lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
+ objc_class_name,
+ objc_class_type));
+ DECL_IN_SYSTEM_HEADER (type) = 1;
- /* id objc_msgSend (id, SEL, ...); */
+ /* Forward-declare '@interface Protocol'. */
- temp_type
- = build_function_type (id_type,
- tree_cons (NULL_TREE, id_type,
- tree_cons (NULL_TREE, selector_type,
- NULL_TREE)));
+ type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
+ objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
+ objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
+ type));
- if (! flag_next_runtime)
- {
- umsg_decl = build_decl (FUNCTION_DECL,
- get_identifier (TAG_MSGSEND), temp_type);
- DECL_EXTERNAL (umsg_decl) = 1;
- TREE_PUBLIC (umsg_decl) = 1;
- DECL_INLINE (umsg_decl) = 1;
- DECL_ARTIFICIAL (umsg_decl) = 1;
+ /* Declare type of selector-objects that represent an operation name. */
- make_decl_rtl (umsg_decl, NULL);
- pushdecl (umsg_decl);
- }
+ if (flag_next_runtime)
+ /* `struct objc_selector *' */
+ objc_selector_type
+ = build_pointer_type (xref_tag (RECORD_TYPE,
+ get_identifier (TAG_SELECTOR)));
else
- {
- umsg_decl = builtin_function (TAG_MSGSEND,
- temp_type, 0, NOT_BUILT_IN,
- NULL, NULL_TREE);
- /* id objc_msgSendNonNil (id, SEL, ...); */
- umsg_nonnil_decl = builtin_function (TAG_MSGSEND_NONNIL,
- temp_type, 0, NOT_BUILT_IN,
- NULL, NULL_TREE);
- }
-
- /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
+ /* `const struct objc_selector *' */
+ objc_selector_type
+ = build_pointer_type
+ (build_qualified_type (xref_tag (RECORD_TYPE,
+ get_identifier (TAG_SELECTOR)),
+ TYPE_QUAL_CONST));
- temp_type
- = build_function_type (id_type,
- tree_cons (NULL_TREE, super_type,
- tree_cons (NULL_TREE, selector_type,
- NULL_TREE)));
-
- umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
- temp_type, 0, NOT_BUILT_IN,
- NULL, NULL_TREE);
-
- /* The NeXT runtime defines the following additional entry points,
- used for dispatching calls to methods returning structs:
-
- #if defined(__cplusplus)
- id objc_msgSend_stret(id self, SEL op, ...);
- id objc_msgSendSuper_stret(struct objc_super *super, SEL op, ...);
- #else
- void objc_msgSend_stret(void * stretAddr, id self, SEL op, ...);
- void objc_msgSendSuper_stret(void * stretAddr, struct objc_super *super,
- SEL op, ...);
- #endif
+ /* Declare receiver type used for dispatching messages to 'super'. */
- struct objc_return_struct objc_msgSendNonNil_stret(id self, SEL op, ...);
+ /* `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)));
- These prototypes appear in <objc/objc-runtime.h>; however, they
- CANNOT BE USED DIRECTLY. In order to call one of the ..._stret
- 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. */
+ /* 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. */
if (flag_next_runtime)
{
- tree objc_return_struct_type
- = xref_tag (RECORD_TYPE,
- get_identifier (TAG_RETURN_STRUCT));
+ /* 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. */
- tree stret_temp_type
- = build_function_type (id_type,
- tree_cons (NULL_TREE, id_type,
- tree_cons (NULL_TREE, selector_type,
+ /* id objc_msgSend (id, SEL, ...); */
+ /* id objc_msgSendNonNil (id, SEL, ...); */
+ /* id objc_msgSend_stret (id, SEL, ...); */
+ /* id objc_msgSendNonNil_stret (id, SEL, ...); */
+ type
+ = build_function_type (objc_object_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_selector_type,
NULL_TREE)));
-
+ umsg_decl = builtin_function (TAG_MSGSEND,
+ type, 0, NOT_BUILT_IN,
+ NULL, NULL_TREE);
+ umsg_nonnil_decl = builtin_function (TAG_MSGSEND_NONNIL,
+ type, 0, NOT_BUILT_IN,
+ NULL, NULL_TREE);
umsg_stret_decl = builtin_function (TAG_MSGSEND_STRET,
- stret_temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
- stret_temp_type
- = build_function_type (objc_return_struct_type,
- tree_cons (NULL_TREE, id_type,
- tree_cons (NULL_TREE, selector_type,
- NULL_TREE)));
-
umsg_nonnil_stret_decl = builtin_function (TAG_MSGSEND_NONNIL_STRET,
- stret_temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
- stret_temp_type
- = build_function_type (id_type,
- tree_cons (NULL_TREE, super_type,
- tree_cons (NULL_TREE, selector_type,
- 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 = 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 availible. */
+ umsg_fast_decl = umsg_decl;
+#endif
+ /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
+ /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
+ type
+ = build_function_type (objc_object_type,
+ tree_cons (NULL_TREE, objc_super_type,
+ tree_cons (NULL_TREE, objc_selector_type,
+ NULL_TREE)));
+ umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
+ type, 0, NOT_BUILT_IN,
+ NULL, NULL_TREE);
umsg_super_stret_decl = builtin_function (TAG_MSGSENDSUPER_STRET,
- stret_temp_type, 0, NOT_BUILT_IN, 0,
+ type, 0, NOT_BUILT_IN, 0,
NULL_TREE);
+ TREE_NOTHROW (umsg_super_decl) = 0;
+ TREE_NOTHROW (umsg_super_stret_decl) = 0;
+ }
+ else
+ {
+ /* GNU runtime messenger entry points. */
+
+ /* typedef id (*IMP)(id, SEL, ...); */
+ tree IMP_type
+ = build_pointer_type
+ (build_function_type (objc_object_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_selector_type,
+ NULL_TREE))));
+
+ /* IMP objc_msg_lookup (id, SEL); */
+ type
+ = build_function_type (IMP_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_selector_type,
+ OBJC_VOID_AT_END)));
+ umsg_decl = 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 (IMP_type,
+ tree_cons (NULL_TREE, objc_super_type,
+ tree_cons (NULL_TREE, objc_selector_type,
+ OBJC_VOID_AT_END)));
+ umsg_super_decl = 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 (void_type_node,
+ tree_cons (NULL_TREE, ptr_type_node,
+ OBJC_VOID_AT_END));
+ execclass_decl = builtin_function (TAG_EXECCLASS,
+ type, 0, NOT_BUILT_IN,
+ NULL, NULL_TREE);
}
/* id objc_getClass (const char *); */
- temp_type = build_function_type (id_type,
+ type = build_function_type (objc_object_type,
tree_cons (NULL_TREE,
const_string_type_node,
OBJC_VOID_AT_END));
objc_get_class_decl
- = builtin_function (TAG_GETCLASS, temp_type, 0, NOT_BUILT_IN,
+ = builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
/* id objc_getMetaClass (const char *); */
objc_get_meta_class_decl
- = builtin_function (TAG_GETMETACLASS, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
+ = builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
+ build_class_template ();
build_super_template ();
+ build_protocol_template ();
+ build_category_template ();
+ build_objc_exception_stuff ();
+
if (flag_next_runtime)
- build_objc_exception_stuff ();
+ build_next_objc_exception_stuff ();
/* static SEL _OBJC_SELECTOR_TABLE[]; */
if (! flag_next_runtime)
- {
- if (flag_typed_selectors)
- {
- /* Suppress outputting debug symbols, because
- dbxout_init hasn'r been called yet. */
- enum debug_info_type save_write_symbols = write_symbols;
- const struct gcc_debug_hooks *const save_hooks = debug_hooks;
- write_symbols = NO_DEBUG;
- debug_hooks = &do_nothing_debug_hooks;
-
- build_selector_template ();
- temp_type = build_array_type (objc_selector_template, NULL_TREE);
-
- write_symbols = save_write_symbols;
- debug_hooks = save_hooks;
- }
- else
- temp_type = build_array_type (selector_type, NULL_TREE);
-
- layout_type (temp_type);
- UOBJC_SELECTOR_TABLE_decl
- = create_builtin_decl (VAR_DECL, temp_type,
- "_OBJC_SELECTOR_TABLE");
-
- /* Avoid warning when not sending messages. */
- TREE_USED (UOBJC_SELECTOR_TABLE_decl) = 1;
- }
-
- generate_forward_declaration_to_string_table ();
+ build_selector_table_decl ();
/* Forward declare constant_string_id and constant_string_type. */
if (!constant_string_class_name)
/* Pre-build the following entities - for speed/convenience. */
self_id = get_identifier ("self");
ucmd_id = get_identifier ("_cmd");
-#ifndef OBJCPLUS
- /* The C++ front-end does not appear to grok __attribute__((__unused__)). */
- unused_list = build_tree_list (get_identifier ("__unused__"), NULL_TREE);
-#endif
+
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif
+
+ write_symbols = save_write_symbols;
+ debug_hooks = save_hooks;
}
/* Ensure that the ivar list for NSConstantString/NXConstantString
static int
check_string_class_template (void)
{
- tree field_decl = TYPE_FIELDS (constant_string_type);
+ 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 (DECL_SIZE (F)) \
+ && (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))
/* 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 (FIELD_DECL, NULL_TREE, ptr_type_node);
+ tree field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
+
+ TREE_CHAIN (field) = fields; fields = field;
+ field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
+ TREE_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! */
static tree
return fix_string_type (build_string (len, str));
}
+/* Build a string with contents STR and length LEN and convert it to a
+ pointer. */
+
+static 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)
+{
+ tree str = ((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)
+{
+ tree str1 = ((struct string_descriptor *)ptr1)->literal;
+ tree str2 = ((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
NXConstantString class object. */
tree
-build_objc_string_object (tree string)
+objc_build_string_object (tree string)
{
tree initlist, constructor, constant_string_class;
int length;
+ tree fields, addr;
+ struct string_descriptor *desc, key;
+ void **loc;
+ /* Prep the string argument. */
string = fix_string_type (string);
-
- constant_string_class = lookup_interface (constant_string_id);
- if (!constant_string_class
- || !(constant_string_type
- = CLASS_STATIC_TEMPLATE (constant_string_class)))
- {
- error ("cannot find interface declaration for `%s'",
- IDENTIFIER_POINTER (constant_string_id));
- return error_mark_node;
- }
-
- /* Call to 'combine_strings' has been moved above. */
TREE_SET_CODE (string, STRING_CST);
length = TREE_STRING_LENGTH (string) - 1;
+ /* Check whether the string class being used actually exists and has the
+ correct ivar layout. */
if (!string_layout_checked)
{
- /* The NSConstantString/NXConstantString ivar layout is now
- known. */
- if (!check_string_class_template ())
- {
- error ("interface `%s' does not have valid constant string layout",
- IDENTIFIER_POINTER (constant_string_id));
- return error_mark_node;
- }
- add_class_reference (constant_string_id);
- }
-
- /* & ((NXConstantString) { NULL, string, length }) */
-
- if (flag_next_runtime)
- {
+ 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 %qs",
+ IDENTIFIER_POINTER (constant_string_id));
+ /* The NSConstantString/NXConstantString ivar layout is now known. */
+ else if (!check_string_class_template ())
+ error ("interface %qs does not have valid constant string layout",
+ IDENTIFIER_POINTER (constant_string_id));
/* For the NeXT runtime, we can generate a literal reference
to the string class, don't need to run a constructor. */
- setup_string_decl ();
- if (string_class_decl == NULL_TREE)
+ else if (flag_next_runtime && !setup_string_decl ())
+ error ("cannot find reference tag for class %qs",
+ IDENTIFIER_POINTER (constant_string_id));
+ else
{
- error ("cannot find reference tag for class `%s'",
- IDENTIFIER_POINTER (constant_string_id));
- return error_mark_node;
+ string_layout_checked = 1; /* Success! */
+ add_class_reference (constant_string_id);
}
- initlist = build_tree_list
- (NULL_TREE,
- copy_node (build_unary_op (ADDR_EXPR, string_class_decl, 0)));
- }
- else
- {
- initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
}
- initlist
- = tree_cons (NULL_TREE, copy_node (build_unary_op (ADDR_EXPR, string, 1)),
- initlist);
- initlist = tree_cons (NULL_TREE, build_int_2 (length, 0), initlist);
- constructor = objc_build_constructor (constant_string_type,
- nreverse (initlist));
+ if (string_layout_checked == -1)
+ return error_mark_node;
- if (!flag_next_runtime)
+ /* Perhaps we already constructed a constant string just like this one? */
+ key.literal = string;
+ loc = htab_find_slot (string_htab, &key, INSERT);
+ desc = *loc;
+
+ if (!desc)
{
- constructor
- = objc_add_static_instance (constructor, constant_string_type);
+ tree var;
+ *loc = desc = ggc_alloc (sizeof (*desc));
+ desc->literal = string;
+
+ /* GNU: (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length }) */
+ /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */
+ fields = TYPE_FIELDS (internal_const_str_type);
+ initlist
+ = build_tree_list (fields,
+ flag_next_runtime
+ ? build_unary_op (ADDR_EXPR, string_class_decl, 0)
+ : build_int_cst (NULL_TREE, 0));
+ fields = TREE_CHAIN (fields);
+ initlist = tree_cons (fields, build_unary_op (ADDR_EXPR, string, 1),
+ initlist);
+ fields = TREE_CHAIN (fields);
+ initlist = tree_cons (fields, build_int_cst (NULL_TREE, length),
+ initlist);
+ constructor = objc_build_constructor (internal_const_str_type,
+ nreverse (initlist));
+ TREE_INVARIANT (constructor) = true;
+
+ if (!flag_next_runtime)
+ constructor
+ = objc_add_static_instance (constructor, constant_string_type);
+ else
+ {
+ var = build_decl (CONST_DECL, NULL, TREE_TYPE (constructor));
+ DECL_INITIAL (var) = constructor;
+ TREE_STATIC (var) = 1;
+ pushdecl_top_level (var);
+ constructor = var;
+ }
+ desc->constructor = constructor;
}
- return (build_unary_op (ADDR_EXPR, constructor, 1));
+ addr = convert (build_pointer_type (constant_string_type),
+ build_unary_op (ADDR_EXPR, desc->constructor, 1));
+
+ return addr;
}
/* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR. */
Postpone till end of input. */
DECL_DEFER_OUTPUT (decl) = 1;
pushdecl_top_level (decl);
- rest_of_decl_compilation (decl, 0, 1, 0);
+ 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));
static tree
objc_build_constructor (tree type, tree elts)
{
- tree constructor, f, e;
-
- /* ??? Most of the places that we build constructors, we don't fill in
- the type of integers properly. Convert them all en masse. */
- if (TREE_CODE (type) == ARRAY_TYPE)
- {
- f = TREE_TYPE (type);
- if (TREE_CODE (f) == POINTER_TYPE || TREE_CODE (f) == INTEGER_TYPE)
- for (e = elts; e ; e = TREE_CHAIN (e))
- TREE_VALUE (e) = convert (f, TREE_VALUE (e));
- }
- else
- {
- f = TYPE_FIELDS (type);
- for (e = elts; e && f; e = TREE_CHAIN (e), f = TREE_CHAIN (f))
- if (TREE_CODE (TREE_TYPE (f)) == POINTER_TYPE
- || TREE_CODE (TREE_TYPE (f)) == INTEGER_TYPE)
- TREE_VALUE (e) = convert (TREE_TYPE (f), TREE_VALUE (e));
- }
+ tree constructor = build_constructor_from_list (type, elts);
- constructor = build_constructor (type, elts);
TREE_CONSTANT (constructor) = 1;
TREE_STATIC (constructor) = 1;
TREE_READONLY (constructor) = 1;
#ifdef OBJCPLUS
- /* zlaski 2001-Apr-02: mark this as a call to a constructor, as required by
- build_unary_op (wasn't true in 2.7.2.1 days) */
+ /* Adjust for impedance mismatch. We should figure out how to build
+ CONSTRUCTORs that consistently please both the C and C++ gods. */
+ if (!TREE_PURPOSE (elts))
+ TREE_TYPE (constructor) = NULL_TREE;
TREE_HAS_CONSTRUCTOR (constructor) = 1;
#endif
+
return constructor;
}
\f
= start_struct (RECORD_TYPE, get_identifier (UTAG_SYMTAB));
/* long sel_ref_cnt; */
-
- field_decl = create_builtin_decl (FIELD_DECL,
- long_integer_type_node,
- "sel_ref_cnt");
+ field_decl = create_field_decl (long_integer_type_node, "sel_ref_cnt");
field_decl_chain = field_decl;
/* SEL *refs; */
-
- field_decl = create_builtin_decl (FIELD_DECL,
- build_pointer_type (selector_type),
- "refs");
+ field_decl = create_field_decl (build_pointer_type (objc_selector_type),
+ "refs");
chainon (field_decl_chain, field_decl);
/* short cls_def_cnt; */
-
- field_decl = create_builtin_decl (FIELD_DECL,
- short_integer_type_node,
- "cls_def_cnt");
+ field_decl = create_field_decl (short_integer_type_node, "cls_def_cnt");
chainon (field_decl_chain, field_decl);
/* short cat_def_cnt; */
-
- field_decl = create_builtin_decl (FIELD_DECL,
- short_integer_type_node,
- "cat_def_cnt");
+ field_decl = create_field_decl (short_integer_type_node,
+ "cat_def_cnt");
chainon (field_decl_chain, field_decl);
if (imp_count || cat_count || !flag_next_runtime)
/* NB: The index is one less than the size of the array. */
int index = imp_count + cat_count
+ (flag_next_runtime? -1: 0);
- field_decl = create_builtin_decl
- (FIELD_DECL,
- build_array_type
+ field_decl = create_field_decl
+ (build_array_type
(ptr_type_node,
- build_index_type (build_int_2 (index, 0))),
+ build_index_type (build_int_cst (NULL_TREE, index))),
"defs");
chainon (field_decl_chain, field_decl);
}
if (static_instances_decl)
expr = build_unary_op (ADDR_EXPR, static_instances_decl, 0);
else
- expr = build_int_2 (0, 0);
+ expr = build_int_cst (NULL_TREE, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* sel_ref_cnt = { ..., 5, ... } */
- initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
+ initlist = build_tree_list (NULL_TREE,
+ build_int_cst (long_integer_type_node, 0));
/* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
if (flag_next_runtime || ! sel_ref_chain)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
- initlist = tree_cons (NULL_TREE,
- build_unary_op (ADDR_EXPR,
- UOBJC_SELECTOR_TABLE_decl, 1),
- initlist);
+ initlist
+ = tree_cons (NULL_TREE,
+ convert (build_pointer_type (objc_selector_type),
+ build_unary_op (ADDR_EXPR,
+ UOBJC_SELECTOR_TABLE_decl, 1)),
+ initlist);
/* cls_def_cnt = { ..., 5, ... } */
- initlist = tree_cons (NULL_TREE, build_int_2 (imp_count, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, imp_count), initlist);
/* cat_def_cnt = { ..., 5, ... } */
- initlist = tree_cons (NULL_TREE, build_int_2 (cat_count, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, cat_count), initlist);
/* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
static tree
build_metadata_decl (const char *name, tree type)
{
- tree decl, decl_specs;
- /* extern struct TYPE NAME_<name>; */
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]);
- decl_specs = tree_cons (NULL_TREE, type, decl_specs);
- decl = define_decl (synth_id_with_class_suffix
- (name,
- objc_implementation_context),
- decl_specs);
- TREE_USED (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- TREE_PUBLIC (decl) = 0;
+ tree decl;
+
+ /* struct TYPE NAME_<name>; */
+ decl = start_var_decl (type, synth_id_with_class_suffix
+ (name,
+ objc_implementation_context));
+
return decl;
}
objc_implementation_context = impent->imp_context;
/* extern struct objc_category _OBJC_CATEGORY_<name>; */
impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
- objc_category_template);
+ objc_category_template);
}
}
objc_implementation_context = sav;
static void
generate_objc_symtab_decl (void)
{
- tree sc_spec;
-
- if (!objc_category_template)
- build_category_template ();
-
/* forward declare categories */
if (cat_count)
forward_declare_categories ();
- if (!objc_symtab_template)
- build_objc_symtab_template ();
-
- sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
-
- UOBJC_SYMBOLS_decl = start_decl (get_identifier ("_OBJC_SYMBOLS"),
- tree_cons (NULL_TREE,
- objc_symtab_template, sc_spec),
- 1,
- NULL_TREE);
-
- TREE_USED (UOBJC_SYMBOLS_decl) = 1;
- DECL_IGNORED_P (UOBJC_SYMBOLS_decl) = 1;
- DECL_ARTIFICIAL (UOBJC_SYMBOLS_decl) = 1;
- finish_decl (UOBJC_SYMBOLS_decl,
- init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)),
- NULL_TREE);
+ build_objc_symtab_template ();
+ UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS");
+ finish_var_decl (UOBJC_SYMBOLS_decl,
+ init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
}
\f
static tree
/* version = { 1, ... } */
- expr = build_int_2 (OBJC_VERSION, 0);
+ expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
initlist = build_tree_list (NULL_TREE, expr);
- /* size = { ..., sizeof (struct objc_module), ... } */
+ /* size = { ..., sizeof (struct _objc_module), ... } */
- expr = size_in_bytes (objc_module_template);
+ expr = convert (long_integer_type_node,
+ size_in_bytes (objc_module_template));
initlist = tree_cons (NULL_TREE, expr, initlist);
/* name = { ..., "foo.m", ... } */
if (UOBJC_SYMBOLS_decl)
expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
else
- expr = build_int_2 (0, 0);
+ expr = build_int_cst (NULL_TREE, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
return objc_build_constructor (type, nreverse (initlist));
}
/* Write out the data structures to describe Objective C classes defined.
- If appropriate, compile and output a setup function to initialize them.
- Return a symbol_ref to the function to call to initialize the Objective C
- data structures for this file (and perhaps for other files also).
- struct objc_module { ... } _OBJC_MODULE = { ... }; */
+ struct _objc_module { ... } _OBJC_MODULE = { ... }; */
-static rtx
+static void
build_module_descriptor (void)
{
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
+
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c); /* extern "C" */
+#endif
objc_module_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_MODULE));
- /* Long version; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
- field_decl = get_identifier ("version");
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* long version; */
+ field_decl = create_field_decl (long_integer_type_node, "version");
field_decl_chain = field_decl;
- /* long size; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
- field_decl = get_identifier ("size");
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* long size; */
+ field_decl = create_field_decl (long_integer_type_node, "size");
chainon (field_decl_chain, field_decl);
- /* char *name; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("name"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* char *name; */
+ field_decl = create_field_decl (string_type_node, "name");
chainon (field_decl_chain, field_decl);
- /* struct objc_symtab *symtab; */
-
- decl_specs = get_identifier (UTAG_SYMTAB);
- decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE, decl_specs));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("symtab"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_symtab *symtab; */
+ field_decl
+ = create_field_decl (build_pointer_type
+ (xref_tag (RECORD_TYPE,
+ get_identifier (UTAG_SYMTAB))),
+ "symtab");
chainon (field_decl_chain, field_decl);
finish_struct (objc_module_template, field_decl_chain, NULL_TREE);
- /* Create an instance of "objc_module". */
+ /* Create an instance of "_objc_module". */
+ UOBJC_MODULES_decl = start_var_decl (objc_module_template, "_OBJC_MODULES");
+ finish_var_decl (UOBJC_MODULES_decl,
+ init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)));
- decl_specs = tree_cons (NULL_TREE, objc_module_template,
- build_tree_list (NULL_TREE,
- ridpointers[(int) RID_STATIC]));
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif
+}
- UOBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"),
- decl_specs, 1, NULL_TREE);
+/* The GNU runtime requires us to provide a static initializer function
+ for each module:
- DECL_ARTIFICIAL (UOBJC_MODULES_decl) = 1;
- DECL_IGNORED_P (UOBJC_MODULES_decl) = 1;
- DECL_CONTEXT (UOBJC_MODULES_decl) = NULL_TREE;
+ static void __objc_gnu_init (void) {
+ __objc_exec_class (&L_OBJC_MODULES);
+ } */
- finish_decl (UOBJC_MODULES_decl,
- init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)),
- NULL_TREE);
+static void
+build_module_initializer_routine (void)
+{
+ tree body;
- /* Mark the decl to avoid "defined but not used" warning. */
- DECL_IN_SYSTEM_HEADER (UOBJC_MODULES_decl) = 1;
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c); /* extern "C" */
+#endif
+
+ objc_push_parm (build_decl (PARM_DECL, NULL_TREE, void_type_node));
+ objc_start_function (get_identifier (TAG_GNUINIT),
+ build_function_type (void_type_node,
+ OBJC_VOID_AT_END),
+ NULL_TREE, objc_get_parm_info (0));
+
+ body = c_begin_compound_stmt (true);
+ add_stmt (build_function_call
+ (execclass_decl,
+ build_tree_list
+ (NULL_TREE,
+ build_unary_op (ADDR_EXPR,
+ UOBJC_MODULES_decl, 0))));
+ add_stmt (c_end_compound_stmt (body, true));
+
+ TREE_PUBLIC (current_function_decl) = 0;
- /* Generate a constructor call for the module descriptor.
- This code was generated by reading the grammar rules
- of c-parse.in; Therefore, it may not be the most efficient
- way of generating the requisite code. */
+#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
- if (flag_next_runtime)
- return NULL_RTX;
+ GNU_INIT_decl = current_function_decl;
+ finish_function ();
- {
- tree parms, execclass_decl, decelerator, void_list_node_1;
- tree init_function_name, init_function_decl;
-
- /* Declare void __objc_execClass (void *); */
-
- void_list_node_1 = build_tree_list (NULL_TREE, void_type_node);
- execclass_decl = build_decl (FUNCTION_DECL,
- get_identifier (TAG_EXECCLASS),
- build_function_type (void_type_node,
- tree_cons (NULL_TREE, ptr_type_node,
- OBJC_VOID_AT_END)));
-
- DECL_EXTERNAL (execclass_decl) = 1;
- DECL_ARTIFICIAL (execclass_decl) = 1;
- TREE_PUBLIC (execclass_decl) = 1;
- pushdecl (execclass_decl);
- rest_of_decl_compilation (execclass_decl, 0, 0, 0);
- assemble_external (execclass_decl);
-
- /* void _GLOBAL_$I$<gnyf> () {objc_execClass (&L_OBJC_MODULES);} */
-
- init_function_name = get_file_function_name ('I');
- start_function (void_list_node_1,
- build_nt (CALL_EXPR, init_function_name,
- tree_cons (NULL_TREE, NULL_TREE,
- OBJC_VOID_AT_END),
- NULL_TREE),
- NULL_TREE);
- store_parm_decls ();
-
- init_function_decl = current_function_decl;
- TREE_PUBLIC (init_function_decl) = ! targetm.have_ctors_dtors;
- TREE_USED (init_function_decl) = 1;
- /* Don't let this one be deferred. */
- DECL_INLINE (init_function_decl) = 0;
- DECL_UNINLINABLE (init_function_decl) = 1;
- current_function_cannot_inline
- = "static constructors and destructors cannot be inlined";
-
- parms
- = build_tree_list (NULL_TREE,
- build_unary_op (ADDR_EXPR, UOBJC_MODULES_decl, 0));
- decelerator = build_function_call (execclass_decl, parms);
-
- c_expand_expr_stmt (decelerator);
-
- finish_function ();
-
- return XEXP (DECL_RTL (init_function_decl), 0);
- }
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif
}
-/* extern const char _OBJC_STRINGS[]; */
+#ifdef OBJCPLUS
+/* Return 1 if the __objc_gnu_init function has been synthesized and needs
+ to be called by the module initializer routine. */
-static void
-generate_forward_declaration_to_string_table (void)
+int
+objc_static_init_needed_p (void)
{
- tree sc_spec, decl_specs, expr_decl;
+ return (GNU_INIT_decl != NULL_TREE);
+}
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_EXTERN], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
+/* Generate a call to the __objc_gnu_init initializer function. */
- expr_decl
- = build_nt (ARRAY_REF, get_identifier ("_OBJC_STRINGS"), NULL_TREE);
+tree
+objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
+{
+ add_stmt (build_stmt (EXPR_STMT,
+ build_function_call (GNU_INIT_decl, NULL_TREE)));
- UOBJC_STRINGS_decl = define_decl (expr_decl, decl_specs);
+ return ctors;
}
+#endif /* OBJCPLUS */
/* Return the DECL of the string IDENT in the SECTION. */
static void
generate_static_references (void)
{
- tree decls = NULL_TREE, ident, decl_spec, expr_decl, expr = NULL_TREE;
+ tree decls = NULL_TREE, expr = NULL_TREE;
tree class_name, class, decl, initlist;
- tree cl_chain, in_chain, type;
+ tree cl_chain, in_chain, type
+ = build_array_type (build_pointer_type (void_type_node), NULL_TREE);
int num_inst, num_class;
char buf[256];
in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
- ident = get_identifier (buf);
-
- expr_decl = build_nt (ARRAY_REF, ident, NULL_TREE);
- decl_spec = tree_cons (NULL_TREE, build_pointer_type (void_type_node),
- build_tree_list (NULL_TREE,
- ridpointers[(int) RID_STATIC]));
- decl = start_decl (expr_decl, decl_spec, 1, NULL_TREE);
- DECL_CONTEXT (decl) = 0;
- DECL_ARTIFICIAL (decl) = 1;
+ decl = start_var_decl (type, buf);
/* Output {class_name, ...}. */
class = TREE_VALUE (cl_chain);
}
/* Output {..., NULL}. */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
- finish_decl (decl, expr, NULL_TREE);
- TREE_USED (decl) = 1;
-
- type = build_array_type (build_pointer_type (void_type_node), 0);
- decl = build_decl (VAR_DECL, ident, type);
- TREE_USED (decl) = 1;
- TREE_STATIC (decl) = 1;
+ finish_var_decl (decl, expr);
decls
= tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, decl, 1), decls);
}
- decls = tree_cons (NULL_TREE, build_int_2 (0, 0), decls);
- ident = get_identifier ("_OBJC_STATIC_INSTANCES");
- expr_decl = build_nt (ARRAY_REF, ident, NULL_TREE);
- decl_spec = tree_cons (NULL_TREE, build_pointer_type (void_type_node),
- build_tree_list (NULL_TREE,
- ridpointers[(int) RID_STATIC]));
- static_instances_decl
- = start_decl (expr_decl, decl_spec, 1, NULL_TREE);
- TREE_USED (static_instances_decl) = 1;
- DECL_CONTEXT (static_instances_decl) = 0;
- DECL_ARTIFICIAL (static_instances_decl) = 1;
- expr = objc_build_constructor (TREE_TYPE (static_instances_decl),
- nreverse (decls));
- finish_decl (static_instances_decl, expr, NULL_TREE);
-}
-
-/* Output all strings. */
-
-static void
-generate_strings (void)
-{
- tree sc_spec, decl_specs, expr_decl;
- tree chain, string_expr;
- tree string, decl;
-
- for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain))
- {
- string = TREE_VALUE (chain);
- decl = TREE_PURPOSE (chain);
- sc_spec
- = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
- expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
- decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (decl) = NULL_TREE;
- string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
- IDENTIFIER_POINTER (string));
- finish_decl (decl, string_expr, NULL_TREE);
- }
-
- for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain))
- {
- string = TREE_VALUE (chain);
- decl = TREE_PURPOSE (chain);
- sc_spec
- = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
- expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
- decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (decl) = NULL_TREE;
- string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
- IDENTIFIER_POINTER (string));
- finish_decl (decl, string_expr, NULL_TREE);
- }
-
- for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain))
- {
- string = TREE_VALUE (chain);
- decl = TREE_PURPOSE (chain);
- sc_spec
- = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], sc_spec);
- expr_decl = build_nt (ARRAY_REF, DECL_NAME (decl), NULL_TREE);
- decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (decl) = NULL_TREE;
- string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
- IDENTIFIER_POINTER (string));
- finish_decl (decl, string_expr, NULL_TREE);
- }
+ decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), decls);
+ expr = objc_build_constructor (type, nreverse (decls));
+ static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
+ finish_var_decl (static_instances_decl, expr);
}
static GTY(()) int selector_reference_idx;
static tree
build_selector_reference_decl (void)
{
- tree decl, ident;
+ tree decl;
char buf[256];
sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
+ decl = start_var_decl (objc_selector_type, buf);
- ident = get_identifier (buf);
+ return decl;
+}
- decl = build_decl (VAR_DECL, ident, selector_type);
- DECL_EXTERNAL (decl) = 1;
- TREE_PUBLIC (decl) = 0;
- TREE_USED (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
- DECL_CONTEXT (decl) = 0;
+static void
+build_selector_table_decl (void)
+{
+ tree temp;
- make_decl_rtl (decl, 0);
- pushdecl_top_level (decl);
+ if (flag_typed_selectors)
+ {
+ build_selector_template ();
+ temp = build_array_type (objc_selector_template, NULL_TREE);
+ }
+ else
+ temp = build_array_type (objc_selector_type, NULL_TREE);
- return decl;
+ UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
}
/* Just a handy wrapper for add_objc_string. */
static tree
build_selector (tree ident)
{
- tree expr = add_objc_string (ident, meth_var_names);
- if (flag_typed_selectors)
- return expr;
- else
- return build_c_cast (selector_type, expr); /* cast! */
+ return convert (objc_selector_type,
+ add_objc_string (ident, meth_var_names));
}
static void
build_selector_translation_table (void)
{
- tree sc_spec, decl_specs;
tree chain, initlist = NULL_TREE;
int offset = 0;
- tree decl = NULL_TREE, var_decl, name;
+ tree decl = NULL_TREE;
for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
{
}
}
if (!found)
- {
- /* Adjust line number for warning message. */
- int save_lineno = input_line;
- if (flag_next_runtime && TREE_PURPOSE (chain))
- input_line = DECL_SOURCE_LINE (TREE_PURPOSE (chain));
- warning ("creating selector for non existant method %s",
- IDENTIFIER_POINTER (TREE_VALUE (chain)));
- input_line = save_lineno;
- }
+ {
+ location_t *loc;
+ if (flag_next_runtime && TREE_PURPOSE (chain))
+ loc = &DECL_SOURCE_LOCATION (TREE_PURPOSE (chain));
+ else
+ loc = &input_location;
+ warning (0, "%Hcreating selector for nonexistent method %qE",
+ loc, TREE_VALUE (chain));
+ }
}
expr = build_selector (TREE_VALUE (chain));
-
- if (flag_next_runtime)
- {
- name = DECL_NAME (TREE_PURPOSE (chain));
-
- sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
-
- /* static SEL _OBJC_SELECTOR_REFERENCES_n = ...; */
- decl_specs = tree_cons (NULL_TREE, selector_type, sc_spec);
-
- var_decl = name;
-
- /* The `decl' that is returned from start_decl is the one that we
- forward declared in `build_selector_reference' */
- decl = start_decl (var_decl, decl_specs, 1, NULL_TREE );
- }
-
/* add one for the '\0' character */
offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
if (flag_next_runtime)
- finish_decl (decl, expr, NULL_TREE);
+ {
+ decl = TREE_PURPOSE (chain);
+ finish_var_decl (decl, expr);
+ }
else
{
if (flag_typed_selectors)
expr = objc_build_constructor (objc_selector_template,
nreverse (eltlist));
}
- initlist = tree_cons (NULL_TREE, expr, initlist);
+ initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (! flag_next_runtime)
{
- /* Cause the variable and its initial value to be actually output. */
- DECL_EXTERNAL (UOBJC_SELECTOR_TABLE_decl) = 0;
- TREE_STATIC (UOBJC_SELECTOR_TABLE_decl) = 1;
- /* NULL terminate the list and fix the decl for output. */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
- DECL_INITIAL (UOBJC_SELECTOR_TABLE_decl) = objc_ellipsis_node;
+ /* Cause the selector table (previously forward-declared)
+ to be actually output. */
+ initlist = tree_cons (NULL_TREE,
+ flag_typed_selectors
+ ? objc_build_constructor
+ (objc_selector_template,
+ tree_cons (NULL_TREE,
+ build_int_cst (NULL_TREE, 0),
+ tree_cons (NULL_TREE,
+ build_int_cst (NULL_TREE, 0),
+ NULL_TREE)))
+ : build_int_cst (NULL_TREE, 0), initlist);
initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
nreverse (initlist));
- finish_decl (UOBJC_SELECTOR_TABLE_decl, initlist, NULL_TREE);
- current_function_decl = NULL_TREE;
+ finish_var_decl (UOBJC_SELECTOR_TABLE_decl, initlist);
}
}
return add_objc_string (encoding, meth_var_types);
}
else
- return build_int_2 (0, 0);
+ return build_int_cst (NULL_TREE, 0);
}
/* sel_ref_chain is a list whose "value" fields will be instances of
return_at_index:
expr = build_unary_op (ADDR_EXPR,
build_array_ref (UOBJC_SELECTOR_TABLE_decl,
- build_int_2 (index, 0)),
+ build_int_cst (NULL_TREE, index)),
1);
- return build_c_cast (selector_type, expr);
+ return convert (objc_selector_type, expr);
}
static tree
return (flag_next_runtime
? TREE_PURPOSE (*chain)
: build_array_ref (UOBJC_SELECTOR_TABLE_decl,
- build_int_2 (index, 0)));
+ build_int_cst (NULL_TREE, index)));
index++;
chain = &TREE_CHAIN (*chain);
}
- expr = build_selector_reference_decl ();
+ expr = (flag_next_runtime ? build_selector_reference_decl (): NULL_TREE);
*chain = tree_cons (expr, ident, NULL_TREE);
return (flag_next_runtime
? expr
: build_array_ref (UOBJC_SELECTOR_TABLE_decl,
- build_int_2 (index, 0)));
+ build_int_cst (NULL_TREE, index)));
}
static GTY(()) int class_reference_idx;
static tree
build_class_reference_decl (void)
{
- tree decl, ident;
+ tree decl;
char buf[256];
sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
-
- ident = get_identifier (buf);
-
- decl = build_decl (VAR_DECL, ident, objc_class_type);
- DECL_EXTERNAL (decl) = 1;
- TREE_PUBLIC (decl) = 0;
- TREE_USED (decl) = 1;
- DECL_CONTEXT (decl) = 0;
- DECL_ARTIFICIAL (decl) = 1;
-
- make_decl_rtl (decl, 0);
- pushdecl_top_level (decl);
+ decl = start_var_decl (objc_class_type, buf);
return decl;
}
reference variable. */
tree
-get_class_reference (tree ident)
+objc_get_class_reference (tree ident)
{
- tree orig_ident;
+ tree orig_ident = (DECL_P (ident)
+ ? DECL_NAME (ident)
+ : TYPE_P (ident)
+ ? OBJC_TYPE_NAME (ident)
+ : ident);
+ bool local_scope = false;
#ifdef OBJCPLUS
if (processing_template_decl)
/* Must wait until template instantiation time. */
return build_min_nt (CLASS_REFERENCE_EXPR, ident);
+#endif
+
if (TREE_CODE (ident) == TYPE_DECL)
- ident = DECL_NAME (ident);
+ ident = (DECL_ORIGINAL_TYPE (ident)
+ ? DECL_ORIGINAL_TYPE (ident)
+ : TREE_TYPE (ident));
+
+#ifdef OBJCPLUS
+ if (TYPE_P (ident) && TYPE_CONTEXT (ident)
+ && TYPE_CONTEXT (ident) != global_namespace)
+ local_scope = true;
#endif
- orig_ident = ident;
- if (!(ident = is_class_name (ident)))
+ if (local_scope || !(ident = objc_is_class_name (ident)))
{
- error ("`%s' is not an Objective-C class name or alias",
+ error ("%qs is not an Objective-C class name or alias",
IDENTIFIER_POINTER (orig_ident));
return error_mark_node;
}
add_class_reference (ident);
params = build_tree_list (NULL_TREE,
- my_build_string (IDENTIFIER_LENGTH (ident) + 1,
- IDENTIFIER_POINTER (ident)));
+ my_build_string_pointer
+ (IDENTIFIER_LENGTH (ident) + 1,
+ IDENTIFIER_POINTER (ident)));
assemble_external (objc_get_class_decl);
return build_function_call (objc_get_class_decl, params);
static tree
add_objc_string (tree ident, enum string_section section)
{
- tree *chain, decl;
+ tree *chain, decl, type, string_expr;
if (section == class_names)
chain = &class_names_chain;
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
- return build_unary_op (ADDR_EXPR, TREE_PURPOSE (*chain), 1);
+ return convert (string_type_node,
+ build_unary_op (ADDR_EXPR, TREE_PURPOSE (*chain), 1));
chain = &TREE_CHAIN (*chain);
}
decl = build_objc_string_decl (section);
+
+ type = build_array_type
+ (char_type_node,
+ build_index_type
+ (build_int_cst (NULL_TREE,
+ IDENTIFIER_LENGTH (ident))));
+ decl = start_var_decl (type, IDENTIFIER_POINTER (DECL_NAME (decl)));
+ string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
+ IDENTIFIER_POINTER (ident));
+ finish_var_decl (decl, string_expr);
*chain = tree_cons (decl, ident, NULL_TREE);
- return build_unary_op (ADDR_EXPR, decl, 1);
+ return convert (string_type_node, build_unary_op (ADDR_EXPR, decl, 1));
}
static GTY(()) int class_names_idx;
TREE_CONSTANT (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
+#ifdef OBJCPLUS
+ DECL_THIS_STATIC (decl) = 1; /* squash redeclaration errors */
+#endif
- make_decl_rtl (decl, 0);
+ make_decl_rtl (decl);
pushdecl_top_level (decl);
return decl;
}
#endif /* OBJCPLUS */
- if (!(underlying_class = is_class_name (class_ident)))
- warning ("cannot find class `%s'", IDENTIFIER_POINTER (class_ident));
- else if (is_class_name (alias_ident))
- warning ("class `%s' already exists", IDENTIFIER_POINTER (alias_ident));
+ if (!(underlying_class = objc_is_class_name (class_ident)))
+ warning (0, "cannot find class %qs", IDENTIFIER_POINTER (class_ident));
+ else if (objc_is_class_name (alias_ident))
+ warning (0, "class %qs already exists", IDENTIFIER_POINTER (alias_ident));
else
- alias_chain = tree_cons (underlying_class, alias_ident, alias_chain);
+ {
+ /* Implement @compatibility_alias as a typedef. */
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c); /* extern "C" */
+#endif
+ lang_hooks.decls.pushdecl (build_decl
+ (TYPE_DECL,
+ alias_ident,
+ xref_tag (RECORD_TYPE, underlying_class)));
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif
+ alias_chain = tree_cons (underlying_class, alias_ident, alias_chain);
+ }
}
void
{
tree ident = TREE_VALUE (list);
- if (! is_class_name (ident))
+ if (! objc_is_class_name (ident))
{
- tree record = lookup_name (ident);
-
- if (record && ! TREE_STATIC_TEMPLATE (record))
+ tree record = lookup_name (ident), type = record;
+
+ if (record)
{
- error ("`%s' redeclared as different kind of symbol",
- IDENTIFIER_POINTER (ident));
- error ("%Jprevious declaration of '%D'",
- record, record);
+ if (TREE_CODE (record) == TYPE_DECL)
+ type = DECL_ORIGINAL_TYPE (record);
+
+ if (!TYPE_HAS_OBJC_INFO (type)
+ || !TYPE_OBJC_INTERFACE (type))
+ {
+ error ("%qs redeclared as different kind of symbol",
+ IDENTIFIER_POINTER (ident));
+ error ("previous declaration of %q+D",
+ record);
+ }
}
record = xref_tag (RECORD_TYPE, ident);
- TREE_STATIC_TEMPLATE (record) = 1;
+ INIT_TYPE_OBJC_INFO (record);
+ TYPE_OBJC_INTERFACE (record) = ident;
class_chain = tree_cons (NULL_TREE, ident, class_chain);
}
}
}
tree
-is_class_name (tree ident)
+objc_is_class_name (tree ident)
{
tree chain;
&& identifier_global_value (ident))
ident = identifier_global_value (ident);
while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
- ident = TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
+ ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
-#ifdef OBJCPLUS
if (ident && TREE_CODE (ident) == RECORD_TYPE)
- ident = TYPE_NAME (ident);
+ ident = OBJC_TYPE_NAME (ident);
+#ifdef OBJCPLUS
if (ident && TREE_CODE (ident) == TYPE_DECL)
ident = DECL_NAME (ident);
#endif
for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
{
- if (ident == TREE_VALUE (chain))
- return TREE_PURPOSE (chain);
+ if (ident == TREE_VALUE (chain))
+ return TREE_PURPOSE (chain);
+ }
+
+ return 0;
+}
+
+/* Check whether TYPE is either 'id' or 'Class'. */
+
+tree
+objc_is_id (tree type)
+{
+ if (type && TREE_CODE (type) == IDENTIFIER_NODE
+ && identifier_global_value (type))
+ type = identifier_global_value (type);
+
+ if (type && TREE_CODE (type) == TYPE_DECL)
+ type = TREE_TYPE (type);
+
+ /* NB: This function may be called before the ObjC front-end has
+ been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL. */
+ return (objc_object_type && type
+ && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
+ ? type
+ : NULL_TREE);
+}
+
+/* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
+ class instance. This is needed by other parts of the compiler to
+ handle ObjC types gracefully. */
+
+tree
+objc_is_object_ptr (tree type)
+{
+ tree ret;
+
+ type = TYPE_MAIN_VARIANT (type);
+ if (!POINTER_TYPE_P (type))
+ return 0;
+
+ ret = objc_is_id (type);
+ if (!ret)
+ ret = objc_is_class_name (TREE_TYPE (type));
+
+ return ret;
+}
+
+static int
+objc_is_gcable_type (tree type, int or_strong_p)
+{
+ tree name;
+
+ if (!TYPE_P (type))
+ return 0;
+ if (objc_is_id (TYPE_MAIN_VARIANT (type)))
+ return 1;
+ if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
+ return 1;
+ if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
+ return 0;
+ type = TREE_TYPE (type);
+ if (TREE_CODE (type) != RECORD_TYPE)
+ return 0;
+ name = TYPE_NAME (type);
+ return (objc_is_class_name (name) != NULL_TREE);
+}
+
+static tree
+objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
+{
+ if (expr == oldexpr)
+ return newexpr;
+
+ switch (TREE_CODE (expr))
+ {
+ case COMPONENT_REF:
+ return objc_build_component_ref
+ (objc_substitute_decl (TREE_OPERAND (expr, 0),
+ oldexpr,
+ newexpr),
+ DECL_NAME (TREE_OPERAND (expr, 1)));
+ case ARRAY_REF:
+ return build_array_ref (objc_substitute_decl (TREE_OPERAND (expr, 0),
+ oldexpr,
+ newexpr),
+ TREE_OPERAND (expr, 1));
+ case INDIRECT_REF:
+ return build_indirect_ref (objc_substitute_decl (TREE_OPERAND (expr, 0),
+ oldexpr,
+ newexpr), "->");
+ 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 (ADDR_EXPR, offs, 0));
+ offs = fold (offs);
+ func_params = tree_cons (NULL_TREE,
+ convert (objc_object_type, rhs),
+ tree_cons (NULL_TREE, convert (objc_object_type, outervar),
+ tree_cons (NULL_TREE, offs,
+ NULL_TREE)));
+
+ assemble_external (func);
+ return build_function_call (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 (ADDR_EXPR, lhs, 0)),
+ NULL_TREE));
+
+ assemble_external (objc_assign_global_decl);
+ return build_function_call (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 (ADDR_EXPR, lhs, 0)),
+ NULL_TREE));
+
+ assemble_external (objc_assign_strong_cast_decl);
+ return build_function_call (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_CONTEXT (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;
+
+ /* 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
+ && (TREE_CODE (outer) == CONVERT_EXPR
+ || TREE_CODE (outer) == NOP_EXPR
+ || 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);
}
- return 0;
+ /* In all other cases, fall back to the normal mechanism. */
+ exit_point:
+ return result;
}
-/* 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. */
+struct interface_tuple GTY(())
+{
+ tree id;
+ tree class_name;
+};
-tree
-objc_is_object_ptr (tree type)
+static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
+
+static hashval_t
+hash_interface (const void *p)
{
- type = TYPE_MAIN_VARIANT (type);
- if (!type || TREE_CODE (type) != POINTER_TYPE)
- return 0;
- /* NB: This function may be called before the ObjC front-end has
- been initialized, in which case ID_TYPE will be NULL. */
- if (id_type && type && TYPE_P (type)
- && (IS_ID (type)
- || TREE_TYPE (type) == TREE_TYPE (objc_class_type)))
- return type;
- return is_class_name (OBJC_TYPE_NAME (TREE_TYPE (type)));
+ const struct interface_tuple *d = p;
+ return htab_hash_pointer (d->id);
}
-tree
-lookup_interface (tree ident)
+static int
+eq_interface (const void *p1, const void *p2)
{
- tree chain;
+ const struct interface_tuple *d = p1;
+ return d->id == p2;
+}
+static tree
+lookup_interface (tree ident)
+{
#ifdef OBJCPLUS
if (ident && TREE_CODE (ident) == TYPE_DECL)
ident = DECL_NAME (ident);
#endif
- for (chain = interface_chain; chain; chain = TREE_CHAIN (chain))
- {
- if (ident == CLASS_NAME (chain))
- return chain;
- }
- return NULL_TREE;
+
+ if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
+ return NULL_TREE;
+
+ {
+ struct interface_tuple **slot;
+ tree i = NULL_TREE;
+
+ if (interface_htab)
+ {
+ slot = (struct interface_tuple **)
+ htab_find_slot_with_hash (interface_htab, ident,
+ htab_hash_pointer (ident),
+ NO_INSERT);
+ if (slot && *slot)
+ i = (*slot)->class_name;
+ }
+ return i;
+ }
}
/* Implement @defs (<classname>) within struct bodies. */
tree
-get_class_ivars_from_name (tree class_name)
+objc_get_class_ivars (tree class_name)
{
tree interface = lookup_interface (class_name);
- tree field, fields = NULL_TREE;
if (interface)
- {
- tree raw_ivar = get_class_ivars (interface, 1);
+ return get_class_ivars (interface, true);
- /* Regenerate the FIELD_DECLs for the enclosing struct. */
- for (; raw_ivar; raw_ivar = TREE_CHAIN (raw_ivar))
- {
- field = grokfield (TREE_PURPOSE (TREE_VALUE (raw_ivar)),
- TREE_PURPOSE (raw_ivar),
- TREE_VALUE (TREE_VALUE (raw_ivar)));
-#ifdef OBJCPLUS
- finish_member_declaration (field);
-#else
- fields = chainon (fields, field);
-#endif
- }
- }
- else
- error ("cannot find interface declaration for `%s'",
- IDENTIFIER_POINTER (class_name));
+ error ("cannot find interface declaration for %qs",
+ IDENTIFIER_POINTER (class_name));
- return fields;
+ return error_mark_node;
}
/* Used by: build_private_template, continue_class,
and for @defs constructs. */
static tree
-get_class_ivars (tree interface, int raw)
+get_class_ivars (tree interface, bool inherited)
{
- tree my_name, super_name, ivar_chain;
-
- my_name = CLASS_NAME (interface);
- super_name = CLASS_SUPER_NAME (interface);
- if (raw)
- ivar_chain = CLASS_RAW_IVARS (interface);
- else
- {
- ivar_chain = CLASS_IVARS (interface);
- /* Save off a pristine copy of the leaf ivars (i.e, those not
- inherited from a super class). */
- if (!CLASS_OWN_IVARS (interface))
- CLASS_OWN_IVARS (interface) = copy_list (ivar_chain);
- }
-
- while (super_name)
- {
- tree op1;
- tree super_interface = lookup_interface (super_name);
-
- if (!super_interface)
- {
- /* fatal did not work with 2 args...should fix */
- error ("cannot find interface declaration for `%s', superclass of `%s'",
- IDENTIFIER_POINTER (super_name),
- IDENTIFIER_POINTER (my_name));
- exit (FATAL_EXIT_CODE);
- }
-
- if (super_interface == interface)
- fatal_error ("circular inheritance in interface declaration for `%s'",
- IDENTIFIER_POINTER (super_name));
+ tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
- interface = super_interface;
- my_name = CLASS_NAME (interface);
- super_name = CLASS_SUPER_NAME (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;
- op1 = (raw ? CLASS_RAW_IVARS (interface) : CLASS_OWN_IVARS (interface));
- if (op1)
- {
- tree head = copy_list (op1);
+ if (!inherited)
+ return ivar_chain;
- /* Prepend super class ivars...make a copy of the list, we
- do not want to alter the original. */
- chainon (head, ivar_chain);
- ivar_chain = head;
- }
+ 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;
}
static tree
-objc_enter_block (void)
-{
- tree block;
-
-#ifdef OBJCPLUS
- block = begin_compound_stmt (0);
-#else
- block = c_begin_compound_stmt ();
- pushlevel (0);
- clear_last_expr ();
- add_scope_stmt (/*begin_p=*/1, /*partial_p=*/0);
-#endif
-
- objc_exception_block_stack = tree_cons (NULL_TREE, block,
- objc_exception_block_stack);
-
- blk_nesting_count++;
- return block;
-}
-
-static tree
-objc_exit_block (void)
-{
- tree block = TREE_VALUE (objc_exception_block_stack);
-#ifndef OBJCPLUS
- tree scope_stmt, inner;
-#endif
-
- objc_clear_super_receiver ();
-#ifdef OBJCPLUS
- finish_compound_stmt (0, block);
-#else
- scope_stmt = add_scope_stmt (/*begin_p=*/0, /*partial_p=*/0);
- inner = poplevel (KEEP_MAYBE, 1, 0);
-
- SCOPE_STMT_BLOCK (TREE_PURPOSE (scope_stmt))
- = SCOPE_STMT_BLOCK (TREE_VALUE (scope_stmt))
- = inner;
- RECHAIN_STMTS (block, COMPOUND_BODY (block));
-#endif
- last_expr_type = NULL_TREE;
- objc_exception_block_stack = TREE_CHAIN (objc_exception_block_stack);
-
- blk_nesting_count--;
- return block;
-}
-
-static tree
-objc_declare_variable (enum rid scspec, tree name, tree type, tree init)
+objc_create_temporary_var (tree type)
{
tree decl;
-
- type = tree_cons (NULL_TREE, type,
- tree_cons (NULL_TREE, ridpointers[(int) scspec],
- NULL_TREE));
- TREE_STATIC (type) = 1;
- decl = start_decl (name, type, (init != NULL_TREE), NULL_TREE);
- finish_decl (decl, init, NULL_TREE);
- /* This prevents `unused variable' warnings when compiling with -Wall. */
+
+ decl = build_decl (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;
}
+\f
+/* Exception handling constructs. We begin by having the parser do most
+ of the work and passing us blocks. What we do next depends on whether
+ we're doing "native" exception handling or legacy Darwin setjmp exceptions.
+ We abstract all of this in a handful of appropriately named routines. */
-tree
-objc_build_throw_stmt (tree throw_expr)
+/* Stack of open try blocks. */
+
+struct objc_try_context
{
- tree func_params;
+ struct objc_try_context *outer;
- if (!flag_objc_exceptions)
- fatal_error ("Use `-fobjc-exceptions' to enable Objective-C exception syntax");
+ /* Statements (or statement lists) as processed by the parser. */
+ tree try_body;
+ tree finally_body;
- if (!throw_expr && objc_caught_exception)
- throw_expr = TREE_VALUE (objc_caught_exception);
+ /* 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;
- if (!throw_expr)
- {
- error ("`@throw;' (rethrow) used outside of a `@catch' block");
- return error_mark_node;
- }
+ /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
+ of a TRY_CATCH_EXPR. Even when doing Darwin setjmp. */
+ tree catch_list;
- func_params = tree_cons (NULL_TREE, throw_expr, NULL_TREE);
+ /* The CATCH_EXPR of an open @catch clause. */
+ tree current_catch;
- assemble_external (objc_exception_throw_decl);
- return c_expand_expr_stmt (build_function_call (objc_exception_throw_decl,
- func_params));
-}
+ /* The VAR_DECL holding the Darwin equivalent of EXC_PTR_EXPR. */
+ tree caught_decl;
+ tree stack_decl;
+ tree rethrow_decl;
+};
-static void
-val_stack_push (struct val_stack **nc, long val)
-{
- struct val_stack *new_elem = xmalloc (sizeof (struct val_stack));
- new_elem->val = val;
- new_elem->next = *nc;
- *nc = new_elem;
-}
+static struct objc_try_context *cur_try_context;
-static void
-val_stack_pop (struct val_stack **nc)
+/* This hook, called via lang_eh_runtime_type, generates a runtime object
+ that represents TYPE. For Objective-C, this is just the class name. */
+/* ??? Isn't there a class object or some such? Is it easy to get? */
+
+#ifndef OBJCPLUS
+static tree
+objc_eh_runtime_type (tree type)
{
- struct val_stack *old_elem = *nc;
- *nc = old_elem->next;
- free (old_elem);
+ return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
}
+#endif
+
+/* Initialize exception handling. */
static void
-objc_build_try_enter_fragment (void)
+objc_init_exceptions (void)
{
- /* objc_exception_try_enter(&_stackExceptionData);
- if (!_setjmp(&_stackExceptionData.buf)) { */
-
- tree func_params, if_stmt, cond;
-
- func_params
- = tree_cons (NULL_TREE,
- build_unary_op (ADDR_EXPR,
- TREE_VALUE (objc_stack_exception_data),
- 0),
- NULL_TREE);
+ static bool done = false;
+ if (done)
+ return;
+ done = true;
- assemble_external (objc_exception_try_enter_decl);
- c_expand_expr_stmt (build_function_call
- (objc_exception_try_enter_decl, func_params));
-
- if_stmt = c_begin_if_stmt ();
- if_nesting_count++;
- /* If <setjmp.h> has been included, the _setjmp prototype has
- acquired a real, breathing type for its parameter. Cast our
- argument to that type. */
- func_params
- = tree_cons (NULL_TREE,
- build_c_cast (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))
- ? TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl)))
- : ptr_type_node,
- build_unary_op
- (ADDR_EXPR,
- build_component_ref (TREE_VALUE (objc_stack_exception_data),
- get_identifier ("buf")), 0)),
- NULL_TREE);
- assemble_external (objc_setjmp_decl);
- cond = build_unary_op (TRUTH_NOT_EXPR,
- build_function_call (objc_setjmp_decl, func_params),
- 0);
- c_expand_start_cond ((*lang_hooks.truthvalue_conversion) (cond),
- 0, if_stmt);
- objc_enter_block ();
+ if (flag_objc_sjlj_exceptions)
+ {
+ /* On Darwin, ObjC exceptions require a sufficiently recent
+ version of the runtime, so the user must ask for them explicitly. */
+ if (!flag_objc_exceptions)
+ warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
+ "exception syntax");
+ }
+#ifndef OBJCPLUS
+ else
+ {
+ c_eh_initialized_p = true;
+ eh_personality_libfunc
+ = init_one_libfunc (USING_SJLJ_EXCEPTIONS
+ ? "__gnu_objc_personality_sj0"
+ : "__gnu_objc_personality_v0");
+ default_init_unwind_resume_libfunc ();
+ using_eh_for_cleanups ();
+ lang_eh_runtime_type = objc_eh_runtime_type;
+ }
+#endif
}
+/* Build an EXC_PTR_EXPR, 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_extract_expr (void)
+objc_build_exc_ptr (void)
{
- /* ... = objc_exception_extract(&_stackExceptionData); */
+ if (flag_objc_sjlj_exceptions)
+ {
+ tree var = cur_try_context->caught_decl;
+ if (!var)
+ {
+ var = objc_create_temporary_var (objc_object_type);
+ cur_try_context->caught_decl = var;
+ }
+ return var;
+ }
+ else
+ return build (EXC_PTR_EXPR, objc_object_type);
+}
- tree func_params
- = tree_cons (NULL_TREE,
- build_unary_op (ADDR_EXPR,
- TREE_VALUE (objc_stack_exception_data), 0),
- NULL_TREE);
+/* Build "objc_exception_try_exit(&_stack)". */
- assemble_external (objc_exception_extract_decl);
- return build_function_call (objc_exception_extract_decl, func_params);
+static tree
+next_sjlj_build_try_exit (void)
+{
+ tree t;
+ t = build_fold_addr_expr (cur_try_context->stack_decl);
+ t = tree_cons (NULL, t, NULL);
+ t = build_function_call (objc_exception_try_exit_decl, t);
+ return t;
}
-static void
-objc_build_try_exit_fragment (void)
+/* 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 (void)
{
- /* objc_exception_try_exit(&_stackExceptionData); */
+ tree t, enter, sj, cond;
- tree func_params
- = tree_cons (NULL_TREE,
- build_unary_op (ADDR_EXPR,
- TREE_VALUE (objc_stack_exception_data), 0),
- NULL_TREE);
+ t = build_fold_addr_expr (cur_try_context->stack_decl);
+ t = tree_cons (NULL, t, NULL);
+ enter = build_function_call (objc_exception_try_enter_decl, t);
+
+ t = objc_build_component_ref (cur_try_context->stack_decl,
+ get_identifier ("buf"));
+ t = build_fold_addr_expr (t);
+#ifdef OBJCPLUS
+ /* Convert _setjmp argument to type that is expected. */
+ if (TYPE_ARG_TYPES (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 (objc_setjmp_decl, t);
- assemble_external (objc_exception_try_exit_decl);
- c_expand_expr_stmt (build_function_call (objc_exception_try_exit_decl,
- func_params));
+ cond = build (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
+ cond = c_common_truthvalue_conversion (cond);
+
+ return build (COND_EXPR, void_type_node, cond, NULL, NULL);
}
-static void
-objc_build_extract_fragment (void)
+/* Build
+ DECL = objc_exception_extract(&_stack);
+*/
+
+static tree
+next_sjlj_build_exc_extract (tree decl)
{
- /* } else {
- _rethrowException = objc_exception_extract(&_stackExceptionData);
- } */
+ tree t;
- objc_exit_block ();
- c_finish_then ();
+ t = build_fold_addr_expr (cur_try_context->stack_decl);
+ t = tree_cons (NULL, t, NULL);
+ t = build_function_call (objc_exception_extract_decl, t);
+ t = convert (TREE_TYPE (decl), t);
+ t = build (MODIFY_EXPR, void_type_node, decl, t);
- c_expand_start_else ();
- objc_enter_block ();
- c_expand_expr_stmt (build_modify_expr
- (TREE_VALUE (objc_rethrow_exception),
- NOP_EXPR,
- objc_build_extract_expr ()));
- objc_exit_block ();
- c_finish_else ();
- c_expand_end_cond ();
- if_nesting_count--;
+ return t;
}
-tree
-objc_build_try_prologue (void)
-{
- /* { // new scope
- struct _objc_exception_data _stackExceptionData;
- volatile id _rethrowException = nil;
- { // begin TRY-CATCH scope
- objc_exception_try_enter(&_stackExceptionData);
- if (!_setjmp(&_stackExceptionData.buf)) { */
-
- tree try_catch_block;
-
- if (!flag_objc_exceptions)
- fatal_error ("Use `-fobjc-exceptions' to enable Objective-C exception syntax");
-
- objc_mark_locals_volatile ((void *)(exc_binding_stack
- ? exc_binding_stack->val
- : 0));
- objc_enter_block ();
- objc_stack_exception_data
- = tree_cons (NULL_TREE,
- objc_declare_variable (RID_AUTO,
- get_identifier (UTAG_EXCDATA_VAR),
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_EXCDATA)),
- NULL_TREE),
- objc_stack_exception_data);
- objc_rethrow_exception = tree_cons (NULL_TREE,
- objc_declare_variable (RID_VOLATILE,
- get_identifier (UTAG_RETHROWEXC_VAR),
- id_type,
- build_int_2 (0, 0)),
- objc_rethrow_exception);
-
- try_catch_block = objc_enter_block ();
- val_stack_push (&exc_binding_stack, (long) get_current_scope ());
- objc_build_try_enter_fragment ();
-
- return try_catch_block;
-}
+/* 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. */
-void
-objc_build_try_epilogue (int also_catch_prologue)
+static tree
+next_sjlj_build_catch_list (void)
{
- if (also_catch_prologue)
+ tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
+ tree catch_seq, t;
+ tree *last = &catch_seq;
+ bool saw_id = false;
+
+ for (; !tsi_end_p (i); tsi_next (&i))
{
- /* } else {
- register id _caughtException = objc_exception_extract( &_stackExceptionData);
- objc_exception_try_enter(&_stackExceptionData);
- if(!_setjmp(&_stackExceptionData.buf)) {
- if (0) { */
+ tree stmt = tsi_stmt (i);
+ tree type = CATCH_TYPES (stmt);
+ tree body = CATCH_BODY (stmt);
- tree if_stmt;
+ if (type == NULL)
+ {
+ *last = body;
+ saw_id = true;
+ break;
+ }
+ else
+ {
+ tree args, cond;
- objc_exit_block ();
- c_finish_then ();
-
- c_expand_start_else ();
- objc_enter_block ();
- objc_caught_exception
- = tree_cons (NULL_TREE,
- objc_declare_variable (RID_REGISTER,
- get_identifier (UTAG_CAUGHTEXC_VAR),
- id_type,
- objc_build_extract_expr ()),
- objc_caught_exception);
- objc_build_try_enter_fragment ();
- val_stack_push (&catch_count_stack, 1);
- if_stmt = c_begin_if_stmt ();
- if_nesting_count++;
- c_expand_start_cond ((*lang_hooks.truthvalue_conversion) (boolean_false_node),
- 0, if_stmt);
- objc_enter_block ();
-
- /* Start a new chain of @catch statements for this @try. */
- objc_catch_type = tree_cons (objc_catch_type, NULL_TREE, NULL_TREE);
+ if (type == error_mark_node)
+ cond = error_mark_node;
+ else
+ {
+ args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
+ t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
+ args = tree_cons (NULL, t, args);
+ t = build_function_call (objc_exception_match_decl, args);
+ cond = c_common_truthvalue_conversion (t);
+ }
+ t = build (COND_EXPR, void_type_node, cond, body, NULL);
+ SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
+
+ *last = t;
+ last = &COND_EXPR_ELSE (t);
+ }
}
- else
- { /* !also_catch_prologue */
- /* } else {
- _rethrowException = objc_exception_extract( &_stackExceptionData);
- }
- } */
- objc_build_extract_fragment ();
- objc_exit_block ();
+ if (!saw_id)
+ {
+ t = build (MODIFY_EXPR, void_type_node, cur_try_context->rethrow_decl,
+ cur_try_context->caught_decl);
+ SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
+ append_to_statement_list (t, last);
+
+ t = next_sjlj_build_try_exit ();
+ SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
+ append_to_statement_list (t, last);
}
+
+ return catch_seq;
}
-void
-objc_build_catch_stmt (tree catch_expr)
+/* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
+ exception handling. We aim to build:
+
+ {
+ struct _objc_exception_data _stack;
+ id volatile _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 (void)
{
- /* } else if (objc_exception_match(objc_get_class("SomeClass"), _caughtException)) {
- register SomeClass *e = _caughtException; */
+ tree rethrow_decl, stack_decl, t;
+ tree catch_seq, try_fin, bind;
- tree if_stmt, cond, func_params, prev_catch, var_name, var_type;
- int catch_id;
+ /* Create the declarations involved. */
+ t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
+ stack_decl = objc_create_temporary_var (t);
+ cur_try_context->stack_decl = stack_decl;
-#ifndef OBJCPLUS
- /* Yet another C/C++ impedance mismatch. */
- catch_expr = TREE_PURPOSE (catch_expr);
-#endif
+ rethrow_decl = objc_create_temporary_var (objc_object_type);
+ cur_try_context->rethrow_decl = rethrow_decl;
+ TREE_THIS_VOLATILE (rethrow_decl) = 1;
+ TREE_CHAIN (rethrow_decl) = stack_decl;
- var_name = TREE_VALUE (catch_expr);
- var_type = TREE_VALUE (TREE_PURPOSE (catch_expr));
- if (TREE_CODE (var_name) == INDIRECT_REF)
- var_name = TREE_OPERAND (var_name, 0);
- if (TREE_CODE (var_type) == TYPE_DECL
- || TREE_CODE (var_type) == POINTER_TYPE)
- var_type = TREE_TYPE (var_type);
- catch_id = (var_type == TREE_TYPE (id_type));
+ /* Build the outermost variable binding level. */
+ bind = build (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
+ SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
+ TREE_SIDE_EFFECTS (bind) = 1;
- if (!flag_objc_exceptions)
- fatal_error ("Use `-fobjc-exceptions' to enable Objective-C exception syntax");
+ /* Initialize rethrow_decl. */
+ t = build (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));
- if (!(catch_id || TYPED_OBJECT (var_type)))
- fatal_error ("`@catch' parameter is not a known Objective-C class type");
+ /* Build the outermost TRY_FINALLY_EXPR. */
+ try_fin = build (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));
- /* Examine previous @catch clauses for the current @try block for
- superclasses of the 'var_type' class. */
- for (prev_catch = objc_catch_type; TREE_VALUE (prev_catch);
- prev_catch = TREE_CHAIN (prev_catch))
+ /* Create the complete catch sequence. */
+ if (cur_try_context->catch_list)
{
- if (TREE_VALUE (prev_catch) == TREE_TYPE (id_type))
- {
- warning ("Exception already handled by preceding `@catch(id)'");
- break;
- }
- else if (!catch_id
- && objc_comptypes (TREE_VALUE (prev_catch), var_type, 0) == 1)
- warning ("Exception of type `%s *' already handled by `@catch (%s *)'",
- IDENTIFIER_POINTER (OBJC_TYPE_NAME (var_type)),
- IDENTIFIER_POINTER (OBJC_TYPE_NAME (TREE_VALUE (prev_catch))));
+ tree caught_decl = objc_build_exc_ptr ();
+ catch_seq = build_stmt (BIND_EXPR, caught_decl, NULL, NULL);
+ TREE_SIDE_EFFECTS (catch_seq) = 1;
+
+ t = next_sjlj_build_exc_extract (caught_decl);
+ append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
+
+ t = next_sjlj_build_enter_and_setjmp ();
+ COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (rethrow_decl);
+ COND_EXPR_ELSE (t) = next_sjlj_build_catch_list ();
+ append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
}
+ else
+ catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
+ SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
- objc_catch_type = tree_cons (NULL_TREE, var_type, objc_catch_type);
+ /* Build the main register-and-try if statement. */
+ t = next_sjlj_build_enter_and_setjmp ();
+ 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;
- objc_exit_block ();
- c_finish_then ();
+ /* Build the complete FINALLY statement list. */
+ t = next_sjlj_build_try_exit ();
+ t = build_stmt (COND_EXPR,
+ c_common_truthvalue_conversion (rethrow_decl),
+ NULL, t);
+ SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
+ append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
- c_expand_start_else ();
- catch_count_stack->val++;
- if_stmt = c_begin_if_stmt ();
- if_nesting_count++;
+ append_to_statement_list (cur_try_context->finally_body,
+ &TREE_OPERAND (try_fin, 1));
- if (catch_id)
- cond = integer_one_node;
- else
- {
- cond = get_class_reference (OBJC_TYPE_NAME (var_type));
-
- func_params
- = tree_cons (NULL_TREE, cond,
- tree_cons (NULL_TREE,
- TREE_VALUE (objc_caught_exception),
- NULL_TREE));
- assemble_external (objc_exception_match_decl);
- cond = build_function_call (objc_exception_match_decl, func_params);
- }
+ t = tree_cons (NULL, rethrow_decl, NULL);
+ t = build_function_call (objc_exception_throw_decl, t);
+ t = build_stmt (COND_EXPR,
+ c_common_truthvalue_conversion (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;
+}
+
+/* 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 = xcalloc (1, sizeof (*c));
+ c->outer = cur_try_context;
+ c->try_body = body;
+ c->try_locus = try_locus;
+ c->end_try_locus = input_location;
+ cur_try_context = c;
+
+ objc_init_exceptions ();
- c_expand_start_cond ((*lang_hooks.truthvalue_conversion) (cond),
- 0, if_stmt);
- objc_enter_block ();
- objc_declare_variable (RID_REGISTER, var_name,
- build_pointer_type (var_type),
- TREE_VALUE (objc_caught_exception));
+ 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. */
+
void
-objc_build_catch_epilogue (void)
-{
- /* } else {
- _rethrowException = _caughtException;
- objc_exception_try_exit(&_stackExceptionData);
- }
- } else {
- _rethrowException = objc_exception_extract(&_stackExceptionData);
- }
- }
- } // end TRY-CATCH scope
- */
+objc_begin_catch_clause (tree decl)
+{
+ tree compound, type, t;
+
+ /* Begin a new scope that the entire catch clause will live in. */
+ compound = c_begin_compound_stmt (true);
+
+ /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL. */
+ decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
+ lang_hooks.decls.pushdecl (decl);
- objc_exit_block ();
- c_finish_then ();
+ /* Since a decl is required here by syntax, don't warn if its unused. */
+ /* ??? As opposed to __attribute__((unused))? Anyway, this appears to
+ be what the previous objc implementation did. */
+ TREE_USED (decl) = 1;
+
+ /* 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). */
+ type = TREE_TYPE (decl);
- c_expand_start_else ();
- objc_enter_block ();
- c_expand_expr_stmt
- (build_modify_expr
- (TREE_VALUE (objc_rethrow_exception),
- NOP_EXPR,
- TREE_VALUE (objc_caught_exception)));
- objc_build_try_exit_fragment ();
- objc_exit_block ();
- while (catch_count_stack->val--)
+ if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
+ type = NULL;
+ else if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
{
- c_finish_else (); /* close off all the nested ifs ! */
- c_expand_end_cond ();
- if_nesting_count--;
+ error ("@catch parameter is not a known Objective-C class type");
+ type = error_mark_node;
+ }
+ else 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 (0, "%H by earlier handler for %<%T%>",
+ EXPR_LOCUS (stmt), TREE_TYPE (t ? t : objc_object_type));
+ break;
+ }
+ }
}
- val_stack_pop (&catch_count_stack);
- objc_caught_exception = TREE_CHAIN (objc_caught_exception);
-
- objc_build_extract_fragment ();
- objc_exit_block ();
- c_finish_else ();
- c_expand_end_cond ();
- if_nesting_count--;
- objc_exit_block ();
+ /* Record the data for the catch in the try context so that we can
+ finalize it later. */
+ t = build_stmt (CATCH_EXPR, type, compound);
+ cur_try_context->current_catch = t;
- /* Return to enclosing chain of @catch statements (if any). */
- while (TREE_VALUE (objc_catch_type))
- objc_catch_type = TREE_CHAIN (objc_catch_type);
- objc_catch_type = TREE_PURPOSE (objc_catch_type);
+ /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */
+ t = objc_build_exc_ptr ();
+ t = convert (TREE_TYPE (decl), t);
+ t = build (MODIFY_EXPR, void_type_node, decl, t);
+ add_stmt (t);
}
-tree
-objc_build_finally_prologue (void)
-{
- /* { // begin FINALLY scope
- if (!_rethrowException) {
- objc_exception_try_exit(&_stackExceptionData);
- } */
+/* Called just after parsing the closing brace of a @catch clause. Close
+ the open binding level, and record a CATCH_EXPR for it. */
- tree blk = objc_enter_block ();
+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;
- tree if_stmt = c_begin_if_stmt ();
- if_nesting_count++;
+ CATCH_BODY (c) = c_end_compound_stmt (CATCH_BODY (c), 1);
+ append_to_statement_list (c, &cur_try_context->catch_list);
+}
- c_expand_start_cond ((*lang_hooks.truthvalue_conversion)
- (build_unary_op
- (TRUTH_NOT_EXPR,
- TREE_VALUE (objc_rethrow_exception), 0)),
- 0, if_stmt);
- objc_enter_block ();
- objc_build_try_exit_fragment ();
- objc_exit_block ();
- c_finish_then ();
- c_expand_end_cond ();
- if_nesting_count--;
+/* Called after parsing a @finally clause and its associated BODY.
+ Record the body for later placement. */
- return blk;
+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_build_finally_epilogue (void)
+objc_finish_try_stmt (void)
{
- /* if (_rethrowException) {
- objc_exception_throw(_rethrowException);
- }
- } // end FINALLY scope
- } */
+ struct objc_try_context *c = cur_try_context;
+ tree stmt;
- tree if_stmt = c_begin_if_stmt ();
- if_nesting_count++;
+ if (c->catch_list == NULL && c->finally_body == NULL)
+ error ("%<@try%> without %<@catch%> or %<@finally%>");
- c_expand_start_cond
- ((*lang_hooks.truthvalue_conversion) (TREE_VALUE (objc_rethrow_exception)),
- 0, if_stmt);
- objc_enter_block ();
- objc_build_throw_stmt (TREE_VALUE (objc_rethrow_exception));
- objc_exit_block ();
- c_finish_then ();
- c_expand_end_cond ();
- if_nesting_count--;
-
- objc_exit_block ();
- objc_rethrow_exception = TREE_CHAIN (objc_rethrow_exception);
- objc_stack_exception_data = TREE_CHAIN (objc_stack_exception_data);
+ /* If we're doing Darwin setjmp exceptions, build the big nasty. */
+ if (flag_objc_sjlj_exceptions)
+ {
+ if (!cur_try_context->finally_body)
+ {
+ cur_try_context->finally_locus = input_location;
+ cur_try_context->end_finally_locus = input_location;
+ }
+ stmt = next_sjlj_build_try_catch_finally ();
+ }
+ else
+ {
+ /* Otherwise, nest the CATCH inside a FINALLY. */
+ stmt = c->try_body;
+ if (c->catch_list)
+ {
+ stmt = build_stmt (TRY_CATCH_EXPR, stmt, c->catch_list);
+ SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
+ }
+ if (c->finally_body)
+ {
+ stmt = build_stmt (TRY_FINALLY_EXPR, stmt, c->finally_body);
+ SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
+ }
+ }
+ add_stmt (stmt);
- val_stack_pop (&exc_binding_stack);
- return objc_exit_block ();
+ cur_try_context = c->outer;
+ free (c);
+ return stmt;
}
tree
-objc_build_try_catch_finally_stmt (int has_catch, int has_finally)
-{
- /* NB: The operative assumption here is that TRY_FINALLY_EXPR will
- deal with all exits from 'try_catch_blk' and route them through
- 'finally_blk'. */
- tree outer_blk = objc_build_finally_epilogue ();
- tree prec_stmt = TREE_CHAIN (TREE_CHAIN (COMPOUND_BODY (outer_blk)));
- tree try_catch_blk = TREE_CHAIN (prec_stmt), try_catch_expr;
- tree finally_blk = TREE_CHAIN (try_catch_blk), finally_expr;
- tree succ_stmt = TREE_CHAIN (finally_blk);
- tree try_finally_stmt, try_finally_expr;
-
- if (!flag_objc_exceptions)
- fatal_error ("Use `-fobjc-exceptions' to enable Objective-C exception syntax");
-
- /* It is an error to have a @try block without a @catch and/or @finally
- (even though sensible code can be generated nonetheless). */
-
- if (!has_catch && !has_finally)
- error ("`@try' without `@catch' or `@finally'");
-
- /* We shall now do something truly disgusting. We shall remove the
- 'try_catch_blk' and 'finally_blk' from the 'outer_blk' statement
- chain, and replace them with a TRY_FINALLY_EXPR statement! If
- this doesn't work, we will have to learn (from Per/gcj) how to
- construct the 'outer_blk' lazily. */
-
- TREE_CHAIN (try_catch_blk) = TREE_CHAIN (finally_blk) = NULL_TREE;
- try_catch_expr = build1 (STMT_EXPR, void_type_node, try_catch_blk);
- TREE_SIDE_EFFECTS (try_catch_expr) = 1;
- finally_expr = build1 (STMT_EXPR, void_type_node, finally_blk);
- TREE_SIDE_EFFECTS (finally_expr) = 1;
- try_finally_expr = build (TRY_FINALLY_EXPR, void_type_node, try_catch_expr,
- finally_expr);
- TREE_SIDE_EFFECTS (try_finally_expr) = 1;
- try_finally_stmt = build_stmt (EXPR_STMT, try_finally_expr);
- TREE_CHAIN (prec_stmt) = try_finally_stmt;
- TREE_CHAIN (try_finally_stmt) = succ_stmt;
-
- return outer_blk; /* the whole enchilada */
-}
-
-void
-objc_build_synchronized_prologue (tree sync_expr)
+objc_build_throw_stmt (tree throw_expr)
{
- /* {
- id _eval_once = <sync_expr>;
- @try {
- objc_sync_enter( _eval_once ); */
+ tree args;
- tree func_params;
+ objc_init_exceptions ();
- if (!flag_objc_exceptions)
- fatal_error ("Use `-fobjc-exceptions' to enable Objective-C exception syntax");
+ 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 ("%<@throw%> (rethrow) used outside of a @catch block");
+ return NULL_TREE;
+ }
- objc_enter_block ();
- objc_eval_once
- = tree_cons (NULL_TREE,
- objc_declare_variable (RID_AUTO,
- get_identifier (UTAG_EVALONCE_VAR),
- id_type,
- sync_expr),
- objc_eval_once);
- objc_build_try_prologue ();
- objc_enter_block ();
- func_params = tree_cons (NULL_TREE,
- TREE_VALUE (objc_eval_once),
- NULL_TREE);
+ /* Otherwise the object is still sitting in the EXC_PTR_EXPR
+ value that we get from the runtime. */
+ throw_expr = objc_build_exc_ptr ();
+ }
- assemble_external (objc_sync_enter_decl);
- c_expand_expr_stmt (build_function_call
- (objc_sync_enter_decl, func_params));
+ /* A throw is just a call to the runtime throw function with the
+ object as a parameter. */
+ args = tree_cons (NULL, throw_expr, NULL);
+ return add_stmt (build_function_call (objc_exception_throw_decl, args));
}
tree
-objc_build_synchronized_epilogue (void)
+objc_build_synchronized (location_t start_locus, tree mutex, tree body)
{
- /* }
- @finally {
- objc_sync_exit( _eval_once );
- }
- } */
-
- tree func_params;
+ tree args, call;
- objc_exit_block ();
- objc_build_try_epilogue (0);
- objc_build_finally_prologue ();
- func_params = tree_cons (NULL_TREE, TREE_VALUE (objc_eval_once),
- NULL_TREE);
+ /* First lock the mutex. */
+ mutex = save_expr (mutex);
+ args = tree_cons (NULL, mutex, NULL);
+ call = build_function_call (objc_sync_enter_decl, args);
+ SET_EXPR_LOCATION (call, start_locus);
+ add_stmt (call);
- assemble_external (objc_sync_exit_decl);
- c_expand_expr_stmt (build_function_call (objc_sync_exit_decl,
- func_params));
- objc_build_try_catch_finally_stmt (0, 1);
+ /* Build the mutex unlock. */
+ args = tree_cons (NULL, mutex, NULL);
+ call = build_function_call (objc_sync_exit_decl, args);
+ SET_EXPR_LOCATION (call, input_location);
- return objc_exit_block ();
+ /* Put the that and the body in a TRY_FINALLY. */
+ objc_begin_try_stmt (start_locus, body);
+ objc_build_finally_clause (input_location, call);
+ return objc_finish_try_stmt ();
}
+\f
/* Predefine the following data type:
struct _objc_exception_data
#endif
static void
-build_objc_exception_stuff (void)
+build_next_objc_exception_stuff (void)
{
tree field_decl, field_decl_chain, index, temp_type;
- /* Suppress outputting debug symbols, because
- dbxout_init hasn't been called yet. */
- enum debug_info_type save_write_symbols = write_symbols;
- const struct gcc_debug_hooks *save_hooks = debug_hooks;
-
- write_symbols = NO_DEBUG;
- debug_hooks = &do_nothing_debug_hooks;
objc_exception_data_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
/* int buf[_JBLEN]; */
- index = build_index_type (build_int_2 (_JBLEN - 1, 0));
- field_decl = create_builtin_decl (FIELD_DECL,
- build_array_type (integer_type_node, index),
- "buf");
+ index = build_index_type (build_int_cst (NULL_TREE, _JBLEN - 1));
+ field_decl = create_field_decl (build_array_type (integer_type_node, index),
+ "buf");
field_decl_chain = field_decl;
/* void *pointers[4]; */
- index = build_index_type (build_int_2 (4 - 1, 0));
- field_decl = create_builtin_decl (FIELD_DECL,
- build_array_type (ptr_type_node, index),
- "pointers");
+ index = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
+ field_decl = create_field_decl (build_array_type (ptr_type_node, index),
+ "pointers");
chainon (field_decl_chain, field_decl);
finish_struct (objc_exception_data_template, field_decl_chain, NULL_TREE);
/* int _setjmp(...); */
- /* If the user includes <setjmp.h>, this shall be superceded by
+ /* If the user includes <setjmp.h>, this shall be superseded by
'int _setjmp(jmp_buf);' */
temp_type = build_function_type (integer_type_node, NULL_TREE);
objc_setjmp_decl
/* id objc_exception_extract(struct _objc_exception_data *); */
temp_type
- = build_function_type (id_type,
+ = build_function_type (objc_object_type,
tree_cons (NULL_TREE,
build_pointer_type (objc_exception_data_template),
OBJC_VOID_AT_END));
= builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
objc_exception_try_exit_decl
= builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
+
+ /* int objc_exception_match(id, id); */
+ temp_type
+ = build_function_type (integer_type_node,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ OBJC_VOID_AT_END)));
+ objc_exception_match_decl
+ = 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 (objc_object_type,
+ tree_cons
+ (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE,
+ unsigned_type_node,
+ OBJC_VOID_AT_END))));
+ objc_assign_ivar_decl
+ = builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN,
+ NULL, NULL_TREE);
+#ifdef OFFS_ASSIGNIVAR_FAST
+ objc_assign_ivar_fast_decl
+ = 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 (objc_object_type,
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, build_pointer_type (objc_object_type),
+ OBJC_VOID_AT_END)));
+ objc_assign_global_decl
+ = builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
+ objc_assign_strong_cast_decl
+ = builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
+}
+
+static void
+build_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 (void_type_node,
- tree_cons (NULL_TREE, id_type,
+ tree_cons (NULL_TREE, objc_object_type,
OBJC_VOID_AT_END));
objc_exception_throw_decl
- = builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
- DECL_ATTRIBUTES (objc_exception_throw_decl)
- = tree_cons (get_identifier ("noreturn"), NULL_TREE, NULL_TREE);
+ = builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL,
+ noreturn_list);
objc_sync_enter_decl
- = builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
+ = builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
+ NULL, nothrow_list);
objc_sync_exit_decl
- = builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
- /* int objc_exception_match(id, id); */
- temp_type = build_function_type (integer_type_node,
- tree_cons (NULL_TREE, id_type,
- tree_cons (NULL_TREE, id_type,
- OBJC_VOID_AT_END)));
- objc_exception_match_decl
- = builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
-
- write_symbols = save_write_symbols;
- debug_hooks = save_hooks;
+ = builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
+ NULL, nothrow_list);
}
-/* struct <classname> {
- struct objc_class *isa;
+/* Construct a C struct corresponding to ObjC class CLASS, with the same
+ name as the class:
+
+ struct <classname> {
+ struct _objc_class *isa;
...
}; */
-static tree
+static void
build_private_template (tree class)
{
- tree ivar_context;
-
- if (CLASS_STATIC_TEMPLATE (class))
+ if (!CLASS_STATIC_TEMPLATE (class))
{
- uprivate_record = CLASS_STATIC_TEMPLATE (class);
- ivar_context = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class));
- }
- else
- {
- uprivate_record = start_struct (RECORD_TYPE, CLASS_NAME (class));
- ivar_context = get_class_ivars (class, 0);
-
- finish_struct (uprivate_record, ivar_context, NULL_TREE);
+ tree record = objc_build_struct (class,
+ get_class_ivars (class, false),
+ CLASS_SUPER_NAME (class));
- CLASS_STATIC_TEMPLATE (class) = uprivate_record;
-
- /* mark this record as class template - for class type checking */
- TREE_STATIC_TEMPLATE (uprivate_record) = 1;
+ /* 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;
}
-
- instance_type
- = groktypename (build_tree_list (build_tree_list (NULL_TREE,
- uprivate_record),
- build1 (INDIRECT_REF, NULL_TREE,
- NULL_TREE)));
-
- return ivar_context;
}
\f
/* Begin code generation for protocols... */
-/* struct objc_protocol {
+/* struct _objc_protocol {
+ struct _objc_class *isa;
char *protocol_name;
- struct objc_protocol **protocol_list;
- struct objc_method_desc *instance_methods;
- struct objc_method_desc *class_methods;
+ struct _objc_protocol **protocol_list;
+ struct _objc__method_prototype_list *instance_methods;
+ struct _objc__method_prototype_list *class_methods;
}; */
-static tree
+static void
build_protocol_template (void)
{
- tree decl_specs, field_decl, field_decl_chain;
- tree template;
-
- template = start_struct (RECORD_TYPE, get_identifier (UTAG_PROTOCOL));
+ tree field_decl, field_decl_chain;
- /* struct objc_class *isa; */
+ objc_protocol_template = start_struct (RECORD_TYPE,
+ get_identifier (UTAG_PROTOCOL));
- decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
- get_identifier (UTAG_CLASS)));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("isa"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_class *isa; */
+ field_decl = create_field_decl (build_pointer_type
+ (xref_tag (RECORD_TYPE,
+ get_identifier (UTAG_CLASS))),
+ "isa");
field_decl_chain = field_decl;
/* char *protocol_name; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_name"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (string_type_node, "protocol_name");
chainon (field_decl_chain, field_decl);
- /* struct objc_protocol **protocol_list; */
-
- decl_specs = build_tree_list (NULL_TREE, template);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_protocol **protocol_list; */
+ field_decl = create_field_decl (build_pointer_type
+ (build_pointer_type
+ (objc_protocol_template)),
+ "protocol_list");
chainon (field_decl_chain, field_decl);
- /* struct objc_method_list *instance_methods; */
-
- decl_specs
- = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("instance_methods"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc__method_prototype_list *instance_methods; */
+ field_decl = create_field_decl (objc_method_proto_list_ptr,
+ "instance_methods");
chainon (field_decl_chain, field_decl);
- /* struct objc_method_list *class_methods; */
-
- decl_specs
- = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_methods"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc__method_prototype_list *class_methods; */
+ field_decl = create_field_decl (objc_method_proto_list_ptr,
+ "class_methods");
chainon (field_decl_chain, field_decl);
- return finish_struct (template, field_decl_chain, NULL_TREE);
+ finish_struct (objc_protocol_template, field_decl_chain, NULL_TREE);
}
static tree
build_method_prototype_list_template (tree list_type, int size)
{
tree objc_ivar_list_record;
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
/* Generate an unnamed struct definition. */
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
/* int method_count; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
- field_decl = get_identifier ("method_count");
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (integer_type_node, "method_count");
field_decl_chain = field_decl;
/* struct objc_method method_list[]; */
-
- decl_specs = build_tree_list (NULL_TREE, list_type);
- field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
- build_int_2 (size, 0));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_array_type
+ (list_type,
+ build_index_type
+ (build_int_cst (NULL_TREE, size - 1))),
+ "method_list");
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
build_method_prototype_template (void)
{
tree proto_record;
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
proto_record
= start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD_PROTOTYPE));
- /* struct objc_selector *_cmd; */
- decl_specs = tree_cons (NULL_TREE, xref_tag (RECORD_TYPE,
- get_identifier (TAG_SELECTOR)), NULL_TREE);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_cmd"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* SEL _cmd; */
+ field_decl = create_field_decl (objc_selector_type, "_cmd");
field_decl_chain = field_decl;
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], NULL_TREE);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("method_types"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* char *method_types; */
+ field_decl = create_field_decl (string_type_node, "method_types");
chainon (field_decl_chain, field_decl);
finish_struct (proto_record, field_decl_chain, NULL_TREE);
static tree
objc_method_parm_type (tree type)
{
- type = groktypename (TREE_TYPE (type));
+ type = TREE_VALUE (TREE_TYPE (type));
if (TREE_CODE (type) == TYPE_DECL)
type = TREE_TYPE (type);
- return TYPE_MAIN_VARIANT (type);
+ return type;
}
static int
/* Make all integer and enum types at least as large
as an int. */
- if (sz > 0 && (TREE_CODE (type) == INTEGER_TYPE
- || TREE_CODE (type) == BOOLEAN_TYPE
- || TREE_CODE (type) == ENUMERAL_TYPE))
+ 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. */
/* If a type size is not known, bail out. */
if (sz < 0)
{
- error ("%Jtype '%D' does not have a known size",
- type, type);
+ error ("type %q+D does not have a known size",
+ type);
/* Pretend that the encoding succeeded; the compilation will
fail nevertheless. */
goto finish_encoding;
generate_descriptor_table (tree type, const char *name, int size, tree list,
tree proto)
{
- tree sc_spec, decl_specs, decl, initlist;
-
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, type, sc_spec);
+ tree decl, initlist;
- decl = start_decl (synth_id_with_class_suffix (name, proto),
- decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (decl) = NULL_TREE;
+ decl = start_var_decl (type, synth_id_with_class_suffix (name, proto));
- initlist = build_tree_list (NULL_TREE, build_int_2 (size, 0));
+ initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
initlist = tree_cons (NULL_TREE, list, initlist);
- finish_decl (decl, objc_build_constructor (type, nreverse (initlist)),
- NULL_TREE);
+ finish_var_decl (decl, objc_build_constructor (type, nreverse (initlist)));
return decl;
}
generate_method_descriptors (tree protocol)
{
tree initlist, chain, method_list_template;
- tree cast, variable_length_type;
int size;
if (!objc_method_prototype_template)
objc_method_prototype_template = build_method_prototype_template ();
- cast = build_tree_list (build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_PROTOTYPE_LIST))),
- NULL_TREE);
- variable_length_type = groktypename (cast);
-
chain = PROTOCOL_CLS_METHODS (protocol);
if (chain)
{
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_CLASS_METHODS",
size, initlist, protocol);
- TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
}
else
UOBJC_CLASS_METHODS_decl = 0;
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_INSTANCE_METHODS",
size, initlist, protocol);
- TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
}
+/* 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_set_method_type (MINUS_EXPR);
+ objc_start_method_definition
+ (objc_build_method_signature (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));
+ 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 (IS_AGGR_TYPE (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_TREE, type, LOOKUP_NORMAL));
+ }
+ }
+
+ /* 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;
+
+ /* 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 (IS_AGGR_TYPE (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 (flag_next_runtime)
+ imp_list->has_cxx_cdtors = (need_ctor || need_dtor);
+}
+#endif
+
/* 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
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 inizialization.
+ 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 sc_spec, decl_specs, decl;
+ tree decl;
tree initlist, protocol_name_expr, refs_decl, refs_expr;
- tree cast_type2;
-
- if (! objc_protocol_template)
- objc_protocol_template = build_protocol_template ();
/* If a protocol was directly referenced, pull in indirect references. */
for (p = protocol_chain; p; p = TREE_CHAIN (p))
tree cls_methods = PROTOCOL_CLS_METHODS (p);
/* If protocol wasn't referenced, don't generate any code. */
- if (! PROTOCOL_FORWARD_DECL (p))
+ decl = PROTOCOL_FORWARD_DECL (p);
+
+ if (!decl)
continue;
/* Make sure we link in the Protocol class. */
refs_decl = 0;
/* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
-
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC],
- NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, objc_protocol_template, sc_spec);
-
- decl = start_decl (synth_id_with_class_suffix ("_OBJC_PROTOCOL", p),
- decl_specs, 1, NULL_TREE);
-
- DECL_CONTEXT (decl) = NULL_TREE;
-
protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
if (refs_decl)
- {
- cast_type2
- = groktypename
- (build_tree_list (build_tree_list (NULL_TREE,
- objc_protocol_template),
- build1 (INDIRECT_REF, NULL_TREE,
- build1 (INDIRECT_REF, NULL_TREE,
- NULL_TREE))));
-
- refs_expr = build_unary_op (ADDR_EXPR, refs_decl, 0);
- TREE_TYPE (refs_expr) = cast_type2;
- }
+ refs_expr = convert (build_pointer_type (build_pointer_type
+ (objc_protocol_template)),
+ build_unary_op (ADDR_EXPR, refs_decl, 0));
else
- refs_expr = build_int_2 (0, 0);
+ 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. */
protocol_name_expr, refs_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl);
- finish_decl (decl, initlist, NULL_TREE);
-
- /* Mark the decl as used to avoid "defined but not used" warning. */
- TREE_USED (decl) = 1;
+ finish_var_decl (decl, initlist);
}
}
tree class_methods)
{
tree initlist = NULL_TREE, expr;
- tree cast_type;
-
- cast_type = groktypename
- (build_tree_list
- (build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_CLASS))),
- build1 (INDIRECT_REF, NULL_TREE, NULL_TREE)));
+ tree cast_type = build_pointer_type
+ (xref_tag (RECORD_TYPE,
+ get_identifier (UTAG_CLASS)));
/* Filling the "isa" in with one allows the runtime system to
detect that the version change...should remove before final release. */
- expr = build_int_2 (PROTOCOL_VERSION, 0);
- TREE_TYPE (expr) = cast_type;
+ expr = build_int_cst (cast_type, PROTOCOL_VERSION);
initlist = tree_cons (NULL_TREE, expr, initlist);
initlist = tree_cons (NULL_TREE, protocol_name, initlist);
initlist = tree_cons (NULL_TREE, protocol_list, initlist);
if (!instance_methods)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
+ expr = convert (objc_method_proto_list_ptr,
+ build_unary_op (ADDR_EXPR, instance_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = build_unary_op (ADDR_EXPR, class_methods, 0);
+ expr = convert (objc_method_proto_list_ptr,
+ build_unary_op (ADDR_EXPR, class_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return objc_build_constructor (type, nreverse (initlist));
}
\f
-/* struct objc_category {
+/* 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;
+ struct _objc_method_list *instance_methods;
+ struct _objc_method_list *class_methods;
+ struct _objc_protocol_list *protocols;
}; */
static void
build_category_template (void)
{
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
objc_category_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_CATEGORY));
- /* char *category_name; */
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("category_name"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* char *category_name; */
+ field_decl = create_field_decl (string_type_node, "category_name");
field_decl_chain = field_decl;
/* char *class_name; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_name"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (string_type_node, "class_name");
chainon (field_decl_chain, field_decl);
- /* struct objc_method_list *instance_methods; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_LIST)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("instance_methods"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_method_list *instance_methods; */
+ field_decl = create_field_decl (objc_method_list_ptr,
+ "instance_methods");
chainon (field_decl_chain, field_decl);
- /* struct objc_method_list *class_methods; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_LIST)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class_methods"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_method_list *class_methods; */
+ field_decl = create_field_decl (objc_method_list_ptr,
+ "class_methods");
chainon (field_decl_chain, field_decl);
- /* struct objc_protocol **protocol_list; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_PROTOCOL)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_protocol **protocol_list; */
+ field_decl = create_field_decl (build_pointer_type
+ (build_pointer_type
+ (objc_protocol_template)),
+ "protocol_list");
chainon (field_decl_chain, field_decl);
finish_struct (objc_category_template, field_decl_chain, NULL_TREE);
}
-/* struct objc_selector {
- void *sel_id;
+/* struct _objc_selector {
+ SEL sel_id;
char *sel_type;
}; */
build_selector_template (void)
{
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
objc_selector_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_SELECTOR));
- /* void *sel_id; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_id"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* SEL sel_id; */
+ field_decl = create_field_decl (objc_selector_type, "sel_id");
field_decl_chain = field_decl;
/* char *sel_type; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_type"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (string_type_node, "sel_type");
chainon (field_decl_chain, field_decl);
finish_struct (objc_selector_template, field_decl_chain, NULL_TREE);
}
-/* struct objc_class {
- struct objc_class *isa;
- struct objc_class *super_class;
+/* 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;
- if (flag_next_runtime)
+ struct _objc_ivar_list *ivars;
+ struct _objc_method_list *methods;
+ #ifdef __NEXT_RUNTIME__
struct objc_cache *cache;
- else {
+ #else
struct sarray *dtable;
- struct objc_class *subclass_list;
- struct objc_class *sibling_class;
- }
- struct objc_protocol_list *protocols;
- if (flag_next_runtime)
+ struct _objc_class *subclass_list;
+ struct _objc_class *sibling_class;
+ #endif
+ struct _objc_protocol_list *protocols;
+ #ifdef __NEXT_RUNTIME__
void *sel_id;
+ #endif
void *gc_object_type;
}; */
static void
build_class_template (void)
{
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
objc_class_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_CLASS));
- /* struct objc_class *isa; */
-
- decl_specs = build_tree_list (NULL_TREE, objc_class_template);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("isa"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_class *isa; */
+ field_decl = create_field_decl (build_pointer_type (objc_class_template),
+ "isa");
field_decl_chain = field_decl;
- /* struct objc_class *super_class; */
-
- decl_specs = build_tree_list (NULL_TREE, objc_class_template);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("super_class"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_class *super_class; */
+ field_decl = create_field_decl (build_pointer_type (objc_class_template),
+ "super_class");
chainon (field_decl_chain, field_decl);
/* char *name; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("name"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (string_type_node, "name");
chainon (field_decl_chain, field_decl);
/* long version; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
- field_decl = get_identifier ("version");
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (long_integer_type_node, "version");
chainon (field_decl_chain, field_decl);
/* long info; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
- field_decl = get_identifier ("info");
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (long_integer_type_node, "info");
chainon (field_decl_chain, field_decl);
/* long instance_size; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_LONG]);
- field_decl = get_identifier ("instance_size");
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (long_integer_type_node, "instance_size");
chainon (field_decl_chain, field_decl);
- /* struct objc_ivar_list *ivars; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_IVAR_LIST)));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivars"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_ivar_list *ivars; */
+ field_decl = create_field_decl (objc_ivar_list_ptr,
+ "ivars");
chainon (field_decl_chain, field_decl);
- /* struct objc_method_list *methods; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_LIST)));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("methods"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_method_list *methods; */
+ field_decl = create_field_decl (objc_method_list_ptr,
+ "methods");
chainon (field_decl_chain, field_decl);
if (flag_next_runtime)
{
/* struct objc_cache *cache; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier ("objc_cache")));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("cache"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type
+ (xref_tag (RECORD_TYPE,
+ get_identifier
+ ("objc_cache"))),
+ "cache");
chainon (field_decl_chain, field_decl);
}
else
{
/* struct sarray *dtable; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier ("sarray")));
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("dtable"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type
+ (xref_tag (RECORD_TYPE,
+ get_identifier
+ ("sarray"))),
+ "dtable");
chainon (field_decl_chain, field_decl);
/* struct objc_class *subclass_list; */
-
- decl_specs = build_tree_list (NULL_TREE, objc_class_template);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("subclass_list"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type
+ (objc_class_template),
+ "subclass_list");
chainon (field_decl_chain, field_decl);
/* struct objc_class *sibling_class; */
-
- decl_specs = build_tree_list (NULL_TREE, objc_class_template);
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sibling_class"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type
+ (objc_class_template),
+ "sibling_class");
chainon (field_decl_chain, field_decl);
}
- /* struct objc_protocol **protocol_list; */
-
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_PROTOCOL)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("protocol_list"));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, field_decl);
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_protocol **protocol_list; */
+ field_decl = create_field_decl (build_pointer_type
+ (build_pointer_type
+ (xref_tag (RECORD_TYPE,
+ get_identifier
+ (UTAG_PROTOCOL)))),
+ "protocol_list");
chainon (field_decl_chain, field_decl);
if (flag_next_runtime)
{
/* void *sel_id; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("sel_id"));
- field_decl
- = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type (void_type_node),
+ "sel_id");
chainon (field_decl_chain, field_decl);
}
/* void *gc_object_type; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_VOID]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("gc_object_type"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type (void_type_node),
+ "gc_object_type");
chainon (field_decl_chain, field_decl);
finish_struct (objc_class_template, field_decl_chain, NULL_TREE);
/* static struct objc_class _OBJC_CLASS_<my_name>; */
UOBJC_CLASS_decl = build_metadata_decl ("_OBJC_CLASS",
- objc_class_template);
+ objc_class_template);
/* static struct objc_class _OBJC_METACLASS_<my_name>; */
UOBJC_METACLASS_decl = build_metadata_decl ("_OBJC_METACLASS",
/* Pre-build the following entities - for speed/convenience. */
an_id = get_identifier ("super_class");
- ucls_super_ref = build_component_ref (UOBJC_CLASS_decl, an_id);
- uucls_super_ref = build_component_ref (UOBJC_METACLASS_decl, an_id);
+ ucls_super_ref = objc_build_component_ref (UOBJC_CLASS_decl, an_id);
+ uucls_super_ref = objc_build_component_ref (UOBJC_METACLASS_decl, an_id);
}
static void
-error_with_ivar (const char *message, tree decl, tree rawdecl)
+error_with_ivar (const char *message, tree decl)
{
- error ("%J%s `%s'", decl,
- message, gen_declaration (rawdecl, errbuf));
+ error ("%J%s %qs", decl,
+ message, gen_declaration (decl));
}
static void
check_ivars (tree inter, tree imp)
{
- tree intdecls = CLASS_IVARS (inter);
- tree impdecls = CLASS_IVARS (imp);
- tree rawintdecls = CLASS_RAW_IVARS (inter);
- tree rawimpdecls = CLASS_RAW_IVARS (imp);
+ tree intdecls = CLASS_RAW_IVARS (inter);
+ tree impdecls = CLASS_RAW_IVARS (imp);
while (1)
{
t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
- if (!comptypes (t1, t2, false)
- || !tree_int_cst_equal (TREE_VALUE (TREE_VALUE (rawintdecls)),
- TREE_VALUE (TREE_VALUE (rawimpdecls))))
+ 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, rawimpdecls);
+ impdecls);
error_with_ivar ("previous declaration of",
- intdecls, rawintdecls);
+ intdecls);
}
else /* both the type and the name don't match */
{
else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable name",
- impdecls, rawimpdecls);
+ impdecls);
error_with_ivar ("previous declaration of",
- intdecls, rawintdecls);
+ intdecls);
}
intdecls = TREE_CHAIN (intdecls);
impdecls = TREE_CHAIN (impdecls);
- rawintdecls = TREE_CHAIN (rawintdecls);
- rawimpdecls = TREE_CHAIN (rawimpdecls);
}
}
/* 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;
+ }; */
+
static void
build_super_template (void)
{
- tree decl_specs, field_decl, field_decl_chain;
-
- /* Suppress outputting debug symbols, because
- dbxout_init hasn't been called yet. */
- enum debug_info_type save_write_symbols = write_symbols;
- const struct gcc_debug_hooks *save_hooks = debug_hooks;
-
- write_symbols = NO_DEBUG;
- debug_hooks = &do_nothing_debug_hooks;
+ tree field_decl, field_decl_chain;
objc_super_template = start_struct (RECORD_TYPE, get_identifier (UTAG_SUPER));
- /* struct objc_object *self; */
-
- decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
- field_decl = get_identifier ("self");
- field_decl = build1 (INDIRECT_REF, NULL_TREE, field_decl);
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_object *self; */
+ field_decl = create_field_decl (objc_object_type, "self");
field_decl_chain = field_decl;
-#ifdef OBJCPLUS
- /* struct objc_class *super_class; */
-#else
- /* struct objc_class *class; */
-#endif
-
- decl_specs = get_identifier (UTAG_CLASS);
- decl_specs = build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE, decl_specs));
-#ifdef OBJCPLUS
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("super_class"));
-#else
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("class"));
-#endif
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc_class *super_class; */
+ field_decl = create_field_decl (build_pointer_type (objc_class_template),
+ "super_class");
chainon (field_decl_chain, field_decl);
finish_struct (objc_super_template, field_decl_chain, NULL_TREE);
-
- write_symbols = save_write_symbols;
- debug_hooks = save_hooks;
}
-/* struct objc_ivar {
+/* struct _objc_ivar {
char *ivar_name;
char *ivar_type;
int ivar_offset;
build_ivar_template (void)
{
tree objc_ivar_id, objc_ivar_record;
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
objc_ivar_id = get_identifier (UTAG_IVAR);
objc_ivar_record = start_struct (RECORD_TYPE, objc_ivar_id);
/* char *ivar_name; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivar_name"));
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (string_type_node, "ivar_name");
field_decl_chain = field_decl;
/* char *ivar_type; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_CHAR]);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("ivar_type"));
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (string_type_node, "ivar_type");
chainon (field_decl_chain, field_decl);
/* int ivar_offset; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
- field_decl = get_identifier ("ivar_offset");
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (integer_type_node, "ivar_offset");
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_record, field_decl_chain, NULL_TREE);
build_ivar_list_template (tree list_type, int size)
{
tree objc_ivar_list_record;
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
/* int ivar_count; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
- field_decl = get_identifier ("ivar_count");
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (integer_type_node, "ivar_count");
field_decl_chain = field_decl;
/* struct objc_ivar ivar_list[]; */
-
- decl_specs = build_tree_list (NULL_TREE, list_type);
- field_decl = build_nt (ARRAY_REF, get_identifier ("ivar_list"),
- build_int_2 (size, 0));
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_array_type
+ (list_type,
+ build_index_type
+ (build_int_cst (NULL_TREE, size - 1))),
+ "ivar_list");
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
}
/* struct {
- int method_next;
+ struct _objc__method_prototype_list *method_next;
int method_count;
struct objc_method method_list[method_count];
}; */
build_method_list_template (tree list_type, int size)
{
tree objc_ivar_list_record;
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
- /* int method_next; */
-
- decl_specs
- = build_tree_list
- (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
- field_decl
- = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("method_next"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* struct _objc__method_prototype_list *method_next; */
+ field_decl = create_field_decl (objc_method_proto_list_ptr,
+ "method_next");
field_decl_chain = field_decl;
/* int method_count; */
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_INT]);
- field_decl = get_identifier ("method_count");
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (integer_type_node, "method_count");
chainon (field_decl_chain, field_decl);
/* struct objc_method method_list[]; */
-
- decl_specs = build_tree_list (NULL_TREE, list_type);
- field_decl = build_nt (ARRAY_REF, get_identifier ("method_list"),
- build_int_2 (size, 0));
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_array_type
+ (list_type,
+ build_index_type
+ (build_int_cst (NULL_TREE, size - 1))),
+ "method_list");
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
ivar);
else
/* Unnamed bit-field ivar (yuck). */
- ivar = tree_cons (NULL_TREE, build_int_2 (0, 0), ivar);
+ ivar = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), ivar);
/* Set type. */
encode_field_decl (field_decl,
static tree
generate_ivars_list (tree type, const char *name, int size, tree list)
{
- tree sc_spec, decl_specs, decl, initlist;
+ tree decl, initlist;
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, type, sc_spec);
+ decl = start_var_decl (type, synth_id_with_class_suffix
+ (name, objc_implementation_context));
- decl = start_decl (synth_id_with_class_suffix (name, objc_implementation_context),
- decl_specs, 1, NULL_TREE);
-
- initlist = build_tree_list (NULL_TREE, build_int_2 (size, 0));
+ initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
initlist = tree_cons (NULL_TREE, list, initlist);
- finish_decl (decl,
- objc_build_constructor (TREE_TYPE (decl), nreverse (initlist)),
- NULL_TREE);
+ finish_var_decl (decl,
+ objc_build_constructor (TREE_TYPE (decl),
+ nreverse (initlist)));
return decl;
}
generate_ivar_lists (void)
{
tree initlist, ivar_list_template, chain;
- tree cast, variable_length_type;
int size;
generating_instance_variables = 1;
if (!objc_ivar_template)
objc_ivar_template = build_ivar_template ();
- cast
- = build_tree_list
- (build_tree_list (NULL_TREE, xref_tag (RECORD_TYPE,
- get_identifier (UTAG_IVAR_LIST))),
- NULL_TREE);
- variable_length_type = groktypename (cast);
-
/* Only generate class variables for the root of the inheritance
hierarchy since these will be the same for every class. */
UOBJC_CLASS_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
size, initlist);
- TREE_TYPE (UOBJC_CLASS_VARIABLES_decl) = variable_length_type;
}
else
UOBJC_CLASS_VARIABLES_decl = 0;
UOBJC_INSTANCE_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
size, initlist);
- TREE_TYPE (UOBJC_INSTANCE_VARIABLES_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_VARIABLES_decl = 0;
meth_var_types),
elemlist);
- elemlist = tree_cons (NULL_TREE,
- build_unary_op (ADDR_EXPR,
- METHOD_DEFINITION (entries), 1),
- elemlist);
+ elemlist
+ = tree_cons (NULL_TREE,
+ convert (ptr_type_node,
+ build_unary_op (ADDR_EXPR,
+ METHOD_DEFINITION (entries), 1)),
+ elemlist);
initlist = tree_cons (NULL_TREE,
objc_build_constructor (type, nreverse (elemlist)),
build_method_template (void)
{
tree _SLT_record;
- tree decl_specs, field_decl, field_decl_chain;
+ tree field_decl, field_decl_chain;
_SLT_record = start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD));
- /* struct objc_selector *_cmd; */
- decl_specs = tree_cons (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (TAG_SELECTOR)),
- NULL_TREE);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_cmd"));
-
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* SEL _cmd; */
+ field_decl = create_field_decl (objc_selector_type, "_cmd");
field_decl_chain = field_decl;
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_CHAR], NULL_TREE);
- field_decl = build1 (INDIRECT_REF, NULL_TREE,
- get_identifier ("method_types"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ /* char *method_types; */
+ field_decl = create_field_decl (string_type_node, "method_types");
chainon (field_decl_chain, field_decl);
/* void *_imp; */
-
- decl_specs = tree_cons (NULL_TREE, ridpointers[(int) RID_VOID], NULL_TREE);
- field_decl = build1 (INDIRECT_REF, NULL_TREE, get_identifier ("_imp"));
- field_decl = grokfield (field_decl, decl_specs, NULL_TREE);
+ field_decl = create_field_decl (build_pointer_type (void_type_node),
+ "_imp");
chainon (field_decl_chain, field_decl);
finish_struct (_SLT_record, field_decl_chain, NULL_TREE);
static tree
generate_dispatch_table (tree type, const char *name, int size, tree list)
{
- tree sc_spec, decl_specs, decl, initlist;
-
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, type, sc_spec);
+ tree decl, initlist;
- decl = start_decl (synth_id_with_class_suffix (name, objc_implementation_context),
- decl_specs, 1, NULL_TREE);
+ decl = start_var_decl (type, synth_id_with_class_suffix
+ (name, objc_implementation_context));
- initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
- initlist = tree_cons (NULL_TREE, build_int_2 (size, 0), initlist);
+ initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
initlist = tree_cons (NULL_TREE, list, initlist);
- finish_decl (decl,
- objc_build_constructor (TREE_TYPE (decl), nreverse (initlist)),
- NULL_TREE);
+ finish_var_decl (decl,
+ objc_build_constructor (TREE_TYPE (decl),
+ nreverse (initlist)));
return decl;
}
generate_dispatch_tables (void)
{
tree initlist, chain, method_list_template;
- tree cast, variable_length_type;
int size;
if (!objc_method_template)
objc_method_template = build_method_template ();
- cast
- = build_tree_list
- (build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_METHOD_LIST))),
- NULL_TREE);
-
- variable_length_type = groktypename (cast);
-
chain = CLASS_CLS_METHODS (objc_implementation_context);
if (chain)
{
? "_OBJC_CLASS_METHODS"
: "_OBJC_CATEGORY_CLASS_METHODS"),
size, initlist);
- TREE_TYPE (UOBJC_CLASS_METHODS_decl) = variable_length_type;
}
else
UOBJC_CLASS_METHODS_decl = 0;
= generate_dispatch_table (method_list_template,
"_OBJC_CATEGORY_INSTANCE_METHODS",
size, initlist);
- TREE_TYPE (UOBJC_INSTANCE_METHODS_decl) = variable_length_type;
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
static tree
generate_protocol_list (tree i_or_p)
{
- tree initlist, decl_specs, sc_spec;
- tree refs_decl, expr_decl, lproto, e, plist;
- tree cast_type;
+ tree initlist;
+ tree refs_decl, lproto, e, plist;
int size = 0;
+ const char *ref_name;
if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE
|| TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
else
abort ();
- cast_type = groktypename
- (build_tree_list
- (build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_PROTOCOL))),
- build1 (INDIRECT_REF, NULL_TREE, NULL_TREE)));
-
/* Compute size. */
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
size++;
/* Build initializer. */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), NULL_TREE);
-
- e = build_int_2 (size, 0);
- TREE_TYPE (e) = cast_type;
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), NULL_TREE);
+ e = build_int_cst (build_pointer_type (objc_protocol_template), size);
initlist = tree_cons (NULL_TREE, e, initlist);
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
/* static struct objc_protocol *refs[n]; */
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, xref_tag (RECORD_TYPE,
- get_identifier (UTAG_PROTOCOL)),
- sc_spec);
-
if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
- expr_decl = build_nt (ARRAY_REF,
- synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS",
- i_or_p),
- build_int_2 (size + 2, 0));
+ ref_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS", i_or_p);
else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
- expr_decl = build_nt (ARRAY_REF,
- synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS",
- i_or_p),
- build_int_2 (size + 2, 0));
+ ref_name = synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS", i_or_p);
else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
- expr_decl
- = build_nt (ARRAY_REF,
- synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS",
- i_or_p),
- build_int_2 (size + 2, 0));
+ ref_name = synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS", i_or_p);
else
abort ();
- expr_decl = build1 (INDIRECT_REF, NULL_TREE, expr_decl);
+ refs_decl = start_var_decl
+ (build_array_type
+ (build_pointer_type (objc_protocol_template),
+ build_index_type (build_int_cst (NULL_TREE, size + 2))),
+ ref_name);
- refs_decl = start_decl (expr_decl, decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (refs_decl) = NULL_TREE;
-
- finish_decl (refs_decl, objc_build_constructor (TREE_TYPE (refs_decl),
- nreverse (initlist)),
- NULL_TREE);
+ finish_var_decl (refs_decl, objc_build_constructor (TREE_TYPE (refs_decl),
+ nreverse (initlist)));
return refs_decl;
}
initlist = tree_cons (NULL_TREE, class_name, initlist);
if (!instance_methods)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = build_unary_op (ADDR_EXPR, instance_methods, 0);
+ expr = convert (objc_method_list_ptr,
+ build_unary_op (ADDR_EXPR, instance_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = build_unary_op (ADDR_EXPR, class_methods, 0);
+ expr = convert (objc_method_list_ptr,
+ build_unary_op (ADDR_EXPR, class_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* protocol_list = */
if (!protocol_list)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
- {
- tree cast_type2 = groktypename
- (build_tree_list
- (build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_PROTOCOL))),
- build1 (INDIRECT_REF, NULL_TREE,
- build1 (INDIRECT_REF, NULL_TREE, NULL_TREE))));
-
- expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
- TREE_TYPE (expr) = cast_type2;
- initlist = tree_cons (NULL_TREE, expr, initlist);
- }
+ {
+ expr = convert (build_pointer_type
+ (build_pointer_type
+ (objc_protocol_template)),
+ build_unary_op (ADDR_EXPR, protocol_list, 0));
+ initlist = tree_cons (NULL_TREE, expr, initlist);
+ }
return objc_build_constructor (type, nreverse (initlist));
}
-/* struct objc_class {
+/* struct _objc_class {
struct objc_class *isa;
struct objc_class *super_class;
char *name;
initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
/* version = */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (long_integer_type_node, 0),
+ initlist);
/* info = */
- initlist = tree_cons (NULL_TREE, build_int_2 (status, 0), initlist);
+ initlist = tree_cons (NULL_TREE,
+ build_int_cst (long_integer_type_node, status),
+ initlist);
/* instance_size = */
- initlist = tree_cons (NULL_TREE, size, initlist);
+ initlist = tree_cons (NULL_TREE, convert (long_integer_type_node, size),
+ initlist);
/* objc_ivar_list = */
if (!ivar_list)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = build_unary_op (ADDR_EXPR, ivar_list, 0);
+ expr = convert (objc_ivar_list_ptr,
+ build_unary_op (ADDR_EXPR, ivar_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
/* objc_method_list = */
if (!dispatch_table)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
- expr = build_unary_op (ADDR_EXPR, dispatch_table, 0);
+ expr = convert (objc_method_list_ptr,
+ build_unary_op (ADDR_EXPR, dispatch_table, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (flag_next_runtime)
/* method_cache = */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
{
/* dtable = */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
/* subclass_list = */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
/* sibling_class = */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
}
/* protocol_list = */
if (! protocol_list)
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
else
- {
- tree cast_type2
- = groktypename
- (build_tree_list
- (build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (UTAG_PROTOCOL))),
- build1 (INDIRECT_REF, NULL_TREE,
- build1 (INDIRECT_REF, NULL_TREE, NULL_TREE))));
-
- expr = build_unary_op (ADDR_EXPR, protocol_list, 0);
- TREE_TYPE (expr) = cast_type2;
- initlist = tree_cons (NULL_TREE, expr, initlist);
- }
+ {
+ expr = convert (build_pointer_type
+ (build_pointer_type
+ (objc_protocol_template)),
+ build_unary_op (ADDR_EXPR, protocol_list, 0));
+ initlist = tree_cons (NULL_TREE, expr, initlist);
+ }
if (flag_next_runtime)
/* sel_id = NULL */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
/* gc_object_type = NULL */
- initlist = tree_cons (NULL_TREE, build_int_2 (0, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
return objc_build_constructor (type, nreverse (initlist));
}
static void
generate_category (tree cat)
{
- tree sc_spec, decl_specs, decl;
+ tree decl;
tree initlist, cat_name_expr, class_name_expr;
tree protocol_decl, category;
else
protocol_decl = 0;
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- decl_specs = tree_cons (NULL_TREE, objc_category_template, sc_spec);
-
- decl = start_decl (synth_id_with_class_suffix ("_OBJC_CATEGORY",
- objc_implementation_context),
- decl_specs, 1, NULL_TREE);
+ decl = start_var_decl (objc_category_template,
+ synth_id_with_class_suffix
+ ("_OBJC_CATEGORY", objc_implementation_context));
initlist = build_category_initializer (TREE_TYPE (decl),
cat_name_expr, class_name_expr,
UOBJC_CLASS_METHODS_decl,
protocol_decl);
- finish_decl (decl, initlist, NULL_TREE);
+ finish_var_decl (decl, initlist);
}
/* static struct objc_class _OBJC_METACLASS_Foo={ ... };
static struct objc_class _OBJC_CLASS_Foo={ ... }; */
static void
-generate_shared_structures (void)
+generate_shared_structures (int cls_flags)
{
tree sc_spec, decl_specs, decl;
tree name_expr, super_expr, root_expr;
/* No super class. */
my_root_id = CLASS_NAME (implementation_template);
- cast_type
- = groktypename (build_tree_list (build_tree_list (NULL_TREE,
- objc_class_template),
- build1 (INDIRECT_REF,
- NULL_TREE, NULL_TREE)));
-
+ cast_type = build_pointer_type (objc_class_template);
name_expr = add_objc_string (CLASS_NAME (implementation_template),
class_names);
super_expr = build_c_cast (cast_type, super_expr); /* cast! */
}
else
- super_expr = build_int_2 (0, 0);
+ super_expr = build_int_cst (NULL_TREE, 0);
root_expr = add_objc_string (my_root_id, class_names);
root_expr = build_c_cast (cast_type, root_expr); /* cast! */
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
- decl = start_decl (DECL_NAME (UOBJC_METACLASS_decl), decl_specs, 1,
- NULL_TREE);
+ decl = start_var_decl (objc_class_template,
+ IDENTIFIER_POINTER
+ (DECL_NAME (UOBJC_METACLASS_decl)));
initlist
= build_shared_structure_initializer
UOBJC_CLASS_VARIABLES_decl,
protocol_decl);
- finish_decl (decl, initlist, NULL_TREE);
+ finish_var_decl (decl, initlist);
/* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
- decl = start_decl (DECL_NAME (UOBJC_CLASS_decl), decl_specs, 1,
- NULL_TREE);
+ decl = start_var_decl (objc_class_template,
+ IDENTIFIER_POINTER
+ (DECL_NAME (UOBJC_CLASS_decl)));
initlist
= build_shared_structure_initializer
convert (integer_type_node,
TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
(implementation_template))),
- 1 /*CLS_FACTORY*/,
+ 1 /*CLS_FACTORY*/ | cls_flags,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_INSTANCE_VARIABLES_decl,
protocol_decl);
- finish_decl (decl, initlist, NULL_TREE);
+ finish_var_decl (decl, initlist);
}
-static tree
+
+static const char *
synth_id_with_class_suffix (const char *preamble, tree ctxt)
{
- char *string;
+ static char string[BUFSIZE];
+
if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
{
- const char *const class_name
- = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
- string = (char *) alloca (strlen (preamble) + strlen (class_name) + 3);
sprintf (string, "%s_%s", preamble,
IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
}
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
const char *const class_super_name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context));
- string = (char *) alloca (strlen (preamble)
- + strlen (class_name)
- + strlen (class_super_name)
- + 3);
sprintf (string, "%s_%s_%s", preamble, class_name, class_super_name);
}
else if (TREE_CODE (ctxt) == PROTOCOL_INTERFACE_TYPE)
{
const char *protocol_name = IDENTIFIER_POINTER (PROTOCOL_NAME (ctxt));
- string
- = (char *) alloca (strlen (preamble) + strlen (protocol_name) + 3);
sprintf (string, "%s_%s", preamble, protocol_name);
}
else
abort ();
- return get_identifier (string);
-}
-
-static int
-is_objc_type_qualifier (tree node)
-{
- return (TREE_CODE (node) == IDENTIFIER_NODE
- && (node == ridpointers [(int) RID_CONST]
- || node == ridpointers [(int) RID_VOLATILE]
- || node == ridpointers [(int) RID_IN]
- || node == ridpointers [(int) RID_OUT]
- || node == ridpointers [(int) RID_INOUT]
- || node == ridpointers [(int) RID_BYCOPY]
- || node == ridpointers [(int) RID_BYREF]
- || node == ridpointers [(int) RID_ONEWAY]));
+ return string;
}
/* If type is empty or only type qualifiers are present, add default
static tree
adjust_type_for_id_default (tree type)
{
- tree declspecs, chain;
-
if (!type)
- return build_tree_list (build_tree_list (NULL_TREE, objc_object_reference),
- build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
-
- declspecs = TREE_PURPOSE (type);
+ type = make_node (TREE_LIST);
- /* Determine if a typespec is present. */
- for (chain = declspecs;
- chain;
- chain = TREE_CHAIN (chain))
- {
- if (TYPED_OBJECT (TREE_VALUE (chain))
- && !(TREE_VALUE (type)
- && TREE_CODE (TREE_VALUE (type)) == INDIRECT_REF))
- error ("can not use an object as parameter to a method\n");
- if (!is_objc_type_qualifier (TREE_VALUE (chain)))
- return type;
- }
+ 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 build_tree_list (tree_cons (NULL_TREE, objc_object_reference,
- declspecs),
- build1 (INDIRECT_REF, NULL_TREE, NULL_TREE));
+ return type;
}
/* Usage:
Out: an instance of "keyword_decl". */
tree
-build_keyword_decl (tree key_name, tree arg_type, tree arg_name)
+objc_build_keyword_decl (tree key_name, tree arg_type, tree arg_name)
{
tree keyword_decl;
/* Used for declarations and definitions. */
-tree
+static tree
build_method_decl (enum tree_code code, tree ret_type, tree selector,
- tree add_args)
+ tree add_args, bool ellipsis)
{
tree method_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
{
/* Receiver type. */
if (flag_next_runtime && superflag)
- arglist = build_tree_list (NULL_TREE, super_type);
- else if (context == METHOD_DEF)
- arglist = build_tree_list (NULL_TREE, TREE_TYPE (self_decl));
+ arglist = build_tree_list (NULL_TREE, objc_super_type);
+ else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
+ arglist = build_tree_list (NULL_TREE, objc_instance_type);
else
- arglist = build_tree_list (NULL_TREE, id_type);
+ arglist = build_tree_list (NULL_TREE, objc_object_type);
/* Selector type - will eventually change to `int'. */
- chainon (arglist, build_tree_list (NULL_TREE, selector_type));
+ chainon (arglist, build_tree_list (NULL_TREE, objc_selector_type));
/* No actual method prototype given -- assume that remaining arguments
are `...'. */
/* Build a list of argument types. */
for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
{
- tree arg_decl = groktypename_in_parm_context (TREE_TYPE (akey));
- chainon (arglist, build_tree_list (NULL_TREE, TREE_TYPE (arg_decl)));
+ tree arg_type = TREE_VALUE (TREE_TYPE (akey));
+
+ /* Decay arrays and functions into pointers. */
+ if (TREE_CODE (arg_type) == ARRAY_TYPE)
+ arg_type = build_pointer_type (TREE_TYPE (arg_type));
+ else if (TREE_CODE (arg_type) == FUNCTION_TYPE)
+ arg_type = build_pointer_type (arg_type);
+
+ chainon (arglist, build_tree_list (NULL_TREE, arg_type));
}
- if (METHOD_ADD_ARGS (meth) == objc_ellipsis_node)
- /* We have a `, ...' immediately following the selector,
- finalize the arglist...simulate get_parm_info (0). */
- ;
- else if (METHOD_ADD_ARGS (meth))
+ if (METHOD_ADD_ARGS (meth))
{
- /* we have a variable length selector */
- tree add_arg_list = TREE_CHAIN (METHOD_ADD_ARGS (meth));
- chainon (arglist, add_arg_list);
+ for (akey = TREE_CHAIN (METHOD_ADD_ARGS (meth));
+ akey; akey = TREE_CHAIN (akey))
+ {
+ tree arg_type = TREE_TYPE (TREE_VALUE (akey));
+
+ chainon (arglist, build_tree_list (NULL_TREE, arg_type));
+ }
+
+ if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth))
+ goto lack_of_ellipsis;
}
else
- /* finalize the arglist...simulate get_parm_info (1) */
- chainon (arglist, OBJC_VOID_AT_END);
+ {
+ lack_of_ellipsis:
+ chainon (arglist, OBJC_VOID_AT_END);
+ }
return arglist;
}
different types. */
attr loop;
- warning ("multiple %s named `%c%s' found",
+ /* But just how different are those types? If
+ -Wno-strict-selector-match is specified, we shall not
+ complain if the differences are solely among types with
+ identical size and alignment. */
+ if (!warn_strict_selector_match)
+ {
+ for (loop = hsh->list; loop; loop = loop->next)
+ if (!comp_proto_with_proto (meth, loop->value, 0))
+ goto issue_warning;
+
+ return meth;
+ }
+
+ issue_warning:
+ warning (0, "multiple %s named %<%c%s%> found",
methods ? "methods" : "selectors",
(is_class ? '+' : '-'),
IDENTIFIER_POINTER (METHOD_SEL_NAME (meth)));
}
/* If RECEIVER is a class reference, return the identifier node for
- the referenced class. RECEIVER is created by get_class_reference,
+ the referenced class. RECEIVER is created by objc_get_class_reference,
so we check the exact form created depending on which runtimes are
used. */
{
/* The receiver is a variable created by
build_class_reference_decl. */
- if (TREE_CODE (receiver) == VAR_DECL
- && TREE_TYPE (TREE_TYPE (receiver)) == TREE_TYPE (objc_class_type))
+ if (TREE_CODE (receiver) == VAR_DECL && IS_CLASS (TREE_TYPE (receiver)))
/* Look up the identifier. */
for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
if (TREE_PURPOSE (chain) == receiver)
&& (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(). Thankfuly, they seem to share the
+ 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)), TAG_GETCLASS)
(*(<abstract_decl>(*)())_msgSuper)(receiver, selTransTbl[n], ...); */
tree
-build_message_expr (tree mess)
+objc_build_message_expr (tree mess)
{
tree receiver = TREE_PURPOSE (mess);
tree sel_name;
+#ifdef OBJCPLUS
+ tree args = TREE_PURPOSE (TREE_VALUE (mess));
+#else
tree args = TREE_VALUE (mess);
+#endif
tree method_params = NULL_TREE;
if (TREE_CODE (receiver) == ERROR_MARK)
/* Build the parameter list to give to the method. */
if (TREE_CODE (args) == TREE_LIST)
+#ifdef OBJCPLUS
+ method_params = chainon (args, TREE_VALUE (TREE_VALUE (mess)));
+#else
{
tree chain = args, prev = NULL_TREE;
}
method_params = args;
}
+#endif
#ifdef OBJCPLUS
if (processing_template_decl)
method_params);
#endif
- return finish_message_expr (receiver, sel_name, method_params);
+ return objc_finish_message_expr (receiver, sel_name, method_params);
}
/* Look up method SEL_NAME that would be suitable for receiver
return check_duplicates (method_prototype, 1, is_class);
}
-/* The 'finish_message_expr' routine is called from within
- 'build_message_expr' for non-template functions. In the case of
+/* 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. */
tree
-finish_message_expr (tree receiver, tree sel_name, tree method_params)
+objc_finish_message_expr (tree receiver, tree sel_name, tree method_params)
{
tree method_prototype = NULL_TREE, rprotos = NULL_TREE, rtype;
- tree selector, retval, is_class;
+ tree selector, retval, class_tree;
int self, super, have_cast;
/* Extract the receiver of the message, as well as its type
while (TREE_CODE (rtype) == COMPOUND_EXPR
|| TREE_CODE (rtype) == MODIFY_EXPR
|| TREE_CODE (rtype) == NOP_EXPR
+ || TREE_CODE (rtype) == CONVERT_EXPR
|| TREE_CODE (rtype) == COMPONENT_REF)
rtype = TREE_OPERAND (rtype, 0);
self = (rtype == self_decl);
|| (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. */
- is_class = receiver_is_class_object (receiver, self, super);
+ 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 (is_class)
- rtype = lookup_interface (is_class);
+ if (class_tree)
+ rtype = lookup_interface (class_tree);
/* Handle `self' and `super'. */
else if (super)
{
if (!CLASS_SUPER_NAME (implementation_template))
{
- error ("no super class declared in @interface for `%s'",
+ error ("no super class declared in @interface for %qs",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
/* If receiver is of type `id' or `Class' (or if the @interface for a
class is not visible), we shall be satisfied with the existence of
any instance or class method. */
- if (!rtype || IS_ID (rtype)
- || TREE_TYPE (rtype) == TREE_TYPE (objc_class_type))
+ if (objc_is_id (rtype))
{
- if (!rtype)
- rtype = xref_tag (RECORD_TYPE, is_class);
- else if (IS_ID (rtype))
- {
- rprotos = TYPE_PROTOCOL_LIST (rtype);
- rtype = NULL_TREE;
- }
- else
- is_class = TYPE_NAME (rtype) = get_identifier ("Class");
+ class_tree = (IS_CLASS (rtype) ? objc_class_name : NULL_TREE);
+ rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
+ ? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
+ : NULL_TREE);
+ rtype = NULL_TREE;
if (rprotos)
- method_prototype
- = lookup_method_in_protocol_list (rprotos, sel_name,
- is_class != NULL_TREE);
- if (!method_prototype && !rprotos)
- method_prototype
- = lookup_method_in_hash_lists (sel_name,
- is_class != NULL_TREE);
+ {
+ /* 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 %<-%s%> instead of %<+%s%> in protocol(s)",
+ IDENTIFIER_POINTER (sel_name),
+ IDENTIFIER_POINTER (sel_name));
+ }
+ }
}
- else
+ else if (rtype)
{
tree orig_rtype = rtype, saved_rtype;
if (TREE_CODE (rtype) == POINTER_TYPE)
rtype = TREE_TYPE (rtype);
/* Traverse typedef aliases */
- while (TREE_CODE (rtype) == RECORD_TYPE && TYPE_NAME (rtype)
- && TREE_CODE (TYPE_NAME (rtype)) == TYPE_DECL
- && DECL_ORIGINAL_TYPE (TYPE_NAME (rtype)))
- rtype = DECL_ORIGINAL_TYPE (TYPE_NAME (rtype));
+ 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));
saved_rtype = rtype;
if (TYPED_OBJECT (rtype))
{
- rprotos = TYPE_PROTOCOL_LIST (rtype);
- rtype = lookup_interface (OBJC_TYPE_NAME (rtype));
+ rprotos = TYPE_OBJC_PROTOCOL_LIST (rtype);
+ rtype = TYPE_OBJC_INTERFACE (rtype);
}
/* If we could not find an @interface declaration, we must have
only seen a @class declaration; so, we cannot say anything
more intelligent about which methods the receiver will
understand. */
- if (!rtype)
- rtype = saved_rtype;
+ if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
+ rtype = NULL_TREE;
else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
|| TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
{
in the published @interface for the class (and its
superclasses). */
method_prototype
- = lookup_method_static (rtype, sel_name, is_class != NULL_TREE);
+ = 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. */
== OBJC_TYPE_NAME (rtype))
method_prototype
= lookup_method
- ((is_class
+ ((class_tree
? CLASS_CLS_METHODS (objc_implementation_context)
: CLASS_NST_METHODS (objc_implementation_context)),
sel_name);
if (!method_prototype && rprotos)
method_prototype
= lookup_method_in_protocol_list (rprotos, sel_name,
- is_class != NULL_TREE);
+ class_tree != NULL_TREE);
}
else
{
- warning ("invalid receiver type `%s'",
- gen_declaration (orig_rtype, errbuf));
+ warning (0, "invalid receiver type %qs",
+ gen_type_name (orig_rtype));
+ /* After issuing the "invalid receiver" warning, perform method
+ lookup as if we were messaging 'id'. */
rtype = rprotos = NULL_TREE;
}
}
+
+ /* For 'id' or 'Class' receivers, search in the global hash table
+ as a last resort. For all receivers, warn if protocol searches
+ have failed. */
+ if (!method_prototype)
+ {
+ if (rprotos)
+ warning (0, "%<%c%s%> not found in protocol(s)",
+ (class_tree ? '+' : '-'),
+ IDENTIFIER_POINTER (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 ("`%s' may not respond to `%c%s'",
+ warning (0, "%qs may not respond to %<%c%s%>",
IDENTIFIER_POINTER (OBJC_TYPE_NAME (rtype)),
- (is_class ? '+' : '-'),
+ (class_tree ? '+' : '-'),
IDENTIFIER_POINTER (sel_name));
- if (rprotos)
- warning ("`%c%s' not implemented by protocol(s)",
- (is_class ? '+' : '-'),
+ /* 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%s%> method found",
+ (class_tree ? '+' : '-'),
IDENTIFIER_POINTER (sel_name));
+
if (!warn_missing_methods)
{
- warning ("(Messages without a matching method signature");
- warning ("will be assumed to return `id' and accept");
- warning ("`...' as arguments.)");
+ warning (0, "(Messages without a matching method signature");
+ warning (0, "will be assumed to return %<id%> and accept");
+ warning (0, "%<...%> as arguments.)");
warn_missing_methods = true;
}
}
{
tree sender = (super_flag ? umsg_super_decl :
(!flag_next_runtime || flag_nil_receivers
- ? umsg_decl
+ ? (flag_objc_direct_dispatch
+ ? umsg_fast_decl
+ : umsg_decl)
: umsg_nonnil_decl));
- tree rcv_p = (super_flag ? super_type : id_type);
+ tree rcv_p = (super_flag ? objc_super_type : objc_object_type);
/* 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
- ? groktypename (TREE_TYPE (method_prototype))
- : id_type);
+ ? TREE_VALUE (TREE_TYPE (method_prototype))
+ : objc_object_type);
tree sender_cast
= build_pointer_type
(build_function_type
(ret_type,
get_arg_type_list
(method_prototype, METHOD_REF, super_flag)));
+ tree method, t;
lookup_object = build_c_cast (rcv_p, lookup_object);
+
+ /* Use SAVE_EXPR to avoid evaluating the receiver twice. */
+ lookup_object = save_expr (lookup_object);
if (flag_next_runtime)
{
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
- TREE_USED (sender) = 1;
- assemble_external (sender);
- /* We want to cast the sender, not convert it. */
- return build_function_call (build_c_cast (sender_cast, sender),
- method_params);
+ method = build_fold_addr_expr (sender);
}
else
{
/* This is the portable (GNU) way. */
- tree method, object;
+ tree object;
/* First, call the lookup function to get a pointer to the method,
- then cast the pointer, then call it with the method arguments.
- Use SAVE_EXPR to avoid evaluating the receiver twice. */
- lookup_object = save_expr (lookup_object);
+ then cast the pointer, then call it with the method arguments. */
+
object = (super_flag ? self_decl : lookup_object);
- TREE_USED (sender) = 1;
- assemble_external (sender);
- method
- = build_function_call (sender,
- tree_cons (NULL_TREE, lookup_object,
- tree_cons (NULL_TREE, selector,
- NULL_TREE)));
+
+ t = tree_cons (NULL_TREE, selector, NULL_TREE);
+ t = tree_cons (NULL_TREE, lookup_object, t);
+ method = build_function_call (sender, t);
/* Pass the object to the method. */
- TREE_USED (method) = 1;
- assemble_external (method);
- return build_function_call
- (build_c_cast (sender_cast, method),
- tree_cons (NULL_TREE, object,
- tree_cons (NULL_TREE, selector, method_params)));
+ method_params = tree_cons (NULL_TREE, object,
+ tree_cons (NULL_TREE, selector,
+ method_params));
}
+
+ /* ??? Selector is not at this point something we can use inside
+ the compiler itself. Set it to garbage for the nonce. */
+ t = build (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node);
+ return build_function_call (t, method_params);
}
\f
static void
build_protocol_reference (tree p)
{
- tree decl, ident, ptype;
-
- /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
-
- ident = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
- ptype
- = groktypename (build_tree_list (build_tree_list (NULL_TREE,
- objc_protocol_template),
- NULL_TREE));
+ tree decl;
+ const char *proto_name;
- if (identifier_global_value (ident))
- decl = identifier_global_value (ident); /* Set by pushdecl. */
- else
- {
- decl = build_decl (VAR_DECL, ident, ptype);
- DECL_EXTERNAL (decl) = 1;
- TREE_PUBLIC (decl) = 0;
- TREE_USED (decl) = 1;
- DECL_ARTIFICIAL (decl) = 1;
+ /* static struct _objc_protocol _OBJC_PROTOCOL_<mumble>; */
- make_decl_rtl (decl, 0);
- pushdecl_top_level (decl);
- }
+ proto_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
+ decl = start_var_decl (objc_protocol_template, proto_name);
PROTOCOL_FORWARD_DECL (p) = decl;
}
/* This function is called by the parser when (and only when) a
@protocol() expression is found, in order to compile it. */
tree
-build_protocol_expr (tree protoname)
+objc_build_protocol_expr (tree protoname)
{
tree expr;
tree p = lookup_protocol (protoname);
if (!p)
{
- error ("cannot find protocol declaration for `%s'",
+ error ("cannot find protocol declaration for %qs",
IDENTIFIER_POINTER (protoname));
return error_mark_node;
}
expr = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
- TREE_TYPE (expr) = protocol_type;
+ /* ??? 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
if (! flag_next_runtime)
{
/* This type is a struct containing the fields of a Protocol
- object. (Cfr. protocol_type instead is the type of a pointer
+ object. (Cfr. objc_protocol_type instead is the type of a pointer
to such a struct). */
tree protocol_struct_type = xref_tag
(RECORD_TYPE, get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
is found, in order to compile it. It is only called by the parser
and only to compile a @selector(). */
tree
-build_selector_expr (tree selnamelist)
+objc_build_selector_expr (tree selnamelist)
{
tree selname;
/* If still not found, print out a warning. */
if (!hsh)
{
- warning ("undeclared selector `%s'", IDENTIFIER_POINTER (selname));
+ warning (0, "undeclared selector %qs", IDENTIFIER_POINTER (selname));
}
}
}
tree
-build_encode_expr (tree type)
+objc_build_encode_expr (tree type)
{
tree result;
const char *string;
return result;
}
-tree
+static tree
build_ivar_reference (tree id)
{
if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
to an instance variable. It's better to catch the cases
where this is done unknowingly than to support the above
paradigm. */
- warning ("instance variable `%s' accessed in class method",
+ warning (0, "instance variable %qs accessed in class method",
IDENTIFIER_POINTER (id));
- TREE_TYPE (self_decl) = instance_type; /* cast */
+ self_decl = convert (objc_instance_type, self_decl); /* cast */
}
- return build_component_ref (build_indirect_ref (self_decl, "->"), id);
+ return objc_build_component_ref (build_indirect_ref (self_decl, "->"), id);
}
\f
/* Compute a hash value for a given method SEL_NAME. */
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
cls_method_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
+
+ /* Initialize the hash table used to hold the constant string objects. */
+ string_htab = htab_create_ggc (31, string_hash,
+ string_eq, NULL);
+
+ /* Initialize the hash table used to hold EH-volatilized types. */
+ volatilized_htab = htab_create_ggc (31, volatilized_hash,
+ volatilized_eq, NULL);
}
/* WARNING!!!! hash_enter is called with a method, and will peek
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 cleared, 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.
+
+ If a suitable method cannot be found, return NULL_TREE. */
+
static tree
-lookup_method_static (tree interface, tree ident, int is_class)
+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);
while (inter)
{
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));
{
/* Check types against those; if different, add to a list. */
attr loop;
- int already_there = comp_proto_with_proto (method, hsh->key);
+ int already_there = comp_proto_with_proto (method, hsh->key, 1);
for (loop = hsh->list; !already_there && loop; loop = loop->next)
- already_there |= comp_proto_with_proto (method, loop->value);
+ already_there |= comp_proto_with_proto (method, loop->value, 1);
if (!already_there)
hash_add_attr (hsh, method);
}
}
-tree
+static tree
objc_add_method (tree class, tree method, int is_class)
{
tree mth;
- if (!(mth = lookup_method (is_class ? CLASS_CLS_METHODS (class) : CLASS_NST_METHODS (class), method)))
+ if (!(mth = lookup_method (is_class
+ ? CLASS_CLS_METHODS (class)
+ : CLASS_NST_METHODS (class), method)))
{
/* put method on list in reverse order */
if (is_class)
definition errors). */
if ((TREE_CODE (class) == CLASS_INTERFACE_TYPE
|| TREE_CODE (class) == CATEGORY_INTERFACE_TYPE)
- && !comp_proto_with_proto (method, mth))
- error ("duplicate declaration of method `%c%s'",
- is_class ? '+' : '-', IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
+ && !comp_proto_with_proto (method, mth, 1))
+ error ("duplicate declaration of method %<%c%s%>",
+ is_class ? '+' : '-',
+ IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
if (is_class)
add_method_to_hash_list (nst_method_hash_list, method);
/* Instance methods in root classes (and categories thereof)
- may acts as class methods as a last resort. */
+ 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 (class) == CATEGORY_INTERFACE_TYPE
|| TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
class = lookup_interface (CLASS_NAME (class));
- if (TREE_CODE (class) != PROTOCOL_INTERFACE_TYPE
- && !CLASS_SUPER_NAME (class))
+ if (TREE_CODE (class) == PROTOCOL_INTERFACE_TYPE
+ || !CLASS_SUPER_NAME (class))
add_method_to_hash_list (cls_method_hash_list, method);
}
}
static tree
-add_class (tree class)
+add_class (tree class_name, tree name)
{
+ struct interface_tuple **slot;
+
/* Put interfaces on list in reverse order. */
- TREE_CHAIN (class) = interface_chain;
- interface_chain = class;
+ TREE_CHAIN (class_name) = interface_chain;
+ interface_chain = class_name;
+
+ if (interface_htab == NULL)
+ interface_htab = htab_create_ggc (31, hash_interface, eq_interface, NULL);
+ slot = (struct interface_tuple **)
+ htab_find_slot_with_hash (interface_htab, name,
+ htab_hash_pointer (name),
+ INSERT);
+ if (!*slot)
+ {
+ *slot = (struct interface_tuple *) ggc_alloc_cleared (sizeof (struct interface_tuple));
+ (*slot)->id = name;
+ }
+ (*slot)->class_name = class_name;
+
return interface_chain;
}
if (cat)
{
- warning ("duplicate interface declaration for category `%s(%s)'",
+ warning (0, "duplicate interface declaration for category %<%s(%s)%>",
IDENTIFIER_POINTER (CLASS_NAME (class)),
IDENTIFIER_POINTER (CLASS_SUPER_NAME (category)));
}
PUBLIC is 1 for public, 0 for protected, and 2 for private. */
-tree
-add_instance_variable (tree class, int public, tree declarator,
- tree declspecs, tree width)
+static tree
+add_instance_variable (tree class, int public, tree field_decl)
{
- tree field_decl = grokfield (declarator, declspecs, width);
tree field_type = TREE_TYPE (field_decl);
const char *ivar_name = DECL_NAME (field_decl)
? IDENTIFIER_POINTER (DECL_NAME (field_decl))
: "<unnamed>";
- tree raw_decl;
#ifdef OBJCPLUS
if (TREE_CODE (field_type) == REFERENCE_TYPE)
{
- error ("illegal reference type specified for instance variable `%s'",
+ error ("illegal reference type specified for instance variable %qs",
ivar_name);
/* Return class as is without adding this ivar. */
return class;
#endif
if (field_type == error_mark_node || !TYPE_SIZE (field_type)
- || TYPE_SIZE (field_type) == error_mark_node
+ || TYPE_SIZE (field_type) == error_mark_node)
/* 'type[0]' is allowed, but 'type[]' is not! */
-#ifdef OBJCPLUS
- || (TYPE_SIZE (field_type) == bitsize_zero_node
- && !TREE_OPERAND (declarator, 1))
-#endif
- )
{
- error ("instance variable `%s' has unknown size", ivar_name);
+ error ("instance variable %qs has unknown size", ivar_name);
/* Return class as is without adding this ivar. */
return class;
}
#ifdef OBJCPLUS
- /* zlaski 2001-Apr-24: C++ classes with non-trivial constructors and/or destructors
- cannot be ivars; ditto for classes with vtables. */
- if(IS_AGGR_TYPE (field_type) && (TYPE_NEEDS_CONSTRUCTING (field_type)
- || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type) || TYPE_POLYMORPHIC_P (field_type)))
+ /* 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 (IS_AGGR_TYPE (field_type)
+ && (TYPE_NEEDS_CONSTRUCTING (field_type)
+ || TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type)
+ || TYPE_POLYMORPHIC_P (field_type)))
{
const char *type_name = IDENTIFIER_POINTER (OBJC_TYPE_NAME (field_type));
- if(TYPE_POLYMORPHIC_P (field_type)) {
- /* vtable pointers are Real Bad(tm), since Obj-C cannot initialize them */
- error ("type `%s' has virtual member functions", type_name);
- error ("illegal aggregate type `%s' specified for instance variable `%s'",
- type_name, ivar_name);
- /* Return class as is without adding this ivar. */
- return class;
- }
- /* 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 ("type `%s' has a user-defined constructor", type_name);
- if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
- warning ("type `%s' has a user-defined destructor", type_name);
- warning ("C++ constructors and destructors will not be invoked for Objective-C fields");
+
+ 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 %qs 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 %qs 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 %qs has virtual member functions", type_name);
+ error ("illegal aggregate type %qs specified "
+ "for instance variable %qs",
+ type_name, ivar_name);
+ /* Return class as is without adding this ivar. */
+ return class;
+ }
+
+ /* 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 %qs has a user-defined constructor", type_name);
+ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (field_type))
+ warning (0, "type %qs 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
}
- raw_decl = build_tree_list (declspecs, build_tree_list (declarator, width));
- CLASS_RAW_IVARS (class) = chainon (CLASS_RAW_IVARS (class), raw_decl);
- CLASS_IVARS (class) = chainon (CLASS_IVARS (class), field_decl);
+ CLASS_RAW_IVARS (class) = chainon (CLASS_RAW_IVARS (class), field_decl);
+
return class;
}
\f
-tree
+static tree
is_ivar (tree decl_chain, tree ident)
{
for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain))
/* True if the ivar is private and we are not in its implementation. */
-int
+static int
is_private (tree decl)
{
- if (TREE_PRIVATE (decl)
- && ! is_ivar (CLASS_IVARS (implementation_template), DECL_NAME (decl)))
- {
- error ("instance variable `%s' is declared private",
- IDENTIFIER_POINTER (DECL_NAME (decl)));
- return 1;
- }
- else
- return 0;
+ return (TREE_PRIVATE (decl)
+ && ! is_ivar (CLASS_IVARS (implementation_template),
+ DECL_NAME (decl)));
}
/* We have an instance variable reference;, check to see if it is public. */
int
-is_public (tree expr, tree identifier)
+objc_is_public (tree expr, tree identifier)
{
- tree basetype = TREE_TYPE (expr);
- enum tree_code code = TREE_CODE (basetype);
- tree decl;
+ tree basetype, decl;
+
+#ifdef OBJCPLUS
+ if (processing_template_decl)
+ return 1;
+#endif
+
+ basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
- if (code == RECORD_TYPE)
+ if (basetype && TREE_CODE (basetype) == RECORD_TYPE)
{
- if (TREE_STATIC_TEMPLATE (basetype))
+ if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
{
- if (!lookup_interface (OBJC_TYPE_NAME (basetype)))
+ tree class = lookup_interface (OBJC_TYPE_NAME (basetype));
+
+ if (!class)
{
- error ("cannot find interface declaration for `%s'",
+ error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (OBJC_TYPE_NAME (basetype)));
return 0;
}
- if ((decl = is_ivar (TYPE_FIELDS (basetype), identifier)))
+ if ((decl = is_ivar (get_class_ivars (class, true), identifier)))
{
if (TREE_PUBLIC (decl))
return 1;
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))
- && (CLASS_NAME (objc_implementation_context)
- == OBJC_TYPE_NAME (basetype))))
- return ! is_private (decl);
+ && ((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 private = is_private (decl);
+
+ if (private)
+ error ("instance variable %qs is declared private",
+ IDENTIFIER_POINTER (DECL_NAME (decl)));
+
+ return !private;
+ }
+ }
/* 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 ("instance variable `%s' is %s; "
+ warning (0, "instance variable %qs is %s; "
"this will be a hard error in the future",
IDENTIFIER_POINTER (identifier),
TREE_PRIVATE (decl) ? "@private" : "@protected");
return 1;
}
- error ("instance variable `%s' is declared %s",
+ error ("instance variable %qs is declared %s",
IDENTIFIER_POINTER (identifier),
TREE_PRIVATE (decl) ? "private" : "protected");
return 0;
}
}
-
- else if (objc_implementation_context && (basetype == objc_object_reference))
- {
- TREE_TYPE (expr) = uprivate_record;
- warning ("static access to object of type `id'");
- }
}
return 1;
{
if (TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
- warning ("incomplete implementation of class `%s'",
+ warning (0, "incomplete implementation of class %qs",
IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context)));
else if (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
- warning ("incomplete implementation of category `%s'",
+ warning (0, "incomplete implementation of category %qs",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
first = 0;
}
- warning ("method definition for `%c%s' not found",
+ warning (0, "method definition for %<%c%s%> not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
{
if (TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
- warning ("incomplete implementation of class `%s'",
+ warning (0, "incomplete implementation of class %qs",
IDENTIFIER_POINTER
(CLASS_NAME (objc_implementation_context)));
else if (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
- warning ("incomplete implementation of category `%s'",
+ warning (0, "incomplete implementation of category %qs",
IDENTIFIER_POINTER
(CLASS_SUPER_NAME (objc_implementation_context)));
first = 0;
}
- warning ("method definition for `%c%s' not found",
+ warning (0, "method definition for %<%c%s%> not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
}
if (!f1 || !f2)
- warning ("%s `%s' does not fully implement the `%s' protocol",
+ warning (0, "%s %qs does not fully implement the %qs protocol",
type, name, IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
It can be CLASS_INTERFACE_TYPE, CLASS_IMPLEMENTATION_TYPE,
CATEGORY_INTERFACE_TYPE, or CATEGORY_IMPLEMENTATION_TYPE. */
-tree
+static tree
start_class (enum tree_code code, tree class_name, tree super_name,
tree protocol_list)
{
if (objc_implementation_context)
{
- warning ("`@end' missing in implementation context");
+ warning (0, "%<@end%> missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
class = make_node (code);
- TYPE_BINFO (class) = make_tree_vec (CLASS_BINFO_ELTS);
+ TYPE_LANG_SLOT_1 (class) = 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);
+
+ if (!super || !lookup_interface (super))
+ {
+ error ("cannot find interface declaration for %qs, superclass of %qs",
+ IDENTIFIER_POINTER (super ? super : super_name),
+ IDENTIFIER_POINTER (class_name));
+ super_name = NULL_TREE;
+ }
+ else
+ super_name = super;
+ }
CLASS_NAME (class) = class_name;
CLASS_SUPER_NAME (class) = super_name;
CLASS_CLS_METHODS (class) = NULL_TREE;
- if (! is_class_name (class_name)
+ if (! objc_is_class_name (class_name)
&& (decl = lookup_name (class_name)))
{
- error ("`%s' redeclared as different kind of symbol",
+ error ("%qs redeclared as different kind of symbol",
IDENTIFIER_POINTER (class_name));
- error ("%Jprevious declaration of '%D'",
- decl, decl);
+ error ("previous declaration of %q+D",
+ decl);
}
if (code == CLASS_IMPLEMENTATION_TYPE)
for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
if (TREE_VALUE (chain) == class_name)
{
- error ("reimplementation of class `%s'",
+ error ("reimplementation of class %qs",
IDENTIFIER_POINTER (class_name));
return error_mark_node;
}
if (!(implementation_template = lookup_interface (class_name)))
{
- warning ("cannot find interface declaration for `%s'",
+ warning (0, "cannot find interface declaration for %qs",
IDENTIFIER_POINTER (class_name));
- add_class (implementation_template = objc_implementation_context);
+ add_class (implementation_template = objc_implementation_context,
+ class_name);
}
/* If a super class has been specified in the implementation,
tree previous_name = CLASS_SUPER_NAME (implementation_template);
const char *const name =
previous_name ? IDENTIFIER_POINTER (previous_name) : "";
- error ("conflicting super class name `%s'",
+ error ("conflicting super class name %qs",
IDENTIFIER_POINTER (super_name));
- error ("previous declaration of `%s'", name);
+ error ("previous declaration of %qs", name);
}
else if (! super_name)
{
if (lookup_interface (class_name))
#ifdef OBJCPLUS
- error ("duplicate interface declaration for class `%s'",
+ error ("duplicate interface declaration for class %qs",
#else
- warning ("duplicate interface declaration for class `%s'",
+ warning (0, "duplicate interface declaration for class %qs",
#endif
IDENTIFIER_POINTER (class_name));
else
- add_class (class);
+ add_class (class, class_name);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
if (!(class_category_is_assoc_with = lookup_interface (class_name)))
{
- error ("cannot find interface declaration for `%s'",
+ error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
if (!(implementation_template = lookup_interface (class_name)))
{
- error ("cannot find interface declaration for `%s'",
+ error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
return class;
}
-tree
+static tree
continue_class (tree class)
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
struct imp_entry *imp_entry;
- tree ivar_context;
/* Check consistency of the instance variables. */
- if (CLASS_IVARS (class))
+ if (CLASS_RAW_IVARS (class))
check_ivars (implementation_template, class);
/* code generation */
- ivar_context = build_private_template (implementation_template);
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c);
+#endif
- if (!objc_class_template)
- build_class_template ();
+ build_private_template (implementation_template);
+ uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template);
+ objc_instance_type = build_pointer_type (uprivate_record);
imp_entry = (struct imp_entry *) ggc_alloc (sizeof (struct imp_entry));
synth_forward_declarations ();
imp_entry->class_decl = UOBJC_CLASS_decl;
imp_entry->meta_decl = UOBJC_METACLASS_decl;
+ imp_entry->has_cxx_cdtors = 0;
/* Append to front and increment count. */
imp_list = imp_entry;
else
cat_count++;
- return ivar_context;
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif /* OBJCPLUS */
+
+ return get_class_ivars (implementation_template, true);
}
else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
{
- if (!CLASS_STATIC_TEMPLATE (class))
- {
- tree record = start_struct (RECORD_TYPE, CLASS_NAME (class));
- finish_struct (record, get_class_ivars (class, 0), NULL_TREE);
- CLASS_STATIC_TEMPLATE (class) = record;
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c);
+#endif /* OBJCPLUS */
- /* Mark this record as a class template for static typing. */
- TREE_STATIC_TEMPLATE (record) = 1;
- }
+ build_private_template (class);
+
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif /* OBJCPLUS */
return NULL_TREE;
}
/* This is called once we see the "@end" in an interface/implementation. */
-void
+static void
finish_class (tree class)
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
}
}
-
- else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
- {
- tree decl_specs;
- const char *class_name = IDENTIFIER_POINTER (CLASS_NAME (class));
- char *string = (char *) alloca (strlen (class_name) + 3);
-
- /* extern struct objc_object *_<my_name>; */
-
- sprintf (string, "_%s", class_name);
-
- decl_specs = build_tree_list (NULL_TREE, ridpointers[(int) RID_EXTERN]);
- decl_specs = tree_cons (NULL_TREE, objc_object_reference, decl_specs);
- define_decl (build1 (INDIRECT_REF, NULL_TREE, get_identifier (string)),
- decl_specs);
- }
}
static tree
{
tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
- TYPE_BINFO (protocol) = make_tree_vec (2);
+ TYPE_LANG_SLOT_1 (protocol)
+ = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = NULL_TREE;
add_protocol (protocol);
}
}
-tree
+static tree
start_protocol (enum tree_code code, tree name, tree list)
{
tree protocol;
}
#endif /* OBJCPLUS */
- /* This is as good a place as any. Need to invoke
- push_tag_toplevel. */
- if (!objc_protocol_template)
- objc_protocol_template = build_protocol_template ();
-
protocol = lookup_protocol (name);
if (!protocol)
{
protocol = make_node (code);
- TYPE_BINFO (protocol) = make_tree_vec (2);
+ TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list);
}
else
{
- warning ("duplicate declaration for protocol `%s'",
+ warning (0, "duplicate declaration for protocol %qs",
IDENTIFIER_POINTER (name));
}
return protocol;
}
-void
-finish_protocol (tree protocol ATTRIBUTE_UNUSED)
-{
-}
-
\f
/* "Encode" a data type into a string, which grows in util_obstack.
??? What is the FORMAT? Someone please document this! */
for (spec = declspecs; spec; spec = TREE_CHAIN (spec))
{
- if (ridpointers[(int) RID_CONST] == TREE_VALUE (spec))
- obstack_1grow (&util_obstack, 'r');
- else if (ridpointers[(int) RID_IN] == TREE_VALUE (spec))
+ 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');
obstack_1grow (&util_obstack, '@');
return;
}
- else if (TREE_STATIC_TEMPLATE (pointer_to))
+ else if (TYPE_HAS_OBJC_INFO (pointer_to)
+ && TYPE_OBJC_INTERFACE (pointer_to))
{
if (generating_instance_variables)
{
if (!flag_next_runtime || strcmp (IDENTIFIER_POINTER (pname), "BOOL"))
{
+ /* It appears that "r*" means "const char *" rather than
+ "char *const". */
+ if (TYPE_READONLY (pointer_to))
+ obstack_1grow (&util_obstack, 'r');
+
obstack_1grow (&util_obstack, '*');
return;
}
return;
}
- sprintf (buffer, "[%ld",
- (long) (TREE_INT_CST_LOW (an_int_cst)
- / TREE_INT_CST_LOW (TYPE_SIZE (array_of))));
+ 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);
}
\f
static void
+encode_aggregate_fields (tree type, int pointed_to, int curtype, int format)
+{
+ tree field = TYPE_FIELDS (type);
+
+ for (; field; field = TREE_CHAIN (field))
+ {
+#ifdef OBJCPLUS
+ /* C++ static members, and things that are not field at all,
+ should not appear in the encoding. */
+ if (TREE_CODE (field) != FIELD_DECL || TREE_STATIC (field))
+ continue;
+#endif
+
+ /* Recursively encode fields of embedded base classes. */
+ if (DECL_ARTIFICIAL (field) && !DECL_NAME (field)
+ && TREE_CODE (TREE_TYPE (field)) == RECORD_TYPE)
+ {
+ encode_aggregate_fields (TREE_TYPE (field),
+ pointed_to, curtype, format);
+ continue;
+ }
+
+ if (generating_instance_variables && !pointed_to)
+ {
+ tree fname = DECL_NAME (field);
+
+ obstack_1grow (&util_obstack, '"');
+
+ if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
+ obstack_grow (&util_obstack,
+ IDENTIFIER_POINTER (fname),
+ strlen (IDENTIFIER_POINTER (fname)));
+
+ obstack_1grow (&util_obstack, '"');
+ }
+
+ encode_field_decl (field, curtype, format);
+ }
+}
+
+static void
encode_aggregate_within (tree type, int curtype, int format, int left,
int right)
{
tree name;
/* NB: aggregates that are pointed to have slightly different encoding
rules in that you never encode the names of instance variables. */
- int pointed_to
- = (obstack_object_size (&util_obstack) > 0
- && *(obstack_next_free (&util_obstack) - 1) == '^');
+ int ob_size = obstack_object_size (&util_obstack);
+ char c1 = ob_size > 1 ? *(obstack_next_free (&util_obstack) - 2) : 0;
+ char c0 = ob_size > 0 ? *(obstack_next_free (&util_obstack) - 1) : 0;
+ int pointed_to = (c0 == '^' || (c1 == '^' && c0 == 'r'));
int inline_contents
= ((format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables)
- && (!pointed_to || obstack_object_size (&util_obstack) - curtype == 1));
+ && (!pointed_to || ob_size - curtype == (c1 == 'r' ? 2 : 1)));
/* Traverse struct aliases; it is important to get the
original struct and its tag name (if any). */
if required. */
if (inline_contents)
{
- tree fields = TYPE_FIELDS (type);
-
obstack_1grow (&util_obstack, '=');
- for (; fields; fields = TREE_CHAIN (fields))
- {
-#ifdef OBJCPLUS
- /* C++ static members, and things that are not fields at all,
- should not appear in the encoding. */
- if (TREE_CODE (fields) != FIELD_DECL || TREE_STATIC (fields))
- continue;
-#endif
- if (generating_instance_variables && !pointed_to)
- {
- tree fname = DECL_NAME (fields);
-
- obstack_1grow (&util_obstack, '"');
- if (fname && TREE_CODE (fname) == IDENTIFIER_NODE)
- obstack_grow (&util_obstack,
- IDENTIFIER_POINTER (fname),
- strlen (IDENTIFIER_POINTER (fname)));
- obstack_1grow (&util_obstack, '"');
- }
- encode_field_decl (fields, curtype, format);
- }
+ encode_aggregate_fields (type, pointed_to, curtype, format);
}
/* Close parenth/bracket. */
obstack_1grow (&util_obstack, right);
enum tree_code code = TREE_CODE (type);
char c;
+ if (TYPE_READONLY (type))
+ obstack_1grow (&util_obstack, 'r');
+
if (code == INTEGER_TYPE)
{
switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
{
- case 8: c = TREE_UNSIGNED (type) ? 'C' : 'c'; break;
- case 16: c = TREE_UNSIGNED (type) ? 'S' : 's'; break;
+ case 8: c = TYPE_UNSIGNED (type) ? 'C' : 'c'; break;
+ case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break;
case 32:
if (type == long_unsigned_type_node
|| type == long_integer_type_node)
- c = TREE_UNSIGNED (type) ? 'L' : 'l';
+ c = TYPE_UNSIGNED (type) ? 'L' : 'l';
else
- c = TREE_UNSIGNED (type) ? 'I' : 'i';
+ c = TYPE_UNSIGNED (type) ? 'I' : 'i';
break;
- case 64: c = TREE_UNSIGNED (type) ? 'Q' : 'q'; break;
+ case 64: c = TYPE_UNSIGNED (type) ? 'Q' : 'q'; break;
default: abort ();
}
obstack_1grow (&util_obstack, c);
{
case 32: c = 'f'; break;
case 64:
+ case 96:
case 128: c = 'd'; break;
default: abort ();
}
encode_type (TREE_TYPE (field_decl), curtype, format);
}
-static tree
-objc_expr_last (tree complex_expr)
+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. */
+
+static void
+objc_push_parm (tree parm)
{
- tree next;
+ /* Decay arrays and functions into pointers. */
+ if (TREE_CODE (TREE_TYPE (parm)) == ARRAY_TYPE)
+ TREE_TYPE (parm) = build_pointer_type (TREE_TYPE (TREE_TYPE (parm)));
+ else if (TREE_CODE (TREE_TYPE (parm)) == FUNCTION_TYPE)
+ TREE_TYPE (parm) = build_pointer_type (TREE_TYPE (parm));
+
+ DECL_ARG_TYPE (parm)
+ = lang_hooks.types.type_promotes_to (TREE_TYPE (parm));
- if (complex_expr)
- while ((next = TREE_OPERAND (complex_expr, 0)))
- complex_expr = next;
+ /* Record constancy and volatility. */
+ c_apply_type_quals_to_decl
+ ((TYPE_READONLY (TREE_TYPE (parm)) ? TYPE_QUAL_CONST : 0)
+ | (TYPE_RESTRICT (TREE_TYPE (parm)) ? TYPE_QUAL_RESTRICT : 0)
+ | (TYPE_VOLATILE (TREE_TYPE (parm)) ? TYPE_QUAL_VOLATILE : 0), parm);
+
+ objc_parmlist = chainon (objc_parmlist, parm);
+}
+
+/* Retrieve the formal parameter list constructed via preceding calls to
+ objc_push_parm(). */
+
+#ifdef OBJCPLUS
+static tree
+objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED)
+#else
+static struct c_arg_info *
+objc_get_parm_info (int have_ellipsis)
+#endif
+{
+#ifdef OBJCPLUS
+ tree parm_info = objc_parmlist;
+ objc_parmlist = NULL_TREE;
- return complex_expr;
+ return parm_info;
+#else
+ 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 = TREE_CHAIN (parm_info);
+
+ TREE_CHAIN (parm_info) = NULL_TREE;
+ parm_info = pushdecl (parm_info);
+ finish_decl (parm_info, NULL_TREE, NULL_TREE);
+ parm_info = next;
+ }
+ arg_info = get_parm_info (have_ellipsis);
+ pop_scope ();
+ objc_parmlist = NULL_TREE;
+ return arg_info;
+#endif
}
+/* Synthesize the formal parameters 'id self' and 'SEL _cmd' needed for ObjC
+ method definitions. In the case of instance methods, we can be more
+ specific as to the type of 'self'. */
+
static void
synth_self_and_ucmd_args (void)
{
- tree decl_specs;
+ tree self_type;
if (objc_method_context
&& TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
- decl_specs = build_tree_list (NULL_TREE, uprivate_record);
+ self_type = objc_instance_type;
else
/* Really a `struct objc_class *'. However, we allow people to
assign to self, which changes its type midstream. */
- decl_specs = build_tree_list (NULL_TREE, objc_object_reference);
+ self_type = objc_object_type;
- push_parm_decl (build_tree_list
- (build_tree_list (decl_specs,
- build1 (INDIRECT_REF, NULL_TREE, self_id)),
- unused_list));
+ /* id self; */
+ objc_push_parm (build_decl (PARM_DECL, self_id, self_type));
- decl_specs = build_tree_list (NULL_TREE,
- xref_tag (RECORD_TYPE,
- get_identifier (TAG_SELECTOR)));
- push_parm_decl (build_tree_list
- (build_tree_list (decl_specs,
- build1 (INDIRECT_REF, NULL_TREE, ucmd_id)),
- unused_list));
+ /* SEL _cmd; */
+ objc_push_parm (build_decl (PARM_DECL, ucmd_id, objc_selector_type));
}
-/* Transform a method definition into a function definition as follows:
- - synthesize the first two arguments, "self" and "_cmd". */
+/* Transform an Objective-C method definition into a static C function
+ definition, synthesizing the first two arguments, "self" and "_cmd",
+ in the process. */
-void
+static void
start_method_def (tree method)
{
+ tree parmlist;
+#ifdef OBJCPLUS
+ tree parm_info;
+#else
+ struct c_arg_info *parm_info;
+#endif
+ int have_ellipsis = 0;
+
+ /* If we are defining a "dealloc" method in a non-root class, we
+ will need to check if a [super dealloc] is missing, and warn if
+ it is. */
+ if(CLASS_SUPER_NAME (objc_implementation_context)
+ && !strcmp ("dealloc", IDENTIFIER_POINTER (METHOD_SEL_NAME (method))))
+ should_call_super_dealloc = 1;
+ else
+ should_call_super_dealloc = 0;
+
/* Required to implement _msgSuper. */
objc_method_context = method;
UOBJC_SUPER_decl = NULL_TREE;
- /* Must be called BEFORE start_function. */
- pushlevel (0);
-
/* Generate prototype declarations for arguments..."new-style". */
synth_self_and_ucmd_args ();
/* Generate argument declarations if a keyword_decl. */
- if (METHOD_SEL_ARGS (method))
+ parmlist = METHOD_SEL_ARGS (method);
+ while (parmlist)
{
- tree arglist = METHOD_SEL_ARGS (method);
- do
- {
- tree arg_spec = TREE_PURPOSE (TREE_TYPE (arglist));
- tree arg_decl = TREE_VALUE (TREE_TYPE (arglist));
-
- if (arg_decl)
- {
- tree last_expr = objc_expr_last (arg_decl);
-
- /* Unite the abstract decl with its name. */
- TREE_OPERAND (last_expr, 0) = KEYWORD_ARG_NAME (arglist);
- push_parm_decl (build_tree_list
- (build_tree_list (arg_spec, arg_decl),
- NULL_TREE));
-
-#ifndef OBJCPLUS
- /* Unhook: restore the abstract declarator. */
- TREE_OPERAND (last_expr, 0) = NULL_TREE;
-#endif
- }
-
- else
- push_parm_decl (build_tree_list
- (build_tree_list (arg_spec,
- KEYWORD_ARG_NAME (arglist)),
- NULL_TREE));
+ tree type = TREE_VALUE (TREE_TYPE (parmlist)), parm;
- arglist = TREE_CHAIN (arglist);
- }
- while (arglist);
+ parm = build_decl (PARM_DECL, KEYWORD_ARG_NAME (parmlist), type);
+ objc_push_parm (parm);
+ parmlist = TREE_CHAIN (parmlist);
}
- if (METHOD_ADD_ARGS (method) != NULL_TREE
- && METHOD_ADD_ARGS (method) != objc_ellipsis_node)
+ if (METHOD_ADD_ARGS (method))
{
- /* We have a variable length selector - in "prototype" format. */
- tree akey = TREE_PURPOSE (METHOD_ADD_ARGS (method));
- while (akey)
+ tree akey;
+
+ for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
+ akey; akey = TREE_CHAIN (akey))
{
- /* This must be done prior to calling pushdecl. pushdecl is
- going to change our chain on us. */
- tree nextkey = TREE_CHAIN (akey);
- pushdecl (akey);
- akey = nextkey;
+ objc_push_parm (TREE_VALUE (akey));
}
+
+ if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
+ have_ellipsis = 1;
}
+
+ parm_info = objc_get_parm_info (have_ellipsis);
+
+ really_start_method (objc_method_context, parm_info);
}
static void
warn_with_method (const char *message, int mtype, tree method)
{
/* Add a readable method name to the warning. */
- warning ("%J%s `%c%s'", method,
- message, mtype, gen_method_decl (method, errbuf));
-}
-
-/* Return 1 if METHOD is consistent with PROTO. */
-
-static int
-comp_method_with_proto (tree method, tree proto)
-{
- /* Create a function template node at most once. */
- if (!function1_template)
- function1_template = make_node (FUNCTION_TYPE);
-
- /* Install argument types - normally set by build_function_type. */
- TYPE_ARG_TYPES (function1_template) = get_arg_type_list (proto, METHOD_DEF, 0);
-
- /* install return type */
- TREE_TYPE (function1_template) = groktypename (TREE_TYPE (proto));
-
- return comptypes (TREE_TYPE (METHOD_DEFINITION (method)), function1_template,
- false);
+ warning (0, "%J%s %<%c%s%>", method,
+ message, mtype, gen_method_decl (method));
}
-/* Return 1 if TYPE1 is equivalent to TYPE2. */
+/* 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;
- type1 = TYPE_PROTOCOL_LIST (type1);
- type2 = TYPE_PROTOCOL_LIST (type2);
+
+ 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 (list_length (type1) == list_length (type2))
{
for (; type2; type2 = TREE_CHAIN (type2))
return 0;
}
-/* Return 1 if PROTO1 is equivalent to PROTO2. */
+/* 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)
+comp_proto_with_proto (tree proto1, tree proto2, int strict)
{
tree type1, type2;
return 0;
/* Compare return types. */
- type1 = groktypename (TREE_TYPE (proto1));
- type2 = groktypename (TREE_TYPE (proto2));
+ type1 = TREE_VALUE (TREE_TYPE (proto1));
+ type2 = TREE_VALUE (TREE_TYPE (proto2));
- if (!objc_types_are_equivalent (type1, type2))
+ if (!objc_types_are_equivalent (type1, type2)
+ && (strict || !objc_types_share_size_and_alignment (type1, type2)))
return 0;
/* Compare argument types. */
type1 && type2;
type1 = TREE_CHAIN (type1), type2 = TREE_CHAIN (type2))
{
- if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2)))
+ if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2))
+ && (strict
+ || !objc_types_share_size_and_alignment (TREE_VALUE (type1),
+ TREE_VALUE (type2))))
return 0;
}
- return (!type1 && !type2);
+ return (!type1 && !type2);
+}
+
+/* Fold an OBJ_TYPE_REF expression for ObjC method dispatches, where
+ this occurs. ObjC method dispatches are _not_ like C++ virtual
+ member function dispatches, and we account for the difference here. */
+tree
+#ifdef OBJCPLUS
+objc_fold_obj_type_ref (tree ref, tree known_type)
+#else
+objc_fold_obj_type_ref (tree ref ATTRIBUTE_UNUSED,
+ tree known_type ATTRIBUTE_UNUSED)
+#endif
+{
+#ifdef OBJCPLUS
+ tree v = BINFO_VIRTUALS (TYPE_BINFO (known_type));
+
+ /* If the receiver does not have virtual member functions, there
+ is nothing we can (or need to) do here. */
+ if (!v)
+ return NULL_TREE;
+
+ /* Let C++ handle C++ virtual functions. */
+ return cp_fold_obj_type_ref (ref, known_type);
+#else
+ /* For plain ObjC, we currently do not need to do anything. */
+ return NULL_TREE;
+#endif
+}
+
+static 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 (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
+ struct c_label_context_se *nstack_se;
+ struct c_label_context_vm *nstack_vm;
+ nstack_se = XOBNEW (&parser_obstack, struct c_label_context_se);
+ nstack_se->labels_def = NULL;
+ nstack_se->labels_used = NULL;
+ nstack_se->next = label_context_stack_se;
+ label_context_stack_se = nstack_se;
+ nstack_vm = XOBNEW (&parser_obstack, struct c_label_context_vm);
+ nstack_vm->labels_def = NULL;
+ nstack_vm->labels_used = NULL;
+ nstack_vm->scope = 0;
+ nstack_vm->next = label_context_stack_vm;
+ label_context_stack_vm = nstack_vm;
+ 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 (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",
- If we have a prototype, check for type consistency. */
static void
-really_start_method (tree method, tree parmlist)
+really_start_method (tree method,
+#ifdef OBJCPLUS
+ tree parmlist
+#else
+ struct c_arg_info *parmlist
+#endif
+ )
{
- tree sc_spec, ret_spec, ret_decl, decl_specs;
- tree method_decl, method_id;
+ 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. */
- sc_spec = tree_cons (NULL_TREE, ridpointers[(int) RID_STATIC], NULL_TREE);
- ret_spec = TREE_PURPOSE (TREE_TYPE (method));
- decl_specs = chainon (sc_spec, ret_spec);
+ ret_type = TREE_VALUE (TREE_TYPE (method));
sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
push_lang_context (lang_name_c);
#endif
- method_decl = build_nt (CALL_EXPR, method_id, parmlist, NULL_TREE);
-
- /* Check the declarator portion of the return type for the method. */
- if ((ret_decl = TREE_VALUE (TREE_TYPE (method))))
- {
- /* Unite the complex decl (specified in the abstract decl) with the
- function decl just synthesized..(int *), (int (*)()), (int (*)[]). */
- tree save_expr = objc_expr_last (ret_decl);
-
- TREE_OPERAND (save_expr, 0) = method_decl;
- method_decl = ret_decl;
-
- /* Fool the parser into thinking it is starting a function. */
- start_function (decl_specs, method_decl, NULL_TREE);
+ meth_type
+ = build_function_type (ret_type,
+ get_arg_type_list (method, METHOD_DEF, 0));
+ objc_start_function (method_id, meth_type, NULL_TREE, parmlist);
- /* Unhook: this has the effect of restoring the abstract declarator. */
- TREE_OPERAND (save_expr, 0) = NULL_TREE;
- }
-
- else
- {
- TREE_VALUE (TREE_TYPE (method)) = method_decl;
-
- /* Fool the parser into thinking it is starting a function. */
- start_function (decl_specs, method_decl, NULL_TREE);
-
- /* Unhook: this has the effect of restoring the abstract declarator. */
- TREE_VALUE (TREE_TYPE (method)) = NULL_TREE;
- }
-
-#ifdef OBJCPLUS
- /* set self_decl from the first argument...this global is used by
- * build_ivar_reference().build_indirect_ref().
- */
+ /* Set self_decl from the first argument. */
self_decl = DECL_ARGUMENTS (current_function_decl);
- /* snaroff (3/28/96): when compiling with -Wall, this suppresses
- * the following: warning:unused parameter `struct objc_selector * _cmd'
- */
+ /* Suppress unused warnings. */
TREE_USED (self_decl) = 1;
TREE_USED (TREE_CHAIN (self_decl)) = 1;
- /* Ditto for the underlying (static) C function. */
- TREE_USED (current_function_decl) = 1;
+#ifdef OBJCPLUS
pop_lang_context ();
#endif
tree proto
= lookup_method_static (implementation_template,
METHOD_SEL_NAME (method),
- TREE_CODE (method) == CLASS_METHOD_DECL);
+ ((TREE_CODE (method) == CLASS_METHOD_DECL)
+ | OBJC_LOOKUP_NO_SUPER));
if (proto)
{
- if (!comp_method_with_proto (method, proto))
+ if (!comp_proto_with_proto (method, proto, 1))
{
char type = (TREE_CODE (method) == INSTANCE_METHOD_DECL ? '-' : '+');
}
}
-/* The following routine is always called...this "architecture" is to
- accommodate "old-style" variable length selectors.
-
- - a:a b:b // prototype ; id c; id d; // old-style. */
-
-void
-continue_method_def (void)
-{
- tree parmlist;
-
- if (METHOD_ADD_ARGS (objc_method_context) == objc_ellipsis_node)
- /* We have a `, ...' immediately following the selector. */
- parmlist = get_parm_info (0);
- else
- parmlist = get_parm_info (1); /* place a `void_at_end' */
-
-#ifndef OBJCPLUS
- /* Set self_decl from the first argument...this global is used by
- build_ivar_reference calling build_indirect_ref. */
- self_decl = TREE_PURPOSE (parmlist);
-#endif /* !OBJCPLUS */
-
- poplevel (0, 0, 0);
- really_start_method (objc_method_context, parmlist);
- store_parm_decls ();
-}
-
static void *UOBJC_SUPER_scope = 0;
/* _n_Method (id self, SEL sel, ...)
_msgSuper ((_S.self = self, _S.class = _cls, &_S), ...);
} */
-tree
+static tree
get_super_receiver (void)
{
if (objc_method_context)
if (!UOBJC_SUPER_decl)
{
- UOBJC_SUPER_decl = start_decl (get_identifier (TAG_SUPER),
- build_tree_list (NULL_TREE,
- objc_super_template),
- 0, NULL_TREE);
-
- finish_decl (UOBJC_SUPER_decl, NULL_TREE, NULL_TREE);
-
+ UOBJC_SUPER_decl = build_decl (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_ARTIFICIAL (UOBJC_SUPER_decl) = 1;
-
- UOBJC_SUPER_scope = get_current_scope ();
+ lang_hooks.decls.pushdecl (UOBJC_SUPER_decl);
+ finish_decl (UOBJC_SUPER_decl, NULL_TREE, NULL_TREE);
+ UOBJC_SUPER_scope = objc_get_current_scope ();
}
/* Set receiver to self. */
- super_expr = build_component_ref (UOBJC_SUPER_decl, self_id);
+ super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl);
- super_expr_list = build_tree_list (NULL_TREE, super_expr);
+ super_expr_list = super_expr;
/* Set class to begin searching. */
- super_expr = build_component_ref (UOBJC_SUPER_decl,
-#ifdef OBJCPLUS
- get_identifier ("super_class"));
-#else
- get_identifier ("class"));
-#endif
-
- if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
- {
- /* [_cls, __cls]Super are "pre-built" in
- synth_forward_declarations. */
-
- super_expr = build_modify_expr (super_expr, NOP_EXPR,
- ((TREE_CODE (objc_method_context)
- == INSTANCE_METHOD_DECL)
- ? ucls_super_ref
- : uucls_super_ref));
- }
-
- else
- /* We have a category. */
- {
- tree super_name = CLASS_SUPER_NAME (implementation_template);
- tree super_class;
-
- /* Barf if super used in a category of Object. */
- if (!super_name)
- {
- error ("no super class declared in interface for `%s'",
- IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
- return error_mark_node;
- }
-
- if (flag_next_runtime && !flag_zero_link)
- {
- super_class = get_class_reference (super_name);
- if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
- /* 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
- (build_c_cast (build_pointer_type (objc_class_type),
- super_class), "unary *");
- }
- else
- {
- add_class_reference (super_name);
- super_class = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
- ? objc_get_class_decl : objc_get_meta_class_decl);
- assemble_external (super_class);
- super_class
- = build_function_call
- (super_class,
- build_tree_list
- (NULL_TREE,
- my_build_string (IDENTIFIER_LENGTH (super_name) + 1,
- IDENTIFIER_POINTER (super_name))));
- }
-
- super_expr
- = build_modify_expr (super_expr, NOP_EXPR,
- build_c_cast (TREE_TYPE (super_expr),
- super_class));
- }
-
- chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
-
- super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
- chainon (super_expr_list, build_tree_list (NULL_TREE, super_expr));
-
- return build_compound_expr (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 == get_current_scope ()) {
- UOBJC_SUPER_decl = 0;
- UOBJC_SUPER_scope = 0;
- }
-}
-
-static void
-objc_expand_function_end (void)
-{
- /* This routine may also get called for C functions, including those
- nested within ObjC methods. In such cases, method encoding is
- meaningless. */
- if (objc_method_context == NULL_TREE
- || DECL_INITIAL (objc_method_context) != current_function_decl)
- return;
-
- METHOD_ENCODING (objc_method_context)
- = encode_method_prototype (objc_method_context);
-}
-
-void
-finish_method_def (void)
-{
- lang_expand_function_end = objc_expand_function_end;
- /* 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_INLINE (current_function_decl) = 0;
- DECL_UNINLINABLE (current_function_decl) = 1;
- current_function_cannot_inline = "methods cannot be inlined";
-
- finish_function ();
- lang_expand_function_end = NULL;
-
- /* 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 0
-int
-lang_report_error_function (tree decl)
-{
- if (objc_method_context)
- {
- fprintf (stderr, "In method `%s'\n",
- IDENTIFIER_POINTER (METHOD_SEL_NAME (objc_method_context)));
- return 1;
- }
-
- else
- return 0;
-}
-#endif
-
-static int
-is_complex_decl (tree type)
-{
- return (TREE_CODE (type) == ARRAY_TYPE
- || TREE_CODE (type) == FUNCTION_TYPE
- || (TREE_CODE (type) == POINTER_TYPE && ! IS_ID (type)));
-}
-
-\f
-/* Code to convert a decl node into text for a declaration in C. */
-
-static char tmpbuf[256];
-
-static void
-adorn_decl (tree decl, char *str)
-{
- enum tree_code code = TREE_CODE (decl);
-
- if (code == ARRAY_REF)
- {
- tree an_int_cst = TREE_OPERAND (decl, 1);
-
- if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_CST)
- sprintf (str + strlen (str), "[%ld]",
- (long) TREE_INT_CST_LOW (an_int_cst));
- else
- strcat (str, "[]");
- }
-
- else if (code == ARRAY_TYPE)
- {
- tree an_int_cst = TYPE_SIZE (decl);
- tree array_of = TREE_TYPE (decl);
-
- if (an_int_cst && TREE_CODE (an_int_cst) == INTEGER_TYPE)
- sprintf (str + strlen (str), "[%ld]",
- (long) (TREE_INT_CST_LOW (an_int_cst)
- / TREE_INT_CST_LOW (TYPE_SIZE (array_of))));
- else
- strcat (str, "[]");
- }
-
- else if (code == CALL_EXPR)
- {
- tree chain = TREE_PURPOSE (TREE_OPERAND (decl, 1));
-
- strcat (str, "(");
- while (chain)
- {
- gen_declaration_1 (chain, str);
- chain = TREE_CHAIN (chain);
- if (chain)
- strcat (str, ", ");
- }
- strcat (str, ")");
- }
-
- else if (code == FUNCTION_TYPE)
- {
- tree chain = TYPE_ARG_TYPES (decl);
-
- strcat (str, "(");
- while (chain && TREE_VALUE (chain) != void_type_node)
- {
- gen_declaration_1 (TREE_VALUE (chain), str);
- chain = TREE_CHAIN (chain);
- if (chain && TREE_VALUE (chain) != void_type_node)
- strcat (str, ", ");
- }
- strcat (str, ")");
- }
-
- else if (code == INDIRECT_REF)
- {
- strcpy (tmpbuf, "*");
- if (TREE_TYPE (decl) && TREE_CODE (TREE_TYPE (decl)) == TREE_LIST)
- {
- tree chain;
-
- for (chain = nreverse (copy_list (TREE_TYPE (decl)));
- chain;
- chain = TREE_CHAIN (chain))
- {
- if (TREE_CODE (TREE_VALUE (chain)) == IDENTIFIER_NODE)
- {
- strcat (tmpbuf, " ");
- strcat (tmpbuf, IDENTIFIER_POINTER (TREE_VALUE (chain)));
- }
- }
- if (str[0])
- strcat (tmpbuf, " ");
- }
- strcat (tmpbuf, str);
- strcpy (str, tmpbuf);
- }
-
- else if (code == POINTER_TYPE)
- {
- strcpy (tmpbuf, "*");
- if (TREE_READONLY (decl) || TYPE_VOLATILE (decl))
- {
- if (TREE_READONLY (decl))
- strcat (tmpbuf, " const");
- if (TYPE_VOLATILE (decl))
- strcat (tmpbuf, " volatile");
- if (str[0])
- strcat (tmpbuf, " ");
- }
- strcat (tmpbuf, str);
- strcpy (str, tmpbuf);
- }
-}
-
-static char *
-gen_declarator (tree decl, char *buf, const char *name)
-{
- if (decl)
- {
- enum tree_code code = TREE_CODE (decl);
- char *str;
- tree op;
- int wrap = 0;
-
- switch (code)
- {
- case ARRAY_REF:
- case INDIRECT_REF:
- case CALL_EXPR:
- op = TREE_OPERAND (decl, 0);
-
- /* We have a pointer to a function or array...(*)(), (*)[] */
- if ((code == ARRAY_REF || code == CALL_EXPR)
- && op && TREE_CODE (op) == INDIRECT_REF)
- wrap = 1;
-
- str = gen_declarator (op, buf, name);
-
- if (wrap)
- {
- strcpy (tmpbuf, "(");
- strcat (tmpbuf, str);
- strcat (tmpbuf, ")");
- strcpy (str, tmpbuf);
- }
-
- adorn_decl (decl, str);
- break;
-
- case ARRAY_TYPE:
- case FUNCTION_TYPE:
- case POINTER_TYPE:
- strcpy (buf, name);
- str = buf;
-
- /* This clause is done iteratively rather than recursively. */
- do
- {
- op = (is_complex_decl (TREE_TYPE (decl))
- ? TREE_TYPE (decl) : NULL_TREE);
-
- adorn_decl (decl, str);
-
- /* We have a pointer to a function or array...(*)(), (*)[] */
- if (code == POINTER_TYPE
- && op && (TREE_CODE (op) == FUNCTION_TYPE
- || TREE_CODE (op) == ARRAY_TYPE))
- {
- strcpy (tmpbuf, "(");
- strcat (tmpbuf, str);
- strcat (tmpbuf, ")");
- strcpy (str, tmpbuf);
- }
-
- decl = (is_complex_decl (TREE_TYPE (decl))
- ? TREE_TYPE (decl) : NULL_TREE);
- }
-
- while (decl && (code = TREE_CODE (decl)))
- ;
-
- break;
-
- case IDENTIFIER_NODE:
- /* Will only happen if we are processing a "raw" expr-decl. */
- strcpy (buf, IDENTIFIER_POINTER (decl));
- return buf;
-
- default:
- abort ();
- }
-
- return str;
- }
-
- else
- /* We have an abstract declarator or a _DECL node. */
- {
- strcpy (buf, name);
- return buf;
- }
-}
-
-static void
-gen_declspecs (tree declspecs, char *buf, int raw)
-{
- if (raw)
- {
- tree chain;
+ super_expr = objc_build_component_ref (UOBJC_SUPER_decl,
+ get_identifier ("super_class"));
- for (chain = nreverse (copy_list (declspecs));
- chain; chain = TREE_CHAIN (chain))
+ if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
- tree aspec = TREE_VALUE (chain);
-
- if (TREE_CODE (aspec) == IDENTIFIER_NODE)
- strcat (buf, IDENTIFIER_POINTER (aspec));
- else if (TREE_CODE (aspec) == RECORD_TYPE)
- {
- if (OBJC_TYPE_NAME (aspec))
- {
- tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
+ /* [_cls, __cls]Super are "pre-built" in
+ synth_forward_declarations. */
- if (! TREE_STATIC_TEMPLATE (aspec))
- strcat (buf, "struct ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec)));
+ super_expr = build_modify_expr (super_expr, NOP_EXPR,
+ ((TREE_CODE (objc_method_context)
+ == INSTANCE_METHOD_DECL)
+ ? ucls_super_ref
+ : uucls_super_ref));
+ }
- /* NEW!!! */
- if (protocol_list)
- {
- tree chain = protocol_list;
-
- strcat (buf, " <");
- while (chain)
- {
- strcat (buf,
- IDENTIFIER_POINTER
- (PROTOCOL_NAME (TREE_VALUE (chain))));
- chain = TREE_CHAIN (chain);
- if (chain)
- strcat (buf, ", ");
- }
- strcat (buf, ">");
- }
- }
+ else
+ /* We have a category. */
+ {
+ tree super_name = CLASS_SUPER_NAME (implementation_template);
+ tree super_class;
- else
- strcat (buf, "untagged struct");
+ /* Barf if super used in a category of Object. */
+ if (!super_name)
+ {
+ error ("no super class declared in interface for %qs",
+ IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
+ return error_mark_node;
}
- else if (TREE_CODE (aspec) == UNION_TYPE)
+ if (flag_next_runtime && !flag_zero_link)
{
- if (OBJC_TYPE_NAME (aspec))
- {
- if (! TREE_STATIC_TEMPLATE (aspec))
- strcat (buf, "union ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec)));
- }
- else
- strcat (buf, "untagged union");
+ super_class = objc_get_class_reference (super_name);
+ if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
+ /* 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
+ (build_c_cast (build_pointer_type (objc_class_type),
+ super_class), "unary *");
}
-
- else if (TREE_CODE (aspec) == ENUMERAL_TYPE)
+ else
{
- if (OBJC_TYPE_NAME (aspec))
- {
- if (! TREE_STATIC_TEMPLATE (aspec))
- strcat (buf, "enum ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec)));
- }
- else
- strcat (buf, "untagged enum");
+ add_class_reference (super_name);
+ super_class = (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
+ ? objc_get_class_decl : objc_get_meta_class_decl);
+ assemble_external (super_class);
+ super_class
+ = build_function_call
+ (super_class,
+ build_tree_list
+ (NULL_TREE,
+ my_build_string_pointer
+ (IDENTIFIER_LENGTH (super_name) + 1,
+ IDENTIFIER_POINTER (super_name))));
}
- else if (TREE_CODE (aspec) == TYPE_DECL && DECL_NAME (aspec))
- strcat (buf, IDENTIFIER_POINTER (DECL_NAME (aspec)));
+ super_expr
+ = build_modify_expr (super_expr, NOP_EXPR,
+ build_c_cast (TREE_TYPE (super_expr),
+ super_class));
+ }
- else if (IS_ID (aspec))
- {
- tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
+ super_expr_list = build_compound_expr (super_expr_list, super_expr);
- strcat (buf, "id");
- if (protocol_list)
- {
- tree chain = protocol_list;
+ super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
+ super_expr_list = build_compound_expr (super_expr_list, super_expr);
- strcat (buf, " <");
- while (chain)
- {
- strcat (buf,
- IDENTIFIER_POINTER
- (PROTOCOL_NAME (TREE_VALUE (chain))));
- chain = TREE_CHAIN (chain);
- if (chain)
- strcat (buf, ", ");
- }
- strcat (buf, ">");
- }
- }
- if (TREE_CHAIN (chain))
- strcat (buf, " ");
- }
+ return super_expr_list;
}
else
{
- /* Type qualifiers. */
- if (TREE_READONLY (declspecs))
- strcat (buf, "const ");
- if (TYPE_VOLATILE (declspecs))
- strcat (buf, "volatile ");
-
- switch (TREE_CODE (declspecs))
- {
- /* Type specifiers. */
-
- case INTEGER_TYPE:
- declspecs = TYPE_MAIN_VARIANT (declspecs);
-
- /* Signed integer types. */
-
- if (declspecs == short_integer_type_node)
- strcat (buf, "short int ");
- else if (declspecs == integer_type_node)
- strcat (buf, "int ");
- else if (declspecs == long_integer_type_node)
- strcat (buf, "long int ");
- else if (declspecs == long_long_integer_type_node)
- strcat (buf, "long long int ");
- else if (declspecs == signed_char_type_node
- || declspecs == char_type_node)
- strcat (buf, "char ");
-
- /* Unsigned integer types. */
-
- else if (declspecs == short_unsigned_type_node)
- strcat (buf, "unsigned short ");
- else if (declspecs == unsigned_type_node)
- strcat (buf, "unsigned int ");
- else if (declspecs == long_unsigned_type_node)
- strcat (buf, "unsigned long ");
- else if (declspecs == long_long_unsigned_type_node)
- strcat (buf, "unsigned long long ");
- else if (declspecs == unsigned_char_type_node)
- strcat (buf, "unsigned char ");
- break;
-
- case REAL_TYPE:
- declspecs = TYPE_MAIN_VARIANT (declspecs);
-
- if (declspecs == float_type_node)
- strcat (buf, "float ");
- else if (declspecs == double_type_node)
- strcat (buf, "double ");
- else if (declspecs == long_double_type_node)
- strcat (buf, "long double ");
- break;
+ error ("[super ...] must appear in a method context");
+ return error_mark_node;
+ }
+}
- case RECORD_TYPE:
- if (OBJC_TYPE_NAME (declspecs)
- && TREE_CODE (OBJC_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
- {
- tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
+/* When exiting a scope, sever links to a 'super' declaration (if any)
+ therein contained. */
- if (! TREE_STATIC_TEMPLATE (declspecs))
- strcat (buf, "struct ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs)));
+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;
+ }
+}
- if (protocol_list)
- {
- tree chain = protocol_list;
+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_INLINE (fndecl) = 0;
+ DECL_UNINLINABLE (fndecl) = 1;
- strcat (buf, " <");
- while (chain)
- {
- strcat (buf,
- IDENTIFIER_POINTER
- (PROTOCOL_NAME (TREE_VALUE (chain))));
- chain = TREE_CHAIN (chain);
- if (chain)
- strcat (buf, ", ");
- }
- strcat (buf, ">");
- }
- }
+#ifndef OBJCPLUS
+ /* The C++ front-end will have called finish_function() for us. */
+ finish_function ();
+#endif
- else
- strcat (buf, "untagged struct");
+ METHOD_ENCODING (objc_method_context)
+ = encode_method_prototype (objc_method_context);
- strcat (buf, " ");
- break;
+ /* 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;
- case UNION_TYPE:
- if (OBJC_TYPE_NAME (declspecs)
- && TREE_CODE (OBJC_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
- {
- strcat (buf, "union ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs)));
- strcat (buf, " ");
- }
+ if (should_call_super_dealloc)
+ warning (0, "method possibly missing a [super dealloc] call");
+}
- else
- strcat (buf, "untagged union ");
- break;
+#if 0
+int
+lang_report_error_function (tree decl)
+{
+ if (objc_method_context)
+ {
+ fprintf (stderr, "In method %qs\n",
+ IDENTIFIER_POINTER (METHOD_SEL_NAME (objc_method_context)));
+ return 1;
+ }
- case ENUMERAL_TYPE:
- if (OBJC_TYPE_NAME (declspecs)
- && TREE_CODE (OBJC_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
- {
- strcat (buf, "enum ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs)));
- strcat (buf, " ");
- }
+ else
+ return 0;
+}
+#endif
- else
- strcat (buf, "untagged enum ");
- break;
+/* Given a tree DECL node, produce a printable description of it in the given
+ buffer, overwriting the buffer. */
- case VOID_TYPE:
- strcat (buf, "void ");
- break;
+static char *
+gen_declaration (tree decl)
+{
+ errbuf[0] = '\0';
- case POINTER_TYPE:
- {
- tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
+ if (DECL_P (decl))
+ {
+ gen_type_name_0 (TREE_TYPE (decl));
- strcat (buf, "id");
- if (protocol_list)
- {
- tree chain = protocol_list;
-
- strcat (buf, " <");
- while (chain)
- {
- strcat (buf,
- IDENTIFIER_POINTER
- (PROTOCOL_NAME (TREE_VALUE (chain))));
- chain = TREE_CHAIN (chain);
- if (chain)
- strcat (buf, ", ");
- }
-
- strcat (buf, ">");
- }
- }
- break;
+ if (DECL_NAME (decl))
+ {
+ if (!POINTER_TYPE_P (TREE_TYPE (decl)))
+ strcat (errbuf, " ");
- default:
- break;
+ 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 node, produce a printable description of it in the given
+/* Given a tree TYPE node, produce a printable description of it in the given
buffer, overwriting the buffer. */
static char *
-gen_declaration (tree atype_or_adecl, char *buf)
+gen_type_name_0 (tree type)
{
- buf[0] = '\0';
- gen_declaration_1 (atype_or_adecl, buf);
- return buf;
-}
+ tree orig = type, proto;
-/* Given a tree node, append a printable description to the end of the
- given buffer. */
+ 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);
-static void
-gen_declaration_1 (tree atype_or_adecl, char *buf)
-{
- char declbuf[256];
+ while (TREE_CODE (inner) == ARRAY_TYPE)
+ inner = TREE_TYPE (inner);
- if (TREE_CODE (atype_or_adecl) == TREE_LIST)
- {
- tree declspecs; /* "identifier_node", "record_type" */
- tree declarator; /* "array_ref", "indirect_ref", "call_expr"... */
- tree width = NULL_TREE; /* for bitfields */
+ gen_type_name_0 (inner);
+
+ if (!POINTER_TYPE_P (inner))
+ strcat (errbuf, " ");
- /* We have a "raw", abstract declarator (typename). */
- declarator = TREE_VALUE (atype_or_adecl);
- /* In the case of raw ivars, the declarator itself is a list,
- and contains bitfield widths. */
- if (declarator && TREE_CODE (declarator) == TREE_LIST)
- {
- width = TREE_VALUE (declarator);
- declarator = TREE_PURPOSE (declarator);
- }
- declspecs = TREE_PURPOSE (atype_or_adecl);
+ if (POINTER_TYPE_P (type))
+ strcat (errbuf, "*");
+ else
+ while (type != inner)
+ {
+ strcat (errbuf, "[");
- gen_declspecs (declspecs, buf, 1);
- if (declarator)
- {
- strcat (buf, " ");
- strcat (buf, gen_declarator (declarator, declbuf, ""));
- }
- if (width)
- sprintf (buf + strlen (buf), ": " HOST_WIDE_INT_PRINT_UNSIGNED,
- TREE_INT_CST_LOW (width));
- }
+ if (TYPE_DOMAIN (type))
+ {
+ char sz[20];
- else
- {
- tree atype;
- tree declspecs; /* "integer_type", "real_type", "record_type"... */
- tree declarator; /* "array_type", "function_type", "pointer_type". */
+ sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
+ (TREE_INT_CST_LOW
+ (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
+ strcat (errbuf, sz);
+ }
- if (TREE_CODE (atype_or_adecl) == FIELD_DECL
- || TREE_CODE (atype_or_adecl) == PARM_DECL
- || TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
- atype = TREE_TYPE (atype_or_adecl);
- else
- /* Assume we have a *_type node. */
- atype = atype_or_adecl;
+ strcat (errbuf, "]");
+ type = TREE_TYPE (type);
+ }
- if (is_complex_decl (atype))
- {
- tree chain;
-
- /* Get the declaration specifier; it is at the end of the list. */
- declarator = chain = atype;
- do
- chain = TREE_TYPE (chain); /* not TREE_CHAIN (chain); */
- while (is_complex_decl (chain));
- declspecs = chain;
- }
+ goto exit_function;
+ }
- else
- {
- declspecs = atype;
- declarator = NULL_TREE;
- }
+ if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
+ type = DECL_NAME (type);
- gen_declspecs (declspecs, buf, 0);
+ strcat (errbuf, IDENTIFIER_POINTER (type));
- if (TREE_CODE (atype_or_adecl) == FIELD_DECL
- || TREE_CODE (atype_or_adecl) == PARM_DECL
- || TREE_CODE (atype_or_adecl) == FUNCTION_DECL)
- {
- const char *const decl_name =
- (DECL_NAME (atype_or_adecl)
- ? IDENTIFIER_POINTER (DECL_NAME (atype_or_adecl)) : "");
+ /* 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 (declarator)
- {
- strcat (buf, " ");
- strcat (buf, gen_declarator (declarator, declbuf, decl_name));
- }
+ if (proto)
+ {
+ strcat (errbuf, " <");
- else if (decl_name[0])
- {
- strcat (buf, " ");
- strcat (buf, decl_name);
- }
- }
- else if (declarator)
- {
- strcat (buf, " ");
- strcat (buf, gen_declarator (declarator, declbuf, ""));
- }
+ while (proto) {
+ strcat (errbuf,
+ IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
+ proto = TREE_CHAIN (proto);
+ strcat (errbuf, proto ? ", " : ">");
+ }
}
+
+ exit_function:
+ return errbuf;
}
-#define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth))))
+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, char *buf)
+gen_method_decl (tree method)
{
tree chain;
- buf[0] = '\0';
- if (RAW_TYPESPEC (method) != objc_object_reference)
- {
- strcat (buf, "(");
- gen_declaration_1 (TREE_TYPE (method), buf);
- strcat (buf, ")");
- }
-
+ 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 (buf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
+ strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
- strcat (buf, ":");
- if (RAW_TYPESPEC (chain) != objc_object_reference)
- {
- strcat (buf, "(");
- gen_declaration_1 (TREE_TYPE (chain), buf);
- strcat (buf, ")");
- }
+ strcat (errbuf, ":(");
+ gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain)));
+ strcat (errbuf, ")");
- strcat (buf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
+ strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
if ((chain = TREE_CHAIN (chain)))
- strcat (buf, " ");
+ strcat (errbuf, " ");
}
while (chain);
- if (METHOD_ADD_ARGS (method) == objc_ellipsis_node)
- strcat (buf, ", ...");
- else if (METHOD_ADD_ARGS (method))
- {
- /* We have a tree list node as generate by get_parm_info. */
- chain = TREE_PURPOSE (METHOD_ADD_ARGS (method));
-
- /* Know we have a chain of parm_decls. */
- while (chain)
- {
- strcat (buf, ", ");
- gen_declaration_1 (chain, buf);
+ 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 (buf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
+ strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
- return buf;
+ return errbuf;
}
\f
/* Debug info. */
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. */
- char *buf = (char *) xmalloc (1024 * 10);
const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
tree ivar_decls = CLASS_RAW_IVARS (chain);
tree nst_methods = CLASS_NST_METHODS (chain);
fprintf (fp, "{\n");
do
{
- fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls, buf));
+ fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls));
ivar_decls = TREE_CHAIN (ivar_decls);
}
while (ivar_decls);
while (nst_methods)
{
- fprintf (fp, "- %s;\n", gen_method_decl (nst_methods, buf));
+ 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, buf));
+ fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods));
cls_methods = TREE_CHAIN (cls_methods);
}
gcc_obstack_init (&util_obstack);
util_firstobj = (char *) obstack_finish (&util_obstack);
- errbuf = (char *) xmalloc (BUFSIZE);
+ errbuf = (char *) xmalloc (1024 * 10);
hash_init ();
synth_module_prologue ();
}
/* A missing @end may not be detected by the parser. */
if (objc_implementation_context)
{
- warning ("`@end' missing in implementation context");
+ warning (0, "%<@end%> missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
- generate_forward_declaration_to_string_table ();
-
/* Process the static instances here because initialization of objc_symtab
depends on them. */
if (objc_static_instances)
/* all of the following reference the string pool... */
generate_ivar_lists ();
generate_dispatch_tables ();
- generate_shared_structures ();
+ generate_shared_structures (impent->has_cxx_cdtors
+ ? CLS_HAS_CXX_STRUCTORS
+ : 0);
}
else
{
if (protocol_chain)
generate_protocols ();
- if (flag_replace_objc_classes && imp_list)
+ if ((flag_replace_objc_classes && imp_list) || flag_objc_gc)
generate_objc_image_info ();
+ /* Arrange for ObjC data structures to be initialized at run time. */
if (objc_implementation_context || class_names_chain || objc_static_instances
|| meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
{
- /* Arrange for ObjC data structures to be initialized at run time. */
- rtx init_sym = build_module_descriptor ();
- if (init_sym && targetm.have_ctors_dtors)
- (* targetm.asm_out.constructor) (init_sym, DEFAULT_INIT_PRIORITY);
+ build_module_descriptor ();
+
+ if (!flag_next_runtime)
+ build_module_initializer_routine ();
}
/* Dump the class references. This forces the appropriate classes
for (impent = imp_list; impent; impent = impent->next)
handle_impent (impent);
- /* Dump the string table last. */
-
- generate_strings ();
-
if (warn_selector)
{
int slot;
static void
generate_classref_translation_entry (tree chain)
{
- tree expr, name, decl_specs, decl, sc_spec;
- tree type;
+ tree expr, decl, type;
- type = TREE_TYPE (TREE_PURPOSE (chain));
+ decl = TREE_PURPOSE (chain);
+ type = TREE_TYPE (decl);
expr = add_objc_string (TREE_VALUE (chain), class_names);
- expr = build_c_cast (type, expr); /* cast! */
+ expr = convert (type, expr); /* cast! */
- name = DECL_NAME (TREE_PURPOSE (chain));
-
- sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
-
- /* static struct objc_class * _OBJC_CLASS_REFERENCES_n = ...; */
- decl_specs = tree_cons (NULL_TREE, type, sc_spec);
-
- /* The decl that is returned from start_decl is the one that we
+ /* The decl that is the one that we
forward declared in build_class_reference. */
- decl = start_decl (name, decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (decl) = NULL_TREE;
- finish_decl (decl, expr, NULL_TREE);
+ finish_var_decl (decl, expr);
return;
}
TREE_PUBLIC (decl) = 1;
pushdecl (decl);
- rest_of_decl_compilation (decl, 0, 0, 0);
+ rest_of_decl_compilation (decl, 0, 0);
/* Make a decl for the address. */
sprintf (string, "%sobjc_class_ref_%s",
DECL_INITIAL (decl) = exp;
TREE_STATIC (decl) = 1;
TREE_USED (decl) = 1;
+ /* Force the output of the decl as this forces the reference of the class. */
+ mark_decl_referenced (decl);
pushdecl (decl);
- rest_of_decl_compilation (decl, 0, 0, 0);
+ rest_of_decl_compilation (decl, 0, 0);
}
static void
{
tree decl, init;
- init = build_int_2 (0, 0);
- TREE_TYPE (init) = c_common_type_for_size (BITS_PER_WORD, 1);
+ init = build_int_cst (c_common_type_for_size (BITS_PER_WORD, 1), 0);
decl = build_decl (VAR_DECL, get_identifier (string), TREE_TYPE (init));
TREE_PUBLIC (decl) = 1;
TREE_READONLY (decl) = 1;
}
}
\f
-/* The Fix-and-Countinue functionality available in Mac OS X 10.3 and
+/* The Fix-and-Continue functionality available in Mac OS X 10.3 and
later requires that ObjC translation units participating in F&C be
specially marked. The following routine accomplishes this. */
static void
generate_objc_image_info (void)
{
- tree sc_spec, decl, initlist;
+ tree decl, initlist;
+ int flags
+ = ((flag_replace_objc_classes && imp_list ? 1 : 0)
+ | (flag_objc_gc ? 2 : 0));
- sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
- decl
- = start_decl (get_identifier ("_OBJC_IMAGE_INFO"),
- tree_cons (NULL_TREE,
- build_array_type
- (integer_type_node,
- build_index_type (build_int_2 (1, 0))),
- sc_spec),
- 1,
- NULL_TREE);
+ decl = start_var_decl (build_array_type
+ (integer_type_node,
+ build_index_type (build_int_cst (NULL_TREE, 2 - 1))),
+ "_OBJC_IMAGE_INFO");
- initlist = build_tree_list (NULL_TREE, build_int_2 (0, 0));
- initlist = tree_cons (NULL_TREE, build_int_2 (1, 0), initlist);
- initlist = build_constructor (TREE_TYPE (decl), nreverse (initlist));
+ initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 0));
+ initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), initlist);
+ initlist = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
- TREE_USED (decl) = DECL_IGNORED_P (decl) = DECL_ARTIFICIAL (decl) = 1;
- TREE_CONSTANT (initlist) = TREE_STATIC (initlist) = 1;
- finish_decl (decl, initlist, NULL_TREE);
+ finish_var_decl (decl, initlist);
}
-/* Look up ID as an instance variable. */
+/* Look up ID as an instance variable. OTHER contains the result of
+ the C or C++ lookup, which we may want to use instead. */
tree
-lookup_objc_ivar (tree id)
+objc_lookup_ivar (tree other, tree id)
{
- tree decl;
+ tree ivar;
+
+ /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
+ if (!objc_method_context)
+ return other;
- if (objc_method_context && !strcmp (IDENTIFIER_POINTER (id), "super"))
+ if (!strcmp (IDENTIFIER_POINTER (id), "super"))
/* We have a message to super. */
return get_super_receiver ();
- else if (objc_method_context && (decl = is_ivar (objc_ivar_chain, id)))
+
+ /* 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
{
- if (is_private (decl))
- return error_mark_node;
- else
- return build_ivar_reference (id);
+ warning (0, "local declaration of %qs hides instance variable",
+ IDENTIFIER_POINTER (id));
+
+ return other;
}
- else
+
+ /* 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 params)
+{
+ 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 = build (OBJ_TYPE_REF, TREE_TYPE (function),
+ TREE_OPERAND (function, 0),
+ TREE_VALUE (params), size_zero_node);
+ }
+
+ return function;
+}
+
+/* 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). */
+
+enum gimplify_status
+objc_gimplify_expr (tree *expr_p, tree *pre_p, tree *post_p)
+{
+ enum gimplify_status r0, r1;
+ if (TREE_CODE (*expr_p) == OBJ_TYPE_REF
+ && TREE_CODE (OBJ_TYPE_REF_EXPR (*expr_p)) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (OBJ_TYPE_REF_EXPR (*expr_p), 0))
+ == FUNCTION_DECL)
+ {
+ /* 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);
+ }
+
+#ifdef OBJCPLUS
+ return cp_gimplify_expr (expr_p, pre_p, post_p);
+#else
+ return c_gimplify_expr (expr_p, pre_p, post_p);
+#endif
+}
+
+/* Given a CALL expression, find the function being called. The ObjC
+ version looks for the OBJ_TYPE_REF_EXPR which is used for objc_msgSend. */
+
+tree
+objc_get_callee_fndecl (tree call_expr)
+{
+ tree addr = TREE_OPERAND (call_expr, 0);
+ if (TREE_CODE (addr) != OBJ_TYPE_REF)
return 0;
+
+ addr = OBJ_TYPE_REF_EXPR (addr);
+
+ /* If the address is just `&f' for some function `f', then we know
+ that `f' is being called. */
+ if (TREE_CODE (addr) == ADDR_EXPR
+ && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
+ return TREE_OPERAND (addr, 0);
+
+ return 0;
}
#include "gt-objc-objc-act.h"
-#include "gtype-objc.h"