* [binutils-gdb] libctf: add rewriting tests
@ 2024-04-19 15:52 Nick Alcock
0 siblings, 0 replies; only message in thread
From: Nick Alcock @ 2024-04-19 15:52 UTC (permalink / raw)
To: binutils-cvs
https://sourceware.org/git/gitweb.cgi?p=binutils-gdb.git;h=3b5e2d0e8d55fd61c8b0f7aaf61b6b097654a5c1
commit 3b5e2d0e8d55fd61c8b0f7aaf61b6b097654a5c1
Author: Nick Alcock <nick.alcock@oracle.com>
Date: Tue Apr 2 16:13:46 2024 +0100
libctf: add rewriting tests
Now there's a chance of it actually working, we can add more tests for
the long-broken dict read-and-rewrite cases. This is the first ever
test for the (rarely-used, unpleasant, and until recently completely
broken) ctf_gzwrite function.
libctf/
* testsuite/libctf-regression/gzrewrite*: New test.
* testsuite/libctf-regression/zrewrite*: Likewise.
Diff:
---
libctf/testsuite/libctf-regression/gzrewrite-ctf.c | 19 +++
libctf/testsuite/libctf-regression/gzrewrite.c | 165 +++++++++++++++++++++
libctf/testsuite/libctf-regression/gzrewrite.lk | 3 +
libctf/testsuite/libctf-regression/zrewrite.c | 156 +++++++++++++++++++
libctf/testsuite/libctf-regression/zrewrite.lk | 3 +
5 files changed, 346 insertions(+)
diff --git a/libctf/testsuite/libctf-regression/gzrewrite-ctf.c b/libctf/testsuite/libctf-regression/gzrewrite-ctf.c
new file mode 100644
index 00000000000..b5d483ea1cb
--- /dev/null
+++ b/libctf/testsuite/libctf-regression/gzrewrite-ctf.c
@@ -0,0 +1,19 @@
+int an_int;
+char *a_char_ptr;
+typedef int (*a_typedef) (int main);
+struct struct_forward;
+enum enum_forward;
+union union_forward;
+typedef int an_array[50];
+struct a_struct { int foo; };
+union a_union { int bar; };
+enum an_enum { FOO };
+
+a_typedef a;
+struct struct_forward *x;
+union union_forward *y;
+enum enum_forward *z;
+struct a_struct *xx;
+union a_union *yy;
+enum an_enum *zz;
+an_array ar;
diff --git a/libctf/testsuite/libctf-regression/gzrewrite.c b/libctf/testsuite/libctf-regression/gzrewrite.c
new file mode 100644
index 00000000000..8e279ca3fac
--- /dev/null
+++ b/libctf/testsuite/libctf-regression/gzrewrite.c
@@ -0,0 +1,165 @@
+/* Make sure that you can modify then ctf_gzwrite() a dict
+ and it changes after modification. */
+
+#include <ctf-api.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <zlib.h>
+
+char *read_gz(const char *path, size_t *len)
+{
+ char *in = NULL;
+ char buf[4096];
+ gzFile foo;
+ size_t ret;
+
+ if ((foo = gzopen (path, "rb")) == NULL)
+ return NULL;
+
+ *len = 0;
+ while ((ret = gzread (foo, buf, 4096)) > 0)
+ {
+ if ((in = realloc (in, *len + ret)) == NULL)
+ {
+ fprintf (stderr, "Out of memory\n");
+ exit (1);
+ }
+
+ memcpy (&in[*len], buf, ret);
+ *len += ret;
+ }
+ if (ret < 0)
+ {
+ int errnum;
+ const char *err;
+ err = gzerror (foo, &errnum);
+ if (errnum != Z_ERRNO)
+ fprintf (stderr, "error reading %s: %s\n", path, err);
+ else
+ fprintf (stderr, "error reading %s: %s\n", path, strerror(errno));
+ exit (1);
+ }
+ gzclose (foo);
+ return in;
+}
+
+int
+main (int argc, char *argv[])
+{
+ ctf_dict_t *fp, *fp_b;
+ ctf_archive_t *ctf;
+ gzFile foo;
+ char *a, *b;
+ size_t a_len, b_len;
+ ctf_id_t type, ptrtype;
+ int err;
+
+ if (argc != 2)
+ {
+ fprintf (stderr, "Syntax: %s PROGRAM\n", argv[0]);
+ exit(1);
+ }
+
+ if ((ctf = ctf_open (argv[1], NULL, &err)) == NULL)
+ goto open_err;
+ if ((fp = ctf_dict_open (ctf, NULL, &err)) == NULL)
+ goto open_err;
+
+ if ((foo = gzopen ("tmpdir/one.gz", "wb")) == NULL)
+ goto write_gzerr;
+ if (ctf_gzwrite (fp, foo) < 0)
+ goto write_err;
+ gzclose (foo);
+
+ if ((foo = gzopen ("tmpdir/two.gz", "wb")) == NULL)
+ goto write_gzerr;
+ if (ctf_gzwrite (fp, foo) < 0)
+ goto write_err;
+ gzclose (foo);
+
+ if ((a = read_gz ("tmpdir/one.gz", &a_len)) == NULL)
+ goto read_err;
+
+ if ((b = read_gz ("tmpdir/two.gz", &b_len)) == NULL)
+ goto read_err;
+
+ if (a_len != b_len || memcmp (a, b, a_len) != 0)
+ {
+ fprintf (stderr, "consecutive gzwrites are different: lengths %i and %i\n", a_len, b_len);
+ return 1;
+ }
+
+ free (b);
+
+ /* Add some new types to the dict and write it out, then read it back in and
+ make sure they're still there, and that at least some of the
+ originally-present data objects are still there too. */
+
+ if ((type = ctf_lookup_by_name (fp, "struct a_struct")) == CTF_ERR)
+ fprintf (stderr, "Lookup of struct a_struct failed: %s\n", ctf_errmsg (ctf_errno (fp)));
+
+ if ((ptrtype = ctf_add_pointer (fp, CTF_ADD_ROOT, type)) == CTF_ERR)
+ fprintf (stderr, "Cannot add pointer to ctf_opened dict: %s\n", ctf_errmsg (ctf_errno (fp)));
+
+ unlink ("tmpdir/two.gz");
+ if ((foo = gzopen ("tmpdir/two.gz", "wb")) == NULL)
+ goto write_gzerr;
+ if (ctf_gzwrite (fp, foo) < 0)
+ goto write_err;
+ gzclose (foo);
+
+ if ((b = read_gz ("tmpdir/two.gz", &b_len)) == NULL)
+ goto read_err;
+
+ if (memcmp (a, b, b_len) == 0)
+ {
+ fprintf (stderr, "gzwrites after adding types does not change the dict\n");
+ return 1;
+ }
+
+ free (a);
+ if ((fp_b = ctf_simple_open (b, b_len, NULL, 0, 0, NULL, 0, &err)) == NULL)
+ goto open_err;
+
+ if (ctf_type_reference (fp_b, ptrtype) == CTF_ERR)
+ fprintf (stderr, "Lookup of pointer preserved across writeout failed: %s\n", ctf_errmsg (ctf_errno (fp_b)));
+
+ if (ctf_type_reference (fp_b, ptrtype) != type)
+ fprintf (stderr, "Look up of newly-added type in serialized dict yields ID %lx, expected %lx\n", ctf_type_reference (fp_b, ptrtype), type);
+
+ if (ctf_lookup_by_symbol_name (fp_b, "an_int") == CTF_ERR)
+ fprintf (stderr, "Lookup of symbol an_int failed: %s\n", ctf_errmsg (ctf_errno (fp_b)));
+
+ free (b);
+ ctf_dict_close (fp);
+ ctf_dict_close (fp_b);
+ ctf_close (ctf);
+
+ printf ("All done.\n");
+ return 0;
+
+ open_err:
+ fprintf (stderr, "%s: cannot open: %s\n", argv[0], ctf_errmsg (err));
+ return 1;
+ write_err:
+ fprintf (stderr, "%s: cannot write: %s\n", argv[0], ctf_errmsg (ctf_errno (fp)));
+ return 1;
+ write_gzerr:
+ {
+ int errnum;
+ const char *err;
+
+ err = gzerror (foo, &errnum);
+ if (errnum != Z_ERRNO)
+ fprintf (stderr, "error gzwriting: %s\n", err);
+ else
+ fprintf (stderr, "error gzwriting: %s\n", strerror(errno));
+ return 1;
+ }
+ read_err:
+ fprintf (stderr, "%s: cannot read\n", argv[0]);
+ return 1;
+}
diff --git a/libctf/testsuite/libctf-regression/gzrewrite.lk b/libctf/testsuite/libctf-regression/gzrewrite.lk
new file mode 100644
index 00000000000..2d0de3dc464
--- /dev/null
+++ b/libctf/testsuite/libctf-regression/gzrewrite.lk
@@ -0,0 +1,3 @@
+# source: gzrewrite-ctf.c
+# lookup: gzrewrite.c
+All done.
diff --git a/libctf/testsuite/libctf-regression/zrewrite.c b/libctf/testsuite/libctf-regression/zrewrite.c
new file mode 100644
index 00000000000..4d5d15e7985
--- /dev/null
+++ b/libctf/testsuite/libctf-regression/zrewrite.c
@@ -0,0 +1,156 @@
+/* Make sure that you can modify then ctf_compress_write() a dict
+ and it changes after modification. */
+
+#include <ctf-api.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+
+char *read_file(const char *path, size_t *len)
+{
+ char *in = NULL;
+ char buf[4096];
+ int foo;
+ size_t ret;
+
+ if ((foo = open (path, O_RDONLY)) < 0)
+ {
+ fprintf (stderr, "error opening %s: %s\n", path, strerror(errno));
+ exit (1);
+ }
+
+ *len = 0;
+ while ((ret = read (foo, buf, 4096)) > 0)
+ {
+ if ((in = realloc (in, *len + ret)) == NULL)
+ {
+ fprintf (stderr, "Out of memory\n");
+ exit (1);
+ }
+
+ memcpy (&in[*len], buf, ret);
+ *len += ret;
+ }
+
+ if (ret < 0)
+ {
+ fprintf (stderr, "error reading %s: %s\n", path, strerror(errno));
+ exit (1);
+ }
+ close (foo);
+ return in;
+}
+
+int
+main (int argc, char *argv[])
+{
+ ctf_dict_t *fp, *fp_b;
+ ctf_archive_t *ctf, *ctf_b;
+ int foo;
+ char *a, *b;
+ size_t a_len, b_len;
+ ctf_id_t type, ptrtype;
+ int err;
+
+ if (argc != 2)
+ {
+ fprintf (stderr, "Syntax: %s PROGRAM\n", argv[0]);
+ exit(1);
+ }
+
+ if ((ctf = ctf_open (argv[1], NULL, &err)) == NULL)
+ goto open_err;
+ if ((fp = ctf_dict_open (ctf, NULL, &err)) == NULL)
+ goto open_err;
+
+ if ((foo = open ("tmpdir/one", O_CREAT | O_TRUNC | O_WRONLY, 0666)) < 0)
+ goto write_stderr;
+ if (ctf_compress_write (fp, foo) < 0)
+ goto write_err;
+ close (foo);
+
+ if ((foo = open ("tmpdir/two", O_CREAT | O_TRUNC | O_WRONLY, 0666)) < 0)
+ goto write_stderr;
+ if (ctf_compress_write (fp, foo) < 0)
+ goto write_err;
+ close (foo);
+
+ a = read_file ("tmpdir/one", &a_len);
+ b = read_file ("tmpdir/two", &b_len);
+
+ if (a_len != b_len || memcmp (a, b, a_len) != 0)
+ {
+ fprintf (stderr, "consecutive compress_writes are different: lengths %i and %i\n", a_len, b_len);
+ return 1;
+ }
+
+ free (b);
+
+ /* Add some new types to the dict and write it out, then read it back in and
+ make sure they're still there, and that at least some of the
+ originally-present data objects are still there too. */
+
+ if ((type = ctf_lookup_by_name (fp, "struct a_struct")) == CTF_ERR)
+ fprintf (stderr, "Lookup of struct a_struct failed: %s\n", ctf_errmsg (ctf_errno (fp)));
+
+ if ((ptrtype = ctf_add_pointer (fp, CTF_ADD_ROOT, type)) == CTF_ERR)
+ fprintf (stderr, "Cannot add pointer to ctf_opened dict: %s\n", ctf_errmsg (ctf_errno (fp)));
+
+ unlink ("tmpdir/two");
+
+ if ((foo = open ("tmpdir/two", O_CREAT | O_TRUNC | O_WRONLY, 0666)) < 0)
+ goto write_stderr;
+ if (ctf_compress_write (fp, foo) < 0)
+ goto write_err;
+ close (foo);
+
+ b = read_file ("tmpdir/two", &b_len);
+
+ if (memcmp (a, b, b_len) == 0)
+ {
+ fprintf (stderr, "compress_writes after adding types does not change the dict\n");
+ return 1;
+ }
+
+ free (a);
+ free (b);
+
+ if ((ctf_b = ctf_open ("tmpdir/two", NULL, &err)) == NULL)
+ goto open_err;
+ if ((fp_b = ctf_dict_open (ctf_b, NULL, &err)) == NULL)
+ goto open_err;
+
+ if (ctf_type_reference (fp_b, ptrtype) == CTF_ERR)
+ fprintf (stderr, "Lookup of pointer preserved across writeout failed: %s\n", ctf_errmsg (ctf_errno (fp_b)));
+
+ if (ctf_type_reference (fp_b, ptrtype) != type)
+ fprintf (stderr, "Look up of newly-added type in serialized dict yields ID %lx, expected %lx\n", ctf_type_reference (fp_b, ptrtype), type);
+
+ if (ctf_lookup_by_symbol_name (fp_b, "an_int") == CTF_ERR)
+ fprintf (stderr, "Lookup of symbol an_int failed: %s\n", ctf_errmsg (ctf_errno (fp_b)));
+
+ ctf_dict_close (fp);
+ ctf_close (ctf);
+
+ ctf_dict_close (fp_b);
+ ctf_close (ctf_b);
+
+ printf ("All done.\n");
+ return 0;
+
+ open_err:
+ fprintf (stderr, "%s: cannot open: %s\n", argv[0], ctf_errmsg (err));
+ return 1;
+ write_err:
+ fprintf (stderr, "%s: cannot write: %s\n", argv[0], ctf_errmsg (ctf_errno (fp)));
+ return 1;
+ write_stderr:
+ fprintf (stderr, "%s: cannot open for writing: %s\n", argv[0], strerror (errno));
+ return 1;
+ read_err:
+ fprintf (stderr, "%s: cannot read\n", argv[0]);
+ return 1;
+}
diff --git a/libctf/testsuite/libctf-regression/zrewrite.lk b/libctf/testsuite/libctf-regression/zrewrite.lk
new file mode 100644
index 00000000000..a0a53d91a04
--- /dev/null
+++ b/libctf/testsuite/libctf-regression/zrewrite.lk
@@ -0,0 +1,3 @@
+# source: gzrewrite-ctf.c
+# lookup: zrewrite.c
+All done.
^ permalink raw reply [flat|nested] only message in thread
only message in thread, other threads:[~2024-04-19 15:52 UTC | newest]
Thread overview: (only message) (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2024-04-19 15:52 [binutils-gdb] libctf: add rewriting tests Nick Alcock
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).