1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 /*
  26  * Copyright 2012 Jason King.  All rights reserved.
  27  * Use is subject to license terms.
  28  */
  29 
  30 /*
  31  * Copyright 2019, Joyent, Inc.
  32  */
  33 
  34 /*
  35  * CTF DWARF conversion theory.
  36  *
  37  * DWARF data contains a series of compilation units. Each compilation unit
  38  * generally refers to an object file or what once was, in the case of linked
  39  * binaries and shared objects. Each compilation unit has a series of what DWARF
  40  * calls a DIE (Debugging Information Entry). The set of entries that we care
  41  * about have type information stored in a series of attributes. Each DIE also
  42  * has a tag that identifies the kind of attributes that it has.
  43  *
  44  * A given DIE may itself have children. For example, a DIE that represents a
  45  * structure has children which represent members. Whenever we encounter a DIE
  46  * that has children or other values or types associated with it, we recursively
  47  * process those children first so that way we can then refer to the generated
  48  * CTF type id while processing its parent. This reduces the amount of unknowns
  49  * and fixups that we need. It also ensures that we don't accidentally add types
  50  * that an overzealous compiler might add to the DWARF data but aren't used by
  51  * anything in the system.
  52  *
  53  * Once we do a conversion, we store a mapping in an AVL tree that goes from the
  54  * DWARF's die offset, which is relative to the given compilation unit, to a
  55  * ctf_id_t.
  56  *
  57  * Unfortunately, some compilers actually will emit duplicate entries for a
  58  * given type that look similar, but aren't quite. To that end, we go through
  59  * and do a variant on a merge once we're done processing a single compilation
  60  * unit which deduplicates all of the types that are in the unit.
  61  *
  62  * Finally, if we encounter an object that has multiple compilation units, then
  63  * we'll convert all of the compilation units separately and then do a merge, so
  64  * that way we can result in one single ctf_file_t that represents everything
  65  * for the object.
  66  *
  67  * Conversion Steps
  68  * ----------------
  69  *
  70  * Because a given object we've been given to convert may have multiple
  71  * compilation units, we break the work into two halves. The first half
  72  * processes each compilation unit (potentially in parallel) and then the second
  73  * half optionally merges all of the dies in the first half. First, we'll cover
  74  * what's involved in converting a single ctf_cu_t's dwarf to CTF. This covers
  75  * the work done in ctf_dwarf_convert_one().
  76  *
  77  * An individual ctf_cu_t, which represents a compilation unit, is converted to
  78  * CTF in a series of multiple passes.
  79  *
  80  * Pass 1: During the first pass we walk all of the top-level dies and if we
  81  * find a function, variable, struct, union, enum or typedef, we recursively
  82  * transform all of its types. We don't recurse or process everything, because
  83  * we don't want to add some of the types that compilers may add which are
  84  * effectively unused.
  85  *
  86  * During pass 1, if we encounter any structures or unions we mark them for
  87  * fixing up later. This is necessary because we may not be able to determine
  88  * the full size of a structure at the beginning of time. This will happen if
  89  * the DWARF attribute DW_AT_byte_size is not present for a member. Because of
  90  * this possibility we defer adding members to structures or even converting
  91  * them during pass 1 and save that for pass 2. Adding all of the base
  92  * structures without any of their members helps deal with any circular
  93  * dependencies that we might encounter.
  94  *
  95  * Pass 2: This pass is used to do the first half of fixing up structures and
  96  * unions. Rather than walk the entire type space again, we actually walk the
  97  * list of structures and unions that we marked for later fixing up. Here, we
  98  * iterate over every structure and add members to the underlying ctf_file_t,
  99  * but not to the structs themselves. One might wonder why we don't, and the
 100  * main reason is that libctf requires a ctf_update() be done before adding the
 101  * members to structures or unions.
 102  *
 103  * Pass 3: This pass is used to do the second half of fixing up structures and
 104  * unions. During this part we always go through and add members to structures
 105  * and unions that we added to the container in the previous pass. In addition,
 106  * we set the structure and union's actual size, which may have additional
 107  * padding added by the compiler, it isn't simply the last offset. DWARF always
 108  * guarantees an attribute exists for this. Importantly no ctf_id_t's change
 109  * during pass 2.
 110  *
 111  * Pass 4: The next phase is to add CTF entries for all of the symbols and
 112  * variables that are present in this die. During pass 1 we added entries to a
 113  * map for each variable and function. During this pass, we iterate over the
 114  * symbol table and when we encounter a symbol that we have in our lists of
 115  * translated information which matches, we then add it to the ctf_file_t.
 116  *
 117  * Pass 5: Here we go and look for any weak symbols and functions and see if
 118  * they match anything that we recognize. If so, then we add type information
 119  * for them at this point based on the matching type.
 120  *
 121  * Pass 6: This pass is actually a variant on a merge. The traditional merge
 122  * process expects there to be no duplicate types. As such, at the end of
 123  * conversion, we do a dedup on all of the types in the system. The
 124  * deduplication process is described in lib/libctf/common/ctf_merge.c.
 125  *
 126  * Once pass 6 is done, we've finished processing the individual compilation
 127  * unit.
 128  *
 129  * The following steps reflect the general process of doing a conversion.
 130  *
 131  * 1) Walk the dwarf section and determine the number of compilation units
 132  * 2) Create a ctf_cu_t for each compilation unit
 133  * 3) Add all ctf_cu_t's to a workq
 134  * 4) Have the workq process each die with ctf_dwarf_convert_one. This itself
 135  *    is comprised of several steps, which were already enumerated.
 136  * 5) If we have multiple cu's, we do a ctf merge of all the dies. The mechanics
 137  *    of the merge are discussed in lib/libctf/common/ctf_merge.c.
 138  * 6) Free everything up and return a ctf_file_t to the user. If we only had a
 139  *    single compilation unit, then we give that to the user. Otherwise, we
 140  *    return the merged ctf_file_t.
 141  *
 142  * Threading
 143  * ---------
 144  *
 145  * The process has been designed to be amenable to threading. Each compilation
 146  * unit has its own type stream, therefore the logical place to divide and
 147  * conquer is at the compilation unit. Each ctf_cu_t has been built to be able
 148  * to be processed independently of the others. It has its own libdwarf handle,
 149  * as a given libdwarf handle may only be used by a single thread at a time.
 150  * This allows the various ctf_cu_t's to be processed in parallel by different
 151  * threads.
 152  *
 153  * All of the ctf_cu_t's are loaded into a workq which allows for a number of
 154  * threads to be specified and used as a thread pool to process all of the
 155  * queued work. We set the number of threads to use in the workq equal to the
 156  * number of threads that the user has specified.
 157  *
 158  * After all of the compilation units have been drained, we use the same number
 159  * of threads when performing a merge of multiple compilation units, if they
 160  * exist.
 161  *
 162  * While all of these different parts do support and allow for multiple threads,
 163  * it's important that when only a single thread is specified, that it be the
 164  * calling thread. This allows the conversion routines to be used in a context
 165  * that doesn't allow additional threads, such as rtld.
 166  *
 167  * Common DWARF Mechanics and Notes
 168  * --------------------------------
 169  *
 170  * At this time, we really only support DWARFv2, though support for DWARFv4 is
 171  * mostly there. There is no intent to support DWARFv3.
 172  *
 173  * Generally types for something are stored in the DW_AT_type attribute. For
 174  * example, a function's return type will be stored in the local DW_AT_type
 175  * attribute while the arguments will be in child DIEs. There are also various
 176  * times when we don't have any DW_AT_type. In that case, the lack of a type
 177  * implies, at least for C, that its C type is void. Because DWARF doesn't emit
 178  * one, we have a synthetic void type that we create and manipulate instead and
 179  * pass it off to consumers on an as-needed basis. If nothing has a void type,
 180  * it will not be emitted.
 181  *
 182  * Architecture Specific Parts
 183  * ---------------------------
 184  *
 185  * The CTF tooling encodes various information about the various architectures
 186  * in the system. Importantly, the tool assumes that every architecture has a
 187  * data model where long and pointer are the same size. This is currently the
 188  * case, as the two data models illumos supports are ILP32 and LP64.
 189  *
 190  * In addition, we encode the mapping of various floating point sizes to various
 191  * types for each architecture. If a new architecture is being added, it should
 192  * be added to the list. The general design of the ctf conversion tools is to be
 193  * architecture independent. eg. any of the tools here should be able to convert
 194  * any architecture's DWARF into ctf; however, this has not been rigorously
 195  * tested and more importantly, the ctf routines don't currently write out the
 196  * data in an endian-aware form, they only use that of the currently running
 197  * library.
 198  */
 199 
 200 #include <libctf_impl.h>
 201 #include <sys/avl.h>
 202 #include <sys/debug.h>
 203 #include <gelf.h>
 204 #include <libdwarf.h>
 205 #include <dwarf.h>
 206 #include <libgen.h>
 207 #include <workq.h>
 208 #include <errno.h>
 209 
 210 #define DWARF_VERSION_TWO       2
 211 #define DWARF_VARARGS_NAME      "..."
 212 
 213 /*
 214  * Dwarf may refer recursively to other types that we've already processed. To
 215  * see if we've already converted them, we look them up in an AVL tree that's
 216  * sorted by the DWARF id.
 217  */
 218 typedef struct ctf_dwmap {
 219         avl_node_t      cdm_avl;
 220         Dwarf_Off       cdm_off;
 221         Dwarf_Die       cdm_die;
 222         ctf_id_t        cdm_id;
 223         boolean_t       cdm_fix;
 224 } ctf_dwmap_t;
 225 
 226 typedef struct ctf_dwvar {
 227         ctf_list_t      cdv_list;
 228         char            *cdv_name;
 229         ctf_id_t        cdv_type;
 230         boolean_t       cdv_global;
 231 } ctf_dwvar_t;
 232 
 233 typedef struct ctf_dwfunc {
 234         ctf_list_t      cdf_list;
 235         char            *cdf_name;
 236         ctf_funcinfo_t  cdf_fip;
 237         ctf_id_t        *cdf_argv;
 238         boolean_t       cdf_global;
 239 } ctf_dwfunc_t;
 240 
 241 typedef struct ctf_dwbitf {
 242         ctf_list_t      cdb_list;
 243         ctf_id_t        cdb_base;
 244         uint_t          cdb_nbits;
 245         ctf_id_t        cdb_id;
 246 } ctf_dwbitf_t;
 247 
 248 /*
 249  * The ctf_cu_t represents a single top-level DWARF die unit. While generally,
 250  * the typical object file has only a single die, if we're asked to convert
 251  * something that's been linked from multiple sources, multiple dies will exist.
 252  */
 253 typedef struct ctf_die {
 254         Elf             *cu_elf;        /* shared libelf handle */
 255         char            *cu_name;       /* basename of the DIE */
 256         ctf_merge_t     *cu_cmh;        /* merge handle */
 257         ctf_list_t      cu_vars;        /* List of variables */
 258         ctf_list_t      cu_funcs;       /* List of functions */
 259         ctf_list_t      cu_bitfields;   /* Bit field members */
 260         Dwarf_Debug     cu_dwarf;       /* libdwarf handle */
 261         Dwarf_Die       cu_cu;          /* libdwarf compilation unit */
 262         Dwarf_Off       cu_cuoff;       /* cu's offset */
 263         Dwarf_Off       cu_maxoff;      /* maximum offset */
 264         ctf_file_t      *cu_ctfp;       /* output CTF file */
 265         avl_tree_t      cu_map;         /* map die offsets to CTF types */
 266         char            *cu_errbuf;     /* error message buffer */
 267         size_t          cu_errlen;      /* error message buffer length */
 268         size_t          cu_ptrsz;       /* object's pointer size */
 269         boolean_t       cu_bigend;      /* is it big endian */
 270         boolean_t       cu_doweaks;     /* should we convert weak symbols? */
 271         uint_t          cu_mach;        /* machine type */
 272         ctf_id_t        cu_voidtid;     /* void pointer */
 273         ctf_id_t        cu_longtid;     /* id for a 'long' */
 274 } ctf_cu_t;
 275 
 276 static int ctf_dwarf_offset(ctf_cu_t *, Dwarf_Die, Dwarf_Off *);
 277 static int ctf_dwarf_convert_die(ctf_cu_t *, Dwarf_Die);
 278 static int ctf_dwarf_convert_type(ctf_cu_t *, Dwarf_Die, ctf_id_t *, int);
 279 
 280 static int ctf_dwarf_function_count(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *,
 281     boolean_t);
 282 static int ctf_dwarf_convert_fargs(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *,
 283     ctf_id_t *);
 284 
 285 /*
 286  * This is a generic way to set a CTF Conversion backend error depending on what
 287  * we were doing. Unless it was one of a specific set of errors that don't
 288  * indicate a programming / translation bug, eg. ENOMEM, then we transform it
 289  * into a CTF backend error and fill in the error buffer.
 290  */
 291 static int
 292 ctf_dwarf_error(ctf_cu_t *cup, ctf_file_t *cfp, int err, const char *fmt, ...)
 293 {
 294         va_list ap;
 295         int ret;
 296         size_t off = 0;
 297         ssize_t rem = cup->cu_errlen;
 298         if (cfp != NULL)
 299                 err = ctf_errno(cfp);
 300 
 301         if (err == ENOMEM)
 302                 return (err);
 303 
 304         ret = snprintf(cup->cu_errbuf, rem, "die %s: ", cup->cu_name);
 305         if (ret < 0)
 306                 goto err;
 307         off += ret;
 308         rem = MAX(rem - ret, 0);
 309 
 310         va_start(ap, fmt);
 311         ret = vsnprintf(cup->cu_errbuf + off, rem, fmt, ap);
 312         va_end(ap);
 313         if (ret < 0)
 314                 goto err;
 315 
 316         off += ret;
 317         rem = MAX(rem - ret, 0);
 318         if (fmt[strlen(fmt) - 1] != '\n') {
 319                 (void) snprintf(cup->cu_errbuf + off, rem,
 320                     ": %s\n", ctf_errmsg(err));
 321         }
 322         va_end(ap);
 323         return (ECTF_CONVBKERR);
 324 
 325 err:
 326         cup->cu_errbuf[0] = '\0';
 327         return (ECTF_CONVBKERR);
 328 }
 329 
 330 /*
 331  * DWARF often opts to put no explicit type to describe a void type. eg. if we
 332  * have a reference type whose DW_AT_type member doesn't exist, then we should
 333  * instead assume it points to void. Because this isn't represented, we
 334  * instead cause it to come into existence.
 335  */
 336 static ctf_id_t
 337 ctf_dwarf_void(ctf_cu_t *cup)
 338 {
 339         if (cup->cu_voidtid == CTF_ERR) {
 340                 ctf_encoding_t enc = { CTF_INT_SIGNED, 0, 0 };
 341                 cup->cu_voidtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_ROOT,
 342                     "void", &enc);
 343                 if (cup->cu_voidtid == CTF_ERR) {
 344                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 345                             "failed to create void type: %s\n",
 346                             ctf_errmsg(ctf_errno(cup->cu_ctfp)));
 347                 }
 348         }
 349 
 350         return (cup->cu_voidtid);
 351 }
 352 
 353 /*
 354  * There are many different forms that an array index may take. However, we just
 355  * always force it to be of a type long no matter what. Therefore we use this to
 356  * have a single instance of long across everything.
 357  */
 358 static ctf_id_t
 359 ctf_dwarf_long(ctf_cu_t *cup)
 360 {
 361         if (cup->cu_longtid == CTF_ERR) {
 362                 ctf_encoding_t enc;
 363 
 364                 enc.cte_format = CTF_INT_SIGNED;
 365                 enc.cte_offset = 0;
 366                 /* All illumos systems are LP */
 367                 enc.cte_bits = cup->cu_ptrsz * 8;
 368                 cup->cu_longtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT,
 369                     "long", &enc);
 370                 if (cup->cu_longtid == CTF_ERR) {
 371                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 372                             "failed to create long type: %s\n",
 373                             ctf_errmsg(ctf_errno(cup->cu_ctfp)));
 374                 }
 375 
 376         }
 377 
 378         return (cup->cu_longtid);
 379 }
 380 
 381 static int
 382 ctf_dwmap_comp(const void *a, const void *b)
 383 {
 384         const ctf_dwmap_t *ca = a;
 385         const ctf_dwmap_t *cb = b;
 386 
 387         if (ca->cdm_off > cb->cdm_off)
 388                 return (1);
 389         if (ca->cdm_off < cb->cdm_off)
 390                 return (-1);
 391         return (0);
 392 }
 393 
 394 static int
 395 ctf_dwmap_add(ctf_cu_t *cup, ctf_id_t id, Dwarf_Die die, boolean_t fix)
 396 {
 397         int ret;
 398         avl_index_t index;
 399         ctf_dwmap_t *dwmap;
 400         Dwarf_Off off;
 401 
 402         VERIFY(id > 0 && id < CTF_MAX_TYPE);
 403 
 404         if ((ret = ctf_dwarf_offset(cup, die, &off)) != 0)
 405                 return (ret);
 406 
 407         if ((dwmap = ctf_alloc(sizeof (ctf_dwmap_t))) == NULL)
 408                 return (ENOMEM);
 409 
 410         dwmap->cdm_die = die;
 411         dwmap->cdm_off = off;
 412         dwmap->cdm_id = id;
 413         dwmap->cdm_fix = fix;
 414 
 415         ctf_dprintf("dwmap: %p %" DW_PR_DUx "->%d\n", dwmap, off, id);
 416         VERIFY(avl_find(&cup->cu_map, dwmap, &index) == NULL);
 417         avl_insert(&cup->cu_map, dwmap, index);
 418         return (0);
 419 }
 420 
 421 static int
 422 ctf_dwarf_attribute(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
 423     Dwarf_Attribute *attrp)
 424 {
 425         int ret;
 426         Dwarf_Error derr;
 427 
 428         if ((ret = dwarf_attr(die, name, attrp, &derr)) == DW_DLV_OK)
 429                 return (0);
 430         if (ret == DW_DLV_NO_ENTRY) {
 431                 *attrp = NULL;
 432                 return (ENOENT);
 433         }
 434         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 435             "failed to get attribute for type: %s\n",
 436             dwarf_errmsg(derr));
 437         return (ECTF_CONVBKERR);
 438 }
 439 
 440 static int
 441 ctf_dwarf_ref(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, Dwarf_Off *refp)
 442 {
 443         int ret;
 444         Dwarf_Attribute attr;
 445         Dwarf_Error derr;
 446 
 447         if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
 448                 return (ret);
 449 
 450         if (dwarf_formref(attr, refp, &derr) == DW_DLV_OK) {
 451                 dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 452                 return (0);
 453         }
 454 
 455         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 456             "failed to get unsigned attribute for type: %s\n",
 457             dwarf_errmsg(derr));
 458         return (ECTF_CONVBKERR);
 459 }
 460 
 461 static int
 462 ctf_dwarf_refdie(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
 463     Dwarf_Die *diep)
 464 {
 465         int ret;
 466         Dwarf_Off off;
 467         Dwarf_Error derr;
 468 
 469         if ((ret = ctf_dwarf_ref(cup, die, name, &off)) != 0)
 470                 return (ret);
 471 
 472         off += cup->cu_cuoff;
 473         if ((ret = dwarf_offdie(cup->cu_dwarf, off, diep, &derr)) !=
 474             DW_DLV_OK) {
 475                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 476                     "failed to get die from offset %" DW_PR_DUu ": %s\n",
 477                     off, dwarf_errmsg(derr));
 478                 return (ECTF_CONVBKERR);
 479         }
 480 
 481         return (0);
 482 }
 483 
 484 static int
 485 ctf_dwarf_signed(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
 486     Dwarf_Signed *valp)
 487 {
 488         int ret;
 489         Dwarf_Attribute attr;
 490         Dwarf_Error derr;
 491 
 492         if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
 493                 return (ret);
 494 
 495         if (dwarf_formsdata(attr, valp, &derr) == DW_DLV_OK) {
 496                 dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 497                 return (0);
 498         }
 499 
 500         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 501             "failed to get unsigned attribute for type: %s\n",
 502             dwarf_errmsg(derr));
 503         return (ECTF_CONVBKERR);
 504 }
 505 
 506 static int
 507 ctf_dwarf_unsigned(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
 508     Dwarf_Unsigned *valp)
 509 {
 510         int ret;
 511         Dwarf_Attribute attr;
 512         Dwarf_Error derr;
 513 
 514         if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
 515                 return (ret);
 516 
 517         if (dwarf_formudata(attr, valp, &derr) == DW_DLV_OK) {
 518                 dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 519                 return (0);
 520         }
 521 
 522         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 523             "failed to get unsigned attribute for type: %s\n",
 524             dwarf_errmsg(derr));
 525         return (ECTF_CONVBKERR);
 526 }
 527 
 528 static int
 529 ctf_dwarf_boolean(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name,
 530     Dwarf_Bool *val)
 531 {
 532         int ret;
 533         Dwarf_Attribute attr;
 534         Dwarf_Error derr;
 535 
 536         if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
 537                 return (ret);
 538 
 539         if (dwarf_formflag(attr, val, &derr) == DW_DLV_OK) {
 540                 dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 541                 return (0);
 542         }
 543 
 544         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 545             "failed to get boolean attribute for type: %s\n",
 546             dwarf_errmsg(derr));
 547 
 548         return (ECTF_CONVBKERR);
 549 }
 550 
 551 static int
 552 ctf_dwarf_string(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, char **strp)
 553 {
 554         int ret;
 555         char *s;
 556         Dwarf_Attribute attr;
 557         Dwarf_Error derr;
 558 
 559         *strp = NULL;
 560         if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0)
 561                 return (ret);
 562 
 563         if (dwarf_formstring(attr, &s, &derr) == DW_DLV_OK) {
 564                 if ((*strp = ctf_strdup(s)) == NULL)
 565                         ret = ENOMEM;
 566                 else
 567                         ret = 0;
 568                 dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 569                 return (ret);
 570         }
 571 
 572         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 573             "failed to get string attribute for type: %s\n",
 574             dwarf_errmsg(derr));
 575         return (ECTF_CONVBKERR);
 576 }
 577 
 578 static int
 579 ctf_dwarf_member_location(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Unsigned *valp)
 580 {
 581         int ret;
 582         Dwarf_Error derr;
 583         Dwarf_Attribute attr;
 584         Dwarf_Locdesc *loc;
 585         Dwarf_Signed locnum;
 586 
 587         if ((ret = ctf_dwarf_attribute(cup, die, DW_AT_data_member_location,
 588             &attr)) != 0)
 589                 return (ret);
 590 
 591         if (dwarf_loclist(attr, &loc, &locnum, &derr) != DW_DLV_OK) {
 592                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 593                     "failed to obtain location list for member offset: %s",
 594                     dwarf_errmsg(derr));
 595                 dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 596                 return (ECTF_CONVBKERR);
 597         }
 598         dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR);
 599 
 600         if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) {
 601                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 602                     "failed to parse location structure for member");
 603                 dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK);
 604                 dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC);
 605                 return (ECTF_CONVBKERR);
 606         }
 607 
 608         *valp = loc->ld_s->lr_number;
 609 
 610         dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK);
 611         dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC);
 612         return (0);
 613 }
 614 
 615 
 616 static int
 617 ctf_dwarf_offset(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Off *offsetp)
 618 {
 619         Dwarf_Error derr;
 620 
 621         if (dwarf_dieoffset(die, offsetp, &derr) == DW_DLV_OK)
 622                 return (0);
 623 
 624         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 625             "failed to get die offset: %s\n",
 626             dwarf_errmsg(derr));
 627         return (ECTF_CONVBKERR);
 628 }
 629 
 630 /* simpler variant for debugging output */
 631 static Dwarf_Off
 632 ctf_die_offset(Dwarf_Die die)
 633 {
 634         Dwarf_Off off = -1;
 635         Dwarf_Error derr;
 636 
 637         (void) dwarf_dieoffset(die, &off, &derr);
 638         return (off);
 639 }
 640 
 641 static int
 642 ctf_dwarf_tag(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half *tagp)
 643 {
 644         Dwarf_Error derr;
 645 
 646         if (dwarf_tag(die, tagp, &derr) == DW_DLV_OK)
 647                 return (0);
 648 
 649         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 650             "failed to get tag type: %s\n",
 651             dwarf_errmsg(derr));
 652         return (ECTF_CONVBKERR);
 653 }
 654 
 655 static int
 656 ctf_dwarf_sib(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *sibp)
 657 {
 658         Dwarf_Error derr;
 659         int ret;
 660 
 661         *sibp = NULL;
 662         ret = dwarf_siblingof(cup->cu_dwarf, base, sibp, &derr);
 663         if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY)
 664                 return (0);
 665 
 666         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 667             "failed to sibling from die: %s\n",
 668             dwarf_errmsg(derr));
 669         return (ECTF_CONVBKERR);
 670 }
 671 
 672 static int
 673 ctf_dwarf_child(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *childp)
 674 {
 675         Dwarf_Error derr;
 676         int ret;
 677 
 678         *childp = NULL;
 679         ret = dwarf_child(base, childp, &derr);
 680         if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY)
 681                 return (0);
 682 
 683         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 684             "failed to child from die: %s\n",
 685             dwarf_errmsg(derr));
 686         return (ECTF_CONVBKERR);
 687 }
 688 
 689 /*
 690  * Compilers disagree on what to do to determine if something has global
 691  * visiblity. Traditionally gcc has used DW_AT_external to indicate this while
 692  * Studio has used DW_AT_visibility. We check DW_AT_visibility first and then
 693  * fall back to DW_AT_external. Lack of DW_AT_external implies that it is not.
 694  */
 695 static int
 696 ctf_dwarf_isglobal(ctf_cu_t *cup, Dwarf_Die die, boolean_t *igp)
 697 {
 698         int ret;
 699         Dwarf_Signed vis;
 700         Dwarf_Bool ext;
 701 
 702         if ((ret = ctf_dwarf_signed(cup, die, DW_AT_visibility, &vis)) == 0) {
 703                 *igp = vis == DW_VIS_exported;
 704                 return (0);
 705         } else if (ret != ENOENT) {
 706                 return (ret);
 707         }
 708 
 709         if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_external, &ext)) != 0) {
 710                 if (ret == ENOENT) {
 711                         *igp = B_FALSE;
 712                         return (0);
 713                 }
 714                 return (ret);
 715         }
 716         *igp = ext != 0 ? B_TRUE : B_FALSE;
 717         return (0);
 718 }
 719 
 720 static int
 721 ctf_dwarf_die_elfenc(Elf *elf, ctf_cu_t *cup, char *errbuf, size_t errlen)
 722 {
 723         GElf_Ehdr ehdr;
 724 
 725         if (gelf_getehdr(elf, &ehdr) == NULL) {
 726                 (void) snprintf(errbuf, errlen,
 727                     "failed to get ELF header: %s\n",
 728                     elf_errmsg(elf_errno()));
 729                 return (ECTF_CONVBKERR);
 730         }
 731 
 732         cup->cu_mach = ehdr.e_machine;
 733 
 734         if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) {
 735                 cup->cu_ptrsz = 4;
 736                 VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_ILP32) == 0);
 737         } else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) {
 738                 cup->cu_ptrsz = 8;
 739                 VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_LP64) == 0);
 740         } else {
 741                 (void) snprintf(errbuf, errlen,
 742                     "unknown ELF class %d", ehdr.e_ident[EI_CLASS]);
 743                 return (ECTF_CONVBKERR);
 744         }
 745 
 746         if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB) {
 747                 cup->cu_bigend = B_FALSE;
 748         } else if (ehdr.e_ident[EI_DATA] == ELFDATA2MSB) {
 749                 cup->cu_bigend = B_TRUE;
 750         } else {
 751                 (void) snprintf(errbuf, errlen,
 752                     "unknown ELF data encoding: %hhu", ehdr.e_ident[EI_DATA]);
 753                 return (ECTF_CONVBKERR);
 754         }
 755 
 756         return (0);
 757 }
 758 
 759 typedef struct ctf_dwarf_fpent {
 760         size_t  cdfe_size;
 761         uint_t  cdfe_enc[3];
 762 } ctf_dwarf_fpent_t;
 763 
 764 typedef struct ctf_dwarf_fpmap {
 765         uint_t                  cdf_mach;
 766         ctf_dwarf_fpent_t       cdf_ents[4];
 767 } ctf_dwarf_fpmap_t;
 768 
 769 static const ctf_dwarf_fpmap_t ctf_dwarf_fpmaps[] = {
 770         { EM_SPARC, {
 771                 { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
 772                 { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
 773                 { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
 774                 { 0, { 0 } }
 775         } },
 776         { EM_SPARC32PLUS, {
 777                 { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
 778                 { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
 779                 { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
 780                 { 0, { 0 } }
 781         } },
 782         { EM_SPARCV9, {
 783                 { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
 784                 { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
 785                 { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
 786                 { 0, { 0 } }
 787         } },
 788         { EM_386, {
 789                 { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
 790                 { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
 791                 { 12, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
 792                 { 0, { 0 } }
 793         } },
 794         { EM_X86_64, {
 795                 { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } },
 796                 { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } },
 797                 { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } },
 798                 { 0, { 0 } }
 799         } },
 800         { EM_NONE }
 801 };
 802 
 803 static int
 804 ctf_dwarf_float_base(ctf_cu_t *cup, Dwarf_Signed type, ctf_encoding_t *enc)
 805 {
 806         const ctf_dwarf_fpmap_t *map = &ctf_dwarf_fpmaps[0];
 807         const ctf_dwarf_fpent_t *ent;
 808         uint_t col = 0, mult = 1;
 809 
 810         for (map = &ctf_dwarf_fpmaps[0]; map->cdf_mach != EM_NONE; map++) {
 811                 if (map->cdf_mach == cup->cu_mach)
 812                         break;
 813         }
 814 
 815         if (map->cdf_mach == EM_NONE) {
 816                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 817                     "Unsupported machine type: %d\n", cup->cu_mach);
 818                 return (ENOTSUP);
 819         }
 820 
 821         if (type == DW_ATE_complex_float) {
 822                 mult = 2;
 823                 col = 1;
 824         } else if (type == DW_ATE_imaginary_float ||
 825             type == DW_ATE_SUN_imaginary_float) {
 826                 col = 2;
 827         }
 828 
 829         ent = &map->cdf_ents[0];
 830         for (ent = &map->cdf_ents[0]; ent->cdfe_size != 0; ent++) {
 831                 if (ent->cdfe_size * mult * 8 == enc->cte_bits) {
 832                         enc->cte_format = ent->cdfe_enc[col];
 833                         return (0);
 834                 }
 835         }
 836 
 837         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 838             "failed to find valid fp mapping for encoding %d, size %d bits\n",
 839             type, enc->cte_bits);
 840         return (EINVAL);
 841 }
 842 
 843 static int
 844 ctf_dwarf_dwarf_base(ctf_cu_t *cup, Dwarf_Die die, int *kindp,
 845     ctf_encoding_t *enc)
 846 {
 847         int ret;
 848         Dwarf_Signed type;
 849 
 850         if ((ret = ctf_dwarf_signed(cup, die, DW_AT_encoding, &type)) != 0)
 851                 return (ret);
 852 
 853         switch (type) {
 854         case DW_ATE_unsigned:
 855         case DW_ATE_address:
 856                 *kindp = CTF_K_INTEGER;
 857                 enc->cte_format = 0;
 858                 break;
 859         case DW_ATE_unsigned_char:
 860                 *kindp = CTF_K_INTEGER;
 861                 enc->cte_format = CTF_INT_CHAR;
 862                 break;
 863         case DW_ATE_signed:
 864                 *kindp = CTF_K_INTEGER;
 865                 enc->cte_format = CTF_INT_SIGNED;
 866                 break;
 867         case DW_ATE_signed_char:
 868                 *kindp = CTF_K_INTEGER;
 869                 enc->cte_format = CTF_INT_SIGNED | CTF_INT_CHAR;
 870                 break;
 871         case DW_ATE_boolean:
 872                 *kindp = CTF_K_INTEGER;
 873                 enc->cte_format = CTF_INT_SIGNED | CTF_INT_BOOL;
 874                 break;
 875         case DW_ATE_float:
 876         case DW_ATE_complex_float:
 877         case DW_ATE_imaginary_float:
 878         case DW_ATE_SUN_imaginary_float:
 879         case DW_ATE_SUN_interval_float:
 880                 *kindp = CTF_K_FLOAT;
 881                 if ((ret = ctf_dwarf_float_base(cup, type, enc)) != 0)
 882                         return (ret);
 883                 break;
 884         default:
 885                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
 886                     "encountered unknown DWARF encoding: %d", type);
 887                 return (ECTF_CONVBKERR);
 888         }
 889 
 890         return (0);
 891 }
 892 
 893 /*
 894  * Different compilers (at least GCC and Studio) use different names for types.
 895  * This parses the types and attempts to unify them. If this fails, we just fall
 896  * back to using the DWARF itself.
 897  */
 898 static int
 899 ctf_dwarf_parse_base(const char *name, int *kindp, ctf_encoding_t *enc,
 900     char **newnamep)
 901 {
 902         char buf[256];
 903         char *base, *c, *last;
 904         int nlong = 0, nshort = 0, nchar = 0, nint = 0;
 905         int sign = 1;
 906 
 907         if (strlen(name) + 1 > sizeof (buf))
 908                 return (EINVAL);
 909 
 910         (void) strlcpy(buf, name, sizeof (buf));
 911         for (c = strtok_r(buf, " ", &last); c != NULL;
 912             c = strtok_r(NULL, " ", &last)) {
 913                 if (strcmp(c, "signed") == 0) {
 914                         sign = 1;
 915                 } else if (strcmp(c, "unsigned") == 0) {
 916                         sign = 0;
 917                 } else if (strcmp(c, "long") == 0) {
 918                         nlong++;
 919                 } else if (strcmp(c, "char") == 0) {
 920                         nchar++;
 921                 } else if (strcmp(c, "short") == 0) {
 922                         nshort++;
 923                 } else if (strcmp(c, "int") == 0) {
 924                         nint++;
 925                 } else {
 926                         /*
 927                          * If we don't recognize any of the tokens, we'll tell
 928                          * the caller to fall back to the dwarf-provided
 929                          * encoding information.
 930                          */
 931                         return (EINVAL);
 932                 }
 933         }
 934 
 935         if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2)
 936                 return (EINVAL);
 937 
 938         if (nchar > 0) {
 939                 if (nlong > 0 || nshort > 0 || nint > 0)
 940                         return (EINVAL);
 941                 base = "char";
 942         } else if (nshort > 0) {
 943                 if (nlong > 0)
 944                         return (EINVAL);
 945                 base = "short";
 946         } else if (nlong > 0) {
 947                 base = "long";
 948         } else {
 949                 base = "int";
 950         }
 951 
 952         if (nchar > 0)
 953                 enc->cte_format = CTF_INT_CHAR;
 954         else
 955                 enc->cte_format = 0;
 956 
 957         if (sign > 0)
 958                 enc->cte_format |= CTF_INT_SIGNED;
 959 
 960         (void) snprintf(buf, sizeof (buf), "%s%s%s",
 961             (sign ? "" : "unsigned "),
 962             (nlong > 1 ? "long " : ""),
 963             base);
 964 
 965         *newnamep = ctf_strdup(buf);
 966         if (*newnamep == NULL)
 967                 return (ENOMEM);
 968         *kindp = CTF_K_INTEGER;
 969         return (0);
 970 }
 971 
 972 static int
 973 ctf_dwarf_create_base(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot,
 974     Dwarf_Off off)
 975 {
 976         int ret;
 977         char *name, *nname;
 978         Dwarf_Unsigned sz;
 979         int kind;
 980         ctf_encoding_t enc;
 981         ctf_id_t id;
 982 
 983         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0)
 984                 return (ret);
 985         if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &sz)) != 0) {
 986                 goto out;
 987         }
 988         ctf_dprintf("Creating base type %s from off %llu, size: %d\n", name,
 989             off, sz);
 990 
 991         bzero(&enc, sizeof (ctf_encoding_t));
 992         enc.cte_bits = sz * 8;
 993         if ((ret = ctf_dwarf_parse_base(name, &kind, &enc, &nname)) == 0) {
 994                 ctf_free(name, strlen(name) + 1);
 995                 name = nname;
 996         } else {
 997                 if (ret != EINVAL)
 998                         return (ret);
 999                 ctf_dprintf("falling back to dwarf for base type %s\n", name);
1000                 if ((ret = ctf_dwarf_dwarf_base(cup, die, &kind, &enc)) != 0)
1001                         return (ret);
1002         }
1003 
1004         id = ctf_add_encoded(cup->cu_ctfp, isroot, name, &enc, kind);
1005         if (id == CTF_ERR) {
1006                 ret = ctf_errno(cup->cu_ctfp);
1007         } else {
1008                 *idp = id;
1009                 ret = ctf_dwmap_add(cup, id, die, B_FALSE);
1010         }
1011 out:
1012         ctf_free(name, strlen(name) + 1);
1013         return (ret);
1014 }
1015 
1016 /*
1017  * Getting a member's offset is a surprisingly intricate dance. It works as
1018  * follows:
1019  *
1020  * 1) If we're in DWARFv4, then we either have a DW_AT_data_bit_offset or we
1021  * have a DW_AT_data_member_location. We won't have both. Thus we check first
1022  * for DW_AT_data_bit_offset, and if it exists, we're set.
1023  *
1024  * Next, if we have a bitfield and we don't have a DW_AT_data_bit_offset, then
1025  * we have to grab the data location and use the following dance:
1026  *
1027  * 2) Gather the set of DW_AT_byte_size, DW_AT_bit_offset, and DW_AT_bit_size.
1028  * Of course, the DW_AT_byte_size may be omitted, even though it isn't always.
1029  * When it's been omitted, we then have to say that the size is that of the
1030  * underlying type, which forces that to be after a ctf_update(). Here, we have
1031  * to do different things based on whether or not we're using big endian or
1032  * little endian to obtain the proper offset.
1033  */
1034 static int
1035 ctf_dwarf_member_offset(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t mid,
1036     ulong_t *offp)
1037 {
1038         int ret;
1039         Dwarf_Unsigned loc, bitsz, bytesz;
1040         Dwarf_Signed bitoff;
1041         size_t off;
1042         ssize_t tsz;
1043 
1044         if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_data_bit_offset,
1045             &loc)) == 0) {
1046                 *offp = loc;
1047                 return (0);
1048         } else if (ret != ENOENT) {
1049                 return (ret);
1050         }
1051 
1052         if ((ret = ctf_dwarf_member_location(cup, die, &loc)) != 0)
1053                 return (ret);
1054         off = loc * 8;
1055 
1056         if ((ret = ctf_dwarf_signed(cup, die, DW_AT_bit_offset,
1057             &bitoff)) != 0) {
1058                 if (ret != ENOENT)
1059                         return (ret);
1060                 *offp = off;
1061                 return (0);
1062         }
1063 
1064         /* At this point we have to have DW_AT_bit_size */
1065         if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0)
1066                 return (ret);
1067 
1068         if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size,
1069             &bytesz)) != 0) {
1070                 if (ret != ENOENT)
1071                         return (ret);
1072                 if ((tsz = ctf_type_size(cup->cu_ctfp, mid)) == CTF_ERR) {
1073                         int e = ctf_errno(cup->cu_ctfp);
1074                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1075                             "failed to get type size: %s", ctf_errmsg(e));
1076                         return (ECTF_CONVBKERR);
1077                 }
1078         } else {
1079                 tsz = bytesz;
1080         }
1081         tsz *= 8;
1082         if (cup->cu_bigend == B_TRUE) {
1083                 *offp = off + bitoff;
1084         } else {
1085                 *offp = off + tsz - bitoff - bitsz;
1086         }
1087 
1088         return (0);
1089 }
1090 
1091 /*
1092  * We need to determine if the member in question is a bitfield. If it is, then
1093  * we need to go through and create a new type that's based on the actual base
1094  * type, but has a different size. We also rename the type as a result to help
1095  * deal with future collisions.
1096  *
1097  * Here we need to look and see if we have a DW_AT_bit_size value. If we have a
1098  * bit size member and it does not equal the byte size member, then we need to
1099  * create a bitfield type based on this.
1100  *
1101  * Note: When we support DWARFv4, there may be a chance that we need to also
1102  * search for the DW_AT_byte_size if we don't have a DW_AT_bit_size member.
1103  */
1104 static int
1105 ctf_dwarf_member_bitfield(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp)
1106 {
1107         int ret;
1108         Dwarf_Unsigned bitsz;
1109         ctf_encoding_t e;
1110         ctf_dwbitf_t *cdb;
1111         ctf_dtdef_t *dtd;
1112         ctf_id_t base = *idp;
1113         int kind;
1114 
1115         if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0) {
1116                 if (ret == ENOENT)
1117                         return (0);
1118                 return (ret);
1119         }
1120 
1121         ctf_dprintf("Trying to deal with bitfields on %d:%d\n", base, bitsz);
1122         /*
1123          * Given that we now have a bitsize, time to go do something about it.
1124          * We're going to create a new type based on the current one, but first
1125          * we need to find the base type. This means we need to traverse any
1126          * typedef's, consts, and volatiles until we get to what should be
1127          * something of type integer or enumeration.
1128          */
1129         VERIFY(bitsz < UINT32_MAX);
1130         dtd = ctf_dtd_lookup(cup->cu_ctfp, base);
1131         VERIFY(dtd != NULL);
1132         kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
1133         while (kind == CTF_K_TYPEDEF || kind == CTF_K_CONST ||
1134             kind == CTF_K_VOLATILE) {
1135                 dtd = ctf_dtd_lookup(cup->cu_ctfp, dtd->dtd_data.ctt_type);
1136                 VERIFY(dtd != NULL);
1137                 kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info);
1138         }
1139         ctf_dprintf("got kind %d\n", kind);
1140         VERIFY(kind == CTF_K_INTEGER || kind == CTF_K_ENUM);
1141 
1142         /*
1143          * As surprising as it may be, it is strictly possible to create a
1144          * bitfield that is based on an enum. Of course, the C standard leaves
1145          * enums sizing as an ABI concern more or less. To that effect, today on
1146          * all illumos platforms the size of an enum is generally that of an
1147          * int as our supported data models and ABIs all agree on that. So what
1148          * we'll do is fake up a CTF encoding here to use. In this case, we'll
1149          * treat it as an unsigned value of whatever size the underlying enum
1150          * currently has (which is in the ctt_size member of its dynamic type
1151          * data).
1152          */
1153         if (kind == CTF_K_INTEGER) {
1154                 e = dtd->dtd_u.dtu_enc;
1155         } else {
1156                 bzero(&e, sizeof (ctf_encoding_t));
1157                 e.cte_bits = dtd->dtd_data.ctt_size * NBBY;
1158         }
1159 
1160         for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL;
1161             cdb = ctf_list_next(cdb)) {
1162                 if (cdb->cdb_base == base && cdb->cdb_nbits == bitsz)
1163                         break;
1164         }
1165 
1166         /*
1167          * Create a new type if none exists. We name all types in a way that is
1168          * guaranteed not to conflict with the corresponding C type. We do this
1169          * by using the ':' operator.
1170          */
1171         if (cdb == NULL) {
1172                 size_t namesz;
1173                 char *name;
1174 
1175                 e.cte_bits = bitsz;
1176                 namesz = snprintf(NULL, 0, "%s:%d", dtd->dtd_name,
1177                     (uint32_t)bitsz);
1178                 name = ctf_alloc(namesz + 1);
1179                 if (name == NULL)
1180                         return (ENOMEM);
1181                 cdb = ctf_alloc(sizeof (ctf_dwbitf_t));
1182                 if (cdb == NULL) {
1183                         ctf_free(name, namesz + 1);
1184                         return (ENOMEM);
1185                 }
1186                 (void) snprintf(name, namesz + 1, "%s:%d", dtd->dtd_name,
1187                     (uint32_t)bitsz);
1188 
1189                 cdb->cdb_base = base;
1190                 cdb->cdb_nbits = bitsz;
1191                 cdb->cdb_id = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT,
1192                     name, &e);
1193                 if (cdb->cdb_id == CTF_ERR) {
1194                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1195                             "failed to get add bitfield type %s: %s", name,
1196                             ctf_errmsg(ctf_errno(cup->cu_ctfp)));
1197                         ctf_free(name, namesz + 1);
1198                         ctf_free(cdb, sizeof (ctf_dwbitf_t));
1199                         return (ECTF_CONVBKERR);
1200                 }
1201                 ctf_free(name, namesz + 1);
1202                 ctf_list_append(&cup->cu_bitfields, cdb);
1203         }
1204 
1205         *idp = cdb->cdb_id;
1206 
1207         return (0);
1208 }
1209 
1210 static int
1211 ctf_dwarf_fixup_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t base, boolean_t add)
1212 {
1213         int ret, kind;
1214         Dwarf_Die child, memb;
1215         Dwarf_Unsigned size;
1216         ulong_t nsz;
1217 
1218         kind = ctf_type_kind(cup->cu_ctfp, base);
1219         VERIFY(kind != CTF_ERR);
1220         VERIFY(kind == CTF_K_STRUCT || kind == CTF_K_UNION);
1221 
1222         /*
1223          * Members are in children. However, gcc also allows empty ones.
1224          */
1225         if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1226                 return (ret);
1227         if (child == NULL)
1228                 return (0);
1229 
1230         memb = child;
1231         while (memb != NULL) {
1232                 Dwarf_Die sib, tdie;
1233                 Dwarf_Half tag;
1234                 ctf_id_t mid;
1235                 char *mname;
1236                 ulong_t memboff = 0;
1237 
1238                 if ((ret = ctf_dwarf_tag(cup, memb, &tag)) != 0)
1239                         return (ret);
1240 
1241                 if (tag != DW_TAG_member)
1242                         continue;
1243 
1244                 if ((ret = ctf_dwarf_refdie(cup, memb, DW_AT_type, &tdie)) != 0)
1245                         return (ret);
1246 
1247                 if ((ret = ctf_dwarf_convert_type(cup, tdie, &mid,
1248                     CTF_ADD_NONROOT)) != 0)
1249                         return (ret);
1250                 ctf_dprintf("Got back type id: %d\n", mid);
1251 
1252                 /*
1253                  * If we're not adding a member, just go ahead and return.
1254                  */
1255                 if (add == B_FALSE) {
1256                         if ((ret = ctf_dwarf_member_bitfield(cup, memb,
1257                             &mid)) != 0)
1258                                 return (ret);
1259                         goto next;
1260                 }
1261 
1262                 if ((ret = ctf_dwarf_string(cup, memb, DW_AT_name,
1263                     &mname)) != 0 && ret != ENOENT)
1264                         return (ret);
1265                 if (ret == ENOENT)
1266                         mname = NULL;
1267 
1268                 if (kind == CTF_K_UNION) {
1269                         memboff = 0;
1270                 } else if ((ret = ctf_dwarf_member_offset(cup, memb, mid,
1271                     &memboff)) != 0) {
1272                         if (mname != NULL)
1273                                 ctf_free(mname, strlen(mname) + 1);
1274                         return (ret);
1275                 }
1276 
1277                 if ((ret = ctf_dwarf_member_bitfield(cup, memb, &mid)) != 0)
1278                         return (ret);
1279 
1280                 ret = ctf_add_member(cup->cu_ctfp, base, mname, mid, memboff);
1281                 if (ret == CTF_ERR) {
1282                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1283                             "failed to add member %s: %s",
1284                             mname, ctf_errmsg(ctf_errno(cup->cu_ctfp)));
1285                         if (mname != NULL)
1286                                 ctf_free(mname, strlen(mname) + 1);
1287                         return (ECTF_CONVBKERR);
1288                 }
1289 
1290                 if (mname != NULL)
1291                         ctf_free(mname, strlen(mname) + 1);
1292 
1293 next:
1294                 if ((ret = ctf_dwarf_sib(cup, memb, &sib)) != 0)
1295                         return (ret);
1296                 memb = sib;
1297         }
1298 
1299         /*
1300          * If we're not adding members, then we don't know the final size of the
1301          * structure, so end here.
1302          */
1303         if (add == B_FALSE)
1304                 return (0);
1305 
1306         /* Finally set the size of the structure to the actual byte size */
1307         if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &size)) != 0)
1308                 return (ret);
1309         nsz = size;
1310         if ((ctf_set_size(cup->cu_ctfp, base, nsz)) == CTF_ERR) {
1311                 int e = ctf_errno(cup->cu_ctfp);
1312                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1313                     "failed to set type size for %d to 0x%x: %s", base,
1314                     (uint32_t)size, ctf_errmsg(e));
1315                 return (ECTF_CONVBKERR);
1316         }
1317 
1318         return (0);
1319 }
1320 
1321 static int
1322 ctf_dwarf_create_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp,
1323     int kind, int isroot)
1324 {
1325         int ret;
1326         char *name;
1327         ctf_id_t base;
1328         Dwarf_Die child;
1329         Dwarf_Bool decl;
1330 
1331         /*
1332          * Deal with the terribly annoying case of anonymous structs and unions.
1333          * If they don't have a name, set the name to the empty string.
1334          */
1335         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
1336             ret != ENOENT)
1337                 return (ret);
1338         if (ret == ENOENT)
1339                 name = NULL;
1340 
1341         /*
1342          * We need to check if we just have a declaration here. If we do, then
1343          * instead of creating an actual structure or union, we're just going to
1344          * go ahead and create a forward. During a dedup or merge, the forward
1345          * will be replaced with the real thing.
1346          */
1347         if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration,
1348             &decl)) != 0) {
1349                 if (ret != ENOENT)
1350                         return (ret);
1351                 decl = 0;
1352         }
1353 
1354         if (decl != 0) {
1355                 base = ctf_add_forward(cup->cu_ctfp, isroot, name, kind);
1356         } else if (kind == CTF_K_STRUCT) {
1357                 base = ctf_add_struct(cup->cu_ctfp, isroot, name);
1358         } else {
1359                 base = ctf_add_union(cup->cu_ctfp, isroot, name);
1360         }
1361         ctf_dprintf("added sou %s (%d) (%d)\n", name, kind, base);
1362         if (name != NULL)
1363                 ctf_free(name, strlen(name) + 1);
1364         if (base == CTF_ERR)
1365                 return (ctf_errno(cup->cu_ctfp));
1366         *idp = base;
1367 
1368         /*
1369          * If it's just a declaration, we're not going to mark it for fix up or
1370          * do anything else.
1371          */
1372         if (decl == B_TRUE)
1373                 return (ctf_dwmap_add(cup, base, die, B_FALSE));
1374         if ((ret = ctf_dwmap_add(cup, base, die, B_TRUE)) != 0)
1375                 return (ret);
1376 
1377         /*
1378          * Members are in children. However, gcc also allows empty ones.
1379          */
1380         if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1381                 return (ret);
1382         if (child == NULL)
1383                 return (0);
1384 
1385         return (0);
1386 }
1387 
1388 static int
1389 ctf_dwarf_create_array_range(ctf_cu_t *cup, Dwarf_Die range, ctf_id_t *idp,
1390     ctf_id_t base, int isroot)
1391 {
1392         int ret;
1393         Dwarf_Die sib;
1394         Dwarf_Unsigned val;
1395         Dwarf_Signed sval;
1396         ctf_arinfo_t ar;
1397 
1398         ctf_dprintf("creating array range\n");
1399 
1400         if ((ret = ctf_dwarf_sib(cup, range, &sib)) != 0)
1401                 return (ret);
1402         if (sib != NULL) {
1403                 ctf_id_t id;
1404                 if ((ret = ctf_dwarf_create_array_range(cup, sib, &id,
1405                     base, CTF_ADD_NONROOT)) != 0)
1406                         return (ret);
1407                 ar.ctr_contents = id;
1408         } else {
1409                 ar.ctr_contents = base;
1410         }
1411 
1412         if ((ar.ctr_index = ctf_dwarf_long(cup)) == CTF_ERR)
1413                 return (ctf_errno(cup->cu_ctfp));
1414 
1415         /*
1416          * Array bounds can be signed or unsigned, but there are several kinds
1417          * of signless forms (data1, data2, etc) that take their sign from the
1418          * routine that is trying to interpret them.  That is, data1 can be
1419          * either signed or unsigned, depending on whether you use the signed or
1420          * unsigned accessor function.  GCC will use the signless forms to store
1421          * unsigned values which have their high bit set, so we need to try to
1422          * read them first as unsigned to get positive values.  We could also
1423          * try signed first, falling back to unsigned if we got a negative
1424          * value.
1425          */
1426         if ((ret = ctf_dwarf_unsigned(cup, range, DW_AT_upper_bound,
1427             &val)) == 0) {
1428                 ar.ctr_nelems = val + 1;
1429         } else if (ret != ENOENT) {
1430                 return (ret);
1431         } else if ((ret = ctf_dwarf_signed(cup, range, DW_AT_upper_bound,
1432             &sval)) == 0) {
1433                 ar.ctr_nelems = sval + 1;
1434         } else if (ret != ENOENT) {
1435                 return (ret);
1436         } else {
1437                 ar.ctr_nelems = 0;
1438         }
1439 
1440         if ((*idp = ctf_add_array(cup->cu_ctfp, isroot, &ar)) == CTF_ERR)
1441                 return (ctf_errno(cup->cu_ctfp));
1442 
1443         return (0);
1444 }
1445 
1446 /*
1447  * Try and create an array type. First, the kind of the array is specified in
1448  * the DW_AT_type entry. Next, the number of entries is stored in a more
1449  * complicated form, we should have a child that has the DW_TAG_subrange type.
1450  */
1451 static int
1452 ctf_dwarf_create_array(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot)
1453 {
1454         int ret;
1455         Dwarf_Die tdie, rdie;
1456         ctf_id_t tid;
1457         Dwarf_Half rtag;
1458 
1459         if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0)
1460                 return (ret);
1461         if ((ret = ctf_dwarf_convert_type(cup, tdie, &tid,
1462             CTF_ADD_NONROOT)) != 0)
1463                 return (ret);
1464 
1465         if ((ret = ctf_dwarf_child(cup, die, &rdie)) != 0)
1466                 return (ret);
1467         if ((ret = ctf_dwarf_tag(cup, rdie, &rtag)) != 0)
1468                 return (ret);
1469         if (rtag != DW_TAG_subrange_type) {
1470                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1471                     "encountered array without DW_TAG_subrange_type child\n");
1472                 return (ECTF_CONVBKERR);
1473         }
1474 
1475         /*
1476          * The compiler may opt to describe a multi-dimensional array as one
1477          * giant array or it may opt to instead encode it as a series of
1478          * subranges. If it's the latter, then for each subrange we introduce a
1479          * type. We can always use the base type.
1480          */
1481         if ((ret = ctf_dwarf_create_array_range(cup, rdie, idp, tid,
1482             isroot)) != 0)
1483                 return (ret);
1484         ctf_dprintf("Got back id %d\n", *idp);
1485         return (ctf_dwmap_add(cup, *idp, die, B_FALSE));
1486 }
1487 
1488 /*
1489  * Given "const int const_array3[11]", GCC7 at least will create a DIE tree of
1490  * DW_TAG_const_type:DW_TAG_array_type:DW_Tag_const_type:<member_type>.
1491  *
1492  * Given C's syntax, this renders out as "const const int const_array3[11]".  To
1493  * get closer to round-tripping (and make the unit tests work), we'll peek for
1494  * this case, and avoid adding the extraneous qualifier if we see that the
1495  * underlying array referent already has the same qualifier.
1496  *
1497  * This is unfortunately less trivial than it could be: this issue applies to
1498  * qualifier sets like "const volatile", as well as multi-dimensional arrays, so
1499  * we need to descend down those.
1500  *
1501  * Returns CTF_ERR on error, or a boolean value otherwise.
1502  */
1503 static int
1504 needed_array_qualifier(ctf_cu_t *cup, int kind, ctf_id_t ref_id)
1505 {
1506         const ctf_type_t *t;
1507         ctf_arinfo_t arinfo;
1508         int akind;
1509 
1510         if (kind != CTF_K_CONST && kind != CTF_K_VOLATILE &&
1511             kind != CTF_K_RESTRICT)
1512                 return (1);
1513 
1514         if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, ref_id)) == NULL)
1515                 return (CTF_ERR);
1516 
1517         if (LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info) != CTF_K_ARRAY)
1518                 return (1);
1519 
1520         if (ctf_dyn_array_info(cup->cu_ctfp, ref_id, &arinfo) != 0)
1521                 return (CTF_ERR);
1522 
1523         ctf_id_t id = arinfo.ctr_contents;
1524 
1525         for (;;) {
1526                 if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, id)) == NULL)
1527                         return (CTF_ERR);
1528 
1529                 akind = LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info);
1530 
1531                 if (akind == kind)
1532                         break;
1533 
1534                 if (akind == CTF_K_ARRAY) {
1535                         if (ctf_dyn_array_info(cup->cu_ctfp,
1536                             id, &arinfo) != 0)
1537                                 return (CTF_ERR);
1538                         id = arinfo.ctr_contents;
1539                         continue;
1540                 }
1541 
1542                 if (akind != CTF_K_CONST && akind != CTF_K_VOLATILE &&
1543                     akind != CTF_K_RESTRICT)
1544                         break;
1545 
1546                 id = t->ctt_type;
1547         }
1548 
1549         if (kind == akind) {
1550                 ctf_dprintf("ignoring extraneous %s qualifier for array %d\n",
1551                     ctf_kind_name(cup->cu_ctfp, kind), ref_id);
1552         }
1553 
1554         return (kind != akind);
1555 }
1556 
1557 static int
1558 ctf_dwarf_create_reference(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp,
1559     int kind, int isroot)
1560 {
1561         int ret;
1562         ctf_id_t id;
1563         Dwarf_Die tdie;
1564         char *name;
1565         size_t namelen;
1566 
1567         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
1568             ret != ENOENT)
1569                 return (ret);
1570         if (ret == ENOENT) {
1571                 name = NULL;
1572                 namelen = 0;
1573         } else {
1574                 namelen = strlen(name);
1575         }
1576 
1577         ctf_dprintf("reference kind %d %s\n", kind, name != NULL ? name : "<>");
1578 
1579         if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) {
1580                 if (ret != ENOENT) {
1581                         ctf_free(name, namelen);
1582                         return (ret);
1583                 }
1584                 if ((id = ctf_dwarf_void(cup)) == CTF_ERR) {
1585                         ctf_free(name, namelen);
1586                         return (ctf_errno(cup->cu_ctfp));
1587                 }
1588         } else {
1589                 if ((ret = ctf_dwarf_convert_type(cup, tdie, &id,
1590                     CTF_ADD_NONROOT)) != 0) {
1591                         ctf_free(name, namelen);
1592                         return (ret);
1593                 }
1594         }
1595 
1596         if ((ret = needed_array_qualifier(cup, kind, id)) <= 0) {
1597                 if (ret != 0) {
1598                         ret = (ctf_errno(cup->cu_ctfp));
1599                 } else {
1600                         *idp = id;
1601                 }
1602 
1603                 ctf_free(name, namelen);
1604                 return (ret);
1605         }
1606 
1607         if ((*idp = ctf_add_reftype(cup->cu_ctfp, isroot, name, id, kind)) ==
1608             CTF_ERR) {
1609                 ctf_free(name, namelen);
1610                 return (ctf_errno(cup->cu_ctfp));
1611         }
1612 
1613         ctf_free(name, namelen);
1614         return (ctf_dwmap_add(cup, *idp, die, B_FALSE));
1615 }
1616 
1617 static int
1618 ctf_dwarf_create_enum(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot)
1619 {
1620         int ret;
1621         ctf_id_t id;
1622         Dwarf_Die child;
1623         char *name;
1624 
1625         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
1626             ret != ENOENT)
1627                 return (ret);
1628         if (ret == ENOENT)
1629                 name = NULL;
1630         id = ctf_add_enum(cup->cu_ctfp, isroot, name);
1631         ctf_dprintf("added enum %s (%d)\n", name, id);
1632         if (name != NULL)
1633                 ctf_free(name, strlen(name) + 1);
1634         if (id == CTF_ERR)
1635                 return (ctf_errno(cup->cu_ctfp));
1636         *idp = id;
1637         if ((ret = ctf_dwmap_add(cup, id, die, B_FALSE)) != 0)
1638                 return (ret);
1639 
1640         if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) {
1641                 if (ret == ENOENT)
1642                         ret = 0;
1643                 return (ret);
1644         }
1645 
1646         while (child != NULL) {
1647                 Dwarf_Half tag;
1648                 Dwarf_Signed sval;
1649                 Dwarf_Unsigned uval;
1650                 Dwarf_Die arg = child;
1651                 int eval;
1652 
1653                 if ((ret = ctf_dwarf_sib(cup, arg, &child)) != 0)
1654                         return (ret);
1655 
1656                 if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0)
1657                         return (ret);
1658 
1659                 if (tag != DW_TAG_enumerator) {
1660                         if ((ret = ctf_dwarf_convert_type(cup, arg, NULL,
1661                             CTF_ADD_NONROOT)) != 0)
1662                                 return (ret);
1663                         continue;
1664                 }
1665 
1666                 /*
1667                  * DWARF v4 section 5.7 tells us we'll always have names.
1668                  */
1669                 if ((ret = ctf_dwarf_string(cup, arg, DW_AT_name, &name)) != 0)
1670                         return (ret);
1671 
1672                 /*
1673                  * We have to be careful here: newer GCCs generate DWARF where
1674                  * an unsigned value will happily pass ctf_dwarf_signed().
1675                  * Since negative values will fail ctf_dwarf_unsigned(), we try
1676                  * that first to make sure we get the right value.
1677                  */
1678                 if ((ret = ctf_dwarf_unsigned(cup, arg, DW_AT_const_value,
1679                     &uval)) == 0) {
1680                         eval = (int)uval;
1681                 } else if ((ret = ctf_dwarf_signed(cup, arg, DW_AT_const_value,
1682                     &sval)) == 0) {
1683                         eval = sval;
1684                 }
1685 
1686                 if (ret != 0) {
1687                         if (ret != ENOENT)
1688                                 return (ret);
1689 
1690                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1691                             "encountered enumeration without constant value\n");
1692                         return (ECTF_CONVBKERR);
1693                 }
1694 
1695                 ret = ctf_add_enumerator(cup->cu_ctfp, id, name, eval);
1696                 if (ret == CTF_ERR) {
1697                         (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1698                             "failed to add enumarator %s (%d) to %d\n",
1699                             name, eval, id);
1700                         ctf_free(name, strlen(name) + 1);
1701                         return (ctf_errno(cup->cu_ctfp));
1702                 }
1703                 ctf_free(name, strlen(name) + 1);
1704         }
1705 
1706         return (0);
1707 }
1708 
1709 /*
1710  * For a function pointer, walk over and process all of its children, unless we
1711  * encounter one that's just a declaration. In which case, we error on it.
1712  */
1713 static int
1714 ctf_dwarf_create_fptr(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot)
1715 {
1716         int ret;
1717         Dwarf_Bool b;
1718         ctf_funcinfo_t fi;
1719         Dwarf_Die retdie;
1720         ctf_id_t *argv = NULL;
1721 
1722         bzero(&fi, sizeof (ctf_funcinfo_t));
1723 
1724         if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) {
1725                 if (ret != ENOENT)
1726                         return (ret);
1727         } else {
1728                 if (b != 0)
1729                         return (EPROTOTYPE);
1730         }
1731 
1732         /*
1733          * Return type is in DW_AT_type, if none, it returns void.
1734          */
1735         if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &retdie)) != 0) {
1736                 if (ret != ENOENT)
1737                         return (ret);
1738                 if ((fi.ctc_return = ctf_dwarf_void(cup)) == CTF_ERR)
1739                         return (ctf_errno(cup->cu_ctfp));
1740         } else {
1741                 if ((ret = ctf_dwarf_convert_type(cup, retdie, &fi.ctc_return,
1742                     CTF_ADD_NONROOT)) != 0)
1743                         return (ret);
1744         }
1745 
1746         if ((ret = ctf_dwarf_function_count(cup, die, &fi, B_TRUE)) != 0) {
1747                 return (ret);
1748         }
1749 
1750         if (fi.ctc_argc != 0) {
1751                 argv = ctf_alloc(sizeof (ctf_id_t) * fi.ctc_argc);
1752                 if (argv == NULL)
1753                         return (ENOMEM);
1754 
1755                 if ((ret = ctf_dwarf_convert_fargs(cup, die, &fi, argv)) != 0) {
1756                         ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc);
1757                         return (ret);
1758                 }
1759         }
1760 
1761         if ((*idp = ctf_add_funcptr(cup->cu_ctfp, isroot, &fi, argv)) ==
1762             CTF_ERR) {
1763                 ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc);
1764                 return (ctf_errno(cup->cu_ctfp));
1765         }
1766 
1767         ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc);
1768         return (ctf_dwmap_add(cup, *idp, die, B_FALSE));
1769 }
1770 
1771 static int
1772 ctf_dwarf_convert_type(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp,
1773     int isroot)
1774 {
1775         int ret;
1776         Dwarf_Off offset;
1777         Dwarf_Half tag;
1778         ctf_dwmap_t lookup, *map;
1779         ctf_id_t id;
1780 
1781         if (idp == NULL)
1782                 idp = &id;
1783 
1784         if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0)
1785                 return (ret);
1786 
1787         if (offset > cup->cu_maxoff) {
1788                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
1789                     "die offset %llu beyond maximum for header %llu\n",
1790                     offset, cup->cu_maxoff);
1791                 return (ECTF_CONVBKERR);
1792         }
1793 
1794         /*
1795          * If we've already added an entry for this offset, then we're done.
1796          */
1797         lookup.cdm_off = offset;
1798         if ((map = avl_find(&cup->cu_map, &lookup, NULL)) != NULL) {
1799                 *idp = map->cdm_id;
1800                 return (0);
1801         }
1802 
1803         if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0)
1804                 return (ret);
1805 
1806         ret = ENOTSUP;
1807         switch (tag) {
1808         case DW_TAG_base_type:
1809                 ctf_dprintf("base\n");
1810                 ret = ctf_dwarf_create_base(cup, die, idp, isroot, offset);
1811                 break;
1812         case DW_TAG_array_type:
1813                 ctf_dprintf("array\n");
1814                 ret = ctf_dwarf_create_array(cup, die, idp, isroot);
1815                 break;
1816         case DW_TAG_enumeration_type:
1817                 ctf_dprintf("enum\n");
1818                 ret = ctf_dwarf_create_enum(cup, die, idp, isroot);
1819                 break;
1820         case DW_TAG_pointer_type:
1821                 ctf_dprintf("pointer\n");
1822                 ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_POINTER,
1823                     isroot);
1824                 break;
1825         case DW_TAG_structure_type:
1826                 ctf_dprintf("struct\n");
1827                 ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_STRUCT,
1828                     isroot);
1829                 break;
1830         case DW_TAG_subroutine_type:
1831                 ctf_dprintf("fptr\n");
1832                 ret = ctf_dwarf_create_fptr(cup, die, idp, isroot);
1833                 break;
1834         case DW_TAG_typedef:
1835                 ctf_dprintf("typedef\n");
1836                 ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_TYPEDEF,
1837                     isroot);
1838                 break;
1839         case DW_TAG_union_type:
1840                 ctf_dprintf("union\n");
1841                 ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_UNION,
1842                     isroot);
1843                 break;
1844         case DW_TAG_const_type:
1845                 ctf_dprintf("const\n");
1846                 ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_CONST,
1847                     isroot);
1848                 break;
1849         case DW_TAG_volatile_type:
1850                 ctf_dprintf("volatile\n");
1851                 ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_VOLATILE,
1852                     isroot);
1853                 break;
1854         case DW_TAG_restrict_type:
1855                 ctf_dprintf("restrict\n");
1856                 ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_RESTRICT,
1857                     isroot);
1858                 break;
1859         default:
1860                 ctf_dprintf("ignoring tag type %x\n", tag);
1861                 *idp = CTF_ERR;
1862                 ret = 0;
1863                 break;
1864         }
1865         ctf_dprintf("ctf_dwarf_convert_type tag specific handler returned %d\n",
1866             ret);
1867 
1868         return (ret);
1869 }
1870 
1871 static int
1872 ctf_dwarf_walk_lexical(ctf_cu_t *cup, Dwarf_Die die)
1873 {
1874         int ret;
1875         Dwarf_Die child;
1876 
1877         if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1878                 return (ret);
1879 
1880         if (child == NULL)
1881                 return (0);
1882 
1883         return (ctf_dwarf_convert_die(cup, die));
1884 }
1885 
1886 static int
1887 ctf_dwarf_function_count(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip,
1888     boolean_t fptr)
1889 {
1890         int ret;
1891         Dwarf_Die child, sib, arg;
1892 
1893         if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1894                 return (ret);
1895 
1896         arg = child;
1897         while (arg != NULL) {
1898                 Dwarf_Half tag;
1899 
1900                 if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0)
1901                         return (ret);
1902 
1903                 /*
1904                  * We have to check for a varargs type declaration. This will
1905                  * happen in one of two ways. If we have a function pointer
1906                  * type, then it'll be done with a tag of type
1907                  * DW_TAG_unspecified_parameters. However, it only means we have
1908                  * a variable number of arguments, if we have more than one
1909                  * argument found so far. Otherwise, when we have a function
1910                  * type, it instead uses a formal parameter whose name is '...'
1911                  * to indicate a variable arguments member.
1912                  *
1913                  * Also, if we have a function pointer, then we have to expect
1914                  * that we might not get a name at all.
1915                  */
1916                 if (tag == DW_TAG_formal_parameter && fptr == B_FALSE) {
1917                         char *name;
1918                         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name,
1919                             &name)) != 0)
1920                                 return (ret);
1921                         if (strcmp(name, DWARF_VARARGS_NAME) == 0)
1922                                 fip->ctc_flags |= CTF_FUNC_VARARG;
1923                         else
1924                                 fip->ctc_argc++;
1925                         ctf_free(name, strlen(name) + 1);
1926                 } else if (tag == DW_TAG_formal_parameter) {
1927                         fip->ctc_argc++;
1928                 } else if (tag == DW_TAG_unspecified_parameters &&
1929                     fip->ctc_argc > 0) {
1930                         fip->ctc_flags |= CTF_FUNC_VARARG;
1931                 }
1932                 if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0)
1933                         return (ret);
1934                 arg = sib;
1935         }
1936 
1937         return (0);
1938 }
1939 
1940 static int
1941 ctf_dwarf_convert_fargs(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip,
1942     ctf_id_t *argv)
1943 {
1944         int ret;
1945         int i = 0;
1946         Dwarf_Die child, sib, arg;
1947 
1948         if ((ret = ctf_dwarf_child(cup, die, &child)) != 0)
1949                 return (ret);
1950 
1951         arg = child;
1952         while (arg != NULL) {
1953                 Dwarf_Half tag;
1954 
1955                 if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0)
1956                         return (ret);
1957                 if (tag == DW_TAG_formal_parameter) {
1958                         Dwarf_Die tdie;
1959 
1960                         if ((ret = ctf_dwarf_refdie(cup, arg, DW_AT_type,
1961                             &tdie)) != 0)
1962                                 return (ret);
1963 
1964                         if ((ret = ctf_dwarf_convert_type(cup, tdie, &argv[i],
1965                             CTF_ADD_ROOT)) != 0)
1966                                 return (ret);
1967                         i++;
1968 
1969                         /*
1970                          * Once we hit argc entries, we're done. This ensures we
1971                          * don't accidentally hit a varargs which should be the
1972                          * last entry.
1973                          */
1974                         if (i == fip->ctc_argc)
1975                                 break;
1976                 }
1977 
1978                 if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0)
1979                         return (ret);
1980                 arg = sib;
1981         }
1982 
1983         return (0);
1984 }
1985 
1986 static int
1987 ctf_dwarf_convert_function(ctf_cu_t *cup, Dwarf_Die die)
1988 {
1989         ctf_dwfunc_t *cdf;
1990         Dwarf_Die tdie;
1991         Dwarf_Bool b;
1992         char *name;
1993         int ret;
1994 
1995         /*
1996          * Functions that don't have a name are generally functions that have
1997          * been inlined and thus most information about them has been lost. If
1998          * we can't get a name, then instead of returning ENOENT, we silently
1999          * swallow the error.
2000          */
2001         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0) {
2002                 if (ret == ENOENT)
2003                         return (0);
2004                 return (ret);
2005         }
2006 
2007         ctf_dprintf("beginning work on function %s (die %llx)\n",
2008             name, ctf_die_offset(die));
2009 
2010         if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) {
2011                 if (ret != ENOENT)
2012                         return (ret);
2013         } else if (b != 0) {
2014                 /*
2015                  * GCC7 at least creates empty DW_AT_declarations for functions
2016                  * defined in headers.  As they lack details on the function
2017                  * prototype, we need to ignore them.  If we later actually
2018                  * see the relevant function's definition, we will see another
2019                  * DW_TAG_subprogram that is more complete.
2020                  */
2021                 ctf_dprintf("ignoring declaration of function %s (die %llx)\n",
2022                     name, ctf_die_offset(die));
2023                 return (0);
2024         }
2025 
2026         if ((cdf = ctf_alloc(sizeof (ctf_dwfunc_t))) == NULL) {
2027                 ctf_free(name, strlen(name) + 1);
2028                 return (ENOMEM);
2029         }
2030         bzero(cdf, sizeof (ctf_dwfunc_t));
2031         cdf->cdf_name = name;
2032 
2033         if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) == 0) {
2034                 if ((ret = ctf_dwarf_convert_type(cup, tdie,
2035                     &(cdf->cdf_fip.ctc_return), CTF_ADD_ROOT)) != 0) {
2036                         ctf_free(name, strlen(name) + 1);
2037                         ctf_free(cdf, sizeof (ctf_dwfunc_t));
2038                         return (ret);
2039                 }
2040         } else if (ret != ENOENT) {
2041                 ctf_free(name, strlen(name) + 1);
2042                 ctf_free(cdf, sizeof (ctf_dwfunc_t));
2043                 return (ret);
2044         } else {
2045                 if ((cdf->cdf_fip.ctc_return = ctf_dwarf_void(cup)) ==
2046                     CTF_ERR) {
2047                         ctf_free(name, strlen(name) + 1);
2048                         ctf_free(cdf, sizeof (ctf_dwfunc_t));
2049                         return (ctf_errno(cup->cu_ctfp));
2050                 }
2051         }
2052 
2053         /*
2054          * A function has a number of children, some of which may not be ones we
2055          * care about. Children that we care about have a type of
2056          * DW_TAG_formal_parameter. We're going to do two passes, the first to
2057          * count the arguments, the second to process them. Afterwards, we
2058          * should be good to go ahead and add this function.
2059          *
2060          * Note, we already got the return type by going in and grabbing it out
2061          * of the DW_AT_type.
2062          */
2063         if ((ret = ctf_dwarf_function_count(cup, die, &cdf->cdf_fip,
2064             B_FALSE)) != 0) {
2065                 ctf_free(name, strlen(name) + 1);
2066                 ctf_free(cdf, sizeof (ctf_dwfunc_t));
2067                 return (ret);
2068         }
2069 
2070         ctf_dprintf("beginning to convert function arguments %s\n", name);
2071         if (cdf->cdf_fip.ctc_argc != 0) {
2072                 uint_t argc = cdf->cdf_fip.ctc_argc;
2073                 cdf->cdf_argv = ctf_alloc(sizeof (ctf_id_t) * argc);
2074                 if (cdf->cdf_argv == NULL) {
2075                         ctf_free(name, strlen(name) + 1);
2076                         ctf_free(cdf, sizeof (ctf_dwfunc_t));
2077                         return (ENOMEM);
2078                 }
2079                 if ((ret = ctf_dwarf_convert_fargs(cup, die,
2080                     &cdf->cdf_fip, cdf->cdf_argv)) != 0) {
2081                         ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) * argc);
2082                         ctf_free(name, strlen(name) + 1);
2083                         ctf_free(cdf, sizeof (ctf_dwfunc_t));
2084                         return (ret);
2085                 }
2086         } else {
2087                 cdf->cdf_argv = NULL;
2088         }
2089 
2090         if ((ret = ctf_dwarf_isglobal(cup, die, &cdf->cdf_global)) != 0) {
2091                 ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) *
2092                     cdf->cdf_fip.ctc_argc);
2093                 ctf_free(name, strlen(name) + 1);
2094                 ctf_free(cdf, sizeof (ctf_dwfunc_t));
2095                 return (ret);
2096         }
2097 
2098         ctf_list_append(&cup->cu_funcs, cdf);
2099         return (ret);
2100 }
2101 
2102 /*
2103  * Convert variables, but only if they're not prototypes and have names.
2104  */
2105 static int
2106 ctf_dwarf_convert_variable(ctf_cu_t *cup, Dwarf_Die die)
2107 {
2108         int ret;
2109         char *name;
2110         Dwarf_Bool b;
2111         Dwarf_Die tdie;
2112         ctf_id_t id;
2113         ctf_dwvar_t *cdv;
2114 
2115         /* Skip "Non-Defining Declarations" */
2116         if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) == 0) {
2117                 if (b != 0)
2118                         return (0);
2119         } else if (ret != ENOENT) {
2120                 return (ret);
2121         }
2122 
2123         /*
2124          * If we find a DIE of "Declarations Completing Non-Defining
2125          * Declarations", we will use the referenced type's DIE.  This isn't
2126          * quite correct, e.g. DW_AT_decl_line will be the forward declaration
2127          * not this site.  It's sufficient for what we need, however: in
2128          * particular, we should find DW_AT_external as needed there.
2129          */
2130         if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_specification,
2131             &tdie)) == 0) {
2132                 Dwarf_Off offset;
2133                 if ((ret = ctf_dwarf_offset(cup, tdie, &offset)) != 0)
2134                         return (ret);
2135                 ctf_dprintf("die 0x%llx DW_AT_specification -> die 0x%llx\n",
2136                     ctf_die_offset(die), ctf_die_offset(tdie));
2137                 die = tdie;
2138         } else if (ret != ENOENT) {
2139                 return (ret);
2140         }
2141 
2142         if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 &&
2143             ret != ENOENT)
2144                 return (ret);
2145         if (ret == ENOENT)
2146                 return (0);
2147 
2148         if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) {
2149                 ctf_free(name, strlen(name) + 1);
2150                 return (ret);
2151         }
2152 
2153         if ((ret = ctf_dwarf_convert_type(cup, tdie, &id,
2154             CTF_ADD_ROOT)) != 0)
2155                 return (ret);
2156 
2157         if ((cdv = ctf_alloc(sizeof (ctf_dwvar_t))) == NULL) {
2158                 ctf_free(name, strlen(name) + 1);
2159                 return (ENOMEM);
2160         }
2161 
2162         cdv->cdv_name = name;
2163         cdv->cdv_type = id;
2164 
2165         if ((ret = ctf_dwarf_isglobal(cup, die, &cdv->cdv_global)) != 0) {
2166                 ctf_free(cdv, sizeof (ctf_dwvar_t));
2167                 ctf_free(name, strlen(name) + 1);
2168                 return (ret);
2169         }
2170 
2171         ctf_list_append(&cup->cu_vars, cdv);
2172         return (0);
2173 }
2174 
2175 /*
2176  * Walk through our set of top-level types and process them.
2177  */
2178 static int
2179 ctf_dwarf_walk_toplevel(ctf_cu_t *cup, Dwarf_Die die)
2180 {
2181         int ret;
2182         Dwarf_Off offset;
2183         Dwarf_Half tag;
2184 
2185         if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0)
2186                 return (ret);
2187 
2188         if (offset > cup->cu_maxoff) {
2189                 (void) snprintf(cup->cu_errbuf, cup->cu_errlen,
2190                     "die offset %llu beyond maximum for header %llu\n",
2191                     offset, cup->cu_maxoff);
2192                 return (ECTF_CONVBKERR);
2193         }
2194 
2195         if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0)
2196                 return (ret);
2197 
2198         ret = 0;
2199         switch (tag) {
2200         case DW_TAG_subprogram:
2201                 ctf_dprintf("top level func\n");
2202                 ret = ctf_dwarf_convert_function(cup, die);
2203                 break;
2204         case DW_TAG_variable:
2205                 ctf_dprintf("top level var\n");
2206                 ret = ctf_dwarf_convert_variable(cup, die);
2207                 break;
2208         case DW_TAG_lexical_block:
2209                 ctf_dprintf("top level block\n");
2210                 ret = ctf_dwarf_walk_lexical(cup, die);
2211                 break;
2212         case DW_TAG_enumeration_type:
2213         case DW_TAG_structure_type:
2214         case DW_TAG_typedef:
2215         case DW_TAG_union_type:
2216                 ctf_dprintf("top level type\n");
2217                 ret = ctf_dwarf_convert_type(cup, die, NULL, B_TRUE);
2218                 break;
2219         default:
2220                 break;
2221         }
2222 
2223         return (ret);
2224 }
2225 
2226 
2227 /*
2228  * We're given a node. At this node we need to convert it and then proceed to
2229  * convert any siblings that are associaed with this die.
2230  */
2231 static int
2232 ctf_dwarf_convert_die(ctf_cu_t *cup, Dwarf_Die die)
2233 {
2234         while (die != NULL) {
2235                 int ret;
2236                 Dwarf_Die sib;
2237 
2238                 if ((ret = ctf_dwarf_walk_toplevel(cup, die)) != 0)
2239                         return (ret);
2240 
2241                 if ((ret = ctf_dwarf_sib(cup, die, &sib)) != 0)
2242                         return (ret);
2243                 die = sib;
2244         }
2245         return (0);
2246 }
2247 
2248 static int
2249 ctf_dwarf_fixup_die(ctf_cu_t *cup, boolean_t addpass)
2250 {
2251         ctf_dwmap_t *map;
2252 
2253         for (map = avl_first(&cup->cu_map); map != NULL;
2254             map = AVL_NEXT(&cup->cu_map, map)) {
2255                 int ret;
2256                 if (map->cdm_fix == B_FALSE)
2257                         continue;
2258                 if ((ret = ctf_dwarf_fixup_sou(cup, map->cdm_die, map->cdm_id,
2259                     addpass)) != 0)
2260                         return (ret);
2261         }
2262 
2263         return (0);
2264 }
2265 
2266 /*
2267  * The DWARF information about a symbol and the information in the symbol table
2268  * may not be the same due to symbol reduction that is performed by ld due to a
2269  * mapfile or other such directive. We process weak symbols at a later time.
2270  *
2271  * The following are the rules that we employ:
2272  *
2273  * 1. A DWARF function that is considered exported matches STB_GLOBAL entries
2274  * with the same name.
2275  *
2276  * 2. A DWARF function that is considered exported matches STB_LOCAL entries
2277  * with the same name and the same file. This case may happen due to mapfile
2278  * reduction.
2279  *
2280  * 3. A DWARF function that is not considered exported matches STB_LOCAL entries
2281  * with the same name and the same file.
2282  *
2283  * 4. A DWARF function that has the same name as the symbol table entry, but the
2284  * files do not match. This is considered a 'fuzzy' match. This may also happen
2285  * due to a mapfile reduction. Fuzzy matching is only used when we know that the
2286  * file in question refers to the primary object. This is because when a symbol
2287  * is reduced in a mapfile, it's always going to be tagged as a local value in
2288  * the generated output and it is considered as to belong to the primary file
2289  * which is the first STT_FILE symbol we see.
2290  */
2291 static boolean_t
2292 ctf_dwarf_symbol_match(const char *symtab_file, const char *symtab_name,
2293     uint_t symtab_bind, const char *dwarf_file, const char *dwarf_name,
2294     boolean_t dwarf_global, boolean_t *is_fuzzy)
2295 {
2296         *is_fuzzy = B_FALSE;
2297 
2298         if (symtab_bind != STB_LOCAL && symtab_bind != STB_GLOBAL) {
2299                 return (B_FALSE);
2300         }
2301 
2302         if (strcmp(symtab_name, dwarf_name) != 0) {
2303                 return (B_FALSE);
2304         }
2305 
2306         if (symtab_bind == STB_GLOBAL) {
2307                 return (dwarf_global);
2308         }
2309 
2310         if (strcmp(symtab_file, dwarf_file) == 0) {
2311                 return (B_TRUE);
2312         }
2313 
2314         if (dwarf_global) {
2315                 *is_fuzzy = B_TRUE;
2316                 return (B_TRUE);
2317         }
2318 
2319         return (B_FALSE);
2320 }
2321 
2322 static ctf_dwfunc_t *
2323 ctf_dwarf_match_func(ctf_cu_t *cup, const char *file, const char *name,
2324     uint_t bind, boolean_t primary)
2325 {
2326         ctf_dwfunc_t *cdf, *fuzzy = NULL;
2327 
2328         if (bind == STB_WEAK)
2329                 return (NULL);
2330 
2331         if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL))
2332                 return (NULL);
2333 
2334         for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL;
2335             cdf = ctf_list_next(cdf)) {
2336                 boolean_t is_fuzzy = B_FALSE;
2337 
2338                 if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name,
2339                     cdf->cdf_name, cdf->cdf_global, &is_fuzzy)) {
2340                         if (is_fuzzy) {
2341                                 if (primary) {
2342                                         fuzzy = cdf;
2343                                 }
2344                                 continue;
2345                         } else {
2346                                 return (cdf);
2347                         }
2348                 }
2349         }
2350 
2351         return (fuzzy);
2352 }
2353 
2354 static ctf_dwvar_t *
2355 ctf_dwarf_match_var(ctf_cu_t *cup, const char *file, const char *name,
2356     uint_t bind, boolean_t primary)
2357 {
2358         ctf_dwvar_t *cdv, *fuzzy = NULL;
2359 
2360         if (bind == STB_WEAK)
2361                 return (NULL);
2362 
2363         if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL))
2364                 return (NULL);
2365 
2366         for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL;
2367             cdv = ctf_list_next(cdv)) {
2368                 boolean_t is_fuzzy = B_FALSE;
2369 
2370                 if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name,
2371                     cdv->cdv_name, cdv->cdv_global, &is_fuzzy)) {
2372                         if (is_fuzzy) {
2373                                 if (primary) {
2374                                         fuzzy = cdv;
2375                                 }
2376                         } else {
2377                                 return (cdv);
2378                         }
2379                 }
2380         }
2381 
2382         return (fuzzy);
2383 }
2384 
2385 static int
2386 ctf_dwarf_conv_funcvars_cb(const Elf64_Sym *symp, ulong_t idx,
2387     const char *file, const char *name, boolean_t primary, void *arg)
2388 {
2389         int ret;
2390         uint_t bind, type;
2391         ctf_cu_t *cup = arg;
2392 
2393         bind = GELF_ST_BIND(symp->st_info);
2394         type = GELF_ST_TYPE(symp->st_info);
2395 
2396         /*
2397          * Come back to weak symbols in another pass
2398          */
2399         if (bind == STB_WEAK)
2400                 return (0);
2401 
2402         if (type == STT_OBJECT) {
2403                 ctf_dwvar_t *cdv = ctf_dwarf_match_var(cup, file, name,
2404                     bind, primary);
2405                 if (cdv == NULL)
2406                         return (0);
2407                 ret = ctf_add_object(cup->cu_ctfp, idx, cdv->cdv_type);
2408                 ctf_dprintf("added object %s->%ld\n", name, cdv->cdv_type);
2409         } else {
2410                 ctf_dwfunc_t *cdf = ctf_dwarf_match_func(cup, file, name,
2411                     bind, primary);
2412                 if (cdf == NULL)
2413                         return (0);
2414                 ret = ctf_add_function(cup->cu_ctfp, idx, &cdf->cdf_fip,
2415                     cdf->cdf_argv);
2416                 ctf_dprintf("added function %s\n", name);
2417         }
2418 
2419         if (ret == CTF_ERR) {
2420                 return (ctf_errno(cup->cu_ctfp));
2421         }
2422 
2423         return (0);
2424 }
2425 
2426 static int
2427 ctf_dwarf_conv_funcvars(ctf_cu_t *cup)
2428 {
2429         return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_funcvars_cb, cup));
2430 }
2431 
2432 /*
2433  * If we have a weak symbol, attempt to find the strong symbol it will resolve
2434  * to.  Note: the code where this actually happens is in sym_process() in
2435  * cmd/sgs/libld/common/syms.c
2436  *
2437  * Finding the matching symbol is unfortunately not trivial.  For a symbol to be
2438  * a candidate, it must:
2439  *
2440  * - have the same type (function, object)
2441  * - have the same value (address)
2442  * - have the same size
2443  * - not be another weak symbol
2444  * - belong to the same section (checked via section index)
2445  *
2446  * To perform this check, we first iterate over the symbol table. For each weak
2447  * symbol that we encounter, we then do a second walk over the symbol table,
2448  * calling ctf_dwarf_conv_check_weak(). If a symbol matches the above, then it's
2449  * either a local or global symbol. If we find a global symbol then we go with
2450  * it and stop searching for additional matches.
2451  *
2452  * If instead, we find a local symbol, things are more complicated. The first
2453  * thing we do is to try and see if we have file information about both symbols
2454  * (STT_FILE). If they both have file information and it matches, then we treat
2455  * that as a good match and stop searching for additional matches.
2456  *
2457  * Otherwise, this means we have a non-matching file and a local symbol. We
2458  * treat this as a candidate and if we find a better match (one of the two cases
2459  * above), use that instead. There are two different ways this can happen.
2460  * Either this is a completely different symbol, or it's a once-global symbol
2461  * that was scoped to local via a mapfile.  In the former case, curfile is
2462  * likely inaccurate since the linker does not preserve the needed curfile in
2463  * the order of the symbol table (see the comments about locally scoped symbols
2464  * in libld's update_osym()).  As we can't tell this case from the former one,
2465  * we use this symbol iff no other matching symbol is found.
2466  *
2467  * What we really need here is a SUNW section containing weak<->strong mappings
2468  * that we can consume.
2469  */
2470 typedef struct ctf_dwarf_weak_arg {
2471         const Elf64_Sym *cweak_symp;
2472         const char *cweak_file;
2473         boolean_t cweak_candidate;
2474         ulong_t cweak_idx;
2475 } ctf_dwarf_weak_arg_t;
2476 
2477 static int
2478 ctf_dwarf_conv_check_weak(const Elf64_Sym *symp, ulong_t idx, const char *file,
2479     const char *name, boolean_t primary, void *arg)
2480 {
2481         ctf_dwarf_weak_arg_t *cweak = arg;
2482 
2483         const Elf64_Sym *wsymp = cweak->cweak_symp;
2484 
2485         ctf_dprintf("comparing weak to %s\n", name);
2486 
2487         if (GELF_ST_BIND(symp->st_info) == STB_WEAK) {
2488                 return (0);
2489         }
2490 
2491         if (GELF_ST_TYPE(wsymp->st_info) != GELF_ST_TYPE(symp->st_info)) {
2492                 return (0);
2493         }
2494 
2495         if (wsymp->st_value != symp->st_value) {
2496                 return (0);
2497         }
2498 
2499         if (wsymp->st_size != symp->st_size) {
2500                 return (0);
2501         }
2502 
2503         if (wsymp->st_shndx != symp->st_shndx) {
2504                 return (0);
2505         }
2506 
2507         /*
2508          * Check if it's a weak candidate.
2509          */
2510         if (GELF_ST_BIND(symp->st_info) == STB_LOCAL &&
2511             (file == NULL || cweak->cweak_file == NULL ||
2512             strcmp(file, cweak->cweak_file) != 0)) {
2513                 cweak->cweak_candidate = B_TRUE;
2514                 cweak->cweak_idx = idx;
2515                 return (0);
2516         }
2517 
2518         /*
2519          * Found a match, break.
2520          */
2521         cweak->cweak_idx = idx;
2522         return (1);
2523 }
2524 
2525 static int
2526 ctf_dwarf_duplicate_sym(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx)
2527 {
2528         ctf_id_t id = ctf_lookup_by_symbol(cup->cu_ctfp, matchidx);
2529 
2530         /*
2531          * If we matched something that for some reason didn't have type data,
2532          * we don't consider that a fatal error and silently swallow it.
2533          */
2534         if (id == CTF_ERR) {
2535                 if (ctf_errno(cup->cu_ctfp) == ECTF_NOTYPEDAT)
2536                         return (0);
2537                 else
2538                         return (ctf_errno(cup->cu_ctfp));
2539         }
2540 
2541         if (ctf_add_object(cup->cu_ctfp, idx, id) == CTF_ERR)
2542                 return (ctf_errno(cup->cu_ctfp));
2543 
2544         return (0);
2545 }
2546 
2547 static int
2548 ctf_dwarf_duplicate_func(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx)
2549 {
2550         int ret;
2551         ctf_funcinfo_t fip;
2552         ctf_id_t *args = NULL;
2553 
2554         if (ctf_func_info(cup->cu_ctfp, matchidx, &fip) == CTF_ERR) {
2555                 if (ctf_errno(cup->cu_ctfp) == ECTF_NOFUNCDAT)
2556                         return (0);
2557                 else
2558                         return (ctf_errno(cup->cu_ctfp));
2559         }
2560 
2561         if (fip.ctc_argc != 0) {
2562                 args = ctf_alloc(sizeof (ctf_id_t) * fip.ctc_argc);
2563                 if (args == NULL)
2564                         return (ENOMEM);
2565 
2566                 if (ctf_func_args(cup->cu_ctfp, matchidx, fip.ctc_argc, args) ==
2567                     CTF_ERR) {
2568                         ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc);
2569                         return (ctf_errno(cup->cu_ctfp));
2570                 }
2571         }
2572 
2573         ret = ctf_add_function(cup->cu_ctfp, idx, &fip, args);
2574         if (args != NULL)
2575                 ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc);
2576         if (ret == CTF_ERR)
2577                 return (ctf_errno(cup->cu_ctfp));
2578 
2579         return (0);
2580 }
2581 
2582 static int
2583 ctf_dwarf_conv_weaks_cb(const Elf64_Sym *symp, ulong_t idx, const char *file,
2584     const char *name, boolean_t primary, void *arg)
2585 {
2586         int ret, type;
2587         ctf_dwarf_weak_arg_t cweak;
2588         ctf_cu_t *cup = arg;
2589 
2590         /*
2591          * We only care about weak symbols.
2592          */
2593         if (GELF_ST_BIND(symp->st_info) != STB_WEAK)
2594                 return (0);
2595 
2596         type = GELF_ST_TYPE(symp->st_info);
2597         ASSERT(type == STT_OBJECT || type == STT_FUNC);
2598 
2599         /*
2600          * For each weak symbol we encounter, we need to do a second iteration
2601          * to try and find a match. We should probably think about other
2602          * techniques to try and save us time in the future.
2603          */
2604         cweak.cweak_symp = symp;
2605         cweak.cweak_file = file;
2606         cweak.cweak_candidate = B_FALSE;
2607         cweak.cweak_idx = 0;
2608 
2609         ctf_dprintf("Trying to find weak equiv for %s\n", name);
2610 
2611         ret = ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_check_weak, &cweak);
2612         VERIFY(ret == 0 || ret == 1);
2613 
2614         /*
2615          * Nothing was ever found, we're not going to add anything for this
2616          * entry.
2617          */
2618         if (ret == 0 && cweak.cweak_candidate == B_FALSE) {
2619                 ctf_dprintf("found no weak match for %s\n", name);
2620                 return (0);
2621         }
2622 
2623         /*
2624          * Now, finally go and add the type based on the match.
2625          */
2626         ctf_dprintf("matched weak symbol %lu to %lu\n", idx, cweak.cweak_idx);
2627         if (type == STT_OBJECT) {
2628                 ret = ctf_dwarf_duplicate_sym(cup, idx, cweak.cweak_idx);
2629         } else {
2630                 ret = ctf_dwarf_duplicate_func(cup, idx, cweak.cweak_idx);
2631         }
2632 
2633         return (ret);
2634 }
2635 
2636 static int
2637 ctf_dwarf_conv_weaks(ctf_cu_t *cup)
2638 {
2639         return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_weaks_cb, cup));
2640 }
2641 
2642 /* ARGSUSED */
2643 static int
2644 ctf_dwarf_convert_one(void *arg, void *unused)
2645 {
2646         int ret;
2647         ctf_file_t *dedup;
2648         ctf_cu_t *cup = arg;
2649 
2650         ctf_dprintf("converting die: %s\n", cup->cu_name);
2651         ctf_dprintf("max offset: %x\n", cup->cu_maxoff);
2652         VERIFY(cup != NULL);
2653 
2654         ret = ctf_dwarf_convert_die(cup, cup->cu_cu);
2655         ctf_dprintf("ctf_dwarf_convert_die (%s) returned %d\n", cup->cu_name,
2656             ret);
2657         if (ret != 0) {
2658                 return (ret);
2659         }
2660         if (ctf_update(cup->cu_ctfp) != 0) {
2661                 return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2662                     "failed to update output ctf container"));
2663         }
2664 
2665         ret = ctf_dwarf_fixup_die(cup, B_FALSE);
2666         ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name,
2667             ret);
2668         if (ret != 0) {
2669                 return (ret);
2670         }
2671         if (ctf_update(cup->cu_ctfp) != 0) {
2672                 return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2673                     "failed to update output ctf container"));
2674         }
2675 
2676         ret = ctf_dwarf_fixup_die(cup, B_TRUE);
2677         ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name,
2678             ret);
2679         if (ret != 0) {
2680                 return (ret);
2681         }
2682         if (ctf_update(cup->cu_ctfp) != 0) {
2683                 return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2684                     "failed to update output ctf container"));
2685         }
2686 
2687 
2688         if ((ret = ctf_dwarf_conv_funcvars(cup)) != 0) {
2689                 return (ctf_dwarf_error(cup, NULL, ret,
2690                     "failed to convert strong functions and variables"));
2691         }
2692 
2693         if (ctf_update(cup->cu_ctfp) != 0) {
2694                 return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2695                     "failed to update output ctf container"));
2696         }
2697 
2698         if (cup->cu_doweaks == B_TRUE) {
2699                 if ((ret = ctf_dwarf_conv_weaks(cup)) != 0) {
2700                         return (ctf_dwarf_error(cup, NULL, ret,
2701                             "failed to convert weak functions and variables"));
2702                 }
2703 
2704                 if (ctf_update(cup->cu_ctfp) != 0) {
2705                         return (ctf_dwarf_error(cup, cup->cu_ctfp, 0,
2706                             "failed to update output ctf container"));
2707                 }
2708         }
2709 
2710         ctf_phase_dump(cup->cu_ctfp, "pre-dwarf-dedup", cup->cu_name);
2711         ctf_dprintf("adding inputs for dedup\n");
2712         if ((ret = ctf_merge_add(cup->cu_cmh, cup->cu_ctfp)) != 0) {
2713                 return (ctf_dwarf_error(cup, NULL, ret,
2714                     "failed to add inputs for merge"));
2715         }
2716 
2717         ctf_dprintf("starting dedup of %s\n", cup->cu_name);
2718         if ((ret = ctf_merge_dedup(cup->cu_cmh, &dedup)) != 0) {
2719                 return (ctf_dwarf_error(cup, NULL, ret,
2720                     "failed to deduplicate die"));
2721         }
2722         ctf_close(cup->cu_ctfp);
2723         cup->cu_ctfp = dedup;
2724         ctf_phase_dump(cup->cu_ctfp, "post-dwarf-dedup", cup->cu_name);
2725 
2726         return (0);
2727 }
2728 
2729 /*
2730  * Note, we expect that if we're returning a ctf_file_t from one of the dies,
2731  * say in the single node case, it's been saved and the entry here has been set
2732  * to NULL, which ctf_close happily ignores.
2733  */
2734 static void
2735 ctf_dwarf_free_die(ctf_cu_t *cup)
2736 {
2737         ctf_dwfunc_t *cdf, *ndf;
2738         ctf_dwvar_t *cdv, *ndv;
2739         ctf_dwbitf_t *cdb, *ndb;
2740         ctf_dwmap_t *map;
2741         void *cookie;
2742         Dwarf_Error derr;
2743 
2744         ctf_dprintf("Beginning to free die: %p\n", cup);
2745         cup->cu_elf = NULL;
2746         ctf_dprintf("Trying to free name: %p\n", cup->cu_name);
2747         if (cup->cu_name != NULL)
2748                 ctf_free(cup->cu_name, strlen(cup->cu_name) + 1);
2749         ctf_dprintf("Trying to free merge handle: %p\n", cup->cu_cmh);
2750         if (cup->cu_cmh != NULL) {
2751                 ctf_merge_fini(cup->cu_cmh);
2752                 cup->cu_cmh = NULL;
2753         }
2754 
2755         ctf_dprintf("Trying to free functions\n");
2756         for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL; cdf = ndf) {
2757                 ndf = ctf_list_next(cdf);
2758                 ctf_free(cdf->cdf_name, strlen(cdf->cdf_name) + 1);
2759                 if (cdf->cdf_fip.ctc_argc != 0) {
2760                         ctf_free(cdf->cdf_argv,
2761                             sizeof (ctf_id_t) * cdf->cdf_fip.ctc_argc);
2762                 }
2763                 ctf_free(cdf, sizeof (ctf_dwfunc_t));
2764         }
2765 
2766         ctf_dprintf("Trying to free variables\n");
2767         for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL; cdv = ndv) {
2768                 ndv = ctf_list_next(cdv);
2769                 ctf_free(cdv->cdv_name, strlen(cdv->cdv_name) + 1);
2770                 ctf_free(cdv, sizeof (ctf_dwvar_t));
2771         }
2772 
2773         ctf_dprintf("Trying to free bitfields\n");
2774         for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL; cdb = ndb) {
2775                 ndb = ctf_list_next(cdb);
2776                 ctf_free(cdb, sizeof (ctf_dwbitf_t));
2777         }
2778 
2779         ctf_dprintf("Trying to clean up dwarf_t: %p\n", cup->cu_dwarf);
2780         if (cup->cu_dwarf != NULL)
2781                 (void) dwarf_finish(cup->cu_dwarf, &derr);
2782         cup->cu_dwarf = NULL;
2783         ctf_close(cup->cu_ctfp);
2784 
2785         cookie = NULL;
2786         while ((map = avl_destroy_nodes(&cup->cu_map, &cookie)) != NULL) {
2787                 ctf_free(map, sizeof (ctf_dwmap_t));
2788         }
2789         avl_destroy(&cup->cu_map);
2790         cup->cu_errbuf = NULL;
2791 }
2792 
2793 static void
2794 ctf_dwarf_free_dies(ctf_cu_t *cdies, int ndies)
2795 {
2796         int i;
2797 
2798         ctf_dprintf("Beginning to free dies\n");
2799         for (i = 0; i < ndies; i++) {
2800                 ctf_dwarf_free_die(&cdies[i]);
2801         }
2802 
2803         ctf_free(cdies, sizeof (ctf_cu_t) * ndies);
2804 }
2805 
2806 static int
2807 ctf_dwarf_count_dies(Dwarf_Debug dw, Dwarf_Error *derr, int *ndies,
2808     char *errbuf, size_t errlen)
2809 {
2810         int ret;
2811         Dwarf_Half vers;
2812         Dwarf_Unsigned nexthdr;
2813 
2814         while ((ret = dwarf_next_cu_header(dw, NULL, &vers, NULL, NULL,
2815             &nexthdr, derr)) != DW_DLV_NO_ENTRY) {
2816                 if (ret != DW_DLV_OK) {
2817                         (void) snprintf(errbuf, errlen,
2818                             "file does not contain valid DWARF data: %s\n",
2819                             dwarf_errmsg(*derr));
2820                         return (ECTF_CONVBKERR);
2821                 }
2822 
2823                 if (vers != DWARF_VERSION_TWO) {
2824                         (void) snprintf(errbuf, errlen,
2825                             "unsupported DWARF version: %d\n", vers);
2826                         return (ECTF_CONVBKERR);
2827                 }
2828                 *ndies = *ndies + 1;
2829         }
2830 
2831         return (0);
2832 }
2833 
2834 static int
2835 ctf_dwarf_init_die(int fd, Elf *elf, ctf_cu_t *cup, int ndie, char *errbuf,
2836     size_t errlen)
2837 {
2838         int ret;
2839         Dwarf_Unsigned hdrlen, abboff, nexthdr;
2840         Dwarf_Half addrsz;
2841         Dwarf_Unsigned offset = 0;
2842         Dwarf_Error derr;
2843 
2844         while ((ret = dwarf_next_cu_header(cup->cu_dwarf, &hdrlen, NULL,
2845             &abboff, &addrsz, &nexthdr, &derr)) != DW_DLV_NO_ENTRY) {
2846                 char *name;
2847                 Dwarf_Die cu, child;
2848 
2849                 /* Based on the counting above, we should be good to go */
2850                 VERIFY(ret == DW_DLV_OK);
2851                 if (ndie > 0) {
2852                         ndie--;
2853                         offset = nexthdr;
2854                         continue;
2855                 }
2856 
2857                 /*
2858                  * Compilers are apparently inconsistent. Some emit no DWARF for
2859                  * empty files and others emit empty compilation unit.
2860                  */
2861                 cup->cu_voidtid = CTF_ERR;
2862                 cup->cu_longtid = CTF_ERR;
2863                 cup->cu_elf = elf;
2864                 cup->cu_maxoff = nexthdr - 1;
2865                 cup->cu_ctfp = ctf_fdcreate(fd, &ret);
2866                 if (cup->cu_ctfp == NULL)
2867                         return (ret);
2868 
2869                 avl_create(&cup->cu_map, ctf_dwmap_comp, sizeof (ctf_dwmap_t),
2870                     offsetof(ctf_dwmap_t, cdm_avl));
2871                 cup->cu_errbuf = errbuf;
2872                 cup->cu_errlen = errlen;
2873                 bzero(&cup->cu_vars, sizeof (ctf_list_t));
2874                 bzero(&cup->cu_funcs, sizeof (ctf_list_t));
2875                 bzero(&cup->cu_bitfields, sizeof (ctf_list_t));
2876 
2877                 if ((ret = ctf_dwarf_die_elfenc(elf, cup, errbuf,
2878                     errlen)) != 0)
2879                         return (ret);
2880 
2881                 if ((ret = ctf_dwarf_sib(cup, NULL, &cu)) != 0)
2882                         return (ret);
2883 
2884                 if (cu == NULL) {
2885                         (void) snprintf(errbuf, errlen,
2886                             "file does not contain DWARF data");
2887                         return (ECTF_CONVNODEBUG);
2888                 }
2889 
2890                 if ((ret = ctf_dwarf_child(cup, cu, &child)) != 0)
2891                         return (ret);
2892 
2893                 if (child == NULL) {
2894                         (void) snprintf(errbuf, errlen,
2895                             "file does not contain DWARF data");
2896                         return (ECTF_CONVNODEBUG);
2897                 }
2898 
2899                 cup->cu_cuoff = offset;
2900                 cup->cu_cu = child;
2901 
2902                 if ((cup->cu_cmh = ctf_merge_init(fd, &ret)) == NULL)
2903                         return (ret);
2904 
2905                 if (ctf_dwarf_string(cup, cu, DW_AT_name, &name) == 0) {
2906                         size_t len = strlen(name) + 1;
2907                         char *b = basename(name);
2908                         cup->cu_name = strdup(b);
2909                         ctf_free(name, len);
2910                 }
2911                 break;
2912         }
2913 
2914         return (0);
2915 }
2916 
2917 /*
2918  * This is our only recourse to identify a C source file that is missing debug
2919  * info: it will be mentioned as an STT_FILE, but not have a compile unit entry.
2920  * (A traditional ctfmerge works on individual files, so can identify missing
2921  * DWARF more directly, via ctf_has_c_source() on the .o file.)
2922  *
2923  * As we operate on basenames, this can of course miss some cases, but it's
2924  * better than not checking at all.
2925  *
2926  * We explicitly whitelist some CRT components.  Failing that, there's always
2927  * the -m option.
2928  */
2929 static boolean_t
2930 c_source_has_debug(const char *file, ctf_cu_t *cus, size_t nr_cus)
2931 {
2932         const char *basename = strrchr(file, '/');
2933 
2934         if (basename == NULL)
2935                 basename = file;
2936         else
2937                 basename++;
2938 
2939         if (strcmp(basename, "common-crt.c") == 0 ||
2940             strcmp(basename, "gmon.c") == 0 ||
2941             strcmp(basename, "dlink_init.c") == 0 ||
2942             strcmp(basename, "dlink_common.c") == 0 ||
2943             strncmp(basename, "crt", strlen("crt")) == 0 ||
2944             strncmp(basename, "values-", strlen("values-")) == 0)
2945                 return (B_TRUE);
2946 
2947         for (size_t i = 0; i < nr_cus; i++) {
2948                 if (strcmp(basename, cus[i].cu_name) == 0)
2949                         return (B_TRUE);
2950         }
2951 
2952         return (B_FALSE);
2953 }
2954 
2955 static int
2956 ctf_dwarf_check_missing(ctf_cu_t *cus, size_t nr_cus, Elf *elf,
2957     char *errmsg, size_t errlen)
2958 {
2959         Elf_Scn *scn, *strscn;
2960         Elf_Data *data, *strdata;
2961         GElf_Shdr shdr;
2962         ulong_t i;
2963 
2964         scn = NULL;
2965         while ((scn = elf_nextscn(elf, scn)) != NULL) {
2966                 if (gelf_getshdr(scn, &shdr) == NULL) {
2967                         (void) snprintf(errmsg, errlen,
2968                             "failed to get section header: %s\n",
2969                             elf_errmsg(elf_errno()));
2970                         return (EINVAL);
2971                 }
2972 
2973                 if (shdr.sh_type == SHT_SYMTAB)
2974                         break;
2975         }
2976 
2977         if (scn == NULL)
2978                 return (0);
2979 
2980         if ((strscn = elf_getscn(elf, shdr.sh_link)) == NULL) {
2981                 (void) snprintf(errmsg, errlen,
2982                     "failed to get str section: %s\n",
2983                     elf_errmsg(elf_errno()));
2984                 return (EINVAL);
2985         }
2986 
2987         if ((data = elf_getdata(scn, NULL)) == NULL) {
2988                 (void) snprintf(errmsg, errlen, "failed to read section: %s\n",
2989                     elf_errmsg(elf_errno()));
2990                 return (EINVAL);
2991         }
2992 
2993         if ((strdata = elf_getdata(strscn, NULL)) == NULL) {
2994                 (void) snprintf(errmsg, errlen,
2995                     "failed to read string table: %s\n",
2996                     elf_errmsg(elf_errno()));
2997                 return (EINVAL);
2998         }
2999 
3000         for (i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) {
3001                 GElf_Sym sym;
3002                 const char *file;
3003                 size_t len;
3004 
3005                 if (gelf_getsym(data, i, &sym) == NULL) {
3006                         (void) snprintf(errmsg, errlen,
3007                             "failed to read sym %lu: %s\n",
3008                             i, elf_errmsg(elf_errno()));
3009                         return (EINVAL);
3010                 }
3011 
3012                 if (GELF_ST_TYPE(sym.st_info) != STT_FILE)
3013                         continue;
3014 
3015                 file = (const char *)((uintptr_t)strdata->d_buf + sym.st_name);
3016                 len = strlen(file);
3017                 if (len < 2 || strncmp(".c", &file[len - 2], 2) != 0)
3018                         continue;
3019 
3020                 if (!c_source_has_debug(file, cus, nr_cus)) {
3021                         (void) snprintf(errmsg, errlen,
3022                             "file %s is missing debug info\n", file);
3023                         return (ECTF_CONVNODEBUG);
3024                 }
3025         }
3026 
3027         return (0);
3028 }
3029 
3030 int
3031 ctf_dwarf_convert(int fd, Elf *elf, uint_t nthrs, uint_t flags,
3032     ctf_file_t **fpp, char *errbuf, size_t errlen)
3033 {
3034         int err, ret, ndies, i;
3035         Dwarf_Debug dw;
3036         Dwarf_Error derr;
3037         ctf_cu_t *cdies = NULL, *cup;
3038         workq_t *wqp = NULL;
3039 
3040         *fpp = NULL;
3041 
3042         ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw, &derr);
3043         if (ret != DW_DLV_OK) {
3044                 if (ret == DW_DLV_NO_ENTRY ||
3045                     dwarf_errno(derr) == DW_DLE_DEBUG_INFO_NULL) {
3046                         (void) snprintf(errbuf, errlen,
3047                             "file does not contain DWARF data\n");
3048                         return (ECTF_CONVNODEBUG);
3049                 }
3050 
3051                 (void) snprintf(errbuf, errlen,
3052                     "dwarf_elf_init() failed: %s\n", dwarf_errmsg(derr));
3053                 return (ECTF_CONVBKERR);
3054         }
3055 
3056         /*
3057          * Iterate over all of the compilation units and create a ctf_cu_t for
3058          * each of them.  This is used to determine if we have zero, one, or
3059          * multiple dies to convert. If we have zero, that's an error. If
3060          * there's only one die, that's the simple case.  No merge needed and
3061          * only a single Dwarf_Debug as well.
3062          */
3063         ndies = 0;
3064         err = ctf_dwarf_count_dies(dw, &derr, &ndies, errbuf, errlen);
3065 
3066         ctf_dprintf("found %d DWARF CUs\n", ndies);
3067 
3068         if (ndies == 0) {
3069                 (void) snprintf(errbuf, errlen,
3070                     "file does not contain DWARF data\n");
3071                 return (ECTF_CONVNODEBUG);
3072         }
3073 
3074         (void) dwarf_finish(dw, &derr);
3075         cdies = ctf_alloc(sizeof (ctf_cu_t) * ndies);
3076         if (cdies == NULL) {
3077                 return (ENOMEM);
3078         }
3079 
3080         bzero(cdies, sizeof (ctf_cu_t) * ndies);
3081 
3082         for (i = 0; i < ndies; i++) {
3083                 cup = &cdies[i];
3084                 ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL,
3085                     &cup->cu_dwarf, &derr);
3086                 if (ret != 0) {
3087                         ctf_free(cdies, sizeof (ctf_cu_t) * ndies);
3088                         (void) snprintf(errbuf, errlen,
3089                             "failed to initialize DWARF: %s\n",
3090                             dwarf_errmsg(derr));
3091                         return (ECTF_CONVBKERR);
3092                 }
3093 
3094                 err = ctf_dwarf_init_die(fd, elf, cup, i, errbuf, errlen);
3095                 if (err != 0)
3096                         goto out;
3097 
3098                 cup->cu_doweaks = ndies > 1 ? B_FALSE : B_TRUE;
3099         }
3100 
3101         if (!(flags & CTF_ALLOW_MISSING_DEBUG) &&
3102             (err = ctf_dwarf_check_missing(cdies, ndies,
3103             elf, errbuf, errlen)) != 0)
3104                 goto out;
3105 
3106         /*
3107          * If we only have one compilation unit, there's no reason to use
3108          * multiple threads, even if the user requested them. After all, they
3109          * just gave us an upper bound.
3110          */
3111         if (ndies == 1)
3112                 nthrs = 1;
3113 
3114         if (workq_init(&wqp, nthrs) == -1) {
3115                 err = errno;
3116                 goto out;
3117         }
3118 
3119         for (i = 0; i < ndies; i++) {
3120                 cup = &cdies[i];
3121                 ctf_dprintf("adding cu %s: %p, %x %x\n", cup->cu_name,
3122                     cup->cu_cu, cup->cu_cuoff, cup->cu_maxoff);
3123                 if (workq_add(wqp, cup) == -1) {
3124                         err = errno;
3125                         goto out;
3126                 }
3127         }
3128 
3129         ret = workq_work(wqp, ctf_dwarf_convert_one, NULL, &err);
3130         if (ret == WORKQ_ERROR) {
3131                 err = errno;
3132                 goto out;
3133         } else if (ret == WORKQ_UERROR) {
3134                 ctf_dprintf("internal convert failed: %s\n",
3135                     ctf_errmsg(err));
3136                 goto out;
3137         }
3138 
3139         ctf_dprintf("Determining next phase: have %d CUs\n", ndies);
3140         if (ndies != 1) {
3141                 ctf_merge_t *cmp;
3142 
3143                 cmp = ctf_merge_init(fd, &err);
3144                 if (cmp == NULL)
3145                         goto out;
3146 
3147                 ctf_dprintf("setting threads\n");
3148                 if ((err = ctf_merge_set_nthreads(cmp, nthrs)) != 0) {
3149                         ctf_merge_fini(cmp);
3150                         goto out;
3151                 }
3152 
3153                 for (i = 0; i < ndies; i++) {
3154                         cup = &cdies[i];
3155                         if ((err = ctf_merge_add(cmp, cup->cu_ctfp)) != 0) {
3156                                 ctf_merge_fini(cmp);
3157                                 goto out;
3158                         }
3159                 }
3160 
3161                 ctf_dprintf("performing merge\n");
3162                 err = ctf_merge_merge(cmp, fpp);
3163                 if (err != 0) {
3164                         ctf_dprintf("failed merge!\n");
3165                         *fpp = NULL;
3166                         ctf_merge_fini(cmp);
3167                         goto out;
3168                 }
3169                 ctf_merge_fini(cmp);
3170                 err = 0;
3171                 ctf_dprintf("successfully converted!\n");
3172         } else {
3173                 err = 0;
3174                 *fpp = cdies->cu_ctfp;
3175                 cdies->cu_ctfp = NULL;
3176                 ctf_dprintf("successfully converted!\n");
3177         }
3178 
3179 out:
3180         workq_fini(wqp);
3181         ctf_dwarf_free_dies(cdies, ndies);
3182         return (err);
3183 }