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