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