Mercurial > hg > CbC > CbC_gcc
diff gcc/gengtype.c @ 67:f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
author | nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Tue, 22 Mar 2011 17:18:12 +0900 |
parents | b7f97abdc517 |
children | 04ced10e8804 |
line wrap: on
line diff
--- a/gcc/gengtype.c Tue May 25 18:58:51 2010 +0900 +++ b/gcc/gengtype.c Tue Mar 22 17:18:12 2011 +0900 @@ -1,5 +1,5 @@ /* Process source files and output type information. - Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010 Free Software Foundation, Inc. This file is part of GCC. @@ -20,158 +20,72 @@ #include "bconfig.h" #include "system.h" +#include "errors.h" /* for fatal */ +#include "getopt.h" +#include "double-int.h" +#include "version.h" /* for version_string & pkgversion_string. */ +#include "hashtab.h" +#include "xregex.h" +#include "obstack.h" #include "gengtype.h" -#include "errors.h" /* for fatal */ -#include "double-int.h" -#include "hashtab.h" /* Data types, macros, etc. used only in this file. */ -/* Kinds of types we can understand. */ -enum typekind { - TYPE_SCALAR, - TYPE_STRING, - TYPE_STRUCT, - TYPE_UNION, - TYPE_POINTER, - TYPE_ARRAY, - TYPE_LANG_STRUCT, - TYPE_PARAM_STRUCT -}; - -typedef unsigned lang_bitmap; - -/* A way to pass data through to the output end. */ -struct options -{ - struct options *next; - const char *name; - const char *info; -}; - -/* Option data for the 'nested_ptr' option. */ -struct nested_ptr_data -{ - type_p type; - const char *convert_to; - const char *convert_from; -}; - -/* A name and a type. */ -struct pair -{ - pair_p next; - const char *name; - type_p type; - struct fileloc line; - options_p opt; -}; - -#define NUM_PARAM 10 - -/* A description of a type. */ -enum gc_used_enum - { - GC_UNUSED = 0, - GC_USED, - /* Used for 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, - GC_POINTED_TO - }; - -struct type -{ - enum typekind kind; - type_p next; - type_p pointer_to; - enum gc_used_enum gc_used; - union { - type_p p; - struct { - const char *tag; - struct fileloc line; - pair_p fields; - options_p opt; - lang_bitmap bitmap; - type_p lang_struct; - } s; - bool scalar_is_char; - struct { - type_p p; - const char *len; - } a; - struct { - type_p stru; - type_p param[NUM_PARAM]; - struct fileloc line; - } param_struct; - } u; -}; - -#define UNION_P(x) \ - ((x)->kind == TYPE_UNION || \ - ((x)->kind == TYPE_LANG_STRUCT \ - && (x)->u.s.lang_struct->kind == TYPE_UNION)) -#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; - -/* An output file, suitable for definitions, that can see declarations - made in INPUT_FILE and is linked into every language that uses - INPUT_FILE. May return NULL in plugin mode. */ -extern outf_p get_output_file_with_visibility - (const char *input_file); -const char *get_output_file_name (const char *); - -/* Print, like fprintf, to O. No-op if O is NULL. */ -static void oprintf (outf_p o, const char *S, ...) - ATTRIBUTE_PRINTF_2; /* The list of output files. */ -static outf_p output_files; +outf_p output_files; + +/* The output header file that is included into pretty much every + source file. */ +outf_p header_file; + + +/* The name of the file containing the list of input files. */ +static char *inputlist; /* The plugin input files and their number; in that case only a single file is produced. */ -static char** plugin_files; +static input_file **plugin_files; static size_t nb_plugin_files; -/* the generated plugin output name & file */ + +/* The generated plugin output file and name. */ static outf_p plugin_output; - -/* The output header file that is included into pretty much every - source file. */ -static outf_p header_file; - -/* Source directory. */ -static const char *srcdir; - -/* Length of srcdir name. */ -static size_t srcdir_len = 0; +static char *plugin_output_filename; + +/* Our source directory and its length. */ +const char *srcdir; +size_t srcdir_len; + +/* Variables used for reading and writing the state. */ +const char *read_state_filename; +const char *write_state_filename; + +/* Variables to help debugging. */ +int do_dump; +int do_debug; + +/* Level for verbose messages. */ +int verbosity_level; + +/* We have a type count and use it to set the state_number of newly + allocated types to some unique negative number. */ +static int type_count; + +/* The backup directory should be in the same file system as the + generated files, otherwise the rename(2) system call would fail. + If NULL, no backup is made when overwriting a generated file. */ +static const char* backup_dir; /* (-B) program option. */ + static outf_p create_file (const char *, const char *); -static const char * get_file_basename (const char *); -static const char * get_file_realbasename (const char *); -static const char * get_file_srcdir_relative_path (const char *); +static const char *get_file_basename (const input_file *); +static const char *get_file_realbasename (const input_file *); static int get_prefix_langdir_index (const char *); -static const char * get_file_langdir (const char *); - +static const char *get_file_langdir (const input_file *); + /* Nonzero iff an error has occurred. */ bool hit_error = false; @@ -187,9 +101,10 @@ { va_list ap; + gcc_assert (pos != NULL && pos->file != NULL); va_start (ap, msg); - fprintf (stderr, "%s:%d: ", pos->file, pos->line); + fprintf (stderr, "%s:%d: ", get_input_file_name (pos->file), pos->line); vfprintf (stderr, msg, ap); fputc ('\n', stderr); hit_error = true; @@ -217,63 +132,83 @@ /* Input file handling. */ /* Table of all input files. */ -static const char **gt_files; -static size_t num_gt_files; - -/* A number of places use the name of this file for a location for - things that we can't rely on the source to define. Make sure we - can still use pointer comparison on filenames. */ -static const char this_file[] = __FILE__; +const input_file **gt_files; +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. + Make sure we can still use pointer comparison on filenames. */ +input_file* this_file; +/* The "system.h" file is likewise specially useful. */ +input_file* system_h_file; /* Vector of per-language directories. */ -static const char **lang_dir_names; -static size_t num_lang_dirs; +const char **lang_dir_names; +size_t num_lang_dirs; /* An array of output files suitable for definitions. There is one BASE_FILES entry for each language. */ static outf_p *base_files; -/* 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. - - The relevant bitmap is stored immediately before the file's name in the - buffer set up by read_input_list. It may be unaligned, so we have to - read it byte-by-byte. */ - -static lang_bitmap -get_lang_bitmap (const char *gtfile) + + +#if ENABLE_CHECKING +/* Utility debugging function, printing the various type counts within + a list of types. Called thru the DBGPRINT_COUNT_TYPE macro. */ +void +dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t) { - - if (gtfile == this_file) - /* Things defined in this file are universal. */ - return (((lang_bitmap)1) << num_lang_dirs) - 1; - else + int nb_types = 0, nb_scalar = 0, nb_string = 0; + int nb_struct = 0, nb_union = 0, nb_array = 0, nb_pointer = 0; + int nb_lang_struct = 0, nb_param_struct = 0; + type_p p = NULL; + for (p = t; p; p = p->next) { - lang_bitmap n = 0; - int i; - for (i = -(int) sizeof (lang_bitmap); i < 0; i++) - n = (n << CHAR_BIT) + (unsigned char)gtfile[i]; - return n; + nb_types++; + switch (p->kind) + { + case TYPE_SCALAR: + nb_scalar++; + break; + case TYPE_STRING: + nb_string++; + break; + case TYPE_STRUCT: + nb_struct++; + break; + case TYPE_UNION: + nb_union++; + break; + case TYPE_POINTER: + nb_pointer++; + break; + case TYPE_ARRAY: + nb_array++; + break; + case TYPE_LANG_STRUCT: + nb_lang_struct++; + break; + case TYPE_PARAM_STRUCT: + nb_param_struct++; + break; + default: + gcc_unreachable (); + } } + fprintf (stderr, "\n" "%s:%d: %s: @@%%@@ %d types ::\n", + lbasename (fil), lin, msg, nb_types); + if (nb_scalar > 0 || nb_string > 0) + fprintf (stderr, "@@%%@@ %d scalars, %d strings\n", nb_scalar, nb_string); + if (nb_struct > 0 || nb_union > 0) + fprintf (stderr, "@@%%@@ %d structs, %d unions\n", nb_struct, nb_union); + if (nb_pointer > 0 || nb_array > 0) + fprintf (stderr, "@@%%@@ %d pointers, %d arrays\n", nb_pointer, nb_array); + if (nb_lang_struct > 0 || nb_param_struct > 0) + fprintf (stderr, "@@%%@@ %d lang_structs, %d param_structs\n", + nb_lang_struct, nb_param_struct); + fprintf (stderr, "\n"); } - -/* Set the bitmap returned by get_lang_bitmap. The only legitimate - caller of this function is read_input_list. */ -static void -set_lang_bitmap (char *gtfile, lang_bitmap n) -{ - int i; - for (i = -1; i >= -(int) sizeof (lang_bitmap); i--) - { - gtfile[i] = n & ((1U << CHAR_BIT)-1); - n >>= CHAR_BIT; - } -} +#endif /* ENABLE_CHECKING */ /* Scan the input file, LIST, and determine how much space we need to store strings in. Also, count the number of language directories @@ -319,8 +254,7 @@ touch *HEREP, and sets *LINEP to NULL. POS is used for diagnostics. */ static bool -read_input_line (FILE *list, char **herep, char **linep, - struct fileloc *pos) +read_input_line (FILE *list, char **herep, char **linep, struct fileloc *pos) { char *here = *herep; char *line; @@ -349,12 +283,13 @@ if (c == ']') { - c = getc (list); /* eat what should be a newline */ + c = getc (list); /* eat what should be a newline */ if (c != '\n' && c != EOF) error_at_line (pos, "junk on line after language tag [%s]", line); } else - error_at_line (pos, "missing close bracket for language tag [%s", line); + error_at_line (pos, "missing close bracket for language tag [%s", + line); *herep = here; *linep = line; @@ -392,7 +327,7 @@ { FILE *list = fopen (listname, "r"); if (!list) - fatal ("cannot open %s: %s", listname, strerror (errno)); + fatal ("cannot open %s: %s", listname, xstrerror (errno)); else { struct fileloc epos; @@ -407,11 +342,11 @@ size_t nfiles = 0; lang_bitmap curlangs = (1 << num_lang_dirs) - 1; - epos.file = listname; + epos.file = input_file_by_name (listname); epos.line = 0; lang_dir_names = XNEWVEC (const char *, num_lang_dirs); - gt_files = XNEWVEC (const char *, num_gt_files); + gt_files = XNEWVEC (const input_file *, num_gt_files); for (;;) { @@ -429,7 +364,8 @@ for (i = 0; i < langno; i++) if (strcmp (lang_dir_names[i], line) == 0) { - error_at_line (&epos, "duplicate language tag [%s]", line); + error_at_line (&epos, "duplicate language tag [%s]", + line); curlangs = 1 << i; here = committed; goto next_line; @@ -441,31 +377,36 @@ else { size_t i; + input_file *inpf = input_file_by_name (line); gcc_assert (nfiles <= num_gt_files); for (i = 0; i < nfiles; i++) - if (strcmp (gt_files[i], line) == 0) + /* Since the input_file-s are uniquely hash-consed, we + can just compare pointers! */ + if (gt_files[i] == inpf) { /* Throw away the string we just read, and add the current language to the existing string's bitmap. */ - lang_bitmap bmap = get_lang_bitmap (gt_files[i]); + lang_bitmap bmap = get_lang_bitmap (inpf); if (bmap & curlangs) - error_at_line (&epos, "file %s specified more than once " - "for language %s", line, langno == 0 - ? "(all)" - : lang_dir_names[langno - 1]); + error_at_line (&epos, + "file %s specified more than once " + "for language %s", line, + langno == + 0 ? "(all)" : lang_dir_names[langno - + 1]); bmap |= curlangs; - set_lang_bitmap (CONST_CAST(char *, gt_files[i]), bmap); + set_lang_bitmap (inpf, bmap); here = committed; goto next_line; } - set_lang_bitmap (line, curlangs); - gt_files[nfiles++] = line; + set_lang_bitmap (inpf, curlangs); + gt_files[nfiles++] = inpf; } } /* Update the global counts now that we know accurately how many - things there are. (We do not bother resizing the arrays down.) */ + things there are. (We do not bother resizing the arrays down.) */ num_lang_dirs = langno; /* Add the plugin files if provided. */ if (plugin_files) @@ -493,7 +434,7 @@ { size_t l; for (l = 0; l < num_lang_dirs; l++) - if ((size_t)(slashpos - basename) == strlen (lang_dir_names [l]) + if ((size_t) (slashpos - basename) == strlen (lang_dir_names[l]) && memcmp (basename, lang_dir_names[l], strlen (lang_dir_names[l])) == 0) { @@ -503,43 +444,43 @@ basename, lang_dir_names[l]); break; } - } + } } } if (ferror (list)) - fatal ("error reading %s: %s", listname, strerror (errno)); + fatal ("error reading %s: %s", listname, xstrerror (errno)); fclose (list); } - - + + /* The one and only TYPE_STRING. */ -static struct type string_type = { - TYPE_STRING, 0, 0, GC_USED, {0} +struct type string_type = { + TYPE_STRING, 0, 0, 0, GC_USED, {0} }; /* The two and only TYPE_SCALARs. Their u.scalar_is_char flags are - set to appropriate values at the beginning of main. */ - -static struct type scalar_nonchar = { - TYPE_SCALAR, 0, 0, GC_USED, {0} + set early in main. */ + +struct type scalar_nonchar = { + TYPE_SCALAR, 0, 0, 0, GC_USED, {0} }; -static struct type scalar_char = { - TYPE_SCALAR, 0, 0, GC_USED, {0} + +struct type scalar_char = { + TYPE_SCALAR, 0, 0, 0, GC_USED, {0} }; /* Lists of various things. */ -static pair_p typedefs; -static type_p structures; -static type_p param_structs; -static pair_p variables; - -static type_p find_param_structure - (type_p t, type_p param[NUM_PARAM]); +pair_p typedefs; +type_p structures; +type_p param_structs; +pair_p variables; + +static type_p find_param_structure (type_p t, type_p param[NUM_PARAM]); static type_p adjust_field_tree_exp (type_p t, options_p opt); static type_p adjust_field_rtx_def (type_p t, options_p opt); @@ -597,7 +538,7 @@ if (strcmp (p->name, s) == 0) return p->type; error_at_line (pos, "unidentified type `%s'", s); - return &scalar_nonchar; /* treat as "int" */ + return &scalar_nonchar; /* treat as "int" */ } /* Create and return a new structure with tag NAME (or a union iff @@ -611,16 +552,8 @@ type_p s = NULL; lang_bitmap bitmap = get_lang_bitmap (pos->file); - /* temporary kludge - gengtype doesn't handle conditionals or - macros. Ignore any attempt to define struct location_s, unless - it is coming from this file (main() sets it up safely). */ - if (!strcmp (name, "location_s") && !isunion - && pos->file != this_file) - return find_structure (name, 0); - for (si = structures; si != NULL; si = si->next) - if (strcmp (name, si->u.s.tag) == 0 - && UNION_P (si) == isunion) + if (strcmp (name, si->u.s.tag) == 0 && UNION_P (si) == isunion) { type_p ls = NULL; if (si->kind == TYPE_LANG_STRUCT) @@ -634,12 +567,14 @@ else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap) { ls = si; + type_count++; si = XCNEW (struct type); memcpy (si, ls, sizeof (struct type)); ls->kind = TYPE_LANG_STRUCT; ls->u.s.lang_struct = si; ls->u.s.fields = NULL; si->next = NULL; + si->state_number = -type_count; si->pointer_to = NULL; si->u.s.lang_struct = ls; } @@ -648,7 +583,9 @@ if (ls != NULL && s == NULL) { + type_count++; s = XCNEW (struct type); + s->state_number = -type_count; s->next = ls->u.s.lang_struct; ls->u.s.lang_struct = s; s->u.s.lang_struct = ls; @@ -658,7 +595,9 @@ if (s == NULL) { + type_count++; s = XCNEW (struct type); + s->state_number = -type_count; s->next = structures; structures = s; } @@ -680,22 +619,7 @@ if (s->u.s.lang_struct) s->u.s.lang_struct->u.s.bitmap |= bitmap; - /* Reset location_s's location to input.h so that we know where to - write out its mark routine. */ - if (!strcmp (name, "location_s") && !isunion - && pos->file == this_file) - { - size_t n; - for (n = 0; n < num_gt_files; n++) - if (!strcmp (gt_files[n] + strlen (gt_files[n]) - strlen ("input.h"), - "input.h")) - { - s->u.s.line.file = gt_files[n]; - break; - } - } - - return s; + return s; } /* Return the previously-defined structure with tag NAME (or a union @@ -708,12 +632,13 @@ type_p s; for (s = structures; s != NULL; s = s->next) - if (strcmp (name, s->u.s.tag) == 0 - && UNION_P (s) == isunion) + if (strcmp (name, s->u.s.tag) == 0 && UNION_P (s) == isunion) return s; + type_count++; s = XCNEW (struct type); s->next = structures; + s->state_number = -type_count; structures = s; s->kind = isunion ? TYPE_UNION : TYPE_STRUCT; s->u.s.tag = name; @@ -737,9 +662,11 @@ break; if (res == NULL) { + type_count++; res = XCNEW (struct type); res->kind = TYPE_PARAM_STRUCT; res->next = param_structs; + res->state_number = -type_count; param_structs = res; res->u.param_struct.stru = t; memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM); @@ -763,9 +690,11 @@ type_p create_pointer (type_p t) { - if (! t->pointer_to) + if (!t->pointer_to) { type_p r = XCNEW (struct type); + type_count++; + r->state_number = -type_count; r->kind = TYPE_POINTER; r->u.p = t; t->pointer_to = r; @@ -780,23 +709,53 @@ { type_p v; + type_count++; v = XCNEW (struct type); v->kind = TYPE_ARRAY; + v->state_number = -type_count; v->u.a.p = t; v->u.a.len = len; return v; } -/* Return an options structure with name NAME and info INFO. NEXT is the - next option in the chain. */ - +/* Return a string options structure with name NAME and info INFO. + NEXT is the next option in the chain. */ options_p -create_option (options_p next, const char *name, const void *info) +create_string_option (options_p next, const char *name, const char *info) +{ + options_p o = XNEW (struct options); + o->kind = OPTION_STRING; + o->next = next; + o->name = name; + o->info.string = info; + return o; +} + +/* Create a type options structure with name NAME and info INFO. NEXT + is the next option in the chain. */ +options_p +create_type_option (options_p next, const char* name, type_p info) { options_p o = XNEW (struct options); o->next = next; o->name = name; - o->info = (const char*) info; + o->kind = OPTION_TYPE; + o->info.type = info; + return o; +} + +/* Create a nested pointer options structure with name NAME and info + INFO. NEXT is the next option in the chain. */ +options_p +create_nested_option (options_p next, const char* name, + struct nested_ptr_data* info) +{ + options_p o; + o = XNEW (struct options); + o->next = next; + o->name = name; + o->kind = OPTION_NESTED; + o->info.nested = info; return o; } @@ -810,12 +769,11 @@ d->type = adjust_field_type (t, 0); d->convert_to = to; d->convert_from = from; - return create_option (next, "nested_ptr", d); + return create_nested_option (next, "nested_ptr", d); } /* Add a variable named S of type T with options O defined at POS, to `variables'. */ - void note_variable (const char *s, type_p t, options_p o, struct fileloc *pos) { @@ -832,7 +790,7 @@ /* Most-general structure field creator. */ static pair_p create_field_all (pair_p next, type_p type, const char *name, options_p opt, - const char *file, int line) + const input_file *inpf, int line) { pair_p field; @@ -841,7 +799,7 @@ field->type = type; field->name = name; field->opt = opt; - field->line.file = file; + field->line.file = inpf; field->line.line = line; return field; } @@ -877,17 +835,21 @@ The field has a tag of "1". This allows us to make the presence of a field of type TYPE depend on some boolean "desc" being true. */ union_fields = create_field (NULL, type, ""); - union_fields->opt = create_option (union_fields->opt, "dot", ""); - union_fields->opt = create_option (union_fields->opt, "tag", "1"); - union_type = new_structure (xasprintf ("%s_%d", "fake_union", id++), 1, - &lexer_line, union_fields, NULL); + union_fields->opt = + create_string_option (union_fields->opt, "dot", ""); + union_fields->opt = + create_string_option (union_fields->opt, "tag", "1"); + union_type = + new_structure (xasprintf ("%s_%d", "fake_union", id++), 1, + &lexer_line, union_fields, NULL); /* Create the field and give it the new fake union type. Add a "desc" tag that specifies the condition under which the field is valid. */ return create_field_all (next, union_type, name, - create_option (0, "desc", cond), + create_string_option (0, "desc", cond), this_file, line); } + #define create_optional_field(next,type,name,cond) \ create_optional_field_(next,type,name,cond,__LINE__) @@ -904,27 +866,28 @@ } return prev; } - + /* We don't care how long a CONST_DOUBLE is. */ #define CONST_DOUBLE_FORMAT "ww" /* We don't want to see codes that are only for generator files. */ #undef GENERATOR_FILE -enum rtx_code { +enum rtx_code +{ #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM , #include "rtl.def" #undef DEF_RTL_EXPR NUM_RTX_CODE }; -static const char * const rtx_name[NUM_RTX_CODE] = { +static const char *const rtx_name[NUM_RTX_CODE] = { #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME , #include "rtl.def" #undef DEF_RTL_EXPR }; -static const char * const rtx_format[NUM_RTX_CODE] = { +static const char *const rtx_format[NUM_RTX_CODE] = { #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , #include "rtl.def" #undef DEF_RTL_EXPR @@ -934,7 +897,8 @@ /* We also need codes and names for insn notes (not register notes). Note that we do *not* bias the note values here. */ -enum insn_note { +enum insn_note +{ #define DEF_INSN_NOTE(NAME) NAME, #include "insn-notes.def" #undef DEF_INSN_NOTE @@ -944,7 +908,7 @@ /* We must allocate one more entry here, as we use NOTE_INSN_MAX as the default field for line number notes. */ -static const char *const note_insn_name[NOTE_INSN_MAX+1] = { +static const char *const note_insn_name[NOTE_INSN_MAX + 1] = { #define DEF_INSN_NOTE(NAME) #NAME, #include "insn-notes.def" #undef DEF_INSN_NOTE @@ -992,8 +956,7 @@ oprintf (f, " 0,\n"); else oprintf (f, - " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", - rtx_next_new[i]); + " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new[i]); oprintf (f, "};\n"); } @@ -1017,16 +980,19 @@ return &string_type; } - nodot = create_option (NULL, "dot", ""); + nodot = create_string_option (NULL, "dot", ""); rtx_tp = create_pointer (find_structure ("rtx_def", 0)); rtvec_tp = create_pointer (find_structure ("rtvec_def", 0)); tree_tp = create_pointer (find_structure ("tree_node", 1)); mem_attrs_tp = create_pointer (find_structure ("mem_attrs", 0)); - reg_attrs_tp = create_pointer (find_structure ("reg_attrs", 0)); - basic_block_tp = create_pointer (find_structure ("basic_block_def", 0)); - constant_tp = create_pointer (find_structure ("constant_descriptor_rtx", 0)); - scalar_tp = &scalar_nonchar; /* rtunion int */ + reg_attrs_tp = + create_pointer (find_structure ("reg_attrs", 0)); + basic_block_tp = + create_pointer (find_structure ("basic_block_def", 0)); + constant_tp = + create_pointer (find_structure ("constant_descriptor_rtx", 0)); + scalar_tp = &scalar_nonchar; /* rtunion int */ { pair_p note_flds = NULL; @@ -1057,9 +1023,11 @@ /* NOTE_INSN_MAX is used as the default field for line number notes. */ if (c == NOTE_INSN_MAX) - note_flds->opt = create_option (nodot, "default", ""); + note_flds->opt = + create_string_option (nodot, "default", ""); else - note_flds->opt = create_option (nodot, "tag", note_insn_name[c]); + note_flds->opt = + create_string_option (nodot, "tag", note_insn_name[c]); } note_union_tp = new_structure ("rtx_def_note_subunion", 1, &lexer_line, note_flds, NULL); @@ -1067,13 +1035,10 @@ /* Create a type to represent the various forms of SYMBOL_REF_DATA. */ { pair_p sym_flds; - sym_flds = create_field (NULL, tree_tp, "rt_tree"); - sym_flds->opt = create_option (nodot, "default", ""); - + sym_flds->opt = create_string_option (nodot, "default", ""); sym_flds = create_field (sym_flds, constant_tp, "rt_constant"); - sym_flds->opt = create_option (nodot, "tag", "1"); - + sym_flds->opt = create_string_option (nodot, "tag", "1"); symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1, &lexer_line, sym_flds, NULL); } @@ -1105,12 +1070,11 @@ t = mem_attrs_tp, subname = "rt_mem"; else if (i == JUMP_INSN && aindex == 8) t = rtx_tp, subname = "rt_rtx"; - else if (i == CODE_LABEL && aindex == 4) + else if (i == CODE_LABEL && aindex == 5) t = scalar_tp, subname = "rt_int"; - else if (i == CODE_LABEL && aindex == 5) + else if (i == CODE_LABEL && aindex == 4) t = rtx_tp, subname = "rt_rtx"; - else if (i == LABEL_REF - && (aindex == 1 || aindex == 2)) + else if (i == LABEL_REF && (aindex == 1 || aindex == 2)) t = rtx_tp, subname = "rt_rtx"; else if (i == NOTE && aindex == 4) t = note_union_tp, subname = ""; @@ -1138,9 +1102,10 @@ t = scalar_tp, subname = "rt_int"; else { - error_at_line (&lexer_line, - "rtx type `%s' has `0' in position %lu, can't handle", - rtx_name[i], (unsigned long) aindex); + error_at_line + (&lexer_line, + "rtx type `%s' has `0' in position %lu, can't handle", + rtx_name[i], (unsigned long) aindex); t = &string_type; subname = "rt_int"; } @@ -1176,10 +1141,11 @@ break; default: - error_at_line (&lexer_line, - "rtx type `%s' has `%c' in position %lu, can't handle", - rtx_name[i], rtx_format[i][aindex], - (unsigned long)aindex); + error_at_line + (&lexer_line, + "rtx type `%s' has `%c' in position %lu, can't handle", + rtx_name[i], rtx_format[i][aindex], + (unsigned long) aindex); t = &string_type; subname = "rt_int"; break; @@ -1191,16 +1157,19 @@ subname)); subfields->opt = nodot; if (t == note_union_tp) - subfields->opt = create_option (subfields->opt, "desc", - "NOTE_KIND (&%0)"); + subfields->opt = + create_string_option (subfields->opt, "desc", + "NOTE_KIND (&%0)"); if (t == symbol_union_tp) - subfields->opt = create_option (subfields->opt, "desc", - "CONSTANT_POOL_ADDRESS_P (&%0)"); + subfields->opt = + create_string_option (subfields->opt, "desc", + "CONSTANT_POOL_ADDRESS_P (&%0)"); } if (i == SYMBOL_REF) { - /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P holds. */ + /* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P + holds. */ type_p field_tp = find_structure ("block_symbol", 0); subfields = create_optional_field (subfields, field_tp, "block_sym", @@ -1213,11 +1182,9 @@ ftag = xstrdup (rtx_name[i]); for (nmindex = 0; nmindex < strlen (ftag); nmindex++) ftag[nmindex] = TOUPPER (ftag[nmindex]); - flds = create_field (flds, substruct, ""); - flds->opt = create_option (nodot, "tag", ftag); + flds->opt = create_string_option (nodot, "tag", ftag); } - return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot); } @@ -1240,12 +1207,12 @@ return &string_type; } - nodot = create_option (NULL, "dot", ""); + nodot = create_string_option (NULL, "dot", ""); flds = create_field (NULL, t, ""); - flds->opt = create_option (nodot, "length", - "TREE_OPERAND_LENGTH ((tree) &%0)"); - flds->opt = create_option (flds->opt, "default", ""); + flds->opt = create_string_option (nodot, "length", + "TREE_OPERAND_LENGTH ((tree) &%0)"); + flds->opt = create_string_option (flds->opt, "default", ""); return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot); } @@ -1275,18 +1242,19 @@ for (; opt; opt = opt->next) if (strcmp (opt->name, "length") == 0) length_p = 1; - else if (strcmp (opt->name, "param_is") == 0 - || (strncmp (opt->name, "param", 5) == 0 - && ISDIGIT (opt->name[5]) - && strcmp (opt->name + 6, "_is") == 0)) + else if ((strcmp (opt->name, "param_is") == 0 + || (strncmp (opt->name, "param", 5) == 0 + && ISDIGIT (opt->name[5]) + && strcmp (opt->name + 6, "_is") == 0)) + && opt->kind == OPTION_TYPE) { int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0; - if (! UNION_OR_STRUCT_P (t) - && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p))) + if (!UNION_OR_STRUCT_P (t) + && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p))) { error_at_line (&lexer_line, - "option `%s' may only be applied to structures or structure pointers", + "option `%s' may only be applied to structures or structure pointers", opt->name); return t; } @@ -1294,14 +1262,15 @@ params_p = 1; if (params[num] != NULL) error_at_line (&lexer_line, "duplicate `%s' option", opt->name); - if (! ISDIGIT (opt->name[5])) - params[num] = create_pointer (CONST_CAST2(type_p, const char *, opt->info)); + if (!ISDIGIT (opt->name[5])) + params[num] = create_pointer (opt->info.type); else - params[num] = CONST_CAST2 (type_p, const char *, opt->info); + params[num] = opt->info.type; } - else if (strcmp (opt->name, "special") == 0) + else if (strcmp (opt->name, "special") == 0 + && opt->kind == OPTION_STRING) { - const char *special_name = opt->info; + const char *special_name = opt->info.string; if (strcmp (special_name, "tree_exp") == 0) t = adjust_field_tree_exp (t, opt); else if (strcmp (special_name, "rtx_def") == 0) @@ -1320,10 +1289,8 @@ t = pointer_p ? create_pointer (realt) : realt; } - if (! length_p - && pointer_p - && t->u.p->kind == TYPE_SCALAR - && t->u.p->u.scalar_is_char) + if (!length_p + && pointer_p && t->u.p->kind == TYPE_SCALAR && t->u.p->u.scalar_is_char) return &string_type; if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER && t->u.a.p->u.p->kind == TYPE_SCALAR @@ -1332,8 +1299,8 @@ return t; } - + static void set_gc_used_type (type_p, enum gc_used_enum, type_p *); static void set_gc_used (pair_p); @@ -1341,12 +1308,14 @@ static void process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef, - int *pass_param, int *length, int *skip, type_p *nested_ptr) + int *pass_param, int *length, int *skip, + type_p *nested_ptr) { options_p o; for (o = opt; o; o = o->next) - if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO) - set_gc_used_type (CONST_CAST2 (type_p, const char *, o->info), + if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO + && o->kind == OPTION_TYPE) + set_gc_used_type (o->info.type, GC_POINTED_TO, NULL); else if (strcmp (o->name, "maybe_undef") == 0) *maybe_undef = 1; @@ -1356,12 +1325,13 @@ *length = 1; else if (strcmp (o->name, "skip") == 0) *skip = 1; - else if (strcmp (o->name, "nested_ptr") == 0) - *nested_ptr = ((const struct nested_ptr_data *) o->info)->type; + else if (strcmp (o->name, "nested_ptr") == 0 + && o->kind == OPTION_NESTED) + *nested_ptr = ((const struct nested_ptr_data *) o->info.nested)->type; } + /* Set the gc_used field of T to LEVEL, and handle the types it references. */ - static void set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM]) { @@ -1403,7 +1373,7 @@ set_gc_used_type (find_param_structure (f->type->u.p, param), GC_POINTED_TO, NULL); else if (skip) - ; /* target type is not used through this field */ + ; /* target type is not used through this field */ else set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL); } @@ -1449,9 +1419,15 @@ static void set_gc_used (pair_p variables) { + int nbvars = 0; pair_p p; for (p = variables; p; p = p->next) - set_gc_used_type (p->type, GC_USED, NULL); + { + set_gc_used_type (p->type, GC_USED, NULL); + nbvars++; + }; + if (verbosity_level >= 2) + printf ("%s used %d GTY-ed variables\n", progname, nbvars); } /* File mapping routines. For each input file, there is one output .c file @@ -1522,7 +1498,7 @@ va_start (ap, format); slength = vasprintf (&s, format, ap); - if (s == NULL || (int)slength < 0) + if (s == NULL || (int) slength < 0) fatal ("out of memory"); va_end (ap); @@ -1531,9 +1507,11 @@ size_t new_len = o->buflength; if (new_len == 0) new_len = 1024; - do { - new_len *= 2; - } while (o->bufused + slength >= new_len); + do + { + new_len *= 2; + } + while (o->bufused + slength >= new_len); o->buf = XRESIZEVEC (char, o->buf, new_len); o->buflength = new_len; } @@ -1563,15 +1541,15 @@ /* gtype-desc.c is a little special, so we create it here. */ { /* The order of files here matters very much. */ - static const char *const ifiles [] = { + static const char *const ifiles[] = { "config.h", "system.h", "coretypes.h", "tm.h", - "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h", + "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h", "tree.h", "rtl.h", "function.h", "insn-config.h", "expr.h", "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h", "optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h", "tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h", "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h", - "target.h", "ipa-prop.h", "lto-streamer.h", NULL + "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", NULL }; const char *const *ifp; outf_p gtype_desc_c; @@ -1586,40 +1564,43 @@ } } -/* For F a filename, return the real basename of F, with all the directory - components skipped. */ +/* For INPF an input file, return the real basename of INPF, with all + the directory components skipped. */ static const char * -get_file_realbasename (const char *f) +get_file_realbasename (const input_file *inpf) { - const char * lastslash = strrchr (f, '/'); + const char *f = get_input_file_name (inpf); + const char *lastslash = strrchr (f, '/'); return (lastslash != NULL) ? lastslash + 1 : f; } -/* For F a filename, return the relative path to F from $(srcdir) if the - latter is a prefix in F, NULL otherwise. */ - -static const char * -get_file_srcdir_relative_path (const char *f) +/* For INPF a filename, return the relative path to INPF from + $(srcdir) if the latter is a prefix in INPF, NULL otherwise. */ + +const char * +get_file_srcdir_relative_path (const input_file *inpf) { + const char *f = get_input_file_name (inpf); if (strlen (f) > srcdir_len && IS_DIR_SEPARATOR (f[srcdir_len]) - && memcmp (f, srcdir, srcdir_len) == 0) + && strncmp (f, srcdir, srcdir_len) == 0) return f + srcdir_len + 1; else return NULL; } -/* For F a filename, return the relative path to F from $(srcdir) if the - latter is a prefix in F, or the real basename of F otherwise. */ +/* For INPF an input_file, return the relative path to INPF from + $(srcdir) if the latter is a prefix in INPF, or the real basename + of INPF otherwise. */ static const char * -get_file_basename (const char *f) +get_file_basename (const input_file *inpf) { - const char * srcdir_path = get_file_srcdir_relative_path (f); - - return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (f); + const char *srcdir_path = get_file_srcdir_relative_path (inpf); + + return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (inpf); } /* For F a filename, return the lang_dir_names relative index of the language @@ -1633,7 +1614,7 @@ for (lang_index = 0; lang_index < num_lang_dirs; lang_index++) { - const char * langdir = lang_dir_names [lang_index]; + const char *langdir = lang_dir_names[lang_index]; size_t langdir_len = strlen (langdir); if (f_len > langdir_len @@ -1645,39 +1626,47 @@ return -1; } -/* For F a filename, return the name of language directory where F is located, - if any, NULL otherwise. */ +/* For INPF an input file, return the name of language directory where + F is located, if any, NULL otherwise. */ static const char * -get_file_langdir (const char *f) +get_file_langdir (const input_file *inpf) { - /* Get the relative path to F from $(srcdir) and find the language by - comparing the prefix with language directory names. If F is not even - srcdir relative, no point in looking further. */ + /* Get the relative path to INPF from $(srcdir) and find the + language by comparing the prefix with language directory names. + If INPF is not even srcdir relative, no point in looking + further. */ int lang_index; - const char * srcdir_relative_path = get_file_srcdir_relative_path (f); + const char *srcdir_relative_path = get_file_srcdir_relative_path (inpf); + const char *r; if (!srcdir_relative_path) return NULL; lang_index = get_prefix_langdir_index (srcdir_relative_path); - - return (lang_index >= 0) ? lang_dir_names [lang_index] : NULL; + if (lang_index < 0 && strncmp (srcdir_relative_path, "c-family", 8) == 0) + r = "c-family"; + else if (lang_index >= 0) + r = lang_dir_names[lang_index]; + else + r = NULL; + + return r; } -/* The gt- output file name for F. */ +/* The gt- output file name for INPF. */ static const char * -get_file_gtfilename (const char *f) +get_file_gtfilename (const input_file *inpf) { /* Cook up an initial version of the gt- file name from the file real basename and the language name, if any. */ - const char *basename = get_file_realbasename (f); - const char *langdir = get_file_langdir (f); - - char * result = + const char *basename = get_file_realbasename (inpf); + const char *langdir = get_file_langdir (inpf); + + char *result = (langdir ? xasprintf ("gt-%s-%s", langdir, basename) : xasprintf ("gt-%s", basename)); @@ -1688,7 +1677,7 @@ char *s = result; for (; *s != '.'; s++) - if (! ISALNUM (*s) && *s != '-') + if (!ISALNUM (*s) && *s != '-') *s = '-'; memcpy (s, ".h", sizeof (".h")); @@ -1696,24 +1685,275 @@ return result; } +/* Each input_file has its associated output file outf_p. The + association is computed by the function + get_output_file_with_visibility. The associated file is cached + inside input_file in its inpoutf field, so is really computed only + once. Associated output file paths (i.e. output_name-s) are + computed by a rule based regexp machinery, using the files_rules + array of struct file_rule_st. A for_name is also computed, giving + the source file name for which the output_file is generated; it is + often the last component of the input_file path. */ + + +/* + Regexpr machinery to compute the output_name and for_name-s of each + input_file. We have a sequence of file rules which gives the POSIX + extended regular expression to match an input file path, and two + transformed strings for the corresponding output_name and the + corresponding for_name. The transformed string contain dollars: $0 + is replaced by the entire match, $1 is replaced by the substring + matching the first parenthesis in the regexp, etc. And $$ is replaced + by a single verbatim dollar. The rule order is important. The + general case is last, and the particular cases should come before. + An action routine can, when needed, update the out_name & for_name + and/or return the appropriate output file. It is invoked only when a + rule is triggered. When a rule is triggered, the output_name and + for_name are computed using their transform string in while $$, $0, + $1, ... are suitably replaced. If there is an action, it is called. + In some few cases, the action can directly return the outf_p, but + usually it just updates the output_name and for_name so should free + them before replacing them. The get_output_file_with_visibility + function creates an outf_p only once per each output_name, so it + scans the output_files list for previously seen output file names. + */ + +/* Signature of actions in file rules. */ +typedef outf_p (frul_actionrout_t) (input_file*, char**, char**); + + +struct file_rule_st { + const char* frul_srcexpr; /* Source string for regexp. */ + int frul_rflags; /* Flags passed to regcomp, usually + * REG_EXTENDED. */ + regex_t* frul_re; /* Compiled regular expression + obtained by regcomp. */ + const char* frul_tr_out; /* Transformation string for making + * the output_name, with $1 ... $9 for + * subpatterns and $0 for the whole + * matched filename. */ + const char* frul_tr_for; /* Tranformation string for making the + for_name. */ + frul_actionrout_t* frul_action; /* The action, if non null, is + * called once the rule matches, on + * the transformed out_name & + * for_name. It could change them + * and/or give the output file. */ +}; + +/* File rule action handling *.h files. */ +static outf_p header_dot_h_frul (input_file*, char**, char**); + +/* File rule action handling *.c files. */ +static outf_p source_dot_c_frul (input_file*, char**, char**); + +#define NULL_REGEX (regex_t*)0 + +/* The prefix in our regexp-s matching the directory. */ +#define DIR_PREFIX_REGEX "^(([^/]*/)*)" + +#define NULL_FRULACT (frul_actionrout_t*)0 + +/* The array of our rules governing file name generation. Rules order + matters, so change with extreme care! */ + +struct file_rule_st files_rules[] = { + /* the c-family/ source directory is special. */ + { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.c$", + REG_EXTENDED, NULL_REGEX, + "gt-c-family-$3.h", "c-family/$3.c", NULL_FRULACT}, + + { DIR_PREFIX_REGEX "c-family/([[:alnum:]_-]*)\\.h$", + REG_EXTENDED, NULL_REGEX, + "gt-c-family-$3.h", "c-family/$3.h", NULL_FRULACT}, + + /* Both c-lang.h & c-tree.h gives gt-c-decl.h for c-decl.c ! */ + { DIR_PREFIX_REGEX "c-lang\\.h$", + REG_EXTENDED, NULL_REGEX, "gt-c-decl.h", "c-decl.c", NULL_FRULACT}, + + { DIR_PREFIX_REGEX "c-tree\\.h$", + REG_EXTENDED, NULL_REGEX, "gt-c-decl.h", "c-decl.c", NULL_FRULACT}, + + /* cp/cp-tree.h gives gt-cp-tree.h for cp/tree.c ! */ + { DIR_PREFIX_REGEX "cp/cp-tree\\.h$", + REG_EXTENDED, NULL_REGEX, + "gt-cp-tree.h", "cp/tree.c", NULL_FRULACT }, + + /* cp/decl.h & cp/decl.c gives gt-cp-decl.h for cp/decl.c ! */ + { DIR_PREFIX_REGEX "cp/decl\\.[ch]$", + REG_EXTENDED, NULL_REGEX, + "gt-cp-decl.h", "cp/decl.c", NULL_FRULACT }, + + /* cp/name-lookup.h gives gt-cp-name-lookup.h for cp/name-lookup.c ! */ + { DIR_PREFIX_REGEX "cp/name-lookup\\.h$", + REG_EXTENDED, NULL_REGEX, + "gt-cp-name-lookup.h", "cp/name-lookup.c", NULL_FRULACT }, + + /* objc/objc-act.h fives gt-objc-objc-act.h for objc/objc-act.c ! */ + { DIR_PREFIX_REGEX "objc/objc-act\\.h$", + REG_EXTENDED, NULL_REGEX, + "gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT }, + + /* General cases. For header *.h and source *.c files, we need + * special actions to handle the language. */ + + /* Source *.c files are using get_file_gtfilename to compute their + output_name and get_file_basename to compute their for_name + thru the source_dot_c_frul action. */ + { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.c$", + REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.c", source_dot_c_frul}, + /* Common header files get "gtype-desc.c" as their output_name, + * while language specific header files are handled specially. So + * we need the header_dot_h_frul action. */ + { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.h$", + REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.h", header_dot_h_frul}, + + { DIR_PREFIX_REGEX "([[:alnum:]_-]*)\\.in$", + REG_EXTENDED, NULL_REGEX, "gt-$3.h", "$3.in", NULL_FRULACT}, + + /* Mandatory null last entry signaling end of rules. */ + {NULL, 0, NULL_REGEX, NULL, NULL, NULL_FRULACT} +}; + +/* Special file rules action for handling *.h header files. It gives + "gtype-desc.c" for common headers and corresponding output + files for language-specific header files. */ +static outf_p +header_dot_h_frul (input_file* inpf, char**poutname, + char**pforname ATTRIBUTE_UNUSED) +{ + const char *basename = 0; + int lang_index = 0; + DBGPRINTF ("inpf %p inpname %s outname %s forname %s", + (void*) inpf, get_input_file_name (inpf), + *poutname, *pforname); + basename = get_file_basename (inpf); + lang_index = get_prefix_langdir_index (basename); + DBGPRINTF ("basename %s lang_index %d", basename, lang_index); + + if (lang_index >= 0) + { + /* The header is language specific. Given output_name & + for_name remains unchanged. The base_files array gives the + outf_p. */ + DBGPRINTF ("header_dot_h found language specific @ %p '%s'", + (void*) base_files[lang_index], + (base_files[lang_index])->name); + return base_files[lang_index]; + } + else + { + /* The header is common to all front-end languages. So + output_name is "gtype-desc.c" file. The calling function + get_output_file_with_visibility will find its outf_p. */ + free (*poutname); + *poutname = xstrdup ("gtype-desc.c"); + DBGPRINTF ("special 'gtype-desc.c' for inpname %s", + get_input_file_name (inpf)); + return NULL; + } +} + + +/* Special file rules action for handling *.c source files using + * get_file_gtfilename to compute their output_name and + * get_file_basename to compute their for_name. The output_name is + * gt-<LANG>-<BASE>.h for language specific source files, and + * gt-<BASE>.h for common source files. */ +static outf_p +source_dot_c_frul (input_file* inpf, char**poutname, char**pforname) +{ + char *newbasename = CONST_CAST (char*, get_file_basename (inpf)); + char *newoutname = CONST_CAST (char*, get_file_gtfilename (inpf)); + DBGPRINTF ("inpf %p inpname %s original outname %s forname %s", + (void*) inpf, get_input_file_name (inpf), + *poutname, *pforname); + DBGPRINTF ("newoutname %s", newoutname); + DBGPRINTF ("newbasename %s", newbasename); + free (*poutname); + free (*pforname); + *poutname = newoutname; + *pforname = newbasename; + return NULL; +} + +/* Utility function for get_output_file_with_visibility which returns + * a malloc-ed substituted string using TRS on matching of the FILNAM + * file name, using the PMATCH array. */ +static char* +matching_file_name_substitute (const char *filnam, regmatch_t pmatch[10], + const char *trs) +{ + struct obstack str_obstack; + char *str = NULL; + char *rawstr = NULL; + const char *pt = NULL; + DBGPRINTF ("filnam %s", filnam); + obstack_init (&str_obstack); + for (pt = trs; *pt; pt++) { + char c = *pt; + if (c == '$') + { + if (pt[1] == '$') + { + /* A double dollar $$ is substituted by a single verbatim + dollar, but who really uses dollar signs in file + paths? */ + obstack_1grow (&str_obstack, '$'); + } + else if (ISDIGIT (pt[1])) + { + /* Handle $0 $1 ... $9 by appropriate substitution. */ + int dolnum = pt[1] - '0'; + int so = pmatch[dolnum].rm_so; + int eo = pmatch[dolnum].rm_eo; + DBGPRINTF ("so=%d eo=%d dolnum=%d", so, eo, dolnum); + if (so>=0 && eo>=so) + obstack_grow (&str_obstack, filnam + so, eo - so); + } + else + { + /* This can happen only when files_rules is buggy! */ + gcc_unreachable(); + } + /* Always skip the character after the dollar. */ + pt++; + } + else + obstack_1grow (&str_obstack, c); + } + obstack_1grow (&str_obstack, '\0'); + rawstr = XOBFINISH (&str_obstack, char *); + str = xstrdup (rawstr); + obstack_free (&str_obstack, rawstr); + DBGPRINTF ("matched replacement %s", str); + rawstr = NULL; + return str; +} + + /* An output file, suitable for definitions, that can see declarations - made in INPUT_FILE and is linked into every language that uses - INPUT_FILE. */ + made in INPF and is linked into every language that uses INPF. + Since the the result is cached inside INPF, that argument cannot be + declared constant, but is "almost" constant. */ outf_p -get_output_file_with_visibility (const char *input_file) +get_output_file_with_visibility (input_file *inpf) { outf_p r; - size_t len; - const char *basename; - const char *for_name; - const char *output_name; + char *for_name = NULL; + char *output_name = NULL; + const char* inpfname; /* This can happen when we need a file with visibility on a structure that we've never seen. We have to just hope that it's globally visible. */ - if (input_file == NULL) - input_file = "system.h"; + if (inpf == NULL) + inpf = system_h_file; + + /* The result is cached in INPF, so return it if already known. */ + if (inpf->inpoutf) + return inpf->inpoutf; /* In plugin mode, return NULL unless the input_file is one of the plugin_files. */ @@ -1721,77 +1961,140 @@ { size_t i; for (i = 0; i < nb_plugin_files; i++) - if (strcmp (input_file, plugin_files[i]) == 0) - return plugin_output; + if (inpf == plugin_files[i]) + { + inpf->inpoutf = plugin_output; + return plugin_output; + } return NULL; } - /* Determine the output file name. */ - basename = get_file_basename (input_file); - - len = strlen (basename); - if ((len > 2 && memcmp (basename+len-2, ".c", 2) == 0) - || (len > 2 && memcmp (basename+len-2, ".y", 2) == 0) - || (len > 3 && memcmp (basename+len-3, ".in", 3) == 0)) + inpfname = get_input_file_name (inpf); + + /* Try each rule in sequence in files_rules until one is triggered. */ + { + int rulix = 0; + DBGPRINTF ("passing input file @ %p named %s thru the files_rules", + (void*) inpf, inpfname); + + for (; files_rules[rulix].frul_srcexpr != NULL; rulix++) + { + DBGPRINTF ("rulix#%d srcexpr %s", + rulix, files_rules[rulix].frul_srcexpr); + + if (!files_rules[rulix].frul_re) + { + /* Compile the regexpr lazily. */ + int err = 0; + files_rules[rulix].frul_re = XCNEW (regex_t); + err = regcomp (files_rules[rulix].frul_re, + files_rules[rulix].frul_srcexpr, + files_rules[rulix].frul_rflags); + if (err) + { + /* The regular expression compilation fails only when + file_rules is buggy. */ + gcc_unreachable (); + } + } + + output_name = NULL; + for_name = NULL; + + /* Match the regexpr and trigger the rule if matched. */ + { + /* We have exactly ten pmatch-s, one for each $0, $1, $2, + $3, ... $9. */ + regmatch_t pmatch[10]; + memset (pmatch, 0, sizeof (pmatch)); + if (!regexec (files_rules[rulix].frul_re, + inpfname, 10, pmatch, 0)) + { + DBGPRINTF ("input @ %p filename %s matched rulix#%d pattern %s", + (void*) inpf, inpfname, rulix, + files_rules[rulix].frul_srcexpr); + for_name = + matching_file_name_substitute (inpfname, pmatch, + files_rules[rulix].frul_tr_for); + DBGPRINTF ("for_name %s", for_name); + output_name = + matching_file_name_substitute (inpfname, pmatch, + files_rules[rulix].frul_tr_out); + DBGPRINTF ("output_name %s", output_name); + if (files_rules[rulix].frul_action) + { + /* Invoke our action routine. */ + outf_p of = NULL; + DBGPRINTF ("before action rulix#%d output_name %s for_name %s", + rulix, output_name, for_name); + of = + (files_rules[rulix].frul_action) (inpf, + &output_name, &for_name); + DBGPRINTF ("after action rulix#%d of=%p output_name %s for_name %s", + rulix, (void*)of, output_name, for_name); + /* If the action routine returned something, give it back + immediately and cache it in inpf. */ + if (of) + { + inpf->inpoutf = of; + return of; + } + } + /* The rule matched, and had no action, or that action did + not return any output file but could have changed the + output_name or for_name. We break out of the loop on the + files_rules. */ + break; + } + else + { + /* The regexpr did not match. */ + DBGPRINTF ("rulix#%d did not match %s pattern %s", + rulix, inpfname, files_rules[rulix].frul_srcexpr); + continue; + } + } + } + } + if (!output_name || !for_name) { - output_name = get_file_gtfilename (input_file); - for_name = basename; + /* This is impossible, and could only happen if the files_rules is + incomplete or buggy. */ + gcc_unreachable (); } - /* Some headers get used by more than one front-end; hence, it - would be inappropriate to spew them out to a single gtype-<lang>.h - (and gengtype doesn't know how to direct spewage into multiple - gtype-<lang>.h headers at this time). Instead, we pair up these - headers with source files (and their special purpose gt-*.h headers). */ - else if (strcmp (basename, "c-common.h") == 0) - output_name = "gt-c-common.h", for_name = "c-common.c"; - else if (strcmp (basename, "c-lang.h") == 0) - output_name = "gt-c-decl.h", for_name = "c-decl.c"; - else if (strcmp (basename, "c-tree.h") == 0) - output_name = "gt-c-decl.h", for_name = "c-decl.c"; - else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2]) - && strcmp (basename + 3, "cp-tree.h") == 0) - output_name = "gt-cp-tree.h", for_name = "cp/tree.c"; - else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2]) - && strcmp (basename + 3, "decl.h") == 0) - output_name = "gt-cp-decl.h", for_name = "cp/decl.c"; - else if (strncmp (basename, "cp", 2) == 0 && IS_DIR_SEPARATOR (basename[2]) - && strcmp (basename + 3, "name-lookup.h") == 0) - output_name = "gt-cp-name-lookup.h", for_name = "cp/name-lookup.c"; - else if (strncmp (basename, "objc", 4) == 0 && IS_DIR_SEPARATOR (basename[4]) - && strcmp (basename + 5, "objc-act.h") == 0) - output_name = "gt-objc-objc-act.h", for_name = "objc/objc-act.c"; - else - { - int lang_index = get_prefix_langdir_index (basename); - - if (lang_index >= 0) - return base_files[lang_index]; - - output_name = "gtype-desc.c"; - for_name = NULL; - } - - /* Look through to see if we've ever seen this output filename before. */ + + /* Look through to see if we've ever seen this output filename + before. If found, cache the result in inpf. */ for (r = output_files; r; r = r->next) if (strcmp (r->name, output_name) == 0) - return r; - - /* If not, create it. */ + { + inpf->inpoutf = r; + DBGPRINTF ("found r @ %p for output_name %s for_name %s", (void*)r, + output_name, for_name); + return r; + } + + /* If not found, create it, and cache it in inpf. */ r = create_file (for_name, output_name); gcc_assert (r && r->name); + DBGPRINTF ("created r @ %p for output_name %s for_name %s", (void*) r, + output_name, for_name); + inpf->inpoutf = r; return r; + + } /* The name of an output file, suitable for definitions, that can see - declarations made in INPUT_FILE and is linked into every language - that uses INPUT_FILE. */ + declarations made in INPF and is linked into every language that + uses INPF. */ const char * -get_output_file_name (const char *input_file) +get_output_file_name (input_file* inpf) { - outf_p o = get_output_file_with_visibility (input_file); + outf_p o = get_output_file_with_visibility (inpf); if (o) return o->name; return NULL; @@ -1829,31 +2132,61 @@ static void close_output_files (void) { + int nbwrittenfiles = 0; outf_p of; for (of = output_files; of; of = of->next) { - if (!is_file_equal(of)) - { - FILE *newfile = fopen (of->name, "w"); - if (newfile == NULL) - fatal ("opening output file %s: %s", of->name, strerror (errno)); - if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused) - fatal ("writing output file %s: %s", of->name, strerror (errno)); - if (fclose (newfile) != 0) - fatal ("closing output file %s: %s", of->name, strerror (errno)); - } - free(of->buf); + if (!is_file_equal (of)) + { + FILE *newfile = NULL; + char *backupname = NULL; + /* Back up the old version of the output file gt-FOO.c as + BACKUPDIR/gt-FOO.c~ if we have a backup directory. */ + if (backup_dir) + { + backupname = concat (backup_dir, "/", + lbasename (of->name), "~", NULL); + if (!access (of->name, F_OK) && rename (of->name, backupname)) + fatal ("failed to back up %s as %s: %s", + of->name, backupname, xstrerror (errno)); + } + + newfile = fopen (of->name, "w"); + if (newfile == NULL) + fatal ("opening output file %s: %s", of->name, xstrerror (errno)); + if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused) + fatal ("writing output file %s: %s", of->name, xstrerror (errno)); + if (fclose (newfile) != 0) + fatal ("closing output file %s: %s", of->name, xstrerror (errno)); + nbwrittenfiles++; + if (verbosity_level >= 2 && backupname) + printf ("%s wrote #%-3d %s backed-up in %s\n", + progname, nbwrittenfiles, of->name, backupname); + else if (verbosity_level >= 1) + printf ("%s write #%-3d %s\n", progname, nbwrittenfiles, of->name); + free (backupname); + } + else + { + /* output file remains unchanged. */ + if (verbosity_level >= 2) + printf ("%s keep %s\n", progname, of->name); + } + free (of->buf); of->buf = NULL; of->bufused = of->buflength = 0; } + if (verbosity_level >= 1) + printf ("%s wrote %d files.\n", progname, nbwrittenfiles); } -struct flist { +struct flist +{ struct flist *next; int started_p; - const char *name; + const input_file* file; outf_p f; }; @@ -1863,10 +2196,8 @@ For structures, given a pointer to the item in 'val'. For misc. pointers, given the item in 'val'. */ -typedef void (*process_field_fn) - (type_p f, const struct walk_type_data *p); -typedef void (*func_name_fn) - (type_p s, const struct walk_type_data *p); +typedef void (*process_field_fn) (type_p f, const struct walk_type_data * p); +typedef void (*func_name_fn) (type_p s, const struct walk_type_data * p); /* Parameters for write_types. */ @@ -1885,29 +2216,27 @@ const char *, const char *); static void output_mangled_typename (outf_p, const_type_p); static void walk_type (type_p t, struct walk_type_data *d); -static void write_func_for_structure - (type_p orig_s, type_p s, type_p * param, - const struct write_types_data *wtd); +static void write_func_for_structure (type_p orig_s, type_p s, type_p *param, + const struct write_types_data *wtd); static void write_types_process_field - (type_p f, const struct walk_type_data *d); + (type_p f, const struct walk_type_data *d); static void write_types (outf_p output_header, - type_p structures, + type_p structures, type_p param_structs, const struct write_types_data *wtd); static void write_types_local_process_field - (type_p f, const struct walk_type_data *d); + (type_p f, const struct walk_type_data *d); static void write_local_func_for_structure - (const_type_p orig_s, type_p s, type_p * param); + (const_type_p orig_s, type_p s, type_p *param); static void write_local (outf_p output_header, - type_p structures, - type_p param_structs); + type_p structures, type_p param_structs); static void write_enum_defn (type_p structures, type_p param_structs); static int contains_scalar_p (type_p t); -static void put_mangled_filename (outf_p , const char *); +static void put_mangled_filename (outf_p, const input_file *); static void finish_root_table (struct flist *flp, const char *pfx, const char *tname, const char *lastname, const char *name); -static void write_root (outf_p , pair_p, type_p, const char *, int, +static void write_root (outf_p, pair_p, type_p, const char *, int, struct fileloc *, const char *, bool); static void write_array (outf_p f, pair_p v, const struct write_types_data *wtd); @@ -1942,35 +2271,40 @@ { if (t == NULL) oprintf (of, "Z"); - else switch (t->kind) - { - case TYPE_POINTER: - oprintf (of, "P"); - output_mangled_typename (of, t->u.p); - break; - case TYPE_SCALAR: - oprintf (of, "I"); - break; - case TYPE_STRING: - oprintf (of, "S"); - break; - case TYPE_STRUCT: - case TYPE_UNION: - case TYPE_LANG_STRUCT: - oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), t->u.s.tag); - break; - case TYPE_PARAM_STRUCT: + else + switch (t->kind) { - int i; - for (i = 0; i < NUM_PARAM; i++) - if (t->u.param_struct.param[i] != NULL) - output_mangled_typename (of, t->u.param_struct.param[i]); - output_mangled_typename (of, t->u.param_struct.stru); + case TYPE_NONE: + gcc_unreachable (); + break; + case TYPE_POINTER: + oprintf (of, "P"); + output_mangled_typename (of, t->u.p); + break; + case TYPE_SCALAR: + oprintf (of, "I"); + break; + case TYPE_STRING: + oprintf (of, "S"); + break; + case TYPE_STRUCT: + case TYPE_UNION: + case TYPE_LANG_STRUCT: + oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), + t->u.s.tag); + break; + case TYPE_PARAM_STRUCT: + { + int i; + for (i = 0; i < NUM_PARAM; i++) + if (t->u.param_struct.param[i] != NULL) + output_mangled_typename (of, t->u.param_struct.param[i]); + output_mangled_typename (of, t->u.param_struct.stru); + } + break; + case TYPE_ARRAY: + gcc_unreachable (); } - break; - case TYPE_ARRAY: - gcc_unreachable (); - } } /* Print PARAM to D->OF processing escapes. D->VAL references the @@ -1987,30 +2321,31 @@ for (p = param; *p; p++) if (*p != '%') oprintf (d->of, "%c", *p); - else switch (*++p) - { - case 'h': - oprintf (d->of, "(%s)", d->prev_val[2]); - break; - case '0': - oprintf (d->of, "(%s)", d->prev_val[0]); - break; - case '1': - oprintf (d->of, "(%s)", d->prev_val[1]); - break; - case 'a': + else + switch (*++p) { - const char *pp = d->val + strlen (d->val); - while (pp[-1] == ']') - while (*pp != '[') - pp--; - oprintf (d->of, "%s", pp); + case 'h': + oprintf (d->of, "(%s)", d->prev_val[2]); + break; + case '0': + oprintf (d->of, "(%s)", d->prev_val[0]); + break; + case '1': + oprintf (d->of, "(%s)", d->prev_val[1]); + break; + case 'a': + { + const char *pp = d->val + strlen (d->val); + while (pp[-1] == ']') + while (*pp != '[') + pp--; + oprintf (d->of, "%s", pp); + } + break; + default: + error_at_line (d->line, "`%s' option contains bad escape %c%c", + oname, '%', *p); } - break; - default: - error_at_line (d->line, "`%s' option contains bad escape %c%c", - oname, '%', *p); - } } /* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL, @@ -2037,8 +2372,8 @@ d->needs_cast_p = false; for (oo = d->opt; oo; oo = oo->next) - if (strcmp (oo->name, "length") == 0) - length = oo->info; + if (strcmp (oo->name, "length") == 0 && oo->kind == OPTION_STRING) + length = oo->info.string; else if (strcmp (oo->name, "maybe_undef") == 0) maybe_undef_p = 1; else if (strncmp (oo->name, "use_param", 9) == 0 @@ -2046,12 +2381,13 @@ use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0'; else if (strcmp (oo->name, "use_params") == 0) use_params_p = 1; - else if (strcmp (oo->name, "desc") == 0) - desc = oo->info; + else if (strcmp (oo->name, "desc") == 0 && oo->kind == OPTION_STRING) + desc = oo->info.string; else if (strcmp (oo->name, "mark_hook") == 0) ; - else if (strcmp (oo->name, "nested_ptr") == 0) - nested_ptr_d = (const struct nested_ptr_data *) oo->info; + else if (strcmp (oo->name, "nested_ptr") == 0 + && oo->kind == OPTION_NESTED) + nested_ptr_d = (const struct nested_ptr_data *) oo->info.nested; else if (strcmp (oo->name, "dot") == 0) ; else if (strcmp (oo->name, "tag") == 0) @@ -2062,13 +2398,10 @@ ; else if (strcmp (oo->name, "default") == 0) ; - else if (strcmp (oo->name, "descbits") == 0) - ; else if (strcmp (oo->name, "param_is") == 0) ; else if (strncmp (oo->name, "param", 5) == 0 - && ISDIGIT (oo->name[5]) - && strcmp (oo->name + 6, "_is") == 0) + && ISDIGIT (oo->name[5]) && strcmp (oo->name + 6, "_is") == 0) ; else if (strcmp (oo->name, "chain_next") == 0) ; @@ -2078,6 +2411,8 @@ ; else if (strcmp (oo->name, "reorder") == 0) ; + else if (strcmp (oo->name, "variable_size") == 0) + ; else error_at_line (d->line, "unknown option `%s'\n", oo->name); @@ -2090,7 +2425,7 @@ if (pointer_p) t = t->u.p; - if (! UNION_OR_STRUCT_P (t)) + if (!UNION_OR_STRUCT_P (t)) error_at_line (d->line, "`use_params' option on unimplemented type"); else t = find_param_structure (t, d->param); @@ -2114,12 +2449,11 @@ t = nt; } else - error_at_line (d->line, "no parameter defined for `%s'", - d->val); + error_at_line (d->line, "no parameter defined for `%s'", d->val); } if (maybe_undef_p - && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p))) + && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p))) { error_at_line (d->line, "field `%s' has invalid option `maybe_undef_p'\n", @@ -2136,16 +2470,15 @@ case TYPE_POINTER: { - if (maybe_undef_p - && t->u.p->u.s.line.file == NULL) + if (maybe_undef_p && t->u.p->u.s.line.file == NULL) { oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val); break; } - if (! length) + if (!length) { - if (! UNION_OR_STRUCT_P (t->u.p) + if (!UNION_OR_STRUCT_P (t->u.p) && t->u.p->kind != TYPE_PARAM_STRUCT) { error_at_line (d->line, @@ -2158,12 +2491,11 @@ { const char *oldprevval2 = d->prev_val[2]; - if (! UNION_OR_STRUCT_P (nested_ptr_d->type)) + if (!UNION_OR_STRUCT_P (nested_ptr_d->type)) { error_at_line (d->line, "field `%s' has invalid " - "option `nested_ptr'\n", - d->val); + "option `nested_ptr'\n", d->val); return; } @@ -2175,8 +2507,7 @@ (nested_ptr_d->type->kind == TYPE_UNION ? "union" : "struct"), nested_ptr_d->type->u.s.tag, - d->fn_wants_lvalue ? "" : "const ", - d->val); + d->fn_wants_lvalue ? "" : "const ", d->val); oprintf (d->of, "%*s", d->indent + 2, ""); output_escaped_param (d, nested_ptr_d->convert_from, "nested_ptr"); @@ -2212,8 +2543,8 @@ oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val); d->indent += 2; oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter); - oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, "", - loopcounter, loopcounter); + oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, + "", loopcounter, loopcounter); output_escaped_param (d, length, "length"); oprintf (d->of, "); i%d++) {\n", loopcounter); d->indent += 2; @@ -2227,7 +2558,7 @@ d->used_length = 0; d->indent -= 2; oprintf (d->of, "%*s}\n", d->indent, ""); - d->process_field(t, d); + d->process_field (t, d); d->indent -= 2; oprintf (d->of, "%*s}\n", d->indent, ""); } @@ -2291,7 +2622,7 @@ int seen_default_p = 0; options_p o; - if (! t->u.s.line.file) + if (!t->u.s.line.file) error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag); if ((d->bitmap & t->u.s.bitmap) != d->bitmap) @@ -2304,8 +2635,9 @@ /* Some things may also be defined in the structure's options. */ for (o = t->u.s.opt; o; o = o->next) - if (! desc && strcmp (o->name, "desc") == 0) - desc = o->info; + if (!desc && strcmp (o->name, "desc") == 0 + && o->kind == OPTION_STRING) + desc = o->info.string; d->prev_val[2] = oldval; d->prev_val[1] = oldprevval2; @@ -2313,7 +2645,8 @@ { if (desc == NULL) { - error_at_line (d->line, "missing `desc' option for union `%s'", + error_at_line (d->line, + "missing `desc' option for union `%s'", t->u.s.tag); desc = "1"; } @@ -2335,16 +2668,19 @@ d->reorder_fn = NULL; for (oo = f->opt; oo; oo = oo->next) - if (strcmp (oo->name, "dot") == 0) - dot = oo->info; - else if (strcmp (oo->name, "tag") == 0) - tagid = oo->info; + if (strcmp (oo->name, "dot") == 0 + && oo->kind == OPTION_STRING) + dot = oo->info.string; + else if (strcmp (oo->name, "tag") == 0 + && oo->kind == OPTION_STRING) + tagid = oo->info.string; else if (strcmp (oo->name, "skip") == 0) skip_p = 1; else if (strcmp (oo->name, "default") == 0) default_p = 1; - else if (strcmp (oo->name, "reorder") == 0) - d->reorder_fn = oo->info; + else if (strcmp (oo->name, "reorder") == 0 + && oo->kind == OPTION_STRING) + d->reorder_fn = oo->info.string; else if (strncmp (oo->name, "use_param", 9) == 0 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9]))) use_param_p = 1; @@ -2363,19 +2699,20 @@ d->indent += 2; seen_default_p = 1; } - else if (! union_p && (default_p || tagid)) + else if (!union_p && (default_p || tagid)) error_at_line (d->line, "can't use `%s' outside a union on field `%s'", default_p ? "default" : "tag", f->name); - else if (union_p && ! (default_p || tagid) + else if (union_p && !(default_p || tagid) && f->type->kind == TYPE_SCALAR) { fprintf (stderr, - "%s:%d: warning: field `%s' is missing `tag' or `default' option\n", - d->line->file, d->line->line, f->name); + "%s:%d: warning: field `%s' is missing `tag' or `default' option\n", + get_input_file_name (d->line->file), d->line->line, + f->name); continue; } - else if (union_p && ! (default_p || tagid)) + else if (union_p && !(default_p || tagid)) error_at_line (d->line, "field `%s' is missing `tag' or `default' option", f->name); @@ -2404,7 +2741,7 @@ d->prev_val[1] = oldprevval1; d->prev_val[2] = oldprevval2; - if (union_p && ! seen_default_p) + if (union_p && !seen_default_p) { oprintf (d->of, "%*sdefault:\n", d->indent, ""); oprintf (d->of, "%*s break;\n", d->indent, ""); @@ -2457,6 +2794,8 @@ switch (f->kind) { + case TYPE_NONE: + gcc_unreachable (); case TYPE_POINTER: oprintf (d->of, "%*s%s (%s%s", d->indent, "", wtd->subfield_marker_routine, cast, d->val); @@ -2477,8 +2816,7 @@ oprintf (d->of, ", gt_e_"); output_mangled_typename (d->of, f); } - else if (UNION_OR_STRUCT_P (f) - && f->u.p->u.s.line.file != NULL) + else if (UNION_OR_STRUCT_P (f) && f->u.p->u.s.line.file != NULL) { oprintf (d->of, ", gt_ggc_e_"); output_mangled_typename (d->of, f); @@ -2510,7 +2848,7 @@ case TYPE_SCALAR: break; - default: + case TYPE_ARRAY: gcc_unreachable (); } } @@ -2520,7 +2858,7 @@ static void output_type_enum (outf_p of, type_p s) { - if (s->kind == TYPE_PARAM_STRUCT && s->u.s.line.file != NULL) + if (s->kind == TYPE_PARAM_STRUCT && s->u.param_struct.line.file != NULL) { oprintf (of, ", gt_e_"); output_mangled_typename (of, s); @@ -2540,24 +2878,29 @@ static outf_p get_output_file_for_structure (const_type_p s, type_p *param) { - const char * fn = s->u.s.line.file; + const input_file *fn; int i; + gcc_assert (UNION_OR_STRUCT_P (s)); + fn = s->u.s.line.file; + /* This is a hack, and not the good kind either. */ for (i = NUM_PARAM - 1; i >= 0; i--) if (param && param[i] && param[i]->kind == TYPE_POINTER && UNION_OR_STRUCT_P (param[i]->u.p)) fn = param[i]->u.p->u.s.line.file; - return get_output_file_with_visibility (fn); + /* The call to get_output_file_with_visibility may update fn by + caching its result inside, so we need the CONST_CAST. */ + return get_output_file_with_visibility (CONST_CAST (input_file*, fn)); } /* For S, a structure that's part of ORIG_S, and using parameters PARAM, write out a routine that: - Takes a parameter, a void * but actually of type *S - If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each - field of S or its substructures and (in some cases) things - that are pointed to by S. + field of S or its substructures and (in some cases) things + that are pointed to by S. */ static void @@ -2573,17 +2916,19 @@ memset (&d, 0, sizeof (d)); d.of = get_output_file_for_structure (s, param); - for (opt = s->u.s.opt; opt; opt = opt->next) - if (strcmp (opt->name, "chain_next") == 0) - chain_next = opt->info; - else if (strcmp (opt->name, "chain_prev") == 0) - chain_prev = opt->info; - else if (strcmp (opt->name, "chain_circular") == 0) - chain_circular = opt->info; - else if (strcmp (opt->name, "mark_hook") == 0) - mark_hook_name = opt->info; - + if (strcmp (opt->name, "chain_next") == 0 + && opt->kind == OPTION_STRING) + chain_next = opt->info.string; + else if (strcmp (opt->name, "chain_prev") == 0 + && opt->kind == OPTION_STRING) + chain_prev = opt->info.string; + else if (strcmp (opt->name, "chain_circular") == 0 + && opt->kind == OPTION_STRING) + chain_circular = opt->info.string; + else if (strcmp (opt->name, "mark_hook") == 0 + && opt->kind == OPTION_STRING) + mark_hook_name = opt->info.string; if (chain_prev != NULL && chain_next == NULL) error_at_line (&s->u.s.line, "chain_prev without chain_next"); if (chain_circular != NULL && chain_next != NULL) @@ -2599,7 +2944,7 @@ d.bitmap = s->u.s.bitmap; d.param = param; d.prev_val[0] = "*x"; - d.prev_val[1] = "not valid postage"; /* Guarantee an error. */ + d.prev_val[1] = "not valid postage"; /* Guarantee an error. */ d.prev_val[3] = "x"; d.val = "(*x)"; @@ -2671,8 +3016,7 @@ oprintf (d.of, ");\n"); oprintf (d.of, " if (xprev == NULL) break;\n"); oprintf (d.of, " x = xprev;\n"); - oprintf (d.of, " (void) %s (xprev", - wtd->marker_routine); + oprintf (d.of, " (void) %s (xprev", wtd->marker_routine); if (wtd->param_prefix) { oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix); @@ -2727,6 +3071,7 @@ write_types (outf_p output_header, type_p structures, type_p param_structs, const struct write_types_data *wtd) { + int nbfun = 0; /* Count the emitted functions. */ type_p s; oprintf (output_header, "\n/* %s*/\n", wtd->comment); @@ -2734,13 +3079,11 @@ emitted afterwards. This is needed in plugin mode. */ oprintf (output_header, "/* macros and declarations */\n"); for (s = structures; s; s = s->next) - if (s->gc_used == GC_POINTED_TO - || s->gc_used == GC_MAYBE_POINTED_TO) + if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO) { options_p opt; - if (s->gc_used == GC_MAYBE_POINTED_TO - && s->u.s.line.file == NULL) + if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL) continue; oprintf (output_header, "#define gt_%s_", wtd->prefix); @@ -2749,16 +3092,15 @@ oprintf (output_header, " if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix, s->u.s.tag); - oprintf (output_header, - " } while (0)\n"); + oprintf (output_header, " } while (0)\n"); for (opt = s->u.s.opt; opt; opt = opt->next) - if (strcmp (opt->name, "ptr_alias") == 0) + if (strcmp (opt->name, "ptr_alias") == 0 + && opt->kind == OPTION_TYPE) { - const_type_p const t = (const_type_p) opt->info; + const_type_p const t = (const_type_p) opt->info.type; if (t->kind == TYPE_STRUCT - || t->kind == TYPE_UNION - || t->kind == TYPE_LANG_STRUCT) + || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT) oprintf (output_header, "#define gt_%sx_%s gt_%sx_%s\n", wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag); @@ -2804,13 +3146,11 @@ /* At last we emit the functions code. */ oprintf (output_header, "\n/* functions code */\n"); for (s = structures; s; s = s->next) - if (s->gc_used == GC_POINTED_TO - || s->gc_used == GC_MAYBE_POINTED_TO) + if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO) { options_p opt; - if (s->gc_used == GC_MAYBE_POINTED_TO - && s->u.s.line.file == NULL) + if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL) continue; for (opt = s->u.s.opt; opt; opt = opt->next) if (strcmp (opt->name, "ptr_alias") == 0) @@ -2822,11 +3162,29 @@ { type_p ss; for (ss = s->u.s.lang_struct; ss; ss = ss->next) - write_func_for_structure (s, ss, NULL, wtd); + { + nbfun++; + DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'", + nbfun, (void*) ss, ss->u.s.tag); + write_func_for_structure (s, ss, NULL, wtd); + } } else - write_func_for_structure (s, s, NULL, wtd); + { + nbfun++; + DBGPRINTF ("writing func #%d struct s @ %p '%s'", + nbfun, (void*) s, s->u.s.tag); + write_func_for_structure (s, s, NULL, wtd); + } } + else + { + /* Structure s is not possibly pointed to, so can be ignored. */ + DBGPRINTF ("ignored s @ %p '%s' gc_used#%d", + (void*)s, s->u.s.tag, + (int) s->gc_used); + } + for (s = param_structs; s; s = s->next) if (s->gc_used == GC_POINTED_TO) { @@ -2838,22 +3196,39 @@ { type_p ss; for (ss = stru->u.s.lang_struct; ss; ss = ss->next) - write_func_for_structure (s, ss, param, wtd); + { + nbfun++; + DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'", + nbfun, (void*) ss, ss->u.s.tag); + write_func_for_structure (s, ss, param, wtd); + } } else - write_func_for_structure (s, stru, param, wtd); + { + nbfun++; + DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'", + nbfun, (void*) s, + (void*) stru, stru->u.s.tag); + write_func_for_structure (s, stru, param, wtd); + } } + else + { + /* Param structure s is not pointed to, so should be ignored. */ + DBGPRINTF ("ignored s @ %p", (void*)s); + } + if (verbosity_level >= 2) + printf ("%s emitted %d routines for %s\n", + progname, nbfun, wtd->comment); } -static const struct write_types_data ggc_wtd = -{ +static const struct write_types_data ggc_wtd = { "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL, "GC marker procedures. ", FALSE }; -static const struct write_types_data pch_wtd = -{ +static const struct write_types_data pch_wtd = { "pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object", "gt_pch_note_reorder", "PCH type-walking procedures. ", @@ -2907,7 +3282,7 @@ d.bitmap = s->u.s.bitmap; d.param = param; d.prev_val[0] = d.prev_val[2] = "*x"; - d.prev_val[1] = "not valid postage"; /* Guarantee an error. */ + d.prev_val[1] = "not valid postage"; /* Guarantee an error. */ d.prev_val[3] = "x"; d.val = "(*x)"; d.fn_wants_lvalue = true; @@ -2940,21 +3315,19 @@ return; oprintf (output_header, "\n/* Local pointer-walking routines. */\n"); for (s = structures; s; s = s->next) - if (s->gc_used == GC_POINTED_TO - || s->gc_used == GC_MAYBE_POINTED_TO) + if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO) { options_p opt; if (s->u.s.line.file == NULL) continue; - - for (opt = s->u.s.opt; opt; opt = opt->next) - if (strcmp (opt->name, "ptr_alias") == 0) + for (opt = s->u.s.opt; opt; opt = opt->next) + if (strcmp (opt->name, "ptr_alias") == 0 + && opt->kind == OPTION_TYPE) { - const_type_p const t = (const_type_p) opt->info; + const_type_p const t = (const_type_p) opt->info.type; if (t->kind == TYPE_STRUCT - || t->kind == TYPE_UNION - || t->kind == TYPE_LANG_STRUCT) + || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT) { oprintf (output_header, "#define gt_pch_p_"); output_mangled_typename (output_header, s); @@ -2974,7 +3347,7 @@ oprintf (output_header, "extern void gt_pch_p_"); output_mangled_typename (output_header, s); oprintf (output_header, - "\n (void *, void *, gt_pointer_operator, void *);\n"); + "\n (void *, void *, gt_pointer_operator, void *);\n"); if (s->kind == TYPE_LANG_STRUCT) { @@ -2989,14 +3362,14 @@ for (s = param_structs; s; s = s->next) if (s->gc_used == GC_POINTED_TO) { - type_p * param = s->u.param_struct.param; + type_p *param = s->u.param_struct.param; type_p stru = s->u.param_struct.stru; /* Declare the marker procedure. */ oprintf (output_header, "extern void gt_pch_p_"); output_mangled_typename (output_header, s); oprintf (output_header, - "\n (void *, void *, gt_pointer_operator, void *);\n"); + "\n (void *, void *, gt_pointer_operator, void *);\n"); if (stru->u.s.line.file == NULL) { @@ -3016,38 +3389,62 @@ } } +/* Nonzero if S is a type for which typed GC allocators should be output. */ + +#define USED_BY_TYPED_GC_P(s) \ + (((s->kind == TYPE_POINTER) \ + && ((s->u.p->gc_used == GC_POINTED_TO) \ + || (s->u.p->gc_used == GC_USED))) \ + || (UNION_OR_STRUCT_P (s) && \ + (((s)->gc_used == GC_POINTED_TO) \ + || ((s)->gc_used == GC_MAYBE_POINTED_TO \ + && s->u.s.line.file != NULL) \ + || ((s)->gc_used == GC_USED \ + && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous")))))) + + /* Write out the 'enum' definition for gt_types_enum. */ static void write_enum_defn (type_p structures, type_p param_structs) { type_p s; + int nbstruct = 0; + int nbparamstruct = 0; if (!header_file) return; oprintf (header_file, "\n/* Enumeration of types known. */\n"); oprintf (header_file, "enum gt_types_enum {\n"); for (s = structures; s; s = s->next) - if (s->gc_used == GC_POINTED_TO - || s->gc_used == GC_MAYBE_POINTED_TO) + if (USED_BY_TYPED_GC_P (s)) { - if (s->gc_used == GC_MAYBE_POINTED_TO - && s->u.s.line.file == NULL) - continue; - + nbstruct++; + DBGPRINTF ("write_enum_defn s @ %p nbstruct %d", + (void*) s, nbstruct); + if (UNION_OR_STRUCT_P (s)) + DBGPRINTF ("write_enum_defn s %p #%d is unionorstruct tagged %s", + (void*) s, nbstruct, s->u.s.tag); oprintf (header_file, " gt_ggc_e_"); output_mangled_typename (header_file, s); - oprintf (header_file, ", \n"); + oprintf (header_file, ",\n"); } for (s = param_structs; s; s = s->next) if (s->gc_used == GC_POINTED_TO) { + nbparamstruct++; + DBGPRINTF ("write_enum_defn s %p nbparamstruct %d", + (void*) s, nbparamstruct); oprintf (header_file, " gt_e_"); output_mangled_typename (header_file, s); - oprintf (header_file, ", \n"); + oprintf (header_file, ",\n"); } oprintf (header_file, " gt_types_enum_last\n"); oprintf (header_file, "};\n"); + if (verbosity_level >= 2) + printf ("%s handled %d GTY-ed structures & %d parameterized structures.\n", + progname, nbstruct, nbparamstruct); + } /* Might T contain any non-pointer elements? */ @@ -3064,17 +3461,20 @@ return contains_scalar_p (t->u.a.p); default: /* Could also check for structures that have no non-pointer - fields, but there aren't enough of those to worry about. */ + fields, but there aren't enough of those to worry about. */ return 1; } } -/* Mangle FN and print it to F. */ +/* Mangle INPF and print it to F. */ static void -put_mangled_filename (outf_p f, const char *fn) +put_mangled_filename (outf_p f, const input_file *inpf) { - const char *name = get_output_file_name (fn); + /* The call to get_output_file_name may indirectly update fn since + get_output_file_with_visibility caches its result inside, so we + need the CONST_CAST. */ + const char *name = get_output_file_name (CONST_CAST (input_file*, inpf)); if (!f || !name) return; for (; *name != 0; name++) @@ -3104,16 +3504,15 @@ for (fli2 = flp; fli2 && base_files; fli2 = fli2->next) if (fli2->started_p) { - lang_bitmap bitmap = get_lang_bitmap (fli2->name); + lang_bitmap bitmap = get_lang_bitmap (fli2->file); int fnum; for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1) if (bitmap & 1) { oprintf (base_files[fnum], - "extern const struct %s gt_%s_", - tname, pfx); - put_mangled_filename (base_files[fnum], fli2->name); + "extern const struct %s gt_%s_", tname, pfx); + put_mangled_filename (base_files[fnum], fli2->file); oprintf (base_files[fnum], "[];\n"); } } @@ -3121,16 +3520,15 @@ { size_t fnum; for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++) - oprintf (base_files [fnum], - "EXPORTED_CONST struct %s * const %s[] = {\n", - tname, name); + oprintf (base_files[fnum], + "EXPORTED_CONST struct %s * const %s[] = {\n", tname, name); } for (fli2 = flp; fli2; fli2 = fli2->next) if (fli2->started_p) { - lang_bitmap bitmap = get_lang_bitmap (fli2->name); + lang_bitmap bitmap = get_lang_bitmap (fli2->file); int fnum; fli2->started_p = 0; @@ -3139,7 +3537,7 @@ if (bitmap & 1) { oprintf (base_files[fnum], " gt_%s_", pfx); - put_mangled_filename (base_files[fnum], fli2->name); + put_mangled_filename (base_files[fnum], fli2->file); oprintf (base_files[fnum], ",\n"); } } @@ -3154,8 +3552,81 @@ } } +/* Write the first three fields (pointer, count and stride) for + root NAME to F. V and LINE are as for write_root. + + Return true if the entry could be written; return false on error. */ + +static bool +start_root_entry (outf_p f, pair_p v, const char *name, struct fileloc *line) +{ + type_p ap; + + if (!v) + { + error_at_line (line, "`%s' is too complex to be a root", name); + return false; + } + + oprintf (f, " {\n"); + oprintf (f, " &%s,\n", name); + oprintf (f, " 1"); + + for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p) + if (ap->u.a.len[0]) + oprintf (f, " * (%s)", ap->u.a.len); + else if (ap == v->type) + oprintf (f, " * ARRAY_SIZE (%s)", v->name); + oprintf (f, ",\n"); + oprintf (f, " sizeof (%s", v->name); + for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p) + oprintf (f, "[0]"); + oprintf (f, "),\n"); + return true; +} + +/* A subroutine of write_root for writing the roots for field FIELD_NAME, + which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters + of the caller. */ + +static void +write_field_root (outf_p f, pair_p v, type_p type, const char *name, + int has_length, struct fileloc *line, const char *if_marked, + bool emit_pch, type_p field_type, const char *field_name) +{ + /* If the field reference is relative to V, rather than to some + subcomponent of V, we can mark any subarrays with a single stride. + We're effectively treating the field as a global variable in its + own right. */ + if (v && type == v->type) + { + struct pair newv; + + newv = *v; + newv.type = field_type; + newv.name = ACONCAT ((v->name, ".", field_name, NULL)); + v = &newv; + } + /* Otherwise, any arrays nested in the structure are too complex to + handle. */ + else if (field_type->kind == TYPE_ARRAY) + v = NULL; + write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)), + has_length, line, if_marked, emit_pch); +} + /* Write out to F the table entry and any marker routines needed to - mark NAME as TYPE. The original variable is V, at LINE. + mark NAME as TYPE. V can be one of three values: + + - null, if NAME is too complex to represent using a single + count and stride. In this case, it is an error for NAME to + contain any gc-ed data. + + - the outermost array that contains NAME, if NAME is part of an array. + + - the C variable that contains NAME, if NAME is not part of an array. + + LINE is the line of the C source that declares the root variable. HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED is nonzero iff we are building the root table for hash table caches. */ @@ -3177,13 +3648,14 @@ for (o = fld->opt; o; o = o->next) if (strcmp (o->name, "skip") == 0) skip_p = 1; - else if (strcmp (o->name, "desc") == 0) - desc = o->info; + else if (strcmp (o->name, "desc") == 0 + && o->kind == OPTION_STRING) + desc = o->info.string; else if (strcmp (o->name, "param_is") == 0) ; else error_at_line (line, - "field `%s' of global `%s' has unknown option `%s'", + "field `%s' of global `%s' has unknown option `%s'", fld->name, name, o->name); if (skip_p) @@ -3197,42 +3669,32 @@ { const char *tag = NULL; options_p oo; - - for (oo = ufld->opt; oo; oo = oo->next) - if (strcmp (oo->name, "tag") == 0) - tag = oo->info; + for (oo = ufld->opt; oo; oo = oo->next) + if (strcmp (oo->name, "tag") == 0 + && oo->kind == OPTION_STRING) + tag = oo->info.string; if (tag == NULL || strcmp (tag, desc) != 0) continue; if (validf != NULL) error_at_line (line, - "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'", + "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'", name, fld->name, validf->name, - name, fld->name, ufld->name, - tag); + name, fld->name, ufld->name, tag); validf = ufld; } if (validf != NULL) - { - char *newname; - newname = xasprintf ("%s.%s.%s", - name, fld->name, validf->name); - write_root (f, v, validf->type, newname, 0, line, - if_marked, emit_pch); - free (newname); - } + write_field_root (f, v, type, name, 0, line, if_marked, + emit_pch, validf->type, + ACONCAT ((fld->name, ".", + validf->name, NULL))); } else if (desc) error_at_line (line, - "global `%s.%s' has `desc' option but is not union", + "global `%s.%s' has `desc' option but is not union", name, fld->name); else - { - char *newname; - newname = xasprintf ("%s.%s", name, fld->name); - write_root (f, v, fld->type, newname, 0, line, if_marked, - emit_pch); - free (newname); - } + write_field_root (f, v, type, name, 0, line, if_marked, + emit_pch, fld->type, fld->name); } } break; @@ -3249,26 +3711,14 @@ case TYPE_POINTER: { - type_p ap, tp; - - oprintf (f, " {\n"); - oprintf (f, " &%s,\n", name); - oprintf (f, " 1"); - - for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p) - if (ap->u.a.len[0]) - oprintf (f, " * (%s)", ap->u.a.len); - else if (ap == v->type) - oprintf (f, " * ARRAY_SIZE (%s)", v->name); - oprintf (f, ",\n"); - oprintf (f, " sizeof (%s", v->name); - for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p) - oprintf (f, "[0]"); - oprintf (f, "),\n"); + type_p tp; + + if (!start_root_entry (f, v, name, line)) + return; tp = type->u.p; - if (! has_length && UNION_OR_STRUCT_P (tp)) + if (!has_length && UNION_OR_STRUCT_P (tp)) { oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag); if (emit_pch) @@ -3276,7 +3726,7 @@ else oprintf (f, " NULL"); } - else if (! has_length && tp->kind == TYPE_PARAM_STRUCT) + else if (!has_length && tp->kind == TYPE_PARAM_STRUCT) { oprintf (f, " >_ggc_m_"); output_mangled_typename (f, tp); @@ -3311,10 +3761,9 @@ case TYPE_STRING: { - oprintf (f, " {\n"); - oprintf (f, " &%s,\n", name); - oprintf (f, " 1, \n"); - oprintf (f, " sizeof (%s),\n", v->name); + if (!start_root_entry (f, v, name, line)) + return; + oprintf (f, " (gt_pointer_walker) >_ggc_m_S,\n"); oprintf (f, " (gt_pointer_walker) >_pch_n_S\n"); oprintf (f, " },\n"); @@ -3325,9 +3774,7 @@ break; default: - error_at_line (line, - "global `%s' is unimplemented type", - name); + error_at_line (line, "global `%s' is unimplemented type", name); } } @@ -3353,8 +3800,7 @@ if (wtd->param_prefix) { oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name); - oprintf (f, - " (void *, void *, gt_pointer_operator, void *);\n"); + oprintf (f, " (void *, void *, gt_pointer_operator, void *);\n"); oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n", wtd->param_prefix, v->name); oprintf (d.of, @@ -3369,8 +3815,7 @@ } d.opt = v->opt; - oprintf (f, "static void gt_%sa_%s (void *);\n", - wtd->prefix, v->name); + oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name); oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n", wtd->prefix, v->name); oprintf (f, "{\n"); @@ -3391,22 +3836,23 @@ for (v = variables; v; v = v->next) { - outf_p f = get_output_file_with_visibility (v->line.file); + outf_p f = + get_output_file_with_visibility (CONST_CAST (input_file*, + v->line.file)); struct flist *fli; const char *length = NULL; int deletable_p = 0; options_p o; - for (o = v->opt; o; o = o->next) - if (strcmp (o->name, "length") == 0) - length = o->info; + if (strcmp (o->name, "length") == 0 + && o->kind == OPTION_STRING) + length = o->info.string; else if (strcmp (o->name, "deletable") == 0) deletable_p = 1; else if (strcmp (o->name, "param_is") == 0) ; else if (strncmp (o->name, "param", 5) == 0 - && ISDIGIT (o->name[5]) - && strcmp (o->name + 6, "_is") == 0) + && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0) ; else if (strcmp (o->name, "if_marked") == 0) ; @@ -3424,14 +3870,14 @@ fli->f = f; fli->next = flp; fli->started_p = 0; - fli->name = v->line.file; - gcc_assert(fli->name); + fli->file = v->line.file; + gcc_assert (fli->file); flp = fli; oprintf (f, "\n/* GC roots. */\n\n"); } - if (! deletable_p + if (!deletable_p && length && v->type->kind == TYPE_POINTER && (v->type->u.p->kind == TYPE_POINTER @@ -3444,7 +3890,8 @@ for (v = variables; v; v = v->next) { - outf_p f = get_output_file_with_visibility (v->line.file); + outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, + v->line.file)); struct flist *fli; int skip_p = 0; int length_p = 0; @@ -3463,7 +3910,7 @@ for (fli = flp; fli; fli = fli->next) if (fli->f == f) break; - if (! fli->started_p) + if (!fli->started_p) { fli->started_p = 1; @@ -3480,7 +3927,8 @@ for (v = variables; v; v = v->next) { - outf_p f = get_output_file_with_visibility (v->line.file); + outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, + v->line.file)); struct flist *fli; int skip_p = 1; options_p o; @@ -3497,7 +3945,7 @@ for (fli = flp; fli; fli = fli->next) if (fli->f == f) break; - if (! fli->started_p) + if (!fli->started_p) { fli->started_p = 1; @@ -3515,7 +3963,8 @@ for (v = variables; v; v = v->next) { - outf_p f = get_output_file_with_visibility (v->line.file); + outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, + v->line.file)); struct flist *fli; const char *if_marked = NULL; int length_p = 0; @@ -3524,24 +3973,24 @@ for (o = v->opt; o; o = o->next) if (strcmp (o->name, "length") == 0) length_p = 1; - else if (strcmp (o->name, "if_marked") == 0) - if_marked = o->info; - - if (if_marked == NULL) + else if (strcmp (o->name, "if_marked") == 0 + && o->kind == OPTION_STRING) + if_marked = o->info.string; + if (if_marked == NULL) continue; - if (v->type->kind != TYPE_POINTER || v->type->u.p->kind != TYPE_PARAM_STRUCT || v->type->u.p->u.param_struct.stru != find_structure ("htab", 0)) { - error_at_line (&v->line, "if_marked option used but not hash table"); + error_at_line (&v->line, + "if_marked option used but not hash table"); continue; } for (fli = flp; fli; fli = fli->next) if (fli->f == f) break; - if (! fli->started_p) + if (!fli->started_p) { fli->started_p = 1; @@ -3562,7 +4011,8 @@ for (v = variables; v; v = v->next) { - outf_p f = get_output_file_with_visibility (v->line.file); + outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, + v->line.file)); struct flist *fli; int length_p = 0; int if_marked_p = 0; @@ -3574,13 +4024,13 @@ else if (strcmp (o->name, "if_marked") == 0) if_marked_p = 1; - if (! if_marked_p) + if (!if_marked_p) continue; for (fli = flp; fli; fli = fli->next) if (fli->f == f) break; - if (! fli->started_p) + if (!fli->started_p) { fli->started_p = 1; @@ -3597,7 +4047,8 @@ for (v = variables; v; v = v->next) { - outf_p f = get_output_file_with_visibility (v->line.file); + outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*, + v->line.file)); struct flist *fli; int skip_p = 0; options_p o; @@ -3610,13 +4061,13 @@ if (skip_p) continue; - if (! contains_scalar_p (v->type)) + if (!contains_scalar_p (v->type)) continue; for (fli = flp; fli; fli = fli->next) if (fli->f == f) break; - if (! fli->started_p) + if (!fli->started_p) { fli->started_p = 1; @@ -3651,7 +4102,7 @@ type_p t; options_p o; type_p len_ty = create_scalar_type ("unsigned"); - const char *name = concat ("VEC_", type_name, "_base", (char *)0); + const char *name = concat ("VEC_", type_name, "_base", (char *) 0); if (is_scalar) { @@ -3661,9 +4112,8 @@ else { t = resolve_typedef (type_name, pos); - o = create_option (0, "length", "%h.num"); + o = create_string_option (0, "length", "%h.num"); } - /* We assemble the field list in reverse order. */ fields = create_field_at (0, create_array (t, "1"), "vec", o, pos); fields = create_field_at (fields, len_ty, "alloc", 0, pos); @@ -3682,8 +4132,8 @@ void note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos) { - const char *astratname = concat ("VEC_", type, "_", astrat, (char *)0); - const char *basename = concat ("VEC_", type, "_base", (char *)0); + const char *astratname = concat ("VEC_", type, "_", astrat, (char *) 0); + const char *basename = concat ("VEC_", type, "_base", (char *) 0); pair_p field = create_field_at (0, resolve_typedef (basename, pos), "base", 0, pos); @@ -3691,6 +4141,216 @@ do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos); } +/* Returns the specifier keyword for a string or union type S, empty string + otherwise. */ + +static const char * +get_type_specifier (const type_p s) +{ + if (s->kind == TYPE_STRUCT || s->kind == TYPE_LANG_STRUCT) + return "struct "; + if (s->kind == TYPE_UNION) + return "union "; + return ""; +} + +/* TRUE if type S has the GTY variable_size annotation. */ + +static bool +variable_size_p (const type_p s) +{ + options_p o; + for (o = s->u.s.opt; o; o = o->next) + if (strcmp (o->name, "variable_size") == 0) + return true; + return false; +} + +enum alloc_quantity +{ single, vector }; +enum alloc_zone +{ any_zone, specific_zone }; + +/* Writes one typed allocator definition for type identifier TYPE_NAME with + optional type specifier TYPE_SPECIFIER. The allocator name will contain + ALLOCATOR_TYPE. If VARIABLE_SIZE is true, the allocator will have an extra + parameter specifying number of bytes to allocate. If QUANTITY is set to + VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE, + the allocator will be zone-specific. */ + +static void +write_typed_alloc_def (bool variable_size, const char *type_specifier, + const char *type_name, const char *allocator_type, + enum alloc_quantity quantity, enum alloc_zone zone) +{ + bool two_args = variable_size && (quantity == vector); + bool third_arg = ((zone == specific_zone) + && (variable_size || (quantity == vector))); + + oprintf (header_file, "#define ggc_alloc_%s%s", allocator_type, type_name); + oprintf (header_file, "(%s%s%s%s%s) ", + (variable_size ? "SIZE" : ""), + (two_args ? ", " : ""), + (quantity == vector) ? "n" : "", + (third_arg ? ", " : ""), (zone == specific_zone) ? "z" : ""); + oprintf (header_file, "((%s%s *)", type_specifier, type_name); + oprintf (header_file, "(ggc_internal_%salloc_stat (", allocator_type); + if (zone == specific_zone) + oprintf (header_file, "z, "); + if (variable_size) + oprintf (header_file, "SIZE"); + else + oprintf (header_file, "sizeof (%s%s)", type_specifier, type_name); + if (quantity == vector) + oprintf (header_file, ", n"); + oprintf (header_file, " MEM_STAT_INFO)))\n"); +} + +/* Writes a typed allocator definition for a struct or union S. */ + +static void +write_typed_struct_alloc_def (const type_p s, const char *allocator_type, + enum alloc_quantity quantity, + enum alloc_zone zone) +{ + write_typed_alloc_def (variable_size_p (s), get_type_specifier (s), + s->u.s.tag, allocator_type, quantity, zone); +} + +/* Writes a typed allocator definition for a typedef P. */ + +static void +write_typed_typedef_alloc_def (const pair_p p, const char *allocator_type, + enum alloc_quantity quantity, + enum alloc_zone zone) +{ + write_typed_alloc_def (variable_size_p (p->type), "", p->name, + allocator_type, quantity, zone); +} + +/* Writes typed allocator definitions for the types in STRUCTURES and + TYPEDEFS that are used by GC. */ + +static void +write_typed_alloc_defns (const type_p structures, const pair_p typedefs) +{ + type_p s; + pair_p p; + + oprintf (header_file, + "\n/* Allocators for known structs and unions. */\n\n"); + for (s = structures; s; s = s->next) + { + if (!USED_BY_TYPED_GC_P (s)) + continue; + write_typed_struct_alloc_def (s, "", single, any_zone); + write_typed_struct_alloc_def (s, "cleared_", single, any_zone); + write_typed_struct_alloc_def (s, "vec_", vector, any_zone); + write_typed_struct_alloc_def (s, "cleared_vec_", vector, any_zone); + write_typed_struct_alloc_def (s, "zone_", single, specific_zone); + write_typed_struct_alloc_def (s, "zone_cleared_", single, + specific_zone); + write_typed_struct_alloc_def (s, "zone_vec_", vector, specific_zone); + write_typed_struct_alloc_def (s, "zone_cleared_vec_", vector, + specific_zone); + } + + oprintf (header_file, "\n/* Allocators for known typedefs. */\n"); + for (p = typedefs; p; p = p->next) + { + s = p->type; + if (!USED_BY_TYPED_GC_P (s) || (strcmp (p->name, s->u.s.tag) == 0)) + continue; + write_typed_typedef_alloc_def (p, "", single, any_zone); + write_typed_typedef_alloc_def (p, "cleared_", single, any_zone); + write_typed_typedef_alloc_def (p, "vec_", vector, any_zone); + write_typed_typedef_alloc_def (p, "cleared_vec_", vector, any_zone); + write_typed_typedef_alloc_def (p, "zone_", single, specific_zone); + write_typed_typedef_alloc_def (p, "zone_cleared_", single, + specific_zone); + write_typed_typedef_alloc_def (p, "zone_cleared_vec_", vector, + specific_zone); + } +} + +/* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness + guaranteee for somewhat increased readability. If name conflicts do happen, + this funcion will have to be adjusted to be more like + output_mangled_typename. */ + +static void +output_typename (outf_p of, const_type_p t) +{ + switch (t->kind) + { + case TYPE_STRING: + oprintf (of, "str"); + break; + case TYPE_SCALAR: + oprintf (of, "scalar"); + break; + case TYPE_POINTER: + output_typename (of, t->u.p); + break; + case TYPE_STRUCT: + case TYPE_UNION: + case TYPE_LANG_STRUCT: + oprintf (of, "%s", t->u.s.tag); + break; + case TYPE_PARAM_STRUCT: + { + int i; + for (i = 0; i < NUM_PARAM; i++) + if (t->u.param_struct.param[i] != NULL) + { + output_typename (of, t->u.param_struct.param[i]); + oprintf (of, "_"); + } + output_typename (of, t->u.param_struct.stru); + break; + } + default: + gcc_unreachable (); + } +} + +/* Writes a typed GC allocator for type S that is suitable as a callback for + the splay tree implementation in libiberty. */ + +static void +write_splay_tree_allocator_def (const_type_p s) +{ + outf_p of = get_output_file_with_visibility (NULL); + oprintf (of, "void * ggc_alloc_splay_tree_"); + output_typename (of, s); + oprintf (of, " (int sz, void * nl)\n"); + oprintf (of, "{\n"); + oprintf (of, " return ggc_splay_alloc ("); + oprintf (of, "gt_e_"); + output_mangled_typename (of, s); + oprintf (of, ", sz, nl);\n"); + oprintf (of, "}\n\n"); +} + +/* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks + for the splay tree implementation in libiberty. */ + +static void +write_splay_tree_allocators (const_type_p param_structs) +{ + const_type_p s; + + oprintf (header_file, "\n/* Splay tree callback allocators. */\n"); + for (s = param_structs; s; s = s->next) + if (s->gc_used == GC_POINTED_TO) + { + oprintf (header_file, "extern void * ggc_alloc_splay_tree_"); + output_typename (header_file, s); + oprintf (header_file, " (int, void *);\n"); + write_splay_tree_allocator_def (s); + } +} + static void dump_pair (int indent, pair_p p); static void dump_type (int indent, type_p p); static void dump_type_list (int indent, type_p p); @@ -3705,15 +4365,32 @@ printf ("%*ckind = ", indent, ' '); switch (kind) { - case TYPE_SCALAR: printf ("TYPE_SCALAR"); break; - case TYPE_STRING: printf ("TYPE_STRING"); break; - case TYPE_STRUCT: printf ("TYPE_STRUCT"); break; - case TYPE_UNION: printf ("TYPE_UNION"); break; - case TYPE_POINTER: printf ("TYPE_POINTER"); break; - case TYPE_ARRAY: printf ("TYPE_ARRAY"); break; - case TYPE_LANG_STRUCT: printf ("TYPE_LANG_STRUCT"); break; - case TYPE_PARAM_STRUCT: printf ("TYPE_PARAM_STRUCT"); break; - default: gcc_unreachable (); + case TYPE_SCALAR: + printf ("TYPE_SCALAR"); + break; + case TYPE_STRING: + printf ("TYPE_STRING"); + break; + case TYPE_STRUCT: + printf ("TYPE_STRUCT"); + break; + case TYPE_UNION: + printf ("TYPE_UNION"); + break; + case TYPE_POINTER: + printf ("TYPE_POINTER"); + break; + case TYPE_ARRAY: + printf ("TYPE_ARRAY"); + break; + case TYPE_LANG_STRUCT: + printf ("TYPE_LANG_STRUCT"); + break; + case TYPE_PARAM_STRUCT: + printf ("TYPE_PARAM_STRUCT"); + break; + default: + gcc_unreachable (); } printf ("\n"); } @@ -3726,11 +4403,20 @@ printf ("%*cgc_used = ", indent, ' '); switch (gc_used) { - case GC_UNUSED: printf ("GC_UNUSED"); break; - case GC_USED: printf ("GC_USED"); break; - case GC_MAYBE_POINTED_TO: printf ("GC_MAYBE_POINTED_TO"); break; - case GC_POINTED_TO: printf ("GC_POINTED_TO"); break; - default: gcc_unreachable (); + case GC_UNUSED: + printf ("GC_UNUSED"); + break; + case GC_USED: + printf ("GC_USED"); + break; + case GC_MAYBE_POINTED_TO: + printf ("GC_MAYBE_POINTED_TO"); + break; + case GC_POINTED_TO: + printf ("GC_POINTED_TO"); + break; + default: + gcc_unreachable (); } printf ("\n"); } @@ -3745,8 +4431,22 @@ o = opt; while (o) { - printf ("%s:%s ", o->name, o->info); - o = o->next; + switch (o->kind) + { + case OPTION_STRING: + printf ("%s:string %s ", o->name, o->info.string); + break; + case OPTION_TYPE: + printf ("%s:type ", o->name); + dump_type (indent+1, o->info.type); + break; + case OPTION_NESTED: + printf ("%s:nested ", o->name); + break; + case OPTION_NONE: + gcc_unreachable (); + } + o = o->next; } printf ("\n"); } @@ -3756,7 +4456,8 @@ static void dump_fileloc (int indent, struct fileloc line) { - printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ', line.file, + printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ', + get_input_file_name (line.file), line.line); } @@ -3776,8 +4477,8 @@ fields = t->u.s.fields; while (fields) { - dump_pair (indent + INDENT, fields); - fields = fields->next; + dump_pair (indent + INDENT, fields); + fields = fields->next; } printf ("%*cend of fields of type %p\n", indent, ' ', (void *) t); dump_options (indent, t->u.s.opt); @@ -3840,7 +4541,7 @@ { PTR *slot; - printf ("%*cType at %p: ", indent, ' ', (void *)t); + printf ("%*cType at %p: ", indent, ' ', (void *) t); slot = htab_find_slot (seen_types, t, INSERT); if (*slot != NULL) { @@ -3852,7 +4553,7 @@ dump_typekind (indent, t->kind); printf ("%*cpointer_to = %p\n", indent + INDENT, ' ', - (void *)t->pointer_to); + (void *) t->pointer_to); dump_gc_used (indent + INDENT, t->gc_used); switch (t->kind) { @@ -3880,7 +4581,7 @@ default: gcc_unreachable (); } - printf ("%*cEnd of type at %p\n", indent, ' ', (void *)t); + printf ("%*cEnd of type at %p\n", indent, ' ', (void *) t); } /* Dumps the pair P. */ @@ -3898,7 +4599,7 @@ /* Dumps the list of pairs PP. */ static void -dump_pair_list (const char * name, pair_p pp) +dump_pair_list (const char *name, pair_p pp) { pair_p p; printf ("%s:\n", name); @@ -3910,14 +4611,16 @@ /* Dumps the STRUCTURES. */ static void -dump_structures (const char * name, type_p structures) +dump_structures (const char *name, type_p structures) { printf ("%s:\n", name); dump_type_list (0, structures); printf ("End of %s\n\n", name); } -/* Dumps the internal structures of gengtype. */ +/* Dumps the internal structures of gengtype. This is useful to debug + gengtype itself, or to understand what it does, e.g. for plugin + developers. */ static void dump_everything (void) @@ -3929,95 +4632,364 @@ dump_pair_list ("variables", variables); htab_delete (seen_types); } + + + +/* Option specification for getopt_long. */ +static const struct option gengtype_long_options[] = { + {"help", no_argument, NULL, 'h'}, + {"version", no_argument, NULL, 'V'}, + {"verbose", no_argument, NULL, 'v'}, + {"dump", no_argument, NULL, 'd'}, + {"debug", no_argument, NULL, 'D'}, + {"plugin", required_argument, NULL, 'P'}, + {"srcdir", required_argument, NULL, 'S'}, + {"backupdir", required_argument, NULL, 'B'}, + {"inputs", required_argument, NULL, 'I'}, + {"read-state", required_argument, NULL, 'r'}, + {"write-state", required_argument, NULL, 'w'}, + /* Terminating NULL placeholder. */ + {NULL, no_argument, NULL, 0}, +}; + + +static void +print_usage (void) +{ + printf ("Usage: %s\n", progname); + printf ("\t -h | --help " " \t# Give this help.\n"); + printf ("\t -D | --debug " + " \t# Give debug output to debug %s itself.\n", progname); + printf ("\t -V | --version " " \t# Give version information.\n"); + printf ("\t -v | --verbose \t# Increase verbosity. Can be given several times.\n"); + printf ("\t -d | --dump " " \t# Dump state for debugging.\n"); + printf ("\t -P | --plugin <output-file> <plugin-src> ... " + " \t# Generate for plugin.\n"); + printf ("\t -S | --srcdir <GCC-directory> " + " \t# Specify the GCC source directory.\n"); + printf ("\t -B | --backupdir <directory> " + " \t# Specify the backup directory for updated files.\n"); + printf ("\t -I | --inputs <input-list> " + " \t# Specify the file with source files list.\n"); + printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n"); + printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n"); +} + +static void +print_version (void) +{ + printf ("%s %s%s\n", progname, pkgversion_string, version_string); + printf ("Report bugs: %s\n", bug_report_url); +} + +/* Parse the program options using getopt_long... */ +static void +parse_program_options (int argc, char **argv) +{ + int opt = -1; + while ((opt = getopt_long (argc, argv, "hVvdP:S:B:I:w:r:D", + gengtype_long_options, NULL)) >= 0) + { + switch (opt) + { + case 'h': /* --help */ + print_usage (); + break; + case 'V': /* --version */ + print_version (); + break; + case 'd': /* --dump */ + do_dump = 1; + break; + case 'D': /* --debug */ + do_debug = 1; + break; + case 'v': /* --verbose */ + verbosity_level++; + break; + case 'P': /* --plugin */ + if (optarg) + plugin_output_filename = optarg; + else + fatal ("missing plugin output file name"); + break; + case 'S': /* --srcdir */ + if (optarg) + srcdir = optarg; + else + fatal ("missing source directory"); + srcdir_len = strlen (srcdir); + break; + case 'B': /* --backupdir */ + if (optarg) + backup_dir = optarg; + else + fatal ("missing backup directory"); + break; + case 'I': /* --inputs */ + if (optarg) + inputlist = optarg; + else + fatal ("missing input list"); + break; + case 'r': /* --read-state */ + if (optarg) + read_state_filename = optarg; + else + fatal ("missing read state file"); + DBGPRINTF ("read state %s\n", optarg); + break; + case 'w': /* --write-state */ + DBGPRINTF ("write state %s\n", optarg); + if (optarg) + write_state_filename = optarg; + else + fatal ("missing write state file"); + break; + default: + fprintf (stderr, "%s: unknown flag '%c'\n", progname, opt); + print_usage (); + fatal ("unexpected flag"); + } + }; + if (plugin_output_filename) + { + /* In plugin mode we require some input files. */ + int i = 0; + if (optind >= argc) + fatal ("no source files given in plugin mode"); + nb_plugin_files = argc - optind; + plugin_files = XNEWVEC (input_file*, nb_plugin_files); + for (i = 0; i < (int) nb_plugin_files; i++) + { + char *name = argv[i + optind]; + plugin_files[i] = input_file_by_name (name); + } + } +} + +/******* Manage input files. ******/ + +/* Hash table of unique input file names. */ +static htab_t input_file_htab; + +/* Find or allocate a new input_file by hash-consing it. */ +input_file* +input_file_by_name (const char* name) +{ + PTR* slot; + input_file* f = NULL; + int namlen = 0; + if (!name) + return NULL; + namlen = strlen (name); + f = XCNEWVAR (input_file, sizeof (input_file)+namlen+2); + f->inpbitmap = 0; + f->inpoutf = NULL; + strcpy (f->inpname, name); + slot = htab_find_slot (input_file_htab, f, INSERT); + gcc_assert (slot != NULL); + if (*slot) + { + /* Already known input file. */ + free (f); + return (input_file*)(*slot); + } + /* New input file. */ + *slot = f; + return f; + } + +/* Hash table support routines for input_file-s. */ +static hashval_t +htab_hash_inputfile (const void *p) +{ + const input_file *inpf = (const input_file *) p; + gcc_assert (inpf); + return htab_hash_string (get_input_file_name (inpf)); +} + +static int +htab_eq_inputfile (const void *x, const void *y) +{ + const input_file *inpfx = (const input_file *) x; + const input_file *inpfy = (const input_file *) y; + gcc_assert (inpfx != NULL && inpfy != NULL); + return !strcmp (get_input_file_name (inpfx), get_input_file_name (inpfy)); +} + + int main (int argc, char **argv) { size_t i; - static struct fileloc pos = { this_file, 0 }; - char* inputlist = 0; - int do_dump = 0; + static struct fileloc pos = { NULL, 0 }; outf_p output_header; - char* plugin_output_filename = NULL; - /* fatal uses this */ - progname = "gengtype"; - - if (argc >= 2 && !strcmp (argv[1], "-d")) + + /* Mandatory common initializations. */ + progname = "gengtype"; /* For fatal and messages. */ + /* Create the hash-table used to hash-cons input files. */ + input_file_htab = + htab_create (800, htab_hash_inputfile, htab_eq_inputfile, NULL); + /* Initialize our special input files. */ + this_file = input_file_by_name (__FILE__); + system_h_file = input_file_by_name ("system.h"); + /* Set the scalar_is_char union number for predefined scalar types. */ + scalar_nonchar.u.scalar_is_char = FALSE; + scalar_char.u.scalar_is_char = TRUE; + + parse_program_options (argc, argv); + +#if ENABLE_CHECKING + if (do_debug) { - do_dump = 1; - argv = &argv[1]; - argc--; + time_t now = (time_t) 0; + time (&now); + DBGPRINTF ("gengtype started pid %d at %s", + (int) getpid (), ctime (&now)); } - - if (argc >= 6 && !strcmp (argv[1], "-P")) +#endif /* ENABLE_CHECKING */ + + /* Parse the input list and the input files. */ + DBGPRINTF ("inputlist %s", inputlist); + if (read_state_filename) { - plugin_output_filename = argv[2]; - plugin_output = create_file ("GCC", plugin_output_filename); - srcdir = argv[3]; - inputlist = argv[4]; - nb_plugin_files = argc - 5; - plugin_files = XCNEWVEC (char *, nb_plugin_files); - for (i = 0; i < nb_plugin_files; i++) - { - /* Place an all zero lang_bitmap before the plugin file - name. */ - char *name = argv[i + 5]; - int len = strlen(name) + 1 + sizeof (lang_bitmap); - plugin_files[i] = XCNEWVEC (char, len) + sizeof (lang_bitmap); - strcpy (plugin_files[i], name); - } + if (inputlist) + fatal ("input list %s cannot be given with a read state file %s", + inputlist, read_state_filename); + read_state (read_state_filename); + DBGPRINT_COUNT_TYPE ("structures after read_state", structures); + DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs); } - else if (argc == 3) + else if (inputlist) { - srcdir = argv[1]; - inputlist = argv[2]; + /* These types are set up with #define or else outside of where + we can see them. We should initialize them before calling + read_input_list. */ +#define POS_HERE(Call) do { pos.file = this_file; pos.line = __LINE__; \ + Call;} while(0) + POS_HERE (do_scalar_typedef ("CUMULATIVE_ARGS", &pos)); + POS_HERE (do_scalar_typedef ("REAL_VALUE_TYPE", &pos)); + POS_HERE (do_scalar_typedef ("FIXED_VALUE_TYPE", &pos)); + POS_HERE (do_scalar_typedef ("double_int", &pos)); + POS_HERE (do_scalar_typedef ("uint64_t", &pos)); + POS_HERE (do_scalar_typedef ("uint8", &pos)); + POS_HERE (do_scalar_typedef ("jword", &pos)); + POS_HERE (do_scalar_typedef ("JCF_u2", &pos)); + POS_HERE (do_scalar_typedef ("void", &pos)); + POS_HERE (do_typedef ("PTR", + create_pointer (resolve_typedef ("void", &pos)), + &pos)); +#undef POS_HERE + read_input_list (inputlist); + for (i = 0; i < num_gt_files; i++) + { + parse_file (get_input_file_name (gt_files[i])); + DBGPRINTF ("parsed file #%d %s", + (int) i, get_input_file_name (gt_files[i])); + } + if (verbosity_level >= 1) + printf ("%s parsed %d files with %d GTY types\n", + progname, (int) num_gt_files, type_count); + + DBGPRINT_COUNT_TYPE ("structures after parsing", structures); + DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs); + } else - fatal ("usage: gengtype [-d] [-P pluginout.h] srcdir input-list " - "[file1 file2 ... fileN]"); - - srcdir_len = strlen (srcdir); - - read_input_list (inputlist); + fatal ("either an input list or a read state file should be given"); + if (hit_error) + return 1; + + + if (plugin_output_filename) + { + size_t ix = 0; + /* In plugin mode, we should have read a state file, and have + given at least one plugin file. */ + if (!read_state_filename) + fatal ("No read state given in plugin mode for %s", + plugin_output_filename); + + if (nb_plugin_files == 0 || !plugin_files) + fatal ("No plugin files given in plugin mode for %s", + plugin_output_filename); + + /* Parse our plugin files and augment the state. */ + for (ix = 0; ix < nb_plugin_files; ix++) + parse_file (get_input_file_name (plugin_files[ix])); + + if (hit_error) + return 1; + + plugin_output = create_file ("GCC", plugin_output_filename); + DBGPRINTF ("created plugin_output %p named %s", + (void *) plugin_output, plugin_output->name); + } + else + { /* No plugin files, we are in normal mode. */ + if (!srcdir) + fatal ("gengtype needs a source directory in normal mode"); + } if (hit_error) return 1; - scalar_char.u.scalar_is_char = true; - scalar_nonchar.u.scalar_is_char = false; gen_rtx_next (); - /* These types are set up with #define or else outside of where - we can see them. */ - pos.line = __LINE__ + 1; - do_scalar_typedef ("CUMULATIVE_ARGS", &pos); pos.line++; - do_scalar_typedef ("REAL_VALUE_TYPE", &pos); pos.line++; - do_scalar_typedef ("FIXED_VALUE_TYPE", &pos); pos.line++; - do_scalar_typedef ("double_int", &pos); pos.line++; - do_scalar_typedef ("uint64_t", &pos); pos.line++; - do_scalar_typedef ("uint8", &pos); pos.line++; - do_scalar_typedef ("jword", &pos); pos.line++; - do_scalar_typedef ("JCF_u2", &pos); pos.line++; - do_scalar_typedef ("void", &pos); pos.line++; - do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos)), &pos); - - for (i = 0; i < num_gt_files; i++) - parse_file (gt_files[i]); - - if (hit_error) - return 1; - + /* The call to set_gc_used may indirectly call find_param_structure + hence enlarge the param_structs list of types. */ set_gc_used (variables); + /* The state at this point is read from the state input file or by + parsing source files and optionally augmented by parsing plugin + source files. Write it now. */ + if (write_state_filename) + { + DBGPRINT_COUNT_TYPE ("structures before write_state", structures); + DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs); + + if (hit_error) + fatal ("didn't write state file %s after errors", + write_state_filename); + + DBGPRINTF ("before write_state %s", write_state_filename); + write_state (write_state_filename); + + if (do_dump) + dump_everything (); + + /* After having written the state file we return immediately to + avoid generating any output file. */ + if (hit_error) + return 1; + else + return 0; + } + + open_base_files (); + write_enum_defn (structures, param_structs); + write_typed_alloc_defns (structures, typedefs); output_header = plugin_output ? plugin_output : header_file; + DBGPRINT_COUNT_TYPE ("structures before write_types outputheader", + structures); + DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader", + param_structs); + write_types (output_header, structures, param_structs, &ggc_wtd); if (plugin_files == NULL) { + DBGPRINT_COUNT_TYPE ("structures before write_types headerfil", + structures); + DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil", + param_structs); write_types (header_file, structures, param_structs, &pch_wtd); write_local (header_file, structures, param_structs); } + write_splay_tree_allocators (param_structs); write_roots (variables, plugin_files == NULL); write_rtx_next (); close_output_files (); @@ -4025,12 +4997,7 @@ if (do_dump) dump_everything (); - if (plugin_files) - { - for (i = 0; i < nb_plugin_files; i++) - free (plugin_files[i] - sizeof (lang_bitmap)); - free (plugin_files); - } + /* Don't bother about free-ing any input or plugin file, etc. */ if (hit_error) return 1;