/* Process source files and output type information.
- Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008
+ Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
Free Software Foundation, Inc.
This file is part of GCC.
#include "bconfig.h"
#include "system.h"
-#include "gengtype.h"
-#include "errors.h" /* for fatal */
+#include "errors.h" /* for fatal */
+#include "getopt.h"
#include "double-int.h"
+#include "version.h" /* for version_string & pkgversion_string. */
+#include "hashtab.h"
+#include "gengtype.h"
/* Data types, macros, etc. used only in this file. */
/* Kinds of types we can understand. */
-enum typekind {
+enum typekind
+{
TYPE_SCALAR,
TYPE_STRING,
TYPE_STRUCT,
TYPE_PARAM_STRUCT
};
-typedef unsigned lang_bitmap;
/* A way to pass data through to the output end. */
struct options
/* A description of a type. */
enum gc_used_enum
- {
- GC_UNUSED = 0,
- GC_USED,
- GC_MAYBE_POINTED_TO,
- GC_POINTED_TO
- };
+{
+ 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
{
type_p next;
type_p pointer_to;
enum gc_used_enum gc_used;
- union {
+ union
+ {
type_p p;
- struct {
+ struct
+ {
const char *tag;
struct fileloc line;
pair_p fields;
type_p lang_struct;
} s;
bool scalar_is_char;
- struct {
+ struct
+ {
type_p p;
const char *len;
} a;
- struct {
+ struct
+ {
type_p stru;
type_p param[NUM_PARAM];
struct fileloc line;
|| (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;
+outf_p output_files;
/* The output header file that is included into pretty much every
source file. */
-static outf_p header_file;
+outf_p header_file;
+
+
+/* The name of the file containing the list of input files. */
+static char *inputlist;
-/* Source directory. */
-static const char *srcdir;
+/* 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;
-/* Length of srcdir name. */
-static size_t srcdir_len = 0;
+/* The generated plugin output file and name. */
+static outf_p plugin_output;
+static char *plugin_output_filename;
+
+/* Our source directory and its length. */
+const char *srcdir;
+size_t srcdir_len;
+
+/* Variables used for reading and writing the state. */
+const char *read_state_filename;
+const char *write_state_filename;
+
+/* Variables to help debugging. */
+int do_dump;
+int do_debug;
static outf_p create_file (const char *, const char *);
-static const char * get_file_basename (const char *);
-static const char * get_file_realbasename (const char *);
-static const char * get_file_srcdir_relative_path (const char *);
+static const char *get_file_basename (const 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 *);
-
+static const char *get_file_langdir (const char *);
\f
+
/* Nonzero iff an error has occurred. */
bool hit_error = false;
/* 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;
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__;
+/* A number of places use the name of this "gengtype.h" 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. */
+const char this_file[] = __FILE__;
+/* The "system.h" file is likewise specially useful. */
+const char system_h_file[] = "system.h";
/* Vector of per-language directories. */
static const char **lang_dir_names;
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;
+ if (gtfile == this_file || gtfile == system_h_file)
+ {
+ /* Things defined in this "gengtype.c" file or in "system.h" are
+ universal (and there is no space for their lang_bitmap before
+ their file names). */
+ 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];
+ n = (n << CHAR_BIT) + (unsigned char) gtfile[i];
return n;
}
}
int i;
for (i = -1; i >= -(int) sizeof (lang_bitmap); i--)
{
- gtfile[i] = n & ((1U << CHAR_BIT)-1);
+ gtfile[i] = n & ((1U << CHAR_BIT) - 1);
n >>= CHAR_BIT;
}
}
+
+#if ENABLE_CHECKING
+/* Utility debugging function, printing the various type counts within
+ a list of types. Called thru the DBGPRINT_COUNT_TYPE macro. */
+void
+dbgprint_count_type_at (const char *fil, int lin, const char *msg, type_p t)
+{
+ int nb_types = 0, nb_scalar = 0, nb_string = 0;
+ int nb_struct = 0, nb_union = 0, nb_array = 0, nb_pointer = 0;
+ int nb_lang_struct = 0, nb_param_struct = 0;
+ type_p p = NULL;
+ for (p = t; p; p = p->next)
+ {
+ nb_types++;
+ switch (p->kind)
+ {
+ case TYPE_SCALAR:
+ nb_scalar++;
+ break;
+ case TYPE_STRING:
+ nb_string++;
+ break;
+ case TYPE_STRUCT:
+ nb_struct++;
+ break;
+ case TYPE_UNION:
+ nb_union++;
+ break;
+ case TYPE_POINTER:
+ nb_pointer++;
+ break;
+ case TYPE_ARRAY:
+ nb_array++;
+ break;
+ case TYPE_LANG_STRUCT:
+ nb_lang_struct++;
+ break;
+ case TYPE_PARAM_STRUCT:
+ nb_param_struct++;
+ break;
+ default:
+ gcc_unreachable ();
+ }
+ }
+ fprintf (stderr, "\n" "%s:%d: %s: @@%%@@ %d types ::\n",
+ lbasename (fil), lin, msg, nb_types);
+ if (nb_scalar > 0 || nb_string > 0)
+ fprintf (stderr, "@@%%@@ %d scalars, %d strings\n", nb_scalar, nb_string);
+ if (nb_struct > 0 || nb_union > 0)
+ fprintf (stderr, "@@%%@@ %d structs, %d unions\n", nb_struct, nb_union);
+ if (nb_pointer > 0 || nb_array > 0)
+ fprintf (stderr, "@@%%@@ %d pointers, %d arrays\n", nb_pointer, nb_array);
+ if (nb_lang_struct > 0 || nb_param_struct > 0)
+ fprintf (stderr, "@@%%@@ %d lang_structs, %d param_structs\n",
+ nb_lang_struct, nb_param_struct);
+ fprintf (stderr, "\n");
+}
+#endif /* ENABLE_CHECKING */
+
/* Scan the input file, LIST, and determine how much space we need to
store strings in. Also, count the number of language directories
and files. The numbers returned are overestimates as they does not
int c;
bool atbol = true;
num_lang_dirs = 0;
- num_gt_files = 0;
+ num_gt_files = plugin_files ? nb_plugin_files : 0;
while ((c = getc (list)) != EOF)
{
n++;
touch *HEREP, and sets *LINEP to NULL. POS is used for
diagnostics. */
static bool
-read_input_line (FILE *list, char **herep, char **linep,
- struct fileloc *pos)
+read_input_line (FILE *list, char **herep, char **linep, struct fileloc *pos)
{
char *here = *herep;
char *line;
int c = getc (list);
+ /* Read over whitespace. */
+ while (c == '\n' || c == ' ')
+ c = getc (list);
+
if (c == EOF)
{
*linep = 0;
if (c == ']')
{
- c = getc (list); /* eat what should be a newline */
+ c = getc (list); /* eat what should be a newline */
if (c != '\n' && c != EOF)
error_at_line (pos, "junk on line after language tag [%s]", line);
}
else
- error_at_line (pos, "missing close bracket for language tag [%s", line);
+ error_at_line (pos, "missing close bracket for language tag [%s",
+ line);
*herep = here;
*linep = line;
{
FILE *list = fopen (listname, "r");
if (!list)
- fatal ("cannot open %s: %s", listname, strerror (errno));
+ fatal ("cannot open %s: %s", listname, xstrerror (errno));
else
{
struct fileloc epos;
for (i = 0; i < langno; i++)
if (strcmp (lang_dir_names[i], line) == 0)
{
- error_at_line (&epos, "duplicate language tag [%s]", line);
+ error_at_line (&epos, "duplicate language tag [%s]",
+ line);
curlangs = 1 << i;
here = committed;
goto next_line;
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]);
+ error_at_line (&epos,
+ "file %s specified more than once "
+ "for language %s", line,
+ langno ==
+ 0 ? "(all)" : lang_dir_names[langno -
+ 1]);
bmap |= curlangs;
- set_lang_bitmap (CONST_CAST(char *, gt_files[i]), bmap);
+ set_lang_bitmap (CONST_CAST (char *, gt_files[i]), bmap);
here = committed;
goto next_line;
}
}
}
/* Update the global counts now that we know accurately how many
- things there are. (We do not bother resizing the arrays down.) */
+ things there are. (We do not bother resizing the arrays down.) */
num_lang_dirs = langno;
+ /* Add the plugin files if provided. */
+ if (plugin_files)
+ {
+ size_t i;
+ for (i = 0; i < nb_plugin_files; i++)
+ gt_files[nfiles++] = plugin_files[i];
+ }
num_gt_files = nfiles;
}
{
size_t l;
for (l = 0; l < num_lang_dirs; l++)
- if ((size_t)(slashpos - basename) == strlen (lang_dir_names [l])
+ if ((size_t) (slashpos - basename) == strlen (lang_dir_names[l])
&& memcmp (basename, lang_dir_names[l],
strlen (lang_dir_names[l])) == 0)
{
basename, lang_dir_names[l]);
break;
}
- }
+ }
}
}
if (ferror (list))
- fatal ("error reading %s: %s", listname, strerror (errno));
+ fatal ("error reading %s: %s", listname, xstrerror (errno));
fclose (list);
}
+\f
-\f
/* The one and only TYPE_STRING. */
static struct type string_type = {
static struct type scalar_nonchar = {
TYPE_SCALAR, 0, 0, GC_USED, {0}
};
+
static struct type scalar_char = {
TYPE_SCALAR, 0, 0, GC_USED, {0}
};
static type_p param_structs;
static pair_p variables;
-static type_p find_param_structure
- (type_p t, type_p param[NUM_PARAM]);
+static type_p find_param_structure (type_p t, type_p param[NUM_PARAM]);
static type_p adjust_field_tree_exp (type_p t, options_p opt);
static type_p adjust_field_rtx_def (type_p t, options_p opt);
p->name = s;
p->type = t;
p->line = *pos;
+ p->opt = NULL;
typedefs = p;
}
if (strcmp (p->name, s) == 0)
return p->type;
error_at_line (pos, "unidentified type `%s'", s);
- return &scalar_nonchar; /* treat as "int" */
+ return &scalar_nonchar; /* treat as "int" */
}
/* Create and return a new structure with tag NAME (or a union iff
/* 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)
+ if (!strcmp (name, "location_s") && !isunion && pos->file != this_file)
return find_structure (name, 0);
for (si = structures; si != NULL; si = si->next)
- if (strcmp (name, si->u.s.tag) == 0
- && UNION_P (si) == isunion)
+ if (strcmp (name, si->u.s.tag) == 0 && UNION_P (si) == isunion)
{
type_p ls = NULL;
if (si->kind == TYPE_LANG_STRUCT)
/* 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)
+ if (!strcmp (name, "location_s") && !isunion && pos->file == this_file)
{
size_t n;
for (n = 0; n < num_gt_files; n++)
}
}
- return s;
+ return s;
}
/* Return the previously-defined structure with tag NAME (or a union
type_p s;
for (s = structures; s != NULL; s = s->next)
- if (strcmp (name, s->u.s.tag) == 0
- && UNION_P (s) == isunion)
+ if (strcmp (name, s->u.s.tag) == 0 && UNION_P (s) == isunion)
return s;
s = XCNEW (struct type);
type_p
create_pointer (type_p t)
{
- if (! t->pointer_to)
+ if (!t->pointer_to)
{
type_p r = XCNEW (struct type);
r->kind = TYPE_POINTER;
options_p o = XNEW (struct options);
o->next = next;
o->name = name;
- o->info = (const char*) info;
+ o->info = (const char *) info;
return o;
}
/* 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);
+ create_option (0, "desc", cond), this_file, line);
}
+
#define create_optional_field(next,type,name,cond) \
create_optional_field_(next,type,name,cond,__LINE__)
}
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. */
#undef GENERATOR_FILE
-enum rtx_code {
+enum rtx_code
+{
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) ENUM ,
#include "rtl.def"
#undef DEF_RTL_EXPR
NUM_RTX_CODE
};
-static const char * const rtx_name[NUM_RTX_CODE] = {
+static const char *const rtx_name[NUM_RTX_CODE] = {
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) NAME ,
#include "rtl.def"
#undef DEF_RTL_EXPR
};
-static const char * const rtx_format[NUM_RTX_CODE] = {
+static const char *const rtx_format[NUM_RTX_CODE] = {
#define DEF_RTL_EXPR(ENUM, NAME, FORMAT, CLASS) FORMAT ,
#include "rtl.def"
#undef DEF_RTL_EXPR
/* We also need codes and names for insn notes (not register notes).
Note that we do *not* bias the note values here. */
-enum insn_note {
+enum insn_note
+{
#define DEF_INSN_NOTE(NAME) NAME,
#include "insn-notes.def"
#undef DEF_INSN_NOTE
/* We must allocate one more entry here, as we use NOTE_INSN_MAX as the
default field for line number notes. */
-static const char *const note_insn_name[NOTE_INSN_MAX+1] = {
+static const char *const note_insn_name[NOTE_INSN_MAX + 1] = {
#define DEF_INSN_NOTE(NAME) #NAME,
#include "insn-notes.def"
#undef DEF_INSN_NOTE
{
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");
else
oprintf (f,
- " RTX_HDR_SIZE + %d * sizeof (rtunion),\n",
- rtx_next_new[i]);
+ " RTX_HDR_SIZE + %d * sizeof (rtunion),\n", rtx_next_new[i]);
oprintf (f, "};\n");
}
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, constant_tp, symbol_union_tp;
+ type_p basic_block_tp, reg_attrs_tp, constant_tp, symbol_union_tp;
if (t->kind != TYPE_UNION)
{
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));
- constant_tp = create_pointer (find_structure ("constant_descriptor_rtx", 0));
- scalar_tp = &scalar_nonchar; /* rtunion int */
+ constant_tp =
+ create_pointer (find_structure ("constant_descriptor_rtx", 0));
+ scalar_tp = &scalar_nonchar; /* rtunion int */
{
pair_p note_flds = NULL;
switch (c)
{
case NOTE_INSN_MAX:
+ case NOTE_INSN_DELETED_LABEL:
note_flds = create_field (note_flds, &string_type, "rt_str");
break;
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 = "rt_int";
else if (i == CODE_LABEL && aindex == 5)
+ t = scalar_tp, subname = "rt_int";
+ else if (i == CODE_LABEL && aindex == 4)
t = rtx_tp, subname = "rt_rtx";
- else if (i == LABEL_REF
- && (aindex == 1 || aindex == 2))
+ else if (i == LABEL_REF && (aindex == 1 || aindex == 2))
t = rtx_tp, subname = "rt_rtx";
else if (i == NOTE && aindex == 4)
t = note_union_tp, subname = "";
t = scalar_tp, subname = "rt_int";
else if (i == VALUE && aindex == 0)
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 = "rt_int";
else if (i == REG && aindex == 2)
else
{
error_at_line (&lexer_line,
- "rtx type `%s' has `0' in position %lu, can't handle",
+ "rtx type `%s' has `0' in position %lu, can't handle",
rtx_name[i], (unsigned long) aindex);
t = &string_type;
subname = "rt_int";
subname = "rt_tree";
break;
- case 'b':
- t = bitmap_tp;
- subname = "rt_bit";
- break;
-
case 'B':
t = basic_block_tp;
subname = "rt_bb";
default:
error_at_line (&lexer_line,
- "rtx type `%s' has `%c' in position %lu, can't handle",
+ "rtx type `%s' has `%c' in position %lu, can't handle",
rtx_name[i], rtx_format[i][aindex],
- (unsigned long)aindex);
+ (unsigned long) aindex);
t = &string_type;
subname = "rt_int";
break;
{
int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
- if (! UNION_OR_STRUCT_P (t)
- && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
+ if (!UNION_OR_STRUCT_P (t)
+ && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p)))
{
error_at_line (&lexer_line,
- "option `%s' may only be applied to structures or structure pointers",
+ "option `%s' may only be applied to structures or structure pointers",
opt->name);
return t;
}
params_p = 1;
if (params[num] != NULL)
error_at_line (&lexer_line, "duplicate `%s' option", opt->name);
- if (! ISDIGIT (opt->name[5]))
- params[num] = create_pointer (CONST_CAST2(type_p, const char *, opt->info));
+ if (!ISDIGIT (opt->name[5]))
+ params[num] =
+ create_pointer (CONST_CAST2 (type_p, const char *, opt->info));
else
params[num] = CONST_CAST2 (type_p, const char *, opt->info);
}
t = pointer_p ? create_pointer (realt) : realt;
}
- if (! length_p
- && pointer_p
- && t->u.p->kind == TYPE_SCALAR
- && t->u.p->u.scalar_is_char)
+ if (!length_p
+ && pointer_p && t->u.p->kind == TYPE_SCALAR && t->u.p->u.scalar_is_char)
return &string_type;
if (t->kind == TYPE_ARRAY && t->u.a.p->kind == TYPE_POINTER
&& t->u.a.p->u.p->kind == TYPE_SCALAR
return t;
}
-
\f
+
static void set_gc_used_type (type_p, enum gc_used_enum, type_p *);
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, int *skip, type_p *nested_ptr)
+ int *pass_param, int *length, int *skip,
+ type_p *nested_ptr)
{
options_p o;
for (o = opt; o; o = o->next)
&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);
set_gc_used_type (find_param_structure (f->type->u.p, param),
GC_POINTED_TO, NULL);
else if (skip)
- ; /* target type is not used through this field */
+ ; /* target type is not used through this field */
else
set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL);
}
create_file (const char *name, const char *oname)
{
static const char *const hdr[] = {
- " Copyright (C) 2004, 2007 Free Software Foundation, Inc.\n",
+ " Copyright (C) 2004, 2007, 2009 Free Software Foundation, Inc.\n",
"\n",
"This file is part of GCC.\n",
"\n",
outf_p f;
size_t i;
+ gcc_assert (name != NULL);
+ gcc_assert (oname != NULL);
f = XCNEW (struct outf);
f->next = output_files;
f->name = 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
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 = vasprintf (&s, format, ap);
- if (s == NULL || (int)slength < 0)
+ if (s == NULL || (int) slength < 0)
fatal ("out of memory");
va_end (ap);
size_t new_len = o->buflength;
if (new_len == 0)
new_len = 1024;
- do {
- new_len *= 2;
- } while (o->bufused + slength >= new_len);
+ do
+ {
+ new_len *= 2;
+ }
+ while (o->bufused + slength >= new_len);
o->buf = XRESIZEVEC (char, o->buf, new_len);
o->buflength = new_len;
}
{
size_t i;
+ if (nb_plugin_files > 0 && plugin_files)
+ return;
+
header_file = create_file ("GCC", "gtype-desc.h");
base_files = XNEWVEC (outf_p, num_lang_dirs);
/* gtype-desc.c is a little special, so we create it here. */
{
/* The order of files here matters very much. */
- static const char *const ifiles [] = {
- "config.h", "system.h", "coretypes.h", "tm.h", "varray.h",
- "hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
+ static const char *const ifiles[] = {
+ "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", "cfgloop.h", NULL
+ "cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
+ "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", NULL
};
const char *const *ifp;
outf_p gtype_desc_c;
static const char *
get_file_realbasename (const char *f)
{
- const char * lastslash = strrchr (f, '/');
-
+ const char *lastslash = strrchr (f, '/');
+
return (lastslash != NULL) ? lastslash + 1 : f;
}
static const char *
get_file_basename (const char *f)
{
- const char * srcdir_path = get_file_srcdir_relative_path (f);
+ const char *srcdir_path = get_file_srcdir_relative_path (f);
return (srcdir_path != NULL) ? srcdir_path : get_file_realbasename (f);
}
for (lang_index = 0; lang_index < num_lang_dirs; lang_index++)
{
- const char * langdir = lang_dir_names [lang_index];
+ const char *langdir = lang_dir_names[lang_index];
size_t langdir_len = strlen (langdir);
-
+
if (f_len > langdir_len
&& IS_DIR_SEPARATOR (f[langdir_len])
&& memcmp (f, langdir, langdir_len) == 0)
srcdir relative, no point in looking further. */
int lang_index;
- const char * srcdir_relative_path = get_file_srcdir_relative_path (f);
+ const char *srcdir_relative_path = get_file_srcdir_relative_path (f);
+ const char *r;
if (!srcdir_relative_path)
return NULL;
lang_index = get_prefix_langdir_index (srcdir_relative_path);
+ if (lang_index < 0 && strncmp (srcdir_relative_path, "c-family", 8) == 0)
+ r = "c-family";
+ else if (lang_index >= 0)
+ r = lang_dir_names[lang_index];
+ else
+ r = NULL;
- return (lang_index >= 0) ? lang_dir_names [lang_index] : NULL;
+ return r;
}
/* The gt- output file name for F. */
const char *basename = get_file_realbasename (f);
const char *langdir = get_file_langdir (f);
-
- char * result =
+
+ char *result =
(langdir ? xasprintf ("gt-%s-%s", langdir, basename)
: xasprintf ("gt-%s", basename));
/* Then replace all non alphanumerics characters by '-' and change the
- extenstion to ".h". We expect the input filename extension was at least
+ extension to ".h". We expect the input filename extension was at least
one character long. */
char *s = result;
for (; *s != '.'; s++)
- if (! ISALNUM (*s) && *s != '-')
+ if (!ISALNUM (*s) && *s != '-')
*s = '-';
memcpy (s, ".h", sizeof (".h"));
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);
len = strlen (basename);
- if ((len > 2 && memcmp (basename+len-2, ".c", 2) == 0)
- || (len > 2 && memcmp (basename+len-2, ".y", 2) == 0)
- || (len > 3 && memcmp (basename+len-3, ".in", 3) == 0))
+ if ((len > 2 && memcmp (basename + len - 2, ".c", 2) == 0)
+ || (len > 2 && memcmp (basename + len - 2, ".y", 2) == 0)
+ || (len > 3 && memcmp (basename + len - 3, ".in", 3) == 0))
{
- output_name = get_file_gtfilename (input_file);
+ output_name = get_file_gtfilename (input_file);
for_name = basename;
}
/* Some headers get used by more than one front-end; hence, it
(and gengtype doesn't know how to direct spewage into multiple
gtype-<lang>.h headers at this time). Instead, we pair up these
headers with source files (and their special purpose gt-*.h headers). */
- else if (strcmp (basename, "c-common.h") == 0)
- output_name = "gt-c-common.h", for_name = "c-common.c";
+ else if (strncmp (basename, "c-family", 8) == 0
+ && IS_DIR_SEPARATOR (basename[8])
+ && strcmp (basename + 9, "c-common.h") == 0)
+ output_name = "gt-c-family-c-common.h", for_name = "c-family/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])
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])
+ 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
+ else
{
int lang_index = get_prefix_langdir_index (basename);
/* If not, create it. */
r = create_file (for_name, output_name);
+ gcc_assert (r && r->name);
return r;
}
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,
for (of = output_files; of; of = of->next)
{
- FILE * newfile;
- newfile = fopen (of->name, "r");
- if (newfile != NULL )
+ if (!is_file_equal (of))
{
- 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;
+ FILE *newfile = fopen (of->name, "w");
+ if (newfile == NULL)
+ fatal ("opening output file %s: %s", of->name, xstrerror (errno));
+ if (fwrite (of->buf, 1, of->bufused, newfile) != of->bufused)
+ fatal ("writing output file %s: %s", of->name, xstrerror (errno));
+ if (fclose (newfile) != 0)
+ fatal ("closing output file %s: %s", of->name, xstrerror (errno));
}
-
- 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;
}
}
\f
-struct flist {
+struct flist
+{
struct flist *next;
int started_p;
const char *name;
For structures, given a pointer to the item in 'val'.
For misc. pointers, given the item in 'val'.
*/
-typedef void (*process_field_fn)
- (type_p f, const struct walk_type_data *p);
-typedef void (*func_name_fn)
- (type_p s, const struct walk_type_data *p);
+typedef void (*process_field_fn) (type_p f, const struct walk_type_data * p);
+typedef void (*func_name_fn) (type_p s, const struct walk_type_data * p);
/* Parameters for write_types. */
const char *, const char *);
static void output_mangled_typename (outf_p, const_type_p);
static void walk_type (type_p t, struct walk_type_data *d);
-static void write_func_for_structure
- (type_p orig_s, type_p s, type_p * param,
- const struct write_types_data *wtd);
+static void write_func_for_structure (type_p orig_s, type_p s, type_p *param,
+ const struct write_types_data *wtd);
static void write_types_process_field
- (type_p f, const struct walk_type_data *d);
-static void write_types (type_p structures,
+ (type_p f, const struct walk_type_data *d);
+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);
+ (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,
- type_p param_structs);
+ (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);
-static void put_mangled_filename (outf_p , const char *);
+static void put_mangled_filename (outf_p, const char *);
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 *);
+static void write_root (outf_p, pair_p, type_p, const char *, int,
+ struct fileloc *, const char *, bool);
static void write_array (outf_p f, pair_p v,
const struct write_types_data *wtd);
-static void write_roots (pair_p);
+static void write_roots (pair_p, bool);
/* Parameters for walk_type. */
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;
{
if (t == NULL)
oprintf (of, "Z");
- else switch (t->kind)
- {
- case TYPE_POINTER:
- oprintf (of, "P");
- output_mangled_typename (of, t->u.p);
- break;
- case TYPE_SCALAR:
- oprintf (of, "I");
- break;
- case TYPE_STRING:
- oprintf (of, "S");
- break;
- case TYPE_STRUCT:
- case TYPE_UNION:
- case TYPE_LANG_STRUCT:
- oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag), t->u.s.tag);
- break;
- case TYPE_PARAM_STRUCT:
+ else
+ switch (t->kind)
{
- int i;
- for (i = 0; i < NUM_PARAM; i++)
- if (t->u.param_struct.param[i] != NULL)
- output_mangled_typename (of, t->u.param_struct.param[i]);
- output_mangled_typename (of, t->u.param_struct.stru);
+ case TYPE_POINTER:
+ oprintf (of, "P");
+ output_mangled_typename (of, t->u.p);
+ break;
+ case TYPE_SCALAR:
+ oprintf (of, "I");
+ break;
+ case TYPE_STRING:
+ oprintf (of, "S");
+ break;
+ case TYPE_STRUCT:
+ case TYPE_UNION:
+ case TYPE_LANG_STRUCT:
+ oprintf (of, "%lu%s", (unsigned long) strlen (t->u.s.tag),
+ t->u.s.tag);
+ break;
+ case TYPE_PARAM_STRUCT:
+ {
+ int i;
+ for (i = 0; i < NUM_PARAM; i++)
+ if (t->u.param_struct.param[i] != NULL)
+ output_mangled_typename (of, t->u.param_struct.param[i]);
+ output_mangled_typename (of, t->u.param_struct.stru);
+ }
+ break;
+ case TYPE_ARRAY:
+ gcc_unreachable ();
}
- break;
- case TYPE_ARRAY:
- gcc_unreachable ();
- }
}
/* Print PARAM to D->OF processing escapes. D->VAL references the
for (p = param; *p; p++)
if (*p != '%')
oprintf (d->of, "%c", *p);
- else switch (*++p)
- {
- case 'h':
- oprintf (d->of, "(%s)", d->prev_val[2]);
- break;
- case '0':
- oprintf (d->of, "(%s)", d->prev_val[0]);
- break;
- case '1':
- oprintf (d->of, "(%s)", d->prev_val[1]);
- break;
- case 'a':
+ else
+ switch (*++p)
{
- const char *pp = d->val + strlen (d->val);
- while (pp[-1] == ']')
- while (*pp != '[')
- pp--;
- oprintf (d->of, "%s", pp);
+ case 'h':
+ oprintf (d->of, "(%s)", d->prev_val[2]);
+ break;
+ case '0':
+ oprintf (d->of, "(%s)", d->prev_val[0]);
+ break;
+ case '1':
+ oprintf (d->of, "(%s)", d->prev_val[1]);
+ break;
+ case 'a':
+ {
+ const char *pp = d->val + strlen (d->val);
+ while (pp[-1] == ']')
+ while (*pp != '[')
+ pp--;
+ oprintf (d->of, "%s", pp);
+ }
+ break;
+ default:
+ error_at_line (d->line, "`%s' option contains bad escape %c%c",
+ oname, '%', *p);
}
- break;
- default:
- error_at_line (d->line, "`%s' option contains bad escape %c%c",
- oname, '%', *p);
- }
}
/* Call D->PROCESS_FIELD for every field (or subfield) of D->VAL,
else if (strcmp (oo->name, "param_is") == 0)
;
else if (strncmp (oo->name, "param", 5) == 0
- && ISDIGIT (oo->name[5])
- && strcmp (oo->name + 6, "_is") == 0)
+ && ISDIGIT (oo->name[5]) && strcmp (oo->name + 6, "_is") == 0)
;
else if (strcmp (oo->name, "chain_next") == 0)
;
;
else if (strcmp (oo->name, "reorder") == 0)
;
+ else if (strcmp (oo->name, "variable_size") == 0)
+ ;
else
error_at_line (d->line, "unknown option `%s'\n", oo->name);
if (pointer_p)
t = t->u.p;
- if (! UNION_OR_STRUCT_P (t))
+ if (!UNION_OR_STRUCT_P (t))
error_at_line (d->line, "`use_params' option on unimplemented type");
else
t = find_param_structure (t, d->param);
t = nt;
}
else
- error_at_line (d->line, "no parameter defined for `%s'",
- d->val);
+ error_at_line (d->line, "no parameter defined for `%s'", d->val);
}
if (maybe_undef_p
- && (t->kind != TYPE_POINTER || ! UNION_OR_STRUCT_P (t->u.p)))
+ && (t->kind != TYPE_POINTER || !UNION_OR_STRUCT_P (t->u.p)))
{
error_at_line (d->line,
"field `%s' has invalid option `maybe_undef_p'\n",
case TYPE_POINTER:
{
- if (maybe_undef_p
- && t->u.p->u.s.line.file == NULL)
+ if (maybe_undef_p && t->u.p->u.s.line.file == NULL)
{
oprintf (d->of, "%*sgcc_assert (!%s);\n", d->indent, "", d->val);
break;
}
- if (! length)
+ if (!length)
{
- if (! UNION_OR_STRUCT_P (t->u.p)
+ if (!UNION_OR_STRUCT_P (t->u.p)
&& t->u.p->kind != TYPE_PARAM_STRUCT)
{
error_at_line (d->line,
{
const char *oldprevval2 = d->prev_val[2];
- if (! UNION_OR_STRUCT_P (nested_ptr_d->type))
+ if (!UNION_OR_STRUCT_P (nested_ptr_d->type))
{
error_at_line (d->line,
"field `%s' has invalid "
- "option `nested_ptr'\n",
- d->val);
+ "option `nested_ptr'\n", d->val);
return;
}
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,
- d->fn_wants_lvalue ? "" : "const ",
- d->val);
+ (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, "");
output_escaped_param (d, nested_ptr_d->convert_from,
"nested_ptr");
oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
d->indent += 2;
oprintf (d->of, "%*ssize_t i%d;\n", d->indent, "", loopcounter);
- oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent, "",
- loopcounter, loopcounter);
+ oprintf (d->of, "%*sfor (i%d = 0; i%d != (size_t)(", d->indent,
+ "", loopcounter, loopcounter);
output_escaped_param (d, length, "length");
oprintf (d->of, "); i%d++) {\n", loopcounter);
d->indent += 2;
d->used_length = 0;
d->indent -= 2;
oprintf (d->of, "%*s}\n", d->indent, "");
- d->process_field(t, d);
+ d->process_field (t, d);
d->indent -= 2;
oprintf (d->of, "%*s}\n", d->indent, "");
}
else
oprintf (d->of, "%s", t->u.a.len);
oprintf (d->of, ");\n");
-
+
oprintf (d->of, "%*sfor (i%d = 0; i%d != l%d; i%d++) {\n",
d->indent, "",
loopcounter, loopcounter, loopcounter, loopcounter);
int seen_default_p = 0;
options_p o;
- if (! t->u.s.line.file)
+ if (!t->u.s.line.file)
error_at_line (d->line, "incomplete structure `%s'", t->u.s.tag);
if ((d->bitmap & t->u.s.bitmap) != d->bitmap)
/* 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)
+ if (!desc && strcmp (o->name, "desc") == 0)
desc = o->info;
d->prev_val[2] = oldval;
{
if (desc == NULL)
{
- error_at_line (d->line, "missing `desc' option for union `%s'",
+ error_at_line (d->line,
+ "missing `desc' option for union `%s'",
t->u.s.tag);
desc = "1";
}
d->indent += 2;
seen_default_p = 1;
}
- else if (! union_p && (default_p || tagid))
+ else if (!union_p && (default_p || tagid))
error_at_line (d->line,
"can't use `%s' outside a union on field `%s'",
default_p ? "default" : "tag", f->name);
- else if (union_p && ! (default_p || tagid)
+ else if (union_p && !(default_p || tagid)
&& f->type->kind == TYPE_SCALAR)
{
fprintf (stderr,
- "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
+ "%s:%d: warning: field `%s' is missing `tag' or `default' option\n",
d->line->file, d->line->line, f->name);
continue;
}
- else if (union_p && ! (default_p || tagid))
+ else if (union_p && !(default_p || tagid))
error_at_line (d->line,
"field `%s' is missing `tag' or `default' option",
f->name);
d->prev_val[1] = oldprevval1;
d->prev_val[2] = oldprevval2;
- if (union_p && ! seen_default_p)
+ if (union_p && !seen_default_p)
{
oprintf (d->of, "%*sdefault:\n", d->indent, "");
oprintf (d->of, "%*s break;\n", d->indent, "");
oprintf (d->of, ", gt_e_");
output_mangled_typename (d->of, f);
}
- else if (UNION_OR_STRUCT_P (f)
- && f->u.p->u.s.line.file != NULL)
+ else if (UNION_OR_STRUCT_P (f) && f->u.p->u.s.line.file != NULL)
{
oprintf (d->of, ", gt_ggc_e_");
output_mangled_typename (d->of, f);
static void
output_type_enum (outf_p of, type_p s)
{
- if (s->kind == TYPE_PARAM_STRUCT && s->u.s.line.file != NULL)
+ if (s->kind == TYPE_PARAM_STRUCT && s->u.param_struct.line.file != NULL)
{
oprintf (of, ", gt_e_");
output_mangled_typename (of, s);
oprintf (of, ", gt_types_enum_last");
}
+/* Return an output file that is suitable for definitions which can
+ reference struct S */
+
+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
PARAM, write out a routine that:
- Takes a parameter, a void * but actually of type *S
- If SEEN_ROUTINE returns nonzero, calls write_types_process_field on each
- field of S or its substructures and (in some cases) things
- that are pointed to by S.
+ field of S or its substructures and (in some cases) things
+ that are pointed to by S.
*/
static void
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;
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)
d.bitmap = s->u.s.bitmap;
d.param = param;
d.prev_val[0] = "*x";
- d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
+ d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
d.prev_val[3] = "x";
d.val = "(*x)";
oprintf (d.of, ");\n");
oprintf (d.of, " if (xprev == NULL) break;\n");
oprintf (d.of, " x = xprev;\n");
- oprintf (d.of, " (void) %s (xprev",
- wtd->marker_routine);
+ oprintf (d.of, " (void) %s (xprev", wtd->marker_routine);
if (wtd->param_prefix)
{
oprintf (d.of, ", xprev, gt_%s_", wtd->param_prefix);
/* 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)
+ if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
{
options_p opt;
- if (s->gc_used == GC_MAYBE_POINTED_TO
- && s->u.s.line.file == NULL)
+ if (s->gc_used == GC_MAYBE_POINTED_TO && s->u.s.line.file == NULL)
continue;
- oprintf (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,
- " } while (0)\n");
+ oprintf (output_header, " } while (0)\n");
for (opt = s->u.s.opt; opt; opt = opt->next)
if (strcmp (opt->name, "ptr_alias") == 0)
{
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,
+ || t->kind == TYPE_UNION || t->kind == TYPE_LANG_STRUCT)
+ oprintf (output_header,
"#define gt_%sx_%s gt_%sx_%s\n",
wtd->prefix, s->u.s.tag, wtd->prefix, t->u.s.tag);
else
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);
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)
{
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;
}
}
-static const struct write_types_data ggc_wtd =
-{
+static const struct write_types_data ggc_wtd = {
"ggc_m", NULL, "ggc_mark", "ggc_test_and_set_mark", NULL,
"GC marker procedures. ",
FALSE
};
-static const struct write_types_data pch_wtd =
-{
+static const struct write_types_data pch_wtd = {
"pch_n", "pch_p", "gt_pch_note_object", "gt_pch_note_object",
"gt_pch_note_reorder",
"PCH type-walking procedures. ",
*/
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;
d.bitmap = s->u.s.bitmap;
d.param = param;
d.prev_val[0] = d.prev_val[2] = "*x";
- d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
+ d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
d.prev_val[3] = "x";
d.val = "(*x)";
d.fn_wants_lvalue = true;
/* 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)
+ if (s->gc_used == GC_POINTED_TO || s->gc_used == GC_MAYBE_POINTED_TO)
{
options_p opt;
{
const_type_p const t = (const_type_p) opt->info;
if (t->kind == TYPE_STRUCT
- || t->kind == TYPE_UNION
- || t->kind == TYPE_LANG_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,
continue;
/* Declare the marker procedure only once. */
- oprintf (header_file, "extern void gt_pch_p_");
- output_mangled_typename (header_file, s);
- oprintf (header_file,
- "\n (void *, void *, gt_pointer_operator, void *);\n");
+ 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)
{
for (s = param_structs; s; s = s->next)
if (s->gc_used == GC_POINTED_TO)
{
- type_p * param = s->u.param_struct.param;
+ type_p *param = s->u.param_struct.param;
type_p stru = s->u.param_struct.stru;
/* Declare the marker procedure. */
- oprintf (header_file, "extern void gt_pch_p_");
- output_mangled_typename (header_file, s);
- oprintf (header_file,
- "\n (void *, void *, gt_pointer_operator, void *);\n");
+ 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)
{
}
}
+/* Nonzero if S is a type for which typed GC allocators should be output. */
+
+#define USED_BY_TYPED_GC_P(s) \
+ (((s->kind == TYPE_POINTER) \
+ && ((s->u.p->gc_used == GC_POINTED_TO) \
+ || (s->u.p->gc_used == GC_USED))) \
+ || (UNION_OR_STRUCT_P (s) && \
+ (((s)->gc_used == GC_POINTED_TO) \
+ || ((s)->gc_used == GC_MAYBE_POINTED_TO \
+ && s->u.s.line.file != NULL) \
+ || ((s)->gc_used == GC_USED \
+ && strncmp (s->u.s.tag, "anonymous", strlen ("anonymous"))))))
+
+
/* Write out the 'enum' definition for gt_types_enum. */
static void
{
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)
- if (s->gc_used == GC_POINTED_TO
- || s->gc_used == GC_MAYBE_POINTED_TO)
+ if (USED_BY_TYPED_GC_P (s))
{
- if (s->gc_used == GC_MAYBE_POINTED_TO
- && s->u.s.line.file == NULL)
- continue;
-
oprintf (header_file, " gt_ggc_e_");
output_mangled_typename (header_file, s);
- oprintf (header_file, ", \n");
+ oprintf (header_file, ",\n");
}
for (s = param_structs; s; s = s->next)
if (s->gc_used == GC_POINTED_TO)
{
oprintf (header_file, " gt_e_");
output_mangled_typename (header_file, s);
- oprintf (header_file, ", \n");
+ oprintf (header_file, ",\n");
}
oprintf (header_file, " gt_types_enum_last\n");
oprintf (header_file, "};\n");
return contains_scalar_p (t->u.a.p);
default:
/* Could also check for structures that have no non-pointer
- fields, but there aren't enough of those to worry about. */
+ fields, but there aren't enough of those to worry about. */
return 1;
}
}
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);
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_lang_bitmap (fli2->name);
if (bitmap & 1)
{
oprintf (base_files[fnum],
- "extern const struct %s gt_%s_",
- tname, pfx);
+ "extern const struct %s gt_%s_", tname, pfx);
put_mangled_filename (base_files[fnum], fli2->name);
oprintf (base_files[fnum], "[];\n");
}
{
size_t fnum;
- for (fnum = 0; fnum < num_lang_dirs; fnum++)
- oprintf (base_files [fnum],
- "const struct %s * const %s[] = {\n",
- tname, name);
+ for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
+ oprintf (base_files[fnum],
+ "EXPORTED_CONST struct %s * const %s[] = {\n", tname, name);
}
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);
{
size_t fnum;
- for (fnum = 0; fnum < num_lang_dirs; fnum++)
+ for (fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
{
oprintf (base_files[fnum], " NULL\n");
oprintf (base_files[fnum], "};\n");
}
}
+/* Write the first three fields (pointer, count and stride) for
+ root NAME to F. V and LINE are as for write_root.
+
+ Return true if the entry could be written; return false on error. */
+
+static bool
+start_root_entry (outf_p f, pair_p v, const char *name, struct fileloc *line)
+{
+ type_p ap;
+
+ if (!v)
+ {
+ error_at_line (line, "`%s' is too complex to be a root", name);
+ return false;
+ }
+
+ oprintf (f, " {\n");
+ oprintf (f, " &%s,\n", name);
+ oprintf (f, " 1");
+
+ for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
+ if (ap->u.a.len[0])
+ oprintf (f, " * (%s)", ap->u.a.len);
+ else if (ap == v->type)
+ oprintf (f, " * ARRAY_SIZE (%s)", v->name);
+ oprintf (f, ",\n");
+ oprintf (f, " sizeof (%s", v->name);
+ for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
+ oprintf (f, "[0]");
+ oprintf (f, "),\n");
+ return true;
+}
+
+/* A subroutine of write_root for writing the roots for field FIELD_NAME,
+ which has type FIELD_TYPE. Parameters F to EMIT_PCH are the parameters
+ of the caller. */
+
+static void
+write_field_root (outf_p f, pair_p v, type_p type, const char *name,
+ int has_length, struct fileloc *line, const char *if_marked,
+ bool emit_pch, type_p field_type, const char *field_name)
+{
+ /* If the field reference is relative to V, rather than to some
+ subcomponent of V, we can mark any subarrays with a single stride.
+ We're effectively treating the field as a global variable in its
+ own right. */
+ if (v && type == v->type)
+ {
+ struct pair newv;
+
+ newv = *v;
+ newv.type = field_type;
+ newv.name = ACONCAT ((v->name, ".", field_name, NULL));
+ v = &newv;
+ }
+ /* Otherwise, any arrays nested in the structure are too complex to
+ handle. */
+ else if (field_type->kind == TYPE_ARRAY)
+ v = NULL;
+ write_root (f, v, field_type, ACONCAT ((name, ".", field_name, NULL)),
+ has_length, line, if_marked, emit_pch);
+}
+
/* Write out to F the table entry and any marker routines needed to
- mark NAME as TYPE. The original variable is V, at LINE.
+ mark NAME as TYPE. V can be one of three values:
+
+ - null, if NAME is too complex to represent using a single
+ count and stride. In this case, it is an error for NAME to
+ contain any gc-ed data.
+
+ - the outermost array that contains NAME, if NAME is part of an array.
+
+ - the C variable that contains NAME, if NAME is not part of an array.
+
+ LINE is the line of the C source that declares the root variable.
HAS_LENGTH is nonzero iff V was a variable-length array. IF_MARKED
is nonzero iff we are building the root table for hash table caches. */
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)
{
;
else
error_at_line (line,
- "field `%s' of global `%s' has unknown option `%s'",
+ "field `%s' of global `%s' has unknown option `%s'",
fld->name, name, o->name);
if (skip_p)
continue;
if (validf != NULL)
error_at_line (line,
- "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
+ "both `%s.%s.%s' and `%s.%s.%s' have tag `%s'",
name, fld->name, validf->name,
- name, fld->name, ufld->name,
- tag);
+ name, fld->name, ufld->name, tag);
validf = ufld;
}
if (validf != NULL)
- {
- char *newname;
- newname = xasprintf ("%s.%s.%s",
- name, fld->name, validf->name);
- write_root (f, v, validf->type, newname, 0, line,
- if_marked);
- free (newname);
- }
+ write_field_root (f, v, type, name, 0, line, if_marked,
+ emit_pch, validf->type,
+ ACONCAT ((fld->name, ".",
+ validf->name, NULL)));
}
else if (desc)
error_at_line (line,
- "global `%s.%s' has `desc' option but is not union",
+ "global `%s.%s' has `desc' option but is not union",
name, fld->name);
else
- {
- char *newname;
- newname = xasprintf ("%s.%s", name, fld->name);
- write_root (f, v, fld->type, newname, 0, line, if_marked);
- free (newname);
- }
+ write_field_root (f, v, type, name, 0, line, if_marked,
+ emit_pch, fld->type, fld->name);
}
}
break;
{
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;
case TYPE_POINTER:
{
- type_p ap, tp;
-
- oprintf (f, " {\n");
- oprintf (f, " &%s,\n", name);
- oprintf (f, " 1");
-
- for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
- if (ap->u.a.len[0])
- oprintf (f, " * (%s)", ap->u.a.len);
- else if (ap == v->type)
- oprintf (f, " * ARRAY_SIZE (%s)", v->name);
- oprintf (f, ",\n");
- oprintf (f, " sizeof (%s", v->name);
- for (ap = v->type; ap->kind == TYPE_ARRAY; ap = ap->u.a.p)
- oprintf (f, "[0]");
- oprintf (f, "),\n");
+ type_p tp;
+
+ if (!start_root_entry (f, v, name, line))
+ return;
tp = type->u.p;
- if (! has_length && UNION_OR_STRUCT_P (tp))
+ if (!has_length && UNION_OR_STRUCT_P (tp))
{
oprintf (f, " >_ggc_mx_%s,\n", tp->u.s.tag);
- 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)
+ 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
{
case TYPE_STRING:
{
- oprintf (f, " {\n");
- oprintf (f, " &%s,\n", name);
- oprintf (f, " 1, \n");
- oprintf (f, " sizeof (%s),\n", v->name);
+ if (!start_root_entry (f, v, name, line))
+ return;
+
oprintf (f, " (gt_pointer_walker) >_ggc_m_S,\n");
oprintf (f, " (gt_pointer_walker) >_pch_n_S\n");
oprintf (f, " },\n");
break;
default:
- error_at_line (line,
- "global `%s' is unimplemented type",
- name);
+ error_at_line (line, "global `%s' is unimplemented type", name);
}
}
if (wtd->param_prefix)
{
oprintf (f, "static void gt_%sa_%s\n", wtd->param_prefix, v->name);
- oprintf (f,
- " (void *, void *, gt_pointer_operator, void *);\n");
+ oprintf (f, " (void *, void *, gt_pointer_operator, void *);\n");
oprintf (f, "static void gt_%sa_%s (ATTRIBUTE_UNUSED void *this_obj,\n",
wtd->param_prefix, v->name);
oprintf (d.of,
}
d.opt = v->opt;
- oprintf (f, "static void gt_%sa_%s (void *);\n",
- wtd->prefix, v->name);
+ oprintf (f, "static void gt_%sa_%s (void *);\n", wtd->prefix, v->name);
oprintf (f, "static void\ngt_%sa_%s (ATTRIBUTE_UNUSED void *x_p)\n",
wtd->prefix, v->name);
oprintf (f, "{\n");
/* 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;
else if (strcmp (o->name, "param_is") == 0)
;
else if (strncmp (o->name, "param", 5) == 0
- && ISDIGIT (o->name[5])
- && strcmp (o->name + 6, "_is") == 0)
+ && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0)
;
else if (strcmp (o->name, "if_marked") == 0)
;
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->next = flp;
fli->started_p = 0;
fli->name = v->line.file;
+ gcc_assert (fli->name);
flp = fli;
oprintf (f, "\n/* GC roots. */\n\n");
}
- if (! deletable_p
+ if (!deletable_p
&& length
&& v->type->kind == TYPE_POINTER
&& (v->type->u.p->kind == TYPE_POINTER
for (fli = flp; fli; fli = fli->next)
if (fli->f == f)
break;
- if (! fli->started_p)
+ if (!fli->started_p)
{
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",
for (fli = flp; fli; fli = fli->next)
if (fli->f == f)
break;
- if (! fli->started_p)
+ if (!fli->started_p)
{
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");
}
|| v->type->u.p->kind != TYPE_PARAM_STRUCT
|| v->type->u.p->u.param_struct.stru != find_structure ("htab", 0))
{
- error_at_line (&v->line, "if_marked option used but not hash table");
+ error_at_line (&v->line,
+ "if_marked option used but not hash table");
continue;
}
for (fli = flp; fli; fli = fli->next)
if (fli->f == f)
break;
- if (! fli->started_p)
+ if (!fli->started_p)
{
fli->started_p = 1;
- 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);
else if (strcmp (o->name, "if_marked") == 0)
if_marked_p = 1;
- if (! if_marked_p)
+ if (!if_marked_p)
continue;
for (fli = flp; fli; fli = fli->next)
if (fli->f == f)
break;
- if (! fli->started_p)
+ if (!fli->started_p)
{
fli->started_p = 1;
- 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",
if (skip_p)
continue;
- if (! contains_scalar_p (v->type))
+ if (!contains_scalar_p (v->type))
continue;
for (fli = flp; fli; fli = fli->next)
if (fli->f == f)
break;
- if (! fli->started_p)
+ if (!fli->started_p)
{
fli->started_p = 1;
- 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");
}
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 fields;
type_p t;
options_p o;
type_p len_ty = create_scalar_type ("unsigned");
- const char *name = concat ("VEC_", typename, "_base", (char *)0);
+ 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");
}
void
note_def_vec_alloc (const char *type, const char *astrat, struct fileloc *pos)
{
- const char *astratname = concat ("VEC_", type, "_", astrat, (char *)0);
- const char *basename = concat ("VEC_", type, "_base", (char *)0);
+ const char *astratname = concat ("VEC_", type, "_", astrat, (char *) 0);
+ const char *basename = concat ("VEC_", type, "_base", (char *) 0);
pair_p field = create_field_at (0, resolve_typedef (basename, pos),
"base", 0, pos);
do_typedef (astratname, new_structure (astratname, 0, pos, field, 0), pos);
}
+/* Returns the specifier keyword for a string or union type S, empty string
+ otherwise. */
+
+static const char *
+get_type_specifier (const type_p s)
+{
+ if (s->kind == TYPE_STRUCT || s->kind == TYPE_LANG_STRUCT)
+ return "struct ";
+ if (s->kind == TYPE_UNION)
+ return "union ";
+ return "";
+}
+
+/* TRUE if type S has the GTY variable_size annotation. */
+
+static bool
+variable_size_p (const type_p s)
+{
+ options_p o;
+ for (o = s->u.s.opt; o; o = o->next)
+ if (strcmp (o->name, "variable_size") == 0)
+ return true;
+ return false;
+}
+
+enum alloc_quantity
+{ single, vector };
+enum alloc_zone
+{ any_zone, specific_zone };
+
+/* Writes one typed allocator definition for type identifier TYPE_NAME with
+ optional type specifier TYPE_SPECIFIER. The allocator name will contain
+ ALLOCATOR_TYPE. If VARIABLE_SIZE is true, the allocator will have an extra
+ parameter specifying number of bytes to allocate. If QUANTITY is set to
+ VECTOR, a vector allocator will be output, if ZONE is set to SPECIFIC_ZONE,
+ the allocator will be zone-specific. */
+
+static void
+write_typed_alloc_def (bool variable_size, const char *type_specifier,
+ const char *type_name, const char *allocator_type,
+ enum alloc_quantity quantity, enum alloc_zone zone)
+{
+ bool two_args = variable_size && (quantity == vector);
+ bool third_arg = ((zone == specific_zone)
+ && (variable_size || (quantity == vector)));
+
+ oprintf (header_file, "#define ggc_alloc_%s%s", allocator_type, type_name);
+ oprintf (header_file, "(%s%s%s%s%s) ",
+ (variable_size ? "SIZE" : ""),
+ (two_args ? ", " : ""),
+ (quantity == vector) ? "n" : "",
+ (third_arg ? ", " : ""), (zone == specific_zone) ? "z" : "");
+ oprintf (header_file, "((%s%s *)", type_specifier, type_name);
+ oprintf (header_file, "(ggc_internal_%salloc_stat (", allocator_type);
+ if (zone == specific_zone)
+ oprintf (header_file, "z, ");
+ if (variable_size)
+ oprintf (header_file, "SIZE");
+ else
+ oprintf (header_file, "sizeof (%s%s)", type_specifier, type_name);
+ if (quantity == vector)
+ oprintf (header_file, ", n");
+ oprintf (header_file, " MEM_STAT_INFO)))\n");
+}
+
+/* Writes a typed allocator definition for a struct or union S. */
+
+static void
+write_typed_struct_alloc_def (const type_p s, const char *allocator_type,
+ enum alloc_quantity quantity,
+ enum alloc_zone zone)
+{
+ write_typed_alloc_def (variable_size_p (s), get_type_specifier (s),
+ s->u.s.tag, allocator_type, quantity, zone);
+}
+
+/* Writes a typed allocator definition for a typedef P. */
+
+static void
+write_typed_typedef_alloc_def (const pair_p p, const char *allocator_type,
+ enum alloc_quantity quantity,
+ enum alloc_zone zone)
+{
+ write_typed_alloc_def (variable_size_p (p->type), "", p->name,
+ allocator_type, quantity, zone);
+}
+
+/* Writes typed allocator definitions for the types in STRUCTURES and
+ TYPEDEFS that are used by GC. */
+
+static void
+write_typed_alloc_defns (const type_p structures, const pair_p typedefs)
+{
+ type_p s;
+ pair_p p;
+
+ oprintf (header_file,
+ "\n/* Allocators for known structs and unions. */\n\n");
+ for (s = structures; s; s = s->next)
+ {
+ if (!USED_BY_TYPED_GC_P (s))
+ continue;
+ write_typed_struct_alloc_def (s, "", single, any_zone);
+ write_typed_struct_alloc_def (s, "cleared_", single, any_zone);
+ write_typed_struct_alloc_def (s, "vec_", vector, any_zone);
+ write_typed_struct_alloc_def (s, "cleared_vec_", vector, any_zone);
+ write_typed_struct_alloc_def (s, "zone_", single, specific_zone);
+ write_typed_struct_alloc_def (s, "zone_cleared_", single,
+ specific_zone);
+ write_typed_struct_alloc_def (s, "zone_vec_", vector, specific_zone);
+ write_typed_struct_alloc_def (s, "zone_cleared_vec_", vector,
+ specific_zone);
+ }
+
+ oprintf (header_file, "\n/* Allocators for known typedefs. */\n");
+ for (p = typedefs; p; p = p->next)
+ {
+ s = p->type;
+ if (!USED_BY_TYPED_GC_P (s) || (strcmp (p->name, s->u.s.tag) == 0))
+ continue;
+ write_typed_typedef_alloc_def (p, "", single, any_zone);
+ write_typed_typedef_alloc_def (p, "cleared_", single, any_zone);
+ write_typed_typedef_alloc_def (p, "vec_", vector, any_zone);
+ write_typed_typedef_alloc_def (p, "cleared_vec_", vector, any_zone);
+ write_typed_typedef_alloc_def (p, "zone_", single, specific_zone);
+ write_typed_typedef_alloc_def (p, "zone_cleared_", single,
+ specific_zone);
+ write_typed_typedef_alloc_def (p, "zone_cleared_vec_", vector,
+ specific_zone);
+ }
+}
+
+/* Prints not-as-ugly version of a typename of T to OF. Trades the uniquness
+ guaranteee for somewhat increased readability. If name conflicts do happen,
+ this funcion will have to be adjusted to be more like
+ output_mangled_typename. */
+
+static void
+output_typename (outf_p of, const_type_p t)
+{
+ switch (t->kind)
+ {
+ case TYPE_STRING:
+ oprintf (of, "str");
+ break;
+ case TYPE_SCALAR:
+ oprintf (of, "scalar");
+ break;
+ case TYPE_POINTER:
+ output_typename (of, t->u.p);
+ break;
+ case TYPE_STRUCT:
+ case TYPE_UNION:
+ case TYPE_LANG_STRUCT:
+ oprintf (of, "%s", t->u.s.tag);
+ break;
+ case TYPE_PARAM_STRUCT:
+ {
+ int i;
+ for (i = 0; i < NUM_PARAM; i++)
+ if (t->u.param_struct.param[i] != NULL)
+ {
+ output_typename (of, t->u.param_struct.param[i]);
+ oprintf (of, "_");
+ }
+ output_typename (of, t->u.param_struct.stru);
+ break;
+ }
+ default:
+ gcc_unreachable ();
+ }
+}
+
+/* Writes a typed GC allocator for type S that is suitable as a callback for
+ the splay tree implementation in libiberty. */
+
+static void
+write_splay_tree_allocator_def (const_type_p s)
+{
+ outf_p of = get_output_file_for_structure (s, NULL);
+ oprintf (of, "void * ggc_alloc_splay_tree_");
+ output_typename (of, s);
+ oprintf (of, " (int sz, void * nl)\n");
+ oprintf (of, "{\n");
+ oprintf (of, " return ggc_splay_alloc (");
+ oprintf (of, "gt_e_");
+ output_mangled_typename (of, s);
+ oprintf (of, ", sz, nl);\n");
+ oprintf (of, "}\n\n");
+}
+
+/* Writes typed GC allocators for PARAM_STRUCTS that are suitable as callbacks
+ for the splay tree implementation in libiberty. */
+
+static void
+write_splay_tree_allocators (const_type_p param_structs)
+{
+ const_type_p s;
+
+ oprintf (header_file, "\n/* Splay tree callback allocators. */\n");
+ for (s = param_structs; s; s = s->next)
+ if (s->gc_used == GC_POINTED_TO)
+ {
+ oprintf (header_file, "extern void * ggc_alloc_splay_tree_");
+ output_typename (header_file, s);
+ oprintf (header_file, " (int, void *);\n");
+ write_splay_tree_allocator_def (s);
+ }
+}
+
+static void dump_pair (int indent, pair_p p);
+static void dump_type (int indent, type_p p);
+static void dump_type_list (int indent, type_p p);
+
+#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);
+}
\f
+
+
+/* Option specification for getopt_long. */
+static const struct option gengtype_long_options[] = {
+ {"help", no_argument, NULL, 'h'},
+ {"version", no_argument, NULL, 'V'},
+ {"dump", no_argument, NULL, 'd'},
+ {"debug", no_argument, NULL, 'D'},
+ {"plugin", required_argument, NULL, 'P'},
+ {"srcdir", required_argument, NULL, 'S'},
+ {"inputs", required_argument, NULL, 'I'},
+ {"read-state", required_argument, NULL, 'r'},
+ {"write-state", required_argument, NULL, 'w'},
+ /* Terminating NULL placeholder. */
+ {NULL, no_argument, NULL, 0},
+};
+
+
+static void
+print_usage (void)
+{
+ printf ("Usage: %s\n", progname);
+ printf ("\t -h | --help " " \t# Give this help.\n");
+ printf ("\t -D | --debug "
+ " \t# Give debug output to debug %s itself.\n", progname);
+ printf ("\t -V | --version " " \t# Give version information.\n");
+ printf ("\t -d | --dump " " \t# Dump state for debugging.\n");
+ printf ("\t -P | --plugin <output-file> <plugin-src> ... "
+ " \t# Generate for plugin.\n");
+ printf ("\t -S | --srcdir <GCC-directory> "
+ " \t# Specify the GCC source directory.\n");
+ printf ("\t -I | --inputs <input-list> "
+ " \t# Specify the file with source files list.\n");
+ printf ("\t -w | --write-state <state-file> " " \t# Write a state file.\n");
+ printf ("\t -r | --read-state <state-file> " " \t# Read a state file.\n");
+}
+
+static void
+print_version (void)
+{
+ printf ("%s %s%s\n", progname, pkgversion_string, version_string);
+ printf ("Report bugs: %s\n", bug_report_url);
+}
+
+/* Parse the program options using getopt_long... */
+static void
+parse_program_options (int argc, char **argv)
+{
+ int opt = -1;
+ while ((opt = getopt_long (argc, argv, "hVdP:S:I:w:r:D",
+ gengtype_long_options, NULL)) >= 0)
+ {
+ switch (opt)
+ {
+ case 'h': /* --help */
+ print_usage ();
+ break;
+ case 'V': /* --version */
+ print_version ();
+ break;
+ case 'd': /* --dump */
+ do_dump = 1;
+ break;
+ case 'D': /* --debug */
+ do_debug = 1;
+ break;
+ case 'P': /* --plugin */
+ if (optarg)
+ plugin_output_filename = optarg;
+ else
+ fatal ("missing plugin output file name");
+ break;
+ case 'S': /* --srcdir */
+ if (optarg)
+ srcdir = optarg;
+ else
+ fatal ("missing source directory");
+ srcdir_len = strlen (srcdir);
+ break;
+ case 'I': /* --inputs */
+ if (optarg)
+ inputlist = optarg;
+ else
+ fatal ("missing input list");
+ break;
+ case 'r': /* --read-state */
+ if (optarg)
+ read_state_filename = optarg;
+ else
+ fatal ("missing read state file");
+ DBGPRINTF ("read state %s\n", optarg);
+ break;
+ case 'w': /* --write-state */
+ DBGPRINTF ("write state %s\n", optarg);
+ if (optarg)
+ write_state_filename = optarg;
+ else
+ fatal ("missing write state file");
+ break;
+ default:
+ fprintf (stderr, "%s: unknown flag '%c'\n", progname, opt);
+ print_usage ();
+ fatal ("unexpected flag");
+ }
+ };
+ if (plugin_output_filename)
+ {
+ /* In plugin mode we require some input files. */
+ int i = 0;
+ if (optind >= argc)
+ fatal ("no source files given in plugin mode");
+ nb_plugin_files = argc - optind;
+ for (i = 0; i < (int) nb_plugin_files; i++)
+ {
+ char *name = argv[i + optind];
+ plugin_files[i] = name;
+ }
+ }
+}
+
+
int
main (int argc, char **argv)
{
size_t i;
- static struct fileloc pos = { this_file, 0 };
+ static struct fileloc pos = { NULL, 0 };
+ outf_p output_header;
- /* fatal uses this */
- progname = "gengtype";
+ /* Mandatory common initializations. */
+ progname = "gengtype"; /* For fatal and messages. */
+ /* Set the scalar_is_char union number for predefined scalar types. */
+ scalar_nonchar.u.scalar_is_char = FALSE;
+ scalar_char.u.scalar_is_char = TRUE;
- if (argc != 3)
- fatal ("usage: gengtype srcdir input-list");
+ parse_program_options (argc, argv);
- srcdir = argv[1];
- srcdir_len = strlen (srcdir);
+#if ENABLE_CHECKING
+ if (do_debug)
+ {
+ time_t now = (time_t) 0;
+ time (&now);
+ DBGPRINTF ("gengtype started pid %d at %s",
+ (int) getpid (), ctime (&now));
+ }
+#endif /* ENABLE_CHECKING */
+
+ /* Parse the input list and the input files. */
+ DBGPRINTF ("inputlist %s", inputlist);
+ if (read_state_filename)
+ {
+ fatal ("read state %s not implemented yet", read_state_filename);
+ /* TODO: implement read state. */
+ }
+ else if (inputlist)
+ {
+ /* These types are set up with #define or else outside of where
+ we can see them. We should initialize them before calling
+ read_input_list. */
+ pos.file = this_file;
+ 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);
+ read_input_list (inputlist);
+ for (i = 0; i < num_gt_files; i++)
+ {
+ parse_file (gt_files[i]);
+ DBGPRINTF ("parsed file #%d %s", (int) i, gt_files[i]);
+ }
+ DBGPRINT_COUNT_TYPE ("structures after parsing", structures);
+ DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs);
- read_input_list (argv[2]);
+ }
+ else
+ fatal ("either an input list or a read state file should be given");
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 ("uint8", &pos); pos.line++;
- do_scalar_typedef ("jword", &pos); pos.line++;
- do_scalar_typedef ("JCF_u2", &pos); pos.line++;
- do_scalar_typedef ("void", &pos); pos.line++;
- do_typedef ("PTR", create_pointer (resolve_typedef ("void", &pos)), &pos);
-
- for (i = 0; i < num_gt_files; i++)
- parse_file (gt_files[i]);
+ if (plugin_output_filename)
+ {
+ size_t ix = 0;
+ /* In plugin mode, we should have read a state file, and have
+ given at least one plugin file. */
+ if (!read_state_filename)
+ fatal ("No read state given in plugin mode for %s",
+ plugin_output_filename);
+
+ if (nb_plugin_files <= 0 || !plugin_files)
+ fatal ("No plugin files given in plugin mode for %s",
+ plugin_output_filename);
+
+ /* Parse our plugin files. */
+ for (ix = 0; ix < nb_plugin_files; ix++)
+ parse_file (plugin_files[ix]);
+
+ if (hit_error)
+ return 1;
+
+ plugin_output = create_file ("GCC", plugin_output_filename);
+ DBGPRINTF ("created plugin_output %p named %s",
+ (void *) plugin_output, plugin_output->name);
+ }
+ else
+ { /* No plugin files, we are in normal mode. */
+ if (!srcdir)
+ fatal ("gengtype needs a source directory in normal mode");
+ }
if (hit_error)
return 1;
+ gen_rtx_next ();
+
+ /* The call to set_gc_used may indirectly call find_param_structure
+ hence enlarge the param_structs list of types. */
set_gc_used (variables);
+ /* We should write the state here, but it is not yet implemented. */
+ if (write_state_filename)
+ {
+ fatal ("write state %s in not yet implemented", write_state_filename);
+ /* TODO: implement write state. */
+ }
+
+
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);
+ write_typed_alloc_defns (structures, typedefs);
+ output_header = plugin_output ? plugin_output : header_file;
+ DBGPRINT_COUNT_TYPE ("structures before write_types outputheader",
+ structures);
+ DBGPRINT_COUNT_TYPE ("param_structs before write_types outputheader",
+ param_structs);
+
+ write_types (output_header, structures, param_structs, &ggc_wtd);
+ if (plugin_files == NULL)
+ {
+ DBGPRINT_COUNT_TYPE ("structures before write_types headerfil",
+ structures);
+ DBGPRINT_COUNT_TYPE ("param_structs before write_types headerfil",
+ param_structs);
+ write_types (header_file, structures, param_structs, &pch_wtd);
+ write_local (header_file, structures, param_structs);
+ }
+ write_splay_tree_allocators (param_structs);
+ write_roots (variables, plugin_files == NULL);
write_rtx_next ();
close_output_files ();
+ if (do_dump)
+ dump_everything ();
+
+ /* Don't bother about free-ing any input or plugin file, etc. */
+
if (hit_error)
return 1;
return 0;
OSDN Git Service
