yggdrasil/binutils-gdb
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

libctf: rip out dead code handling typedefs with no name

Browse Source 
There is special code in libctf to handle typedefs with no name, which
the code calls "anonymous typedef nodes".

These monsters are obviously not something C programs can include: the
whole point of a ttypedef is to introduce a new name.  Looking back at
the history of DWARF in GCC, the only thing (outside C++ anonymous
namespaces) which can generate a DW_TAG_typedef without a DW_AT_name is
obsolete code to handle the long-removed -feliminate-dwarf2-dups option.
Looking at OpenSolaris, typedef nodes with no name couldn't be generated
by the DWARF->CTF converter at all (and its deduplicator barfed on
them): the only reason for the existence of this code is a special case
working around a peculiarity of stabs whereby types could sometimes be
referenced before they were introduced.

We don't need to carry code in libctf to handle special cases in an
obsolete OpenSolaris converter (that yields a format that isn't readable
by libctf anyway).  So drop it.

libctf/ChangeLog
2021-01-27  Nick Alcock  <nick.alcock@oracle.com>

	* ctf-open.c (init_types): Rip out code to check anonymous typedef
	nodes.
	* ctf-create.c (ctf_add_reftype): Likewise.
	* ctf-lookup.c (refresh_pptrtab): Likewise.
This commit is contained in:
Nick Alcock 2021-01-27 19:41:49 +00:00
parent 35a01a0454
commit 78f28b89e8
4 changed files with 14 additions and 61 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
libctf/ChangeLog
View File

@ -1,3 +1,10 @@
2021-01-27 Nick Alcock <nick.alcock@oracle.com>
* ctf-open.c (init_types): Rip out code to check anonymous typedef
nodes.
* ctf-create.c (ctf_add_reftype): Likewise.
* ctf-lookup.c (refresh_pptrtab): Likewise.
2021-01-27 Nick Alcock <nick.alcock@oracle.com>
* ctf-impl.c (_libctf_nonnull_): Add parameters.

23
libctf/ctf-create.c
View File

@ -1629,29 +1629,18 @@ ctf_add_reftype (ctf_dict_t *fp, uint32_t flag, ctf_id_t ref, uint32_t kind)
if (kind != CTF_K_POINTER)
return type;
/* If we are adding a pointer, update the ptrtab, both the directly pointed-to
type and (if an anonymous typedef node is being pointed at) the type that
points at too. Note that ctf_typemax is at this point one higher than we
want to check against, because it's just been incremented for the addition
of this type. The pptrtab is lazily-updated as needed, so is not touched
here. */
/* If we are adding a pointer, update the ptrtab, pointing at this type from
the type it points to. Note that ctf_typemax is at this point one higher
than we want to check against, because it's just been incremented for the
addition of this type. The pptrtab is lazily-updated as needed, so is not
touched here. */
uint32_t type_idx = LCTF_TYPE_TO_INDEX (fp, type);
uint32_t ref_idx = LCTF_TYPE_TO_INDEX (fp, ref);
if (LCTF_TYPE_ISCHILD (fp, ref) == child
&& ref_idx < fp->ctf_typemax)
{
fp->ctf_ptrtab[ref_idx] = type_idx;
ctf_id_t refref_idx = LCTF_TYPE_TO_INDEX (fp, dtd->dtd_data.ctt_type);
if (tmp == fp
&& (LCTF_INFO_KIND (fp, dtd->dtd_data.ctt_info) == CTF_K_TYPEDEF)
&& strcmp (ctf_strptr (fp, dtd->dtd_data.ctt_name), "") == 0
&& refref_idx < fp->ctf_typemax)
fp->ctf_ptrtab[refref_idx] = type_idx;
}
fp->ctf_ptrtab[ref_idx] = type_idx;
return type;
}

24
libctf/ctf-lookup.c
View File

@ -51,7 +51,6 @@ refresh_pptrtab (ctf_dict_t *fp, ctf_dict_t *pfp)
{
ctf_id_t type = LCTF_INDEX_TO_TYPE (fp, i, 1);
ctf_id_t reffed_type;
int updated;
if (ctf_type_kind (fp, type) != CTF_K_POINTER)
continue;
@ -65,29 +64,6 @@ refresh_pptrtab (ctf_dict_t *fp, ctf_dict_t *pfp)
/* Guard against references to invalid types. No need to consider
the CTF dict corrupt in this case: this pointer just can't be a
pointer to any type we know about. */
if (idx <= pfp->ctf_typemax)
{
if (idx >= fp->ctf_pptrtab_len
&& grow_pptrtab (fp, pfp->ctf_ptrtab_len) < 0)
return -1; /* errno is set for us. */
fp->ctf_pptrtab[idx] = i;
updated = 1;
}
}
if (!updated)
continue;
/* If we updated the ptrtab entry for this type's referent, and it's an
anonymous typedef node, we also want to chase down its referent and
change that as well. */
if ((ctf_type_kind (fp, reffed_type) == CTF_K_TYPEDEF)
&& strcmp (ctf_type_name_raw (fp, reffed_type), "") == 0)
{
uint32_t idx;
idx = LCTF_TYPE_TO_INDEX (pfp, ctf_type_reference (fp, reffed_type));
if (idx <= pfp->ctf_typemax)
{
if (idx >= fp->ctf_pptrtab_len

21
libctf/ctf-open.c
View File

@ -683,7 +683,7 @@ init_types (ctf_dict_t *fp, ctf_header_t *cth)
unsigned long pop[CTF_K_MAX + 1] = { 0 };
const ctf_type_t *tp;
uint32_t id, dst;
uint32_t id;
uint32_t *xp;
/* We determine whether the dict is a child or a parent based on the value of
@ -953,25 +953,6 @@ init_types (ctf_dict_t *fp, ctf_header_t *cth)
ctf_dprintf ("%u base type names hashed\n",
ctf_hash_size (fp->ctf_names.ctn_readonly));
/* Make an additional pass through the pointer table to find pointers that
point to anonymous typedef nodes. If we find one, modify the pointer table
so that the pointer is also known to point to the node that is referenced
by the anonymous typedef node. */
for (id = 1; id <= fp->ctf_typemax; id++)
{
if ((dst = fp->ctf_ptrtab[id]) != 0)
{
tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
if (LCTF_INFO_KIND (fp, tp->ctt_info) == CTF_K_TYPEDEF
&& strcmp (ctf_strptr (fp, tp->ctt_name), "") == 0
&& LCTF_TYPE_ISCHILD (fp, tp->ctt_type) == child
&& LCTF_TYPE_TO_INDEX (fp, tp->ctt_type) <= fp->ctf_typemax)
fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, tp->ctt_type)] = dst;
}
}
return 0;
}