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