]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-nios2.c
projects / thirdparty / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Automatic date update in version.in
[thirdparty/binutils-gdb.git] / bfd / elf32-nios2.c
1 /* 32-bit ELF support for Nios II.
2 Copyright (C) 2012-2020 Free Software Foundation, Inc.
3 Contributed by Nigel Gray (ngray@altera.com).
4 Contributed by Mentor Graphics, Inc.
5
6 This file is part of BFD, the Binary File Descriptor library.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
21 MA 02110-1301, USA. */
22
23 /* This file handles Altera Nios II ELF targets. */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "libbfd.h"
28 #include "bfdlink.h"
29 #include "genlink.h"
30 #include "elf-bfd.h"
31 #include "elf/nios2.h"
32 #include "opcode/nios2.h"
33 #include "elf32-nios2.h"
34 #include "libiberty.h"
35
36 /* Use RELA relocations. */
37 #ifndef USE_RELA
38 #define USE_RELA
39 #endif
40
41 #ifdef USE_REL
42 #undef USE_REL
43 #endif
44
45 /* Forward declarations. */
46 static bfd_reloc_status_type nios2_elf32_ignore_reloc
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type nios2_elf32_hi16_relocate
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type nios2_elf32_lo16_relocate
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
57 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
58 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
59 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
60 static bfd_reloc_status_type nios2_elf32_call26_relocate
61 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
62 static bfd_reloc_status_type nios2_elf32_gprel_relocate
63 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
64 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
65 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
66 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
67 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
68 static bfd_reloc_status_type nios2_elf32_callr_relocate
69 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
70
71 /* Target vector. */
72 extern const bfd_target nios2_elf32_le_vec;
73 extern const bfd_target nios2_elf32_be_vec;
74
75 /* Offset of tp and dtp pointers from start of TLS block. */
76 #define TP_OFFSET 0x7000
77 #define DTP_OFFSET 0x8000
78
79 /* The relocation tables used for SHT_REL sections. There are separate
80 tables for R1 and R2 encodings. */
81 static reloc_howto_type elf_nios2_r1_howto_table_rel[] = {
82 /* No relocation. */
83 HOWTO (R_NIOS2_NONE, /* type */
84 0, /* rightshift */
85 3, /* size (0 = byte, 1 = short, 2 = long) */
86 0, /* bitsize */
87 FALSE, /* pc_relative */
88 0, /* bitpos */
89 complain_overflow_dont, /* complain_on_overflow */
90 bfd_elf_generic_reloc, /* special_function */
91 "R_NIOS2_NONE", /* name */
92 FALSE, /* partial_inplace */
93 0, /* src_mask */
94 0, /* dst_mask */
95 FALSE), /* pcrel_offset */
96
97 /* 16-bit signed immediate relocation. */
98 HOWTO (R_NIOS2_S16, /* type */
99 0, /* rightshift */
100 2, /* size (0 = byte, 1 = short, 2 = long) */
101 16, /* bitsize */
102 FALSE, /* pc_relative */
103 6, /* bitpos */
104 complain_overflow_signed, /* complain on overflow */
105 bfd_elf_generic_reloc, /* special function */
106 "R_NIOS2_S16", /* name */
107 FALSE, /* partial_inplace */
108 0x003fffc0, /* src_mask */
109 0x003fffc0, /* dest_mask */
110 FALSE), /* pcrel_offset */
111
112 /* 16-bit unsigned immediate relocation. */
113 HOWTO (R_NIOS2_U16, /* type */
114 0, /* rightshift */
115 2, /* size (0 = byte, 1 = short, 2 = long) */
116 16, /* bitsize */
117 FALSE, /* pc_relative */
118 6, /* bitpos */
119 complain_overflow_unsigned, /* complain on overflow */
120 bfd_elf_generic_reloc, /* special function */
121 "R_NIOS2_U16", /* name */
122 FALSE, /* partial_inplace */
123 0x003fffc0, /* src_mask */
124 0x003fffc0, /* dest_mask */
125 FALSE), /* pcrel_offset */
126
127 HOWTO (R_NIOS2_PCREL16, /* type */
128 0, /* rightshift */
129 2, /* size (0 = byte, 1 = short, 2 = long) */
130 16, /* bitsize */
131 TRUE, /* pc_relative */
132 6, /* bitpos */
133 complain_overflow_signed, /* complain on overflow */
134 nios2_elf32_pcrel16_relocate, /* special function */
135 "R_NIOS2_PCREL16", /* name */
136 FALSE, /* partial_inplace */
137 0x003fffc0, /* src_mask */
138 0x003fffc0, /* dest_mask */
139 TRUE), /* pcrel_offset */
140
141 HOWTO (R_NIOS2_CALL26, /* type */
142 2, /* rightshift */
143 2, /* size (0 = byte, 1 = short, 2 = long) */
144 26, /* bitsize */
145 FALSE, /* pc_relative */
146 6, /* bitpos */
147 complain_overflow_dont, /* complain on overflow */
148 nios2_elf32_call26_relocate, /* special function */
149 "R_NIOS2_CALL26", /* name */
150 FALSE, /* partial_inplace */
151 0xffffffc0, /* src_mask */
152 0xffffffc0, /* dst_mask */
153 FALSE), /* pcrel_offset */
154
155 HOWTO (R_NIOS2_IMM5,
156 0,
157 2,
158 5,
159 FALSE,
160 6,
161 complain_overflow_bitfield,
162 bfd_elf_generic_reloc,
163 "R_NIOS2_IMM5",
164 FALSE,
165 0x000007c0,
166 0x000007c0,
167 FALSE),
168
169 HOWTO (R_NIOS2_CACHE_OPX,
170 0,
171 2,
172 5,
173 FALSE,
174 22,
175 complain_overflow_bitfield,
176 bfd_elf_generic_reloc,
177 "R_NIOS2_CACHE_OPX",
178 FALSE,
179 0x07c00000,
180 0x07c00000,
181 FALSE),
182
183 HOWTO (R_NIOS2_IMM6,
184 0,
185 2,
186 6,
187 FALSE,
188 6,
189 complain_overflow_bitfield,
190 bfd_elf_generic_reloc,
191 "R_NIOS2_IMM6",
192 FALSE,
193 0x00000fc0,
194 0x00000fc0,
195 FALSE),
196
197 HOWTO (R_NIOS2_IMM8,
198 0,
199 2,
200 8,
201 FALSE,
202 6,
203 complain_overflow_bitfield,
204 bfd_elf_generic_reloc,
205 "R_NIOS2_IMM8",
206 FALSE,
207 0x00003fc0,
208 0x00003fc0,
209 FALSE),
210
211 HOWTO (R_NIOS2_HI16,
212 0,
213 2,
214 32,
215 FALSE,
216 6,
217 complain_overflow_dont,
218 nios2_elf32_hi16_relocate,
219 "R_NIOS2_HI16",
220 FALSE,
221 0x003fffc0,
222 0x003fffc0,
223 FALSE),
224
225 HOWTO (R_NIOS2_LO16,
226 0,
227 2,
228 32,
229 FALSE,
230 6,
231 complain_overflow_dont,
232 nios2_elf32_lo16_relocate,
233 "R_NIOS2_LO16",
234 FALSE,
235 0x003fffc0,
236 0x003fffc0,
237 FALSE),
238
239 HOWTO (R_NIOS2_HIADJ16,
240 0,
241 2,
242 32,
243 FALSE,
244 6,
245 complain_overflow_dont,
246 nios2_elf32_hiadj16_relocate,
247 "R_NIOS2_HIADJ16",
248 FALSE,
249 0x003fffc0,
250 0x003fffc0,
251 FALSE),
252
253 HOWTO (R_NIOS2_BFD_RELOC_32,
254 0,
255 2, /* long */
256 32,
257 FALSE,
258 0,
259 complain_overflow_dont,
260 bfd_elf_generic_reloc,
261 "R_NIOS2_BFD_RELOC32",
262 FALSE,
263 0xffffffff,
264 0xffffffff,
265 FALSE),
266
267 HOWTO (R_NIOS2_BFD_RELOC_16,
268 0,
269 1, /* short */
270 16,
271 FALSE,
272 0,
273 complain_overflow_bitfield,
274 bfd_elf_generic_reloc,
275 "R_NIOS2_BFD_RELOC16",
276 FALSE,
277 0x0000ffff,
278 0x0000ffff,
279 FALSE),
280
281 HOWTO (R_NIOS2_BFD_RELOC_8,
282 0,
283 0, /* byte */
284 8,
285 FALSE,
286 0,
287 complain_overflow_bitfield,
288 bfd_elf_generic_reloc,
289 "R_NIOS2_BFD_RELOC8",
290 FALSE,
291 0x000000ff,
292 0x000000ff,
293 FALSE),
294
295 HOWTO (R_NIOS2_GPREL,
296 0,
297 2,
298 32,
299 FALSE,
300 6,
301 complain_overflow_dont,
302 nios2_elf32_gprel_relocate,
303 "R_NIOS2_GPREL",
304 FALSE,
305 0x003fffc0,
306 0x003fffc0,
307 FALSE),
308
309 HOWTO (R_NIOS2_GNU_VTINHERIT,
310 0,
311 2, /* short */
312 0,
313 FALSE,
314 0,
315 complain_overflow_dont,
316 NULL,
317 "R_NIOS2_GNU_VTINHERIT",
318 FALSE,
319 0,
320 0,
321 FALSE),
322
323 HOWTO (R_NIOS2_GNU_VTENTRY,
324 0,
325 2, /* byte */
326 0,
327 FALSE,
328 0,
329 complain_overflow_dont,
330 _bfd_elf_rel_vtable_reloc_fn,
331 "R_NIOS2_GNU_VTENTRY",
332 FALSE,
333 0,
334 0,
335 FALSE),
336
337 HOWTO (R_NIOS2_UJMP,
338 0,
339 2,
340 32,
341 FALSE,
342 6,
343 complain_overflow_dont,
344 nios2_elf32_ujmp_relocate,
345 "R_NIOS2_UJMP",
346 FALSE,
347 0x003fffc0,
348 0x003fffc0,
349 FALSE),
350
351 HOWTO (R_NIOS2_CJMP,
352 0,
353 2,
354 32,
355 FALSE,
356 6,
357 complain_overflow_dont,
358 nios2_elf32_cjmp_relocate,
359 "R_NIOS2_CJMP",
360 FALSE,
361 0x003fffc0,
362 0x003fffc0,
363 FALSE),
364
365 HOWTO (R_NIOS2_CALLR,
366 0,
367 2,
368 32,
369 FALSE,
370 6,
371 complain_overflow_dont,
372 nios2_elf32_callr_relocate,
373 "R_NIOS2_CALLR",
374 FALSE,
375 0x003fffc0,
376 0x003fffc0,
377 FALSE),
378
379 HOWTO (R_NIOS2_ALIGN,
380 0,
381 2,
382 0,
383 FALSE,
384 0,
385 complain_overflow_dont,
386 nios2_elf32_ignore_reloc,
387 "R_NIOS2_ALIGN",
388 FALSE,
389 0,
390 0,
391 TRUE),
392
393
394 HOWTO (R_NIOS2_GOT16,
395 0,
396 2,
397 16,
398 FALSE,
399 6,
400 complain_overflow_bitfield,
401 bfd_elf_generic_reloc,
402 "R_NIOS2_GOT16",
403 FALSE,
404 0x003fffc0,
405 0x003fffc0,
406 FALSE),
407
408 HOWTO (R_NIOS2_CALL16,
409 0,
410 2,
411 16,
412 FALSE,
413 6,
414 complain_overflow_bitfield,
415 bfd_elf_generic_reloc,
416 "R_NIOS2_CALL16",
417 FALSE,
418 0x003fffc0,
419 0x003fffc0,
420 FALSE),
421
422 HOWTO (R_NIOS2_GOTOFF_LO,
423 0,
424 2,
425 16,
426 FALSE,
427 6,
428 complain_overflow_dont,
429 bfd_elf_generic_reloc,
430 "R_NIOS2_GOTOFF_LO",
431 FALSE,
432 0x003fffc0,
433 0x003fffc0,
434 FALSE),
435
436 HOWTO (R_NIOS2_GOTOFF_HA,
437 0,
438 2,
439 16,
440 FALSE,
441 6,
442 complain_overflow_dont,
443 bfd_elf_generic_reloc,
444 "R_NIOS2_GOTOFF_HA",
445 FALSE,
446 0x003fffc0,
447 0x003fffc0,
448 FALSE),
449
450 HOWTO (R_NIOS2_PCREL_LO,
451 0,
452 2,
453 16,
454 TRUE,
455 6,
456 complain_overflow_dont,
457 nios2_elf32_pcrel_lo16_relocate,
458 "R_NIOS2_PCREL_LO",
459 FALSE,
460 0x003fffc0,
461 0x003fffc0,
462 TRUE),
463
464 HOWTO (R_NIOS2_PCREL_HA,
465 0,
466 2,
467 16,
468 FALSE, /* This is a PC-relative relocation, but we need to subtract
469 PC ourselves before the HIADJ. */
470 6,
471 complain_overflow_dont,
472 nios2_elf32_pcrel_hiadj16_relocate,
473 "R_NIOS2_PCREL_HA",
474 FALSE,
475 0x003fffc0,
476 0x003fffc0,
477 TRUE),
478
479 HOWTO (R_NIOS2_TLS_GD16,
480 0,
481 2,
482 16,
483 FALSE,
484 6,
485 complain_overflow_bitfield,
486 bfd_elf_generic_reloc,
487 "R_NIOS2_TLS_GD16",
488 FALSE,
489 0x003fffc0,
490 0x003fffc0,
491 FALSE),
492
493 HOWTO (R_NIOS2_TLS_LDM16,
494 0,
495 2,
496 16,
497 FALSE,
498 6,
499 complain_overflow_bitfield,
500 bfd_elf_generic_reloc,
501 "R_NIOS2_TLS_LDM16",
502 FALSE,
503 0x003fffc0,
504 0x003fffc0,
505 FALSE),
506
507 HOWTO (R_NIOS2_TLS_LDO16,
508 0,
509 2,
510 16,
511 FALSE,
512 6,
513 complain_overflow_bitfield,
514 bfd_elf_generic_reloc,
515 "R_NIOS2_TLS_LDO16",
516 FALSE,
517 0x003fffc0,
518 0x003fffc0,
519 FALSE),
520
521 HOWTO (R_NIOS2_TLS_IE16,
522 0,
523 2,
524 16,
525 FALSE,
526 6,
527 complain_overflow_bitfield,
528 bfd_elf_generic_reloc,
529 "R_NIOS2_TLS_IE16",
530 FALSE,
531 0x003fffc0,
532 0x003fffc0,
533 FALSE),
534
535 HOWTO (R_NIOS2_TLS_LE16,
536 0,
537 2,
538 16,
539 FALSE,
540 6,
541 complain_overflow_bitfield,
542 bfd_elf_generic_reloc,
543 "R_NIOS2_TLS_LE16",
544 FALSE,
545 0x003fffc0,
546 0x003fffc0,
547 FALSE),
548
549 HOWTO (R_NIOS2_TLS_DTPMOD,
550 0,
551 2,
552 32,
553 FALSE,
554 0,
555 complain_overflow_dont,
556 bfd_elf_generic_reloc,
557 "R_NIOS2_TLS_DTPMOD",
558 FALSE,
559 0xffffffff,
560 0xffffffff,
561 FALSE),
562
563 HOWTO (R_NIOS2_TLS_DTPREL,
564 0,
565 2,
566 32,
567 FALSE,
568 0,
569 complain_overflow_dont,
570 bfd_elf_generic_reloc,
571 "R_NIOS2_TLS_DTPREL",
572 FALSE,
573 0xffffffff,
574 0xffffffff,
575 FALSE),
576
577 HOWTO (R_NIOS2_TLS_TPREL,
578 0,
579 2,
580 32,
581 FALSE,
582 0,
583 complain_overflow_dont,
584 bfd_elf_generic_reloc,
585 "R_NIOS2_TLS_TPREL",
586 FALSE,
587 0xffffffff,
588 0xffffffff,
589 FALSE),
590
591 HOWTO (R_NIOS2_COPY,
592 0,
593 2,
594 32,
595 FALSE,
596 0,
597 complain_overflow_dont,
598 bfd_elf_generic_reloc,
599 "R_NIOS2_COPY",
600 FALSE,
601 0,
602 0,
603 FALSE),
604
605 HOWTO (R_NIOS2_GLOB_DAT,
606 0,
607 2,
608 32,
609 FALSE,
610 0,
611 complain_overflow_dont,
612 bfd_elf_generic_reloc,
613 "R_NIOS2_GLOB_DAT",
614 FALSE,
615 0xffffffff,
616 0xffffffff,
617 FALSE),
618
619 HOWTO (R_NIOS2_JUMP_SLOT,
620 0,
621 2,
622 32,
623 FALSE,
624 0,
625 complain_overflow_dont,
626 bfd_elf_generic_reloc,
627 "R_NIOS2_JUMP_SLOT",
628 FALSE,
629 0xffffffff,
630 0xffffffff,
631 FALSE),
632
633 HOWTO (R_NIOS2_RELATIVE,
634 0,
635 2,
636 32,
637 FALSE,
638 0,
639 complain_overflow_dont,
640 bfd_elf_generic_reloc,
641 "R_NIOS2_RELATIVE",
642 FALSE,
643 0xffffffff,
644 0xffffffff,
645 FALSE),
646
647 HOWTO (R_NIOS2_GOTOFF,
648 0,
649 2,
650 32,
651 FALSE,
652 0,
653 complain_overflow_dont,
654 bfd_elf_generic_reloc,
655 "R_NIOS2_GOTOFF",
656 FALSE,
657 0xffffffff,
658 0xffffffff,
659 FALSE),
660
661 HOWTO (R_NIOS2_CALL26_NOAT, /* type */
662 2, /* rightshift */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
664 26, /* bitsize */
665 FALSE, /* pc_relative */
666 6, /* bitpos */
667 complain_overflow_dont, /* complain on overflow */
668 nios2_elf32_call26_relocate, /* special function */
669 "R_NIOS2_CALL26_NOAT", /* name */
670 FALSE, /* partial_inplace */
671 0xffffffc0, /* src_mask */
672 0xffffffc0, /* dst_mask */
673 FALSE), /* pcrel_offset */
674
675 HOWTO (R_NIOS2_GOT_LO,
676 0,
677 2,
678 16,
679 FALSE,
680 6,
681 complain_overflow_dont,
682 bfd_elf_generic_reloc,
683 "R_NIOS2_GOT_LO",
684 FALSE,
685 0x003fffc0,
686 0x003fffc0,
687 FALSE),
688
689 HOWTO (R_NIOS2_GOT_HA,
690 0,
691 2,
692 16,
693 FALSE,
694 6,
695 complain_overflow_dont,
696 bfd_elf_generic_reloc,
697 "R_NIOS2_GOT_HA",
698 FALSE,
699 0x003fffc0,
700 0x003fffc0,
701 FALSE),
702
703 HOWTO (R_NIOS2_CALL_LO,
704 0,
705 2,
706 16,
707 FALSE,
708 6,
709 complain_overflow_dont,
710 bfd_elf_generic_reloc,
711 "R_NIOS2_CALL_LO",
712 FALSE,
713 0x003fffc0,
714 0x003fffc0,
715 FALSE),
716
717 HOWTO (R_NIOS2_CALL_HA,
718 0,
719 2,
720 16,
721 FALSE,
722 6,
723 complain_overflow_dont,
724 bfd_elf_generic_reloc,
725 "R_NIOS2_CALL_HA",
726 FALSE,
727 0x003fffc0,
728 0x003fffc0,
729 FALSE),
730
731 /* Add other relocations here. */
732 };
733
734 static reloc_howto_type elf_nios2_r2_howto_table_rel[] = {
735 /* No relocation. */
736 HOWTO (R_NIOS2_NONE, /* type */
737 0, /* rightshift */
738 0, /* size (0 = byte, 1 = short, 2 = long) */
739 0, /* bitsize */
740 FALSE, /* pc_relative */
741 0, /* bitpos */
742 complain_overflow_dont, /* complain_on_overflow */
743 bfd_elf_generic_reloc, /* special_function */
744 "R_NIOS2_NONE", /* name */
745 FALSE, /* partial_inplace */
746 0, /* src_mask */
747 0, /* dst_mask */
748 FALSE), /* pcrel_offset */
749
750 /* 16-bit signed immediate relocation. */
751 HOWTO (R_NIOS2_S16, /* type */
752 0, /* rightshift */
753 2, /* size (0 = byte, 1 = short, 2 = long) */
754 16, /* bitsize */
755 FALSE, /* pc_relative */
756 16, /* bitpos */
757 complain_overflow_signed, /* complain on overflow */
758 bfd_elf_generic_reloc, /* special function */
759 "R_NIOS2_S16", /* name */
760 FALSE, /* partial_inplace */
761 0xffff0000, /* src_mask */
762 0xffff0000, /* dest_mask */
763 FALSE), /* pcrel_offset */
764
765 /* 16-bit unsigned immediate relocation. */
766 HOWTO (R_NIOS2_U16, /* type */
767 0, /* rightshift */
768 2, /* size (0 = byte, 1 = short, 2 = long) */
769 16, /* bitsize */
770 FALSE, /* pc_relative */
771 16, /* bitpos */
772 complain_overflow_unsigned, /* complain on overflow */
773 bfd_elf_generic_reloc, /* special function */
774 "R_NIOS2_U16", /* name */
775 FALSE, /* partial_inplace */
776 0xffff0000, /* src_mask */
777 0xffff0000, /* dest_mask */
778 FALSE), /* pcrel_offset */
779
780 HOWTO (R_NIOS2_PCREL16, /* type */
781 0, /* rightshift */
782 2, /* size (0 = byte, 1 = short, 2 = long) */
783 16, /* bitsize */
784 TRUE, /* pc_relative */
785 16, /* bitpos */
786 complain_overflow_signed, /* complain on overflow */
787 nios2_elf32_pcrel16_relocate, /* special function */
788 "R_NIOS2_PCREL16", /* name */
789 FALSE, /* partial_inplace */
790 0xffff0000, /* src_mask */
791 0xffff0000, /* dest_mask */
792 TRUE), /* pcrel_offset */
793
794 HOWTO (R_NIOS2_CALL26, /* type */
795 2, /* rightshift */
796 2, /* size (0 = byte, 1 = short, 2 = long) */
797 26, /* bitsize */
798 FALSE, /* pc_relative */
799 6, /* bitpos */
800 complain_overflow_dont, /* complain on overflow */
801 nios2_elf32_call26_relocate, /* special function */
802 "R_NIOS2_CALL26", /* name */
803 FALSE, /* partial_inplace */
804 0xffffffc0, /* src_mask */
805 0xffffffc0, /* dst_mask */
806 FALSE), /* pcrel_offset */
807
808 HOWTO (R_NIOS2_IMM5,
809 0,
810 2,
811 5,
812 FALSE,
813 21,
814 complain_overflow_bitfield,
815 bfd_elf_generic_reloc,
816 "R_NIOS2_IMM5",
817 FALSE,
818 0x03e00000,
819 0x03e00000,
820 FALSE),
821
822 HOWTO (R_NIOS2_CACHE_OPX,
823 0,
824 2,
825 5,
826 FALSE,
827 11,
828 complain_overflow_bitfield,
829 bfd_elf_generic_reloc,
830 "R_NIOS2_CACHE_OPX",
831 FALSE,
832 0x0000f800,
833 0x0000f800,
834 FALSE),
835
836 HOWTO (R_NIOS2_IMM6,
837 0,
838 2,
839 6,
840 FALSE,
841 26,
842 complain_overflow_bitfield,
843 bfd_elf_generic_reloc,
844 "R_NIOS2_IMM6",
845 FALSE,
846 0xfc000000,
847 0xfc000000,
848 FALSE),
849
850 HOWTO (R_NIOS2_IMM8,
851 0,
852 2,
853 8,
854 FALSE,
855 24,
856 complain_overflow_bitfield,
857 bfd_elf_generic_reloc,
858 "R_NIOS2_IMM8",
859 FALSE,
860 0xff000000,
861 0xff000000,
862 FALSE),
863
864 HOWTO (R_NIOS2_HI16,
865 0,
866 2,
867 32,
868 FALSE,
869 16,
870 complain_overflow_dont,
871 nios2_elf32_hi16_relocate,
872 "R_NIOS2_HI16",
873 FALSE,
874 0xffff0000,
875 0xffff0000,
876 FALSE),
877
878 HOWTO (R_NIOS2_LO16,
879 0,
880 2,
881 32,
882 FALSE,
883 16,
884 complain_overflow_dont,
885 nios2_elf32_lo16_relocate,
886 "R_NIOS2_LO16",
887 FALSE,
888 0xffff0000,
889 0xffff0000,
890 FALSE),
891
892 HOWTO (R_NIOS2_HIADJ16,
893 0,
894 2,
895 32,
896 FALSE,
897 16,
898 complain_overflow_dont,
899 nios2_elf32_hiadj16_relocate,
900 "R_NIOS2_HIADJ16",
901 FALSE,
902 0xffff0000,
903 0xffff0000,
904 FALSE),
905
906 HOWTO (R_NIOS2_BFD_RELOC_32,
907 0,
908 2, /* long */
909 32,
910 FALSE,
911 0,
912 complain_overflow_dont,
913 bfd_elf_generic_reloc,
914 "R_NIOS2_BFD_RELOC32",
915 FALSE,
916 0xffffffff,
917 0xffffffff,
918 FALSE),
919
920 HOWTO (R_NIOS2_BFD_RELOC_16,
921 0,
922 1, /* short */
923 16,
924 FALSE,
925 0,
926 complain_overflow_bitfield,
927 bfd_elf_generic_reloc,
928 "R_NIOS2_BFD_RELOC16",
929 FALSE,
930 0x0000ffff,
931 0x0000ffff,
932 FALSE),
933
934 HOWTO (R_NIOS2_BFD_RELOC_8,
935 0,
936 0, /* byte */
937 8,
938 FALSE,
939 0,
940 complain_overflow_bitfield,
941 bfd_elf_generic_reloc,
942 "R_NIOS2_BFD_RELOC8",
943 FALSE,
944 0x000000ff,
945 0x000000ff,
946 FALSE),
947
948 HOWTO (R_NIOS2_GPREL,
949 0,
950 2,
951 32,
952 FALSE,
953 16,
954 complain_overflow_dont,
955 nios2_elf32_gprel_relocate,
956 "R_NIOS2_GPREL",
957 FALSE,
958 0xffff0000,
959 0xffff0000,
960 FALSE),
961
962 HOWTO (R_NIOS2_GNU_VTINHERIT,
963 0,
964 2, /* short */
965 0,
966 FALSE,
967 0,
968 complain_overflow_dont,
969 NULL,
970 "R_NIOS2_GNU_VTINHERIT",
971 FALSE,
972 0,
973 0,
974 FALSE),
975
976 HOWTO (R_NIOS2_GNU_VTENTRY,
977 0,
978 2, /* byte */
979 0,
980 FALSE,
981 0,
982 complain_overflow_dont,
983 _bfd_elf_rel_vtable_reloc_fn,
984 "R_NIOS2_GNU_VTENTRY",
985 FALSE,
986 0,
987 0,
988 FALSE),
989
990 HOWTO (R_NIOS2_UJMP,
991 0,
992 2,
993 32,
994 FALSE,
995 16,
996 complain_overflow_dont,
997 nios2_elf32_ujmp_relocate,
998 "R_NIOS2_UJMP",
999 FALSE,
1000 0xffff0000,
1001 0xffff0000,
1002 FALSE),
1003
1004 HOWTO (R_NIOS2_CJMP,
1005 0,
1006 2,
1007 32,
1008 FALSE,
1009 16,
1010 complain_overflow_dont,
1011 nios2_elf32_cjmp_relocate,
1012 "R_NIOS2_CJMP",
1013 FALSE,
1014 0xffff0000,
1015 0xffff0000,
1016 FALSE),
1017
1018 HOWTO (R_NIOS2_CALLR,
1019 0,
1020 2,
1021 32,
1022 FALSE,
1023 16,
1024 complain_overflow_dont,
1025 nios2_elf32_callr_relocate,
1026 "R_NIOS2_CALLR",
1027 FALSE,
1028 0xffff0000,
1029 0xffff0000,
1030 FALSE),
1031
1032 HOWTO (R_NIOS2_ALIGN,
1033 0,
1034 2,
1035 0,
1036 FALSE,
1037 0,
1038 complain_overflow_dont,
1039 nios2_elf32_ignore_reloc,
1040 "R_NIOS2_ALIGN",
1041 FALSE,
1042 0,
1043 0,
1044 TRUE),
1045
1046 HOWTO (R_NIOS2_GOT16,
1047 0,
1048 2,
1049 16,
1050 FALSE,
1051 16,
1052 complain_overflow_bitfield,
1053 bfd_elf_generic_reloc,
1054 "R_NIOS2_GOT16",
1055 FALSE,
1056 0xffff0000,
1057 0xffff0000,
1058 FALSE),
1059
1060 HOWTO (R_NIOS2_CALL16,
1061 0,
1062 2,
1063 16,
1064 FALSE,
1065 16,
1066 complain_overflow_bitfield,
1067 bfd_elf_generic_reloc,
1068 "R_NIOS2_CALL16",
1069 FALSE,
1070 0xffff0000,
1071 0xffff0000,
1072 FALSE),
1073
1074 HOWTO (R_NIOS2_GOTOFF_LO,
1075 0,
1076 2,
1077 16,
1078 FALSE,
1079 16,
1080 complain_overflow_dont,
1081 bfd_elf_generic_reloc,
1082 "R_NIOS2_GOTOFF_LO",
1083 FALSE,
1084 0xffff0000,
1085 0xffff0000,
1086 FALSE),
1087
1088 HOWTO (R_NIOS2_GOTOFF_HA,
1089 0,
1090 2,
1091 16,
1092 FALSE,
1093 16,
1094 complain_overflow_dont,
1095 bfd_elf_generic_reloc,
1096 "R_NIOS2_GOTOFF_HA",
1097 FALSE,
1098 0xffff0000,
1099 0xffff0000,
1100 FALSE),
1101
1102 HOWTO (R_NIOS2_PCREL_LO,
1103 0,
1104 2,
1105 16,
1106 TRUE,
1107 16,
1108 complain_overflow_dont,
1109 nios2_elf32_pcrel_lo16_relocate,
1110 "R_NIOS2_PCREL_LO",
1111 FALSE,
1112 0xffff0000,
1113 0xffff0000,
1114 TRUE),
1115
1116 HOWTO (R_NIOS2_PCREL_HA,
1117 0,
1118 2,
1119 16,
1120 FALSE, /* This is a PC-relative relocation, but we need to subtract
1121 PC ourselves before the HIADJ. */
1122 16,
1123 complain_overflow_dont,
1124 nios2_elf32_pcrel_hiadj16_relocate,
1125 "R_NIOS2_PCREL_HA",
1126 FALSE,
1127 0xffff0000,
1128 0xffff0000,
1129 TRUE),
1130
1131 HOWTO (R_NIOS2_TLS_GD16,
1132 0,
1133 2,
1134 16,
1135 FALSE,
1136 16,
1137 complain_overflow_bitfield,
1138 bfd_elf_generic_reloc,
1139 "R_NIOS2_TLS_GD16",
1140 FALSE,
1141 0xffff0000,
1142 0xffff0000,
1143 FALSE),
1144
1145 HOWTO (R_NIOS2_TLS_LDM16,
1146 0,
1147 2,
1148 16,
1149 FALSE,
1150 16,
1151 complain_overflow_bitfield,
1152 bfd_elf_generic_reloc,
1153 "R_NIOS2_TLS_LDM16",
1154 FALSE,
1155 0xffff0000,
1156 0xffff0000,
1157 FALSE),
1158
1159 HOWTO (R_NIOS2_TLS_LDO16,
1160 0,
1161 2,
1162 16,
1163 FALSE,
1164 16,
1165 complain_overflow_bitfield,
1166 bfd_elf_generic_reloc,
1167 "R_NIOS2_TLS_LDO16",
1168 FALSE,
1169 0xffff0000,
1170 0xffff0000,
1171 FALSE),
1172
1173 HOWTO (R_NIOS2_TLS_IE16,
1174 0,
1175 2,
1176 16,
1177 FALSE,
1178 16,
1179 complain_overflow_bitfield,
1180 bfd_elf_generic_reloc,
1181 "R_NIOS2_TLS_IE16",
1182 FALSE,
1183 0xffff0000,
1184 0xffff0000,
1185 FALSE),
1186
1187 HOWTO (R_NIOS2_TLS_LE16,
1188 0,
1189 2,
1190 16,
1191 FALSE,
1192 16,
1193 complain_overflow_bitfield,
1194 bfd_elf_generic_reloc,
1195 "R_NIOS2_TLS_LE16",
1196 FALSE,
1197 0xffff0000,
1198 0xffff0000,
1199 FALSE),
1200
1201 HOWTO (R_NIOS2_TLS_DTPMOD,
1202 0,
1203 2,
1204 32,
1205 FALSE,
1206 0,
1207 complain_overflow_dont,
1208 bfd_elf_generic_reloc,
1209 "R_NIOS2_TLS_DTPMOD",
1210 FALSE,
1211 0xffffffff,
1212 0xffffffff,
1213 FALSE),
1214
1215 HOWTO (R_NIOS2_TLS_DTPREL,
1216 0,
1217 2,
1218 32,
1219 FALSE,
1220 0,
1221 complain_overflow_dont,
1222 bfd_elf_generic_reloc,
1223 "R_NIOS2_TLS_DTPREL",
1224 FALSE,
1225 0xffffffff,
1226 0xffffffff,
1227 FALSE),
1228
1229 HOWTO (R_NIOS2_TLS_TPREL,
1230 0,
1231 2,
1232 32,
1233 FALSE,
1234 0,
1235 complain_overflow_dont,
1236 bfd_elf_generic_reloc,
1237 "R_NIOS2_TLS_TPREL",
1238 FALSE,
1239 0xffffffff,
1240 0xffffffff,
1241 FALSE),
1242
1243 HOWTO (R_NIOS2_COPY,
1244 0,
1245 2,
1246 32,
1247 FALSE,
1248 0,
1249 complain_overflow_dont,
1250 bfd_elf_generic_reloc,
1251 "R_NIOS2_COPY",
1252 FALSE,
1253 0,
1254 0,
1255 FALSE),
1256
1257 HOWTO (R_NIOS2_GLOB_DAT,
1258 0,
1259 2,
1260 32,
1261 FALSE,
1262 0,
1263 complain_overflow_dont,
1264 bfd_elf_generic_reloc,
1265 "R_NIOS2_GLOB_DAT",
1266 FALSE,
1267 0xffffffff,
1268 0xffffffff,
1269 FALSE),
1270
1271 HOWTO (R_NIOS2_JUMP_SLOT,
1272 0,
1273 2,
1274 32,
1275 FALSE,
1276 0,
1277 complain_overflow_dont,
1278 bfd_elf_generic_reloc,
1279 "R_NIOS2_JUMP_SLOT",
1280 FALSE,
1281 0xffffffff,
1282 0xffffffff,
1283 FALSE),
1284
1285 HOWTO (R_NIOS2_RELATIVE,
1286 0,
1287 2,
1288 32,
1289 FALSE,
1290 0,
1291 complain_overflow_dont,
1292 bfd_elf_generic_reloc,
1293 "R_NIOS2_RELATIVE",
1294 FALSE,
1295 0xffffffff,
1296 0xffffffff,
1297 FALSE),
1298
1299 HOWTO (R_NIOS2_GOTOFF,
1300 0,
1301 2,
1302 32,
1303 FALSE,
1304 0,
1305 complain_overflow_dont,
1306 bfd_elf_generic_reloc,
1307 "R_NIOS2_GOTOFF",
1308 FALSE,
1309 0xffffffff,
1310 0xffffffff,
1311 FALSE),
1312
1313 HOWTO (R_NIOS2_CALL26_NOAT, /* type */
1314 2, /* rightshift */
1315 2, /* size (0 = byte, 1 = short, 2 = long) */
1316 26, /* bitsize */
1317 FALSE, /* pc_relative */
1318 6, /* bitpos */
1319 complain_overflow_dont, /* complain on overflow */
1320 nios2_elf32_call26_relocate, /* special function */
1321 "R_NIOS2_CALL26_NOAT", /* name */
1322 FALSE, /* partial_inplace */
1323 0xffffffc0, /* src_mask */
1324 0xffffffc0, /* dst_mask */
1325 FALSE), /* pcrel_offset */
1326
1327 HOWTO (R_NIOS2_GOT_LO,
1328 0,
1329 2,
1330 16,
1331 FALSE,
1332 16,
1333 complain_overflow_dont,
1334 bfd_elf_generic_reloc,
1335 "R_NIOS2_GOT_LO",
1336 FALSE,
1337 0xffff0000,
1338 0xffff0000,
1339 FALSE),
1340
1341 HOWTO (R_NIOS2_GOT_HA,
1342 0,
1343 2,
1344 16,
1345 FALSE,
1346 16,
1347 complain_overflow_dont,
1348 bfd_elf_generic_reloc,
1349 "R_NIOS2_GOT_HA",
1350 FALSE,
1351 0xffff0000,
1352 0xffff0000,
1353 FALSE),
1354
1355 HOWTO (R_NIOS2_CALL_LO,
1356 0,
1357 2,
1358 16,
1359 FALSE,
1360 16,
1361 complain_overflow_dont,
1362 bfd_elf_generic_reloc,
1363 "R_NIOS2_CALL_LO",
1364 FALSE,
1365 0xffff0000,
1366 0xffff0000,
1367 FALSE),
1368
1369 HOWTO (R_NIOS2_CALL_HA,
1370 0,
1371 2,
1372 16,
1373 FALSE,
1374 16,
1375 complain_overflow_dont,
1376 bfd_elf_generic_reloc,
1377 "R_NIOS2_CALL_HA",
1378 FALSE,
1379 0xffff0000,
1380 0xffff0000,
1381 FALSE),
1382
1383 HOWTO (R_NIOS2_R2_S12,
1384 0,
1385 2,
1386 12,
1387 FALSE,
1388 16,
1389 complain_overflow_signed,
1390 bfd_elf_generic_reloc,
1391 "R_NIOS2_R2_S12",
1392 FALSE,
1393 0x0fff0000,
1394 0x0fff0000,
1395 FALSE),
1396
1397 HOWTO (R_NIOS2_R2_I10_1_PCREL,
1398 1,
1399 1,
1400 10,
1401 TRUE,
1402 6,
1403 complain_overflow_signed,
1404 bfd_elf_generic_reloc, /* FIXME? */
1405 "R_NIOS2_R2_I10_1_PCREL",
1406 FALSE,
1407 0xffc0,
1408 0xffc0,
1409 TRUE),
1410
1411 HOWTO (R_NIOS2_R2_T1I7_1_PCREL,
1412 1,
1413 1,
1414 7,
1415 TRUE,
1416 9,
1417 complain_overflow_signed,
1418 bfd_elf_generic_reloc, /* FIXME? */
1419 "R_NIOS2_R2_T1I7_1_PCREL",
1420 FALSE,
1421 0xfe00,
1422 0xfe00,
1423 TRUE),
1424
1425 HOWTO (R_NIOS2_R2_T1I7_2,
1426 2,
1427 1,
1428 7,
1429 FALSE,
1430 9,
1431 complain_overflow_unsigned,
1432 bfd_elf_generic_reloc,
1433 "R_NIOS2_R2_T1I7_2",
1434 FALSE,
1435 0xfe00,
1436 0xfe00,
1437 FALSE),
1438
1439 HOWTO (R_NIOS2_R2_T2I4,
1440 0,
1441 1,
1442 4,
1443 FALSE,
1444 12,
1445 complain_overflow_unsigned,
1446 bfd_elf_generic_reloc,
1447 "R_NIOS2_R2_T2I4",
1448 FALSE,
1449 0xf000,
1450 0xf000,
1451 FALSE),
1452
1453 HOWTO (R_NIOS2_R2_T2I4_1,
1454 1,
1455 1,
1456 4,
1457 FALSE,
1458 12,
1459 complain_overflow_unsigned,
1460 bfd_elf_generic_reloc,
1461 "R_NIOS2_R2_T2I4_1",
1462 FALSE,
1463 0xf000,
1464 0xf000,
1465 FALSE),
1466
1467 HOWTO (R_NIOS2_R2_T2I4_2,
1468 2,
1469 1,
1470 4,
1471 FALSE,
1472 12,
1473 complain_overflow_unsigned,
1474 bfd_elf_generic_reloc,
1475 "R_NIOS2_R2_T2I4_2",
1476 FALSE,
1477 0xf000,
1478 0xf000,
1479 FALSE),
1480
1481 HOWTO (R_NIOS2_R2_X1I7_2,
1482 2,
1483 1,
1484 7,
1485 FALSE,
1486 6,
1487 complain_overflow_unsigned,
1488 bfd_elf_generic_reloc,
1489 "R_NIOS2_R2_X1I7_2",
1490 FALSE,
1491 0x1fc0,
1492 0x1fc0,
1493 FALSE),
1494
1495 HOWTO (R_NIOS2_R2_X2L5,
1496 0,
1497 1,
1498 5,
1499 FALSE,
1500 6,
1501 complain_overflow_unsigned,
1502 bfd_elf_generic_reloc,
1503 "R_NIOS2_R2_X2L5",
1504 FALSE,
1505 0x07c0,
1506 0x07c0,
1507 FALSE),
1508
1509 HOWTO (R_NIOS2_R2_F1I5_2,
1510 2,
1511 1,
1512 5,
1513 FALSE,
1514 6,
1515 complain_overflow_unsigned,
1516 bfd_elf_generic_reloc,
1517 "R_NIOS2_R2_F1L5_2",
1518 FALSE,
1519 0x07c0,
1520 0x07c0,
1521 FALSE),
1522
1523 HOWTO (R_NIOS2_R2_L5I4X1,
1524 2,
1525 1,
1526 4,
1527 FALSE,
1528 6,
1529 complain_overflow_unsigned,
1530 bfd_elf_generic_reloc,
1531 "R_NIOS2_R2_L5I4X1",
1532 FALSE,
1533 0x03c0,
1534 0x03c0,
1535 FALSE),
1536
1537 HOWTO (R_NIOS2_R2_T1X1I6,
1538 0,
1539 1,
1540 6,
1541 FALSE,
1542 9,
1543 complain_overflow_unsigned,
1544 bfd_elf_generic_reloc,
1545 "R_NIOS2_R2_T1X1I6",
1546 FALSE,
1547 0x7e00,
1548 0x7e00,
1549 FALSE),
1550
1551 HOWTO (R_NIOS2_R2_T1X1I6_2,
1552 2,
1553 2,
1554 6,
1555 FALSE,
1556 9,
1557 complain_overflow_unsigned,
1558 bfd_elf_generic_reloc,
1559 "R_NIOS2_R2_T1I1X6_2",
1560 FALSE,
1561 0x7e00,
1562 0x7e00,
1563 FALSE),
1564
1565 /* Add other relocations here. */
1566 };
1567
1568 static unsigned char elf_code_to_howto_index[R_NIOS2_ILLEGAL + 1];
1569
1570
1571 /* Return true if producing output for a R2 BFD. */
1572 #define BFD_IS_R2(abfd) (bfd_get_mach (abfd) == bfd_mach_nios2r2)
1573
1574 /* Return the howto for relocation RTYPE. */
1575 static reloc_howto_type *
1576 lookup_howto (unsigned int rtype, bfd *abfd)
1577 {
1578 static int initialized = 0;
1579 int i;
1580 /* R2 relocations are a superset of R1, so use that for the lookup
1581 table. */
1582 int r1_howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
1583 int r2_howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
1584
1585 if (!initialized)
1586 {
1587 initialized = 1;
1588 memset (elf_code_to_howto_index, 0xff,
1589 sizeof (elf_code_to_howto_index));
1590 for (i = 0; i < r2_howto_tbl_size; i++)
1591 {
1592 elf_code_to_howto_index[elf_nios2_r2_howto_table_rel[i].type] = i;
1593 if (i < r1_howto_tbl_size)
1594 BFD_ASSERT (elf_nios2_r2_howto_table_rel[i].type
1595 == elf_nios2_r1_howto_table_rel[i].type);
1596 }
1597 }
1598
1599 if (rtype > R_NIOS2_ILLEGAL)
1600 return NULL;
1601 i = elf_code_to_howto_index[rtype];
1602 if (BFD_IS_R2 (abfd))
1603 {
1604 if (i >= r2_howto_tbl_size)
1605 return NULL;
1606 return elf_nios2_r2_howto_table_rel + i;
1607 }
1608 else
1609 {
1610 if (i >= r1_howto_tbl_size)
1611 return NULL;
1612 return elf_nios2_r1_howto_table_rel + i;
1613 }
1614 }
1615
1616 /* Map for converting BFD reloc types to Nios II reloc types. */
1617 struct elf_reloc_map
1618 {
1619 bfd_reloc_code_real_type bfd_val;
1620 enum elf_nios2_reloc_type elf_val;
1621 };
1622
1623 static const struct elf_reloc_map nios2_reloc_map[] =
1624 {
1625 {BFD_RELOC_NONE, R_NIOS2_NONE},
1626 {BFD_RELOC_NIOS2_S16, R_NIOS2_S16},
1627 {BFD_RELOC_NIOS2_U16, R_NIOS2_U16},
1628 {BFD_RELOC_16_PCREL, R_NIOS2_PCREL16},
1629 {BFD_RELOC_NIOS2_CALL26, R_NIOS2_CALL26},
1630 {BFD_RELOC_NIOS2_IMM5, R_NIOS2_IMM5},
1631 {BFD_RELOC_NIOS2_CACHE_OPX, R_NIOS2_CACHE_OPX},
1632 {BFD_RELOC_NIOS2_IMM6, R_NIOS2_IMM6},
1633 {BFD_RELOC_NIOS2_IMM8, R_NIOS2_IMM8},
1634 {BFD_RELOC_NIOS2_HI16, R_NIOS2_HI16},
1635 {BFD_RELOC_NIOS2_LO16, R_NIOS2_LO16},
1636 {BFD_RELOC_NIOS2_HIADJ16, R_NIOS2_HIADJ16},
1637 {BFD_RELOC_32, R_NIOS2_BFD_RELOC_32},
1638 {BFD_RELOC_16, R_NIOS2_BFD_RELOC_16},
1639 {BFD_RELOC_8, R_NIOS2_BFD_RELOC_8},
1640 {BFD_RELOC_NIOS2_GPREL, R_NIOS2_GPREL},
1641 {BFD_RELOC_VTABLE_INHERIT, R_NIOS2_GNU_VTINHERIT},
1642 {BFD_RELOC_VTABLE_ENTRY, R_NIOS2_GNU_VTENTRY},
1643 {BFD_RELOC_NIOS2_UJMP, R_NIOS2_UJMP},
1644 {BFD_RELOC_NIOS2_CJMP, R_NIOS2_CJMP},
1645 {BFD_RELOC_NIOS2_CALLR, R_NIOS2_CALLR},
1646 {BFD_RELOC_NIOS2_ALIGN, R_NIOS2_ALIGN},
1647 {BFD_RELOC_NIOS2_GOT16, R_NIOS2_GOT16},
1648 {BFD_RELOC_NIOS2_CALL16, R_NIOS2_CALL16},
1649 {BFD_RELOC_NIOS2_GOTOFF_LO, R_NIOS2_GOTOFF_LO},
1650 {BFD_RELOC_NIOS2_GOTOFF_HA, R_NIOS2_GOTOFF_HA},
1651 {BFD_RELOC_NIOS2_PCREL_LO, R_NIOS2_PCREL_LO},
1652 {BFD_RELOC_NIOS2_PCREL_HA, R_NIOS2_PCREL_HA},
1653 {BFD_RELOC_NIOS2_TLS_GD16, R_NIOS2_TLS_GD16},
1654 {BFD_RELOC_NIOS2_TLS_LDM16, R_NIOS2_TLS_LDM16},
1655 {BFD_RELOC_NIOS2_TLS_LDO16, R_NIOS2_TLS_LDO16},
1656 {BFD_RELOC_NIOS2_TLS_IE16, R_NIOS2_TLS_IE16},
1657 {BFD_RELOC_NIOS2_TLS_LE16, R_NIOS2_TLS_LE16},
1658 {BFD_RELOC_NIOS2_TLS_DTPMOD, R_NIOS2_TLS_DTPMOD},
1659 {BFD_RELOC_NIOS2_TLS_DTPREL, R_NIOS2_TLS_DTPREL},
1660 {BFD_RELOC_NIOS2_TLS_TPREL, R_NIOS2_TLS_TPREL},
1661 {BFD_RELOC_NIOS2_COPY, R_NIOS2_COPY},
1662 {BFD_RELOC_NIOS2_GLOB_DAT, R_NIOS2_GLOB_DAT},
1663 {BFD_RELOC_NIOS2_JUMP_SLOT, R_NIOS2_JUMP_SLOT},
1664 {BFD_RELOC_NIOS2_RELATIVE, R_NIOS2_RELATIVE},
1665 {BFD_RELOC_NIOS2_GOTOFF, R_NIOS2_GOTOFF},
1666 {BFD_RELOC_NIOS2_CALL26_NOAT, R_NIOS2_CALL26_NOAT},
1667 {BFD_RELOC_NIOS2_GOT_LO, R_NIOS2_GOT_LO},
1668 {BFD_RELOC_NIOS2_GOT_HA, R_NIOS2_GOT_HA},
1669 {BFD_RELOC_NIOS2_CALL_LO, R_NIOS2_CALL_LO},
1670 {BFD_RELOC_NIOS2_CALL_HA, R_NIOS2_CALL_HA},
1671 {BFD_RELOC_NIOS2_R2_S12, R_NIOS2_R2_S12},
1672 {BFD_RELOC_NIOS2_R2_I10_1_PCREL, R_NIOS2_R2_I10_1_PCREL},
1673 {BFD_RELOC_NIOS2_R2_T1I7_1_PCREL, R_NIOS2_R2_T1I7_1_PCREL},
1674 {BFD_RELOC_NIOS2_R2_T1I7_2, R_NIOS2_R2_T1I7_2},
1675 {BFD_RELOC_NIOS2_R2_T2I4, R_NIOS2_R2_T2I4},
1676 {BFD_RELOC_NIOS2_R2_T2I4_1, R_NIOS2_R2_T2I4_1},
1677 {BFD_RELOC_NIOS2_R2_T2I4_2, R_NIOS2_R2_T2I4_2},
1678 {BFD_RELOC_NIOS2_R2_X1I7_2, R_NIOS2_R2_X1I7_2},
1679 {BFD_RELOC_NIOS2_R2_X2L5, R_NIOS2_R2_X2L5},
1680 {BFD_RELOC_NIOS2_R2_F1I5_2, R_NIOS2_R2_F1I5_2},
1681 {BFD_RELOC_NIOS2_R2_L5I4X1, R_NIOS2_R2_L5I4X1},
1682 {BFD_RELOC_NIOS2_R2_T1X1I6, R_NIOS2_R2_T1X1I6},
1683 {BFD_RELOC_NIOS2_R2_T1X1I6_2, R_NIOS2_R2_T1X1I6_2},
1684 };
1685
1686 enum elf32_nios2_stub_type
1687 {
1688 nios2_stub_call26_before,
1689 nios2_stub_call26_after,
1690 nios2_stub_none
1691 };
1692
1693 struct elf32_nios2_stub_hash_entry
1694 {
1695 /* Base hash table entry structure. */
1696 struct bfd_hash_entry bh_root;
1697
1698 /* The stub section. */
1699 asection *stub_sec;
1700
1701 /* Offset within stub_sec of the beginning of this stub. */
1702 bfd_vma stub_offset;
1703
1704 /* Given the symbol's value and its section we can determine its final
1705 value when building the stubs (so the stub knows where to jump. */
1706 bfd_vma target_value;
1707 asection *target_section;
1708
1709 enum elf32_nios2_stub_type stub_type;
1710
1711 /* The symbol table entry, if any, that this was derived from. */
1712 struct elf32_nios2_link_hash_entry *hh;
1713
1714 /* And the reloc addend that this was derived from. */
1715 bfd_vma addend;
1716
1717 /* Where this stub is being called from, or, in the case of combined
1718 stub sections, the first input section in the group. */
1719 asection *id_sec;
1720 };
1721
1722 #define nios2_stub_hash_entry(ent) \
1723 ((struct elf32_nios2_stub_hash_entry *)(ent))
1724
1725 #define nios2_stub_hash_lookup(table, string, create, copy) \
1726 ((struct elf32_nios2_stub_hash_entry *) \
1727 bfd_hash_lookup ((table), (string), (create), (copy)))
1728
1729
1730 /* Nios II ELF linker hash entry. */
1731
1732 struct elf32_nios2_link_hash_entry
1733 {
1734 struct elf_link_hash_entry root;
1735
1736 /* A pointer to the most recently used stub hash entry against this
1737 symbol. */
1738 struct elf32_nios2_stub_hash_entry *hsh_cache;
1739
1740 /* Track dynamic relocs copied for this symbol. */
1741 struct elf_dyn_relocs *dyn_relocs;
1742
1743 #define GOT_UNKNOWN 0
1744 #define GOT_NORMAL 1
1745 #define GOT_TLS_GD 2
1746 #define GOT_TLS_IE 4
1747 unsigned char tls_type;
1748
1749 /* We need to detect and take special action for symbols which are only
1750 referenced with %call() and not with %got(). Such symbols do not need
1751 a dynamic GOT reloc in shared objects, only a dynamic PLT reloc. Lazy
1752 linking will not work if the dynamic GOT reloc exists.
1753 To check for this condition efficiently, we compare got_types_used against
1754 CALL_USED, meaning
1755 (got_types_used & (GOT_USED | CALL_USED)) == CALL_USED.
1756 */
1757 #define GOT_USED 1
1758 #define CALL_USED 2
1759 unsigned char got_types_used;
1760 };
1761
1762 #define elf32_nios2_hash_entry(ent) \
1763 ((struct elf32_nios2_link_hash_entry *) (ent))
1764
1765 /* Get the Nios II elf linker hash table from a link_info structure. */
1766 #define elf32_nios2_hash_table(info) \
1767 ((struct elf32_nios2_link_hash_table *) ((info)->hash))
1768
1769 /* Nios II ELF linker hash table. */
1770 struct elf32_nios2_link_hash_table
1771 {
1772 /* The main hash table. */
1773 struct elf_link_hash_table root;
1774
1775 /* The stub hash table. */
1776 struct bfd_hash_table bstab;
1777
1778 /* Linker stub bfd. */
1779 bfd *stub_bfd;
1780
1781 /* Linker call-backs. */
1782 asection * (*add_stub_section) (const char *, asection *, bfd_boolean);
1783 void (*layout_sections_again) (void);
1784
1785 /* Array to keep track of which stub sections have been created, and
1786 information on stub grouping. */
1787 struct map_stub
1788 {
1789 /* These are the section to which stubs in the group will be
1790 attached. */
1791 asection *first_sec, *last_sec;
1792 /* The stub sections. There might be stubs inserted either before
1793 or after the real section.*/
1794 asection *first_stub_sec, *last_stub_sec;
1795 } *stub_group;
1796
1797 /* Assorted information used by nios2_elf32_size_stubs. */
1798 unsigned int bfd_count;
1799 unsigned int top_index;
1800 asection **input_list;
1801 Elf_Internal_Sym **all_local_syms;
1802
1803 /* Short-cuts to get to dynamic linker sections. */
1804 asection *sbss;
1805
1806 /* GOT pointer symbol _gp_got. */
1807 struct elf_link_hash_entry *h_gp_got;
1808
1809 union {
1810 bfd_signed_vma refcount;
1811 bfd_vma offset;
1812 } tls_ldm_got;
1813
1814 /* Small local sym cache. */
1815 struct sym_cache sym_cache;
1816
1817 bfd_vma res_n_size;
1818 };
1819
1820 struct nios2_elf32_obj_tdata
1821 {
1822 struct elf_obj_tdata root;
1823
1824 /* tls_type for each local got entry. */
1825 char *local_got_tls_type;
1826
1827 /* TRUE if TLS GD relocs have been seen for this object. */
1828 bfd_boolean has_tlsgd;
1829 };
1830
1831 #define elf32_nios2_tdata(abfd) \
1832 ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
1833
1834 #define elf32_nios2_local_got_tls_type(abfd) \
1835 (elf32_nios2_tdata (abfd)->local_got_tls_type)
1836
1837 /* The name of the dynamic interpreter. This is put in the .interp
1838 section. */
1839 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1840
1841 /* PLT implementation for position-dependent code. */
1842 static const bfd_vma nios2_plt_entry[] = { /* .PLTn: */
1843 0x03c00034, /* movhi r15, %hiadj(plt_got_slot_address) */
1844 0x7bc00017, /* ldw r15, %lo(plt_got_slot_address)(r15) */
1845 0x7800683a /* jmp r15 */
1846 };
1847
1848 static const bfd_vma nios2_plt0_entry[] = { /* .PLTresolve */
1849 0x03800034, /* movhi r14, %hiadj(res_0) */
1850 0x73800004, /* addi r14, r14, %lo(res_0) */
1851 0x7b9fc83a, /* sub r15, r15, r14 */
1852 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1853 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1854 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1855 0x6800683a /* jmp r13 */
1856 };
1857
1858 /* PLT implementation for position-independent code. */
1859 static const bfd_vma nios2_so_plt_entry[] = { /* .PLTn */
1860 0x03c00034, /* movhi r15, %hiadj(index * 4) */
1861 0x7bc00004, /* addi r15, r15, %lo(index * 4) */
1862 0x00000006 /* br .PLTresolve */
1863 };
1864
1865 static const bfd_vma nios2_so_plt0_entry[] = { /* .PLTresolve */
1866 0x001ce03a, /* nextpc r14 */
1867 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
1868 0x6b9b883a, /* add r13, r13, r14 */
1869 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
1870 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
1871 0x6800683a /* jmp r13 */
1872 };
1873
1874 /* CALL26 stub. */
1875 static const bfd_vma nios2_call26_stub_entry[] = {
1876 0x00400034, /* orhi at, r0, %hiadj(dest) */
1877 0x08400004, /* addi at, at, %lo(dest) */
1878 0x0800683a /* jmp at */
1879 };
1880
1881 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC. */
1882 static void
1883 nios2_elf32_install_imm16 (asection *sec, bfd_vma offset, bfd_vma value)
1884 {
1885 bfd_vma word = bfd_get_32 (sec->owner, sec->contents + offset);
1886
1887 BFD_ASSERT (value <= 0xffff || ((bfd_signed_vma) value) >= -0xffff);
1888
1889 bfd_put_32 (sec->owner, word | ((value & 0xffff) << 6),
1890 sec->contents + offset);
1891 }
1892
1893 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
1894 section SEC. */
1895 static void
1896 nios2_elf32_install_data (asection *sec, const bfd_vma *data, bfd_vma offset,
1897 int count)
1898 {
1899 while (count--)
1900 {
1901 bfd_put_32 (sec->owner, *data, sec->contents + offset);
1902 offset += 4;
1903 ++data;
1904 }
1905 }
1906
1907 /* The usual way of loading a 32-bit constant into a Nios II register is to
1908 load the high 16 bits in one instruction and then add the low 16 bits with
1909 a signed add. This means that the high halfword needs to be adjusted to
1910 compensate for the sign bit of the low halfword. This function returns the
1911 adjusted high halfword for a given 32-bit constant. */
1912 static
1913 bfd_vma hiadj (bfd_vma symbol_value)
1914 {
1915 return ((symbol_value + 0x8000) >> 16) & 0xffff;
1916 }
1917
1918 /* Implement elf_backend_grok_prstatus:
1919 Support for core dump NOTE sections. */
1920 static bfd_boolean
1921 nios2_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
1922 {
1923 int offset;
1924 size_t size;
1925
1926 switch (note->descsz)
1927 {
1928 default:
1929 return FALSE;
1930
1931 case 212: /* Linux/Nios II */
1932 /* pr_cursig */
1933 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
1934
1935 /* pr_pid */
1936 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
1937
1938 /* pr_reg */
1939 offset = 72;
1940 size = 136;
1941
1942 break;
1943 }
1944
1945 /* Make a ".reg/999" section. */
1946 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
1947 size, note->descpos + offset);
1948 }
1949
1950 /* Implement elf_backend_grok_psinfo. */
1951 static bfd_boolean
1952 nios2_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
1953 {
1954 switch (note->descsz)
1955 {
1956 default:
1957 return FALSE;
1958
1959 case 124: /* Linux/Nios II elf_prpsinfo */
1960 elf_tdata (abfd)->core->program
1961 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
1962 elf_tdata (abfd)->core->command
1963 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
1964 }
1965
1966 /* Note that for some reason, a spurious space is tacked
1967 onto the end of the args in some (at least one anyway)
1968 implementations, so strip it off if it exists. */
1969
1970 {
1971 char *command = elf_tdata (abfd)->core->command;
1972 int n = strlen (command);
1973
1974 if (0 < n && command[n - 1] == ' ')
1975 command[n - 1] = '\0';
1976 }
1977
1978 return TRUE;
1979 }
1980
1981 /* Assorted hash table functions. */
1982
1983 /* Initialize an entry in the stub hash table. */
1984 static struct bfd_hash_entry *
1985 stub_hash_newfunc (struct bfd_hash_entry *entry,
1986 struct bfd_hash_table *table,
1987 const char *string)
1988 {
1989 /* Allocate the structure if it has not already been allocated by a
1990 subclass. */
1991 if (entry == NULL)
1992 {
1993 entry = bfd_hash_allocate (table,
1994 sizeof (struct elf32_nios2_stub_hash_entry));
1995 if (entry == NULL)
1996 return entry;
1997 }
1998
1999 /* Call the allocation method of the superclass. */
2000 entry = bfd_hash_newfunc (entry, table, string);
2001 if (entry != NULL)
2002 {
2003 struct elf32_nios2_stub_hash_entry *hsh;
2004
2005 /* Initialize the local fields. */
2006 hsh = (struct elf32_nios2_stub_hash_entry *) entry;
2007 hsh->stub_sec = NULL;
2008 hsh->stub_offset = 0;
2009 hsh->target_value = 0;
2010 hsh->target_section = NULL;
2011 hsh->stub_type = nios2_stub_none;
2012 hsh->hh = NULL;
2013 hsh->id_sec = NULL;
2014 }
2015
2016 return entry;
2017 }
2018
2019 /* Create an entry in a Nios II ELF linker hash table. */
2020 static struct bfd_hash_entry *
2021 link_hash_newfunc (struct bfd_hash_entry *entry,
2022 struct bfd_hash_table *table, const char *string)
2023 {
2024 /* Allocate the structure if it has not already been allocated by a
2025 subclass. */
2026 if (entry == NULL)
2027 {
2028 entry = bfd_hash_allocate (table,
2029 sizeof (struct elf32_nios2_link_hash_entry));
2030 if (entry == NULL)
2031 return entry;
2032 }
2033
2034 /* Call the allocation method of the superclass. */
2035 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
2036 if (entry)
2037 {
2038 struct elf32_nios2_link_hash_entry *eh;
2039
2040 eh = (struct elf32_nios2_link_hash_entry *) entry;
2041 eh->hsh_cache = NULL;
2042 eh->dyn_relocs = NULL;
2043 eh->tls_type = GOT_UNKNOWN;
2044 eh->got_types_used = 0;
2045 }
2046
2047 return entry;
2048 }
2049
2050 /* Section name for stubs is the associated section name plus this
2051 string. */
2052 #define STUB_SUFFIX ".stub"
2053
2054 /* Build a name for an entry in the stub hash table. */
2055 static char *
2056 nios2_stub_name (const asection *input_section,
2057 const asection *sym_sec,
2058 const struct elf32_nios2_link_hash_entry *hh,
2059 const Elf_Internal_Rela *rel,
2060 enum elf32_nios2_stub_type stub_type)
2061 {
2062 char *stub_name;
2063 bfd_size_type len;
2064 char stubpos = (stub_type == nios2_stub_call26_before) ? 'b' : 'a';
2065
2066 if (hh)
2067 {
2068 len = 8 + 1 + 1 + 1+ strlen (hh->root.root.root.string) + 1 + 8 + 1;
2069 stub_name = bfd_malloc (len);
2070 if (stub_name != NULL)
2071 {
2072 sprintf (stub_name, "%08x_%c_%s+%x",
2073 input_section->id & 0xffffffff,
2074 stubpos,
2075 hh->root.root.root.string,
2076 (int) rel->r_addend & 0xffffffff);
2077 }
2078 }
2079 else
2080 {
2081 len = 8 + 1 + 1 + 1+ 8 + 1 + 8 + 1 + 8 + 1;
2082 stub_name = bfd_malloc (len);
2083 if (stub_name != NULL)
2084 {
2085 sprintf (stub_name, "%08x_%c_%x:%x+%x",
2086 input_section->id & 0xffffffff,
2087 stubpos,
2088 sym_sec->id & 0xffffffff,
2089 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
2090 (int) rel->r_addend & 0xffffffff);
2091 }
2092 }
2093 return stub_name;
2094 }
2095
2096 /* Look up an entry in the stub hash. Stub entries are cached because
2097 creating the stub name takes a bit of time. */
2098 static struct elf32_nios2_stub_hash_entry *
2099 nios2_get_stub_entry (const asection *input_section,
2100 const asection *sym_sec,
2101 struct elf32_nios2_link_hash_entry *hh,
2102 const Elf_Internal_Rela *rel,
2103 struct elf32_nios2_link_hash_table *htab,
2104 enum elf32_nios2_stub_type stub_type)
2105 {
2106 struct elf32_nios2_stub_hash_entry *hsh;
2107 const asection *id_sec;
2108
2109 /* If this input section is part of a group of sections sharing one
2110 stub section, then use the id of the first/last section in the group,
2111 depending on the stub section placement relative to the group.
2112 Stub names need to include a section id, as there may well be
2113 more than one stub used to reach say, printf, and we need to
2114 distinguish between them. */
2115 if (stub_type == nios2_stub_call26_before)
2116 id_sec = htab->stub_group[input_section->id].first_sec;
2117 else
2118 id_sec = htab->stub_group[input_section->id].last_sec;
2119
2120 if (hh != NULL && hh->hsh_cache != NULL
2121 && hh->hsh_cache->hh == hh
2122 && hh->hsh_cache->id_sec == id_sec
2123 && hh->hsh_cache->stub_type == stub_type)
2124 {
2125 hsh = hh->hsh_cache;
2126 }
2127 else
2128 {
2129 char *stub_name;
2130
2131 stub_name = nios2_stub_name (id_sec, sym_sec, hh, rel, stub_type);
2132 if (stub_name == NULL)
2133 return NULL;
2134
2135 hsh = nios2_stub_hash_lookup (&htab->bstab,
2136 stub_name, FALSE, FALSE);
2137
2138 if (hh != NULL)
2139 hh->hsh_cache = hsh;
2140
2141 free (stub_name);
2142 }
2143
2144 return hsh;
2145 }
2146
2147 /* Add a new stub entry to the stub hash. Not all fields of the new
2148 stub entry are initialised. */
2149 static struct elf32_nios2_stub_hash_entry *
2150 nios2_add_stub (const char *stub_name,
2151 asection *section,
2152 struct elf32_nios2_link_hash_table *htab,
2153 enum elf32_nios2_stub_type stub_type)
2154 {
2155 asection *link_sec;
2156 asection *stub_sec;
2157 asection **secptr, **linkptr;
2158 struct elf32_nios2_stub_hash_entry *hsh;
2159 bfd_boolean afterp;
2160
2161 if (stub_type == nios2_stub_call26_before)
2162 {
2163 link_sec = htab->stub_group[section->id].first_sec;
2164 secptr = &(htab->stub_group[section->id].first_stub_sec);
2165 linkptr = &(htab->stub_group[link_sec->id].first_stub_sec);
2166 afterp = FALSE;
2167 }
2168 else
2169 {
2170 link_sec = htab->stub_group[section->id].last_sec;
2171 secptr = &(htab->stub_group[section->id].last_stub_sec);
2172 linkptr = &(htab->stub_group[link_sec->id].last_stub_sec);
2173 afterp = TRUE;
2174 }
2175 stub_sec = *secptr;
2176 if (stub_sec == NULL)
2177 {
2178 stub_sec = *linkptr;
2179 if (stub_sec == NULL)
2180 {
2181 size_t namelen;
2182 bfd_size_type len;
2183 char *s_name;
2184
2185 namelen = strlen (link_sec->name);
2186 len = namelen + sizeof (STUB_SUFFIX);
2187 s_name = bfd_alloc (htab->stub_bfd, len);
2188 if (s_name == NULL)
2189 return NULL;
2190
2191 memcpy (s_name, link_sec->name, namelen);
2192 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
2193
2194 stub_sec = (*htab->add_stub_section) (s_name, link_sec, afterp);
2195 if (stub_sec == NULL)
2196 return NULL;
2197 *linkptr = stub_sec;
2198 }
2199 *secptr = stub_sec;
2200 }
2201
2202 /* Enter this entry into the linker stub hash table. */
2203 hsh = nios2_stub_hash_lookup (&htab->bstab, stub_name,
2204 TRUE, FALSE);
2205 if (hsh == NULL)
2206 {
2207 /* xgettext:c-format */
2208 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
2209 section->owner,
2210 stub_name);
2211 return NULL;
2212 }
2213
2214 hsh->stub_sec = stub_sec;
2215 hsh->stub_offset = 0;
2216 hsh->id_sec = link_sec;
2217 return hsh;
2218 }
2219
2220 /* Set up various things so that we can make a list of input sections
2221 for each output section included in the link. Returns -1 on error,
2222 0 when no stubs will be needed, and 1 on success. */
2223 int
2224 nios2_elf32_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
2225 {
2226 bfd *input_bfd;
2227 unsigned int bfd_count;
2228 unsigned int top_id, top_index;
2229 asection *section;
2230 asection **input_list, **list;
2231 size_t amt;
2232 struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2233
2234 /* Count the number of input BFDs and find the top input section id. */
2235 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
2236 input_bfd != NULL;
2237 input_bfd = input_bfd->link.next)
2238 {
2239 bfd_count += 1;
2240 for (section = input_bfd->sections;
2241 section != NULL;
2242 section = section->next)
2243 {
2244 if (top_id < section->id)
2245 top_id = section->id;
2246 }
2247 }
2248
2249 htab->bfd_count = bfd_count;
2250
2251 amt = sizeof (struct map_stub) * (top_id + 1);
2252 htab->stub_group = bfd_zmalloc (amt);
2253 if (htab->stub_group == NULL)
2254 return -1;
2255
2256 /* We can't use output_bfd->section_count here to find the top output
2257 section index as some sections may have been removed, and
2258 strip_excluded_output_sections doesn't renumber the indices. */
2259 for (section = output_bfd->sections, top_index = 0;
2260 section != NULL;
2261 section = section->next)
2262 {
2263 if (top_index < section->index)
2264 top_index = section->index;
2265 }
2266
2267 htab->top_index = top_index;
2268 amt = sizeof (asection *) * (top_index + 1);
2269 input_list = bfd_malloc (amt);
2270 htab->input_list = input_list;
2271 if (input_list == NULL)
2272 return -1;
2273
2274 /* For sections we aren't interested in, mark their entries with a
2275 value we can check later. */
2276 list = input_list + top_index;
2277 do
2278 *list = bfd_abs_section_ptr;
2279 while (list-- != input_list);
2280
2281 for (section = output_bfd->sections;
2282 section != NULL;
2283 section = section->next)
2284 {
2285 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
2286 * have PC relative relocs in them but no code flag set. */
2287 if (((section->flags & SEC_CODE) != 0) ||
2288 strcmp(".ctors", section->name) ||
2289 strcmp(".dtors", section->name))
2290 input_list[section->index] = NULL;
2291 }
2292
2293 return 1;
2294 }
2295
2296 /* The linker repeatedly calls this function for each input section,
2297 in the order that input sections are linked into output sections.
2298 Build lists of input sections to determine groupings between which
2299 we may insert linker stubs. */
2300 void
2301 nios2_elf32_next_input_section (struct bfd_link_info *info, asection *isec)
2302 {
2303 struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2304
2305 if (isec->output_section->index <= htab->top_index)
2306 {
2307 asection **list = htab->input_list + isec->output_section->index;
2308 if (*list != bfd_abs_section_ptr)
2309 {
2310 /* Steal the last_sec pointer for our list.
2311 This happens to make the list in reverse order,
2312 which is what we want. */
2313 htab->stub_group[isec->id].last_sec = *list;
2314 *list = isec;
2315 }
2316 }
2317 }
2318
2319 /* Segment mask for CALL26 relocation relaxation. */
2320 #define CALL26_SEGMENT(x) ((x) & 0xf0000000)
2321
2322 /* Fudge factor for approximate maximum size of all stubs that might
2323 be inserted by the linker. This does not actually limit the number
2324 of stubs that might be inserted, and only affects strategy for grouping
2325 and placement of stubs. Perhaps this should be computed based on number
2326 of relocations seen, or be specifiable on the command line. */
2327 #define MAX_STUB_SECTION_SIZE 0xffff
2328
2329 /* See whether we can group stub sections together. Grouping stub
2330 sections may result in fewer stubs. More importantly, we need to
2331 put all .init* and .fini* stubs at the end of the .init or
2332 .fini output sections respectively, because glibc splits the
2333 _init and _fini functions into multiple parts. Putting a stub in
2334 the middle of a function is not a good idea.
2335 Rather than computing groups of a maximum fixed size, for Nios II
2336 CALL26 relaxation it makes more sense to compute the groups based on
2337 sections that fit within a 256MB address segment. Also do not allow
2338 a group to span more than one output section, since different output
2339 sections might correspond to different memory banks on a bare-metal
2340 target, etc. */
2341 static void
2342 group_sections (struct elf32_nios2_link_hash_table *htab)
2343 {
2344 asection **list = htab->input_list + htab->top_index;
2345 do
2346 {
2347 /* The list is in reverse order so we'll search backwards looking
2348 for the first section that begins in the same memory segment,
2349 marking sections along the way to point at the tail for this
2350 group. */
2351 asection *tail = *list;
2352 if (tail == bfd_abs_section_ptr)
2353 continue;
2354 while (tail != NULL)
2355 {
2356 bfd_vma start = tail->output_section->vma + tail->output_offset;
2357 bfd_vma end = start + tail->size;
2358 bfd_vma segment = CALL26_SEGMENT (end);
2359 asection *prev;
2360
2361 if (segment != CALL26_SEGMENT (start)
2362 || segment != CALL26_SEGMENT (end + MAX_STUB_SECTION_SIZE))
2363 /* This section spans more than one memory segment, or is
2364 close enough to the end of the segment that adding stub
2365 sections before it might cause it to move so that it
2366 spans memory segments, or that stubs added at the end of
2367 this group might overflow into the next memory segment.
2368 Put it in a group by itself to localize the effects. */
2369 {
2370 prev = htab->stub_group[tail->id].last_sec;
2371 htab->stub_group[tail->id].last_sec = tail;
2372 htab->stub_group[tail->id].first_sec = tail;
2373 }
2374 else
2375 /* Collect more sections for this group. */
2376 {
2377 asection *curr, *first;
2378 for (curr = tail; ; curr = prev)
2379 {
2380 prev = htab->stub_group[curr->id].last_sec;
2381 if (!prev
2382 || tail->output_section != prev->output_section
2383 || (CALL26_SEGMENT (prev->output_section->vma
2384 + prev->output_offset)
2385 != segment))
2386 break;
2387 }
2388 first = curr;
2389 for (curr = tail; ; curr = prev)
2390 {
2391 prev = htab->stub_group[curr->id].last_sec;
2392 htab->stub_group[curr->id].last_sec = tail;
2393 htab->stub_group[curr->id].first_sec = first;
2394 if (curr == first)
2395 break;
2396 }
2397 }
2398
2399 /* Reset tail for the next group. */
2400 tail = prev;
2401 }
2402 }
2403 while (list-- != htab->input_list);
2404 free (htab->input_list);
2405 }
2406
2407 /* Determine the type of stub needed, if any, for a call. */
2408 static enum elf32_nios2_stub_type
2409 nios2_type_of_stub (asection *input_sec,
2410 const Elf_Internal_Rela *rel,
2411 struct elf32_nios2_link_hash_entry *hh,
2412 struct elf32_nios2_link_hash_table *htab,
2413 bfd_vma destination,
2414 struct bfd_link_info *info ATTRIBUTE_UNUSED)
2415 {
2416 bfd_vma location, segment, start, end;
2417 asection *s0, *s1, *s;
2418
2419 if (hh != NULL &&
2420 !(hh->root.root.type == bfd_link_hash_defined
2421 || hh->root.root.type == bfd_link_hash_defweak))
2422 return nios2_stub_none;
2423
2424 /* Determine where the call point is. */
2425 location = (input_sec->output_section->vma
2426 + input_sec->output_offset + rel->r_offset);
2427 segment = CALL26_SEGMENT (location);
2428
2429 /* Nios II CALL and JMPI instructions can transfer control to addresses
2430 within the same 256MB segment as the PC. */
2431 if (segment == CALL26_SEGMENT (destination))
2432 return nios2_stub_none;
2433
2434 /* Find the start and end addresses of the stub group. Also account for
2435 any already-created stub sections for this group. Note that for stubs
2436 in the end section, only the first instruction of the last stub
2437 (12 bytes long) needs to be within range. */
2438 s0 = htab->stub_group[input_sec->id].first_sec;
2439 s = htab->stub_group[s0->id].first_stub_sec;
2440 if (s != NULL && s->size > 0)
2441 start = s->output_section->vma + s->output_offset;
2442 else
2443 start = s0->output_section->vma + s0->output_offset;
2444
2445 s1 = htab->stub_group[input_sec->id].last_sec;
2446 s = htab->stub_group[s1->id].last_stub_sec;
2447 if (s != NULL && s->size > 0)
2448 end = s->output_section->vma + s->output_offset + s->size - 8;
2449 else
2450 end = s1->output_section->vma + s1->output_offset + s1->size;
2451
2452 BFD_ASSERT (start < end);
2453 BFD_ASSERT (start <= location);
2454 BFD_ASSERT (location < end);
2455
2456 /* Put stubs at the end of the group unless that is not a valid
2457 location and the beginning of the group is. It might be that
2458 neither the beginning nor end works if we have an input section
2459 so large that it spans multiple segment boundaries. In that
2460 case, punt; the end result will be a relocation overflow error no
2461 matter what we do here.
2462
2463 Note that adding stubs pushes up the addresses of all subsequent
2464 sections, so that stubs allocated on one pass through the
2465 relaxation loop may not be valid on the next pass. (E.g., we may
2466 allocate a stub at the beginning of the section on one pass and
2467 find that the call site has been bumped into the next memory
2468 segment on the next pass.) The important thing to note is that
2469 we never try to reclaim the space allocated to such unused stubs,
2470 so code size and section addresses can only increase with each
2471 iteration. Accounting for the start and end addresses of the
2472 already-created stub sections ensures that when the algorithm
2473 converges, it converges accurately, with the entire appropriate
2474 stub section accessible from the call site and not just the
2475 address at the start or end of the stub group proper. */
2476
2477 if (segment == CALL26_SEGMENT (end))
2478 return nios2_stub_call26_after;
2479 else if (segment == CALL26_SEGMENT (start))
2480 return nios2_stub_call26_before;
2481 else
2482 /* Perhaps this should be a dedicated error code. */
2483 return nios2_stub_none;
2484 }
2485
2486 static bfd_boolean
2487 nios2_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2488 {
2489 struct elf32_nios2_stub_hash_entry *hsh
2490 = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2491 asection *stub_sec = hsh->stub_sec;
2492 bfd_vma sym_value;
2493 struct bfd_link_info *info;
2494
2495 info = (struct bfd_link_info *) in_arg;
2496
2497 /* Fail if the target section could not be assigned to an output
2498 section. The user should fix his linker script. */
2499 if (hsh->target_section->output_section == NULL
2500 && info->non_contiguous_regions)
2501 info->callbacks->einfo (_("%F%P: Could not assign '%pA' to an output section. "
2502 "Retry without --enable-non-contiguous-regions.\n"),
2503 hsh->target_section);
2504
2505 /* Make a note of the offset within the stubs for this entry. */
2506 hsh->stub_offset = stub_sec->size;
2507
2508 switch (hsh->stub_type)
2509 {
2510 case nios2_stub_call26_before:
2511 case nios2_stub_call26_after:
2512 /* A call26 stub looks like:
2513 orhi at, %hiadj(dest)
2514 addi at, at, %lo(dest)
2515 jmp at
2516 Note that call/jmpi instructions can't be used in PIC code
2517 so there is no reason for the stub to be PIC, either. */
2518 sym_value = (hsh->target_value
2519 + hsh->target_section->output_offset
2520 + hsh->target_section->output_section->vma
2521 + hsh->addend);
2522
2523 nios2_elf32_install_data (stub_sec, nios2_call26_stub_entry,
2524 hsh->stub_offset, 3);
2525 nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset,
2526 hiadj (sym_value));
2527 nios2_elf32_install_imm16 (stub_sec, hsh->stub_offset + 4,
2528 (sym_value & 0xffff));
2529 stub_sec->size += 12;
2530 break;
2531 default:
2532 BFD_FAIL ();
2533 return FALSE;
2534 }
2535
2536 return TRUE;
2537 }
2538
2539 /* As above, but don't actually build the stub. Just bump offset so
2540 we know stub section sizes. */
2541 static bfd_boolean
2542 nios2_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
2543 {
2544 struct elf32_nios2_stub_hash_entry *hsh
2545 = (struct elf32_nios2_stub_hash_entry *) gen_entry;
2546
2547 switch (hsh->stub_type)
2548 {
2549 case nios2_stub_call26_before:
2550 case nios2_stub_call26_after:
2551 hsh->stub_sec->size += 12;
2552 break;
2553 default:
2554 BFD_FAIL ();
2555 return FALSE;
2556 }
2557 return TRUE;
2558 }
2559
2560 /* Read in all local syms for all input bfds.
2561 Returns -1 on error, 0 otherwise. */
2562
2563 static int
2564 get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
2565 struct bfd_link_info *info)
2566 {
2567 unsigned int bfd_indx;
2568 Elf_Internal_Sym *local_syms, **all_local_syms;
2569 struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2570
2571 /* We want to read in symbol extension records only once. To do this
2572 we need to read in the local symbols in parallel and save them for
2573 later use; so hold pointers to the local symbols in an array. */
2574 size_t amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
2575 all_local_syms = bfd_zmalloc (amt);
2576 htab->all_local_syms = all_local_syms;
2577 if (all_local_syms == NULL)
2578 return -1;
2579
2580 /* Walk over all the input BFDs, swapping in local symbols. */
2581 for (bfd_indx = 0;
2582 input_bfd != NULL;
2583 input_bfd = input_bfd->link.next, bfd_indx++)
2584 {
2585 Elf_Internal_Shdr *symtab_hdr;
2586
2587 /* We'll need the symbol table in a second. */
2588 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2589 if (symtab_hdr->sh_info == 0)
2590 continue;
2591
2592 /* We need an array of the local symbols attached to the input bfd. */
2593 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
2594 if (local_syms == NULL)
2595 {
2596 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2597 symtab_hdr->sh_info, 0,
2598 NULL, NULL, NULL);
2599 /* Cache them for elf_link_input_bfd. */
2600 symtab_hdr->contents = (unsigned char *) local_syms;
2601 }
2602 if (local_syms == NULL)
2603 return -1;
2604
2605 all_local_syms[bfd_indx] = local_syms;
2606 }
2607
2608 return 0;
2609 }
2610
2611 /* Determine and set the size of the stub section for a final link. */
2612 bfd_boolean
2613 nios2_elf32_size_stubs (bfd *output_bfd, bfd *stub_bfd,
2614 struct bfd_link_info *info,
2615 asection *(*add_stub_section) (const char *,
2616 asection *, bfd_boolean),
2617 void (*layout_sections_again) (void))
2618 {
2619 bfd_boolean stub_changed = FALSE;
2620 struct elf32_nios2_link_hash_table *htab = elf32_nios2_hash_table (info);
2621
2622 /* Stash our params away. */
2623 htab->stub_bfd = stub_bfd;
2624 htab->add_stub_section = add_stub_section;
2625 htab->layout_sections_again = layout_sections_again;
2626
2627 /* FIXME: We only compute the section groups once. This could cause
2628 problems if adding a large stub section causes following sections,
2629 or parts of them, to move into another segment. However, this seems
2630 to be consistent with the way other back ends handle this.... */
2631 group_sections (htab);
2632
2633 if (get_local_syms (output_bfd, info->input_bfds, info))
2634 {
2635 if (htab->all_local_syms)
2636 goto error_ret_free_local;
2637 return FALSE;
2638 }
2639
2640 while (1)
2641 {
2642 bfd *input_bfd;
2643 unsigned int bfd_indx;
2644 asection *stub_sec;
2645
2646 for (input_bfd = info->input_bfds, bfd_indx = 0;
2647 input_bfd != NULL;
2648 input_bfd = input_bfd->link.next, bfd_indx++)
2649 {
2650 Elf_Internal_Shdr *symtab_hdr;
2651 asection *section;
2652 Elf_Internal_Sym *local_syms;
2653
2654 /* We'll need the symbol table in a second. */
2655 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2656 if (symtab_hdr->sh_info == 0)
2657 continue;
2658
2659 local_syms = htab->all_local_syms[bfd_indx];
2660
2661 /* Walk over each section attached to the input bfd. */
2662 for (section = input_bfd->sections;
2663 section != NULL;
2664 section = section->next)
2665 {
2666 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
2667
2668 /* If there aren't any relocs, then there's nothing more
2669 to do. */
2670 if ((section->flags & SEC_RELOC) == 0
2671 || section->reloc_count == 0)
2672 continue;
2673
2674 /* If this section is a link-once section that will be
2675 discarded, then don't create any stubs. */
2676 if (section->output_section == NULL
2677 || section->output_section->owner != output_bfd)
2678 continue;
2679
2680 /* Get the relocs. */
2681 internal_relocs
2682 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
2683 info->keep_memory);
2684 if (internal_relocs == NULL)
2685 goto error_ret_free_local;
2686
2687 /* Now examine each relocation. */
2688 irela = internal_relocs;
2689 irelaend = irela + section->reloc_count;
2690 for (; irela < irelaend; irela++)
2691 {
2692 unsigned int r_type, r_indx;
2693 enum elf32_nios2_stub_type stub_type;
2694 struct elf32_nios2_stub_hash_entry *hsh;
2695 asection *sym_sec;
2696 bfd_vma sym_value;
2697 bfd_vma destination;
2698 struct elf32_nios2_link_hash_entry *hh;
2699 char *stub_name;
2700 const asection *id_sec;
2701
2702 r_type = ELF32_R_TYPE (irela->r_info);
2703 r_indx = ELF32_R_SYM (irela->r_info);
2704
2705 if (r_type >= (unsigned int) R_NIOS2_ILLEGAL)
2706 {
2707 bfd_set_error (bfd_error_bad_value);
2708 error_ret_free_internal:
2709 if (elf_section_data (section)->relocs == NULL)
2710 free (internal_relocs);
2711 goto error_ret_free_local;
2712 }
2713
2714 /* Only look for stubs on CALL and JMPI instructions. */
2715 if (r_type != (unsigned int) R_NIOS2_CALL26)
2716 continue;
2717
2718 /* Now determine the call target, its name, value,
2719 section. */
2720 sym_sec = NULL;
2721 sym_value = 0;
2722 destination = 0;
2723 hh = NULL;
2724 if (r_indx < symtab_hdr->sh_info)
2725 {
2726 /* It's a local symbol. */
2727 Elf_Internal_Sym *sym;
2728 Elf_Internal_Shdr *hdr;
2729 unsigned int shndx;
2730
2731 sym = local_syms + r_indx;
2732 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2733 sym_value = sym->st_value;
2734 shndx = sym->st_shndx;
2735 if (shndx < elf_numsections (input_bfd))
2736 {
2737 hdr = elf_elfsections (input_bfd)[shndx];
2738 sym_sec = hdr->bfd_section;
2739 destination = (sym_value + irela->r_addend
2740 + sym_sec->output_offset
2741 + sym_sec->output_section->vma);
2742 }
2743 }
2744 else
2745 {
2746 /* It's an external symbol. */
2747 int e_indx;
2748
2749 e_indx = r_indx - symtab_hdr->sh_info;
2750 hh = ((struct elf32_nios2_link_hash_entry *)
2751 elf_sym_hashes (input_bfd)[e_indx]);
2752
2753 while (hh->root.root.type == bfd_link_hash_indirect
2754 || hh->root.root.type == bfd_link_hash_warning)
2755 hh = ((struct elf32_nios2_link_hash_entry *)
2756 hh->root.root.u.i.link);
2757
2758 if (hh->root.root.type == bfd_link_hash_defined
2759 || hh->root.root.type == bfd_link_hash_defweak)
2760 {
2761 sym_sec = hh->root.root.u.def.section;
2762 sym_value = hh->root.root.u.def.value;
2763
2764 if (sym_sec->output_section != NULL)
2765 destination = (sym_value + irela->r_addend
2766 + sym_sec->output_offset
2767 + sym_sec->output_section->vma);
2768 else
2769 continue;
2770 }
2771 else if (hh->root.root.type == bfd_link_hash_undefweak)
2772 {
2773 if (! bfd_link_pic (info))
2774 continue;
2775 }
2776 else if (hh->root.root.type == bfd_link_hash_undefined)
2777 {
2778 if (! (info->unresolved_syms_in_objects == RM_IGNORE
2779 && (ELF_ST_VISIBILITY (hh->root.other)
2780 == STV_DEFAULT)))
2781 continue;
2782 }
2783 else
2784 {
2785 bfd_set_error (bfd_error_bad_value);
2786 goto error_ret_free_internal;
2787 }
2788 }
2789
2790 /* Determine what (if any) linker stub is needed. */
2791 stub_type = nios2_type_of_stub (section, irela, hh, htab,
2792 destination, info);
2793 if (stub_type == nios2_stub_none)
2794 continue;
2795
2796 /* Support for grouping stub sections. */
2797 if (stub_type == nios2_stub_call26_before)
2798 id_sec = htab->stub_group[section->id].first_sec;
2799 else
2800 id_sec = htab->stub_group[section->id].last_sec;
2801
2802 /* Get the name of this stub. */
2803 stub_name = nios2_stub_name (id_sec, sym_sec, hh, irela,
2804 stub_type);
2805 if (!stub_name)
2806 goto error_ret_free_internal;
2807
2808 hsh = nios2_stub_hash_lookup (&htab->bstab,
2809 stub_name,
2810 FALSE, FALSE);
2811 if (hsh != NULL)
2812 {
2813 /* The proper stub has already been created. */
2814 free (stub_name);
2815 continue;
2816 }
2817
2818 hsh = nios2_add_stub (stub_name, section, htab, stub_type);
2819 if (hsh == NULL)
2820 {
2821 free (stub_name);
2822 goto error_ret_free_internal;
2823 }
2824 hsh->target_value = sym_value;
2825 hsh->target_section = sym_sec;
2826 hsh->stub_type = stub_type;
2827 hsh->hh = hh;
2828 hsh->addend = irela->r_addend;
2829 stub_changed = TRUE;
2830 }
2831
2832 /* We're done with the internal relocs, free them. */
2833 if (elf_section_data (section)->relocs == NULL)
2834 free (internal_relocs);
2835 }
2836 }
2837
2838 if (!stub_changed)
2839 break;
2840
2841 /* OK, we've added some stubs. Find out the new size of the
2842 stub sections. */
2843 for (stub_sec = htab->stub_bfd->sections;
2844 stub_sec != NULL;
2845 stub_sec = stub_sec->next)
2846 stub_sec->size = 0;
2847
2848 bfd_hash_traverse (&htab->bstab, nios2_size_one_stub, htab);
2849
2850 /* Ask the linker to do its stuff. */
2851 (*htab->layout_sections_again) ();
2852 stub_changed = FALSE;
2853 }
2854
2855 free (htab->all_local_syms);
2856 return TRUE;
2857
2858 error_ret_free_local:
2859 free (htab->all_local_syms);
2860 return FALSE;
2861 }
2862
2863 /* Build all the stubs associated with the current output file. The
2864 stubs are kept in a hash table attached to the main linker hash
2865 table. This function is called via nios2elf_finish in the linker. */
2866 bfd_boolean
2867 nios2_elf32_build_stubs (struct bfd_link_info *info)
2868 {
2869 asection *stub_sec;
2870 struct bfd_hash_table *table;
2871 struct elf32_nios2_link_hash_table *htab;
2872
2873 htab = elf32_nios2_hash_table (info);
2874
2875 for (stub_sec = htab->stub_bfd->sections;
2876 stub_sec != NULL;
2877 stub_sec = stub_sec->next)
2878 /* The stub_bfd may contain non-stub sections if it is also the
2879 dynobj. Any such non-stub sections are created with the
2880 SEC_LINKER_CREATED flag set, while stub sections do not
2881 have that flag. Ignore any non-stub sections here. */
2882 if ((stub_sec->flags & SEC_LINKER_CREATED) == 0)
2883 {
2884 bfd_size_type size;
2885
2886 /* Allocate memory to hold the linker stubs. */
2887 size = stub_sec->size;
2888 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
2889 if (stub_sec->contents == NULL && size != 0)
2890 return FALSE;
2891 stub_sec->size = 0;
2892 }
2893
2894 /* Build the stubs as directed by the stub hash table. */
2895 table = &htab->bstab;
2896 bfd_hash_traverse (table, nios2_build_one_stub, info);
2897
2898 return TRUE;
2899 }
2900
2901
2902 #define is_nios2_elf(bfd) \
2903 (bfd_get_flavour (bfd) == bfd_target_elf_flavour \
2904 && elf_object_id (bfd) == NIOS2_ELF_DATA)
2905
2906 /* Merge backend specific data from an object file to the output
2907 object file when linking. */
2908
2909 static bfd_boolean
2910 nios2_elf32_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2911 {
2912 bfd *obfd = info->output_bfd;
2913 flagword old_flags;
2914 flagword new_flags;
2915
2916 if (!is_nios2_elf (ibfd) || !is_nios2_elf (obfd))
2917 return TRUE;
2918
2919 /* Check if we have the same endianness. */
2920 if (! _bfd_generic_verify_endian_match (ibfd, info))
2921 return FALSE;
2922
2923 new_flags = elf_elfheader (ibfd)->e_flags;
2924 old_flags = elf_elfheader (obfd)->e_flags;
2925 if (!elf_flags_init (obfd))
2926 {
2927 /* First call, no flags set. */
2928 elf_flags_init (obfd) = TRUE;
2929 elf_elfheader (obfd)->e_flags = new_flags;
2930
2931 switch (new_flags)
2932 {
2933 default:
2934 case EF_NIOS2_ARCH_R1:
2935 bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r1);
2936 break;
2937 case EF_NIOS2_ARCH_R2:
2938 if (bfd_big_endian (ibfd))
2939 {
2940 _bfd_error_handler
2941 (_("error: %pB: big-endian R2 is not supported"), ibfd);
2942 bfd_set_error (bfd_error_bad_value);
2943 return FALSE;
2944 }
2945 bfd_default_set_arch_mach (obfd, bfd_arch_nios2, bfd_mach_nios2r2);
2946 break;
2947 }
2948 }
2949
2950 /* Incompatible flags. */
2951 else if (new_flags != old_flags)
2952 {
2953 /* So far, the only incompatible flags denote incompatible
2954 architectures. */
2955 _bfd_error_handler
2956 /* xgettext:c-format */
2957 (_("error: %pB: conflicting CPU architectures %d/%d"),
2958 ibfd, new_flags, old_flags);
2959 bfd_set_error (bfd_error_bad_value);
2960 return FALSE;
2961 }
2962
2963 /* Merge Tag_compatibility attributes and any common GNU ones. */
2964 _bfd_elf_merge_object_attributes (ibfd, info);
2965
2966 return TRUE;
2967 }
2968
2969 /* Implement bfd_elf32_bfd_reloc_type_lookup:
2970 Given a BFD reloc type, return a howto structure. */
2971
2972 static reloc_howto_type *
2973 nios2_elf32_bfd_reloc_type_lookup (bfd *abfd,
2974 bfd_reloc_code_real_type code)
2975 {
2976 int i;
2977
2978 for (i = 0; i < (int) ARRAY_SIZE (nios2_reloc_map); ++i)
2979 if (nios2_reloc_map[i].bfd_val == code)
2980 return lookup_howto (nios2_reloc_map[i].elf_val, abfd);
2981 return NULL;
2982 }
2983
2984 /* Implement bfd_elf32_bfd_reloc_name_lookup:
2985 Given a reloc name, return a howto structure. */
2986
2987 static reloc_howto_type *
2988 nios2_elf32_bfd_reloc_name_lookup (bfd *abfd,
2989 const char *r_name)
2990 {
2991 int i;
2992 reloc_howto_type *howto_tbl;
2993 int howto_tbl_size;
2994
2995 if (BFD_IS_R2 (abfd))
2996 {
2997 howto_tbl = elf_nios2_r2_howto_table_rel;
2998 howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r2_howto_table_rel);
2999 }
3000 else
3001 {
3002 howto_tbl = elf_nios2_r1_howto_table_rel;
3003 howto_tbl_size = (int) ARRAY_SIZE (elf_nios2_r1_howto_table_rel);
3004 }
3005
3006 for (i = 0; i < howto_tbl_size; i++)
3007 if (howto_tbl[i].name && strcasecmp (howto_tbl[i].name, r_name) == 0)
3008 return howto_tbl + i;
3009
3010 return NULL;
3011 }
3012
3013 /* Implement elf_info_to_howto:
3014 Given a ELF32 relocation, fill in a arelent structure. */
3015
3016 static bfd_boolean
3017 nios2_elf32_info_to_howto (bfd *abfd, arelent *cache_ptr,
3018 Elf_Internal_Rela *dst)
3019 {
3020 unsigned int r_type;
3021
3022 r_type = ELF32_R_TYPE (dst->r_info);
3023 if ((cache_ptr->howto = lookup_howto (r_type, abfd)) == NULL)
3024 {
3025 /* xgettext:c-format */
3026 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
3027 abfd, r_type);
3028 bfd_set_error (bfd_error_bad_value);
3029 return FALSE;
3030 }
3031 return TRUE;
3032 }
3033
3034 /* Return the base VMA address which should be subtracted from real addresses
3035 when resolving @dtpoff relocation.
3036 This is PT_TLS segment p_vaddr. */
3037 static bfd_vma
3038 dtpoff_base (struct bfd_link_info *info)
3039 {
3040 /* If tls_sec is NULL, we should have signalled an error already. */
3041 if (elf_hash_table (info)->tls_sec == NULL)
3042 return 0;
3043 return elf_hash_table (info)->tls_sec->vma;
3044 }
3045
3046 /* Return the relocation value for @tpoff relocation
3047 if STT_TLS virtual address is ADDRESS. */
3048 static bfd_vma
3049 tpoff (struct bfd_link_info *info, bfd_vma address)
3050 {
3051 struct elf_link_hash_table *htab = elf_hash_table (info);
3052
3053 /* If tls_sec is NULL, we should have signalled an error already. */
3054 if (htab->tls_sec == NULL)
3055 return 0;
3056 return address - htab->tls_sec->vma;
3057 }
3058
3059 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
3060 dangerous relocation. */
3061 static bfd_boolean
3062 nios2_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp, struct bfd_link_info *info)
3063 {
3064
3065 bfd_boolean gp_found;
3066 struct bfd_hash_entry *h;
3067 struct bfd_link_hash_entry *lh;
3068
3069 /* If we've already figured out what GP will be, just return it. */
3070 *pgp = _bfd_get_gp_value (output_bfd);
3071 if (*pgp)
3072 return TRUE;
3073
3074 h = bfd_hash_lookup (&info->hash->table, "_gp", FALSE, FALSE);
3075 lh = (struct bfd_link_hash_entry *) h;
3076 lookup:
3077 if (lh)
3078 {
3079 switch (lh->type)
3080 {
3081 case bfd_link_hash_undefined:
3082 case bfd_link_hash_undefweak:
3083 case bfd_link_hash_common:
3084 gp_found = FALSE;
3085 break;
3086 case bfd_link_hash_defined:
3087 case bfd_link_hash_defweak:
3088 gp_found = TRUE;
3089 {
3090 asection *sym_sec = lh->u.def.section;
3091 bfd_vma sym_value = lh->u.def.value;
3092
3093 if (sym_sec->output_section)
3094 sym_value = (sym_value + sym_sec->output_offset
3095 + sym_sec->output_section->vma);
3096 *pgp = sym_value;
3097 }
3098 break;
3099 case bfd_link_hash_indirect:
3100 case bfd_link_hash_warning:
3101 lh = lh->u.i.link;
3102 /* @@FIXME ignoring warning for now */
3103 goto lookup;
3104 case bfd_link_hash_new:
3105 default:
3106 abort ();
3107 }
3108 }
3109 else
3110 gp_found = FALSE;
3111
3112 if (!gp_found)
3113 {
3114 /* Only get the error once. */
3115 *pgp = 4;
3116 _bfd_set_gp_value (output_bfd, *pgp);
3117 return FALSE;
3118 }
3119
3120 _bfd_set_gp_value (output_bfd, *pgp);
3121
3122 return TRUE;
3123 }
3124
3125 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
3126 if it's not available as we don't have a link_info pointer available here
3127 to look it up in the output symbol table. We don't need to adjust the
3128 symbol value for an external symbol if we are producing relocatable
3129 output. */
3130 static bfd_reloc_status_type
3131 nios2_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
3132 char **error_message, bfd_vma *pgp)
3133 {
3134 if (bfd_is_und_section (symbol->section) && !relocatable)
3135 {
3136 *pgp = 0;
3137 return bfd_reloc_undefined;
3138 }
3139
3140 *pgp = _bfd_get_gp_value (output_bfd);
3141 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
3142 {
3143 if (relocatable)
3144 {
3145 /* Make up a value. */
3146 *pgp = symbol->section->output_section->vma + 0x4000;
3147 _bfd_set_gp_value (output_bfd, *pgp);
3148 }
3149 else
3150 {
3151 *error_message
3152 = (char *) _("global pointer relative relocation when _gp not defined");
3153 return bfd_reloc_dangerous;
3154 }
3155 }
3156
3157 return bfd_reloc_ok;
3158 }
3159
3160 /* Do the relocations that require special handling. */
3161 static bfd_reloc_status_type
3162 nios2_elf32_do_hi16_relocate (bfd *abfd, reloc_howto_type *howto,
3163 asection *input_section,
3164 bfd_byte *data, bfd_vma offset,
3165 bfd_vma symbol_value, bfd_vma addend)
3166 {
3167 symbol_value = symbol_value + addend;
3168 addend = 0;
3169 symbol_value = (symbol_value >> 16) & 0xffff;
3170 return _bfd_final_link_relocate (howto, abfd, input_section,
3171 data, offset, symbol_value, addend);
3172 }
3173
3174 static bfd_reloc_status_type
3175 nios2_elf32_do_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3176 asection *input_section,
3177 bfd_byte *data, bfd_vma offset,
3178 bfd_vma symbol_value, bfd_vma addend)
3179 {
3180 symbol_value = symbol_value + addend;
3181 addend = 0;
3182 symbol_value = symbol_value & 0xffff;
3183 return _bfd_final_link_relocate (howto, abfd, input_section,
3184 data, offset, symbol_value, addend);
3185 }
3186
3187 static bfd_reloc_status_type
3188 nios2_elf32_do_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3189 asection *input_section,
3190 bfd_byte *data, bfd_vma offset,
3191 bfd_vma symbol_value, bfd_vma addend)
3192 {
3193 symbol_value = symbol_value + addend;
3194 addend = 0;
3195 symbol_value = hiadj(symbol_value);
3196 return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3197 symbol_value, addend);
3198 }
3199
3200 static bfd_reloc_status_type
3201 nios2_elf32_do_pcrel_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
3202 asection *input_section,
3203 bfd_byte *data, bfd_vma offset,
3204 bfd_vma symbol_value, bfd_vma addend)
3205 {
3206 symbol_value = symbol_value + addend;
3207 addend = 0;
3208 symbol_value = symbol_value & 0xffff;
3209 return _bfd_final_link_relocate (howto, abfd, input_section,
3210 data, offset, symbol_value, addend);
3211 }
3212
3213 static bfd_reloc_status_type
3214 nios2_elf32_do_pcrel_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
3215 asection *input_section,
3216 bfd_byte *data, bfd_vma offset,
3217 bfd_vma symbol_value, bfd_vma addend)
3218 {
3219 symbol_value = symbol_value + addend;
3220 symbol_value -= (input_section->output_section->vma
3221 + input_section->output_offset);
3222 symbol_value -= offset;
3223 addend = 0;
3224 symbol_value = hiadj(symbol_value);
3225 return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
3226 symbol_value, addend);
3227 }
3228
3229 static bfd_reloc_status_type
3230 nios2_elf32_do_pcrel16_relocate (bfd *abfd, reloc_howto_type *howto,
3231 asection *input_section,
3232 bfd_byte *data, bfd_vma offset,
3233 bfd_vma symbol_value, bfd_vma addend)
3234 {
3235 /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
3236 so we need to subtract 4 before doing a final_link_relocate. */
3237 symbol_value = symbol_value + addend - 4;
3238 addend = 0;
3239 return _bfd_final_link_relocate (howto, abfd, input_section,
3240 data, offset, symbol_value, addend);
3241 }
3242
3243 static bfd_reloc_status_type
3244 nios2_elf32_do_call26_relocate (bfd *abfd, reloc_howto_type *howto,
3245 asection *input_section,
3246 bfd_byte *data, bfd_vma offset,
3247 bfd_vma symbol_value, bfd_vma addend)
3248 {
3249 /* Check that the relocation is in the same page as the current address. */
3250 if (CALL26_SEGMENT (symbol_value + addend)
3251 != CALL26_SEGMENT (input_section->output_section->vma
3252 + input_section->output_offset
3253 + offset))
3254 return bfd_reloc_overflow;
3255
3256 /* Check that the target address is correctly aligned on a 4-byte
3257 boundary. */
3258 if ((symbol_value + addend) & 0x3)
3259 return bfd_reloc_overflow;
3260
3261 return _bfd_final_link_relocate (howto, abfd, input_section,
3262 data, offset, symbol_value, addend);
3263 }
3264
3265 static bfd_reloc_status_type
3266 nios2_elf32_do_gprel_relocate (bfd *abfd, reloc_howto_type *howto,
3267 asection *input_section,
3268 bfd_byte *data, bfd_vma offset,
3269 bfd_vma symbol_value, bfd_vma addend)
3270 {
3271 /* Because we need the output_bfd, the special handling is done
3272 in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate. */
3273 return _bfd_final_link_relocate (howto, abfd, input_section,
3274 data, offset, symbol_value, addend);
3275 }
3276
3277 static bfd_reloc_status_type
3278 nios2_elf32_do_ujmp_relocate (bfd *abfd, reloc_howto_type *howto,
3279 asection *input_section,
3280 bfd_byte *data, bfd_vma offset,
3281 bfd_vma symbol_value, bfd_vma addend)
3282 {
3283 bfd_vma symbol_lo16, symbol_hi16;
3284 bfd_reloc_status_type r;
3285 symbol_value = symbol_value + addend;
3286 addend = 0;
3287 symbol_hi16 = (symbol_value >> 16) & 0xffff;
3288 symbol_lo16 = symbol_value & 0xffff;
3289
3290 r = _bfd_final_link_relocate (howto, abfd, input_section,
3291 data, offset, symbol_hi16, addend);
3292
3293 if (r == bfd_reloc_ok)
3294 return _bfd_final_link_relocate (howto, abfd, input_section,
3295 data, offset + 4, symbol_lo16, addend);
3296
3297 return r;
3298 }
3299
3300 static bfd_reloc_status_type
3301 nios2_elf32_do_cjmp_relocate (bfd *abfd, reloc_howto_type *howto,
3302 asection *input_section,
3303 bfd_byte *data, bfd_vma offset,
3304 bfd_vma symbol_value, bfd_vma addend)
3305 {
3306 bfd_vma symbol_lo16, symbol_hi16;
3307 bfd_reloc_status_type r;
3308 symbol_value = symbol_value + addend;
3309 addend = 0;
3310 symbol_hi16 = (symbol_value >> 16) & 0xffff;
3311 symbol_lo16 = symbol_value & 0xffff;
3312
3313 r = _bfd_final_link_relocate (howto, abfd, input_section,
3314 data, offset, symbol_hi16, addend);
3315
3316 if (r == bfd_reloc_ok)
3317 return _bfd_final_link_relocate (howto, abfd, input_section,
3318 data, offset + 4, symbol_lo16, addend);
3319
3320 return r;
3321 }
3322
3323 static bfd_reloc_status_type
3324 nios2_elf32_do_callr_relocate (bfd *abfd, reloc_howto_type *howto,
3325 asection *input_section,
3326 bfd_byte *data, bfd_vma offset,
3327 bfd_vma symbol_value, bfd_vma addend)
3328 {
3329 bfd_vma symbol_lo16, symbol_hi16;
3330 bfd_reloc_status_type r;
3331 symbol_value = symbol_value + addend;
3332 addend = 0;
3333 symbol_hi16 = (symbol_value >> 16) & 0xffff;
3334 symbol_lo16 = symbol_value & 0xffff;
3335
3336 r = _bfd_final_link_relocate (howto, abfd, input_section,
3337 data, offset, symbol_hi16, addend);
3338
3339 if (r == bfd_reloc_ok)
3340 return _bfd_final_link_relocate (howto, abfd, input_section,
3341 data, offset + 4, symbol_lo16, addend);
3342
3343 return r;
3344 }
3345
3346 /* HOWTO handlers for relocations that require special handling. */
3347
3348 /* This is for relocations used only when relaxing to ensure
3349 changes in size of section don't screw up .align. */
3350 static bfd_reloc_status_type
3351 nios2_elf32_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
3352 asymbol *symbol ATTRIBUTE_UNUSED,
3353 void *data ATTRIBUTE_UNUSED, asection *input_section,
3354 bfd *output_bfd,
3355 char **error_message ATTRIBUTE_UNUSED)
3356 {
3357 if (output_bfd != NULL)
3358 reloc_entry->address += input_section->output_offset;
3359 return bfd_reloc_ok;
3360 }
3361
3362 static bfd_reloc_status_type
3363 nios2_elf32_hi16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3364 void *data, asection *input_section,
3365 bfd *output_bfd,
3366 char **error_message ATTRIBUTE_UNUSED)
3367 {
3368 /* This part is from bfd_elf_generic_reloc. */
3369 if (output_bfd != NULL
3370 && (symbol->flags & BSF_SECTION_SYM) == 0
3371 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3372 {
3373 reloc_entry->address += input_section->output_offset;
3374 return bfd_reloc_ok;
3375 }
3376
3377 if (output_bfd != NULL)
3378 /* FIXME: See bfd_perform_relocation. Is this right? */
3379 return bfd_reloc_continue;
3380
3381 return nios2_elf32_do_hi16_relocate (abfd, reloc_entry->howto,
3382 input_section,
3383 data, reloc_entry->address,
3384 (symbol->value
3385 + symbol->section->output_section->vma
3386 + symbol->section->output_offset),
3387 reloc_entry->addend);
3388 }
3389
3390 static bfd_reloc_status_type
3391 nios2_elf32_lo16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3392 void *data, asection *input_section,
3393 bfd *output_bfd,
3394 char **error_message ATTRIBUTE_UNUSED)
3395 {
3396 /* This part is from bfd_elf_generic_reloc. */
3397 if (output_bfd != NULL
3398 && (symbol->flags & BSF_SECTION_SYM) == 0
3399 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3400 {
3401 reloc_entry->address += input_section->output_offset;
3402 return bfd_reloc_ok;
3403 }
3404
3405 if (output_bfd != NULL)
3406 /* FIXME: See bfd_perform_relocation. Is this right? */
3407 return bfd_reloc_continue;
3408
3409 return nios2_elf32_do_lo16_relocate (abfd, reloc_entry->howto,
3410 input_section,
3411 data, reloc_entry->address,
3412 (symbol->value
3413 + symbol->section->output_section->vma
3414 + symbol->section->output_offset),
3415 reloc_entry->addend);
3416 }
3417
3418 static bfd_reloc_status_type
3419 nios2_elf32_hiadj16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3420 void *data, asection *input_section,
3421 bfd *output_bfd,
3422 char **error_message ATTRIBUTE_UNUSED)
3423 {
3424 /* This part is from bfd_elf_generic_reloc. */
3425 if (output_bfd != NULL
3426 && (symbol->flags & BSF_SECTION_SYM) == 0
3427 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3428 {
3429 reloc_entry->address += input_section->output_offset;
3430 return bfd_reloc_ok;
3431 }
3432
3433 if (output_bfd != NULL)
3434 /* FIXME: See bfd_perform_relocation. Is this right? */
3435 return bfd_reloc_continue;
3436
3437 return nios2_elf32_do_hiadj16_relocate (abfd, reloc_entry->howto,
3438 input_section,
3439 data, reloc_entry->address,
3440 (symbol->value
3441 + symbol->section->output_section->vma
3442 + symbol->section->output_offset),
3443 reloc_entry->addend);
3444 }
3445
3446 static bfd_reloc_status_type
3447 nios2_elf32_pcrel_lo16_relocate (bfd *abfd, arelent *reloc_entry,
3448 asymbol *symbol, void *data,
3449 asection *input_section, bfd *output_bfd,
3450 char **error_message ATTRIBUTE_UNUSED)
3451 {
3452 /* This part is from bfd_elf_generic_reloc. */
3453 if (output_bfd != NULL
3454 && (symbol->flags & BSF_SECTION_SYM) == 0
3455 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3456 {
3457 reloc_entry->address += input_section->output_offset;
3458 return bfd_reloc_ok;
3459 }
3460
3461 if (output_bfd != NULL)
3462 /* FIXME: See bfd_perform_relocation. Is this right? */
3463 return bfd_reloc_continue;
3464
3465 return nios2_elf32_do_pcrel_lo16_relocate (
3466 abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3467 (symbol->value + symbol->section->output_section->vma
3468 + symbol->section->output_offset),
3469 reloc_entry->addend);
3470 }
3471
3472 static bfd_reloc_status_type
3473 nios2_elf32_pcrel_hiadj16_relocate (bfd *abfd, arelent *reloc_entry,
3474 asymbol *symbol, void *data,
3475 asection *input_section, bfd *output_bfd,
3476 char **error_message ATTRIBUTE_UNUSED)
3477 {
3478 /* This part is from bfd_elf_generic_reloc. */
3479 if (output_bfd != NULL
3480 && (symbol->flags & BSF_SECTION_SYM) == 0
3481 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3482 {
3483 reloc_entry->address += input_section->output_offset;
3484 return bfd_reloc_ok;
3485 }
3486
3487 if (output_bfd != NULL)
3488 /* FIXME: See bfd_perform_relocation. Is this right? */
3489 return bfd_reloc_continue;
3490
3491 return nios2_elf32_do_pcrel_hiadj16_relocate (
3492 abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
3493 (symbol->value + symbol->section->output_section->vma
3494 + symbol->section->output_offset),
3495 reloc_entry->addend);
3496 }
3497
3498 static bfd_reloc_status_type
3499 nios2_elf32_pcrel16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3500 void *data, asection *input_section,
3501 bfd *output_bfd,
3502 char **error_message ATTRIBUTE_UNUSED)
3503 {
3504 /* This part is from bfd_elf_generic_reloc. */
3505 if (output_bfd != NULL
3506 && (symbol->flags & BSF_SECTION_SYM) == 0
3507 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3508 {
3509 reloc_entry->address += input_section->output_offset;
3510 return bfd_reloc_ok;
3511 }
3512
3513 if (output_bfd != NULL)
3514 /* FIXME: See bfd_perform_relocation. Is this right? */
3515 return bfd_reloc_continue;
3516
3517 return nios2_elf32_do_pcrel16_relocate (abfd, reloc_entry->howto,
3518 input_section,
3519 data, reloc_entry->address,
3520 (symbol->value
3521 + symbol->section->output_section->vma
3522 + symbol->section->output_offset),
3523 reloc_entry->addend);
3524 }
3525
3526 static bfd_reloc_status_type
3527 nios2_elf32_call26_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3528 void *data, asection *input_section,
3529 bfd *output_bfd,
3530 char **error_message ATTRIBUTE_UNUSED)
3531 {
3532 /* This part is from bfd_elf_generic_reloc. */
3533 if (output_bfd != NULL
3534 && (symbol->flags & BSF_SECTION_SYM) == 0
3535 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3536 {
3537 reloc_entry->address += input_section->output_offset;
3538 return bfd_reloc_ok;
3539 }
3540
3541 if (output_bfd != NULL)
3542 /* FIXME: See bfd_perform_relocation. Is this right? */
3543 return bfd_reloc_continue;
3544
3545 return nios2_elf32_do_call26_relocate (abfd, reloc_entry->howto,
3546 input_section,
3547 data, reloc_entry->address,
3548 (symbol->value
3549 + symbol->section->output_section->vma
3550 + symbol->section->output_offset),
3551 reloc_entry->addend);
3552 }
3553
3554 static bfd_reloc_status_type
3555 nios2_elf32_gprel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3556 void *data, asection *input_section,
3557 bfd *output_bfd, char **msg)
3558 {
3559 bfd_vma relocation;
3560 bfd_vma gp;
3561 bfd_reloc_status_type r;
3562
3563
3564 /* This part is from bfd_elf_generic_reloc. */
3565 if (output_bfd != NULL
3566 && (symbol->flags & BSF_SECTION_SYM) == 0
3567 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3568 {
3569 reloc_entry->address += input_section->output_offset;
3570 return bfd_reloc_ok;
3571 }
3572
3573 if (output_bfd != NULL)
3574 /* FIXME: See bfd_perform_relocation. Is this right? */
3575 return bfd_reloc_continue;
3576
3577 relocation = (symbol->value
3578 + symbol->section->output_section->vma
3579 + symbol->section->output_offset);
3580
3581 /* This assumes we've already cached the _gp symbol. */
3582 r = nios2_elf_final_gp (abfd, symbol, FALSE, msg, &gp);
3583 if (r == bfd_reloc_ok)
3584 {
3585 relocation = relocation + reloc_entry->addend - gp;
3586 reloc_entry->addend = 0;
3587 if ((signed) relocation < -32768 || (signed) relocation > 32767)
3588 {
3589 *msg = _("global pointer relative address out of range");
3590 r = bfd_reloc_outofrange;
3591 }
3592 else
3593 r = nios2_elf32_do_gprel_relocate (abfd, reloc_entry->howto,
3594 input_section,
3595 data, reloc_entry->address,
3596 relocation, reloc_entry->addend);
3597 }
3598
3599 return r;
3600 }
3601
3602 static bfd_reloc_status_type
3603 nios2_elf32_ujmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3604 void *data, asection *input_section,
3605 bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3606 {
3607 /* This part is from bfd_elf_generic_reloc. */
3608 if (output_bfd != NULL
3609 && (symbol->flags & BSF_SECTION_SYM) == 0
3610 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3611 {
3612 reloc_entry->address += input_section->output_offset;
3613 return bfd_reloc_ok;
3614 }
3615
3616 if (output_bfd != NULL)
3617 /* FIXME: See bfd_perform_relocation. Is this right? */
3618 return bfd_reloc_continue;
3619
3620 return nios2_elf32_do_ujmp_relocate (abfd, reloc_entry->howto,
3621 input_section,
3622 data, reloc_entry->address,
3623 (symbol->value
3624 + symbol->section->output_section->vma
3625 + symbol->section->output_offset),
3626 reloc_entry->addend);
3627 }
3628
3629 static bfd_reloc_status_type
3630 nios2_elf32_cjmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3631 void *data, asection *input_section,
3632 bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3633 {
3634 /* This part is from bfd_elf_generic_reloc. */
3635 if (output_bfd != NULL
3636 && (symbol->flags & BSF_SECTION_SYM) == 0
3637 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3638 {
3639 reloc_entry->address += input_section->output_offset;
3640 return bfd_reloc_ok;
3641 }
3642
3643 if (output_bfd != NULL)
3644 /* FIXME: See bfd_perform_relocation. Is this right? */
3645 return bfd_reloc_continue;
3646
3647 return nios2_elf32_do_cjmp_relocate (abfd, reloc_entry->howto,
3648 input_section,
3649 data, reloc_entry->address,
3650 (symbol->value
3651 + symbol->section->output_section->vma
3652 + symbol->section->output_offset),
3653 reloc_entry->addend);
3654 }
3655
3656 static bfd_reloc_status_type
3657 nios2_elf32_callr_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
3658 void *data, asection *input_section,
3659 bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
3660 {
3661 /* This part is from bfd_elf_generic_reloc. */
3662 if (output_bfd != NULL
3663 && (symbol->flags & BSF_SECTION_SYM) == 0
3664 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
3665 {
3666 reloc_entry->address += input_section->output_offset;
3667 return bfd_reloc_ok;
3668 }
3669
3670 if (output_bfd != NULL)
3671 /* FIXME: See bfd_perform_relocation. Is this right? */
3672 return bfd_reloc_continue;
3673
3674 return nios2_elf32_do_callr_relocate (abfd, reloc_entry->howto,
3675 input_section,
3676 data, reloc_entry->address,
3677 (symbol->value
3678 + symbol->section->output_section->vma
3679 + symbol->section->output_offset),
3680 reloc_entry->addend);
3681 }
3682
3683
3684 /* Implement elf_backend_relocate_section. */
3685 static bfd_boolean
3686 nios2_elf32_relocate_section (bfd *output_bfd,
3687 struct bfd_link_info *info,
3688 bfd *input_bfd,
3689 asection *input_section,
3690 bfd_byte *contents,
3691 Elf_Internal_Rela *relocs,
3692 Elf_Internal_Sym *local_syms,
3693 asection **local_sections)
3694 {
3695 Elf_Internal_Shdr *symtab_hdr;
3696 struct elf_link_hash_entry **sym_hashes;
3697 Elf_Internal_Rela *rel;
3698 Elf_Internal_Rela *relend;
3699 struct elf32_nios2_link_hash_table *htab;
3700 asection *sgot;
3701 asection *splt;
3702 asection *sreloc = NULL;
3703 bfd_vma *local_got_offsets;
3704 bfd_vma got_base;
3705
3706 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3707 sym_hashes = elf_sym_hashes (input_bfd);
3708 relend = relocs + input_section->reloc_count;
3709
3710 htab = elf32_nios2_hash_table (info);
3711 sgot = htab->root.sgot;
3712 splt = htab->root.splt;
3713 local_got_offsets = elf_local_got_offsets (input_bfd);
3714
3715 if (htab->h_gp_got == NULL)
3716 got_base = 0;
3717 else
3718 got_base = htab->h_gp_got->root.u.def.value;
3719
3720 for (rel = relocs; rel < relend; rel++)
3721 {
3722 reloc_howto_type *howto;
3723 unsigned long r_symndx;
3724 Elf_Internal_Sym *sym;
3725 asection *sec;
3726 struct elf_link_hash_entry *h;
3727 struct elf32_nios2_link_hash_entry *eh;
3728 bfd_vma relocation;
3729 bfd_vma gp;
3730 bfd_reloc_status_type r = bfd_reloc_ok;
3731 const char *name = NULL;
3732 int r_type;
3733 const char *format;
3734 char *msgbuf = NULL;
3735 char *msg = NULL;
3736 bfd_boolean unresolved_reloc;
3737 bfd_vma off;
3738 int use_plt;
3739
3740 r_type = ELF32_R_TYPE (rel->r_info);
3741 r_symndx = ELF32_R_SYM (rel->r_info);
3742
3743 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info), output_bfd);
3744 h = NULL;
3745 sym = NULL;
3746 sec = NULL;
3747
3748 if (r_symndx < symtab_hdr->sh_info)
3749 {
3750 sym = local_syms + r_symndx;
3751 sec = local_sections[r_symndx];
3752 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
3753 }
3754 else
3755 {
3756 bfd_boolean warned, ignored;
3757
3758 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
3759 r_symndx, symtab_hdr, sym_hashes,
3760 h, sec, relocation,
3761 unresolved_reloc, warned, ignored);
3762 }
3763
3764 if (sec && discarded_section (sec))
3765 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
3766 rel, 1, relend, howto, 0, contents);
3767
3768 /* Nothing more to do unless this is a final link. */
3769 if (bfd_link_relocatable (info))
3770 continue;
3771
3772 if (howto)
3773 {
3774 bfd_boolean resolved_to_zero;
3775
3776 resolved_to_zero = (h != NULL
3777 && UNDEFWEAK_NO_DYNAMIC_RELOC (info, h));
3778 switch (howto->type)
3779 {
3780 case R_NIOS2_HI16:
3781 r = nios2_elf32_do_hi16_relocate (input_bfd, howto,
3782 input_section,
3783 contents, rel->r_offset,
3784 relocation, rel->r_addend);
3785 break;
3786 case R_NIOS2_LO16:
3787 r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
3788 input_section,
3789 contents, rel->r_offset,
3790 relocation, rel->r_addend);
3791 break;
3792 case R_NIOS2_PCREL_LO:
3793 r = nios2_elf32_do_pcrel_lo16_relocate (input_bfd, howto,
3794 input_section,
3795 contents,
3796 rel->r_offset,
3797 relocation,
3798 rel->r_addend);
3799 break;
3800 case R_NIOS2_HIADJ16:
3801 r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
3802 input_section, contents,
3803 rel->r_offset, relocation,
3804 rel->r_addend);
3805 break;
3806 case R_NIOS2_PCREL_HA:
3807 r = nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd, howto,
3808 input_section,
3809 contents,
3810 rel->r_offset,
3811 relocation,
3812 rel->r_addend);
3813 break;
3814 case R_NIOS2_PCREL16:
3815 r = nios2_elf32_do_pcrel16_relocate (input_bfd, howto,
3816 input_section, contents,
3817 rel->r_offset, relocation,
3818 rel->r_addend);
3819 break;
3820 case R_NIOS2_GPREL:
3821 /* Turns an absolute address into a gp-relative address. */
3822 if (!nios2_elf_assign_gp (output_bfd, &gp, info))
3823 {
3824 bfd_vma reloc_address;
3825
3826 if (sec && sec->output_section)
3827 reloc_address = (sec->output_section->vma
3828 + sec->output_offset
3829 + rel->r_offset);
3830 else
3831 reloc_address = 0;
3832
3833 format = _("global pointer relative relocation at address "
3834 "%#" PRIx64 " when _gp not defined\n");
3835 if (asprintf (&msgbuf, format,
3836 (uint64_t) reloc_address) == -1)
3837 msgbuf = NULL;
3838 msg = msgbuf;
3839 r = bfd_reloc_dangerous;
3840 }
3841 else
3842 {
3843 bfd_vma symbol_address = rel->r_addend + relocation;
3844 relocation = symbol_address - gp;
3845 rel->r_addend = 0;
3846 if (((signed) relocation < -32768
3847 || (signed) relocation > 32767)
3848 && (!h
3849 || h->root.type == bfd_link_hash_defined
3850 || h->root.type == bfd_link_hash_defweak))
3851 {
3852 if (h)
3853 name = h->root.root.string;
3854 else
3855 {
3856 name = (bfd_elf_string_from_elf_section
3857 (input_bfd, symtab_hdr->sh_link,
3858 sym->st_name));
3859 if (name == NULL || *name == '\0')
3860 name = bfd_section_name (sec);
3861 }
3862 /* xgettext:c-format */
3863 format = _("unable to reach %s (at %#" PRIx64 ") from "
3864 "the global pointer (at %#" PRIx64 ") "
3865 "because the offset (%" PRId64 ") is out of "
3866 "the allowed range, -32678 to 32767\n" );
3867 if (asprintf (&msgbuf, format, name,
3868 (uint64_t) symbol_address, (uint64_t) gp,
3869 (int64_t) relocation) == -1)
3870 msgbuf = NULL;
3871 msg = msgbuf;
3872 r = bfd_reloc_outofrange;
3873 }
3874 else
3875 r = _bfd_final_link_relocate (howto, input_bfd,
3876 input_section, contents,
3877 rel->r_offset, relocation,
3878 rel->r_addend);
3879 }
3880 break;
3881 case R_NIOS2_UJMP:
3882 r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
3883 input_section,
3884 contents, rel->r_offset,
3885 relocation, rel->r_addend);
3886 break;
3887 case R_NIOS2_CJMP:
3888 r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
3889 input_section,
3890 contents, rel->r_offset,
3891 relocation, rel->r_addend);
3892 break;
3893 case R_NIOS2_CALLR:
3894 r = nios2_elf32_do_callr_relocate (input_bfd, howto,
3895 input_section, contents,
3896 rel->r_offset, relocation,
3897 rel->r_addend);
3898 break;
3899 case R_NIOS2_CALL26:
3900 case R_NIOS2_CALL26_NOAT:
3901 /* If we have a call to an undefined weak symbol, we just want
3902 to stuff a zero in the bits of the call instruction and
3903 bypass the normal call26 relocation handling, because it'll
3904 diagnose an overflow error if address 0 isn't in the same
3905 256MB segment as the call site. Presumably the call
3906 should be guarded by a null check anyway. */
3907 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
3908 {
3909 BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
3910 r = _bfd_final_link_relocate (howto, input_bfd,
3911 input_section, contents,
3912 rel->r_offset, relocation,
3913 rel->r_addend);
3914 break;
3915 }
3916 /* Handle relocations which should use the PLT entry.
3917 NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
3918 which may point to a PLT entry, but we don't need to handle
3919 that here. If we created a PLT entry, all branches in this
3920 object should go to it. */
3921 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
3922 {
3923 /* If we've created a .plt section, and assigned a PLT entry
3924 to this function, it should not be known to bind locally.
3925 If it were, we would have cleared the PLT entry. */
3926 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
3927
3928 relocation = (splt->output_section->vma
3929 + splt->output_offset
3930 + h->plt.offset);
3931
3932 unresolved_reloc = FALSE;
3933 }
3934 /* Detect R_NIOS2_CALL26 relocations that would overflow the
3935 256MB segment. Replace the target with a reference to a
3936 trampoline instead.
3937 Note that htab->stub_group is null if relaxation has been
3938 disabled by the --no-relax linker command-line option, so
3939 we can use that to skip this processing entirely. */
3940 if (howto->type == R_NIOS2_CALL26 && htab->stub_group)
3941 {
3942 bfd_vma dest = relocation + rel->r_addend;
3943 enum elf32_nios2_stub_type stub_type;
3944
3945 eh = (struct elf32_nios2_link_hash_entry *)h;
3946 stub_type = nios2_type_of_stub (input_section, rel, eh,
3947 htab, dest, NULL);
3948
3949 if (stub_type != nios2_stub_none)
3950 {
3951 struct elf32_nios2_stub_hash_entry *hsh;
3952
3953 hsh = nios2_get_stub_entry (input_section, sec,
3954 eh, rel, htab, stub_type);
3955 if (hsh == NULL)
3956 {
3957 r = bfd_reloc_undefined;
3958 break;
3959 }
3960
3961 dest = (hsh->stub_offset
3962 + hsh->stub_sec->output_offset
3963 + hsh->stub_sec->output_section->vma);
3964 r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3965 input_section,
3966 contents,
3967 rel->r_offset,
3968 dest, 0);
3969 break;
3970 }
3971 }
3972
3973 /* Normal case. */
3974 r = nios2_elf32_do_call26_relocate (input_bfd, howto,
3975 input_section, contents,
3976 rel->r_offset, relocation,
3977 rel->r_addend);
3978 break;
3979 case R_NIOS2_ALIGN:
3980 r = bfd_reloc_ok;
3981 /* For symmetry this would be
3982 r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
3983 input_section, contents,
3984 rel->r_offset, relocation,
3985 rel->r_addend);
3986 but do_ignore_reloc would do no more than return
3987 bfd_reloc_ok. */
3988 break;
3989
3990 case R_NIOS2_GOT16:
3991 case R_NIOS2_CALL16:
3992 case R_NIOS2_GOT_LO:
3993 case R_NIOS2_GOT_HA:
3994 case R_NIOS2_CALL_LO:
3995 case R_NIOS2_CALL_HA:
3996 /* Relocation is to the entry for this symbol in the
3997 global offset table. */
3998 if (sgot == NULL)
3999 {
4000 r = bfd_reloc_notsupported;
4001 break;
4002 }
4003
4004 use_plt = 0;
4005
4006 if (h != NULL)
4007 {
4008 bfd_boolean dyn;
4009
4010 eh = (struct elf32_nios2_link_hash_entry *)h;
4011 use_plt = (eh->got_types_used == CALL_USED
4012 && h->plt.offset != (bfd_vma) -1);
4013
4014 off = h->got.offset;
4015 BFD_ASSERT (off != (bfd_vma) -1);
4016 dyn = htab->root.dynamic_sections_created;
4017 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4018 bfd_link_pic (info),
4019 h)
4020 || (bfd_link_pic (info)
4021 && SYMBOL_REFERENCES_LOCAL (info, h))
4022 || ((ELF_ST_VISIBILITY (h->other)
4023 || resolved_to_zero)
4024 && h->root.type == bfd_link_hash_undefweak))
4025 {
4026 /* This is actually a static link, or it is a -Bsymbolic
4027 link and the symbol is defined locally. We must
4028 initialize this entry in the global offset table.
4029 Since the offset must always be a multiple of 4, we
4030 use the least significant bit to record whether we
4031 have initialized it already.
4032
4033 When doing a dynamic link, we create a .rela.got
4034 relocation entry to initialize the value. This is
4035 done in the finish_dynamic_symbol routine. */
4036 if ((off & 1) != 0)
4037 off &= ~1;
4038 else
4039 {
4040 bfd_put_32 (output_bfd, relocation,
4041 sgot->contents + off);
4042 h->got.offset |= 1;
4043 }
4044 }
4045 else
4046 unresolved_reloc = FALSE;
4047 }
4048 else
4049 {
4050 BFD_ASSERT (local_got_offsets != NULL
4051 && local_got_offsets[r_symndx] != (bfd_vma) -1);
4052
4053 off = local_got_offsets[r_symndx];
4054
4055 /* The offset must always be a multiple of 4. We use the
4056 least significant bit to record whether we have already
4057 generated the necessary reloc. */
4058 if ((off & 1) != 0)
4059 off &= ~1;
4060 else
4061 {
4062 bfd_put_32 (output_bfd, relocation,
4063 sgot->contents + off);
4064
4065 if (bfd_link_pic (info))
4066 {
4067 asection *srelgot;
4068 Elf_Internal_Rela outrel;
4069 bfd_byte *loc;
4070
4071 srelgot = htab->root.srelgot;
4072 BFD_ASSERT (srelgot != NULL);
4073
4074 outrel.r_addend = relocation;
4075 outrel.r_offset = (sgot->output_section->vma
4076 + sgot->output_offset
4077 + off);
4078 outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4079 loc = srelgot->contents;
4080 loc += (srelgot->reloc_count++ *
4081 sizeof (Elf32_External_Rela));
4082 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4083 }
4084
4085 local_got_offsets[r_symndx] |= 1;
4086 }
4087 }
4088
4089 if (use_plt && bfd_link_pic (info))
4090 {
4091 off = ((h->plt.offset - 24) / 12 + 3) * 4;
4092 relocation = (htab->root.sgotplt->output_offset + off
4093 - got_base);
4094 }
4095 else
4096 relocation = sgot->output_offset + off - got_base;
4097
4098 /* This relocation does not use the addend. */
4099 rel->r_addend = 0;
4100
4101 switch (howto->type)
4102 {
4103 case R_NIOS2_GOT_LO:
4104 case R_NIOS2_CALL_LO:
4105 r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4106 input_section, contents,
4107 rel->r_offset, relocation,
4108 rel->r_addend);
4109 break;
4110 case R_NIOS2_GOT_HA:
4111 case R_NIOS2_CALL_HA:
4112 r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4113 input_section, contents,
4114 rel->r_offset,
4115 relocation,
4116 rel->r_addend);
4117 break;
4118 default:
4119 r = _bfd_final_link_relocate (howto, input_bfd,
4120 input_section, contents,
4121 rel->r_offset, relocation,
4122 rel->r_addend);
4123 break;
4124 }
4125 break;
4126
4127 case R_NIOS2_GOTOFF_LO:
4128 case R_NIOS2_GOTOFF_HA:
4129 case R_NIOS2_GOTOFF:
4130 /* Relocation is relative to the global offset table pointer. */
4131
4132 BFD_ASSERT (sgot != NULL);
4133 if (sgot == NULL)
4134 {
4135 r = bfd_reloc_notsupported;
4136 break;
4137 }
4138
4139 /* Note that sgot->output_offset is not involved in this
4140 calculation. We always want the start of .got. */
4141 relocation -= sgot->output_section->vma;
4142
4143 /* Now we adjust the relocation to be relative to the GOT pointer
4144 (the _gp_got symbol), which possibly contains the 0x8000 bias. */
4145 relocation -= got_base;
4146
4147 switch (howto->type)
4148 {
4149 case R_NIOS2_GOTOFF_LO:
4150 r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
4151 input_section, contents,
4152 rel->r_offset, relocation,
4153 rel->r_addend);
4154 break;
4155 case R_NIOS2_GOTOFF_HA:
4156 r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
4157 input_section, contents,
4158 rel->r_offset,
4159 relocation,
4160 rel->r_addend);
4161 break;
4162 default:
4163 r = _bfd_final_link_relocate (howto, input_bfd,
4164 input_section, contents,
4165 rel->r_offset, relocation,
4166 rel->r_addend);
4167 break;
4168 }
4169 break;
4170
4171 case R_NIOS2_TLS_LDO16:
4172 relocation -= dtpoff_base (info) + DTP_OFFSET;
4173
4174 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4175 contents, rel->r_offset,
4176 relocation, rel->r_addend);
4177 break;
4178 case R_NIOS2_TLS_LDM16:
4179 if (htab->root.sgot == NULL)
4180 abort ();
4181
4182 off = htab->tls_ldm_got.offset;
4183
4184 if ((off & 1) != 0)
4185 off &= ~1;
4186 else
4187 {
4188 /* If we don't know the module number, create a relocation
4189 for it. */
4190 if (bfd_link_pic (info))
4191 {
4192 Elf_Internal_Rela outrel;
4193 bfd_byte *loc;
4194
4195 if (htab->root.srelgot == NULL)
4196 abort ();
4197
4198 outrel.r_addend = 0;
4199 outrel.r_offset = (htab->root.sgot->output_section->vma
4200 + htab->root.sgot->output_offset
4201 + off);
4202 outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
4203
4204 loc = htab->root.srelgot->contents;
4205 loc += (htab->root.srelgot->reloc_count++
4206 * sizeof (Elf32_External_Rela));
4207 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4208 }
4209 else
4210 bfd_put_32 (output_bfd, 1,
4211 htab->root.sgot->contents + off);
4212
4213 htab->tls_ldm_got.offset |= 1;
4214 }
4215
4216 relocation = htab->root.sgot->output_offset + off - got_base;
4217
4218 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4219 contents, rel->r_offset,
4220 relocation, rel->r_addend);
4221
4222 break;
4223 case R_NIOS2_TLS_GD16:
4224 case R_NIOS2_TLS_IE16:
4225 {
4226 int indx;
4227 char tls_type;
4228
4229 if (htab->root.sgot == NULL)
4230 abort ();
4231
4232 indx = 0;
4233 if (h != NULL)
4234 {
4235 bfd_boolean dyn;
4236 dyn = htab->root.dynamic_sections_created;
4237 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
4238 bfd_link_pic (info),
4239 h)
4240 && (!bfd_link_pic (info)
4241 || !SYMBOL_REFERENCES_LOCAL (info, h)))
4242 {
4243 unresolved_reloc = FALSE;
4244 indx = h->dynindx;
4245 }
4246 off = h->got.offset;
4247 tls_type = (((struct elf32_nios2_link_hash_entry *) h)
4248 ->tls_type);
4249 }
4250 else
4251 {
4252 if (local_got_offsets == NULL)
4253 abort ();
4254 off = local_got_offsets[r_symndx];
4255 tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
4256 [r_symndx]);
4257 }
4258
4259 if (tls_type == GOT_UNKNOWN)
4260 abort ();
4261
4262 if ((off & 1) != 0)
4263 off &= ~1;
4264 else
4265 {
4266 bfd_boolean need_relocs = FALSE;
4267 Elf_Internal_Rela outrel;
4268 bfd_byte *loc = NULL;
4269 int cur_off = off;
4270
4271 /* The GOT entries have not been initialized yet. Do it
4272 now, and emit any relocations. If both an IE GOT and a
4273 GD GOT are necessary, we emit the GD first. */
4274
4275 if ((bfd_link_pic (info) || indx != 0)
4276 && (h == NULL
4277 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4278 && !resolved_to_zero)
4279 || h->root.type != bfd_link_hash_undefweak))
4280 {
4281 need_relocs = TRUE;
4282 if (htab->root.srelgot == NULL)
4283 abort ();
4284 loc = htab->root.srelgot->contents;
4285 loc += (htab->root.srelgot->reloc_count *
4286 sizeof (Elf32_External_Rela));
4287 }
4288
4289 if (tls_type & GOT_TLS_GD)
4290 {
4291 if (need_relocs)
4292 {
4293 outrel.r_addend = 0;
4294 outrel.r_offset = (htab->root.sgot->output_section->vma
4295 + htab->root.sgot->output_offset
4296 + cur_off);
4297 outrel.r_info = ELF32_R_INFO (indx,
4298 R_NIOS2_TLS_DTPMOD);
4299
4300 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4301 loc);
4302 htab->root.srelgot->reloc_count++;
4303 loc += sizeof (Elf32_External_Rela);
4304
4305 if (indx == 0)
4306 bfd_put_32 (output_bfd,
4307 (relocation - dtpoff_base (info) -
4308 DTP_OFFSET),
4309 htab->root.sgot->contents + cur_off + 4);
4310 else
4311 {
4312 outrel.r_addend = 0;
4313 outrel.r_info = ELF32_R_INFO (indx,
4314 R_NIOS2_TLS_DTPREL);
4315 outrel.r_offset += 4;
4316
4317 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4318 loc);
4319 htab->root.srelgot->reloc_count++;
4320 loc += sizeof (Elf32_External_Rela);
4321 }
4322 }
4323 else
4324 {
4325 /* If we are not emitting relocations for a
4326 general dynamic reference, then we must be in a
4327 static link or an executable link with the
4328 symbol binding locally. Mark it as belonging
4329 to module 1, the executable. */
4330 bfd_put_32 (output_bfd, 1,
4331 htab->root.sgot->contents + cur_off);
4332 bfd_put_32 (output_bfd, (relocation -
4333 dtpoff_base (info) -
4334 DTP_OFFSET),
4335 htab->root.sgot->contents + cur_off + 4);
4336 }
4337
4338 cur_off += 8;
4339 }
4340
4341 if (tls_type & GOT_TLS_IE)
4342 {
4343 if (need_relocs)
4344 {
4345 if (indx == 0)
4346 outrel.r_addend = (relocation -
4347 dtpoff_base (info));
4348 else
4349 outrel.r_addend = 0;
4350 outrel.r_offset = (htab->root.sgot->output_section->vma
4351 + htab->root.sgot->output_offset
4352 + cur_off);
4353 outrel.r_info = ELF32_R_INFO (indx,
4354 R_NIOS2_TLS_TPREL);
4355
4356 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
4357 loc);
4358 htab->root.srelgot->reloc_count++;
4359 loc += sizeof (Elf32_External_Rela);
4360 }
4361 else
4362 bfd_put_32 (output_bfd, (tpoff (info, relocation)
4363 - TP_OFFSET),
4364 htab->root.sgot->contents + cur_off);
4365 cur_off += 4;
4366 }
4367
4368 if (h != NULL)
4369 h->got.offset |= 1;
4370 else
4371 local_got_offsets[r_symndx] |= 1;
4372 }
4373
4374 if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
4375 off += 8;
4376 relocation = htab->root.sgot->output_offset + off - got_base;
4377
4378 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4379 contents, rel->r_offset,
4380 relocation, rel->r_addend);
4381 }
4382
4383 break;
4384 case R_NIOS2_TLS_LE16:
4385 if (bfd_link_dll (info))
4386 {
4387 _bfd_error_handler
4388 /* xgettext:c-format */
4389 (_("%pB(%pA+%#" PRIx64 "): %s relocation not "
4390 "permitted in shared object"),
4391 input_bfd, input_section,
4392 (uint64_t) rel->r_offset, howto->name);
4393 return FALSE;
4394 }
4395 else
4396 relocation = tpoff (info, relocation) - TP_OFFSET;
4397
4398 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
4399 contents, rel->r_offset,
4400 relocation, rel->r_addend);
4401 break;
4402
4403 case R_NIOS2_BFD_RELOC_32:
4404 if (bfd_link_pic (info)
4405 && (input_section->flags & SEC_ALLOC) != 0
4406 && (h == NULL
4407 || (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
4408 && !resolved_to_zero)
4409 || h->root.type != bfd_link_hash_undefweak))
4410 {
4411 Elf_Internal_Rela outrel;
4412 bfd_byte *loc;
4413 bfd_boolean skip, relocate;
4414
4415 /* When generating a shared object, these relocations
4416 are copied into the output file to be resolved at run
4417 time. */
4418
4419 skip = FALSE;
4420 relocate = FALSE;
4421
4422 outrel.r_offset
4423 = _bfd_elf_section_offset (output_bfd, info,
4424 input_section, rel->r_offset);
4425 if (outrel.r_offset == (bfd_vma) -1)
4426 skip = TRUE;
4427 else if (outrel.r_offset == (bfd_vma) -2)
4428 skip = TRUE, relocate = TRUE;
4429 outrel.r_offset += (input_section->output_section->vma
4430 + input_section->output_offset);
4431
4432 if (skip)
4433 memset (&outrel, 0, sizeof outrel);
4434 else if (h != NULL
4435 && h->dynindx != -1
4436 && (!bfd_link_pic (info)
4437 || !SYMBOLIC_BIND (info, h)
4438 || !h->def_regular))
4439 {
4440 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
4441 outrel.r_addend = rel->r_addend;
4442 }
4443 else
4444 {
4445 /* This symbol is local, or marked to become local. */
4446 outrel.r_addend = relocation + rel->r_addend;
4447 relocate = TRUE;
4448 outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
4449 }
4450
4451 sreloc = elf_section_data (input_section)->sreloc;
4452 if (sreloc == NULL)
4453 abort ();
4454
4455 loc = sreloc->contents;
4456 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
4457 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
4458
4459 /* This reloc will be computed at runtime, so there's no
4460 need to do anything now, except for R_NIOS2_BFD_RELOC_32
4461 relocations that have been turned into
4462 R_NIOS2_RELATIVE. */
4463 if (!relocate)
4464 break;
4465 }
4466
4467 r = _bfd_final_link_relocate (howto, input_bfd,
4468 input_section, contents,
4469 rel->r_offset, relocation,
4470 rel->r_addend);
4471 break;
4472
4473 case R_NIOS2_TLS_DTPREL:
4474 relocation -= dtpoff_base (info);
4475 /* Fall through. */
4476
4477 default:
4478 r = _bfd_final_link_relocate (howto, input_bfd,
4479 input_section, contents,
4480 rel->r_offset, relocation,
4481 rel->r_addend);
4482 break;
4483 }
4484 }
4485 else
4486 r = bfd_reloc_notsupported;
4487
4488 if (r != bfd_reloc_ok)
4489 {
4490 if (h != NULL)
4491 name = h->root.root.string;
4492 else
4493 {
4494 name = bfd_elf_string_from_elf_section (input_bfd,
4495 symtab_hdr->sh_link,
4496 sym->st_name);
4497 if (name == NULL || *name == '\0')
4498 name = bfd_section_name (sec);
4499 }
4500
4501 switch (r)
4502 {
4503 case bfd_reloc_overflow:
4504 (*info->callbacks->reloc_overflow) (info, NULL, name,
4505 howto->name, (bfd_vma) 0,
4506 input_bfd, input_section,
4507 rel->r_offset);
4508 break;
4509
4510 case bfd_reloc_undefined:
4511 (*info->callbacks->undefined_symbol) (info, name, input_bfd,
4512 input_section,
4513 rel->r_offset, TRUE);
4514 break;
4515
4516 case bfd_reloc_outofrange:
4517 if (msg == NULL)
4518 msg = _("relocation out of range");
4519 break;
4520
4521 case bfd_reloc_notsupported:
4522 if (msg == NULL)
4523 msg = _("unsupported relocation");
4524 break;
4525
4526 case bfd_reloc_dangerous:
4527 if (msg == NULL)
4528 msg = _("dangerous relocation");
4529 break;
4530
4531 default:
4532 if (msg == NULL)
4533 msg = _("unknown error");
4534 break;
4535 }
4536
4537 if (msg)
4538 {
4539 (*info->callbacks->warning) (info, msg, name, input_bfd,
4540 input_section, rel->r_offset);
4541 free (msgbuf);
4542 return FALSE;
4543 }
4544 }
4545 }
4546 return TRUE;
4547 }
4548
4549 /* Implement elf-backend_section_flags:
4550 Convert NIOS2 specific section flags to bfd internal section flags. */
4551 static bfd_boolean
4552 nios2_elf32_section_flags (const Elf_Internal_Shdr *hdr)
4553 {
4554 if (hdr->sh_flags & SHF_NIOS2_GPREL)
4555 hdr->bfd_section->flags |= SEC_SMALL_DATA;
4556
4557 return TRUE;
4558 }
4559
4560 /* Implement elf_backend_fake_sections:
4561 Set the correct type for an NIOS2 ELF section. We do this by the
4562 section name, which is a hack, but ought to work. */
4563 static bfd_boolean
4564 nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
4565 Elf_Internal_Shdr *hdr, asection *sec)
4566 {
4567 const char *name = bfd_section_name (sec);
4568
4569 if ((sec->flags & SEC_SMALL_DATA)
4570 || strcmp (name, ".sdata") == 0
4571 || strcmp (name, ".sbss") == 0
4572 || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
4573 hdr->sh_flags |= SHF_NIOS2_GPREL;
4574
4575 return TRUE;
4576 }
4577
4578 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
4579 shortcuts to them in our hash table. */
4580 static bfd_boolean
4581 create_got_section (bfd *dynobj, struct bfd_link_info *info)
4582 {
4583 struct elf32_nios2_link_hash_table *htab;
4584 struct elf_link_hash_entry *h;
4585
4586 htab = elf32_nios2_hash_table (info);
4587
4588 if (! _bfd_elf_create_got_section (dynobj, info))
4589 return FALSE;
4590
4591 /* In order for the two loads in .PLTresolve to share the same %hiadj,
4592 _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary. */
4593 if (!bfd_set_section_alignment (htab->root.sgotplt, 4))
4594 return FALSE;
4595
4596 /* The Nios II ABI specifies that GOT-relative relocations are relative
4597 to the linker-created symbol _gp_got, rather than using
4598 _GLOBAL_OFFSET_TABLE_ directly. In particular, the latter always
4599 points to the base of the GOT while _gp_got may include a bias. */
4600 h = _bfd_elf_define_linkage_sym (dynobj, info, htab->root.sgotplt,
4601 "_gp_got");
4602 htab->h_gp_got = h;
4603 if (h == NULL)
4604 return FALSE;
4605
4606 return TRUE;
4607 }
4608
4609 /* Implement elf_backend_create_dynamic_sections:
4610 Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
4611 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
4612 hash table. */
4613 static bfd_boolean
4614 nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
4615 {
4616 struct elf32_nios2_link_hash_table *htab;
4617
4618 htab = elf32_nios2_hash_table (info);
4619 if (!htab->root.sgot && !create_got_section (dynobj, info))
4620 return FALSE;
4621
4622 if (!_bfd_elf_create_dynamic_sections (dynobj, info))
4623 return FALSE;
4624
4625 /* In order for the two loads in a shared object .PLTresolve to share the
4626 same %hiadj, the start of the PLT (as well as the GOT) must be aligned
4627 to a 16-byte boundary. This is because the addresses for these loads
4628 include the -(.plt+4) PIC correction. */
4629 return bfd_set_section_alignment (htab->root.splt, 4);
4630 }
4631
4632 /* Implement elf_backend_copy_indirect_symbol:
4633 Copy the extra info we tack onto an elf_link_hash_entry. */
4634 static void
4635 nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
4636 struct elf_link_hash_entry *dir,
4637 struct elf_link_hash_entry *ind)
4638 {
4639 struct elf32_nios2_link_hash_entry *edir, *eind;
4640
4641 edir = (struct elf32_nios2_link_hash_entry *) dir;
4642 eind = (struct elf32_nios2_link_hash_entry *) ind;
4643
4644 if (eind->dyn_relocs != NULL)
4645 {
4646 if (edir->dyn_relocs != NULL)
4647 {
4648 struct elf_dyn_relocs **pp;
4649 struct elf_dyn_relocs *p;
4650
4651 /* Add reloc counts against the indirect sym to the direct sym
4652 list. Merge any entries against the same section. */
4653 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
4654 {
4655 struct elf_dyn_relocs *q;
4656
4657 for (q = edir->dyn_relocs; q != NULL; q = q->next)
4658 if (q->sec == p->sec)
4659 {
4660 q->pc_count += p->pc_count;
4661 q->count += p->count;
4662 *pp = p->next;
4663 break;
4664 }
4665 if (q == NULL)
4666 pp = &p->next;
4667 }
4668 *pp = edir->dyn_relocs;
4669 }
4670
4671 edir->dyn_relocs = eind->dyn_relocs;
4672 eind->dyn_relocs = NULL;
4673 }
4674
4675 if (ind->root.type == bfd_link_hash_indirect
4676 && dir->got.refcount <= 0)
4677 {
4678 edir->tls_type = eind->tls_type;
4679 eind->tls_type = GOT_UNKNOWN;
4680 }
4681
4682 edir->got_types_used |= eind->got_types_used;
4683
4684 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
4685 }
4686
4687 /* Set the right machine number for a NIOS2 ELF file. */
4688
4689 static bfd_boolean
4690 nios2_elf32_object_p (bfd *abfd)
4691 {
4692 unsigned long mach;
4693
4694 mach = elf_elfheader (abfd)->e_flags;
4695
4696 switch (mach)
4697 {
4698 default:
4699 case EF_NIOS2_ARCH_R1:
4700 bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r1);
4701 break;
4702 case EF_NIOS2_ARCH_R2:
4703 bfd_default_set_arch_mach (abfd, bfd_arch_nios2, bfd_mach_nios2r2);
4704 break;
4705 }
4706
4707 return TRUE;
4708 }
4709
4710 /* Implement elf_backend_check_relocs:
4711 Look through the relocs for a section during the first phase. */
4712 static bfd_boolean
4713 nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
4714 asection *sec, const Elf_Internal_Rela *relocs)
4715 {
4716 Elf_Internal_Shdr *symtab_hdr;
4717 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4718 const Elf_Internal_Rela *rel;
4719 const Elf_Internal_Rela *rel_end;
4720 struct elf32_nios2_link_hash_table *htab;
4721 asection *sreloc = NULL;
4722 bfd_signed_vma *local_got_refcounts;
4723
4724 if (bfd_link_relocatable (info))
4725 return TRUE;
4726
4727 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4728 sym_hashes = elf_sym_hashes (abfd);
4729 sym_hashes_end = (sym_hashes
4730 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
4731 if (!elf_bad_symtab (abfd))
4732 sym_hashes_end -= symtab_hdr->sh_info;
4733 local_got_refcounts = elf_local_got_refcounts (abfd);
4734
4735 htab = elf32_nios2_hash_table (info);
4736
4737 rel_end = relocs + sec->reloc_count;
4738 for (rel = relocs; rel < rel_end; rel++)
4739 {
4740 unsigned int r_type;
4741 struct elf_link_hash_entry *h;
4742 unsigned long r_symndx;
4743
4744 r_symndx = ELF32_R_SYM (rel->r_info);
4745 if (r_symndx < symtab_hdr->sh_info)
4746 h = NULL;
4747 else
4748 {
4749 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4750 while (h->root.type == bfd_link_hash_indirect
4751 || h->root.type == bfd_link_hash_warning)
4752 h = (struct elf_link_hash_entry *) h->root.u.i.link;
4753 }
4754
4755 r_type = ELF32_R_TYPE (rel->r_info);
4756
4757 switch (r_type)
4758 {
4759 case R_NIOS2_GOT16:
4760 case R_NIOS2_GOT_LO:
4761 case R_NIOS2_GOT_HA:
4762 case R_NIOS2_CALL16:
4763 case R_NIOS2_CALL_LO:
4764 case R_NIOS2_CALL_HA:
4765 case R_NIOS2_TLS_GD16:
4766 case R_NIOS2_TLS_IE16:
4767 /* This symbol requires a global offset table entry. */
4768 {
4769 int tls_type, old_tls_type;
4770
4771 switch (r_type)
4772 {
4773 default:
4774 case R_NIOS2_GOT16:
4775 case R_NIOS2_GOT_LO:
4776 case R_NIOS2_GOT_HA:
4777 case R_NIOS2_CALL16:
4778 case R_NIOS2_CALL_LO:
4779 case R_NIOS2_CALL_HA:
4780 tls_type = GOT_NORMAL;
4781 break;
4782 case R_NIOS2_TLS_GD16:
4783 tls_type = GOT_TLS_GD;
4784 break;
4785 case R_NIOS2_TLS_IE16:
4786 tls_type = GOT_TLS_IE;
4787 break;
4788 }
4789
4790 if (h != NULL)
4791 {
4792 struct elf32_nios2_link_hash_entry *eh
4793 = (struct elf32_nios2_link_hash_entry *)h;
4794 h->got.refcount++;
4795 old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
4796 if (r_type == R_NIOS2_CALL16
4797 || r_type == R_NIOS2_CALL_LO
4798 || r_type == R_NIOS2_CALL_HA)
4799 {
4800 /* Make sure a plt entry is created for this symbol if
4801 it turns out to be a function defined by a dynamic
4802 object. */
4803 h->plt.refcount++;
4804 h->needs_plt = 1;
4805 h->type = STT_FUNC;
4806 eh->got_types_used |= CALL_USED;
4807 }
4808 else
4809 eh->got_types_used |= GOT_USED;
4810 }
4811 else
4812 {
4813 /* This is a global offset table entry for a local symbol. */
4814 if (local_got_refcounts == NULL)
4815 {
4816 bfd_size_type size;
4817
4818 size = symtab_hdr->sh_info;
4819 size *= (sizeof (bfd_signed_vma) + sizeof (char));
4820 local_got_refcounts
4821 = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
4822 if (local_got_refcounts == NULL)
4823 return FALSE;
4824 elf_local_got_refcounts (abfd) = local_got_refcounts;
4825 elf32_nios2_local_got_tls_type (abfd)
4826 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
4827 }
4828 local_got_refcounts[r_symndx]++;
4829 old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
4830 }
4831
4832 /* We will already have issued an error message if there is a
4833 TLS / non-TLS mismatch, based on the symbol type. We don't
4834 support any linker relaxations. So just combine any TLS
4835 types needed. */
4836 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
4837 && tls_type != GOT_NORMAL)
4838 tls_type |= old_tls_type;
4839
4840 if (old_tls_type != tls_type)
4841 {
4842 if (h != NULL)
4843 elf32_nios2_hash_entry (h)->tls_type = tls_type;
4844 else
4845 elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
4846 }
4847 }
4848 make_got:
4849 if (htab->root.sgot == NULL)
4850 {
4851 if (htab->root.dynobj == NULL)
4852 htab->root.dynobj = abfd;
4853 if (!create_got_section (htab->root.dynobj, info))
4854 return FALSE;
4855 }
4856 break;
4857
4858 case R_NIOS2_TLS_LDM16:
4859 htab->tls_ldm_got.refcount++;
4860 goto make_got;
4861
4862 /* This relocation describes the C++ object vtable hierarchy.
4863 Reconstruct it for later use during GC. */
4864 case R_NIOS2_GNU_VTINHERIT:
4865 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4866 return FALSE;
4867 break;
4868
4869 /* This relocation describes which C++ vtable entries are actually
4870 used. Record for later use during GC. */
4871 case R_NIOS2_GNU_VTENTRY:
4872 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4873 return FALSE;
4874 break;
4875
4876 case R_NIOS2_BFD_RELOC_32:
4877 case R_NIOS2_CALL26:
4878 case R_NIOS2_CALL26_NOAT:
4879 case R_NIOS2_HIADJ16:
4880 case R_NIOS2_LO16:
4881
4882 if (h != NULL)
4883 {
4884 /* If this reloc is in a read-only section, we might
4885 need a copy reloc. We can't check reliably at this
4886 stage whether the section is read-only, as input
4887 sections have not yet been mapped to output sections.
4888 Tentatively set the flag for now, and correct in
4889 adjust_dynamic_symbol. */
4890 if (!bfd_link_pic (info))
4891 h->non_got_ref = 1;
4892
4893 /* Make sure a plt entry is created for this symbol if it
4894 turns out to be a function defined by a dynamic object. */
4895 h->plt.refcount++;
4896
4897 if (r_type == R_NIOS2_CALL26 || r_type == R_NIOS2_CALL26_NOAT)
4898 h->needs_plt = 1;
4899 }
4900
4901 /* If we are creating a shared library, we need to copy the
4902 reloc into the shared library. */
4903 if (bfd_link_pic (info)
4904 && (sec->flags & SEC_ALLOC) != 0
4905 && (r_type == R_NIOS2_BFD_RELOC_32
4906 || (h != NULL && ! h->needs_plt
4907 && (! SYMBOLIC_BIND (info, h) || ! h->def_regular))))
4908 {
4909 struct elf_dyn_relocs *p;
4910 struct elf_dyn_relocs **head;
4911
4912 /* When creating a shared object, we must copy these
4913 reloc types into the output file. We create a reloc
4914 section in dynobj and make room for this reloc. */
4915 if (sreloc == NULL)
4916 {
4917 if (htab->root.dynobj == NULL)
4918 htab->root.dynobj = abfd;
4919
4920 sreloc = _bfd_elf_make_dynamic_reloc_section
4921 (sec, htab->root.dynobj, 2, abfd, TRUE);
4922 if (sreloc == NULL)
4923 return FALSE;
4924 }
4925
4926 /* If this is a global symbol, we count the number of
4927 relocations we need for this symbol. */
4928 if (h != NULL)
4929 head = &((struct elf32_nios2_link_hash_entry *) h)->dyn_relocs;
4930 else
4931 {
4932 /* Track dynamic relocs needed for local syms too.
4933 We really need local syms available to do this
4934 easily. Oh well. */
4935
4936 asection *s;
4937 void *vpp;
4938 Elf_Internal_Sym *isym;
4939
4940 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
4941 abfd, r_symndx);
4942 if (isym == NULL)
4943 return FALSE;
4944
4945 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
4946 if (s == NULL)
4947 s = sec;
4948
4949 vpp = &elf_section_data (s)->local_dynrel;
4950 head = (struct elf_dyn_relocs **) vpp;
4951 }
4952
4953 p = *head;
4954 if (p == NULL || p->sec != sec)
4955 {
4956 size_t amt = sizeof *p;
4957 p = ((struct elf_dyn_relocs *)
4958 bfd_alloc (htab->root.dynobj, amt));
4959 if (p == NULL)
4960 return FALSE;
4961 p->next = *head;
4962 *head = p;
4963 p->sec = sec;
4964 p->count = 0;
4965 p->pc_count = 0;
4966 }
4967
4968 p->count += 1;
4969
4970 }
4971 break;
4972 }
4973 }
4974
4975 return TRUE;
4976 }
4977
4978
4979 /* Implement elf_backend_gc_mark_hook:
4980 Return the section that should be marked against GC for a given
4981 relocation. */
4982 static asection *
4983 nios2_elf32_gc_mark_hook (asection *sec,
4984 struct bfd_link_info *info,
4985 Elf_Internal_Rela *rel,
4986 struct elf_link_hash_entry *h,
4987 Elf_Internal_Sym *sym)
4988 {
4989 if (h != NULL)
4990 switch (ELF32_R_TYPE (rel->r_info))
4991 {
4992 case R_NIOS2_GNU_VTINHERIT:
4993 case R_NIOS2_GNU_VTENTRY:
4994 return NULL;
4995 }
4996 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4997 }
4998
4999 /* Implement elf_backend_finish_dynamic_symbols:
5000 Finish up dynamic symbol handling. We set the contents of various
5001 dynamic sections here. */
5002 static bfd_boolean
5003 nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
5004 struct bfd_link_info *info,
5005 struct elf_link_hash_entry *h,
5006 Elf_Internal_Sym *sym)
5007 {
5008 struct elf32_nios2_link_hash_table *htab;
5009 struct elf32_nios2_link_hash_entry *eh
5010 = (struct elf32_nios2_link_hash_entry *)h;
5011 int use_plt;
5012
5013 htab = elf32_nios2_hash_table (info);
5014
5015 if (h->plt.offset != (bfd_vma) -1)
5016 {
5017 asection *splt;
5018 asection *sgotplt;
5019 asection *srela;
5020 bfd_vma plt_index;
5021 bfd_vma got_offset;
5022 Elf_Internal_Rela rela;
5023 bfd_byte *loc;
5024 bfd_vma got_address;
5025
5026 /* This symbol has an entry in the procedure linkage table. Set
5027 it up. */
5028 BFD_ASSERT (h->dynindx != -1);
5029 splt = htab->root.splt;
5030 sgotplt = htab->root.sgotplt;
5031 srela = htab->root.srelplt;
5032 BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
5033
5034 /* Emit the PLT entry. */
5035 if (bfd_link_pic (info))
5036 {
5037 nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
5038 3);
5039 plt_index = (h->plt.offset - 24) / 12;
5040 got_offset = (plt_index + 3) * 4;
5041 nios2_elf32_install_imm16 (splt, h->plt.offset,
5042 hiadj(plt_index * 4));
5043 nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5044 (plt_index * 4) & 0xffff);
5045 nios2_elf32_install_imm16 (splt, h->plt.offset + 8,
5046 0xfff4 - h->plt.offset);
5047 got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5048 + got_offset);
5049
5050 /* Fill in the entry in the global offset table. There are no
5051 res_n slots for a shared object PLT, instead the .got.plt entries
5052 point to the PLT entries. */
5053 bfd_put_32 (output_bfd,
5054 splt->output_section->vma + splt->output_offset
5055 + h->plt.offset, sgotplt->contents + got_offset);
5056 }
5057 else
5058 {
5059 plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
5060 got_offset = (plt_index + 3) * 4;
5061
5062 nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
5063 got_address = (sgotplt->output_section->vma + sgotplt->output_offset
5064 + got_offset);
5065 nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj(got_address));
5066 nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
5067 got_address & 0xffff);
5068
5069 /* Fill in the entry in the global offset table. */
5070 bfd_put_32 (output_bfd,
5071 splt->output_section->vma + splt->output_offset
5072 + plt_index * 4, sgotplt->contents + got_offset);
5073 }
5074
5075 /* Fill in the entry in the .rela.plt section. */
5076 rela.r_offset = got_address;
5077 rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
5078 rela.r_addend = 0;
5079 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
5080 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5081
5082 if (!h->def_regular)
5083 {
5084 /* Mark the symbol as undefined, rather than as defined in
5085 the .plt section. Leave the value alone. */
5086 sym->st_shndx = SHN_UNDEF;
5087 /* If the symbol is weak, we do need to clear the value.
5088 Otherwise, the PLT entry would provide a definition for
5089 the symbol even if the symbol wasn't defined anywhere,
5090 and so the symbol would never be NULL. */
5091 if (!h->ref_regular_nonweak)
5092 sym->st_value = 0;
5093 }
5094 }
5095
5096 use_plt = (eh->got_types_used == CALL_USED
5097 && h->plt.offset != (bfd_vma) -1);
5098
5099 if (!use_plt && h->got.offset != (bfd_vma) -1
5100 && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
5101 && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
5102 {
5103 asection *sgot;
5104 asection *srela;
5105 Elf_Internal_Rela rela;
5106 bfd_byte *loc;
5107 bfd_vma offset;
5108
5109 /* This symbol has an entry in the global offset table. Set it
5110 up. */
5111 sgot = htab->root.sgot;
5112 srela = htab->root.srelgot;
5113 BFD_ASSERT (sgot != NULL && srela != NULL);
5114
5115 offset = (h->got.offset & ~(bfd_vma) 1);
5116 rela.r_offset = (sgot->output_section->vma
5117 + sgot->output_offset + offset);
5118
5119 /* If this is a -Bsymbolic link, and the symbol is defined
5120 locally, we just want to emit a RELATIVE reloc. Likewise if
5121 the symbol was forced to be local because of a version file.
5122 The entry in the global offset table will already have been
5123 initialized in the relocate_section function. */
5124
5125 if (bfd_link_pic (info) && SYMBOL_REFERENCES_LOCAL (info, h))
5126 {
5127 rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
5128 rela.r_addend = bfd_get_signed_32 (output_bfd,
5129 (sgot->contents + offset));
5130 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
5131 }
5132 else
5133 {
5134 bfd_put_32 (output_bfd, (bfd_vma) 0,
5135 sgot->contents + offset);
5136 rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
5137 rela.r_addend = 0;
5138 }
5139
5140 loc = srela->contents;
5141 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5142 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5143 }
5144
5145 if (use_plt && h->got.offset != (bfd_vma) -1)
5146 {
5147 bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
5148 asection *sgot = htab->root.sgot;
5149 asection *splt = htab->root.splt;
5150 bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
5151 + h->plt.offset),
5152 sgot->contents + offset);
5153 }
5154
5155 if (h->needs_copy)
5156 {
5157 asection *s;
5158 Elf_Internal_Rela rela;
5159 bfd_byte *loc;
5160
5161 /* This symbol needs a copy reloc. Set it up. */
5162 BFD_ASSERT (h->dynindx != -1
5163 && (h->root.type == bfd_link_hash_defined
5164 || h->root.type == bfd_link_hash_defweak));
5165
5166 rela.r_offset = (h->root.u.def.value
5167 + h->root.u.def.section->output_section->vma
5168 + h->root.u.def.section->output_offset);
5169 rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
5170 rela.r_addend = 0;
5171 if (h->root.u.def.section == htab->root.sdynrelro)
5172 s = htab->root.sreldynrelro;
5173 else
5174 s = htab->root.srelbss;
5175 BFD_ASSERT (s != NULL);
5176 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
5177 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5178 }
5179
5180 /* Mark _DYNAMIC, _GLOBAL_OFFSET_TABLE_, and _gp_got as absolute. */
5181 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5182 || h == htab->root.hgot
5183 || h == htab->h_gp_got)
5184 sym->st_shndx = SHN_ABS;
5185
5186 return TRUE;
5187 }
5188
5189 /* Implement elf_backend_finish_dynamic_sections. */
5190 static bfd_boolean
5191 nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
5192 struct bfd_link_info *info)
5193 {
5194 asection *sgotplt;
5195 asection *sdyn;
5196 struct elf32_nios2_link_hash_table *htab;
5197
5198 htab = elf32_nios2_hash_table (info);
5199 sgotplt = htab->root.sgotplt;
5200 sdyn = NULL;
5201
5202 if (htab->root.dynamic_sections_created)
5203 {
5204 asection *splt;
5205 Elf32_External_Dyn *dyncon, *dynconend;
5206
5207 splt = htab->root.splt;
5208 sdyn = bfd_get_linker_section (htab->root.dynobj, ".dynamic");
5209 BFD_ASSERT (splt != NULL && sdyn != NULL && sgotplt != NULL);
5210
5211 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5212 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5213 for (; dyncon < dynconend; dyncon++)
5214 {
5215 Elf_Internal_Dyn dyn;
5216 asection *s;
5217
5218 bfd_elf32_swap_dyn_in (htab->root.dynobj, dyncon, &dyn);
5219
5220 switch (dyn.d_tag)
5221 {
5222 default:
5223 break;
5224
5225 case DT_PLTGOT:
5226 s = htab->root.sgotplt;
5227 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5228 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5229 break;
5230
5231 case DT_JMPREL:
5232 s = htab->root.srelplt;
5233 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
5234 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5235 break;
5236
5237 case DT_PLTRELSZ:
5238 s = htab->root.srelplt;
5239 dyn.d_un.d_val = s->size;
5240 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5241 break;
5242
5243 case DT_NIOS2_GP:
5244 s = htab->root.sgotplt;
5245 dyn.d_un.d_ptr
5246 = s->output_section->vma + s->output_offset + 0x7ff0;
5247 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5248 break;
5249 }
5250 }
5251
5252 /* Fill in the first entry in the procedure linkage table. */
5253 if (splt->size > 0)
5254 {
5255 bfd_vma got_address = (sgotplt->output_section->vma
5256 + sgotplt->output_offset);
5257 if (bfd_link_pic (info))
5258 {
5259 bfd_vma got_pcrel = got_address - (splt->output_section->vma
5260 + splt->output_offset);
5261 /* Both GOT and PLT must be aligned to a 16-byte boundary
5262 for the two loads to share the %hiadj part. The 4-byte
5263 offset for nextpc is accounted for in the %lo offsets
5264 on the loads. */
5265 BFD_ASSERT ((got_pcrel & 0xf) == 0);
5266 nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
5267 nios2_elf32_install_imm16 (splt, 4, hiadj (got_pcrel));
5268 nios2_elf32_install_imm16 (splt, 12, got_pcrel & 0xffff);
5269 nios2_elf32_install_imm16 (splt, 16, (got_pcrel + 4) & 0xffff);
5270 }
5271 else
5272 {
5273 /* Divide by 4 here, not 3 because we already corrected for the
5274 res_N branches. */
5275 bfd_vma res_size = (splt->size - 28) / 4;
5276 bfd_vma res_start = (splt->output_section->vma
5277 + splt->output_offset);
5278 bfd_vma res_offset;
5279
5280 for (res_offset = 0; res_offset < res_size; res_offset += 4)
5281 bfd_put_32 (output_bfd,
5282 6 | ((res_size - (res_offset + 4)) << 6),
5283 splt->contents + res_offset);
5284
5285 /* The GOT must be aligned to a 16-byte boundary for the
5286 two loads to share the same %hiadj part. */
5287 BFD_ASSERT ((got_address & 0xf) == 0);
5288
5289 nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
5290 nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
5291 nios2_elf32_install_imm16 (splt, res_size + 4,
5292 res_start & 0xffff);
5293 nios2_elf32_install_imm16 (splt, res_size + 12,
5294 hiadj (got_address));
5295 nios2_elf32_install_imm16 (splt, res_size + 16,
5296 (got_address + 4) & 0xffff);
5297 nios2_elf32_install_imm16 (splt, res_size + 20,
5298 (got_address + 8) & 0xffff);
5299 }
5300 }
5301 }
5302
5303 /* Fill in the first three entries in the global offset table. */
5304 if (sgotplt != NULL && sgotplt->size > 0)
5305 {
5306 if (sdyn == NULL)
5307 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
5308 else
5309 bfd_put_32 (output_bfd,
5310 sdyn->output_section->vma + sdyn->output_offset,
5311 sgotplt->contents);
5312 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
5313 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
5314
5315 if (sgotplt->output_section != bfd_abs_section_ptr)
5316 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
5317 }
5318
5319 return TRUE;
5320 }
5321
5322 /* Implement elf_backend_adjust_dynamic_symbol:
5323 Adjust a symbol defined by a dynamic object and referenced by a
5324 regular object. The current definition is in some section of the
5325 dynamic object, but we're not including those sections. We have to
5326 change the definition to something the rest of the link can
5327 understand. */
5328 static bfd_boolean
5329 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
5330 struct elf_link_hash_entry *h)
5331 {
5332 struct elf32_nios2_link_hash_table *htab;
5333 bfd *dynobj;
5334 asection *s, *srel;
5335 unsigned align2;
5336
5337 htab = elf32_nios2_hash_table (info);
5338 dynobj = htab->root.dynobj;
5339
5340 /* Make sure we know what is going on here. */
5341 BFD_ASSERT (dynobj != NULL
5342 && (h->needs_plt
5343 || h->is_weakalias
5344 || (h->def_dynamic
5345 && h->ref_regular
5346 && !h->def_regular)));
5347
5348 /* If this is a function, put it in the procedure linkage table. We
5349 will fill in the contents of the procedure linkage table later,
5350 when we know the address of the .got section. */
5351 if (h->type == STT_FUNC || h->needs_plt)
5352 {
5353 if (h->plt.refcount <= 0
5354 || SYMBOL_CALLS_LOCAL (info, h)
5355 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5356 && h->root.type == bfd_link_hash_undefweak))
5357 {
5358 /* This case can occur if we saw a PLT reloc in an input
5359 file, but the symbol was never referred to by a dynamic
5360 object, or if all references were garbage collected. In
5361 such a case, we don't actually need to build a procedure
5362 linkage table, and we can just do a PCREL reloc instead. */
5363 h->plt.offset = (bfd_vma) -1;
5364 h->needs_plt = 0;
5365 }
5366
5367 return TRUE;
5368 }
5369
5370 /* Reinitialize the plt offset now that it is not used as a reference
5371 count any more. */
5372 h->plt.offset = (bfd_vma) -1;
5373
5374 /* If this is a weak symbol, and there is a real definition, the
5375 processor independent code will have arranged for us to see the
5376 real definition first, and we can just use the same value. */
5377 if (h->is_weakalias)
5378 {
5379 struct elf_link_hash_entry *def = weakdef (h);
5380 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
5381 h->root.u.def.section = def->root.u.def.section;
5382 h->root.u.def.value = def->root.u.def.value;
5383 return TRUE;
5384 }
5385
5386 /* If there are no non-GOT references, we do not need a copy
5387 relocation. */
5388 if (!h->non_got_ref)
5389 return TRUE;
5390
5391 /* This is a reference to a symbol defined by a dynamic object which
5392 is not a function.
5393 If we are creating a shared library, we must presume that the
5394 only references to the symbol are via the global offset table.
5395 For such cases we need not do anything here; the relocations will
5396 be handled correctly by relocate_section. */
5397 if (bfd_link_pic (info))
5398 return TRUE;
5399
5400 if (h->size == 0)
5401 {
5402 _bfd_error_handler (_("dynamic variable `%s' is zero size"),
5403 h->root.root.string);
5404 return TRUE;
5405 }
5406
5407 /* We must allocate the symbol in our .dynbss section, which will
5408 become part of the .bss section of the executable. There will be
5409 an entry for this symbol in the .dynsym section. The dynamic
5410 object will contain position independent code, so all references
5411 from the dynamic object to this symbol will go through the global
5412 offset table. The dynamic linker will use the .dynsym entry to
5413 determine the address it must put in the global offset table, so
5414 both the dynamic object and the regular object will refer to the
5415 same memory location for the variable. */
5416 /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
5417 copy the initial value out of the dynamic object and into the
5418 runtime process image. We need to remember the offset into the
5419 .rela.bss section we are going to use. */
5420 if ((h->root.u.def.section->flags & SEC_READONLY) != 0)
5421 {
5422 s = htab->root.sdynrelro;
5423 srel = htab->root.sreldynrelro;
5424 }
5425 else
5426 {
5427 s = htab->root.sdynbss;
5428 srel = htab->root.srelbss;
5429 }
5430 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5431 {
5432 srel->size += sizeof (Elf32_External_Rela);
5433 h->needs_copy = 1;
5434 }
5435
5436 align2 = bfd_log2 (h->size);
5437 if (align2 > h->root.u.def.section->alignment_power)
5438 align2 = h->root.u.def.section->alignment_power;
5439
5440 /* Align dynbss. */
5441 s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
5442 if (align2 > bfd_section_alignment (s)
5443 && !bfd_set_section_alignment (s, align2))
5444 return FALSE;
5445
5446 /* Define the symbol as being at this point in the section. */
5447 h->root.u.def.section = s;
5448 h->root.u.def.value = s->size;
5449
5450 /* Increment the section size to make room for the symbol. */
5451 s->size += h->size;
5452
5453 return TRUE;
5454 }
5455
5456 /* Worker function for nios2_elf32_size_dynamic_sections. */
5457 static bfd_boolean
5458 adjust_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5459 {
5460 struct bfd_link_info *info;
5461 struct elf32_nios2_link_hash_table *htab;
5462
5463 if (h->root.type == bfd_link_hash_indirect)
5464 return TRUE;
5465
5466 if (h->root.type == bfd_link_hash_warning)
5467 /* When warning symbols are created, they **replace** the "real"
5468 entry in the hash table, thus we never get to see the real
5469 symbol in a hash traversal. So look at it now. */
5470 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5471
5472 info = (struct bfd_link_info *) inf;
5473 htab = elf32_nios2_hash_table (info);
5474
5475 if (h->plt.offset != (bfd_vma)-1)
5476 h->plt.offset += htab->res_n_size;
5477 if (htab->root.splt == h->root.u.def.section)
5478 h->root.u.def.value += htab->res_n_size;
5479
5480 return TRUE;
5481 }
5482
5483 /* Another worker function for nios2_elf32_size_dynamic_sections.
5484 Allocate space in .plt, .got and associated reloc sections for
5485 dynamic relocs. */
5486 static bfd_boolean
5487 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
5488 {
5489 struct bfd_link_info *info;
5490 struct elf32_nios2_link_hash_table *htab;
5491 struct elf32_nios2_link_hash_entry *eh;
5492 struct elf_dyn_relocs *p;
5493 int use_plt;
5494
5495 if (h->root.type == bfd_link_hash_indirect)
5496 return TRUE;
5497
5498 if (h->root.type == bfd_link_hash_warning)
5499 /* When warning symbols are created, they **replace** the "real"
5500 entry in the hash table, thus we never get to see the real
5501 symbol in a hash traversal. So look at it now. */
5502 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5503
5504 info = (struct bfd_link_info *) inf;
5505 htab = elf32_nios2_hash_table (info);
5506
5507 if (htab->root.dynamic_sections_created
5508 && h->plt.refcount > 0)
5509 {
5510 /* Make sure this symbol is output as a dynamic symbol.
5511 Undefined weak syms won't yet be marked as dynamic. */
5512 if (h->dynindx == -1
5513 && !h->forced_local
5514 && !bfd_elf_link_record_dynamic_symbol (info, h))
5515 return FALSE;
5516
5517 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
5518 {
5519 asection *s = htab->root.splt;
5520
5521 /* Allocate room for the header. */
5522 if (s->size == 0)
5523 {
5524 if (bfd_link_pic (info))
5525 s->size = 24;
5526 else
5527 s->size = 28;
5528 }
5529
5530 h->plt.offset = s->size;
5531
5532 /* If this symbol is not defined in a regular file, and we are
5533 not generating a shared library, then set the symbol to this
5534 location in the .plt. This is required to make function
5535 pointers compare as equal between the normal executable and
5536 the shared library. */
5537 if (! bfd_link_pic (info)
5538 && !h->def_regular)
5539 {
5540 h->root.u.def.section = s;
5541 h->root.u.def.value = h->plt.offset;
5542 }
5543
5544 /* Make room for this entry. */
5545 s->size += 12;
5546
5547 /* We also need to make an entry in the .rela.plt section. */
5548 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
5549
5550 /* And the .got.plt section. */
5551 htab->root.sgotplt->size += 4;
5552 }
5553 else
5554 {
5555 h->plt.offset = (bfd_vma) -1;
5556 h->needs_plt = 0;
5557 }
5558 }
5559 else
5560 {
5561 h->plt.offset = (bfd_vma) -1;
5562 h->needs_plt = 0;
5563 }
5564
5565 eh = (struct elf32_nios2_link_hash_entry *) h;
5566 use_plt = (eh->got_types_used == CALL_USED
5567 && h->plt.offset != (bfd_vma) -1);
5568
5569 if (h->got.refcount > 0)
5570 {
5571 asection *s;
5572 bfd_boolean dyn;
5573 int tls_type = eh->tls_type;
5574 int indx;
5575
5576 /* Make sure this symbol is output as a dynamic symbol.
5577 Undefined weak syms won't yet be marked as dynamic. */
5578 if (h->dynindx == -1
5579 && !h->forced_local
5580 && !bfd_elf_link_record_dynamic_symbol (info, h))
5581 return FALSE;
5582
5583 s = htab->root.sgot;
5584 h->got.offset = s->size;
5585
5586 if (tls_type == GOT_UNKNOWN)
5587 abort ();
5588
5589 if (tls_type == GOT_NORMAL)
5590 /* Non-TLS symbols need one GOT slot. */
5591 s->size += 4;
5592 else
5593 {
5594 if (tls_type & GOT_TLS_GD)
5595 /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots. */
5596 s->size += 8;
5597 if (tls_type & GOT_TLS_IE)
5598 /* R_NIOS2_TLS_IE16 needs one GOT slot. */
5599 s->size += 4;
5600 }
5601
5602 dyn = htab->root.dynamic_sections_created;
5603
5604 indx = 0;
5605 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h)
5606 && (!bfd_link_pic (info)
5607 || !SYMBOL_REFERENCES_LOCAL (info, h)))
5608 indx = h->dynindx;
5609
5610 if (tls_type != GOT_NORMAL
5611 && (bfd_link_pic (info) || indx != 0)
5612 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5613 || h->root.type != bfd_link_hash_undefweak))
5614 {
5615 if (tls_type & GOT_TLS_IE)
5616 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5617
5618 if (tls_type & GOT_TLS_GD)
5619 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5620
5621 if ((tls_type & GOT_TLS_GD) && indx != 0)
5622 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5623 }
5624 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
5625 || h->root.type != bfd_link_hash_undefweak)
5626 && !use_plt
5627 && (bfd_link_pic (info)
5628 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
5629 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5630 }
5631 else
5632 h->got.offset = (bfd_vma) -1;
5633
5634 if (eh->dyn_relocs == NULL)
5635 return TRUE;
5636
5637 /* In the shared -Bsymbolic case, discard space allocated for
5638 dynamic pc-relative relocs against symbols which turn out to be
5639 defined in regular objects. For the normal shared case, discard
5640 space for pc-relative relocs that have become local due to symbol
5641 visibility changes. */
5642
5643 if (bfd_link_pic (info))
5644 {
5645 if (h->def_regular
5646 && (h->forced_local || SYMBOLIC_BIND (info, h)))
5647 {
5648 struct elf_dyn_relocs **pp;
5649
5650 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
5651 {
5652 p->count -= p->pc_count;
5653 p->pc_count = 0;
5654 if (p->count == 0)
5655 *pp = p->next;
5656 else
5657 pp = &p->next;
5658 }
5659 }
5660
5661 /* Also discard relocs on undefined weak syms with non-default
5662 visibility. */
5663 if (eh->dyn_relocs != NULL
5664 && h->root.type == bfd_link_hash_undefweak)
5665 {
5666 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
5667 || UNDEFWEAK_NO_DYNAMIC_RELOC (info, h))
5668 eh->dyn_relocs = NULL;
5669
5670 /* Make sure undefined weak symbols are output as a dynamic
5671 symbol in PIEs. */
5672 else if (h->dynindx == -1
5673 && !h->forced_local
5674 && !bfd_elf_link_record_dynamic_symbol (info, h))
5675 return FALSE;
5676 }
5677 }
5678 else
5679 {
5680 /* For the non-shared case, discard space for relocs against
5681 symbols which turn out to need copy relocs or are not
5682 dynamic. */
5683
5684 if (!h->non_got_ref
5685 && ((h->def_dynamic && !h->def_regular)
5686 || (htab->root.dynamic_sections_created
5687 && (h->root.type == bfd_link_hash_undefweak
5688 || h->root.type == bfd_link_hash_undefined))))
5689 {
5690 /* Make sure this symbol is output as a dynamic symbol.
5691 Undefined weak syms won't yet be marked as dynamic. */
5692 if (h->dynindx == -1
5693 && !h->forced_local
5694 && !bfd_elf_link_record_dynamic_symbol (info, h))
5695 return FALSE;
5696
5697 /* If that succeeded, we know we'll be keeping all the
5698 relocs. */
5699 if (h->dynindx != -1)
5700 goto keep;
5701 }
5702
5703 eh->dyn_relocs = NULL;
5704
5705 keep: ;
5706 }
5707
5708 /* Finally, allocate space. */
5709 for (p = eh->dyn_relocs; p != NULL; p = p->next)
5710 {
5711 asection *sreloc = elf_section_data (p->sec)->sreloc;
5712 sreloc->size += p->count * sizeof (Elf32_External_Rela);
5713 }
5714
5715 return TRUE;
5716 }
5717
5718 /* Implement elf_backend_size_dynamic_sections:
5719 Set the sizes of the dynamic sections. */
5720 static bfd_boolean
5721 nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5722 struct bfd_link_info *info)
5723 {
5724 bfd *dynobj;
5725 asection *s;
5726 bfd_boolean relocs;
5727 bfd *ibfd;
5728 struct elf32_nios2_link_hash_table *htab;
5729
5730 htab = elf32_nios2_hash_table (info);
5731 dynobj = htab->root.dynobj;
5732 BFD_ASSERT (dynobj != NULL);
5733
5734 htab->res_n_size = 0;
5735 if (htab->root.dynamic_sections_created)
5736 {
5737 /* Set the contents of the .interp section to the interpreter. */
5738 if (bfd_link_executable (info) && !info->nointerp)
5739 {
5740 s = bfd_get_linker_section (dynobj, ".interp");
5741 BFD_ASSERT (s != NULL);
5742 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5743 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5744 }
5745 }
5746 else
5747 {
5748 /* We may have created entries in the .rela.got section.
5749 However, if we are not creating the dynamic sections, we will
5750 not actually use these entries. Reset the size of .rela.got,
5751 which will cause it to get stripped from the output file
5752 below. */
5753 s = htab->root.srelgot;
5754 if (s != NULL)
5755 s->size = 0;
5756 }
5757
5758 /* Set up .got offsets for local syms, and space for local dynamic
5759 relocs. */
5760 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
5761 {
5762 bfd_signed_vma *local_got;
5763 bfd_signed_vma *end_local_got;
5764 char *local_tls_type;
5765 bfd_size_type locsymcount;
5766 Elf_Internal_Shdr *symtab_hdr;
5767 asection *srel;
5768
5769 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
5770 continue;
5771
5772 for (s = ibfd->sections; s != NULL; s = s->next)
5773 {
5774 struct elf_dyn_relocs *p;
5775
5776 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
5777 {
5778 if (!bfd_is_abs_section (p->sec)
5779 && bfd_is_abs_section (p->sec->output_section))
5780 {
5781 /* Input section has been discarded, either because
5782 it is a copy of a linkonce section or due to
5783 linker script /DISCARD/, so we'll be discarding
5784 the relocs too. */
5785 }
5786 else if (p->count != 0)
5787 {
5788 srel = elf_section_data (p->sec)->sreloc;
5789 srel->size += p->count * sizeof (Elf32_External_Rela);
5790 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
5791 info->flags |= DF_TEXTREL;
5792 }
5793 }
5794 }
5795
5796 local_got = elf_local_got_refcounts (ibfd);
5797 if (!local_got)
5798 continue;
5799
5800 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
5801 locsymcount = symtab_hdr->sh_info;
5802 end_local_got = local_got + locsymcount;
5803 local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
5804 s = htab->root.sgot;
5805 srel = htab->root.srelgot;
5806 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
5807 {
5808 if (*local_got > 0)
5809 {
5810 *local_got = s->size;
5811 if (*local_tls_type & GOT_TLS_GD)
5812 /* TLS_GD relocs need an 8-byte structure in the GOT. */
5813 s->size += 8;
5814 if (*local_tls_type & GOT_TLS_IE)
5815 s->size += 4;
5816 if (*local_tls_type == GOT_NORMAL)
5817 s->size += 4;
5818
5819 if (bfd_link_pic (info) || *local_tls_type == GOT_TLS_GD)
5820 srel->size += sizeof (Elf32_External_Rela);
5821 }
5822 else
5823 *local_got = (bfd_vma) -1;
5824 }
5825 }
5826
5827 if (htab->tls_ldm_got.refcount > 0)
5828 {
5829 /* Allocate two GOT entries and one dynamic relocation (if necessary)
5830 for R_NIOS2_TLS_LDM16 relocations. */
5831 htab->tls_ldm_got.offset = htab->root.sgot->size;
5832 htab->root.sgot->size += 8;
5833 if (bfd_link_pic (info))
5834 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
5835 }
5836 else
5837 htab->tls_ldm_got.offset = -1;
5838
5839 /* Allocate global sym .plt and .got entries, and space for global
5840 sym dynamic relocs. */
5841 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
5842
5843 if (htab->root.dynamic_sections_created)
5844 {
5845 /* If the .got section is more than 0x8000 bytes, we add
5846 0x8000 to the value of _gp_got, so that 16-bit relocations
5847 have a greater chance of working. */
5848 if (htab->root.sgot->size >= 0x8000
5849 && htab->h_gp_got->root.u.def.value == 0)
5850 htab->h_gp_got->root.u.def.value = 0x8000;
5851 }
5852
5853 /* The check_relocs and adjust_dynamic_symbol entry points have
5854 determined the sizes of the various dynamic sections. Allocate
5855 memory for them. */
5856 relocs = FALSE;
5857 for (s = dynobj->sections; s != NULL; s = s->next)
5858 {
5859 const char *name;
5860
5861 if ((s->flags & SEC_LINKER_CREATED) == 0)
5862 continue;
5863
5864 /* It's OK to base decisions on the section name, because none
5865 of the dynobj section names depend upon the input files. */
5866 name = bfd_section_name (s);
5867
5868 if (CONST_STRNEQ (name, ".rela"))
5869 {
5870 if (s->size != 0)
5871 {
5872 if (s != htab->root.srelplt)
5873 relocs = TRUE;
5874
5875 /* We use the reloc_count field as a counter if we need
5876 to copy relocs into the output file. */
5877 s->reloc_count = 0;
5878 }
5879 }
5880 else if (s == htab->root.splt)
5881 {
5882 /* Correct for the number of res_N branches. */
5883 if (s->size != 0 && !bfd_link_pic (info))
5884 {
5885 htab->res_n_size = (s->size - 28) / 3;
5886 s->size += htab->res_n_size;
5887 }
5888 }
5889 else if (s != htab->sbss
5890 && s != htab->root.sgot
5891 && s != htab->root.sgotplt
5892 && s != htab->root.sdynbss
5893 && s != htab->root.sdynrelro)
5894 /* It's not one of our sections, so don't allocate space. */
5895 continue;
5896
5897 if (s->size == 0)
5898 {
5899 s->flags |= SEC_EXCLUDE;
5900 continue;
5901 }
5902
5903 if ((s->flags & SEC_HAS_CONTENTS) == 0)
5904 continue;
5905
5906 /* Allocate memory for the section contents. */
5907 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5908 if (s->contents == NULL)
5909 return FALSE;
5910 }
5911
5912 /* Adjust dynamic symbols that point to the plt to account for the
5913 now-known number of resN slots. */
5914 if (htab->res_n_size)
5915 elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
5916
5917 if (htab->root.dynamic_sections_created)
5918 {
5919 /* Add some entries to the .dynamic section. We fill in the
5920 values later, in elf_nios2_finish_dynamic_sections, but we
5921 must add the entries now so that we get the correct size for
5922 the .dynamic section. The DT_DEBUG entry is filled in by the
5923 dynamic linker and used by the debugger. */
5924 #define add_dynamic_entry(TAG, VAL) \
5925 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5926
5927 if (!bfd_link_pic (info) && !add_dynamic_entry (DT_DEBUG, 0))
5928 return FALSE;
5929
5930 if (htab->root.sgotplt->size != 0
5931 && !add_dynamic_entry (DT_PLTGOT, 0))
5932 return FALSE;
5933
5934 if (htab->root.splt->size != 0
5935 && (!add_dynamic_entry (DT_PLTRELSZ, 0)
5936 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
5937 || !add_dynamic_entry (DT_JMPREL, 0)))
5938 return FALSE;
5939
5940 if (relocs
5941 && (!add_dynamic_entry (DT_RELA, 0)
5942 || !add_dynamic_entry (DT_RELASZ, 0)
5943 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))))
5944 return FALSE;
5945
5946 if (!bfd_link_pic (info) && !add_dynamic_entry (DT_NIOS2_GP, 0))
5947 return FALSE;
5948
5949 if ((info->flags & DF_TEXTREL) != 0
5950 && !add_dynamic_entry (DT_TEXTREL, 0))
5951 return FALSE;
5952 }
5953 #undef add_dynamic_entry
5954
5955 return TRUE;
5956 }
5957
5958 /* Free the derived linker hash table. */
5959 static void
5960 nios2_elf32_link_hash_table_free (bfd *obfd)
5961 {
5962 struct elf32_nios2_link_hash_table *htab
5963 = (struct elf32_nios2_link_hash_table *) obfd->link.hash;
5964
5965 bfd_hash_table_free (&htab->bstab);
5966 _bfd_elf_link_hash_table_free (obfd);
5967 }
5968
5969 /* Implement bfd_elf32_bfd_link_hash_table_create. */
5970 static struct bfd_link_hash_table *
5971 nios2_elf32_link_hash_table_create (bfd *abfd)
5972 {
5973 struct elf32_nios2_link_hash_table *ret;
5974 size_t amt = sizeof (struct elf32_nios2_link_hash_table);
5975
5976 ret = bfd_zmalloc (amt);
5977 if (ret == NULL)
5978 return NULL;
5979
5980 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5981 link_hash_newfunc,
5982 sizeof (struct
5983 elf32_nios2_link_hash_entry),
5984 NIOS2_ELF_DATA))
5985 {
5986 free (ret);
5987 return NULL;
5988 }
5989
5990 /* Init the stub hash table too. */
5991 if (!bfd_hash_table_init (&ret->bstab, stub_hash_newfunc,
5992 sizeof (struct elf32_nios2_stub_hash_entry)))
5993 {
5994 _bfd_elf_link_hash_table_free (abfd);
5995 return NULL;
5996 }
5997 ret->root.root.hash_table_free = nios2_elf32_link_hash_table_free;
5998
5999 return &ret->root.root;
6000 }
6001
6002 /* Implement elf_backend_reloc_type_class. */
6003 static enum elf_reloc_type_class
6004 nios2_elf32_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
6005 const asection *rel_sec ATTRIBUTE_UNUSED,
6006 const Elf_Internal_Rela *rela)
6007 {
6008 switch ((int) ELF32_R_TYPE (rela->r_info))
6009 {
6010 case R_NIOS2_RELATIVE:
6011 return reloc_class_relative;
6012 case R_NIOS2_JUMP_SLOT:
6013 return reloc_class_plt;
6014 case R_NIOS2_COPY:
6015 return reloc_class_copy;
6016 default:
6017 return reloc_class_normal;
6018 }
6019 }
6020
6021 /* Return 1 if target is one of ours. */
6022 static bfd_boolean
6023 is_nios2_elf_target (const struct bfd_target *targ)
6024 {
6025 return (targ == &nios2_elf32_le_vec
6026 || targ == &nios2_elf32_be_vec);
6027 }
6028
6029 /* Implement elf_backend_add_symbol_hook.
6030 This hook is called by the linker when adding symbols from an object
6031 file. We use it to put .comm items in .sbss, and not .bss. */
6032 static bfd_boolean
6033 nios2_elf_add_symbol_hook (bfd *abfd,
6034 struct bfd_link_info *info,
6035 Elf_Internal_Sym *sym,
6036 const char **namep ATTRIBUTE_UNUSED,
6037 flagword *flagsp ATTRIBUTE_UNUSED,
6038 asection **secp,
6039 bfd_vma *valp)
6040 {
6041 if (sym->st_shndx == SHN_COMMON
6042 && !bfd_link_relocatable (info)
6043 && sym->st_size <= elf_gp_size (abfd)
6044 && is_nios2_elf_target (info->output_bfd->xvec))
6045 {
6046 /* Common symbols less than or equal to -G nn bytes are automatically
6047 put into .sbss. */
6048 struct elf32_nios2_link_hash_table *htab;
6049
6050 htab = elf32_nios2_hash_table (info);
6051 if (htab->sbss == NULL)
6052 {
6053 flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
6054
6055 if (htab->root.dynobj == NULL)
6056 htab->root.dynobj = abfd;
6057
6058 htab->sbss = bfd_make_section_anyway_with_flags (htab->root.dynobj,
6059 ".sbss", flags);
6060 if (htab->sbss == NULL)
6061 return FALSE;
6062 }
6063
6064 *secp = htab->sbss;
6065 *valp = sym->st_size;
6066 }
6067
6068 return TRUE;
6069 }
6070
6071 /* Implement elf_backend_can_make_relative_eh_frame:
6072 Decide whether to attempt to turn absptr or lsda encodings in
6073 shared libraries into pcrel within the given input section. */
6074 static bfd_boolean
6075 nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
6076 struct bfd_link_info *info
6077 ATTRIBUTE_UNUSED,
6078 asection *eh_frame_section
6079 ATTRIBUTE_UNUSED)
6080 {
6081 /* We can't use PC-relative encodings in the .eh_frame section. */
6082 return FALSE;
6083 }
6084
6085 /* Implement elf_backend_special_sections. */
6086 const struct bfd_elf_special_section elf32_nios2_special_sections[] =
6087 {
6088 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS,
6089 SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6090 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
6091 SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
6092 { NULL, 0, 0, 0, 0 }
6093 };
6094
6095 #define ELF_ARCH bfd_arch_nios2
6096 #define ELF_TARGET_ID NIOS2_ELF_DATA
6097 #define ELF_MACHINE_CODE EM_ALTERA_NIOS2
6098
6099 /* The Nios II MMU uses a 4K page size. */
6100
6101 #define ELF_MAXPAGESIZE 0x1000
6102
6103 #define bfd_elf32_bfd_link_hash_table_create \
6104 nios2_elf32_link_hash_table_create
6105
6106 #define bfd_elf32_bfd_merge_private_bfd_data \
6107 nios2_elf32_merge_private_bfd_data
6108
6109 /* Relocation table lookup macros. */
6110
6111 #define bfd_elf32_bfd_reloc_type_lookup nios2_elf32_bfd_reloc_type_lookup
6112 #define bfd_elf32_bfd_reloc_name_lookup nios2_elf32_bfd_reloc_name_lookup
6113
6114 /* JUMP_TABLE_LINK macros. */
6115
6116 /* elf_info_to_howto (using RELA relocations). */
6117
6118 #define elf_info_to_howto nios2_elf32_info_to_howto
6119
6120 /* elf backend functions. */
6121
6122 #define elf_backend_can_gc_sections 1
6123 #define elf_backend_can_refcount 1
6124 #define elf_backend_plt_readonly 1
6125 #define elf_backend_want_got_plt 1
6126 #define elf_backend_want_dynrelro 1
6127 #define elf_backend_rela_normal 1
6128 #define elf_backend_dtrel_excludes_plt 1
6129
6130 #define elf_backend_relocate_section nios2_elf32_relocate_section
6131 #define elf_backend_section_flags nios2_elf32_section_flags
6132 #define elf_backend_fake_sections nios2_elf32_fake_sections
6133 #define elf_backend_check_relocs nios2_elf32_check_relocs
6134
6135 #define elf_backend_gc_mark_hook nios2_elf32_gc_mark_hook
6136 #define elf_backend_create_dynamic_sections \
6137 nios2_elf32_create_dynamic_sections
6138 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
6139 #define elf_backend_finish_dynamic_sections \
6140 nios2_elf32_finish_dynamic_sections
6141 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
6142 #define elf_backend_reloc_type_class nios2_elf32_reloc_type_class
6143 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
6144 #define elf_backend_add_symbol_hook nios2_elf_add_symbol_hook
6145 #define elf_backend_copy_indirect_symbol nios2_elf32_copy_indirect_symbol
6146 #define elf_backend_object_p nios2_elf32_object_p
6147
6148 #define elf_backend_grok_prstatus nios2_grok_prstatus
6149 #define elf_backend_grok_psinfo nios2_grok_psinfo
6150
6151 #undef elf_backend_can_make_relative_eh_frame
6152 #define elf_backend_can_make_relative_eh_frame \
6153 nios2_elf32_can_make_relative_eh_frame
6154
6155 #define elf_backend_special_sections elf32_nios2_special_sections
6156
6157 #define TARGET_LITTLE_SYM nios2_elf32_le_vec
6158 #define TARGET_LITTLE_NAME "elf32-littlenios2"
6159 #define TARGET_BIG_SYM nios2_elf32_be_vec
6160 #define TARGET_BIG_NAME "elf32-bignios2"
6161
6162 #define elf_backend_got_header_size 12
6163 #define elf_backend_default_execstack 0
6164
6165 #include "elf32-target.h"
A mirror of the official binutils-gdb repository