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