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;
}