1 /* Generate ELF backend handle. 2 Copyright (C) 2000-2011 Red Hat, Inc. 3 This file is part of Red Hat elfutils. 4 5 Red Hat elfutils is free software; you can redistribute it and/or modify 6 it under the terms of the GNU General Public License as published by the 7 Free Software Foundation; version 2 of the License. 8 9 Red Hat elfutils is distributed in the hope that it will be useful, but 10 WITHOUT ANY WARRANTY; without even the implied warranty of 11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 12 General Public License for more details. 13 14 You should have received a copy of the GNU General Public License along 15 with Red Hat elfutils; if not, write to the Free Software Foundation, 16 Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301 USA. 17 18 In addition, as a special exception, Red Hat, Inc. gives You the 19 additional right to link the code of Red Hat elfutils with code licensed 20 under any Open Source Initiative certified open source license 21 (http://www.opensource.org/licenses/index.php) which requires the 22 distribution of source code with any binary distribution and to 23 distribute linked combinations of the two. Non-GPL Code permitted under 24 this exception must only link to the code of Red Hat elfutils through 25 those well defined interfaces identified in the file named EXCEPTION 26 found in the source code files (the "Approved Interfaces"). The files 27 of Non-GPL Code may instantiate templates or use macros or inline 28 functions from the Approved Interfaces without causing the resulting 29 work to be covered by the GNU General Public License. Only Red Hat, 30 Inc. may make changes or additions to the list of Approved Interfaces. 31 Red Hat's grant of this exception is conditioned upon your not adding 32 any new exceptions. If you wish to add a new Approved Interface or 33 exception, please contact Red Hat. You must obey the GNU General Public 34 License in all respects for all of the Red Hat elfutils code and other 35 code used in conjunction with Red Hat elfutils except the Non-GPL Code 36 covered by this exception. If you modify this file, you may extend this 37 exception to your version of the file, but you are not obligated to do 38 so. If you do not wish to provide this exception without modification, 39 you must delete this exception statement from your version and license 40 this file solely under the GPL without exception. 41 42 Red Hat elfutils is an included package of the Open Invention Network. 43 An included package of the Open Invention Network is a package for which 44 Open Invention Network licensees cross-license their patents. No patent 45 license is granted, either expressly or impliedly, by designation as an 46 included package. Should you wish to participate in the Open Invention 47 Network licensing program, please visit www.openinventionnetwork.com 48 <http://www.openinventionnetwork.com>. */ 49 50 #ifdef HAVE_CONFIG_H 51 # include <config.h> 52 #endif 53 54 #include <assert.h> 55 #include <dlfcn.h> 56 #include <error.h> 57 #include <libelfP.h> 58 #include <dwarf.h> 59 #include <stdlib.h> 60 #include <string.h> 61 #include <stdio.h> 62 63 #include <libeblP.h> 64 65 66 /* This table should contain the complete list of architectures as far 67 as the ELF specification is concerned. */ 68 /* XXX When things are stable replace the string pointers with char 69 arrays to avoid relocations. */ 70 static const struct 71 { 72 const char *dsoname; 73 const char *emulation; 74 const char *prefix; 75 int prefix_len; 76 int em; 77 int class; 78 int data; 79 } machines[] = 80 { 81 { "i386", "elf_i386", "i386", 4, EM_386, ELFCLASS32, ELFDATA2LSB }, 82 { "ia64", "elf_ia64", "ia64", 4, EM_IA_64, ELFCLASS64, ELFDATA2LSB }, 83 { "alpha", "elf_alpha", "alpha", 5, EM_ALPHA, ELFCLASS64, ELFDATA2LSB }, 84 { "x86_64", "elf_x86_64", "x86_64", 6, EM_X86_64, ELFCLASS64, ELFDATA2LSB }, 85 { "ppc", "elf_ppc", "ppc", 3, EM_PPC, ELFCLASS32, ELFDATA2MSB }, 86 { "ppc64", "elf_ppc64", "ppc64", 5, EM_PPC64, ELFCLASS64, ELFDATA2MSB }, 87 // XXX class and machine fields need to be filled in for all archs. 88 { "sh", "elf_sh", "sh", 2, EM_SH, 0, 0 }, 89 { "arm", "ebl_arm", "arm", 3, EM_ARM, 0, 0 }, 90 { "sparc", "elf_sparcv9", "sparc", 5, EM_SPARCV9, 0, 0 }, 91 { "sparc", "elf_sparc", "sparc", 5, EM_SPARC, 0, 0 }, 92 { "sparc", "elf_sparcv8plus", "sparc", 5, EM_SPARC32PLUS, 0, 0 }, 93 { "s390", "ebl_s390", "s390", 4, EM_S390, 0, 0 }, 94 95 { "m32", "elf_m32", "m32", 3, EM_M32, 0, 0 }, 96 { "m68k", "elf_m68k", "m68k", 4, EM_68K, 0, 0 }, 97 { "m88k", "elf_m88k", "m88k", 4, EM_88K, 0, 0 }, 98 { "i860", "elf_i860", "i860", 4, EM_860, 0, 0 }, 99 { "s370", "ebl_s370", "s370", 4, EM_S370, 0, 0 }, 100 { "parisc", "elf_parisc", "parisc", 6, EM_PARISC, 0, 0 }, 101 { "vpp500", "elf_vpp500", "vpp500", 5, EM_VPP500, 0, 0 }, 102 { "sparc", "elf_v8plus", "v8plus", 6, EM_SPARC32PLUS, 0, 0 }, 103 { "i960", "elf_i960", "i960", 4, EM_960, 0, 0 }, 104 { "v800", "ebl_v800", "v800", 4, EM_V800, 0, 0 }, 105 { "fr20", "ebl_fr20", "fr20", 4, EM_FR20, 0, 0 }, 106 { "rh32", "ebl_rh32", "rh32", 4, EM_RH32, 0, 0 }, 107 { "rce", "ebl_rce", "rce", 3, EM_RCE, 0, 0 }, 108 { "tricore", "elf_tricore", "tricore", 7, EM_TRICORE, 0, 0 }, 109 { "arc", "elf_arc", "arc", 3, EM_ARC, 0, 0 }, 110 { "h8", "elf_h8_300", "h8_300", 6, EM_H8_300, 0, 0 }, 111 { "h8", "elf_h8_300h", "h8_300h", 6, EM_H8_300H, 0, 0 }, 112 { "h8", "elf_h8s", "h8s", 6, EM_H8S, 0, 0 }, 113 { "h8", "elf_h8_500", "h8_500", 6, EM_H8_500, 0, 0 }, 114 { "coldfire", "elf_coldfire", "coldfire", 8, EM_COLDFIRE, 0, 0 }, 115 { "m68k", "elf_68hc12", "68hc12", 6, EM_68HC12, 0, 0 }, 116 { "mma", "elf_mma", "mma", 3, EM_MMA, 0, 0 }, 117 { "pcp", "elf_pcp", "pcp", 3, EM_PCP, 0, 0 }, 118 { "ncpu", "elf_ncpu", "ncpu", 4, EM_NCPU, 0, 0 }, 119 { "ndr1", "elf_ndr1", "ndr1", 4, EM_NDR1, 0, 0 }, 120 { "starcore", "elf_starcore", "starcore", 8, EM_STARCORE, 0, 0 }, 121 { "me16", "elf_me16", "em16", 4, EM_ME16, 0, 0 }, 122 { "st100", "elf_st100", "st100", 5, EM_ST100, 0, 0 }, 123 { "tinyj", "elf_tinyj", "tinyj", 5, EM_TINYJ, 0, 0 }, 124 { "pdsp", "elf_pdsp", "pdsp", 4, EM_PDSP, 0, 0 }, 125 { "fx66", "elf_fx66", "fx66", 4, EM_FX66, 0, 0 }, 126 { "st9plus", "elf_st9plus", "st9plus", 7, EM_ST9PLUS, 0, 0 }, 127 { "st7", "elf_st7", "st7", 3, EM_ST7, 0, 0 }, 128 { "m68k", "elf_68hc16", "68hc16", 6, EM_68HC16, 0, 0 }, 129 { "m68k", "elf_68hc11", "68hc11", 6, EM_68HC11, 0, 0 }, 130 { "m68k", "elf_68hc08", "68hc08", 6, EM_68HC08, 0, 0 }, 131 { "m68k", "elf_68hc05", "68hc05", 6, EM_68HC05, 0, 0 }, 132 { "svx", "elf_svx", "svx", 3, EM_SVX, 0, 0 }, 133 { "st19", "elf_st19", "st19", 4, EM_ST19, 0, 0 }, 134 { "vax", "elf_vax", "vax", 3, EM_VAX, 0, 0 }, 135 { "cris", "elf_cris", "cris", 4, EM_CRIS, 0, 0 }, 136 { "javelin", "elf_javelin", "javelin", 7, EM_JAVELIN, 0, 0 }, 137 { "firepath", "elf_firepath", "firepath", 8, EM_FIREPATH, 0, 0 }, 138 { "zsp", "elf_zsp", "zsp", 3, EM_ZSP, 0, 0 }, 139 { "mmix", "elf_mmix", "mmix", 4, EM_MMIX, 0, 0 }, 140 { "hunay", "elf_huany", "huany", 5, EM_HUANY, 0, 0 }, 141 { "prism", "elf_prism", "prism", 5, EM_PRISM, 0, 0 }, 142 { "avr", "elf_avr", "avr", 3, EM_AVR, 0, 0 }, 143 { "fr30", "elf_fr30", "fr30", 4, EM_FR30, 0, 0 }, 144 { "dv10", "elf_dv10", "dv10", 4, EM_D10V, 0, 0 }, 145 { "dv30", "elf_dv30", "dv30", 4, EM_D30V, 0, 0 }, 146 { "v850", "elf_v850", "v850", 4, EM_V850, 0, 0 }, 147 { "m32r", "elf_m32r", "m32r", 4, EM_M32R, 0, 0 }, 148 { "mn10300", "elf_mn10300", "mn10300", 7, EM_MN10300, 0, 0 }, 149 { "mn10200", "elf_mn10200", "mn10200", 7, EM_MN10200, 0, 0 }, 150 { "pj", "elf_pj", "pj", 2, EM_PJ, 0, 0 }, 151 { "openrisc", "elf_openrisc", "openrisc", 8, EM_OPENRISC, 0, 0 }, 152 { "arc", "elf_arc_a5", "arc_a5", 6, EM_ARC_A5, 0, 0 }, 153 { "xtensa", "elf_xtensa", "xtensa", 6, EM_XTENSA, 0, 0 }, 154 }; 155 #define nmachines (sizeof (machines) / sizeof (machines[0])) 156 157 158 /* Default callbacks. Mostly they just return the error value. */ 159 static const char *default_object_type_name (int ignore, char *buf, 160 size_t len); 161 static const char *default_reloc_type_name (int ignore, char *buf, size_t len); 162 static bool default_reloc_type_check (int ignore); 163 static bool default_reloc_valid_use (Elf *elf, int ignore); 164 static Elf_Type default_reloc_simple_type (Ebl *ebl, int ignore); 165 static bool default_gotpc_reloc_check (Elf *elf, int ignore); 166 static const char *default_segment_type_name (int ignore, char *buf, 167 size_t len); 168 static const char *default_section_type_name (int ignore, char *buf, 169 size_t len); 170 static const char *default_section_name (int ignore, int ignore2, char *buf, 171 size_t len); 172 static const char *default_machine_flag_name (Elf64_Word *ignore); 173 static bool default_machine_flag_check (Elf64_Word flags); 174 static bool default_machine_section_flag_check (GElf_Xword flags); 175 static const char *default_symbol_type_name (int ignore, char *buf, 176 size_t len); 177 static const char *default_symbol_binding_name (int ignore, char *buf, 178 size_t len); 179 static const char *default_dynamic_tag_name (int64_t ignore, char *buf, 180 size_t len); 181 static bool default_dynamic_tag_check (int64_t ignore); 182 static GElf_Word default_sh_flags_combine (GElf_Word flags1, GElf_Word flags2); 183 static const char *default_osabi_name (int ignore, char *buf, size_t len); 184 static void default_destr (struct ebl *ignore); 185 static const char *default_core_note_type_name (uint32_t, char *buf, 186 size_t len); 187 static const char *default_object_note_type_name (const char *name, uint32_t, 188 char *buf, size_t len); 189 static int default_core_note (const GElf_Nhdr *nhdr, const char *name, 190 GElf_Word *regs_offset, size_t *nregloc, 191 const Ebl_Register_Location **reglocs, 192 size_t *nitems, const Ebl_Core_Item **); 193 static int default_auxv_info (GElf_Xword a_type, 194 const char **name, const char **format); 195 static bool default_object_note (const char *name, uint32_t type, 196 uint32_t descsz, const char *desc); 197 static bool default_debugscn_p (const char *name); 198 static bool default_copy_reloc_p (int reloc); 199 #ifndef __APPLE__ 200 static bool default_none_reloc_p (int reloc); 201 static bool default_relative_reloc_p (int reloc); 202 #else 203 #define default_none_reloc_p default_copy_reloc_p 204 #define default_relative_reloc_p default_copy_reloc_p 205 #endif 206 static bool default_check_special_symbol (Elf *elf, GElf_Ehdr *ehdr, 207 const GElf_Sym *sym, 208 const char *name, 209 const GElf_Shdr *destshdr); 210 static bool default_check_st_other_bits (unsigned char st_other); 211 static bool default_check_special_section (Ebl *, int, 212 const GElf_Shdr *, const char *); 213 static bool default_bss_plt_p (Elf *elf, GElf_Ehdr *ehdr); 214 static int default_return_value_location (Dwarf_Die *functypedie, 215 const Dwarf_Op **locops); 216 static ssize_t default_register_info (Ebl *ebl, 217 int regno, char *name, size_t namelen, 218 const char **prefix, 219 const char **setname, 220 int *bits, int *type); 221 static int default_syscall_abi (Ebl *ebl, int *sp, int *pc, 222 int *callno, int args[6]); 223 static bool default_check_object_attribute (Ebl *ebl, const char *vendor, 224 int tag, uint64_t value, 225 const char **tag_name, 226 const char **value_name); 227 static int default_abi_cfi (Ebl *ebl, Dwarf_CIE *abi_info); 228 229 230 static void 231 fill_defaults (Ebl *result) 232 { 233 result->object_type_name = default_object_type_name; 234 result->reloc_type_name = default_reloc_type_name; 235 result->reloc_type_check = default_reloc_type_check; 236 result->reloc_valid_use = default_reloc_valid_use; 237 result->reloc_simple_type = default_reloc_simple_type; 238 result->gotpc_reloc_check = default_gotpc_reloc_check; 239 result->segment_type_name = default_segment_type_name; 240 result->section_type_name = default_section_type_name; 241 result->section_name = default_section_name; 242 result->machine_flag_name = default_machine_flag_name; 243 result->machine_flag_check = default_machine_flag_check; 244 result->machine_section_flag_check = default_machine_section_flag_check; 245 result->check_special_section = default_check_special_section; 246 result->symbol_type_name = default_symbol_type_name; 247 result->symbol_binding_name = default_symbol_binding_name; 248 result->dynamic_tag_name = default_dynamic_tag_name; 249 result->dynamic_tag_check = default_dynamic_tag_check; 250 result->sh_flags_combine = default_sh_flags_combine; 251 result->osabi_name = default_osabi_name; 252 result->core_note_type_name = default_core_note_type_name; 253 result->object_note_type_name = default_object_note_type_name; 254 result->core_note = default_core_note; 255 result->auxv_info = default_auxv_info; 256 result->object_note = default_object_note; 257 result->debugscn_p = default_debugscn_p; 258 result->copy_reloc_p = default_copy_reloc_p; 259 result->none_reloc_p = default_none_reloc_p; 260 result->relative_reloc_p = default_relative_reloc_p; 261 result->check_special_symbol = default_check_special_symbol; 262 result->check_st_other_bits = default_check_st_other_bits; 263 result->bss_plt_p = default_bss_plt_p; 264 result->return_value_location = default_return_value_location; 265 result->register_info = default_register_info; 266 result->syscall_abi = default_syscall_abi; 267 result->check_object_attribute = default_check_object_attribute; 268 result->disasm = NULL; 269 result->abi_cfi = default_abi_cfi; 270 result->destr = default_destr; 271 result->sysvhash_entrysize = sizeof (Elf32_Word); 272 } 273 274 275 /* Find an appropriate backend for the file associated with ELF. */ 276 static Ebl * 277 openbackend (elf, emulation, machine) 278 Elf *elf; 279 const char *emulation; 280 GElf_Half machine; 281 { 282 Ebl *result; 283 size_t cnt; 284 285 /* First allocate the data structure for the result. We do this 286 here since this assures that the structure is always large 287 enough. */ 288 result = (Ebl *) calloc (1, sizeof (Ebl)); 289 if (result == NULL) 290 { 291 // XXX uncomment 292 // __libebl_seterror (ELF_E_NOMEM); 293 return NULL; 294 } 295 296 /* Fill in the default callbacks. The initializer for the machine 297 specific module can overwrite the values. */ 298 fill_defaults (result); 299 300 /* XXX Currently all we do is to look at 'e_machine' value in the 301 ELF header. With an internal mapping table from EM_* value to 302 DSO name we try to load the appropriate module to handle this 303 binary type. 304 305 Multiple modules for the same machine type are possible and they 306 will be tried in sequence. The lookup process will only stop 307 when a module which can handle the machine type is found or all 308 available matching modules are tried. */ 309 for (cnt = 0; cnt < nmachines; ++cnt) 310 if ((emulation != NULL && strcmp (emulation, machines[cnt].emulation) == 0) 311 || (emulation == NULL && machines[cnt].em == machine)) 312 { 313 /* Well, we know the emulation name now. */ 314 result->emulation = machines[cnt].emulation; 315 316 /* We access some data structures directly. Make sure the 32 and 317 64 bit variants are laid out the same. */ 318 assert (offsetof (Elf32_Ehdr, e_machine) 319 == offsetof (Elf64_Ehdr, e_machine)); 320 assert (sizeof (((Elf32_Ehdr *) 0)->e_machine) 321 == sizeof (((Elf64_Ehdr *) 0)->e_machine)); 322 assert (offsetof (Elf, state.elf32.ehdr) 323 == offsetof (Elf, state.elf64.ehdr)); 324 325 /* Prefer taking the information from the ELF file. */ 326 if (elf == NULL) 327 { 328 result->machine = machines[cnt].em; 329 result->class = machines[cnt].class; 330 result->data = machines[cnt].data; 331 } 332 else 333 { 334 result->machine = elf->state.elf32.ehdr->e_machine; 335 result->class = elf->state.elf32.ehdr->e_ident[EI_CLASS]; 336 result->data = elf->state.elf32.ehdr->e_ident[EI_DATA]; 337 } 338 339 #ifndef LIBEBL_SUBDIR 340 # define LIBEBL_SUBDIR PACKAGE 341 #endif 342 #define ORIGINDIR "$ORIGIN/../$LIB/" LIBEBL_SUBDIR "/" 343 344 /* Give it a try. At least the machine type matches. First 345 try to load the module. */ 346 char dsoname[100]; 347 strcpy (stpcpy (stpcpy (dsoname, ORIGINDIR "libebl_"), 348 machines[cnt].dsoname), 349 ".so"); 350 351 void *h = dlopen (dsoname, RTLD_LAZY); 352 if (h == NULL) 353 { 354 strcpy (stpcpy (stpcpy (dsoname, "libebl_"), 355 machines[cnt].dsoname), 356 ".so"); 357 h = dlopen (dsoname, RTLD_LAZY); 358 } 359 360 /* Try without an explicit path. */ 361 if (h != NULL) 362 { 363 /* We managed to load the object. Now see whether the 364 initialization function likes our file. */ 365 static const char version[] = MODVERSION; 366 const char *modversion; 367 ebl_bhinit_t initp; 368 char symname[machines[cnt].prefix_len + sizeof "_init"]; 369 370 strcpy (mempcpy (symname, machines[cnt].prefix, 371 machines[cnt].prefix_len), "_init"); 372 373 initp = (ebl_bhinit_t) dlsym (h, symname); 374 if (initp != NULL 375 && (modversion = initp (elf, machine, result, sizeof (Ebl))) 376 && strcmp (version, modversion) == 0) 377 { 378 /* We found a module to handle our file. */ 379 result->dlhandle = h; 380 result->elf = elf; 381 382 /* A few entries are mandatory. */ 383 assert (result->name != NULL); 384 assert (result->destr != NULL); 385 386 return result; 387 } 388 389 /* Not the module we need. */ 390 (void) dlclose (h); 391 } 392 393 /* We cannot find a DSO but the emulation/machine ID matches. 394 Return that information. */ 395 result->dlhandle = NULL; 396 result->elf = elf; 397 result->name = machines[cnt].prefix; 398 fill_defaults (result); 399 400 return result; 401 } 402 403 /* Nothing matched. We use only the default callbacks. */ 404 result->dlhandle = NULL; 405 result->elf = elf; 406 result->emulation = "<unknown>"; 407 result->name = "<unknown>"; 408 fill_defaults (result); 409 410 return result; 411 } 412 413 414 /* Find an appropriate backend for the file associated with ELF. */ 415 Ebl * 416 ebl_openbackend (elf) 417 Elf *elf; 418 { 419 GElf_Ehdr ehdr_mem; 420 GElf_Ehdr *ehdr; 421 422 /* Get the ELF header of the object. */ 423 ehdr = gelf_getehdr (elf, &ehdr_mem); 424 if (ehdr == NULL) 425 { 426 // XXX uncomment 427 // __libebl_seterror (elf_errno ()); 428 return NULL; 429 } 430 431 return openbackend (elf, NULL, ehdr->e_machine); 432 } 433 434 435 /* Find backend without underlying ELF file. */ 436 Ebl * 437 ebl_openbackend_machine (machine) 438 GElf_Half machine; 439 { 440 return openbackend (NULL, NULL, machine); 441 } 442 443 444 /* Find backend with given emulation name. */ 445 Ebl * 446 ebl_openbackend_emulation (const char *emulation) 447 { 448 return openbackend (NULL, emulation, EM_NONE); 449 } 450 451 452 /* Default callbacks. Mostly they just return the error value. */ 453 static const char * 454 default_object_type_name (int ignore __attribute__ ((unused)), 455 char *buf __attribute__ ((unused)), 456 size_t len __attribute__ ((unused))) 457 { 458 return NULL; 459 } 460 461 static const char * 462 default_reloc_type_name (int ignore __attribute__ ((unused)), 463 char *buf __attribute__ ((unused)), 464 size_t len __attribute__ ((unused))) 465 { 466 return NULL; 467 } 468 469 static bool 470 default_reloc_type_check (int ignore __attribute__ ((unused))) 471 { 472 return false; 473 } 474 475 static bool 476 default_reloc_valid_use (Elf *elf __attribute__ ((unused)), 477 int ignore __attribute__ ((unused))) 478 { 479 return false; 480 } 481 482 static Elf_Type 483 default_reloc_simple_type (Ebl *eh __attribute__ ((unused)), 484 int ignore __attribute__ ((unused))) 485 { 486 return ELF_T_NUM; 487 } 488 489 static bool 490 default_gotpc_reloc_check (Elf *elf __attribute__ ((unused)), 491 int ignore __attribute__ ((unused))) 492 { 493 return false; 494 } 495 496 static const char * 497 default_segment_type_name (int ignore __attribute__ ((unused)), 498 char *buf __attribute__ ((unused)), 499 size_t len __attribute__ ((unused))) 500 { 501 return NULL; 502 } 503 504 static const char * 505 default_section_type_name (int ignore __attribute__ ((unused)), 506 char *buf __attribute__ ((unused)), 507 size_t len __attribute__ ((unused))) 508 { 509 return NULL; 510 } 511 512 static const char * 513 default_section_name (int ignore __attribute__ ((unused)), 514 int ignore2 __attribute__ ((unused)), 515 char *buf __attribute__ ((unused)), 516 size_t len __attribute__ ((unused))) 517 { 518 return NULL; 519 } 520 521 static const char * 522 default_machine_flag_name (Elf64_Word *ignore __attribute__ ((unused))) 523 { 524 return NULL; 525 } 526 527 static bool 528 default_machine_flag_check (Elf64_Word flags __attribute__ ((unused))) 529 { 530 return flags == 0; 531 } 532 533 static bool 534 default_machine_section_flag_check (GElf_Xword flags) 535 { 536 return flags == 0; 537 } 538 539 static bool 540 default_check_special_section (Ebl *ebl __attribute__ ((unused)), 541 int ndx __attribute__ ((unused)), 542 const GElf_Shdr *shdr __attribute__ ((unused)), 543 const char *sname __attribute__ ((unused))) 544 { 545 return false; 546 } 547 548 static const char * 549 default_symbol_type_name (int ignore __attribute__ ((unused)), 550 char *buf __attribute__ ((unused)), 551 size_t len __attribute__ ((unused))) 552 { 553 return NULL; 554 } 555 556 static const char * 557 default_symbol_binding_name (int ignore __attribute__ ((unused)), 558 char *buf __attribute__ ((unused)), 559 size_t len __attribute__ ((unused))) 560 { 561 return NULL; 562 } 563 564 static const char * 565 default_dynamic_tag_name (int64_t ignore __attribute__ ((unused)), 566 char *buf __attribute__ ((unused)), 567 size_t len __attribute__ ((unused))) 568 { 569 return NULL; 570 } 571 572 static bool 573 default_dynamic_tag_check (int64_t ignore __attribute__ ((unused))) 574 { 575 return false; 576 } 577 578 static GElf_Word 579 default_sh_flags_combine (GElf_Word flags1, GElf_Word flags2) 580 { 581 return SH_FLAGS_COMBINE (flags1, flags2); 582 } 583 584 static void 585 default_destr (struct ebl *ignore __attribute__ ((unused))) 586 { 587 } 588 589 static const char * 590 default_osabi_name (int ignore __attribute__ ((unused)), 591 char *buf __attribute__ ((unused)), 592 size_t len __attribute__ ((unused))) 593 { 594 return NULL; 595 } 596 597 static const char * 598 default_core_note_type_name (uint32_t ignore __attribute__ ((unused)), 599 char *buf __attribute__ ((unused)), 600 size_t len __attribute__ ((unused))) 601 { 602 return NULL; 603 } 604 605 static int 606 default_auxv_info (GElf_Xword a_type __attribute__ ((unused)), 607 const char **name __attribute__ ((unused)), 608 const char **format __attribute__ ((unused))) 609 { 610 return 0; 611 } 612 613 static int 614 default_core_note (const GElf_Nhdr *nhdr __attribute__ ((unused)), 615 const char *name __attribute__ ((unused)), 616 GElf_Word *ro __attribute__ ((unused)), 617 size_t *nregloc __attribute__ ((unused)), 618 const Ebl_Register_Location **reglocs 619 __attribute__ ((unused)), 620 size_t *nitems __attribute__ ((unused)), 621 const Ebl_Core_Item **items __attribute__ ((unused))) 622 { 623 return 0; 624 } 625 626 static const char * 627 default_object_note_type_name (const char *name __attribute__ ((unused)), 628 uint32_t ignore __attribute__ ((unused)), 629 char *buf __attribute__ ((unused)), 630 size_t len __attribute__ ((unused))) 631 { 632 return NULL; 633 } 634 635 static bool 636 default_object_note (const char *name __attribute__ ((unused)), 637 uint32_t type __attribute__ ((unused)), 638 uint32_t descsz __attribute__ ((unused)), 639 const char *desc __attribute__ ((unused))) 640 { 641 return NULL; 642 } 643 644 static bool 645 default_debugscn_p (const char *name) 646 { 647 /* We know by default only about the DWARF debug sections which have 648 fixed names. */ 649 static const char *dwarf_scn_names[] = 650 { 651 /* DWARF 1 */ 652 ".debug", 653 ".line", 654 /* GNU DWARF 1 extensions */ 655 ".debug_srcinfo", 656 ".debug_sfnames", 657 /* DWARF 1.1 and DWARF 2 */ 658 ".debug_aranges", 659 ".debug_pubnames", 660 /* DWARF 2 */ 661 ".debug_info", 662 ".debug_abbrev", 663 ".debug_line", 664 ".debug_frame", 665 ".debug_str", 666 ".debug_loc", 667 ".debug_macinfo", 668 /* DWARF 3 */ 669 ".debug_ranges", 670 ".debug_pubtypes", 671 /* DWARF 4 */ 672 ".debug_types", 673 /* GDB DWARF 4 extension */ 674 ".gdb_index", 675 /* SGI/MIPS DWARF 2 extensions */ 676 ".debug_weaknames", 677 ".debug_funcnames", 678 ".debug_typenames", 679 ".debug_varnames" 680 }; 681 const size_t ndwarf_scn_names = (sizeof (dwarf_scn_names) 682 / sizeof (dwarf_scn_names[0])); 683 for (size_t cnt = 0; cnt < ndwarf_scn_names; ++cnt) 684 if (strcmp (name, dwarf_scn_names[cnt]) == 0) 685 return true; 686 687 return false; 688 } 689 690 static bool 691 default_copy_reloc_p (int reloc __attribute__ ((unused))) 692 { 693 return false; 694 } 695 #ifndef __APPLE__ 696 strong_alias (default_copy_reloc_p, default_none_reloc_p) 697 strong_alias (default_copy_reloc_p, default_relative_reloc_p) 698 #endif 699 700 static bool 701 default_check_special_symbol (Elf *elf __attribute__ ((unused)), 702 GElf_Ehdr *ehdr __attribute__ ((unused)), 703 const GElf_Sym *sym __attribute__ ((unused)), 704 const char *name __attribute__ ((unused)), 705 const GElf_Shdr *destshdr __attribute__ ((unused))) 706 { 707 return false; 708 } 709 710 static bool 711 default_check_st_other_bits (unsigned char st_other __attribute__ ((unused))) 712 { 713 return false; 714 } 715 716 717 static bool 718 default_bss_plt_p (Elf *elf __attribute__ ((unused)), 719 GElf_Ehdr *ehdr __attribute__ ((unused))) 720 { 721 return false; 722 } 723 724 static int 725 default_return_value_location (Dwarf_Die *functypedie __attribute__ ((unused)), 726 const Dwarf_Op **locops __attribute__ ((unused))) 727 { 728 return -2; 729 } 730 731 static ssize_t 732 default_register_info (Ebl *ebl __attribute__ ((unused)), 733 int regno, char *name, size_t namelen, 734 const char **prefix, 735 const char **setname, 736 int *bits, int *type) 737 { 738 if (name == NULL) 739 return 0; 740 741 *setname = "???"; 742 *prefix = ""; 743 *bits = -1; 744 *type = DW_ATE_void; 745 return snprintf (name, namelen, "reg%d", regno); 746 } 747 748 static int 749 default_syscall_abi (Ebl *ebl __attribute__ ((unused)), 750 int *sp, int *pc, int *callno, int args[6]) 751 { 752 *sp = *pc = *callno = -1; 753 args[0] = -1; 754 args[1] = -1; 755 args[2] = -1; 756 args[3] = -1; 757 args[4] = -1; 758 args[5] = -1; 759 return -1; 760 } 761 762 static bool 763 default_check_object_attribute (Ebl *ebl __attribute__ ((unused)), 764 const char *vendor __attribute__ ((unused)), 765 int tag __attribute__ ((unused)), 766 uint64_t value __attribute__ ((unused)), 767 const char **tag_name, const char **value_name) 768 { 769 *tag_name = NULL; 770 *value_name = NULL; 771 return false; 772 } 773 774 static int 775 default_abi_cfi (Ebl *ebl __attribute__ ((unused)), 776 Dwarf_CIE *abi_info __attribute__ ((unused))) 777 { 778 return 0; 779 } 780
