libebl/eblopenbackend.c

   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 static bool default_none_reloc_p (int reloc);
 200 static bool default_relative_reloc_p (int reloc);
 201 static bool default_check_special_symbol (Elf *elf, GElf_Ehdr *ehdr,
 202                                           const GElf_Sym *sym,
 203                                           const char *name,
 204                                           const GElf_Shdr *destshdr);
 205 static bool default_check_st_other_bits (unsigned char st_other);
 206 static bool default_check_special_section (Ebl *, int,
 207                                            const GElf_Shdr *, const char *);
 208 static bool default_bss_plt_p (Elf *elf, GElf_Ehdr *ehdr);
 209 static int default_return_value_location (Dwarf_Die *functypedie,
 210                                           const Dwarf_Op **locops);
 211 static ssize_t default_register_info (Ebl *ebl,
 212                                       int regno, char *name, size_t namelen,
 213                                       const char **prefix,
 214                                       const char **setname,
 215                                       int *bits, int *type);
 216 static int default_syscall_abi (Ebl *ebl, int *sp, int *pc,
 217                                 int *callno, int args[6]);
 218 static bool default_check_object_attribute (Ebl *ebl, const char *vendor,
 219                                             int tag, uint64_t value,
 220                                             const char **tag_name,
 221                                             const char **value_name);
 222 static int default_abi_cfi (Ebl *ebl, Dwarf_CIE *abi_info);
 223
 224
 225 static void
 226 fill_defaults (Ebl *result)
 227 {
 228   result->object_type_name = default_object_type_name;
 229   result->reloc_type_name = default_reloc_type_name;
 230   result->reloc_type_check = default_reloc_type_check;
 231   result->reloc_valid_use = default_reloc_valid_use;
 232   result->reloc_simple_type = default_reloc_simple_type;
 233   result->gotpc_reloc_check = default_gotpc_reloc_check;
 234   result->segment_type_name = default_segment_type_name;
 235   result->section_type_name = default_section_type_name;
 236   result->section_name = default_section_name;
 237   result->machine_flag_name = default_machine_flag_name;
 238   result->machine_flag_check = default_machine_flag_check;
 239   result->machine_section_flag_check = default_machine_section_flag_check;
 240   result->check_special_section = default_check_special_section;
 241   result->symbol_type_name = default_symbol_type_name;
 242   result->symbol_binding_name = default_symbol_binding_name;
 243   result->dynamic_tag_name = default_dynamic_tag_name;
 244   result->dynamic_tag_check = default_dynamic_tag_check;
 245   result->sh_flags_combine = default_sh_flags_combine;
 246   result->osabi_name = default_osabi_name;
 247   result->core_note_type_name = default_core_note_type_name;
 248   result->object_note_type_name = default_object_note_type_name;
 249   result->core_note = default_core_note;
 250   result->auxv_info = default_auxv_info;
 251   result->object_note = default_object_note;
 252   result->debugscn_p = default_debugscn_p;
 253   result->copy_reloc_p = default_copy_reloc_p;
 254   result->none_reloc_p = default_none_reloc_p;
 255   result->relative_reloc_p = default_relative_reloc_p;
 256   result->check_special_symbol = default_check_special_symbol;
 257   result->check_st_other_bits = default_check_st_other_bits;
 258   result->bss_plt_p = default_bss_plt_p;
 259   result->return_value_location = default_return_value_location;
 260   result->register_info = default_register_info;
 261   result->syscall_abi = default_syscall_abi;
 262   result->check_object_attribute = default_check_object_attribute;
 263   result->disasm = NULL;
 264   result->abi_cfi = default_abi_cfi;
 265   result->destr = default_destr;
 266   result->sysvhash_entrysize = sizeof (Elf32_Word);
 267 }
 268
 269
 270 /* Find an appropriate backend for the file associated with ELF.  */
 271 static Ebl *
 272 openbackend (elf, emulation, machine)
 273      Elf *elf;
 274      const char *emulation;
 275      GElf_Half machine;
 276 {
 277   Ebl *result;
 278   size_t cnt;
 279
 280   /* First allocate the data structure for the result.  We do this
 281      here since this assures that the structure is always large
 282      enough.  */
 283   result = (Ebl *) calloc (1, sizeof (Ebl));
 284   if (result == NULL)
 285     {
 286       // XXX uncomment
 287       // __libebl_seterror (ELF_E_NOMEM);
 288       return NULL;
 289     }
 290
 291   /* Fill in the default callbacks.  The initializer for the machine
 292      specific module can overwrite the values.  */
 293   fill_defaults (result);
 294
 295   /* XXX Currently all we do is to look at 'e_machine' value in the
 296      ELF header.  With an internal mapping table from EM_* value to
 297      DSO name we try to load the appropriate module to handle this
 298      binary type.
 299
 300      Multiple modules for the same machine type are possible and they
 301      will be tried in sequence.  The lookup process will only stop
 302      when a module which can handle the machine type is found or all
 303      available matching modules are tried.  */
 304   for (cnt = 0; cnt < nmachines; ++cnt)
 305     if ((emulation != NULL && strcmp (emulation, machines[cnt].emulation) == 0)
 306         || (emulation == NULL && machines[cnt].em == machine))
 307       {
 308         /* Well, we know the emulation name now.  */
 309         result->emulation = machines[cnt].emulation;
 310
 311         /* We access some data structures directly.  Make sure the 32 and
 312            64 bit variants are laid out the same.  */
 313         assert (offsetof (Elf32_Ehdr, e_machine)
 314                 == offsetof (Elf64_Ehdr, e_machine));
 315         assert (sizeof (((Elf32_Ehdr *) 0)->e_machine)
 316                 == sizeof (((Elf64_Ehdr *) 0)->e_machine));
 317         assert (offsetof (Elf, state.elf32.ehdr)
 318                 == offsetof (Elf, state.elf64.ehdr));
 319
 320         /* Prefer taking the information from the ELF file.  */
 321         if (elf == NULL)
 322           {
 323             result->machine = machines[cnt].em;
 324             result->class = machines[cnt].class;
 325             result->data = machines[cnt].data;
 326           }
 327         else
 328           {
 329             result->machine = elf->state.elf32.ehdr->e_machine;
 330             result->class = elf->state.elf32.ehdr->e_ident[EI_CLASS];
 331             result->data = elf->state.elf32.ehdr->e_ident[EI_DATA];
 332           }
 333
 334 #ifndef LIBEBL_SUBDIR
 335 # define LIBEBL_SUBDIR PACKAGE
 336 #endif
 337 #define ORIGINDIR "$ORIGIN/../$LIB/" LIBEBL_SUBDIR "/"
 338
 339         /* Give it a try.  At least the machine type matches.  First
 340            try to load the module.  */
 341         char dsoname[100];
 342         strcpy (stpcpy (stpcpy (dsoname, ORIGINDIR "libebl_"),
 343                         machines[cnt].dsoname),
 344                 ".so");
 345
 346         void *h = dlopen (dsoname, RTLD_LAZY);
 347         if (h == NULL)
 348           {
 349             strcpy (stpcpy (stpcpy (dsoname, "libebl_"),
 350                             machines[cnt].dsoname),
 351                     ".so");
 352             h = dlopen (dsoname, RTLD_LAZY);
 353           }
 354
 355           /* Try without an explicit path.  */
 356         if (h != NULL)
 357           {
 358             /* We managed to load the object.  Now see whether the
 359                initialization function likes our file.  */
 360             static const char version[] = MODVERSION;
 361             const char *modversion;
 362             ebl_bhinit_t initp;
 363             char symname[machines[cnt].prefix_len + sizeof "_init"];
 364
 365             strcpy (mempcpy (symname, machines[cnt].prefix,
 366                              machines[cnt].prefix_len), "_init");
 367
 368             initp = (ebl_bhinit_t) dlsym (h, symname);
 369             if (initp != NULL
 370                 && (modversion = initp (elf, machine, result, sizeof (Ebl)))
 371                 && strcmp (version, modversion) == 0)
 372               {
 373                 /* We found a module to handle our file.  */
 374                 result->dlhandle = h;
 375                 result->elf = elf;
 376
 377                 /* A few entries are mandatory.  */
 378                 assert (result->name != NULL);
 379                 assert (result->destr != NULL);
 380
 381                 return result;
 382               }
 383
 384             /* Not the module we need.  */
 385             (void) dlclose (h);
 386           }
 387
 388         /* We cannot find a DSO but the emulation/machine ID matches.
 389            Return that information.  */
 390         result->dlhandle = NULL;
 391         result->elf = elf;
 392         result->name = machines[cnt].prefix;
 393         fill_defaults (result);
 394
 395         return result;
 396       }
 397
 398   /* Nothing matched.  We use only the default callbacks.   */
 399   result->dlhandle = NULL;
 400   result->elf = elf;
 401   result->emulation = "<unknown>";
 402   result->name = "<unknown>";
 403   fill_defaults (result);
 404
 405   return result;
 406 }
 407
 408
 409 /* Find an appropriate backend for the file associated with ELF.  */
 410 Ebl *
 411 ebl_openbackend (elf)
 412      Elf *elf;
 413 {
 414   GElf_Ehdr ehdr_mem;
 415   GElf_Ehdr *ehdr;
 416
 417   /* Get the ELF header of the object.  */
 418   ehdr = gelf_getehdr (elf, &ehdr_mem);
 419   if (ehdr == NULL)
 420     {
 421       // XXX uncomment
 422       // __libebl_seterror (elf_errno ());
 423       return NULL;
 424     }
 425
 426   return openbackend (elf, NULL, ehdr->e_machine);
 427 }
 428
 429
 430 /* Find backend without underlying ELF file.  */
 431 Ebl *
 432 ebl_openbackend_machine (machine)
 433      GElf_Half machine;
 434 {
 435   return openbackend (NULL, NULL, machine);
 436 }
 437
 438
 439 /* Find backend with given emulation name.  */
 440 Ebl *
 441 ebl_openbackend_emulation (const char *emulation)
 442 {
 443   return openbackend (NULL, emulation, EM_NONE);
 444 }
 445
 446
 447 /* Default callbacks.  Mostly they just return the error value.  */
 448 static const char *
 449 default_object_type_name (int ignore __attribute__ ((unused)),
 450                           char *buf __attribute__ ((unused)),
 451                           size_t len __attribute__ ((unused)))
 452 {
 453   return NULL;
 454 }
 455
 456 static const char *
 457 default_reloc_type_name (int ignore __attribute__ ((unused)),
 458                          char *buf __attribute__ ((unused)),
 459                          size_t len __attribute__ ((unused)))
 460 {
 461   return NULL;
 462 }
 463
 464 static bool
 465 default_reloc_type_check (int ignore __attribute__ ((unused)))
 466 {
 467   return false;
 468 }
 469
 470 static bool
 471 default_reloc_valid_use (Elf *elf __attribute__ ((unused)),
 472                          int ignore __attribute__ ((unused)))
 473 {
 474   return false;
 475 }
 476
 477 static Elf_Type
 478 default_reloc_simple_type (Ebl *eh __attribute__ ((unused)),
 479                            int ignore __attribute__ ((unused)))
 480 {
 481   return ELF_T_NUM;
 482 }
 483
 484 static bool
 485 default_gotpc_reloc_check (Elf *elf __attribute__ ((unused)),
 486                            int ignore __attribute__ ((unused)))
 487 {
 488   return false;
 489 }
 490
 491 static const char *
 492 default_segment_type_name (int ignore __attribute__ ((unused)),
 493                            char *buf __attribute__ ((unused)),
 494                            size_t len __attribute__ ((unused)))
 495 {
 496   return NULL;
 497 }
 498
 499 static const char *
 500 default_section_type_name (int ignore __attribute__ ((unused)),
 501                            char *buf __attribute__ ((unused)),
 502                            size_t len __attribute__ ((unused)))
 503 {
 504   return NULL;
 505 }
 506
 507 static const char *
 508 default_section_name (int ignore __attribute__ ((unused)),
 509                       int ignore2 __attribute__ ((unused)),
 510                       char *buf __attribute__ ((unused)),
 511                       size_t len __attribute__ ((unused)))
 512 {
 513   return NULL;
 514 }
 515
 516 static const char *
 517 default_machine_flag_name (Elf64_Word *ignore __attribute__ ((unused)))
 518 {
 519   return NULL;
 520 }
 521
 522 static bool
 523 default_machine_flag_check (Elf64_Word flags __attribute__ ((unused)))
 524 {
 525   return flags == 0;
 526 }
 527
 528 static bool
 529 default_machine_section_flag_check (GElf_Xword flags)
 530 {
 531   return flags == 0;
 532 }
 533
 534 static bool
 535 default_check_special_section (Ebl *ebl __attribute__ ((unused)),
 536                                int ndx __attribute__ ((unused)),
 537                                const GElf_Shdr *shdr __attribute__ ((unused)),
 538                                const char *sname __attribute__ ((unused)))
 539 {
 540   return false;
 541 }
 542
 543 static const char *
 544 default_symbol_type_name (int ignore __attribute__ ((unused)),
 545                           char *buf __attribute__ ((unused)),
 546                           size_t len __attribute__ ((unused)))
 547 {
 548   return NULL;
 549 }
 550
 551 static const char *
 552 default_symbol_binding_name (int ignore __attribute__ ((unused)),
 553                              char *buf __attribute__ ((unused)),
 554                              size_t len __attribute__ ((unused)))
 555 {
 556   return NULL;
 557 }
 558
 559 static const char *
 560 default_dynamic_tag_name (int64_t ignore __attribute__ ((unused)),
 561                           char *buf __attribute__ ((unused)),
 562                           size_t len __attribute__ ((unused)))
 563 {
 564   return NULL;
 565 }
 566
 567 static bool
 568 default_dynamic_tag_check (int64_t ignore __attribute__ ((unused)))
 569 {
 570   return false;
 571 }
 572
 573 static GElf_Word
 574 default_sh_flags_combine (GElf_Word flags1, GElf_Word flags2)
 575 {
 576   return SH_FLAGS_COMBINE (flags1, flags2);
 577 }
 578
 579 static void
 580 default_destr (struct ebl *ignore __attribute__ ((unused)))
 581 {
 582 }
 583
 584 static const char *
 585 default_osabi_name (int ignore __attribute__ ((unused)),
 586                     char *buf __attribute__ ((unused)),
 587                     size_t len __attribute__ ((unused)))
 588 {
 589   return NULL;
 590 }
 591
 592 static const char *
 593 default_core_note_type_name (uint32_t ignore __attribute__ ((unused)),
 594                              char *buf __attribute__ ((unused)),
 595                              size_t len __attribute__ ((unused)))
 596 {
 597   return NULL;
 598 }
 599
 600 static int
 601 default_auxv_info (GElf_Xword a_type __attribute__ ((unused)),
 602                    const char **name __attribute__ ((unused)),
 603                    const char **format __attribute__ ((unused)))
 604 {
 605   return 0;
 606 }
 607
 608 static int
 609 default_core_note (const GElf_Nhdr *nhdr __attribute__ ((unused)),
 610                    const char *name __attribute__ ((unused)),
 611                    GElf_Word *ro __attribute__ ((unused)),
 612                    size_t *nregloc  __attribute__ ((unused)),
 613                    const Ebl_Register_Location **reglocs
 614                    __attribute__ ((unused)),
 615                    size_t *nitems __attribute__ ((unused)),
 616                    const Ebl_Core_Item **items __attribute__ ((unused)))
 617 {
 618   return 0;
 619 }
 620
 621 static const char *
 622 default_object_note_type_name (const char *name __attribute__ ((unused)),
 623                                uint32_t ignore __attribute__ ((unused)),
 624                                char *buf __attribute__ ((unused)),
 625                                size_t len __attribute__ ((unused)))
 626 {
 627   return NULL;
 628 }
 629
 630 static bool
 631 default_object_note (const char *name __attribute__ ((unused)),
 632                      uint32_t type __attribute__ ((unused)),
 633                      uint32_t descsz __attribute__ ((unused)),
 634                      const char *desc __attribute__ ((unused)))
 635 {
 636   return NULL;
 637 }
 638
 639 static bool
 640 default_debugscn_p (const char *name)
 641 {
 642   /* We know by default only about the DWARF debug sections which have
 643      fixed names.  */
 644   static const char *dwarf_scn_names[] =
 645     {
 646       /* DWARF 1 */
 647       ".debug",
 648       ".line",
 649       /* GNU DWARF 1 extensions */
 650       ".debug_srcinfo",
 651       ".debug_sfnames",
 652       /* DWARF 1.1 and DWARF 2 */
 653       ".debug_aranges",
 654       ".debug_pubnames",
 655       /* DWARF 2 */
 656       ".debug_info",
 657       ".debug_abbrev",
 658       ".debug_line",
 659       ".debug_frame",
 660       ".debug_str",
 661       ".debug_loc",
 662       ".debug_macinfo",
 663       /* DWARF 3 */
 664       ".debug_ranges",
 665       ".debug_pubtypes",
 666       /* DWARF 4 */
 667       ".debug_types",
 668       /* GDB DWARF 4 extension */
 669       ".gdb_index",
 670       /* SGI/MIPS DWARF 2 extensions */
 671       ".debug_weaknames",
 672       ".debug_funcnames",
 673       ".debug_typenames",
 674       ".debug_varnames"
 675     };
 676   const size_t ndwarf_scn_names = (sizeof (dwarf_scn_names)
 677                                    / sizeof (dwarf_scn_names[0]));
 678   for (size_t cnt = 0; cnt < ndwarf_scn_names; ++cnt)
 679     if (strcmp (name, dwarf_scn_names[cnt]) == 0)
 680       return true;
 681
 682   return false;
 683 }
 684
 685 static bool
 686 default_copy_reloc_p (int reloc __attribute__ ((unused)))
 687 {
 688   return false;
 689 }
 690 strong_alias (default_copy_reloc_p, default_none_reloc_p)
 691 strong_alias (default_copy_reloc_p, default_relative_reloc_p)
 692
 693 static bool
 694 default_check_special_symbol (Elf *elf __attribute__ ((unused)),
 695                               GElf_Ehdr *ehdr __attribute__ ((unused)),
 696                               const GElf_Sym *sym __attribute__ ((unused)),
 697                               const char *name __attribute__ ((unused)),
 698                               const GElf_Shdr *destshdr __attribute__ ((unused)))
 699 {
 700   return false;
 701 }
 702
 703 static bool
 704 default_check_st_other_bits (unsigned char st_other __attribute__ ((unused)))
 705 {
 706   return false;
 707 }
 708
 709
 710 static bool
 711 default_bss_plt_p (Elf *elf __attribute__ ((unused)),
 712                    GElf_Ehdr *ehdr __attribute__ ((unused)))
 713 {
 714   return false;
 715 }
 716
 717 static int
 718 default_return_value_location (Dwarf_Die *functypedie __attribute__ ((unused)),
 719                                const Dwarf_Op **locops __attribute__ ((unused)))
 720 {
 721   return -2;
 722 }
 723
 724 static ssize_t
 725 default_register_info (Ebl *ebl __attribute__ ((unused)),
 726                        int regno, char *name, size_t namelen,
 727                        const char **prefix,
 728                        const char **setname,
 729                        int *bits, int *type)
 730 {
 731   if (name == NULL)
 732     return 0;
 733
 734   *setname = "???";
 735   *prefix = "";
 736   *bits = -1;
 737   *type = DW_ATE_void;
 738   return snprintf (name, namelen, "reg%d", regno);
 739 }
 740
 741 static int
 742 default_syscall_abi (Ebl *ebl __attribute__ ((unused)),
 743                      int *sp, int *pc, int *callno, int args[6])
 744 {
 745   *sp = *pc = *callno = -1;
 746   args[0] = -1;
 747   args[1] = -1;
 748   args[2] = -1;
 749   args[3] = -1;
 750   args[4] = -1;
 751   args[5] = -1;
 752   return -1;
 753 }
 754
 755 static bool
 756 default_check_object_attribute (Ebl *ebl __attribute__ ((unused)),
 757                                 const char *vendor  __attribute__ ((unused)),
 758                                 int tag __attribute__ ((unused)),
 759                                 uint64_t value __attribute__ ((unused)),
 760                                 const char **tag_name, const char **value_name)
 761 {
 762   *tag_name = NULL;
 763   *value_name = NULL;
 764   return false;
 765 }
 766
 767 static int
 768 default_abi_cfi (Ebl *ebl __attribute__ ((unused)),
 769                  Dwarf_CIE *abi_info __attribute__ ((unused)))
 770 {
 771   return 0;
 772 }