aboutsummaryrefslogtreecommitdiff
path: root/libctf/ctf-create.c
diff options
context:
space:
mode:
authorNick Alcock <nick.alcock@oracle.com>2021-01-05 13:25:56 +0000
committerNick Alcock <nick.alcock@oracle.com>2021-01-05 14:53:39 +0000
commitffeece6ac2d4e4d2bf28c910b51c74ffc881c963 (patch)
treedbb61a523d3289f68a024ed1c84a4290d75b364b /libctf/ctf-create.c
parent91e7ce2fd7b82f3982b453d1c6f4576621bc1c2d (diff)
downloadbinutils-ffeece6ac2d4e4d2bf28c910b51c74ffc881c963.zip
binutils-ffeece6ac2d4e4d2bf28c910b51c74ffc881c963.tar.gz
binutils-ffeece6ac2d4e4d2bf28c910b51c74ffc881c963.tar.bz2
libctf, ld: prohibit getting the size or alignment of forwards
C allows you to do only a very few things with entities of incomplete type (as opposed to pointers to them): make pointers to them and give them cv-quals, roughly. In particular you can't sizeof them and you can't get their alignment. We cannot impose all the requirements the standard imposes on CTF users, because the deduplicator can transform any structure type into a forward for the purposes of breaking cycles: so CTF type graphs can easily contain things like arrays of forward type (if you want to figure out their size or alignment, you need to chase down the types this forward might be a forward to in child TU dicts: we will soon add API functions to make doing this much easier). Nonetheless, it is still meaningless to ask for the size or alignment of forwards: but libctf didn't prohibit this and returned nonsense from internal implementation details when you asked (it returned the kind of the pointed-to type as both the size and alignment, because forwards reuse ctt_type as a type kind, and ctt_type and ctt_size overlap). So introduce a new error, ECTF_INCOMPLETE, which is returned when you try to get the size or alignment of forwards: we also return it when you try to do things that require libctf itself to get the size or alignment of a forward, notably using a forward as an array index type (which C should never do in any case) or adding forwards to structures without specifying their offset explicitly. The dumper will not emit size or alignment info for forwards any more. (This should not be an API break since ctf_type_size and ctf_type_align could both return errors before now: any code that isn't expecting error returns is already potentially broken.) include/ChangeLog 2021-01-05 Nick Alcock <nick.alcock@oracle.com> * ctf-api.h (ECTF_INCOMPLETE): New. (ECTF_NERR): Adjust. ld/ChangeLog 2021-01-05 Nick Alcock <nick.alcock@oracle.com> * testsuite/ld-ctf/conflicting-cycle-1.parent.d: Adjust for dumper changes. * testsuite/ld-ctf/cross-tu-cyclic-conflicting.d: Likewise. * testsuite/ld-ctf/forward.c: New test... * testsuite/ld-ctf/forward.d: ... and results. libctf/ChangeLog 2021-01-05 Nick Alcock <nick.alcock@oracle.com> * ctf-types.c (ctf_type_resolve): Improve comment. (ctf_type_size): Yield ECTF_INCOMPLETE when applied to forwards. Emit errors into the right dict. (ctf_type_align): Likewise. * ctf-create.c (ctf_add_member_offset): Yield ECTF_INCOMPLETE when adding a member without explicit offset when this member, or the previous member, is incomplete. * ctf-dump.c (ctf_dump_format_type): Do not try to print the size of forwards. (ctf_dump_member): Do not try to print their alignment.
Diffstat (limited to 'libctf/ctf-create.c')
-rw-r--r--libctf/ctf-create.c50
1 files changed, 43 insertions, 7 deletions
diff --git a/libctf/ctf-create.c b/libctf/ctf-create.c
index 0af46d3..6fe7461 100644
--- a/libctf/ctf-create.c
+++ b/libctf/ctf-create.c
@@ -1690,6 +1690,14 @@ ctf_add_array (ctf_dict_t *fp, uint32_t flag, const ctf_arinfo_t *arp)
if (ctf_lookup_by_id (&tmp, arp->ctr_index) == NULL)
return CTF_ERR; /* errno is set for us. */
+ if (ctf_type_kind (fp, arp->ctr_index) == CTF_K_FORWARD)
+ {
+ ctf_err_warn (fp, 1, ECTF_INCOMPLETE,
+ _("ctf_add_array: index type %lx is incomplete"),
+ arp->ctr_contents);
+ return (ctf_set_errno (fp, ECTF_INCOMPLETE));
+ }
+
if ((type = ctf_add_generic (fp, flag, NULL, CTF_K_ARRAY, &dtd)) == CTF_ERR)
return CTF_ERR; /* errno is set for us. */
@@ -2040,6 +2048,7 @@ ctf_add_member_offset (ctf_dict_t *fp, ctf_id_t souid, const char *name,
ssize_t msize, malign, ssize;
uint32_t kind, vlen, root;
char *s = NULL;
+ int is_incomplete = 0;
if (!(fp->ctf_flags & LCTF_RDWR))
return (ctf_set_errno (fp, ECTF_RDONLY));
@@ -2075,14 +2084,19 @@ ctf_add_member_offset (ctf_dict_t *fp, ctf_id_t souid, const char *name,
{
/* The unimplemented type, and any type that resolves to it, has no size
and no alignment: it can correspond to any number of compiler-inserted
- types. */
-
+ types. We allow incomplete types through since they are routinely
+ added to the ends of structures, and can even be added elsewhere in
+ structures by the deduplicator. They are assumed to be zero-size with
+ no alignment: this is often wrong, but problems can be avoided in this
+ case by explicitly specifying the size of the structure via the _sized
+ functions. The deduplicator always does this. */
+
+ msize = 0;
+ malign = 0;
if (ctf_errno (fp) == ECTF_NONREPRESENTABLE)
- {
- msize = 0;
- malign = 0;
- ctf_set_errno (fp, 0);
- }
+ ctf_set_errno (fp, 0);
+ else if (ctf_errno (fp) == ECTF_INCOMPLETE)
+ is_incomplete = 1;
else
return -1; /* errno is set for us. */
}
@@ -2123,10 +2137,32 @@ ctf_add_member_offset (ctf_dict_t *fp, ctf_id_t souid, const char *name,
return -1; /* errno is set for us. */
}
+ if (is_incomplete)
+ {
+ ctf_err_warn (fp, 1, ECTF_INCOMPLETE,
+ _("ctf_add_member_offset: cannot add member %s of "
+ "incomplete type %lx to struct %lx without "
+ "specifying explicit offset\n"),
+ name ? name : _("(unnamed member)"), type, souid);
+ return (ctf_set_errno (fp, ECTF_INCOMPLETE));
+ }
+
if (ctf_type_encoding (fp, ltype, &linfo) == 0)
off += linfo.cte_bits;
else if ((lsize = ctf_type_size (fp, ltype)) > 0)
off += lsize * CHAR_BIT;
+ else if (lsize == -1 && ctf_errno (fp) == ECTF_INCOMPLETE)
+ {
+ ctf_err_warn (fp, 1, ECTF_INCOMPLETE,
+ _("ctf_add_member_offset: cannot add member %s of "
+ "type %lx to struct %lx without specifying "
+ "explicit offset after member %s of type %lx, "
+ "which is an incomplete type\n"),
+ name ? name : _("(unnamed member)"), type, souid,
+ lmd->dmd_name ? lmd->dmd_name
+ : _("(unnamed member)"), ltype);
+ return -1; /* errno is set for us. */
+ }
/* Round up the offset of the end of the last member to
the next byte boundary, convert 'off' to bytes, and