1 /* Find debugging and symbol information for a module in libdwfl. 2 Copyright (C) 2005-2013 Red Hat, Inc. 3 This file is part of elfutils. 4 5 This file is free software; you can redistribute it and/or modify 6 it under the terms of either 7 8 * the GNU Lesser General Public License as published by the Free 9 Software Foundation; either version 3 of the License, or (at 10 your option) any later version 11 12 or 13 14 * the GNU General Public License as published by the Free 15 Software Foundation; either version 2 of the License, or (at 16 your option) any later version 17 18 or both in parallel, as here. 19 20 elfutils is distributed in the hope that it will be useful, but 21 WITHOUT ANY WARRANTY; without even the implied warranty of 22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23 General Public License for more details. 24 25 You should have received copies of the GNU General Public License and 26 the GNU Lesser General Public License along with this program. If 27 not, see <http://www.gnu.org/licenses/>. */ 28 29 #include "libdwflP.h" 30 31 struct search_state 32 { 33 Dwfl_Module *mod; 34 GElf_Addr addr; 35 36 GElf_Sym *closest_sym; 37 bool adjust_st_value; 38 GElf_Word addr_shndx; 39 Elf *addr_symelf; 40 41 /* Keep track of the closest symbol we have seen so far. 42 Here we store only symbols with nonzero st_size. */ 43 const char *closest_name; 44 GElf_Addr closest_value; 45 GElf_Word closest_shndx; 46 Elf *closest_elf; 47 48 /* Keep track of an eligible symbol with st_size == 0 as a fallback. */ 49 const char *sizeless_name; 50 GElf_Sym sizeless_sym; 51 GElf_Addr sizeless_value; 52 GElf_Word sizeless_shndx; 53 Elf *sizeless_elf; 54 55 /* Keep track of the lowest address a relevant sizeless symbol could have. */ 56 GElf_Addr min_label; 57 }; 58 59 /* Return true iff we consider ADDR to lie in the same section as SYM. */ 60 static inline bool 61 same_section (struct search_state *state, 62 GElf_Addr value, Elf *symelf, GElf_Word shndx) 63 { 64 /* For absolute symbols and the like, only match exactly. */ 65 if (shndx >= SHN_LORESERVE) 66 return value == state->addr; 67 68 /* If value might not be st_value, the shndx of the symbol might 69 not match the section of the value. Explicitly look both up. */ 70 if (! state->adjust_st_value) 71 { 72 Dwarf_Addr v; 73 if (state->addr_shndx == SHN_UNDEF) 74 { 75 v = state->addr; 76 state->addr_shndx = __libdwfl_find_section_ndx (state->mod, &v); 77 } 78 79 v = value; 80 return state->addr_shndx == __libdwfl_find_section_ndx (state->mod, &v); 81 } 82 83 /* Figure out what section ADDR lies in. */ 84 if (state->addr_shndx == SHN_UNDEF || state->addr_symelf != symelf) 85 { 86 GElf_Addr mod_addr = dwfl_deadjust_st_value (state->mod, symelf, 87 state->addr); 88 Elf_Scn *scn = NULL; 89 state->addr_shndx = SHN_ABS; 90 state->addr_symelf = symelf; 91 while ((scn = elf_nextscn (symelf, scn)) != NULL) 92 { 93 GElf_Shdr shdr_mem; 94 GElf_Shdr *shdr = gelf_getshdr (scn, &shdr_mem); 95 if (likely (shdr != NULL) 96 && mod_addr >= shdr->sh_addr 97 && mod_addr < shdr->sh_addr + shdr->sh_size) 98 { 99 state->addr_shndx = elf_ndxscn (scn); 100 break; 101 } 102 } 103 } 104 105 return shndx == state->addr_shndx && state->addr_symelf == symelf; 106 } 107 108 /* Return GELF_ST_BIND as higher-is-better integer. */ 109 static inline int 110 binding_value (const GElf_Sym *symp) 111 { 112 switch (GELF_ST_BIND (symp->st_info)) 113 { 114 case STB_GLOBAL: 115 return 3; 116 case STB_WEAK: 117 return 2; 118 case STB_LOCAL: 119 return 1; 120 default: 121 return 0; 122 } 123 } 124 125 /* Try one symbol and associated value from the search table. */ 126 static inline void 127 try_sym_value (struct search_state *state, 128 GElf_Addr value, GElf_Sym *sym, 129 const char *name, GElf_Word shndx, 130 Elf *elf, bool resolved) 131 { 132 /* Even if we don't choose this symbol, its existence excludes 133 any sizeless symbol (assembly label) that is below its upper 134 bound. */ 135 if (value + sym->st_size > state->min_label) 136 state->min_label = value + sym->st_size; 137 138 if (sym->st_size == 0 || state->addr - value < sym->st_size) 139 { 140 /* This symbol is a better candidate than the current one 141 if it's closer to ADDR or is global when it was local. */ 142 if (state->closest_name == NULL 143 || state->closest_value < value 144 || binding_value (state->closest_sym) < binding_value (sym)) 145 { 146 if (sym->st_size != 0) 147 { 148 *state->closest_sym = *sym; 149 state->closest_value = value; 150 state->closest_shndx = shndx; 151 state->closest_elf = elf; 152 state->closest_name = name; 153 } 154 else if (state->closest_name == NULL 155 && value >= state->min_label 156 && same_section (state, value, 157 resolved ? state->mod->main.elf : elf, 158 shndx)) 159 { 160 /* Handwritten assembly symbols sometimes have no 161 st_size. If no symbol with proper size includes 162 the address, we'll use the closest one that is in 163 the same section as ADDR. */ 164 state->sizeless_sym = *sym; 165 state->sizeless_value = value; 166 state->sizeless_shndx = shndx; 167 state->sizeless_elf = elf; 168 state->sizeless_name = name; 169 } 170 } 171 /* When the beginning of its range is no closer, 172 the end of its range might be. Otherwise follow 173 GELF_ST_BIND preference. If all are equal prefer 174 the first symbol found. */ 175 else if (sym->st_size != 0 176 && state->closest_value == value 177 && ((state->closest_sym->st_size > sym->st_size 178 && (binding_value (state->closest_sym) 179 <= binding_value (sym))) 180 || (state->closest_sym->st_size >= sym->st_size 181 && (binding_value (state->closest_sym) 182 < binding_value (sym))))) 183 { 184 *state->closest_sym = *sym; 185 state->closest_value = value; 186 state->closest_shndx = shndx; 187 state->closest_elf = elf; 188 state->closest_name = name; 189 } 190 } 191 } 192 193 /* Look through the symbol table for a matching symbol. */ 194 static inline void 195 search_table (struct search_state *state, int start, int end) 196 { 197 for (int i = start; i < end; ++i) 198 { 199 GElf_Sym sym; 200 GElf_Addr value; 201 GElf_Word shndx; 202 Elf *elf; 203 bool resolved; 204 const char *name = __libdwfl_getsym (state->mod, i, &sym, &value, 205 &shndx, &elf, NULL, 206 &resolved, 207 state->adjust_st_value); 208 if (name != NULL && name[0] != '\0' 209 && sym.st_shndx != SHN_UNDEF 210 && value <= state->addr 211 && GELF_ST_TYPE (sym.st_info) != STT_SECTION 212 && GELF_ST_TYPE (sym.st_info) != STT_FILE 213 && GELF_ST_TYPE (sym.st_info) != STT_TLS) 214 { 215 try_sym_value (state, value, &sym, name, shndx, elf, resolved); 216 217 /* If this is an addrinfo variant and the value could be 218 resolved then also try matching the (adjusted) st_value. */ 219 if (resolved && state->mod->e_type != ET_REL) 220 { 221 GElf_Addr adjusted_st_value; 222 adjusted_st_value = dwfl_adjusted_st_value (state->mod, elf, 223 sym.st_value); 224 if (value != adjusted_st_value 225 && adjusted_st_value <= state->addr) 226 try_sym_value (state, adjusted_st_value, &sym, name, shndx, 227 elf, false); 228 } 229 } 230 } 231 } 232 233 /* Returns the name of the symbol "closest" to ADDR. 234 Never returns symbols at addresses above ADDR. */ 235 const char * 236 internal_function 237 __libdwfl_addrsym (Dwfl_Module *_mod, GElf_Addr _addr, GElf_Off *off, 238 GElf_Sym *_closest_sym, GElf_Word *shndxp, 239 Elf **elfp, Dwarf_Addr *biasp, bool _adjust_st_value) 240 { 241 int syments = INTUSE(dwfl_module_getsymtab) (_mod); 242 if (syments < 0) 243 return NULL; 244 245 struct search_state state = 246 { 247 .addr = _addr, 248 .mod = _mod, 249 .closest_sym = _closest_sym, 250 .adjust_st_value = _adjust_st_value, 251 .addr_shndx = SHN_UNDEF, 252 .addr_symelf = NULL, 253 .closest_name = NULL, 254 .closest_value = 0, 255 .closest_shndx = SHN_UNDEF, 256 .closest_elf = NULL, 257 .sizeless_name = NULL, 258 .sizeless_sym = { 0, 0, 0, 0, 0, SHN_UNDEF }, 259 .sizeless_value = 0, 260 .sizeless_shndx = SHN_UNDEF, 261 .sizeless_elf = NULL, 262 .min_label = 0 263 }; 264 265 /* First go through global symbols. mod->first_global and 266 mod->aux_first_global are setup by dwfl_module_getsymtab to the 267 index of the first global symbol in those symbol tables. Both 268 are non-zero when the table exist, except when there is only a 269 dynsym table loaded through phdrs, then first_global is zero and 270 there will be no auxiliary table. All symbols with local binding 271 come first in the symbol table, then all globals. The zeroth, 272 null entry, in the auxiliary table is skipped if there is a main 273 table. */ 274 int first_global = INTUSE (dwfl_module_getsymtab_first_global) (state.mod); 275 if (first_global < 0) 276 return NULL; 277 search_table (&state, first_global == 0 ? 1 : first_global, syments); 278 279 /* If we found nothing searching the global symbols, then try the locals. 280 Unless we have a global sizeless symbol that matches exactly. */ 281 if (state.closest_name == NULL && first_global > 1 282 && (state.sizeless_name == NULL || state.sizeless_value != state.addr)) 283 search_table (&state, 1, first_global); 284 285 /* If we found no proper sized symbol to use, fall back to the best 286 candidate sizeless symbol we found, if any. */ 287 if (state.closest_name == NULL 288 && state.sizeless_name != NULL 289 && state.sizeless_value >= state.min_label) 290 { 291 *state.closest_sym = state.sizeless_sym; 292 state.closest_value = state.sizeless_value; 293 state.closest_shndx = state.sizeless_shndx; 294 state.closest_elf = state.sizeless_elf; 295 state.closest_name = state.sizeless_name; 296 } 297 298 *off = state.addr - state.closest_value; 299 300 if (shndxp != NULL) 301 *shndxp = state.closest_shndx; 302 if (elfp != NULL) 303 *elfp = state.closest_elf; 304 if (biasp != NULL) 305 *biasp = dwfl_adjusted_st_value (state.mod, state.closest_elf, 0); 306 return state.closest_name; 307 } 308 309 310 const char * 311 dwfl_module_addrsym (Dwfl_Module *mod, GElf_Addr addr, 312 GElf_Sym *closest_sym, GElf_Word *shndxp) 313 { 314 GElf_Off off; 315 return __libdwfl_addrsym (mod, addr, &off, closest_sym, shndxp, 316 NULL, NULL, true); 317 } 318 INTDEF (dwfl_module_addrsym) 319 320 const char 321 *dwfl_module_addrinfo (Dwfl_Module *mod, GElf_Addr address, 322 GElf_Off *offset, GElf_Sym *sym, 323 GElf_Word *shndxp, Elf **elfp, Dwarf_Addr *bias) 324 { 325 return __libdwfl_addrsym (mod, address, offset, sym, shndxp, elfp, bias, 326 false); 327 } 328 INTDEF (dwfl_module_addrinfo) 329
