LCOV - code coverage report
Current view: top level - elfutils/libebl - eblopenbackend.c (source / functions) Hit Total Coverage
Test: lcov.out Lines: 116 177 65.5 %
Date: 2013-03-08 Functions: 21 40 52.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 20 36 55.6 %

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

Generated by: LCOV version 1.9