OSDN Git Service

fix PR23716
[pf3gnuchains/gcc-fork.git] / 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   /* We reserve the right for the runtime to use/modify these variables
1528      in ways that are opaque to us.  */
1529   DECL_PRESERVE_P (var) = 1;
1530 }
1531
1532 /* Find the decl for the constant string class reference.  This is only
1533    used for the NeXT runtime.  */
1534
1535 static tree
1536 setup_string_decl (void)
1537 {
1538   char *name;
1539   size_t length;
1540
1541   /* %s in format will provide room for terminating null */
1542   length = strlen (STRING_OBJECT_GLOBAL_FORMAT)
1543            + strlen (constant_string_class_name);
1544   name = XNEWVEC (char, length);
1545   sprintf (name, STRING_OBJECT_GLOBAL_FORMAT,
1546            constant_string_class_name);
1547   constant_string_global_id = get_identifier (name);
1548   string_class_decl = lookup_name (constant_string_global_id);
1549
1550   return string_class_decl;
1551 }
1552
1553 /* Purpose: "play" parser, creating/installing representations
1554    of the declarations that are required by Objective-C.
1555
1556    Model:
1557
1558         type_spec--------->sc_spec
1559         (tree_list)        (tree_list)
1560             |                  |
1561             |                  |
1562         identifier_node    identifier_node  */
1563
1564 static void
1565 synth_module_prologue (void)
1566 {
1567   tree type;
1568   enum debug_info_type save_write_symbols = write_symbols;
1569   const struct gcc_debug_hooks *const save_hooks = debug_hooks;
1570
1571   /* Suppress outputting debug symbols, because
1572      dbxout_init hasn't been called yet.  */
1573   write_symbols = NO_DEBUG;
1574   debug_hooks = &do_nothing_debug_hooks;
1575
1576 #ifdef OBJCPLUS
1577   push_lang_context (lang_name_c); /* extern "C" */
1578 #endif
1579
1580   /* The following are also defined in <objc/objc.h> and friends.  */
1581
1582   objc_object_id = get_identifier (TAG_OBJECT);
1583   objc_class_id = get_identifier (TAG_CLASS);
1584
1585   objc_object_reference = xref_tag (RECORD_TYPE, objc_object_id);
1586   objc_class_reference = xref_tag (RECORD_TYPE, objc_class_id);
1587
1588   objc_object_type = build_pointer_type (objc_object_reference);
1589   objc_class_type = build_pointer_type (objc_class_reference);
1590
1591   objc_object_name = get_identifier (OBJECT_TYPEDEF_NAME);
1592   objc_class_name = get_identifier (CLASS_TYPEDEF_NAME);
1593
1594   /* Declare the 'id' and 'Class' typedefs.  */
1595
1596   type = lang_hooks.decls.pushdecl (build_decl (input_location,
1597                                                 TYPE_DECL,
1598                                                 objc_object_name,
1599                                                 objc_object_type));
1600   TREE_NO_WARNING (type) = 1;
1601   type = lang_hooks.decls.pushdecl (build_decl (input_location,
1602                                                 TYPE_DECL,
1603                                                 objc_class_name,
1604                                                 objc_class_type));
1605   TREE_NO_WARNING (type) = 1;
1606
1607   /* Forward-declare '@interface Protocol'.  */
1608
1609   type = get_identifier (PROTOCOL_OBJECT_CLASS_NAME);
1610   objc_declare_class (tree_cons (NULL_TREE, type, NULL_TREE));
1611   objc_protocol_type = build_pointer_type (xref_tag (RECORD_TYPE,
1612                                 type));
1613
1614   /* Declare type of selector-objects that represent an operation name.  */
1615
1616   if (flag_next_runtime)
1617     /* `struct objc_selector *' */
1618     objc_selector_type
1619       = build_pointer_type (xref_tag (RECORD_TYPE,
1620                                       get_identifier (TAG_SELECTOR)));
1621   else
1622     /* `const struct objc_selector *' */
1623     objc_selector_type
1624       = build_pointer_type
1625         (build_qualified_type (xref_tag (RECORD_TYPE,
1626                                          get_identifier (TAG_SELECTOR)),
1627                                TYPE_QUAL_CONST));
1628
1629   /* Declare receiver type used for dispatching messages to 'super'.  */
1630
1631   /* `struct objc_super *' */
1632   objc_super_type = build_pointer_type (xref_tag (RECORD_TYPE,
1633                                                   get_identifier (TAG_SUPER)));
1634
1635   /* Declare pointers to method and ivar lists.  */
1636   objc_method_list_ptr = build_pointer_type
1637                          (xref_tag (RECORD_TYPE,
1638                                     get_identifier (UTAG_METHOD_LIST)));
1639   objc_method_proto_list_ptr
1640     = build_pointer_type (xref_tag (RECORD_TYPE,
1641                                     get_identifier (UTAG_METHOD_PROTOTYPE_LIST)));
1642   objc_ivar_list_ptr = build_pointer_type
1643                        (xref_tag (RECORD_TYPE,
1644                                   get_identifier (UTAG_IVAR_LIST)));
1645
1646   /* TREE_NOTHROW is cleared for the message-sending functions,
1647      because the function that gets called can throw in Obj-C++, or
1648      could itself call something that can throw even in Obj-C.  */
1649
1650   if (flag_next_runtime)
1651     {
1652       /* NB: In order to call one of the ..._stret (struct-returning)
1653       functions, the function *MUST* first be cast to a signature that
1654       corresponds to the actual ObjC method being invoked.  This is
1655       what is done by the build_objc_method_call() routine below.  */
1656
1657       /* id objc_msgSend (id, SEL, ...); */
1658       /* id objc_msgSendNonNil (id, SEL, ...); */
1659       /* id objc_msgSend_stret (id, SEL, ...); */
1660       /* id objc_msgSendNonNil_stret (id, SEL, ...); */
1661       type
1662         = build_function_type (objc_object_type,
1663                                tree_cons (NULL_TREE, objc_object_type,
1664                                           tree_cons (NULL_TREE, objc_selector_type,
1665                                                      NULL_TREE)));
1666       umsg_decl = add_builtin_function (TAG_MSGSEND,
1667                                         type, 0, NOT_BUILT_IN,
1668                                         NULL, NULL_TREE);
1669       umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL,
1670                                                type, 0, NOT_BUILT_IN,
1671                                                NULL, NULL_TREE);
1672       umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET,
1673                                               type, 0, NOT_BUILT_IN,
1674                                               NULL, NULL_TREE);
1675       umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET,
1676                                                      type, 0, NOT_BUILT_IN,
1677                                                      NULL, NULL_TREE);
1678
1679       /* These can throw, because the function that gets called can throw
1680          in Obj-C++, or could itself call something that can throw even
1681          in Obj-C.  */
1682       TREE_NOTHROW (umsg_decl) = 0;
1683       TREE_NOTHROW (umsg_nonnil_decl) = 0;
1684       TREE_NOTHROW (umsg_stret_decl) = 0;
1685       TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
1686
1687       /* id objc_msgSend_Fast (id, SEL, ...)
1688            __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
1689 #ifdef OFFS_MSGSEND_FAST
1690       umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST,
1691                                              type, 0, NOT_BUILT_IN,
1692                                              NULL, NULL_TREE);
1693       TREE_NOTHROW (umsg_fast_decl) = 0;
1694       DECL_ATTRIBUTES (umsg_fast_decl)
1695         = tree_cons (get_identifier ("hard_coded_address"),
1696                      build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
1697                      NULL_TREE);
1698 #else
1699       /* No direct dispatch available.  */
1700       umsg_fast_decl = umsg_decl;
1701 #endif
1702
1703       /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
1704       /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
1705       type
1706         = build_function_type (objc_object_type,
1707                                tree_cons (NULL_TREE, objc_super_type,
1708                                           tree_cons (NULL_TREE, objc_selector_type,
1709                                                      NULL_TREE)));
1710       umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1711                                               type, 0, NOT_BUILT_IN,
1712                                               NULL, NULL_TREE);
1713       umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET,
1714                                                     type, 0, NOT_BUILT_IN, 0,
1715                                                     NULL_TREE);
1716       TREE_NOTHROW (umsg_super_decl) = 0;
1717       TREE_NOTHROW (umsg_super_stret_decl) = 0;
1718     }
1719   else
1720     {
1721       /* GNU runtime messenger entry points.  */
1722
1723       /* typedef id (*IMP)(id, SEL, ...); */
1724       tree IMP_type
1725         = build_pointer_type
1726           (build_function_type (objc_object_type,
1727                                 tree_cons (NULL_TREE, objc_object_type,
1728                                            tree_cons (NULL_TREE, objc_selector_type,
1729                                                       NULL_TREE))));
1730
1731       /* IMP objc_msg_lookup (id, SEL); */
1732       type
1733         = build_function_type (IMP_type,
1734                                tree_cons (NULL_TREE, objc_object_type,
1735                                           tree_cons (NULL_TREE, objc_selector_type,
1736                                                      OBJC_VOID_AT_END)));
1737       umsg_decl = add_builtin_function (TAG_MSGSEND,
1738                                         type, 0, NOT_BUILT_IN,
1739                                         NULL, NULL_TREE);
1740       TREE_NOTHROW (umsg_decl) = 0;
1741
1742       /* IMP objc_msg_lookup_super (struct objc_super *, SEL); */
1743       type
1744         = build_function_type (IMP_type,
1745                                tree_cons (NULL_TREE, objc_super_type,
1746                                           tree_cons (NULL_TREE, objc_selector_type,
1747                                                      OBJC_VOID_AT_END)));
1748       umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
1749                                               type, 0, NOT_BUILT_IN,
1750                                               NULL, NULL_TREE);
1751       TREE_NOTHROW (umsg_super_decl) = 0;
1752
1753       /* The following GNU runtime entry point is called to initialize
1754          each module:
1755
1756          __objc_exec_class (void *); */
1757       type
1758         = build_function_type (void_type_node,
1759                                tree_cons (NULL_TREE, ptr_type_node,
1760                                           OBJC_VOID_AT_END));
1761       execclass_decl = add_builtin_function (TAG_EXECCLASS,
1762                                              type, 0, NOT_BUILT_IN,
1763                                              NULL, NULL_TREE);
1764     }
1765
1766   /* id objc_getClass (const char *); */
1767
1768   type = build_function_type (objc_object_type,
1769                                    tree_cons (NULL_TREE,
1770                                               const_string_type_node,
1771                                               OBJC_VOID_AT_END));
1772
1773   objc_get_class_decl
1774     = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
1775                             NULL, NULL_TREE);
1776
1777   /* id objc_getMetaClass (const char *); */
1778
1779   objc_get_meta_class_decl
1780     = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
1781
1782   build_class_template ();
1783   build_super_template ();
1784   build_protocol_template ();
1785   build_category_template ();
1786   build_objc_exception_stuff ();
1787
1788   if (flag_next_runtime)
1789     build_next_objc_exception_stuff ();
1790
1791   /* static SEL _OBJC_SELECTOR_TABLE[]; */
1792
1793   if (! flag_next_runtime)
1794     build_selector_table_decl ();
1795
1796   /* Forward declare constant_string_id and constant_string_type.  */
1797   if (!constant_string_class_name)
1798     constant_string_class_name = default_constant_string_class_name;
1799
1800   constant_string_id = get_identifier (constant_string_class_name);
1801   objc_declare_class (tree_cons (NULL_TREE, constant_string_id, NULL_TREE));
1802
1803   /* Pre-build the following entities - for speed/convenience.  */
1804   self_id = get_identifier ("self");
1805   ucmd_id = get_identifier ("_cmd");
1806
1807 #ifdef OBJCPLUS
1808   pop_lang_context ();
1809 #endif
1810
1811   write_symbols = save_write_symbols;
1812   debug_hooks = save_hooks;
1813 }
1814
1815 /* Ensure that the ivar list for NSConstantString/NXConstantString
1816    (or whatever was specified via `-fconstant-string-class')
1817    contains fields at least as large as the following three, so that
1818    the runtime can stomp on them with confidence:
1819
1820    struct STRING_OBJECT_CLASS_NAME
1821    {
1822      Object isa;
1823      char *cString;
1824      unsigned int length;
1825    }; */
1826
1827 static int
1828 check_string_class_template (void)
1829 {
1830   tree field_decl = objc_get_class_ivars (constant_string_id);
1831
1832 #define AT_LEAST_AS_LARGE_AS(F, T) \
1833   (F && TREE_CODE (F) == FIELD_DECL \
1834      && (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (F))) \
1835          >= TREE_INT_CST_LOW (TYPE_SIZE (T))))
1836
1837   if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1838     return 0;
1839
1840   field_decl = TREE_CHAIN (field_decl);
1841   if (!AT_LEAST_AS_LARGE_AS (field_decl, ptr_type_node))
1842     return 0;
1843
1844   field_decl = TREE_CHAIN (field_decl);
1845   return AT_LEAST_AS_LARGE_AS (field_decl, unsigned_type_node);
1846
1847 #undef AT_LEAST_AS_LARGE_AS
1848 }
1849
1850 /* Avoid calling `check_string_class_template ()' more than once.  */
1851 static GTY(()) int string_layout_checked;
1852
1853 /* Construct an internal string layout to be used as a template for
1854    creating NSConstantString/NXConstantString instances.  */
1855
1856 static tree
1857 objc_build_internal_const_str_type (void)
1858 {
1859   tree type = (*lang_hooks.types.make_type) (RECORD_TYPE);
1860   tree fields = build_decl (input_location,
1861                             FIELD_DECL, NULL_TREE, ptr_type_node);
1862   tree field = build_decl (input_location,
1863                            FIELD_DECL, NULL_TREE, ptr_type_node);
1864
1865   TREE_CHAIN (field) = fields; fields = field;
1866   field = build_decl (input_location,
1867                       FIELD_DECL, NULL_TREE, unsigned_type_node);
1868   TREE_CHAIN (field) = fields; fields = field;
1869   /* NB: The finish_builtin_struct() routine expects FIELD_DECLs in
1870      reverse order!  */
1871   finish_builtin_struct (type, "__builtin_ObjCString",
1872                          fields, NULL_TREE);
1873
1874   return type;
1875 }
1876
1877 /* Custom build_string which sets TREE_TYPE!  */
1878
1879 static tree
1880 my_build_string (int len, const char *str)
1881 {
1882   return fix_string_type (build_string (len, str));
1883 }
1884
1885 /* Build a string with contents STR and length LEN and convert it to a
1886    pointer.  */
1887
1888 static tree
1889 my_build_string_pointer (int len, const char *str)
1890 {
1891   tree string = my_build_string (len, str);
1892   tree ptrtype = build_pointer_type (TREE_TYPE (TREE_TYPE (string)));
1893   return build1 (ADDR_EXPR, ptrtype, string);
1894 }
1895
1896 static hashval_t
1897 string_hash (const void *ptr)
1898 {
1899   const_tree const str = ((const struct string_descriptor *)ptr)->literal;
1900   const unsigned char *p = (const unsigned char *) TREE_STRING_POINTER (str);
1901   int i, len = TREE_STRING_LENGTH (str);
1902   hashval_t h = len;
1903
1904   for (i = 0; i < len; i++)
1905     h = ((h * 613) + p[i]);
1906
1907   return h;
1908 }
1909
1910 static int
1911 string_eq (const void *ptr1, const void *ptr2)
1912 {
1913   const_tree const str1 = ((const struct string_descriptor *)ptr1)->literal;
1914   const_tree const str2 = ((const struct string_descriptor *)ptr2)->literal;
1915   int len1 = TREE_STRING_LENGTH (str1);
1916
1917   return (len1 == TREE_STRING_LENGTH (str2)
1918           && !memcmp (TREE_STRING_POINTER (str1), TREE_STRING_POINTER (str2),
1919                       len1));
1920 }
1921
1922 /* Given a chain of STRING_CST's, build a static instance of
1923    NXConstantString which points at the concatenation of those
1924    strings.  We place the string object in the __string_objects
1925    section of the __OBJC segment.  The Objective-C runtime will
1926    initialize the isa pointers of the string objects to point at the
1927    NXConstantString class object.  */
1928
1929 tree
1930 objc_build_string_object (tree string)
1931 {
1932   tree initlist, constructor, constant_string_class;
1933   int length;
1934   tree fields, addr;
1935   struct string_descriptor *desc, key;
1936   void **loc;
1937
1938   /* Prep the string argument.  */
1939   string = fix_string_type (string);
1940   TREE_SET_CODE (string, STRING_CST);
1941   length = TREE_STRING_LENGTH (string) - 1;
1942
1943   /* Check whether the string class being used actually exists and has the
1944      correct ivar layout.  */
1945   if (!string_layout_checked)
1946     {
1947       string_layout_checked = -1;
1948       constant_string_class = lookup_interface (constant_string_id);
1949       internal_const_str_type = objc_build_internal_const_str_type ();
1950
1951       if (!constant_string_class
1952           || !(constant_string_type
1953                = CLASS_STATIC_TEMPLATE (constant_string_class)))
1954         error ("cannot find interface declaration for %qE",
1955                constant_string_id);
1956       /* The NSConstantString/NXConstantString ivar layout is now known.  */
1957       else if (!check_string_class_template ())
1958         error ("interface %qE does not have valid constant string layout",
1959                constant_string_id);
1960       /* For the NeXT runtime, we can generate a literal reference
1961          to the string class, don't need to run a constructor.  */
1962       else if (flag_next_runtime && !setup_string_decl ())
1963         error ("cannot find reference tag for class %qE",
1964                constant_string_id);
1965       else
1966         {
1967           string_layout_checked = 1;  /* Success!  */
1968           add_class_reference (constant_string_id);
1969         }
1970     }
1971
1972   if (string_layout_checked == -1)
1973     return error_mark_node;
1974
1975   /* Perhaps we already constructed a constant string just like this one? */
1976   key.literal = string;
1977   loc = htab_find_slot (string_htab, &key, INSERT);
1978   desc = (struct string_descriptor *) *loc;
1979
1980   if (!desc)
1981     {
1982       tree var;
1983       *loc = desc = GGC_NEW (struct string_descriptor);
1984       desc->literal = string;
1985
1986       /* GNU:    (NXConstantString *) & ((__builtin_ObjCString) { NULL, string, length })  */
1987       /* NeXT:   (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length })   */
1988       fields = TYPE_FIELDS (internal_const_str_type);
1989       initlist
1990         = build_tree_list (fields,
1991                            flag_next_runtime
1992                            ? build_unary_op (input_location,
1993                                              ADDR_EXPR, string_class_decl, 0)
1994                            : build_int_cst (NULL_TREE, 0));
1995       fields = TREE_CHAIN (fields);
1996       initlist = tree_cons (fields, build_unary_op (input_location,
1997                                                     ADDR_EXPR, string, 1),
1998                             initlist);
1999       fields = TREE_CHAIN (fields);
2000       initlist = tree_cons (fields, build_int_cst (NULL_TREE, length),
2001                             initlist);
2002       constructor = objc_build_constructor (internal_const_str_type,
2003                                             nreverse (initlist));
2004
2005       if (!flag_next_runtime)
2006         constructor
2007           = objc_add_static_instance (constructor, constant_string_type);
2008       else
2009         {
2010           var = build_decl (input_location,
2011                             CONST_DECL, NULL, TREE_TYPE (constructor));
2012           DECL_INITIAL (var) = constructor;
2013           TREE_STATIC (var) = 1;
2014           pushdecl_top_level (var);
2015           constructor = var;
2016         }
2017       desc->constructor = constructor;
2018     }
2019
2020   addr = convert (build_pointer_type (constant_string_type),
2021                   build_unary_op (input_location,
2022                                   ADDR_EXPR, desc->constructor, 1));
2023
2024   return addr;
2025 }
2026
2027 /* Declare a static instance of CLASS_DECL initialized by CONSTRUCTOR.  */
2028
2029 static GTY(()) int num_static_inst;
2030
2031 static tree
2032 objc_add_static_instance (tree constructor, tree class_decl)
2033 {
2034   tree *chain, decl;
2035   char buf[256];
2036
2037   /* Find the list of static instances for the CLASS_DECL.  Create one if
2038      not found.  */
2039   for (chain = &objc_static_instances;
2040        *chain && TREE_VALUE (*chain) != class_decl;
2041        chain = &TREE_CHAIN (*chain));
2042   if (!*chain)
2043     {
2044       *chain = tree_cons (NULL_TREE, class_decl, NULL_TREE);
2045       add_objc_string (OBJC_TYPE_NAME (class_decl), class_names);
2046     }
2047
2048   sprintf (buf, "_OBJC_INSTANCE_%d", num_static_inst++);
2049   decl = build_decl (input_location,
2050                      VAR_DECL, get_identifier (buf), class_decl);
2051   TREE_STATIC (decl) = 1;
2052   DECL_ARTIFICIAL (decl) = 1;
2053   TREE_USED (decl) = 1;
2054   DECL_INITIAL (decl) = constructor;
2055
2056   /* We may be writing something else just now.
2057      Postpone till end of input.  */
2058   DECL_DEFER_OUTPUT (decl) = 1;
2059   pushdecl_top_level (decl);
2060   rest_of_decl_compilation (decl, 1, 0);
2061
2062   /* Add the DECL to the head of this CLASS' list.  */
2063   TREE_PURPOSE (*chain) = tree_cons (NULL_TREE, decl, TREE_PURPOSE (*chain));
2064
2065   return decl;
2066 }
2067
2068 /* Build a static constant CONSTRUCTOR
2069    with type TYPE and elements ELTS.  */
2070
2071 static tree
2072 objc_build_constructor (tree type, tree elts)
2073 {
2074   tree constructor = build_constructor_from_list (type, elts);
2075
2076   TREE_CONSTANT (constructor) = 1;
2077   TREE_STATIC (constructor) = 1;
2078   TREE_READONLY (constructor) = 1;
2079
2080 #ifdef OBJCPLUS
2081   /* Adjust for impedance mismatch.  We should figure out how to build
2082      CONSTRUCTORs that consistently please both the C and C++ gods.  */
2083   if (!TREE_PURPOSE (elts))
2084     TREE_TYPE (constructor) = init_list_type_node;
2085 #endif
2086
2087   return constructor;
2088 }
2089 \f
2090 /* Take care of defining and initializing _OBJC_SYMBOLS.  */
2091
2092 /* Predefine the following data type:
2093
2094    struct _objc_symtab
2095    {
2096      long sel_ref_cnt;
2097      SEL *refs;
2098      short cls_def_cnt;
2099      short cat_def_cnt;
2100      void *defs[cls_def_cnt + cat_def_cnt];
2101    }; */
2102
2103 static void
2104 build_objc_symtab_template (void)
2105 {
2106   tree field_decl, field_decl_chain;
2107
2108   objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB));
2109
2110   /* long sel_ref_cnt; */
2111   field_decl = create_field_decl (long_integer_type_node, "sel_ref_cnt");
2112   field_decl_chain = field_decl;
2113
2114   /* SEL *refs; */
2115   field_decl = create_field_decl (build_pointer_type (objc_selector_type),
2116                                   "refs");
2117   chainon (field_decl_chain, field_decl);
2118
2119   /* short cls_def_cnt; */
2120   field_decl = create_field_decl (short_integer_type_node, "cls_def_cnt");
2121   chainon (field_decl_chain, field_decl);
2122
2123   /* short cat_def_cnt; */
2124   field_decl = create_field_decl (short_integer_type_node,
2125                                   "cat_def_cnt");
2126   chainon (field_decl_chain, field_decl);
2127
2128   if (imp_count || cat_count || !flag_next_runtime)
2129     {
2130       /* void *defs[imp_count + cat_count (+ 1)]; */
2131       /* NB: The index is one less than the size of the array.  */
2132       int index = imp_count + cat_count
2133                 + (flag_next_runtime? -1: 0);
2134       field_decl = create_field_decl
2135                    (build_array_type
2136                     (ptr_type_node,
2137                      build_index_type (build_int_cst (NULL_TREE, index))),
2138                     "defs");
2139       chainon (field_decl_chain, field_decl);
2140     }
2141
2142   objc_finish_struct (objc_symtab_template, field_decl_chain);
2143 }
2144
2145 /* Create the initial value for the `defs' field of _objc_symtab.
2146    This is a CONSTRUCTOR.  */
2147
2148 static tree
2149 init_def_list (tree type)
2150 {
2151   tree expr, initlist = NULL_TREE;
2152   struct imp_entry *impent;
2153
2154   if (imp_count)
2155     for (impent = imp_list; impent; impent = impent->next)
2156       {
2157         if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
2158           {
2159             expr = build_unary_op (input_location,
2160                                    ADDR_EXPR, impent->class_decl, 0);
2161             initlist = tree_cons (NULL_TREE, expr, initlist);
2162           }
2163       }
2164
2165   if (cat_count)
2166     for (impent = imp_list; impent; impent = impent->next)
2167       {
2168         if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2169           {
2170             expr = build_unary_op (input_location,
2171                                    ADDR_EXPR, impent->class_decl, 0);
2172             initlist = tree_cons (NULL_TREE, expr, initlist);
2173           }
2174       }
2175
2176   if (!flag_next_runtime)
2177     {
2178       /* statics = { ..., _OBJC_STATIC_INSTANCES, ... }  */
2179       tree expr;
2180
2181       if (static_instances_decl)
2182         expr = build_unary_op (input_location,
2183                                ADDR_EXPR, static_instances_decl, 0);
2184       else
2185         expr = build_int_cst (NULL_TREE, 0);
2186
2187       initlist = tree_cons (NULL_TREE, expr, initlist);
2188     }
2189
2190   return objc_build_constructor (type, nreverse (initlist));
2191 }
2192
2193 /* Construct the initial value for all of _objc_symtab.  */
2194
2195 static tree
2196 init_objc_symtab (tree type)
2197 {
2198   tree initlist;
2199
2200   /* sel_ref_cnt = { ..., 5, ... } */
2201
2202   initlist = build_tree_list (NULL_TREE,
2203                               build_int_cst (long_integer_type_node, 0));
2204
2205   /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
2206
2207   if (flag_next_runtime || ! sel_ref_chain)
2208     initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
2209   else
2210     initlist
2211       = tree_cons (NULL_TREE,
2212                    convert (build_pointer_type (objc_selector_type),
2213                             build_unary_op (input_location, ADDR_EXPR,
2214                                             UOBJC_SELECTOR_TABLE_decl, 1)),
2215                    initlist);
2216
2217   /* cls_def_cnt = { ..., 5, ... } */
2218
2219   initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, imp_count), initlist);
2220
2221   /* cat_def_cnt = { ..., 5, ... } */
2222
2223   initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, cat_count), initlist);
2224
2225   /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
2226
2227   if (imp_count || cat_count || !flag_next_runtime)
2228     {
2229
2230       tree field = TYPE_FIELDS (type);
2231       field = TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (field))));
2232
2233       initlist = tree_cons (NULL_TREE, init_def_list (TREE_TYPE (field)),
2234                             initlist);
2235     }
2236
2237   return objc_build_constructor (type, nreverse (initlist));
2238 }
2239
2240 /* Generate forward declarations for metadata such as
2241   'OBJC_CLASS_...'.  */
2242
2243 static tree
2244 build_metadata_decl (const char *name, tree type)
2245 {
2246   tree decl;
2247
2248   /* struct TYPE NAME_<name>; */
2249   decl = start_var_decl (type, synth_id_with_class_suffix
2250                                (name,
2251                                 objc_implementation_context));
2252
2253   return decl;
2254 }
2255
2256 /* Push forward-declarations of all the categories so that
2257    init_def_list can use them in a CONSTRUCTOR.  */
2258
2259 static void
2260 forward_declare_categories (void)
2261 {
2262   struct imp_entry *impent;
2263   tree sav = objc_implementation_context;
2264
2265   for (impent = imp_list; impent; impent = impent->next)
2266     {
2267       if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2268         {
2269           /* Set an invisible arg to synth_id_with_class_suffix.  */
2270           objc_implementation_context = impent->imp_context;
2271           /* extern struct objc_category _OBJC_CATEGORY_<name>; */
2272           impent->class_decl = build_metadata_decl ("_OBJC_CATEGORY",
2273                                                     objc_category_template);
2274         }
2275     }
2276   objc_implementation_context = sav;
2277 }
2278
2279 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
2280    and initialized appropriately.  */
2281
2282 static void
2283 generate_objc_symtab_decl (void)
2284 {
2285   /* forward declare categories */
2286   if (cat_count)
2287     forward_declare_categories ();
2288
2289   build_objc_symtab_template ();
2290   UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_SYMBOLS");
2291   finish_var_decl (UOBJC_SYMBOLS_decl,
2292                    init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
2293 }
2294 \f
2295 static tree
2296 init_module_descriptor (tree type)
2297 {
2298   tree initlist, expr;
2299
2300   /* version = { 1, ... } */
2301
2302   expr = build_int_cst (long_integer_type_node, OBJC_VERSION);
2303   initlist = build_tree_list (NULL_TREE, expr);
2304
2305   /* size = { ..., sizeof (struct _objc_module), ... } */
2306
2307   expr = convert (long_integer_type_node,
2308                   size_in_bytes (objc_module_template));
2309   initlist = tree_cons (NULL_TREE, expr, initlist);
2310
2311   /* Don't provide any file name for security reasons. */
2312   /* name = { ..., "", ... } */
2313
2314   expr = add_objc_string (get_identifier (""), class_names);
2315   initlist = tree_cons (NULL_TREE, expr, initlist);
2316
2317   /* symtab = { ..., _OBJC_SYMBOLS, ... } */
2318
2319   if (UOBJC_SYMBOLS_decl)
2320     expr = build_unary_op (input_location,
2321                            ADDR_EXPR, UOBJC_SYMBOLS_decl, 0);
2322   else
2323     expr = build_int_cst (NULL_TREE, 0);
2324   initlist = tree_cons (NULL_TREE, expr, initlist);
2325
2326   return objc_build_constructor (type, nreverse (initlist));
2327 }
2328
2329 /* Write out the data structures to describe Objective C classes defined.
2330
2331    struct _objc_module { ... } _OBJC_MODULE = { ... };   */
2332
2333 static void
2334 build_module_descriptor (void)
2335 {
2336   tree field_decl, field_decl_chain;
2337
2338 #ifdef OBJCPLUS
2339   push_lang_context (lang_name_c); /* extern "C" */
2340 #endif
2341
2342   objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE));
2343
2344   /* long version; */
2345   field_decl = create_field_decl (long_integer_type_node, "version");
2346   field_decl_chain = field_decl;
2347
2348   /* long size; */
2349   field_decl = create_field_decl (long_integer_type_node, "size");
2350   chainon (field_decl_chain, field_decl);
2351
2352   /* char *name; */
2353   field_decl = create_field_decl (string_type_node, "name");
2354   chainon (field_decl_chain, field_decl);
2355
2356   /* struct _objc_symtab *symtab; */
2357   field_decl
2358     = create_field_decl (build_pointer_type
2359                          (xref_tag (RECORD_TYPE,
2360                                     get_identifier (UTAG_SYMTAB))),
2361                          "symtab");
2362   chainon (field_decl_chain, field_decl);
2363
2364   objc_finish_struct (objc_module_template, field_decl_chain);
2365
2366   /* Create an instance of "_objc_module".  */
2367   UOBJC_MODULES_decl = start_var_decl (objc_module_template, "_OBJC_MODULES");
2368   finish_var_decl (UOBJC_MODULES_decl,
2369                    init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl)));
2370
2371 #ifdef OBJCPLUS
2372   pop_lang_context ();
2373 #endif
2374 }
2375
2376 /* The GNU runtime requires us to provide a static initializer function
2377    for each module:
2378
2379    static void __objc_gnu_init (void) {
2380      __objc_exec_class (&L_OBJC_MODULES);
2381    }  */
2382
2383 static void
2384 build_module_initializer_routine (void)
2385 {
2386   tree body;
2387
2388 #ifdef OBJCPLUS
2389   push_lang_context (lang_name_c); /* extern "C" */
2390 #endif
2391
2392   objc_push_parm (build_decl (input_location,
2393                               PARM_DECL, NULL_TREE, void_type_node));
2394 #ifdef OBJCPLUS
2395   objc_start_function (get_identifier (TAG_GNUINIT),
2396                        build_function_type (void_type_node,
2397                                             OBJC_VOID_AT_END),
2398                        NULL_TREE, NULL_TREE);
2399 #else
2400   objc_start_function (get_identifier (TAG_GNUINIT),
2401                        build_function_type (void_type_node,
2402                                             OBJC_VOID_AT_END),
2403                        NULL_TREE, objc_get_parm_info (0));
2404 #endif
2405   body = c_begin_compound_stmt (true);
2406   add_stmt (build_function_call
2407             (input_location,
2408              execclass_decl,
2409              build_tree_list
2410              (NULL_TREE,
2411               build_unary_op (input_location, ADDR_EXPR,
2412                               UOBJC_MODULES_decl, 0))));
2413   add_stmt (c_end_compound_stmt (input_location, body, true));
2414
2415   TREE_PUBLIC (current_function_decl) = 0;
2416
2417 #ifndef OBJCPLUS
2418   /* For Objective-C++, we will need to call __objc_gnu_init
2419      from objc_generate_static_init_call() below.  */
2420   DECL_STATIC_CONSTRUCTOR (current_function_decl) = 1;
2421 #endif
2422
2423   GNU_INIT_decl = current_function_decl;
2424   finish_function ();
2425
2426 #ifdef OBJCPLUS
2427     pop_lang_context ();
2428 #endif
2429 }
2430
2431 #ifdef OBJCPLUS
2432 /* Return 1 if the __objc_gnu_init function has been synthesized and needs
2433    to be called by the module initializer routine.  */
2434
2435 int
2436 objc_static_init_needed_p (void)
2437 {
2438   return (GNU_INIT_decl != NULL_TREE);
2439 }
2440
2441 /* Generate a call to the __objc_gnu_init initializer function.  */
2442
2443 tree
2444 objc_generate_static_init_call (tree ctors ATTRIBUTE_UNUSED)
2445 {
2446   add_stmt (build_stmt (input_location, EXPR_STMT,
2447                         build_function_call (input_location,
2448                                              GNU_INIT_decl, NULL_TREE)));
2449
2450   return ctors;
2451 }
2452 #endif /* OBJCPLUS */
2453
2454 /* Return the DECL of the string IDENT in the SECTION.  */
2455
2456 static tree
2457 get_objc_string_decl (tree ident, enum string_section section)
2458 {
2459   tree chain;
2460
2461   if (section == class_names)
2462     chain = class_names_chain;
2463   else if (section == meth_var_names)
2464     chain = meth_var_names_chain;
2465   else if (section == meth_var_types)
2466     chain = meth_var_types_chain;
2467   else
2468     abort ();
2469
2470   for (; chain != 0; chain = TREE_CHAIN (chain))
2471     if (TREE_VALUE (chain) == ident)
2472       return (TREE_PURPOSE (chain));
2473
2474   abort ();
2475   return NULL_TREE;
2476 }
2477
2478 /* Output references to all statically allocated objects.  Return the DECL
2479    for the array built.  */
2480
2481 static void
2482 generate_static_references (void)
2483 {
2484   tree decls = NULL_TREE, expr = NULL_TREE;
2485   tree class_name, klass, decl, initlist;
2486   tree cl_chain, in_chain, type
2487     = build_array_type (build_pointer_type (void_type_node), NULL_TREE);
2488   int num_inst, num_class;
2489   char buf[256];
2490
2491   if (flag_next_runtime)
2492     abort ();
2493
2494   for (cl_chain = objc_static_instances, num_class = 0;
2495        cl_chain; cl_chain = TREE_CHAIN (cl_chain), num_class++)
2496     {
2497       for (num_inst = 0, in_chain = TREE_PURPOSE (cl_chain);
2498            in_chain; num_inst++, in_chain = TREE_CHAIN (in_chain));
2499
2500       sprintf (buf, "_OBJC_STATIC_INSTANCES_%d", num_class);
2501       decl = start_var_decl (type, buf);
2502
2503       /* Output {class_name, ...}.  */
2504       klass = TREE_VALUE (cl_chain);
2505       class_name = get_objc_string_decl (OBJC_TYPE_NAME (klass), class_names);
2506       initlist = build_tree_list (NULL_TREE,
2507                                   build_unary_op (input_location, 
2508                                                   ADDR_EXPR, class_name, 1));
2509
2510       /* Output {..., instance, ...}.  */
2511       for (in_chain = TREE_PURPOSE (cl_chain);
2512            in_chain; in_chain = TREE_CHAIN (in_chain))
2513         {
2514           expr = build_unary_op (input_location,
2515                                  ADDR_EXPR, TREE_VALUE (in_chain), 1);
2516           initlist = tree_cons (NULL_TREE, expr, initlist);
2517         }
2518
2519       /* Output {..., NULL}.  */
2520       initlist = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), initlist);
2521
2522       expr = objc_build_constructor (TREE_TYPE (decl), nreverse (initlist));
2523       finish_var_decl (decl, expr);
2524       decls
2525         = tree_cons (NULL_TREE, build_unary_op (input_location,
2526                                                 ADDR_EXPR, decl, 1), decls);
2527     }
2528
2529   decls = tree_cons (NULL_TREE, build_int_cst (NULL_TREE, 0), decls);
2530   expr = objc_build_constructor (type, nreverse (decls));
2531   static_instances_decl = start_var_decl (type, "_OBJC_STATIC_INSTANCES");
2532   finish_var_decl (static_instances_decl, expr);
2533 }
2534
2535 static GTY(()) int selector_reference_idx;
2536
2537 static tree
2538 build_selector_reference_decl (void)
2539 {
2540   tree decl;
2541   char buf[256];
2542
2543   sprintf (buf, "_OBJC_SELECTOR_REFERENCES_%d", selector_reference_idx++);
2544   decl = start_var_decl (objc_selector_type, buf);
2545
2546   return decl;
2547 }
2548
2549 static void
2550 build_selector_table_decl (void)
2551 {
2552   tree temp;
2553
2554   if (flag_typed_selectors)
2555     {
2556       build_selector_template ();
2557       temp = build_array_type (objc_selector_template, NULL_TREE);
2558     }
2559   else
2560     temp = build_array_type (objc_selector_type, NULL_TREE);
2561
2562   UOBJC_SELECTOR_TABLE_decl = start_var_decl (temp, "_OBJC_SELECTOR_TABLE");
2563 }
2564
2565 /* Just a handy wrapper for add_objc_string.  */
2566
2567 static tree
2568 build_selector (tree ident)
2569 {
2570   return convert (objc_selector_type,
2571                   add_objc_string (ident, meth_var_names));
2572 }
2573
2574 static void
2575 build_selector_translation_table (void)
2576 {
2577   tree chain, initlist = NULL_TREE;
2578   int offset = 0;
2579   tree decl = NULL_TREE;
2580
2581   for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
2582     {
2583       tree expr;
2584
2585       if (warn_selector && objc_implementation_context)
2586       {
2587         tree method_chain;
2588         bool found = false;
2589         for (method_chain = meth_var_names_chain;
2590              method_chain;
2591              method_chain = TREE_CHAIN (method_chain))
2592           {
2593             if (TREE_VALUE (method_chain) == TREE_VALUE (chain))
2594               {
2595                 found = true;
2596                 break;
2597               }
2598           }
2599         if (!found)
2600           {
2601             location_t loc;
2602             if (flag_next_runtime && TREE_PURPOSE (chain))
2603               loc = DECL_SOURCE_LOCATION (TREE_PURPOSE (chain));
2604             else
2605               loc = input_location;
2606             warning_at (loc, 0, "creating selector for nonexistent method %qE",
2607                         TREE_VALUE (chain));
2608           }
2609       }
2610
2611       expr = build_selector (TREE_VALUE (chain));
2612       /* add one for the '\0' character */
2613       offset += IDENTIFIER_LENGTH (TREE_VALUE (chain)) + 1;
2614
2615       if (flag_next_runtime)
2616         {
2617           decl = TREE_PURPOSE (chain);
2618           finish_var_decl (decl, expr);
2619         }
2620       else
2621         {
2622           if (flag_typed_selectors)
2623             {
2624               tree eltlist = NULL_TREE;
2625               tree encoding = get_proto_encoding (TREE_PURPOSE (chain));
2626               eltlist = tree_cons (NULL_TREE, expr, NULL_TREE);
2627               eltlist = tree_cons (NULL_TREE, encoding, eltlist);
2628               expr = objc_build_constructor (objc_selector_template,
2629                                              nreverse (eltlist));
2630             }
2631
2632           initlist = tree_cons (NULL_TREE, expr, initlist);
2633         }
2634     }
2635
2636   if (! flag_next_runtime)
2637     {
2638       /* Cause the selector table (previously forward-declared)
2639          to be actually output.  */
2640       initlist = tree_cons (NULL_TREE,
2641                             flag_typed_selectors
2642                             ? objc_build_constructor
2643                               (objc_selector_template,
2644                                tree_cons (NULL_TREE,
2645                                           build_int_cst (NULL_TREE, 0),
2646                                           tree_cons (NULL_TREE,
2647                                                      build_int_cst (NULL_TREE, 0),
2648                                                      NULL_TREE)))
2649                             : build_int_cst (NULL_TREE, 0), initlist);
2650       initlist = objc_build_constructor (TREE_TYPE (UOBJC_SELECTOR_TABLE_decl),
2651                                          nreverse (initlist));
2652       finish_var_decl (UOBJC_SELECTOR_TABLE_decl, initlist);
2653     }
2654 }
2655
2656 static tree
2657 get_proto_encoding (tree proto)
2658 {
2659   tree encoding;
2660   if (proto)
2661     {
2662       if (! METHOD_ENCODING (proto))
2663         {
2664           encoding = encode_method_prototype (proto);
2665           METHOD_ENCODING (proto) = encoding;
2666         }
2667       else
2668         encoding = METHOD_ENCODING (proto);
2669
2670       return add_objc_string (encoding, meth_var_types);
2671     }
2672   else
2673     return build_int_cst (NULL_TREE, 0);
2674 }
2675
2676 /* sel_ref_chain is a list whose "value" fields will be instances of
2677    identifier_node that represent the selector.  LOC is the location of
2678    the @selector.  */
2679
2680 static tree
2681 build_typed_selector_reference (location_t loc, tree ident, tree prototype)
2682 {
2683   tree *chain = &sel_ref_chain;
2684   tree expr;
2685   int index = 0;
2686
2687   while (*chain)
2688     {
2689       if (TREE_PURPOSE (*chain) == prototype && TREE_VALUE (*chain) == ident)
2690         goto return_at_index;
2691
2692       index++;
2693       chain = &TREE_CHAIN (*chain);
2694     }
2695
2696   *chain = tree_cons (prototype, ident, NULL_TREE);
2697
2698  return_at_index:
2699   expr = build_unary_op (loc, ADDR_EXPR,
2700                          build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2701                                           build_int_cst (NULL_TREE, index)),
2702                          1);
2703   return convert (objc_selector_type, expr);
2704 }
2705
2706 static tree
2707 build_selector_reference (location_t loc, tree ident)
2708 {
2709   tree *chain = &sel_ref_chain;
2710   tree expr;
2711   int index = 0;
2712
2713   while (*chain)
2714     {
2715       if (TREE_VALUE (*chain) == ident)
2716         return (flag_next_runtime
2717                 ? TREE_PURPOSE (*chain)
2718                 : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2719                                    build_int_cst (NULL_TREE, index)));
2720
2721       index++;
2722       chain = &TREE_CHAIN (*chain);
2723     }
2724
2725   expr = (flag_next_runtime ? build_selector_reference_decl (): NULL_TREE);
2726
2727   *chain = tree_cons (expr, ident, NULL_TREE);
2728
2729   return (flag_next_runtime
2730           ? expr
2731           : build_array_ref (loc, UOBJC_SELECTOR_TABLE_decl,
2732                              build_int_cst (NULL_TREE, index)));
2733 }
2734
2735 static GTY(()) int class_reference_idx;
2736
2737 static tree
2738 build_class_reference_decl (void)
2739 {
2740   tree decl;
2741   char buf[256];
2742
2743   sprintf (buf, "_OBJC_CLASS_REFERENCES_%d", class_reference_idx++);
2744   decl = start_var_decl (objc_class_type, buf);
2745
2746   return decl;
2747 }
2748
2749 /* Create a class reference, but don't create a variable to reference
2750    it.  */
2751
2752 static void
2753 add_class_reference (tree ident)
2754 {
2755   tree chain;
2756
2757   if ((chain = cls_ref_chain))
2758     {
2759       tree tail;
2760       do
2761         {
2762           if (ident == TREE_VALUE (chain))
2763             return;
2764
2765           tail = chain;
2766           chain = TREE_CHAIN (chain);
2767         }
2768       while (chain);
2769
2770       /* Append to the end of the list */
2771       TREE_CHAIN (tail) = tree_cons (NULL_TREE, ident, NULL_TREE);
2772     }
2773   else
2774     cls_ref_chain = tree_cons (NULL_TREE, ident, NULL_TREE);
2775 }
2776
2777 /* Get a class reference, creating it if necessary.  Also create the
2778    reference variable.  */
2779
2780 tree
2781 objc_get_class_reference (tree ident)
2782 {
2783   tree orig_ident = (DECL_P (ident)
2784                      ? DECL_NAME (ident)
2785                      : TYPE_P (ident)
2786                      ? OBJC_TYPE_NAME (ident)
2787                      : ident);
2788   bool local_scope = false;
2789
2790 #ifdef OBJCPLUS
2791   if (processing_template_decl)
2792     /* Must wait until template instantiation time.  */
2793     return build_min_nt (CLASS_REFERENCE_EXPR, ident);
2794 #endif
2795
2796   if (TREE_CODE (ident) == TYPE_DECL)
2797     ident = (DECL_ORIGINAL_TYPE (ident)
2798              ? DECL_ORIGINAL_TYPE (ident)
2799              : TREE_TYPE (ident));
2800
2801 #ifdef OBJCPLUS
2802   if (TYPE_P (ident) && TYPE_CONTEXT (ident)
2803       && TYPE_CONTEXT (ident) != global_namespace)
2804     local_scope = true;
2805 #endif
2806
2807   if (local_scope || !(ident = objc_is_class_name (ident)))
2808     {
2809       error ("%qE is not an Objective-C class name or alias",
2810              orig_ident);
2811       return error_mark_node;
2812     }
2813
2814   if (flag_next_runtime && !flag_zero_link)
2815     {
2816       tree *chain;
2817       tree decl;
2818
2819       for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
2820         if (TREE_VALUE (*chain) == ident)
2821           {
2822             if (! TREE_PURPOSE (*chain))
2823               TREE_PURPOSE (*chain) = build_class_reference_decl ();
2824
2825             return TREE_PURPOSE (*chain);
2826           }
2827
2828       decl = build_class_reference_decl ();
2829       *chain = tree_cons (decl, ident, NULL_TREE);
2830       return decl;
2831     }
2832   else
2833     {
2834       tree params;
2835
2836       add_class_reference (ident);
2837
2838       params = build_tree_list (NULL_TREE,
2839                                 my_build_string_pointer
2840                                 (IDENTIFIER_LENGTH (ident) + 1,
2841                                  IDENTIFIER_POINTER (ident)));
2842
2843       assemble_external (objc_get_class_decl);
2844       return build_function_call (input_location, objc_get_class_decl, params);
2845     }
2846 }
2847
2848 /* For each string section we have a chain which maps identifier nodes
2849    to decls for the strings.  */
2850
2851 static tree
2852 add_objc_string (tree ident, enum string_section section)
2853 {
2854   tree *chain, decl, type, string_expr;
2855
2856   if (section == class_names)
2857     chain = &class_names_chain;
2858   else if (section == meth_var_names)
2859     chain = &meth_var_names_chain;
2860   else if (section == meth_var_types)
2861     chain = &meth_var_types_chain;
2862   else
2863     abort ();
2864
2865   while (*chain)
2866     {
2867       if (TREE_VALUE (*chain) == ident)
2868         return convert (string_type_node,
2869                         build_unary_op (input_location,
2870                                         ADDR_EXPR, TREE_PURPOSE (*chain), 1));
2871
2872       chain = &TREE_CHAIN (*chain);
2873     }
2874
2875   decl = build_objc_string_decl (section);
2876
2877   type = build_array_type
2878          (char_type_node,
2879           build_index_type
2880           (build_int_cst (NULL_TREE,
2881                           IDENTIFIER_LENGTH (ident))));
2882   decl = start_var_decl (type, IDENTIFIER_POINTER (DECL_NAME (decl)));
2883   string_expr = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
2884                                  IDENTIFIER_POINTER (ident));
2885   finish_var_decl (decl, string_expr);
2886
2887   *chain = tree_cons (decl, ident, NULL_TREE);
2888
2889   return convert (string_type_node, build_unary_op (input_location,
2890                                                     ADDR_EXPR, decl, 1));
2891 }
2892
2893 static GTY(()) int class_names_idx;
2894 static GTY(()) int meth_var_names_idx;
2895 static GTY(()) int meth_var_types_idx;
2896
2897 static tree
2898 build_objc_string_decl (enum string_section section)
2899 {
2900   tree decl, ident;
2901   char buf[256];
2902
2903   if (section == class_names)
2904     sprintf (buf, "_OBJC_CLASS_NAME_%d", class_names_idx++);
2905   else if (section == meth_var_names)
2906     sprintf (buf, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
2907   else if (section == meth_var_types)
2908     sprintf (buf, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
2909
2910   ident = get_identifier (buf);
2911
2912   decl = build_decl (input_location,
2913                      VAR_DECL, ident, build_array_type (char_type_node, 0));
2914   DECL_EXTERNAL (decl) = 1;
2915   TREE_PUBLIC (decl) = 0;
2916   TREE_USED (decl) = 1;
2917   TREE_CONSTANT (decl) = 1;
2918   DECL_CONTEXT (decl) = 0;
2919   DECL_ARTIFICIAL (decl) = 1;
2920 #ifdef OBJCPLUS
2921   DECL_THIS_STATIC (decl) = 1; /* squash redeclaration errors */
2922 #endif
2923
2924   make_decl_rtl (decl);
2925   pushdecl_top_level (decl);
2926
2927   return decl;
2928 }
2929
2930
2931 void
2932 objc_declare_alias (tree alias_ident, tree class_ident)
2933 {
2934   tree underlying_class;
2935
2936 #ifdef OBJCPLUS
2937   if (current_namespace != global_namespace) {
2938     error ("Objective-C declarations may only appear in global scope");
2939   }
2940 #endif /* OBJCPLUS */
2941
2942   if (!(underlying_class = objc_is_class_name (class_ident)))
2943     warning (0, "cannot find class %qE", class_ident);
2944   else if (objc_is_class_name (alias_ident))
2945     warning (0, "class %qE already exists", alias_ident);
2946   else
2947     {
2948       /* Implement @compatibility_alias as a typedef.  */
2949 #ifdef OBJCPLUS
2950       push_lang_context (lang_name_c); /* extern "C" */
2951 #endif
2952       lang_hooks.decls.pushdecl (build_decl
2953                                  (input_location,
2954                                   TYPE_DECL,
2955                                   alias_ident,
2956                                   xref_tag (RECORD_TYPE, underlying_class)));
2957 #ifdef OBJCPLUS
2958       pop_lang_context ();
2959 #endif
2960       alias_chain = tree_cons (underlying_class, alias_ident, alias_chain);
2961     }
2962 }
2963
2964 void
2965 objc_declare_class (tree ident_list)
2966 {
2967   tree list;
2968 #ifdef OBJCPLUS
2969   if (current_namespace != global_namespace) {
2970     error ("Objective-C declarations may only appear in global scope");
2971   }
2972 #endif /* OBJCPLUS */
2973
2974   for (list = ident_list; list; list = TREE_CHAIN (list))
2975     {
2976       tree ident = TREE_VALUE (list);
2977
2978       if (! objc_is_class_name (ident))
2979         {
2980           tree record = lookup_name (ident), type = record;
2981
2982           if (record)
2983             {
2984               if (TREE_CODE (record) == TYPE_DECL)
2985                 type = DECL_ORIGINAL_TYPE (record);
2986
2987               if (!TYPE_HAS_OBJC_INFO (type)
2988                   || !TYPE_OBJC_INTERFACE (type))
2989                 {
2990                   error ("%qE redeclared as different kind of symbol",
2991                          ident);
2992                   error ("previous declaration of %q+D",
2993                          record);
2994                 }
2995             }
2996
2997           record = xref_tag (RECORD_TYPE, ident);
2998           INIT_TYPE_OBJC_INFO (record);
2999           TYPE_OBJC_INTERFACE (record) = ident;
3000           class_chain = tree_cons (NULL_TREE, ident, class_chain);
3001         }
3002     }
3003 }
3004
3005 tree
3006 objc_is_class_name (tree ident)
3007 {
3008   tree chain;
3009
3010   if (ident && TREE_CODE (ident) == IDENTIFIER_NODE
3011       && identifier_global_value (ident))
3012     ident = identifier_global_value (ident);
3013   while (ident && TREE_CODE (ident) == TYPE_DECL && DECL_ORIGINAL_TYPE (ident))
3014     ident = OBJC_TYPE_NAME (DECL_ORIGINAL_TYPE (ident));
3015
3016   if (ident && TREE_CODE (ident) == RECORD_TYPE)
3017     ident = OBJC_TYPE_NAME (ident);
3018 #ifdef OBJCPLUS
3019   if (ident && TREE_CODE (ident) == TYPE_DECL)
3020     ident = DECL_NAME (ident);
3021 #endif
3022   if (!ident || TREE_CODE (ident) != IDENTIFIER_NODE)
3023     return NULL_TREE;
3024
3025   if (lookup_interface (ident))
3026     return ident;
3027
3028   for (chain = class_chain; chain; chain = TREE_CHAIN (chain))
3029     {
3030       if (ident == TREE_VALUE (chain))
3031         return ident;
3032     }
3033
3034   for (chain = alias_chain; chain; chain = TREE_CHAIN (chain))
3035     {
3036       if (ident == TREE_VALUE (chain))
3037         return TREE_PURPOSE (chain);
3038     }
3039
3040   return 0;
3041 }
3042
3043 /* Check whether TYPE is either 'id' or 'Class'.  */
3044
3045 tree
3046 objc_is_id (tree type)
3047 {
3048   if (type && TREE_CODE (type) == IDENTIFIER_NODE
3049       && identifier_global_value (type))
3050     type = identifier_global_value (type);
3051
3052   if (type && TREE_CODE (type) == TYPE_DECL)
3053     type = TREE_TYPE (type);
3054
3055   /* NB: This function may be called before the ObjC front-end has
3056      been initialized, in which case OBJC_OBJECT_TYPE will (still) be NULL.  */
3057   return (objc_object_type && type
3058           && (IS_ID (type) || IS_CLASS (type) || IS_SUPER (type))
3059           ? type
3060           : NULL_TREE);
3061 }
3062
3063 /* Check whether TYPE is either 'id', 'Class', or a pointer to an ObjC
3064    class instance.  This is needed by other parts of the compiler to
3065    handle ObjC types gracefully.  */
3066
3067 tree
3068 objc_is_object_ptr (tree type)
3069 {
3070   tree ret;
3071
3072   type = TYPE_MAIN_VARIANT (type);
3073   if (!POINTER_TYPE_P (type))
3074     return 0;
3075
3076   ret = objc_is_id (type);
3077   if (!ret)
3078     ret = objc_is_class_name (TREE_TYPE (type));
3079
3080   return ret;
3081 }
3082
3083 static int
3084 objc_is_gcable_type (tree type, int or_strong_p)
3085 {
3086   tree name;
3087
3088   if (!TYPE_P (type))
3089     return 0;
3090   if (objc_is_id (TYPE_MAIN_VARIANT (type)))
3091     return 1;
3092   if (or_strong_p && lookup_attribute ("objc_gc", TYPE_ATTRIBUTES (type)))
3093     return 1;
3094   if (TREE_CODE (type) != POINTER_TYPE && TREE_CODE (type) != INDIRECT_REF)
3095     return 0;
3096   type = TREE_TYPE (type);
3097   if (TREE_CODE (type) != RECORD_TYPE)
3098     return 0;
3099   name = TYPE_NAME (type);
3100   return (objc_is_class_name (name) != NULL_TREE);
3101 }
3102
3103 static tree
3104 objc_substitute_decl (tree expr, tree oldexpr, tree newexpr)
3105 {
3106   if (expr == oldexpr)
3107     return newexpr;
3108
3109   switch (TREE_CODE (expr))
3110     {
3111     case COMPONENT_REF:
3112       return objc_build_component_ref
3113              (objc_substitute_decl (TREE_OPERAND (expr, 0),
3114                                     oldexpr,
3115                                     newexpr),
3116               DECL_NAME (TREE_OPERAND (expr, 1)));
3117     case ARRAY_REF:
3118       return build_array_ref (input_location,
3119                               objc_substitute_decl (TREE_OPERAND (expr, 0),
3120                                                     oldexpr,
3121                                                     newexpr),
3122                               TREE_OPERAND (expr, 1));
3123     case INDIRECT_REF:
3124       return build_indirect_ref (input_location,
3125                                  objc_substitute_decl (TREE_OPERAND (expr, 0),
3126                                                        oldexpr,
3127                                                        newexpr), RO_ARROW);
3128     default:
3129       return expr;
3130     }
3131 }
3132
3133 static tree
3134 objc_build_ivar_assignment (tree outervar, tree lhs, tree rhs)
3135 {
3136   tree func_params;
3137   /* The LHS parameter contains the expression 'outervar->memberspec';
3138      we need to transform it into '&((typeof(outervar) *) 0)->memberspec',
3139      where memberspec may be arbitrarily complex (e.g., 'g->f.d[2].g[3]').
3140   */
3141   tree offs
3142     = objc_substitute_decl
3143       (lhs, outervar, convert (TREE_TYPE (outervar), integer_zero_node));
3144   tree func
3145     = (flag_objc_direct_dispatch
3146        ? objc_assign_ivar_fast_decl
3147        : objc_assign_ivar_decl);
3148
3149   offs = convert (integer_type_node, build_unary_op (input_location,
3150                                                      ADDR_EXPR, offs, 0));
3151   offs = fold (offs);
3152   func_params = tree_cons (NULL_TREE,
3153         convert (objc_object_type, rhs),
3154             tree_cons (NULL_TREE, convert (objc_object_type, outervar),
3155                 tree_cons (NULL_TREE, offs,
3156                     NULL_TREE)));
3157
3158   assemble_external (func);
3159   return build_function_call (input_location, func, func_params);
3160 }
3161
3162 static tree
3163 objc_build_global_assignment (tree lhs, tree rhs)
3164 {
3165   tree func_params = tree_cons (NULL_TREE,
3166         convert (objc_object_type, rhs),
3167             tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3168                       build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3169                     NULL_TREE));
3170
3171   assemble_external (objc_assign_global_decl);
3172   return build_function_call (input_location, 
3173                               objc_assign_global_decl, func_params);
3174 }
3175
3176 static tree
3177 objc_build_strong_cast_assignment (tree lhs, tree rhs)
3178 {
3179   tree func_params = tree_cons (NULL_TREE,
3180         convert (objc_object_type, rhs),
3181             tree_cons (NULL_TREE, convert (build_pointer_type (objc_object_type),
3182                       build_unary_op (input_location, ADDR_EXPR, lhs, 0)),
3183                     NULL_TREE));
3184
3185   assemble_external (objc_assign_strong_cast_decl);
3186   return build_function_call (input_location,
3187                               objc_assign_strong_cast_decl, func_params);
3188 }
3189
3190 static int
3191 objc_is_gcable_p (tree expr)
3192 {
3193   return (TREE_CODE (expr) == COMPONENT_REF
3194           ? objc_is_gcable_p (TREE_OPERAND (expr, 1))
3195           : TREE_CODE (expr) == ARRAY_REF
3196           ? (objc_is_gcable_p (TREE_TYPE (expr))
3197              || objc_is_gcable_p (TREE_OPERAND (expr, 0)))
3198           : TREE_CODE (expr) == ARRAY_TYPE
3199           ? objc_is_gcable_p (TREE_TYPE (expr))
3200           : TYPE_P (expr)
3201           ? objc_is_gcable_type (expr, 1)
3202           : (objc_is_gcable_p (TREE_TYPE (expr))
3203              || (DECL_P (expr)
3204                  && lookup_attribute ("objc_gc", DECL_ATTRIBUTES (expr)))));
3205 }
3206
3207 static int
3208 objc_is_ivar_reference_p (tree expr)
3209 {
3210   return (TREE_CODE (expr) == ARRAY_REF
3211           ? objc_is_ivar_reference_p (TREE_OPERAND (expr, 0))
3212           : TREE_CODE (expr) == COMPONENT_REF
3213           ? TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL
3214           : 0);
3215 }
3216
3217 static int
3218 objc_is_global_reference_p (tree expr)
3219 {
3220   return (TREE_CODE (expr) == INDIRECT_REF || TREE_CODE (expr) == PLUS_EXPR
3221           ? objc_is_global_reference_p (TREE_OPERAND (expr, 0))
3222           : DECL_P (expr)
3223           ? (!DECL_CONTEXT (expr) || TREE_STATIC (expr))
3224           : 0);
3225 }
3226
3227 tree
3228 objc_generate_write_barrier (tree lhs, enum tree_code modifycode, tree rhs)
3229 {
3230   tree result = NULL_TREE, outer;
3231   int strong_cast_p = 0, outer_gc_p = 0, indirect_p = 0;
3232
3233   /* See if we have any lhs casts, and strip them out.  NB: The lvalue casts
3234      will have been transformed to the form '*(type *)&expr'.  */
3235   if (TREE_CODE (lhs) == INDIRECT_REF)
3236     {
3237       outer = TREE_OPERAND (lhs, 0);
3238
3239       while (!strong_cast_p
3240              && (CONVERT_EXPR_P (outer)
3241                  || TREE_CODE (outer) == NON_LVALUE_EXPR))
3242         {
3243           tree lhstype = TREE_TYPE (outer);
3244
3245           /* Descend down the cast chain, and record the first objc_gc
3246              attribute found.  */
3247           if (POINTER_TYPE_P (lhstype))
3248             {
3249               tree attr
3250                 = lookup_attribute ("objc_gc",
3251                                     TYPE_ATTRIBUTES (TREE_TYPE (lhstype)));
3252
3253               if (attr)
3254                 strong_cast_p = 1;
3255             }
3256
3257           outer = TREE_OPERAND (outer, 0);
3258         }
3259     }
3260
3261   /* If we have a __strong cast, it trumps all else.  */
3262   if (strong_cast_p)
3263     {
3264       if (modifycode != NOP_EXPR)
3265         goto invalid_pointer_arithmetic;
3266
3267       if (warn_assign_intercept)
3268         warning (0, "strong-cast assignment has been intercepted");
3269
3270       result = objc_build_strong_cast_assignment (lhs, rhs);
3271
3272       goto exit_point;
3273     }
3274
3275   /* the lhs must be of a suitable type, regardless of its underlying
3276      structure.  */
3277   if (!objc_is_gcable_p (lhs))
3278     goto exit_point;
3279
3280   outer = lhs;
3281
3282   while (outer
3283          && (TREE_CODE (outer) == COMPONENT_REF
3284              || TREE_CODE (outer) == ARRAY_REF))
3285     outer = TREE_OPERAND (outer, 0);
3286
3287   if (TREE_CODE (outer) == INDIRECT_REF)
3288     {
3289       outer = TREE_OPERAND (outer, 0);
3290       indirect_p = 1;
3291     }
3292
3293   outer_gc_p = objc_is_gcable_p (outer);
3294
3295   /* Handle ivar assignments. */
3296   if (objc_is_ivar_reference_p (lhs))
3297     {
3298       /* if the struct to the left of the ivar is not an Objective-C object (__strong
3299          doesn't cut it here), the best we can do here is suggest a cast.  */
3300       if (!objc_is_gcable_type (TREE_TYPE (outer), 0))
3301         {
3302           /* We may still be able to use the global write barrier... */
3303           if (!indirect_p && objc_is_global_reference_p (outer))
3304             goto global_reference;
3305
3306          suggest_cast:
3307           if (modifycode == NOP_EXPR)
3308             {
3309               if (warn_assign_intercept)
3310                 warning (0, "strong-cast may possibly be needed");
3311             }
3312
3313           goto exit_point;
3314         }
3315
3316       if (modifycode != NOP_EXPR)
3317         goto invalid_pointer_arithmetic;
3318
3319       if (warn_assign_intercept)
3320         warning (0, "instance variable assignment has been intercepted");
3321
3322       result = objc_build_ivar_assignment (outer, lhs, rhs);
3323
3324       goto exit_point;
3325     }
3326
3327   /* Likewise, intercept assignment to global/static variables if their type is
3328      GC-marked.  */
3329   if (objc_is_global_reference_p (outer))
3330     {
3331       if (indirect_p)
3332         goto suggest_cast;
3333
3334      global_reference:
3335       if (modifycode != NOP_EXPR)
3336         {
3337          invalid_pointer_arithmetic:
3338           if (outer_gc_p)
3339             warning (0, "pointer arithmetic for garbage-collected objects not allowed");
3340
3341           goto exit_point;
3342         }
3343
3344       if (warn_assign_intercept)
3345         warning (0, "global/static variable assignment has been intercepted");
3346
3347       result = objc_build_global_assignment (lhs, rhs);
3348     }
3349
3350   /* In all other cases, fall back to the normal mechanism.  */
3351  exit_point:
3352   return result;
3353 }
3354
3355 struct GTY(()) interface_tuple {
3356   tree id;
3357   tree class_name;
3358 };
3359
3360 static GTY ((param_is (struct interface_tuple))) htab_t interface_htab;
3361
3362 static hashval_t
3363 hash_interface (const void *p)
3364 {
3365   const struct interface_tuple *d = (const struct interface_tuple *) p;
3366   return IDENTIFIER_HASH_VALUE (d->id);
3367 }
3368
3369 static int
3370 eq_interface (const void *p1, const void *p2)
3371 {
3372   const struct interface_tuple *d = (const struct interface_tuple *) p1;
3373   return d->id == p2;
3374 }
3375
3376 static tree
3377 lookup_interface (tree ident)
3378 {
3379 #ifdef OBJCPLUS
3380   if (ident && TREE_CODE (ident) == TYPE_DECL)
3381     ident = DECL_NAME (ident);
3382 #endif
3383
3384   if (ident == NULL_TREE || TREE_CODE (ident) != IDENTIFIER_NODE)
3385     return NULL_TREE;
3386
3387   {
3388     struct interface_tuple **slot;
3389     tree i = NULL_TREE;
3390
3391     if (interface_htab)
3392       {
3393         slot = (struct interface_tuple **)
3394           htab_find_slot_with_hash (interface_htab, ident,
3395                                     IDENTIFIER_HASH_VALUE (ident),
3396                                     NO_INSERT);
3397         if (slot && *slot)
3398           i = (*slot)->class_name;
3399       }
3400     return i;
3401   }
3402 }
3403
3404 /* Implement @defs (<classname>) within struct bodies.  */
3405
3406 tree
3407 objc_get_class_ivars (tree class_name)
3408 {
3409   tree interface = lookup_interface (class_name);
3410
3411   if (interface)
3412     return get_class_ivars (interface, true);
3413
3414   error ("cannot find interface declaration for %qE",
3415          class_name);
3416
3417   return error_mark_node;
3418 }
3419
3420 /* Used by: build_private_template, continue_class,
3421    and for @defs constructs.  */
3422
3423 static tree
3424 get_class_ivars (tree interface, bool inherited)
3425 {
3426   tree ivar_chain = copy_list (CLASS_RAW_IVARS (interface));
3427
3428   /* Both CLASS_RAW_IVARS and CLASS_IVARS contain a list of ivars declared
3429      by the current class (i.e., they do not include super-class ivars).
3430      However, the CLASS_IVARS list will be side-effected by a call to
3431      finish_struct(), which will fill in field offsets.  */
3432   if (!CLASS_IVARS (interface))
3433     CLASS_IVARS (interface) = ivar_chain;
3434
3435   if (!inherited)
3436     return ivar_chain;
3437
3438   while (CLASS_SUPER_NAME (interface))
3439     {
3440       /* Prepend super-class ivars.  */
3441       interface = lookup_interface (CLASS_SUPER_NAME (interface));
3442       ivar_chain = chainon (copy_list (CLASS_RAW_IVARS (interface)),
3443                             ivar_chain);
3444     }
3445
3446   return ivar_chain;
3447 }
3448
3449 static tree
3450 objc_create_temporary_var (tree type)
3451 {
3452   tree decl;
3453
3454   decl = build_decl (input_location,
3455                      VAR_DECL, NULL_TREE, type);
3456   TREE_USED (decl) = 1;
3457   DECL_ARTIFICIAL (decl) = 1;
3458   DECL_IGNORED_P (decl) = 1;
3459   DECL_CONTEXT (decl) = current_function_decl;
3460
3461   return decl;
3462 }
3463 \f
3464 /* Exception handling constructs.  We begin by having the parser do most
3465    of the work and passing us blocks.  What we do next depends on whether
3466    we're doing "native" exception handling or legacy Darwin setjmp exceptions.
3467    We abstract all of this in a handful of appropriately named routines.  */
3468
3469 /* Stack of open try blocks.  */
3470
3471 struct objc_try_context
3472 {
3473   struct objc_try_context *outer;
3474
3475   /* Statements (or statement lists) as processed by the parser.  */
3476   tree try_body;
3477   tree finally_body;
3478
3479   /* Some file position locations.  */
3480   location_t try_locus;
3481   location_t end_try_locus;
3482   location_t end_catch_locus;
3483   location_t finally_locus;
3484   location_t end_finally_locus;
3485
3486   /* A STATEMENT_LIST of CATCH_EXPRs, appropriate for sticking into op1
3487      of a TRY_CATCH_EXPR.  Even when doing Darwin setjmp.  */
3488   tree catch_list;
3489
3490   /* The CATCH_EXPR of an open @catch clause.  */
3491   tree current_catch;
3492
3493   /* The VAR_DECL holding the Darwin equivalent of __builtin_eh_pointer.  */
3494   tree caught_decl;
3495   tree stack_decl;
3496   tree rethrow_decl;
3497 };
3498
3499 static struct objc_try_context *cur_try_context;
3500
3501 static GTY(()) tree objc_eh_personality_decl;
3502
3503 /* This hook, called via lang_eh_runtime_type, generates a runtime object
3504    that represents TYPE.  For Objective-C, this is just the class name.  */
3505 /* ??? Isn't there a class object or some such?  Is it easy to get?  */
3506
3507 #ifndef OBJCPLUS
3508 tree
3509 objc_eh_runtime_type (tree type)
3510 {
3511   return add_objc_string (OBJC_TYPE_NAME (TREE_TYPE (type)), class_names);
3512 }
3513
3514 tree
3515 objc_eh_personality (void)
3516 {
3517   if (!flag_objc_sjlj_exceptions
3518       && !objc_eh_personality_decl)
3519     objc_eh_personality_decl
3520       = build_personality_function (USING_SJLJ_EXCEPTIONS
3521                                     ? "__gnu_objc_personality_sj0"
3522                                     : "__gnu_objc_personality_v0");
3523
3524   return objc_eh_personality_decl;
3525 }
3526 #endif
3527
3528 /* Build __builtin_eh_pointer, or the moral equivalent.  In the case
3529    of Darwin, we'll arrange for it to be initialized (and associated
3530    with a binding) later.  */
3531
3532 static tree
3533 objc_build_exc_ptr (void)
3534 {
3535   if (flag_objc_sjlj_exceptions)
3536     {
3537       tree var = cur_try_context->caught_decl;
3538       if (!var)
3539         {
3540           var = objc_create_temporary_var (objc_object_type);
3541           cur_try_context->caught_decl = var;
3542         }
3543       return var;
3544     }
3545   else
3546     {
3547       tree t;
3548       t = built_in_decls[BUILT_IN_EH_POINTER];
3549       t = build_call_expr (t, 1, integer_zero_node);
3550       return fold_convert (objc_object_type, t);
3551     }
3552 }
3553
3554 /* Build "objc_exception_try_exit(&_stack)".  */
3555
3556 static tree
3557 next_sjlj_build_try_exit (void)
3558 {
3559   tree t;
3560   t = build_fold_addr_expr_loc (input_location, cur_try_context->stack_decl);
3561   t = tree_cons (NULL, t, NULL);
3562   t = build_function_call (input_location,
3563                            objc_exception_try_exit_decl, t);
3564   return t;
3565 }
3566
3567 /* Build
3568         objc_exception_try_enter (&_stack);
3569         if (_setjmp(&_stack.buf))
3570           ;
3571         else
3572           ;
3573    Return the COND_EXPR.  Note that the THEN and ELSE fields are left
3574    empty, ready for the caller to fill them in.  */
3575
3576 static tree
3577 next_sjlj_build_enter_and_setjmp (void)
3578 {
3579   tree t, enter, sj, cond;