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