mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2025-01-06 12:09:26 +08:00
c59e30ed17
This introduces a new lookup testsuite under libctf, which operates by compiling (with libtool) a "lookup" .c file that uses libctf to analyze some other program, then compiling some number of test object files with CTF and optionally linking them together and running the lookup program on the test object files (or linked test binary), before diffing the result much as run_dump_test does. This lets us test the portions of libctf that are not previously testable, notably the portions that do lookup on linked output and that create dynamic dictionaries and then do lookup on them before writing them out, something that is not tested by the ld-ctf testsuite because the linker never does this. A couple of simple tests are added: one testing the functionality of enum lookups, and one testing that the recently-added commit adding extra paranoia to incomplete type handling doesn't break linking and that the result of the link is an (otherwise-impossible) array of forward type in the shared CTF dict. ChangeLog 2021-01-05 Nick Alcock <nick.alcock@oracle.com> * Makefile.def (libctf): No longer no_check. Checking depends on all-ld. * Makefile.in: Regenerated. libctf/ChangeLog 2021-01-05 Nick Alcock <nick.alcock@oracle.com> * Makefile.am (EXPECT): New. (RUNTEST): Likewise. (RUNTESTFLAGS): Likewise. (CC_FOR_TARGET): Likewise. (check-DEJAGNU): Likewise. (AUTOMAKE_OPTIONS): Add dejagnu. * Makefile.in: Regenerated. * testsuite/config/default.exp: New. * testsuite/lib/ctf-lib.exp: Likewise. * testsuite/libctf-lookup/enum.lk: New test. * testsuite/libctf-lookup/enum-ctf.c: New CTF input. * testsuite/libctf-lookup/enum.c: New lookup test. * testsuite/libctf-lookup/ambiguous-struct*.c: New test. * testsuite/libctf-lookup/lookup.exp: New.
79 lines
1.8 KiB
C
79 lines
1.8 KiB
C
#include <ctf-api.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
static int
|
|
print_enum (const char *name, int val, void *unused)
|
|
{
|
|
printf ("iter test: %s has value %i\n", name, val);
|
|
return 0;
|
|
}
|
|
|
|
int
|
|
main (int argc, char *argv[])
|
|
{
|
|
ctf_dict_t *fp;
|
|
ctf_archive_t *ctf;
|
|
ctf_id_t type;
|
|
const char *name;
|
|
ctf_next_t *i = NULL;
|
|
int val;
|
|
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;
|
|
|
|
/* Try getting some enum values by hand. */
|
|
|
|
if ((type = ctf_lookup_by_name (fp, "enum e") ) == CTF_ERR)
|
|
goto err;
|
|
if (ctf_enum_value (fp, type, "ENUMSAMPLE_1", &val) < 0)
|
|
goto err;
|
|
printf ("Enum e enumerand ENUMSAMPLE_1 has value %i\n", val);
|
|
|
|
if ((name = ctf_enum_name (fp, type, 1)) == NULL)
|
|
goto err;
|
|
printf ("Enum e enumerand %s has value 1\n", name);
|
|
|
|
/* Try getting some values using both sorts of iterator. */
|
|
|
|
if ((type = ctf_lookup_by_name (fp, "enum ie") ) == CTF_ERR)
|
|
goto err;
|
|
|
|
if ((ctf_enum_iter (fp, type, print_enum, NULL)) < 0)
|
|
goto ierr;
|
|
|
|
while ((name = ctf_enum_next (fp, type, &i, &val)) != NULL)
|
|
{
|
|
printf ("next test: %s has value %i\n", name, val);
|
|
}
|
|
if (ctf_errno (fp) != ECTF_NEXT_END)
|
|
goto nerr;
|
|
|
|
ctf_dict_close (fp);
|
|
ctf_close (ctf);
|
|
|
|
return 0;
|
|
|
|
open_err:
|
|
fprintf (stderr, "%s: cannot open: %s\n", argv[0], ctf_errmsg (err));
|
|
return 1;
|
|
err:
|
|
fprintf (stderr, "Lookup failed: %s\n", ctf_errmsg (ctf_errno (fp)));
|
|
return 1;
|
|
ierr:
|
|
fprintf (stderr, "_iter iteration failed: %s\n", ctf_errmsg (ctf_errno (fp)));
|
|
return 1;
|
|
nerr:
|
|
fprintf (stderr, "_next iteration failed: %s\n", ctf_errmsg (ctf_errno (fp)));
|
|
return 1;
|
|
}
|