/* Process source files and output type information.
- Copyright (C) 2002-2014 Free Software Foundation, Inc.
+ Copyright (C) 2002-2015 Free Software Foundation, Inc.
This file is part of GCC.
along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
-#ifdef GENERATOR_FILE
-#include "bconfig.h"
-#else
+#ifdef HOST_GENERATOR_FILE
#include "config.h"
+#define GENERATOR_FILE 1
+#else
+#include "bconfig.h"
#endif
#include "system.h"
#include "errors.h" /* for fatal */
va_end (ap);
}
-
-/* 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);
- n = vasprintf (&result, format, ap);
- if (result == NULL || n < 0)
- fatal ("out of memory");
- va_end (ap);
-
- return result;
-}
\f
/* Locate the ultimate base class of struct S. */
{
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;
+ int nb_lang_struct = 0;
int nb_user_struct = 0, nb_undefined = 0;
type_p p = NULL;
for (p = t; p; p = p->next)
case TYPE_LANG_STRUCT:
nb_lang_struct++;
break;
- case TYPE_PARAM_STRUCT:
- nb_param_struct++;
- break;
case TYPE_NONE:
gcc_unreachable ();
}
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);
+ if (nb_lang_struct > 0)
+ fprintf (stderr, "@@%%@@ %d lang_structs\n", nb_lang_struct);
if (nb_user_struct > 0)
fprintf (stderr, "@@%%@@ %d user_structs\n", nb_user_struct);
if (nb_undefined > 0)
pair_p typedefs = NULL;
type_p structures = NULL;
-type_p param_structs = NULL;
pair_p variables = NULL;
-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);
comma-separated list of strings, implicitly assumed to
be type names, potentially with "*" characters. */
char *arg = open_bracket + 1;
- char *next;
+ /* Workaround -Wmaybe-uninitialized false positive during
+ profiledbootstrap by initializing it. */
+ char *next = NULL;
char *type_id = strtoken (arg, ",>", &next);
pair_p fields = 0;
while (type_id)
return s;
}
-/* Return the previously-defined parameterized structure for structure
- T and parameters PARAM, or a new parameterized empty structure or
- union if none was defined previously. */
-
-static type_p
-find_param_structure (type_p t, type_p param[NUM_PARAM])
-{
- type_p res;
-
- for (res = param_structs; res; res = res->next)
- if (res->u.param_struct.stru == t
- && memcmp (res->u.param_struct.param, param,
- sizeof (type_p) * NUM_PARAM) == 0)
- break;
- if (res == NULL)
- {
- type_count++;
- res = XCNEW (struct type);
- res->kind = TYPE_PARAM_STRUCT;
- res->next = param_structs;
- res->state_number = -type_count;
- param_structs = res;
- res->u.param_struct.stru = t;
- memcpy (res->u.param_struct.param, param, sizeof (type_p) * NUM_PARAM);
- }
- return res;
-}
-
/* Return a scalar type with name NAME. */
type_p
case 'i':
case 'n':
case 'w':
+ case 'r':
t = scalar_tp;
subname = "rt_int";
break;
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 = reg_attrs_tp, subname = "rt_reg";
else if (i == SYMBOL_REF && aindex == 1)
t = symbol_union_tp, subname = "";
else if (i == JUMP_TABLE_DATA && aindex >= 4)
"CONSTANT_POOL_ADDRESS_P (&%0)");
}
+ if (i == REG)
+ subfields = create_field (subfields, reg_attrs_tp, "reg.attrs");
+
if (i == SYMBOL_REF)
{
/* Add the "block_sym" field if SYMBOL_REF_HAS_BLOCK_INFO_P
{
int length_p = 0;
const int pointer_p = t->kind == TYPE_POINTER;
- type_p params[NUM_PARAM];
- int params_p = 0;
- int i;
-
- for (i = 0; i < NUM_PARAM; i++)
- params[i] = NULL;
for (; opt; opt = opt->next)
if (strcmp (opt->name, "length") == 0)
}
length_p = 1;
}
- else if ((strcmp (opt->name, "param_is") == 0
- || (strncmp (opt->name, "param", 5) == 0
- && ISDIGIT (opt->name[5])
- && strcmp (opt->name + 6, "_is") == 0))
- && opt->kind == OPTION_TYPE)
- {
- int num = ISDIGIT (opt->name[5]) ? opt->name[5] - '0' : 0;
-
- if (!union_or_struct_p (t)
- && (t->kind != TYPE_POINTER || !union_or_struct_p (t->u.p)))
- {
- error_at_line (&lexer_line,
- "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 (opt->info.type);
- else
- params[num] = opt->info.type;
- }
else if (strcmp (opt->name, "special") == 0
&& opt->kind == OPTION_STRING)
{
error_at_line (&lexer_line, "unknown special `%s'", special_name);
}
- if (params_p)
- {
- type_p realt;
-
- if (pointer_p)
- t = t->u.p;
- realt = find_param_structure (t, params);
- 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)
return &string_type;
}
\f
-static void set_gc_used_type (type_p, enum gc_used_enum, type_p *,
- bool = false);
+static void set_gc_used_type (type_p, enum gc_used_enum, bool = false);
static void set_gc_used (pair_p);
/* Handle OPT for set_gc_used_type. */
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 *length, int *skip, type_p *nested_ptr)
{
options_p o;
for (o = opt; o; o = o->next)
if (strcmp (o->name, "ptr_alias") == 0 && level == GC_POINTED_TO
&& o->kind == OPTION_TYPE)
set_gc_used_type (o->info.type,
- GC_POINTED_TO, NULL);
+ GC_POINTED_TO);
else if (strcmp (o->name, "maybe_undef") == 0)
*maybe_undef = 1;
- else if (strcmp (o->name, "use_params") == 0)
- *pass_param = 1;
else if (strcmp (o->name, "length") == 0)
*length = 1;
else if (strcmp (o->name, "skip") == 0)
'EnumValue' is a type. */
static void
-set_gc_used_type (type_p t, enum gc_used_enum level, type_p param[NUM_PARAM],
+set_gc_used_type (type_p t, enum gc_used_enum level,
bool allow_undefined_types)
{
if (t->gc_used >= level)
type_p dummy2;
bool allow_undefined_field_types = (t->kind == TYPE_USER_STRUCT);
- process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy, &dummy,
+ process_gc_options (t->u.s.opt, level, &dummy, &dummy, &dummy,
&dummy2);
if (t->u.s.base_class)
- set_gc_used_type (t->u.s.base_class, level, param,
- allow_undefined_types);
+ set_gc_used_type (t->u.s.base_class, level, allow_undefined_types);
/* Anything pointing to a base class might actually be pointing
to a subclass. */
for (type_p subclass = t->u.s.first_subclass; subclass;
subclass = subclass->u.s.next_sibling_class)
- set_gc_used_type (subclass, level, param,
- allow_undefined_types);
+ set_gc_used_type (subclass, level, allow_undefined_types);
FOR_ALL_INHERITED_FIELDS(t, f)
{
int maybe_undef = 0;
- int pass_param = 0;
int length = 0;
int skip = 0;
type_p nested_ptr = NULL;
- process_gc_options (f->opt, level, &maybe_undef, &pass_param,
- &length, &skip, &nested_ptr);
+ process_gc_options (f->opt, level, &maybe_undef, &length, &skip,
+ &nested_ptr);
if (nested_ptr && f->type->kind == TYPE_POINTER)
- set_gc_used_type (nested_ptr, GC_POINTED_TO,
- pass_param ? param : NULL);
+ set_gc_used_type (nested_ptr, GC_POINTED_TO);
else if (length && f->type->kind == TYPE_POINTER)
- set_gc_used_type (f->type->u.p, GC_USED, NULL);
+ set_gc_used_type (f->type->u.p, GC_USED);
else if (maybe_undef && f->type->kind == TYPE_POINTER)
- set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO, NULL);
- else if (pass_param && f->type->kind == TYPE_POINTER && param)
- set_gc_used_type (find_param_structure (f->type->u.p, param),
- GC_POINTED_TO, NULL);
+ set_gc_used_type (f->type->u.p, GC_MAYBE_POINTED_TO);
else if (skip)
; /* target type is not used through this field */
else
- set_gc_used_type (f->type, GC_USED, pass_param ? param : NULL,
- allow_undefined_field_types);
+ set_gc_used_type (f->type, GC_USED, allow_undefined_field_types);
}
break;
}
break;
case TYPE_POINTER:
- set_gc_used_type (t->u.p, GC_POINTED_TO, NULL);
+ set_gc_used_type (t->u.p, GC_POINTED_TO);
break;
case TYPE_ARRAY:
- set_gc_used_type (t->u.a.p, GC_USED, param);
+ set_gc_used_type (t->u.a.p, GC_USED);
break;
case TYPE_LANG_STRUCT:
for (t = t->u.s.lang_struct; t; t = t->next)
- set_gc_used_type (t, level, param);
- break;
-
- case TYPE_PARAM_STRUCT:
- {
- int i;
- for (i = 0; i < NUM_PARAM; i++)
- if (t->u.param_struct.param[i] != 0)
- set_gc_used_type (t->u.param_struct.param[i], GC_USED, NULL);
- }
- if (t->u.param_struct.stru->gc_used == GC_POINTED_TO)
- level = GC_POINTED_TO;
- else
- level = GC_USED;
- t->u.param_struct.stru->gc_used = GC_UNUSED;
- set_gc_used_type (t->u.param_struct.stru, level,
- t->u.param_struct.param);
+ set_gc_used_type (t, level);
break;
default:
pair_p p;
for (p = variables; p; p = p->next)
{
- set_gc_used_type (p->type, GC_USED, NULL);
+ set_gc_used_type (p->type, GC_USED);
nbvars++;
};
if (verbosity_level >= 2)
create_file (const char *name, const char *oname)
{
static const char *const hdr[] = {
- " Copyright (C) 2004-2014 Free Software Foundation, Inc.\n",
+ " Copyright (C) 2004-2015 Free Software Foundation, Inc.\n",
"\n",
"This file is part of GCC.\n",
"\n",
static const char *const ifiles[] = {
"config.h", "system.h", "coretypes.h", "tm.h", "insn-codes.h",
"hashtab.h", "splay-tree.h", "obstack.h", "bitmap.h", "input.h",
- "tree.h", "rtl.h", "wide-int.h", "hashtab.h", "hash-set.h", "vec.h",
+ "hash-set.h", "machmode.h", "vec.h", "double-int.h", "input.h",
+ "alias.h", "symtab.h", "options.h",
+ "wide-int.h", "inchash.h",
+ "tree.h", "fold-const.h", "rtl.h",
"machmode.h", "tm.h", "hard-reg-set.h", "input.h", "predict.h",
- "function.h", "insn-config.h", "expr.h", "alloc-pool.h",
- "hard-reg-set.h", "basic-block.h", "cselib.h", "insn-addr.h",
+ "function.h", "insn-config.h", "flags.h", "statistics.h",
+ "real.h", "fixed-value.h", "tree.h", "expmed.h", "dojump.h",
+ "explow.h", "calls.h", "emit-rtl.h", "varasm.h", "stmt.h",
+ "expr.h", "alloc-pool.h",
+ "basic-block.h", "cselib.h", "insn-addr.h",
"optabs.h", "libfuncs.h", "debug.h", "ggc.h",
- "hash-table.h", "vec.h", "ggc.h", "dominance.h", "cfg.h", "basic-block.h",
+ "ggc.h", "dominance.h", "cfg.h", "basic-block.h",
"tree-ssa-alias.h", "internal-fn.h", "gimple-fold.h", "tree-eh.h",
"gimple-expr.h", "is-a.h",
"gimple.h", "gimple-iterator.h", "gimple-ssa.h", "tree-cfg.h",
"tree-ssa-loop-niter.h", "tree-into-ssa.h", "tree-dfa.h",
"tree-ssa.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
"except.h", "output.h", "cfgloop.h", "target.h", "lto-streamer.h",
- "target-globals.h", "ipa-ref.h", "cgraph.h", "ipa-prop.h",
- "ipa-inline.h", "dwarf2out.h", NULL
+ "target-globals.h", "ipa-ref.h", "cgraph.h", "symbol-summary.h",
+ "ipa-prop.h", "ipa-inline.h", "dwarf2out.h", "omp-low.h", NULL
};
const char *const *ifp;
outf_p gtype_desc_c;
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,
+static void write_func_for_structure (type_p orig_s, type_p s,
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 (outf_p output_header,
type_p structures,
- type_p param_structs,
const struct write_types_data *wtd);
static void write_types_local_process_field
(type_p f, const struct walk_type_data *d);
-static void write_local_func_for_structure
- (const_type_p orig_s, type_p s, type_p *param);
+static void write_local_func_for_structure (const_type_p orig_s, type_p s);
static void write_local (outf_p output_header,
- type_p structures, type_p param_structs);
+ type_p structures);
static int contains_scalar_p (type_p t);
static void put_mangled_filename (outf_p, const input_file *);
static void finish_root_table (struct flist *flp, const char *pfx,
const char *tname, const char *lastname,
const char *name);
static void write_root (outf_p, pair_p, type_p, const char *, int,
- struct fileloc *, const char *, bool);
+ struct fileloc *, bool);
static void write_array (outf_p f, pair_p v,
const struct write_types_data *wtd);
static void write_roots (pair_p, bool);
int counter;
const struct fileloc *line;
lang_bitmap bitmap;
- type_p *param;
int used_length;
type_p orig_s;
const char *reorder_fn;
free (CONST_CAST (char *, id_for_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 ();
}
containing the current object, D->OPT is a list of options to
apply, D->INDENT is the current indentation level, D->LINE is used
to print error messages, D->BITMAP indicates which languages to
- print the structure for, and D->PARAM is the current parameter
- (from an enclosing param_is option). */
+ print the structure for. */
static void
walk_type (type_p t, struct walk_type_data *d)
const char *desc = NULL;
const char *type_tag = NULL;
int maybe_undef_p = 0;
- int use_param_num = -1;
- int use_params_p = 0;
int atomic_p = 0;
options_p oo;
const struct nested_ptr_data *nested_ptr_d = NULL;
length = oo->info.string;
else if (strcmp (oo->name, "maybe_undef") == 0)
maybe_undef_p = 1;
- else if (strncmp (oo->name, "use_param", 9) == 0
- && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
- use_param_num = oo->name[9] == '\0' ? 0 : oo->name[9] - '0';
- else if (strcmp (oo->name, "use_params") == 0)
- use_params_p = 1;
else if (strcmp (oo->name, "desc") == 0 && oo->kind == OPTION_STRING)
desc = oo->info.string;
else if (strcmp (oo->name, "mark_hook") == 0)
atomic_p = 1;
else if (strcmp (oo->name, "default") == 0)
;
- else if (strcmp (oo->name, "param_is") == 0)
- ;
- else if (strncmp (oo->name, "param", 5) == 0
- && ISDIGIT (oo->name[5]) && strcmp (oo->name + 6, "_is") == 0)
- ;
else if (strcmp (oo->name, "chain_next") == 0)
;
else if (strcmp (oo->name, "chain_prev") == 0)
if (d->used_length)
length = NULL;
- if (use_params_p)
- {
- int pointer_p = t->kind == TYPE_POINTER;
-
- if (pointer_p)
- t = t->u.p;
- 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);
- if (pointer_p)
- t = create_pointer (t);
- }
-
- if (use_param_num != -1)
- {
- if (d->param != NULL && d->param[use_param_num] != NULL)
- {
- type_p nt = d->param[use_param_num];
-
- if (t->kind == TYPE_ARRAY)
- nt = create_array (nt, t->u.a.len);
- else if (length != NULL && t->kind == TYPE_POINTER)
- nt = create_pointer (nt);
- d->needs_cast_p = (t->kind != TYPE_POINTER
- && (nt->kind == TYPE_POINTER
- || nt->kind == TYPE_STRING));
- t = nt;
- }
- else
- 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)))
{
if (!length)
{
- if (!union_or_struct_p (t->u.p)
- && t->u.p->kind != TYPE_PARAM_STRUCT)
+ if (!union_or_struct_p (t->u.p))
{
error_at_line (d->line,
"field `%s' is pointer to unimplemented type",
const char *tagid = NULL;
int skip_p = 0;
int default_p = 0;
- int use_param_p = 0;
const char *fieldlength = NULL;
char *newval;
else if (strcmp (oo->name, "reorder") == 0
&& oo->kind == OPTION_STRING)
d->reorder_fn = oo->info.string;
- else if (strncmp (oo->name, "use_param", 9) == 0
- && (oo->name[9] == '\0' || ISDIGIT (oo->name[9])))
- use_param_p = 1;
else if (strcmp (oo->name, "length") == 0
&& oo->kind == OPTION_STRING)
fieldlength = oo->info.string;
d->used_length = false;
d->in_record_p = !union_p;
- if (union_p && use_param_p && d->param == NULL)
- oprintf (d->of, "%*sgcc_unreachable ();\n", d->indent, "");
- else
- walk_type (f->type, d);
+ walk_type (f->type, d);
d->in_record_p = false;
}
break;
- case TYPE_PARAM_STRUCT:
- {
- type_p *oldparam = d->param;
-
- d->param = t->u.param_struct.param;
- walk_type (t->u.param_struct.stru, d);
- d->param = oldparam;
- }
- break;
-
case TYPE_USER_STRUCT:
d->process_field (t, d);
break;
case TYPE_STRUCT:
case TYPE_UNION:
case TYPE_LANG_STRUCT:
- case TYPE_PARAM_STRUCT:
case TYPE_USER_STRUCT:
if (f->kind == TYPE_USER_STRUCT && !d->in_ptr_field)
{
reference struct S */
static outf_p
-get_output_file_for_structure (const_type_p s, type_p *param)
+get_output_file_for_structure (const_type_p s)
{
const input_file *fn;
- int i;
gcc_assert (union_or_struct_p (s));
fn = s->u.s.line.file;
- /* This is a hack, and not the good kind either. */
- for (i = NUM_PARAM - 1; i >= 0; i--)
- if (param && param[i] && param[i]->kind == TYPE_POINTER
- && union_or_struct_p (param[i]->u.p))
- fn = param[i]->u.p->u.s.line.file;
-
/* The call to get_output_file_with_visibility may update fn by
caching its result inside, so we need the CONST_CAST. */
return get_output_file_with_visibility (CONST_CAST (input_file*, fn));
if (id_for_tag != s->u.s.tag)
free (CONST_CAST (char *, id_for_tag));
}
- else if (s->kind == TYPE_PARAM_STRUCT)
- {
- oprintf (of, "gt_%s_", prefix);
- output_mangled_typename (of, s);
- }
else
gcc_unreachable ();
}
static void
write_user_func_for_structure_ptr (outf_p of, type_p s, const write_types_data *wtd)
{
- /* Parameterized structures are not supported in user markers. There
- is no way for the marker function to know which specific type
- to use to generate the call to the void * entry point. For
- instance, a marker for struct htab may need to call different
- routines to mark the fields, depending on the paramN_is attributes.
-
- A user-defined marker that accepts 'struct htab' as its argument
- would not know which variant to call. Generating several entry
- points accepting 'struct htab' would cause multiply-defined
- errors during compilation. */
gcc_assert (union_or_struct_p (s));
type_p alias_of = NULL;
}
-/* For S, a structure that's part of ORIG_S, and using parameters
- PARAM, write out a routine that:
+/* For S, a structure that's part of ORIG_S 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. */
static void
-write_func_for_structure (type_p orig_s, type_p s, type_p *param,
+write_func_for_structure (type_p orig_s, type_p s,
const struct write_types_data *wtd)
{
const char *chain_next = NULL;
}
memset (&d, 0, sizeof (d));
- d.of = get_output_file_for_structure (s, param);
+ d.of = get_output_file_for_structure (s);
bool for_user = false;
for (opt = s->u.s.opt; opt; opt = opt->next)
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] = "*x";
d.prev_val[1] = "not valid postage"; /* Guarantee an error. */
d.prev_val[3] = "x";
/* Write out marker routines for STRUCTURES and PARAM_STRUCTS. */
static void
-write_types (outf_p output_header, type_p structures, type_p param_structs,
+write_types (outf_p output_header, type_p structures,
const struct write_types_data *wtd)
{
int nbfun = 0; /* Count the emitted functions. */
}
}
- for (s = param_structs; s; s = s->next)
- if (s->gc_used == GC_POINTED_TO)
- {
- type_p stru = s->u.param_struct.stru;
-
- /* Declare the marker procedure. */
- 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)
- {
- fprintf (stderr, "warning: structure `%s' used but not defined\n",
- stru->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)
nbfun++;
DBGPRINTF ("writing func #%d lang_struct ss @ %p '%s'",
nbfun, (void*) ss, ss->u.s.tag);
- write_func_for_structure (s, ss, NULL, wtd);
+ write_func_for_structure (s, ss, wtd);
}
}
else
nbfun++;
DBGPRINTF ("writing func #%d struct s @ %p '%s'",
nbfun, (void*) s, s->u.s.tag);
- write_func_for_structure (s, s, NULL, wtd);
+ write_func_for_structure (s, s, wtd);
}
}
else
(int) s->gc_used);
}
- 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;
- for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
- {
- nbfun++;
- DBGPRINTF ("writing func #%d param lang_struct ss @ %p '%s'",
- nbfun, (void*) ss, ss->u.s.tag);
- write_func_for_structure (s, ss, param, wtd);
- }
- }
- else
- {
- nbfun++;
- DBGPRINTF ("writing func #%d param struct s @ %p stru @ %p '%s'",
- nbfun, (void*) s,
- (void*) stru, stru->u.s.tag);
- write_func_for_structure (s, stru, param, wtd);
- }
- }
- else
- {
- /* Param structure s is not pointed to, so should be ignored. */
- DBGPRINTF ("ignored s @ %p", (void*)s);
- }
if (verbosity_level >= 2)
printf ("%s emitted %d routines for %s\n",
progname, nbfun, wtd->comment);
case TYPE_STRUCT:
case TYPE_UNION:
case TYPE_LANG_STRUCT:
- case TYPE_PARAM_STRUCT:
case TYPE_STRING:
oprintf (d->of, "%*s op (&(%s), cookie);\n", d->indent, "", d->val);
break;
case TYPE_STRUCT:
case TYPE_UNION:
case TYPE_LANG_STRUCT:
- case TYPE_PARAM_STRUCT:
case TYPE_STRING:
oprintf (d->of, "%*sif ((void *)(%s) == this_obj)\n", d->indent, "",
d->prev_val[3]);
*/
static void
-write_local_func_for_structure (const_type_p orig_s, type_p s, type_p *param)
+write_local_func_for_structure (const_type_p orig_s, type_p s)
{
struct walk_type_data d;
return;
memset (&d, 0, sizeof (d));
- d.of = get_output_file_for_structure (s, param);
+ d.of = get_output_file_for_structure (s);
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[3] = "x";
/* Write out local marker routines for STRUCTURES and PARAM_STRUCTS. */
static void
-write_local (outf_p output_header, type_p structures, type_p param_structs)
+write_local (outf_p output_header, type_p structures)
{
type_p s;
{
type_p ss;
for (ss = s->u.s.lang_struct; ss; ss = ss->next)
- write_local_func_for_structure (s, ss, NULL);
- }
- else
- write_local_func_for_structure (s, s, NULL);
- }
-
- 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 (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)
- {
- fprintf (stderr, "warning: structure `%s' used but not defined\n",
- stru->u.s.tag);
- continue;
- }
-
- if (stru->kind == TYPE_LANG_STRUCT)
- {
- type_p ss;
- for (ss = stru->u.s.lang_struct; ss; ss = ss->next)
- write_local_func_for_structure (s, ss, param);
+ write_local_func_for_structure (s, ss);
}
else
- write_local_func_for_structure (s, stru, param);
+ write_local_func_for_structure (s, s);
}
}
}
}
+/* Finish off the created gt_clear_caches_file_c functions. */
+
+static void
+finish_cache_funcs (flist *flp)
+{
+ struct flist *fli2;
+
+ for (fli2 = flp; fli2; fli2 = fli2->next)
+ if (fli2->started_p)
+ {
+ oprintf (fli2->f, "}\n\n");
+ }
+
+ for (fli2 = flp; fli2 && base_files; fli2 = fli2->next)
+ if (fli2->started_p)
+ {
+ lang_bitmap bitmap = get_lang_bitmap (fli2->file);
+ int fnum;
+
+ for (fnum = 0; bitmap != 0; fnum++, bitmap >>= 1)
+ if (bitmap & 1)
+ {
+ oprintf (base_files[fnum], "extern void gt_clear_caches_");
+ put_mangled_filename (base_files[fnum], fli2->file);
+ oprintf (base_files[fnum], " ();\n");
+ }
+ }
+
+ for (size_t fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
+ oprintf (base_files[fnum], "void\ngt_clear_caches ()\n{\n");
+
+ for (fli2 = flp; fli2; fli2 = fli2->next)
+ if (fli2->started_p)
+ {
+ lang_bitmap bitmap = get_lang_bitmap (fli2->file);
+ int fnum;
+
+ fli2->started_p = 0;
+
+ for (fnum = 0; base_files && bitmap != 0; fnum++, bitmap >>= 1)
+ if (bitmap & 1)
+ {
+ oprintf (base_files[fnum], " gt_clear_caches_");
+ put_mangled_filename (base_files[fnum], fli2->file);
+ oprintf (base_files[fnum], " ();\n");
+ }
+ }
+
+ for (size_t fnum = 0; base_files && fnum < num_lang_dirs; fnum++)
+ {
+ 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.
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,
+ int has_length, struct fileloc *line,
bool emit_pch, type_p field_type, const char *field_name)
{
struct pair newv;
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);
+ has_length, line, emit_pch);
}
/* Write out to F the table entry and any marker routines needed to
- 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. */
+ HAS_LENGTH is nonzero iff V was a variable-length array. */
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, bool emit_pch)
+ struct fileloc *line, bool emit_pch)
{
switch (type->kind)
{
else if (strcmp (o->name, "desc") == 0
&& o->kind == OPTION_STRING)
desc = o->info.string;
- else if (strcmp (o->name, "param_is") == 0)
- ;
else
error_at_line (line,
"field `%s' of global `%s' has unknown option `%s'",
validf = ufld;
}
if (validf != NULL)
- write_field_root (f, v, type, name, 0, line, if_marked,
- emit_pch, validf->type,
+ write_field_root (f, v, type, name, 0, line, emit_pch,
+ validf->type,
ACONCAT ((fld->name, ".",
validf->name, NULL)));
}
"global `%s.%s' has `desc' option but is not union",
name, fld->name);
else
- write_field_root (f, v, type, name, 0, line, if_marked,
- emit_pch, fld->type, fld->name);
+ write_field_root (f, v, type, name, 0, line, 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,
- emit_pch);
+ write_root (f, v, type->u.a.p, newname, has_length, line, emit_pch);
free (newname);
}
break;
if (id_for_tag != tp->u.s.tag)
free (CONST_CAST (char *, id_for_tag));
}
- else if (!has_length && tp->kind == TYPE_PARAM_STRUCT)
- {
- oprintf (f, " >_ggc_m_");
- 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)))
{
"global `%s' is pointer to unimplemented type",
name);
}
- if (if_marked)
- oprintf (f, ",\n &%s", if_marked);
oprintf (f, "\n },\n");
}
break;
case TYPE_UNDEFINED:
case TYPE_UNION:
case TYPE_LANG_STRUCT:
- case TYPE_PARAM_STRUCT:
error_at_line (line, "global `%s' is unimplemented type", name);
}
}
d.line = &v->line;
d.opt = v->opt;
d.bitmap = get_lang_bitmap (v->line.file);
- d.param = NULL;
d.prev_val[3] = prevval3 = xasprintf ("&%s", v->name);
length = o->info.string;
else if (strcmp (o->name, "deletable") == 0)
deletable_p = 1;
- else if (strcmp (o->name, "param_is") == 0)
- ;
- else if (strncmp (o->name, "param", 5) == 0
- && ISDIGIT (o->name[5]) && strcmp (o->name + 6, "_is") == 0)
- ;
- else if (strcmp (o->name, "if_marked") == 0)
+ else if (strcmp (o->name, "cache") == 0)
;
else
error_at_line (&v->line,
for (o = v->opt; o; o = o->next)
if (strcmp (o->name, "length") == 0)
length_p = 1;
- else if (strcmp (o->name, "deletable") == 0
- || strcmp (o->name, "if_marked") == 0)
+ else if (strcmp (o->name, "deletable") == 0)
skip_p = 1;
if (skip_p)
oprintf (f, "[] = {\n");
}
- write_root (f, v, v->type, v->name, length_p, &v->line, NULL, emit_pch);
+ write_root (f, v, v->type, v->name, length_p, &v->line, emit_pch);
}
finish_root_table (flp, "ggc_r", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
for (o = v->opt; o; o = o->next)
if (strcmp (o->name, "deletable") == 0)
skip_p = 0;
- else if (strcmp (o->name, "if_marked") == 0)
- skip_p = 1;
if (skip_p)
continue;
outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
v->line.file));
struct flist *fli;
- const char *if_marked = NULL;
- int length_p = 0;
+ bool cache = false;
options_p o;
for (o = v->opt; o; o = o->next)
- if (strcmp (o->name, "length") == 0)
- length_p = 1;
- else if (strcmp (o->name, "if_marked") == 0
- && o->kind == OPTION_STRING)
- if_marked = o->info.string;
- if (if_marked == NULL)
+ if (strcmp (o->name, "cache") == 0)
+ cache = true;
+ if (!cache)
continue;
- if (v->type->kind != TYPE_POINTER
- || v->type->u.p->kind != TYPE_PARAM_STRUCT
- || v->type->u.p->u.param_struct.stru != find_structure ("htab",
- TYPE_STRUCT))
- {
- 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)
{
fli->started_p = 1;
- oprintf (f, "EXPORTED_CONST struct ggc_cache_tab gt_ggc_rc_");
+ oprintf (f, "void\ngt_clear_caches_");
put_mangled_filename (f, v->line.file);
- oprintf (f, "[] = {\n");
+ oprintf (f, " ()\n{\n");
}
- write_root (f, v, v->type->u.p->u.param_struct.param[0],
- v->name, length_p, &v->line, if_marked, emit_pch);
+ oprintf (f, " gt_cleare_cache (%s);\n", v->name);
}
- finish_root_table (flp, "ggc_rc", "LAST_GGC_CACHE_TAB", "ggc_cache_tab",
- "gt_ggc_cache_rtab");
+ finish_cache_funcs (flp);
if (!emit_pch)
return;
- for (v = variables; v; v = v->next)
- {
- outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
- v->line.file));
- struct flist *fli;
- int length_p = 0;
- int if_marked_p = 0;
- options_p o;
-
- for (o = v->opt; o; o = o->next)
- if (strcmp (o->name, "length") == 0)
- length_p = 1;
- else if (strcmp (o->name, "if_marked") == 0)
- if_marked_p = 1;
-
- if (!if_marked_p)
- continue;
-
- for (fli = flp; fli; fli = fli->next)
- if (fli->f == f)
- break;
- if (!fli->started_p)
- {
- fli->started_p = 1;
-
- 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, emit_pch);
- }
-
- finish_root_table (flp, "pch_rc", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
- "gt_pch_cache_rtab");
-
for (v = variables; v; v = v->next)
{
outf_p f = get_output_file_with_visibility (CONST_CAST (input_file*,
options_p o;
for (o = v->opt; o; o = o->next)
- if (strcmp (o->name, "deletable") == 0
- || strcmp (o->name, "if_marked") == 0)
+ if (strcmp (o->name, "deletable") == 0)
{
skip_p = 1;
break;
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;
- }
case TYPE_NONE:
case TYPE_UNDEFINED:
case TYPE_ARRAY:
}
}
-/* Writes a typed GC allocator for type S that is suitable as a callback for
- the splay tree implementation in libiberty. */
-
-static void
-write_splay_tree_allocator_def (const_type_p s)
-{
- outf_p of = get_output_file_with_visibility (NULL);
- oprintf (of, "void * ggc_alloc_splay_tree_");
- output_typename (of, s);
- oprintf (of, " (int sz, void * nl)\n");
- oprintf (of, "{\n");
- oprintf (of, " return ggc_splay_alloc (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);
- }
-}
-
#define INDENT 2
/* Dumps the value of typekind KIND. */
case TYPE_LANG_STRUCT:
printf ("TYPE_LANG_STRUCT");
break;
- case TYPE_PARAM_STRUCT:
- printf ("TYPE_PARAM_STRUCT");
- break;
default:
gcc_unreachable ();
}
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
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 ();
}
{
dump_pair_list ("typedefs", typedefs);
dump_structures ("structures", structures);
- dump_structures ("param_structs", param_structs);
dump_pair_list ("variables", variables);
/* Allocated with the first call to dump_type. */
inputlist, read_state_filename);
read_state (read_state_filename);
DBGPRINT_COUNT_TYPE ("structures after read_state", structures);
- DBGPRINT_COUNT_TYPE ("param_structs after read_state", param_structs);
}
else if (inputlist)
{
progname, (int) num_gt_files, type_count);
DBGPRINT_COUNT_TYPE ("structures after parsing", structures);
- DBGPRINT_COUNT_TYPE ("param_structs after parsing", param_structs);
-
}
else
fatal ("either an input list or a read state file should be given");
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);
for (type_p t = structures; t; t = t->next)
}
if (for_user)
- set_gc_used_type (t, GC_POINTED_TO, NULL);
+ set_gc_used_type (t, GC_POINTED_TO);
}
/* The state at this point is read from the state input file or by
parsing source files and optionally augmented by parsing plugin
if (write_state_filename)
{
DBGPRINT_COUNT_TYPE ("structures before write_state", structures);
- DBGPRINT_COUNT_TYPE ("param_structs before write_state", param_structs);
if (hit_error)
fatal ("didn't write state file %s after errors",
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);
+ write_types (output_header, structures, &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_types (header_file, structures, &pch_wtd);
+ write_local (header_file, structures);
}
- write_splay_tree_allocators (param_structs);
write_roots (variables, plugin_files == NULL);
write_rtx_next ();
close_output_files ();
projects / gcc.git / blobdiff