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