mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-12-05 15:15:42 +00:00
83e8a5d39b
Slices had a bunch of horrible usability problems. In particular, while towers of cv-quals are resolved away by functions that need to do it, towers of cv-quals with slices in the middle are not resolved away by functions like ctf_enum_value that can see through slices: resolving volatile -> slice -> const -> enum will leave it with a 'const', which will error pointlessly, annoying callers, who reasonably expect slices to be more invisible than this. (The user-callable ctf_type_resolve still does not resolve away slices, because this is the only way users can see that the slices are there at all.) This is induced by a fix for another wart: ctf_add_enumerator does not resolve anything away at all, so you can't even add enumerators to const or volatile enums -- and more problematically, you can't add enumerators to enums with an explicit encoding without resolving away the types by hand, since ctf_add_enum_encoded works by returning a slice! ctf_add_enumerator now resolves away all of those, so any cvr-or-typedef-or-slice-qual terminating in an enum can be added to, exactly as callers likely expect. (New tests added.) libctf/ * ctf-create.c (ctf_add_enumerator): Resolve away cvr-qualness. * ctf-types.c (ctf_type_resolve_unsliced): Don't terminate at the first slice. * testsuite/libctf-writable/slice-of-slice.*: New test.
78 lines
1.8 KiB
C
78 lines
1.8 KiB
C
/* Make sure that slices of slices are properly resolved. If they're not, both
|
|
population and lookup will fail. */
|
|
|
|
#include <ctf-api.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
int main (void)
|
|
{
|
|
ctf_dict_t *fp;
|
|
ctf_id_t base;
|
|
ctf_id_t slice;
|
|
ctf_id_t slice2;
|
|
ctf_encoding_t long_encoding = { CTF_INT_SIGNED, 0, sizeof (long) };
|
|
ctf_encoding_t foo;
|
|
int val;
|
|
int err;
|
|
|
|
if ((fp = ctf_create (&err)) == NULL)
|
|
{
|
|
fprintf (stderr, "Cannot create: %s\n", ctf_errmsg (err));
|
|
return 1;
|
|
}
|
|
|
|
if ((base = ctf_add_enum_encoded (fp, CTF_ADD_ROOT, "enom", &long_encoding))
|
|
== CTF_ERR)
|
|
goto err;
|
|
|
|
if (ctf_add_enumerator (fp, base, "a", 1) < 0 ||
|
|
ctf_add_enumerator (fp, base, "b", 0) < 0)
|
|
goto err;
|
|
|
|
foo.cte_format = 0;
|
|
foo.cte_bits = 4;
|
|
foo.cte_offset = 4;
|
|
if ((slice = ctf_add_slice (fp, CTF_ADD_ROOT, base, &foo)) == CTF_ERR)
|
|
goto err;
|
|
|
|
foo.cte_bits = 6;
|
|
foo.cte_offset = 2;
|
|
if ((slice2 = ctf_add_slice (fp, CTF_ADD_ROOT, slice, &foo)) == CTF_ERR)
|
|
goto err;
|
|
|
|
if (ctf_add_variable (fp, "foo", slice) < 0)
|
|
goto err;
|
|
|
|
if (ctf_enum_value (fp, slice, "a", &val) < 0)
|
|
{
|
|
fprintf (stderr, "Cannot look up value of sliced enum: %s\n", ctf_errmsg (ctf_errno (fp)));
|
|
return 1;
|
|
}
|
|
if (val != 1)
|
|
{
|
|
fprintf (stderr, "sliced enum value is wrong\n");
|
|
return 1;
|
|
}
|
|
|
|
if (ctf_enum_value (fp, slice2, "b", &val) < 0)
|
|
{
|
|
fprintf (stderr, "Cannot look up value of sliced sliced enum: %s\n", ctf_errmsg (ctf_errno (fp)));
|
|
return 1;
|
|
}
|
|
if (val != 0)
|
|
{
|
|
fprintf (stderr, "sliced sliced enum value is wrong\n");
|
|
return 1;
|
|
}
|
|
|
|
ctf_dict_close (fp);
|
|
fprintf (stderr, "All done.\n");
|
|
return 0;
|
|
|
|
err:
|
|
fprintf (stderr, "cannot populate: %s\n", ctf_errmsg (ctf_errno (fp)));
|
|
return 1;
|
|
}
|