In gcc/: 2011-05-21 Nicola Pero <nicola.pero@meta-innovation.com>

In gcc/:
2011-05-21  Nicola Pero  <nicola.pero@meta-innovation.com>

	* gengtype.c (walk_type): Implemented "atomic" GTY option.
	* doc/gty.texi (GTY Options): Document "atomic" GTY option.

From-SVN: r173996
This commit is contained in:
Nicola Pero 2011-05-21 13:08:18 +00:00 committed by Nicola Pero
parent 86fa5de4fc
commit 555c377190
3 changed files with 78 additions and 0 deletions

View File

@ -1,3 +1,8 @@
2011-05-21 Nicola Pero <nicola.pero@meta-innovation.com>
* gengtype.c (walk_type): Implemented "atomic" GTY option.
* doc/gty.texi (GTY Options): Document "atomic" GTY option.
2011-05-21 Joseph Myers <joseph@codesourcery.com> 2011-05-21 Joseph Myers <joseph@codesourcery.com>
* opt-read.awk: New. Split out of optc-gen.awk and opth-gen.awk. * opt-read.awk: New. Split out of optc-gen.awk and opth-gen.awk.

View File

@ -383,6 +383,51 @@ could be calculated as follows:
size_t size = sizeof (struct sorted_fields_type) + n * sizeof (tree); size_t size = sizeof (struct sorted_fields_type) + n * sizeof (tree);
@end smallexample @end smallexample
@findex atomic
@item atomic
The @code{atomic} option can only be used with pointers. It informs
the GC machinery that the memory that the pointer points to does not
contain any pointers, and hence it should be treated by the GC and PCH
machinery as an ``atomic'' block of memory that does not need to be
examined when scanning memory for pointers. In particular, the
machinery will not scan that memory for pointers to mark them as
reachable (when marking pointers for GC) or to relocate them (when
writing a PCH file).
The @code{atomic} option differs from the @code{skip} option.
@code{atomic} keeps the memory under Garbage Collection, but makes the
GC ignore the contents of the memory. @code{skip} is more drastic in
that it causes the pointer and the memory to be completely ignored by
the Garbage Collector. So, memory marked as @code{atomic} is
automatically freed when no longer reachable, while memory marked as
@code{skip} is not.
The @code{atomic} option must be used with great care, because all
sorts of problem can occur if used incorrectly, that is, if the memory
the pointer points to does actually contain a pointer.
Here is an example of how to use it:
@smallexample
struct GTY(()) my_struct @{
int number_of_elements;
unsigned int GTY ((atomic)) * elements;
@};
@end smallexample
In this case, @code{elements} is a pointer under GC, and the memory it
points to needs to be allocated using the Garbage Collector, and will
be freed automatically by the Garbage Collector when it is no longer
referenced. But the memory that the pointer points to is an array of
@code{unsigned int} elements, and the GC must not try to scan it to
find pointers to mark or relocate, which is why it is marked with the
@code{atomic} option.
Note that, currently, global variables can not be marked with
@code{atomic}; only fields of a struct can. This is a known
limitation. It would be useful to be able to mark global pointers
with @code{atomic} to make the PCH machinery aware of them so that
they are saved and restored correctly to PCH files.
@findex special @findex special
@item special ("@var{name}") @item special ("@var{name}")

View File

@ -2386,6 +2386,7 @@ walk_type (type_p t, struct walk_type_data *d)
int maybe_undef_p = 0; int maybe_undef_p = 0;
int use_param_num = -1; int use_param_num = -1;
int use_params_p = 0; int use_params_p = 0;
int atomic_p = 0;
options_p oo; options_p oo;
const struct nested_ptr_data *nested_ptr_d = NULL; const struct nested_ptr_data *nested_ptr_d = NULL;
@ -2415,6 +2416,8 @@ walk_type (type_p t, struct walk_type_data *d)
; ;
else if (strcmp (oo->name, "skip") == 0) 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, "default") == 0)
; ;
else if (strcmp (oo->name, "param_is") == 0) else if (strcmp (oo->name, "param_is") == 0)
@ -2480,6 +2483,12 @@ walk_type (type_p t, struct walk_type_data *d)
return; 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) switch (t->kind)
{ {
case TYPE_SCALAR: case TYPE_SCALAR:
@ -2495,6 +2504,25 @@ walk_type (type_p t, struct walk_type_data *d)
break; 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 (!length)
{ {
if (!UNION_OR_STRUCT_P (t->u.p) if (!UNION_OR_STRUCT_P (t->u.p)