libctf/ctf-types.c

   1 /* Type handling functions.
   2    Copyright (C) 2019-2020 Free Software Foundation, Inc.
   3
   4    This file is part of libctf.
   5
   6    libctf is free software; you can redistribute it and/or modify it under
   7    the terms of the GNU General Public License as published by the Free
   8    Software Foundation; either version 3, or (at your option) any later
   9    version.
  10
  11    This program is distributed in the hope that it will be useful, but
  12    WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  14    See the GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program; see the file COPYING.  If not see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <ctf-impl.h>
  21 #include <string.h>
  22
  23 /* Determine whether a type is a parent or a child.  */
  24
  25 int
  26 ctf_type_isparent (ctf_file_t *fp, ctf_id_t id)
  27 {
  28   return (LCTF_TYPE_ISPARENT (fp, id));
  29 }
  30
  31 int
  32 ctf_type_ischild (ctf_file_t * fp, ctf_id_t id)
  33 {
  34   return (LCTF_TYPE_ISCHILD (fp, id));
  35 }
  36
  37 /* Iterate over the members of a STRUCT or UNION.  We pass the name, member
  38    type, and offset of each member to the specified callback function.  */
  39
  40 int
  41 ctf_member_iter (ctf_file_t *fp, ctf_id_t type, ctf_member_f *func, void *arg)
  42 {
  43   ctf_file_t *ofp = fp;
  44   const ctf_type_t *tp;
  45   ctf_dtdef_t *dtd;
  46   ssize_t size, increment;
  47   uint32_t kind, n;
  48   int rc;
  49
  50   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
  51     return -1;                  /* errno is set for us.  */
  52
  53   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
  54     return -1;                  /* errno is set for us.  */
  55
  56   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
  57   kind = LCTF_INFO_KIND (fp, tp->ctt_info);
  58
  59   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
  60     return (ctf_set_errno (ofp, ECTF_NOTSOU));
  61
  62   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
  63     {
  64       if (size < CTF_LSTRUCT_THRESH)
  65         {
  66           const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
  67                                                            increment);
  68
  69           for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
  70             {
  71               const char *name = ctf_strptr (fp, mp->ctm_name);
  72               if ((rc = func (name, mp->ctm_type, mp->ctm_offset, arg)) != 0)
  73             return rc;
  74             }
  75         }
  76       else
  77         {
  78           const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
  79                                                               increment);
  80
  81           for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
  82             {
  83               const char *name = ctf_strptr (fp, lmp->ctlm_name);
  84               if ((rc = func (name, lmp->ctlm_type,
  85                               (unsigned long) CTF_LMEM_OFFSET (lmp), arg)) != 0)
  86                 return rc;
  87             }
  88         }
  89     }
  90   else
  91     {
  92       ctf_dmdef_t *dmd;
  93
  94       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
  95            dmd != NULL; dmd = ctf_list_next (dmd))
  96         {
  97           if ((rc = func (dmd->dmd_name, dmd->dmd_type,
  98                           dmd->dmd_offset, arg)) != 0)
  99             return rc;
 100         }
 101     }
 102
 103   return 0;
 104 }
 105
 106 /* Iterate over the members of an ENUM.  We pass the string name and associated
 107    integer value of each enum element to the specified callback function.  */
 108
 109 int
 110 ctf_enum_iter (ctf_file_t *fp, ctf_id_t type, ctf_enum_f *func, void *arg)
 111 {
 112   ctf_file_t *ofp = fp;
 113   const ctf_type_t *tp;
 114   const ctf_enum_t *ep;
 115   ctf_dtdef_t *dtd;
 116   ssize_t increment;
 117   uint32_t n;
 118   int rc;
 119
 120   if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
 121     return -1;                  /* errno is set for us.  */
 122
 123   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 124     return -1;                  /* errno is set for us.  */
 125
 126   if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
 127     return (ctf_set_errno (ofp, ECTF_NOTENUM));
 128
 129   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
 130
 131   if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
 132     {
 133       ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
 134
 135       for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
 136         {
 137           const char *name = ctf_strptr (fp, ep->cte_name);
 138           if ((rc = func (name, ep->cte_value, arg)) != 0)
 139             return rc;
 140         }
 141     }
 142   else
 143     {
 144       ctf_dmdef_t *dmd;
 145
 146       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 147            dmd != NULL; dmd = ctf_list_next (dmd))
 148         {
 149           if ((rc = func (dmd->dmd_name, dmd->dmd_value, arg)) != 0)
 150             return rc;
 151         }
 152     }
 153
 154   return 0;
 155 }
 156
 157 /* Iterate over every root (user-visible) type in the given CTF container.
 158    We pass the type ID of each type to the specified callback function.  */
 159
 160 int
 161 ctf_type_iter (ctf_file_t *fp, ctf_type_f *func, void *arg)
 162 {
 163   ctf_id_t id, max = fp->ctf_typemax;
 164   int rc, child = (fp->ctf_flags & LCTF_CHILD);
 165
 166   for (id = 1; id <= max; id++)
 167     {
 168       const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
 169       if (LCTF_INFO_ISROOT (fp, tp->ctt_info)
 170           && (rc = func (LCTF_INDEX_TO_TYPE (fp, id, child), arg)) != 0)
 171         return rc;
 172     }
 173
 174   return 0;
 175 }
 176
 177 /* Iterate over every type in the given CTF container, user-visible or not.
 178    We pass the type ID of each type to the specified callback function.  */
 179
 180 int
 181 ctf_type_iter_all (ctf_file_t *fp, ctf_type_all_f *func, void *arg)
 182 {
 183   ctf_id_t id, max = fp->ctf_typemax;
 184   int rc, child = (fp->ctf_flags & LCTF_CHILD);
 185
 186   for (id = 1; id <= max; id++)
 187     {
 188       const ctf_type_t *tp = LCTF_INDEX_TO_TYPEPTR (fp, id);
 189       if ((rc = func (LCTF_INDEX_TO_TYPE (fp, id, child),
 190                       LCTF_INFO_ISROOT(fp, tp->ctt_info)
 191                       ? CTF_ADD_ROOT : CTF_ADD_NONROOT, arg) != 0))
 192         return rc;
 193     }
 194
 195   return 0;
 196 }
 197
 198 /* Iterate over every variable in the given CTF container, in arbitrary order.
 199    We pass the name of each variable to the specified callback function.  */
 200
 201 int
 202 ctf_variable_iter (ctf_file_t *fp, ctf_variable_f *func, void *arg)
 203 {
 204   int rc;
 205
 206   if ((fp->ctf_flags & LCTF_CHILD) && (fp->ctf_parent == NULL))
 207     return ECTF_NOPARENT;
 208
 209   if (!(fp->ctf_flags & LCTF_RDWR))
 210     {
 211       unsigned long i;
 212       for (i = 0; i < fp->ctf_nvars; i++)
 213         if ((rc = func (ctf_strptr (fp, fp->ctf_vars[i].ctv_name),
 214                         fp->ctf_vars[i].ctv_type, arg)) != 0)
 215           return rc;
 216     }
 217   else
 218     {
 219       ctf_dvdef_t *dvd;
 220
 221       for (dvd = ctf_list_next (&fp->ctf_dvdefs); dvd != NULL;
 222            dvd = ctf_list_next (dvd))
 223         {
 224           if ((rc = func (dvd->dvd_name, dvd->dvd_type, arg)) != 0)
 225             return rc;
 226         }
 227     }
 228
 229   return 0;
 230 }
 231
 232 /* Follow a given type through the graph for TYPEDEF, VOLATILE, CONST, and
 233    RESTRICT nodes until we reach a "base" type node.  This is useful when
 234    we want to follow a type ID to a node that has members or a size.  To guard
 235    against infinite loops, we implement simplified cycle detection and check
 236    each link against itself, the previous node, and the topmost node.
 237
 238    Does not drill down through slices to their contained type.  */
 239
 240 ctf_id_t
 241 ctf_type_resolve (ctf_file_t *fp, ctf_id_t type)
 242 {
 243   ctf_id_t prev = type, otype = type;
 244   ctf_file_t *ofp = fp;
 245   const ctf_type_t *tp;
 246
 247   if (type == 0)
 248     return (ctf_set_errno (ofp, ECTF_NONREPRESENTABLE));
 249
 250   while ((tp = ctf_lookup_by_id (&fp, type)) != NULL)
 251     {
 252       switch (LCTF_INFO_KIND (fp, tp->ctt_info))
 253         {
 254         case CTF_K_TYPEDEF:
 255         case CTF_K_VOLATILE:
 256         case CTF_K_CONST:
 257         case CTF_K_RESTRICT:
 258           if (tp->ctt_type == type || tp->ctt_type == otype
 259               || tp->ctt_type == prev)
 260             {
 261               ctf_dprintf ("type %ld cycle detected\n", otype);
 262               return (ctf_set_errno (ofp, ECTF_CORRUPT));
 263             }
 264           prev = type;
 265           type = tp->ctt_type;
 266           break;
 267         default:
 268           return type;
 269         }
 270       if (type == 0)
 271         return (ctf_set_errno (ofp, ECTF_NONREPRESENTABLE));
 272     }
 273
 274   return CTF_ERR;               /* errno is set for us.  */
 275 }
 276
 277 /* Like ctf_type_resolve(), but traverse down through slices to their contained
 278    type.  */
 279
 280 ctf_id_t
 281 ctf_type_resolve_unsliced (ctf_file_t *fp, ctf_id_t type)
 282 {
 283   const ctf_type_t *tp;
 284
 285   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
 286     return -1;
 287
 288   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 289     return CTF_ERR;             /* errno is set for us.  */
 290
 291   if ((LCTF_INFO_KIND (fp, tp->ctt_info)) == CTF_K_SLICE)
 292     return ctf_type_reference (fp, type);
 293   return type;
 294 }
 295
 296 /* Look up a name in the given name table, in the appropriate hash given the
 297    kind of the identifier.  The name is a raw, undecorated identifier.  */
 298
 299 ctf_id_t ctf_lookup_by_rawname (ctf_file_t *fp, int kind, const char *name)
 300 {
 301   return ctf_lookup_by_rawhash (fp, ctf_name_table (fp, kind), name);
 302 }
 303
 304 /* Look up a name in the given name table, in the appropriate hash given the
 305    readability state of the dictionary.  The name is a raw, undecorated
 306    identifier.  */
 307
 308 ctf_id_t ctf_lookup_by_rawhash (ctf_file_t *fp, ctf_names_t *np, const char *name)
 309 {
 310   ctf_id_t id;
 311
 312   if (fp->ctf_flags & LCTF_RDWR)
 313     id = (ctf_id_t) ctf_dynhash_lookup (np->ctn_writable, name);
 314   else
 315     id = ctf_hash_lookup_type (np->ctn_readonly, fp, name);
 316   return id;
 317 }
 318
 319 /* Lookup the given type ID and return its name as a new dynamically-allocated
 320    string.  */
 321
 322 char *
 323 ctf_type_aname (ctf_file_t *fp, ctf_id_t type)
 324 {
 325   ctf_decl_t cd;
 326   ctf_decl_node_t *cdp;
 327   ctf_decl_prec_t prec, lp, rp;
 328   int ptr, arr;
 329   uint32_t k;
 330   char *buf;
 331
 332   if (fp == NULL && type == CTF_ERR)
 333     return NULL;        /* Simplify caller code by permitting CTF_ERR.  */
 334
 335   ctf_decl_init (&cd);
 336   ctf_decl_push (&cd, fp, type);
 337
 338   if (cd.cd_err != 0)
 339     {
 340       ctf_decl_fini (&cd);
 341       ctf_set_errno (fp, cd.cd_err);
 342       return NULL;
 343     }
 344
 345   /* If the type graph's order conflicts with lexical precedence order
 346      for pointers or arrays, then we need to surround the declarations at
 347      the corresponding lexical precedence with parentheses.  This can
 348      result in either a parenthesized pointer (*) as in int (*)() or
 349      int (*)[], or in a parenthesized pointer and array as in int (*[])().  */
 350
 351   ptr = cd.cd_order[CTF_PREC_POINTER] > CTF_PREC_POINTER;
 352   arr = cd.cd_order[CTF_PREC_ARRAY] > CTF_PREC_ARRAY;
 353
 354   rp = arr ? CTF_PREC_ARRAY : ptr ? CTF_PREC_POINTER : -1;
 355   lp = ptr ? CTF_PREC_POINTER : arr ? CTF_PREC_ARRAY : -1;
 356
 357   k = CTF_K_POINTER;            /* Avoid leading whitespace (see below).  */
 358
 359   for (prec = CTF_PREC_BASE; prec < CTF_PREC_MAX; prec++)
 360     {
 361       for (cdp = ctf_list_next (&cd.cd_nodes[prec]);
 362            cdp != NULL; cdp = ctf_list_next (cdp))
 363         {
 364           ctf_file_t *rfp = fp;
 365           const ctf_type_t *tp = ctf_lookup_by_id (&rfp, cdp->cd_type);
 366           const char *name = ctf_strptr (rfp, tp->ctt_name);
 367
 368           if (k != CTF_K_POINTER && k != CTF_K_ARRAY)
 369             ctf_decl_sprintf (&cd, " ");
 370
 371           if (lp == prec)
 372             {
 373               ctf_decl_sprintf (&cd, "(");
 374               lp = -1;
 375             }
 376
 377           switch (cdp->cd_kind)
 378             {
 379             case CTF_K_INTEGER:
 380             case CTF_K_FLOAT:
 381             case CTF_K_TYPEDEF:
 382               /* Integers, floats, and typedefs must always be named types.  */
 383
 384               if (name[0] == '\0')
 385                 {
 386                   ctf_set_errno (fp, ECTF_CORRUPT);
 387                   ctf_decl_fini (&cd);
 388                   return NULL;
 389                 }
 390
 391               ctf_decl_sprintf (&cd, "%s", name);
 392               break;
 393             case CTF_K_POINTER:
 394               ctf_decl_sprintf (&cd, "*");
 395               break;
 396             case CTF_K_ARRAY:
 397               ctf_decl_sprintf (&cd, "[%u]", cdp->cd_n);
 398               break;
 399             case CTF_K_FUNCTION:
 400               ctf_decl_sprintf (&cd, "()");
 401               break;
 402             case CTF_K_STRUCT:
 403             case CTF_K_FORWARD:
 404               ctf_decl_sprintf (&cd, "struct %s", name);
 405               break;
 406             case CTF_K_UNION:
 407               ctf_decl_sprintf (&cd, "union %s", name);
 408               break;
 409             case CTF_K_ENUM:
 410               ctf_decl_sprintf (&cd, "enum %s", name);
 411               break;
 412             case CTF_K_VOLATILE:
 413               ctf_decl_sprintf (&cd, "volatile");
 414               break;
 415             case CTF_K_CONST:
 416               ctf_decl_sprintf (&cd, "const");
 417               break;
 418             case CTF_K_RESTRICT:
 419               ctf_decl_sprintf (&cd, "restrict");
 420               break;
 421             case CTF_K_SLICE:
 422               /* No representation: just changes encoding of contained type,
 423                  which is not in any case printed.  Skip it.  */
 424               break;
 425             }
 426
 427           k = cdp->cd_kind;
 428         }
 429
 430       if (rp == prec)
 431         ctf_decl_sprintf (&cd, ")");
 432     }
 433
 434   if (cd.cd_enomem)
 435     (void) ctf_set_errno (fp, ENOMEM);
 436
 437   buf = ctf_decl_buf (&cd);
 438
 439   ctf_decl_fini (&cd);
 440   return buf;
 441 }
 442
 443 /* Lookup the given type ID and print a string name for it into buf.  Return
 444    the actual number of bytes (not including \0) needed to format the name.  */
 445
 446 ssize_t
 447 ctf_type_lname (ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
 448 {
 449   char *str = ctf_type_aname (fp, type);
 450   size_t slen;
 451
 452   if (str == NULL)
 453     return CTF_ERR;                     /* errno is set for us.  */
 454
 455   slen = strlen (str);
 456   snprintf (buf, len, "%s", str);
 457   free (str);
 458
 459   if (slen >= len)
 460     (void) ctf_set_errno (fp, ECTF_NAMELEN);
 461
 462   return slen;
 463 }
 464
 465 /* Lookup the given type ID and print a string name for it into buf.  If buf
 466    is too small, return NULL: the ECTF_NAMELEN error is set on 'fp' for us.  */
 467
 468 char *
 469 ctf_type_name (ctf_file_t *fp, ctf_id_t type, char *buf, size_t len)
 470 {
 471   ssize_t rv = ctf_type_lname (fp, type, buf, len);
 472   return (rv >= 0 && (size_t) rv < len ? buf : NULL);
 473 }
 474
 475 /* Lookup the given type ID and return its raw, unadorned, undecorated name as a
 476    new dynamcally-allocated string.  */
 477
 478 char *
 479 ctf_type_aname_raw (ctf_file_t *fp, ctf_id_t type)
 480 {
 481   const ctf_type_t *tp;
 482
 483   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 484     return NULL;                /* errno is set for us.  */
 485
 486   if (ctf_strraw (fp, tp->ctt_name) != NULL)
 487     return strdup (ctf_strraw (fp, tp->ctt_name));
 488
 489   return NULL;
 490 }
 491
 492 /* Resolve the type down to a base type node, and then return the size
 493    of the type storage in bytes.  */
 494
 495 ssize_t
 496 ctf_type_size (ctf_file_t *fp, ctf_id_t type)
 497 {
 498   const ctf_type_t *tp;
 499   ssize_t size;
 500   ctf_arinfo_t ar;
 501
 502   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
 503     return -1;                  /* errno is set for us.  */
 504
 505   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 506     return -1;                  /* errno is set for us.  */
 507
 508   switch (LCTF_INFO_KIND (fp, tp->ctt_info))
 509     {
 510     case CTF_K_POINTER:
 511       return fp->ctf_dmodel->ctd_pointer;
 512
 513     case CTF_K_FUNCTION:
 514       return 0;         /* Function size is only known by symtab.  */
 515
 516     case CTF_K_ENUM:
 517       return fp->ctf_dmodel->ctd_int;
 518
 519     case CTF_K_ARRAY:
 520       /* ctf_add_array() does not directly encode the element size, but
 521          requires the user to multiply to determine the element size.
 522
 523          If ctf_get_ctt_size() returns nonzero, then use the recorded
 524          size instead.  */
 525
 526       if ((size = ctf_get_ctt_size (fp, tp, NULL, NULL)) > 0)
 527         return size;
 528
 529       if (ctf_array_info (fp, type, &ar) < 0
 530           || (size = ctf_type_size (fp, ar.ctr_contents)) < 0)
 531         return -1;              /* errno is set for us.  */
 532
 533       return size * ar.ctr_nelems;
 534
 535     default: /* including slices of enums, etc */
 536       return (ctf_get_ctt_size (fp, tp, NULL, NULL));
 537     }
 538 }
 539
 540 /* Resolve the type down to a base type node, and then return the alignment
 541    needed for the type storage in bytes.
 542
 543    XXX may need arch-dependent attention.  */
 544
 545 ssize_t
 546 ctf_type_align (ctf_file_t *fp, ctf_id_t type)
 547 {
 548   const ctf_type_t *tp;
 549   ctf_file_t *ofp = fp;
 550   int kind;
 551
 552   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
 553     return -1;                  /* errno is set for us.  */
 554
 555   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 556     return -1;                  /* errno is set for us.  */
 557
 558   kind = LCTF_INFO_KIND (fp, tp->ctt_info);
 559   switch (kind)
 560     {
 561     case CTF_K_POINTER:
 562     case CTF_K_FUNCTION:
 563       return fp->ctf_dmodel->ctd_pointer;
 564
 565     case CTF_K_ARRAY:
 566       {
 567         ctf_arinfo_t r;
 568         if (ctf_array_info (fp, type, &r) < 0)
 569           return -1;            /* errno is set for us.  */
 570         return (ctf_type_align (fp, r.ctr_contents));
 571       }
 572
 573     case CTF_K_STRUCT:
 574     case CTF_K_UNION:
 575       {
 576         size_t align = 0;
 577         ctf_dtdef_t *dtd;
 578
 579         if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
 580           {
 581             uint32_t n = LCTF_INFO_VLEN (fp, tp->ctt_info);
 582             ssize_t size, increment;
 583             const void *vmp;
 584
 585             (void) ctf_get_ctt_size (fp, tp, &size, &increment);
 586             vmp = (unsigned char *) tp + increment;
 587
 588             if (kind == CTF_K_STRUCT)
 589               n = MIN (n, 1);   /* Only use first member for structs.  */
 590
 591             if (size < CTF_LSTRUCT_THRESH)
 592               {
 593                 const ctf_member_t *mp = vmp;
 594                 for (; n != 0; n--, mp++)
 595                   {
 596                     ssize_t am = ctf_type_align (fp, mp->ctm_type);
 597                     align = MAX (align, (size_t) am);
 598                   }
 599               }
 600             else
 601               {
 602                 const ctf_lmember_t *lmp = vmp;
 603                 for (; n != 0; n--, lmp++)
 604                   {
 605                     ssize_t am = ctf_type_align (fp, lmp->ctlm_type);
 606                     align = MAX (align, (size_t) am);
 607                   }
 608               }
 609           }
 610         else
 611           {
 612               ctf_dmdef_t *dmd;
 613
 614               for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 615                    dmd != NULL; dmd = ctf_list_next (dmd))
 616                 {
 617                   ssize_t am = ctf_type_align (fp, dmd->dmd_type);
 618                   align = MAX (align, (size_t) am);
 619                   if (kind == CTF_K_STRUCT)
 620                     break;
 621                 }
 622           }
 623
 624         return align;
 625       }
 626
 627     case CTF_K_ENUM:
 628       return fp->ctf_dmodel->ctd_int;
 629
 630     default:  /* including slices of enums, etc */
 631       return (ctf_get_ctt_size (fp, tp, NULL, NULL));
 632     }
 633 }
 634
 635 /* Return the kind (CTF_K_* constant) for the specified type ID.  */
 636
 637 int
 638 ctf_type_kind_unsliced (ctf_file_t *fp, ctf_id_t type)
 639 {
 640   const ctf_type_t *tp;
 641
 642   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 643     return -1;                  /* errno is set for us.  */
 644
 645   return (LCTF_INFO_KIND (fp, tp->ctt_info));
 646 }
 647
 648 /* Return the kind (CTF_K_* constant) for the specified type ID.
 649    Slices are considered to be of the same kind as the type sliced.  */
 650
 651 int
 652 ctf_type_kind (ctf_file_t *fp, ctf_id_t type)
 653 {
 654   int kind;
 655
 656   if ((kind = ctf_type_kind_unsliced (fp, type)) < 0)
 657     return -1;
 658
 659   if (kind == CTF_K_SLICE)
 660     {
 661       if ((type = ctf_type_reference (fp, type)) == CTF_ERR)
 662         return -1;
 663       kind = ctf_type_kind_unsliced (fp, type);
 664     }
 665
 666   return kind;
 667 }
 668
 669 /* If the type is one that directly references another type (such as POINTER),
 670    then return the ID of the type to which it refers.  */
 671
 672 ctf_id_t
 673 ctf_type_reference (ctf_file_t *fp, ctf_id_t type)
 674 {
 675   ctf_file_t *ofp = fp;
 676   const ctf_type_t *tp;
 677
 678   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 679     return CTF_ERR;             /* errno is set for us.  */
 680
 681   switch (LCTF_INFO_KIND (fp, tp->ctt_info))
 682     {
 683     case CTF_K_POINTER:
 684     case CTF_K_TYPEDEF:
 685     case CTF_K_VOLATILE:
 686     case CTF_K_CONST:
 687     case CTF_K_RESTRICT:
 688       return tp->ctt_type;
 689       /* Slices store their type in an unusual place.  */
 690     case CTF_K_SLICE:
 691       {
 692         ctf_dtdef_t *dtd;
 693         const ctf_slice_t *sp;
 694
 695         if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
 696           {
 697             ssize_t increment;
 698
 699             (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
 700             sp = (const ctf_slice_t *) ((uintptr_t) tp + increment);
 701           }
 702         else
 703           sp = &dtd->dtd_u.dtu_slice;
 704
 705         return sp->cts_type;
 706       }
 707     default:
 708       return (ctf_set_errno (ofp, ECTF_NOTREF));
 709     }
 710 }
 711
 712 /* Find a pointer to type by looking in fp->ctf_ptrtab.  If we can't find a
 713    pointer to the given type, see if we can compute a pointer to the type
 714    resulting from resolving the type down to its base type and use that
 715    instead.  This helps with cases where the CTF data includes "struct foo *"
 716    but not "foo_t *" and the user accesses "foo_t *" in the debugger.
 717
 718    XXX what about parent containers?  */
 719
 720 ctf_id_t
 721 ctf_type_pointer (ctf_file_t *fp, ctf_id_t type)
 722 {
 723   ctf_file_t *ofp = fp;
 724   ctf_id_t ntype;
 725
 726   if (ctf_lookup_by_id (&fp, type) == NULL)
 727     return CTF_ERR;             /* errno is set for us.  */
 728
 729   if ((ntype = fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, type)]) != 0)
 730     return (LCTF_INDEX_TO_TYPE (fp, ntype, (fp->ctf_flags & LCTF_CHILD)));
 731
 732   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
 733     return (ctf_set_errno (ofp, ECTF_NOTYPE));
 734
 735   if (ctf_lookup_by_id (&fp, type) == NULL)
 736     return (ctf_set_errno (ofp, ECTF_NOTYPE));
 737
 738   if ((ntype = fp->ctf_ptrtab[LCTF_TYPE_TO_INDEX (fp, type)]) != 0)
 739     return (LCTF_INDEX_TO_TYPE (fp, ntype, (fp->ctf_flags & LCTF_CHILD)));
 740
 741   return (ctf_set_errno (ofp, ECTF_NOTYPE));
 742 }
 743
 744 /* Return the encoding for the specified INTEGER or FLOAT.  */
 745
 746 int
 747 ctf_type_encoding (ctf_file_t *fp, ctf_id_t type, ctf_encoding_t *ep)
 748 {
 749   ctf_file_t *ofp = fp;
 750   ctf_dtdef_t *dtd;
 751   const ctf_type_t *tp;
 752   ssize_t increment;
 753   uint32_t data;
 754
 755   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 756     return -1;                  /* errno is set for us.  */
 757
 758   if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
 759     {
 760       switch (LCTF_INFO_KIND (fp, tp->ctt_info))
 761         {
 762         case CTF_K_INTEGER:
 763         case CTF_K_FLOAT:
 764           *ep = dtd->dtd_u.dtu_enc;
 765           break;
 766         case CTF_K_SLICE:
 767           {
 768             const ctf_slice_t *slice;
 769             ctf_encoding_t underlying_en;
 770             ctf_id_t underlying;
 771
 772             slice = &dtd->dtd_u.dtu_slice;
 773             underlying = ctf_type_resolve (fp, slice->cts_type);
 774             data = ctf_type_encoding (fp, underlying, &underlying_en);
 775
 776             ep->cte_format = underlying_en.cte_format;
 777             ep->cte_offset = slice->cts_offset;
 778             ep->cte_bits = slice->cts_bits;
 779             break;
 780           }
 781         default:
 782           return (ctf_set_errno (ofp, ECTF_NOTINTFP));
 783         }
 784       return 0;
 785     }
 786
 787   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
 788
 789   switch (LCTF_INFO_KIND (fp, tp->ctt_info))
 790     {
 791     case CTF_K_INTEGER:
 792       data = *(const uint32_t *) ((uintptr_t) tp + increment);
 793       ep->cte_format = CTF_INT_ENCODING (data);
 794       ep->cte_offset = CTF_INT_OFFSET (data);
 795       ep->cte_bits = CTF_INT_BITS (data);
 796       break;
 797     case CTF_K_FLOAT:
 798       data = *(const uint32_t *) ((uintptr_t) tp + increment);
 799       ep->cte_format = CTF_FP_ENCODING (data);
 800       ep->cte_offset = CTF_FP_OFFSET (data);
 801       ep->cte_bits = CTF_FP_BITS (data);
 802       break;
 803     case CTF_K_SLICE:
 804       {
 805         const ctf_slice_t *slice;
 806         ctf_encoding_t underlying_en;
 807         ctf_id_t underlying;
 808
 809         slice = (ctf_slice_t *) ((uintptr_t) tp + increment);
 810         underlying = ctf_type_resolve (fp, slice->cts_type);
 811         data = ctf_type_encoding (fp, underlying, &underlying_en);
 812
 813         ep->cte_format = underlying_en.cte_format;
 814         ep->cte_offset = slice->cts_offset;
 815         ep->cte_bits = slice->cts_bits;
 816         break;
 817       }
 818     default:
 819       return (ctf_set_errno (ofp, ECTF_NOTINTFP));
 820     }
 821
 822   return 0;
 823 }
 824
 825 int
 826 ctf_type_cmp (ctf_file_t *lfp, ctf_id_t ltype, ctf_file_t *rfp,
 827               ctf_id_t rtype)
 828 {
 829   int rval;
 830
 831   if (ltype < rtype)
 832     rval = -1;
 833   else if (ltype > rtype)
 834     rval = 1;
 835   else
 836     rval = 0;
 837
 838   if (lfp == rfp)
 839     return rval;
 840
 841   if (LCTF_TYPE_ISPARENT (lfp, ltype) && lfp->ctf_parent != NULL)
 842     lfp = lfp->ctf_parent;
 843
 844   if (LCTF_TYPE_ISPARENT (rfp, rtype) && rfp->ctf_parent != NULL)
 845     rfp = rfp->ctf_parent;
 846
 847   if (lfp < rfp)
 848     return -1;
 849
 850   if (lfp > rfp)
 851     return 1;
 852
 853   return rval;
 854 }
 855
 856 /* Return a boolean value indicating if two types are compatible.  This function
 857    returns true if the two types are the same, or if they (or their ultimate
 858    base type) have the same encoding properties, or (for structs / unions /
 859    enums / forward declarations) if they have the same name and (for structs /
 860    unions) member count.  */
 861
 862 int
 863 ctf_type_compat (ctf_file_t *lfp, ctf_id_t ltype,
 864                  ctf_file_t *rfp, ctf_id_t rtype)
 865 {
 866   const ctf_type_t *ltp, *rtp;
 867   ctf_encoding_t le, re;
 868   ctf_arinfo_t la, ra;
 869   uint32_t lkind, rkind;
 870   int same_names = 0;
 871
 872   if (ctf_type_cmp (lfp, ltype, rfp, rtype) == 0)
 873     return 1;
 874
 875   ltype = ctf_type_resolve (lfp, ltype);
 876   lkind = ctf_type_kind (lfp, ltype);
 877
 878   rtype = ctf_type_resolve (rfp, rtype);
 879   rkind = ctf_type_kind (rfp, rtype);
 880
 881   ltp = ctf_lookup_by_id (&lfp, ltype);
 882   rtp = ctf_lookup_by_id (&rfp, rtype);
 883
 884   if (ltp != NULL && rtp != NULL)
 885     same_names = (strcmp (ctf_strptr (lfp, ltp->ctt_name),
 886                           ctf_strptr (rfp, rtp->ctt_name)) == 0);
 887
 888   if (((lkind == CTF_K_ENUM) && (rkind == CTF_K_INTEGER)) ||
 889       ((rkind == CTF_K_ENUM) && (lkind == CTF_K_INTEGER)))
 890     return 1;
 891
 892   if (lkind != rkind)
 893     return 0;
 894
 895   switch (lkind)
 896     {
 897     case CTF_K_INTEGER:
 898     case CTF_K_FLOAT:
 899       memset (&le, 0, sizeof (le));
 900       memset (&re, 0, sizeof (re));
 901       return (ctf_type_encoding (lfp, ltype, &le) == 0
 902               && ctf_type_encoding (rfp, rtype, &re) == 0
 903               && memcmp (&le, &re, sizeof (ctf_encoding_t)) == 0);
 904     case CTF_K_POINTER:
 905       return (ctf_type_compat (lfp, ctf_type_reference (lfp, ltype),
 906                                rfp, ctf_type_reference (rfp, rtype)));
 907     case CTF_K_ARRAY:
 908       return (ctf_array_info (lfp, ltype, &la) == 0
 909               && ctf_array_info (rfp, rtype, &ra) == 0
 910               && la.ctr_nelems == ra.ctr_nelems
 911               && ctf_type_compat (lfp, la.ctr_contents, rfp, ra.ctr_contents)
 912               && ctf_type_compat (lfp, la.ctr_index, rfp, ra.ctr_index));
 913     case CTF_K_STRUCT:
 914     case CTF_K_UNION:
 915       return (same_names && (ctf_type_size (lfp, ltype)
 916                              == ctf_type_size (rfp, rtype)));
 917     case CTF_K_ENUM:
 918       {
 919         int lencoded, rencoded;
 920         lencoded = ctf_type_encoding (lfp, ltype, &le);
 921         rencoded = ctf_type_encoding (rfp, rtype, &re);
 922
 923         if ((lencoded != rencoded) ||
 924             ((lencoded == 0) && memcmp (&le, &re, sizeof (ctf_encoding_t)) != 0))
 925           return 0;
 926       }
 927       /* FALLTHRU */
 928     case CTF_K_FORWARD:
 929       return same_names;   /* No other checks required for these type kinds.  */
 930     default:
 931       return 0;               /* Should not get here since we did a resolve.  */
 932     }
 933 }
 934
 935 /* Return the type and offset for a given member of a STRUCT or UNION.  */
 936
 937 int
 938 ctf_member_info (ctf_file_t *fp, ctf_id_t type, const char *name,
 939                  ctf_membinfo_t *mip)
 940 {
 941   ctf_file_t *ofp = fp;
 942   const ctf_type_t *tp;
 943   ctf_dtdef_t *dtd;
 944   ssize_t size, increment;
 945   uint32_t kind, n;
 946
 947   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
 948     return -1;                  /* errno is set for us.  */
 949
 950   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
 951     return -1;                  /* errno is set for us.  */
 952
 953   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
 954   kind = LCTF_INFO_KIND (fp, tp->ctt_info);
 955
 956   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
 957     return (ctf_set_errno (ofp, ECTF_NOTSOU));
 958
 959   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
 960     {
 961       if (size < CTF_LSTRUCT_THRESH)
 962         {
 963           const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
 964                                                            increment);
 965
 966           for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
 967             {
 968               if (strcmp (ctf_strptr (fp, mp->ctm_name), name) == 0)
 969                 {
 970                   mip->ctm_type = mp->ctm_type;
 971                   mip->ctm_offset = mp->ctm_offset;
 972                   return 0;
 973                 }
 974             }
 975         }
 976       else
 977         {
 978           const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
 979                                                               increment);
 980
 981           for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
 982             {
 983               if (strcmp (ctf_strptr (fp, lmp->ctlm_name), name) == 0)
 984                 {
 985                   mip->ctm_type = lmp->ctlm_type;
 986                   mip->ctm_offset = (unsigned long) CTF_LMEM_OFFSET (lmp);
 987                   return 0;
 988                 }
 989             }
 990         }
 991     }
 992   else
 993     {
 994       ctf_dmdef_t *dmd;
 995
 996       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
 997            dmd != NULL; dmd = ctf_list_next (dmd))
 998         {
 999           if (strcmp (dmd->dmd_name, name) == 0)
1000             {
1001               mip->ctm_type = dmd->dmd_type;
1002               mip->ctm_offset = dmd->dmd_offset;
1003               return 0;
1004             }
1005         }
1006     }
1007
1008   return (ctf_set_errno (ofp, ECTF_NOMEMBNAM));
1009 }
1010
1011 /* Return the array type, index, and size information for the specified ARRAY.  */
1012
1013 int
1014 ctf_array_info (ctf_file_t *fp, ctf_id_t type, ctf_arinfo_t *arp)
1015 {
1016   ctf_file_t *ofp = fp;
1017   const ctf_type_t *tp;
1018   const ctf_array_t *ap;
1019   const ctf_dtdef_t *dtd;
1020   ssize_t increment;
1021
1022   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
1023     return -1;                  /* errno is set for us.  */
1024
1025   if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ARRAY)
1026     return (ctf_set_errno (ofp, ECTF_NOTARRAY));
1027
1028   if ((dtd = ctf_dynamic_type (ofp, type)) != NULL)
1029     {
1030       *arp = dtd->dtd_u.dtu_arr;
1031       return 0;
1032     }
1033
1034   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
1035
1036   ap = (const ctf_array_t *) ((uintptr_t) tp + increment);
1037   arp->ctr_contents = ap->cta_contents;
1038   arp->ctr_index = ap->cta_index;
1039   arp->ctr_nelems = ap->cta_nelems;
1040
1041   return 0;
1042 }
1043
1044 /* Convert the specified value to the corresponding enum tag name, if a
1045    matching name can be found.  Otherwise NULL is returned.  */
1046
1047 const char *
1048 ctf_enum_name (ctf_file_t *fp, ctf_id_t type, int value)
1049 {
1050   ctf_file_t *ofp = fp;
1051   const ctf_type_t *tp;
1052   const ctf_enum_t *ep;
1053   const ctf_dtdef_t *dtd;
1054   ssize_t increment;
1055   uint32_t n;
1056
1057   if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
1058     return NULL;                /* errno is set for us.  */
1059
1060   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
1061     return NULL;                /* errno is set for us.  */
1062
1063   if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
1064     {
1065       (void) ctf_set_errno (ofp, ECTF_NOTENUM);
1066       return NULL;
1067     }
1068
1069   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
1070
1071   if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
1072     {
1073       ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
1074
1075       for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
1076         {
1077           if (ep->cte_value == value)
1078             return (ctf_strptr (fp, ep->cte_name));
1079         }
1080     }
1081   else
1082     {
1083       ctf_dmdef_t *dmd;
1084
1085       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1086            dmd != NULL; dmd = ctf_list_next (dmd))
1087         {
1088           if (dmd->dmd_value == value)
1089             return dmd->dmd_name;
1090         }
1091     }
1092
1093   (void) ctf_set_errno (ofp, ECTF_NOENUMNAM);
1094   return NULL;
1095 }
1096
1097 /* Convert the specified enum tag name to the corresponding value, if a
1098    matching name can be found.  Otherwise CTF_ERR is returned.  */
1099
1100 int
1101 ctf_enum_value (ctf_file_t * fp, ctf_id_t type, const char *name, int *valp)
1102 {
1103   ctf_file_t *ofp = fp;
1104   const ctf_type_t *tp;
1105   const ctf_enum_t *ep;
1106   const ctf_dtdef_t *dtd;
1107   ssize_t increment;
1108   uint32_t n;
1109
1110   if ((type = ctf_type_resolve_unsliced (fp, type)) == CTF_ERR)
1111     return -1;                  /* errno is set for us.  */
1112
1113   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
1114     return -1;                  /* errno is set for us.  */
1115
1116   if (LCTF_INFO_KIND (fp, tp->ctt_info) != CTF_K_ENUM)
1117     {
1118       (void) ctf_set_errno (ofp, ECTF_NOTENUM);
1119       return -1;
1120     }
1121
1122   (void) ctf_get_ctt_size (fp, tp, NULL, &increment);
1123
1124   ep = (const ctf_enum_t *) ((uintptr_t) tp + increment);
1125
1126   if ((dtd = ctf_dynamic_type (ofp, type)) == NULL)
1127     {
1128       for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, ep++)
1129         {
1130           if (strcmp (ctf_strptr (fp, ep->cte_name), name) == 0)
1131             {
1132               if (valp != NULL)
1133                 *valp = ep->cte_value;
1134               return 0;
1135             }
1136         }
1137     }
1138   else
1139     {
1140       ctf_dmdef_t *dmd;
1141
1142       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1143            dmd != NULL; dmd = ctf_list_next (dmd))
1144         {
1145           if (strcmp (dmd->dmd_name, name) == 0)
1146             {
1147               if (valp != NULL)
1148                 *valp = dmd->dmd_value;
1149               return 0;
1150             }
1151         }
1152     }
1153
1154   (void) ctf_set_errno (ofp, ECTF_NOENUMNAM);
1155   return -1;
1156 }
1157
1158 /* Given a type ID relating to a function type, return info on return types and
1159    arg counts for that function.  */
1160
1161 int
1162 ctf_func_type_info (ctf_file_t *fp, ctf_id_t type, ctf_funcinfo_t *fip)
1163 {
1164   const ctf_type_t *tp;
1165   uint32_t kind;
1166   const uint32_t *args;
1167   const ctf_dtdef_t *dtd;
1168   ssize_t size, increment;
1169
1170   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
1171     return -1;                  /* errno is set for us.  */
1172
1173   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
1174     return -1;                  /* errno is set for us.  */
1175
1176   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
1177   kind = LCTF_INFO_KIND (fp, tp->ctt_info);
1178
1179   if (kind != CTF_K_FUNCTION)
1180     return (ctf_set_errno (fp, ECTF_NOTFUNC));
1181
1182   fip->ctc_return = tp->ctt_type;
1183   fip->ctc_flags = 0;
1184   fip->ctc_argc = LCTF_INFO_VLEN (fp, tp->ctt_info);
1185
1186   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
1187     args = (uint32_t *) ((uintptr_t) tp + increment);
1188   else
1189     args = dtd->dtd_u.dtu_argv;
1190
1191   if (fip->ctc_argc != 0 && args[fip->ctc_argc - 1] == 0)
1192     {
1193       fip->ctc_flags |= CTF_FUNC_VARARG;
1194       fip->ctc_argc--;
1195     }
1196
1197   return 0;
1198 }
1199
1200 /* Given a type ID relating to a function type, return the arguments for the
1201    function.  */
1202
1203 int
1204 ctf_func_type_args (ctf_file_t *fp, ctf_id_t type, uint32_t argc, ctf_id_t *argv)
1205 {
1206   const ctf_type_t *tp;
1207   const uint32_t *args;
1208   const ctf_dtdef_t *dtd;
1209   ssize_t size, increment;
1210   ctf_funcinfo_t f;
1211
1212   if (ctf_func_type_info (fp, type, &f) < 0)
1213     return -1;                  /* errno is set for us.  */
1214
1215   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
1216     return -1;                  /* errno is set for us.  */
1217
1218   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
1219     return -1;                  /* errno is set for us.  */
1220
1221   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
1222
1223   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
1224     args = (uint32_t *) ((uintptr_t) tp + increment);
1225   else
1226     args = dtd->dtd_u.dtu_argv;
1227
1228   for (argc = MIN (argc, f.ctc_argc); argc != 0; argc--)
1229     *argv++ = *args++;
1230
1231   return 0;
1232 }
1233
1234 /* Recursively visit the members of any type.  This function is used as the
1235    engine for ctf_type_visit, below.  We resolve the input type, recursively
1236    invoke ourself for each type member if the type is a struct or union, and
1237    then invoke the callback function on the current type.  If any callback
1238    returns non-zero, we abort and percolate the error code back up to the top.  */
1239
1240 static int
1241 ctf_type_rvisit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func,
1242                  void *arg, const char *name, unsigned long offset, int depth)
1243 {
1244   ctf_id_t otype = type;
1245   const ctf_type_t *tp;
1246   const ctf_dtdef_t *dtd;
1247   ssize_t size, increment;
1248   uint32_t kind, n;
1249   int rc;
1250
1251   if ((type = ctf_type_resolve (fp, type)) == CTF_ERR)
1252     return -1;                  /* errno is set for us.  */
1253
1254   if ((tp = ctf_lookup_by_id (&fp, type)) == NULL)
1255     return -1;                  /* errno is set for us.  */
1256
1257   if ((rc = func (name, otype, offset, depth, arg)) != 0)
1258     return rc;
1259
1260   kind = LCTF_INFO_KIND (fp, tp->ctt_info);
1261
1262   if (kind != CTF_K_STRUCT && kind != CTF_K_UNION)
1263     return 0;
1264
1265   (void) ctf_get_ctt_size (fp, tp, &size, &increment);
1266
1267   if ((dtd = ctf_dynamic_type (fp, type)) == NULL)
1268     {
1269       if (size < CTF_LSTRUCT_THRESH)
1270         {
1271           const ctf_member_t *mp = (const ctf_member_t *) ((uintptr_t) tp +
1272                                                            increment);
1273
1274           for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, mp++)
1275             {
1276               if ((rc = ctf_type_rvisit (fp, mp->ctm_type,
1277                                          func, arg, ctf_strptr (fp,
1278                                                                 mp->ctm_name),
1279                                          offset + mp->ctm_offset,
1280                                          depth + 1)) != 0)
1281                 return rc;
1282             }
1283         }
1284       else
1285         {
1286           const ctf_lmember_t *lmp = (const ctf_lmember_t *) ((uintptr_t) tp +
1287                                                               increment);
1288
1289           for (n = LCTF_INFO_VLEN (fp, tp->ctt_info); n != 0; n--, lmp++)
1290             {
1291               if ((rc = ctf_type_rvisit (fp, lmp->ctlm_type,
1292                                          func, arg, ctf_strptr (fp,
1293                                                                 lmp->ctlm_name),
1294                                          offset + (unsigned long) CTF_LMEM_OFFSET (lmp),
1295                                          depth + 1)) != 0)
1296                 return rc;
1297             }
1298         }
1299     }
1300   else
1301     {
1302       ctf_dmdef_t *dmd;
1303
1304       for (dmd = ctf_list_next (&dtd->dtd_u.dtu_members);
1305            dmd != NULL; dmd = ctf_list_next (dmd))
1306         {
1307           if ((rc = ctf_type_rvisit (fp, dmd->dmd_type, func, arg,
1308                                      dmd->dmd_name, dmd->dmd_offset,
1309                                      depth + 1)) != 0)
1310             return rc;
1311         }
1312     }
1313
1314   return 0;
1315 }
1316
1317 /* Recursively visit the members of any type.  We pass the name, member
1318  type, and offset of each member to the specified callback function.  */
1319 int
1320 ctf_type_visit (ctf_file_t *fp, ctf_id_t type, ctf_visit_f *func, void *arg)
1321 {
1322   return (ctf_type_rvisit (fp, type, func, arg, "", 0, 0));
1323 }