libebl/eblopenbackend.c

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