1bc1f688bSRobert Mustacchi /* 2bc1f688bSRobert Mustacchi * CDDL HEADER START 3bc1f688bSRobert Mustacchi * 4bc1f688bSRobert Mustacchi * The contents of this file are subject to the terms of the 5bc1f688bSRobert Mustacchi * Common Development and Distribution License (the "License"). 6bc1f688bSRobert Mustacchi * You may not use this file except in compliance with the License. 7bc1f688bSRobert Mustacchi * 8bc1f688bSRobert Mustacchi * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9bc1f688bSRobert Mustacchi * or http://www.opensolaris.org/os/licensing. 10bc1f688bSRobert Mustacchi * See the License for the specific language governing permissions 11bc1f688bSRobert Mustacchi * and limitations under the License. 12bc1f688bSRobert Mustacchi * 13bc1f688bSRobert Mustacchi * When distributing Covered Code, include this CDDL HEADER in each 14bc1f688bSRobert Mustacchi * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15bc1f688bSRobert Mustacchi * If applicable, add the following below this CDDL HEADER, with the 16bc1f688bSRobert Mustacchi * fields enclosed by brackets "[]" replaced with your own identifying 17bc1f688bSRobert Mustacchi * information: Portions Copyright [yyyy] [name of copyright owner] 18bc1f688bSRobert Mustacchi * 19bc1f688bSRobert Mustacchi * CDDL HEADER END 20bc1f688bSRobert Mustacchi */ 21bc1f688bSRobert Mustacchi /* 22bc1f688bSRobert Mustacchi * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23bc1f688bSRobert Mustacchi * Use is subject to license terms. 24bc1f688bSRobert Mustacchi */ 25bc1f688bSRobert Mustacchi /* 26bc1f688bSRobert Mustacchi * Copyright 2012 Jason King. All rights reserved. 27bc1f688bSRobert Mustacchi * Use is subject to license terms. 28bc1f688bSRobert Mustacchi */ 29bc1f688bSRobert Mustacchi 30bc1f688bSRobert Mustacchi /* 31fe2dc8bdSJohn Levon * Copyright 2020 Joyent, Inc. 322e25d8e1SRobert Mustacchi * Copyright 2020 Robert Mustacchi 33bc1f688bSRobert Mustacchi */ 34bc1f688bSRobert Mustacchi 35bc1f688bSRobert Mustacchi /* 36bc1f688bSRobert Mustacchi * CTF DWARF conversion theory. 37bc1f688bSRobert Mustacchi * 38bc1f688bSRobert Mustacchi * DWARF data contains a series of compilation units. Each compilation unit 39bc1f688bSRobert Mustacchi * generally refers to an object file or what once was, in the case of linked 40bc1f688bSRobert Mustacchi * binaries and shared objects. Each compilation unit has a series of what DWARF 41bc1f688bSRobert Mustacchi * calls a DIE (Debugging Information Entry). The set of entries that we care 42bc1f688bSRobert Mustacchi * about have type information stored in a series of attributes. Each DIE also 43bc1f688bSRobert Mustacchi * has a tag that identifies the kind of attributes that it has. 44bc1f688bSRobert Mustacchi * 45bc1f688bSRobert Mustacchi * A given DIE may itself have children. For example, a DIE that represents a 46bc1f688bSRobert Mustacchi * structure has children which represent members. Whenever we encounter a DIE 47bc1f688bSRobert Mustacchi * that has children or other values or types associated with it, we recursively 48bc1f688bSRobert Mustacchi * process those children first so that way we can then refer to the generated 49bc1f688bSRobert Mustacchi * CTF type id while processing its parent. This reduces the amount of unknowns 50bc1f688bSRobert Mustacchi * and fixups that we need. It also ensures that we don't accidentally add types 51bc1f688bSRobert Mustacchi * that an overzealous compiler might add to the DWARF data but aren't used by 52bc1f688bSRobert Mustacchi * anything in the system. 53bc1f688bSRobert Mustacchi * 54bc1f688bSRobert Mustacchi * Once we do a conversion, we store a mapping in an AVL tree that goes from the 55bc1f688bSRobert Mustacchi * DWARF's die offset, which is relative to the given compilation unit, to a 56bc1f688bSRobert Mustacchi * ctf_id_t. 57bc1f688bSRobert Mustacchi * 58bc1f688bSRobert Mustacchi * Unfortunately, some compilers actually will emit duplicate entries for a 59bc1f688bSRobert Mustacchi * given type that look similar, but aren't quite. To that end, we go through 60bc1f688bSRobert Mustacchi * and do a variant on a merge once we're done processing a single compilation 61bc1f688bSRobert Mustacchi * unit which deduplicates all of the types that are in the unit. 62bc1f688bSRobert Mustacchi * 63bc1f688bSRobert Mustacchi * Finally, if we encounter an object that has multiple compilation units, then 64bc1f688bSRobert Mustacchi * we'll convert all of the compilation units separately and then do a merge, so 65bc1f688bSRobert Mustacchi * that way we can result in one single ctf_file_t that represents everything 66bc1f688bSRobert Mustacchi * for the object. 67bc1f688bSRobert Mustacchi * 68bc1f688bSRobert Mustacchi * Conversion Steps 69bc1f688bSRobert Mustacchi * ---------------- 70bc1f688bSRobert Mustacchi * 71bc1f688bSRobert Mustacchi * Because a given object we've been given to convert may have multiple 72bc1f688bSRobert Mustacchi * compilation units, we break the work into two halves. The first half 73bc1f688bSRobert Mustacchi * processes each compilation unit (potentially in parallel) and then the second 74bc1f688bSRobert Mustacchi * half optionally merges all of the dies in the first half. First, we'll cover 75bc1f688bSRobert Mustacchi * what's involved in converting a single ctf_cu_t's dwarf to CTF. This covers 76bc1f688bSRobert Mustacchi * the work done in ctf_dwarf_convert_one(). 77bc1f688bSRobert Mustacchi * 78bc1f688bSRobert Mustacchi * An individual ctf_cu_t, which represents a compilation unit, is converted to 79bc1f688bSRobert Mustacchi * CTF in a series of multiple passes. 80bc1f688bSRobert Mustacchi * 81bc1f688bSRobert Mustacchi * Pass 1: During the first pass we walk all of the top-level dies and if we 82bc1f688bSRobert Mustacchi * find a function, variable, struct, union, enum or typedef, we recursively 83bc1f688bSRobert Mustacchi * transform all of its types. We don't recurse or process everything, because 84bc1f688bSRobert Mustacchi * we don't want to add some of the types that compilers may add which are 85bc1f688bSRobert Mustacchi * effectively unused. 86bc1f688bSRobert Mustacchi * 87bc1f688bSRobert Mustacchi * During pass 1, if we encounter any structures or unions we mark them for 88bc1f688bSRobert Mustacchi * fixing up later. This is necessary because we may not be able to determine 89bc1f688bSRobert Mustacchi * the full size of a structure at the beginning of time. This will happen if 90bc1f688bSRobert Mustacchi * the DWARF attribute DW_AT_byte_size is not present for a member. Because of 91bc1f688bSRobert Mustacchi * this possibility we defer adding members to structures or even converting 92bc1f688bSRobert Mustacchi * them during pass 1 and save that for pass 2. Adding all of the base 93bc1f688bSRobert Mustacchi * structures without any of their members helps deal with any circular 94bc1f688bSRobert Mustacchi * dependencies that we might encounter. 95bc1f688bSRobert Mustacchi * 96bc1f688bSRobert Mustacchi * Pass 2: This pass is used to do the first half of fixing up structures and 97bc1f688bSRobert Mustacchi * unions. Rather than walk the entire type space again, we actually walk the 98bc1f688bSRobert Mustacchi * list of structures and unions that we marked for later fixing up. Here, we 99bc1f688bSRobert Mustacchi * iterate over every structure and add members to the underlying ctf_file_t, 100bc1f688bSRobert Mustacchi * but not to the structs themselves. One might wonder why we don't, and the 101bc1f688bSRobert Mustacchi * main reason is that libctf requires a ctf_update() be done before adding the 102bc1f688bSRobert Mustacchi * members to structures or unions. 103bc1f688bSRobert Mustacchi * 104bc1f688bSRobert Mustacchi * Pass 3: This pass is used to do the second half of fixing up structures and 105bc1f688bSRobert Mustacchi * unions. During this part we always go through and add members to structures 106bc1f688bSRobert Mustacchi * and unions that we added to the container in the previous pass. In addition, 107bc1f688bSRobert Mustacchi * we set the structure and union's actual size, which may have additional 108bc1f688bSRobert Mustacchi * padding added by the compiler, it isn't simply the last offset. DWARF always 109bc1f688bSRobert Mustacchi * guarantees an attribute exists for this. Importantly no ctf_id_t's change 110bc1f688bSRobert Mustacchi * during pass 2. 111bc1f688bSRobert Mustacchi * 112bc1f688bSRobert Mustacchi * Pass 4: The next phase is to add CTF entries for all of the symbols and 113bc1f688bSRobert Mustacchi * variables that are present in this die. During pass 1 we added entries to a 114bc1f688bSRobert Mustacchi * map for each variable and function. During this pass, we iterate over the 115bc1f688bSRobert Mustacchi * symbol table and when we encounter a symbol that we have in our lists of 116bc1f688bSRobert Mustacchi * translated information which matches, we then add it to the ctf_file_t. 117bc1f688bSRobert Mustacchi * 118bc1f688bSRobert Mustacchi * Pass 5: Here we go and look for any weak symbols and functions and see if 119bc1f688bSRobert Mustacchi * they match anything that we recognize. If so, then we add type information 120bc1f688bSRobert Mustacchi * for them at this point based on the matching type. 121bc1f688bSRobert Mustacchi * 122bc1f688bSRobert Mustacchi * Pass 6: This pass is actually a variant on a merge. The traditional merge 123bc1f688bSRobert Mustacchi * process expects there to be no duplicate types. As such, at the end of 124bc1f688bSRobert Mustacchi * conversion, we do a dedup on all of the types in the system. The 125bc1f688bSRobert Mustacchi * deduplication process is described in lib/libctf/common/ctf_merge.c. 126bc1f688bSRobert Mustacchi * 127bc1f688bSRobert Mustacchi * Once pass 6 is done, we've finished processing the individual compilation 128bc1f688bSRobert Mustacchi * unit. 129bc1f688bSRobert Mustacchi * 130bc1f688bSRobert Mustacchi * The following steps reflect the general process of doing a conversion. 131bc1f688bSRobert Mustacchi * 132bc1f688bSRobert Mustacchi * 1) Walk the dwarf section and determine the number of compilation units 133bc1f688bSRobert Mustacchi * 2) Create a ctf_cu_t for each compilation unit 134bc1f688bSRobert Mustacchi * 3) Add all ctf_cu_t's to a workq 135bc1f688bSRobert Mustacchi * 4) Have the workq process each die with ctf_dwarf_convert_one. This itself 136bc1f688bSRobert Mustacchi * is comprised of several steps, which were already enumerated. 137bc1f688bSRobert Mustacchi * 5) If we have multiple cu's, we do a ctf merge of all the dies. The mechanics 138bc1f688bSRobert Mustacchi * of the merge are discussed in lib/libctf/common/ctf_merge.c. 139bc1f688bSRobert Mustacchi * 6) Free everything up and return a ctf_file_t to the user. If we only had a 140bc1f688bSRobert Mustacchi * single compilation unit, then we give that to the user. Otherwise, we 141bc1f688bSRobert Mustacchi * return the merged ctf_file_t. 142bc1f688bSRobert Mustacchi * 143bc1f688bSRobert Mustacchi * Threading 144bc1f688bSRobert Mustacchi * --------- 145bc1f688bSRobert Mustacchi * 146bc1f688bSRobert Mustacchi * The process has been designed to be amenable to threading. Each compilation 147bc1f688bSRobert Mustacchi * unit has its own type stream, therefore the logical place to divide and 148bc1f688bSRobert Mustacchi * conquer is at the compilation unit. Each ctf_cu_t has been built to be able 149bc1f688bSRobert Mustacchi * to be processed independently of the others. It has its own libdwarf handle, 150bc1f688bSRobert Mustacchi * as a given libdwarf handle may only be used by a single thread at a time. 151bc1f688bSRobert Mustacchi * This allows the various ctf_cu_t's to be processed in parallel by different 152bc1f688bSRobert Mustacchi * threads. 153bc1f688bSRobert Mustacchi * 154bc1f688bSRobert Mustacchi * All of the ctf_cu_t's are loaded into a workq which allows for a number of 155bc1f688bSRobert Mustacchi * threads to be specified and used as a thread pool to process all of the 156bc1f688bSRobert Mustacchi * queued work. We set the number of threads to use in the workq equal to the 157bc1f688bSRobert Mustacchi * number of threads that the user has specified. 158bc1f688bSRobert Mustacchi * 159bc1f688bSRobert Mustacchi * After all of the compilation units have been drained, we use the same number 160bc1f688bSRobert Mustacchi * of threads when performing a merge of multiple compilation units, if they 161bc1f688bSRobert Mustacchi * exist. 162bc1f688bSRobert Mustacchi * 163bc1f688bSRobert Mustacchi * While all of these different parts do support and allow for multiple threads, 164bc1f688bSRobert Mustacchi * it's important that when only a single thread is specified, that it be the 165bc1f688bSRobert Mustacchi * calling thread. This allows the conversion routines to be used in a context 166bc1f688bSRobert Mustacchi * that doesn't allow additional threads, such as rtld. 167bc1f688bSRobert Mustacchi * 168bc1f688bSRobert Mustacchi * Common DWARF Mechanics and Notes 169bc1f688bSRobert Mustacchi * -------------------------------- 170bc1f688bSRobert Mustacchi * 171bc1f688bSRobert Mustacchi * At this time, we really only support DWARFv2, though support for DWARFv4 is 172bc1f688bSRobert Mustacchi * mostly there. There is no intent to support DWARFv3. 173bc1f688bSRobert Mustacchi * 174bc1f688bSRobert Mustacchi * Generally types for something are stored in the DW_AT_type attribute. For 175bc1f688bSRobert Mustacchi * example, a function's return type will be stored in the local DW_AT_type 176bc1f688bSRobert Mustacchi * attribute while the arguments will be in child DIEs. There are also various 177bc1f688bSRobert Mustacchi * times when we don't have any DW_AT_type. In that case, the lack of a type 178bc1f688bSRobert Mustacchi * implies, at least for C, that its C type is void. Because DWARF doesn't emit 179bc1f688bSRobert Mustacchi * one, we have a synthetic void type that we create and manipulate instead and 180bc1f688bSRobert Mustacchi * pass it off to consumers on an as-needed basis. If nothing has a void type, 181bc1f688bSRobert Mustacchi * it will not be emitted. 182bc1f688bSRobert Mustacchi * 183bc1f688bSRobert Mustacchi * Architecture Specific Parts 184bc1f688bSRobert Mustacchi * --------------------------- 185bc1f688bSRobert Mustacchi * 186bc1f688bSRobert Mustacchi * The CTF tooling encodes various information about the various architectures 187bc1f688bSRobert Mustacchi * in the system. Importantly, the tool assumes that every architecture has a 188bc1f688bSRobert Mustacchi * data model where long and pointer are the same size. This is currently the 189bc1f688bSRobert Mustacchi * case, as the two data models illumos supports are ILP32 and LP64. 190bc1f688bSRobert Mustacchi * 191bc1f688bSRobert Mustacchi * In addition, we encode the mapping of various floating point sizes to various 192bc1f688bSRobert Mustacchi * types for each architecture. If a new architecture is being added, it should 193bc1f688bSRobert Mustacchi * be added to the list. The general design of the ctf conversion tools is to be 194bc1f688bSRobert Mustacchi * architecture independent. eg. any of the tools here should be able to convert 195bc1f688bSRobert Mustacchi * any architecture's DWARF into ctf; however, this has not been rigorously 196bc1f688bSRobert Mustacchi * tested and more importantly, the ctf routines don't currently write out the 197bc1f688bSRobert Mustacchi * data in an endian-aware form, they only use that of the currently running 198bc1f688bSRobert Mustacchi * library. 199bc1f688bSRobert Mustacchi */ 200bc1f688bSRobert Mustacchi 201bc1f688bSRobert Mustacchi #include <libctf_impl.h> 202bc1f688bSRobert Mustacchi #include <sys/avl.h> 203bc1f688bSRobert Mustacchi #include <sys/debug.h> 204bc1f688bSRobert Mustacchi #include <gelf.h> 205bc1f688bSRobert Mustacchi #include <libdwarf.h> 206bc1f688bSRobert Mustacchi #include <dwarf.h> 207bc1f688bSRobert Mustacchi #include <libgen.h> 208bc1f688bSRobert Mustacchi #include <workq.h> 209bc1f688bSRobert Mustacchi #include <errno.h> 210bc1f688bSRobert Mustacchi 211bc1f688bSRobert Mustacchi #define DWARF_VERSION_TWO 2 212*40f72ea9SRobert Mustacchi #define DWARF_VERSION_FOUR 4 213bc1f688bSRobert Mustacchi #define DWARF_VARARGS_NAME "..." 214bc1f688bSRobert Mustacchi 215bc1f688bSRobert Mustacchi /* 216bc1f688bSRobert Mustacchi * Dwarf may refer recursively to other types that we've already processed. To 217bc1f688bSRobert Mustacchi * see if we've already converted them, we look them up in an AVL tree that's 218bc1f688bSRobert Mustacchi * sorted by the DWARF id. 219bc1f688bSRobert Mustacchi */ 220bc1f688bSRobert Mustacchi typedef struct ctf_dwmap { 221bc1f688bSRobert Mustacchi avl_node_t cdm_avl; 222bc1f688bSRobert Mustacchi Dwarf_Off cdm_off; 223bc1f688bSRobert Mustacchi Dwarf_Die cdm_die; 224bc1f688bSRobert Mustacchi ctf_id_t cdm_id; 225bc1f688bSRobert Mustacchi boolean_t cdm_fix; 226bc1f688bSRobert Mustacchi } ctf_dwmap_t; 227bc1f688bSRobert Mustacchi 228bc1f688bSRobert Mustacchi typedef struct ctf_dwvar { 229bc1f688bSRobert Mustacchi ctf_list_t cdv_list; 230bc1f688bSRobert Mustacchi char *cdv_name; 231bc1f688bSRobert Mustacchi ctf_id_t cdv_type; 232bc1f688bSRobert Mustacchi boolean_t cdv_global; 233bc1f688bSRobert Mustacchi } ctf_dwvar_t; 234bc1f688bSRobert Mustacchi 235bc1f688bSRobert Mustacchi typedef struct ctf_dwfunc { 236bc1f688bSRobert Mustacchi ctf_list_t cdf_list; 237bc1f688bSRobert Mustacchi char *cdf_name; 238bc1f688bSRobert Mustacchi ctf_funcinfo_t cdf_fip; 239bc1f688bSRobert Mustacchi ctf_id_t *cdf_argv; 240bc1f688bSRobert Mustacchi boolean_t cdf_global; 241bc1f688bSRobert Mustacchi } ctf_dwfunc_t; 242bc1f688bSRobert Mustacchi 243bc1f688bSRobert Mustacchi typedef struct ctf_dwbitf { 244bc1f688bSRobert Mustacchi ctf_list_t cdb_list; 245bc1f688bSRobert Mustacchi ctf_id_t cdb_base; 246bc1f688bSRobert Mustacchi uint_t cdb_nbits; 247bc1f688bSRobert Mustacchi ctf_id_t cdb_id; 248bc1f688bSRobert Mustacchi } ctf_dwbitf_t; 249bc1f688bSRobert Mustacchi 250bc1f688bSRobert Mustacchi /* 251bc1f688bSRobert Mustacchi * The ctf_cu_t represents a single top-level DWARF die unit. While generally, 252bc1f688bSRobert Mustacchi * the typical object file has only a single die, if we're asked to convert 253bc1f688bSRobert Mustacchi * something that's been linked from multiple sources, multiple dies will exist. 254bc1f688bSRobert Mustacchi */ 255bc1f688bSRobert Mustacchi typedef struct ctf_die { 256bc1f688bSRobert Mustacchi Elf *cu_elf; /* shared libelf handle */ 257bc1f688bSRobert Mustacchi char *cu_name; /* basename of the DIE */ 258bc1f688bSRobert Mustacchi ctf_merge_t *cu_cmh; /* merge handle */ 259bc1f688bSRobert Mustacchi ctf_list_t cu_vars; /* List of variables */ 260bc1f688bSRobert Mustacchi ctf_list_t cu_funcs; /* List of functions */ 261bc1f688bSRobert Mustacchi ctf_list_t cu_bitfields; /* Bit field members */ 262bc1f688bSRobert Mustacchi Dwarf_Debug cu_dwarf; /* libdwarf handle */ 263bc1f688bSRobert Mustacchi Dwarf_Die cu_cu; /* libdwarf compilation unit */ 264bc1f688bSRobert Mustacchi Dwarf_Off cu_cuoff; /* cu's offset */ 265bc1f688bSRobert Mustacchi Dwarf_Off cu_maxoff; /* maximum offset */ 266*40f72ea9SRobert Mustacchi Dwarf_Half cu_vers; /* Dwarf Version */ 267*40f72ea9SRobert Mustacchi Dwarf_Half cu_addrsz; /* Dwarf Address Size */ 268bc1f688bSRobert Mustacchi ctf_file_t *cu_ctfp; /* output CTF file */ 269bc1f688bSRobert Mustacchi avl_tree_t cu_map; /* map die offsets to CTF types */ 270bc1f688bSRobert Mustacchi char *cu_errbuf; /* error message buffer */ 271bc1f688bSRobert Mustacchi size_t cu_errlen; /* error message buffer length */ 272bc1f688bSRobert Mustacchi size_t cu_ptrsz; /* object's pointer size */ 273bc1f688bSRobert Mustacchi boolean_t cu_bigend; /* is it big endian */ 274bc1f688bSRobert Mustacchi boolean_t cu_doweaks; /* should we convert weak symbols? */ 275bc1f688bSRobert Mustacchi uint_t cu_mach; /* machine type */ 276bc1f688bSRobert Mustacchi ctf_id_t cu_voidtid; /* void pointer */ 277bc1f688bSRobert Mustacchi ctf_id_t cu_longtid; /* id for a 'long' */ 278bc1f688bSRobert Mustacchi } ctf_cu_t; 279bc1f688bSRobert Mustacchi 280bc1f688bSRobert Mustacchi static int ctf_dwarf_offset(ctf_cu_t *, Dwarf_Die, Dwarf_Off *); 281bc1f688bSRobert Mustacchi static int ctf_dwarf_convert_die(ctf_cu_t *, Dwarf_Die); 282bc1f688bSRobert Mustacchi static int ctf_dwarf_convert_type(ctf_cu_t *, Dwarf_Die, ctf_id_t *, int); 283bc1f688bSRobert Mustacchi 284bc1f688bSRobert Mustacchi static int ctf_dwarf_function_count(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *, 285bc1f688bSRobert Mustacchi boolean_t); 286bc1f688bSRobert Mustacchi static int ctf_dwarf_convert_fargs(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *, 287bc1f688bSRobert Mustacchi ctf_id_t *); 288bc1f688bSRobert Mustacchi 289bc1f688bSRobert Mustacchi /* 290bc1f688bSRobert Mustacchi * This is a generic way to set a CTF Conversion backend error depending on what 291bc1f688bSRobert Mustacchi * we were doing. Unless it was one of a specific set of errors that don't 292bc1f688bSRobert Mustacchi * indicate a programming / translation bug, eg. ENOMEM, then we transform it 293bc1f688bSRobert Mustacchi * into a CTF backend error and fill in the error buffer. 294bc1f688bSRobert Mustacchi */ 295bc1f688bSRobert Mustacchi static int 296bc1f688bSRobert Mustacchi ctf_dwarf_error(ctf_cu_t *cup, ctf_file_t *cfp, int err, const char *fmt, ...) 297bc1f688bSRobert Mustacchi { 298bc1f688bSRobert Mustacchi va_list ap; 299bc1f688bSRobert Mustacchi int ret; 300bc1f688bSRobert Mustacchi size_t off = 0; 301bc1f688bSRobert Mustacchi ssize_t rem = cup->cu_errlen; 302bc1f688bSRobert Mustacchi if (cfp != NULL) 303bc1f688bSRobert Mustacchi err = ctf_errno(cfp); 304bc1f688bSRobert Mustacchi 305bc1f688bSRobert Mustacchi if (err == ENOMEM) 306bc1f688bSRobert Mustacchi return (err); 307bc1f688bSRobert Mustacchi 308bc1f688bSRobert Mustacchi ret = snprintf(cup->cu_errbuf, rem, "die %s: ", cup->cu_name); 309bc1f688bSRobert Mustacchi if (ret < 0) 310bc1f688bSRobert Mustacchi goto err; 311bc1f688bSRobert Mustacchi off += ret; 312bc1f688bSRobert Mustacchi rem = MAX(rem - ret, 0); 313bc1f688bSRobert Mustacchi 314bc1f688bSRobert Mustacchi va_start(ap, fmt); 315bc1f688bSRobert Mustacchi ret = vsnprintf(cup->cu_errbuf + off, rem, fmt, ap); 316bc1f688bSRobert Mustacchi va_end(ap); 317bc1f688bSRobert Mustacchi if (ret < 0) 318bc1f688bSRobert Mustacchi goto err; 319bc1f688bSRobert Mustacchi 320bc1f688bSRobert Mustacchi off += ret; 321bc1f688bSRobert Mustacchi rem = MAX(rem - ret, 0); 322bc1f688bSRobert Mustacchi if (fmt[strlen(fmt) - 1] != '\n') { 323bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf + off, rem, 324bc1f688bSRobert Mustacchi ": %s\n", ctf_errmsg(err)); 325bc1f688bSRobert Mustacchi } 326bc1f688bSRobert Mustacchi va_end(ap); 327bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 328bc1f688bSRobert Mustacchi 329bc1f688bSRobert Mustacchi err: 330bc1f688bSRobert Mustacchi cup->cu_errbuf[0] = '\0'; 331bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 332bc1f688bSRobert Mustacchi } 333bc1f688bSRobert Mustacchi 334bc1f688bSRobert Mustacchi /* 335bc1f688bSRobert Mustacchi * DWARF often opts to put no explicit type to describe a void type. eg. if we 336bc1f688bSRobert Mustacchi * have a reference type whose DW_AT_type member doesn't exist, then we should 337bc1f688bSRobert Mustacchi * instead assume it points to void. Because this isn't represented, we 338bc1f688bSRobert Mustacchi * instead cause it to come into existence. 339bc1f688bSRobert Mustacchi */ 340bc1f688bSRobert Mustacchi static ctf_id_t 341bc1f688bSRobert Mustacchi ctf_dwarf_void(ctf_cu_t *cup) 342bc1f688bSRobert Mustacchi { 343bc1f688bSRobert Mustacchi if (cup->cu_voidtid == CTF_ERR) { 344bc1f688bSRobert Mustacchi ctf_encoding_t enc = { CTF_INT_SIGNED, 0, 0 }; 345bc1f688bSRobert Mustacchi cup->cu_voidtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_ROOT, 346bc1f688bSRobert Mustacchi "void", &enc); 347bc1f688bSRobert Mustacchi if (cup->cu_voidtid == CTF_ERR) { 348bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 349bc1f688bSRobert Mustacchi "failed to create void type: %s\n", 350bc1f688bSRobert Mustacchi ctf_errmsg(ctf_errno(cup->cu_ctfp))); 351bc1f688bSRobert Mustacchi } 352bc1f688bSRobert Mustacchi } 353bc1f688bSRobert Mustacchi 354bc1f688bSRobert Mustacchi return (cup->cu_voidtid); 355bc1f688bSRobert Mustacchi } 356bc1f688bSRobert Mustacchi 357bc1f688bSRobert Mustacchi /* 358bc1f688bSRobert Mustacchi * There are many different forms that an array index may take. However, we just 359bc1f688bSRobert Mustacchi * always force it to be of a type long no matter what. Therefore we use this to 360bc1f688bSRobert Mustacchi * have a single instance of long across everything. 361bc1f688bSRobert Mustacchi */ 362bc1f688bSRobert Mustacchi static ctf_id_t 363bc1f688bSRobert Mustacchi ctf_dwarf_long(ctf_cu_t *cup) 364bc1f688bSRobert Mustacchi { 365bc1f688bSRobert Mustacchi if (cup->cu_longtid == CTF_ERR) { 366bc1f688bSRobert Mustacchi ctf_encoding_t enc; 367bc1f688bSRobert Mustacchi 368bc1f688bSRobert Mustacchi enc.cte_format = CTF_INT_SIGNED; 369bc1f688bSRobert Mustacchi enc.cte_offset = 0; 370bc1f688bSRobert Mustacchi /* All illumos systems are LP */ 371bc1f688bSRobert Mustacchi enc.cte_bits = cup->cu_ptrsz * 8; 372bc1f688bSRobert Mustacchi cup->cu_longtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT, 373bc1f688bSRobert Mustacchi "long", &enc); 374bc1f688bSRobert Mustacchi if (cup->cu_longtid == CTF_ERR) { 375bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 376bc1f688bSRobert Mustacchi "failed to create long type: %s\n", 377bc1f688bSRobert Mustacchi ctf_errmsg(ctf_errno(cup->cu_ctfp))); 378bc1f688bSRobert Mustacchi } 379bc1f688bSRobert Mustacchi 380bc1f688bSRobert Mustacchi } 381bc1f688bSRobert Mustacchi 382bc1f688bSRobert Mustacchi return (cup->cu_longtid); 383bc1f688bSRobert Mustacchi } 384bc1f688bSRobert Mustacchi 385bc1f688bSRobert Mustacchi static int 386bc1f688bSRobert Mustacchi ctf_dwmap_comp(const void *a, const void *b) 387bc1f688bSRobert Mustacchi { 388bc1f688bSRobert Mustacchi const ctf_dwmap_t *ca = a; 389bc1f688bSRobert Mustacchi const ctf_dwmap_t *cb = b; 390bc1f688bSRobert Mustacchi 391bc1f688bSRobert Mustacchi if (ca->cdm_off > cb->cdm_off) 392bc1f688bSRobert Mustacchi return (1); 393bc1f688bSRobert Mustacchi if (ca->cdm_off < cb->cdm_off) 394bc1f688bSRobert Mustacchi return (-1); 395bc1f688bSRobert Mustacchi return (0); 396bc1f688bSRobert Mustacchi } 397bc1f688bSRobert Mustacchi 398bc1f688bSRobert Mustacchi static int 399bc1f688bSRobert Mustacchi ctf_dwmap_add(ctf_cu_t *cup, ctf_id_t id, Dwarf_Die die, boolean_t fix) 400bc1f688bSRobert Mustacchi { 401bc1f688bSRobert Mustacchi int ret; 402bc1f688bSRobert Mustacchi avl_index_t index; 403bc1f688bSRobert Mustacchi ctf_dwmap_t *dwmap; 404bc1f688bSRobert Mustacchi Dwarf_Off off; 405bc1f688bSRobert Mustacchi 406bc1f688bSRobert Mustacchi VERIFY(id > 0 && id < CTF_MAX_TYPE); 407bc1f688bSRobert Mustacchi 408bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, die, &off)) != 0) 409bc1f688bSRobert Mustacchi return (ret); 410bc1f688bSRobert Mustacchi 411bc1f688bSRobert Mustacchi if ((dwmap = ctf_alloc(sizeof (ctf_dwmap_t))) == NULL) 412bc1f688bSRobert Mustacchi return (ENOMEM); 413bc1f688bSRobert Mustacchi 414bc1f688bSRobert Mustacchi dwmap->cdm_die = die; 415bc1f688bSRobert Mustacchi dwmap->cdm_off = off; 416bc1f688bSRobert Mustacchi dwmap->cdm_id = id; 417bc1f688bSRobert Mustacchi dwmap->cdm_fix = fix; 418bc1f688bSRobert Mustacchi 419bc1f688bSRobert Mustacchi ctf_dprintf("dwmap: %p %" DW_PR_DUx "->%d\n", dwmap, off, id); 420bc1f688bSRobert Mustacchi VERIFY(avl_find(&cup->cu_map, dwmap, &index) == NULL); 421bc1f688bSRobert Mustacchi avl_insert(&cup->cu_map, dwmap, index); 422bc1f688bSRobert Mustacchi return (0); 423bc1f688bSRobert Mustacchi } 424bc1f688bSRobert Mustacchi 425bc1f688bSRobert Mustacchi static int 426bc1f688bSRobert Mustacchi ctf_dwarf_attribute(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 427bc1f688bSRobert Mustacchi Dwarf_Attribute *attrp) 428bc1f688bSRobert Mustacchi { 429bc1f688bSRobert Mustacchi int ret; 430bc1f688bSRobert Mustacchi Dwarf_Error derr; 431bc1f688bSRobert Mustacchi 432bc1f688bSRobert Mustacchi if ((ret = dwarf_attr(die, name, attrp, &derr)) == DW_DLV_OK) 433bc1f688bSRobert Mustacchi return (0); 434bc1f688bSRobert Mustacchi if (ret == DW_DLV_NO_ENTRY) { 435bc1f688bSRobert Mustacchi *attrp = NULL; 436bc1f688bSRobert Mustacchi return (ENOENT); 437bc1f688bSRobert Mustacchi } 438bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 439bc1f688bSRobert Mustacchi "failed to get attribute for type: %s\n", 440bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 441bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 442bc1f688bSRobert Mustacchi } 443bc1f688bSRobert Mustacchi 444bc1f688bSRobert Mustacchi static int 445bc1f688bSRobert Mustacchi ctf_dwarf_ref(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, Dwarf_Off *refp) 446bc1f688bSRobert Mustacchi { 447bc1f688bSRobert Mustacchi int ret; 448bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 449bc1f688bSRobert Mustacchi Dwarf_Error derr; 450bc1f688bSRobert Mustacchi 451bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 452bc1f688bSRobert Mustacchi return (ret); 453bc1f688bSRobert Mustacchi 454bc1f688bSRobert Mustacchi if (dwarf_formref(attr, refp, &derr) == DW_DLV_OK) { 455bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 456bc1f688bSRobert Mustacchi return (0); 457bc1f688bSRobert Mustacchi } 458bc1f688bSRobert Mustacchi 459bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 460bc1f688bSRobert Mustacchi "failed to get unsigned attribute for type: %s\n", 461bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 462bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 463bc1f688bSRobert Mustacchi } 464bc1f688bSRobert Mustacchi 465bc1f688bSRobert Mustacchi static int 466bc1f688bSRobert Mustacchi ctf_dwarf_refdie(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 467bc1f688bSRobert Mustacchi Dwarf_Die *diep) 468bc1f688bSRobert Mustacchi { 469bc1f688bSRobert Mustacchi int ret; 470bc1f688bSRobert Mustacchi Dwarf_Off off; 471bc1f688bSRobert Mustacchi Dwarf_Error derr; 472bc1f688bSRobert Mustacchi 473bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_ref(cup, die, name, &off)) != 0) 474bc1f688bSRobert Mustacchi return (ret); 475bc1f688bSRobert Mustacchi 476bc1f688bSRobert Mustacchi off += cup->cu_cuoff; 477bc1f688bSRobert Mustacchi if ((ret = dwarf_offdie(cup->cu_dwarf, off, diep, &derr)) != 478bc1f688bSRobert Mustacchi DW_DLV_OK) { 479bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 480bc1f688bSRobert Mustacchi "failed to get die from offset %" DW_PR_DUu ": %s\n", 481bc1f688bSRobert Mustacchi off, dwarf_errmsg(derr)); 482bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 483bc1f688bSRobert Mustacchi } 484bc1f688bSRobert Mustacchi 485bc1f688bSRobert Mustacchi return (0); 486bc1f688bSRobert Mustacchi } 487bc1f688bSRobert Mustacchi 488bc1f688bSRobert Mustacchi static int 489bc1f688bSRobert Mustacchi ctf_dwarf_signed(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 490bc1f688bSRobert Mustacchi Dwarf_Signed *valp) 491bc1f688bSRobert Mustacchi { 492bc1f688bSRobert Mustacchi int ret; 493bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 494bc1f688bSRobert Mustacchi Dwarf_Error derr; 495bc1f688bSRobert Mustacchi 496bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 497bc1f688bSRobert Mustacchi return (ret); 498bc1f688bSRobert Mustacchi 499bc1f688bSRobert Mustacchi if (dwarf_formsdata(attr, valp, &derr) == DW_DLV_OK) { 500bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 501bc1f688bSRobert Mustacchi return (0); 502bc1f688bSRobert Mustacchi } 503bc1f688bSRobert Mustacchi 504bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 505bc1f688bSRobert Mustacchi "failed to get unsigned attribute for type: %s\n", 506bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 507bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 508bc1f688bSRobert Mustacchi } 509bc1f688bSRobert Mustacchi 510bc1f688bSRobert Mustacchi static int 511bc1f688bSRobert Mustacchi ctf_dwarf_unsigned(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 512bc1f688bSRobert Mustacchi Dwarf_Unsigned *valp) 513bc1f688bSRobert Mustacchi { 514bc1f688bSRobert Mustacchi int ret; 515bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 516bc1f688bSRobert Mustacchi Dwarf_Error derr; 517bc1f688bSRobert Mustacchi 518bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 519bc1f688bSRobert Mustacchi return (ret); 520bc1f688bSRobert Mustacchi 521bc1f688bSRobert Mustacchi if (dwarf_formudata(attr, valp, &derr) == DW_DLV_OK) { 522bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 523bc1f688bSRobert Mustacchi return (0); 524bc1f688bSRobert Mustacchi } 525bc1f688bSRobert Mustacchi 526bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 527bc1f688bSRobert Mustacchi "failed to get unsigned attribute for type: %s\n", 528bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 529bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 530bc1f688bSRobert Mustacchi } 531bc1f688bSRobert Mustacchi 532bc1f688bSRobert Mustacchi static int 533bc1f688bSRobert Mustacchi ctf_dwarf_boolean(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 534bc1f688bSRobert Mustacchi Dwarf_Bool *val) 535bc1f688bSRobert Mustacchi { 536bc1f688bSRobert Mustacchi int ret; 537bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 538bc1f688bSRobert Mustacchi Dwarf_Error derr; 539bc1f688bSRobert Mustacchi 540bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 541bc1f688bSRobert Mustacchi return (ret); 542bc1f688bSRobert Mustacchi 543bc1f688bSRobert Mustacchi if (dwarf_formflag(attr, val, &derr) == DW_DLV_OK) { 544bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 545bc1f688bSRobert Mustacchi return (0); 546bc1f688bSRobert Mustacchi } 547bc1f688bSRobert Mustacchi 548bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 549bc1f688bSRobert Mustacchi "failed to get boolean attribute for type: %s\n", 550bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 551bc1f688bSRobert Mustacchi 552bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 553bc1f688bSRobert Mustacchi } 554bc1f688bSRobert Mustacchi 555bc1f688bSRobert Mustacchi static int 556bc1f688bSRobert Mustacchi ctf_dwarf_string(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, char **strp) 557bc1f688bSRobert Mustacchi { 558bc1f688bSRobert Mustacchi int ret; 559bc1f688bSRobert Mustacchi char *s; 560bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 561bc1f688bSRobert Mustacchi Dwarf_Error derr; 562bc1f688bSRobert Mustacchi 563bc1f688bSRobert Mustacchi *strp = NULL; 564bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 565bc1f688bSRobert Mustacchi return (ret); 566bc1f688bSRobert Mustacchi 567bc1f688bSRobert Mustacchi if (dwarf_formstring(attr, &s, &derr) == DW_DLV_OK) { 568bc1f688bSRobert Mustacchi if ((*strp = ctf_strdup(s)) == NULL) 569bc1f688bSRobert Mustacchi ret = ENOMEM; 570bc1f688bSRobert Mustacchi else 571bc1f688bSRobert Mustacchi ret = 0; 572bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 573bc1f688bSRobert Mustacchi return (ret); 574bc1f688bSRobert Mustacchi } 575bc1f688bSRobert Mustacchi 576bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 577bc1f688bSRobert Mustacchi "failed to get string attribute for type: %s\n", 578bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 579bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 580bc1f688bSRobert Mustacchi } 581bc1f688bSRobert Mustacchi 582*40f72ea9SRobert Mustacchi /* 583*40f72ea9SRobert Mustacchi * The encoding of a DW_AT_data_member_location has changed between different 584*40f72ea9SRobert Mustacchi * revisions of the specification. It may be a general udata form or it may be 585*40f72ea9SRobert Mustacchi * location data information. In DWARF 2, it is only the latter. In later 586*40f72ea9SRobert Mustacchi * revisions of the spec, it may be either. To determine the form, we ask the 587*40f72ea9SRobert Mustacchi * class, which will be of type CONSTANT. 588*40f72ea9SRobert Mustacchi */ 589bc1f688bSRobert Mustacchi static int 590bc1f688bSRobert Mustacchi ctf_dwarf_member_location(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Unsigned *valp) 591bc1f688bSRobert Mustacchi { 592bc1f688bSRobert Mustacchi int ret; 593bc1f688bSRobert Mustacchi Dwarf_Error derr; 594bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 595bc1f688bSRobert Mustacchi Dwarf_Locdesc *loc; 596bc1f688bSRobert Mustacchi Dwarf_Signed locnum; 597*40f72ea9SRobert Mustacchi Dwarf_Half form; 598*40f72ea9SRobert Mustacchi enum Dwarf_Form_Class class; 599bc1f688bSRobert Mustacchi 600bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, DW_AT_data_member_location, 601bc1f688bSRobert Mustacchi &attr)) != 0) 602bc1f688bSRobert Mustacchi return (ret); 603bc1f688bSRobert Mustacchi 604*40f72ea9SRobert Mustacchi if (dwarf_whatform(attr, &form, &derr) != DW_DLV_OK) { 605*40f72ea9SRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 606*40f72ea9SRobert Mustacchi "failed to get dwarf attribute for for member location: %s", 607*40f72ea9SRobert Mustacchi dwarf_errmsg(derr)); 608*40f72ea9SRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 609*40f72ea9SRobert Mustacchi return (ECTF_CONVBKERR); 610*40f72ea9SRobert Mustacchi } 611*40f72ea9SRobert Mustacchi 612*40f72ea9SRobert Mustacchi class = dwarf_get_form_class(cup->cu_vers, DW_AT_data_member_location, 613*40f72ea9SRobert Mustacchi cup->cu_addrsz, form); 614*40f72ea9SRobert Mustacchi if (class == DW_FORM_CLASS_CONSTANT) { 615*40f72ea9SRobert Mustacchi Dwarf_Signed sign; 616*40f72ea9SRobert Mustacchi 617*40f72ea9SRobert Mustacchi /* 618*40f72ea9SRobert Mustacchi * We have a constant. We need to try to get both this as signed 619*40f72ea9SRobert Mustacchi * and unsigned data, as unfortunately, DWARF doesn't define the 620*40f72ea9SRobert Mustacchi * sign. Which is a joy. We try unsigned first. If neither 621*40f72ea9SRobert Mustacchi * match, fall through to the normal path. 622*40f72ea9SRobert Mustacchi */ 623*40f72ea9SRobert Mustacchi if (dwarf_formudata(attr, valp, &derr) == DW_DLV_OK) { 624*40f72ea9SRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 625*40f72ea9SRobert Mustacchi return (0); 626*40f72ea9SRobert Mustacchi } 627*40f72ea9SRobert Mustacchi 628*40f72ea9SRobert Mustacchi if (dwarf_formsdata(attr, &sign, &derr) == DW_DLV_OK) { 629*40f72ea9SRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 630*40f72ea9SRobert Mustacchi if (sign < 0) { 631*40f72ea9SRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 632*40f72ea9SRobert Mustacchi "encountered negative member data " 633*40f72ea9SRobert Mustacchi "location: %d", sign); 634*40f72ea9SRobert Mustacchi } 635*40f72ea9SRobert Mustacchi *valp = (Dwarf_Unsigned)sign; 636*40f72ea9SRobert Mustacchi return (0); 637*40f72ea9SRobert Mustacchi } 638*40f72ea9SRobert Mustacchi } 639*40f72ea9SRobert Mustacchi 640bc1f688bSRobert Mustacchi if (dwarf_loclist(attr, &loc, &locnum, &derr) != DW_DLV_OK) { 641bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 642bc1f688bSRobert Mustacchi "failed to obtain location list for member offset: %s", 643bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 644bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 645bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 646bc1f688bSRobert Mustacchi } 647bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 648bc1f688bSRobert Mustacchi 649bc1f688bSRobert Mustacchi if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) { 650bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 651bc1f688bSRobert Mustacchi "failed to parse location structure for member"); 652bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK); 653bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC); 654bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 655bc1f688bSRobert Mustacchi } 656bc1f688bSRobert Mustacchi 657bc1f688bSRobert Mustacchi *valp = loc->ld_s->lr_number; 658bc1f688bSRobert Mustacchi 659bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK); 660bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC); 661bc1f688bSRobert Mustacchi return (0); 662bc1f688bSRobert Mustacchi } 663bc1f688bSRobert Mustacchi 664bc1f688bSRobert Mustacchi 665bc1f688bSRobert Mustacchi static int 666bc1f688bSRobert Mustacchi ctf_dwarf_offset(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Off *offsetp) 667bc1f688bSRobert Mustacchi { 668bc1f688bSRobert Mustacchi Dwarf_Error derr; 669bc1f688bSRobert Mustacchi 670bc1f688bSRobert Mustacchi if (dwarf_dieoffset(die, offsetp, &derr) == DW_DLV_OK) 671bc1f688bSRobert Mustacchi return (0); 672bc1f688bSRobert Mustacchi 673bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 674bc1f688bSRobert Mustacchi "failed to get die offset: %s\n", 675bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 676bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 677bc1f688bSRobert Mustacchi } 678bc1f688bSRobert Mustacchi 679bc1f688bSRobert Mustacchi /* simpler variant for debugging output */ 680bc1f688bSRobert Mustacchi static Dwarf_Off 681bc1f688bSRobert Mustacchi ctf_die_offset(Dwarf_Die die) 682bc1f688bSRobert Mustacchi { 683bc1f688bSRobert Mustacchi Dwarf_Off off = -1; 684bc1f688bSRobert Mustacchi Dwarf_Error derr; 685bc1f688bSRobert Mustacchi 686bc1f688bSRobert Mustacchi (void) dwarf_dieoffset(die, &off, &derr); 687bc1f688bSRobert Mustacchi return (off); 688bc1f688bSRobert Mustacchi } 689bc1f688bSRobert Mustacchi 690bc1f688bSRobert Mustacchi static int 691bc1f688bSRobert Mustacchi ctf_dwarf_tag(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half *tagp) 692bc1f688bSRobert Mustacchi { 693bc1f688bSRobert Mustacchi Dwarf_Error derr; 694bc1f688bSRobert Mustacchi 695bc1f688bSRobert Mustacchi if (dwarf_tag(die, tagp, &derr) == DW_DLV_OK) 696bc1f688bSRobert Mustacchi return (0); 697bc1f688bSRobert Mustacchi 698bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 699bc1f688bSRobert Mustacchi "failed to get tag type: %s\n", 700bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 701bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 702bc1f688bSRobert Mustacchi } 703bc1f688bSRobert Mustacchi 704bc1f688bSRobert Mustacchi static int 705bc1f688bSRobert Mustacchi ctf_dwarf_sib(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *sibp) 706bc1f688bSRobert Mustacchi { 707bc1f688bSRobert Mustacchi Dwarf_Error derr; 708bc1f688bSRobert Mustacchi int ret; 709bc1f688bSRobert Mustacchi 710bc1f688bSRobert Mustacchi *sibp = NULL; 711bc1f688bSRobert Mustacchi ret = dwarf_siblingof(cup->cu_dwarf, base, sibp, &derr); 712bc1f688bSRobert Mustacchi if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY) 713bc1f688bSRobert Mustacchi return (0); 714bc1f688bSRobert Mustacchi 715bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 716bc1f688bSRobert Mustacchi "failed to sibling from die: %s\n", 717bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 718bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 719bc1f688bSRobert Mustacchi } 720bc1f688bSRobert Mustacchi 721bc1f688bSRobert Mustacchi static int 722bc1f688bSRobert Mustacchi ctf_dwarf_child(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *childp) 723bc1f688bSRobert Mustacchi { 724bc1f688bSRobert Mustacchi Dwarf_Error derr; 725bc1f688bSRobert Mustacchi int ret; 726bc1f688bSRobert Mustacchi 727bc1f688bSRobert Mustacchi *childp = NULL; 728bc1f688bSRobert Mustacchi ret = dwarf_child(base, childp, &derr); 729bc1f688bSRobert Mustacchi if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY) 730bc1f688bSRobert Mustacchi return (0); 731bc1f688bSRobert Mustacchi 732bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 733bc1f688bSRobert Mustacchi "failed to child from die: %s\n", 734bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 735bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 736bc1f688bSRobert Mustacchi } 737bc1f688bSRobert Mustacchi 738bc1f688bSRobert Mustacchi /* 739bc1f688bSRobert Mustacchi * Compilers disagree on what to do to determine if something has global 740bc1f688bSRobert Mustacchi * visiblity. Traditionally gcc has used DW_AT_external to indicate this while 741bc1f688bSRobert Mustacchi * Studio has used DW_AT_visibility. We check DW_AT_visibility first and then 742bc1f688bSRobert Mustacchi * fall back to DW_AT_external. Lack of DW_AT_external implies that it is not. 743bc1f688bSRobert Mustacchi */ 744bc1f688bSRobert Mustacchi static int 745bc1f688bSRobert Mustacchi ctf_dwarf_isglobal(ctf_cu_t *cup, Dwarf_Die die, boolean_t *igp) 746bc1f688bSRobert Mustacchi { 747bc1f688bSRobert Mustacchi int ret; 748bc1f688bSRobert Mustacchi Dwarf_Signed vis; 749bc1f688bSRobert Mustacchi Dwarf_Bool ext; 750bc1f688bSRobert Mustacchi 751bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_signed(cup, die, DW_AT_visibility, &vis)) == 0) { 752bc1f688bSRobert Mustacchi *igp = vis == DW_VIS_exported; 753bc1f688bSRobert Mustacchi return (0); 754bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 755bc1f688bSRobert Mustacchi return (ret); 756bc1f688bSRobert Mustacchi } 757bc1f688bSRobert Mustacchi 758bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_external, &ext)) != 0) { 759bc1f688bSRobert Mustacchi if (ret == ENOENT) { 760bc1f688bSRobert Mustacchi *igp = B_FALSE; 761bc1f688bSRobert Mustacchi return (0); 762bc1f688bSRobert Mustacchi } 763bc1f688bSRobert Mustacchi return (ret); 764bc1f688bSRobert Mustacchi } 765bc1f688bSRobert Mustacchi *igp = ext != 0 ? B_TRUE : B_FALSE; 766bc1f688bSRobert Mustacchi return (0); 767bc1f688bSRobert Mustacchi } 768bc1f688bSRobert Mustacchi 769bc1f688bSRobert Mustacchi static int 770bc1f688bSRobert Mustacchi ctf_dwarf_die_elfenc(Elf *elf, ctf_cu_t *cup, char *errbuf, size_t errlen) 771bc1f688bSRobert Mustacchi { 772bc1f688bSRobert Mustacchi GElf_Ehdr ehdr; 773bc1f688bSRobert Mustacchi 774bc1f688bSRobert Mustacchi if (gelf_getehdr(elf, &ehdr) == NULL) { 775bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 776bc1f688bSRobert Mustacchi "failed to get ELF header: %s\n", 777bc1f688bSRobert Mustacchi elf_errmsg(elf_errno())); 778bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 779bc1f688bSRobert Mustacchi } 780bc1f688bSRobert Mustacchi 781bc1f688bSRobert Mustacchi cup->cu_mach = ehdr.e_machine; 782bc1f688bSRobert Mustacchi 783bc1f688bSRobert Mustacchi if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) { 784bc1f688bSRobert Mustacchi cup->cu_ptrsz = 4; 785bc1f688bSRobert Mustacchi VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_ILP32) == 0); 786bc1f688bSRobert Mustacchi } else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) { 787bc1f688bSRobert Mustacchi cup->cu_ptrsz = 8; 788bc1f688bSRobert Mustacchi VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_LP64) == 0); 789bc1f688bSRobert Mustacchi } else { 790bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 791bc1f688bSRobert Mustacchi "unknown ELF class %d", ehdr.e_ident[EI_CLASS]); 792bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 793bc1f688bSRobert Mustacchi } 794bc1f688bSRobert Mustacchi 795bc1f688bSRobert Mustacchi if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB) { 796bc1f688bSRobert Mustacchi cup->cu_bigend = B_FALSE; 797bc1f688bSRobert Mustacchi } else if (ehdr.e_ident[EI_DATA] == ELFDATA2MSB) { 798bc1f688bSRobert Mustacchi cup->cu_bigend = B_TRUE; 799bc1f688bSRobert Mustacchi } else { 800bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 801bc1f688bSRobert Mustacchi "unknown ELF data encoding: %hhu", ehdr.e_ident[EI_DATA]); 802bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 803bc1f688bSRobert Mustacchi } 804bc1f688bSRobert Mustacchi 805bc1f688bSRobert Mustacchi return (0); 806bc1f688bSRobert Mustacchi } 807bc1f688bSRobert Mustacchi 808bc1f688bSRobert Mustacchi typedef struct ctf_dwarf_fpent { 809bc1f688bSRobert Mustacchi size_t cdfe_size; 810bc1f688bSRobert Mustacchi uint_t cdfe_enc[3]; 811bc1f688bSRobert Mustacchi } ctf_dwarf_fpent_t; 812bc1f688bSRobert Mustacchi 813bc1f688bSRobert Mustacchi typedef struct ctf_dwarf_fpmap { 814bc1f688bSRobert Mustacchi uint_t cdf_mach; 815bc1f688bSRobert Mustacchi ctf_dwarf_fpent_t cdf_ents[4]; 816bc1f688bSRobert Mustacchi } ctf_dwarf_fpmap_t; 817bc1f688bSRobert Mustacchi 818bc1f688bSRobert Mustacchi static const ctf_dwarf_fpmap_t ctf_dwarf_fpmaps[] = { 819bc1f688bSRobert Mustacchi { EM_SPARC, { 820bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 821bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 822bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 823bc1f688bSRobert Mustacchi { 0, { 0 } } 824bc1f688bSRobert Mustacchi } }, 825bc1f688bSRobert Mustacchi { EM_SPARC32PLUS, { 826bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 827bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 828bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 829bc1f688bSRobert Mustacchi { 0, { 0 } } 830bc1f688bSRobert Mustacchi } }, 831bc1f688bSRobert Mustacchi { EM_SPARCV9, { 832bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 833bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 834bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 835bc1f688bSRobert Mustacchi { 0, { 0 } } 836bc1f688bSRobert Mustacchi } }, 837bc1f688bSRobert Mustacchi { EM_386, { 838bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 839bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 840bc1f688bSRobert Mustacchi { 12, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 841bc1f688bSRobert Mustacchi { 0, { 0 } } 842bc1f688bSRobert Mustacchi } }, 843bc1f688bSRobert Mustacchi { EM_X86_64, { 844bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 845bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 846bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 847bc1f688bSRobert Mustacchi { 0, { 0 } } 848bc1f688bSRobert Mustacchi } }, 849bc1f688bSRobert Mustacchi { EM_NONE } 850bc1f688bSRobert Mustacchi }; 851bc1f688bSRobert Mustacchi 8522e25d8e1SRobert Mustacchi /* 8532e25d8e1SRobert Mustacchi * We want to normalize the type names that are used between compilers in the 8542e25d8e1SRobert Mustacchi * case of complex. gcc prefixes things with types like 'long complex' where as 8552e25d8e1SRobert Mustacchi * clang only calls them 'complex' in the dwarf even if in the C they are long 8562e25d8e1SRobert Mustacchi * complex or similar. 8572e25d8e1SRobert Mustacchi */ 8582e25d8e1SRobert Mustacchi static int 8592e25d8e1SRobert Mustacchi ctf_dwarf_fixup_complex(ctf_cu_t *cup, ctf_encoding_t *enc, char **namep) 8602e25d8e1SRobert Mustacchi { 8612e25d8e1SRobert Mustacchi const char *name; 8622e25d8e1SRobert Mustacchi *namep = NULL; 8632e25d8e1SRobert Mustacchi 8642e25d8e1SRobert Mustacchi switch (enc->cte_format) { 8652e25d8e1SRobert Mustacchi case CTF_FP_CPLX: 8662e25d8e1SRobert Mustacchi name = "complex float"; 8672e25d8e1SRobert Mustacchi break; 8682e25d8e1SRobert Mustacchi case CTF_FP_DCPLX: 8692e25d8e1SRobert Mustacchi name = "complex double"; 8702e25d8e1SRobert Mustacchi break; 8712e25d8e1SRobert Mustacchi case CTF_FP_LDCPLX: 8722e25d8e1SRobert Mustacchi name = "complex long double"; 8732e25d8e1SRobert Mustacchi break; 8742e25d8e1SRobert Mustacchi default: 8752e25d8e1SRobert Mustacchi return (0); 8762e25d8e1SRobert Mustacchi } 8772e25d8e1SRobert Mustacchi 8782e25d8e1SRobert Mustacchi *namep = ctf_strdup(name); 8792e25d8e1SRobert Mustacchi if (*namep == NULL) { 8802e25d8e1SRobert Mustacchi return (ENOMEM); 8812e25d8e1SRobert Mustacchi } 8822e25d8e1SRobert Mustacchi 8832e25d8e1SRobert Mustacchi return (0); 8842e25d8e1SRobert Mustacchi } 8852e25d8e1SRobert Mustacchi 886bc1f688bSRobert Mustacchi static int 887bc1f688bSRobert Mustacchi ctf_dwarf_float_base(ctf_cu_t *cup, Dwarf_Signed type, ctf_encoding_t *enc) 888bc1f688bSRobert Mustacchi { 889bc1f688bSRobert Mustacchi const ctf_dwarf_fpmap_t *map = &ctf_dwarf_fpmaps[0]; 890bc1f688bSRobert Mustacchi const ctf_dwarf_fpent_t *ent; 891bc1f688bSRobert Mustacchi uint_t col = 0, mult = 1; 892bc1f688bSRobert Mustacchi 893bc1f688bSRobert Mustacchi for (map = &ctf_dwarf_fpmaps[0]; map->cdf_mach != EM_NONE; map++) { 894bc1f688bSRobert Mustacchi if (map->cdf_mach == cup->cu_mach) 895bc1f688bSRobert Mustacchi break; 896bc1f688bSRobert Mustacchi } 897bc1f688bSRobert Mustacchi 898bc1f688bSRobert Mustacchi if (map->cdf_mach == EM_NONE) { 899bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 900bc1f688bSRobert Mustacchi "Unsupported machine type: %d\n", cup->cu_mach); 901bc1f688bSRobert Mustacchi return (ENOTSUP); 902bc1f688bSRobert Mustacchi } 903bc1f688bSRobert Mustacchi 904bc1f688bSRobert Mustacchi if (type == DW_ATE_complex_float) { 905bc1f688bSRobert Mustacchi mult = 2; 906bc1f688bSRobert Mustacchi col = 1; 907bc1f688bSRobert Mustacchi } else if (type == DW_ATE_imaginary_float || 908bc1f688bSRobert Mustacchi type == DW_ATE_SUN_imaginary_float) { 909bc1f688bSRobert Mustacchi col = 2; 910bc1f688bSRobert Mustacchi } 911bc1f688bSRobert Mustacchi 912bc1f688bSRobert Mustacchi ent = &map->cdf_ents[0]; 913bc1f688bSRobert Mustacchi for (ent = &map->cdf_ents[0]; ent->cdfe_size != 0; ent++) { 914bc1f688bSRobert Mustacchi if (ent->cdfe_size * mult * 8 == enc->cte_bits) { 915bc1f688bSRobert Mustacchi enc->cte_format = ent->cdfe_enc[col]; 916bc1f688bSRobert Mustacchi return (0); 917bc1f688bSRobert Mustacchi } 918bc1f688bSRobert Mustacchi } 919bc1f688bSRobert Mustacchi 920bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 921bc1f688bSRobert Mustacchi "failed to find valid fp mapping for encoding %d, size %d bits\n", 922bc1f688bSRobert Mustacchi type, enc->cte_bits); 923bc1f688bSRobert Mustacchi return (EINVAL); 924bc1f688bSRobert Mustacchi } 925bc1f688bSRobert Mustacchi 926bc1f688bSRobert Mustacchi static int 927bc1f688bSRobert Mustacchi ctf_dwarf_dwarf_base(ctf_cu_t *cup, Dwarf_Die die, int *kindp, 928bc1f688bSRobert Mustacchi ctf_encoding_t *enc) 929bc1f688bSRobert Mustacchi { 930bc1f688bSRobert Mustacchi int ret; 931bc1f688bSRobert Mustacchi Dwarf_Signed type; 932bc1f688bSRobert Mustacchi 933bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_signed(cup, die, DW_AT_encoding, &type)) != 0) 934bc1f688bSRobert Mustacchi return (ret); 935bc1f688bSRobert Mustacchi 936bc1f688bSRobert Mustacchi switch (type) { 937bc1f688bSRobert Mustacchi case DW_ATE_unsigned: 938bc1f688bSRobert Mustacchi case DW_ATE_address: 939bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 940bc1f688bSRobert Mustacchi enc->cte_format = 0; 941bc1f688bSRobert Mustacchi break; 942bc1f688bSRobert Mustacchi case DW_ATE_unsigned_char: 943bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 944bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_CHAR; 945bc1f688bSRobert Mustacchi break; 946bc1f688bSRobert Mustacchi case DW_ATE_signed: 947bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 948bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_SIGNED; 949bc1f688bSRobert Mustacchi break; 950bc1f688bSRobert Mustacchi case DW_ATE_signed_char: 951bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 952bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_SIGNED | CTF_INT_CHAR; 953bc1f688bSRobert Mustacchi break; 954bc1f688bSRobert Mustacchi case DW_ATE_boolean: 955bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 956bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_SIGNED | CTF_INT_BOOL; 957bc1f688bSRobert Mustacchi break; 958bc1f688bSRobert Mustacchi case DW_ATE_float: 959bc1f688bSRobert Mustacchi case DW_ATE_complex_float: 960bc1f688bSRobert Mustacchi case DW_ATE_imaginary_float: 961bc1f688bSRobert Mustacchi case DW_ATE_SUN_imaginary_float: 962bc1f688bSRobert Mustacchi case DW_ATE_SUN_interval_float: 963bc1f688bSRobert Mustacchi *kindp = CTF_K_FLOAT; 964bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_float_base(cup, type, enc)) != 0) 965bc1f688bSRobert Mustacchi return (ret); 966bc1f688bSRobert Mustacchi break; 967bc1f688bSRobert Mustacchi default: 968bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 9693eca6103SJohn Levon "encountered unknown DWARF encoding: %d", type); 970bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 971bc1f688bSRobert Mustacchi } 972bc1f688bSRobert Mustacchi 973bc1f688bSRobert Mustacchi return (0); 974bc1f688bSRobert Mustacchi } 975bc1f688bSRobert Mustacchi 976bc1f688bSRobert Mustacchi /* 977bc1f688bSRobert Mustacchi * Different compilers (at least GCC and Studio) use different names for types. 978bc1f688bSRobert Mustacchi * This parses the types and attempts to unify them. If this fails, we just fall 979bc1f688bSRobert Mustacchi * back to using the DWARF itself. 980bc1f688bSRobert Mustacchi */ 981bc1f688bSRobert Mustacchi static int 9822e25d8e1SRobert Mustacchi ctf_dwarf_parse_int(const char *name, int *kindp, ctf_encoding_t *enc, 983bc1f688bSRobert Mustacchi char **newnamep) 984bc1f688bSRobert Mustacchi { 985bc1f688bSRobert Mustacchi char buf[256]; 986bc1f688bSRobert Mustacchi char *base, *c, *last; 987bc1f688bSRobert Mustacchi int nlong = 0, nshort = 0, nchar = 0, nint = 0; 988bc1f688bSRobert Mustacchi int sign = 1; 989bc1f688bSRobert Mustacchi 990bc1f688bSRobert Mustacchi if (strlen(name) + 1 > sizeof (buf)) 991bc1f688bSRobert Mustacchi return (EINVAL); 992bc1f688bSRobert Mustacchi 993bc1f688bSRobert Mustacchi (void) strlcpy(buf, name, sizeof (buf)); 994bc1f688bSRobert Mustacchi for (c = strtok_r(buf, " ", &last); c != NULL; 995bc1f688bSRobert Mustacchi c = strtok_r(NULL, " ", &last)) { 996bc1f688bSRobert Mustacchi if (strcmp(c, "signed") == 0) { 997bc1f688bSRobert Mustacchi sign = 1; 998bc1f688bSRobert Mustacchi } else if (strcmp(c, "unsigned") == 0) { 999bc1f688bSRobert Mustacchi sign = 0; 1000bc1f688bSRobert Mustacchi } else if (strcmp(c, "long") == 0) { 1001bc1f688bSRobert Mustacchi nlong++; 1002bc1f688bSRobert Mustacchi } else if (strcmp(c, "char") == 0) { 1003bc1f688bSRobert Mustacchi nchar++; 1004bc1f688bSRobert Mustacchi } else if (strcmp(c, "short") == 0) { 1005bc1f688bSRobert Mustacchi nshort++; 1006bc1f688bSRobert Mustacchi } else if (strcmp(c, "int") == 0) { 1007bc1f688bSRobert Mustacchi nint++; 1008bc1f688bSRobert Mustacchi } else { 1009bc1f688bSRobert Mustacchi /* 1010bc1f688bSRobert Mustacchi * If we don't recognize any of the tokens, we'll tell 1011bc1f688bSRobert Mustacchi * the caller to fall back to the dwarf-provided 1012bc1f688bSRobert Mustacchi * encoding information. 1013bc1f688bSRobert Mustacchi */ 1014bc1f688bSRobert Mustacchi return (EINVAL); 1015bc1f688bSRobert Mustacchi } 1016bc1f688bSRobert Mustacchi } 1017bc1f688bSRobert Mustacchi 1018bc1f688bSRobert Mustacchi if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2) 1019bc1f688bSRobert Mustacchi return (EINVAL); 1020bc1f688bSRobert Mustacchi 1021bc1f688bSRobert Mustacchi if (nchar > 0) { 1022bc1f688bSRobert Mustacchi if (nlong > 0 || nshort > 0 || nint > 0) 1023bc1f688bSRobert Mustacchi return (EINVAL); 1024bc1f688bSRobert Mustacchi base = "char"; 1025bc1f688bSRobert Mustacchi } else if (nshort > 0) { 1026bc1f688bSRobert Mustacchi if (nlong > 0) 1027bc1f688bSRobert Mustacchi return (EINVAL); 1028bc1f688bSRobert Mustacchi base = "short"; 1029bc1f688bSRobert Mustacchi } else if (nlong > 0) { 1030bc1f688bSRobert Mustacchi base = "long"; 1031bc1f688bSRobert Mustacchi } else { 1032bc1f688bSRobert Mustacchi base = "int"; 1033bc1f688bSRobert Mustacchi } 1034bc1f688bSRobert Mustacchi 1035bc1f688bSRobert Mustacchi if (nchar > 0) 1036bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_CHAR; 1037bc1f688bSRobert Mustacchi else 1038bc1f688bSRobert Mustacchi enc->cte_format = 0; 1039bc1f688bSRobert Mustacchi 1040bc1f688bSRobert Mustacchi if (sign > 0) 1041bc1f688bSRobert Mustacchi enc->cte_format |= CTF_INT_SIGNED; 1042bc1f688bSRobert Mustacchi 1043bc1f688bSRobert Mustacchi (void) snprintf(buf, sizeof (buf), "%s%s%s", 1044bc1f688bSRobert Mustacchi (sign ? "" : "unsigned "), 1045bc1f688bSRobert Mustacchi (nlong > 1 ? "long " : ""), 1046bc1f688bSRobert Mustacchi base); 1047bc1f688bSRobert Mustacchi 1048bc1f688bSRobert Mustacchi *newnamep = ctf_strdup(buf); 1049bc1f688bSRobert Mustacchi if (*newnamep == NULL) 1050bc1f688bSRobert Mustacchi return (ENOMEM); 1051bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 1052bc1f688bSRobert Mustacchi return (0); 1053bc1f688bSRobert Mustacchi } 1054bc1f688bSRobert Mustacchi 1055bc1f688bSRobert Mustacchi static int 1056bc1f688bSRobert Mustacchi ctf_dwarf_create_base(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot, 1057bc1f688bSRobert Mustacchi Dwarf_Off off) 1058bc1f688bSRobert Mustacchi { 1059bc1f688bSRobert Mustacchi int ret; 10602e25d8e1SRobert Mustacchi char *name, *nname = NULL; 1061bc1f688bSRobert Mustacchi Dwarf_Unsigned sz; 1062bc1f688bSRobert Mustacchi int kind; 1063bc1f688bSRobert Mustacchi ctf_encoding_t enc; 1064bc1f688bSRobert Mustacchi ctf_id_t id; 1065bc1f688bSRobert Mustacchi 1066bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0) 1067bc1f688bSRobert Mustacchi return (ret); 1068bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &sz)) != 0) { 1069bc1f688bSRobert Mustacchi goto out; 1070bc1f688bSRobert Mustacchi } 1071bc1f688bSRobert Mustacchi ctf_dprintf("Creating base type %s from off %llu, size: %d\n", name, 1072bc1f688bSRobert Mustacchi off, sz); 1073bc1f688bSRobert Mustacchi 1074bc1f688bSRobert Mustacchi bzero(&enc, sizeof (ctf_encoding_t)); 1075bc1f688bSRobert Mustacchi enc.cte_bits = sz * 8; 10762e25d8e1SRobert Mustacchi if ((ret = ctf_dwarf_parse_int(name, &kind, &enc, &nname)) == 0) { 1077bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1078bc1f688bSRobert Mustacchi name = nname; 1079bc1f688bSRobert Mustacchi } else { 10802e25d8e1SRobert Mustacchi if (ret != EINVAL) { 10812e25d8e1SRobert Mustacchi goto out; 10822e25d8e1SRobert Mustacchi } 1083bc1f688bSRobert Mustacchi ctf_dprintf("falling back to dwarf for base type %s\n", name); 10842e25d8e1SRobert Mustacchi if ((ret = ctf_dwarf_dwarf_base(cup, die, &kind, &enc)) != 0) { 10852e25d8e1SRobert Mustacchi goto out; 10862e25d8e1SRobert Mustacchi } 10872e25d8e1SRobert Mustacchi 10882e25d8e1SRobert Mustacchi if (kind == CTF_K_FLOAT && (ret = ctf_dwarf_fixup_complex(cup, 10892e25d8e1SRobert Mustacchi &enc, &nname)) != 0) { 10902e25d8e1SRobert Mustacchi goto out; 10912e25d8e1SRobert Mustacchi } else if (nname != NULL) { 10922e25d8e1SRobert Mustacchi ctf_free(name, strlen(name) + 1); 10932e25d8e1SRobert Mustacchi name = nname; 10942e25d8e1SRobert Mustacchi } 1095bc1f688bSRobert Mustacchi } 1096bc1f688bSRobert Mustacchi 1097bc1f688bSRobert Mustacchi id = ctf_add_encoded(cup->cu_ctfp, isroot, name, &enc, kind); 1098bc1f688bSRobert Mustacchi if (id == CTF_ERR) { 1099bc1f688bSRobert Mustacchi ret = ctf_errno(cup->cu_ctfp); 1100bc1f688bSRobert Mustacchi } else { 1101bc1f688bSRobert Mustacchi *idp = id; 1102bc1f688bSRobert Mustacchi ret = ctf_dwmap_add(cup, id, die, B_FALSE); 1103bc1f688bSRobert Mustacchi } 1104bc1f688bSRobert Mustacchi out: 1105bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1106bc1f688bSRobert Mustacchi return (ret); 1107bc1f688bSRobert Mustacchi } 1108bc1f688bSRobert Mustacchi 1109bc1f688bSRobert Mustacchi /* 1110bc1f688bSRobert Mustacchi * Getting a member's offset is a surprisingly intricate dance. It works as 1111bc1f688bSRobert Mustacchi * follows: 1112bc1f688bSRobert Mustacchi * 1113bc1f688bSRobert Mustacchi * 1) If we're in DWARFv4, then we either have a DW_AT_data_bit_offset or we 1114bc1f688bSRobert Mustacchi * have a DW_AT_data_member_location. We won't have both. Thus we check first 1115bc1f688bSRobert Mustacchi * for DW_AT_data_bit_offset, and if it exists, we're set. 1116bc1f688bSRobert Mustacchi * 1117bc1f688bSRobert Mustacchi * Next, if we have a bitfield and we don't have a DW_AT_data_bit_offset, then 1118bc1f688bSRobert Mustacchi * we have to grab the data location and use the following dance: 1119bc1f688bSRobert Mustacchi * 1120bc1f688bSRobert Mustacchi * 2) Gather the set of DW_AT_byte_size, DW_AT_bit_offset, and DW_AT_bit_size. 1121bc1f688bSRobert Mustacchi * Of course, the DW_AT_byte_size may be omitted, even though it isn't always. 1122bc1f688bSRobert Mustacchi * When it's been omitted, we then have to say that the size is that of the 1123bc1f688bSRobert Mustacchi * underlying type, which forces that to be after a ctf_update(). Here, we have 1124bc1f688bSRobert Mustacchi * to do different things based on whether or not we're using big endian or 1125bc1f688bSRobert Mustacchi * little endian to obtain the proper offset. 1126bc1f688bSRobert Mustacchi */ 1127bc1f688bSRobert Mustacchi static int 1128bc1f688bSRobert Mustacchi ctf_dwarf_member_offset(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t mid, 1129bc1f688bSRobert Mustacchi ulong_t *offp) 1130bc1f688bSRobert Mustacchi { 1131bc1f688bSRobert Mustacchi int ret; 1132bc1f688bSRobert Mustacchi Dwarf_Unsigned loc, bitsz, bytesz; 1133bc1f688bSRobert Mustacchi Dwarf_Signed bitoff; 1134bc1f688bSRobert Mustacchi size_t off; 1135bc1f688bSRobert Mustacchi ssize_t tsz; 1136bc1f688bSRobert Mustacchi 1137bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_data_bit_offset, 1138bc1f688bSRobert Mustacchi &loc)) == 0) { 1139bc1f688bSRobert Mustacchi *offp = loc; 1140bc1f688bSRobert Mustacchi return (0); 1141bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 1142bc1f688bSRobert Mustacchi return (ret); 1143bc1f688bSRobert Mustacchi } 1144bc1f688bSRobert Mustacchi 1145bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_member_location(cup, die, &loc)) != 0) 1146bc1f688bSRobert Mustacchi return (ret); 1147bc1f688bSRobert Mustacchi off = loc * 8; 1148bc1f688bSRobert Mustacchi 1149bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_signed(cup, die, DW_AT_bit_offset, 1150bc1f688bSRobert Mustacchi &bitoff)) != 0) { 1151bc1f688bSRobert Mustacchi if (ret != ENOENT) 1152bc1f688bSRobert Mustacchi return (ret); 1153bc1f688bSRobert Mustacchi *offp = off; 1154bc1f688bSRobert Mustacchi return (0); 1155bc1f688bSRobert Mustacchi } 1156bc1f688bSRobert Mustacchi 1157bc1f688bSRobert Mustacchi /* At this point we have to have DW_AT_bit_size */ 1158bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0) 1159bc1f688bSRobert Mustacchi return (ret); 1160bc1f688bSRobert Mustacchi 1161bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, 1162bc1f688bSRobert Mustacchi &bytesz)) != 0) { 1163bc1f688bSRobert Mustacchi if (ret != ENOENT) 1164bc1f688bSRobert Mustacchi return (ret); 1165bc1f688bSRobert Mustacchi if ((tsz = ctf_type_size(cup->cu_ctfp, mid)) == CTF_ERR) { 1166bc1f688bSRobert Mustacchi int e = ctf_errno(cup->cu_ctfp); 1167bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1168bc1f688bSRobert Mustacchi "failed to get type size: %s", ctf_errmsg(e)); 1169bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1170bc1f688bSRobert Mustacchi } 1171bc1f688bSRobert Mustacchi } else { 1172bc1f688bSRobert Mustacchi tsz = bytesz; 1173bc1f688bSRobert Mustacchi } 1174bc1f688bSRobert Mustacchi tsz *= 8; 1175bc1f688bSRobert Mustacchi if (cup->cu_bigend == B_TRUE) { 1176bc1f688bSRobert Mustacchi *offp = off + bitoff; 1177bc1f688bSRobert Mustacchi } else { 1178bc1f688bSRobert Mustacchi *offp = off + tsz - bitoff - bitsz; 1179bc1f688bSRobert Mustacchi } 1180bc1f688bSRobert Mustacchi 1181bc1f688bSRobert Mustacchi return (0); 1182bc1f688bSRobert Mustacchi } 1183bc1f688bSRobert Mustacchi 1184bc1f688bSRobert Mustacchi /* 1185bc1f688bSRobert Mustacchi * We need to determine if the member in question is a bitfield. If it is, then 1186bc1f688bSRobert Mustacchi * we need to go through and create a new type that's based on the actual base 1187bc1f688bSRobert Mustacchi * type, but has a different size. We also rename the type as a result to help 1188bc1f688bSRobert Mustacchi * deal with future collisions. 1189bc1f688bSRobert Mustacchi * 1190bc1f688bSRobert Mustacchi * Here we need to look and see if we have a DW_AT_bit_size value. If we have a 1191bc1f688bSRobert Mustacchi * bit size member and it does not equal the byte size member, then we need to 1192bc1f688bSRobert Mustacchi * create a bitfield type based on this. 1193bc1f688bSRobert Mustacchi * 1194bc1f688bSRobert Mustacchi * Note: When we support DWARFv4, there may be a chance that we need to also 1195bc1f688bSRobert Mustacchi * search for the DW_AT_byte_size if we don't have a DW_AT_bit_size member. 1196bc1f688bSRobert Mustacchi */ 1197bc1f688bSRobert Mustacchi static int 1198bc1f688bSRobert Mustacchi ctf_dwarf_member_bitfield(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp) 1199bc1f688bSRobert Mustacchi { 1200bc1f688bSRobert Mustacchi int ret; 1201bc1f688bSRobert Mustacchi Dwarf_Unsigned bitsz; 1202bc1f688bSRobert Mustacchi ctf_encoding_t e; 1203bc1f688bSRobert Mustacchi ctf_dwbitf_t *cdb; 1204bc1f688bSRobert Mustacchi ctf_dtdef_t *dtd; 1205bc1f688bSRobert Mustacchi ctf_id_t base = *idp; 1206bc1f688bSRobert Mustacchi int kind; 1207bc1f688bSRobert Mustacchi 1208bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0) { 1209bc1f688bSRobert Mustacchi if (ret == ENOENT) 1210bc1f688bSRobert Mustacchi return (0); 1211bc1f688bSRobert Mustacchi return (ret); 1212bc1f688bSRobert Mustacchi } 1213bc1f688bSRobert Mustacchi 1214bc1f688bSRobert Mustacchi ctf_dprintf("Trying to deal with bitfields on %d:%d\n", base, bitsz); 1215bc1f688bSRobert Mustacchi /* 1216bc1f688bSRobert Mustacchi * Given that we now have a bitsize, time to go do something about it. 1217bc1f688bSRobert Mustacchi * We're going to create a new type based on the current one, but first 1218bc1f688bSRobert Mustacchi * we need to find the base type. This means we need to traverse any 1219bc1f688bSRobert Mustacchi * typedef's, consts, and volatiles until we get to what should be 1220bc1f688bSRobert Mustacchi * something of type integer or enumeration. 1221bc1f688bSRobert Mustacchi */ 1222bc1f688bSRobert Mustacchi VERIFY(bitsz < UINT32_MAX); 1223bc1f688bSRobert Mustacchi dtd = ctf_dtd_lookup(cup->cu_ctfp, base); 1224bc1f688bSRobert Mustacchi VERIFY(dtd != NULL); 1225bc1f688bSRobert Mustacchi kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info); 1226bc1f688bSRobert Mustacchi while (kind == CTF_K_TYPEDEF || kind == CTF_K_CONST || 1227bc1f688bSRobert Mustacchi kind == CTF_K_VOLATILE) { 1228bc1f688bSRobert Mustacchi dtd = ctf_dtd_lookup(cup->cu_ctfp, dtd->dtd_data.ctt_type); 1229bc1f688bSRobert Mustacchi VERIFY(dtd != NULL); 1230bc1f688bSRobert Mustacchi kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info); 1231bc1f688bSRobert Mustacchi } 1232bc1f688bSRobert Mustacchi ctf_dprintf("got kind %d\n", kind); 1233bc1f688bSRobert Mustacchi VERIFY(kind == CTF_K_INTEGER || kind == CTF_K_ENUM); 1234bc1f688bSRobert Mustacchi 1235bc1f688bSRobert Mustacchi /* 1236bc1f688bSRobert Mustacchi * As surprising as it may be, it is strictly possible to create a 1237bc1f688bSRobert Mustacchi * bitfield that is based on an enum. Of course, the C standard leaves 1238bc1f688bSRobert Mustacchi * enums sizing as an ABI concern more or less. To that effect, today on 1239bc1f688bSRobert Mustacchi * all illumos platforms the size of an enum is generally that of an 1240bc1f688bSRobert Mustacchi * int as our supported data models and ABIs all agree on that. So what 1241bc1f688bSRobert Mustacchi * we'll do is fake up a CTF encoding here to use. In this case, we'll 1242bc1f688bSRobert Mustacchi * treat it as an unsigned value of whatever size the underlying enum 1243bc1f688bSRobert Mustacchi * currently has (which is in the ctt_size member of its dynamic type 1244bc1f688bSRobert Mustacchi * data). 1245bc1f688bSRobert Mustacchi */ 1246bc1f688bSRobert Mustacchi if (kind == CTF_K_INTEGER) { 1247bc1f688bSRobert Mustacchi e = dtd->dtd_u.dtu_enc; 1248bc1f688bSRobert Mustacchi } else { 1249bc1f688bSRobert Mustacchi bzero(&e, sizeof (ctf_encoding_t)); 1250bc1f688bSRobert Mustacchi e.cte_bits = dtd->dtd_data.ctt_size * NBBY; 1251bc1f688bSRobert Mustacchi } 1252bc1f688bSRobert Mustacchi 1253bc1f688bSRobert Mustacchi for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL; 1254bc1f688bSRobert Mustacchi cdb = ctf_list_next(cdb)) { 1255bc1f688bSRobert Mustacchi if (cdb->cdb_base == base && cdb->cdb_nbits == bitsz) 1256bc1f688bSRobert Mustacchi break; 1257bc1f688bSRobert Mustacchi } 1258bc1f688bSRobert Mustacchi 1259bc1f688bSRobert Mustacchi /* 1260bc1f688bSRobert Mustacchi * Create a new type if none exists. We name all types in a way that is 1261bc1f688bSRobert Mustacchi * guaranteed not to conflict with the corresponding C type. We do this 1262bc1f688bSRobert Mustacchi * by using the ':' operator. 1263bc1f688bSRobert Mustacchi */ 1264bc1f688bSRobert Mustacchi if (cdb == NULL) { 1265bc1f688bSRobert Mustacchi size_t namesz; 1266bc1f688bSRobert Mustacchi char *name; 1267bc1f688bSRobert Mustacchi 1268bc1f688bSRobert Mustacchi e.cte_bits = bitsz; 1269bc1f688bSRobert Mustacchi namesz = snprintf(NULL, 0, "%s:%d", dtd->dtd_name, 1270bc1f688bSRobert Mustacchi (uint32_t)bitsz); 1271bc1f688bSRobert Mustacchi name = ctf_alloc(namesz + 1); 1272bc1f688bSRobert Mustacchi if (name == NULL) 1273bc1f688bSRobert Mustacchi return (ENOMEM); 1274bc1f688bSRobert Mustacchi cdb = ctf_alloc(sizeof (ctf_dwbitf_t)); 1275bc1f688bSRobert Mustacchi if (cdb == NULL) { 1276bc1f688bSRobert Mustacchi ctf_free(name, namesz + 1); 1277bc1f688bSRobert Mustacchi return (ENOMEM); 1278bc1f688bSRobert Mustacchi } 1279bc1f688bSRobert Mustacchi (void) snprintf(name, namesz + 1, "%s:%d", dtd->dtd_name, 1280bc1f688bSRobert Mustacchi (uint32_t)bitsz); 1281bc1f688bSRobert Mustacchi 1282bc1f688bSRobert Mustacchi cdb->cdb_base = base; 1283bc1f688bSRobert Mustacchi cdb->cdb_nbits = bitsz; 1284bc1f688bSRobert Mustacchi cdb->cdb_id = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT, 1285bc1f688bSRobert Mustacchi name, &e); 1286bc1f688bSRobert Mustacchi if (cdb->cdb_id == CTF_ERR) { 1287bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1288bc1f688bSRobert Mustacchi "failed to get add bitfield type %s: %s", name, 1289bc1f688bSRobert Mustacchi ctf_errmsg(ctf_errno(cup->cu_ctfp))); 1290bc1f688bSRobert Mustacchi ctf_free(name, namesz + 1); 1291bc1f688bSRobert Mustacchi ctf_free(cdb, sizeof (ctf_dwbitf_t)); 1292bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1293bc1f688bSRobert Mustacchi } 1294bc1f688bSRobert Mustacchi ctf_free(name, namesz + 1); 1295bc1f688bSRobert Mustacchi ctf_list_append(&cup->cu_bitfields, cdb); 1296bc1f688bSRobert Mustacchi } 1297bc1f688bSRobert Mustacchi 1298bc1f688bSRobert Mustacchi *idp = cdb->cdb_id; 1299bc1f688bSRobert Mustacchi 1300bc1f688bSRobert Mustacchi return (0); 1301bc1f688bSRobert Mustacchi } 1302bc1f688bSRobert Mustacchi 1303bc1f688bSRobert Mustacchi static int 1304bc1f688bSRobert Mustacchi ctf_dwarf_fixup_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t base, boolean_t add) 1305bc1f688bSRobert Mustacchi { 1306bc1f688bSRobert Mustacchi int ret, kind; 1307bc1f688bSRobert Mustacchi Dwarf_Die child, memb; 1308bc1f688bSRobert Mustacchi Dwarf_Unsigned size; 1309bc1f688bSRobert Mustacchi 1310bc1f688bSRobert Mustacchi kind = ctf_type_kind(cup->cu_ctfp, base); 1311bc1f688bSRobert Mustacchi VERIFY(kind != CTF_ERR); 1312bc1f688bSRobert Mustacchi VERIFY(kind == CTF_K_STRUCT || kind == CTF_K_UNION); 1313bc1f688bSRobert Mustacchi 1314bc1f688bSRobert Mustacchi /* 1315bc1f688bSRobert Mustacchi * Members are in children. However, gcc also allows empty ones. 1316bc1f688bSRobert Mustacchi */ 1317bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 1318bc1f688bSRobert Mustacchi return (ret); 1319bc1f688bSRobert Mustacchi if (child == NULL) 1320bc1f688bSRobert Mustacchi return (0); 1321bc1f688bSRobert Mustacchi 1322bc1f688bSRobert Mustacchi memb = child; 1323bc1f688bSRobert Mustacchi while (memb != NULL) { 1324bc1f688bSRobert Mustacchi Dwarf_Die sib, tdie; 1325bc1f688bSRobert Mustacchi Dwarf_Half tag; 1326bc1f688bSRobert Mustacchi ctf_id_t mid; 1327bc1f688bSRobert Mustacchi char *mname; 1328bc1f688bSRobert Mustacchi ulong_t memboff = 0; 1329bc1f688bSRobert Mustacchi 1330bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, memb, &tag)) != 0) 1331bc1f688bSRobert Mustacchi return (ret); 1332bc1f688bSRobert Mustacchi 1333bc1f688bSRobert Mustacchi if (tag != DW_TAG_member) 13343df9f064SRobert Mustacchi goto next; 1335bc1f688bSRobert Mustacchi 1336bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, memb, DW_AT_type, &tdie)) != 0) 1337bc1f688bSRobert Mustacchi return (ret); 1338bc1f688bSRobert Mustacchi 1339bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &mid, 1340bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1341bc1f688bSRobert Mustacchi return (ret); 1342bc1f688bSRobert Mustacchi ctf_dprintf("Got back type id: %d\n", mid); 1343bc1f688bSRobert Mustacchi 1344bc1f688bSRobert Mustacchi /* 1345bc1f688bSRobert Mustacchi * If we're not adding a member, just go ahead and return. 1346bc1f688bSRobert Mustacchi */ 1347bc1f688bSRobert Mustacchi if (add == B_FALSE) { 1348bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_member_bitfield(cup, memb, 1349bc1f688bSRobert Mustacchi &mid)) != 0) 1350bc1f688bSRobert Mustacchi return (ret); 1351bc1f688bSRobert Mustacchi goto next; 1352bc1f688bSRobert Mustacchi } 1353bc1f688bSRobert Mustacchi 1354bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, memb, DW_AT_name, 1355bc1f688bSRobert Mustacchi &mname)) != 0 && ret != ENOENT) 1356bc1f688bSRobert Mustacchi return (ret); 1357bc1f688bSRobert Mustacchi if (ret == ENOENT) 1358bc1f688bSRobert Mustacchi mname = NULL; 1359bc1f688bSRobert Mustacchi 1360bc1f688bSRobert Mustacchi if (kind == CTF_K_UNION) { 1361bc1f688bSRobert Mustacchi memboff = 0; 1362bc1f688bSRobert Mustacchi } else if ((ret = ctf_dwarf_member_offset(cup, memb, mid, 1363bc1f688bSRobert Mustacchi &memboff)) != 0) { 1364bc1f688bSRobert Mustacchi if (mname != NULL) 1365bc1f688bSRobert Mustacchi ctf_free(mname, strlen(mname) + 1); 1366bc1f688bSRobert Mustacchi return (ret); 1367bc1f688bSRobert Mustacchi } 1368bc1f688bSRobert Mustacchi 1369bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_member_bitfield(cup, memb, &mid)) != 0) 1370bc1f688bSRobert Mustacchi return (ret); 1371bc1f688bSRobert Mustacchi 1372bc1f688bSRobert Mustacchi ret = ctf_add_member(cup->cu_ctfp, base, mname, mid, memboff); 1373bc1f688bSRobert Mustacchi if (ret == CTF_ERR) { 1374bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1375bc1f688bSRobert Mustacchi "failed to add member %s: %s", 1376bc1f688bSRobert Mustacchi mname, ctf_errmsg(ctf_errno(cup->cu_ctfp))); 1377bc1f688bSRobert Mustacchi if (mname != NULL) 1378bc1f688bSRobert Mustacchi ctf_free(mname, strlen(mname) + 1); 1379bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1380bc1f688bSRobert Mustacchi } 1381bc1f688bSRobert Mustacchi 1382bc1f688bSRobert Mustacchi if (mname != NULL) 1383bc1f688bSRobert Mustacchi ctf_free(mname, strlen(mname) + 1); 1384bc1f688bSRobert Mustacchi 1385bc1f688bSRobert Mustacchi next: 1386bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, memb, &sib)) != 0) 1387bc1f688bSRobert Mustacchi return (ret); 1388bc1f688bSRobert Mustacchi memb = sib; 1389bc1f688bSRobert Mustacchi } 1390bc1f688bSRobert Mustacchi 1391bc1f688bSRobert Mustacchi /* 1392bc1f688bSRobert Mustacchi * If we're not adding members, then we don't know the final size of the 1393bc1f688bSRobert Mustacchi * structure, so end here. 1394bc1f688bSRobert Mustacchi */ 1395bc1f688bSRobert Mustacchi if (add == B_FALSE) 1396bc1f688bSRobert Mustacchi return (0); 1397bc1f688bSRobert Mustacchi 1398bc1f688bSRobert Mustacchi /* Finally set the size of the structure to the actual byte size */ 1399bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &size)) != 0) 1400bc1f688bSRobert Mustacchi return (ret); 1401fe2dc8bdSJohn Levon if ((ctf_set_size(cup->cu_ctfp, base, size)) == CTF_ERR) { 1402bc1f688bSRobert Mustacchi int e = ctf_errno(cup->cu_ctfp); 1403bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1404bc1f688bSRobert Mustacchi "failed to set type size for %d to 0x%x: %s", base, 1405bc1f688bSRobert Mustacchi (uint32_t)size, ctf_errmsg(e)); 1406bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1407bc1f688bSRobert Mustacchi } 1408bc1f688bSRobert Mustacchi 1409bc1f688bSRobert Mustacchi return (0); 1410bc1f688bSRobert Mustacchi } 1411bc1f688bSRobert Mustacchi 1412bc1f688bSRobert Mustacchi static int 1413bc1f688bSRobert Mustacchi ctf_dwarf_create_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, 1414bc1f688bSRobert Mustacchi int kind, int isroot) 1415bc1f688bSRobert Mustacchi { 1416bc1f688bSRobert Mustacchi int ret; 1417bc1f688bSRobert Mustacchi char *name; 1418bc1f688bSRobert Mustacchi ctf_id_t base; 1419bc1f688bSRobert Mustacchi Dwarf_Die child; 1420bc1f688bSRobert Mustacchi Dwarf_Bool decl; 1421bc1f688bSRobert Mustacchi 1422bc1f688bSRobert Mustacchi /* 1423bc1f688bSRobert Mustacchi * Deal with the terribly annoying case of anonymous structs and unions. 1424bc1f688bSRobert Mustacchi * If they don't have a name, set the name to the empty string. 1425bc1f688bSRobert Mustacchi */ 1426bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 1427bc1f688bSRobert Mustacchi ret != ENOENT) 1428bc1f688bSRobert Mustacchi return (ret); 1429bc1f688bSRobert Mustacchi if (ret == ENOENT) 1430bc1f688bSRobert Mustacchi name = NULL; 1431bc1f688bSRobert Mustacchi 1432bc1f688bSRobert Mustacchi /* 1433bc1f688bSRobert Mustacchi * We need to check if we just have a declaration here. If we do, then 1434bc1f688bSRobert Mustacchi * instead of creating an actual structure or union, we're just going to 1435bc1f688bSRobert Mustacchi * go ahead and create a forward. During a dedup or merge, the forward 1436bc1f688bSRobert Mustacchi * will be replaced with the real thing. 1437bc1f688bSRobert Mustacchi */ 1438bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, 1439bc1f688bSRobert Mustacchi &decl)) != 0) { 1440bc1f688bSRobert Mustacchi if (ret != ENOENT) 1441bc1f688bSRobert Mustacchi return (ret); 1442bc1f688bSRobert Mustacchi decl = 0; 1443bc1f688bSRobert Mustacchi } 1444bc1f688bSRobert Mustacchi 1445bc1f688bSRobert Mustacchi if (decl != 0) { 1446bc1f688bSRobert Mustacchi base = ctf_add_forward(cup->cu_ctfp, isroot, name, kind); 1447bc1f688bSRobert Mustacchi } else if (kind == CTF_K_STRUCT) { 1448bc1f688bSRobert Mustacchi base = ctf_add_struct(cup->cu_ctfp, isroot, name); 1449bc1f688bSRobert Mustacchi } else { 1450bc1f688bSRobert Mustacchi base = ctf_add_union(cup->cu_ctfp, isroot, name); 1451bc1f688bSRobert Mustacchi } 1452bc1f688bSRobert Mustacchi ctf_dprintf("added sou %s (%d) (%d)\n", name, kind, base); 1453bc1f688bSRobert Mustacchi if (name != NULL) 1454bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1455bc1f688bSRobert Mustacchi if (base == CTF_ERR) 1456bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1457bc1f688bSRobert Mustacchi *idp = base; 1458bc1f688bSRobert Mustacchi 1459bc1f688bSRobert Mustacchi /* 1460bc1f688bSRobert Mustacchi * If it's just a declaration, we're not going to mark it for fix up or 1461bc1f688bSRobert Mustacchi * do anything else. 1462bc1f688bSRobert Mustacchi */ 1463bc1f688bSRobert Mustacchi if (decl == B_TRUE) 1464bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, base, die, B_FALSE)); 1465bc1f688bSRobert Mustacchi if ((ret = ctf_dwmap_add(cup, base, die, B_TRUE)) != 0) 1466bc1f688bSRobert Mustacchi return (ret); 1467bc1f688bSRobert Mustacchi 1468bc1f688bSRobert Mustacchi /* 14693df9f064SRobert Mustacchi * The children of a structure or union are generally members. However, 14703df9f064SRobert Mustacchi * some compilers actually insert structs and unions there and not as a 14713df9f064SRobert Mustacchi * top-level die. Therefore, to make sure we honor our pass 1 contract 14723df9f064SRobert Mustacchi * of having all the base types, but not members, we need to walk this 14733df9f064SRobert Mustacchi * for instances of a DW_TAG_union_type. 1474bc1f688bSRobert Mustacchi */ 1475bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 1476bc1f688bSRobert Mustacchi return (ret); 14773df9f064SRobert Mustacchi 14783df9f064SRobert Mustacchi while (child != NULL) { 14793df9f064SRobert Mustacchi Dwarf_Half tag; 14803df9f064SRobert Mustacchi Dwarf_Die sib; 14813df9f064SRobert Mustacchi 14823df9f064SRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, child, &tag)) != 0) 14833df9f064SRobert Mustacchi return (ret); 14843df9f064SRobert Mustacchi 14853df9f064SRobert Mustacchi switch (tag) { 14863df9f064SRobert Mustacchi case DW_TAG_union_type: 14873df9f064SRobert Mustacchi case DW_TAG_structure_type: 14883df9f064SRobert Mustacchi ret = ctf_dwarf_convert_type(cup, child, NULL, 14893df9f064SRobert Mustacchi CTF_ADD_NONROOT); 14903df9f064SRobert Mustacchi if (ret != 0) { 14913df9f064SRobert Mustacchi return (ret); 14923df9f064SRobert Mustacchi } 14933df9f064SRobert Mustacchi break; 14943df9f064SRobert Mustacchi default: 14953df9f064SRobert Mustacchi break; 14963df9f064SRobert Mustacchi } 14973df9f064SRobert Mustacchi 14983df9f064SRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, child, &sib)) != 0) 14993df9f064SRobert Mustacchi return (ret); 15003df9f064SRobert Mustacchi child = sib; 15013df9f064SRobert Mustacchi } 1502bc1f688bSRobert Mustacchi 1503bc1f688bSRobert Mustacchi return (0); 1504bc1f688bSRobert Mustacchi } 1505bc1f688bSRobert Mustacchi 15065f977267SJason King static int 15075f977267SJason King ctf_dwarf_array_upper_bound(ctf_cu_t *cup, Dwarf_Die range, ctf_arinfo_t *ar) 15085f977267SJason King { 15095f977267SJason King Dwarf_Attribute attr; 15105f977267SJason King Dwarf_Unsigned uval; 15115f977267SJason King Dwarf_Signed sval; 15125f977267SJason King Dwarf_Half form; 15135f977267SJason King Dwarf_Error derr; 15145f977267SJason King const char *formstr = NULL; 151511551c95SRobert Mustacchi uint_t adj = 0; 15165f977267SJason King int ret = 0; 15175f977267SJason King 15185f977267SJason King ctf_dprintf("setting array upper bound\n"); 15195f977267SJason King 15205f977267SJason King ar->ctr_nelems = 0; 15215f977267SJason King 15225f977267SJason King /* 152311551c95SRobert Mustacchi * Different compilers use different attributes to indicate the size of 152411551c95SRobert Mustacchi * an array. GCC has traditionally used DW_AT_upper_bound, while Clang 152511551c95SRobert Mustacchi * uses DW_AT_count. They have slightly different semantics. DW_AT_count 152611551c95SRobert Mustacchi * indicates the total number of elements that are present, while 152711551c95SRobert Mustacchi * DW_AT_upper_bound indicates the last index, hence we need to add one 152811551c95SRobert Mustacchi * to that index to get the count. 152911551c95SRobert Mustacchi * 153011551c95SRobert Mustacchi * We first search for DW_AT_count and then for DW_AT_upper_bound. If we 153111551c95SRobert Mustacchi * find neither, then we treat the lack of this as a zero element array. 153211551c95SRobert Mustacchi * Our value is initialized assuming we find a DW_AT_count value. 15335f977267SJason King */ 153411551c95SRobert Mustacchi ret = ctf_dwarf_attribute(cup, range, DW_AT_count, &attr); 153511551c95SRobert Mustacchi if (ret != 0 && ret != ENOENT) { 15365f977267SJason King return (ret); 153711551c95SRobert Mustacchi } else if (ret == ENOENT) { 153811551c95SRobert Mustacchi ret = ctf_dwarf_attribute(cup, range, DW_AT_upper_bound, &attr); 153911551c95SRobert Mustacchi if (ret != 0 && ret != ENOENT) { 154011551c95SRobert Mustacchi return (ret); 154111551c95SRobert Mustacchi } else if (ret == ENOENT) { 154211551c95SRobert Mustacchi return (0); 154311551c95SRobert Mustacchi } else { 154411551c95SRobert Mustacchi adj = 1; 154511551c95SRobert Mustacchi } 15465f977267SJason King } 15475f977267SJason King 15485f977267SJason King if (dwarf_whatform(attr, &form, &derr) != DW_DLV_OK) { 15495f977267SJason King (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 15505f977267SJason King "failed to get DW_AT_upper_bound attribute form: %s\n", 15515f977267SJason King dwarf_errmsg(derr)); 15525f977267SJason King ret = ECTF_CONVBKERR; 15535f977267SJason King goto done; 15545f977267SJason King } 15555f977267SJason King 15565f977267SJason King /* 15575f977267SJason King * Compilers can indicate array bounds using signed or unsigned values. 15585f977267SJason King * Additionally, some compilers may also store the array bounds 15595f977267SJason King * using as DW_FORM_data{1,2,4,8} (which DWARF treats as raw data and 15605f977267SJason King * expects the caller to understand how to interpret the value). 15615f977267SJason King * 15625f977267SJason King * GCC 4.4.4 appears to always use unsigned values to encode the 15635f977267SJason King * array size (using '(unsigned)-1' to represent a zero-length or 15645f977267SJason King * unknown length array). Later versions of GCC use a signed value of 15655f977267SJason King * -1 for zero/unknown length arrays, and unsigned values to encode 15665f977267SJason King * known array sizes. 15675f977267SJason King * 15685f977267SJason King * Both dwarf_formsdata() and dwarf_formudata() will retrieve values 15695f977267SJason King * as their respective signed/unsigned forms, but both will also 15705f977267SJason King * retreive DW_FORM_data{1,2,4,8} values and treat them as signed or 15715f977267SJason King * unsigned integers (i.e. dwarf_formsdata() treats DW_FORM_dataXX 15725f977267SJason King * as signed integers and dwarf_formudata() treats DW_FORM_dataXX as 15735f977267SJason King * unsigned integers). Both will return an error if the form is not 15745f977267SJason King * their respective signed/unsigned form, or DW_FORM_dataXX. 15755f977267SJason King * 15765f977267SJason King * To obtain the upper bound, we use the appropriate 15775f977267SJason King * dwarf_form[su]data() function based on the form of DW_AT_upper_bound. 15785f977267SJason King * Additionally, we let dwarf_formudata() handle the DW_FORM_dataXX 15795f977267SJason King * forms (via the default option in the switch). If the value is in an 15805f977267SJason King * unexpected form (i.e. not DW_FORM_udata or DW_FORM_dataXX), 15815f977267SJason King * dwarf_formudata() will return failure (i.e. not DW_DLV_OK) and set 15825f977267SJason King * derr with the specific error value. 15835f977267SJason King */ 15845f977267SJason King switch (form) { 15855f977267SJason King case DW_FORM_sdata: 15865f977267SJason King if (dwarf_formsdata(attr, &sval, &derr) == DW_DLV_OK) { 158711551c95SRobert Mustacchi ar->ctr_nelems = sval + adj; 15885f977267SJason King goto done; 15895f977267SJason King } 15905f977267SJason King break; 15915f977267SJason King case DW_FORM_udata: 15925f977267SJason King default: 15935f977267SJason King if (dwarf_formudata(attr, &uval, &derr) == DW_DLV_OK) { 159411551c95SRobert Mustacchi ar->ctr_nelems = uval + adj; 15955f977267SJason King goto done; 15965f977267SJason King } 15975f977267SJason King break; 15985f977267SJason King } 15995f977267SJason King 16005f977267SJason King if (dwarf_get_FORM_name(form, &formstr) != DW_DLV_OK) 16015f977267SJason King formstr = "unknown DWARF form"; 16025f977267SJason King 16035f977267SJason King (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 16045f977267SJason King "failed to get %s (%hu) value for DW_AT_upper_bound: %s\n", 16055f977267SJason King formstr, form, dwarf_errmsg(derr)); 16065f977267SJason King ret = ECTF_CONVBKERR; 16075f977267SJason King 16085f977267SJason King done: 16095f977267SJason King dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 16105f977267SJason King return (ret); 16115f977267SJason King } 16125f977267SJason King 1613bc1f688bSRobert Mustacchi static int 1614bc1f688bSRobert Mustacchi ctf_dwarf_create_array_range(ctf_cu_t *cup, Dwarf_Die range, ctf_id_t *idp, 1615bc1f688bSRobert Mustacchi ctf_id_t base, int isroot) 1616bc1f688bSRobert Mustacchi { 1617bc1f688bSRobert Mustacchi int ret; 1618bc1f688bSRobert Mustacchi Dwarf_Die sib; 1619bc1f688bSRobert Mustacchi ctf_arinfo_t ar; 1620bc1f688bSRobert Mustacchi 1621bc1f688bSRobert Mustacchi ctf_dprintf("creating array range\n"); 1622bc1f688bSRobert Mustacchi 1623bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, range, &sib)) != 0) 1624bc1f688bSRobert Mustacchi return (ret); 1625bc1f688bSRobert Mustacchi if (sib != NULL) { 1626bc1f688bSRobert Mustacchi ctf_id_t id; 1627bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_create_array_range(cup, sib, &id, 1628bc1f688bSRobert Mustacchi base, CTF_ADD_NONROOT)) != 0) 1629bc1f688bSRobert Mustacchi return (ret); 1630bc1f688bSRobert Mustacchi ar.ctr_contents = id; 1631bc1f688bSRobert Mustacchi } else { 1632bc1f688bSRobert Mustacchi ar.ctr_contents = base; 1633bc1f688bSRobert Mustacchi } 1634bc1f688bSRobert Mustacchi 1635bc1f688bSRobert Mustacchi if ((ar.ctr_index = ctf_dwarf_long(cup)) == CTF_ERR) 1636bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1637bc1f688bSRobert Mustacchi 16385f977267SJason King if ((ret = ctf_dwarf_array_upper_bound(cup, range, &ar)) != 0) 1639bc1f688bSRobert Mustacchi return (ret); 1640bc1f688bSRobert Mustacchi 1641bc1f688bSRobert Mustacchi if ((*idp = ctf_add_array(cup->cu_ctfp, isroot, &ar)) == CTF_ERR) 1642bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1643bc1f688bSRobert Mustacchi 1644bc1f688bSRobert Mustacchi return (0); 1645bc1f688bSRobert Mustacchi } 1646bc1f688bSRobert Mustacchi 1647bc1f688bSRobert Mustacchi /* 1648bc1f688bSRobert Mustacchi * Try and create an array type. First, the kind of the array is specified in 1649bc1f688bSRobert Mustacchi * the DW_AT_type entry. Next, the number of entries is stored in a more 1650bc1f688bSRobert Mustacchi * complicated form, we should have a child that has the DW_TAG_subrange type. 1651bc1f688bSRobert Mustacchi */ 1652bc1f688bSRobert Mustacchi static int 1653bc1f688bSRobert Mustacchi ctf_dwarf_create_array(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot) 1654bc1f688bSRobert Mustacchi { 1655bc1f688bSRobert Mustacchi int ret; 1656bc1f688bSRobert Mustacchi Dwarf_Die tdie, rdie; 1657bc1f688bSRobert Mustacchi ctf_id_t tid; 1658bc1f688bSRobert Mustacchi Dwarf_Half rtag; 1659bc1f688bSRobert Mustacchi 1660bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) 1661bc1f688bSRobert Mustacchi return (ret); 1662bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &tid, 1663bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1664bc1f688bSRobert Mustacchi return (ret); 1665bc1f688bSRobert Mustacchi 1666bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &rdie)) != 0) 1667bc1f688bSRobert Mustacchi return (ret); 1668bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, rdie, &rtag)) != 0) 1669bc1f688bSRobert Mustacchi return (ret); 1670bc1f688bSRobert Mustacchi if (rtag != DW_TAG_subrange_type) { 1671bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1672bc1f688bSRobert Mustacchi "encountered array without DW_TAG_subrange_type child\n"); 1673bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1674bc1f688bSRobert Mustacchi } 1675bc1f688bSRobert Mustacchi 1676bc1f688bSRobert Mustacchi /* 1677bc1f688bSRobert Mustacchi * The compiler may opt to describe a multi-dimensional array as one 1678bc1f688bSRobert Mustacchi * giant array or it may opt to instead encode it as a series of 1679bc1f688bSRobert Mustacchi * subranges. If it's the latter, then for each subrange we introduce a 1680bc1f688bSRobert Mustacchi * type. We can always use the base type. 1681bc1f688bSRobert Mustacchi */ 1682bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_create_array_range(cup, rdie, idp, tid, 1683bc1f688bSRobert Mustacchi isroot)) != 0) 1684bc1f688bSRobert Mustacchi return (ret); 1685bc1f688bSRobert Mustacchi ctf_dprintf("Got back id %d\n", *idp); 1686bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, *idp, die, B_FALSE)); 1687bc1f688bSRobert Mustacchi } 1688bc1f688bSRobert Mustacchi 16896ef284f1SJohn Levon /* 16906ef284f1SJohn Levon * Given "const int const_array3[11]", GCC7 at least will create a DIE tree of 16916ef284f1SJohn Levon * DW_TAG_const_type:DW_TAG_array_type:DW_Tag_const_type:<member_type>. 16926ef284f1SJohn Levon * 16936ef284f1SJohn Levon * Given C's syntax, this renders out as "const const int const_array3[11]". To 16946ef284f1SJohn Levon * get closer to round-tripping (and make the unit tests work), we'll peek for 16956ef284f1SJohn Levon * this case, and avoid adding the extraneous qualifier if we see that the 16966ef284f1SJohn Levon * underlying array referent already has the same qualifier. 16976ef284f1SJohn Levon * 16986ef284f1SJohn Levon * This is unfortunately less trivial than it could be: this issue applies to 16996ef284f1SJohn Levon * qualifier sets like "const volatile", as well as multi-dimensional arrays, so 17006ef284f1SJohn Levon * we need to descend down those. 17016ef284f1SJohn Levon * 17026ef284f1SJohn Levon * Returns CTF_ERR on error, or a boolean value otherwise. 17036ef284f1SJohn Levon */ 17046ef284f1SJohn Levon static int 17056ef284f1SJohn Levon needed_array_qualifier(ctf_cu_t *cup, int kind, ctf_id_t ref_id) 17066ef284f1SJohn Levon { 17076ef284f1SJohn Levon const ctf_type_t *t; 17086ef284f1SJohn Levon ctf_arinfo_t arinfo; 17096ef284f1SJohn Levon int akind; 17106ef284f1SJohn Levon 17116ef284f1SJohn Levon if (kind != CTF_K_CONST && kind != CTF_K_VOLATILE && 17126ef284f1SJohn Levon kind != CTF_K_RESTRICT) 17136ef284f1SJohn Levon return (1); 17146ef284f1SJohn Levon 17156ef284f1SJohn Levon if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, ref_id)) == NULL) 17166ef284f1SJohn Levon return (CTF_ERR); 17176ef284f1SJohn Levon 17186ef284f1SJohn Levon if (LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info) != CTF_K_ARRAY) 17196ef284f1SJohn Levon return (1); 17206ef284f1SJohn Levon 17216ef284f1SJohn Levon if (ctf_dyn_array_info(cup->cu_ctfp, ref_id, &arinfo) != 0) 17226ef284f1SJohn Levon return (CTF_ERR); 17236ef284f1SJohn Levon 17246ef284f1SJohn Levon ctf_id_t id = arinfo.ctr_contents; 17256ef284f1SJohn Levon 17266ef284f1SJohn Levon for (;;) { 17276ef284f1SJohn Levon if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, id)) == NULL) 17286ef284f1SJohn Levon return (CTF_ERR); 17296ef284f1SJohn Levon 17306ef284f1SJohn Levon akind = LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info); 17316ef284f1SJohn Levon 17326ef284f1SJohn Levon if (akind == kind) 17336ef284f1SJohn Levon break; 17346ef284f1SJohn Levon 17356ef284f1SJohn Levon if (akind == CTF_K_ARRAY) { 17366ef284f1SJohn Levon if (ctf_dyn_array_info(cup->cu_ctfp, 17376ef284f1SJohn Levon id, &arinfo) != 0) 17386ef284f1SJohn Levon return (CTF_ERR); 17396ef284f1SJohn Levon id = arinfo.ctr_contents; 17406ef284f1SJohn Levon continue; 17416ef284f1SJohn Levon } 17426ef284f1SJohn Levon 17436ef284f1SJohn Levon if (akind != CTF_K_CONST && akind != CTF_K_VOLATILE && 17446ef284f1SJohn Levon akind != CTF_K_RESTRICT) 17456ef284f1SJohn Levon break; 17466ef284f1SJohn Levon 17476ef284f1SJohn Levon id = t->ctt_type; 17486ef284f1SJohn Levon } 17496ef284f1SJohn Levon 17506ef284f1SJohn Levon if (kind == akind) { 17516ef284f1SJohn Levon ctf_dprintf("ignoring extraneous %s qualifier for array %d\n", 17526ef284f1SJohn Levon ctf_kind_name(cup->cu_ctfp, kind), ref_id); 17536ef284f1SJohn Levon } 17546ef284f1SJohn Levon 17556ef284f1SJohn Levon return (kind != akind); 17566ef284f1SJohn Levon } 17576ef284f1SJohn Levon 1758bc1f688bSRobert Mustacchi static int 1759bc1f688bSRobert Mustacchi ctf_dwarf_create_reference(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, 1760bc1f688bSRobert Mustacchi int kind, int isroot) 1761bc1f688bSRobert Mustacchi { 1762bc1f688bSRobert Mustacchi int ret; 1763bc1f688bSRobert Mustacchi ctf_id_t id; 1764bc1f688bSRobert Mustacchi Dwarf_Die tdie; 1765bc1f688bSRobert Mustacchi char *name; 1766bc1f688bSRobert Mustacchi size_t namelen; 1767bc1f688bSRobert Mustacchi 1768bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 1769bc1f688bSRobert Mustacchi ret != ENOENT) 1770bc1f688bSRobert Mustacchi return (ret); 1771bc1f688bSRobert Mustacchi if (ret == ENOENT) { 1772bc1f688bSRobert Mustacchi name = NULL; 1773bc1f688bSRobert Mustacchi namelen = 0; 1774bc1f688bSRobert Mustacchi } else { 1775bc1f688bSRobert Mustacchi namelen = strlen(name); 1776bc1f688bSRobert Mustacchi } 1777bc1f688bSRobert Mustacchi 1778bc1f688bSRobert Mustacchi ctf_dprintf("reference kind %d %s\n", kind, name != NULL ? name : "<>"); 1779bc1f688bSRobert Mustacchi 1780bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) { 1781bc1f688bSRobert Mustacchi if (ret != ENOENT) { 1782bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1783bc1f688bSRobert Mustacchi return (ret); 1784bc1f688bSRobert Mustacchi } 1785bc1f688bSRobert Mustacchi if ((id = ctf_dwarf_void(cup)) == CTF_ERR) { 1786bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1787bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1788bc1f688bSRobert Mustacchi } 1789bc1f688bSRobert Mustacchi } else { 1790bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &id, 1791bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) { 1792bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1793bc1f688bSRobert Mustacchi return (ret); 1794bc1f688bSRobert Mustacchi } 1795bc1f688bSRobert Mustacchi } 1796bc1f688bSRobert Mustacchi 17976ef284f1SJohn Levon if ((ret = needed_array_qualifier(cup, kind, id)) <= 0) { 17986ef284f1SJohn Levon if (ret != 0) { 17996ef284f1SJohn Levon ret = (ctf_errno(cup->cu_ctfp)); 18006ef284f1SJohn Levon } else { 18016ef284f1SJohn Levon *idp = id; 18026ef284f1SJohn Levon } 18036ef284f1SJohn Levon 18046ef284f1SJohn Levon ctf_free(name, namelen); 18056ef284f1SJohn Levon return (ret); 18066ef284f1SJohn Levon } 18076ef284f1SJohn Levon 1808bc1f688bSRobert Mustacchi if ((*idp = ctf_add_reftype(cup->cu_ctfp, isroot, name, id, kind)) == 1809bc1f688bSRobert Mustacchi CTF_ERR) { 1810bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1811bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1812bc1f688bSRobert Mustacchi } 1813bc1f688bSRobert Mustacchi 1814bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1815bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, *idp, die, B_FALSE)); 1816bc1f688bSRobert Mustacchi } 1817bc1f688bSRobert Mustacchi 1818fe2dc8bdSJohn Levon static int 1819fe2dc8bdSJohn Levon ctf_dwarf_create_enum(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot) 1820fe2dc8bdSJohn Levon { 1821fe2dc8bdSJohn Levon size_t size = 0; 1822bc1f688bSRobert Mustacchi Dwarf_Die child; 182356f23fa0SRobert Mustacchi Dwarf_Unsigned dw; 1824fe2dc8bdSJohn Levon ctf_id_t id; 1825bc1f688bSRobert Mustacchi char *name; 1826fe2dc8bdSJohn Levon int ret; 1827bc1f688bSRobert Mustacchi 1828bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 1829bc1f688bSRobert Mustacchi ret != ENOENT) 1830bc1f688bSRobert Mustacchi return (ret); 1831bc1f688bSRobert Mustacchi if (ret == ENOENT) 1832bc1f688bSRobert Mustacchi name = NULL; 1833fe2dc8bdSJohn Levon 183456f23fa0SRobert Mustacchi /* 183556f23fa0SRobert Mustacchi * Enumerations may have a size associated with them, particularly if 183656f23fa0SRobert Mustacchi * they're packed. Note, a Dwarf_Unsigned is larger than a size_t on an 183756f23fa0SRobert Mustacchi * ILP32 system. 183856f23fa0SRobert Mustacchi */ 183956f23fa0SRobert Mustacchi if (ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &dw) == 0 && 184056f23fa0SRobert Mustacchi dw < SIZE_MAX) { 184156f23fa0SRobert Mustacchi size = (size_t)dw; 184256f23fa0SRobert Mustacchi } 1843fe2dc8bdSJohn Levon 1844fe2dc8bdSJohn Levon id = ctf_add_enum(cup->cu_ctfp, isroot, name, size); 1845bc1f688bSRobert Mustacchi ctf_dprintf("added enum %s (%d)\n", name, id); 1846bc1f688bSRobert Mustacchi if (name != NULL) 1847bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1848bc1f688bSRobert Mustacchi if (id == CTF_ERR) 1849bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1850bc1f688bSRobert Mustacchi *idp = id; 1851bc1f688bSRobert Mustacchi if ((ret = ctf_dwmap_add(cup, id, die, B_FALSE)) != 0) 1852bc1f688bSRobert Mustacchi return (ret); 1853bc1f688bSRobert Mustacchi 1854bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) { 1855bc1f688bSRobert Mustacchi if (ret == ENOENT) 1856bc1f688bSRobert Mustacchi ret = 0; 1857bc1f688bSRobert Mustacchi return (ret); 1858bc1f688bSRobert Mustacchi } 1859bc1f688bSRobert Mustacchi 1860bc1f688bSRobert Mustacchi while (child != NULL) { 1861bc1f688bSRobert Mustacchi Dwarf_Half tag; 1862bc1f688bSRobert Mustacchi Dwarf_Signed sval; 1863bc1f688bSRobert Mustacchi Dwarf_Unsigned uval; 1864bc1f688bSRobert Mustacchi Dwarf_Die arg = child; 1865bc1f688bSRobert Mustacchi int eval; 1866bc1f688bSRobert Mustacchi 1867bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, arg, &child)) != 0) 1868bc1f688bSRobert Mustacchi return (ret); 1869bc1f688bSRobert Mustacchi 1870bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0) 1871bc1f688bSRobert Mustacchi return (ret); 1872bc1f688bSRobert Mustacchi 1873bc1f688bSRobert Mustacchi if (tag != DW_TAG_enumerator) { 1874bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, arg, NULL, 1875bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1876bc1f688bSRobert Mustacchi return (ret); 1877bc1f688bSRobert Mustacchi continue; 1878bc1f688bSRobert Mustacchi } 1879bc1f688bSRobert Mustacchi 1880bc1f688bSRobert Mustacchi /* 1881bc1f688bSRobert Mustacchi * DWARF v4 section 5.7 tells us we'll always have names. 1882bc1f688bSRobert Mustacchi */ 1883bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, arg, DW_AT_name, &name)) != 0) 1884bc1f688bSRobert Mustacchi return (ret); 1885bc1f688bSRobert Mustacchi 1886bc1f688bSRobert Mustacchi /* 1887bc1f688bSRobert Mustacchi * We have to be careful here: newer GCCs generate DWARF where 1888bc1f688bSRobert Mustacchi * an unsigned value will happily pass ctf_dwarf_signed(). 1889bc1f688bSRobert Mustacchi * Since negative values will fail ctf_dwarf_unsigned(), we try 1890bc1f688bSRobert Mustacchi * that first to make sure we get the right value. 1891bc1f688bSRobert Mustacchi */ 1892bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, arg, DW_AT_const_value, 1893bc1f688bSRobert Mustacchi &uval)) == 0) { 1894bc1f688bSRobert Mustacchi eval = (int)uval; 1895bc1f688bSRobert Mustacchi } else if ((ret = ctf_dwarf_signed(cup, arg, DW_AT_const_value, 1896bc1f688bSRobert Mustacchi &sval)) == 0) { 1897bc1f688bSRobert Mustacchi eval = sval; 1898bc1f688bSRobert Mustacchi } 1899bc1f688bSRobert Mustacchi 1900bc1f688bSRobert Mustacchi if (ret != 0) { 1901bc1f688bSRobert Mustacchi if (ret != ENOENT) 1902bc1f688bSRobert Mustacchi return (ret); 1903bc1f688bSRobert Mustacchi 1904bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1905bc1f688bSRobert Mustacchi "encountered enumeration without constant value\n"); 1906bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1907bc1f688bSRobert Mustacchi } 1908bc1f688bSRobert Mustacchi 1909bc1f688bSRobert Mustacchi ret = ctf_add_enumerator(cup->cu_ctfp, id, name, eval); 1910bc1f688bSRobert Mustacchi if (ret == CTF_ERR) { 1911bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1912bc1f688bSRobert Mustacchi "failed to add enumarator %s (%d) to %d\n", 1913bc1f688bSRobert Mustacchi name, eval, id); 1914bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1915bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1916bc1f688bSRobert Mustacchi } 1917bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1918bc1f688bSRobert Mustacchi } 1919bc1f688bSRobert Mustacchi 1920bc1f688bSRobert Mustacchi return (0); 1921bc1f688bSRobert Mustacchi } 1922bc1f688bSRobert Mustacchi 1923bc1f688bSRobert Mustacchi /* 1924bc1f688bSRobert Mustacchi * For a function pointer, walk over and process all of its children, unless we 1925bc1f688bSRobert Mustacchi * encounter one that's just a declaration. In which case, we error on it. 1926bc1f688bSRobert Mustacchi */ 1927bc1f688bSRobert Mustacchi static int 1928bc1f688bSRobert Mustacchi ctf_dwarf_create_fptr(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot) 1929bc1f688bSRobert Mustacchi { 1930bc1f688bSRobert Mustacchi int ret; 1931bc1f688bSRobert Mustacchi Dwarf_Bool b; 1932bc1f688bSRobert Mustacchi ctf_funcinfo_t fi; 1933bc1f688bSRobert Mustacchi Dwarf_Die retdie; 1934bc1f688bSRobert Mustacchi ctf_id_t *argv = NULL; 1935bc1f688bSRobert Mustacchi 1936bc1f688bSRobert Mustacchi bzero(&fi, sizeof (ctf_funcinfo_t)); 1937bc1f688bSRobert Mustacchi 1938bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) { 1939bc1f688bSRobert Mustacchi if (ret != ENOENT) 1940bc1f688bSRobert Mustacchi return (ret); 1941bc1f688bSRobert Mustacchi } else { 1942bc1f688bSRobert Mustacchi if (b != 0) 1943bc1f688bSRobert Mustacchi return (EPROTOTYPE); 1944bc1f688bSRobert Mustacchi } 1945bc1f688bSRobert Mustacchi 1946bc1f688bSRobert Mustacchi /* 1947bc1f688bSRobert Mustacchi * Return type is in DW_AT_type, if none, it returns void. 1948bc1f688bSRobert Mustacchi */ 1949bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &retdie)) != 0) { 1950bc1f688bSRobert Mustacchi if (ret != ENOENT) 1951bc1f688bSRobert Mustacchi return (ret); 1952bc1f688bSRobert Mustacchi if ((fi.ctc_return = ctf_dwarf_void(cup)) == CTF_ERR) 1953bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1954bc1f688bSRobert Mustacchi } else { 1955bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, retdie, &fi.ctc_return, 1956bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1957bc1f688bSRobert Mustacchi return (ret); 1958bc1f688bSRobert Mustacchi } 1959bc1f688bSRobert Mustacchi 1960bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_function_count(cup, die, &fi, B_TRUE)) != 0) { 1961bc1f688bSRobert Mustacchi return (ret); 1962bc1f688bSRobert Mustacchi } 1963bc1f688bSRobert Mustacchi 1964bc1f688bSRobert Mustacchi if (fi.ctc_argc != 0) { 1965bc1f688bSRobert Mustacchi argv = ctf_alloc(sizeof (ctf_id_t) * fi.ctc_argc); 1966bc1f688bSRobert Mustacchi if (argv == NULL) 1967bc1f688bSRobert Mustacchi return (ENOMEM); 1968bc1f688bSRobert Mustacchi 1969bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_fargs(cup, die, &fi, argv)) != 0) { 1970bc1f688bSRobert Mustacchi ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc); 1971bc1f688bSRobert Mustacchi return (ret); 1972bc1f688bSRobert Mustacchi } 1973bc1f688bSRobert Mustacchi } 1974bc1f688bSRobert Mustacchi 1975bc1f688bSRobert Mustacchi if ((*idp = ctf_add_funcptr(cup->cu_ctfp, isroot, &fi, argv)) == 1976bc1f688bSRobert Mustacchi CTF_ERR) { 1977bc1f688bSRobert Mustacchi ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc); 1978bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1979bc1f688bSRobert Mustacchi } 1980bc1f688bSRobert Mustacchi 1981bc1f688bSRobert Mustacchi ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc); 1982bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, *idp, die, B_FALSE)); 1983bc1f688bSRobert Mustacchi } 1984bc1f688bSRobert Mustacchi 1985bc1f688bSRobert Mustacchi static int 1986bc1f688bSRobert Mustacchi ctf_dwarf_convert_type(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, 1987bc1f688bSRobert Mustacchi int isroot) 1988bc1f688bSRobert Mustacchi { 1989bc1f688bSRobert Mustacchi int ret; 1990bc1f688bSRobert Mustacchi Dwarf_Off offset; 1991bc1f688bSRobert Mustacchi Dwarf_Half tag; 1992bc1f688bSRobert Mustacchi ctf_dwmap_t lookup, *map; 1993bc1f688bSRobert Mustacchi ctf_id_t id; 1994bc1f688bSRobert Mustacchi 1995bc1f688bSRobert Mustacchi if (idp == NULL) 1996bc1f688bSRobert Mustacchi idp = &id; 1997bc1f688bSRobert Mustacchi 1998bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0) 1999bc1f688bSRobert Mustacchi return (ret); 2000bc1f688bSRobert Mustacchi 2001bc1f688bSRobert Mustacchi if (offset > cup->cu_maxoff) { 2002bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 2003bc1f688bSRobert Mustacchi "die offset %llu beyond maximum for header %llu\n", 2004bc1f688bSRobert Mustacchi offset, cup->cu_maxoff); 2005bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 2006bc1f688bSRobert Mustacchi } 2007bc1f688bSRobert Mustacchi 2008bc1f688bSRobert Mustacchi /* 2009bc1f688bSRobert Mustacchi * If we've already added an entry for this offset, then we're done. 2010bc1f688bSRobert Mustacchi */ 2011bc1f688bSRobert Mustacchi lookup.cdm_off = offset; 2012bc1f688bSRobert Mustacchi if ((map = avl_find(&cup->cu_map, &lookup, NULL)) != NULL) { 2013bc1f688bSRobert Mustacchi *idp = map->cdm_id; 2014bc1f688bSRobert Mustacchi return (0); 2015bc1f688bSRobert Mustacchi } 2016bc1f688bSRobert Mustacchi 2017bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0) 2018bc1f688bSRobert Mustacchi return (ret); 2019bc1f688bSRobert Mustacchi 2020bc1f688bSRobert Mustacchi ret = ENOTSUP; 2021bc1f688bSRobert Mustacchi switch (tag) { 2022bc1f688bSRobert Mustacchi case DW_TAG_base_type: 2023bc1f688bSRobert Mustacchi ctf_dprintf("base\n"); 2024bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_base(cup, die, idp, isroot, offset); 2025bc1f688bSRobert Mustacchi break; 2026bc1f688bSRobert Mustacchi case DW_TAG_array_type: 2027bc1f688bSRobert Mustacchi ctf_dprintf("array\n"); 2028bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_array(cup, die, idp, isroot); 2029bc1f688bSRobert Mustacchi break; 2030bc1f688bSRobert Mustacchi case DW_TAG_enumeration_type: 2031bc1f688bSRobert Mustacchi ctf_dprintf("enum\n"); 2032bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_enum(cup, die, idp, isroot); 2033bc1f688bSRobert Mustacchi break; 2034bc1f688bSRobert Mustacchi case DW_TAG_pointer_type: 2035bc1f688bSRobert Mustacchi ctf_dprintf("pointer\n"); 2036bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_POINTER, 2037bc1f688bSRobert Mustacchi isroot); 2038bc1f688bSRobert Mustacchi break; 2039bc1f688bSRobert Mustacchi case DW_TAG_structure_type: 2040bc1f688bSRobert Mustacchi ctf_dprintf("struct\n"); 2041bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_STRUCT, 2042bc1f688bSRobert Mustacchi isroot); 2043bc1f688bSRobert Mustacchi break; 2044bc1f688bSRobert Mustacchi case DW_TAG_subroutine_type: 2045bc1f688bSRobert Mustacchi ctf_dprintf("fptr\n"); 2046bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_fptr(cup, die, idp, isroot); 2047bc1f688bSRobert Mustacchi break; 2048bc1f688bSRobert Mustacchi case DW_TAG_typedef: 2049bc1f688bSRobert Mustacchi ctf_dprintf("typedef\n"); 2050bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_TYPEDEF, 2051bc1f688bSRobert Mustacchi isroot); 2052bc1f688bSRobert Mustacchi break; 2053bc1f688bSRobert Mustacchi case DW_TAG_union_type: 2054bc1f688bSRobert Mustacchi ctf_dprintf("union\n"); 2055bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_UNION, 2056bc1f688bSRobert Mustacchi isroot); 2057bc1f688bSRobert Mustacchi break; 2058bc1f688bSRobert Mustacchi case DW_TAG_const_type: 2059bc1f688bSRobert Mustacchi ctf_dprintf("const\n"); 2060bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_CONST, 2061bc1f688bSRobert Mustacchi isroot); 2062bc1f688bSRobert Mustacchi break; 2063bc1f688bSRobert Mustacchi case DW_TAG_volatile_type: 2064bc1f688bSRobert Mustacchi ctf_dprintf("volatile\n"); 2065bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_VOLATILE, 2066bc1f688bSRobert Mustacchi isroot); 2067bc1f688bSRobert Mustacchi break; 2068bc1f688bSRobert Mustacchi case DW_TAG_restrict_type: 2069bc1f688bSRobert Mustacchi ctf_dprintf("restrict\n"); 2070bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_RESTRICT, 2071bc1f688bSRobert Mustacchi isroot); 2072bc1f688bSRobert Mustacchi break; 2073bc1f688bSRobert Mustacchi default: 2074bc1f688bSRobert Mustacchi ctf_dprintf("ignoring tag type %x\n", tag); 20753eca6103SJohn Levon *idp = CTF_ERR; 2076bc1f688bSRobert Mustacchi ret = 0; 2077bc1f688bSRobert Mustacchi break; 2078bc1f688bSRobert Mustacchi } 2079bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_convert_type tag specific handler returned %d\n", 2080bc1f688bSRobert Mustacchi ret); 2081bc1f688bSRobert Mustacchi 2082bc1f688bSRobert Mustacchi return (ret); 2083bc1f688bSRobert Mustacchi } 2084bc1f688bSRobert Mustacchi 2085bc1f688bSRobert Mustacchi static int 2086bc1f688bSRobert Mustacchi ctf_dwarf_walk_lexical(ctf_cu_t *cup, Dwarf_Die die) 2087bc1f688bSRobert Mustacchi { 2088bc1f688bSRobert Mustacchi int ret; 2089bc1f688bSRobert Mustacchi Dwarf_Die child; 2090bc1f688bSRobert Mustacchi 2091bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 2092bc1f688bSRobert Mustacchi return (ret); 2093bc1f688bSRobert Mustacchi 2094bc1f688bSRobert Mustacchi if (child == NULL) 2095bc1f688bSRobert Mustacchi return (0); 2096bc1f688bSRobert Mustacchi 2097bc1f688bSRobert Mustacchi return (ctf_dwarf_convert_die(cup, die)); 2098bc1f688bSRobert Mustacchi } 2099bc1f688bSRobert Mustacchi 2100bc1f688bSRobert Mustacchi static int 2101bc1f688bSRobert Mustacchi ctf_dwarf_function_count(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip, 2102bc1f688bSRobert Mustacchi boolean_t fptr) 2103bc1f688bSRobert Mustacchi { 2104bc1f688bSRobert Mustacchi int ret; 2105bc1f688bSRobert Mustacchi Dwarf_Die child, sib, arg; 2106bc1f688bSRobert Mustacchi 2107bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 2108bc1f688bSRobert Mustacchi return (ret); 2109bc1f688bSRobert Mustacchi 2110bc1f688bSRobert Mustacchi arg = child; 2111bc1f688bSRobert Mustacchi while (arg != NULL) { 2112bc1f688bSRobert Mustacchi Dwarf_Half tag; 2113bc1f688bSRobert Mustacchi 2114bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0) 2115bc1f688bSRobert Mustacchi return (ret); 2116bc1f688bSRobert Mustacchi 2117bc1f688bSRobert Mustacchi /* 21186ef284f1SJohn Levon * We have to check for a varargs type declaration. This will 2119bc1f688bSRobert Mustacchi * happen in one of two ways. If we have a function pointer 2120bc1f688bSRobert Mustacchi * type, then it'll be done with a tag of type 2121bc1f688bSRobert Mustacchi * DW_TAG_unspecified_parameters. However, it only means we have 2122bc1f688bSRobert Mustacchi * a variable number of arguments, if we have more than one 2123bc1f688bSRobert Mustacchi * argument found so far. Otherwise, when we have a function 2124bc1f688bSRobert Mustacchi * type, it instead uses a formal parameter whose name is '...' 2125bc1f688bSRobert Mustacchi * to indicate a variable arguments member. 2126bc1f688bSRobert Mustacchi * 2127bc1f688bSRobert Mustacchi * Also, if we have a function pointer, then we have to expect 2128bc1f688bSRobert Mustacchi * that we might not get a name at all. 2129bc1f688bSRobert Mustacchi */ 2130bc1f688bSRobert Mustacchi if (tag == DW_TAG_formal_parameter && fptr == B_FALSE) { 2131bc1f688bSRobert Mustacchi char *name; 2132bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, 2133bc1f688bSRobert Mustacchi &name)) != 0) 2134bc1f688bSRobert Mustacchi return (ret); 2135bc1f688bSRobert Mustacchi if (strcmp(name, DWARF_VARARGS_NAME) == 0) 2136bc1f688bSRobert Mustacchi fip->ctc_flags |= CTF_FUNC_VARARG; 2137bc1f688bSRobert Mustacchi else 2138bc1f688bSRobert Mustacchi fip->ctc_argc++; 2139bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2140bc1f688bSRobert Mustacchi } else if (tag == DW_TAG_formal_parameter) { 2141bc1f688bSRobert Mustacchi fip->ctc_argc++; 2142bc1f688bSRobert Mustacchi } else if (tag == DW_TAG_unspecified_parameters && 2143bc1f688bSRobert Mustacchi fip->ctc_argc > 0) { 2144bc1f688bSRobert Mustacchi fip->ctc_flags |= CTF_FUNC_VARARG; 2145bc1f688bSRobert Mustacchi } 2146bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0) 2147bc1f688bSRobert Mustacchi return (ret); 2148bc1f688bSRobert Mustacchi arg = sib; 2149bc1f688bSRobert Mustacchi } 2150bc1f688bSRobert Mustacchi 2151bc1f688bSRobert Mustacchi return (0); 2152bc1f688bSRobert Mustacchi } 2153bc1f688bSRobert Mustacchi 2154bc1f688bSRobert Mustacchi static int 2155bc1f688bSRobert Mustacchi ctf_dwarf_convert_fargs(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip, 2156bc1f688bSRobert Mustacchi ctf_id_t *argv) 2157bc1f688bSRobert Mustacchi { 2158bc1f688bSRobert Mustacchi int ret; 2159bc1f688bSRobert Mustacchi int i = 0; 2160bc1f688bSRobert Mustacchi Dwarf_Die child, sib, arg; 2161bc1f688bSRobert Mustacchi 2162bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 2163bc1f688bSRobert Mustacchi return (ret); 2164bc1f688bSRobert Mustacchi 2165bc1f688bSRobert Mustacchi arg = child; 2166bc1f688bSRobert Mustacchi while (arg != NULL) { 2167bc1f688bSRobert Mustacchi Dwarf_Half tag; 2168bc1f688bSRobert Mustacchi 2169bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0) 2170bc1f688bSRobert Mustacchi return (ret); 2171bc1f688bSRobert Mustacchi if (tag == DW_TAG_formal_parameter) { 2172bc1f688bSRobert Mustacchi Dwarf_Die tdie; 2173bc1f688bSRobert Mustacchi 2174bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, arg, DW_AT_type, 2175bc1f688bSRobert Mustacchi &tdie)) != 0) 2176bc1f688bSRobert Mustacchi return (ret); 2177bc1f688bSRobert Mustacchi 2178bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &argv[i], 2179bc1f688bSRobert Mustacchi CTF_ADD_ROOT)) != 0) 2180bc1f688bSRobert Mustacchi return (ret); 2181bc1f688bSRobert Mustacchi i++; 2182bc1f688bSRobert Mustacchi 2183bc1f688bSRobert Mustacchi /* 2184bc1f688bSRobert Mustacchi * Once we hit argc entries, we're done. This ensures we 2185bc1f688bSRobert Mustacchi * don't accidentally hit a varargs which should be the 2186bc1f688bSRobert Mustacchi * last entry. 2187bc1f688bSRobert Mustacchi */ 2188bc1f688bSRobert Mustacchi if (i == fip->ctc_argc) 2189bc1f688bSRobert Mustacchi break; 2190bc1f688bSRobert Mustacchi } 2191bc1f688bSRobert Mustacchi 2192bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0) 2193bc1f688bSRobert Mustacchi return (ret); 2194bc1f688bSRobert Mustacchi arg = sib; 2195bc1f688bSRobert Mustacchi } 2196bc1f688bSRobert Mustacchi 2197bc1f688bSRobert Mustacchi return (0); 2198bc1f688bSRobert Mustacchi } 2199bc1f688bSRobert Mustacchi 2200bc1f688bSRobert Mustacchi static int 2201bc1f688bSRobert Mustacchi ctf_dwarf_convert_function(ctf_cu_t *cup, Dwarf_Die die) 2202bc1f688bSRobert Mustacchi { 2203bc1f688bSRobert Mustacchi ctf_dwfunc_t *cdf; 2204bc1f688bSRobert Mustacchi Dwarf_Die tdie; 22056ef284f1SJohn Levon Dwarf_Bool b; 22066ef284f1SJohn Levon char *name; 22076ef284f1SJohn Levon int ret; 2208bc1f688bSRobert Mustacchi 2209bc1f688bSRobert Mustacchi /* 2210bc1f688bSRobert Mustacchi * Functions that don't have a name are generally functions that have 2211bc1f688bSRobert Mustacchi * been inlined and thus most information about them has been lost. If 2212bc1f688bSRobert Mustacchi * we can't get a name, then instead of returning ENOENT, we silently 2213bc1f688bSRobert Mustacchi * swallow the error. 2214bc1f688bSRobert Mustacchi */ 2215bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0) { 2216bc1f688bSRobert Mustacchi if (ret == ENOENT) 2217bc1f688bSRobert Mustacchi return (0); 2218bc1f688bSRobert Mustacchi return (ret); 2219bc1f688bSRobert Mustacchi } 2220bc1f688bSRobert Mustacchi 22216ef284f1SJohn Levon ctf_dprintf("beginning work on function %s (die %llx)\n", 22226ef284f1SJohn Levon name, ctf_die_offset(die)); 22236ef284f1SJohn Levon 22246ef284f1SJohn Levon if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) { 22256ef284f1SJohn Levon if (ret != ENOENT) 22266ef284f1SJohn Levon return (ret); 22276ef284f1SJohn Levon } else if (b != 0) { 22286ef284f1SJohn Levon /* 22296ef284f1SJohn Levon * GCC7 at least creates empty DW_AT_declarations for functions 22306ef284f1SJohn Levon * defined in headers. As they lack details on the function 22316ef284f1SJohn Levon * prototype, we need to ignore them. If we later actually 22326ef284f1SJohn Levon * see the relevant function's definition, we will see another 22336ef284f1SJohn Levon * DW_TAG_subprogram that is more complete. 22346ef284f1SJohn Levon */ 22356ef284f1SJohn Levon ctf_dprintf("ignoring declaration of function %s (die %llx)\n", 22366ef284f1SJohn Levon name, ctf_die_offset(die)); 22376ef284f1SJohn Levon return (0); 22386ef284f1SJohn Levon } 22396ef284f1SJohn Levon 2240bc1f688bSRobert Mustacchi if ((cdf = ctf_alloc(sizeof (ctf_dwfunc_t))) == NULL) { 2241bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2242bc1f688bSRobert Mustacchi return (ENOMEM); 2243bc1f688bSRobert Mustacchi } 2244bc1f688bSRobert Mustacchi bzero(cdf, sizeof (ctf_dwfunc_t)); 2245bc1f688bSRobert Mustacchi cdf->cdf_name = name; 2246bc1f688bSRobert Mustacchi 2247bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) == 0) { 2248bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, 2249bc1f688bSRobert Mustacchi &(cdf->cdf_fip.ctc_return), CTF_ADD_ROOT)) != 0) { 2250bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2251bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2252bc1f688bSRobert Mustacchi return (ret); 2253bc1f688bSRobert Mustacchi } 2254bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 2255bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2256bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2257bc1f688bSRobert Mustacchi return (ret); 2258bc1f688bSRobert Mustacchi } else { 2259bc1f688bSRobert Mustacchi if ((cdf->cdf_fip.ctc_return = ctf_dwarf_void(cup)) == 2260bc1f688bSRobert Mustacchi CTF_ERR) { 2261bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2262bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2263bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2264bc1f688bSRobert Mustacchi } 2265bc1f688bSRobert Mustacchi } 2266bc1f688bSRobert Mustacchi 2267bc1f688bSRobert Mustacchi /* 2268bc1f688bSRobert Mustacchi * A function has a number of children, some of which may not be ones we 2269bc1f688bSRobert Mustacchi * care about. Children that we care about have a type of 2270bc1f688bSRobert Mustacchi * DW_TAG_formal_parameter. We're going to do two passes, the first to 2271bc1f688bSRobert Mustacchi * count the arguments, the second to process them. Afterwards, we 2272bc1f688bSRobert Mustacchi * should be good to go ahead and add this function. 2273bc1f688bSRobert Mustacchi * 2274bc1f688bSRobert Mustacchi * Note, we already got the return type by going in and grabbing it out 2275bc1f688bSRobert Mustacchi * of the DW_AT_type. 2276bc1f688bSRobert Mustacchi */ 2277bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_function_count(cup, die, &cdf->cdf_fip, 2278bc1f688bSRobert Mustacchi B_FALSE)) != 0) { 2279bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2280bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2281bc1f688bSRobert Mustacchi return (ret); 2282bc1f688bSRobert Mustacchi } 2283bc1f688bSRobert Mustacchi 2284bc1f688bSRobert Mustacchi ctf_dprintf("beginning to convert function arguments %s\n", name); 2285bc1f688bSRobert Mustacchi if (cdf->cdf_fip.ctc_argc != 0) { 2286bc1f688bSRobert Mustacchi uint_t argc = cdf->cdf_fip.ctc_argc; 2287bc1f688bSRobert Mustacchi cdf->cdf_argv = ctf_alloc(sizeof (ctf_id_t) * argc); 2288bc1f688bSRobert Mustacchi if (cdf->cdf_argv == NULL) { 2289bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2290bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2291bc1f688bSRobert Mustacchi return (ENOMEM); 2292bc1f688bSRobert Mustacchi } 2293bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_fargs(cup, die, 2294bc1f688bSRobert Mustacchi &cdf->cdf_fip, cdf->cdf_argv)) != 0) { 2295bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) * argc); 2296bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2297bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2298bc1f688bSRobert Mustacchi return (ret); 2299bc1f688bSRobert Mustacchi } 2300bc1f688bSRobert Mustacchi } else { 2301bc1f688bSRobert Mustacchi cdf->cdf_argv = NULL; 2302bc1f688bSRobert Mustacchi } 2303bc1f688bSRobert Mustacchi 2304bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_isglobal(cup, die, &cdf->cdf_global)) != 0) { 2305bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) * 2306bc1f688bSRobert Mustacchi cdf->cdf_fip.ctc_argc); 2307bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2308bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2309bc1f688bSRobert Mustacchi return (ret); 2310bc1f688bSRobert Mustacchi } 2311bc1f688bSRobert Mustacchi 2312bc1f688bSRobert Mustacchi ctf_list_append(&cup->cu_funcs, cdf); 2313bc1f688bSRobert Mustacchi return (ret); 2314bc1f688bSRobert Mustacchi } 2315bc1f688bSRobert Mustacchi 2316bc1f688bSRobert Mustacchi /* 2317bc1f688bSRobert Mustacchi * Convert variables, but only if they're not prototypes and have names. 2318bc1f688bSRobert Mustacchi */ 2319bc1f688bSRobert Mustacchi static int 2320bc1f688bSRobert Mustacchi ctf_dwarf_convert_variable(ctf_cu_t *cup, Dwarf_Die die) 2321bc1f688bSRobert Mustacchi { 2322bc1f688bSRobert Mustacchi int ret; 2323bc1f688bSRobert Mustacchi char *name; 2324bc1f688bSRobert Mustacchi Dwarf_Bool b; 2325bc1f688bSRobert Mustacchi Dwarf_Die tdie; 2326bc1f688bSRobert Mustacchi ctf_id_t id; 2327bc1f688bSRobert Mustacchi ctf_dwvar_t *cdv; 2328bc1f688bSRobert Mustacchi 2329bc1f688bSRobert Mustacchi /* Skip "Non-Defining Declarations" */ 2330bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) == 0) { 2331bc1f688bSRobert Mustacchi if (b != 0) 2332bc1f688bSRobert Mustacchi return (0); 2333bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 2334bc1f688bSRobert Mustacchi return (ret); 2335bc1f688bSRobert Mustacchi } 2336bc1f688bSRobert Mustacchi 2337bc1f688bSRobert Mustacchi /* 2338bc1f688bSRobert Mustacchi * If we find a DIE of "Declarations Completing Non-Defining 2339bc1f688bSRobert Mustacchi * Declarations", we will use the referenced type's DIE. This isn't 2340bc1f688bSRobert Mustacchi * quite correct, e.g. DW_AT_decl_line will be the forward declaration 2341bc1f688bSRobert Mustacchi * not this site. It's sufficient for what we need, however: in 2342bc1f688bSRobert Mustacchi * particular, we should find DW_AT_external as needed there. 2343bc1f688bSRobert Mustacchi */ 2344bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_specification, 2345bc1f688bSRobert Mustacchi &tdie)) == 0) { 2346bc1f688bSRobert Mustacchi Dwarf_Off offset; 2347bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, tdie, &offset)) != 0) 2348bc1f688bSRobert Mustacchi return (ret); 2349bc1f688bSRobert Mustacchi ctf_dprintf("die 0x%llx DW_AT_specification -> die 0x%llx\n", 2350bc1f688bSRobert Mustacchi ctf_die_offset(die), ctf_die_offset(tdie)); 2351bc1f688bSRobert Mustacchi die = tdie; 2352bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 2353bc1f688bSRobert Mustacchi return (ret); 2354bc1f688bSRobert Mustacchi } 2355bc1f688bSRobert Mustacchi 2356bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 2357bc1f688bSRobert Mustacchi ret != ENOENT) 2358bc1f688bSRobert Mustacchi return (ret); 2359bc1f688bSRobert Mustacchi if (ret == ENOENT) 2360bc1f688bSRobert Mustacchi return (0); 2361bc1f688bSRobert Mustacchi 2362bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) { 2363bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2364bc1f688bSRobert Mustacchi return (ret); 2365bc1f688bSRobert Mustacchi } 2366bc1f688bSRobert Mustacchi 2367bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &id, 2368bc1f688bSRobert Mustacchi CTF_ADD_ROOT)) != 0) 2369bc1f688bSRobert Mustacchi return (ret); 2370bc1f688bSRobert Mustacchi 2371bc1f688bSRobert Mustacchi if ((cdv = ctf_alloc(sizeof (ctf_dwvar_t))) == NULL) { 2372bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2373bc1f688bSRobert Mustacchi return (ENOMEM); 2374bc1f688bSRobert Mustacchi } 2375bc1f688bSRobert Mustacchi 2376bc1f688bSRobert Mustacchi cdv->cdv_name = name; 2377bc1f688bSRobert Mustacchi cdv->cdv_type = id; 2378bc1f688bSRobert Mustacchi 2379bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_isglobal(cup, die, &cdv->cdv_global)) != 0) { 2380bc1f688bSRobert Mustacchi ctf_free(cdv, sizeof (ctf_dwvar_t)); 2381bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2382bc1f688bSRobert Mustacchi return (ret); 2383bc1f688bSRobert Mustacchi } 2384bc1f688bSRobert Mustacchi 2385bc1f688bSRobert Mustacchi ctf_list_append(&cup->cu_vars, cdv); 2386bc1f688bSRobert Mustacchi return (0); 2387bc1f688bSRobert Mustacchi } 2388bc1f688bSRobert Mustacchi 2389bc1f688bSRobert Mustacchi /* 2390bc1f688bSRobert Mustacchi * Walk through our set of top-level types and process them. 2391bc1f688bSRobert Mustacchi */ 2392bc1f688bSRobert Mustacchi static int 2393bc1f688bSRobert Mustacchi ctf_dwarf_walk_toplevel(ctf_cu_t *cup, Dwarf_Die die) 2394bc1f688bSRobert Mustacchi { 2395bc1f688bSRobert Mustacchi int ret; 2396bc1f688bSRobert Mustacchi Dwarf_Off offset; 2397bc1f688bSRobert Mustacchi Dwarf_Half tag; 2398bc1f688bSRobert Mustacchi 2399bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0) 2400bc1f688bSRobert Mustacchi return (ret); 2401bc1f688bSRobert Mustacchi 2402bc1f688bSRobert Mustacchi if (offset > cup->cu_maxoff) { 2403bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 2404bc1f688bSRobert Mustacchi "die offset %llu beyond maximum for header %llu\n", 2405bc1f688bSRobert Mustacchi offset, cup->cu_maxoff); 2406bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 2407bc1f688bSRobert Mustacchi } 2408bc1f688bSRobert Mustacchi 2409bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0) 2410bc1f688bSRobert Mustacchi return (ret); 2411bc1f688bSRobert Mustacchi 2412bc1f688bSRobert Mustacchi ret = 0; 2413bc1f688bSRobert Mustacchi switch (tag) { 2414bc1f688bSRobert Mustacchi case DW_TAG_subprogram: 2415bc1f688bSRobert Mustacchi ctf_dprintf("top level func\n"); 2416bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_function(cup, die); 2417bc1f688bSRobert Mustacchi break; 2418bc1f688bSRobert Mustacchi case DW_TAG_variable: 2419bc1f688bSRobert Mustacchi ctf_dprintf("top level var\n"); 2420bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_variable(cup, die); 2421bc1f688bSRobert Mustacchi break; 2422bc1f688bSRobert Mustacchi case DW_TAG_lexical_block: 2423bc1f688bSRobert Mustacchi ctf_dprintf("top level block\n"); 2424bc1f688bSRobert Mustacchi ret = ctf_dwarf_walk_lexical(cup, die); 2425bc1f688bSRobert Mustacchi break; 2426bc1f688bSRobert Mustacchi case DW_TAG_enumeration_type: 2427bc1f688bSRobert Mustacchi case DW_TAG_structure_type: 2428bc1f688bSRobert Mustacchi case DW_TAG_typedef: 2429bc1f688bSRobert Mustacchi case DW_TAG_union_type: 2430bc1f688bSRobert Mustacchi ctf_dprintf("top level type\n"); 2431bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_type(cup, die, NULL, B_TRUE); 2432bc1f688bSRobert Mustacchi break; 2433bc1f688bSRobert Mustacchi default: 2434bc1f688bSRobert Mustacchi break; 2435bc1f688bSRobert Mustacchi } 2436bc1f688bSRobert Mustacchi 2437bc1f688bSRobert Mustacchi return (ret); 2438bc1f688bSRobert Mustacchi } 2439bc1f688bSRobert Mustacchi 2440bc1f688bSRobert Mustacchi 2441bc1f688bSRobert Mustacchi /* 2442bc1f688bSRobert Mustacchi * We're given a node. At this node we need to convert it and then proceed to 2443bc1f688bSRobert Mustacchi * convert any siblings that are associaed with this die. 2444bc1f688bSRobert Mustacchi */ 2445bc1f688bSRobert Mustacchi static int 2446bc1f688bSRobert Mustacchi ctf_dwarf_convert_die(ctf_cu_t *cup, Dwarf_Die die) 2447bc1f688bSRobert Mustacchi { 2448bc1f688bSRobert Mustacchi while (die != NULL) { 2449bc1f688bSRobert Mustacchi int ret; 2450bc1f688bSRobert Mustacchi Dwarf_Die sib; 2451bc1f688bSRobert Mustacchi 2452bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_walk_toplevel(cup, die)) != 0) 2453bc1f688bSRobert Mustacchi return (ret); 2454bc1f688bSRobert Mustacchi 2455bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, die, &sib)) != 0) 2456bc1f688bSRobert Mustacchi return (ret); 2457bc1f688bSRobert Mustacchi die = sib; 2458bc1f688bSRobert Mustacchi } 2459bc1f688bSRobert Mustacchi return (0); 2460bc1f688bSRobert Mustacchi } 2461bc1f688bSRobert Mustacchi 2462bc1f688bSRobert Mustacchi static int 2463bc1f688bSRobert Mustacchi ctf_dwarf_fixup_die(ctf_cu_t *cup, boolean_t addpass) 2464bc1f688bSRobert Mustacchi { 2465bc1f688bSRobert Mustacchi ctf_dwmap_t *map; 2466bc1f688bSRobert Mustacchi 2467bc1f688bSRobert Mustacchi for (map = avl_first(&cup->cu_map); map != NULL; 2468bc1f688bSRobert Mustacchi map = AVL_NEXT(&cup->cu_map, map)) { 2469bc1f688bSRobert Mustacchi int ret; 2470bc1f688bSRobert Mustacchi if (map->cdm_fix == B_FALSE) 2471bc1f688bSRobert Mustacchi continue; 2472bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_fixup_sou(cup, map->cdm_die, map->cdm_id, 2473bc1f688bSRobert Mustacchi addpass)) != 0) 2474bc1f688bSRobert Mustacchi return (ret); 2475bc1f688bSRobert Mustacchi } 2476bc1f688bSRobert Mustacchi 2477bc1f688bSRobert Mustacchi return (0); 2478bc1f688bSRobert Mustacchi } 2479bc1f688bSRobert Mustacchi 248037e82d12SRobert Mustacchi /* 248137e82d12SRobert Mustacchi * The DWARF information about a symbol and the information in the symbol table 248237e82d12SRobert Mustacchi * may not be the same due to symbol reduction that is performed by ld due to a 248337e82d12SRobert Mustacchi * mapfile or other such directive. We process weak symbols at a later time. 248437e82d12SRobert Mustacchi * 248537e82d12SRobert Mustacchi * The following are the rules that we employ: 248637e82d12SRobert Mustacchi * 248737e82d12SRobert Mustacchi * 1. A DWARF function that is considered exported matches STB_GLOBAL entries 248837e82d12SRobert Mustacchi * with the same name. 248937e82d12SRobert Mustacchi * 249037e82d12SRobert Mustacchi * 2. A DWARF function that is considered exported matches STB_LOCAL entries 249137e82d12SRobert Mustacchi * with the same name and the same file. This case may happen due to mapfile 249237e82d12SRobert Mustacchi * reduction. 249337e82d12SRobert Mustacchi * 249437e82d12SRobert Mustacchi * 3. A DWARF function that is not considered exported matches STB_LOCAL entries 249537e82d12SRobert Mustacchi * with the same name and the same file. 249637e82d12SRobert Mustacchi * 249737e82d12SRobert Mustacchi * 4. A DWARF function that has the same name as the symbol table entry, but the 249837e82d12SRobert Mustacchi * files do not match. This is considered a 'fuzzy' match. This may also happen 249937e82d12SRobert Mustacchi * due to a mapfile reduction. Fuzzy matching is only used when we know that the 250037e82d12SRobert Mustacchi * file in question refers to the primary object. This is because when a symbol 250137e82d12SRobert Mustacchi * is reduced in a mapfile, it's always going to be tagged as a local value in 250237e82d12SRobert Mustacchi * the generated output and it is considered as to belong to the primary file 250337e82d12SRobert Mustacchi * which is the first STT_FILE symbol we see. 250437e82d12SRobert Mustacchi */ 250537e82d12SRobert Mustacchi static boolean_t 250637e82d12SRobert Mustacchi ctf_dwarf_symbol_match(const char *symtab_file, const char *symtab_name, 250737e82d12SRobert Mustacchi uint_t symtab_bind, const char *dwarf_file, const char *dwarf_name, 250837e82d12SRobert Mustacchi boolean_t dwarf_global, boolean_t *is_fuzzy) 250937e82d12SRobert Mustacchi { 251037e82d12SRobert Mustacchi *is_fuzzy = B_FALSE; 251137e82d12SRobert Mustacchi 251237e82d12SRobert Mustacchi if (symtab_bind != STB_LOCAL && symtab_bind != STB_GLOBAL) { 251337e82d12SRobert Mustacchi return (B_FALSE); 251437e82d12SRobert Mustacchi } 251537e82d12SRobert Mustacchi 251637e82d12SRobert Mustacchi if (strcmp(symtab_name, dwarf_name) != 0) { 251737e82d12SRobert Mustacchi return (B_FALSE); 251837e82d12SRobert Mustacchi } 251937e82d12SRobert Mustacchi 252037e82d12SRobert Mustacchi if (symtab_bind == STB_GLOBAL) { 252137e82d12SRobert Mustacchi return (dwarf_global); 252237e82d12SRobert Mustacchi } 252337e82d12SRobert Mustacchi 252437e82d12SRobert Mustacchi if (strcmp(symtab_file, dwarf_file) == 0) { 252537e82d12SRobert Mustacchi return (B_TRUE); 252637e82d12SRobert Mustacchi } 252737e82d12SRobert Mustacchi 252837e82d12SRobert Mustacchi if (dwarf_global) { 252937e82d12SRobert Mustacchi *is_fuzzy = B_TRUE; 253037e82d12SRobert Mustacchi return (B_TRUE); 253137e82d12SRobert Mustacchi } 253237e82d12SRobert Mustacchi 253337e82d12SRobert Mustacchi return (B_FALSE); 253437e82d12SRobert Mustacchi } 253537e82d12SRobert Mustacchi 2536bc1f688bSRobert Mustacchi static ctf_dwfunc_t * 2537bc1f688bSRobert Mustacchi ctf_dwarf_match_func(ctf_cu_t *cup, const char *file, const char *name, 253837e82d12SRobert Mustacchi uint_t bind, boolean_t primary) 2539bc1f688bSRobert Mustacchi { 254037e82d12SRobert Mustacchi ctf_dwfunc_t *cdf, *fuzzy = NULL; 2541bc1f688bSRobert Mustacchi 2542bc1f688bSRobert Mustacchi if (bind == STB_WEAK) 2543bc1f688bSRobert Mustacchi return (NULL); 2544bc1f688bSRobert Mustacchi 2545bc1f688bSRobert Mustacchi if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL)) 2546bc1f688bSRobert Mustacchi return (NULL); 2547bc1f688bSRobert Mustacchi 2548bc1f688bSRobert Mustacchi for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL; 2549bc1f688bSRobert Mustacchi cdf = ctf_list_next(cdf)) { 255037e82d12SRobert Mustacchi boolean_t is_fuzzy = B_FALSE; 255137e82d12SRobert Mustacchi 255237e82d12SRobert Mustacchi if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name, 255337e82d12SRobert Mustacchi cdf->cdf_name, cdf->cdf_global, &is_fuzzy)) { 255437e82d12SRobert Mustacchi if (is_fuzzy) { 255537e82d12SRobert Mustacchi if (primary) { 255637e82d12SRobert Mustacchi fuzzy = cdf; 255737e82d12SRobert Mustacchi } 255837e82d12SRobert Mustacchi continue; 255937e82d12SRobert Mustacchi } else { 256037e82d12SRobert Mustacchi return (cdf); 256137e82d12SRobert Mustacchi } 256237e82d12SRobert Mustacchi } 2563bc1f688bSRobert Mustacchi } 2564bc1f688bSRobert Mustacchi 256537e82d12SRobert Mustacchi return (fuzzy); 2566bc1f688bSRobert Mustacchi } 256737e82d12SRobert Mustacchi 2568bc1f688bSRobert Mustacchi static ctf_dwvar_t * 2569bc1f688bSRobert Mustacchi ctf_dwarf_match_var(ctf_cu_t *cup, const char *file, const char *name, 257037e82d12SRobert Mustacchi uint_t bind, boolean_t primary) 2571bc1f688bSRobert Mustacchi { 257237e82d12SRobert Mustacchi ctf_dwvar_t *cdv, *fuzzy = NULL; 257337e82d12SRobert Mustacchi 257437e82d12SRobert Mustacchi if (bind == STB_WEAK) 257537e82d12SRobert Mustacchi return (NULL); 2576bc1f688bSRobert Mustacchi 2577bc1f688bSRobert Mustacchi if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL)) 2578bc1f688bSRobert Mustacchi return (NULL); 2579bc1f688bSRobert Mustacchi 2580bc1f688bSRobert Mustacchi for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL; 2581bc1f688bSRobert Mustacchi cdv = ctf_list_next(cdv)) { 258237e82d12SRobert Mustacchi boolean_t is_fuzzy = B_FALSE; 258337e82d12SRobert Mustacchi 258437e82d12SRobert Mustacchi if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name, 258537e82d12SRobert Mustacchi cdv->cdv_name, cdv->cdv_global, &is_fuzzy)) { 258637e82d12SRobert Mustacchi if (is_fuzzy) { 258737e82d12SRobert Mustacchi if (primary) { 258837e82d12SRobert Mustacchi fuzzy = cdv; 258937e82d12SRobert Mustacchi } 259037e82d12SRobert Mustacchi } else { 259137e82d12SRobert Mustacchi return (cdv); 2592bc1f688bSRobert Mustacchi } 2593bc1f688bSRobert Mustacchi } 2594bc1f688bSRobert Mustacchi } 2595bc1f688bSRobert Mustacchi 259637e82d12SRobert Mustacchi return (fuzzy); 2597bc1f688bSRobert Mustacchi } 2598bc1f688bSRobert Mustacchi 2599bc1f688bSRobert Mustacchi static int 260037e82d12SRobert Mustacchi ctf_dwarf_conv_funcvars_cb(const Elf64_Sym *symp, ulong_t idx, 260137e82d12SRobert Mustacchi const char *file, const char *name, boolean_t primary, void *arg) 2602bc1f688bSRobert Mustacchi { 260337e82d12SRobert Mustacchi int ret; 260437e82d12SRobert Mustacchi uint_t bind, type; 260537e82d12SRobert Mustacchi ctf_cu_t *cup = arg; 2606bc1f688bSRobert Mustacchi 2607bc1f688bSRobert Mustacchi bind = GELF_ST_BIND(symp->st_info); 2608bc1f688bSRobert Mustacchi type = GELF_ST_TYPE(symp->st_info); 2609bc1f688bSRobert Mustacchi 2610bc1f688bSRobert Mustacchi /* 2611bc1f688bSRobert Mustacchi * Come back to weak symbols in another pass 2612bc1f688bSRobert Mustacchi */ 2613bc1f688bSRobert Mustacchi if (bind == STB_WEAK) 2614bc1f688bSRobert Mustacchi return (0); 2615bc1f688bSRobert Mustacchi 2616bc1f688bSRobert Mustacchi if (type == STT_OBJECT) { 2617bc1f688bSRobert Mustacchi ctf_dwvar_t *cdv = ctf_dwarf_match_var(cup, file, name, 261837e82d12SRobert Mustacchi bind, primary); 2619bc1f688bSRobert Mustacchi if (cdv == NULL) 2620bc1f688bSRobert Mustacchi return (0); 2621bc1f688bSRobert Mustacchi ret = ctf_add_object(cup->cu_ctfp, idx, cdv->cdv_type); 262237e82d12SRobert Mustacchi ctf_dprintf("added object %s->%ld\n", name, cdv->cdv_type); 2623bc1f688bSRobert Mustacchi } else { 2624bc1f688bSRobert Mustacchi ctf_dwfunc_t *cdf = ctf_dwarf_match_func(cup, file, name, 262537e82d12SRobert Mustacchi bind, primary); 2626bc1f688bSRobert Mustacchi if (cdf == NULL) 2627bc1f688bSRobert Mustacchi return (0); 2628bc1f688bSRobert Mustacchi ret = ctf_add_function(cup->cu_ctfp, idx, &cdf->cdf_fip, 2629bc1f688bSRobert Mustacchi cdf->cdf_argv); 263037e82d12SRobert Mustacchi ctf_dprintf("added function %s\n", name); 2631bc1f688bSRobert Mustacchi } 2632bc1f688bSRobert Mustacchi 2633bc1f688bSRobert Mustacchi if (ret == CTF_ERR) { 2634bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2635bc1f688bSRobert Mustacchi } 2636bc1f688bSRobert Mustacchi 2637bc1f688bSRobert Mustacchi return (0); 2638bc1f688bSRobert Mustacchi } 2639bc1f688bSRobert Mustacchi 2640bc1f688bSRobert Mustacchi static int 2641bc1f688bSRobert Mustacchi ctf_dwarf_conv_funcvars(ctf_cu_t *cup) 2642bc1f688bSRobert Mustacchi { 264337e82d12SRobert Mustacchi return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_funcvars_cb, cup)); 2644bc1f688bSRobert Mustacchi } 2645bc1f688bSRobert Mustacchi 2646bc1f688bSRobert Mustacchi /* 2647bc1f688bSRobert Mustacchi * If we have a weak symbol, attempt to find the strong symbol it will resolve 2648bc1f688bSRobert Mustacchi * to. Note: the code where this actually happens is in sym_process() in 2649bc1f688bSRobert Mustacchi * cmd/sgs/libld/common/syms.c 2650bc1f688bSRobert Mustacchi * 2651bc1f688bSRobert Mustacchi * Finding the matching symbol is unfortunately not trivial. For a symbol to be 2652bc1f688bSRobert Mustacchi * a candidate, it must: 2653bc1f688bSRobert Mustacchi * 2654bc1f688bSRobert Mustacchi * - have the same type (function, object) 2655bc1f688bSRobert Mustacchi * - have the same value (address) 2656bc1f688bSRobert Mustacchi * - have the same size 2657bc1f688bSRobert Mustacchi * - not be another weak symbol 2658bc1f688bSRobert Mustacchi * - belong to the same section (checked via section index) 2659bc1f688bSRobert Mustacchi * 2660bc1f688bSRobert Mustacchi * To perform this check, we first iterate over the symbol table. For each weak 2661bc1f688bSRobert Mustacchi * symbol that we encounter, we then do a second walk over the symbol table, 2662bc1f688bSRobert Mustacchi * calling ctf_dwarf_conv_check_weak(). If a symbol matches the above, then it's 2663bc1f688bSRobert Mustacchi * either a local or global symbol. If we find a global symbol then we go with 2664bc1f688bSRobert Mustacchi * it and stop searching for additional matches. 2665bc1f688bSRobert Mustacchi * 2666bc1f688bSRobert Mustacchi * If instead, we find a local symbol, things are more complicated. The first 2667bc1f688bSRobert Mustacchi * thing we do is to try and see if we have file information about both symbols 2668bc1f688bSRobert Mustacchi * (STT_FILE). If they both have file information and it matches, then we treat 2669bc1f688bSRobert Mustacchi * that as a good match and stop searching for additional matches. 2670bc1f688bSRobert Mustacchi * 2671bc1f688bSRobert Mustacchi * Otherwise, this means we have a non-matching file and a local symbol. We 2672bc1f688bSRobert Mustacchi * treat this as a candidate and if we find a better match (one of the two cases 2673bc1f688bSRobert Mustacchi * above), use that instead. There are two different ways this can happen. 2674bc1f688bSRobert Mustacchi * Either this is a completely different symbol, or it's a once-global symbol 2675bc1f688bSRobert Mustacchi * that was scoped to local via a mapfile. In the former case, curfile is 2676bc1f688bSRobert Mustacchi * likely inaccurate since the linker does not preserve the needed curfile in 2677bc1f688bSRobert Mustacchi * the order of the symbol table (see the comments about locally scoped symbols 2678bc1f688bSRobert Mustacchi * in libld's update_osym()). As we can't tell this case from the former one, 2679bc1f688bSRobert Mustacchi * we use this symbol iff no other matching symbol is found. 2680bc1f688bSRobert Mustacchi * 2681bc1f688bSRobert Mustacchi * What we really need here is a SUNW section containing weak<->strong mappings 2682bc1f688bSRobert Mustacchi * that we can consume. 2683bc1f688bSRobert Mustacchi */ 2684bc1f688bSRobert Mustacchi typedef struct ctf_dwarf_weak_arg { 268537e82d12SRobert Mustacchi const Elf64_Sym *cweak_symp; 2686bc1f688bSRobert Mustacchi const char *cweak_file; 2687bc1f688bSRobert Mustacchi boolean_t cweak_candidate; 2688bc1f688bSRobert Mustacchi ulong_t cweak_idx; 2689bc1f688bSRobert Mustacchi } ctf_dwarf_weak_arg_t; 2690bc1f688bSRobert Mustacchi 2691bc1f688bSRobert Mustacchi static int 269237e82d12SRobert Mustacchi ctf_dwarf_conv_check_weak(const Elf64_Sym *symp, ulong_t idx, const char *file, 269337e82d12SRobert Mustacchi const char *name, boolean_t primary, void *arg) 2694bc1f688bSRobert Mustacchi { 2695bc1f688bSRobert Mustacchi ctf_dwarf_weak_arg_t *cweak = arg; 269637e82d12SRobert Mustacchi 269737e82d12SRobert Mustacchi const Elf64_Sym *wsymp = cweak->cweak_symp; 2698bc1f688bSRobert Mustacchi 2699bc1f688bSRobert Mustacchi ctf_dprintf("comparing weak to %s\n", name); 2700bc1f688bSRobert Mustacchi 2701bc1f688bSRobert Mustacchi if (GELF_ST_BIND(symp->st_info) == STB_WEAK) { 2702bc1f688bSRobert Mustacchi return (0); 2703bc1f688bSRobert Mustacchi } 2704bc1f688bSRobert Mustacchi 2705bc1f688bSRobert Mustacchi if (GELF_ST_TYPE(wsymp->st_info) != GELF_ST_TYPE(symp->st_info)) { 2706bc1f688bSRobert Mustacchi return (0); 2707bc1f688bSRobert Mustacchi } 2708bc1f688bSRobert Mustacchi 2709bc1f688bSRobert Mustacchi if (wsymp->st_value != symp->st_value) { 2710bc1f688bSRobert Mustacchi return (0); 2711bc1f688bSRobert Mustacchi } 2712bc1f688bSRobert Mustacchi 2713bc1f688bSRobert Mustacchi if (wsymp->st_size != symp->st_size) { 2714bc1f688bSRobert Mustacchi return (0); 2715bc1f688bSRobert Mustacchi } 2716bc1f688bSRobert Mustacchi 2717bc1f688bSRobert Mustacchi if (wsymp->st_shndx != symp->st_shndx) { 2718bc1f688bSRobert Mustacchi return (0); 2719bc1f688bSRobert Mustacchi } 2720bc1f688bSRobert Mustacchi 2721bc1f688bSRobert Mustacchi /* 2722bc1f688bSRobert Mustacchi * Check if it's a weak candidate. 2723bc1f688bSRobert Mustacchi */ 2724bc1f688bSRobert Mustacchi if (GELF_ST_BIND(symp->st_info) == STB_LOCAL && 2725bc1f688bSRobert Mustacchi (file == NULL || cweak->cweak_file == NULL || 2726bc1f688bSRobert Mustacchi strcmp(file, cweak->cweak_file) != 0)) { 2727bc1f688bSRobert Mustacchi cweak->cweak_candidate = B_TRUE; 2728bc1f688bSRobert Mustacchi cweak->cweak_idx = idx; 2729bc1f688bSRobert Mustacchi return (0); 2730bc1f688bSRobert Mustacchi } 2731bc1f688bSRobert Mustacchi 2732bc1f688bSRobert Mustacchi /* 2733bc1f688bSRobert Mustacchi * Found a match, break. 2734bc1f688bSRobert Mustacchi */ 2735bc1f688bSRobert Mustacchi cweak->cweak_idx = idx; 2736bc1f688bSRobert Mustacchi return (1); 2737bc1f688bSRobert Mustacchi } 2738bc1f688bSRobert Mustacchi 2739bc1f688bSRobert Mustacchi static int 2740bc1f688bSRobert Mustacchi ctf_dwarf_duplicate_sym(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx) 2741bc1f688bSRobert Mustacchi { 2742bc1f688bSRobert Mustacchi ctf_id_t id = ctf_lookup_by_symbol(cup->cu_ctfp, matchidx); 2743bc1f688bSRobert Mustacchi 2744bc1f688bSRobert Mustacchi /* 2745bc1f688bSRobert Mustacchi * If we matched something that for some reason didn't have type data, 2746bc1f688bSRobert Mustacchi * we don't consider that a fatal error and silently swallow it. 2747bc1f688bSRobert Mustacchi */ 2748bc1f688bSRobert Mustacchi if (id == CTF_ERR) { 2749bc1f688bSRobert Mustacchi if (ctf_errno(cup->cu_ctfp) == ECTF_NOTYPEDAT) 2750bc1f688bSRobert Mustacchi return (0); 2751bc1f688bSRobert Mustacchi else 2752bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2753bc1f688bSRobert Mustacchi } 2754bc1f688bSRobert Mustacchi 2755bc1f688bSRobert Mustacchi if (ctf_add_object(cup->cu_ctfp, idx, id) == CTF_ERR) 2756bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2757bc1f688bSRobert Mustacchi 2758bc1f688bSRobert Mustacchi return (0); 2759bc1f688bSRobert Mustacchi } 2760bc1f688bSRobert Mustacchi 2761bc1f688bSRobert Mustacchi static int 2762bc1f688bSRobert Mustacchi ctf_dwarf_duplicate_func(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx) 2763bc1f688bSRobert Mustacchi { 2764bc1f688bSRobert Mustacchi int ret; 2765bc1f688bSRobert Mustacchi ctf_funcinfo_t fip; 2766bc1f688bSRobert Mustacchi ctf_id_t *args = NULL; 2767bc1f688bSRobert Mustacchi 2768bc1f688bSRobert Mustacchi if (ctf_func_info(cup->cu_ctfp, matchidx, &fip) == CTF_ERR) { 2769bc1f688bSRobert Mustacchi if (ctf_errno(cup->cu_ctfp) == ECTF_NOFUNCDAT) 2770bc1f688bSRobert Mustacchi return (0); 2771bc1f688bSRobert Mustacchi else 2772bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2773bc1f688bSRobert Mustacchi } 2774bc1f688bSRobert Mustacchi 2775bc1f688bSRobert Mustacchi if (fip.ctc_argc != 0) { 2776bc1f688bSRobert Mustacchi args = ctf_alloc(sizeof (ctf_id_t) * fip.ctc_argc); 2777bc1f688bSRobert Mustacchi if (args == NULL) 2778bc1f688bSRobert Mustacchi return (ENOMEM); 2779bc1f688bSRobert Mustacchi 2780bc1f688bSRobert Mustacchi if (ctf_func_args(cup->cu_ctfp, matchidx, fip.ctc_argc, args) == 2781bc1f688bSRobert Mustacchi CTF_ERR) { 2782bc1f688bSRobert Mustacchi ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc); 2783bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2784bc1f688bSRobert Mustacchi } 2785bc1f688bSRobert Mustacchi } 2786bc1f688bSRobert Mustacchi 2787bc1f688bSRobert Mustacchi ret = ctf_add_function(cup->cu_ctfp, idx, &fip, args); 2788bc1f688bSRobert Mustacchi if (args != NULL) 2789bc1f688bSRobert Mustacchi ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc); 2790bc1f688bSRobert Mustacchi if (ret == CTF_ERR) 2791bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2792bc1f688bSRobert Mustacchi 2793bc1f688bSRobert Mustacchi return (0); 2794bc1f688bSRobert Mustacchi } 2795bc1f688bSRobert Mustacchi 2796bc1f688bSRobert Mustacchi static int 279737e82d12SRobert Mustacchi ctf_dwarf_conv_weaks_cb(const Elf64_Sym *symp, ulong_t idx, const char *file, 279837e82d12SRobert Mustacchi const char *name, boolean_t primary, void *arg) 2799bc1f688bSRobert Mustacchi { 2800bc1f688bSRobert Mustacchi int ret, type; 2801bc1f688bSRobert Mustacchi ctf_dwarf_weak_arg_t cweak; 280237e82d12SRobert Mustacchi ctf_cu_t *cup = arg; 2803bc1f688bSRobert Mustacchi 2804bc1f688bSRobert Mustacchi /* 2805bc1f688bSRobert Mustacchi * We only care about weak symbols. 2806bc1f688bSRobert Mustacchi */ 2807bc1f688bSRobert Mustacchi if (GELF_ST_BIND(symp->st_info) != STB_WEAK) 2808bc1f688bSRobert Mustacchi return (0); 2809bc1f688bSRobert Mustacchi 2810bc1f688bSRobert Mustacchi type = GELF_ST_TYPE(symp->st_info); 2811bc1f688bSRobert Mustacchi ASSERT(type == STT_OBJECT || type == STT_FUNC); 2812bc1f688bSRobert Mustacchi 2813bc1f688bSRobert Mustacchi /* 2814bc1f688bSRobert Mustacchi * For each weak symbol we encounter, we need to do a second iteration 2815bc1f688bSRobert Mustacchi * to try and find a match. We should probably think about other 2816bc1f688bSRobert Mustacchi * techniques to try and save us time in the future. 2817bc1f688bSRobert Mustacchi */ 2818bc1f688bSRobert Mustacchi cweak.cweak_symp = symp; 2819bc1f688bSRobert Mustacchi cweak.cweak_file = file; 2820bc1f688bSRobert Mustacchi cweak.cweak_candidate = B_FALSE; 2821bc1f688bSRobert Mustacchi cweak.cweak_idx = 0; 2822bc1f688bSRobert Mustacchi 2823bc1f688bSRobert Mustacchi ctf_dprintf("Trying to find weak equiv for %s\n", name); 2824bc1f688bSRobert Mustacchi 282537e82d12SRobert Mustacchi ret = ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_check_weak, &cweak); 2826bc1f688bSRobert Mustacchi VERIFY(ret == 0 || ret == 1); 2827bc1f688bSRobert Mustacchi 2828bc1f688bSRobert Mustacchi /* 2829bc1f688bSRobert Mustacchi * Nothing was ever found, we're not going to add anything for this 2830bc1f688bSRobert Mustacchi * entry. 2831bc1f688bSRobert Mustacchi */ 2832bc1f688bSRobert Mustacchi if (ret == 0 && cweak.cweak_candidate == B_FALSE) { 2833bc1f688bSRobert Mustacchi ctf_dprintf("found no weak match for %s\n", name); 2834bc1f688bSRobert Mustacchi return (0); 2835bc1f688bSRobert Mustacchi } 2836bc1f688bSRobert Mustacchi 2837bc1f688bSRobert Mustacchi /* 2838bc1f688bSRobert Mustacchi * Now, finally go and add the type based on the match. 2839bc1f688bSRobert Mustacchi */ 284037e82d12SRobert Mustacchi ctf_dprintf("matched weak symbol %lu to %lu\n", idx, cweak.cweak_idx); 2841bc1f688bSRobert Mustacchi if (type == STT_OBJECT) { 2842bc1f688bSRobert Mustacchi ret = ctf_dwarf_duplicate_sym(cup, idx, cweak.cweak_idx); 2843bc1f688bSRobert Mustacchi } else { 2844bc1f688bSRobert Mustacchi ret = ctf_dwarf_duplicate_func(cup, idx, cweak.cweak_idx); 2845bc1f688bSRobert Mustacchi } 2846bc1f688bSRobert Mustacchi 2847bc1f688bSRobert Mustacchi return (ret); 2848bc1f688bSRobert Mustacchi } 2849bc1f688bSRobert Mustacchi 2850bc1f688bSRobert Mustacchi static int 2851bc1f688bSRobert Mustacchi ctf_dwarf_conv_weaks(ctf_cu_t *cup) 2852bc1f688bSRobert Mustacchi { 285337e82d12SRobert Mustacchi return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_weaks_cb, cup)); 2854bc1f688bSRobert Mustacchi } 2855bc1f688bSRobert Mustacchi 2856bc1f688bSRobert Mustacchi /* ARGSUSED */ 2857bc1f688bSRobert Mustacchi static int 2858bc1f688bSRobert Mustacchi ctf_dwarf_convert_one(void *arg, void *unused) 2859bc1f688bSRobert Mustacchi { 2860bc1f688bSRobert Mustacchi int ret; 2861bc1f688bSRobert Mustacchi ctf_file_t *dedup; 2862bc1f688bSRobert Mustacchi ctf_cu_t *cup = arg; 2863bc1f688bSRobert Mustacchi 2864bc1f688bSRobert Mustacchi ctf_dprintf("converting die: %s\n", cup->cu_name); 2865bc1f688bSRobert Mustacchi ctf_dprintf("max offset: %x\n", cup->cu_maxoff); 2866bc1f688bSRobert Mustacchi VERIFY(cup != NULL); 2867bc1f688bSRobert Mustacchi 2868bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_die(cup, cup->cu_cu); 2869bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_convert_die (%s) returned %d\n", cup->cu_name, 2870bc1f688bSRobert Mustacchi ret); 2871bc1f688bSRobert Mustacchi if (ret != 0) { 2872bc1f688bSRobert Mustacchi return (ret); 2873bc1f688bSRobert Mustacchi } 2874bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2875bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2876bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2877bc1f688bSRobert Mustacchi } 2878bc1f688bSRobert Mustacchi 2879bc1f688bSRobert Mustacchi ret = ctf_dwarf_fixup_die(cup, B_FALSE); 2880bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name, 2881bc1f688bSRobert Mustacchi ret); 2882bc1f688bSRobert Mustacchi if (ret != 0) { 2883bc1f688bSRobert Mustacchi return (ret); 2884bc1f688bSRobert Mustacchi } 2885bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2886bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2887bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2888bc1f688bSRobert Mustacchi } 2889bc1f688bSRobert Mustacchi 2890bc1f688bSRobert Mustacchi ret = ctf_dwarf_fixup_die(cup, B_TRUE); 2891bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name, 2892bc1f688bSRobert Mustacchi ret); 2893bc1f688bSRobert Mustacchi if (ret != 0) { 2894bc1f688bSRobert Mustacchi return (ret); 2895bc1f688bSRobert Mustacchi } 2896bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2897bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2898bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2899bc1f688bSRobert Mustacchi } 2900bc1f688bSRobert Mustacchi 2901bc1f688bSRobert Mustacchi 2902bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_conv_funcvars(cup)) != 0) { 2903bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2904bc1f688bSRobert Mustacchi "failed to convert strong functions and variables")); 2905bc1f688bSRobert Mustacchi } 2906bc1f688bSRobert Mustacchi 2907bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2908bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2909bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2910bc1f688bSRobert Mustacchi } 2911bc1f688bSRobert Mustacchi 2912bc1f688bSRobert Mustacchi if (cup->cu_doweaks == B_TRUE) { 2913bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_conv_weaks(cup)) != 0) { 2914bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2915bc1f688bSRobert Mustacchi "failed to convert weak functions and variables")); 2916bc1f688bSRobert Mustacchi } 2917bc1f688bSRobert Mustacchi 2918bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2919bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2920bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2921bc1f688bSRobert Mustacchi } 2922bc1f688bSRobert Mustacchi } 2923bc1f688bSRobert Mustacchi 292437e82d12SRobert Mustacchi ctf_phase_dump(cup->cu_ctfp, "pre-dwarf-dedup", cup->cu_name); 2925bc1f688bSRobert Mustacchi ctf_dprintf("adding inputs for dedup\n"); 2926bc1f688bSRobert Mustacchi if ((ret = ctf_merge_add(cup->cu_cmh, cup->cu_ctfp)) != 0) { 2927bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2928bc1f688bSRobert Mustacchi "failed to add inputs for merge")); 2929bc1f688bSRobert Mustacchi } 2930bc1f688bSRobert Mustacchi 293137e82d12SRobert Mustacchi ctf_dprintf("starting dedup of %s\n", cup->cu_name); 2932bc1f688bSRobert Mustacchi if ((ret = ctf_merge_dedup(cup->cu_cmh, &dedup)) != 0) { 2933bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2934bc1f688bSRobert Mustacchi "failed to deduplicate die")); 2935bc1f688bSRobert Mustacchi } 2936bc1f688bSRobert Mustacchi ctf_close(cup->cu_ctfp); 2937bc1f688bSRobert Mustacchi cup->cu_ctfp = dedup; 293837e82d12SRobert Mustacchi ctf_phase_dump(cup->cu_ctfp, "post-dwarf-dedup", cup->cu_name); 2939bc1f688bSRobert Mustacchi 2940bc1f688bSRobert Mustacchi return (0); 2941bc1f688bSRobert Mustacchi } 2942bc1f688bSRobert Mustacchi 2943bc1f688bSRobert Mustacchi /* 2944bc1f688bSRobert Mustacchi * Note, we expect that if we're returning a ctf_file_t from one of the dies, 2945bc1f688bSRobert Mustacchi * say in the single node case, it's been saved and the entry here has been set 2946bc1f688bSRobert Mustacchi * to NULL, which ctf_close happily ignores. 2947bc1f688bSRobert Mustacchi */ 2948bc1f688bSRobert Mustacchi static void 2949bc1f688bSRobert Mustacchi ctf_dwarf_free_die(ctf_cu_t *cup) 2950bc1f688bSRobert Mustacchi { 2951bc1f688bSRobert Mustacchi ctf_dwfunc_t *cdf, *ndf; 2952bc1f688bSRobert Mustacchi ctf_dwvar_t *cdv, *ndv; 2953bc1f688bSRobert Mustacchi ctf_dwbitf_t *cdb, *ndb; 2954bc1f688bSRobert Mustacchi ctf_dwmap_t *map; 2955bc1f688bSRobert Mustacchi void *cookie; 2956bc1f688bSRobert Mustacchi Dwarf_Error derr; 2957bc1f688bSRobert Mustacchi 2958bc1f688bSRobert Mustacchi ctf_dprintf("Beginning to free die: %p\n", cup); 2959bc1f688bSRobert Mustacchi cup->cu_elf = NULL; 2960bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free name: %p\n", cup->cu_name); 2961bc1f688bSRobert Mustacchi if (cup->cu_name != NULL) 2962bc1f688bSRobert Mustacchi ctf_free(cup->cu_name, strlen(cup->cu_name) + 1); 2963bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free merge handle: %p\n", cup->cu_cmh); 2964bc1f688bSRobert Mustacchi if (cup->cu_cmh != NULL) { 2965bc1f688bSRobert Mustacchi ctf_merge_fini(cup->cu_cmh); 2966bc1f688bSRobert Mustacchi cup->cu_cmh = NULL; 2967bc1f688bSRobert Mustacchi } 2968bc1f688bSRobert Mustacchi 2969bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free functions\n"); 2970bc1f688bSRobert Mustacchi for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL; cdf = ndf) { 2971bc1f688bSRobert Mustacchi ndf = ctf_list_next(cdf); 2972bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_name, strlen(cdf->cdf_name) + 1); 2973bc1f688bSRobert Mustacchi if (cdf->cdf_fip.ctc_argc != 0) { 2974bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_argv, 2975bc1f688bSRobert Mustacchi sizeof (ctf_id_t) * cdf->cdf_fip.ctc_argc); 2976bc1f688bSRobert Mustacchi } 2977bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2978bc1f688bSRobert Mustacchi } 2979bc1f688bSRobert Mustacchi 2980bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free variables\n"); 2981bc1f688bSRobert Mustacchi for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL; cdv = ndv) { 2982bc1f688bSRobert Mustacchi ndv = ctf_list_next(cdv); 2983bc1f688bSRobert Mustacchi ctf_free(cdv->cdv_name, strlen(cdv->cdv_name) + 1); 2984bc1f688bSRobert Mustacchi ctf_free(cdv, sizeof (ctf_dwvar_t)); 2985bc1f688bSRobert Mustacchi } 2986bc1f688bSRobert Mustacchi 2987bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free bitfields\n"); 2988bc1f688bSRobert Mustacchi for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL; cdb = ndb) { 2989bc1f688bSRobert Mustacchi ndb = ctf_list_next(cdb); 2990bc1f688bSRobert Mustacchi ctf_free(cdb, sizeof (ctf_dwbitf_t)); 2991bc1f688bSRobert Mustacchi } 2992bc1f688bSRobert Mustacchi 2993bc1f688bSRobert Mustacchi ctf_dprintf("Trying to clean up dwarf_t: %p\n", cup->cu_dwarf); 29943eca6103SJohn Levon if (cup->cu_dwarf != NULL) 29953eca6103SJohn Levon (void) dwarf_finish(cup->cu_dwarf, &derr); 2996bc1f688bSRobert Mustacchi cup->cu_dwarf = NULL; 2997bc1f688bSRobert Mustacchi ctf_close(cup->cu_ctfp); 2998bc1f688bSRobert Mustacchi 2999bc1f688bSRobert Mustacchi cookie = NULL; 3000bc1f688bSRobert Mustacchi while ((map = avl_destroy_nodes(&cup->cu_map, &cookie)) != NULL) { 3001bc1f688bSRobert Mustacchi ctf_free(map, sizeof (ctf_dwmap_t)); 3002bc1f688bSRobert Mustacchi } 3003bc1f688bSRobert Mustacchi avl_destroy(&cup->cu_map); 3004bc1f688bSRobert Mustacchi cup->cu_errbuf = NULL; 3005bc1f688bSRobert Mustacchi } 3006bc1f688bSRobert Mustacchi 3007bc1f688bSRobert Mustacchi static void 3008bc1f688bSRobert Mustacchi ctf_dwarf_free_dies(ctf_cu_t *cdies, int ndies) 3009bc1f688bSRobert Mustacchi { 3010bc1f688bSRobert Mustacchi int i; 3011bc1f688bSRobert Mustacchi 3012bc1f688bSRobert Mustacchi ctf_dprintf("Beginning to free dies\n"); 3013bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3014bc1f688bSRobert Mustacchi ctf_dwarf_free_die(&cdies[i]); 3015bc1f688bSRobert Mustacchi } 3016bc1f688bSRobert Mustacchi 3017bc1f688bSRobert Mustacchi ctf_free(cdies, sizeof (ctf_cu_t) * ndies); 3018bc1f688bSRobert Mustacchi } 3019bc1f688bSRobert Mustacchi 3020bc1f688bSRobert Mustacchi static int 3021bc1f688bSRobert Mustacchi ctf_dwarf_count_dies(Dwarf_Debug dw, Dwarf_Error *derr, int *ndies, 3022bc1f688bSRobert Mustacchi char *errbuf, size_t errlen) 3023bc1f688bSRobert Mustacchi { 3024bc1f688bSRobert Mustacchi int ret; 3025bc1f688bSRobert Mustacchi Dwarf_Half vers; 3026bc1f688bSRobert Mustacchi Dwarf_Unsigned nexthdr; 3027bc1f688bSRobert Mustacchi 3028bc1f688bSRobert Mustacchi while ((ret = dwarf_next_cu_header(dw, NULL, &vers, NULL, NULL, 3029bc1f688bSRobert Mustacchi &nexthdr, derr)) != DW_DLV_NO_ENTRY) { 3030bc1f688bSRobert Mustacchi if (ret != DW_DLV_OK) { 3031bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 3032bc1f688bSRobert Mustacchi "file does not contain valid DWARF data: %s\n", 3033bc1f688bSRobert Mustacchi dwarf_errmsg(*derr)); 3034bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 3035bc1f688bSRobert Mustacchi } 3036bc1f688bSRobert Mustacchi 3037*40f72ea9SRobert Mustacchi switch (vers) { 3038*40f72ea9SRobert Mustacchi case DWARF_VERSION_TWO: 3039*40f72ea9SRobert Mustacchi case DWARF_VERSION_FOUR: 3040*40f72ea9SRobert Mustacchi break; 3041*40f72ea9SRobert Mustacchi default: 3042bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 3043bc1f688bSRobert Mustacchi "unsupported DWARF version: %d\n", vers); 3044bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 3045bc1f688bSRobert Mustacchi } 3046bc1f688bSRobert Mustacchi *ndies = *ndies + 1; 3047bc1f688bSRobert Mustacchi } 3048bc1f688bSRobert Mustacchi 3049bc1f688bSRobert Mustacchi return (0); 3050bc1f688bSRobert Mustacchi } 3051bc1f688bSRobert Mustacchi 3052bc1f688bSRobert Mustacchi static int 3053bc1f688bSRobert Mustacchi ctf_dwarf_init_die(int fd, Elf *elf, ctf_cu_t *cup, int ndie, char *errbuf, 3054bc1f688bSRobert Mustacchi size_t errlen) 3055bc1f688bSRobert Mustacchi { 3056bc1f688bSRobert Mustacchi int ret; 3057bc1f688bSRobert Mustacchi Dwarf_Unsigned hdrlen, abboff, nexthdr; 3058*40f72ea9SRobert Mustacchi Dwarf_Half addrsz, vers; 3059bc1f688bSRobert Mustacchi Dwarf_Unsigned offset = 0; 3060bc1f688bSRobert Mustacchi Dwarf_Error derr; 3061bc1f688bSRobert Mustacchi 3062*40f72ea9SRobert Mustacchi while ((ret = dwarf_next_cu_header(cup->cu_dwarf, &hdrlen, &vers, 3063bc1f688bSRobert Mustacchi &abboff, &addrsz, &nexthdr, &derr)) != DW_DLV_NO_ENTRY) { 3064bc1f688bSRobert Mustacchi char *name; 3065bc1f688bSRobert Mustacchi Dwarf_Die cu, child; 3066bc1f688bSRobert Mustacchi 3067bc1f688bSRobert Mustacchi /* Based on the counting above, we should be good to go */ 3068bc1f688bSRobert Mustacchi VERIFY(ret == DW_DLV_OK); 3069bc1f688bSRobert Mustacchi if (ndie > 0) { 3070bc1f688bSRobert Mustacchi ndie--; 3071bc1f688bSRobert Mustacchi offset = nexthdr; 3072bc1f688bSRobert Mustacchi continue; 3073bc1f688bSRobert Mustacchi } 3074bc1f688bSRobert Mustacchi 3075bc1f688bSRobert Mustacchi /* 3076bc1f688bSRobert Mustacchi * Compilers are apparently inconsistent. Some emit no DWARF for 3077bc1f688bSRobert Mustacchi * empty files and others emit empty compilation unit. 3078bc1f688bSRobert Mustacchi */ 3079bc1f688bSRobert Mustacchi cup->cu_voidtid = CTF_ERR; 3080bc1f688bSRobert Mustacchi cup->cu_longtid = CTF_ERR; 3081bc1f688bSRobert Mustacchi cup->cu_elf = elf; 3082bc1f688bSRobert Mustacchi cup->cu_maxoff = nexthdr - 1; 3083*40f72ea9SRobert Mustacchi cup->cu_vers = vers; 3084*40f72ea9SRobert Mustacchi cup->cu_addrsz = addrsz; 3085bc1f688bSRobert Mustacchi cup->cu_ctfp = ctf_fdcreate(fd, &ret); 30863eca6103SJohn Levon if (cup->cu_ctfp == NULL) 3087bc1f688bSRobert Mustacchi return (ret); 30883eca6103SJohn Levon 3089bc1f688bSRobert Mustacchi avl_create(&cup->cu_map, ctf_dwmap_comp, sizeof (ctf_dwmap_t), 3090bc1f688bSRobert Mustacchi offsetof(ctf_dwmap_t, cdm_avl)); 3091bc1f688bSRobert Mustacchi cup->cu_errbuf = errbuf; 3092bc1f688bSRobert Mustacchi cup->cu_errlen = errlen; 3093bc1f688bSRobert Mustacchi bzero(&cup->cu_vars, sizeof (ctf_list_t)); 3094bc1f688bSRobert Mustacchi bzero(&cup->cu_funcs, sizeof (ctf_list_t)); 3095bc1f688bSRobert Mustacchi bzero(&cup->cu_bitfields, sizeof (ctf_list_t)); 3096bc1f688bSRobert Mustacchi 3097bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_die_elfenc(elf, cup, errbuf, 30983eca6103SJohn Levon errlen)) != 0) 3099bc1f688bSRobert Mustacchi return (ret); 3100bc1f688bSRobert Mustacchi 31013eca6103SJohn Levon if ((ret = ctf_dwarf_sib(cup, NULL, &cu)) != 0) 3102bc1f688bSRobert Mustacchi return (ret); 31033eca6103SJohn Levon 3104bc1f688bSRobert Mustacchi if (cu == NULL) { 3105bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 31063eca6103SJohn Levon "file does not contain DWARF data"); 31073eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3108bc1f688bSRobert Mustacchi } 3109bc1f688bSRobert Mustacchi 31103eca6103SJohn Levon if ((ret = ctf_dwarf_child(cup, cu, &child)) != 0) 3111bc1f688bSRobert Mustacchi return (ret); 31123eca6103SJohn Levon 3113bc1f688bSRobert Mustacchi if (child == NULL) { 3114bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 31153eca6103SJohn Levon "file does not contain DWARF data"); 31163eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3117bc1f688bSRobert Mustacchi } 3118bc1f688bSRobert Mustacchi 3119bc1f688bSRobert Mustacchi cup->cu_cuoff = offset; 3120bc1f688bSRobert Mustacchi cup->cu_cu = child; 3121bc1f688bSRobert Mustacchi 31223eca6103SJohn Levon if ((cup->cu_cmh = ctf_merge_init(fd, &ret)) == NULL) 3123bc1f688bSRobert Mustacchi return (ret); 3124bc1f688bSRobert Mustacchi 3125bc1f688bSRobert Mustacchi if (ctf_dwarf_string(cup, cu, DW_AT_name, &name) == 0) { 3126bc1f688bSRobert Mustacchi size_t len = strlen(name) + 1; 3127bc1f688bSRobert Mustacchi char *b = basename(name); 3128bc1f688bSRobert Mustacchi cup->cu_name = strdup(b); 3129bc1f688bSRobert Mustacchi ctf_free(name, len); 3130bc1f688bSRobert Mustacchi } 3131bc1f688bSRobert Mustacchi break; 3132bc1f688bSRobert Mustacchi } 3133bc1f688bSRobert Mustacchi 3134bc1f688bSRobert Mustacchi return (0); 3135bc1f688bSRobert Mustacchi } 3136bc1f688bSRobert Mustacchi 31373eca6103SJohn Levon /* 31383eca6103SJohn Levon * This is our only recourse to identify a C source file that is missing debug 31393eca6103SJohn Levon * info: it will be mentioned as an STT_FILE, but not have a compile unit entry. 31403eca6103SJohn Levon * (A traditional ctfmerge works on individual files, so can identify missing 31413eca6103SJohn Levon * DWARF more directly, via ctf_has_c_source() on the .o file.) 31423eca6103SJohn Levon * 31433eca6103SJohn Levon * As we operate on basenames, this can of course miss some cases, but it's 31443eca6103SJohn Levon * better than not checking at all. 31453eca6103SJohn Levon * 31463eca6103SJohn Levon * We explicitly whitelist some CRT components. Failing that, there's always 31473eca6103SJohn Levon * the -m option. 31483eca6103SJohn Levon */ 31493eca6103SJohn Levon static boolean_t 31503eca6103SJohn Levon c_source_has_debug(const char *file, ctf_cu_t *cus, size_t nr_cus) 31513eca6103SJohn Levon { 31523eca6103SJohn Levon const char *basename = strrchr(file, '/'); 31533eca6103SJohn Levon 31543eca6103SJohn Levon if (basename == NULL) 31553eca6103SJohn Levon basename = file; 31563eca6103SJohn Levon else 31573eca6103SJohn Levon basename++; 31583eca6103SJohn Levon 31593eca6103SJohn Levon if (strcmp(basename, "common-crt.c") == 0 || 31603eca6103SJohn Levon strcmp(basename, "gmon.c") == 0 || 31613eca6103SJohn Levon strcmp(basename, "dlink_init.c") == 0 || 31623eca6103SJohn Levon strcmp(basename, "dlink_common.c") == 0 || 31633eca6103SJohn Levon strncmp(basename, "crt", strlen("crt")) == 0 || 31643eca6103SJohn Levon strncmp(basename, "values-", strlen("values-")) == 0) 31653eca6103SJohn Levon return (B_TRUE); 3166bc1f688bSRobert Mustacchi 31673eca6103SJohn Levon for (size_t i = 0; i < nr_cus; i++) { 31683eca6103SJohn Levon if (strcmp(basename, cus[i].cu_name) == 0) 31693eca6103SJohn Levon return (B_TRUE); 31703eca6103SJohn Levon } 31713eca6103SJohn Levon 31723eca6103SJohn Levon return (B_FALSE); 31733eca6103SJohn Levon } 31743eca6103SJohn Levon 31753eca6103SJohn Levon static int 31763eca6103SJohn Levon ctf_dwarf_check_missing(ctf_cu_t *cus, size_t nr_cus, Elf *elf, 3177bc1f688bSRobert Mustacchi char *errmsg, size_t errlen) 31783eca6103SJohn Levon { 31793eca6103SJohn Levon Elf_Scn *scn, *strscn; 31803eca6103SJohn Levon Elf_Data *data, *strdata; 31813eca6103SJohn Levon GElf_Shdr shdr; 31823eca6103SJohn Levon ulong_t i; 31833eca6103SJohn Levon 31843eca6103SJohn Levon scn = NULL; 31853eca6103SJohn Levon while ((scn = elf_nextscn(elf, scn)) != NULL) { 31863eca6103SJohn Levon if (gelf_getshdr(scn, &shdr) == NULL) { 31873eca6103SJohn Levon (void) snprintf(errmsg, errlen, 31883eca6103SJohn Levon "failed to get section header: %s\n", 31893eca6103SJohn Levon elf_errmsg(elf_errno())); 31903eca6103SJohn Levon return (EINVAL); 31913eca6103SJohn Levon } 31923eca6103SJohn Levon 31933eca6103SJohn Levon if (shdr.sh_type == SHT_SYMTAB) 31943eca6103SJohn Levon break; 31953eca6103SJohn Levon } 31963eca6103SJohn Levon 31973eca6103SJohn Levon if (scn == NULL) 31983eca6103SJohn Levon return (0); 31993eca6103SJohn Levon 32003eca6103SJohn Levon if ((strscn = elf_getscn(elf, shdr.sh_link)) == NULL) { 32013eca6103SJohn Levon (void) snprintf(errmsg, errlen, 32023eca6103SJohn Levon "failed to get str section: %s\n", 32033eca6103SJohn Levon elf_errmsg(elf_errno())); 32043eca6103SJohn Levon return (EINVAL); 32053eca6103SJohn Levon } 32063eca6103SJohn Levon 32073eca6103SJohn Levon if ((data = elf_getdata(scn, NULL)) == NULL) { 32083eca6103SJohn Levon (void) snprintf(errmsg, errlen, "failed to read section: %s\n", 32093eca6103SJohn Levon elf_errmsg(elf_errno())); 32103eca6103SJohn Levon return (EINVAL); 32113eca6103SJohn Levon } 32123eca6103SJohn Levon 32133eca6103SJohn Levon if ((strdata = elf_getdata(strscn, NULL)) == NULL) { 32143eca6103SJohn Levon (void) snprintf(errmsg, errlen, 32153eca6103SJohn Levon "failed to read string table: %s\n", 32163eca6103SJohn Levon elf_errmsg(elf_errno())); 32173eca6103SJohn Levon return (EINVAL); 32183eca6103SJohn Levon } 32193eca6103SJohn Levon 32203eca6103SJohn Levon for (i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) { 32213eca6103SJohn Levon GElf_Sym sym; 32223eca6103SJohn Levon const char *file; 32233eca6103SJohn Levon size_t len; 32243eca6103SJohn Levon 32253eca6103SJohn Levon if (gelf_getsym(data, i, &sym) == NULL) { 32263eca6103SJohn Levon (void) snprintf(errmsg, errlen, 32273eca6103SJohn Levon "failed to read sym %lu: %s\n", 32283eca6103SJohn Levon i, elf_errmsg(elf_errno())); 32293eca6103SJohn Levon return (EINVAL); 32303eca6103SJohn Levon } 32313eca6103SJohn Levon 32323eca6103SJohn Levon if (GELF_ST_TYPE(sym.st_info) != STT_FILE) 32333eca6103SJohn Levon continue; 32343eca6103SJohn Levon 32353eca6103SJohn Levon file = (const char *)((uintptr_t)strdata->d_buf + sym.st_name); 32363eca6103SJohn Levon len = strlen(file); 32373eca6103SJohn Levon if (len < 2 || strncmp(".c", &file[len - 2], 2) != 0) 32383eca6103SJohn Levon continue; 32393eca6103SJohn Levon 32403eca6103SJohn Levon if (!c_source_has_debug(file, cus, nr_cus)) { 32413eca6103SJohn Levon (void) snprintf(errmsg, errlen, 32423eca6103SJohn Levon "file %s is missing debug info\n", file); 32433eca6103SJohn Levon return (ECTF_CONVNODEBUG); 32443eca6103SJohn Levon } 32453eca6103SJohn Levon } 32463eca6103SJohn Levon 32473eca6103SJohn Levon return (0); 32483eca6103SJohn Levon } 32493eca6103SJohn Levon 32503eca6103SJohn Levon int 32513eca6103SJohn Levon ctf_dwarf_convert(int fd, Elf *elf, uint_t nthrs, uint_t flags, 32523eca6103SJohn Levon ctf_file_t **fpp, char *errbuf, size_t errlen) 3253bc1f688bSRobert Mustacchi { 3254bc1f688bSRobert Mustacchi int err, ret, ndies, i; 3255bc1f688bSRobert Mustacchi Dwarf_Debug dw; 3256bc1f688bSRobert Mustacchi Dwarf_Error derr; 3257bc1f688bSRobert Mustacchi ctf_cu_t *cdies = NULL, *cup; 3258bc1f688bSRobert Mustacchi workq_t *wqp = NULL; 3259bc1f688bSRobert Mustacchi 3260bc1f688bSRobert Mustacchi *fpp = NULL; 3261bc1f688bSRobert Mustacchi 3262bc1f688bSRobert Mustacchi ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw, &derr); 3263bc1f688bSRobert Mustacchi if (ret != DW_DLV_OK) { 3264bc1f688bSRobert Mustacchi if (ret == DW_DLV_NO_ENTRY || 3265bc1f688bSRobert Mustacchi dwarf_errno(derr) == DW_DLE_DEBUG_INFO_NULL) { 32663eca6103SJohn Levon (void) snprintf(errbuf, errlen, 32673eca6103SJohn Levon "file does not contain DWARF data\n"); 32683eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3269bc1f688bSRobert Mustacchi } 32703eca6103SJohn Levon 32713eca6103SJohn Levon (void) snprintf(errbuf, errlen, 32723eca6103SJohn Levon "dwarf_elf_init() failed: %s\n", dwarf_errmsg(derr)); 32733eca6103SJohn Levon return (ECTF_CONVBKERR); 3274bc1f688bSRobert Mustacchi } 3275bc1f688bSRobert Mustacchi 3276bc1f688bSRobert Mustacchi /* 3277bc1f688bSRobert Mustacchi * Iterate over all of the compilation units and create a ctf_cu_t for 3278bc1f688bSRobert Mustacchi * each of them. This is used to determine if we have zero, one, or 3279bc1f688bSRobert Mustacchi * multiple dies to convert. If we have zero, that's an error. If 3280bc1f688bSRobert Mustacchi * there's only one die, that's the simple case. No merge needed and 3281bc1f688bSRobert Mustacchi * only a single Dwarf_Debug as well. 3282bc1f688bSRobert Mustacchi */ 3283bc1f688bSRobert Mustacchi ndies = 0; 32843eca6103SJohn Levon err = ctf_dwarf_count_dies(dw, &derr, &ndies, errbuf, errlen); 32853eca6103SJohn Levon 32863eca6103SJohn Levon ctf_dprintf("found %d DWARF CUs\n", ndies); 32873eca6103SJohn Levon 32883eca6103SJohn Levon if (ndies == 0) { 32893eca6103SJohn Levon (void) snprintf(errbuf, errlen, 32903eca6103SJohn Levon "file does not contain DWARF data\n"); 32913eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3292bc1f688bSRobert Mustacchi } 3293bc1f688bSRobert Mustacchi 3294bc1f688bSRobert Mustacchi (void) dwarf_finish(dw, &derr); 3295bc1f688bSRobert Mustacchi cdies = ctf_alloc(sizeof (ctf_cu_t) * ndies); 3296bc1f688bSRobert Mustacchi if (cdies == NULL) { 32973eca6103SJohn Levon return (ENOMEM); 3298bc1f688bSRobert Mustacchi } 3299bc1f688bSRobert Mustacchi 33003eca6103SJohn Levon bzero(cdies, sizeof (ctf_cu_t) * ndies); 33013eca6103SJohn Levon 3302bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3303bc1f688bSRobert Mustacchi cup = &cdies[i]; 3304bc1f688bSRobert Mustacchi ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, 3305bc1f688bSRobert Mustacchi &cup->cu_dwarf, &derr); 3306bc1f688bSRobert Mustacchi if (ret != 0) { 3307bc1f688bSRobert Mustacchi ctf_free(cdies, sizeof (ctf_cu_t) * ndies); 33083eca6103SJohn Levon (void) snprintf(errbuf, errlen, 3309bc1f688bSRobert Mustacchi "failed to initialize DWARF: %s\n", 3310bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 33113eca6103SJohn Levon return (ECTF_CONVBKERR); 3312bc1f688bSRobert Mustacchi } 3313bc1f688bSRobert Mustacchi 33143eca6103SJohn Levon err = ctf_dwarf_init_die(fd, elf, cup, i, errbuf, errlen); 33153eca6103SJohn Levon if (err != 0) 3316bc1f688bSRobert Mustacchi goto out; 331737e82d12SRobert Mustacchi 3318bc1f688bSRobert Mustacchi cup->cu_doweaks = ndies > 1 ? B_FALSE : B_TRUE; 3319bc1f688bSRobert Mustacchi } 3320bc1f688bSRobert Mustacchi 33213eca6103SJohn Levon if (!(flags & CTF_ALLOW_MISSING_DEBUG) && 33223eca6103SJohn Levon (err = ctf_dwarf_check_missing(cdies, ndies, 33233eca6103SJohn Levon elf, errbuf, errlen)) != 0) 33243eca6103SJohn Levon goto out; 3325bc1f688bSRobert Mustacchi 3326bc1f688bSRobert Mustacchi /* 3327bc1f688bSRobert Mustacchi * If we only have one compilation unit, there's no reason to use 3328bc1f688bSRobert Mustacchi * multiple threads, even if the user requested them. After all, they 3329bc1f688bSRobert Mustacchi * just gave us an upper bound. 3330bc1f688bSRobert Mustacchi */ 3331bc1f688bSRobert Mustacchi if (ndies == 1) 3332bc1f688bSRobert Mustacchi nthrs = 1; 3333bc1f688bSRobert Mustacchi 3334bc1f688bSRobert Mustacchi if (workq_init(&wqp, nthrs) == -1) { 33353eca6103SJohn Levon err = errno; 3336bc1f688bSRobert Mustacchi goto out; 3337bc1f688bSRobert Mustacchi } 3338bc1f688bSRobert Mustacchi 3339bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3340bc1f688bSRobert Mustacchi cup = &cdies[i]; 334137e82d12SRobert Mustacchi ctf_dprintf("adding cu %s: %p, %x %x\n", cup->cu_name, 3342bc1f688bSRobert Mustacchi cup->cu_cu, cup->cu_cuoff, cup->cu_maxoff); 3343bc1f688bSRobert Mustacchi if (workq_add(wqp, cup) == -1) { 33443eca6103SJohn Levon err = errno; 3345bc1f688bSRobert Mustacchi goto out; 3346bc1f688bSRobert Mustacchi } 3347bc1f688bSRobert Mustacchi } 3348bc1f688bSRobert Mustacchi 33493eca6103SJohn Levon ret = workq_work(wqp, ctf_dwarf_convert_one, NULL, &err); 3350bc1f688bSRobert Mustacchi if (ret == WORKQ_ERROR) { 33513eca6103SJohn Levon err = errno; 3352bc1f688bSRobert Mustacchi goto out; 3353bc1f688bSRobert Mustacchi } else if (ret == WORKQ_UERROR) { 3354bc1f688bSRobert Mustacchi ctf_dprintf("internal convert failed: %s\n", 33553eca6103SJohn Levon ctf_errmsg(err)); 3356bc1f688bSRobert Mustacchi goto out; 3357bc1f688bSRobert Mustacchi } 3358bc1f688bSRobert Mustacchi 335937e82d12SRobert Mustacchi ctf_dprintf("Determining next phase: have %d CUs\n", ndies); 3360bc1f688bSRobert Mustacchi if (ndies != 1) { 3361bc1f688bSRobert Mustacchi ctf_merge_t *cmp; 3362bc1f688bSRobert Mustacchi 33633eca6103SJohn Levon cmp = ctf_merge_init(fd, &err); 33643eca6103SJohn Levon if (cmp == NULL) 3365bc1f688bSRobert Mustacchi goto out; 3366bc1f688bSRobert Mustacchi 3367bc1f688bSRobert Mustacchi ctf_dprintf("setting threads\n"); 33683eca6103SJohn Levon if ((err = ctf_merge_set_nthreads(cmp, nthrs)) != 0) { 3369bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 3370bc1f688bSRobert Mustacchi goto out; 3371bc1f688bSRobert Mustacchi } 3372bc1f688bSRobert Mustacchi 3373bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3374bc1f688bSRobert Mustacchi cup = &cdies[i]; 33753eca6103SJohn Levon if ((err = ctf_merge_add(cmp, cup->cu_ctfp)) != 0) { 3376bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 3377bc1f688bSRobert Mustacchi goto out; 3378bc1f688bSRobert Mustacchi } 3379bc1f688bSRobert Mustacchi } 3380bc1f688bSRobert Mustacchi 3381bc1f688bSRobert Mustacchi ctf_dprintf("performing merge\n"); 33823eca6103SJohn Levon err = ctf_merge_merge(cmp, fpp); 33833eca6103SJohn Levon if (err != 0) { 3384bc1f688bSRobert Mustacchi ctf_dprintf("failed merge!\n"); 3385bc1f688bSRobert Mustacchi *fpp = NULL; 3386bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 3387bc1f688bSRobert Mustacchi goto out; 3388bc1f688bSRobert Mustacchi } 3389bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 33903eca6103SJohn Levon err = 0; 3391bc1f688bSRobert Mustacchi ctf_dprintf("successfully converted!\n"); 3392bc1f688bSRobert Mustacchi } else { 33933eca6103SJohn Levon err = 0; 3394bc1f688bSRobert Mustacchi *fpp = cdies->cu_ctfp; 3395bc1f688bSRobert Mustacchi cdies->cu_ctfp = NULL; 3396bc1f688bSRobert Mustacchi ctf_dprintf("successfully converted!\n"); 3397bc1f688bSRobert Mustacchi } 3398bc1f688bSRobert Mustacchi 3399bc1f688bSRobert Mustacchi out: 3400bc1f688bSRobert Mustacchi workq_fini(wqp); 3401bc1f688bSRobert Mustacchi ctf_dwarf_free_dies(cdies, ndies); 34023eca6103SJohn Levon return (err); 3403bc1f688bSRobert Mustacchi } 3404