VOP_FSYNC.9: Missing comma
[dragonfly.git] / contrib / gcc-4.7 / gcc / objc / objc-next-runtime-abi-01.c
1 /* Next Runtime (ABI-0/1) private.
2    Copyright (C) 2011 Free Software Foundation, Inc.
3    Contributed by Iain Sandoe (split from objc-act.c)
4
5 This file is part of GCC.
6
7 GCC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 GCC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING3.  If not see
19 <http://www.gnu.org/licenses/>.  */
20
21 /* This implements the original NeXT ABI (0) used for m32 code and
22    indicated by module version 6.  It also implements the small number
23    of additions made for properties and optional protocol methods as
24    ABI=1 (module version 7).  */
25
26 #include "config.h"
27 #include "system.h"
28 #include "coretypes.h"
29 #include "tm.h"
30 #include "tree.h"
31
32 #ifdef OBJCPLUS
33 #include "cp-tree.h"
34 #else
35 #include "c-tree.h"
36 #include "c-lang.h"
37 #endif
38 #include "langhooks.h"
39 #include "c-family/c-objc.h"
40 #include "objc-act.h"
41
42 /* When building Objective-C++, we are not linking against the C
43    front-end and so need to replicate the C tree-construction
44    functions in some way.  */
45 #ifdef OBJCPLUS
46 #define OBJCP_REMAP_FUNCTIONS
47 #include "objcp-decl.h"
48 #endif  /* OBJCPLUS */
49
50 #include "ggc.h"
51 #include "target.h"
52 #include "output.h"
53 #include "tree-iterator.h"
54
55 #include "objc-runtime-hooks.h"
56 #include "objc-runtime-shared-support.h"
57 #include "objc-encoding.h"
58
59 /* NeXT ABI 0 and 1 private definitions.  */
60 #define DEF_CONSTANT_STRING_CLASS_NAME "NSConstantString"
61
62 #define TAG_GETCLASS                    "objc_getClass"
63 #define TAG_GETMETACLASS                "objc_getMetaClass"
64
65 #define TAG_MSGSEND                     "objc_msgSend"
66 #define TAG_MSGSENDSUPER                "objc_msgSendSuper"
67 #define TAG_MSGSEND_STRET               "objc_msgSend_stret"
68 #define TAG_MSGSENDSUPER_STRET          "objc_msgSendSuper_stret"
69
70 /* NeXT-specific tags.  */
71
72 #define TAG_MSGSEND_NONNIL              "objc_msgSendNonNil"
73 #define TAG_MSGSEND_NONNIL_STRET        "objc_msgSendNonNil_stret"
74 #define TAG_EXCEPTIONEXTRACT            "objc_exception_extract"
75 #define TAG_EXCEPTIONTRYENTER           "objc_exception_try_enter"
76 #define TAG_EXCEPTIONTRYEXIT            "objc_exception_try_exit"
77 #define TAG_EXCEPTIONMATCH              "objc_exception_match"
78 #define TAG_SETJMP                      "_setjmp"
79
80 #define TAG_ASSIGNIVAR                  "objc_assign_ivar"
81 #define TAG_ASSIGNGLOBAL                "objc_assign_global"
82 #define TAG_ASSIGNSTRONGCAST            "objc_assign_strongCast"
83
84 /* Branch entry points.  All that matters here are the addresses;
85    functions with these names do not really exist in libobjc.  */
86
87 #define TAG_MSGSEND_FAST                "objc_msgSend_Fast"
88 #define TAG_ASSIGNIVAR_FAST             "objc_assign_ivar_Fast"
89
90 /* The version identifies which language generation and runtime the
91    module (file) was compiled for, and is recorded in the module
92    descriptor.  */
93 #define OBJC_VERSION                    (flag_objc_abi >= 1 ? 7 : 6)
94
95 #define UTAG_CLASS_EXT                  "_objc_class_ext"
96 #define UTAG_PROPERTY_LIST              "_prop_list_t"
97 #define UTAG_PROTOCOL_EXT               "_objc_protocol_extension"
98
99 #define CLS_HAS_CXX_STRUCTORS           0x2000L
100
101 /* rt_trees identifiers - shared between NeXT implementations.  These
102    allow the FE to tag meta-data in a manner that survives LTO and can
103    be used when the runtime requires that certain meta-data items
104    appear in particular named sections.  */
105
106 #include "objc-next-metadata-tags.h"
107 extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX];
108
109 static void next_runtime_01_initialize (void);
110
111 static tree next_runtime_abi_01_super_superclassfield_id (void);
112
113 static tree next_runtime_abi_01_class_decl (tree);
114 static tree next_runtime_abi_01_metaclass_decl (tree);
115 static tree next_runtime_abi_01_category_decl (tree);
116 static tree next_runtime_abi_01_protocol_decl (tree);
117 static tree next_runtime_abi_01_string_decl (tree, const char *, string_section);
118
119 static tree next_runtime_abi_01_get_class_reference (tree);
120 static tree next_runtime_abi_01_build_selector_reference (location_t, tree, tree);
121 static tree next_runtime_abi_01_get_protocol_reference (location_t, tree);
122 static tree next_runtime_abi_01_build_ivar_ref (location_t, tree, tree);
123 static tree next_runtime_abi_01_get_class_super_ref (location_t, struct imp_entry *, bool);
124 static tree next_runtime_abi_01_get_category_super_ref (location_t, struct imp_entry *, bool);
125
126 static tree next_runtime_abi_01_receiver_is_class_object (tree);
127 static void next_runtime_abi_01_get_arg_type_list_base (VEC(tree,gc) **, tree,
128                                                         int, int);
129 static tree next_runtime_abi_01_build_objc_method_call (location_t, tree, tree,
130                                                         tree, tree, tree, int);
131 static bool next_runtime_abi_01_setup_const_string_class_decl (void);
132 static tree next_runtime_abi_01_build_const_string_constructor (location_t, tree, int);
133
134 static void objc_generate_v1_next_metadata (void);
135
136 static void build_next_objc_exception_stuff (void);
137 static tree objc_eh_runtime_type (tree type);
138 static tree objc_eh_personality (void);
139 static tree build_throw_stmt (location_t, tree, bool);
140 static tree objc_build_exc_ptr (struct objc_try_context **);
141 static tree begin_catch (struct objc_try_context **, tree, tree, tree, bool);
142 static void finish_catch (struct objc_try_context **, tree);
143 static tree finish_try_stmt (struct objc_try_context **);
144
145 bool
146 objc_next_runtime_abi_01_init (objc_runtime_hooks *rthooks)
147 {
148   if (flag_objc_exceptions
149       && !flag_objc_sjlj_exceptions)
150     {
151       warning_at (UNKNOWN_LOCATION, OPT_Wall,
152                 "%<-fobjc-sjlj-exceptions%> is the only supported exceptions "
153                 "system for %<-fnext-runtime%> with %<-fobjc-abi-version%> < 2");
154     }
155
156   rthooks->initialize = next_runtime_01_initialize;
157   rthooks->default_constant_string_class_name = DEF_CONSTANT_STRING_CLASS_NAME;
158   rthooks->tag_getclass = TAG_GETCLASS;
159   rthooks->super_superclassfield_ident = next_runtime_abi_01_super_superclassfield_id;
160
161   rthooks->class_decl = next_runtime_abi_01_class_decl;
162   rthooks->metaclass_decl = next_runtime_abi_01_metaclass_decl;
163   rthooks->category_decl = next_runtime_abi_01_category_decl;
164   rthooks->protocol_decl = next_runtime_abi_01_protocol_decl;
165   rthooks->string_decl = next_runtime_abi_01_string_decl;
166
167   rthooks->get_class_reference = next_runtime_abi_01_get_class_reference;
168   rthooks->build_selector_reference = next_runtime_abi_01_build_selector_reference;
169   rthooks->get_protocol_reference = next_runtime_abi_01_get_protocol_reference;
170   rthooks->build_ivar_reference = next_runtime_abi_01_build_ivar_ref;
171   rthooks->get_class_super_ref = next_runtime_abi_01_get_class_super_ref;
172   rthooks->get_category_super_ref = next_runtime_abi_01_get_category_super_ref;
173
174   rthooks->receiver_is_class_object = next_runtime_abi_01_receiver_is_class_object;
175   rthooks->get_arg_type_list_base = next_runtime_abi_01_get_arg_type_list_base;
176   rthooks->build_objc_method_call = next_runtime_abi_01_build_objc_method_call;
177
178   rthooks->setup_const_string_class_decl =
179                                 next_runtime_abi_01_setup_const_string_class_decl;
180   rthooks->build_const_string_constructor =
181                                 next_runtime_abi_01_build_const_string_constructor;
182
183   rthooks->build_throw_stmt = build_throw_stmt;
184   rthooks->build_exc_ptr = objc_build_exc_ptr;
185   rthooks->begin_catch = begin_catch;
186   rthooks->finish_catch = finish_catch;
187   rthooks->finish_try_stmt = finish_try_stmt;
188
189   rthooks->generate_metadata = objc_generate_v1_next_metadata;
190   return true;
191 }
192
193 /* We need a way to convey what kind of meta-data are represented by a
194    given variable, since each type is expected (by the runtime) to be
195    found in a specific named section.  The solution must be usable
196    with LTO.
197
198    The scheme used for NeXT ABI 0/1 (partial matching of variable
199    names) is not satisfactory for LTO & ABI-2.  We now tag ObjC
200    meta-data with identification attributes in the front end.  The
201    back-end may choose to act on these as it requires.  */
202
203 static void
204 next_runtime_abi_01_init_metadata_attributes (void)
205 {
206   if (!objc_meta)
207     objc_meta = get_identifier ("OBJC1META");
208
209   if (!meta_base)
210     meta_base = get_identifier ("V1_BASE");
211
212   meta_class = get_identifier ("V1_CLAS");
213   meta_metaclass = get_identifier ("V1_META");
214   meta_category = get_identifier ("V1_CATG");
215   meta_protocol = get_identifier ("V1_PROT");
216
217   meta_clac_vars = get_identifier ("V1_CLCV");
218   meta_clai_vars = get_identifier ("V1_CLIV");
219
220   meta_clac_meth = get_identifier ("V1_CLCM");
221   meta_clai_meth = get_identifier ("V1_CLIM");
222   meta_catc_meth = get_identifier ("V1_CACM");
223   meta_cati_meth = get_identifier ("V1_CAIM");
224   meta_proto_cls_meth = get_identifier ("V1_PCLM");
225   meta_proto_nst_meth = get_identifier ("V1_PNSM");
226
227   meta_clas_prot = get_identifier ("V1_CLPR");
228   meta_catg_prot = get_identifier ("V1_CAPR");
229
230   meta_class_reference = get_identifier ("V1_CLRF");
231   meta_proto_ref = get_identifier ("V1_PRFS");
232   meta_sel_refs = get_identifier ("V1_SRFS");
233
234   meta_class_name = get_identifier ("V1_CLSN");
235   meta_meth_name = get_identifier ("V1_METN");
236   meta_meth_type = get_identifier ("V1_METT");
237   meta_prop_name_attr = get_identifier ("V1_STRG");
238
239   meta_modules = get_identifier ("V1_MODU");
240   meta_symtab = get_identifier ("V1_SYMT");
241   meta_info = get_identifier ("V1_INFO");
242
243   meta_proplist = get_identifier ("V1_PLST");
244   meta_protocol_extension = get_identifier ("V1_PEXT");
245   meta_class_extension = get_identifier ("V1_CEXT");
246
247   meta_const_str = get_identifier ("V1_CSTR");
248 }
249
250 static void build_v1_class_template (void);
251 static void build_v1_category_template (void);
252 static void build_v1_protocol_template (void);
253
254 static void next_runtime_01_initialize (void)
255 {
256   tree type;
257
258 #ifdef OBJCPLUS
259   /* For all NeXT objc ABIs -fobjc-call-cxx-cdtors is on by
260      default.  */
261   if (!global_options_set.x_flag_objc_call_cxx_cdtors)
262     global_options.x_flag_objc_call_cxx_cdtors = 1;
263 #endif
264
265   /* Set up attributes to be attached to the meta-data so that they
266      will be placed in the correct sections.  */
267   next_runtime_abi_01_init_metadata_attributes ();
268
269   if (flag_objc_abi >= 1)
270     objc_prop_list_ptr = build_pointer_type (xref_tag (RECORD_TYPE,
271                                              get_identifier ("_prop_list_t")));
272
273  /* Declare type of selector-objects that represent an operation
274     name.  */
275   /* `struct objc_selector *' */
276   objc_selector_type = build_pointer_type (xref_tag (RECORD_TYPE,
277                                            get_identifier (TAG_SELECTOR)));
278
279   build_v1_class_template ();
280   build_super_template ();
281   build_v1_protocol_template ();
282   build_v1_category_template ();
283
284   /* NB: In order to call one of the ..._stret (struct-returning)
285      functions, the function *MUST* first be cast to a signature that
286      corresponds to the actual ObjC method being invoked.  This is
287      what is done by the build_objc_method_call() routine below.  */
288
289   /* id objc_msgSend (id, SEL, ...); */
290   /* id objc_msgSendNonNil (id, SEL, ...); */
291   /* id objc_msgSend_stret (id, SEL, ...); */
292   /* id objc_msgSendNonNil_stret (id, SEL, ...); */
293   type = build_varargs_function_type_list (objc_object_type,
294                                            objc_object_type,
295                                            objc_selector_type,
296                                            NULL_TREE);
297
298   umsg_decl = add_builtin_function (TAG_MSGSEND,
299                                     type, 0, NOT_BUILT_IN,
300                                     NULL, NULL_TREE);
301
302   umsg_nonnil_decl = add_builtin_function (TAG_MSGSEND_NONNIL,
303                                            type, 0, NOT_BUILT_IN,
304                                             NULL, NULL_TREE);
305
306   umsg_stret_decl = add_builtin_function (TAG_MSGSEND_STRET,
307                                           type, 0, NOT_BUILT_IN,
308                                           NULL, NULL_TREE);
309
310   umsg_nonnil_stret_decl = add_builtin_function (TAG_MSGSEND_NONNIL_STRET,
311                                                  type, 0, NOT_BUILT_IN,
312                                                  NULL, NULL_TREE);
313
314   /* These can throw, because the function that gets called can throw
315      in Obj-C++, or could itself call something that can throw even in
316      Obj-C.  */
317   TREE_NOTHROW (umsg_decl) = 0;
318   TREE_NOTHROW (umsg_nonnil_decl) = 0;
319   TREE_NOTHROW (umsg_stret_decl) = 0;
320   TREE_NOTHROW (umsg_nonnil_stret_decl) = 0;
321
322  /* id objc_msgSend_Fast (id, SEL, ...)
323            __attribute__ ((hard_coded_address (OFFS_MSGSEND_FAST))); */
324 #ifdef OFFS_MSGSEND_FAST
325   umsg_fast_decl = add_builtin_function (TAG_MSGSEND_FAST,
326                                              type, 0, NOT_BUILT_IN,
327                                              NULL, NULL_TREE);
328   TREE_NOTHROW (umsg_fast_decl) = 0;
329   DECL_ATTRIBUTES (umsg_fast_decl)
330         = tree_cons (get_identifier ("hard_coded_address"),
331                      build_int_cst (NULL_TREE, OFFS_MSGSEND_FAST),
332                      NULL_TREE);
333 #else
334   /* No direct dispatch available.  */
335   umsg_fast_decl = umsg_decl;
336 #endif
337
338   /* id objc_msgSendSuper (struct objc_super *, SEL, ...); */
339   /* id objc_msgSendSuper_stret (struct objc_super *, SEL, ...); */
340   type = build_varargs_function_type_list (objc_object_type,
341                                             objc_super_type,
342                                             objc_selector_type,
343                                             NULL_TREE);
344   umsg_super_decl = add_builtin_function (TAG_MSGSENDSUPER,
345                                               type, 0, NOT_BUILT_IN,
346                                               NULL, NULL_TREE);
347   umsg_super_stret_decl = add_builtin_function (TAG_MSGSENDSUPER_STRET,
348                                                     type, 0, NOT_BUILT_IN, 0,
349                                                     NULL_TREE);
350   TREE_NOTHROW (umsg_super_decl) = 0;
351   TREE_NOTHROW (umsg_super_stret_decl) = 0;
352
353   type = build_function_type_list (objc_object_type,
354                                    const_string_type_node,
355                                    NULL_TREE);
356
357   /* id objc_getClass (const char *); */
358   objc_get_class_decl
359     = add_builtin_function (TAG_GETCLASS, type, 0, NOT_BUILT_IN,
360                             NULL, NULL_TREE);
361
362   /* id objc_getMetaClass (const char *); */
363   objc_get_meta_class_decl
364     = add_builtin_function (TAG_GETMETACLASS, type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
365
366   /* This is the type of all of the following functions
367      objc_copyStruct().  */
368   type = build_function_type_list (void_type_node,
369                                    ptr_type_node,
370                                    const_ptr_type_node,
371                                    ptrdiff_type_node,
372                                    boolean_type_node,
373                                    boolean_type_node,
374                                    NULL_TREE);
375   /* Declare the following function:
376          void
377          objc_copyStruct (void *destination, const void *source,
378                           ptrdiff_t size, BOOL is_atomic, BOOL has_strong); */
379   objc_copyStruct_decl = add_builtin_function ("objc_copyStruct",
380                                                    type, 0, NOT_BUILT_IN,
381                                                    NULL, NULL_TREE);
382   TREE_NOTHROW (objc_copyStruct_decl) = 0;
383   objc_getPropertyStruct_decl = NULL_TREE;
384   objc_setPropertyStruct_decl = NULL_TREE;
385
386   build_next_objc_exception_stuff ();
387   if (flag_objc_exceptions && !flag_objc_sjlj_exceptions)
388     using_eh_for_cleanups ();
389   lang_hooks.eh_runtime_type = objc_eh_runtime_type;
390   lang_hooks.eh_personality = objc_eh_personality;
391 }
392
393 /* --- templates --- */
394
395 /* struct _objc_class
396    {
397      struct _objc_class *isa;
398      struct _objc_class *super_class;
399      char *name;
400      long version;
401      long info;
402      long instance_size;
403      struct _objc_ivar_list *ivars;
404      struct _objc_method_list *methods;
405      struct objc_cache *cache;
406      struct _objc_protocol_list *protocols;
407    #if ABI=1
408      const char *ivar_layout;
409      struct _objc_class_ext *ext;
410    #else
411      void *sel_id;
412      void *gc_object_type;
413     #endif
414    }; */
415
416 /* The 'sel_id' & 'gc_object_type' fields are not used by the NeXT
417    runtime.  We generate them for ABI==0 to maintain backward binary
418    compatibility.  */
419
420 static void
421 build_v1_class_template (void)
422 {
423   tree ptype, decls, *chain = NULL;
424
425   objc_class_template = objc_start_struct (get_identifier (UTAG_CLASS));
426
427   /* struct _objc_class *isa; */
428   decls = add_field_decl (build_pointer_type (objc_class_template),
429                           "isa", &chain);
430
431   /* struct _objc_class *super_class; */
432   add_field_decl (build_pointer_type (objc_class_template),
433                   "super_class", &chain);
434
435   /* char *name; */
436   add_field_decl (string_type_node, "name", &chain);
437
438   /* long version; */
439   add_field_decl (long_integer_type_node, "version", &chain);
440
441   /* long info; */
442   add_field_decl (long_integer_type_node, "info", &chain);
443
444   /* long instance_size; */
445   add_field_decl (long_integer_type_node, "instance_size", &chain);
446
447   /* struct _objc_ivar_list *ivars; */
448   add_field_decl (objc_ivar_list_ptr,"ivars", &chain);
449
450   /* struct _objc_method_list *methods; */
451   add_field_decl (objc_method_list_ptr, "methods", &chain);
452
453   /* struct objc_cache *cache; */
454   ptype = build_pointer_type (xref_tag (RECORD_TYPE,
455                                             get_identifier ("objc_cache")));
456   add_field_decl (ptype, "cache", &chain);
457
458   /* struct _objc_protocol **protocol_list; */
459   ptype = build_pointer_type (build_pointer_type
460                               (xref_tag (RECORD_TYPE,
461                                          get_identifier (UTAG_PROTOCOL))));
462   add_field_decl (ptype, "protocol_list", &chain);
463
464   if (flag_objc_abi >= 1)
465     {
466       /* const char *ivar_layout; */
467       add_field_decl (const_string_type_node, "ivar_layout", &chain);
468
469       /* struct _objc_class_ext *ext; */
470       ptype = build_pointer_type (xref_tag (RECORD_TYPE,
471                                             get_identifier (UTAG_CLASS_EXT)));
472       add_field_decl (ptype, "ext", &chain);
473     }
474   else
475     {
476       /* void *sel_id; */
477       add_field_decl (build_pointer_type (void_type_node), "sel_id", &chain);
478       /* void *gc_object_type; */
479       add_field_decl (build_pointer_type (void_type_node), "gc_object_type",
480                       &chain);
481     }
482
483   objc_finish_struct (objc_class_template, decls);
484 }
485
486 /* struct _objc_category
487    {
488      char *category_name;
489      char *class_name;
490      struct _objc_method_list *instance_methods;
491      struct _objc_method_list *class_methods;
492      struct _objc_protocol_list *protocols;
493    #if ABI=1
494      uint32_t size;     // sizeof (struct _objc_category)
495      struct _objc_property_list *instance_properties;  // category's own @property decl.
496    #endif
497    };   */
498
499 static void
500 build_v1_category_template (void)
501 {
502   tree ptype, decls, *chain = NULL;
503
504   objc_category_template = objc_start_struct (get_identifier (UTAG_CATEGORY));
505
506   /* char *category_name; */
507   decls = add_field_decl (string_type_node, "category_name", &chain);
508
509   /* char *class_name; */
510   add_field_decl (string_type_node, "class_name", &chain);
511
512   /* struct _objc_method_list *instance_methods; */
513   add_field_decl (objc_method_list_ptr, "instance_methods", &chain);
514
515   /* struct _objc_method_list *class_methods; */
516   add_field_decl (objc_method_list_ptr, "class_methods", &chain);
517
518   /* struct _objc_protocol **protocol_list; */
519   ptype = build_pointer_type (build_pointer_type (objc_protocol_template));
520   add_field_decl (ptype, "protocol_list", &chain);
521
522   if (flag_objc_abi >= 1)
523     {
524       add_field_decl (integer_type_node, "size", &chain);
525
526       /* struct _objc_property_list *instance_properties;
527          This field describes a category's @property declarations.
528          Properties from inherited protocols are not included.  */
529       ptype = build_pointer_type (xref_tag (RECORD_TYPE,
530                                             get_identifier (UTAG_PROPERTY_LIST)));
531       add_field_decl (ptype, "instance_properties", &chain);
532     }
533   objc_finish_struct (objc_category_template, decls);
534 }
535
536 /* Begin code generation for protocols...
537    Modified for ObjC #1 extensions.  */
538
539 /* struct _objc_protocol
540    {
541    #if ABI=1
542      struct _objc_protocol_extension *isa;
543    #else
544      struct _objc_class *isa;
545    #endif
546
547      char *protocol_name;
548      struct _objc_protocol **protocol_list;
549      struct _objc__method_prototype_list *instance_methods;
550      struct _objc__method_prototype_list *class_methods;
551    }; */
552
553 static void
554 build_v1_protocol_template (void)
555 {
556   tree ptype, decls, *chain = NULL;
557
558   objc_protocol_template = objc_start_struct (get_identifier (UTAG_PROTOCOL));
559
560   if (flag_objc_abi >= 1)
561     /* struct _objc_protocol_extension *isa; */
562     ptype = build_pointer_type (xref_tag (RECORD_TYPE,
563                                           get_identifier (UTAG_PROTOCOL_EXT)));
564   else
565     /* struct _objc_class *isa; */
566     ptype = build_pointer_type (xref_tag (RECORD_TYPE,
567                                         get_identifier (UTAG_CLASS)));
568
569   decls = add_field_decl (ptype, "isa", &chain);
570
571   /* char *protocol_name; */
572   add_field_decl (string_type_node, "protocol_name", &chain);
573
574   /* struct _objc_protocol **protocol_list; */
575   ptype = build_pointer_type (build_pointer_type (objc_protocol_template));
576   add_field_decl (ptype, "protocol_list", &chain);
577
578   /* struct _objc__method_prototype_list *instance_methods; */
579   add_field_decl (objc_method_proto_list_ptr, "instance_methods", &chain);
580
581   /* struct _objc__method_prototype_list *class_methods; */
582   add_field_decl (objc_method_proto_list_ptr, "class_methods", &chain);
583
584   objc_finish_struct (objc_protocol_template, decls);
585 }
586
587 /* --- names, decls identifers --- */
588
589 static tree
590 next_runtime_abi_01_super_superclassfield_id (void)
591 {
592   if (!super_superclassfield_id)
593     super_superclassfield_id = get_identifier ("super_class");
594   return super_superclassfield_id;
595 }
596
597 static tree
598 next_runtime_abi_01_class_decl (tree klass)
599 {
600   tree decl;
601   char buf[BUFSIZE];
602   snprintf (buf, BUFSIZE, "_OBJC_Class_%s",
603             IDENTIFIER_POINTER (CLASS_NAME (klass)));
604   decl = start_var_decl (objc_class_template, buf);
605   OBJCMETA (decl, objc_meta, meta_class);
606   return decl;
607 }
608
609 static tree
610 next_runtime_abi_01_metaclass_decl (tree klass)
611 {
612   tree decl;
613   char buf[BUFSIZE];
614   snprintf (buf, BUFSIZE, "_OBJC_MetaClass_%s",
615             IDENTIFIER_POINTER (CLASS_NAME (klass)));
616   decl = start_var_decl (objc_class_template, buf);
617   OBJCMETA (decl, objc_meta, meta_metaclass);
618   return decl;
619 }
620
621 static tree
622 next_runtime_abi_01_category_decl (tree klass)
623 {
624   tree decl;
625   char buf[BUFSIZE];
626   snprintf (buf, BUFSIZE, "_OBJC_Category_%s_on_%s",
627             IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass)),
628             IDENTIFIER_POINTER (CLASS_NAME (klass)));
629   decl = start_var_decl (objc_category_template, buf);
630   OBJCMETA (decl, objc_meta, meta_category);
631   return decl;
632 }
633
634 static tree
635 next_runtime_abi_01_protocol_decl (tree p)
636 {
637   tree decl;
638   char buf[BUFSIZE];
639
640   /* static struct _objc_protocol _OBJC_Protocol_<mumble>; */
641
642   snprintf (buf, BUFSIZE, "_OBJC_Protocol_%s",
643             IDENTIFIER_POINTER (PROTOCOL_NAME (p)));
644   decl = start_var_decl (objc_protocol_template, buf);
645   OBJCMETA (decl, objc_meta, meta_protocol);
646   return decl;
647 }
648
649 static tree
650 next_runtime_abi_01_string_decl (tree type, const char *name,  string_section where)
651 {
652   tree var = start_var_decl (type, name);
653   switch (where)
654     {
655       case class_names:
656         OBJCMETA (var, objc_meta, meta_class_name);
657         break;
658       case meth_var_names:
659         OBJCMETA (var, objc_meta, meta_meth_name);
660         break;
661       case meth_var_types:
662         OBJCMETA (var, objc_meta, meta_meth_type);
663         break;
664       case prop_names_attr:
665         OBJCMETA (var, objc_meta, meta_prop_name_attr);
666         break;
667       default:
668         OBJCMETA (var, objc_meta, meta_base);
669         break;
670     }
671   return var;
672 }
673
674 /* --- entry --- */
675
676 static GTY(()) int class_reference_idx;
677
678 static tree
679 build_class_reference_decl (void)
680 {
681   tree decl;
682   char buf[BUFSIZE];
683
684   sprintf (buf, "_OBJC_ClassRefs_%d", class_reference_idx++);
685   decl = start_var_decl (objc_class_type, buf);
686
687   return decl;
688 }
689
690 static tree
691 next_runtime_abi_01_get_class_reference (tree ident)
692 {
693   if (!flag_zero_link)
694     {
695       tree *chain;
696       tree decl;
697
698       for (chain = &cls_ref_chain; *chain; chain = &TREE_CHAIN (*chain))
699         if (TREE_VALUE (*chain) == ident)
700           {
701             if (! TREE_PURPOSE (*chain))
702               TREE_PURPOSE (*chain) = build_class_reference_decl ();
703
704             return TREE_PURPOSE (*chain);
705           }
706
707       decl = build_class_reference_decl ();
708       *chain = tree_cons (decl, ident, NULL_TREE);
709       return decl;
710     }
711   else
712     {
713       tree params;
714
715       add_class_reference (ident);
716
717       params = build_tree_list (NULL_TREE,
718                                 my_build_string_pointer
719                                 (IDENTIFIER_LENGTH (ident) + 1,
720                                  IDENTIFIER_POINTER (ident)));
721
722       return build_function_call (input_location, objc_get_class_decl, params);
723     }
724 }
725
726 /* Used by build_function_type_for_method.  Append the types for
727    receiver & _cmd at the start of a method argument list to ARGTYPES.
728    CONTEXT is either METHOD_DEF or METHOD_REF, saying whether we are
729    trying to define a method or call one.  SUPERFLAG says this is for a
730    send to super.  METH may be NULL, in the case that there is no
731    prototype.  */
732
733 static void
734 next_runtime_abi_01_get_arg_type_list_base (VEC(tree,gc) **argtypes, tree meth,
735                                             int context, int superflag)
736 {
737   tree receiver_type;
738
739   if (superflag)
740     receiver_type = objc_super_type;
741   else if (context == METHOD_DEF && TREE_CODE (meth) == INSTANCE_METHOD_DECL)
742     receiver_type = objc_instance_type;
743   else
744     receiver_type = objc_object_type;
745
746   VEC_safe_push (tree, gc, *argtypes, receiver_type);
747   /* Selector type - will eventually change to `int'.  */
748   VEC_safe_push (tree, gc, *argtypes, objc_selector_type);
749 }
750
751 static tree
752 next_runtime_abi_01_receiver_is_class_object (tree receiver)
753 {
754   if (TREE_CODE (receiver) == VAR_DECL
755       && IS_CLASS (TREE_TYPE (receiver)))
756     {
757       /* The receiver is a variable created by build_class_reference_decl.  */
758       tree chain = cls_ref_chain ;
759       /* Look up the identifier in the relevant chain.  */
760       for (; chain; chain = TREE_CHAIN (chain))
761         if (TREE_PURPOSE (chain) == receiver)
762           return TREE_VALUE (chain);
763     }
764   return NULL_TREE;
765 }
766
767 static tree
768 build_selector_reference_decl (tree ident)
769 {
770   tree decl;
771   char *t, buf[BUFSIZE];
772
773   snprintf (buf, BUFSIZE, "_OBJC_SelRef_%s", IDENTIFIER_POINTER (ident));
774   t = buf;
775   while (*t)
776     {
777       if (*t==':')
778         *t = '$'; /* Underscore would clash between foo:bar and foo_bar.  */
779       t++;
780     }
781   decl = start_var_decl (objc_selector_type, buf);
782   OBJCMETA (decl, objc_meta, meta_sel_refs);
783   return decl;
784 }
785
786 static tree
787 next_runtime_abi_01_build_selector_reference (location_t loc ATTRIBUTE_UNUSED,
788                                               tree ident,
789                                               tree proto ATTRIBUTE_UNUSED)
790 {
791   tree *chain = &sel_ref_chain;
792   tree expr;
793
794   while (*chain)
795     {
796       if (TREE_VALUE (*chain) == ident)
797         return TREE_PURPOSE (*chain);
798
799       chain = &TREE_CHAIN (*chain);
800     }
801
802   expr = build_selector_reference_decl (ident);
803
804   *chain = tree_cons (expr, ident, NULL_TREE);
805
806   return expr;
807 }
808
809 /* Build a tree expression to send OBJECT the operation SELECTOR,
810    looking up the method on object LOOKUP_OBJECT (often same as OBJECT),
811    assuming the method has prototype METHOD_PROTOTYPE.
812    (That is an INSTANCE_METHOD_DECL or CLASS_METHOD_DECL.)
813    LOC is the location of the expression to build.
814    Use METHOD_PARAMS as list of args to pass to the method.
815    If SUPER_FLAG is nonzero, we look up the superclass's method.  */
816
817 static tree
818 build_objc_method_call (location_t loc, int super_flag, tree method_prototype,
819                         tree lookup_object, tree selector,
820                         tree method_params)
821 {
822   tree sender, sender_cast, method, t;
823   tree rcv_p = (super_flag ? objc_super_type : objc_object_type);
824   VEC(tree, gc) *parms;
825   unsigned nparm = (method_params ? list_length (method_params) : 0);
826
827   /* If a prototype for the method to be called exists, then cast
828      the sender's return type and arguments to match that of the method.
829      Otherwise, leave sender as is.  */
830   tree ret_type
831     = (method_prototype
832        ? TREE_VALUE (TREE_TYPE (method_prototype))
833        : objc_object_type);
834   tree ftype = build_function_type_for_method (ret_type, method_prototype,
835                                                METHOD_REF, super_flag);
836
837   if (method_prototype && METHOD_TYPE_ATTRIBUTES (method_prototype))
838     ftype = build_type_attribute_variant (ftype,
839                                           METHOD_TYPE_ATTRIBUTES
840                                           (method_prototype));
841
842   sender_cast = build_pointer_type (ftype);
843
844   lookup_object = build_c_cast (loc, rcv_p, lookup_object);
845
846   /* Use SAVE_EXPR to avoid evaluating the receiver twice.  */
847   lookup_object = save_expr (lookup_object);
848
849   /* Param list + 2 slots for object and selector.  */
850   parms = VEC_alloc (tree, gc, nparm + 2);
851
852   /* If we are returning a struct in memory, and the address
853      of that memory location is passed as a hidden first
854      argument, then change which messenger entry point this
855      expr will call.  NB: Note that sender_cast remains
856      unchanged (it already has a struct return type).  */
857   if (!targetm.calls.struct_value_rtx (0, 0)
858       && (TREE_CODE (ret_type) == RECORD_TYPE
859           || TREE_CODE (ret_type) == UNION_TYPE)
860       && targetm.calls.return_in_memory (ret_type, 0))
861     sender = (super_flag ? umsg_super_stret_decl
862                          : flag_nil_receivers ? umsg_stret_decl
863                                               : umsg_nonnil_stret_decl);
864   else
865     sender = (super_flag ? umsg_super_decl
866                          : (flag_nil_receivers  ? (flag_objc_direct_dispatch
867                                                         ? umsg_fast_decl
868                                                         : umsg_decl)
869                                                 : umsg_nonnil_decl));
870   method = build_fold_addr_expr_loc (loc, sender);
871
872   /* Pass the object to the method.  */
873   VEC_quick_push (tree, parms, lookup_object);
874   /* Pass the selector to the method.  */
875   VEC_quick_push (tree, parms, selector);
876   /* Now append the remainder of the parms.  */
877   if (nparm)
878     for (; method_params; method_params = TREE_CHAIN (method_params))
879       VEC_quick_push (tree, parms, TREE_VALUE (method_params));
880
881   /* Build an obj_type_ref, with the correct cast for the method call.  */
882   t = build3 (OBJ_TYPE_REF, sender_cast, method,
883                             lookup_object, size_zero_node);
884   t = build_function_call_vec (loc, t, parms, NULL);
885   VEC_free (tree, gc, parms);
886   return t;
887 }
888
889 static tree
890 next_runtime_abi_01_build_objc_method_call (location_t loc,
891                                             tree method_prototype,
892                                             tree receiver,
893                                             tree rtype ATTRIBUTE_UNUSED,
894                                             tree sel_name,
895                                             tree method_params,
896                                             int super)
897 {
898   tree selector = next_runtime_abi_01_build_selector_reference (loc, sel_name,
899                                                                 NULL_TREE);
900
901   return build_objc_method_call (loc, super, method_prototype,
902                                  receiver, selector, method_params);
903 }
904
905 static tree
906 next_runtime_abi_01_get_protocol_reference (location_t loc, tree p)
907 {
908   tree expr;
909
910   if (!PROTOCOL_FORWARD_DECL (p))
911     PROTOCOL_FORWARD_DECL (p) = next_runtime_abi_01_protocol_decl (p);
912
913   expr = build_unary_op (loc, ADDR_EXPR, PROTOCOL_FORWARD_DECL (p), 0);
914   return convert (objc_protocol_type, expr);
915 }
916
917 /* For ABI 0/1 and IVAR is just a fixed offset in the class struct.  */
918
919 static tree
920 next_runtime_abi_01_build_ivar_ref (location_t loc ATTRIBUTE_UNUSED,
921                                    tree base, tree id)
922 {
923   return objc_build_component_ref (base, id);
924 }
925
926 /* We build super class references as we need them (but keep them once
927    built for the sake of efficiency).  */
928
929 static tree
930 next_runtime_abi_01_get_class_super_ref (location_t loc ATTRIBUTE_UNUSED,
931                                          struct imp_entry *imp, bool inst_meth)
932 {
933   if (inst_meth)
934     {
935       if (!ucls_super_ref)
936         ucls_super_ref =
937                 objc_build_component_ref (imp->class_decl,
938                                           get_identifier ("super_class"));
939         return ucls_super_ref;
940     }
941   else
942     {
943       if (!uucls_super_ref)
944         uucls_super_ref =
945                 objc_build_component_ref (imp->meta_decl,
946                                           get_identifier ("super_class"));
947         return uucls_super_ref;
948     }
949 }
950
951 static tree
952 next_runtime_abi_01_get_category_super_ref (location_t loc ATTRIBUTE_UNUSED,
953                                            struct imp_entry *imp, bool inst_meth)
954 {
955   tree super_name = CLASS_SUPER_NAME (imp->imp_template);
956   tree super_class;
957
958   if (!flag_zero_link)
959     {
960       super_class = objc_get_class_reference (super_name);
961
962       if (!inst_meth)
963
964         /* If we are in a class method, we must retrieve the
965            _metaclass_ for the current class, pointed at by
966            the class's "isa" pointer.  The following assumes that
967            "isa" is the first ivar in a class (which it must be).  */
968            super_class =
969                 build_indirect_ref (input_location,
970                                     build_c_cast (input_location,
971                                         build_pointer_type (objc_class_type),
972                                         super_class),
973                                     RO_UNARY_STAR);
974       return super_class;
975     }
976
977   /* else do it the slow way.  */
978   add_class_reference (super_name);
979   super_class = (inst_meth ? objc_get_class_decl : objc_get_meta_class_decl);
980 /* assemble_external (super_class);*/
981   super_name = my_build_string_pointer (IDENTIFIER_LENGTH (super_name) + 1,
982                                         IDENTIFIER_POINTER (super_name));
983   /* super_class = objc_get{Meta}Class("CLASS_SUPER_NAME"); */
984   return build_function_call (input_location,
985                               super_class,
986                               build_tree_list (NULL_TREE, super_name));
987 }
988
989 static bool
990 next_runtime_abi_01_setup_const_string_class_decl (void)
991 {
992   if (!constant_string_global_id)
993     {
994       /* Hopefully, this should not represent a serious limitation.  */
995       char buf[BUFSIZE];
996       snprintf (buf, BUFSIZE, "_%sClassReference", constant_string_class_name);
997       constant_string_global_id = get_identifier (buf);
998     }
999
1000   string_class_decl = lookup_name (constant_string_global_id);
1001
1002   return (string_class_decl != NULL_TREE);
1003 }
1004
1005 static tree
1006 next_runtime_abi_01_build_const_string_constructor (location_t loc, tree string,
1007                                                    int length)
1008 {
1009   tree constructor, fields, var;
1010   VEC(constructor_elt,gc) *v = NULL;
1011
1012   /* NeXT:   (NSConstantString *) & ((__builtin_ObjCString) { isa, string, length })   */
1013   fields = TYPE_FIELDS (internal_const_str_type);
1014   CONSTRUCTOR_APPEND_ELT (v, fields,
1015                           build_unary_op (loc, ADDR_EXPR, string_class_decl, 0));
1016
1017   fields = DECL_CHAIN (fields);
1018   CONSTRUCTOR_APPEND_ELT (v, fields,
1019                           build_unary_op (loc, ADDR_EXPR, string, 1));
1020
1021   /* ??? check if this should be long.  */
1022   fields = DECL_CHAIN (fields);
1023   CONSTRUCTOR_APPEND_ELT (v, fields, build_int_cst (NULL_TREE, length));
1024   constructor = objc_build_constructor (internal_const_str_type, v);
1025
1026   var = build_decl (input_location, CONST_DECL, NULL, TREE_TYPE (constructor));
1027   DECL_INITIAL (var) = constructor;
1028   TREE_STATIC (var) = 1;
1029   DECL_CONTEXT (var) = NULL;
1030   OBJCMETA (var, objc_meta, meta_const_str);
1031   return var;
1032 }
1033
1034 /* ---  metadata templates --- */
1035
1036 /* This routine builds the following type:
1037    struct _prop_t {
1038      const char * const name;                   // property name
1039      const char * const attributes;             // comma-delimited, encoded,
1040                                                 // property attributes
1041    };
1042 */
1043
1044 static GTY(()) tree objc_v1_property_template;
1045
1046 static tree
1047 build_v1_property_template (void)
1048 {
1049   tree prop_record;
1050   tree decls, *chain = NULL;
1051
1052   prop_record = objc_start_struct (get_identifier ("_prop_t"));
1053   /* const char * name */
1054   decls = add_field_decl (string_type_node, "name", &chain);
1055
1056   /* const char * attribute */
1057   add_field_decl (string_type_node, "attribute", &chain);
1058
1059   objc_finish_struct (prop_record, decls);
1060   return prop_record;
1061 }
1062
1063 /* Build the following type:
1064
1065   struct _objc_protocol_extension
1066     {
1067       uint32_t size;    // sizeof (struct _objc_protocol_extension)
1068       struct objc_method_list   *optional_instance_methods;
1069       struct objc_method_list   *optional_class_methods;
1070       struct objc_prop_list     *instance_properties;
1071     }
1072 */
1073
1074 static GTY(()) tree objc_protocol_extension_template;
1075
1076 static void
1077 build_v1_objc_protocol_extension_template (void)
1078 {
1079   tree decls, *chain = NULL;
1080
1081   objc_protocol_extension_template =
1082         objc_start_struct (get_identifier (UTAG_PROTOCOL_EXT));
1083
1084   /*  uint32_t size; */
1085   decls = add_field_decl (integer_type_node, "size", &chain);
1086
1087   /* struct objc_method_list   *optional_instance_methods; */
1088   add_field_decl (objc_method_list_ptr, "optional_instance_methods", &chain);
1089
1090   /* struct objc_method_list   *optional_class_methods; */
1091   add_field_decl (objc_method_list_ptr, "optional_class_methods", &chain);
1092
1093   /* struct objc_prop_list     *instance_properties; */
1094   add_field_decl (objc_prop_list_ptr, "instance_properties", &chain);
1095
1096   objc_finish_struct (objc_protocol_extension_template, decls);
1097 }
1098
1099 /* This routine build following struct type:
1100    struct _objc_class_ext
1101      {
1102        uint32_t size;   // sizeof(struct _objc_class_ext)
1103        const char *weak_ivar_layout;
1104        struct _prop_list_t *properties;
1105      }
1106 */
1107
1108 static GTY(()) tree objc_class_ext_template;
1109
1110 static void
1111 build_objc_class_ext_template (void)
1112 {
1113   tree ptrt, decls, *chain = NULL;
1114
1115   objc_class_ext_template = objc_start_struct (get_identifier (UTAG_CLASS_EXT));
1116
1117   /* uint32_t size; */
1118   decls = add_field_decl (integer_type_node, "size", &chain);
1119
1120   /* const char *weak_ivar_layout; */
1121   add_field_decl (const_string_type_node, "weak_ivar_layout", &chain);
1122
1123   /* struct _prop_list_t *properties; */
1124   ptrt = build_pointer_type (xref_tag (RECORD_TYPE,
1125                              get_identifier(UTAG_PROPERTY_LIST)));
1126   add_field_decl (ptrt, "properties", &chain);
1127
1128   objc_finish_struct (objc_class_ext_template, decls);
1129 }
1130
1131 static void
1132 build_metadata_templates (void)
1133 {
1134
1135   if (!objc_method_template)
1136     objc_method_template = build_method_template ();
1137
1138
1139
1140 }
1141
1142 /* --- emit metadata --- */
1143
1144 static tree
1145 generate_v1_meth_descriptor_table (tree chain, tree protocol,
1146                                    const char *prefix, tree attr)
1147 {
1148   tree method_list_template, initlist, decl;
1149   int size;
1150   VEC(constructor_elt,gc) *v = NULL;
1151   char buf[BUFSIZE];
1152
1153   if (!chain || !prefix)
1154     return NULL_TREE;
1155
1156   if (!objc_method_prototype_template)
1157     objc_method_prototype_template = build_method_prototype_template ();
1158
1159   size = list_length (chain);
1160   method_list_template =
1161         build_method_prototype_list_template (objc_method_prototype_template,
1162                                               size);
1163   snprintf (buf, BUFSIZE, "%s_%s", prefix,
1164             IDENTIFIER_POINTER (PROTOCOL_NAME (protocol)));
1165
1166   decl = start_var_decl (method_list_template, buf);
1167
1168   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
1169   initlist =
1170         build_descriptor_table_initializer (objc_method_prototype_template,
1171                                             chain);
1172   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist);
1173   /* Get into the right section.  */
1174   OBJCMETA (decl, objc_meta, attr);
1175   finish_var_decl (decl, objc_build_constructor (method_list_template, v));
1176   return decl;
1177 }
1178
1179 /* Build protocol ext =
1180    {size, opt_instance_meth, opt_class_meth, instance_props};
1181    or NULL_TREE if none are present.  */
1182
1183 static tree
1184 generate_v1_objc_protocol_extension (tree proto_interface,
1185                                      tree opt_instance_meth,
1186                                      tree opt_class_meth,
1187                                      tree instance_props)
1188 {
1189   int size;
1190   location_t loc;
1191   VEC(constructor_elt,gc) *v = NULL;
1192   tree decl, expr;
1193   char buf[BUFSIZE];
1194
1195   /* If there are no extensions, then don't bother... */
1196   if (!opt_instance_meth && !opt_class_meth && !instance_props)
1197     return NULL_TREE;
1198
1199   if (!objc_protocol_extension_template)
1200     build_v1_objc_protocol_extension_template ();
1201
1202   /* uint32_t size */
1203   size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_protocol_extension_template));
1204   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
1205
1206   /* Try for meaningful diagnostics.  */
1207   loc = DECL_SOURCE_LOCATION (PROTOCOL_FORWARD_DECL (proto_interface));
1208
1209   /* struct objc_method_list *optional_instance_methods; */
1210   if (opt_instance_meth)
1211     expr = convert (objc_method_list_ptr,
1212                     build_unary_op (loc, ADDR_EXPR, opt_instance_meth, 0));
1213   else
1214     expr = convert (objc_method_list_ptr, null_pointer_node);
1215
1216   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1217
1218   /* struct objc_method_list *optional_class_methods; */
1219   if (opt_class_meth)
1220     expr = convert (objc_method_list_ptr,
1221                     build_unary_op (loc, ADDR_EXPR, opt_class_meth, 0));
1222   else
1223     expr = convert (objc_method_list_ptr, null_pointer_node);
1224
1225   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1226   /* struct objc_prop_list *instance_properties; */
1227   if (instance_props)
1228       expr = convert (objc_prop_list_ptr,
1229                       build_unary_op (loc, ADDR_EXPR, instance_props, 0));
1230   else
1231     expr = convert (objc_prop_list_ptr, null_pointer_node);
1232
1233   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1234   snprintf (buf, BUFSIZE, "_OBJC_ProtocolExt_%s",
1235             IDENTIFIER_POINTER (PROTOCOL_NAME (proto_interface)));
1236
1237   decl = start_var_decl (objc_protocol_extension_template, buf);
1238   expr = objc_build_constructor (TREE_TYPE (decl), v);
1239   OBJCMETA (decl, objc_meta, meta_protocol_extension);
1240   finish_var_decl (decl, expr);
1241   return decl;
1242 }
1243
1244 /* This routine builds the following type:
1245    struct _prop_list_t {
1246      uint32_t entsize;                  // sizeof (struct _prop_t)
1247      uint32_t prop_count;
1248      struct _prop_t prop_list [prop_count];
1249    }
1250 */
1251
1252 static tree
1253 build_v1_property_list_template (tree list_type, int size)
1254 {
1255   tree property_list_t_record;
1256   tree array_type, decls, *chain = NULL;
1257
1258   /* anonymous.  */
1259   property_list_t_record = objc_start_struct (NULL_TREE);
1260
1261   /* uint32_t const entsize */
1262   decls = add_field_decl (integer_type_node, "entsize", &chain);
1263
1264   /* int prop_count */
1265   add_field_decl (integer_type_node, "prop_count", &chain);
1266
1267   /* struct _prop_t prop_list[]; */
1268   array_type = build_sized_array_type (list_type, size);
1269   add_field_decl (array_type, "prop_list", &chain);
1270
1271   objc_finish_struct (property_list_t_record, decls);
1272   return property_list_t_record;
1273 }
1274
1275 /* This routine builds the initializer list to initialize the
1276    'struct _prop_t prop_list[]'  field of 'struct _prop_list_t' meta-data. */
1277
1278 static tree
1279 build_v1_property_table_initializer (tree type, tree context)
1280 {
1281   tree x;
1282   VEC(constructor_elt,gc) *inits = NULL;
1283
1284   if (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE)
1285     x = CLASS_PROPERTY_DECL (context);
1286   else
1287     x = IMPL_PROPERTY_DECL (context);
1288
1289   for (; x; x = TREE_CHAIN (x))
1290     {
1291       VEC(constructor_elt,gc) *elemlist = NULL;
1292       tree attribute, name_ident = PROPERTY_NAME (x);
1293
1294       CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE,
1295                               add_objc_string (name_ident, prop_names_attr));
1296
1297       attribute = objc_v2_encode_prop_attr (x);
1298       CONSTRUCTOR_APPEND_ELT (elemlist, NULL_TREE,
1299                               add_objc_string (attribute, prop_names_attr));
1300
1301       CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
1302                               objc_build_constructor (type, elemlist));
1303     }
1304
1305   return objc_build_constructor (build_array_type (type, 0),inits);
1306 }
1307
1308 /* This routine builds the 'struct _prop_list_t' variable declaration and
1309    initializes it with its initializer list. TYPE is 'struct _prop_list_t',
1310    NAME is the internal name of this variable, SIZE is number of properties
1311    for this class and LIST is the initializer list for its 'prop_list' field. */
1312
1313 static tree
1314 generate_v1_property_table (tree context, tree klass_ctxt)
1315 {
1316   tree x, decl, initlist, property_list_template;
1317   bool is_proto = false;
1318   VEC(constructor_elt,gc) *inits = NULL;
1319   int init_val, size = 0;
1320   char buf[BUFSIZE];
1321
1322   if (context)
1323     {
1324       gcc_assert (TREE_CODE (context) == PROTOCOL_INTERFACE_TYPE);
1325       x = CLASS_PROPERTY_DECL (context);
1326       is_proto = true;
1327     }
1328   else
1329     x = IMPL_PROPERTY_DECL (klass_ctxt);
1330
1331   for (; x; x = TREE_CHAIN (x))
1332     size++;
1333
1334   if (size == 0)
1335     return NULL_TREE;
1336
1337   if (!objc_v1_property_template)
1338     objc_v1_property_template = build_v1_property_template ();
1339
1340   property_list_template =
1341         build_v1_property_list_template (objc_v1_property_template,
1342                                          size);
1343   initlist = build_v1_property_table_initializer (objc_v1_property_template,
1344                                                   is_proto ? context
1345                                                            : klass_ctxt);
1346
1347   init_val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_v1_property_template));
1348   if (is_proto)
1349     snprintf (buf, BUFSIZE, "_OBJC_ProtocolPropList_%s",
1350               IDENTIFIER_POINTER (PROTOCOL_NAME (context)));
1351   else
1352     snprintf (buf, BUFSIZE, "_OBJC_ClassPropList_%s",
1353               IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)));
1354
1355   decl = start_var_decl (property_list_template, buf);
1356   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, init_val));
1357   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size));
1358   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist);
1359   x = objc_build_constructor (TREE_TYPE (decl), inits);
1360   OBJCMETA (decl, objc_meta, meta_proplist);
1361   finish_var_decl (decl, x);
1362   return decl;
1363 }
1364
1365 static tree
1366 generate_v1_protocol_list (tree i_or_p, tree klass_ctxt)
1367 {
1368   tree array_type, ptype, refs_decl, lproto, e, plist, attr;
1369   int size = 0;
1370   VEC(constructor_elt,gc) *v = NULL;
1371   char buf[BUFSIZE];
1372
1373   switch (TREE_CODE (i_or_p))
1374     {
1375     case CLASS_INTERFACE_TYPE:
1376     case CATEGORY_INTERFACE_TYPE:
1377       plist = CLASS_PROTOCOL_LIST (i_or_p);
1378       break;
1379     case PROTOCOL_INTERFACE_TYPE:
1380       plist = PROTOCOL_LIST (i_or_p);
1381       break;
1382     default:
1383       gcc_unreachable ();
1384     }
1385
1386   /* Compute size.  */
1387   for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
1388     if (TREE_CODE (TREE_VALUE (lproto)) == PROTOCOL_INTERFACE_TYPE
1389         && PROTOCOL_FORWARD_DECL (TREE_VALUE (lproto)))
1390       size++;
1391
1392   /* Build initializer.  */
1393   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, 0));
1394   e = build_int_cst (build_pointer_type (objc_protocol_template), size);
1395   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e);
1396
1397   for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
1398     {
1399       tree pval = TREE_VALUE (lproto);
1400
1401       if (TREE_CODE (pval) == PROTOCOL_INTERFACE_TYPE
1402           && PROTOCOL_FORWARD_DECL (pval))
1403         {
1404           tree fwref = PROTOCOL_FORWARD_DECL (pval);
1405           location_t loc = DECL_SOURCE_LOCATION (fwref) ;
1406           e = build_unary_op (loc, ADDR_EXPR, fwref, 0);
1407           CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, e);
1408         }
1409     }
1410
1411   /* static struct objc_protocol *refs[n]; */
1412   switch (TREE_CODE (i_or_p))
1413     {
1414     case PROTOCOL_INTERFACE_TYPE:
1415       snprintf (buf, BUFSIZE, "_OBJC_ProtocolRefs_%s",
1416                 IDENTIFIER_POINTER (PROTOCOL_NAME (i_or_p)));
1417       attr = meta_proto_ref;
1418       break;
1419     case CLASS_INTERFACE_TYPE:
1420       snprintf (buf, BUFSIZE, "_OBJC_ClassProtocols_%s",
1421                 IDENTIFIER_POINTER (CLASS_NAME (i_or_p)));
1422       attr = meta_clas_prot;
1423       break;
1424     case CATEGORY_INTERFACE_TYPE:
1425       snprintf (buf, BUFSIZE, "_OBJC_CategoryProtocols_%s_%s",
1426                 IDENTIFIER_POINTER (CLASS_NAME (klass_ctxt)),
1427                 IDENTIFIER_POINTER (CLASS_SUPER_NAME (klass_ctxt)));
1428       attr = meta_catg_prot;
1429       break;
1430     default:
1431       gcc_unreachable ();
1432     }
1433
1434   ptype = build_pointer_type (objc_protocol_template);
1435   array_type = build_sized_array_type (ptype, size + 3);
1436   refs_decl = start_var_decl (array_type, buf);
1437
1438   OBJCMETA (refs_decl, objc_meta, attr);
1439   finish_var_decl (refs_decl,
1440                    objc_build_constructor (TREE_TYPE (refs_decl), v));
1441
1442   return refs_decl;
1443 }
1444
1445 static tree
1446 build_v1_protocol_initializer (tree type, tree protocol_name, tree protocol_list,
1447                                tree inst_methods, tree class_methods,
1448                                tree protocol_ext)
1449 {
1450   tree expr, ttyp;
1451   location_t loc;
1452   VEC(constructor_elt,gc) *inits = NULL;
1453
1454   if (!objc_protocol_extension_template)
1455     build_v1_objc_protocol_extension_template ();
1456
1457   /* TODO: find a better representation of location from the inputs.  */
1458   loc = UNKNOWN_LOCATION;
1459   ttyp = build_pointer_type (objc_protocol_extension_template);
1460   /* Instead of jamming the protocol version number into the isa, we pass
1461      either a pointer to the protocol extension - or NULL.  */
1462   if (protocol_ext)
1463     expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, protocol_ext, 0));
1464   else
1465     expr = convert (ttyp, null_pointer_node);
1466
1467   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
1468   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_name);
1469   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, protocol_list);
1470
1471   ttyp = objc_method_proto_list_ptr;
1472   if (inst_methods)
1473     expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0));
1474   else
1475     expr = convert (ttyp, null_pointer_node);
1476   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
1477
1478   if (class_methods)
1479     expr = convert (ttyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0));
1480   else
1481     expr = convert (ttyp, null_pointer_node);
1482   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, expr);
1483
1484   return objc_build_constructor (type, inits);
1485 }
1486
1487 /* An updated version of generate_protocols () that emit the protocol
1488    extension for ABI=1.  */
1489
1490 /* For each protocol which was referenced either from a @protocol()
1491    expression, or because a class/category implements it (then a
1492    pointer to the protocol is stored in the struct describing the
1493    class/category), we create a statically allocated instance of the
1494    Protocol class.  The code is written in such a way as to generate
1495    as few Protocol objects as possible; we generate a unique Protocol
1496    instance for each protocol, and we don't generate a Protocol
1497    instance if the protocol is never referenced (either from a
1498    @protocol() or from a class/category implementation).  These
1499    statically allocated objects can be referred to via the static
1500    (that is, private to this module) symbols _OBJC_PROTOCOL_n.
1501
1502    The statically allocated Protocol objects that we generate here
1503    need to be fixed up at runtime in order to be used: the 'isa'
1504    pointer of the objects need to be set up to point to the 'Protocol'
1505    class, as known at runtime.
1506
1507    The NeXT runtime fixes up all protocols at program startup time,
1508    before main() is entered.  It uses a low-level trick to look up all
1509    those symbols, then loops on them and fixes them up.  */
1510
1511 /* TODO: finish getting rid of passing stuff around in globals.  */
1512
1513 static GTY(()) tree V1_Protocol_OPT_NST_METHODS_decl;
1514 static GTY(()) tree V1_Protocol_OPT_CLS_METHODS_decl;
1515 static GTY(()) tree V1_ProtocolExt_decl;
1516 static GTY(()) tree V1_Property_decl;
1517
1518 static void
1519 generate_v1_protocols (void)
1520 {
1521   tree p;
1522
1523   /* If a protocol was directly referenced, pull in indirect references.  */
1524   for (p = protocol_chain; p; p = TREE_CHAIN (p))
1525     if (PROTOCOL_FORWARD_DECL (p) && PROTOCOL_LIST (p))
1526       generate_protocol_references (PROTOCOL_LIST (p));
1527
1528   for (p = protocol_chain; p; p = TREE_CHAIN (p))
1529     {
1530       tree decl, encoding, initlist, protocol_name_expr;
1531       tree refs_type, refs_decl, refs_expr;
1532       location_t loc;
1533       tree nst_methods = PROTOCOL_NST_METHODS (p);
1534       tree cls_methods = PROTOCOL_CLS_METHODS (p);
1535
1536       /* If protocol wasn't referenced, don't generate any code.  */
1537       decl = PROTOCOL_FORWARD_DECL (p);
1538
1539       if (!decl)
1540         continue;
1541
1542       /* Make sure we link in the Protocol class.  */
1543       add_class_reference (get_identifier (PROTOCOL_OBJECT_CLASS_NAME));
1544
1545       while (nst_methods)
1546         {
1547           if (! METHOD_ENCODING (nst_methods))
1548             {
1549               encoding = encode_method_prototype (nst_methods);
1550               METHOD_ENCODING (nst_methods) = encoding;
1551             }
1552           nst_methods = TREE_CHAIN (nst_methods);
1553         }
1554
1555       UOBJC_INSTANCE_METHODS_decl =
1556         generate_v1_meth_descriptor_table (PROTOCOL_NST_METHODS (p), p,
1557                                            "_OBJC_ProtocolInstanceMethods",
1558                                            meta_proto_nst_meth);
1559
1560       while (cls_methods)
1561         {
1562           if (! METHOD_ENCODING (cls_methods))
1563             {
1564               encoding = encode_method_prototype (cls_methods);
1565               METHOD_ENCODING (cls_methods) = encoding;
1566             }
1567
1568           cls_methods = TREE_CHAIN (cls_methods);
1569         }
1570
1571       UOBJC_CLASS_METHODS_decl =
1572         generate_v1_meth_descriptor_table (PROTOCOL_CLS_METHODS (p), p,
1573                                            "_OBJC_ProtocolClassMethods",
1574                                            meta_proto_cls_meth);
1575
1576       /* There should be no optional methods for ABI-0 - but we need to
1577          check all this here before the lists are made.  */
1578       nst_methods = PROTOCOL_OPTIONAL_NST_METHODS (p);
1579       while (nst_methods)
1580         {
1581           if (! METHOD_ENCODING (nst_methods))
1582             {
1583               encoding = encode_method_prototype (nst_methods);
1584               METHOD_ENCODING (nst_methods) = encoding;
1585             }
1586           nst_methods = TREE_CHAIN (nst_methods);
1587         }
1588
1589       V1_Protocol_OPT_NST_METHODS_decl =
1590         generate_v1_meth_descriptor_table (PROTOCOL_OPTIONAL_NST_METHODS (p), p,
1591                                            "_OBJC_OptionalProtocolInstanceMethods",
1592                                            meta_proto_nst_meth);
1593
1594       cls_methods = PROTOCOL_OPTIONAL_CLS_METHODS (p);
1595       while (cls_methods)
1596         {
1597           if (! METHOD_ENCODING (cls_methods))
1598             {
1599               encoding = encode_method_prototype (cls_methods);
1600               METHOD_ENCODING (cls_methods) = encoding;
1601             }
1602
1603           cls_methods = TREE_CHAIN (cls_methods);
1604         }
1605
1606       V1_Protocol_OPT_CLS_METHODS_decl =
1607         generate_v1_meth_descriptor_table (PROTOCOL_OPTIONAL_CLS_METHODS (p), p,
1608                                            "_OBJC_OptionalProtocolClassMethods",
1609                                            meta_proto_cls_meth);
1610
1611       if (PROTOCOL_LIST (p))
1612         refs_decl = generate_v1_protocol_list (p, objc_implementation_context);
1613       else
1614         refs_decl = 0;
1615
1616       /* static struct objc_protocol _OBJC_PROTOCOL_<mumble>; */
1617       protocol_name_expr = add_objc_string (PROTOCOL_NAME (p), class_names);
1618       /* TODO: more locations to be fixed up... */
1619       loc = UNKNOWN_LOCATION;
1620       refs_type =
1621         build_pointer_type (build_pointer_type (objc_protocol_template));
1622       if (refs_decl)
1623         refs_expr = convert (refs_type,
1624                              build_unary_op (loc, ADDR_EXPR, refs_decl, 0));
1625       else
1626         refs_expr = convert (refs_type, null_pointer_node);
1627
1628       if (flag_objc_abi < 1)
1629         {
1630           /* Original ABI.  */
1631           initlist =
1632                 build_protocol_initializer (TREE_TYPE (decl),
1633                                             protocol_name_expr, refs_expr,
1634                                             UOBJC_INSTANCE_METHODS_decl,
1635                                             UOBJC_CLASS_METHODS_decl);
1636           finish_var_decl (decl, initlist);
1637           continue;
1638         }
1639
1640       /* else - V1 extensions.  */
1641
1642       V1_Property_decl =
1643                 generate_v1_property_table (p, NULL_TREE);
1644
1645       V1_ProtocolExt_decl =
1646         generate_v1_objc_protocol_extension (p,
1647                                              V1_Protocol_OPT_NST_METHODS_decl,
1648                                              V1_Protocol_OPT_CLS_METHODS_decl,
1649                                              V1_Property_decl);
1650
1651       initlist = build_v1_protocol_initializer (TREE_TYPE (decl),
1652                                                 protocol_name_expr, refs_expr,
1653                                                 UOBJC_INSTANCE_METHODS_decl,
1654                                                 UOBJC_CLASS_METHODS_decl,
1655                                                 V1_ProtocolExt_decl);
1656       finish_var_decl (decl, initlist);
1657     }
1658 }
1659
1660 static tree
1661 generate_dispatch_table (tree chain, const char *name, tree attr)
1662 {
1663   tree decl, method_list_template, initlist;
1664   VEC(constructor_elt,gc) *v = NULL;
1665   int size;;
1666
1667   if (!chain || !name || !(size = list_length (chain)))
1668     return NULL_TREE;
1669
1670   if (!objc_method_template)
1671     objc_method_template = build_method_template ();
1672
1673   method_list_template = build_method_list_template (objc_method_template,
1674                                                      size);
1675   initlist = build_dispatch_table_initializer (objc_method_template, chain);
1676
1677   decl = start_var_decl (method_list_template, name);
1678
1679   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node);
1680   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1681                           build_int_cst (integer_type_node, size));
1682   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, initlist);
1683
1684   OBJCMETA (decl, objc_meta, attr);
1685   finish_var_decl (decl,
1686                    objc_build_constructor (TREE_TYPE (decl), v));
1687
1688   return decl;
1689 }
1690
1691 /* Init a category.  */
1692 static tree
1693 build_v1_category_initializer (tree type, tree cat_name, tree class_name,
1694                                 tree inst_methods, tree class_methods,
1695                                 tree protocol_list, tree property_list,
1696                                 location_t loc)
1697 {
1698   tree expr, ltyp;
1699   VEC(constructor_elt,gc) *v = NULL;
1700
1701   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, cat_name);
1702   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, class_name);
1703
1704   ltyp = objc_method_list_ptr;
1705   if (inst_methods)
1706     expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, inst_methods, 0));
1707   else
1708     expr = convert (ltyp, null_pointer_node);
1709   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1710
1711   if (class_methods)
1712     expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_methods, 0));
1713   else
1714     expr = convert (ltyp, null_pointer_node);
1715   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1716
1717   /* protocol_list = */
1718   ltyp = build_pointer_type (build_pointer_type (objc_protocol_template));
1719   if (protocol_list)
1720     expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, protocol_list, 0));
1721   else
1722     expr = convert (ltyp, null_pointer_node);
1723   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1724
1725   if (flag_objc_abi >= 1)
1726     {
1727       int val = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_category_template));
1728       expr = build_int_cst (NULL_TREE, val);
1729       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1730       ltyp = objc_prop_list_ptr;
1731       if (property_list)
1732         expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0));
1733       else
1734         expr = convert (ltyp, null_pointer_node);
1735       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1736     }
1737
1738   return objc_build_constructor (type, v);
1739 }
1740
1741 /* static struct objc_category _OBJC_CATEGORY_<name> = { ... }; */
1742 /* TODO: get rid of passing stuff around in globals.  */
1743 static void
1744 generate_v1_category (struct imp_entry *impent)
1745 {
1746   tree initlist, cat_name_expr, class_name_expr;
1747   tree protocol_decl, category, cat_decl;
1748   tree inst_methods = NULL_TREE, class_methods = NULL_TREE;
1749   tree cat = impent->imp_context;
1750   location_t loc;
1751   char buf[BUFSIZE];
1752
1753   cat_decl = impent->class_decl;
1754   loc = DECL_SOURCE_LOCATION (cat_decl);
1755
1756   add_class_reference (CLASS_NAME (cat));
1757   cat_name_expr = add_objc_string (CLASS_SUPER_NAME (cat), class_names);
1758   class_name_expr = add_objc_string (CLASS_NAME (cat), class_names);
1759
1760   category = lookup_category (impent->imp_template, CLASS_SUPER_NAME (cat));
1761
1762   if (category && CLASS_PROTOCOL_LIST (category))
1763     {
1764       generate_protocol_references (CLASS_PROTOCOL_LIST (category));
1765       protocol_decl = generate_v1_protocol_list (category, cat);
1766     }
1767   else
1768     protocol_decl = 0;
1769
1770   if (flag_objc_abi >= 1)
1771     V1_Property_decl = generate_v1_property_table (NULL_TREE, cat);
1772   else
1773     V1_Property_decl = NULL_TREE;
1774
1775   if (CLASS_NST_METHODS (cat))
1776     {
1777       snprintf (buf, BUFSIZE, "_OBJC_CategoryInstanceMethods_%s_%s",
1778                 IDENTIFIER_POINTER (CLASS_NAME (cat)),
1779                 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat)));
1780       inst_methods = generate_dispatch_table (CLASS_NST_METHODS (cat), buf,
1781                                               meta_cati_meth);
1782     }
1783
1784   if (CLASS_CLS_METHODS (cat))
1785     {
1786       snprintf (buf, BUFSIZE, "_OBJC_CategoryClassMethods_%s_%s",
1787                 IDENTIFIER_POINTER (CLASS_NAME (cat)),
1788                 IDENTIFIER_POINTER (CLASS_SUPER_NAME (cat)));
1789       class_methods = generate_dispatch_table (CLASS_CLS_METHODS (cat), buf,
1790                                                meta_catc_meth);
1791     }
1792
1793   initlist = build_v1_category_initializer (TREE_TYPE (cat_decl),
1794                                             cat_name_expr, class_name_expr,
1795                                             inst_methods, class_methods,
1796                                             protocol_decl, V1_Property_decl,
1797                                             loc);
1798
1799   finish_var_decl (cat_decl, initlist);
1800   impent->class_decl = cat_decl;
1801 }
1802
1803 /* This routine builds the class extension used by v1 NeXT.  */
1804
1805 static tree
1806 generate_objc_class_ext (tree property_list, tree context)
1807 {
1808   tree decl, expr, ltyp;
1809   tree weak_ivar_layout_tree;
1810   int size;
1811   location_t loc;
1812   VEC(constructor_elt,gc) *v = NULL;
1813   char buf[BUFSIZE];
1814
1815   /* TODO: pass the loc in or find it from args.  */
1816   loc = UNKNOWN_LOCATION;
1817
1818   /* const char *weak_ivar_layout
1819      TODO: Figure the ivar layouts out... */
1820   weak_ivar_layout_tree = NULL_TREE;
1821
1822   if (!property_list && !weak_ivar_layout_tree)
1823     return NULL_TREE;
1824
1825   if (!objc_class_ext_template)
1826     build_objc_class_ext_template ();
1827
1828   /* uint32_t size */
1829   size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (objc_class_ext_template));
1830   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (NULL_TREE, size));
1831
1832   ltyp = const_string_type_node;
1833   if (weak_ivar_layout_tree)
1834     expr = convert (ltyp, weak_ivar_layout_tree);
1835   else
1836     expr = convert (ltyp, null_pointer_node);
1837   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1838
1839   /* struct _prop_list_t *properties; */
1840   ltyp = objc_prop_list_ptr;
1841   if (property_list)
1842      expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, property_list, 0));
1843   else
1844     expr = convert (ltyp, null_pointer_node);
1845   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1846
1847   snprintf (buf, BUFSIZE, "_OBJC_ClassExt_%s",
1848             IDENTIFIER_POINTER (CLASS_NAME (context)));
1849   decl = start_var_decl (objc_class_ext_template, buf);
1850   expr = objc_build_constructor (TREE_TYPE (decl), v);
1851   OBJCMETA (decl, objc_meta, meta_class_extension);
1852   finish_var_decl (decl, expr);
1853   return decl;
1854 }
1855
1856 /* struct _objc_class {
1857      struct objc_class *isa;
1858      struct objc_class *super_class;
1859      char *name;
1860      long version;
1861      long info;
1862      long instance_size;
1863      struct objc_ivar_list *ivars;
1864      struct objc_method_list *methods;
1865      struct objc_cache *cache;
1866      struct objc_protocol_list *protocols;
1867   #if ABI >= 1
1868      const char *ivar_layout;
1869      struct _objc_class_ext *ext;
1870   #else
1871      void *sel_id;
1872      void *gc_object_type;
1873   #endif
1874    }; */
1875
1876 static tree
1877 build_v1_shared_structure_initializer (tree type, tree isa, tree super,
1878                                     tree name, tree size, int status,
1879                                     tree dispatch_table, tree ivar_list,
1880                                     tree protocol_list, tree class_ext)
1881 {
1882   tree expr, ltyp;
1883   location_t loc;
1884   VEC(constructor_elt,gc) *v = NULL;
1885
1886   /* TODO: fish the location out of the input data.  */
1887   loc = UNKNOWN_LOCATION;
1888
1889   /* isa = */
1890   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, isa);
1891
1892   /* super_class = */
1893   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, super);
1894
1895   /* name = */
1896   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, default_conversion (name));
1897
1898   /* version = */
1899   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1900                           build_int_cst (long_integer_type_node, 0));
1901
1902   /* info = */
1903   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1904                           build_int_cst (long_integer_type_node, status));
1905
1906   /* instance_size = */
1907   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
1908                           convert (long_integer_type_node, size));
1909
1910   /* objc_ivar_list = */
1911   ltyp = objc_ivar_list_ptr;
1912   if (ivar_list)
1913     expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, ivar_list, 0));
1914   else
1915     expr = convert (ltyp, null_pointer_node);
1916   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1917
1918   /* objc_method_list = */
1919   ltyp = objc_method_list_ptr;
1920   if (dispatch_table)
1921     expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, dispatch_table, 0));
1922   else
1923     expr = convert (ltyp, null_pointer_node);
1924   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1925
1926   ltyp = build_pointer_type (xref_tag (RECORD_TYPE,
1927                                         get_identifier ("objc_cache")));
1928   /* method_cache = */
1929   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, convert (ltyp, null_pointer_node));
1930
1931   /* protocol_list = */
1932   ltyp = build_pointer_type (build_pointer_type (objc_protocol_template));
1933   if (protocol_list)
1934     expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR,  protocol_list, 0));
1935   else
1936     expr = convert (ltyp, null_pointer_node);
1937   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1938
1939   if (flag_objc_abi >= 1)
1940     {
1941       /* TODO: figure out the ivar_layout stuff.  */
1942       expr = convert (const_string_type_node, null_pointer_node);
1943       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1944       if (!objc_class_ext_template)
1945         build_objc_class_ext_template ();
1946       ltyp = build_pointer_type (objc_class_ext_template);
1947       if (class_ext)
1948         expr = convert (ltyp, build_unary_op (loc, ADDR_EXPR, class_ext, 0));
1949       else
1950         expr = convert (ltyp, null_pointer_node);
1951       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
1952     }
1953   else
1954     {
1955       /* sel_id = NULL */
1956       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_pointer_node);
1957
1958       /* gc_object_type = NULL */
1959       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, null_pointer_node);
1960     }
1961   return objc_build_constructor (type, v);
1962 }
1963
1964 static tree
1965 generate_ivars_list (tree chain, const char *name, tree attr)
1966 {
1967   tree initlist, ivar_list_template, decl;
1968   int size;
1969   VEC(constructor_elt,gc) *inits = NULL;
1970
1971   if (!chain)
1972     return NULL_TREE;
1973
1974   if (!objc_ivar_template)
1975     objc_ivar_template = build_ivar_template ();
1976
1977   size = ivar_list_length (chain);
1978
1979   generating_instance_variables = 1;
1980   ivar_list_template = build_ivar_list_template (objc_ivar_template, size);
1981   initlist = build_ivar_list_initializer (objc_ivar_template, chain);
1982   generating_instance_variables = 0;
1983
1984   decl = start_var_decl (ivar_list_template, name);
1985
1986   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, build_int_cst (NULL_TREE, size));
1987   CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE, initlist);
1988
1989   OBJCMETA (decl, objc_meta, attr);
1990   finish_var_decl (decl,
1991                    objc_build_constructor (TREE_TYPE (decl), inits));
1992
1993   return decl;
1994 }
1995
1996 /* static struct objc_class _OBJC_METACLASS_Foo={ ... };
1997    static struct objc_class _OBJC_CLASS_Foo={ ... }; */
1998
1999 static void
2000 generate_v1_class_structs (struct imp_entry *impent)
2001 {
2002   tree name_expr, super_expr, root_expr, class_decl, meta_decl;
2003   tree my_root_id, my_super_id;
2004   tree cast_type, initlist, protocol_decl;
2005   tree class_ext_decl = NULL_TREE, props = NULL_TREE;
2006   tree inst_methods = NULL_TREE, class_methods = NULL_TREE;
2007   tree chain, inst_ivars = NULL_TREE, class_ivars = NULL_TREE;
2008   int cls_flags;
2009   location_t loc;
2010   char buf[BUFSIZE];
2011
2012 /*  objc_implementation_context = impent->imp_context;
2013   implementation_template = impent->imp_template;*/
2014   class_decl = impent->class_decl;
2015   meta_decl = impent->meta_decl;
2016   cls_flags = impent->has_cxx_cdtors ? CLS_HAS_CXX_STRUCTORS : 0 ;
2017
2018   loc = DECL_SOURCE_LOCATION (impent->class_decl);
2019
2020   if (flag_objc_abi >= 1)
2021     {
2022       /* ABI=1 additions.  */
2023       props = generate_v1_property_table (NULL_TREE, impent->imp_context);
2024       class_ext_decl = generate_objc_class_ext (props, impent->imp_context);
2025     }
2026
2027   my_super_id = CLASS_SUPER_NAME (impent->imp_template);
2028   if (my_super_id)
2029     {
2030       add_class_reference (my_super_id);
2031
2032       /* Compute "my_root_id" - this is required for code generation.
2033          the "isa" for all meta class structures points to the root of
2034          the inheritance hierarchy (e.g. "__Object")...  */
2035       my_root_id = my_super_id;
2036       do
2037         {
2038           tree my_root_int = lookup_interface (my_root_id);
2039
2040           if (my_root_int && CLASS_SUPER_NAME (my_root_int))
2041             my_root_id = CLASS_SUPER_NAME (my_root_int);
2042           else
2043             break;
2044         }
2045       while (1);
2046       super_expr = add_objc_string (my_super_id, class_names);
2047     }
2048   else
2049     {
2050       /* No super class.  */
2051       my_root_id = CLASS_NAME (impent->imp_template);
2052       super_expr = null_pointer_node;
2053     }
2054
2055   /* Install class `isa' and `super' pointers at runtime.  */
2056   cast_type = build_pointer_type (objc_class_template);
2057   super_expr = build_c_cast (loc, cast_type, super_expr);
2058
2059   root_expr = add_objc_string (my_root_id, class_names);
2060   root_expr = build_c_cast (loc, cast_type, root_expr);
2061
2062   if (CLASS_PROTOCOL_LIST (impent->imp_template))
2063     {
2064       generate_protocol_references (CLASS_PROTOCOL_LIST (impent->imp_template));
2065       protocol_decl = generate_v1_protocol_list (impent->imp_template,
2066                                                  impent->imp_context);
2067     }
2068   else
2069     protocol_decl = NULL_TREE;
2070
2071   if (CLASS_CLS_METHODS (impent->imp_context))
2072     {
2073       snprintf (buf, BUFSIZE, "_OBJC_ClassMethods_%s",
2074                 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
2075       class_methods = generate_dispatch_table (CLASS_CLS_METHODS (impent->imp_context),
2076                                                buf, meta_clac_meth);
2077     }
2078
2079   if (CLASS_SUPER_NAME (impent->imp_template) == NULL_TREE
2080       && (chain = TYPE_FIELDS (objc_class_template)))
2081     {
2082       snprintf (buf, BUFSIZE, "_OBJC_ClassIvars_%s",
2083                 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
2084       class_ivars = generate_ivars_list (chain, buf, meta_clac_vars);
2085     }
2086   /* TODO: get rid of hidden passing of stuff in globals.  */
2087   /* UOBJC_INSTANCE/CLASS_Variables_decl made in generate_ivarlists().  */
2088
2089   name_expr = add_objc_string (CLASS_NAME (impent->imp_template), class_names);
2090
2091   /* static struct objc_class _OBJC_METACLASS_Foo = { ... }; */
2092
2093   initlist = build_v1_shared_structure_initializer
2094                 (TREE_TYPE (meta_decl),
2095                 root_expr, super_expr, name_expr,
2096                 convert (integer_type_node, TYPE_SIZE_UNIT (objc_class_template)),
2097                 CLS_META, class_methods, class_ivars,
2098                 protocol_decl, NULL_TREE);
2099
2100   finish_var_decl (meta_decl, initlist);
2101   impent->meta_decl = meta_decl;
2102
2103   /* static struct objc_class _OBJC_CLASS_Foo={ ... }; */
2104   if (CLASS_NST_METHODS (impent->imp_context))
2105     {
2106       snprintf (buf, BUFSIZE, "_OBJC_InstanceMethods_%s",
2107                 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
2108       inst_methods = generate_dispatch_table (CLASS_NST_METHODS (impent->imp_context),
2109                                               buf, meta_clai_meth);
2110     }
2111
2112   if ((chain = CLASS_IVARS (impent->imp_template)))
2113     {
2114       snprintf (buf, BUFSIZE, "_OBJC_InstanceIvars_%s",
2115                 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
2116       inst_ivars = generate_ivars_list (chain, buf, meta_clai_vars);
2117     }
2118
2119   initlist = build_v1_shared_structure_initializer
2120                 (TREE_TYPE (class_decl),
2121                 build_unary_op (loc, ADDR_EXPR, meta_decl, 0),
2122                 super_expr, name_expr,
2123                 convert (integer_type_node,
2124                          TYPE_SIZE_UNIT (CLASS_STATIC_TEMPLATE (impent->imp_template))),
2125                 CLS_FACTORY | cls_flags, inst_methods, inst_ivars,
2126                 protocol_decl, class_ext_decl);
2127
2128   finish_var_decl (class_decl, initlist);
2129   impent->class_decl = class_decl;
2130 }
2131
2132 /* --- Output NeXT V1 Metadata --- */
2133
2134 /* Create the initial value for the `defs' field of _objc_symtab.
2135    This is a CONSTRUCTOR.  */
2136
2137 static tree
2138 init_def_list (tree type)
2139 {
2140   tree expr;
2141   location_t loc;
2142   struct imp_entry *impent;
2143   VEC(constructor_elt,gc) *v = NULL;
2144
2145   if (imp_count)
2146     for (impent = imp_list; impent; impent = impent->next)
2147       {
2148         if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
2149           {
2150             loc = DECL_SOURCE_LOCATION (impent->class_decl);
2151             expr = build_unary_op (loc,
2152                                    ADDR_EXPR, impent->class_decl, 0);
2153             CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2154           }
2155       }
2156
2157   if (cat_count)
2158     for (impent = imp_list; impent; impent = impent->next)
2159       {
2160         if (TREE_CODE (impent->imp_context) == CATEGORY_IMPLEMENTATION_TYPE)
2161           {
2162             loc = DECL_SOURCE_LOCATION (impent->class_decl);
2163             expr = build_unary_op (loc,
2164                                    ADDR_EXPR, impent->class_decl, 0);
2165             CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
2166           }
2167       }
2168
2169   return objc_build_constructor (type, v);
2170 }
2171
2172 /* Take care of defining and initializing _OBJC_SYMBOLS.  */
2173
2174 /* Predefine the following data type:
2175
2176    struct _objc_symtab
2177    {
2178      long sel_ref_cnt;
2179      SEL *refs;
2180      short cls_def_cnt;
2181      short cat_def_cnt;
2182      void *defs[cls_def_cnt + cat_def_cnt];
2183    }; */
2184
2185 static void
2186 build_objc_symtab_template (void)
2187 {
2188   tree fields, *chain = NULL;
2189
2190   objc_symtab_template = objc_start_struct (get_identifier (UTAG_SYMTAB));
2191
2192   /* long sel_ref_cnt; */
2193   fields = add_field_decl (long_integer_type_node, "sel_ref_cnt", &chain);
2194
2195   /* SEL *refs; */
2196   add_field_decl (build_pointer_type (objc_selector_type), "refs", &chain);
2197
2198   /* short cls_def_cnt; */
2199   add_field_decl (short_integer_type_node, "cls_def_cnt", &chain);
2200
2201   /* short cat_def_cnt; */
2202   add_field_decl (short_integer_type_node, "cat_def_cnt", &chain);
2203
2204   if (imp_count || cat_count)
2205     {
2206       /* void *defs[imp_count + cat_count (+ 1)]; */
2207       /* NB: The index is one less than the size of the array.  */
2208       int index = imp_count + cat_count;
2209       tree array_type = build_sized_array_type (ptr_type_node, index);
2210       add_field_decl (array_type, "defs", &chain);
2211     }
2212
2213   objc_finish_struct (objc_symtab_template, fields);
2214 }
2215 /* Construct the initial value for all of _objc_symtab.  */
2216
2217 static tree
2218 init_objc_symtab (tree type)
2219 {
2220   VEC(constructor_elt,gc) *v = NULL;
2221
2222   /* sel_ref_cnt = { ..., 5, ... } */
2223
2224   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2225                           build_int_cst (long_integer_type_node, 0));
2226
2227   /* refs = { ..., _OBJC_SELECTOR_TABLE, ... } */
2228
2229   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2230                           convert (build_pointer_type (objc_selector_type),
2231                                                         integer_zero_node));
2232
2233   /* cls_def_cnt = { ..., 5, ... } */
2234
2235   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2236                           build_int_cst (short_integer_type_node, imp_count));
2237
2238   /* cat_def_cnt = { ..., 5, ... } */
2239
2240   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE,
2241                           build_int_cst (short_integer_type_node, cat_count));
2242
2243   /* cls_def = { ..., { &Foo, &Bar, ...}, ... } */
2244
2245   if (imp_count || cat_count)
2246     {
2247       tree field = TYPE_FIELDS (type);
2248       field = DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (DECL_CHAIN (field))));
2249
2250       CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, init_def_list (TREE_TYPE (field)));
2251     }
2252
2253   return objc_build_constructor (type, v);
2254 }
2255
2256 /* Create the declaration of _OBJC_SYMBOLS, with type `struct _objc_symtab'
2257    and initialized appropriately.  */
2258
2259 static void
2260 generate_objc_symtab_decl (void)
2261 {
2262   build_objc_symtab_template ();
2263   UOBJC_SYMBOLS_decl = start_var_decl (objc_symtab_template, "_OBJC_Symbols");
2264   /* Allow the runtime to mark meta-data such that it can be assigned to target
2265      specific sections by the back-end.  */
2266   OBJCMETA (UOBJC_SYMBOLS_decl, objc_meta, meta_symtab);
2267   finish_var_decl (UOBJC_SYMBOLS_decl,
2268                    init_objc_symtab (TREE_TYPE (UOBJC_SYMBOLS_decl)));
2269 }
2270
2271
2272 static void
2273 handle_next_class_ref (tree chain)
2274 {
2275   const char *name = IDENTIFIER_POINTER (TREE_VALUE (chain));
2276   char *string = (char *) alloca (strlen (name) + 30);
2277
2278   sprintf (string, ".objc_class_name_%s", name);
2279
2280 #ifdef ASM_DECLARE_UNRESOLVED_REFERENCE
2281   ASM_DECLARE_UNRESOLVED_REFERENCE (asm_out_file, string);
2282 #else
2283   return ; /* NULL build for targets other than Darwin.  */
2284 #endif
2285 }
2286
2287 static void
2288 handle_next_impent (struct imp_entry *impent)
2289 {
2290   char buf[BUFSIZE];
2291
2292   switch (TREE_CODE (impent->imp_context))
2293     {
2294     case CLASS_IMPLEMENTATION_TYPE:
2295       snprintf (buf, BUFSIZE, ".objc_class_name_%s",
2296                 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)));
2297       break;
2298     case CATEGORY_IMPLEMENTATION_TYPE:
2299       snprintf (buf, BUFSIZE, "*.objc_category_name_%s_%s",
2300                 IDENTIFIER_POINTER (CLASS_NAME (impent->imp_context)),
2301                 IDENTIFIER_POINTER (CLASS_SUPER_NAME (impent->imp_context)));
2302       break;
2303     default:
2304       return;
2305     }
2306
2307 #ifdef ASM_DECLARE_CLASS_REFERENCE
2308   ASM_DECLARE_CLASS_REFERENCE (asm_out_file, buf);
2309 #else
2310   return ; /* NULL build for targets other than Darwin.  */
2311 #endif
2312 }
2313
2314 static void
2315 generate_classref_translation_entry (tree chain)
2316 {
2317   tree expr, decl, type;
2318
2319   decl = TREE_PURPOSE (chain);
2320   type = TREE_TYPE (decl);
2321
2322   expr = add_objc_string (TREE_VALUE (chain), class_names);
2323   expr = convert (type, expr); /* cast! */
2324
2325   /* This is a class reference.  It is re-written by the runtime,
2326      but will be optimized away unless we force it.  */
2327   DECL_PRESERVE_P (decl) = 1;
2328   OBJCMETA (decl, objc_meta, meta_class_reference);
2329   finish_var_decl (decl, expr);
2330   return;
2331 }
2332
2333
2334 /* The Fix-and-Continue functionality available in Mac OS X 10.3 and
2335    later requires that ObjC translation units participating in F&C be
2336    specially marked.  The following routine accomplishes this.  */
2337
2338 /* static int _OBJC_IMAGE_INFO[2] = { 0, 1 }; */
2339
2340 static void
2341 generate_objc_image_info (void)
2342 {
2343   tree decl;
2344   int flags
2345     = ((flag_replace_objc_classes && imp_count ? 1 : 0)
2346        | (flag_objc_gc ? 2 : 0));
2347   VEC(constructor_elt,gc) *v = NULL;
2348   tree array_type;
2349
2350   array_type  = build_sized_array_type (integer_type_node, 2);
2351
2352   decl = start_var_decl (array_type, "_OBJC_ImageInfo");
2353
2354   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, integer_zero_node);
2355   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, build_int_cst (integer_type_node, flags));
2356   /* The runtime wants this and refers to it in a manner hidden from the compiler.
2357      So we must force the output.  */
2358   DECL_PRESERVE_P (decl) = 1;
2359   OBJCMETA (decl, objc_meta, meta_info);
2360   finish_var_decl (decl, objc_build_constructor (TREE_TYPE (decl), v));
2361 }
2362
2363 static void
2364 objc_generate_v1_next_metadata (void)
2365 {
2366   struct imp_entry *impent;
2367   tree chain, attr;
2368   long vers;
2369
2370   /* FIXME: Make sure that we generate no metadata if there is nothing
2371      to put into it.  */
2372
2373   if (objc_static_instances)
2374     gcc_unreachable (); /* Not for NeXT */
2375
2376   build_metadata_templates ();
2377   objc_implementation_context =
2378   implementation_template =
2379   UOBJC_CLASS_decl =
2380   UOBJC_METACLASS_decl = NULL_TREE;
2381
2382   for (impent = imp_list; impent; impent = impent->next)
2383     {
2384
2385       /* If -gen-decls is present, Dump the @interface of each class.
2386          TODO: Dump the classes in the  order they were found, rather than in
2387          reverse order as we are doing now.  */
2388       if (flag_gen_declaration)
2389         dump_interface (gen_declaration_file, impent->imp_context);
2390
2391       /* all of the following reference the string pool...  */
2392       if (TREE_CODE (impent->imp_context) == CLASS_IMPLEMENTATION_TYPE)
2393         generate_v1_class_structs (impent);
2394       else
2395         generate_v1_category (impent);
2396     }
2397
2398   /* If we are using an array of selectors, we must always
2399      finish up the array decl even if no selectors were used.  */
2400   build_next_selector_translation_table ();
2401
2402   if (protocol_chain)
2403     generate_v1_protocols ();
2404
2405   /* Pass summary information to the runtime.  */
2406   if (imp_count || cat_count)
2407     generate_objc_symtab_decl ();
2408
2409   vers = OBJC_VERSION;
2410   attr = build_tree_list (objc_meta, meta_modules);
2411   build_module_descriptor (vers, attr);
2412
2413   /* This conveys information on GC usage and zero-link.  */
2414   generate_objc_image_info ();
2415
2416   /* Dump the class references.  This forces the appropriate classes
2417      to be linked into the executable image, preserving unix archive
2418      semantics.  This can be removed when we move to a more dynamically
2419      linked environment.  */
2420
2421   for (chain = cls_ref_chain; chain; chain = TREE_CHAIN (chain))
2422     {
2423       handle_next_class_ref (chain);
2424       if (TREE_PURPOSE (chain))
2425         generate_classref_translation_entry (chain);
2426     }
2427
2428   for (impent = imp_list; impent; impent = impent->next)
2429     handle_next_impent (impent);
2430
2431   /* Emit the strings tables.  */
2432   generate_strings ();
2433 }
2434
2435 /* --- exceptions stuff --- */
2436
2437 /* Predefine the following data type:
2438
2439    struct _objc_exception_data
2440    {
2441      int buf[OBJC_JBLEN];
2442      void *pointers[4];
2443    }; */
2444
2445 /* The following yuckiness should prevent users from having to #include
2446    <setjmp.h> in their code... */
2447
2448 /* Define to a harmless positive value so the below code doesn't die.  */
2449 #ifndef OBJC_JBLEN
2450 #define OBJC_JBLEN 18
2451 #endif
2452
2453 static void
2454 build_next_objc_exception_stuff (void)
2455 {
2456   tree decls, temp_type, *chain = NULL;
2457
2458   objc_exception_data_template
2459     = objc_start_struct (get_identifier (UTAG_EXCDATA));
2460
2461   /* int buf[OBJC_JBLEN]; */
2462
2463   temp_type = build_sized_array_type (integer_type_node, OBJC_JBLEN);
2464   decls = add_field_decl (temp_type, "buf", &chain);
2465
2466   /* void *pointers[4]; */
2467
2468   temp_type = build_sized_array_type (ptr_type_node, 4);
2469   add_field_decl (temp_type, "pointers", &chain);
2470
2471   objc_finish_struct (objc_exception_data_template, decls);
2472
2473   /* int _setjmp(...); */
2474   /* If the user includes <setjmp.h>, this shall be superseded by
2475      'int _setjmp(jmp_buf);' */
2476   temp_type = build_varargs_function_type_list (integer_type_node, NULL_TREE);
2477   objc_setjmp_decl
2478     = add_builtin_function (TAG_SETJMP, temp_type, 0, NOT_BUILT_IN, NULL, NULL_TREE);
2479
2480   /* id objc_exception_extract(struct _objc_exception_data *); */
2481   temp_type
2482     = build_function_type_list (objc_object_type,
2483                                 build_pointer_type (objc_exception_data_template),
2484                                 NULL_TREE);
2485   objc_exception_extract_decl
2486     = add_builtin_function (TAG_EXCEPTIONEXTRACT, temp_type, 0, NOT_BUILT_IN, NULL,
2487                             NULL_TREE);
2488   /* void objc_exception_try_enter(struct _objc_exception_data *); */
2489   /* void objc_exception_try_exit(struct _objc_exception_data *); */
2490   temp_type
2491     = build_function_type_list (void_type_node,
2492                                 build_pointer_type (objc_exception_data_template),
2493                                 NULL_TREE);
2494   objc_exception_try_enter_decl
2495     = add_builtin_function (TAG_EXCEPTIONTRYENTER, temp_type, 0, NOT_BUILT_IN, NULL,
2496                             NULL_TREE);
2497   objc_exception_try_exit_decl
2498     = add_builtin_function (TAG_EXCEPTIONTRYEXIT, temp_type, 0, NOT_BUILT_IN, NULL,
2499                             NULL_TREE);
2500
2501   /* int objc_exception_match(id, id); */
2502   temp_type
2503     = build_function_type_list (integer_type_node,
2504                                 objc_object_type, objc_object_type, NULL_TREE);
2505   objc_exception_match_decl
2506     = add_builtin_function (TAG_EXCEPTIONMATCH, temp_type, 0, NOT_BUILT_IN, NULL,
2507                             NULL_TREE);
2508
2509   /* id objc_assign_ivar (id, id, unsigned int); */
2510   /* id objc_assign_ivar_Fast (id, id, unsigned int)
2511        __attribute__ ((hard_coded_address (OFFS_ASSIGNIVAR_FAST))); */
2512   temp_type
2513     = build_function_type_list (objc_object_type,
2514                                 objc_object_type,
2515                                 objc_object_type,
2516                                 unsigned_type_node,
2517                                 NULL_TREE);
2518   objc_assign_ivar_decl
2519     = add_builtin_function (TAG_ASSIGNIVAR, temp_type, 0, NOT_BUILT_IN,
2520                             NULL, NULL_TREE);
2521 #ifdef OFFS_ASSIGNIVAR_FAST
2522   objc_assign_ivar_fast_decl
2523     = add_builtin_function (TAG_ASSIGNIVAR_FAST, temp_type, 0,
2524                             NOT_BUILT_IN, NULL, NULL_TREE);
2525   DECL_ATTRIBUTES (objc_assign_ivar_fast_decl)
2526     = tree_cons (get_identifier ("hard_coded_address"),
2527                  build_int_cst (NULL_TREE, OFFS_ASSIGNIVAR_FAST),
2528                  NULL_TREE);
2529 #else
2530   /* Default to slower ivar method.  */
2531   objc_assign_ivar_fast_decl = objc_assign_ivar_decl;
2532 #endif
2533
2534   /* id objc_assign_global (id, id *); */
2535   /* id objc_assign_strongCast (id, id *); */
2536   temp_type = build_function_type_list (objc_object_type,
2537                                         objc_object_type,
2538                                         build_pointer_type (objc_object_type),
2539                                         NULL_TREE);
2540   objc_assign_global_decl
2541         = add_builtin_function (TAG_ASSIGNGLOBAL, temp_type, 0, NOT_BUILT_IN, NULL,
2542                                 NULL_TREE);
2543   objc_assign_strong_cast_decl
2544         = add_builtin_function (TAG_ASSIGNSTRONGCAST, temp_type, 0, NOT_BUILT_IN, NULL,
2545                                 NULL_TREE);
2546 }
2547
2548 /* --- NeXT V1 SJLJ Exceptions --- */
2549
2550 /* Build "objc_exception_try_exit(&_stack)".  */
2551
2552 static tree
2553 next_sjlj_build_try_exit (struct objc_try_context **ctcp)
2554 {
2555   tree t;
2556   t = build_fold_addr_expr_loc (input_location, (*ctcp)->stack_decl);
2557   t = tree_cons (NULL, t, NULL);
2558   t = build_function_call (input_location,
2559                            objc_exception_try_exit_decl, t);
2560   return t;
2561 }
2562
2563 /* Build
2564         objc_exception_try_enter (&_stack);
2565         if (_setjmp(&_stack.buf))
2566           ;
2567         else
2568           ;
2569    Return the COND_EXPR.  Note that the THEN and ELSE fields are left
2570    empty, ready for the caller to fill them in.  */
2571
2572 static tree
2573 next_sjlj_build_enter_and_setjmp (struct objc_try_context **ctcp)
2574 {
2575   tree t, enter, sj, cond;
2576
2577   t = build_fold_addr_expr_loc (input_location, (*ctcp)->stack_decl);
2578   t = tree_cons (NULL, t, NULL);
2579   enter = build_function_call (input_location,
2580                                objc_exception_try_enter_decl, t);
2581
2582   t = objc_build_component_ref ((*ctcp)->stack_decl,
2583                                 get_identifier ("buf"));
2584   t = build_fold_addr_expr_loc (input_location, t);
2585 #ifdef OBJCPLUS
2586   /* Convert _setjmp argument to type that is expected.  */
2587   if (prototype_p (TREE_TYPE (objc_setjmp_decl)))
2588     t = convert (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (objc_setjmp_decl))), t);
2589   else
2590     t = convert (ptr_type_node, t);
2591 #else
2592   t = convert (ptr_type_node, t);
2593 #endif
2594   t = tree_cons (NULL, t, NULL);
2595   sj = build_function_call (input_location,
2596                             objc_setjmp_decl, t);
2597
2598   cond = build2 (COMPOUND_EXPR, TREE_TYPE (sj), enter, sj);
2599   cond = c_common_truthvalue_conversion (input_location, cond);
2600
2601   return build3 (COND_EXPR, void_type_node, cond, NULL, NULL);
2602 }
2603
2604 /* Build:
2605
2606    DECL = objc_exception_extract(&_stack); */
2607
2608 static tree
2609 next_sjlj_build_exc_extract (struct objc_try_context **ctcp, tree decl)
2610 {
2611   tree t;
2612
2613   t = build_fold_addr_expr_loc (input_location, (*ctcp)->stack_decl);
2614   t = tree_cons (NULL, t, NULL);
2615   t = build_function_call (input_location,
2616                            objc_exception_extract_decl, t);
2617   t = convert (TREE_TYPE (decl), t);
2618   t = build2 (MODIFY_EXPR, void_type_node, decl, t);
2619
2620   return t;
2621 }
2622
2623 /* Build
2624         if (objc_exception_match(obj_get_class(TYPE), _caught)
2625           BODY
2626         else if (...)
2627           ...
2628         else
2629           {
2630             _rethrow = _caught;
2631             objc_exception_try_exit(&_stack);
2632           }
2633    from the sequence of CATCH_EXPRs in the current try context.  */
2634
2635 static tree
2636 next_sjlj_build_catch_list (struct objc_try_context **ctcp)
2637 {
2638   tree_stmt_iterator i = tsi_start ((*ctcp)->catch_list);
2639   tree catch_seq, t;
2640   tree *last = &catch_seq;
2641   bool saw_id = false;
2642
2643   for (; !tsi_end_p (i); tsi_next (&i))
2644     {
2645       tree stmt = tsi_stmt (i);
2646       tree type = CATCH_TYPES (stmt);
2647       tree body = CATCH_BODY (stmt);
2648
2649       if (type != error_mark_node
2650           && objc_is_object_id (TREE_TYPE (type)))
2651         {
2652           *last = body;
2653           saw_id = true;
2654           break;
2655         }
2656       else
2657         {
2658           tree args, cond;
2659
2660           if (type == error_mark_node)
2661             cond = error_mark_node;
2662           else
2663             {
2664               args = tree_cons (NULL, (*ctcp)->caught_decl, NULL);
2665               t = objc_get_class_reference (OBJC_TYPE_NAME (TREE_TYPE (type)));
2666               args = tree_cons (NULL, t, args);
2667               t = build_function_call (input_location,
2668                                        objc_exception_match_decl, args);
2669               cond = c_common_truthvalue_conversion (input_location, t);
2670             }
2671           t = build3 (COND_EXPR, void_type_node, cond, body, NULL);
2672           SET_EXPR_LOCATION (t, EXPR_LOCATION (stmt));
2673
2674           *last = t;
2675           last = &COND_EXPR_ELSE (t);
2676         }
2677     }
2678
2679   if (!saw_id)
2680     {
2681       t = build2 (MODIFY_EXPR, void_type_node, (*ctcp)->rethrow_decl,
2682                   (*ctcp)->caught_decl);
2683       SET_EXPR_LOCATION (t, (*ctcp)->end_catch_locus);
2684       append_to_statement_list (t, last);
2685
2686       t = next_sjlj_build_try_exit (ctcp);
2687       SET_EXPR_LOCATION (t, (*ctcp)->end_catch_locus);
2688       append_to_statement_list (t, last);
2689     }
2690
2691   return catch_seq;
2692 }
2693
2694 /* Build a complete @try-@catch-@finally block for legacy Darwin setjmp
2695    exception handling.  We aim to build:
2696
2697         {
2698           struct _objc_exception_data _stack;
2699           id _rethrow = 0;
2700           try
2701             {
2702               objc_exception_try_enter (&_stack);
2703               if (_setjmp(&_stack.buf))
2704                 {
2705                   id _caught = objc_exception_extract(&_stack);
2706                   objc_exception_try_enter (&_stack);
2707                   if (_setjmp(&_stack.buf))
2708                     _rethrow = objc_exception_extract(&_stack);
2709                   else
2710                     CATCH-LIST
2711                 }
2712               else
2713                 TRY-BLOCK
2714             }
2715           finally
2716             {
2717               if (!_rethrow)
2718                 objc_exception_try_exit(&_stack);
2719               FINALLY-BLOCK
2720               if (_rethrow)
2721                 objc_exception_throw(_rethrow);
2722             }
2723         }
2724
2725    If CATCH-LIST is empty, we can omit all of the block containing
2726    "_caught" except for the setting of _rethrow.  Note the use of
2727    a real TRY_FINALLY_EXPR here, which is not involved in EH per-se,
2728    but handles goto and other exits from the block.  */
2729
2730 static tree
2731 next_sjlj_build_try_catch_finally (struct objc_try_context **ctcp)
2732 {
2733   tree rethrow_decl, stack_decl, t;
2734   tree catch_seq, try_fin, bind;
2735   struct objc_try_context *cur_try_context = *ctcp;
2736
2737   /* Create the declarations involved.  */
2738   t = xref_tag (RECORD_TYPE, get_identifier (UTAG_EXCDATA));
2739   stack_decl = objc_create_temporary_var (t, NULL);
2740   cur_try_context->stack_decl = stack_decl;
2741
2742   rethrow_decl = objc_create_temporary_var (objc_object_type, NULL);
2743   cur_try_context->rethrow_decl = rethrow_decl;
2744   TREE_CHAIN (rethrow_decl) = stack_decl;
2745
2746   /* Build the outermost variable binding level.  */
2747   bind = build3 (BIND_EXPR, void_type_node, rethrow_decl, NULL, NULL);
2748   SET_EXPR_LOCATION (bind, cur_try_context->try_locus);
2749   TREE_SIDE_EFFECTS (bind) = 1;
2750
2751   /* Initialize rethrow_decl.  */
2752   t = build2 (MODIFY_EXPR, void_type_node, rethrow_decl,
2753               convert (objc_object_type, null_pointer_node));
2754   SET_EXPR_LOCATION (t, cur_try_context->try_locus);
2755   append_to_statement_list (t, &BIND_EXPR_BODY (bind));
2756
2757   /* Build the outermost TRY_FINALLY_EXPR.  */
2758   try_fin = build2 (TRY_FINALLY_EXPR, void_type_node, NULL, NULL);
2759   SET_EXPR_LOCATION (try_fin, cur_try_context->try_locus);
2760   TREE_SIDE_EFFECTS (try_fin) = 1;
2761   append_to_statement_list (try_fin, &BIND_EXPR_BODY (bind));
2762
2763   /* Create the complete catch sequence.  */
2764   if (cur_try_context->catch_list)
2765     {
2766       tree caught_decl = objc_build_exc_ptr (ctcp);
2767       catch_seq = build_stmt (input_location, BIND_EXPR, caught_decl, NULL, NULL);
2768       TREE_SIDE_EFFECTS (catch_seq) = 1;
2769
2770       t = next_sjlj_build_exc_extract (ctcp, caught_decl);
2771       append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
2772
2773       t = next_sjlj_build_enter_and_setjmp (ctcp);
2774       COND_EXPR_THEN (t) = next_sjlj_build_exc_extract (ctcp, rethrow_decl);
2775       COND_EXPR_ELSE (t) = next_sjlj_build_catch_list (ctcp);
2776       append_to_statement_list (t, &BIND_EXPR_BODY (catch_seq));
2777     }
2778   else
2779     catch_seq = next_sjlj_build_exc_extract (ctcp, rethrow_decl);
2780   SET_EXPR_LOCATION (catch_seq, cur_try_context->end_try_locus);
2781
2782   /* Build the main register-and-try if statement.  */
2783   t = next_sjlj_build_enter_and_setjmp (ctcp);
2784   SET_EXPR_LOCATION (t, cur_try_context->try_locus);
2785   COND_EXPR_THEN (t) = catch_seq;
2786   COND_EXPR_ELSE (t) = cur_try_context->try_body;
2787   TREE_OPERAND (try_fin, 0) = t;
2788
2789   /* Build the complete FINALLY statement list.  */
2790   t = next_sjlj_build_try_exit (ctcp);
2791   t = build_stmt (input_location, COND_EXPR,
2792                   c_common_truthvalue_conversion
2793                     (input_location, rethrow_decl),
2794                   NULL, t);
2795   SET_EXPR_LOCATION (t, cur_try_context->finally_locus);
2796   append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
2797
2798   append_to_statement_list (cur_try_context->finally_body,
2799                             &TREE_OPERAND (try_fin, 1));
2800
2801   t = tree_cons (NULL, rethrow_decl, NULL);
2802   t = build_function_call (input_location,
2803                            objc_exception_throw_decl, t);
2804   t = build_stmt (input_location, COND_EXPR,
2805                   c_common_truthvalue_conversion (input_location,
2806                                                   rethrow_decl),
2807                   t, NULL);
2808   SET_EXPR_LOCATION (t, cur_try_context->end_finally_locus);
2809   append_to_statement_list (t, &TREE_OPERAND (try_fin, 1));
2810
2811   return bind;
2812 }
2813
2814 /* We do not expect this to be used at the moment.
2815    If (a) it is possible to implement unwinder exceptions.
2816       (b) we do it... then it might be possibly useful.
2817 */
2818 static GTY(()) tree objc_eh_personality_decl;
2819
2820 static tree
2821 objc_eh_runtime_type (tree type)
2822 {
2823   tree ident, eh_id, decl, str;
2824
2825   gcc_unreachable ();
2826   if (type == error_mark_node)
2827     {
2828       /* Use 'ErrorMarkNode' as class name when error_mark_node is found
2829          to prevent an ICE.  Note that we know that the compiler will
2830          terminate with an error and this 'ErrorMarkNode' class name will
2831          never be actually used.  */
2832       ident = get_identifier ("ErrorMarkNode");
2833       goto make_err_class;
2834     }
2835
2836   if (POINTER_TYPE_P (type) && objc_is_object_id (TREE_TYPE (type)))
2837     {
2838       ident = get_identifier ("id");
2839       goto make_err_class;
2840     }
2841
2842   if (!POINTER_TYPE_P (type) || !TYPED_OBJECT (TREE_TYPE (type)))
2843     {
2844 #ifdef OBJCPLUS
2845       /* This routine is also called for c++'s catch clause; in which case,
2846          we use c++'s typeinfo decl. */
2847       return build_eh_type_type (type);
2848 #else
2849       error ("non-objective-c type '%T' cannot be caught", type);
2850       ident = get_identifier ("ErrorMarkNode");
2851       goto make_err_class;
2852 #endif
2853     }
2854   else
2855     ident = OBJC_TYPE_NAME (TREE_TYPE (type));
2856
2857 make_err_class:
2858   /* If this class was already referenced, then it will be output during
2859      meta-data emission, so we don't need to do it here.  */
2860   decl = get_objc_string_decl (ident, class_names);
2861   eh_id = add_objc_string (ident, class_names);
2862   if (!decl)
2863     {
2864       /* Not found ... so we need to build it - from the freshly-entered id.  */
2865       decl = get_objc_string_decl (ident, class_names);
2866       str = my_build_string (IDENTIFIER_LENGTH (ident) + 1,
2867                              IDENTIFIER_POINTER (ident));
2868       /* We have to finalize this var here, because this might be called after
2869          all the other metadata strings have been emitted.  */
2870       finish_var_decl (decl, str);
2871     }
2872   return eh_id;
2873 }
2874
2875 /* For NeXT ABI 0 and 1, the personality routines are just those of the 
2876    underlying language.  */
2877
2878 static tree
2879 objc_eh_personality (void)
2880 {
2881   if (!objc_eh_personality_decl)
2882 #ifndef OBJCPLUS
2883     objc_eh_personality_decl = build_personality_function ("gcc");
2884 #else
2885     objc_eh_personality_decl = build_personality_function ("gxx");
2886 #endif
2887   return objc_eh_personality_decl;
2888 }
2889
2890 /* --- interfaces --- */
2891
2892 static tree
2893 build_throw_stmt (location_t loc, tree throw_expr, bool rethrown ATTRIBUTE_UNUSED)
2894 {
2895   tree t;
2896   VEC(tree, gc) *parms = VEC_alloc (tree, gc, 1);
2897   /* A throw is just a call to the runtime throw function with the
2898      object as a parameter.  */
2899   VEC_quick_push (tree, parms, throw_expr);
2900   t = build_function_call_vec (loc, objc_exception_throw_decl, parms, NULL);
2901   VEC_free (tree, gc, parms);
2902   return add_stmt (t);
2903 }
2904
2905 /* Build __builtin_eh_pointer, or the moral equivalent.  In the case
2906    of Darwin, we'll arrange for it to be initialized (and associated
2907    with a binding) later.  */
2908
2909 static tree
2910 objc_build_exc_ptr (struct objc_try_context **cur_try_context)
2911 {
2912   if (flag_objc_sjlj_exceptions)
2913     {
2914       tree var = (*cur_try_context)->caught_decl;
2915       if (!var)
2916         {
2917           var = objc_create_temporary_var (objc_object_type, NULL);
2918           (*cur_try_context)->caught_decl = var;
2919         }
2920       return var;
2921     }
2922   else
2923     {
2924       tree t;
2925       t = builtin_decl_explicit (BUILT_IN_EH_POINTER);
2926       t = build_call_expr (t, 1, integer_zero_node);
2927       return fold_convert (objc_object_type, t);
2928     }
2929 }
2930
2931 static tree
2932 begin_catch (struct objc_try_context **cur_try_context, tree type,
2933              tree decl, tree compound, bool ellipsis ATTRIBUTE_UNUSED)
2934 {
2935   tree t;
2936   /* Record the data for the catch in the try context so that we can
2937      finalize it later.  We treat ellipsis the same way as catching
2938      with 'id xyz'.  */
2939   t = build_stmt (input_location, CATCH_EXPR, type, compound);
2940   (*cur_try_context)->current_catch = t;
2941
2942   /* Initialize the decl from the EXC_PTR_EXPR we get from the runtime.  */
2943   t = objc_build_exc_ptr (cur_try_context);
2944   t = convert (TREE_TYPE (decl), t);
2945   return build2 (MODIFY_EXPR, void_type_node, decl, t);
2946 }
2947
2948 static void
2949 finish_catch (struct objc_try_context **cur_try_context, tree current_catch)
2950 {
2951   append_to_statement_list (current_catch, &((*cur_try_context)->catch_list));
2952 }
2953
2954 static tree
2955 finish_try_stmt (struct objc_try_context **cur_try_context)
2956 {
2957   tree stmt;
2958   struct objc_try_context *c = *cur_try_context;
2959   /* If we're doing Darwin setjmp exceptions, build the big nasty.  */
2960   if (flag_objc_sjlj_exceptions)
2961     {
2962       bool save = in_late_binary_op;
2963       in_late_binary_op = true;
2964       if (!c->finally_body)
2965         {
2966           c->finally_locus = input_location;
2967           c->end_finally_locus = input_location;
2968         }
2969       stmt = next_sjlj_build_try_catch_finally (cur_try_context);
2970       in_late_binary_op = save;
2971     }
2972   else
2973     /* This doesn't happen at the moment... but maybe one day... */
2974     {
2975       /* Otherwise, nest the CATCH inside a FINALLY.  */
2976       stmt = c->try_body;
2977       if (c->catch_list)
2978         stmt = build_stmt (c->try_locus, TRY_CATCH_EXPR, stmt, c->catch_list);
2979       if (c->finally_body)
2980         stmt = build_stmt (c->try_locus, TRY_FINALLY_EXPR, stmt, c->finally_body);
2981     }
2982   return stmt;
2983 }
2984
2985 #include "gt-objc-objc-next-runtime-abi-01.h"