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