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