1 /* Adapteva epiphany specific support for 32-bit ELF
2 Copyright (C) 2000-2023 Free Software Foundation, Inc.
3 Contributed by Embecosm on behalf of Adapteva, 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/epiphany.h"
27 #include "libiberty.h"
28
29 /* Struct used to pass miscellaneous paramaters which
30 helps to avoid overly long parameter lists. */
31 struct misc
32 {
33 Elf_Internal_Shdr * symtab_hdr;
34 Elf_Internal_Rela * irelbase;
35 bfd_byte * contents;
36 Elf_Internal_Sym * isymbuf;
37 };
38
39 struct epiphany_opcode
40 {
41 unsigned short opcode;
42 unsigned short mask;
43 };
44
45 static bool epiphany_relaxed = false;
46
47 /* Relocation tables. */
48 static reloc_howto_type epiphany_elf_howto_table [] =
49 {
50 #define AHOW(t,rs,s,bs,pr,bp,co,name,sm,dm) \
51 HOWTO(t, /* type */ \
52 rs, /* rightshift */ \
53 s, /* size */ \
54 bs, /* bitsize */ \
55 pr, /* pc_relative */ \
56 bp, /* bitpos */ \
57 co, /* complain_on_overflow */ \
58 bfd_elf_generic_reloc,/* special_function */ \
59 name, /* name */ \
60 false, /* partial_inplace */ \
61 sm, /* src_mask */ \
62 dm, /* dst_mask */ \
63 pr) /* pcrel_offset */
64
65 /* This reloc does nothing. */
66 AHOW (R_EPIPHANY_NONE, 0, 0,0, false, 0, complain_overflow_dont, "R_EPIPHANY_NONE", 0, 0),
67
68 /* 8 bit absolute (not likely) */
69 AHOW (R_EPIPHANY_8, 0, 1, 8, false, 0, complain_overflow_bitfield, "R_EPIPHANY_8", 0x000000ff, 0x000000ff),
70 /* 16 bit absolute */
71 AHOW (R_EPIPHANY_16, 0, 2,16, false, 0, complain_overflow_bitfield, "R_EPIPHANY_16", 0x0000ffff, 0x00ff1fe0),
72 /* A 32 bit absolute relocation. */
73 AHOW (R_EPIPHANY_32, 0, 4,32, false, 0, complain_overflow_dont, "R_EPIPHANY_32", 0xffffffff, 0xffffffff),
74
75 /* 8 bit relative relocation */
76 HOWTO ( R_EPIPHANY_8_PCREL, 0, 1, 8, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", false, 0x000000ff, 0x000000ff, false),
77 /* 16 bit relative relocation */
78 HOWTO ( R_EPIPHANY_16_PCREL, 0, 2, 16, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", false, 0x000000ff, 0x000000ff, false),
79 /* 32 bit relative relocation */
80 HOWTO ( R_EPIPHANY_32_PCREL, 0, 4, 32, true, 0, complain_overflow_bitfield, bfd_elf_generic_reloc, "R_EPIPHANY_8_PCREL", false, 0x000000ff, 0x000000ff, false),
81
82 /* 8 bit pc-relative relocation */
83 AHOW (R_EPIPHANY_SIMM8, 1, 1, 8, true, 8, complain_overflow_signed, "R_EPIPHANY_SIMM8", 0x000000ff, 0x0000ff00),
84 /* 24 bit pc-relative relocation */
85 AHOW (R_EPIPHANY_SIMM24, 1, 4,24, true, 8, complain_overflow_signed, "R_EPIPHANY_SIMM24", 0x00ffffff, 0xffffff00),
86
87 /* %HIGH(EA) */
88 AHOW (R_EPIPHANY_HIGH, 0, 4,16, false, 0, complain_overflow_dont, "R_EPIPHANY_HIGH", 0x0ff01fe0, 0x0ff01fe0),
89
90 /* %LOW(EA) */
91 AHOW (R_EPIPHANY_LOW, 0, 4,16, false, 0, complain_overflow_dont, "R_EPIPHANY_LOW", 0x0ff01fe0, 0x0ff01fe0),
92
93 /* simm11 */
94 AHOW (R_EPIPHANY_SIMM11, 0, 4,11, false, 0, complain_overflow_bitfield, "R_EPIPHANY_SIMM11", 0x00ff0380, 0x00ff0380),
95 /* imm12 - sign-magnitude */
96 AHOW (R_EPIPHANY_IMM11, 0, 4,11, false, 0, complain_overflow_bitfield, "R_EPIPHANY_IMM12", 0x00ff0380, 0x00ff0380),
97 /* imm8 */
98 AHOW (R_EPIPHANY_IMM8, 0, 2, 8, false, 8, complain_overflow_signed, "R_EPIPHANY_IMM8", 0x0000ff00, 0x0000ff00)
99
100
101 };
102 #undef AHOW
103
104 /* Map BFD reloc types to EPIPHANY ELF reloc types. */
105
106 static reloc_howto_type *
107 epiphany_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
108 bfd_reloc_code_real_type code)
109 {
110 /* Note that the epiphany_elf_howto_table is indxed by the R_
111 constants. Thus, the order that the howto records appear in the
112 table *must* match the order of the relocation types defined in
113 include/elf/epiphany.h. */
114
115 switch (code)
116 {
117 case BFD_RELOC_NONE:
118 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_NONE];
119
120 case BFD_RELOC_EPIPHANY_SIMM8:
121 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM8];
122 case BFD_RELOC_EPIPHANY_SIMM24:
123 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM24];
124
125 case BFD_RELOC_8_PCREL:
126 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8_PCREL];
127 case BFD_RELOC_16_PCREL:
128 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16_PCREL];
129 case BFD_RELOC_32_PCREL:
130 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32_PCREL];
131
132 case BFD_RELOC_8:
133 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_8];
134 case BFD_RELOC_16:
135 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_16];
136 case BFD_RELOC_32:
137 return &epiphany_elf_howto_table[ (int) R_EPIPHANY_32];
138
139 case BFD_RELOC_EPIPHANY_HIGH:
140 return & epiphany_elf_howto_table[ (int) R_EPIPHANY_HIGH];
141 case BFD_RELOC_EPIPHANY_LOW:
142 return & epiphany_elf_howto_table[ (int) R_EPIPHANY_LOW];
143
144 case BFD_RELOC_EPIPHANY_SIMM11:
145 return & epiphany_elf_howto_table[ (int) R_EPIPHANY_SIMM11];
146 case BFD_RELOC_EPIPHANY_IMM11:
147 return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM11];
148
149 case BFD_RELOC_EPIPHANY_IMM8:
150 return & epiphany_elf_howto_table[ (int) R_EPIPHANY_IMM8];
151
152 default:
153 /* Pacify gcc -Wall. */
154 return NULL;
155 }
156 return NULL;
157 }
158
159 static reloc_howto_type *
160 epiphany_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
161 {
162 unsigned int i;
163
164 for (i = 0; i < ARRAY_SIZE (epiphany_elf_howto_table); i++)
165 if (epiphany_elf_howto_table[i].name != NULL
166 && strcasecmp (epiphany_elf_howto_table[i].name, r_name) == 0)
167 return &epiphany_elf_howto_table[i];
168
169 return NULL;
170 }
171
172 #define PAGENO(ABSADDR) ((ABSADDR) & 0xFFFFC000)
173 #define BASEADDR(SEC) ((SEC)->output_section->vma + (SEC)->output_offset)
174
175 /* This function handles relaxing for the epiphany.
176 Dummy placeholder for future optimizations. */
177
178 static bool
179 epiphany_elf_relax_section (bfd *abfd, asection *sec,
180 struct bfd_link_info *link_info,
181 bool *again)
182 {
183 Elf_Internal_Shdr *symtab_hdr;
184 Elf_Internal_Rela *internal_relocs;
185 bfd_byte *contents = NULL;
186 Elf_Internal_Sym *isymbuf = NULL;
187 static asection * first_section = NULL;
188 static unsigned long search_addr;
189 static unsigned long page_start = 0;
190 static unsigned long page_end = 0;
191 static unsigned int pass = 0;
192 static bool new_pass = false;
193 static bool changed = false;
194 struct misc misc ATTRIBUTE_UNUSED;
195 asection *stab;
196
197 /* Assume nothing changes. */
198 *again = false;
199
200 if (first_section == NULL)
201 {
202 epiphany_relaxed = true;
203 first_section = sec;
204 }
205
206 if (first_section == sec)
207 {
208 pass++;
209 new_pass = true;
210 }
211
212 /* We don't have to do anything for a relocatable link,
213 if this section does not have relocs, or if this is
214 not a code section. */
215 if (bfd_link_relocatable (link_info)
216 || sec->reloc_count == 0
217 || (sec->flags & SEC_RELOC) == 0
218 || (sec->flags & SEC_HAS_CONTENTS) == 0
219 || (sec->flags & SEC_CODE) == 0)
220 return true;
221
222 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
223
224 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
225 link_info->keep_memory);
226 if (internal_relocs == NULL)
227 goto error_return;
228
229 /* Make sure the stac.rela stuff gets read in. */
230 stab = bfd_get_section_by_name (abfd, ".stab");
231
232 if (stab)
233 {
234 /* So stab does exits. */
235 Elf_Internal_Rela * irelbase ATTRIBUTE_UNUSED;
236
237 irelbase = _bfd_elf_link_read_relocs (abfd, stab, NULL, NULL,
238 link_info->keep_memory);
239 }
240
241 /* Get section contents cached copy if it exists. */
242 if (contents == NULL)
243 {
244 /* Get cached copy if it exists. */
245 if (elf_section_data (sec)->this_hdr.contents != NULL)
246 contents = elf_section_data (sec)->this_hdr.contents;
247 else
248 {
249 /* Go get them off disk. */
250 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
251 goto error_return;
252 }
253 }
254
255 /* Read this BFD's symbols cached copy if it exists. */
256 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
257 {
258 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
259 if (isymbuf == NULL)
260 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
261 symtab_hdr->sh_info, 0,
262 NULL, NULL, NULL);
263 if (isymbuf == NULL)
264 goto error_return;
265 }
266
267 misc.symtab_hdr = symtab_hdr;
268 misc.isymbuf = isymbuf;
269 misc.irelbase = internal_relocs;
270 misc.contents = contents;
271
272 /* This is where all the relaxation actually get done. */
273 if ((pass == 1) || (new_pass && !changed))
274 {
275 /* On the first pass we simply search for the lowest page that
276 we havn't relaxed yet. Note that the pass count is reset
277 each time a page is complete in order to move on to the next page.
278 If we can't find any more pages then we are finished. */
279 if (new_pass)
280 {
281 pass = 1;
282 new_pass = false;
283 changed = true; /* Pre-initialize to break out of pass 1. */
284 search_addr = 0xFFFFFFFF;
285 }
286
287 if ((BASEADDR (sec) + sec->size < search_addr)
288 && (BASEADDR (sec) + sec->size > page_end))
289 {
290 if (BASEADDR (sec) <= page_end)
291 search_addr = page_end + 1;
292 else
293 search_addr = BASEADDR (sec);
294
295 /* Found a page => more work to do. */
296 *again = true;
297 }
298 }
299 else
300 {
301 if (new_pass)
302 {
303 new_pass = false;
304 changed = false;
305 page_start = PAGENO (search_addr);
306 page_end = page_start | 0x00003FFF;
307 }
308
309 /* Only process sections in range. */
310 if ((BASEADDR (sec) + sec->size >= page_start)
311 && (BASEADDR (sec) <= page_end))
312 {
313 #if 0
314 if (!epiphany_elf_relax_section_page (abfd, sec, &changed, &misc,
315 page_start, page_end))
316 #endif
317 return false;
318 }
319 *again = true;
320 }
321
322 /* Perform some house keeping after relaxing the section. */
323
324 if (isymbuf != NULL
325 && symtab_hdr->contents != (unsigned char *) isymbuf)
326 {
327 if (! link_info->keep_memory)
328 free (isymbuf);
329 else
330 symtab_hdr->contents = (unsigned char *) isymbuf;
331 }
332
333 if (contents != NULL
334 && elf_section_data (sec)->this_hdr.contents != contents)
335 {
336 if (! link_info->keep_memory)
337 free (contents);
338 else
339 {
340 /* Cache the section contents for elf_link_input_bfd. */
341 elf_section_data (sec)->this_hdr.contents = contents;
342 }
343 }
344
345 if (elf_section_data (sec)->relocs != internal_relocs)
346 free (internal_relocs);
347
348 return true;
349
350 error_return:
351 if (symtab_hdr->contents != (unsigned char *) isymbuf)
352 free (isymbuf);
353 if (elf_section_data (sec)->this_hdr.contents != contents)
354 free (contents);
355 if (elf_section_data (sec)->relocs != internal_relocs)
356 free (internal_relocs);
357 return false;
358 }
359
360 /* Set the howto pointer for a EPIPHANY ELF reloc. */
361
362 static bool
363 epiphany_info_to_howto_rela (bfd * abfd,
364 arelent * cache_ptr,
365 Elf_Internal_Rela * dst)
366 {
367 unsigned int r_type;
368
369 r_type = ELF32_R_TYPE (dst->r_info);
370 if (r_type >= (unsigned int) R_EPIPHANY_max)
371 {
372 /* xgettext:c-format */
373 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
374 abfd, r_type);
375 bfd_set_error (bfd_error_bad_value);
376 return false;
377 }
378 cache_ptr->howto = & epiphany_elf_howto_table [r_type];
379 return true;
380 }
381
382 /* Perform a single relocation.
383 By default we use the standard BFD routines. */
384
385 static bfd_reloc_status_type
386 epiphany_final_link_relocate (reloc_howto_type * howto,
387 bfd * input_bfd,
388 asection * input_section,
389 bfd_byte * contents,
390 Elf_Internal_Rela * rel,
391 bfd_vma relocation)
392 {
393 switch (howto->type)
394 {
395 /* Handle 16 bit immediates. */
396 case R_EPIPHANY_HIGH:
397 relocation += rel->r_addend;
398 relocation >>= 16;
399 goto common;
400
401 case R_EPIPHANY_LOW:
402 relocation += rel->r_addend;
403 common:
404 relocation = ((relocation & 0xff00L) << 12)
405 | ((relocation & 0x00ffL) << 5);
406 /* Sanity check the address. */
407 if (rel->r_offset > bfd_get_section_limit (input_bfd, input_section))
408 return bfd_reloc_outofrange;
409
410 return _bfd_relocate_contents (howto, input_bfd, relocation,
411 contents + rel->r_offset);
412
413 case R_EPIPHANY_SIMM11:
414 relocation += rel->r_addend;
415 /* Check signed overflow. */
416 if ((int)relocation > 1023 || (int)relocation < -1024)
417 return bfd_reloc_outofrange;
418 goto disp11;
419
420 case R_EPIPHANY_IMM11:
421 relocation += rel->r_addend;
422 if ((unsigned int) relocation > 0x7ff)
423 return bfd_reloc_outofrange;
424 /* Fall through. */
425 disp11:
426 relocation = (((relocation & 7) << 5)
427 | ((relocation & 0x7f8 ) << 13));
428 return _bfd_relocate_contents (howto, input_bfd, relocation,
429 contents + rel->r_offset);
430
431 /* Pass others through. */
432 default:
433 break;
434 }
435
436 /* Only install relocation if above tests did not disqualify it. */
437 return _bfd_final_link_relocate (howto, input_bfd, input_section,
438 contents, rel->r_offset,
439 relocation, rel->r_addend);
440 }
441
442 /* Relocate an EPIPHANY ELF section.
443
444 The RELOCATE_SECTION function is called by the new ELF backend linker
445 to handle the relocations for a section.
446
447 The relocs are always passed as Rela structures; if the section
448 actually uses Rel structures, the r_addend field will always be
449 zero.
450
451 This function is responsible for adjusting the section contents as
452 necessary, and (if using Rela relocs and generating a relocatable
453 output file) adjusting the reloc addend as necessary.
454
455 This function does not have to worry about setting the reloc
456 address or the reloc symbol index.
457
458 LOCAL_SYMS is a pointer to the swapped in local symbols.
459
460 LOCAL_SECTIONS is an array giving the section in the input file
461 corresponding to the st_shndx field of each local symbol.
462
463 The global hash table entry for the global symbols can be found
464 via elf_sym_hashes (input_bfd).
465
466 When generating relocatable output, this function must handle
467 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
468 going to be the section symbol corresponding to the output
469 section, which means that the addend must be adjusted
470 accordingly. */
471
472 static int
473 epiphany_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
474 struct bfd_link_info *info,
475 bfd *input_bfd,
476 asection *input_section,
477 bfd_byte *contents,
478 Elf_Internal_Rela *relocs,
479 Elf_Internal_Sym *local_syms,
480 asection **local_sections)
481 {
482 Elf_Internal_Shdr *symtab_hdr;
483 struct elf_link_hash_entry **sym_hashes;
484 Elf_Internal_Rela *rel;
485 Elf_Internal_Rela *relend;
486
487 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
488 sym_hashes = elf_sym_hashes (input_bfd);
489 relend = relocs + input_section->reloc_count;
490
491 for (rel = relocs; rel < relend; rel ++)
492 {
493 reloc_howto_type * howto;
494 unsigned long r_symndx;
495 Elf_Internal_Sym * sym;
496 asection * sec;
497 struct elf_link_hash_entry * h;
498 bfd_vma relocation;
499 bfd_reloc_status_type r;
500 const char * name = NULL;
501 int r_type ATTRIBUTE_UNUSED;
502
503 r_type = ELF32_R_TYPE (rel->r_info);
504 r_symndx = ELF32_R_SYM (rel->r_info);
505 howto = epiphany_elf_howto_table + ELF32_R_TYPE (rel->r_info);
506 h = NULL;
507 sym = NULL;
508 sec = NULL;
509
510 if (r_symndx < symtab_hdr->sh_info)
511 {
512 sym = local_syms + r_symndx;
513 sec = local_sections [r_symndx];
514 relocation = BASEADDR (sec) + sym->st_value;
515
516 name = bfd_elf_string_from_elf_section
517 (input_bfd, symtab_hdr->sh_link, sym->st_name);
518 name = name == NULL ? bfd_section_name (sec) : name;
519 }
520 else
521 {
522 bool warned ATTRIBUTE_UNUSED;
523 bool unresolved_reloc ATTRIBUTE_UNUSED;
524 bool ignored ATTRIBUTE_UNUSED;
525
526 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
527 r_symndx, symtab_hdr, sym_hashes,
528 h, sec, relocation,
529 unresolved_reloc, warned, ignored);
530
531 name = h->root.root.string;
532 }
533
534 if (sec != NULL && discarded_section (sec))
535 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
536 rel, 1, relend, howto, 0, contents);
537
538 if (bfd_link_relocatable (info))
539 continue;
540
541 /* Finally, the sole EPIPHANY-specific part. */
542 r = epiphany_final_link_relocate (howto, input_bfd, input_section,
543 contents, rel, relocation);
544
545 if (r != bfd_reloc_ok)
546 {
547 const char * msg = NULL;
548
549 switch (r)
550 {
551 case bfd_reloc_overflow:
552 (*info->callbacks->reloc_overflow)
553 (info, (h ? &h->root : NULL), name, howto->name,
554 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
555 break;
556
557 case bfd_reloc_undefined:
558 (*info->callbacks->undefined_symbol)
559 (info, name, input_bfd, input_section, rel->r_offset, true);
560 break;
561
562 case bfd_reloc_outofrange:
563 msg = _("internal error: out of range error");
564 break;
565
566 /* This is how epiphany_final_link_relocate tells us of a
567 non-kosher reference between insn & data address spaces. */
568 case bfd_reloc_notsupported:
569 if (sym != NULL) /* Only if it's not an unresolved symbol. */
570 msg = _("unsupported relocation between data/insn address spaces");
571 break;
572
573 case bfd_reloc_dangerous:
574 msg = _("internal error: dangerous relocation");
575 break;
576
577 default:
578 msg = _("internal error: unknown error");
579 break;
580 }
581
582 if (msg)
583 (*info->callbacks->warning) (info, msg, name, input_bfd,
584 input_section, rel->r_offset);
585 }
586 }
587
588 return true;
589 }
590
591 /* We only have a little-endian target. */
592 #define TARGET_LITTLE_SYM epiphany_elf32_vec
593 #define TARGET_LITTLE_NAME "elf32-epiphany"
594
595 #define ELF_ARCH bfd_arch_epiphany
596 #define ELF_MACHINE_CODE EM_ADAPTEVA_EPIPHANY
597
598 #define ELF_MAXPAGESIZE 0x8000 /* No pages on the EPIPHANY. */
599
600 #define elf_info_to_howto_rel NULL
601 #define elf_info_to_howto epiphany_info_to_howto_rela
602
603 #define elf_backend_can_gc_sections 1
604 #define elf_backend_rela_normal 1
605 #define elf_backend_relocate_section epiphany_elf_relocate_section
606
607 #define elf_symbol_leading_char '_'
608 #define bfd_elf32_bfd_reloc_type_lookup epiphany_reloc_type_lookup
609 #define bfd_elf32_bfd_reloc_name_lookup epiphany_reloc_name_lookup
610 #define bfd_elf32_bfd_relax_section epiphany_elf_relax_section
611
612 #include "elf32-target.h"