gcc/gengtype.c

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