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