gcc/objc/objc-runtime-shared-support.c

   1 /* Support routines shared by all runtimes.
   2    Copyright (C) 2011-2015 Free Software Foundation, Inc.
   3    Contributed by Iain Sandoe (partially 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 #include "config.h"
  22 #include "system.h"
  23 #include "coretypes.h"
  24 #include "tm.h"
  25 #include "alias.h"
  26 #include "tree.h"
  27 #include "options.h"
  28 #include "stringpool.h"
  29
  30 #ifdef OBJCPLUS
  31 #include "cp/cp-tree.h"
  32 #else
  33 #include "c/c-tree.h"
  34 #include "c/c-lang.h"
  35 #endif
  36 #include "langhooks.h"
  37 #include "c-family/c-objc.h"
  38 #include "objc-act.h"
  39
  40 /* When building Objective-C++, we are not linking against the C front-end
  41    and so need to replicate the C tree-construction functions in some way.  */
  42 #ifdef OBJCPLUS
  43 #define OBJCP_REMAP_FUNCTIONS
  44 #include "objcp-decl.h"
  45 #endif  /* OBJCPLUS */
  46
  47 /* Hooks for string decls etc.  */
  48 #include "objc-runtime-hooks.h"
  49
  50 #include "objc-runtime-shared-support.h"
  51 #include "objc-encoding.h"
  52
  53 /* rt_trees identifiers - shared between NeXT implementations.  These allow
  54    the FE to tag meta-data in a manner that survives LTO and can be used when
  55    the  runtime requires that certain meta-data items appear in particular
  56    named sections.  */
  57 #include "objc-next-metadata-tags.h"
  58 extern GTY(()) tree objc_rt_trees[OCTI_RT_META_MAX];
  59
  60 /* Rather than repeatedly looking up the identifiers, we save them here.  */
  61 tree objc_rt_trees[OCTI_RT_META_MAX];
  62
  63 /* For building an objc struct.  These might not be used when this file
  64    is compiled as part of obj-c++.  */
  65
  66 static bool objc_building_struct;
  67 static struct c_struct_parse_info *objc_struct_info ATTRIBUTE_UNUSED;
  68
  69 /* Start building a struct for objc.  */
  70
  71 tree
  72 objc_start_struct (tree name)
  73 {
  74   gcc_assert (!objc_building_struct);
  75   objc_building_struct = true;
  76   return start_struct (input_location, RECORD_TYPE, name, &objc_struct_info);
  77 }
  78
  79 /* Finish building a struct for objc.  */
  80
  81 tree
  82 objc_finish_struct (tree type, tree fieldlist)
  83 {
  84   gcc_assert (objc_building_struct);
  85   objc_building_struct = false;
  86   return finish_struct (input_location, type, fieldlist, NULL_TREE,
  87                         objc_struct_info);
  88 }
  89
  90 tree
  91 build_sized_array_type (tree base_type, int size)
  92 {
  93   tree index_type = build_index_type (build_int_cst (NULL_TREE, size - 1));
  94   return build_array_type (base_type, index_type);
  95 }
  96
  97 /* Create a declaration for field NAME of a given TYPE.  */
  98
  99 static tree
 100 create_field_decl (tree type, const char *name)
 101 {
 102   return build_decl (input_location,
 103                      FIELD_DECL, get_identifier (name), type);
 104 }
 105
 106 tree
 107 add_field_decl (tree type, const char *name, tree **chain)
 108 {
 109   tree field = create_field_decl (type, name);
 110
 111   if (*chain != NULL)
 112     **chain = field;
 113   *chain = &DECL_CHAIN (field);
 114
 115   return field;
 116 }
 117
 118 /* Create a global, static declaration for variable NAME of a given TYPE.  The
 119    finish_var_decl() routine will need to be called on it afterwards.  */
 120
 121 tree
 122 start_var_decl (tree type, const char *name)
 123 {
 124   tree var = build_decl (input_location,
 125                          VAR_DECL, get_identifier (name), type);
 126   TREE_STATIC (var) = 1;
 127   DECL_INITIAL (var) = error_mark_node;  /* A real initializer is coming... */
 128   DECL_IGNORED_P (var) = 1;
 129   DECL_ARTIFICIAL (var) = 1;
 130   DECL_CONTEXT (var) = NULL_TREE;
 131 #ifdef OBJCPLUS
 132   DECL_THIS_STATIC (var) = 1; /* squash redeclaration errors */
 133 #endif
 134   return var;
 135 }
 136
 137 /* Finish off the variable declaration created by start_var_decl().  */
 138
 139 void
 140 finish_var_decl (tree var, tree initializer)
 141 {
 142   finish_decl (var, input_location, initializer, NULL_TREE, NULL_TREE);
 143 }
 144
 145 /* Just a handy wrapper for add_objc_string.  */
 146
 147 tree
 148 build_selector (tree ident)
 149 {
 150   return convert (objc_selector_type, add_objc_string (ident, meth_var_names));
 151 }
 152
 153 /* --- templates --- */
 154
 155 /* Set 'objc_super_template' to the data type node for 'struct _objc_super'.
 156    This needs to be done just once per compilation.  */
 157
 158 /* struct _objc_super {
 159      struct _objc_object *self;
 160      struct _objc_class *super_class;
 161                 [or Class cls; for the abi v2]
 162    };  */
 163
 164 void
 165 build_super_template (void)
 166 {
 167   tree decls, *chain = NULL;
 168
 169   objc_super_template = objc_start_struct (get_identifier (UTAG_SUPER));
 170
 171   /* struct _objc_object *self; */
 172   decls = add_field_decl (objc_object_type, "self", &chain);
 173
 174   /* struct _objc_class *super_class; */
 175   add_field_decl (build_pointer_type (objc_class_template),
 176                   "super_class", &chain);
 177
 178   objc_finish_struct (objc_super_template, decls);
 179 }
 180
 181 /* To accomplish method prototyping without generating all kinds of
 182    inane warnings, the definition of the dispatch table entries were
 183    changed from:
 184
 185         struct objc_method { SEL _cmd; ...; id (*_imp)(); };
 186    to:
 187         struct objc_method { SEL _cmd; ...; void *_imp; };  */
 188
 189 tree
 190 build_method_template (void)
 191 {
 192   tree _SLT_record;
 193   tree decls, *chain = NULL;
 194
 195   _SLT_record = objc_start_struct (get_identifier (UTAG_METHOD));
 196
 197   /* SEL _cmd; */
 198   decls = add_field_decl (objc_selector_type, "_cmd", &chain);
 199
 200   /* char *method_types; */
 201   add_field_decl (string_type_node, "method_types", &chain);
 202
 203   /* void *_imp; */
 204   add_field_decl (build_pointer_type (void_type_node), "_imp", &chain);
 205
 206   objc_finish_struct (_SLT_record, decls);
 207
 208   return _SLT_record;
 209 }
 210
 211 tree
 212 build_method_prototype_template (void)
 213 {
 214   tree proto_record;
 215   tree decls, *chain = NULL;
 216
 217   proto_record = objc_start_struct (get_identifier (UTAG_METHOD_PROTOTYPE));
 218
 219   /* SEL _cmd; */
 220   decls = add_field_decl (objc_selector_type, "_cmd", &chain);
 221
 222   /* char *method_types; */
 223   add_field_decl (string_type_node, "method_types", &chain);
 224
 225   objc_finish_struct (proto_record, decls);
 226
 227   return proto_record;
 228 }
 229
 230 /* struct {
 231      struct _objc__method_prototype_list *method_next;
 232      int method_count;
 233      struct objc_method method_list[method_count];
 234    };  */
 235
 236 tree
 237 build_method_list_template (tree list_type, int size)
 238 {
 239   tree objc_ivar_list_record;
 240   tree array_type, decls, *chain = NULL;
 241
 242   objc_ivar_list_record = objc_start_struct (NULL_TREE);
 243
 244   /* struct _objc__method_prototype_list *method_next; */
 245   decls = add_field_decl (objc_method_proto_list_ptr, "method_next", &chain);
 246
 247   /* int method_count; */
 248   add_field_decl (integer_type_node, "method_count", &chain);
 249
 250   /* struct objc_method method_list[]; */
 251   array_type = build_sized_array_type (list_type, size);
 252   add_field_decl (array_type, "method_list", &chain);
 253
 254   objc_finish_struct (objc_ivar_list_record, decls);
 255
 256   return objc_ivar_list_record;
 257 }
 258
 259 /* struct objc_method_prototype_list {
 260      int count;
 261      struct objc_method_prototype {
 262         SEL name;
 263         char *types;
 264      } list[1];
 265    };  */
 266
 267 tree
 268 build_method_prototype_list_template (tree list_type, int size)
 269 {
 270   tree objc_ivar_list_record;
 271   tree array_type, decls, *chain = NULL;
 272
 273   /* Generate an unnamed struct definition.  */
 274
 275   objc_ivar_list_record = objc_start_struct (NULL_TREE);
 276
 277   /* int method_count; */
 278   decls = add_field_decl (integer_type_node, "method_count", &chain);
 279
 280   /* struct objc_method method_list[]; */
 281   array_type = build_sized_array_type (list_type, size);
 282   add_field_decl (array_type, "method_list", &chain);
 283
 284   objc_finish_struct (objc_ivar_list_record, decls);
 285
 286   return objc_ivar_list_record;
 287 }
 288
 289 /* --- names, decls entry --- */
 290
 291 /* For each string section we have a chain which maps identifier nodes
 292    to decls for the strings.  */
 293
 294 static GTY(()) int meth_var_names_idx;
 295 static GTY(()) int meth_var_types_idx;
 296 static GTY(()) int property_name_attr_idx;
 297
 298 tree
 299 add_objc_string (tree ident, string_section section)
 300 {
 301   tree *chain, decl, type;
 302   char buf[BUFSIZE];
 303
 304   switch (section)
 305     {
 306     case class_names:
 307       chain = &class_names_chain;
 308       snprintf (buf, BUFSIZE, "_OBJC_ClassName_%s", IDENTIFIER_POINTER (ident));
 309       break;
 310     case meth_var_names:
 311       chain = &meth_var_names_chain;
 312       snprintf (buf, BUFSIZE, "_OBJC_METH_VAR_NAME_%d", meth_var_names_idx++);
 313       break;
 314     case meth_var_types:
 315       chain = &meth_var_types_chain;
 316       snprintf (buf, BUFSIZE, "_OBJC_METH_VAR_TYPE_%d", meth_var_types_idx++);
 317       break;
 318     case prop_names_attr:
 319       chain = &prop_names_attr_chain;
 320       snprintf (buf, BUFSIZE, "_OBJC_PropertyAttributeOrName_%d", property_name_attr_idx++);
 321       break;
 322     default:
 323       gcc_unreachable ();
 324     }
 325
 326   while (*chain)
 327     {
 328       if (TREE_VALUE (*chain) == ident)
 329         return convert (string_type_node,
 330                         build_unary_op (input_location,
 331                                         ADDR_EXPR, TREE_PURPOSE (*chain), 1));
 332
 333       chain = &TREE_CHAIN (*chain);
 334     }
 335
 336   type = build_sized_array_type (char_type_node, IDENTIFIER_LENGTH (ident) + 1);
 337   /* Get a runtime-specific string decl which will be finish_var()'ed in
 338      generate_strings ().  */
 339   decl = (*runtime.string_decl) (type, buf, section);
 340   TREE_CONSTANT (decl) = 1;
 341   *chain = tree_cons (decl, ident, NULL_TREE);
 342
 343   return convert (string_type_node,
 344                   build_unary_op (input_location, ADDR_EXPR, decl, 1));
 345 }
 346
 347 /* --- shared metadata routines --- */
 348
 349 tree
 350 build_descriptor_table_initializer (tree type, tree entries)
 351 {
 352   vec<constructor_elt, va_gc> *inits = NULL;
 353
 354   do
 355     {
 356       vec<constructor_elt, va_gc> *elts = NULL;
 357
 358       CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
 359                               build_selector (METHOD_SEL_NAME (entries)));
 360       CONSTRUCTOR_APPEND_ELT (elts, NULL_TREE,
 361                               add_objc_string (METHOD_ENCODING (entries),
 362                                                meth_var_types));
 363
 364       CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
 365                               objc_build_constructor (type, elts));
 366
 367       entries = DECL_CHAIN (entries);
 368     }
 369   while (entries);
 370
 371   return objc_build_constructor (build_array_type (type, 0), inits);
 372 }
 373
 374 tree
 375 build_dispatch_table_initializer (tree type, tree entries)
 376 {
 377   vec<constructor_elt, va_gc> *inits = NULL;
 378
 379   do
 380     {
 381       vec<constructor_elt, va_gc> *elems = NULL;
 382       tree expr;
 383
 384       CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
 385                               build_selector (METHOD_SEL_NAME (entries)));
 386
 387       /* Generate the method encoding if we don't have one already.  */
 388       if (! METHOD_ENCODING (entries))
 389         METHOD_ENCODING (entries) =
 390           encode_method_prototype (entries);
 391
 392       CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE,
 393                               add_objc_string (METHOD_ENCODING (entries),
 394                                                meth_var_types));
 395
 396       expr = convert (ptr_type_node,
 397                       build_unary_op (input_location, ADDR_EXPR,
 398                                       METHOD_DEFINITION (entries), 1));
 399       CONSTRUCTOR_APPEND_ELT (elems, NULL_TREE, expr);
 400
 401       CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
 402                               objc_build_constructor (type, elems));
 403
 404       entries = DECL_CHAIN (entries);
 405     }
 406   while (entries);
 407
 408   return objc_build_constructor (build_array_type (type, 0), inits);
 409 }
 410
 411 /* Used only by build_*_selector_translation_table (). */
 412 void
 413 diagnose_missing_method (tree meth, location_t here)
 414 {
 415   tree method_chain;
 416   bool found = false;
 417   for (method_chain = meth_var_names_chain;
 418        method_chain;
 419        method_chain = TREE_CHAIN (method_chain))
 420     {
 421       if (TREE_VALUE (method_chain) == meth)
 422         {
 423           found = true;
 424           break;
 425         }
 426      }
 427
 428   if (!found)
 429     warning_at (here, 0, "creating selector for nonexistent method %qE",
 430                         meth);
 431 }
 432
 433
 434 static tree
 435 init_module_descriptor (tree type, long vers)
 436 {
 437   tree expr, ltyp;
 438   location_t loc;
 439   vec<constructor_elt, va_gc> *v = NULL;
 440
 441   /* No really useful place to point to.  */
 442   loc = UNKNOWN_LOCATION;
 443
 444   /* version = { 1, ... } */
 445
 446   expr = build_int_cst (long_integer_type_node, vers);
 447   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
 448
 449   /* size = { ..., sizeof (struct _objc_module), ... } */
 450
 451   expr = convert (long_integer_type_node,
 452                   size_in_bytes (objc_module_template));
 453   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
 454
 455   /* Don't provide any file name for security reasons. */
 456   /* name = { ..., "", ... } */
 457
 458   expr = add_objc_string (get_identifier (""), class_names);
 459   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
 460
 461   /* symtab = { ..., _OBJC_SYMBOLS, ... } */
 462
 463   ltyp = build_pointer_type (xref_tag (RECORD_TYPE,
 464                                        get_identifier (UTAG_SYMTAB)));
 465   if (UOBJC_SYMBOLS_decl)
 466     expr = convert (ltyp, build_unary_op (loc,
 467                            ADDR_EXPR, UOBJC_SYMBOLS_decl, 0));
 468   else
 469     expr = convert (ltyp, null_pointer_node);
 470   CONSTRUCTOR_APPEND_ELT (v, NULL_TREE, expr);
 471
 472   return objc_build_constructor (type, v);
 473 }
 474
 475 /* Write out the data structures to describe Objective C classes defined.
 476
 477    struct _objc_module { ... } _OBJC_MODULE = { ... };   */
 478
 479 void
 480 build_module_descriptor (long vers, tree attr)
 481 {
 482   tree decls, *chain = NULL;
 483
 484 #ifdef OBJCPLUS
 485   push_lang_context (lang_name_c); /* extern "C" */
 486 #endif
 487
 488   objc_module_template = objc_start_struct (get_identifier (UTAG_MODULE));
 489
 490   /* long version; */
 491   decls = add_field_decl (long_integer_type_node, "version", &chain);
 492
 493   /* long size; */
 494   add_field_decl (long_integer_type_node, "size", &chain);
 495
 496   /* char *name; */
 497   add_field_decl (string_type_node, "name", &chain);
 498
 499   /* struct _objc_symtab *symtab; */
 500   add_field_decl (build_pointer_type (xref_tag (RECORD_TYPE,
 501                                                 get_identifier (UTAG_SYMTAB))),
 502                   "symtab", &chain);
 503
 504   objc_finish_struct (objc_module_template, decls);
 505
 506   /* Create an instance of "_objc_module".  */
 507   UOBJC_MODULES_decl = start_var_decl (objc_module_template,
 508                                        /* FIXME - why the conditional
 509                                           if the symbol is the
 510                                           same.  */
 511                                        flag_next_runtime ? "_OBJC_Module" :  "_OBJC_Module");
 512
 513   /* This is the root of the metadata for defined classes and categories, it
 514      is referenced by the runtime and, therefore, needed.  */
 515   DECL_PRESERVE_P (UOBJC_MODULES_decl) = 1;
 516
 517   /* Squash `defined but not used' warning.  */
 518   TREE_USED (UOBJC_MODULES_decl) = 1;
 519
 520   /* Allow the runtime to mark meta-data such that it can be assigned to target
 521      specific sections by the back-end.  */
 522   if (attr)
 523     DECL_ATTRIBUTES (UOBJC_MODULES_decl) = attr;
 524
 525   finish_var_decl (UOBJC_MODULES_decl,
 526                    init_module_descriptor (TREE_TYPE (UOBJC_MODULES_decl),
 527                                            vers));
 528
 529 #ifdef OBJCPLUS
 530   pop_lang_context ();
 531 #endif
 532 }
 533
 534 tree
 535 build_ivar_list_initializer (tree type, tree field_decl)
 536 {
 537   vec<constructor_elt, va_gc> *inits = NULL;
 538
 539   do
 540     {
 541       vec<constructor_elt, va_gc> *ivar = NULL;
 542       tree id;
 543
 544       /* Set name.  */
 545       if (DECL_NAME (field_decl))
 546         CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE,
 547                                 add_objc_string (DECL_NAME (field_decl),
 548                                                  meth_var_names));
 549       else
 550         /* Unnamed bit-field ivar (yuck).  */
 551         CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, build_int_cst (NULL_TREE, 0));
 552
 553       /* Set type.  */
 554       id = add_objc_string (encode_field_decl (field_decl),
 555                             meth_var_types);
 556       CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, id);
 557
 558       /* Set offset.  */
 559       CONSTRUCTOR_APPEND_ELT (ivar, NULL_TREE, byte_position (field_decl));
 560       CONSTRUCTOR_APPEND_ELT (inits, NULL_TREE,
 561                               objc_build_constructor (type, ivar));
 562       do
 563         field_decl = DECL_CHAIN (field_decl);
 564       while (field_decl && TREE_CODE (field_decl) != FIELD_DECL);
 565     }
 566   while (field_decl);
 567
 568   return objc_build_constructor (build_array_type (type, 0), inits);
 569 }
 570
 571 /* struct {
 572      int ivar_count;
 573      struct objc_ivar ivar_list[ivar_count];
 574    };  */
 575
 576 tree
 577 build_ivar_list_template (tree list_type, int size)
 578 {
 579   tree objc_ivar_list_record;
 580   tree array_type, decls, *chain = NULL;
 581
 582   objc_ivar_list_record = objc_start_struct (NULL_TREE);
 583
 584   /* int ivar_count; */
 585   decls = add_field_decl (integer_type_node, "ivar_count", &chain);
 586
 587   /* struct objc_ivar ivar_list[]; */
 588   array_type = build_sized_array_type (list_type, size);
 589   add_field_decl (array_type, "ivar_list", &chain);
 590
 591   objc_finish_struct (objc_ivar_list_record, decls);
 592
 593   return objc_ivar_list_record;
 594 }
 595
 596 /* struct _objc_ivar {
 597      char *ivar_name;
 598      char *ivar_type;
 599      int ivar_offset;
 600    };  */
 601
 602 tree
 603 build_ivar_template (void)
 604 {
 605   tree objc_ivar_id, objc_ivar_record;
 606   tree decls, *chain = NULL;
 607
 608   objc_ivar_id = get_identifier (UTAG_IVAR);
 609   objc_ivar_record = objc_start_struct (objc_ivar_id);
 610
 611   /* char *ivar_name; */
 612   decls = add_field_decl (string_type_node, "ivar_name", &chain);
 613
 614   /* char *ivar_type; */
 615   add_field_decl (string_type_node, "ivar_type", &chain);
 616
 617   /* int ivar_offset; */
 618   add_field_decl (integer_type_node, "ivar_offset", &chain);
 619
 620   objc_finish_struct (objc_ivar_record, decls);
 621
 622   return objc_ivar_record;
 623 }
 624
 625 /* Used by NeXT ABI=0..2 */
 626 void
 627 build_next_selector_translation_table (void)
 628 {
 629   tree chain;
 630   for (chain = sel_ref_chain; chain; chain = TREE_CHAIN (chain))
 631     {
 632       tree expr;
 633       tree decl = TREE_PURPOSE (chain);
 634       if (warn_selector)
 635         {
 636           location_t loc;
 637           if (decl)
 638             loc = DECL_SOURCE_LOCATION (decl);
 639           else
 640             loc = UNKNOWN_LOCATION;
 641           diagnose_missing_method (TREE_VALUE (chain), loc);
 642         }
 643
 644       expr = build_selector (TREE_VALUE (chain));
 645
 646       if (decl)
 647         {
 648           /* Entries of this form are used for references to methods.
 649           The runtime re-writes these on start-up, but the compiler can't see
 650           that and optimizes it away unless we force it.  */
 651           DECL_PRESERVE_P (decl) = 1;
 652           finish_var_decl (decl, expr);
 653         }
 654     }
 655 }
 656
 657 void
 658 generate_protocol_references (tree plist)
 659 {
 660   tree lproto;
 661
 662   /* Forward declare protocols referenced.  */
 663   for (lproto = plist; lproto; lproto = TREE_CHAIN (lproto))
 664     {
 665       tree proto = TREE_VALUE (lproto);
 666
 667       if (TREE_CODE (proto) == PROTOCOL_INTERFACE_TYPE
 668           && PROTOCOL_NAME (proto))
 669         {
 670           if (! PROTOCOL_FORWARD_DECL (proto))
 671             PROTOCOL_FORWARD_DECL (proto) = (*runtime.protocol_decl) (proto);
 672
 673           if (PROTOCOL_LIST (proto))
 674             generate_protocol_references (PROTOCOL_LIST (proto));
 675         }
 676     }
 677 }
 678
 679 /* --- new routines --- */
 680
 681 /* Output all strings.  */
 682
 683 /* FIXME: don't use global vars for all this... */
 684
 685 /* This emits all the meta-data string tables (and finalizes each var
 686    as it goes).  */
 687 void
 688 generate_strings (void)
 689 {
 690   tree chain, string_expr;
 691   tree string, decl; /* , type;*/
 692
 693   for (chain = class_names_chain; chain; chain = TREE_CHAIN (chain))
 694     {
 695       string = TREE_VALUE (chain);
 696       decl = TREE_PURPOSE (chain);
 697       string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
 698                                      IDENTIFIER_POINTER (string));
 699       finish_var_decl (decl, string_expr);
 700     }
 701
 702   for (chain = meth_var_names_chain; chain; chain = TREE_CHAIN (chain))
 703     {
 704       string = TREE_VALUE (chain);
 705       decl = TREE_PURPOSE (chain);
 706       string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
 707                                      IDENTIFIER_POINTER (string));
 708       finish_var_decl (decl, string_expr);
 709     }
 710
 711   for (chain = meth_var_types_chain; chain; chain = TREE_CHAIN (chain))
 712     {
 713       string = TREE_VALUE (chain);
 714       decl = TREE_PURPOSE (chain);
 715       string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
 716                                      IDENTIFIER_POINTER (string));
 717       finish_var_decl (decl, string_expr);
 718     }
 719
 720   for (chain = prop_names_attr_chain; chain; chain = TREE_CHAIN (chain))
 721     {
 722       string = TREE_VALUE (chain);
 723       decl = TREE_PURPOSE (chain);
 724       string_expr = my_build_string (IDENTIFIER_LENGTH (string) + 1,
 725                                      IDENTIFIER_POINTER (string));
 726       finish_var_decl (decl, string_expr);
 727     }
 728 }
 729
 730 #include "gt-objc-objc-runtime-shared-support.h"