/* Implement classes and message passing for Objective C.
Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000,
- 2001, 2002, 2003, 2004 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 "cgraph.h"
#include "tree-iterator.h"
#include "libfuncs.h"
+#include "hashtab.h"
+#include "langhooks-def.h"
+
+#define OBJC_VOID_AT_END void_list_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 void build_next_objc_exception_stuff (void);
-static tree build_ivar_template (void);
-static tree build_method_template (void);
-static tree build_private_template (tree);
+/* We only need the following for ObjC; ObjC++ will use C++'s definition
+ of DERIVED_FROM_P. */
+#ifndef OBJCPLUS
+static bool objc_derived_from_p (tree, tree);
+#define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
+#endif
+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 build_protocol_reference (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 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. */
+
+#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)
{
mark_referenced_methods ();
+#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
return 0;
}
+void
+objc_start_class_interface (tree class, tree super_class, tree protos)
+{
+ objc_interface_context
+ = objc_ivar_context
+ = start_class (CLASS_INTERFACE_TYPE, class, super_class, protos);
+ objc_public_flag = 0;
+}
+
+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);
+}
+
+void
+objc_start_protocol (tree name, tree protos)
+{
+ objc_interface_context
+ = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos);
+}
+
+void
+objc_continue_interface (void)
+{
+ objc_ivar_chain
+ = continue_class (objc_interface_context);
+}
+
+void
+objc_finish_interface (void)
+{
+ finish_class (objc_interface_context);
+ objc_interface_context = NULL_TREE;
+}
+
+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;
+}
+
+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);
+}
+
+void
+objc_continue_implementation (void)
+{
+ objc_ivar_chain
+ = continue_class (objc_implementation_context);
+}
+
+void
+objc_finish_implementation (void)
+{
+#ifdef OBJCPLUS
+ if (flag_objc_call_cxx_cdtors)
+ objc_generate_cxx_cdtors ();
+#endif
+
+ if (objc_implementation_context)
+ {
+ finish_class (objc_implementation_context);
+ objc_ivar_chain = NULL_TREE;
+ objc_implementation_context = NULL_TREE;
+ }
+ else
+ warning (0, "%<@end%> must appear in an @implementation context");
+}
+
+void
+objc_set_visibility (int visibility)
+{
+ objc_public_flag = visibility;
+}
+
+void
+objc_set_method_type (enum tree_code type)
+{
+ objc_inherit_code = (type == PLUS_EXPR
+ ? CLASS_METHOD_DECL
+ : INSTANCE_METHOD_DECL);
+}
+
+tree
+objc_build_method_signature (tree rettype, tree selector,
+ tree optparms, bool ellipsis)
+{
+ return build_method_decl (objc_inherit_code, rettype, selector,
+ optparms, ellipsis);
+}
+
+void
+objc_add_method_declaration (tree decl)
+{
+ if (!objc_interface_context)
+ fatal_error ("method declaration not in @interface context");
+
+ objc_add_method (objc_interface_context,
+ decl,
+ objc_inherit_code == CLASS_METHOD_DECL);
+}
+
+void
+objc_start_method_definition (tree decl)
+{
+ if (!objc_implementation_context)
+ fatal_error ("method definition not in @implementation context");
+
+ objc_add_method (objc_implementation_context,
+ decl,
+ objc_inherit_code == CLASS_METHOD_DECL);
+ start_method_def (decl);
+}
+
+void
+objc_add_instance_variable (tree decl)
+{
+ (void) add_instance_variable (objc_ivar_context,
+ objc_public_flag,
+ decl);
+}
+
/* Return 1 if IDENT is an ObjC/ObjC++ reserved keyword in the context of
an '@'. */
return OBJC_TYPE_NAME (type) == objc_class_id;
}
-/* 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)
-{
- /* New clause for protocols. */
-
- /* 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);
+/* Construct a C struct with same name as CLASS, a base struct with tag
+ SUPER_NAME (if any), and FIELDS indicated. */
- if (lhs_is_proto)
- {
- tree lproto, lproto_list = TYPE_PROTOCOL_LIST (lhs);
- tree rproto, rproto_list;
- tree p;
-
- /* <Protocol> = <Protocol> */
- if (rhs_is_proto)
- {
- rproto_list = TYPE_PROTOCOL_LIST (rhs);
+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;
- 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);
+ 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;
+ }
- 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;
+ /* 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. */
- /* 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);
+ 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)));
- 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));
- }
+ /* Point the struct at its related Objective-C class. */
+ INIT_TYPE_OBJC_INFO (s);
+ TYPE_OBJC_INTERFACE (s) = class;
- 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_is_object_id (TREE_TYPE (rhs)))
- {
- return 1;
- }
- /* <Protocol> = Class */
- else if (objc_is_class_id (TREE_TYPE (rhs)))
- {
- 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_is_object_id (TREE_TYPE (lhs)))
- {
- return 1;
- }
- /* Class = <Protocol> */
- else if (objc_is_class_id (TREE_TYPE (lhs)))
- {
- 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);
- }
- }
+ s = finish_struct (s, fields, NULL_TREE);
- if (TREE_CODE (lhs) != RECORD_TYPE || TREE_CODE (rhs) != RECORD_TYPE)
+ for (t = TYPE_NEXT_VARIANT (s); t;
+ t = TYPE_NEXT_VARIANT (t), objc_info = TREE_CHAIN (objc_info))
{
- /* Nothing to do with ObjC - let immediately comptypes take
- responsibility for checking. */
- return -1;
+ TYPE_OBJC_INFO (t) = TREE_VALUE (objc_info);
+ /* Replace the IDENTIFIER_NODE with an actual @interface. */
+ TYPE_OBJC_INTERFACE (t) = class;
}
- /* `id' = `<class> *' `<class> *' = `id': always allow it.
- Please note that
- 'Object *o = [[Object alloc] init]; falls
- in the case <class> * = `id'.
- */
- if ((objc_is_object_id (lhs) && TYPED_OBJECT (rhs))
- || (objc_is_object_id (rhs) && TYPED_OBJECT (lhs)))
- return 1;
-
- /* `id' = `Class', `Class' = `id' */
+ /* Use TYPE_BINFO structures to point at the super class, if any. */
+ objc_xref_basetypes (s, super);
- else if ((objc_is_object_id (lhs) && objc_is_class_id (rhs))
- || (objc_is_class_id (lhs) && objc_is_object_id (rhs)))
- return 1;
+ /* Mark this struct as a class template. */
+ CLASS_STATIC_TEMPLATE (class) = s;
- /* `Class' != `<class> *' && `<class> *' != `Class'! */
- else if ((OBJC_TYPE_NAME (lhs) == objc_class_id && TYPED_OBJECT (rhs))
- || (OBJC_TYPE_NAME (rhs) == objc_class_id && TYPED_OBJECT (lhs)))
- return 0;
+ return s;
+}
- /* `<class> *' = `<class> *' */
+/* 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;
- else if (TYPED_OBJECT (lhs) && TYPED_OBJECT (rhs))
+ /* Check if we have not constructed the desired variant already. */
+ for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
{
- tree lname = OBJC_TYPE_NAME (lhs);
- tree rname = OBJC_TYPE_NAME (rhs);
- tree inter;
+ /* The type qualifiers must (obviously) match up. */
+ if (!TYPE_VOLATILE (t)
+ || (TYPE_READONLY (t) != TYPE_READONLY (type))
+ || (TYPE_RESTRICT (t) != TYPE_RESTRICT (type)))
+ continue;
- if (lname == rname)
- return 1;
+ /* 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;
- /* 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;
+ /* Everything matches up! */
+ return t;
+ }
- /* 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;
+ /* 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 0;
- }
- else
- /* Not an ObjC type - let comptypes do the check. */
- return -1;
+ return t;
}
-/* Called from finish_decl. */
-
+/* Mark DECL as being 'volatile' for purposes of Darwin
+ _setjmp()/_longjmp() exception handling. Called from
+ objc_mark_locals_volatile(). */
void
-objc_check_decl (tree decl)
+objc_volatilize_decl (tree decl)
{
- tree type = TREE_TYPE (decl);
-
- if (TREE_CODE (type) != RECORD_TYPE)
- return;
- if (TYPE_NAME (type) && (type = objc_is_class_name (TYPE_NAME (type))))
- error ("statically allocated instance of Objective-C class `%s'",
- IDENTIFIER_POINTER (type));
-}
+ /* 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 t = TREE_TYPE (decl);
+ struct volatilized_type key;
+ void **loc;
-/* Implement static typing. At this point, we know we have an interface. */
+ t = objc_build_volatilized_type (t);
+ key.type = t;
+ loc = htab_find_slot (volatilized_htab, &key, INSERT);
-tree
-get_static_reference (tree interface, tree protocols)
-{
- tree type = xref_tag (RECORD_TYPE, interface);
+ if (!*loc)
+ {
+ *loc = ggc_alloc (sizeof (key));
+ ((struct volatilized_type *) *loc)->type = t;
+ }
- if (protocols)
- {
- type = build_variant_type_copy (type);
-
- /* 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 (type, lookup_and_install_protocols (protocols));
+ 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
}
-
- return type;
}
-/* Return a declaration corresponding to a protocol list qualified 'id'. */
-tree
-get_protocol_reference (tree protocols)
+/* 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 bool
+objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
{
- tree type_decl = lookup_name (objc_id_id);
- tree type;
+ bool class_type = (cls != NULL_TREE);
- if (type_decl && TREE_CODE (type_decl) == TYPE_DECL)
+ while (cls)
{
- type = TREE_TYPE (type_decl);
- if (TYPE_MAIN_VARIANT (type) != objc_id_type)
- warning ("unexpected type for `id' (%s)",
- gen_declaration (type, errbuf));
+ tree c;
+
+ /* Check protocols adopted by the class and its categories. */
+ for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
+ {
+ if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
+ return true;
+ }
+
+ /* Repeat for superclasses. */
+ cls = lookup_interface (CLASS_SUPER_NAME (cls));
}
- else
+
+ /* Check for any protocols attached directly to the object type. */
+ if (TYPE_HAS_OBJC_INFO (typ))
{
- error ("undefined type `id', please import <objc/objc.h>");
- return error_mark_node;
+ if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
+ return true;
}
- /* 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. */
-
- if (protocols)
+ if (warn)
{
- type = build_variant_type_copy (type);
-
- /* Look up protocols...and install in lang specific list */
- SET_TYPE_PROTOCOL_LIST (type, lookup_and_install_protocols (protocols));
+ 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 type;
+
+ return false;
}
-/* Check for circular dependencies in protocols. The arguments are
- PROTO, the protocol to check, and LIST, a list of protocol it
- conforms to. */
+/* Check if class RCLS and instance struct type RTYP conform to at least the
+ same protocols that LCLS and LTYP conform to. */
-static void
-check_protocol_recursively (tree proto, tree list)
+static bool
+objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
{
tree p;
+ bool have_lproto = false;
- for (p = list; p; p = TREE_CHAIN (p))
+ while (lcls)
{
- tree pp = TREE_VALUE (p);
+ /* 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 (TREE_CODE (pp) == IDENTIFIER_NODE)
- pp = lookup_protocol (pp);
+ if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
+ return warn;
+ }
- if (pp == proto)
- fatal_error ("protocol `%s' has circular dependency",
- IDENTIFIER_POINTER (PROTOCOL_NAME (pp)));
+ /* Repeat for superclasses. */
+ lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
+ }
+
+ /* Check for any protocols attached directly to the object type. */
+ if (TYPE_HAS_OBJC_INFO (ltyp))
+ {
+ for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p))
+ {
+ have_lproto = true;
+
+ if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
+ return warn;
+ }
+ }
+
+ /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
+ vacuously, _unless_ RTYP is a protocol-qualified 'id'. We can get
+ away with simply checking for 'id' or 'Class' (!RCLS), since this
+ routine will not get called in other cases. */
+ return have_lproto || (rcls != NULL_TREE);
+}
+
+/* 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
+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 INTERFACE is not provided, default to 'id'. */
+ tree type = (interface ? objc_is_id (interface) : objc_object_type);
+ bool is_ptr = (type != NULL_TREE);
+
+ if (!is_ptr)
+ {
+ type = objc_is_class_name (interface);
+
+ if (type)
+ 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)
+ {
+ TREE_TYPE (type) = build_variant_type_copy (TREE_TYPE (type));
+ TYPE_POINTER_TO (TREE_TYPE (type)) = type;
+ type = TREE_TYPE (type);
+ }
+
+ /* Look up protocols and install in lang specific list. */
+ DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
+ TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols (protocols);
+
+ /* 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));
}
tree ident = TREE_VALUE (proto);
tree p = lookup_protocol (ident);
- if (!p)
- error ("cannot find protocol declaration for `%s'",
- IDENTIFIER_POINTER (ident));
- else
+ if (p)
return_value = chainon (return_value,
build_tree_list (NULL_TREE, p));
+ else if (ident != error_mark_node)
+ error ("cannot find protocol declaration for %qs",
+ IDENTIFIER_POINTER (ident));
}
return return_value;
}
-/* Create and push a decl for a built-in external variable or field NAME.
- CODE says which.
- TYPE is its data type. */
+/* Create a declaration for field NAME of a given TYPE. */
static tree
-create_builtin_decl (enum tree_code code, tree type, const char *name)
+create_field_decl (tree type, const char *name)
{
- tree decl = build_decl (code, get_identifier (name), type);
+ return build_decl (FIELD_DECL, get_identifier (name), type);
+}
- if (code == VAR_DECL)
- {
- TREE_STATIC (decl) = 1;
- make_decl_rtl (decl);
- pushdecl (decl);
- DECL_ARTIFICIAL (decl) = 1;
- }
+/* 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. */
- return decl;
+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;
}
-/* Find the decl for the constant string class. */
+/* 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)
{
- if (!string_class_decl)
- {
- if (!constant_string_global_id)
- {
- 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);
- }
+ 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;
+
+ /* Suppress outputting debug symbols, because
+ dbxout_init hasn'r been called yet. */
+ write_symbols = NO_DEBUG;
+ debug_hooks = &do_nothing_debug_hooks;
+
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c); /* extern "C" */
+#endif
+
+ /* The following are also defined in <objc/objc.h> and friends. */
- /* Defined in `objc.h' */
objc_object_id = get_identifier (TAG_OBJECT);
+ objc_class_id = get_identifier (TAG_CLASS);
objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
+ objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
- objc_id_type = build_pointer_type (objc_object_reference);
+ objc_object_type = build_pointer_type (objc_object_reference);
+ objc_class_type = build_pointer_type (objc_class_reference);
- objc_id_id = get_identifier (TYPE_ID);
- objc_class_id = get_identifier (TAG_CLASS);
+ objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
+ objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
- 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));
- objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE, temp_type));
+ /* 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;
+
+ /* Forward-declare '@interface Protocol'. */
+
+ type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
+ objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
+ objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
+ type));
/* Declare type of selector-objects that represent an operation name. */
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)));
+
+ /* 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)
{
/* NB: In order to call one of the ..._stret (struct-returning)
/* id objc_msgSendNonNil (id, SEL, ...); */
/* id objc_msgSend_stret (id, SEL, ...); */
/* id objc_msgSendNonNil_stret (id, SEL, ...); */
- temp_type
- = build_function_type (objc_id_type,
- tree_cons (NULL_TREE, objc_id_type,
- tree_cons (NULL_TREE,
- objc_selector_type,
+ 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,
- temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_nonnil_decl = builtin_function (TAG_MSGSEND_NONNIL,
- temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_stret_decl = builtin_function (TAG_MSGSEND_STRET,
- temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_nonnil_stret_decl = builtin_function (TAG_MSGSEND_NONNIL_STRET,
- temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
+ /* These can throw, because the function that gets called can throw
+ in Obj-C++, or could itself call something that can throw even
+ in Obj-C. */
+ TREE_NOTHROW (umsg_decl) = 0;
+ TREE_NOTHROW (umsg_nonnil_decl) = 0;
+ TREE_NOTHROW (umsg_stret_decl) = 0;
+ TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
+
+ /* id objc_msgSend_Fast (id, SEL, ...)
+ __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
+#ifdef OFFS_MSGSEND_FAST
+ umsg_fast_decl = 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, ...); */
- temp_type
- = build_function_type (objc_id_type,
+ type
+ = build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_super_type,
- tree_cons (NULL_TREE,
- objc_selector_type,
+ tree_cons (NULL_TREE, objc_selector_type,
NULL_TREE)));
umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
- temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_super_stret_decl = builtin_function (TAG_MSGSENDSUPER_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
{
/* typedef id (*IMP)(id, SEL, ...); */
tree IMP_type
= build_pointer_type
- (build_function_type (objc_id_type,
- tree_cons (NULL_TREE, objc_id_type,
- tree_cons (NULL_TREE,
- objc_selector_type,
- NULL_TREE))));
+ (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); */
- temp_type
+ type
= build_function_type (IMP_type,
- tree_cons (NULL_TREE, objc_id_type,
- tree_cons (NULL_TREE,
- objc_selector_type,
- void_list_node)));
+ tree_cons (NULL_TREE, objc_object_type,
+ tree_cons (NULL_TREE, objc_selector_type,
+ OBJC_VOID_AT_END)));
umsg_decl = builtin_function (TAG_MSGSEND,
- temp_type, 0, NOT_BUILT_IN,
+ type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
+ TREE_NOTHROW (umsg_decl) = 0;
/* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
- temp_type
+ type
= build_function_type (IMP_type,
- tree_cons (NULL_TREE, objc_super_type,
- tree_cons (NULL_TREE,
- objc_selector_type,
- void_list_node)));
+ 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,
- temp_type, 0, NOT_BUILT_IN,
+ 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 (objc_id_type,
+ type = build_function_type (objc_object_type,
tree_cons (NULL_TREE,
const_string_type_node,
- void_list_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_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 (objc_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;
- }
+ 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;
-/* Custom build_string which sets TREE_TYPE! */
+/* Construct an internal string layout to be used as a template for
+ creating NSConstantString/NXConstantString instances. */
static tree
-my_build_string (int len, const char *str)
+objc_build_internal_const_str_type (void)
{
- return fix_string_type (build_string (len, str));
-}
+ 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
+my_build_string (int len, const char *str)
+{
+ return fix_string_type (build_string (len, str));
+}
+
+/* Build a string with contents STR and length LEN and convert it to a
+ pointer. */
+
+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
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;
+ 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);
- }
- fields = TYPE_FIELDS (constant_string_type);
-
- /* & ((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
- (fields,
- copy_node (build_unary_op (ADDR_EXPR, string_class_decl, 0)));
- }
- else
- {
- initlist = build_tree_list (fields, build_int_cst (NULL_TREE, 0));
}
- fields = TREE_CHAIN (fields);
-
- initlist
- = tree_cons (fields, copy_node (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 (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;
}
- constructor = build_unary_op (ADDR_EXPR, constructor, 1);
- TREE_CONSTANT (constructor) = true;
- return constructor;
+ 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. */
static tree
objc_build_constructor (tree type, tree elts)
{
- tree constructor, f, e;
+ tree constructor = build_constructor_from_list (type, elts);
- /* ??? 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));
- }
-
- 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 (objc_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_cst (NULL_TREE, index))),
"defs");
/* sel_ref_cnt = { ..., 5, ... } */
- initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 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_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, ... } */
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_cst (NULL_TREE, OBJC_VERSION);
+ 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", ... } */
+ /* Don't provide any file name for security reasons. */
+ /* name = { ..., "", ... } */
- expr = add_objc_string (get_identifier (input_filename), class_names);
+ expr = add_objc_string (get_identifier (""), class_names);
initlist = tree_cons (NULL_TREE, expr, initlist);
/* symtab = { ..., _OBJC_SYMBOLS, ... } */
}
/* 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)));
+
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif
+}
+
+/* The GNU runtime requires us to provide a static initializer function
+ for each module:
- decl_specs = tree_cons (NULL_TREE, objc_module_template,
- build_tree_list (NULL_TREE,
- ridpointers[(int) RID_STATIC]));
+ static void __objc_gnu_init (void) {
+ __objc_exec_class (&L_OBJC_MODULES);
+ } */
- UOBJC_MODULES_decl = start_decl (get_identifier ("_OBJC_MODULES"),
- decl_specs, 1, NULL_TREE);
+static void
+build_module_initializer_routine (void)
+{
+ tree body;
+
+#ifdef OBJCPLUS
+ push_lang_context (lang_name_c); /* extern "C" */
+#endif
- DECL_ARTIFICIAL (UOBJC_MODULES_decl) = 1;
- DECL_IGNORED_P (UOBJC_MODULES_decl) = 1;
- DECL_CONTEXT (UOBJC_MODULES_decl) = NULL_TREE;
+ 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));
- finish_decl (UOBJC_MODULES_decl,
- init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)),
- NULL_TREE);
+ 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));
- /* Mark the decl to avoid "defined but not used" warning. */
- DECL_IN_SYSTEM_HEADER (UOBJC_MODULES_decl) = 1;
-
- mark_decl_referenced (UOBJC_MODULES_decl);
+ 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, compound;
-
- /* 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,
- void_list_node)));
-
- 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);
- 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,
- void_list_node),
- NULL_TREE),
- NULL_TREE);
- store_parm_decls ();
- compound = c_begin_compound_stmt (true);
-
- 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;
-
- parms
- = build_tree_list (NULL_TREE,
- build_unary_op (ADDR_EXPR, UOBJC_MODULES_decl, 0));
- decelerator = build_function_call (execclass_decl, parms);
-
- add_stmt (decelerator);
- add_stmt (c_end_compound_stmt (compound, true));
-
- finish_function ();
-
- return XEXP (DECL_RTL (init_function_decl), 0);
- }
+#ifdef OBJCPLUS
+ pop_lang_context ();
+#endif
+}
+
+#ifdef OBJCPLUS
+/* Return 1 if the __objc_gnu_init function has been synthesized and needs
+ to be called by the module initializer routine. */
+
+int
+objc_static_init_needed_p (void)
+{
+ return (GNU_INIT_decl != NULL_TREE);
}
+/* Generate a call to the __objc_gnu_init initializer function. */
+
+tree
+objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
+{
+ add_stmt (build_stmt (EXPR_STMT,
+ build_function_call (GNU_INIT_decl, NULL_TREE)));
+
+ return ctors;
+}
+#endif /* OBJCPLUS */
+
/* Return the DECL of the string IDENT in the SECTION. */
static tree
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;
+ 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, NULL_TREE, 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;
- TREE_USED (decl) = 1;
+ decl = start_var_decl (type, buf);
/* Output {class_name, ...}. */
class = TREE_VALUE (cl_chain);
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);
+ 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_cst (NULL_TREE, 0), decls);
- ident = get_identifier ("_OBJC_STATIC_INSTANCES");
- expr_decl = build_nt (ARRAY_REF, ident, NULL_TREE, NULL_TREE, 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);
- rest_of_decl_compilation (static_instances_decl, 0, 0);
-}
-
-/* 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,
- NULL_TREE, 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,
- NULL_TREE, 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,
- NULL_TREE, 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);
- }
+ 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, objc_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);
- 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 (objc_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, objc_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_cst (NULL_TREE, 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);
}
}
build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_cst (NULL_TREE, index)),
1);
- return build_c_cast (objc_selector_type, expr);
+ return convert (objc_selector_type, expr);
}
static tree
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);
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);
- 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 = objc_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);
pushdecl_top_level (decl);
#endif /* OBJCPLUS */
if (!(underlying_class = objc_is_class_name (class_ident)))
- warning ("cannot find class `%s'", IDENTIFIER_POINTER (class_ident));
+ warning (0, "cannot find class %qs", IDENTIFIER_POINTER (class_ident));
else if (objc_is_class_name (alias_ident))
- warning ("class `%s' already exists", IDENTIFIER_POINTER (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
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);
}
}
&& 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
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 (!type || TREE_CODE (type) != POINTER_TYPE)
+ if (!POINTER_TYPE_P (type))
return 0;
- /* NB: This function may be called before the ObjC front-end has
- been initialized, in which case OBJC_ID_TYPE will be NULL. */
- if (objc_id_type && type && TYPE_P (type)
- && (IS_ID (type)
- || TREE_TYPE (type) == TREE_TYPE (objc_class_type)))
- return type;
- return objc_is_class_name (OBJC_TYPE_NAME (TREE_TYPE (type)));
+
+ ret = objc_is_id (type);
+ if (!ret)
+ ret = objc_is_class_name (TREE_TYPE (type));
+
+ return ret;
}
-static tree
-lookup_interface (tree ident)
+static int
+objc_is_gcable_type (tree type, int or_strong_p)
{
- tree chain;
+ tree name;
-#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;
+ 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;
}
- return NULL_TREE;
}
-/* Implement @defs (<classname>) within struct bodies. */
+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);
+}
-tree
-get_class_ivars_from_name (tree class_name)
+static tree
+objc_build_global_assignment (tree lhs, tree rhs)
{
- tree interface = lookup_interface (class_name);
- tree field, fields = NULL_TREE;
+ 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));
- if (interface)
- {
- tree raw_ivar = get_class_ivars (interface, 1);
+ assemble_external (objc_assign_global_decl);
+ return build_function_call (objc_assign_global_decl, func_params);
+}
- /* 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));
+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));
- return fields;
+ assemble_external (objc_assign_strong_cast_decl);
+ return build_function_call (objc_assign_strong_cast_decl, func_params);
}
-/* Used by: build_private_template, continue_class,
- and for @defs constructs. */
+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 tree
-get_class_ivars (tree interface, int raw)
+static int
+objc_is_ivar_reference_p (tree expr)
{
- tree my_name, super_name, ivar_chain;
+ 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);
+}
- my_name = CLASS_NAME (interface);
- super_name = CLASS_SUPER_NAME (interface);
- if (raw)
- ivar_chain = CLASS_RAW_IVARS (interface);
- else
+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)
{
- 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);
+ 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);
+ }
}
- while (super_name)
+ /* If we have a __strong cast, it trumps all else. */
+ if (strong_cast_p)
{
- tree op1;
- tree super_interface = lookup_interface (super_name);
+ if (modifycode != NOP_EXPR)
+ goto invalid_pointer_arithmetic;
- 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 (warn_assign_intercept)
+ warning (0, "strong-cast assignment has been intercepted");
- if (super_interface == interface)
- fatal_error ("circular inheritance in interface declaration for `%s'",
- IDENTIFIER_POINTER (super_name));
+ result = objc_build_strong_cast_assignment (lhs, rhs);
- interface = super_interface;
- my_name = CLASS_NAME (interface);
- super_name = CLASS_SUPER_NAME (interface);
+ goto exit_point;
+ }
- op1 = (raw ? CLASS_RAW_IVARS (interface) : CLASS_OWN_IVARS (interface));
- if (op1)
- {
- tree head = copy_list (op1);
+ /* the lhs must be of a suitable type, regardless of its underlying
+ structure. */
+ if (!objc_is_gcable_p (lhs))
+ goto exit_point;
- /* 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;
- }
+ outer = lhs;
+
+ while (outer
+ && (TREE_CODE (outer) == COMPONENT_REF
+ || TREE_CODE (outer) == ARRAY_REF))
+ outer = TREE_OPERAND (outer, 0);
+
+ if (TREE_CODE (outer) == INDIRECT_REF)
+ {
+ outer = TREE_OPERAND (outer, 0);
+ indirect_p = 1;
+ }
+
+ outer_gc_p = objc_is_gcable_p (outer);
+
+ /* Handle ivar assignments. */
+ if (objc_is_ivar_reference_p (lhs))
+ {
+ /* if the struct to the left of the ivar is not an Objective-C object (__strong
+ doesn't cut it here), the best we can do here is suggest a cast. */
+ if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
+ {
+ /* We may still be able to use the global write barrier... */
+ if (!indirect_p && objc_is_global_reference_p (outer))
+ goto global_reference;
+
+ suggest_cast:
+ if (modifycode == NOP_EXPR)
+ {
+ if (warn_assign_intercept)
+ warning (0, "strong-cast may possibly be needed");
+ }
+
+ goto exit_point;
+ }
+
+ if (modifycode != NOP_EXPR)
+ goto invalid_pointer_arithmetic;
+
+ if (warn_assign_intercept)
+ warning (0, "instance variable assignment has been intercepted");
+
+ result = objc_build_ivar_assignment (outer, lhs, rhs);
+
+ goto exit_point;
+ }
+
+ /* Likewise, intercept assignment to global/static variables if their type is
+ GC-marked. */
+ if (objc_is_global_reference_p (outer))
+ {
+ if (indirect_p)
+ goto suggest_cast;
+
+ global_reference:
+ if (modifycode != NOP_EXPR)
+ {
+ invalid_pointer_arithmetic:
+ if (outer_gc_p)
+ warning (0, "pointer arithmetic for garbage-collected objects not allowed");
+
+ goto exit_point;
+ }
+
+ if (warn_assign_intercept)
+ warning (0, "global/static variable assignment has been intercepted");
+
+ result = objc_build_global_assignment (lhs, rhs);
+ }
+
+ /* In all other cases, fall back to the normal mechanism. */
+ exit_point:
+ return result;
+}
+
+struct interface_tuple GTY(())
+{
+ tree id;
+ tree class_name;
+};
+
+static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
+
+static hashval_t
+hash_interface (const void *p)
+{
+ const struct interface_tuple *d = p;
+ return htab_hash_pointer (d->id);
+}
+
+static int
+eq_interface (const void *p1, const void *p2)
+{
+ 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
+
+ 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
+objc_get_class_ivars (tree class_name)
+{
+ tree interface = lookup_interface (class_name);
+
+ if (interface)
+ return get_class_ivars (interface, true);
+
+ error ("cannot find interface declaration for %qs",
+ IDENTIFIER_POINTER (class_name));
+
+ return error_mark_node;
+}
+
+/* Used by: build_private_template, continue_class,
+ and for @defs constructs. */
+
+static tree
+get_class_ivars (tree interface, bool inherited)
+{
+ tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
+
+ /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
+ by the current class (i.e., they do not include super-class ivars).
+ However, the CLASS_IVARS list will be side-effected by a call to
+ finish_struct(), which will fill in field offsets. */
+ if (!CLASS_IVARS (interface))
+ CLASS_IVARS (interface) = ivar_chain;
+
+ if (!inherited)
+ return ivar_chain;
+
+ while (CLASS_SUPER_NAME (interface))
+ {
+ /* Prepend super-class ivars. */
+ interface = lookup_interface (CLASS_SUPER_NAME (interface));
+ ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
+ ivar_chain);
}
return ivar_chain;
objc_create_temporary_var (tree type)
{
tree decl;
-
+
decl = build_decl (VAR_DECL, NULL_TREE, type);
TREE_USED (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
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)
{
return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
}
+#endif
/* Initialize exception handling. */
return;
done = true;
- /* Why? */
- if (!flag_objc_exceptions)
- warning ("use %<-fobjc-exceptions%> to enable Objective-C "
- "exception syntax");
-
- if (!flag_objc_sjlj_exceptions)
+ 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,
tree var = cur_try_context->caught_decl;
if (!var)
{
- var = objc_create_temporary_var (objc_id_type);
+ var = objc_create_temporary_var (objc_object_type);
cur_try_context->caught_decl = var;
}
return var;
}
else
- return build (EXC_PTR_EXPR, objc_id_type);
+ return build0 (EXC_PTR_EXPR, objc_object_type);
}
/* Build "objc_exception_try_exit(&_stack)". */
t = tree_cons (NULL, t, NULL);
enter = build_function_call (objc_exception_try_enter_decl, t);
- t = build_component_ref (cur_try_context->stack_decl,
- get_identifier ("buf"));
+ 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);
- cond = build (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
- cond = lang_hooks.truthvalue_conversion (cond);
+ cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
+ cond = c_common_truthvalue_conversion (cond);
- return build (COND_EXPR, void_type_node, cond, NULL, NULL);
+ return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
}
-/* Build
- DECL = objc_exception_extract(&_stack);
-*/
-
+/* Build:
+
+ DECL = objc_exception_extract(&_stack); */
+
static tree
next_sjlj_build_exc_extract (tree 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);
+ t = build2 (MODIFY_EXPR, void_type_node, decl, t);
return t;
}
else
{
args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
- t = get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
+ 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 = lang_hooks.truthvalue_conversion (t);
+ cond = c_common_truthvalue_conversion (t);
}
- t = build (COND_EXPR, void_type_node, cond, body, NULL);
+ t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
*last = t;
if (!saw_id)
{
- t = build (MODIFY_EXPR, void_type_node, cur_try_context->rethrow_decl,
- cur_try_context->caught_decl);
- annotate_with_locus (t, cur_try_context->end_catch_locus);
+ t = build2 (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 ();
- annotate_with_locus (t, cur_try_context->end_catch_locus);
+ SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
append_to_statement_list (t, last);
}
stack_decl = objc_create_temporary_var (t);
cur_try_context->stack_decl = stack_decl;
- rethrow_decl = objc_create_temporary_var (objc_id_type);
+ 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;
- /* Build the outermost varible binding level. */
- bind = build (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
- annotate_with_locus (bind, cur_try_context->try_locus);
+ /* Build the outermost variable binding level. */
+ bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
+ SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
TREE_SIDE_EFFECTS (bind) = 1;
/* Initialize rethrow_decl. */
- t = build (MODIFY_EXPR, void_type_node, rethrow_decl,
- convert (objc_id_type, null_pointer_node));
- annotate_with_locus (t, cur_try_context->try_locus);
+ t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
+ convert (objc_object_type, null_pointer_node));
+ SET_EXPR_LOCATION (t, cur_try_context->try_locus);
append_to_statement_list (t, &BIND_EXPR_BODY (bind));
/* Build the outermost TRY_FINALLY_EXPR. */
- try_fin = build (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
- annotate_with_locus (try_fin, cur_try_context->try_locus);
+ try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
+ SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus);
TREE_SIDE_EFFECTS (try_fin) = 1;
append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind));
{
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));
}
else
catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
- annotate_with_locus (catch_seq, cur_try_context->end_try_locus);
+ SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
/* Build the main register-and-try if statement. */
t = next_sjlj_build_enter_and_setjmp ();
- annotate_with_locus (t, cur_try_context->try_locus);
+ SET_EXPR_LOCATION (t, cur_try_context->try_locus);
COND_EXPR_THEN (t) = catch_seq;
COND_EXPR_ELSE (t) = cur_try_context->try_body;
TREE_OPERAND (try_fin, 0) = t;
/* Build the complete FINALLY statement list. */
t = next_sjlj_build_try_exit ();
t = build_stmt (COND_EXPR,
- lang_hooks.truthvalue_conversion (rethrow_decl),
+ c_common_truthvalue_conversion (rethrow_decl),
NULL, t);
- annotate_with_locus (t, cur_try_context->finally_locus);
+ SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
append_to_statement_list (cur_try_context->finally_body,
t = tree_cons (NULL, rethrow_decl, NULL);
t = build_function_call (objc_exception_throw_decl, t);
t = build_stmt (COND_EXPR,
- lang_hooks.truthvalue_conversion (rethrow_decl),
+ c_common_truthvalue_conversion (rethrow_decl),
t, NULL);
- annotate_with_locus (t, cur_try_context->end_finally_locus);
+ SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
return bind;
cur_try_context = c;
objc_init_exceptions ();
+
+ if (flag_objc_sjlj_exceptions)
+ objc_mark_locals_volatile (NULL);
}
-/* Called just after parsing "@catch (parm)". Open a binding level,
- enter PARM into the binding level, and initialize it. Leave the
+/* 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_begin_catch_clause (tree parm)
+objc_begin_catch_clause (tree decl)
{
- tree compound, decl, type, t;
+ tree compound, type, t;
/* Begin a new scope that the entire catch clause will live in. */
- compound = c_begin_compound_stmt (1);
+ compound = c_begin_compound_stmt (true);
- /* Turn the raw declarator/declspecs into a decl in the current scope. */
- decl = define_decl (TREE_VALUE (TREE_PURPOSE (parm)),
- TREE_PURPOSE (TREE_PURPOSE (parm)));
+ /* 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);
/* Since a decl is required here by syntax, don't warn if its unused. */
/* ??? As opposed to __attribute__((unused))? Anyway, this appears to
/* 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);
+
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)))
t = CATCH_TYPES (stmt);
if (t == error_mark_node)
continue;
- if (!t || objc_comptypes (TREE_TYPE (t), TREE_TYPE (type), 0) == 1)
+ if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
{
- warning ("exception of type %<%T%> will be caught",
+ warning (0, "exception of type %<%T%> will be caught",
TREE_TYPE (type));
- warning ("%H by earlier handler for %<%T%>",
- EXPR_LOCUS (stmt), TREE_TYPE (t ? t : objc_id_type));
+ warning (0, "%H by earlier handler for %<%T%>",
+ EXPR_LOCUS (stmt), TREE_TYPE (t ? t : objc_object_type));
break;
}
}
/* 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);
+ t = build2 (MODIFY_EXPR, void_type_node, decl, t);
add_stmt (t);
}
/* Called to finalize a @try construct. */
-void
+tree
objc_finish_try_stmt (void)
{
struct objc_try_context *c = cur_try_context;
tree stmt;
if (c->catch_list == NULL && c->finally_body == NULL)
- error ("`@try' without `@catch' or `@finally'");
+ error ("%<@try%> without %<@catch%> or %<@finally%>");
/* If we're doing Darwin setjmp exceptions, build the big nasty. */
if (flag_objc_sjlj_exceptions)
if (c->catch_list)
{
stmt = build_stmt (TRY_CATCH_EXPR, stmt, c->catch_list);
- annotate_with_locus (stmt, cur_try_context->try_locus);
+ SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
}
if (c->finally_body)
{
stmt = build_stmt (TRY_FINALLY_EXPR, stmt, c->finally_body);
- annotate_with_locus (stmt, cur_try_context->try_locus);
+ SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
}
}
add_stmt (stmt);
cur_try_context = c->outer;
free (c);
+ return stmt;
}
tree
return add_stmt (build_function_call (objc_exception_throw_decl, args));
}
-void
+tree
objc_build_synchronized (location_t start_locus, tree mutex, tree body)
{
tree args, call;
mutex = save_expr (mutex);
args = tree_cons (NULL, mutex, NULL);
call = build_function_call (objc_sync_enter_decl, args);
- annotate_with_locus (call, start_locus);
+ SET_EXPR_LOCATION (call, start_locus);
add_stmt (call);
/* Build the mutex unlock. */
args = tree_cons (NULL, mutex, NULL);
call = build_function_call (objc_sync_exit_decl, args);
- annotate_with_locus (call, input_location);
+ SET_EXPR_LOCATION (call, input_location);
/* Put the that and the body in a TRY_FINALLY. */
objc_begin_try_stmt (start_locus, body);
objc_build_finally_clause (input_location, call);
- objc_finish_try_stmt ();
+ return objc_finish_try_stmt ();
}
\f
struct _objc_exception_data
{
- int buf[_JBLEN];
+ int buf[OBJC_JBLEN];
void *pointers[4];
}; */
/* The following yuckiness should prevent users from having to #include
<setjmp.h> in their code... */
-#ifdef TARGET_POWERPC
-/* snarfed from /usr/include/ppc/setjmp.h */
-#define _JBLEN (26 + 36 + 129 + 1)
-#else
-/* snarfed from /usr/include/i386/{setjmp,signal}.h */
-#define _JBLEN 18
+/* Define to a harmless positive value so the below code doesn't die. */
+#ifndef OBJC_JBLEN
+#define OBJC_JBLEN 18
#endif
static 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]; */
+ /* int buf[OBJC_JBLEN]; */
- index = build_index_type (build_int_cst (NULL_TREE, _JBLEN - 1));
- field_decl = create_builtin_decl (FIELD_DECL,
- build_array_type (integer_type_node, index),
- "buf");
+ index = build_index_type (build_int_cst (NULL_TREE, OBJC_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_cst (NULL_TREE, 4 - 1));
- field_decl = create_builtin_decl (FIELD_DECL,
- build_array_type (ptr_type_node, index),
- "pointers");
+ 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);
/* id objc_exception_extract(struct _objc_exception_data *); */
temp_type
- = build_function_type (objc_id_type,
+ = build_function_type (objc_object_type,
tree_cons (NULL_TREE,
build_pointer_type (objc_exception_data_template),
- void_list_node));
+ OBJC_VOID_AT_END));
objc_exception_extract_decl
= builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
/* void objc_exception_try_enter(struct _objc_exception_data *); */
= build_function_type (void_type_node,
tree_cons (NULL_TREE,
build_pointer_type (objc_exception_data_template),
- void_list_node));
+ OBJC_VOID_AT_END));
objc_exception_try_enter_decl
= 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
+ temp_type
= build_function_type (integer_type_node,
- tree_cons (NULL_TREE, objc_id_type,
- tree_cons (NULL_TREE, objc_id_type,
- void_list_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);
-
- write_symbols = save_write_symbols;
- debug_hooks = save_hooks;
+
+ /* 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
/* void objc_sync_enter(id); */
/* void objc_sync_exit(id); */
temp_type = build_function_type (void_type_node,
- tree_cons (NULL_TREE, objc_id_type,
- void_list_node));
+ 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,
noreturn_list);
NULL, nothrow_list);
}
+/* Construct a C struct corresponding to ObjC class CLASS, with the same
+ name as the class:
-/* struct <classname> {
- struct objc_class *isa;
+ struct <classname> {
+ struct _objc_class *isa;
...
}; */
-static tree
+static void
build_private_template (tree class)
{
- tree ivar_context;
-
- if (CLASS_STATIC_TEMPLATE (class))
- {
- uprivate_record = CLASS_STATIC_TEMPLATE (class);
- ivar_context = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (class));
- }
- else
+ if (!CLASS_STATIC_TEMPLATE (class))
{
- 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;
}
-
- objc_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_cst (NULL_TREE, size), NULL_TREE, NULL_TREE);
- 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_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_cst (NULL_TREE, 0);
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. */
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);
}
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",
objc_class_template);
-
- mark_decl_referenced (UOBJC_CLASS_decl);
- mark_decl_referenced (UOBJC_METACLASS_decl);
/* 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 (TREE_VALUE (TREE_VALUE (rawimpdecls)))
- {
- /* t1 is the bit-field type, so t2 must be converted to the
- bit-field type for comparison as well. */
- unsigned HOST_WIDE_INT width
- = tree_low_cst (TREE_VALUE (TREE_VALUE (rawimpdecls)), 1);
- if (width != TYPE_PRECISION (t2))
- t2 = build_nonstandard_integer_type (width, TYPE_UNSIGNED (t2));
- }
-
if (!comptypes (t1, t2)
- || !tree_int_cst_equal (TREE_VALUE (TREE_VALUE (rawintdecls)),
- TREE_VALUE (TREE_VALUE (rawimpdecls))))
+ || !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_cst (NULL_TREE, size), NULL_TREE, NULL_TREE);
-
- 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_cst (NULL_TREE, size), NULL_TREE, NULL_TREE);
-
- 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);
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_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_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;
}
/* Count only the fields occurring in T. */
+
static int
ivar_list_length (tree t)
{
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;
+ 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_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_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
/* Build initializer. */
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), NULL_TREE);
-
- e = build_int_cst (cast_type, size);
+ 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_cst (NULL_TREE, size + 2), NULL_TREE, NULL_TREE);
+ 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_cst (NULL_TREE, size + 2), NULL_TREE, NULL_TREE);
+ 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_cst (NULL_TREE, size + 2), NULL_TREE, NULL_TREE);
+ 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_decl (expr_decl, decl_specs, 1, NULL_TREE);
- DECL_CONTEXT (refs_decl) = NULL_TREE;
+ 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);
- 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, 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_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);
}
if (!protocol_list)
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_cst (NULL_TREE, 0), initlist);
+ initlist = tree_cons (NULL_TREE, build_int_cst (long_integer_type_node, 0),
+ initlist);
/* info = */
- initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, status), 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_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);
}
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 (! protocol_list)
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 */
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);
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, objc_super_type);
- else if (context == METHOD_DEF)
- arglist = build_tree_list (NULL_TREE, TREE_TYPE (self_decl));
+ else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
+ arglist = build_tree_list (NULL_TREE, objc_instance_type);
else
- arglist = build_tree_list (NULL_TREE, objc_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, objc_selector_type));
/* 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 (true). */
- ;
- 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 (false) */
- chainon (arglist, void_list_node);
+ {
+ 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)));
warn_with_method (methods ? "using" : "found",
((TREE_CODE (meth) == INSTANCE_METHOD_DECL)
? '-'
- : '+'),
+ : '+'),
meth);
for (loop = hsh->list; loop; loop = loop->next)
warn_with_method ("also found",
((TREE_CODE (loop->value) == INSTANCE_METHOD_DECL)
- ? '-'
+ ? '-'
: '+'),
loop->value);
}
}
/* 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)
(*(<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
if (!is_class)
method_prototype = hash_lookup (nst_method_hash_list,
sel_name);
-
+
if (!method_prototype)
{
method_prototype = hash_lookup (cls_method_hash_list,
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, class_tree;
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. */
class_tree = receiver_is_class_object (receiver, self, 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, class_tree);
- else if (IS_ID (rtype))
- {
- rprotos = TYPE_PROTOCOL_LIST (rtype);
- rtype = NULL_TREE;
- }
- else
- class_tree = 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,
- class_tree != NULL_TREE);
- if (!method_prototype && !rprotos)
- method_prototype
- = lookup_method_in_hash_lists (sel_name,
- class_tree != 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)
{
exist locally as part of the @implementation. */
if (!method_prototype && objc_implementation_context
&& CLASS_NAME (objc_implementation_context)
- == OBJC_TYPE_NAME (rtype))
+ == OBJC_TYPE_NAME (rtype))
method_prototype
= lookup_method
((class_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)),
(class_tree ? '+' : '-'),
IDENTIFIER_POINTER (sel_name));
- if (rprotos)
- warning ("`%c%s' not implemented by protocol(s)",
+ /* 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 ? objc_super_type : objc_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))
- : objc_id_type);
+ ? TREE_VALUE (TREE_TYPE (method_prototype))
+ : objc_object_type);
tree sender_cast
= build_pointer_type
(build_function_type
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);
/* First, call the lookup function to get a pointer to the method,
then cast the pointer, then call it with the method arguments. */
-
+
object = (super_flag ? self_decl : lookup_object);
t = tree_cons (NULL_TREE, selector, NULL_TREE);
/* ??? 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);
+ t = build3 (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);
- 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;
}
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) = objc_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));
/* Add the method to the hash list if it doesn't contain an identical
method already. */
+
static void
add_method_to_hash_list (hash *hash_list, tree method)
{
{
/* 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)
{
return (TREE_PRIVATE (decl)
int
objc_is_public (tree expr, tree identifier)
{
- tree basetype = TREE_TYPE (expr);
- enum tree_code code = TREE_CODE (basetype);
- tree decl;
+ tree basetype, decl;
- if (code == RECORD_TYPE)
+#ifdef OBJCPLUS
+ if (processing_template_decl)
+ return 1;
+#endif
+
+ if (TREE_TYPE (expr) == error_mark_node)
+ return 1;
+
+ basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
+
+ if (basetype && TREE_CODE (basetype) == RECORD_TYPE)
{
- if (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))))
+ && ((TREE_CODE (objc_implementation_context)
+ == CLASS_IMPLEMENTATION_TYPE)
+ || (TREE_CODE (objc_implementation_context)
+ == CATEGORY_IMPLEMENTATION_TYPE)))
{
- int private = is_private (decl);
+ 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)));
- if (private)
- error ("instance variable `%s' is declared private",
- IDENTIFIER_POINTER (DECL_NAME (decl)));
- return !private;
+ 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_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 (! 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'",
-#endif
+ 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
+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)
}
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))));
+ if (TREE_INT_CST_LOW (TYPE_SIZE (array_of)) == 0)
+ sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0);
+ else
+ sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC,
+ TREE_INT_CST_LOW (an_int_cst)
+ / TREE_INT_CST_LOW (TYPE_SIZE (array_of)));
obstack_grow (&util_obstack, buffer, strlen (buffer));
encode_type (array_of, curtype, format);
}
\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). */
type = TYPE_MAIN_VARIANT (type);
name = OBJC_TYPE_NAME (type);
- /* Open parenth/bracket. */
+ /* Open parenth/bracket. */
obstack_1grow (&util_obstack, left);
/* Encode the struct/union tag name, or '?' if a tag was
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. */
+ /* 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 = TYPE_UNSIGNED (type) ? 'C' : 'c'; break;
case 16: c = TYPE_UNSIGNED (type) ? 'S' : 's'; break;
- case 32:
+ case 32:
if (type == long_unsigned_type_node
|| type == long_integer_type_node)
c = TYPE_UNSIGNED (type) ? 'L' : 'l';
{
case 32: c = 'f'; break;
case 64:
+ case 96:
case 128: c = 'd'; break;
default: abort ();
}
else if (code == FUNCTION_TYPE) /* '?' */
obstack_1grow (&util_obstack, '?');
+
+ else if (code == COMPLEX_TYPE)
+ {
+ obstack_1grow (&util_obstack, 'j');
+ encode_type (TREE_TYPE (type), curtype, format);
+ }
}
static void
encode_type (TREE_TYPE (field_decl), curtype, format);
}
+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)
+{
+ /* 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));
+
+ /* 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_expr_last (tree complex_expr)
+objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED)
+#else
+static struct c_arg_info *
+objc_get_parm_info (int have_ellipsis)
+#endif
{
- tree next;
+#ifdef OBJCPLUS
+ tree parm_info = objc_parmlist;
+ objc_parmlist = NULL_TREE;
- if (complex_expr)
- while ((next = TREE_OPERAND (complex_expr, 0)))
- complex_expr = next;
+ 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);
- return complex_expr;
+ 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, TREE_TYPE (objc_selector_type));
- 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. */
- push_scope ();
- declare_parm_level ();
-
/* 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
- }
+ tree type = TREE_VALUE (TREE_TYPE (parmlist)), parm;
- else
- push_parm_decl (build_tree_list
- (build_tree_list (arg_spec,
- KEYWORD_ARG_NAME (arglist)),
- NULL_TREE));
-
- 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));
+ warning (0, "%J%s %<%c%s%>", method,
+ message, mtype, gen_method_decl (method));
}
-/* 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);
-}
-
-/* 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);
}
+/* 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",
where 1 <= n <= nMethods, and cls is the name the implementation we
are processing.
- 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);
+ 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);
- 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);
-
- /* 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 (/*ellipsis=*/true);
- else
- parmlist = get_parm_info (/*ellipsis=*/false);
-
-#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 */
-
- pop_scope ();
- 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;
-
+ 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 = super_expr;
/* Set class to begin searching. */
-#ifdef OBJCPLUS
- super_expr = build_component_ref (UOBJC_SUPER_decl,
- get_identifier ("super_class"));
-#else
- super_expr = build_component_ref (UOBJC_SUPER_decl,
- get_identifier ("class"));
-#endif
+ super_expr = objc_build_component_ref (UOBJC_SUPER_decl,
+ get_identifier ("super_class"));
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
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));
- }
-
- super_expr_list = build_compound_expr (super_expr_list, super_expr);
-
- super_expr = build_unary_op (ADDR_EXPR, UOBJC_SUPER_decl, 0);
- super_expr_list = build_compound_expr (super_expr_list, super_expr);
-
- return super_expr_list;
- }
- else
- {
- error ("[super ...] must appear in a method context");
- return error_mark_node;
- }
-}
-
-/* When exiting a scope, sever links to a 'super' declaration (if any)
- therein contained. */
-
-void
-objc_clear_super_receiver (void)
-{
- if (objc_method_context
- && UOBJC_SUPER_scope == objc_get_current_scope ()) {
- UOBJC_SUPER_decl = 0;
- UOBJC_SUPER_scope = 0;
- }
-}
-
-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;
-
- 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 (TYPE_READONLY (decl) || TYPE_VOLATILE (decl))
- {
- if (TYPE_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;
+ == INSTANCE_METHOD_DECL)
+ ? ucls_super_ref
+ : uucls_super_ref));
+ }
- for (chain = nreverse (copy_list (declspecs));
- chain; chain = TREE_CHAIN (chain))
+ else
+ /* We have a category. */
{
- tree aspec = TREE_VALUE (chain);
+ tree super_name = CLASS_SUPER_NAME (implementation_template);
+ tree super_class;
- if (TREE_CODE (aspec) == IDENTIFIER_NODE)
- strcat (buf, IDENTIFIER_POINTER (aspec));
- else if (TREE_CODE (aspec) == RECORD_TYPE)
+ /* Barf if super used in a category of Object. */
+ if (!super_name)
{
- if (OBJC_TYPE_NAME (aspec))
- {
- tree protocol_list = TYPE_PROTOCOL_LIST (aspec);
-
- if (! TREE_STATIC_TEMPLATE (aspec))
- strcat (buf, "struct ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (aspec)));
-
- /* 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
- strcat (buf, "untagged struct");
+ 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 (TYPE_READONLY (declspecs))
- strcat (buf, "const ");
- if (TYPE_VOLATILE (declspecs))
- strcat (buf, "volatile ");
+ error ("[super ...] must appear in a method context");
+ return error_mark_node;
+ }
+}
- switch (TREE_CODE (declspecs))
- {
- /* Type specifiers. */
+/* When exiting a scope, sever links to a 'super' declaration (if any)
+ therein contained. */
- case INTEGER_TYPE:
- declspecs = TYPE_MAIN_VARIANT (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;
+ }
+}
- /* Signed integer types. */
+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;
- 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 ");
+#ifndef OBJCPLUS
+ /* The C++ front-end will have called finish_function() for us. */
+ finish_function ();
+#endif
- /* Unsigned integer types. */
+ METHOD_ENCODING (objc_method_context)
+ = encode_method_prototype (objc_method_context);
- 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;
+ /* 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 REAL_TYPE:
- declspecs = TYPE_MAIN_VARIANT (declspecs);
+ if (should_call_super_dealloc)
+ warning (0, "method possibly missing a [super dealloc] call");
+}
- 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;
+#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 RECORD_TYPE:
- if (OBJC_TYPE_NAME (declspecs)
- && TREE_CODE (OBJC_TYPE_NAME (declspecs)) == IDENTIFIER_NODE)
- {
- tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
+ else
+ return 0;
+}
+#endif
- if (! TREE_STATIC_TEMPLATE (declspecs))
- strcat (buf, "struct ");
- strcat (buf, IDENTIFIER_POINTER (OBJC_TYPE_NAME (declspecs)));
+/* Given a tree DECL node, produce a printable description of it in the given
+ buffer, overwriting the buffer. */
- if (protocol_list)
- {
- tree chain = protocol_list;
+static char *
+gen_declaration (tree decl)
+{
+ errbuf[0] = '\0';
- strcat (buf, " <");
- while (chain)
- {
- strcat (buf,
- IDENTIFIER_POINTER
- (PROTOCOL_NAME (TREE_VALUE (chain))));
- chain = TREE_CHAIN (chain);
- if (chain)
- strcat (buf, ", ");
- }
- strcat (buf, ">");
- }
- }
+ if (DECL_P (decl))
+ {
+ gen_type_name_0 (TREE_TYPE (decl));
- else
- strcat (buf, "untagged struct");
+ if (DECL_NAME (decl))
+ {
+ if (!POINTER_TYPE_P (TREE_TYPE (decl)))
+ strcat (errbuf, " ");
- strcat (buf, " ");
- break;
+ strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl)));
+ }
- 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 (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)));
+ }
- else
- strcat (buf, "untagged union ");
- break;
+ return errbuf;
+}
- 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, " ");
- }
+/* Given a tree TYPE node, produce a printable description of it in the given
+ buffer, overwriting the buffer. */
- else
- strcat (buf, "untagged enum ");
- break;
+static char *
+gen_type_name_0 (tree type)
+{
+ tree orig = type, proto;
- case VOID_TYPE:
- strcat (buf, "void ");
- break;
+ if (TYPE_P (type) && TYPE_NAME (type))
+ type = TYPE_NAME (type);
+ else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
+ {
+ tree inner = TREE_TYPE (type);
+
+ while (TREE_CODE (inner) == ARRAY_TYPE)
+ inner = TREE_TYPE (inner);
+
+ gen_type_name_0 (inner);
- case POINTER_TYPE:
+ if (!POINTER_TYPE_P (inner))
+ strcat (errbuf, " ");
+
+ if (POINTER_TYPE_P (type))
+ strcat (errbuf, "*");
+ else
+ while (type != inner)
{
- tree protocol_list = TYPE_PROTOCOL_LIST (declspecs);
+ strcat (errbuf, "[");
- strcat (buf, "id");
- if (protocol_list)
+ if (TYPE_DOMAIN (type))
{
- 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, ">");
+ char sz[20];
+
+ sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
+ (TREE_INT_CST_LOW
+ (TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
+ strcat (errbuf, sz);
}
+
+ strcat (errbuf, "]");
+ type = TREE_TYPE (type);
}
- break;
- default:
- break;
- }
+ goto exit_function;
}
-}
-/* Given a tree node, produce a printable description of it in the given
- buffer, overwriting the buffer. */
+ if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
+ type = DECL_NAME (type);
-static char *
-gen_declaration (tree atype_or_adecl, char *buf)
-{
- buf[0] = '\0';
- gen_declaration_1 (atype_or_adecl, buf);
- return buf;
-}
+ strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE
+ ? IDENTIFIER_POINTER (type)
+ : "");
-/* Given a tree node, append a printable description to the end of the
- given buffer. */
+ /* For 'id' and 'Class', adopted protocols are stored in the pointee. */
+ if (objc_is_id (orig))
+ orig = TREE_TYPE (orig);
-static void
-gen_declaration_1 (tree atype_or_adecl, char *buf)
-{
- char declbuf[256];
+ proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
- if (TREE_CODE (atype_or_adecl) == TREE_LIST)
+ if (proto)
{
- tree declspecs; /* "identifier_node", "record_type" */
- tree declarator; /* "array_ref", "indirect_ref", "call_expr"... */
- tree width = NULL_TREE; /* for bitfields */
-
- /* 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);
+ 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));
+ while (proto) {
+ strcat (errbuf,
+ IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
+ proto = TREE_CHAIN (proto);
+ strcat (errbuf, proto ? ", " : ">");
+ }
}
- else
- {
- tree atype;
- tree declspecs; /* "integer_type", "real_type", "record_type"... */
- tree declarator; /* "array_type", "function_type", "pointer_type". */
-
- 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;
-
- 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;
- }
-
- else
- {
- declspecs = atype;
- declarator = NULL_TREE;
- }
-
- gen_declspecs (declspecs, buf, 0);
-
- 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)) : "");
+ exit_function:
+ return errbuf;
+}
- if (declarator)
- {
- strcat (buf, " ");
- strcat (buf, gen_declarator (declarator, declbuf, decl_name));
- }
+static char *
+gen_type_name (tree type)
+{
+ errbuf[0] = '\0';
- else if (decl_name[0])
- {
- strcat (buf, " ");
- strcat (buf, decl_name);
- }
- }
- else if (declarator)
- {
- strcat (buf, " ");
- strcat (buf, gen_declarator (declarator, declbuf, ""));
- }
- }
+ return gen_type_name_0 (type);
}
-#define RAW_TYPESPEC(meth) (TREE_VALUE (TREE_PURPOSE (TREE_TYPE (meth))))
-
/* 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);
}
(mangled[1] == 'i' || mangled[1] == 'c') &&
mangled[2] == '_')
{
- cp = demangled = xmalloc(strlen(mangled) + 2);
+ cp = demangled = XNEWVEC (char, strlen(mangled) + 2);
if (mangled[1] == 'i')
*cp++ = '-'; /* for instance method */
else
gcc_obstack_init (&util_obstack);
util_firstobj = (char *) obstack_finish (&util_obstack);
- errbuf = (char *) xmalloc (BUFSIZE);
+ errbuf = XNEWVEC (char, 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;
/* 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! */
-
- name = DECL_NAME (TREE_PURPOSE (chain));
+ expr = convert (type, expr); /* cast! */
- 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;
}
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);
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_cst (NULL_TREE, 1))),
- 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_cst (NULL_TREE, 0));
- initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 1), initlist);
- initlist = build_constructor (TREE_TYPE (decl), nreverse (initlist));
+ 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
-objc_lookup_ivar (tree id)
+objc_lookup_ivar (tree other, tree id)
{
- tree decl;
+ tree ivar;
- if (objc_method_context && !strcmp (IDENTIFIER_POINTER (id), "super"))
+ /* If we are not inside of an ObjC method, ivar lookup makes no sense. */
+ if (!objc_method_context)
+ return other;
+
+ if (!strcmp (IDENTIFIER_POINTER (id), "super"))
/* We have a message to super. */
return get_super_receiver ();
- 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 0;
- 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 = build3 (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"
OSDN Git Service
