libebl/eblopenbackend.c

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