libctf: fix slices of slices and of enums

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.

1 files changed, 77 insertions, 0 deletions

diff --git a/libctf/testsuite/libctf-writable/slice-of-slice.c b/libctf/testsuite/libctf-writable/slice-of-slice.c
new file mode 100644
index 0000000..9bacfe2
--- /dev/null
+++ b/libctf/testsuite/libctf-writable/slice-of-slice.c
@@ -0,0 +1,77 @@
+/* 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;
+}