gcc/gengtype.c

   1 /* Process source files and output type information.
   2    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it under
   8    the terms of the GNU General Public License as published by the Free
   9    Software Foundation; either version 3, or (at your option) any later
  10    version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13    WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15    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 "bconfig.h"
  22 #include "system.h"
  23 #include "errors.h"             /* for fatal */
  24 #include "getopt.h"
  25 #include "double-int.h"
  26 #include "version.h"            /* for version_string & pkgversion_string.  */
  27 #include "hashtab.h"
  28 #include "xregex.h"
  29 #include "obstack.h"
  30 #include "gengtype.h"
  31
  32 /* Data types, macros, etc. used only in this file.  */
  33
  34
  35 /* The list of output files.  */
  36 outf_p output_files;
  37
  38 /* The output header file that is included into pretty much every
  39    source file.  */
  40 outf_p header_file;
  41
  42
  43 /* The name of the file containing the list of input files.  */
  44 static char *inputlist;
  45
  46 /* The plugin input files and their number; in that case only
  47    a single file is produced.  */
  48 static input_file **plugin_files;
  49 static size_t nb_plugin_files;
  50
  51 /* The generated plugin output file and name.  */
  52 static outf_p plugin_output;
  53 static char *plugin_output_filename;
  54
  55 /* Our source directory and its length.  */
  56 const char *srcdir;
  57 size_t srcdir_len;
  58
  59 /* Variables used for reading and writing the state.  */
  60 const char *read_state_filename;
  61 const char *write_state_filename;
  62
  63 /* Variables to help debugging.  */
  64 int do_dump;
  65 int do_debug;
  66
  67 /* Level for verbose messages.  */
  68 int verbosity_level;
  69
  70 /* We have a type count and use it to set the state_number of newly
  71    allocated types to some unique negative number.  */
  72 static int type_count;
  73
  74 /* The backup directory should be in the same file system as the
  75    generated files, otherwise the rename(2) system call would fail.
  76    If NULL, no backup is made when overwriting a generated file.  */
  77 static const char* backup_dir;  /* (-B) program option.  */
  78
  79
  80 static outf_p create_file (const char *, const char *);
  81
  82 static const char *get_file_basename (const input_file *);
  83 static const char *get_file_realbasename (const input_file *);
  84
  85 static int get_prefix_langdir_index (const char *);
  86 static const char *get_file_langdir (const input_file *);
  87 \f
  88
  89 /* Nonzero iff an error has occurred.  */
  90 bool hit_error = false;
  91
  92 static void gen_rtx_next (void);
  93 static void write_rtx_next (void);
  94 static void open_base_files (void);
  95 static void close_output_files (void);
  96
  97 /* Report an error at POS, printing MSG.  */
  98
  99 void
 100 error_at_line (const struct fileloc *pos, const char *msg, ...)
 101 {
 102   va_list ap;
 103
 104   gcc_assert (pos != NULL && pos->file != NULL);
 105   va_start (ap, msg);
 106
 107   fprintf (stderr, "%s:%d: ", get_input_file_name (pos->file), pos->line);
 108   vfprintf (stderr, msg, ap);
 109   fputc ('\n', stderr);
 110   hit_error = true;
 111
 112   va_end (ap);
 113 }
 114
 115 /* asprintf, but produces fatal message on out-of-memory.  */
 116 char *
 117 xasprintf (const char *format, ...)
 118 {
 119   int n;
 120   char *result;
 121   va_list ap;
 122
 123   va_start (ap, format);
 124   n = vasprintf (&result, format, ap);
 125   if (result == NULL || n < 0)
 126     fatal ("out of memory");
 127   va_end (ap);
 128
 129   return result;
 130 }
 131 \f
 132 /* Input file handling. */
 133
 134 /* Table of all input files.  */
 135 const input_file **gt_files;
 136 size_t num_gt_files;
 137
 138 /* A number of places use the name of this "gengtype.c" file for a
 139    location for things that we can't rely on the source to define.
 140    Make sure we can still use pointer comparison on filenames.  */
 141 input_file* this_file;
 142 /* The "system.h" file is likewise specially useful.  */
 143 input_file* system_h_file;
 144
 145 /* Vector of per-language directories.  */
 146 const char **lang_dir_names;
 147 size_t num_lang_dirs;
 148
 149 /* An array of output files suitable for definitions.  There is one
 150    BASE_FILES entry for each language.  */
 151 static outf_p *base_files;
 152
 153
 154
 155 #if ENABLE_CHECKING
 156 /* Utility debugging function, printing the various type counts within
 157    a list of types.  Called thru the DBGPRINT_COUNT_TYPE macro.  */
 158 void
 159 dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
 160 {
 161   int nb_types = 0, nb_scalar = 0, nb_string = 0;
 162   int nb_struct = 0, nb_union = 0, nb_array = 0, nb_pointer = 0;
 163   int nb_lang_struct = 0, nb_param_struct = 0;
 164   type_p p = NULL;
 165   for (p = t; p; p = p->next)
 166     {
 167       nb_types++;
 168       switch (p->kind)
 169         {
 170         case TYPE_SCALAR:
 171           nb_scalar++;
 172           break;
 173         case TYPE_STRING:
 174           nb_string++;
 175           break;
 176         case TYPE_STRUCT:
 177           nb_struct++;
 178           break;
 179         case TYPE_UNION:
 180           nb_union++;
 181           break;
 182         case TYPE_POINTER:
 183           nb_pointer++;
 184           break;
 185         case TYPE_ARRAY:
 186           nb_array++;
 187           break;
 188         case TYPE_LANG_STRUCT:
 189           nb_lang_struct++;
 190           break;
 191         case TYPE_PARAM_STRUCT:
 192           nb_param_struct++;
 193           break;
 194         default:
 195           gcc_unreachable ();
 196         }
 197     }
 198   fprintf (stderr, "\n" "%s:%d: %s: @@%%@@ %d types ::\n",
 199            lbasename (fil), lin, msg, nb_types);
 200   if (nb_scalar > 0 || nb_string > 0)
 201     fprintf (stderr, "@@%%@@ %d scalars, %d strings\n", nb_scalar, nb_string);
 202   if (nb_struct > 0 || nb_union > 0)
 203     fprintf (stderr, "@@%%@@ %d structs, %d unions\n", nb_struct, nb_union);
 204   if (nb_pointer > 0 || nb_array > 0)
 205     fprintf (stderr, "@@%%@@ %d pointers, %d arrays\n", nb_pointer, nb_array);
 206   if (nb_lang_struct > 0 || nb_param_struct > 0)
 207     fprintf (stderr, "@@%%@@ %d lang_structs, %d param_structs\n",
 208              nb_lang_struct, nb_param_struct);
 209   fprintf (stderr, "\n");
 210 }
 211 #endif /* ENABLE_CHECKING */
 212
 213 /* Scan the input file, LIST, and determine how much space we need to
 214    store strings in.  Also, count the number of language directories
 215    and files.  The numbers returned are overestimates as they does not
 216    consider repeated files.  */
 217 static size_t
 218 measure_input_list (FILE *list)
 219 {
 220   size_t n = 0;
 221   int c;
 222   bool atbol = true;
 223   num_lang_dirs = 0;
 224   num_gt_files = plugin_files ? nb_plugin_files : 0;
 225   while ((c = getc (list)) != EOF)
 226     {
 227       n++;
 228       if (atbol)
 229         {
 230           if (c == '[')
 231             num_lang_dirs++;
 232           else
 233             {
 234               /* Add space for a lang_bitmap before the input file name.  */
 235               n += sizeof (lang_bitmap);
 236               num_gt_files++;
 237             }
 238           atbol = false;
 239         }
 240
 241       if (c == '\n')
 242         atbol = true;
 243     }
 244
 245   rewind (list);
 246   return n;
 247 }
 248
 249 /* Read one input line from LIST to HEREP (which is updated).  A
 250    pointer to the string is returned via LINEP.  If it was a language
 251    subdirectory in square brackets, strip off the square brackets and
 252    return true.  Otherwise, leave space before the string for a
 253    lang_bitmap, and return false.  At EOF, returns false, does not
 254    touch *HEREP, and sets *LINEP to NULL.  POS is used for
 255    diagnostics.  */
 256 static bool
 257 read_input_line (FILE *list, char **herep, char **linep, struct fileloc *pos)
 258 {
 259   char *here = *herep;
 260   char *line;
 261   int c = getc (list);
 262
 263   /* Read over whitespace.  */
 264   while (c == '\n' || c == ' ')
 265     c = getc (list);
 266
 267   if (c == EOF)
 268     {
 269       *linep = 0;
 270       return false;
 271     }
 272   else if (c == '[')
 273     {
 274       /* No space for a lang_bitmap is necessary.  Discard the '['. */
 275       c = getc (list);
 276       line = here;
 277       while (c != ']' && c != '\n' && c != EOF)
 278         {
 279           *here++ = c;
 280           c = getc (list);
 281         }
 282       *here++ = '\0';
 283
 284       if (c == ']')
 285         {
 286           c = getc (list);      /* eat what should be a newline */
 287           if (c != '\n' && c != EOF)
 288             error_at_line (pos, "junk on line after language tag [%s]", line);
 289         }
 290       else
 291         error_at_line (pos, "missing close bracket for language tag [%s",
 292                        line);
 293
 294       *herep = here;
 295       *linep = line;
 296       return true;
 297     }
 298   else
 299     {
 300       /* Leave space for a lang_bitmap.  */
 301       memset (here, 0, sizeof (lang_bitmap));
 302       here += sizeof (lang_bitmap);
 303       line = here;
 304       do
 305         {
 306           *here++ = c;
 307           c = getc (list);
 308         }
 309       while (c != EOF && c != '\n');
 310       *here++ = '\0';
 311       *herep = here;
 312       *linep = line;
 313       return false;
 314     }
 315 }
 316
 317 /* Read the list of input files from LIST and compute all of the
 318    relevant tables.  There is one file per line of the list.  At
 319    first, all the files on the list are language-generic, but
 320    eventually a line will appear which is the name of a language
 321    subdirectory in square brackets, like this: [cp].  All subsequent
 322    files are specific to that language, until another language
 323    subdirectory tag appears.  Files can appear more than once, if
 324    they apply to more than one language.  */
 325 static void
 326 read_input_list (const char *listname)
 327 {
 328   FILE *list = fopen (listname, "r");
 329   if (!list)
 330     fatal ("cannot open %s: %s", listname, xstrerror (errno));
 331   else
 332     {
 333       struct fileloc epos;
 334       size_t bufsz = measure_input_list (list);
 335       char *buf = XNEWVEC (char, bufsz);
 336       char *here = buf;
 337       char *committed = buf;
 338       char *limit = buf + bufsz;
 339       char *line;
 340       bool is_language;
 341       size_t langno = 0;
 342       size_t nfiles = 0;
 343       lang_bitmap curlangs = (1 << num_lang_dirs) - 1;
 344
 345       epos.file = input_file_by_name (listname);
 346       epos.line = 0;
 347
 348       lang_dir_names = XNEWVEC (const char *, num_lang_dirs);
 349       gt_files = XNEWVEC (const input_file *, num_gt_files);
 350
 351       for (;;)
 352         {
 353         next_line:
 354           epos.line++;
 355           committed = here;
 356           is_language = read_input_line (list, &here, &line, &epos);
 357           gcc_assert (here <= limit);
 358           if (line == 0)
 359             break;
 360           else if (is_language)
 361             {
 362               size_t i;
 363               gcc_assert (langno <= num_lang_dirs);
 364               for (i = 0; i < langno; i++)
 365                 if (strcmp (lang_dir_names[i], line) == 0)
 366                   {
 367                     error_at_line (&epos, "duplicate language tag [%s]",
 368                                    line);
 369                     curlangs = 1 << i;
 370                     here = committed;
 371                     goto next_line;
 372                   }
 373
 374               curlangs = 1 << langno;
 375               lang_dir_names[langno++] = line;
 376             }
 377           else
 378             {
 379               size_t i;
 380               input_file *inpf = input_file_by_name (line);
 381               gcc_assert (nfiles <= num_gt_files);
 382               for (i = 0; i < nfiles; i++)
 383                 /* Since the input_file-s are uniquely hash-consed, we
 384                    can just compare pointers! */
 385                 if (gt_files[i] == inpf)
 386                   {
 387                     /* Throw away the string we just read, and add the
 388                        current language to the existing string's bitmap.  */
 389                     lang_bitmap bmap = get_lang_bitmap (inpf);
 390                     if (bmap & curlangs)
 391                       error_at_line (&epos,
 392                                      "file %s specified more than once "
 393                                      "for language %s", line,
 394                                      langno ==
 395                                      0 ? "(all)" : lang_dir_names[langno -
 396                                                                   1]);
 397
 398                     bmap |= curlangs;
 399                     set_lang_bitmap (inpf, bmap);
 400                     here = committed;
 401                     goto next_line;
 402                   }
 403
 404               set_lang_bitmap (inpf, curlangs);
 405               gt_files[nfiles++] = inpf;
 406             }
 407         }
 408       /* Update the global counts now that we know accurately how many
 409          things there are.  (We do not bother resizing the arrays down.)  */
 410       num_lang_dirs = langno;
 411       /* Add the plugin files if provided.  */
 412       if (plugin_files)
 413         {
 414           size_t i;
 415           for (i = 0; i < nb_plugin_files; i++)
 416             gt_files[nfiles++] = plugin_files[i];
 417         }
 418       num_gt_files = nfiles;
 419     }
 420
 421   /* Sanity check: any file that resides in a language subdirectory
 422      (e.g. 'cp') ought to belong to the corresponding language.
 423      ??? Still true if for instance ObjC++ is enabled and C++ isn't?
 424      (Can you even do that?  Should you be allowed to?)  */
 425   {
 426     size_t f;
 427     for (f = 0; f < num_gt_files; f++)
 428       {
 429         lang_bitmap bitmap = get_lang_bitmap (gt_files[f]);
 430         const char *basename = get_file_basename (gt_files[f]);
 431         const char *slashpos = strchr (basename, '/');
 432
 433         if (slashpos)
 434           {
 435             size_t l;
 436             for (l = 0; l < num_lang_dirs; l++)
 437               if ((size_t) (slashpos - basename) == strlen (lang_dir_names[l])
 438                   && memcmp (basename, lang_dir_names[l],
 439                              strlen (lang_dir_names[l])) == 0)
 440                 {
 441                   if (!(bitmap & (1 << l)))
 442                     error ("%s is in language directory '%s' but is not "
 443                            "tagged for that language",
 444                            basename, lang_dir_names[l]);
 445                   break;
 446                 }
 447           }
 448       }
 449   }
 450
 451   if (ferror (list))
 452     fatal ("error reading %s: %s", listname, xstrerror (errno));
 453
 454   fclose (list);
 455 }
 456 \f
 457
 458
 459 /* The one and only TYPE_STRING.  */
 460
 461 struct type string_type = {
 462   TYPE_STRING, 0, 0, 0, GC_USED, {0}
 463 };
 464
 465 /* The two and only TYPE_SCALARs.  Their u.scalar_is_char flags are
 466    set early in main.  */
 467
 468 struct type scalar_nonchar = {
 469   TYPE_SCALAR, 0, 0, 0, GC_USED, {0}
 470 };
 471
 472 struct type scalar_char = {
 473   TYPE_SCALAR, 0, 0, 0, GC_USED, {0}
 474 };
 475
 476 /* Lists of various things.  */
 477
 478 pair_p typedefs;
 479 type_p structures;
 480 type_p param_structs;
 481 pair_p variables;
 482
 483 static type_p find_param_structure (type_p t, type_p param[NUM_PARAM]);
 484 static type_p adjust_field_tree_exp (type_p t, options_p opt);
 485 static type_p adjust_field_rtx_def (type_p t, options_p opt);
 486
 487 /* Define S as a typedef to T at POS.  */
 488
 489 void
 490 do_typedef (const char *s, type_p t, struct fileloc *pos)
 491 {
 492   pair_p p;
 493
 494   /* temporary kludge - gengtype doesn't handle conditionals or
 495      macros.  Ignore any attempt to typedef CUMULATIVE_ARGS, unless it
 496      is coming from this file (main() sets them up with safe dummy
 497      definitions).  */
 498   if (!strcmp (s, "CUMULATIVE_ARGS") && pos->file != this_file)
 499     return;
 500
 501   for (p = typedefs; p != NULL; p = p->next)
 502     if (strcmp (p->name, s) == 0)
 503       {
 504         if (p->type != t)
 505           {
 506             error_at_line (pos, "type `%s' previously defined", s);
 507             error_at_line (&p->line, "previously defined here");
 508           }
 509         return;
 510       }
 511
 512   p = XNEW (struct pair);
 513   p->next = typedefs;
 514   p->name = s;
 515   p->type = t;
 516   p->line = *pos;
 517   p->opt = NULL;
 518   typedefs = p;
 519 }
 520
 521 /* Define S as a typename of a scalar.  Cannot be used to define
 522    typedefs of 'char'.  Note: is also used for pointer-to-function
 523    typedefs (which are therefore not treated as pointers).  */
 524
 525 void
 526 do_scalar_typedef (const char *s, struct fileloc *pos)
 527 {
 528   do_typedef (s, &scalar_nonchar, pos);
 529 }
 530
 531 /* Return the type previously defined for S.  Use POS to report errors.  */
 532
 533 type_p
 534 resolve_typedef (const char *s, struct fileloc *pos)
 535 {
 536   pair_p p;
 537   for (p = typedefs; p != NULL; p = p->next)
 538     if (strcmp (p->name, s) == 0)
 539       return p->type;
 540   error_at_line (pos, "unidentified type `%s'", s);
 541   return &scalar_nonchar;       /* treat as "int" */
 542 }
 543
 544 /* Create and return a new structure with tag NAME (or a union iff
 545    ISUNION is nonzero), at POS with fields FIELDS and options O.  */
 546
 547 type_p
 548 new_structure (const char *name, int isunion, struct fileloc *pos,
 549                pair_p fields, options_p o)
 550 {
 551   type_p si;
 552   type_p s = NULL;
 553   lang_bitmap bitmap = get_lang_bitmap (pos->file);
 554
 555   for (si = structures; si != NULL; si = si->next)
 556     if (strcmp (name, si->u.s.tag) == 0 && UNION_P (si) == isunion)
 557       {
 558         type_p ls = NULL;
 559         if (si->kind == TYPE_LANG_STRUCT)
 560           {
 561             ls = si;
 562
 563             for (si = ls->u.s.lang_struct; si != NULL; si = si->next)
 564               if (si->u.s.bitmap == bitmap)
 565                 s = si;
 566           }
 567         else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap)
 568           {
 569             ls = si;
 570             type_count++;
 571             si = XCNEW (struct type);
 572             memcpy (si, ls, sizeof (struct type));
 573             ls->kind = TYPE_LANG_STRUCT;
 574             ls->u.s.lang_struct = si;
 575             ls->u.s.fields = NULL;
 576             si->next = NULL;
 577             si->state_number = -type_count;
 578             si->pointer_to = NULL;
 579             si->u.s.lang_struct = ls;
 580           }
 581         else
 582           s = si;
 583
 584         if (ls != NULL && s == NULL)
 585           {
 586             type_count++;
 587             s = XCNEW (struct type);
 588             s->state_number = -type_count;
 589             s->next = ls->u.s.lang_struct;
 590             ls->u.s.lang_struct = s;
 591             s->u.s.lang_struct = ls;
 592           }
 593         break;
 594       }
 595
 596   if (s == NULL)
 597     {
 598       type_count++;
 599       s = XCNEW (struct type);
 600       s->state_number = -type_count;
 601       s->next = structures;
 602       structures = s;
 603     }
 604
 605   if (s->u.s.line.file != NULL
 606       || (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap)))
 607     {
 608       error_at_line (pos, "duplicate definition of '%s %s'",
 609                      isunion ? "union" : "struct", s->u.s.tag);
 610       error_at_line (&s->u.s.line, "previous definition here");
 611     }
 612
 613   s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
 614   s->u.s.tag = name;
 615   s->u.s.line = *pos;
 616   s->u.s.fields = fields;
 617   s->u.s.opt = o;
 618   s->u.s.bitmap = bitmap;
 619   if (s->u.s.lang_struct)
 620     s->u.s.lang_struct->u.s.bitmap |= bitmap;
 621
 622   return s;
 623 }
 624
 625 /* Return the previously-defined structure with tag NAME (or a union
 626    iff ISUNION is nonzero), or a new empty structure or union if none
 627    was defined previously.  */
 628
 629 type_p
 630 find_structure (const char *name, int isunion)
 631 {
 632   type_p s;
 633
 634   for (s = structures; s != NULL; s = s->next)
 635     if (strcmp (name, s->u.s.tag) == 0 && UNION_P (s) == isunion)
 636       return s;
 637
 638   type_count++;
 639   s = XCNEW (struct type);
 640   s->next = structures;
 641   s->state_number = -type_count;
 642   structures = s;
 643   s->kind = isunion ? TYPE_UNION : TYPE_STRUCT;
 644   s->u.s.tag = name;
 645   structures = s;
 646   return s;
 647 }
 648
 649 /* Return the previously-defined parameterized structure for structure
 650    T and parameters PARAM, or a new parameterized empty structure or
 651    union if none was defined previously.  */
 652
 653 static type_p
 654 find_param_structure (type_p t, type_p param[NUM_PARAM])
 655 {
 656   type_p res;
 657
 658   for (res = param_structs; res; res = res->next)
 659     if (res->u.param_struct.stru == t
 660         && memcmp (res->u.param_struct.param, param,
 661                    sizeof (type_p) * NUM_PARAM) == 0)
 662       break;
 663   if (res == NULL)
 664     {
 665       type_count++;
 666       res = XCNEW (struct type);
 667       res->kind = TYPE_PARAM_STRUCT;
 668       res->next = param_structs;
 669       res->state_number = -type_count;
 670       param_structs = res;
 671       res->u.param_struct.stru = t;
 672       memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM);
 673     }
 674   return res;
 675 }
 676
 677 /* Return a scalar type with name NAME.  */
 678
 679 type_p
 680 create_scalar_type (const char *name)
 681 {
 682   if (!strcmp (name, "char") || !strcmp (name, "unsigned char"))
 683     return &scalar_char;
 684   else
 685     return &scalar_nonchar;
 686 }
 687
 688 /* Return a pointer to T.  */
 689
 690 type_p
 691 create_pointer (type_p t)
 692 {
 693   if (!t->pointer_to)
 694     {
 695       type_p r = XCNEW (struct type);
 696       type_count++;
 697       r->state_number = -type_count;
 698       r->kind = TYPE_POINTER;
 699       r->u.p = t;
 700       t->pointer_to = r;
 701     }
 702   return t->pointer_to;
 703 }
 704
 705 /* Return an array of length LEN.  */
 706
 707 type_p
 708 create_array (type_p t, const char *len)
 709 {
 710   type_p v;
 711
 712   type_count++;
 713   v = XCNEW (struct type);
 714   v->kind = TYPE_ARRAY;
 715   v->state_number = -type_count;
 716   v->u.a.p = t;
 717   v->u.a.len = len;
 718   return v;
 719 }
 720
 721 /* Return a string options structure with name NAME and info INFO.
 722    NEXT is the next option in the chain.  */
 723 options_p
 724 create_string_option (options_p next, const char *name, const char *info)
 725 {
 726   options_p o = XNEW (struct options);
 727   o->kind = OPTION_STRING;
 728   o->next = next;
 729   o->name = name;
 730   o->info.string = info;
 731   return o;
 732 }
 733
 734 /* Create a type options structure with name NAME and info INFO.  NEXT
 735    is the next option in the chain.  */
 736 options_p
 737 create_type_option (options_p next, const char* name, type_p info)
 738 {
 739   options_p o = XNEW (struct options);
 740   o->next = next;
 741   o->name = name;
 742   o->kind = OPTION_TYPE;
 743   o->info.type = info;
 744   return o;
 745 }
 746
 747 /* Create a nested pointer options structure with name NAME and info
 748    INFO.  NEXT is the next option in the chain.  */
 749 options_p
 750 create_nested_option (options_p next, const char* name,
 751                       struct nested_ptr_data* info)
 752 {
 753   options_p o;
 754   o = XNEW (struct options);
 755   o->next = next;
 756   o->name = name;
 757   o->kind = OPTION_NESTED;
 758   o->info.nested = info;
 759   return o;
 760 }
 761
 762 /* Return an options structure for a "nested_ptr" option.  */
 763 options_p
 764 create_nested_ptr_option (options_p next, type_p t,
 765                           const char *to, const char *from)
 766 {
 767   struct nested_ptr_data *d = XNEW (struct nested_ptr_data);
 768
 769   d->type = adjust_field_type (t, 0);
 770   d->convert_to = to;
 771   d->convert_from = from;
 772   return create_nested_option (next, "nested_ptr", d);
 773 }
 774
 775 /* Add a variable named S of type T with options O defined at POS,
 776    to `variables'.  */
 777 void
 778 note_variable (const char *s, type_p t, options_p o, struct fileloc *pos)
 779 {
 780   pair_p n;
 781   n = XNEW (struct pair);
 782   n->name = s;
 783   n->type = t;
 784   n->line = *pos;
 785   n->opt = o;
 786   n->next = variables;
 787   variables = n;
 788 }
 789
 790 /* Most-general structure field creator.  */
 791 static pair_p
 792 create_field_all (pair_p next, type_p type, const char *name, options_p opt,
 793                   const input_file *inpf, int line)
 794 {
 795   pair_p field;
 796
 797   field = XNEW (struct pair);
 798   field->next = next;
 799   field->type = type;
 800   field->name = name;
 801   field->opt = opt;
 802   field->line.file = inpf;
 803   field->line.line = line;
 804   return field;
 805 }
 806
 807 /* Create a field that came from the source code we are scanning,
 808    i.e. we have a 'struct fileloc', and possibly options; also,
 809    adjust_field_type should be called.  */
 810 pair_p
 811 create_field_at (pair_p next, type_p type, const char *name, options_p opt,
 812                  struct fileloc *pos)
 813 {
 814   return create_field_all (next, adjust_field_type (type, opt),
 815                            name, opt, pos->file, pos->line);
 816 }
 817
 818 /* Create a fake field with the given type and name.  NEXT is the next
 819    field in the chain.  */
 820 #define create_field(next,type,name) \
 821     create_field_all(next,type,name, 0, this_file, __LINE__)
 822
 823 /* Like create_field, but the field is only valid when condition COND
 824    is true.  */
 825
 826 static pair_p
 827 create_optional_field_ (pair_p next, type_p type, const char *name,
 828                         const char *cond, int line)
 829 {
 830   static int id = 1;
 831   pair_p union_fields;
 832   type_p union_type;
 833
 834   /* Create a fake union type with a single nameless field of type TYPE.
 835      The field has a tag of "1".  This allows us to make the presence
 836      of a field of type TYPE depend on some boolean "desc" being true.  */
 837   union_fields = create_field (NULL, type, "");
 838   union_fields->opt =
 839     create_string_option (union_fields->opt, "dot", "");
 840   union_fields->opt =
 841     create_string_option (union_fields->opt, "tag", "1");
 842   union_type =
 843     new_structure (xasprintf ("%s_%d", "fake_union", id++), 1,
 844                    &lexer_line, union_fields, NULL);
 845
 846   /* Create the field and give it the new fake union type.  Add a "desc"
 847      tag that specifies the condition under which the field is valid.  */
 848   return create_field_all (next, union_type, name,
 849                            create_string_option (0, "desc", cond),
 850                            this_file, line);
 851 }
 852
 853 #define create_optional_field(next,type,name,cond)      \
 854        create_optional_field_(next,type,name,cond,__LINE__)
 855
 856 /* Reverse a linked list of 'struct pair's in place.  */
 857 pair_p
 858 nreverse_pairs (pair_p list)
 859 {
 860   pair_p prev = 0, p, next;
 861   for (p = list; p; p = next)
 862     {
 863       next = p->next;
 864       p->next = prev;
 865       prev = p;
 866     }
 867   return prev;
 868 }
 869 \f
 870
 871 /* We don't care how long a CONST_DOUBLE is.  */
 872 #define CONST_DOUBLE_FORMAT "ww"
 873 /* We don't want to see codes that are only for generator files.  */
 874 #undef GENERATOR_FILE
 875
 876 enum rtx_code
 877 {
 878 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
 879 #include "rtl.def"
 880 #undef DEF_RTL_EXPR
 881   NUM_RTX_CODE
 882 };
 883
 884 static const char *const rtx_name[NUM_RTX_CODE] = {
 885 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   NAME ,
 886 #include "rtl.def"
 887 #undef DEF_RTL_EXPR
 888 };
 889
 890 static const char *const rtx_format[NUM_RTX_CODE] = {
 891 #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS)   FORMAT ,
 892 #include "rtl.def"
 893 #undef DEF_RTL_EXPR
 894 };
 895
 896 static int rtx_next_new[NUM_RTX_CODE];
 897
 898 /* We also need codes and names for insn notes (not register notes).
 899    Note that we do *not* bias the note values here.  */
 900 enum insn_note
 901 {
 902 #define DEF_INSN_NOTE(NAME) NAME,
 903 #include "insn-notes.def"
 904 #undef DEF_INSN_NOTE
 905
 906   NOTE_INSN_MAX
 907 };
 908
 909 /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
 910    default field for line number notes.  */
 911 static const char *const note_insn_name[NOTE_INSN_MAX + 1] = {
 912 #define DEF_INSN_NOTE(NAME) #NAME,
 913 #include "insn-notes.def"
 914 #undef DEF_INSN_NOTE
 915 };
 916
 917 #undef CONST_DOUBLE_FORMAT
 918 #define GENERATOR_FILE
 919
 920 /* Generate the contents of the rtx_next array.  This really doesn't belong
 921    in gengtype at all, but it's needed for adjust_field_rtx_def.  */
 922
 923 static void
 924 gen_rtx_next (void)
 925 {
 926   int i;
 927   for (i = 0; i < NUM_RTX_CODE; i++)
 928     {
 929       int k;
 930
 931       rtx_next_new[i] = -1;
 932       if (strncmp (rtx_format[i], "iuu", 3) == 0)
 933         rtx_next_new[i] = 2;
 934       else if (i == COND_EXEC || i == SET || i == EXPR_LIST || i == INSN_LIST)
 935         rtx_next_new[i] = 1;
 936       else
 937         for (k = strlen (rtx_format[i]) - 1; k >= 0; k--)
 938           if (rtx_format[i][k] == 'e' || rtx_format[i][k] == 'u')
 939             rtx_next_new[i] = k;
 940     }
 941 }
 942
 943 /* Write out the contents of the rtx_next array.  */
 944 static void
 945 write_rtx_next (void)
 946 {
 947   outf_p f = get_output_file_with_visibility (NULL);
 948   int i;
 949   if (!f)
 950     return;
 951
 952   oprintf (f, "\n/* Used to implement the RTX_NEXT macro.  */\n");
 953   oprintf (f, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n");
 954   for (i = 0; i < NUM_RTX_CODE; i++)
 955     if (rtx_next_new[i] == -1)
 956       oprintf (f, "  0,\n");
 957     else
 958       oprintf (f,
 959                "  RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new[i]);
 960   oprintf (f, "};\n");
 961 }
 962
 963 /* Handle `special("rtx_def")'.  This is a special case for field
 964    `fld' of struct rtx_def, which is an array of unions whose values
 965    are based in a complex way on the type of RTL.  */
 966
 967 static type_p
 968 adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt))
 969 {
 970   pair_p flds = NULL;
 971   options_p nodot;
 972   int i;
 973   type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp;
 974   type_p basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp;
 975
 976   if (t->kind != TYPE_UNION)
 977     {
 978       error_at_line (&lexer_line,
 979                      "special `rtx_def' must be applied to a union");
 980       return &string_type;
 981     }
 982
 983   nodot = create_string_option (NULL, "dot", "");
 984
 985   rtx_tp = create_pointer (find_structure ("rtx_def", 0));
 986   rtvec_tp = create_pointer (find_structure ("rtvec_def", 0));
 987   tree_tp = create_pointer (find_structure ("tree_node", 1));
 988   mem_attrs_tp = create_pointer (find_structure ("mem_attrs", 0));
 989   reg_attrs_tp =
 990     create_pointer (find_structure ("reg_attrs", 0));
 991   basic_block_tp =
 992     create_pointer (find_structure ("basic_block_def", 0));
 993   constant_tp =
 994     create_pointer (find_structure ("constant_descriptor_rtx", 0));
 995   scalar_tp = &scalar_nonchar;  /* rtunion int */
 996
 997   {
 998     pair_p note_flds = NULL;
 999     int c;
1000
1001     for (c = 0; c <= NOTE_INSN_MAX; c++)
1002       {
1003         switch (c)
1004           {
1005           case NOTE_INSN_MAX:
1006           case NOTE_INSN_DELETED_LABEL:
1007             note_flds = create_field (note_flds, &string_type, "rt_str");
1008             break;
1009
1010           case NOTE_INSN_BLOCK_BEG:
1011           case NOTE_INSN_BLOCK_END:
1012             note_flds = create_field (note_flds, tree_tp, "rt_tree");
1013             break;
1014
1015           case NOTE_INSN_VAR_LOCATION:
1016             note_flds = create_field (note_flds, rtx_tp, "rt_rtx");
1017             break;
1018
1019           default:
1020             note_flds = create_field (note_flds, scalar_tp, "rt_int");
1021             break;
1022           }
1023         /* NOTE_INSN_MAX is used as the default field for line
1024            number notes.  */
1025         if (c == NOTE_INSN_MAX)
1026           note_flds->opt =
1027             create_string_option (nodot, "default", "");
1028         else
1029           note_flds->opt =
1030             create_string_option (nodot, "tag", note_insn_name[c]);
1031       }
1032     note_union_tp = new_structure ("rtx_def_note_subunion", 1,
1033                                    &lexer_line, note_flds, NULL);
1034   }
1035   /* Create a type to represent the various forms of SYMBOL_REF_DATA.  */
1036   {
1037     pair_p sym_flds;
1038     sym_flds = create_field (NULL, tree_tp, "rt_tree");
1039     sym_flds->opt = create_string_option (nodot, "default", "");
1040     sym_flds = create_field (sym_flds, constant_tp, "rt_constant");
1041     sym_flds->opt = create_string_option (nodot, "tag", "1");
1042     symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1,
1043                                      &lexer_line, sym_flds, NULL);
1044   }
1045   for (i = 0; i < NUM_RTX_CODE; i++)
1046     {
1047       pair_p subfields = NULL;
1048       size_t aindex, nmindex;
1049       const char *sname;
1050       type_p substruct;
1051       char *ftag;
1052
1053       for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++)
1054         {
1055           type_p t;
1056           const char *subname;
1057
1058           switch (rtx_format[i][aindex])
1059             {
1060             case '*':
1061             case 'i':
1062             case 'n':
1063             case 'w':
1064               t = scalar_tp;
1065               subname = "rt_int";
1066               break;
1067
1068             case '0':
1069               if (i == MEM && aindex == 1)
1070                 t = mem_attrs_tp, subname = "rt_mem";
1071               else if (i == JUMP_INSN && aindex == 8)
1072                 t = rtx_tp, subname = "rt_rtx";
1073               else if (i == CODE_LABEL && aindex == 5)
1074                 t = scalar_tp, subname = "rt_int";
1075               else if (i == CODE_LABEL && aindex == 4)
1076                 t = rtx_tp, subname = "rt_rtx";
1077               else if (i == LABEL_REF && (aindex == 1 || aindex == 2))
1078                 t = rtx_tp, subname = "rt_rtx";
1079               else if (i == NOTE && aindex == 4)
1080                 t = note_union_tp, subname = "";
1081               else if (i == NOTE && aindex == 5)
1082                 t = scalar_tp, subname = "rt_int";
1083               else if (i == NOTE && aindex >= 7)
1084                 t = scalar_tp, subname = "rt_int";
1085               else if (i == ADDR_DIFF_VEC && aindex == 4)
1086                 t = scalar_tp, subname = "rt_int";
1087               else if (i == VALUE && aindex == 0)
1088                 t = scalar_tp, subname = "rt_int";
1089               else if (i == DEBUG_EXPR && aindex == 0)
1090                 t = tree_tp, subname = "rt_tree";
1091               else if (i == REG && aindex == 1)
1092                 t = scalar_tp, subname = "rt_int";
1093               else if (i == REG && aindex == 2)
1094                 t = reg_attrs_tp, subname = "rt_reg";
1095               else if (i == SCRATCH && aindex == 0)
1096                 t = scalar_tp, subname = "rt_int";
1097               else if (i == SYMBOL_REF && aindex == 1)
1098                 t = scalar_tp, subname = "rt_int";
1099               else if (i == SYMBOL_REF && aindex == 2)
1100                 t = symbol_union_tp, subname = "";
1101               else if (i == BARRIER && aindex >= 3)
1102                 t = scalar_tp, subname = "rt_int";
1103               else
1104                 {
1105                   error_at_line
1106                     (&lexer_line,
1107                      "rtx type `%s' has `0' in position %lu, can't handle",
1108                      rtx_name[i], (unsigned long) aindex);
1109                   t = &string_type;
1110                   subname = "rt_int";
1111                 }
1112               break;
1113
1114             case 's':
1115             case 'S':
1116             case 'T':
1117               t = &string_type;
1118               subname = "rt_str";
1119               break;
1120
1121             case 'e':
1122             case 'u':
1123               t = rtx_tp;
1124               subname = "rt_rtx";
1125               break;
1126
1127             case 'E':
1128             case 'V':
1129               t = rtvec_tp;
1130               subname = "rt_rtvec";
1131               break;
1132
1133             case 't':
1134               t = tree_tp;
1135               subname = "rt_tree";
1136               break;
1137
1138             case 'B':
1139               t = basic_block_tp;
1140               subname = "rt_bb";
1141               break;
1142
1143             default:
1144               error_at_line
1145                 (&lexer_line,
1146                  "rtx type `%s' has `%c' in position %lu, can't handle",
1147                  rtx_name[i], rtx_format[i][aindex],
1148                  (unsigned long) aindex);
1149               t = &string_type;
1150               subname = "rt_int";
1151               break;
1152             }
1153
1154           subfields = create_field (subfields, t,
1155                                     xasprintf (".fld[%lu].%s",
1156                                                (unsigned long) aindex,
1157                                                subname));
1158           subfields->opt = nodot;
1159           if (t == note_union_tp)
1160             subfields->opt =
1161               create_string_option (subfields->opt, "desc",
1162                                     "NOTE_KIND (&%0)");
1163           if (t == symbol_union_tp)
1164             subfields->opt =
1165               create_string_option (subfields->opt, "desc",
1166                                     "CONSTANT_POOL_ADDRESS_P (&%0)");
1167         }
1168
1169       if (i == SYMBOL_REF)
1170         {
1171           /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
1172              holds.  */
1173           type_p field_tp = find_structure ("block_symbol", 0);
1174           subfields
1175             = create_optional_field (subfields, field_tp, "block_sym",
1176                                      "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)");
1177         }
1178
1179       sname = xasprintf ("rtx_def_%s", rtx_name[i]);
1180       substruct = new_structure (sname, 0, &lexer_line, subfields, NULL);
1181
1182       ftag = xstrdup (rtx_name[i]);
1183       for (nmindex = 0; nmindex < strlen (ftag); nmindex++)
1184         ftag[nmindex] = TOUPPER (ftag[nmindex]);
1185       flds = create_field (flds, substruct, "");
1186       flds->opt = create_string_option (nodot, "tag", ftag);
1187     }
1188   return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot);
1189 }
1190
1191 /* Handle `special("tree_exp")'.  This is a special case for
1192    field `operands' of struct tree_exp, which although it claims to contain
1193    pointers to trees, actually sometimes contains pointers to RTL too.
1194    Passed T, the old type of the field, and OPT its options.  Returns
1195    a new type for the field.  */
1196
1197 static type_p
1198 adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED)
1199 {
1200   pair_p flds;
1201   options_p nodot;
1202
1203   if (t->kind != TYPE_ARRAY)
1204     {
1205       error_at_line (&lexer_line,
1206                      "special `tree_exp' must be applied to an array");
1207       return &string_type;
1208     }
1209
1210   nodot = create_string_option (NULL, "dot", "");
1211
1212   flds = create_field (NULL, t, "");
1213   flds->opt = create_string_option (nodot, "length",
1214                                     "TREE_OPERAND_LENGTH ((tree) &%0)");
1215   flds->opt = create_string_option (flds->opt, "default", "");
1216
1217   return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot);
1218 }
1219
1220 /* Perform any special processing on a type T, about to become the type
1221    of a field.  Return the appropriate type for the field.
1222    At present:
1223    - Converts pointer-to-char, with no length parameter, to TYPE_STRING;
1224    - Similarly for arrays of pointer-to-char;
1225    - Converts structures for which a parameter is provided to
1226      TYPE_PARAM_STRUCT;
1227    - Handles "special" options.
1228 */
1229
1230 type_p
1231 adjust_field_type (type_p t, options_p opt)
1232 {
1233   int length_p = 0;
1234   const int pointer_p = t->kind == TYPE_POINTER;
1235   type_p params[NUM_PARAM];
1236   int params_p = 0;
1237   int i;
1238
1239   for (i = 0; i < NUM_PARAM; i++)
1240     params[i] = NULL;
1241
1242   for (; opt; opt = opt->next)
1243     if (strcmp (opt->name, "length") == 0)
1244       length_p = 1;
1245     else if ((strcmp (opt->name, "param_is") == 0
1246               || (strncmp (opt->name, "param", 5) == 0
1247                   && ISDIGIT (opt->name[5])
1248                   && strcmp (opt->name + 6, "_is") == 0))
1249              && opt->kind == OPTION_TYPE)
1250       {
1251         int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
1252
1253         if (!UNION_OR_STRUCT_P (t)
1254             && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p)))
1255           {
1256             error_at_line (&lexer_line,
1257                            "option `%s' may only be applied to structures or structure pointers",
1258                            opt->name);
1259             return t;
1260           }
1261
1262         params_p = 1;
1263         if (params[num] != NULL)
1264           error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
1265         if (!ISDIGIT (opt->name[5]))
1266           params[num] = create_pointer (opt->info.type);
1267         else
1268           params[num] = opt->info.type;
1269       }
1270     else if (strcmp (opt->name, "special") == 0
1271              && opt->kind == OPTION_STRING)
1272       {
1273         const char *special_name = opt->info.string;
1274         if (strcmp (special_name, "tree_exp") == 0)
1275           t = adjust_field_tree_exp (t, opt);
1276         else if (strcmp (special_name, "rtx_def") == 0)
1277           t = adjust_field_rtx_def (t, opt);
1278         else
1279           error_at_line (&lexer_line, "unknown special `%s'", special_name);
1280       }
1281
1282   if (params_p)
1283     {
1284       type_p realt;
1285
1286       if (pointer_p)
1287         t = t->u.p;
1288       realt = find_param_structure (t, params);
1289       t = pointer_p ? create_pointer (realt) : realt;
1290     }
1291
1292   if (!length_p
1293       && pointer_p && t->u.p->kind == TYPE_SCALAR && t->u.p->u.scalar_is_char)
1294     return &string_type;
1295   if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER
1296       && t->u.a.p->u.p->kind == TYPE_SCALAR
1297       && t->u.a.p->u.p->u.scalar_is_char)
1298     return create_array (&string_type, t->u.a.len);
1299
1300   return t;
1301 }
1302 \f
1303
1304 static void set_gc_used_type (type_p, enum gc_used_enum, type_p *);
1305 static void set_gc_used (pair_p);
1306
1307 /* Handle OPT for set_gc_used_type.  */
1308
1309 static void
1310 process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef,
1311                     int *pass_param, int *length, int *skip,
1312                     type_p *nested_ptr)
1313 {
1314   options_p o;
1315   for (o = opt; o; o = o->next)
1316     if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO
1317         && o->kind == OPTION_TYPE)
1318       set_gc_used_type (o->info.type,
1319                         GC_POINTED_TO, NULL);
1320     else if (strcmp (o->name, "maybe_undef") == 0)
1321       *maybe_undef = 1;
1322     else if (strcmp (o->name, "use_params") == 0)
1323       *pass_param = 1;
1324     else if (strcmp (o->name, "length") == 0)
1325       *length = 1;
1326     else if (strcmp (o->name, "skip") == 0)
1327       *skip = 1;
1328     else if (strcmp (o->name, "nested_ptr") == 0
1329              && o->kind == OPTION_NESTED)
1330       *nested_ptr = ((const struct nested_ptr_data *) o->info.nested)->type;
1331 }
1332
1333
1334 /* Set the gc_used field of T to LEVEL, and handle the types it references.  */
1335 static void
1336 set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM])
1337 {
1338   if (t->gc_used >= level)
1339     return;
1340
1341   t->gc_used = level;
1342
1343   switch (t->kind)
1344     {
1345     case TYPE_STRUCT:
1346     case TYPE_UNION:
1347       {
1348         pair_p f;
1349         int dummy;
1350         type_p dummy2;
1351
1352         process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
1353                             &dummy2);
1354
1355         for (f = t->u.s.fields; f; f = f->next)
1356           {
1357             int maybe_undef = 0;
1358             int pass_param = 0;
1359             int length = 0;
1360             int skip = 0;
1361             type_p nested_ptr = NULL;
1362             process_gc_options (f->opt, level, &maybe_undef, &pass_param,
1363                                 &length, &skip, &nested_ptr);
1364
1365             if (nested_ptr && f->type->kind == TYPE_POINTER)
1366               set_gc_used_type (nested_ptr, GC_POINTED_TO,
1367                                 pass_param ? param : NULL);
1368             else if (length && f->type->kind == TYPE_POINTER)
1369               set_gc_used_type (f->type->u.p, GC_USED, NULL);
1370             else if (maybe_undef && f->type->kind == TYPE_POINTER)
1371               set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL);
1372             else if (pass_param && f->type->kind == TYPE_POINTER && param)
1373               set_gc_used_type (find_param_structure (f->type->u.p, param),
1374                                 GC_POINTED_TO, NULL);
1375             else if (skip)
1376               ;                 /* target type is not used through this field */
1377             else
1378               set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL);
1379           }
1380         break;
1381       }
1382
1383     case TYPE_POINTER:
1384       set_gc_used_type (t->u.p, GC_POINTED_TO, NULL);
1385       break;
1386
1387     case TYPE_ARRAY:
1388       set_gc_used_type (t->u.a.p, GC_USED, param);
1389       break;
1390
1391     case TYPE_LANG_STRUCT:
1392       for (t = t->u.s.lang_struct; t; t = t->next)
1393         set_gc_used_type (t, level, param);
1394       break;
1395
1396     case TYPE_PARAM_STRUCT:
1397       {
1398         int i;
1399         for (i = 0; i < NUM_PARAM; i++)
1400           if (t->u.param_struct.param[i] != 0)
1401             set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL);
1402       }
1403       if (t->u.param_struct.stru->gc_used == GC_POINTED_TO)
1404         level = GC_POINTED_TO;
1405       else
1406         level = GC_USED;
1407       t->u.param_struct.stru->gc_used = GC_UNUSED;
1408       set_gc_used_type (t->u.param_struct.stru, level,
1409                         t->u.param_struct.param);
1410       break;
1411
1412     default:
1413       break;
1414     }
1415 }
1416
1417 /* Set the gc_used fields of all the types pointed to by VARIABLES.  */
1418
1419 static void
1420 set_gc_used (pair_p variables)
1421 {
1422   int nbvars = 0;
1423   pair_p p;
1424   for (p = variables; p; p = p->next)
1425     {
1426       set_gc_used_type (p->type, GC_USED, NULL);
1427       nbvars++;
1428     };
1429   if (verbosity_level >= 2)
1430     printf ("%s used %d GTY-ed variables\n", progname, nbvars);
1431 }
1432 \f
1433 /* File mapping routines.  For each input file, there is one output .c file
1434    (but some output files have many input files), and there is one .h file
1435    for the whole build.  */
1436
1437 /* Output file handling.  */
1438
1439 /* Create and return an outf_p for a new file for NAME, to be called
1440    ONAME.  */
1441
1442 static outf_p
1443 create_file (const char *name, const char *oname)
1444 {
1445   static const char *const hdr[] = {
1446     "   Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
1447     "\n",
1448     "This file is part of GCC.\n",
1449     "\n",
1450     "GCC is free software; you can redistribute it and/or modify it under\n",
1451     "the terms of the GNU General Public License as published by the Free\n",
1452     "Software Foundation; either version 3, or (at your option) any later\n",
1453     "version.\n",
1454     "\n",
1455     "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n",
1456     "WARRANTY; without even the implied warranty of MERCHANTABILITY or\n",
1457     "FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License\n",
1458     "for more details.\n",
1459     "\n",
1460     "You should have received a copy of the GNU General Public License\n",
1461     "along with GCC; see the file COPYING3.  If not see\n",
1462     "<http://www.gnu.org/licenses/>.  */\n",
1463     "\n",
1464     "/* This file is machine generated.  Do not edit.  */\n"
1465   };
1466   outf_p f;
1467   size_t i;
1468
1469   gcc_assert (name != NULL);
1470   gcc_assert (oname != NULL);
1471   f = XCNEW (struct outf);
1472   f->next = output_files;
1473   f->name = oname;
1474   output_files = f;
1475
1476   oprintf (f, "/* Type information for %s.\n", name);
1477   for (i = 0; i < ARRAY_SIZE (hdr); i++)
1478     oprintf (f, "%s", hdr[i]);
1479   return f;
1480 }
1481
1482 /* Print, like fprintf, to O.
1483    N.B. You might think this could be implemented more efficiently
1484    with vsnprintf().  Unfortunately, there are C libraries that
1485    provide that function but without the C99 semantics for its return
1486    value, making it impossible to know how much space is required.  */
1487 void
1488 oprintf (outf_p o, const char *format, ...)
1489 {
1490   char *s;
1491   size_t slength;
1492   va_list ap;
1493
1494   /* In plugin mode, the O could be a NULL pointer, so avoid crashing
1495      in that case.  */
1496   if (!o)
1497     return;
1498
1499   va_start (ap, format);
1500   slength = vasprintf (&s, format, ap);
1501   if (s == NULL || (int) slength < 0)
1502     fatal ("out of memory");
1503   va_end (ap);
1504
1505   if (o->bufused + slength > o->buflength)
1506     {
1507       size_t new_len = o->buflength;
1508       if (new_len == 0)
1509         new_len = 1024;
1510       do
1511         {
1512           new_len *= 2;
1513         }
1514       while (o->bufused + slength >= new_len);
1515       o->buf = XRESIZEVEC (char, o->buf, new_len);
1516       o->buflength = new_len;
1517     }
1518   memcpy (o->buf + o->bufused, s, slength);
1519   o->bufused += slength;
1520   free (s);
1521 }
1522
1523 /* Open the global header file and the language-specific header files.  */
1524
1525 static void
1526 open_base_files (void)
1527 {
1528   size_t i;
1529
1530   if (nb_plugin_files > 0 && plugin_files)
1531     return;
1532
1533   header_file = create_file ("GCC", "gtype-desc.h");
1534
1535   base_files = XNEWVEC (outf_p, num_lang_dirs);
1536
1537   for (i = 0; i < num_lang_dirs; i++)
1538     base_files[i] = create_file (lang_dir_names[i],
1539                                  xasprintf ("gtype-%s.h", lang_dir_names[i]));
1540
1541   /* gtype-desc.c is a little special, so we create it here.  */
1542   {
1543     /* The order of files here matters very much.  */
1544     static const char *const ifiles[] = {
1545       "config.h", "system.h", "coretypes.h", "tm.h",
1546       "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
1547       "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h",
1548       "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
1549       "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
1550       "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
1551       "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
1552       "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", NULL
1553     };
1554     const char *const *ifp;
1555     outf_p gtype_desc_c;
1556
1557     gtype_desc_c = create_file ("GCC", "gtype-desc.c");
1558     for (ifp = ifiles; *ifp; ifp++)
1559       oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp);
1560
1561     /* Make sure we handle "cfun" specially.  */
1562     oprintf (gtype_desc_c, "\n/* See definition in function.h.  */\n");
1563     oprintf (gtype_desc_c, "#undef cfun\n");
1564   }
1565 }
1566
1567 /* For INPF an input file, return the real basename of INPF, with all
1568    the directory components skipped.  */
1569
1570 static const char *
1571 get_file_realbasename (const input_file *inpf)
1572 {
1573   const char *f = get_input_file_name (inpf);
1574   const char *lastslash = strrchr (f, '/');
1575
1576   return (lastslash != NULL) ? lastslash + 1 : f;
1577 }
1578
1579 /* For INPF a filename, return the relative path to INPF from
1580    $(srcdir) if the latter is a prefix in INPF, NULL otherwise.  */
1581
1582 const char *
1583 get_file_srcdir_relative_path (const input_file *inpf)
1584 {
1585   const char *f = get_input_file_name (inpf);
1586   if (strlen (f) > srcdir_len
1587       && IS_DIR_SEPARATOR (f[srcdir_len])
1588       && strncmp (f, srcdir, srcdir_len) == 0)
1589     return f + srcdir_len + 1;
1590   else
1591     return NULL;
1592 }
1593
1594 /*  For INPF an input_file, return the relative path to INPF from
1595     $(srcdir) if the latter is a prefix in INPF, or the real basename
1596     of INPF otherwise. */
1597
1598 static const char *
1599 get_file_basename (const input_file *inpf)
1600 {
1601   const char *srcdir_path = get_file_srcdir_relative_path (inpf);
1602
1603   return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (inpf);
1604 }
1605
1606 /* For F a filename, return the lang_dir_names relative index of the language
1607    directory that is a prefix in F, if any, -1 otherwise.  */
1608
1609 static int
1610 get_prefix_langdir_index (const char *f)
1611 {
1612   size_t f_len = strlen (f);
1613   size_t lang_index;
1614
1615   for (lang_index = 0; lang_index < num_lang_dirs; lang_index++)
1616     {
1617       const char *langdir = lang_dir_names[lang_index];
1618       size_t langdir_len = strlen (langdir);
1619
1620       if (f_len > langdir_len
1621           && IS_DIR_SEPARATOR (f[langdir_len])
1622           && memcmp (f, langdir, langdir_len) == 0)
1623         return lang_index;
1624     }
1625
1626   return -1;
1627 }
1628
1629 /* For INPF an input file, return the name of language directory where
1630    F is located, if any, NULL otherwise.  */
1631
1632 static const char *
1633 get_file_langdir (const input_file *inpf)
1634 {
1635   /* Get the relative path to INPF from $(srcdir) and find the
1636      language by comparing the prefix with language directory names.
1637      If INPF is not even srcdir relative, no point in looking
1638      further.  */
1639
1640   int lang_index;
1641   const char *srcdir_relative_path = get_file_srcdir_relative_path (inpf);
1642   const char *r;
1643
1644   if (!srcdir_relative_path)
1645     return NULL;
1646
1647   lang_index = get_prefix_langdir_index (srcdir_relative_path);
1648   if (lang_index < 0 && strncmp (srcdir_relative_path, "c-family", 8) == 0)
1649     r = "c-family";
1650   else if (lang_index >= 0)
1651     r = lang_dir_names[lang_index];
1652   else
1653     r = NULL;
1654
1655   return r;
1656 }
1657
1658 /* The gt- output file name for INPF.  */
1659
1660 static const char *
1661 get_file_gtfilename (const input_file *inpf)
1662 {
1663   /* Cook up an initial version of the gt- file name from the file real
1664      basename and the language name, if any.  */
1665
1666   const char *basename = get_file_realbasename (inpf);
1667   const char *langdir = get_file_langdir (inpf);
1668
1669   char *result =
1670     (langdir ? xasprintf ("gt-%s-%s", langdir, basename)
1671      : xasprintf ("gt-%s", basename));
1672
1673   /* Then replace all non alphanumerics characters by '-' and change the
1674      extension to ".h".  We expect the input filename extension was at least
1675      one character long.  */
1676
1677   char *s = result;
1678
1679   for (; *s != '.'; s++)
1680     if (!ISALNUM (*s) && *s != '-')
1681       *s = '-';
1682
1683   memcpy (s, ".h", sizeof (".h"));
1684
1685   return result;
1686 }
1687
1688 /* Each input_file has its associated output file outf_p.  The
1689    association is computed by the function
1690    get_output_file_with_visibility.  The associated file is cached
1691    inside input_file in its inpoutf field, so is really computed only
1692    once.  Associated output file paths (i.e. output_name-s) are
1693    computed by a rule based regexp machinery, using the files_rules
1694    array of struct file_rule_st.  A for_name is also computed, giving
1695    the source file name for which the output_file is generated; it is
1696    often the last component of the input_file path.  */
1697
1698
1699 /*
1700  Regexpr machinery to compute the output_name and for_name-s of each
1701  input_file.  We have a sequence of file rules which gives the POSIX
1702  extended regular expression to match an input file path, and two
1703  transformed strings for the corresponding output_name and the
1704  corresponding for_name.  The transformed string contain dollars: $0
1705  is replaced by the entire match, $1 is replaced by the substring
1706  matching the first parenthesis in the regexp, etc.  And $$ is replaced
1707  by a single verbatim dollar.  The rule order is important.  The
1708  general case is last, and the particular cases should come before.
1709  An action routine can, when needed, update the out_name & for_name
1710  and/or return the appropriate output file.  It is invoked only when a
1711  rule is triggered.  When a rule is triggered, the output_name and
1712  for_name are computed using their transform string in while $$, $0,
1713  $1, ... are suitably replaced.  If there is an action, it is called.
1714  In some few cases, the action can directly return the outf_p, but
1715  usually it just updates the output_name and for_name so should free
1716  them before replacing them.  The get_output_file_with_visibility
1717  function creates an outf_p only once per each output_name, so it
1718  scans the output_files list for previously seen output file names.
1719  */
1720
1721 /* Signature of actions in file rules.  */
1722 typedef outf_p (frul_actionrout_t) (input_file*, char**, char**);
1723
1724
1725 struct file_rule_st {
1726   const char* frul_srcexpr;     /* Source string for regexp.  */
1727   int frul_rflags;              /* Flags passed to regcomp, usually
1728                                  * REG_EXTENDED.  */
1729   regex_t* frul_re;             /* Compiled regular expression
1730                                    obtained by regcomp.  */
1731   const char* frul_tr_out;      /* Transformation string for making
1732                                  * the output_name, with $1 ... $9 for
1733                                  * subpatterns and $0 for the whole
1734                                  * matched filename.  */
1735   const char* frul_tr_for;      /* Tranformation string for making the
1736                                    for_name.  */
1737   frul_actionrout_t* frul_action; /* The action, if non null, is
1738                                    * called once the rule matches, on
1739                                    * the transformed out_name &
1740                                    * for_name.  It could change them
1741                                    * and/or give the output file.  */
1742 };
1743
1744 /* File rule action handling *.h files.  */
1745 static outf_p header_dot_h_frul (input_file*, char**, char**);
1746
1747 /* File rule action handling *.c files.  */
1748 static outf_p source_dot_c_frul (input_file*, char**, char**);
1749
1750 #define NULL_REGEX (regex_t*)0
1751
1752 /* The prefix in our regexp-s matching the directory.  */
1753 #define DIR_PREFIX_REGEX "^(([^/]*/)*)"
1754
1755 #define NULL_FRULACT (frul_actionrout_t*)0
1756
1757 /* The array of our rules governing file name generation.  Rules order
1758    matters, so change with extreme care!  */
1759
1760 struct file_rule_st files_rules[] = {
1761   /* the c-family/ source directory is special.  */
1762   { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.c$",
1763     REG_EXTENDED, NULL_REGEX,
1764     "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT},
1765
1766   { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.h$",
1767     REG_EXTENDED, NULL_REGEX,
1768     "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT},
1769
1770   /* Both c-lang.h & c-tree.h gives gt-c-decl.h for c-decl.c !  */
1771   { DIR_PREFIX_REGEX "c-lang\\.h$",
1772     REG_EXTENDED, NULL_REGEX, "gt-c-decl.h", "c-decl.c", NULL_FRULACT},
1773
1774   { DIR_PREFIX_REGEX "c-tree\\.h$",
1775     REG_EXTENDED, NULL_REGEX, "gt-c-decl.h", "c-decl.c", NULL_FRULACT},
1776
1777   /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c !  */
1778   { DIR_PREFIX_REGEX "cp/cp-tree\\.h$",
1779     REG_EXTENDED, NULL_REGEX,
1780     "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT },
1781
1782   /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c !  */
1783   { DIR_PREFIX_REGEX "cp/decl\\.[ch]$",
1784     REG_EXTENDED, NULL_REGEX,
1785     "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT },
1786
1787   /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c !  */
1788   { DIR_PREFIX_REGEX "cp/name-lookup\\.h$",
1789     REG_EXTENDED, NULL_REGEX,
1790     "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT },
1791
1792   /* objc/objc-act.h fives gt-objc-objc-act.h for objc/objc-act.c !  */
1793   { DIR_PREFIX_REGEX "objc/objc-act\\.h$",
1794     REG_EXTENDED, NULL_REGEX,
1795     "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT },
1796
1797   /* General cases.  For header *.h and source *.c files, we need
1798    * special actions to handle the language.  */
1799
1800   /* Source *.c files are using get_file_gtfilename to compute their
1801      output_name and get_file_basename to compute their for_name
1802      thru the source_dot_c_frul action.  */
1803   { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.c$",
1804     REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.c", source_dot_c_frul},
1805   /* Common header files get "gtype-desc.c" as their output_name,
1806    * while language specific header files are handled specially.  So
1807    * we need the header_dot_h_frul action.  */
1808   { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.h$",
1809     REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.h", header_dot_h_frul},
1810
1811   { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.in$",
1812     REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.in", NULL_FRULACT},
1813
1814   /* Mandatory null last entry signaling end of rules.  */
1815   {NULL, 0, NULL_REGEX, NULL, NULL, NULL_FRULACT}
1816 };
1817
1818 /* Special file rules action for handling *.h header files.  It gives
1819    "gtype-desc.c" for common headers and corresponding output
1820    files for language-specific header files.  */
1821 static outf_p
1822 header_dot_h_frul (input_file* inpf, char**poutname,
1823                    char**pforname ATTRIBUTE_UNUSED)
1824 {
1825   const char *basename = 0;
1826   int lang_index = 0;
1827   DBGPRINTF ("inpf %p inpname %s outname %s forname %s",
1828              (void*) inpf, get_input_file_name (inpf),
1829              *poutname, *pforname);
1830   basename = get_file_basename (inpf);
1831   lang_index = get_prefix_langdir_index (basename);
1832   DBGPRINTF ("basename %s lang_index %d", basename, lang_index);
1833
1834   if (lang_index >= 0)
1835     {
1836       /* The header is language specific.  Given output_name &
1837          for_name remains unchanged.  The base_files array gives the
1838          outf_p.  */
1839       DBGPRINTF ("header_dot_h found language specific @ %p '%s'",
1840                  (void*) base_files[lang_index],
1841                  (base_files[lang_index])->name);
1842       return base_files[lang_index];
1843     }
1844   else
1845     {
1846       /* The header is common to all front-end languages.  So
1847          output_name is "gtype-desc.c" file.  The calling function
1848          get_output_file_with_visibility will find its outf_p.  */
1849       free (*poutname);
1850       *poutname = xstrdup ("gtype-desc.c");
1851       DBGPRINTF ("special 'gtype-desc.c' for inpname %s",
1852                  get_input_file_name (inpf));
1853       return NULL;
1854     }
1855 }
1856
1857
1858 /* Special file rules action for handling *.c source files using
1859  * get_file_gtfilename to compute their output_name and
1860  * get_file_basename to compute their for_name.  The output_name is
1861  * gt-<LANG>-<BASE>.h for language specific source files, and
1862  * gt-<BASE>.h for common source files.  */
1863 static outf_p
1864 source_dot_c_frul (input_file* inpf, char**poutname, char**pforname)
1865 {
1866   char *newbasename = CONST_CAST (char*, get_file_basename (inpf));
1867   char *newoutname = CONST_CAST (char*, get_file_gtfilename (inpf));
1868   DBGPRINTF ("inpf %p inpname %s original outname %s forname %s",
1869              (void*) inpf, get_input_file_name (inpf),
1870              *poutname, *pforname);
1871   DBGPRINTF ("newoutname %s", newoutname);
1872   DBGPRINTF ("newbasename %s", newbasename);
1873   free (*poutname);
1874   free (*pforname);
1875   *poutname = newoutname;
1876   *pforname = newbasename;
1877   return NULL;
1878 }
1879
1880 /* Utility function for get_output_file_with_visibility which returns
1881  * a malloc-ed substituted string using TRS on matching of the FILNAM
1882  * file name, using the PMATCH array.  */
1883 static char*
1884 matching_file_name_substitute (const char *filnam, regmatch_t pmatch[10],
1885                                const char *trs)
1886 {
1887   struct obstack str_obstack;
1888   char *str = NULL;
1889   char *rawstr = NULL;
1890   const char *pt = NULL;
1891   DBGPRINTF ("filnam %s", filnam);
1892   obstack_init (&str_obstack);
1893   for (pt = trs; *pt; pt++) {
1894     char c = *pt;
1895     if (c == '$')
1896       {
1897         if (pt[1] == '$')
1898           {
1899             /* A double dollar $$ is substituted by a single verbatim
1900                dollar, but who really uses dollar signs in file
1901                paths? */
1902             obstack_1grow (&str_obstack, '$');
1903           }
1904         else if (ISDIGIT (pt[1]))
1905           {
1906             /* Handle $0 $1 ... $9 by appropriate substitution.  */
1907             int dolnum = pt[1] - '0';
1908             int so = pmatch[dolnum].rm_so;
1909             int eo = pmatch[dolnum].rm_eo;
1910             DBGPRINTF ("so=%d eo=%d dolnum=%d", so, eo, dolnum);
1911             if (so>=0 && eo>=so)
1912               obstack_grow (&str_obstack, filnam + so, eo - so);
1913           }
1914         else
1915           {
1916             /* This can happen only when files_rules is buggy! */
1917             gcc_unreachable();
1918           }
1919         /* Always skip the character after the dollar.  */
1920         pt++;
1921       }
1922     else
1923       obstack_1grow (&str_obstack, c);
1924   }
1925   obstack_1grow (&str_obstack, '\0');
1926   rawstr = XOBFINISH (&str_obstack, char *);
1927   str = xstrdup (rawstr);
1928   obstack_free (&str_obstack, rawstr);
1929   DBGPRINTF ("matched replacement %s", str);
1930   rawstr = NULL;
1931   return str;
1932 }
1933
1934
1935 /* An output file, suitable for definitions, that can see declarations
1936    made in INPF and is linked into every language that uses INPF.
1937    Since the the result is cached inside INPF, that argument cannot be
1938    declared constant, but is "almost" constant. */
1939
1940 outf_p
1941 get_output_file_with_visibility (input_file *inpf)
1942 {
1943   outf_p r;
1944   char *for_name = NULL;
1945   char *output_name = NULL;
1946   const char* inpfname;
1947
1948   /* This can happen when we need a file with visibility on a
1949      structure that we've never seen.  We have to just hope that it's
1950      globally visible.  */
1951   if (inpf == NULL)
1952     inpf = system_h_file;
1953
1954   /* The result is cached in INPF, so return it if already known.  */
1955   if (inpf->inpoutf)
1956     return inpf->inpoutf;
1957
1958   /* In plugin mode, return NULL unless the input_file is one of the
1959      plugin_files.  */
1960   if (plugin_files)
1961     {
1962       size_t i;
1963       for (i = 0; i < nb_plugin_files; i++)
1964         if (inpf == plugin_files[i])
1965           {
1966             inpf->inpoutf = plugin_output;
1967             return plugin_output;
1968           }
1969
1970       return NULL;
1971     }
1972
1973   inpfname = get_input_file_name (inpf);
1974
1975   /* Try each rule in sequence in files_rules until one is triggered. */
1976   {
1977     int rulix = 0;
1978     DBGPRINTF ("passing input file @ %p named %s thru the files_rules",
1979                (void*) inpf, inpfname);
1980
1981     for (; files_rules[rulix].frul_srcexpr != NULL; rulix++)
1982       {
1983         DBGPRINTF ("rulix#%d srcexpr %s",
1984                    rulix, files_rules[rulix].frul_srcexpr);
1985
1986         if (!files_rules[rulix].frul_re)
1987           {
1988             /* Compile the regexpr lazily.  */
1989             int err = 0;
1990             files_rules[rulix].frul_re = XCNEW (regex_t);
1991             err = regcomp (files_rules[rulix].frul_re,
1992                            files_rules[rulix].frul_srcexpr,
1993                            files_rules[rulix].frul_rflags);
1994             if (err)
1995               {
1996                 /* The regular expression compilation fails only when
1997                    file_rules is buggy.  */
1998                 gcc_unreachable ();
1999               }
2000           }
2001
2002         output_name = NULL;
2003         for_name = NULL;
2004
2005         /* Match the regexpr and trigger the rule if matched.  */
2006         {
2007           /* We have exactly ten pmatch-s, one for each $0, $1, $2,
2008              $3, ... $9.  */
2009           regmatch_t pmatch[10];
2010           memset (pmatch, 0, sizeof (pmatch));
2011           if (!regexec (files_rules[rulix].frul_re,
2012                         inpfname, 10, pmatch, 0))
2013             {
2014               DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s",
2015                          (void*) inpf, inpfname, rulix,
2016                          files_rules[rulix].frul_srcexpr);
2017               for_name =
2018                 matching_file_name_substitute (inpfname, pmatch,
2019                                                files_rules[rulix].frul_tr_for);
2020               DBGPRINTF ("for_name %s", for_name);
2021               output_name =
2022                 matching_file_name_substitute (inpfname, pmatch,
2023                                                files_rules[rulix].frul_tr_out);
2024               DBGPRINTF ("output_name %s", output_name);
2025               if (files_rules[rulix].frul_action)
2026                 {
2027                   /* Invoke our action routine.  */
2028                   outf_p of = NULL;
2029                   DBGPRINTF ("before action rulix#%d output_name %s for_name %s",
2030                              rulix, output_name, for_name);
2031                   of =
2032                     (files_rules[rulix].frul_action) (inpf,
2033                                                       &output_name, &for_name);
2034                   DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s",
2035                              rulix, (void*)of, output_name, for_name);
2036                   /* If the action routine returned something, give it back
2037                      immediately and cache it in inpf.  */
2038                   if (of)
2039                     {
2040                       inpf->inpoutf = of;
2041                       return of;
2042                     }
2043                 }
2044               /* The rule matched, and had no action, or that action did
2045                  not return any output file but could have changed the
2046                  output_name or for_name.  We break out of the loop on the
2047                  files_rules.  */
2048               break;
2049             }
2050           else
2051             {
2052               /* The regexpr did not match.  */
2053               DBGPRINTF ("rulix#%d did not match %s pattern %s",
2054                          rulix, inpfname, files_rules[rulix].frul_srcexpr);
2055               continue;
2056             }
2057         }
2058       }
2059   }
2060   if (!output_name || !for_name)
2061     {
2062       /* This is impossible, and could only happen if the files_rules is
2063          incomplete or buggy.  */
2064       gcc_unreachable ();
2065     }
2066
2067   /* Look through to see if we've ever seen this output filename
2068      before.  If found, cache the result in inpf.  */
2069   for (r = output_files; r; r = r->next)
2070     if (strcmp (r->name, output_name) == 0)
2071       {
2072         inpf->inpoutf = r;
2073         DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r,
2074                    output_name, for_name);
2075         return r;
2076       }
2077
2078   /* If not found, create it, and cache it in inpf.  */
2079   r = create_file (for_name, output_name);
2080
2081   gcc_assert (r && r->name);
2082   DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r,
2083              output_name, for_name);
2084   inpf->inpoutf = r;
2085   return r;
2086
2087
2088 }
2089
2090 /* The name of an output file, suitable for definitions, that can see
2091    declarations made in INPF and is linked into every language that
2092    uses INPF.  */
2093
2094 const char *
2095 get_output_file_name (input_file* inpf)
2096 {
2097   outf_p o = get_output_file_with_visibility (inpf);
2098   if (o)
2099     return o->name;
2100   return NULL;
2101 }
2102
2103 /* Check if existing file is equal to the in memory buffer. */
2104
2105 static bool
2106 is_file_equal (outf_p of)
2107 {
2108   FILE *newfile = fopen (of->name, "r");
2109   size_t i;
2110   bool equal;
2111   if (newfile == NULL)
2112     return false;
2113
2114   equal = true;
2115   for (i = 0; i < of->bufused; i++)
2116     {
2117       int ch;
2118       ch = fgetc (newfile);
2119       if (ch == EOF || ch != (unsigned char) of->buf[i])
2120         {
2121           equal = false;
2122           break;
2123         }
2124     }
2125   fclose (newfile);
2126   return equal;
2127 }
2128
2129 /* Copy the output to its final destination,
2130    but don't unnecessarily change modification times.  */
2131
2132 static void
2133 close_output_files (void)
2134 {
2135   int nbwrittenfiles = 0;
2136   outf_p of;
2137
2138   for (of = output_files; of; of = of->next)
2139     {
2140
2141       if (!is_file_equal (of))
2142         {
2143           FILE *newfile = NULL;
2144           char *backupname = NULL;
2145           /* Back up the old version of the output file gt-FOO.c as
2146              BACKUPDIR/gt-FOO.c~ if we have a backup directory.  */
2147           if (backup_dir)
2148             {
2149               backupname = concat (backup_dir, "/",
2150                                    lbasename (of->name), "~", NULL);
2151               if (!access (of->name, F_OK) && rename (of->name, backupname))
2152                 fatal ("failed to back up %s as %s: %s",
2153                        of->name, backupname, xstrerror (errno));
2154             }
2155
2156           newfile = fopen (of->name, "w");
2157           if (newfile == NULL)
2158             fatal ("opening output file %s: %s", of->name, xstrerror (errno));
2159           if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
2160             fatal ("writing output file %s: %s", of->name, xstrerror (errno));
2161           if (fclose (newfile) != 0)
2162             fatal ("closing output file %s: %s", of->name, xstrerror (errno));
2163           nbwrittenfiles++;
2164           if (verbosity_level >= 2 && backupname)
2165             printf ("%s wrote #%-3d %s backed-up in %s\n",
2166                     progname, nbwrittenfiles, of->name, backupname);
2167           else if (verbosity_level >= 1)
2168             printf ("%s write #%-3d %s\n", progname, nbwrittenfiles, of->name);
2169           free (backupname);
2170         }
2171       else
2172         {
2173           /* output file remains unchanged. */
2174           if (verbosity_level >= 2)
2175             printf ("%s keep %s\n", progname, of->name);
2176         }
2177       free (of->buf);
2178       of->buf = NULL;
2179       of->bufused = of->buflength = 0;
2180     }
2181   if (verbosity_level >= 1)
2182     printf ("%s wrote %d files.\n", progname, nbwrittenfiles);
2183 }
2184 \f
2185 struct flist
2186 {
2187   struct flist *next;
2188   int started_p;
2189   const input_file* file;
2190   outf_p f;
2191 };
2192
2193 struct walk_type_data;
2194
2195 /* For scalars and strings, given the item in 'val'.
2196    For structures, given a pointer to the item in 'val'.
2197    For misc. pointers, given the item in 'val'.
2198 */
2199 typedef void (*process_field_fn) (type_p f, const struct walk_type_data * p);
2200 typedef void (*func_name_fn) (type_p s, const struct walk_type_data * p);
2201
2202 /* Parameters for write_types.  */
2203
2204 struct write_types_data
2205 {
2206   const char *prefix;
2207   const char *param_prefix;
2208   const char *subfield_marker_routine;
2209   const char *marker_routine;
2210   const char *reorder_note_routine;
2211   const char *comment;
2212   int skip_hooks;               /* skip hook generation if non zero */
2213 };
2214
2215 static void output_escaped_param (struct walk_type_data *d,
2216                                   const char *, const char *);
2217 static void output_mangled_typename (outf_p, const_type_p);
2218 static void walk_type (type_p t, struct walk_type_data *d);
2219 static void write_func_for_structure (type_p orig_s, type_p s, type_p *param,
2220                                       const struct write_types_data *wtd);
2221 static void write_types_process_field
2222   (type_p f, const struct walk_type_data *d);
2223 static void write_types (outf_p output_header,
2224                          type_p structures,
2225                          type_p param_structs,
2226                          const struct write_types_data *wtd);
2227 static void write_types_local_process_field
2228   (type_p f, const struct walk_type_data *d);
2229 static void write_local_func_for_structure
2230   (const_type_p orig_s, type_p s, type_p *param);
2231 static void write_local (outf_p output_header,
2232                          type_p structures, type_p param_structs);
2233 static void write_enum_defn (type_p structures, type_p param_structs);
2234 static int contains_scalar_p (type_p t);
2235 static void put_mangled_filename (outf_p, const input_file *);
2236 static void finish_root_table (struct flist *flp, const char *pfx,
2237                                const char *tname, const char *lastname,
2238                                const char *name);
2239 static void write_root (outf_p, pair_p, type_p, const char *, int,
2240                         struct fileloc *, const char *, bool);
2241 static void write_array (outf_p f, pair_p v,
2242                          const struct write_types_data *wtd);
2243 static void write_roots (pair_p, bool);
2244
2245 /* Parameters for walk_type.  */
2246
2247 struct walk_type_data
2248 {
2249   process_field_fn process_field;
2250   const void *cookie;
2251   outf_p of;
2252   options_p opt;
2253   const char *val;
2254   const char *prev_val[4];
2255   int indent;
2256   int counter;
2257   const struct fileloc *line;
2258   lang_bitmap bitmap;
2259   type_p *param;
2260   int used_length;
2261   type_p orig_s;
2262   const char *reorder_fn;
2263   bool needs_cast_p;
2264   bool fn_wants_lvalue;
2265 };
2266
2267 /* Print a mangled name representing T to OF.  */
2268
2269 static void
2270 output_mangled_typename (outf_p of, const_type_p t)
2271 {
2272   if (t == NULL)
2273     oprintf (of, "Z");
2274   else
2275     switch (t->kind)
2276       {
2277       case TYPE_NONE:
2278         gcc_unreachable ();
2279         break;
2280       case TYPE_POINTER:
2281         oprintf (of, "P");
2282         output_mangled_typename (of, t->u.p);
2283         break;
2284       case TYPE_SCALAR:
2285         oprintf (of, "I");
2286         break;
2287       case TYPE_STRING:
2288         oprintf (of, "S");
2289         break;
2290       case TYPE_STRUCT:
2291       case TYPE_UNION:
2292       case TYPE_LANG_STRUCT:
2293         oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag),
2294                  t->u.s.tag);
2295         break;
2296       case TYPE_PARAM_STRUCT:
2297         {
2298           int i;
2299           for (i = 0; i < NUM_PARAM; i++)
2300             if (t->u.param_struct.param[i] != NULL)
2301               output_mangled_typename (of, t->u.param_struct.param[i]);
2302           output_mangled_typename (of, t->u.param_struct.stru);
2303         }
2304         break;
2305       case TYPE_ARRAY:
2306         gcc_unreachable ();
2307       }
2308 }
2309
2310 /* Print PARAM to D->OF processing escapes.  D->VAL references the
2311    current object, D->PREV_VAL the object containing the current
2312    object, ONAME is the name of the option and D->LINE is used to
2313    print error messages.  */
2314
2315 static void
2316 output_escaped_param (struct walk_type_data *d, const char *param,
2317                       const char *oname)
2318 {
2319   const char *p;
2320
2321   for (p = param; *p; p++)
2322     if (*p != '%')
2323       oprintf (d->of, "%c", *p);
2324     else
2325       switch (*++p)
2326         {
2327         case 'h':
2328           oprintf (d->of, "(%s)", d->prev_val[2]);
2329           break;
2330         case '0':
2331           oprintf (d->of, "(%s)", d->prev_val[0]);
2332           break;
2333         case '1':
2334           oprintf (d->of, "(%s)", d->prev_val[1]);
2335           break;
2336         case 'a':
2337           {
2338             const char *pp = d->val + strlen (d->val);
2339             while (pp[-1] == ']')
2340               while (*pp != '[')
2341                 pp--;
2342             oprintf (d->of, "%s", pp);
2343           }
2344           break;
2345         default:
2346           error_at_line (d->line, "`%s' option contains bad escape %c%c",
2347                          oname, '%', *p);
2348         }
2349 }
2350
2351 /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
2352    which is of type T.  Write code to D->OF to constrain execution (at
2353    the point that D->PROCESS_FIELD is called) to the appropriate
2354    cases.  Call D->PROCESS_FIELD on subobjects before calling it on
2355    pointers to those objects.  D->PREV_VAL lists the objects
2356    containing the current object, D->OPT is a list of options to
2357    apply, D->INDENT is the current indentation level, D->LINE is used
2358    to print error messages, D->BITMAP indicates which languages to
2359    print the structure for, and D->PARAM is the current parameter
2360    (from an enclosing param_is option).  */
2361
2362 static void
2363 walk_type (type_p t, struct walk_type_data *d)
2364 {
2365   const char *length = NULL;
2366   const char *desc = NULL;
2367   int maybe_undef_p = 0;
2368   int use_param_num = -1;
2369   int use_params_p = 0;
2370   options_p oo;
2371   const struct nested_ptr_data *nested_ptr_d = NULL;
2372
2373   d->needs_cast_p = false;
2374   for (oo = d->opt; oo; oo = oo->next)
2375     if (strcmp (oo->name, "length") == 0 && oo->kind == OPTION_STRING)
2376       length = oo->info.string;
2377     else if (strcmp (oo->name, "maybe_undef") == 0)
2378       maybe_undef_p = 1;
2379     else if (strncmp (oo->name, "use_param", 9) == 0
2380              && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
2381       use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0';
2382     else if (strcmp (oo->name, "use_params") == 0)
2383       use_params_p = 1;
2384     else if (strcmp (oo->name, "desc") == 0 && oo->kind == OPTION_STRING)
2385       desc = oo->info.string;
2386     else if (strcmp (oo->name, "mark_hook") == 0)
2387       ;
2388     else if (strcmp (oo->name, "nested_ptr") == 0
2389              && oo->kind == OPTION_NESTED)
2390       nested_ptr_d = (const struct nested_ptr_data *) oo->info.nested;
2391     else if (strcmp (oo->name, "dot") == 0)
2392       ;
2393     else if (strcmp (oo->name, "tag") == 0)
2394       ;
2395     else if (strcmp (oo->name, "special") == 0)
2396       ;
2397     else if (strcmp (oo->name, "skip") == 0)
2398       ;
2399     else if (strcmp (oo->name, "default") == 0)
2400       ;
2401     else if (strcmp (oo->name, "param_is") == 0)
2402       ;
2403     else if (strncmp (oo->name, "param", 5) == 0
2404              && ISDIGIT (oo->name[5]) && strcmp (oo->name + 6, "_is") == 0)
2405       ;
2406     else if (strcmp (oo->name, "chain_next") == 0)
2407       ;
2408     else if (strcmp (oo->name, "chain_prev") == 0)
2409       ;
2410     else if (strcmp (oo->name, "chain_circular") == 0)
2411       ;
2412     else if (strcmp (oo->name, "reorder") == 0)
2413       ;
2414     else if (strcmp (oo->name, "variable_size") == 0)
2415       ;
2416     else
2417       error_at_line (d->line, "unknown option `%s'\n", oo->name);
2418
2419   if (d->used_length)
2420     length = NULL;
2421
2422   if (use_params_p)
2423     {
2424       int pointer_p = t->kind == TYPE_POINTER;
2425
2426       if (pointer_p)
2427         t = t->u.p;
2428       if (!UNION_OR_STRUCT_P (t))
2429         error_at_line (d->line, "`use_params' option on unimplemented type");
2430       else
2431         t = find_param_structure (t, d->param);
2432       if (pointer_p)
2433         t = create_pointer (t);
2434     }
2435
2436   if (use_param_num != -1)
2437     {
2438       if (d->param != NULL && d->param[use_param_num] != NULL)
2439         {
2440           type_p nt = d->param[use_param_num];
2441
2442           if (t->kind == TYPE_ARRAY)
2443             nt = create_array (nt, t->u.a.len);
2444           else if (length != NULL && t->kind == TYPE_POINTER)
2445             nt = create_pointer (nt);
2446           d->needs_cast_p = (t->kind != TYPE_POINTER
2447                              && (nt->kind == TYPE_POINTER
2448                                  || nt->kind == TYPE_STRING));
2449           t = nt;
2450         }
2451       else
2452         error_at_line (d->line, "no parameter defined for `%s'", d->val);
2453     }
2454
2455   if (maybe_undef_p
2456       && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p)))
2457     {
2458       error_at_line (d->line,
2459                      "field `%s' has invalid option `maybe_undef_p'\n",
2460                      d->val);
2461       return;
2462     }
2463
2464   switch (t->kind)
2465     {
2466     case TYPE_SCALAR:
2467     case TYPE_STRING:
2468       d->process_field (t, d);
2469       break;
2470
2471     case TYPE_POINTER:
2472       {
2473         if (maybe_undef_p && t->u.p->u.s.line.file == NULL)
2474           {
2475             oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val);
2476             break;
2477           }
2478
2479         if (!length)
2480           {
2481             if (!UNION_OR_STRUCT_P (t->u.p)
2482                 && t->u.p->kind != TYPE_PARAM_STRUCT)
2483               {
2484                 error_at_line (d->line,
2485                                "field `%s' is pointer to unimplemented type",
2486                                d->val);
2487                 break;
2488               }
2489
2490             if (nested_ptr_d)
2491               {
2492                 const char *oldprevval2 = d->prev_val[2];
2493
2494                 if (!UNION_OR_STRUCT_P (nested_ptr_d->type))
2495                   {
2496                     error_at_line (d->line,
2497                                    "field `%s' has invalid "
2498                                    "option `nested_ptr'\n", d->val);
2499                     return;
2500                   }
2501
2502                 d->prev_val[2] = d->val;
2503                 oprintf (d->of, "%*s{\n", d->indent, "");
2504                 d->indent += 2;
2505                 d->val = xasprintf ("x%d", d->counter++);
2506                 oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "",
2507                          (nested_ptr_d->type->kind == TYPE_UNION
2508                           ? "union" : "struct"),
2509                          nested_ptr_d->type->u.s.tag,
2510                          d->fn_wants_lvalue ? "" : "const ", d->val);
2511                 oprintf (d->of, "%*s", d->indent + 2, "");
2512                 output_escaped_param (d, nested_ptr_d->convert_from,
2513                                       "nested_ptr");
2514                 oprintf (d->of, ";\n");
2515
2516                 d->process_field (nested_ptr_d->type, d);
2517
2518                 if (d->fn_wants_lvalue)
2519                   {
2520                     oprintf (d->of, "%*s%s = ", d->indent, "",
2521                              d->prev_val[2]);
2522                     d->prev_val[2] = d->val;
2523                     output_escaped_param (d, nested_ptr_d->convert_to,
2524                                           "nested_ptr");
2525                     oprintf (d->of, ";\n");
2526                   }
2527
2528                 d->indent -= 2;
2529                 oprintf (d->of, "%*s}\n", d->indent, "");
2530                 d->val = d->prev_val[2];
2531                 d->prev_val[2] = oldprevval2;
2532               }
2533             else
2534               d->process_field (t->u.p, d);
2535           }
2536         else
2537           {
2538             int loopcounter = d->counter++;
2539             const char *oldval = d->val;
2540             const char *oldprevval3 = d->prev_val[3];
2541             char *newval;
2542
2543             oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
2544             d->indent += 2;
2545             oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2546             oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent,
2547                      "", loopcounter, loopcounter);
2548             output_escaped_param (d, length, "length");
2549             oprintf (d->of, "); i%d++) {\n", loopcounter);
2550             d->indent += 2;
2551             d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2552             d->used_length = 1;
2553             d->prev_val[3] = oldval;
2554             walk_type (t->u.p, d);
2555             free (newval);
2556             d->val = oldval;
2557             d->prev_val[3] = oldprevval3;
2558             d->used_length = 0;
2559             d->indent -= 2;
2560             oprintf (d->of, "%*s}\n", d->indent, "");
2561             d->process_field (t, d);
2562             d->indent -= 2;
2563             oprintf (d->of, "%*s}\n", d->indent, "");
2564           }
2565       }
2566       break;
2567
2568     case TYPE_ARRAY:
2569       {
2570         int loopcounter = d->counter++;
2571         const char *oldval = d->val;
2572         char *newval;
2573
2574         /* If it's an array of scalars, we optimize by not generating
2575            any code.  */
2576         if (t->u.a.p->kind == TYPE_SCALAR)
2577           break;
2578
2579         /* When walking an array, compute the length and store it in a
2580            local variable before walking the array elements, instead of
2581            recomputing the length expression each time through the loop.
2582            This is necessary to handle tcc_vl_exp objects like CALL_EXPR,
2583            where the length is stored in the first array element,
2584            because otherwise that operand can get overwritten on the
2585            first iteration.  */
2586         oprintf (d->of, "%*s{\n", d->indent, "");
2587         d->indent += 2;
2588         oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
2589         oprintf (d->of, "%*ssize_t l%d = (size_t)(",
2590                  d->indent, "", loopcounter);
2591         if (length)
2592           output_escaped_param (d, length, "length");
2593         else
2594           oprintf (d->of, "%s", t->u.a.len);
2595         oprintf (d->of, ");\n");
2596
2597         oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
2598                  d->indent, "",
2599                  loopcounter, loopcounter, loopcounter, loopcounter);
2600         d->indent += 2;
2601         d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter);
2602         d->used_length = 1;
2603         walk_type (t->u.a.p, d);
2604         free (newval);
2605         d->used_length = 0;
2606         d->val = oldval;
2607         d->indent -= 2;
2608         oprintf (d->of, "%*s}\n", d->indent, "");
2609         d->indent -= 2;
2610         oprintf (d->of, "%*s}\n", d->indent, "");
2611       }
2612       break;
2613
2614     case TYPE_STRUCT:
2615     case TYPE_UNION:
2616       {
2617         pair_p f;
2618         const char *oldval = d->val;
2619         const char *oldprevval1 = d->prev_val[1];
2620         const char *oldprevval2 = d->prev_val[2];
2621         const int union_p = t->kind == TYPE_UNION;
2622         int seen_default_p = 0;
2623         options_p o;
2624
2625         if (!t->u.s.line.file)
2626           error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag);
2627
2628         if ((d->bitmap & t->u.s.bitmap) != d->bitmap)
2629           {
2630             error_at_line (d->line,
2631                            "structure `%s' defined for mismatching languages",
2632                            t->u.s.tag);
2633             error_at_line (&t->u.s.line, "one structure defined here");
2634           }
2635
2636         /* Some things may also be defined in the structure's options.  */
2637         for (o = t->u.s.opt; o; o = o->next)
2638           if (!desc && strcmp (o->name, "desc") == 0
2639               && o->kind == OPTION_STRING)
2640             desc = o->info.string;
2641
2642         d->prev_val[2] = oldval;
2643         d->prev_val[1] = oldprevval2;
2644         if (union_p)
2645           {
2646             if (desc == NULL)
2647               {
2648                 error_at_line (d->line,
2649                                "missing `desc' option for union `%s'",
2650                                t->u.s.tag);
2651                 desc = "1";
2652               }
2653             oprintf (d->of, "%*sswitch (", d->indent, "");
2654             output_escaped_param (d, desc, "desc");
2655             oprintf (d->of, ")\n");
2656             d->indent += 2;
2657             oprintf (d->of, "%*s{\n", d->indent, "");
2658           }
2659         for (f = t->u.s.fields; f; f = f->next)
2660           {
2661             options_p oo;
2662             const char *dot = ".";
2663             const char *tagid = NULL;
2664             int skip_p = 0;
2665             int default_p = 0;
2666             int use_param_p = 0;
2667             char *newval;
2668
2669             d->reorder_fn = NULL;
2670             for (oo = f->opt; oo; oo = oo->next)
2671               if (strcmp (oo->name, "dot") == 0
2672                   && oo->kind == OPTION_STRING)
2673                 dot = oo->info.string;
2674               else if (strcmp (oo->name, "tag") == 0
2675                        && oo->kind == OPTION_STRING)
2676                 tagid = oo->info.string;
2677               else if (strcmp (oo->name, "skip") == 0)
2678                 skip_p = 1;
2679               else if (strcmp (oo->name, "default") == 0)
2680                 default_p = 1;
2681               else if (strcmp (oo->name, "reorder") == 0
2682                   && oo->kind == OPTION_STRING)
2683                 d->reorder_fn = oo->info.string;
2684               else if (strncmp (oo->name, "use_param", 9) == 0
2685                        && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
2686                 use_param_p = 1;
2687
2688             if (skip_p)
2689               continue;
2690
2691             if (union_p && tagid)
2692               {
2693                 oprintf (d->of, "%*scase %s:\n", d->indent, "", tagid);
2694                 d->indent += 2;
2695               }
2696             else if (union_p && default_p)
2697               {
2698                 oprintf (d->of, "%*sdefault:\n", d->indent, "");
2699                 d->indent += 2;
2700                 seen_default_p = 1;
2701               }
2702             else if (!union_p && (default_p || tagid))
2703               error_at_line (d->line,
2704                              "can't use `%s' outside a union on field `%s'",
2705                              default_p ? "default" : "tag", f->name);
2706             else if (union_p && !(default_p || tagid)
2707                      && f->type->kind == TYPE_SCALAR)
2708               {
2709                 fprintf (stderr,
2710                          "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
2711                          get_input_file_name (d->line->file), d->line->line,
2712                          f->name);
2713                 continue;
2714               }
2715             else if (union_p && !(default_p || tagid))
2716               error_at_line (d->line,
2717                              "field `%s' is missing `tag' or `default' option",
2718                              f->name);
2719
2720             d->line = &f->line;
2721             d->val = newval = xasprintf ("%s%s%s", oldval, dot, f->name);
2722             d->opt = f->opt;
2723             d->used_length = false;
2724
2725             if (union_p && use_param_p && d->param == NULL)
2726               oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, "");
2727             else
2728               walk_type (f->type, d);
2729
2730             free (newval);
2731
2732             if (union_p)
2733               {
2734                 oprintf (d->of, "%*sbreak;\n", d->indent, "");
2735                 d->indent -= 2;
2736               }
2737           }
2738         d->reorder_fn = NULL;
2739
2740         d->val = oldval;
2741         d->prev_val[1] = oldprevval1;
2742         d->prev_val[2] = oldprevval2;
2743
2744         if (union_p && !seen_default_p)
2745           {
2746             oprintf (d->of, "%*sdefault:\n", d->indent, "");
2747             oprintf (d->of, "%*s  break;\n", d->indent, "");
2748           }
2749         if (union_p)
2750           {
2751             oprintf (d->of, "%*s}\n", d->indent, "");
2752             d->indent -= 2;
2753           }
2754       }
2755       break;
2756
2757     case TYPE_LANG_STRUCT:
2758       {
2759         type_p nt;
2760         for (nt = t->u.s.lang_struct; nt; nt = nt->next)
2761           if ((d->bitmap & nt->u.s.bitmap) == d->bitmap)
2762             break;
2763         if (nt == NULL)
2764           error_at_line (d->line, "structure `%s' differs between languages",
2765                          t->u.s.tag);
2766         else
2767           walk_type (nt, d);
2768       }
2769       break;
2770
2771     case TYPE_PARAM_STRUCT:
2772       {
2773         type_p *oldparam = d->param;
2774
2775         d->param = t->u.param_struct.param;
2776         walk_type (t->u.param_struct.stru, d);
2777         d->param = oldparam;
2778       }
2779       break;
2780
2781     default:
2782       gcc_unreachable ();
2783     }
2784 }
2785
2786 /* process_field routine for marking routines.  */
2787
2788 static void
2789 write_types_process_field (type_p f, const struct walk_type_data *d)
2790 {
2791   const struct write_types_data *wtd;
2792   const char *cast = d->needs_cast_p ? "(void *)" : "";
2793   wtd = (const struct write_types_data *) d->cookie;
2794
2795   switch (f->kind)
2796     {
2797     case TYPE_NONE:
2798       gcc_unreachable ();
2799     case TYPE_POINTER:
2800       oprintf (d->of, "%*s%s (%s%s", d->indent, "",
2801                wtd->subfield_marker_routine, cast, d->val);
2802       if (wtd->param_prefix)
2803         {
2804           oprintf (d->of, ", %s", d->prev_val[3]);
2805           if (d->orig_s)
2806             {
2807               oprintf (d->of, ", gt_%s_", wtd->param_prefix);
2808               output_mangled_typename (d->of, d->orig_s);
2809             }
2810           else
2811             oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]);
2812
2813           if (f->u.p->kind == TYPE_PARAM_STRUCT
2814               && f->u.p->u.s.line.file != NULL)
2815             {
2816               oprintf (d->of, ", gt_e_");
2817               output_mangled_typename (d->of, f);
2818             }
2819           else if (UNION_OR_STRUCT_P (f) && f->u.p->u.s.line.file != NULL)
2820             {
2821               oprintf (d->of, ", gt_ggc_e_");
2822               output_mangled_typename (d->of, f);
2823             }
2824           else
2825             oprintf (d->of, ", gt_types_enum_last");
2826         }
2827       oprintf (d->of, ");\n");
2828       if (d->reorder_fn && wtd->reorder_note_routine)
2829         oprintf (d->of, "%*s%s (%s%s, %s, %s);\n", d->indent, "",
2830                  wtd->reorder_note_routine, cast, d->val,
2831                  d->prev_val[3], d->reorder_fn);
2832       break;
2833
2834     case TYPE_STRING:
2835     case TYPE_STRUCT:
2836     case TYPE_UNION:
2837     case TYPE_LANG_STRUCT:
2838     case TYPE_PARAM_STRUCT:
2839       oprintf (d->of, "%*sgt_%s_", d->indent, "", wtd->prefix);
2840       output_mangled_typename (d->of, f);
2841       oprintf (d->of, " (%s%s);\n", cast, d->val);
2842       if (d->reorder_fn && wtd->reorder_note_routine)
2843         oprintf (d->of, "%*s%s (%s%s, %s%s, %s);\n", d->indent, "",
2844                  wtd->reorder_note_routine, cast, d->val, cast, d->val,
2845                  d->reorder_fn);
2846       break;
2847
2848     case TYPE_SCALAR:
2849       break;
2850
2851     case TYPE_ARRAY:
2852       gcc_unreachable ();
2853     }
2854 }
2855
2856 /* A subroutine of write_func_for_structure.  Write the enum tag for S.  */
2857
2858 static void
2859 output_type_enum (outf_p of, type_p s)
2860 {
2861   if (s->kind == TYPE_PARAM_STRUCT && s->u.param_struct.line.file != NULL)
2862     {
2863       oprintf (of, ", gt_e_");
2864       output_mangled_typename (of, s);
2865     }
2866   else if (UNION_OR_STRUCT_P (s) && s->u.s.line.file != NULL)
2867     {
2868       oprintf (of, ", gt_ggc_e_");
2869       output_mangled_typename (of, s);
2870     }
2871   else
2872     oprintf (of, ", gt_types_enum_last");
2873 }
2874
2875 /* Return an output file that is suitable for definitions which can
2876    reference struct S */
2877
2878 static outf_p
2879 get_output_file_for_structure (const_type_p s, type_p *param)
2880 {
2881   const input_file *fn;
2882   int i;
2883
2884   gcc_assert (UNION_OR_STRUCT_P (s));
2885   fn = s->u.s.line.file;
2886
2887   /* This is a hack, and not the good kind either.  */
2888   for (i = NUM_PARAM - 1; i >= 0; i--)
2889     if (param && param[i] && param[i]->kind == TYPE_POINTER
2890         && UNION_OR_STRUCT_P (param[i]->u.p))
2891       fn = param[i]->u.p->u.s.line.file;
2892
2893   /* The call to get_output_file_with_visibility may update fn by
2894      caching its result inside, so we need the CONST_CAST.  */
2895   return get_output_file_with_visibility (CONST_CAST (input_file*, fn));
2896 }
2897
2898 /* For S, a structure that's part of ORIG_S, and using parameters
2899    PARAM, write out a routine that:
2900    - Takes a parameter, a void * but actually of type *S
2901    - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
2902    field of S or its substructures and (in some cases) things
2903    that are pointed to by S.
2904 */
2905
2906 static void
2907 write_func_for_structure (type_p orig_s, type_p s, type_p *param,
2908                           const struct write_types_data *wtd)
2909 {
2910   const char *chain_next = NULL;
2911   const char *chain_prev = NULL;
2912   const char *chain_circular = NULL;
2913   const char *mark_hook_name = NULL;
2914   options_p opt;
2915   struct walk_type_data d;
2916
2917   memset (&d, 0, sizeof (d));
2918   d.of = get_output_file_for_structure (s, param);
2919   for (opt = s->u.s.opt; opt; opt = opt->next)
2920     if (strcmp (opt->name, "chain_next") == 0
2921         && opt->kind == OPTION_STRING)
2922       chain_next = opt->info.string;
2923     else if (strcmp (opt->name, "chain_prev") == 0
2924              && opt->kind == OPTION_STRING)
2925       chain_prev = opt->info.string;
2926     else if (strcmp (opt->name, "chain_circular") == 0
2927              && opt->kind == OPTION_STRING)
2928       chain_circular = opt->info.string;
2929     else if (strcmp (opt->name, "mark_hook") == 0
2930              && opt->kind == OPTION_STRING)
2931       mark_hook_name = opt->info.string;
2932   if (chain_prev != NULL && chain_next == NULL)
2933     error_at_line (&s->u.s.line, "chain_prev without chain_next");
2934   if (chain_circular != NULL && chain_next != NULL)
2935     error_at_line (&s->u.s.line, "chain_circular with chain_next");
2936   if (chain_circular != NULL)
2937     chain_next = chain_circular;
2938
2939   d.process_field = write_types_process_field;
2940   d.cookie = wtd;
2941   d.orig_s = orig_s;
2942   d.opt = s->u.s.opt;
2943   d.line = &s->u.s.line;
2944   d.bitmap = s->u.s.bitmap;
2945   d.param = param;
2946   d.prev_val[0] = "*x";
2947   d.prev_val[1] = "not valid postage";  /* Guarantee an error.  */
2948   d.prev_val[3] = "x";
2949   d.val = "(*x)";
2950
2951   oprintf (d.of, "\n");
2952   oprintf (d.of, "void\n");
2953   if (param == NULL)
2954     oprintf (d.of, "gt_%sx_%s", wtd->prefix, orig_s->u.s.tag);
2955   else
2956     {
2957       oprintf (d.of, "gt_%s_", wtd->prefix);
2958       output_mangled_typename (d.of, orig_s);
2959     }
2960   oprintf (d.of, " (void *x_p)\n");
2961   oprintf (d.of, "{\n");
2962   oprintf (d.of, "  %s %s * %sx = (%s %s *)x_p;\n",
2963            s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
2964            chain_next == NULL ? "const " : "",
2965            s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2966   if (chain_next != NULL)
2967     oprintf (d.of, "  %s %s * xlimit = x;\n",
2968              s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
2969   if (chain_next == NULL)
2970     {
2971       oprintf (d.of, "  if (%s (x", wtd->marker_routine);
2972       if (wtd->param_prefix)
2973         {
2974           oprintf (d.of, ", x, gt_%s_", wtd->param_prefix);
2975           output_mangled_typename (d.of, orig_s);
2976           output_type_enum (d.of, orig_s);
2977         }
2978       oprintf (d.of, "))\n");
2979     }
2980   else
2981     {
2982       if (chain_circular != NULL)
2983         oprintf (d.of, "  if (!%s (xlimit", wtd->marker_routine);
2984       else
2985         oprintf (d.of, "  while (%s (xlimit", wtd->marker_routine);
2986       if (wtd->param_prefix)
2987         {
2988           oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
2989           output_mangled_typename (d.of, orig_s);
2990           output_type_enum (d.of, orig_s);
2991         }
2992       oprintf (d.of, "))\n");
2993       if (chain_circular != NULL)
2994         oprintf (d.of, "    return;\n  do\n");
2995       if (mark_hook_name && !wtd->skip_hooks)
2996         {
2997           oprintf (d.of, "    {\n");
2998           oprintf (d.of, "      %s (xlimit);\n   ", mark_hook_name);
2999         }
3000       oprintf (d.of, "   xlimit = (");
3001       d.prev_val[2] = "*xlimit";
3002       output_escaped_param (&d, chain_next, "chain_next");
3003       oprintf (d.of, ");\n");
3004       if (mark_hook_name && !wtd->skip_hooks)
3005         oprintf (d.of, "    }\n");
3006       if (chain_prev != NULL)
3007         {
3008           oprintf (d.of, "  if (x != xlimit)\n");
3009           oprintf (d.of, "    for (;;)\n");
3010           oprintf (d.of, "      {\n");
3011           oprintf (d.of, "        %s %s * const xprev = (",
3012                    s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
3013
3014           d.prev_val[2] = "*x";
3015           output_escaped_param (&d, chain_prev, "chain_prev");
3016           oprintf (d.of, ");\n");
3017           oprintf (d.of, "        if (xprev == NULL) break;\n");
3018           oprintf (d.of, "        x = xprev;\n");
3019           oprintf (d.of, "        (void) %s (xprev", wtd->marker_routine);
3020           if (wtd->param_prefix)
3021             {
3022               oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix);
3023               output_mangled_typename (d.of, orig_s);
3024               output_type_enum (d.of, orig_s);
3025             }
3026           oprintf (d.of, ");\n");
3027           oprintf (d.of, "      }\n");
3028         }
3029       if (chain_circular != NULL)
3030         {
3031           oprintf (d.of, "  while (%s (xlimit", wtd->marker_routine);
3032           if (wtd->param_prefix)
3033             {
3034               oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix);
3035               output_mangled_typename (d.of, orig_s);
3036               output_type_enum (d.of, orig_s);
3037             }
3038           oprintf (d.of, "));\n");
3039           if (mark_hook_name && !wtd->skip_hooks)
3040             oprintf (d.of, "  %s (xlimit);\n", mark_hook_name);
3041           oprintf (d.of, "  do\n");
3042         }
3043       else
3044         oprintf (d.of, "  while (x != xlimit)\n");
3045     }
3046   oprintf (d.of, "    {\n");
3047   if (mark_hook_name && chain_next == NULL && !wtd->skip_hooks)
3048     {
3049       oprintf (d.of, "      %s (x);\n", mark_hook_name);
3050     }
3051   d.prev_val[2] = "*x";
3052   d.indent = 6;
3053   walk_type (s, &d);
3054
3055   if (chain_next != NULL)
3056     {
3057       oprintf (d.of, "      x = (");
3058       output_escaped_param (&d, chain_next, "chain_next");
3059       oprintf (d.of, ");\n");
3060     }
3061
3062   oprintf (d.of, "    }\n");
3063   if (chain_circular != NULL)
3064     oprintf (d.of, "  while (x != xlimit);\n");
3065   oprintf (d.of, "}\n");
3066 }
3067
3068 /* Write out marker routines for STRUCTURES and PARAM_STRUCTS.  */
3069
3070 static void
3071 write_types (outf_p output_header, type_p structures, type_p param_structs,
3072              const struct write_types_data *wtd)
3073 {
3074   int nbfun = 0;                /* Count the emitted functions.  */
3075   type_p s;
3076
3077   oprintf (output_header, "\n/* %s*/\n", wtd->comment);
3078   /* We first emit the macros and the declarations. Functions' code is
3079      emitted afterwards.  This is needed in plugin mode.  */
3080   oprintf (output_header, "/* macros and declarations */\n");
3081   for (s = structures; s; s = s->next)
3082     if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
3083       {
3084         options_p opt;
3085
3086         if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL)
3087           continue;
3088
3089         oprintf (output_header, "#define gt_%s_", wtd->prefix);
3090         output_mangled_typename (output_header, s);
3091         oprintf (output_header, "(X) do { \\\n");
3092         oprintf (output_header,
3093                  "  if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix,
3094                  s->u.s.tag);
3095         oprintf (output_header, "  } while (0)\n");
3096
3097         for (opt = s->u.s.opt; opt; opt = opt->next)
3098           if (strcmp (opt->name, "ptr_alias") == 0
3099               && opt->kind == OPTION_TYPE)
3100             {
3101               const_type_p const t = (const_type_p) opt->info.type;
3102               if (t->kind == TYPE_STRUCT
3103                   || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT)
3104                 oprintf (output_header,
3105                          "#define gt_%sx_%s gt_%sx_%s\n",
3106                          wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag);
3107               else
3108                 error_at_line (&s->u.s.line,
3109                                "structure alias is not a structure");
3110               break;
3111             }
3112         if (opt)
3113           continue;
3114
3115         /* Declare the marker procedure only once.  */
3116         oprintf (output_header,
3117                  "extern void gt_%sx_%s (void *);\n",
3118                  wtd->prefix, s->u.s.tag);
3119
3120         if (s->u.s.line.file == NULL)
3121           {
3122             fprintf (stderr, "warning: structure `%s' used but not defined\n",
3123                      s->u.s.tag);
3124             continue;
3125           }
3126       }
3127
3128   for (s = param_structs; s; s = s->next)
3129     if (s->gc_used == GC_POINTED_TO)
3130       {
3131         type_p stru = s->u.param_struct.stru;
3132
3133         /* Declare the marker procedure.  */
3134         oprintf (output_header, "extern void gt_%s_", wtd->prefix);
3135         output_mangled_typename (output_header, s);
3136         oprintf (output_header, " (void *);\n");
3137
3138         if (stru->u.s.line.file == NULL)
3139           {
3140             fprintf (stderr, "warning: structure `%s' used but not defined\n",
3141                      s->u.s.tag);
3142             continue;
3143           }
3144       }
3145
3146   /* At last we emit the functions code.  */
3147   oprintf (output_header, "\n/* functions code */\n");
3148   for (s = structures; s; s = s->next)
3149     if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
3150       {
3151         options_p opt;
3152
3153         if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL)
3154           continue;
3155         for (opt = s->u.s.opt; opt; opt = opt->next)
3156           if (strcmp (opt->name, "ptr_alias") == 0)
3157             break;
3158         if (opt)
3159           continue;
3160
3161         if (s->kind == TYPE_LANG_STRUCT)
3162           {
3163             type_p ss;
3164             for (ss = s->u.s.lang_struct; ss; ss = ss->next)
3165               {
3166                 nbfun++;
3167                 DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
3168                            nbfun, (void*) ss, ss->u.s.tag);
3169                 write_func_for_structure (s, ss, NULL, wtd);
3170               }
3171           }
3172         else
3173           {
3174             nbfun++;
3175             DBGPRINTF ("writing func #%d struct s @ %p '%s'",
3176                        nbfun, (void*) s, s->u.s.tag);
3177             write_func_for_structure (s, s, NULL, wtd);
3178           }
3179       }
3180     else
3181       {
3182         /* Structure s is not possibly pointed to, so can be ignored.  */
3183         DBGPRINTF ("ignored s @ %p  '%s' gc_used#%d",
3184                    (void*)s,  s->u.s.tag,
3185                    (int) s->gc_used);
3186       }
3187
3188   for (s = param_structs; s; s = s->next)
3189     if (s->gc_used == GC_POINTED_TO)
3190       {
3191         type_p *param = s->u.param_struct.param;
3192         type_p stru = s->u.param_struct.stru;
3193         if (stru->u.s.line.file == NULL)
3194           continue;
3195         if (stru->kind == TYPE_LANG_STRUCT)
3196           {
3197             type_p ss;
3198             for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
3199               {
3200                 nbfun++;
3201                 DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'",
3202                            nbfun, (void*) ss,  ss->u.s.tag);
3203                 write_func_for_structure (s, ss, param, wtd);
3204               }
3205           }
3206         else
3207           {
3208             nbfun++;
3209             DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'",
3210                        nbfun, (void*) s,
3211                        (void*) stru,  stru->u.s.tag);
3212             write_func_for_structure (s, stru, param, wtd);
3213           }
3214       }
3215     else
3216       {
3217         /* Param structure s is not pointed to, so should be ignored.  */
3218         DBGPRINTF ("ignored s @ %p", (void*)s);
3219       }
3220   if (verbosity_level >= 2)
3221     printf ("%s emitted %d routines for %s\n",
3222             progname, nbfun, wtd->comment);
3223 }
3224
3225 static const struct write_types_data ggc_wtd = {
3226   "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL,
3227   "GC marker procedures.  ",
3228   FALSE
3229 };
3230
3231 static const struct write_types_data pch_wtd = {
3232   "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
3233   "gt_pch_note_reorder",
3234   "PCH type-walking procedures.  ",
3235   TRUE
3236 };
3237
3238 /* Write out the local pointer-walking routines.  */
3239
3240 /* process_field routine for local pointer-walking.  */
3241
3242 static void
3243 write_types_local_process_field (type_p f, const struct walk_type_data *d)
3244 {
3245   switch (f->kind)
3246     {
3247     case TYPE_POINTER:
3248     case TYPE_STRUCT:
3249     case TYPE_UNION:
3250     case TYPE_LANG_STRUCT:
3251     case TYPE_PARAM_STRUCT:
3252     case TYPE_STRING:
3253       oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
3254                d->prev_val[3]);
3255       oprintf (d->of, "%*s  op (&(%s), cookie);\n", d->indent, "", d->val);
3256       break;
3257
3258     case TYPE_SCALAR:
3259       break;
3260
3261     default:
3262       gcc_unreachable ();
3263     }
3264 }
3265
3266 /* For S, a structure that's part of ORIG_S, and using parameters
3267    PARAM, write out a routine that:
3268    - Is of type gt_note_pointers
3269    - Calls PROCESS_FIELD on each field of S or its substructures.
3270 */
3271
3272 static void
3273 write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param)
3274 {
3275   struct walk_type_data d;
3276
3277   memset (&d, 0, sizeof (d));
3278   d.of = get_output_file_for_structure (s, param);
3279   d.process_field = write_types_local_process_field;
3280   d.opt = s->u.s.opt;
3281   d.line = &s->u.s.line;
3282   d.bitmap = s->u.s.bitmap;
3283   d.param = param;
3284   d.prev_val[0] = d.prev_val[2] = "*x";
3285   d.prev_val[1] = "not valid postage";  /* Guarantee an error.  */
3286   d.prev_val[3] = "x";
3287   d.val = "(*x)";
3288   d.fn_wants_lvalue = true;
3289
3290   oprintf (d.of, "\n");
3291   oprintf (d.of, "void\n");
3292   oprintf (d.of, "gt_pch_p_");
3293   output_mangled_typename (d.of, orig_s);
3294   oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n"
3295            "\tvoid *x_p,\n"
3296            "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3297            "\tATTRIBUTE_UNUSED void *cookie)\n");
3298   oprintf (d.of, "{\n");
3299   oprintf (d.of, "  %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n",
3300            s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag,
3301            s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag);
3302   d.indent = 2;
3303   walk_type (s, &d);
3304   oprintf (d.of, "}\n");
3305 }
3306
3307 /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS.  */
3308
3309 static void
3310 write_local (outf_p output_header, type_p structures, type_p param_structs)
3311 {
3312   type_p s;
3313
3314   if (!output_header)
3315     return;
3316   oprintf (output_header, "\n/* Local pointer-walking routines.  */\n");
3317   for (s = structures; s; s = s->next)
3318     if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
3319       {
3320         options_p opt;
3321
3322         if (s->u.s.line.file == NULL)
3323           continue;
3324         for (opt = s->u.s.opt; opt; opt = opt->next)
3325           if (strcmp (opt->name, "ptr_alias") == 0
3326               && opt->kind == OPTION_TYPE)
3327             {
3328               const_type_p const t = (const_type_p) opt->info.type;
3329               if (t->kind == TYPE_STRUCT
3330                   || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT)
3331                 {
3332                   oprintf (output_header, "#define gt_pch_p_");
3333                   output_mangled_typename (output_header, s);
3334                   oprintf (output_header, " gt_pch_p_");
3335                   output_mangled_typename (output_header, t);
3336                   oprintf (output_header, "\n");
3337                 }
3338               else
3339                 error_at_line (&s->u.s.line,
3340                                "structure alias is not a structure");
3341               break;
3342             }
3343         if (opt)
3344           continue;
3345
3346         /* Declare the marker procedure only once.  */
3347         oprintf (output_header, "extern void gt_pch_p_");
3348         output_mangled_typename (output_header, s);
3349         oprintf (output_header,
3350                  "\n    (void *, void *, gt_pointer_operator, void *);\n");
3351
3352         if (s->kind == TYPE_LANG_STRUCT)
3353           {
3354             type_p ss;
3355             for (ss = s->u.s.lang_struct; ss; ss = ss->next)
3356               write_local_func_for_structure (s, ss, NULL);
3357           }
3358         else
3359           write_local_func_for_structure (s, s, NULL);
3360       }
3361
3362   for (s = param_structs; s; s = s->next)
3363     if (s->gc_used == GC_POINTED_TO)
3364       {
3365         type_p *param = s->u.param_struct.param;
3366         type_p stru = s->u.param_struct.stru;
3367
3368         /* Declare the marker procedure.  */
3369         oprintf (output_header, "extern void gt_pch_p_");
3370         output_mangled_typename (output_header, s);
3371         oprintf (output_header,
3372                  "\n    (void *, void *, gt_pointer_operator, void *);\n");
3373
3374         if (stru->u.s.line.file == NULL)
3375           {
3376             fprintf (stderr, "warning: structure `%s' used but not defined\n",
3377                      s->u.s.tag);
3378             continue;
3379           }
3380
3381         if (stru->kind == TYPE_LANG_STRUCT)
3382           {
3383             type_p ss;
3384             for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
3385               write_local_func_for_structure (s, ss, param);
3386           }
3387         else
3388           write_local_func_for_structure (s, stru, param);
3389       }
3390 }
3391
3392 /* Nonzero if S is a type for which typed GC allocators should be output.  */
3393
3394 #define USED_BY_TYPED_GC_P(s)                                           \
3395   (((s->kind == TYPE_POINTER)                                           \
3396     && ((s->u.p->gc_used == GC_POINTED_TO)                              \
3397         || (s->u.p->gc_used == GC_USED)))                               \
3398    || (UNION_OR_STRUCT_P (s) &&                                         \
3399        (((s)->gc_used == GC_POINTED_TO)                                 \
3400         || ((s)->gc_used == GC_MAYBE_POINTED_TO                         \
3401             && s->u.s.line.file != NULL)                                \
3402         || ((s)->gc_used == GC_USED                                     \
3403             && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))))))
3404
3405
3406 /* Write out the 'enum' definition for gt_types_enum.  */
3407
3408 static void
3409 write_enum_defn (type_p structures, type_p param_structs)
3410 {
3411   type_p s;
3412   int nbstruct = 0;
3413   int nbparamstruct = 0;
3414
3415   if (!header_file)
3416     return;
3417   oprintf (header_file, "\n/* Enumeration of types known.  */\n");
3418   oprintf (header_file, "enum gt_types_enum {\n");
3419   for (s = structures; s; s = s->next)
3420     if (USED_BY_TYPED_GC_P (s))
3421       {
3422         nbstruct++;
3423         DBGPRINTF ("write_enum_defn s @ %p nbstruct %d",
3424                    (void*) s, nbstruct);
3425         if (UNION_OR_STRUCT_P (s))
3426           DBGPRINTF ("write_enum_defn s %p #%d is unionorstruct tagged %s",
3427                      (void*) s, nbstruct, s->u.s.tag);
3428         oprintf (header_file, " gt_ggc_e_");
3429         output_mangled_typename (header_file, s);
3430         oprintf (header_file, ",\n");
3431       }
3432   for (s = param_structs; s; s = s->next)
3433     if (s->gc_used == GC_POINTED_TO)
3434       {
3435         nbparamstruct++;
3436         DBGPRINTF ("write_enum_defn s %p nbparamstruct %d",
3437                    (void*) s, nbparamstruct);
3438         oprintf (header_file, " gt_e_");
3439         output_mangled_typename (header_file, s);
3440         oprintf (header_file, ",\n");
3441       }
3442   oprintf (header_file, " gt_types_enum_last\n");
3443   oprintf (header_file, "};\n");
3444   if (verbosity_level >= 2)
3445     printf ("%s handled %d GTY-ed structures & %d parameterized structures.\n",
3446             progname, nbstruct, nbparamstruct);
3447
3448 }
3449
3450 /* Might T contain any non-pointer elements?  */
3451
3452 static int
3453 contains_scalar_p (type_p t)
3454 {
3455   switch (t->kind)
3456     {
3457     case TYPE_STRING:
3458     case TYPE_POINTER:
3459       return 0;
3460     case TYPE_ARRAY:
3461       return contains_scalar_p (t->u.a.p);
3462     default:
3463       /* Could also check for structures that have no non-pointer
3464          fields, but there aren't enough of those to worry about.  */
3465       return 1;
3466     }
3467 }
3468
3469 /* Mangle INPF and print it to F.  */
3470
3471 static void
3472 put_mangled_filename (outf_p f, const input_file *inpf)
3473 {
3474   /* The call to get_output_file_name may indirectly update fn since
3475      get_output_file_with_visibility caches its result inside, so we
3476      need the CONST_CAST.  */
3477   const char *name = get_output_file_name (CONST_CAST (input_file*, inpf));
3478   if (!f || !name)
3479     return;
3480   for (; *name != 0; name++)
3481     if (ISALNUM (*name))
3482       oprintf (f, "%c", *name);
3483     else
3484       oprintf (f, "%c", '_');
3485 }
3486
3487 /* Finish off the currently-created root tables in FLP.  PFX, TNAME,
3488    LASTNAME, and NAME are all strings to insert in various places in
3489    the resulting code.  */
3490
3491 static void
3492 finish_root_table (struct flist *flp, const char *pfx, const char *lastname,
3493                    const char *tname, const char *name)
3494 {
3495   struct flist *fli2;
3496
3497   for (fli2 = flp; fli2; fli2 = fli2->next)
3498     if (fli2->started_p)
3499       {
3500         oprintf (fli2->f, "  %s\n", lastname);
3501         oprintf (fli2->f, "};\n\n");
3502       }
3503
3504   for (fli2 = flp; fli2 && base_files; fli2 = fli2->next)
3505     if (fli2->started_p)
3506       {
3507         lang_bitmap bitmap = get_lang_bitmap (fli2->file);
3508         int fnum;
3509
3510         for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
3511           if (bitmap & 1)
3512             {
3513               oprintf (base_files[fnum],
3514                        "extern const struct %s gt_%s_", tname, pfx);
3515               put_mangled_filename (base_files[fnum], fli2->file);
3516               oprintf (base_files[fnum], "[];\n");
3517             }
3518       }
3519
3520   {
3521     size_t fnum;
3522     for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
3523       oprintf (base_files[fnum],
3524                "EXPORTED_CONST struct %s * const %s[] = {\n", tname, name);
3525   }
3526
3527
3528   for (fli2 = flp; fli2; fli2 = fli2->next)
3529     if (fli2->started_p)
3530       {
3531         lang_bitmap bitmap = get_lang_bitmap (fli2->file);
3532         int fnum;
3533
3534         fli2->started_p = 0;
3535
3536         for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1)
3537           if (bitmap & 1)
3538             {
3539               oprintf (base_files[fnum], "  gt_%s_", pfx);
3540               put_mangled_filename (base_files[fnum], fli2->file);
3541               oprintf (base_files[fnum], ",\n");
3542             }
3543       }
3544
3545   {
3546     size_t fnum;
3547     for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
3548       {
3549         oprintf (base_files[fnum], "  NULL\n");
3550         oprintf (base_files[fnum], "};\n");
3551       }
3552   }
3553 }
3554
3555 /* Write the first three fields (pointer, count and stride) for
3556    root NAME to F.  V and LINE are as for write_root.
3557
3558    Return true if the entry could be written; return false on error.  */
3559
3560 static bool
3561 start_root_entry (outf_p f, pair_p v, const char *name, struct fileloc *line)
3562 {
3563   type_p ap;
3564
3565   if (!v)
3566     {
3567       error_at_line (line, "`%s' is too complex to be a root", name);
3568       return false;
3569     }
3570
3571   oprintf (f, "  {\n");
3572   oprintf (f, "    &%s,\n", name);
3573   oprintf (f, "    1");
3574
3575   for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
3576     if (ap->u.a.len[0])
3577       oprintf (f, " * (%s)", ap->u.a.len);
3578     else if (ap == v->type)
3579       oprintf (f, " * ARRAY_SIZE (%s)", v->name);
3580   oprintf (f, ",\n");
3581   oprintf (f, "    sizeof (%s", v->name);
3582   for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
3583     oprintf (f, "[0]");
3584   oprintf (f, "),\n");
3585   return true;
3586 }
3587
3588 /* A subroutine of write_root for writing the roots for field FIELD_NAME,
3589    which has type FIELD_TYPE.  Parameters F to EMIT_PCH are the parameters
3590    of the caller.  */
3591
3592 static void
3593 write_field_root (outf_p f, pair_p v, type_p type, const char *name,
3594                   int has_length, struct fileloc *line, const char *if_marked,
3595                   bool emit_pch, type_p field_type, const char *field_name)
3596 {
3597   /* If the field reference is relative to V, rather than to some
3598      subcomponent of V, we can mark any subarrays with a single stride.
3599      We're effectively treating the field as a global variable in its
3600      own right.  */
3601   if (v && type == v->type)
3602     {
3603       struct pair newv;
3604
3605       newv = *v;
3606       newv.type = field_type;
3607       newv.name = ACONCAT ((v->name, ".", field_name, NULL));
3608       v = &newv;
3609     }
3610   /* Otherwise, any arrays nested in the structure are too complex to
3611      handle.  */
3612   else if (field_type->kind == TYPE_ARRAY)
3613     v = NULL;
3614   write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)),
3615               has_length, line, if_marked, emit_pch);
3616 }
3617
3618 /* Write out to F the table entry and any marker routines needed to
3619    mark NAME as TYPE.  V can be one of three values:
3620
3621      - null, if NAME is too complex to represent using a single
3622        count and stride.  In this case, it is an error for NAME to
3623        contain any gc-ed data.
3624
3625      - the outermost array that contains NAME, if NAME is part of an array.
3626
3627      - the C variable that contains NAME, if NAME is not part of an array.
3628
3629    LINE is the line of the C source that declares the root variable.
3630    HAS_LENGTH is nonzero iff V was a variable-length array.  IF_MARKED
3631    is nonzero iff we are building the root table for hash table caches.  */
3632
3633 static void
3634 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
3635             struct fileloc *line, const char *if_marked, bool emit_pch)
3636 {
3637   switch (type->kind)
3638     {
3639     case TYPE_STRUCT:
3640       {
3641         pair_p fld;
3642         for (fld = type->u.s.fields; fld; fld = fld->next)
3643           {
3644             int skip_p = 0;
3645             const char *desc = NULL;
3646             options_p o;
3647
3648             for (o = fld->opt; o; o = o->next)
3649               if (strcmp (o->name, "skip") == 0)
3650                 skip_p = 1;
3651               else if (strcmp (o->name, "desc") == 0
3652                        && o->kind == OPTION_STRING)
3653                 desc = o->info.string;
3654               else if (strcmp (o->name, "param_is") == 0)
3655                 ;
3656               else
3657                 error_at_line (line,
3658                                "field `%s' of global `%s' has unknown option `%s'",
3659                                fld->name, name, o->name);
3660
3661             if (skip_p)
3662               continue;
3663             else if (desc && fld->type->kind == TYPE_UNION)
3664               {
3665                 pair_p validf = NULL;
3666                 pair_p ufld;
3667
3668                 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next)
3669                   {
3670                     const char *tag = NULL;
3671                     options_p oo;
3672                     for (oo = ufld->opt; oo; oo = oo->next)
3673                       if (strcmp (oo->name, "tag") == 0
3674                           && oo->kind == OPTION_STRING)
3675                         tag = oo->info.string;
3676                     if (tag == NULL || strcmp (tag, desc) != 0)
3677                       continue;
3678                     if (validf != NULL)
3679                       error_at_line (line,
3680                                      "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3681                                      name, fld->name, validf->name,
3682                                      name, fld->name, ufld->name, tag);
3683                     validf = ufld;
3684                   }
3685                 if (validf != NULL)
3686                   write_field_root (f, v, type, name, 0, line, if_marked,
3687                                     emit_pch, validf->type,
3688                                     ACONCAT ((fld->name, ".",
3689                                               validf->name, NULL)));
3690               }
3691             else if (desc)
3692               error_at_line (line,
3693                              "global `%s.%s' has `desc' option but is not union",
3694                              name, fld->name);
3695             else
3696               write_field_root (f, v, type, name, 0, line, if_marked,
3697                                 emit_pch, fld->type, fld->name);
3698           }
3699       }
3700       break;
3701
3702     case TYPE_ARRAY:
3703       {
3704         char *newname;
3705         newname = xasprintf ("%s[0]", name);
3706         write_root (f, v, type->u.a.p, newname, has_length, line, if_marked,
3707                     emit_pch);
3708         free (newname);
3709       }
3710       break;
3711
3712     case TYPE_POINTER:
3713       {
3714         type_p tp;
3715
3716         if (!start_root_entry (f, v, name, line))
3717           return;
3718
3719         tp = type->u.p;
3720
3721         if (!has_length && UNION_OR_STRUCT_P (tp))
3722           {
3723             oprintf (f, "    &gt_ggc_mx_%s,\n", tp->u.s.tag);
3724             if (emit_pch)
3725               oprintf (f, "    &gt_pch_nx_%s", tp->u.s.tag);
3726             else
3727               oprintf (f, "    NULL");
3728           }
3729         else if (!has_length && tp->kind == TYPE_PARAM_STRUCT)
3730           {
3731             oprintf (f, "    &gt_ggc_m_");
3732             output_mangled_typename (f, tp);
3733             if (emit_pch)
3734               {
3735                 oprintf (f, ",\n    &gt_pch_n_");
3736                 output_mangled_typename (f, tp);
3737               }
3738             else
3739               oprintf (f, ",\n    NULL");
3740           }
3741         else if (has_length
3742                  && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp)))
3743           {
3744             oprintf (f, "    &gt_ggc_ma_%s,\n", name);
3745             if (emit_pch)
3746               oprintf (f, "    &gt_pch_na_%s", name);
3747             else
3748               oprintf (f, "    NULL");
3749           }
3750         else
3751           {
3752             error_at_line (line,
3753                            "global `%s' is pointer to unimplemented type",
3754                            name);
3755           }
3756         if (if_marked)
3757           oprintf (f, ",\n    &%s", if_marked);
3758         oprintf (f, "\n  },\n");
3759       }
3760       break;
3761
3762     case TYPE_STRING:
3763       {
3764         if (!start_root_entry (f, v, name, line))
3765           return;
3766
3767         oprintf (f, "    (gt_pointer_walker) &gt_ggc_m_S,\n");
3768         oprintf (f, "    (gt_pointer_walker) &gt_pch_n_S\n");
3769         oprintf (f, "  },\n");
3770       }
3771       break;
3772
3773     case TYPE_SCALAR:
3774       break;
3775
3776     default:
3777       error_at_line (line, "global `%s' is unimplemented type", name);
3778     }
3779 }
3780
3781 /* This generates a routine to walk an array.  */
3782
3783 static void
3784 write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
3785 {
3786   struct walk_type_data d;
3787   char *prevval3;
3788
3789   memset (&d, 0, sizeof (d));
3790   d.of = f;
3791   d.cookie = wtd;
3792   d.indent = 2;
3793   d.line = &v->line;
3794   d.opt = v->opt;
3795   d.bitmap = get_lang_bitmap (v->line.file);
3796   d.param = NULL;
3797
3798   d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
3799
3800   if (wtd->param_prefix)
3801     {
3802       oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
3803       oprintf (f, "    (void *, void *, gt_pointer_operator, void *);\n");
3804       oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3805                wtd->param_prefix, v->name);
3806       oprintf (d.of,
3807                "      ATTRIBUTE_UNUSED void *x_p,\n"
3808                "      ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3809                "      ATTRIBUTE_UNUSED void * cookie)\n");
3810       oprintf (d.of, "{\n");
3811       d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3812       d.process_field = write_types_local_process_field;
3813       walk_type (v->type, &d);
3814       oprintf (f, "}\n\n");
3815     }
3816
3817   d.opt = v->opt;
3818   oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name);
3819   oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3820            wtd->prefix, v->name);
3821   oprintf (f, "{\n");
3822   d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3823   d.process_field = write_types_process_field;
3824   walk_type (v->type, &d);
3825   free (prevval3);
3826   oprintf (f, "}\n\n");
3827 }
3828
3829 /* Output a table describing the locations and types of VARIABLES.  */
3830
3831 static void
3832 write_roots (pair_p variables, bool emit_pch)
3833 {
3834   pair_p v;
3835   struct flist *flp = NULL;
3836
3837   for (v = variables; v; v = v->next)
3838     {
3839       outf_p f =
3840         get_output_file_with_visibility (CONST_CAST (input_file*,
3841                                                      v->line.file));
3842       struct flist *fli;
3843       const char *length = NULL;
3844       int deletable_p = 0;
3845       options_p o;
3846       for (o = v->opt; o; o = o->next)
3847         if (strcmp (o->name, "length") == 0
3848             && o->kind == OPTION_STRING)
3849           length = o->info.string;
3850         else if (strcmp (o->name, "deletable") == 0)
3851           deletable_p = 1;
3852         else if (strcmp (o->name, "param_is") == 0)
3853           ;
3854         else if (strncmp (o->name, "param", 5) == 0
3855                  && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0)
3856           ;
3857         else if (strcmp (o->name, "if_marked") == 0)
3858           ;
3859         else
3860           error_at_line (&v->line,
3861                          "global `%s' has unknown option `%s'",
3862                          v->name, o->name);
3863
3864       for (fli = flp; fli; fli = fli->next)
3865         if (fli->f == f && f)
3866           break;
3867       if (fli == NULL)
3868         {
3869           fli = XNEW (struct flist);
3870           fli->f = f;
3871           fli->next = flp;
3872           fli->started_p = 0;
3873           fli->file = v->line.file;
3874           gcc_assert (fli->file);
3875           flp = fli;
3876
3877           oprintf (f, "\n/* GC roots.  */\n\n");
3878         }
3879
3880       if (!deletable_p
3881           && length
3882           && v->type->kind == TYPE_POINTER
3883           && (v->type->u.p->kind == TYPE_POINTER
3884               || v->type->u.p->kind == TYPE_STRUCT))
3885         {
3886           write_array (f, v, &ggc_wtd);
3887           write_array (f, v, &pch_wtd);
3888         }
3889     }
3890
3891   for (v = variables; v; v = v->next)
3892     {
3893       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
3894                                                               v->line.file));
3895       struct flist *fli;
3896       int skip_p = 0;
3897       int length_p = 0;
3898       options_p o;
3899
3900       for (o = v->opt; o; o = o->next)
3901         if (strcmp (o->name, "length") == 0)
3902           length_p = 1;
3903         else if (strcmp (o->name, "deletable") == 0
3904                  || strcmp (o->name, "if_marked") == 0)
3905           skip_p = 1;
3906
3907       if (skip_p)
3908         continue;
3909
3910       for (fli = flp; fli; fli = fli->next)
3911         if (fli->f == f)
3912           break;
3913       if (!fli->started_p)
3914         {
3915           fli->started_p = 1;
3916
3917           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3918           put_mangled_filename (f, v->line.file);
3919           oprintf (f, "[] = {\n");
3920         }
3921
3922       write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
3923     }
3924
3925   finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3926                      "gt_ggc_rtab");
3927
3928   for (v = variables; v; v = v->next)
3929     {
3930       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
3931                                                               v->line.file));
3932       struct flist *fli;
3933       int skip_p = 1;
3934       options_p o;
3935
3936       for (o = v->opt; o; o = o->next)
3937         if (strcmp (o->name, "deletable") == 0)
3938           skip_p = 0;
3939         else if (strcmp (o->name, "if_marked") == 0)
3940           skip_p = 1;
3941
3942       if (skip_p)
3943         continue;
3944
3945       for (fli = flp; fli; fli = fli->next)
3946         if (fli->f == f)
3947           break;
3948       if (!fli->started_p)
3949         {
3950           fli->started_p = 1;
3951
3952           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3953           put_mangled_filename (f, v->line.file);
3954           oprintf (f, "[] = {\n");
3955         }
3956
3957       oprintf (f, "  { &%s, 1, sizeof (%s), NULL, NULL },\n",
3958                v->name, v->name);
3959     }
3960
3961   finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3962                      "gt_ggc_deletable_rtab");
3963
3964   for (v = variables; v; v = v->next)
3965     {
3966       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
3967                                                               v->line.file));
3968       struct flist *fli;
3969       const char *if_marked = NULL;
3970       int length_p = 0;
3971       options_p o;
3972
3973       for (o = v->opt; o; o = o->next)
3974         if (strcmp (o->name, "length") == 0)
3975           length_p = 1;
3976         else if (strcmp (o->name, "if_marked") == 0
3977                        && o->kind == OPTION_STRING)
3978           if_marked = o->info.string;
3979        if (if_marked == NULL)
3980         continue;
3981       if (v->type->kind != TYPE_POINTER
3982           || v->type->u.p->kind != TYPE_PARAM_STRUCT
3983           || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0))
3984         {
3985           error_at_line (&v->line,
3986                          "if_marked option used but not hash table");
3987           continue;
3988         }
3989
3990       for (fli = flp; fli; fli = fli->next)
3991         if (fli->f == f)
3992           break;
3993       if (!fli->started_p)
3994         {
3995           fli->started_p = 1;
3996
3997           oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3998           put_mangled_filename (f, v->line.file);
3999           oprintf (f, "[] = {\n");
4000         }
4001
4002       write_root (f, v, v->type->u.p->u.param_struct.param[0],
4003                   v->name, length_p, &v->line, if_marked, emit_pch);
4004     }
4005
4006   finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
4007                      "gt_ggc_cache_rtab");
4008
4009   if (!emit_pch)
4010     return;
4011
4012   for (v = variables; v; v = v->next)
4013     {
4014       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4015                                                               v->line.file));
4016       struct flist *fli;
4017       int length_p = 0;
4018       int if_marked_p = 0;
4019       options_p o;
4020
4021       for (o = v->opt; o; o = o->next)
4022         if (strcmp (o->name, "length") == 0)
4023           length_p = 1;
4024         else if (strcmp (o->name, "if_marked") == 0)
4025           if_marked_p = 1;
4026
4027       if (!if_marked_p)
4028         continue;
4029
4030       for (fli = flp; fli; fli = fli->next)
4031         if (fli->f == f)
4032           break;
4033       if (!fli->started_p)
4034         {
4035           fli->started_p = 1;
4036
4037           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
4038           put_mangled_filename (f, v->line.file);
4039           oprintf (f, "[] = {\n");
4040         }
4041
4042       write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
4043     }
4044
4045   finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4046                      "gt_pch_cache_rtab");
4047
4048   for (v = variables; v; v = v->next)
4049     {
4050       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4051                                                               v->line.file));
4052       struct flist *fli;
4053       int skip_p = 0;
4054       options_p o;
4055
4056       for (o = v->opt; o; o = o->next)
4057         if (strcmp (o->name, "deletable") == 0
4058             || strcmp (o->name, "if_marked") == 0)
4059           skip_p = 1;
4060
4061       if (skip_p)
4062         continue;
4063
4064       if (!contains_scalar_p (v->type))
4065         continue;
4066
4067       for (fli = flp; fli; fli = fli->next)
4068         if (fli->f == f)
4069           break;
4070       if (!fli->started_p)
4071         {
4072           fli->started_p = 1;
4073
4074           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4075           put_mangled_filename (f, v->line.file);
4076           oprintf (f, "[] = {\n");
4077         }
4078
4079       oprintf (f, "  { &%s, 1, sizeof (%s), NULL, NULL },\n",
4080                v->name, v->name);
4081     }
4082
4083   finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4084                      "gt_pch_scalar_rtab");
4085 }
4086
4087 /* Record the definition of a generic VEC structure, as if we had expanded
4088    the macros in vec.h:
4089
4090    typedef struct VEC_<type>_base GTY(()) {
4091    unsigned num;
4092    unsigned alloc;
4093    <type> GTY((length ("%h.num"))) vec[1];
4094    } VEC_<type>_base
4095
4096    where the GTY(()) tags are only present if is_scalar is _false_.  */
4097
4098 void
4099 note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos)
4100 {
4101   pair_p fields;
4102   type_p t;
4103   options_p o;
4104   type_p len_ty = create_scalar_type ("unsigned");
4105   const char *name = concat ("VEC_", type_name, "_base", (char *) 0);
4106
4107   if (is_scalar)
4108     {
4109       t = create_scalar_type (type_name);
4110       o = 0;
4111     }
4112   else
4113     {
4114       t = resolve_typedef (type_name, pos);
4115       o = create_string_option (0, "length", "%h.num");
4116     }
4117   /* We assemble the field list in reverse order.  */
4118   fields = create_field_at (0, create_array (t, "1"), "vec", o, pos);
4119   fields = create_field_at (fields, len_ty, "alloc", 0, pos);
4120   fields = create_field_at (fields, len_ty, "num", 0, pos);
4121
4122   do_typedef (name, new_structure (name, 0, pos, fields, 0), pos);
4123 }
4124
4125 /* Record the definition of an allocation-specific VEC structure, as if
4126    we had expanded the macros in vec.h:
4127
4128    typedef struct VEC_<type>_<astrat> {
4129      VEC_<type>_base base;
4130    } VEC_<type>_<astrat>;
4131 */
4132 void
4133 note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos)
4134 {
4135   const char *astratname = concat ("VEC_", type, "_", astrat, (char *) 0);
4136   const char *basename = concat ("VEC_", type, "_base", (char *) 0);
4137
4138   pair_p field = create_field_at (0, resolve_typedef (basename, pos),
4139                                   "base", 0, pos);
4140
4141   do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos);
4142 }
4143
4144 /* Returns the specifier keyword for a string or union type S, empty string
4145    otherwise.  */
4146
4147 static const char *
4148 get_type_specifier (const type_p s)
4149 {
4150   if (s->kind == TYPE_STRUCT || s->kind == TYPE_LANG_STRUCT)
4151     return "struct ";
4152   if (s->kind == TYPE_UNION)
4153     return "union ";
4154   return "";
4155 }
4156
4157 /* TRUE if type S has the GTY variable_size annotation.  */
4158
4159 static bool
4160 variable_size_p (const type_p s)
4161 {
4162   options_p o;
4163   for (o = s->u.s.opt; o; o = o->next)
4164     if (strcmp (o->name, "variable_size") == 0)
4165       return true;
4166   return false;
4167 }
4168
4169 enum alloc_quantity
4170 { single, vector };
4171 enum alloc_zone
4172 { any_zone, specific_zone };
4173
4174 /* Writes one typed allocator definition for type identifier TYPE_NAME with
4175    optional type specifier TYPE_SPECIFIER.  The allocator name will contain
4176    ALLOCATOR_TYPE.  If VARIABLE_SIZE is true, the allocator will have an extra
4177    parameter specifying number of bytes to allocate.  If QUANTITY is set to
4178    VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
4179    the allocator will be zone-specific.  */
4180
4181 static void
4182 write_typed_alloc_def (bool variable_size, const char *type_specifier,
4183                        const char *type_name, const char *allocator_type,
4184                        enum alloc_quantity quantity, enum alloc_zone zone)
4185 {
4186   bool two_args = variable_size && (quantity == vector);
4187   bool third_arg = ((zone == specific_zone)
4188                     && (variable_size || (quantity == vector)));
4189
4190   oprintf (header_file, "#define ggc_alloc_%s%s", allocator_type, type_name);
4191   oprintf (header_file, "(%s%s%s%s%s) ",
4192            (variable_size ? "SIZE" : ""),
4193            (two_args ? ", " : ""),
4194            (quantity == vector) ? "n" : "",
4195            (third_arg ? ", " : ""), (zone == specific_zone) ? "z" : "");
4196   oprintf (header_file, "((%s%s *)", type_specifier, type_name);
4197   oprintf (header_file, "(ggc_internal_%salloc_stat (", allocator_type);
4198   if (zone == specific_zone)
4199     oprintf (header_file, "z, ");
4200   if (variable_size)
4201     oprintf (header_file, "SIZE");
4202   else
4203     oprintf (header_file, "sizeof (%s%s)", type_specifier, type_name);
4204   if (quantity == vector)
4205     oprintf (header_file, ", n");
4206   oprintf (header_file, " MEM_STAT_INFO)))\n");
4207 }
4208
4209 /* Writes a typed allocator definition for a struct or union S.  */
4210
4211 static void
4212 write_typed_struct_alloc_def (const type_p s, const char *allocator_type,
4213                               enum alloc_quantity quantity,
4214                               enum alloc_zone zone)
4215 {
4216   write_typed_alloc_def (variable_size_p (s), get_type_specifier (s),
4217                          s->u.s.tag, allocator_type, quantity, zone);
4218 }
4219
4220 /* Writes a typed allocator definition for a typedef P.  */
4221
4222 static void
4223 write_typed_typedef_alloc_def (const pair_p p, const char *allocator_type,
4224                                enum alloc_quantity quantity,
4225                                enum alloc_zone zone)
4226 {
4227   write_typed_alloc_def (variable_size_p (p->type), "", p->name,
4228                          allocator_type, quantity, zone);
4229 }
4230
4231 /* Writes typed allocator definitions for the types in STRUCTURES and
4232    TYPEDEFS that are used by GC.  */
4233
4234 static void
4235 write_typed_alloc_defns (const type_p structures, const pair_p typedefs)
4236 {
4237   type_p s;
4238   pair_p p;
4239
4240   oprintf (header_file,
4241            "\n/* Allocators for known structs and unions.  */\n\n");
4242   for (s = structures; s; s = s->next)
4243     {
4244       if (!USED_BY_TYPED_GC_P (s))
4245         continue;
4246       write_typed_struct_alloc_def (s, "", single, any_zone);
4247       write_typed_struct_alloc_def (s, "cleared_", single, any_zone);
4248       write_typed_struct_alloc_def (s, "vec_", vector, any_zone);
4249       write_typed_struct_alloc_def (s, "cleared_vec_", vector, any_zone);
4250       write_typed_struct_alloc_def (s, "zone_", single, specific_zone);
4251       write_typed_struct_alloc_def (s, "zone_cleared_", single,
4252                                     specific_zone);
4253       write_typed_struct_alloc_def (s, "zone_vec_", vector, specific_zone);
4254       write_typed_struct_alloc_def (s, "zone_cleared_vec_", vector,
4255                                     specific_zone);
4256     }
4257
4258   oprintf (header_file, "\n/* Allocators for known typedefs.  */\n");
4259   for (p = typedefs; p; p = p->next)
4260     {
4261       s = p->type;
4262       if (!USED_BY_TYPED_GC_P (s) || (strcmp (p->name, s->u.s.tag) == 0))
4263         continue;
4264       write_typed_typedef_alloc_def (p, "", single, any_zone);
4265       write_typed_typedef_alloc_def (p, "cleared_", single, any_zone);
4266       write_typed_typedef_alloc_def (p, "vec_", vector, any_zone);
4267       write_typed_typedef_alloc_def (p, "cleared_vec_", vector, any_zone);
4268       write_typed_typedef_alloc_def (p, "zone_", single, specific_zone);
4269       write_typed_typedef_alloc_def (p, "zone_cleared_", single,
4270                                      specific_zone);
4271       write_typed_typedef_alloc_def (p, "zone_cleared_vec_", vector,
4272                                      specific_zone);
4273     }
4274 }
4275
4276 /* Prints not-as-ugly version of a typename of T to OF.  Trades the uniquness
4277    guaranteee for somewhat increased readability.  If name conflicts do happen,
4278    this funcion will have to be adjusted to be more like
4279    output_mangled_typename.  */
4280
4281 static void
4282 output_typename (outf_p of, const_type_p t)
4283 {
4284   switch (t->kind)
4285     {
4286     case TYPE_STRING:
4287       oprintf (of, "str");
4288       break;
4289     case TYPE_SCALAR:
4290       oprintf (of, "scalar");
4291       break;
4292     case TYPE_POINTER:
4293       output_typename (of, t->u.p);
4294       break;
4295     case TYPE_STRUCT:
4296     case TYPE_UNION:
4297     case TYPE_LANG_STRUCT:
4298       oprintf (of, "%s", t->u.s.tag);
4299       break;
4300     case TYPE_PARAM_STRUCT:
4301       {
4302         int i;
4303         for (i = 0; i < NUM_PARAM; i++)
4304           if (t->u.param_struct.param[i] != NULL)
4305             {
4306               output_typename (of, t->u.param_struct.param[i]);
4307               oprintf (of, "_");
4308             }
4309         output_typename (of, t->u.param_struct.stru);
4310         break;
4311       }
4312     default:
4313       gcc_unreachable ();
4314     }
4315 }
4316
4317 /* Writes a typed GC allocator for type S that is suitable as a callback for
4318    the splay tree implementation in libiberty.  */
4319
4320 static void
4321 write_splay_tree_allocator_def (const_type_p s)
4322 {
4323   outf_p of = get_output_file_with_visibility (NULL);
4324   oprintf (of, "void * ggc_alloc_splay_tree_");
4325   output_typename (of, s);
4326   oprintf (of, " (int sz, void * nl)\n");
4327   oprintf (of, "{\n");
4328   oprintf (of, "  return ggc_splay_alloc (");
4329   oprintf (of, "gt_e_");
4330   output_mangled_typename (of, s);
4331   oprintf (of, ", sz, nl);\n");
4332   oprintf (of, "}\n\n");
4333 }
4334
4335 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
4336    for the splay tree implementation in libiberty.  */
4337
4338 static void
4339 write_splay_tree_allocators (const_type_p param_structs)
4340 {
4341   const_type_p s;
4342
4343   oprintf (header_file, "\n/* Splay tree callback allocators.  */\n");
4344   for (s = param_structs; s; s = s->next)
4345     if (s->gc_used == GC_POINTED_TO)
4346       {
4347         oprintf (header_file, "extern void * ggc_alloc_splay_tree_");
4348         output_typename (header_file, s);
4349         oprintf (header_file, " (int, void *);\n");
4350         write_splay_tree_allocator_def (s);
4351       }
4352 }
4353
4354 static void dump_pair (int indent, pair_p p);
4355 static void dump_type (int indent, type_p p);
4356 static void dump_type_list (int indent, type_p p);
4357
4358 #define INDENT 2
4359
4360 /* Dumps the value of typekind KIND.  */
4361
4362 static void
4363 dump_typekind (int indent, enum typekind kind)
4364 {
4365   printf ("%*ckind = ", indent, ' ');
4366   switch (kind)
4367     {
4368     case TYPE_SCALAR:
4369       printf ("TYPE_SCALAR");
4370       break;
4371     case TYPE_STRING:
4372       printf ("TYPE_STRING");
4373       break;
4374     case TYPE_STRUCT:
4375       printf ("TYPE_STRUCT");
4376       break;
4377     case TYPE_UNION:
4378       printf ("TYPE_UNION");
4379       break;
4380     case TYPE_POINTER:
4381       printf ("TYPE_POINTER");
4382       break;
4383     case TYPE_ARRAY:
4384       printf ("TYPE_ARRAY");
4385       break;
4386     case TYPE_LANG_STRUCT:
4387       printf ("TYPE_LANG_STRUCT");
4388       break;
4389     case TYPE_PARAM_STRUCT:
4390       printf ("TYPE_PARAM_STRUCT");
4391       break;
4392     default:
4393       gcc_unreachable ();
4394     }
4395   printf ("\n");
4396 }
4397
4398 /* Dumps the value of GC_USED flag.  */
4399
4400 static void
4401 dump_gc_used (int indent, enum gc_used_enum gc_used)
4402 {
4403   printf ("%*cgc_used = ", indent, ' ');
4404   switch (gc_used)
4405     {
4406     case GC_UNUSED:
4407       printf ("GC_UNUSED");
4408       break;
4409     case GC_USED:
4410       printf ("GC_USED");
4411       break;
4412     case GC_MAYBE_POINTED_TO:
4413       printf ("GC_MAYBE_POINTED_TO");
4414       break;
4415     case GC_POINTED_TO:
4416       printf ("GC_POINTED_TO");
4417       break;
4418     default:
4419       gcc_unreachable ();
4420     }
4421   printf ("\n");
4422 }
4423
4424 /* Dumps the type options OPT.  */
4425
4426 static void
4427 dump_options (int indent, options_p opt)
4428 {
4429   options_p o;
4430   printf ("%*coptions = ", indent, ' ');
4431   o = opt;
4432   while (o)
4433     {
4434       switch (o->kind)
4435         {
4436         case OPTION_STRING:
4437           printf ("%s:string %s ", o->name, o->info.string);
4438           break;
4439         case OPTION_TYPE:
4440           printf ("%s:type ", o->name);
4441           dump_type (indent+1, o->info.type);
4442           break;
4443         case OPTION_NESTED:
4444           printf ("%s:nested ", o->name);
4445           break;
4446         case OPTION_NONE:
4447           gcc_unreachable ();
4448         }
4449       o = o->next;
4450     }
4451   printf ("\n");
4452 }
4453
4454 /* Dumps the source file location in LINE.  */
4455
4456 static void
4457 dump_fileloc (int indent, struct fileloc line)
4458 {
4459   printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ',
4460           get_input_file_name (line.file),
4461           line.line);
4462 }
4463
4464 /* Recursively dumps the struct, union, or a language-specific
4465    struct T.  */
4466
4467 static void
4468 dump_type_u_s (int indent, type_p t)
4469 {
4470   pair_p fields;
4471
4472   gcc_assert (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION
4473               || t->kind == TYPE_LANG_STRUCT);
4474   printf ("%*cu.s.tag = %s\n", indent, ' ', t->u.s.tag);
4475   dump_fileloc (indent, t->u.s.line);
4476   printf ("%*cu.s.fields =\n", indent, ' ');
4477   fields = t->u.s.fields;
4478   while (fields)
4479     {
4480       dump_pair (indent + INDENT, fields);
4481       fields = fields->next;
4482     }
4483   printf ("%*cend of fields of type %p\n", indent, ' ', (void *) t);
4484   dump_options (indent, t->u.s.opt);
4485   printf ("%*cu.s.bitmap = %X\n", indent, ' ', t->u.s.bitmap);
4486   if (t->kind == TYPE_LANG_STRUCT)
4487     {
4488       printf ("%*cu.s.lang_struct:\n", indent, ' ');
4489       dump_type_list (indent + INDENT, t->u.s.lang_struct);
4490     }
4491 }
4492
4493 /* Recursively dumps the array T.  */
4494
4495 static void
4496 dump_type_u_a (int indent, type_p t)
4497 {
4498   gcc_assert (t->kind == TYPE_ARRAY);
4499   printf ("%*clen = %s, u.a.p:\n", indent, ' ', t->u.a.len);
4500   dump_type_list (indent + INDENT, t->u.a.p);
4501 }
4502
4503 /* Recursively dumps the parameterized struct T.  */
4504
4505 static void
4506 dump_type_u_param_struct (int indent, type_p t)
4507 {
4508   int i;
4509   gcc_assert (t->kind == TYPE_PARAM_STRUCT);
4510   printf ("%*cu.param_struct.stru:\n", indent, ' ');
4511   dump_type_list (indent, t->u.param_struct.stru);
4512   dump_fileloc (indent, t->u.param_struct.line);
4513   for (i = 0; i < NUM_PARAM; i++)
4514     {
4515       if (t->u.param_struct.param[i] == NULL)
4516         continue;
4517       printf ("%*cu.param_struct.param[%d]:\n", indent, ' ', i);
4518       dump_type (indent + INDENT, t->u.param_struct.param[i]);
4519     }
4520 }
4521
4522 /* Recursively dumps the type list T.  */
4523
4524 static void
4525 dump_type_list (int indent, type_p t)
4526 {
4527   type_p p = t;
4528   while (p)
4529     {
4530       dump_type (indent, p);
4531       p = p->next;
4532     }
4533 }
4534
4535 static htab_t seen_types;
4536
4537 /* Recursively dumps the type T if it was not dumped previously.  */
4538
4539 static void
4540 dump_type (int indent, type_p t)
4541 {
4542   PTR *slot;
4543
4544   printf ("%*cType at %p: ", indent, ' ', (void *) t);
4545   slot = htab_find_slot (seen_types, t, INSERT);
4546   if (*slot != NULL)
4547     {
4548       printf ("already seen.\n");
4549       return;
4550     }
4551   *slot = t;
4552   printf ("\n");
4553
4554   dump_typekind (indent, t->kind);
4555   printf ("%*cpointer_to = %p\n", indent + INDENT, ' ',
4556           (void *) t->pointer_to);
4557   dump_gc_used (indent + INDENT, t->gc_used);
4558   switch (t->kind)
4559     {
4560     case TYPE_SCALAR:
4561       printf ("%*cscalar_is_char = %s\n", indent + INDENT, ' ',
4562               t->u.scalar_is_char ? "true" : "false");
4563       break;
4564     case TYPE_STRING:
4565       break;
4566     case TYPE_STRUCT:
4567     case TYPE_UNION:
4568     case TYPE_LANG_STRUCT:
4569       dump_type_u_s (indent + INDENT, t);
4570       break;
4571     case TYPE_POINTER:
4572       printf ("%*cp:\n", indent + INDENT, ' ');
4573       dump_type (indent + INDENT, t->u.p);
4574       break;
4575     case TYPE_ARRAY:
4576       dump_type_u_a (indent + INDENT, t);
4577       break;
4578     case TYPE_PARAM_STRUCT:
4579       dump_type_u_param_struct (indent + INDENT, t);
4580       break;
4581     default:
4582       gcc_unreachable ();
4583     }
4584   printf ("%*cEnd of type at %p\n", indent, ' ', (void *) t);
4585 }
4586
4587 /* Dumps the pair P.  */
4588
4589 static void
4590 dump_pair (int indent, pair_p p)
4591 {
4592   printf ("%*cpair: name = %s\n", indent, ' ', p->name);
4593   dump_type (indent, p->type);
4594   dump_fileloc (indent, p->line);
4595   dump_options (indent, p->opt);
4596   printf ("%*cEnd of pair %s\n", indent, ' ', p->name);
4597 }
4598
4599 /* Dumps the list of pairs PP.  */
4600
4601 static void
4602 dump_pair_list (const char *name, pair_p pp)
4603 {
4604   pair_p p;
4605   printf ("%s:\n", name);
4606   for (p = pp; p != NULL; p = p->next)
4607     dump_pair (0, p);
4608   printf ("End of %s\n\n", name);
4609 }
4610
4611 /* Dumps the STRUCTURES.  */
4612
4613 static void
4614 dump_structures (const char *name, type_p structures)
4615 {
4616   printf ("%s:\n", name);
4617   dump_type_list (0, structures);
4618   printf ("End of %s\n\n", name);
4619 }
4620
4621 /* Dumps the internal structures of gengtype.  This is useful to debug
4622    gengtype itself, or to understand what it does, e.g. for plugin
4623    developers.  */
4624
4625 static void
4626 dump_everything (void)
4627 {
4628   seen_types = htab_create (100, htab_hash_pointer, htab_eq_pointer, NULL);
4629   dump_pair_list ("typedefs", typedefs);
4630   dump_structures ("structures", structures);
4631   dump_structures ("param_structs", param_structs);
4632   dump_pair_list ("variables", variables);
4633   htab_delete (seen_types);
4634 }
4635 \f
4636
4637
4638 /* Option specification for getopt_long.  */
4639 static const struct option gengtype_long_options[] = {
4640   {"help", no_argument, NULL, 'h'},
4641   {"version", no_argument, NULL, 'V'},
4642   {"verbose", no_argument, NULL, 'v'},
4643   {"dump", no_argument, NULL, 'd'},
4644   {"debug", no_argument, NULL, 'D'},
4645   {"plugin", required_argument, NULL, 'P'},
4646   {"srcdir", required_argument, NULL, 'S'},
4647   {"backupdir", required_argument, NULL, 'B'},
4648   {"inputs", required_argument, NULL, 'I'},
4649   {"read-state", required_argument, NULL, 'r'},
4650   {"write-state", required_argument, NULL, 'w'},
4651   /* Terminating NULL placeholder.  */
4652   {NULL, no_argument, NULL, 0},
4653 };
4654
4655
4656 static void
4657 print_usage (void)
4658 {
4659   printf ("Usage: %s\n", progname);
4660   printf ("\t -h | --help " " \t# Give this help.\n");
4661   printf ("\t -D | --debug "
4662           " \t# Give debug output to debug %s itself.\n", progname);
4663   printf ("\t -V | --version " " \t# Give version information.\n");
4664   printf ("\t -v | --verbose  \t# Increase verbosity.  Can be given several times.\n");
4665   printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
4666   printf ("\t -P | --plugin <output-file> <plugin-src> ... "
4667           " \t# Generate for plugin.\n");
4668   printf ("\t -S | --srcdir <GCC-directory> "
4669           " \t# Specify the GCC source directory.\n");
4670   printf ("\t -B | --backupdir <directory> "
4671           " \t# Specify the backup directory for updated files.\n");
4672   printf ("\t -I | --inputs <input-list> "
4673           " \t# Specify the file with source files list.\n");
4674   printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
4675   printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
4676 }
4677
4678 static void
4679 print_version (void)
4680 {
4681   printf ("%s %s%s\n", progname, pkgversion_string, version_string);
4682   printf ("Report bugs: %s\n", bug_report_url);
4683 }
4684
4685 /* Parse the program options using getopt_long... */
4686 static void
4687 parse_program_options (int argc, char **argv)
4688 {
4689   int opt = -1;
4690   while ((opt = getopt_long (argc, argv, "hVvdP:S:B:I:w:r:D",
4691                              gengtype_long_options, NULL)) >= 0)
4692     {
4693       switch (opt)
4694         {
4695         case 'h':               /* --help */
4696           print_usage ();
4697           break;
4698         case 'V':               /* --version */
4699           print_version ();
4700           break;
4701         case 'd':               /* --dump */
4702           do_dump = 1;
4703           break;
4704         case 'D':               /* --debug */
4705           do_debug = 1;
4706           break;
4707         case 'v':               /* --verbose */
4708           verbosity_level++;
4709           break;
4710         case 'P':               /* --plugin */
4711           if (optarg)
4712             plugin_output_filename = optarg;
4713           else
4714             fatal ("missing plugin output file name");
4715           break;
4716         case 'S':               /* --srcdir */
4717           if (optarg)
4718             srcdir = optarg;
4719           else
4720             fatal ("missing source directory");
4721           srcdir_len = strlen (srcdir);
4722           break;
4723         case 'B':               /* --backupdir */
4724           if (optarg)
4725             backup_dir = optarg;
4726           else
4727             fatal ("missing backup directory");
4728           break;
4729         case 'I':               /* --inputs */
4730           if (optarg)
4731             inputlist = optarg;
4732           else
4733             fatal ("missing input list");
4734           break;
4735         case 'r':               /* --read-state */
4736           if (optarg)
4737             read_state_filename = optarg;
4738           else
4739             fatal ("missing read state file");
4740           DBGPRINTF ("read state %s\n", optarg);
4741           break;
4742         case 'w':               /* --write-state */
4743           DBGPRINTF ("write state %s\n", optarg);
4744           if (optarg)
4745             write_state_filename = optarg;
4746           else
4747             fatal ("missing write state file");
4748           break;
4749         default:
4750           fprintf (stderr, "%s: unknown flag '%c'\n", progname, opt);
4751           print_usage ();
4752           fatal ("unexpected flag");
4753         }
4754     };
4755   if (plugin_output_filename)
4756     {
4757       /* In plugin mode we require some input files.  */
4758       int i = 0;
4759       if (optind >= argc)
4760         fatal ("no source files given in plugin mode");
4761       nb_plugin_files = argc - optind;
4762       plugin_files = XNEWVEC (input_file*, nb_plugin_files);
4763       for (i = 0; i < (int) nb_plugin_files; i++)
4764         {
4765           char *name = argv[i + optind];
4766           plugin_files[i] = input_file_by_name (name);
4767         }
4768     }
4769 }
4770
4771
4772 \f
4773 /******* Manage input files.  ******/
4774
4775 /* Hash table of unique input file names.  */
4776 static htab_t input_file_htab;
4777
4778 /* Find or allocate a new input_file by hash-consing it.  */
4779 input_file*
4780 input_file_by_name (const char* name)
4781 {
4782   PTR* slot;
4783   input_file* f = NULL;
4784   int namlen = 0;
4785   if (!name)
4786     return NULL;
4787   namlen = strlen (name);
4788   f = XCNEWVAR (input_file, sizeof (input_file)+namlen+2);
4789   f->inpbitmap = 0;
4790   f->inpoutf = NULL;
4791   strcpy (f->inpname, name);
4792   slot = htab_find_slot (input_file_htab, f, INSERT);
4793   gcc_assert (slot != NULL);
4794   if (*slot)
4795     {
4796       /* Already known input file.  */
4797       free (f);
4798       return (input_file*)(*slot);
4799     }
4800   /* New input file.  */
4801   *slot = f;
4802   return f;
4803     }
4804
4805 /* Hash table support routines for input_file-s.  */
4806 static hashval_t
4807 htab_hash_inputfile (const void *p)
4808 {
4809   const input_file *inpf = (const input_file *) p;
4810   gcc_assert (inpf);
4811   return htab_hash_string (get_input_file_name (inpf));
4812 }
4813
4814 static int
4815 htab_eq_inputfile (const void *x, const void *y)
4816 {
4817   const input_file *inpfx = (const input_file *) x;
4818   const input_file *inpfy = (const input_file *) y;
4819   gcc_assert (inpfx != NULL && inpfy != NULL);
4820   return !strcmp (get_input_file_name (inpfx), get_input_file_name (inpfy));
4821 }
4822
4823
4824 int
4825 main (int argc, char **argv)
4826 {
4827   size_t i;
4828   static struct fileloc pos = { NULL, 0 };
4829   outf_p output_header;
4830
4831   /* Mandatory common initializations.  */
4832   progname = "gengtype";        /* For fatal and messages.  */
4833   /* Create the hash-table used to hash-cons input files.  */
4834   input_file_htab =
4835     htab_create (800, htab_hash_inputfile, htab_eq_inputfile, NULL);
4836   /* Initialize our special input files.  */
4837   this_file = input_file_by_name (__FILE__);
4838   system_h_file = input_file_by_name ("system.h");
4839   /* Set the scalar_is_char union number for predefined scalar types.  */
4840   scalar_nonchar.u.scalar_is_char = FALSE;
4841   scalar_char.u.scalar_is_char = TRUE;
4842
4843   parse_program_options (argc, argv);
4844
4845 #if ENABLE_CHECKING
4846   if (do_debug)
4847     {
4848       time_t now = (time_t) 0;
4849       time (&now);
4850       DBGPRINTF ("gengtype started pid %d at %s",
4851                  (int) getpid (), ctime (&now));
4852     }
4853 #endif  /* ENABLE_CHECKING */
4854
4855   /* Parse the input list and the input files.  */
4856   DBGPRINTF ("inputlist %s", inputlist);
4857   if (read_state_filename)
4858     {
4859       if (inputlist)
4860         fatal ("input list %s cannot be given with a read state file %s",
4861                inputlist, read_state_filename);
4862       read_state (read_state_filename);
4863       DBGPRINT_COUNT_TYPE ("structures after read_state", structures);
4864       DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs);
4865     }
4866   else if (inputlist)
4867     {
4868       /* These types are set up with #define or else outside of where
4869          we can see them.  We should initialize them before calling
4870          read_input_list.  */
4871 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
4872         Call;} while(0)
4873       POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos));
4874       POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos));
4875       POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos));
4876       POS_HERE (do_scalar_typedef ("double_int", &pos));
4877       POS_HERE (do_scalar_typedef ("uint64_t", &pos));
4878       POS_HERE (do_scalar_typedef ("uint8", &pos));
4879       POS_HERE (do_scalar_typedef ("jword", &pos));
4880       POS_HERE (do_scalar_typedef ("JCF_u2", &pos));
4881       POS_HERE (do_scalar_typedef ("void", &pos));
4882       POS_HERE (do_typedef ("PTR",
4883                             create_pointer (resolve_typedef ("void", &pos)),
4884                             &pos));
4885 #undef POS_HERE
4886       read_input_list (inputlist);
4887       for (i = 0; i < num_gt_files; i++)
4888         {
4889           parse_file (get_input_file_name (gt_files[i]));
4890           DBGPRINTF ("parsed file #%d %s",
4891                      (int) i, get_input_file_name (gt_files[i]));
4892         }
4893       if (verbosity_level >= 1)
4894         printf ("%s parsed %d files with %d GTY types\n",
4895                 progname, (int) num_gt_files, type_count);
4896
4897       DBGPRINT_COUNT_TYPE ("structures after parsing", structures);
4898       DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs);
4899
4900     }
4901   else
4902     fatal ("either an input list or a read state file should be given");
4903   if (hit_error)
4904     return 1;
4905
4906
4907   if (plugin_output_filename)
4908     {
4909       size_t ix = 0;
4910       /* In plugin mode, we should have read a state file, and have
4911          given at least one plugin file.  */
4912       if (!read_state_filename)
4913         fatal ("No read state given in plugin mode for %s",
4914                plugin_output_filename);
4915
4916       if (nb_plugin_files == 0 || !plugin_files)
4917         fatal ("No plugin files given in plugin mode for %s",
4918                plugin_output_filename);
4919
4920       /* Parse our plugin files and augment the state.  */
4921       for (ix = 0; ix < nb_plugin_files; ix++)
4922         parse_file (get_input_file_name (plugin_files[ix]));
4923
4924       if (hit_error)
4925         return 1;
4926
4927       plugin_output = create_file ("GCC", plugin_output_filename);
4928       DBGPRINTF ("created plugin_output %p named %s",
4929                  (void *) plugin_output, plugin_output->name);
4930     }
4931   else
4932     {                           /* No plugin files, we are in normal mode.  */
4933       if (!srcdir)
4934         fatal ("gengtype needs a source directory in normal mode");
4935     }
4936   if (hit_error)
4937     return 1;
4938
4939   gen_rtx_next ();
4940
4941   /* The call to set_gc_used may indirectly call find_param_structure
4942      hence enlarge the param_structs list of types.  */
4943   set_gc_used (variables);
4944
4945  /* The state at this point is read from the state input file or by
4946     parsing source files and optionally augmented by parsing plugin
4947     source files.  Write it now.  */
4948   if (write_state_filename)
4949     {
4950       DBGPRINT_COUNT_TYPE ("structures before write_state", structures);
4951       DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs);
4952
4953       if (hit_error)
4954         fatal ("didn't write state file %s after errors",
4955                write_state_filename);
4956
4957       DBGPRINTF ("before write_state %s", write_state_filename);
4958       write_state (write_state_filename);
4959
4960       if (do_dump)
4961         dump_everything ();
4962
4963       /* After having written the state file we return immediately to
4964          avoid generating any output file.  */
4965       if (hit_error)
4966         return 1;
4967       else
4968         return 0;
4969     }
4970
4971
4972   open_base_files ();
4973
4974   write_enum_defn (structures, param_structs);
4975   write_typed_alloc_defns (structures, typedefs);
4976   output_header = plugin_output ? plugin_output : header_file;
4977   DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
4978                        structures);
4979   DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
4980                        param_structs);
4981
4982   write_types (output_header, structures, param_structs, &ggc_wtd);
4983   if (plugin_files == NULL)
4984     {
4985       DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
4986                            structures);
4987       DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
4988                            param_structs);
4989       write_types (header_file, structures, param_structs, &pch_wtd);
4990       write_local (header_file, structures, param_structs);
4991     }
4992   write_splay_tree_allocators (param_structs);
4993   write_roots (variables, plugin_files == NULL);
4994   write_rtx_next ();
4995   close_output_files ();
4996
4997   if (do_dump)
4998     dump_everything ();
4999
5000   /* Don't bother about free-ing any input or plugin file, etc.  */
5001
5002   if (hit_error)
5003     return 1;
5004   return 0;
5005 }