/* Type handling functions.
- Copyright (C) 2019 Free Software Foundation, Inc.
+ Copyright (C) 2019-2020 Free Software Foundation, Inc.
This file is part of libctf.
<http://www.gnu.org/licenses/>. */
#include <ctf-impl.h>
+#include <assert.h>
#include <string.h>
/* Determine whether a type is a parent or a child. */
return 0;
}
+/* Iterate over the members of a STRUCT or UNION, returning each member's
+ offset and optionally name and member type in turn. On end-of-iteration,
+ returns -1. */
+
+ssize_t
+ctf_member_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
+ const char **name, ctf_id_t *membtype)
+{
+ ctf_file_t *ofp = fp;
+ uint32_t kind;
+ ssize_t offset;
+ ctf_next_t *i = *it;
+
+ if (!i)
+ {
+ const ctf_type_t *tp;
+ ctf_dtdef_t *dtd;
+
+ if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
+ return -1; /* errno is set for us. */
+
+ if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
+ return -1; /* errno is set for us. */
+
+ if ((i = ctf_next_create ()) == NULL)
+ return ctf_set_errno (ofp, ENOMEM);
+ i->cu.ctn_fp = ofp;
+
+ (void) ctf_get_ctt_size (fp, tp, &i->ctn_size,
+ &i->ctn_increment);
+ kind = LCTF_INFO_KIND (fp, tp->ctt_info);
+
+ if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
+ {
+ ctf_next_destroy (i);
+ return (ctf_set_errno (ofp, ECTF_NOTSOU));
+ }
+
+ dtd = ctf_dynamic_type (fp, type);
+ i->ctn_iter_fun = (void (*) (void)) ctf_member_next;
+
+ /* We depend below on the RDWR state indicating whether the DTD-related
+ fields or the DMD-related fields have been initialized. */
+
+ assert ((dtd && (fp->ctf_flags & LCTF_RDWR))
+ || (!dtd && (!(fp->ctf_flags & LCTF_RDWR))));
+
+ if (dtd == NULL)
+ {
+ i->ctn_n = LCTF_INFO_VLEN (fp, tp->ctt_info);
+
+ if (i->ctn_size < CTF_LSTRUCT_THRESH)
+ i->u.ctn_mp = (const ctf_member_t *) ((uintptr_t) tp +
+ i->ctn_increment);
+ else
+ i->u.ctn_lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
+ i->ctn_increment);
+ }
+ else
+ i->u.ctn_dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+
+ *it = i;
+ }
+
+ if ((void (*) (void)) ctf_member_next != i->ctn_iter_fun)
+ return (ctf_set_errno (ofp, ECTF_NEXT_WRONGFUN));
+
+ if (ofp != i->cu.ctn_fp)
+ return (ctf_set_errno (ofp, ECTF_NEXT_WRONGFP));
+
+ /* Resolve to the native dict of this type. */
+ if ((fp = ctf_get_dict (ofp, type)) == NULL)
+ return (ctf_set_errno (ofp, ECTF_NOPARENT));
+
+ if (!(fp->ctf_flags & LCTF_RDWR))
+ {
+ if (i->ctn_n == 0)
+ goto end_iter;
+
+ if (i->ctn_size < CTF_LSTRUCT_THRESH)
+ {
+ if (name)
+ *name = ctf_strptr (fp, i->u.ctn_mp->ctm_name);
+ if (membtype)
+ *membtype = i->u.ctn_mp->ctm_type;
+ offset = i->u.ctn_mp->ctm_offset;
+ i->u.ctn_mp++;
+ }
+ else
+ {
+ if (name)
+ *name = ctf_strptr (fp, i->u.ctn_lmp->ctlm_name);
+ if (membtype)
+ *membtype = i->u.ctn_lmp->ctlm_type;
+ offset = (unsigned long) CTF_LMEM_OFFSET (i->u.ctn_lmp);
+ i->u.ctn_lmp++;
+ }
+ i->ctn_n--;
+ }
+ else
+ {
+ if (i->u.ctn_dmd == NULL)
+ goto end_iter;
+ if (name)
+ *name = i->u.ctn_dmd->dmd_name;
+ if (membtype)
+ *membtype = i->u.ctn_dmd->dmd_type;
+ offset = i->u.ctn_dmd->dmd_offset;
+ i->u.ctn_dmd = ctf_list_next (i->u.ctn_dmd);
+ }
+
+ return offset;
+
+ end_iter:
+ ctf_next_destroy (i);
+ *it = NULL;
+ return ctf_set_errno (ofp, ECTF_NEXT_END);
+}
+
/* Iterate over the members of an ENUM. We pass the string name and associated
integer value of each enum element to the specified callback function. */
return 0;
}
+/* Iterate over the members of an enum TYPE, returning each enumerand's NAME or
+ NULL at end of iteration or error, and optionally passing back the
+ enumerand's integer VALue. */
+
+const char *
+ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
+ int *val)
+{
+ ctf_file_t *ofp = fp;
+ uint32_t kind;
+ const char *name;
+ ctf_next_t *i = *it;
+
+ if (!i)
+ {
+ const ctf_type_t *tp;
+ ctf_dtdef_t *dtd;
+
+ if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
+ return NULL; /* errno is set for us. */
+
+ if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
+ return NULL; /* errno is set for us. */
+
+ if ((i = ctf_next_create ()) == NULL)
+ {
+ ctf_set_errno (ofp, ENOMEM);
+ return NULL;
+ }
+ i->cu.ctn_fp = ofp;
+
+ (void) ctf_get_ctt_size (fp, tp, NULL,
+ &i->ctn_increment);
+ kind = LCTF_INFO_KIND (fp, tp->ctt_info);
+
+ if (kind != CTF_K_ENUM)
+ {
+ ctf_next_destroy (i);
+ ctf_set_errno (ofp, ECTF_NOTENUM);
+ return NULL;
+ }
+
+ dtd = ctf_dynamic_type (fp, type);
+ i->ctn_iter_fun = (void (*) (void)) ctf_enum_next;
+
+ /* We depend below on the RDWR state indicating whether the DTD-related
+ fields or the DMD-related fields have been initialized. */
+
+ assert ((dtd && (fp->ctf_flags & LCTF_RDWR))
+ || (!dtd && (!(fp->ctf_flags & LCTF_RDWR))));
+
+ if (dtd == NULL)
+ {
+ i->ctn_n = LCTF_INFO_VLEN (fp, tp->ctt_info);
+
+ i->u.ctn_en = (const ctf_enum_t *) ((uintptr_t) tp +
+ i->ctn_increment);
+ }
+ else
+ i->u.ctn_dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+
+ *it = i;
+ }
+
+ if ((void (*) (void)) ctf_enum_next != i->ctn_iter_fun)
+ {
+ ctf_set_errno (ofp, ECTF_NEXT_WRONGFUN);
+ return NULL;
+ }
+
+ if (ofp != i->cu.ctn_fp)
+ {
+ ctf_set_errno (ofp, ECTF_NEXT_WRONGFP);
+ return NULL;
+ }
+
+ /* Resolve to the native dict of this type. */
+ if ((fp = ctf_get_dict (ofp, type)) == NULL)
+ {
+ ctf_set_errno (ofp, ECTF_NOPARENT);
+ return NULL;
+ }
+
+ if (!(fp->ctf_flags & LCTF_RDWR))
+ {
+ if (i->ctn_n == 0)
+ goto end_iter;
+
+ name = ctf_strptr (fp, i->u.ctn_en->cte_name);
+ if (val)
+ *val = i->u.ctn_en->cte_value;
+ i->u.ctn_en++;
+ i->ctn_n--;
+ }
+ else
+ {
+ if (i->u.ctn_dmd == NULL)
+ goto end_iter;
+
+ name = i->u.ctn_dmd->dmd_name;
+ if (val)
+ *val = i->u.ctn_dmd->dmd_value;
+ i->u.ctn_dmd = ctf_list_next (i->u.ctn_dmd);
+ }
+
+ return name;
+
+ end_iter:
+ ctf_next_destroy (i);
+ *it = NULL;
+ ctf_set_errno (ofp, ECTF_NEXT_END);
+ return NULL;
+}
+
/* Iterate over every root (user-visible) type in the given CTF container.
- We pass the type ID of each type to the specified callback function. */
+ We pass the type ID of each type to the specified callback function.
+
+ Does not traverse parent types: you have to do that explicitly. This is by
+ design, to avoid traversing them more than once if traversing many children
+ of a single parent. */
int
ctf_type_iter (ctf_file_t *fp, ctf_type_f *func, void *arg)
}
/* Iterate over every type in the given CTF container, user-visible or not.
- We pass the type ID of each type to the specified callback function. */
+ We pass the type ID of each type to the specified callback function.
+
+ Does not traverse parent types: you have to do that explicitly. This is by
+ design, to avoid traversing them more than once if traversing many children
+ of a single parent. */
int
ctf_type_iter_all (ctf_file_t *fp, ctf_type_all_f *func, void *arg)
return 0;
}
+/* Iterate over every type in the given CTF container, optionally including
+ non-user-visible types, returning each type ID and hidden flag in turn.
+ Returns CTF_ERR on end of iteration or error.
+
+ Does not traverse parent types: you have to do that explicitly. This is by
+ design, to avoid traversing them more than once if traversing many children
+ of a single parent. */
+
+ctf_id_t
+ctf_type_next (ctf_file_t *fp, ctf_next_t **it, int *flag, int want_hidden)
+{
+ ctf_next_t *i = *it;
+
+ if (!i)
+ {
+ if ((i = ctf_next_create ()) == NULL)
+ return ctf_set_errno (fp, ENOMEM);
+
+ i->cu.ctn_fp = fp;
+ i->ctn_type = 1;
+ i->ctn_iter_fun = (void (*) (void)) ctf_type_next;
+ *it = i;
+ }
+
+ if ((void (*) (void)) ctf_type_next != i->ctn_iter_fun)
+ return (ctf_set_errno (fp, ECTF_NEXT_WRONGFUN));
+
+ if (fp != i->cu.ctn_fp)
+ return (ctf_set_errno (fp, ECTF_NEXT_WRONGFP));
+
+ while (i->ctn_type <= fp->ctf_typemax)
+ {
+ const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR (fp, i->ctn_type);
+
+ if ((!want_hidden) && (!LCTF_INFO_ISROOT (fp, tp->ctt_info)))
+ {
+ i->ctn_type++;
+ continue;
+ }
+
+ if (flag)
+ *flag = LCTF_INFO_ISROOT (fp, tp->ctt_info);
+ return LCTF_INDEX_TO_TYPE (fp, i->ctn_type++, fp->ctf_flags & LCTF_CHILD);
+ }
+ ctf_next_destroy (i);
+ *it = NULL;
+ return ctf_set_errno (fp, ECTF_NEXT_END);
+}
+
/* Iterate over every variable in the given CTF container, in arbitrary order.
We pass the name of each variable to the specified callback function. */
int rc;
if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
- return ECTF_NOPARENT;
+ return (ctf_set_errno (fp, ECTF_NOPARENT));
if (!(fp->ctf_flags & LCTF_RDWR))
{
return 0;
}
+/* Iterate over every variable in the given CTF container, in arbitrary order,
+ returning the name and type of each variable in turn. The name argument is
+ not optional. Returns CTF_ERR on end of iteration or error. */
+
+ctf_id_t
+ctf_variable_next (ctf_file_t *fp, ctf_next_t **it, const char **name)
+{
+ ctf_next_t *i = *it;
+
+ if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
+ return (ctf_set_errno (fp, ECTF_NOPARENT));
+
+ if (!i)
+ {
+ if ((i = ctf_next_create ()) == NULL)
+ return ctf_set_errno (fp, ENOMEM);
+
+ i->cu.ctn_fp = fp;
+ i->ctn_iter_fun = (void (*) (void)) ctf_variable_next;
+ if (fp->ctf_flags & LCTF_RDWR)
+ i->u.ctn_dvd = ctf_list_next (&fp->ctf_dvdefs);
+ *it = i;
+ }
+
+ if ((void (*) (void)) ctf_variable_next != i->ctn_iter_fun)
+ return (ctf_set_errno (fp, ECTF_NEXT_WRONGFUN));
+
+ if (fp != i->cu.ctn_fp)
+ return (ctf_set_errno (fp, ECTF_NEXT_WRONGFP));
+
+ if (!(fp->ctf_flags & LCTF_RDWR))
+ {
+ if (i->ctn_n >= fp->ctf_nvars)
+ goto end_iter;
+
+ *name = ctf_strptr (fp, fp->ctf_vars[i->ctn_n].ctv_name);
+ return fp->ctf_vars[i->ctn_n++].ctv_type;
+ }
+ else
+ {
+ ctf_id_t id;
+
+ if (i->u.ctn_dvd == NULL)
+ goto end_iter;
+
+ *name = i->u.ctn_dvd->dvd_name;
+ id = i->u.ctn_dvd->dvd_type;
+ i->u.ctn_dvd = ctf_list_next (i->u.ctn_dvd);
+ return id;
+ }
+
+ end_iter:
+ ctf_next_destroy (i);
+ *it = NULL;
+ return ctf_set_errno (fp, ECTF_NEXT_END);
+}
+
/* Follow a given type through the graph for TYPEDEF, VOLATILE, CONST, and
RESTRICT nodes until we reach a "base" type node. This is useful when
we want to follow a type ID to a node that has members or a size. To guard
ctf_id_t id;
if (fp->ctf_flags & LCTF_RDWR)
- id = (ctf_id_t) ctf_dynhash_lookup (np->ctn_writable, name);
+ id = (ctf_id_t) (uintptr_t) ctf_dynhash_lookup (np->ctn_writable, name);
else
id = ctf_hash_lookup_type (np->ctn_readonly, fp, name);
return id;
}
-/* Lookup the given type ID and return its name as a new dynamcally-allocated
+/* Lookup the given type ID and return its name as a new dynamically-allocated
string. */
char *
case CTF_K_INTEGER:
case CTF_K_FLOAT:
case CTF_K_TYPEDEF:
+ /* Integers, floats, and typedefs must always be named types. */
+
+ if (name[0] == '\0')
+ {
+ ctf_set_errno (fp, ECTF_CORRUPT);
+ ctf_decl_fini (&cd);
+ return NULL;
+ }
+
ctf_decl_sprintf (&cd, "%s", name);
break;
case CTF_K_POINTER:
ctf_decl_sprintf (&cd, "[%u]", cdp->cd_n);
break;
case CTF_K_FUNCTION:
- ctf_decl_sprintf (&cd, "()");
+ {
+ size_t i;
+ ctf_funcinfo_t fi;
+ ctf_id_t *argv = NULL;
+
+ if (ctf_func_type_info (rfp, cdp->cd_type, &fi) < 0)
+ goto err; /* errno is set for us. */
+
+ if ((argv = calloc (fi.ctc_argc, sizeof (ctf_id_t *))) == NULL)
+ {
+ ctf_set_errno (rfp, errno);
+ goto err;
+ }
+
+ if (ctf_func_type_args (rfp, cdp->cd_type,
+ fi.ctc_argc, argv) < 0)
+ goto err; /* errno is set for us. */
+
+ ctf_decl_sprintf (&cd, "(*) (");
+ for (i = 0; i < fi.ctc_argc; i++)
+ {
+ char *arg = ctf_type_aname (rfp, argv[i]);
+
+ if (arg == NULL)
+ goto err; /* errno is set for us. */
+ ctf_decl_sprintf (&cd, "%s", arg);
+ free (arg);
+
+ if ((i < fi.ctc_argc - 1)
+ || (fi.ctc_flags & CTF_FUNC_VARARG))
+ ctf_decl_sprintf (&cd, ", ");
+ }
+
+ if (fi.ctc_flags & CTF_FUNC_VARARG)
+ ctf_decl_sprintf (&cd, "...");
+ ctf_decl_sprintf (&cd, ")");
+
+ free (argv);
+ break;
+
+ err:
+ free (argv);
+ ctf_decl_fini (&cd);
+ return NULL;
+ }
break;
case CTF_K_STRUCT:
case CTF_K_FORWARD:
size_t slen;
if (str == NULL)
- return CTF_ERR; /* errno is set for us */
+ return CTF_ERR; /* errno is set for us. */
slen = strlen (str);
snprintf (buf, len, "%s", str);
return (rv >= 0 && (size_t) rv < len ? buf : NULL);
}
-/* Lookup the given type ID and return its raw, unadorned, undecorated name as a
- new dynamcally-allocated string. */
+/* Lookup the given type ID and return its raw, unadorned, undecorated name.
+ The name will live as long as its ctf_file_t does. */
-char *
-ctf_type_aname_raw (ctf_file_t *fp, ctf_id_t type)
+const char *
+ctf_type_name_raw (ctf_file_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return NULL; /* errno is set for us. */
- if (ctf_strraw (fp, tp->ctt_name) != NULL)
- return strdup (ctf_strraw (fp, tp->ctt_name));
+ return ctf_strraw (fp, tp->ctt_name);
+}
+
+/* Lookup the given type ID and return its raw, unadorned, undecorated name as a
+ new dynamically-allocated string. */
+
+char *
+ctf_type_aname_raw (ctf_file_t *fp, ctf_id_t type)
+{
+ const char *name = ctf_type_name_raw (fp, type);
+
+ if (name != NULL)
+ return strdup (name);
return NULL;
}
return kind;
}
+/* Return the kind of this type, except, for forwards, return the kind of thing
+ this is a forward to. */
+int
+ctf_type_kind_forwarded (ctf_file_t *fp, ctf_id_t type)
+{
+ int kind;
+ const ctf_type_t *tp;
+
+ if ((kind = ctf_type_kind (fp, type)) < 0)
+ return -1; /* errno is set for us. */
+
+ if (kind != CTF_K_FORWARD)
+ return kind;
+
+ if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
+ return -1; /* errno is set for us. */
+
+ return tp->ctt_type;
+}
+
/* If the type is one that directly references another type (such as POINTER),
then return the ID of the type to which it refers. */
/* Slices store their type in an unusual place. */
case CTF_K_SLICE:
{
+ ctf_dtdef_t *dtd;
const ctf_slice_t *sp;
- ssize_t increment;
- (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
- sp = (const ctf_slice_t *) ((uintptr_t) tp + increment);
+
+ if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
+ {
+ ssize_t increment;
+
+ (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
+ sp = (const ctf_slice_t *) ((uintptr_t) tp + increment);
+ }
+ else
+ sp = &dtd->dtd_u.dtu_slice;
+
return sp->cts_type;
}
default:
if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
{
- *ep = dtd->dtd_u.dtu_enc;
+ switch (LCTF_INFO_KIND (fp, tp->ctt_info))
+ {
+ case CTF_K_INTEGER:
+ case CTF_K_FLOAT:
+ *ep = dtd->dtd_u.dtu_enc;
+ break;
+ case CTF_K_SLICE:
+ {
+ const ctf_slice_t *slice;
+ ctf_encoding_t underlying_en;
+ ctf_id_t underlying;
+
+ slice = &dtd->dtd_u.dtu_slice;
+ underlying = ctf_type_resolve (fp, slice->cts_type);
+ data = ctf_type_encoding (fp, underlying, &underlying_en);
+
+ ep->cte_format = underlying_en.cte_format;
+ ep->cte_offset = slice->cts_offset;
+ ep->cte_bits = slice->cts_bits;
+ break;
+ }
+ default:
+ return (ctf_set_errno (ofp, ECTF_NOTINTFP));
+ }
return 0;
}
{
const ctf_slice_t *slice;
ctf_encoding_t underlying_en;
+ ctf_id_t underlying;
slice = (ctf_slice_t *) ((uintptr_t) tp + increment);
- data = ctf_type_encoding (fp, slice->cts_type, &underlying_en);
+ underlying = ctf_type_resolve (fp, slice->cts_type);
+ data = ctf_type_encoding (fp, underlying, &underlying_en);
ep->cte_format = underlying_en.cte_format;
ep->cte_offset = slice->cts_offset;
}
}
+/* Return the number of members in a STRUCT or UNION, or the number of
+ enumerators in an ENUM. */
+
+int
+ctf_member_count (ctf_file_t *fp, ctf_id_t type)
+{
+ ctf_file_t *ofp = fp;
+ const ctf_type_t *tp;
+ uint32_t kind;
+
+ if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
+ return -1; /* errno is set for us. */
+
+ if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
+ return -1; /* errno is set for us. */
+
+ kind = LCTF_INFO_KIND (fp, tp->ctt_info);
+
+ if (kind != CTF_K_STRUCT && kind != CTF_K_UNION && kind != CTF_K_ENUM)
+ return (ctf_set_errno (ofp, ECTF_NOTSUE));
+
+ return LCTF_INFO_VLEN (fp, tp->ctt_info);
+}
+
/* Return the type and offset for a given member of a STRUCT or UNION. */
int
if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
args = (uint32_t *) ((uintptr_t) tp + increment);
else
- args = (uint32_t *) dtd->dtd_u.dtu_argv;
+ args = dtd->dtd_u.dtu_argv;
if (fip->ctc_argc != 0 && args[fip->ctc_argc - 1] == 0)
{
return 0;
}
-/* Given a type ID relating to a function type,, return the arguments for the
+/* Given a type ID relating to a function type, return the arguments for the
function. */
int
if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
args = (uint32_t *) ((uintptr_t) tp + increment);
else
- args = (uint32_t *) dtd->dtd_u.dtu_argv;
+ args = dtd->dtd_u.dtu_argv;
for (argc = MIN (argc, f.ctc_argc); argc != 0; argc--)
*argv++ = *args++;
projects / deliverable / binutils-gdb.git / blobdiff