/* Type handling functions.
- Copyright (C) 2019-2020 Free Software Foundation, Inc.
+ Copyright (C) 2019-2021 Free Software Foundation, Inc.
This file is part of libctf.
/* Determine whether a type is a parent or a child. */
int
-ctf_type_isparent (ctf_file_t *fp, ctf_id_t id)
+ctf_type_isparent (ctf_dict_t *fp, ctf_id_t id)
{
return (LCTF_TYPE_ISPARENT (fp, id));
}
int
-ctf_type_ischild (ctf_file_t * fp, ctf_id_t id)
+ctf_type_ischild (ctf_dict_t * fp, ctf_id_t id)
{
return (LCTF_TYPE_ISCHILD (fp, id));
}
-/* Iterate over the members of a STRUCT or UNION. We pass the name, member
- type, and offset of each member to the specified callback function. */
+/* Expand a structure element into the passed-in ctf_lmember_t. */
-int
-ctf_member_iter (ctf_file_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
+static int
+ctf_struct_member (ctf_dict_t *fp, ctf_lmember_t *dst, const ctf_type_t *tp,
+ unsigned char *vlen, size_t vbytes, size_t n)
{
- ctf_file_t *ofp = fp;
- const ctf_type_t *tp;
- ctf_dtdef_t *dtd;
- ssize_t size, increment;
- uint32_t kind, n;
- int rc;
-
- 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. */
-
- (void) ctf_get_ctt_size (fp, tp, &size, &increment);
- kind = LCTF_INFO_KIND (fp, tp->ctt_info);
-
- if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
- return (ctf_set_errno (ofp, ECTF_NOTSOU));
+ if (!ctf_assert (fp, n < LCTF_INFO_VLEN (fp, tp->ctt_info)))
+ return -1; /* errno is set for us. */
- if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
+ /* Already large. */
+ if (tp->ctt_size == CTF_LSIZE_SENT)
{
- if (size < CTF_LSTRUCT_THRESH)
- {
- const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
- increment);
+ ctf_lmember_t *lmp = (ctf_lmember_t *) vlen;
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
- {
- const char *name = ctf_strptr (fp, mp->ctm_name);
- if ((rc = func (name, mp->ctm_type, mp->ctm_offset, arg)) != 0)
- return rc;
- }
- }
- else
- {
- const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
- increment);
+ if (!ctf_assert (fp, (n + 1) * sizeof (ctf_lmember_t) <= vbytes))
+ return -1; /* errno is set for us. */
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
- {
- const char *name = ctf_strptr (fp, lmp->ctlm_name);
- if ((rc = func (name, lmp->ctlm_type,
- (unsigned long) CTF_LMEM_OFFSET (lmp), arg)) != 0)
- return rc;
- }
- }
+ memcpy (dst, &lmp[n], sizeof (ctf_lmember_t));
}
else
{
- ctf_dmdef_t *dmd;
+ ctf_member_t *mp = (ctf_member_t *) vlen;
+ dst->ctlm_name = mp[n].ctm_name;
+ dst->ctlm_type = mp[n].ctm_type;
+ dst->ctlm_offsetlo = mp[n].ctm_offset;
+ dst->ctlm_offsethi = 0;
+ }
+ return 0;
+}
+
+/* Iterate over the members of a STRUCT or UNION. We pass the name, member
+ type, and offset of each member to the specified callback function. */
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
+int
+ctf_member_iter (ctf_dict_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
+{
+ ctf_next_t *i = NULL;
+ ssize_t offset;
+ const char *name;
+ ctf_id_t membtype;
+
+ while ((offset = ctf_member_next (fp, type, &i, &name, &membtype, 0)) >= 0)
+ {
+ int rc;
+ if ((rc = func (name, membtype, offset, arg)) != 0)
{
- if ((rc = func (dmd->dmd_name, dmd->dmd_type,
- dmd->dmd_offset, arg)) != 0)
- return rc;
+ ctf_next_destroy (i);
+ return rc;
}
}
+ if (ctf_errno (fp) != ECTF_NEXT_END)
+ return -1; /* errno is set for us. */
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. */
+ returns -1. If FLAGS is CTF_MN_RECURSE, recurse into unnamed members. */
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_member_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
+ const char **name, ctf_id_t *membtype, int flags)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
uint32_t kind;
ssize_t offset;
+ uint32_t max_vlen;
ctf_next_t *i = *it;
if (!i)
{
const ctf_type_t *tp;
ctf_dtdef_t *dtd;
+ ssize_t size;
+ ssize_t increment;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
return -1; /* errno is set for us. */
if ((i = ctf_next_create ()) == NULL)
return ctf_set_errno (ofp, ENOMEM);
i->cu.ctn_fp = ofp;
+ i->ctn_tp = tp;
- (void) ctf_get_ctt_size (fp, tp, &i->ctn_size,
- &i->ctn_increment);
+ ctf_get_ctt_size (fp, tp, &size, &increment);
kind = LCTF_INFO_KIND (fp, tp->ctt_info);
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
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)
+ if ((dtd = ctf_dynamic_type (fp, type)) != 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);
+ i->u.ctn_vlen = dtd->dtd_vlen;
+ i->ctn_size = dtd->dtd_vlen_alloc;
}
else
- i->u.ctn_dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
+ {
+ unsigned long vlen = LCTF_INFO_VLEN (fp, tp->ctt_info);
+ i->u.ctn_vlen = (unsigned char *) tp + increment;
+ i->ctn_size = LCTF_VBYTES (fp, kind, size, vlen);;
+ }
+ i->ctn_iter_fun = (void (*) (void)) ctf_member_next;
+ i->ctn_n = 0;
*it = i;
}
if ((fp = ctf_get_dict (ofp, type)) == NULL)
return (ctf_set_errno (ofp, ECTF_NOPARENT));
- if (!(fp->ctf_flags & LCTF_RDWR))
+ max_vlen = LCTF_INFO_VLEN (fp, i->ctn_tp->ctt_info);
+
+ /* When we hit an unnamed struct/union member, we set ctn_type to indicate
+ that we are inside one, then return the unnamed member: on the next call,
+ we must skip over top-level member iteration in favour of iteration within
+ the sub-struct until it later turns out that that iteration has ended. */
+
+ retry:
+ if (!i->ctn_type)
{
- if (i->ctn_n == 0)
+ ctf_lmember_t memb;
+ const char *membname;
+
+ if (i->ctn_n == max_vlen)
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--;
+ if (ctf_struct_member (fp, &memb, i->ctn_tp, i->u.ctn_vlen, i->ctn_size,
+ i->ctn_n) < 0)
+ return -1; /* errno is set for us. */
+
+ membname = ctf_strptr (fp, memb.ctlm_name);
+
+ if (name)
+ *name = membname;
+ if (membtype)
+ *membtype = memb.ctlm_type;
+ offset = (unsigned long) CTF_LMEM_OFFSET (&memb);
+
+ if (membname[0] == 0
+ && (ctf_type_kind (fp, memb.ctlm_type) == CTF_K_STRUCT
+ || ctf_type_kind (fp, memb.ctlm_type) == CTF_K_UNION))
+ i->ctn_type = memb.ctlm_type;
+ i->ctn_n++;
+
+ /* The callers might want automatic recursive sub-struct traversal. */
+ if (!(flags & CTF_MN_RECURSE))
+ i->ctn_type = 0;
+
+ /* Sub-struct traversal starting? Take note of the offset of this member,
+ for later boosting of sub-struct members' offsets. */
+ if (i->ctn_type)
+ i->ctn_increment = offset;
}
+ /* Traversing a sub-struct? Just return it, with the offset adjusted. */
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);
+ ssize_t ret = ctf_member_next (fp, i->ctn_type, &i->ctn_next, name,
+ membtype, flags);
+
+ if (ret >= 0)
+ return ret + i->ctn_increment;
+
+ if (ctf_errno (fp) != ECTF_NEXT_END)
+ {
+ ctf_next_destroy (i);
+ *it = NULL;
+ i->ctn_type = 0;
+ return ret; /* errno is set for us. */
+ }
+
+ if (!ctf_assert (fp, (i->ctn_next == NULL)))
+ return -1; /* errno is set for us. */
+
+ i->ctn_type = 0;
+ /* This sub-struct has ended: on to the next real member. */
+ goto retry;
}
return offset;
integer value of each enum element to the specified callback function. */
int
-ctf_enum_iter (ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
+ctf_enum_iter (ctf_dict_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
{
- ctf_file_t *ofp = fp;
- const ctf_type_t *tp;
- const ctf_enum_t *ep;
- ctf_dtdef_t *dtd;
- ssize_t increment;
- uint32_t n;
- int rc;
-
- if ((type = ctf_type_resolve_unsliced (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 (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
- return (ctf_set_errno (ofp, ECTF_NOTENUM));
-
- (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
+ ctf_next_t *i = NULL;
+ const char *name;
+ int val;
- if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
+ while ((name = ctf_enum_next (fp, type, &i, &val)) != NULL)
{
- ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
-
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+ int rc;
+ if ((rc = func (name, val, arg)) != 0)
{
- const char *name = ctf_strptr (fp, ep->cte_name);
- if ((rc = func (name, ep->cte_value, arg)) != 0)
- return rc;
- }
- }
- else
- {
- ctf_dmdef_t *dmd;
-
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
- {
- if ((rc = func (dmd->dmd_name, dmd->dmd_value, arg)) != 0)
- return rc;
+ ctf_next_destroy (i);
+ return rc;
}
}
+ if (ctf_errno (fp) != ECTF_NEXT_END)
+ return -1; /* errno is set for us. */
return 0;
}
enumerand's integer VALue. */
const char *
-ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
+ctf_enum_next (ctf_dict_t *fp, ctf_id_t type, ctf_next_t **it,
int *val)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
uint32_t kind;
const char *name;
ctf_next_t *i = *it;
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))));
+ i->ctn_n = LCTF_INFO_VLEN (fp, tp->ctt_info);
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);
- }
+ 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);
+ i->u.ctn_en = (const ctf_enum_t *) dtd->dtd_vlen;
*it = i;
}
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;
+ if (i->ctn_n == 0)
+ 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);
- }
+ 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--;
return name;
return NULL;
}
-/* Iterate over every root (user-visible) type in the given CTF container.
+/* Iterate over every root (user-visible) type in the given CTF dict.
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
of a single parent. */
int
-ctf_type_iter (ctf_file_t *fp, ctf_type_f *func, void *arg)
+ctf_type_iter (ctf_dict_t *fp, ctf_type_f *func, void *arg)
{
- ctf_id_t id, max = fp->ctf_typemax;
- int rc, child = (fp->ctf_flags & LCTF_CHILD);
+ ctf_next_t *i = NULL;
+ ctf_id_t type;
- for (id = 1; id <= max; id++)
+ while ((type = ctf_type_next (fp, &i, NULL, 0)) != CTF_ERR)
{
- const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
- if (LCTF_INFO_ISROOT (fp, tp->ctt_info)
- && (rc = func (LCTF_INDEX_TO_TYPE (fp, id, child), arg)) != 0)
- return rc;
+ int rc;
+ if ((rc = func (type, arg)) != 0)
+ {
+ ctf_next_destroy (i);
+ return rc;
+ }
}
+ if (ctf_errno (fp) != ECTF_NEXT_END)
+ return -1; /* errno is set for us. */
return 0;
}
-/* Iterate over every type in the given CTF container, user-visible or not.
+/* Iterate over every type in the given CTF dict, user-visible or not.
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
of a single parent. */
int
-ctf_type_iter_all (ctf_file_t *fp, ctf_type_all_f *func, void *arg)
+ctf_type_iter_all (ctf_dict_t *fp, ctf_type_all_f *func, void *arg)
{
- ctf_id_t id, max = fp->ctf_typemax;
- int rc, child = (fp->ctf_flags & LCTF_CHILD);
+ ctf_next_t *i = NULL;
+ ctf_id_t type;
+ int flag;
- for (id = 1; id <= max; id++)
+ while ((type = ctf_type_next (fp, &i, &flag, 1)) != CTF_ERR)
{
- const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
- if ((rc = func (LCTF_INDEX_TO_TYPE (fp, id, child),
- LCTF_INFO_ISROOT(fp, tp->ctt_info)
- ? CTF_ADD_ROOT : CTF_ADD_NONROOT, arg) != 0))
- return rc;
+ int rc;
+ if ((rc = func (type, flag, arg)) != 0)
+ {
+ ctf_next_destroy (i);
+ return rc;
+ }
}
+ if (ctf_errno (fp) != ECTF_NEXT_END)
+ return -1; /* errno is set for us. */
return 0;
}
-/* Iterate over every type in the given CTF container, optionally including
+/* Iterate over every type in the given CTF dict, optionally including
non-user-visible types, returning each type ID and hidden flag in turn.
Returns CTF_ERR on end of iteration or error.
of a single parent. */
ctf_id_t
-ctf_type_next (ctf_file_t *fp, ctf_next_t **it, int *flag, int want_hidden)
+ctf_type_next (ctf_dict_t *fp, ctf_next_t **it, int *flag, int want_hidden)
{
ctf_next_t *i = *it;
return ctf_set_errno (fp, ECTF_NEXT_END);
}
-/* Iterate over every variable in the given CTF container, in arbitrary order.
+/* Iterate over every variable in the given CTF dict, in arbitrary order.
We pass the name of each variable to the specified callback function. */
int
-ctf_variable_iter (ctf_file_t *fp, ctf_variable_f *func, void *arg)
+ctf_variable_iter (ctf_dict_t *fp, ctf_variable_f *func, void *arg)
{
- int rc;
-
- if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
- return ECTF_NOPARENT;
+ ctf_next_t *i = NULL;
+ ctf_id_t type;
+ const char *name;
- if (!(fp->ctf_flags & LCTF_RDWR))
+ while ((type = ctf_variable_next (fp, &i, &name)) != CTF_ERR)
{
- unsigned long i;
- for (i = 0; i < fp->ctf_nvars; i++)
- if ((rc = func (ctf_strptr (fp, fp->ctf_vars[i].ctv_name),
- fp->ctf_vars[i].ctv_type, arg)) != 0)
- return rc;
- }
- else
- {
- ctf_dvdef_t *dvd;
-
- for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
- dvd = ctf_list_next (dvd))
+ int rc;
+ if ((rc = func (name, type, arg)) != 0)
{
- if ((rc = func (dvd->dvd_name, dvd->dvd_type, arg)) != 0)
- return rc;
+ ctf_next_destroy (i);
+ return rc;
}
}
+ if (ctf_errno (fp) != ECTF_NEXT_END)
+ return -1; /* errno is set for us. */
return 0;
}
-/* Iterate over every variable in the given CTF container, in arbitrary order,
+/* Iterate over every variable in the given CTF dict, 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_variable_next (ctf_dict_t *fp, ctf_next_t **it, const char **name)
{
ctf_next_t *i = *it;
against infinite loops, we implement simplified cycle detection and check
each link against itself, the previous node, and the topmost node.
- Does not drill down through slices to their contained type. */
+ Does not drill down through slices to their contained type.
+
+ Callers of this function must not presume that a type it returns must have a
+ valid ctt_size: forwards do not, and must be separately handled. */
ctf_id_t
-ctf_type_resolve (ctf_file_t *fp, ctf_id_t type)
+ctf_type_resolve (ctf_dict_t *fp, ctf_id_t type)
{
ctf_id_t prev = type, otype = type;
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
if (type == 0)
if (tp->ctt_type == type || tp->ctt_type == otype
|| tp->ctt_type == prev)
{
- ctf_dprintf ("type %ld cycle detected\n", otype);
+ ctf_err_warn (ofp, 0, ECTF_CORRUPT, _("type %lx cycle detected"),
+ otype);
return (ctf_set_errno (ofp, ECTF_CORRUPT));
}
prev = type;
type = tp->ctt_type;
break;
+ case CTF_K_UNKNOWN:
+ return (ctf_set_errno (ofp, ECTF_NONREPRESENTABLE));
default:
return type;
}
type. */
ctf_id_t
-ctf_type_resolve_unsliced (ctf_file_t *fp, ctf_id_t type)
+ctf_type_resolve_unsliced (ctf_dict_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
return type;
}
+/* Return the native dict of a given type: if called on a child and the
+ type is in the parent, return the parent. Needed if you plan to access
+ the type directly, without using the API. */
+ctf_dict_t *
+ctf_get_dict (ctf_dict_t *fp, ctf_id_t type)
+{
+ if ((fp->ctf_flags & LCTF_CHILD) && LCTF_TYPE_ISPARENT (fp, type))
+ return fp->ctf_parent;
+
+ return fp;
+}
+
/* Look up a name in the given name table, in the appropriate hash given the
kind of the identifier. The name is a raw, undecorated identifier. */
-ctf_id_t ctf_lookup_by_rawname (ctf_file_t *fp, int kind, const char *name)
+ctf_id_t ctf_lookup_by_rawname (ctf_dict_t *fp, int kind, const char *name)
{
return ctf_lookup_by_rawhash (fp, ctf_name_table (fp, kind), name);
}
readability state of the dictionary. The name is a raw, undecorated
identifier. */
-ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *fp, ctf_names_t *np, const char *name)
+ctf_id_t ctf_lookup_by_rawhash (ctf_dict_t *fp, ctf_names_t *np, const char *name)
{
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;
string. */
char *
-ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
+ctf_type_aname (ctf_dict_t *fp, ctf_id_t type)
{
ctf_decl_t cd;
ctf_decl_node_t *cdp;
for (cdp = ctf_list_next (&cd.cd_nodes[prec]);
cdp != NULL; cdp = ctf_list_next (cdp))
{
- ctf_file_t *rfp = fp;
+ ctf_dict_t *rfp = fp;
const ctf_type_t *tp = ctf_lookup_by_id (&rfp, cdp->cd_type);
const char *name = ctf_strptr (rfp, tp->ctt_name);
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:
ctf_decl_sprintf (&cd, "struct %s", name);
break;
case CTF_K_UNION:
case CTF_K_ENUM:
ctf_decl_sprintf (&cd, "enum %s", name);
break;
+ case CTF_K_FORWARD:
+ {
+ switch (ctf_type_kind_forwarded (fp, cdp->cd_type))
+ {
+ case CTF_K_STRUCT:
+ ctf_decl_sprintf (&cd, "struct %s", name);
+ break;
+ case CTF_K_UNION:
+ ctf_decl_sprintf (&cd, "union %s", name);
+ break;
+ case CTF_K_ENUM:
+ ctf_decl_sprintf (&cd, "enum %s", name);
+ break;
+ default:
+ ctf_set_errno (fp, ECTF_CORRUPT);
+ ctf_decl_fini (&cd);
+ return NULL;
+ }
+ break;
+ }
case CTF_K_VOLATILE:
ctf_decl_sprintf (&cd, "volatile");
break;
case CTF_K_RESTRICT:
ctf_decl_sprintf (&cd, "restrict");
break;
- case CTF_K_SLICE:
- /* No representation: just changes encoding of contained type,
- which is not in any case printed. Skip it. */
+ case CTF_K_UNKNOWN:
+ if (name[0] == '\0')
+ ctf_decl_sprintf (&cd, _("(nonrepresentable type)"));
+ else
+ ctf_decl_sprintf (&cd, _("(nonrepresentable type %s)"),
+ name);
break;
}
the actual number of bytes (not including \0) needed to format the name. */
ssize_t
-ctf_type_lname (ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
+ctf_type_lname (ctf_dict_t *fp, ctf_id_t type, char *buf, size_t len)
{
char *str = ctf_type_aname (fp, type);
size_t slen;
is too small, return NULL: the ECTF_NAMELEN error is set on 'fp' for us. */
char *
-ctf_type_name (ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
+ctf_type_name (ctf_dict_t *fp, ctf_id_t type, char *buf, size_t len)
{
ssize_t rv = ctf_type_lname (fp, type, buf, len);
return (rv >= 0 && (size_t) rv < len ? buf : NULL);
}
/* Lookup the given type ID and return its raw, unadorned, undecorated name.
- The name will live as long as its ctf_file_t does. */
+ The name will live as long as its ctf_dict_t does.
+
+ The only decoration is that a NULL return always means an error: nameless
+ types return a null string. */
const char *
-ctf_type_name_raw (ctf_file_t *fp, ctf_id_t type)
+ctf_type_name_raw (ctf_dict_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 (tp->ctt_name == 0)
+ return "";
+
return ctf_strraw (fp, tp->ctt_name);
}
new dynamically-allocated string. */
char *
-ctf_type_aname_raw (ctf_file_t *fp, ctf_id_t type)
+ctf_type_aname_raw (ctf_dict_t *fp, ctf_id_t type)
{
const char *name = ctf_type_name_raw (fp, type);
of the type storage in bytes. */
ssize_t
-ctf_type_size (ctf_file_t *fp, ctf_id_t type)
+ctf_type_size (ctf_dict_t *fp, ctf_id_t type)
{
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
ssize_t size;
ctf_arinfo_t ar;
if ((size = ctf_get_ctt_size (fp, tp, NULL, NULL)) > 0)
return size;
- if (ctf_array_info (fp, type, &ar) < 0
- || (size = ctf_type_size (fp, ar.ctr_contents)) < 0)
+ if (ctf_array_info (ofp, type, &ar) < 0
+ || (size = ctf_type_size (ofp, ar.ctr_contents)) < 0)
return -1; /* errno is set for us. */
return size * ar.ctr_nelems;
+ case CTF_K_FORWARD:
+ /* Forwards do not have a meaningful size. */
+ return (ctf_set_errno (ofp, ECTF_INCOMPLETE));
+
default: /* including slices of enums, etc */
return (ctf_get_ctt_size (fp, tp, NULL, NULL));
}
XXX may need arch-dependent attention. */
ssize_t
-ctf_type_align (ctf_file_t *fp, ctf_id_t type)
+ctf_type_align (ctf_dict_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
int kind;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
case CTF_K_ARRAY:
{
ctf_arinfo_t r;
- if (ctf_array_info (fp, type, &r) < 0)
+ if (ctf_array_info (ofp, type, &r) < 0)
return -1; /* errno is set for us. */
- return (ctf_type_align (fp, r.ctr_contents));
+ return (ctf_type_align (ofp, r.ctr_contents));
}
case CTF_K_STRUCT:
{
size_t align = 0;
ctf_dtdef_t *dtd;
+ unsigned char *vlen;
+ uint32_t i = 0, n = LCTF_INFO_VLEN (fp, tp->ctt_info);
+ ssize_t size, increment, vbytes;
- if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
- {
- uint32_t n = LCTF_INFO_VLEN (fp, tp->ctt_info);
- ssize_t size, increment;
- const void *vmp;
-
- (void) ctf_get_ctt_size (fp, tp, &size, &increment);
- vmp = (unsigned char *) tp + increment;
+ ctf_get_ctt_size (fp, tp, &size, &increment);
- if (kind == CTF_K_STRUCT)
- n = MIN (n, 1); /* Only use first member for structs. */
-
- if (size < CTF_LSTRUCT_THRESH)
- {
- const ctf_member_t *mp = vmp;
- for (; n != 0; n--, mp++)
- {
- ssize_t am = ctf_type_align (fp, mp->ctm_type);
- align = MAX (align, (size_t) am);
- }
- }
- else
- {
- const ctf_lmember_t *lmp = vmp;
- for (; n != 0; n--, lmp++)
- {
- ssize_t am = ctf_type_align (fp, lmp->ctlm_type);
- align = MAX (align, (size_t) am);
- }
- }
+ if ((dtd = ctf_dynamic_type (fp, type)) != NULL)
+ {
+ vlen = dtd->dtd_vlen;
+ vbytes = dtd->dtd_vlen_alloc;
}
else
{
- ctf_dmdef_t *dmd;
-
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
- {
- ssize_t am = ctf_type_align (fp, dmd->dmd_type);
- align = MAX (align, (size_t) am);
- if (kind == CTF_K_STRUCT)
- break;
- }
+ vlen = (unsigned char *) tp + increment;
+ vbytes = LCTF_VBYTES (fp, kind, size, n);
}
+ if (kind == CTF_K_STRUCT)
+ n = MIN (n, 1); /* Only use first member for structs. */
+
+ for (; n != 0; n--, i++)
+ {
+ ctf_lmember_t memb;
+
+ if (ctf_struct_member (fp, &memb, tp, vlen, vbytes, i) < 0)
+ return -1; /* errno is set for us. */
+
+ ssize_t am = ctf_type_align (ofp, memb.ctlm_type);
+ align = MAX (align, (size_t) am);
+ }
return align;
}
case CTF_K_ENUM:
return fp->ctf_dmodel->ctd_int;
+ case CTF_K_FORWARD:
+ /* Forwards do not have a meaningful alignment. */
+ return (ctf_set_errno (ofp, ECTF_INCOMPLETE));
+
default: /* including slices of enums, etc */
return (ctf_get_ctt_size (fp, tp, NULL, NULL));
}
/* Return the kind (CTF_K_* constant) for the specified type ID. */
int
-ctf_type_kind_unsliced (ctf_file_t *fp, ctf_id_t type)
+ctf_type_kind_unsliced (ctf_dict_t *fp, ctf_id_t type)
{
const ctf_type_t *tp;
Slices are considered to be of the same kind as the type sliced. */
int
-ctf_type_kind (ctf_file_t *fp, ctf_id_t type)
+ctf_type_kind (ctf_dict_t *fp, ctf_id_t type)
{
int 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)
+ctf_type_kind_forwarded (ctf_dict_t *fp, ctf_id_t type)
{
int kind;
const ctf_type_t *tp;
then return the ID of the type to which it refers. */
ctf_id_t
-ctf_type_reference (ctf_file_t *fp, ctf_id_t type)
+ctf_type_reference (ctf_dict_t *fp, ctf_id_t type)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
sp = (const ctf_slice_t *) ((uintptr_t) tp + increment);
}
else
- sp = &dtd->dtd_u.dtu_slice;
+ sp = (const ctf_slice_t *) dtd->dtd_vlen;
return sp->cts_type;
}
instead. This helps with cases where the CTF data includes "struct foo *"
but not "foo_t *" and the user accesses "foo_t *" in the debugger.
- XXX what about parent containers? */
+ XXX what about parent dicts? */
ctf_id_t
-ctf_type_pointer (ctf_file_t *fp, ctf_id_t type)
+ctf_type_pointer (ctf_dict_t *fp, ctf_id_t type)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
ctf_id_t ntype;
if (ctf_lookup_by_id (&fp, type) == NULL)
return (ctf_set_errno (ofp, ECTF_NOTYPE));
}
-/* Return the encoding for the specified INTEGER or FLOAT. */
+/* Return the encoding for the specified INTEGER, FLOAT, or ENUM. */
int
-ctf_type_encoding (ctf_file_t *fp, ctf_id_t type, ctf_encoding_t *ep)
+ctf_type_encoding (ctf_dict_t *fp, ctf_id_t type, ctf_encoding_t *ep)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
ctf_dtdef_t *dtd;
const ctf_type_t *tp;
ssize_t increment;
+ const unsigned char *vlen;
uint32_t data;
if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
return -1; /* errno is set for us. */
if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
+ vlen = dtd->dtd_vlen;
+ else
{
- 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;
+ ctf_get_ctt_size (fp, tp, NULL, &increment);
+ vlen = (const unsigned char *) ((uintptr_t) tp + increment);
}
- (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
-
switch (LCTF_INFO_KIND (fp, tp->ctt_info))
{
case CTF_K_INTEGER:
- data = *(const uint32_t *) ((uintptr_t) tp + increment);
+ data = *(const uint32_t *) vlen;
ep->cte_format = CTF_INT_ENCODING (data);
ep->cte_offset = CTF_INT_OFFSET (data);
ep->cte_bits = CTF_INT_BITS (data);
break;
case CTF_K_FLOAT:
- data = *(const uint32_t *) ((uintptr_t) tp + increment);
+ data = *(const uint32_t *) vlen;
ep->cte_format = CTF_FP_ENCODING (data);
ep->cte_offset = CTF_FP_OFFSET (data);
ep->cte_bits = CTF_FP_BITS (data);
break;
+ case CTF_K_ENUM:
+ /* v3 only: we must guess at the underlying integral format. */
+ ep->cte_format = CTF_INT_SIGNED;
+ ep->cte_offset = 0;
+ ep->cte_bits = 0;
+ break;
case CTF_K_SLICE:
{
const ctf_slice_t *slice;
ctf_encoding_t underlying_en;
ctf_id_t underlying;
- slice = (ctf_slice_t *) ((uintptr_t) tp + increment);
+ slice = (ctf_slice_t *) vlen;
underlying = ctf_type_resolve (fp, slice->cts_type);
- data = ctf_type_encoding (fp, underlying, &underlying_en);
+ if (ctf_type_encoding (fp, underlying, &underlying_en) < 0)
+ return -1; /* errno is set for us. */
ep->cte_format = underlying_en.cte_format;
ep->cte_offset = slice->cts_offset;
}
int
-ctf_type_cmp (ctf_file_t *lfp, ctf_id_t ltype, ctf_file_t *rfp,
+ctf_type_cmp (ctf_dict_t *lfp, ctf_id_t ltype, ctf_dict_t *rfp,
ctf_id_t rtype)
{
int rval;
unions) member count. */
int
-ctf_type_compat (ctf_file_t *lfp, ctf_id_t ltype,
- ctf_file_t *rfp, ctf_id_t rtype)
+ctf_type_compat (ctf_dict_t *lfp, ctf_id_t ltype,
+ ctf_dict_t *rfp, ctf_id_t rtype)
{
const ctf_type_t *ltp, *rtp;
ctf_encoding_t le, re;
}
/* Return the number of members in a STRUCT or UNION, or the number of
- enumerators in an ENUM. */
+ enumerators in an ENUM. The count does not include unnamed sub-members. */
int
-ctf_member_count (ctf_file_t *fp, ctf_id_t type)
+ctf_member_count (ctf_dict_t *fp, ctf_id_t type)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
uint32_t kind;
/* Return the type and offset for a given member of a STRUCT or UNION. */
int
-ctf_member_info (ctf_file_t *fp, ctf_id_t type, const char *name,
+ctf_member_info (ctf_dict_t *fp, ctf_id_t type, const char *name,
ctf_membinfo_t *mip)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
ctf_dtdef_t *dtd;
- ssize_t size, increment;
- uint32_t kind, n;
+ unsigned char *vlen;
+ ssize_t size, increment, vbytes;
+ uint32_t kind, n, i = 0;
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. */
- (void) ctf_get_ctt_size (fp, tp, &size, &increment);
+ ctf_get_ctt_size (fp, tp, &size, &increment);
kind = LCTF_INFO_KIND (fp, tp->ctt_info);
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
return (ctf_set_errno (ofp, ECTF_NOTSOU));
- if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
+ n = LCTF_INFO_VLEN (fp, tp->ctt_info);
+ if ((dtd = ctf_dynamic_type (fp, type)) != NULL)
{
- if (size < CTF_LSTRUCT_THRESH)
- {
- const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
- increment);
-
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
- {
- if (strcmp (ctf_strptr (fp, mp->ctm_name), name) == 0)
- {
- mip->ctm_type = mp->ctm_type;
- mip->ctm_offset = mp->ctm_offset;
- return 0;
- }
- }
- }
- else
- {
- const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
- increment);
-
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
- {
- if (strcmp (ctf_strptr (fp, lmp->ctlm_name), name) == 0)
- {
- mip->ctm_type = lmp->ctlm_type;
- mip->ctm_offset = (unsigned long) CTF_LMEM_OFFSET (lmp);
- return 0;
- }
- }
- }
+ vlen = dtd->dtd_vlen;
+ vbytes = dtd->dtd_vlen_alloc;
}
else
{
- ctf_dmdef_t *dmd;
+ vlen = (unsigned char *) tp + increment;
+ vbytes = LCTF_VBYTES (fp, kind, size, n);
+ }
+
+ for (; n != 0; n--, i++)
+ {
+ ctf_lmember_t memb;
+ const char *membname;
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
+ if (ctf_struct_member (fp, &memb, tp, vlen, vbytes, i) < 0)
+ return -1; /* errno is set for us. */
+
+ membname = ctf_strptr (fp, memb.ctlm_name);
+
+ if (membname[0] == 0
+ && (ctf_type_kind (fp, memb.ctlm_type) == CTF_K_STRUCT
+ || ctf_type_kind (fp, memb.ctlm_type) == CTF_K_UNION)
+ && (ctf_member_info (fp, memb.ctlm_type, name, mip) == 0))
+ return 0;
+
+ if (strcmp (membname, name) == 0)
{
- if (strcmp (dmd->dmd_name, name) == 0)
- {
- mip->ctm_type = dmd->dmd_type;
- mip->ctm_offset = dmd->dmd_offset;
- return 0;
- }
+ mip->ctm_type = memb.ctlm_type;
+ mip->ctm_offset = (unsigned long) CTF_LMEM_OFFSET (&memb);
+ return 0;
}
}
/* Return the array type, index, and size information for the specified ARRAY. */
int
-ctf_array_info (ctf_file_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
+ctf_array_info (ctf_dict_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
const ctf_array_t *ap;
const ctf_dtdef_t *dtd;
return (ctf_set_errno (ofp, ECTF_NOTARRAY));
if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
+ ap = (const ctf_array_t *) dtd->dtd_vlen;
+ else
{
- *arp = dtd->dtd_u.dtu_arr;
- return 0;
+ ctf_get_ctt_size (fp, tp, NULL, &increment);
+ ap = (const ctf_array_t *) ((uintptr_t) tp + increment);
}
-
- (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
-
- ap = (const ctf_array_t *) ((uintptr_t) tp + increment);
arp->ctr_contents = ap->cta_contents;
arp->ctr_index = ap->cta_index;
arp->ctr_nelems = ap->cta_nelems;
matching name can be found. Otherwise NULL is returned. */
const char *
-ctf_enum_name (ctf_file_t *fp, ctf_id_t type, int value)
+ctf_enum_name (ctf_dict_t *fp, ctf_id_t type, int value)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
const ctf_enum_t *ep;
const ctf_dtdef_t *dtd;
if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
{
- (void) ctf_set_errno (ofp, ECTF_NOTENUM);
+ ctf_set_errno (ofp, ECTF_NOTENUM);
return NULL;
}
- (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
+ ctf_get_ctt_size (fp, tp, NULL, &increment);
if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
- {
- ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
-
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
- {
- if (ep->cte_value == value)
- return (ctf_strptr (fp, ep->cte_name));
- }
- }
+ ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
else
- {
- ctf_dmdef_t *dmd;
+ ep = (const ctf_enum_t *) dtd->dtd_vlen;
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
- {
- if (dmd->dmd_value == value)
- return dmd->dmd_name;
- }
+ for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+ {
+ if (ep->cte_value == value)
+ return (ctf_strptr (fp, ep->cte_name));
}
- (void) ctf_set_errno (ofp, ECTF_NOENUMNAM);
+ ctf_set_errno (ofp, ECTF_NOENUMNAM);
return NULL;
}
matching name can be found. Otherwise CTF_ERR is returned. */
int
-ctf_enum_value (ctf_file_t * fp, ctf_id_t type, const char *name, int *valp)
+ctf_enum_value (ctf_dict_t *fp, ctf_id_t type, const char *name, int *valp)
{
- ctf_file_t *ofp = fp;
+ ctf_dict_t *ofp = fp;
const ctf_type_t *tp;
const ctf_enum_t *ep;
const ctf_dtdef_t *dtd;
return -1;
}
- (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
-
- ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
+ ctf_get_ctt_size (fp, tp, NULL, &increment);
if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
- {
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
- {
- if (strcmp (ctf_strptr (fp, ep->cte_name), name) == 0)
- {
- if (valp != NULL)
- *valp = ep->cte_value;
- return 0;
- }
- }
- }
+ ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
else
- {
- ctf_dmdef_t *dmd;
+ ep = (const ctf_enum_t *) dtd->dtd_vlen;
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
+ for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
+ {
+ if (strcmp (ctf_strptr (fp, ep->cte_name), name) == 0)
{
- if (strcmp (dmd->dmd_name, name) == 0)
- {
- if (valp != NULL)
- *valp = dmd->dmd_value;
- return 0;
- }
+ if (valp != NULL)
+ *valp = ep->cte_value;
+ return 0;
}
}
- (void) ctf_set_errno (ofp, ECTF_NOENUMNAM);
+ ctf_set_errno (ofp, ECTF_NOENUMNAM);
return -1;
}
arg counts for that function. */
int
-ctf_func_type_info (ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
+ctf_func_type_info (ctf_dict_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
{
const ctf_type_t *tp;
uint32_t kind;
if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
args = (uint32_t *) ((uintptr_t) tp + increment);
else
- args = dtd->dtd_u.dtu_argv;
+ args = (uint32_t *) dtd->dtd_vlen;
if (fip->ctc_argc != 0 && args[fip->ctc_argc - 1] == 0)
{
function. */
int
-ctf_func_type_args (ctf_file_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv)
+ctf_func_type_args (ctf_dict_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv)
{
const ctf_type_t *tp;
const uint32_t *args;
if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
args = (uint32_t *) ((uintptr_t) tp + increment);
else
- args = dtd->dtd_u.dtu_argv;
+ args = (uint32_t *) dtd->dtd_vlen;
for (argc = MIN (argc, f.ctc_argc); argc != 0; argc--)
*argv++ = *args++;
returns non-zero, we abort and percolate the error code back up to the top. */
static int
-ctf_type_rvisit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func,
+ctf_type_rvisit (ctf_dict_t *fp, ctf_id_t type, ctf_visit_f *func,
void *arg, const char *name, unsigned long offset, int depth)
{
ctf_id_t otype = type;
const ctf_type_t *tp;
const ctf_dtdef_t *dtd;
- ssize_t size, increment;
- uint32_t kind, n;
+ unsigned char *vlen;
+ ssize_t size, increment, vbytes;
+ uint32_t kind, n, i = 0;
int rc;
if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
return 0;
- (void) ctf_get_ctt_size (fp, tp, &size, &increment);
+ ctf_get_ctt_size (fp, tp, &size, &increment);
- if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
+ n = LCTF_INFO_VLEN (fp, tp->ctt_info);
+ if ((dtd = ctf_dynamic_type (fp, type)) != NULL)
{
- if (size < CTF_LSTRUCT_THRESH)
- {
- const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
- increment);
-
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
- {
- if ((rc = ctf_type_rvisit (fp, mp->ctm_type,
- func, arg, ctf_strptr (fp,
- mp->ctm_name),
- offset + mp->ctm_offset,
- depth + 1)) != 0)
- return rc;
- }
- }
- else
- {
- const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
- increment);
-
- for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
- {
- if ((rc = ctf_type_rvisit (fp, lmp->ctlm_type,
- func, arg, ctf_strptr (fp,
- lmp->ctlm_name),
- offset + (unsigned long) CTF_LMEM_OFFSET (lmp),
- depth + 1)) != 0)
- return rc;
- }
- }
+ vlen = dtd->dtd_vlen;
+ vbytes = dtd->dtd_vlen_alloc;
}
else
{
- ctf_dmdef_t *dmd;
+ vlen = (unsigned char *) tp + increment;
+ vbytes = LCTF_VBYTES (fp, kind, size, n);
+ }
- for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
- dmd != NULL; dmd = ctf_list_next (dmd))
- {
- if ((rc = ctf_type_rvisit (fp, dmd->dmd_type, func, arg,
- dmd->dmd_name, dmd->dmd_offset,
- depth + 1)) != 0)
- return rc;
- }
+ for (; n != 0; n--, i++)
+ {
+ ctf_lmember_t memb;
+
+ if (ctf_struct_member (fp, &memb, tp, vlen, vbytes, i) < 0)
+ return -1; /* errno is set for us. */
+
+ if ((rc = ctf_type_rvisit (fp, memb.ctlm_type,
+ func, arg, ctf_strptr (fp, memb.ctlm_name),
+ offset + (unsigned long) CTF_LMEM_OFFSET (&memb),
+ depth + 1)) != 0)
+ return rc;
}
return 0;
/* Recursively visit the members of any type. We pass the name, member
type, and offset of each member to the specified callback function. */
int
-ctf_type_visit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg)
+ctf_type_visit (ctf_dict_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg)
{
return (ctf_type_rvisit (fp, type, func, arg, "", 0, 0));
}