1 /* Linux bpf specific support for 64-bit ELF
2 Copyright (C) 2019-2023 Free Software Foundation, Inc.
3 Contributed by Oracle Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/bpf.h"
27 #include "libiberty.h"
28
29 /* In case we're on a 32-bit machine, construct a 64-bit "-1" value. */
30 #define MINUS_ONE (~ (bfd_vma) 0)
31
32 #define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset)
33
34 static bfd_reloc_status_type bpf_elf_generic_reloc
35 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
36
37 #undef BPF_HOWTO
38 #define BPF_HOWTO(type, right, size, bits, pcrel, left, ovf, func, name, \
39 inplace, src_mask, dst_mask, pcrel_off) \
40 type##_IDX,
41 enum bpf_reloc_index {
42 R_BPF_INVALID_IDX = -1,
43 #include "bpf-reloc.def"
44 R_BPF_SIZE
45 };
46 #undef BPF_HOWTO
47
48 /* Relocation tables. */
49 #define BPF_HOWTO(...) HOWTO(__VA_ARGS__),
50 static reloc_howto_type bpf_elf_howto_table [] =
51 {
52 #include "bpf-reloc.def"
53 };
54 #undef AHOW
55 #undef BPF_HOWTO
56
57 #define BPF_HOWTO(type, right, size, bits, pcrel, left, ovf, func, name, \
58 inplace, src_mask, dst_mask, pcrel_off) \
59 case type: { return type##_IDX; }
60 static enum bpf_reloc_index
61 bpf_index_for_rtype(unsigned int r_type)
62 {
63 switch(r_type) {
64 #include "bpf-reloc.def"
65 default:
66 /* Unreachable code. */
67 BFD_ASSERT(0);
68 return -1;
69 };
70 }
71
72 /* Map BFD reloc types to bpf ELF reloc types. */
73
74 static reloc_howto_type *
75 bpf_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
76 bfd_reloc_code_real_type code)
77 {
78 switch (code)
79 {
80 case BFD_RELOC_NONE:
81 return &bpf_elf_howto_table[ (int) R_BPF_NONE_IDX];
82
83 case BFD_RELOC_32:
84 return &bpf_elf_howto_table[ (int) R_BPF_64_ABS32_IDX];
85 case BFD_RELOC_64:
86 return &bpf_elf_howto_table[ (int) R_BPF_64_ABS64_IDX];
87
88 case BFD_RELOC_BPF_64:
89 return &bpf_elf_howto_table[ (int) R_BPF_64_64_IDX];
90 case BFD_RELOC_BPF_DISP32:
91 return &bpf_elf_howto_table[ (int) R_BPF_64_32_IDX];
92
93 default:
94 /* Pacify gcc -Wall. */
95 return NULL;
96 }
97 return NULL;
98 }
99
100 /* Map BFD reloc names to bpf ELF reloc names. */
101
102 static reloc_howto_type *
103 bpf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
104 {
105 unsigned int i;
106
107 for (i = 0; i < R_BPF_SIZE; i++)
108 if (bpf_elf_howto_table[i].name != NULL
109 && strcasecmp (bpf_elf_howto_table[i].name, r_name) == 0)
110 return &bpf_elf_howto_table[i];
111
112 return NULL;
113 }
114
115 /* Set the howto pointer for a bpf reloc. */
116
117 static bool
118 bpf_info_to_howto (bfd *abfd, arelent *bfd_reloc,
119 Elf_Internal_Rela *elf_reloc)
120 {
121 unsigned int r_type;
122 unsigned int i;
123 r_type = ELF64_R_TYPE (elf_reloc->r_info);
124
125 i = bpf_index_for_rtype(r_type);
126 if (i == (unsigned int) -1)
127 {
128 /* xgettext:c-format */
129 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
130 abfd, r_type);
131 bfd_set_error (bfd_error_bad_value);
132 return false;
133 }
134
135 bfd_reloc->howto = &bpf_elf_howto_table [i];
136 return true;
137 }
138
139 /* Relocate an eBPF ELF section.
140
141 The RELOCATE_SECTION function is called by the new ELF backend linker
142 to handle the relocations for a section.
143
144 The relocs are always passed as Rela structures; if the section
145 actually uses Rel structures, the r_addend field will always be
146 zero.
147
148 This function is responsible for adjusting the section contents as
149 necessary, and (if using Rela relocs and generating a relocatable
150 output file) adjusting the reloc addend as necessary.
151
152 This function does not have to worry about setting the reloc
153 address or the reloc symbol index.
154
155 LOCAL_SYMS is a pointer to the swapped in local symbols.
156
157 LOCAL_SECTIONS is an array giving the section in the input file
158 corresponding to the st_shndx field of each local symbol.
159
160 The global hash table entry for the global symbols can be found
161 via elf_sym_hashes (input_bfd).
162
163 When generating relocatable output, this function must handle
164 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
165 going to be the section symbol corresponding to the output
166 section, which means that the addend must be adjusted
167 accordingly. */
168
169 #define sec_addr(sec) ((sec)->output_section->vma + (sec)->output_offset)
170
171 static int
172 bpf_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
173 struct bfd_link_info *info,
174 bfd *input_bfd,
175 asection *input_section,
176 bfd_byte *contents,
177 Elf_Internal_Rela *relocs,
178 Elf_Internal_Sym *local_syms,
179 asection **local_sections)
180 {
181 Elf_Internal_Shdr *symtab_hdr;
182 struct elf_link_hash_entry **sym_hashes;
183 Elf_Internal_Rela *rel;
184 Elf_Internal_Rela *relend;
185
186 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
187 sym_hashes = elf_sym_hashes (input_bfd);
188 relend = relocs + input_section->reloc_count;
189
190 for (rel = relocs; rel < relend; rel ++)
191 {
192 reloc_howto_type * howto;
193 unsigned int howto_index;
194 unsigned long r_symndx;
195 Elf_Internal_Sym * sym;
196 asection * sec;
197 struct elf_link_hash_entry * h;
198 bfd_vma relocation;
199 bfd_reloc_status_type r;
200 const char * name = NULL;
201 int r_type ATTRIBUTE_UNUSED;
202 bfd_signed_vma addend;
203 bfd_byte * where;
204
205 r_type = ELF64_R_TYPE (rel->r_info);
206 r_symndx = ELF64_R_SYM (rel->r_info);
207
208 howto_index = bpf_index_for_rtype (ELF64_R_TYPE (rel->r_info));
209 howto = &bpf_elf_howto_table[howto_index];
210 h = NULL;
211 sym = NULL;
212 sec = NULL;
213 where = contents + rel->r_offset;
214
215 if (r_symndx < symtab_hdr->sh_info)
216 {
217 sym = local_syms + r_symndx;
218 sec = local_sections [r_symndx];
219 relocation = BASEADDR (sec) + sym->st_value;
220
221 name = bfd_elf_string_from_elf_section
222 (input_bfd, symtab_hdr->sh_link, sym->st_name);
223 name = name == NULL ? bfd_section_name (sec) : name;
224 }
225 else
226 {
227 bool warned ATTRIBUTE_UNUSED;
228 bool unresolved_reloc ATTRIBUTE_UNUSED;
229 bool ignored ATTRIBUTE_UNUSED;
230
231 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
232 r_symndx, symtab_hdr, sym_hashes,
233 h, sec, relocation,
234 unresolved_reloc, warned, ignored);
235
236 name = h->root.root.string;
237 }
238
239 if (sec != NULL && discarded_section (sec))
240 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
241 rel, 1, relend, howto, 0, contents);
242
243 if (bfd_link_relocatable (info))
244 continue;
245
246 switch (howto->type)
247 {
248 case R_BPF_64_32:
249 {
250 /* Make the relocation PC-relative, and change its unit to
251 64-bit words. Note we need *signed* arithmetic
252 here. */
253 relocation = ((bfd_signed_vma) relocation
254 - (sec_addr (input_section) + rel->r_offset));
255 relocation = (bfd_signed_vma) relocation / 8;
256
257 /* Get the addend from the instruction and apply it. */
258 addend = bfd_get (howto->bitsize, input_bfd,
259 contents + rel->r_offset
260 + (howto->bitsize == 16 ? 2 : 4));
261
262 if ((addend & (((~howto->src_mask) >> 1) & howto->src_mask)) != 0)
263 addend -= (((~howto->src_mask) >> 1) & howto->src_mask) << 1;
264 relocation += addend;
265
266 /* Write out the relocated value. */
267 bfd_put (howto->bitsize, input_bfd, relocation,
268 contents + rel->r_offset
269 + (howto->bitsize == 16 ? 2 : 4));
270
271 r = bfd_reloc_ok;
272 break;
273 }
274 case R_BPF_64_ABS64:
275 case R_BPF_64_ABS32:
276 {
277 addend = bfd_get (howto->bitsize, input_bfd, where);
278 relocation += addend;
279 bfd_put (howto->bitsize, input_bfd, relocation, where);
280
281 r = bfd_reloc_ok;
282 break;
283 }
284 case R_BPF_64_64:
285 {
286 /*
287 LDDW instructions are 128 bits long, with a 64-bit immediate.
288 The lower 32 bits of the immediate are in the same position
289 as the imm32 field of other instructions.
290 The upper 32 bits of the immediate are stored at the end of
291 the instruction.
292 */
293
294
295 /* Get the addend. The upper and lower 32 bits are split.
296 'where' is the beginning of the 16-byte instruction. */
297 addend = bfd_get_32 (input_bfd, where + 4);
298 addend |= (bfd_get_32 (input_bfd, where + 12) << 32);
299
300 relocation += addend;
301
302 bfd_put_32 (input_bfd, (relocation & 0xFFFFFFFF), where + 4);
303 bfd_put_32 (input_bfd, (relocation >> 32), where + 12);
304 r = bfd_reloc_ok;
305 break;
306 }
307 default:
308 r = bfd_reloc_notsupported;
309 }
310
311 if (r == bfd_reloc_ok)
312 r = bfd_check_overflow (howto->complain_on_overflow,
313 howto->bitsize,
314 howto->rightshift,
315 64, relocation);
316
317 if (r != bfd_reloc_ok)
318 {
319 const char * msg = NULL;
320
321 switch (r)
322 {
323 case bfd_reloc_overflow:
324 (*info->callbacks->reloc_overflow)
325 (info, (h ? &h->root : NULL), name, howto->name,
326 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
327 break;
328
329 case bfd_reloc_undefined:
330 (*info->callbacks->undefined_symbol)
331 (info, name, input_bfd, input_section, rel->r_offset, true);
332 break;
333
334 case bfd_reloc_outofrange:
335 msg = _("internal error: out of range error");
336 break;
337
338 case bfd_reloc_notsupported:
339 if (sym != NULL) /* Only if it's not an unresolved symbol. */
340 msg = _("internal error: relocation not supported");
341 break;
342
343 case bfd_reloc_dangerous:
344 msg = _("internal error: dangerous relocation");
345 break;
346
347 default:
348 msg = _("internal error: unknown error");
349 break;
350 }
351
352 if (msg)
353 (*info->callbacks->warning) (info, msg, name, input_bfd,
354 input_section, rel->r_offset);
355 }
356 }
357
358 return true;
359 }
360
361 /* Merge backend specific data from an object file to the output
362 object file when linking. */
363
364 static bool
365 elf64_bpf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
366 {
367 /* Check if we have the same endianness. */
368 if (! _bfd_generic_verify_endian_match (ibfd, info))
369 return false;
370
371 return true;
372 }
373
374 /* A generic howto special function for installing BPF relocations.
375 This function will be called by the assembler (via bfd_install_relocation),
376 and by various get_relocated_section_contents functions.
377 At link time, bpf_elf_relocate_section will resolve the final relocations.
378
379 BPF instructions are always big endian, and this approach avoids problems in
380 bfd_install_relocation. */
381
382 static bfd_reloc_status_type
383 bpf_elf_generic_reloc (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
384 void *data, asection *input_section,
385 bfd *output_bfd ATTRIBUTE_UNUSED,
386 char **error_message ATTRIBUTE_UNUSED)
387 {
388
389 bfd_signed_vma relocation;
390 bfd_reloc_status_type status;
391 bfd_byte *where;
392
393 /* Sanity check that the address is in range. */
394 bfd_size_type end = bfd_get_section_limit_octets (abfd, input_section);
395 bfd_size_type reloc_size;
396 if (reloc_entry->howto->type == R_BPF_64_64)
397 reloc_size = 16;
398 else
399 reloc_size = (reloc_entry->howto->bitsize
400 + reloc_entry->howto->bitpos) / 8;
401
402 if (reloc_entry->address > end
403 || end - reloc_entry->address < reloc_size)
404 return bfd_reloc_outofrange;
405
406 /* Get the symbol value. */
407 if (bfd_is_com_section (symbol->section))
408 relocation = 0;
409 else
410 relocation = symbol->value;
411
412 if (symbol->flags & BSF_SECTION_SYM)
413 /* Relocation against a section symbol: add in the section base address. */
414 relocation += BASEADDR (symbol->section);
415
416 relocation += reloc_entry->addend;
417
418 where = (bfd_byte *) data + reloc_entry->address;
419
420 status = bfd_check_overflow (reloc_entry->howto->complain_on_overflow,
421 reloc_entry->howto->bitsize,
422 reloc_entry->howto->rightshift, 64, relocation);
423
424 if (status != bfd_reloc_ok)
425 return status;
426
427 /* Now finally install the relocation. */
428 if (reloc_entry->howto->type == R_BPF_64_64)
429 {
430 /* lddw is a 128-bit (!) instruction that allows loading a 64-bit
431 immediate into a register. the immediate is split in half, with the
432 lower 32 bits in the same position as the imm32 field of other
433 instructions, and the upper 32 bits placed at the very end of the
434 instruction. that is, there are 32 unused bits between them. */
435
436 bfd_put_32 (abfd, (relocation & 0xFFFFFFFF), where + 4);
437 bfd_put_32 (abfd, (relocation >> 32), where + 12);
438 }
439 else
440 {
441 /* For other kinds of relocations, the relocated value simply goes
442 BITPOS bits from the start of the entry. This is always a multiple
443 of 8, i.e. whole bytes. */
444 bfd_put (reloc_entry->howto->bitsize, abfd, relocation,
445 where + reloc_entry->howto->bitpos / 8);
446 }
447
448 reloc_entry->addend = relocation;
449 reloc_entry->address += input_section->output_offset;
450
451 return bfd_reloc_ok;
452 }
453
454
455 /* The macros below configure the architecture. */
456
457 #define TARGET_LITTLE_SYM bpf_elf64_le_vec
458 #define TARGET_LITTLE_NAME "elf64-bpfle"
459
460 #define TARGET_BIG_SYM bpf_elf64_be_vec
461 #define TARGET_BIG_NAME "elf64-bpfbe"
462
463 #define ELF_ARCH bfd_arch_bpf
464 #define ELF_MACHINE_CODE EM_BPF
465
466 #define ELF_MAXPAGESIZE 0x100000
467
468 #define elf_info_to_howto_rel bpf_info_to_howto
469 #define elf_info_to_howto bpf_info_to_howto
470
471 #define elf_backend_may_use_rel_p 1
472 #define elf_backend_may_use_rela_p 0
473 #define elf_backend_default_use_rela_p 0
474 #define elf_backend_relocate_section bpf_elf_relocate_section
475
476 #define elf_backend_can_gc_sections 0
477
478 #define elf_symbol_leading_char '_'
479 #define bfd_elf64_bfd_reloc_type_lookup bpf_reloc_type_lookup
480 #define bfd_elf64_bfd_reloc_name_lookup bpf_reloc_name_lookup
481
482 #define bfd_elf64_bfd_merge_private_bfd_data elf64_bpf_merge_private_bfd_data
483
484 #include "elf64-target.h"