#include "config.h"
#include "system.h"
#include "coretypes.h"
#include "tm.h"
#include "tree.h"
#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 "input.h"
#include "except.h"
#include "function.h"
#include "output.h"
#include "toplev.h"
#include "ggc.h"
#include "varray.h"
#include "debug.h"
#include "target.h"
#include "diagnostic.h"
#include "cgraph.h"
#include "tree-iterator.h"
#include "libfuncs.h"
#include "hashtab.h"
#include "langhooks-def.h"
#include "opts.h"
#define OBJC_VOID_AT_END void_list_node
static bool in_objc_property_setter_name_context = false;
static unsigned int should_call_super_dealloc = 0;
static bool should_call_super_finalize = false;
#ifdef OBJCPLUS
#define OBJCP_REMAP_FUNCTIONS
#include "objcp-decl.h"
#endif
#ifndef OBJC_GEN_METHOD_LABEL
#define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
do { \
char *temp; \
sprintf ((BUF), "_%s_%s_%s_%s", \
((IS_INST) ? "i" : "c"), \
(CLASS_NAME), \
((CAT_NAME)? (CAT_NAME) : ""), \
(SEL_NAME)); \
for (temp = (BUF); *temp; temp++) \
if (*temp == ':') *temp = '_'; \
} while (0)
#endif
#ifndef OBJC_FLAG_OBJC_ABI
#define OBJC_FLAG_OBJC_ABI \
do { if (flag_objc_abi == -1) \
flag_objc_abi = 1; \
} while (0)
#endif
#ifndef OBJC_FLAG_ZEROCOST_EXCEPTIONS
#define OBJC_FLAG_ZEROCOST_EXCEPTIONS
#endif
#ifndef OBJC_WARN_OBJC2_FEATURES
#define OBJC_WARN_OBJC2_FEATURES(MESSAGE)
#endif
#ifndef OBJC2_ABI_DISPATCH
#define OBJC2_ABI_DISPATCH 0
#endif
#ifndef OBJC_FORWARDING_STACK_OFFSET
#define OBJC_FORWARDING_STACK_OFFSET 0
#endif
#ifndef OBJC_FORWARDING_MIN_OFFSET
#define OBJC_FORWARDING_MIN_OFFSET 0
#endif
#include "obstack.h"
static struct obstack util_obstack;
char *util_firstobj;
#define OBJC_VERSION (flag_next_runtime ? 7 : 8)
#define PROTOCOL_VERSION 2
#define NEW_PROTOCOL_VERSION 3
#define OBJC_ENCODE_INLINE_DEFS 0
#define OBJC_ENCODE_DONT_INLINE_DEFS 1
static void init_objc (void);
static void finish_objc (void);
static tree objc_build_constructor (tree, tree);
static tree build_objc_method_call (int, tree, tree, tree, tree, tree);
static tree get_proto_encoding (tree);
static tree lookup_interface (tree);
static tree objc_add_static_instance (tree, tree);
static bool objc_is_object_id (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, tree);
#else
static void objc_start_function (tree, tree, tree, struct c_arg_info *, tree);
#endif
static tree start_protocol (tree, tree, tree);
static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
static tree objc_add_method (tree, tree, int, int);
static tree add_instance_variable (tree, int, tree);
static tree build_ivar_reference (tree);
static tree is_ivar (tree, tree);
static bool objc_lookup_protocol (tree, tree, tree, bool);
static tree lookup_method_static (tree, tree, int, bool, bool);
static void objc_lookup_property_ivar (tree, tree);
static void build_objc_exception_stuff (void);
static void build_next_objc_exception_stuff (void);
static tree nested_ivar_lookup (tree, tree);
static void objc_set_global_decl_fields (tree);
static int objc_is_strong_p (tree);
static int objc_is_gcable_p (tree);
#ifndef OBJCPLUS
static bool objc_derived_from_p (tree, tree);
#define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
#endif
static char *objc_build_property_setter_name (tree, bool);
static int match_proto_with_proto (tree, tree, int);
static char * objc_build_property_ivar_name (tree);
static void objc_xref_basetypes (tree, tree);
static void objc_warn_direct_ivar_access (tree, tree);
static void build_v2_class_template (void);
static void build_v2_protocol_template (void);
static void build_message_ref_template (void);
static tree build_v2_build_objc_method_call (int, tree, tree, tree, tree, tree, bool);
static void build_v2_protocol_reference (tree);
static void init_UOBJC2_EHTYPE_decls (void);
static void create_ivar_offset_name (char *, tree, tree);
static void build_v2_category_template (void);
static tree build_protocollist_reference_decl (tree);
static void objc_add_to_category_list_chain (tree);
static void objc_add_to_nonlazy_category_list_chain (tree);
static void hash_name_enter (hash *, tree);
static tree hash_name_lookup (hash *, tree);
static void build_objc_fast_enum_state_type (void);
static void build_class_template (void);
static void build_selector_template (void);
static void build_category_template (void);
static void build_super_template (void);
static tree build_protocol_initializer (tree, tree, tree, tree, tree, bool, tree, tree, tree);
static tree get_class_ivars (tree, bool);
static tree generate_protocol_list (tree);
static void build_protocol_reference (tree);
#ifdef OBJCPLUS
static void objc_generate_cxx_cdtors (void);
#endif
static size_t hash_func (tree);
static void hash_add_attr (hash, tree);
static hash hash_ident_lookup (hash *, tree);
static hash hash_ident_enter (hash *, tree);
static void objc_decl_method_attributes (tree*, tree, int);
static const char *synth_id_with_class_suffix (const char *, tree);
static void objc_warn_on_class_attributes (tree, bool);
static void objc_attach_attrs_to_type (tree, tree);
static tree objc_create_named_tmp_var (tree, const char *);
static tree objc2_eh_runtime_type (tree);
static tree objc_v2_ivar_reference (tree);
static tree receiver_is_class_object (tree, int, int);
static tree lookup_nested_method (tree, tree);
static bool objc_is_object_id (tree);
static bool objc_is_class_id (tree);
hash *nst_method_hash_list = 0;
hash *cls_method_hash_list = 0;
hash *class_nst_method_hash_list = 0;
hash *class_cls_method_hash_list = 0;
hash *class_names_hash_list = 0;
hash *meth_var_names_hash_list = 0;
hash *meth_var_types_hash_list = 0;
hash *prop_names_attr_hash_list = 0;
hash *sel_ref_hash_list = 0;
hash *cls_name_hash_list = 0;
hash *als_name_hash_list = 0;
hash *ivar_offset_hash_list = 0;
static void hash_class_name_enter (hash *, tree, tree);
static hash hash_class_name_lookup (hash *, tree);
static hash hash_lookup (hash *, tree);
static tree lookup_method (tree, tree);
static inline tree lookup_category (tree, tree);
enum string_section
{
class_names,
meth_var_names,
meth_var_types,
prop_names_attr
};
static tree add_objc_string (tree, enum string_section);
static tree build_objc_string_ident (enum string_section);
static void build_selector_table_decl (void);
static tree lookup_protocol (tree);
static tree lookup_and_install_protocols (tree, bool);
static int conforms_to_protocol (tree, tree);
static void encode_type_qualifiers (tree);
static void encode_type (tree, int, int);
static void encode_field_decl (tree, int, int);
#ifdef OBJCPLUS
static void really_start_method (tree, tree);
#else
static void really_start_method (tree, struct c_arg_info *);
#endif
static int comp_proto_with_proto (tree, tree, int);
static tree get_arg_type_list (tree, tree, int, int);
static tree objc_decay_parm_type (tree);
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
static void warn_with_method (const char *, int, 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);
static tree start_var_decl (tree, const char *);
static void finish_var_decl (tree, tree);
static tree create_field_decl (tree, const char *);
static void add_class_reference (tree);
static void build_protocol_template (void);
static tree encode_method_prototype (tree);
static void generate_classref_translation_entry (tree);
static void handle_class_ref (tree);
static void generate_struct_by_value_array (void)
ATTRIBUTE_NORETURN;
static void mark_referenced_methods (void);
static void generate_objc_image_info (void);
#define OBJECT_TYPEDEF_NAME "id"
#define CLASS_TYPEDEF_NAME "Class"
#define TAG_OBJECT "objc_object"
#define TAG_CLASS "objc_class"
#define TAG_SUPER "objc_super"
#define TAG_SELECTOR "objc_selector"
#define UTAG_CLASS "_objc_class"
#define UTAG_IVAR "_objc_ivar"
#define UTAG_IVAR_LIST "_objc_ivar_list"
#define UTAG_METHOD "_objc_method"
#define UTAG_METHOD_LIST "_objc_method_list"
#define UTAG_CATEGORY "_objc_category"
#define UTAG_MODULE "_objc_module"
#define UTAG_SYMTAB "_objc_symtab"
#define UTAG_SUPER "_objc_super"
#define UTAG_SELECTOR "_objc_selector"
#define UTAG_PROTOCOL "_objc_protocol"
#define UTAG_METHOD_PROTOTYPE "_objc_method_prototype"
#define UTAG_METHOD_PROTOTYPE_LIST "_objc__method_prototype_list"
#define UTAG_CLASS_EXT "_objc_class_ext"
#define UTAG_PROPERTY_LIST "_prop_list_t"
#define UTAG_PROTOCOL_EXT "_objc_protocol_extension"
#define STRING_OBJECT_GLOBAL_FORMAT "_%sClassReference"
#define STRING_V2_OBJECT_GLOBAL_FORMAT "OBJC_CLASS_$_%s"
#define STRING_V2_IVAR_OFFSET_PREFIX "OBJC_IVAR_$_"
#define STRING_V2_OBJC_EHTYPE_PREFIX "OBJC_EHTYPE_$"
#define PROTOCOL_OBJECT_CLASS_NAME "Protocol"
#define UTAG_V2_CLASS "_class_t"
#define UTAG_V2_CLASS_RO "_class_ro_t"
#define UTAG_V2_PROTOCOL_LIST "_protocol_list_t"
#define UTAG_V2_PROTOCOL "_protocol_t"
static const char *TAG_GETCLASS;
static const char *TAG_GETMETACLASS;
static const char *TAG_MSGSEND;
static const char *TAG_MSGSENDSUPER;
static const char *TAG_MSGSEND_STRET;
static const char *TAG_MSGSENDSUPER_STRET;
static const char *default_constant_string_class_name;
static const struct gcc_debug_hooks *save_default_debug_hooks;
static int donot_warn_missing_methods;
#define CLS_FACTORY 0x0001L
#define CLS_META 0x0002L
#define IS_CLS_META(X) ((X & 0x0003) == CLS_META)
#define CLS_HAS_CXX_STRUCTORS 0x2000L
#define OBJC2_CLS_HAS_CXX_STRUCTORS 0x0004L
#define CLS_HIDDEN 0x20000
#define OBJC2_CLS_HIDDEN 0x10
#define OBJC_MODIFIER_STATIC 0x00000001
#define OBJC_MODIFIER_FINAL 0x00000002
#define OBJC_MODIFIER_PUBLIC 0x00000004
#define OBJC_MODIFIER_PRIVATE 0x00000008
#define OBJC_MODIFIER_PROTECTED 0x00000010
#define OBJC_MODIFIER_NATIVE 0x00000020
#define OBJC_MODIFIER_SYNCHRONIZED 0x00000040
#define OBJC_MODIFIER_ABSTRACT 0x00000080
#define OBJC_MODIFIER_VOLATILE 0x00000100
#define OBJC_MODIFIER_TRANSIENT 0x00000200
#define OBJC_MODIFIER_NONE_SPECIFIED 0x80000000
#define TAG_MSGSEND_NONNIL "objc_msgSendNonNil"
#define TAG_MSGSEND_NONNIL_STRET "objc_msgSendNonNil_stret"
#define TAG_EXCEPTIONEXTRACT "objc_exception_extract"
#define TAG_EXCEPTIONTRYENTER "objc_exception_try_enter"
#define TAG_EXCEPTIONTRYEXIT "objc_exception_try_exit"
#define TAG_EXCEPTIONMATCH "objc_exception_match"
#define TAG_EXCEPTIONTHROW "objc_exception_throw"
#define TAG_SYNCENTER "objc_sync_enter"
#define TAG_SYNCEXIT "objc_sync_exit"
#define TAG_SETJMP "_setjmp"
#define UTAG_EXCDATA "_objc_exception_data"
#define TAG_MSGSEND_FPRET "objc_msgSend_fpret"
#define TAG_ASSIGN_WEAK "objc_assign_weak"
#define TAG_READ_WEAK "objc_read_weak"
#define TAG_MEMMOVE_COLLECTABLE "objc_memmove_collectable"
#define TAG_ASSIGNIVAR "objc_assign_ivar"
#define TAG_ASSIGNGLOBAL "objc_assign_global"
#define TAG_ASSIGNSTRONGCAST "objc_assign_strongCast"
#define TAG_MSGSEND_FAST "objc_msgSend_Fast"
#define TAG_ASSIGNIVAR_FAST "objc_assign_ivar_Fast"
#ifndef OFFS_MSGSEND_FAST
#define OFFS_MSGSEND_FAST 0
#endif
#ifndef OFFS_ASSIGNIVAR_FAST
#define OFFS_ASSIGNIVAR_FAST 0
#endif
#define TAG_CXX_CONSTRUCT ".cxx_construct"
#define TAG_CXX_DESTRUCT ".cxx_destruct"
#define TAG_EXECCLASS "__objc_exec_class"
#define TAG_GNUINIT "__objc_gnu_init"
#define OBJC_LOOKUP_CLASS 1
#define OBJC_LOOKUP_NO_SUPER 2
tree objc_global_trees[OCTI_MAX];
static void handle_impent (struct imp_entry *);
struct imp_entry *imp_list = 0;
int imp_count = 0;
int cat_count = 0;
enum tree_code objc_inherit_code;
int objc_public_flag;
static int objc_method_optional_flag = 0;
static bool property_readonly;
static tree property_getter;
static tree property_setter;
static bool property_readwrite;
static bool property_assign;
static bool property_retain;
static bool property_copy;
static bool property_atomic;
static int method_slot = 0;
static int objc_collecting_ivars = 0;
#define BUFSIZE 1024
static char *errbuf;
extern enum debug_info_type write_symbols;
extern const char *dump_base_name;
int lvalue_or_else (tree*, enum lvalue_use);
static int flag_typed_selectors;
struct string_descriptor GTY(())
{
tree literal;
tree constructor;
};
static GTY((param_is (struct string_descriptor))) htab_t string_htab;
FILE *gen_declaration_file;
static int generating_property_type_encoding = 0;
static int generating_instance_variables = 0;
static void
generate_struct_by_value_array (void)
{
tree type;
tree field_decl, field_decl_chain;
int i, j;
int aggregate_in_mem[32];
int found = 0;
for (i = 1; i < 32; i++)
{
char buffer[5];
type = start_struct (RECORD_TYPE, NULL_TREE);
strcpy (buffer, "c1");
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_field_decl (char_type_node,
buffer);
chainon (field_decl_chain, field_decl);
}
finish_struct (type, field_decl_chain, NULL_TREE);
aggregate_in_mem[i] = aggregate_value_p (type, 0);
if (!aggregate_in_mem[i])
found = 1;
}
if (found)
{
for (i = 31; i >= 0; i--)
if (!aggregate_in_mem[i])
break;
printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i);
printf ("static int struct_forward_array[] = {\n 0");
for (j = 1; j <= i; j++)
printf (", %d", aggregate_in_mem[j]);
printf ("\n};\n");
}
exit (0);
}
bool
objc_init (void)
{
#ifdef OBJC_TARGET_FLAG_OBJC_ABI
OBJC_TARGET_FLAG_OBJC_ABI;
#endif
OBJC_FLAG_OBJC_ABI;
if (flag_objc_abi == 2)
OBJC_WARN_OBJC2_FEATURES ("the new objc abi");
#ifdef OBJCPLUS
if (cxx_init () == false)
#else
if (c_objc_common_init () == false)
#endif
return false;
#ifndef USE_MAPPED_LOCATION
input_line = 0;
#endif
if (flag_gen_declaration)
{
register char * const dumpname = concat (dump_base_name, ".decl", NULL);
gen_declaration_file = fopen (dumpname, "w");
if (gen_declaration_file == 0)
fatal_error ("can't open %s: %m", dumpname);
free (dumpname);
}
if (flag_next_runtime)
{
TAG_GETCLASS = "objc_getClass";
TAG_GETMETACLASS = "objc_getMetaClass";
TAG_MSGSEND = "objc_msgSend";
TAG_MSGSENDSUPER = flag_objc_abi==2 ? "objc_msgSendSuper2"
: "objc_msgSendSuper";
TAG_MSGSEND_STRET = "objc_msgSend_stret";
TAG_MSGSENDSUPER_STRET = flag_objc_abi==2 ? "objc_msgSendSuper2_stret"
: "objc_msgSendSuper_stret";
default_constant_string_class_name = "NSConstantString";
if (flag_objc_gc_only)
flag_objc_gc = 1;
#ifdef OBJCPLUS
if (flag_objc_call_cxx_cdtors == -1)
flag_objc_call_cxx_cdtors = 1;
#endif
}
else
{
TAG_GETCLASS = "objc_get_class";
TAG_GETMETACLASS = "objc_get_meta_class";
TAG_MSGSEND = "objc_msg_lookup";
TAG_MSGSENDSUPER = "objc_msg_lookup_super";
default_constant_string_class_name = "NXConstantString";
flag_typed_selectors = 1;
}
init_objc ();
#ifdef OBJCPLUS
if (flag_objc_zerocost_exceptions)
{
lang_eh_runtime_type = objc2_eh_runtime_type;
init_UOBJC2_EHTYPE_decls ();
}
#endif
if (print_struct_values)
generate_struct_by_value_array ();
return true;
}
void
objc_finish_file (void)
{
mark_referenced_methods ();
#ifdef OBJCPLUS
{
location_t locus = input_location;
emit_instantiate_pending_templates (&locus);
}
#endif
if (!flag_syntax_only && !pch_file)
finish_objc ();
if (gen_declaration_file)
fclose (gen_declaration_file);
#ifdef OBJCPLUS
cp_finish_file ();
#endif
}
static tree
lookup_method_in_protocol_list (tree rproto_list, tree sel_name,
int is_class)
{
tree rproto, p;
tree fnd = 0;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
fnd = lookup_method (is_class
? PROTOCOL_CLS_METHODS (p)
: PROTOCOL_NST_METHODS (p), sel_name);
if (!fnd)
fnd = lookup_method (is_class
? PROTOCOL_OPTIONAL_CLS_METHODS (p)
: PROTOCOL_OPTIONAL_NST_METHODS (p), sel_name);
if (!fnd && PROTOCOL_LIST (p))
fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
sel_name, is_class);
}
else
{
;
}
if (fnd)
return fnd;
}
return 0;
}
static tree
lookup_protocol_in_reflist (tree rproto_list, tree lproto)
{
tree rproto, p;
if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
{
tree fnd = 0;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
if (lproto == p)
fnd = lproto;
else if (PROTOCOL_LIST (p))
fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
}
if (fnd)
return fnd;
}
}
else
{
;
}
return 0;
}
void
objc_start_class_interface (tree class, tree super_class, tree protos, tree attributes)
{
objc_interface_context
= objc_ivar_context
= start_class (CLASS_INTERFACE_TYPE, class, super_class, protos);
CLASS_ATTRIBUTES (objc_interface_context) = attributes;
objc_warn_on_class_attributes (objc_interface_context, false);
objc_public_flag = 0;
}
void
objc_start_category_interface (tree class, tree categ, tree protos)
{
if (categ == NULL_TREE)
{
tree class_category_is_assoc_with = lookup_interface (class);
if (class_category_is_assoc_with)
{
tree cat = lookup_category (class_category_is_assoc_with, NULL_TREE);
if (cat)
{
objc_interface_context = cat;
objc_ivar_chain = continue_class (objc_interface_context);
return;
}
}
}
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, tree prefix_attrs)
{
objc_interface_context
= start_protocol (name, protos, prefix_attrs);
objc_method_optional_flag = 0;
}
void
objc_continue_interface (void)
{
gcc_assert (TREE_CODE (objc_interface_context) == CLASS_INTERFACE_TYPE);
save_default_debug_hooks = debug_hooks;
debug_hooks = &do_nothing_debug_hooks;
objc_ivar_chain
= continue_class (objc_interface_context);
debug_hooks = save_default_debug_hooks;
}
void
objc_finish_interface (void)
{
finish_class (objc_interface_context);
if (TREE_CODE (objc_interface_context) == CLASS_INTERFACE_TYPE)
{
tree record = CLASS_STATIC_TEMPLATE (objc_interface_context);
gcc_assert (record);
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
rest_of_type_compilation (record, 1);
if (flag_debug_only_used_symbols && TYPE_STUB_DECL (record))
TREE_USED (TYPE_STUB_DECL (record)) = 1;
#ifdef OBJCPLUS
pop_lang_context ();
#endif
}
objc_interface_context = NULL_TREE;
objc_method_optional_flag = 0;
}
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_opt (int optional)
{
objc_method_optional_flag = optional;
if (!objc_interface_context
|| TREE_CODE (objc_interface_context) != PROTOCOL_INTERFACE_TYPE)
{
error ("@optional/@required is allowed in @protocol context only.");
objc_method_optional_flag = 0;
}
}
void
objc_set_property_attr (int attr, tree ident)
{
static char string[BUFSIZE];
switch (attr)
{
case 0:
property_readonly = false;
property_setter = property_getter = NULL_TREE;
property_readwrite = property_assign = property_retain = property_copy = false;
property_atomic = true;
break;
case 1:
property_readonly = true;
break;
case 2:
if (property_getter != NULL_TREE)
error("getter attribute can be specified only once");
property_getter = ident;
break;
case 3:
if (property_setter != NULL_TREE)
error("setter attribute can be specified only once");
sprintf (string, "%s:", IDENTIFIER_POINTER (ident));
property_setter = get_identifier (string);;
break;
case 9:
property_readwrite = true;
break;
case 10:
property_assign = true;
break;
case 11:
property_retain = true;
break;
case 12:
property_copy = true;
break;
case 13:
property_atomic = false;
break;
default:
break;
}
}
static bool
managed_objc_object_pointer (tree type)
{
return type && type != error_mark_node && POINTER_TYPE_P (type)
&& (objc_is_object_id (TREE_TYPE (type)) || TYPED_OBJECT (TREE_TYPE (type))
|| TREE_CODE (type) == BLOCK_POINTER_TYPE);
}
static void
objc_add_property_setter_method (tree class, tree x)
{
tree type = TREE_TYPE (x);
tree key_name, arg_type, arg_name;
tree setter_decl, selector;
tree ret_type = build_tree_list (NULL_TREE, void_type_node);
tree mth;
key_name = get_identifier (objc_build_property_setter_name (
PROPERTY_NAME (x), false));
arg_type = build_tree_list (NULL_TREE, type);
arg_name = get_identifier ("_value");
selector = objc_build_keyword_decl (key_name, arg_type, arg_name, NULL_TREE);
DECL_SOURCE_LOCATION (selector) = DECL_SOURCE_LOCATION (x);
setter_decl = build_method_decl (INSTANCE_METHOD_DECL,
ret_type, selector,
build_tree_list (NULL_TREE, NULL_TREE),
false);
TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x);
mth = lookup_method (CLASS_NST_METHODS (class),
METHOD_SEL_NAME (setter_decl));
if (PROPERTY_IVAR_NAME (x)
&& (mth = lookup_method (CLASS_NST_METHODS (class),
METHOD_SEL_NAME (setter_decl))))
{
error ("user accessor %<%c%s%> not allowed for property %qs",
'-', IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)),
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
}
else
objc_add_method (class, setter_decl, false, OPTIONAL_PROPERTY (x));
METHOD_PROPERTY_CONTEXT (setter_decl) = x;
return;
}
void
objc_add_property_variable (tree decl)
{
tree property_decl;
tree x;
OBJC_WARN_OBJC2_FEATURES ("property");
if (DECL_INITIAL (decl) || TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
{
error ("bad property declaration");
return;
}
if (objc_implementation_context)
{
error ("property cannot be declared inside @implemenation context");
return;
}
else if (!objc_interface_context)
{
fatal_error ("property declaration not in @interface or @implementation context");
return;
}
property_decl = make_node (PROPERTY_DECL);
TREE_TYPE (property_decl) = TREE_TYPE (decl);
PROPERTY_NAME (property_decl) = DECL_NAME (decl);
PROPERTY_GETTER_NAME (property_decl) = property_getter;
PROPERTY_SETTER_NAME (property_decl) = property_setter;
PROPERTY_READONLY (property_decl) = property_readonly
? boolean_true_node
: boolean_false_node;
PROPERTY_IVAR_NAME (property_decl) = NULL_TREE;
PROPERTY_DYNAMIC (property_decl) = NULL_TREE;
TREE_DEPRECATED (property_decl) = TREE_DEPRECATED (decl);
OPTIONAL_PROPERTY (property_decl) = objc_method_optional_flag;
if ((property_assign && property_retain)
|| (property_assign && property_copy)
|| (property_retain && property_copy))
{
error ("assign, retain and copy are mutually exclusive");
property_copy = property_retain = false;
}
else if (!property_assign && !property_retain && !property_copy
&& !property_readonly
&& managed_objc_object_pointer (TREE_TYPE (property_decl)))
{
if (!flag_objc_gc_only && warn_property_assign_default)
warning (0, "no 'assign', 'retain', or 'copy' attribute is specified - 'assign' is assumed");
}
if (!property_readonly)
property_readwrite = true;
else if (property_readwrite)
{
error ("readonly and readwrite are mutually exclusive");
property_readwrite = false;
PROPERTY_READONLY (property_decl) = boolean_false_node;
}
PROPERTY_COPY (property_decl) = property_copy
? boolean_true_node
: boolean_false_node;
PROPERTY_RETAIN (property_decl) = property_retain
? boolean_true_node
: boolean_false_node;
PROPERTY_READWRITE (property_decl) = property_readwrite
? boolean_true_node
: boolean_false_node;
ATOMIC_PROPERTY (property_decl) = property_atomic;
if (objc_interface_context)
{
if (PROPERTY_ASSIGN (property_decl))
{
if (managed_objc_object_pointer (TREE_TYPE (property_decl)))
{
if (!flag_objc_gc)
{
if (!property_assign)
{
if (TREE_CODE (TREE_TYPE (property_decl)) == BLOCK_POINTER_TYPE)
error ("assign attribute (default) not appropriate for non-gc object property %qs",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)));
else
warning (0, "assign attribute (default) not appropriate for non-gc object property %qs",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)));
}
}
else if (!property_assign)
{
tree ltyp = TREE_TYPE (property_decl);
if (flag_objc_gc_only
&& TREE_CODE (ltyp) == BLOCK_POINTER_TYPE
&& !property_copy)
warning (0, "'copy' attribute must be specified for the block"
" property %qs when -fobjc-gc-only is specified",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)));
do
ltyp = TREE_TYPE (ltyp);
while (POINTER_TYPE_P (ltyp));
if (TYPE_HAS_OBJC_INFO (ltyp)
&& !objc_is_object_id (ltyp) && !objc_is_class_id (ltyp)
&& TREE_CODE (TYPE_OBJC_INTERFACE (ltyp)) != IDENTIFIER_NODE)
{
tree id_NSCopying = get_identifier ("NSCopying");
tree lproto = lookup_protocol (id_NSCopying);
objc_declare_protocols (tree_cons (NULL_TREE, id_NSCopying, NULL_TREE), NULL_TREE);
if (lproto && TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE
&& objc_lookup_protocol (lproto , TYPE_OBJC_INTERFACE (ltyp), ltyp, false))
warning (0, "%s'assign' attribute on property %qs which implements 'NSCopying' "
"protocol not appropriate with %s",
!property_assign ? "default " : "",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)),
flag_objc_gc_only ? "-fobjc-gc-only" : "-fobjc-gc");
}
}
}
}
for (x = CLASS_PROPERTY_DECL (objc_interface_context); x; x = TREE_CHAIN (x))
{
if (PROPERTY_NAME (x) == DECL_NAME (decl))
{
error ("%Jduplicate property declaration %qD", decl, decl);
return;
}
}
if (ANONYMOUS_CATEGORY (objc_interface_context))
{
tree class = lookup_interface (CLASS_NAME (objc_interface_context));
if (class)
{
for (x = CLASS_PROPERTY_DECL (class); x; x = TREE_CHAIN (x))
if (PROPERTY_NAME (x) == DECL_NAME (decl))
break;
if (x)
{
if (PROPERTY_READONLY (x) == boolean_true_node
&& PROPERTY_READWRITE (property_decl) == boolean_true_node)
{
if ((PROPERTY_ASSIGN (x) != PROPERTY_ASSIGN (property_decl))
|| (PROPERTY_RETAIN (x) != PROPERTY_RETAIN (property_decl))
|| (PROPERTY_COPY (x) != PROPERTY_COPY (property_decl))
|| (IS_ATOMIC (x) != IS_ATOMIC (property_decl)))
warning (0, "property %qs attribute in %qs class continuation"
" does not match class %qs property",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)),
IDENTIFIER_POINTER (CLASS_NAME (class)),
IDENTIFIER_POINTER (CLASS_NAME (class)));
PROPERTY_READONLY (x) = boolean_false_node;
PROPERTY_READWRITE (x) = boolean_true_node;
PROPERTY_COPY (x) = PROPERTY_COPY (property_decl);
PROPERTY_RETAIN (x) = PROPERTY_RETAIN (property_decl);
PROPERTY_SETTER_NAME (x) = PROPERTY_SETTER_NAME (property_decl);
}
else
error ("use class continuation to override %<readonly%> property %qs with %<readwrite%> in class %qs",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)),
IDENTIFIER_POINTER (CLASS_NAME (class)));
if (!comptypes (TREE_TYPE (x), TREE_TYPE (property_decl)))
{
warning (0, "property %qs type in %qs class continuation does not match class %qs property",
IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)),
IDENTIFIER_POINTER (CLASS_NAME (class)),
IDENTIFIER_POINTER (CLASS_NAME (class)));
TREE_TYPE (property_decl) = TREE_TYPE (x);
}
}
else
{
tree save_objc_interface_context = objc_interface_context;
objc_interface_context = class;
objc_add_property_variable (decl);
objc_interface_context = save_objc_interface_context;
}
}
else
error ("anonymous category %qs has no primary class", IDENTIFIER_POINTER (CLASS_NAME (class)));
}
TREE_CHAIN (property_decl) = CLASS_PROPERTY_DECL (objc_interface_context);
CLASS_PROPERTY_DECL (objc_interface_context) = property_decl;
}
}
static tree
lookup_property_in_list (tree chain, tree property)
{
tree x;
for (x = CLASS_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x))
if (PROPERTY_NAME (x) == property)
return x;
return NULL_TREE;
}
static tree
lookup_property_in_protocol_list (tree rproto_list, tree property)
{
tree rproto, x;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
tree p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
if ((x = lookup_property_in_list (p, property)))
return x;
if (PROTOCOL_LIST (p)
&& (x = lookup_property_in_protocol_list (PROTOCOL_LIST (p), property)))
return x;
}
else
{
;
}
}
return NULL_TREE;
}
static tree
lookup_property (tree interface_type, tree property)
{
tree inter = interface_type;
while (inter)
{
tree x, category;
if (TREE_CODE (inter) != CLASS_INTERFACE_TYPE)
return NULL_TREE;
if ((x = lookup_property_in_list (inter, property)))
return x;
category = inter;
while ((category = CLASS_CATEGORY_LIST (category)))
if ((x = lookup_property_in_list (category, property)))
return x;
if (CLASS_PROTOCOL_LIST (inter)
&& (x = lookup_property_in_protocol_list (
CLASS_PROTOCOL_LIST (inter), property)))
return x;
inter = lookup_interface (CLASS_SUPER_NAME (inter));
}
return inter;
}
static tree
objc_get_inner_exp (tree t)
{
while (TREE_CODE (t) == COMPOUND_EXPR
|| TREE_CODE (t) == MODIFY_EXPR
|| TREE_CODE (t) == NOP_EXPR
|| TREE_CODE (t) == CONVERT_EXPR
|| TREE_CODE (t) == COMPONENT_REF)
t = TREE_OPERAND (t, 0);
return t;
}
static tree
objc_property_access_info (tree receiver, tree component, tree rtype,
bool check_prop_cond,
tree *interface_type, tree *prop, bool *receiver_is_class)
{
*prop = NULL_TREE;
*interface_type = NULL_TREE;
*receiver_is_class = false;
if (objc_is_id (rtype))
{
tree rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
: NULL_TREE);
if (rprotos)
*prop = lookup_property_in_protocol_list (rprotos, component);
else
{
tree t = objc_get_inner_exp (receiver);
int super = (t == UOBJC_SUPER_decl);
tree class_tree = receiver_is_class_object (receiver, (t == self_decl), super);
if (class_tree)
{
tree class_type = lookup_interface (class_tree);
if (class_type)
{
*interface_type = class_type;
*receiver_is_class = true;
}
}
else if (super)
{
if (implementation_template && CLASS_SUPER_NAME (implementation_template))
{
*interface_type = lookup_interface (CLASS_SUPER_NAME (implementation_template));
if (*interface_type)
*prop = lookup_property (*interface_type, component);
}
}
}
}
else
{
tree basetype = TYPE_MAIN_VARIANT (rtype);
if (basetype != NULL_TREE && TREE_CODE (basetype) == POINTER_TYPE)
basetype = TREE_TYPE (basetype);
else if (check_prop_cond)
{
if (!flag_objc_gc && warn_direct_ivar_access && flag_objc_abi != 2)
objc_warn_direct_ivar_access (basetype, component);
return NULL_TREE;
}
while (basetype != NULL_TREE
&& TREE_CODE (basetype) == RECORD_TYPE && OBJC_TYPE_NAME (basetype)
&& TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)))
basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype));
if (basetype != NULL_TREE && TYPED_OBJECT (basetype))
{
*interface_type = TYPE_OBJC_INTERFACE (basetype);
if (check_prop_cond &&
(!*interface_type ||
(TREE_CODE (*interface_type) != CLASS_INTERFACE_TYPE
&& TREE_CODE (*interface_type) != PROTOCOL_INTERFACE_TYPE
&& TREE_CODE (*interface_type) != CATEGORY_INTERFACE_TYPE)))
{
if (TREE_CODE (receiver) == OBJC_PROPERTY_REFERENCE_EXPR)
{
error ("accessing unknown %qs component of a property",
IDENTIFIER_POINTER (component));
return error_mark_node;
}
return NULL_TREE;
}
*prop = lookup_property (*interface_type, component);
if (!*prop && TYPE_OBJC_PROTOCOL_LIST (basetype))
*prop = lookup_property_in_protocol_list (TYPE_OBJC_PROTOCOL_LIST (basetype),
component);
}
}
return receiver;
}
tree
objc_build_property_reference_expr (tree receiver, tree component)
{
tree interface_type;
tree rtype;
tree prop, prop_type, res;
bool receiver_is_class;
tree ivar;
if (component == error_mark_node || component == NULL_TREE
|| TREE_CODE (component) != IDENTIFIER_NODE)
return NULL_TREE;
if (receiver == error_mark_node || receiver == NULL_TREE
|| (rtype = TREE_TYPE (receiver)) == NULL_TREE)
return NULL_TREE;
res = objc_property_access_info (receiver, component, rtype, true,
&interface_type, &prop, &receiver_is_class);
if (res == NULL_TREE || res == error_mark_node)
return res;
prop_type = ivar = NULL_TREE;
if (interface_type && !receiver_is_class)
{
ivar = nested_ivar_lookup (interface_type, component);
if (ivar)
prop_type = TREE_TYPE (ivar);
else
{
tree getter = lookup_method_static (interface_type, component, 0, false, false);
if (getter)
prop_type = TREE_VALUE (TREE_TYPE (getter));
}
}
else if (interface_type)
{
tree getter = lookup_method_static (interface_type, component, 1, false, true);
prop_type = getter ? TREE_VALUE (TREE_TYPE (getter)) : integer_type_node;
}
else if (!prop && objc_is_id (rtype))
{
tree rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
: NULL_TREE);
if (rprotos) {
tree getter = lookup_method_in_protocol_list (rprotos, component, 0);
prop_type = getter ? TREE_VALUE (TREE_TYPE (getter)) : integer_type_node;
}
}
if (prop)
{
tree property_type = TREE_TYPE (prop);
bool comparison_result = false;
if (prop_type)
{
#ifdef OBJCPLUS
if (TREE_CODE (property_type) == REFERENCE_TYPE
|| TREE_CODE (prop_type) == REFERENCE_TYPE)
{
if (TREE_CODE (property_type) == REFERENCE_TYPE)
property_type = TREE_TYPE (property_type);
if (TREE_CODE (prop_type) == REFERENCE_TYPE)
prop_type = TREE_TYPE (prop_type);
comparison_result =
!objcp_reference_related_p (prop_type, property_type);
}
else
#endif
comparison_result = comptypes (prop_type, property_type) != 1;
}
if (!ivar && prop_type && comparison_result
&& !objc_compare_types(property_type, prop_type, -6, NULL_TREE, NULL))
warning (0, "type of accessor does not match the type of property %qs",
IDENTIFIER_POINTER (PROPERTY_NAME (prop)));
else
prop_type = property_type;
}
if (prop_type)
{
tree prop_expr = build3 (OBJC_PROPERTY_REFERENCE_EXPR, prop_type,
receiver, component, UOBJC_SUPER_decl);
TREE_SIDE_EFFECTS (prop_expr) = 1;
return prop_expr;
}
else
return NULL_TREE;
}
static tree
objc_build_getter_call (tree receiver, tree component)
{
tree interface_type;
tree x;
bool receiver_is_class;
tree getter = error_mark_node;
tree rtype = TREE_TYPE (receiver);
(void)objc_property_access_info (receiver, component, rtype, false,
&interface_type, &x, &receiver_is_class);
if (x)
{
gcc_assert (PROPERTY_NAME (x));
if (PROPERTY_GETTER_NAME (x))
getter = objc_finish_message_expr (receiver, PROPERTY_GETTER_NAME (x), NULL_TREE);
else
getter = objc_finish_message_expr (receiver, PROPERTY_NAME (x), NULL_TREE);
}
else if (interface_type)
{
getter = lookup_method_static (interface_type, component, receiver_is_class,
false, receiver_is_class);
if (getter)
#ifdef OBJCPLUS
getter = objc_build_message_expr (
build_tree_list (receiver,
build_tree_list (component, NULL_TREE)));
#else
getter = objc_build_message_expr (build_tree_list (receiver, component));
#endif
else
{
error ("accessing unknown %qs %s method",
IDENTIFIER_POINTER (component), receiver_is_class ? "class" : "getter");
getter = receiver;
}
}
else if (objc_is_id (rtype))
{
tree rprotos = (TYPE_HAS_OBJC_INFO (TREE_TYPE (rtype))
? TYPE_OBJC_PROTOCOL_LIST (TREE_TYPE (rtype))
: NULL_TREE);
if (rprotos) {
getter = lookup_method_in_protocol_list (rprotos, component, 0);
if (getter)
#ifdef OBJCPLUS
getter = objc_build_message_expr (
build_tree_list (receiver, build_tree_list (component, NULL_TREE)));
#else
getter = objc_build_message_expr (build_tree_list (receiver, component));
#endif
else
{
error ("accessing unknown %qs getter method",
IDENTIFIER_POINTER (component));
getter = receiver;
}
}
}
return getter;
}
static const char *
objc_resolve_build_property_setter_name (tree receiver, tree property_ident)
{
tree rtype, basetype,x,class=NULL_TREE;
bool receiver_is_class = false;
gcc_assert (receiver && TREE_TYPE (receiver));
rtype = TREE_TYPE (receiver);
if (objc_is_id (rtype))
{
tree t = objc_get_inner_exp (receiver);
int super = (t == UOBJC_SUPER_decl);
tree class_tree = receiver_is_class_object (receiver, (t == self_decl), super);
if (class_tree)
{
class = lookup_interface (class_tree);
receiver_is_class = true;
}
else if (super)
{
if (implementation_template
&& CLASS_SUPER_NAME (implementation_template))
class = lookup_interface (CLASS_SUPER_NAME (implementation_template));
}
}
else
{
basetype = TYPE_MAIN_VARIANT (rtype);
gcc_assert (basetype && TREE_CODE (basetype) == POINTER_TYPE);
basetype = TREE_TYPE (basetype);
while (basetype != NULL_TREE
&& TREE_CODE (basetype) == RECORD_TYPE && OBJC_TYPE_NAME (basetype)
&& TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)))
basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype));
gcc_assert (basetype && TYPED_OBJECT (basetype));
class = TYPE_OBJC_INTERFACE (basetype);
}
gcc_assert (class);
if (receiver_is_class)
{
char *setter_name = objc_build_property_setter_name (property_ident, true);
if (!lookup_method_static (class, get_identifier (setter_name), 1, false, true))
error ("accessing unknown %qs class method", setter_name);
return setter_name;
}
x = lookup_property (class, property_ident);
return (x && PROPERTY_SETTER_NAME (x)) ? IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x))
: objc_build_property_setter_name
(property_ident, true);
}
static tree
objc_setter_func_call (tree receiver, tree property_ident, tree rhs)
{
tree setter_argument = build_tree_list (NULL_TREE, rhs);
const char *setter_name = objc_resolve_build_property_setter_name (receiver, property_ident);
tree setter;
in_objc_property_setter_name_context = true;
setter = objc_finish_message_expr (receiver,
get_identifier (setter_name),
setter_argument);
in_objc_property_setter_name_context = false;
if (TREE_CODE (setter) == CALL_EXPR && TREE_TYPE (setter) != void_type_node)
warning (0, "type of setter %qs must be 'void' instead of '%T'",
setter_name, TREE_TYPE (setter) );
return setter;
}
static tree
objc_build_compound_setter_call (tree receiver, tree prop_ident, tree rhs)
{
tree temp, bind, comma_exp;
if (TREE_SIDE_EFFECTS (rhs))
{
temp = objc_create_named_tmp_var (TREE_TYPE (rhs), "prop");
bind = build3 (BIND_EXPR, void_type_node, temp, NULL, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
comma_exp = build_modify_expr (temp, NOP_EXPR, rhs);
comma_exp = build_compound_expr (comma_exp,
objc_setter_func_call (receiver, prop_ident, temp));
temp = default_conversion (temp);
}
else
{
comma_exp = objc_setter_func_call (receiver, prop_ident, rhs);
rhs = default_conversion (rhs);
temp = save_expr (rhs);
if (TREE_CODE (temp) == VAR_DECL)
DECL_SEEN_IN_BIND_EXPR_P (temp) = 1;
}
TREE_NO_WARNING (temp) = 1;
comma_exp = build_compound_expr (comma_exp, temp);
TREE_NO_WARNING (comma_exp) = 1;
return comma_exp;
}
bool
objc_property_reference_expr (tree expr)
{
return (expr
&& TREE_CODE (expr) == OBJC_PROPERTY_REFERENCE_EXPR);
}
tree
objc_build_setter_call (tree lhs, tree rhs)
{
if (objc_property_reference_expr (lhs))
return objc_build_compound_setter_call (TREE_OPERAND (lhs, 0),
TREE_OPERAND (lhs, 1), rhs);
return NULL_TREE;
}
static tree
build_v2_property_template (void)
{
tree prop_record;
tree field_decl, field_decl_chain;
prop_record = start_struct (RECORD_TYPE, get_identifier ("_prop_t"));
field_decl = create_field_decl (string_type_node, "name");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "attribute");
chainon (field_decl_chain, field_decl);
finish_struct (prop_record, field_decl_chain, NULL_TREE);
return prop_record;
}
static tree
build_v2_property_list_template (tree list_type, int size)
{
tree property_list_t_record;
tree field_decl, field_decl_chain;
property_list_t_record = start_struct (RECORD_TYPE, NULL_TREE);
field_decl = create_field_decl (integer_type_node, "entsize");
field_decl_chain = field_decl;
field_decl = create_field_decl (integer_type_node, "prop_count");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_array_type
(list_type,
build_index_type
(build_int_cst (NULL_TREE, size - 1))),
"prop_list");
chainon (field_decl_chain, field_decl);
finish_struct (property_list_t_record, field_decl_chain, NULL_TREE);
return property_list_t_record;
}
static tree
objc_v2_encode_prop_attr (tree property)
{
const char *string;
tree type = TREE_TYPE (property);
obstack_1grow (&util_obstack, 'T');
generating_property_type_encoding = 1;
encode_type (type, obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
generating_property_type_encoding = 0;
if (PROPERTY_READONLY (property) == boolean_true_node)
obstack_grow (&util_obstack, ",R", 2);
if (PROPERTY_COPY (property) == boolean_true_node)
obstack_grow (&util_obstack, ",C", 2);
if (PROPERTY_RETAIN (property) == boolean_true_node)
obstack_grow (&util_obstack, ",&", 2);
if (PROPERTY_DYNAMIC (property) == boolean_true_node)
obstack_grow (&util_obstack, ",D", 2);
if (!IS_ATOMIC (property))
obstack_grow (&util_obstack, ",N", 2);
if (PROPERTY_GETTER_NAME (property))
{
obstack_grow (&util_obstack, ",G", 2);
string = IDENTIFIER_POINTER (PROPERTY_GETTER_NAME (property));
obstack_grow (&util_obstack, string, strlen (string));
}
if (PROPERTY_SETTER_NAME (property))
{
obstack_grow (&util_obstack, ",S", 2);
string = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (property));
obstack_grow (&util_obstack, string, strlen (string));
}
if (PROPERTY_IVAR_NAME (property))
{
obstack_grow (&util_obstack, ",V", 2);
if (PROPERTY_IVAR_NAME (property) != boolean_true_node)
string = IDENTIFIER_POINTER (PROPERTY_IVAR_NAME (property));
else
string = objc_build_property_ivar_name (property);
obstack_grow (&util_obstack, string, strlen (string));
}
if (flag_objc_gc)
{
int g = objc_is_gcable_type (type);
if (g == -1)
obstack_grow (&util_obstack, ",W", 2);
else if (g == 1)
obstack_grow (&util_obstack, ",P", 2);
}
obstack_1grow (&util_obstack, 0);
string = obstack_finish (&util_obstack);
obstack_free (&util_obstack, util_firstobj);
return get_identifier (string);
}
static tree
build_v2_property_table_initializer (tree type)
{
tree x;
tree initlist = NULL_TREE;
generating_instance_variables = 1;
for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
{
tree name_ident = PROPERTY_NAME (x);
tree elemlist = tree_cons (NULL_TREE,
add_objc_string (name_ident, prop_names_attr),
NULL_TREE);
tree attribute = objc_v2_encode_prop_attr (x);
elemlist = tree_cons (NULL_TREE, add_objc_string (attribute, prop_names_attr),
elemlist);
initlist = tree_cons (NULL_TREE,
objc_build_constructor (type, nreverse (elemlist)),
initlist);
}
generating_instance_variables = 0;
return objc_build_constructor (build_array_type (type, 0),
nreverse (initlist));
}
static tree
generate_v2_property_list (tree type, const char *name, int size, tree list)
{
tree decl, initlist;
int init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_property_template));
const char * ref_name = synth_id_with_class_suffix (name, objc_implementation_context);
decl = start_var_decl (type, ref_name);
set_user_assembler_name (decl, ref_name);
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, init_val));
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
initlist = tree_cons (NULL_TREE, list, initlist);
finish_var_decl (decl,
objc_build_constructor (TREE_TYPE (decl),
nreverse (initlist)));
return decl;
}
#define OUTPUT_LAYOUT_BYTE(BYTE) \
do { \
obstack_1grow (&util_obstack, BYTE); \
if (print_objc_ivar_layout) \
{ \
if (first_nibble) \
{ \
first_nibble = false; \
printf ("\n%s for class \'%s\': ", \
strong_ivar_layout ? \
"strong ivar layout" :\
"weak ivar layout", \
IDENTIFIER_POINTER (CLASS_NAME (implementation_template))); \
} \
if (!(BYTE & 0xf0)) \
printf ("0x0%x%s", BYTE, BYTE != 0 ? ", " : ""); \
else \
printf ("0x%x%s", BYTE, BYTE != 0 ? ", " : ""); \
if (++num_nibbles > 20 \
|| BYTE == 0) \
{ printf("\n"); num_nibbles=1; }\
} \
} while (0);
#define GC_IVAR_BUFSIZE_INCR 256
struct GC_IVAR {
unsigned int ivar_bytepos;
unsigned int ivar_size;
};
static struct GC_IVAR *ivar;
static struct GC_IVAR *sk_ivar;
struct skip_scan
{
unsigned int skip;
unsigned int scan;
};
static struct skip_scan *skip_scan;
static int max_layout_buf_size = 0;
static void
adjust_max_layout_buf_size (int index)
{
if (index < max_layout_buf_size-1)
return;
max_layout_buf_size += GC_IVAR_BUFSIZE_INCR;
ivar = (struct GC_IVAR*)xrealloc (ivar, sizeof(struct GC_IVAR) * max_layout_buf_size);
sk_ivar = (struct GC_IVAR*)xrealloc (sk_ivar, sizeof(struct GC_IVAR) * max_layout_buf_size);
skip_scan = (struct skip_scan*)xrealloc (skip_scan, sizeof(struct GC_IVAR) * max_layout_buf_size);
return;
}
static int
ivar_bytepos_cmp (const void *a, const void *b)
{
HOST_WIDE_INT sa = ((struct GC_IVAR *)a)->ivar_bytepos;
HOST_WIDE_INT sb = ((struct GC_IVAR *)b)->ivar_bytepos;
if (sa < sb)
return -1;
if (sa > sb)
return 1;
return 0;
}
static HOST_WIDE_INT
total_type_elements (tree type)
{
HOST_WIDE_INT el_count = 1;
do {
tree telts = array_type_nelts (type);
if (telts && host_integerp (telts, 1))
el_count *= (tree_low_cst (telts, 1) + 1);
else
{
el_count = 0;
break;
}
type = TREE_TYPE (type);
} while (TREE_CODE (type) == ARRAY_TYPE);
return el_count;
}
static int
block_pointer_strong_value (tree type)
{
gcc_assert (type && TREE_CODE (type) == BLOCK_POINTER_TYPE);
type = TREE_TYPE (TREE_TYPE (type));
while (POINTER_TYPE_P (type))
type = TREE_TYPE (type);
return (objc_is_strong_p (type) >= 0 ? 1 : -1);
}
static void
objc_build_aggregate_ivar_layout (tree aggr_type, tree field_decl,
unsigned int base_byte_pos,
bool strong_ivar_layout,
int *index,
int *sk_index,
bool *hasUnion)
{
int iIndex = *index;
int iSkIndex = *sk_index;
unsigned int max_gc_union_ivar_size = 0;
tree max_field_decl = NULL_TREE;
unsigned int max_sk_union_ivar_size = 0;
tree max_sk_field_decl = NULL_TREE;
bool is_union = (aggr_type && TREE_CODE (aggr_type) == UNION_TYPE);
unsigned int base = 0;
if (!field_decl)
return;
if (is_union)
base = base_byte_pos + int_byte_position (field_decl);
do {
tree type;
int strong;
if (!DECL_NAME (field_decl) || DECL_BIT_FIELD_TYPE (field_decl))
{
tree last_field_decl = field_decl;
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
if (field_decl)
continue;
field_decl = last_field_decl;
}
#ifdef OBJCPLUS
if (TREE_CODE (field_decl) != FIELD_DECL || TREE_STATIC (field_decl))
{
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
continue;
}
#endif
type = TREE_TYPE (field_decl);
if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
{
if (TREE_CODE (type) == UNION_TYPE)
*hasUnion = true;
objc_build_aggregate_ivar_layout (type, TYPE_FIELDS (type),
base_byte_pos + int_byte_position (field_decl),
strong_ivar_layout,
&iIndex,
&iSkIndex,
hasUnion);
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
continue;
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
tree inner = TREE_TYPE (type);
while (TREE_CODE (inner) == ARRAY_TYPE)
inner = TREE_TYPE (inner);
if (TREE_CODE (inner) == UNION_TYPE)
error ("Layout for array of unions not supported");
else if (TREE_CODE (inner) == RECORD_TYPE)
{
HOST_WIDE_INT el_count = total_type_elements (type);
HOST_WIDE_INT el_ix;
int old_iIndex = iIndex, old_iSkIndex = iSkIndex;
int first_iIndex, first_iSkIndex;
objc_build_aggregate_ivar_layout (inner, TYPE_FIELDS (inner),
base_byte_pos + int_byte_position (field_decl),
strong_ivar_layout,
&iIndex,
&iSkIndex,
hasUnion);
first_iIndex = iIndex;
first_iSkIndex = iSkIndex;
for (el_ix = 1; el_ix < el_count; el_ix++)
{
int i;
int size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (inner));
for (i = old_iIndex+1; i <= first_iIndex; ++i)
{
adjust_max_layout_buf_size (iIndex);
ivar[++iIndex].ivar_bytepos = ivar[i].ivar_bytepos + size*el_ix;
ivar[iIndex].ivar_size = ivar[i].ivar_size;
}
for (i = old_iSkIndex+1; i <= first_iSkIndex; ++i)
{
adjust_max_layout_buf_size (iSkIndex);
sk_ivar[++iSkIndex].ivar_bytepos = sk_ivar[i].ivar_bytepos + size*el_ix;
sk_ivar[iSkIndex].ivar_size = sk_ivar[i].ivar_size;
}
}
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
continue;
}
}
strong = 0;
do
{
strong = objc_is_strong_p (type);
if (strong)
break;
if (TREE_CODE (type) == FUNCTION_TYPE
|| TREE_CODE (type) == METHOD_TYPE)
break;
if (objc_is_object_ptr (type))
{
strong = ((objc_is_strong_p (TREE_TYPE (type)) >= 0) ? 1 : -1);
break;
}
if (TREE_CODE (type) == BLOCK_POINTER_TYPE)
{
strong = block_pointer_strong_value (type);
break;
}
type = TREE_TYPE (type);
}
while (!strong && type);
if ((strong_ivar_layout && strong == 1)
|| (!strong_ivar_layout && strong == -1))
{
if (is_union)
{
unsigned int u_ivar_size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl))
/ GET_MODE_SIZE (Pmode);
if (u_ivar_size > max_gc_union_ivar_size)
{
max_gc_union_ivar_size = u_ivar_size;
max_field_decl = field_decl;
}
}
else
{
adjust_max_layout_buf_size (iIndex);
ivar[++iIndex].ivar_bytepos = base_byte_pos + int_byte_position (field_decl);
ivar[iIndex].ivar_size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl))
/ GET_MODE_SIZE (Pmode);
}
}
else if ((strong_ivar_layout && strong <= 0)
|| (!strong_ivar_layout && strong != -1))
{
if (is_union)
{
unsigned int u_ivar_size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl));
if (u_ivar_size > max_sk_union_ivar_size)
{
max_sk_union_ivar_size = u_ivar_size;
max_sk_field_decl = field_decl;
}
}
else
{
adjust_max_layout_buf_size (iSkIndex);
sk_ivar[++iSkIndex].ivar_bytepos = base_byte_pos + int_byte_position (field_decl);
sk_ivar[iSkIndex].ivar_size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl));
}
}
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
}
while (field_decl);
if (max_field_decl)
{
adjust_max_layout_buf_size (iIndex);
ivar[++iIndex].ivar_bytepos = base_byte_pos + int_byte_position (max_field_decl);
ivar[iIndex].ivar_size = max_gc_union_ivar_size;
}
if (max_sk_field_decl)
{
adjust_max_layout_buf_size (iSkIndex);
sk_ivar[++iSkIndex].ivar_bytepos = base_byte_pos + int_byte_position (max_sk_field_decl);
sk_ivar[iSkIndex].ivar_size = max_sk_union_ivar_size;
}
*index = iIndex;
*sk_index = iSkIndex;
}
static tree
objc_build_ivar_layout (bool strong_ivar_layout)
{
tree field_decl;
unsigned int words_to_skip, words_to_scan;
int i;
int iIndex = -1;
int iSkIndex = -1;
int iSkip_scan;
unsigned char byte;
const char *string;
bool hasUnion, bytesSkipped;
int num_nibbles = 0;
bool first_nibble = true;
tree retval;
if (!flag_objc_gc || !implementation_template)
return NULL_TREE;
field_decl = CLASS_IVARS (implementation_template);
if (CLASS_SUPER_NAME (implementation_template))
{
tree interface = implementation_template;
field_decl = copy_list (field_decl);
while (CLASS_SUPER_NAME (interface))
{
interface = lookup_interface (CLASS_SUPER_NAME (interface));
field_decl = chainon (copy_list (CLASS_IVARS (interface)),
field_decl);
}
}
if (!field_decl)
return NULL_TREE;
hasUnion = false;
if (max_layout_buf_size == 0)
{
gcc_assert (ivar == NULL && sk_ivar == NULL && skip_scan == NULL);
adjust_max_layout_buf_size (GC_IVAR_BUFSIZE_INCR);
}
objc_build_aggregate_ivar_layout (NULL_TREE, field_decl, 0, strong_ivar_layout,
&iIndex, &iSkIndex, &hasUnion);
if (iIndex == -1)
{
return NULL_TREE;
}
if (hasUnion && iIndex > 0)
qsort (ivar, iIndex+1, sizeof (struct GC_IVAR), ivar_bytepos_cmp);
if (hasUnion && iSkIndex > 0)
qsort (sk_ivar, iSkIndex+1, sizeof (struct GC_IVAR), ivar_bytepos_cmp);
iSkip_scan = -1;
if (ivar[0].ivar_bytepos == 0)
{
words_to_skip = 0;
words_to_scan = ivar[0].ivar_size;
}
else
{
words_to_skip = ivar[0].ivar_bytepos / GET_MODE_SIZE (Pmode);
words_to_scan = ivar[0].ivar_size;
}
for (i=1; i <= iIndex; i++)
{
unsigned int tail_prev_gc_obj = ivar[i-1].ivar_bytepos +
ivar[i-1].ivar_size * GET_MODE_SIZE (Pmode);
if (ivar[i].ivar_bytepos == tail_prev_gc_obj)
{
words_to_scan += ivar[i].ivar_size;
}
else
{
if (tail_prev_gc_obj > ivar[i].ivar_bytepos)
continue;
adjust_max_layout_buf_size (iSkip_scan);
skip_scan[++iSkip_scan].skip = words_to_skip;
skip_scan[iSkip_scan].scan = words_to_scan;
skip_scan[++iSkip_scan].skip = (ivar[i].ivar_bytepos - tail_prev_gc_obj)
/ GET_MODE_SIZE (Pmode);
skip_scan[iSkip_scan].scan = 0;
words_to_skip = 0;
words_to_scan = ivar[i].ivar_size;
}
}
if (words_to_scan > 0)
{
adjust_max_layout_buf_size (iSkip_scan);
skip_scan[++iSkip_scan].skip = words_to_skip;
skip_scan[iSkip_scan].scan = words_to_scan;
}
bytesSkipped = false;
if (iSkIndex >= 0)
{
int lastByteSkipped = sk_ivar[iSkIndex].ivar_bytepos + sk_ivar[iSkIndex].ivar_size;
int lastByteScanned = ivar[iIndex].ivar_bytepos + ivar[iIndex].ivar_size * GET_MODE_SIZE (Pmode);
bytesSkipped = (lastByteSkipped > lastByteScanned);
if (bytesSkipped)
{
unsigned int totalWord = (lastByteSkipped + (GET_MODE_SIZE (Pmode) -1))
/ GET_MODE_SIZE (Pmode);
adjust_max_layout_buf_size (iSkip_scan);
skip_scan[++iSkip_scan].skip = totalWord - (lastByteScanned / GET_MODE_SIZE (Pmode));
skip_scan[iSkip_scan].scan = 0;
}
}
for (i = 0; i <= iSkip_scan; i++)
{
if (i < iSkip_scan)
{
if (skip_scan[i].skip && skip_scan[i].scan == 0
&& skip_scan[i+1].skip == 0 && skip_scan[i+1].scan)
{
int j;
skip_scan[i].scan = skip_scan[i+1].scan;
for (j = i+1; j < iSkip_scan; j++)
skip_scan[j] = skip_scan[j+1];
--iSkip_scan;
}
}
}
for (i = 0; i <= iSkip_scan; i++)
{
unsigned int skip_small = skip_scan[i].skip % 0xf;
unsigned int scan_small = skip_scan[i].scan % 0xf;
unsigned int skip_big = skip_scan[i].skip / 0xf;
unsigned int scan_big = skip_scan[i].scan / 0xf;
unsigned int ix;
if (skip_small > 0 || skip_big > 0)
bytesSkipped = true;
for (ix = 0; ix < skip_big; ix++)
OUTPUT_LAYOUT_BYTE (0xf0);
if (skip_small)
{
byte = skip_small << 4;
if (scan_big > 0)
{
byte |= 0xf;
--scan_big;
}
else if (scan_small)
{
byte |= scan_small;
scan_small = 0;
}
OUTPUT_LAYOUT_BYTE (byte);
}
for (ix = 0; ix < scan_big; ix++)
OUTPUT_LAYOUT_BYTE (0x0f);
if (scan_small)
{
byte = scan_small;
OUTPUT_LAYOUT_BYTE (byte);
}
}
OUTPUT_LAYOUT_BYTE (0);
string = obstack_finish (&util_obstack);
retval = (strong_ivar_layout && !bytesSkipped)
? NULL_TREE
: add_objc_string (get_identifier (string), class_names);
obstack_free (&util_obstack, util_firstobj);
return retval;
}
static void build_objc_protocol_extension_template (void)
{
tree field_decl, field_decl_chain;
objc_protocol_extension_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL_EXT));
field_decl = create_field_decl (integer_type_node, "size");
field_decl_chain = field_decl;
field_decl = create_field_decl (objc_method_list_ptr, "optional_instance_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr, "optional_class_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_prop_list_ptr, "instance_properties");
chainon (field_decl_chain, field_decl);
finish_struct (objc_protocol_extension_template, field_decl_chain, NULL_TREE);
}
static tree
generate_objc_protocol_extension (tree proto_interface, tree optional_instance_meth,
tree optional_class_meth, tree instance_prop)
{
int size;
tree decl, initlist, expr;
if (!optional_instance_meth && !optional_class_meth && !instance_prop)
return NULL_TREE;
if (!objc_protocol_extension_template)
build_objc_protocol_extension_template ();
size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_protocol_extension_template));
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
if (!optional_instance_meth)
initlist = tree_cons (NULL_TREE,
convert (objc_method_list_ptr, integer_zero_node),
initlist);
else
{
expr = convert (objc_method_list_ptr, build_unary_op (ADDR_EXPR,
optional_instance_meth, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!optional_class_meth)
initlist = tree_cons (NULL_TREE,
convert (objc_method_list_ptr, integer_zero_node),
initlist);
else
{
expr = convert (objc_method_list_ptr, build_unary_op (ADDR_EXPR,
optional_class_meth, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!instance_prop)
initlist = tree_cons (NULL_TREE,
convert (objc_prop_list_ptr, integer_zero_node),
initlist);
else
{
expr = convert (objc_prop_list_ptr, build_unary_op (ADDR_EXPR,
instance_prop, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
decl = start_var_decl (objc_protocol_extension_template,
synth_id_with_class_suffix
("_OBJC_PROTOCOLEXT", proto_interface));
expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
finish_var_decl (decl, expr);
return decl;
}
static void
build_objc_class_ext_template (void)
{
tree field_decl, field_decl_chain;
objc_class_ext_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_CLASS_EXT));
field_decl = create_field_decl (integer_type_node, "size");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "weak_ivar_layout");
chainon (field_decl_chain, field_decl);
field_decl
= create_field_decl (build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier(UTAG_PROPERTY_LIST))),
"properties");
chainon (field_decl_chain, field_decl);
finish_struct (objc_class_ext_template, field_decl_chain, NULL_TREE);
}
static tree
generate_objc_class_ext (tree property_list)
{
tree decl, initlist, expr;
int size;
tree weak_ivar_layout_tree;
weak_ivar_layout_tree = objc_build_ivar_layout (false);
if (!property_list && !weak_ivar_layout_tree)
return NULL_TREE;
if (!objc_class_ext_template)
build_objc_class_ext_template ();
size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_class_ext_template));
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
initlist = tree_cons (NULL_TREE,
(!weak_ivar_layout_tree ? integer_zero_node
: weak_ivar_layout_tree),
initlist);
if (!property_list)
initlist = tree_cons (NULL_TREE,
convert (objc_prop_list_ptr, integer_zero_node),
initlist);
else
{
expr = convert (objc_prop_list_ptr,
build_unary_op (ADDR_EXPR, property_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
decl = start_var_decl (objc_class_ext_template,
synth_id_with_class_suffix
("_OBJC_CLASSEXT", objc_implementation_context));
expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
finish_var_decl (decl, expr);
return decl;
}
static void
generate_v2_property_tables (tree protocol)
{
tree x, initlist, property_list_template;
int size = 0;
x = protocol ? CLASS_PROPERTY_DECL (protocol)
: IMPL_PROPERTY_DECL (objc_implementation_context);
for (; x; x = TREE_CHAIN (x))
size++;
if (size == 0)
{
UOBJC_V2_PROPERTY_decl = NULL_TREE;
return;
}
if (!objc_v2_property_template)
objc_v2_property_template = build_v2_property_template ();
property_list_template = build_v2_property_list_template (objc_v2_property_template,
size);
initlist
= build_v2_property_table_initializer (objc_v2_property_template);
UOBJC_V2_PROPERTY_decl = generate_v2_property_list (
property_list_template,
protocol ? "l_OBJC_$_PROP_PROTO_LIST"
: "l_OBJC_$_PROP_LIST",
size, initlist);
}
static void
objc_v2_merge_property (void)
{
tree property_decl;
tree interface = NULL_TREE;
tree x, y;
gcc_assert (objc_implementation_context);
interface = lookup_interface (CLASS_NAME (objc_implementation_context));
if (!interface)
return;
if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
interface = lookup_category (interface,
CLASS_SUPER_NAME (objc_implementation_context));
if (!interface)
return;
}
for (x = CLASS_PROPERTY_DECL (interface); x; x = TREE_CHAIN (x))
{
for (y = IMPL_PROPERTY_DECL (objc_implementation_context); y; y = TREE_CHAIN (y))
if (PROPERTY_NAME (x) == PROPERTY_NAME (y))
break;
if (y)
continue;
else
{
property_decl = copy_node (x);
TREE_CHAIN (property_decl) = IMPL_PROPERTY_DECL (objc_implementation_context);
IMPL_PROPERTY_DECL (objc_implementation_context) = property_decl;
continue;
}
property_decl = make_node (PROPERTY_DECL);
TREE_TYPE (property_decl) = TREE_TYPE (x);
PROPERTY_NAME (property_decl) = PROPERTY_NAME (x);
PROPERTY_READONLY (property_decl) = PROPERTY_READONLY (x);
PROPERTY_DYNAMIC (property_decl) = PROPERTY_DYNAMIC (x);
PROPERTY_GETTER_NAME (property_decl) = NULL_TREE;
PROPERTY_SETTER_NAME (property_decl) = NULL_TREE;
PROPERTY_IVAR_NAME (property_decl) = PROPERTY_IVAR_NAME (x);
TREE_CHAIN (property_decl) = IMPL_PROPERTY_DECL (objc_implementation_context);
IMPL_PROPERTY_DECL (objc_implementation_context) = property_decl;
}
return;
}
void
objc_set_method_type (enum tree_code type)
{
objc_inherit_code = (type == PLUS_EXPR
? CLASS_METHOD_DECL
: INSTANCE_METHOD_DECL);
}
static const char * const nonlegacy_dispatched_selectors[] = {
"allocWithZone:",
"alloc",
"class",
"self",
"isKindOfClass:",
"respondsToSelector:",
"isFlipped",
"length",
"objectForKey:",
"count",
"objectAtIndex:",
"isEqualToString:",
"isEqual:",
"retain",
"release",
"autorelease",
"hash",
"addObject:",
"countByEnumeratingWithState:objects:count:",
};
static int
objc_legacy_dispatched_selector_p (tree sel_name)
{
gcc_assert (flag_objc_abi == 2);
gcc_assert (sel_name);
if (flag_objc_legacy_dispatch)
return true;
if (OBJC2_ABI_DISPATCH)
return false;
else {
size_t i, count;
const char *sel_cname = IDENTIFIER_POINTER (sel_name);
count = sizeof(nonlegacy_dispatched_selectors) / sizeof(nonlegacy_dispatched_selectors[0]);
for (i = 0; i < count; i++)
{
if (!strcmp (sel_cname, nonlegacy_dispatched_selectors[i]))
return false;
}
}
return true;
}
tree
objc_build_method_signature (tree rettype, tree selector,
tree optparms, bool ellipsis)
{
return build_method_decl (objc_inherit_code, rettype, selector,
optparms, ellipsis);
}
static bool
objc_type_has_bycopy_attr (tree list)
{
tree p;
for (p = list; p; p = TREE_CHAIN (p))
{
tree v = TREE_VALUE (p);
if (v && TREE_CODE (v) == IDENTIFIER_NODE
&& !strcmp (IDENTIFIER_POINTER (v), "bycopy"))
return true;
}
return false;
}
static void
objc_diagnose_bycopy_type (tree decl)
{
tree type = TREE_TYPE (decl);
if (type && TREE_CODE (type) == TREE_LIST)
{
tree p = TREE_PURPOSE (type);
if (p && TREE_CODE (p) == TREE_LIST)
{
if (objc_type_has_bycopy_attr (p))
{
tree intf;
tree objc_class = objc_is_object_ptr (TREE_VALUE (type));
if (objc_class && objc_is_class_name (objc_class)
&& (intf = lookup_interface (objc_class)))
{
tree proto = lookup_protocol (get_identifier ("NSCoding"));
if (proto && !conforms_to_protocol (intf, proto))
warning (0, "\"bycopy\" specified on instance method type of '%T' that does not conform to \"NSCoding\" protocol",
TREE_VALUE (type));
}
}
}
}
}
void
objc_add_method_declaration (tree decl, tree attributes)
{
if (decl == error_mark_node)
return;
if (!objc_interface_context)
fatal_error ("method declaration not in @interface context");
objc_decl_method_attributes (&decl, attributes, 0);
objc_add_method (objc_interface_context,
decl,
objc_inherit_code == CLASS_METHOD_DECL,
objc_method_optional_flag);
if (objc_interface_context &&
TREE_CODE (objc_interface_context) == CLASS_INTERFACE_TYPE
&& objc_inherit_code == INSTANCE_METHOD_DECL)
objc_diagnose_bycopy_type (decl);
}
static tree fast_lookup_method (int is_class, tree class, tree method_ident);
void
objc_start_method_definition (tree decl, tree attributes)
{
tree class;
if (!objc_implementation_context)
fatal_error ("method definition not in @implementation context");
if (decl != NULL_TREE && METHOD_SEL_NAME (decl) == error_mark_node)
return;
#ifndef OBJCPLUS
c_break_label = c_cont_label = size_zero_node;
#endif
if (attributes)
warning (0, "method attribute may be specified on method declarations only");
if (TREE_TYPE (decl) && TREE_CODE (TREE_TYPE (decl)) == TREE_LIST)
{
tree type = TREE_VALUE (TREE_TYPE (decl));
if (type)
{
if (TREE_CODE (type) == FUNCTION_TYPE)
{
error ("%qs declared as method returning a function",
IDENTIFIER_POINTER (DECL_NAME (decl)));
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
error ("%qs declared as method returning an array",
IDENTIFIER_POINTER (DECL_NAME (decl)));
}
}
}
objc_decl_method_attributes (&decl, attributes, 0);
objc_add_method (objc_implementation_context,
decl,
objc_inherit_code == CLASS_METHOD_DECL, 0);
class = lookup_interface (CLASS_NAME (objc_implementation_context));
if (class)
{
tree decl2 = fast_lookup_method (objc_inherit_code == CLASS_METHOD_DECL,
class,
METHOD_SEL_NAME (decl));
if (decl2)
TREE_DEPRECATED (decl) = TREE_DEPRECATED (decl2);
}
start_method_def (decl);
if (flag_objc_abi == 2 && objc_inherit_code == CLASS_METHOD_DECL)
{
tree id = DECL_NAME (decl);
if (id && TREE_CODE (id) == IDENTIFIER_NODE)
{
const char *name = IDENTIFIER_POINTER (id);
if (!strcmp (name, "load"))
CLASS_OR_CATEGORY_HAS_LOAD_IMPL (objc_implementation_context) = decl;
}
}
}
void
objc_add_instance_variable (tree decl)
{
(void) add_instance_variable (objc_ivar_context,
objc_public_flag,
decl);
}
int
objc_is_reserved_word (tree ident)
{
unsigned char code = C_RID_CODE (ident);
return (OBJC_IS_AT_KEYWORD (code)
#ifdef OBJCPLUS
|| code == RID_AT_PACKAGE
|| code == RID_CLASS || code == RID_PUBLIC
|| code == RID_PROTECTED || code == RID_PRIVATE
|| code == RID_TRY || code == RID_THROW || code == RID_CATCH
#endif
);
}
static bool
objc_is_object_id (tree type)
{
return OBJC_TYPE_NAME (type) == objc_object_id;
}
static bool
objc_is_class_id (tree type)
{
return OBJC_TYPE_NAME (type) == objc_class_id;
}
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;
int cv = 0;
struct lang_type ** pTypeLang = 0;
if (flag_objc_abi == 2 && TREE_CODE (class) == CLASS_INTERFACE_TYPE
&& fields != NULL_TREE)
{
tree last = fields;
while (TREE_CHAIN (last))
last = TREE_CHAIN (last);
gcc_assert (TREE_CODE (last) == FIELD_DECL);
if (DECL_INITIAL (last) && DECL_INITIAL (last) != error_mark_node)
{
tree bf_zero = build_decl (FIELD_DECL, NULL_TREE, char_type_node);
DECL_INITIAL (bf_zero) = size_zero_node;
SET_DECL_C_BIT_FIELD (bf_zero);
DECL_NONADDRESSABLE_P (bf_zero) = 1;
TREE_CHAIN (last) = bf_zero;
}
}
if (super)
{
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);
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;
if (write_symbols == DWARF2_DEBUG)
DECL_IGNORED_P (base) = 1;
#ifdef OBJCPLUS
DECL_FIELD_IS_BASE (base) = 1;
if (fields)
TREE_NO_WARNING (fields) = 1;
#endif
TREE_CHAIN (base) = fields;
fields = base;
}
#if 0
removed:
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)));
#endif
INIT_TYPE_OBJC_INFO (s);
TYPE_OBJC_INTERFACE (s) = class;
for (t = TYPE_MAIN_VARIANT (s); t && TYPE_LANG_SPECIFIC (t) && TYPE_OBJC_INFO (t);
t = TYPE_NEXT_VARIANT (t))
++cv;
if (cv > 1) {
int i=0;
pTypeLang = (struct lang_type **) xmalloc (sizeof (struct lang_type *) * cv);
for (t = TYPE_MAIN_VARIANT (s); t && TYPE_LANG_SPECIFIC (t) && TYPE_OBJC_INFO (t);
t = TYPE_NEXT_VARIANT (t))
pTypeLang[i++] = TYPE_LANG_SPECIFIC(t);
}
s = finish_struct (s, fields, NULL_TREE);
if (cv > 1) {
int i=0;
for (t = TYPE_MAIN_VARIANT (s); t && TYPE_LANG_SPECIFIC (t) && TYPE_OBJC_INFO (t);
t = TYPE_NEXT_VARIANT (t))
TYPE_LANG_SPECIFIC(t) = pTypeLang[i++];
free (pTypeLang);
}
objc_xref_basetypes (s, super);
CLASS_STATIC_TEMPLATE (class) = s;
return s;
}
static tree
objc_build_volatilized_type (tree type)
{
tree t;
for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
{
if (!TYPE_VOLATILE (t)
|| (TYPE_READONLY (t) != TYPE_READONLY (type))
|| (TYPE_RESTRICT (t) != TYPE_RESTRICT (type)))
continue;
if (POINTER_TYPE_P (t)
&& (TREE_TYPE (t) != TREE_TYPE (type)))
continue;
if (!lookup_attribute ("objc_volatilized", TYPE_ATTRIBUTES (t)))
continue;
return t;
}
t = build_variant_type_copy (type);
TYPE_VOLATILE (t) = 1;
TYPE_ATTRIBUTES (t) = merge_attributes (TYPE_ATTRIBUTES (type),
tree_cons (get_identifier ("objc_volatilized"),
NULL_TREE,
NULL_TREE));
if (TREE_CODE (t) == ARRAY_TYPE)
TREE_TYPE (t) = objc_build_volatilized_type (TREE_TYPE (t));
return t;
}
void
objc_volatilize_decl (tree decl)
{
if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl)
&& (TREE_CODE (decl) == VAR_DECL
|| TREE_CODE (decl) == PARM_DECL))
{
tree t = TREE_TYPE (decl);
t = objc_build_volatilized_type (t);
TREE_TYPE (decl) = t;
TREE_THIS_VOLATILE (decl) = 1;
TREE_SIDE_EFFECTS (decl) = 1;
DECL_REGISTER (decl) = 0;
#ifndef OBJCPLUS
C_DECL_REGISTER (decl) = 0;
#endif
}
}
void
objc_volatilize_component_ref (tree cref, tree member_type)
{
tree object, type;
if (TYPE_VOLATILE (member_type))
return;
object = TREE_OPERAND (cref, 0);
if (TREE_THIS_VOLATILE (object))
{
type = TREE_TYPE (object);
if (lookup_attribute ("objc_volatilized", TYPE_ATTRIBUTES (type)))
{
member_type = objc_build_volatilized_type (member_type);
TREE_TYPE (cref) = member_type;
TREE_THIS_VOLATILE (cref) = 1;
TREE_SIDE_EFFECTS (cref) = 1;
}
}
return;
}
static bool
objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
{
bool class_type = (cls != NULL_TREE);
while (cls)
{
tree c;
for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
{
if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
return true;
}
cls = lookup_interface (CLASS_SUPER_NAME (cls));
}
if (TYPE_HAS_OBJC_INFO (typ))
{
if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
return true;
}
if (warn)
{
strcpy (errbuf, class_type ? "class \'" : "type \'");
gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
strcat (errbuf, "\' does not ");
strcat (errbuf, class_type ? "implement" : "conform to");
strcat (errbuf, " the \'");
strcat (errbuf, IDENTIFIER_POINTER (PROTOCOL_NAME (proto)));
strcat (errbuf, "\' protocol");
warning (0, "%s", errbuf);
}
return false;
}
static bool
objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
{
tree p;
bool have_lproto = false;
while (lcls)
{
for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p))
{
have_lproto = true;
if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
return warn;
}
lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
}
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;
}
}
return have_lproto || (rcls != NULL_TREE);
}
tree
objc_common_type (tree type1, tree type2)
{
tree inner1 = TREE_TYPE (type1), inner2 = TREE_TYPE (type2);
while (POINTER_TYPE_P (inner1))
{
inner1 = TREE_TYPE (inner1);
inner2 = TREE_TYPE (inner2);
}
if (DERIVED_FROM_P (inner1, inner2))
return type1;
else if (DERIVED_FROM_P (inner2, inner1))
return type2;
if (objc_is_class_id (inner1) && objc_is_class_id (inner2))
return objc_class_type;
return objc_object_type;
}
static bool
objc_nsobject_attribute_type (tree type)
{
return POINTER_TYPE_P (type) &&
lookup_attribute ("NSObject", TYPE_ATTRIBUTES (type));
}
bool
objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee, const char *message)
{
tree lcls, rcls, lproto, rproto;
bool pointers_compatible;
tree orig_ltyp, orig_rtyp;
if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp))
return false;
orig_ltyp = ltyp;
orig_rtyp = rtyp;
do
{
ltyp = TREE_TYPE (ltyp);
rtyp = TREE_TYPE (rtyp);
}
while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
if (TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE)
{
if (!comptypes (TREE_TYPE (ltyp), TREE_TYPE (rtyp))
&& !objc_compare_types (TREE_TYPE (ltyp), TREE_TYPE (rtyp),
argno, callee, message))
return false;
for (ltyp = TYPE_ARG_TYPES (ltyp), rtyp = TYPE_ARG_TYPES (rtyp);
ltyp && rtyp; ltyp = TREE_CHAIN (ltyp), rtyp = TREE_CHAIN (rtyp))
{
if (!comptypes (TREE_VALUE (rtyp), TREE_VALUE (ltyp))
&& !objc_compare_types (TREE_VALUE (rtyp), TREE_VALUE (ltyp),
argno, callee, message))
return false;
}
return (ltyp == rtyp);
}
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 (objc_nsobject_attribute_type (orig_ltyp) && objc_is_object_id (rtyp))
? true : false;
}
if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp)
&& !TYPE_HAS_OBJC_INFO (rtyp)) {
return (objc_nsobject_attribute_type (orig_rtyp) && objc_is_object_id (ltyp))
? true : false;
}
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 (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE)
lcls = lookup_interface (lcls);
if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE)
rcls = lookup_interface (rcls);
if ((argno != -6 && !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 (pointers_compatible && (!lproto || !rproto))
return true;
if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp))
pointers_compatible = false;
else
{
if (!pointers_compatible)
pointers_compatible
= ((argno != -6 && objc_is_object_id (ltyp)) || objc_is_object_id (rtyp));
if (!pointers_compatible && argno != -6)
pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
if (!pointers_compatible && argno <= -3 && argno != -5)
pointers_compatible = DERIVED_FROM_P (rtyp, ltyp);
}
if (pointers_compatible)
{
pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp,
(argno > -3 || argno == -5));
if (!pointers_compatible && argno == -3)
pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp,
false);
}
if (!pointers_compatible)
{
switch (argno)
{
case -6:
case -5:
case -4:
return false;
case -3:
warning (0, "%s of distinct Objective-C types %qT and %qT lacks a cast",
message, orig_rtyp, orig_ltyp);
break;
case -2:
warning (0, "incompatible Objective-C types initializing %qT, expected %qT",
orig_rtyp, orig_ltyp);
break;
case -1:
warning (0, "incompatible Objective-C types assigning %qT, expected %qT",
orig_rtyp, orig_ltyp);
break;
case 0:
warning (0, "incompatible Objective-C types returning %qT, expected %qT",
orig_rtyp, orig_ltyp);
break;
default:
warning (0, "incompatible Objective-C types %qT, expected %qT when"
" passing argument %d of %qE from distinct "
"Objective-C type"
, orig_rtyp, orig_ltyp, argno, callee);
break;
}
}
return true;
}
bool
objc_have_common_type (tree ltyp, tree rtyp, int argno, tree callee, const char *message)
{
if (objc_compare_types (ltyp, rtyp, argno, callee, message))
{
do
{
ltyp = TREE_TYPE (ltyp);
rtyp = TREE_TYPE (rtyp);
}
while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
return !(TREE_CODE (ltyp) == FUNCTION_TYPE && TREE_CODE (rtyp) == FUNCTION_TYPE);
}
return false;
}
bool
objc_type_quals_match (tree ltyp, tree rtyp)
{
int lquals = TYPE_QUALS (ltyp), rquals = TYPE_QUALS (rtyp);
if (lookup_attribute ("objc_volatilized", TYPE_ATTRIBUTES (ltyp)))
lquals &= ~TYPE_QUAL_VOLATILE;
if (lookup_attribute ("objc_volatilized", TYPE_ATTRIBUTES (rtyp)))
rquals &= ~TYPE_QUAL_VOLATILE;
return (lquals == rquals);
}
#ifndef OBJCPLUS
static bool
objc_derived_from_p (tree parent, tree child)
{
parent = TYPE_MAIN_VARIANT (parent);
for (child = TYPE_MAIN_VARIANT (child);
TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));)
{
child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
(TYPE_BINFO (child),
0)));
if (child == parent)
return true;
}
return false;
}
#endif
tree
objc_build_component_ref (tree datum, tree component)
{
if (!component)
{
tree base = TYPE_FIELDS (TREE_TYPE (datum));
return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE);
}
#ifdef OBJCPLUS
return finish_class_member_access_expr (datum, component, false);
#else
return build_component_ref (datum, component);
#endif
}
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);
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;
}
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);
}
}
void
objc_check_decl (tree decl)
{
tree type = TREE_TYPE (decl);
while (TREE_CODE (type) == ARRAY_TYPE)
type = TREE_TYPE (type);
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));
}
void
objc_check_global_decl (tree decl)
{
tree id = DECL_NAME (decl);
if (objc_is_class_name (id) && global_bindings_p())
error ("redeclaration of Objective-C class %qs", IDENTIFIER_POINTER (id));
}
tree
objc_non_volatilized_type (tree type)
{
if (lookup_attribute ("objc_volatilized", TYPE_ATTRIBUTES (type)))
type = build_qualified_type (type, (TYPE_QUALS (type) & ~TYPE_QUAL_VOLATILE));
return type;
}
tree
objc_get_protocol_qualified_type (tree interface, tree protocols)
{
tree type = (interface ? objc_is_id (interface) : objc_object_type);
bool is_ptr = (type != NULL_TREE);
if (!is_ptr)
{
type = objc_is_class_name (interface);
if (type)
{
if (TREE_CODE (interface) == IDENTIFIER_NODE)
interface = identifier_global_value (interface);
type = ((interface && TREE_CODE (interface) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (interface))
? DECL_ORIGINAL_TYPE (interface)
: xref_tag (RECORD_TYPE, type));
}
else {
error ("qualified type is not a valid object");
if (protocols)
(void) lookup_and_install_protocols (protocols, false);
return interface;
}
}
if (protocols)
{
type = build_variant_type_copy (type);
if (is_ptr)
{
TREE_TYPE (type) = build_variant_type_copy (TREE_TYPE (type));
TYPE_POINTER_TO (TREE_TYPE (type)) = type;
type = TREE_TYPE (type);
}
DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols (protocols, false);
if (is_ptr)
type = TYPE_POINTER_TO (type);
else
TYPE_OBJC_INTERFACE (type)
= TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type));
}
return type;
}
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));
}
}
static void
objc_handle_protocol_attrs (tree proto)
{
tree chain;
for (chain = PROTOCOL_ATTRIBUTES (proto); chain; chain = TREE_CHAIN (chain))
{
if (is_attribute_p ("deprecated", TREE_PURPOSE (chain)))
warning (0, "protocol %qs is deprecated",
IDENTIFIER_POINTER (CLASS_NAME (proto)));
if (is_attribute_p ("unavailable", TREE_PURPOSE (chain)))
warning (0, "protocol %qs is unavailable",
IDENTIFIER_POINTER (CLASS_NAME (proto)));
}
return;
}
static tree
lookup_and_install_protocols (tree protocols, bool defNeeded)
{
tree proto;
tree return_value = NULL_TREE;
for (proto = protocols; proto; proto = TREE_CHAIN (proto))
{
tree ident = TREE_VALUE (proto);
tree p = lookup_protocol (ident);
if (p)
{
if (defNeeded && !PROTOCOL_DEFINED (p))
warning (0, "no definition of protocol %qs is found",
IDENTIFIER_POINTER (ident));
objc_handle_protocol_attrs (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;
}
static tree
create_field_decl (tree type, const char *name)
{
return build_decl (FIELD_DECL, get_identifier (name), type);
}
static tree
start_var_decl (tree type, const char *name)
{
tree var = build_decl (VAR_DECL, get_identifier (name), type);
objc_set_global_decl_fields (var);
return var;
}
static void
objc_set_global_decl_fields (tree var)
{
TREE_STATIC (var) = 1;
DECL_INITIAL (var) = error_mark_node;
DECL_IGNORED_P (var) = 1;
DECL_ARTIFICIAL (var) = 1;
DECL_CONTEXT (var) = NULL_TREE;
#ifdef OBJCPLUS
DECL_THIS_STATIC (var) = 1;
#endif
DECL_USER_ALIGN (var) = 1;
}
static tree
create_global_decl (tree type, const char *name)
{
tree id = get_identifier (name);
tree var = hash_name_lookup (ivar_offset_hash_list, id);
if (var)
{
DECL_EXTERNAL (var) = 0;
objc_set_global_decl_fields (var);
}
else
{
var = start_var_decl (type, name);
hash_name_enter (ivar_offset_hash_list, var);
}
TREE_PUBLIC (var) = 1;
return var;
}
static tree
create_hidden_decl (tree type, const char *name)
{
tree decl = create_global_decl (type, name);
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
DECL_VISIBILITY_SPECIFIED (decl) = 1;
return decl;
}
static tree
create_extern_decl (tree type, const char *name)
{
tree id = get_identifier (name);
tree var = hash_name_lookup (ivar_offset_hash_list, id);
if (var)
return var;
var = build_decl (VAR_DECL, id, type);
DECL_EXTERNAL (var) = 1;
TREE_PUBLIC (var) = 1;
pushdecl_top_level (var);
rest_of_decl_compilation (var, 0, 0);
hash_name_enter (ivar_offset_hash_list, var);
return var;
}
static void
declare_atomic_property_api (void)
{
tree func_type;
umsg_GetAtomicProperty = lookup_name (get_identifier ("objc_getProperty"));
umsg_SetAtomicProperty = lookup_name (get_identifier ("objc_setProperty"));
umsg_CopyAtomicStruct = lookup_name (get_identifier ("objc_copyStruct"));
if (umsg_GetAtomicProperty && umsg_SetAtomicProperty && umsg_CopyAtomicStruct)
return;
if (!umsg_GetAtomicProperty)
{
func_type
= build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_selector_type,
tree_cons (NULL_TREE, long_integer_type_node,
tree_cons (NULL_TREE, boolean_type_node, NULL_TREE)))));
umsg_GetAtomicProperty = builtin_function (
"objc_getProperty",
func_type, 0, NOT_BUILT_IN, 0, NULL_TREE);
TREE_NOTHROW (umsg_GetAtomicProperty) = 0;
}
if (!umsg_SetAtomicProperty)
{
func_type
= build_function_type (void_type_node,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_selector_type,
tree_cons (NULL_TREE, long_integer_type_node,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, boolean_type_node,
tree_cons (NULL_TREE, boolean_type_node, NULL_TREE)))))));
umsg_SetAtomicProperty = builtin_function (
"objc_setProperty",
func_type, 0, NOT_BUILT_IN, 0, NULL_TREE);
TREE_NOTHROW (umsg_SetAtomicProperty) = 0;
}
if (!umsg_CopyAtomicStruct)
{
func_type
= build_function_type (void_type_node,
tree_cons (NULL_TREE, ptr_type_node,
tree_cons (NULL_TREE, ptr_type_node,
tree_cons (NULL_TREE, long_unsigned_type_node,
tree_cons (NULL_TREE, boolean_type_node,
tree_cons (NULL_TREE, boolean_type_node, NULL_TREE))))));
umsg_CopyAtomicStruct = builtin_function (
"objc_copyStruct",
func_type, 0, NOT_BUILT_IN, 0, NULL_TREE);
TREE_NOTHROW (umsg_CopyAtomicStruct) = 0;
}
return;
}
static bool
aggregate_contains_objc_pointer (tree type)
{
tree field;
field = TYPE_FIELDS (type);
for (; field; field = TREE_CHAIN (field))
{
#ifdef OBJCPLUS
if (TREE_CODE (field) != FIELD_DECL || TREE_STATIC (field))
continue;
#endif
type = TREE_TYPE (field);
if (TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE)
if (aggregate_contains_objc_pointer (type))
return true;
if (objc_is_gcable_type (type) == 1)
return true;
}
return false;
}
static void
finish_var_decl (tree var, tree initializer)
{
finish_decl (var, initializer, NULL_TREE);
mark_decl_referenced (var);
TREE_USED (var) = 1;
}
static tree
setup_string_decl (void)
{
char *name;
size_t length;
const char *prefix = (flag_objc_abi == 2)
? STRING_V2_OBJECT_GLOBAL_FORMAT
: STRING_OBJECT_GLOBAL_FORMAT;
length = strlen (prefix)
+ strlen (constant_string_class_name);
name = xmalloc (length);
sprintf (name, prefix,
constant_string_class_name);
constant_string_global_id = get_identifier (name);
string_class_decl = lookup_name (constant_string_global_id);
if (flag_objc_abi == 2 && !string_class_decl)
string_class_decl = create_extern_decl (objc_v2_class_template, name);
return string_class_decl;
}
static void
synth_module_prologue (void)
{
tree type;
enum debug_info_type save_write_symbols = write_symbols;
const struct gcc_debug_hooks *const save_hooks = debug_hooks;
int save_warn_padded;
write_symbols = NO_DEBUG;
debug_hooks = &do_nothing_debug_hooks;
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
objc_object_id = get_identifier (TAG_OBJECT);
objc_class_id = get_identifier (TAG_CLASS);
objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
objc_object_type = build_pointer_type (objc_object_reference);
objc_class_type = build_pointer_type (objc_class_reference);
objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
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;
type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
type));
if (flag_next_runtime)
objc_selector_type
= build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)));
else
objc_selector_type
= build_pointer_type
(build_qualified_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SELECTOR)),
TYPE_QUAL_CONST));
objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (TAG_SUPER)));
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)));
objc_prop_list_ptr
= build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier ("_prop_list_t")));
if (flag_objc_abi == 2)
{
objc_v2_ivar_list_ptr = build_pointer_type (
xref_tag (RECORD_TYPE,
get_identifier ("_ivar_list_t")));
}
objc_imp_type
= build_pointer_type
(build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_selector_type,
NULL_TREE))));
if (flag_next_runtime)
{
type
= build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_selector_type,
NULL_TREE)));
umsg_decl = builtin_function (TAG_MSGSEND,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_nonnil_decl = builtin_function (TAG_MSGSEND_NONNIL,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_stret_decl = builtin_function (TAG_MSGSEND_STRET,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_nonnil_stret_decl = builtin_function (TAG_MSGSEND_NONNIL_STRET,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
if (flag_objc_abi == 2 && !flag_objc_legacy_dispatch)
{
build_message_ref_template ();
type
= build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_v2_selector_type,
NULL_TREE)));
umsg_fixup_decl = builtin_function ("objc_msgSend_fixup",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_fixup_decl) = 0;
umsg_fpret_fixup_decl = builtin_function ("objc_msgSend_fpret_fixup",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_fpret_fixup_decl) = 0;
umsg_stret_fixup_decl = builtin_function ("objc_msgSend_stret_fixup",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_stret_fixup_decl) = 0;
umsg_id_fixup_decl = builtin_function ("objc_msgSendId_fixup",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_id_fixup_decl) = 0;
umsg_id_stret_fixup_decl = builtin_function ("objc_msgSendId_stret_fixup",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_id_stret_fixup_decl) = 0;
type
= build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_super_type,
tree_cons (NULL_TREE, objc_v2_super_selector_type,
NULL_TREE)));
umsg_id_super2_fixup_decl = builtin_function ("objc_msgSendSuper2_fixup",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_id_super2_fixup_decl) = 0;
umsg_id_super2_stret_fixup_decl = builtin_function ("objc_msgSendSuper2_stret_fixup",
type, 0, NOT_BUILT_IN, 0,
NULL_TREE);
TREE_NOTHROW (umsg_id_super2_stret_fixup_decl) = 0;
}
build_objc_fast_enum_state_type ();
type = build_function_type (void_type_node,
tree_cons (NULL_TREE, objc_object_type, NULL_TREE));
objc_enum_mutation_decl = builtin_function (
"objc_enumerationMutation",
type, 0, NOT_BUILT_IN, 0, NULL_TREE);
TREE_NOTHROW (objc_enum_mutation_decl) = 0;
umsg_fpret_decl = builtin_function (TAG_MSGSEND_FPRET,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_fpret_decl) = 0;
TREE_NOTHROW (umsg_decl) = 0;
TREE_NOTHROW (umsg_nonnil_decl) = 0;
TREE_NOTHROW (umsg_stret_decl) = 0;
TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
if (OFFS_MSGSEND_FAST)
{
umsg_decl = builtin_function (TAG_MSGSEND_FAST,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_decl) = 0;
DECL_ATTRIBUTES (umsg_decl)
= tree_cons (get_identifier ("hard_coded_address"),
build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
NULL_TREE);
}
type
= build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_super_type,
tree_cons (NULL_TREE, objc_selector_type,
NULL_TREE)));
umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
umsg_super_stret_decl = builtin_function (TAG_MSGSENDSUPER_STRET,
type, 0, NOT_BUILT_IN, 0,
NULL_TREE);
TREE_NOTHROW (umsg_super_decl) = 0;
TREE_NOTHROW (umsg_super_stret_decl) = 0;
}
else
{
type
= build_function_type (objc_imp_type,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_selector_type,
OBJC_VOID_AT_END)));
umsg_decl = builtin_function (TAG_MSGSEND,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_decl) = 0;
type
= build_function_type (objc_imp_type,
tree_cons (NULL_TREE, objc_super_type,
tree_cons (NULL_TREE, objc_selector_type,
OBJC_VOID_AT_END)));
umsg_super_decl = builtin_function (TAG_MSGSENDSUPER,
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (umsg_super_decl) = 0;
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);
}
type = build_function_type (objc_object_type,
tree_cons (NULL_TREE,
const_string_type_node,
OBJC_VOID_AT_END));
objc_get_class_decl
= builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
objc_get_meta_class_decl
= builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
if (flag_objc_abi == 2)
build_v2_class_template ();
build_class_template ();
build_super_template ();
if (flag_objc_abi == 2)
{
build_v2_protocol_template ();
build_v2_category_template ();
}
build_protocol_template ();
save_warn_padded = warn_padded;
warn_padded = 0;
build_category_template ();
build_objc_exception_stuff ();
if (flag_next_runtime)
build_next_objc_exception_stuff ();
warn_padded = save_warn_padded;
if (! flag_next_runtime)
build_selector_table_decl ();
if (!constant_string_class_name)
constant_string_class_name = default_constant_string_class_name;
constant_string_id = get_identifier (constant_string_class_name);
objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE));
self_id = get_identifier ("self");
ucmd_id = get_identifier ("_cmd");
#ifdef OBJCPLUS
pop_lang_context ();
#endif
write_symbols = save_write_symbols;
debug_hooks = save_hooks;
}
static int
check_string_class_template (void)
{
tree field_decl = objc_get_class_ivars (constant_string_id);
#define AT_LEAST_AS_LARGE_AS(F, T) \
(F && TREE_CODE (F) == FIELD_DECL \
&& (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
>= TREE_INT_CST_LOW (TYPE_SIZE (T))))
if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
return 0;
field_decl = TREE_CHAIN (field_decl);
if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
return 0;
field_decl = TREE_CHAIN (field_decl);
return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
#undef AT_LEAST_AS_LARGE_AS
}
static GTY(()) int string_layout_checked;
static tree
objc_build_internal_const_str_type (void)
{
tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
tree fields = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
tree field = build_decl (FIELD_DECL, NULL_TREE, ptr_type_node);
TREE_CHAIN (field) = fields; fields = field;
field = build_decl (FIELD_DECL, NULL_TREE, unsigned_type_node);
TREE_CHAIN (field) = fields; fields = field;
finish_builtin_struct (type, "__builtin_ObjCString",
fields, NULL_TREE);
return type;
}
static tree
my_build_string (int len, const char *str)
{
return fix_string_type (build_string (len, str));
}
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));
}
static tree buildNSStringType(void)
{
tree NSString_decl;
NSString_decl = objc_is_class_name (get_identifier ("NSString"));
if (!NSString_decl)
return NULL_TREE;
return objc_get_protocol_qualified_type (NSString_decl, NULL_TREE);
}
tree
objc_build_string_object (tree string)
{
tree initlist, constructor, constant_string_class;
int length;
tree fields, addr;
struct string_descriptor *desc, key;
void **loc;
#ifdef OBJCPLUS
if (processing_template_decl)
return build_min_nt (OBJC_STRING_REFERENCE, string);
#endif
string = fix_string_type (string);
TREE_SET_CODE (string, STRING_CST);
length = TREE_STRING_LENGTH (string) - 1;
constructor = (*targetm.construct_objc_string) (string);
if (constructor)
{
tree NSStringPtrType = buildNSStringType();
return build1 (NOP_EXPR,
NSStringPtrType ? build_pointer_type (NSStringPtrType)
: objc_object_type, constructor);
}
if (!string_layout_checked)
{
string_layout_checked = -1;
constant_string_class = lookup_interface (constant_string_id);
internal_const_str_type = objc_build_internal_const_str_type ();
if (!constant_string_class
|| !(constant_string_type
= CLASS_STATIC_TEMPLATE (constant_string_class)))
error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (constant_string_id));
else if (!check_string_class_template ())
error ("interface %qs does not have valid constant string layout",
IDENTIFIER_POINTER (constant_string_id));
else if (flag_next_runtime && !setup_string_decl ())
error ("cannot find reference tag for class %qs",
IDENTIFIER_POINTER (constant_string_id));
else
{
string_layout_checked = 1;
add_class_reference (constant_string_id);
}
}
if (string_layout_checked == -1)
return error_mark_node;
key.literal = string;
loc = htab_find_slot (string_htab, &key, INSERT);
desc = *loc;
if (!desc)
{
tree var;
*loc = desc = ggc_alloc (sizeof (*desc));
desc->literal = string;
fields = TYPE_FIELDS (internal_const_str_type);
initlist
= build_tree_list (fields,
flag_next_runtime
? build_unary_op (ADDR_EXPR, string_class_decl, 0)
: integer_zero_node);
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;
}
addr = convert (build_pointer_type (constant_string_type),
build_unary_op (ADDR_EXPR, desc->constructor, 1));
return addr;
}
static GTY(()) int num_static_inst;
static tree
objc_add_static_instance (tree constructor, tree class_decl)
{
tree *chain, decl;
char buf[256];
for (chain = &objc_static_instances;
*chain && TREE_VALUE (*chain) != class_decl;
chain = &TREE_CHAIN (*chain));
if (!*chain)
{
*chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
add_objc_string (OBJC_TYPE_NAME (class_decl), class_names);
}
sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
decl = build_decl (VAR_DECL, get_identifier (buf), class_decl);
DECL_COMMON (decl) = 1;
TREE_STATIC (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
TREE_USED (decl) = 1;
DECL_INITIAL (decl) = constructor;
DECL_DEFER_OUTPUT (decl) = 1;
pushdecl_top_level (decl);
rest_of_decl_compilation (decl, 1, 0);
TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
return decl;
}
static tree
objc_build_constructor (tree type, tree elts)
{
tree constructor = build_constructor_from_list (type, elts);
TREE_CONSTANT (constructor) = 1;
TREE_STATIC (constructor) = 1;
TREE_READONLY (constructor) = 1;
#ifdef OBJCPLUS
if (!TREE_PURPOSE (elts))
TREE_TYPE (constructor) = NULL_TREE;
TREE_HAS_CONSTRUCTOR (constructor) = 1;
#endif
return constructor;
}
static void
build_objc_symtab_template (void)
{
tree field_decl, field_decl_chain;
objc_symtab_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_SYMTAB));
field_decl = create_field_decl (long_integer_type_node, "sel_ref_cnt");
field_decl_chain = field_decl;
field_decl = create_field_decl (build_pointer_type (objc_selector_type),
"refs");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (short_integer_type_node, "cls_def_cnt");
chainon (field_decl_chain, field_decl);
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)
{
int index = imp_count + cat_count
+ (flag_next_runtime? -1: 0);
field_decl = create_field_decl
(build_array_type
(ptr_type_node,
build_index_type (build_int_cst (NULL_TREE, index))),
"defs");
chainon (field_decl_chain, field_decl);
}
finish_struct (objc_symtab_template, field_decl_chain, NULL_TREE);
}
static tree
init_def_list (tree type)
{
tree expr, initlist = NULL_TREE;
struct imp_entry *impent;
if (imp_count)
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
{
expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (cat_count)
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
expr = build_unary_op (ADDR_EXPR, impent->class_decl, 0);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (!flag_next_runtime)
{
tree expr;
if (static_instances_decl)
expr = build_unary_op (ADDR_EXPR, static_instances_decl, 0);
else
expr = integer_zero_node;
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return objc_build_constructor (type, nreverse (initlist));
}
static tree
init_objc_symtab (tree type)
{
tree initlist;
initlist = build_tree_list (NULL_TREE,
build_int_cst (long_integer_type_node, 0));
if (flag_next_runtime || ! sel_ref_chain)
initlist = tree_cons (NULL_TREE,
convert (build_pointer_type (objc_selector_type),
integer_zero_node),
initlist);
else
initlist
= tree_cons (NULL_TREE,
convert (build_pointer_type (objc_selector_type),
build_unary_op (ADDR_EXPR,
UOBJC_SELECTOR_TABLE_decl, 1)),
initlist);
initlist = tree_cons (NULL_TREE, build_int_cst (short_integer_type_node,
imp_count), initlist);
initlist = tree_cons (NULL_TREE, build_int_cst (short_integer_type_node,
cat_count), initlist);
if (imp_count || cat_count || !flag_next_runtime)
{
tree field = TYPE_FIELDS (type);
field = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field))));
initlist = tree_cons (NULL_TREE, init_def_list (TREE_TYPE (field)),
initlist);
}
return objc_build_constructor (type, nreverse (initlist));
}
static tree
build_metadata_decl (const char *name, tree type, bool external_linkage)
{
tree decl;
decl = start_var_decl (type, synth_id_with_class_suffix
(name,
objc_implementation_context));
if (external_linkage)
TREE_PUBLIC (decl) = 1;
return decl;
}
static void
forward_declare_categories (void)
{
struct imp_entry *impent;
tree sav = objc_implementation_context;
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
objc_implementation_context = impent->imp_context;
if (flag_objc_abi == 2)
{
impent->class_v2_decl = build_metadata_decl ("l_OBJC_$_CATEGORY",
objc_v2_category_template, false);
set_user_assembler_name (impent->class_v2_decl,
IDENTIFIER_POINTER (DECL_NAME (impent->class_v2_decl)));
}
else
{
impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
objc_category_template, false);
}
}
}
objc_implementation_context = sav;
}
static void
generate_objc_symtab_decl (void)
{
if (cat_count)
forward_declare_categories ();
if (flag_objc_abi != 2)
{
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)));
}
}
static tree
init_module_descriptor (tree type)
{
tree initlist, expr;
expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
initlist = build_tree_list (NULL_TREE, expr);
expr = convert (long_integer_type_node,
size_in_bytes (objc_module_template));
initlist = tree_cons (NULL_TREE, expr, initlist);
expr = add_objc_string (get_identifier (""), class_names);
initlist = tree_cons (NULL_TREE, expr, initlist);
if (UOBJC_SYMBOLS_decl)
expr = build_unary_op (ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
else
expr = integer_zero_node;
initlist = tree_cons (NULL_TREE, expr, initlist);
return objc_build_constructor (type, nreverse (initlist));
}
static void
build_module_descriptor (void)
{
tree field_decl, field_decl_chain;
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
objc_module_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_MODULE));
field_decl = create_field_decl (long_integer_type_node, "version");
field_decl_chain = field_decl;
field_decl = create_field_decl (long_integer_type_node, "size");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (string_type_node, "name");
chainon (field_decl_chain, field_decl);
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);
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
}
static void
build_module_initializer_routine (void)
{
tree body;
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
objc_push_parm (build_decl (PARM_DECL, NULL_TREE, void_type_node));
objc_start_function (get_identifier (TAG_GNUINIT),
build_function_type (void_type_node,
OBJC_VOID_AT_END),
NULL_TREE, objc_get_parm_info (0), 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));
TREE_PUBLIC (current_function_decl) = 0;
#ifndef OBJCPLUS
DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1;
#endif
GNU_INIT_decl = current_function_decl;
finish_function ();
#ifdef OBJCPLUS
pop_lang_context ();
#endif
}
#ifdef OBJCPLUS
int
objc_static_init_needed_p (void)
{
return (GNU_INIT_decl != NULL_TREE);
}
tree
objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
{
add_stmt (build_stmt (EXPR_STMT,
build_function_call (GNU_INIT_decl, NULL_TREE)));
return ctors;
}
#endif
static tree
get_objc_string_decl (tree ident, enum string_section section)
{
hash *hash_table;
hash hsh;
if (section == class_names)
hash_table = class_names_hash_list;
else if (section == meth_var_names)
hash_table = meth_var_names_hash_list;
else if (section == meth_var_types)
hash_table = meth_var_types_hash_list;
else if (section == prop_names_attr)
hash_table = prop_names_attr_hash_list;
else
abort ();
hsh = hash_ident_lookup (hash_table, ident);
if (hsh)
return hsh->list->value;
abort ();
return NULL_TREE;
}
static void
generate_static_references (void)
{
tree decls = NULL_TREE, expr = NULL_TREE;
tree class_name, class, decl, initlist;
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];
if (flag_next_runtime)
abort ();
for (cl_chain = objc_static_instances, num_class = 0;
cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
{
for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
decl = start_var_decl (type, buf);
class = TREE_VALUE (cl_chain);
class_name = get_objc_string_decl (OBJC_TYPE_NAME (class), class_names);
initlist = build_tree_list (NULL_TREE,
build_unary_op (ADDR_EXPR, class_name, 1));
for (in_chain = TREE_PURPOSE (cl_chain);
in_chain; in_chain = TREE_CHAIN (in_chain))
{
expr = build_unary_op (ADDR_EXPR, TREE_VALUE (in_chain), 1);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
initlist = tree_cons (NULL_TREE, integer_zero_node, initlist);
expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
finish_var_decl (decl, expr);
decls
= tree_cons (NULL_TREE, build_unary_op (ADDR_EXPR, decl, 1), decls);
}
decls = tree_cons (NULL_TREE, integer_zero_node, decls);
expr = objc_build_constructor (type, nreverse (decls));
static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
finish_var_decl (static_instances_decl, expr);
}
static tree
update_var_decl (tree decl)
{
DECL_INITIAL (decl) = error_mark_node;
DECL_EXTERNAL (decl) = 0;
TREE_STATIC (decl) = 1;
TREE_ASM_WRITTEN (decl) = 0;
return decl;
}
static GTY(()) int classlist_reference_idx;
static tree
build_classlist_reference_decl (void)
{
tree decl;
char buf[256];
sprintf (buf, "_OBJC_CLASSLIST_REFERENCES_$_%d", classlist_reference_idx++);
decl = start_var_decl (objc_class_type, buf);
return decl;
}
static char*
objc_build_internal_classname (tree ident, bool metaclass)
{
static char string[BUFSIZE];
sprintf (string, "%s_%s", !metaclass ? "OBJC_CLASS_$"
: "OBJC_METACLASS_$",
IDENTIFIER_POINTER (ident));
return string;
}
static void
build_classlist_translation_table (bool metaclass_chain)
{
tree chain;
for (chain = !metaclass_chain ? classlist_ref_chain
: metaclasslist_ref_chain;
chain; chain = TREE_CHAIN (chain))
{
tree expr = TREE_VALUE (chain);
tree decl = TREE_PURPOSE (chain);
if (TREE_CODE (expr) == IDENTIFIER_NODE)
{
expr = create_extern_decl (objc_v2_class_template,
objc_build_internal_classname (expr, metaclass_chain));
expr = convert (objc_class_type, build_fold_addr_expr (expr));
}
finish_var_decl (decl, expr);
}
}
static void
objc_set_alignment_attribute (tree decl, tree el_type)
{
int int_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (el_type));
tree size = build_int_cst (NULL_TREE, int_size);
tree attribute = build_tree_list (get_identifier ("aligned"),
build_tree_list (NULL_TREE, size));
decl_attributes (&decl, attribute, 0);
return;
}
static void
build_class_list_address_table (bool nonlazy)
{
tree chain;
int count=0;
tree type;
tree initlist = NULL_TREE;
tree decl;
tree expr;
tree list_chain = nonlazy ? nonlazy_class_list_chain : class_list_chain;
const char *label_name = nonlazy ? "_OBJC_LABEL_NONLAZY_CLASS_$"
: "_OBJC_LABEL_CLASS_$";
for (chain = list_chain; chain; chain = TREE_CHAIN (chain))
{
tree purpose = NULL_TREE;
expr = TREE_VALUE (chain);
expr = convert (objc_class_type, build_fold_addr_expr (expr));
#ifndef OBJCPLUS
purpose = build_int_cst (NULL_TREE, count);
#endif
++count;
initlist = tree_cons (purpose, expr, initlist);
}
gcc_assert (count > 0);
type = build_array_type (objc_class_type,
build_index_type (build_int_cst (NULL_TREE, count - 1)));
decl = start_var_decl (type, label_name);
expr = objc_build_constructor (type, nreverse (initlist));
objc_set_alignment_attribute (decl, objc_class_type);
finish_var_decl (decl, expr);
}
static void
build_category_list_address_table (bool nonlazy)
{
tree chain;
int count=0;
tree type;
tree initlist = NULL_TREE;
tree decl;
tree expr;
tree list_chain = nonlazy ? nonlazy_category_list_chain : category_list_chain;
const char * label_name = nonlazy ? "_OBJC_LABEL_NONLAZY_CATEGORY_$"
: "_OBJC_LABEL_CATEGORY_$";
for (chain = list_chain; chain; chain = TREE_CHAIN (chain))
{
tree purpose = NULL_TREE;
expr = TREE_VALUE (chain);
expr = convert (objc_class_type, build_fold_addr_expr (expr));
#ifndef OBJCPLUS
purpose = build_int_cst (NULL_TREE, count);
#endif
++count;
initlist = tree_cons (purpose, expr, initlist);
}
gcc_assert (count > 0);
type = build_array_type (objc_class_type,
build_index_type (build_int_cst (NULL_TREE, count - 1)));
decl = start_var_decl (type, label_name);
expr = objc_build_constructor (type, nreverse (initlist));
objc_set_alignment_attribute (decl, objc_class_type);
finish_var_decl (decl, expr);
}
static GTY(()) int selector_reference_idx;
static tree
build_selector_reference_decl (void)
{
tree decl;
char buf[256];
sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
decl = start_var_decl (objc_selector_type, buf);
return decl;
}
static void
build_selector_table_decl (void)
{
tree temp;
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);
UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
}
static tree
build_selector (tree ident)
{
return convert (objc_selector_type,
add_objc_string (ident, meth_var_names));
}
static void
build_selector_translation_table (void)
{
tree chain, initlist = NULL_TREE;
int offset = 0;
tree decl = NULL_TREE;
for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
{
tree expr;
if (warn_selector && objc_implementation_context)
{
tree method_chain;
bool found = false;
for (method_chain = meth_var_names_chain;
method_chain;
method_chain = TREE_CHAIN (method_chain))
{
if (TREE_VALUE (method_chain) == TREE_VALUE (chain))
{
found = true;
break;
}
}
if (!found)
{
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));
offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
if (flag_next_runtime)
{
decl = TREE_PURPOSE (chain);
finish_var_decl (decl, expr);
}
else
{
if (flag_typed_selectors)
{
tree eltlist = NULL_TREE;
tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
eltlist = tree_cons (NULL_TREE, expr, NULL_TREE);
eltlist = tree_cons (NULL_TREE, encoding, eltlist);
expr = objc_build_constructor (objc_selector_template,
nreverse (eltlist));
}
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (! flag_next_runtime)
{
initlist = tree_cons (NULL_TREE,
flag_typed_selectors
? objc_build_constructor
(objc_selector_template,
tree_cons (NULL_TREE,
integer_zero_node,
tree_cons (NULL_TREE,
integer_zero_node,
NULL_TREE)))
: integer_zero_node, initlist);
initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
nreverse (initlist));
finish_var_decl (UOBJC_SELECTOR_TABLE_decl, initlist);
}
}
static tree
get_proto_encoding (tree proto)
{
tree encoding;
if (proto)
{
if (! METHOD_ENCODING (proto))
{
encoding = encode_method_prototype (proto);
METHOD_ENCODING (proto) = encoding;
}
else
encoding = METHOD_ENCODING (proto);
return add_objc_string (encoding, meth_var_types);
}
else
return integer_zero_node;
}
static tree
build_typed_selector_reference (tree ident, tree prototype)
{
tree *chain = &sel_ref_chain;
tree expr;
int index = 0;
while (*chain)
{
if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
goto return_at_index;
index++;
chain = &TREE_CHAIN (*chain);
}
*chain = tree_cons (prototype, ident, NULL_TREE);
return_at_index:
expr = build_unary_op (ADDR_EXPR,
build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_cst (NULL_TREE, index)),
1);
return convert (objc_selector_type, expr);
}
static tree
build_next_runtime_selector_reference (tree ident)
{
hash hsh;
tree *chain = &sel_ref_chain;
tree expr;
hsh = hash_ident_lookup (sel_ref_hash_list, ident);
if (hsh)
return hsh->list->value;
expr = build_selector_reference_decl ();
hsh = hash_ident_enter (sel_ref_hash_list, ident);
hash_add_attr (hsh, expr);
*chain = tree_cons (expr, ident, *chain);
return expr;
}
static tree
build_selector_reference (tree ident)
{
tree *chain = &sel_ref_chain;
tree expr;
int index = 0;
while (*chain)
{
if (TREE_VALUE (*chain) == ident)
return build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_cst (NULL_TREE, index));
index++;
chain = &TREE_CHAIN (*chain);
}
expr = NULL_TREE;
*chain = tree_cons (expr, ident, NULL_TREE);
return build_array_ref (UOBJC_SELECTOR_TABLE_decl,
build_int_cst (NULL_TREE, index));
}
static GTY(()) int message_reference_idx;
static tree
build_message_reference_decl (tree sel_name, tree message_func_ident)
{
tree decl;
char *buf;
char *temp;
int fixed_prefix_size =
2 + IDENTIFIER_LENGTH (message_func_ident) + 1;
buf = (char *)alloca (fixed_prefix_size +
strlen (IDENTIFIER_POINTER (sel_name)) + 1);
sprintf (buf, "l_%s_%s", IDENTIFIER_POINTER (message_func_ident),
IDENTIFIER_POINTER (sel_name));
for (temp = buf+fixed_prefix_size; *temp; temp++)
if (*temp == ':') *temp = '_';
decl = create_hidden_decl (objc_v2_message_ref_template, buf);
DECL_WEAK (decl) = 1;
set_user_assembler_name (decl, buf);
return decl;
}
static tree
build_selector_messenger_reference (tree sel_name, tree message_func_decl)
{
tree *chain = &message_ref_chain;
tree mess_expr;
while (*chain)
{
if (TREE_VALUE (*chain) == message_func_decl)
{
if (TREE_CHAIN (*chain) && TREE_VALUE (TREE_CHAIN (*chain)) == sel_name)
return TREE_PURPOSE (*chain);
}
chain = &TREE_CHAIN (*chain);
}
mess_expr = build_message_reference_decl (sel_name, DECL_NAME (message_func_decl));
*chain = tree_cons (mess_expr, message_func_decl, NULL_TREE);
chain = &TREE_CHAIN (*chain);
*chain = tree_cons (NULL_TREE, sel_name, NULL_TREE);
return mess_expr;
}
static void
build_message_ref_translation_table (void)
{
tree chain;
tree decl = NULL_TREE;
for (chain = message_ref_chain; chain; chain = TREE_CHAIN (chain))
{
tree expr;
tree fields;
tree initializer = NULL_TREE;
tree constructor;
tree struct_type;
decl = TREE_PURPOSE (chain);
struct_type = TREE_TYPE (decl);
fields = TYPE_FIELDS (struct_type);
expr = build_unary_op (ADDR_EXPR, TREE_VALUE (chain), 0);
expr = convert (objc_v2_imp_type, expr);
initializer = build_tree_list (NULL_TREE, expr);
fields = TREE_CHAIN (fields);
gcc_assert (TREE_CHAIN (chain));
chain = TREE_CHAIN (chain);
expr = build_selector (TREE_VALUE (chain));
initializer = tree_cons (NULL_TREE, expr, initializer);
constructor = objc_build_constructor (struct_type, nreverse (initializer));
TREE_INVARIANT (constructor) = true;
finish_var_decl (decl, constructor);
}
}
static tree
objc_copy_to_temp_side_effect_params (tree typelist, tree values)
{
tree valtail, typetail;
gcc_assert (TREE_CHAIN (typelist));
typetail = TREE_CHAIN (TREE_CHAIN (typelist));
for (valtail = values;
valtail;
valtail = TREE_CHAIN (valtail), typetail = TREE_CHAIN (typetail))
{
tree value = TREE_VALUE (valtail);
tree type = typetail ? TREE_VALUE (typetail) : NULL_TREE;
if (type == NULL_TREE)
break;
if (!TREE_SIDE_EFFECTS (value))
continue;
value = save_expr (value);
add_stmt (value);
TREE_VALUE (valtail) = value;
}
return values;
}
static GTY(()) int class_reference_idx;
static tree
build_class_reference_decl (void)
{
tree decl;
char buf[256];
sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
decl = start_var_decl (objc_class_type, buf);
return decl;
}
static void
add_class_reference (tree ident)
{
tree chain;
if ((chain = cls_ref_chain))
{
tree tail;
do
{
if (ident == TREE_VALUE (chain))
return;
tail = chain;
chain = TREE_CHAIN (chain);
}
while (chain);
TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
}
else
cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
}
static tree
objc_v2_get_class_reference (tree ident)
{
tree *chain;
tree decl;
for (chain = &classlist_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
if (TREE_VALUE (*chain) == ident)
{
if (! TREE_PURPOSE (*chain))
TREE_PURPOSE (*chain) = build_classlist_reference_decl ();
return TREE_PURPOSE (*chain);
}
decl = build_classlist_reference_decl ();
*chain = tree_cons (decl, ident, NULL_TREE);
return decl;
}
static tree
build_classlist_super_reference_decl (void)
{
tree decl;
char buf[256];
sprintf (buf, "_OBJC_CLASSLIST_SUP_REFS_$_%d", classlist_reference_idx++);
decl = start_var_decl (objc_class_type, buf);
return decl;
}
static tree
objc_v2_get_class_super_reference (tree ident, bool inst)
{
tree *chain;
tree decl;
for (chain = inst ? &classlist_super_ref_chain : &metaclasslist_super_ref_chain;
*chain; chain = &TREE_CHAIN (*chain))
if (TREE_VALUE (*chain) == ident)
{
if (! TREE_PURPOSE (*chain))
TREE_PURPOSE (*chain) = build_classlist_super_reference_decl ();
return TREE_PURPOSE (*chain);
}
decl = build_classlist_super_reference_decl ();
*chain = tree_cons (decl, ident, NULL_TREE);
return decl;
}
static void
build_classlist_super_translation_table (bool metaclass_chain)
{
tree chain;
for (chain = !metaclass_chain ? classlist_super_ref_chain
: metaclasslist_super_ref_chain;
chain; chain = TREE_CHAIN (chain))
{
tree expr = TREE_VALUE (chain);
tree decl = TREE_PURPOSE (chain);
if (TREE_CODE (expr) == IDENTIFIER_NODE)
{
expr = create_extern_decl (objc_v2_class_template,
objc_build_internal_classname (expr, metaclass_chain));
expr = convert (objc_class_type, build_fold_addr_expr (expr));
}
finish_var_decl (decl, expr);
}
}
tree
objc_get_class_reference (tree ident)
{
tree orig_ident = (DECL_P (ident)
? DECL_NAME (ident)
: TYPE_P (ident)
? OBJC_TYPE_NAME (ident)
: ident);
bool local_scope = false;
if (orig_ident == error_mark_node)
return orig_ident;
#ifdef OBJCPLUS
if (processing_template_decl)
return build_min_nt (CLASS_REFERENCE_EXPR, ident);
#endif
if (TREE_CODE (ident) == TYPE_DECL)
ident = (DECL_ORIGINAL_TYPE (ident)
? DECL_ORIGINAL_TYPE (ident)
: TREE_TYPE (ident));
#ifdef OBJCPLUS
if (TYPE_P (ident) && TYPE_CONTEXT (ident)
&& TYPE_CONTEXT (ident) != global_namespace)
local_scope = true;
#endif
if (local_scope || !(ident = objc_is_class_name (ident)))
{
error ("%qs is not an Objective-C class name or alias",
IDENTIFIER_POINTER (orig_ident));
return error_mark_node;
}
if (flag_objc_abi == 2 && !flag_zero_link)
return objc_v2_get_class_reference (ident);
if (flag_next_runtime && !flag_zero_link)
{
tree *chain;
tree decl;
for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
if (TREE_VALUE (*chain) == ident)
{
if (! TREE_PURPOSE (*chain))
TREE_PURPOSE (*chain) = build_class_reference_decl ();
return TREE_PURPOSE (*chain);
}
decl = build_class_reference_decl ();
*chain = tree_cons (decl, ident, NULL_TREE);
return decl;
}
else
{
tree params;
add_class_reference (ident);
params = build_tree_list (NULL_TREE,
my_build_string_pointer
(IDENTIFIER_LENGTH (ident) + 1,
IDENTIFIER_POINTER (ident)));
assemble_external (objc_get_class_decl);
return build_function_call (objc_get_class_decl, params);
}
}
static hash
hash_ident_lookup (hash *hashlist, tree sel_name)
{
hash target;
target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
while (target)
{
if (sel_name == target->key)
return target;
target = target->next;
}
return 0;
}
static hash
hash_ident_enter (hash *hashlist, tree ident)
{
hash obj;
int slot = hash_func (ident) % SIZEHASHTABLE;
obj = (hash) ggc_alloc (sizeof (struct hashed_entry));
obj->list = 0;
obj->next = hashlist[slot];
obj->key = ident;
hashlist[slot] = obj;
return obj;
}
static tree
add_objc_string (tree ident, enum string_section section)
{
tree *chain, decl, type, string_expr, sectionname;
hash *hash_table;
hash hsh;
if (section == class_names)
{
chain = &class_names_chain;
hash_table = class_names_hash_list;
}
else if (section == meth_var_names)
{
chain = &meth_var_names_chain;
hash_table = meth_var_names_hash_list;
}
else if (section == meth_var_types)
{
chain = &meth_var_types_chain;
hash_table = meth_var_types_hash_list;
}
else if (section == prop_names_attr)
{
chain = &prop_names_attr_chain;
hash_table = prop_names_attr_hash_list;
}
else
abort ();
hsh = hash_ident_lookup (hash_table, ident);
if (hsh)
return convert (string_type_node,
build_unary_op (ADDR_EXPR, hsh->list->value, 1));
sectionname = build_objc_string_ident (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 (sectionname));
string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
IDENTIFIER_POINTER (ident));
finish_var_decl (decl, string_expr);
hsh = hash_ident_enter (hash_table, ident);
hash_add_attr (hsh, decl);
*chain = tree_cons (decl, ident, *chain);
return convert (string_type_node, build_unary_op (ADDR_EXPR, decl, 1));
}
static GTY(()) int class_names_idx;
static GTY(()) int meth_var_names_idx;
static GTY(()) int meth_var_types_idx;
static GTY(()) int property_name_attr_idx;
static tree
build_objc_string_ident (enum string_section section)
{
char buf[256];
if (section == class_names)
sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
else if (section == meth_var_names)
sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
else if (section == meth_var_types)
sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
else if (section == prop_names_attr)
sprintf (buf, "_OBJC_PROP_NAME_ATTR_%d", property_name_attr_idx++);
return get_identifier (buf);
}
void
objc_declare_alias (tree alias_ident, tree class_ident)
{
tree underlying_class;
#ifdef OBJCPLUS
if (current_namespace != global_namespace) {
error ("Objective-C declarations may only appear in global scope");
}
#endif
if (!(underlying_class = objc_is_class_name (class_ident)))
warning (0, "cannot find class %qs", IDENTIFIER_POINTER (class_ident));
else if (objc_is_class_name (alias_ident))
warning (0, "class %qs already exists", IDENTIFIER_POINTER (alias_ident));
else
{
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
lang_hooks.decls.pushdecl (build_decl
(TYPE_DECL,
alias_ident,
xref_tag (RECORD_TYPE, underlying_class)));
#ifdef OBJCPLUS
pop_lang_context ();
#endif
hash_class_name_enter (als_name_hash_list, alias_ident,
underlying_class);
}
}
void
objc_declare_class (tree ident_list)
{
tree list;
#ifdef OBJCPLUS
if (current_namespace != global_namespace) {
error ("Objective-C declarations may only appear in global scope");
}
#endif
for (list = ident_list; list; list = TREE_CHAIN (list))
{
tree ident = TREE_VALUE (list);
if (! objc_is_class_name (ident))
{
tree record = lookup_name (ident), type = record;
if (record)
{
if (TREE_CODE (record) == TYPE_DECL)
type = DECL_ORIGINAL_TYPE (record) ?
DECL_ORIGINAL_TYPE (record) :
TREE_TYPE (record);
if (TREE_CODE (type) != RECORD_TYPE || !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);
INIT_TYPE_OBJC_INFO (record);
TYPE_OBJC_INTERFACE (record) = ident;
hash_class_name_enter (cls_name_hash_list, ident, NULL_TREE);
}
}
}
tree
objc_is_class_name (tree ident)
{
hash target;
if (ident && TREE_CODE (ident) == IDENTIFIER_NODE
&& identifier_global_value (ident))
ident = identifier_global_value (ident);
while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
if (ident && TREE_CODE (ident) == RECORD_TYPE)
ident = OBJC_TYPE_NAME (ident);
#ifdef OBJCPLUS
if (ident && TREE_CODE (ident) == TYPE_DECL)
{
tree type = TREE_TYPE (ident);
if (type && TREE_CODE (type) == TEMPLATE_TYPE_PARM)
return NULL_TREE;
ident = DECL_NAME (ident);
}
#endif
if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
return NULL_TREE;
if (lookup_interface (ident))
return ident;
target = hash_class_name_lookup (cls_name_hash_list, ident);
if (target)
return target->key;
target = hash_class_name_lookup (als_name_hash_list, ident);
if (target)
{
gcc_assert (target->list && target->list->value);
return target->list->value;
}
return 0;
}
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);
return (objc_object_type && type
&& (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
? type
: NULL_TREE);
}
tree
objc_is_object_ptr (tree type)
{
tree ret;
if (objc_nsobject_attribute_type (type))
return TREE_TYPE (type);
type = TYPE_MAIN_VARIANT (type);
if (!POINTER_TYPE_P (type))
return 0;
ret = objc_is_id (type);
if (!ret)
ret = objc_is_class_name (TYPE_MAIN_VARIANT (TREE_TYPE (type)));
return ret;
}
int
objc_is_gcable_type (tree type)
{
int strong;
if (!TYPE_P (type)
#ifdef OBJCPLUS
|| type_unknown_p (type)
#endif
)
return 0;
strong = 0;
do
{
strong = objc_is_strong_p (type);
if (strong)
break;
if (TREE_CODE (type) == FUNCTION_TYPE
|| TREE_CODE (type) == METHOD_TYPE)
break;
if (objc_is_object_ptr (type))
{
strong = (objc_is_strong_p (TREE_TYPE (type)) >= 0 ? 1 : -1);
break;
}
if (TREE_CODE (type) == BLOCK_POINTER_TYPE)
{
strong = block_pointer_strong_value (type);
break;
}
type = TREE_TYPE (type);
}
while (type);
return strong;
}
static
tree objc2_outervar (tree expr)
{
gcc_assert (TREE_CODE (expr) == NOP_EXPR);
expr = TREE_OPERAND (expr, 0);
gcc_assert (TREE_CODE (expr) == PLUS_EXPR);
return TREE_OPERAND (expr, 0);
}
static tree
objc2_build_indirect_ref_ivar2 (tree indir, tree offset, tree newoutervar)
{
tree ftype = TREE_TYPE (indir);
tree expr = build_c_cast (string_type_node, newoutervar);
expr = fold (build2 (PLUS_EXPR, string_type_node, expr, offset));
expr = build_c_cast (build_pointer_type (ftype), expr);
expr = build_indirect_ref (expr, "unary *");
return expr;
}
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:
{
tree ivar_offset_var;
ivar_offset_var = objc_v2_ivar_reference (expr);
if (ivar_offset_var != NULL_TREE)
return objc2_build_indirect_ref_ivar2 (expr, ivar_offset_var, newexpr);
}
return build_indirect_ref (objc_substitute_decl (TREE_OPERAND (expr, 0),
oldexpr,
newexpr), "->");
default:
return expr;
}
}
static tree
objc_build_ivar_assignment (tree outervar, bool objc2_ivar_ref, tree lhs, tree rhs)
{
tree func_params;
tree offs, func;
int save_warn_invalid_offsetof = warn_invalid_offsetof;
warn_invalid_offsetof = 0;
if (flag_objc_abi == 2 && objc2_ivar_ref)
outervar = objc2_outervar (outervar);
offs
= objc_substitute_decl
(lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
warn_invalid_offsetof = save_warn_invalid_offsetof;
func = objc_assign_ivar_decl;
offs = convert (ptrdiff_type_node, build_unary_op (ADDR_EXPR, offs, 0));
offs = fold (offs);
func_params = tree_cons (NULL_TREE,
convert (objc_object_type, rhs),
tree_cons (NULL_TREE, convert (objc_object_type, outervar),
tree_cons (NULL_TREE, offs,
NULL_TREE)));
assemble_external (func);
return build_function_call (func, func_params);
}
static tree
objc_build_global_assignment (tree lhs, tree rhs, int strong)
{
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));
tree func = (strong == 1) ? objc_assign_global_decl : objc_assign_weak_decl;
assemble_external (func);
return build_function_call (func, func_params);
}
static tree
objc_build_weak_read (tree expr)
{
tree func_params;
expr = build_unary_op (ADDR_EXPR, expr, 1);
expr = convert (build_pointer_type (objc_object_type), expr);
func_params = tree_cons (NULL_TREE, expr, NULL_TREE);
assemble_external (objc_read_weak_decl);
return build_function_call (objc_read_weak_decl, func_params);
}
static bool
objc_tree_is_weak_expr (tree expr)
{
#ifdef OBJCPLUS
if (processing_template_decl)
return false;
#endif
if (skip_evaluation || TREE_CODE (expr) == OBJC_WEAK_REFERENCE_EXPR
|| TREE_TYPE (expr) == NULL_TREE)
return false;
return (objc_is_gcable_p (expr) == -1);
}
tree
objc_build_weak_reference_tree (tree expr)
{
if (!flag_objc_gc)
return expr;
return objc_tree_is_weak_expr (expr) ?
build1 (OBJC_WEAK_REFERENCE_EXPR, TREE_TYPE (expr), expr) : expr;
}
void
objc_weak_reference_expr (tree *ref)
{
tree expr = *ref;
if (expr && TREE_CODE (expr) == OBJC_WEAK_REFERENCE_EXPR)
*ref = TREE_OPERAND (expr, 0);
}
static tree
objc_build_strong_cast_assignment (tree lhs, tree rhs)
{
tree func_params
= tree_cons (NULL_TREE,
convert (objc_object_type, rhs),
tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
build_unary_op (ADDR_EXPR, lhs, 0)),
NULL_TREE));
assemble_external (objc_assign_strong_cast_decl);
return build_function_call (objc_assign_strong_cast_decl, func_params);
}
void
objc_checkon_weak_attribute (tree decl)
{
if (!flag_objc_gc)
return;
if (decl && DECL_P (decl))
{
if (objc_collecting_ivars
|| (TREE_CODE (decl) == VAR_DECL
&& (TREE_STATIC (decl) || DECL_EXTERNAL (decl))))
return;
if ((TREE_CODE (decl) == FIELD_DECL || (TREE_CODE (decl) == VAR_DECL && !COPYABLE_BYREF_LOCAL_VAR (decl)))
&& objc_is_gcable_type (TREE_TYPE (decl)) == -1)
{
location_t saved_location = input_location;
input_location = DECL_SOURCE_LOCATION (decl);
warning (0, "__weak attribute cannot be specified on a %s declaration",
TREE_CODE (decl) == FIELD_DECL ? "field" : "local object");
input_location = saved_location;
return;
}
}
}
static tree
objc_build_memmove_collectable (tree lhs, tree rhs, tree type)
{
tree arg1 = convert (ptr_type_node, build_unary_op (ADDR_EXPR, lhs, 1));
tree arg2 = convert (ptr_type_node, build_unary_op (ADDR_EXPR, rhs, 1));
int size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (type));
tree arg3 = build_int_cst (NULL_TREE, size);
tree func_params = tree_cons (NULL_TREE, arg1,
tree_cons (NULL_TREE, arg2,
tree_cons (NULL_TREE, arg3, NULL_TREE)));
assemble_external (objc_memmove_collectable_decl);
return build_function_call (objc_memmove_collectable_decl, func_params);
}
static int
objc_aggr_type_strong (tree aggr_type)
{
tree fieldlist, field_decl;
if (!flag_objc_gc && !flag_objc_gc_only)
return 0;
gcc_assert (TREE_CODE (aggr_type) == RECORD_TYPE
|| TREE_CODE (aggr_type) == UNION_TYPE);
fieldlist = TYPE_FIELDS (aggr_type);
for (field_decl = fieldlist; field_decl; field_decl = TREE_CHAIN (field_decl))
{
if (TREE_TYPE (field_decl) == error_mark_node)
continue;
if (field_decl && TREE_CODE (field_decl) == FIELD_DECL
&& DECL_NAME (field_decl) && !DECL_BIT_FIELD_TYPE (field_decl)
#ifdef OBJCPLUS
&& !TREE_STATIC (field_decl)
#endif
)
{
tree field_type = TREE_TYPE (field_decl);
if (TREE_CODE (field_type) == ARRAY_TYPE)
{
field_type = TREE_TYPE (field_type);
while (TREE_CODE (field_type) == ARRAY_TYPE)
field_type = TREE_TYPE (field_type);
}
if (TREE_CODE (field_type) == RECORD_TYPE || TREE_CODE (field_type) == UNION_TYPE)
{
if (objc_aggr_type_strong (field_type))
return 1;
else
continue;
}
if (objc_is_gcable_type (field_type) == 1)
return 1;
continue;
}
}
return 0;
}
static int
objc_is_strong_p (tree expr)
{
if (TYPE_P (expr) || DECL_P (expr))
{
tree attr = lookup_attribute ("objc_gc",
(TYPE_P (expr)
? TYPE_ATTRIBUTES (expr)
: DECL_ATTRIBUTES (expr)));
if (attr && TREE_VALUE (attr))
{
if (TREE_VALUE (TREE_VALUE (attr)) == get_identifier ("strong"))
return 1;
if (TREE_VALUE (TREE_VALUE (attr)) == get_identifier ("weak"))
return -1;
}
}
return 0;
}
static int
objc_is_gcable_p (tree expr)
{
tree t = TREE_TYPE (expr);
int strong = objc_is_strong_p (t);
if (strong)
return strong;
while (TREE_CODE (expr) == INDIRECT_REF
&& TREE_CODE (TREE_OPERAND (expr, 0)) == NOP_EXPR
&& TREE_CODE (TREE_OPERAND (TREE_OPERAND (expr, 0), 0)) == ADDR_EXPR)
expr = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (expr, 0), 0), 0);
while (TREE_CODE (expr) == COMPONENT_REF || TREE_CODE (expr) == ARRAY_REF)
expr = TREE_OPERAND (expr, 0);
if (TREE_CODE (expr) == PARM_DECL ||
(TREE_CODE (expr) == VAR_DECL
&& DECL_CONTEXT (expr)
&& !TREE_STATIC (expr)))
return 0;
return objc_is_gcable_type (t);
}
static
tree objc_v2_ivar_reference (tree expr)
{
if (flag_objc_abi < 2 || TREE_CODE (expr) != INDIRECT_REF)
return NULL_TREE;
expr = TREE_OPERAND (expr, 0);
if (TREE_CODE (expr) != NOP_EXPR)
return NULL_TREE;
expr = TREE_OPERAND (expr, 0);
if (TREE_CODE (expr) != PLUS_EXPR)
return NULL_TREE;
expr = TREE_OPERAND (expr, 1);
return (TREE_CODE (expr) == VAR_DECL && DECL_NAME (expr)
&& strncmp (IDENTIFIER_POINTER (DECL_NAME (expr)), STRING_V2_IVAR_OFFSET_PREFIX,
strlen (STRING_V2_IVAR_OFFSET_PREFIX)) == 0) ? expr : NULL_TREE;
}
static tree
objc_strip_off_indirection (tree expr)
{
if ((TREE_CODE (expr) == INDIRECT_REF && (objc_v2_ivar_reference (expr) == NULL_TREE))
|| TREE_CODE (expr) == NOP_EXPR
|| TREE_CODE (expr) == ADDR_EXPR || TREE_CODE (expr) == PLUS_EXPR)
return objc_strip_off_indirection (TREE_OPERAND (expr, 0));
return expr;
}
static int
objc_is_ivar_reference_p (tree expr)
{
return (TREE_CODE (expr) == ARRAY_REF
? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
: TREE_CODE (expr) == COMPONENT_REF
? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
: (objc_v2_ivar_reference (expr) != NULL_TREE));
}
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 outer;
int indirect_p = 0;
int strong;
bool objc2_ivar_ref;
tree lhs_type = TREE_TYPE (lhs);
if (TREE_CODE (lhs_type) == RECORD_TYPE || TREE_CODE (lhs_type) == UNION_TYPE)
{
strong = objc_aggr_type_strong (lhs_type);
return strong ? objc_build_memmove_collectable (lhs, rhs, lhs_type)
: NULL_TREE;
}
if (TREE_CODE (lhs_type) != POINTER_TYPE
&& TREE_CODE (TREE_TYPE (rhs)) != POINTER_TYPE
&& TREE_CODE (lhs_type) != BLOCK_POINTER_TYPE
&& TREE_CODE (TREE_TYPE (rhs)) != BLOCK_POINTER_TYPE)
return NULL_TREE;
if ((strong = objc_is_gcable_p (lhs)) == 0)
return NULL_TREE;
if (modifycode != NOP_EXPR && modifycode != INIT_EXPR)
{
warning (0, "pointer arithmetic for garbage-collected objects not allowed");
return NULL_TREE;
}
gcc_assert (modifycode != INIT_EXPR || c_dialect_cxx ());
outer = lhs;
if (strong == -1)
outer = objc_strip_off_indirection (outer);
while (outer
&& (TREE_CODE (outer) == COMPONENT_REF
|| TREE_CODE (outer) == ARRAY_REF))
outer = TREE_OPERAND (outer, 0);
objc2_ivar_ref = objc_v2_ivar_reference (outer) != NULL_TREE;
if (TREE_CODE (outer) == INDIRECT_REF && !objc2_ivar_ref)
{
outer = TREE_OPERAND (outer, 0);
indirect_p = 1;
}
if (indirect_p && objc_is_ivar_reference_p (strong == -1
? objc_strip_off_indirection (lhs)
: lhs)
&& objc_is_object_ptr (TREE_TYPE (outer)))
{
if (warn_assign_intercept)
warning (0, "instance variable assignment has been intercepted");
return strong == 1
? objc_build_ivar_assignment (outer, objc2_ivar_ref, lhs, rhs)
: objc_build_global_assignment (lhs, rhs, strong);
}
if (!indirect_p && objc2_ivar_ref)
{
if (warn_assign_intercept)
warning (0, "instance variable assignment has been intercepted");
return strong == 1
? objc_build_ivar_assignment (TREE_OPERAND (outer, 0), objc2_ivar_ref, lhs, rhs)
: objc_build_global_assignment (lhs, rhs, strong);
}
if (!indirect_p && objc_is_global_reference_p (outer))
{
if (warn_assign_intercept)
warning (0, "global/static variable assignment has been intercepted");
return objc_build_global_assignment (lhs, rhs, strong);
}
if (strong == -1)
{
if (TREE_CODE (outer) == COMPONENT_REF && TREE_OPERAND (outer, 0)
&& TREE_CODE (TREE_OPERAND (outer, 0)) == VAR_DECL)
{
tree var_decl = TREE_OPERAND (outer, 0);
if (COPYABLE_WEAK_BLOCK (var_decl))
return objc_build_global_assignment (lhs, rhs, -1);
}
return NULL_TREE;
}
if (warn_assign_intercept)
warning (0, "strong-cast assignment has been intercepted");
return objc_build_strong_cast_assignment (lhs, rhs);
}
static tree
objc_is_ivar (tree expr, tree component, tree *class)
{
tree field = NULL_TREE;
tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
if (TREE_CODE (basetype) == RECORD_TYPE
&& TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
{
*class = lookup_interface (OBJC_TYPE_NAME (basetype));
if (*class)
{
do
{
tree ivar_chain = CLASS_RAW_IVARS (*class);
if (ivar_chain)
{
field = is_ivar (ivar_chain, component);
if (field != NULL_TREE)
break;
}
*class = lookup_interface (CLASS_SUPER_NAME (*class));
}
while (*class);
}
}
return field;
}
tree
objc_v2_component_ref_field_offset (tree exp)
{
char var_offset_name[512];
tree class_name, offset;
tree datum = TREE_OPERAND (exp, 0);
tree field = TREE_OPERAND (exp, 1);
tree component = DECL_NAME (field);
if (!component)
return NULL_TREE;
if (!((flag_objc_abi == 2)
&& (field = objc_is_ivar (datum, component, &class_name))))
return NULL_TREE;
gcc_assert (DECL_INITIAL (field));
create_ivar_offset_name (var_offset_name, CLASS_NAME (class_name),
field);
offset = create_extern_decl (TREE_TYPE (size_zero_node), var_offset_name);
return offset;
}
tree
objc_v2_bitfield_ivar_bitpos (tree exp)
{
tree class_name;
int bitpos;
tree datum = TREE_OPERAND (exp, 0);
tree field = TREE_OPERAND (exp, 1);
tree component = DECL_NAME (field);
tree ivar_field;
if (!((flag_objc_abi == 2)
&& (ivar_field = objc_is_ivar (datum, component, &class_name))))
return NULL_TREE;
gcc_assert (DECL_INITIAL (ivar_field));
bitpos = tree_low_cst (DECL_FIELD_BIT_OFFSET (field), 0);
bitpos = bitpos % BITS_PER_UNIT;
return build_int_cst (TREE_TYPE (bitsize_zero_node), bitpos);
}
tree
objc_v2_build_ivar_ref (tree datum, tree component)
{
tree field, ref, class_name, offset, ftype, expr;
char var_offset_name[512];
if (!((flag_objc_abi == 2)
&& (field = objc_is_ivar (datum, component, &class_name))))
return NULL_TREE;
if (DECL_INITIAL (field))
return NULL_TREE;
if (TREE_CODE (datum) == INDIRECT_REF && (TREE_OPERAND (datum, 0) == null_pointer_node
#ifdef OBJCPLUS
|| (TREE_CODE (TREE_OPERAND (datum, 0)) == NOP_EXPR
&& TREE_OPERAND (TREE_OPERAND (datum, 0), 0) == null_pointer_node)
#endif
))
{
error ("Illegal reference to non-fragile ivar");
return error_mark_node;
}
create_ivar_offset_name (var_offset_name, CLASS_NAME (class_name),
field);
offset = create_extern_decl (TREE_TYPE (size_zero_node), var_offset_name);
ftype = TREE_TYPE (field);
expr = build_c_cast (string_type_node,
build_fold_addr_expr (datum));
expr = fold (build2 (PLUS_EXPR, string_type_node, expr, offset));
expr = build_c_cast (build_pointer_type (ftype), expr);
ref = build_indirect_ref (expr, "unary *");
TREE_TYPE (ref) = ftype;
if (TREE_READONLY (datum) || TREE_READONLY (field))
TREE_READONLY (ref) = 1;
if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field))
TREE_THIS_VOLATILE (ref) = 1;
if (TREE_DEPRECATED (field))
warn_deprecated_use (field);
if (TREE_UNAVAILABLE (field))
error_unavailable_use (field);
if (!flag_objc_gc && warn_direct_ivar_access)
objc_warn_direct_ivar_access (TYPE_MAIN_VARIANT (TREE_TYPE (datum)),
component);
return ref;
}
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 IDENTIFIER_HASH_VALUE (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,
IDENTIFIER_HASH_VALUE (ident),
NO_INSERT);
if (slot && *slot)
i = (*slot)->class_name;
}
return i;
}
}
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;
}
void
objc_detect_field_duplicates (tree fieldlist)
{
tree x, y;
int timeout = 10;
#ifdef OBJCPLUS
if (!objc_collecting_ivars)
return;
#endif
if (!fieldlist)
return;
x = TREE_CHAIN (fieldlist);
if (!x)
return;
do {
timeout--;
x = TREE_CHAIN (x);
} while (timeout > 0 && x);
if (timeout > 0)
{
for (x = TREE_CHAIN (fieldlist); x ; x = TREE_CHAIN (x))
if (DECL_NAME (x))
{
for (y = fieldlist; y != x; y = TREE_CHAIN (y))
if (DECL_NAME (y) == DECL_NAME (x))
{
if (objc_collecting_ivars)
{
error ("%Jduplicate member %qD", y, y);
DECL_NAME (y) = NULL_TREE;
}
else
{
error ("%Jduplicate member %qD", x, x);
DECL_NAME (x) = NULL_TREE;
}
}
}
}
else
{
htab_t htab = htab_create (37, htab_hash_pointer, htab_eq_pointer, NULL);
void **slot;
for (x = fieldlist; x ; x = TREE_CHAIN (x))
if ((y = DECL_NAME (x)) != 0)
{
slot = htab_find_slot (htab, y, INSERT);
if (*slot)
{
if (objc_collecting_ivars)
{
tree z;
for (z = fieldlist; z ; z = TREE_CHAIN (z))
if (DECL_NAME (x) == DECL_NAME (z))
{
error ("%Jduplicate member %qD", z, z);
DECL_NAME (z) = NULL_TREE;
break;
}
}
else
{
error ("%Jduplicate member %qD", x, x);
DECL_NAME (x) = NULL_TREE;
}
}
*slot = y;
}
htab_delete (htab);
}
}
tree
objc_get_interface_ivars (tree fieldlist)
{
tree ivar_chain;
tree interface;
if (!objc_collecting_ivars || !objc_interface_context
|| TREE_CODE (objc_interface_context) != CLASS_INTERFACE_TYPE
|| CLASS_SUPER_NAME (objc_interface_context) == NULL_TREE)
return fieldlist;
interface = objc_interface_context;
gcc_assert (TOTAL_CLASS_RAW_IVARS (objc_interface_context) == NULL_TREE);
ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
if (CLASS_SUPER_NAME (interface))
{
interface = lookup_interface (CLASS_SUPER_NAME (interface));
if (TOTAL_CLASS_RAW_IVARS (interface) == NULL_TREE)
TOTAL_CLASS_RAW_IVARS (interface) = copy_list (CLASS_RAW_IVARS (interface));
ivar_chain = chainon (ivar_chain, TOTAL_CLASS_RAW_IVARS (interface));
}
TOTAL_CLASS_RAW_IVARS (objc_interface_context) = ivar_chain;
return ivar_chain;
}
static tree
get_class_ivars (tree interface, bool inherited)
{
tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
if (!CLASS_IVARS (interface))
CLASS_IVARS (interface) = ivar_chain;
if (!inherited)
return ivar_chain;
while (CLASS_SUPER_NAME (interface))
{
interface = lookup_interface (CLASS_SUPER_NAME (interface));
ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
ivar_chain);
}
return ivar_chain;
}
static tree
objc_create_temporary_var (tree type)
{
tree decl;
decl = build_decl (VAR_DECL, NULL_TREE, type);
TREE_USED (decl) = 1;
DECL_ARTIFICIAL (decl) = 1;
DECL_IGNORED_P (decl) = 1;
DECL_CONTEXT (decl) = current_function_decl;
return decl;
}
static tree
create_weak_decl (tree type, const char *name)
{
tree decl = create_global_decl (type, name);
DECL_WEAK (decl) = 1;
return decl;
}
static void
objc2_build_ehtype (void)
{
tree field_decl, field_decl_chain;
objc2_ehtype_template = start_struct (RECORD_TYPE,
get_identifier ("_objc_ehtype_t"));
field_decl = create_field_decl (ptr_type_node, "_objc_ehtype_vtable");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "className");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (objc_v2_class_template),
"cls");
chainon (field_decl_chain, field_decl);
finish_struct (objc2_ehtype_template, field_decl_chain, NULL_TREE);
}
static
void init_UOBJC2_EHTYPE_decls (void)
{
if (!UOBJC2_EHTYPE_VTABLE_decl)
{
UOBJC2_EHTYPE_VTABLE_decl = lookup_name (get_identifier ("objc_ehtype_vtable"));
if (!UOBJC2_EHTYPE_VTABLE_decl)
UOBJC2_EHTYPE_VTABLE_decl = create_extern_decl (ptr_type_node,
"objc_ehtype_vtable");
}
if (!UOBJC2_EHTYPE_id_decl)
{
UOBJC2_EHTYPE_id_decl = lookup_name (get_identifier ("OBJC_EHTYPE_id"));
if (!UOBJC2_EHTYPE_id_decl)
UOBJC2_EHTYPE_id_decl = create_extern_decl (objc2_ehtype_template,
"OBJC_EHTYPE_id");
}
}
static tree
objc2_build_ehtype_initializer (tree name, tree cls)
{
tree initlist = NULL_TREE;
tree addr;
init_UOBJC2_EHTYPE_decls ();
addr =
fold (build2 (MULT_EXPR, ptr_type_node,
TYPE_SIZE_UNIT (ptr_type_node), build_int_cst (NULL_TREE, 2)));
addr = fold (build2 (PLUS_EXPR, ptr_type_node,
build_fold_addr_expr (UOBJC2_EHTYPE_VTABLE_decl), addr));
initlist = tree_cons (NULL_TREE, addr, initlist);
initlist = tree_cons (NULL_TREE, name, initlist);
initlist = tree_cons (NULL_TREE, cls, initlist);
return objc_build_constructor (objc2_ehtype_template, nreverse (initlist));
}
static char*
objc2_internal_ehtype_name (tree cls_name_ident)
{
static char string[BUFSIZE];
sprintf (string, "%s_%s", STRING_V2_OBJC_EHTYPE_PREFIX, IDENTIFIER_POINTER (cls_name_ident));
return string;
}
static tree
objc2_build_ehtype_var_decl (tree cls_name_ident, bool extern_decl, bool weak_decl)
{
tree initlist, ehtype_vdecl;
tree name_expr, class_name_expr;
const char* string = objc2_internal_ehtype_name (cls_name_ident);
if (extern_decl)
return create_extern_decl (objc2_ehtype_template, string);
name_expr = add_objc_string (cls_name_ident, class_names);
class_name_expr = create_extern_decl (objc_v2_class_template,
objc_build_internal_classname (cls_name_ident, false));
class_name_expr = build_fold_addr_expr (class_name_expr);
ehtype_vdecl = weak_decl ? create_weak_decl (objc2_ehtype_template, string)
: create_global_decl (objc2_ehtype_template, string);
initlist = objc2_build_ehtype_initializer (name_expr, class_name_expr);
finish_var_decl (ehtype_vdecl, initlist);
return ehtype_vdecl;
}
#ifdef OBJCPLUS
bool
objc2_valid_objc_catch_type (tree type)
{
return flag_objc_zerocost_exceptions && managed_objc_object_pointer (type);
}
#endif
static bool
objc2_objc_exception_attr (tree cls)
{
tree chain;
while (cls)
{
for (chain = CLASS_ATTRIBUTES (cls); chain; chain = TREE_CHAIN (chain))
if (is_attribute_p ("objc_exception", TREE_PURPOSE (chain)))
return true;
cls = lookup_interface (CLASS_SUPER_NAME (cls));
}
return false;
}
static tree
objc2_eh_runtime_type (tree type)
{
tree t;
if (type == error_mark_node)
return type;
if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
return build_fold_addr_expr (UOBJC2_EHTYPE_id_decl);
if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
{
#ifdef OBJCPLUS
return objcp_build_eh_type_type (type);
#else
error ("non-objective-c type '%T' cannot be caught", type);
return error_mark_node;
#endif
}
t = OBJC_TYPE_NAME (TREE_TYPE (type));
t = objc2_build_ehtype_var_decl (t,
objc2_objc_exception_attr (lookup_interface (t)), true);
return build_fold_addr_expr (t);
}
static void
objc2_build_extern_decl_catch_object (tree type)
{
if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
return;
if (POINTER_TYPE_P (type) && TYPED_OBJECT (TREE_TYPE (type)))
{
tree t = OBJC_TYPE_NAME (TREE_TYPE (type));
(void)add_objc_string (t, class_names);
(void) create_extern_decl (objc_v2_class_template,
objc_build_internal_classname (t, false));
if (objc2_objc_exception_attr (lookup_interface (t)))
(void) create_extern_decl (objc2_ehtype_template, objc2_internal_ehtype_name (t));
}
}
struct objc_try_context
{
struct objc_try_context *outer;
tree try_body;
tree finally_body;
location_t try_locus;
location_t end_try_locus;
location_t end_catch_locus;
location_t finally_locus;
location_t end_finally_locus;
tree catch_list;
tree current_catch;
tree caught_decl;
tree stack_decl;
tree rethrow_decl;
};
static struct objc_try_context *cur_try_context;
#ifndef OBJCPLUS
static tree
objc_eh_runtime_type (tree type)
{
return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
}
#endif
static void
objc_init_exceptions (void)
{
static bool done = false;
if (done)
return;
done = true;
if (flag_objc_sjlj_exceptions)
{
if (darwin_macosx_version_min
&& strverscmp (darwin_macosx_version_min, "10.3") < 0)
warning (0, "Mac OS X version 10.3 or later is needed instead of %s for objc/obj-c++ exceptions",
darwin_macosx_version_min);
}
else if (flag_objc_zerocost_exceptions)
{
#ifndef OBJCPLUS
c_eh_initialized_p = true;
#endif
OBJC_FLAG_ZEROCOST_EXCEPTIONS;
eh_personality_libfunc
= init_one_libfunc ("__objc_personality_v0");
default_init_unwind_resume_libfunc ();
using_eh_for_cleanups ();
lang_eh_runtime_type = objc2_eh_runtime_type;
init_UOBJC2_EHTYPE_decls ();
}
#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
}
static tree
objc_build_exc_ptr (void)
{
if (flag_objc_sjlj_exceptions)
{
tree var = cur_try_context->caught_decl;
if (!var)
{
var = objc_create_temporary_var (objc_object_type);
cur_try_context->caught_decl = var;
}
return var;
}
else
return build0 (EXC_PTR_EXPR, objc_object_type);
}
static tree
next_sjlj_build_try_exit (void)
{
tree t;
t = build_fold_addr_expr (cur_try_context->stack_decl);
t = tree_cons (NULL, t, NULL);
t = build_function_call (objc_exception_try_exit_decl, t);
return t;
}
static tree
next_sjlj_build_enter_and_setjmp (void)
{
tree t, enter, sj, cond;
t = build_fold_addr_expr (cur_try_context->stack_decl);
t = tree_cons (NULL, t, NULL);
enter = build_function_call (objc_exception_try_enter_decl, t);
t = objc_build_component_ref (cur_try_context->stack_decl,
get_identifier ("buf"));
t = build_fold_addr_expr (t);
#ifdef OBJCPLUS
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 = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
cond = c_common_truthvalue_conversion (cond);
return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
}
static tree
next_sjlj_build_exc_extract (tree decl)
{
tree t;
t = build_fold_addr_expr (cur_try_context->stack_decl);
t = tree_cons (NULL, t, NULL);
t = build_function_call (objc_exception_extract_decl, t);
t = convert (TREE_TYPE (decl), t);
t = build2 (MODIFY_EXPR, void_type_node, decl, t);
return t;
}
static tree
next_sjlj_build_catch_list (void)
{
tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
tree catch_seq, t;
tree *last = &catch_seq;
bool saw_id = false;
for (; !tsi_end_p (i); tsi_next (&i))
{
tree stmt = tsi_stmt (i);
tree type = CATCH_TYPES (stmt);
tree body = CATCH_BODY (stmt);
if (type == NULL)
{
*last = body;
saw_id = true;
break;
}
else
{
tree args, cond;
if (type == error_mark_node)
cond = error_mark_node;
else
{
args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
args = tree_cons (NULL, t, args);
t = build_function_call (objc_exception_match_decl, args);
cond = c_common_truthvalue_conversion (t);
}
t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
*last = t;
last = &COND_EXPR_ELSE (t);
}
}
if (!saw_id)
{
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 ();
SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
append_to_statement_list (t, last);
}
return catch_seq;
}
static tree
next_sjlj_build_try_catch_finally (void)
{
tree rethrow_decl, stack_decl, t;
tree catch_seq, try_fin, bind;
t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
stack_decl = objc_create_temporary_var (t);
cur_try_context->stack_decl = stack_decl;
rethrow_decl = objc_create_temporary_var (objc_object_type);
cur_try_context->rethrow_decl = rethrow_decl;
TREE_CHAIN (rethrow_decl) = stack_decl;
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;
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));
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));
if (cur_try_context->catch_list)
{
tree caught_decl = objc_build_exc_ptr ();
catch_seq = build_stmt (BIND_EXPR, caught_decl, NULL, NULL);
TREE_SIDE_EFFECTS (catch_seq) = 1;
t = next_sjlj_build_exc_extract (caught_decl);
append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
t = next_sjlj_build_enter_and_setjmp ();
COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (rethrow_decl);
COND_EXPR_ELSE (t) = next_sjlj_build_catch_list ();
append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
}
else
catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
t = next_sjlj_build_enter_and_setjmp ();
SET_EXPR_LOCATION (t, cur_try_context->try_locus);
COND_EXPR_THEN (t) = catch_seq;
COND_EXPR_ELSE (t) = cur_try_context->try_body;
TREE_OPERAND (try_fin, 0) = t;
t = next_sjlj_build_try_exit ();
t = build_stmt (COND_EXPR,
c_common_truthvalue_conversion (rethrow_decl),
NULL, t);
SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
append_to_statement_list (cur_try_context->finally_body,
&TREE_OPERAND (try_fin, 1));
t = tree_cons (NULL, rethrow_decl, NULL);
t = build_function_call (objc_exception_throw_decl, t);
t = build_stmt (COND_EXPR,
c_common_truthvalue_conversion (rethrow_decl),
t, NULL);
SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
return bind;
}
void
objc_begin_try_stmt (location_t try_locus, tree body)
{
struct objc_try_context *c = xcalloc (1, sizeof (*c));
c->outer = cur_try_context;
c->try_body = body;
c->try_locus = try_locus;
c->end_try_locus = input_location;
cur_try_context = c;
objc_init_exceptions ();
if (flag_objc_sjlj_exceptions)
objc_mark_locals_volatile (NULL);
}
void
objc_begin_catch_clause (tree decl)
{
tree compound, type, t;
compound = c_begin_compound_stmt (true);
if (decl == NULL_TREE)
{
if (flag_objc_zerocost_exceptions)
{
t = build_stmt (CATCH_EXPR, NULL_TREE, compound);
cur_try_context->current_catch = t;
t = build1(NOP_EXPR, ptr_type_node, objc_build_exc_ptr ());
t = build_function_call (objc2_begin_catch_decl,
tree_cons (NULL_TREE, t, NULL_TREE));
add_stmt (t);
return;
}
else
decl = create_tmp_var_raw (objc_object_type, NULL);
}
decl = build_decl (VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
lang_hooks.decls.pushdecl (decl);
TREE_USED (decl) = 1;
type = TREE_TYPE (decl);
if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
type = !flag_objc_zerocost_exceptions ? NULL : type;
else if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
{
error ("@catch parameter is not a known Objective-C class type");
type = error_mark_node;
}
else if (cur_try_context->catch_list)
{
tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
for (; !tsi_end_p (i); tsi_next (&i))
{
tree stmt = tsi_stmt (i);
t = CATCH_TYPES (stmt);
if (t == error_mark_node)
continue;
if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
{
warning (0, "exception of type %<%T%> will be caught",
TREE_TYPE (type));
warning (0, "%H by earlier handler for %<%T%>",
EXPR_LOCUS (stmt), TREE_TYPE (t ? t : objc_object_type));
break;
}
}
}
t = build_stmt (CATCH_EXPR, type, compound);
cur_try_context->current_catch = t;
t = objc_build_exc_ptr ();
t = convert (TREE_TYPE (decl), t);
if (flag_objc_zerocost_exceptions)
{
objc2_build_extern_decl_catch_object (type);
t = build1(NOP_EXPR, ptr_type_node, t);
t = build_function_call (objc2_begin_catch_decl,
tree_cons (NULL_TREE, t, NULL_TREE));
}
t = build2 (MODIFY_EXPR, void_type_node, decl, t);
add_stmt (t);
}
static tree
objc2_liteweight_finish_try_stmt (void)
{
struct objc_try_context *c = cur_try_context;
tree stmt, t;
stmt = c->try_body;
t = build_function_call (objc2_end_catch_decl, NULL_TREE);
append_to_statement_list (t, &c->finally_body);
stmt = build_stmt (TRY_FINALLY_EXPR, stmt, c->finally_body);
SET_EXPR_LOCATION (stmt, c->try_locus);
cur_try_context = c->outer;
free (c);
return stmt;
}
void
objc_finish_catch_clause (void)
{
tree c = cur_try_context->current_catch;
cur_try_context->current_catch = NULL;
cur_try_context->end_catch_locus = input_location;
CATCH_BODY (c) = c_end_compound_stmt (CATCH_BODY (c), 1);
if (flag_objc_zerocost_exceptions)
{
tree try_exp, t;
t = CATCH_BODY (c);
if (TREE_CODE (t) == BIND_EXPR)
{
objc_begin_try_stmt (cur_try_context->try_locus, BIND_EXPR_BODY (t));
try_exp = objc2_liteweight_finish_try_stmt ();
BIND_EXPR_BODY (t) = NULL_TREE;
append_to_statement_list (try_exp, &BIND_EXPR_BODY (t));
}
else
{
objc_begin_try_stmt (cur_try_context->try_locus, t);
try_exp = objc2_liteweight_finish_try_stmt ();
CATCH_BODY (c) = NULL_TREE;
append_to_statement_list (try_exp, &CATCH_BODY (c));
}
}
append_to_statement_list (c, &cur_try_context->catch_list);
}
void
objc_build_finally_clause (location_t finally_locus, tree body)
{
cur_try_context->finally_body = body;
cur_try_context->finally_locus = finally_locus;
cur_try_context->end_finally_locus = input_location;
}
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%>");
if (flag_objc_sjlj_exceptions)
{
if (!cur_try_context->finally_body)
{
cur_try_context->finally_locus = input_location;
cur_try_context->end_finally_locus = input_location;
}
stmt = next_sjlj_build_try_catch_finally ();
}
else
{
stmt = c->try_body;
if (c->catch_list)
{
stmt = build_stmt (TRY_CATCH_EXPR, stmt, c->catch_list);
SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
}
if (c->finally_body)
{
stmt = build_stmt (TRY_FINALLY_EXPR, stmt, c->finally_body);
SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
}
}
add_stmt (stmt);
cur_try_context = c->outer;
free (c);
return stmt;
}
tree
objc2_build_throw_call (tree throw_expr)
{
tree args;
objc_init_exceptions ();
if (throw_expr == NULL)
{
if (cur_try_context == NULL
|| cur_try_context->current_catch == NULL)
{
error ("%<@throw%> (rethrow) used outside of a @catch block");
return error_mark_node;
}
if (flag_objc_zerocost_exceptions)
return build_function_call (objc_rethrow_exception_decl, NULL_TREE);
throw_expr = objc_build_exc_ptr ();
}
args = tree_cons (NULL, throw_expr, NULL);
return build_function_call (objc_exception_throw_decl, args);
}
tree objc_build_throw_stmt (tree throw_expr)
{
return add_stmt (objc2_build_throw_call (throw_expr));
}
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);
SET_EXPR_LOCATION (call, start_locus);
add_stmt (call);
args = tree_cons (NULL, mutex, NULL);
call = build_function_call (objc_sync_exit_decl, args);
SET_EXPR_LOCATION (call, input_location);
objc_begin_try_stmt (start_locus, body);
objc_build_finally_clause (input_location, call);
return objc_finish_try_stmt ();
}
#ifndef OBJC_JBLEN
#define OBJC_JBLEN 18
#endif
static void
build_next_objc_exception_stuff (void)
{
tree field_decl, field_decl_chain, index, temp_type;
objc_exception_data_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
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;
index = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
field_decl = create_field_decl (build_array_type (ptr_type_node, index),
"pointers");
chainon (field_decl_chain, field_decl);
finish_struct (objc_exception_data_template, field_decl_chain, NULL_TREE);
temp_type = build_function_type (integer_type_node, NULL_TREE);
objc_setjmp_decl
= builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
temp_type
= build_function_type (objc_object_type,
tree_cons (NULL_TREE,
build_pointer_type (objc_exception_data_template),
OBJC_VOID_AT_END));
objc_exception_extract_decl
= builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
temp_type
= build_function_type (void_type_node,
tree_cons (NULL_TREE,
build_pointer_type (objc_exception_data_template),
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);
temp_type
= build_function_type (integer_type_node,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
OBJC_VOID_AT_END)));
objc_exception_match_decl
= builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
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,
ptrdiff_type_node,
OBJC_VOID_AT_END))));
if (OFFS_ASSIGNIVAR_FAST)
{
objc_assign_ivar_decl
= builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
NOT_BUILT_IN, NULL, NULL_TREE);
DECL_ATTRIBUTES (objc_assign_ivar_decl)
= tree_cons (get_identifier ("hard_coded_address"),
build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
NULL_TREE);
}
else
{
objc_assign_ivar_decl
= builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
}
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);
objc_assign_weak_decl
= builtin_function (TAG_ASSIGN_WEAK, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
temp_type = build_function_type (objc_object_type,
tree_cons (NULL_TREE,
build_pointer_type (objc_object_type),
OBJC_VOID_AT_END));
objc_read_weak_decl
= builtin_function (TAG_READ_WEAK, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
temp_type = build_function_type (ptr_type_node,
tree_cons (NULL_TREE, ptr_type_node,
tree_cons (NULL_TREE, ptr_type_node,
tree_cons (NULL_TREE, long_unsigned_type_node,
OBJC_VOID_AT_END))));
objc_memmove_collectable_decl
= builtin_function (TAG_MEMMOVE_COLLECTABLE, temp_type, 0,
NOT_BUILT_IN, NULL, NULL_TREE);
}
static void
build_objc_exception_stuff (void)
{
tree noreturn_list, nothrow_list, temp_type;
noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL);
nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL);
temp_type = build_function_type (void_type_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);
objc_sync_enter_decl
= builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
NULL, nothrow_list);
objc_sync_exit_decl
= builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
NULL, nothrow_list);
if (flag_objc_zerocost_exceptions)
{
tree type
= build_function_type (ptr_type_node,
tree_cons (NULL_TREE, ptr_type_node,
OBJC_VOID_AT_END));
objc2_begin_catch_decl = builtin_function ("objc_begin_catch",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (objc2_begin_catch_decl) = 0;
type
= build_function_type (void_type_node, OBJC_VOID_AT_END);
objc2_end_catch_decl = builtin_function ("objc_end_catch",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (objc2_end_catch_decl) = 0;
type
= build_function_type (void_type_node, OBJC_VOID_AT_END);
objc_rethrow_exception_decl = builtin_function ("objc_exception_rethrow",
type, 0, NOT_BUILT_IN,
NULL, NULL_TREE);
TREE_NOTHROW (objc_rethrow_exception_decl) = 0;
TREE_NOTHROW (objc_exception_throw_decl) = 0;
objc2_build_ehtype ();
}
}
static void
build_private_template (tree class)
{
if (!CLASS_STATIC_TEMPLATE (class))
{
tree record = objc_build_struct (class,
get_class_ivars (class, false),
CLASS_SUPER_NAME (class));
if (flag_debug_only_used_symbols && !objc_collecting_ivars
&& TYPE_STUB_DECL (record))
TREE_USED (TYPE_STUB_DECL (record)) = 1;
if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
objc_attach_attrs_to_type (record, class);
if (flag_objc_abi == 2)
CLASS_TYPE (class) = record;
}
}
static void
build_v2_protocol_template (void)
{
tree field_decl, field_decl_chain;
objc_v2_protocol_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_V2_PROTOCOL));
field_decl = create_field_decl (objc_object_type, "isa");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "protocol_name");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(objc_v2_protocol_template),
"protocol_list");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"instance_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"class_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"optionalInstanceMethods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"optionalClassMethods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_prop_list_ptr,
"properties");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (integer_type_node, "size");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (integer_type_node, "flags");
chainon (field_decl_chain, field_decl);
finish_struct (objc_v2_protocol_template, field_decl_chain, NULL_TREE);
}
static void
generate_v2_protocol_references (tree plist)
{
tree lproto;
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree proto = TREE_VALUE (lproto);
if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_NAME (proto))
{
if (! PROTOCOL_V2_FORWARD_DECL (proto))
build_v2_protocol_reference (proto);
if (PROTOCOL_LIST (proto))
generate_v2_protocol_references (PROTOCOL_LIST (proto));
}
}
}
static void
build_protocol_template (void)
{
tree field_decl, field_decl_chain;
objc_protocol_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL));
field_decl = create_field_decl (build_pointer_type
(xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROTOCOL_EXT))),
"isa");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "protocol_name");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(build_pointer_type
(objc_protocol_template)),
"protocol_list");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"instance_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"class_methods");
chainon (field_decl_chain, field_decl);
finish_struct (objc_protocol_template, field_decl_chain, NULL_TREE);
}
static tree
build_descriptor_table_initializer (tree type, tree entries)
{
tree initlist = NULL_TREE;
do
{
tree eltlist = NULL_TREE;
eltlist
= tree_cons (NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)), NULL_TREE);
eltlist
= tree_cons (NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
eltlist);
initlist
= tree_cons (NULL_TREE,
objc_build_constructor (type, nreverse (eltlist)),
initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return objc_build_constructor (build_array_type (type, 0),
nreverse (initlist));
}
static tree
build_method_prototype_list_template (tree list_type, int size)
{
tree objc_ivar_list_record;
tree field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
field_decl = create_field_decl (integer_type_node, "method_count");
field_decl_chain = field_decl;
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);
return objc_ivar_list_record;
}
static tree
build_method_prototype_template (void)
{
tree proto_record;
tree field_decl, field_decl_chain;
proto_record
= start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD_PROTOTYPE));
field_decl = create_field_decl (objc_selector_type, "_cmd");
field_decl_chain = field_decl;
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);
return proto_record;
}
static tree
objc_method_parm_type (tree type)
{
type = TREE_VALUE (TREE_TYPE (type));
if (TREE_CODE (type) == TYPE_DECL)
type = TREE_TYPE (type);
return type;
}
static int
objc_encoded_type_size (tree type)
{
int sz = int_size_in_bytes (type);
if (sz > 0 && INTEGRAL_TYPE_P (type))
sz = MAX (sz, int_size_in_bytes (integer_type_node));
else if (TREE_CODE (type) == ARRAY_TYPE)
sz = int_size_in_bytes (ptr_type_node);
return sz;
}
static tree
encode_method_prototype (tree method_decl)
{
tree parms;
int parm_offset, i;
char buf[40];
tree result;
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (method_decl)));
encode_type (objc_method_parm_type (method_decl),
obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
i = int_size_in_bytes (ptr_type_node);
parm_offset = 2 * i;
for (parms = METHOD_SEL_ARGS (method_decl); parms;
parms = TREE_CHAIN (parms))
{
tree type = objc_method_parm_type (parms);
int sz = objc_encoded_type_size (type);
if (sz < 0)
{
error ("type %q+D does not have a known size",
type);
goto finish_encoding;
}
parm_offset += sz;
}
sprintf (buf, "%d@0:%d", parm_offset, i);
obstack_grow (&util_obstack, buf, strlen (buf));
parm_offset = 2 * i;
for (parms = METHOD_SEL_ARGS (method_decl); parms;
parms = TREE_CHAIN (parms))
{
tree type = objc_method_parm_type (parms);
encode_type_qualifiers (TREE_PURPOSE (TREE_TYPE (parms)));
encode_type (type, obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
sprintf (buf, "%d", parm_offset);
parm_offset += objc_encoded_type_size (type);
obstack_grow (&util_obstack, buf, strlen (buf));
}
finish_encoding:
obstack_1grow (&util_obstack, '\0');
result = get_identifier (obstack_finish (&util_obstack));
obstack_free (&util_obstack, util_firstobj);
return result;
}
static tree
generate_descriptor_table (tree type, const char *name, int size, tree list,
tree proto, bool newabi)
{
tree decl, initlist;
const char* ref_name = synth_id_with_class_suffix (name, proto);
decl = start_var_decl (type, ref_name);
if (newabi)
{
int entsize;
set_user_assembler_name (decl, ref_name);
entsize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template));
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, entsize));
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
}
else
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, size));
initlist = tree_cons (NULL_TREE, list, initlist);
finish_var_decl (decl, objc_build_constructor (type, nreverse (initlist)));
return decl;
}
static void
generate_method_descriptors (tree protocol, bool is_optional)
{
tree initlist, chain, method_list_template;
int size;
if (!objc_method_prototype_template)
objc_method_prototype_template = build_method_prototype_template ();
chain = is_optional ? PROTOCOL_OPTIONAL_CLS_METHODS (protocol)
: PROTOCOL_CLS_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_prototype_list_template (objc_method_prototype_template,
size);
initlist
= build_descriptor_table_initializer (objc_method_prototype_template,
chain);
if (is_optional)
UOBJC_PROTOCOL_OPT_CLS_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_CLASS_METHODS_OPT",
size, initlist, protocol, false);
else
UOBJC_CLASS_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_CLASS_METHODS",
size, initlist, protocol, false);
}
else
{
if (is_optional)
UOBJC_PROTOCOL_OPT_CLS_METHODS_decl = 0;
else
UOBJC_CLASS_METHODS_decl = 0;
}
chain = is_optional ? PROTOCOL_OPTIONAL_NST_METHODS (protocol)
: PROTOCOL_NST_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_prototype_list_template (objc_method_prototype_template,
size);
initlist
= build_descriptor_table_initializer (objc_method_prototype_template,
chain);
if (is_optional)
UOBJC_PROTOCOL_OPT_NST_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_INSTANCE_METHODS_OPT",
size, initlist, protocol, false);
else
UOBJC_INSTANCE_METHODS_decl
= generate_descriptor_table (method_list_template,
"_OBJC_PROTOCOL_INSTANCE_METHODS",
size, initlist, protocol, false);
}
else
{
if (is_optional)
UOBJC_PROTOCOL_OPT_NST_METHODS_decl = 0;
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
}
static void
generate_protocol_references (tree plist)
{
tree lproto;
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree proto = TREE_VALUE (lproto);
if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_NAME (proto))
{
if (! PROTOCOL_FORWARD_DECL (proto))
build_protocol_reference (proto);
if (PROTOCOL_LIST (proto))
generate_protocol_references (PROTOCOL_LIST (proto));
}
}
}
#ifdef OBJCPLUS
static void
objc_generate_cxx_ctor_or_dtor (bool dtor)
{
tree fn, body, compound_stmt, ivar;
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), NULL_TREE);
body = begin_function_body ();
compound_stmt = begin_compound_stmt (0);
ivar = CLASS_IVARS (implementation_template);
if (dtor)
ivar = nreverse (copy_list (ivar));
for (; ivar; ivar = TREE_CHAIN (ivar))
{
if (TREE_CODE (ivar) == FIELD_DECL)
{
tree type = TREE_TYPE (ivar);
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));
}
}
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);
}
static void
objc_generate_cxx_cdtors (void)
{
bool need_ctor = false, need_dtor = false;
tree ivar;
if (!objc_implementation_context)
return;
if (TREE_CODE (objc_implementation_context) != CLASS_IMPLEMENTATION_TYPE)
return;
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))
need_ctor = true;
if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (type)
&& (!TYPE_NEEDS_CONSTRUCTING (type)
|| TYPE_HAS_DEFAULT_CONSTRUCTOR (type)))
need_dtor = true;
}
}
}
if (need_ctor)
objc_generate_cxx_ctor_or_dtor (false);
if (need_dtor)
objc_generate_cxx_ctor_or_dtor (true);
if (flag_next_runtime)
imp_list->has_cxx_cdtors = (need_ctor || need_dtor);
}
#endif
static void
generate_protocols (void)
{
tree p, encoding;
tree decl;
tree initlist, protocol_name_expr, refs_decl, refs_expr;
for (p = protocol_chain; p; p = TREE_CHAIN (p))
if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
generate_protocol_references (PROTOCOL_LIST (p));
for (p = protocol_chain; p; p = TREE_CHAIN (p))
{
tree save_objc_implementation_context;
tree nst_methods = PROTOCOL_NST_METHODS (p);
tree cls_methods = PROTOCOL_CLS_METHODS (p);
decl = PROTOCOL_FORWARD_DECL (p);
if (!decl)
continue;
add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
while (nst_methods)
{
if (! METHOD_ENCODING (nst_methods))
{
encoding = encode_method_prototype (nst_methods);
METHOD_ENCODING (nst_methods) = encoding;
}
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
if (! METHOD_ENCODING (cls_methods))
{
encoding = encode_method_prototype (cls_methods);
METHOD_ENCODING (cls_methods) = encoding;
}
cls_methods = TREE_CHAIN (cls_methods);
}
generate_method_descriptors (p, false);
if (PROTOCOL_LIST (p))
refs_decl = generate_protocol_list (p);
else
refs_decl = 0;
protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
if (refs_decl)
refs_expr = convert (build_pointer_type (build_pointer_type
(objc_protocol_template)),
build_unary_op (ADDR_EXPR, refs_decl, 0));
else
refs_expr =
convert (build_pointer_type (build_pointer_type (objc_protocol_template)),
integer_zero_node);
save_objc_implementation_context = objc_implementation_context;
objc_implementation_context = p;
generate_v2_property_tables (p);
objc_implementation_context = save_objc_implementation_context;
nst_methods = PROTOCOL_OPTIONAL_NST_METHODS (p);
cls_methods = PROTOCOL_OPTIONAL_CLS_METHODS (p);
while (nst_methods)
{
if (! METHOD_ENCODING (nst_methods))
{
encoding = encode_method_prototype (nst_methods);
METHOD_ENCODING (nst_methods) = encoding;
}
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
if (! METHOD_ENCODING (cls_methods))
{
encoding = encode_method_prototype (cls_methods);
METHOD_ENCODING (cls_methods) = encoding;
}
cls_methods = TREE_CHAIN (cls_methods);
}
generate_method_descriptors (p, true);
UOBJC_PROTOCOL_EXT_decl = generate_objc_protocol_extension (p,
UOBJC_PROTOCOL_OPT_NST_METHODS_decl,
UOBJC_PROTOCOL_OPT_CLS_METHODS_decl,
UOBJC_V2_PROPERTY_decl);
initlist = build_protocol_initializer (TREE_TYPE (decl),
protocol_name_expr, refs_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl, false, NULL_TREE,
UOBJC_PROTOCOL_EXT_decl, NULL_TREE);
finish_var_decl (decl, initlist);
}
}
static tree
build_protocol_initializer (tree type, tree protocol_name,
tree protocol_list, tree instance_methods,
tree class_methods, bool newabi, tree property_list,
tree objc_protocol_or_opt_ins_meth, tree opt_cls_meth)
{
tree initlist = NULL_TREE, expr;
if (newabi)
{
expr = convert (objc_object_type, integer_zero_node);
}
else
{
if (!objc_protocol_or_opt_ins_meth)
{
if (!objc_protocol_extension_template)
build_objc_protocol_extension_template ();
expr =
convert (build_pointer_type (objc_protocol_extension_template),
integer_zero_node);
}
else
expr = convert (build_pointer_type (objc_protocol_extension_template),
build_unary_op (ADDR_EXPR, objc_protocol_or_opt_ins_meth, 0));
}
initlist = tree_cons (NULL_TREE, expr, initlist);
initlist = tree_cons (NULL_TREE, protocol_name, initlist);
initlist = tree_cons (NULL_TREE, protocol_list, initlist);
if (!instance_methods)
initlist = tree_cons (NULL_TREE,
convert (objc_method_proto_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_proto_list_ptr,
build_unary_op (ADDR_EXPR, instance_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!class_methods)
initlist = tree_cons (NULL_TREE,
convert (objc_method_proto_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_proto_list_ptr,
build_unary_op (ADDR_EXPR, class_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (newabi)
{
if (!objc_protocol_or_opt_ins_meth)
initlist = tree_cons (NULL_TREE,
convert (objc_method_proto_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_proto_list_ptr,
build_unary_op (ADDR_EXPR, objc_protocol_or_opt_ins_meth, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!opt_cls_meth)
initlist = tree_cons (NULL_TREE,
convert (objc_method_proto_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_proto_list_ptr,
build_unary_op (ADDR_EXPR, opt_cls_meth, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!property_list)
initlist = tree_cons (NULL_TREE,
convert (objc_prop_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_prop_list_ptr,
build_unary_op (ADDR_EXPR, property_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
expr = build_int_cst (
NULL_TREE,
TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_protocol_template)));
initlist = tree_cons (NULL_TREE, expr, initlist);
initlist = tree_cons (NULL_TREE, integer_zero_node, initlist);
}
return objc_build_constructor (type, nreverse (initlist));
}
static void
build_category_template (void)
{
tree field_decl, field_decl_chain;
objc_category_template = start_struct (RECORD_TYPE,
get_identifier (UTAG_CATEGORY));
field_decl = create_field_decl (string_type_node, "category_name");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "class_name");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr,
"instance_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr,
"class_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(build_pointer_type
(objc_protocol_template)),
"protocol_list");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (integer_type_node, "size");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (
xref_tag (RECORD_TYPE,
get_identifier (UTAG_PROPERTY_LIST))),
"instance_properties");
chainon (field_decl_chain, field_decl);
finish_struct (objc_category_template, field_decl_chain, NULL_TREE);
}
static void
build_selector_template (void)
{
tree field_decl, field_decl_chain;
objc_selector_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_SELECTOR));
field_decl = create_field_decl (objc_selector_type, "sel_id");
field_decl_chain = field_decl;
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);
}
static void
build_v2_category_template (void)
{
tree field_decl, field_decl_chain;
objc_v2_category_template = start_struct (RECORD_TYPE,
get_identifier ("_category_t"));
field_decl = create_field_decl (string_type_node, "name");
field_decl_chain = field_decl;
field_decl = create_field_decl (build_pointer_type (objc_v2_class_template),
"cls");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr,
"instance_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr,
"class_methods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(objc_v2_protocol_template),
"protocol_list");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_prop_list_ptr,
"properties");
chainon (field_decl_chain, field_decl);
finish_struct (objc_v2_category_template, field_decl_chain, NULL_TREE);
}
static void
build_v2_class_template (void)
{
tree field_decl, field_decl_chain;
objc_v2_class_ro_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_V2_CLASS_RO));
objc_v2_class_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_V2_CLASS));
field_decl = create_field_decl (build_pointer_type (objc_v2_class_template),
"isa");
field_decl_chain = field_decl;
field_decl = create_field_decl (build_pointer_type (objc_v2_class_template),
"superclass");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (void_type_node),
"cache");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (objc_imp_type),
"vtable");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (objc_v2_class_ro_template),
"ro");
chainon (field_decl_chain, field_decl);
finish_struct (objc_v2_class_template, field_decl_chain, NULL_TREE);
field_decl = create_field_decl (integer_type_node, "flags");
field_decl_chain = field_decl;
field_decl = create_field_decl (integer_type_node, "instanceStart");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (integer_type_node, "instanceSize");
chainon (field_decl_chain, field_decl);
if (TARGET_64BIT)
{
field_decl = create_field_decl (integer_type_node, "reserved");
chainon (field_decl_chain, field_decl);
}
field_decl = create_field_decl (string_type_node,
"ivarLayout");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (string_type_node, "name");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr,
"baseMethods");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(xref_tag (RECORD_TYPE,
get_identifier
(UTAG_V2_PROTOCOL_LIST))),
"baseProtocols");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_v2_ivar_list_ptr,
"ivars");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (string_type_node, "weakIvarLayout");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_prop_list_ptr,
"properties");
chainon (field_decl_chain, field_decl);
finish_struct (objc_v2_class_ro_template, field_decl_chain, NULL_TREE);
}
static void
build_class_template (void)
{
tree field_decl, field_decl_chain;
objc_class_template
= start_struct (RECORD_TYPE, get_identifier (UTAG_CLASS));
field_decl = create_field_decl (build_pointer_type (objc_class_template),
"isa");
field_decl_chain = field_decl;
field_decl = create_field_decl (build_pointer_type (objc_class_template),
"super_class");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (string_type_node, "name");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (long_integer_type_node, "version");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (long_integer_type_node, "info");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (long_integer_type_node, "instance_size");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_ivar_list_ptr,
"ivars");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (objc_method_list_ptr,
"methods");
chainon (field_decl_chain, field_decl);
if (flag_next_runtime)
{
field_decl = create_field_decl (build_pointer_type
(xref_tag (RECORD_TYPE,
get_identifier
("objc_cache"))),
"cache");
chainon (field_decl_chain, field_decl);
}
else
{
field_decl = create_field_decl (build_pointer_type
(xref_tag (RECORD_TYPE,
get_identifier
("sarray"))),
"dtable");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(objc_class_template),
"subclass_list");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type
(objc_class_template),
"sibling_class");
chainon (field_decl_chain, field_decl);
}
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)
{
field_decl = create_field_decl (string_type_node, "ivar_layout");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (
xref_tag (RECORD_TYPE,
get_identifier
(UTAG_CLASS_EXT))),
"ext");
chainon (field_decl_chain, field_decl);
}
else
{
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 void
synth_forward_declarations (void)
{
tree an_id;
UOBJC_CLASS_decl = build_metadata_decl ("_OBJC_CLASS",
objc_class_template, false);
UOBJC_METACLASS_decl = build_metadata_decl ("_OBJC_METACLASS",
objc_class_template, false);
an_id = get_identifier ("super_class");
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
synth_v2_forward_declarations (void)
{
UOBJC_V2_CLASS_decl = build_metadata_decl ("OBJC_CLASS_$",
objc_v2_class_template, true);
UOBJC_V2_METACLASS_decl = build_metadata_decl ("OBJC_METACLASS_$",
objc_v2_class_template, true);
}
static void
error_with_ivar (const char *message, tree decl)
{
error ("%J%s %qs", decl,
message, gen_declaration (decl));
}
static void
check_ivars (tree inter, tree imp)
{
tree intdecls = CLASS_RAW_IVARS (inter);
tree impdecls = CLASS_RAW_IVARS (imp);
while (1)
{
tree t1, t2;
#ifdef OBJCPLUS
if (intdecls && TREE_CODE (intdecls) == TYPE_DECL)
intdecls = TREE_CHAIN (intdecls);
#endif
if (intdecls == 0 && impdecls == 0)
break;
if (intdecls == 0 || impdecls == 0)
{
error ("inconsistent instance variable specification");
break;
}
t1 = TREE_TYPE (intdecls); t2 = TREE_TYPE (impdecls);
if (!comptypes (t1, t2)
|| !tree_int_cst_equal (DECL_INITIAL (intdecls),
DECL_INITIAL (impdecls)))
{
if (DECL_NAME (intdecls) == DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable type",
impdecls);
error_with_ivar ("previous declaration of",
intdecls);
}
else
{
error ("inconsistent instance variable specification");
break;
}
}
else if (DECL_NAME (intdecls) != DECL_NAME (impdecls))
{
error_with_ivar ("conflicting instance variable name",
impdecls);
error_with_ivar ("previous declaration of",
intdecls);
}
intdecls = TREE_CHAIN (intdecls);
impdecls = TREE_CHAIN (impdecls);
}
}
static void
build_message_ref_template (void)
{
tree ptr_message_ref_t;
tree field_decl, field_decl_chain;
objc_v2_message_ref_template = start_struct (RECORD_TYPE,
get_identifier ("_message_ref_t"));
ptr_message_ref_t = build_pointer_type (xref_tag (
RECORD_TYPE, get_identifier ("_message_ref_t")));
objc_v2_imp_type
= build_pointer_type
(build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_object_type,
tree_cons (NULL_TREE, ptr_message_ref_t,
NULL_TREE))));
field_decl = create_field_decl (objc_v2_imp_type, "messenger");
field_decl_chain = field_decl;
field_decl = create_field_decl (objc_selector_type, "name");
chainon (field_decl_chain, field_decl);
finish_struct (objc_v2_message_ref_template, field_decl_chain, NULL_TREE);
objc_v2_selector_type = build_pointer_type (objc_v2_message_ref_template);
objc_v2_super_message_ref_template = start_struct (RECORD_TYPE,
get_identifier ("_super_message_ref_t"));
ptr_message_ref_t = build_pointer_type (xref_tag (
RECORD_TYPE, get_identifier ("_super_message_ref_t")));
objc_v2_super_imp_type
= build_pointer_type
(build_function_type (objc_object_type,
tree_cons (NULL_TREE, objc_super_type,
tree_cons (NULL_TREE, ptr_message_ref_t,
NULL_TREE))));
field_decl = create_field_decl (objc_v2_super_imp_type, "messenger");
field_decl_chain = field_decl;
field_decl = create_field_decl (objc_selector_type, "name");
chainon (field_decl_chain, field_decl);
finish_struct (objc_v2_super_message_ref_template, field_decl_chain, NULL_TREE);
objc_v2_super_selector_type = build_pointer_type (objc_v2_super_message_ref_template);
}
static void
build_super_template (void)
{
tree field_decl, field_decl_chain;
objc_super_template = start_struct (RECORD_TYPE, get_identifier (UTAG_SUPER));
field_decl = create_field_decl (objc_object_type, "self");
field_decl_chain = field_decl;
if (flag_objc_abi == 2)
{
field_decl = create_field_decl (objc_class_type, "cls");
}
else
{
field_decl = create_field_decl (build_pointer_type (objc_class_template),
"cls");
}
chainon (field_decl_chain, field_decl);
finish_struct (objc_super_template, field_decl_chain, NULL_TREE);
}
static tree
build_v2_ivar_t_template (void)
{
tree objc_ivar_id, objc_ivar_record;
tree field_decl, field_decl_chain;
objc_ivar_id = get_identifier ("_ivar_t");
objc_ivar_record = start_struct (RECORD_TYPE, objc_ivar_id);
field_decl = create_field_decl (
build_pointer_type (TREE_TYPE (size_zero_node)), "offset");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "name");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (string_type_node, "type");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (integer_type_node, "alignment");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (integer_type_node, "size");
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_record, field_decl_chain, NULL_TREE);
return objc_ivar_record;
}
static tree
build_v2_ivar_list_t_template (tree list_type, int size)
{
tree objc_ivar_list_record;
tree field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
field_decl = create_field_decl (integer_type_node, "entsize");
field_decl_chain = field_decl;
field_decl = create_field_decl (integer_type_node, "count");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_array_type
(list_type,
build_index_type
(build_int_cst (NULL_TREE, size - 1))),
"list");
chainon (field_decl_chain, field_decl);
finish_struct (objc_ivar_list_record, field_decl_chain, NULL_TREE);
return objc_ivar_list_record;
}
static tree
build_ivar_template (void)
{
tree objc_ivar_id, objc_ivar_record;
tree field_decl, field_decl_chain;
objc_ivar_id = get_identifier (UTAG_IVAR);
objc_ivar_record = start_struct (RECORD_TYPE, objc_ivar_id);
field_decl = create_field_decl (string_type_node, "ivar_name");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "ivar_type");
chainon (field_decl_chain, field_decl);
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);
return objc_ivar_record;
}
static tree
build_ivar_list_template (tree list_type, int size)
{
tree objc_ivar_list_record;
tree field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
field_decl = create_field_decl (integer_type_node, "ivar_count");
field_decl_chain = field_decl;
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);
return objc_ivar_list_record;
}
static tree
build_v2_method_list_template (tree list_type, int size)
{
tree method_list_t_record;
tree field_decl, field_decl_chain;
method_list_t_record = start_struct (RECORD_TYPE, NULL_TREE);
field_decl = create_field_decl (integer_type_node, "entsize");
field_decl_chain = field_decl;
field_decl = create_field_decl (integer_type_node, "method_count");
chainon (field_decl_chain, field_decl);
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 (method_list_t_record, field_decl_chain, NULL_TREE);
return method_list_t_record;
}
static tree
build_method_list_template (tree list_type, int size)
{
tree objc_ivar_list_record;
tree field_decl, field_decl_chain;
objc_ivar_list_record = start_struct (RECORD_TYPE, NULL_TREE);
field_decl = create_field_decl (objc_method_proto_list_ptr,
"method_next");
field_decl_chain = field_decl;
field_decl = create_field_decl (integer_type_node, "method_count");
chainon (field_decl_chain, field_decl);
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);
return objc_ivar_list_record;
}
static const char *
objc_class_visibility (tree class)
{
tree chain;
if (class && TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
return NULL;
gcc_assert (class && TREE_CODE (class) == CLASS_INTERFACE_TYPE);
for (chain = CLASS_ATTRIBUTES (class); chain; chain = TREE_CHAIN (chain))
if (is_attribute_p ("visibility", TREE_PURPOSE (chain)))
return TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE ((chain))));
return NULL;
}
static tree
objc_create_global_decl_for_class (tree type, const char *name, tree class)
{
tree decl = create_global_decl (type, name);
const char *visibility = objc_class_visibility (class);
if (visibility && strcmp (visibility, "hidden") == 0)
{
DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
DECL_VISIBILITY_SPECIFIED (decl) = 1;
}
else if (visibility && strcmp (visibility, "default") == 0)
{
DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
DECL_VISIBILITY_SPECIFIED (decl) = 1;
}
return decl;
}
static void
create_ivar_offset_name (char *buf, tree class_name, tree field_decl)
{
tree fname = DECL_NAME (field_decl);
sprintf (buf, "%s%s.%s", STRING_V2_IVAR_OFFSET_PREFIX,
IDENTIFIER_POINTER (class_name),
IDENTIFIER_POINTER (fname));
return;
}
static tree
ivar_offset_ref (tree class_name, tree field_decl)
{
tree decl;
char buf[512];
tree *chain;
tree iter;
bool global_var;
tree field_decl_id;
gcc_assert (field_decl);
create_ivar_offset_name (buf, class_name, field_decl);
field_decl_id = get_identifier (buf);
for (iter = ivar_offset_ref_chain; iter; iter = TREE_CHAIN (iter))
{
tree var = TREE_PURPOSE (iter);
if (DECL_NAME (var) == field_decl_id)
return var;
}
chain = &ivar_offset_ref_chain;
global_var = IVAR_PUBLIC_OR_PROTECTED (field_decl);
decl = global_var ?
objc_create_global_decl_for_class (
TREE_TYPE (size_zero_node), buf, implementation_template) :
create_hidden_decl (TREE_TYPE (size_zero_node), buf);
while (*chain)
chain = &TREE_CHAIN (*chain);
*chain = tree_cons (decl, byte_position (field_decl), NULL_TREE);
return decl;
}
static tree
build_v2_ivar_list_initializer (tree class_name, tree type, tree field_decl)
{
tree initlist = NULL_TREE;
int val;
do {
tree ivar = NULL_TREE;
if (!DECL_NAME (field_decl))
{
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
continue;
}
ivar = tree_cons (NULL_TREE,
build_unary_op (ADDR_EXPR, ivar_offset_ref (class_name, field_decl), 0),
ivar);
gcc_assert (DECL_NAME (field_decl));
ivar = tree_cons (NULL_TREE,
add_objc_string (DECL_NAME (field_decl),
meth_var_names), ivar);
encode_field_decl (field_decl,
obstack_object_size (&util_obstack),
OBJC_ENCODE_DONT_INLINE_DEFS);
obstack_1grow (&util_obstack, 0);
ivar
= tree_cons
(NULL_TREE,
add_objc_string (get_identifier (obstack_finish (&util_obstack)),
meth_var_types),
ivar);
obstack_free (&util_obstack, util_firstobj);
val = TYPE_ALIGN_UNIT (
DECL_BIT_FIELD_TYPE (field_decl) ? DECL_BIT_FIELD_TYPE (field_decl) :
TREE_TYPE (field_decl));
val = exact_log2 (val);
ivar = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, val), ivar);
val = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl));
ivar = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, val), ivar);
initlist = tree_cons (NULL_TREE,
objc_build_constructor (type, nreverse (ivar)),
initlist);
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
}
while (field_decl);
return objc_build_constructor (build_array_type (type, 0),
nreverse (initlist));
}
static tree
build_ivar_list_initializer (tree type, tree field_decl)
{
tree initlist = NULL_TREE;
do
{
tree ivar = NULL_TREE;
if (DECL_NAME (field_decl))
ivar = tree_cons (NULL_TREE,
add_objc_string (DECL_NAME (field_decl),
meth_var_names),
ivar);
else
ivar = tree_cons (NULL_TREE,
convert (string_type_node,
integer_zero_node),
ivar);
encode_field_decl (field_decl,
obstack_object_size (&util_obstack),
OBJC_ENCODE_DONT_INLINE_DEFS);
obstack_1grow (&util_obstack, 0);
ivar
= tree_cons
(NULL_TREE,
add_objc_string (get_identifier (obstack_finish (&util_obstack)),
meth_var_types),
ivar);
obstack_free (&util_obstack, util_firstobj);
ivar = tree_cons (NULL_TREE, byte_position (field_decl), ivar);
initlist = tree_cons (NULL_TREE,
objc_build_constructor (type, nreverse (ivar)),
initlist);
do
field_decl = TREE_CHAIN (field_decl);
while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
}
while (field_decl);
return objc_build_constructor (build_array_type (type, 0),
nreverse (initlist));
}
static tree
generate_ivars_list (tree type, const char *name, int size, tree list)
{
tree decl, initlist;
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_var_decl (decl,
objc_build_constructor (TREE_TYPE (decl),
nreverse (initlist)));
return decl;
}
static int
ivar_list_length (tree t)
{
int count = 0;
for (; t; t = TREE_CHAIN (t))
if (TREE_CODE (t) == FIELD_DECL)
++count;
return count;
}
static void
generate_v2_ivar_offset_ref_lists (void)
{
tree chain;
for (chain = ivar_offset_ref_chain; chain; chain = TREE_CHAIN (chain))
{
tree decl = TREE_PURPOSE (chain);
tree offset = TREE_VALUE (chain);
finish_var_decl (decl, offset);
}
}
static tree
generate_v2_ivars_list (tree type, const char *name, int ivar_t_size,
int size, tree list)
{
tree decl, initlist;
const char *ref_name = synth_id_with_class_suffix (name, objc_implementation_context);
decl = start_var_decl (type, ref_name);
set_user_assembler_name (decl, ref_name);
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, ivar_t_size));
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
initlist = tree_cons (NULL_TREE, list, initlist);
finish_var_decl (decl,
objc_build_constructor (TREE_TYPE (decl),
nreverse (initlist)));
return decl;
}
static void
generate_v2_ivar_lists (void)
{
tree initlist, ivar_list_template, chain;
int size;
generating_instance_variables = 1;
if (!objc_v2_ivar_template)
objc_v2_ivar_template = build_v2_ivar_t_template ();
UOBJC_V2_CLASS_VARIABLES_decl = 0;
chain = CLASS_IVARS (implementation_template);
if (chain)
{
tree field_decl = chain;
size = 0;
while (field_decl) {
if (TREE_CODE (field_decl) == FIELD_DECL && DECL_NAME (field_decl))
size++;
field_decl = TREE_CHAIN (field_decl);
}
ivar_list_template = build_v2_ivar_list_t_template (objc_v2_ivar_template,
size);
initlist = build_v2_ivar_list_initializer (CLASS_NAME (implementation_template),
objc_v2_ivar_template, chain);
UOBJC_V2_INSTANCE_VARIABLES_decl
= generate_v2_ivars_list (ivar_list_template, "l_OBJC_$_INSTANCE_VARIABLES",
TREE_INT_CST_LOW (
TYPE_SIZE_UNIT (objc_v2_ivar_template)),
size, initlist);
}
else
UOBJC_V2_INSTANCE_VARIABLES_decl = 0;
generating_instance_variables = 0;
}
static void
generate_ivar_lists (void)
{
tree initlist, ivar_list_template, chain;
int size;
generating_instance_variables = 1;
if (!objc_ivar_template)
objc_ivar_template = build_ivar_template ();
if (CLASS_SUPER_NAME (implementation_template) == NULL_TREE
&& (chain = TYPE_FIELDS (objc_class_template)))
{
size = ivar_list_length (chain);
ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
initlist = build_ivar_list_initializer (objc_ivar_template, chain);
UOBJC_CLASS_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_CLASS_VARIABLES",
size, initlist);
}
else
UOBJC_CLASS_VARIABLES_decl = 0;
chain = CLASS_IVARS (implementation_template);
if (chain)
{
size = ivar_list_length (chain);
ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
initlist = build_ivar_list_initializer (objc_ivar_template, chain);
UOBJC_INSTANCE_VARIABLES_decl
= generate_ivars_list (ivar_list_template, "_OBJC_INSTANCE_VARIABLES",
size, initlist);
}
else
UOBJC_INSTANCE_VARIABLES_decl = 0;
generating_instance_variables = 0;
}
static tree
build_dispatch_table_initializer (tree type, tree entries)
{
tree initlist = NULL_TREE;
do
{
tree elemlist = NULL_TREE;
elemlist = tree_cons (NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)),
NULL_TREE);
if (! METHOD_ENCODING (entries))
METHOD_ENCODING (entries) =
encode_method_prototype (entries);
elemlist = tree_cons (NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
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)),
initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return objc_build_constructor (build_array_type (type, 0),
nreverse (initlist));
}
static tree
build_method_template (void)
{
tree _SLT_record;
tree field_decl, field_decl_chain;
_SLT_record = start_struct (RECORD_TYPE, get_identifier (UTAG_METHOD));
field_decl = create_field_decl (objc_selector_type, "_cmd");
field_decl_chain = field_decl;
field_decl = create_field_decl (string_type_node, "method_types");
chainon (field_decl_chain, field_decl);
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);
return _SLT_record;
}
static tree
generate_dispatch_table (tree type, const char *name, int size, tree list, bool newabi)
{
tree decl, initlist;
int init_val = newabi
? TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template))
: 0;
const char* ref_name = synth_id_with_class_suffix (name, objc_implementation_context);
decl = start_var_decl (type, ref_name);
if (newabi)
set_user_assembler_name (decl, ref_name);
initlist = build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, init_val));
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, size), initlist);
initlist = tree_cons (NULL_TREE, list, initlist);
finish_var_decl (decl,
objc_build_constructor (TREE_TYPE (decl),
nreverse (initlist)));
return decl;
}
static void
mark_referenced_methods (void)
{
struct imp_entry *impent;
tree chain;
for (impent = imp_list; impent; impent = impent->next)
{
chain = CLASS_CLS_METHODS (impent->imp_context);
while (chain)
{
cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
chain = TREE_CHAIN (chain);
}
chain = CLASS_NST_METHODS (impent->imp_context);
while (chain)
{
cgraph_mark_needed_node (cgraph_node (METHOD_DEFINITION (chain)));
chain = TREE_CHAIN (chain);
}
}
}
static void
generate_dispatch_tables (void)
{
tree initlist, chain, method_list_template;
int size;
if (!objc_method_template)
objc_method_template = build_method_template ();
chain = CLASS_CLS_METHODS (objc_implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
UOBJC_CLASS_METHODS_decl
= generate_dispatch_table (method_list_template,
((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? "_OBJC_CLASS_METHODS"
: "_OBJC_CATEGORY_CLASS_METHODS"),
size, initlist, false);
}
else
UOBJC_CLASS_METHODS_decl = 0;
chain = CLASS_NST_METHODS (objc_implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
UOBJC_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"_OBJC_INSTANCE_METHODS",
size, initlist, false);
else
UOBJC_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"_OBJC_CATEGORY_INSTANCE_METHODS",
size, initlist, false);
}
else
UOBJC_INSTANCE_METHODS_decl = 0;
}
static void
generate_v2_dispatch_tables (void)
{
tree initlist, chain, method_list_template;
int size;
if (!objc_method_template)
objc_method_template = build_method_template ();
chain = CLASS_CLS_METHODS (objc_implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_v2_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
UOBJC_V2_CLASS_METHODS_decl
= generate_dispatch_table (method_list_template,
((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? "l_OBJC_$_CLASS_METHODS"
: "l_OBJC_$_CATEGORY_CLASS_METHODS"),
size, initlist, true);
}
else
UOBJC_V2_CLASS_METHODS_decl = 0;
chain = CLASS_NST_METHODS (objc_implementation_context);
if (chain)
{
size = list_length (chain);
method_list_template
= build_v2_method_list_template (objc_method_template, size);
initlist
= build_dispatch_table_initializer (objc_method_template, chain);
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
UOBJC_V2_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"l_OBJC_$_INSTANCE_METHODS",
size, initlist, true);
else
UOBJC_V2_INSTANCE_METHODS_decl
= generate_dispatch_table (method_list_template,
"l_OBJC_$_CATEGORY_INSTANCE_METHODS",
size, initlist, true);
}
else
UOBJC_V2_INSTANCE_METHODS_decl = 0;
}
static tree
generate_v2_protocol_list (tree i_or_p)
{
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)
plist = CLASS_PROTOCOL_LIST (i_or_p);
else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
plist = PROTOCOL_LIST (i_or_p);
else
abort ();
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_V2_FORWARD_DECL (TREE_VALUE (lproto)))
size++;
initlist = NULL_TREE;
e = build_int_cst (build_pointer_type (objc_v2_protocol_template), size);
initlist = tree_cons (NULL_TREE, e, initlist);
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree pval = TREE_VALUE (lproto);
if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_V2_FORWARD_DECL (pval))
{
e = build_unary_op (ADDR_EXPR, PROTOCOL_V2_FORWARD_DECL (pval), 0);
initlist = tree_cons (NULL_TREE, e, initlist);
}
}
if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
ref_name = synth_id_with_class_suffix ("l_OBJC_$_PROTOCOL_REFS", i_or_p);
else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
ref_name = synth_id_with_class_suffix ("l_OBJC_CLASS_PROTOCOLS_$", i_or_p);
else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
ref_name = synth_id_with_class_suffix ("l_OBJC_CATEGORY_PROTOCOLS_$", i_or_p);
else
abort ();
refs_decl = start_var_decl
(build_array_type
(build_pointer_type (objc_v2_protocol_template),
build_index_type (build_int_cst (NULL_TREE, size))),
ref_name);
set_user_assembler_name (refs_decl, ref_name);
finish_var_decl (refs_decl, objc_build_constructor (TREE_TYPE (refs_decl),
nreverse (initlist)));
return refs_decl;
}
static tree
build_v2_descriptor_table_initializer (tree type, tree entries)
{
tree initlist = NULL_TREE;
do
{
tree eltlist
= tree_cons (NULL_TREE,
build_selector (METHOD_SEL_NAME (entries)), NULL_TREE);
eltlist
= tree_cons (NULL_TREE,
add_objc_string (METHOD_ENCODING (entries),
meth_var_types),
eltlist);
eltlist = tree_cons (NULL_TREE,
convert (objc_method_list_ptr,
integer_zero_node),
eltlist);
initlist
= tree_cons (NULL_TREE,
objc_build_constructor (type, nreverse (eltlist)),
initlist);
entries = TREE_CHAIN (entries);
}
while (entries);
return objc_build_constructor (build_array_type (type, 0),
nreverse (initlist));
}
static void
generate_v2_method_descriptors (tree protocol, bool is_optional)
{
tree initlist, chain, method_list_template;
int size;
if (!objc_method_template)
objc_method_template = build_method_template ();
chain = is_optional ? PROTOCOL_OPTIONAL_CLS_METHODS (protocol)
: PROTOCOL_CLS_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_v2_method_list_template (objc_method_template, size);
initlist
= build_v2_descriptor_table_initializer (objc_method_template, chain);
if (is_optional)
UOBJC_PROTOCOL_OPT_CLS_METHODS_decl
= generate_descriptor_table (method_list_template,
"l_OBJC_$_PROTOCOL_CLASS_METHODS_OPT",
size, initlist, protocol, true);
else
UOBJC_V2_CLASS_METHODS_decl
= generate_descriptor_table (method_list_template,
"l_OBJC_$_PROTOCOL_CLASS_METHODS",
size, initlist, protocol, true);
}
else
{
if (is_optional)
UOBJC_PROTOCOL_OPT_CLS_METHODS_decl = 0;
else
UOBJC_V2_CLASS_METHODS_decl = 0;
}
chain = is_optional ? PROTOCOL_OPTIONAL_NST_METHODS (protocol)
: PROTOCOL_NST_METHODS (protocol);
if (chain)
{
size = list_length (chain);
method_list_template
= build_v2_method_list_template (objc_method_template, size);
initlist
= build_v2_descriptor_table_initializer (objc_method_template, chain);
if (is_optional)
UOBJC_PROTOCOL_OPT_NST_METHODS_decl
= generate_descriptor_table (method_list_template,
"l_OBJC_$_PROTOCOL_INSTANCE_METHODS_OPT",
size, initlist, protocol, true);
else
UOBJC_V2_INSTANCE_METHODS_decl
= generate_descriptor_table (method_list_template,
"l_OBJC_$_PROTOCOL_INSTANCE_METHODS",
size, initlist, protocol, true);
}
else
{
if (is_optional)
UOBJC_PROTOCOL_OPT_NST_METHODS_decl = 0;
else
UOBJC_V2_INSTANCE_METHODS_decl = 0;
}
}
static tree
generate_protocol_list (tree i_or_p)
{
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)
plist = CLASS_PROTOCOL_LIST (i_or_p);
else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
plist = PROTOCOL_LIST (i_or_p);
else
abort ();
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
size++;
initlist = tree_cons (NULL_TREE, integer_zero_node, NULL_TREE);
e = build_int_cst (build_pointer_type (objc_protocol_template), size);
initlist = tree_cons (NULL_TREE, e, initlist);
for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
{
tree pval = TREE_VALUE (lproto);
if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_FORWARD_DECL (pval))
{
e = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (pval), 0);
initlist = tree_cons (NULL_TREE, e, initlist);
}
}
if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE)
ref_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL_REFS", i_or_p);
else if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE)
ref_name = synth_id_with_class_suffix ("_OBJC_CLASS_PROTOCOLS", i_or_p);
else if (TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE)
ref_name = synth_id_with_class_suffix ("_OBJC_CATEGORY_PROTOCOLS", i_or_p);
else
abort ();
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_var_decl (refs_decl, objc_build_constructor (TREE_TYPE (refs_decl),
nreverse (initlist)));
return refs_decl;
}
static tree
build_category_initializer (tree type, tree cat_name, tree class_name,
tree instance_methods, tree class_methods,
tree protocol_list,
bool abi_v2, tree property_list)
{
tree initlist = NULL_TREE, expr;
initlist = tree_cons (NULL_TREE, cat_name, initlist);
initlist = tree_cons (NULL_TREE, class_name, initlist);
if (!instance_methods)
initlist = tree_cons (NULL_TREE,
convert (objc_method_list_ptr,
integer_zero_node),
initlist);
else
{
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,
convert (objc_method_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_list_ptr,
build_unary_op (ADDR_EXPR, class_methods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
{
tree protocol_list_ptr =
(abi_v2) ? build_pointer_type (objc_v2_protocol_template)
: build_pointer_type (build_pointer_type (objc_protocol_template));
if (!protocol_list)
initlist = tree_cons (NULL_TREE,
convert (protocol_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (protocol_list_ptr, build_unary_op (ADDR_EXPR, protocol_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (!abi_v2)
{
int val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_category_template));
expr = build_int_cst (NULL_TREE, val);
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!property_list)
initlist = tree_cons (NULL_TREE,
convert (objc_prop_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_prop_list_ptr,
build_unary_op (ADDR_EXPR, property_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return objc_build_constructor (type, nreverse (initlist));
}
static tree
build_shared_structure_initializer (tree type, tree isa, tree super,
tree name, tree size, int status,
tree dispatch_table, tree ivar_list,
tree protocol_list, tree objc_class_ext)
{
tree initlist = NULL_TREE, expr;
initlist = tree_cons (NULL_TREE, isa, initlist);
initlist = tree_cons (NULL_TREE, super, initlist);
initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
initlist = tree_cons (NULL_TREE, build_int_cst (long_integer_type_node, 0),
initlist);
initlist = tree_cons (NULL_TREE,
build_int_cst (long_integer_type_node, status),
initlist);
initlist = tree_cons (NULL_TREE, convert (long_integer_type_node, size),
initlist);
if (!ivar_list)
initlist = tree_cons (NULL_TREE,
convert (objc_ivar_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_ivar_list_ptr,
build_unary_op (ADDR_EXPR, ivar_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!dispatch_table)
initlist = tree_cons (NULL_TREE,
convert (objc_method_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_list_ptr,
build_unary_op (ADDR_EXPR, dispatch_table, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (flag_next_runtime)
initlist = tree_cons (NULL_TREE,
convert (build_pointer_type
(xref_tag (RECORD_TYPE,
get_identifier
("objc_cache"))),
integer_zero_node),
initlist);
else
{
tree null_objc_class_ptr =
convert (build_pointer_type (objc_class_template),
integer_zero_node);
initlist = tree_cons (NULL_TREE,
convert (build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier
("sarray"))),
integer_zero_node),
initlist);
initlist = tree_cons (NULL_TREE, null_objc_class_ptr, initlist);
initlist = tree_cons (NULL_TREE, null_objc_class_ptr, initlist);
}
{
tree objc_protocol_ptr_ptr =
build_pointer_type (build_pointer_type (objc_protocol_template));
if (!protocol_list)
initlist = tree_cons (NULL_TREE,
convert (objc_protocol_ptr_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_protocol_ptr_ptr,
build_unary_op (ADDR_EXPR, protocol_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (flag_next_runtime)
{
if (IS_CLS_META (status))
initlist = tree_cons (NULL_TREE,
convert (string_type_node,
integer_zero_node),
initlist);
else
{
tree ivar_layout = objc_build_ivar_layout (true);
if (!ivar_layout)
initlist = tree_cons (NULL_TREE,
convert (string_type_node,
integer_zero_node),
initlist);
else
initlist = tree_cons (NULL_TREE, ivar_layout, initlist);
}
if (!objc_class_ext_template)
build_objc_class_ext_template ();
{
tree objc_class_ext_ptr =
build_pointer_type (objc_class_ext_template);
if (!objc_class_ext)
initlist = tree_cons (NULL_TREE,
convert (objc_class_ext_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_class_ext_ptr,
build_unary_op (ADDR_EXPR, objc_class_ext, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
}
else
initlist = tree_cons (NULL_TREE, null_pointer_node, initlist);
return objc_build_constructor (type, nreverse (initlist));
}
static inline tree
lookup_category (tree class, tree cat_name)
{
tree category = CLASS_CATEGORY_LIST (class);
while (category && CLASS_SUPER_NAME (category) != cat_name)
category = CLASS_CATEGORY_LIST (category);
return category;
}
static void
generate_category (tree cat, struct imp_entry *impent)
{
tree decl;
tree initlist, cat_name_expr, class_name_expr;
tree protocol_decl, category;
add_class_reference (CLASS_NAME (cat));
cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
category = lookup_category (implementation_template,
CLASS_SUPER_NAME (cat));
if (category && CLASS_PROTOCOL_LIST (category))
{
generate_protocol_references (CLASS_PROTOCOL_LIST (category));
protocol_decl = generate_protocol_list (category);
}
else
protocol_decl = 0;
decl = update_var_decl(impent->class_decl);
initlist = build_category_initializer (TREE_TYPE (decl),
cat_name_expr, class_name_expr,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_CLASS_METHODS_decl,
protocol_decl,
false, UOBJC_V2_PROPERTY_decl);
finish_var_decl (decl, initlist);
}
static void
build_empty_cache_vtable_vars (void)
{
UOBJC_V2_CACHE_decl = lookup_name (get_identifier ("_objc_empty_cache"));
if (!UOBJC_V2_CACHE_decl)
UOBJC_V2_CACHE_decl = create_extern_decl (ptr_type_node, "_objc_empty_cache");
UOBJC_V2_VTABLE_decl = lookup_name (get_identifier ("_objc_empty_vtable"));
if (!UOBJC_V2_VTABLE_decl)
UOBJC_V2_VTABLE_decl = create_extern_decl (objc_imp_type, "_objc_empty_vtable");
}
static void
generate_v2_category (tree cat, struct imp_entry *impent)
{
tree decl;
tree initlist, cat_name_expr, class_name_expr;
tree protocol_decl, category;
cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
(void)objc_v2_get_class_reference (CLASS_NAME (cat));
class_name_expr = create_extern_decl (objc_v2_class_template,
objc_build_internal_classname (
CLASS_NAME (cat), false));
class_name_expr = build_fold_addr_expr (class_name_expr);
category = lookup_category (implementation_template,
CLASS_SUPER_NAME (cat));
if (category && CLASS_PROTOCOL_LIST (category))
{
generate_v2_protocol_references (CLASS_PROTOCOL_LIST (category));
protocol_decl = generate_v2_protocol_list (category);
}
else
protocol_decl = 0;
decl = update_var_decl(impent->class_v2_decl);
initlist = build_category_initializer (TREE_TYPE (decl),
cat_name_expr, class_name_expr,
UOBJC_V2_INSTANCE_METHODS_decl,
UOBJC_V2_CLASS_METHODS_decl,
protocol_decl,
true, UOBJC_V2_PROPERTY_decl);
finish_var_decl (decl, initlist);
objc_add_to_category_list_chain (decl);
if (CLASS_OR_CATEGORY_HAS_LOAD_IMPL (objc_implementation_context) != NULL_TREE)
objc_add_to_nonlazy_category_list_chain (decl);
}
static const char *
newabi_append_ro (const char *name)
{
char *dollar;
char *p;
static char string[BUFSIZE];
dollar = strchr (name, '$');
gcc_assert (dollar);
p = string;
*p = 'l'; p++;
*p = '_'; p++;
strncpy (p, name, (int)(dollar - name));
p += (int)(dollar - name);
sprintf (p, "RO_%s", dollar);
return string;
}
static tree
build_class_t_initializer (tree type, tree isa, tree superclass, tree ro, tree cache, tree vtable)
{
tree initlist = NULL_TREE;
initlist = tree_cons (NULL_TREE, isa, initlist);
initlist = tree_cons (NULL_TREE, superclass, initlist);
if (cache)
initlist = tree_cons (NULL_TREE, cache, initlist);
else
initlist = tree_cons (NULL_TREE, null_pointer_node, initlist);
if (vtable)
initlist = tree_cons (NULL_TREE, vtable, initlist);
else
initlist = tree_cons (NULL_TREE,
convert (build_pointer_type (objc_imp_type),
integer_zero_node),
initlist);
initlist = tree_cons (NULL_TREE, ro, initlist);
return objc_build_constructor (type, nreverse (initlist));
}
static tree
build_class_ro_t_initializer (tree type, tree name,
unsigned int flags, unsigned int instanceStart, unsigned int instanceSize,
tree ivarLayout,
tree baseMethods, tree baseProtocols, tree ivars,
tree weakIvarLayout,
tree property_list)
{
tree initlist = NULL_TREE, expr;
initlist = tree_cons (NULL_TREE,
build_int_cst (integer_type_node, flags),
initlist);
initlist = tree_cons (NULL_TREE,
build_int_cst (integer_type_node, instanceStart),
initlist);
initlist = tree_cons (NULL_TREE,
build_int_cst (integer_type_node, instanceSize),
initlist);
if (TARGET_64BIT)
initlist = tree_cons (NULL_TREE,
build_int_cst (integer_type_node, 0),
initlist);
if (!ivarLayout)
initlist = tree_cons (NULL_TREE,
convert (string_type_node,
integer_zero_node),
initlist);
else
initlist = tree_cons (NULL_TREE, ivarLayout, initlist);
initlist = tree_cons (NULL_TREE, default_conversion (name), initlist);
if (!baseMethods)
initlist = tree_cons (NULL_TREE,
convert (objc_method_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_method_list_ptr,
build_unary_op (ADDR_EXPR, baseMethods, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
{
tree protocol_list_t_p =
build_pointer_type (xref_tag (RECORD_TYPE,
get_identifier (UTAG_V2_PROTOCOL_LIST)));
if (!baseProtocols)
initlist = tree_cons (NULL_TREE,
convert (protocol_list_t_p,
integer_zero_node),
initlist);
else
{
expr = convert (protocol_list_t_p,
build_unary_op (ADDR_EXPR, baseProtocols, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
}
if (!ivars)
initlist = tree_cons (NULL_TREE,
convert (objc_v2_ivar_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_v2_ivar_list_ptr,
build_unary_op (ADDR_EXPR, ivars, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
if (!weakIvarLayout)
initlist = tree_cons (NULL_TREE,
convert (string_type_node,
integer_zero_node),
initlist);
else
initlist = tree_cons (NULL_TREE, weakIvarLayout, initlist);
if (!property_list)
initlist = tree_cons (NULL_TREE,
convert (objc_prop_list_ptr,
integer_zero_node),
initlist);
else
{
expr = convert (objc_prop_list_ptr,
build_unary_op (ADDR_EXPR, property_list, 0));
initlist = tree_cons (NULL_TREE, expr, initlist);
}
return objc_build_constructor (type, nreverse (initlist));
}
static void
objc_add_to_protocol_list_chain (tree protocol_interface_decl, tree protocol_decl)
{
tree *chain;
for (chain = &protocol_list_chain; *chain; chain = &TREE_CHAIN (*chain))
;
*chain = tree_cons (protocol_interface_decl, protocol_decl, NULL_TREE);
}
static void
build_protocol_list_address_table (void)
{
tree chain;
tree list_chain = protocol_list_chain;
char *string = NULL;
unsigned int buf_size = 0;
for (chain = list_chain; chain; chain = TREE_CHAIN (chain))
{
tree decl = TREE_PURPOSE (chain);
tree expr = TREE_VALUE (chain);
gcc_assert (decl && TREE_CODE (decl) == PROTOCOL_INTERFACE_TYPE);
if ((strlen ("l_OBJC_LABEL_PROTOCOL_$_") + strlen (IDENTIFIER_POINTER (PROTOCOL_NAME (decl))) + 1) > buf_size)
{
if (!buf_size)
buf_size = BUFSIZE;
else
buf_size = strlen ("l_OBJC_LABEL_PROTOCOL_$_") + strlen (IDENTIFIER_POINTER (PROTOCOL_NAME (decl))) + 1;
string = (char *)alloca (buf_size);
}
sprintf (string, "l_OBJC_LABEL_PROTOCOL_$_%s", IDENTIFIER_POINTER (PROTOCOL_NAME (decl)));
decl = create_hidden_decl (objc_protocol_type, string);
DECL_WEAK (decl) = 1;
set_user_assembler_name (decl, string);
expr = convert (objc_protocol_type, build_fold_addr_expr (expr));
objc_set_alignment_attribute (decl, objc_protocol_type);
finish_var_decl (decl, expr);
}
}
static void
build_protocollist_translation_table (void)
{
tree chain;
static char string[BUFSIZE];
for (chain = protocollist_ref_chain; chain; chain = TREE_CHAIN (chain))
{
tree expr = TREE_VALUE (chain);
tree decl = TREE_PURPOSE (chain);
gcc_assert (TREE_CODE (expr) == PROTOCOL_INTERFACE_TYPE);
if (flag_objc_abi == 2)
{
sprintf (string, "l_OBJC_PROTOCOL_$_%s",
IDENTIFIER_POINTER (PROTOCOL_NAME (expr)));
expr = start_var_decl (objc_v2_protocol_template, string);
set_user_assembler_name (expr, string);
}
else
{
sprintf (string, "_OBJC_PROTOCOL_$_%s",
IDENTIFIER_POINTER (PROTOCOL_NAME (expr)));
expr = start_var_decl (objc_v2_protocol_template, string);
}
expr = convert (objc_protocol_type, build_fold_addr_expr (expr));
finish_var_decl (decl, expr);
}
}
static tree
objc_v2_get_protocol_reference (tree ident)
{
tree *chain;
tree decl;
for (chain = &protocollist_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
if (TREE_VALUE (*chain) == ident)
{
if (! TREE_PURPOSE (*chain))
TREE_PURPOSE (*chain) = build_protocollist_reference_decl (ident);
return TREE_PURPOSE (*chain);
}
decl = build_protocollist_reference_decl (ident);
*chain = tree_cons (decl, ident, NULL_TREE);
return decl;
}
static tree
build_protocollist_reference_decl (tree protocol)
{
tree decl;
tree protocol_ident = PROTOCOL_NAME (protocol);
char *buf = (char *)alloca (strlen ("l_OBJC_PROTOCOL_REFERENCE_$_") +
IDENTIFIER_LENGTH (protocol_ident) + 1);
sprintf (buf, "l_OBJC_PROTOCOL_REFERENCE_$_%s", IDENTIFIER_POINTER (protocol_ident));
decl = create_hidden_decl (objc_protocol_type, buf);
DECL_WEAK (decl) = 1;
set_user_assembler_name (decl, buf);
return decl;
}
static void
objc_add_to_nonlazy_class_list_chain (tree global_class_decl)
{
tree *chain;
for (chain = &nonlazy_class_list_chain; *chain; chain = &TREE_CHAIN (*chain))
;
*chain = tree_cons (NULL_TREE, global_class_decl, NULL_TREE);
}
static void
objc_add_to_class_list_chain (tree global_class_decl)
{
tree *chain;
for (chain = &class_list_chain; *chain; chain = &TREE_CHAIN (*chain))
;
*chain = tree_cons (NULL_TREE, global_class_decl, NULL_TREE);
}
static void
objc_add_to_nonlazy_category_list_chain (tree global_category_decl)
{
tree *chain;
for (chain = &nonlazy_category_list_chain; *chain; chain = &TREE_CHAIN (*chain))
;
*chain = tree_cons (NULL_TREE, global_category_decl, NULL_TREE);
}
static void
objc_add_to_category_list_chain (tree global_category_decl)
{
tree *chain;
for (chain = &category_list_chain; *chain; chain = &TREE_CHAIN (*chain))
;
*chain = tree_cons (NULL_TREE, global_category_decl, NULL_TREE);
}
static void
generate_v2_shared_structures (int cls_flags)
{
tree sc_spec, decl_specs, decl;
tree name_expr, root_expr = NULL_TREE;
tree my_super_id = NULL_TREE;
tree initlist, protocol_decl;
unsigned int instanceStart, instanceSize;
tree ivarLayout;
tree weakIvarLayout;
tree metaclass_decl, class_decl;
tree field, firstIvar;
tree class_superclass_expr, metaclass_superclass_expr;
unsigned int flags = 0x1;
const char* ref_name;
class_decl = objc_create_global_decl_for_class (
objc_v2_class_template,
IDENTIFIER_POINTER (DECL_NAME (UOBJC_V2_CLASS_decl)),
implementation_template);
metaclass_decl = objc_create_global_decl_for_class (
objc_v2_class_template,
IDENTIFIER_POINTER (DECL_NAME (UOBJC_V2_METACLASS_decl)),
implementation_template);
if (DECL_VISIBILITY (class_decl) == VISIBILITY_HIDDEN)
flags |= OBJC2_CLS_HIDDEN;
my_super_id = CLASS_SUPER_NAME (implementation_template);
if (my_super_id)
{
tree sav;
tree my_root_id = my_super_id;
tree my_root_int;
tree interface;
do
{
my_root_int = lookup_interface (my_root_id);
if (my_root_int && CLASS_SUPER_NAME (my_root_int))
my_root_id = CLASS_SUPER_NAME (my_root_int);
else
break;
}
while (1);
sav = objc_implementation_context;
objc_implementation_context = my_root_int;
root_expr = build_metadata_decl ("OBJC_METACLASS_$", objc_v2_class_template, true);
root_expr = build_fold_addr_expr (root_expr);
interface = lookup_interface (my_super_id);
gcc_assert (interface);
objc_implementation_context = interface;
class_superclass_expr = build_metadata_decl ("OBJC_CLASS_$", objc_v2_class_template, true);
class_superclass_expr = build_fold_addr_expr (class_superclass_expr);
metaclass_superclass_expr = build_metadata_decl ("OBJC_METACLASS_$", objc_v2_class_template, true);
metaclass_superclass_expr = build_fold_addr_expr (metaclass_superclass_expr);
objc_implementation_context = sav;
}
else
{
root_expr = build_unary_op (ADDR_EXPR, metaclass_decl, 0);
metaclass_superclass_expr = build_unary_op (ADDR_EXPR, class_decl, 0);
class_superclass_expr = convert (build_pointer_type (objc_v2_class_template),
integer_zero_node);
flags |= 0x2;
}
if (CLASS_PROTOCOL_LIST (implementation_template))
{
generate_v2_protocol_references
(CLASS_PROTOCOL_LIST (implementation_template));
protocol_decl = generate_v2_protocol_list (implementation_template);
}
else
protocol_decl = 0;
instanceStart = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template));
instanceSize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_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_v2_class_ro_template, sc_spec);
ref_name = newabi_append_ro (
IDENTIFIER_POINTER (DECL_NAME (UOBJC_V2_METACLASS_decl)));
decl = start_var_decl (objc_v2_class_ro_template, ref_name);
set_user_assembler_name (decl, ref_name);
initlist = build_class_ro_t_initializer
(TREE_TYPE (decl),
name_expr,
(flags | cls_flags), instanceStart, instanceSize,
NULL_TREE, UOBJC_V2_CLASS_METHODS_decl, protocol_decl,
UOBJC_V2_CLASS_VARIABLES_decl,
NULL_TREE,
NULL_TREE);
finish_var_decl (decl, initlist);
build_empty_cache_vtable_vars ();
initlist = build_class_t_initializer (TREE_TYPE (metaclass_decl),
root_expr,
metaclass_superclass_expr,
build_fold_addr_expr (decl),
build_fold_addr_expr (UOBJC_V2_CACHE_decl),
build_fold_addr_expr (UOBJC_V2_VTABLE_decl));
finish_var_decl (metaclass_decl, initlist);
flags = 0x0;
if (DECL_VISIBILITY (class_decl) == VISIBILITY_HIDDEN)
flags |= OBJC2_CLS_HIDDEN;
if (!my_super_id)
flags |= 0x2;
if (objc2_objc_exception_attr (implementation_template))
flags |= 0x20;
gcc_assert (CLASS_TYPE (implementation_template));
field = TYPE_FIELDS (CLASS_TYPE (implementation_template));
if (UOBJC_V2_INSTANCE_VARIABLES_decl
&& my_super_id && field && TREE_CHAIN (field))
field = TREE_CHAIN (field);
firstIvar = field;
while (firstIvar && TREE_CODE (firstIvar) != FIELD_DECL)
firstIvar = TREE_CHAIN (firstIvar);
gcc_assert (UOBJC_V2_INSTANCE_VARIABLES_decl? (firstIvar != NULL_TREE): true);
while (field && TREE_CHAIN (field)
&& TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
field = TREE_CHAIN (field);
if (field && TREE_CODE (field) == FIELD_DECL)
instanceSize = int_byte_position (field) * BITS_PER_UNIT + tree_low_cst (DECL_SIZE (field), 0);
else
instanceSize = 0;
instanceSize /= BITS_PER_UNIT;
instanceStart = UOBJC_V2_INSTANCE_VARIABLES_decl
? (unsigned int) int_byte_position (firstIvar)
: instanceSize;
ref_name = newabi_append_ro (IDENTIFIER_POINTER (DECL_NAME (UOBJC_V2_CLASS_decl)));
decl = start_var_decl (objc_v2_class_ro_template, ref_name);
set_user_assembler_name (decl, ref_name);
ivarLayout = objc_build_ivar_layout (true);
weakIvarLayout = objc_build_ivar_layout (false);
initlist = build_class_ro_t_initializer (TREE_TYPE (decl),
name_expr,
(flags | cls_flags), instanceStart, instanceSize,
ivarLayout, UOBJC_V2_INSTANCE_METHODS_decl, protocol_decl,
UOBJC_V2_INSTANCE_VARIABLES_decl,
weakIvarLayout,
UOBJC_V2_PROPERTY_decl);
finish_var_decl (decl, initlist);
initlist = build_class_t_initializer (TREE_TYPE (class_decl),
build_fold_addr_expr (metaclass_decl),
class_superclass_expr,
build_fold_addr_expr (decl),
build_fold_addr_expr (UOBJC_V2_CACHE_decl),
build_fold_addr_expr (UOBJC_V2_VTABLE_decl));
finish_var_decl (class_decl, initlist);
objc_add_to_class_list_chain (class_decl);
if (CLASS_OR_CATEGORY_HAS_LOAD_IMPL (objc_implementation_context) != NULL_TREE)
objc_add_to_nonlazy_class_list_chain (class_decl);
if (flag_objc_zerocost_exceptions && (flags & 0x20))
objc2_build_ehtype_var_decl (CLASS_NAME (implementation_template),
false, false);
}
static void
generate_shared_structures (int cls_flags)
{
tree sc_spec, decl_specs, decl;
tree name_expr, super_expr, root_expr;
tree my_root_id = NULL_TREE, my_super_id = NULL_TREE;
tree cast_type, initlist, protocol_decl;
const char *visibility = objc_class_visibility (implementation_template);
int hidden_flag = (visibility && strcmp (visibility, "hidden") == 0) ? CLS_HIDDEN : 0;
my_super_id = CLASS_SUPER_NAME (implementation_template);
if (my_super_id)
{
add_class_reference (my_super_id);
my_root_id = my_super_id;
do
{
tree my_root_int = lookup_interface (my_root_id);
if (my_root_int && CLASS_SUPER_NAME (my_root_int))
my_root_id = CLASS_SUPER_NAME (my_root_int);
else
break;
}
while (1);
}
else
my_root_id = CLASS_NAME (implementation_template);
cast_type = build_pointer_type (objc_class_template);
name_expr = add_objc_string (CLASS_NAME (implementation_template),
class_names);
if (my_super_id)
{
super_expr = add_objc_string (my_super_id, class_names);
super_expr = build_c_cast (cast_type, super_expr);
}
else
{
super_expr = convert (string_type_node,
integer_zero_node);
super_expr = build_c_cast (cast_type, super_expr);
}
root_expr = add_objc_string (my_root_id, class_names);
root_expr = build_c_cast (cast_type, root_expr);
if (CLASS_PROTOCOL_LIST (implementation_template))
{
generate_protocol_references
(CLASS_PROTOCOL_LIST (implementation_template));
protocol_decl = generate_protocol_list (implementation_template);
}
else
protocol_decl = 0;
sc_spec = build_tree_list (NULL_TREE, ridpointers[(int) RID_STATIC]);
decl_specs = tree_cons (NULL_TREE, objc_class_template, sc_spec);
decl = update_var_decl (UOBJC_METACLASS_decl);
initlist
= build_shared_structure_initializer
(TREE_TYPE (decl),
root_expr, super_expr, name_expr,
convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
CLS_META | hidden_flag,
UOBJC_CLASS_METHODS_decl,
UOBJC_CLASS_VARIABLES_decl,
protocol_decl, NULL_TREE);
finish_var_decl (decl, initlist);
decl = update_var_decl (UOBJC_CLASS_decl);
initlist
= build_shared_structure_initializer
(TREE_TYPE (decl),
build_unary_op (ADDR_EXPR, UOBJC_METACLASS_decl, 0),
super_expr, name_expr,
convert (integer_type_node,
TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE
(implementation_template))),
CLS_FACTORY | hidden_flag | cls_flags,
UOBJC_INSTANCE_METHODS_decl,
UOBJC_INSTANCE_VARIABLES_decl,
protocol_decl, UOBJC_CLASS_EXT_decl);
finish_var_decl (decl, initlist);
}
static const char *
synth_id_with_class_suffix (const char *preamble, tree ctxt)
{
static char string[BUFSIZE];
if (TREE_CODE (ctxt) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CLASS_INTERFACE_TYPE)
{
sprintf (string, "%s_%s", preamble,
IDENTIFIER_POINTER (CLASS_NAME (ctxt)));
}
else if (TREE_CODE (ctxt) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (ctxt) == CATEGORY_INTERFACE_TYPE)
{
const char *const class_name
= IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
const char *const class_super_name
= IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context));
if (flag_objc_abi == 2)
sprintf (string, "%s_%s_$_%s", preamble, class_name, class_super_name);
else
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));
sprintf (string, "%s_%s", preamble, protocol_name);
}
else
abort ();
return string;
}
static tree
adjust_type_for_id_default (tree type)
{
if (!type)
type = make_node (TREE_LIST);
if (!TREE_VALUE (type))
TREE_VALUE (type) = objc_object_type;
else if (TREE_CODE (TREE_VALUE (type)) == RECORD_TYPE
&& TYPED_OBJECT (TREE_VALUE (type)))
error ("can not use an object as parameter to a method");
return type;
}
tree
objc_build_keyword_decl (tree key_name, tree arg_type, tree arg_name, tree arg_attr)
{
tree keyword_decl;
arg_type = adjust_type_for_id_default (arg_type);
keyword_decl = make_node (KEYWORD_DECL);
TREE_TYPE (keyword_decl) = arg_type;
KEYWORD_ARG_NAME (keyword_decl) = arg_name;
KEYWORD_ARG_ATTRIBUTE (keyword_decl) = arg_attr;
KEYWORD_KEY_NAME (keyword_decl) = key_name;
return keyword_decl;
}
static tree
build_keyword_selector (tree selector)
{
int len = 0;
tree key_chain, key_name;
char *buf;
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
if (TREE_CODE (selector) == KEYWORD_DECL)
key_name = KEYWORD_KEY_NAME (key_chain);
else if (TREE_CODE (selector) == TREE_LIST)
key_name = TREE_PURPOSE (key_chain);
else
abort ();
if (key_name)
len += IDENTIFIER_LENGTH (key_name) + 1;
else
len++;
}
buf = (char *) alloca (len + 1);
buf[0] = '\0';
for (key_chain = selector; key_chain; key_chain = TREE_CHAIN (key_chain))
{
if (TREE_CODE (selector) == KEYWORD_DECL)
key_name = KEYWORD_KEY_NAME (key_chain);
else if (TREE_CODE (selector) == TREE_LIST)
{
key_name = TREE_PURPOSE (key_chain);
TREE_PURPOSE (key_chain) = NULL_TREE;
}
else
abort ();
if (key_name)
strcat (buf, IDENTIFIER_POINTER (key_name));
strcat (buf, ":");
}
return get_identifier (buf);
}
static tree
build_method_decl (enum tree_code code, tree ret_type, tree selector,
tree add_args, bool ellipsis)
{
tree method_decl;
ret_type = adjust_type_for_id_default (ret_type);
method_decl = make_node (code);
TREE_TYPE (method_decl) = ret_type;
if (TREE_CODE (selector) == KEYWORD_DECL)
{
METHOD_SEL_NAME (method_decl) = build_keyword_selector (selector);
METHOD_SEL_ARGS (method_decl) = selector;
METHOD_ADD_ARGS (method_decl) = add_args;
METHOD_ADD_ARGS_ELLIPSIS_P (method_decl) = ellipsis;
}
else
{
METHOD_SEL_NAME (method_decl) = selector;
METHOD_SEL_ARGS (method_decl) = NULL_TREE;
METHOD_ADD_ARGS (method_decl) = NULL_TREE;
}
return method_decl;
}
#define METHOD_DEF 0
#define METHOD_REF 1
static void
objc_delta_format_args (tree format)
{
tree format_num_expr, first_arg_num_expr;
int val;
tree args = TREE_VALUE (format);
gcc_assert (TREE_CHAIN (args) && TREE_CHAIN (TREE_CHAIN (args)));
format_num_expr = TREE_VALUE (TREE_CHAIN (args));
first_arg_num_expr = TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args)));
if (format_num_expr && TREE_CODE (format_num_expr) == INTEGER_CST)
{
val = TREE_INT_CST_LOW (format_num_expr);
TREE_VALUE (TREE_CHAIN (args)) = build_int_cst (NULL_TREE, val+2);
}
if (first_arg_num_expr && TREE_CODE (first_arg_num_expr) == INTEGER_CST)
{
val = TREE_INT_CST_LOW (first_arg_num_expr);
if (val != 0)
TREE_VALUE (TREE_CHAIN (TREE_CHAIN (args))) = build_int_cst (NULL_TREE, val+2);
}
}
static bool
objc_any_recognized_attribute (tree attributes)
{
tree chain;
bool res = false;
for (chain = attributes; chain; chain = TREE_CHAIN (chain))
{
if (is_attribute_p ("format", TREE_PURPOSE (chain)))
{
objc_delta_format_args (chain);
res = true;
}
else if (is_attribute_p ("sentinel", TREE_PURPOSE (chain)))
res = true;
}
return res;
}
static void
objc_decl_method_attributes (tree *node, tree attributes, int flags)
{
if (objc_any_recognized_attribute (attributes))
{
tree rettype = TREE_TYPE (*node);
TREE_TYPE (*node) = build_function_type (TREE_VALUE (rettype),
get_arg_type_list (METHOD_SEL_NAME (*node),
*node, METHOD_REF, 0));
decl_attributes (node, attributes, flags);
METHOD_TYPE_ATTRIBUTES (*node) = TYPE_ATTRIBUTES (TREE_TYPE (*node));
TREE_TYPE (*node) = rettype;
}
else
decl_attributes (node, attributes, flags);
}
static tree
get_arg_type_list (tree sel_name, tree meth, int context, int superflag)
{
tree arglist, akey;
if (flag_next_runtime && superflag)
arglist = build_tree_list (NULL_TREE, objc_super_type);
else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
arglist = build_tree_list (NULL_TREE, objc_instance_type);
else
arglist = build_tree_list (NULL_TREE, objc_object_type);
chainon (arglist, build_tree_list (NULL_TREE, flag_objc_abi == 2
&& !objc_legacy_dispatched_selector_p (sel_name)
? (superflag
? objc_v2_super_selector_type
: objc_v2_selector_type)
: objc_selector_type));
if (!meth)
return arglist;
for (akey = METHOD_SEL_ARGS (meth); akey; akey = TREE_CHAIN (akey))
{
tree arg_type = TREE_VALUE (TREE_TYPE (akey));
arg_type = objc_decay_parm_type (arg_type);
chainon (arglist, build_tree_list (NULL_TREE, arg_type));
}
if (METHOD_ADD_ARGS (meth))
{
for (akey = TREE_CHAIN (METHOD_ADD_ARGS (meth));
akey; akey = TREE_CHAIN (akey))
{
tree arg_type = TREE_TYPE (TREE_VALUE (akey));
arg_type = objc_decay_parm_type (arg_type);
chainon (arglist, build_tree_list (NULL_TREE, arg_type));
}
if (!METHOD_ADD_ARGS_ELLIPSIS_P (meth))
goto lack_of_ellipsis;
}
else
{
lack_of_ellipsis:
chainon (arglist, OBJC_VOID_AT_END);
}
return arglist;
}
static tree
check_duplicates (hash hsh, int methods, int is_class)
{
tree meth = NULL_TREE;
if (hsh)
{
meth = hsh->key;
if (hsh->list)
{
attr loop;
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);
}
}
return meth;
}
static tree
receiver_is_class_object (tree receiver, int self, int super)
{
tree chain, exp, arg;
if (objc_method_context
&& TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
&& (self || super))
return (super
? CLASS_SUPER_NAME (implementation_template)
: CLASS_NAME (implementation_template));
if (flag_next_runtime)
{
if (TREE_CODE (receiver) == VAR_DECL && IS_CLASS (TREE_TYPE (receiver)))
for (chain = (flag_objc_abi == 2)
? classlist_ref_chain
: cls_ref_chain; chain; chain = TREE_CHAIN (chain))
if (TREE_PURPOSE (chain) == receiver)
return TREE_VALUE (chain);
}
if (TREE_CODE (receiver) == CALL_EXPR
&& (exp = TREE_OPERAND (receiver, 0))
&& TREE_CODE (exp) == ADDR_EXPR
&& (exp = TREE_OPERAND (exp, 0))
&& TREE_CODE (exp) == FUNCTION_DECL
&& TREE_TYPE (exp) == TREE_TYPE (objc_get_class_decl)
&& !strcmp (IDENTIFIER_POINTER (DECL_NAME (exp)), TAG_GETCLASS)
&& (arg = TREE_OPERAND (receiver, 1))
&& TREE_CODE (arg) == TREE_LIST
&& (arg = TREE_VALUE (arg)))
{
STRIP_NOPS (arg);
if (TREE_CODE (arg) == ADDR_EXPR
&& (arg = TREE_OPERAND (arg, 0))
&& TREE_CODE (arg) == STRING_CST)
return get_identifier (TREE_STRING_POINTER (arg));
}
return 0;
}
static tree current_objc_message_selector = 0;
tree
objc_message_selector (void)
{
return current_objc_message_selector;
}
tree
objc_build_message_expr (tree mess)
{
tree receiver = TREE_PURPOSE (mess);
tree sel_name;
#ifdef OBJCPLUS
tree args = TREE_PURPOSE (TREE_VALUE (mess));
#else
tree args = TREE_VALUE (mess);
#endif
tree method_params = NULL_TREE;
if (TREE_CODE (receiver) == ERROR_MARK || TREE_CODE (args) == ERROR_MARK)
return error_mark_node;
if (TREE_CODE (args) == IDENTIFIER_NODE)
sel_name = args;
else if (TREE_CODE (args) == TREE_LIST)
sel_name = build_keyword_selector (args);
else
abort ();
if (TREE_CODE (args) == TREE_LIST)
#ifdef OBJCPLUS
method_params = chainon (args, TREE_VALUE (TREE_VALUE (mess)));
#else
{
tree chain = args, prev = NULL_TREE;
while (chain)
{
tree element = TREE_VALUE (chain);
if (TREE_CODE (element) == TREE_LIST)
{
if (prev)
TREE_CHAIN (prev) = element;
else
args = element;
}
prev = chain;
chain = TREE_CHAIN (chain);
}
method_params = args;
}
#endif
#ifdef OBJCPLUS
if (processing_template_decl)
return build_min_nt (MESSAGE_SEND_EXPR, receiver, sel_name,
method_params);
#endif
return objc_finish_message_expr (receiver, sel_name, method_params);
}
static tree
lookup_method_in_hash_lists (tree sel_name, int is_class)
{
hash method_prototype = NULL;
if (!is_class)
method_prototype = hash_lookup (nst_method_hash_list,
sel_name);
if (!method_prototype)
{
method_prototype = hash_lookup (cls_method_hash_list,
sel_name);
is_class = 1;
}
return check_duplicates (method_prototype, 1, is_class);
}
tree
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;
int self, super, have_cast;
bool forward_class = false;
if (receiver == error_mark_node || TREE_TYPE (receiver) == error_mark_node)
return receiver;
if (TREE_CODE (TREE_TYPE (receiver)) == BLOCK_POINTER_TYPE)
receiver = convert (objc_object_type, receiver);
rtype = objc_get_inner_exp (receiver);
self = (rtype == self_decl);
super = (rtype == UOBJC_SUPER_decl);
rtype = TREE_TYPE (receiver);
have_cast = (TREE_CODE (receiver) == NOP_EXPR
|| (TREE_CODE (receiver) == COMPOUND_EXPR
&& !IS_SUPER (rtype)));
if (super && !strcmp ("dealloc", IDENTIFIER_POINTER (sel_name)))
should_call_super_dealloc = 0;
if (super && !strcmp ("finalize", IDENTIFIER_POINTER (sel_name)))
should_call_super_finalize = 0;
class_tree = receiver_is_class_object (receiver, self, super);
if (!have_cast)
{
if (class_tree)
{
tree interface_record_type = NULL;
rtype = lookup_interface (class_tree);
if (rtype)
interface_record_type =
c_return_interface_record_type (OBJC_TYPE_NAME (rtype));
if (interface_record_type != NULL)
used_types_insert (interface_record_type);
forward_class = !rtype;
}
else if (super)
{
if (!CLASS_SUPER_NAME (implementation_template))
{
error ("no super class declared in @interface for %qs",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
rtype = lookup_interface (CLASS_SUPER_NAME (implementation_template));
}
else if (self)
rtype = lookup_interface (CLASS_NAME (implementation_template));
}
if (objc_is_id (rtype))
{
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 && !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 if (rtype)
{
tree orig_rtype = rtype, saved_rtype;
if (TREE_CODE (rtype) == POINTER_TYPE)
rtype = TREE_TYPE (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_OBJC_PROTOCOL_LIST (rtype);
rtype = TYPE_OBJC_INTERFACE (rtype);
}
if (!rtype || TREE_CODE (rtype) == IDENTIFIER_NODE)
{
rtype = NULL_TREE;
if (!method_prototype && rprotos)
method_prototype
= lookup_method_in_protocol_list (rprotos, sel_name, 0);
}
else if (TREE_CODE (rtype) == CLASS_INTERFACE_TYPE
|| TREE_CODE (rtype) == CLASS_IMPLEMENTATION_TYPE)
{
method_prototype
= lookup_method_static (rtype, sel_name, class_tree != NULL_TREE, false, false);
if (!method_prototype && objc_implementation_context
&& CLASS_NAME (objc_implementation_context)
== OBJC_TYPE_NAME (rtype))
method_prototype
= lookup_method
((class_tree
? CLASS_CLS_METHODS (objc_implementation_context)
: CLASS_NST_METHODS (objc_implementation_context)),
sel_name);
if (!method_prototype && rprotos)
method_prototype
= lookup_method_in_protocol_list (rprotos, sel_name,
class_tree != NULL_TREE);
}
else
{
#ifndef OBJCPLUS
struct c_expr exp;
exp.value = receiver;
exp = default_function_array_conversion (exp);
receiver = exp.value;
#else
if (can_convert_arg (objc_object_type, TREE_TYPE (receiver),
receiver, LOOKUP_NORMAL))
{
tree cnv_rec = perform_implicit_conversion (objc_object_type, receiver);
if (cnv_rec && cnv_rec != error_mark_node)
return objc_finish_message_expr (cnv_rec, sel_name, method_params);
}
#endif
if (!objc_nsobject_attribute_type (orig_rtype))
warning (0, "invalid receiver type %qs",
gen_type_name (orig_rtype));
rtype = rprotos = NULL_TREE;
}
}
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 (forward_class && method_prototype)
warning (0, "receiver %qs is a forward class and corresponding @interface may not exist",
IDENTIFIER_POINTER (class_tree));
}
}
if (!method_prototype && in_objc_property_setter_name_context)
{
error ("object cannot be set - either readonly property or no setter found");
return error_mark_node;
}
else if (!method_prototype)
{
static bool warn_missing_methods = false;
if (rtype)
warning (0, "%qs may not respond to %<%c%s%>",
IDENTIFIER_POINTER (OBJC_TYPE_NAME (rtype)),
(class_tree ? '+' : '-'),
IDENTIFIER_POINTER (sel_name));
else if (!donot_warn_missing_methods)
warning (0, "no %<%c%s%> method found",
(class_tree ? '+' : '-'),
IDENTIFIER_POINTER (sel_name));
if (!warn_missing_methods && !donot_warn_missing_methods)
{
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;
}
}
if (method_prototype && rtype)
{
if (TREE_DEPRECATED (method_prototype))
warn_deprecated_use (method_prototype);
if (TREE_UNAVAILABLE (method_prototype))
error_unavailable_use (method_prototype);
}
current_objc_message_selector = sel_name;
if (flag_objc_abi == 2 && !objc_legacy_dispatched_selector_p (sel_name))
{
tree ret_type;
tree message_func_decl;
bool check_for_nil = flag_objc_nilcheck;
ret_type = (method_prototype ?
TREE_VALUE (TREE_TYPE (method_prototype)) :
objc_object_type);
if (super
|| (TREE_CODE (receiver) == VAR_DECL
&& TREE_TYPE (receiver) == objc_class_type))
check_for_nil = false;
if (!targetm.calls.struct_value_rtx (0, 0)
&& (TREE_CODE (ret_type) == RECORD_TYPE
|| TREE_CODE (ret_type) == UNION_TYPE)
&& (TREE_ADDRESSABLE (ret_type)
|| targetm.calls.return_in_memory (ret_type, 0)))
{
if (super)
message_func_decl = umsg_id_super2_stret_fixup_decl;
else
message_func_decl = objc_is_id (rtype)
? umsg_id_stret_fixup_decl
: umsg_stret_fixup_decl;
}
else
{
if (super)
message_func_decl = umsg_id_super2_fixup_decl;
else
{
if (objc_is_id (rtype))
message_func_decl = umsg_id_fixup_decl;
else if (targetm.calls.objc_fpreturn_msgcall (ret_type, true))
message_func_decl = umsg_fixup_decl;
else if (targetm.calls.objc_fpreturn_msgcall (ret_type, false))
message_func_decl = umsg_fpret_fixup_decl;
else
message_func_decl = umsg_fixup_decl;
}
}
selector = build_selector_messenger_reference (sel_name,
message_func_decl);
selector = build_unary_op (ADDR_EXPR, selector, 0);
selector = build_c_cast (super
? objc_v2_super_selector_type
: objc_v2_selector_type, selector);
retval = build_v2_build_objc_method_call (super, method_prototype,
receiver, sel_name, selector,
method_params,
check_for_nil);
}
else
{
if (flag_typed_selectors)
selector = build_typed_selector_reference (sel_name, method_prototype);
else
selector = flag_next_runtime
? build_next_runtime_selector_reference (sel_name)
: build_selector_reference (sel_name);
retval = build_objc_method_call (super, method_prototype,
receiver, sel_name,
selector, method_params);
}
current_objc_message_selector = 0;
return retval;
}
static tree
build_objc_method_call (int super_flag, tree method_prototype,
tree lookup_object, tree sel_name, tree selector,
tree method_params)
{
tree sender = (super_flag ? umsg_super_decl :
(!flag_next_runtime || flag_nil_receivers
? umsg_decl
: umsg_nonnil_decl));
tree rcv_p = (super_flag ? objc_super_type : objc_object_type);
tree ret_type
= (method_prototype
? TREE_VALUE (TREE_TYPE (method_prototype))
: objc_object_type);
tree method_param_types = get_arg_type_list (sel_name, method_prototype,
METHOD_REF, super_flag);
tree ftype = build_function_type (ret_type, method_param_types);
tree sender_cast;
tree method, t;
if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype))
ftype = build_type_attribute_variant (
ftype, METHOD_TYPE_ATTRIBUTES (method_prototype));
sender_cast = build_pointer_type (ftype);
lookup_object = build_c_cast (rcv_p, lookup_object);
lookup_object = save_expr (lookup_object);
if (flag_next_runtime)
{
#ifdef OBJCPLUS
complete_type (ret_type);
#endif
if (aggregate_value_p (ret_type, 0))
sender = (super_flag ? umsg_super_stret_decl :
flag_nil_receivers ? umsg_stret_decl : umsg_nonnil_stret_decl);
else if (!super_flag && targetm.calls.objc_fpreturn_msgcall (ret_type, true))
sender = umsg_decl;
else if (!super_flag && targetm.calls.objc_fpreturn_msgcall (ret_type, false))
sender = umsg_fpret_decl;
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
method = build_fold_addr_expr (sender);
}
else
{
tree object;
object = (super_flag ? self_decl : lookup_object);
t = tree_cons (NULL_TREE, selector, NULL_TREE);
t = tree_cons (NULL_TREE, lookup_object, t);
method = build_function_call (sender, t);
method_params = tree_cons (NULL_TREE, object,
tree_cons (NULL_TREE, selector,
method_params));
}
t = build3 (OBJ_TYPE_REF, sender_cast, method, lookup_object, size_zero_node);
return build_function_call (t, method_params);
}
static tree
build_v2_build_objc_method_call (int super_flag, tree method_prototype,
tree lookup_object, tree sel_name,
tree selector, tree method_params,
bool check_for_nil)
{
tree ret_val;
tree sender, rcv_p, t;
tree ret_type
= (method_prototype
? TREE_VALUE (TREE_TYPE (method_prototype))
: objc_object_type);
tree method_param_types = get_arg_type_list (sel_name, method_prototype,
METHOD_REF, super_flag);
tree ftype = build_function_type (ret_type, method_param_types);
tree sender_cast;
if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype))
ftype = build_type_attribute_variant (
ftype, METHOD_TYPE_ATTRIBUTES (method_prototype));
sender_cast = build_pointer_type (ftype);
if (check_for_nil)
method_params = objc_copy_to_temp_side_effect_params (method_param_types,
method_params);
sender = build_c_cast (build_pointer_type (
super_flag
? objc_v2_super_imp_type
: objc_v2_imp_type), selector);
sender = build_indirect_ref (sender, "unary *");
rcv_p = (super_flag ? objc_super_type : objc_object_type);
lookup_object = build_c_cast (rcv_p, lookup_object);
lookup_object = save_expr (lookup_object);
method_params = tree_cons (NULL_TREE, lookup_object,
tree_cons (NULL_TREE, selector,
method_params));
t = build3 (OBJ_TYPE_REF, sender_cast, sender, lookup_object, size_zero_node);
ret_val = build_function_call (t, method_params);
if (check_for_nil)
{
tree ftree;
tree ifexp;
if (TREE_CODE (ret_type) == RECORD_TYPE
|| TREE_CODE (ret_type) == UNION_TYPE)
ftree = build_constructor_from_list (ret_type, NULL_TREE);
else
ftree = fold_convert (ret_type, integer_zero_node);
ifexp = build_binary_op (NE_EXPR,
lookup_object,
fold_convert (rcv_p, integer_zero_node), 1);
ret_val = build_conditional_expr (ifexp, ret_val, ftree);
}
return ret_val;
}
static void
build_v2_protocol_reference (tree p)
{
tree decl;
const char *proto_name;
proto_name = synth_id_with_class_suffix ("l_OBJC_PROTOCOL_$", p);
decl = create_hidden_decl (objc_v2_protocol_template, proto_name);
DECL_WEAK (decl) = 1;
set_user_assembler_name (decl, proto_name);
PROTOCOL_V2_FORWARD_DECL (p) = decl;
}
static void
generate_v2_protocols (void)
{
tree p, encoding;
tree decl;
tree initlist, protocol_name_expr, refs_decl, refs_expr;
for (p = protocol_chain; p; p = TREE_CHAIN (p))
if (PROTOCOL_V2_FORWARD_DECL (p) && PROTOCOL_LIST (p))
generate_v2_protocol_references (PROTOCOL_LIST (p));
for (p = protocol_chain; p; p = TREE_CHAIN (p))
{
tree nst_methods = PROTOCOL_NST_METHODS (p);
tree cls_methods = PROTOCOL_CLS_METHODS (p);
decl = PROTOCOL_V2_FORWARD_DECL (p);
if (!decl)
continue;
objc_v2_get_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
while (nst_methods)
{
if (! METHOD_ENCODING (nst_methods))
{
encoding = encode_method_prototype (nst_methods);
METHOD_ENCODING (nst_methods) = encoding;
}
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
if (! METHOD_ENCODING (cls_methods))
{
encoding = encode_method_prototype (cls_methods);
METHOD_ENCODING (cls_methods) = encoding;
}
cls_methods = TREE_CHAIN (cls_methods);
}
generate_v2_method_descriptors (p, false);
nst_methods = PROTOCOL_OPTIONAL_NST_METHODS (p);
while (nst_methods)
{
if (! METHOD_ENCODING (nst_methods))
{
encoding = encode_method_prototype (nst_methods);
METHOD_ENCODING (nst_methods) = encoding;
}
nst_methods = TREE_CHAIN (nst_methods);
}
cls_methods = PROTOCOL_OPTIONAL_CLS_METHODS (p);
while (cls_methods)
{
if (! METHOD_ENCODING (cls_methods))
{
encoding = encode_method_prototype (cls_methods);
METHOD_ENCODING (cls_methods) = encoding;
}
cls_methods = TREE_CHAIN (cls_methods);
}
generate_v2_method_descriptors (p, true);
if (PROTOCOL_LIST (p))
refs_decl = generate_v2_protocol_list (p);
else
refs_decl = 0;
protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
if (refs_decl)
refs_expr = convert (build_pointer_type (objc_v2_protocol_template),
build_unary_op (ADDR_EXPR, refs_decl, 0));
else
refs_expr =
convert (build_pointer_type (objc_v2_protocol_template),
integer_zero_node);
objc_implementation_context = p;
generate_v2_property_tables (p);
initlist = build_protocol_initializer (TREE_TYPE (decl),
protocol_name_expr, refs_expr,
UOBJC_V2_INSTANCE_METHODS_decl,
UOBJC_V2_CLASS_METHODS_decl, true,
UOBJC_V2_PROPERTY_decl,
UOBJC_PROTOCOL_OPT_NST_METHODS_decl,
UOBJC_PROTOCOL_OPT_CLS_METHODS_decl);
finish_var_decl (decl, initlist);
objc_add_to_protocol_list_chain (p, decl);
}
}
static void
build_protocol_reference (tree p)
{
tree decl;
const char *proto_name;
proto_name = synth_id_with_class_suffix ("_OBJC_PROTOCOL", p);
decl = start_var_decl (objc_protocol_template, proto_name);
PROTOCOL_FORWARD_DECL (p) = decl;
}
tree
objc_build_protocol_expr (tree protoname)
{
tree expr;
tree p = lookup_protocol (protoname);
if (!p)
{
error ("cannot find protocol declaration for %qs",
IDENTIFIER_POINTER (protoname));
return error_mark_node;
}
if (flag_objc_abi == 2)
{
if (!PROTOCOL_V2_FORWARD_DECL (p))
build_v2_protocol_reference (p);
return objc_v2_get_protocol_reference (p);
}
else
{
if (!PROTOCOL_FORWARD_DECL (p))
build_protocol_reference (p);
expr = build_unary_op (ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
}
expr = convert (objc_protocol_type, expr);
if (! flag_next_runtime)
{
tree protocol_struct_type = xref_tag
(RECORD_TYPE, get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
tree *chain;
for (chain = &objc_static_instances;
*chain && TREE_VALUE (*chain) != protocol_struct_type;
chain = &TREE_CHAIN (*chain));
if (!*chain)
{
*chain = tree_cons (NULL_TREE, protocol_struct_type, NULL_TREE);
add_objc_string (OBJC_TYPE_NAME (protocol_struct_type),
class_names);
}
TREE_PURPOSE (*chain) = tree_cons (NULL_TREE,
PROTOCOL_FORWARD_DECL (p),
TREE_PURPOSE (*chain));
}
return expr;
}
tree
objc_build_selector_expr (tree selnamelist)
{
tree selname;
if (selnamelist == NULL_TREE)
{
error ("method name missing in @selector");
return error_mark_node;
}
if (TREE_CODE (selnamelist) == IDENTIFIER_NODE)
selname = selnamelist;
else if (TREE_CODE (selnamelist) == TREE_LIST)
selname = build_keyword_selector (selnamelist);
else
abort ();
if (warn_undeclared_selector)
{
hash hsh;
hsh = hash_lookup (nst_method_hash_list, selname);
if (!hsh)
{
hsh = hash_lookup (cls_method_hash_list, selname);
}
if (!hsh)
{
warning (0, "undeclared selector %qs", IDENTIFIER_POINTER (selname));
}
}
if (flag_typed_selectors)
return build_typed_selector_reference (selname, 0);
else
return flag_next_runtime
? build_next_runtime_selector_reference (selname)
: build_selector_reference (selname);
}
tree
objc_build_encode_expr (tree type)
{
tree result;
const char *string;
encode_type (type, obstack_object_size (&util_obstack),
OBJC_ENCODE_INLINE_DEFS);
obstack_1grow (&util_obstack, 0);
string = obstack_finish (&util_obstack);
result = my_build_string (strlen (string) + 1, string);
obstack_free (&util_obstack, util_firstobj);
return result;
}
static void
access_block_ref_self_decl (tree *decl)
{
if (lookup_name_in_block (DECL_NAME (*decl), decl))
*decl = lookup_name (DECL_NAME (*decl));
else
*decl = build_block_ref_decl (DECL_NAME (*decl), *decl);
gcc_assert (*decl);
}
static tree
build_ivar_reference (tree id)
{
tree decl;
tree ivar, base;
if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
{
warning (0, "instance variable %qs accessed in class method",
IDENTIFIER_POINTER (id));
self_decl = convert (objc_instance_type, self_decl);
}
decl = self_decl;
if (cur_block)
{
access_block_ref_self_decl (&decl);
gcc_assert (decl);
}
base = build_indirect_ref (decl, "->");
if ((ivar = objc_v2_build_ivar_ref (base, id)))
return ivar;
else
return objc_build_component_ref (base, id);
}
static size_t
hash_func (tree sel_name)
{
const unsigned char *s
= (const unsigned char *)IDENTIFIER_POINTER (sel_name);
size_t h = 0;
while (*s)
h = h * 67 + *s++ - 113;
return h;
}
static void
hash_init (void)
{
nst_method_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
cls_method_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
class_nst_method_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
class_cls_method_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
class_names_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
meth_var_names_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
meth_var_types_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
prop_names_attr_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
sel_ref_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
cls_name_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
als_name_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
ivar_offset_hash_list
= (hash *) ggc_alloc_cleared (SIZEHASHTABLE * sizeof (hash));
string_htab = htab_create_ggc (31, string_hash,
string_eq, NULL);
}
static void
hash_class_name_enter (hash *hashlist, tree sel_name, tree value)
{
hash obj;
int slot = hash_func (sel_name) % SIZEHASHTABLE;
obj = (hash) ggc_alloc (sizeof (struct hashed_entry));
if (value != NULL_TREE)
{
attr obj_attr = (attr) ggc_alloc (sizeof (struct hashed_attribute));
obj_attr->value = value;
obj->list = obj_attr;
}
else
obj->list = 0;
obj->next = hashlist[slot];
obj->key = sel_name;
hashlist[slot] = obj;
}
static hash
hash_class_name_lookup (hash *hashlist, tree sel_name)
{
hash target;
target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
while (target)
{
if (sel_name == target->key)
return target;
target = target->next;
}
return 0;
}
static void
hash_name_enter (hash *hashlist, tree ivar)
{
hash obj;
int slot = hash_func (DECL_NAME (ivar)) % SIZEHASHTABLE;
obj = (hash) ggc_alloc (sizeof (struct hashed_entry));
obj->list = 0;
obj->next = hashlist[slot];
obj->key = ivar;
hashlist[slot] = obj;
}
static tree
hash_name_lookup (hash *hashlist, tree ivar_name)
{
hash target;
target = hashlist[hash_func (ivar_name) % SIZEHASHTABLE];
while (target)
{
if (ivar_name == DECL_NAME (target->key))
return target->key;
target = target->next;
}
return 0;
}
static void
hash_enter (hash *hashlist, tree method)
{
hash obj;
int slot = hash_func (METHOD_SEL_NAME (method)) % SIZEHASHTABLE;
obj = (hash) ggc_alloc (sizeof (struct hashed_entry));
obj->list = 0;
obj->next = hashlist[slot];
obj->key = method;
hashlist[slot] = obj;
}
static hash
hash_lookup (hash *hashlist, tree sel_name)
{
hash target;
target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
while (target)
{
if (sel_name == METHOD_SEL_NAME (target->key))
return target;
target = target->next;
}
return 0;
}
static void
hash_add_attr (hash entry, tree value)
{
attr obj;
obj = (attr) ggc_alloc (sizeof (struct hashed_attribute));
obj->next = entry->list;
obj->value = value;
entry->list = obj;
}
static tree
lookup_method (tree mchain, tree method)
{
tree key;
if (TREE_CODE (method) == IDENTIFIER_NODE)
key = method;
else
key = METHOD_SEL_NAME (method);
while (mchain)
{
if (METHOD_SEL_NAME (mchain) == key)
return mchain;
mchain = TREE_CHAIN (mchain);
}
return NULL_TREE;
}
static hash
class_method_hash_lookup (hash *hashlist, tree sel_name, tree class)
{
hash target;
target = hashlist[hash_func (sel_name) % SIZEHASHTABLE];
while (target)
{
if (sel_name == METHOD_SEL_NAME (target->key)
&& class == METHOD_CONTEXT (target->key))
return target;
target = target->next;
}
return 0;
}
static void
add_class_method_hash (hash *hash_list, tree method, tree class)
{
hash_enter (hash_list, method);
METHOD_CONTEXT (method) = class;
}
static tree
fast_lookup_method (int is_class, tree class, tree method_ident)
{
hash hsh = (!is_class) ? class_method_hash_lookup (class_nst_method_hash_list,
method_ident, class)
: class_method_hash_lookup (class_cls_method_hash_list,
method_ident, class);
return !hsh ? NULL_TREE : hsh->key;
}
static tree
lookup_method_static (tree interface, tree ident, int flags, bool property_lookup,
bool class_method_only)
{
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)
{
tree chain = is_class ? CLASS_CLS_METHODS (inter) : CLASS_NST_METHODS (inter);
tree category = inter;
if ((meth = fast_lookup_method (is_class, inter, ident))
&& (!property_lookup || METHOD_PROPERTY_CONTEXT (meth)))
return meth;
while ((category = CLASS_CATEGORY_LIST (category)))
{
chain = is_class ? CLASS_CLS_METHODS (category) : CLASS_NST_METHODS (category);
if ((meth = lookup_method (chain, ident))
&& (!property_lookup || METHOD_PROPERTY_CONTEXT (meth)))
return meth;
if (CLASS_PROTOCOL_LIST (category))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (category), ident, is_class)))
&& (!property_lookup || METHOD_PROPERTY_CONTEXT (meth)))
return meth;
}
}
if (CLASS_PROTOCOL_LIST (inter))
{
if ((meth = (lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (inter), ident, is_class)))
&& (!property_lookup || METHOD_PROPERTY_CONTEXT (meth)))
return meth;
}
if (no_superclasses)
return NULL_TREE;
root_inter = inter;
inter = lookup_interface (CLASS_SUPER_NAME (inter));
}
while (inter);
return (is_class && !class_method_only)
? lookup_method_static (root_inter, ident, 0, property_lookup, false): NULL_TREE;
}
static void
add_method_to_hash_list (hash *hash_list, tree method)
{
hash hsh;
if (!(hsh = hash_lookup (hash_list, METHOD_SEL_NAME (method))))
{
hash_enter (hash_list, method);
}
else
{
attr loop;
int already_there = comp_proto_with_proto (method, hsh->key, 2);
for (loop = hsh->list; !already_there && loop; loop = loop->next)
already_there |= comp_proto_with_proto (method, loop->value, 2);
if (!already_there)
hash_add_attr (hsh, method);
}
}
static tree
objc_add_method (tree class, tree method, int is_class, int is_optional)
{
tree mth;
if (is_optional)
{
gcc_assert (TREE_CODE (class) == PROTOCOL_INTERFACE_TYPE);
if (!(mth = lookup_method (is_class
? PROTOCOL_OPTIONAL_CLS_METHODS (class)
: PROTOCOL_OPTIONAL_NST_METHODS (class), method)))
{
if (is_class)
{
TREE_CHAIN (method) = PROTOCOL_OPTIONAL_CLS_METHODS (class);
PROTOCOL_OPTIONAL_CLS_METHODS (class) = method;
}
else
{
TREE_CHAIN (method) = PROTOCOL_OPTIONAL_NST_METHODS (class);
PROTOCOL_OPTIONAL_NST_METHODS (class) = method;
}
}
}
else
if (!(mth = fast_lookup_method (is_class, class, METHOD_SEL_NAME (method))))
{
if (is_class)
{
TREE_CHAIN (method) = CLASS_CLS_METHODS (class);
CLASS_CLS_METHODS (class) = method;
}
else
{
TREE_CHAIN (method) = CLASS_NST_METHODS (class);
CLASS_NST_METHODS (class) = method;
}
add_class_method_hash ((!is_class) ? class_nst_method_hash_list
: class_cls_method_hash_list,
method, class);
}
else
{
if ((TREE_CODE (class) == CLASS_INTERFACE_TYPE
|| TREE_CODE (class) == CATEGORY_INTERFACE_TYPE)
&& !comp_proto_with_proto (method, mth, 2))
error ("duplicate declaration of method %<%c%s%>",
is_class ? '+' : '-',
IDENTIFIER_POINTER (METHOD_SEL_NAME (mth)));
}
if (is_class)
add_method_to_hash_list (cls_method_hash_list, method);
else
{
add_method_to_hash_list (nst_method_hash_list, method);
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))
add_method_to_hash_list (cls_method_hash_list, method);
}
return method;
}
static tree
add_class (tree class_name, tree name)
{
struct interface_tuple **slot;
TREE_CHAIN (class_name) = interface_chain;
interface_chain = class_name;
if (interface_htab == NULL)
interface_htab = htab_create_ggc (31, hash_interface, eq_interface, NULL);
slot = (struct interface_tuple **)
htab_find_slot_with_hash (interface_htab, name,
IDENTIFIER_HASH_VALUE (name),
INSERT);
if (!*slot)
{
*slot = (struct interface_tuple *) ggc_alloc_cleared (sizeof (struct interface_tuple));
(*slot)->id = name;
}
(*slot)->class_name = class_name;
return interface_chain;
}
static void
objc_attach_attrs_to_type (tree type, tree class)
{
tree chain;
if (!CLASS_ATTRIBUTES (class))
return;
for (chain = CLASS_ATTRIBUTES (class); chain; chain = TREE_CHAIN (chain))
{
if (is_attribute_p ("deprecated", TREE_PURPOSE (chain)))
TREE_DEPRECATED (type) = 1;
else if (is_attribute_p ("unavailable", TREE_PURPOSE (chain)))
TREE_UNAVAILABLE (type) = 1;
}
return;
}
static void
objc_warn_on_class_attributes (tree class, bool use)
{
tree chain;
if (!class || !CLASS_ATTRIBUTES (class))
return;
for (chain = CLASS_ATTRIBUTES (class); chain; chain = TREE_CHAIN (chain))
{
if (is_attribute_p ("deprecated", TREE_PURPOSE (chain)))
{
if (use)
warning (0, "class %qs is deprecated",
IDENTIFIER_POINTER (CLASS_NAME (class)));
}
else if (is_attribute_p ("unavailable", TREE_PURPOSE (chain)))
{
if (use)
warning (0, "class %qs is unavailable",
IDENTIFIER_POINTER (CLASS_NAME (class)));
}
else if (!use && is_attribute_p ("visibility", TREE_PURPOSE (chain)))
{
tree id = TREE_VALUE (TREE_VALUE ((chain)));
const char *attr_arg = TREE_STRING_POINTER (id);
if (strcmp (attr_arg, "hidden") && strcmp (attr_arg, "default"))
warning (0, "only \"hidden\" or \"default\" visibility attribute allowed on a class");
return;
}
else if (is_attribute_p ("objc_exception", TREE_PURPOSE (chain)))
;
else if (!use)
warning (0, "attribute %s is unknown - ignored",
IDENTIFIER_POINTER (TREE_PURPOSE (chain)));
}
return;
}
static void
add_category (tree class, tree category)
{
tree cat = lookup_category (class, CLASS_SUPER_NAME (category));
if (cat)
{
warning (0, "duplicate interface declaration for category %<%s(%s)%>",
IDENTIFIER_POINTER (CLASS_NAME (class)),
IDENTIFIER_POINTER (CLASS_SUPER_NAME (category)));
}
else
{
CLASS_CATEGORY_LIST (category) = CLASS_CATEGORY_LIST (class);
CLASS_CATEGORY_LIST (class) = category;
}
objc_warn_on_class_attributes (class, true);
}
static tree
add_instance_variable (tree class, int public, tree field_decl)
{
tree field_type = TREE_TYPE (field_decl);
const char *ivar_name = DECL_NAME (field_decl)
? IDENTIFIER_POINTER (DECL_NAME (field_decl))
: "<unnamed>";
#ifdef OBJCPLUS
if (TREE_CODE (field_type) == REFERENCE_TYPE)
{
error ("illegal reference type specified for instance variable %qs",
ivar_name);
return class;
}
#endif
if (field_type == error_mark_node || !TYPE_SIZE (field_type)
|| TYPE_SIZE (field_type) == error_mark_node)
{
error ("instance variable %qs has unknown size", ivar_name);
return class;
}
#ifdef OBJCPLUS
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 (flag_objc_call_cxx_cdtors)
{
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 (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))
{
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;
}
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
switch (public)
{
case 0:
TREE_PUBLIC (field_decl) = 0;
TREE_PRIVATE (field_decl) = 0;
TREE_PROTECTED (field_decl) = 1;
IVAR_PUBLIC_OR_PROTECTED (field_decl) = 1;
break;
case 3:
case 1:
TREE_PUBLIC (field_decl) = 1;
IVAR_PUBLIC_OR_PROTECTED (field_decl) = (flag_objc_abi == 2 && public == 3) ? 0 : 1;
TREE_PRIVATE (field_decl) = 0;
TREE_PROTECTED (field_decl) = 0;
break;
case 2:
TREE_PUBLIC (field_decl) = 0;
TREE_PRIVATE (field_decl) = 1;
TREE_PROTECTED (field_decl) = 0;
IVAR_PUBLIC_OR_PROTECTED (field_decl) = 0;
break;
}
CLASS_RAW_IVARS (class) = chainon (CLASS_RAW_IVARS (class), field_decl);
return class;
}
static tree
is_ivar (tree decl_chain, tree ident)
{
for ( ; decl_chain; decl_chain = TREE_CHAIN (decl_chain))
if (DECL_NAME (decl_chain) == ident)
return decl_chain;
return NULL_TREE;
}
static tree
nested_ivar_lookup (tree interface, tree ident)
{
tree ivar_chain = CLASS_IVARS (interface);
tree res = is_ivar (ivar_chain, ident);
if (res)
return res;
while (CLASS_SUPER_NAME (interface))
{
interface = lookup_interface (CLASS_SUPER_NAME (interface));
if (interface)
return nested_ivar_lookup (interface, ident);
}
return res;
}
static int
is_private (tree decl)
{
return (TREE_PRIVATE (decl)
&& ! is_ivar (CLASS_IVARS (implementation_template),
DECL_NAME (decl)));
}
int
objc_is_public (tree expr, tree identifier)
{
tree basetype, decl;
#ifdef OBJCPLUS
if (processing_template_decl)
return 1;
#endif
if (expr == error_mark_node)
return 0;
if (TREE_TYPE (expr) == error_mark_node)
return 1;
basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr));
if (basetype && TREE_CODE (basetype) == RECORD_TYPE)
{
if (TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype))
{
tree class = lookup_interface (OBJC_TYPE_NAME (basetype));
if (!class)
{
error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (OBJC_TYPE_NAME (basetype)));
return 0;
}
if ((decl = is_ivar (get_class_ivars (class, true), identifier)))
{
if (TREE_PUBLIC (decl))
return 1;
if (objc_implementation_context
&& ((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
|| (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)))
{
tree curtype = TYPE_MAIN_VARIANT
(CLASS_STATIC_TEMPLATE
(implementation_template));
if (basetype == curtype
|| DERIVED_FROM_P (basetype, curtype))
{
int private = is_private (decl);
if (private)
error ("instance variable %qs is declared private",
IDENTIFIER_POINTER (DECL_NAME (decl)));
return !private;
}
}
if (!objc_method_context)
{
if (objc_interface_context &&
(TREE_CODE (objc_interface_context) == CLASS_INTERFACE_TYPE
|| TREE_CODE (objc_interface_context) == CATEGORY_INTERFACE_TYPE))
{
tree class =
TREE_CODE (objc_interface_context) == CLASS_INTERFACE_TYPE
? objc_interface_context
: lookup_interface (CLASS_NAME (objc_interface_context));
tree curtype =
TYPE_MAIN_VARIANT (CLASS_STATIC_TEMPLATE (class));
if (basetype == curtype
|| DERIVED_FROM_P (basetype, curtype))
{
int private;
gcc_assert (!implementation_template);
implementation_template = objc_interface_context;
private = is_private (decl);
implementation_template = NULL_TREE;
if (private)
error ("instance variable %qs is declared private",
IDENTIFIER_POINTER (DECL_NAME (decl)));
return !private;
}
}
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 %qs is declared %s",
IDENTIFIER_POINTER (identifier),
TREE_PRIVATE (decl) ? "private" : "protected");
return 0;
}
}
}
return 1;
}
static bool
objc_method_inherited (tree meth, int mtype, tree interface)
{
tree list;
tree inter = interface;
while ((inter = lookup_interface (CLASS_SUPER_NAME (inter))))
{
list = (mtype == '+') ? CLASS_CLS_METHODS (inter)
: CLASS_NST_METHODS (inter);
if (lookup_method (list, meth))
return true;
}
return false;
}
static bool
objc_impl_forwardInvocation (tree context)
{
tree inherit;
if (fast_lookup_method (false, context, get_identifier ("forwardInvocation:"))
== NULL_TREE)
return false;
inherit = lookup_interface (CLASS_SUPER_NAME (context));
while (inherit)
{
if (!strcmp (IDENTIFIER_POINTER (CLASS_NAME (inherit)), "NSProxy"))
return true;
inherit = lookup_interface (CLASS_SUPER_NAME (inherit));
}
return false;
}
static bool
property_method_in_class (tree meth, bool inst_method, tree interface)
{
tree list, property_method;
if (!interface || !inst_method)
return false;
list = CLASS_NST_METHODS (interface);
property_method = lookup_method (list, meth);
return (property_method &&
METHOD_PROPERTY_CONTEXT (property_method) != NULL);
}
static int
check_methods (tree chain, int mtype, tree interface)
{
int first = 1;
while (chain)
{
if (!fast_lookup_method (mtype == (int)'+',
objc_implementation_context, METHOD_SEL_NAME (chain)))
{
if (chain != NULL && (METHOD_PROPERTY_CONTEXT (chain) != NULL_TREE ||
property_method_in_class (chain, mtype == (int)'-', interface)))
{
gcc_assert (mtype == (int)'-');
chain = TREE_CHAIN (chain);
continue;
}
else if (interface && objc_method_inherited (chain, mtype, interface))
{
chain = TREE_CHAIN (chain);
continue;
}
if (first)
{
if (TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
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 (0, "incomplete implementation of category %qs",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
first = 0;
}
warning (0, "method definition for %<%c%s%> not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
chain = TREE_CHAIN (chain);
}
return first;
}
static int
conforms_to_protocol (tree class, tree protocol)
{
if (TREE_CODE (protocol) == PROTOCOL_INTERFACE_TYPE)
{
tree p = CLASS_PROTOCOL_LIST (class);
while (p && TREE_VALUE (p) != protocol)
p = TREE_CHAIN (p);
if (!p)
{
tree super = (CLASS_SUPER_NAME (class)
? lookup_interface (CLASS_SUPER_NAME (class))
: NULL_TREE);
int tmp = super ? conforms_to_protocol (super, protocol) : 0;
if (!tmp)
return 0;
}
}
return 1;
}
static int
check_methods_accessible (tree chain, tree context, int mtype)
{
int first = 1;
tree list;
tree base_context = context;
while (chain)
{
if (chain != NULL && METHOD_PROPERTY_CONTEXT (chain) != NULL_TREE)
{
gcc_assert (mtype == (int)'-');
gcc_assert (TREE_CODE (METHOD_PROPERTY_CONTEXT (chain)) == PROPERTY_DECL);
chain = TREE_CHAIN (chain);
continue;
}
context = base_context;
while (context)
{
if (mtype == '+')
list = CLASS_CLS_METHODS (context);
else
list = CLASS_NST_METHODS (context);
if (lookup_method (list, chain))
break;
else if (TREE_CODE (context) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (context) == CLASS_INTERFACE_TYPE)
context = (CLASS_SUPER_NAME (context)
? lookup_interface (CLASS_SUPER_NAME (context))
: NULL_TREE);
else if (TREE_CODE (context) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (context) == CATEGORY_INTERFACE_TYPE)
context = (CLASS_NAME (context)
? lookup_interface (CLASS_NAME (context))
: NULL_TREE);
else
abort ();
}
if (context == NULL_TREE)
{
if (first)
{
if (TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
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 (0, "incomplete implementation of category %qs",
IDENTIFIER_POINTER
(CLASS_SUPER_NAME (objc_implementation_context)));
first = 0;
}
warning (0, "method definition for %<%c%s%> not found",
mtype, IDENTIFIER_POINTER (METHOD_SEL_NAME (chain)));
}
chain = TREE_CHAIN (chain);
}
return first;
}
static void
check_protocol (tree p, const char *type, const char *name, tree interface)
{
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
int f1, f2=1;
if (warn_protocol)
{
f1 = check_methods (PROTOCOL_CLS_METHODS (p),
'+', interface);
if (!objc_impl_forwardInvocation (objc_implementation_context))
f2 = check_methods (PROTOCOL_NST_METHODS (p),
'-', interface);
}
else
{
f1 = check_methods_accessible (PROTOCOL_CLS_METHODS (p),
objc_implementation_context,
'+');
if (!objc_impl_forwardInvocation (objc_implementation_context))
f2 = check_methods_accessible (PROTOCOL_NST_METHODS (p),
objc_implementation_context,
'-');
}
if (!f1 || !f2)
warning (0, "%s %qs does not fully implement the %qs protocol",
type, name, IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
}
if (PROTOCOL_LIST (p))
{
tree subs = PROTOCOL_LIST (p);
tree super_class =
lookup_interface (CLASS_SUPER_NAME (implementation_template));
while (subs)
{
tree sub = TREE_VALUE (subs);
if (!super_class || !conforms_to_protocol (super_class, sub))
check_protocol (sub, type, name, interface);
subs = TREE_CHAIN (subs);
}
}
}
static void
check_protocols (tree proto_list, const char *type, const char *name, tree interface)
{
for ( ; proto_list; proto_list = TREE_CHAIN (proto_list))
{
tree p = TREE_VALUE (proto_list);
check_protocol (p, type, name, interface);
}
}
static tree
start_class (enum tree_code code, tree class_name, tree super_name,
tree protocol_list)
{
tree class, decl, aliased_class_name;
#ifdef OBJCPLUS
if (current_namespace != global_namespace) {
error ("Objective-C declarations may only appear in global scope");
}
#endif
if (objc_implementation_context)
{
warning (0, "%<@end%> missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
class = make_node (code);
TYPE_LANG_SLOT_1 (class) = make_tree_vec (CLASS_LANG_SLOT_ELTS);
if ((code == CLASS_INTERFACE_TYPE || code == CLASS_IMPLEMENTATION_TYPE)
&& super_name)
{
tree super = objc_is_class_name (super_name);
tree super_interface = NULL_TREE;
if (!super || !(super_interface = lookup_interface (super)))
{
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
{
objc_warn_on_class_attributes (super_interface, true);
super_name = super;
}
}
aliased_class_name = objc_is_class_name (class_name);
if (aliased_class_name)
class_name = aliased_class_name;
CLASS_NAME (class) = class_name;
CLASS_SUPER_NAME (class) = super_name;
CLASS_CLS_METHODS (class) = NULL_TREE;
if (!aliased_class_name
&& (decl = lookup_name (class_name)))
{
error ("%qs redeclared as different kind of symbol",
IDENTIFIER_POINTER (class_name));
error ("previous declaration of %q+D",
decl);
}
if (code == CLASS_IMPLEMENTATION_TYPE)
{
{
tree chain;
for (chain = implemented_classes; chain; chain = TREE_CHAIN (chain))
if (TREE_VALUE (chain) == class_name)
{
error ("reimplementation of class %qs",
IDENTIFIER_POINTER (class_name));
return class;
}
implemented_classes = tree_cons (NULL_TREE, class_name,
implemented_classes);
}
method_slot = 0;
objc_implementation_context = class;
if (!(implementation_template = lookup_interface (class_name)))
{
warning (0, "cannot find interface declaration for %qs",
IDENTIFIER_POINTER (class_name));
add_class (implementation_template = objc_implementation_context,
class_name);
}
if (super_name
&& (super_name != CLASS_SUPER_NAME (implementation_template)))
{
tree previous_name = CLASS_SUPER_NAME (implementation_template);
const char *const name =
previous_name ? IDENTIFIER_POINTER (previous_name) : "";
error ("conflicting super class name %qs in interface %qs and its implementation",
IDENTIFIER_POINTER (super_name), IDENTIFIER_POINTER (class_name));
if (previous_name)
error ("previous declaration of %qs", name);
}
else if (! super_name)
{
CLASS_SUPER_NAME (objc_implementation_context)
= CLASS_SUPER_NAME (implementation_template);
}
}
else if (code == CLASS_INTERFACE_TYPE)
{
if (lookup_interface (class_name))
error ("duplicate interface declaration for class %qs",
IDENTIFIER_POINTER (class_name));
else
add_class (class, class_name);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
= lookup_and_install_protocols (protocol_list, true);
}
else if (code == CATEGORY_INTERFACE_TYPE)
{
tree class_category_is_assoc_with;
if (!(class_category_is_assoc_with = lookup_interface (class_name)))
{
error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
else
add_category (class_category_is_assoc_with, class);
if (protocol_list)
CLASS_PROTOCOL_LIST (class)
= lookup_and_install_protocols (protocol_list, true);
}
else if (code == CATEGORY_IMPLEMENTATION_TYPE)
{
method_slot = 0;
objc_implementation_context = class;
if (!(implementation_template = lookup_interface (class_name)))
{
error ("cannot find interface declaration for %qs",
IDENTIFIER_POINTER (class_name));
exit (FATAL_EXIT_CODE);
}
}
return class;
}
static tree
continue_class (tree class)
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE
|| TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
struct imp_entry *imp_entry;
if (CLASS_RAW_IVARS (class))
check_ivars (implementation_template, class);
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
build_private_template (implementation_template);
uprivate_record = CLASS_STATIC_TEMPLATE (implementation_template);
objc_instance_type = build_pointer_type (uprivate_record);
imp_entry = (struct imp_entry *) ggc_alloc_cleared (sizeof (struct imp_entry));
imp_entry->next = imp_list;
imp_entry->imp_context = class;
imp_entry->imp_template = implementation_template;
if (flag_objc_abi == 2)
{
synth_v2_forward_declarations ();
imp_entry->class_v2_decl = UOBJC_V2_CLASS_decl;
imp_entry->meta_v2_decl = UOBJC_V2_METACLASS_decl;
}
else
{
synth_forward_declarations ();
imp_entry->class_decl = UOBJC_CLASS_decl;
imp_entry->meta_decl = UOBJC_METACLASS_decl;
}
imp_entry->has_cxx_cdtors = 0;
imp_list = imp_entry;
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
imp_count++;
else
cat_count++;
#ifdef OBJCPLUS
pop_lang_context ();
#endif
return get_class_ivars (implementation_template, true);
}
else if (TREE_CODE (class) == CLASS_INTERFACE_TYPE)
{
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
objc_collecting_ivars = 1;
build_private_template (class);
objc_collecting_ivars = 0;
#ifdef OBJCPLUS
pop_lang_context ();
#endif
return NULL_TREE;
}
else
return error_mark_node;
}
static void
diagnose_property_mismatch (tree cl_prop, bool super, tree property, const char *mess, tree name)
{
if (PROPERTY_READONLY (cl_prop) == boolean_true_node
&& PROPERTY_READWRITE (property) == boolean_true_node)
warning (0, "attribute 'readonly' of property %qs restricts attribute 'readwrite' of %qs property in %s",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)),
IDENTIFIER_POINTER (name), mess);
if (PROPERTY_COPY (cl_prop) != PROPERTY_COPY (property))
warning (0, "property %qs 'copy' attribute does not match %s %qs property",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
else if (PROPERTY_RETAIN (cl_prop) != PROPERTY_RETAIN (property))
warning (0, "property %qs 'retain' attribute does not match %s %qs property",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
if (PROPERTY_SETTER_NAME (cl_prop) != PROPERTY_SETTER_NAME (property))
warning (0, "property %qs 'setter' attribute does not match %s %qs property",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
if (PROPERTY_GETTER_NAME (cl_prop) != PROPERTY_GETTER_NAME (property))
warning (0, "property %qs 'getter' attribute does not match %s %qs property",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
if (comptypes (TREE_TYPE (cl_prop), TREE_TYPE (property)) != 1) {
if (super &&
PROPERTY_READONLY (cl_prop) == boolean_true_node &&
PROPERTY_READONLY (property) == boolean_true_node &&
objc_compare_types (TREE_TYPE (cl_prop), TREE_TYPE (property),
-6, NULL_TREE, NULL))
;
else
warning (0, "property %qs type does not match %s %qs property type",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
}
if (flag_objc_gc &&
objc_is_gcable_type (TREE_TYPE (cl_prop)) != objc_is_gcable_type (TREE_TYPE (property)))
warning (0, "property %qs storage type does not match %s %qs property storage type",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
if (IS_ATOMIC (cl_prop) != IS_ATOMIC (property))
warning (0, "property %qs and its %s %qs don't have matching 'atomic' attribute",
IDENTIFIER_POINTER (PROPERTY_NAME (cl_prop)), mess,
IDENTIFIER_POINTER (name));
}
static void
objc_compare_properties_with_super (tree class)
{
tree super;
tree property, cl_prop;
if (CLASS_SUPER_NAME (class) == NULL_TREE)
return;
super = lookup_interface (CLASS_SUPER_NAME (class));
if (super == NULL_TREE)
return;
for (property = CLASS_PROPERTY_DECL (super); property;
property = TREE_CHAIN (property))
if ((cl_prop = lookup_property_in_list (class, DECL_NAME (property))))
diagnose_property_mismatch (cl_prop, true, property, "super class", CLASS_NAME (super));
}
static void
objc_merge_proto_properties_in_class (tree class, tree rproto_list)
{
tree rproto;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
tree p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
tree property, cl_prop;
for (property = CLASS_PROPERTY_DECL (p); property;
property = TREE_CHAIN (property))
if (!(cl_prop = lookup_property_in_list (class, DECL_NAME (property))))
{
tree x = copy_node (property);
TREE_CHAIN (x) = IMPL_PROPERTY_DECL (class);
IMPL_PROPERTY_DECL (class) = x;
}
else
diagnose_property_mismatch (cl_prop, false, property, "protocol", PROTOCOL_NAME (p));
objc_merge_proto_properties_in_class (class, PROTOCOL_LIST (p));
}
}
}
static char *
objc_build_property_ivar_name (tree property_decl)
{
static char string[BUFSIZE];
sprintf (string, "_%s", IDENTIFIER_POINTER (PROPERTY_NAME (property_decl)));
return string;
}
static char *
objc_build_property_setter_name (tree ident, bool delimit_colon)
{
extern int toupper(int);
static char string[BUFSIZE];
if (delimit_colon)
sprintf (string, "set%s:", IDENTIFIER_POINTER (ident));
else
sprintf (string, "set%s", IDENTIFIER_POINTER (ident));
string[3] = toupper (string[3]);
return string;
}
static void
objc_gen_one_property_data (tree class, tree property, tree class_methods)
{
if (PROPERTY_GETTER_NAME (property))
{
if (!lookup_method (CLASS_NST_METHODS (class_methods),
PROPERTY_GETTER_NAME (property))
&& !lookup_method_in_protocol_list (CLASS_PROTOCOL_LIST (class_methods),
PROPERTY_GETTER_NAME (property), 0))
error ("property getter %qs not declared in class %qs",
IDENTIFIER_POINTER (PROPERTY_GETTER_NAME (property)),
IDENTIFIER_POINTER (CLASS_NAME (class_methods)));
}
if (PROPERTY_SETTER_NAME (property))
{
if (!lookup_method (CLASS_NST_METHODS (class_methods),
PROPERTY_SETTER_NAME (property))
&& !lookup_method_in_protocol_list (CLASS_PROTOCOL_LIST (class_methods),
PROPERTY_SETTER_NAME (property), 0))
error ("property setter %qs not declared in class %qs",
IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (property)),
IDENTIFIER_POINTER (CLASS_NAME (class_methods)));
}
if (PROPERTY_IVAR_NAME (property)
&& PROPERTY_IVAR_NAME (property) != boolean_true_node)
{
if (!nested_ivar_lookup (class, PROPERTY_IVAR_NAME (property)))
error ("ivar %qs in property declaration must be an existing ivar",
IDENTIFIER_POINTER (PROPERTY_IVAR_NAME (property)));
}
}
static void
objc_process_getter_setter (tree class, tree property, bool getter)
{
tree prop_mth_decl;
tree prop_getter_mth_decl;
tree name_ident;
if (getter)
name_ident = PROPERTY_NAME (property);
else
name_ident = get_identifier (objc_build_property_setter_name (
PROPERTY_NAME (property), true));
prop_mth_decl = lookup_method (CLASS_NST_METHODS (class), name_ident);
if (!prop_mth_decl)
return;
prop_getter_mth_decl = lookup_method (CLASS_NST_METHODS (objc_implementation_context),
getter ? PROPERTY_GETTER_NAME (property)
: PROPERTY_SETTER_NAME (property));
if (!prop_getter_mth_decl)
return;
if (!match_proto_with_proto (prop_getter_mth_decl, prop_mth_decl, 2))
{
error ("User %s %qs does not match property %qs type",
getter ? "getter" : "setter",
IDENTIFIER_POINTER (DECL_NAME (prop_getter_mth_decl)),
IDENTIFIER_POINTER (PROPERTY_NAME (property)));
return;
}
prop_mth_decl = copy_node (prop_mth_decl);
METHOD_ENCODING (prop_mth_decl) = METHOD_ENCODING (prop_getter_mth_decl);
METHOD_DEFINITION (prop_mth_decl) = METHOD_DEFINITION (prop_getter_mth_decl);
objc_add_method (objc_implementation_context, prop_mth_decl, 0, 0);
}
static tree
objc_build_getter_retval (tree ivar_ident)
{
tree ret_val;
ret_val = objc_lookup_ivar (NULL_TREE, ivar_ident);
return ret_val;
}
static void
objc_synthesize_getter (tree class, tree class_method, tree property)
{
tree fn, decl;
tree body;
tree ret_val;
tree ivar_ident;
if (!PROPERTY_IVAR_NAME (property))
{
if (!lookup_method (CLASS_NST_METHODS (
objc_implementation_context),PROPERTY_NAME (property)))
{
bool warn = true;
if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
tree category = lookup_category (class,
CLASS_SUPER_NAME (objc_implementation_context));
if (category
&& lookup_method (CLASS_NST_METHODS (
category),PROPERTY_NAME (property)))
warn = false;
}
if (warn)
warning (0, "no synthesized or user getter is available for property %qs",
IDENTIFIER_POINTER (DECL_NAME (property)));
}
return;
}
if (lookup_method (CLASS_NST_METHODS (
objc_implementation_context),PROPERTY_NAME (property)))
return;
decl = lookup_method (CLASS_NST_METHODS (class_method),
PROPERTY_NAME (property));
if (!decl)
return;
objc_inherit_code = INSTANCE_METHOD_DECL;
objc_start_method_definition (copy_node (decl), NULL_TREE);
body = c_begin_compound_stmt (true);
ivar_ident = (PROPERTY_IVAR_NAME (property) != boolean_true_node)
? PROPERTY_IVAR_NAME (property)
: get_identifier (objc_build_property_ivar_name (property));
ret_val = objc_build_getter_retval (ivar_ident);
if (ret_val)
{
ret_val = objc_build_weak_reference_tree (ret_val);
#ifdef OBJCPLUS
finish_return_stmt (ret_val);
#else
(void)c_finish_return (ret_val);
#endif
}
add_stmt (c_end_compound_stmt (body, true));
fn = current_function_decl;
#ifdef OBJCPLUS
finish_function ();
#endif
objc_finish_method_definition (fn);
}
static tree
objc_build_setter_stmt (tree ivar_ident)
{
tree lhs;
lhs = objc_lookup_ivar (NULL_TREE, ivar_ident);
gcc_assert (lhs);
if (lhs)
{
int save_flag_objc_gc = flag_objc_gc;
tree store;
tree rhs = lookup_name (get_identifier ("_value"));
if (!rhs)
rhs = lhs;
flag_objc_gc = 1;
store = build_modify_expr (lhs, NOP_EXPR, rhs);
flag_objc_gc = save_flag_objc_gc;
return store;
}
return NULL_TREE;
}
static void
objc_synthesize_setter (tree class, tree class_method, tree property)
{
tree fn, decl, ivar_ident, stmt;
tree body;
char *setter_name;
tree setter_ident;
setter_name = objc_build_property_setter_name (
PROPERTY_NAME (property), true);
setter_ident = get_identifier (setter_name);
if (!PROPERTY_IVAR_NAME (property))
{
if (!lookup_method (CLASS_NST_METHODS (
objc_implementation_context),setter_ident))
{
bool warn = true;
if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
tree category = lookup_category (class,
CLASS_SUPER_NAME (objc_implementation_context));
if (category
&& lookup_method (CLASS_NST_METHODS (
category),setter_ident))
warn = false;
}
if (warn)
warning (0, "no synthesized or user setter is available for property %qs",
IDENTIFIER_POINTER (DECL_NAME (property)));
}
return;
}
if (lookup_method (CLASS_NST_METHODS (
objc_implementation_context),setter_ident))
return;
decl = lookup_method (CLASS_NST_METHODS (class_method), setter_ident);
if (!decl)
return;
objc_inherit_code = INSTANCE_METHOD_DECL;
objc_start_method_definition (copy_node (decl), NULL_TREE);
body = c_begin_compound_stmt (true);
ivar_ident = (PROPERTY_IVAR_NAME (property) != boolean_true_node)
? PROPERTY_IVAR_NAME (property)
: get_identifier (objc_build_property_ivar_name (property));
stmt = objc_build_setter_stmt (ivar_ident);
if (stmt)
add_stmt (stmt);
add_stmt (c_end_compound_stmt (body, true));
fn = current_function_decl;
#ifdef OBJCPLUS
finish_function ();
#endif
objc_finish_method_definition (fn);
}
static void
objc_synthesize_new_getter (tree class, tree class_method, tree property)
{
location_t save_input_location;
tree decl,body,ret_val,fn;
tree property_getter = PROPERTY_GETTER_NAME (property)
? PROPERTY_GETTER_NAME (property)
: PROPERTY_NAME (property);
if (lookup_method (CLASS_NST_METHODS (
objc_implementation_context),property_getter))
return;
save_input_location = input_location;
input_location = DECL_SOURCE_LOCATION (property);
if (!flag_new_property_ivar_synthesis)
objc_lookup_property_ivar (class, property);
decl = lookup_nested_method (class_method, property_getter);
if (!decl)
return;
if (!umsg_GetAtomicProperty || !umsg_CopyAtomicStruct)
declare_atomic_property_api ();
objc_inherit_code = INSTANCE_METHOD_DECL;
decl = copy_node (decl);
DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (property);
objc_start_method_definition (decl, NULL_TREE);
body = c_begin_compound_stmt (true);
if (!flag_objc_gc_only && IS_ATOMIC (property)
&& (PROPERTY_COPY (property) == boolean_true_node
|| PROPERTY_RETAIN (property) == boolean_true_node))
{
tree cmd;
tree func_params, func;
tree field_decl = nested_ivar_lookup (class, PROPERTY_IVAR_NAME (property));
tree offset = flag_objc_abi <= 1 ? byte_position (field_decl)
: ivar_offset_ref (CLASS_NAME (class), field_decl);
gcc_assert (self_decl);
cmd = TREE_CHAIN (self_decl);
gcc_assert (cmd);
func_params = tree_cons (NULL_TREE, self_decl,
tree_cons (NULL_TREE, cmd,
tree_cons (NULL_TREE, offset,
tree_cons (NULL_TREE, boolean_true_node, NULL_TREE))));
func = umsg_GetAtomicProperty;
ret_val = build_function_call (func, func_params);
}
else
{
bool isStrong = false;
tree ret_type = TREE_TYPE (TREE_TYPE (current_function_decl));
int save_warn_direct_ivar_access = warn_direct_ivar_access;
warn_direct_ivar_access = 0;
ret_val = build_ivar_reference (PROPERTY_IVAR_NAME (property));
warn_direct_ivar_access = save_warn_direct_ivar_access;
if ((TREE_CODE (ret_type) == RECORD_TYPE || TREE_CODE (ret_type) == UNION_TYPE)
&& (TREE_ADDRESSABLE (ret_type) || targetm.calls.return_in_memory (ret_type, 0))
&& (IS_ATOMIC (property) ||
(isStrong = ((flag_objc_gc || flag_objc_gc_only)
&& aggregate_contains_objc_pointer (ret_type)))))
{
tree decl = create_tmp_var_raw (ret_type, NULL);
tree isAtomic = (IS_ATOMIC (property) ? boolean_true_node : boolean_false_node);
tree hasStrong = (isStrong ? boolean_true_node : boolean_false_node);
tree size_ret_val = build_int_cst_wide (NULL_TREE,
TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ret_type)),
TREE_INT_CST_HIGH (TYPE_SIZE_UNIT (ret_type)));
tree func_params, stmt, tmp;
lang_hooks.decls.pushdecl (decl);
tmp = build_fold_addr_expr (decl);
ret_val = build_fold_addr_expr (ret_val);
func_params = tree_cons (NULL_TREE, tmp,
tree_cons (NULL_TREE, ret_val,
tree_cons (NULL_TREE, size_ret_val,
tree_cons (NULL_TREE, isAtomic,
tree_cons (NULL_TREE, hasStrong, NULL_TREE)))));
stmt = build_function_call (umsg_CopyAtomicStruct, func_params);
add_stmt (stmt);
ret_val = decl;
}
}
if (ret_val)
{
ret_val = objc_build_weak_reference_tree (ret_val);
#ifdef OBJCPLUS
finish_return_stmt (ret_val);
#else
(void)c_finish_return (ret_val);
#endif
}
add_stmt (c_end_compound_stmt (body, true));
fn = current_function_decl;
#ifdef OBJCPLUS
finish_function ();
#endif
objc_finish_method_definition (fn);
input_location = save_input_location;
}
static void
objc_synthesize_new_setter (tree class, tree class_method, tree property)
{
tree fn, decl, stmt;
tree body, lhs;
tree setter_ident;
location_t save_input_location;
if (PROPERTY_SETTER_NAME (property))
setter_ident = PROPERTY_SETTER_NAME (property);
else
setter_ident = get_identifier (objc_build_property_setter_name (PROPERTY_NAME (property), true));
if (lookup_method (CLASS_NST_METHODS (
objc_implementation_context),setter_ident))
return;
if (!flag_new_property_ivar_synthesis)
objc_lookup_property_ivar (class, property);
decl = lookup_nested_method (class_method, setter_ident);
if (!decl)
return;
save_input_location = input_location;
input_location = DECL_SOURCE_LOCATION (property);
if (!umsg_SetAtomicProperty || !umsg_CopyAtomicStruct)
declare_atomic_property_api ();
objc_inherit_code = INSTANCE_METHOD_DECL;
decl = copy_node (decl);
DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (property);
objc_start_method_definition (decl, NULL_TREE);
body = c_begin_compound_stmt (true);
stmt = NULL_TREE;
if (PROPERTY_COPY (property) == boolean_true_node
|| (!flag_objc_gc_only && PROPERTY_RETAIN (property) == boolean_true_node))
{
tree cmd, arg;
tree func_params, func;
tree field_decl = nested_ivar_lookup (class, PROPERTY_IVAR_NAME (property));
tree offset = flag_objc_abi <= 1 ? byte_position (field_decl)
: ivar_offset_ref (CLASS_NAME (class), field_decl);
tree shouldCopy = (PROPERTY_COPY (property) == boolean_true_node)
? boolean_true_node : boolean_false_node;
tree isAtomic = IS_ATOMIC (property) ? boolean_true_node : boolean_false_node;
gcc_assert (self_decl);
cmd = TREE_CHAIN (self_decl);
gcc_assert (cmd);
arg = TREE_CHAIN (cmd);
gcc_assert (arg);
TREE_USED (arg) = 1;
func_params = tree_cons (NULL_TREE, self_decl,
tree_cons (NULL_TREE, cmd,
tree_cons (NULL_TREE, offset,
tree_cons (NULL_TREE, arg,
tree_cons (NULL_TREE, isAtomic,
tree_cons (NULL_TREE, shouldCopy, NULL_TREE))))));
func = umsg_SetAtomicProperty;
stmt = build_function_call (func, func_params);
}
else
{
tree ivar_type;
tree rhs = NULL_TREE;
int save_warn_direct_ivar_access = warn_direct_ivar_access;
if (current_function_decl && DECL_ARGUMENTS (current_function_decl))
rhs = TREE_CHAIN (TREE_CHAIN (DECL_ARGUMENTS (current_function_decl)));
warn_direct_ivar_access = 0;
lhs = build_ivar_reference (PROPERTY_IVAR_NAME (property));
warn_direct_ivar_access = save_warn_direct_ivar_access;
if (!rhs) {
fatal_error ("Failed to synthesize the setter - possibly due to earlier error");
rhs = lhs;
}
else
TREE_USED (rhs) = 1;
ivar_type = TREE_TYPE (lhs);
if ((TREE_CODE (ivar_type) == RECORD_TYPE || TREE_CODE (ivar_type) == UNION_TYPE)
&& IS_ATOMIC (property)
&& (TREE_ADDRESSABLE (ivar_type) || targetm.calls.return_in_memory (ivar_type, 0)))
{
tree func_params;
tree isAtomic = boolean_true_node;
tree hasStrong = boolean_false_node;
tree addr_structIvar = build_fold_addr_expr (lhs);
tree size_struct = build_int_cst_wide (NULL_TREE,
TREE_INT_CST_LOW (TYPE_SIZE_UNIT (ivar_type)),
TREE_INT_CST_HIGH (TYPE_SIZE_UNIT (ivar_type)));
rhs = build_fold_addr_expr (rhs);
func_params = tree_cons (NULL_TREE, addr_structIvar,
tree_cons (NULL_TREE, rhs,
tree_cons (NULL_TREE, size_struct,
tree_cons (NULL_TREE, isAtomic,
tree_cons (NULL_TREE, hasStrong, NULL_TREE)))));
stmt = build_function_call (umsg_CopyAtomicStruct, func_params);
}
else
{
stmt = build_modify_expr (lhs, NOP_EXPR, rhs);
}
}
if (stmt)
add_stmt (stmt);
add_stmt (c_end_compound_stmt (body, true));
fn = current_function_decl;
#ifdef OBJCPLUS
finish_function ();
#endif
objc_finish_method_definition (fn);
input_location = save_input_location;
}
static tree
get_category_base_class_impl (tree category_impl, tree base_class)
{
if (TREE_CODE (category_impl) == CATEGORY_IMPLEMENTATION_TYPE
&& TREE_CODE (base_class) == CLASS_INTERFACE_TYPE)
{
struct imp_entry *impent;
for (impent = imp_list; impent; impent = impent->next)
{
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE
&& impent->imp_template == base_class)
return impent->imp_context;
}
}
return NULL_TREE;
}
static bool
lookup_accessor_in_base_class_impl (tree category_impl, tree base_class, tree method_ident)
{
tree base_impl = get_category_base_class_impl (category_impl, base_class);
return (base_impl != NULL_TREE)
&& lookup_method (CLASS_NST_METHODS (base_impl), method_ident);
}
static void
objc_gen_property_data (tree class, tree class_methods)
{
tree x;
objc_v2_merge_property ();
for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
{
if (PROPERTY_DYNAMIC (x) == boolean_true_node)
continue;
else if (PROPERTY_IVAR_NAME (x))
{
objc_synthesize_new_getter (class, class_methods, x);
if (PROPERTY_READONLY (x) == boolean_false_node)
objc_synthesize_new_setter (class, class_methods, x);
}
else
{
if (PROPERTY_GETTER_NAME (x))
objc_process_getter_setter (class_methods, x, true);
else if (!lookup_method (CLASS_NST_METHODS (objc_implementation_context), PROPERTY_NAME (x))
&& !lookup_accessor_in_base_class_impl (objc_implementation_context, class,
PROPERTY_NAME (x))
&& !OPTIONAL_PROPERTY (x))
warning (0, "property %qs requires method '-%s' to be defined - use @synthesize, "
"@dynamic or provide a method implementation",
IDENTIFIER_POINTER (PROPERTY_NAME (x)), IDENTIFIER_POINTER (PROPERTY_NAME (x)));
if (PROPERTY_READONLY (x) == boolean_false_node
&& PROPERTY_SETTER_NAME (x))
objc_process_getter_setter (class_methods, x, false);
else if (PROPERTY_READONLY (x) == boolean_false_node)
{
char *setter_string_name = objc_build_property_setter_name (PROPERTY_NAME (x), true);
tree ident = get_identifier (setter_string_name);
if (!lookup_method (CLASS_NST_METHODS (objc_implementation_context), ident)
&& !lookup_accessor_in_base_class_impl (objc_implementation_context, class, ident)
&& !OPTIONAL_PROPERTY (x))
warning (0, "property %qs requires the method '%s' to be defined - use @synthesize, "
"@dynamic or provide a method implementation",
IDENTIFIER_POINTER (PROPERTY_NAME (x)), setter_string_name);
}
}
}
return;
for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
objc_gen_one_property_data (class, x, class_methods);
for (x = IMPL_PROPERTY_DECL (objc_implementation_context); x; x = TREE_CHAIN (x))
{
if (PROPERTY_DYNAMIC (x) == boolean_true_node)
continue;
if (PROPERTY_GETTER_NAME (x) == NULL_TREE)
objc_synthesize_getter (class, class_methods, x);
else
objc_process_getter_setter (class_methods, x, true);
if (PROPERTY_READONLY (x) == boolean_false_node)
{
if (PROPERTY_SETTER_NAME (x) == NULL_TREE)
objc_synthesize_setter (class, class_methods, x);
else
objc_process_getter_setter (class_methods, x, false);
}
}
}
static void
objc_add_internal_ivar (tree class, tree property, const char *ivar_name)
{
tree record = CLASS_STATIC_TEMPLATE (class);
tree type = TREE_TYPE (property);
tree field_decl, field, nf;
#ifdef OBJCPLUS
if (TREE_CODE (type) == REFERENCE_TYPE)
type = TYPE_MAIN_VARIANT (TREE_TYPE (type));
#endif
field_decl = create_field_decl (type,
ivar_name ? ivar_name
: objc_build_property_ivar_name (property));
DECL_CONTEXT (field_decl) = record;
(void) add_instance_variable (class,
!flag_new_property_ivar_synthesis ? 1 : 2, field_decl);
if (objc_is_strong_p (type) == -1)
{
tree attribute = tree_cons (NULL_TREE, get_identifier ("weak"), NULL_TREE);
attribute = tree_cons (get_identifier ("objc_gc"), attribute, NULL_TREE);
decl_attributes (&field_decl, attribute, 0);
}
nf = copy_node (field_decl);
if (flag_new_property_ivar_synthesis)
{
TREE_PUBLIC (nf) = IVAR_PUBLIC_OR_PROTECTED (nf) = 1;
TREE_PRIVATE (nf) = TREE_PROTECTED (nf) = 0;
}
#ifdef OBJCPLUS
field = CLASS_IVARS (class);
while (field && TREE_CHAIN (field)
&& TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
field = TREE_CHAIN (field);
if (field && TREE_CHAIN (field)
&& TREE_CODE (TREE_CHAIN (field)) != FIELD_DECL)
{
TREE_CHAIN (nf) = TREE_CHAIN (field);
TREE_CHAIN (field) = nf;
}
else
#endif
CLASS_IVARS (class) = chainon (CLASS_IVARS (class), nf);
gcc_assert (record);
field = TYPE_FIELDS (record);
if (field && field != CLASS_IVARS (class))
TREE_CHAIN (field) = CLASS_IVARS (class);
else
TYPE_FIELDS (record) = CLASS_IVARS (class);
TYPE_SIZE (record) = 0;
layout_type (record);
if (flag_new_property_ivar_synthesis)
objc_ivar_chain = CLASS_RAW_IVARS (class);
}
static void
objc_lookup_property_ivar (tree class, tree property)
{
tree ivar_name = PROPERTY_IVAR_NAME (property);
if (!nested_ivar_lookup (class, PROPERTY_IVAR_NAME (property)))
{
if (flag_objc_abi <= 1)
error ("synthesized property %qs must either be named the same as a compatible ivar or must explicitly name an ivar",
IDENTIFIER_POINTER (PROPERTY_NAME (property)));
objc_add_internal_ivar (class, property, IDENTIFIER_POINTER (ivar_name));
}
}
static void
objc_merge_methods (tree primary, tree chain ,int mtype)
{
while (chain)
{
tree method = chain;
chain = TREE_CHAIN (chain);
objc_add_method (primary, method, mtype == '+', false);
if (mtype == '-' && METHOD_PROPERTY_CONTEXT (method))
{
tree x;
for (x = CLASS_PROPERTY_DECL (primary); x; x = TREE_CHAIN (x))
{
if (PROPERTY_NAME (x) == PROPERTY_NAME (METHOD_PROPERTY_CONTEXT (method)))
{
METHOD_PROPERTY_CONTEXT (method) = x;
break;
}
}
}
}
}
static tree
strip_end_colon (tree ident)
{
size_t pos = IDENTIFIER_LENGTH (ident) - 1;
gcc_assert (IDENTIFIER_LENGTH (ident) > 0 && IDENTIFIER_POINTER (ident)[pos] == ':');
return get_identifier_with_length (IDENTIFIER_POINTER (ident), pos);
}
static void
objc_merge_protocol_methods (tree class, tree rproto_list)
{
tree rproto;
for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
{
tree p = TREE_VALUE (rproto);
if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
{
objc_merge_methods (class, copy_list (PROTOCOL_CLS_METHODS (p)), '+');
objc_merge_methods (class, copy_list (PROTOCOL_NST_METHODS (p)), '-');
objc_merge_proto_properties_in_class (class, PROTOCOL_LIST (p));
}
}
}
static void
finish_class (tree class)
{
if (TREE_CODE (class) == CLASS_IMPLEMENTATION_TYPE)
{
objc_gen_property_data (implementation_template, implementation_template);
if (implementation_template != objc_implementation_context)
{
check_methods (CLASS_CLS_METHODS (implementation_template),
'+', NULL_TREE);
check_methods (CLASS_NST_METHODS (implementation_template),
'-', NULL_TREE);
if (CLASS_PROTOCOL_LIST (implementation_template))
check_protocols (CLASS_PROTOCOL_LIST (implementation_template),
"class",
IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context)),
implementation_template);
}
}
else if (TREE_CODE (class) == CATEGORY_IMPLEMENTATION_TYPE)
{
tree category = lookup_category (implementation_template, CLASS_SUPER_NAME (class));
if (category)
{
objc_gen_property_data (implementation_template, category);
check_methods (CLASS_CLS_METHODS (category),
'+', NULL_TREE);
check_methods (CLASS_NST_METHODS (category),
'-', NULL_TREE);
if (CLASS_PROTOCOL_LIST (category))
check_protocols (CLASS_PROTOCOL_LIST (category),
"category",
IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)),
implementation_template);
}
}
else
{
tree x;
if (TREE_CODE (class) == CLASS_INTERFACE_TYPE || TREE_CODE (class) == CATEGORY_INTERFACE_TYPE)
{
objc_compare_properties_with_super (class);
objc_merge_proto_properties_in_class (class, CLASS_PROTOCOL_LIST (class));
}
for (x = CLASS_PROPERTY_DECL (class); x; x = TREE_CHAIN (x))
{
tree getter_decl, setter_decl;
tree type = TREE_TYPE (x);
tree prop_name = PROPERTY_NAME (x);
if (PROPERTY_GETTER_NAME (x) == NULL_TREE)
{
getter_decl = lookup_method (CLASS_NST_METHODS (class), prop_name);
if (getter_decl)
{
tree getter_type = TREE_VALUE (TREE_TYPE (getter_decl));
if ((comptypes (type, getter_type) != 1)
&& !objc_compare_types (type, getter_type, -6, NULL_TREE, NULL))
warning (0, "type of accessor does not match the type of property %qs",
IDENTIFIER_POINTER (prop_name));
if (METHOD_SEL_ARGS (getter_decl) != NULL_TREE)
error ("accessor %<%c%s%> cannot have any argument",
'-', IDENTIFIER_POINTER (prop_name));
METHOD_PROPERTY_CONTEXT (getter_decl) = x;
TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x);
}
else if (!OPTIONAL_PROPERTY (x) || TREE_CODE (class) == PROTOCOL_INTERFACE_TYPE)
{
tree rettype = build_tree_list (NULL_TREE, type);
getter_decl = build_method_decl (INSTANCE_METHOD_DECL,
rettype, prop_name, NULL_TREE,
false);
DECL_SOURCE_LOCATION (getter_decl) =
DECL_SOURCE_LOCATION (x);
objc_add_method (class, getter_decl, false, OPTIONAL_PROPERTY (x));
METHOD_PROPERTY_CONTEXT (getter_decl) = x;
TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x);
}
}
else
{
getter_decl = lookup_method (CLASS_NST_METHODS (class), PROPERTY_GETTER_NAME (x));
if (!getter_decl)
{
tree rettype = build_tree_list (NULL_TREE, type);
getter_decl = build_method_decl (INSTANCE_METHOD_DECL,
rettype, PROPERTY_GETTER_NAME (x),
NULL_TREE, false);
DECL_SOURCE_LOCATION (getter_decl) =
DECL_SOURCE_LOCATION (x);
objc_add_method (class, getter_decl, false, false);
METHOD_PROPERTY_CONTEXT (getter_decl) = x;
}
else
{
if (comptypes (type, TREE_VALUE (TREE_TYPE (getter_decl))) != 1)
error ("type of existing accessor %<%c%s%> does not match the type of property %qs",
'-', IDENTIFIER_POINTER (PROPERTY_GETTER_NAME (x)), IDENTIFIER_POINTER (prop_name));
if (METHOD_SEL_ARGS (getter_decl) != NULL_TREE)
error ("existing accessor %<%c%s%> cannot have any argument",
'-', IDENTIFIER_POINTER (PROPERTY_GETTER_NAME (x)));
}
TREE_DEPRECATED (getter_decl) = TREE_DEPRECATED (x);
}
if (PROPERTY_SETTER_NAME (x) == NULL_TREE
&& PROPERTY_READONLY (x) == boolean_false_node)
{
tree setter_name = get_identifier (objc_build_property_setter_name (
prop_name, true));
setter_decl = lookup_method (CLASS_NST_METHODS (class), setter_name);
if (setter_decl)
{
if (TREE_VALUE (TREE_TYPE (setter_decl)) != void_type_node)
error ("setter %<%c%s%> type must be 'void'",
'-', IDENTIFIER_POINTER (prop_name));
if (!METHOD_SEL_ARGS (setter_decl))
error ("setter %<%c%s%> has no argument", '-', IDENTIFIER_POINTER (prop_name));
else
{
tree akey = METHOD_SEL_ARGS (setter_decl);
tree arg_type = TREE_VALUE (TREE_TYPE (akey));
if (comptypes (type, arg_type) != 1)
error ("setter %<%c%s%> argument type does not match property type",
'-', IDENTIFIER_POINTER (prop_name));
akey = TREE_CHAIN (akey);
if (akey)
error ("setter %<%c%s%> has too many arguments",
'-', IDENTIFIER_POINTER (prop_name));
}
TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x);
}
else if (!OPTIONAL_PROPERTY (x)
|| TREE_CODE (class) == PROTOCOL_INTERFACE_TYPE)
objc_add_property_setter_method (class, x);
}
else if (PROPERTY_SETTER_NAME (x))
{
if (PROPERTY_READONLY (x) == boolean_true_node)
error ("setter cannot be specified for a 'readonly' property %qs"
, IDENTIFIER_POINTER (PROPERTY_NAME (x)));
else
{
setter_decl = lookup_method (CLASS_NST_METHODS (class), PROPERTY_SETTER_NAME (x));
if (!setter_decl)
{
tree prop;
tree arg_type = build_tree_list (NULL_TREE, type);
tree arg_name = get_identifier ("_value");
tree selector = objc_build_keyword_decl (strip_end_colon (PROPERTY_SETTER_NAME (x)),
arg_type, arg_name, NULL_TREE);
setter_decl = build_method_decl (INSTANCE_METHOD_DECL,
build_tree_list (NULL_TREE, void_type_node), selector,
build_tree_list (NULL_TREE, NULL_TREE), false);
DECL_SOURCE_LOCATION (setter_decl) =
DECL_SOURCE_LOCATION (x);
objc_add_method (class, setter_decl, false, false);
METHOD_PROPERTY_CONTEXT (setter_decl) = x;
for (prop = CLASS_PROPERTY_DECL (class); prop; prop = TREE_CHAIN (prop))
{
const char *property_name = IDENTIFIER_POINTER (PROPERTY_NAME (prop));
const char *setter_name = IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x));
size_t len = strlen (setter_name) - 1;
if (strlen (property_name) == len && !strncmp (setter_name, property_name, len))
{
error ("setter name %qs matches property %qs name",
setter_name, property_name);
break;
}
}
}
else
{
if (TREE_VALUE (TREE_TYPE (setter_decl)) != void_type_node)
error ("user setter's type must be 'void' for property %qs",
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
if (!METHOD_SEL_ARGS (setter_decl))
error ("setter %<%c%s%> has no argument",
'-', IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x)));
else
{
tree akey = METHOD_SEL_ARGS (setter_decl);
if (akey)
{
tree arg_type = TREE_VALUE (TREE_TYPE (akey));
if (comptypes (type, arg_type) != 1)
error ("argument type of setter %<%c%s%> does not match the type of property %qs",
'-', IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x)),
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
akey = TREE_CHAIN (akey);
if (akey)
error ("specified setter %<%c%s%> has too many arguments",
'-', IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x)));
}
else
error ("specified setter %<%c%s%> has no argument",
'-', IDENTIFIER_POINTER (PROPERTY_SETTER_NAME (x)));
}
}
TREE_DEPRECATED (setter_decl) = TREE_DEPRECATED (x);
}
}
if (PROPERTY_RETAIN (x) == boolean_true_node)
{
if (!objc_type_valid_for_messaging (type))
error ("property %qs with 'retain' attribute must be of object type",
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
if (objc_is_gcable_type (type) == -1)
error ("property %qs with 'retain' attribute cannot be used with __weak storage specifier",
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
}
if (PROPERTY_COPY (x) == boolean_true_node)
{
if (!objc_type_valid_for_messaging (type))
error ("property %qs with 'copy' attribute must be of object type",
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
if (objc_is_gcable_type (type) == -1)
error ("property %qs with 'copy' attribute cannot be used with __weak storage specifier",
IDENTIFIER_POINTER (PROPERTY_NAME (x)));
}
}
if (ANONYMOUS_CATEGORY (class))
{
tree primary = lookup_interface (CLASS_NAME (class));
if (primary)
{
objc_merge_methods (primary, CLASS_NST_METHODS (class), '-');
objc_merge_methods (primary, CLASS_CLS_METHODS (class), '+');
objc_merge_protocol_methods (primary, CLASS_PROTOCOL_LIST (class));
}
}
}
}
static tree
add_protocol (tree protocol)
{
TREE_CHAIN (protocol) = protocol_chain;
protocol_chain = protocol;
return protocol_chain;
}
static tree
lookup_protocol (tree ident)
{
tree chain;
for (chain = protocol_chain; chain; chain = TREE_CHAIN (chain))
if (ident == PROTOCOL_NAME (chain))
return chain;
return NULL_TREE;
}
void
objc_declare_protocols (tree names, tree prefix_attrs)
{
tree list;
#ifdef OBJCPLUS
if (current_namespace != global_namespace) {
error ("Objective-C declarations may only appear in global scope");
}
#endif
for (list = names; list; list = TREE_CHAIN (list))
{
tree name = TREE_VALUE (list);
if (lookup_protocol (name) == NULL_TREE)
{
tree protocol = make_node (PROTOCOL_INTERFACE_TYPE);
TYPE_LANG_SLOT_1 (protocol)
= make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = NULL_TREE;
add_protocol (protocol);
PROTOCOL_DEFINED (protocol) = 0;
PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
PROTOCOL_V2_FORWARD_DECL (protocol) = NULL_TREE;
PROTOCOL_ATTRIBUTES (protocol) = prefix_attrs;
}
}
}
static tree
start_protocol (tree name, tree list, tree prefix_attrs)
{
tree protocol;
#ifdef OBJCPLUS
if (current_namespace != global_namespace) {
error ("Objective-C declarations may only appear in global scope");
}
#endif
protocol = lookup_protocol (name);
if (!protocol)
{
protocol = make_node (PROTOCOL_INTERFACE_TYPE);
TYPE_LANG_SLOT_1 (protocol) = make_tree_vec (PROTOCOL_LANG_SLOT_ELTS);
PROTOCOL_NAME (protocol) = name;
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, false);
add_protocol (protocol);
PROTOCOL_DEFINED (protocol) = 1;
PROTOCOL_FORWARD_DECL (protocol) = NULL_TREE;
PROTOCOL_V2_FORWARD_DECL (protocol) = NULL_TREE;
PROTOCOL_ATTRIBUTES (protocol) = prefix_attrs;
check_protocol_recursively (protocol, list);
}
else if (! PROTOCOL_DEFINED (protocol))
{
PROTOCOL_DEFINED (protocol) = 1;
PROTOCOL_ATTRIBUTES (protocol) = merge_attributes
(PROTOCOL_ATTRIBUTES (protocol),
prefix_attrs);
PROTOCOL_LIST (protocol) = lookup_and_install_protocols (list, false);
check_protocol_recursively (protocol, list);
}
else
{
warning (0, "duplicate declaration for protocol %qs",
IDENTIFIER_POINTER (name));
}
return protocol;
}
static void
encode_type_qualifiers (tree declspecs)
{
tree spec;
for (spec = declspecs; spec; spec = TREE_CHAIN (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');
else if (ridpointers[(int) RID_OUT] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'o');
else if (ridpointers[(int) RID_BYCOPY] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'O');
else if (ridpointers[(int) RID_BYREF] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'R');
else if (ridpointers[(int) RID_ONEWAY] == TREE_VALUE (spec))
obstack_1grow (&util_obstack, 'V');
}
}
static bool
pointee_is_readonly (tree pointee)
{
while (POINTER_TYPE_P (pointee))
pointee = TREE_TYPE (pointee);
return TYPE_READONLY (pointee);
}
static void encode_protocol_list (tree record, bool quote)
{
tree p;
bool firsttime = true;
bool close_quote = false;
for (p = TYPE_OBJC_PROTOCOL_LIST (record); p; p = TREE_CHAIN (p))
{
tree proto = TREE_VALUE (p);
if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
&& PROTOCOL_NAME (proto))
{
const char *name = IDENTIFIER_POINTER (PROTOCOL_NAME (proto));
if (quote && firsttime)
{
obstack_1grow (&util_obstack, '"');
firsttime = false;
close_quote = true;
}
obstack_1grow (&util_obstack, '<');
obstack_grow (&util_obstack, name, strlen (name));
obstack_1grow (&util_obstack, '>');
}
}
if (quote && close_quote)
obstack_1grow (&util_obstack, '"');
}
static void
encode_pointer (tree type, int curtype, int format)
{
tree pointer_to = TREE_TYPE (type);
if (!generating_instance_variables
&& (obstack_object_size (&util_obstack) - curtype <= 1)
&& (TYPE_NAME (type) && TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
? TYPE_READONLY (type)
: pointee_is_readonly (pointer_to)))
obstack_1grow (&util_obstack, 'r');
if (TREE_CODE (pointer_to) == RECORD_TYPE)
{
if (generating_property_type_encoding &&
TYPE_NAME (pointer_to)
&& TREE_CODE (TYPE_NAME (pointer_to)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (TYPE_NAME (pointer_to)))
pointer_to = DECL_ORIGINAL_TYPE (TYPE_NAME (pointer_to));
if (OBJC_TYPE_NAME (pointer_to)
&& TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE)
{
const char *name = IDENTIFIER_POINTER (OBJC_TYPE_NAME (pointer_to));
if (strcmp (name, TAG_OBJECT) == 0)
{
obstack_1grow (&util_obstack, '@');
if (generating_instance_variables
&& TYPE_HAS_OBJC_INFO (pointer_to))
encode_protocol_list (pointer_to, true);
return;
}
else if (TYPE_HAS_OBJC_INFO (pointer_to)
&& TYPE_OBJC_INTERFACE (pointer_to))
{
if (generating_instance_variables)
{
obstack_1grow (&util_obstack, '@');
obstack_1grow (&util_obstack, '"');
obstack_grow (&util_obstack, name, strlen (name));
encode_protocol_list (pointer_to, false);
obstack_1grow (&util_obstack, '"');
return;
}
else
{
obstack_1grow (&util_obstack, '@');
return;
}
}
else if (strcmp (name, TAG_CLASS) == 0)
{
obstack_1grow (&util_obstack, '#');
return;
}
else if (strcmp (name, TAG_SELECTOR) == 0)
{
obstack_1grow (&util_obstack, ':');
return;
}
}
}
else if (TREE_CODE (pointer_to) == INTEGER_TYPE
&& TYPE_MODE (pointer_to) == QImode)
{
tree pname = TREE_CODE (OBJC_TYPE_NAME (pointer_to)) == IDENTIFIER_NODE
? OBJC_TYPE_NAME (pointer_to)
: DECL_NAME (OBJC_TYPE_NAME (pointer_to));
if (!flag_next_runtime || strcmp (IDENTIFIER_POINTER (pname), "BOOL"))
{
obstack_1grow (&util_obstack, '*');
return;
}
}
obstack_1grow (&util_obstack, TREE_CODE (type) == BLOCK_POINTER_TYPE ? '@' : '^');
encode_type (pointer_to, curtype, format);
}
static void
encode_array (tree type, int curtype, int format)
{
tree an_int_cst = TYPE_SIZE (type);
tree array_of = TREE_TYPE (type);
char buffer[40];
if (an_int_cst == NULL)
{
encode_pointer (type, curtype, format);
return;
}
if (TREE_INT_CST_LOW (TYPE_SIZE (array_of)) == 0)
sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT)0);
else
sprintf (buffer, "[" HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (an_int_cst)
/ TREE_INT_CST_LOW (TYPE_SIZE (array_of)));
obstack_grow (&util_obstack, buffer, strlen (buffer));
encode_type (array_of, curtype, format);
obstack_1grow (&util_obstack, ']');
return;
}
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
if (TREE_CODE (field) != FIELD_DECL || TREE_STATIC (field))
continue;
#endif
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;
int ob_size = obstack_object_size (&util_obstack);
int pointed_to = (ob_size > 0
? *(obstack_next_free (&util_obstack) - 1) == '^'
: 0);
int inline_contents
= ((format == OBJC_ENCODE_INLINE_DEFS || generating_instance_variables)
&& (!pointed_to
|| ob_size - curtype == 1
|| (ob_size - curtype == 2
&& *(obstack_next_free (&util_obstack) - 2) == 'r')));
type = TYPE_MAIN_VARIANT (type);
name = OBJC_TYPE_NAME (type);
obstack_1grow (&util_obstack, left);
if (name && TREE_CODE (name) == IDENTIFIER_NODE
#ifdef OBJCPLUS
&& !TYPE_WAS_ANONYMOUS (type)
#endif
)
obstack_grow (&util_obstack,
IDENTIFIER_POINTER (name),
strlen (IDENTIFIER_POINTER (name)));
else
obstack_1grow (&util_obstack, '?');
if (inline_contents)
{
obstack_1grow (&util_obstack, '=');
encode_aggregate_fields (type, pointed_to, curtype, format);
}
obstack_1grow (&util_obstack, right);
}
static void
encode_aggregate (tree type, int curtype, int format)
{
enum tree_code code = TREE_CODE (type);
switch (code)
{
case RECORD_TYPE:
{
encode_aggregate_within (type, curtype, format, '{', '}');
break;
}
case UNION_TYPE:
{
encode_aggregate_within (type, curtype, format, '(', ')');
break;
}
case ENUMERAL_TYPE:
obstack_1grow (&util_obstack, 'i');
break;
default:
break;
}
}
static void
encode_next_bitfield (int width)
{
char buffer[40];
sprintf (buffer, "b%d", width);
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
static void
encode_type (tree type, int curtype, int format)
{
enum tree_code code = TREE_CODE (type);
char c;
tree int_type;
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:
int_type = ((!generating_instance_variables
&& (obstack_object_size (&util_obstack)
== (unsigned) curtype))
? TYPE_MAIN_VARIANT (type)
: type);
if (int_type == long_unsigned_type_node
|| int_type == long_integer_type_node)
c = TYPE_UNSIGNED (type) ? 'L' : 'l';
else
c = TYPE_UNSIGNED (type) ? 'I' : 'i';
break;
case 64: c = TYPE_UNSIGNED (type) ? 'Q' : 'q'; break;
case 128: c = TYPE_UNSIGNED (type) ? 'T' : 't'; break;
default: abort ();
}
obstack_1grow (&util_obstack, c);
}
else if (code == REAL_TYPE)
{
switch (GET_MODE_BITSIZE (TYPE_MODE (type)))
{
case 32: c = 'f'; break;
case 64: c = 'd'; break;
case 96:
case 128: c = 'D'; break;
default: abort ();
}
obstack_1grow (&util_obstack, c);
}
else if (code == VOID_TYPE)
obstack_1grow (&util_obstack, 'v');
else if (code == BOOLEAN_TYPE)
obstack_1grow (&util_obstack, 'B');
else if (code == ARRAY_TYPE)
encode_array (type, curtype, format);
#ifdef OBJCPLUS
else if (code == REFERENCE_TYPE)
encode_pointer (type, curtype, format);
#endif
else if (code == POINTER_TYPE || code == BLOCK_POINTER_TYPE)
encode_pointer (type, curtype, format);
else if (code == RECORD_TYPE || code == UNION_TYPE || code == ENUMERAL_TYPE)
encode_aggregate (type, curtype, format);
else if (code == FUNCTION_TYPE)
obstack_1grow (&util_obstack, '?');
if (code == POINTER_TYPE && obstack_object_size (&util_obstack) >= 3)
{
char *enc = obstack_base (&util_obstack) + curtype;
if (curtype >= 1 && !strncmp (enc - 1, "nr", 2))
strncpy (enc - 1, "rn", 2);
}
else if (code == COMPLEX_TYPE)
{
obstack_1grow (&util_obstack, 'j');
encode_type (TREE_TYPE (type), curtype, format);
}
}
static void
encode_gnu_bitfield (int position, tree type, int size)
{
enum tree_code code = TREE_CODE (type);
char buffer[40];
char charType = '?';
if (code == INTEGER_TYPE)
{
if (integer_zerop (TYPE_MIN_VALUE (type)))
{
if (TYPE_MODE (type) == QImode)
charType = 'C';
else if (TYPE_MODE (type) == HImode)
charType = 'S';
else if (TYPE_MODE (type) == SImode)
{
if (type == long_unsigned_type_node)
charType = 'L';
else
charType = 'I';
}
else if (TYPE_MODE (type) == DImode)
charType = 'Q';
}
else
{
if (TYPE_MODE (type) == QImode)
charType = 'c';
else if (TYPE_MODE (type) == HImode)
charType = 's';
else if (TYPE_MODE (type) == SImode)
{
if (type == long_integer_type_node)
charType = 'l';
else
charType = 'i';
}
else if (TYPE_MODE (type) == DImode)
charType = 'q';
}
}
else if (code == ENUMERAL_TYPE)
charType = 'i';
else
abort ();
sprintf (buffer, "b%d%c%d", position, charType, size);
obstack_grow (&util_obstack, buffer, strlen (buffer));
}
static void
encode_field_decl (tree field_decl, int curtype, int format)
{
tree type;
#ifdef OBJCPLUS
if (TREE_CODE (field_decl) != FIELD_DECL || TREE_STATIC (field_decl))
return;
#endif
type = TREE_TYPE (field_decl);
if (DECL_BIT_FIELD_TYPE (field_decl))
{
int size = tree_low_cst (DECL_SIZE (field_decl), 1);
if (flag_next_runtime)
encode_next_bitfield (size);
else
encode_gnu_bitfield (int_bit_position (field_decl),
DECL_BIT_FIELD_TYPE (field_decl), size);
}
else
encode_type (TREE_TYPE (field_decl), curtype, format);
}
static tree
objc_decay_parm_type (tree type)
{
if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == FUNCTION_TYPE)
type = build_pointer_type (TREE_CODE (type) == ARRAY_TYPE
? TREE_TYPE (type)
: type);
return type;
}
static GTY(()) tree objc_parmlist = NULL_TREE;
static void
objc_push_parm (tree parm)
{
tree type = objc_decay_parm_type (TREE_TYPE (parm));
if (type != TREE_TYPE (parm))
{
TREE_TYPE (parm) = type;
relayout_decl (parm);
}
DECL_ARG_TYPE (parm)
= lang_hooks.types.type_promotes_to (TREE_TYPE (parm));
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);
}
#ifdef OBJCPLUS
static tree
objc_get_parm_info (int have_ellipsis ATTRIBUTE_UNUSED)
#else
static struct c_arg_info *
objc_get_parm_info (int have_ellipsis)
#endif
{
#ifdef OBJCPLUS
tree parm_info = objc_parmlist;
objc_parmlist = NULL_TREE;
return parm_info;
#else
tree parm_info = objc_parmlist;
struct c_arg_info *arg_info;
push_scope ();
declare_parm_level ();
while (parm_info)
{
tree next = TREE_CHAIN (parm_info);
TREE_CHAIN (parm_info) = NULL_TREE;
parm_info = pushdecl (parm_info);
finish_decl (parm_info, NULL_TREE, NULL_TREE);
parm_info = next;
}
arg_info = get_parm_info (have_ellipsis);
pop_scope ();
objc_parmlist = NULL_TREE;
return arg_info;
#endif
}
static void
synth_self_and_ucmd_args (void)
{
tree self_type;
if (objc_method_context
&& TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL)
self_type = objc_instance_type;
else
self_type = objc_object_type;
objc_push_parm (build_decl (PARM_DECL, self_id, self_type));
objc_push_parm (build_decl (PARM_DECL, ucmd_id, objc_selector_type));
}
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(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;
should_call_super_finalize =
CLASS_SUPER_NAME (objc_implementation_context)
&& TREE_CODE (method) == INSTANCE_METHOD_DECL
&& !strcmp ("finalize", IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
objc_method_context = method;
UOBJC_SUPER_decl = NULL_TREE;
synth_self_and_ucmd_args ();
parmlist = METHOD_SEL_ARGS (method);
while (parmlist)
{
tree type = TREE_VALUE (TREE_TYPE (parmlist)), parm;
parm = build_decl (PARM_DECL, KEYWORD_ARG_NAME (parmlist), type);
decl_attributes (&parm, KEYWORD_ARG_ATTRIBUTE (parmlist), 0);
objc_push_parm (parm);
parmlist = TREE_CHAIN (parmlist);
}
if (METHOD_ADD_ARGS (method))
{
tree akey;
for (akey = TREE_CHAIN (METHOD_ADD_ARGS (method));
akey; akey = TREE_CHAIN (akey))
{
objc_push_parm (TREE_VALUE (akey));
}
if (METHOD_ADD_ARGS_ELLIPSIS_P (method))
have_ellipsis = 1;
}
parm_info = objc_get_parm_info (have_ellipsis);
really_start_method (objc_method_context, parm_info);
}
static void
warn_with_method (const char *message, int mtype, tree method)
{
warning (0, "%J%s %<%c%s%>", method,
message, mtype, gen_method_decl (method));
}
static int
objc_types_are_equivalent (tree type1, tree type2)
{
if (type1 == type2)
return 1;
while ((TREE_CODE (type1) == ARRAY_TYPE || TREE_CODE (type1) == POINTER_TYPE ||
TREE_CODE (type1) == BLOCK_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_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))
if (!lookup_protocol_in_reflist (type1, TREE_VALUE (type2)))
return 0;
return 1;
}
return 0;
}
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));
}
static int
comp_proto_with_proto (tree proto1, tree proto2, int strict)
{
if (METHOD_SEL_NAME (proto1) != METHOD_SEL_NAME (proto2))
return 0;
return match_proto_with_proto (proto1, proto2, strict);
}
static int
match_proto_with_proto (tree proto1, tree proto2, int strict)
{
tree type1, type2;
type1 = TREE_VALUE (TREE_TYPE (proto1));
type2 = TREE_VALUE (TREE_TYPE (proto2));
if (!objc_types_are_equivalent (type1, type2)) {
if (strict == 2)
return 0;
if (!objc_types_share_size_and_alignment (type1, type2))
return 0;
if (strict == 1 && !objc_compare_types(type1, type2, -2, 0, NULL))
return 0;
}
for (type1 = get_arg_type_list (METHOD_SEL_NAME (proto1), proto1, METHOD_REF, 0),
type2 = get_arg_type_list (METHOD_SEL_NAME (proto2), proto2, METHOD_REF, 0);
type1 && type2;
type1 = TREE_CHAIN (type1), type2 = TREE_CHAIN (type2))
{
if (!objc_types_are_equivalent (TREE_VALUE (type1), TREE_VALUE (type2))) {
if (strict == 2)
return 0;
if (!objc_types_share_size_and_alignment (TREE_VALUE (type1), TREE_VALUE (type2)))
return 0;
if (strict == 1 && !objc_compare_types(TREE_VALUE (type2), TREE_VALUE (type1), -2, 0, NULL))
return 0;
}
}
return (!type1 && !type2);
}
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 (!v)
return NULL_TREE;
return cp_fold_obj_type_ref (ref, known_type);
#else
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 method)
{
tree fndecl = build_decl (FUNCTION_DECL, name, type);
#ifdef OBJCPLUS
if (method
&& (strcmp (DECL_SOURCE_FILE (fndecl), DECL_SOURCE_FILE (method)) != 0
|| DECL_SOURCE_LINE (fndecl) != DECL_SOURCE_LINE (method)))
DECL_SOURCE_LOCATION (fndecl) = DECL_SOURCE_LOCATION (method);
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);
record_func_cl_pf_opts_mapping (fndecl);
start_preparsed_function (fndecl, attrs, SF_DEFAULT);
#else
struct c_label_context_se *nstack_se;
struct c_label_context_vm *nstack_vm;
if (method
&& (strcmp (DECL_SOURCE_FILE (fndecl), DECL_SOURCE_FILE (method)) != 0
|| DECL_SOURCE_LINE (fndecl) != DECL_SOURCE_LINE (method)))
DECL_SOURCE_LOCATION (fndecl) = DECL_SOURCE_LOCATION (method);
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;
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);
record_func_cl_pf_opts_mapping (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;
}
static void
really_start_method (tree method,
#ifdef OBJCPLUS
tree parmlist
#else
struct c_arg_info *parmlist
#endif
)
{
tree ret_type, meth_type;
tree method_id;
const char *sel_name, *class_name, *cat_name;
char *buf;
ret_type = TREE_VALUE (TREE_TYPE (method));
sel_name = IDENTIFIER_POINTER (METHOD_SEL_NAME (method));
class_name = IDENTIFIER_POINTER (CLASS_NAME (objc_implementation_context));
cat_name = ((TREE_CODE (objc_implementation_context)
== CLASS_IMPLEMENTATION_TYPE)
? NULL
: IDENTIFIER_POINTER (CLASS_SUPER_NAME (objc_implementation_context)));
method_slot++;
buf = (char *) alloca (50 + strlen (sel_name) + strlen (class_name)
+ (cat_name ? strlen (cat_name) : 0));
OBJC_GEN_METHOD_LABEL (buf, TREE_CODE (method) == INSTANCE_METHOD_DECL,
class_name, cat_name, sel_name, method_slot);
method_id = get_identifier (buf);
#ifdef OBJCPLUS
push_lang_context (lang_name_c);
#endif
meth_type
= build_function_type (ret_type,
get_arg_type_list (METHOD_SEL_NAME (method), method, METHOD_DEF, 0));
objc_start_function (method_id, meth_type, NULL_TREE, parmlist, method);
self_decl = DECL_ARGUMENTS (current_function_decl);
TREE_USED (self_decl) = 1;
TREE_USED (TREE_CHAIN (self_decl)) = 1;
#ifdef OBJCPLUS
pop_lang_context ();
#endif
METHOD_DEFINITION (method) = current_function_decl;
TREE_DEPRECATED (current_function_decl) = TREE_DEPRECATED (method);
if (implementation_template != objc_implementation_context)
{
tree proto
= lookup_method_static (implementation_template,
METHOD_SEL_NAME (method),
(TREE_CODE (method) == CLASS_METHOD_DECL),
false, false);
if (proto)
{
if (!comp_proto_with_proto (method, proto, 1))
{
char type = (TREE_CODE (method) == INSTANCE_METHOD_DECL ? '-' : '+');
warn_with_method ("conflicting types for", type, method);
warn_with_method ("previous declaration of", type, proto);
}
if (METHOD_DEFINITION (method))
TREE_THIS_VOLATILE (METHOD_DEFINITION (method))
= TREE_THIS_VOLATILE (proto);
}
else
{
tree interface = implementation_template;
if (TREE_CODE (objc_implementation_context)
== CATEGORY_IMPLEMENTATION_TYPE)
interface = lookup_category
(interface,
CLASS_SUPER_NAME (objc_implementation_context));
if (interface)
objc_add_method (interface, copy_node (method),
TREE_CODE (method) == CLASS_METHOD_DECL, 0);
}
}
}
static void *UOBJC_SUPER_scope = 0;
static tree
get_super_receiver (void)
{
if (objc_method_context)
{
tree super_expr, super_expr_list;
if (!UOBJC_SUPER_decl)
{
UOBJC_SUPER_decl = build_decl (VAR_DECL, get_identifier (TAG_SUPER),
objc_super_template);
TREE_USED (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 ();
}
super_expr = objc_build_component_ref (UOBJC_SUPER_decl, self_id);
if (cur_block)
{
tree local_self_decl = self_decl;
access_block_ref_self_decl (&local_self_decl);
super_expr = build_modify_expr (super_expr, NOP_EXPR, local_self_decl);
}
else
super_expr = build_modify_expr (super_expr, NOP_EXPR, self_decl);
super_expr_list = super_expr;
super_expr = objc_build_component_ref (UOBJC_SUPER_decl,
get_identifier ("cls"));
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
if (flag_objc_abi == 2)
{
tree class_expr;
class_expr = objc_v2_get_class_super_reference (
CLASS_NAME (objc_implementation_context),
(TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL));
super_expr = build_modify_expr (super_expr, NOP_EXPR, class_expr);
}
else
{
super_expr = build_modify_expr (super_expr, NOP_EXPR,
((TREE_CODE (objc_method_context)
== INSTANCE_METHOD_DECL)
? ucls_super_ref
: uucls_super_ref));
}
}
else
{
tree super_name = CLASS_SUPER_NAME (implementation_template);
tree super_class;
if (!super_name)
{
error ("no super class declared in interface for %qs",
IDENTIFIER_POINTER (CLASS_NAME (implementation_template)));
return error_mark_node;
}
if (flag_next_runtime && !flag_zero_link)
{
super_class = objc_get_class_reference ((flag_objc_abi == 2)
? CLASS_NAME (implementation_template)
: super_name);
if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL)
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_pointer
(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;
}
}
void
objc_clear_super_receiver (void)
{
if (objc_method_context
&& UOBJC_SUPER_scope == objc_get_current_scope ()) {
UOBJC_SUPER_decl = 0;
UOBJC_SUPER_scope = 0;
}
}
void
objc_finish_method_definition (tree fndecl)
{
DECL_INLINE (fndecl) = 0;
DECL_UNINLINABLE (fndecl) = 1;
#ifndef OBJCPLUS
finish_function ();
#endif
METHOD_ENCODING (objc_method_context)
= encode_method_prototype (objc_method_context);
objc_method_context = NULL_TREE;
if (should_call_super_dealloc)
warning (0, "method possibly missing a [super dealloc] call");
if (should_call_super_finalize)
warning (0, "method possibly missing a [super finalize] call");
}
#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;
}
else
return 0;
}
#endif
static char *
gen_declaration (tree decl)
{
errbuf[0] = '\0';
if (DECL_P (decl))
{
gen_type_name_0 (TREE_TYPE (decl));
if (DECL_NAME (decl))
{
if (!POINTER_TYPE_P (TREE_TYPE (decl)))
strcat (errbuf, " ");
strcat (errbuf, IDENTIFIER_POINTER (DECL_NAME (decl)));
}
if (DECL_INITIAL (decl)
&& TREE_CODE (DECL_INITIAL (decl)) == INTEGER_CST)
sprintf (errbuf + strlen (errbuf), ": " HOST_WIDE_INT_PRINT_DEC,
TREE_INT_CST_LOW (DECL_INITIAL (decl)));
}
return errbuf;
}
static char *
gen_type_name_0 (tree type)
{
tree orig = type, proto;
if (TYPE_P (type) && TYPE_NAME (type))
type = TYPE_NAME (type);
else if (POINTER_TYPE_P (type) || TREE_CODE (type) == ARRAY_TYPE)
{
tree inner = TREE_TYPE (type);
while (TREE_CODE (inner) == ARRAY_TYPE)
inner = TREE_TYPE (inner);
gen_type_name_0 (inner);
if (!POINTER_TYPE_P (inner))
strcat (errbuf, " ");
if (POINTER_TYPE_P (type))
strcat (errbuf, "*");
else
while (type != inner)
{
strcat (errbuf, "[");
if (TYPE_DOMAIN (type))
{
char sz[20];
sprintf (sz, HOST_WIDE_INT_PRINT_DEC,
(TREE_INT_CST_LOW
(TYPE_MAX_VALUE (TYPE_DOMAIN (type))) + 1));
strcat (errbuf, sz);
}
strcat (errbuf, "]");
type = TREE_TYPE (type);
}
goto exit_function;
}
if (TREE_CODE (type) == TYPE_DECL && DECL_NAME (type))
type = DECL_NAME (type);
strcat (errbuf, TREE_CODE (type) == IDENTIFIER_NODE
? IDENTIFIER_POINTER (type)
: "");
if (objc_is_id (orig))
orig = TREE_TYPE (orig);
proto = TYPE_HAS_OBJC_INFO (orig) ? TYPE_OBJC_PROTOCOL_LIST (orig) : NULL_TREE;
if (proto)
{
strcat (errbuf, " <");
while (proto) {
strcat (errbuf,
IDENTIFIER_POINTER (PROTOCOL_NAME (TREE_VALUE (proto))));
proto = TREE_CHAIN (proto);
strcat (errbuf, proto ? ", " : ">");
}
}
exit_function:
return errbuf;
}
static char *
gen_type_name (tree type)
{
errbuf[0] = '\0';
return gen_type_name_0 (type);
}
static char *
gen_method_decl (tree method)
{
tree chain;
strcpy (errbuf, "(");
gen_type_name_0 (TREE_VALUE (TREE_TYPE (method)));
strcat (errbuf, ")");
chain = METHOD_SEL_ARGS (method);
if (chain)
{
do
{
if (KEYWORD_KEY_NAME (chain))
strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_KEY_NAME (chain)));
strcat (errbuf, ":(");
gen_type_name_0 (TREE_VALUE (TREE_TYPE (chain)));
strcat (errbuf, ")");
strcat (errbuf, IDENTIFIER_POINTER (KEYWORD_ARG_NAME (chain)));
if ((chain = TREE_CHAIN (chain)))
strcat (errbuf, " ");
}
while (chain);
if (METHOD_ADD_ARGS (method))
{
chain = TREE_CHAIN (METHOD_ADD_ARGS (method));
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
strcat (errbuf, IDENTIFIER_POINTER (METHOD_SEL_NAME (method)));
return errbuf;
}
static void
dump_interface (FILE *fp, tree chain)
{
const char *my_name = IDENTIFIER_POINTER (CLASS_NAME (chain));
tree ivar_decls = CLASS_RAW_IVARS (chain);
tree nst_methods = CLASS_NST_METHODS (chain);
tree cls_methods = CLASS_CLS_METHODS (chain);
fprintf (fp, "\n@interface %s", my_name);
if (CLASS_SUPER_NAME (chain))
{
const char *name = IDENTIFIER_POINTER (CLASS_SUPER_NAME (chain));
if (TREE_CODE (chain) == CATEGORY_IMPLEMENTATION_TYPE
|| TREE_CODE (chain) == CATEGORY_INTERFACE_TYPE)
{
fprintf (fp, " (%s)\n", name);
}
else
{
fprintf (fp, " : %s\n", name);
}
}
else
fprintf (fp, "\n");
if (ivar_decls)
{
fprintf (fp, "{\n");
do
{
fprintf (fp, "\t%s;\n", gen_declaration (ivar_decls));
ivar_decls = TREE_CHAIN (ivar_decls);
}
while (ivar_decls);
fprintf (fp, "}\n");
}
while (nst_methods)
{
fprintf (fp, "- %s;\n", gen_method_decl (nst_methods));
nst_methods = TREE_CHAIN (nst_methods);
}
while (cls_methods)
{
fprintf (fp, "+ %s;\n", gen_method_decl (cls_methods));
cls_methods = TREE_CHAIN (cls_methods);
}
fprintf (fp, "@end\n");
}
static const char *
objc_demangle (tree decl, int vrb)
{
char *demangled, *cp;
const char *mangled = IDENTIFIER_POINTER (DECL_NAME (decl));
if (mangled[0] == '_' &&
(mangled[1] == 'i' || mangled[1] == 'c') &&
mangled[2] == '_')
{
cp = demangled = XNEWVEC (char, strlen(mangled) + 2);
if (mangled[1] == 'i')
*cp++ = '-';
else
*cp++ = '+';
*cp++ = '[';
strcpy(cp, mangled+3);
while (*cp && *cp == '_')
cp++;
cp = strchr(cp, '_');
if (cp == NULL)
{
free(demangled);
return mangled;
}
if (cp[1] == '_')
{
*cp++ = ' ';
strcpy(cp, mangled + (cp - demangled) + 2);
}
else
{
*cp++ = '(';
cp = strchr(cp, '_');
if (cp == 0)
{
free(demangled);
return mangled;
}
*cp++ = ')';
*cp++ = ' ';
strcpy(cp, mangled + (cp - demangled));
}
while (*cp && *cp == '_')
cp++;
for (; *cp; cp++)
if (*cp == '_')
*cp = ':';
*cp++ = ']';
*cp++ = 0;
return demangled;
}
else
#ifdef OBJCPLUS
return cxx_printable_name (decl, vrb);
#else
return vrb == 2 ? mangled : mangled;
#endif
}
const char *
objc_printable_name (tree decl, int vrb)
{
return objc_demangle (decl, vrb);
}
static void
init_objc (void)
{
gcc_obstack_init (&util_obstack);
util_firstobj = (char *) obstack_finish (&util_obstack);
errbuf = XNEWVEC (char, 1024 * 10);
hash_init ();
synth_module_prologue ();
}
static void
finish_objc (void)
{
struct imp_entry *impent;
tree chain;
int save_warn_missing_braces = warn_missing_braces;
warn_missing_braces = 0;
if (objc_implementation_context)
{
warning (0, "%<@end%> missing in implementation context");
finish_class (objc_implementation_context);
objc_ivar_chain = NULL_TREE;
objc_implementation_context = NULL_TREE;
}
if (objc_static_instances)
generate_static_references ();
if (imp_list || class_names_chain
|| prop_names_attr_chain
|| meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
generate_objc_symtab_decl ();
for (impent = imp_list; impent; impent = impent->next)
{
objc_implementation_context = impent->imp_context;
implementation_template = impent->imp_template;
if (flag_objc_abi == 2)
{
UOBJC_V2_CLASS_decl = impent->class_v2_decl;
UOBJC_V2_METACLASS_decl = impent->meta_v2_decl;
}
else
{
UOBJC_CLASS_decl = impent->class_decl;
UOBJC_METACLASS_decl = impent->meta_decl;
}
if (flag_gen_declaration)
{
dump_interface (gen_declaration_file, objc_implementation_context);
}
if (TREE_CODE (objc_implementation_context) == CLASS_IMPLEMENTATION_TYPE)
{
if (flag_objc_abi == 2)
{
generate_v2_ivar_lists ();
generate_v2_dispatch_tables ();
generate_v2_property_tables (NULL_TREE);
generate_v2_shared_structures (impent->has_cxx_cdtors
? OBJC2_CLS_HAS_CXX_STRUCTORS
: 0);
}
else
{
generate_ivar_lists ();
generate_dispatch_tables ();
generate_v2_property_tables (NULL_TREE);
UOBJC_CLASS_EXT_decl = generate_objc_class_ext (UOBJC_V2_PROPERTY_decl);
generate_shared_structures (impent->has_cxx_cdtors
? CLS_HAS_CXX_STRUCTORS
: 0);
}
}
else
{
if (flag_objc_abi == 2)
{
generate_v2_dispatch_tables ();
generate_v2_property_tables (NULL_TREE);
generate_v2_category (objc_implementation_context, impent);
}
else
{
generate_dispatch_tables ();
generate_v2_property_tables (NULL_TREE);
generate_category (objc_implementation_context, impent);
}
}
}
if (! flag_next_runtime || sel_ref_chain)
build_selector_translation_table ();
if (message_ref_chain)
build_message_ref_translation_table ();
if (classlist_ref_chain)
build_classlist_translation_table (false);
if (metaclasslist_ref_chain)
build_classlist_translation_table (true);
if (classlist_super_ref_chain)
build_classlist_super_translation_table (false);
if (metaclasslist_super_ref_chain)
build_classlist_super_translation_table (true);
if (ivar_offset_ref_chain)
generate_v2_ivar_offset_ref_lists ();
if (protocol_chain)
{
if (flag_objc_abi == 2)
{
generate_v2_protocols ();
}
else
generate_protocols ();
}
if (protocol_list_chain)
build_protocol_list_address_table ();
if (protocollist_ref_chain)
build_protocollist_translation_table ();
if (class_list_chain)
build_class_list_address_table (false);
if (category_list_chain)
build_category_list_address_table (false);
if (nonlazy_class_list_chain)
build_class_list_address_table (true);
if (nonlazy_category_list_chain)
build_category_list_address_table (true);
generate_objc_image_info ();
if (objc_implementation_context || class_names_chain || objc_static_instances
|| meth_var_names_chain || meth_var_types_chain || sel_ref_chain)
{
if (flag_objc_abi != 2)
build_module_descriptor ();
if (!flag_next_runtime)
build_module_initializer_routine ();
}
for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
{
handle_class_ref (chain);
if (TREE_PURPOSE (chain))
generate_classref_translation_entry (chain);
}
for (impent = imp_list; impent; impent = impent->next)
handle_impent (impent);
if (warn_selector)
{
int slot;
hash hsh;
for (slot = 0; slot < SIZEHASHTABLE; slot++)
{
for (hsh = cls_method_hash_list[slot]; hsh; hsh = hsh->next)
check_duplicates (hsh, 0, 1);
for (hsh = nst_method_hash_list[slot]; hsh; hsh = hsh->next)
check_duplicates (hsh, 0, 1);
}
}
warn_missing_braces = save_warn_missing_braces;
}
static void
generate_classref_translation_entry (tree chain)
{
tree expr, decl, type;
decl = TREE_PURPOSE (chain);
type = TREE_TYPE (decl);
expr = add_objc_string (TREE_VALUE (chain), class_names);
expr = convert (type, expr);
finish_var_decl (decl, expr);
return;
}
static void
handle_class_ref (tree chain)
{
const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
char *string = (char *) alloca (strlen (name) + 30);
tree decl;
tree exp;
sprintf (string, "%sobjc_class_name_%s",
(flag_next_runtime ? "." : "__"), name);
#ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
if (flag_next_runtime)
{
ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string);
return;
}
#endif
decl = build_decl (VAR_DECL, get_identifier (string), char_type_node);
DECL_EXTERNAL (decl) = 1;
TREE_PUBLIC (decl) = 1;
pushdecl (decl);
rest_of_decl_compilation (decl, 0, 0);
sprintf (string, "%sobjc_class_ref_%s",
(flag_next_runtime ? "." : "__"), name);
exp = build1 (ADDR_EXPR, string_type_node, decl);
decl = build_decl (VAR_DECL, get_identifier (string), string_type_node);
DECL_INITIAL (decl) = exp;
TREE_STATIC (decl) = 1;
TREE_USED (decl) = 1;
mark_decl_referenced (decl);
pushdecl (decl);
rest_of_decl_compilation (decl, 0, 0);
}
static void
handle_impent (struct imp_entry *impent)
{
char *string;
objc_implementation_context = impent->imp_context;
implementation_template = impent->imp_template;
if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
{
const char *const class_name =
IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
string = (char *) alloca (strlen (class_name) + 30);
sprintf (string, "%sobjc_class_name_%s",
(flag_next_runtime ? "." : "__"), class_name);
}
else if (flag_objc_abi <= 1 && TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
const char *const class_name =
IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context));
const char *const class_super_name =
IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context));
string = (char *) alloca (strlen (class_name)
+ strlen (class_super_name) + 30);
sprintf (string, "*%sobjc_category_name_%s_%s",
(flag_next_runtime ? "." : "__"), class_name, class_super_name);
}
else
return;
#ifdef ASM_DECLARE_CLASS_REFERENCE
if (flag_next_runtime)
{
ASM_DECLARE_CLASS_REFERENCE (asm_out_file, string);
return;
}
else
#endif
{
tree decl, init;
init = build_int_cst (c_common_type_for_size (BITS_PER_WORD, 1), 0);
decl = build_decl (VAR_DECL, get_identifier (string), TREE_TYPE (init));
TREE_PUBLIC (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_USED (decl) = 1;
TREE_CONSTANT (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
DECL_INITIAL (decl) = init;
assemble_variable (decl, 1, 0, 0);
}
}
static void
generate_objc_image_info (void)
{
tree decl, initlist;
int flags
= ((flag_replace_objc_classes && imp_list ? 1 : 0)
| (flag_objc_gc ? 2 : 0));
if (flag_objc_gc_only)
flags |= 6;
if (flag_objc_abi == 2)
flags |= 16;
decl = build_decl (VAR_DECL, get_identifier ("_OBJC_IMAGE_INFO"),
build_array_type
(integer_type_node,
build_index_type (build_int_cst (NULL_TREE, 2 - 1))));
initlist = build_tree_list (NULL_TREE, integer_zero_node);
initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, flags), initlist);
initlist = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
TREE_TYPE (initlist) = TREE_TYPE (decl);
TREE_PUBLIC (decl) = 0;
TREE_STATIC (decl) = 1;
TREE_READONLY (decl) = 1;
TREE_USED (decl) = 1;
TREE_CONSTANT (decl) = 1;
DECL_CONTEXT (decl) = 0;
DECL_ARTIFICIAL (decl) = 1;
DECL_INITIAL (decl) = initlist;
assemble_variable (decl, 1, 0, 0);
}
bool
objc_diagnose_private_ivar (tree id)
{
tree ivar;
if (!objc_method_context)
return false;
ivar = is_ivar (objc_ivar_chain, id);
if (ivar && is_private (ivar))
{
error ("instance variable %qs is declared private",
IDENTIFIER_POINTER (id));
return true;
}
return false;
}
tree
objc_lookup_ivar (tree other, tree id)
{
tree ivar;
if (!objc_method_context)
return other;
if (other && TREE_CODE (other) == VAR_DECL &&
(BLOCK_DECL_BYREF (other) || BLOCK_DECL_COPIED (other)))
return other;
if (!strcmp (IDENTIFIER_POINTER (id), "super"))
return get_super_receiver ();
if (TREE_CODE (objc_method_context) == CLASS_METHOD_DECL
&& other && other != error_mark_node)
return other;
ivar = is_ivar (objc_ivar_chain, id);
if (!ivar || is_private (ivar))
return other;
if (TREE_CODE (objc_method_context) == INSTANCE_METHOD_DECL
&& other && other != error_mark_node
#ifdef OBJCPLUS
&& CP_DECL_CONTEXT (other) != global_namespace)
#else
&& !DECL_FILE_SCOPE_P (other))
#endif
{
warning (0, "local declaration of %qs hides instance variable",
IDENTIFIER_POINTER (id));
return other;
}
return build_ivar_reference (id);
}
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;
}
tree objc_build_property_getter_func_call (tree pref_expr)
{
tree getter_call;
tree save_UOBJC_SUPER_decl = UOBJC_SUPER_decl;
UOBJC_SUPER_decl = TREE_OPERAND (pref_expr, 2);
getter_call = objc_build_getter_call (TREE_OPERAND (pref_expr, 0),
TREE_OPERAND (pref_expr, 1));
UOBJC_SUPER_decl = save_UOBJC_SUPER_decl;
return getter_call;
}
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)
{
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);
}
else if (TREE_CODE (*expr_p) == OBJC_WEAK_REFERENCE_EXPR)
{
tree expr = TREE_OPERAND (*expr_p, 0);
tree t = TREE_TYPE (expr);
expr = objc_build_weak_read (expr);
expr = convert (t, expr);
*expr_p = expr;
}
else if (objc_property_reference_expr (*expr_p))
*expr_p = objc_build_property_getter_func_call (*expr_p);
#ifdef OBJCPLUS
return cp_gimplify_expr (expr_p, pre_p, post_p);
#else
return c_gimplify_expr (expr_p, pre_p, post_p);
#endif
}
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 (TREE_CODE (addr) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
return TREE_OPERAND (addr, 0);
return 0;
}
static void
build_objc_fast_enum_state_type (void)
{
tree field_decl, field_decl_chain;
objc_fast_enum_state_type = start_struct (RECORD_TYPE,
get_identifier ("__objcFastEnumerationState"));
field_decl = create_field_decl (long_unsigned_type_node, "state");
field_decl_chain = field_decl;
field_decl = create_field_decl (build_pointer_type (objc_object_type), "itemsPtr");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_pointer_type (
long_unsigned_type_node), "mutationsPtr");
chainon (field_decl_chain, field_decl);
field_decl = create_field_decl (build_array_type
(long_unsigned_type_node,
build_index_type
(build_int_cst (NULL_TREE, 5 - 1))),
"extra");
chainon (field_decl_chain, field_decl);
finish_struct (objc_fast_enum_state_type, field_decl_chain, NULL_TREE);
}
static tree
objc_create_named_tmp_var (tree type, const char *prefix)
{
tree decl = create_tmp_var_raw (type, prefix);
DECL_CONTEXT (decl) = current_function_decl;
return decl;
}
tree
objc_build_foreach_components (tree receiver, tree *enumState_decl,
tree *items_decl,
tree *limit_decl,
tree *startMutations_decl,
tree *counter_decl,
tree *countByEnumeratingWithState)
{
tree constructor_fields, initlist, init;
tree type, exp;
tree sel_name, method_params;
tree fast_enum_state_type = objc_fast_enum_state_type;
tree enum_st_type_decl = lookup_name (get_identifier ("NSFastEnumerationState"));
OBJC_WARN_OBJC2_FEATURES ("foreach-collection-statement");
if (enum_st_type_decl && TREE_CODE (enum_st_type_decl) == TYPE_DECL)
fast_enum_state_type = DECL_ORIGINAL_TYPE (enum_st_type_decl)
? DECL_ORIGINAL_TYPE (enum_st_type_decl)
: TREE_TYPE (enum_st_type_decl);
gcc_assert (fast_enum_state_type != NULL_TREE
&& TREE_CODE (fast_enum_state_type) == RECORD_TYPE);
constructor_fields = TYPE_FIELDS (fast_enum_state_type);
*enumState_decl = objc_create_named_tmp_var (fast_enum_state_type, "cstar");
initlist = build_tree_list (constructor_fields,
convert (TREE_TYPE(constructor_fields),
integer_zero_node));
init = objc_build_constructor (fast_enum_state_type, initlist);
DECL_INITIAL (*enumState_decl) = init;
type = build_array_type (objc_object_type,
build_index_type (build_int_cst (NULL_TREE, 16 - 1)));
*items_decl = objc_create_named_tmp_var (type, "cstar");
*limit_decl = objc_create_named_tmp_var (long_unsigned_type_node, "cstar");
*startMutations_decl = objc_create_named_tmp_var (long_unsigned_type_node, "cstar");
*counter_decl = objc_create_named_tmp_var (long_unsigned_type_node, "cstar");
sel_name = get_identifier ("countByEnumeratingWithState:objects:count:");
exp = build_fold_addr_expr (*enumState_decl);
method_params = build_tree_list (NULL_TREE, exp);
#ifndef OBJCPLUS
{
struct c_expr cexpr;
cexpr.value = *items_decl;
chainon (method_params,
build_tree_list (NULL_TREE,
default_function_array_conversion (cexpr).value));
}
#else
chainon (method_params,
build_tree_list (NULL_TREE, *items_decl));
#endif
chainon (method_params,
build_tree_list (NULL_TREE, build_int_cst (NULL_TREE, 16)));
exp = objc_finish_message_expr (receiver, sel_name, method_params);
*countByEnumeratingWithState = exp;
exp = build_function_call (objc_enum_mutation_decl,
build_tree_list (NULL_TREE, save_expr (receiver)));
return exp;
}
bool
objc_type_valid_for_messaging (tree typ)
{
if (TREE_CODE (typ) == BLOCK_POINTER_TYPE)
return true;
if (!POINTER_TYPE_P (typ))
return false;
if (objc_nsobject_attribute_type (typ))
return true;
do
typ = TREE_TYPE (typ);
while (POINTER_TYPE_P (typ));
if (TREE_CODE (typ) != RECORD_TYPE)
return false;
return objc_is_object_id (typ)
|| objc_is_class_id (typ) || TYPE_HAS_OBJC_INFO (typ);
}
#ifndef OBJCPLUS
void
objc_finish_foreach_loop (location_t location, tree cond, tree for_body, tree blab, tree clab)
{
tree enumState_decl, items_decl, limit_decl, limit_decl_assign_expr;
tree startMutations_decl, counter_decl;
tree enumerationMutation_call_exp, countByEnumeratingWithState;
tree exp;
tree receiver, elem_decl;
tree bind;
tree if_condition, do_condition;
tree outer_if_body, inner_if_body;
tree outer_if_block_start, inner_if_block_start;
tree outer_do_body, inner_do_body;
tree inner_do_block_start, outer_do_block_start;
tree body;
location_t save_input_location = input_location;
tree exit_label;
tree outer_else_body;
receiver = TREE_VALUE (cond);
elem_decl = TREE_PURPOSE (cond);
if (!lvalue_or_else (&elem_decl, lv_foreach))
return;
if (!objc_type_valid_for_messaging (TREE_TYPE (elem_decl)))
{
error ("selector element does not have a valid object type");
return;
}
if (!objc_type_valid_for_messaging (TREE_TYPE (receiver)))
{
error ("expression does not have a valid object type");
return;
}
input_location = location;
enumerationMutation_call_exp = objc_build_foreach_components (receiver, &enumState_decl,
&items_decl, &limit_decl,
&startMutations_decl, &counter_decl,
&countByEnumeratingWithState);
exp = build_stmt (DECL_EXPR, enumState_decl);
bind = build3 (BIND_EXPR, void_type_node, enumState_decl, exp, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
bind = build3 (BIND_EXPR, void_type_node, items_decl, NULL, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
limit_decl_assign_expr = build2 (MODIFY_EXPR, TREE_TYPE (limit_decl), limit_decl,
countByEnumeratingWithState);
bind = build3 (BIND_EXPR, void_type_node, limit_decl, NULL, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
outer_if_block_start = c_begin_compound_stmt (true);
outer_if_body = c_begin_compound_stmt (true);
exp = objc_build_component_ref (enumState_decl, get_identifier("mutationsPtr"));
exp = build_indirect_ref (exp, "unary *");
exp = build2 (MODIFY_EXPR, void_type_node, startMutations_decl, exp);
bind = build3 (BIND_EXPR, void_type_node, startMutations_decl, exp, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
outer_do_block_start = c_begin_compound_stmt (true);
outer_do_body = c_begin_compound_stmt (true);
exp = build2 (MODIFY_EXPR, void_type_node, counter_decl,
fold_convert (TREE_TYPE (counter_decl), integer_zero_node));
bind = build3 (BIND_EXPR, void_type_node, counter_decl, exp, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
inner_do_block_start = c_begin_compound_stmt (true);
inner_do_body = c_begin_compound_stmt (true);
inner_if_block_start = c_begin_compound_stmt (true);
inner_if_body = c_begin_compound_stmt (true);
exp = objc_build_component_ref (enumState_decl,
get_identifier ("mutationsPtr"));
exp = build_indirect_ref (exp, "unary *");
if_condition = build_binary_op (NE_EXPR, startMutations_decl, exp, 1);
body = build_function_call (objc_enum_mutation_decl,
build_tree_list (NULL_TREE, save_expr (receiver)));
add_stmt (body);
inner_if_body = c_end_compound_stmt (inner_if_body, true);
c_finish_if_stmt (location, if_condition, inner_if_body, NULL, false);
add_stmt (c_end_compound_stmt (inner_if_block_start, true));
exp = objc_build_component_ref (enumState_decl, get_identifier("itemsPtr"));
exp = build_array_ref (exp, counter_decl);
add_stmt (build2 (MODIFY_EXPR, void_type_node, elem_decl, exp));
TREE_USED (elem_decl) = 1;
exp = build2 (PLUS_EXPR, TREE_TYPE (counter_decl), counter_decl,
build_int_cst (NULL_TREE, 1));
add_stmt (build2 (MODIFY_EXPR, void_type_node, counter_decl, exp));
add_stmt (for_body);
do_condition = build_binary_op (LT_EXPR, counter_decl, limit_decl, 1);
inner_do_body = c_end_compound_stmt (inner_do_body, true);
\
c_finish_loop (location, do_condition, NULL, inner_do_body, NULL_TREE, clab,
NULL_TREE, false);
\
add_stmt (c_end_compound_stmt (inner_do_block_start, true));
exp = unshare_expr (limit_decl_assign_expr);
do_condition = build_binary_op (NE_EXPR, exp,
fold_convert (TREE_TYPE (limit_decl), integer_zero_node),
1);
outer_do_body = c_end_compound_stmt (outer_do_body, true);
exit_label = create_artificial_label ();
\
c_finish_loop (location, do_condition, NULL, outer_do_body, exit_label,
NULL_TREE, NULL_TREE, false);
\
add_stmt (build2 (MODIFY_EXPR, void_type_node, elem_decl,
fold_convert (TREE_TYPE (elem_decl), integer_zero_node)));
if (blab)
add_stmt (build1 (LABEL_EXPR, void_type_node, blab));
add_stmt (c_end_compound_stmt (outer_do_block_start, true));
if_condition = unshare_expr (do_condition);
outer_if_body = c_end_compound_stmt (outer_if_body, true);
outer_else_body = c_begin_compound_stmt (true);
add_stmt (build2 (MODIFY_EXPR, void_type_node, elem_decl,
fold_convert (TREE_TYPE (elem_decl), integer_zero_node)));
outer_else_body = c_end_compound_stmt (outer_else_body, true);
c_finish_if_stmt (location, if_condition, outer_if_body, outer_else_body, false);
add_stmt (c_end_compound_stmt (outer_if_block_start, true));
input_location = save_input_location;
return;
}
#endif
void
diagnose_selector_cast (tree cast_type, tree sel_exp)
{
tree type = TREE_TYPE (sel_exp);
if (type)
{
if (type == objc_selector_type && cast_type != objc_selector_type)
if (flag_objc_abi == 2 || flag_objc2_check)
warning (0, "type-cast of @selector expression won't be supported in future");
}
}
bool
objc_method_decl (enum tree_code opcode)
{
return opcode == INSTANCE_METHOD_DECL || opcode == CLASS_METHOD_DECL;
}
static tree
objc_build_compound_incr_decr_setter_call (tree receiver, tree prop_ident,
enum tree_code code, tree getter_expr,
tree inc)
{
tree temp, bind, rhs, comma_exp;
temp = objc_create_named_tmp_var (TREE_TYPE (inc), "prop");
bind = build3 (BIND_EXPR, void_type_node, temp, NULL, NULL);
TREE_SIDE_EFFECTS (bind) = 1;
add_stmt (bind);
if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
rhs = getter_expr;
else if (code == PREINCREMENT_EXPR)
rhs = build2 (PLUS_EXPR, TREE_TYPE (inc), getter_expr, inc);
else
rhs = build2 (MINUS_EXPR, TREE_TYPE (inc), getter_expr, inc);
comma_exp = build_modify_expr (temp, NOP_EXPR, rhs);
if (code == PREINCREMENT_EXPR || code == PREDECREMENT_EXPR)
rhs = temp;
else if (code == POSTINCREMENT_EXPR)
rhs = build2 (PLUS_EXPR, TREE_TYPE (inc), temp, inc);
else
rhs = build2 (MINUS_EXPR, TREE_TYPE (inc), temp, inc);
comma_exp = build_compound_expr (comma_exp,
objc_setter_func_call (receiver, prop_ident, rhs));
TREE_NO_WARNING (temp) = 1;
return build_compound_expr (comma_exp, temp);
}
tree
objc_build_incr_decr_setter_call (enum tree_code code, tree lhs, tree inc)
{
if (objc_property_reference_expr (lhs))
{
tree expr = objc_build_getter_call (TREE_OPERAND (lhs, 0), TREE_OPERAND (lhs, 1));
return objc_build_compound_incr_decr_setter_call
(TREE_OPERAND (lhs, 0), TREE_OPERAND (lhs, 1), code, expr, inc);
}
return NULL_TREE;
}
static tree
lookup_nested_property (tree interface_type, tree property)
{
tree inter = interface_type;
while (inter)
{
tree x;
if ((x = lookup_property_in_list (inter, property)))
return x;
inter = lookup_interface (CLASS_SUPER_NAME (inter));
}
return NULL_TREE;
}
static tree
lookup_nested_method (tree interface_type, tree method_name)
{
tree inter = interface_type;
while (inter)
{
tree x;
if ((x = lookup_method (CLASS_NST_METHODS (inter), method_name)) ||
(x = lookup_method_in_protocol_list
(CLASS_PROTOCOL_LIST (inter), method_name, 0)))
return x;
inter = lookup_interface (CLASS_SUPER_NAME (inter));
}
return NULL_TREE;
}
static tree
lookup_property_impl_in_list (tree chain, tree property)
{
tree x;
for (x = IMPL_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x))
if (PROPERTY_NAME (x) == property)
return x;
return NULL_TREE;
}
static tree
lookup_ivar_in_property_list (tree chain, tree ivar_name)
{
tree x;
for (x = IMPL_PROPERTY_DECL (chain); x; x = TREE_CHAIN (x))
if (PROPERTY_IVAR_NAME (x) == ivar_name)
return x;
return NULL_TREE;
}
static void error_previous_property_decl (tree x)
{ tree decl = build_decl (VAR_DECL, DECL_NAME (x), TREE_TYPE (x));
DECL_SOURCE_LOCATION (decl) = DECL_SOURCE_LOCATION (x);
error ("previous property declaration of %q+D was here", decl);
}
void objc_declare_property_impl (int impl_code, tree tree_list)
{
tree chain, interface, class;
if (tree_list == error_mark_node
|| TREE_PURPOSE (tree_list) == error_mark_node
|| TREE_VALUE (tree_list) == error_mark_node)
return;
if (objc_implementation_context == NULL_TREE)
{
error ("@%s property must be in implementation context",
impl_code == 1 ? "synthesize" : "dynamic");
return;
}
interface = lookup_interface (CLASS_NAME (objc_implementation_context));
if (!interface)
{
error ("%s property may not be specified in implementation without an interface",
impl_code == 1 ? "synthesize" : "dynamic");
return;
}
class = interface;
if (TREE_CODE (objc_implementation_context) == CATEGORY_IMPLEMENTATION_TYPE)
{
if (impl_code == 1)
error ("@synthesize not allowed in a category's implementation");
interface = lookup_category (interface,
CLASS_SUPER_NAME (objc_implementation_context));
if (!interface && (impl_code == 2))
{
error ("@dynamic may not be specified in category without an interface");
return;
}
}
if (impl_code == 1 || impl_code == 2)
{
for (chain = tree_list; chain; chain = TREE_CHAIN (chain))
{
tree property_name = TREE_VALUE (chain);
tree x;
if (!property_name)
continue;
x = lookup_nested_property (interface, property_name);
if (!x)
error ("no declaration of property %qs found in the interface",
IDENTIFIER_POINTER (property_name));
else
{
tree property_decl = copy_node (x);
DECL_SOURCE_LOCATION (property_decl) = input_location;
if (impl_code == 2)
PROPERTY_DYNAMIC (property_decl) = boolean_true_node;
else
{
tree ivar_decl;
tree ivar_name = TREE_PURPOSE (chain);
if (!ivar_name)
ivar_name = property_name;
PROPERTY_IVAR_NAME (property_decl) = ivar_name;
ivar_decl = nested_ivar_lookup (class, ivar_name);
if (flag_objc_abi <= 1 && TREE_PURPOSE (chain) && !ivar_decl)
warning (0, "ivar name %qs specified on the synthesized property %qs not found",
IDENTIFIER_POINTER (ivar_name), IDENTIFIER_POINTER (property_name)) ;
if (ivar_decl)
{
tree ivar_type = DECL_BIT_FIELD_TYPE (ivar_decl)
? DECL_BIT_FIELD_TYPE (ivar_decl)
: TREE_TYPE (ivar_decl);
tree property_type = TREE_TYPE (property_decl);
bool comparison_result;
if (flag_new_property_ivar_synthesis && flag_objc_abi == 2) {
tree record = CLASS_STATIC_TEMPLATE (class);
if (record && record != DECL_CONTEXT (ivar_decl))
error ("property %qs attempting to use ivar %qs declared in super class of %qs",
IDENTIFIER_POINTER (property_name),
IDENTIFIER_POINTER (ivar_name),
IDENTIFIER_POINTER (OBJC_TYPE_NAME (record)));
}
#ifdef OBJCPLUS
if (TREE_CODE (property_type) == REFERENCE_TYPE)
{
property_type = TREE_TYPE (property_type);
comparison_result =
!objcp_reference_related_p (property_type, ivar_type);
}
else
#endif
comparison_result = comptypes (ivar_type, property_type) != 1;
if (comparison_result
&& !objc_compare_types (property_type, ivar_type, -5, NULL_TREE, NULL))
{
error ("type of property %qs does not match type of ivar %qs",
IDENTIFIER_POINTER (property_name), IDENTIFIER_POINTER (ivar_name));
PROPERTY_DYNAMIC (property_decl) = boolean_true_node;
}
if (flag_objc_gc)
{
int strong = objc_is_gcable_type (property_type);
if (strong)
{
int gc_able = objc_is_gcable_type (ivar_type);
if (strong != gc_able)
{
if (strong == -1)
error ("existing ivar %qs for the '__weak' property %qs must be __weak",
IDENTIFIER_POINTER (ivar_name),
IDENTIFIER_POINTER (property_name));
else
error ("existing ivar %qs for a '__strong' property %qs must be garbage collectable",
IDENTIFIER_POINTER (ivar_name),
IDENTIFIER_POINTER (property_name));
}
}
}
}
else if (flag_new_property_ivar_synthesis)
objc_lookup_property_ivar (class, property_decl);
if (flag_new_property_ivar_synthesis &&
(x = lookup_ivar_in_property_list (objc_implementation_context,
ivar_name)))
{
error ("synthesized properties %qs and %qs both claim ivar %qs",
IDENTIFIER_POINTER (property_name),
IDENTIFIER_POINTER (DECL_NAME (x)),
IDENTIFIER_POINTER (ivar_name));
error_previous_property_decl (x);
}
}
if (flag_new_property_ivar_synthesis &&
(x = lookup_property_impl_in_list (objc_implementation_context, property_name)))
{
error ("property %qs is already implemented",
IDENTIFIER_POINTER (property_name));
error_previous_property_decl (x);
}
TREE_CHAIN (property_decl) = IMPL_PROPERTY_DECL (objc_implementation_context);
IMPL_PROPERTY_DECL (objc_implementation_context) = property_decl;
}
}
}
else
gcc_assert (false);
}
bool
objc_check_nsstring_pointer_type (tree type)
{
tree NSString_type;
if (TREE_CODE (type) != POINTER_TYPE)
return false;
NSString_type = buildNSStringType();
if (!NSString_type)
return false;
return (TYPE_MAIN_VARIANT (TREE_TYPE (type)) == NSString_type);
}
bool
objc_check_format_nsstring (tree argument,
unsigned HOST_WIDE_INT format_num,
bool *no_add_attrs)
{
unsigned HOST_WIDE_INT i;
for (i = 1; i != format_num; i++)
{
if (argument == 0)
break;
argument = TREE_CHAIN (argument);
}
if (!argument || !objc_check_nsstring_pointer_type (TREE_VALUE (argument)))
{
error ("format NSString argument not an 'NSString *' type");
*no_add_attrs = true;
return false;
}
return true;
}
bool
objc_anonymous_local_objc_name (const char * name)
{
const char *p = name;
#ifdef OBJCPLUS
if (!strncmp (p, "_ZL", 3))
{
p += 3;
while (p && ISDIGIT (*p))
p++;
}
#endif
return p && !strncmp (p, "_OBJC_", 6);
}
bool
cp_objc_protocol_id_list (tree protocols)
{
tree proto;
if (!protocols)
return false;
for (proto = protocols; proto; proto = TREE_CHAIN (proto))
{
tree ident = TREE_VALUE (proto);
tree p = lookup_protocol (ident);
if (!p)
return false;
}
return true;
}
static void
objc_warn_direct_ivar_access (tree basetype, tree component)
{
while (basetype != NULL_TREE
&& TREE_CODE (basetype) == RECORD_TYPE && OBJC_TYPE_NAME (basetype)
&& TREE_CODE (OBJC_TYPE_NAME (basetype)) == TYPE_DECL
&& DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype)))
basetype = DECL_ORIGINAL_TYPE (OBJC_TYPE_NAME (basetype));
if (basetype != NULL_TREE && TYPED_OBJECT (basetype))
{
tree interface_type = TYPE_OBJC_INTERFACE (basetype);
if (interface_type &&
TREE_CODE (interface_type) == CLASS_INTERFACE_TYPE)
{
tree ivar = nested_ivar_lookup (interface_type, component);
if (ivar && managed_objc_object_pointer (TREE_TYPE (ivar)))
warning (0, "ivar %qs is being directly accessed", IDENTIFIER_POINTER (component));
}
}
return;
}
bool block_requires_copying (tree exp)
{
return TREE_CODE (TREE_TYPE (exp)) == BLOCK_POINTER_TYPE ||
objc_is_object_ptr (TREE_TYPE (exp));
}
#include "gt-objc-objc-act.h"