Toolchain/binutils-gdb
1
0
Fork 0
forked from Imagelibrary/binutils-gdb
Code Pull Requests Activity

Revert "libctf: fix linking of non-root-visible types"

Browse Source 
This reverts commit 87b2f67310.

It is based on a misconception, that hidden types in the deduplicator
input should always be hidden in the output.  For cu-mapped links,
and final links following cu-mapped links, this is not true: we want
to hide inputs if they were conflicting on the output and no more.

We will reintroduce the testcase once a better fix is found.

libctf/
	PR libctf/33047
	* ctf-dedup.c (ctf_dedup_emit_type): Don't respect the nonroot flag.
	* testsuite/libctf-writable/ctf-nonroot-linking.c: Removed.
	* testsuite/libctf-writable/ctf-nonroot-linking.lk: Removed.
This commit is contained in:
Nick Alcock
2025-05-30 15:31:36 +01:00
parent 4bdc7aed03
commit 13c3c2087a
3 changed files with 2 additions and 136 deletions
Download Patch File Download Diff File Expand all files Collapse all files

127
libctf/testsuite/libctf-writable/ctf-nonroot-linking.c
View File

@@ -1,127 +0,0 @@
/* Make sure linking a non-root-visible type emits a non-root-visible
type, rather than silently promoting it to root-visible. Do it by dumping,
thus also testing the {non-root sigils} you get when dumping
non-root-visible types. */
#include <ctf-api.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int
main (int argc, char *argv[])
{
ctf_dict_t *in1;
ctf_dict_t *fp;
ctf_dict_t *dump_fp;
ctf_archive_t *arc1;
ctf_archive_t *final_arc;
ctf_sect_t s;
ctf_encoding_t encoding = { CTF_INT_SIGNED, 0, sizeof (char) };
unsigned char *buf1, *buf2;
size_t buf1_sz, buf2_sz;
ctf_dump_state_t *dump_state = NULL;
ctf_next_t *i = NULL;
int err;
/* Linking does not currently work on mingw because of an unreliable tmpfile
implementation on that platform (see
https://github.com/msys2/MINGW-packages/issues/18878). Simply skip for
now. */
#ifdef __MINGW32__
printf ("UNSUPPORTED: platform bug breaks ctf_link\n");
return 0;
#else
if ((fp = ctf_create (&err)) == NULL)
goto create_err;
if ((in1 = ctf_create (&err)) == NULL)
goto create_err;
/* A non-root addition. */
if ((ctf_add_integer (in1, CTF_ADD_NONROOT, "foo", &encoding)) == CTF_ERR)
{
fprintf (stderr, "Cannot add: %s\n", ctf_errmsg (ctf_errno (in1)));
return 1;
}
/* Write it out and read it back in, to turn it into an archive.
This would be unnecessary if ctf_link_add() were public :( */
if ((buf1 = ctf_write_mem (in1, &buf1_sz, -1)) == NULL)
{
fprintf (stderr, "Cannot serialize: %s\n", ctf_errmsg (ctf_errno (in1)));
return 1;
}
s.cts_name = "foo";
s.cts_data = (void *) buf1;
s.cts_size = buf1_sz;
s.cts_entsize = 64; /* Unimportant. */
if ((arc1 = ctf_arc_bufopen (&s, NULL, NULL, &err)) == NULL)
goto open_err;
ctf_dict_close (in1);
/* Link! Even a one-file link does deduplication. */
if (ctf_link_add_ctf (fp, arc1, "a") < 0)
goto link_err;
if (ctf_link (fp, 0) < 0)
goto link_err;
/* Write it out. We need a new buf here, because the archive is still
using the other buf. */
if ((buf2 = ctf_link_write (fp, &buf2_sz, 4096)) == NULL)
goto link_err;
/* Read it back in. */
s.cts_data = (void *) buf2;
s.cts_size = buf2_sz;
if ((final_arc = ctf_arc_bufopen (&s, NULL, NULL, &err)) == NULL)
goto open_err;
/* Dump the types, and search for the {sigils of non-rootedness}. */
while ((dump_fp = ctf_archive_next (final_arc, &i, NULL, 0, &err)) != NULL)
{
char *dumpstr;
while ((dumpstr = ctf_dump (dump_fp, &dump_state, CTF_SECT_TYPE,
NULL, NULL)) != NULL)
{
if (strchr (dumpstr, '{') != NULL && strchr (dumpstr, '}') != NULL)
printf ("Non-root type found.\n");
free (dumpstr);
}
ctf_dict_close (dump_fp);
}
if (err != ECTF_NEXT_END)
{
fprintf (stderr, "Archive iteration error: %s\n", ctf_errmsg (err));
return 1;
}
ctf_arc_close (final_arc);
free (buf1);
free (buf2);
ctf_dict_close (fp);
return 0;
create_err:
fprintf (stderr, "Cannot create: %s\n", ctf_errmsg (err));
return 1;
open_err:
fprintf (stderr, "Cannot open: %s\n", ctf_errmsg (err));
return 1;
link_err:
fprintf (stderr, "Cannot link: %s\n", ctf_errmsg (ctf_errno (fp)));
return 1;
#endif
}