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