/* Process source files and output type information.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
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, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA. */
+ You should have received a copy of the GNU General Public License
+ along with GCC; see the file COPYING3. If not see
+ <http://www.gnu.org/licenses/>. */
#include "bconfig.h"
#include "system.h"
#include "gengtype.h"
-#include "gtyp-gen.h"
#include "errors.h" /* for fatal */
+#include "double-int.h"
+
+/* Data types, macros, etc. used only in this file. */
+
+/* Kinds of types we can understand. */
+enum typekind {
+ TYPE_SCALAR,
+ TYPE_STRING,
+ TYPE_STRUCT,
+ TYPE_UNION,
+ TYPE_POINTER,
+ TYPE_ARRAY,
+ TYPE_LANG_STRUCT,
+ TYPE_PARAM_STRUCT
+};
+
+typedef unsigned lang_bitmap;
+
+/* A way to pass data through to the output end. */
+struct options
+{
+ struct options *next;
+ const char *name;
+ const char *info;
+};
+
+/* Option data for the 'nested_ptr' option. */
+struct nested_ptr_data
+{
+ type_p type;
+ const char *convert_to;
+ const char *convert_from;
+};
+
+/* A name and a type. */
+struct pair
+{
+ pair_p next;
+ const char *name;
+ type_p type;
+ struct fileloc line;
+ options_p opt;
+};
+
+#define NUM_PARAM 10
+
+/* A description of a type. */
+enum gc_used_enum
+ {
+ GC_UNUSED = 0,
+ GC_USED,
+ 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. */
+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. */
+static void oprintf (outf_p o, const char *S, ...)
+ ATTRIBUTE_PRINTF_2;
+
+/* 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;
+/* 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 *);
+
+\f
/* 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);
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;
}
+\f
+/* 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_<lang>' set iff
+ INPUT_FILE is used by <lang>.
+
+ This function should be written to assume that a file _is_ used
+ if the situation is unclear. If it wrongly assumes a file _is_ used,
+ a linker error will result. If it wrongly assumes a file _is not_ used,
+ some GC roots may be missed, which is a much harder-to-debug problem.
+
+ The relevant bitmap is stored immediately before the file's name in the
+ buffer set up by read_input_list. It may be unaligned, so we have to
+ read it byte-by-byte. */
+
+static lang_bitmap
+get_lang_bitmap (const char *gtfile)
+{
+
+ if (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 = 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;
+ 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);
+}
+
+\f
/* The one and only TYPE_STRING. */
static struct type string_type = {
{
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)
{
{
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
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");
}
if (s->u.s.lang_struct)
s->u.s.lang_struct->u.s.bitmap |= bitmap;
- return s;
+ /* 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
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'. */
variables = n;
}
-/* Create a fake field with the given type and name. NEXT is the next
- field in the chain. */
-
+/* Most-general structure field creator. */
static pair_p
-create_field (pair_p next, type_p type, const char *name)
+create_field_all (pair_p next, type_p type, const char *name, options_p opt,
+ const char *file, int line)
{
pair_p field;
field->next = next;
field->type = type;
field->name = name;
- field->opt = NULL;
- field->line.file = __FILE__;
- field->line.line = __LINE__;
+ 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)
+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, field;
+ pair_p union_fields;
type_p union_type;
/* Create a fake union type with a single nameless field of type TYPE.
/* 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. */
- field = create_field (next, union_type, name);
- field->opt = create_option (field->opt, "desc", cond);
- return field;
+ 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;
+}
+
+\f
/* We don't care how long a CONST_DOUBLE is. */
#define CONST_DOUBLE_FORMAT "ww"
/* We don't want to see codes that are only for generator files. */
switch (c)
{
case NOTE_INSN_MAX:
+ case NOTE_INSN_DELETED_LABEL:
note_flds = create_field (note_flds, &string_type, "rt_str");
break;
case '0':
if (i == MEM && aindex == 1)
t = mem_attrs_tp, subname = "rt_mem";
- else if (i == JUMP_INSN && aindex == 9)
+ else if (i == JUMP_INSN && aindex == 8)
t = rtx_tp, subname = "rt_rtx";
else if (i == CODE_LABEL && aindex == 4)
t = scalar_tp, subname = "rt_int";
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 = "rt_int";
else if (i == ADDR_DIFF_VEC && aindex == 4)
subfields->opt = nodot;
if (t == note_union_tp)
subfields->opt = create_option (subfields->opt, "desc",
- "NOTE_LINE_NUMBER (&%0)");
+ "NOTE_KIND (&%0)");
if (t == symbol_union_tp)
subfields->opt = create_option (subfields->opt, "desc",
"CONSTANT_POOL_ADDRESS_P (&%0)");
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)
{
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)
(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. */
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 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",
"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, 51 Franklin Street, Fifth Floor, Boston, MA\n",
- "02110-1301, USA. */\n",
+ "along with GCC; see the file COPYING3. If not see\n",
+ "<http://www.gnu.org/licenses/>. */\n",
"\n",
"/* This file is machine generated. Do not edit. */\n"
};
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, ...)
{
va_list ap;
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)
{
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. */
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]));
"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", NULL
+ "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h", NULL
};
const char *const *ifp;
outf_p gtype_desc_c;
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 && IS_DIR_SEPARATOR (s1[-1]) && !memcmp (s1, s2, l2))
- {
- basename -= l2 + 1;
- if ((basename - f - 1) != srcdir_len)
- fatal ("filename `%s' should be preceded by $srcdir", f);
- 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_<lang>' set iff
- INPUT_FILE is used by <lang>.
-
- This function should be written to assume that a file _is_ used
- if the situation is unclear. If it wrongly assumes a file _is_ used,
- a linker error will result. If it wrongly assumes a file _is not_ used,
- some GC roots may be missed, which is a much harder-to-debug problem. */
+/* For F a filename, return the name of language directory where F is located,
+ if any, NULL otherwise. */
-unsigned
-get_base_file_bitmap (const char *input_file)
+static const char *
+get_file_langdir (const char *f)
{
- const char *basename = get_file_basename (input_file);
- const char *slashpos = strchr (basename, '/');
- unsigned j;
- unsigned k;
- unsigned bitmap;
+ /* 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. */
- /* If the file resides in a language subdirectory (e.g., 'cp'), assume that
- it belongs to the corresponding language. The file may belong to other
- languages as well (which is checked for below). */
+ int lang_index;
+ const char * srcdir_relative_path = get_file_srcdir_relative_path (f);
- 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;
- }
- }
+ if (!srcdir_relative_path)
+ return NULL;
- /* If it's in any config-lang.in, then set for the languages
- specified. */
+ lang_index = get_prefix_langdir_index (srcdir_relative_path);
- bitmap = 0;
+ return (lang_index >= 0) ? lang_dir_names [lang_index] : NULL;
+}
- 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);
- }
- }
- }
+/* The gt- output file name for F. */
+
+static const char *
+get_file_gtfilename (const char *f)
+{
+ /* Cook up an initial version of the gt- file name from the file real
+ basename and the language name, if any. */
- /* Otherwise, set all languages. */
- if (!bitmap)
- bitmap = (1 << NUM_BASE_FILES) - 1;
+ const char *basename = get_file_realbasename (f);
+ const char *langdir = get_file_langdir (f);
+
+ char * result =
+ (langdir ? xasprintf ("gt-%s-%s", langdir, basename)
+ : xasprintf ("gt-%s", basename));
- return bitmap;
+ /* Then replace all non alphanumerics characters by '-' and change the
+ extenstion to ".h". We expect the input filename extension was at least
+ one character long. */
+
+ char *s = result;
+
+ for (; *s != '.'; s++)
+ if (! ISALNUM (*s) && *s != '-')
+ *s = '-';
+
+ memcpy (s, ".h", sizeof (".h"));
+
+ return result;
}
/* An output file, suitable for definitions, that can see declarations
|| (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
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;
newfile = fopen (of->name, "w");
if (newfile == NULL)
- {
- perror ("opening output file");
- exit (1);
- }
+ fatal ("opening output file %s: %s", of->name, strerror (errno));
if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
- {
- perror ("writing output file");
- exit (1);
- }
+ fatal ("writing output file %s: %s", of->name, strerror (errno));
if (fclose (newfile) != 0)
- {
- perror ("closing output file");
- exit (1);
- }
+ fatal ("closing output file %s: %s", of->name, strerror (errno));
}
}
\f
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,
/* 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");
;
else if (strcmp (oo->name, "chain_prev") == 0)
;
+ else if (strcmp (oo->name, "chain_circular") == 0)
+ ;
else if (strcmp (oo->name, "reorder") == 0)
;
else
break;
case TYPE_STRING:
- if (wtd->param_prefix == NULL)
- break;
-
case TYPE_STRUCT:
case TYPE_UNION:
case TYPE_LANG_STRUCT:
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;
chain_next = opt->info;
else if (strcmp (opt->name, "chain_prev") == 0)
chain_prev = opt->info;
+ else if (strcmp (opt->name, "chain_circular") == 0)
+ chain_circular = opt->info;
else if (strcmp (opt->name, "mark_hook") == 0)
mark_hook_name = opt->info;
if (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;
}
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_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, ");\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, " }\n");
+ if (chain_circular != NULL)
+ oprintf (d.of, " while (x != xlimit);\n");
oprintf (d.of, "}\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)
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)
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;
for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
{
size_t fnum;
- for (fnum = 0; fnum < NUM_BASE_FILES; fnum++)
+ for (fnum = 0; fnum < num_lang_dirs; fnum++)
oprintf (base_files [fnum],
"const struct %s * const %s[] = {\n",
tname, name);
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;
{
size_t fnum;
- for (fnum = 0; fnum < NUM_BASE_FILES; fnum++)
+ for (fnum = 0; fnum < num_lang_dirs; fnum++)
{
oprintf (base_files[fnum], " NULL\n");
oprintf (base_files[fnum], "};\n");
skip_p = 1;
else if (strcmp (o->name, "desc") == 0)
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'",
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");
}
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);
where the GTY(()) tags are only present if is_scalar is _false_. */
void
-note_def_vec (const char *typename, bool is_scalar, struct fileloc *pos)
+note_def_vec (const char *type_name, bool is_scalar, struct fileloc *pos)
{
- pair_p f, fields;
+ pair_p fields;
type_p t;
options_p o;
- const char *name = concat ("VEC_", typename, "_base", (char *)0);
+ 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 (typename);
+ t = create_scalar_type (type_name);
o = 0;
}
else
{
- t = resolve_typedef (typename, pos);
+ t = resolve_typedef (type_name, pos);
o = create_option (0, "length", "%h.num");
}
/* We assemble the field list in reverse order. */
- f = XNEW (struct pair);
- f->type = adjust_field_type (create_array (t, "1"), o);
- f->name = "vec";
- f->opt = o;
- f->line = *pos;
- f->next = 0;
- fields = f;
-
- f = XNEW (struct pair);
- f->type = adjust_field_type (create_scalar_type ("unsigned"), 0);
- f->name = "alloc";
- f->opt = 0;
- f->line = *pos;
- f->next = fields;
- fields = f;
-
- f = XNEW (struct pair);
- f->type = adjust_field_type (create_scalar_type ("unsigned"), 0);
- f->name = "num";
- f->opt = 0;
- f->line = *pos;
- f->next = fields;
- fields = f;
+ 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);
}
const char *astratname = concat ("VEC_", type, "_", astrat, (char *)0);
const char *basename = concat ("VEC_", type, "_base", (char *)0);
- pair_p field = XNEW (struct pair);
- field->name = "base";
- field->type = adjust_field_type (resolve_typedef (basename, pos), 0);
- field->line = *pos;
- field->next = 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);
}
\f
-extern int main (int argc, char **argv);
int
-main (int ARG_UNUSED (argc), char ** ARG_UNUSED (argv))
+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 };
+ /* fatal uses this */
+ progname = "gengtype";
+
+ if (argc != 3)
+ fatal ("usage: gengtype srcdir input-list");
+
+ srcdir = argv[1];
srcdir_len = strlen (srcdir);
+ read_input_list (argv[2]);
+ if (hit_error)
+ return 1;
+
scalar_char.u.scalar_is_char = true;
scalar_nonchar.u.scalar_is_char = false;
-
gen_rtx_next ();
- do_scalar_typedef ("CUMULATIVE_ARGS", &pos);
- do_scalar_typedef ("REAL_VALUE_TYPE", &pos);
- do_scalar_typedef ("double_int", &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);
-
+ /* 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 ("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 (&scalar_nonchar, "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
- }
+ for (i = 0; i < num_gt_files; i++)
+ parse_file (gt_files[i]);
- if (hit_error != 0)
- exit (1);
+ if (hit_error)
+ return 1;
set_gc_used (variables);
write_rtx_next ();
close_output_files ();
- return (hit_error != 0);
+ if (hit_error)
+ return 1;
+ return 0;
}
OSDN Git Service
