1 /* Next Runtime (ABI-2) private. 2 Copyright (C) 2011-2015 Free Software Foundation, Inc. 3 4 Contributed by Iain Sandoe and based, in part, on an implementation in 5 'branches/apple/trunk' contributed by Apple Computer Inc. 6 7 This file is part of GCC. 8 9 GCC is free software; you can redistribute it and/or modify 10 it under the terms of the GNU General Public License as published by 11 the Free Software Foundation; either version 3, or (at your option) 12 any later version. 13 14 GCC is distributed in the hope that it will be useful, 15 but WITHOUT ANY WARRANTY; without even the implied warranty of 16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 GNU General Public License for more details. 18 19 You should have received a copy of the GNU General Public License 20 along with GCC; see the file COPYING3. If not see 21 <http://www.gnu.org/licenses/>. */ 22 23 /* The NeXT ABI2 is used for m64 implementations on Darwin/OSX machines. 24 25 This version is intended to match (logically) the output of Apple's 26 4.2.1 compiler. */ 27 28 #include "config.h" 29 #include "system.h" 30 #include "coretypes.h" 31 #include "tm.h" 32 #include "hash-set.h" 33 #include "machmode.h" 34 #include "vec.h" 35 #include "double-int.h" 36 #include "input.h" 37 #include "alias.h" 38 #include "symtab.h" 39 #include "options.h" 40 #include "wide-int.h" 41 #include "inchash.h" 42 #include "tree.h" 43 #include "fold-const.h" 44 #include "stringpool.h" 45 46 #ifdef OBJCPLUS 47 #include "cp/cp-tree.h" 48 #else 49 #include "c/c-tree.h" 50 #include "c/c-lang.h" 51 #endif 52 #include "langhooks.h" 53 #include "c-family/c-objc.h" 54 #include "objc-act.h" 55 56 /* When building Objective-C++, we are not linking against the C front-end 57 and so need to replicate the C tree-construction functions in some way. */ 58 #ifdef OBJCPLUS 59 #define OBJCP_REMAP_FUNCTIONS 60 #include "objcp-decl.h" 61 #endif /* OBJCPLUS */ 62 63 #include "ggc.h" 64 #include "target.h" 65 #include "tree-iterator.h" 66 67 #include "objc-runtime-hooks.h" 68 #include "objc-runtime-shared-support.h" 69 #include "objc-encoding.h" 70 71 /* ABI 2 Private definitions. */ 72 #define DEF_CONSTANT_STRING_CLASS_NAME "NSConstantString" 73 74 #define TAG_GETCLASS "objc_getClass" 75 #define TAG_GETMETACLASS "objc_getMetaClass" 76 77 #define TAG_MSGSEND "objc_msgSend" 78 #define TAG_MSGSENDSUPER "objc_msgSendSuper" 79 #define TAG_MSGSEND_STRET "objc_msgSend_stret" 80 #define TAG_MSGSENDSUPER_STRET "objc_msgSendSuper_stret" 81 82 #define TAG_NEXT_EHVTABLE_NAME "objc_ehtype_vtable" 83 #define TAG_V2_EH_TYPE "objc_ehtype_t" 84 85 #define UTAG_V2_CLASS "_class_t" 86 #define UTAG_V2_CLASS_RO "_class_ro_t" 87 #define UTAG_V2_PROTOCOL "_protocol_t" 88 #define UTAG_V2_PROTOCOL_LIST "_protocol_list_t" 89 90 #define UTAG_V2_EH_TYPE "_objc_ehtype_t" 91 92 #define OBJC2_CLS_HAS_CXX_STRUCTORS 0x0004L 93 94 enum objc_v2_tree_index 95 { 96 /* Templates. */ 97 OCTI_V2_CLS_TEMPL, 98 OCTI_V2_CAT_TEMPL, 99 OCTI_V2_CLS_RO_TEMPL, 100 OCTI_V2_PROTO_TEMPL, 101 OCTI_V2_IVAR_TEMPL, 102 OCTI_V2_IVAR_LIST_TEMPL, 103 OCTI_V2_MESSAGE_REF_TEMPL, 104 OCTI_V2_SUPER_MESSAGE_REF_TEMPL, 105 106 OCTI_V2_MESSAGE_SELECTOR_TYPE, 107 OCTI_V2_SUPER_MESSAGE_SELECTOR_TYPE, 108 OCTI_V2_IMP_TYPE, 109 OCTI_V2_SUPER_IMP_TYPE, 110 111 OCTI_V2_CACHE_DECL, 112 OCTI_V2_VTABLE_DECL, 113 114 OCTI_V2_PROPERTY_TEMPL, 115 116 /* V2 messaging. */ 117 OCTI_V2_UMSG_FIXUP_DECL, 118 OCTI_V2_UMSG_STRET_FIXUP_DECL, 119 OCTI_V2_UMSG_ID_FIXUP_DECL, 120 OCTI_V2_UMSG_ID_STRET_FIXUP_DECL, 121 OCTI_V2_UMSG_SUPER2_FIXUP_DECL, 122 OCTI_V2_UMSG_SUPER2_STRET_FIXUP_DECL, 123 124 /* Exceptions - related. */ 125 OCTI_V2_BEGIN_CATCH_DECL, 126 OCTI_V2_END_CATCH_DECL, 127 OCTI_V2_RETHROW_DECL, 128 129 OCTI_V2_MAX 130 }; 131 132 #define objc_v2_class_template objc_v2_global_trees[OCTI_V2_CLS_TEMPL] 133 #define objc_v2_class_ro_template \ 134 objc_v2_global_trees[OCTI_V2_CLS_RO_TEMPL] 135 #define objc_v2_category_template \ 136 objc_v2_global_trees[OCTI_V2_CAT_TEMPL] 137 #define objc_v2_protocol_template \ 138 objc_v2_global_trees[OCTI_V2_PROTO_TEMPL] 139 140 /* struct message_ref_t */ 141 #define objc_v2_message_ref_template \ 142 objc_v2_global_trees[OCTI_V2_MESSAGE_REF_TEMPL] 143 144 #define objc_v2_ivar_list_ptr objc_v2_global_trees[OCTI_V2_IVAR_LIST_TEMPL] 145 146 /* struct super_message_ref_t */ 147 #define objc_v2_super_message_ref_template \ 148 objc_v2_global_trees[OCTI_V2_SUPER_MESSAGE_REF_TEMPL] 149 150 /* struct message_ref_t* */ 151 #define objc_v2_selector_type objc_v2_global_trees[OCTI_V2_MESSAGE_SELECTOR_TYPE] 152 /* struct super_super_message_ref_t */ 153 #define objc_v2_super_selector_type \ 154 objc_v2_global_trees[OCTI_V2_SUPER_MESSAGE_SELECTOR_TYPE] 155 #define objc_v2_imp_type objc_v2_global_trees[OCTI_V2_IMP_TYPE] 156 #define objc_v2_super_imp_type objc_v2_global_trees[OCTI_V2_SUPER_IMP_TYPE] 157 158 #define UOBJC_V2_CACHE_decl objc_v2_global_trees[OCTI_V2_CACHE_DECL] 159 #define UOBJC_V2_VTABLE_decl objc_v2_global_trees[OCTI_V2_VTABLE_DECL] 160 161 #define objc_v2_ivar_template objc_v2_global_trees[OCTI_V2_IVAR_TEMPL] 162 #define objc_v2_property_template \ 163 objc_v2_global_trees[OCTI_V2_PROPERTY_TEMPL] 164 165 /* V2 Messaging */ 166 167 /* objc_msgSend_fixup_rtp */ 168 #define umsg_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_FIXUP_DECL] 169 /* objc_msgSend_stret_fixup_rtp */ 170 #define umsg_stret_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_STRET_FIXUP_DECL] 171 /* objc_msgSendId_fixup_rtp */ 172 #define umsg_id_fixup_decl objc_v2_global_trees[OCTI_V2_UMSG_ID_FIXUP_DECL] 173 /* objc_msgSendId_stret_fixup_rtp */ 174 #define umsg_id_stret_fixup_decl \ 175 objc_v2_global_trees[OCTI_V2_UMSG_ID_STRET_FIXUP_DECL] 176 /* objc_msgSendSuper2_fixup_rtp */ 177 #define umsg_id_super2_fixup_decl \ 178 objc_v2_global_trees[OCTI_V2_UMSG_SUPER2_FIXUP_DECL] 179 /* objc_msgSendSuper2_stret_fixup_rtp */ 180 #define umsg_id_super2_stret_fixup_decl \ 181 objc_v2_global_trees[OCTI_V2_UMSG_SUPER2_STRET_FIXUP_DECL] 182 183 #define objc2_begin_catch_decl objc_v2_global_trees[OCTI_V2_BEGIN_CATCH_DECL] 184 #define objc2_end_catch_decl objc_v2_global_trees[OCTI_V2_END_CATCH_DECL] 185 #define objc_rethrow_exception_decl \ 186 objc_v2_global_trees[OCTI_V2_RETHROW_DECL] 187 188 /* rt_trees identifiers - shared between NeXT implementations. These allow 189 the FE to tag meta-data in a manner that survives LTO and can be used when 190 the runtime requires that certain meta-data items appear in particular 191 named sections. */ 192 193 #include "objc-next-metadata-tags.h" 194 extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX]; 195 196 /* The OCTI_V2_... enumeration itself is in above. */ 197 static GTY(()) tree objc_v2_global_trees[OCTI_V2_MAX]; 198 199 static void next_runtime_02_initialize (void); 200 201 static void build_v2_message_ref_templates (void); 202 static void build_v2_class_templates (void); 203 static void build_v2_super_template (void); 204 static void build_v2_category_template (void); 205 static void build_v2_protocol_template (void); 206 207 static tree next_runtime_abi_02_super_superclassfield_id (void); 208 209 static tree next_runtime_abi_02_class_decl (tree); 210 static tree next_runtime_abi_02_metaclass_decl (tree); 211 static tree next_runtime_abi_02_category_decl (tree); 212 static tree next_runtime_abi_02_protocol_decl (tree); 213 static tree next_runtime_abi_02_string_decl (tree, const char *, string_section); 214 215 static tree next_runtime_abi_02_get_class_reference (tree); 216 static tree next_runtime_abi_02_build_selector_reference (location_t, tree, tree); 217 static tree next_runtime_abi_02_get_protocol_reference (location_t, tree); 218 static tree next_runtime_abi_02_build_ivar_ref (location_t, tree, tree); 219 static tree next_runtime_abi_02_get_class_super_ref (location_t, struct imp_entry *, bool); 220 static tree next_runtime_abi_02_get_category_super_ref (location_t, struct imp_entry *, bool); 221 222 static tree next_runtime_abi_02_receiver_is_class_object (tree); 223 static void next_runtime_abi_02_get_arg_type_list_base (vec<tree, va_gc> **, 224 tree, int, int); 225 static tree next_runtime_abi_02_build_objc_method_call (location_t, tree, tree, 226 tree, tree, tree, int); 227 static bool next_runtime_abi_02_setup_const_string_class_decl (void); 228 static tree next_runtime_abi_02_build_const_string_constructor (location_t, tree, int); 229 230 static tree create_extern_decl (tree, const char *); 231 232 static void objc_generate_v2_next_metadata (void); 233 static bool objc2_objc_exception_attr (tree); 234 235 /* void build_v2_protocol_reference (tree);*/ 236 static void build_v2_ehtype_template (void); 237 static void build_v2_eh_catch_objects (void); 238 static tree next_runtime_02_eh_type (tree); 239 static tree objc_eh_personality (void); 240 static tree build_throw_stmt (location_t, tree, bool); 241 static tree objc_build_exc_ptr (struct objc_try_context **); 242 static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool); 243 static void finish_catch (struct objc_try_context **, tree); 244 static tree finish_try_stmt (struct objc_try_context **); 245 246 /* TODO: Use an objc-map. */ 247 static GTY ((length ("SIZEHASHTABLE"))) hash *extern_names; 248 249 bool 250 objc_next_runtime_abi_02_init (objc_runtime_hooks *rthooks) 251 { 252 extern_names = ggc_cleared_vec_alloc<hash> (SIZEHASHTABLE); 253 254 if (flag_objc_exceptions && flag_objc_sjlj_exceptions) 255 { 256 inform (UNKNOWN_LOCATION, "%<-fobjc-sjlj-exceptions%> is ignored for " 257 "%<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2"); 258 flag_objc_sjlj_exceptions = 0; 259 } 260 261 rthooks->initialize = next_runtime_02_initialize; 262 rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME; 263 rthooks->tag_getclass = TAG_GETCLASS; 264 rthooks->super_superclassfield_ident = next_runtime_abi_02_super_superclassfield_id; 265 266 rthooks->class_decl = next_runtime_abi_02_class_decl; 267 rthooks->metaclass_decl = next_runtime_abi_02_metaclass_decl; 268 rthooks->category_decl = next_runtime_abi_02_category_decl; 269 rthooks->protocol_decl = next_runtime_abi_02_protocol_decl; 270 rthooks->string_decl = next_runtime_abi_02_string_decl; 271 272 rthooks->get_class_reference = next_runtime_abi_02_get_class_reference; 273 rthooks->build_selector_reference = next_runtime_abi_02_build_selector_reference; 274 rthooks->get_protocol_reference = next_runtime_abi_02_get_protocol_reference; 275 rthooks->build_ivar_reference = next_runtime_abi_02_build_ivar_ref; 276 rthooks->get_class_super_ref = next_runtime_abi_02_get_class_super_ref; 277 rthooks->get_category_super_ref = next_runtime_abi_02_get_category_super_ref; 278 279 rthooks->receiver_is_class_object = next_runtime_abi_02_receiver_is_class_object; 280 rthooks->get_arg_type_list_base = next_runtime_abi_02_get_arg_type_list_base; 281 rthooks->build_objc_method_call = next_runtime_abi_02_build_objc_method_call; 282 283 rthooks->setup_const_string_class_decl = 284 next_runtime_abi_02_setup_const_string_class_decl; 285 rthooks->build_const_string_constructor = 286 next_runtime_abi_02_build_const_string_constructor; 287 288 rthooks->build_throw_stmt = build_throw_stmt; 289 rthooks->build_exc_ptr = objc_build_exc_ptr; 290 rthooks->begin_catch = begin_catch; 291 rthooks->finish_catch = finish_catch; 292 rthooks->finish_try_stmt = finish_try_stmt; 293 294 rthooks->generate_metadata = objc_generate_v2_next_metadata; 295 return true; 296 } 297 298 /* We need a way to convey what kind of meta-data are represented by a given 299 variable, since each type is expected (by the runtime) to be found in a 300 specific named section. The solution must be usable with LTO. 301 302 The scheme used for NeXT ABI 0/1 (partial matching of variable names) is not 303 satisfactory when LTO is used with ABI-2. We now tag ObjC meta-data with 304 identification attributes in the front end. The back-end may choose to act 305 on these as it requires. */ 306 307 static void 308 next_runtime_abi_02_init_metadata_attributes (void) 309 { 310 if (!objc_meta) 311 objc_meta = get_identifier ("OBJC2META"); 312 313 if (!meta_base) 314 meta_base = get_identifier ("V2_BASE"); 315 316 meta_class = get_identifier ("G2_CLAS"); 317 meta_metaclass = get_identifier ("G2_META"); 318 meta_category = 319 meta_protocol = meta_base; 320 321 meta_clac_vars = 322 meta_clai_vars = meta_base; 323 324 meta_clac_meth = 325 meta_clai_meth = 326 meta_catc_meth = 327 meta_cati_meth = 328 meta_proto_cls_meth = 329 meta_proto_nst_meth = meta_base; 330 331 meta_clas_prot = 332 meta_catg_prot = meta_base; 333 334 meta_sel_refs = get_identifier ("V2_SRFS"); 335 336 meta_class_name = 337 meta_meth_name = 338 meta_meth_type = 339 meta_prop_name_attr = get_identifier ("V2_STRG"); 340 341 meta_mref = get_identifier ("V2_MREF"); 342 meta_class_ref = get_identifier ("V2_CLRF"); 343 meta_superclass_ref = get_identifier ("V2_SURF"); 344 345 meta_label_classlist = get_identifier ("V2_CLAB"); 346 meta_label_nonlazy_classlist = get_identifier ("V2_NLCL"); 347 meta_label_categorylist = get_identifier ("V2_CALA"); 348 meta_label_nonlazy_categorylist = get_identifier ("V2_NLCA"); 349 350 meta_label_protocollist = get_identifier ("V2_PLST"); 351 meta_proto_ref = get_identifier ("V2_PRFS"); 352 353 meta_info = get_identifier ("V2_INFO"); 354 355 meta_ehtype = get_identifier ("V2_EHTY"); 356 357 meta_const_str = get_identifier ("V2_CSTR"); 358 } 359 360 static void next_runtime_02_initialize (void) 361 { 362 tree type; 363 #ifdef OBJCPLUS 364 /* For all NeXT objc ABIs -fobjc-call-cxx-cdtors is on by 365 default. */ 366 if (!global_options_set.x_flag_objc_call_cxx_cdtors) 367 global_options.x_flag_objc_call_cxx_cdtors = 1; 368 #endif 369 370 /* Set up attributes to be attached to the meta-data so that they 371 will be placed in the correct sections. */ 372 next_runtime_abi_02_init_metadata_attributes (); 373 374 /* `struct objc_selector *' */ 375 objc_selector_type = build_pointer_type (xref_tag (RECORD_TYPE, 376 get_identifier (TAG_SELECTOR))); 377 378 /* IMP : id (*) (id, _message_ref_t*, ...) 379 SUPER_IMP : id (*) ( super_t*, _super_message_ref_t*, ...) 380 objc_v2_selector_type. */ 381 build_v2_message_ref_templates (); 382 383 objc_v2_ivar_list_ptr = 384 build_pointer_type (xref_tag (RECORD_TYPE, 385 get_identifier ("_ivar_list_t"))); 386 387 objc_prop_list_ptr = 388 build_pointer_type (xref_tag (RECORD_TYPE, 389 get_identifier ("_prop_list_t"))); 390 391 build_v2_class_templates (); 392 build_v2_super_template (); 393 build_v2_protocol_template (); 394 build_v2_category_template (); 395 396 /* id objc_msgSend_fixup_rtp (id, struct message_ref_t*, ...); */ 397 type = build_varargs_function_type_list (objc_object_type, 398 objc_object_type, 399 objc_v2_selector_type, 400 NULL_TREE); 401 umsg_fixup_decl = add_builtin_function ("objc_msgSend_fixup", 402 type, 0, NOT_BUILT_IN, 403 NULL, NULL_TREE); 404 TREE_NOTHROW (umsg_fixup_decl) = 0; 405 406 /* id objc_msgSend_stret_fixup_rtp (id, struct message_ref_t*, ...); */ 407 umsg_stret_fixup_decl = add_builtin_function ("objc_msgSend_stret_fixup", 408 type, 0, NOT_BUILT_IN, 409 NULL, NULL_TREE); 410 TREE_NOTHROW (umsg_stret_fixup_decl) = 0; 411 412 /* id objc_msgSendId_fixup_rtp (id, struct message_ref_t*, ...); */ 413 umsg_id_fixup_decl = add_builtin_function ("objc_msgSendId_fixup", 414 type, 0, NOT_BUILT_IN, 415 NULL, NULL_TREE); 416 TREE_NOTHROW (umsg_id_fixup_decl) = 0; 417 418 /* id objc_msgSendId_stret_fixup_rtp 419 (id, struct message_ref_t*, ...); */ 420 umsg_id_stret_fixup_decl = add_builtin_function ("objc_msgSendId_stret_fixup", 421 type, 0, NOT_BUILT_IN, 422 NULL, NULL_TREE); 423 TREE_NOTHROW (umsg_id_stret_fixup_decl) = 0; 424 425 /* id objc_msgSendSuper2_fixup_rtp 426 (struct objc_super *, struct message_ref_t*, ...); */ 427 type = build_varargs_function_type_list (objc_object_type, 428 objc_super_type, 429 objc_v2_super_selector_type, 430 NULL_TREE); 431 umsg_id_super2_fixup_decl = add_builtin_function ("objc_msgSendSuper2_fixup", 432 type, 0, NOT_BUILT_IN, 433 NULL, NULL_TREE); 434 TREE_NOTHROW (umsg_id_super2_fixup_decl) = 0; 435 436 /* id objc_msgSendSuper2_stret_fixup_rtp 437 (struct objc_super *, struct message_ref_t*, ...); */ 438 umsg_id_super2_stret_fixup_decl = 439 add_builtin_function ("objc_msgSendSuper2_stret_fixup", 440 type, 0, NOT_BUILT_IN, 441 NULL, NULL_TREE); 442 TREE_NOTHROW (umsg_id_super2_stret_fixup_decl) = 0; 443 444 /* Present in the library, but unused by the FE. */ 445 /* Protocol *objc_getProtocol (const char *) 446 type = build_function_type_list (objc_protocol_type, 447 const_string_type_node, 448 NULL_TREE); 449 objc_v2_getprotocol_decl = add_builtin_function ("objc_getProtocol", 450 type, 0, NOT_BUILT_IN, 451 NULL, NULL_TREE); 452 TREE_NOTHROW (objc_v2_getprotocol_decl) = 0;*/ 453 454 UOBJC_V2_CACHE_decl = create_extern_decl (ptr_type_node, 455 "_objc_empty_cache"); 456 457 UOBJC_V2_VTABLE_decl = create_extern_decl (objc_v2_imp_type, 458 "_objc_empty_vtable"); 459 460 /* id objc_getClass (const char *); */ 461 type = build_function_type_list (objc_object_type, 462 const_string_type_node, 463 NULL_TREE); 464 objc_get_class_decl = add_builtin_function (TAG_GETCLASS, 465 type, 0, NOT_BUILT_IN, 466 NULL, NULL_TREE); 467 468 /* id objc_getMetaClass (const char *); */ 469 objc_get_meta_class_decl = add_builtin_function (TAG_GETMETACLASS, 470 type, 0, NOT_BUILT_IN, 471 NULL, NULL_TREE); 472 473 /* This is the type of all of the following functions 474 objc_copyStruct(). */ 475 type = build_function_type_list (void_type_node, 476 ptr_type_node, 477 const_ptr_type_node, 478 ptrdiff_type_node, 479 boolean_type_node, 480 boolean_type_node, 481 NULL_TREE); 482 /* Declare the following function: 483 void 484 objc_copyStruct (void *destination, const void *source, 485 ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */ 486 objc_copyStruct_decl = add_builtin_function ("objc_copyStruct", 487 type, 0, NOT_BUILT_IN, 488 NULL, NULL_TREE); 489 TREE_NOTHROW (objc_copyStruct_decl) = 0; 490 objc_getPropertyStruct_decl = NULL_TREE; 491 objc_setPropertyStruct_decl = NULL_TREE; 492 493 gcc_assert (!flag_objc_sjlj_exceptions); 494 495 /* Although we warn that fobjc-exceptions is required for exceptions 496 code, we carry on and create it anyway. */ 497 498 /* This can be required, even when exceptions code is not present, 499 when an __attribute__((objc_exception)) is applied to a 500 class. */ 501 build_v2_ehtype_template (); 502 503 /* void * objc_begin_catch (void *) */ 504 type = build_function_type_list (ptr_type_node, 505 ptr_type_node, NULL_TREE); 506 507 objc2_begin_catch_decl = add_builtin_function ("objc_begin_catch", 508 type, 0, NOT_BUILT_IN, 509 NULL, NULL_TREE); 510 TREE_NOTHROW (objc2_begin_catch_decl) = 0; 511 512 /* void objc_end_catch () */ 513 type = build_function_type_list (void_type_node, NULL_TREE); 514 objc2_end_catch_decl = add_builtin_function ("objc_end_catch", 515 type, 0, NOT_BUILT_IN, 516 NULL, NULL_TREE); 517 TREE_NOTHROW (objc2_end_catch_decl) = 0; 518 519 /* void objc_exception_rethrow (void) */ 520 objc_rethrow_exception_decl = 521 add_builtin_function ("objc_exception_rethrow", 522 type, 0, NOT_BUILT_IN, 523 NULL, NULL_TREE); 524 TREE_NOTHROW (objc_rethrow_exception_decl) = 0; 525 using_eh_for_cleanups (); 526 lang_hooks.eh_runtime_type = next_runtime_02_eh_type; 527 lang_hooks.eh_personality = objc_eh_personality; 528 } 529 530 /* NOTE --- templates --- */ 531 532 /* Set 'objc_v2_message_ref_template' to the data type node for 533 'struct _message_ref_t'. This needs to be done just once per 534 compilation. Also Set 'objc_v2_super_message_ref_template' to data 535 type node for 'struct _super_message_ref_t'. */ 536 537 /* struct _message_ref_t 538 { 539 IMP messenger; 540 SEL name; 541 }; 542 where IMP is: id (*) (id, _message_ref_t*, ...) 543 */ 544 545 /* struct _super_message_ref_t 546 { 547 SUPER_IMP messenger; 548 SEL name; 549 }; 550 where SUPER_IMP is: id (*) ( super_t*, _super_message_ref_t*, ...) 551 */ 552 553 static void 554 build_v2_message_ref_templates (void) 555 { 556 tree ptr_message_ref_t; 557 tree decls, *chain = NULL; 558 559 /* struct _message_ref_t {...} */ 560 objc_v2_message_ref_template = 561 objc_start_struct (get_identifier ("_message_ref_t")); 562 563 /* IMP messenger; */ 564 ptr_message_ref_t = 565 build_pointer_type (xref_tag (RECORD_TYPE, 566 get_identifier ("_message_ref_t"))); 567 568 objc_v2_imp_type = 569 build_pointer_type (build_function_type_list 570 (objc_object_type, 571 objc_object_type, 572 ptr_message_ref_t, 573 NULL_TREE)); 574 575 decls = add_field_decl (objc_v2_imp_type, "messenger", &chain); 576 577 /* SEL name; */ 578 add_field_decl (objc_selector_type, "name", &chain); 579 580 objc_finish_struct (objc_v2_message_ref_template, decls); 581 582 objc_v2_selector_type = build_pointer_type (objc_v2_message_ref_template); 583 584 chain = NULL; 585 /* struct _super_message_ref_t {...} */ 586 objc_v2_super_message_ref_template = 587 objc_start_struct (get_identifier ("_super_message_ref_t")); 588 589 /* SUPER_IMP messenger; */ 590 ptr_message_ref_t = build_pointer_type 591 (xref_tag (RECORD_TYPE, 592 get_identifier ("_super_message_ref_t"))); 593 594 objc_v2_super_imp_type = 595 build_pointer_type (build_function_type_list 596 (objc_object_type, 597 objc_super_type, 598 ptr_message_ref_t, 599 NULL_TREE)); 600 601 add_field_decl (objc_v2_super_imp_type, "messenger", &chain); 602 603 /* SEL name; */ 604 add_field_decl (objc_selector_type, "name", &chain); 605 606 objc_finish_struct (objc_v2_super_message_ref_template, decls); 607 objc_v2_super_selector_type = 608 build_pointer_type (objc_v2_super_message_ref_template); 609 } 610 611 /* Build following types which represent each class implementation. 612 613 struct class_ro_t 614 { 615 uint32_t const flags; 616 uint32_t const instanceStart; 617 uint32_t const instanceSize; 618 #ifdef __LP64__ 619 uint32_t const reserved; 620 #endif 621 const uint8_t * const ivarLayout; 622 const char *const name; 623 const struct method_list_t * const baseMethods; 624 const struct objc_protocol_list *const baseProtocols; 625 const struct ivar_list_t *const ivars; 626 const uint8_t * const weakIvarLayout; 627 const struct _prop_list_t * const properties; 628 }; 629 630 struct class_t 631 { 632 struct class_t *isa; 633 struct class_t *superclass; 634 void *cache; 635 IMP *vtable; 636 637 ...When this is active - it will point to a rw version, but 638 when we build the meta-data we point it to the ro... 639 struct class_ro_t *data; 640 }; 641 642 */ 643 644 static void 645 build_v2_class_templates (void) 646 { 647 tree cnst_strg_type; 648 tree decls, *chain = NULL; 649 650 /* struct class_ro_t {...} */ 651 objc_v2_class_ro_template = 652 objc_start_struct (get_identifier (UTAG_V2_CLASS_RO)); 653 654 /* uint32_t const flags; */ 655 decls = add_field_decl (integer_type_node, "flags", &chain); 656 657 /* uint32_t const instanceStart; */ 658 add_field_decl (integer_type_node, "instanceStart", &chain); 659 660 /* uint32_t const instanceSize; */ 661 add_field_decl (integer_type_node, "instanceSize", &chain); 662 663 /* This ABI is currently only used on m64 NeXT. We always 664 explicitly declare the alignment padding. */ 665 /* uint32_t const reserved; */ 666 add_field_decl (integer_type_node, "reserved", &chain); 667 668 /* const uint8_t * const ivarLayout; */ 669 cnst_strg_type = build_pointer_type (unsigned_char_type_node); 670 add_field_decl (cnst_strg_type, "ivarLayout", &chain); 671 672 /* const char *const name; */ 673 add_field_decl (string_type_node, "name", &chain); 674 675 /* const struct method_list_t * const baseMethods; */ 676 add_field_decl (objc_method_list_ptr, "baseMethods", &chain); 677 678 /* const struct objc_protocol_list *const baseProtocols; */ 679 add_field_decl (build_pointer_type 680 (xref_tag (RECORD_TYPE, 681 get_identifier (UTAG_V2_PROTOCOL_LIST))), 682 "baseProtocols", &chain); 683 684 /* const struct ivar_list_t *const ivars; */ 685 add_field_decl (objc_v2_ivar_list_ptr, "ivars", &chain); 686 687 /* const uint8_t * const weakIvarLayout; */ 688 add_field_decl (cnst_strg_type, "weakIvarLayout", &chain); 689 690 /* struct _prop_list_t * baseProperties; */ 691 add_field_decl (objc_prop_list_ptr, "baseProperties", &chain); 692 693 objc_finish_struct (objc_v2_class_ro_template, decls); 694 695 chain = NULL; 696 /* struct class_t {...} */ 697 objc_v2_class_template = 698 objc_start_struct (get_identifier (UTAG_V2_CLASS)); 699 700 /* struct class_t *isa; */ 701 decls = add_field_decl (build_pointer_type (objc_v2_class_template), 702 "isa", &chain); 703 704 /* struct class_t * const superclass; */ 705 add_field_decl (build_pointer_type (objc_v2_class_template), 706 "superclass", &chain); 707 708 /* void *cache; */ 709 add_field_decl (build_pointer_type (void_type_node), "cache", &chain); 710 711 /* IMP *vtable; */ 712 add_field_decl (build_pointer_type (objc_v2_imp_type), "vtable", &chain); 713 714 /* struct class_ro_t *ro; */ 715 add_field_decl (build_pointer_type (objc_v2_class_ro_template), "ro", &chain); 716 717 objc_finish_struct (objc_v2_class_template, decls); 718 } 719 720 /* struct _objc_super 721 { 722 struct _objc_object *self; 723 Class cls; 724 }; */ 725 void 726 build_v2_super_template (void) 727 { 728 tree decls, *chain = NULL; 729 730 objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER)); 731 732 /* struct _objc_object *self; */ 733 decls = add_field_decl (objc_object_type, "self", &chain); 734 735 /* Class cls; */ 736 add_field_decl (objc_class_type, "cls", &chain); 737 738 objc_finish_struct (objc_super_template, decls); 739 } 740 741 /* struct protocol_t 742 { 743 Class isa; 744 const char * const protocol_name; 745 const struct protocol_list_t * const protocol_list; 746 const struct method_list_t * const instance_methods; 747 const struct method_list_t * const class_methods; 748 const struct method_list_t * optionalInstanceMethods; 749 const struct method_list_t * optionalClassMethod 750 const struct _prop_list_t * const properties; 751 const uint32_t size; 752 const uint32_t flags; 753 } 754 */ 755 static void 756 build_v2_protocol_template (void) 757 { 758 tree decls, *chain = NULL; 759 760 objc_v2_protocol_template = 761 objc_start_struct (get_identifier (UTAG_V2_PROTOCOL)); 762 763 /* Class isa; */ 764 decls = add_field_decl (objc_object_type, "isa", &chain); 765 766 /* char *protocol_name; */ 767 add_field_decl (string_type_node, "protocol_name", &chain); 768 769 /* const struct protocol_list_t * const protocol_list; */ 770 add_field_decl (build_pointer_type (objc_v2_protocol_template), 771 "protocol_list", &chain); 772 773 /* const struct method_list_t * const instance_methods; */ 774 add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain); 775 776 /* const struct method_list_t * const class_methods; */ 777 add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain); 778 779 /* const struct method_list_t * optionalInstanceMethods; */ 780 add_field_decl (objc_method_proto_list_ptr, "optionalInstanceMethods", &chain); 781 782 /* const struct method_list_t * optionalClassMethods; */ 783 add_field_decl (objc_method_proto_list_ptr, "optionalClassMethods", &chain); 784 785 /* struct _prop_list_t * properties; */ 786 add_field_decl (objc_prop_list_ptr, "properties", &chain); 787 788 /* const uint32_t size; */ 789 add_field_decl (integer_type_node, "size", &chain); 790 791 /* const uint32_t flags; */ 792 add_field_decl (integer_type_node, "flags", &chain); 793 794 objc_finish_struct (objc_v2_protocol_template, decls); 795 } 796 797 /* Build type for a category: 798 struct category_t 799 { 800 const char * const name; 801 struct class_t *const cls; 802 const struct method_list_t * const instance_methods; 803 const struct method_list_t * const class_methods; 804 const struct protocol_list_t * const protocols; 805 const struct _prop_list_t * const properties; 806 } 807 */ 808 809 static void 810 build_v2_category_template (void) 811 { 812 tree decls, *chain = NULL; 813 814 objc_v2_category_template = 815 objc_start_struct (get_identifier ("_category_t")); 816 817 /* char *name; */ 818 decls = add_field_decl (string_type_node, "name", &chain); 819 820 /* struct class_t *const cls; */ 821 add_field_decl (build_pointer_type (objc_v2_class_template), "cls", &chain); 822 823 /* struct method_list_t *instance_methods; */ 824 add_field_decl (objc_method_list_ptr, "instance_methods", &chain); 825 826 /* struct method_list_t *class_methods; */ 827 add_field_decl (objc_method_list_ptr, "class_methods", &chain); 828 829 /* struct protocol_list_t *protocol_list; */ 830 add_field_decl (build_pointer_type (objc_v2_protocol_template), 831 "protocol_list", &chain ); 832 833 /* struct _prop_list_t * properties; */ 834 add_field_decl (objc_prop_list_ptr, "properties", &chain); 835 836 objc_finish_struct (objc_v2_category_template, decls); 837 } 838 839 /* NOTE --- Decls, Identifiers, Names etc. --- */ 840 841 /* This routine is given a name and returns a matching extern variable 842 if one is found. */ 843 844 static tree 845 hash_name_lookup (hash *hashlist, tree name) 846 { 847 hash target; 848 849 target = hashlist[IDENTIFIER_HASH_VALUE (name) % SIZEHASHTABLE]; 850 851 while (target) 852 { 853 if (name == DECL_NAME (target->key)) 854 return target->key; 855 856 target = target->next; 857 } 858 return 0; 859 } 860 861 /* This routine is given an extern variable and enters it in its hash 862 table. Note that hashing is done on its inner IDENTIFIER_NODE 863 node. */ 864 865 static void 866 hash_name_enter (hash *hashlist, tree id) 867 { 868 hash obj; 869 int slot = IDENTIFIER_HASH_VALUE (DECL_NAME (id)) % SIZEHASHTABLE; 870 871 obj = ggc_alloc<hashed_entry> (); 872 obj->list = 0; 873 obj->next = hashlist[slot]; 874 obj->key = id; 875 876 hashlist[slot] = obj; /* append to front */ 877 } 878 879 /* Create a declaration "extern <type> <name>;" 880 The var will need to be finalized (e.g. by calling finish_var_decl()). */ 881 882 static tree 883 create_extern_decl (tree type, const char *name) 884 { 885 tree id = get_identifier (name); 886 tree var = hash_name_lookup (extern_names, id); 887 if (var) 888 return var; 889 /* New name. */ 890 var = start_var_decl (type, name); 891 TREE_STATIC (var) = 0; 892 DECL_EXTERNAL (var) = 1; 893 TREE_PUBLIC (var) = 1; 894 hash_name_enter (extern_names, var); 895 return var; 896 } 897 898 /* Create a globally visible definition for variable NAME of a given TYPE. The 899 finish_var_decl() routine will need to be called on it afterwards. */ 900 901 static tree 902 create_global_decl (tree type, const char *name) 903 { 904 tree id = get_identifier (name); 905 tree var = hash_name_lookup (extern_names, id); 906 if (var) 907 { 908 DECL_EXTERNAL (var) = 0; 909 TREE_STATIC (var) = 1; 910 } 911 else 912 { 913 var = start_var_decl (type, name); 914 hash_name_enter (extern_names, var); 915 } 916 TREE_PUBLIC (var) = 1; 917 return var; 918 } 919 920 /* Create a symbol with __attribute__ ((visibility ("hidden"))) 921 attribute (private extern). */ 922 923 static tree 924 create_hidden_decl (tree type, const char *name) 925 { 926 tree decl = create_global_decl (type, name); 927 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN; 928 DECL_VISIBILITY_SPECIFIED (decl) = 1; 929 return decl; 930 } 931 932 /* Irritatingly, we have a different superclass field name for ABI=2. */ 933 /* PS/TODO: The field name does not matter, it is only used internally 934 by the compiler. We can rename it to whatever we want. ;-) */ 935 936 static tree 937 next_runtime_abi_02_super_superclassfield_id (void) 938 { 939 /* TODO: Simplify. Just always return get_identifier ("cls"), or at 940 most look it once at startup then always return it. */ 941 if (!super_superclassfield_id) 942 super_superclassfield_id = get_identifier ("cls"); 943 return super_superclassfield_id; 944 } 945 946 static tree 947 next_runtime_abi_02_class_decl (tree klass) 948 { 949 tree decl; 950 char buf[BUFSIZE]; 951 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", 952 IDENTIFIER_POINTER (CLASS_NAME (klass))); 953 /* ObjC2 classes are extern visible. */ 954 decl = create_global_decl (objc_v2_class_template, buf); 955 OBJCMETA (decl, objc_meta, meta_class); 956 return decl; 957 } 958 959 static tree 960 next_runtime_abi_02_metaclass_decl (tree klass) 961 { 962 tree decl; 963 char buf[BUFSIZE]; 964 snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s", 965 IDENTIFIER_POINTER (CLASS_NAME (klass))); 966 /* ObjC2 classes are extern visible. */ 967 decl = create_global_decl (objc_v2_class_template, buf); 968 OBJCMETA (decl, objc_meta, meta_metaclass); 969 return decl; 970 } 971 972 static tree 973 next_runtime_abi_02_category_decl (tree klass) 974 { 975 tree decl; 976 char buf[BUFSIZE]; 977 snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s", 978 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)), 979 IDENTIFIER_POINTER (CLASS_NAME (klass))); 980 decl = start_var_decl (objc_v2_category_template, buf); 981 OBJCMETA (decl, objc_meta, meta_category); 982 return decl; 983 } 984 985 static tree 986 next_runtime_abi_02_protocol_decl (tree p) 987 { 988 tree decl; 989 char buf[BUFSIZE]; 990 991 /* static struct _objc_protocol _OBJC_Protocol_<mumble>; */ 992 snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", 993 IDENTIFIER_POINTER (PROTOCOL_NAME (p))); 994 decl = start_var_decl (objc_v2_protocol_template, buf); 995 OBJCMETA (decl, objc_meta, meta_protocol); 996 return decl; 997 } 998 999 static tree 1000 next_runtime_abi_02_string_decl (tree type, const char *name, string_section where) 1001 { 1002 tree var = start_var_decl (type, name); 1003 switch (where) 1004 { 1005 case class_names: 1006 OBJCMETA (var, objc_meta, meta_class_name); 1007 break; 1008 case meth_var_names: 1009 OBJCMETA (var, objc_meta, meta_meth_name); 1010 break; 1011 case meth_var_types: 1012 OBJCMETA (var, objc_meta, meta_meth_type); 1013 break; 1014 case prop_names_attr: 1015 OBJCMETA (var, objc_meta, meta_prop_name_attr); 1016 break; 1017 default: 1018 OBJCMETA (var, objc_meta, meta_base); 1019 break; 1020 } 1021 return var; 1022 } 1023 1024 /* NOTE --- entry --- */ 1025 1026 typedef struct GTY(()) ident_data_tuple { 1027 tree ident; 1028 tree data; 1029 } ident_data_tuple ; 1030 1031 /* This routine creates a file scope static variable of type 'Class' 1032 to hold the address of a class. */ 1033 1034 static tree 1035 build_v2_class_reference_decl (tree ident) 1036 { 1037 tree decl; 1038 char buf[BUFSIZE]; 1039 1040 snprintf (buf, BUFSIZE, "_OBJC_ClassRef_%s", IDENTIFIER_POINTER (ident)); 1041 decl = start_var_decl (objc_class_type, buf); 1042 OBJCMETA (decl, objc_meta, meta_class_ref); 1043 return decl; 1044 } 1045 1046 /* This routine builds a class refs entry for each class name used. 1047 Initially, a (static-ref, IDENT) tuple is added to the list. The 1048 ident is replaced with address of the class metadata (of type 1049 'Class') in the output routine. */ 1050 1051 static GTY (()) vec<ident_data_tuple, va_gc> *classrefs; 1052 1053 static tree 1054 objc_v2_get_class_reference (tree ident) 1055 { 1056 tree decl; 1057 ident_data_tuple e; 1058 if (classrefs) 1059 { 1060 int count; 1061 ident_data_tuple *ref; 1062 FOR_EACH_VEC_ELT (*classrefs, count, ref) 1063 { 1064 if (ref->ident == ident) 1065 { 1066 if (!ref->data) 1067 ref->data = build_v2_class_reference_decl (ident); 1068 return ref->data; 1069 } 1070 } 1071 } 1072 else 1073 /* Somewhat arbitrary initial provision. */ 1074 vec_alloc (classrefs, 16); 1075 1076 /* We come here if we don't find the entry - or if the table was yet 1077 to be created. */ 1078 decl = build_v2_class_reference_decl (ident); 1079 e.ident = ident; 1080 e.data = decl; 1081 vec_safe_push (classrefs, e); 1082 return decl; 1083 } 1084 1085 static tree 1086 next_runtime_abi_02_get_class_reference (tree ident) 1087 { 1088 if (!flag_zero_link) 1089 return objc_v2_get_class_reference (ident); 1090 else 1091 { 1092 /* We fall back to using objc_getClass (). */ 1093 vec<tree, va_gc> *v; 1094 vec_alloc (v, 1); 1095 tree t; 1096 /* ??? add_class_reference (ident); - is pointless, since the 1097 system lib does not export the equivalent symbols. Maybe we 1098 need to build a class ref anyway. */ 1099 t = my_build_string_pointer (IDENTIFIER_LENGTH (ident) + 1, 1100 IDENTIFIER_POINTER (ident)); 1101 v->quick_push (t); 1102 t = build_function_call_vec (input_location, vNULL, objc_get_class_decl, 1103 v, 0); 1104 vec_free (v); 1105 return t; 1106 } 1107 } 1108 1109 /* Used by build_function_type_for_method. Append the types for 1110 receiver & _cmd at the start of a method argument list to ARGTYPES. 1111 CONTEXT is either METHOD_DEF or METHOD_REF, saying whether we are 1112 trying to define a method or call one. SUPERFLAG says this is for a 1113 send to super. METH may be NULL, in the case that there is no 1114 prototype. */ 1115 1116 static void 1117 next_runtime_abi_02_get_arg_type_list_base (vec<tree, va_gc> **argtypes, 1118 tree meth, int context, 1119 int superflag) 1120 { 1121 tree receiver_type; 1122 1123 if (superflag) 1124 receiver_type = objc_super_type; 1125 else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL) 1126 receiver_type = objc_instance_type; 1127 else 1128 receiver_type = objc_object_type; 1129 1130 vec_safe_push (*argtypes, receiver_type); 1131 /* Selector type - will eventually change to `int'. */ 1132 vec_safe_push (*argtypes, 1133 superflag ? objc_v2_super_selector_type 1134 : objc_v2_selector_type); 1135 } 1136 1137 /* TODO: Merge this with the message refs. */ 1138 static tree 1139 build_selector_reference_decl (tree ident) 1140 { 1141 tree decl; 1142 char *t, buf[BUFSIZE]; 1143 1144 snprintf (buf, BUFSIZE, "_OBJC_SelRef_%s", IDENTIFIER_POINTER (ident)); 1145 t = buf; 1146 while (*t) 1147 { 1148 if (*t==':') 1149 *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */ 1150 t++; 1151 } 1152 decl = start_var_decl (objc_selector_type, buf); 1153 OBJCMETA (decl, objc_meta, meta_sel_refs); 1154 return decl; 1155 } 1156 1157 static tree 1158 next_runtime_abi_02_build_selector_reference (location_t loc ATTRIBUTE_UNUSED, 1159 tree ident, 1160 tree proto ATTRIBUTE_UNUSED) 1161 { 1162 tree *chain = &sel_ref_chain; 1163 tree expr; 1164 1165 while (*chain) 1166 { 1167 if (TREE_VALUE (*chain) == ident) 1168 return TREE_PURPOSE (*chain); 1169 1170 chain = &TREE_CHAIN (*chain); 1171 } 1172 1173 expr = build_selector_reference_decl (ident); 1174 *chain = tree_cons (expr, ident, NULL_TREE); 1175 1176 return expr; 1177 } 1178 1179 /* Declare a variable of type 'struct message_ref_t'. */ 1180 /* This will be finished in build_v2_message_ref_translation_table (). 1181 We take an idea from LLVM in making the names a bit more connected 1182 and thus the asm more readable. */ 1183 1184 static tree 1185 build_v2_message_reference_decl (tree sel_name, tree message_func_ident) 1186 { 1187 tree decl; 1188 char buf[BUFSIZE], *t; 1189 int offset = 12; 1190 1191 /* Skip past the objc_msgSend it's the same for all... */ 1192 if (IDENTIFIER_POINTER (message_func_ident)[offset] == '_') 1193 offset++; 1194 1195 snprintf (buf, BUFSIZE, "_OBJC_MsgRef_%s_%s", 1196 &(IDENTIFIER_POINTER (message_func_ident)[offset]), 1197 IDENTIFIER_POINTER (sel_name)); 1198 t = buf; 1199 while (*t) 1200 { 1201 if (*t==':') 1202 *t = '$'; /* Underscore would clash between foo:bar and foo_bar. */ 1203 t++; 1204 } 1205 decl = start_var_decl (objc_v2_message_ref_template, buf); 1206 OBJCMETA (decl, objc_meta, meta_mref); 1207 return decl; 1208 } 1209 1210 typedef struct GTY(()) msgref_entry { 1211 tree func; 1212 tree selname; 1213 tree refdecl; 1214 } msgref_entry; 1215 1216 static GTY (()) vec<msgref_entry, va_gc> *msgrefs; 1217 1218 /* Build the list of (objc_msgSend_fixup_xxx, selector name), used 1219 later on to initialize the table of 'struct message_ref_t' 1220 elements. */ 1221 1222 static tree 1223 build_v2_selector_messenger_reference (tree sel_name, tree message_func_decl) 1224 { 1225 tree decl; 1226 msgref_entry e; 1227 if (msgrefs) 1228 { 1229 int count; 1230 msgref_entry *ref; 1231 FOR_EACH_VEC_ELT (*msgrefs, count, ref) 1232 if (ref->func == message_func_decl && ref->selname == sel_name) 1233 return ref->refdecl; 1234 } 1235 else 1236 /* Somewhat arbitrary initial provision. */ 1237 vec_alloc (msgrefs, 32); 1238 1239 /* We come here if we don't find a match or at the start. */ 1240 decl = build_v2_message_reference_decl (sel_name, 1241 DECL_NAME (message_func_decl)); 1242 e.func = message_func_decl; 1243 e.selname = sel_name; 1244 e.refdecl = decl; 1245 vec_safe_push (msgrefs, e); 1246 return decl; 1247 } 1248 1249 static tree 1250 build_v2_protocollist_ref_decl (tree protocol) 1251 { 1252 tree decl; 1253 tree protocol_ident = PROTOCOL_NAME (protocol); 1254 char buf[BUFSIZE]; 1255 1256 snprintf (buf, BUFSIZE, "_OBJC_ProtocolRef_%s", 1257 IDENTIFIER_POINTER (protocol_ident)); 1258 /* TODO: other compiler versions make these hidden & weak. */ 1259 decl = create_global_decl (objc_protocol_type, buf); 1260 /* Let optimizer know that this decl is not removable. */ 1261 DECL_PRESERVE_P (decl) = 1; 1262 OBJCMETA (decl, objc_meta, meta_proto_ref); 1263 return decl; 1264 } 1265 1266 typedef struct GTY(()) prot_list_entry { 1267 tree id; 1268 tree refdecl; 1269 } prot_list_entry; 1270 static GTY (()) vec<prot_list_entry, va_gc> *protrefs; 1271 1272 static tree 1273 objc_v2_get_protocol_reference (tree ident) 1274 { 1275 tree decl; 1276 prot_list_entry e; 1277 if (protrefs) 1278 { 1279 int count; 1280 prot_list_entry *ref; 1281 FOR_EACH_VEC_ELT (*protrefs, count, ref) 1282 { 1283 if (ref->id == ident) 1284 { 1285 if (!ref->refdecl) 1286 ref->refdecl = build_v2_protocollist_ref_decl (ident); 1287 return ref->refdecl; 1288 } 1289 } 1290 } 1291 else 1292 /* Somewhat arbitrary initial provision. */ 1293 vec_alloc (protrefs, 32); 1294 1295 /* We come here if we don't find the entry - or if the table was yet 1296 to be created. */ 1297 decl = build_v2_protocollist_ref_decl (ident); 1298 e.id = ident; 1299 e.refdecl = decl; 1300 vec_safe_push (protrefs, e); 1301 return decl; 1302 } 1303 1304 static tree 1305 next_runtime_abi_02_get_protocol_reference (location_t loc ATTRIBUTE_UNUSED, 1306 tree p) 1307 { 1308 if (!PROTOCOL_FORWARD_DECL (p)) 1309 PROTOCOL_FORWARD_DECL (p) = next_runtime_abi_02_protocol_decl (p); 1310 1311 return objc_v2_get_protocol_reference (p); 1312 } 1313 1314 /* This routine returns the ivar declaration, if component is a valid 1315 ivar field; NULL_TREE otherwise. On finding an ivar, it also 1316 returns the class name in CLASS. */ 1317 1318 static tree 1319 objc_is_ivar (tree expr, tree component, tree *klass) 1320 { 1321 tree field = NULL_TREE; 1322 tree basetype = TYPE_MAIN_VARIANT (TREE_TYPE (expr)); 1323 1324 if (TREE_CODE (basetype) == RECORD_TYPE 1325 && TYPE_HAS_OBJC_INFO (basetype) && TYPE_OBJC_INTERFACE (basetype)) 1326 { 1327 *klass = lookup_interface (OBJC_TYPE_NAME (basetype)); 1328 if (*klass) 1329 { 1330 do 1331 { 1332 tree ivar_chain = CLASS_RAW_IVARS (*klass); 1333 if (ivar_chain) 1334 { 1335 field = is_ivar (ivar_chain, component); 1336 if (field != NULL_TREE) 1337 break; 1338 } 1339 *klass = lookup_interface (CLASS_SUPER_NAME (*klass)); 1340 } 1341 while (*klass); 1342 } 1343 } 1344 return field; 1345 } 1346 1347 static void 1348 create_ivar_offset_name (char *buf, tree class_name, tree field_decl) 1349 { 1350 tree fname = DECL_NAME (field_decl); 1351 1352 sprintf (buf, "OBJC_IVAR_$_%s.%s", IDENTIFIER_POINTER (class_name), 1353 IDENTIFIER_POINTER (fname)); 1354 return; 1355 } 1356 1357 /* This routine generates new abi's ivar reference tree. It amounts 1358 to generating *(TYPE*)((char*)pObj + OFFSET_IVAR) when we normally 1359 generate pObj->IVAR. OFFSET_IVAR is an 'extern' variable holding 1360 the offset for 'IVAR' field. TYPE is type of IVAR field. */ 1361 1362 static tree 1363 objc_v2_build_ivar_ref (tree datum, tree component) 1364 { 1365 tree field, ref, class_name, offset, ftype, expr; 1366 char var_offset_name[512]; 1367 1368 field = objc_is_ivar (datum, component, &class_name); 1369 if (!field) 1370 return NULL_TREE; 1371 1372 /* This routine only handles non-bitfield fields */ 1373 /* DECL_INITIAL macro is set to width of bitfield and can be relied 1374 on to check for bitfield ivars. Note that I cannot rely on 1375 DECL_BIT_FIELD macro because it is only set when the whole struct 1376 is seen (at finish_struct) and not when the ivar chain is 1377 built. */ 1378 if (DECL_INITIAL (field)) 1379 return NULL_TREE; 1380 1381 create_ivar_offset_name (var_offset_name, CLASS_NAME (class_name), field); 1382 1383 offset = create_extern_decl (TREE_TYPE (size_zero_node), var_offset_name); 1384 1385 ftype = TREE_TYPE (field); 1386 1387 /* (char*)datum */ 1388 expr = build_c_cast (input_location, 1389 string_type_node, build_fold_addr_expr (datum)); 1390 1391 /* (char*)datum + offset */ 1392 expr = fold_build_pointer_plus_loc (input_location, expr, offset); 1393 1394 /* (ftype*)((char*)datum + offset) */ 1395 expr = build_c_cast (input_location, build_pointer_type (ftype), expr); 1396 1397 /* Finally: *(ftype*)((char*)datum + offset) */ 1398 ref = build_indirect_ref (input_location, expr, RO_UNARY_STAR); 1399 1400 /* We must set type of the resulting expression to be the same as 1401 the field type. This is because, build_indirect_ref (...) 1402 rebuilds the type which may result in lost information; as in the 1403 case of protocol-qualified types (id <protocol> ). */ 1404 TREE_TYPE (ref) = ftype; 1405 1406 if (TREE_READONLY (datum) || TREE_READONLY (field)) 1407 TREE_READONLY (ref) = 1; 1408 1409 if (TREE_THIS_VOLATILE (datum) || TREE_THIS_VOLATILE (field)) 1410 TREE_THIS_VOLATILE (ref) = 1; 1411 1412 if (TREE_DEPRECATED (field)) 1413 warn_deprecated_use (field, NULL_TREE); 1414 1415 return ref; 1416 } 1417 1418 /* IVAR refs are made via an externally referenceable offset and built 1419 on the fly. That is, unless they refer to (private) fields in the 1420 class structure. */ 1421 static tree 1422 next_runtime_abi_02_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED, 1423 tree base, tree id) 1424 { 1425 tree ivar; 1426 if ((ivar = objc_v2_build_ivar_ref (base, id))) 1427 return ivar; 1428 return objc_build_component_ref (base, id); 1429 } 1430 1431 /* [super ...] references are listed here (and built into a table at 1432 meta -data emit time). */ 1433 static tree 1434 build_v2_superclass_ref_decl (tree ident, bool inst) 1435 { 1436 tree decl; 1437 char buf[BUFSIZE]; 1438 1439 snprintf (buf, BUFSIZE, "_OBJC_%sSuperRef_%s", (inst?"":"Meta"), 1440 IDENTIFIER_POINTER (ident)); 1441 decl = start_var_decl (objc_class_type, buf); 1442 OBJCMETA (decl, objc_meta, meta_superclass_ref); 1443 return decl; 1444 } 1445 1446 static GTY (()) vec<ident_data_tuple, va_gc> *class_super_refs; 1447 static GTY (()) vec<ident_data_tuple, va_gc> *metaclass_super_refs; 1448 1449 static tree 1450 next_runtime_abi_02_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED, 1451 struct imp_entry *imp, bool inst_meth) 1452 { 1453 tree decl; 1454 ident_data_tuple e; 1455 tree id = CLASS_NAME (imp->imp_context); 1456 vec<ident_data_tuple, va_gc> *list = inst_meth ? class_super_refs 1457 : metaclass_super_refs; 1458 1459 if (list) 1460 { 1461 int count; 1462 ident_data_tuple *ref; 1463 FOR_EACH_VEC_ELT (*list, count, ref) 1464 { 1465 if (ref->ident == id) 1466 { 1467 if (!ref->data) 1468 ref->data = build_v2_superclass_ref_decl (id, inst_meth); 1469 return ref->data; 1470 } 1471 } 1472 } 1473 else 1474 { 1475 /* Somewhat arbitrary initial provision. */ 1476 if (inst_meth) 1477 { 1478 vec_alloc (class_super_refs, 16); 1479 list = class_super_refs; 1480 } 1481 else 1482 { 1483 vec_alloc (metaclass_super_refs, 16); 1484 list = metaclass_super_refs; 1485 } 1486 } 1487 /* We come here if we don't find the entry - or if the table was yet 1488 to be created. */ 1489 decl = build_v2_superclass_ref_decl (id, inst_meth); 1490 e.ident = id; 1491 e.data = decl; 1492 vec_safe_push (list, e); 1493 return decl; 1494 } 1495 1496 static tree 1497 next_runtime_abi_02_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED, 1498 struct imp_entry *imp, bool inst_meth) 1499 { 1500 /* ??? is this OK when zero-link = true? */ 1501 tree super_name = CLASS_SUPER_NAME (imp->imp_template); 1502 tree super_class; 1503 1504 if (!flag_zero_link) 1505 { 1506 super_class = objc_get_class_reference (CLASS_NAME (imp->imp_template)); 1507 1508 if (!inst_meth) 1509 1510 /* If we are in a class method, we must retrieve the 1511 _metaclass_ for the current class, pointed at by the 1512 class's "isa" pointer. The following assumes that "isa" is 1513 the first ivar in a class (which it must be). */ 1514 super_class = 1515 build_indirect_ref (input_location, 1516 build_c_cast (input_location, 1517 build_pointer_type (objc_class_type), 1518 super_class), 1519 RO_UNARY_STAR); 1520 return super_class; 1521 } 1522 /* ??? Do we need to add the class ref anway for zero-link? */ 1523 /* else do it the slow way. */ 1524 super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl); 1525 super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1, 1526 IDENTIFIER_POINTER (super_name)); 1527 /* super_class = objc_get{Meta}Class("CLASS_SUPER_NAME"); */ 1528 return build_function_call (input_location, 1529 super_class, 1530 build_tree_list (NULL_TREE, super_name)); 1531 } 1532 1533 static tree 1534 next_runtime_abi_02_receiver_is_class_object (tree receiver) 1535 { 1536 if (TREE_CODE (receiver) == VAR_DECL 1537 && IS_CLASS (TREE_TYPE (receiver)) 1538 && vec_safe_length (classrefs)) 1539 { 1540 int count; 1541 ident_data_tuple *ref; 1542 /* The receiver is a variable created by build_class_reference_decl. */ 1543 FOR_EACH_VEC_ELT (*classrefs, count, ref) 1544 if (ref->data == receiver) 1545 return ref->ident; 1546 } 1547 return NULL_TREE; 1548 } 1549 1550 /* Assign all arguments in VALUES which have side-effect to a temporary 1551 and replaced that argument in VALUES list with the temporary. The 1552 arguments will be passed to a function with FNTYPE. */ 1553 1554 static tree 1555 objc_copy_to_temp_side_effect_params (tree fntype, tree values) 1556 { 1557 tree valtail; 1558 function_args_iterator iter; 1559 1560 /* Skip over receiver and the &_msf_ref types. */ 1561 function_args_iter_init (&iter, fntype); 1562 function_args_iter_next (&iter); 1563 function_args_iter_next (&iter); 1564 1565 for (valtail = values; valtail; 1566 valtail = TREE_CHAIN (valtail), function_args_iter_next (&iter)) 1567 { 1568 tree value = TREE_VALUE (valtail); 1569 tree type = function_args_iter_cond (&iter); 1570 if (type == NULL_TREE) 1571 break; 1572 if (!TREE_SIDE_EFFECTS (value)) 1573 continue; 1574 /* To prevent re-evaluation. */ 1575 value = save_expr (value); 1576 add_stmt (value); 1577 TREE_VALUE (valtail) = value; 1578 } 1579 return values; 1580 } 1581 1582 /* Build the new abi's messaging library call. It looks like: 1583 (*_msg.messenger) (receiver, &_msg, ...) */ 1584 1585 static tree 1586 build_v2_build_objc_method_call (int super_flag, tree method_prototype, 1587 tree lookup_object, tree selector, 1588 tree method_params, 1589 bool check_for_nil) 1590 { 1591 tree ret_val; 1592 tree sender, rcv_p, t; 1593 tree ret_type 1594 = (method_prototype 1595 ? TREE_VALUE (TREE_TYPE (method_prototype)) 1596 : objc_object_type); 1597 tree ftype = build_function_type_for_method (ret_type, method_prototype, 1598 METHOD_REF, super_flag); 1599 tree sender_cast; 1600 1601 if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype)) 1602 ftype = build_type_attribute_variant ( 1603 ftype, METHOD_TYPE_ATTRIBUTES (method_prototype)); 1604 1605 sender_cast = build_pointer_type (ftype); 1606 1607 if (check_for_nil) 1608 method_params = objc_copy_to_temp_side_effect_params (ftype, 1609 method_params); 1610 1611 /* Get &message_ref_t.messenger. */ 1612 sender = build_c_cast (input_location, 1613 build_pointer_type (super_flag 1614 ? objc_v2_super_imp_type 1615 : objc_v2_imp_type), 1616 selector); 1617 1618 sender = build_indirect_ref (input_location, sender, RO_UNARY_STAR); 1619 1620 rcv_p = (super_flag ? objc_super_type : objc_object_type); 1621 1622 lookup_object = build_c_cast (input_location, rcv_p, lookup_object); 1623 1624 /* Use SAVE_EXPR to avoid evaluating the receiver twice. */ 1625 lookup_object = save_expr (lookup_object); 1626 1627 method_params = tree_cons (NULL_TREE, lookup_object, 1628 tree_cons (NULL_TREE, selector, 1629 method_params)); 1630 t = build3 (OBJ_TYPE_REF, sender_cast, sender, lookup_object, size_zero_node); 1631 ret_val = build_function_call (input_location, t, method_params); 1632 if (check_for_nil) 1633 { 1634 /* receiver != nil ? ret_val : 0 */ 1635 tree ftree; 1636 tree ifexp; 1637 1638 if (TREE_CODE (ret_type) == RECORD_TYPE 1639 || TREE_CODE (ret_type) == UNION_TYPE) 1640 { 1641 vec<constructor_elt, va_gc> *rtt = NULL; 1642 /* ??? CHECKME. hmmm..... think we need something more 1643 here. */ 1644 CONSTRUCTOR_APPEND_ELT (rtt, NULL_TREE, NULL_TREE); 1645 ftree = objc_build_constructor (ret_type, rtt); 1646 } 1647 else 1648 ftree = fold_convert (ret_type, integer_zero_node); 1649 1650 ifexp = build_binary_op (input_location, NE_EXPR, 1651 lookup_object, 1652 fold_convert (rcv_p, integer_zero_node), 1); 1653 1654 #ifdef OBJCPLUS 1655 ret_val = build_conditional_expr (input_location, 1656 ifexp, ret_val, ftree, 1657 tf_warning_or_error); 1658 #else 1659 /* ??? CHECKME. */ 1660 ret_val = build_conditional_expr (input_location, 1661 ifexp, 1, 1662 ret_val, NULL_TREE, 1663 ftree, NULL_TREE); 1664 #endif 1665 } 1666 return ret_val; 1667 } 1668 1669 static tree 1670 next_runtime_abi_02_build_objc_method_call (location_t loc, 1671 tree method_prototype, 1672 tree receiver, 1673 tree rtype, 1674 tree sel_name, 1675 tree method_params, 1676 int super) 1677 { 1678 tree ret_type, selector; 1679 tree message_func_decl; 1680 bool check_for_nil = flag_objc_nilcheck; 1681 1682 ret_type = method_prototype 1683 ? TREE_VALUE (TREE_TYPE (method_prototype)) 1684 : objc_object_type; 1685 1686 /* Do we need to check for nil receivers ? */ 1687 /* For now, message sent to classes need no nil check. In the 1688 future, class declaration marked as weak_import must be nil 1689 checked. */ 1690 if (super 1691 || (TREE_CODE (receiver) == VAR_DECL 1692 && TREE_TYPE (receiver) == objc_class_type)) 1693 check_for_nil = false; 1694 1695 if (!targetm.calls.struct_value_rtx (0, 0) 1696 && (TREE_CODE (ret_type) == RECORD_TYPE 1697 || TREE_CODE (ret_type) == UNION_TYPE) 1698 && targetm.calls.return_in_memory (ret_type, 0)) 1699 { 1700 if (super) 1701 message_func_decl = umsg_id_super2_stret_fixup_decl; 1702 else 1703 message_func_decl = objc_is_id (rtype) 1704 ? umsg_id_stret_fixup_decl 1705 : umsg_stret_fixup_decl; 1706 } 1707 else 1708 { 1709 if (super) 1710 message_func_decl = umsg_id_super2_fixup_decl; 1711 else 1712 message_func_decl = objc_is_id (rtype) 1713 ? umsg_id_fixup_decl 1714 : umsg_fixup_decl; 1715 } 1716 1717 selector = build_v2_selector_messenger_reference (sel_name, 1718 message_func_decl); 1719 1720 /* selector = &_msg; */ 1721 selector = build_unary_op (loc, ADDR_EXPR, selector, 0); 1722 1723 selector = build_c_cast (loc, (super ? objc_v2_super_selector_type 1724 : objc_v2_selector_type), 1725 selector); 1726 1727 /* (*_msg.messenger) (receiver, &_msg, ...); */ 1728 return build_v2_build_objc_method_call (super, method_prototype, 1729 receiver, selector, 1730 method_params, check_for_nil); 1731 } 1732 1733 /* NOTE --- Constant String Class Stuff --- */ 1734 1735 static bool 1736 next_runtime_abi_02_setup_const_string_class_decl (void) 1737 { 1738 if (!constant_string_global_id) 1739 { 1740 /* Hopefully, this should not represent a serious limitation. */ 1741 char buf[BUFSIZE]; 1742 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", constant_string_class_name); 1743 constant_string_global_id = get_identifier (buf); 1744 } 1745 1746 string_class_decl = lookup_name (constant_string_global_id); 1747 1748 /* In OBJC2 abi, constant string class reference refers to class 1749 name for NSConstantString class. This declaration may not be 1750 available yet (in fact it is not in most cases). So, declare an 1751 extern OBJC_CLASS_$_NSConstantString in its place. */ 1752 if (!string_class_decl) 1753 string_class_decl = 1754 create_extern_decl (objc_v2_class_template, 1755 IDENTIFIER_POINTER (constant_string_global_id)); 1756 1757 return (string_class_decl != NULL_TREE); 1758 } 1759 1760 static tree 1761 next_runtime_abi_02_build_const_string_constructor (location_t loc, tree string, 1762 int length) 1763 { 1764 tree constructor, fields, var; 1765 vec<constructor_elt, va_gc> *v = NULL; 1766 1767 /* NeXT: (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length }) */ 1768 fields = TYPE_FIELDS (internal_const_str_type); 1769 CONSTRUCTOR_APPEND_ELT (v, fields, 1770 build_unary_op (loc, ADDR_EXPR, string_class_decl, 0)); 1771 1772 fields = DECL_CHAIN (fields); 1773 CONSTRUCTOR_APPEND_ELT (v, fields, 1774 build_unary_op (loc, ADDR_EXPR, string, 1)); 1775 1776 /* ??? check if this should be long. */ 1777 fields = DECL_CHAIN (fields); 1778 CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length)); 1779 constructor = objc_build_constructor (internal_const_str_type, v); 1780 1781 var = build_decl (input_location, CONST_DECL, NULL, TREE_TYPE (constructor)); 1782 DECL_INITIAL (var) = constructor; 1783 TREE_STATIC (var) = 1; 1784 DECL_CONTEXT (var) = NULL; 1785 OBJCMETA (var, objc_meta, meta_const_str); 1786 return var; 1787 } 1788 1789 /* NOTE --- NeXT V2 Metadata templates --- */ 1790 1791 /* This routine builds the following type: 1792 struct _prop_t 1793 { 1794 const char * const name; // property name 1795 const char * const attributes; // comma-delimited, encoded, 1796 // property attributes 1797 }; 1798 */ 1799 1800 static tree 1801 build_v2_property_template (void) 1802 { 1803 tree prop_record; 1804 tree decls, *chain = NULL; 1805 1806 prop_record = objc_start_struct (get_identifier ("_prop_t")); 1807 /* const char * name */ 1808 decls = add_field_decl (string_type_node, "name", &chain); 1809 1810 /* const char * attribute */ 1811 add_field_decl (string_type_node, "attribute", &chain); 1812 1813 objc_finish_struct (prop_record, decls); 1814 return prop_record; 1815 } 1816 1817 /* struct ivar_t 1818 { 1819 unsigned long int *offset; 1820 char *name; 1821 char *type; 1822 uint32_t alignment; 1823 uint32_t size; 1824 }; 1825 */ 1826 1827 static tree 1828 build_v2_ivar_t_template (void) 1829 { 1830 tree objc_ivar_id, objc_ivar_record; 1831 tree decls, *chain = NULL; 1832 1833 objc_ivar_id = get_identifier ("_ivar_t"); 1834 objc_ivar_record = objc_start_struct (objc_ivar_id); 1835 1836 /* unsigned long int *offset; */ 1837 decls = add_field_decl (build_pointer_type 1838 (TREE_TYPE (size_zero_node)), "offset", &chain); 1839 1840 /* char *name; */ 1841 add_field_decl (string_type_node, "name", &chain); 1842 1843 /* char *type; */ 1844 add_field_decl (string_type_node, "type", &chain); 1845 1846 /* uint32_t alignment; */ 1847 add_field_decl (integer_type_node, "alignment", &chain); 1848 1849 /* uint32_t size; */ 1850 add_field_decl (integer_type_node, "size", &chain); 1851 1852 objc_finish_struct (objc_ivar_record, decls); 1853 return objc_ivar_record; 1854 } 1855 1856 static void 1857 build_metadata_templates (void) 1858 { 1859 1860 if (!objc_method_template) 1861 objc_method_template = build_method_template (); 1862 1863 if (!objc_v2_property_template) 1864 objc_v2_property_template = build_v2_property_template (); 1865 1866 if (!objc_v2_ivar_template) 1867 objc_v2_ivar_template = build_v2_ivar_t_template (); 1868 1869 } 1870 1871 /* NOTE --- Output NeXT V2 Metadata --- */ 1872 1873 /* Routine builds name of Interface's main meta-data of type class_t. */ 1874 1875 static char * 1876 objc_build_internal_classname (tree ident, bool metaclass) 1877 { 1878 static char string[512]; 1879 snprintf (string, 512, "%s_%s", metaclass ? "OBJC_METACLASS_$" 1880 : "OBJC_CLASS_$", 1881 IDENTIFIER_POINTER (ident)); 1882 return string; 1883 } 1884 1885 /* Build the name for object of type struct class_ro_t */ 1886 1887 static const char * 1888 newabi_append_ro (const char *name) 1889 { 1890 const char *dollar; 1891 char *p; 1892 static char string[BUFSIZE]; 1893 dollar = strchr (name, '$'); 1894 gcc_assert (dollar); 1895 p = string; 1896 *p = '_'; p++; 1897 strncpy (p, name, (int)(dollar - name)); 1898 p += (int)(dollar - name); 1899 sprintf (p, "RO_%s", dollar); 1900 return string; 1901 } 1902 1903 /* Build the struct message_ref_t msg = 1904 {objc_msgSend_fixup_xxx, @selector(func)} 1905 table. */ 1906 1907 static 1908 void build_v2_message_ref_translation_table (void) 1909 { 1910 int count; 1911 msgref_entry *ref; 1912 1913 if (!vec_safe_length (msgrefs)) 1914 return; 1915 1916 FOR_EACH_VEC_ELT (*msgrefs, count, ref) 1917 { 1918 vec<constructor_elt, va_gc> *initializer; 1919 tree expr, constructor; 1920 tree struct_type = TREE_TYPE (ref->refdecl); 1921 location_t loc = DECL_SOURCE_LOCATION (ref->refdecl); 1922 1923 initializer = NULL; 1924 /* First 'IMP messenger' field... */ 1925 expr = build_unary_op (loc, ADDR_EXPR, ref->func, 0); 1926 expr = convert (objc_v2_imp_type, expr); 1927 CONSTRUCTOR_APPEND_ELT (initializer, NULL_TREE, expr); 1928 1929 /* ... then 'SEL name' field. */ 1930 expr = build_selector (ref->selname); 1931 CONSTRUCTOR_APPEND_ELT (initializer, NULL_TREE, expr); 1932 constructor = objc_build_constructor (struct_type, initializer); 1933 finish_var_decl (ref->refdecl, constructor); 1934 } 1935 } 1936 1937 /* Build decl = initializer; for each externally visible class 1938 reference. */ 1939 1940 static void 1941 build_v2_classrefs_table (void) 1942 { 1943 int count; 1944 ident_data_tuple *ref; 1945 1946 if (!vec_safe_length (classrefs)) 1947 return; 1948 1949 FOR_EACH_VEC_ELT (*classrefs, count, ref) 1950 { 1951 tree expr = ref->ident; 1952 tree decl = ref->data; 1953 /* Interface with no implementation and yet one of its messages 1954 has been used. Need to generate a full address-of tree for it 1955 here. */ 1956 if (TREE_CODE (expr) == IDENTIFIER_NODE) 1957 { 1958 const char *name = objc_build_internal_classname (expr, false); 1959 expr = create_extern_decl (objc_v2_class_template, name); 1960 expr = convert (objc_class_type, build_fold_addr_expr (expr)); 1961 } 1962 /* The runtime wants this, even if it appears unused, so we must force the 1963 output. 1964 DECL_PRESERVE_P (decl) = 1; */ 1965 finish_var_decl (decl, expr); 1966 } 1967 } 1968 1969 /* Build decl = initializer; for each externally visible super class 1970 reference. */ 1971 1972 static void 1973 build_v2_super_classrefs_table (bool metaclass) 1974 { 1975 int count; 1976 ident_data_tuple *ref; 1977 vec<ident_data_tuple, va_gc> *list = metaclass ? metaclass_super_refs 1978 : class_super_refs; 1979 1980 if (!vec_safe_length (list)) 1981 return; 1982 1983 FOR_EACH_VEC_ELT (*list, count, ref) 1984 { 1985 tree expr = ref->ident; 1986 tree decl = ref->data; 1987 /* Interface with no implementation and yet one of its messages 1988 has been used. Need to generate a full address-of tree for it 1989 here. */ 1990 if (TREE_CODE (expr) == IDENTIFIER_NODE) 1991 { 1992 const char * name = objc_build_internal_classname (expr, metaclass); 1993 expr = create_extern_decl (objc_v2_class_template, name); 1994 expr = convert (objc_class_type, build_fold_addr_expr (expr)); 1995 } 1996 finish_var_decl (decl, expr); 1997 } 1998 } 1999 2000 /* Add the global class meta-data declaration to the list which later 2001 on ends up in the __class_list section. */ 2002 2003 static GTY(()) vec<tree, va_gc> *class_list; 2004 2005 static void 2006 objc_v2_add_to_class_list (tree global_class_decl) 2007 { 2008 vec_safe_push (class_list, global_class_decl); 2009 } 2010 2011 static GTY(()) vec<tree, va_gc> *nonlazy_class_list; 2012 2013 /* Add the global class meta-data declaration to the list which later 2014 on ends up in the __nonlazy_class section. */ 2015 2016 static void 2017 objc_v2_add_to_nonlazy_class_list (tree global_class_decl) 2018 { 2019 vec_safe_push (nonlazy_class_list, global_class_decl); 2020 } 2021 2022 static GTY(()) vec<tree, va_gc> *category_list; 2023 2024 /* Add the category meta-data declaration to the list which later on 2025 ends up in the __nonlazy_category section. */ 2026 2027 static void 2028 objc_v2_add_to_category_list (tree decl) 2029 { 2030 vec_safe_push (category_list, decl); 2031 } 2032 2033 static GTY(()) vec<tree, va_gc> *nonlazy_category_list; 2034 2035 /* Add the category meta-data declaration to the list which later on 2036 ends up in the __category_list section. */ 2037 2038 static void 2039 objc_v2_add_to_nonlazy_category_list (tree decl) 2040 { 2041 vec_safe_push (nonlazy_category_list, decl); 2042 } 2043 2044 static bool 2045 has_load_impl (tree clsmeth) 2046 { 2047 while (clsmeth) 2048 { 2049 tree id = METHOD_SEL_NAME (clsmeth); 2050 if (IDENTIFIER_LENGTH (id) == 4 2051 && strncmp (IDENTIFIER_POINTER (id), "load", 4) == 0) 2052 return true; 2053 clsmeth = DECL_CHAIN (clsmeth); 2054 } 2055 2056 return false; 2057 } 2058 2059 /* Build a __{class,category}_list section table containing address of 2060 all @implemented {class,category} meta-data. */ 2061 2062 static void 2063 build_v2_address_table (vec<tree, va_gc> *src, const char *nam, tree attr) 2064 { 2065 int count=0; 2066 tree type, decl, expr; 2067 vec<constructor_elt, va_gc> *initlist = NULL; 2068 2069 if (!vec_safe_length (src)) 2070 return; 2071 2072 FOR_EACH_VEC_ELT (*src, count, decl) 2073 { 2074 #ifndef OBJCPLUS 2075 tree purpose = build_int_cst (NULL_TREE, count); 2076 #else 2077 tree purpose = NULL_TREE; 2078 #endif 2079 expr = convert (objc_class_type, build_fold_addr_expr (decl)); 2080 CONSTRUCTOR_APPEND_ELT (initlist, purpose, expr); 2081 } 2082 gcc_assert (count > 0); 2083 type = build_array_type (objc_class_type, 2084 build_index_type (build_int_cst (NULL_TREE, count - 1))); 2085 decl = start_var_decl (type, nam); 2086 /* The runtime wants this, even if it appears unused, so we must 2087 force the output. */ 2088 DECL_PRESERVE_P (decl) = 1; 2089 expr = objc_build_constructor (type, initlist); 2090 OBJCMETA (decl, objc_meta, attr); 2091 finish_var_decl (decl, expr); 2092 } 2093 2094 /* Build decl = initializer; for each protocol referenced in 2095 @protocol(MyProt) expression. Refs as built in the entry section 2096 above. */ 2097 2098 static void 2099 build_v2_protocol_list_translation_table (void) 2100 { 2101 int count; 2102 prot_list_entry *ref; 2103 2104 if (!protrefs) 2105 return; 2106 2107 FOR_EACH_VEC_ELT (*protrefs, count, ref) 2108 { 2109 char buf[BUFSIZE]; 2110 tree expr; 2111 gcc_assert (TREE_CODE (ref->id) == PROTOCOL_INTERFACE_TYPE); 2112 snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s", 2113 IDENTIFIER_POINTER (PROTOCOL_NAME (ref->id))); 2114 expr = start_var_decl (objc_v2_protocol_template, buf); 2115 expr = convert (objc_protocol_type, build_fold_addr_expr (expr)); 2116 finish_var_decl (ref->refdecl, expr); 2117 } 2118 /* TODO: Maybe we could explicitly delete the vec. now? */ 2119 } 2120 2121 static GTY (()) vec<prot_list_entry, va_gc> *protlist; 2122 2123 /* Add the local protocol meta-data declaration to the list which 2124 later on ends up in the __protocol_list section. */ 2125 2126 static void 2127 objc_add_to_protocol_list (tree protocol_interface_decl, tree protocol_decl) 2128 { 2129 prot_list_entry e; 2130 if (!protlist) 2131 /* Arbitrary init count. */ 2132 vec_alloc (protlist, 32); 2133 e.id = protocol_interface_decl; 2134 e.refdecl = protocol_decl; 2135 vec_safe_push (protlist, e); 2136 } 2137 2138 /* Build the __protocol_list section table containing address of all 2139 generate protocol_t meta-data. */ 2140 2141 static void 2142 build_v2_protocol_list_address_table (void) 2143 { 2144 int count; 2145 prot_list_entry *ref; 2146 if (!vec_safe_length (protlist)) 2147 return; 2148 2149 FOR_EACH_VEC_ELT (*protlist, count, ref) 2150 { 2151 tree decl, expr; 2152 char buf[BUFSIZE]; 2153 gcc_assert (ref->id && TREE_CODE (ref->id) == PROTOCOL_INTERFACE_TYPE); 2154 snprintf (buf, BUFSIZE, "_OBJC_LabelProtocol_%s", 2155 IDENTIFIER_POINTER (PROTOCOL_NAME (ref->id))); 2156 decl = create_global_decl (objc_protocol_type, buf); 2157 expr = convert (objc_protocol_type, build_fold_addr_expr (ref->refdecl)); 2158 OBJCMETA (decl, objc_meta, meta_label_protocollist); 2159 finish_var_decl (decl, expr); 2160 } 2161 2162 /* TODO: delete the vec. */ 2163 /* TODO: upgrade to the clang/llvm hidden version. */ 2164 } 2165 2166 /* This routine declares a variable to hold meta data for 'struct 2167 protocol_list_t'. */ 2168 2169 static tree 2170 generate_v2_protocol_list (tree i_or_p, tree klass_ctxt) 2171 { 2172 tree refs_decl, lproto, e, plist, ptempl_p_t; 2173 int size = 0; 2174 vec<constructor_elt, va_gc> *initlist = NULL; 2175 char buf[BUFSIZE]; 2176 2177 if (TREE_CODE (i_or_p) == CLASS_INTERFACE_TYPE 2178 || TREE_CODE (i_or_p) == CATEGORY_INTERFACE_TYPE) 2179 plist = CLASS_PROTOCOL_LIST (i_or_p); 2180 else if (TREE_CODE (i_or_p) == PROTOCOL_INTERFACE_TYPE) 2181 plist = PROTOCOL_LIST (i_or_p); 2182 else 2183 gcc_unreachable (); 2184 2185 /* Compute size. */ 2186 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) 2187 if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE 2188 && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto))) 2189 size++; 2190 2191 /* Build initializer. */ 2192 2193 ptempl_p_t = build_pointer_type (objc_v2_protocol_template); 2194 e = build_int_cst (ptempl_p_t, size); 2195 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, e); 2196 2197 for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto)) 2198 { 2199 tree pval = TREE_VALUE (lproto); 2200 2201 if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE 2202 && PROTOCOL_FORWARD_DECL (pval)) 2203 { 2204 tree fwref = PROTOCOL_FORWARD_DECL (pval); 2205 location_t loc = DECL_SOURCE_LOCATION (fwref) ; 2206 e = build_unary_op (loc, ADDR_EXPR, fwref, 0); 2207 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, e); 2208 } 2209 } 2210 2211 /* static struct protocol_list_t *list[size]; */ 2212 2213 switch (TREE_CODE (i_or_p)) 2214 { 2215 case PROTOCOL_INTERFACE_TYPE: 2216 snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s", 2217 IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p))); 2218 break; 2219 case CLASS_INTERFACE_TYPE: 2220 snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s", 2221 IDENTIFIER_POINTER (CLASS_NAME (i_or_p))); 2222 break; 2223 case CATEGORY_INTERFACE_TYPE: 2224 snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s", 2225 IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)), 2226 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt))); 2227 break; 2228 default: 2229 gcc_unreachable (); 2230 } 2231 2232 refs_decl = start_var_decl (build_sized_array_type (ptempl_p_t, size+1), 2233 buf); 2234 /* ObjC2 puts all these in the base section. */ 2235 OBJCMETA (refs_decl, objc_meta, meta_base); 2236 DECL_PRESERVE_P (refs_decl) = 1; 2237 finish_var_decl (refs_decl, 2238 objc_build_constructor (TREE_TYPE (refs_decl),initlist)); 2239 return refs_decl; 2240 } 2241 2242 /* This routine builds one 'struct method_t' initializer list. Note 2243 that the old ABI is supposed to build 'struct objc_method' which 2244 has 3 fields, but it does not build the initialization expression 2245 for 'method_imp' which for protocols is NULL any way. To be 2246 consistent with declaration of 'struct method_t', in the new ABI we 2247 set the method_t.imp to NULL. */ 2248 2249 static tree 2250 build_v2_descriptor_table_initializer (tree type, tree entries) 2251 { 2252 vec<constructor_elt, va_gc> *initlist = NULL; 2253 do 2254 { 2255 vec<constructor_elt, va_gc> *eltlist = NULL; 2256 CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, 2257 build_selector (METHOD_SEL_NAME (entries))); 2258 CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, 2259 add_objc_string (METHOD_ENCODING (entries), 2260 meth_var_types)); 2261 CONSTRUCTOR_APPEND_ELT (eltlist, NULL_TREE, null_pointer_node); 2262 2263 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, 2264 objc_build_constructor (type, eltlist)); 2265 entries = TREE_CHAIN (entries); 2266 } 2267 while (entries); 2268 2269 return objc_build_constructor (build_array_type (type, 0), initlist); 2270 } 2271 2272 /* struct method_list_t 2273 { 2274 uint32_t entsize; 2275 uint32_t method_count; 2276 struct objc_method method_list[method_count]; 2277 }; */ 2278 2279 static tree 2280 build_v2_method_list_template (tree list_type, int size) 2281 { 2282 tree method_list_t_record; 2283 tree array_type, decls, *chain = NULL; 2284 2285 method_list_t_record = objc_start_struct (NULL_TREE); 2286 2287 /* uint32_t const entsize; */ 2288 decls = add_field_decl (integer_type_node, "entsize", &chain); 2289 2290 /* int method_count; */ 2291 add_field_decl (integer_type_node, "method_count", &chain); 2292 2293 /* struct objc_method method_list[]; */ 2294 array_type = build_sized_array_type (list_type, size); 2295 add_field_decl (array_type, "method_list", &chain); 2296 2297 objc_finish_struct (method_list_t_record, decls); 2298 return method_list_t_record; 2299 } 2300 2301 /* Note, as above that we are building to the objc_method_template 2302 which has the *imp field. ABI0/1 build with 2303 objc_method_prototype_template which is missing this field. */ 2304 static tree 2305 generate_v2_meth_descriptor_table (tree chain, tree protocol, 2306 const char *prefix, tree attr) 2307 { 2308 tree method_list_template, initlist, decl, methods; 2309 int size, entsize; 2310 vec<constructor_elt, va_gc> *v = NULL; 2311 char buf[BUFSIZE]; 2312 2313 if (!chain || !prefix) 2314 return NULL_TREE; 2315 2316 methods = chain; 2317 size = 0; 2318 while (methods) 2319 { 2320 if (! METHOD_ENCODING (methods)) 2321 METHOD_ENCODING (methods) = encode_method_prototype (methods); 2322 methods = TREE_CHAIN (methods); 2323 size++; 2324 } 2325 2326 gcc_assert (size); 2327 method_list_template = build_v2_method_list_template (objc_method_template, 2328 size); 2329 snprintf (buf, BUFSIZE, "%s_%s", prefix, 2330 IDENTIFIER_POINTER (PROTOCOL_NAME (protocol))); 2331 2332 decl = start_var_decl (method_list_template, buf); 2333 2334 entsize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template)); 2335 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, entsize)); 2336 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size)); 2337 initlist = 2338 build_v2_descriptor_table_initializer (objc_method_template, 2339 chain); 2340 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); 2341 /* Get into the right section. */ 2342 OBJCMETA (decl, objc_meta, attr); 2343 finish_var_decl (decl, objc_build_constructor (method_list_template, v)); 2344 return decl; 2345 } 2346 2347 /* This routine builds the initializer list to initialize the 'struct 2348 _prop_t prop_list[]' field of 'struct _prop_list_t' meta-data. */ 2349 2350 static tree 2351 build_v2_property_table_initializer (tree type, tree context) 2352 { 2353 tree x; 2354 vec<constructor_elt, va_gc> *inits = NULL; 2355 if (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE) 2356 x = CLASS_PROPERTY_DECL (context); 2357 else 2358 x = IMPL_PROPERTY_DECL (context); 2359 2360 for (; x; x = TREE_CHAIN (x)) 2361 { 2362 vec<constructor_elt, va_gc> *elemlist = NULL; 2363 /* NOTE! sections where property name/attribute go MUST change 2364 later. */ 2365 tree attribute, name_ident = PROPERTY_NAME (x); 2366 2367 CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE, 2368 add_objc_string (name_ident, prop_names_attr)); 2369 2370 attribute = objc_v2_encode_prop_attr (x); 2371 CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE, 2372 add_objc_string (attribute, prop_names_attr)); 2373 2374 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2375 objc_build_constructor (type, elemlist)); 2376 } 2377 2378 return objc_build_constructor (build_array_type (type, 0),inits); 2379 } 2380 2381 /* This routine builds the following type: 2382 struct _prop_list_t 2383 { 2384 uint32_t entsize; // sizeof (struct _prop_t) 2385 uint32_t prop_count; 2386 struct _prop_t prop_list [prop_count]; 2387 } 2388 */ 2389 2390 static tree 2391 build_v2_property_list_template (tree list_type, int size) 2392 { 2393 tree property_list_t_record; 2394 tree array_type, decls, *chain = NULL; 2395 2396 /* anonymous. */ 2397 property_list_t_record = objc_start_struct (NULL_TREE); 2398 2399 /* uint32_t const entsize; */ 2400 decls = add_field_decl (integer_type_node, "entsize", &chain); 2401 2402 /* int prop_count; */ 2403 add_field_decl (integer_type_node, "prop_count", &chain); 2404 2405 /* struct _prop_t prop_list[]; */ 2406 array_type = build_sized_array_type (list_type, size); 2407 add_field_decl (array_type, "prop_list", &chain); 2408 2409 objc_finish_struct (property_list_t_record, decls); 2410 return property_list_t_record; 2411 } 2412 2413 /* Top-level routine to generate property tables for each 2414 implementation. */ 2415 2416 static tree 2417 generate_v2_property_table (tree context, tree klass_ctxt) 2418 { 2419 tree x, decl, initlist, property_list_template; 2420 bool is_proto = false; 2421 vec<constructor_elt, va_gc> *inits = NULL; 2422 int init_val, size = 0; 2423 char buf[BUFSIZE]; 2424 2425 if (context) 2426 { 2427 gcc_assert (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE); 2428 x = CLASS_PROPERTY_DECL (context); 2429 is_proto = true; 2430 } 2431 else 2432 x = IMPL_PROPERTY_DECL (klass_ctxt); 2433 2434 for (; x; x = TREE_CHAIN (x)) 2435 size++; 2436 2437 if (size == 0) 2438 return NULL_TREE; 2439 2440 property_list_template = 2441 build_v2_property_list_template (objc_v2_property_template, 2442 size); 2443 2444 initlist = build_v2_property_table_initializer (objc_v2_property_template, 2445 is_proto ? context 2446 : klass_ctxt); 2447 2448 init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_property_template)); 2449 if (is_proto) 2450 snprintf (buf, BUFSIZE, "_OBJC_ProtocolPropList_%s", 2451 IDENTIFIER_POINTER (PROTOCOL_NAME (context))); 2452 else 2453 snprintf (buf, BUFSIZE, "_OBJC_ClassPropList_%s", 2454 IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt))); 2455 2456 decl = start_var_decl (property_list_template, buf); 2457 2458 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2459 build_int_cst (NULL_TREE, init_val)); 2460 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2461 build_int_cst (NULL_TREE, size)); 2462 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); 2463 2464 OBJCMETA (decl, objc_meta, meta_base); 2465 finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), inits)); 2466 return decl; 2467 } 2468 2469 static tree 2470 build_v2_protocol_initializer (tree type, tree protocol_name, tree protocol_list, 2471 tree inst_methods, tree class_methods, 2472 tree opt_ins_meth, tree opt_cls_meth, 2473 tree property_list) 2474 { 2475 tree expr, ttyp; 2476 location_t loc; 2477 vec<constructor_elt, va_gc> *inits = NULL; 2478 2479 /* TODO: find a better representation of location from the inputs. */ 2480 loc = UNKNOWN_LOCATION; 2481 2482 /* This is NULL for the new ABI. */ 2483 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2484 convert (objc_object_type, null_pointer_node)); 2485 2486 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name); 2487 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list); 2488 2489 ttyp = objc_method_proto_list_ptr; 2490 if (inst_methods) 2491 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); 2492 else 2493 expr = convert (ttyp, null_pointer_node); 2494 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 2495 2496 if (class_methods) 2497 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); 2498 else 2499 expr = convert (ttyp, null_pointer_node); 2500 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 2501 2502 if (opt_ins_meth) 2503 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, opt_ins_meth, 0)); 2504 else 2505 expr = convert (ttyp, null_pointer_node); 2506 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 2507 2508 if (opt_cls_meth) 2509 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, opt_cls_meth, 0)); 2510 else 2511 expr = convert (ttyp, null_pointer_node); 2512 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 2513 2514 ttyp = objc_prop_list_ptr; 2515 if (property_list) 2516 expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); 2517 else 2518 expr = convert (ttyp, null_pointer_node); 2519 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 2520 2521 /* const uint32_t size; = sizeof(struct protocol_t) */ 2522 expr = build_int_cst (integer_type_node, 2523 TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_protocol_template))); 2524 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr); 2525 /* const uint32_t flags; = 0 */ 2526 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, integer_zero_node); 2527 2528 return objc_build_constructor (type, inits); 2529 } 2530 2531 /* Main routine to build all meta data for all protocols used in a 2532 translation unit. */ 2533 2534 static void 2535 generate_v2_protocols (void) 2536 { 2537 tree p ; 2538 bool some = false; 2539 2540 if (!protocol_chain) 2541 return ; 2542 2543 /* If a protocol was directly referenced, pull in indirect 2544 references. */ 2545 for (p = protocol_chain; p; p = TREE_CHAIN (p)) 2546 if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p)) 2547 generate_protocol_references (PROTOCOL_LIST (p)); 2548 2549 for (p = protocol_chain; p; p = TREE_CHAIN (p)) 2550 { 2551 location_t loc; 2552 tree inst_meth, class_meth, opt_inst_meth, opt_class_meth, props; 2553 tree decl, initlist, protocol_name_expr, refs_decl, refs_expr; 2554 2555 /* If protocol wasn't referenced, don't generate any code. */ 2556 decl = PROTOCOL_FORWARD_DECL (p); 2557 2558 if (!decl) 2559 continue; 2560 2561 loc = DECL_SOURCE_LOCATION (decl); 2562 some = true; 2563 2564 inst_meth = 2565 generate_v2_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p, 2566 "_OBJC_ProtocolInstanceMethods", 2567 meta_proto_nst_meth); 2568 2569 class_meth = 2570 generate_v2_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p, 2571 "_OBJC_ProtocolClassMethods", 2572 meta_proto_cls_meth); 2573 2574 opt_inst_meth = 2575 generate_v2_meth_descriptor_table (PROTOCOL_OPTIONAL_NST_METHODS (p), p, 2576 "_OBJC_OptProtocolInstMethods", 2577 meta_proto_nst_meth); 2578 2579 opt_class_meth = 2580 generate_v2_meth_descriptor_table (PROTOCOL_OPTIONAL_CLS_METHODS (p), p, 2581 "_OBJC_OptProtocolClassMethods", 2582 meta_proto_cls_meth); 2583 2584 if (PROTOCOL_LIST (p)) 2585 refs_decl = generate_v2_protocol_list (p, NULL_TREE); 2586 else 2587 refs_decl = 0; 2588 2589 /* static struct objc_protocol _OBJC_Protocol_<mumble>; */ 2590 protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names); 2591 2592 if (refs_decl) 2593 refs_expr = convert (build_pointer_type (objc_v2_protocol_template), 2594 build_unary_op (loc, ADDR_EXPR, refs_decl, 0)); 2595 else 2596 refs_expr = build_int_cst (NULL_TREE, 0); 2597 2598 props = generate_v2_property_table (p, NULL_TREE); 2599 2600 initlist = build_v2_protocol_initializer (TREE_TYPE (decl), 2601 protocol_name_expr, refs_expr, 2602 inst_meth, class_meth, 2603 opt_inst_meth, opt_class_meth, 2604 props); 2605 finish_var_decl (decl, initlist); 2606 objc_add_to_protocol_list (p, decl); 2607 } 2608 2609 if (some) 2610 { 2611 /* Make sure we get the Protocol class linked in - reference 2612 it... */ 2613 p = objc_v2_get_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME)); 2614 /* ... but since we don't specifically use the reference... we 2615 need to force it. */ 2616 DECL_PRESERVE_P (p) = 1; 2617 } 2618 } 2619 2620 static tree 2621 generate_v2_dispatch_table (tree chain, const char *name, tree attr) 2622 { 2623 tree decl, method_list_template, initlist; 2624 vec<constructor_elt, va_gc> *v = NULL; 2625 int size, init_val; 2626 2627 if (!chain || !name || !(size = list_length (chain))) 2628 return NULL_TREE; 2629 2630 method_list_template 2631 = build_v2_method_list_template (objc_method_template, size); 2632 initlist 2633 = build_dispatch_table_initializer (objc_method_template, chain); 2634 2635 decl = start_var_decl (method_list_template, name); 2636 2637 init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_method_template)); 2638 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 2639 build_int_cst (integer_type_node, init_val)); 2640 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, 2641 build_int_cst (integer_type_node, size)); 2642 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist); 2643 2644 OBJCMETA (decl, objc_meta, attr); 2645 finish_var_decl (decl, 2646 objc_build_constructor (TREE_TYPE (decl), v)); 2647 return decl; 2648 } 2649 2650 /* Init a category. */ 2651 static tree 2652 build_v2_category_initializer (tree type, tree cat_name, tree class_name, 2653 tree inst_methods, tree class_methods, 2654 tree protocol_list, tree property_list, 2655 location_t loc) 2656 { 2657 tree expr, ltyp; 2658 vec<constructor_elt, va_gc> *v = NULL; 2659 2660 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name); 2661 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name); 2662 2663 ltyp = objc_method_list_ptr; 2664 if (inst_methods) 2665 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0)); 2666 else 2667 expr = convert (ltyp, null_pointer_node); 2668 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 2669 2670 if (class_methods) 2671 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0)); 2672 else 2673 expr = convert (ltyp, null_pointer_node); 2674 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 2675 2676 /* protocol_list = */ 2677 ltyp = build_pointer_type (objc_v2_protocol_template); 2678 if (protocol_list) 2679 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0)); 2680 else 2681 expr = convert (ltyp, null_pointer_node); 2682 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 2683 2684 ltyp = objc_prop_list_ptr; 2685 if (property_list) 2686 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); 2687 else 2688 expr = convert (ltyp, null_pointer_node); 2689 CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr); 2690 2691 return objc_build_constructor (type, v); 2692 } 2693 2694 /* static struct category_t _OBJC_CATEGORY_$_<name> = { ... }; */ 2695 2696 static void 2697 generate_v2_category (struct imp_entry *impent) 2698 { 2699 tree initlist, cat_name_expr, class_name_expr; 2700 tree protocol_decl, category, props, t; 2701 tree inst_methods = NULL_TREE, class_methods = NULL_TREE; 2702 tree cat = impent->imp_context; 2703 tree cat_decl = impent->class_decl; 2704 location_t loc; 2705 char buf[BUFSIZE]; 2706 2707 loc = DECL_SOURCE_LOCATION (cat_decl); 2708 2709 /* ??? not sure this is really necessary, the following references should 2710 force appropriate linkage linkage... 2711 -- but ... ensure a reference to the class... */ 2712 t = objc_v2_get_class_reference (CLASS_NAME (cat)); 2713 /* ... which we ignore so force it out.. */ 2714 DECL_PRESERVE_P (t) = 1; 2715 2716 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", IDENTIFIER_POINTER (CLASS_NAME (cat))); 2717 class_name_expr = create_extern_decl (objc_v2_class_template, buf); 2718 class_name_expr = build_fold_addr_expr (class_name_expr); 2719 2720 cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names); 2721 category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat)); 2722 2723 if (category && CLASS_PROTOCOL_LIST (category)) 2724 { 2725 generate_protocol_references (CLASS_PROTOCOL_LIST (category)); 2726 protocol_decl = generate_v2_protocol_list (category, cat); 2727 } 2728 else 2729 protocol_decl = NULL_TREE; 2730 2731 /* decl = update_var_decl(impent->class_decl); */ 2732 2733 props = generate_v2_property_table (NULL_TREE, cat); 2734 2735 if (CLASS_NST_METHODS (cat)) 2736 { 2737 snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s", 2738 IDENTIFIER_POINTER (CLASS_NAME (cat)), 2739 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); 2740 inst_methods = generate_v2_dispatch_table (CLASS_NST_METHODS (cat), buf, 2741 meta_cati_meth); 2742 } 2743 2744 if (CLASS_CLS_METHODS (cat)) 2745 { 2746 snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s", 2747 IDENTIFIER_POINTER (CLASS_NAME (cat)), 2748 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat))); 2749 class_methods = generate_v2_dispatch_table (CLASS_CLS_METHODS (cat), buf, 2750 meta_catc_meth); 2751 } 2752 2753 initlist = build_v2_category_initializer (TREE_TYPE (cat_decl), 2754 cat_name_expr, class_name_expr, 2755 inst_methods, class_methods, 2756 protocol_decl, props, loc); 2757 2758 finish_var_decl (cat_decl, initlist); 2759 impent->class_decl = cat_decl; 2760 2761 /* Add to list of pointers in __category_list section. */ 2762 objc_v2_add_to_category_list (cat_decl); 2763 if (has_load_impl (CLASS_CLS_METHODS (impent->imp_context))) 2764 objc_v2_add_to_nonlazy_category_list (cat_decl); 2765 } 2766 2767 /* This routine declares a variable to hold the offset for ivar 2768 FIELD_DECL. Variable name is .objc_ivar.ClassName.IvarName. */ 2769 2770 typedef struct GTY(()) ivarref_entry 2771 { 2772 tree decl; 2773 tree offset; 2774 } ivarref_entry; 2775 2776 static GTY (()) vec<ivarref_entry, va_gc> *ivar_offset_refs; 2777 2778 static tree 2779 ivar_offset_ref (tree class_name, tree field_decl) 2780 { 2781 tree decl, field_decl_id; 2782 ivarref_entry e; 2783 bool global_var; 2784 char buf[512]; 2785 2786 create_ivar_offset_name (buf, class_name, field_decl); 2787 field_decl_id = get_identifier (buf); 2788 2789 if (ivar_offset_refs) 2790 { 2791 int count; 2792 ivarref_entry *ref; 2793 FOR_EACH_VEC_ELT (*ivar_offset_refs, count, ref) 2794 if (DECL_NAME (ref->decl) == field_decl_id) 2795 return ref->decl; 2796 } 2797 else 2798 /* Somewhat arbitrary initial provision. */ 2799 vec_alloc (ivar_offset_refs, 32); 2800 2801 /* We come here if we don't find a match or at the start. */ 2802 global_var = (TREE_PUBLIC (field_decl) || TREE_PROTECTED (field_decl)); 2803 if (global_var) 2804 decl = create_global_decl (TREE_TYPE (size_zero_node), buf); 2805 else 2806 decl = create_hidden_decl (TREE_TYPE (size_zero_node), buf); 2807 2808 /* Make sure it ends up in an ObjC section. */ 2809 OBJCMETA (decl, objc_meta, meta_base); 2810 2811 e.decl = decl; 2812 e.offset = byte_position (field_decl); 2813 vec_safe_push (ivar_offset_refs, e); 2814 return decl; 2815 } 2816 2817 /* This routine builds initializer-list needed to initialize 'struct 2818 ivar_t list[count] of 'struct ivar_list_t' meta data. TYPE is 2819 'struct ivar_t' and FIELD_DECL is list of ivars for the target 2820 class. */ 2821 2822 static tree 2823 build_v2_ivar_list_initializer (tree class_name, tree type, tree field_decl) 2824 { 2825 vec<constructor_elt, va_gc> *inits = NULL; 2826 2827 do 2828 { 2829 vec<constructor_elt, va_gc> *ivar = NULL; 2830 int val; 2831 tree id; 2832 2833 /* Unnamed bitfields are ignored. */ 2834 if (!DECL_NAME (field_decl)) 2835 { 2836 field_decl = DECL_CHAIN (field_decl); 2837 continue; 2838 } 2839 2840 /* Set offset. */ 2841 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, 2842 build_unary_op (input_location, 2843 ADDR_EXPR, 2844 ivar_offset_ref (class_name, 2845 field_decl), 0)); 2846 2847 /* Set name. */ 2848 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, 2849 add_objc_string (DECL_NAME (field_decl), 2850 meth_var_names)); 2851 2852 /* Set type. */ 2853 id = add_objc_string (encode_field_decl (field_decl), 2854 meth_var_types); 2855 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id); 2856 2857 /* Set alignment. */ 2858 val = DECL_ALIGN_UNIT (field_decl); 2859 val = exact_log2 (val); 2860 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, 2861 build_int_cst (integer_type_node, val)); 2862 2863 /* Set size. */ 2864 val = TREE_INT_CST_LOW (DECL_SIZE_UNIT (field_decl)); 2865 CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, 2866 build_int_cst (integer_type_node, val)); 2867 2868 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2869 objc_build_constructor (type, ivar)); 2870 2871 do 2872 field_decl = DECL_CHAIN (field_decl); 2873 while (field_decl && TREE_CODE (field_decl) != FIELD_DECL); 2874 } 2875 while (field_decl); 2876 2877 return objc_build_constructor (build_array_type (type, 0), inits); 2878 } 2879 2880 /* 2881 struct ivar_list_t 2882 { 2883 uint32 entsize; 2884 uint32 count; 2885 struct iver_t list[count]; 2886 }; 2887 */ 2888 2889 static tree 2890 build_v2_ivar_list_t_template (tree list_type, int size) 2891 { 2892 tree objc_ivar_list_record; 2893 tree decls, *chain = NULL; 2894 2895 /* Anonymous. */ 2896 objc_ivar_list_record = objc_start_struct (NULL_TREE); 2897 2898 /* uint32 entsize; */ 2899 decls = add_field_decl (integer_type_node, "entsize", &chain); 2900 2901 /* uint32 count; */ 2902 add_field_decl (integer_type_node, "count", &chain); 2903 2904 /* struct objc_ivar ivar_list[]; */ 2905 add_field_decl (build_sized_array_type (list_type, size), 2906 "list", &chain); 2907 2908 objc_finish_struct (objc_ivar_list_record, decls); 2909 return objc_ivar_list_record; 2910 } 2911 2912 /* This routine declares a static variable of type 'struct 2913 ivar_list_t' and initializes it. chain is the source of the data, 2914 name is the name for the var. attr is the meta-data section tag 2915 attribute. templ is the implementation template for the class. */ 2916 2917 static tree 2918 generate_v2_ivars_list (tree chain, const char *name, tree attr, tree templ) 2919 { 2920 tree decl, initlist, ivar_list_template; 2921 vec<constructor_elt, va_gc> *inits = NULL; 2922 int size, ivar_t_size; 2923 2924 if (!chain || !name || !(size = ivar_list_length (chain))) 2925 return NULL_TREE; 2926 2927 generating_instance_variables = 1; 2928 ivar_list_template = build_v2_ivar_list_t_template (objc_v2_ivar_template, 2929 size); 2930 2931 initlist = build_v2_ivar_list_initializer (CLASS_NAME (templ), 2932 objc_v2_ivar_template, chain); 2933 ivar_t_size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_ivar_template)); 2934 2935 decl = start_var_decl (ivar_list_template, name); 2936 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2937 build_int_cst (integer_type_node, ivar_t_size)); 2938 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, 2939 build_int_cst (integer_type_node, size)); 2940 CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist); 2941 OBJCMETA (decl, objc_meta, attr); 2942 finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), inits)); 2943 generating_instance_variables = 0; 2944 return decl; 2945 } 2946 2947 /* Routine to build initializer list to initialize objects of type 2948 struct class_t; */ 2949 2950 static tree 2951 build_v2_class_t_initializer (tree type, tree isa, tree superclass, 2952 tree ro, tree cache, tree vtable) 2953 { 2954 vec<constructor_elt, va_gc> *initlist = NULL; 2955 2956 /* isa */ 2957 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, isa); 2958 2959 /* superclass */ 2960 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, superclass); 2961 2962 /* cache */ 2963 if (cache) 2964 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, cache); 2965 else 2966 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, null_pointer_node); 2967 2968 /* vtable */ 2969 if (vtable) 2970 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, vtable); 2971 else 2972 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, null_pointer_node); 2973 2974 /* ro */ 2975 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, ro); 2976 2977 return objc_build_constructor (type, initlist); 2978 } 2979 2980 /* Routine to build object of struct class_ro_t { ... }; */ 2981 2982 static tree 2983 build_v2_class_ro_t_initializer (tree type, tree name, 2984 unsigned int flags, unsigned int instanceStart, 2985 unsigned int instanceSize, 2986 tree ivarLayout, 2987 tree baseMethods, tree baseProtocols, 2988 tree ivars, tree property_list) 2989 { 2990 tree expr, unsigned_char_star, ltyp; 2991 location_t loc; 2992 vec<constructor_elt, va_gc> *initlist = NULL; 2993 2994 /* TODO: fish out the real location from somewhere. */ 2995 loc = UNKNOWN_LOCATION; 2996 2997 /* flags */ 2998 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, 2999 build_int_cst (integer_type_node, flags)); 3000 3001 /* instanceStart */ 3002 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, 3003 build_int_cst (integer_type_node, instanceStart)); 3004 3005 /* instanceSize */ 3006 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, 3007 build_int_cst (integer_type_node, instanceSize)); 3008 3009 /* This ABI is currently only used on m64 NeXT. We always 3010 explicitly declare the alignment padding. */ 3011 /* reserved, pads alignment. */ 3012 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, 3013 build_int_cst (integer_type_node, 0)); 3014 3015 /* ivarLayout */ 3016 unsigned_char_star = build_pointer_type (unsigned_char_type_node); 3017 if (ivarLayout) 3018 expr = ivarLayout; 3019 else 3020 expr = convert (unsigned_char_star, null_pointer_node); 3021 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); 3022 3023 /* name */ 3024 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, default_conversion (name)); 3025 3026 /* baseMethods */ 3027 ltyp = objc_method_list_ptr; 3028 if (baseMethods) 3029 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, baseMethods, 0)); 3030 else 3031 expr = convert (ltyp, null_pointer_node); 3032 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); 3033 3034 /* baseProtocols */ 3035 ltyp = build_pointer_type (xref_tag (RECORD_TYPE, 3036 get_identifier (UTAG_V2_PROTOCOL_LIST))); 3037 if (baseProtocols) 3038 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, baseProtocols, 0)); 3039 else 3040 expr = convert (ltyp, null_pointer_node); 3041 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); 3042 3043 /* ivars */ 3044 ltyp = objc_v2_ivar_list_ptr; 3045 if (ivars) 3046 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, ivars, 0)); 3047 else 3048 expr = convert (ltyp, null_pointer_node); 3049 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); 3050 3051 /* TODO: We don't yet have the weak/strong stuff... */ 3052 /* weakIvarLayout */ 3053 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, 3054 convert (unsigned_char_star, null_pointer_node)); 3055 3056 /* property list */ 3057 ltyp = objc_prop_list_ptr; 3058 if (property_list) 3059 expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0)); 3060 else 3061 expr = convert (ltyp, null_pointer_node); 3062 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, expr); 3063 return objc_build_constructor (type, initlist); 3064 } 3065 3066 static GTY (()) vec<ident_data_tuple, va_gc> *ehtype_list; 3067 3068 /* Record a name as needing a catcher. */ 3069 static void 3070 objc_v2_add_to_ehtype_list (tree name) 3071 { 3072 ident_data_tuple e; 3073 if (ehtype_list) 3074 { 3075 int count = 0; 3076 ident_data_tuple *ref; 3077 3078 FOR_EACH_VEC_ELT (*ehtype_list, count, ref) 3079 if (ref->ident == name) 3080 return; /* Already entered. */ 3081 } 3082 else 3083 /* Arbitrary initial count. */ 3084 vec_alloc (ehtype_list, 8); 3085 3086 /* Not found, or new list. */ 3087 e.ident = name; 3088 e.data = NULL_TREE; 3089 vec_safe_push (ehtype_list, e); 3090 } 3091 3092 static void 3093 generate_v2_class_structs (struct imp_entry *impent) 3094 { 3095 tree decl, name_expr, initlist, protocol_decl, metaclass_decl, class_decl; 3096 tree field, firstIvar, chain; 3097 tree class_superclass_expr, metaclass_superclass_expr, props; 3098 /* TODO: figure out how to compute this. */ 3099 tree ivarLayout = NULL_TREE; 3100 tree my_super_id = NULL_TREE, root_expr = NULL_TREE; 3101 tree inst_methods = NULL_TREE, class_methods = NULL_TREE; 3102 tree inst_ivars = NULL_TREE, class_ivars = NULL_TREE; 3103 location_t loc; 3104 char buf[BUFSIZE]; 3105 unsigned int instanceStart, instanceSize; 3106 unsigned int flags = 0x01; /* RO_META */ 3107 int cls_flags = impent->has_cxx_cdtors ? OBJC2_CLS_HAS_CXX_STRUCTORS 3108 : 0 ; 3109 3110 class_decl = impent->class_decl; 3111 metaclass_decl = impent->meta_decl; 3112 loc = DECL_SOURCE_LOCATION (class_decl); 3113 3114 DECL_EXTERNAL (class_decl) = DECL_EXTERNAL (metaclass_decl) = 0; 3115 TREE_PUBLIC (class_decl) = TREE_PUBLIC (metaclass_decl) = 1; 3116 #ifdef OBJCPLUS 3117 gcc_assert (!CP_DECL_CONTEXT (class_decl) || CP_DECL_CONTEXT (class_decl) == global_namespace); 3118 gcc_assert (!CP_DECL_CONTEXT (metaclass_decl) || CP_DECL_CONTEXT (metaclass_decl) == global_namespace); 3119 #endif 3120 3121 /* Generation of data for meta class. */ 3122 my_super_id = CLASS_SUPER_NAME (impent->imp_template); 3123 if (my_super_id) 3124 { 3125 /* Compute reference to root's name. For a meta class, "isa" is 3126 a reference to the root class name. */ 3127 tree my_root_id = my_super_id; 3128 tree my_root_int, interface; 3129 do 3130 { 3131 my_root_int = lookup_interface (my_root_id); 3132 3133 if (my_root_int && CLASS_SUPER_NAME (my_root_int)) 3134 my_root_id = CLASS_SUPER_NAME (my_root_int); 3135 else 3136 break; 3137 } 3138 while (1); 3139 3140 /* {extern} struct class_t OBJC_METACLASS_$_<my_root_int> 3141 create extern if not already declared. */ 3142 snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s", 3143 IDENTIFIER_POINTER (CLASS_NAME (my_root_int))); 3144 root_expr = create_extern_decl (objc_v2_class_template, buf); 3145 root_expr = build_fold_addr_expr (root_expr); 3146 3147 /* Install class `isa' and `super' pointers at runtime. */ 3148 interface = lookup_interface (my_super_id); 3149 gcc_assert (interface); 3150 /* Similarly, for OBJC_CLASS_$_<interface>... */ 3151 snprintf (buf, BUFSIZE, "OBJC_CLASS_$_%s", 3152 IDENTIFIER_POINTER (CLASS_NAME (interface))); 3153 class_superclass_expr = create_extern_decl (objc_v2_class_template, buf); 3154 class_superclass_expr = build_fold_addr_expr (class_superclass_expr); 3155 /* ... and for OBJC_METACLASS_$_<interface>. */ 3156 snprintf (buf, BUFSIZE, "OBJC_METACLASS_$_%s", 3157 IDENTIFIER_POINTER (CLASS_NAME (interface))); 3158 metaclass_superclass_expr = create_extern_decl (objc_v2_class_template, buf); 3159 metaclass_superclass_expr = build_fold_addr_expr (metaclass_superclass_expr); 3160 } 3161 else 3162 { 3163 /* Root class. */ 3164 root_expr = build_unary_op (loc, ADDR_EXPR, metaclass_decl, 0); 3165 metaclass_superclass_expr = build_unary_op (loc, ADDR_EXPR, class_decl, 0); 3166 class_superclass_expr = build_int_cst (NULL_TREE, 0); 3167 flags |= 0x02; /* RO_ROOT: it is also a root meta class. */ 3168 } 3169 3170 if (CLASS_PROTOCOL_LIST (impent->imp_template)) 3171 { 3172 generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template)); 3173 protocol_decl = generate_v2_protocol_list (impent->imp_template, 3174 impent->imp_context); 3175 } 3176 else 3177 protocol_decl = 0; 3178 3179 name_expr = add_objc_string (CLASS_NAME (impent->imp_template), 3180 class_names); 3181 3182 if (CLASS_CLS_METHODS (impent->imp_context)) 3183 { 3184 snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s", 3185 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 3186 class_methods = 3187 generate_v2_dispatch_table (CLASS_CLS_METHODS (impent->imp_context), 3188 buf, meta_clac_meth); 3189 } 3190 3191 instanceStart = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template)); 3192 3193 /* Currently there are no class ivars and generation of class 3194 variables for the root of the inheritance has been removed. It 3195 causes multiple defines if there are two root classes in the 3196 link, because each will define its own identically-named offset 3197 variable. */ 3198 3199 class_ivars = NULL_TREE; 3200 /* TODO: Add total size of class variables when implemented. */ 3201 instanceSize = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v2_class_template)); 3202 3203 /* So now build the META CLASS structs. */ 3204 /* static struct class_ro_t _OBJC_METACLASS_Foo = { ... }; */ 3205 3206 decl = start_var_decl (objc_v2_class_ro_template, 3207 newabi_append_ro (IDENTIFIER_POINTER 3208 (DECL_NAME (metaclass_decl)))); 3209 3210 /* TODO: ivarLayout needs t be built. */ 3211 initlist = 3212 build_v2_class_ro_t_initializer (TREE_TYPE (decl), name_expr, 3213 (flags | cls_flags), instanceStart, 3214 instanceSize, ivarLayout, 3215 class_methods, protocol_decl, 3216 class_ivars, NULL_TREE); 3217 /* The ROs sit in the default const section. */ 3218 OBJCMETA (decl, objc_meta, meta_base); 3219 finish_var_decl (decl, initlist); 3220 3221 /* static struct class_t _OBJC_METACLASS_Foo = { ... }; */ 3222 initlist = 3223 build_v2_class_t_initializer (TREE_TYPE (metaclass_decl), 3224 root_expr, 3225 metaclass_superclass_expr, 3226 build_fold_addr_expr (decl), 3227 build_fold_addr_expr (UOBJC_V2_CACHE_decl), 3228 build_fold_addr_expr (UOBJC_V2_VTABLE_decl)); 3229 /* The class section attributes are set when they are created. */ 3230 finish_var_decl (metaclass_decl, initlist); 3231 impent->meta_decl = metaclass_decl; 3232 3233 /* So now build the CLASS structs. */ 3234 3235 flags = 0x0; /* ... */ 3236 if (!my_super_id) 3237 flags |= 0x02; /* RO_ROOT: this is a root class */ 3238 3239 if (DECL_VISIBILITY (class_decl) == VISIBILITY_HIDDEN) 3240 flags |= 0x10; /* RO_HIDDEN, OBJC2_CLS_HIDDEN; */ 3241 3242 if (objc2_objc_exception_attr (impent->imp_template)) 3243 flags |= 0x20; /* RO_EXCEPTION */ 3244 3245 if (CLASS_NST_METHODS (impent->imp_context)) 3246 { 3247 snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s", 3248 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 3249 inst_methods = 3250 generate_v2_dispatch_table (CLASS_NST_METHODS (impent->imp_context), 3251 buf, meta_clai_meth); 3252 } 3253 3254 /* Sort out the ivars before we try to compute the class sizes. */ 3255 if ((chain = CLASS_IVARS (impent->imp_template))) 3256 { 3257 snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s", 3258 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context))); 3259 inst_ivars = generate_v2_ivars_list (chain, buf, meta_clai_vars, 3260 impent->imp_template); 3261 } 3262 3263 /* Compute instanceStart. */ 3264 gcc_assert (CLASS_STATIC_TEMPLATE (impent->imp_template)); 3265 field = TYPE_FIELDS (CLASS_STATIC_TEMPLATE (impent->imp_template)); 3266 if (my_super_id && field && TREE_CHAIN (field)) 3267 field = TREE_CHAIN (field); 3268 3269 firstIvar = field; 3270 3271 while (firstIvar && TREE_CODE (firstIvar) != FIELD_DECL) 3272 firstIvar = TREE_CHAIN (firstIvar); 3273 3274 gcc_assert (inst_ivars? (firstIvar != NULL_TREE): true); 3275 3276 /* Compute instanceSize. */ 3277 while (field && TREE_CHAIN (field) 3278 && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL) 3279 field = TREE_CHAIN (field); 3280 3281 if (field && TREE_CODE (field) == FIELD_DECL) 3282 instanceSize = int_byte_position (field) * BITS_PER_UNIT 3283 + tree_to_shwi (DECL_SIZE (field)); 3284 else 3285 instanceSize = 0; 3286 instanceSize /= BITS_PER_UNIT; 3287 3288 props = generate_v2_property_table (NULL_TREE, impent->imp_context); 3289 3290 /* If the class has no ivars, instanceStart should be set to the 3291 superclass's instanceSize. */ 3292 instanceStart = 3293 (inst_ivars != NULL_TREE) ? (unsigned) int_byte_position (firstIvar) 3294 : instanceSize; 3295 3296 /* static struct class_ro_t _OBJC_CLASS_Foo = { ... }; */ 3297 decl = start_var_decl (objc_v2_class_ro_template, 3298 newabi_append_ro (IDENTIFIER_POINTER 3299 (DECL_NAME (class_decl)))); 3300 3301 initlist = 3302 build_v2_class_ro_t_initializer (TREE_TYPE (decl), name_expr, 3303 (flags | cls_flags), instanceStart, 3304 instanceSize, ivarLayout, 3305 inst_methods, protocol_decl, 3306 inst_ivars, props); 3307 /* The ROs sit in the default const section. */ 3308 OBJCMETA (decl, objc_meta, meta_base); 3309 finish_var_decl (decl, initlist); 3310 3311 /* static struct class_t _OBJC_CLASS_Foo = { ... }; */ 3312 initlist = build_v2_class_t_initializer (TREE_TYPE (class_decl), 3313 build_fold_addr_expr (metaclass_decl), 3314 class_superclass_expr, 3315 build_fold_addr_expr (decl), 3316 build_fold_addr_expr (UOBJC_V2_CACHE_decl), 3317 build_fold_addr_expr (UOBJC_V2_VTABLE_decl)); 3318 3319 /* The class section attributes are set when they are created. */ 3320 finish_var_decl (class_decl, initlist); 3321 impent->class_decl = class_decl; 3322 3323 objc_v2_add_to_class_list (class_decl); 3324 if (has_load_impl (CLASS_CLS_METHODS (impent->imp_context))) 3325 objc_v2_add_to_nonlazy_class_list (class_decl); 3326 3327 if (flags & 0x20) /* RO_EXCEPTION */ 3328 objc_v2_add_to_ehtype_list (CLASS_NAME (impent->imp_template)); 3329 } 3330 3331 /* This routine outputs the (ivar_reference_offset, offset) 3332 tuples. */ 3333 3334 static void 3335 build_v2_ivar_offset_ref_table (void) 3336 { 3337 int count; 3338 ivarref_entry *ref; 3339 3340 if (!vec_safe_length (ivar_offset_refs)) 3341 return; 3342 3343 FOR_EACH_VEC_ELT (*ivar_offset_refs, count, ref) 3344 finish_var_decl (ref->decl, ref->offset); 3345 } 3346 3347 static void 3348 objc_generate_v2_next_metadata (void) 3349 { 3350 struct imp_entry *impent; 3351 3352 /* FIXME: Make sure that we generate no metadata if there is nothing 3353 to put into it. */ 3354 3355 gcc_assert (!objc_static_instances); /* Not for NeXT */ 3356 3357 build_metadata_templates (); 3358 3359 for (impent = imp_list; impent; impent = impent->next) 3360 { 3361 /* If -gen-decls is present, Dump the @interface of each class. 3362 TODO: Dump the classes in the order they were found, rather 3363 than in reverse order as we are doing now. */ 3364 if (flag_gen_declaration) 3365 dump_interface (gen_declaration_file, impent->imp_context); 3366 3367 /* all of the following reference the string pool... */ 3368 if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE) 3369 generate_v2_class_structs (impent); 3370 else 3371 generate_v2_category (impent); 3372 } 3373 3374 build_next_selector_translation_table (); 3375 build_v2_message_ref_translation_table (); 3376 3377 /* This will add "Protocol" to the class refs. */ 3378 generate_v2_protocols (); 3379 3380 build_v2_classrefs_table (); 3381 build_v2_super_classrefs_table (/*metaclass= */false); 3382 build_v2_super_classrefs_table (/*metaclass= */true); 3383 3384 build_v2_ivar_offset_ref_table (); 3385 3386 build_v2_protocol_list_translation_table (); 3387 build_v2_protocol_list_address_table (); 3388 3389 build_v2_address_table (class_list, "_OBJC_ClassList$", 3390 meta_label_classlist); 3391 build_v2_address_table (category_list, "_OBJC_CategoryList$", 3392 meta_label_categorylist); 3393 build_v2_address_table (nonlazy_class_list, "_OBJC_NonLazyClassList$", 3394 meta_label_nonlazy_classlist); 3395 build_v2_address_table (nonlazy_category_list, "_OBJC_NonLazyCategoryList$", 3396 meta_label_nonlazy_categorylist); 3397 3398 /* Generate catch objects for eh, if any are needed. */ 3399 build_v2_eh_catch_objects (); 3400 3401 /* Emit the string table last. */ 3402 generate_strings (); 3403 } 3404 3405 /* NOTE --- Output NeXT V2 Exceptions --- */ 3406 3407 static GTY(()) tree objc_v2_ehtype_template; 3408 static GTY(()) tree next_v2_ehvtable_decl; 3409 static GTY(()) tree next_v2_EHTYPE_id_decl; 3410 3411 static void 3412 build_v2_ehtype_template (void) 3413 { 3414 tree decls, *chain = NULL; 3415 objc_v2_ehtype_template = objc_start_struct (get_identifier (UTAG_V2_EH_TYPE)); 3416 3417 /* void *_objc_ehtype_vtable; */ 3418 decls = add_field_decl (ptr_type_node, "_objc_ehtype_vtable_ptr", &chain); 3419 3420 /* const char *className; */ 3421 add_field_decl (string_type_node, "className", &chain); 3422 3423 /* struct class_t *const cls; */ 3424 add_field_decl (build_pointer_type (objc_v2_class_template), "cls", &chain); 3425 3426 objc_finish_struct (objc_v2_ehtype_template, decls); 3427 } 3428 3429 /* Template for the Objective-C family typeinfo type for ABI=2. This 3430 starts off the same as the gxx/cxx eh typeinfo. 3431 3432 struct _objc_ehtype_t 3433 { 3434 void *_objc_ehtype_vtable_ptr; - as per c++ 3435 const char *className; - as per c++ 3436 struct class_t *const cls; 3437 } 3438 */ 3439 3440 /* This routine builds initializer list for object of type struct _objc_ehtype_t. 3441 */ 3442 3443 static tree 3444 objc2_build_ehtype_initializer (tree name, tree cls) 3445 { 3446 vec<constructor_elt, va_gc> *initlist = NULL; 3447 tree addr, offs; 3448 3449 /* This is done the same way as c++, missing the two first entries 3450 in the parent vtable. NOTE: there is a fix-me in the Apple/NeXT 3451 runtime source about this so, perhaps, this will change at some 3452 point. */ 3453 /* _objc_ehtype_vtable + 2*sizeof(void*) */ 3454 if (!next_v2_ehvtable_decl) 3455 { 3456 next_v2_ehvtable_decl = 3457 start_var_decl (ptr_type_node, TAG_NEXT_EHVTABLE_NAME); 3458 TREE_STATIC (next_v2_ehvtable_decl) = 0; 3459 DECL_EXTERNAL (next_v2_ehvtable_decl) = 1; 3460 TREE_PUBLIC (next_v2_ehvtable_decl) = 1; 3461 } 3462 addr = build_fold_addr_expr_with_type (next_v2_ehvtable_decl, ptr_type_node); 3463 offs = size_int (2 * int_cst_value (TYPE_SIZE_UNIT (ptr_type_node))); 3464 addr = fold_build_pointer_plus (addr, offs); 3465 3466 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, addr); 3467 3468 /* className */ 3469 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, name); 3470 3471 /* cls */ 3472 CONSTRUCTOR_APPEND_ELT (initlist, NULL_TREE, cls); 3473 3474 return objc_build_constructor (objc_v2_ehtype_template, initlist); 3475 } 3476 3477 static tree 3478 build_ehtype (tree name, const char *eh_name, bool weak) 3479 { 3480 tree name_expr, class_name_expr, ehtype_decl, inits; 3481 3482 name_expr = add_objc_string (name, class_names); 3483 /* Extern ref. for the class. ??? Maybe we can look this up 3484 somewhere. */ 3485 class_name_expr = 3486 create_extern_decl (objc_v2_class_template, 3487 objc_build_internal_classname (name, false)); 3488 class_name_expr = build_fold_addr_expr (class_name_expr); 3489 ehtype_decl = create_global_decl (objc_v2_ehtype_template, eh_name); 3490 if (weak) 3491 DECL_WEAK (ehtype_decl) = 1; 3492 inits = objc2_build_ehtype_initializer (name_expr, class_name_expr); 3493 OBJCMETA (ehtype_decl, objc_meta, meta_ehtype); 3494 finish_var_decl (ehtype_decl, inits); 3495 return ehtype_decl; 3496 } 3497 3498 /* This routine returns TRUE if CLS or any of its super classes has 3499 __attribute__ ((objc_exception)). */ 3500 3501 static bool 3502 objc2_objc_exception_attr (tree cls) 3503 { 3504 while (cls) 3505 { 3506 if (CLASS_HAS_EXCEPTION_ATTR (cls)) 3507 return true; 3508 cls = lookup_interface (CLASS_SUPER_NAME (cls)); 3509 } 3510 3511 return false; 3512 } 3513 3514 static bool 3515 is_implemented (tree name) 3516 { 3517 struct imp_entry *t; 3518 for (t = imp_list; t; t = t->next) 3519 if (TREE_CODE (t->imp_context) == CLASS_IMPLEMENTATION_TYPE 3520 && CLASS_NAME (t->imp_template) == name) 3521 return true; 3522 3523 return false; 3524 } 3525 3526 /* We will build catch objects: 3527 for any type implemented here. 3528 for any type used in a catch that has no exception attribute. */ 3529 static void build_v2_eh_catch_objects (void) 3530 { 3531 int count=0; 3532 ident_data_tuple *ref; 3533 3534 if (!vec_safe_length (ehtype_list)) 3535 return; 3536 3537 FOR_EACH_VEC_ELT (*ehtype_list, count, ref) 3538 { 3539 char buf[BUFSIZE]; 3540 bool impl = is_implemented (ref->ident); 3541 bool excpt = objc2_objc_exception_attr (lookup_interface (ref->ident)); 3542 snprintf (buf, BUFSIZE, "OBJC_EHTYPE_$_%s", IDENTIFIER_POINTER (ref->ident)); 3543 if (!impl && excpt) 3544 /* The User says this class has a catcher already. */ 3545 ref->data = create_extern_decl (objc_v2_ehtype_template, buf); 3546 else 3547 /* Create a catcher, weak if it wasn't marked. */ 3548 ref->data = build_ehtype (ref->ident, buf, !excpt); 3549 } 3550 } 3551 3552 static tree 3553 lookup_ehtype_ref (tree id) 3554 { 3555 int count=0; 3556 ident_data_tuple *ref; 3557 3558 if (!vec_safe_length (ehtype_list)) 3559 return NULL_TREE; 3560 3561 FOR_EACH_VEC_ELT (*ehtype_list, count, ref) 3562 if (ref->ident == id) 3563 return ref->data; 3564 return NULL_TREE; 3565 } 3566 3567 /* This hook, called via lang_eh_runtime_type, generates a runtime 3568 object which is either the address of the 'OBJC_EHTYPE_$_class' 3569 object or address of external OBJC_EHTYPE_id object. */ 3570 static tree 3571 next_runtime_02_eh_type (tree type) 3572 { 3573 tree t; 3574 3575 if (type == error_mark_node 3576 /*|| errorcount || sorrycount*/) 3577 goto err_mark_in; 3578 3579 if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type))) 3580 { 3581 if (!next_v2_EHTYPE_id_decl) 3582 { 3583 /* This is provided by the Apple/NeXT libobjc.dylib so we 3584 need only to reference it. */ 3585 next_v2_EHTYPE_id_decl = 3586 start_var_decl (objc_v2_ehtype_template, "OBJC_EHTYPE_id"); 3587 DECL_EXTERNAL (next_v2_EHTYPE_id_decl) = 1; 3588 TREE_PUBLIC (next_v2_EHTYPE_id_decl) = 1; 3589 TREE_STATIC (next_v2_EHTYPE_id_decl) = 0; 3590 } 3591 return build_fold_addr_expr (next_v2_EHTYPE_id_decl); 3592 } 3593 3594 if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type))) 3595 { 3596 #ifdef OBJCPLUS 3597 /* This routine is also called for c++'s catch clause; in which 3598 case, we use c++'s typeinfo decl. */ 3599 return build_eh_type_type (type); 3600 #else 3601 error ("non-objective-c type '%T' cannot be caught", type); 3602 goto err_mark_in; 3603 #endif 3604 } 3605 else 3606 t = OBJC_TYPE_NAME (TREE_TYPE (type)); 3607 3608 /* We have to build a reference to the OBJC_EHTYPE_<Class>. */ 3609 t = lookup_ehtype_ref (t); 3610 if (!t) 3611 goto err_mark_in; 3612 3613 return build_fold_addr_expr (t); 3614 3615 err_mark_in: 3616 return error_mark_node; 3617 } 3618 3619 static GTY(()) tree objc_eh_personality_decl; 3620 3621 static tree 3622 objc_eh_personality (void) 3623 { 3624 if (!objc_eh_personality_decl) 3625 objc_eh_personality_decl = build_personality_function ("objc"); 3626 return objc_eh_personality_decl; 3627 } 3628 3629 /* NOTE --- interfaces --- */ 3630 3631 static tree 3632 build_throw_stmt (location_t loc, tree throw_expr, bool rethrown) 3633 { 3634 tree t; 3635 if (rethrown) 3636 /* We have a separate re-throw entry. */ 3637 t = build_function_call_vec (loc, vNULL, objc_rethrow_exception_decl, 3638 NULL, NULL); 3639 else 3640 { 3641 /* Throw like the others... */ 3642 vec<tree, va_gc> *parms; 3643 vec_alloc (parms, 1); 3644 parms->quick_push (throw_expr); 3645 t = build_function_call_vec (loc, vNULL, objc_exception_throw_decl, 3646 parms, 0); 3647 vec_free (parms); 3648 } 3649 return add_stmt (t); 3650 } 3651 3652 /* Build __builtin_eh_pointer. */ 3653 3654 static tree 3655 objc_build_exc_ptr (struct objc_try_context **x ATTRIBUTE_UNUSED) 3656 { 3657 tree t; 3658 t = builtin_decl_explicit (BUILT_IN_EH_POINTER); 3659 t = build_call_expr (t, 1, integer_zero_node); 3660 return fold_convert (objc_object_type, t); 3661 } 3662 3663 static tree begin_catch (struct objc_try_context **cur_try_context, tree type, 3664 tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED) 3665 { 3666 tree t; 3667 3668 /* Record the data for the catch in the try context so that we can 3669 finalize it later. Ellipsis is signalled by a NULL entry. */ 3670 if (ellipsis) 3671 t = build_stmt (input_location, CATCH_EXPR, NULL_TREE, compound); 3672 else 3673 t = build_stmt (input_location, CATCH_EXPR, type, compound); 3674 (*cur_try_context)->current_catch = t; 3675 3676 /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime. */ 3677 t = objc_build_exc_ptr (cur_try_context); 3678 t = convert (TREE_TYPE (decl), t); 3679 /* FIXME: location. */ 3680 if (type && type != error_mark_node) 3681 { 3682 t = build1(NOP_EXPR, ptr_type_node, t); 3683 t = build_function_call (input_location, objc2_begin_catch_decl, 3684 tree_cons (NULL_TREE, t, NULL_TREE)); 3685 3686 /* We might want to build a catch object for this (if it's not 3687 id). */ 3688 if (POINTER_TYPE_P (type) 3689 && !objc_is_object_id (TREE_TYPE (type)) 3690 && TYPED_OBJECT (TREE_TYPE (type))) 3691 objc_v2_add_to_ehtype_list (OBJC_TYPE_NAME (TREE_TYPE (type))); 3692 } 3693 return build2 (MODIFY_EXPR, void_type_node, decl, t); 3694 } 3695 3696 /* try { catch-body } finally { objc_end_catch (); } */ 3697 static void 3698 finish_catch (struct objc_try_context **cur_try_context, tree curr_catch) 3699 { 3700 struct objc_try_context *ct; 3701 tree try_exp, func, *l, t ; 3702 location_t loc = (*cur_try_context)->try_locus; 3703 3704 if (!curr_catch || curr_catch == error_mark_node) 3705 return; 3706 3707 t = CATCH_BODY (curr_catch); 3708 if (TREE_CODE (t) == BIND_EXPR) 3709 { 3710 /* Usual case of @catch (objc-expr). */ 3711 objc_begin_try_stmt (loc, BIND_EXPR_BODY (t)); 3712 BIND_EXPR_BODY (t) = NULL_TREE; 3713 l = &BIND_EXPR_BODY (t); 3714 } 3715 else 3716 { 3717 /* NULL entry, meaning @catch (...). */ 3718 objc_begin_try_stmt (loc, t); 3719 CATCH_BODY (curr_catch) = NULL_TREE; 3720 l = &CATCH_BODY (curr_catch); 3721 } 3722 3723 /* Pick up the new context we made in begin_try above... */ 3724 ct = *cur_try_context; 3725 func = build_function_call_vec (loc, vNULL, objc2_end_catch_decl, NULL, 3726 NULL); 3727 append_to_statement_list (func, &ct->finally_body); 3728 try_exp = build_stmt (loc, TRY_FINALLY_EXPR, ct->try_body, ct->finally_body); 3729 *cur_try_context = ct->outer; 3730 free (ct); 3731 append_to_statement_list (try_exp, l); 3732 append_to_statement_list (curr_catch, &((*cur_try_context)->catch_list)); 3733 } 3734 3735 static tree 3736 finish_try_stmt (struct objc_try_context **cur_try_context) 3737 { 3738 struct objc_try_context *c = *cur_try_context; 3739 tree stmt = c->try_body; 3740 if (c->catch_list) 3741 stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list); 3742 if (c->finally_body) 3743 stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body); 3744 return stmt; 3745 } 3746 3747 #include "gt-objc-objc-next-runtime-abi-02.h" 3748