along with GCC; see the file COPYING3. If not see
<http://www.gnu.org/licenses/>. */
+#ifdef GENERATOR_FILE
#include "bconfig.h"
+#else
+#include "config.h"
+#endif
#include "system.h"
#include "errors.h" /* for fatal */
#include "getopt.h"
{
case NOTE_INSN_MAX:
case NOTE_INSN_DELETED_LABEL:
+ case NOTE_INSN_DELETED_DEBUG_LABEL:
note_flds = create_field (note_flds, &string_type, "rt_str");
break;
"optabs.h", "libfuncs.h", "debug.h", "ggc.h", "cgraph.h",
"tree-flow.h", "reload.h", "cpp-id-data.h", "tree-chrec.h",
"cfglayout.h", "except.h", "output.h", "gimple.h", "cfgloop.h",
- "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h", NULL
+ "target.h", "ipa-prop.h", "lto-streamer.h", "target-globals.h",
+ "ipa-inline.h", "dwarf2out.h", NULL
};
const char *const *ifp;
outf_p gtype_desc_c;
REG_EXTENDED, NULL_REGEX,
"gt-objc-objc-act.h", "objc/objc-act.c", NULL_FRULACT },
+ /* objc/objc-map.h gives gt-objc-objc-map.h for objc/objc-map.c ! */
+ { DIR_PREFIX_REGEX "objc/objc-map\\.h$",
+ REG_EXTENDED, NULL_REGEX,
+ "gt-objc-objc-map.h", "objc/objc-map.c", NULL_FRULACT },
+
/* General cases. For header *.h and source *.c files, we need
* special actions to handle the language. */
obstack_1grow (&str_obstack, '\0');
rawstr = XOBFINISH (&str_obstack, char *);
str = xstrdup (rawstr);
- obstack_free (&str_obstack, rawstr);
+ obstack_free (&str_obstack, NULL);
DBGPRINTF ("matched replacement %s", str);
rawstr = NULL;
return str;
/* An output file, suitable for definitions, that can see declarations
made in INPF and is linked into every language that uses INPF.
- Since the the result is cached inside INPF, that argument cannot be
+ Since the result is cached inside INPF, that argument cannot be
declared constant, but is "almost" constant. */
outf_p
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;
;
else if (strcmp (oo->name, "skip") == 0)
;
+ else if (strcmp (oo->name, "atomic") == 0)
+ atomic_p = 1;
else if (strcmp (oo->name, "default") == 0)
;
else if (strcmp (oo->name, "param_is") == 0)
return;
}
+ if (atomic_p && (t->kind != TYPE_POINTER))
+ {
+ error_at_line (d->line, "field `%s' has invalid option `atomic'\n", d->val);
+ return;
+ }
+
switch (t->kind)
{
case TYPE_SCALAR:
break;
}
+ /* If a pointer type is marked as "atomic", we process the
+ field itself, but we don't walk the data that they point to.
+
+ There are two main cases where we walk types: to mark
+ pointers that are reachable, and to relocate pointers when
+ writing a PCH file. In both cases, an atomic pointer is
+ itself marked or relocated, but the memory that it points
+ to is left untouched. In the case of PCH, that memory will
+ be read/written unchanged to the PCH file. */
+ if (atomic_p)
+ {
+ oprintf (d->of, "%*sif (%s != NULL) {\n", d->indent, "", d->val);
+ d->indent += 2;
+ d->process_field (t, d);
+ d->indent -= 2;
+ oprintf (d->of, "%*s}\n", d->indent, "");
+ break;
+ }
+
if (!length)
{
if (!UNION_OR_STRUCT_P (t->u.p)
int has_length, struct fileloc *line, const char *if_marked,
bool emit_pch, type_p field_type, const char *field_name)
{
+ struct pair newv;
/* 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));
finish_root_table (flp, "pch_rs", "LAST_GGC_ROOT_TAB", "ggc_root_tab",
"gt_pch_scalar_rtab");
}
+/* Record the definition of the vec_prefix structure, as defined in vec.h:
+
+ struct vec_prefix GTY(()) {
+ unsigned num;
+ unsigned alloc;
+ }; */
+static type_p
+vec_prefix_type (void)
+{
+ static type_p prefix_type = NULL;
+ if (prefix_type == NULL)
+ {
+ pair_p fields;
+ static struct fileloc pos = { NULL, 0 };
+ type_p len_ty = create_scalar_type ("unsigned");
+ pos.file = input_file_by_name (__FILE__); pos.line = __LINE__;
+ fields = create_field_at (0, len_ty, "alloc", 0, &pos);
+ fields = create_field_at (fields, len_ty, "num", 0, &pos);
+ prefix_type = new_structure ("vec_prefix", 0, &pos, fields, 0);
+ prefix_type->u.s.bitmap = -1;
+ }
+ return prefix_type;
+}
/* Record the definition of a generic VEC structure, as if we had expanded
the macros in vec.h:
typedef struct VEC_<type>_base GTY(()) {
- unsigned num;
- unsigned alloc;
- <type> GTY((length ("%h.num"))) vec[1];
+ struct vec_prefix prefix;
+ <type> GTY((length ("%h.prefix.num"))) vec[1];
} VEC_<type>_base
where the GTY(()) tags are only present if is_scalar is _false_. */
pair_p fields;
type_p t;
options_p o;
- type_p len_ty = create_scalar_type ("unsigned");
const char *name = concat ("VEC_", type_name, "_base", (char *) 0);
if (is_scalar)
else
{
t = resolve_typedef (type_name, pos);
- o = create_string_option (0, "length", "%h.num");
+ o = create_string_option (0, "length", "%h.prefix.num");
}
/* We assemble the field list in reverse order. */
fields = create_field_at (0, create_array (t, "1"), "vec", o, pos);
- fields = create_field_at (fields, len_ty, "alloc", 0, pos);
- fields = create_field_at (fields, len_ty, "num", 0, pos);
+ fields = create_field_at (fields, vec_prefix_type (), "prefix", 0, pos);
do_typedef (name, new_structure (name, 0, pos, fields, 0), pos);
}
enum alloc_quantity quantity,
enum alloc_zone zone)
{
+ gcc_assert (UNION_OR_STRUCT_P (s));
write_typed_alloc_def (f, variable_size_p (s), get_type_specifier (s),
s->u.s.tag, allocator_type, quantity, zone);
}
{
if (!USED_BY_TYPED_GC_P (s))
continue;
+ gcc_assert (UNION_OR_STRUCT_P (s));
+ /* In plugin mode onput output ggc_alloc macro definitions
+ relevant to plugin input files. */
+ if (nb_plugin_files > 0
+ && ((s->u.s.line.file == NULL) || !s->u.s.line.file->inpisplugin))
+ continue;
write_typed_struct_alloc_def (f, s, "", single, any_zone);
write_typed_struct_alloc_def (f, s, "cleared_", single, any_zone);
write_typed_struct_alloc_def (f, s, "vec_", vector, any_zone);
s = p->type;
if (!USED_BY_TYPED_GC_P (s) || (strcmp (p->name, s->u.s.tag) == 0))
continue;
+ /* In plugin mode onput output ggc_alloc macro definitions
+ relevant to plugin input files. */
+ if (nb_plugin_files > 0)
+ {
+ struct fileloc* filoc = type_fileloc(s);
+ if (!filoc || !filoc->file->inpisplugin)
+ continue;
+ };
write_typed_typedef_alloc_def (f, p, "", single, any_zone);
write_typed_typedef_alloc_def (f, p, "cleared_", single, any_zone);
write_typed_typedef_alloc_def (f, p, "vec_", vector, any_zone);
f = XCNEWVAR (input_file, sizeof (input_file)+namlen+2);
f->inpbitmap = 0;
f->inpoutf = NULL;
+ f->inpisplugin = false;
strcpy (f->inpname, name);
slot = htab_find_slot (input_file_htab, f, INSERT);
gcc_assert (slot != NULL);
/* Parse our plugin files and augment the state. */
for (ix = 0; ix < nb_plugin_files; ix++)
- parse_file (get_input_file_name (plugin_files[ix]));
-
+ {
+ input_file* pluginput = plugin_files [ix];
+ pluginput->inpisplugin = true;
+ parse_file (get_input_file_name (pluginput));
+ }
if (hit_error)
return 1;
OSDN Git Service
