--- a/gcc/gengtype.h	Tue May 25 18:58:51 2010 +0900
+++ b/gcc/gengtype.h	Tue Mar 22 17:18:12 2011 +0900
@@ -1,32 +1,111 @@
 /* Process source files and output type information.
-   Copyright (C) 2002, 2003, 2004, 2007, 2008 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2003, 2004, 2007, 2008, 2010 
+   Free Software Foundation, Inc.
 
-This file is part of GCC.
+   This file is part of GCC.
 
-GCC is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 3, or (at your option) any later
-version.
+   GCC is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 3, or (at your option) any later
+   version.
 
-GCC is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
+   GCC is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+   for more details.
 
-You should have received a copy of the GNU General Public License
-along with GCC; see the file COPYING3.  If not see
-<http://www.gnu.org/licenses/>.  */
+   You should have received a copy of the GNU General Public License
+   along with GCC; see the file COPYING3.  If not see
+   <http://www.gnu.org/licenses/>.  */
 
 #ifndef GCC_GENGTYPE_H
 #define GCC_GENGTYPE_H
 
+/* Sets of accepted source languages like C, C++, Ada... are
+   represented by a bitmap.  */
+typedef unsigned lang_bitmap;
+
+/* Variable length structure representing an input file.  A hash table
+   ensure uniqueness for a given input file name.  The only function
+   allocating input_file-s is input_file_by_name.  */
+struct input_file_st 
+{
+  struct outf* inpoutf;  /* Cached corresponding output file, computed
+                            in get_output_file_with_visibility.  */
+  lang_bitmap inpbitmap; /* The set of languages using this file.  */
+  char inpname[1];       /* A variable-length array, ended by a null
+                            char.  */
+};
+typedef struct input_file_st input_file;
+
 /* A file position, mostly for error messages.
    The FILE element may be compared using pointer equality.  */
-struct fileloc {
-  const char *file;
+struct fileloc
+{
+  const input_file *file;
   int line;
 };
 
+
+/* Table of all input files and its size.  */
+extern const input_file** gt_files;
+extern size_t num_gt_files;
+
+/* A number of places use the name of this "gengtype.c" file for a
+   location for things that we can't rely on the source to define.  We
+   also need to refer to the "system.h" file specifically.  These two
+   pointers are initialized early in main.  */
+extern input_file* this_file;
+extern input_file* system_h_file;
+
+/* Retrieve or create the input_file for a given name, which is a file
+   path.  This is the only function allocating input_file-s and it is
+   hash-consing them.  */
+input_file* input_file_by_name (const char* name);
+
+/* For F an input_file, return the relative path to F from $(srcdir)
+   if the latter is a prefix in F, NULL otherwise.  */
+const char *get_file_srcdir_relative_path (const input_file *inpf);
+
+/* Get the name of an input file.  */
+static inline const char*
+get_input_file_name (const input_file *inpf)
+{
+  if (inpf)
+      return inpf->inpname;
+  return NULL;
+}
+
+/* Return a bitmap which has bit `1 << BASE_FILE_<lang>' set iff
+   INPUT_FILE is used by <lang>.
+
+   This function should be written to assume that a file _is_ used
+   if the situation is unclear.  If it wrongly assumes a file _is_ used,
+   a linker error will result.  If it wrongly assumes a file _is not_ used,
+   some GC roots may be missed, which is a much harder-to-debug problem.
+  */
+
+static inline lang_bitmap
+get_lang_bitmap (const input_file* inpf)
+{
+  if (inpf == NULL)
+    return 0;
+  return inpf->inpbitmap;
+}
+
+/* Set the bitmap returned by get_lang_bitmap.  The only legitimate
+   callers of this function are read_input_list & read_state_*.  */
+static inline void
+set_lang_bitmap (input_file* inpf, lang_bitmap n)
+{
+  gcc_assert (inpf);
+  inpf->inpbitmap = n;
+}
+
+/* Vector of per-language directories.  */
+extern const char **lang_dir_names;
+extern size_t num_lang_dirs;
+
 /* Data types handed around within, but opaque to, the lexer and parser.  */
 typedef struct pair *pair_p;
 typedef struct type *type_p;
@@ -37,12 +116,277 @@
 extern int lexer_toplevel_done;
 extern struct fileloc lexer_line;
 
+/* Various things, organized as linked lists, needed both in
+   gengtype.c & in gengtype-state.c files.  */
+extern pair_p typedefs;
+extern type_p structures;
+extern type_p param_structs;
+extern pair_p variables;
+
+
+
+/* Discrimating kind of types we can understand.  */
+
+enum typekind {
+  TYPE_NONE=0,          /* Never used, so zeroed memory is invalid.  */
+  TYPE_SCALAR,          /* Scalar types like char.  */
+  TYPE_STRING,          /* The string type.  */
+  TYPE_STRUCT,          /* Type for GTY-ed structs.  */
+  TYPE_UNION,           /* Type for GTY-ed discriminated unions.  */
+  TYPE_POINTER,         /* Pointer type to GTY-ed type.  */
+  TYPE_ARRAY,           /* Array of GTY-ed types.  */
+  TYPE_LANG_STRUCT,     /* GCC front-end language specific structs.
+                           Various languages may have homonymous but
+                           different structs.  */
+  TYPE_PARAM_STRUCT     /* Type for parametrized structs, e.g. hash_t
+                           hash-tables, ...  See (param_is, use_param,
+                           param1_is, param2_is,... use_param1,
+                           use_param_2,... use_params) GTY
+                           options.  */
+};
+
+/* Discriminating kind for options.  */
+enum option_kind {
+  OPTION_NONE=0,        /* Never used, so zeroed memory is invalid.  */
+  OPTION_STRING,        /* A string-valued option.  Most options are
+                           strings.  */
+  OPTION_TYPE,          /* A type-valued option.  */
+  OPTION_NESTED         /* Option data for 'nested_ptr'.  */
+};
+
+
+/* A way to pass data through to the output end.  */
+struct options {
+  struct options *next;         /* next option of the same pair.  */
+  const char *name;             /* GTY option name.  */
+  enum option_kind kind;        /* discriminating option kind.  */
+  union {
+    const char* string;                    /* When OPTION_STRING.  */
+    type_p type;                           /* When OPTION_TYPE.  */
+    struct nested_ptr_data* nested;        /* when OPTION_NESTED.  */
+  } info;
+};
+
+
+/* Option data for the 'nested_ptr' option.  */
+struct nested_ptr_data {
+  type_p type;
+  const char *convert_to;
+  const char *convert_from;
+};
+
+/* Some functions to create various options structures with name NAME
+   and info INFO.  NEXT is the next option in the chain.  */
+
+/* Create a string option.  */
+options_p create_string_option (options_p next, const char* name,
+                                const char* info);
+
+/* Create a type option.  */
+options_p create_type_option (options_p next, const char* name,
+                              type_p info);
+
+/* Create a nested option.  */
+options_p create_nested_option (options_p next, const char* name,
+				struct nested_ptr_data* info);
+
+/* Create a nested pointer option.  */
+options_p create_nested_ptr_option (options_p, type_p t,
+			 	     const char *from, const char *to);
+
+/* A name and a type.  */
+struct pair {
+  pair_p next;                  /* The next pair in the linked list.  */
+  const char *name;             /* The defined name.  */
+  type_p type;                  /* Its GTY-ed type.  */
+  struct fileloc line;          /* The file location.  */
+  options_p opt;                /* GTY options, as a linked list.  */
+};
+
+/* Usage information for GTY-ed types.  Gengtype has to care only of
+   used GTY-ed types.  Types are initially unused, and their usage is
+   computed by set_gc_used_type and set_gc_used functions.  */
+
+enum gc_used_enum {
+
+  /* We need that zeroed types are initially unused.  */
+  GC_UNUSED=0,
+
+  /* The GTY-ed type is used, e.g by a GTY-ed variable or a field
+     inside a GTY-ed used type.  */
+  GC_USED,
+
+  /* For GTY-ed structures whose definitions we haven't seen so far
+     when we encounter a pointer to it that is annotated with
+     ``maybe_undef''.  If after reading in everything we don't have
+     source file information for it, we assume that it never has been
+     defined.  */
+  GC_MAYBE_POINTED_TO,
+
+  /* For known GTY-ed structures which are pointed to by GTY-ed
+     variables or fields.  */
+  GC_POINTED_TO
+};
+
+/* We can have at most ten type parameters in parameterized structures.  */
+#define NUM_PARAM 10
+
+/* Our type structure describes all types handled by gengtype.  */
+struct type {
+  /* Discriminating kind, cannot be TYPE_NONE.  */
+  enum typekind kind;
+
+  /* For top-level structs or unions, the 'next' field links the
+     global list 'structures' or 'param_structs'; for lang_structs,
+     their homonymous structs are linked using this 'next' field.  The
+     homonymous list starts at the s.lang_struct field of the
+     lang_struct.  See the new_structure function for details.  This is
+     tricky!  */
+  type_p next;
+
+  /* State number used when writing & reading the persistent state.  A
+     type with a positive number has already been written.  For ease
+     of debugging, newly allocated types have a unique negative
+     number.  */
+  int state_number;
+
+  /* Each GTY-ed type which is pointed to by some GTY-ed type knows
+     the GTY pointer type pointing to it.  See create_pointer
+     function.  */
+  type_p pointer_to;
+
+  /* Type usage information, computed by set_gc_used_type and
+     set_gc_used functions.  */
+  enum gc_used_enum gc_used;
+
+  /* The following union is discriminated by the 'kind' field above.  */
+  union {
+    /* TYPE__NONE is impossible.  */
+
+    /* when TYPE_POINTER:  */
+    type_p p;
+
+    /* when TYPE_STRUCT or TYPE_UNION or TYPE_LANG_STRUCT, we have an
+       aggregate type containing fields: */
+    struct {
+      const char *tag;          /* the aggragate tag, if any.  */
+      struct fileloc line;      /* the source location.  */
+      pair_p fields;            /* the linked list of fields.  */
+      options_p opt;            /* the GTY options if any.  */
+      lang_bitmap bitmap;       /* the set of front-end languages
+                                   using that GTY-ed aggregate.  */
+      /* For TYPE_LANG_STRUCT, the lang_struct field gives the first
+         element of a linked list of homonymous struct or union types.
+         Within this list, each homonymous type has as its lang_struct
+         field the original TYPE_LANG_STRUCT type.  This is a dirty
+         trick, see the new_structure function for details.  */
+      type_p lang_struct;
+    } s;
+
+    /* when TYPE_SCALAR: */
+    bool scalar_is_char;
+
+    /* when TYPE_ARRAY: */
+    struct {
+      type_p p;                 /* The array component type.  */
+      const char *len;          /* The string if any giving its length.  */
+    } a;
+
+    /* When TYPE_PARAM_STRUCT for (param_is, use_param, param1_is,
+       param2_is, ... use_param1, use_param_2, ... use_params) GTY
+       options.  */
+    struct {
+      type_p stru;              /* The generic GTY-ed type.  */
+      type_p param[NUM_PARAM];  /* The actual parameter types.  */
+      struct fileloc line;      /* The source location.  */
+    } param_struct;
+
+  } u;
+};
+
+/* The one and only TYPE_STRING.  */
+extern struct type string_type;
+
+/* The two and only TYPE_SCALARs.  Their u.scalar_is_char flags are
+   set early in main.  */
+extern struct type scalar_nonchar;
+extern struct type scalar_char;
+
+/* Test if a type is a union, either a plain one or a language
+   specific one.  */
+#define UNION_P(x)                                      \
+    ((x)->kind == TYPE_UNION ||                         \
+     ((x)->kind == TYPE_LANG_STRUCT                     \
+      && (x)->u.s.lang_struct->kind == TYPE_UNION))
+
+/* Test if a type is a union or a structure, perhaps a language
+   specific one.  */
+#define UNION_OR_STRUCT_P(x)			\
+    ((x)->kind == TYPE_UNION 			\
+     || (x)->kind == TYPE_STRUCT		\
+     || (x)->kind == TYPE_LANG_STRUCT)
+
+
+
+/* Structure representing an output file.  */
+struct outf
+{
+  struct outf *next;
+  const char *name;
+  size_t buflength;
+  size_t bufused;
+  char *buf;
+};
+typedef struct outf *outf_p;
+
+/* The list of output files.  */
+extern outf_p output_files;
+
+/* The output header file that is included into pretty much every
+   source file.  */
+extern outf_p header_file;
+
+/* Print, like fprintf, to O.  No-op if O is NULL.  */
+void
+oprintf (outf_p o, const char *S, ...)
+  ATTRIBUTE_PRINTF_2;
+
+/* An output file, suitable for definitions, that can see declarations
+   made in INPF and is linked into every language that uses INPF.  May
+   return NULL in plugin mode.  The INPF argument is almost const, but
+   since the result is cached in its inpoutf field it cannot be
+   declared const.  */
+outf_p get_output_file_with_visibility (input_file* inpf);
+
+/* The name of an output file, suitable for definitions, that can see
+   declarations made in INPF and is linked into every language that
+   uses INPF.  May return NULL.  */
+const char *get_output_file_name (input_file *inpf);
+
+
+/* Source directory.  */
+extern const char *srcdir;	/* (-S) program argument. */
+
+/* Length of srcdir name.  */
+extern size_t srcdir_len;
+
+/* Variable used for reading and writing the state.  */
+extern const char *read_state_filename; /* (-r) program argument. */
+extern const char *write_state_filename; /* (-w) program argument. */
+
+/* Functions reading and writing the entire gengtype state, called from
+   main, and implemented in file gengtype-state.c.  */
+void read_state (const char* path);
+/* Write the state, and update the state_number field in types.  */
+void write_state (const char* path);
+
+
 /* Print an error message.  */
 extern void error_at_line
-  (const struct fileloc *pos, const char *msg, ...) ATTRIBUTE_PRINTF_2;
+(const struct fileloc *pos, const char *msg, ...) ATTRIBUTE_PRINTF_2;
 
 /* Like asprintf, but calls fatal() on out of memory.  */
-extern char *xasprintf(const char *, ...) ATTRIBUTE_PRINTF_1;
+extern char *xasprintf (const char *, ...) ATTRIBUTE_PRINTF_1;
 
 /* Constructor routines for types.  */
 extern void do_typedef (const char *s, type_p t, struct fileloc *pos);
@@ -55,11 +399,9 @@
 extern type_p create_scalar_type (const char *name);
 extern type_p create_pointer (type_p t);
 extern type_p create_array (type_p t, const char *len);
-extern options_p create_option (options_p, const char *name, const void *info);
-extern options_p create_nested_ptr_option (options_p, type_p t,
-					   const char *from, const char *to);
-extern pair_p create_field_at (pair_p next, type_p type, const char *name,
-			       options_p opt, struct fileloc *pos);
+extern pair_p create_field_at (pair_p next, type_p type,
+			       const char *name, options_p opt,
+			       struct fileloc *pos);
 extern pair_p nreverse_pairs (pair_p list);
 extern type_p adjust_field_type (type_p, options_p);
 extern void note_variable (const char *s, type_p t, options_p o,
@@ -77,37 +419,65 @@
 extern bool hit_error;
 
 /* Token codes.  */
-enum {
-  EOF_TOKEN = 0,
+enum
+  {
+    EOF_TOKEN = 0,
+
+    /* Per standard convention, codes in the range (0, UCHAR_MAX]
+       represent single characters with those character codes.  */
 
-  /* Per standard convention, codes in the range (0, UCHAR_MAX]
-     represent single characters with those character codes.  */
+    CHAR_TOKEN_OFFSET = UCHAR_MAX + 1,
+    GTY_TOKEN = CHAR_TOKEN_OFFSET,
+    TYPEDEF,
+    EXTERN,
+    STATIC,
+    UNION,
+    STRUCT,
+    ENUM,
+    VEC_TOKEN,
+    DEFVEC_OP,
+    DEFVEC_I,
+    DEFVEC_ALLOC,
+    ELLIPSIS,
+    PTR_ALIAS,
+    NESTED_PTR,
+    PARAM_IS,
+    NUM,
+    SCALAR,
+    ID,
+    STRING,
+    CHAR,
+    ARRAY,
 
-  CHAR_TOKEN_OFFSET = UCHAR_MAX + 1,
-  GTY_TOKEN = CHAR_TOKEN_OFFSET,
-  TYPEDEF,
-  EXTERN,
-  STATIC,
-  UNION,
-  STRUCT,
-  ENUM,
-  VEC_TOKEN,
-  DEFVEC_OP,
-  DEFVEC_I,
-  DEFVEC_ALLOC,
-  ELLIPSIS,
-  PTR_ALIAS,
-  NESTED_PTR,
-  PARAM_IS,
-  NUM,
-  SCALAR,
-  ID,
-  STRING,
-  CHAR,
-  ARRAY,
+    /* print_token assumes that any token >= FIRST_TOKEN_WITH_VALUE may have
+       a meaningful value to be printed.  */
+    FIRST_TOKEN_WITH_VALUE = PARAM_IS
+  };
+
+
+/* Level for verbose messages, e.g. output file generation...  */
+extern int verbosity_level;	/* (-v) program argument.  */
+
+/* For debugging purposes we provide two flags.  */
+
+/* Dump everything to understand gengtype's state. Might be useful to
+   gengtype users.  */
+extern int do_dump;		/* (-d) program argument. */
 
-  /* print_token assumes that any token >= FIRST_TOKEN_WITH_VALUE may have
-     a meaningful value to be printed.  */
-  FIRST_TOKEN_WITH_VALUE = PARAM_IS
-};
+/* Trace the execution by many DBGPRINTF (with the position inside
+   gengtype source code).  Only useful to debug gengtype itself.  */
+extern int do_debug;		/* (-D) program argument. */
+
+#if ENABLE_CHECKING
+#define DBGPRINTF(Fmt,...) do {if (do_debug)				\
+      fprintf (stderr, "%s:%d: " Fmt "\n",				\
+	       lbasename (__FILE__),__LINE__, ##__VA_ARGS__);} while (0)
+void dbgprint_count_type_at (const char *, int, const char *, type_p);
+#define DBGPRINT_COUNT_TYPE(Msg,Ty) do {if (do_debug)			\
+      dbgprint_count_type_at (__FILE__, __LINE__, Msg, Ty);}while (0)
+#else
+#define DBGPRINTF(Fmt,...) do {/*nodbgrintf*/} while (0)
+#define DBGPRINT_COUNT_TYPE(Msg,Ty) do{/*nodbgprint_count_type*/}while (0)
+#endif /*ENABLE_CHECKING */
+
 #endif