]> Git Repo - binutils.git/blobdiff - libctf/ctf-types.c
projects / binutils.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Automatic date update in version.in
[binutils.git] / libctf / ctf-types.c
diff --git a/libctf/ctf-types.c b/libctf/ctf-types.c
index d7ed0e31dca3d3926e59f9a4d15c439d5e7ee135..220bbb528fbccf5dae9f081d0181f0efadc7f4de 100644 (file)
--- a/libctf/ctf-types.c
+++ b/libctf/ctf-types.c
@@ -1,5 +1,5 @@
 /* Type handling functions.
 /* Type handling functions.
-   Copyright (C) 2019-2020 Free Software Foundation, Inc.
+   Copyright (C) 2019-2022 Free Software Foundation, Inc.
 
    This file is part of libctf.
 
 
    This file is part of libctf.
 
@@ -24,103 +24,93 @@
 /* Determine whether a type is a parent or a child.  */
 
 int
 /* 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
 {
   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));
 }
 
 {
   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
     {
     }
   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,
 
   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
 
 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 kind;
   ssize_t offset;
+  uint32_t max_vlen;
   ctf_next_t *i = *it;
 
   if (!i)
     {
       const ctf_type_t *tp;
       ctf_dtdef_t *dtd;
   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 ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
        return -1;                      /* errno is set for us.  */
@@ -131,9 +121,9 @@ ctf_member_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
       if ((i = ctf_next_create ()) == NULL)
        return ctf_set_errno (ofp, ENOMEM);
       i->cu.ctn_fp = ofp;
       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)
       kind = LCTF_INFO_KIND (fp, tp->ctt_info);
 
       if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
@@ -142,29 +132,20 @@ ctf_member_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
          return (ctf_set_errno (ofp, ECTF_NOTSOU));
        }
 
          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
        }
       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;
     }
 
       *it = i;
     }
 
@@ -178,41 +159,72 @@ ctf_member_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
   if ((fp = ctf_get_dict (ofp, type)) == NULL)
     return (ctf_set_errno (ofp, ECTF_NOPARENT));
 
   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;
 
        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
     {
   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;
     }
 
   return offset;
@@ -227,49 +239,23 @@ ctf_member_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
    integer value of each enum element to the specified callback function.  */
 
 int
    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);
-
-  if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
-    {
-      ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
+  ctf_next_t *i = NULL;
+  const char *name;
+  int val;
 
 
-      for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
-       {
-         const char *name = ctf_strptr (fp, ep->cte_name);
-         if ((rc = func (name, ep->cte_value, arg)) != 0)
-           return rc;
-       }
-    }
-  else
+  while ((name = ctf_enum_next (fp, type, &i, &val)) != NULL)
     {
     {
-      ctf_dmdef_t *dmd;
-
-      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
-          dmd != NULL; dmd = ctf_list_next (dmd))
+      int rc;
+      if ((rc = func (name, val, arg)) != 0)
        {
        {
-         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;
 }
 
   return 0;
 }
@@ -279,10 +265,10 @@ ctf_enum_iter (ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
    enumerand's integer VALue.  */
 
 const char *
    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)
 {
               int *val)
 {
-  ctf_file_t *ofp = fp;
+  ctf_dict_t *ofp = fp;
   uint32_t kind;
   const char *name;
   ctf_next_t *i = *it;
   uint32_t kind;
   const char *name;
   ctf_next_t *i = *it;
@@ -318,22 +304,13 @@ ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
 
       dtd = ctf_dynamic_type (fp, type);
       i->ctn_iter_fun = (void (*) (void)) ctf_enum_next;
 
       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)
 
       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
       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;
     }
 
       *it = i;
     }
@@ -357,27 +334,14 @@ ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
       return NULL;
     }
 
       return NULL;
     }
 
-  if (!(fp->ctf_flags & LCTF_RDWR))
-    {
-      if (i->ctn_n == 0)
-       goto end_iter;
+  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);
-    }
+  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 name;
 
@@ -388,7 +352,7 @@ ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
   return NULL;
 }
 
   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
    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
@@ -396,23 +360,27 @@ ctf_enum_next (ctf_file_t *fp, ctf_id_t type, ctf_next_t **it,
    of a single parent.  */
 
 int
    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;
 }
 
 
   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
    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
@@ -420,24 +388,28 @@ ctf_type_iter (ctf_file_t *fp, ctf_type_f *func, void *arg)
    of a single parent.  */
 
 int
    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;
 }
 
 
   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.
 
    non-user-visible types, returning each type ID and hidden flag in turn.
    Returns CTF_ERR on end of iteration or error.
 
@@ -446,7 +418,7 @@ ctf_type_iter_all (ctf_file_t *fp, ctf_type_all_f *func, void *arg)
    of a single parent.  */
 
 ctf_id_t
    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;
 
 {
   ctf_next_t *i = *it;
 
@@ -486,46 +458,37 @@ ctf_type_next (ctf_file_t *fp, ctf_next_t **it, int *flag, int want_hidden)
   return ctf_set_errno (fp, ECTF_NEXT_END);
 }
 
   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
    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))
-    {
-      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
+  while ((type = ctf_variable_next (fp, &i, &name)) != CTF_ERR)
     {
     {
-      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;
 }
 
 
   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
    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;
 
 {
   ctf_next_t *i = *it;
 
@@ -583,13 +546,16 @@ ctf_variable_next (ctf_file_t *fp, ctf_next_t **it, const char **name)
    against infinite loops, we implement simplified cycle detection and check
    each link against itself, the previous node, and the topmost node.
 
    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_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_id_t prev = type, otype = type;
-  ctf_file_t *ofp = fp;
+  ctf_dict_t *ofp = fp;
   const ctf_type_t *tp;
 
   if (type == 0)
   const ctf_type_t *tp;
 
   if (type == 0)
@@ -606,12 +572,15 @@ ctf_type_resolve (ctf_file_t *fp, ctf_id_t type)
          if (tp->ctt_type == type || tp->ctt_type == otype
              || tp->ctt_type == prev)
            {
          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;
              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;
        }
        default:
          return type;
        }
@@ -626,7 +595,7 @@ ctf_type_resolve (ctf_file_t *fp, ctf_id_t type)
    type.  */
 
 ctf_id_t
    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;
 
 {
   const ctf_type_t *tp;
 
@@ -641,10 +610,22 @@ ctf_type_resolve_unsliced (ctf_file_t *fp, ctf_id_t type)
   return type;
 }
 
   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.  */
 
 /* 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);
 }
 {
   return ctf_lookup_by_rawhash (fp, ctf_name_table (fp, kind), name);
 }
@@ -653,12 +634,12 @@ ctf_id_t ctf_lookup_by_rawname (ctf_file_t *fp, int kind, const char *name)
    readability state of the dictionary.  The name is a raw, undecorated
    identifier.  */
 
    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)
 {
   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;
   else
     id = ctf_hash_lookup_type (np->ctn_readonly, fp, name);
   return id;
@@ -668,7 +649,7 @@ ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *fp, ctf_names_t *np, const char *nam
    string.  */
 
 char *
    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;
 {
   ctf_decl_t cd;
   ctf_decl_node_t *cdp;
@@ -709,7 +690,7 @@ ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
       for (cdp = ctf_list_next (&cd.cd_nodes[prec]);
           cdp != NULL; cdp = ctf_list_next (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);
 
          const ctf_type_t *tp = ctf_lookup_by_id (&rfp, cdp->cd_type);
          const char *name = ctf_strptr (rfp, tp->ctt_name);
 
@@ -745,10 +726,53 @@ ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
              ctf_decl_sprintf (&cd, "[%u]", cdp->cd_n);
              break;
            case CTF_K_FUNCTION:
              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:
              break;
            case CTF_K_STRUCT:
-           case CTF_K_FORWARD:
              ctf_decl_sprintf (&cd, "struct %s", name);
              break;
            case CTF_K_UNION:
              ctf_decl_sprintf (&cd, "struct %s", name);
              break;
            case CTF_K_UNION:
@@ -757,6 +781,26 @@ ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
            case CTF_K_ENUM:
              ctf_decl_sprintf (&cd, "enum %s", name);
              break;
            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_VOLATILE:
              ctf_decl_sprintf (&cd, "volatile");
              break;
@@ -766,9 +810,12 @@ ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
            case CTF_K_RESTRICT:
              ctf_decl_sprintf (&cd, "restrict");
              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;
            }
 
              break;
            }
 
@@ -792,7 +839,7 @@ ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
    the actual number of bytes (not including \0) needed to format the name.  */
 
 ssize_t
    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;
 {
   char *str = ctf_type_aname (fp, type);
   size_t slen;
@@ -814,23 +861,29 @@ ctf_type_lname (ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
    is too small, return NULL: the ECTF_NAMELEN error is set on 'fp' for us.  */
 
 char *
    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.
 {
   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 *
 
 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.  */
 
 {
   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);
 }
 
   return ctf_strraw (fp, tp->ctt_name);
 }
 
@@ -838,7 +891,7 @@ ctf_type_name_raw (ctf_file_t *fp, ctf_id_t type)
    new dynamically-allocated string.  */
 
 char *
    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);
 
 {
   const char *name = ctf_type_name_raw (fp, type);
 
@@ -852,8 +905,9 @@ ctf_type_aname_raw (ctf_file_t *fp, ctf_id_t type)
    of the type storage in bytes.  */
 
 ssize_t
    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;
   const ctf_type_t *tp;
   ssize_t size;
   ctf_arinfo_t ar;
@@ -885,12 +939,16 @@ ctf_type_size (ctf_file_t *fp, ctf_id_t type)
       if ((size = ctf_get_ctt_size (fp, tp, NULL, NULL)) > 0)
        return size;
 
       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;
 
        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));
     }
     default: /* including slices of enums, etc */
       return (ctf_get_ctt_size (fp, tp, NULL, NULL));
     }
@@ -902,10 +960,10 @@ ctf_type_size (ctf_file_t *fp, ctf_id_t type)
    XXX may need arch-dependent attention.  */
 
 ssize_t
    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;
 {
   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)
   int kind;
 
   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
@@ -924,9 +982,9 @@ ctf_type_align (ctf_file_t *fp, ctf_id_t type)
     case CTF_K_ARRAY:
       {
        ctf_arinfo_t r;
     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 -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:
       }
 
     case CTF_K_STRUCT:
@@ -934,58 +992,46 @@ ctf_type_align (ctf_file_t *fp, ctf_id_t type)
       {
        size_t align = 0;
        ctf_dtdef_t *dtd;
       {
        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
          {
          }
        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;
 
        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));
     }
     default:  /* including slices of enums, etc */
       return (ctf_get_ctt_size (fp, tp, NULL, NULL));
     }
@@ -994,7 +1040,7 @@ ctf_type_align (ctf_file_t *fp, ctf_id_t type)
 /* Return the kind (CTF_K_* constant) for the specified type ID.  */
 
 int
 /* 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;
 
 {
   const ctf_type_t *tp;
 
@@ -1008,7 +1054,7 @@ ctf_type_kind_unsliced (ctf_file_t *fp, ctf_id_t type)
    Slices are considered to be of the same kind as the type sliced.  */
 
 int
    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;
 
 {
   int kind;
 
@@ -1028,7 +1074,7 @@ ctf_type_kind (ctf_file_t *fp, ctf_id_t type)
 /* Return the kind of this type, except, for forwards, return the kind of thing
    this is a forward to.  */
 int
 /* 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;
 {
   int kind;
   const ctf_type_t *tp;
@@ -1049,9 +1095,9 @@ ctf_type_kind_forwarded (ctf_file_t *fp, ctf_id_t type)
    then return the ID of the type to which it refers.  */
 
 ctf_id_t
    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)
   const ctf_type_t *tp;
 
   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
@@ -1079,7 +1125,7 @@ ctf_type_reference (ctf_file_t *fp, ctf_id_t type)
            sp = (const ctf_slice_t *) ((uintptr_t) tp + increment);
          }
        else
            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;
       }
 
        return sp->cts_type;
       }
@@ -1094,12 +1140,12 @@ ctf_type_reference (ctf_file_t *fp, ctf_id_t 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.
 
    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_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)
   ctf_id_t ntype;
 
   if (ctf_lookup_by_id (&fp, type) == NULL)
@@ -1120,74 +1166,59 @@ ctf_type_pointer (ctf_file_t *fp, ctf_id_t type)
   return (ctf_set_errno (ofp, ECTF_NOTYPE));
 }
 
   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
 
 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;
   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)
   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:
   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:
       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;
       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;
 
     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);
        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;
 
        ep->cte_format = underlying_en.cte_format;
        ep->cte_offset = slice->cts_offset;
@@ -1202,7 +1233,7 @@ ctf_type_encoding (ctf_file_t *fp, ctf_id_t type, ctf_encoding_t *ep)
 }
 
 int
 }
 
 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;
              ctf_id_t rtype)
 {
   int rval;
@@ -1239,8 +1270,8 @@ ctf_type_cmp (ctf_file_t *lfp, ctf_id_t ltype, ctf_file_t *rfp,
    unions) member count.  */
 
 int
    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;
 {
   const ctf_type_t *ltp, *rtp;
   ctf_encoding_t le, re;
@@ -1312,12 +1343,12 @@ ctf_type_compat (ctf_file_t *lfp, ctf_id_t ltype,
 }
 
 /* Return the number of members in a STRUCT or UNION, or the number of
 }
 
 /* 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
 
 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;
 
   const ctf_type_t *tp;
   uint32_t kind;
 
@@ -1338,14 +1369,15 @@ ctf_member_count (ctf_file_t *fp, ctf_id_t type)
 /* Return the type and offset for a given member of a STRUCT or UNION.  */
 
 int
 /* 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_membinfo_t *mip)
 {
-  ctf_file_t *ofp = fp;
+  ctf_dict_t *ofp = fp;
   const ctf_type_t *tp;
   ctf_dtdef_t *dtd;
   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 ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
     return -1;                 /* errno is set for us.  */
@@ -1353,58 +1385,45 @@ ctf_member_info (ctf_file_t *fp, ctf_id_t type, const char *name,
   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
     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));
 
   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
     {
     }
   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;
+
+      if (ctf_struct_member (fp, &memb, tp, vlen, vbytes, i) < 0)
+       return -1;                              /* errno is set for us.  */
 
 
-      for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
-          dmd != NULL; dmd = ctf_list_next (dmd))
+      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;
        }
     }
 
        }
     }
 
@@ -1414,9 +1433,9 @@ ctf_member_info (ctf_file_t *fp, ctf_id_t type, const char *name,
 /* Return the array type, index, and size information for the specified ARRAY.  */
 
 int
 /* 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;
   const ctf_type_t *tp;
   const ctf_array_t *ap;
   const ctf_dtdef_t *dtd;
@@ -1429,14 +1448,12 @@ ctf_array_info (ctf_file_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
     return (ctf_set_errno (ofp, ECTF_NOTARRAY));
 
   if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
     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;
   arp->ctr_contents = ap->cta_contents;
   arp->ctr_index = ap->cta_index;
   arp->ctr_nelems = ap->cta_nelems;
@@ -1448,9 +1465,9 @@ ctf_array_info (ctf_file_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
    matching name can be found.  Otherwise NULL is returned.  */
 
 const char *
    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;
   const ctf_type_t *tp;
   const ctf_enum_t *ep;
   const ctf_dtdef_t *dtd;
@@ -1465,35 +1482,24 @@ ctf_enum_name (ctf_file_t *fp, ctf_id_t type, int value)
 
   if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
     {
 
   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;
     }
 
       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)
 
   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
   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;
 }
 
   return NULL;
 }
 
@@ -1501,9 +1507,9 @@ ctf_enum_name (ctf_file_t *fp, ctf_id_t type, int value)
    matching name can be found.  Otherwise CTF_ERR is returned.  */
 
 int
    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;
   const ctf_type_t *tp;
   const ctf_enum_t *ep;
   const ctf_dtdef_t *dtd;
@@ -1522,39 +1528,24 @@ ctf_enum_value (ctf_file_t * fp, ctf_id_t type, const char *name, int *valp)
       return -1;
     }
 
       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)
 
   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
   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;
 }
 
   return -1;
 }
 
@@ -1562,7 +1553,7 @@ ctf_enum_value (ctf_file_t * fp, ctf_id_t type, const char *name, int *valp)
    arg counts for that function.  */
 
 int
    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;
 {
   const ctf_type_t *tp;
   uint32_t kind;
@@ -1589,7 +1580,7 @@ ctf_func_type_info (ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
     args = (uint32_t *) ((uintptr_t) tp + increment);
   else
   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)
     {
 
   if (fip->ctc_argc != 0 && args[fip->ctc_argc - 1] == 0)
     {
@@ -1604,7 +1595,7 @@ ctf_func_type_info (ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
    function.  */
 
 int
    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;
 {
   const ctf_type_t *tp;
   const uint32_t *args;
@@ -1626,7 +1617,7 @@ ctf_func_type_args (ctf_file_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv
   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
     args = (uint32_t *) ((uintptr_t) tp + increment);
   else
   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++;
 
   for (argc = MIN (argc, f.ctc_argc); argc != 0; argc--)
     *argv++ = *args++;
@@ -1641,77 +1632,64 @@ ctf_func_type_args (ctf_file_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv
    returns non-zero, we abort and percolate the error code back up to the top.  */
 
 static int
    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;
                 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 nonrepresentable = 0;
   int rc;
 
   int rc;
 
-  if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
-    return -1;                 /* errno is set for us.  */
+  if ((type = ctf_type_resolve (fp, type)) == CTF_ERR) {
+    if (ctf_errno (fp) != ECTF_NONREPRESENTABLE)
+      return -1;               /* errno is set for us.  */
+    else
+      nonrepresentable = 1;
+  }
 
 
-  if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
-    return -1;                 /* errno is set for us.  */
+  if (!nonrepresentable)
+    if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
+      return -1;               /* errno is set for us.  */
 
   if ((rc = func (name, otype, offset, depth, arg)) != 0)
     return rc;
 
 
   if ((rc = func (name, otype, offset, depth, arg)) != 0)
     return rc;
 
-  kind = LCTF_INFO_KIND (fp, tp->ctt_info);
+  if (!nonrepresentable)
+    kind = LCTF_INFO_KIND (fp, tp->ctt_info);
 
 
-  if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
+  if (nonrepresentable || (kind != CTF_K_STRUCT && kind != CTF_K_UNION))
     return 0;
 
     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
     {
     }
   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;
     }
 
   return 0;
@@ -1720,7 +1698,7 @@ ctf_type_rvisit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func,
 /* Recursively visit the members of any type.  We pass the name, member
  type, and offset of each member to the specified callback function.  */
 int
 /* 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));
 }
 {
   return (ctf_type_rvisit (fp, type, func, arg, "", 0, 0));
 }
Empty description
This page took 0.081091 seconds and 4 git commands to generate.