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