X-Git-Url: http://git.sourceforge.jp/view?a=blobdiff_plain;f=gcc%2Fgengtype.c;h=cb3d9bbf2211e87ec844e6a1f0571d836890a071;hb=a0cacb451a846e838aa6a1ba4746c6fe92179bcd;hp=3912c99fef6b159dcc4a5405b5b22f54a51313d3;hpb=6388f9f700c2179281798c832fa45aa1914706f8;p=pf3gnuchains%2Fgcc-fork.git diff --git a/gcc/gengtype.c b/gcc/gengtype.c index 3912c99fef6..cb3d9bbf221 100644 --- a/gcc/gengtype.c +++ b/gcc/gengtype.c @@ -1,36 +1,179 @@ /* Process source files and output type information. - Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc. + Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009 + Free Software Foundation, Inc. -This file is part of GCC. + This file is part of GCC. -GCC is free software; you can redistribute it and/or modify it under -the terms of the GNU General Public License as published by the Free -Software Foundation; either version 2, or (at your option) any later -version. + GCC is free software; you can redistribute it and/or modify it under + the terms of the GNU General Public License as published by the Free + Software Foundation; either version 3, or (at your option) any later + version. -GCC is distributed in the hope that it will be useful, but WITHOUT ANY -WARRANTY; without even the implied warranty of MERCHANTABILITY or -FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License -for more details. + GCC is distributed in the hope that it will be useful, but WITHOUT ANY + WARRANTY; without even the implied warranty of MERCHANTABILITY or + FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License + for more details. -You should have received a copy of the GNU General Public License -along with GCC; see the file COPYING. If not, write to the Free -Software Foundation, 59 Temple Place - Suite 330, Boston, MA -02111-1307, USA. */ + You should have received a copy of the GNU General Public License + along with GCC; see the file COPYING3. If not see + . */ #include "bconfig.h" #include "system.h" -#include "coretypes.h" -#include "tm.h" #include "gengtype.h" -#include "gtyp-gen.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; -#define NO_GENRTL_H -#include "rtl.h" -#undef abort +/* 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; + +/* The plugin input files and their number; in that case only + a single file is produced. */ +static char** plugin_files; +static size_t nb_plugin_files; +/* the generated plugin output name & file */ +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 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 int get_prefix_langdir_index (const char *); +static const char * get_file_langdir (const char *); + + /* Nonzero iff an error has occurred. */ -static int hit_error = 0; +bool hit_error = false; static void gen_rtx_next (void); static void write_rtx_next (void); @@ -40,7 +183,7 @@ static void close_output_files (void); /* Report an error at POS, printing MSG. */ void -error_at_line (struct fileloc *pos, const char *msg, ...) +error_at_line (const struct fileloc *pos, const char *msg, ...) { va_list ap; @@ -49,41 +192,343 @@ error_at_line (struct fileloc *pos, const char *msg, ...) fprintf (stderr, "%s:%d: ", pos->file, pos->line); vfprintf (stderr, msg, ap); fputc ('\n', stderr); - hit_error = 1; + hit_error = true; va_end (ap); } -/* vasprintf, but produces fatal message on out-of-memory. */ -int -xvasprintf (char **result, const char *format, va_list args) -{ - int ret = vasprintf (result, format, args); - if (*result == NULL || ret < 0) - { - fputs ("gengtype: out of memory", stderr); - xexit (1); - } - return ret; -} - -/* Wrapper for xvasprintf. */ +/* asprintf, but produces fatal message on out-of-memory. */ char * xasprintf (const char *format, ...) { + int n; char *result; va_list ap; va_start (ap, format); - xvasprintf (&result, format, ap); + n = vasprintf (&result, format, ap); + if (result == NULL || n < 0) + fatal ("out of memory"); va_end (ap); + return result; } + +/* 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__; + +/* Vector of per-language directories. */ +static const char **lang_dir_names; +static 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_' set iff + INPUT_FILE is used by . + + 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 (gtfile == this_file) + /* Things defined in this file are universal. */ + return (((lang_bitmap)1) << num_lang_dirs) - 1; + else + { + 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; + } +} + +/* 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; + } +} + +/* Scan the input file, LIST, and determine how much space we need to + store strings in. Also, count the number of language directories + and files. The numbers returned are overestimates as they does not + consider repeated files. */ +static size_t +measure_input_list (FILE *list) +{ + size_t n = 0; + int c; + bool atbol = true; + num_lang_dirs = 0; + num_gt_files = plugin_files ? nb_plugin_files : 0; + while ((c = getc (list)) != EOF) + { + n++; + if (atbol) + { + if (c == '[') + num_lang_dirs++; + else + { + /* Add space for a lang_bitmap before the input file name. */ + n += sizeof (lang_bitmap); + num_gt_files++; + } + atbol = false; + } + + if (c == '\n') + atbol = true; + } + + rewind (list); + return n; +} + +/* Read one input line from LIST to HEREP (which is updated). A + pointer to the string is returned via LINEP. If it was a language + subdirectory in square brackets, strip off the square brackets and + return true. Otherwise, leave space before the string for a + lang_bitmap, and return false. At EOF, returns false, does not + 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) +{ + char *here = *herep; + char *line; + int c = getc (list); + + /* Read over whitespace. */ + while (c == '\n' || c == ' ') + c = getc (list); + + if (c == EOF) + { + *linep = 0; + return false; + } + else if (c == '[') + { + /* No space for a lang_bitmap is necessary. Discard the '['. */ + c = getc (list); + line = here; + while (c != ']' && c != '\n' && c != EOF) + { + *here++ = c; + c = getc (list); + } + *here++ = '\0'; + + if (c == ']') + { + 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); + + *herep = here; + *linep = line; + return true; + } + else + { + /* Leave space for a lang_bitmap. */ + memset (here, 0, sizeof (lang_bitmap)); + here += sizeof (lang_bitmap); + line = here; + do + { + *here++ = c; + c = getc (list); + } + while (c != EOF && c != '\n'); + *here++ = '\0'; + *herep = here; + *linep = line; + return false; + } +} + +/* Read the list of input files from LIST and compute all of the + relevant tables. There is one file per line of the list. At + first, all the files on the list are language-generic, but + eventually a line will appear which is the name of a language + subdirectory in square brackets, like this: [cp]. All subsequent + files are specific to that language, until another language + subdirectory tag appears. Files can appear more than once, if + they apply to more than one language. */ +static void +read_input_list (const char *listname) +{ + FILE *list = fopen (listname, "r"); + if (!list) + fatal ("cannot open %s: %s", listname, strerror (errno)); + else + { + struct fileloc epos; + size_t bufsz = measure_input_list (list); + char *buf = XNEWVEC (char, bufsz); + char *here = buf; + char *committed = buf; + char *limit = buf + bufsz; + char *line; + bool is_language; + size_t langno = 0; + size_t nfiles = 0; + lang_bitmap curlangs = (1 << num_lang_dirs) - 1; + + epos.file = listname; + epos.line = 0; + + lang_dir_names = XNEWVEC (const char *, num_lang_dirs); + gt_files = XNEWVEC (const char *, num_gt_files); + + for (;;) + { + next_line: + epos.line++; + committed = here; + is_language = read_input_line (list, &here, &line, &epos); + gcc_assert (here <= limit); + if (line == 0) + break; + else if (is_language) + { + size_t i; + gcc_assert (langno <= num_lang_dirs); + for (i = 0; i < langno; i++) + if (strcmp (lang_dir_names[i], line) == 0) + { + error_at_line (&epos, "duplicate language tag [%s]", line); + curlangs = 1 << i; + here = committed; + goto next_line; + } + + curlangs = 1 << langno; + lang_dir_names[langno++] = line; + } + else + { + size_t i; + gcc_assert (nfiles <= num_gt_files); + for (i = 0; i < nfiles; i++) + if (strcmp (gt_files[i], line) == 0) + { + /* 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]); + 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]); + + bmap |= curlangs; + set_lang_bitmap (CONST_CAST(char *, gt_files[i]), bmap); + here = committed; + goto next_line; + } + + set_lang_bitmap (line, curlangs); + gt_files[nfiles++] = line; + } + } + /* Update the global counts now that we know accurately how many + things there are. (We do not bother resizing the arrays down.) */ + num_lang_dirs = langno; + /* Add the plugin files if provided. */ + if (plugin_files) + { + size_t i; + for (i = 0; i < nb_plugin_files; i++) + gt_files[nfiles++] = plugin_files[i]; + } + num_gt_files = nfiles; + } + + /* Sanity check: any file that resides in a language subdirectory + (e.g. 'cp') ought to belong to the corresponding language. + ??? Still true if for instance ObjC++ is enabled and C++ isn't? + (Can you even do that? Should you be allowed to?) */ + { + size_t f; + for (f = 0; f < num_gt_files; f++) + { + lang_bitmap bitmap = get_lang_bitmap (gt_files[f]); + const char *basename = get_file_basename (gt_files[f]); + const char *slashpos = strchr (basename, '/'); + + if (slashpos) + { + size_t l; + for (l = 0; l < num_lang_dirs; l++) + if ((size_t)(slashpos - basename) == strlen (lang_dir_names [l]) + && memcmp (basename, lang_dir_names[l], + strlen (lang_dir_names[l])) == 0) + { + if (!(bitmap & (1 << l))) + error ("%s is in language directory '%s' but is not " + "tagged for that language", + basename, lang_dir_names[l]); + break; + } + } + } + } + + if (ferror (list)) + fatal ("error reading %s: %s", listname, strerror (errno)); + fclose (list); +} + + + /* The one and only TYPE_STRING. */ -struct type string_type = { - TYPE_STRING, NULL, NULL, GC_USED, {0} +static struct type string_type = { + TYPE_STRING, 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} +}; +static struct type scalar_char = { + TYPE_SCALAR, 0, 0, GC_USED, {0} }; /* Lists of various things. */ @@ -93,7 +538,6 @@ static type_p structures; static type_p param_structs; static pair_p variables; -static void do_scalar_typedef (const char *, struct fileloc *); 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); @@ -106,6 +550,13 @@ do_typedef (const char *s, type_p t, struct fileloc *pos) { pair_p p; + /* temporary kludge - gengtype doesn't handle conditionals or + macros. Ignore any attempt to typedef CUMULATIVE_ARGS, unless it + is coming from this file (main() sets them up with safe dummy + definitions). */ + if (!strcmp (s, "CUMULATIVE_ARGS") && pos->file != this_file) + return; + for (p = typedefs; p != NULL; p = p->next) if (strcmp (p->name, s) == 0) { @@ -117,20 +568,23 @@ do_typedef (const char *s, type_p t, struct fileloc *pos) return; } - p = xmalloc (sizeof (struct pair)); + p = XNEW (struct pair); p->next = typedefs; p->name = s; p->type = t; p->line = *pos; + p->opt = NULL; typedefs = p; } -/* Define S as a typename of a scalar. */ +/* Define S as a typename of a scalar. Cannot be used to define + typedefs of 'char'. Note: is also used for pointer-to-function + typedefs (which are therefore not treated as pointers). */ -static void +void do_scalar_typedef (const char *s, struct fileloc *pos) { - do_typedef (s, create_scalar_type (s, strlen (s)), pos); + do_typedef (s, &scalar_nonchar, pos); } /* Return the type previously defined for S. Use POS to report errors. */ @@ -143,19 +597,26 @@ resolve_typedef (const char *s, struct fileloc *pos) if (strcmp (p->name, s) == 0) return p->type; error_at_line (pos, "unidentified type `%s'", s); - return create_scalar_type ("char", 4); + return &scalar_nonchar; /* treat as "int" */ } -/* Create a new structure with tag NAME (or a union iff ISUNION is nonzero), - at POS with fields FIELDS and options O. */ +/* Create and return a new structure with tag NAME (or a union iff + ISUNION is nonzero), at POS with fields FIELDS and options O. */ -void +type_p new_structure (const char *name, int isunion, struct fileloc *pos, pair_p fields, options_p o) { type_p si; type_p s = NULL; - lang_bitmap bitmap = get_base_file_bitmap (pos->file); + 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 @@ -173,7 +634,7 @@ new_structure (const char *name, int isunion, struct fileloc *pos, else if (si->u.s.line.file != NULL && si->u.s.bitmap != bitmap) { ls = si; - si = xcalloc (1, sizeof (struct type)); + si = XCNEW (struct type); memcpy (si, ls, sizeof (struct type)); ls->kind = TYPE_LANG_STRUCT; ls->u.s.lang_struct = si; @@ -187,7 +648,7 @@ new_structure (const char *name, int isunion, struct fileloc *pos, if (ls != NULL && s == NULL) { - s = xcalloc (1, sizeof (struct type)); + s = XCNEW (struct type); s->next = ls->u.s.lang_struct; ls->u.s.lang_struct = s; s->u.s.lang_struct = ls; @@ -197,7 +658,7 @@ new_structure (const char *name, int isunion, struct fileloc *pos, if (s == NULL) { - s = xcalloc (1, sizeof (struct type)); + s = XCNEW (struct type); s->next = structures; structures = s; } @@ -205,7 +666,8 @@ new_structure (const char *name, int isunion, struct fileloc *pos, if (s->u.s.line.file != NULL || (s->u.s.lang_struct && (s->u.s.lang_struct->u.s.bitmap & bitmap))) { - error_at_line (pos, "duplicate structure definition"); + error_at_line (pos, "duplicate definition of '%s %s'", + isunion ? "union" : "struct", s->u.s.tag); error_at_line (&s->u.s.line, "previous definition here"); } @@ -217,6 +679,23 @@ new_structure (const char *name, int isunion, struct fileloc *pos, s->u.s.bitmap = bitmap; 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 the previously-defined structure with tag NAME (or a union @@ -233,7 +712,7 @@ find_structure (const char *name, int isunion) && UNION_P (s) == isunion) return s; - s = xcalloc (1, sizeof (struct type)); + s = XCNEW (struct type); s->next = structures; structures = s; s->kind = isunion ? TYPE_UNION : TYPE_STRUCT; @@ -258,7 +737,7 @@ find_param_structure (type_p t, type_p param[NUM_PARAM]) break; if (res == NULL) { - res = xcalloc (1, sizeof (*res)); + res = XCNEW (struct type); res->kind = TYPE_PARAM_STRUCT; res->next = param_structs; param_structs = res; @@ -271,12 +750,12 @@ find_param_structure (type_p t, type_p param[NUM_PARAM]) /* Return a scalar type with name NAME. */ type_p -create_scalar_type (const char *name, size_t name_len) +create_scalar_type (const char *name) { - type_p r = xcalloc (1, sizeof (struct type)); - r->kind = TYPE_SCALAR; - r->u.sc = xmemdup (name, name_len, name_len + 1); - return r; + if (!strcmp (name, "char") || !strcmp (name, "unsigned char")) + return &scalar_char; + else + return &scalar_nonchar; } /* Return a pointer to T. */ @@ -286,7 +765,7 @@ create_pointer (type_p t) { if (! t->pointer_to) { - type_p r = xcalloc (1, sizeof (struct type)); + type_p r = XCNEW (struct type); r->kind = TYPE_POINTER; r->u.p = t; t->pointer_to = r; @@ -301,23 +780,39 @@ create_array (type_p t, const char *len) { type_p v; - v = xcalloc (1, sizeof (*v)); + v = XCNEW (struct type); v->kind = TYPE_ARRAY; v->u.a.p = t; v->u.a.len = len; return v; } -/* Return an options structure with name NAME and info INFO. */ +/* Return an options structure with name NAME and info INFO. NEXT is the + next option in the chain. */ + options_p -create_option (const char *name, void *info) +create_option (options_p next, const char *name, const void *info) { - options_p o = xmalloc (sizeof (*o)); + options_p o = XNEW (struct options); + o->next = next; o->name = name; - o->info = info; + o->info = (const char*) info; return o; } +/* Return an options structure for a "nested_ptr" option. */ +options_p +create_nested_ptr_option (options_p next, type_p t, + const char *to, const char *from) +{ + struct nested_ptr_data *d = XNEW (struct nested_ptr_data); + + d->type = adjust_field_type (t, 0); + d->convert_to = to; + d->convert_from = from; + return create_option (next, "nested_ptr", d); +} + /* Add a variable named S of type T with options O defined at POS, to `variables'. */ @@ -325,7 +820,7 @@ void note_variable (const char *s, type_p t, options_p o, struct fileloc *pos) { pair_p n; - n = xmalloc (sizeof (*n)); + n = XNEW (struct pair); n->name = s; n->type = t; n->line = *pos; @@ -334,9 +829,102 @@ note_variable (const char *s, type_p t, options_p o, struct fileloc *pos) variables = n; } -/* We really don't care how long a CONST_DOUBLE is. */ +/* 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) +{ + pair_p field; + + field = XNEW (struct pair); + field->next = next; + field->type = type; + field->name = name; + field->opt = opt; + field->line.file = file; + field->line.line = line; + return field; +} + +/* Create a field that came from the source code we are scanning, + i.e. we have a 'struct fileloc', and possibly options; also, + adjust_field_type should be called. */ +pair_p +create_field_at (pair_p next, type_p type, const char *name, options_p opt, + struct fileloc *pos) +{ + return create_field_all (next, adjust_field_type (type, opt), + name, opt, pos->file, pos->line); +} + +/* Create a fake field with the given type and name. NEXT is the next + field in the chain. */ +#define create_field(next,type,name) \ + create_field_all(next,type,name, 0, this_file, __LINE__) + +/* Like create_field, but the field is only valid when condition COND + is true. */ + +static pair_p +create_optional_field_ (pair_p next, type_p type, const char *name, + const char *cond, int line) +{ + static int id = 1; + pair_p union_fields; + type_p union_type; + + /* Create a fake union type with a single nameless field of type TYPE. + 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); + + /* 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), + this_file, line); +} +#define create_optional_field(next,type,name,cond) \ + create_optional_field_(next,type,name,cond,__LINE__) + +/* Reverse a linked list of 'struct pair's in place. */ +pair_p +nreverse_pairs (pair_p list) +{ + pair_p prev = 0, p, next; + for (p = list; p; p = next) + { + next = p->next; + p->next = prev; + prev = p; + } + return prev; +} + + +/* We don't care how long a CONST_DOUBLE is. */ #define CONST_DOUBLE_FORMAT "ww" -const char * const rtx_format[NUM_RTX_CODE] = { +/* We don't want to see codes that are only for generator files. */ +#undef GENERATOR_FILE + +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] = { +#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] = { #define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT , #include "rtl.def" #undef DEF_RTL_EXPR @@ -344,6 +932,27 @@ const char * const rtx_format[NUM_RTX_CODE] = { static int rtx_next_new[NUM_RTX_CODE]; +/* 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 { +#define DEF_INSN_NOTE(NAME) NAME, +#include "insn-notes.def" +#undef DEF_INSN_NOTE + + NOTE_INSN_MAX +}; + +/* 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] = { +#define DEF_INSN_NOTE(NAME) #NAME, +#include "insn-notes.def" +#undef DEF_INSN_NOTE +}; + +#undef CONST_DOUBLE_FORMAT +#define GENERATOR_FILE + /* Generate the contents of the rtx_next array. This really doesn't belong in gengtype at all, but it's needed for adjust_field_rtx_def. */ @@ -373,9 +982,11 @@ write_rtx_next (void) { outf_p f = get_output_file_with_visibility (NULL); int i; + if (!f) + return; oprintf (f, "\n/* Used to implement the RTX_NEXT macro. */\n"); - oprintf (f, "const unsigned char rtx_next[NUM_RTX_CODE] = {\n"); + oprintf (f, "EXPORTED_CONST unsigned char rtx_next[NUM_RTX_CODE] = {\n"); for (i = 0; i < NUM_RTX_CODE; i++) if (rtx_next_new[i] == -1) oprintf (f, " 0,\n"); @@ -391,19 +1002,13 @@ write_rtx_next (void) are based in a complex way on the type of RTL. */ static type_p -adjust_field_rtx_def (type_p t, options_p opt ATTRIBUTE_UNUSED) +adjust_field_rtx_def (type_p t, options_p ARG_UNUSED (opt)) { pair_p flds = NULL; options_p nodot; int i; type_p rtx_tp, rtvec_tp, tree_tp, mem_attrs_tp, note_union_tp, scalar_tp; - type_p bitmap_tp, basic_block_tp, reg_attrs_tp; - - 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 - }; + type_p basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp; if (t->kind != TYPE_UNION) { @@ -412,81 +1017,76 @@ adjust_field_rtx_def (type_p t, options_p opt ATTRIBUTE_UNUSED) return &string_type; } - nodot = xmalloc (sizeof (*nodot)); - nodot->next = NULL; - nodot->name = "dot"; - nodot->info = ""; + nodot = create_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)); - bitmap_tp = create_pointer (find_structure ("bitmap_element_def", 0)); basic_block_tp = create_pointer (find_structure ("basic_block_def", 0)); - scalar_tp = create_scalar_type ("rtunion scalar", 14); + constant_tp = create_pointer (find_structure ("constant_descriptor_rtx", 0)); + scalar_tp = &scalar_nonchar; /* rtunion int */ { pair_p note_flds = NULL; int c; - for (c = NOTE_INSN_BIAS; c <= NOTE_INSN_MAX; c++) + for (c = 0; c <= NOTE_INSN_MAX; c++) { - pair_p old_note_flds = note_flds; - - note_flds = xmalloc (sizeof (*note_flds)); - note_flds->line.file = __FILE__; - note_flds->line.line = __LINE__; - note_flds->opt = xmalloc (sizeof (*note_flds->opt)); - note_flds->opt->next = nodot; - note_flds->opt->name = "tag"; - note_flds->opt->info = xasprintf ("%d", c); - note_flds->next = old_note_flds; - switch (c) { - /* NOTE_INSN_MAX is used as the default field for line - number notes. */ case NOTE_INSN_MAX: - note_flds->opt->name = "default"; - note_flds->name = "rtstr"; - note_flds->type = &string_type; + case NOTE_INSN_DELETED_LABEL: + note_flds = create_field (note_flds, &string_type, "rt_str"); break; case NOTE_INSN_BLOCK_BEG: case NOTE_INSN_BLOCK_END: - note_flds->name = "rttree"; - note_flds->type = tree_tp; + note_flds = create_field (note_flds, tree_tp, "rt_tree"); break; - case NOTE_INSN_EXPECTED_VALUE: case NOTE_INSN_VAR_LOCATION: - note_flds->name = "rtx"; - note_flds->type = rtx_tp; + note_flds = create_field (note_flds, rtx_tp, "rt_rtx"); break; default: - note_flds->name = "rtint"; - note_flds->type = scalar_tp; + note_flds = create_field (note_flds, scalar_tp, "rt_int"); break; } + /* 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", ""); + else + note_flds->opt = create_option (nodot, "tag", note_insn_name[c]); } - new_structure ("rtx_def_note_subunion", 1, &lexer_line, note_flds, NULL); + note_union_tp = new_structure ("rtx_def_note_subunion", 1, + &lexer_line, note_flds, NULL); } + /* Create a type to represent the various forms of SYMBOL_REF_DATA. */ + { + pair_p sym_flds; - note_union_tp = find_structure ("rtx_def_note_subunion", 1); + sym_flds = create_field (NULL, tree_tp, "rt_tree"); + sym_flds->opt = create_option (nodot, "default", ""); + sym_flds = create_field (sym_flds, constant_tp, "rt_constant"); + sym_flds->opt = create_option (nodot, "tag", "1"); + + symbol_union_tp = new_structure ("rtx_def_symbol_subunion", 1, + &lexer_line, sym_flds, NULL); + } for (i = 0; i < NUM_RTX_CODE; i++) { - pair_p old_flds = flds; pair_p subfields = NULL; size_t aindex, nmindex; const char *sname; + type_p substruct; char *ftag; for (aindex = 0; aindex < strlen (rtx_format[i]); aindex++) { - pair_p old_subf = subfields; type_p t; const char *subname; @@ -497,48 +1097,52 @@ adjust_field_rtx_def (type_p t, options_p opt ATTRIBUTE_UNUSED) case 'n': case 'w': t = scalar_tp; - subname = "rtint"; + subname = "rt_int"; break; case '0': if (i == MEM && aindex == 1) - t = mem_attrs_tp, subname = "rtmem"; - else if (i == JUMP_INSN && aindex == 9) - t = rtx_tp, subname = "rtx"; + 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) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; else if (i == CODE_LABEL && aindex == 5) - t = rtx_tp, subname = "rtx"; + t = rtx_tp, subname = "rt_rtx"; else if (i == LABEL_REF && (aindex == 1 || aindex == 2)) - t = rtx_tp, subname = "rtx"; + t = rtx_tp, subname = "rt_rtx"; else if (i == NOTE && aindex == 4) t = note_union_tp, subname = ""; + else if (i == NOTE && aindex == 5) + t = scalar_tp, subname = "rt_int"; else if (i == NOTE && aindex >= 7) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; else if (i == ADDR_DIFF_VEC && aindex == 4) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; else if (i == VALUE && aindex == 0) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; + else if (i == DEBUG_EXPR && aindex == 0) + t = tree_tp, subname = "rt_tree"; else if (i == REG && aindex == 1) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; else if (i == REG && aindex == 2) - t = reg_attrs_tp, subname = "rtreg"; + t = reg_attrs_tp, subname = "rt_reg"; else if (i == SCRATCH && aindex == 0) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; else if (i == SYMBOL_REF && aindex == 1) - t = scalar_tp, subname = "rtint"; + t = scalar_tp, subname = "rt_int"; else if (i == SYMBOL_REF && aindex == 2) - t = tree_tp, subname = "rttree"; + t = symbol_union_tp, subname = ""; else if (i == BARRIER && aindex >= 3) - t = scalar_tp, subname = "rtint"; + 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); t = &string_type; - subname = "rtint"; + subname = "rt_int"; } break; @@ -546,34 +1150,29 @@ adjust_field_rtx_def (type_p t, options_p opt ATTRIBUTE_UNUSED) case 'S': case 'T': t = &string_type; - subname = "rtstr"; + subname = "rt_str"; break; case 'e': case 'u': t = rtx_tp; - subname = "rtx"; + subname = "rt_rtx"; break; case 'E': case 'V': t = rtvec_tp; - subname = "rtvec"; + subname = "rt_rtvec"; break; case 't': t = tree_tp; - subname = "rttree"; - break; - - case 'b': - t = bitmap_tp; - subname = "rtbit"; + subname = "rt_tree"; break; case 'B': t = basic_block_tp; - subname = "bb"; + subname = "rt_bb"; break; default: @@ -582,55 +1181,44 @@ adjust_field_rtx_def (type_p t, options_p opt ATTRIBUTE_UNUSED) rtx_name[i], rtx_format[i][aindex], (unsigned long)aindex); t = &string_type; - subname = "rtint"; + subname = "rt_int"; break; } - subfields = xmalloc (sizeof (*subfields)); - subfields->next = old_subf; - subfields->type = t; - subfields->name = xasprintf (".fld[%lu].%s", (unsigned long)aindex, - subname); - subfields->line.file = __FILE__; - subfields->line.line = __LINE__; + subfields = create_field (subfields, t, + xasprintf (".fld[%lu].%s", + (unsigned long) aindex, + subname)); + subfields->opt = nodot; if (t == note_union_tp) - { - subfields->opt = xmalloc (sizeof (*subfields->opt)); - subfields->opt->next = nodot; - subfields->opt->name = "desc"; - subfields->opt->info = "NOTE_LINE_NUMBER (&%0)"; - } - else if (t == basic_block_tp) - { - /* We don't presently GC basic block structures... */ - subfields->opt = xmalloc (sizeof (*subfields->opt)); - subfields->opt->next = nodot; - subfields->opt->name = "skip"; - subfields->opt->info = NULL; - } - else - subfields->opt = nodot; + subfields->opt = create_option (subfields->opt, "desc", + "NOTE_KIND (&%0)"); + if (t == symbol_union_tp) + subfields->opt = create_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. */ + type_p field_tp = find_structure ("block_symbol", 0); + subfields + = create_optional_field (subfields, field_tp, "block_sym", + "SYMBOL_REF_HAS_BLOCK_INFO_P (&%0)"); } - flds = xmalloc (sizeof (*flds)); - flds->next = old_flds; - flds->name = ""; sname = xasprintf ("rtx_def_%s", rtx_name[i]); - new_structure (sname, 0, &lexer_line, subfields, NULL); - flds->type = find_structure (sname, 0); - flds->line.file = __FILE__; - flds->line.line = __LINE__; - flds->opt = xmalloc (sizeof (*flds->opt)); - flds->opt->next = nodot; - flds->opt->name = "tag"; + substruct = new_structure (sname, 0, &lexer_line, subfields, NULL); + ftag = xstrdup (rtx_name[i]); for (nmindex = 0; nmindex < strlen (ftag); nmindex++) ftag[nmindex] = TOUPPER (ftag[nmindex]); - flds->opt->info = ftag; + + flds = create_field (flds, substruct, ""); + flds->opt = create_option (nodot, "tag", ftag); } - new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot); - return find_structure ("rtx_def_subunion", 1); + return new_structure ("rtx_def_subunion", 1, &lexer_line, flds, nodot); } /* Handle `special("tree_exp")'. This is a special case for @@ -652,31 +1240,14 @@ adjust_field_tree_exp (type_p t, options_p opt ATTRIBUTE_UNUSED) return &string_type; } - nodot = xmalloc (sizeof (*nodot)); - nodot->next = NULL; - nodot->name = "dot"; - nodot->info = ""; - - flds = xmalloc (sizeof (*flds)); - flds->next = NULL; - flds->name = ""; - flds->type = t; - flds->line.file = __FILE__; - flds->line.line = __LINE__; - flds->opt = xmalloc (sizeof (*flds->opt)); - flds->opt->next = nodot; - flds->opt->name = "length"; - flds->opt->info = "TREE_CODE_LENGTH (TREE_CODE ((tree) &%0))"; - { - options_p oldopt = flds->opt; - flds->opt = xmalloc (sizeof (*flds->opt)); - flds->opt->next = oldopt; - flds->opt->name = "default"; - flds->opt->info = ""; - } + nodot = create_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", ""); - new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot); - return find_structure ("tree_exp_subunion", 1); + return new_structure ("tree_exp_subunion", 1, &lexer_line, flds, nodot); } /* Perform any special processing on a type T, about to become the type @@ -724,13 +1295,13 @@ adjust_field_type (type_p t, options_p opt) if (params[num] != NULL) error_at_line (&lexer_line, "duplicate `%s' option", opt->name); if (! ISDIGIT (opt->name[5])) - params[num] = create_pointer ((type_p) opt->info); + params[num] = create_pointer (CONST_CAST2(type_p, const char *, opt->info)); else - params[num] = (type_p) opt->info; + params[num] = CONST_CAST2 (type_p, const char *, opt->info); } else if (strcmp (opt->name, "special") == 0) { - const char *special_name = (const char *)opt->info; + const char *special_name = opt->info; if (strcmp (special_name, "tree_exp") == 0) t = adjust_field_tree_exp (t, opt); else if (strcmp (special_name, "rtx_def") == 0) @@ -752,81 +1323,17 @@ adjust_field_type (type_p t, options_p opt) if (! length_p && pointer_p && t->u.p->kind == TYPE_SCALAR - && (strcmp (t->u.p->u.sc, "char") == 0 - || strcmp (t->u.p->u.sc, "unsigned char") == 0)) + && 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 - && (strcmp (t->u.a.p->u.p->u.sc, "char") == 0 - || strcmp (t->u.a.p->u.p->u.sc, "unsigned char") == 0)) + && t->u.a.p->u.p->u.scalar_is_char) return create_array (&string_type, t->u.a.len); return t; } -/* Create a union for YYSTYPE, as yacc would do it, given a fieldlist FIELDS - and information about the correspondence between token types and fields - in TYPEINFO. POS is used for error messages. */ - -void -note_yacc_type (options_p o, pair_p fields, pair_p typeinfo, - struct fileloc *pos) -{ - pair_p p; - pair_p *p_p; - - for (p = typeinfo; p; p = p->next) - { - pair_p m; - - if (p->name == NULL) - continue; - - if (p->type == (type_p) 1) - { - pair_p pp; - int ok = 0; - - for (pp = typeinfo; pp; pp = pp->next) - if (pp->type != (type_p) 1 - && strcmp (pp->opt->info, p->opt->info) == 0) - { - ok = 1; - break; - } - if (! ok) - continue; - } - - for (m = fields; m; m = m->next) - if (strcmp (m->name, p->name) == 0) - p->type = m->type; - if (p->type == NULL) - { - error_at_line (&p->line, - "couldn't match fieldname `%s'", p->name); - p->name = NULL; - } - } - - p_p = &typeinfo; - while (*p_p) - { - pair_p p = *p_p; - - if (p->name == NULL - || p->type == (type_p) 1) - *p_p = p->next; - else - p_p = &p->next; - } - - new_structure ("yy_union", 1, pos, typeinfo, o); - do_typedef ("YYSTYPE", find_structure ("yy_union", 1), pos); -} -static void process_gc_options (options_p, enum gc_used_enum, - int *, int *, int *, type_p *); static void set_gc_used_type (type_p, enum gc_used_enum, type_p *); static void set_gc_used (pair_p); @@ -834,18 +1341,21 @@ static void set_gc_used (pair_p); static void process_gc_options (options_p opt, enum gc_used_enum level, int *maybe_undef, - int *pass_param, int *length, 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 ((type_p) o->info, GC_POINTED_TO, NULL); + set_gc_used_type (CONST_CAST2 (type_p, const char *, o->info), + GC_POINTED_TO, NULL); else if (strcmp (o->name, "maybe_undef") == 0) *maybe_undef = 1; else if (strcmp (o->name, "use_params") == 0) *pass_param = 1; else if (strcmp (o->name, "length") == 0) *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; } @@ -869,7 +1379,7 @@ set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM]) int dummy; type_p dummy2; - process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, + process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy, &dummy2); for (f = t->u.s.fields; f; f = f->next) @@ -877,12 +1387,13 @@ set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM]) int maybe_undef = 0; int pass_param = 0; int length = 0; + int skip = 0; type_p nested_ptr = NULL; process_gc_options (f->opt, level, &maybe_undef, &pass_param, - &length, &nested_ptr); + &length, &skip, &nested_ptr); if (nested_ptr && f->type->kind == TYPE_POINTER) - set_gc_used_type (nested_ptr, GC_POINTED_TO, + set_gc_used_type (nested_ptr, GC_POINTED_TO, pass_param ? param : NULL); else if (length && f->type->kind == TYPE_POINTER) set_gc_used_type (f->type->u.p, GC_USED, NULL); @@ -891,6 +1402,8 @@ set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM]) else if (pass_param && f->type->kind == TYPE_POINTER && param) 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 */ else set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL); } @@ -945,27 +1458,7 @@ set_gc_used (pair_p variables) (but some output files have many input files), and there is one .h file for the whole build. */ -/* The list of output files. */ -static outf_p output_files; - -/* The output header file that is included into pretty much every - source file. */ -static outf_p header_file; - -/* Number of files specified in gtfiles. */ -#define NUM_GT_FILES (ARRAY_SIZE (all_files) - 1) - -/* Number of files in the language files array. */ -#define NUM_LANG_FILES (ARRAY_SIZE (lang_files) - 1) - -/* Length of srcdir name. */ -static int srcdir_len = 0; - -#define NUM_BASE_FILES (ARRAY_SIZE (lang_dir_names) - 1) -outf_p base_files[NUM_BASE_FILES]; - -static outf_p create_file (const char *, const char *); -static const char * get_file_basename (const char *); +/* Output file handling. */ /* Create and return an outf_p for a new file for NAME, to be called ONAME. */ @@ -974,13 +1467,13 @@ static outf_p create_file (const char *name, const char *oname) { static const char *const hdr[] = { - " Copyright (C) 2004 Free Software Foundation, Inc.\n", + " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n", "\n", "This file is part of GCC.\n", "\n", "GCC is free software; you can redistribute it and/or modify it under\n", "the terms of the GNU General Public License as published by the Free\n", - "Software Foundation; either version 2, or (at your option) any later\n", + "Software Foundation; either version 3, or (at your option) any later\n", "version.\n", "\n", "GCC is distributed in the hope that it will be useful, but WITHOUT ANY\n", @@ -989,16 +1482,17 @@ create_file (const char *name, const char *oname) "for more details.\n", "\n", "You should have received a copy of the GNU General Public License\n", - "along with GCC; see the file COPYING. If not, write to the Free\n", - "Software Foundation, 59 Temple Place - Suite 330, Boston, MA\n", - "02111-1307, USA. */\n", + "along with GCC; see the file COPYING3. If not see\n", + ". */\n", "\n", "/* This file is machine generated. Do not edit. */\n" }; outf_p f; size_t i; - f = xcalloc (sizeof (*f), 1); + gcc_assert (name != NULL); + gcc_assert (oname != NULL); + f = XCNEW (struct outf); f->next = output_files; f->name = oname; output_files = f; @@ -1009,7 +1503,11 @@ create_file (const char *name, const char *oname) return f; } -/* Print, like fprintf, to O. */ +/* Print, like fprintf, to O. + N.B. You might think this could be implemented more efficiently + with vsnprintf(). Unfortunately, there are C libraries that + provide that function but without the C99 semantics for its return + value, making it impossible to know how much space is required. */ void oprintf (outf_p o, const char *format, ...) { @@ -1017,8 +1515,16 @@ oprintf (outf_p o, const char *format, ...) size_t slength; va_list ap; + /* In plugin mode, the O could be a NULL pointer, so avoid crashing + in that case. */ + if (!o) + return; + va_start (ap, format); - slength = xvasprintf (&s, format, ap); + slength = vasprintf (&s, format, ap); + if (s == NULL || (int)slength < 0) + fatal ("out of memory"); + va_end (ap); if (o->bufused + slength > o->buflength) { @@ -1028,13 +1534,12 @@ oprintf (outf_p o, const char *format, ...) do { new_len *= 2; } while (o->bufused + slength >= new_len); - o->buf = xrealloc (o->buf, new_len); + o->buf = XRESIZEVEC (char, o->buf, new_len); o->buflength = new_len; } memcpy (o->buf + o->bufused, s, slength); o->bufused += slength; free (s); - va_end (ap); } /* Open the global header file and the language-specific header files. */ @@ -1044,9 +1549,14 @@ open_base_files (void) { size_t i; + if (nb_plugin_files > 0 && plugin_files) + return; + header_file = create_file ("GCC", "gtype-desc.h"); - for (i = 0; i < NUM_BASE_FILES; i++) + base_files = XNEWVEC (outf_p, num_lang_dirs); + + for (i = 0; i < num_lang_dirs; i++) base_files[i] = create_file (lang_dir_names[i], xasprintf ("gtype-%s.h", lang_dir_names[i])); @@ -1054,15 +1564,14 @@ open_base_files (void) { /* The order of files here matters very much. */ static const char *const ifiles [] = { - "config.h", "system.h", "coretypes.h", "tm.h", "varray.h", - "hashtab.h", "splay-tree.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-alias-type.h", "tree-flow.h", "reload.h", - "cpp-id-data.h", - "tree-chrec.h", - NULL + "config.h", "system.h", "coretypes.h", "tm.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 }; const char *const *ifp; outf_p gtype_desc_c; @@ -1070,100 +1579,121 @@ open_base_files (void) gtype_desc_c = create_file ("GCC", "gtype-desc.c"); for (ifp = ifiles; *ifp; ifp++) oprintf (gtype_desc_c, "#include \"%s\"\n", *ifp); + + /* Make sure we handle "cfun" specially. */ + oprintf (gtype_desc_c, "\n/* See definition in function.h. */\n"); + oprintf (gtype_desc_c, "#undef cfun\n"); } } -/* Determine the pathname to F relative to $(srcdir). */ +/* For F a filename, return the real basename of F, with all the directory + components skipped. */ + +static const char * +get_file_realbasename (const char *f) +{ + 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) +{ + if (strlen (f) > srcdir_len + && IS_DIR_SEPARATOR (f[srcdir_len]) + && memcmp (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. */ static const char * get_file_basename (const char *f) { - const char *basename; - unsigned i; + const char * srcdir_path = get_file_srcdir_relative_path (f); - basename = strrchr (f, '/'); + return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (f); +} - if (!basename) - return f; +/* For F a filename, return the lang_dir_names relative index of the language + directory that is a prefix in F, if any, -1 otherwise. */ - basename++; +static int +get_prefix_langdir_index (const char *f) +{ + size_t f_len = strlen (f); + size_t lang_index; - for (i = 1; i < NUM_BASE_FILES; i++) + for (lang_index = 0; lang_index < num_lang_dirs; lang_index++) { - const char * s1; - const char * s2; - int l1; - int l2; - s1 = basename - strlen (lang_dir_names [i]) - 1; - s2 = lang_dir_names [i]; - l1 = strlen (s1); - l2 = strlen (s2); - if (l1 >= l2 && !memcmp (s1, s2, l2)) - { - basename -= l2 + 1; - if ((basename - f - 1) != srcdir_len) - abort (); /* Match is wrong - should be preceded by $srcdir. */ - break; - } + const char * langdir = lang_dir_names [lang_index]; + size_t langdir_len = strlen (langdir); + + if (f_len > langdir_len + && IS_DIR_SEPARATOR (f[langdir_len]) + && memcmp (f, langdir, langdir_len) == 0) + return lang_index; } - return basename; + return -1; } -/* Return a bitmap which has bit `1 << BASE_FILE_' set iff - INPUT_FILE is used by . +/* For F a filename, return the name of language directory where F is located, + if any, NULL otherwise. */ - This function should be written to assume that a file _is_ used - if the situation is unclear. If it wrongly assumes a file _is_ used, - a linker error will result. If it wrongly assumes a file _is not_ used, - some GC roots may be missed, which is a much harder-to-debug problem. */ +static const char * +get_file_langdir (const char *f) +{ + /* 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. */ + + int lang_index; + const char * srcdir_relative_path = get_file_srcdir_relative_path (f); + + 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; +} + +/* The gt- output file name for F. */ -unsigned -get_base_file_bitmap (const char *input_file) +static const char * +get_file_gtfilename (const char *f) { - const char *basename = get_file_basename (input_file); - const char *slashpos = strchr (basename, '/'); - unsigned j; - unsigned k; - unsigned bitmap; + /* Cook up an initial version of the gt- file name from the file real + basename and the language name, if any. */ - if (slashpos) - { - size_t i; - for (i = 1; i < NUM_BASE_FILES; i++) - if ((size_t)(slashpos - basename) == strlen (lang_dir_names [i]) - && memcmp (basename, lang_dir_names[i], strlen (lang_dir_names[i])) == 0) - { - /* It's in a language directory, set that language. */ - bitmap = 1 << i; - return bitmap; - } + const char *basename = get_file_realbasename (f); + const char *langdir = get_file_langdir (f); - abort (); /* Should have found the language. */ - } + char * result = + (langdir ? xasprintf ("gt-%s-%s", langdir, basename) + : xasprintf ("gt-%s", basename)); - /* If it's in any config-lang.in, then set for the languages - specified. */ + /* Then replace all non alphanumerics characters by '-' and change the + extension to ".h". We expect the input filename extension was at least + one character long. */ - bitmap = 0; + char *s = result; - for (j = 0; j < NUM_LANG_FILES; j++) - { - if (!strcmp(input_file, lang_files[j])) - { - for (k = 0; k < NUM_BASE_FILES; k++) - { - if (!strcmp(lang_dir_names[k], langs_for_lang_files[j])) - bitmap |= (1 << k); - } - } - } + for (; *s != '.'; s++) + if (! ISALNUM (*s) && *s != '-') + *s = '-'; - /* Otherwise, set all languages. */ - if (!bitmap) - bitmap = (1 << NUM_BASE_FILES) - 1; + memcpy (s, ".h", sizeof (".h")); - return bitmap; + return result; } /* An output file, suitable for definitions, that can see declarations @@ -1185,6 +1715,18 @@ get_output_file_with_visibility (const char *input_file) if (input_file == NULL) input_file = "system.h"; + /* In plugin mode, return NULL unless the input_file is one of the + plugin_files. */ + if (plugin_files) + { + size_t i; + for (i = 0; i < nb_plugin_files; i++) + if (strcmp (input_file, plugin_files[i]) == 0) + return plugin_output; + + return NULL; + } + /* Determine the output file name. */ basename = get_file_basename (input_file); @@ -1193,27 +1735,38 @@ get_output_file_with_visibility (const char *input_file) || (len > 2 && memcmp (basename+len-2, ".y", 2) == 0) || (len > 3 && memcmp (basename+len-3, ".in", 3) == 0)) { - char *s; - - output_name = s = xasprintf ("gt-%s", basename); - for (; *s != '.'; s++) - if (! ISALNUM (*s) && *s != '-') - *s = '-'; - memcpy (s, ".h", sizeof (".h")); + output_name = get_file_gtfilename (input_file); for_name = basename; } + /* Some headers get used by more than one front-end; hence, it + would be inappropriate to spew them out to a single gtype-.h + (and gengtype doesn't know how to direct spewage into multiple + gtype-.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 { - size_t i; + int lang_index = get_prefix_langdir_index (basename); - for (i = 0; i < NUM_BASE_FILES; i++) - if (memcmp (basename, lang_dir_names[i], strlen (lang_dir_names[i])) == 0 - && basename[strlen(lang_dir_names[i])] == '/') - return base_files[i]; + if (lang_index >= 0) + return base_files[lang_index]; output_name = "gtype-desc.c"; for_name = NULL; @@ -1227,6 +1780,7 @@ get_output_file_with_visibility (const char *input_file) /* If not, create it. */ r = create_file (for_name, output_name); + gcc_assert (r && r->name); return r; } @@ -1237,7 +1791,36 @@ get_output_file_with_visibility (const char *input_file) const char * get_output_file_name (const char *input_file) { - return get_output_file_with_visibility (input_file)->name; + outf_p o = get_output_file_with_visibility (input_file); + if (o) + return o->name; + return NULL; +} + +/* Check if existing file is equal to the in memory buffer. */ + +static bool +is_file_equal (outf_p of) +{ + FILE *newfile = fopen (of->name, "r"); + size_t i; + bool equal; + if (newfile == NULL) + return false; + + equal = true; + for (i = 0; i < of->bufused; i++) + { + int ch; + ch = fgetc (newfile); + if (ch == EOF || ch != (unsigned char) of->buf[i]) + { + equal = false; + break; + } + } + fclose (newfile); + return equal; } /* Copy the output to its final destination, @@ -1250,44 +1833,20 @@ close_output_files (void) for (of = output_files; of; of = of->next) { - FILE * newfile; - - newfile = fopen (of->name, "r"); - if (newfile != NULL ) - { - int no_write_p; - size_t i; - - for (i = 0; i < of->bufused; i++) - { - int ch; - ch = fgetc (newfile); - if (ch == EOF || ch != (unsigned char) of->buf[i]) - break; - } - no_write_p = i == of->bufused && fgetc (newfile) == EOF; - fclose (newfile); - - if (no_write_p) - continue; - } - newfile = fopen (of->name, "w"); - if (newfile == NULL) - { - perror ("opening output file"); - exit (1); - } - if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused) - { - perror ("writing output file"); - exit (1); - } - if (fclose (newfile) != 0) - { - perror ("closing output file"); - exit (1); - } + 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); + of->buf = NULL; + of->bufused = of->buflength = 0; } } @@ -1319,25 +1878,28 @@ struct write_types_data const char *marker_routine; const char *reorder_note_routine; const char *comment; + int skip_hooks; /* skip hook generation if non zero */ }; static void output_escaped_param (struct walk_type_data *d, const char *, const char *); -static void output_mangled_typename (outf_p, type_p); +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_types_process_field (type_p f, const struct walk_type_data *d); -static void write_types (type_p structures, +static void write_types (outf_p output_header, + 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); static void write_local_func_for_structure - (type_p orig_s, type_p s, type_p * param); -static void write_local (type_p structures, + (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); static void write_enum_defn (type_p structures, type_p param_structs); static int contains_scalar_p (type_p t); @@ -1346,10 +1908,10 @@ 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, - struct fileloc *, const char *); + struct fileloc *, const char *, bool); static void write_array (outf_p f, pair_p v, const struct write_types_data *wtd); -static void write_roots (pair_p); +static void write_roots (pair_p, bool); /* Parameters for walk_type. */ @@ -1363,7 +1925,7 @@ struct walk_type_data const char *prev_val[4]; int indent; int counter; - struct fileloc *line; + const struct fileloc *line; lang_bitmap bitmap; type_p *param; int used_length; @@ -1376,7 +1938,7 @@ struct walk_type_data /* Print a mangled name representing T to OF. */ static void -output_mangled_typename (outf_p of, type_p t) +output_mangled_typename (outf_p of, const_type_p t) { if (t == NULL) oprintf (of, "Z"); @@ -1407,7 +1969,7 @@ output_mangled_typename (outf_p of, type_p t) } break; case TYPE_ARRAY: - abort (); + gcc_unreachable (); } } @@ -1476,7 +2038,7 @@ walk_type (type_p t, struct walk_type_data *d) d->needs_cast_p = false; for (oo = d->opt; oo; oo = oo->next) if (strcmp (oo->name, "length") == 0) - length = (const char *)oo->info; + length = oo->info; else if (strcmp (oo->name, "maybe_undef") == 0) maybe_undef_p = 1; else if (strncmp (oo->name, "use_param", 9) == 0 @@ -1485,7 +2047,9 @@ walk_type (type_p t, struct walk_type_data *d) else if (strcmp (oo->name, "use_params") == 0) use_params_p = 1; else if (strcmp (oo->name, "desc") == 0) - desc = (const char *)oo->info; + desc = oo->info; + 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, "dot") == 0) @@ -1510,6 +2074,8 @@ walk_type (type_p t, struct walk_type_data *d) ; else if (strcmp (oo->name, "chain_prev") == 0) ; + else if (strcmp (oo->name, "chain_circular") == 0) + ; else if (strcmp (oo->name, "reorder") == 0) ; else @@ -1573,7 +2139,7 @@ walk_type (type_p t, struct walk_type_data *d) if (maybe_undef_p && t->u.p->u.s.line.file == NULL) { - oprintf (d->of, "%*sif (%s) abort();\n", d->indent, "", d->val); + oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val); break; } @@ -1606,9 +2172,9 @@ walk_type (type_p t, struct walk_type_data *d) d->indent += 2; d->val = xasprintf ("x%d", d->counter++); oprintf (d->of, "%*s%s %s * %s%s =\n", d->indent, "", - (nested_ptr_d->type->kind == TYPE_UNION - ? "union" : "struct"), - nested_ptr_d->type->u.s.tag, + (nested_ptr_d->type->kind == TYPE_UNION + ? "union" : "struct"), + nested_ptr_d->type->u.s.tag, d->fn_wants_lvalue ? "" : "const ", d->val); oprintf (d->of, "%*s", d->indent + 2, ""); @@ -1646,7 +2212,7 @@ walk_type (type_p t, struct walk_type_data *d) 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, "", + 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); @@ -1679,16 +2245,27 @@ walk_type (type_p t, struct walk_type_data *d) if (t->u.a.p->kind == TYPE_SCALAR) break; + /* When walking an array, compute the length and store it in a + local variable before walking the array elements, instead of + recomputing the length expression each time through the loop. + This is necessary to handle tcc_vl_exp objects like CALL_EXPR, + where the length is stored in the first array element, + because otherwise that operand can get overwritten on the + first iteration. */ oprintf (d->of, "%*s{\n", d->indent, ""); 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, "%*ssize_t l%d = (size_t)(", + d->indent, "", loopcounter); if (length) output_escaped_param (d, length, "length"); else oprintf (d->of, "%s", t->u.a.len); - oprintf (d->of, "); i%d++) {\n", loopcounter); + oprintf (d->of, ");\n"); + + oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n", + d->indent, "", + loopcounter, loopcounter, loopcounter, loopcounter); d->indent += 2; d->val = newval = xasprintf ("%s[i%d]", oldval, loopcounter); d->used_length = 1; @@ -1728,7 +2305,7 @@ walk_type (type_p t, struct walk_type_data *d) /* 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 = (const char *)o->info; + desc = o->info; d->prev_val[2] = oldval; d->prev_val[1] = oldprevval2; @@ -1759,15 +2336,15 @@ walk_type (type_p t, struct walk_type_data *d) d->reorder_fn = NULL; for (oo = f->opt; oo; oo = oo->next) if (strcmp (oo->name, "dot") == 0) - dot = (const char *)oo->info; + dot = oo->info; else if (strcmp (oo->name, "tag") == 0) - tagid = (const char *)oo->info; + tagid = oo->info; 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 = (const char *)oo->info; + d->reorder_fn = oo->info; else if (strncmp (oo->name, "use_param", 9) == 0 && (oo->name[9] == '\0' || ISDIGIT (oo->name[9]))) use_param_p = 1; @@ -1809,7 +2386,7 @@ walk_type (type_p t, struct walk_type_data *d) d->used_length = false; if (union_p && use_param_p && d->param == NULL) - oprintf (d->of, "%*sabort();\n", d->indent, ""); + oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, ""); else walk_type (f->type, d); @@ -1865,7 +2442,7 @@ walk_type (type_p t, struct walk_type_data *d) break; default: - abort (); + gcc_unreachable (); } } @@ -1893,6 +2470,21 @@ write_types_process_field (type_p f, const struct walk_type_data *d) } else oprintf (d->of, ", gt_%sa_%s", wtd->param_prefix, d->prev_val[0]); + + if (f->u.p->kind == TYPE_PARAM_STRUCT + && f->u.p->u.s.line.file != NULL) + { + 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) + { + oprintf (d->of, ", gt_ggc_e_"); + output_mangled_typename (d->of, f); + } + else + oprintf (d->of, ", gt_types_enum_last"); } oprintf (d->of, ");\n"); if (d->reorder_fn && wtd->reorder_note_routine) @@ -1902,9 +2494,6 @@ write_types_process_field (type_p f, const struct walk_type_data *d) break; case TYPE_STRING: - if (wtd->param_prefix == NULL) - break; - case TYPE_STRUCT: case TYPE_UNION: case TYPE_LANG_STRUCT: @@ -1918,12 +2507,49 @@ write_types_process_field (type_p f, const struct walk_type_data *d) d->reorder_fn); break; - case TYPE_SCALAR: - break; + case TYPE_SCALAR: + break; + + default: + gcc_unreachable (); + } +} + +/* A subroutine of write_func_for_structure. Write the enum tag for S. */ + +static void +output_type_enum (outf_p of, type_p s) +{ + if (s->kind == TYPE_PARAM_STRUCT && s->u.s.line.file != NULL) + { + oprintf (of, ", gt_e_"); + output_mangled_typename (of, s); + } + else if (UNION_OR_STRUCT_P (s) && s->u.s.line.file != NULL) + { + oprintf (of, ", gt_ggc_e_"); + output_mangled_typename (of, s); + } + else + oprintf (of, ", gt_types_enum_last"); +} + +/* Return an output file that is suitable for definitions which can + reference struct S */ - default: - abort (); - } +static outf_p +get_output_file_for_structure (const_type_p s, type_p *param) +{ + const char * fn = s->u.s.line.file; + int i; + + /* 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); } /* For S, a structure that's part of ORIG_S, and using parameters @@ -1938,30 +2564,32 @@ static void write_func_for_structure (type_p orig_s, type_p s, type_p *param, const struct write_types_data *wtd) { - const char *fn = s->u.s.line.file; - int i; const char *chain_next = NULL; const char *chain_prev = NULL; + const char *chain_circular = NULL; + const char *mark_hook_name = NULL; options_p opt; struct walk_type_data d; - /* 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; - memset (&d, 0, sizeof (d)); - d.of = get_output_file_with_visibility (fn); + 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 = (const char *) opt->info; + chain_next = opt->info; else if (strcmp (opt->name, "chain_prev") == 0) - chain_prev = (const char *) opt->info; + 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 (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) + error_at_line (&s->u.s.line, "chain_circular with chain_next"); + if (chain_circular != NULL) + chain_next = chain_circular; d.process_field = write_types_process_field; d.cookie = wtd; @@ -2000,22 +2628,36 @@ write_func_for_structure (type_p orig_s, type_p s, type_p *param, { oprintf (d.of, ", x, gt_%s_", wtd->param_prefix); output_mangled_typename (d.of, orig_s); + output_type_enum (d.of, orig_s); } oprintf (d.of, "))\n"); } else { - oprintf (d.of, " while (%s (xlimit", wtd->marker_routine); + if (chain_circular != NULL) + oprintf (d.of, " if (!%s (xlimit", wtd->marker_routine); + else + oprintf (d.of, " while (%s (xlimit", wtd->marker_routine); if (wtd->param_prefix) { oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix); output_mangled_typename (d.of, orig_s); + output_type_enum (d.of, orig_s); } oprintf (d.of, "))\n"); + if (chain_circular != NULL) + oprintf (d.of, " return;\n do\n"); + if (mark_hook_name && !wtd->skip_hooks) + { + oprintf (d.of, " {\n"); + oprintf (d.of, " %s (xlimit);\n ", mark_hook_name); + } oprintf (d.of, " xlimit = ("); d.prev_val[2] = "*xlimit"; output_escaped_param (&d, chain_next, "chain_next"); oprintf (d.of, ");\n"); + if (mark_hook_name && !wtd->skip_hooks) + oprintf (d.of, " }\n"); if (chain_prev != NULL) { oprintf (d.of, " if (x != xlimit)\n"); @@ -2035,14 +2677,33 @@ write_func_for_structure (type_p orig_s, type_p s, type_p *param, { oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix); output_mangled_typename (d.of, orig_s); + output_type_enum (d.of, orig_s); } oprintf (d.of, ");\n"); oprintf (d.of, " }\n"); } - oprintf (d.of, " while (x != xlimit)\n"); + if (chain_circular != NULL) + { + oprintf (d.of, " while (%s (xlimit", wtd->marker_routine); + if (wtd->param_prefix) + { + oprintf (d.of, ", xlimit, gt_%s_", wtd->param_prefix); + output_mangled_typename (d.of, orig_s); + output_type_enum (d.of, orig_s); + } + oprintf (d.of, "));\n"); + if (mark_hook_name && !wtd->skip_hooks) + oprintf (d.of, " %s (xlimit);\n", mark_hook_name); + oprintf (d.of, " do\n"); + } + else + oprintf (d.of, " while (x != xlimit)\n"); } oprintf (d.of, " {\n"); - + if (mark_hook_name && chain_next == NULL && !wtd->skip_hooks) + { + oprintf (d.of, " %s (x);\n", mark_hook_name); + } d.prev_val[2] = "*x"; d.indent = 6; walk_type (s, &d); @@ -2055,18 +2716,23 @@ write_func_for_structure (type_p orig_s, type_p s, type_p *param, } oprintf (d.of, " }\n"); + if (chain_circular != NULL) + oprintf (d.of, " while (x != xlimit);\n"); oprintf (d.of, "}\n"); } /* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */ static void -write_types (type_p structures, type_p param_structs, +write_types (outf_p output_header, type_p structures, type_p param_structs, const struct write_types_data *wtd) { type_p s; - oprintf (header_file, "\n/* %s*/\n", wtd->comment); + oprintf (output_header, "\n/* %s*/\n", wtd->comment); + /* We first emit the macros and the declarations. Functions' code is + 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) @@ -2077,23 +2743,23 @@ write_types (type_p structures, type_p param_structs, && s->u.s.line.file == NULL) continue; - oprintf (header_file, "#define gt_%s_", wtd->prefix); - output_mangled_typename (header_file, s); - oprintf (header_file, "(X) do { \\\n"); - oprintf (header_file, + oprintf (output_header, "#define gt_%s_", wtd->prefix); + output_mangled_typename (output_header, s); + oprintf (output_header, "(X) do { \\\n"); + oprintf (output_header, " if (X != NULL) gt_%sx_%s (X);\\\n", wtd->prefix, s->u.s.tag); - oprintf (header_file, + oprintf (output_header, " } while (0)\n"); for (opt = s->u.s.opt; opt; opt = opt->next) if (strcmp (opt->name, "ptr_alias") == 0) { - type_p t = (type_p) opt->info; + const_type_p const t = (const_type_p) opt->info; if (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT) - oprintf (header_file, + oprintf (output_header, "#define gt_%sx_%s gt_%sx_%s\n", wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag); else @@ -2105,7 +2771,7 @@ write_types (type_p structures, type_p param_structs, continue; /* Declare the marker procedure only once. */ - oprintf (header_file, + oprintf (output_header, "extern void gt_%sx_%s (void *);\n", wtd->prefix, s->u.s.tag); @@ -2115,27 +2781,17 @@ write_types (type_p structures, type_p param_structs, s->u.s.tag); continue; } - - if (s->kind == TYPE_LANG_STRUCT) - { - type_p ss; - for (ss = s->u.s.lang_struct; ss; ss = ss->next) - write_func_for_structure (s, ss, NULL, wtd); - } - else - write_func_for_structure (s, s, NULL, wtd); } 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 stru = s->u.param_struct.stru; /* Declare the marker procedure. */ - oprintf (header_file, "extern void gt_%s_", wtd->prefix); - output_mangled_typename (header_file, s); - oprintf (header_file, " (void *);\n"); + oprintf (output_header, "extern void gt_%s_", wtd->prefix); + output_mangled_typename (output_header, s); + oprintf (output_header, " (void *);\n"); if (stru->u.s.line.file == NULL) { @@ -2143,7 +2799,41 @@ write_types (type_p structures, type_p param_structs, s->u.s.tag); continue; } + } + /* 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) + { + options_p opt; + + 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) + break; + if (opt) + continue; + + if (s->kind == TYPE_LANG_STRUCT) + { + type_p ss; + for (ss = s->u.s.lang_struct; ss; ss = ss->next) + write_func_for_structure (s, ss, NULL, wtd); + } + else + write_func_for_structure (s, s, NULL, wtd); + } + 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 stru = s->u.param_struct.stru; + if (stru->u.s.line.file == NULL) + continue; if (stru->kind == TYPE_LANG_STRUCT) { type_p ss; @@ -2158,14 +2848,16 @@ write_types (type_p structures, type_p param_structs, static const struct write_types_data ggc_wtd = { "ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL, - "GC marker procedures. " + "GC marker procedures. ", + FALSE }; 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. " + "PCH type-walking procedures. ", + TRUE }; /* Write out the local pointer-walking routines. */ @@ -2192,7 +2884,7 @@ write_types_local_process_field (type_p f, const struct walk_type_data *d) break; default: - abort (); + gcc_unreachable (); } } @@ -2203,21 +2895,12 @@ write_types_local_process_field (type_p f, const struct walk_type_data *d) */ static void -write_local_func_for_structure (type_p orig_s, type_p s, type_p *param) +write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param) { - const char *fn = s->u.s.line.file; - int i; struct walk_type_data d; - /* 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; - memset (&d, 0, sizeof (d)); - d.of = get_output_file_with_visibility (fn); - + d.of = get_output_file_for_structure (s, param); d.process_field = write_types_local_process_field; d.opt = s->u.s.opt; d.line = &s->u.s.line; @@ -2233,7 +2916,10 @@ write_local_func_for_structure (type_p orig_s, type_p s, type_p *param) oprintf (d.of, "void\n"); oprintf (d.of, "gt_pch_p_"); output_mangled_typename (d.of, orig_s); - oprintf (d.of, " (void *this_obj ATTRIBUTE_UNUSED,\n\tvoid *x_p,\n\tgt_pointer_operator op ATTRIBUTE_UNUSED,\n\tvoid *cookie ATTRIBUTE_UNUSED)\n"); + oprintf (d.of, " (ATTRIBUTE_UNUSED void *this_obj,\n" + "\tvoid *x_p,\n" + "\tATTRIBUTE_UNUSED gt_pointer_operator op,\n" + "\tATTRIBUTE_UNUSED void *cookie)\n"); oprintf (d.of, "{\n"); oprintf (d.of, " %s %s * const x ATTRIBUTE_UNUSED = (%s %s *)x_p;\n", s->kind == TYPE_UNION ? "union" : "struct", s->u.s.tag, @@ -2246,11 +2932,13 @@ write_local_func_for_structure (type_p orig_s, type_p s, type_p *param) /* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */ static void -write_local (type_p structures, type_p param_structs) +write_local (outf_p output_header, type_p structures, type_p param_structs) { type_p s; - oprintf (header_file, "\n/* Local pointer-walking routines. */\n"); + if (!output_header) + 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) @@ -2263,16 +2951,16 @@ write_local (type_p structures, type_p param_structs) for (opt = s->u.s.opt; opt; opt = opt->next) if (strcmp (opt->name, "ptr_alias") == 0) { - type_p t = (type_p) opt->info; + const_type_p const t = (const_type_p) opt->info; if (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT) { - oprintf (header_file, "#define gt_pch_p_"); - output_mangled_typename (header_file, s); - oprintf (header_file, " gt_pch_p_"); - output_mangled_typename (header_file, t); - oprintf (header_file, "\n"); + oprintf (output_header, "#define gt_pch_p_"); + output_mangled_typename (output_header, s); + oprintf (output_header, " gt_pch_p_"); + output_mangled_typename (output_header, t); + oprintf (output_header, "\n"); } else error_at_line (&s->u.s.line, @@ -2283,9 +2971,9 @@ write_local (type_p structures, type_p param_structs) continue; /* Declare the marker procedure only once. */ - oprintf (header_file, "extern void gt_pch_p_"); - output_mangled_typename (header_file, s); - oprintf (header_file, + 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"); if (s->kind == TYPE_LANG_STRUCT) @@ -2305,9 +2993,9 @@ write_local (type_p structures, type_p param_structs) type_p stru = s->u.param_struct.stru; /* Declare the marker procedure. */ - oprintf (header_file, "extern void gt_pch_p_"); - output_mangled_typename (header_file, s); - oprintf (header_file, + 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"); if (stru->u.s.line.file == NULL) @@ -2335,6 +3023,8 @@ write_enum_defn (type_p structures, type_p param_structs) { type_p s; + 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) @@ -2385,6 +3075,8 @@ static void put_mangled_filename (outf_p f, const char *fn) { const char *name = get_output_file_name (fn); + if (!f || !name) + return; for (; *name != 0; name++) if (ISALNUM (*name)) oprintf (f, "%c", *name); @@ -2409,10 +3101,10 @@ finish_root_table (struct flist *flp, const char *pfx, const char *lastname, oprintf (fli2->f, "};\n\n"); } - for (fli2 = flp; fli2; fli2 = fli2->next) + for (fli2 = flp; fli2 && base_files; fli2 = fli2->next) if (fli2->started_p) { - lang_bitmap bitmap = get_base_file_bitmap (fli2->name); + lang_bitmap bitmap = get_lang_bitmap (fli2->name); int fnum; for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1) @@ -2428,9 +3120,9 @@ finish_root_table (struct flist *flp, const char *pfx, const char *lastname, { size_t fnum; - for (fnum = 0; fnum < NUM_BASE_FILES; fnum++) + for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++) oprintf (base_files [fnum], - "const struct %s * const %s[] = {\n", + "EXPORTED_CONST struct %s * const %s[] = {\n", tname, name); } @@ -2438,12 +3130,12 @@ finish_root_table (struct flist *flp, const char *pfx, const char *lastname, for (fli2 = flp; fli2; fli2 = fli2->next) if (fli2->started_p) { - lang_bitmap bitmap = get_base_file_bitmap (fli2->name); + lang_bitmap bitmap = get_lang_bitmap (fli2->name); int fnum; fli2->started_p = 0; - for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1) + for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1) if (bitmap & 1) { oprintf (base_files[fnum], " gt_%s_", pfx); @@ -2454,7 +3146,7 @@ finish_root_table (struct flist *flp, const char *pfx, const char *lastname, { size_t fnum; - for (fnum = 0; fnum < NUM_BASE_FILES; fnum++) + for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++) { oprintf (base_files[fnum], " NULL\n"); oprintf (base_files[fnum], "};\n"); @@ -2469,7 +3161,7 @@ finish_root_table (struct flist *flp, const char *pfx, const char *lastname, static void write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, - struct fileloc *line, const char *if_marked) + struct fileloc *line, const char *if_marked, bool emit_pch) { switch (type->kind) { @@ -2486,7 +3178,9 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, if (strcmp (o->name, "skip") == 0) skip_p = 1; else if (strcmp (o->name, "desc") == 0) - desc = (const char *)o->info; + desc = o->info; + else if (strcmp (o->name, "param_is") == 0) + ; else error_at_line (line, "field `%s' of global `%s' has unknown option `%s'", @@ -2506,7 +3200,7 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, for (oo = ufld->opt; oo; oo = oo->next) if (strcmp (oo->name, "tag") == 0) - tag = (const char *)oo->info; + tag = oo->info; if (tag == NULL || strcmp (tag, desc) != 0) continue; if (validf != NULL) @@ -2523,7 +3217,7 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, newname = xasprintf ("%s.%s.%s", name, fld->name, validf->name); write_root (f, v, validf->type, newname, 0, line, - if_marked); + if_marked, emit_pch); free (newname); } } @@ -2535,7 +3229,8 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, { char *newname; newname = xasprintf ("%s.%s", name, fld->name); - write_root (f, v, fld->type, newname, 0, line, if_marked); + write_root (f, v, fld->type, newname, 0, line, if_marked, + emit_pch); free (newname); } } @@ -2546,7 +3241,8 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, { char *newname; newname = xasprintf ("%s[0]", name); - write_root (f, v, type->u.a.p, newname, has_length, line, if_marked); + write_root (f, v, type->u.a.p, newname, has_length, line, if_marked, + emit_pch); free (newname); } break; @@ -2575,20 +3271,31 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, if (! has_length && UNION_OR_STRUCT_P (tp)) { oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag); - oprintf (f, " >_pch_nx_%s", tp->u.s.tag); + if (emit_pch) + oprintf (f, " >_pch_nx_%s", tp->u.s.tag); + else + oprintf (f, " NULL"); } else if (! has_length && tp->kind == TYPE_PARAM_STRUCT) { oprintf (f, " >_ggc_m_"); output_mangled_typename (f, tp); - oprintf (f, ",\n >_pch_n_"); - output_mangled_typename (f, tp); + if (emit_pch) + { + oprintf (f, ",\n >_pch_n_"); + output_mangled_typename (f, tp); + } + else + oprintf (f, ",\n NULL"); } else if (has_length && (tp->kind == TYPE_POINTER || UNION_OR_STRUCT_P (tp))) { oprintf (f, " >_ggc_ma_%s,\n", name); - oprintf (f, " >_pch_na_%s", name); + if (emit_pch) + oprintf (f, " >_pch_na_%s", name); + else + oprintf (f, " NULL"); } else { @@ -2608,7 +3315,7 @@ write_root (outf_p f, pair_p v, type_p type, const char *name, int has_length, oprintf (f, " &%s,\n", name); oprintf (f, " 1, \n"); oprintf (f, " sizeof (%s),\n", v->name); - oprintf (f, " >_ggc_m_S,\n"); + oprintf (f, " (gt_pointer_walker) >_ggc_m_S,\n"); oprintf (f, " (gt_pointer_walker) >_pch_n_S\n"); oprintf (f, " },\n"); } @@ -2638,7 +3345,7 @@ write_array (outf_p f, pair_p v, const struct write_types_data *wtd) d.indent = 2; d.line = &v->line; d.opt = v->opt; - d.bitmap = get_base_file_bitmap (v->line.file); + d.bitmap = get_lang_bitmap (v->line.file); d.param = NULL; d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name); @@ -2648,11 +3355,12 @@ write_array (outf_p f, pair_p v, const struct write_types_data *wtd) oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name); oprintf (f, " (void *, void *, gt_pointer_operator, void *);\n"); - oprintf (f, "static void gt_%sa_%s (void *this_obj ATTRIBUTE_UNUSED,\n", + oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n", wtd->param_prefix, v->name); - oprintf (d.of, " void *x_p ATTRIBUTE_UNUSED,\n"); - oprintf (d.of, " gt_pointer_operator op ATTRIBUTE_UNUSED,\n"); - oprintf (d.of, " void *cookie ATTRIBUTE_UNUSED)\n"); + oprintf (d.of, + " ATTRIBUTE_UNUSED void *x_p,\n" + " ATTRIBUTE_UNUSED gt_pointer_operator op,\n" + " ATTRIBUTE_UNUSED void * cookie)\n"); oprintf (d.of, "{\n"); d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name; d.process_field = write_types_local_process_field; @@ -2663,7 +3371,7 @@ write_array (outf_p f, pair_p v, const struct write_types_data *wtd) d.opt = v->opt; oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name); - oprintf (f, "static void\ngt_%sa_%s (void *x_p ATTRIBUTE_UNUSED)\n", + oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n", wtd->prefix, v->name); oprintf (f, "{\n"); d.prev_val[0] = d.prev_val[1] = d.prev_val[2] = d.val = v->name; @@ -2676,7 +3384,7 @@ write_array (outf_p f, pair_p v, const struct write_types_data *wtd) /* Output a table describing the locations and types of VARIABLES. */ static void -write_roots (pair_p variables) +write_roots (pair_p variables, bool emit_pch) { pair_p v; struct flist *flp = NULL; @@ -2691,7 +3399,7 @@ write_roots (pair_p variables) for (o = v->opt; o; o = o->next) if (strcmp (o->name, "length") == 0) - length = (const char *)o->info; + length = o->info; else if (strcmp (o->name, "deletable") == 0) deletable_p = 1; else if (strcmp (o->name, "param_is") == 0) @@ -2708,15 +3416,16 @@ write_roots (pair_p variables) v->name, o->name); for (fli = flp; fli; fli = fli->next) - if (fli->f == f) + if (fli->f == f && f) break; if (fli == NULL) { - fli = xmalloc (sizeof (*fli)); + fli = XNEW (struct flist); fli->f = f; fli->next = flp; fli->started_p = 0; fli->name = v->line.file; + gcc_assert(fli->name); flp = fli; oprintf (f, "\n/* GC roots. */\n\n"); @@ -2758,12 +3467,12 @@ write_roots (pair_p variables) { fli->started_p = 1; - oprintf (f, "const struct ggc_root_tab gt_ggc_r_"); + oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_r_"); put_mangled_filename (f, v->line.file); oprintf (f, "[] = {\n"); } - write_root (f, v, v->type, v->name, length_p, &v->line, NULL); + write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch); } finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab", @@ -2792,7 +3501,7 @@ write_roots (pair_p variables) { fli->started_p = 1; - oprintf (f, "const struct ggc_root_tab gt_ggc_rd_"); + oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_ggc_rd_"); put_mangled_filename (f, v->line.file); oprintf (f, "[] = {\n"); } @@ -2816,7 +3525,7 @@ write_roots (pair_p variables) if (strcmp (o->name, "length") == 0) length_p = 1; else if (strcmp (o->name, "if_marked") == 0) - if_marked = (const char *) o->info; + if_marked = o->info; if (if_marked == NULL) continue; @@ -2836,18 +3545,21 @@ write_roots (pair_p variables) { fli->started_p = 1; - oprintf (f, "const struct ggc_cache_tab gt_ggc_rc_"); + oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_"); put_mangled_filename (f, v->line.file); oprintf (f, "[] = {\n"); } write_root (f, v, v->type->u.p->u.param_struct.param[0], - v->name, length_p, &v->line, if_marked); + v->name, length_p, &v->line, if_marked, emit_pch); } finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab", "gt_ggc_cache_rtab"); + if (!emit_pch) + return; + for (v = variables; v; v = v->next) { outf_p f = get_output_file_with_visibility (v->line.file); @@ -2872,12 +3584,12 @@ write_roots (pair_p variables) { fli->started_p = 1; - oprintf (f, "const struct ggc_root_tab gt_pch_rc_"); + oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rc_"); put_mangled_filename (f, v->line.file); oprintf (f, "[] = {\n"); } - write_root (f, v, v->type, v->name, length_p, &v->line, NULL); + write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch); } finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab", @@ -2908,7 +3620,7 @@ write_roots (pair_p variables) { fli->started_p = 1; - oprintf (f, "const struct ggc_root_tab gt_pch_rs_"); + oprintf (f, "EXPORTED_CONST struct ggc_root_tab gt_pch_rs_"); put_mangled_filename (f, v->line.file); oprintf (f, "[] = {\n"); } @@ -2921,71 +3633,406 @@ write_roots (pair_p variables) "gt_pch_scalar_rtab"); } +/* Record the definition of a generic VEC structure, as if we had expanded + the macros in vec.h: + + typedef struct VEC__base GTY(()) { + unsigned num; + unsigned alloc; + GTY((length ("%h.num"))) vec[1]; + } VEC__base + + where the GTY(()) tags are only present if is_scalar is _false_. */ + +void +note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos) +{ + pair_p fields; + type_p t; + options_p o; + type_p len_ty = create_scalar_type ("unsigned"); + const char *name = concat ("VEC_", type_name, "_base", (char *)0); + + if (is_scalar) + { + t = create_scalar_type (type_name); + o = 0; + } + else + { + t = resolve_typedef (type_name, pos); + o = create_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); + fields = create_field_at (fields, len_ty, "num", 0, pos); + + do_typedef (name, new_structure (name, 0, pos, fields, 0), pos); +} + +/* Record the definition of an allocation-specific VEC structure, as if + we had expanded the macros in vec.h: + + typedef struct VEC__ { + VEC__base base; + } VEC__; +*/ +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); + + pair_p field = create_field_at (0, resolve_typedef (basename, pos), + "base", 0, pos); + + do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos); +} + +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); + +#define INDENT 2 + +/* Dumps the value of typekind KIND. */ + +static void +dump_typekind (int indent, enum typekind kind) +{ + 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 (); + } + printf ("\n"); +} + +/* Dumps the value of GC_USED flag. */ + +static void +dump_gc_used (int indent, enum gc_used_enum gc_used) +{ + 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 (); + } + printf ("\n"); +} + +/* Dumps the type options OPT. */ + +static void +dump_options (int indent, options_p opt) +{ + options_p o; + printf ("%*coptions = ", indent, ' '); + o = opt; + while (o) + { + printf ("%s:%s ", o->name, o->info); + o = o->next; + } + printf ("\n"); +} + +/* Dumps the source file location in LINE. */ + +static void +dump_fileloc (int indent, struct fileloc line) +{ + printf ("%*cfileloc: file = %s, line = %d\n", indent, ' ', line.file, + line.line); +} + +/* Recursively dumps the struct, union, or a language-specific + struct T. */ + +static void +dump_type_u_s (int indent, type_p t) +{ + pair_p fields; + + gcc_assert (t->kind == TYPE_STRUCT || t->kind == TYPE_UNION + || t->kind == TYPE_LANG_STRUCT); + printf ("%*cu.s.tag = %s\n", indent, ' ', t->u.s.tag); + dump_fileloc (indent, t->u.s.line); + printf ("%*cu.s.fields =\n", indent, ' '); + fields = t->u.s.fields; + while (fields) + { + 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); + printf ("%*cu.s.bitmap = %X\n", indent, ' ', t->u.s.bitmap); + if (t->kind == TYPE_LANG_STRUCT) + { + printf ("%*cu.s.lang_struct:\n", indent, ' '); + dump_type_list (indent + INDENT, t->u.s.lang_struct); + } +} + +/* Recursively dumps the array T. */ + +static void +dump_type_u_a (int indent, type_p t) +{ + gcc_assert (t->kind == TYPE_ARRAY); + printf ("%*clen = %s, u.a.p:\n", indent, ' ', t->u.a.len); + dump_type_list (indent + INDENT, t->u.a.p); +} + +/* Recursively dumps the parameterized struct T. */ + +static void +dump_type_u_param_struct (int indent, type_p t) +{ + int i; + gcc_assert (t->kind == TYPE_PARAM_STRUCT); + printf ("%*cu.param_struct.stru:\n", indent, ' '); + dump_type_list (indent, t->u.param_struct.stru); + dump_fileloc (indent, t->u.param_struct.line); + for (i = 0; i < NUM_PARAM; i++) + { + if (t->u.param_struct.param[i] == NULL) + continue; + printf ("%*cu.param_struct.param[%d]:\n", indent, ' ', i); + dump_type (indent + INDENT, t->u.param_struct.param[i]); + } +} + +/* Recursively dumps the type list T. */ + +static void +dump_type_list (int indent, type_p t) +{ + type_p p = t; + while (p) + { + dump_type (indent, p); + p = p->next; + } +} + +static htab_t seen_types; + +/* Recursively dumps the type T if it was not dumped previously. */ + +static void +dump_type (int indent, type_p t) +{ + PTR *slot; + + printf ("%*cType at %p: ", indent, ' ', (void *)t); + slot = htab_find_slot (seen_types, t, INSERT); + if (*slot != NULL) + { + printf ("already seen.\n"); + return; + } + *slot = t; + printf ("\n"); + + dump_typekind (indent, t->kind); + printf ("%*cpointer_to = %p\n", indent + INDENT, ' ', + (void *)t->pointer_to); + dump_gc_used (indent + INDENT, t->gc_used); + switch (t->kind) + { + case TYPE_SCALAR: + printf ("%*cscalar_is_char = %s\n", indent + INDENT, ' ', + t->u.scalar_is_char ? "true" : "false"); + break; + case TYPE_STRING: + break; + case TYPE_STRUCT: + case TYPE_UNION: + case TYPE_LANG_STRUCT: + dump_type_u_s (indent + INDENT, t); + break; + case TYPE_POINTER: + printf ("%*cp:\n", indent + INDENT, ' '); + dump_type (indent + INDENT, t->u.p); + break; + case TYPE_ARRAY: + dump_type_u_a (indent + INDENT, t); + break; + case TYPE_PARAM_STRUCT: + dump_type_u_param_struct (indent + INDENT, t); + break; + default: + gcc_unreachable (); + } + printf ("%*cEnd of type at %p\n", indent, ' ', (void *)t); +} + +/* Dumps the pair P. */ + +static void +dump_pair (int indent, pair_p p) +{ + printf ("%*cpair: name = %s\n", indent, ' ', p->name); + dump_type (indent, p->type); + dump_fileloc (indent, p->line); + dump_options (indent, p->opt); + printf ("%*cEnd of pair %s\n", indent, ' ', p->name); +} + +/* Dumps the list of pairs PP. */ + +static void +dump_pair_list (const char * name, pair_p pp) +{ + pair_p p; + printf ("%s:\n", name); + for (p = pp; p != NULL; p = p->next) + dump_pair (0, p); + printf ("End of %s\n\n", name); +} + +/* Dumps the STRUCTURES. */ + +static void +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. */ + +static void +dump_everything (void) +{ + seen_types = htab_create (100, htab_hash_pointer, htab_eq_pointer, NULL); + dump_pair_list ("typedefs", typedefs); + dump_structures ("structures", structures); + dump_structures ("param_structs", param_structs); + dump_pair_list ("variables", variables); + htab_delete (seen_types); +} + -extern int main (int argc, char **argv); int -main(int argc ATTRIBUTE_UNUSED, char **argv ATTRIBUTE_UNUSED) +main (int argc, char **argv) { - unsigned i; - static struct fileloc pos = { __FILE__, __LINE__ }; - unsigned j; + size_t i; + static struct fileloc pos = { this_file, 0 }; + char* inputlist = 0; + int do_dump = 0; + outf_p output_header; + char* plugin_output_filename = NULL; + /* fatal uses this */ + progname = "gengtype"; + + if (argc >= 2 && !strcmp (argv[1], "-d")) + { + do_dump = 1; + argv = &argv[1]; + argc--; + } - gen_rtx_next (); + if (argc >= 6 && !strcmp (argv[1], "-P")) + { + 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); + } + } + else if (argc == 3) + { + srcdir = argv[1]; + inputlist = argv[2]; + } + else + fatal ("usage: gengtype [-d] [-P pluginout.h] srcdir input-list " + "[file1 file2 ... fileN]"); srcdir_len = strlen (srcdir); - do_scalar_typedef ("CUMULATIVE_ARGS", &pos); - do_scalar_typedef ("REAL_VALUE_TYPE", &pos); - do_scalar_typedef ("uint8", &pos); - do_scalar_typedef ("jword", &pos); - do_scalar_typedef ("JCF_u2", &pos); -#ifdef USE_MAPPED_LOCATION - do_scalar_typedef ("location_t", &pos); - do_scalar_typedef ("source_locus", &pos); -#endif - do_scalar_typedef ("void", &pos); + read_input_list (inputlist); + 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); - do_typedef ("HARD_REG_SET", create_array ( - create_scalar_type ("unsigned long", strlen ("unsigned long")), - "2"), &pos); - - for (i = 0; i < NUM_GT_FILES; i++) - { - int dupflag = 0; - /* Omit if already seen. */ - for (j = 0; j < i; j++) - { - if (!strcmp (all_files[i], all_files[j])) - { - dupflag = 1; - break; - } - } - if (!dupflag) - parse_file (all_files[i]); -#ifndef USE_MAPPED_LOCATION - /* temporary kludge - gengtype doesn't handle conditionals. - Manually add source_locus *after* we've processed input.h. */ - if (i == 0) - do_typedef ("source_locus", create_pointer (resolve_typedef ("location_t", &pos)), &pos); -#endif - } - - if (hit_error != 0) - exit (1); + for (i = 0; i < num_gt_files; i++) + parse_file (gt_files[i]); + + if (hit_error) + return 1; set_gc_used (variables); open_base_files (); write_enum_defn (structures, param_structs); - write_types (structures, param_structs, &ggc_wtd); - write_types (structures, param_structs, &pch_wtd); - write_local (structures, param_structs); - write_roots (variables); + output_header = plugin_output ? plugin_output : header_file; + write_types (output_header, structures, param_structs, &ggc_wtd); + if (plugin_files == NULL) + { + write_types (header_file, structures, param_structs, &pch_wtd); + write_local (header_file, structures, param_structs); + } + write_roots (variables, plugin_files == NULL); write_rtx_next (); close_output_files (); - return (hit_error != 0); + 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); + } + + if (hit_error) + return 1; + return 0; }