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   struct pair newv;
3598   /* If the field reference is relative to V, rather than to some
3599      subcomponent of V, we can mark any subarrays with a single stride.
3600      We're effectively treating the field as a global variable in its
3601      own right.  */
3602   if (v && type == v->type)
3603     {
3604       newv = *v;
3605       newv.type = field_type;
3606       newv.name = ACONCAT ((v->name, ".", field_name, NULL));
3607       v = &newv;
3608     }
3609   /* Otherwise, any arrays nested in the structure are too complex to
3610      handle.  */
3611   else if (field_type->kind == TYPE_ARRAY)
3612     v = NULL;
3613   write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)),
3614               has_length, line, if_marked, emit_pch);
3615 }
3616
3617 /* Write out to F the table entry and any marker routines needed to
3618    mark NAME as TYPE.  V can be one of three values:
3619
3620      - null, if NAME is too complex to represent using a single
3621        count and stride.  In this case, it is an error for NAME to
3622        contain any gc-ed data.
3623
3624      - the outermost array that contains NAME, if NAME is part of an array.
3625
3626      - the C variable that contains NAME, if NAME is not part of an array.
3627
3628    LINE is the line of the C source that declares the root variable.
3629    HAS_LENGTH is nonzero iff V was a variable-length array.  IF_MARKED
3630    is nonzero iff we are building the root table for hash table caches.  */
3631
3632 static void
3633 write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length,
3634             struct fileloc *line, const char *if_marked, bool emit_pch)
3635 {
3636   switch (type->kind)
3637     {
3638     case TYPE_STRUCT:
3639       {
3640         pair_p fld;
3641         for (fld = type->u.s.fields; fld; fld = fld->next)
3642           {
3643             int skip_p = 0;
3644             const char *desc = NULL;
3645             options_p o;
3646
3647             for (o = fld->opt; o; o = o->next)
3648               if (strcmp (o->name, "skip") == 0)
3649                 skip_p = 1;
3650               else if (strcmp (o->name, "desc") == 0
3651                        && o->kind == OPTION_STRING)
3652                 desc = o->info.string;
3653               else if (strcmp (o->name, "param_is") == 0)
3654                 ;
3655               else
3656                 error_at_line (line,
3657                                "field `%s' of global `%s' has unknown option `%s'",
3658                                fld->name, name, o->name);
3659
3660             if (skip_p)
3661               continue;
3662             else if (desc && fld->type->kind == TYPE_UNION)
3663               {
3664                 pair_p validf = NULL;
3665                 pair_p ufld;
3666
3667                 for (ufld = fld->type->u.s.fields; ufld; ufld = ufld->next)
3668                   {
3669                     const char *tag = NULL;
3670                     options_p oo;
3671                     for (oo = ufld->opt; oo; oo = oo->next)
3672                       if (strcmp (oo->name, "tag") == 0
3673                           && oo->kind == OPTION_STRING)
3674                         tag = oo->info.string;
3675                     if (tag == NULL || strcmp (tag, desc) != 0)
3676                       continue;
3677                     if (validf != NULL)
3678                       error_at_line (line,
3679                                      "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
3680                                      name, fld->name, validf->name,
3681                                      name, fld->name, ufld->name, tag);
3682                     validf = ufld;
3683                   }
3684                 if (validf != NULL)
3685                   write_field_root (f, v, type, name, 0, line, if_marked,
3686                                     emit_pch, validf->type,
3687                                     ACONCAT ((fld->name, ".",
3688                                               validf->name, NULL)));
3689               }
3690             else if (desc)
3691               error_at_line (line,
3692                              "global `%s.%s' has `desc' option but is not union",
3693                              name, fld->name);
3694             else
3695               write_field_root (f, v, type, name, 0, line, if_marked,
3696                                 emit_pch, fld->type, fld->name);
3697           }
3698       }
3699       break;
3700
3701     case TYPE_ARRAY:
3702       {
3703         char *newname;
3704         newname = xasprintf ("%s[0]", name);
3705         write_root (f, v, type->u.a.p, newname, has_length, line, if_marked,
3706                     emit_pch);
3707         free (newname);
3708       }
3709       break;
3710
3711     case TYPE_POINTER:
3712       {
3713         type_p tp;
3714
3715         if (!start_root_entry (f, v, name, line))
3716           return;
3717
3718         tp = type->u.p;
3719
3720         if (!has_length && UNION_OR_STRUCT_P (tp))
3721           {
3722             oprintf (f, "    &gt_ggc_mx_%s,\n", tp->u.s.tag);
3723             if (emit_pch)
3724               oprintf (f, "    &gt_pch_nx_%s", tp->u.s.tag);
3725             else
3726               oprintf (f, "    NULL");
3727           }
3728         else if (!has_length && tp->kind == TYPE_PARAM_STRUCT)
3729           {
3730             oprintf (f, "    &gt_ggc_m_");
3731             output_mangled_typename (f, tp);
3732             if (emit_pch)
3733               {
3734                 oprintf (f, ",\n    &gt_pch_n_");
3735                 output_mangled_typename (f, tp);
3736               }
3737             else
3738               oprintf (f, ",\n    NULL");
3739           }
3740         else if (has_length
3741                  && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp)))
3742           {
3743             oprintf (f, "    &gt_ggc_ma_%s,\n", name);
3744             if (emit_pch)
3745               oprintf (f, "    &gt_pch_na_%s", name);
3746             else
3747               oprintf (f, "    NULL");
3748           }
3749         else
3750           {
3751             error_at_line (line,
3752                            "global `%s' is pointer to unimplemented type",
3753                            name);
3754           }
3755         if (if_marked)
3756           oprintf (f, ",\n    &%s", if_marked);
3757         oprintf (f, "\n  },\n");
3758       }
3759       break;
3760
3761     case TYPE_STRING:
3762       {
3763         if (!start_root_entry (f, v, name, line))
3764           return;
3765
3766         oprintf (f, "    (gt_pointer_walker) &gt_ggc_m_S,\n");
3767         oprintf (f, "    (gt_pointer_walker) &gt_pch_n_S\n");
3768         oprintf (f, "  },\n");
3769       }
3770       break;
3771
3772     case TYPE_SCALAR:
3773       break;
3774
3775     default:
3776       error_at_line (line, "global `%s' is unimplemented type", name);
3777     }
3778 }
3779
3780 /* This generates a routine to walk an array.  */
3781
3782 static void
3783 write_array (outf_p f, pair_p v, const struct write_types_data *wtd)
3784 {
3785   struct walk_type_data d;
3786   char *prevval3;
3787
3788   memset (&d, 0, sizeof (d));
3789   d.of = f;
3790   d.cookie = wtd;
3791   d.indent = 2;
3792   d.line = &v->line;
3793   d.opt = v->opt;
3794   d.bitmap = get_lang_bitmap (v->line.file);
3795   d.param = NULL;
3796
3797   d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
3798
3799   if (wtd->param_prefix)
3800     {
3801       oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
3802       oprintf (f, "    (void *, void *, gt_pointer_operator, void *);\n");
3803       oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
3804                wtd->param_prefix, v->name);
3805       oprintf (d.of,
3806                "      ATTRIBUTE_UNUSED void *x_p,\n"
3807                "      ATTRIBUTE_UNUSED gt_pointer_operator op,\n"
3808                "      ATTRIBUTE_UNUSED void * cookie)\n");
3809       oprintf (d.of, "{\n");
3810       d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3811       d.process_field = write_types_local_process_field;
3812       walk_type (v->type, &d);
3813       oprintf (f, "}\n\n");
3814     }
3815
3816   d.opt = v->opt;
3817   oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name);
3818   oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
3819            wtd->prefix, v->name);
3820   oprintf (f, "{\n");
3821   d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name;
3822   d.process_field = write_types_process_field;
3823   walk_type (v->type, &d);
3824   free (prevval3);
3825   oprintf (f, "}\n\n");
3826 }
3827
3828 /* Output a table describing the locations and types of VARIABLES.  */
3829
3830 static void
3831 write_roots (pair_p variables, bool emit_pch)
3832 {
3833   pair_p v;
3834   struct flist *flp = NULL;
3835
3836   for (v = variables; v; v = v->next)
3837     {
3838       outf_p f =
3839         get_output_file_with_visibility (CONST_CAST (input_file*,
3840                                                      v->line.file));
3841       struct flist *fli;
3842       const char *length = NULL;
3843       int deletable_p = 0;
3844       options_p o;
3845       for (o = v->opt; o; o = o->next)
3846         if (strcmp (o->name, "length") == 0
3847             && o->kind == OPTION_STRING)
3848           length = o->info.string;
3849         else if (strcmp (o->name, "deletable") == 0)
3850           deletable_p = 1;
3851         else if (strcmp (o->name, "param_is") == 0)
3852           ;
3853         else if (strncmp (o->name, "param", 5) == 0
3854                  && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0)
3855           ;
3856         else if (strcmp (o->name, "if_marked") == 0)
3857           ;
3858         else
3859           error_at_line (&v->line,
3860                          "global `%s' has unknown option `%s'",
3861                          v->name, o->name);
3862
3863       for (fli = flp; fli; fli = fli->next)
3864         if (fli->f == f && f)
3865           break;
3866       if (fli == NULL)
3867         {
3868           fli = XNEW (struct flist);
3869           fli->f = f;
3870           fli->next = flp;
3871           fli->started_p = 0;
3872           fli->file = v->line.file;
3873           gcc_assert (fli->file);
3874           flp = fli;
3875
3876           oprintf (f, "\n/* GC roots.  */\n\n");
3877         }
3878
3879       if (!deletable_p
3880           && length
3881           && v->type->kind == TYPE_POINTER
3882           && (v->type->u.p->kind == TYPE_POINTER
3883               || v->type->u.p->kind == TYPE_STRUCT))
3884         {
3885           write_array (f, v, &ggc_wtd);
3886           write_array (f, v, &pch_wtd);
3887         }
3888     }
3889
3890   for (v = variables; v; v = v->next)
3891     {
3892       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
3893                                                               v->line.file));
3894       struct flist *fli;
3895       int skip_p = 0;
3896       int length_p = 0;
3897       options_p o;
3898
3899       for (o = v->opt; o; o = o->next)
3900         if (strcmp (o->name, "length") == 0)
3901           length_p = 1;
3902         else if (strcmp (o->name, "deletable") == 0
3903                  || strcmp (o->name, "if_marked") == 0)
3904           skip_p = 1;
3905
3906       if (skip_p)
3907         continue;
3908
3909       for (fli = flp; fli; fli = fli->next)
3910         if (fli->f == f)
3911           break;
3912       if (!fli->started_p)
3913         {
3914           fli->started_p = 1;
3915
3916           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_");
3917           put_mangled_filename (f, v->line.file);
3918           oprintf (f, "[] = {\n");
3919         }
3920
3921       write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
3922     }
3923
3924   finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3925                      "gt_ggc_rtab");
3926
3927   for (v = variables; v; v = v->next)
3928     {
3929       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
3930                                                               v->line.file));
3931       struct flist *fli;
3932       int skip_p = 1;
3933       options_p o;
3934
3935       for (o = v->opt; o; o = o->next)
3936         if (strcmp (o->name, "deletable") == 0)
3937           skip_p = 0;
3938         else if (strcmp (o->name, "if_marked") == 0)
3939           skip_p = 1;
3940
3941       if (skip_p)
3942         continue;
3943
3944       for (fli = flp; fli; fli = fli->next)
3945         if (fli->f == f)
3946           break;
3947       if (!fli->started_p)
3948         {
3949           fli->started_p = 1;
3950
3951           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_");
3952           put_mangled_filename (f, v->line.file);
3953           oprintf (f, "[] = {\n");
3954         }
3955
3956       oprintf (f, "  { &%s, 1, sizeof (%s), NULL, NULL },\n",
3957                v->name, v->name);
3958     }
3959
3960   finish_root_table (flp, "ggc_rd", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
3961                      "gt_ggc_deletable_rtab");
3962
3963   for (v = variables; v; v = v->next)
3964     {
3965       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
3966                                                               v->line.file));
3967       struct flist *fli;
3968       const char *if_marked = NULL;
3969       int length_p = 0;
3970       options_p o;
3971
3972       for (o = v->opt; o; o = o->next)
3973         if (strcmp (o->name, "length") == 0)
3974           length_p = 1;
3975         else if (strcmp (o->name, "if_marked") == 0
3976                        && o->kind == OPTION_STRING)
3977           if_marked = o->info.string;
3978        if (if_marked == NULL)
3979         continue;
3980       if (v->type->kind != TYPE_POINTER
3981           || v->type->u.p->kind != TYPE_PARAM_STRUCT
3982           || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0))
3983         {
3984           error_at_line (&v->line,
3985                          "if_marked option used but not hash table");
3986           continue;
3987         }
3988
3989       for (fli = flp; fli; fli = fli->next)
3990         if (fli->f == f)
3991           break;
3992       if (!fli->started_p)
3993         {
3994           fli->started_p = 1;
3995
3996           oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
3997           put_mangled_filename (f, v->line.file);
3998           oprintf (f, "[] = {\n");
3999         }
4000
4001       write_root (f, v, v->type->u.p->u.param_struct.param[0],
4002                   v->name, length_p, &v->line, if_marked, emit_pch);
4003     }
4004
4005   finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
4006                      "gt_ggc_cache_rtab");
4007
4008   if (!emit_pch)
4009     return;
4010
4011   for (v = variables; v; v = v->next)
4012     {
4013       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4014                                                               v->line.file));
4015       struct flist *fli;
4016       int length_p = 0;
4017       int if_marked_p = 0;
4018       options_p o;
4019
4020       for (o = v->opt; o; o = o->next)
4021         if (strcmp (o->name, "length") == 0)
4022           length_p = 1;
4023         else if (strcmp (o->name, "if_marked") == 0)
4024           if_marked_p = 1;
4025
4026       if (!if_marked_p)
4027         continue;
4028
4029       for (fli = flp; fli; fli = fli->next)
4030         if (fli->f == f)
4031           break;
4032       if (!fli->started_p)
4033         {
4034           fli->started_p = 1;
4035
4036           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_");
4037           put_mangled_filename (f, v->line.file);
4038           oprintf (f, "[] = {\n");
4039         }
4040
4041       write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
4042     }
4043
4044   finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4045                      "gt_pch_cache_rtab");
4046
4047   for (v = variables; v; v = v->next)
4048     {
4049       outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
4050                                                               v->line.file));
4051       struct flist *fli;
4052       int skip_p = 0;
4053       options_p o;
4054
4055       for (o = v->opt; o; o = o->next)
4056         if (strcmp (o->name, "deletable") == 0
4057             || strcmp (o->name, "if_marked") == 0)
4058           skip_p = 1;
4059
4060       if (skip_p)
4061         continue;
4062
4063       if (!contains_scalar_p (v->type))
4064         continue;
4065
4066       for (fli = flp; fli; fli = fli->next)
4067         if (fli->f == f)
4068           break;
4069       if (!fli->started_p)
4070         {
4071           fli->started_p = 1;
4072
4073           oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_");
4074           put_mangled_filename (f, v->line.file);
4075           oprintf (f, "[] = {\n");
4076         }
4077
4078       oprintf (f, "  { &%s, 1, sizeof (%s), NULL, NULL },\n",
4079                v->name, v->name);
4080     }
4081
4082   finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
4083                      "gt_pch_scalar_rtab");
4084 }
4085
4086 /* Record the definition of a generic VEC structure, as if we had expanded
4087    the macros in vec.h:
4088
4089    typedef struct VEC_<type>_base GTY(()) {
4090    unsigned num;
4091    unsigned alloc;
4092    <type> GTY((length ("%h.num"))) vec[1];
4093    } VEC_<type>_base
4094
4095    where the GTY(()) tags are only present if is_scalar is _false_.  */
4096
4097 void
4098 note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos)
4099 {
4100   pair_p fields;
4101   type_p t;
4102   options_p o;
4103   type_p len_ty = create_scalar_type ("unsigned");
4104   const char *name = concat ("VEC_", type_name, "_base", (char *) 0);
4105
4106   if (is_scalar)
4107     {
4108       t = create_scalar_type (type_name);
4109       o = 0;
4110     }
4111   else
4112     {
4113       t = resolve_typedef (type_name, pos);
4114       o = create_string_option (0, "length", "%h.num");
4115     }
4116   /* We assemble the field list in reverse order.  */
4117   fields = create_field_at (0, create_array (t, "1"), "vec", o, pos);
4118   fields = create_field_at (fields, len_ty, "alloc", 0, pos);
4119   fields = create_field_at (fields, len_ty, "num", 0, pos);
4120
4121   do_typedef (name, new_structure (name, 0, pos, fields, 0), pos);
4122 }
4123
4124 /* Record the definition of an allocation-specific VEC structure, as if
4125    we had expanded the macros in vec.h:
4126
4127    typedef struct VEC_<type>_<astrat> {
4128      VEC_<type>_base base;
4129    } VEC_<type>_<astrat>;
4130 */
4131 void
4132 note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos)
4133 {
4134   const char *astratname = concat ("VEC_", type, "_", astrat, (char *) 0);
4135   const char *basename = concat ("VEC_", type, "_base", (char *) 0);
4136
4137   pair_p field = create_field_at (0, resolve_typedef (basename, pos),
4138                                   "base", 0, pos);
4139
4140   do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos);
4141 }
4142
4143 /* Returns the specifier keyword for a string or union type S, empty string
4144    otherwise.  */
4145
4146 static const char *
4147 get_type_specifier (const type_p s)
4148 {
4149   if (s->kind == TYPE_STRUCT || s->kind == TYPE_LANG_STRUCT)
4150     return "struct ";
4151   if (s->kind == TYPE_UNION)
4152     return "union ";
4153   return "";
4154 }
4155
4156 /* TRUE if type S has the GTY variable_size annotation.  */
4157
4158 static bool
4159 variable_size_p (const type_p s)
4160 {
4161   options_p o;
4162   for (o = s->u.s.opt; o; o = o->next)
4163     if (strcmp (o->name, "variable_size") == 0)
4164       return true;
4165   return false;
4166 }
4167
4168 enum alloc_quantity
4169 { single, vector };
4170 enum alloc_zone
4171 { any_zone, specific_zone };
4172
4173 /* Writes one typed allocator definition for type identifier TYPE_NAME with
4174    optional type specifier TYPE_SPECIFIER.  The allocator name will contain
4175    ALLOCATOR_TYPE.  If VARIABLE_SIZE is true, the allocator will have an extra
4176    parameter specifying number of bytes to allocate.  If QUANTITY is set to
4177    VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
4178    the allocator will be zone-specific.  */
4179
4180 static void
4181 write_typed_alloc_def (bool variable_size, const char *type_specifier,
4182                        const char *type_name, const char *allocator_type,
4183                        enum alloc_quantity quantity, enum alloc_zone zone)
4184 {
4185   bool two_args = variable_size && (quantity == vector);
4186   bool third_arg = ((zone == specific_zone)
4187                     && (variable_size || (quantity == vector)));
4188
4189   oprintf (header_file, "#define ggc_alloc_%s%s", allocator_type, type_name);
4190   oprintf (header_file, "(%s%s%s%s%s) ",
4191            (variable_size ? "SIZE" : ""),
4192            (two_args ? ", " : ""),
4193            (quantity == vector) ? "n" : "",
4194            (third_arg ? ", " : ""), (zone == specific_zone) ? "z" : "");
4195   oprintf (header_file, "((%s%s *)", type_specifier, type_name);
4196   oprintf (header_file, "(ggc_internal_%salloc_stat (", allocator_type);
4197   if (zone == specific_zone)
4198     oprintf (header_file, "z, ");
4199   if (variable_size)
4200     oprintf (header_file, "SIZE");
4201   else
4202     oprintf (header_file, "sizeof (%s%s)", type_specifier, type_name);
4203   if (quantity == vector)
4204     oprintf (header_file, ", n");
4205   oprintf (header_file, " MEM_STAT_INFO)))\n");
4206 }
4207
4208 /* Writes a typed allocator definition for a struct or union S.  */
4209
4210 static void
4211 write_typed_struct_alloc_def (const type_p s, const char *allocator_type,
4212                               enum alloc_quantity quantity,
4213                               enum alloc_zone zone)
4214 {
4215   write_typed_alloc_def (variable_size_p (s), get_type_specifier (s),
4216                          s->u.s.tag, allocator_type, quantity, zone);
4217 }
4218
4219 /* Writes a typed allocator definition for a typedef P.  */
4220
4221 static void
4222 write_typed_typedef_alloc_def (const pair_p p, const char *allocator_type,
4223                                enum alloc_quantity quantity,
4224                                enum alloc_zone zone)
4225 {
4226   write_typed_alloc_def (variable_size_p (p->type), "", p->name,
4227                          allocator_type, quantity, zone);
4228 }
4229
4230 /* Writes typed allocator definitions for the types in STRUCTURES and
4231    TYPEDEFS that are used by GC.  */
4232
4233 static void
4234 write_typed_alloc_defns (const type_p structures, const pair_p typedefs)
4235 {
4236   type_p s;
4237   pair_p p;
4238
4239   oprintf (header_file,
4240            "\n/* Allocators for known structs and unions.  */\n\n");
4241   for (s = structures; s; s = s->next)
4242     {
4243       if (!USED_BY_TYPED_GC_P (s))
4244         continue;
4245       write_typed_struct_alloc_def (s, "", single, any_zone);
4246       write_typed_struct_alloc_def (s, "cleared_", single, any_zone);
4247       write_typed_struct_alloc_def (s, "vec_", vector, any_zone);
4248       write_typed_struct_alloc_def (s, "cleared_vec_", vector, any_zone);
4249       write_typed_struct_alloc_def (s, "zone_", single, specific_zone);
4250       write_typed_struct_alloc_def (s, "zone_cleared_", single,
4251                                     specific_zone);
4252       write_typed_struct_alloc_def (s, "zone_vec_", vector, specific_zone);
4253       write_typed_struct_alloc_def (s, "zone_cleared_vec_", vector,
4254                                     specific_zone);
4255     }
4256
4257   oprintf (header_file, "\n/* Allocators for known typedefs.  */\n");
4258   for (p = typedefs; p; p = p->next)
4259     {
4260       s = p->type;
4261       if (!USED_BY_TYPED_GC_P (s) || (strcmp (p->name, s->u.s.tag) == 0))
4262         continue;
4263       write_typed_typedef_alloc_def (p, "", single, any_zone);
4264       write_typed_typedef_alloc_def (p, "cleared_", single, any_zone);
4265       write_typed_typedef_alloc_def (p, "vec_", vector, any_zone);
4266       write_typed_typedef_alloc_def (p, "cleared_vec_", vector, any_zone);
4267       write_typed_typedef_alloc_def (p, "zone_", single, specific_zone);
4268       write_typed_typedef_alloc_def (p, "zone_cleared_", single,
4269                                      specific_zone);
4270       write_typed_typedef_alloc_def (p, "zone_cleared_vec_", vector,
4271                                      specific_zone);
4272     }
4273 }
4274
4275 /* Prints not-as-ugly version of a typename of T to OF.  Trades the uniquness
4276    guaranteee for somewhat increased readability.  If name conflicts do happen,
4277    this funcion will have to be adjusted to be more like
4278    output_mangled_typename.  */
4279
4280 static void
4281 output_typename (outf_p of, const_type_p t)
4282 {
4283   switch (t->kind)
4284     {
4285     case TYPE_STRING:
4286       oprintf (of, "str");
4287       break;
4288     case TYPE_SCALAR:
4289       oprintf (of, "scalar");
4290       break;
4291     case TYPE_POINTER:
4292       output_typename (of, t->u.p);
4293       break;
4294     case TYPE_STRUCT:
4295     case TYPE_UNION:
4296     case TYPE_LANG_STRUCT:
4297       oprintf (of, "%s", t->u.s.tag);
4298       break;
4299     case TYPE_PARAM_STRUCT:
4300       {
4301         int i;
4302         for (i = 0; i < NUM_PARAM; i++)
4303           if (t->u.param_struct.param[i] != NULL)
4304             {
4305               output_typename (of, t->u.param_struct.param[i]);
4306               oprintf (of, "_");
4307             }
4308         output_typename (of, t->u.param_struct.stru);
4309         break;
4310       }
4311     default:
4312       gcc_unreachable ();
4313     }
4314 }
4315
4316 /* Writes a typed GC allocator for type S that is suitable as a callback for
4317    the splay tree implementation in libiberty.  */
4318
4319 static void
4320 write_splay_tree_allocator_def (const_type_p s)
4321 {
4322   outf_p of = get_output_file_with_visibility (NULL);
4323   oprintf (of, "void * ggc_alloc_splay_tree_");
4324   output_typename (of, s);
4325   oprintf (of, " (int sz, void * nl)\n");
4326   oprintf (of, "{\n");
4327   oprintf (of, "  return ggc_splay_alloc (");
4328   oprintf (of, "gt_e_");
4329   output_mangled_typename (of, s);
4330   oprintf (of, ", sz, nl);\n");
4331   oprintf (of, "}\n\n");
4332 }
4333
4334 /* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
4335    for the splay tree implementation in libiberty.  */
4336
4337 static void
4338 write_splay_tree_allocators (const_type_p param_structs)
4339 {
4340   const_type_p s;
4341
4342   oprintf (header_file, "\n/* Splay tree callback allocators.  */\n");
4343   for (s = param_structs; s; s = s->next)
4344     if (s->gc_used == GC_POINTED_TO)
4345       {
4346         oprintf (header_file, "extern void * ggc_alloc_splay_tree_");
4347         output_typename (header_file, s);
4348         oprintf (header_file, " (int, void *);\n");
4349         write_splay_tree_allocator_def (s);
4350       }
4351 }
4352
4353 static void dump_pair (int indent, pair_p p);
4354 static void dump_type (int indent, type_p p);
4355 static void dump_type_list (int indent, type_p p);
4356
4357 #define INDENT 2
4358
4359 /* Dumps the value of typekind KIND.  */
4360
4361 static void
4362 dump_typekind (int indent, enum typekind kind)
4363 {
4364   printf ("%*ckind = ", indent, ' ');
4365   switch (kind)
4366     {
4367     case TYPE_SCALAR:
4368       printf ("TYPE_SCALAR");
4369       break;
4370     case TYPE_STRING:
4371       printf ("TYPE_STRING");
4372       break;
4373     case TYPE_STRUCT:
4374       printf ("TYPE_STRUCT");
4375       break;
4376     case TYPE_UNION:
4377       printf ("TYPE_UNION");
4378       break;
4379     case TYPE_POINTER:
4380       printf ("TYPE_POINTER");
4381       break;
4382     case TYPE_ARRAY:
4383       printf ("TYPE_ARRAY");
4384       break;
4385     case TYPE_LANG_STRUCT:
4386       printf ("TYPE_LANG_STRUCT");
4387       break;
4388     case TYPE_PARAM_STRUCT:
4389       printf ("TYPE_PARAM_STRUCT");
4390       break;
4391     default:
4392       gcc_unreachable ();
4393     }
4394   printf ("\n");
4395 }
4396
4397 /* Dumps the value of GC_USED flag.  */
4398
4399 static void
4400 dump_gc_used (int indent, enum gc_used_enum gc_used)
4401 {
4402   printf ("%*cgc_used = ", indent, ' ');
4403   switch (gc_used)
4404     {
4405     case GC_UNUSED:
4406       printf ("GC_UNUSED");
4407       break;
4408     case GC_USED:
4409       printf ("GC_USED");
4410       break;
4411     case GC_MAYBE_POINTED_TO:
4412       printf ("GC_MAYBE_POINTED_TO");
4413       break;
4414     case GC_POINTED_TO:
4415       printf ("GC_POINTED_TO");
4416       break;
4417     default:
4418       gcc_unreachable ();
4419     }
4420   printf ("\n");
4421 }
4422
4423 /* Dumps the type options OPT.  */
4424
4425 static void
4426 dump_options (int indent, options_p opt)
4427 {
4428   options_p o;
4429   printf ("%*coptions = ", indent, ' ');
4430   o = opt;
4431   while (o)
4432     {
4433       switch (o->kind)
4434         {
4435         case OPTION_STRING:
4436           printf ("%s:string %s ", o->name, o->info.string);
4437           break;
4438         case OPTION_TYPE:
4439           printf ("%s:type ", o->name);
4440           dump_type (indent+1, o->info.type);
4441           break;
4442         case OPTION_NESTED:
4443           printf ("%s:nested ", o->name);
4444           break;
4445         case OPTION_NONE:
4446           gcc_unreachable ();
4447         }
4448       o = o->next;
4449     }
4450   printf ("\n");
4451 }
4452
4453 /* Dumps the source file location in LINE.  */
4454
4455 static void
4456 dump_fileloc (int indent, struct fileloc line)
4457 {
4458   printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ',
4459           get_input_file_name (line.file),
4460           line.line);
4461 }
4462
4463 /* Recursively dumps the struct, union, or a language-specific
4464    struct T.  */
4465
4466 static void
4467 dump_type_u_s (int indent, type_p t)
4468 {
4469   pair_p fields;
4470
4471   gcc_assert (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION
4472               || t->kind == TYPE_LANG_STRUCT);
4473   printf ("%*cu.s.tag = %s\n", indent, ' ', t->u.s.tag);
4474   dump_fileloc (indent, t->u.s.line);
4475   printf ("%*cu.s.fields =\n", indent, ' ');
4476   fields = t->u.s.fields;
4477   while (fields)
4478     {
4479       dump_pair (indent + INDENT, fields);
4480       fields = fields->next;
4481     }
4482   printf ("%*cend of fields of type %p\n", indent, ' ', (void *) t);
4483   dump_options (indent, t->u.s.opt);
4484   printf ("%*cu.s.bitmap = %X\n", indent, ' ', t->u.s.bitmap);
4485   if (t->kind == TYPE_LANG_STRUCT)
4486     {
4487       printf ("%*cu.s.lang_struct:\n", indent, ' ');
4488       dump_type_list (indent + INDENT, t->u.s.lang_struct);
4489     }
4490 }
4491
4492 /* Recursively dumps the array T.  */
4493
4494 static void
4495 dump_type_u_a (int indent, type_p t)
4496 {
4497   gcc_assert (t->kind == TYPE_ARRAY);
4498   printf ("%*clen = %s, u.a.p:\n", indent, ' ', t->u.a.len);
4499   dump_type_list (indent + INDENT, t->u.a.p);
4500 }
4501
4502 /* Recursively dumps the parameterized struct T.  */
4503
4504 static void
4505 dump_type_u_param_struct (int indent, type_p t)
4506 {
4507   int i;
4508   gcc_assert (t->kind == TYPE_PARAM_STRUCT);
4509   printf ("%*cu.param_struct.stru:\n", indent, ' ');
4510   dump_type_list (indent, t->u.param_struct.stru);
4511   dump_fileloc (indent, t->u.param_struct.line);
4512   for (i = 0; i < NUM_PARAM; i++)
4513     {
4514       if (t->u.param_struct.param[i] == NULL)
4515         continue;
4516       printf ("%*cu.param_struct.param[%d]:\n", indent, ' ', i);
4517       dump_type (indent + INDENT, t->u.param_struct.param[i]);
4518     }
4519 }
4520
4521 /* Recursively dumps the type list T.  */
4522
4523 static void
4524 dump_type_list (int indent, type_p t)
4525 {
4526   type_p p = t;
4527   while (p)
4528     {
4529       dump_type (indent, p);
4530       p = p->next;
4531     }
4532 }
4533
4534 static htab_t seen_types;
4535
4536 /* Recursively dumps the type T if it was not dumped previously.  */
4537
4538 static void
4539 dump_type (int indent, type_p t)
4540 {
4541   PTR *slot;
4542
4543   printf ("%*cType at %p: ", indent, ' ', (void *) t);
4544   slot = htab_find_slot (seen_types, t, INSERT);
4545   if (*slot != NULL)
4546     {
4547       printf ("already seen.\n");
4548       return;
4549     }
4550   *slot = t;
4551   printf ("\n");
4552
4553   dump_typekind (indent, t->kind);
4554   printf ("%*cpointer_to = %p\n", indent + INDENT, ' ',
4555           (void *) t->pointer_to);
4556   dump_gc_used (indent + INDENT, t->gc_used);
4557   switch (t->kind)
4558     {
4559     case TYPE_SCALAR:
4560       printf ("%*cscalar_is_char = %s\n", indent + INDENT, ' ',
4561               t->u.scalar_is_char ? "true" : "false");
4562       break;
4563     case TYPE_STRING:
4564       break;
4565     case TYPE_STRUCT:
4566     case TYPE_UNION:
4567     case TYPE_LANG_STRUCT:
4568       dump_type_u_s (indent + INDENT, t);
4569       break;
4570     case TYPE_POINTER:
4571       printf ("%*cp:\n", indent + INDENT, ' ');
4572       dump_type (indent + INDENT, t->u.p);
4573       break;
4574     case TYPE_ARRAY:
4575       dump_type_u_a (indent + INDENT, t);
4576       break;
4577     case TYPE_PARAM_STRUCT:
4578       dump_type_u_param_struct (indent + INDENT, t);
4579       break;
4580     default:
4581       gcc_unreachable ();
4582     }
4583   printf ("%*cEnd of type at %p\n", indent, ' ', (void *) t);
4584 }
4585
4586 /* Dumps the pair P.  */
4587
4588 static void
4589 dump_pair (int indent, pair_p p)
4590 {
4591   printf ("%*cpair: name = %s\n", indent, ' ', p->name);
4592   dump_type (indent, p->type);
4593   dump_fileloc (indent, p->line);
4594   dump_options (indent, p->opt);
4595   printf ("%*cEnd of pair %s\n", indent, ' ', p->name);
4596 }
4597
4598 /* Dumps the list of pairs PP.  */
4599
4600 static void
4601 dump_pair_list (const char *name, pair_p pp)
4602 {
4603   pair_p p;
4604   printf ("%s:\n", name);
4605   for (p = pp; p != NULL; p = p->next)
4606     dump_pair (0, p);
4607   printf ("End of %s\n\n", name);
4608 }
4609
4610 /* Dumps the STRUCTURES.  */
4611
4612 static void
4613 dump_structures (const char *name, type_p structures)
4614 {
4615   printf ("%s:\n", name);
4616   dump_type_list (0, structures);
4617   printf ("End of %s\n\n", name);
4618 }
4619
4620 /* Dumps the internal structures of gengtype.  This is useful to debug
4621    gengtype itself, or to understand what it does, e.g. for plugin
4622    developers.  */
4623
4624 static void
4625 dump_everything (void)
4626 {
4627   seen_types = htab_create (100, htab_hash_pointer, htab_eq_pointer, NULL);
4628   dump_pair_list ("typedefs", typedefs);
4629   dump_structures ("structures", structures);
4630   dump_structures ("param_structs", param_structs);
4631   dump_pair_list ("variables", variables);
4632   htab_delete (seen_types);
4633 }
4634 \f
4635
4636
4637 /* Option specification for getopt_long.  */
4638 static const struct option gengtype_long_options[] = {
4639   {"help", no_argument, NULL, 'h'},
4640   {"version", no_argument, NULL, 'V'},
4641   {"verbose", no_argument, NULL, 'v'},
4642   {"dump", no_argument, NULL, 'd'},
4643   {"debug", no_argument, NULL, 'D'},
4644   {"plugin", required_argument, NULL, 'P'},
4645   {"srcdir", required_argument, NULL, 'S'},
4646   {"backupdir", required_argument, NULL, 'B'},
4647   {"inputs", required_argument, NULL, 'I'},
4648   {"read-state", required_argument, NULL, 'r'},
4649   {"write-state", required_argument, NULL, 'w'},
4650   /* Terminating NULL placeholder.  */
4651   {NULL, no_argument, NULL, 0},
4652 };
4653
4654
4655 static void
4656 print_usage (void)
4657 {
4658   printf ("Usage: %s\n", progname);
4659   printf ("\t -h | --help " " \t# Give this help.\n");
4660   printf ("\t -D | --debug "
4661           " \t# Give debug output to debug %s itself.\n", progname);
4662   printf ("\t -V | --version " " \t# Give version information.\n");
4663   printf ("\t -v | --verbose  \t# Increase verbosity.  Can be given several times.\n");
4664   printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
4665   printf ("\t -P | --plugin <output-file> <plugin-src> ... "
4666           " \t# Generate for plugin.\n");
4667   printf ("\t -S | --srcdir <GCC-directory> "
4668           " \t# Specify the GCC source directory.\n");
4669   printf ("\t -B | --backupdir <directory> "
4670           " \t# Specify the backup directory for updated files.\n");
4671   printf ("\t -I | --inputs <input-list> "
4672           " \t# Specify the file with source files list.\n");
4673   printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
4674   printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
4675 }
4676
4677 static void
4678 print_version (void)
4679 {
4680   printf ("%s %s%s\n", progname, pkgversion_string, version_string);
4681   printf ("Report bugs: %s\n", bug_report_url);
4682 }
4683
4684 /* Parse the program options using getopt_long... */
4685 static void
4686 parse_program_options (int argc, char **argv)
4687 {
4688   int opt = -1;
4689   while ((opt = getopt_long (argc, argv, "hVvdP:S:B:I:w:r:D",
4690                              gengtype_long_options, NULL)) >= 0)
4691     {
4692       switch (opt)
4693         {
4694         case 'h':               /* --help */
4695           print_usage ();
4696           break;
4697         case 'V':               /* --version */
4698           print_version ();
4699           break;
4700         case 'd':               /* --dump */
4701           do_dump = 1;
4702           break;
4703         case 'D':               /* --debug */
4704           do_debug = 1;
4705           break;
4706         case 'v':               /* --verbose */
4707           verbosity_level++;
4708           break;
4709         case 'P':               /* --plugin */
4710           if (optarg)
4711             plugin_output_filename = optarg;
4712           else
4713             fatal ("missing plugin output file name");
4714           break;
4715         case 'S':               /* --srcdir */
4716           if (optarg)
4717             srcdir = optarg;
4718           else
4719             fatal ("missing source directory");
4720           srcdir_len = strlen (srcdir);
4721           break;
4722         case 'B':               /* --backupdir */
4723           if (optarg)
4724             backup_dir = optarg;
4725           else
4726             fatal ("missing backup directory");
4727           break;
4728         case 'I':               /* --inputs */
4729           if (optarg)
4730             inputlist = optarg;
4731           else
4732             fatal ("missing input list");
4733           break;
4734         case 'r':               /* --read-state */
4735           if (optarg)
4736             read_state_filename = optarg;
4737           else
4738             fatal ("missing read state file");
4739           DBGPRINTF ("read state %s\n", optarg);
4740           break;
4741         case 'w':               /* --write-state */
4742           DBGPRINTF ("write state %s\n", optarg);
4743           if (optarg)
4744             write_state_filename = optarg;
4745           else
4746             fatal ("missing write state file");
4747           break;
4748         default:
4749           fprintf (stderr, "%s: unknown flag '%c'\n", progname, opt);
4750           print_usage ();
4751           fatal ("unexpected flag");
4752         }
4753     };
4754   if (plugin_output_filename)
4755     {
4756       /* In plugin mode we require some input files.  */
4757       int i = 0;
4758       if (optind >= argc)
4759         fatal ("no source files given in plugin mode");
4760       nb_plugin_files = argc - optind;
4761       plugin_files = XNEWVEC (input_file*, nb_plugin_files);
4762       for (i = 0; i < (int) nb_plugin_files; i++)
4763         {
4764           char *name = argv[i + optind];
4765           plugin_files[i] = input_file_by_name (name);
4766         }
4767     }
4768 }
4769
4770
4771 \f
4772 /******* Manage input files.  ******/
4773
4774 /* Hash table of unique input file names.  */
4775 static htab_t input_file_htab;
4776
4777 /* Find or allocate a new input_file by hash-consing it.  */
4778 input_file*
4779 input_file_by_name (const char* name)
4780 {
4781   PTR* slot;
4782   input_file* f = NULL;
4783   int namlen = 0;
4784   if (!name)
4785     return NULL;
4786   namlen = strlen (name);
4787   f = XCNEWVAR (input_file, sizeof (input_file)+namlen+2);
4788   f->inpbitmap = 0;
4789   f->inpoutf = NULL;
4790   strcpy (f->inpname, name);
4791   slot = htab_find_slot (input_file_htab, f, INSERT);
4792   gcc_assert (slot != NULL);
4793   if (*slot)
4794     {
4795       /* Already known input file.  */
4796       free (f);
4797       return (input_file*)(*slot);
4798     }
4799   /* New input file.  */
4800   *slot = f;
4801   return f;
4802     }
4803
4804 /* Hash table support routines for input_file-s.  */
4805 static hashval_t
4806 htab_hash_inputfile (const void *p)
4807 {
4808   const input_file *inpf = (const input_file *) p;
4809   gcc_assert (inpf);
4810   return htab_hash_string (get_input_file_name (inpf));
4811 }
4812
4813 static int
4814 htab_eq_inputfile (const void *x, const void *y)
4815 {
4816   const input_file *inpfx = (const input_file *) x;
4817   const input_file *inpfy = (const input_file *) y;
4818   gcc_assert (inpfx != NULL && inpfy != NULL);
4819   return !strcmp (get_input_file_name (inpfx), get_input_file_name (inpfy));
4820 }
4821
4822
4823 int
4824 main (int argc, char **argv)
4825 {
4826   size_t i;
4827   static struct fileloc pos = { NULL, 0 };
4828   outf_p output_header;
4829
4830   /* Mandatory common initializations.  */
4831   progname = "gengtype";        /* For fatal and messages.  */
4832   /* Create the hash-table used to hash-cons input files.  */
4833   input_file_htab =
4834     htab_create (800, htab_hash_inputfile, htab_eq_inputfile, NULL);
4835   /* Initialize our special input files.  */
4836   this_file = input_file_by_name (__FILE__);
4837   system_h_file = input_file_by_name ("system.h");
4838   /* Set the scalar_is_char union number for predefined scalar types.  */
4839   scalar_nonchar.u.scalar_is_char = FALSE;
4840   scalar_char.u.scalar_is_char = TRUE;
4841
4842   parse_program_options (argc, argv);
4843
4844 #if ENABLE_CHECKING
4845   if (do_debug)
4846     {
4847       time_t now = (time_t) 0;
4848       time (&now);
4849       DBGPRINTF ("gengtype started pid %d at %s",
4850                  (int) getpid (), ctime (&now));
4851     }
4852 #endif  /* ENABLE_CHECKING */
4853
4854   /* Parse the input list and the input files.  */
4855   DBGPRINTF ("inputlist %s", inputlist);
4856   if (read_state_filename)
4857     {
4858       if (inputlist)
4859         fatal ("input list %s cannot be given with a read state file %s",
4860                inputlist, read_state_filename);
4861       read_state (read_state_filename);
4862       DBGPRINT_COUNT_TYPE ("structures after read_state", structures);
4863       DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs);
4864     }
4865   else if (inputlist)
4866     {
4867       /* These types are set up with #define or else outside of where
4868          we can see them.  We should initialize them before calling
4869          read_input_list.  */
4870 #define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \
4871         Call;} while(0)
4872       POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos));
4873       POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos));
4874       POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos));
4875       POS_HERE (do_scalar_typedef ("double_int", &pos));
4876       POS_HERE (do_scalar_typedef ("uint64_t", &pos));
4877       POS_HERE (do_scalar_typedef ("uint8", &pos));
4878       POS_HERE (do_scalar_typedef ("jword", &pos));
4879       POS_HERE (do_scalar_typedef ("JCF_u2", &pos));
4880       POS_HERE (do_scalar_typedef ("void", &pos));
4881       POS_HERE (do_typedef ("PTR",
4882                             create_pointer (resolve_typedef ("void", &pos)),
4883                             &pos));
4884 #undef POS_HERE
4885       read_input_list (inputlist);
4886       for (i = 0; i < num_gt_files; i++)
4887         {
4888           parse_file (get_input_file_name (gt_files[i]));
4889           DBGPRINTF ("parsed file #%d %s",
4890                      (int) i, get_input_file_name (gt_files[i]));
4891         }
4892       if (verbosity_level >= 1)
4893         printf ("%s parsed %d files with %d GTY types\n",
4894                 progname, (int) num_gt_files, type_count);
4895
4896       DBGPRINT_COUNT_TYPE ("structures after parsing", structures);
4897       DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs);
4898
4899     }
4900   else
4901     fatal ("either an input list or a read state file should be given");
4902   if (hit_error)
4903     return 1;
4904
4905
4906   if (plugin_output_filename)
4907     {
4908       size_t ix = 0;
4909       /* In plugin mode, we should have read a state file, and have
4910          given at least one plugin file.  */
4911       if (!read_state_filename)
4912         fatal ("No read state given in plugin mode for %s",
4913                plugin_output_filename);
4914
4915       if (nb_plugin_files == 0 || !plugin_files)
4916         fatal ("No plugin files given in plugin mode for %s",
4917                plugin_output_filename);
4918
4919       /* Parse our plugin files and augment the state.  */
4920       for (ix = 0; ix < nb_plugin_files; ix++)
4921         parse_file (get_input_file_name (plugin_files[ix]));
4922
4923       if (hit_error)
4924         return 1;
4925
4926       plugin_output = create_file ("GCC", plugin_output_filename);
4927       DBGPRINTF ("created plugin_output %p named %s",
4928                  (void *) plugin_output, plugin_output->name);
4929     }
4930   else
4931     {                           /* No plugin files, we are in normal mode.  */
4932       if (!srcdir)
4933         fatal ("gengtype needs a source directory in normal mode");
4934     }
4935   if (hit_error)
4936     return 1;
4937
4938   gen_rtx_next ();
4939
4940   /* The call to set_gc_used may indirectly call find_param_structure
4941      hence enlarge the param_structs list of types.  */
4942   set_gc_used (variables);
4943
4944  /* The state at this point is read from the state input file or by
4945     parsing source files and optionally augmented by parsing plugin
4946     source files.  Write it now.  */
4947   if (write_state_filename)
4948     {
4949       DBGPRINT_COUNT_TYPE ("structures before write_state", structures);
4950       DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs);
4951
4952       if (hit_error)
4953         fatal ("didn't write state file %s after errors",
4954                write_state_filename);
4955
4956       DBGPRINTF ("before write_state %s", write_state_filename);
4957       write_state (write_state_filename);
4958
4959       if (do_dump)
4960         dump_everything ();
4961
4962       /* After having written the state file we return immediately to
4963          avoid generating any output file.  */
4964       if (hit_error)
4965         return 1;
4966       else
4967         return 0;
4968     }
4969
4970
4971   open_base_files ();
4972
4973   write_enum_defn (structures, param_structs);
4974   write_typed_alloc_defns (structures, typedefs);
4975   output_header = plugin_output ? plugin_output : header_file;
4976   DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
4977                        structures);
4978   DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
4979                        param_structs);
4980
4981   write_types (output_header, structures, param_structs, &ggc_wtd);
4982   if (plugin_files == NULL)
4983     {
4984       DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
4985                            structures);
4986       DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
4987                            param_structs);
4988       write_types (header_file, structures, param_structs, &pch_wtd);
4989       write_local (header_file, structures, param_structs);
4990     }
4991   write_splay_tree_allocators (param_structs);
4992   write_roots (variables, plugin_files == NULL);
4993   write_rtx_next ();
4994   close_output_files ();
4995
4996   if (do_dump)
4997     dump_everything ();
4998
4999   /* Don't bother about free-ing any input or plugin file, etc.  */
5000
5001   if (hit_error)
5002     return 1;
5003   return 0;
5004 }