LCOV - code coverage report
Current view: top level - libebl - eblopenbackend.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 117 178 65.7 %
Date: 2017-01-05 09:15:16 Functions: 22 39 56.4 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.12