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. 32*2e25d8e1SRobert 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 212bc1f688bSRobert Mustacchi #define DWARF_VARARGS_NAME "..." 213bc1f688bSRobert Mustacchi 214bc1f688bSRobert Mustacchi /* 215bc1f688bSRobert Mustacchi * Dwarf may refer recursively to other types that we've already processed. To 216bc1f688bSRobert Mustacchi * see if we've already converted them, we look them up in an AVL tree that's 217bc1f688bSRobert Mustacchi * sorted by the DWARF id. 218bc1f688bSRobert Mustacchi */ 219bc1f688bSRobert Mustacchi typedef struct ctf_dwmap { 220bc1f688bSRobert Mustacchi avl_node_t cdm_avl; 221bc1f688bSRobert Mustacchi Dwarf_Off cdm_off; 222bc1f688bSRobert Mustacchi Dwarf_Die cdm_die; 223bc1f688bSRobert Mustacchi ctf_id_t cdm_id; 224bc1f688bSRobert Mustacchi boolean_t cdm_fix; 225bc1f688bSRobert Mustacchi } ctf_dwmap_t; 226bc1f688bSRobert Mustacchi 227bc1f688bSRobert Mustacchi typedef struct ctf_dwvar { 228bc1f688bSRobert Mustacchi ctf_list_t cdv_list; 229bc1f688bSRobert Mustacchi char *cdv_name; 230bc1f688bSRobert Mustacchi ctf_id_t cdv_type; 231bc1f688bSRobert Mustacchi boolean_t cdv_global; 232bc1f688bSRobert Mustacchi } ctf_dwvar_t; 233bc1f688bSRobert Mustacchi 234bc1f688bSRobert Mustacchi typedef struct ctf_dwfunc { 235bc1f688bSRobert Mustacchi ctf_list_t cdf_list; 236bc1f688bSRobert Mustacchi char *cdf_name; 237bc1f688bSRobert Mustacchi ctf_funcinfo_t cdf_fip; 238bc1f688bSRobert Mustacchi ctf_id_t *cdf_argv; 239bc1f688bSRobert Mustacchi boolean_t cdf_global; 240bc1f688bSRobert Mustacchi } ctf_dwfunc_t; 241bc1f688bSRobert Mustacchi 242bc1f688bSRobert Mustacchi typedef struct ctf_dwbitf { 243bc1f688bSRobert Mustacchi ctf_list_t cdb_list; 244bc1f688bSRobert Mustacchi ctf_id_t cdb_base; 245bc1f688bSRobert Mustacchi uint_t cdb_nbits; 246bc1f688bSRobert Mustacchi ctf_id_t cdb_id; 247bc1f688bSRobert Mustacchi } ctf_dwbitf_t; 248bc1f688bSRobert Mustacchi 249bc1f688bSRobert Mustacchi /* 250bc1f688bSRobert Mustacchi * The ctf_cu_t represents a single top-level DWARF die unit. While generally, 251bc1f688bSRobert Mustacchi * the typical object file has only a single die, if we're asked to convert 252bc1f688bSRobert Mustacchi * something that's been linked from multiple sources, multiple dies will exist. 253bc1f688bSRobert Mustacchi */ 254bc1f688bSRobert Mustacchi typedef struct ctf_die { 255bc1f688bSRobert Mustacchi Elf *cu_elf; /* shared libelf handle */ 256bc1f688bSRobert Mustacchi char *cu_name; /* basename of the DIE */ 257bc1f688bSRobert Mustacchi ctf_merge_t *cu_cmh; /* merge handle */ 258bc1f688bSRobert Mustacchi ctf_list_t cu_vars; /* List of variables */ 259bc1f688bSRobert Mustacchi ctf_list_t cu_funcs; /* List of functions */ 260bc1f688bSRobert Mustacchi ctf_list_t cu_bitfields; /* Bit field members */ 261bc1f688bSRobert Mustacchi Dwarf_Debug cu_dwarf; /* libdwarf handle */ 262bc1f688bSRobert Mustacchi Dwarf_Die cu_cu; /* libdwarf compilation unit */ 263bc1f688bSRobert Mustacchi Dwarf_Off cu_cuoff; /* cu's offset */ 264bc1f688bSRobert Mustacchi Dwarf_Off cu_maxoff; /* maximum offset */ 265bc1f688bSRobert Mustacchi ctf_file_t *cu_ctfp; /* output CTF file */ 266bc1f688bSRobert Mustacchi avl_tree_t cu_map; /* map die offsets to CTF types */ 267bc1f688bSRobert Mustacchi char *cu_errbuf; /* error message buffer */ 268bc1f688bSRobert Mustacchi size_t cu_errlen; /* error message buffer length */ 269bc1f688bSRobert Mustacchi size_t cu_ptrsz; /* object's pointer size */ 270bc1f688bSRobert Mustacchi boolean_t cu_bigend; /* is it big endian */ 271bc1f688bSRobert Mustacchi boolean_t cu_doweaks; /* should we convert weak symbols? */ 272bc1f688bSRobert Mustacchi uint_t cu_mach; /* machine type */ 273bc1f688bSRobert Mustacchi ctf_id_t cu_voidtid; /* void pointer */ 274bc1f688bSRobert Mustacchi ctf_id_t cu_longtid; /* id for a 'long' */ 275bc1f688bSRobert Mustacchi } ctf_cu_t; 276bc1f688bSRobert Mustacchi 277bc1f688bSRobert Mustacchi static int ctf_dwarf_offset(ctf_cu_t *, Dwarf_Die, Dwarf_Off *); 278bc1f688bSRobert Mustacchi static int ctf_dwarf_convert_die(ctf_cu_t *, Dwarf_Die); 279bc1f688bSRobert Mustacchi static int ctf_dwarf_convert_type(ctf_cu_t *, Dwarf_Die, ctf_id_t *, int); 280bc1f688bSRobert Mustacchi 281bc1f688bSRobert Mustacchi static int ctf_dwarf_function_count(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *, 282bc1f688bSRobert Mustacchi boolean_t); 283bc1f688bSRobert Mustacchi static int ctf_dwarf_convert_fargs(ctf_cu_t *, Dwarf_Die, ctf_funcinfo_t *, 284bc1f688bSRobert Mustacchi ctf_id_t *); 285bc1f688bSRobert Mustacchi 286bc1f688bSRobert Mustacchi /* 287bc1f688bSRobert Mustacchi * This is a generic way to set a CTF Conversion backend error depending on what 288bc1f688bSRobert Mustacchi * we were doing. Unless it was one of a specific set of errors that don't 289bc1f688bSRobert Mustacchi * indicate a programming / translation bug, eg. ENOMEM, then we transform it 290bc1f688bSRobert Mustacchi * into a CTF backend error and fill in the error buffer. 291bc1f688bSRobert Mustacchi */ 292bc1f688bSRobert Mustacchi static int 293bc1f688bSRobert Mustacchi ctf_dwarf_error(ctf_cu_t *cup, ctf_file_t *cfp, int err, const char *fmt, ...) 294bc1f688bSRobert Mustacchi { 295bc1f688bSRobert Mustacchi va_list ap; 296bc1f688bSRobert Mustacchi int ret; 297bc1f688bSRobert Mustacchi size_t off = 0; 298bc1f688bSRobert Mustacchi ssize_t rem = cup->cu_errlen; 299bc1f688bSRobert Mustacchi if (cfp != NULL) 300bc1f688bSRobert Mustacchi err = ctf_errno(cfp); 301bc1f688bSRobert Mustacchi 302bc1f688bSRobert Mustacchi if (err == ENOMEM) 303bc1f688bSRobert Mustacchi return (err); 304bc1f688bSRobert Mustacchi 305bc1f688bSRobert Mustacchi ret = snprintf(cup->cu_errbuf, rem, "die %s: ", cup->cu_name); 306bc1f688bSRobert Mustacchi if (ret < 0) 307bc1f688bSRobert Mustacchi goto err; 308bc1f688bSRobert Mustacchi off += ret; 309bc1f688bSRobert Mustacchi rem = MAX(rem - ret, 0); 310bc1f688bSRobert Mustacchi 311bc1f688bSRobert Mustacchi va_start(ap, fmt); 312bc1f688bSRobert Mustacchi ret = vsnprintf(cup->cu_errbuf + off, rem, fmt, ap); 313bc1f688bSRobert Mustacchi va_end(ap); 314bc1f688bSRobert Mustacchi if (ret < 0) 315bc1f688bSRobert Mustacchi goto err; 316bc1f688bSRobert Mustacchi 317bc1f688bSRobert Mustacchi off += ret; 318bc1f688bSRobert Mustacchi rem = MAX(rem - ret, 0); 319bc1f688bSRobert Mustacchi if (fmt[strlen(fmt) - 1] != '\n') { 320bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf + off, rem, 321bc1f688bSRobert Mustacchi ": %s\n", ctf_errmsg(err)); 322bc1f688bSRobert Mustacchi } 323bc1f688bSRobert Mustacchi va_end(ap); 324bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 325bc1f688bSRobert Mustacchi 326bc1f688bSRobert Mustacchi err: 327bc1f688bSRobert Mustacchi cup->cu_errbuf[0] = '\0'; 328bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 329bc1f688bSRobert Mustacchi } 330bc1f688bSRobert Mustacchi 331bc1f688bSRobert Mustacchi /* 332bc1f688bSRobert Mustacchi * DWARF often opts to put no explicit type to describe a void type. eg. if we 333bc1f688bSRobert Mustacchi * have a reference type whose DW_AT_type member doesn't exist, then we should 334bc1f688bSRobert Mustacchi * instead assume it points to void. Because this isn't represented, we 335bc1f688bSRobert Mustacchi * instead cause it to come into existence. 336bc1f688bSRobert Mustacchi */ 337bc1f688bSRobert Mustacchi static ctf_id_t 338bc1f688bSRobert Mustacchi ctf_dwarf_void(ctf_cu_t *cup) 339bc1f688bSRobert Mustacchi { 340bc1f688bSRobert Mustacchi if (cup->cu_voidtid == CTF_ERR) { 341bc1f688bSRobert Mustacchi ctf_encoding_t enc = { CTF_INT_SIGNED, 0, 0 }; 342bc1f688bSRobert Mustacchi cup->cu_voidtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_ROOT, 343bc1f688bSRobert Mustacchi "void", &enc); 344bc1f688bSRobert Mustacchi if (cup->cu_voidtid == CTF_ERR) { 345bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 346bc1f688bSRobert Mustacchi "failed to create void type: %s\n", 347bc1f688bSRobert Mustacchi ctf_errmsg(ctf_errno(cup->cu_ctfp))); 348bc1f688bSRobert Mustacchi } 349bc1f688bSRobert Mustacchi } 350bc1f688bSRobert Mustacchi 351bc1f688bSRobert Mustacchi return (cup->cu_voidtid); 352bc1f688bSRobert Mustacchi } 353bc1f688bSRobert Mustacchi 354bc1f688bSRobert Mustacchi /* 355bc1f688bSRobert Mustacchi * There are many different forms that an array index may take. However, we just 356bc1f688bSRobert Mustacchi * always force it to be of a type long no matter what. Therefore we use this to 357bc1f688bSRobert Mustacchi * have a single instance of long across everything. 358bc1f688bSRobert Mustacchi */ 359bc1f688bSRobert Mustacchi static ctf_id_t 360bc1f688bSRobert Mustacchi ctf_dwarf_long(ctf_cu_t *cup) 361bc1f688bSRobert Mustacchi { 362bc1f688bSRobert Mustacchi if (cup->cu_longtid == CTF_ERR) { 363bc1f688bSRobert Mustacchi ctf_encoding_t enc; 364bc1f688bSRobert Mustacchi 365bc1f688bSRobert Mustacchi enc.cte_format = CTF_INT_SIGNED; 366bc1f688bSRobert Mustacchi enc.cte_offset = 0; 367bc1f688bSRobert Mustacchi /* All illumos systems are LP */ 368bc1f688bSRobert Mustacchi enc.cte_bits = cup->cu_ptrsz * 8; 369bc1f688bSRobert Mustacchi cup->cu_longtid = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT, 370bc1f688bSRobert Mustacchi "long", &enc); 371bc1f688bSRobert Mustacchi if (cup->cu_longtid == CTF_ERR) { 372bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 373bc1f688bSRobert Mustacchi "failed to create long type: %s\n", 374bc1f688bSRobert Mustacchi ctf_errmsg(ctf_errno(cup->cu_ctfp))); 375bc1f688bSRobert Mustacchi } 376bc1f688bSRobert Mustacchi 377bc1f688bSRobert Mustacchi } 378bc1f688bSRobert Mustacchi 379bc1f688bSRobert Mustacchi return (cup->cu_longtid); 380bc1f688bSRobert Mustacchi } 381bc1f688bSRobert Mustacchi 382bc1f688bSRobert Mustacchi static int 383bc1f688bSRobert Mustacchi ctf_dwmap_comp(const void *a, const void *b) 384bc1f688bSRobert Mustacchi { 385bc1f688bSRobert Mustacchi const ctf_dwmap_t *ca = a; 386bc1f688bSRobert Mustacchi const ctf_dwmap_t *cb = b; 387bc1f688bSRobert Mustacchi 388bc1f688bSRobert Mustacchi if (ca->cdm_off > cb->cdm_off) 389bc1f688bSRobert Mustacchi return (1); 390bc1f688bSRobert Mustacchi if (ca->cdm_off < cb->cdm_off) 391bc1f688bSRobert Mustacchi return (-1); 392bc1f688bSRobert Mustacchi return (0); 393bc1f688bSRobert Mustacchi } 394bc1f688bSRobert Mustacchi 395bc1f688bSRobert Mustacchi static int 396bc1f688bSRobert Mustacchi ctf_dwmap_add(ctf_cu_t *cup, ctf_id_t id, Dwarf_Die die, boolean_t fix) 397bc1f688bSRobert Mustacchi { 398bc1f688bSRobert Mustacchi int ret; 399bc1f688bSRobert Mustacchi avl_index_t index; 400bc1f688bSRobert Mustacchi ctf_dwmap_t *dwmap; 401bc1f688bSRobert Mustacchi Dwarf_Off off; 402bc1f688bSRobert Mustacchi 403bc1f688bSRobert Mustacchi VERIFY(id > 0 && id < CTF_MAX_TYPE); 404bc1f688bSRobert Mustacchi 405bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, die, &off)) != 0) 406bc1f688bSRobert Mustacchi return (ret); 407bc1f688bSRobert Mustacchi 408bc1f688bSRobert Mustacchi if ((dwmap = ctf_alloc(sizeof (ctf_dwmap_t))) == NULL) 409bc1f688bSRobert Mustacchi return (ENOMEM); 410bc1f688bSRobert Mustacchi 411bc1f688bSRobert Mustacchi dwmap->cdm_die = die; 412bc1f688bSRobert Mustacchi dwmap->cdm_off = off; 413bc1f688bSRobert Mustacchi dwmap->cdm_id = id; 414bc1f688bSRobert Mustacchi dwmap->cdm_fix = fix; 415bc1f688bSRobert Mustacchi 416bc1f688bSRobert Mustacchi ctf_dprintf("dwmap: %p %" DW_PR_DUx "->%d\n", dwmap, off, id); 417bc1f688bSRobert Mustacchi VERIFY(avl_find(&cup->cu_map, dwmap, &index) == NULL); 418bc1f688bSRobert Mustacchi avl_insert(&cup->cu_map, dwmap, index); 419bc1f688bSRobert Mustacchi return (0); 420bc1f688bSRobert Mustacchi } 421bc1f688bSRobert Mustacchi 422bc1f688bSRobert Mustacchi static int 423bc1f688bSRobert Mustacchi ctf_dwarf_attribute(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 424bc1f688bSRobert Mustacchi Dwarf_Attribute *attrp) 425bc1f688bSRobert Mustacchi { 426bc1f688bSRobert Mustacchi int ret; 427bc1f688bSRobert Mustacchi Dwarf_Error derr; 428bc1f688bSRobert Mustacchi 429bc1f688bSRobert Mustacchi if ((ret = dwarf_attr(die, name, attrp, &derr)) == DW_DLV_OK) 430bc1f688bSRobert Mustacchi return (0); 431bc1f688bSRobert Mustacchi if (ret == DW_DLV_NO_ENTRY) { 432bc1f688bSRobert Mustacchi *attrp = NULL; 433bc1f688bSRobert Mustacchi return (ENOENT); 434bc1f688bSRobert Mustacchi } 435bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 436bc1f688bSRobert Mustacchi "failed to get attribute for type: %s\n", 437bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 438bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 439bc1f688bSRobert Mustacchi } 440bc1f688bSRobert Mustacchi 441bc1f688bSRobert Mustacchi static int 442bc1f688bSRobert Mustacchi ctf_dwarf_ref(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, Dwarf_Off *refp) 443bc1f688bSRobert Mustacchi { 444bc1f688bSRobert Mustacchi int ret; 445bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 446bc1f688bSRobert Mustacchi Dwarf_Error derr; 447bc1f688bSRobert Mustacchi 448bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 449bc1f688bSRobert Mustacchi return (ret); 450bc1f688bSRobert Mustacchi 451bc1f688bSRobert Mustacchi if (dwarf_formref(attr, refp, &derr) == DW_DLV_OK) { 452bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 453bc1f688bSRobert Mustacchi return (0); 454bc1f688bSRobert Mustacchi } 455bc1f688bSRobert Mustacchi 456bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 457bc1f688bSRobert Mustacchi "failed to get unsigned attribute for type: %s\n", 458bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 459bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 460bc1f688bSRobert Mustacchi } 461bc1f688bSRobert Mustacchi 462bc1f688bSRobert Mustacchi static int 463bc1f688bSRobert Mustacchi ctf_dwarf_refdie(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 464bc1f688bSRobert Mustacchi Dwarf_Die *diep) 465bc1f688bSRobert Mustacchi { 466bc1f688bSRobert Mustacchi int ret; 467bc1f688bSRobert Mustacchi Dwarf_Off off; 468bc1f688bSRobert Mustacchi Dwarf_Error derr; 469bc1f688bSRobert Mustacchi 470bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_ref(cup, die, name, &off)) != 0) 471bc1f688bSRobert Mustacchi return (ret); 472bc1f688bSRobert Mustacchi 473bc1f688bSRobert Mustacchi off += cup->cu_cuoff; 474bc1f688bSRobert Mustacchi if ((ret = dwarf_offdie(cup->cu_dwarf, off, diep, &derr)) != 475bc1f688bSRobert Mustacchi DW_DLV_OK) { 476bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 477bc1f688bSRobert Mustacchi "failed to get die from offset %" DW_PR_DUu ": %s\n", 478bc1f688bSRobert Mustacchi off, dwarf_errmsg(derr)); 479bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 480bc1f688bSRobert Mustacchi } 481bc1f688bSRobert Mustacchi 482bc1f688bSRobert Mustacchi return (0); 483bc1f688bSRobert Mustacchi } 484bc1f688bSRobert Mustacchi 485bc1f688bSRobert Mustacchi static int 486bc1f688bSRobert Mustacchi ctf_dwarf_signed(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 487bc1f688bSRobert Mustacchi Dwarf_Signed *valp) 488bc1f688bSRobert Mustacchi { 489bc1f688bSRobert Mustacchi int ret; 490bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 491bc1f688bSRobert Mustacchi Dwarf_Error derr; 492bc1f688bSRobert Mustacchi 493bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 494bc1f688bSRobert Mustacchi return (ret); 495bc1f688bSRobert Mustacchi 496bc1f688bSRobert Mustacchi if (dwarf_formsdata(attr, valp, &derr) == DW_DLV_OK) { 497bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 498bc1f688bSRobert Mustacchi return (0); 499bc1f688bSRobert Mustacchi } 500bc1f688bSRobert Mustacchi 501bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 502bc1f688bSRobert Mustacchi "failed to get unsigned attribute for type: %s\n", 503bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 504bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 505bc1f688bSRobert Mustacchi } 506bc1f688bSRobert Mustacchi 507bc1f688bSRobert Mustacchi static int 508bc1f688bSRobert Mustacchi ctf_dwarf_unsigned(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 509bc1f688bSRobert Mustacchi Dwarf_Unsigned *valp) 510bc1f688bSRobert Mustacchi { 511bc1f688bSRobert Mustacchi int ret; 512bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 513bc1f688bSRobert Mustacchi Dwarf_Error derr; 514bc1f688bSRobert Mustacchi 515bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 516bc1f688bSRobert Mustacchi return (ret); 517bc1f688bSRobert Mustacchi 518bc1f688bSRobert Mustacchi if (dwarf_formudata(attr, valp, &derr) == DW_DLV_OK) { 519bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 520bc1f688bSRobert Mustacchi return (0); 521bc1f688bSRobert Mustacchi } 522bc1f688bSRobert Mustacchi 523bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 524bc1f688bSRobert Mustacchi "failed to get unsigned attribute for type: %s\n", 525bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 526bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 527bc1f688bSRobert Mustacchi } 528bc1f688bSRobert Mustacchi 529bc1f688bSRobert Mustacchi static int 530bc1f688bSRobert Mustacchi ctf_dwarf_boolean(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, 531bc1f688bSRobert Mustacchi Dwarf_Bool *val) 532bc1f688bSRobert Mustacchi { 533bc1f688bSRobert Mustacchi int ret; 534bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 535bc1f688bSRobert Mustacchi Dwarf_Error derr; 536bc1f688bSRobert Mustacchi 537bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 538bc1f688bSRobert Mustacchi return (ret); 539bc1f688bSRobert Mustacchi 540bc1f688bSRobert Mustacchi if (dwarf_formflag(attr, val, &derr) == DW_DLV_OK) { 541bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 542bc1f688bSRobert Mustacchi return (0); 543bc1f688bSRobert Mustacchi } 544bc1f688bSRobert Mustacchi 545bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 546bc1f688bSRobert Mustacchi "failed to get boolean attribute for type: %s\n", 547bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 548bc1f688bSRobert Mustacchi 549bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 550bc1f688bSRobert Mustacchi } 551bc1f688bSRobert Mustacchi 552bc1f688bSRobert Mustacchi static int 553bc1f688bSRobert Mustacchi ctf_dwarf_string(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half name, char **strp) 554bc1f688bSRobert Mustacchi { 555bc1f688bSRobert Mustacchi int ret; 556bc1f688bSRobert Mustacchi char *s; 557bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 558bc1f688bSRobert Mustacchi Dwarf_Error derr; 559bc1f688bSRobert Mustacchi 560bc1f688bSRobert Mustacchi *strp = NULL; 561bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, name, &attr)) != 0) 562bc1f688bSRobert Mustacchi return (ret); 563bc1f688bSRobert Mustacchi 564bc1f688bSRobert Mustacchi if (dwarf_formstring(attr, &s, &derr) == DW_DLV_OK) { 565bc1f688bSRobert Mustacchi if ((*strp = ctf_strdup(s)) == NULL) 566bc1f688bSRobert Mustacchi ret = ENOMEM; 567bc1f688bSRobert Mustacchi else 568bc1f688bSRobert Mustacchi ret = 0; 569bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 570bc1f688bSRobert Mustacchi return (ret); 571bc1f688bSRobert Mustacchi } 572bc1f688bSRobert Mustacchi 573bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 574bc1f688bSRobert Mustacchi "failed to get string attribute for type: %s\n", 575bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 576bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 577bc1f688bSRobert Mustacchi } 578bc1f688bSRobert Mustacchi 579bc1f688bSRobert Mustacchi static int 580bc1f688bSRobert Mustacchi ctf_dwarf_member_location(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Unsigned *valp) 581bc1f688bSRobert Mustacchi { 582bc1f688bSRobert Mustacchi int ret; 583bc1f688bSRobert Mustacchi Dwarf_Error derr; 584bc1f688bSRobert Mustacchi Dwarf_Attribute attr; 585bc1f688bSRobert Mustacchi Dwarf_Locdesc *loc; 586bc1f688bSRobert Mustacchi Dwarf_Signed locnum; 587bc1f688bSRobert Mustacchi 588bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_attribute(cup, die, DW_AT_data_member_location, 589bc1f688bSRobert Mustacchi &attr)) != 0) 590bc1f688bSRobert Mustacchi return (ret); 591bc1f688bSRobert Mustacchi 592bc1f688bSRobert Mustacchi if (dwarf_loclist(attr, &loc, &locnum, &derr) != DW_DLV_OK) { 593bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 594bc1f688bSRobert Mustacchi "failed to obtain location list for member offset: %s", 595bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 596bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 597bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 598bc1f688bSRobert Mustacchi } 599bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, attr, DW_DLA_ATTR); 600bc1f688bSRobert Mustacchi 601bc1f688bSRobert Mustacchi if (locnum != 1 || loc->ld_s->lr_atom != DW_OP_plus_uconst) { 602bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 603bc1f688bSRobert Mustacchi "failed to parse location structure for member"); 604bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK); 605bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC); 606bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 607bc1f688bSRobert Mustacchi } 608bc1f688bSRobert Mustacchi 609bc1f688bSRobert Mustacchi *valp = loc->ld_s->lr_number; 610bc1f688bSRobert Mustacchi 611bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc->ld_s, DW_DLA_LOC_BLOCK); 612bc1f688bSRobert Mustacchi dwarf_dealloc(cup->cu_dwarf, loc, DW_DLA_LOCDESC); 613bc1f688bSRobert Mustacchi return (0); 614bc1f688bSRobert Mustacchi } 615bc1f688bSRobert Mustacchi 616bc1f688bSRobert Mustacchi 617bc1f688bSRobert Mustacchi static int 618bc1f688bSRobert Mustacchi ctf_dwarf_offset(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Off *offsetp) 619bc1f688bSRobert Mustacchi { 620bc1f688bSRobert Mustacchi Dwarf_Error derr; 621bc1f688bSRobert Mustacchi 622bc1f688bSRobert Mustacchi if (dwarf_dieoffset(die, offsetp, &derr) == DW_DLV_OK) 623bc1f688bSRobert Mustacchi return (0); 624bc1f688bSRobert Mustacchi 625bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 626bc1f688bSRobert Mustacchi "failed to get die offset: %s\n", 627bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 628bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 629bc1f688bSRobert Mustacchi } 630bc1f688bSRobert Mustacchi 631bc1f688bSRobert Mustacchi /* simpler variant for debugging output */ 632bc1f688bSRobert Mustacchi static Dwarf_Off 633bc1f688bSRobert Mustacchi ctf_die_offset(Dwarf_Die die) 634bc1f688bSRobert Mustacchi { 635bc1f688bSRobert Mustacchi Dwarf_Off off = -1; 636bc1f688bSRobert Mustacchi Dwarf_Error derr; 637bc1f688bSRobert Mustacchi 638bc1f688bSRobert Mustacchi (void) dwarf_dieoffset(die, &off, &derr); 639bc1f688bSRobert Mustacchi return (off); 640bc1f688bSRobert Mustacchi } 641bc1f688bSRobert Mustacchi 642bc1f688bSRobert Mustacchi static int 643bc1f688bSRobert Mustacchi ctf_dwarf_tag(ctf_cu_t *cup, Dwarf_Die die, Dwarf_Half *tagp) 644bc1f688bSRobert Mustacchi { 645bc1f688bSRobert Mustacchi Dwarf_Error derr; 646bc1f688bSRobert Mustacchi 647bc1f688bSRobert Mustacchi if (dwarf_tag(die, tagp, &derr) == DW_DLV_OK) 648bc1f688bSRobert Mustacchi return (0); 649bc1f688bSRobert Mustacchi 650bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 651bc1f688bSRobert Mustacchi "failed to get tag type: %s\n", 652bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 653bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 654bc1f688bSRobert Mustacchi } 655bc1f688bSRobert Mustacchi 656bc1f688bSRobert Mustacchi static int 657bc1f688bSRobert Mustacchi ctf_dwarf_sib(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *sibp) 658bc1f688bSRobert Mustacchi { 659bc1f688bSRobert Mustacchi Dwarf_Error derr; 660bc1f688bSRobert Mustacchi int ret; 661bc1f688bSRobert Mustacchi 662bc1f688bSRobert Mustacchi *sibp = NULL; 663bc1f688bSRobert Mustacchi ret = dwarf_siblingof(cup->cu_dwarf, base, sibp, &derr); 664bc1f688bSRobert Mustacchi if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY) 665bc1f688bSRobert Mustacchi return (0); 666bc1f688bSRobert Mustacchi 667bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 668bc1f688bSRobert Mustacchi "failed to sibling from die: %s\n", 669bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 670bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 671bc1f688bSRobert Mustacchi } 672bc1f688bSRobert Mustacchi 673bc1f688bSRobert Mustacchi static int 674bc1f688bSRobert Mustacchi ctf_dwarf_child(ctf_cu_t *cup, Dwarf_Die base, Dwarf_Die *childp) 675bc1f688bSRobert Mustacchi { 676bc1f688bSRobert Mustacchi Dwarf_Error derr; 677bc1f688bSRobert Mustacchi int ret; 678bc1f688bSRobert Mustacchi 679bc1f688bSRobert Mustacchi *childp = NULL; 680bc1f688bSRobert Mustacchi ret = dwarf_child(base, childp, &derr); 681bc1f688bSRobert Mustacchi if (ret == DW_DLV_OK || ret == DW_DLV_NO_ENTRY) 682bc1f688bSRobert Mustacchi return (0); 683bc1f688bSRobert Mustacchi 684bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 685bc1f688bSRobert Mustacchi "failed to child from die: %s\n", 686bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 687bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 688bc1f688bSRobert Mustacchi } 689bc1f688bSRobert Mustacchi 690bc1f688bSRobert Mustacchi /* 691bc1f688bSRobert Mustacchi * Compilers disagree on what to do to determine if something has global 692bc1f688bSRobert Mustacchi * visiblity. Traditionally gcc has used DW_AT_external to indicate this while 693bc1f688bSRobert Mustacchi * Studio has used DW_AT_visibility. We check DW_AT_visibility first and then 694bc1f688bSRobert Mustacchi * fall back to DW_AT_external. Lack of DW_AT_external implies that it is not. 695bc1f688bSRobert Mustacchi */ 696bc1f688bSRobert Mustacchi static int 697bc1f688bSRobert Mustacchi ctf_dwarf_isglobal(ctf_cu_t *cup, Dwarf_Die die, boolean_t *igp) 698bc1f688bSRobert Mustacchi { 699bc1f688bSRobert Mustacchi int ret; 700bc1f688bSRobert Mustacchi Dwarf_Signed vis; 701bc1f688bSRobert Mustacchi Dwarf_Bool ext; 702bc1f688bSRobert Mustacchi 703bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_signed(cup, die, DW_AT_visibility, &vis)) == 0) { 704bc1f688bSRobert Mustacchi *igp = vis == DW_VIS_exported; 705bc1f688bSRobert Mustacchi return (0); 706bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 707bc1f688bSRobert Mustacchi return (ret); 708bc1f688bSRobert Mustacchi } 709bc1f688bSRobert Mustacchi 710bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_external, &ext)) != 0) { 711bc1f688bSRobert Mustacchi if (ret == ENOENT) { 712bc1f688bSRobert Mustacchi *igp = B_FALSE; 713bc1f688bSRobert Mustacchi return (0); 714bc1f688bSRobert Mustacchi } 715bc1f688bSRobert Mustacchi return (ret); 716bc1f688bSRobert Mustacchi } 717bc1f688bSRobert Mustacchi *igp = ext != 0 ? B_TRUE : B_FALSE; 718bc1f688bSRobert Mustacchi return (0); 719bc1f688bSRobert Mustacchi } 720bc1f688bSRobert Mustacchi 721bc1f688bSRobert Mustacchi static int 722bc1f688bSRobert Mustacchi ctf_dwarf_die_elfenc(Elf *elf, ctf_cu_t *cup, char *errbuf, size_t errlen) 723bc1f688bSRobert Mustacchi { 724bc1f688bSRobert Mustacchi GElf_Ehdr ehdr; 725bc1f688bSRobert Mustacchi 726bc1f688bSRobert Mustacchi if (gelf_getehdr(elf, &ehdr) == NULL) { 727bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 728bc1f688bSRobert Mustacchi "failed to get ELF header: %s\n", 729bc1f688bSRobert Mustacchi elf_errmsg(elf_errno())); 730bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 731bc1f688bSRobert Mustacchi } 732bc1f688bSRobert Mustacchi 733bc1f688bSRobert Mustacchi cup->cu_mach = ehdr.e_machine; 734bc1f688bSRobert Mustacchi 735bc1f688bSRobert Mustacchi if (ehdr.e_ident[EI_CLASS] == ELFCLASS32) { 736bc1f688bSRobert Mustacchi cup->cu_ptrsz = 4; 737bc1f688bSRobert Mustacchi VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_ILP32) == 0); 738bc1f688bSRobert Mustacchi } else if (ehdr.e_ident[EI_CLASS] == ELFCLASS64) { 739bc1f688bSRobert Mustacchi cup->cu_ptrsz = 8; 740bc1f688bSRobert Mustacchi VERIFY(ctf_setmodel(cup->cu_ctfp, CTF_MODEL_LP64) == 0); 741bc1f688bSRobert Mustacchi } else { 742bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 743bc1f688bSRobert Mustacchi "unknown ELF class %d", ehdr.e_ident[EI_CLASS]); 744bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 745bc1f688bSRobert Mustacchi } 746bc1f688bSRobert Mustacchi 747bc1f688bSRobert Mustacchi if (ehdr.e_ident[EI_DATA] == ELFDATA2LSB) { 748bc1f688bSRobert Mustacchi cup->cu_bigend = B_FALSE; 749bc1f688bSRobert Mustacchi } else if (ehdr.e_ident[EI_DATA] == ELFDATA2MSB) { 750bc1f688bSRobert Mustacchi cup->cu_bigend = B_TRUE; 751bc1f688bSRobert Mustacchi } else { 752bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 753bc1f688bSRobert Mustacchi "unknown ELF data encoding: %hhu", ehdr.e_ident[EI_DATA]); 754bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 755bc1f688bSRobert Mustacchi } 756bc1f688bSRobert Mustacchi 757bc1f688bSRobert Mustacchi return (0); 758bc1f688bSRobert Mustacchi } 759bc1f688bSRobert Mustacchi 760bc1f688bSRobert Mustacchi typedef struct ctf_dwarf_fpent { 761bc1f688bSRobert Mustacchi size_t cdfe_size; 762bc1f688bSRobert Mustacchi uint_t cdfe_enc[3]; 763bc1f688bSRobert Mustacchi } ctf_dwarf_fpent_t; 764bc1f688bSRobert Mustacchi 765bc1f688bSRobert Mustacchi typedef struct ctf_dwarf_fpmap { 766bc1f688bSRobert Mustacchi uint_t cdf_mach; 767bc1f688bSRobert Mustacchi ctf_dwarf_fpent_t cdf_ents[4]; 768bc1f688bSRobert Mustacchi } ctf_dwarf_fpmap_t; 769bc1f688bSRobert Mustacchi 770bc1f688bSRobert Mustacchi static const ctf_dwarf_fpmap_t ctf_dwarf_fpmaps[] = { 771bc1f688bSRobert Mustacchi { EM_SPARC, { 772bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 773bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 774bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 775bc1f688bSRobert Mustacchi { 0, { 0 } } 776bc1f688bSRobert Mustacchi } }, 777bc1f688bSRobert Mustacchi { EM_SPARC32PLUS, { 778bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 779bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 780bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 781bc1f688bSRobert Mustacchi { 0, { 0 } } 782bc1f688bSRobert Mustacchi } }, 783bc1f688bSRobert Mustacchi { EM_SPARCV9, { 784bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 785bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 786bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 787bc1f688bSRobert Mustacchi { 0, { 0 } } 788bc1f688bSRobert Mustacchi } }, 789bc1f688bSRobert Mustacchi { EM_386, { 790bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 791bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 792bc1f688bSRobert Mustacchi { 12, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 793bc1f688bSRobert Mustacchi { 0, { 0 } } 794bc1f688bSRobert Mustacchi } }, 795bc1f688bSRobert Mustacchi { EM_X86_64, { 796bc1f688bSRobert Mustacchi { 4, { CTF_FP_SINGLE, CTF_FP_CPLX, CTF_FP_IMAGRY } }, 797bc1f688bSRobert Mustacchi { 8, { CTF_FP_DOUBLE, CTF_FP_DCPLX, CTF_FP_DIMAGRY } }, 798bc1f688bSRobert Mustacchi { 16, { CTF_FP_LDOUBLE, CTF_FP_LDCPLX, CTF_FP_LDIMAGRY } }, 799bc1f688bSRobert Mustacchi { 0, { 0 } } 800bc1f688bSRobert Mustacchi } }, 801bc1f688bSRobert Mustacchi { EM_NONE } 802bc1f688bSRobert Mustacchi }; 803bc1f688bSRobert Mustacchi 804*2e25d8e1SRobert Mustacchi /* 805*2e25d8e1SRobert Mustacchi * We want to normalize the type names that are used between compilers in the 806*2e25d8e1SRobert Mustacchi * case of complex. gcc prefixes things with types like 'long complex' where as 807*2e25d8e1SRobert Mustacchi * clang only calls them 'complex' in the dwarf even if in the C they are long 808*2e25d8e1SRobert Mustacchi * complex or similar. 809*2e25d8e1SRobert Mustacchi */ 810*2e25d8e1SRobert Mustacchi static int 811*2e25d8e1SRobert Mustacchi ctf_dwarf_fixup_complex(ctf_cu_t *cup, ctf_encoding_t *enc, char **namep) 812*2e25d8e1SRobert Mustacchi { 813*2e25d8e1SRobert Mustacchi const char *name; 814*2e25d8e1SRobert Mustacchi *namep = NULL; 815*2e25d8e1SRobert Mustacchi 816*2e25d8e1SRobert Mustacchi switch (enc->cte_format) { 817*2e25d8e1SRobert Mustacchi case CTF_FP_CPLX: 818*2e25d8e1SRobert Mustacchi name = "complex float"; 819*2e25d8e1SRobert Mustacchi break; 820*2e25d8e1SRobert Mustacchi case CTF_FP_DCPLX: 821*2e25d8e1SRobert Mustacchi name = "complex double"; 822*2e25d8e1SRobert Mustacchi break; 823*2e25d8e1SRobert Mustacchi case CTF_FP_LDCPLX: 824*2e25d8e1SRobert Mustacchi name = "complex long double"; 825*2e25d8e1SRobert Mustacchi break; 826*2e25d8e1SRobert Mustacchi default: 827*2e25d8e1SRobert Mustacchi return (0); 828*2e25d8e1SRobert Mustacchi } 829*2e25d8e1SRobert Mustacchi 830*2e25d8e1SRobert Mustacchi *namep = ctf_strdup(name); 831*2e25d8e1SRobert Mustacchi if (*namep == NULL) { 832*2e25d8e1SRobert Mustacchi return (ENOMEM); 833*2e25d8e1SRobert Mustacchi } 834*2e25d8e1SRobert Mustacchi 835*2e25d8e1SRobert Mustacchi return (0); 836*2e25d8e1SRobert Mustacchi } 837*2e25d8e1SRobert Mustacchi 838bc1f688bSRobert Mustacchi static int 839bc1f688bSRobert Mustacchi ctf_dwarf_float_base(ctf_cu_t *cup, Dwarf_Signed type, ctf_encoding_t *enc) 840bc1f688bSRobert Mustacchi { 841bc1f688bSRobert Mustacchi const ctf_dwarf_fpmap_t *map = &ctf_dwarf_fpmaps[0]; 842bc1f688bSRobert Mustacchi const ctf_dwarf_fpent_t *ent; 843bc1f688bSRobert Mustacchi uint_t col = 0, mult = 1; 844bc1f688bSRobert Mustacchi 845bc1f688bSRobert Mustacchi for (map = &ctf_dwarf_fpmaps[0]; map->cdf_mach != EM_NONE; map++) { 846bc1f688bSRobert Mustacchi if (map->cdf_mach == cup->cu_mach) 847bc1f688bSRobert Mustacchi break; 848bc1f688bSRobert Mustacchi } 849bc1f688bSRobert Mustacchi 850bc1f688bSRobert Mustacchi if (map->cdf_mach == EM_NONE) { 851bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 852bc1f688bSRobert Mustacchi "Unsupported machine type: %d\n", cup->cu_mach); 853bc1f688bSRobert Mustacchi return (ENOTSUP); 854bc1f688bSRobert Mustacchi } 855bc1f688bSRobert Mustacchi 856bc1f688bSRobert Mustacchi if (type == DW_ATE_complex_float) { 857bc1f688bSRobert Mustacchi mult = 2; 858bc1f688bSRobert Mustacchi col = 1; 859bc1f688bSRobert Mustacchi } else if (type == DW_ATE_imaginary_float || 860bc1f688bSRobert Mustacchi type == DW_ATE_SUN_imaginary_float) { 861bc1f688bSRobert Mustacchi col = 2; 862bc1f688bSRobert Mustacchi } 863bc1f688bSRobert Mustacchi 864bc1f688bSRobert Mustacchi ent = &map->cdf_ents[0]; 865bc1f688bSRobert Mustacchi for (ent = &map->cdf_ents[0]; ent->cdfe_size != 0; ent++) { 866bc1f688bSRobert Mustacchi if (ent->cdfe_size * mult * 8 == enc->cte_bits) { 867bc1f688bSRobert Mustacchi enc->cte_format = ent->cdfe_enc[col]; 868bc1f688bSRobert Mustacchi return (0); 869bc1f688bSRobert Mustacchi } 870bc1f688bSRobert Mustacchi } 871bc1f688bSRobert Mustacchi 872bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 873bc1f688bSRobert Mustacchi "failed to find valid fp mapping for encoding %d, size %d bits\n", 874bc1f688bSRobert Mustacchi type, enc->cte_bits); 875bc1f688bSRobert Mustacchi return (EINVAL); 876bc1f688bSRobert Mustacchi } 877bc1f688bSRobert Mustacchi 878bc1f688bSRobert Mustacchi static int 879bc1f688bSRobert Mustacchi ctf_dwarf_dwarf_base(ctf_cu_t *cup, Dwarf_Die die, int *kindp, 880bc1f688bSRobert Mustacchi ctf_encoding_t *enc) 881bc1f688bSRobert Mustacchi { 882bc1f688bSRobert Mustacchi int ret; 883bc1f688bSRobert Mustacchi Dwarf_Signed type; 884bc1f688bSRobert Mustacchi 885bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_signed(cup, die, DW_AT_encoding, &type)) != 0) 886bc1f688bSRobert Mustacchi return (ret); 887bc1f688bSRobert Mustacchi 888bc1f688bSRobert Mustacchi switch (type) { 889bc1f688bSRobert Mustacchi case DW_ATE_unsigned: 890bc1f688bSRobert Mustacchi case DW_ATE_address: 891bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 892bc1f688bSRobert Mustacchi enc->cte_format = 0; 893bc1f688bSRobert Mustacchi break; 894bc1f688bSRobert Mustacchi case DW_ATE_unsigned_char: 895bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 896bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_CHAR; 897bc1f688bSRobert Mustacchi break; 898bc1f688bSRobert Mustacchi case DW_ATE_signed: 899bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 900bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_SIGNED; 901bc1f688bSRobert Mustacchi break; 902bc1f688bSRobert Mustacchi case DW_ATE_signed_char: 903bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 904bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_SIGNED | CTF_INT_CHAR; 905bc1f688bSRobert Mustacchi break; 906bc1f688bSRobert Mustacchi case DW_ATE_boolean: 907bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 908bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_SIGNED | CTF_INT_BOOL; 909bc1f688bSRobert Mustacchi break; 910bc1f688bSRobert Mustacchi case DW_ATE_float: 911bc1f688bSRobert Mustacchi case DW_ATE_complex_float: 912bc1f688bSRobert Mustacchi case DW_ATE_imaginary_float: 913bc1f688bSRobert Mustacchi case DW_ATE_SUN_imaginary_float: 914bc1f688bSRobert Mustacchi case DW_ATE_SUN_interval_float: 915bc1f688bSRobert Mustacchi *kindp = CTF_K_FLOAT; 916bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_float_base(cup, type, enc)) != 0) 917bc1f688bSRobert Mustacchi return (ret); 918bc1f688bSRobert Mustacchi break; 919bc1f688bSRobert Mustacchi default: 920bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 9213eca6103SJohn Levon "encountered unknown DWARF encoding: %d", type); 922bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 923bc1f688bSRobert Mustacchi } 924bc1f688bSRobert Mustacchi 925bc1f688bSRobert Mustacchi return (0); 926bc1f688bSRobert Mustacchi } 927bc1f688bSRobert Mustacchi 928bc1f688bSRobert Mustacchi /* 929bc1f688bSRobert Mustacchi * Different compilers (at least GCC and Studio) use different names for types. 930bc1f688bSRobert Mustacchi * This parses the types and attempts to unify them. If this fails, we just fall 931bc1f688bSRobert Mustacchi * back to using the DWARF itself. 932bc1f688bSRobert Mustacchi */ 933bc1f688bSRobert Mustacchi static int 934*2e25d8e1SRobert Mustacchi ctf_dwarf_parse_int(const char *name, int *kindp, ctf_encoding_t *enc, 935bc1f688bSRobert Mustacchi char **newnamep) 936bc1f688bSRobert Mustacchi { 937bc1f688bSRobert Mustacchi char buf[256]; 938bc1f688bSRobert Mustacchi char *base, *c, *last; 939bc1f688bSRobert Mustacchi int nlong = 0, nshort = 0, nchar = 0, nint = 0; 940bc1f688bSRobert Mustacchi int sign = 1; 941bc1f688bSRobert Mustacchi 942bc1f688bSRobert Mustacchi if (strlen(name) + 1 > sizeof (buf)) 943bc1f688bSRobert Mustacchi return (EINVAL); 944bc1f688bSRobert Mustacchi 945bc1f688bSRobert Mustacchi (void) strlcpy(buf, name, sizeof (buf)); 946bc1f688bSRobert Mustacchi for (c = strtok_r(buf, " ", &last); c != NULL; 947bc1f688bSRobert Mustacchi c = strtok_r(NULL, " ", &last)) { 948bc1f688bSRobert Mustacchi if (strcmp(c, "signed") == 0) { 949bc1f688bSRobert Mustacchi sign = 1; 950bc1f688bSRobert Mustacchi } else if (strcmp(c, "unsigned") == 0) { 951bc1f688bSRobert Mustacchi sign = 0; 952bc1f688bSRobert Mustacchi } else if (strcmp(c, "long") == 0) { 953bc1f688bSRobert Mustacchi nlong++; 954bc1f688bSRobert Mustacchi } else if (strcmp(c, "char") == 0) { 955bc1f688bSRobert Mustacchi nchar++; 956bc1f688bSRobert Mustacchi } else if (strcmp(c, "short") == 0) { 957bc1f688bSRobert Mustacchi nshort++; 958bc1f688bSRobert Mustacchi } else if (strcmp(c, "int") == 0) { 959bc1f688bSRobert Mustacchi nint++; 960bc1f688bSRobert Mustacchi } else { 961bc1f688bSRobert Mustacchi /* 962bc1f688bSRobert Mustacchi * If we don't recognize any of the tokens, we'll tell 963bc1f688bSRobert Mustacchi * the caller to fall back to the dwarf-provided 964bc1f688bSRobert Mustacchi * encoding information. 965bc1f688bSRobert Mustacchi */ 966bc1f688bSRobert Mustacchi return (EINVAL); 967bc1f688bSRobert Mustacchi } 968bc1f688bSRobert Mustacchi } 969bc1f688bSRobert Mustacchi 970bc1f688bSRobert Mustacchi if (nchar > 1 || nshort > 1 || nint > 1 || nlong > 2) 971bc1f688bSRobert Mustacchi return (EINVAL); 972bc1f688bSRobert Mustacchi 973bc1f688bSRobert Mustacchi if (nchar > 0) { 974bc1f688bSRobert Mustacchi if (nlong > 0 || nshort > 0 || nint > 0) 975bc1f688bSRobert Mustacchi return (EINVAL); 976bc1f688bSRobert Mustacchi base = "char"; 977bc1f688bSRobert Mustacchi } else if (nshort > 0) { 978bc1f688bSRobert Mustacchi if (nlong > 0) 979bc1f688bSRobert Mustacchi return (EINVAL); 980bc1f688bSRobert Mustacchi base = "short"; 981bc1f688bSRobert Mustacchi } else if (nlong > 0) { 982bc1f688bSRobert Mustacchi base = "long"; 983bc1f688bSRobert Mustacchi } else { 984bc1f688bSRobert Mustacchi base = "int"; 985bc1f688bSRobert Mustacchi } 986bc1f688bSRobert Mustacchi 987bc1f688bSRobert Mustacchi if (nchar > 0) 988bc1f688bSRobert Mustacchi enc->cte_format = CTF_INT_CHAR; 989bc1f688bSRobert Mustacchi else 990bc1f688bSRobert Mustacchi enc->cte_format = 0; 991bc1f688bSRobert Mustacchi 992bc1f688bSRobert Mustacchi if (sign > 0) 993bc1f688bSRobert Mustacchi enc->cte_format |= CTF_INT_SIGNED; 994bc1f688bSRobert Mustacchi 995bc1f688bSRobert Mustacchi (void) snprintf(buf, sizeof (buf), "%s%s%s", 996bc1f688bSRobert Mustacchi (sign ? "" : "unsigned "), 997bc1f688bSRobert Mustacchi (nlong > 1 ? "long " : ""), 998bc1f688bSRobert Mustacchi base); 999bc1f688bSRobert Mustacchi 1000bc1f688bSRobert Mustacchi *newnamep = ctf_strdup(buf); 1001bc1f688bSRobert Mustacchi if (*newnamep == NULL) 1002bc1f688bSRobert Mustacchi return (ENOMEM); 1003bc1f688bSRobert Mustacchi *kindp = CTF_K_INTEGER; 1004bc1f688bSRobert Mustacchi return (0); 1005bc1f688bSRobert Mustacchi } 1006bc1f688bSRobert Mustacchi 1007bc1f688bSRobert Mustacchi static int 1008bc1f688bSRobert Mustacchi ctf_dwarf_create_base(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot, 1009bc1f688bSRobert Mustacchi Dwarf_Off off) 1010bc1f688bSRobert Mustacchi { 1011bc1f688bSRobert Mustacchi int ret; 1012*2e25d8e1SRobert Mustacchi char *name, *nname = NULL; 1013bc1f688bSRobert Mustacchi Dwarf_Unsigned sz; 1014bc1f688bSRobert Mustacchi int kind; 1015bc1f688bSRobert Mustacchi ctf_encoding_t enc; 1016bc1f688bSRobert Mustacchi ctf_id_t id; 1017bc1f688bSRobert Mustacchi 1018bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0) 1019bc1f688bSRobert Mustacchi return (ret); 1020bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &sz)) != 0) { 1021bc1f688bSRobert Mustacchi goto out; 1022bc1f688bSRobert Mustacchi } 1023bc1f688bSRobert Mustacchi ctf_dprintf("Creating base type %s from off %llu, size: %d\n", name, 1024bc1f688bSRobert Mustacchi off, sz); 1025bc1f688bSRobert Mustacchi 1026bc1f688bSRobert Mustacchi bzero(&enc, sizeof (ctf_encoding_t)); 1027bc1f688bSRobert Mustacchi enc.cte_bits = sz * 8; 1028*2e25d8e1SRobert Mustacchi if ((ret = ctf_dwarf_parse_int(name, &kind, &enc, &nname)) == 0) { 1029bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1030bc1f688bSRobert Mustacchi name = nname; 1031bc1f688bSRobert Mustacchi } else { 1032*2e25d8e1SRobert Mustacchi if (ret != EINVAL) { 1033*2e25d8e1SRobert Mustacchi goto out; 1034*2e25d8e1SRobert Mustacchi } 1035bc1f688bSRobert Mustacchi ctf_dprintf("falling back to dwarf for base type %s\n", name); 1036*2e25d8e1SRobert Mustacchi if ((ret = ctf_dwarf_dwarf_base(cup, die, &kind, &enc)) != 0) { 1037*2e25d8e1SRobert Mustacchi goto out; 1038*2e25d8e1SRobert Mustacchi } 1039*2e25d8e1SRobert Mustacchi 1040*2e25d8e1SRobert Mustacchi if (kind == CTF_K_FLOAT && (ret = ctf_dwarf_fixup_complex(cup, 1041*2e25d8e1SRobert Mustacchi &enc, &nname)) != 0) { 1042*2e25d8e1SRobert Mustacchi goto out; 1043*2e25d8e1SRobert Mustacchi } else if (nname != NULL) { 1044*2e25d8e1SRobert Mustacchi ctf_free(name, strlen(name) + 1); 1045*2e25d8e1SRobert Mustacchi name = nname; 1046*2e25d8e1SRobert Mustacchi } 1047bc1f688bSRobert Mustacchi } 1048bc1f688bSRobert Mustacchi 1049bc1f688bSRobert Mustacchi id = ctf_add_encoded(cup->cu_ctfp, isroot, name, &enc, kind); 1050bc1f688bSRobert Mustacchi if (id == CTF_ERR) { 1051bc1f688bSRobert Mustacchi ret = ctf_errno(cup->cu_ctfp); 1052bc1f688bSRobert Mustacchi } else { 1053bc1f688bSRobert Mustacchi *idp = id; 1054bc1f688bSRobert Mustacchi ret = ctf_dwmap_add(cup, id, die, B_FALSE); 1055bc1f688bSRobert Mustacchi } 1056bc1f688bSRobert Mustacchi out: 1057bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1058bc1f688bSRobert Mustacchi return (ret); 1059bc1f688bSRobert Mustacchi } 1060bc1f688bSRobert Mustacchi 1061bc1f688bSRobert Mustacchi /* 1062bc1f688bSRobert Mustacchi * Getting a member's offset is a surprisingly intricate dance. It works as 1063bc1f688bSRobert Mustacchi * follows: 1064bc1f688bSRobert Mustacchi * 1065bc1f688bSRobert Mustacchi * 1) If we're in DWARFv4, then we either have a DW_AT_data_bit_offset or we 1066bc1f688bSRobert Mustacchi * have a DW_AT_data_member_location. We won't have both. Thus we check first 1067bc1f688bSRobert Mustacchi * for DW_AT_data_bit_offset, and if it exists, we're set. 1068bc1f688bSRobert Mustacchi * 1069bc1f688bSRobert Mustacchi * Next, if we have a bitfield and we don't have a DW_AT_data_bit_offset, then 1070bc1f688bSRobert Mustacchi * we have to grab the data location and use the following dance: 1071bc1f688bSRobert Mustacchi * 1072bc1f688bSRobert Mustacchi * 2) Gather the set of DW_AT_byte_size, DW_AT_bit_offset, and DW_AT_bit_size. 1073bc1f688bSRobert Mustacchi * Of course, the DW_AT_byte_size may be omitted, even though it isn't always. 1074bc1f688bSRobert Mustacchi * When it's been omitted, we then have to say that the size is that of the 1075bc1f688bSRobert Mustacchi * underlying type, which forces that to be after a ctf_update(). Here, we have 1076bc1f688bSRobert Mustacchi * to do different things based on whether or not we're using big endian or 1077bc1f688bSRobert Mustacchi * little endian to obtain the proper offset. 1078bc1f688bSRobert Mustacchi */ 1079bc1f688bSRobert Mustacchi static int 1080bc1f688bSRobert Mustacchi ctf_dwarf_member_offset(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t mid, 1081bc1f688bSRobert Mustacchi ulong_t *offp) 1082bc1f688bSRobert Mustacchi { 1083bc1f688bSRobert Mustacchi int ret; 1084bc1f688bSRobert Mustacchi Dwarf_Unsigned loc, bitsz, bytesz; 1085bc1f688bSRobert Mustacchi Dwarf_Signed bitoff; 1086bc1f688bSRobert Mustacchi size_t off; 1087bc1f688bSRobert Mustacchi ssize_t tsz; 1088bc1f688bSRobert Mustacchi 1089bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_data_bit_offset, 1090bc1f688bSRobert Mustacchi &loc)) == 0) { 1091bc1f688bSRobert Mustacchi *offp = loc; 1092bc1f688bSRobert Mustacchi return (0); 1093bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 1094bc1f688bSRobert Mustacchi return (ret); 1095bc1f688bSRobert Mustacchi } 1096bc1f688bSRobert Mustacchi 1097bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_member_location(cup, die, &loc)) != 0) 1098bc1f688bSRobert Mustacchi return (ret); 1099bc1f688bSRobert Mustacchi off = loc * 8; 1100bc1f688bSRobert Mustacchi 1101bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_signed(cup, die, DW_AT_bit_offset, 1102bc1f688bSRobert Mustacchi &bitoff)) != 0) { 1103bc1f688bSRobert Mustacchi if (ret != ENOENT) 1104bc1f688bSRobert Mustacchi return (ret); 1105bc1f688bSRobert Mustacchi *offp = off; 1106bc1f688bSRobert Mustacchi return (0); 1107bc1f688bSRobert Mustacchi } 1108bc1f688bSRobert Mustacchi 1109bc1f688bSRobert Mustacchi /* At this point we have to have DW_AT_bit_size */ 1110bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0) 1111bc1f688bSRobert Mustacchi return (ret); 1112bc1f688bSRobert Mustacchi 1113bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, 1114bc1f688bSRobert Mustacchi &bytesz)) != 0) { 1115bc1f688bSRobert Mustacchi if (ret != ENOENT) 1116bc1f688bSRobert Mustacchi return (ret); 1117bc1f688bSRobert Mustacchi if ((tsz = ctf_type_size(cup->cu_ctfp, mid)) == CTF_ERR) { 1118bc1f688bSRobert Mustacchi int e = ctf_errno(cup->cu_ctfp); 1119bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1120bc1f688bSRobert Mustacchi "failed to get type size: %s", ctf_errmsg(e)); 1121bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1122bc1f688bSRobert Mustacchi } 1123bc1f688bSRobert Mustacchi } else { 1124bc1f688bSRobert Mustacchi tsz = bytesz; 1125bc1f688bSRobert Mustacchi } 1126bc1f688bSRobert Mustacchi tsz *= 8; 1127bc1f688bSRobert Mustacchi if (cup->cu_bigend == B_TRUE) { 1128bc1f688bSRobert Mustacchi *offp = off + bitoff; 1129bc1f688bSRobert Mustacchi } else { 1130bc1f688bSRobert Mustacchi *offp = off + tsz - bitoff - bitsz; 1131bc1f688bSRobert Mustacchi } 1132bc1f688bSRobert Mustacchi 1133bc1f688bSRobert Mustacchi return (0); 1134bc1f688bSRobert Mustacchi } 1135bc1f688bSRobert Mustacchi 1136bc1f688bSRobert Mustacchi /* 1137bc1f688bSRobert Mustacchi * We need to determine if the member in question is a bitfield. If it is, then 1138bc1f688bSRobert Mustacchi * we need to go through and create a new type that's based on the actual base 1139bc1f688bSRobert Mustacchi * type, but has a different size. We also rename the type as a result to help 1140bc1f688bSRobert Mustacchi * deal with future collisions. 1141bc1f688bSRobert Mustacchi * 1142bc1f688bSRobert Mustacchi * Here we need to look and see if we have a DW_AT_bit_size value. If we have a 1143bc1f688bSRobert Mustacchi * bit size member and it does not equal the byte size member, then we need to 1144bc1f688bSRobert Mustacchi * create a bitfield type based on this. 1145bc1f688bSRobert Mustacchi * 1146bc1f688bSRobert Mustacchi * Note: When we support DWARFv4, there may be a chance that we need to also 1147bc1f688bSRobert Mustacchi * search for the DW_AT_byte_size if we don't have a DW_AT_bit_size member. 1148bc1f688bSRobert Mustacchi */ 1149bc1f688bSRobert Mustacchi static int 1150bc1f688bSRobert Mustacchi ctf_dwarf_member_bitfield(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp) 1151bc1f688bSRobert Mustacchi { 1152bc1f688bSRobert Mustacchi int ret; 1153bc1f688bSRobert Mustacchi Dwarf_Unsigned bitsz; 1154bc1f688bSRobert Mustacchi ctf_encoding_t e; 1155bc1f688bSRobert Mustacchi ctf_dwbitf_t *cdb; 1156bc1f688bSRobert Mustacchi ctf_dtdef_t *dtd; 1157bc1f688bSRobert Mustacchi ctf_id_t base = *idp; 1158bc1f688bSRobert Mustacchi int kind; 1159bc1f688bSRobert Mustacchi 1160bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_bit_size, &bitsz)) != 0) { 1161bc1f688bSRobert Mustacchi if (ret == ENOENT) 1162bc1f688bSRobert Mustacchi return (0); 1163bc1f688bSRobert Mustacchi return (ret); 1164bc1f688bSRobert Mustacchi } 1165bc1f688bSRobert Mustacchi 1166bc1f688bSRobert Mustacchi ctf_dprintf("Trying to deal with bitfields on %d:%d\n", base, bitsz); 1167bc1f688bSRobert Mustacchi /* 1168bc1f688bSRobert Mustacchi * Given that we now have a bitsize, time to go do something about it. 1169bc1f688bSRobert Mustacchi * We're going to create a new type based on the current one, but first 1170bc1f688bSRobert Mustacchi * we need to find the base type. This means we need to traverse any 1171bc1f688bSRobert Mustacchi * typedef's, consts, and volatiles until we get to what should be 1172bc1f688bSRobert Mustacchi * something of type integer or enumeration. 1173bc1f688bSRobert Mustacchi */ 1174bc1f688bSRobert Mustacchi VERIFY(bitsz < UINT32_MAX); 1175bc1f688bSRobert Mustacchi dtd = ctf_dtd_lookup(cup->cu_ctfp, base); 1176bc1f688bSRobert Mustacchi VERIFY(dtd != NULL); 1177bc1f688bSRobert Mustacchi kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info); 1178bc1f688bSRobert Mustacchi while (kind == CTF_K_TYPEDEF || kind == CTF_K_CONST || 1179bc1f688bSRobert Mustacchi kind == CTF_K_VOLATILE) { 1180bc1f688bSRobert Mustacchi dtd = ctf_dtd_lookup(cup->cu_ctfp, dtd->dtd_data.ctt_type); 1181bc1f688bSRobert Mustacchi VERIFY(dtd != NULL); 1182bc1f688bSRobert Mustacchi kind = CTF_INFO_KIND(dtd->dtd_data.ctt_info); 1183bc1f688bSRobert Mustacchi } 1184bc1f688bSRobert Mustacchi ctf_dprintf("got kind %d\n", kind); 1185bc1f688bSRobert Mustacchi VERIFY(kind == CTF_K_INTEGER || kind == CTF_K_ENUM); 1186bc1f688bSRobert Mustacchi 1187bc1f688bSRobert Mustacchi /* 1188bc1f688bSRobert Mustacchi * As surprising as it may be, it is strictly possible to create a 1189bc1f688bSRobert Mustacchi * bitfield that is based on an enum. Of course, the C standard leaves 1190bc1f688bSRobert Mustacchi * enums sizing as an ABI concern more or less. To that effect, today on 1191bc1f688bSRobert Mustacchi * all illumos platforms the size of an enum is generally that of an 1192bc1f688bSRobert Mustacchi * int as our supported data models and ABIs all agree on that. So what 1193bc1f688bSRobert Mustacchi * we'll do is fake up a CTF encoding here to use. In this case, we'll 1194bc1f688bSRobert Mustacchi * treat it as an unsigned value of whatever size the underlying enum 1195bc1f688bSRobert Mustacchi * currently has (which is in the ctt_size member of its dynamic type 1196bc1f688bSRobert Mustacchi * data). 1197bc1f688bSRobert Mustacchi */ 1198bc1f688bSRobert Mustacchi if (kind == CTF_K_INTEGER) { 1199bc1f688bSRobert Mustacchi e = dtd->dtd_u.dtu_enc; 1200bc1f688bSRobert Mustacchi } else { 1201bc1f688bSRobert Mustacchi bzero(&e, sizeof (ctf_encoding_t)); 1202bc1f688bSRobert Mustacchi e.cte_bits = dtd->dtd_data.ctt_size * NBBY; 1203bc1f688bSRobert Mustacchi } 1204bc1f688bSRobert Mustacchi 1205bc1f688bSRobert Mustacchi for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL; 1206bc1f688bSRobert Mustacchi cdb = ctf_list_next(cdb)) { 1207bc1f688bSRobert Mustacchi if (cdb->cdb_base == base && cdb->cdb_nbits == bitsz) 1208bc1f688bSRobert Mustacchi break; 1209bc1f688bSRobert Mustacchi } 1210bc1f688bSRobert Mustacchi 1211bc1f688bSRobert Mustacchi /* 1212bc1f688bSRobert Mustacchi * Create a new type if none exists. We name all types in a way that is 1213bc1f688bSRobert Mustacchi * guaranteed not to conflict with the corresponding C type. We do this 1214bc1f688bSRobert Mustacchi * by using the ':' operator. 1215bc1f688bSRobert Mustacchi */ 1216bc1f688bSRobert Mustacchi if (cdb == NULL) { 1217bc1f688bSRobert Mustacchi size_t namesz; 1218bc1f688bSRobert Mustacchi char *name; 1219bc1f688bSRobert Mustacchi 1220bc1f688bSRobert Mustacchi e.cte_bits = bitsz; 1221bc1f688bSRobert Mustacchi namesz = snprintf(NULL, 0, "%s:%d", dtd->dtd_name, 1222bc1f688bSRobert Mustacchi (uint32_t)bitsz); 1223bc1f688bSRobert Mustacchi name = ctf_alloc(namesz + 1); 1224bc1f688bSRobert Mustacchi if (name == NULL) 1225bc1f688bSRobert Mustacchi return (ENOMEM); 1226bc1f688bSRobert Mustacchi cdb = ctf_alloc(sizeof (ctf_dwbitf_t)); 1227bc1f688bSRobert Mustacchi if (cdb == NULL) { 1228bc1f688bSRobert Mustacchi ctf_free(name, namesz + 1); 1229bc1f688bSRobert Mustacchi return (ENOMEM); 1230bc1f688bSRobert Mustacchi } 1231bc1f688bSRobert Mustacchi (void) snprintf(name, namesz + 1, "%s:%d", dtd->dtd_name, 1232bc1f688bSRobert Mustacchi (uint32_t)bitsz); 1233bc1f688bSRobert Mustacchi 1234bc1f688bSRobert Mustacchi cdb->cdb_base = base; 1235bc1f688bSRobert Mustacchi cdb->cdb_nbits = bitsz; 1236bc1f688bSRobert Mustacchi cdb->cdb_id = ctf_add_integer(cup->cu_ctfp, CTF_ADD_NONROOT, 1237bc1f688bSRobert Mustacchi name, &e); 1238bc1f688bSRobert Mustacchi if (cdb->cdb_id == CTF_ERR) { 1239bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1240bc1f688bSRobert Mustacchi "failed to get add bitfield type %s: %s", name, 1241bc1f688bSRobert Mustacchi ctf_errmsg(ctf_errno(cup->cu_ctfp))); 1242bc1f688bSRobert Mustacchi ctf_free(name, namesz + 1); 1243bc1f688bSRobert Mustacchi ctf_free(cdb, sizeof (ctf_dwbitf_t)); 1244bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1245bc1f688bSRobert Mustacchi } 1246bc1f688bSRobert Mustacchi ctf_free(name, namesz + 1); 1247bc1f688bSRobert Mustacchi ctf_list_append(&cup->cu_bitfields, cdb); 1248bc1f688bSRobert Mustacchi } 1249bc1f688bSRobert Mustacchi 1250bc1f688bSRobert Mustacchi *idp = cdb->cdb_id; 1251bc1f688bSRobert Mustacchi 1252bc1f688bSRobert Mustacchi return (0); 1253bc1f688bSRobert Mustacchi } 1254bc1f688bSRobert Mustacchi 1255bc1f688bSRobert Mustacchi static int 1256bc1f688bSRobert Mustacchi ctf_dwarf_fixup_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t base, boolean_t add) 1257bc1f688bSRobert Mustacchi { 1258bc1f688bSRobert Mustacchi int ret, kind; 1259bc1f688bSRobert Mustacchi Dwarf_Die child, memb; 1260bc1f688bSRobert Mustacchi Dwarf_Unsigned size; 1261bc1f688bSRobert Mustacchi 1262bc1f688bSRobert Mustacchi kind = ctf_type_kind(cup->cu_ctfp, base); 1263bc1f688bSRobert Mustacchi VERIFY(kind != CTF_ERR); 1264bc1f688bSRobert Mustacchi VERIFY(kind == CTF_K_STRUCT || kind == CTF_K_UNION); 1265bc1f688bSRobert Mustacchi 1266bc1f688bSRobert Mustacchi /* 1267bc1f688bSRobert Mustacchi * Members are in children. However, gcc also allows empty ones. 1268bc1f688bSRobert Mustacchi */ 1269bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 1270bc1f688bSRobert Mustacchi return (ret); 1271bc1f688bSRobert Mustacchi if (child == NULL) 1272bc1f688bSRobert Mustacchi return (0); 1273bc1f688bSRobert Mustacchi 1274bc1f688bSRobert Mustacchi memb = child; 1275bc1f688bSRobert Mustacchi while (memb != NULL) { 1276bc1f688bSRobert Mustacchi Dwarf_Die sib, tdie; 1277bc1f688bSRobert Mustacchi Dwarf_Half tag; 1278bc1f688bSRobert Mustacchi ctf_id_t mid; 1279bc1f688bSRobert Mustacchi char *mname; 1280bc1f688bSRobert Mustacchi ulong_t memboff = 0; 1281bc1f688bSRobert Mustacchi 1282bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, memb, &tag)) != 0) 1283bc1f688bSRobert Mustacchi return (ret); 1284bc1f688bSRobert Mustacchi 1285bc1f688bSRobert Mustacchi if (tag != DW_TAG_member) 12863df9f064SRobert Mustacchi goto next; 1287bc1f688bSRobert Mustacchi 1288bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, memb, DW_AT_type, &tdie)) != 0) 1289bc1f688bSRobert Mustacchi return (ret); 1290bc1f688bSRobert Mustacchi 1291bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &mid, 1292bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1293bc1f688bSRobert Mustacchi return (ret); 1294bc1f688bSRobert Mustacchi ctf_dprintf("Got back type id: %d\n", mid); 1295bc1f688bSRobert Mustacchi 1296bc1f688bSRobert Mustacchi /* 1297bc1f688bSRobert Mustacchi * If we're not adding a member, just go ahead and return. 1298bc1f688bSRobert Mustacchi */ 1299bc1f688bSRobert Mustacchi if (add == B_FALSE) { 1300bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_member_bitfield(cup, memb, 1301bc1f688bSRobert Mustacchi &mid)) != 0) 1302bc1f688bSRobert Mustacchi return (ret); 1303bc1f688bSRobert Mustacchi goto next; 1304bc1f688bSRobert Mustacchi } 1305bc1f688bSRobert Mustacchi 1306bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, memb, DW_AT_name, 1307bc1f688bSRobert Mustacchi &mname)) != 0 && ret != ENOENT) 1308bc1f688bSRobert Mustacchi return (ret); 1309bc1f688bSRobert Mustacchi if (ret == ENOENT) 1310bc1f688bSRobert Mustacchi mname = NULL; 1311bc1f688bSRobert Mustacchi 1312bc1f688bSRobert Mustacchi if (kind == CTF_K_UNION) { 1313bc1f688bSRobert Mustacchi memboff = 0; 1314bc1f688bSRobert Mustacchi } else if ((ret = ctf_dwarf_member_offset(cup, memb, mid, 1315bc1f688bSRobert Mustacchi &memboff)) != 0) { 1316bc1f688bSRobert Mustacchi if (mname != NULL) 1317bc1f688bSRobert Mustacchi ctf_free(mname, strlen(mname) + 1); 1318bc1f688bSRobert Mustacchi return (ret); 1319bc1f688bSRobert Mustacchi } 1320bc1f688bSRobert Mustacchi 1321bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_member_bitfield(cup, memb, &mid)) != 0) 1322bc1f688bSRobert Mustacchi return (ret); 1323bc1f688bSRobert Mustacchi 1324bc1f688bSRobert Mustacchi ret = ctf_add_member(cup->cu_ctfp, base, mname, mid, memboff); 1325bc1f688bSRobert Mustacchi if (ret == CTF_ERR) { 1326bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1327bc1f688bSRobert Mustacchi "failed to add member %s: %s", 1328bc1f688bSRobert Mustacchi mname, ctf_errmsg(ctf_errno(cup->cu_ctfp))); 1329bc1f688bSRobert Mustacchi if (mname != NULL) 1330bc1f688bSRobert Mustacchi ctf_free(mname, strlen(mname) + 1); 1331bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1332bc1f688bSRobert Mustacchi } 1333bc1f688bSRobert Mustacchi 1334bc1f688bSRobert Mustacchi if (mname != NULL) 1335bc1f688bSRobert Mustacchi ctf_free(mname, strlen(mname) + 1); 1336bc1f688bSRobert Mustacchi 1337bc1f688bSRobert Mustacchi next: 1338bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, memb, &sib)) != 0) 1339bc1f688bSRobert Mustacchi return (ret); 1340bc1f688bSRobert Mustacchi memb = sib; 1341bc1f688bSRobert Mustacchi } 1342bc1f688bSRobert Mustacchi 1343bc1f688bSRobert Mustacchi /* 1344bc1f688bSRobert Mustacchi * If we're not adding members, then we don't know the final size of the 1345bc1f688bSRobert Mustacchi * structure, so end here. 1346bc1f688bSRobert Mustacchi */ 1347bc1f688bSRobert Mustacchi if (add == B_FALSE) 1348bc1f688bSRobert Mustacchi return (0); 1349bc1f688bSRobert Mustacchi 1350bc1f688bSRobert Mustacchi /* Finally set the size of the structure to the actual byte size */ 1351bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, die, DW_AT_byte_size, &size)) != 0) 1352bc1f688bSRobert Mustacchi return (ret); 1353fe2dc8bdSJohn Levon if ((ctf_set_size(cup->cu_ctfp, base, size)) == CTF_ERR) { 1354bc1f688bSRobert Mustacchi int e = ctf_errno(cup->cu_ctfp); 1355bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1356bc1f688bSRobert Mustacchi "failed to set type size for %d to 0x%x: %s", base, 1357bc1f688bSRobert Mustacchi (uint32_t)size, ctf_errmsg(e)); 1358bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1359bc1f688bSRobert Mustacchi } 1360bc1f688bSRobert Mustacchi 1361bc1f688bSRobert Mustacchi return (0); 1362bc1f688bSRobert Mustacchi } 1363bc1f688bSRobert Mustacchi 1364bc1f688bSRobert Mustacchi static int 1365bc1f688bSRobert Mustacchi ctf_dwarf_create_sou(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, 1366bc1f688bSRobert Mustacchi int kind, int isroot) 1367bc1f688bSRobert Mustacchi { 1368bc1f688bSRobert Mustacchi int ret; 1369bc1f688bSRobert Mustacchi char *name; 1370bc1f688bSRobert Mustacchi ctf_id_t base; 1371bc1f688bSRobert Mustacchi Dwarf_Die child; 1372bc1f688bSRobert Mustacchi Dwarf_Bool decl; 1373bc1f688bSRobert Mustacchi 1374bc1f688bSRobert Mustacchi /* 1375bc1f688bSRobert Mustacchi * Deal with the terribly annoying case of anonymous structs and unions. 1376bc1f688bSRobert Mustacchi * If they don't have a name, set the name to the empty string. 1377bc1f688bSRobert Mustacchi */ 1378bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 1379bc1f688bSRobert Mustacchi ret != ENOENT) 1380bc1f688bSRobert Mustacchi return (ret); 1381bc1f688bSRobert Mustacchi if (ret == ENOENT) 1382bc1f688bSRobert Mustacchi name = NULL; 1383bc1f688bSRobert Mustacchi 1384bc1f688bSRobert Mustacchi /* 1385bc1f688bSRobert Mustacchi * We need to check if we just have a declaration here. If we do, then 1386bc1f688bSRobert Mustacchi * instead of creating an actual structure or union, we're just going to 1387bc1f688bSRobert Mustacchi * go ahead and create a forward. During a dedup or merge, the forward 1388bc1f688bSRobert Mustacchi * will be replaced with the real thing. 1389bc1f688bSRobert Mustacchi */ 1390bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, 1391bc1f688bSRobert Mustacchi &decl)) != 0) { 1392bc1f688bSRobert Mustacchi if (ret != ENOENT) 1393bc1f688bSRobert Mustacchi return (ret); 1394bc1f688bSRobert Mustacchi decl = 0; 1395bc1f688bSRobert Mustacchi } 1396bc1f688bSRobert Mustacchi 1397bc1f688bSRobert Mustacchi if (decl != 0) { 1398bc1f688bSRobert Mustacchi base = ctf_add_forward(cup->cu_ctfp, isroot, name, kind); 1399bc1f688bSRobert Mustacchi } else if (kind == CTF_K_STRUCT) { 1400bc1f688bSRobert Mustacchi base = ctf_add_struct(cup->cu_ctfp, isroot, name); 1401bc1f688bSRobert Mustacchi } else { 1402bc1f688bSRobert Mustacchi base = ctf_add_union(cup->cu_ctfp, isroot, name); 1403bc1f688bSRobert Mustacchi } 1404bc1f688bSRobert Mustacchi ctf_dprintf("added sou %s (%d) (%d)\n", name, kind, base); 1405bc1f688bSRobert Mustacchi if (name != NULL) 1406bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1407bc1f688bSRobert Mustacchi if (base == CTF_ERR) 1408bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1409bc1f688bSRobert Mustacchi *idp = base; 1410bc1f688bSRobert Mustacchi 1411bc1f688bSRobert Mustacchi /* 1412bc1f688bSRobert Mustacchi * If it's just a declaration, we're not going to mark it for fix up or 1413bc1f688bSRobert Mustacchi * do anything else. 1414bc1f688bSRobert Mustacchi */ 1415bc1f688bSRobert Mustacchi if (decl == B_TRUE) 1416bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, base, die, B_FALSE)); 1417bc1f688bSRobert Mustacchi if ((ret = ctf_dwmap_add(cup, base, die, B_TRUE)) != 0) 1418bc1f688bSRobert Mustacchi return (ret); 1419bc1f688bSRobert Mustacchi 1420bc1f688bSRobert Mustacchi /* 14213df9f064SRobert Mustacchi * The children of a structure or union are generally members. However, 14223df9f064SRobert Mustacchi * some compilers actually insert structs and unions there and not as a 14233df9f064SRobert Mustacchi * top-level die. Therefore, to make sure we honor our pass 1 contract 14243df9f064SRobert Mustacchi * of having all the base types, but not members, we need to walk this 14253df9f064SRobert Mustacchi * for instances of a DW_TAG_union_type. 1426bc1f688bSRobert Mustacchi */ 1427bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 1428bc1f688bSRobert Mustacchi return (ret); 14293df9f064SRobert Mustacchi 14303df9f064SRobert Mustacchi while (child != NULL) { 14313df9f064SRobert Mustacchi Dwarf_Half tag; 14323df9f064SRobert Mustacchi Dwarf_Die sib; 14333df9f064SRobert Mustacchi 14343df9f064SRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, child, &tag)) != 0) 14353df9f064SRobert Mustacchi return (ret); 14363df9f064SRobert Mustacchi 14373df9f064SRobert Mustacchi switch (tag) { 14383df9f064SRobert Mustacchi case DW_TAG_union_type: 14393df9f064SRobert Mustacchi case DW_TAG_structure_type: 14403df9f064SRobert Mustacchi ret = ctf_dwarf_convert_type(cup, child, NULL, 14413df9f064SRobert Mustacchi CTF_ADD_NONROOT); 14423df9f064SRobert Mustacchi if (ret != 0) { 14433df9f064SRobert Mustacchi return (ret); 14443df9f064SRobert Mustacchi } 14453df9f064SRobert Mustacchi break; 14463df9f064SRobert Mustacchi default: 14473df9f064SRobert Mustacchi break; 14483df9f064SRobert Mustacchi } 14493df9f064SRobert Mustacchi 14503df9f064SRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, child, &sib)) != 0) 14513df9f064SRobert Mustacchi return (ret); 14523df9f064SRobert Mustacchi child = sib; 14533df9f064SRobert Mustacchi } 1454bc1f688bSRobert Mustacchi 1455bc1f688bSRobert Mustacchi return (0); 1456bc1f688bSRobert Mustacchi } 1457bc1f688bSRobert Mustacchi 1458bc1f688bSRobert Mustacchi static int 1459bc1f688bSRobert Mustacchi ctf_dwarf_create_array_range(ctf_cu_t *cup, Dwarf_Die range, ctf_id_t *idp, 1460bc1f688bSRobert Mustacchi ctf_id_t base, int isroot) 1461bc1f688bSRobert Mustacchi { 1462bc1f688bSRobert Mustacchi int ret; 1463bc1f688bSRobert Mustacchi Dwarf_Die sib; 1464bc1f688bSRobert Mustacchi Dwarf_Unsigned val; 1465bc1f688bSRobert Mustacchi Dwarf_Signed sval; 1466bc1f688bSRobert Mustacchi ctf_arinfo_t ar; 1467bc1f688bSRobert Mustacchi 1468bc1f688bSRobert Mustacchi ctf_dprintf("creating array range\n"); 1469bc1f688bSRobert Mustacchi 1470bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, range, &sib)) != 0) 1471bc1f688bSRobert Mustacchi return (ret); 1472bc1f688bSRobert Mustacchi if (sib != NULL) { 1473bc1f688bSRobert Mustacchi ctf_id_t id; 1474bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_create_array_range(cup, sib, &id, 1475bc1f688bSRobert Mustacchi base, CTF_ADD_NONROOT)) != 0) 1476bc1f688bSRobert Mustacchi return (ret); 1477bc1f688bSRobert Mustacchi ar.ctr_contents = id; 1478bc1f688bSRobert Mustacchi } else { 1479bc1f688bSRobert Mustacchi ar.ctr_contents = base; 1480bc1f688bSRobert Mustacchi } 1481bc1f688bSRobert Mustacchi 1482bc1f688bSRobert Mustacchi if ((ar.ctr_index = ctf_dwarf_long(cup)) == CTF_ERR) 1483bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1484bc1f688bSRobert Mustacchi 1485bc1f688bSRobert Mustacchi /* 1486bc1f688bSRobert Mustacchi * Array bounds can be signed or unsigned, but there are several kinds 1487bc1f688bSRobert Mustacchi * of signless forms (data1, data2, etc) that take their sign from the 1488bc1f688bSRobert Mustacchi * routine that is trying to interpret them. That is, data1 can be 1489bc1f688bSRobert Mustacchi * either signed or unsigned, depending on whether you use the signed or 1490bc1f688bSRobert Mustacchi * unsigned accessor function. GCC will use the signless forms to store 1491bc1f688bSRobert Mustacchi * unsigned values which have their high bit set, so we need to try to 1492bc1f688bSRobert Mustacchi * read them first as unsigned to get positive values. We could also 1493bc1f688bSRobert Mustacchi * try signed first, falling back to unsigned if we got a negative 1494bc1f688bSRobert Mustacchi * value. 1495bc1f688bSRobert Mustacchi */ 1496bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, range, DW_AT_upper_bound, 1497bc1f688bSRobert Mustacchi &val)) == 0) { 1498bc1f688bSRobert Mustacchi ar.ctr_nelems = val + 1; 1499bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 1500bc1f688bSRobert Mustacchi return (ret); 1501bc1f688bSRobert Mustacchi } else if ((ret = ctf_dwarf_signed(cup, range, DW_AT_upper_bound, 1502bc1f688bSRobert Mustacchi &sval)) == 0) { 1503bc1f688bSRobert Mustacchi ar.ctr_nelems = sval + 1; 1504bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 1505bc1f688bSRobert Mustacchi return (ret); 1506bc1f688bSRobert Mustacchi } else { 1507bc1f688bSRobert Mustacchi ar.ctr_nelems = 0; 1508bc1f688bSRobert Mustacchi } 1509bc1f688bSRobert Mustacchi 1510bc1f688bSRobert Mustacchi if ((*idp = ctf_add_array(cup->cu_ctfp, isroot, &ar)) == CTF_ERR) 1511bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1512bc1f688bSRobert Mustacchi 1513bc1f688bSRobert Mustacchi return (0); 1514bc1f688bSRobert Mustacchi } 1515bc1f688bSRobert Mustacchi 1516bc1f688bSRobert Mustacchi /* 1517bc1f688bSRobert Mustacchi * Try and create an array type. First, the kind of the array is specified in 1518bc1f688bSRobert Mustacchi * the DW_AT_type entry. Next, the number of entries is stored in a more 1519bc1f688bSRobert Mustacchi * complicated form, we should have a child that has the DW_TAG_subrange type. 1520bc1f688bSRobert Mustacchi */ 1521bc1f688bSRobert Mustacchi static int 1522bc1f688bSRobert Mustacchi ctf_dwarf_create_array(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot) 1523bc1f688bSRobert Mustacchi { 1524bc1f688bSRobert Mustacchi int ret; 1525bc1f688bSRobert Mustacchi Dwarf_Die tdie, rdie; 1526bc1f688bSRobert Mustacchi ctf_id_t tid; 1527bc1f688bSRobert Mustacchi Dwarf_Half rtag; 1528bc1f688bSRobert Mustacchi 1529bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) 1530bc1f688bSRobert Mustacchi return (ret); 1531bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &tid, 1532bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1533bc1f688bSRobert Mustacchi return (ret); 1534bc1f688bSRobert Mustacchi 1535bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &rdie)) != 0) 1536bc1f688bSRobert Mustacchi return (ret); 1537bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, rdie, &rtag)) != 0) 1538bc1f688bSRobert Mustacchi return (ret); 1539bc1f688bSRobert Mustacchi if (rtag != DW_TAG_subrange_type) { 1540bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1541bc1f688bSRobert Mustacchi "encountered array without DW_TAG_subrange_type child\n"); 1542bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1543bc1f688bSRobert Mustacchi } 1544bc1f688bSRobert Mustacchi 1545bc1f688bSRobert Mustacchi /* 1546bc1f688bSRobert Mustacchi * The compiler may opt to describe a multi-dimensional array as one 1547bc1f688bSRobert Mustacchi * giant array or it may opt to instead encode it as a series of 1548bc1f688bSRobert Mustacchi * subranges. If it's the latter, then for each subrange we introduce a 1549bc1f688bSRobert Mustacchi * type. We can always use the base type. 1550bc1f688bSRobert Mustacchi */ 1551bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_create_array_range(cup, rdie, idp, tid, 1552bc1f688bSRobert Mustacchi isroot)) != 0) 1553bc1f688bSRobert Mustacchi return (ret); 1554bc1f688bSRobert Mustacchi ctf_dprintf("Got back id %d\n", *idp); 1555bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, *idp, die, B_FALSE)); 1556bc1f688bSRobert Mustacchi } 1557bc1f688bSRobert Mustacchi 15586ef284f1SJohn Levon /* 15596ef284f1SJohn Levon * Given "const int const_array3[11]", GCC7 at least will create a DIE tree of 15606ef284f1SJohn Levon * DW_TAG_const_type:DW_TAG_array_type:DW_Tag_const_type:<member_type>. 15616ef284f1SJohn Levon * 15626ef284f1SJohn Levon * Given C's syntax, this renders out as "const const int const_array3[11]". To 15636ef284f1SJohn Levon * get closer to round-tripping (and make the unit tests work), we'll peek for 15646ef284f1SJohn Levon * this case, and avoid adding the extraneous qualifier if we see that the 15656ef284f1SJohn Levon * underlying array referent already has the same qualifier. 15666ef284f1SJohn Levon * 15676ef284f1SJohn Levon * This is unfortunately less trivial than it could be: this issue applies to 15686ef284f1SJohn Levon * qualifier sets like "const volatile", as well as multi-dimensional arrays, so 15696ef284f1SJohn Levon * we need to descend down those. 15706ef284f1SJohn Levon * 15716ef284f1SJohn Levon * Returns CTF_ERR on error, or a boolean value otherwise. 15726ef284f1SJohn Levon */ 15736ef284f1SJohn Levon static int 15746ef284f1SJohn Levon needed_array_qualifier(ctf_cu_t *cup, int kind, ctf_id_t ref_id) 15756ef284f1SJohn Levon { 15766ef284f1SJohn Levon const ctf_type_t *t; 15776ef284f1SJohn Levon ctf_arinfo_t arinfo; 15786ef284f1SJohn Levon int akind; 15796ef284f1SJohn Levon 15806ef284f1SJohn Levon if (kind != CTF_K_CONST && kind != CTF_K_VOLATILE && 15816ef284f1SJohn Levon kind != CTF_K_RESTRICT) 15826ef284f1SJohn Levon return (1); 15836ef284f1SJohn Levon 15846ef284f1SJohn Levon if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, ref_id)) == NULL) 15856ef284f1SJohn Levon return (CTF_ERR); 15866ef284f1SJohn Levon 15876ef284f1SJohn Levon if (LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info) != CTF_K_ARRAY) 15886ef284f1SJohn Levon return (1); 15896ef284f1SJohn Levon 15906ef284f1SJohn Levon if (ctf_dyn_array_info(cup->cu_ctfp, ref_id, &arinfo) != 0) 15916ef284f1SJohn Levon return (CTF_ERR); 15926ef284f1SJohn Levon 15936ef284f1SJohn Levon ctf_id_t id = arinfo.ctr_contents; 15946ef284f1SJohn Levon 15956ef284f1SJohn Levon for (;;) { 15966ef284f1SJohn Levon if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, id)) == NULL) 15976ef284f1SJohn Levon return (CTF_ERR); 15986ef284f1SJohn Levon 15996ef284f1SJohn Levon akind = LCTF_INFO_KIND(cup->cu_ctfp, t->ctt_info); 16006ef284f1SJohn Levon 16016ef284f1SJohn Levon if (akind == kind) 16026ef284f1SJohn Levon break; 16036ef284f1SJohn Levon 16046ef284f1SJohn Levon if (akind == CTF_K_ARRAY) { 16056ef284f1SJohn Levon if (ctf_dyn_array_info(cup->cu_ctfp, 16066ef284f1SJohn Levon id, &arinfo) != 0) 16076ef284f1SJohn Levon return (CTF_ERR); 16086ef284f1SJohn Levon id = arinfo.ctr_contents; 16096ef284f1SJohn Levon continue; 16106ef284f1SJohn Levon } 16116ef284f1SJohn Levon 16126ef284f1SJohn Levon if (akind != CTF_K_CONST && akind != CTF_K_VOLATILE && 16136ef284f1SJohn Levon akind != CTF_K_RESTRICT) 16146ef284f1SJohn Levon break; 16156ef284f1SJohn Levon 16166ef284f1SJohn Levon id = t->ctt_type; 16176ef284f1SJohn Levon } 16186ef284f1SJohn Levon 16196ef284f1SJohn Levon if (kind == akind) { 16206ef284f1SJohn Levon ctf_dprintf("ignoring extraneous %s qualifier for array %d\n", 16216ef284f1SJohn Levon ctf_kind_name(cup->cu_ctfp, kind), ref_id); 16226ef284f1SJohn Levon } 16236ef284f1SJohn Levon 16246ef284f1SJohn Levon return (kind != akind); 16256ef284f1SJohn Levon } 16266ef284f1SJohn Levon 1627bc1f688bSRobert Mustacchi static int 1628bc1f688bSRobert Mustacchi ctf_dwarf_create_reference(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, 1629bc1f688bSRobert Mustacchi int kind, int isroot) 1630bc1f688bSRobert Mustacchi { 1631bc1f688bSRobert Mustacchi int ret; 1632bc1f688bSRobert Mustacchi ctf_id_t id; 1633bc1f688bSRobert Mustacchi Dwarf_Die tdie; 1634bc1f688bSRobert Mustacchi char *name; 1635bc1f688bSRobert Mustacchi size_t namelen; 1636bc1f688bSRobert Mustacchi 1637bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 1638bc1f688bSRobert Mustacchi ret != ENOENT) 1639bc1f688bSRobert Mustacchi return (ret); 1640bc1f688bSRobert Mustacchi if (ret == ENOENT) { 1641bc1f688bSRobert Mustacchi name = NULL; 1642bc1f688bSRobert Mustacchi namelen = 0; 1643bc1f688bSRobert Mustacchi } else { 1644bc1f688bSRobert Mustacchi namelen = strlen(name); 1645bc1f688bSRobert Mustacchi } 1646bc1f688bSRobert Mustacchi 1647bc1f688bSRobert Mustacchi ctf_dprintf("reference kind %d %s\n", kind, name != NULL ? name : "<>"); 1648bc1f688bSRobert Mustacchi 1649bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) { 1650bc1f688bSRobert Mustacchi if (ret != ENOENT) { 1651bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1652bc1f688bSRobert Mustacchi return (ret); 1653bc1f688bSRobert Mustacchi } 1654bc1f688bSRobert Mustacchi if ((id = ctf_dwarf_void(cup)) == CTF_ERR) { 1655bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1656bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1657bc1f688bSRobert Mustacchi } 1658bc1f688bSRobert Mustacchi } else { 1659bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &id, 1660bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) { 1661bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1662bc1f688bSRobert Mustacchi return (ret); 1663bc1f688bSRobert Mustacchi } 1664bc1f688bSRobert Mustacchi } 1665bc1f688bSRobert Mustacchi 16666ef284f1SJohn Levon if ((ret = needed_array_qualifier(cup, kind, id)) <= 0) { 16676ef284f1SJohn Levon if (ret != 0) { 16686ef284f1SJohn Levon ret = (ctf_errno(cup->cu_ctfp)); 16696ef284f1SJohn Levon } else { 16706ef284f1SJohn Levon *idp = id; 16716ef284f1SJohn Levon } 16726ef284f1SJohn Levon 16736ef284f1SJohn Levon ctf_free(name, namelen); 16746ef284f1SJohn Levon return (ret); 16756ef284f1SJohn Levon } 16766ef284f1SJohn Levon 1677bc1f688bSRobert Mustacchi if ((*idp = ctf_add_reftype(cup->cu_ctfp, isroot, name, id, kind)) == 1678bc1f688bSRobert Mustacchi CTF_ERR) { 1679bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1680bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1681bc1f688bSRobert Mustacchi } 1682bc1f688bSRobert Mustacchi 1683bc1f688bSRobert Mustacchi ctf_free(name, namelen); 1684bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, *idp, die, B_FALSE)); 1685bc1f688bSRobert Mustacchi } 1686bc1f688bSRobert Mustacchi 1687fe2dc8bdSJohn Levon /* 1688fe2dc8bdSJohn Levon * Get the size of the type of a particular die. Note that this is a simple 1689fe2dc8bdSJohn Levon * version that doesn't attempt to traverse further than expecting a single 1690fe2dc8bdSJohn Levon * sized type reference (so no qualifiers etc.). Nor does it attempt to do as 1691fe2dc8bdSJohn Levon * much as ctf_type_size() - which we cannot use here as that doesn't look up 1692fe2dc8bdSJohn Levon * dynamic types, and we don't yet want to do a ctf_update(). 1693fe2dc8bdSJohn Levon */ 1694bc1f688bSRobert Mustacchi static int 1695fe2dc8bdSJohn Levon ctf_dwarf_get_type_size(ctf_cu_t *cup, Dwarf_Die die, size_t *sizep) 1696bc1f688bSRobert Mustacchi { 1697fe2dc8bdSJohn Levon const ctf_type_t *t; 1698fe2dc8bdSJohn Levon Dwarf_Die tdie; 1699fe2dc8bdSJohn Levon ctf_id_t tid; 1700bc1f688bSRobert Mustacchi int ret; 1701fe2dc8bdSJohn Levon 1702fe2dc8bdSJohn Levon if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) 1703fe2dc8bdSJohn Levon return (ret); 1704fe2dc8bdSJohn Levon 1705fe2dc8bdSJohn Levon if ((ret = ctf_dwarf_convert_type(cup, tdie, &tid, 1706fe2dc8bdSJohn Levon CTF_ADD_NONROOT)) != 0) 1707fe2dc8bdSJohn Levon return (ret); 1708fe2dc8bdSJohn Levon 1709fe2dc8bdSJohn Levon if ((t = ctf_dyn_lookup_by_id(cup->cu_ctfp, tid)) == NULL) 1710fe2dc8bdSJohn Levon return (ENOENT); 1711fe2dc8bdSJohn Levon 1712fe2dc8bdSJohn Levon *sizep = ctf_get_ctt_size(cup->cu_ctfp, t, NULL, NULL); 1713fe2dc8bdSJohn Levon return (0); 1714fe2dc8bdSJohn Levon } 1715fe2dc8bdSJohn Levon 1716fe2dc8bdSJohn Levon static int 1717fe2dc8bdSJohn Levon ctf_dwarf_create_enum(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot) 1718fe2dc8bdSJohn Levon { 1719fe2dc8bdSJohn Levon size_t size = 0; 1720bc1f688bSRobert Mustacchi Dwarf_Die child; 1721fe2dc8bdSJohn Levon ctf_id_t id; 1722bc1f688bSRobert Mustacchi char *name; 1723fe2dc8bdSJohn Levon int ret; 1724bc1f688bSRobert Mustacchi 1725bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 1726bc1f688bSRobert Mustacchi ret != ENOENT) 1727bc1f688bSRobert Mustacchi return (ret); 1728bc1f688bSRobert Mustacchi if (ret == ENOENT) 1729bc1f688bSRobert Mustacchi name = NULL; 1730fe2dc8bdSJohn Levon 1731fe2dc8bdSJohn Levon (void) ctf_dwarf_get_type_size(cup, die, &size); 1732fe2dc8bdSJohn Levon 1733fe2dc8bdSJohn Levon id = ctf_add_enum(cup->cu_ctfp, isroot, name, size); 1734bc1f688bSRobert Mustacchi ctf_dprintf("added enum %s (%d)\n", name, id); 1735bc1f688bSRobert Mustacchi if (name != NULL) 1736bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1737bc1f688bSRobert Mustacchi if (id == CTF_ERR) 1738bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1739bc1f688bSRobert Mustacchi *idp = id; 1740bc1f688bSRobert Mustacchi if ((ret = ctf_dwmap_add(cup, id, die, B_FALSE)) != 0) 1741bc1f688bSRobert Mustacchi return (ret); 1742bc1f688bSRobert Mustacchi 1743bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) { 1744bc1f688bSRobert Mustacchi if (ret == ENOENT) 1745bc1f688bSRobert Mustacchi ret = 0; 1746bc1f688bSRobert Mustacchi return (ret); 1747bc1f688bSRobert Mustacchi } 1748bc1f688bSRobert Mustacchi 1749bc1f688bSRobert Mustacchi while (child != NULL) { 1750bc1f688bSRobert Mustacchi Dwarf_Half tag; 1751bc1f688bSRobert Mustacchi Dwarf_Signed sval; 1752bc1f688bSRobert Mustacchi Dwarf_Unsigned uval; 1753bc1f688bSRobert Mustacchi Dwarf_Die arg = child; 1754bc1f688bSRobert Mustacchi int eval; 1755bc1f688bSRobert Mustacchi 1756bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, arg, &child)) != 0) 1757bc1f688bSRobert Mustacchi return (ret); 1758bc1f688bSRobert Mustacchi 1759bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0) 1760bc1f688bSRobert Mustacchi return (ret); 1761bc1f688bSRobert Mustacchi 1762bc1f688bSRobert Mustacchi if (tag != DW_TAG_enumerator) { 1763bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, arg, NULL, 1764bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1765bc1f688bSRobert Mustacchi return (ret); 1766bc1f688bSRobert Mustacchi continue; 1767bc1f688bSRobert Mustacchi } 1768bc1f688bSRobert Mustacchi 1769bc1f688bSRobert Mustacchi /* 1770bc1f688bSRobert Mustacchi * DWARF v4 section 5.7 tells us we'll always have names. 1771bc1f688bSRobert Mustacchi */ 1772bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, arg, DW_AT_name, &name)) != 0) 1773bc1f688bSRobert Mustacchi return (ret); 1774bc1f688bSRobert Mustacchi 1775bc1f688bSRobert Mustacchi /* 1776bc1f688bSRobert Mustacchi * We have to be careful here: newer GCCs generate DWARF where 1777bc1f688bSRobert Mustacchi * an unsigned value will happily pass ctf_dwarf_signed(). 1778bc1f688bSRobert Mustacchi * Since negative values will fail ctf_dwarf_unsigned(), we try 1779bc1f688bSRobert Mustacchi * that first to make sure we get the right value. 1780bc1f688bSRobert Mustacchi */ 1781bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_unsigned(cup, arg, DW_AT_const_value, 1782bc1f688bSRobert Mustacchi &uval)) == 0) { 1783bc1f688bSRobert Mustacchi eval = (int)uval; 1784bc1f688bSRobert Mustacchi } else if ((ret = ctf_dwarf_signed(cup, arg, DW_AT_const_value, 1785bc1f688bSRobert Mustacchi &sval)) == 0) { 1786bc1f688bSRobert Mustacchi eval = sval; 1787bc1f688bSRobert Mustacchi } 1788bc1f688bSRobert Mustacchi 1789bc1f688bSRobert Mustacchi if (ret != 0) { 1790bc1f688bSRobert Mustacchi if (ret != ENOENT) 1791bc1f688bSRobert Mustacchi return (ret); 1792bc1f688bSRobert Mustacchi 1793bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1794bc1f688bSRobert Mustacchi "encountered enumeration without constant value\n"); 1795bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1796bc1f688bSRobert Mustacchi } 1797bc1f688bSRobert Mustacchi 1798bc1f688bSRobert Mustacchi ret = ctf_add_enumerator(cup->cu_ctfp, id, name, eval); 1799bc1f688bSRobert Mustacchi if (ret == CTF_ERR) { 1800bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1801bc1f688bSRobert Mustacchi "failed to add enumarator %s (%d) to %d\n", 1802bc1f688bSRobert Mustacchi name, eval, id); 1803bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1804bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1805bc1f688bSRobert Mustacchi } 1806bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 1807bc1f688bSRobert Mustacchi } 1808bc1f688bSRobert Mustacchi 1809bc1f688bSRobert Mustacchi return (0); 1810bc1f688bSRobert Mustacchi } 1811bc1f688bSRobert Mustacchi 1812bc1f688bSRobert Mustacchi /* 1813bc1f688bSRobert Mustacchi * For a function pointer, walk over and process all of its children, unless we 1814bc1f688bSRobert Mustacchi * encounter one that's just a declaration. In which case, we error on it. 1815bc1f688bSRobert Mustacchi */ 1816bc1f688bSRobert Mustacchi static int 1817bc1f688bSRobert Mustacchi ctf_dwarf_create_fptr(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, int isroot) 1818bc1f688bSRobert Mustacchi { 1819bc1f688bSRobert Mustacchi int ret; 1820bc1f688bSRobert Mustacchi Dwarf_Bool b; 1821bc1f688bSRobert Mustacchi ctf_funcinfo_t fi; 1822bc1f688bSRobert Mustacchi Dwarf_Die retdie; 1823bc1f688bSRobert Mustacchi ctf_id_t *argv = NULL; 1824bc1f688bSRobert Mustacchi 1825bc1f688bSRobert Mustacchi bzero(&fi, sizeof (ctf_funcinfo_t)); 1826bc1f688bSRobert Mustacchi 1827bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) { 1828bc1f688bSRobert Mustacchi if (ret != ENOENT) 1829bc1f688bSRobert Mustacchi return (ret); 1830bc1f688bSRobert Mustacchi } else { 1831bc1f688bSRobert Mustacchi if (b != 0) 1832bc1f688bSRobert Mustacchi return (EPROTOTYPE); 1833bc1f688bSRobert Mustacchi } 1834bc1f688bSRobert Mustacchi 1835bc1f688bSRobert Mustacchi /* 1836bc1f688bSRobert Mustacchi * Return type is in DW_AT_type, if none, it returns void. 1837bc1f688bSRobert Mustacchi */ 1838bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &retdie)) != 0) { 1839bc1f688bSRobert Mustacchi if (ret != ENOENT) 1840bc1f688bSRobert Mustacchi return (ret); 1841bc1f688bSRobert Mustacchi if ((fi.ctc_return = ctf_dwarf_void(cup)) == CTF_ERR) 1842bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1843bc1f688bSRobert Mustacchi } else { 1844bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, retdie, &fi.ctc_return, 1845bc1f688bSRobert Mustacchi CTF_ADD_NONROOT)) != 0) 1846bc1f688bSRobert Mustacchi return (ret); 1847bc1f688bSRobert Mustacchi } 1848bc1f688bSRobert Mustacchi 1849bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_function_count(cup, die, &fi, B_TRUE)) != 0) { 1850bc1f688bSRobert Mustacchi return (ret); 1851bc1f688bSRobert Mustacchi } 1852bc1f688bSRobert Mustacchi 1853bc1f688bSRobert Mustacchi if (fi.ctc_argc != 0) { 1854bc1f688bSRobert Mustacchi argv = ctf_alloc(sizeof (ctf_id_t) * fi.ctc_argc); 1855bc1f688bSRobert Mustacchi if (argv == NULL) 1856bc1f688bSRobert Mustacchi return (ENOMEM); 1857bc1f688bSRobert Mustacchi 1858bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_fargs(cup, die, &fi, argv)) != 0) { 1859bc1f688bSRobert Mustacchi ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc); 1860bc1f688bSRobert Mustacchi return (ret); 1861bc1f688bSRobert Mustacchi } 1862bc1f688bSRobert Mustacchi } 1863bc1f688bSRobert Mustacchi 1864bc1f688bSRobert Mustacchi if ((*idp = ctf_add_funcptr(cup->cu_ctfp, isroot, &fi, argv)) == 1865bc1f688bSRobert Mustacchi CTF_ERR) { 1866bc1f688bSRobert Mustacchi ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc); 1867bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 1868bc1f688bSRobert Mustacchi } 1869bc1f688bSRobert Mustacchi 1870bc1f688bSRobert Mustacchi ctf_free(argv, sizeof (ctf_id_t) * fi.ctc_argc); 1871bc1f688bSRobert Mustacchi return (ctf_dwmap_add(cup, *idp, die, B_FALSE)); 1872bc1f688bSRobert Mustacchi } 1873bc1f688bSRobert Mustacchi 1874bc1f688bSRobert Mustacchi static int 1875bc1f688bSRobert Mustacchi ctf_dwarf_convert_type(ctf_cu_t *cup, Dwarf_Die die, ctf_id_t *idp, 1876bc1f688bSRobert Mustacchi int isroot) 1877bc1f688bSRobert Mustacchi { 1878bc1f688bSRobert Mustacchi int ret; 1879bc1f688bSRobert Mustacchi Dwarf_Off offset; 1880bc1f688bSRobert Mustacchi Dwarf_Half tag; 1881bc1f688bSRobert Mustacchi ctf_dwmap_t lookup, *map; 1882bc1f688bSRobert Mustacchi ctf_id_t id; 1883bc1f688bSRobert Mustacchi 1884bc1f688bSRobert Mustacchi if (idp == NULL) 1885bc1f688bSRobert Mustacchi idp = &id; 1886bc1f688bSRobert Mustacchi 1887bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0) 1888bc1f688bSRobert Mustacchi return (ret); 1889bc1f688bSRobert Mustacchi 1890bc1f688bSRobert Mustacchi if (offset > cup->cu_maxoff) { 1891bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 1892bc1f688bSRobert Mustacchi "die offset %llu beyond maximum for header %llu\n", 1893bc1f688bSRobert Mustacchi offset, cup->cu_maxoff); 1894bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 1895bc1f688bSRobert Mustacchi } 1896bc1f688bSRobert Mustacchi 1897bc1f688bSRobert Mustacchi /* 1898bc1f688bSRobert Mustacchi * If we've already added an entry for this offset, then we're done. 1899bc1f688bSRobert Mustacchi */ 1900bc1f688bSRobert Mustacchi lookup.cdm_off = offset; 1901bc1f688bSRobert Mustacchi if ((map = avl_find(&cup->cu_map, &lookup, NULL)) != NULL) { 1902bc1f688bSRobert Mustacchi *idp = map->cdm_id; 1903bc1f688bSRobert Mustacchi return (0); 1904bc1f688bSRobert Mustacchi } 1905bc1f688bSRobert Mustacchi 1906bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0) 1907bc1f688bSRobert Mustacchi return (ret); 1908bc1f688bSRobert Mustacchi 1909bc1f688bSRobert Mustacchi ret = ENOTSUP; 1910bc1f688bSRobert Mustacchi switch (tag) { 1911bc1f688bSRobert Mustacchi case DW_TAG_base_type: 1912bc1f688bSRobert Mustacchi ctf_dprintf("base\n"); 1913bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_base(cup, die, idp, isroot, offset); 1914bc1f688bSRobert Mustacchi break; 1915bc1f688bSRobert Mustacchi case DW_TAG_array_type: 1916bc1f688bSRobert Mustacchi ctf_dprintf("array\n"); 1917bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_array(cup, die, idp, isroot); 1918bc1f688bSRobert Mustacchi break; 1919bc1f688bSRobert Mustacchi case DW_TAG_enumeration_type: 1920bc1f688bSRobert Mustacchi ctf_dprintf("enum\n"); 1921bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_enum(cup, die, idp, isroot); 1922bc1f688bSRobert Mustacchi break; 1923bc1f688bSRobert Mustacchi case DW_TAG_pointer_type: 1924bc1f688bSRobert Mustacchi ctf_dprintf("pointer\n"); 1925bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_POINTER, 1926bc1f688bSRobert Mustacchi isroot); 1927bc1f688bSRobert Mustacchi break; 1928bc1f688bSRobert Mustacchi case DW_TAG_structure_type: 1929bc1f688bSRobert Mustacchi ctf_dprintf("struct\n"); 1930bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_STRUCT, 1931bc1f688bSRobert Mustacchi isroot); 1932bc1f688bSRobert Mustacchi break; 1933bc1f688bSRobert Mustacchi case DW_TAG_subroutine_type: 1934bc1f688bSRobert Mustacchi ctf_dprintf("fptr\n"); 1935bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_fptr(cup, die, idp, isroot); 1936bc1f688bSRobert Mustacchi break; 1937bc1f688bSRobert Mustacchi case DW_TAG_typedef: 1938bc1f688bSRobert Mustacchi ctf_dprintf("typedef\n"); 1939bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_TYPEDEF, 1940bc1f688bSRobert Mustacchi isroot); 1941bc1f688bSRobert Mustacchi break; 1942bc1f688bSRobert Mustacchi case DW_TAG_union_type: 1943bc1f688bSRobert Mustacchi ctf_dprintf("union\n"); 1944bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_sou(cup, die, idp, CTF_K_UNION, 1945bc1f688bSRobert Mustacchi isroot); 1946bc1f688bSRobert Mustacchi break; 1947bc1f688bSRobert Mustacchi case DW_TAG_const_type: 1948bc1f688bSRobert Mustacchi ctf_dprintf("const\n"); 1949bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_CONST, 1950bc1f688bSRobert Mustacchi isroot); 1951bc1f688bSRobert Mustacchi break; 1952bc1f688bSRobert Mustacchi case DW_TAG_volatile_type: 1953bc1f688bSRobert Mustacchi ctf_dprintf("volatile\n"); 1954bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_VOLATILE, 1955bc1f688bSRobert Mustacchi isroot); 1956bc1f688bSRobert Mustacchi break; 1957bc1f688bSRobert Mustacchi case DW_TAG_restrict_type: 1958bc1f688bSRobert Mustacchi ctf_dprintf("restrict\n"); 1959bc1f688bSRobert Mustacchi ret = ctf_dwarf_create_reference(cup, die, idp, CTF_K_RESTRICT, 1960bc1f688bSRobert Mustacchi isroot); 1961bc1f688bSRobert Mustacchi break; 1962bc1f688bSRobert Mustacchi default: 1963bc1f688bSRobert Mustacchi ctf_dprintf("ignoring tag type %x\n", tag); 19643eca6103SJohn Levon *idp = CTF_ERR; 1965bc1f688bSRobert Mustacchi ret = 0; 1966bc1f688bSRobert Mustacchi break; 1967bc1f688bSRobert Mustacchi } 1968bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_convert_type tag specific handler returned %d\n", 1969bc1f688bSRobert Mustacchi ret); 1970bc1f688bSRobert Mustacchi 1971bc1f688bSRobert Mustacchi return (ret); 1972bc1f688bSRobert Mustacchi } 1973bc1f688bSRobert Mustacchi 1974bc1f688bSRobert Mustacchi static int 1975bc1f688bSRobert Mustacchi ctf_dwarf_walk_lexical(ctf_cu_t *cup, Dwarf_Die die) 1976bc1f688bSRobert Mustacchi { 1977bc1f688bSRobert Mustacchi int ret; 1978bc1f688bSRobert Mustacchi Dwarf_Die child; 1979bc1f688bSRobert Mustacchi 1980bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 1981bc1f688bSRobert Mustacchi return (ret); 1982bc1f688bSRobert Mustacchi 1983bc1f688bSRobert Mustacchi if (child == NULL) 1984bc1f688bSRobert Mustacchi return (0); 1985bc1f688bSRobert Mustacchi 1986bc1f688bSRobert Mustacchi return (ctf_dwarf_convert_die(cup, die)); 1987bc1f688bSRobert Mustacchi } 1988bc1f688bSRobert Mustacchi 1989bc1f688bSRobert Mustacchi static int 1990bc1f688bSRobert Mustacchi ctf_dwarf_function_count(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip, 1991bc1f688bSRobert Mustacchi boolean_t fptr) 1992bc1f688bSRobert Mustacchi { 1993bc1f688bSRobert Mustacchi int ret; 1994bc1f688bSRobert Mustacchi Dwarf_Die child, sib, arg; 1995bc1f688bSRobert Mustacchi 1996bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 1997bc1f688bSRobert Mustacchi return (ret); 1998bc1f688bSRobert Mustacchi 1999bc1f688bSRobert Mustacchi arg = child; 2000bc1f688bSRobert Mustacchi while (arg != NULL) { 2001bc1f688bSRobert Mustacchi Dwarf_Half tag; 2002bc1f688bSRobert Mustacchi 2003bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0) 2004bc1f688bSRobert Mustacchi return (ret); 2005bc1f688bSRobert Mustacchi 2006bc1f688bSRobert Mustacchi /* 20076ef284f1SJohn Levon * We have to check for a varargs type declaration. This will 2008bc1f688bSRobert Mustacchi * happen in one of two ways. If we have a function pointer 2009bc1f688bSRobert Mustacchi * type, then it'll be done with a tag of type 2010bc1f688bSRobert Mustacchi * DW_TAG_unspecified_parameters. However, it only means we have 2011bc1f688bSRobert Mustacchi * a variable number of arguments, if we have more than one 2012bc1f688bSRobert Mustacchi * argument found so far. Otherwise, when we have a function 2013bc1f688bSRobert Mustacchi * type, it instead uses a formal parameter whose name is '...' 2014bc1f688bSRobert Mustacchi * to indicate a variable arguments member. 2015bc1f688bSRobert Mustacchi * 2016bc1f688bSRobert Mustacchi * Also, if we have a function pointer, then we have to expect 2017bc1f688bSRobert Mustacchi * that we might not get a name at all. 2018bc1f688bSRobert Mustacchi */ 2019bc1f688bSRobert Mustacchi if (tag == DW_TAG_formal_parameter && fptr == B_FALSE) { 2020bc1f688bSRobert Mustacchi char *name; 2021bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, 2022bc1f688bSRobert Mustacchi &name)) != 0) 2023bc1f688bSRobert Mustacchi return (ret); 2024bc1f688bSRobert Mustacchi if (strcmp(name, DWARF_VARARGS_NAME) == 0) 2025bc1f688bSRobert Mustacchi fip->ctc_flags |= CTF_FUNC_VARARG; 2026bc1f688bSRobert Mustacchi else 2027bc1f688bSRobert Mustacchi fip->ctc_argc++; 2028bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2029bc1f688bSRobert Mustacchi } else if (tag == DW_TAG_formal_parameter) { 2030bc1f688bSRobert Mustacchi fip->ctc_argc++; 2031bc1f688bSRobert Mustacchi } else if (tag == DW_TAG_unspecified_parameters && 2032bc1f688bSRobert Mustacchi fip->ctc_argc > 0) { 2033bc1f688bSRobert Mustacchi fip->ctc_flags |= CTF_FUNC_VARARG; 2034bc1f688bSRobert Mustacchi } 2035bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0) 2036bc1f688bSRobert Mustacchi return (ret); 2037bc1f688bSRobert Mustacchi arg = sib; 2038bc1f688bSRobert Mustacchi } 2039bc1f688bSRobert Mustacchi 2040bc1f688bSRobert Mustacchi return (0); 2041bc1f688bSRobert Mustacchi } 2042bc1f688bSRobert Mustacchi 2043bc1f688bSRobert Mustacchi static int 2044bc1f688bSRobert Mustacchi ctf_dwarf_convert_fargs(ctf_cu_t *cup, Dwarf_Die die, ctf_funcinfo_t *fip, 2045bc1f688bSRobert Mustacchi ctf_id_t *argv) 2046bc1f688bSRobert Mustacchi { 2047bc1f688bSRobert Mustacchi int ret; 2048bc1f688bSRobert Mustacchi int i = 0; 2049bc1f688bSRobert Mustacchi Dwarf_Die child, sib, arg; 2050bc1f688bSRobert Mustacchi 2051bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_child(cup, die, &child)) != 0) 2052bc1f688bSRobert Mustacchi return (ret); 2053bc1f688bSRobert Mustacchi 2054bc1f688bSRobert Mustacchi arg = child; 2055bc1f688bSRobert Mustacchi while (arg != NULL) { 2056bc1f688bSRobert Mustacchi Dwarf_Half tag; 2057bc1f688bSRobert Mustacchi 2058bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, arg, &tag)) != 0) 2059bc1f688bSRobert Mustacchi return (ret); 2060bc1f688bSRobert Mustacchi if (tag == DW_TAG_formal_parameter) { 2061bc1f688bSRobert Mustacchi Dwarf_Die tdie; 2062bc1f688bSRobert Mustacchi 2063bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, arg, DW_AT_type, 2064bc1f688bSRobert Mustacchi &tdie)) != 0) 2065bc1f688bSRobert Mustacchi return (ret); 2066bc1f688bSRobert Mustacchi 2067bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &argv[i], 2068bc1f688bSRobert Mustacchi CTF_ADD_ROOT)) != 0) 2069bc1f688bSRobert Mustacchi return (ret); 2070bc1f688bSRobert Mustacchi i++; 2071bc1f688bSRobert Mustacchi 2072bc1f688bSRobert Mustacchi /* 2073bc1f688bSRobert Mustacchi * Once we hit argc entries, we're done. This ensures we 2074bc1f688bSRobert Mustacchi * don't accidentally hit a varargs which should be the 2075bc1f688bSRobert Mustacchi * last entry. 2076bc1f688bSRobert Mustacchi */ 2077bc1f688bSRobert Mustacchi if (i == fip->ctc_argc) 2078bc1f688bSRobert Mustacchi break; 2079bc1f688bSRobert Mustacchi } 2080bc1f688bSRobert Mustacchi 2081bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, arg, &sib)) != 0) 2082bc1f688bSRobert Mustacchi return (ret); 2083bc1f688bSRobert Mustacchi arg = sib; 2084bc1f688bSRobert Mustacchi } 2085bc1f688bSRobert Mustacchi 2086bc1f688bSRobert Mustacchi return (0); 2087bc1f688bSRobert Mustacchi } 2088bc1f688bSRobert Mustacchi 2089bc1f688bSRobert Mustacchi static int 2090bc1f688bSRobert Mustacchi ctf_dwarf_convert_function(ctf_cu_t *cup, Dwarf_Die die) 2091bc1f688bSRobert Mustacchi { 2092bc1f688bSRobert Mustacchi ctf_dwfunc_t *cdf; 2093bc1f688bSRobert Mustacchi Dwarf_Die tdie; 20946ef284f1SJohn Levon Dwarf_Bool b; 20956ef284f1SJohn Levon char *name; 20966ef284f1SJohn Levon int ret; 2097bc1f688bSRobert Mustacchi 2098bc1f688bSRobert Mustacchi /* 2099bc1f688bSRobert Mustacchi * Functions that don't have a name are generally functions that have 2100bc1f688bSRobert Mustacchi * been inlined and thus most information about them has been lost. If 2101bc1f688bSRobert Mustacchi * we can't get a name, then instead of returning ENOENT, we silently 2102bc1f688bSRobert Mustacchi * swallow the error. 2103bc1f688bSRobert Mustacchi */ 2104bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0) { 2105bc1f688bSRobert Mustacchi if (ret == ENOENT) 2106bc1f688bSRobert Mustacchi return (0); 2107bc1f688bSRobert Mustacchi return (ret); 2108bc1f688bSRobert Mustacchi } 2109bc1f688bSRobert Mustacchi 21106ef284f1SJohn Levon ctf_dprintf("beginning work on function %s (die %llx)\n", 21116ef284f1SJohn Levon name, ctf_die_offset(die)); 21126ef284f1SJohn Levon 21136ef284f1SJohn Levon if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) != 0) { 21146ef284f1SJohn Levon if (ret != ENOENT) 21156ef284f1SJohn Levon return (ret); 21166ef284f1SJohn Levon } else if (b != 0) { 21176ef284f1SJohn Levon /* 21186ef284f1SJohn Levon * GCC7 at least creates empty DW_AT_declarations for functions 21196ef284f1SJohn Levon * defined in headers. As they lack details on the function 21206ef284f1SJohn Levon * prototype, we need to ignore them. If we later actually 21216ef284f1SJohn Levon * see the relevant function's definition, we will see another 21226ef284f1SJohn Levon * DW_TAG_subprogram that is more complete. 21236ef284f1SJohn Levon */ 21246ef284f1SJohn Levon ctf_dprintf("ignoring declaration of function %s (die %llx)\n", 21256ef284f1SJohn Levon name, ctf_die_offset(die)); 21266ef284f1SJohn Levon return (0); 21276ef284f1SJohn Levon } 21286ef284f1SJohn Levon 2129bc1f688bSRobert Mustacchi if ((cdf = ctf_alloc(sizeof (ctf_dwfunc_t))) == NULL) { 2130bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2131bc1f688bSRobert Mustacchi return (ENOMEM); 2132bc1f688bSRobert Mustacchi } 2133bc1f688bSRobert Mustacchi bzero(cdf, sizeof (ctf_dwfunc_t)); 2134bc1f688bSRobert Mustacchi cdf->cdf_name = name; 2135bc1f688bSRobert Mustacchi 2136bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) == 0) { 2137bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, 2138bc1f688bSRobert Mustacchi &(cdf->cdf_fip.ctc_return), CTF_ADD_ROOT)) != 0) { 2139bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2140bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2141bc1f688bSRobert Mustacchi return (ret); 2142bc1f688bSRobert Mustacchi } 2143bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 2144bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2145bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2146bc1f688bSRobert Mustacchi return (ret); 2147bc1f688bSRobert Mustacchi } else { 2148bc1f688bSRobert Mustacchi if ((cdf->cdf_fip.ctc_return = ctf_dwarf_void(cup)) == 2149bc1f688bSRobert Mustacchi CTF_ERR) { 2150bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2151bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2152bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2153bc1f688bSRobert Mustacchi } 2154bc1f688bSRobert Mustacchi } 2155bc1f688bSRobert Mustacchi 2156bc1f688bSRobert Mustacchi /* 2157bc1f688bSRobert Mustacchi * A function has a number of children, some of which may not be ones we 2158bc1f688bSRobert Mustacchi * care about. Children that we care about have a type of 2159bc1f688bSRobert Mustacchi * DW_TAG_formal_parameter. We're going to do two passes, the first to 2160bc1f688bSRobert Mustacchi * count the arguments, the second to process them. Afterwards, we 2161bc1f688bSRobert Mustacchi * should be good to go ahead and add this function. 2162bc1f688bSRobert Mustacchi * 2163bc1f688bSRobert Mustacchi * Note, we already got the return type by going in and grabbing it out 2164bc1f688bSRobert Mustacchi * of the DW_AT_type. 2165bc1f688bSRobert Mustacchi */ 2166bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_function_count(cup, die, &cdf->cdf_fip, 2167bc1f688bSRobert Mustacchi B_FALSE)) != 0) { 2168bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2169bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2170bc1f688bSRobert Mustacchi return (ret); 2171bc1f688bSRobert Mustacchi } 2172bc1f688bSRobert Mustacchi 2173bc1f688bSRobert Mustacchi ctf_dprintf("beginning to convert function arguments %s\n", name); 2174bc1f688bSRobert Mustacchi if (cdf->cdf_fip.ctc_argc != 0) { 2175bc1f688bSRobert Mustacchi uint_t argc = cdf->cdf_fip.ctc_argc; 2176bc1f688bSRobert Mustacchi cdf->cdf_argv = ctf_alloc(sizeof (ctf_id_t) * argc); 2177bc1f688bSRobert Mustacchi if (cdf->cdf_argv == NULL) { 2178bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2179bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2180bc1f688bSRobert Mustacchi return (ENOMEM); 2181bc1f688bSRobert Mustacchi } 2182bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_fargs(cup, die, 2183bc1f688bSRobert Mustacchi &cdf->cdf_fip, cdf->cdf_argv)) != 0) { 2184bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) * argc); 2185bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2186bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2187bc1f688bSRobert Mustacchi return (ret); 2188bc1f688bSRobert Mustacchi } 2189bc1f688bSRobert Mustacchi } else { 2190bc1f688bSRobert Mustacchi cdf->cdf_argv = NULL; 2191bc1f688bSRobert Mustacchi } 2192bc1f688bSRobert Mustacchi 2193bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_isglobal(cup, die, &cdf->cdf_global)) != 0) { 2194bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_argv, sizeof (ctf_id_t) * 2195bc1f688bSRobert Mustacchi cdf->cdf_fip.ctc_argc); 2196bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2197bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2198bc1f688bSRobert Mustacchi return (ret); 2199bc1f688bSRobert Mustacchi } 2200bc1f688bSRobert Mustacchi 2201bc1f688bSRobert Mustacchi ctf_list_append(&cup->cu_funcs, cdf); 2202bc1f688bSRobert Mustacchi return (ret); 2203bc1f688bSRobert Mustacchi } 2204bc1f688bSRobert Mustacchi 2205bc1f688bSRobert Mustacchi /* 2206bc1f688bSRobert Mustacchi * Convert variables, but only if they're not prototypes and have names. 2207bc1f688bSRobert Mustacchi */ 2208bc1f688bSRobert Mustacchi static int 2209bc1f688bSRobert Mustacchi ctf_dwarf_convert_variable(ctf_cu_t *cup, Dwarf_Die die) 2210bc1f688bSRobert Mustacchi { 2211bc1f688bSRobert Mustacchi int ret; 2212bc1f688bSRobert Mustacchi char *name; 2213bc1f688bSRobert Mustacchi Dwarf_Bool b; 2214bc1f688bSRobert Mustacchi Dwarf_Die tdie; 2215bc1f688bSRobert Mustacchi ctf_id_t id; 2216bc1f688bSRobert Mustacchi ctf_dwvar_t *cdv; 2217bc1f688bSRobert Mustacchi 2218bc1f688bSRobert Mustacchi /* Skip "Non-Defining Declarations" */ 2219bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_boolean(cup, die, DW_AT_declaration, &b)) == 0) { 2220bc1f688bSRobert Mustacchi if (b != 0) 2221bc1f688bSRobert Mustacchi return (0); 2222bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 2223bc1f688bSRobert Mustacchi return (ret); 2224bc1f688bSRobert Mustacchi } 2225bc1f688bSRobert Mustacchi 2226bc1f688bSRobert Mustacchi /* 2227bc1f688bSRobert Mustacchi * If we find a DIE of "Declarations Completing Non-Defining 2228bc1f688bSRobert Mustacchi * Declarations", we will use the referenced type's DIE. This isn't 2229bc1f688bSRobert Mustacchi * quite correct, e.g. DW_AT_decl_line will be the forward declaration 2230bc1f688bSRobert Mustacchi * not this site. It's sufficient for what we need, however: in 2231bc1f688bSRobert Mustacchi * particular, we should find DW_AT_external as needed there. 2232bc1f688bSRobert Mustacchi */ 2233bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_specification, 2234bc1f688bSRobert Mustacchi &tdie)) == 0) { 2235bc1f688bSRobert Mustacchi Dwarf_Off offset; 2236bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, tdie, &offset)) != 0) 2237bc1f688bSRobert Mustacchi return (ret); 2238bc1f688bSRobert Mustacchi ctf_dprintf("die 0x%llx DW_AT_specification -> die 0x%llx\n", 2239bc1f688bSRobert Mustacchi ctf_die_offset(die), ctf_die_offset(tdie)); 2240bc1f688bSRobert Mustacchi die = tdie; 2241bc1f688bSRobert Mustacchi } else if (ret != ENOENT) { 2242bc1f688bSRobert Mustacchi return (ret); 2243bc1f688bSRobert Mustacchi } 2244bc1f688bSRobert Mustacchi 2245bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_string(cup, die, DW_AT_name, &name)) != 0 && 2246bc1f688bSRobert Mustacchi ret != ENOENT) 2247bc1f688bSRobert Mustacchi return (ret); 2248bc1f688bSRobert Mustacchi if (ret == ENOENT) 2249bc1f688bSRobert Mustacchi return (0); 2250bc1f688bSRobert Mustacchi 2251bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_refdie(cup, die, DW_AT_type, &tdie)) != 0) { 2252bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2253bc1f688bSRobert Mustacchi return (ret); 2254bc1f688bSRobert Mustacchi } 2255bc1f688bSRobert Mustacchi 2256bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_convert_type(cup, tdie, &id, 2257bc1f688bSRobert Mustacchi CTF_ADD_ROOT)) != 0) 2258bc1f688bSRobert Mustacchi return (ret); 2259bc1f688bSRobert Mustacchi 2260bc1f688bSRobert Mustacchi if ((cdv = ctf_alloc(sizeof (ctf_dwvar_t))) == NULL) { 2261bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2262bc1f688bSRobert Mustacchi return (ENOMEM); 2263bc1f688bSRobert Mustacchi } 2264bc1f688bSRobert Mustacchi 2265bc1f688bSRobert Mustacchi cdv->cdv_name = name; 2266bc1f688bSRobert Mustacchi cdv->cdv_type = id; 2267bc1f688bSRobert Mustacchi 2268bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_isglobal(cup, die, &cdv->cdv_global)) != 0) { 2269bc1f688bSRobert Mustacchi ctf_free(cdv, sizeof (ctf_dwvar_t)); 2270bc1f688bSRobert Mustacchi ctf_free(name, strlen(name) + 1); 2271bc1f688bSRobert Mustacchi return (ret); 2272bc1f688bSRobert Mustacchi } 2273bc1f688bSRobert Mustacchi 2274bc1f688bSRobert Mustacchi ctf_list_append(&cup->cu_vars, cdv); 2275bc1f688bSRobert Mustacchi return (0); 2276bc1f688bSRobert Mustacchi } 2277bc1f688bSRobert Mustacchi 2278bc1f688bSRobert Mustacchi /* 2279bc1f688bSRobert Mustacchi * Walk through our set of top-level types and process them. 2280bc1f688bSRobert Mustacchi */ 2281bc1f688bSRobert Mustacchi static int 2282bc1f688bSRobert Mustacchi ctf_dwarf_walk_toplevel(ctf_cu_t *cup, Dwarf_Die die) 2283bc1f688bSRobert Mustacchi { 2284bc1f688bSRobert Mustacchi int ret; 2285bc1f688bSRobert Mustacchi Dwarf_Off offset; 2286bc1f688bSRobert Mustacchi Dwarf_Half tag; 2287bc1f688bSRobert Mustacchi 2288bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_offset(cup, die, &offset)) != 0) 2289bc1f688bSRobert Mustacchi return (ret); 2290bc1f688bSRobert Mustacchi 2291bc1f688bSRobert Mustacchi if (offset > cup->cu_maxoff) { 2292bc1f688bSRobert Mustacchi (void) snprintf(cup->cu_errbuf, cup->cu_errlen, 2293bc1f688bSRobert Mustacchi "die offset %llu beyond maximum for header %llu\n", 2294bc1f688bSRobert Mustacchi offset, cup->cu_maxoff); 2295bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 2296bc1f688bSRobert Mustacchi } 2297bc1f688bSRobert Mustacchi 2298bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_tag(cup, die, &tag)) != 0) 2299bc1f688bSRobert Mustacchi return (ret); 2300bc1f688bSRobert Mustacchi 2301bc1f688bSRobert Mustacchi ret = 0; 2302bc1f688bSRobert Mustacchi switch (tag) { 2303bc1f688bSRobert Mustacchi case DW_TAG_subprogram: 2304bc1f688bSRobert Mustacchi ctf_dprintf("top level func\n"); 2305bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_function(cup, die); 2306bc1f688bSRobert Mustacchi break; 2307bc1f688bSRobert Mustacchi case DW_TAG_variable: 2308bc1f688bSRobert Mustacchi ctf_dprintf("top level var\n"); 2309bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_variable(cup, die); 2310bc1f688bSRobert Mustacchi break; 2311bc1f688bSRobert Mustacchi case DW_TAG_lexical_block: 2312bc1f688bSRobert Mustacchi ctf_dprintf("top level block\n"); 2313bc1f688bSRobert Mustacchi ret = ctf_dwarf_walk_lexical(cup, die); 2314bc1f688bSRobert Mustacchi break; 2315bc1f688bSRobert Mustacchi case DW_TAG_enumeration_type: 2316bc1f688bSRobert Mustacchi case DW_TAG_structure_type: 2317bc1f688bSRobert Mustacchi case DW_TAG_typedef: 2318bc1f688bSRobert Mustacchi case DW_TAG_union_type: 2319bc1f688bSRobert Mustacchi ctf_dprintf("top level type\n"); 2320bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_type(cup, die, NULL, B_TRUE); 2321bc1f688bSRobert Mustacchi break; 2322bc1f688bSRobert Mustacchi default: 2323bc1f688bSRobert Mustacchi break; 2324bc1f688bSRobert Mustacchi } 2325bc1f688bSRobert Mustacchi 2326bc1f688bSRobert Mustacchi return (ret); 2327bc1f688bSRobert Mustacchi } 2328bc1f688bSRobert Mustacchi 2329bc1f688bSRobert Mustacchi 2330bc1f688bSRobert Mustacchi /* 2331bc1f688bSRobert Mustacchi * We're given a node. At this node we need to convert it and then proceed to 2332bc1f688bSRobert Mustacchi * convert any siblings that are associaed with this die. 2333bc1f688bSRobert Mustacchi */ 2334bc1f688bSRobert Mustacchi static int 2335bc1f688bSRobert Mustacchi ctf_dwarf_convert_die(ctf_cu_t *cup, Dwarf_Die die) 2336bc1f688bSRobert Mustacchi { 2337bc1f688bSRobert Mustacchi while (die != NULL) { 2338bc1f688bSRobert Mustacchi int ret; 2339bc1f688bSRobert Mustacchi Dwarf_Die sib; 2340bc1f688bSRobert Mustacchi 2341bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_walk_toplevel(cup, die)) != 0) 2342bc1f688bSRobert Mustacchi return (ret); 2343bc1f688bSRobert Mustacchi 2344bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_sib(cup, die, &sib)) != 0) 2345bc1f688bSRobert Mustacchi return (ret); 2346bc1f688bSRobert Mustacchi die = sib; 2347bc1f688bSRobert Mustacchi } 2348bc1f688bSRobert Mustacchi return (0); 2349bc1f688bSRobert Mustacchi } 2350bc1f688bSRobert Mustacchi 2351bc1f688bSRobert Mustacchi static int 2352bc1f688bSRobert Mustacchi ctf_dwarf_fixup_die(ctf_cu_t *cup, boolean_t addpass) 2353bc1f688bSRobert Mustacchi { 2354bc1f688bSRobert Mustacchi ctf_dwmap_t *map; 2355bc1f688bSRobert Mustacchi 2356bc1f688bSRobert Mustacchi for (map = avl_first(&cup->cu_map); map != NULL; 2357bc1f688bSRobert Mustacchi map = AVL_NEXT(&cup->cu_map, map)) { 2358bc1f688bSRobert Mustacchi int ret; 2359bc1f688bSRobert Mustacchi if (map->cdm_fix == B_FALSE) 2360bc1f688bSRobert Mustacchi continue; 2361bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_fixup_sou(cup, map->cdm_die, map->cdm_id, 2362bc1f688bSRobert Mustacchi addpass)) != 0) 2363bc1f688bSRobert Mustacchi return (ret); 2364bc1f688bSRobert Mustacchi } 2365bc1f688bSRobert Mustacchi 2366bc1f688bSRobert Mustacchi return (0); 2367bc1f688bSRobert Mustacchi } 2368bc1f688bSRobert Mustacchi 236937e82d12SRobert Mustacchi /* 237037e82d12SRobert Mustacchi * The DWARF information about a symbol and the information in the symbol table 237137e82d12SRobert Mustacchi * may not be the same due to symbol reduction that is performed by ld due to a 237237e82d12SRobert Mustacchi * mapfile or other such directive. We process weak symbols at a later time. 237337e82d12SRobert Mustacchi * 237437e82d12SRobert Mustacchi * The following are the rules that we employ: 237537e82d12SRobert Mustacchi * 237637e82d12SRobert Mustacchi * 1. A DWARF function that is considered exported matches STB_GLOBAL entries 237737e82d12SRobert Mustacchi * with the same name. 237837e82d12SRobert Mustacchi * 237937e82d12SRobert Mustacchi * 2. A DWARF function that is considered exported matches STB_LOCAL entries 238037e82d12SRobert Mustacchi * with the same name and the same file. This case may happen due to mapfile 238137e82d12SRobert Mustacchi * reduction. 238237e82d12SRobert Mustacchi * 238337e82d12SRobert Mustacchi * 3. A DWARF function that is not considered exported matches STB_LOCAL entries 238437e82d12SRobert Mustacchi * with the same name and the same file. 238537e82d12SRobert Mustacchi * 238637e82d12SRobert Mustacchi * 4. A DWARF function that has the same name as the symbol table entry, but the 238737e82d12SRobert Mustacchi * files do not match. This is considered a 'fuzzy' match. This may also happen 238837e82d12SRobert Mustacchi * due to a mapfile reduction. Fuzzy matching is only used when we know that the 238937e82d12SRobert Mustacchi * file in question refers to the primary object. This is because when a symbol 239037e82d12SRobert Mustacchi * is reduced in a mapfile, it's always going to be tagged as a local value in 239137e82d12SRobert Mustacchi * the generated output and it is considered as to belong to the primary file 239237e82d12SRobert Mustacchi * which is the first STT_FILE symbol we see. 239337e82d12SRobert Mustacchi */ 239437e82d12SRobert Mustacchi static boolean_t 239537e82d12SRobert Mustacchi ctf_dwarf_symbol_match(const char *symtab_file, const char *symtab_name, 239637e82d12SRobert Mustacchi uint_t symtab_bind, const char *dwarf_file, const char *dwarf_name, 239737e82d12SRobert Mustacchi boolean_t dwarf_global, boolean_t *is_fuzzy) 239837e82d12SRobert Mustacchi { 239937e82d12SRobert Mustacchi *is_fuzzy = B_FALSE; 240037e82d12SRobert Mustacchi 240137e82d12SRobert Mustacchi if (symtab_bind != STB_LOCAL && symtab_bind != STB_GLOBAL) { 240237e82d12SRobert Mustacchi return (B_FALSE); 240337e82d12SRobert Mustacchi } 240437e82d12SRobert Mustacchi 240537e82d12SRobert Mustacchi if (strcmp(symtab_name, dwarf_name) != 0) { 240637e82d12SRobert Mustacchi return (B_FALSE); 240737e82d12SRobert Mustacchi } 240837e82d12SRobert Mustacchi 240937e82d12SRobert Mustacchi if (symtab_bind == STB_GLOBAL) { 241037e82d12SRobert Mustacchi return (dwarf_global); 241137e82d12SRobert Mustacchi } 241237e82d12SRobert Mustacchi 241337e82d12SRobert Mustacchi if (strcmp(symtab_file, dwarf_file) == 0) { 241437e82d12SRobert Mustacchi return (B_TRUE); 241537e82d12SRobert Mustacchi } 241637e82d12SRobert Mustacchi 241737e82d12SRobert Mustacchi if (dwarf_global) { 241837e82d12SRobert Mustacchi *is_fuzzy = B_TRUE; 241937e82d12SRobert Mustacchi return (B_TRUE); 242037e82d12SRobert Mustacchi } 242137e82d12SRobert Mustacchi 242237e82d12SRobert Mustacchi return (B_FALSE); 242337e82d12SRobert Mustacchi } 242437e82d12SRobert Mustacchi 2425bc1f688bSRobert Mustacchi static ctf_dwfunc_t * 2426bc1f688bSRobert Mustacchi ctf_dwarf_match_func(ctf_cu_t *cup, const char *file, const char *name, 242737e82d12SRobert Mustacchi uint_t bind, boolean_t primary) 2428bc1f688bSRobert Mustacchi { 242937e82d12SRobert Mustacchi ctf_dwfunc_t *cdf, *fuzzy = NULL; 2430bc1f688bSRobert Mustacchi 2431bc1f688bSRobert Mustacchi if (bind == STB_WEAK) 2432bc1f688bSRobert Mustacchi return (NULL); 2433bc1f688bSRobert Mustacchi 2434bc1f688bSRobert Mustacchi if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL)) 2435bc1f688bSRobert Mustacchi return (NULL); 2436bc1f688bSRobert Mustacchi 2437bc1f688bSRobert Mustacchi for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL; 2438bc1f688bSRobert Mustacchi cdf = ctf_list_next(cdf)) { 243937e82d12SRobert Mustacchi boolean_t is_fuzzy = B_FALSE; 244037e82d12SRobert Mustacchi 244137e82d12SRobert Mustacchi if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name, 244237e82d12SRobert Mustacchi cdf->cdf_name, cdf->cdf_global, &is_fuzzy)) { 244337e82d12SRobert Mustacchi if (is_fuzzy) { 244437e82d12SRobert Mustacchi if (primary) { 244537e82d12SRobert Mustacchi fuzzy = cdf; 244637e82d12SRobert Mustacchi } 244737e82d12SRobert Mustacchi continue; 244837e82d12SRobert Mustacchi } else { 244937e82d12SRobert Mustacchi return (cdf); 245037e82d12SRobert Mustacchi } 245137e82d12SRobert Mustacchi } 2452bc1f688bSRobert Mustacchi } 2453bc1f688bSRobert Mustacchi 245437e82d12SRobert Mustacchi return (fuzzy); 2455bc1f688bSRobert Mustacchi } 245637e82d12SRobert Mustacchi 2457bc1f688bSRobert Mustacchi static ctf_dwvar_t * 2458bc1f688bSRobert Mustacchi ctf_dwarf_match_var(ctf_cu_t *cup, const char *file, const char *name, 245937e82d12SRobert Mustacchi uint_t bind, boolean_t primary) 2460bc1f688bSRobert Mustacchi { 246137e82d12SRobert Mustacchi ctf_dwvar_t *cdv, *fuzzy = NULL; 246237e82d12SRobert Mustacchi 246337e82d12SRobert Mustacchi if (bind == STB_WEAK) 246437e82d12SRobert Mustacchi return (NULL); 2465bc1f688bSRobert Mustacchi 2466bc1f688bSRobert Mustacchi if (bind == STB_LOCAL && (file == NULL || cup->cu_name == NULL)) 2467bc1f688bSRobert Mustacchi return (NULL); 2468bc1f688bSRobert Mustacchi 2469bc1f688bSRobert Mustacchi for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL; 2470bc1f688bSRobert Mustacchi cdv = ctf_list_next(cdv)) { 247137e82d12SRobert Mustacchi boolean_t is_fuzzy = B_FALSE; 247237e82d12SRobert Mustacchi 247337e82d12SRobert Mustacchi if (ctf_dwarf_symbol_match(file, name, bind, cup->cu_name, 247437e82d12SRobert Mustacchi cdv->cdv_name, cdv->cdv_global, &is_fuzzy)) { 247537e82d12SRobert Mustacchi if (is_fuzzy) { 247637e82d12SRobert Mustacchi if (primary) { 247737e82d12SRobert Mustacchi fuzzy = cdv; 247837e82d12SRobert Mustacchi } 247937e82d12SRobert Mustacchi } else { 248037e82d12SRobert Mustacchi return (cdv); 2481bc1f688bSRobert Mustacchi } 2482bc1f688bSRobert Mustacchi } 2483bc1f688bSRobert Mustacchi } 2484bc1f688bSRobert Mustacchi 248537e82d12SRobert Mustacchi return (fuzzy); 2486bc1f688bSRobert Mustacchi } 2487bc1f688bSRobert Mustacchi 2488bc1f688bSRobert Mustacchi static int 248937e82d12SRobert Mustacchi ctf_dwarf_conv_funcvars_cb(const Elf64_Sym *symp, ulong_t idx, 249037e82d12SRobert Mustacchi const char *file, const char *name, boolean_t primary, void *arg) 2491bc1f688bSRobert Mustacchi { 249237e82d12SRobert Mustacchi int ret; 249337e82d12SRobert Mustacchi uint_t bind, type; 249437e82d12SRobert Mustacchi ctf_cu_t *cup = arg; 2495bc1f688bSRobert Mustacchi 2496bc1f688bSRobert Mustacchi bind = GELF_ST_BIND(symp->st_info); 2497bc1f688bSRobert Mustacchi type = GELF_ST_TYPE(symp->st_info); 2498bc1f688bSRobert Mustacchi 2499bc1f688bSRobert Mustacchi /* 2500bc1f688bSRobert Mustacchi * Come back to weak symbols in another pass 2501bc1f688bSRobert Mustacchi */ 2502bc1f688bSRobert Mustacchi if (bind == STB_WEAK) 2503bc1f688bSRobert Mustacchi return (0); 2504bc1f688bSRobert Mustacchi 2505bc1f688bSRobert Mustacchi if (type == STT_OBJECT) { 2506bc1f688bSRobert Mustacchi ctf_dwvar_t *cdv = ctf_dwarf_match_var(cup, file, name, 250737e82d12SRobert Mustacchi bind, primary); 2508bc1f688bSRobert Mustacchi if (cdv == NULL) 2509bc1f688bSRobert Mustacchi return (0); 2510bc1f688bSRobert Mustacchi ret = ctf_add_object(cup->cu_ctfp, idx, cdv->cdv_type); 251137e82d12SRobert Mustacchi ctf_dprintf("added object %s->%ld\n", name, cdv->cdv_type); 2512bc1f688bSRobert Mustacchi } else { 2513bc1f688bSRobert Mustacchi ctf_dwfunc_t *cdf = ctf_dwarf_match_func(cup, file, name, 251437e82d12SRobert Mustacchi bind, primary); 2515bc1f688bSRobert Mustacchi if (cdf == NULL) 2516bc1f688bSRobert Mustacchi return (0); 2517bc1f688bSRobert Mustacchi ret = ctf_add_function(cup->cu_ctfp, idx, &cdf->cdf_fip, 2518bc1f688bSRobert Mustacchi cdf->cdf_argv); 251937e82d12SRobert Mustacchi ctf_dprintf("added function %s\n", name); 2520bc1f688bSRobert Mustacchi } 2521bc1f688bSRobert Mustacchi 2522bc1f688bSRobert Mustacchi if (ret == CTF_ERR) { 2523bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2524bc1f688bSRobert Mustacchi } 2525bc1f688bSRobert Mustacchi 2526bc1f688bSRobert Mustacchi return (0); 2527bc1f688bSRobert Mustacchi } 2528bc1f688bSRobert Mustacchi 2529bc1f688bSRobert Mustacchi static int 2530bc1f688bSRobert Mustacchi ctf_dwarf_conv_funcvars(ctf_cu_t *cup) 2531bc1f688bSRobert Mustacchi { 253237e82d12SRobert Mustacchi return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_funcvars_cb, cup)); 2533bc1f688bSRobert Mustacchi } 2534bc1f688bSRobert Mustacchi 2535bc1f688bSRobert Mustacchi /* 2536bc1f688bSRobert Mustacchi * If we have a weak symbol, attempt to find the strong symbol it will resolve 2537bc1f688bSRobert Mustacchi * to. Note: the code where this actually happens is in sym_process() in 2538bc1f688bSRobert Mustacchi * cmd/sgs/libld/common/syms.c 2539bc1f688bSRobert Mustacchi * 2540bc1f688bSRobert Mustacchi * Finding the matching symbol is unfortunately not trivial. For a symbol to be 2541bc1f688bSRobert Mustacchi * a candidate, it must: 2542bc1f688bSRobert Mustacchi * 2543bc1f688bSRobert Mustacchi * - have the same type (function, object) 2544bc1f688bSRobert Mustacchi * - have the same value (address) 2545bc1f688bSRobert Mustacchi * - have the same size 2546bc1f688bSRobert Mustacchi * - not be another weak symbol 2547bc1f688bSRobert Mustacchi * - belong to the same section (checked via section index) 2548bc1f688bSRobert Mustacchi * 2549bc1f688bSRobert Mustacchi * To perform this check, we first iterate over the symbol table. For each weak 2550bc1f688bSRobert Mustacchi * symbol that we encounter, we then do a second walk over the symbol table, 2551bc1f688bSRobert Mustacchi * calling ctf_dwarf_conv_check_weak(). If a symbol matches the above, then it's 2552bc1f688bSRobert Mustacchi * either a local or global symbol. If we find a global symbol then we go with 2553bc1f688bSRobert Mustacchi * it and stop searching for additional matches. 2554bc1f688bSRobert Mustacchi * 2555bc1f688bSRobert Mustacchi * If instead, we find a local symbol, things are more complicated. The first 2556bc1f688bSRobert Mustacchi * thing we do is to try and see if we have file information about both symbols 2557bc1f688bSRobert Mustacchi * (STT_FILE). If they both have file information and it matches, then we treat 2558bc1f688bSRobert Mustacchi * that as a good match and stop searching for additional matches. 2559bc1f688bSRobert Mustacchi * 2560bc1f688bSRobert Mustacchi * Otherwise, this means we have a non-matching file and a local symbol. We 2561bc1f688bSRobert Mustacchi * treat this as a candidate and if we find a better match (one of the two cases 2562bc1f688bSRobert Mustacchi * above), use that instead. There are two different ways this can happen. 2563bc1f688bSRobert Mustacchi * Either this is a completely different symbol, or it's a once-global symbol 2564bc1f688bSRobert Mustacchi * that was scoped to local via a mapfile. In the former case, curfile is 2565bc1f688bSRobert Mustacchi * likely inaccurate since the linker does not preserve the needed curfile in 2566bc1f688bSRobert Mustacchi * the order of the symbol table (see the comments about locally scoped symbols 2567bc1f688bSRobert Mustacchi * in libld's update_osym()). As we can't tell this case from the former one, 2568bc1f688bSRobert Mustacchi * we use this symbol iff no other matching symbol is found. 2569bc1f688bSRobert Mustacchi * 2570bc1f688bSRobert Mustacchi * What we really need here is a SUNW section containing weak<->strong mappings 2571bc1f688bSRobert Mustacchi * that we can consume. 2572bc1f688bSRobert Mustacchi */ 2573bc1f688bSRobert Mustacchi typedef struct ctf_dwarf_weak_arg { 257437e82d12SRobert Mustacchi const Elf64_Sym *cweak_symp; 2575bc1f688bSRobert Mustacchi const char *cweak_file; 2576bc1f688bSRobert Mustacchi boolean_t cweak_candidate; 2577bc1f688bSRobert Mustacchi ulong_t cweak_idx; 2578bc1f688bSRobert Mustacchi } ctf_dwarf_weak_arg_t; 2579bc1f688bSRobert Mustacchi 2580bc1f688bSRobert Mustacchi static int 258137e82d12SRobert Mustacchi ctf_dwarf_conv_check_weak(const Elf64_Sym *symp, ulong_t idx, const char *file, 258237e82d12SRobert Mustacchi const char *name, boolean_t primary, void *arg) 2583bc1f688bSRobert Mustacchi { 2584bc1f688bSRobert Mustacchi ctf_dwarf_weak_arg_t *cweak = arg; 258537e82d12SRobert Mustacchi 258637e82d12SRobert Mustacchi const Elf64_Sym *wsymp = cweak->cweak_symp; 2587bc1f688bSRobert Mustacchi 2588bc1f688bSRobert Mustacchi ctf_dprintf("comparing weak to %s\n", name); 2589bc1f688bSRobert Mustacchi 2590bc1f688bSRobert Mustacchi if (GELF_ST_BIND(symp->st_info) == STB_WEAK) { 2591bc1f688bSRobert Mustacchi return (0); 2592bc1f688bSRobert Mustacchi } 2593bc1f688bSRobert Mustacchi 2594bc1f688bSRobert Mustacchi if (GELF_ST_TYPE(wsymp->st_info) != GELF_ST_TYPE(symp->st_info)) { 2595bc1f688bSRobert Mustacchi return (0); 2596bc1f688bSRobert Mustacchi } 2597bc1f688bSRobert Mustacchi 2598bc1f688bSRobert Mustacchi if (wsymp->st_value != symp->st_value) { 2599bc1f688bSRobert Mustacchi return (0); 2600bc1f688bSRobert Mustacchi } 2601bc1f688bSRobert Mustacchi 2602bc1f688bSRobert Mustacchi if (wsymp->st_size != symp->st_size) { 2603bc1f688bSRobert Mustacchi return (0); 2604bc1f688bSRobert Mustacchi } 2605bc1f688bSRobert Mustacchi 2606bc1f688bSRobert Mustacchi if (wsymp->st_shndx != symp->st_shndx) { 2607bc1f688bSRobert Mustacchi return (0); 2608bc1f688bSRobert Mustacchi } 2609bc1f688bSRobert Mustacchi 2610bc1f688bSRobert Mustacchi /* 2611bc1f688bSRobert Mustacchi * Check if it's a weak candidate. 2612bc1f688bSRobert Mustacchi */ 2613bc1f688bSRobert Mustacchi if (GELF_ST_BIND(symp->st_info) == STB_LOCAL && 2614bc1f688bSRobert Mustacchi (file == NULL || cweak->cweak_file == NULL || 2615bc1f688bSRobert Mustacchi strcmp(file, cweak->cweak_file) != 0)) { 2616bc1f688bSRobert Mustacchi cweak->cweak_candidate = B_TRUE; 2617bc1f688bSRobert Mustacchi cweak->cweak_idx = idx; 2618bc1f688bSRobert Mustacchi return (0); 2619bc1f688bSRobert Mustacchi } 2620bc1f688bSRobert Mustacchi 2621bc1f688bSRobert Mustacchi /* 2622bc1f688bSRobert Mustacchi * Found a match, break. 2623bc1f688bSRobert Mustacchi */ 2624bc1f688bSRobert Mustacchi cweak->cweak_idx = idx; 2625bc1f688bSRobert Mustacchi return (1); 2626bc1f688bSRobert Mustacchi } 2627bc1f688bSRobert Mustacchi 2628bc1f688bSRobert Mustacchi static int 2629bc1f688bSRobert Mustacchi ctf_dwarf_duplicate_sym(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx) 2630bc1f688bSRobert Mustacchi { 2631bc1f688bSRobert Mustacchi ctf_id_t id = ctf_lookup_by_symbol(cup->cu_ctfp, matchidx); 2632bc1f688bSRobert Mustacchi 2633bc1f688bSRobert Mustacchi /* 2634bc1f688bSRobert Mustacchi * If we matched something that for some reason didn't have type data, 2635bc1f688bSRobert Mustacchi * we don't consider that a fatal error and silently swallow it. 2636bc1f688bSRobert Mustacchi */ 2637bc1f688bSRobert Mustacchi if (id == CTF_ERR) { 2638bc1f688bSRobert Mustacchi if (ctf_errno(cup->cu_ctfp) == ECTF_NOTYPEDAT) 2639bc1f688bSRobert Mustacchi return (0); 2640bc1f688bSRobert Mustacchi else 2641bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2642bc1f688bSRobert Mustacchi } 2643bc1f688bSRobert Mustacchi 2644bc1f688bSRobert Mustacchi if (ctf_add_object(cup->cu_ctfp, idx, id) == CTF_ERR) 2645bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2646bc1f688bSRobert Mustacchi 2647bc1f688bSRobert Mustacchi return (0); 2648bc1f688bSRobert Mustacchi } 2649bc1f688bSRobert Mustacchi 2650bc1f688bSRobert Mustacchi static int 2651bc1f688bSRobert Mustacchi ctf_dwarf_duplicate_func(ctf_cu_t *cup, ulong_t idx, ulong_t matchidx) 2652bc1f688bSRobert Mustacchi { 2653bc1f688bSRobert Mustacchi int ret; 2654bc1f688bSRobert Mustacchi ctf_funcinfo_t fip; 2655bc1f688bSRobert Mustacchi ctf_id_t *args = NULL; 2656bc1f688bSRobert Mustacchi 2657bc1f688bSRobert Mustacchi if (ctf_func_info(cup->cu_ctfp, matchidx, &fip) == CTF_ERR) { 2658bc1f688bSRobert Mustacchi if (ctf_errno(cup->cu_ctfp) == ECTF_NOFUNCDAT) 2659bc1f688bSRobert Mustacchi return (0); 2660bc1f688bSRobert Mustacchi else 2661bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2662bc1f688bSRobert Mustacchi } 2663bc1f688bSRobert Mustacchi 2664bc1f688bSRobert Mustacchi if (fip.ctc_argc != 0) { 2665bc1f688bSRobert Mustacchi args = ctf_alloc(sizeof (ctf_id_t) * fip.ctc_argc); 2666bc1f688bSRobert Mustacchi if (args == NULL) 2667bc1f688bSRobert Mustacchi return (ENOMEM); 2668bc1f688bSRobert Mustacchi 2669bc1f688bSRobert Mustacchi if (ctf_func_args(cup->cu_ctfp, matchidx, fip.ctc_argc, args) == 2670bc1f688bSRobert Mustacchi CTF_ERR) { 2671bc1f688bSRobert Mustacchi ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc); 2672bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2673bc1f688bSRobert Mustacchi } 2674bc1f688bSRobert Mustacchi } 2675bc1f688bSRobert Mustacchi 2676bc1f688bSRobert Mustacchi ret = ctf_add_function(cup->cu_ctfp, idx, &fip, args); 2677bc1f688bSRobert Mustacchi if (args != NULL) 2678bc1f688bSRobert Mustacchi ctf_free(args, sizeof (ctf_id_t) * fip.ctc_argc); 2679bc1f688bSRobert Mustacchi if (ret == CTF_ERR) 2680bc1f688bSRobert Mustacchi return (ctf_errno(cup->cu_ctfp)); 2681bc1f688bSRobert Mustacchi 2682bc1f688bSRobert Mustacchi return (0); 2683bc1f688bSRobert Mustacchi } 2684bc1f688bSRobert Mustacchi 2685bc1f688bSRobert Mustacchi static int 268637e82d12SRobert Mustacchi ctf_dwarf_conv_weaks_cb(const Elf64_Sym *symp, ulong_t idx, const char *file, 268737e82d12SRobert Mustacchi const char *name, boolean_t primary, void *arg) 2688bc1f688bSRobert Mustacchi { 2689bc1f688bSRobert Mustacchi int ret, type; 2690bc1f688bSRobert Mustacchi ctf_dwarf_weak_arg_t cweak; 269137e82d12SRobert Mustacchi ctf_cu_t *cup = arg; 2692bc1f688bSRobert Mustacchi 2693bc1f688bSRobert Mustacchi /* 2694bc1f688bSRobert Mustacchi * We only care about weak symbols. 2695bc1f688bSRobert Mustacchi */ 2696bc1f688bSRobert Mustacchi if (GELF_ST_BIND(symp->st_info) != STB_WEAK) 2697bc1f688bSRobert Mustacchi return (0); 2698bc1f688bSRobert Mustacchi 2699bc1f688bSRobert Mustacchi type = GELF_ST_TYPE(symp->st_info); 2700bc1f688bSRobert Mustacchi ASSERT(type == STT_OBJECT || type == STT_FUNC); 2701bc1f688bSRobert Mustacchi 2702bc1f688bSRobert Mustacchi /* 2703bc1f688bSRobert Mustacchi * For each weak symbol we encounter, we need to do a second iteration 2704bc1f688bSRobert Mustacchi * to try and find a match. We should probably think about other 2705bc1f688bSRobert Mustacchi * techniques to try and save us time in the future. 2706bc1f688bSRobert Mustacchi */ 2707bc1f688bSRobert Mustacchi cweak.cweak_symp = symp; 2708bc1f688bSRobert Mustacchi cweak.cweak_file = file; 2709bc1f688bSRobert Mustacchi cweak.cweak_candidate = B_FALSE; 2710bc1f688bSRobert Mustacchi cweak.cweak_idx = 0; 2711bc1f688bSRobert Mustacchi 2712bc1f688bSRobert Mustacchi ctf_dprintf("Trying to find weak equiv for %s\n", name); 2713bc1f688bSRobert Mustacchi 271437e82d12SRobert Mustacchi ret = ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_check_weak, &cweak); 2715bc1f688bSRobert Mustacchi VERIFY(ret == 0 || ret == 1); 2716bc1f688bSRobert Mustacchi 2717bc1f688bSRobert Mustacchi /* 2718bc1f688bSRobert Mustacchi * Nothing was ever found, we're not going to add anything for this 2719bc1f688bSRobert Mustacchi * entry. 2720bc1f688bSRobert Mustacchi */ 2721bc1f688bSRobert Mustacchi if (ret == 0 && cweak.cweak_candidate == B_FALSE) { 2722bc1f688bSRobert Mustacchi ctf_dprintf("found no weak match for %s\n", name); 2723bc1f688bSRobert Mustacchi return (0); 2724bc1f688bSRobert Mustacchi } 2725bc1f688bSRobert Mustacchi 2726bc1f688bSRobert Mustacchi /* 2727bc1f688bSRobert Mustacchi * Now, finally go and add the type based on the match. 2728bc1f688bSRobert Mustacchi */ 272937e82d12SRobert Mustacchi ctf_dprintf("matched weak symbol %lu to %lu\n", idx, cweak.cweak_idx); 2730bc1f688bSRobert Mustacchi if (type == STT_OBJECT) { 2731bc1f688bSRobert Mustacchi ret = ctf_dwarf_duplicate_sym(cup, idx, cweak.cweak_idx); 2732bc1f688bSRobert Mustacchi } else { 2733bc1f688bSRobert Mustacchi ret = ctf_dwarf_duplicate_func(cup, idx, cweak.cweak_idx); 2734bc1f688bSRobert Mustacchi } 2735bc1f688bSRobert Mustacchi 2736bc1f688bSRobert Mustacchi return (ret); 2737bc1f688bSRobert Mustacchi } 2738bc1f688bSRobert Mustacchi 2739bc1f688bSRobert Mustacchi static int 2740bc1f688bSRobert Mustacchi ctf_dwarf_conv_weaks(ctf_cu_t *cup) 2741bc1f688bSRobert Mustacchi { 274237e82d12SRobert Mustacchi return (ctf_symtab_iter(cup->cu_ctfp, ctf_dwarf_conv_weaks_cb, cup)); 2743bc1f688bSRobert Mustacchi } 2744bc1f688bSRobert Mustacchi 2745bc1f688bSRobert Mustacchi /* ARGSUSED */ 2746bc1f688bSRobert Mustacchi static int 2747bc1f688bSRobert Mustacchi ctf_dwarf_convert_one(void *arg, void *unused) 2748bc1f688bSRobert Mustacchi { 2749bc1f688bSRobert Mustacchi int ret; 2750bc1f688bSRobert Mustacchi ctf_file_t *dedup; 2751bc1f688bSRobert Mustacchi ctf_cu_t *cup = arg; 2752bc1f688bSRobert Mustacchi 2753bc1f688bSRobert Mustacchi ctf_dprintf("converting die: %s\n", cup->cu_name); 2754bc1f688bSRobert Mustacchi ctf_dprintf("max offset: %x\n", cup->cu_maxoff); 2755bc1f688bSRobert Mustacchi VERIFY(cup != NULL); 2756bc1f688bSRobert Mustacchi 2757bc1f688bSRobert Mustacchi ret = ctf_dwarf_convert_die(cup, cup->cu_cu); 2758bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_convert_die (%s) returned %d\n", cup->cu_name, 2759bc1f688bSRobert Mustacchi ret); 2760bc1f688bSRobert Mustacchi if (ret != 0) { 2761bc1f688bSRobert Mustacchi return (ret); 2762bc1f688bSRobert Mustacchi } 2763bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2764bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2765bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2766bc1f688bSRobert Mustacchi } 2767bc1f688bSRobert Mustacchi 2768bc1f688bSRobert Mustacchi ret = ctf_dwarf_fixup_die(cup, B_FALSE); 2769bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name, 2770bc1f688bSRobert Mustacchi ret); 2771bc1f688bSRobert Mustacchi if (ret != 0) { 2772bc1f688bSRobert Mustacchi return (ret); 2773bc1f688bSRobert Mustacchi } 2774bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2775bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2776bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2777bc1f688bSRobert Mustacchi } 2778bc1f688bSRobert Mustacchi 2779bc1f688bSRobert Mustacchi ret = ctf_dwarf_fixup_die(cup, B_TRUE); 2780bc1f688bSRobert Mustacchi ctf_dprintf("ctf_dwarf_fixup_die (%s) returned %d\n", cup->cu_name, 2781bc1f688bSRobert Mustacchi ret); 2782bc1f688bSRobert Mustacchi if (ret != 0) { 2783bc1f688bSRobert Mustacchi return (ret); 2784bc1f688bSRobert Mustacchi } 2785bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2786bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2787bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2788bc1f688bSRobert Mustacchi } 2789bc1f688bSRobert Mustacchi 2790bc1f688bSRobert Mustacchi 2791bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_conv_funcvars(cup)) != 0) { 2792bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2793bc1f688bSRobert Mustacchi "failed to convert strong functions and variables")); 2794bc1f688bSRobert Mustacchi } 2795bc1f688bSRobert Mustacchi 2796bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2797bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2798bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2799bc1f688bSRobert Mustacchi } 2800bc1f688bSRobert Mustacchi 2801bc1f688bSRobert Mustacchi if (cup->cu_doweaks == B_TRUE) { 2802bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_conv_weaks(cup)) != 0) { 2803bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2804bc1f688bSRobert Mustacchi "failed to convert weak functions and variables")); 2805bc1f688bSRobert Mustacchi } 2806bc1f688bSRobert Mustacchi 2807bc1f688bSRobert Mustacchi if (ctf_update(cup->cu_ctfp) != 0) { 2808bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, cup->cu_ctfp, 0, 2809bc1f688bSRobert Mustacchi "failed to update output ctf container")); 2810bc1f688bSRobert Mustacchi } 2811bc1f688bSRobert Mustacchi } 2812bc1f688bSRobert Mustacchi 281337e82d12SRobert Mustacchi ctf_phase_dump(cup->cu_ctfp, "pre-dwarf-dedup", cup->cu_name); 2814bc1f688bSRobert Mustacchi ctf_dprintf("adding inputs for dedup\n"); 2815bc1f688bSRobert Mustacchi if ((ret = ctf_merge_add(cup->cu_cmh, cup->cu_ctfp)) != 0) { 2816bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2817bc1f688bSRobert Mustacchi "failed to add inputs for merge")); 2818bc1f688bSRobert Mustacchi } 2819bc1f688bSRobert Mustacchi 282037e82d12SRobert Mustacchi ctf_dprintf("starting dedup of %s\n", cup->cu_name); 2821bc1f688bSRobert Mustacchi if ((ret = ctf_merge_dedup(cup->cu_cmh, &dedup)) != 0) { 2822bc1f688bSRobert Mustacchi return (ctf_dwarf_error(cup, NULL, ret, 2823bc1f688bSRobert Mustacchi "failed to deduplicate die")); 2824bc1f688bSRobert Mustacchi } 2825bc1f688bSRobert Mustacchi ctf_close(cup->cu_ctfp); 2826bc1f688bSRobert Mustacchi cup->cu_ctfp = dedup; 282737e82d12SRobert Mustacchi ctf_phase_dump(cup->cu_ctfp, "post-dwarf-dedup", cup->cu_name); 2828bc1f688bSRobert Mustacchi 2829bc1f688bSRobert Mustacchi return (0); 2830bc1f688bSRobert Mustacchi } 2831bc1f688bSRobert Mustacchi 2832bc1f688bSRobert Mustacchi /* 2833bc1f688bSRobert Mustacchi * Note, we expect that if we're returning a ctf_file_t from one of the dies, 2834bc1f688bSRobert Mustacchi * say in the single node case, it's been saved and the entry here has been set 2835bc1f688bSRobert Mustacchi * to NULL, which ctf_close happily ignores. 2836bc1f688bSRobert Mustacchi */ 2837bc1f688bSRobert Mustacchi static void 2838bc1f688bSRobert Mustacchi ctf_dwarf_free_die(ctf_cu_t *cup) 2839bc1f688bSRobert Mustacchi { 2840bc1f688bSRobert Mustacchi ctf_dwfunc_t *cdf, *ndf; 2841bc1f688bSRobert Mustacchi ctf_dwvar_t *cdv, *ndv; 2842bc1f688bSRobert Mustacchi ctf_dwbitf_t *cdb, *ndb; 2843bc1f688bSRobert Mustacchi ctf_dwmap_t *map; 2844bc1f688bSRobert Mustacchi void *cookie; 2845bc1f688bSRobert Mustacchi Dwarf_Error derr; 2846bc1f688bSRobert Mustacchi 2847bc1f688bSRobert Mustacchi ctf_dprintf("Beginning to free die: %p\n", cup); 2848bc1f688bSRobert Mustacchi cup->cu_elf = NULL; 2849bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free name: %p\n", cup->cu_name); 2850bc1f688bSRobert Mustacchi if (cup->cu_name != NULL) 2851bc1f688bSRobert Mustacchi ctf_free(cup->cu_name, strlen(cup->cu_name) + 1); 2852bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free merge handle: %p\n", cup->cu_cmh); 2853bc1f688bSRobert Mustacchi if (cup->cu_cmh != NULL) { 2854bc1f688bSRobert Mustacchi ctf_merge_fini(cup->cu_cmh); 2855bc1f688bSRobert Mustacchi cup->cu_cmh = NULL; 2856bc1f688bSRobert Mustacchi } 2857bc1f688bSRobert Mustacchi 2858bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free functions\n"); 2859bc1f688bSRobert Mustacchi for (cdf = ctf_list_next(&cup->cu_funcs); cdf != NULL; cdf = ndf) { 2860bc1f688bSRobert Mustacchi ndf = ctf_list_next(cdf); 2861bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_name, strlen(cdf->cdf_name) + 1); 2862bc1f688bSRobert Mustacchi if (cdf->cdf_fip.ctc_argc != 0) { 2863bc1f688bSRobert Mustacchi ctf_free(cdf->cdf_argv, 2864bc1f688bSRobert Mustacchi sizeof (ctf_id_t) * cdf->cdf_fip.ctc_argc); 2865bc1f688bSRobert Mustacchi } 2866bc1f688bSRobert Mustacchi ctf_free(cdf, sizeof (ctf_dwfunc_t)); 2867bc1f688bSRobert Mustacchi } 2868bc1f688bSRobert Mustacchi 2869bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free variables\n"); 2870bc1f688bSRobert Mustacchi for (cdv = ctf_list_next(&cup->cu_vars); cdv != NULL; cdv = ndv) { 2871bc1f688bSRobert Mustacchi ndv = ctf_list_next(cdv); 2872bc1f688bSRobert Mustacchi ctf_free(cdv->cdv_name, strlen(cdv->cdv_name) + 1); 2873bc1f688bSRobert Mustacchi ctf_free(cdv, sizeof (ctf_dwvar_t)); 2874bc1f688bSRobert Mustacchi } 2875bc1f688bSRobert Mustacchi 2876bc1f688bSRobert Mustacchi ctf_dprintf("Trying to free bitfields\n"); 2877bc1f688bSRobert Mustacchi for (cdb = ctf_list_next(&cup->cu_bitfields); cdb != NULL; cdb = ndb) { 2878bc1f688bSRobert Mustacchi ndb = ctf_list_next(cdb); 2879bc1f688bSRobert Mustacchi ctf_free(cdb, sizeof (ctf_dwbitf_t)); 2880bc1f688bSRobert Mustacchi } 2881bc1f688bSRobert Mustacchi 2882bc1f688bSRobert Mustacchi ctf_dprintf("Trying to clean up dwarf_t: %p\n", cup->cu_dwarf); 28833eca6103SJohn Levon if (cup->cu_dwarf != NULL) 28843eca6103SJohn Levon (void) dwarf_finish(cup->cu_dwarf, &derr); 2885bc1f688bSRobert Mustacchi cup->cu_dwarf = NULL; 2886bc1f688bSRobert Mustacchi ctf_close(cup->cu_ctfp); 2887bc1f688bSRobert Mustacchi 2888bc1f688bSRobert Mustacchi cookie = NULL; 2889bc1f688bSRobert Mustacchi while ((map = avl_destroy_nodes(&cup->cu_map, &cookie)) != NULL) { 2890bc1f688bSRobert Mustacchi ctf_free(map, sizeof (ctf_dwmap_t)); 2891bc1f688bSRobert Mustacchi } 2892bc1f688bSRobert Mustacchi avl_destroy(&cup->cu_map); 2893bc1f688bSRobert Mustacchi cup->cu_errbuf = NULL; 2894bc1f688bSRobert Mustacchi } 2895bc1f688bSRobert Mustacchi 2896bc1f688bSRobert Mustacchi static void 2897bc1f688bSRobert Mustacchi ctf_dwarf_free_dies(ctf_cu_t *cdies, int ndies) 2898bc1f688bSRobert Mustacchi { 2899bc1f688bSRobert Mustacchi int i; 2900bc1f688bSRobert Mustacchi 2901bc1f688bSRobert Mustacchi ctf_dprintf("Beginning to free dies\n"); 2902bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 2903bc1f688bSRobert Mustacchi ctf_dwarf_free_die(&cdies[i]); 2904bc1f688bSRobert Mustacchi } 2905bc1f688bSRobert Mustacchi 2906bc1f688bSRobert Mustacchi ctf_free(cdies, sizeof (ctf_cu_t) * ndies); 2907bc1f688bSRobert Mustacchi } 2908bc1f688bSRobert Mustacchi 2909bc1f688bSRobert Mustacchi static int 2910bc1f688bSRobert Mustacchi ctf_dwarf_count_dies(Dwarf_Debug dw, Dwarf_Error *derr, int *ndies, 2911bc1f688bSRobert Mustacchi char *errbuf, size_t errlen) 2912bc1f688bSRobert Mustacchi { 2913bc1f688bSRobert Mustacchi int ret; 2914bc1f688bSRobert Mustacchi Dwarf_Half vers; 2915bc1f688bSRobert Mustacchi Dwarf_Unsigned nexthdr; 2916bc1f688bSRobert Mustacchi 2917bc1f688bSRobert Mustacchi while ((ret = dwarf_next_cu_header(dw, NULL, &vers, NULL, NULL, 2918bc1f688bSRobert Mustacchi &nexthdr, derr)) != DW_DLV_NO_ENTRY) { 2919bc1f688bSRobert Mustacchi if (ret != DW_DLV_OK) { 2920bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 2921bc1f688bSRobert Mustacchi "file does not contain valid DWARF data: %s\n", 2922bc1f688bSRobert Mustacchi dwarf_errmsg(*derr)); 2923bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 2924bc1f688bSRobert Mustacchi } 2925bc1f688bSRobert Mustacchi 2926bc1f688bSRobert Mustacchi if (vers != DWARF_VERSION_TWO) { 2927bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 2928bc1f688bSRobert Mustacchi "unsupported DWARF version: %d\n", vers); 2929bc1f688bSRobert Mustacchi return (ECTF_CONVBKERR); 2930bc1f688bSRobert Mustacchi } 2931bc1f688bSRobert Mustacchi *ndies = *ndies + 1; 2932bc1f688bSRobert Mustacchi } 2933bc1f688bSRobert Mustacchi 2934bc1f688bSRobert Mustacchi return (0); 2935bc1f688bSRobert Mustacchi } 2936bc1f688bSRobert Mustacchi 2937bc1f688bSRobert Mustacchi static int 2938bc1f688bSRobert Mustacchi ctf_dwarf_init_die(int fd, Elf *elf, ctf_cu_t *cup, int ndie, char *errbuf, 2939bc1f688bSRobert Mustacchi size_t errlen) 2940bc1f688bSRobert Mustacchi { 2941bc1f688bSRobert Mustacchi int ret; 2942bc1f688bSRobert Mustacchi Dwarf_Unsigned hdrlen, abboff, nexthdr; 2943bc1f688bSRobert Mustacchi Dwarf_Half addrsz; 2944bc1f688bSRobert Mustacchi Dwarf_Unsigned offset = 0; 2945bc1f688bSRobert Mustacchi Dwarf_Error derr; 2946bc1f688bSRobert Mustacchi 2947bc1f688bSRobert Mustacchi while ((ret = dwarf_next_cu_header(cup->cu_dwarf, &hdrlen, NULL, 2948bc1f688bSRobert Mustacchi &abboff, &addrsz, &nexthdr, &derr)) != DW_DLV_NO_ENTRY) { 2949bc1f688bSRobert Mustacchi char *name; 2950bc1f688bSRobert Mustacchi Dwarf_Die cu, child; 2951bc1f688bSRobert Mustacchi 2952bc1f688bSRobert Mustacchi /* Based on the counting above, we should be good to go */ 2953bc1f688bSRobert Mustacchi VERIFY(ret == DW_DLV_OK); 2954bc1f688bSRobert Mustacchi if (ndie > 0) { 2955bc1f688bSRobert Mustacchi ndie--; 2956bc1f688bSRobert Mustacchi offset = nexthdr; 2957bc1f688bSRobert Mustacchi continue; 2958bc1f688bSRobert Mustacchi } 2959bc1f688bSRobert Mustacchi 2960bc1f688bSRobert Mustacchi /* 2961bc1f688bSRobert Mustacchi * Compilers are apparently inconsistent. Some emit no DWARF for 2962bc1f688bSRobert Mustacchi * empty files and others emit empty compilation unit. 2963bc1f688bSRobert Mustacchi */ 2964bc1f688bSRobert Mustacchi cup->cu_voidtid = CTF_ERR; 2965bc1f688bSRobert Mustacchi cup->cu_longtid = CTF_ERR; 2966bc1f688bSRobert Mustacchi cup->cu_elf = elf; 2967bc1f688bSRobert Mustacchi cup->cu_maxoff = nexthdr - 1; 2968bc1f688bSRobert Mustacchi cup->cu_ctfp = ctf_fdcreate(fd, &ret); 29693eca6103SJohn Levon if (cup->cu_ctfp == NULL) 2970bc1f688bSRobert Mustacchi return (ret); 29713eca6103SJohn Levon 2972bc1f688bSRobert Mustacchi avl_create(&cup->cu_map, ctf_dwmap_comp, sizeof (ctf_dwmap_t), 2973bc1f688bSRobert Mustacchi offsetof(ctf_dwmap_t, cdm_avl)); 2974bc1f688bSRobert Mustacchi cup->cu_errbuf = errbuf; 2975bc1f688bSRobert Mustacchi cup->cu_errlen = errlen; 2976bc1f688bSRobert Mustacchi bzero(&cup->cu_vars, sizeof (ctf_list_t)); 2977bc1f688bSRobert Mustacchi bzero(&cup->cu_funcs, sizeof (ctf_list_t)); 2978bc1f688bSRobert Mustacchi bzero(&cup->cu_bitfields, sizeof (ctf_list_t)); 2979bc1f688bSRobert Mustacchi 2980bc1f688bSRobert Mustacchi if ((ret = ctf_dwarf_die_elfenc(elf, cup, errbuf, 29813eca6103SJohn Levon errlen)) != 0) 2982bc1f688bSRobert Mustacchi return (ret); 2983bc1f688bSRobert Mustacchi 29843eca6103SJohn Levon if ((ret = ctf_dwarf_sib(cup, NULL, &cu)) != 0) 2985bc1f688bSRobert Mustacchi return (ret); 29863eca6103SJohn Levon 2987bc1f688bSRobert Mustacchi if (cu == NULL) { 2988bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 29893eca6103SJohn Levon "file does not contain DWARF data"); 29903eca6103SJohn Levon return (ECTF_CONVNODEBUG); 2991bc1f688bSRobert Mustacchi } 2992bc1f688bSRobert Mustacchi 29933eca6103SJohn Levon if ((ret = ctf_dwarf_child(cup, cu, &child)) != 0) 2994bc1f688bSRobert Mustacchi return (ret); 29953eca6103SJohn Levon 2996bc1f688bSRobert Mustacchi if (child == NULL) { 2997bc1f688bSRobert Mustacchi (void) snprintf(errbuf, errlen, 29983eca6103SJohn Levon "file does not contain DWARF data"); 29993eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3000bc1f688bSRobert Mustacchi } 3001bc1f688bSRobert Mustacchi 3002bc1f688bSRobert Mustacchi cup->cu_cuoff = offset; 3003bc1f688bSRobert Mustacchi cup->cu_cu = child; 3004bc1f688bSRobert Mustacchi 30053eca6103SJohn Levon if ((cup->cu_cmh = ctf_merge_init(fd, &ret)) == NULL) 3006bc1f688bSRobert Mustacchi return (ret); 3007bc1f688bSRobert Mustacchi 3008bc1f688bSRobert Mustacchi if (ctf_dwarf_string(cup, cu, DW_AT_name, &name) == 0) { 3009bc1f688bSRobert Mustacchi size_t len = strlen(name) + 1; 3010bc1f688bSRobert Mustacchi char *b = basename(name); 3011bc1f688bSRobert Mustacchi cup->cu_name = strdup(b); 3012bc1f688bSRobert Mustacchi ctf_free(name, len); 3013bc1f688bSRobert Mustacchi } 3014bc1f688bSRobert Mustacchi break; 3015bc1f688bSRobert Mustacchi } 3016bc1f688bSRobert Mustacchi 3017bc1f688bSRobert Mustacchi return (0); 3018bc1f688bSRobert Mustacchi } 3019bc1f688bSRobert Mustacchi 30203eca6103SJohn Levon /* 30213eca6103SJohn Levon * This is our only recourse to identify a C source file that is missing debug 30223eca6103SJohn Levon * info: it will be mentioned as an STT_FILE, but not have a compile unit entry. 30233eca6103SJohn Levon * (A traditional ctfmerge works on individual files, so can identify missing 30243eca6103SJohn Levon * DWARF more directly, via ctf_has_c_source() on the .o file.) 30253eca6103SJohn Levon * 30263eca6103SJohn Levon * As we operate on basenames, this can of course miss some cases, but it's 30273eca6103SJohn Levon * better than not checking at all. 30283eca6103SJohn Levon * 30293eca6103SJohn Levon * We explicitly whitelist some CRT components. Failing that, there's always 30303eca6103SJohn Levon * the -m option. 30313eca6103SJohn Levon */ 30323eca6103SJohn Levon static boolean_t 30333eca6103SJohn Levon c_source_has_debug(const char *file, ctf_cu_t *cus, size_t nr_cus) 30343eca6103SJohn Levon { 30353eca6103SJohn Levon const char *basename = strrchr(file, '/'); 30363eca6103SJohn Levon 30373eca6103SJohn Levon if (basename == NULL) 30383eca6103SJohn Levon basename = file; 30393eca6103SJohn Levon else 30403eca6103SJohn Levon basename++; 30413eca6103SJohn Levon 30423eca6103SJohn Levon if (strcmp(basename, "common-crt.c") == 0 || 30433eca6103SJohn Levon strcmp(basename, "gmon.c") == 0 || 30443eca6103SJohn Levon strcmp(basename, "dlink_init.c") == 0 || 30453eca6103SJohn Levon strcmp(basename, "dlink_common.c") == 0 || 30463eca6103SJohn Levon strncmp(basename, "crt", strlen("crt")) == 0 || 30473eca6103SJohn Levon strncmp(basename, "values-", strlen("values-")) == 0) 30483eca6103SJohn Levon return (B_TRUE); 3049bc1f688bSRobert Mustacchi 30503eca6103SJohn Levon for (size_t i = 0; i < nr_cus; i++) { 30513eca6103SJohn Levon if (strcmp(basename, cus[i].cu_name) == 0) 30523eca6103SJohn Levon return (B_TRUE); 30533eca6103SJohn Levon } 30543eca6103SJohn Levon 30553eca6103SJohn Levon return (B_FALSE); 30563eca6103SJohn Levon } 30573eca6103SJohn Levon 30583eca6103SJohn Levon static int 30593eca6103SJohn Levon ctf_dwarf_check_missing(ctf_cu_t *cus, size_t nr_cus, Elf *elf, 3060bc1f688bSRobert Mustacchi char *errmsg, size_t errlen) 30613eca6103SJohn Levon { 30623eca6103SJohn Levon Elf_Scn *scn, *strscn; 30633eca6103SJohn Levon Elf_Data *data, *strdata; 30643eca6103SJohn Levon GElf_Shdr shdr; 30653eca6103SJohn Levon ulong_t i; 30663eca6103SJohn Levon 30673eca6103SJohn Levon scn = NULL; 30683eca6103SJohn Levon while ((scn = elf_nextscn(elf, scn)) != NULL) { 30693eca6103SJohn Levon if (gelf_getshdr(scn, &shdr) == NULL) { 30703eca6103SJohn Levon (void) snprintf(errmsg, errlen, 30713eca6103SJohn Levon "failed to get section header: %s\n", 30723eca6103SJohn Levon elf_errmsg(elf_errno())); 30733eca6103SJohn Levon return (EINVAL); 30743eca6103SJohn Levon } 30753eca6103SJohn Levon 30763eca6103SJohn Levon if (shdr.sh_type == SHT_SYMTAB) 30773eca6103SJohn Levon break; 30783eca6103SJohn Levon } 30793eca6103SJohn Levon 30803eca6103SJohn Levon if (scn == NULL) 30813eca6103SJohn Levon return (0); 30823eca6103SJohn Levon 30833eca6103SJohn Levon if ((strscn = elf_getscn(elf, shdr.sh_link)) == NULL) { 30843eca6103SJohn Levon (void) snprintf(errmsg, errlen, 30853eca6103SJohn Levon "failed to get str section: %s\n", 30863eca6103SJohn Levon elf_errmsg(elf_errno())); 30873eca6103SJohn Levon return (EINVAL); 30883eca6103SJohn Levon } 30893eca6103SJohn Levon 30903eca6103SJohn Levon if ((data = elf_getdata(scn, NULL)) == NULL) { 30913eca6103SJohn Levon (void) snprintf(errmsg, errlen, "failed to read section: %s\n", 30923eca6103SJohn Levon elf_errmsg(elf_errno())); 30933eca6103SJohn Levon return (EINVAL); 30943eca6103SJohn Levon } 30953eca6103SJohn Levon 30963eca6103SJohn Levon if ((strdata = elf_getdata(strscn, NULL)) == NULL) { 30973eca6103SJohn Levon (void) snprintf(errmsg, errlen, 30983eca6103SJohn Levon "failed to read string table: %s\n", 30993eca6103SJohn Levon elf_errmsg(elf_errno())); 31003eca6103SJohn Levon return (EINVAL); 31013eca6103SJohn Levon } 31023eca6103SJohn Levon 31033eca6103SJohn Levon for (i = 0; i < shdr.sh_size / shdr.sh_entsize; i++) { 31043eca6103SJohn Levon GElf_Sym sym; 31053eca6103SJohn Levon const char *file; 31063eca6103SJohn Levon size_t len; 31073eca6103SJohn Levon 31083eca6103SJohn Levon if (gelf_getsym(data, i, &sym) == NULL) { 31093eca6103SJohn Levon (void) snprintf(errmsg, errlen, 31103eca6103SJohn Levon "failed to read sym %lu: %s\n", 31113eca6103SJohn Levon i, elf_errmsg(elf_errno())); 31123eca6103SJohn Levon return (EINVAL); 31133eca6103SJohn Levon } 31143eca6103SJohn Levon 31153eca6103SJohn Levon if (GELF_ST_TYPE(sym.st_info) != STT_FILE) 31163eca6103SJohn Levon continue; 31173eca6103SJohn Levon 31183eca6103SJohn Levon file = (const char *)((uintptr_t)strdata->d_buf + sym.st_name); 31193eca6103SJohn Levon len = strlen(file); 31203eca6103SJohn Levon if (len < 2 || strncmp(".c", &file[len - 2], 2) != 0) 31213eca6103SJohn Levon continue; 31223eca6103SJohn Levon 31233eca6103SJohn Levon if (!c_source_has_debug(file, cus, nr_cus)) { 31243eca6103SJohn Levon (void) snprintf(errmsg, errlen, 31253eca6103SJohn Levon "file %s is missing debug info\n", file); 31263eca6103SJohn Levon return (ECTF_CONVNODEBUG); 31273eca6103SJohn Levon } 31283eca6103SJohn Levon } 31293eca6103SJohn Levon 31303eca6103SJohn Levon return (0); 31313eca6103SJohn Levon } 31323eca6103SJohn Levon 31333eca6103SJohn Levon int 31343eca6103SJohn Levon ctf_dwarf_convert(int fd, Elf *elf, uint_t nthrs, uint_t flags, 31353eca6103SJohn Levon ctf_file_t **fpp, char *errbuf, size_t errlen) 3136bc1f688bSRobert Mustacchi { 3137bc1f688bSRobert Mustacchi int err, ret, ndies, i; 3138bc1f688bSRobert Mustacchi Dwarf_Debug dw; 3139bc1f688bSRobert Mustacchi Dwarf_Error derr; 3140bc1f688bSRobert Mustacchi ctf_cu_t *cdies = NULL, *cup; 3141bc1f688bSRobert Mustacchi workq_t *wqp = NULL; 3142bc1f688bSRobert Mustacchi 3143bc1f688bSRobert Mustacchi *fpp = NULL; 3144bc1f688bSRobert Mustacchi 3145bc1f688bSRobert Mustacchi ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, &dw, &derr); 3146bc1f688bSRobert Mustacchi if (ret != DW_DLV_OK) { 3147bc1f688bSRobert Mustacchi if (ret == DW_DLV_NO_ENTRY || 3148bc1f688bSRobert Mustacchi dwarf_errno(derr) == DW_DLE_DEBUG_INFO_NULL) { 31493eca6103SJohn Levon (void) snprintf(errbuf, errlen, 31503eca6103SJohn Levon "file does not contain DWARF data\n"); 31513eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3152bc1f688bSRobert Mustacchi } 31533eca6103SJohn Levon 31543eca6103SJohn Levon (void) snprintf(errbuf, errlen, 31553eca6103SJohn Levon "dwarf_elf_init() failed: %s\n", dwarf_errmsg(derr)); 31563eca6103SJohn Levon return (ECTF_CONVBKERR); 3157bc1f688bSRobert Mustacchi } 3158bc1f688bSRobert Mustacchi 3159bc1f688bSRobert Mustacchi /* 3160bc1f688bSRobert Mustacchi * Iterate over all of the compilation units and create a ctf_cu_t for 3161bc1f688bSRobert Mustacchi * each of them. This is used to determine if we have zero, one, or 3162bc1f688bSRobert Mustacchi * multiple dies to convert. If we have zero, that's an error. If 3163bc1f688bSRobert Mustacchi * there's only one die, that's the simple case. No merge needed and 3164bc1f688bSRobert Mustacchi * only a single Dwarf_Debug as well. 3165bc1f688bSRobert Mustacchi */ 3166bc1f688bSRobert Mustacchi ndies = 0; 31673eca6103SJohn Levon err = ctf_dwarf_count_dies(dw, &derr, &ndies, errbuf, errlen); 31683eca6103SJohn Levon 31693eca6103SJohn Levon ctf_dprintf("found %d DWARF CUs\n", ndies); 31703eca6103SJohn Levon 31713eca6103SJohn Levon if (ndies == 0) { 31723eca6103SJohn Levon (void) snprintf(errbuf, errlen, 31733eca6103SJohn Levon "file does not contain DWARF data\n"); 31743eca6103SJohn Levon return (ECTF_CONVNODEBUG); 3175bc1f688bSRobert Mustacchi } 3176bc1f688bSRobert Mustacchi 3177bc1f688bSRobert Mustacchi (void) dwarf_finish(dw, &derr); 3178bc1f688bSRobert Mustacchi cdies = ctf_alloc(sizeof (ctf_cu_t) * ndies); 3179bc1f688bSRobert Mustacchi if (cdies == NULL) { 31803eca6103SJohn Levon return (ENOMEM); 3181bc1f688bSRobert Mustacchi } 3182bc1f688bSRobert Mustacchi 31833eca6103SJohn Levon bzero(cdies, sizeof (ctf_cu_t) * ndies); 31843eca6103SJohn Levon 3185bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3186bc1f688bSRobert Mustacchi cup = &cdies[i]; 3187bc1f688bSRobert Mustacchi ret = dwarf_elf_init(elf, DW_DLC_READ, NULL, NULL, 3188bc1f688bSRobert Mustacchi &cup->cu_dwarf, &derr); 3189bc1f688bSRobert Mustacchi if (ret != 0) { 3190bc1f688bSRobert Mustacchi ctf_free(cdies, sizeof (ctf_cu_t) * ndies); 31913eca6103SJohn Levon (void) snprintf(errbuf, errlen, 3192bc1f688bSRobert Mustacchi "failed to initialize DWARF: %s\n", 3193bc1f688bSRobert Mustacchi dwarf_errmsg(derr)); 31943eca6103SJohn Levon return (ECTF_CONVBKERR); 3195bc1f688bSRobert Mustacchi } 3196bc1f688bSRobert Mustacchi 31973eca6103SJohn Levon err = ctf_dwarf_init_die(fd, elf, cup, i, errbuf, errlen); 31983eca6103SJohn Levon if (err != 0) 3199bc1f688bSRobert Mustacchi goto out; 320037e82d12SRobert Mustacchi 3201bc1f688bSRobert Mustacchi cup->cu_doweaks = ndies > 1 ? B_FALSE : B_TRUE; 3202bc1f688bSRobert Mustacchi } 3203bc1f688bSRobert Mustacchi 32043eca6103SJohn Levon if (!(flags & CTF_ALLOW_MISSING_DEBUG) && 32053eca6103SJohn Levon (err = ctf_dwarf_check_missing(cdies, ndies, 32063eca6103SJohn Levon elf, errbuf, errlen)) != 0) 32073eca6103SJohn Levon goto out; 3208bc1f688bSRobert Mustacchi 3209bc1f688bSRobert Mustacchi /* 3210bc1f688bSRobert Mustacchi * If we only have one compilation unit, there's no reason to use 3211bc1f688bSRobert Mustacchi * multiple threads, even if the user requested them. After all, they 3212bc1f688bSRobert Mustacchi * just gave us an upper bound. 3213bc1f688bSRobert Mustacchi */ 3214bc1f688bSRobert Mustacchi if (ndies == 1) 3215bc1f688bSRobert Mustacchi nthrs = 1; 3216bc1f688bSRobert Mustacchi 3217bc1f688bSRobert Mustacchi if (workq_init(&wqp, nthrs) == -1) { 32183eca6103SJohn Levon err = errno; 3219bc1f688bSRobert Mustacchi goto out; 3220bc1f688bSRobert Mustacchi } 3221bc1f688bSRobert Mustacchi 3222bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3223bc1f688bSRobert Mustacchi cup = &cdies[i]; 322437e82d12SRobert Mustacchi ctf_dprintf("adding cu %s: %p, %x %x\n", cup->cu_name, 3225bc1f688bSRobert Mustacchi cup->cu_cu, cup->cu_cuoff, cup->cu_maxoff); 3226bc1f688bSRobert Mustacchi if (workq_add(wqp, cup) == -1) { 32273eca6103SJohn Levon err = errno; 3228bc1f688bSRobert Mustacchi goto out; 3229bc1f688bSRobert Mustacchi } 3230bc1f688bSRobert Mustacchi } 3231bc1f688bSRobert Mustacchi 32323eca6103SJohn Levon ret = workq_work(wqp, ctf_dwarf_convert_one, NULL, &err); 3233bc1f688bSRobert Mustacchi if (ret == WORKQ_ERROR) { 32343eca6103SJohn Levon err = errno; 3235bc1f688bSRobert Mustacchi goto out; 3236bc1f688bSRobert Mustacchi } else if (ret == WORKQ_UERROR) { 3237bc1f688bSRobert Mustacchi ctf_dprintf("internal convert failed: %s\n", 32383eca6103SJohn Levon ctf_errmsg(err)); 3239bc1f688bSRobert Mustacchi goto out; 3240bc1f688bSRobert Mustacchi } 3241bc1f688bSRobert Mustacchi 324237e82d12SRobert Mustacchi ctf_dprintf("Determining next phase: have %d CUs\n", ndies); 3243bc1f688bSRobert Mustacchi if (ndies != 1) { 3244bc1f688bSRobert Mustacchi ctf_merge_t *cmp; 3245bc1f688bSRobert Mustacchi 32463eca6103SJohn Levon cmp = ctf_merge_init(fd, &err); 32473eca6103SJohn Levon if (cmp == NULL) 3248bc1f688bSRobert Mustacchi goto out; 3249bc1f688bSRobert Mustacchi 3250bc1f688bSRobert Mustacchi ctf_dprintf("setting threads\n"); 32513eca6103SJohn Levon if ((err = ctf_merge_set_nthreads(cmp, nthrs)) != 0) { 3252bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 3253bc1f688bSRobert Mustacchi goto out; 3254bc1f688bSRobert Mustacchi } 3255bc1f688bSRobert Mustacchi 3256bc1f688bSRobert Mustacchi for (i = 0; i < ndies; i++) { 3257bc1f688bSRobert Mustacchi cup = &cdies[i]; 32583eca6103SJohn Levon if ((err = ctf_merge_add(cmp, cup->cu_ctfp)) != 0) { 3259bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 3260bc1f688bSRobert Mustacchi goto out; 3261bc1f688bSRobert Mustacchi } 3262bc1f688bSRobert Mustacchi } 3263bc1f688bSRobert Mustacchi 3264bc1f688bSRobert Mustacchi ctf_dprintf("performing merge\n"); 32653eca6103SJohn Levon err = ctf_merge_merge(cmp, fpp); 32663eca6103SJohn Levon if (err != 0) { 3267bc1f688bSRobert Mustacchi ctf_dprintf("failed merge!\n"); 3268bc1f688bSRobert Mustacchi *fpp = NULL; 3269bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 3270bc1f688bSRobert Mustacchi goto out; 3271bc1f688bSRobert Mustacchi } 3272bc1f688bSRobert Mustacchi ctf_merge_fini(cmp); 32733eca6103SJohn Levon err = 0; 3274bc1f688bSRobert Mustacchi ctf_dprintf("successfully converted!\n"); 3275bc1f688bSRobert Mustacchi } else { 32763eca6103SJohn Levon err = 0; 3277bc1f688bSRobert Mustacchi *fpp = cdies->cu_ctfp; 3278bc1f688bSRobert Mustacchi cdies->cu_ctfp = NULL; 3279bc1f688bSRobert Mustacchi ctf_dprintf("successfully converted!\n"); 3280bc1f688bSRobert Mustacchi } 3281bc1f688bSRobert Mustacchi 3282bc1f688bSRobert Mustacchi out: 3283bc1f688bSRobert Mustacchi workq_fini(wqp); 3284bc1f688bSRobert Mustacchi ctf_dwarf_free_dies(cdies, ndies); 32853eca6103SJohn Levon return (err); 3286bc1f688bSRobert Mustacchi } 3287