gcc/objc/objc-act.c

   1 /* Implement classes and message passing for Objective C.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
   4    Contributed by Steve Naroff.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 3, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22
  23 /* Purpose: This module implements the Objective-C 4.0 language.
  24
  25    compatibility issues (with the Stepstone translator):
  26
  27    - does not recognize the following 3.3 constructs.
  28      @requires, @classes, @messages, = (...)
  29    - methods with variable arguments must conform to ANSI standard.
  30    - tagged structure definitions that appear in BOTH the interface
  31      and implementation are not allowed.
  32    - public/private: all instance variables are public within the
  33      context of the implementation...I consider this to be a bug in
  34      the translator.
  35    - statically allocated objects are not supported. the user will
  36      receive an error if this service is requested.
  37
  38    code generation `options':
  39
  40    */
  41
  42 #include "config.h"
  43 #include "system.h"
  44 #include "coretypes.h"
  45 #include "tm.h"
  46 #include "tree.h"
  47 #include "rtl.h"
  48 #include "tm_p.h"
  49 #include "expr.h"
  50
  51 #ifdef OBJCPLUS
  52 #include "cp-tree.h"
  53 #else
  54 #include "c-tree.h"
  55 #include "c-lang.h"
  56 #endif
  57
  58 #include "c-common.h"
  59 #include "c-pragma.h"
  60 #include "flags.h"
  61 #include "langhooks.h"
  62 #include "objc-act.h"
  63 #include "input.h"
  64 #include "except.h"
  65 #include "function.h"
  66 #include "output.h"
  67 #include "toplev.h"
  68 #include "ggc.h"
  69 #include "varray.h"
  70 #include "debug.h"
  71 #include "target.h"
  72 #include "diagnostic.h"
  73 #include "intl.h"
  74 #include "cgraph.h"
  75 #include "tree-iterator.h"
  76 #include "libfuncs.h"
  77 #include "hashtab.h"
  78 #include "langhooks-def.h"
  79
  80 #define OBJC_VOID_AT_END        void_list_node
  81
  82 static unsigned int should_call_super_dealloc = 0;
  83
  84 /* When building Objective-C++, we need in_late_binary_op.  */
  85 #ifdef OBJCPLUS
  86 bool in_late_binary_op = false;
  87 #endif  /* OBJCPLUS */
  88
  89 /* When building Objective-C++, we are not linking against the C front-end
  90    and so need to replicate the C tree-construction functions in some way.  */
  91 #ifdef OBJCPLUS
  92 #define OBJCP_REMAP_FUNCTIONS
  93 #include "objcp-decl.h"
  94 #endif  /* OBJCPLUS */
  95
  96 /* This is the default way of generating a method name.  */
  97 /* I am not sure it is really correct.
  98    Perhaps there's a danger that it will make name conflicts
  99    if method names contain underscores. -- rms.  */
 100 #ifndef OBJC_GEN_METHOD_LABEL
 101 #define OBJC_GEN_METHOD_LABEL(BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME, NUM) \
 102   do {                                      \
 103     char *temp;                             \
 104     sprintf ((BUF), "_%s_%s_%s_%s",         \
 105              ((IS_INST) ? "i" : "c"),       \
 106              (CLASS_NAME),                  \
 107              ((CAT_NAME)? (CAT_NAME) : ""), \
 108              (SEL_NAME));                   \
 109     for (temp = (BUF); *temp; temp++)       \
 110       if (*temp == ':') *temp = '_';        \
 111   } while (0)
 112 #endif
 113
 114 /* These need specifying.  */
 115 #ifndef OBJC_FORWARDING_STACK_OFFSET
 116 #define OBJC_FORWARDING_STACK_OFFSET 0
 117 #endif
 118
 119 #ifndef OBJC_FORWARDING_MIN_OFFSET
 120 #define OBJC_FORWARDING_MIN_OFFSET 0
 121 #endif
 122 \f
 123 /* Set up for use of obstacks.  */
 124
 125 #include "obstack.h"
 126
 127 /* This obstack is used to accumulate the encoding of a data type.  */
 128 static struct obstack util_obstack;
 129
 130 /* This points to the beginning of obstack contents, so we can free
 131    the whole contents.  */
 132 char *util_firstobj;
 133
 134 /* The version identifies which language generation and runtime
 135    the module (file) was compiled for, and is recorded in the
 136    module descriptor.  */
 137
 138 #define OBJC_VERSION    (flag_next_runtime ? 6 : 8)
 139 #define PROTOCOL_VERSION 2
 140
 141 /* (Decide if these can ever be validly changed.) */
 142 #define OBJC_ENCODE_INLINE_DEFS         0
 143 #define OBJC_ENCODE_DONT_INLINE_DEFS    1
 144
 145 /*** Private Interface (procedures) ***/
 146
 147 /* Used by compile_file.  */
 148
 149 static void init_objc (void);
 150 static void finish_objc (void);
 151
 152 /* Code generation.  */
 153
 154 static tree objc_build_constructor (tree, tree);
 155 static tree build_objc_method_call (location_t, int, tree, tree, tree, tree);
 156 static tree get_proto_encoding (tree);
 157 static tree lookup_interface (tree);
 158 static tree objc_add_static_instance (tree, tree);
 159
 160 static tree start_class (enum tree_code, tree, tree, tree);
 161 static tree continue_class (tree);
 162 static void finish_class (tree);
 163 static void start_method_def (tree);
 164 #ifdef OBJCPLUS
 165 static void objc_start_function (tree, tree, tree, tree);
 166 #else
 167 static void objc_start_function (tree, tree, tree, struct c_arg_info *);
 168 #endif
 169 static tree start_protocol (enum tree_code, tree, tree);
 170 static tree build_method_decl (enum tree_code, tree, tree, tree, bool);
 171 static tree objc_add_method (tree, tree, int);
 172 static tree add_instance_variable (tree, int, tree);
 173 static tree build_ivar_reference (tree);
 174 static tree is_ivar (tree, tree);
 175
 176 static void build_objc_exception_stuff (void);
 177 static void build_next_objc_exception_stuff (void);
 178
 179 /* We only need the following for ObjC; ObjC++ will use C++'s definition
 180    of DERIVED_FROM_P.  */
 181 #ifndef OBJCPLUS
 182 static bool objc_derived_from_p (tree, tree);
 183 #define DERIVED_FROM_P(PARENT, CHILD) objc_derived_from_p (PARENT, CHILD)
 184 #endif
 185 static void objc_xref_basetypes (tree, tree);
 186
 187 static void build_class_template (void);
 188 static void build_selector_template (void);
 189 static void build_category_template (void);
 190 static void build_super_template (void);
 191 static tree build_protocol_initializer (tree, tree, tree, tree, tree);
 192 static tree get_class_ivars (tree, bool);
 193 static tree generate_protocol_list (tree);
 194 static void build_protocol_reference (tree);
 195
 196 #ifdef OBJCPLUS
 197 static void objc_generate_cxx_cdtors (void);
 198 #endif
 199
 200 static const char *synth_id_with_class_suffix (const char *, tree);
 201
 202 /* Hash tables to manage the global pool of method prototypes.  */
 203
 204 hash *nst_method_hash_list = 0;
 205 hash *cls_method_hash_list = 0;
 206
 207 static hash hash_lookup (hash *, tree);
 208 static tree lookup_method (tree, tree);
 209 static tree lookup_method_static (tree, tree, int);
 210
 211 enum string_section
 212 {
 213   class_names,          /* class, category, protocol, module names */
 214   meth_var_names,       /* method and variable names */
 215   meth_var_types        /* method and variable type descriptors */
 216 };
 217
 218 static tree add_objc_string (tree, enum string_section);
 219 static tree build_objc_string_decl (enum string_section);
 220 static void build_selector_table_decl (void);
 221
 222 /* Protocol additions.  */
 223
 224 static tree lookup_protocol (tree);
 225 static tree lookup_and_install_protocols (tree);
 226
 227 /* Type encoding.  */
 228
 229 static void encode_type_qualifiers (tree);
 230 static void encode_type (tree, int, int);
 231 static void encode_field_decl (tree, int, int);
 232
 233 #ifdef OBJCPLUS
 234 static void really_start_method (tree, tree);
 235 #else
 236 static void really_start_method (tree, struct c_arg_info *);
 237 #endif
 238 static int comp_proto_with_proto (tree, tree, int);
 239 static void objc_push_parm (tree);
 240 #ifdef OBJCPLUS
 241 static tree objc_get_parm_info (int);
 242 #else
 243 static struct c_arg_info *objc_get_parm_info (int);
 244 #endif
 245
 246 /* Utilities for debugging and error diagnostics.  */
 247
 248 static char *gen_type_name (tree);
 249 static char *gen_type_name_0 (tree);
 250 static char *gen_method_decl (tree);
 251 static char *gen_declaration (tree);
 252
 253 /* Everything else.  */
 254
 255 static tree create_field_decl (tree, const char *);
 256 static void add_class_reference (tree);
 257 static void build_protocol_template (void);
 258 static tree encode_method_prototype (tree);
 259 static void generate_classref_translation_entry (tree);
 260 static void handle_class_ref (tree);
 261 static void generate_struct_by_value_array (void)
 262      ATTRIBUTE_NORETURN;
 263 static void mark_referenced_methods (void);
 264 static void generate_objc_image_info (void);
 265
 266 /*** Private Interface (data) ***/
 267
 268 /* Reserved tag definitions.  */
 269
 270 #define OBJECT_TYPEDEF_NAME             "id"
 271 #define CLASS_TYPEDEF_NAME              "Class"
 272
 273 #define TAG_OBJECT                      "objc_object"
 274 #define TAG_CLASS                       "objc_class"
 275 #define TAG_SUPER                       "objc_super"
 276 #define TAG_SELECTOR                    "objc_selector"
 277
 278 #define UTAG_CLASS                      "_objc_class"
 279 #define UTAG_IVAR                       "_objc_ivar"
 280 #define UTAG_IVAR_LIST                  "_objc_ivar_list"
 281 #define UTAG_METHOD                     "_objc_method"
 282 #define UTAG_METHOD_LIST                "_objc_method_list"
 283 #define UTAG_CATEGORY                   "_objc_category"
 284 #define UTAG_MODULE                     "_objc_module"
 285 #define UTAG_SYMTAB                     "_objc_symtab"
 286 #define UTAG_SUPER                      "_objc_super"
 287 #define UTAG_SELECTOR                   "_objc_selector"
 288
 289 #define UTAG_PROTOCOL                   "_objc_protocol"
 290 #define UTAG_METHOD_PROTOTYPE           "_objc_method_prototype"
 291 #define UTAG_METHOD_PROTOTYPE_LIST      "_objc__method_prototype_list"
 292
 293 /* Note that the string object global name is only needed for the
 294    NeXT runtime.  */
 295 #define STRING_OBJECT_GLOBAL_FORMAT     "_%sClassReference"
 296
 297 #define PROTOCOL_OBJECT_CLASS_NAME      "Protocol"
 298
 299 static const char *TAG_GETCLASS;
 300 static const char *TAG_GETMETACLASS;
 301 static const char *TAG_MSGSEND;
 302 static const char *TAG_MSGSENDSUPER;
 303 /* The NeXT Objective-C messenger may have two extra entry points, for use
 304    when returning a structure. */
 305 static const char *TAG_MSGSEND_STRET;
 306 static const char *TAG_MSGSENDSUPER_STRET;
 307 static const char *default_constant_string_class_name;
 308
 309 /* Runtime metadata flags.  */
 310 #define CLS_FACTORY                     0x0001L
 311 #define CLS_META                        0x0002L
 312 #define CLS_HAS_CXX_STRUCTORS           0x2000L
 313
 314 #define OBJC_MODIFIER_STATIC            0x00000001
 315 #define OBJC_MODIFIER_FINAL             0x00000002
 316 #define OBJC_MODIFIER_PUBLIC            0x00000004
 317 #define OBJC_MODIFIER_PRIVATE           0x00000008
 318 #define OBJC_MODIFIER_PROTECTED         0x00000010
 319 #define OBJC_MODIFIER_NATIVE            0x00000020
 320 #define OBJC_MODIFIER_SYNCHRONIZED      0x00000040
 321 #define OBJC_MODIFIER_ABSTRACT          0x00000080
 322 #define OBJC_MODIFIER_VOLATILE          0x00000100
 323 #define OBJC_MODIFIER_TRANSIENT         0x00000200
 324 #define OBJC_MODIFIER_NONE_SPECIFIED    0x80000000
 325
 326 /* NeXT-specific tags.  */
 327
 328 #define TAG_MSGSEND_NONNIL              "objc_msgSendNonNil"
 329 #define TAG_MSGSEND_NONNIL_STRET        "objc_msgSendNonNil_stret"
 330 #define TAG_EXCEPTIONEXTRACT            "objc_exception_extract"
 331 #define TAG_EXCEPTIONTRYENTER           "objc_exception_try_enter"
 332 #define TAG_EXCEPTIONTRYEXIT            "objc_exception_try_exit"
 333 #define TAG_EXCEPTIONMATCH              "objc_exception_match"
 334 #define TAG_EXCEPTIONTHROW              "objc_exception_throw"
 335 #define TAG_SYNCENTER                   "objc_sync_enter"
 336 #define TAG_SYNCEXIT                    "objc_sync_exit"
 337 #define TAG_SETJMP                      "_setjmp"
 338 #define UTAG_EXCDATA                    "_objc_exception_data"
 339
 340 #define TAG_ASSIGNIVAR                  "objc_assign_ivar"
 341 #define TAG_ASSIGNGLOBAL                "objc_assign_global"
 342 #define TAG_ASSIGNSTRONGCAST            "objc_assign_strongCast"
 343
 344 /* Branch entry points.  All that matters here are the addresses;
 345    functions with these names do not really exist in libobjc.  */
 346
 347 #define TAG_MSGSEND_FAST                "objc_msgSend_Fast"
 348 #define TAG_ASSIGNIVAR_FAST             "objc_assign_ivar_Fast"
 349
 350 #define TAG_CXX_CONSTRUCT               ".cxx_construct"
 351 #define TAG_CXX_DESTRUCT                ".cxx_destruct"
 352
 353 /* GNU-specific tags.  */
 354
 355 #define TAG_EXECCLASS                   "__objc_exec_class"
 356 #define TAG_GNUINIT                     "__objc_gnu_init"
 357
 358 /* Flags for lookup_method_static().  */
 359 #define OBJC_LOOKUP_CLASS       1       /* Look for class methods.  */
 360 #define OBJC_LOOKUP_NO_SUPER    2       /* Do not examine superclasses.  */
 361
 362 /* The OCTI_... enumeration itself is in objc/objc-act.h.  */
 363 tree objc_global_trees[OCTI_MAX];
 364
 365 static void handle_impent (struct imp_entry *);
 366
 367 struct imp_entry *imp_list = 0;
 368 int imp_count = 0;      /* `@implementation' */
 369 int cat_count = 0;      /* `@category' */
 370
 371 enum tree_code objc_inherit_code;
 372 int objc_public_flag;
 373
 374 /* Use to generate method labels.  */
 375 static int method_slot = 0;
 376
 377 #define BUFSIZE         1024
 378
 379 static char *errbuf;    /* Buffer for error diagnostics */
 380
 381 /* Data imported from tree.c.  */
 382
 383 extern enum debug_info_type write_symbols;
 384
 385 /* Data imported from toplev.c.  */
 386
 387 extern const char *dump_base_name;
 388 \f
 389 static int flag_typed_selectors;
 390
 391 /* Store all constructed constant strings in a hash table so that
 392    they get uniqued properly.  */
 393
 394 struct GTY(()) string_descriptor {
 395   /* The literal argument .  */
 396   tree literal;
 397
 398   /* The resulting constant string.  */
 399   tree constructor;
 400 };
 401
 402 static GTY((param_is (struct string_descriptor))) htab_t string_htab;
 403
 404 /* Store the EH-volatilized types in a hash table, for easy retrieval.  */
 405 struct GTY(()) volatilized_type {
 406   tree type;
 407 };
 408
 409 static GTY((param_is (struct volatilized_type))) htab_t volatilized_htab;
 410
 411 FILE *gen_declaration_file;
 412
 413 /* Tells "encode_pointer/encode_aggregate" whether we are generating
 414    type descriptors for instance variables (as opposed to methods).
 415    Type descriptors for instance variables contain more information
 416    than methods (for static typing and embedded structures).  */
 417
 418 static int generating_instance_variables = 0;
 419
 420 /* For building an objc struct.  These may not be used when this file
 421    is compiled as part of obj-c++.  */
 422
 423 static bool objc_building_struct;
 424 static struct c_struct_parse_info *objc_struct_info ATTRIBUTE_UNUSED;
 425
 426 /* Start building a struct for objc.  */
 427
 428 static tree
 429 objc_start_struct (tree name)
 430 {
 431   gcc_assert (!objc_building_struct);
 432   objc_building_struct = true;
 433   return start_struct (input_location, RECORD_TYPE, name, &objc_struct_info);
 434 }
 435
 436 /* Finish building a struct for objc.  */
 437
 438 static tree
 439 objc_finish_struct (tree type, tree fieldlist)
 440 {
 441   gcc_assert (objc_building_struct);
 442   objc_building_struct = false;
 443   return finish_struct (input_location, type, fieldlist, NULL_TREE,
 444                         objc_struct_info);
 445 }
 446
 447 /* Some platforms pass small structures through registers versus
 448    through an invisible pointer.  Determine at what size structure is
 449    the transition point between the two possibilities.  */
 450
 451 static void
 452 generate_struct_by_value_array (void)
 453 {
 454   tree type;
 455   tree field_decl, field_decl_chain;
 456   int i, j;
 457   int aggregate_in_mem[32];
 458   int found = 0;
 459
 460   /* Presumably no platform passes 32 byte structures in a register.  */
 461   for (i = 1; i < 32; i++)
 462     {
 463       char buffer[5];
 464
 465       /* Create an unnamed struct that has `i' character components */
 466       type = objc_start_struct (NULL_TREE);
 467
 468       strcpy (buffer, "c1");
 469       field_decl = create_field_decl (char_type_node,
 470                                       buffer);
 471       field_decl_chain = field_decl;
 472
 473       for (j = 1; j < i; j++)
 474         {
 475           sprintf (buffer, "c%d", j + 1);
 476           field_decl = create_field_decl (char_type_node,
 477                                           buffer);
 478           chainon (field_decl_chain, field_decl);
 479         }
 480       objc_finish_struct (type, field_decl_chain);
 481
 482       aggregate_in_mem[i] = aggregate_value_p (type, 0);
 483       if (!aggregate_in_mem[i])
 484         found = 1;
 485     }
 486
 487   /* We found some structures that are returned in registers instead of memory
 488      so output the necessary data.  */
 489   if (found)
 490     {
 491       for (i = 31; i >= 0;  i--)
 492         if (!aggregate_in_mem[i])
 493           break;
 494       printf ("#define OBJC_MAX_STRUCT_BY_VALUE %d\n\n", i);
 495
 496       /* The first member of the structure is always 0 because we don't handle
 497          structures with 0 members */
 498       printf ("static int struct_forward_array[] = {\n  0");
 499
 500       for (j = 1; j <= i; j++)
 501         printf (", %d", aggregate_in_mem[j]);
 502       printf ("\n};\n");
 503     }
 504
 505   exit (0);
 506 }
 507
 508 bool
 509 objc_init (void)
 510 {
 511 #ifdef OBJCPLUS
 512   if (cxx_init () == false)
 513 #else
 514   if (c_objc_common_init () == false)
 515 #endif
 516     return false;
 517
 518   /* If gen_declaration desired, open the output file.  */
 519   if (flag_gen_declaration)
 520     {
 521       register char * const dumpname = concat (dump_base_name, ".decl", NULL);
 522       gen_declaration_file = fopen (dumpname, "w");
 523       if (gen_declaration_file == 0)
 524         fatal_error ("can't open %s: %m", dumpname);
 525       free (dumpname);
 526     }
 527
 528   if (flag_next_runtime)
 529     {
 530       TAG_GETCLASS = "objc_getClass";
 531       TAG_GETMETACLASS = "objc_getMetaClass";
 532       TAG_MSGSEND = "objc_msgSend";
 533       TAG_MSGSENDSUPER = "objc_msgSendSuper";
 534       TAG_MSGSEND_STRET = "objc_msgSend_stret";
 535       TAG_MSGSENDSUPER_STRET = "objc_msgSendSuper_stret";
 536       default_constant_string_class_name = "NSConstantString";
 537     }
 538   else
 539     {
 540       TAG_GETCLASS = "objc_get_class";
 541       TAG_GETMETACLASS = "objc_get_meta_class";
 542       TAG_MSGSEND = "objc_msg_lookup";
 543       TAG_MSGSENDSUPER = "objc_msg_lookup_super";
 544       /* GNU runtime does not provide special functions to support
 545          structure-returning methods.  */
 546       default_constant_string_class_name = "NXConstantString";
 547       flag_typed_selectors = 1;
 548     }
 549
 550   init_objc ();
 551
 552   if (print_struct_values && !flag_compare_debug)
 553     generate_struct_by_value_array ();
 554
 555   return true;
 556 }
 557
 558 void
 559 objc_finish_file (void)
 560 {
 561   mark_referenced_methods ();
 562
 563 #ifdef OBJCPLUS
 564   /* We need to instantiate templates _before_ we emit ObjC metadata;
 565      if we do not, some metadata (such as selectors) may go missing.  */
 566   at_eof = 1;
 567   instantiate_pending_templates (0);
 568 #endif
 569
 570   /* Finalize Objective-C runtime data.  No need to generate tables
 571      and code if only checking syntax, or if generating a PCH file.  */
 572   if (!flag_syntax_only && !pch_file)
 573     finish_objc ();
 574
 575   if (gen_declaration_file)
 576     fclose (gen_declaration_file);
 577 }
 578 \f
 579 /* Return the first occurrence of a method declaration corresponding
 580    to sel_name in rproto_list.  Search rproto_list recursively.
 581    If is_class is 0, search for instance methods, otherwise for class
 582    methods.  */
 583 static tree
 584 lookup_method_in_protocol_list (tree rproto_list, tree sel_name,
 585                                 int is_class)
 586 {
 587    tree rproto, p;
 588    tree fnd = 0;
 589
 590    for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
 591      {
 592         p = TREE_VALUE (rproto);
 593
 594         if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
 595           {
 596             if ((fnd = lookup_method (is_class
 597                                       ? PROTOCOL_CLS_METHODS (p)
 598                                       : PROTOCOL_NST_METHODS (p), sel_name)))
 599               ;
 600             else if (PROTOCOL_LIST (p))
 601               fnd = lookup_method_in_protocol_list (PROTOCOL_LIST (p),
 602                                                     sel_name, is_class);
 603           }
 604         else
 605           {
 606             ; /* An identifier...if we could not find a protocol.  */
 607           }
 608
 609         if (fnd)
 610           return fnd;
 611      }
 612
 613    return 0;
 614 }
 615
 616 static tree
 617 lookup_protocol_in_reflist (tree rproto_list, tree lproto)
 618 {
 619   tree rproto, p;
 620
 621   /* Make sure the protocol is supported by the object on the rhs.  */
 622   if (TREE_CODE (lproto) == PROTOCOL_INTERFACE_TYPE)
 623     {
 624       tree fnd = 0;
 625       for (rproto = rproto_list; rproto; rproto = TREE_CHAIN (rproto))
 626         {
 627           p = TREE_VALUE (rproto);
 628
 629           if (TREE_CODE (p) == PROTOCOL_INTERFACE_TYPE)
 630             {
 631               if (lproto == p)
 632                 fnd = lproto;
 633
 634               else if (PROTOCOL_LIST (p))
 635                 fnd = lookup_protocol_in_reflist (PROTOCOL_LIST (p), lproto);
 636             }
 637
 638           if (fnd)
 639             return fnd;
 640         }
 641     }
 642   else
 643     {
 644       ; /* An identifier...if we could not find a protocol.  */
 645     }
 646
 647   return 0;
 648 }
 649
 650 void
 651 objc_start_class_interface (tree klass, tree super_class, tree protos)
 652 {
 653   objc_interface_context
 654     = objc_ivar_context
 655     = start_class (CLASS_INTERFACE_TYPE, klass, super_class, protos);
 656   objc_public_flag = 0;
 657 }
 658
 659 void
 660 objc_start_category_interface (tree klass, tree categ, tree protos)
 661 {
 662   objc_interface_context
 663     = start_class (CATEGORY_INTERFACE_TYPE, klass, categ, protos);
 664   objc_ivar_chain
 665     = continue_class (objc_interface_context);
 666 }
 667
 668 void
 669 objc_start_protocol (tree name, tree protos)
 670 {
 671   objc_interface_context
 672     = start_protocol (PROTOCOL_INTERFACE_TYPE, name, protos);
 673 }
 674
 675 void
 676 objc_continue_interface (void)
 677 {
 678   objc_ivar_chain
 679     = continue_class (objc_interface_context);
 680 }
 681
 682 void
 683 objc_finish_interface (void)
 684 {
 685   finish_class (objc_interface_context);
 686   objc_interface_context = NULL_TREE;
 687 }
 688
 689 void
 690 objc_start_class_implementation (tree klass, tree super_class)
 691 {
 692   objc_implementation_context
 693     = objc_ivar_context
 694     = start_class (CLASS_IMPLEMENTATION_TYPE, klass, super_class, NULL_TREE);
 695   objc_public_flag = 0;
 696 }
 697
 698 void
 699 objc_start_category_implementation (tree klass, tree categ)
 700 {
 701   objc_implementation_context
 702     = start_class (CATEGORY_IMPLEMENTATION_TYPE, klass, categ, NULL_TREE);
 703   objc_ivar_chain
 704     = continue_class (objc_implementation_context);
 705 }
 706
 707 void
 708 objc_continue_implementation (void)
 709 {
 710   objc_ivar_chain
 711     = continue_class (objc_implementation_context);
 712 }
 713
 714 void
 715 objc_finish_implementation (void)
 716 {
 717 #ifdef OBJCPLUS
 718   if (flag_objc_call_cxx_cdtors)
 719     objc_generate_cxx_cdtors ();
 720 #endif
 721
 722   if (objc_implementation_context)
 723     {
 724       finish_class (objc_implementation_context);
 725       objc_ivar_chain = NULL_TREE;
 726       objc_implementation_context = NULL_TREE;
 727     }
 728   else
 729     warning (0, "%<@end%> must appear in an @implementation context");
 730 }
 731
 732 void
 733 objc_set_visibility (int visibility)
 734 {
 735   objc_public_flag = visibility;
 736 }
 737
 738 void
 739 objc_set_method_type (enum tree_code type)
 740 {
 741   objc_inherit_code = (type == PLUS_EXPR
 742                        ? CLASS_METHOD_DECL
 743                        : INSTANCE_METHOD_DECL);
 744 }
 745
 746 tree
 747 objc_build_method_signature (tree rettype, tree selector,
 748                              tree optparms, bool ellipsis)
 749 {
 750   return build_method_decl (objc_inherit_code, rettype, selector,
 751                             optparms, ellipsis);
 752 }
 753
 754 void
 755 objc_add_method_declaration (tree decl)
 756 {
 757   if (!objc_interface_context)
 758     fatal_error ("method declaration not in @interface context");
 759
 760   objc_add_method (objc_interface_context,
 761                    decl,
 762                    objc_inherit_code == CLASS_METHOD_DECL);
 763 }
 764
 765 void
 766 objc_start_method_definition (tree decl)
 767 {
 768   if (!objc_implementation_context)
 769     fatal_error ("method definition not in @implementation context");
 770
 771   objc_add_method (objc_implementation_context,
 772                    decl,
 773                    objc_inherit_code == CLASS_METHOD_DECL);
 774   start_method_def (decl);
 775 }
 776
 777 void
 778 objc_add_instance_variable (tree decl)
 779 {
 780   (void) add_instance_variable (objc_ivar_context,
 781                                 objc_public_flag,
 782                                 decl);
 783 }
 784
 785 /* Return 1 if IDENT is an ObjC/ObjC++ reserved keyword in the context of
 786    an '@'.  */
 787
 788 int
 789 objc_is_reserved_word (tree ident)
 790 {
 791   unsigned char code = C_RID_CODE (ident);
 792
 793   return (OBJC_IS_AT_KEYWORD (code)
 794           || code == RID_CLASS || code == RID_PUBLIC
 795           || code == RID_PROTECTED || code == RID_PRIVATE
 796           || code == RID_TRY || code == RID_THROW || code == RID_CATCH);
 797 }
 798
 799 /* Return true if TYPE is 'id'.  */
 800
 801 static bool
 802 objc_is_object_id (tree type)
 803 {
 804   return OBJC_TYPE_NAME (type) == objc_object_id;
 805 }
 806
 807 static bool
 808 objc_is_class_id (tree type)
 809 {
 810   return OBJC_TYPE_NAME (type) == objc_class_id;
 811 }
 812
 813 /* Construct a C struct with same name as KLASS, a base struct with tag
 814    SUPER_NAME (if any), and FIELDS indicated.  */
 815
 816 static tree
 817 objc_build_struct (tree klass, tree fields, tree super_name)
 818 {
 819   tree name = CLASS_NAME (klass);
 820   tree s = objc_start_struct (name);
 821   tree super = (super_name ? xref_tag (RECORD_TYPE, super_name) : NULL_TREE);
 822   tree t, objc_info = NULL_TREE;
 823
 824   if (super)
 825     {
 826       /* Prepend a packed variant of the base class into the layout.  This
 827          is necessary to preserve ObjC ABI compatibility.  */
 828       tree base = build_decl (input_location,
 829                               FIELD_DECL, NULL_TREE, super);
 830       tree field = TYPE_FIELDS (super);
 831
 832       while (field && TREE_CHAIN (field)
 833              && TREE_CODE (TREE_CHAIN (field)) == FIELD_DECL)
 834         field = TREE_CHAIN (field);
 835
 836       /* For ObjC ABI purposes, the "packed" size of a base class is
 837          the sum of the offset and the size (in bits) of the last field
 838          in the class.  */
 839       DECL_SIZE (base)
 840         = (field && TREE_CODE (field) == FIELD_DECL
 841            ? size_binop (PLUS_EXPR,
 842                          size_binop (PLUS_EXPR,
 843                                      size_binop
 844                                      (MULT_EXPR,
 845                                       convert (bitsizetype,
 846                                                DECL_FIELD_OFFSET (field)),
 847                                       bitsize_int (BITS_PER_UNIT)),
 848                                      DECL_FIELD_BIT_OFFSET (field)),
 849                          DECL_SIZE (field))
 850            : bitsize_zero_node);
 851       DECL_SIZE_UNIT (base)
 852         = size_binop (FLOOR_DIV_EXPR, convert (sizetype, DECL_SIZE (base)),
 853                       size_int (BITS_PER_UNIT));
 854       DECL_ARTIFICIAL (base) = 1;
 855       DECL_ALIGN (base) = 1;
 856       DECL_FIELD_CONTEXT (base) = s;
 857 #ifdef OBJCPLUS
 858       DECL_FIELD_IS_BASE (base) = 1;
 859
 860       if (fields)
 861         TREE_NO_WARNING (fields) = 1;   /* Suppress C++ ABI warnings -- we   */
 862 #endif                                  /* are following the ObjC ABI here.  */
 863       TREE_CHAIN (base) = fields;
 864       fields = base;
 865     }
 866
 867   /* NB: Calling finish_struct() may cause type TYPE_LANG_SPECIFIC fields
 868      in all variants of this RECORD_TYPE to be clobbered, but it is therein
 869      that we store protocol conformance info (e.g., 'NSObject <MyProtocol>').
 870      Hence, we must squirrel away the ObjC-specific information before calling
 871      finish_struct(), and then reinstate it afterwards.  */
 872
 873   for (t = TYPE_NEXT_VARIANT (s); t; t = TYPE_NEXT_VARIANT (t))
 874     {
 875       if (!TYPE_HAS_OBJC_INFO (t))
 876         {
 877           INIT_TYPE_OBJC_INFO (t);
 878           TYPE_OBJC_INTERFACE (t) = klass;
 879         }
 880       objc_info
 881         = chainon (objc_info,
 882                    build_tree_list (NULL_TREE, TYPE_OBJC_INFO (t)));
 883     }
 884
 885   /* Point the struct at its related Objective-C class.  */
 886   INIT_TYPE_OBJC_INFO (s);
 887   TYPE_OBJC_INTERFACE (s) = klass;
 888
 889   s = objc_finish_struct (s, fields);
 890
 891   for (t = TYPE_NEXT_VARIANT (s); t;
 892        t = TYPE_NEXT_VARIANT (t), objc_info = TREE_CHAIN (objc_info))
 893     {
 894       TYPE_OBJC_INFO (t) = TREE_VALUE (objc_info);
 895       /* Replace the IDENTIFIER_NODE with an actual @interface.  */
 896       TYPE_OBJC_INTERFACE (t) = klass;
 897     }
 898
 899   /* Use TYPE_BINFO structures to point at the super class, if any.  */
 900   objc_xref_basetypes (s, super);
 901
 902   /* Mark this struct as a class template.  */
 903   CLASS_STATIC_TEMPLATE (klass) = s;
 904
 905   return s;
 906 }
 907
 908 /* Build a type differing from TYPE only in that TYPE_VOLATILE is set.
 909    Unlike tree.c:build_qualified_type(), preserve TYPE_LANG_SPECIFIC in the
 910    process.  */
 911 static tree
 912 objc_build_volatilized_type (tree type)
 913 {
 914   tree t;
 915
 916   /* Check if we have not constructed the desired variant already.  */
 917   for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
 918     {
 919       /* The type qualifiers must (obviously) match up.  */
 920       if (!TYPE_VOLATILE (t)
 921           || (TYPE_READONLY (t) != TYPE_READONLY (type))
 922           || (TYPE_RESTRICT (t) != TYPE_RESTRICT (type)))
 923         continue;
 924
 925       /* For pointer types, the pointees (and hence their TYPE_LANG_SPECIFIC
 926          info, if any) must match up.  */
 927       if (POINTER_TYPE_P (t)
 928           && (TREE_TYPE (t) != TREE_TYPE (type)))
 929         continue;
 930
 931       /* Everything matches up!  */
 932       return t;
 933     }
 934
 935   /* Ok, we could not re-use any of the pre-existing variants.  Create
 936      a new one.  */
 937   t = build_variant_type_copy (type);
 938   TYPE_VOLATILE (t) = 1;
 939
 940   /* Set up the canonical type information. */
 941   if (TYPE_STRUCTURAL_EQUALITY_P (type))
 942     SET_TYPE_STRUCTURAL_EQUALITY (t);
 943   else if (TYPE_CANONICAL (type) != type)
 944     TYPE_CANONICAL (t) = objc_build_volatilized_type (TYPE_CANONICAL (type));
 945   else
 946     TYPE_CANONICAL (t) = t;
 947
 948   return t;
 949 }
 950
 951 /* Mark DECL as being 'volatile' for purposes of Darwin
 952    _setjmp()/_longjmp() exception handling.  Called from
 953    objc_mark_locals_volatile().  */
 954 void
 955 objc_volatilize_decl (tree decl)
 956 {
 957   /* Do not mess with variables that are 'static' or (already)
 958      'volatile'.  */
 959   if (!TREE_THIS_VOLATILE (decl) && !TREE_STATIC (decl)
 960       && (TREE_CODE (decl) == VAR_DECL
 961           || TREE_CODE (decl) == PARM_DECL))
 962     {
 963       tree t = TREE_TYPE (decl);
 964       struct volatilized_type key;
 965       void **loc;
 966
 967       t = objc_build_volatilized_type (t);
 968       key.type = t;
 969       loc = htab_find_slot (volatilized_htab, &key, INSERT);
 970
 971       if (!*loc)
 972         {
 973           *loc = ggc_alloc (sizeof (key));
 974           ((struct volatilized_type *) *loc)->type = t;
 975         }
 976
 977       TREE_TYPE (decl) = t;
 978       TREE_THIS_VOLATILE (decl) = 1;
 979       TREE_SIDE_EFFECTS (decl) = 1;
 980       DECL_REGISTER (decl) = 0;
 981 #ifndef OBJCPLUS
 982       C_DECL_REGISTER (decl) = 0;
 983 #endif
 984     }
 985 }
 986
 987 /* Check if protocol PROTO is adopted (directly or indirectly) by class CLS
 988    (including its categories and superclasses) or by object type TYP.
 989    Issue a warning if PROTO is not adopted anywhere and WARN is set.  */
 990
 991 static bool
 992 objc_lookup_protocol (tree proto, tree cls, tree typ, bool warn)
 993 {
 994   bool class_type = (cls != NULL_TREE);
 995
 996   while (cls)
 997     {
 998       tree c;
 999
1000       /* Check protocols adopted by the class and its categories.  */
1001       for (c = cls; c; c = CLASS_CATEGORY_LIST (c))
1002         {
1003           if (lookup_protocol_in_reflist (CLASS_PROTOCOL_LIST (c), proto))
1004             return true;
1005         }
1006
1007       /* Repeat for superclasses.  */
1008       cls = lookup_interface (CLASS_SUPER_NAME (cls));
1009     }
1010
1011   /* Check for any protocols attached directly to the object type.  */
1012   if (TYPE_HAS_OBJC_INFO (typ))
1013     {
1014       if (lookup_protocol_in_reflist (TYPE_OBJC_PROTOCOL_LIST (typ), proto))
1015         return true;
1016     }
1017
1018   if (warn)
1019     {
1020       *errbuf = 0;
1021       gen_type_name_0 (class_type ? typ : TYPE_POINTER_TO (typ));
1022       /* NB: Types 'id' and 'Class' cannot reasonably be described as
1023          "implementing" a given protocol, since they do not have an
1024          implementation.  */
1025       if (class_type)
1026         warning (0, "class %qs does not implement the %qE protocol",
1027                  identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
1028       else
1029         warning (0, "type %qs does not conform to the %qE protocol",
1030                  identifier_to_locale (errbuf), PROTOCOL_NAME (proto));
1031     }
1032
1033   return false;
1034 }
1035
1036 /* Check if class RCLS and instance struct type RTYP conform to at least the
1037    same protocols that LCLS and LTYP conform to.  */
1038
1039 static bool
1040 objc_compare_protocols (tree lcls, tree ltyp, tree rcls, tree rtyp, bool warn)
1041 {
1042   tree p;
1043   bool have_lproto = false;
1044
1045   while (lcls)
1046     {
1047       /* NB: We do _not_ look at categories defined for LCLS; these may or
1048          may not get loaded in, and therefore it is unreasonable to require
1049          that RCLS/RTYP must implement any of their protocols.  */
1050       for (p = CLASS_PROTOCOL_LIST (lcls); p; p = TREE_CHAIN (p))
1051         {
1052           have_lproto = true;
1053
1054           if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
1055             return warn;
1056         }
1057
1058       /* Repeat for superclasses.  */
1059       lcls = lookup_interface (CLASS_SUPER_NAME (lcls));
1060     }
1061
1062   /* Check for any protocols attached directly to the object type.  */
1063   if (TYPE_HAS_OBJC_INFO (ltyp))
1064     {
1065       for (p = TYPE_OBJC_PROTOCOL_LIST (ltyp); p; p = TREE_CHAIN (p))
1066         {
1067           have_lproto = true;
1068
1069           if (!objc_lookup_protocol (TREE_VALUE (p), rcls, rtyp, warn))
1070             return warn;
1071         }
1072     }
1073
1074   /* NB: If LTYP and LCLS have no protocols to search for, return 'true'
1075      vacuously, _unless_ RTYP is a protocol-qualified 'id'.  We can get
1076      away with simply checking for 'id' or 'Class' (!RCLS), since this
1077      routine will not get called in other cases.  */
1078   return have_lproto || (rcls != NULL_TREE);
1079 }
1080
1081 /* Determine if it is permissible to assign (if ARGNO is greater than -3)
1082    an instance of RTYP to an instance of LTYP or to compare the two
1083    (if ARGNO is equal to -3), per ObjC type system rules.  Before
1084    returning 'true', this routine may issue warnings related to, e.g.,
1085    protocol conformance.  When returning 'false', the routine must
1086    produce absolutely no warnings; the C or C++ front-end will do so
1087    instead, if needed.  If either LTYP or RTYP is not an Objective-C type,
1088    the routine must return 'false'.
1089
1090    The ARGNO parameter is encoded as follows:
1091      >= 1       Parameter number (CALLEE contains function being called);
1092      0          Return value;
1093      -1         Assignment;
1094      -2         Initialization;
1095      -3         Comparison (LTYP and RTYP may match in either direction).  */
1096
1097 bool
1098 objc_compare_types (tree ltyp, tree rtyp, int argno, tree callee)
1099 {
1100   tree lcls, rcls, lproto, rproto;
1101   bool pointers_compatible;
1102
1103   /* We must be dealing with pointer types */
1104   if (!POINTER_TYPE_P (ltyp) || !POINTER_TYPE_P (rtyp))
1105     return false;
1106
1107   do
1108     {
1109       ltyp = TREE_TYPE (ltyp);  /* Remove indirections.  */
1110       rtyp = TREE_TYPE (rtyp);
1111     }
1112   while (POINTER_TYPE_P (ltyp) && POINTER_TYPE_P (rtyp));
1113
1114   /* Past this point, we are only interested in ObjC class instances,
1115      or 'id' or 'Class'.  */
1116   if (TREE_CODE (ltyp) != RECORD_TYPE || TREE_CODE (rtyp) != RECORD_TYPE)
1117     return false;
1118
1119   if (!objc_is_object_id (ltyp) && !objc_is_class_id (ltyp)
1120       && !TYPE_HAS_OBJC_INFO (ltyp))
1121     return false;
1122
1123   if (!objc_is_object_id (rtyp) && !objc_is_class_id (rtyp)
1124       && !TYPE_HAS_OBJC_INFO (rtyp))
1125     return false;
1126
1127   /* Past this point, we are committed to returning 'true' to the caller.
1128      However, we can still warn about type and/or protocol mismatches.  */
1129
1130   if (TYPE_HAS_OBJC_INFO (ltyp))
1131     {
1132       lcls = TYPE_OBJC_INTERFACE (ltyp);
1133       lproto = TYPE_OBJC_PROTOCOL_LIST (ltyp);
1134     }
1135   else
1136     lcls = lproto = NULL_TREE;
1137
1138   if (TYPE_HAS_OBJC_INFO (rtyp))
1139     {
1140       rcls = TYPE_OBJC_INTERFACE (rtyp);
1141       rproto = TYPE_OBJC_PROTOCOL_LIST (rtyp);
1142     }
1143   else
1144     rcls = rproto = NULL_TREE;
1145
1146   /* If we could not find an @interface declaration, we must have
1147      only seen a @class declaration; for purposes of type comparison,
1148      treat it as a stand-alone (root) class.  */
1149
1150   if (lcls && TREE_CODE (lcls) == IDENTIFIER_NODE)
1151     lcls = NULL_TREE;
1152
1153   if (rcls && TREE_CODE (rcls) == IDENTIFIER_NODE)
1154     rcls = NULL_TREE;
1155
1156   /* If either type is an unqualified 'id', we're done.  */
1157   if ((!lproto && objc_is_object_id (ltyp))
1158       || (!rproto && objc_is_object_id (rtyp)))
1159     return true;
1160
1161   pointers_compatible = (TYPE_MAIN_VARIANT (ltyp) == TYPE_MAIN_VARIANT (rtyp));
1162
1163   /* If the underlying types are the same, and at most one of them has
1164      a protocol list, we do not need to issue any diagnostics.  */
1165   if (pointers_compatible && (!lproto || !rproto))
1166     return true;
1167
1168   /* If exactly one of the types is 'Class', issue a diagnostic; any
1169      exceptions of this rule have already been handled.  */
1170   if (objc_is_class_id (ltyp) ^ objc_is_class_id (rtyp))
1171     pointers_compatible = false;
1172   /* Otherwise, check for inheritance relations.  */
1173   else
1174     {
1175       if (!pointers_compatible)
1176         pointers_compatible
1177           = (objc_is_object_id (ltyp) || objc_is_object_id (rtyp));
1178
1179       if (!pointers_compatible)
1180         pointers_compatible = DERIVED_FROM_P (ltyp, rtyp);
1181
1182       if (!pointers_compatible && argno == -3)
1183         pointers_compatible = DERIVED_FROM_P (rtyp, ltyp);
1184     }
1185
1186   /* If the pointers match modulo protocols, check for protocol conformance
1187      mismatches.  */
1188   if (pointers_compatible)
1189     {
1190       pointers_compatible = objc_compare_protocols (lcls, ltyp, rcls, rtyp,
1191                                                     argno != -3);
1192
1193       if (!pointers_compatible && argno == -3)
1194         pointers_compatible = objc_compare_protocols (rcls, rtyp, lcls, ltyp,
1195                                                       argno != -3);
1196     }
1197
1198   if (!pointers_compatible)
1199     {
1200       /* NB: For the time being, we shall make our warnings look like their
1201          C counterparts.  In the future, we may wish to make them more
1202          ObjC-specific.  */
1203       switch (argno)
1204         {
1205         case -3:
1206           warning (0, "comparison of distinct Objective-C types lacks a cast");
1207           break;
1208
1209         case -2:
1210           warning (0, "initialization from distinct Objective-C type");
1211           break;
1212
1213         case -1:
1214           warning (0, "assignment from distinct Objective-C type");
1215           break;
1216
1217         case 0:
1218           warning (0, "distinct Objective-C type in return");
1219           break;
1220
1221         default:
1222           warning (0, "passing argument %d of %qE from distinct "
1223                    "Objective-C type", argno, callee);
1224           break;
1225         }
1226     }
1227
1228   return true;
1229 }
1230
1231 /* Check if LTYP and RTYP have the same type qualifiers.  If either type
1232    lives in the volatilized hash table, ignore the 'volatile' bit when
1233    making the comparison.  */
1234
1235 bool
1236 objc_type_quals_match (tree ltyp, tree rtyp)
1237 {
1238   int lquals = TYPE_QUALS (ltyp), rquals = TYPE_QUALS (rtyp);
1239   struct volatilized_type key;
1240
1241   key.type = ltyp;
1242
1243   if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
1244     lquals &= ~TYPE_QUAL_VOLATILE;
1245
1246   key.type = rtyp;
1247
1248   if (htab_find_slot (volatilized_htab, &key, NO_INSERT))
1249     rquals &= ~TYPE_QUAL_VOLATILE;
1250
1251   return (lquals == rquals);
1252 }
1253
1254 #ifndef OBJCPLUS
1255 /* Determine if CHILD is derived from PARENT.  The routine assumes that
1256    both parameters are RECORD_TYPEs, and is non-reflexive.  */
1257
1258 static bool
1259 objc_derived_from_p (tree parent, tree child)
1260 {
1261   parent = TYPE_MAIN_VARIANT (parent);
1262
1263   for (child = TYPE_MAIN_VARIANT (child);
1264        TYPE_BINFO (child) && BINFO_N_BASE_BINFOS (TYPE_BINFO (child));)
1265     {
1266       child = TYPE_MAIN_VARIANT (BINFO_TYPE (BINFO_BASE_BINFO
1267                                              (TYPE_BINFO (child),
1268                                               0)));
1269
1270       if (child == parent)
1271         return true;
1272     }
1273
1274   return false;
1275 }
1276 #endif
1277
1278 static tree
1279 objc_build_component_ref (tree datum, tree component)
1280 {
1281   /* If COMPONENT is NULL, the caller is referring to the anonymous
1282      base class field.  */
1283   if (!component)
1284     {
1285       tree base = TYPE_FIELDS (TREE_TYPE (datum));
1286
1287       return build3 (COMPONENT_REF, TREE_TYPE (base), datum, base, NULL_TREE);
1288     }
1289
1290   /* The 'build_component_ref' routine has been removed from the C++
1291      front-end, but 'finish_class_member_access_expr' seems to be
1292      a worthy substitute.  */
1293 #ifdef OBJCPLUS
1294   return finish_class_member_access_expr (datum, component, false,
1295                                           tf_warning_or_error);
1296 #else
1297   return build_component_ref (input_location, datum, component);
1298 #endif
1299 }
1300
1301 /* Recursively copy inheritance information rooted at BINFO.  To do this,
1302    we emulate the song and dance performed by cp/tree.c:copy_binfo().  */
1303
1304 static tree
1305 objc_copy_binfo (tree binfo)
1306 {
1307   tree btype = BINFO_TYPE (binfo);
1308   tree binfo2 = make_tree_binfo (BINFO_N_BASE_BINFOS (binfo));
1309   tree base_binfo;
1310   int ix;
1311
1312   BINFO_TYPE (binfo2) = btype;
1313   BINFO_OFFSET (binfo2) = BINFO_OFFSET (binfo);
1314   BINFO_BASE_ACCESSES (binfo2) = BINFO_BASE_ACCESSES (binfo);
1315
1316   /* Recursively copy base binfos of BINFO.  */
1317   for (ix = 0; BINFO_BASE_ITERATE (binfo, ix, base_binfo); ix++)
1318     {
1319       tree base_binfo2 = objc_copy_binfo (base_binfo);
1320
1321       BINFO_INHERITANCE_CHAIN (base_binfo2) = binfo2;
1322       BINFO_BASE_APPEND (binfo2, base_binfo2);
1323     }
1324
1325   return binfo2;
1326 }
1327
1328 /* Record superclass information provided in BASETYPE for ObjC class REF.
1329    This is loosely based on cp/decl.c:xref_basetypes().  */
1330
1331 static void
1332 objc_xref_basetypes (tree ref, tree basetype)
1333 {
1334   tree binfo = make_tree_binfo (basetype ? 1 : 0);
1335
1336   TYPE_BINFO (ref) = binfo;
1337   BINFO_OFFSET (binfo) = size_zero_node;
1338   BINFO_TYPE (binfo) = ref;
1339
1340   if (basetype)
1341     {
1342       tree base_binfo = objc_copy_binfo (TYPE_BINFO (basetype));
1343
1344       BINFO_INHERITANCE_CHAIN (base_binfo) = binfo;
1345       BINFO_BASE_ACCESSES (binfo) = VEC_alloc (tree, gc, 1);
1346       BINFO_BASE_APPEND (binfo, base_binfo);
1347       BINFO_BASE_ACCESS_APPEND (binfo, access_public_node);
1348     }
1349 }
1350
1351 static hashval_t
1352 volatilized_hash (const void *ptr)
1353 {
1354   const_tree const typ = ((const struct volatilized_type *)ptr)->type;
1355
1356   return htab_hash_pointer(typ);
1357 }
1358
1359 static int
1360 volatilized_eq (const void *ptr1, const void *ptr2)
1361 {
1362   const_tree const typ1 = ((const struct volatilized_type *)ptr1)->type;
1363   const_tree const typ2 = ((const struct volatilized_type *)ptr2)->type;
1364
1365   return typ1 == typ2;
1366 }
1367
1368 /* Called from finish_decl.  */
1369
1370 void
1371 objc_check_decl (tree decl)
1372 {
1373   tree type = TREE_TYPE (decl);
1374
1375   if (TREE_CODE (type) != RECORD_TYPE)
1376     return;
1377   if (OBJC_TYPE_NAME (type) && (type = objc_is_class_name (OBJC_TYPE_NAME (type))))
1378     error ("statically allocated instance of Objective-C class %qE",
1379            type);
1380 }
1381
1382 /* Construct a PROTOCOLS-qualified variant of INTERFACE, where INTERFACE may
1383    either name an Objective-C class, or refer to the special 'id' or 'Class'
1384    types.  If INTERFACE is not a valid ObjC type, just return it unchanged.  */
1385
1386 tree
1387 objc_get_protocol_qualified_type (tree interface, tree protocols)
1388 {
1389   /* If INTERFACE is not provided, default to 'id'.  */
1390   tree type = (interface ? objc_is_id (interface) : objc_object_type);
1391   bool is_ptr = (type != NULL_TREE);
1392
1393   if (!is_ptr)
1394     {
1395       type = objc_is_class_name (interface);
1396
1397       if (type)
1398         type = xref_tag (RECORD_TYPE, type);
1399       else
1400         return interface;
1401     }
1402
1403   if (protocols)
1404     {
1405       type = build_variant_type_copy (type);
1406
1407       /* For pointers (i.e., 'id' or 'Class'), attach the protocol(s)
1408          to the pointee.  */
1409       if (is_ptr)
1410         {
1411           tree orig_pointee_type = TREE_TYPE (type);
1412           TREE_TYPE (type) = build_variant_type_copy (orig_pointee_type);
1413
1414           /* Set up the canonical type information. */
1415           TYPE_CANONICAL (type)
1416             = TYPE_CANONICAL (TYPE_POINTER_TO (orig_pointee_type));
1417
1418           TYPE_POINTER_TO (TREE_TYPE (type)) = type;
1419           type = TREE_TYPE (type);
1420         }
1421
1422       /* Look up protocols and install in lang specific list.  */
1423       DUP_TYPE_OBJC_INFO (type, TYPE_MAIN_VARIANT (type));
1424       TYPE_OBJC_PROTOCOL_LIST (type) = lookup_and_install_protocols (protocols);
1425
1426       /* For RECORD_TYPEs, point to the @interface; for 'id' and 'Class',
1427          return the pointer to the new pointee variant.  */
1428       if (is_ptr)
1429         type = TYPE_POINTER_TO (type);
1430       else
1431         TYPE_OBJC_INTERFACE (type)
1432           = TYPE_OBJC_INTERFACE (TYPE_MAIN_VARIANT (type));
1433     }
1434
1435   return type;
1436 }
1437
1438 /* Check for circular dependencies in protocols.  The arguments are
1439    PROTO, the protocol to check, and LIST, a list of protocol it
1440    conforms to.  */
1441
1442 static void
1443 check_protocol_recursively (tree proto, tree list)
1444 {
1445   tree p;
1446
1447   for (p = list; p; p = TREE_CHAIN (p))
1448     {
1449       tree pp = TREE_VALUE (p);
1450
1451       if (TREE_CODE (pp) == IDENTIFIER_NODE)
1452         pp = lookup_protocol (pp);
1453
1454       if (pp == proto)
1455         fatal_error ("protocol %qE has circular dependency",
1456                      PROTOCOL_NAME (pp));
1457       if (pp)
1458         check_protocol_recursively (proto, PROTOCOL_LIST (pp));
1459     }
1460 }
1461
1462 /* Look up PROTOCOLS, and return a list of those that are found.
1463    If none are found, return NULL.  */
1464
1465 static tree
1466 lookup_and_install_protocols (tree protocols)
1467 {
1468   tree proto;
1469   tree return_value = NULL_TREE;
1470
1471   for (proto = protocols; proto; proto = TREE_CHAIN (proto))
1472     {
1473       tree ident = TREE_VALUE (proto);
1474       tree p = lookup_protocol (ident);
1475
1476       if (p)
1477         return_value = chainon (return_value,
1478                                 build_tree_list (NULL_TREE, p));
1479       else if (ident != error_mark_node)
1480         error ("cannot find protocol declaration for %qE",
1481                ident);
1482     }
1483
1484   return return_value;
1485 }
1486
1487 /* Create a declaration for field NAME of a given TYPE.  */
1488
1489 static tree
1490 create_field_decl (tree type, const char *name)
1491 {
1492   return build_decl (input_location,
1493                      FIELD_DECL, get_identifier (name), type);
1494 }
1495
1496 /* Create a global, static declaration for variable NAME of a given TYPE.  The
1497    finish_var_decl() routine will need to be called on it afterwards.  */
1498
1499 static tree
1500 start_var_decl (tree type, const char *name)
1501 {
1502   tree var = build_decl (input_location,
1503                          VAR_DECL, get_identifier (name), type);
1504
1505   TREE_STATIC (var) = 1;
1506   DECL_INITIAL (var) = error_mark_node;  /* A real initializer is coming... */
1507   DECL_IGNORED_P (var) = 1;
1508   DECL_ARTIFICIAL (var) = 1;
1509   DECL_CONTEXT (var) = NULL_TREE;
1510 #ifdef OBJCPLUS
1511   DECL_THIS_STATIC (var) = 1; /* squash redeclaration errors */
1512 #endif
1513
1514   return var;
1515 }
1516
1517 /* Finish off the variable declaration created by start_var_decl().  */
1518
1519 static void
1520 finish_var_decl (tree var, tree initializer)
1521 {
1522   finish_decl (var, input_location, initializer, NULL_TREE, NULL_TREE);
1523   /* Ensure that the variable actually gets output.  */
1524   mark_decl_referenced (var);
1525   /* Mark the decl to avoid "defined but not used" warning.  */
1526   TREE_USED (var) = 1;
1527 }
1528
1529 /* Find the decl for the constant string class reference.  This is only
1530    used for the NeXT runtime.  */
1531
1532 static tree
1533 setup_string_decl (void)
1534 {
1535   char *name;
1536   size_t length;
1537
1538   /* %s in format will provide room for terminating null */
1539   length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
1540            + strlen (constant_string_class_name);
1541   name = XNEWVEC (char, length);
1542   sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
1543            constant_string_class_name);
1544   constant_string_global_id = get_identifier (name);
1545   string_class_decl = lookup_name (constant_string_global_id);
1546
1547   return string_class_decl;
1548 }
1549
1550 /* Purpose: "play" parser, creating/installing representations
1551    of the declarations that are required by Objective-C.
1552
1553    Model:
1554
1555         type_spec--------->sc_spec
1556         (tree_list)        (tree_list)
1557             |                  |
1558             |                  |
1559         identifier_node    identifier_node  */
1560
1561 static void
1562 synth_module_prologue (void)
1563 {
1564   tree type;
1565   enum debug_info_type save_write_symbols = write_symbols;
1566   const struct gcc_debug_hooks *const save_hooks = debug_hooks;
1567
1568   /* Suppress outputting debug symbols, because
1569      dbxout_init hasn't been called yet.  */
1570   write_symbols = NO_DEBUG;
1571   debug_hooks = &do_nothing_debug_hooks;
1572
1573 #ifdef OBJCPLUS
1574   push_lang_context (lang_name_c); /* extern "C" */
1575 #endif
1576
1577   /* The following are also defined in <objc/objc.h> and friends.  */
1578
1579   objc_object_id = get_identifier (TAG_OBJECT);
1580   objc_class_id = get_identifier (TAG_CLASS);
1581
1582   objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
1583   objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
1584
1585   objc_object_type = build_pointer_type (objc_object_reference);
1586   objc_class_type = build_pointer_type (objc_class_reference);
1587
1588   objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
1589   objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
1590
1591   /* Declare the 'id' and 'Class' typedefs.  */
1592
1593   type = lang_hooks.decls.pushdecl (build_decl (input_location,
1594                                                 TYPE_DECL,
1595                                                 objc_object_name,
1596                                                 objc_object_type));
1597   TREE_NO_WARNING (type) = 1;
1598   type = lang_hooks.decls.pushdecl (build_decl (input_location,
1599                                                 TYPE_DECL,
1600                                                 objc_class_name,
1601                                                 objc_class_type));
1602   TREE_NO_WARNING (type) = 1;
1603
1604   /* Forward-declare '@interface Protocol'.  */
1605
1606   type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
1607   objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
1608   objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
1609                                 type));
1610
1611   /* Declare type of selector-objects that represent an operation name.  */
1612
1613   if (flag_next_runtime)
1614     /* `struct objc_selector *' */
1615     objc_selector_type
1616       = build_pointer_type (xref_tag (RECORD_TYPE,
1617                                       get_identifier (TAG_SELECTOR)));
1618   else
1619     /* `const struct objc_selector *' */
1620     objc_selector_type
1621       = build_pointer_type
1622         (build_qualified_type (xref_tag (RECORD_TYPE,
1623                                          get_identifier (TAG_SELECTOR)),
1624                                TYPE_QUAL_CONST));
1625
1626   /* Declare receiver type used for dispatching messages to 'super'.  */
1627
1628   /* `struct objc_super *' */
1629   objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
1630                                                   get_identifier (TAG_SUPER)));
1631
1632   /* Declare pointers to method and ivar lists.  */
1633   objc_method_list_ptr = build_pointer_type
1634                          (xref_tag (RECORD_TYPE,
1635                                     get_identifier (UTAG_METHOD_LIST)));
1636   objc_method_proto_list_ptr
1637     = build_pointer_type (xref_tag (RECORD_TYPE,
1638                                     get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
1639   objc_ivar_list_ptr = build_pointer_type
1640                        (xref_tag (RECORD_TYPE,
1641                                   get_identifier (UTAG_IVAR_LIST)));
1642
1643   /* TREE_NOTHROW is cleared for the message-sending functions,
1644      because the function that gets called can throw in Obj-C++, or
1645      could itself call something that can throw even in Obj-C.  */
1646
1647   if (flag_next_runtime)
1648     {
1649       /* NB: In order to call one of the ..._stret (struct-returning)
1650       functions, the function *MUST* first be cast to a signature that
1651       corresponds to the actual ObjC method being invoked.  This is
1652       what is done by the build_objc_method_call() routine below.  */
1653
1654       /* id objc_msgSend (id, SEL, ...); */
1655       /* id objc_msgSendNonNil (id, SEL, ...); */
1656       /* id objc_msgSend_stret (id, SEL, ...); */
1657       /* id objc_msgSendNonNil_stret (id, SEL, ...); */
1658       type
1659         = build_function_type (objc_object_type,
1660                                tree_cons (NULL_TREE, objc_object_type,
1661                                           tree_cons (NULL_TREE, objc_selector_type,
1662                                                      NULL_TREE)));
1663       umsg_decl = add_builtin_function (TAG_MSGSEND,
1664                                         type, 0, NOT_BUILT_IN,
1665                                         NULL, NULL_TREE);
1666       umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL,
1667                                                type, 0, NOT_BUILT_IN,
1668                                                NULL, NULL_TREE);
1669       umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET,
1670                                               type, 0, NOT_BUILT_IN,
1671                                               NULL, NULL_TREE);
1672       umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET,
1673                                                      type, 0, NOT_BUILT_IN,
1674                                                      NULL, NULL_TREE);
1675
1676       /* These can throw, because the function that gets called can throw
1677          in Obj-C++, or could itself call something that can throw even
1678          in Obj-C.  */
1679       TREE_NOTHROW (umsg_decl) = 0;
1680       TREE_NOTHROW (umsg_nonnil_decl) = 0;
1681       TREE_NOTHROW (umsg_stret_decl) = 0;
1682       TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
1683
1684       /* id objc_msgSend_Fast (id, SEL, ...)
1685            __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
1686 #ifdef OFFS_MSGSEND_FAST
1687       umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST,
1688                                              type, 0, NOT_BUILT_IN,
1689                                              NULL, NULL_TREE);
1690       TREE_NOTHROW (umsg_fast_decl) = 0;
1691       DECL_ATTRIBUTES (umsg_fast_decl)
1692         = tree_cons (get_identifier ("hard_coded_address"),
1693                      build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
1694                      NULL_TREE);
1695 #else
1696       /* No direct dispatch available.  */
1697       umsg_fast_decl = umsg_decl;
1698 #endif
1699
1700       /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
1701       /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
1702       type
1703         = build_function_type (objc_object_type,
1704                                tree_cons (NULL_TREE, objc_super_type,
1705                                           tree_cons (NULL_TREE, objc_selector_type,
1706                                                      NULL_TREE)));
1707       umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1708                                               type, 0, NOT_BUILT_IN,
1709                                               NULL, NULL_TREE);
1710       umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET,
1711                                                     type, 0, NOT_BUILT_IN, 0,
1712                                                     NULL_TREE);
1713       TREE_NOTHROW (umsg_super_decl) = 0;
1714       TREE_NOTHROW (umsg_super_stret_decl) = 0;
1715     }
1716   else
1717     {
1718       /* GNU runtime messenger entry points.  */
1719
1720       /* typedef id (*IMP)(id, SEL, ...); */
1721       tree IMP_type
1722         = build_pointer_type
1723           (build_function_type (objc_object_type,
1724                                 tree_cons (NULL_TREE, objc_object_type,
1725                                            tree_cons (NULL_TREE, objc_selector_type,
1726                                                       NULL_TREE))));
1727
1728       /* IMP objc_msg_lookup (id, SEL); */
1729       type
1730         = build_function_type (IMP_type,
1731                                tree_cons (NULL_TREE, objc_object_type,
1732                                           tree_cons (NULL_TREE, objc_selector_type,
1733                                                      OBJC_VOID_AT_END)));
1734       umsg_decl = add_builtin_function (TAG_MSGSEND,
1735                                         type, 0, NOT_BUILT_IN,
1736                                         NULL, NULL_TREE);
1737       TREE_NOTHROW (umsg_decl) = 0;
1738
1739       /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
1740       type
1741         = build_function_type (IMP_type,
1742                                tree_cons (NULL_TREE, objc_super_type,
1743                                           tree_cons (NULL_TREE, objc_selector_type,
1744                                                      OBJC_VOID_AT_END)));
1745       umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1746                                               type, 0, NOT_BUILT_IN,
1747                                               NULL, NULL_TREE);
1748       TREE_NOTHROW (umsg_super_decl) = 0;
1749
1750       /* The following GNU runtime entry point is called to initialize
1751          each module:
1752
1753          __objc_exec_class (void *); */
1754       type
1755         = build_function_type (void_type_node,
1756                                tree_cons (NULL_TREE, ptr_type_node,
1757                                           OBJC_VOID_AT_END));
1758       execclass_decl = add_builtin_function (TAG_EXECCLASS,
1759                                              type, 0, NOT_BUILT_IN,
1760                                              NULL, NULL_TREE);
1761     }
1762
1763   /* id objc_getClass (const char *); */
1764
1765   type = build_function_type (objc_object_type,
1766                                    tree_cons (NULL_TREE,
1767                                               const_string_type_node,
1768                                               OBJC_VOID_AT_END));
1769
1770   objc_get_class_decl
1771     = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
1772                             NULL, NULL_TREE);
1773
1774   /* id objc_getMetaClass (const char *); */
1775
1776   objc_get_meta_class_decl
1777     = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
1778
1779   build_class_template ();
1780   build_super_template ();
1781   build_protocol_template ();
1782   build_category_template ();
1783   build_objc_exception_stuff ();
1784
1785   if (flag_next_runtime)
1786     build_next_objc_exception_stuff ();
1787
1788   /* static SEL _OBJC_SELECTOR_TABLE[]; */
1789
1790   if (! flag_next_runtime)
1791     build_selector_table_decl ();
1792
1793   /* Forward declare constant_string_id and constant_string_type.  */
1794   if (!constant_string_class_name)
1795     constant_string_class_name = default_constant_string_class_name;
1796
1797   constant_string_id = get_identifier (constant_string_class_name);
1798   objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE));
1799
1800   /* Pre-build the following entities - for speed/convenience.  */
1801   self_id = get_identifier ("self");
1802   ucmd_id = get_identifier ("_cmd");
1803
1804 #ifdef OBJCPLUS
1805   pop_lang_context ();
1806 #endif
1807
1808   write_symbols = save_write_symbols;
1809   debug_hooks = save_hooks;
1810 }
1811
1812 /* Ensure that the ivar list for NSConstantString/NXConstantString
1813    (or whatever was specified via `-fconstant-string-class')
1814    contains fields at least as large as the following three, so that
1815    the runtime can stomp on them with confidence:
1816
1817    struct STRING_OBJECT_CLASS_NAME
1818    {
1819      Object isa;
1820      char *cString;
1821      unsigned int length;
1822    }; */
1823
1824 static int
1825 check_string_class_template (void)
1826 {
1827   tree field_decl = objc_get_class_ivars (constant_string_id);
1828
1829 #define AT_LEAST_AS_LARGE_AS(F, T) \
1830   (F && TREE_CODE (F) == FIELD_DECL \
1831      && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
1832          >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
1833
1834   if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1835     return 0;
1836
1837   field_decl = TREE_CHAIN (field_decl);
1838   if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1839     return 0;
1840
1841   field_decl = TREE_CHAIN (field_decl);
1842   return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
1843
1844 #undef AT_LEAST_AS_LARGE_AS
1845 }
1846
1847 /* Avoid calling `check_string_class_template ()' more than once.  */
1848 static GTY(()) int string_layout_checked;
1849
1850 /* Construct an internal string layout to be used as a template for
1851    creating NSConstantString/NXConstantString instances.  */
1852
1853 static tree
1854 objc_build_internal_const_str_type (void)
1855 {
1856   tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
1857   tree fields = build_decl (input_location,
1858                             FIELD_DECL, NULL_TREE, ptr_type_node);
1859   tree field = build_decl (input_location,
1860                            FIELD_DECL, NULL_TREE, ptr_type_node);
1861
1862   TREE_CHAIN (field) = fields; fields = field;
1863   field = build_decl (input_location,
1864                       FIELD_DECL, NULL_TREE, unsigned_type_node);
1865   TREE_CHAIN (field) = fields; fields = field;
1866   /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
1867      reverse order!  */
1868   finish_builtin_struct (type, "__builtin_ObjCString",
1869                          fields, NULL_TREE);
1870
1871   return type;
1872 }
1873
1874 /* Custom build_string which sets TREE_TYPE!  */
1875
1876 static tree
1877 my_build_string (int len, const char *str)
1878 {
1879   return fix_string_type (build_string (len, str));
1880 }
1881
1882 /* Build a string with contents STR and length LEN and convert it to a
1883    pointer.  */
1884
1885 static tree
1886 my_build_string_pointer (int len, const char *str)
1887 {
1888   tree string = my_build_string (len, str);
1889   tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string)));
1890   return build1 (ADDR_EXPR, ptrtype, string);
1891 }
1892
1893 static hashval_t
1894 string_hash (const void *ptr)
1895 {
1896   const_tree const str = ((const struct string_descriptor *)ptr)->literal;
1897   const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
1898   int i, len = TREE_STRING_LENGTH (str);
1899   hashval_t h = len;
1900
1901   for (i = 0; i < len; i++)
1902     h = ((h * 613) + p[i]);
1903
1904   return h;
1905 }
1906
1907 static int
1908 string_eq (const void *ptr1, const void *ptr2)
1909 {
1910   const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal;
1911   const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal;
1912   int len1 = TREE_STRING_LENGTH (str1);
1913
1914   return (len1 == TREE_STRING_LENGTH (str2)
1915           && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
1916                       len1));
1917 }
1918
1919 /* Given a chain of STRING_CST's, build a static instance of
1920    NXConstantString which points at the concatenation of those
1921    strings.  We place the string object in the __string_objects
1922    section of the __OBJC segment.  The Objective-C runtime will
1923    initialize the isa pointers of the string objects to point at the
1924    NXConstantString class object.  */
1925
1926 tree
1927 objc_build_string_object (tree string)
1928 {
1929   tree initlist, constructor, constant_string_class;
1930   int length;
1931   tree fields, addr;
1932   struct string_descriptor *desc, key;
1933   void **loc;
1934
1935   /* Prep the string argument.  */
1936   string = fix_string_type (string);
1937   TREE_SET_CODE (string, STRING_CST);
1938   length = TREE_STRING_LENGTH (string) - 1;
1939
1940   /* Check whether the string class being used actually exists and has the
1941      correct ivar layout.  */
1942   if (!string_layout_checked)
1943     {
1944       string_layout_checked = -1;
1945       constant_string_class = lookup_interface (constant_string_id);
1946       internal_const_str_type = objc_build_internal_const_str_type ();
1947
1948       if (!constant_string_class
1949           || !(constant_string_type
1950                = CLASS_STATIC_TEMPLATE (constant_string_class)))
1951         error ("cannot find interface declaration for %qE",
1952                constant_string_id);
1953       /* The NSConstantString/NXConstantString ivar layout is now known.  */
1954       else if (!check_string_class_template ())
1955         error ("interface %qE does not have valid constant string layout",
1956                constant_string_id);
1957       /* For the NeXT runtime, we can generate a literal reference
1958          to the string class, don't need to run a constructor.  */
1959       else if (flag_next_runtime && !setup_string_decl ())
1960         error ("cannot find reference tag for class %qE",
1961                constant_string_id);
1962       else
1963         {
1964           string_layout_checked = 1;  /* Success!  */
1965           add_class_reference (constant_string_id);
1966         }
1967     }
1968
1969   if (string_layout_checked == -1)
1970     return error_mark_node;
1971
1972   /* Perhaps we already constructed a constant string just like this one? */
1973   key.literal = string;
1974   loc = htab_find_slot (string_htab, &key, INSERT);
1975   desc = (struct string_descriptor *) *loc;
1976
1977   if (!desc)
1978     {
1979       tree var;
1980       *loc = desc = GGC_NEW (struct string_descriptor);
1981       desc->literal = string;
1982
1983       /* GNU:    (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length })  */
1984       /* NeXT:   (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length })   */
1985       fields = TYPE_FIELDS (internal_const_str_type);
1986       initlist
1987         = build_tree_list (fields,
1988                            flag_next_runtime
1989                            ? build_unary_op (input_location,
1990                                              ADDR_EXPR, string_class_decl, 0)
1991                            : build_int_cst (NULL_TREE, 0));
1992       fields = TREE_CHAIN (fields);
1993       initlist = tree_cons (fields, build_unary_op (input_location,
1994                                                     ADDR_EXPR, string, 1),
1995                             initlist);
1996       fields = TREE_CHAIN (fields);
1997       initlist = tree_cons (fields, build_int_cst (NULL_TREE, length),
1998                             initlist);
1999       constructor = objc_build_constructor (internal_const_str_type,
2000                                             nreverse (initlist));
2001
2002       if (!flag_next_runtime)
2003         constructor
2004           = objc_add_static_instance (constructor, constant_string_type);
2005       else
2006         {
2007           var = build_decl (input_location,
2008                             CONST_DECL, NULL, TREE_TYPE (constructor));
2009           DECL_INITIAL (var) = constructor;
2010           TREE_STATIC (var) = 1;
2011           pushdecl_top_level (var);
2012           constructor = var;
2013         }
2014       desc->constructor = constructor;
2015     }
2016
2017   addr = convert (build_pointer_type (constant_string_type),
2018                   build_unary_op (input_location,
2019                                   ADDR_EXPR, desc->constructor, 1));
2020
2021   return addr;
2022 }
2023
2024 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR.  */
2025
2026 static GTY(()) int num_static_inst;
2027
2028 static tree
2029 objc_add_static_instance (tree constructor, tree class_decl)
2030 {
2031   tree *chain, decl;
2032   char buf[256];
2033
2034   /* Find the list of static instances for the CLASS_DECL.  Create one if
2035      not found.  */
2036   for (chain = &objc_static_instances;
2037        *chain && TREE_VALUE (*chain) != class_decl;
2038        chain = &TREE_CHAIN (*chain));
2039   if (!*chain)
2040     {
2041       *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
2042       add_objc_string (OBJC_TYPE_NAME (class_decl), class_names);
2043     }
2044
2045   sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
2046   decl = build_decl (input_location,
2047                      VAR_DECL, get_identifier (buf), class_decl);
2048   TREE_STATIC (decl) = 1;
2049   DECL_ARTIFICIAL (decl) = 1;
2050   TREE_USED (decl) = 1;
2051   DECL_INITIAL (decl) = constructor;
2052
2053   /* We may be writing something else just now.
2054      Postpone till end of input.  */
2055   DECL_DEFER_OUTPUT (decl) = 1;
2056   pushdecl_top_level (decl);
2057   rest_of_decl_compilation (decl, 1, 0);
2058
2059   /* Add the DECL to the head of this CLASS' list.  */
2060   TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
2061
2062   return decl;
2063 }
2064
2065 /* Build a static constant CONSTRUCTOR
2066    with type TYPE and elements ELTS.  */
2067
2068 static tree
2069 objc_build_constructor (tree type, tree elts)
2070 {
2071   tree constructor = build_constructor_from_list (type, elts);
2072
2073   TREE_CONSTANT (constructor) = 1;
2074   TREE_STATIC (constructor) = 1;
2075   TREE_READONLY (constructor) = 1;
2076
2077 #ifdef OBJCPLUS
2078   /* Adjust for impedance mismatch.  We should figure out how to build
2079      CONSTRUCTORs that consistently please both the C and C++ gods.  */
2080   if (!TREE_PURPOSE (elts))
2081     TREE_TYPE (constructor) = init_list_type_node;
2082 #endif
2083
2084   return constructor;
2085 }
2086 \f
2087 /* Take care of defining and initializing _OBJC_SYMBOLS.  */
2088
2089 /* Predefine the following data type:
2090
2091    struct _objc_symtab
2092    {
2093      long sel_ref_cnt;
2094      SEL *refs;
2095      short cls_def_cnt;
2096      short cat_def_cnt;
2097      void *defs[cls_def_cnt + cat_def_cnt];
2098    }; */
2099
2100 static void
2101 build_objc_symtab_template (void)
2102 {
2103   tree field_decl, field_decl_chain;
2104
2105   objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB));
2106
2107   /* long sel_ref_cnt; */
2108   field_decl = create_field_decl (long_integer_type_node, "sel_ref_cnt");
2109   field_decl_chain = field_decl;
2110
2111   /* SEL *refs; */
2112   field_decl = create_field_decl (build_pointer_type (objc_selector_type),
2113                                   "refs");
2114   chainon (field_decl_chain, field_decl);
2115
2116   /* short cls_def_cnt; */
2117   field_decl = create_field_decl (short_integer_type_node, "cls_def_cnt");
2118   chainon (field_decl_chain, field_decl);
2119
2120   /* short cat_def_cnt; */
2121   field_decl = create_field_decl (short_integer_type_node,
2122                                   "cat_def_cnt");
2123   chainon (field_decl_chain, field_decl);
2124
2125   if (imp_count || cat_count || !flag_next_runtime)
2126     {
2127       /* void *defs[imp_count + cat_count (+ 1)]; */
2128       /* NB: The index is one less than the size of the array.  */
2129       int index = imp_count + cat_count
2130                 + (flag_next_runtime? -1: 0);
2131       field_decl = create_field_decl
2132                    (build_array_type
2133                     (ptr_type_node,
2134                      build_index_type (build_int_cst (NULL_TREE, index))),
2135                     "defs");
2136       chainon (field_decl_chain, field_decl);
2137     }
2138
2139   objc_finish_struct (objc_symtab_template, field_decl_chain);
2140 }
2141
2142 /* Create the initial value for the `defs' field of _objc_symtab.
2143    This is a CONSTRUCTOR.  */
2144
2145 static tree
2146 init_def_list (tree type)
2147 {
2148   tree expr, initlist = NULL_TREE;
2149   struct imp_entry *impent;
2150
2151   if (imp_count)
2152     for (impent = imp_list; impent; impent = impent->next)
2153       {
2154         if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
2155           {
2156             expr = build_unary_op (input_location,
2157                                    ADDR_EXPR, impent->class_decl, 0);
2158             initlist = tree_cons (NULL_TREE, expr, initlist);
2159           }
2160       }
2161
2162   if (cat_count)
2163     for (impent = imp_list; impent; impent = impent->next)
2164       {
2165         if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2166           {
2167             expr = build_unary_op (input_location,
2168                                    ADDR_EXPR, impent->class_decl, 0);
2169             initlist = tree_cons (NULL_TREE, expr, initlist);
2170           }
2171       }
2172
2173   if (!flag_next_runtime)
2174     {
2175       /* statics = { ..., _OBJC_STATIC_INSTANCES, ... }  */
2176       tree expr;
2177
2178       if (static_instances_decl)
2179         expr = build_unary_op (input_location,
2180                                ADDR_EXPR, static_instances_decl, 0);
2181       else
2182         expr = build_int_cst (NULL_TREE, 0);
2183
2184       initlist = tree_cons (NULL_TREE, expr, initlist);
2185     }
2186
2187   return objc_build_constructor (type, nreverse (initlist));
2188 }
2189
2190 /* Construct the initial value for all of _objc_symtab.  */
2191
2192 static tree
2193 init_objc_symtab (tree type)
2194 {
2195   tree initlist;
2196
2197   /* sel_ref_cnt = { ..., 5, ... } */
2198
2199   initlist = build_tree_list (NULL_TREE,
2200                               build_int_cst (long_integer_type_node, 0));
2201
2202   /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
2203
2204   if (flag_next_runtime || ! sel_ref_chain)
2205     initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
2206   else
2207     initlist
2208       = tree_cons (NULL_TREE,
2209                    convert (build_pointer_type (objc_selector_type),
2210                             build_unary_op (input_location, ADDR_EXPR,
2211                                             UOBJC_SELECTOR_TABLE_decl, 1)),
2212                    initlist);
2213
2214   /* cls_def_cnt = { ..., 5, ... } */
2215
2216   initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, imp_count), initlist);
2217
2218   /* cat_def_cnt = { ..., 5, ... } */
2219
2220   initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, cat_count), initlist);
2221
2222   /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
2223
2224   if (imp_count || cat_count || !flag_next_runtime)
2225     {
2226
2227       tree field = TYPE_FIELDS (type);
2228       field = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field))));
2229
2230       initlist = tree_cons (NULL_TREE, init_def_list (TREE_TYPE (field)),
2231                             initlist);
2232     }
2233
2234   return objc_build_constructor (type, nreverse (initlist));
2235 }
2236
2237 /* Generate forward declarations for metadata such as
2238   'OBJC_CLASS_...'.  */
2239
2240 static tree
2241 build_metadata_decl (const char *name, tree type)
2242 {
2243   tree decl;
2244
2245   /* struct TYPE NAME_<name>; */
2246   decl = start_var_decl (type, synth_id_with_class_suffix
2247                                (name,
2248                                 objc_implementation_context));
2249
2250   return decl;
2251 }
2252
2253 /* Push forward-declarations of all the categories so that
2254    init_def_list can use them in a CONSTRUCTOR.  */
2255
2256 static void
2257 forward_declare_categories (void)
2258 {
2259   struct imp_entry *impent;
2260   tree sav = objc_implementation_context;
2261
2262   for (impent = imp_list; impent; impent = impent->next)
2263     {
2264       if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2265         {
2266           /* Set an invisible arg to synth_id_with_class_suffix.  */
2267           objc_implementation_context = impent->imp_context;
2268           /* extern struct objc_category _OBJC_CATEGORY_<name>; */
2269           impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
2270                                                     objc_category_template);
2271         }
2272     }
2273   objc_implementation_context = sav;
2274 }
2275
2276 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
2277    and initialized appropriately.  */
2278
2279 static void
2280 generate_objc_symtab_decl (void)
2281 {
2282   /* forward declare categories */
2283   if (cat_count)
2284     forward_declare_categories ();
2285
2286   build_objc_symtab_template ();
2287   UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS");
2288   finish_var_decl (UOBJC_SYMBOLS_decl,
2289                    init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
2290 }
2291 \f
2292 static tree
2293 init_module_descriptor (tree type)
2294 {
2295   tree initlist, expr;
2296
2297   /* version = { 1, ... } */
2298
2299   expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
2300   initlist = build_tree_list (NULL_TREE, expr);
2301
2302   /* size = { ..., sizeof (struct _objc_module), ... } */
2303
2304   expr = convert (long_integer_type_node,
2305                   size_in_bytes (objc_module_template));
2306   initlist = tree_cons (NULL_TREE, expr, initlist);
2307
2308   /* Don't provide any file name for security reasons. */
2309   /* name = { ..., "", ... } */
2310
2311   expr = add_objc_string (get_identifier (""), class_names);
2312   initlist = tree_cons (NULL_TREE, expr, initlist);
2313
2314   /* symtab = { ..., _OBJC_SYMBOLS, ... } */
2315
2316   if (UOBJC_SYMBOLS_decl)
2317     expr = build_unary_op (input_location,
2318                            ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
2319   else
2320     expr = build_int_cst (NULL_TREE, 0);
2321   initlist = tree_cons (NULL_TREE, expr, initlist);
2322
2323   return objc_build_constructor (type, nreverse (initlist));
2324 }
2325
2326 /* Write out the data structures to describe Objective C classes defined.
2327
2328    struct _objc_module { ... } _OBJC_MODULE = { ... };   */
2329
2330 static void
2331 build_module_descriptor (void)
2332 {
2333   tree field_decl, field_decl_chain;
2334
2335 #ifdef OBJCPLUS
2336   push_lang_context (lang_name_c); /* extern "C" */
2337 #endif
2338
2339   objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE));
2340
2341   /* long version; */
2342   field_decl = create_field_decl (long_integer_type_node, "version");
2343   field_decl_chain = field_decl;
2344
2345   /* long size; */
2346   field_decl = create_field_decl (long_integer_type_node, "size");
2347   chainon (field_decl_chain, field_decl);
2348
2349   /* char *name; */
2350   field_decl = create_field_decl (string_type_node, "name");
2351   chainon (field_decl_chain, field_decl);
2352
2353   /* struct _objc_symtab *symtab; */
2354   field_decl
2355     = create_field_decl (build_pointer_type
2356                          (xref_tag (RECORD_TYPE,
2357                                     get_identifier (UTAG_SYMTAB))),
2358                          "symtab");
2359   chainon (field_decl_chain, field_decl);
2360
2361   objc_finish_struct (objc_module_template, field_decl_chain);
2362
2363   /* Create an instance of "_objc_module".  */
2364   UOBJC_MODULES_decl = start_var_decl (objc_module_template, "_OBJC_MODULES");
2365   finish_var_decl (UOBJC_MODULES_decl,
2366                    init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)));
2367
2368 #ifdef OBJCPLUS
2369   pop_lang_context ();
2370 #endif
2371 }
2372
2373 /* The GNU runtime requires us to provide a static initializer function
2374    for each module:
2375
2376    static void __objc_gnu_init (void) {
2377      __objc_exec_class (&L_OBJC_MODULES);
2378    }  */
2379
2380 static void
2381 build_module_initializer_routine (void)
2382 {
2383   tree body;
2384
2385 #ifdef OBJCPLUS
2386   push_lang_context (lang_name_c); /* extern "C" */
2387 #endif
2388
2389   objc_push_parm (build_decl (input_location,
2390                               PARM_DECL, NULL_TREE, void_type_node));
2391   objc_start_function (get_identifier (TAG_GNUINIT),
2392                        build_function_type (void_type_node,
2393                                             OBJC_VOID_AT_END),
2394                        NULL_TREE, objc_get_parm_info (0));
2395
2396   body = c_begin_compound_stmt (true);
2397   add_stmt (build_function_call
2398             (input_location,
2399              execclass_decl,
2400              build_tree_list
2401              (NULL_TREE,
2402               build_unary_op (input_location, ADDR_EXPR,
2403                               UOBJC_MODULES_decl, 0))));
2404   add_stmt (c_end_compound_stmt (input_location, body, true));
2405
2406   TREE_PUBLIC (current_function_decl) = 0;
2407
2408 #ifndef OBJCPLUS
2409   /* For Objective-C++, we will need to call __objc_gnu_init
2410      from objc_generate_static_init_call() below.  */
2411   DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1;
2412 #endif
2413
2414   GNU_INIT_decl = current_function_decl;
2415   finish_function ();
2416
2417 #ifdef OBJCPLUS
2418     pop_lang_context ();
2419 #endif
2420 }
2421
2422 #ifdef OBJCPLUS
2423 /* Return 1 if the __objc_gnu_init function has been synthesized and needs
2424    to be called by the module initializer routine.  */
2425
2426 int
2427 objc_static_init_needed_p (void)
2428 {
2429   return (GNU_INIT_decl != NULL_TREE);
2430 }
2431
2432 /* Generate a call to the __objc_gnu_init initializer function.  */
2433
2434 tree
2435 objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
2436 {
2437   add_stmt (build_stmt (input_location, EXPR_STMT,
2438                         build_function_call (input_location,
2439                                              GNU_INIT_decl, NULL_TREE)));
2440
2441   return ctors;
2442 }
2443 #endif /* OBJCPLUS */
2444
2445 /* Return the DECL of the string IDENT in the SECTION.  */
2446
2447 static tree
2448 get_objc_string_decl (tree ident, enum string_section section)
2449 {
2450   tree chain;
2451
2452   if (section == class_names)
2453     chain = class_names_chain;
2454   else if (section == meth_var_names)
2455     chain = meth_var_names_chain;
2456   else if (section == meth_var_types)
2457     chain = meth_var_types_chain;
2458   else
2459     abort ();
2460
2461   for (; chain != 0; chain = TREE_CHAIN (chain))
2462     if (TREE_VALUE (chain) == ident)
2463       return (TREE_PURPOSE (chain));
2464
2465   abort ();
2466   return NULL_TREE;
2467 }
2468
2469 /* Output references to all statically allocated objects.  Return the DECL
2470    for the array built.  */
2471
2472 static void
2473 generate_static_references (void)
2474 {
2475   tree decls = NULL_TREE, expr = NULL_TREE;
2476   tree class_name, klass, decl, initlist;
2477   tree cl_chain, in_chain, type
2478     = build_array_type (build_pointer_type (void_type_node), NULL_TREE);
2479   int num_inst, num_class;
2480   char buf[256];
2481
2482   if (flag_next_runtime)
2483     abort ();
2484
2485   for (cl_chain = objc_static_instances, num_class = 0;
2486        cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
2487     {
2488       for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
2489            in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
2490
2491       sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
2492       decl = start_var_decl (type, buf);
2493
2494       /* Output {class_name, ...}.  */
2495       klass = TREE_VALUE (cl_chain);
2496       class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names);
2497       initlist = build_tree_list (NULL_TREE,
2498                                   build_unary_op (input_location,
2499                                                   ADDR_EXPR, class_name, 1));
2500
2501       /* Output {..., instance, ...}.  */
2502       for (in_chain = TREE_PURPOSE (cl_chain);
2503            in_chain; in_chain = TREE_CHAIN (in_chain))
2504         {
2505           expr = build_unary_op (input_location,
2506                                  ADDR_EXPR, TREE_VALUE (in_chain), 1);
2507           initlist = tree_cons (NULL_TREE, expr, initlist);
2508         }
2509
2510       /* Output {..., NULL}.  */
2511       initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
2512
2513       expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
2514       finish_var_decl (decl, expr);
2515       decls
2516         = tree_cons (NULL_TREE, build_unary_op (input_location,
2517                                                 ADDR_EXPR, decl, 1), decls);
2518     }
2519
2520   decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), decls);
2521   expr = objc_build_constructor (type, nreverse (decls));
2522   static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
2523   finish_var_decl (static_instances_decl, expr);
2524 }
2525
2526 static GTY(()) int selector_reference_idx;
2527
2528 static tree
2529 build_selector_reference_decl (void)
2530 {
2531   tree decl;
2532   char buf[256];
2533
2534   sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
2535   decl = start_var_decl (objc_selector_type, buf);
2536
2537   return decl;
2538 }
2539
2540 static void
2541 build_selector_table_decl (void)
2542 {
2543   tree temp;
2544
2545   if (flag_typed_selectors)
2546     {
2547       build_selector_template ();
2548       temp = build_array_type (objc_selector_template, NULL_TREE);
2549     }
2550   else
2551     temp = build_array_type (objc_selector_type, NULL_TREE);
2552
2553   UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
2554 }
2555
2556 /* Just a handy wrapper for add_objc_string.  */
2557
2558 static tree
2559 build_selector (tree ident)
2560 {
2561   return convert (objc_selector_type,
2562                   add_objc_string (ident, meth_var_names));
2563 }
2564
2565 static void
2566 build_selector_translation_table (void)
2567 {
2568   tree chain, initlist = NULL_TREE;
2569   int offset = 0;
2570   tree decl = NULL_TREE;
2571
2572   for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
2573     {
2574       tree expr;
2575
2576       if (warn_selector && objc_implementation_context)
2577       {
2578         tree method_chain;
2579         bool found = false;
2580         for (method_chain = meth_var_names_chain;
2581              method_chain;
2582              method_chain = TREE_CHAIN (method_chain))
2583           {
2584             if (TREE_VALUE (method_chain) == TREE_VALUE (chain))
2585               {
2586                 found = true;
2587                 break;
2588               }
2589           }
2590         if (!found)
2591           {
2592             location_t loc;
2593             if (flag_next_runtime && TREE_PURPOSE (chain))
2594               loc = DECL_SOURCE_LOCATION (TREE_PURPOSE (chain));
2595             else
2596               loc = input_location;
2597             warning_at (loc, 0, "creating selector for nonexistent method %qE",
2598                         TREE_VALUE (chain));
2599           }
2600       }
2601
2602       expr = build_selector (TREE_VALUE (chain));
2603       /* add one for the '\0' character */
2604       offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
2605
2606       if (flag_next_runtime)
2607         {
2608           decl = TREE_PURPOSE (chain);
2609           finish_var_decl (decl, expr);
2610         }
2611       else
2612         {
2613           if (flag_typed_selectors)
2614             {
2615               tree eltlist = NULL_TREE;
2616               tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
2617               eltlist = tree_cons (NULL_TREE, expr, NULL_TREE);
2618               eltlist = tree_cons (NULL_TREE, encoding, eltlist);
2619               expr = objc_build_constructor (objc_selector_template,
2620                                              nreverse (eltlist));
2621             }
2622
2623           initlist = tree_cons (NULL_TREE, expr, initlist);
2624         }
2625     }
2626
2627   if (! flag_next_runtime)
2628     {
2629       /* Cause the selector table (previously forward-declared)
2630          to be actually output.  */
2631       initlist = tree_cons (NULL_TREE,
2632                             flag_typed_selectors
2633                             ? objc_build_constructor
2634                               (objc_selector_template,
2635                                tree_cons (NULL_TREE,
2636                                           build_int_cst (NULL_TREE, 0),
2637                                           tree_cons (NULL_TREE,
2638                                                      build_int_cst (NULL_TREE, 0),
2639                                                      NULL_TREE)))
2640                             : build_int_cst (NULL_TREE, 0), initlist);
2641       initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
2642                                          nreverse (initlist));
2643       finish_var_decl (UOBJC_SELECTOR_TABLE_decl, initlist);
2644     }
2645 }
2646
2647 static tree
2648 get_proto_encoding (tree proto)
2649 {
2650   tree encoding;
2651   if (proto)
2652     {
2653       if (! METHOD_ENCODING (proto))
2654         {
2655           encoding = encode_method_prototype (proto);
2656           METHOD_ENCODING (proto) = encoding;
2657         }
2658       else
2659         encoding = METHOD_ENCODING (proto);
2660
2661       return add_objc_string (encoding, meth_var_types);
2662     }
2663   else
2664     return build_int_cst (NULL_TREE, 0);
2665 }
2666
2667 /* sel_ref_chain is a list whose "value" fields will be instances of
2668    identifier_node that represent the selector.  LOC is the location of
2669    the @selector.  */
2670
2671 static tree
2672 build_typed_selector_reference (location_t loc, tree ident, tree prototype)
2673 {
2674   tree *chain = &sel_ref_chain;
2675   tree expr;
2676   int index = 0;
2677
2678   while (*chain)
2679     {
2680       if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
2681         goto return_at_index;
2682
2683       index++;
2684       chain = &TREE_CHAIN (*chain);
2685     }
2686
2687   *chain = tree_cons (prototype, ident, NULL_TREE);
2688
2689  return_at_index:
2690   expr = build_unary_op (loc, ADDR_EXPR,
2691                          build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2692                                           build_int_cst (NULL_TREE, index)),
2693                          1);
2694   return convert (objc_selector_type, expr);
2695 }
2696
2697 static tree
2698 build_selector_reference (location_t loc, tree ident)
2699 {
2700   tree *chain = &sel_ref_chain;
2701   tree expr;
2702   int index = 0;
2703
2704   while (*chain)
2705     {
2706       if (TREE_VALUE (*chain) == ident)
2707         return (flag_next_runtime
2708                 ? TREE_PURPOSE (*chain)
2709                 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2710                                    build_int_cst (NULL_TREE, index)));
2711
2712       index++;
2713       chain = &TREE_CHAIN (*chain);
2714     }
2715
2716   expr = (flag_next_runtime ? build_selector_reference_decl (): NULL_TREE);
2717
2718   *chain = tree_cons (expr, ident, NULL_TREE);
2719
2720   return (flag_next_runtime
2721           ? expr
2722           : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2723                              build_int_cst (NULL_TREE, index)));
2724 }
2725
2726 static GTY(()) int class_reference_idx;
2727
2728 static tree
2729 build_class_reference_decl (void)
2730 {
2731   tree decl;
2732   char buf[256];
2733
2734   sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
2735   decl = start_var_decl (objc_class_type, buf);
2736
2737   return decl;
2738 }
2739
2740 /* Create a class reference, but don't create a variable to reference
2741    it.  */
2742
2743 static void
2744 add_class_reference (tree ident)
2745 {
2746   tree chain;
2747
2748   if ((chain = cls_ref_chain))
2749     {
2750       tree tail;
2751       do
2752         {
2753           if (ident == TREE_VALUE (chain))
2754             return;
2755
2756           tail = chain;
2757           chain = TREE_CHAIN (chain);
2758         }
2759       while (chain);
2760
2761       /* Append to the end of the list */
2762       TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
2763     }
2764   else
2765     cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
2766 }
2767
2768 /* Get a class reference, creating it if necessary.  Also create the
2769    reference variable.  */
2770
2771 tree
2772 objc_get_class_reference (tree ident)
2773 {
2774   tree orig_ident = (DECL_P (ident)
2775                      ? DECL_NAME (ident)
2776                      : TYPE_P (ident)
2777                      ? OBJC_TYPE_NAME (ident)
2778                      : ident);
2779   bool local_scope = false;
2780
2781 #ifdef OBJCPLUS
2782   if (processing_template_decl)
2783     /* Must wait until template instantiation time.  */
2784     return build_min_nt (CLASS_REFERENCE_EXPR, ident);
2785 #endif
2786
2787   if (TREE_CODE (ident) == TYPE_DECL)
2788     ident = (DECL_ORIGINAL_TYPE (ident)
2789              ? DECL_ORIGINAL_TYPE (ident)
2790              : TREE_TYPE (ident));
2791
2792 #ifdef OBJCPLUS
2793   if (TYPE_P (ident) && TYPE_CONTEXT (ident)
2794       && TYPE_CONTEXT (ident) != global_namespace)
2795     local_scope = true;
2796 #endif
2797
2798   if (local_scope || !(ident = objc_is_class_name (ident)))
2799     {
2800       error ("%qE is not an Objective-C class name or alias",
2801              orig_ident);
2802       return error_mark_node;
2803     }
2804
2805   if (flag_next_runtime && !flag_zero_link)
2806     {
2807       tree *chain;
2808       tree decl;
2809
2810       for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
2811         if (TREE_VALUE (*chain) == ident)
2812           {
2813             if (! TREE_PURPOSE (*chain))
2814               TREE_PURPOSE (*chain) = build_class_reference_decl ();
2815
2816             return TREE_PURPOSE (*chain);
2817           }
2818
2819       decl = build_class_reference_decl ();
2820       *chain = tree_cons (decl, ident, NULL_TREE);
2821       return decl;
2822     }
2823   else
2824     {
2825       tree params;
2826
2827       add_class_reference (ident);
2828
2829       params = build_tree_list (NULL_TREE,
2830                                 my_build_string_pointer
2831                                 (IDENTIFIER_LENGTH (ident) + 1,
2832                                  IDENTIFIER_POINTER (ident)));
2833
2834       assemble_external (objc_get_class_decl);
2835       return build_function_call (input_location, objc_get_class_decl, params);
2836     }
2837 }
2838
2839 /* For each string section we have a chain which maps identifier nodes
2840    to decls for the strings.  */
2841
2842 static tree
2843 add_objc_string (tree ident, enum string_section section)
2844 {
2845   tree *chain, decl, type, string_expr;
2846
2847   if (section == class_names)
2848     chain = &class_names_chain;
2849   else if (section == meth_var_names)
2850     chain = &meth_var_names_chain;
2851   else if (section == meth_var_types)
2852     chain = &meth_var_types_chain;
2853   else
2854     abort ();
2855
2856   while (*chain)
2857     {
2858       if (TREE_VALUE (*chain) == ident)
2859         return convert (string_type_node,
2860                         build_unary_op (input_location,
2861                                         ADDR_EXPR, TREE_PURPOSE (*chain), 1));
2862
2863       chain = &TREE_CHAIN (*chain);
2864     }
2865
2866   decl = build_objc_string_decl (section);
2867
2868   type = build_array_type
2869          (char_type_node,
2870           build_index_type
2871           (build_int_cst (NULL_TREE,
2872                           IDENTIFIER_LENGTH (ident))));
2873   decl = start_var_decl (type, IDENTIFIER_POINTER (DECL_NAME (decl)));
2874   string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
2875                                  IDENTIFIER_POINTER (ident));
2876   finish_var_decl (decl, string_expr);
2877
2878   *chain = tree_cons (decl, ident, NULL_TREE);
2879
2880   return convert (string_type_node, build_unary_op (input_location,
2881                                                     ADDR_EXPR, decl, 1));
2882 }
2883
2884 static GTY(()) int class_names_idx;
2885 static GTY(()) int meth_var_names_idx;
2886 static GTY(()) int meth_var_types_idx;
2887
2888 static tree
2889 build_objc_string_decl (enum string_section section)
2890 {
2891   tree decl, ident;
2892   char buf[256];
2893
2894   if (section == class_names)
2895     sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
2896   else if (section == meth_var_names)
2897     sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
2898   else if (section == meth_var_types)
2899     sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
2900
2901   ident = get_identifier (buf);
2902
2903   decl = build_decl (input_location,
2904                      VAR_DECL, ident, build_array_type (char_type_node, 0));
2905   DECL_EXTERNAL (decl) = 1;
2906   TREE_PUBLIC (decl) = 0;
2907   TREE_USED (decl) = 1;
2908   TREE_CONSTANT (decl) = 1;
2909   DECL_CONTEXT (decl) = 0;
2910   DECL_ARTIFICIAL (decl) = 1;
2911 #ifdef OBJCPLUS
2912   DECL_THIS_STATIC (decl) = 1; /* squash redeclaration errors */
2913 #endif
2914
2915   make_decl_rtl (decl);
2916   pushdecl_top_level (decl);
2917
2918   return decl;
2919 }
2920
2921
2922 void
2923 objc_declare_alias (tree alias_ident, tree class_ident)
2924 {
2925   tree underlying_class;
2926
2927 #ifdef OBJCPLUS
2928   if (current_namespace != global_namespace) {
2929     error ("Objective-C declarations may only appear in global scope");
2930   }
2931 #endif /* OBJCPLUS */
2932
2933   if (!(underlying_class = objc_is_class_name (class_ident)))
2934     warning (0, "cannot find class %qE", class_ident);
2935   else if (objc_is_class_name (alias_ident))
2936     warning (0, "class %qE already exists", alias_ident);
2937   else
2938     {
2939       /* Implement @compatibility_alias as a typedef.  */
2940 #ifdef OBJCPLUS
2941       push_lang_context (lang_name_c); /* extern "C" */
2942 #endif
2943       lang_hooks.decls.pushdecl (build_decl
2944                                  (input_location,
2945                                   TYPE_DECL,
2946                                   alias_ident,
2947                                   xref_tag (RECORD_TYPE, underlying_class)));
2948 #ifdef OBJCPLUS
2949       pop_lang_context ();
2950 #endif
2951       alias_chain = tree_cons (underlying_class, alias_ident, alias_chain);
2952     }
2953 }
2954
2955 void
2956 objc_declare_class (tree ident_list)
2957 {
2958   tree list;
2959 #ifdef OBJCPLUS
2960   if (current_namespace != global_namespace) {
2961     error ("Objective-C declarations may only appear in global scope");
2962   }
2963 #endif /* OBJCPLUS */
2964
2965   for (list = ident_list; list; list = TREE_CHAIN (list))
2966     {
2967       tree ident = TREE_VALUE (list);
2968
2969       if (! objc_is_class_name (ident))
2970         {
2971           tree record = lookup_name (ident), type = record;
2972
2973           if (record)
2974             {
2975               if (TREE_CODE (record) == TYPE_DECL)
2976                 type = DECL_ORIGINAL_TYPE (record);
2977
2978               if (!TYPE_HAS_OBJC_INFO (type)
2979                   || !TYPE_OBJC_INTERFACE (type))
2980                 {
2981                   error ("%qE redeclared as different kind of symbol",
2982                          ident);
2983                   error ("previous declaration of %q+D",
2984                          record);
2985                 }
2986             }
2987
2988           record = xref_tag (RECORD_TYPE, ident);
2989           INIT_TYPE_OBJC_INFO (record);
2990           TYPE_OBJC_INTERFACE (record) = ident;
2991           class_chain = tree_cons (NULL_TREE, ident, class_chain);
2992         }
2993     }
2994 }
2995
2996 tree
2997 objc_is_class_name (tree ident)
2998 {
2999   tree chain;
3000
3001   if (ident && TREE_CODE (ident) == IDENTIFIER_NODE
3002       && identifier_global_value (ident))
3003     ident = identifier_global_value (ident);
3004   while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
3005     ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
3006
3007   if (ident && TREE_CODE (ident) == RECORD_TYPE)
3008     ident = OBJC_TYPE_NAME (ident);
3009 #ifdef OBJCPLUS
3010   if (ident && TREE_CODE (ident) == TYPE_DECL)
3011     ident = DECL_NAME (ident);
3012 #endif
3013   if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
3014     return NULL_TREE;
3015
3016   if (lookup_interface (ident))
3017     return ident;
3018
3019   for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
3020     {
3021       if (ident == TREE_VALUE (chain))
3022         return ident;
3023     }
3024
3025   for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
3026     {
3027       if (ident == TREE_VALUE (chain))
3028         return TREE_PURPOSE (chain);
3029     }
3030
3031   return 0;
3032 }
3033
3034 /* Check whether TYPE is either 'id' or 'Class'.  */
3035
3036 tree
3037 objc_is_id (tree type)
3038 {
3039   if (type && TREE_CODE (type) == IDENTIFIER_NODE
3040       && identifier_global_value (type))
3041     type = identifier_global_value (type);
3042
3043   if (type && TREE_CODE (type) == TYPE_DECL)
3044     type = TREE_TYPE (type);
3045
3046   /* NB: This function may be called before the ObjC front-end has
3047      been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL.  */
3048   return (objc_object_type && type
3049           && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
3050           ? type
3051           : NULL_TREE);
3052 }
3053
3054 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3055    class instance.  This is needed by other parts of the compiler to
3056    handle ObjC types gracefully.  */
3057
3058 tree
3059 objc_is_object_ptr (tree type)
3060 {
3061   tree ret;
3062
3063   type = TYPE_MAIN_VARIANT (type);
3064   if (!POINTER_TYPE_P (type))
3065     return 0;
3066
3067   ret = objc_is_id (type);
3068   if (!ret)
3069     ret = objc_is_class_name (TREE_TYPE (type));
3070
3071   return ret;
3072 }
3073
3074 static int
3075 objc_is_gcable_type (tree type, int or_strong_p)
3076 {
3077   tree name;
3078
3079   if (!TYPE_P (type))
3080     return 0;
3081   if (objc_is_id (TYPE_MAIN_VARIANT (type)))
3082     return 1;
3083   if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
3084     return 1;
3085   if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
3086     return 0;
3087   type = TREE_TYPE (type);
3088   if (TREE_CODE (type) != RECORD_TYPE)
3089     return 0;
3090   name = TYPE_NAME (type);
3091   return (objc_is_class_name (name) != NULL_TREE);
3092 }
3093
3094 static tree
3095 objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
3096 {
3097   if (expr == oldexpr)
3098     return newexpr;
3099
3100   switch (TREE_CODE (expr))
3101     {
3102     case COMPONENT_REF:
3103       return objc_build_component_ref
3104              (objc_substitute_decl (TREE_OPERAND (expr, 0),
3105                                     oldexpr,
3106                                     newexpr),
3107               DECL_NAME (TREE_OPERAND (expr, 1)));
3108     case ARRAY_REF:
3109       return build_array_ref (input_location,
3110                               objc_substitute_decl (TREE_OPERAND (expr, 0),
3111                                                     oldexpr,
3112                                                     newexpr),
3113                               TREE_OPERAND (expr, 1));
3114     case INDIRECT_REF:
3115       return build_indirect_ref (input_location,
3116                                  objc_substitute_decl (TREE_OPERAND (expr, 0),
3117                                                        oldexpr,
3118                                                        newexpr), RO_ARROW);
3119     default:
3120       return expr;
3121     }
3122 }
3123
3124 static tree
3125 objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
3126 {
3127   tree func_params;
3128   /* The LHS parameter contains the expression 'outervar->memberspec';
3129      we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3130      where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3131   */
3132   tree offs
3133     = objc_substitute_decl
3134       (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
3135   tree func
3136     = (flag_objc_direct_dispatch
3137        ? objc_assign_ivar_fast_decl
3138        : objc_assign_ivar_decl);
3139
3140   offs = convert (integer_type_node, build_unary_op (input_location,
3141                                                      ADDR_EXPR, offs, 0));
3142   offs = fold (offs);
3143   func_params = tree_cons (NULL_TREE,
3144         convert (objc_object_type, rhs),
3145             tree_cons (NULL_TREE, convert (objc_object_type, outervar),
3146                 tree_cons (NULL_TREE, offs,
3147                     NULL_TREE)));
3148
3149   assemble_external (func);
3150   return build_function_call (input_location, func, func_params);
3151 }
3152
3153 static tree
3154 objc_build_global_assignment (tree lhs, tree rhs)
3155 {
3156   tree func_params = tree_cons (NULL_TREE,
3157         convert (objc_object_type, rhs),
3158             tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3159                       build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3160                     NULL_TREE));
3161
3162   assemble_external (objc_assign_global_decl);
3163   return build_function_call (input_location,
3164                               objc_assign_global_decl, func_params);
3165 }
3166
3167 static tree
3168 objc_build_strong_cast_assignment (tree lhs, tree rhs)
3169 {
3170   tree func_params = tree_cons (NULL_TREE,
3171         convert (objc_object_type, rhs),
3172             tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3173                       build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3174                     NULL_TREE));
3175
3176   assemble_external (objc_assign_strong_cast_decl);
3177   return build_function_call (input_location,
3178                               objc_assign_strong_cast_decl, func_params);
3179 }
3180
3181 static int
3182 objc_is_gcable_p (tree expr)
3183 {
3184   return (TREE_CODE (expr) == COMPONENT_REF
3185           ? objc_is_gcable_p (TREE_OPERAND (expr, 1))
3186           : TREE_CODE (expr) == ARRAY_REF
3187           ? (objc_is_gcable_p (TREE_TYPE (expr))
3188              || objc_is_gcable_p (TREE_OPERAND (expr, 0)))
3189           : TREE_CODE (expr) == ARRAY_TYPE
3190           ? objc_is_gcable_p (TREE_TYPE (expr))
3191           : TYPE_P (expr)
3192           ? objc_is_gcable_type (expr, 1)
3193           : (objc_is_gcable_p (TREE_TYPE (expr))
3194              || (DECL_P (expr)
3195                  && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr)))));
3196 }
3197
3198 static int
3199 objc_is_ivar_reference_p (tree expr)
3200 {
3201   return (TREE_CODE (expr) == ARRAY_REF
3202           ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
3203           : TREE_CODE (expr) == COMPONENT_REF
3204           ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
3205           : 0);
3206 }
3207
3208 static int
3209 objc_is_global_reference_p (tree expr)
3210 {
3211   return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR
3212           ? objc_is_global_reference_p (TREE_OPERAND (expr, 0))
3213           : DECL_P (expr)
3214           ? (!DECL_CONTEXT (expr) || TREE_STATIC (expr))
3215           : 0);
3216 }
3217
3218 tree
3219 objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs)
3220 {
3221   tree result = NULL_TREE, outer;
3222   int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0;
3223
3224   /* See if we have any lhs casts, and strip them out.  NB: The lvalue casts
3225      will have been transformed to the form '*(type *)&expr'.  */
3226   if (TREE_CODE (lhs) == INDIRECT_REF)
3227     {
3228       outer = TREE_OPERAND (lhs, 0);
3229
3230       while (!strong_cast_p
3231              && (CONVERT_EXPR_P (outer)
3232                  || TREE_CODE (outer) == NON_LVALUE_EXPR))
3233         {
3234           tree lhstype = TREE_TYPE (outer);
3235
3236           /* Descend down the cast chain, and record the first objc_gc
3237              attribute found.  */
3238           if (POINTER_TYPE_P (lhstype))
3239             {
3240               tree attr
3241                 = lookup_attribute ("objc_gc",
3242                                     TYPE_ATTRIBUTES (TREE_TYPE (lhstype)));
3243
3244               if (attr)
3245                 strong_cast_p = 1;
3246             }
3247
3248           outer = TREE_OPERAND (outer, 0);
3249         }
3250     }
3251
3252   /* If we have a __strong cast, it trumps all else.  */
3253   if (strong_cast_p)
3254     {
3255       if (modifycode != NOP_EXPR)
3256         goto invalid_pointer_arithmetic;
3257
3258       if (warn_assign_intercept)
3259         warning (0, "strong-cast assignment has been intercepted");
3260
3261       result = objc_build_strong_cast_assignment (lhs, rhs);
3262
3263       goto exit_point;
3264     }
3265
3266   /* the lhs must be of a suitable type, regardless of its underlying
3267      structure.  */
3268   if (!objc_is_gcable_p (lhs))
3269     goto exit_point;
3270
3271   outer = lhs;
3272
3273   while (outer
3274          && (TREE_CODE (outer) == COMPONENT_REF
3275              || TREE_CODE (outer) == ARRAY_REF))
3276     outer = TREE_OPERAND (outer, 0);
3277
3278   if (TREE_CODE (outer) == INDIRECT_REF)
3279     {
3280       outer = TREE_OPERAND (outer, 0);
3281       indirect_p = 1;
3282     }
3283
3284   outer_gc_p = objc_is_gcable_p (outer);
3285
3286   /* Handle ivar assignments. */
3287   if (objc_is_ivar_reference_p (lhs))
3288     {
3289       /* if the struct to the left of the ivar is not an Objective-C object (__strong
3290          doesn't cut it here), the best we can do here is suggest a cast.  */
3291       if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
3292         {
3293           /* We may still be able to use the global write barrier... */
3294           if (!indirect_p && objc_is_global_reference_p (outer))
3295             goto global_reference;
3296
3297          suggest_cast:
3298           if (modifycode == NOP_EXPR)
3299             {
3300               if (warn_assign_intercept)
3301                 warning (0, "strong-cast may possibly be needed");
3302             }
3303
3304           goto exit_point;
3305         }
3306
3307       if (modifycode != NOP_EXPR)
3308         goto invalid_pointer_arithmetic;
3309
3310       if (warn_assign_intercept)
3311         warning (0, "instance variable assignment has been intercepted");
3312
3313       result = objc_build_ivar_assignment (outer, lhs, rhs);
3314
3315       goto exit_point;
3316     }
3317
3318   /* Likewise, intercept assignment to global/static variables if their type is
3319      GC-marked.  */
3320   if (objc_is_global_reference_p (outer))
3321     {
3322       if (indirect_p)
3323         goto suggest_cast;
3324
3325      global_reference:
3326       if (modifycode != NOP_EXPR)
3327         {
3328          invalid_pointer_arithmetic:
3329           if (outer_gc_p)
3330             warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3331
3332           goto exit_point;
3333         }
3334
3335       if (warn_assign_intercept)
3336         warning (0, "global/static variable assignment has been intercepted");
3337
3338       result = objc_build_global_assignment (lhs, rhs);
3339     }
3340
3341   /* In all other cases, fall back to the normal mechanism.  */
3342  exit_point:
3343   return result;
3344 }
3345
3346 struct GTY(()) interface_tuple {
3347   tree id;
3348   tree class_name;
3349 };
3350
3351 static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
3352
3353 static hashval_t
3354 hash_interface (const void *p)
3355 {
3356   const struct interface_tuple *d = (const struct interface_tuple *) p;
3357   return IDENTIFIER_HASH_VALUE (d->id);
3358 }
3359
3360 static int
3361 eq_interface (const void *p1, const void *p2)
3362 {
3363   const struct interface_tuple *d = (const struct interface_tuple *) p1;
3364   return d->id == p2;
3365 }
3366
3367 static tree
3368 lookup_interface (tree ident)
3369 {
3370 #ifdef OBJCPLUS
3371   if (ident && TREE_CODE (ident) == TYPE_DECL)
3372     ident = DECL_NAME (ident);
3373 #endif
3374
3375   if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
3376     return NULL_TREE;
3377
3378   {
3379     struct interface_tuple **slot;
3380     tree i = NULL_TREE;
3381
3382     if (interface_htab)
3383       {
3384         slot = (struct interface_tuple **)
3385           htab_find_slot_with_hash (interface_htab, ident,
3386                                     IDENTIFIER_HASH_VALUE (ident),
3387                                     NO_INSERT);
3388         if (slot && *slot)
3389           i = (*slot)->class_name;
3390       }
3391     return i;
3392   }
3393 }
3394
3395 /* Implement @defs (<classname>) within struct bodies.  */
3396
3397 tree
3398 objc_get_class_ivars (tree class_name)
3399 {
3400   tree interface = lookup_interface (class_name);
3401
3402   if (interface)
3403     return get_class_ivars (interface, true);
3404
3405   error ("cannot find interface declaration for %qE",
3406          class_name);
3407
3408   return error_mark_node;
3409 }
3410
3411 /* Used by: build_private_template, continue_class,
3412    and for @defs constructs.  */
3413
3414 static tree
3415 get_class_ivars (tree interface, bool inherited)
3416 {
3417   tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
3418
3419   /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
3420      by the current class (i.e., they do not include super-class ivars).
3421      However, the CLASS_IVARS list will be side-effected by a call to
3422      finish_struct(), which will fill in field offsets.  */
3423   if (!CLASS_IVARS (interface))
3424     CLASS_IVARS (interface) = ivar_chain;
3425
3426   if (!inherited)
3427     return ivar_chain;
3428
3429   while (CLASS_SUPER_NAME (interface))
3430     {
3431       /* Prepend super-class ivars.  */
3432       interface = lookup_interface (CLASS_SUPER_NAME (interface));
3433       ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
3434                             ivar_chain);
3435     }
3436
3437   return ivar_chain;
3438 }
3439
3440 static tree
3441 objc_create_temporary_var (tree type)
3442 {
3443   tree decl;
3444
3445   decl = build_decl (input_location,
3446                      VAR_DECL, NULL_TREE, type);
3447   TREE_USED (decl) = 1;
3448   DECL_ARTIFICIAL (decl) = 1;
3449   DECL_IGNORED_P (decl) = 1;
3450   DECL_CONTEXT (decl) = current_function_decl;
3451
3452   return decl;
3453 }
3454 \f
3455 /* Exception handling constructs.  We begin by having the parser do most
3456    of the work and passing us blocks.  What we do next depends on whether
3457    we're doing "native" exception handling or legacy Darwin setjmp exceptions.
3458    We abstract all of this in a handful of appropriately named routines.  */
3459
3460 /* Stack of open try blocks.  */
3461
3462 struct objc_try_context
3463 {
3464   struct objc_try_context *outer;
3465
3466   /* Statements (or statement lists) as processed by the parser.  */
3467   tree try_body;
3468   tree finally_body;
3469
3470   /* Some file position locations.  */
3471   location_t try_locus;
3472   location_t end_try_locus;
3473   location_t end_catch_locus;
3474   location_t finally_locus;
3475   location_t end_finally_locus;
3476
3477   /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
3478      of a TRY_CATCH_EXPR.  Even when doing Darwin setjmp.  */
3479   tree catch_list;
3480
3481   /* The CATCH_EXPR of an open @catch clause.  */
3482   tree current_catch;
3483
3484   /* The VAR_DECL holding the Darwin equivalent of __builtin_eh_pointer.  */
3485   tree caught_decl;
3486   tree stack_decl;
3487   tree rethrow_decl;
3488 };
3489
3490 static struct objc_try_context *cur_try_context;
3491
3492 static GTY(()) tree objc_eh_personality_decl;
3493
3494 /* This hook, called via lang_eh_runtime_type, generates a runtime object
3495    that represents TYPE.  For Objective-C, this is just the class name.  */
3496 /* ??? Isn't there a class object or some such?  Is it easy to get?  */
3497
3498 #ifndef OBJCPLUS
3499 tree
3500 objc_eh_runtime_type (tree type)
3501 {
3502   return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
3503 }
3504
3505 tree
3506 objc_eh_personality (void)
3507 {
3508   if (!flag_objc_sjlj_exceptions
3509       && !objc_eh_personality_decl)
3510     objc_eh_personality_decl
3511       = build_personality_function (USING_SJLJ_EXCEPTIONS
3512                                     ? "__gnu_objc_personality_sj0"
3513                                     : "__gnu_objc_personality_v0");
3514
3515   return objc_eh_personality_decl;
3516 }
3517 #endif
3518
3519 /* Build __builtin_eh_pointer, or the moral equivalent.  In the case
3520    of Darwin, we'll arrange for it to be initialized (and associated
3521    with a binding) later.  */
3522
3523 static tree
3524 objc_build_exc_ptr (void)
3525 {
3526   if (flag_objc_sjlj_exceptions)
3527     {
3528       tree var = cur_try_context->caught_decl;
3529       if (!var)
3530         {
3531           var = objc_create_temporary_var (objc_object_type);
3532           cur_try_context->caught_decl = var;
3533         }
3534       return var;
3535     }
3536   else
3537     {
3538       tree t;
3539       t = built_in_decls[BUILT_IN_EH_POINTER];
3540       t = build_call_expr (t, 1, integer_zero_node);
3541       return fold_convert (objc_object_type, t);
3542     }
3543 }
3544
3545 /* Build "objc_exception_try_exit(&_stack)".  */
3546
3547 static tree
3548 next_sjlj_build_try_exit (void)
3549 {
3550   tree t;
3551   t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3552   t = tree_cons (NULL, t, NULL);
3553   t = build_function_call (input_location,
3554                            objc_exception_try_exit_decl, t);
3555   return t;
3556 }
3557
3558 /* Build
3559         objc_exception_try_enter (&_stack);
3560         if (_setjmp(&_stack.buf))
3561           ;
3562         else
3563           ;
3564    Return the COND_EXPR.  Note that the THEN and ELSE fields are left
3565    empty, ready for the caller to fill them in.  */
3566
3567 static tree
3568 next_sjlj_build_enter_and_setjmp (void)
3569 {
3570   tree t, enter, sj, cond;
3571
3572   t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3573   t = tree_cons (NULL, t, NULL);
3574   enter = build_function_call (input_location,
3575                                objc_exception_try_enter_decl, t);
3576
3577   t = objc_build_component_ref (cur_try_context->stack_decl,
3578                                 get_identifier ("buf"));
3579   t = build_fold_addr_expr_loc (input_location, t);
3580 #ifdef OBJCPLUS
3581   /* Convert _setjmp argument to type that is expected.  */
3582   if (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl)))
3583     t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
3584   else
3585     t = convert (ptr_type_node, t);
3586 #else
3587   t = convert (ptr_type_node, t);
3588 #endif
3589   t = tree_cons (NULL, t, NULL);
3590   sj = build_function_call (input_location,
3591                             objc_setjmp_decl, t);
3592
3593   cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
3594   cond = c_common_truthvalue_conversion (input_location, cond);
3595
3596   return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
3597 }
3598
3599 /* Build:
3600
3601    DECL = objc_exception_extract(&_stack);  */
3602
3603 static tree
3604 next_sjlj_build_exc_extract (tree decl)
3605 {
3606   tree t;
3607
3608   t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3609   t = tree_cons (NULL, t, NULL);
3610   t = build_function_call (input_location,
3611                            objc_exception_extract_decl, t);
3612   t = convert (TREE_TYPE (decl), t);
3613   t = build2 (MODIFY_EXPR, void_type_node, decl, t);
3614
3615   return t;
3616 }
3617
3618 /* Build
3619         if (objc_exception_match(obj_get_class(TYPE), _caught)
3620           BODY
3621         else if (...)
3622           ...
3623         else
3624           {
3625             _rethrow = _caught;
3626             objc_exception_try_exit(&_stack);
3627           }
3628    from the sequence of CATCH_EXPRs in the current try context.  */
3629
3630 static tree
3631 next_sjlj_build_catch_list (void)
3632 {
3633   tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
3634   tree catch_seq, t;
3635   tree *last = &catch_seq;
3636   bool saw_id = false;
3637
3638   for (; !tsi_end_p (i); tsi_next (&i))
3639     {
3640       tree stmt = tsi_stmt (i);
3641       tree type = CATCH_TYPES (stmt);
3642       tree body = CATCH_BODY (stmt);
3643
3644       if (type == NULL)
3645         {
3646           *last = body;
3647           saw_id = true;
3648           break;
3649         }
3650       else
3651         {
3652           tree args, cond;
3653
3654           if (type == error_mark_node)
3655             cond = error_mark_node;
3656           else
3657             {
3658               args = tree_cons (NULL, cur_try_context->caught_decl, NULL);
3659               t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
3660               args = tree_cons (NULL, t, args);
3661               t = build_function_call (input_location,
3662                                        objc_exception_match_decl, args);
3663               cond = c_common_truthvalue_conversion (input_location, t);
3664             }
3665           t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
3666           SET_EXPR_LOCATION (t, EXPR_LOCATION (stmt));
3667
3668           *last = t;
3669           last = &COND_EXPR_ELSE (t);
3670         }
3671     }
3672
3673   if (!saw_id)
3674     {
3675       t = build2 (MODIFY_EXPR, void_type_node, cur_try_context->rethrow_decl,
3676                   cur_try_context->caught_decl);
3677       SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
3678       append_to_statement_list (t, last);
3679
3680       t = next_sjlj_build_try_exit ();
3681       SET_EXPR_LOCATION (t, cur_try_context->end_catch_locus);
3682       append_to_statement_list (t, last);
3683     }
3684
3685   return catch_seq;
3686 }
3687
3688 /* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
3689    exception handling.  We aim to build:
3690
3691         {
3692           struct _objc_exception_data _stack;
3693           id _rethrow = 0;
3694           try
3695             {
3696               objc_exception_try_enter (&_stack);
3697               if (_setjmp(&_stack.buf))
3698                 {
3699                   id _caught = objc_exception_extract(&_stack);
3700                   objc_exception_try_enter (&_stack);
3701                   if (_setjmp(&_stack.buf))
3702                     _rethrow = objc_exception_extract(&_stack);
3703                   else
3704                     CATCH-LIST
3705                 }
3706               else
3707                 TRY-BLOCK
3708             }
3709           finally
3710             {
3711               if (!_rethrow)
3712                 objc_exception_try_exit(&_stack);
3713               FINALLY-BLOCK
3714               if (_rethrow)
3715                 objc_exception_throw(_rethrow);
3716             }
3717         }
3718
3719    If CATCH-LIST is empty, we can omit all of the block containing
3720    "_caught" except for the setting of _rethrow.  Note the use of
3721    a real TRY_FINALLY_EXPR here, which is not involved in EH per-se,
3722    but handles goto and other exits from the block.  */
3723
3724 static tree
3725 next_sjlj_build_try_catch_finally (void)
3726 {
3727   tree rethrow_decl, stack_decl, t;
3728   tree catch_seq, try_fin, bind;
3729
3730   /* Create the declarations involved.  */
3731   t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
3732   stack_decl = objc_create_temporary_var (t);
3733   cur_try_context->stack_decl = stack_decl;
3734
3735   rethrow_decl = objc_create_temporary_var (objc_object_type);
3736   cur_try_context->rethrow_decl = rethrow_decl;
3737   TREE_CHAIN (rethrow_decl) = stack_decl;
3738
3739   /* Build the outermost variable binding level.  */
3740   bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
3741   SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
3742   TREE_SIDE_EFFECTS (bind) = 1;
3743
3744   /* Initialize rethrow_decl.  */
3745   t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
3746               convert (objc_object_type, null_pointer_node));
3747   SET_EXPR_LOCATION (t, cur_try_context->try_locus);
3748   append_to_statement_list (t, &BIND_EXPR_BODY (bind));
3749
3750   /* Build the outermost TRY_FINALLY_EXPR.  */
3751   try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
3752   SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus);
3753   TREE_SIDE_EFFECTS (try_fin) = 1;
3754   append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind));
3755
3756   /* Create the complete catch sequence.  */
3757   if (cur_try_context->catch_list)
3758     {
3759       tree caught_decl = objc_build_exc_ptr ();
3760       catch_seq = build_stmt (input_location, BIND_EXPR, caught_decl, NULL, NULL);
3761       TREE_SIDE_EFFECTS (catch_seq) = 1;
3762
3763       t = next_sjlj_build_exc_extract (caught_decl);
3764       append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
3765
3766       t = next_sjlj_build_enter_and_setjmp ();
3767       COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (rethrow_decl);
3768       COND_EXPR_ELSE (t) = next_sjlj_build_catch_list ();
3769       append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
3770     }
3771   else
3772     catch_seq = next_sjlj_build_exc_extract (rethrow_decl);
3773   SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
3774
3775   /* Build the main register-and-try if statement.  */
3776   t = next_sjlj_build_enter_and_setjmp ();
3777   SET_EXPR_LOCATION (t, cur_try_context->try_locus);
3778   COND_EXPR_THEN (t) = catch_seq;
3779   COND_EXPR_ELSE (t) = cur_try_context->try_body;
3780   TREE_OPERAND (try_fin, 0) = t;
3781
3782   /* Build the complete FINALLY statement list.  */
3783   t = next_sjlj_build_try_exit ();
3784   t = build_stmt (input_location, COND_EXPR,
3785                   c_common_truthvalue_conversion
3786                     (input_location, rethrow_decl),
3787                   NULL, t);
3788   SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
3789   append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
3790
3791   append_to_statement_list (cur_try_context->finally_body,
3792                             &TREE_OPERAND (try_fin, 1));
3793
3794   t = tree_cons (NULL, rethrow_decl, NULL);
3795   t = build_function_call (input_location,
3796                            objc_exception_throw_decl, t);
3797   t = build_stmt (input_location, COND_EXPR,
3798                   c_common_truthvalue_conversion (input_location,
3799                                                   rethrow_decl),
3800                   t, NULL);
3801   SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
3802   append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
3803
3804   return bind;
3805 }
3806
3807 /* Called just after parsing the @try and its associated BODY.  We now
3808    must prepare for the tricky bits -- handling the catches and finally.  */
3809
3810 void
3811 objc_begin_try_stmt (location_t try_locus, tree body)
3812 {
3813   struct objc_try_context *c = XCNEW (struct objc_try_context);
3814   c->outer = cur_try_context;
3815   c->try_body = body;
3816   c->try_locus = try_locus;
3817   c->end_try_locus = input_location;
3818   cur_try_context = c;
3819
3820   if (flag_objc_sjlj_exceptions)
3821     {
3822       /* On Darwin, ObjC exceptions require a sufficiently recent
3823          version of the runtime, so the user must ask for them explicitly.  */
3824       if (!flag_objc_exceptions)
3825         warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
3826                  "exception syntax");
3827     }
3828
3829   if (flag_objc_sjlj_exceptions)
3830     objc_mark_locals_volatile (NULL);
3831 }
3832
3833 /* Called just after parsing "@catch (parm)".  Open a binding level,
3834    enter DECL into the binding level, and initialize it.  Leave the
3835    binding level open while the body of the compound statement is parsed.  */
3836
3837 void
3838 objc_begin_catch_clause (tree decl)
3839 {
3840   tree compound, type, t;
3841
3842   /* Begin a new scope that the entire catch clause will live in.  */
3843   compound = c_begin_compound_stmt (true);
3844
3845   /* The parser passed in a PARM_DECL, but what we really want is a VAR_DECL.  */
3846   decl = build_decl (input_location,
3847                      VAR_DECL, DECL_NAME (decl), TREE_TYPE (decl));
3848   lang_hooks.decls.pushdecl (decl);
3849
3850   /* Since a decl is required here by syntax, don't warn if its unused.  */
3851   /* ??? As opposed to __attribute__((unused))?  Anyway, this appears to
3852      be what the previous objc implementation did.  */
3853   TREE_USED (decl) = 1;
3854
3855   /* Verify that the type of the catch is valid.  It must be a pointer
3856      to an Objective-C class, or "id" (which is catch-all).  */
3857   type = TREE_TYPE (decl);
3858
3859   if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
3860     type = NULL;
3861   else if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
3862     {
3863       error ("@catch parameter is not a known Objective-C class type");
3864       type = error_mark_node;
3865     }
3866   else if (cur_try_context->catch_list)
3867     {
3868       /* Examine previous @catch clauses and see if we've already
3869          caught the type in question.  */
3870       tree_stmt_iterator i = tsi_start (cur_try_context->catch_list);
3871       for (; !tsi_end_p (i); tsi_next (&i))
3872         {
3873           tree stmt = tsi_stmt (i);
3874           t = CATCH_TYPES (stmt);
3875           if (t == error_mark_node)
3876             continue;
3877           if (!t || DERIVED_FROM_P (TREE_TYPE (t), TREE_TYPE (type)))
3878             {
3879               warning (0, "exception of type %<%T%> will be caught",
3880                        TREE_TYPE (type));
3881               warning_at  (EXPR_LOCATION (stmt), 0, "   by earlier handler for %<%T%>",
3882                            TREE_TYPE (t ? t : objc_object_type));
3883               break;
3884             }
3885         }
3886     }
3887
3888   /* Record the data for the catch in the try context so that we can
3889      finalize it later.  */
3890   t = build_stmt (input_location, CATCH_EXPR, type, compound);
3891   cur_try_context->current_catch = t;
3892
3893   /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime.  */
3894   t = objc_build_exc_ptr ();
3895   t = convert (TREE_TYPE (decl), t);
3896   t = build2 (MODIFY_EXPR, void_type_node, decl, t);
3897   add_stmt (t);
3898 }
3899
3900 /* Called just after parsing the closing brace of a @catch clause.  Close
3901    the open binding level, and record a CATCH_EXPR for it.  */
3902
3903 void
3904 objc_finish_catch_clause (void)
3905 {
3906   tree c = cur_try_context->current_catch;
3907   cur_try_context->current_catch = NULL;
3908   cur_try_context->end_catch_locus = input_location;
3909
3910   CATCH_BODY (c) = c_end_compound_stmt (input_location, CATCH_BODY (c), 1);
3911   append_to_statement_list (c, &cur_try_context->catch_list);
3912 }
3913
3914 /* Called after parsing a @finally clause and its associated BODY.
3915    Record the body for later placement.  */
3916
3917 void
3918 objc_build_finally_clause (location_t finally_locus, tree body)
3919 {
3920   cur_try_context->finally_body = body;
3921   cur_try_context->finally_locus = finally_locus;
3922   cur_try_context->end_finally_locus = input_location;
3923 }
3924
3925 /* Called to finalize a @try construct.  */
3926
3927 tree
3928 objc_finish_try_stmt (void)
3929 {
3930   struct objc_try_context *c = cur_try_context;
3931   tree stmt;
3932
3933   if (c->catch_list == NULL && c->finally_body == NULL)
3934     error ("%<@try%> without %<@catch%> or %<@finally%>");
3935
3936   /* If we're doing Darwin setjmp exceptions, build the big nasty.  */
3937   if (flag_objc_sjlj_exceptions)
3938     {
3939       bool save = in_late_binary_op;
3940       in_late_binary_op = true;
3941       if (!cur_try_context->finally_body)
3942         {
3943           cur_try_context->finally_locus = input_location;
3944           cur_try_context->end_finally_locus = input_location;
3945         }
3946       stmt = next_sjlj_build_try_catch_finally ();
3947       in_late_binary_op = save;
3948     }
3949   else
3950     {
3951       /* Otherwise, nest the CATCH inside a FINALLY.  */
3952       stmt = c->try_body;
3953       if (c->catch_list)
3954         {
3955           stmt = build_stmt (input_location, TRY_CATCH_EXPR, stmt, c->catch_list);
3956           SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
3957         }
3958       if (c->finally_body)
3959         {
3960           stmt = build_stmt (input_location, TRY_FINALLY_EXPR, stmt, c->finally_body);
3961           SET_EXPR_LOCATION (stmt, cur_try_context->try_locus);
3962         }
3963     }
3964   add_stmt (stmt);
3965
3966   cur_try_context = c->outer;
3967   free (c);
3968   return stmt;
3969 }
3970
3971 tree
3972 objc_build_throw_stmt (location_t loc, tree throw_expr)
3973 {
3974   tree args;
3975
3976   if (flag_objc_sjlj_exceptions)
3977     {
3978       /* On Darwin, ObjC exceptions require a sufficiently recent
3979          version of the runtime, so the user must ask for them explicitly.  */
3980       if (!flag_objc_exceptions)
3981         warning (0, "use %<-fobjc-exceptions%> to enable Objective-C "
3982                  "exception syntax");
3983     }
3984
3985   if (throw_expr == NULL)
3986     {
3987       /* If we're not inside a @catch block, there is no "current
3988          exception" to be rethrown.  */
3989       if (cur_try_context == NULL
3990           || cur_try_context->current_catch == NULL)
3991         {
3992           error_at (loc, "%<@throw%> (rethrow) used outside of a @catch block");
3993           return NULL_TREE;
3994         }
3995
3996       /* Otherwise the object is still sitting in the EXC_PTR_EXPR
3997          value that we get from the runtime.  */
3998       throw_expr = objc_build_exc_ptr ();
3999     }
4000
4001   /* A throw is just a call to the runtime throw function with the
4002      object as a parameter.  */
4003   args = tree_cons (NULL, throw_expr, NULL);
4004   return add_stmt (build_function_call (loc,
4005                                         objc_exception_throw_decl, args));
4006 }
4007
4008 tree
4009 objc_build_synchronized (location_t start_locus, tree mutex, tree body)
4010 {
4011   tree args, call;
4012
4013   /* First lock the mutex.  */
4014   mutex = save_expr (mutex);
4015   args = tree_cons (NULL, mutex, NULL);
4016   call = build_function_call (input_location,
4017                               objc_sync_enter_decl, args);
4018   SET_EXPR_LOCATION (call, start_locus);
4019   add_stmt (call);
4020
4021   /* Build the mutex unlock.  */
4022   args = tree_cons (NULL, mutex, NULL);
4023   call = build_function_call (input_location,
4024                               objc_sync_exit_decl, args);
4025   SET_EXPR_LOCATION (call, input_location);
4026
4027   /* Put the that and the body in a TRY_FINALLY.  */
4028   objc_begin_try_stmt (start_locus, body);
4029   objc_build_finally_clause (input_location, call);
4030   return objc_finish_try_stmt ();
4031 }
4032
4033 \f
4034 /* Predefine the following data type:
4035
4036    struct _objc_exception_data
4037    {
4038      int buf[OBJC_JBLEN];
4039      void *pointers[4];
4040    }; */
4041
4042 /* The following yuckiness should prevent users from having to #include
4043    <setjmp.h> in their code... */
4044
4045 /* Define to a harmless positive value so the below code doesn't die.  */
4046 #ifndef OBJC_JBLEN
4047 #define OBJC_JBLEN 18
4048 #endif
4049
4050 static void
4051 build_next_objc_exception_stuff (void)
4052 {
4053   tree field_decl, field_decl_chain, index, temp_type;
4054
4055   objc_exception_data_template
4056     = objc_start_struct (get_identifier (UTAG_EXCDATA));
4057
4058   /* int buf[OBJC_JBLEN]; */
4059
4060   index = build_index_type (build_int_cst (NULL_TREE, OBJC_JBLEN - 1));
4061   field_decl = create_field_decl (build_array_type (integer_type_node, index),
4062                                   "buf");
4063   field_decl_chain = field_decl;
4064
4065   /* void *pointers[4]; */
4066
4067   index = build_index_type (build_int_cst (NULL_TREE, 4 - 1));
4068   field_decl = create_field_decl (build_array_type (ptr_type_node, index),
4069                                   "pointers");
4070   chainon (field_decl_chain, field_decl);
4071
4072   objc_finish_struct (objc_exception_data_template, field_decl_chain);
4073
4074   /* int _setjmp(...); */
4075   /* If the user includes <setjmp.h>, this shall be superseded by
4076      'int _setjmp(jmp_buf);' */
4077   temp_type = build_function_type (integer_type_node, NULL_TREE);
4078   objc_setjmp_decl
4079     = add_builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
4080
4081   /* id objc_exception_extract(struct _objc_exception_data *); */
4082   temp_type
4083     = build_function_type (objc_object_type,
4084                            tree_cons (NULL_TREE,
4085                                       build_pointer_type (objc_exception_data_template),
4086                                       OBJC_VOID_AT_END));
4087   objc_exception_extract_decl
4088     = add_builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL,
4089                             NULL_TREE);
4090   /* void objc_exception_try_enter(struct _objc_exception_data *); */
4091   /* void objc_exception_try_exit(struct _objc_exception_data *); */
4092   temp_type
4093     = build_function_type (void_type_node,
4094                            tree_cons (NULL_TREE,
4095                                       build_pointer_type (objc_exception_data_template),
4096                                       OBJC_VOID_AT_END));
4097   objc_exception_try_enter_decl
4098     = add_builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL,
4099                             NULL_TREE);
4100   objc_exception_try_exit_decl
4101     = add_builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL,
4102                             NULL_TREE);
4103
4104   /* int objc_exception_match(id, id); */
4105   temp_type
4106     = build_function_type (integer_type_node,
4107                            tree_cons (NULL_TREE, objc_object_type,
4108                                       tree_cons (NULL_TREE, objc_object_type,
4109                                                  OBJC_VOID_AT_END)));
4110   objc_exception_match_decl
4111     = add_builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL,
4112                             NULL_TREE);
4113
4114   /* id objc_assign_ivar (id, id, unsigned int); */
4115   /* id objc_assign_ivar_Fast (id, id, unsigned int)
4116        __attribute__ ((hard_coded_address (OFFS_ASSIGNIVAR_FAST))); */
4117   temp_type
4118     = build_function_type (objc_object_type,
4119                            tree_cons
4120                            (NULL_TREE, objc_object_type,
4121                             tree_cons (NULL_TREE, objc_object_type,
4122                                        tree_cons (NULL_TREE,
4123                                                   unsigned_type_node,
4124                                                   OBJC_VOID_AT_END))));
4125   objc_assign_ivar_decl
4126     = add_builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN,
4127                             NULL, NULL_TREE);
4128 #ifdef OFFS_ASSIGNIVAR_FAST
4129   objc_assign_ivar_fast_decl
4130     = add_builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
4131                             NOT_BUILT_IN, NULL, NULL_TREE);
4132   DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
4133     = tree_cons (get_identifier ("hard_coded_address"),
4134                  build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
4135                  NULL_TREE);
4136 #else
4137   /* Default to slower ivar method.  */
4138   objc_assign_ivar_fast_decl = objc_assign_ivar_decl;
4139 #endif
4140
4141   /* id objc_assign_global (id, id *); */
4142   /* id objc_assign_strongCast (id, id *); */
4143   temp_type = build_function_type (objc_object_type,
4144                 tree_cons (NULL_TREE, objc_object_type,
4145                     tree_cons (NULL_TREE, build_pointer_type (objc_object_type),
4146                         OBJC_VOID_AT_END)));
4147   objc_assign_global_decl
4148         = add_builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL,
4149                                 NULL_TREE);
4150   objc_assign_strong_cast_decl
4151         = add_builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL,
4152                                 NULL_TREE);
4153 }
4154
4155 static void
4156 build_objc_exception_stuff (void)
4157 {
4158   tree noreturn_list, nothrow_list, temp_type;
4159
4160   noreturn_list = tree_cons (get_identifier ("noreturn"), NULL, NULL);
4161   nothrow_list = tree_cons (get_identifier ("nothrow"), NULL, NULL);
4162
4163   /* void objc_exception_throw(id) __attribute__((noreturn)); */
4164   /* void objc_sync_enter(id); */
4165   /* void objc_sync_exit(id); */
4166   temp_type = build_function_type (void_type_node,
4167                                    tree_cons (NULL_TREE, objc_object_type,
4168                                               OBJC_VOID_AT_END));
4169   objc_exception_throw_decl
4170     = add_builtin_function (TAG_EXCEPTIONTHROW, temp_type, 0, NOT_BUILT_IN, NULL,
4171                             noreturn_list);
4172   objc_sync_enter_decl
4173     = add_builtin_function (TAG_SYNCENTER, temp_type, 0, NOT_BUILT_IN,
4174                             NULL, nothrow_list);
4175   objc_sync_exit_decl
4176     = add_builtin_function (TAG_SYNCEXIT, temp_type, 0, NOT_BUILT_IN,
4177                             NULL, nothrow_list);
4178 }
4179
4180 /* Construct a C struct corresponding to ObjC class CLASS, with the same
4181    name as the class:
4182
4183    struct <classname> {
4184      struct _objc_class *isa;
4185      ...
4186    };  */
4187
4188 static void
4189 build_private_template (tree klass)
4190 {
4191   if (!CLASS_STATIC_TEMPLATE (klass))
4192     {
4193       tree record = objc_build_struct (klass,
4194                                        get_class_ivars (klass, false),
4195                                        CLASS_SUPER_NAME (klass));
4196