LCOV - code coverage report
Current view: top level - libebl - eblopenbackend.c (source / functions) Hit Total Coverage
Test: elfutils-0.189 Lines: 127 163 77.9 %
Date: 2023-04-06 23:11:33 Functions: 24 39 61.5 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 23 36 63.9 %

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

Generated by: LCOV version 1.14