?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2013-03-12 Sebastian Huber <sebastian.huber@embedded-brains.de>
[binutils-gdb.git] / bfd / elf32-nios2.c
blob85ef7c9039d0a778b4aa81335c863f0d5487dd0a
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"
33
34 /* Use RELA relocations. */
35 #ifndef USE_RELA
36 #define USE_RELA
37 #endif
38
39 #ifdef USE_REL
40 #undef USE_REL
41 #endif
42
43 /* Forward declarations. */
44 static bfd_reloc_status_type nios2_elf32_ignore_reloc
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46 static bfd_reloc_status_type nios2_elf32_hi16_relocate
47 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
48 static bfd_reloc_status_type nios2_elf32_lo16_relocate
49 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
50 static bfd_reloc_status_type nios2_elf32_hiadj16_relocate
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52 static bfd_reloc_status_type nios2_elf32_pcrel_lo16_relocate
53 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
54 static bfd_reloc_status_type nios2_elf32_pcrel_hiadj16_relocate
55 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
56 static bfd_reloc_status_type nios2_elf32_pcrel16_relocate
57 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
58 static bfd_reloc_status_type nios2_elf32_call26_relocate
59 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
60 static bfd_reloc_status_type nios2_elf32_gprel_relocate
61 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
62 static bfd_reloc_status_type nios2_elf32_ujmp_relocate
63 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
64 static bfd_reloc_status_type nios2_elf32_cjmp_relocate
65 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
66 static bfd_reloc_status_type nios2_elf32_callr_relocate
67 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
68
69 /* Target vector. */
70 extern const bfd_target bfd_elf32_littlenios2_vec;
71 extern const bfd_target bfd_elf32_bignios2_vec;
72
73 /* Offset of tp and dtp pointers from start of TLS block. */
74 #define TP_OFFSET 0x7000
75 #define DTP_OFFSET 0x8000
76
77 /* The relocation table used for SHT_REL sections. */
78 static reloc_howto_type elf_nios2_howto_table_rel[] = {
79 /* No relocation. */
80 HOWTO (R_NIOS2_NONE, /* type */
81 0, /* rightshift */
82 0, /* size (0 = byte, 1 = short, 2 = long) */
83 0, /* bitsize */
84 FALSE, /* pc_relative */
85 0, /* bitpos */
86 complain_overflow_dont, /* complain_on_overflow */
87 bfd_elf_generic_reloc, /* special_function */
88 "R_NIOS2_NONE", /* name */
89 FALSE, /* partial_inplace */
90 0, /* src_mask */
91 0, /* dst_mask */
92 FALSE), /* pcrel_offset */
93
94 /* 16-bit signed immediate relocation. */
95 HOWTO (R_NIOS2_S16, /* type */
96 0, /* rightshift */
97 2, /* size (0 = byte, 1 = short, 2 = long) */
98 16, /* bitsize */
99 FALSE, /* pc_relative */
100 6, /* bitpos */
101 complain_overflow_signed, /* complain on overflow */
102 bfd_elf_generic_reloc, /* special function */
103 "R_NIOS2_S16", /* name */
104 FALSE, /* partial_inplace */
105 0x003fffc0, /* src_mask */
106 0x003fffc0, /* dest_mask */
107 FALSE), /* pcrel_offset */
108
109 /* 16-bit unsigned immediate relocation. */
110 HOWTO (R_NIOS2_U16, /* type */
111 0, /* rightshift */
112 2, /* size (0 = byte, 1 = short, 2 = long) */
113 16, /* bitsize */
114 FALSE, /* pc_relative */
115 6, /* bitpos */
116 complain_overflow_unsigned, /* complain on overflow */
117 bfd_elf_generic_reloc, /* special function */
118 "R_NIOS2_U16", /* name */
119 FALSE, /* partial_inplace */
120 0x003fffc0, /* src_mask */
121 0x003fffc0, /* dest_mask */
122 FALSE), /* pcrel_offset */
123
124 HOWTO (R_NIOS2_PCREL16, /* type */
125 0, /* rightshift */
126 2, /* size (0 = byte, 1 = short, 2 = long) */
127 16, /* bitsize */
128 TRUE, /* pc_relative */
129 6, /* bitpos */
130 complain_overflow_signed, /* complain on overflow */
131 nios2_elf32_pcrel16_relocate, /* special function */
132 "R_NIOS2_PCREL16", /* name */
133 FALSE, /* partial_inplace */
134 0x003fffc0, /* src_mask */
135 0x003fffc0, /* dest_mask */
136 TRUE), /* pcrel_offset */
137
138 HOWTO (R_NIOS2_CALL26, /* type */
139 2, /* rightshift */
140 2, /* size (0 = byte, 1 = short, 2 = long) */
141 26, /* bitsize */
142 FALSE, /* pc_relative */
143 6, /* bitpos */
144 complain_overflow_dont, /* complain on overflow */
145 nios2_elf32_call26_relocate, /* special function */
146 "R_NIOS2_CALL26", /* name */
147 FALSE, /* partial_inplace */
148 0xffffffc0, /* src_mask */
149 0xffffffc0, /* dst_mask */
150 FALSE), /* pcrel_offset */
151
152 HOWTO (R_NIOS2_IMM5,
153 0,
154 2,
155 5,
156 FALSE,
157 6,
158 complain_overflow_bitfield,
159 bfd_elf_generic_reloc,
160 "R_NIOS2_IMM5",
161 FALSE,
162 0x000007c0,
163 0x000007c0,
164 FALSE),
165
166 HOWTO (R_NIOS2_CACHE_OPX,
167 0,
168 2,
169 5,
170 FALSE,
171 22,
172 complain_overflow_bitfield,
173 bfd_elf_generic_reloc,
174 "R_NIOS2_CACHE_OPX",
175 FALSE,
176 0x07c00000,
177 0x07c00000,
178 FALSE),
179
180 HOWTO (R_NIOS2_IMM6,
181 0,
182 2,
183 6,
184 FALSE,
185 6,
186 complain_overflow_bitfield,
187 bfd_elf_generic_reloc,
188 "R_NIOS2_IMM6",
189 FALSE,
190 0x00000fc0,
191 0x00000fc0,
192 FALSE),
193
194 HOWTO (R_NIOS2_IMM8,
195 0,
196 2,
197 8,
198 FALSE,
199 6,
200 complain_overflow_bitfield,
201 bfd_elf_generic_reloc,
202 "R_NIOS2_IMM8",
203 FALSE,
204 0x00003fc0,
205 0x00003fc0,
206 FALSE),
207
208 HOWTO (R_NIOS2_HI16,
209 0,
210 2,
211 32,
212 FALSE,
213 6,
214 complain_overflow_dont,
215 nios2_elf32_hi16_relocate,
216 "R_NIOS2_HI16",
217 FALSE,
218 0x003fffc0,
219 0x003fffc0,
220 FALSE),
221
222 HOWTO (R_NIOS2_LO16,
223 0,
224 2,
225 32,
226 FALSE,
227 6,
228 complain_overflow_dont,
229 nios2_elf32_lo16_relocate,
230 "R_NIOS2_LO16",
231 FALSE,
232 0x003fffc0,
233 0x003fffc0,
234 FALSE),
235
236 HOWTO (R_NIOS2_HIADJ16,
237 0,
238 2,
239 32,
240 FALSE,
241 6,
242 complain_overflow_dont,
243 nios2_elf32_hiadj16_relocate,
244 "R_NIOS2_HIADJ16",
245 FALSE,
246 0x003fffc0,
247 0x003fffc0,
248 FALSE),
249
250 HOWTO (R_NIOS2_BFD_RELOC_32,
251 0,
252 2, /* long */
253 32,
254 FALSE,
255 0,
256 complain_overflow_dont,
257 bfd_elf_generic_reloc,
258 "R_NIOS2_BFD_RELOC32",
259 FALSE,
260 0xffffffff,
261 0xffffffff,
262 FALSE),
263
264 HOWTO (R_NIOS2_BFD_RELOC_16,
265 0,
266 1, /* short */
267 16,
268 FALSE,
269 0,
270 complain_overflow_bitfield,
271 bfd_elf_generic_reloc,
272 "R_NIOS2_BFD_RELOC16",
273 FALSE,
274 0x0000ffff,
275 0x0000ffff,
276 FALSE),
277
278 HOWTO (R_NIOS2_BFD_RELOC_8,
279 0,
280 0, /* byte */
281 8,
282 FALSE,
283 0,
284 complain_overflow_bitfield,
285 bfd_elf_generic_reloc,
286 "R_NIOS2_BFD_RELOC8",
287 FALSE,
288 0x000000ff,
289 0x000000ff,
290 FALSE),
291
292 HOWTO (R_NIOS2_GPREL,
293 0,
294 2,
295 32,
296 FALSE,
297 6,
298 complain_overflow_dont,
299 nios2_elf32_gprel_relocate,
300 "R_NIOS2_GPREL",
301 FALSE,
302 0x003fffc0,
303 0x003fffc0,
304 FALSE),
305
306 HOWTO (R_NIOS2_GNU_VTINHERIT,
307 0,
308 2, /* short */
309 0,
310 FALSE,
311 0,
312 complain_overflow_dont,
313 NULL,
314 "R_NIOS2_GNU_VTINHERIT",
315 FALSE,
316 0,
317 0,
318 FALSE),
319
320 HOWTO (R_NIOS2_GNU_VTENTRY,
321 0,
322 2, /* byte */
323 0,
324 FALSE,
325 0,
326 complain_overflow_dont,
327 _bfd_elf_rel_vtable_reloc_fn,
328 "R_NIOS2_GNU_VTENTRY",
329 FALSE,
330 0,
331 0,
332 FALSE),
333
334 HOWTO (R_NIOS2_UJMP,
335 0,
336 2,
337 32,
338 FALSE,
339 6,
340 complain_overflow_dont,
341 nios2_elf32_ujmp_relocate,
342 "R_NIOS2_UJMP",
343 FALSE,
344 0x003fffc0,
345 0x003fffc0,
346 FALSE),
347
348 HOWTO (R_NIOS2_CJMP,
349 0,
350 2,
351 32,
352 FALSE,
353 6,
354 complain_overflow_dont,
355 nios2_elf32_cjmp_relocate,
356 "R_NIOS2_CJMP",
357 FALSE,
358 0x003fffc0,
359 0x003fffc0,
360 FALSE),
361
362 HOWTO (R_NIOS2_CALLR,
363 0,
364 2,
365 32,
366 FALSE,
367 6,
368 complain_overflow_dont,
369 nios2_elf32_callr_relocate,
370 "R_NIOS2_CALLR",
371 FALSE,
372 0x003fffc0,
373 0x003fffc0,
374 FALSE),
375
376 HOWTO (R_NIOS2_ALIGN,
377 0,
378 2,
379 0,
380 FALSE,
381 0,
382 complain_overflow_dont,
383 nios2_elf32_ignore_reloc,
384 "R_NIOS2_ALIGN",
385 FALSE,
386 0,
387 0,
388 TRUE),
389
390
391 HOWTO (R_NIOS2_GOT16,
392 0,
393 2,
394 16,
395 FALSE,
396 6,
397 complain_overflow_bitfield,
398 bfd_elf_generic_reloc,
399 "R_NIOS2_GOT16",
400 FALSE,
401 0x003fffc0,
402 0x003fffc0,
403 FALSE),
404
405 HOWTO (R_NIOS2_CALL16,
406 0,
407 2,
408 16,
409 FALSE,
410 6,
411 complain_overflow_bitfield,
412 bfd_elf_generic_reloc,
413 "R_NIOS2_CALL16",
414 FALSE,
415 0x003fffc0,
416 0x003fffc0,
417 FALSE),
418
419 HOWTO (R_NIOS2_GOTOFF_LO,
420 0,
421 2,
422 16,
423 FALSE,
424 6,
425 complain_overflow_dont,
426 bfd_elf_generic_reloc,
427 "R_NIOS2_GOTOFF_LO",
428 FALSE,
429 0x003fffc0,
430 0x003fffc0,
431 FALSE),
432
433 HOWTO (R_NIOS2_GOTOFF_HA,
434 0,
435 2,
436 16,
437 FALSE,
438 6,
439 complain_overflow_dont,
440 bfd_elf_generic_reloc,
441 "R_NIOS2_GOTOFF_HA",
442 FALSE,
443 0x003fffc0,
444 0x003fffc0,
445 FALSE),
446
447 HOWTO (R_NIOS2_PCREL_LO,
448 0,
449 2,
450 16,
451 TRUE,
452 6,
453 complain_overflow_dont,
454 nios2_elf32_pcrel_lo16_relocate,
455 "R_NIOS2_PCREL_LO",
456 FALSE,
457 0x003fffc0,
458 0x003fffc0,
459 TRUE),
460
461 HOWTO (R_NIOS2_PCREL_HA,
462 0,
463 2,
464 16,
465 FALSE, /* This is a PC-relative relocation, but we need to subtract
466 PC ourselves before the HIADJ. */
467 6,
468 complain_overflow_dont,
469 nios2_elf32_pcrel_hiadj16_relocate,
470 "R_NIOS2_PCREL_HA",
471 FALSE,
472 0x003fffc0,
473 0x003fffc0,
474 TRUE),
475
476 HOWTO (R_NIOS2_TLS_GD16,
477 0,
478 2,
479 16,
480 FALSE,
481 6,
482 complain_overflow_bitfield,
483 bfd_elf_generic_reloc,
484 "R_NIOS2_TLS_GD16",
485 FALSE,
486 0x003fffc0,
487 0x003fffc0,
488 FALSE),
489
490 HOWTO (R_NIOS2_TLS_LDM16,
491 0,
492 2,
493 16,
494 FALSE,
495 6,
496 complain_overflow_bitfield,
497 bfd_elf_generic_reloc,
498 "R_NIOS2_TLS_LDM16",
499 FALSE,
500 0x003fffc0,
501 0x003fffc0,
502 FALSE),
503
504 HOWTO (R_NIOS2_TLS_LDO16,
505 0,
506 2,
507 16,
508 FALSE,
509 6,
510 complain_overflow_bitfield,
511 bfd_elf_generic_reloc,
512 "R_NIOS2_TLS_LDO16",
513 FALSE,
514 0x003fffc0,
515 0x003fffc0,
516 FALSE),
517
518 HOWTO (R_NIOS2_TLS_IE16,
519 0,
520 2,
521 16,
522 FALSE,
523 6,
524 complain_overflow_bitfield,
525 bfd_elf_generic_reloc,
526 "R_NIOS2_TLS_IE16",
527 FALSE,
528 0x003fffc0,
529 0x003fffc0,
530 FALSE),
531
532 HOWTO (R_NIOS2_TLS_LE16,
533 0,
534 2,
535 16,
536 FALSE,
537 6,
538 complain_overflow_bitfield,
539 bfd_elf_generic_reloc,
540 "R_NIOS2_TLS_LE16",
541 FALSE,
542 0x003fffc0,
543 0x003fffc0,
544 FALSE),
545
546 HOWTO (R_NIOS2_TLS_DTPMOD,
547 0,
548 2,
549 32,
550 FALSE,
551 0,
552 complain_overflow_dont,
553 bfd_elf_generic_reloc,
554 "R_NIOS2_TLS_DTPMOD",
555 FALSE,
556 0xffffffff,
557 0xffffffff,
558 FALSE),
559
560 HOWTO (R_NIOS2_TLS_DTPREL,
561 0,
562 2,
563 32,
564 FALSE,
565 0,
566 complain_overflow_dont,
567 bfd_elf_generic_reloc,
568 "R_NIOS2_TLS_DTPREL",
569 FALSE,
570 0xffffffff,
571 0xffffffff,
572 FALSE),
573
574 HOWTO (R_NIOS2_TLS_TPREL,
575 0,
576 2,
577 32,
578 FALSE,
579 0,
580 complain_overflow_dont,
581 bfd_elf_generic_reloc,
582 "R_NIOS2_TLS_TPREL",
583 FALSE,
584 0xffffffff,
585 0xffffffff,
586 FALSE),
587
588 HOWTO (R_NIOS2_COPY,
589 0,
590 2,
591 32,
592 FALSE,
593 0,
594 complain_overflow_dont,
595 bfd_elf_generic_reloc,
596 "R_NIOS2_COPY",
597 FALSE,
598 0,
599 0,
600 FALSE),
601
602 HOWTO (R_NIOS2_GLOB_DAT,
603 0,
604 2,
605 32,
606 FALSE,
607 0,
608 complain_overflow_dont,
609 bfd_elf_generic_reloc,
610 "R_NIOS2_GLOB_DAT",
611 FALSE,
612 0xffffffff,
613 0xffffffff,
614 FALSE),
615
616 HOWTO (R_NIOS2_JUMP_SLOT,
617 0,
618 2,
619 32,
620 FALSE,
621 0,
622 complain_overflow_dont,
623 bfd_elf_generic_reloc,
624 "R_NIOS2_JUMP_SLOT",
625 FALSE,
626 0xffffffff,
627 0xffffffff,
628 FALSE),
629
630 HOWTO (R_NIOS2_RELATIVE,
631 0,
632 2,
633 32,
634 FALSE,
635 0,
636 complain_overflow_dont,
637 bfd_elf_generic_reloc,
638 "R_NIOS2_RELATIVE",
639 FALSE,
640 0xffffffff,
641 0xffffffff,
642 FALSE),
643
644 HOWTO (R_NIOS2_GOTOFF,
645 0,
646 2,
647 32,
648 FALSE,
649 0,
650 complain_overflow_dont,
651 bfd_elf_generic_reloc,
652 "R_NIOS2_GOTOFF",
653 FALSE,
654 0xffffffff,
655 0xffffffff,
656 FALSE),
657
658 /* Add other relocations here. */
659 };
660
661 static unsigned char elf_code_to_howto_index[R_NIOS2_ILLEGAL + 1];
662
663 /* Return the howto for relocation RTYPE. */
664 static reloc_howto_type *
665 lookup_howto (unsigned int rtype)
666 {
667 static int initialized = 0;
668 int i;
669 int howto_tbl_size = (int) (sizeof (elf_nios2_howto_table_rel)
670 / sizeof (elf_nios2_howto_table_rel[0]));
671
672 if (!initialized)
673 {
674 initialized = 1;
675 memset (elf_code_to_howto_index, 0xff,
676 sizeof (elf_code_to_howto_index));
677 for (i = 0; i < howto_tbl_size; i++)
678 elf_code_to_howto_index[elf_nios2_howto_table_rel[i].type] = i;
679 }
680
681 BFD_ASSERT (rtype <= R_NIOS2_ILLEGAL);
682 i = elf_code_to_howto_index[rtype];
683 if (i >= howto_tbl_size)
684 return 0;
685 return elf_nios2_howto_table_rel + i;
686 }
687
688 /* Map for converting BFD reloc types to Nios II reloc types. */
689 struct elf_reloc_map
690 {
691 bfd_reloc_code_real_type bfd_val;
692 enum elf_nios2_reloc_type elf_val;
693 };
694
695 static const struct elf_reloc_map nios2_reloc_map[] = {
696 {BFD_RELOC_NIOS2_S16, R_NIOS2_S16},
697 {BFD_RELOC_NIOS2_U16, R_NIOS2_U16},
698 {BFD_RELOC_16_PCREL, R_NIOS2_PCREL16},
699 {BFD_RELOC_NIOS2_CALL26, R_NIOS2_CALL26},
700 {BFD_RELOC_NIOS2_IMM5, R_NIOS2_IMM5},
701 {BFD_RELOC_NIOS2_CACHE_OPX, R_NIOS2_CACHE_OPX},
702 {BFD_RELOC_NIOS2_IMM6, R_NIOS2_IMM6},
703 {BFD_RELOC_NIOS2_IMM8, R_NIOS2_IMM8},
704 {BFD_RELOC_NIOS2_HI16, R_NIOS2_HI16},
705 {BFD_RELOC_NIOS2_LO16, R_NIOS2_LO16},
706 {BFD_RELOC_NIOS2_HIADJ16, R_NIOS2_HIADJ16},
707 {BFD_RELOC_32, R_NIOS2_BFD_RELOC_32},
708 {BFD_RELOC_16, R_NIOS2_BFD_RELOC_16},
709 {BFD_RELOC_8, R_NIOS2_BFD_RELOC_8},
710 {BFD_RELOC_NIOS2_GPREL, R_NIOS2_GPREL},
711 {BFD_RELOC_VTABLE_INHERIT, R_NIOS2_GNU_VTINHERIT},
712 {BFD_RELOC_VTABLE_ENTRY, R_NIOS2_GNU_VTENTRY},
713 {BFD_RELOC_NIOS2_UJMP, R_NIOS2_UJMP},
714 {BFD_RELOC_NIOS2_CJMP, R_NIOS2_CJMP},
715 {BFD_RELOC_NIOS2_CALLR, R_NIOS2_CALLR},
716 {BFD_RELOC_NIOS2_ALIGN, R_NIOS2_ALIGN},
717 {BFD_RELOC_NIOS2_GOT16, R_NIOS2_GOT16},
718 {BFD_RELOC_NIOS2_CALL16, R_NIOS2_CALL16},
719 {BFD_RELOC_NIOS2_GOTOFF_LO, R_NIOS2_GOTOFF_LO},
720 {BFD_RELOC_NIOS2_GOTOFF_HA, R_NIOS2_GOTOFF_HA},
721 {BFD_RELOC_NIOS2_PCREL_LO, R_NIOS2_PCREL_LO},
722 {BFD_RELOC_NIOS2_PCREL_HA, R_NIOS2_PCREL_HA},
723 {BFD_RELOC_NIOS2_TLS_GD16, R_NIOS2_TLS_GD16},
724 {BFD_RELOC_NIOS2_TLS_LDM16, R_NIOS2_TLS_LDM16},
725 {BFD_RELOC_NIOS2_TLS_LDO16, R_NIOS2_TLS_LDO16},
726 {BFD_RELOC_NIOS2_TLS_IE16, R_NIOS2_TLS_IE16},
727 {BFD_RELOC_NIOS2_TLS_LE16, R_NIOS2_TLS_LE16},
728 {BFD_RELOC_NIOS2_TLS_DTPMOD, R_NIOS2_TLS_DTPMOD},
729 {BFD_RELOC_NIOS2_TLS_DTPREL, R_NIOS2_TLS_DTPREL},
730 {BFD_RELOC_NIOS2_TLS_TPREL, R_NIOS2_TLS_TPREL},
731 {BFD_RELOC_NIOS2_COPY, R_NIOS2_COPY},
732 {BFD_RELOC_NIOS2_GLOB_DAT, R_NIOS2_GLOB_DAT},
733 {BFD_RELOC_NIOS2_JUMP_SLOT, R_NIOS2_JUMP_SLOT},
734 {BFD_RELOC_NIOS2_RELATIVE, R_NIOS2_RELATIVE},
735 {BFD_RELOC_NIOS2_GOTOFF, R_NIOS2_GOTOFF}
736 };
737
738 /* The Nios II linker needs to keep track of the number of relocs that it
739 decides to copy as dynamic relocs in check_relocs for each symbol.
740 This is so that it can later discard them if they are found to be
741 unnecessary. We store the information in a field extending the
742 regular ELF linker hash table. */
743
744 struct elf32_nios2_dyn_relocs
745 {
746 struct elf32_nios2_dyn_relocs *next;
747
748 /* The input section of the reloc. */
749 asection *sec;
750
751 /* Total number of relocs copied for the input section. */
752 bfd_size_type count;
753
754 /* Number of pc-relative relocs copied for the input section. */
755 bfd_size_type pc_count;
756 };
757
758 /* Nios II ELF linker hash entry. */
759
760 struct elf32_nios2_link_hash_entry
761 {
762 struct elf_link_hash_entry root;
763
764 /* Track dynamic relocs copied for this symbol. */
765 struct elf32_nios2_dyn_relocs *dyn_relocs;
766
767 #define GOT_UNKNOWN 0
768 #define GOT_NORMAL 1
769 #define GOT_TLS_GD 2
770 #define GOT_TLS_IE 4
771 unsigned char tls_type;
772
773 /* We need to detect and take special action for symbols which are only
774 referenced with %call() and not with %got(). Such symbols do not need
775 a dynamic GOT reloc in shared objects, only a dynamic PLT reloc. Lazy
776 linking will not work if the dynamic GOT reloc exists.
777 To check for this condition efficiently, we compare got_types_used against
778 CALL16_USED, meaning
779 (got_types_used & (GOT16_USED | CALL16_USED)) == CALL16_USED. */
780 #define GOT16_USED 1
781 #define CALL16_USED 2
782 unsigned char got_types_used;
783 };
784
785 #define elf32_nios2_hash_entry(ent) \
786 ((struct elf32_nios2_link_hash_entry *) (ent))
787
788 /* Get the Nios II elf linker hash table from a link_info structure. */
789 #define elf32_nios2_hash_table(info) \
790 ((struct elf32_nios2_link_hash_table *) ((info)->hash))
791
792 /* Nios II ELF linker hash table. */
793 struct elf32_nios2_link_hash_table
794 {
795 /* The main hash table. */
796 struct elf_link_hash_table root;
797
798 /* Short-cuts to get to dynamic linker sections. */
799 asection *sdynbss;
800 asection *srelbss;
801 asection *sbss;
802
803 union {
804 bfd_signed_vma refcount;
805 bfd_vma offset;
806 } tls_ldm_got;
807
808 /* Small local sym cache. */
809 struct sym_cache sym_cache;
810
811 bfd_vma res_n_size;
812 };
813
814 struct nios2_elf32_obj_tdata
815 {
816 struct elf_obj_tdata root;
817
818 /* tls_type for each local got entry. */
819 char *local_got_tls_type;
820
821 /* TRUE if TLS GD relocs have been seen for this object. */
822 bfd_boolean has_tlsgd;
823 };
824
825 #define elf32_nios2_tdata(abfd) \
826 ((struct nios2_elf32_obj_tdata *) (abfd)->tdata.any)
827
828 #define elf32_nios2_local_got_tls_type(abfd) \
829 (elf32_nios2_tdata (abfd)->local_got_tls_type)
830
831 /* The name of the dynamic interpreter. This is put in the .interp
832 section. */
833 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
834
835 /* PLT implementation for position-dependent code. */
836 static const bfd_vma nios2_plt_entry[] = { /* .PLTn: */
837 0x03c00034, /* movhi r15, %hiadj(plt_got_slot_address) */
838 0x7bc00017, /* ldw r15, %lo(plt_got_slot_address)(r15) */
839 0x7800683a /* jmp r15 */
840 };
841
842 static const bfd_vma nios2_plt0_entry[] = { /* .PLTresolve */
843 0x03800034, /* movhi r14, %hiadj(res_0) */
844 0x73800004, /* addi r14, r14, %lo(res_0) */
845 0x7b9fc83a, /* sub r15, r15, r14 */
846 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
847 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
848 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
849 0x6800683a /* jmp r13 */
850 };
851
852 /* PLT implementation for position-independent code. */
853 static const bfd_vma nios2_so_plt_entry[] = { /* .PLTn */
854 0x03c00034, /* movhi r15, %hiadj(index * 4) */
855 0x7bc00004, /* addi r15, r15, %lo(index * 4) */
856 0x00000006 /* br .PLTresolve */
857 };
858
859 static const bfd_vma nios2_so_plt0_entry[] = { /* .PLTresolve */
860 0x001ce03a, /* nextpc r14 */
861 0x03400034, /* movhi r13, %hiadj(_GLOBAL_OFFSET_TABLE_) */
862 0x6b9b883a, /* add r13, r13, r14 */
863 0x6b800017, /* ldw r14, %lo(_GLOBAL_OFFSET_TABLE_+4)(r13) */
864 0x6b400017, /* ldw r13, %lo(_GLOBAL_OFFSET_TABLE_+8)(r13) */
865 0x6800683a /* jmp r13 */
866 };
867
868 /* Implement elf_backend_grok_prstatus:
869 Support for core dump NOTE sections. */
870 static bfd_boolean
871 nios2_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
872 {
873 int offset;
874 size_t size;
875
876 switch (note->descsz)
877 {
878 default:
879 return FALSE;
880
881 case 212: /* Linux/Nios II */
882 /* pr_cursig */
883 elf_tdata (abfd)->core->signal = bfd_get_16 (abfd, note->descdata + 12);
884
885 /* pr_pid */
886 elf_tdata (abfd)->core->pid = bfd_get_32 (abfd, note->descdata + 24);
887
888 /* pr_reg */
889 offset = 72;
890 size = 136;
891
892 break;
893 }
894
895 /* Make a ".reg/999" section. */
896 return _bfd_elfcore_make_pseudosection (abfd, ".reg",
897 size, note->descpos + offset);
898 }
899
900 /* Implement elf_backend_grok_psinfo. */
901 static bfd_boolean
902 nios2_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
903 {
904 switch (note->descsz)
905 {
906 default:
907 return FALSE;
908
909 case 124: /* Linux/Nios II elf_prpsinfo */
910 elf_tdata (abfd)->core->program
911 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
912 elf_tdata (abfd)->core->command
913 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
914 }
915
916 /* Note that for some reason, a spurious space is tacked
917 onto the end of the args in some (at least one anyway)
918 implementations, so strip it off if it exists. */
919
920 {
921 char *command = elf_tdata (abfd)->core->command;
922 int n = strlen (command);
923
924 if (0 < n && command[n - 1] == ' ')
925 command[n - 1] = '\0';
926 }
927
928 return TRUE;
929 }
930
931 /* Create an entry in a Nios II ELF linker hash table. */
932 static struct bfd_hash_entry *
933 link_hash_newfunc (struct bfd_hash_entry *entry,
934 struct bfd_hash_table *table, const char *string)
935 {
936 /* Allocate the structure if it has not already been allocated by a
937 subclass. */
938 if (entry == NULL)
939 {
940 entry = bfd_hash_allocate (table,
941 sizeof (struct elf32_nios2_link_hash_entry));
942 if (entry == NULL)
943 return entry;
944 }
945
946 /* Call the allocation method of the superclass. */
947 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
948 if (entry)
949 {
950 struct elf32_nios2_link_hash_entry *eh;
951
952 eh = (struct elf32_nios2_link_hash_entry *) entry;
953 eh->dyn_relocs = NULL;
954 eh->tls_type = GOT_UNKNOWN;
955 eh->got_types_used = 0;
956 }
957
958 return entry;
959 }
960
961 /* Implement bfd_elf32_bfd_reloc_type_lookup:
962 Given a BFD reloc type, return a howto structure. */
963 static reloc_howto_type *
964 nios2_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
965 bfd_reloc_code_real_type code)
966 {
967 int i;
968 for (i = 0;
969 i < (int) (sizeof (nios2_reloc_map) / sizeof (struct elf_reloc_map));
970 ++i)
971 if (nios2_reloc_map[i].bfd_val == code)
972 return &elf_nios2_howto_table_rel[(int) nios2_reloc_map[i].elf_val];
973 return NULL;
974 }
975
976 /* Implement bfd_elf32_bfd_reloc_name_lookup:
977 Given a reloc name, return a howto structure. */
978 static reloc_howto_type *
979 nios2_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
980 const char *r_name)
981 {
982 unsigned int i;
983 for (i = 0;
984 i < (sizeof (elf_nios2_howto_table_rel)
985 / sizeof (elf_nios2_howto_table_rel[0]));
986 i++)
987 if (elf_nios2_howto_table_rel[i].name
988 && strcasecmp (elf_nios2_howto_table_rel[i].name, r_name) == 0)
989 return &elf_nios2_howto_table_rel[i];
990
991 return NULL;
992 }
993
994 /* Implement elf_info_to_howto:
995 Given a ELF32 relocation, fill in a arelent structure. */
996 static void
997 nios2_elf32_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED, arelent *cache_ptr,
998 Elf_Internal_Rela *dst)
999 {
1000 unsigned int r_type;
1001
1002 r_type = ELF32_R_TYPE (dst->r_info);
1003 BFD_ASSERT (r_type < R_NIOS2_ILLEGAL);
1004 cache_ptr->howto = &elf_nios2_howto_table_rel[r_type];
1005 }
1006
1007 /* Return the base VMA address which should be subtracted from real addresses
1008 when resolving @dtpoff relocation.
1009 This is PT_TLS segment p_vaddr. */
1010 static bfd_vma
1011 dtpoff_base (struct bfd_link_info *info)
1012 {
1013 /* If tls_sec is NULL, we should have signalled an error already. */
1014 if (elf_hash_table (info)->tls_sec == NULL)
1015 return 0;
1016 return elf_hash_table (info)->tls_sec->vma;
1017 }
1018
1019 /* Return the relocation value for @tpoff relocation
1020 if STT_TLS virtual address is ADDRESS. */
1021 static bfd_vma
1022 tpoff (struct bfd_link_info *info, bfd_vma address)
1023 {
1024 struct elf_link_hash_table *htab = elf_hash_table (info);
1025
1026 /* If tls_sec is NULL, we should have signalled an error already. */
1027 if (htab->tls_sec == NULL)
1028 return 0;
1029 return address - htab->tls_sec->vma;
1030 }
1031
1032 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
1033 dangerous relocation. */
1034 static bfd_boolean
1035 nios2_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp, struct bfd_link_info *info)
1036 {
1037
1038 bfd_boolean gp_found;
1039 struct bfd_hash_entry *h;
1040 struct bfd_link_hash_entry *lh;
1041
1042 /* If we've already figured out what GP will be, just return it. */
1043 *pgp = _bfd_get_gp_value (output_bfd);
1044 if (*pgp)
1045 return TRUE;
1046
1047 h = bfd_hash_lookup (&info->hash->table, "_gp", FALSE, FALSE);
1048 lh = (struct bfd_link_hash_entry *) h;
1049 lookup:
1050 if (lh)
1051 {
1052 switch (lh->type)
1053 {
1054 case bfd_link_hash_undefined:
1055 case bfd_link_hash_undefweak:
1056 case bfd_link_hash_common:
1057 gp_found = FALSE;
1058 break;
1059 case bfd_link_hash_defined:
1060 case bfd_link_hash_defweak:
1061 gp_found = TRUE;
1062 *pgp = lh->u.def.value;
1063 break;
1064 case bfd_link_hash_indirect:
1065 case bfd_link_hash_warning:
1066 lh = lh->u.i.link;
1067 /* @@FIXME ignoring warning for now */
1068 goto lookup;
1069 case bfd_link_hash_new:
1070 default:
1071 abort ();
1072 }
1073 }
1074 else
1075 gp_found = FALSE;
1076
1077 if (!gp_found)
1078 {
1079 /* Only get the error once. */
1080 *pgp = 4;
1081 _bfd_set_gp_value (output_bfd, *pgp);
1082 return FALSE;
1083 }
1084
1085 _bfd_set_gp_value (output_bfd, *pgp);
1086
1087 return TRUE;
1088 }
1089
1090 /* Retrieve the previously cached _gp pointer, returning bfd_reloc_dangerous
1091 if it's not available as we don't have a link_info pointer available here
1092 to look it up in the output symbol table. We don't need to adjust the
1093 symbol value for an external symbol if we are producing relocatable
1094 output. */
1095 static bfd_reloc_status_type
1096 nios2_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
1097 char **error_message, bfd_vma *pgp)
1098 {
1099 if (bfd_is_und_section (symbol->section) && !relocatable)
1100 {
1101 *pgp = 0;
1102 return bfd_reloc_undefined;
1103 }
1104
1105 *pgp = _bfd_get_gp_value (output_bfd);
1106 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
1107 {
1108 if (relocatable)
1109 {
1110 /* Make up a value. */
1111 *pgp = symbol->section->output_section->vma + 0x4000;
1112 _bfd_set_gp_value (output_bfd, *pgp);
1113 }
1114 else
1115 {
1116 *error_message
1117 = (char *) _("global pointer relative relocation when _gp not defined");
1118 return bfd_reloc_dangerous;
1119 }
1120 }
1121
1122 return bfd_reloc_ok;
1123 }
1124
1125 /* The usual way of loading a 32-bit constant into a Nios II register is to
1126 load the high 16 bits in one instruction and then add the low 16 bits with
1127 a signed add. This means that the high halfword needs to be adjusted to
1128 compensate for the sign bit of the low halfword. This function returns the
1129 adjusted high halfword for a given 32-bit constant. */
1130 static
1131 bfd_vma hiadj (bfd_vma symbol_value)
1132 {
1133 return ((symbol_value + 0x8000) >> 16) & 0xffff;
1134 }
1135
1136 /* Do the relocations that require special handling. */
1137 static bfd_reloc_status_type
1138 nios2_elf32_do_hi16_relocate (bfd *abfd, reloc_howto_type *howto,
1139 asection *input_section ATTRIBUTE_UNUSED,
1140 bfd_byte *data, bfd_vma offset,
1141 bfd_vma symbol_value, bfd_vma addend)
1142 {
1143 symbol_value = symbol_value + addend;
1144 addend = 0;
1145 symbol_value = (symbol_value >> 16) & 0xffff;
1146 return _bfd_final_link_relocate (howto, abfd, input_section,
1147 data, offset, symbol_value, addend);
1148 }
1149
1150 static bfd_reloc_status_type
1151 nios2_elf32_do_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
1152 asection *input_section ATTRIBUTE_UNUSED,
1153 bfd_byte *data, bfd_vma offset,
1154 bfd_vma symbol_value, bfd_vma addend)
1155 {
1156 symbol_value = symbol_value + addend;
1157 addend = 0;
1158 symbol_value = symbol_value & 0xffff;
1159 return _bfd_final_link_relocate (howto, abfd, input_section,
1160 data, offset, symbol_value, addend);
1161 }
1162
1163 static bfd_reloc_status_type
1164 nios2_elf32_do_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
1165 asection *input_section ATTRIBUTE_UNUSED,
1166 bfd_byte *data, bfd_vma offset,
1167 bfd_vma symbol_value, bfd_vma addend)
1168 {
1169 symbol_value = symbol_value + addend;
1170 addend = 0;
1171 symbol_value = hiadj(symbol_value);
1172 return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
1173 symbol_value, addend);
1174 }
1175
1176 static bfd_reloc_status_type
1177 nios2_elf32_do_pcrel_lo16_relocate (bfd *abfd, reloc_howto_type *howto,
1178 asection *input_section ATTRIBUTE_UNUSED,
1179 bfd_byte *data, bfd_vma offset,
1180 bfd_vma symbol_value, bfd_vma addend)
1181 {
1182 symbol_value = symbol_value + addend;
1183 addend = 0;
1184 symbol_value = symbol_value & 0xffff;
1185 return _bfd_final_link_relocate (howto, abfd, input_section,
1186 data, offset, symbol_value, addend);
1187 }
1188
1189 static bfd_reloc_status_type
1190 nios2_elf32_do_pcrel_hiadj16_relocate (bfd *abfd, reloc_howto_type *howto,
1191 asection *input_section
1192 ATTRIBUTE_UNUSED,
1193 bfd_byte *data, bfd_vma offset,
1194 bfd_vma symbol_value, bfd_vma addend)
1195 {
1196 symbol_value = symbol_value + addend;
1197 symbol_value -= (input_section->output_section->vma
1198 + input_section->output_offset);
1199 symbol_value -= offset;
1200 addend = 0;
1201 symbol_value = hiadj(symbol_value);
1202 return _bfd_final_link_relocate (howto, abfd, input_section, data, offset,
1203 symbol_value, addend);
1204 }
1205
1206 static bfd_reloc_status_type
1207 nios2_elf32_do_pcrel16_relocate (bfd *abfd, reloc_howto_type *howto,
1208 asection *input_section ATTRIBUTE_UNUSED,
1209 bfd_byte *data, bfd_vma offset,
1210 bfd_vma symbol_value, bfd_vma addend)
1211 {
1212 /* NIOS2 pc relative relocations are relative to the next 32-bit instruction
1213 so we need to subtract 4 before doing a final_link_relocate. */
1214 symbol_value = symbol_value + addend - 4;
1215 addend = 0;
1216 return _bfd_final_link_relocate (howto, abfd, input_section,
1217 data, offset, symbol_value, addend);
1218 }
1219
1220 static bfd_reloc_status_type
1221 nios2_elf32_do_call26_relocate (bfd *abfd, reloc_howto_type *howto,
1222 asection *input_section ATTRIBUTE_UNUSED,
1223 bfd_byte *data, bfd_vma offset,
1224 bfd_vma symbol_value, bfd_vma addend)
1225 {
1226 /* Check that the relocation is in the same page as the current address. */
1227 if (((symbol_value + addend) & 0xf0000000)
1228 != ((input_section->output_section->vma + offset) & 0xf0000000))
1229 return bfd_reloc_overflow;
1230
1231 return _bfd_final_link_relocate (howto, abfd, input_section,
1232 data, offset, symbol_value, addend);
1233 }
1234
1235 static bfd_reloc_status_type
1236 nios2_elf32_do_gprel_relocate (bfd *abfd, reloc_howto_type *howto,
1237 asection *input_section ATTRIBUTE_UNUSED,
1238 bfd_byte *data, bfd_vma offset,
1239 bfd_vma symbol_value, bfd_vma addend)
1240 {
1241 /* Because we need the output_bfd, the special handling is done
1242 in nios2_elf32_relocate_section or in nios2_elf32_gprel_relocate. */
1243 return _bfd_final_link_relocate (howto, abfd, input_section,
1244 data, offset, symbol_value, addend);
1245 }
1246
1247 static bfd_reloc_status_type
1248 nios2_elf32_do_ujmp_relocate (bfd *abfd, reloc_howto_type *howto,
1249 asection *input_section ATTRIBUTE_UNUSED,
1250 bfd_byte *data, bfd_vma offset,
1251 bfd_vma symbol_value, bfd_vma addend)
1252 {
1253 bfd_vma symbol_lo16, symbol_hi16;
1254 bfd_reloc_status_type r;
1255 symbol_value = symbol_value + addend;
1256 addend = 0;
1257 symbol_hi16 = (symbol_value >> 16) & 0xffff;
1258 symbol_lo16 = symbol_value & 0xffff;
1259
1260 r = _bfd_final_link_relocate (howto, abfd, input_section,
1261 data, offset, symbol_hi16, addend);
1262
1263 if (r == bfd_reloc_ok)
1264 return _bfd_final_link_relocate (howto, abfd, input_section,
1265 data, offset + 4, symbol_lo16, addend);
1266
1267 return r;
1268 }
1269
1270 static bfd_reloc_status_type
1271 nios2_elf32_do_cjmp_relocate (bfd *abfd, reloc_howto_type *howto,
1272 asection *input_section ATTRIBUTE_UNUSED,
1273 bfd_byte *data, bfd_vma offset,
1274 bfd_vma symbol_value, bfd_vma addend)
1275 {
1276 bfd_vma symbol_lo16, symbol_hi16;
1277 bfd_reloc_status_type r;
1278 symbol_value = symbol_value + addend;
1279 addend = 0;
1280 symbol_hi16 = (symbol_value >> 16) & 0xffff;
1281 symbol_lo16 = symbol_value & 0xffff;
1282
1283 r = _bfd_final_link_relocate (howto, abfd, input_section,
1284 data, offset, symbol_hi16, addend);
1285
1286 if (r == bfd_reloc_ok)
1287 return _bfd_final_link_relocate (howto, abfd, input_section,
1288 data, offset + 4, symbol_lo16, addend);
1289
1290 return r;
1291 }
1292
1293 static bfd_reloc_status_type
1294 nios2_elf32_do_callr_relocate (bfd *abfd, reloc_howto_type *howto,
1295 asection *input_section ATTRIBUTE_UNUSED,
1296 bfd_byte *data, bfd_vma offset,
1297 bfd_vma symbol_value, bfd_vma addend)
1298 {
1299 bfd_vma symbol_lo16, symbol_hi16;
1300 bfd_reloc_status_type r;
1301 symbol_value = symbol_value + addend;
1302 addend = 0;
1303 symbol_hi16 = (symbol_value >> 16) & 0xffff;
1304 symbol_lo16 = symbol_value & 0xffff;
1305
1306 r = _bfd_final_link_relocate (howto, abfd, input_section,
1307 data, offset, symbol_hi16, addend);
1308
1309 if (r == bfd_reloc_ok)
1310 return _bfd_final_link_relocate (howto, abfd, input_section,
1311 data, offset + 4, symbol_lo16, addend);
1312
1313 return r;
1314 }
1315
1316 /* HOWTO handlers for relocations that require special handling. */
1317
1318 /* This is for relocations used only when relaxing to ensure
1319 changes in size of section don't screw up .align. */
1320 static bfd_reloc_status_type
1321 nios2_elf32_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED, arelent *reloc_entry,
1322 asymbol *symbol ATTRIBUTE_UNUSED,
1323 void *data ATTRIBUTE_UNUSED, asection *input_section,
1324 bfd *output_bfd,
1325 char **error_message ATTRIBUTE_UNUSED)
1326 {
1327 if (output_bfd != NULL)
1328 reloc_entry->address += input_section->output_offset;
1329 return bfd_reloc_ok;
1330 }
1331
1332 static bfd_reloc_status_type
1333 nios2_elf32_hi16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1334 void *data, asection *input_section,
1335 bfd *output_bfd,
1336 char **error_message ATTRIBUTE_UNUSED)
1337 {
1338 /* This part is from bfd_elf_generic_reloc. */
1339 if (output_bfd != NULL
1340 && (symbol->flags & BSF_SECTION_SYM) == 0
1341 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1342 {
1343 reloc_entry->address += input_section->output_offset;
1344 return bfd_reloc_ok;
1345 }
1346
1347 if (output_bfd != NULL)
1348 /* FIXME: See bfd_perform_relocation. Is this right? */
1349 return bfd_reloc_continue;
1350
1351 return nios2_elf32_do_hi16_relocate (abfd, reloc_entry->howto,
1352 input_section,
1353 data, reloc_entry->address,
1354 (symbol->value
1355 + symbol->section->output_section->vma
1356 + symbol->section->output_offset),
1357 reloc_entry->addend);
1358 }
1359
1360 static bfd_reloc_status_type
1361 nios2_elf32_lo16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1362 void *data, asection *input_section,
1363 bfd *output_bfd,
1364 char **error_message ATTRIBUTE_UNUSED)
1365 {
1366 /* This part is from bfd_elf_generic_reloc. */
1367 if (output_bfd != NULL
1368 && (symbol->flags & BSF_SECTION_SYM) == 0
1369 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1370 {
1371 reloc_entry->address += input_section->output_offset;
1372 return bfd_reloc_ok;
1373 }
1374
1375 if (output_bfd != NULL)
1376 /* FIXME: See bfd_perform_relocation. Is this right? */
1377 return bfd_reloc_continue;
1378
1379 return nios2_elf32_do_lo16_relocate (abfd, reloc_entry->howto,
1380 input_section,
1381 data, reloc_entry->address,
1382 (symbol->value
1383 + symbol->section->output_section->vma
1384 + symbol->section->output_offset),
1385 reloc_entry->addend);
1386 }
1387
1388 static bfd_reloc_status_type
1389 nios2_elf32_hiadj16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1390 void *data, asection *input_section,
1391 bfd *output_bfd,
1392 char **error_message ATTRIBUTE_UNUSED)
1393 {
1394 /* This part is from bfd_elf_generic_reloc. */
1395 if (output_bfd != NULL
1396 && (symbol->flags & BSF_SECTION_SYM) == 0
1397 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1398 {
1399 reloc_entry->address += input_section->output_offset;
1400 return bfd_reloc_ok;
1401 }
1402
1403 if (output_bfd != NULL)
1404 /* FIXME: See bfd_perform_relocation. Is this right? */
1405 return bfd_reloc_continue;
1406
1407 return nios2_elf32_do_hiadj16_relocate (abfd, reloc_entry->howto,
1408 input_section,
1409 data, reloc_entry->address,
1410 (symbol->value
1411 + symbol->section->output_section->vma
1412 + symbol->section->output_offset),
1413 reloc_entry->addend);
1414 }
1415
1416 static bfd_reloc_status_type
1417 nios2_elf32_pcrel_lo16_relocate (bfd *abfd, arelent *reloc_entry,
1418 asymbol *symbol, void *data,
1419 asection *input_section, bfd *output_bfd,
1420 char **error_message ATTRIBUTE_UNUSED)
1421 {
1422 /* This part is from bfd_elf_generic_reloc. */
1423 if (output_bfd != NULL
1424 && (symbol->flags & BSF_SECTION_SYM) == 0
1425 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1426 {
1427 reloc_entry->address += input_section->output_offset;
1428 return bfd_reloc_ok;
1429 }
1430
1431 if (output_bfd != NULL)
1432 /* FIXME: See bfd_perform_relocation. Is this right? */
1433 return bfd_reloc_continue;
1434
1435 return nios2_elf32_do_pcrel_lo16_relocate (
1436 abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
1437 (symbol->value + symbol->section->output_section->vma
1438 + symbol->section->output_offset),
1439 reloc_entry->addend);
1440 }
1441
1442 static bfd_reloc_status_type
1443 nios2_elf32_pcrel_hiadj16_relocate (bfd *abfd, arelent *reloc_entry,
1444 asymbol *symbol, void *data,
1445 asection *input_section, bfd *output_bfd,
1446 char **error_message ATTRIBUTE_UNUSED)
1447 {
1448 /* This part is from bfd_elf_generic_reloc. */
1449 if (output_bfd != NULL
1450 && (symbol->flags & BSF_SECTION_SYM) == 0
1451 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1452 {
1453 reloc_entry->address += input_section->output_offset;
1454 return bfd_reloc_ok;
1455 }
1456
1457 if (output_bfd != NULL)
1458 /* FIXME: See bfd_perform_relocation. Is this right? */
1459 return bfd_reloc_continue;
1460
1461 return nios2_elf32_do_pcrel_hiadj16_relocate (
1462 abfd, reloc_entry->howto, input_section, data, reloc_entry->address,
1463 (symbol->value + symbol->section->output_section->vma
1464 + symbol->section->output_offset),
1465 reloc_entry->addend);
1466 }
1467
1468 static bfd_reloc_status_type
1469 nios2_elf32_pcrel16_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1470 void *data, asection *input_section,
1471 bfd *output_bfd,
1472 char **error_message ATTRIBUTE_UNUSED)
1473 {
1474 /* This part is from bfd_elf_generic_reloc. */
1475 if (output_bfd != NULL
1476 && (symbol->flags & BSF_SECTION_SYM) == 0
1477 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1478 {
1479 reloc_entry->address += input_section->output_offset;
1480 return bfd_reloc_ok;
1481 }
1482
1483 if (output_bfd != NULL)
1484 /* FIXME: See bfd_perform_relocation. Is this right? */
1485 return bfd_reloc_continue;
1486
1487 return nios2_elf32_do_pcrel16_relocate (abfd, reloc_entry->howto,
1488 input_section,
1489 data, reloc_entry->address,
1490 (symbol->value
1491 + symbol->section->output_section->vma
1492 + symbol->section->output_offset),
1493 reloc_entry->addend);
1494 }
1495
1496 static bfd_reloc_status_type
1497 nios2_elf32_call26_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1498 void *data, asection *input_section,
1499 bfd *output_bfd,
1500 char **error_message ATTRIBUTE_UNUSED)
1501 {
1502 /* This part is from bfd_elf_generic_reloc. */
1503 if (output_bfd != NULL
1504 && (symbol->flags & BSF_SECTION_SYM) == 0
1505 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1506 {
1507 reloc_entry->address += input_section->output_offset;
1508 return bfd_reloc_ok;
1509 }
1510
1511 if (output_bfd != NULL)
1512 /* FIXME: See bfd_perform_relocation. Is this right? */
1513 return bfd_reloc_continue;
1514
1515 return nios2_elf32_do_call26_relocate (abfd, reloc_entry->howto,
1516 input_section,
1517 data, reloc_entry->address,
1518 (symbol->value
1519 + symbol->section->output_section->vma
1520 + symbol->section->output_offset),
1521 reloc_entry->addend);
1522 }
1523
1524 static bfd_reloc_status_type
1525 nios2_elf32_gprel_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1526 void *data, asection *input_section,
1527 bfd *output_bfd, char **msg)
1528 {
1529 bfd_vma relocation;
1530 bfd_vma gp;
1531 bfd_reloc_status_type r;
1532
1533
1534 /* This part is from bfd_elf_generic_reloc. */
1535 if (output_bfd != NULL
1536 && (symbol->flags & BSF_SECTION_SYM) == 0
1537 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1538 {
1539 reloc_entry->address += input_section->output_offset;
1540 return bfd_reloc_ok;
1541 }
1542
1543 if (output_bfd != NULL)
1544 /* FIXME: See bfd_perform_relocation. Is this right? */
1545 return bfd_reloc_continue;
1546
1547 relocation = (symbol->value
1548 + symbol->section->output_section->vma
1549 + symbol->section->output_offset);
1550
1551 /* This assumes we've already cached the _gp symbol. */
1552 r = nios2_elf_final_gp (abfd, symbol, FALSE, msg, &gp);
1553 if (r == bfd_reloc_ok)
1554 {
1555 relocation = relocation + reloc_entry->addend - gp;
1556 reloc_entry->addend = 0;
1557 if ((signed) relocation < -32768 || (signed) relocation > 32767)
1558 {
1559 *msg = _("global pointer relative address out of range");
1560 r = bfd_reloc_outofrange;
1561 }
1562 else
1563 r = nios2_elf32_do_gprel_relocate (abfd, reloc_entry->howto,
1564 input_section,
1565 data, reloc_entry->address,
1566 relocation, reloc_entry->addend);
1567 }
1568
1569 return r;
1570 }
1571
1572 static bfd_reloc_status_type
1573 nios2_elf32_ujmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1574 void *data, asection *input_section,
1575 bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
1576 {
1577 /* This part is from bfd_elf_generic_reloc. */
1578 if (output_bfd != NULL
1579 && (symbol->flags & BSF_SECTION_SYM) == 0
1580 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1581 {
1582 reloc_entry->address += input_section->output_offset;
1583 return bfd_reloc_ok;
1584 }
1585
1586 if (output_bfd != NULL)
1587 /* FIXME: See bfd_perform_relocation. Is this right? */
1588 return bfd_reloc_continue;
1589
1590 return nios2_elf32_do_ujmp_relocate (abfd, reloc_entry->howto,
1591 input_section,
1592 data, reloc_entry->address,
1593 (symbol->value
1594 + symbol->section->output_section->vma
1595 + symbol->section->output_offset),
1596 reloc_entry->addend);
1597 }
1598
1599 static bfd_reloc_status_type
1600 nios2_elf32_cjmp_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1601 void *data, asection *input_section,
1602 bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
1603 {
1604 /* This part is from bfd_elf_generic_reloc. */
1605 if (output_bfd != NULL
1606 && (symbol->flags & BSF_SECTION_SYM) == 0
1607 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1608 {
1609 reloc_entry->address += input_section->output_offset;
1610 return bfd_reloc_ok;
1611 }
1612
1613 if (output_bfd != NULL)
1614 /* FIXME: See bfd_perform_relocation. Is this right? */
1615 return bfd_reloc_continue;
1616
1617 return nios2_elf32_do_cjmp_relocate (abfd, reloc_entry->howto,
1618 input_section,
1619 data, reloc_entry->address,
1620 (symbol->value
1621 + symbol->section->output_section->vma
1622 + symbol->section->output_offset),
1623 reloc_entry->addend);
1624 }
1625
1626 static bfd_reloc_status_type
1627 nios2_elf32_callr_relocate (bfd *abfd, arelent *reloc_entry, asymbol *symbol,
1628 void *data, asection *input_section,
1629 bfd *output_bfd, char **msg ATTRIBUTE_UNUSED)
1630 {
1631 /* This part is from bfd_elf_generic_reloc. */
1632 if (output_bfd != NULL
1633 && (symbol->flags & BSF_SECTION_SYM) == 0
1634 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
1635 {
1636 reloc_entry->address += input_section->output_offset;
1637 return bfd_reloc_ok;
1638 }
1639
1640 if (output_bfd != NULL)
1641 /* FIXME: See bfd_perform_relocation. Is this right? */
1642 return bfd_reloc_continue;
1643
1644 return nios2_elf32_do_callr_relocate (abfd, reloc_entry->howto,
1645 input_section,
1646 data, reloc_entry->address,
1647 (symbol->value
1648 + symbol->section->output_section->vma
1649 + symbol->section->output_offset),
1650 reloc_entry->addend);
1651 }
1652
1653
1654 /* Implement elf_backend_relocate_section. */
1655 static bfd_boolean
1656 nios2_elf32_relocate_section (bfd *output_bfd,
1657 struct bfd_link_info *info,
1658 bfd *input_bfd,
1659 asection *input_section,
1660 bfd_byte *contents,
1661 Elf_Internal_Rela *relocs,
1662 Elf_Internal_Sym *local_syms,
1663 asection **local_sections)
1664 {
1665 Elf_Internal_Shdr *symtab_hdr;
1666 struct elf_link_hash_entry **sym_hashes;
1667 Elf_Internal_Rela *rel;
1668 Elf_Internal_Rela *relend;
1669 struct elf32_nios2_link_hash_table *htab;
1670 asection *sgot;
1671 asection *splt;
1672 asection *sreloc = NULL;
1673 bfd_vma *local_got_offsets;
1674
1675 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1676 sym_hashes = elf_sym_hashes (input_bfd);
1677 relend = relocs + input_section->reloc_count;
1678
1679 htab = elf32_nios2_hash_table (info);
1680 sgot = htab->root.sgot;
1681 splt = htab->root.splt;
1682 local_got_offsets = elf_local_got_offsets (input_bfd);
1683
1684 for (rel = relocs; rel < relend; rel++)
1685 {
1686 reloc_howto_type *howto;
1687 unsigned long r_symndx;
1688 Elf_Internal_Sym *sym;
1689 asection *sec;
1690 struct elf_link_hash_entry *h;
1691 struct elf32_nios2_link_hash_entry *eh;
1692 bfd_vma relocation;
1693 bfd_vma gp;
1694 bfd_vma reloc_address;
1695 bfd_reloc_status_type r = bfd_reloc_ok;
1696 const char *name = NULL;
1697 int r_type;
1698 const char *format;
1699 char msgbuf[256];
1700 const char* msg = (const char*) NULL;
1701 bfd_boolean unresolved_reloc;
1702 bfd_vma off;
1703 int use_plt;
1704
1705 r_type = ELF32_R_TYPE (rel->r_info);
1706 r_symndx = ELF32_R_SYM (rel->r_info);
1707
1708 howto = lookup_howto ((unsigned) ELF32_R_TYPE (rel->r_info));
1709 h = NULL;
1710 sym = NULL;
1711 sec = NULL;
1712
1713 if (r_symndx < symtab_hdr->sh_info)
1714 {
1715 sym = local_syms + r_symndx;
1716 sec = local_sections[r_symndx];
1717 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1718 }
1719 else
1720 {
1721 bfd_boolean warned;
1722
1723 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1724 r_symndx, symtab_hdr, sym_hashes,
1725 h, sec, relocation,
1726 unresolved_reloc, warned);
1727 }
1728
1729 if (sec && discarded_section (sec))
1730 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1731 rel, 1, relend, howto, 0, contents);
1732
1733 /* Nothing more to do unless this is a final link. */
1734 if (info->relocatable)
1735 continue;
1736
1737 if (sec && sec->output_section)
1738 reloc_address = (sec->output_section->vma + sec->output_offset
1739 + rel->r_offset);
1740 else
1741 reloc_address = 0;
1742
1743 if (howto)
1744 {
1745 switch (howto->type)
1746 {
1747 case R_NIOS2_HI16:
1748 r = nios2_elf32_do_hi16_relocate (input_bfd, howto,
1749 input_section,
1750 contents, rel->r_offset,
1751 relocation, rel->r_addend);
1752 break;
1753 case R_NIOS2_LO16:
1754 r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
1755 input_section,
1756 contents, rel->r_offset,
1757 relocation, rel->r_addend);
1758 break;
1759 case R_NIOS2_PCREL_LO:
1760 r = nios2_elf32_do_pcrel_lo16_relocate (input_bfd, howto,
1761 input_section,
1762 contents,
1763 rel->r_offset,
1764 relocation,
1765 rel->r_addend);
1766 break;
1767 case R_NIOS2_HIADJ16:
1768 r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
1769 input_section, contents,
1770 rel->r_offset, relocation,
1771 rel->r_addend);
1772 break;
1773 case R_NIOS2_PCREL_HA:
1774 r = nios2_elf32_do_pcrel_hiadj16_relocate (input_bfd, howto,
1775 input_section,
1776 contents,
1777 rel->r_offset,
1778 relocation,
1779 rel->r_addend);
1780 break;
1781 case R_NIOS2_PCREL16:
1782 r = nios2_elf32_do_pcrel16_relocate (input_bfd, howto,
1783 input_section, contents,
1784 rel->r_offset, relocation,
1785 rel->r_addend);
1786 break;
1787 case R_NIOS2_GPREL:
1788 /* Turns an absolute address into a gp-relative address. */
1789 if (!nios2_elf_assign_gp (output_bfd, &gp, info))
1790 {
1791 format = _("global pointer relative relocation at address "
1792 "0x%08x when _gp not defined\n");
1793 sprintf (msgbuf, format, reloc_address);
1794 msg = msgbuf;
1795 r = bfd_reloc_dangerous;
1796 }
1797 else
1798 {
1799 bfd_vma symbol_address = rel->r_addend + relocation;
1800 relocation = relocation + rel->r_addend - gp;
1801 rel->r_addend = 0;
1802 if (((signed) relocation < -32768
1803 || (signed) relocation > 32767)
1804 && (!h
1805 || h->root.type == bfd_link_hash_defined
1806 || h->root.type == bfd_link_hash_defweak))
1807 {
1808 format = _("Unable to reach %s (at 0x%08x) from the "
1809 "global pointer (at 0x%08x) because the "
1810 "offset (%d) is out of the allowed range, "
1811 "-32678 to 32767.\n" );
1812 sprintf (msgbuf, format, name, symbol_address, gp,
1813 (signed)relocation);
1814 msg = msgbuf;
1815 r = bfd_reloc_outofrange;
1816 }
1817 else
1818 r = _bfd_final_link_relocate (howto, input_bfd,
1819 input_section, contents,
1820 rel->r_offset, relocation,
1821 rel->r_addend);
1822 }
1823
1824 break;
1825 case R_NIOS2_UJMP:
1826 r = nios2_elf32_do_ujmp_relocate (input_bfd, howto,
1827 input_section,
1828 contents, rel->r_offset,
1829 relocation, rel->r_addend);
1830 break;
1831 case R_NIOS2_CJMP:
1832 r = nios2_elf32_do_cjmp_relocate (input_bfd, howto,
1833 input_section,
1834 contents, rel->r_offset,
1835 relocation, rel->r_addend);
1836 break;
1837 case R_NIOS2_CALLR:
1838 r = nios2_elf32_do_callr_relocate (input_bfd, howto,
1839 input_section, contents,
1840 rel->r_offset, relocation,
1841 rel->r_addend);
1842 break;
1843 case R_NIOS2_CALL26:
1844 /* If we have a call to an undefined weak symbol, we just want
1845 to stuff a zero in the bits of the call instruction and
1846 bypass the normal call26 relocation handling, because it'll
1847 diagnose an overflow error if address 0 isn't in the same
1848 256MB segment as the call site. Presumably the call
1849 should be guarded by a null check anyway. */
1850 if (h != NULL && h->root.type == bfd_link_hash_undefweak)
1851 {
1852 BFD_ASSERT (relocation == 0 && rel->r_addend == 0);
1853 r = _bfd_final_link_relocate (howto, input_bfd,
1854 input_section, contents,
1855 rel->r_offset, relocation,
1856 rel->r_addend);
1857 break;
1858 }
1859 /* Handle relocations which should use the PLT entry.
1860 NIOS2_BFD_RELOC_32 relocations will use the symbol's value,
1861 which may point to a PLT entry, but we don't need to handle
1862 that here. If we created a PLT entry, all branches in this
1863 object should go to it. */
1864 if (h != NULL && splt != NULL && h->plt.offset != (bfd_vma) -1)
1865 {
1866 /* If we've created a .plt section, and assigned a PLT entry
1867 to this function, it should not be known to bind locally.
1868 If it were, we would have cleared the PLT entry. */
1869 BFD_ASSERT (!SYMBOL_CALLS_LOCAL (info, h));
1870
1871 relocation = (splt->output_section->vma
1872 + splt->output_offset
1873 + h->plt.offset);
1874
1875 unresolved_reloc = FALSE;
1876 }
1877 r = nios2_elf32_do_call26_relocate (input_bfd, howto,
1878 input_section, contents,
1879 rel->r_offset, relocation,
1880 rel->r_addend);
1881 break;
1882 case R_NIOS2_ALIGN:
1883 r = bfd_reloc_ok;
1884 /* For symmetry this would be
1885 r = nios2_elf32_do_ignore_reloc (input_bfd, howto,
1886 input_section, contents,
1887 rel->r_offset, relocation,
1888 rel->r_addend);
1889 but do_ignore_reloc would do no more than return
1890 bfd_reloc_ok. */
1891 break;
1892
1893 case R_NIOS2_GOT16:
1894 case R_NIOS2_CALL16:
1895 /* Relocation is to the entry for this symbol in the
1896 global offset table. */
1897 if (sgot == NULL)
1898 {
1899 r = bfd_reloc_notsupported;
1900 break;
1901 }
1902
1903 use_plt = 0;
1904
1905 if (h != NULL)
1906 {
1907 bfd_boolean dyn;
1908
1909 eh = (struct elf32_nios2_link_hash_entry *)h;
1910 use_plt = (eh->got_types_used == CALL16_USED
1911 && h->plt.offset != (bfd_vma) -1);
1912
1913 off = h->got.offset;
1914 BFD_ASSERT (off != (bfd_vma) -1);
1915 dyn = elf_hash_table (info)->dynamic_sections_created;
1916 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
1917 || (info->shared
1918 && SYMBOL_REFERENCES_LOCAL (info, h))
1919 || (ELF_ST_VISIBILITY (h->other)
1920 && h->root.type == bfd_link_hash_undefweak))
1921 {
1922 /* This is actually a static link, or it is a -Bsymbolic
1923 link and the symbol is defined locally. We must
1924 initialize this entry in the global offset table.
1925 Since the offset must always be a multiple of 4, we
1926 use the least significant bit to record whether we
1927 have initialized it already.
1928
1929 When doing a dynamic link, we create a .rela.got
1930 relocation entry to initialize the value. This is
1931 done in the finish_dynamic_symbol routine. */
1932 if ((off & 1) != 0)
1933 off &= ~1;
1934 else
1935 {
1936 bfd_put_32 (output_bfd, relocation,
1937 sgot->contents + off);
1938 h->got.offset |= 1;
1939 }
1940 }
1941 else
1942 unresolved_reloc = FALSE;
1943 }
1944 else
1945 {
1946 BFD_ASSERT (local_got_offsets != NULL
1947 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1948
1949 off = local_got_offsets[r_symndx];
1950
1951 /* The offset must always be a multiple of 4. We use the
1952 least significant bit to record whether we have already
1953 generated the necessary reloc. */
1954 if ((off & 1) != 0)
1955 off &= ~1;
1956 else
1957 {
1958 bfd_put_32 (output_bfd, relocation,
1959 sgot->contents + off);
1960
1961 if (info->shared)
1962 {
1963 asection *srelgot;
1964 Elf_Internal_Rela outrel;
1965 bfd_byte *loc;
1966
1967 srelgot = htab->root.srelgot;
1968 BFD_ASSERT (srelgot != NULL);
1969
1970 outrel.r_addend = relocation;
1971 outrel.r_offset = (sgot->output_section->vma
1972 + sgot->output_offset
1973 + off);
1974 outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
1975 loc = srelgot->contents;
1976 loc += (srelgot->reloc_count++ *
1977 sizeof (Elf32_External_Rela));
1978 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1979 }
1980
1981 local_got_offsets[r_symndx] |= 1;
1982 }
1983 }
1984
1985 if (use_plt && info->shared)
1986 {
1987 off = ((h->plt.offset - 24) / 12 + 3) * 4;
1988 relocation = htab->root.sgotplt->output_offset + off;
1989 }
1990 else
1991 relocation = sgot->output_offset + off;
1992
1993 /* This relocation does not use the addend. */
1994 rel->r_addend = 0;
1995
1996 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1997 contents, rel->r_offset,
1998 relocation, rel->r_addend);
1999 break;
2000
2001 case R_NIOS2_GOTOFF_LO:
2002 case R_NIOS2_GOTOFF_HA:
2003 case R_NIOS2_GOTOFF:
2004 /* Relocation is relative to the start of the
2005 global offset table. */
2006
2007 BFD_ASSERT (sgot != NULL);
2008 if (sgot == NULL)
2009 {
2010 r = bfd_reloc_notsupported;
2011 break;
2012 }
2013
2014 /* Note that sgot->output_offset is not involved in this
2015 calculation. We always want the start of .got. If we
2016 define _GLOBAL_OFFSET_TABLE in a different way, as is
2017 permitted by the ABI, we might have to change this
2018 calculation. */
2019 relocation -= sgot->output_section->vma;
2020 switch (howto->type)
2021 {
2022 case R_NIOS2_GOTOFF_LO:
2023 r = nios2_elf32_do_lo16_relocate (input_bfd, howto,
2024 input_section, contents,
2025 rel->r_offset, relocation,
2026 rel->r_addend);
2027 break;
2028 case R_NIOS2_GOTOFF_HA:
2029 r = nios2_elf32_do_hiadj16_relocate (input_bfd, howto,
2030 input_section, contents,
2031 rel->r_offset,
2032 relocation,
2033 rel->r_addend);
2034 break;
2035 default:
2036 r = _bfd_final_link_relocate (howto, input_bfd,
2037 input_section, contents,
2038 rel->r_offset, relocation,
2039 rel->r_addend);
2040 break;
2041 }
2042 break;
2043
2044 case R_NIOS2_TLS_LDO16:
2045 relocation -= dtpoff_base (info) + DTP_OFFSET;
2046
2047 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2048 contents, rel->r_offset,
2049 relocation, rel->r_addend);
2050 break;
2051 case R_NIOS2_TLS_LDM16:
2052 if (htab->root.sgot == NULL)
2053 abort ();
2054
2055 off = htab->tls_ldm_got.offset;
2056
2057 if ((off & 1) != 0)
2058 off &= ~1;
2059 else
2060 {
2061 /* If we don't know the module number, create a relocation
2062 for it. */
2063 if (info->shared)
2064 {
2065 Elf_Internal_Rela outrel;
2066 bfd_byte *loc;
2067
2068 if (htab->root.srelgot == NULL)
2069 abort ();
2070
2071 outrel.r_addend = 0;
2072 outrel.r_offset = (htab->root.sgot->output_section->vma
2073 + htab->root.sgot->output_offset
2074 + off);
2075 outrel.r_info = ELF32_R_INFO (0, R_NIOS2_TLS_DTPMOD);
2076
2077 loc = htab->root.srelgot->contents;
2078 loc += (htab->root.srelgot->reloc_count++
2079 * sizeof (Elf32_External_Rela));
2080 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2081 }
2082 else
2083 bfd_put_32 (output_bfd, 1,
2084 htab->root.sgot->contents + off);
2085
2086 htab->tls_ldm_got.offset |= 1;
2087 }
2088
2089 relocation = (htab->root.sgot->output_offset + off);
2090
2091 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2092 contents, rel->r_offset,
2093 relocation, rel->r_addend);
2094
2095 break;
2096 case R_NIOS2_TLS_GD16:
2097 case R_NIOS2_TLS_IE16:
2098 {
2099 int indx;
2100 char tls_type;
2101
2102 if (htab->root.sgot == NULL)
2103 abort ();
2104
2105 indx = 0;
2106 if (h != NULL)
2107 {
2108 bfd_boolean dyn;
2109 dyn = htab->root.dynamic_sections_created;
2110 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2111 && (!info->shared
2112 || !SYMBOL_REFERENCES_LOCAL (info, h)))
2113 {
2114 unresolved_reloc = FALSE;
2115 indx = h->dynindx;
2116 }
2117 off = h->got.offset;
2118 tls_type = (((struct elf32_nios2_link_hash_entry *) h)
2119 ->tls_type);
2120 }
2121 else
2122 {
2123 if (local_got_offsets == NULL)
2124 abort ();
2125 off = local_got_offsets[r_symndx];
2126 tls_type = (elf32_nios2_local_got_tls_type (input_bfd)
2127 [r_symndx]);
2128 }
2129
2130 if (tls_type == GOT_UNKNOWN)
2131 abort ();
2132
2133 if ((off & 1) != 0)
2134 off &= ~1;
2135 else
2136 {
2137 bfd_boolean need_relocs = FALSE;
2138 Elf_Internal_Rela outrel;
2139 bfd_byte *loc = NULL;
2140 int cur_off = off;
2141
2142 /* The GOT entries have not been initialized yet. Do it
2143 now, and emit any relocations. If both an IE GOT and a
2144 GD GOT are necessary, we emit the GD first. */
2145
2146 if ((info->shared || indx != 0)
2147 && (h == NULL
2148 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2149 || h->root.type != bfd_link_hash_undefweak))
2150 {
2151 need_relocs = TRUE;
2152 if (htab->root.srelgot == NULL)
2153 abort ();
2154 loc = htab->root.srelgot->contents;
2155 loc += (htab->root.srelgot->reloc_count *
2156 sizeof (Elf32_External_Rela));
2157 }
2158
2159 if (tls_type & GOT_TLS_GD)
2160 {
2161 if (need_relocs)
2162 {
2163 outrel.r_addend = 0;
2164 outrel.r_offset = (htab->root.sgot->output_section->vma
2165 + htab->root.sgot->output_offset
2166 + cur_off);
2167 outrel.r_info = ELF32_R_INFO (indx,
2168 R_NIOS2_TLS_DTPMOD);
2169
2170 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2171 loc);
2172 htab->root.srelgot->reloc_count++;
2173 loc += sizeof (Elf32_External_Rela);
2174
2175 if (indx == 0)
2176 bfd_put_32 (output_bfd,
2177 (relocation - dtpoff_base (info) -
2178 DTP_OFFSET),
2179 htab->root.sgot->contents + cur_off + 4);
2180 else
2181 {
2182 outrel.r_addend = 0;
2183 outrel.r_info = ELF32_R_INFO (indx,
2184 R_NIOS2_TLS_DTPREL);
2185 outrel.r_offset += 4;
2186
2187 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2188 loc);
2189 htab->root.srelgot->reloc_count++;
2190 loc += sizeof (Elf32_External_Rela);
2191 }
2192 }
2193 else
2194 {
2195 /* If we are not emitting relocations for a
2196 general dynamic reference, then we must be in a
2197 static link or an executable link with the
2198 symbol binding locally. Mark it as belonging
2199 to module 1, the executable. */
2200 bfd_put_32 (output_bfd, 1,
2201 htab->root.sgot->contents + cur_off);
2202 bfd_put_32 (output_bfd, (relocation -
2203 dtpoff_base (info) -
2204 DTP_OFFSET),
2205 htab->root.sgot->contents + cur_off + 4);
2206 }
2207
2208 cur_off += 8;
2209 }
2210
2211 if (tls_type & GOT_TLS_IE)
2212 {
2213 if (need_relocs)
2214 {
2215 if (indx == 0)
2216 outrel.r_addend = (relocation -
2217 dtpoff_base (info));
2218 else
2219 outrel.r_addend = 0;
2220 outrel.r_offset = (htab->root.sgot->output_section->vma
2221 + htab->root.sgot->output_offset
2222 + cur_off);
2223 outrel.r_info = ELF32_R_INFO (indx,
2224 R_NIOS2_TLS_TPREL);
2225
2226 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
2227 loc);
2228 htab->root.srelgot->reloc_count++;
2229 loc += sizeof (Elf32_External_Rela);
2230 }
2231 else
2232 bfd_put_32 (output_bfd, (tpoff (info, relocation)
2233 - TP_OFFSET),
2234 htab->root.sgot->contents + cur_off);
2235 cur_off += 4;
2236 }
2237
2238 if (h != NULL)
2239 h->got.offset |= 1;
2240 else
2241 local_got_offsets[r_symndx] |= 1;
2242 }
2243
2244 if ((tls_type & GOT_TLS_GD) && r_type != R_NIOS2_TLS_GD16)
2245 off += 8;
2246 relocation = (htab->root.sgot->output_offset + off);
2247
2248 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2249 contents, rel->r_offset,
2250 relocation, rel->r_addend);
2251 }
2252
2253 break;
2254 case R_NIOS2_TLS_LE16:
2255 if (info->shared && !info->pie)
2256 {
2257 (*_bfd_error_handler)
2258 (_("%B(%A+0x%lx): R_NIOS2_TLS_LE16 relocation not "
2259 "permitted in shared object"),
2260 input_bfd, input_section,
2261 (long) rel->r_offset, howto->name);
2262 return FALSE;
2263 }
2264 else
2265 relocation = tpoff (info, relocation) - TP_OFFSET;
2266
2267 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2268 contents, rel->r_offset,
2269 relocation, rel->r_addend);
2270 break;
2271
2272 case R_NIOS2_BFD_RELOC_32:
2273 if (info->shared
2274 && (input_section->flags & SEC_ALLOC) != 0
2275 && (h == NULL
2276 || ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2277 || h->root.type != bfd_link_hash_undefweak))
2278 {
2279 Elf_Internal_Rela outrel;
2280 bfd_byte *loc;
2281 bfd_boolean skip, relocate;
2282
2283 /* When generating a shared object, these relocations
2284 are copied into the output file to be resolved at run
2285 time. */
2286
2287 skip = FALSE;
2288 relocate = FALSE;
2289
2290 outrel.r_offset
2291 = _bfd_elf_section_offset (output_bfd, info,
2292 input_section, rel->r_offset);
2293 if (outrel.r_offset == (bfd_vma) -1)
2294 skip = TRUE;
2295 else if (outrel.r_offset == (bfd_vma) -2)
2296 skip = TRUE, relocate = TRUE;
2297 outrel.r_offset += (input_section->output_section->vma
2298 + input_section->output_offset);
2299
2300 if (skip)
2301 memset (&outrel, 0, sizeof outrel);
2302 else if (h != NULL
2303 && h->dynindx != -1
2304 && (!info->shared
2305 || !info->symbolic
2306 || !h->def_regular))
2307 {
2308 outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2309 outrel.r_addend = rel->r_addend;
2310 }
2311 else
2312 {
2313 /* This symbol is local, or marked to become local. */
2314 outrel.r_addend = relocation + rel->r_addend;
2315 relocate = TRUE;
2316 outrel.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
2317 }
2318
2319 sreloc = elf_section_data (input_section)->sreloc;
2320 if (sreloc == NULL)
2321 abort ();
2322
2323 loc = sreloc->contents;
2324 loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
2325 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
2326
2327 /* This reloc will be computed at runtime, so there's no
2328 need to do anything now, except for R_NIOS2_BFD_RELOC_32
2329 relocations that have been turned into
2330 R_NIOS2_RELATIVE. */
2331 if (!relocate)
2332 break;
2333 }
2334
2335 r = _bfd_final_link_relocate (howto, input_bfd,
2336 input_section, contents,
2337 rel->r_offset, relocation,
2338 rel->r_addend);
2339 break;
2340
2341 case R_NIOS2_TLS_DTPREL:
2342 relocation -= dtpoff_base (info);
2343 /* Fall through. */
2344
2345 default:
2346 r = _bfd_final_link_relocate (howto, input_bfd,
2347 input_section, contents,
2348 rel->r_offset, relocation,
2349 rel->r_addend);
2350 break;
2351 }
2352 }
2353 else
2354 r = bfd_reloc_notsupported;
2355
2356 if (r != bfd_reloc_ok)
2357 {
2358 if (h != NULL)
2359 name = h->root.root.string;
2360 else
2361 {
2362 name = bfd_elf_string_from_elf_section (input_bfd,
2363 symtab_hdr->sh_link,
2364 sym->st_name);
2365 if (name == NULL || *name == '\0')
2366 name = bfd_section_name (input_bfd, sec);
2367 }
2368
2369 switch (r)
2370 {
2371 case bfd_reloc_overflow:
2372 r = info->callbacks->reloc_overflow (info, NULL, name,
2373 howto->name, (bfd_vma) 0,
2374 input_bfd, input_section,
2375 rel->r_offset);
2376 break;
2377
2378 case bfd_reloc_undefined:
2379 r = info->callbacks->undefined_symbol (info, name, input_bfd,
2380 input_section,
2381 rel->r_offset, TRUE);
2382 break;
2383
2384 case bfd_reloc_outofrange:
2385 if (msg == NULL)
2386 msg = _("relocation out of range");
2387 break;
2388
2389 case bfd_reloc_notsupported:
2390 if (msg == NULL)
2391 msg = _("unsupported relocation");
2392 break;
2393
2394 case bfd_reloc_dangerous:
2395 if (msg == NULL)
2396 msg = _("dangerous relocation");
2397 break;
2398
2399 default:
2400 if (msg == NULL)
2401 msg = _("unknown error");
2402 break;
2403 }
2404
2405 if (msg)
2406 {
2407 r = info->callbacks->warning
2408 (info, msg, name, input_bfd, input_section, rel->r_offset);
2409 return FALSE;
2410 }
2411 }
2412 }
2413 return TRUE;
2414 }
2415
2416 /* Implement elf-backend_section_flags:
2417 Convert NIOS2 specific section flags to bfd internal section flags. */
2418 static bfd_boolean
2419 nios2_elf32_section_flags (flagword *flags, const Elf_Internal_Shdr *hdr)
2420 {
2421 if (hdr->sh_flags & SHF_NIOS2_GPREL)
2422 *flags |= SEC_SMALL_DATA;
2423
2424 return TRUE;
2425 }
2426
2427 /* Implement elf_backend_fake_sections:
2428 Set the correct type for an NIOS2 ELF section. We do this by the
2429 section name, which is a hack, but ought to work. */
2430 static bfd_boolean
2431 nios2_elf32_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2432 Elf_Internal_Shdr *hdr, asection *sec)
2433 {
2434 register const char *name = bfd_get_section_name (abfd, sec);
2435
2436 if ((sec->flags & SEC_SMALL_DATA)
2437 || strcmp (name, ".sdata") == 0
2438 || strcmp (name, ".sbss") == 0
2439 || strcmp (name, ".lit4") == 0 || strcmp (name, ".lit8") == 0)
2440 hdr->sh_flags |= SHF_NIOS2_GPREL;
2441
2442 return TRUE;
2443 }
2444
2445 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
2446 shortcuts to them in our hash table. */
2447 static bfd_boolean
2448 create_got_section (bfd *dynobj, struct bfd_link_info *info)
2449 {
2450 struct elf32_nios2_link_hash_table *htab;
2451
2452 htab = elf32_nios2_hash_table (info);
2453
2454 if (! _bfd_elf_create_got_section (dynobj, info))
2455 return FALSE;
2456
2457 /* In order for the two loads in .PLTresolve to share the same %hiadj,
2458 _GLOBAL_OFFSET_TABLE_ must be aligned to a 16-byte boundary. */
2459 if (!bfd_set_section_alignment (dynobj, htab->root.sgotplt, 4))
2460 return FALSE;
2461
2462 return TRUE;
2463 }
2464
2465 /* Implement elf_backend_create_dynamic_sections:
2466 Create .plt, .rela.plt, .got, .got.plt, .rela.got, .dynbss, and
2467 .rela.bss sections in DYNOBJ, and set up shortcuts to them in our
2468 hash table. */
2469 static bfd_boolean
2470 nios2_elf32_create_dynamic_sections (bfd *dynobj, struct bfd_link_info *info)
2471 {
2472 struct elf32_nios2_link_hash_table *htab;
2473
2474 htab = elf32_nios2_hash_table (info);
2475 if (!htab->root.sgot && !create_got_section (dynobj, info))
2476 return FALSE;
2477
2478 _bfd_elf_create_dynamic_sections (dynobj, info);
2479
2480 /* In order for the two loads in a shared object .PLTresolve to share the
2481 same %hiadj, the start of the PLT (as well as the GOT) must be aligned
2482 to a 16-byte boundary. This is because the addresses for these loads
2483 include the -(.plt+4) PIC correction. */
2484 if (!bfd_set_section_alignment (dynobj, htab->root.splt, 4))
2485 return FALSE;
2486
2487 htab->sdynbss = bfd_get_linker_section (dynobj, ".dynbss");
2488 if (!htab->sdynbss)
2489 return FALSE;
2490 if (!info->shared)
2491 {
2492 htab->srelbss = bfd_get_linker_section (dynobj, ".rela.bss");
2493 if (!htab->srelbss)
2494 return FALSE;
2495 }
2496
2497 return TRUE;
2498 }
2499
2500 /* Implement elf_backend_copy_indirect_symbol:
2501 Copy the extra info we tack onto an elf_link_hash_entry. */
2502 static void
2503 nios2_elf32_copy_indirect_symbol (struct bfd_link_info *info,
2504 struct elf_link_hash_entry *dir,
2505 struct elf_link_hash_entry *ind)
2506 {
2507 struct elf32_nios2_link_hash_entry *edir, *eind;
2508
2509 edir = (struct elf32_nios2_link_hash_entry *) dir;
2510 eind = (struct elf32_nios2_link_hash_entry *) ind;
2511
2512 if (eind->dyn_relocs != NULL)
2513 {
2514 if (edir->dyn_relocs != NULL)
2515 {
2516 struct elf32_nios2_dyn_relocs **pp;
2517 struct elf32_nios2_dyn_relocs *p;
2518
2519 /* Add reloc counts against the indirect sym to the direct sym
2520 list. Merge any entries against the same section. */
2521 for (pp = &eind->dyn_relocs; (p = *pp) != NULL; )
2522 {
2523 struct elf32_nios2_dyn_relocs *q;
2524
2525 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2526 if (q->sec == p->sec)
2527 {
2528 q->pc_count += p->pc_count;
2529 q->count += p->count;
2530 *pp = p->next;
2531 break;
2532 }
2533 if (q == NULL)
2534 pp = &p->next;
2535 }
2536 *pp = edir->dyn_relocs;
2537 }
2538
2539 edir->dyn_relocs = eind->dyn_relocs;
2540 eind->dyn_relocs = NULL;
2541 }
2542
2543 if (ind->root.type == bfd_link_hash_indirect
2544 && dir->got.refcount <= 0)
2545 {
2546 edir->tls_type = eind->tls_type;
2547 eind->tls_type = GOT_UNKNOWN;
2548 }
2549
2550 edir->got_types_used |= eind->got_types_used;
2551
2552 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2553 }
2554
2555 /* Implement elf_backend_check_relocs:
2556 Look through the relocs for a section during the first phase. */
2557 static bfd_boolean
2558 nios2_elf32_check_relocs (bfd *abfd, struct bfd_link_info *info,
2559 asection *sec, const Elf_Internal_Rela *relocs)
2560 {
2561 bfd *dynobj;
2562 Elf_Internal_Shdr *symtab_hdr;
2563 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
2564 const Elf_Internal_Rela *rel;
2565 const Elf_Internal_Rela *rel_end;
2566 struct elf32_nios2_link_hash_table *htab;
2567 asection *sgot;
2568 asection *srelgot;
2569 asection *sreloc = NULL;
2570 bfd_signed_vma *local_got_refcounts;
2571
2572 if (info->relocatable)
2573 return TRUE;
2574
2575 dynobj = elf_hash_table (info)->dynobj;
2576 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2577 sym_hashes = elf_sym_hashes (abfd);
2578 sym_hashes_end = (sym_hashes
2579 + symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2580 if (!elf_bad_symtab (abfd))
2581 sym_hashes_end -= symtab_hdr->sh_info;
2582 local_got_refcounts = elf_local_got_refcounts (abfd);
2583
2584 htab = elf32_nios2_hash_table (info);
2585 sgot = htab->root.sgot;
2586 srelgot = htab->root.srelgot;
2587
2588 rel_end = relocs + sec->reloc_count;
2589 for (rel = relocs; rel < rel_end; rel++)
2590 {
2591 unsigned int r_type;
2592 struct elf_link_hash_entry *h;
2593 unsigned long r_symndx;
2594
2595 r_symndx = ELF32_R_SYM (rel->r_info);
2596 if (r_symndx < symtab_hdr->sh_info)
2597 h = NULL;
2598 else
2599 {
2600 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2601 while (h->root.type == bfd_link_hash_indirect
2602 || h->root.type == bfd_link_hash_warning)
2603 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2604 }
2605
2606 r_type = ELF32_R_TYPE (rel->r_info);
2607
2608 switch (r_type)
2609 {
2610 case R_NIOS2_GOT16:
2611 case R_NIOS2_CALL16:
2612 case R_NIOS2_TLS_GD16:
2613 case R_NIOS2_TLS_IE16:
2614 /* This symbol requires a global offset table entry. */
2615 {
2616 int tls_type, old_tls_type;
2617
2618 switch (r_type)
2619 {
2620 default:
2621 case R_NIOS2_GOT16:
2622 case R_NIOS2_CALL16:
2623 tls_type = GOT_NORMAL;
2624 break;
2625 case R_NIOS2_TLS_GD16:
2626 tls_type = GOT_TLS_GD;
2627 break;
2628 case R_NIOS2_TLS_IE16:
2629 tls_type = GOT_TLS_IE;
2630 break;
2631 }
2632
2633 if (dynobj == NULL)
2634 {
2635 /* Create the .got section. */
2636 elf_hash_table (info)->dynobj = dynobj = abfd;
2637 nios2_elf32_create_dynamic_sections (dynobj, info);
2638 }
2639
2640 if (sgot == NULL)
2641 {
2642 sgot = htab->root.sgot;
2643 BFD_ASSERT (sgot != NULL);
2644 }
2645
2646 if (srelgot == NULL
2647 && (h != NULL || info->shared))
2648 {
2649 srelgot = htab->root.srelgot;
2650 BFD_ASSERT (srelgot != NULL);
2651 }
2652
2653 if (h != NULL)
2654 {
2655 struct elf32_nios2_link_hash_entry *eh
2656 = (struct elf32_nios2_link_hash_entry *)h;
2657 h->got.refcount++;
2658 old_tls_type = elf32_nios2_hash_entry(h)->tls_type;
2659 if (r_type == R_NIOS2_CALL16)
2660 {
2661 /* Make sure a plt entry is created for this symbol if
2662 it turns out to be a function defined by a dynamic
2663 object. */
2664 h->plt.refcount++;
2665 h->needs_plt = 1;
2666 h->type = STT_FUNC;
2667 eh->got_types_used |= CALL16_USED;
2668 }
2669 else
2670 eh->got_types_used |= GOT16_USED;
2671 }
2672 else
2673 {
2674 /* This is a global offset table entry for a local symbol. */
2675 if (local_got_refcounts == NULL)
2676 {
2677 bfd_size_type size;
2678
2679 size = symtab_hdr->sh_info;
2680 size *= (sizeof (bfd_signed_vma) + sizeof (char));
2681 local_got_refcounts
2682 = ((bfd_signed_vma *) bfd_zalloc (abfd, size));
2683 if (local_got_refcounts == NULL)
2684 return FALSE;
2685 elf_local_got_refcounts (abfd) = local_got_refcounts;
2686 elf32_nios2_local_got_tls_type (abfd)
2687 = (char *) (local_got_refcounts + symtab_hdr->sh_info);
2688 }
2689 local_got_refcounts[r_symndx]++;
2690 old_tls_type = elf32_nios2_local_got_tls_type (abfd) [r_symndx];
2691 }
2692
2693 /* We will already have issued an error message if there is a
2694 TLS / non-TLS mismatch, based on the symbol type. We don't
2695 support any linker relaxations. So just combine any TLS
2696 types needed. */
2697 if (old_tls_type != GOT_UNKNOWN && old_tls_type != GOT_NORMAL
2698 && tls_type != GOT_NORMAL)
2699 tls_type |= old_tls_type;
2700
2701 if (old_tls_type != tls_type)
2702 {
2703 if (h != NULL)
2704 elf32_nios2_hash_entry (h)->tls_type = tls_type;
2705 else
2706 elf32_nios2_local_got_tls_type (abfd) [r_symndx] = tls_type;
2707 }
2708 }
2709 /* Fall through */
2710 case R_NIOS2_TLS_LDM16:
2711 if (r_type == R_NIOS2_TLS_LDM16)
2712 htab->tls_ldm_got.refcount++;
2713
2714 if (htab->root.sgot == NULL)
2715 {
2716 if (htab->root.dynobj == NULL)
2717 htab->root.dynobj = abfd;
2718 if (!create_got_section (htab->root.dynobj, info))
2719 return FALSE;
2720 }
2721 break;
2722
2723 /* This relocation describes the C++ object vtable hierarchy.
2724 Reconstruct it for later use during GC. */
2725 case R_NIOS2_GNU_VTINHERIT:
2726 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
2727 return FALSE;
2728 break;
2729
2730 /* This relocation describes which C++ vtable entries are actually
2731 used. Record for later use during GC. */
2732 case R_NIOS2_GNU_VTENTRY:
2733 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
2734 return FALSE;
2735 break;
2736
2737 case R_NIOS2_BFD_RELOC_32:
2738 case R_NIOS2_CALL26:
2739 case R_NIOS2_HIADJ16:
2740 case R_NIOS2_LO16:
2741
2742 if (h != NULL)
2743 {
2744 /* If this reloc is in a read-only section, we might
2745 need a copy reloc. We can't check reliably at this
2746 stage whether the section is read-only, as input
2747 sections have not yet been mapped to output sections.
2748 Tentatively set the flag for now, and correct in
2749 adjust_dynamic_symbol. */
2750 if (!info->shared)
2751 h->non_got_ref = 1;
2752
2753 /* Make sure a plt entry is created for this symbol if it
2754 turns out to be a function defined by a dynamic object. */
2755 h->plt.refcount++;
2756
2757 if (r_type == R_NIOS2_CALL26)
2758 h->needs_plt = 1;
2759 }
2760
2761 /* If we are creating a shared library, we need to copy the
2762 reloc into the shared library. */
2763 if (info->shared
2764 && (sec->flags & SEC_ALLOC) != 0
2765 && (r_type == R_NIOS2_BFD_RELOC_32
2766 || (h != NULL && ! h->needs_plt
2767 && (! info->symbolic || ! h->def_regular))))
2768 {
2769 struct elf32_nios2_dyn_relocs *p;
2770 struct elf32_nios2_dyn_relocs **head;
2771
2772 /* When creating a shared object, we must copy these
2773 reloc types into the output file. We create a reloc
2774 section in dynobj and make room for this reloc. */
2775 if (sreloc == NULL)
2776 {
2777 sreloc = _bfd_elf_make_dynamic_reloc_section
2778 (sec, dynobj, 2, abfd, TRUE);
2779 if (sreloc == NULL)
2780 return FALSE;
2781 }
2782
2783 /* If this is a global symbol, we count the number of
2784 relocations we need for this symbol. */
2785 if (h != NULL)
2786 head = &((struct elf32_nios2_link_hash_entry *) h)->dyn_relocs;
2787 else
2788 {
2789 /* Track dynamic relocs needed for local syms too.
2790 We really need local syms available to do this
2791 easily. Oh well. */
2792
2793 asection *s;
2794 void *vpp;
2795 Elf_Internal_Sym *isym;
2796
2797 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2798 abfd, r_symndx);
2799 if (isym == NULL)
2800 return FALSE;
2801
2802 s = bfd_section_from_elf_index (abfd, isym->st_shndx);
2803 if (s == NULL)
2804 s = sec;
2805
2806 vpp = &elf_section_data (s)->local_dynrel;
2807 head = (struct elf32_nios2_dyn_relocs **) vpp;
2808 }
2809
2810 p = *head;
2811 if (p == NULL || p->sec != sec)
2812 {
2813 bfd_size_type amt = sizeof *p;
2814 p = ((struct elf32_nios2_dyn_relocs *)
2815 bfd_alloc (htab->root.dynobj, amt));
2816 if (p == NULL)
2817 return FALSE;
2818 p->next = *head;
2819 *head = p;
2820 p->sec = sec;
2821 p->count = 0;
2822 p->pc_count = 0;
2823 }
2824
2825 p->count += 1;
2826
2827 }
2828 break;
2829 }
2830 }
2831
2832 return TRUE;
2833 }
2834
2835
2836 /* Implement elf_backend_gc_mark_hook:
2837 Return the section that should be marked against GC for a given
2838 relocation. */
2839 static asection *
2840 nios2_elf32_gc_mark_hook (asection *sec,
2841 struct bfd_link_info *info ATTRIBUTE_UNUSED,
2842 Elf_Internal_Rela *rel,
2843 struct elf_link_hash_entry *h,
2844 Elf_Internal_Sym *sym)
2845 {
2846 if (h != NULL)
2847 switch (ELF32_R_TYPE (rel->r_info))
2848 {
2849 case R_NIOS2_GNU_VTINHERIT:
2850 case R_NIOS2_GNU_VTENTRY:
2851 return NULL;
2852 }
2853 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2854 }
2855
2856 /* Implement elf_backend_gc_sweep_hook:
2857 Update the got entry reference counts for the section being removed. */
2858 static bfd_boolean
2859 nios2_elf32_gc_sweep_hook (bfd *abfd,
2860 struct bfd_link_info *info,
2861 asection *sec,
2862 const Elf_Internal_Rela *relocs)
2863 {
2864 Elf_Internal_Shdr *symtab_hdr;
2865 struct elf_link_hash_entry **sym_hashes;
2866 bfd_signed_vma *local_got_refcounts;
2867 const Elf_Internal_Rela *rel, *relend;
2868 bfd *dynobj;
2869
2870 if (info->relocatable)
2871 return TRUE;
2872
2873 elf_section_data (sec)->local_dynrel = NULL;
2874
2875 dynobj = elf_hash_table (info)->dynobj;
2876 if (dynobj == NULL)
2877 return TRUE;
2878
2879 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2880 sym_hashes = elf_sym_hashes (abfd);
2881 local_got_refcounts = elf_local_got_refcounts (abfd);
2882
2883 relend = relocs + sec->reloc_count;
2884 for (rel = relocs; rel < relend; rel++)
2885 {
2886 unsigned long r_symndx;
2887 struct elf_link_hash_entry *h = NULL;
2888 int r_type;
2889
2890 r_symndx = ELF32_R_SYM (rel->r_info);
2891 if (r_symndx >= symtab_hdr->sh_info)
2892 {
2893 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2894 while (h->root.type == bfd_link_hash_indirect
2895 || h->root.type == bfd_link_hash_warning)
2896 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2897 }
2898
2899 r_type = ELF32_R_TYPE (rel->r_info);
2900 switch (r_type)
2901 {
2902 case R_NIOS2_GOT16:
2903 case R_NIOS2_CALL16:
2904 if (h != NULL)
2905 {
2906 if (h->got.refcount > 0)
2907 --h->got.refcount;
2908 }
2909 else if (local_got_refcounts != NULL)
2910 {
2911 if (local_got_refcounts[r_symndx] > 0)
2912 --local_got_refcounts[r_symndx];
2913 }
2914 break;
2915
2916 case R_NIOS2_PCREL_LO:
2917 case R_NIOS2_PCREL_HA:
2918 case R_NIOS2_BFD_RELOC_32:
2919 case R_NIOS2_CALL26:
2920 if (h != NULL)
2921 {
2922 struct elf32_nios2_link_hash_entry *eh;
2923 struct elf32_nios2_dyn_relocs **pp;
2924 struct elf32_nios2_dyn_relocs *p;
2925
2926 eh = (struct elf32_nios2_link_hash_entry *) h;
2927
2928 if (h->plt.refcount > 0)
2929 --h->plt.refcount;
2930
2931 if (r_type == R_NIOS2_PCREL_LO || r_type == R_NIOS2_PCREL_HA
2932 || r_type == R_NIOS2_BFD_RELOC_32)
2933 {
2934 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;
2935 pp = &p->next)
2936 if (p->sec == sec)
2937 {
2938 p->count -= 1;
2939 if (p->count == 0)
2940 *pp = p->next;
2941 break;
2942 }
2943 }
2944 }
2945 break;
2946
2947 default:
2948 break;
2949 }
2950 }
2951
2952 return TRUE;
2953 }
2954
2955 /* Install 16-bit immediate value VALUE at offset OFFSET into section SEC. */
2956 static void
2957 nios2_elf32_install_imm16 (asection *sec, bfd_vma offset, bfd_vma value)
2958 {
2959 bfd_vma word = bfd_get_32 (sec->owner, sec->contents + offset);
2960
2961 BFD_ASSERT(value <= 0xffff);
2962
2963 bfd_put_32 (sec->owner, word | ((value & 0xffff) << 6),
2964 sec->contents + offset);
2965 }
2966
2967 /* Install COUNT 32-bit values DATA starting at offset OFFSET into
2968 section SEC. */
2969 static void
2970 nios2_elf32_install_data (asection *sec, const bfd_vma *data, bfd_vma offset,
2971 int count)
2972 {
2973 while (count--)
2974 {
2975 bfd_put_32 (sec->owner, *data, sec->contents + offset);
2976 offset += 4;
2977 ++data;
2978 }
2979 }
2980
2981 /* Implement elf_backend_finish_dynamic_symbols:
2982 Finish up dynamic symbol handling. We set the contents of various
2983 dynamic sections here. */
2984 static bfd_boolean
2985 nios2_elf32_finish_dynamic_symbol (bfd *output_bfd,
2986 struct bfd_link_info *info,
2987 struct elf_link_hash_entry *h,
2988 Elf_Internal_Sym *sym)
2989 {
2990 struct elf32_nios2_link_hash_table *htab;
2991 struct elf32_nios2_link_hash_entry *eh
2992 = (struct elf32_nios2_link_hash_entry *)h;
2993 int use_plt;
2994
2995 htab = elf32_nios2_hash_table (info);
2996
2997 if (h->plt.offset != (bfd_vma) -1)
2998 {
2999 asection *splt;
3000 asection *sgotplt;
3001 asection *srela;
3002 bfd_vma plt_index;
3003 bfd_vma got_offset;
3004 Elf_Internal_Rela rela;
3005 bfd_byte *loc;
3006 bfd_vma got_address;
3007
3008 /* This symbol has an entry in the procedure linkage table. Set
3009 it up. */
3010 BFD_ASSERT (h->dynindx != -1);
3011 splt = htab->root.splt;
3012 sgotplt = htab->root.sgotplt;
3013 srela = htab->root.srelplt;
3014 BFD_ASSERT (splt != NULL && sgotplt != NULL && srela != NULL);
3015
3016 /* Emit the PLT entry. */
3017 if (info->shared)
3018 {
3019 nios2_elf32_install_data (splt, nios2_so_plt_entry, h->plt.offset,
3020 3);
3021 plt_index = (h->plt.offset - 24) / 12;
3022 got_offset = (plt_index + 3) * 4;
3023 nios2_elf32_install_imm16 (splt, h->plt.offset,
3024 hiadj(plt_index * 4));
3025 nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
3026 (plt_index * 4) & 0xffff);
3027 nios2_elf32_install_imm16 (splt, h->plt.offset + 8,
3028 0xfff4 - h->plt.offset);
3029 got_address = (sgotplt->output_section->vma + sgotplt->output_offset
3030 + got_offset);
3031
3032 /* Fill in the entry in the global offset table. There are no
3033 res_n slots for a shared object PLT, instead the .got.plt entries
3034 point to the PLT entries. */
3035 bfd_put_32 (output_bfd,
3036 splt->output_section->vma + splt->output_offset
3037 + h->plt.offset, sgotplt->contents + got_offset);
3038 }
3039 else
3040 {
3041 plt_index = (h->plt.offset - 28 - htab->res_n_size) / 12;
3042 got_offset = (plt_index + 3) * 4;
3043
3044 nios2_elf32_install_data (splt, nios2_plt_entry, h->plt.offset, 3);
3045 got_address = (sgotplt->output_section->vma + sgotplt->output_offset
3046 + got_offset);
3047 nios2_elf32_install_imm16 (splt, h->plt.offset, hiadj(got_address));
3048 nios2_elf32_install_imm16 (splt, h->plt.offset + 4,
3049 got_address & 0xffff);
3050
3051 /* Fill in the entry in the global offset table. */
3052 bfd_put_32 (output_bfd,
3053 splt->output_section->vma + splt->output_offset
3054 + plt_index * 4, sgotplt->contents + got_offset);
3055 }
3056
3057 /* Fill in the entry in the .rela.plt section. */
3058 rela.r_offset = got_address;
3059 rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_JUMP_SLOT);
3060 rela.r_addend = 0;
3061 loc = srela->contents + plt_index * sizeof (Elf32_External_Rela);
3062 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3063
3064 if (!h->def_regular)
3065 {
3066 /* Mark the symbol as undefined, rather than as defined in
3067 the .plt section. Leave the value alone. */
3068 sym->st_shndx = SHN_UNDEF;
3069 /* If the symbol is weak, we do need to clear the value.
3070 Otherwise, the PLT entry would provide a definition for
3071 the symbol even if the symbol wasn't defined anywhere,
3072 and so the symbol would never be NULL. */
3073 if (!h->ref_regular_nonweak)
3074 sym->st_value = 0;
3075 }
3076 }
3077
3078 use_plt = (eh->got_types_used == CALL16_USED
3079 && h->plt.offset != (bfd_vma) -1);
3080
3081 if (!use_plt && h->got.offset != (bfd_vma) -1
3082 && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_GD) == 0
3083 && (elf32_nios2_hash_entry (h)->tls_type & GOT_TLS_IE) == 0)
3084 {
3085 asection *sgot;
3086 asection *srela;
3087 Elf_Internal_Rela rela;
3088 bfd_byte *loc;
3089 bfd_vma offset;
3090
3091 /* This symbol has an entry in the global offset table. Set it
3092 up. */
3093 sgot = htab->root.sgot;
3094 srela = htab->root.srelgot;
3095 BFD_ASSERT (sgot != NULL && srela != NULL);
3096
3097 offset = (h->got.offset & ~(bfd_vma) 1);
3098 rela.r_offset = (sgot->output_section->vma
3099 + sgot->output_offset + offset);
3100
3101 /* If this is a -Bsymbolic link, and the symbol is defined
3102 locally, we just want to emit a RELATIVE reloc. Likewise if
3103 the symbol was forced to be local because of a version file.
3104 The entry in the global offset table will already have been
3105 initialized in the relocate_section function. */
3106
3107 if (info->shared && SYMBOL_REFERENCES_LOCAL (info, h))
3108 {
3109 rela.r_info = ELF32_R_INFO (0, R_NIOS2_RELATIVE);
3110 rela.r_addend = bfd_get_signed_32 (output_bfd,
3111 (sgot->contents + offset));
3112 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + offset);
3113 }
3114 else
3115 {
3116 bfd_put_32 (output_bfd, (bfd_vma) 0,
3117 sgot->contents + offset);
3118 rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_GLOB_DAT);
3119 rela.r_addend = 0;
3120 }
3121
3122 loc = srela->contents;
3123 loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
3124 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3125 }
3126
3127 if (use_plt && h->got.offset != (bfd_vma) -1)
3128 {
3129 bfd_vma offset = (h->got.offset & ~(bfd_vma) 1);
3130 asection *sgot = htab->root.sgot;
3131 asection *splt = htab->root.splt;
3132 bfd_put_32 (output_bfd, (splt->output_section->vma + splt->output_offset
3133 + h->plt.offset),
3134 sgot->contents + offset);
3135 }
3136
3137 if (h->needs_copy)
3138 {
3139 asection *s;
3140 Elf_Internal_Rela rela;
3141 bfd_byte *loc;
3142
3143 /* This symbol needs a copy reloc. Set it up. */
3144 BFD_ASSERT (h->dynindx != -1
3145 && (h->root.type == bfd_link_hash_defined
3146 || h->root.type == bfd_link_hash_defweak));
3147
3148 s = htab->srelbss;
3149 BFD_ASSERT (s != NULL);
3150
3151 rela.r_offset = (h->root.u.def.value
3152 + h->root.u.def.section->output_section->vma
3153 + h->root.u.def.section->output_offset);
3154 rela.r_info = ELF32_R_INFO (h->dynindx, R_NIOS2_COPY);
3155 rela.r_addend = 0;
3156 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3157 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3158 }
3159
3160 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3161 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3162 || h == elf_hash_table (info)->hgot)
3163 sym->st_shndx = SHN_ABS;
3164
3165 return TRUE;
3166 }
3167
3168 /* Implement elf_backend_finish_dynamic_sections. */
3169 static bfd_boolean
3170 nios2_elf32_finish_dynamic_sections (bfd *output_bfd,
3171 struct bfd_link_info *info)
3172 {
3173 bfd *dynobj;
3174 asection *sgotplt;
3175 asection *sdyn;
3176 struct elf32_nios2_link_hash_table *htab;
3177
3178 htab = elf32_nios2_hash_table (info);
3179 dynobj = elf_hash_table (info)->dynobj;
3180 sgotplt = htab->root.sgotplt;
3181 BFD_ASSERT (sgotplt != NULL);
3182 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3183
3184 if (elf_hash_table (info)->dynamic_sections_created)
3185 {
3186 asection *splt;
3187 Elf32_External_Dyn *dyncon, *dynconend;
3188
3189 splt = htab->root.splt;
3190 BFD_ASSERT (splt != NULL && sdyn != NULL);
3191
3192 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3193 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3194 for (; dyncon < dynconend; dyncon++)
3195 {
3196 Elf_Internal_Dyn dyn;
3197 asection *s;
3198
3199 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3200
3201 switch (dyn.d_tag)
3202 {
3203 default:
3204 break;
3205
3206 case DT_PLTGOT:
3207 s = htab->root.sgot;
3208 BFD_ASSERT (s != NULL);
3209 dyn.d_un.d_ptr = s->output_section->vma;
3210 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3211 break;
3212
3213 case DT_JMPREL:
3214 s = htab->root.srelplt;
3215 BFD_ASSERT (s != NULL);
3216 dyn.d_un.d_ptr = s->output_section->vma;
3217 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3218 break;
3219
3220 case DT_PLTRELSZ:
3221 s = htab->root.srelplt;
3222 BFD_ASSERT (s != NULL);
3223 dyn.d_un.d_val = s->size;
3224 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3225 break;
3226
3227 case DT_RELASZ:
3228 /* The procedure linkage table relocs (DT_JMPREL) should
3229 not be included in the overall relocs (DT_RELA).
3230 Therefore, we override the DT_RELASZ entry here to
3231 make it not include the JMPREL relocs. Since the
3232 linker script arranges for .rela.plt to follow all
3233 other relocation sections, we don't have to worry
3234 about changing the DT_RELA entry. */
3235 s = htab->root.srelplt;
3236 if (s != NULL)
3237 dyn.d_un.d_val -= s->size;
3238 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3239 break;
3240
3241 case DT_NIOS2_GP:
3242 s = htab->root.sgot;
3243 BFD_ASSERT (s != NULL);
3244 dyn.d_un.d_ptr = s->output_section->vma + 0x7ff0;
3245 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3246 break;
3247 }
3248 }
3249
3250 /* Fill in the first entry in the procedure linkage table. */
3251 if (splt->size > 0)
3252 {
3253 bfd_vma got_address = (sgotplt->output_section->vma
3254 + sgotplt->output_offset);
3255 if (info->shared)
3256 {
3257 bfd_vma corrected = got_address - (splt->output_section->vma
3258 + splt->output_offset + 4);
3259 nios2_elf32_install_data (splt, nios2_so_plt0_entry, 0, 6);
3260 nios2_elf32_install_imm16 (splt, 4, hiadj (corrected));
3261 nios2_elf32_install_imm16 (splt, 12, (corrected & 0xffff) + 4);
3262 nios2_elf32_install_imm16 (splt, 16, (corrected & 0xffff) + 8);
3263
3264 elf_section_data (splt->output_section)->this_hdr.sh_entsize
3265 = 24;
3266 }
3267 else
3268 {
3269 /* Divide by 4 here, not 3 because we already corrected for the
3270 res_N branches. */
3271 bfd_vma res_size = (splt->size - 28) / 4;
3272 bfd_vma res_start = (splt->output_section->vma
3273 + splt->output_offset);
3274 bfd_vma res_offset;
3275
3276 for (res_offset = 0; res_offset < res_size; res_offset += 4)
3277 bfd_put_32 (output_bfd,
3278 6 | ((res_size - (res_offset + 4)) << 6),
3279 splt->contents + res_offset);
3280
3281 nios2_elf32_install_data (splt, nios2_plt0_entry, res_size, 7);
3282 nios2_elf32_install_imm16 (splt, res_size, hiadj (res_start));
3283 nios2_elf32_install_imm16 (splt, res_size + 4,
3284 res_start & 0xffff);
3285 nios2_elf32_install_imm16 (splt, res_size + 12,
3286 hiadj (got_address));
3287 nios2_elf32_install_imm16 (splt, res_size + 16,
3288 (got_address & 0xffff) + 4);
3289 nios2_elf32_install_imm16 (splt, res_size + 20,
3290 (got_address & 0xffff) + 8);
3291
3292 elf_section_data (splt->output_section)->this_hdr.sh_entsize
3293 = 28 + res_size;
3294 }
3295 }
3296 }
3297 /* Fill in the first three entries in the global offset table. */
3298 if (sgotplt->size > 0)
3299 {
3300 if (sdyn == NULL)
3301 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents);
3302 else
3303 bfd_put_32 (output_bfd,
3304 sdyn->output_section->vma + sdyn->output_offset,
3305 sgotplt->contents);
3306 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 4);
3307 bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 8);
3308 }
3309
3310 elf_section_data (sgotplt->output_section)->this_hdr.sh_entsize = 4;
3311
3312 return TRUE;
3313 }
3314
3315 /* Implement elf_backend_adjust_dynamic_symbol:
3316 Adjust a symbol defined by a dynamic object and referenced by a
3317 regular object. The current definition is in some section of the
3318 dynamic object, but we're not including those sections. We have to
3319 change the definition to something the rest of the link can
3320 understand. */
3321 static bfd_boolean
3322 nios2_elf32_adjust_dynamic_symbol (struct bfd_link_info *info,
3323 struct elf_link_hash_entry *h)
3324 {
3325 struct elf32_nios2_link_hash_table *htab;
3326 bfd *dynobj;
3327 asection *s;
3328 unsigned align2;
3329
3330 htab = elf32_nios2_hash_table (info);
3331 dynobj = elf_hash_table (info)->dynobj;
3332
3333 /* Make sure we know what is going on here. */
3334 BFD_ASSERT (dynobj != NULL
3335 && (h->needs_plt
3336 || h->u.weakdef != NULL
3337 || (h->def_dynamic
3338 && h->ref_regular
3339 && !h->def_regular)));
3340
3341 /* If this is a function, put it in the procedure linkage table. We
3342 will fill in the contents of the procedure linkage table later,
3343 when we know the address of the .got section. */
3344 if (h->type == STT_FUNC || h->needs_plt)
3345 {
3346 if (h->plt.refcount <= 0
3347 || SYMBOL_CALLS_LOCAL (info, h)
3348 || (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
3349 && h->root.type == bfd_link_hash_undefweak))
3350 {
3351 /* This case can occur if we saw a PLT reloc in an input
3352 file, but the symbol was never referred to by a dynamic
3353 object, or if all references were garbage collected. In
3354 such a case, we don't actually need to build a procedure
3355 linkage table, and we can just do a PCREL reloc instead. */
3356 h->plt.offset = (bfd_vma) -1;
3357 h->needs_plt = 0;
3358 }
3359
3360 return TRUE;
3361 }
3362
3363 /* Reinitialize the plt offset now that it is not used as a reference
3364 count any more. */
3365 h->plt.offset = (bfd_vma) -1;
3366
3367 /* If this is a weak symbol, and there is a real definition, the
3368 processor independent code will have arranged for us to see the
3369 real definition first, and we can just use the same value. */
3370 if (h->u.weakdef != NULL)
3371 {
3372 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
3373 || h->u.weakdef->root.type == bfd_link_hash_defweak);
3374 h->root.u.def.section = h->u.weakdef->root.u.def.section;
3375 h->root.u.def.value = h->u.weakdef->root.u.def.value;
3376 return TRUE;
3377 }
3378
3379 /* If there are no non-GOT references, we do not need a copy
3380 relocation. */
3381 if (!h->non_got_ref)
3382 return TRUE;
3383
3384 /* This is a reference to a symbol defined by a dynamic object which
3385 is not a function.
3386 If we are creating a shared library, we must presume that the
3387 only references to the symbol are via the global offset table.
3388 For such cases we need not do anything here; the relocations will
3389 be handled correctly by relocate_section. */
3390 if (info->shared)
3391 return TRUE;
3392
3393 if (h->size == 0)
3394 {
3395 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
3396 h->root.root.string);
3397 return TRUE;
3398 }
3399
3400 /* We must allocate the symbol in our .dynbss section, which will
3401 become part of the .bss section of the executable. There will be
3402 an entry for this symbol in the .dynsym section. The dynamic
3403 object will contain position independent code, so all references
3404 from the dynamic object to this symbol will go through the global
3405 offset table. The dynamic linker will use the .dynsym entry to
3406 determine the address it must put in the global offset table, so
3407 both the dynamic object and the regular object will refer to the
3408 same memory location for the variable. */
3409 s = htab->sdynbss;
3410 BFD_ASSERT (s != NULL);
3411
3412 /* We must generate a R_NIOS2_COPY reloc to tell the dynamic linker to
3413 copy the initial value out of the dynamic object and into the
3414 runtime process image. We need to remember the offset into the
3415 .rela.bss section we are going to use. */
3416 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3417 {
3418 asection *srel;
3419
3420 srel = htab->srelbss;
3421 BFD_ASSERT (srel != NULL);
3422 srel->size += sizeof (Elf32_External_Rela);
3423 h->needs_copy = 1;
3424 }
3425
3426 align2 = bfd_log2 (h->size);
3427 if (align2 > h->root.u.def.section->alignment_power)
3428 align2 = h->root.u.def.section->alignment_power;
3429
3430 /* Align dynbss. */
3431 s->size = BFD_ALIGN (s->size, (bfd_size_type)1 << align2);
3432 if (align2 > bfd_get_section_alignment (dynobj, s)
3433 && !bfd_set_section_alignment (dynobj, s, align2))
3434 return FALSE;
3435
3436 /* Define the symbol as being at this point in the section. */
3437 h->root.u.def.section = s;
3438 h->root.u.def.value = s->size;
3439
3440 /* Increment the section size to make room for the symbol. */
3441 s->size += h->size;
3442
3443 return TRUE;
3444 }
3445
3446 /* Worker function for nios2_elf32_size_dynamic_sections. */
3447 static bfd_boolean
3448 adjust_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
3449 {
3450 struct bfd_link_info *info;
3451 struct elf32_nios2_link_hash_table *htab;
3452
3453 if (h->root.type == bfd_link_hash_indirect)
3454 return TRUE;
3455
3456 if (h->root.type == bfd_link_hash_warning)
3457 /* When warning symbols are created, they **replace** the "real"
3458 entry in the hash table, thus we never get to see the real
3459 symbol in a hash traversal. So look at it now. */
3460 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3461
3462 info = (struct bfd_link_info *) inf;
3463 htab = elf32_nios2_hash_table (info);
3464
3465 if (h->plt.offset != (bfd_vma)-1)
3466 h->plt.offset += htab->res_n_size;
3467 if (htab->root.splt == h->root.u.def.section)
3468 h->root.u.def.value += htab->res_n_size;
3469
3470 return TRUE;
3471 }
3472
3473 /* Another worker function for nios2_elf32_size_dynamic_sections.
3474 Allocate space in .plt, .got and associated reloc sections for
3475 dynamic relocs. */
3476 static bfd_boolean
3477 allocate_dynrelocs (struct elf_link_hash_entry *h, PTR inf)
3478 {
3479 struct bfd_link_info *info;
3480 struct elf32_nios2_link_hash_table *htab;
3481 struct elf32_nios2_link_hash_entry *eh;
3482 struct elf32_nios2_dyn_relocs *p;
3483 int use_plt;
3484
3485 if (h->root.type == bfd_link_hash_indirect)
3486 return TRUE;
3487
3488 if (h->root.type == bfd_link_hash_warning)
3489 /* When warning symbols are created, they **replace** the "real"
3490 entry in the hash table, thus we never get to see the real
3491 symbol in a hash traversal. So look at it now. */
3492 h = (struct elf_link_hash_entry *) h->root.u.i.link;
3493
3494 info = (struct bfd_link_info *) inf;
3495 htab = elf32_nios2_hash_table (info);
3496
3497 if (htab->root.dynamic_sections_created
3498 && h->plt.refcount > 0)
3499 {
3500 /* Make sure this symbol is output as a dynamic symbol.
3501 Undefined weak syms won't yet be marked as dynamic. */
3502 if (h->dynindx == -1
3503 && !h->forced_local
3504 && !bfd_elf_link_record_dynamic_symbol (info, h))
3505 return FALSE;
3506
3507 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
3508 {
3509 asection *s = htab->root.splt;
3510
3511 /* Allocate room for the header. */
3512 if (s->size == 0)
3513 {
3514 if (info->shared)
3515 s->size = 24;
3516 else
3517 s->size = 28;
3518 }
3519
3520 h->plt.offset = s->size;
3521
3522 /* If this symbol is not defined in a regular file, and we are
3523 not generating a shared library, then set the symbol to this
3524 location in the .plt. This is required to make function
3525 pointers compare as equal between the normal executable and
3526 the shared library. */
3527 if (! info->shared
3528 && !h->def_regular)
3529 {
3530 h->root.u.def.section = s;
3531 h->root.u.def.value = h->plt.offset;
3532 }
3533
3534 /* Make room for this entry. */
3535 s->size += 12;
3536
3537 /* We also need to make an entry in the .rela.plt section. */
3538 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
3539
3540 /* And the .got.plt section. */
3541 htab->root.sgotplt->size += 4;
3542 }
3543 else
3544 {
3545 h->plt.offset = (bfd_vma) -1;
3546 h->needs_plt = 0;
3547 }
3548 }
3549 else
3550 {
3551 h->plt.offset = (bfd_vma) -1;
3552 h->needs_plt = 0;
3553 }
3554
3555 eh = (struct elf32_nios2_link_hash_entry *) h;
3556 use_plt = (eh->got_types_used == CALL16_USED
3557 && h->plt.offset != (bfd_vma) -1);
3558
3559 if (h->got.refcount > 0)
3560 {
3561 asection *s;
3562 bfd_boolean dyn;
3563 int tls_type = eh->tls_type;
3564 int indx;
3565
3566 /* Make sure this symbol is output as a dynamic symbol.
3567 Undefined weak syms won't yet be marked as dynamic. */
3568 if (h->dynindx == -1
3569 && !h->forced_local
3570 && !bfd_elf_link_record_dynamic_symbol (info, h))
3571 return FALSE;
3572
3573 s = htab->root.sgot;
3574 h->got.offset = s->size;
3575
3576 if (tls_type == GOT_UNKNOWN)
3577 abort ();
3578
3579 if (tls_type == GOT_NORMAL)
3580 /* Non-TLS symbols need one GOT slot. */
3581 s->size += 4;
3582 else
3583 {
3584 if (tls_type & GOT_TLS_GD)
3585 /* R_NIOS2_TLS_GD16 needs 2 consecutive GOT slots. */
3586 s->size += 8;
3587 if (tls_type & GOT_TLS_IE)
3588 /* R_NIOS2_TLS_IE16 needs one GOT slot. */
3589 s->size += 4;
3590 }
3591
3592 dyn = htab->root.dynamic_sections_created;
3593
3594 indx = 0;
3595 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
3596 && (!info->shared
3597 || !SYMBOL_REFERENCES_LOCAL (info, h)))
3598 indx = h->dynindx;
3599
3600 if (tls_type != GOT_NORMAL
3601 && (info->shared || indx != 0)
3602 && (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3603 || h->root.type != bfd_link_hash_undefweak))
3604 {
3605 if (tls_type & GOT_TLS_IE)
3606 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3607
3608 if (tls_type & GOT_TLS_GD)
3609 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3610
3611 if ((tls_type & GOT_TLS_GD) && indx != 0)
3612 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3613 }
3614 else if ((ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
3615 || h->root.type != bfd_link_hash_undefweak)
3616 && !use_plt
3617 && (info->shared
3618 || WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, 0, h)))
3619 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3620 }
3621 else
3622 h->got.offset = (bfd_vma) -1;
3623
3624 if (eh->dyn_relocs == NULL)
3625 return TRUE;
3626
3627 /* In the shared -Bsymbolic case, discard space allocated for
3628 dynamic pc-relative relocs against symbols which turn out to be
3629 defined in regular objects. For the normal shared case, discard
3630 space for pc-relative relocs that have become local due to symbol
3631 visibility changes. */
3632
3633 if (info->shared)
3634 {
3635 if (h->def_regular
3636 && (h->forced_local || info->symbolic))
3637 {
3638 struct elf32_nios2_dyn_relocs **pp;
3639
3640 for (pp = &eh->dyn_relocs; (p = *pp) != NULL; )
3641 {
3642 p->count -= p->pc_count;
3643 p->pc_count = 0;
3644 if (p->count == 0)
3645 *pp = p->next;
3646 else
3647 pp = &p->next;
3648 }
3649 }
3650
3651 /* Also discard relocs on undefined weak syms with non-default
3652 visibility. */
3653 if (eh->dyn_relocs != NULL
3654 && h->root.type == bfd_link_hash_undefweak)
3655 {
3656 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3657 eh->dyn_relocs = NULL;
3658
3659 /* Make sure undefined weak symbols are output as a dynamic
3660 symbol in PIEs. */
3661 else if (h->dynindx == -1
3662 && !h->forced_local
3663 && !bfd_elf_link_record_dynamic_symbol (info, h))
3664 return FALSE;
3665 }
3666 }
3667 else
3668 {
3669 /* For the non-shared case, discard space for relocs against
3670 symbols which turn out to need copy relocs or are not
3671 dynamic. */
3672
3673 if (!h->non_got_ref
3674 && ((h->def_dynamic && !h->def_regular)
3675 || (htab->root.dynamic_sections_created
3676 && (h->root.type == bfd_link_hash_undefweak
3677 || h->root.type == bfd_link_hash_undefined))))
3678 {
3679 /* Make sure this symbol is output as a dynamic symbol.
3680 Undefined weak syms won't yet be marked as dynamic. */
3681 if (h->dynindx == -1
3682 && !h->forced_local
3683 && !bfd_elf_link_record_dynamic_symbol (info, h))
3684 return FALSE;
3685
3686 /* If that succeeded, we know we'll be keeping all the
3687 relocs. */
3688 if (h->dynindx != -1)
3689 goto keep;
3690 }
3691
3692 eh->dyn_relocs = NULL;
3693
3694 keep: ;
3695 }
3696
3697 /* Finally, allocate space. */
3698 for (p = eh->dyn_relocs; p != NULL; p = p->next)
3699 {
3700 asection *sreloc = elf_section_data (p->sec)->sreloc;
3701 sreloc->size += p->count * sizeof (Elf32_External_Rela);
3702 }
3703
3704 return TRUE;
3705 }
3706
3707 /* Implement elf_backend_size_dynamic_sections:
3708 Set the sizes of the dynamic sections. */
3709 static bfd_boolean
3710 nios2_elf32_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3711 struct bfd_link_info *info)
3712 {
3713 bfd *dynobj;
3714 asection *s;
3715 bfd_boolean plt;
3716 bfd_boolean got;
3717 bfd_boolean relocs;
3718 bfd *ibfd;
3719 struct elf32_nios2_link_hash_table *htab;
3720
3721 htab = elf32_nios2_hash_table (info);
3722 dynobj = elf_hash_table (info)->dynobj;
3723 BFD_ASSERT (dynobj != NULL);
3724
3725 htab->res_n_size = 0;
3726 if (elf_hash_table (info)->dynamic_sections_created)
3727 {
3728 /* Set the contents of the .interp section to the interpreter. */
3729 if (info->executable)
3730 {
3731 s = bfd_get_linker_section (dynobj, ".interp");
3732 BFD_ASSERT (s != NULL);
3733 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3734 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3735 }
3736 }
3737 else
3738 {
3739 /* We may have created entries in the .rela.got section.
3740 However, if we are not creating the dynamic sections, we will
3741 not actually use these entries. Reset the size of .rela.got,
3742 which will cause it to get stripped from the output file
3743 below. */
3744 s = htab->root.srelgot;
3745 if (s != NULL)
3746 s->size = 0;
3747 }
3748
3749 /* Set up .got offsets for local syms, and space for local dynamic
3750 relocs. */
3751 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
3752 {
3753 bfd_signed_vma *local_got;
3754 bfd_signed_vma *end_local_got;
3755 char *local_tls_type;
3756 bfd_size_type locsymcount;
3757 Elf_Internal_Shdr *symtab_hdr;
3758 asection *srel;
3759
3760 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
3761 continue;
3762
3763 for (s = ibfd->sections; s != NULL; s = s->next)
3764 {
3765 struct elf32_nios2_dyn_relocs *p;
3766
3767 for (p = elf_section_data (s)->local_dynrel; p != NULL; p = p->next)
3768 {
3769 if (!bfd_is_abs_section (p->sec)
3770 && bfd_is_abs_section (p->sec->output_section))
3771 {
3772 /* Input section has been discarded, either because
3773 it is a copy of a linkonce section or due to
3774 linker script /DISCARD/, so we'll be discarding
3775 the relocs too. */
3776 }
3777 else if (p->count != 0)
3778 {
3779 srel = elf_section_data (p->sec)->sreloc;
3780 srel->size += p->count * sizeof (Elf32_External_Rela);
3781 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
3782 info->flags |= DF_TEXTREL;
3783 }
3784 }
3785 }
3786
3787 local_got = elf_local_got_refcounts (ibfd);
3788 if (!local_got)
3789 continue;
3790
3791 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
3792 locsymcount = symtab_hdr->sh_info;
3793 end_local_got = local_got + locsymcount;
3794 local_tls_type = elf32_nios2_local_got_tls_type (ibfd);
3795 s = htab->root.sgot;
3796 srel = htab->root.srelgot;
3797 for (; local_got < end_local_got; ++local_got, ++local_tls_type)
3798 {
3799 if (*local_got > 0)
3800 {
3801 *local_got = s->size;
3802 if (*local_tls_type & GOT_TLS_GD)
3803 /* TLS_GD relocs need an 8-byte structure in the GOT. */
3804 s->size += 8;
3805 if (*local_tls_type & GOT_TLS_IE)
3806 s->size += 4;
3807 if (*local_tls_type == GOT_NORMAL)
3808 s->size += 4;
3809
3810 if (info->shared || *local_tls_type == GOT_TLS_GD)
3811 srel->size += sizeof (Elf32_External_Rela);
3812 }
3813 else
3814 *local_got = (bfd_vma) -1;
3815 }
3816 }
3817
3818 if (htab->tls_ldm_got.refcount > 0)
3819 {
3820 /* Allocate two GOT entries and one dynamic relocation (if necessary)
3821 for R_NIOS2_TLS_LDM16 relocations. */
3822 htab->tls_ldm_got.offset = htab->root.sgot->size;
3823 htab->root.sgot->size += 8;
3824 if (info->shared)
3825 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
3826 }
3827 else
3828 htab->tls_ldm_got.offset = -1;
3829
3830 /* Allocate global sym .plt and .got entries, and space for global
3831 sym dynamic relocs. */
3832 elf_link_hash_traverse (& htab->root, allocate_dynrelocs, info);
3833
3834 /* The check_relocs and adjust_dynamic_symbol entry points have
3835 determined the sizes of the various dynamic sections. Allocate
3836 memory for them. */
3837 plt = FALSE;
3838 got = FALSE;
3839 relocs = FALSE;
3840 for (s = dynobj->sections; s != NULL; s = s->next)
3841 {
3842 const char *name;
3843
3844 if ((s->flags & SEC_LINKER_CREATED) == 0)
3845 continue;
3846
3847 /* It's OK to base decisions on the section name, because none
3848 of the dynobj section names depend upon the input files. */
3849 name = bfd_get_section_name (dynobj, s);
3850
3851 if (strcmp (name, ".plt") == 0)
3852 {
3853 /* Remember whether there is a PLT. */
3854 plt = s->size != 0;
3855
3856 /* Correct for the number of res_N branches. */
3857 if (plt && !info->shared)
3858 {
3859 htab->res_n_size = (s->size-28) / 3;
3860 s->size += htab->res_n_size;
3861 }
3862 }
3863 else if (CONST_STRNEQ (name, ".rela"))
3864 {
3865 if (s->size != 0)
3866 {
3867 relocs = TRUE;
3868
3869 /* We use the reloc_count field as a counter if we need
3870 to copy relocs into the output file. */
3871 s->reloc_count = 0;
3872 }
3873 }
3874 else if (CONST_STRNEQ (name, ".got"))
3875 got = s->size != 0;
3876 else if (strcmp (name, ".dynbss") != 0)
3877 /* It's not one of our sections, so don't allocate space. */
3878 continue;
3879
3880 if (s->size == 0)
3881 {
3882 /* If we don't need this section, strip it from the
3883 output file. This is mostly to handle .rela.bss and
3884 .rela.plt. We must create both sections in
3885 create_dynamic_sections, because they must be created
3886 before the linker maps input sections to output
3887 sections. The linker does that before
3888 adjust_dynamic_symbol is called, and it is that
3889 function which decides whether anything needs to go
3890 into these sections. */
3891 s->flags |= SEC_EXCLUDE;
3892 continue;
3893 }
3894
3895 if ((s->flags & SEC_HAS_CONTENTS) == 0)
3896 continue;
3897
3898 /* Allocate memory for the section contents. */
3899 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
3900 Unused entries should be reclaimed before the section's contents
3901 are written out, but at the moment this does not happen. Thus in
3902 order to prevent writing out garbage, we initialize the section's
3903 contents to zero. */
3904 s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3905 if (s->contents == NULL)
3906 return FALSE;
3907 }
3908
3909 /* Adjust dynamic symbols that point to the plt to account for the
3910 now-known number of resN slots. */
3911 if (htab->res_n_size)
3912 elf_link_hash_traverse (& htab->root, adjust_dynrelocs, info);
3913
3914 if (elf_hash_table (info)->dynamic_sections_created)
3915 {
3916 /* Add some entries to the .dynamic section. We fill in the
3917 values later, in elf_nios2_finish_dynamic_sections, but we
3918 must add the entries now so that we get the correct size for
3919 the .dynamic section. The DT_DEBUG entry is filled in by the
3920 dynamic linker and used by the debugger. */
3921 #define add_dynamic_entry(TAG, VAL) \
3922 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3923
3924 if (!info->shared && !add_dynamic_entry (DT_DEBUG, 0))
3925 return FALSE;
3926
3927 if (got && !add_dynamic_entry (DT_PLTGOT, 0))
3928 return FALSE;
3929
3930 if (plt
3931 && (!add_dynamic_entry (DT_PLTRELSZ, 0)
3932 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3933 || !add_dynamic_entry (DT_JMPREL, 0)))
3934 return FALSE;
3935
3936 if (relocs
3937 && (!add_dynamic_entry (DT_RELA, 0)
3938 || !add_dynamic_entry (DT_RELASZ, 0)
3939 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela))))
3940 return FALSE;
3941
3942 if (!info->shared && !add_dynamic_entry (DT_NIOS2_GP, 0))
3943 return FALSE;
3944
3945 if ((info->flags & DF_TEXTREL) != 0
3946 && !add_dynamic_entry (DT_TEXTREL, 0))
3947 return FALSE;
3948 }
3949 #undef add_dynamic_entry
3950
3951 return TRUE;
3952 }
3953
3954 /* Implement bfd_elf32_bfd_link_hash_table_create. */
3955 static struct bfd_link_hash_table *
3956 nios2_elf32_link_hash_table_create (bfd *abfd)
3957 {
3958 struct elf32_nios2_link_hash_table *ret;
3959 bfd_size_type amt = sizeof (struct elf32_nios2_link_hash_table);
3960
3961 ret = bfd_zmalloc (amt);
3962 if (ret == NULL)
3963 return NULL;
3964
3965 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3966 link_hash_newfunc,
3967 sizeof (struct
3968 elf32_nios2_link_hash_entry),
3969 NIOS2_ELF_DATA))
3970 {
3971 free (ret);
3972 return NULL;
3973 }
3974
3975 return &ret->root.root;
3976 }
3977
3978 /* Implement elf_backend_reloc_type_class. */
3979 static enum elf_reloc_type_class
3980 nios2_elf32_reloc_type_class (const Elf_Internal_Rela *rela)
3981 {
3982 switch ((int) ELF32_R_TYPE (rela->r_info))
3983 {
3984 case R_NIOS2_RELATIVE:
3985 return reloc_class_relative;
3986 case R_NIOS2_JUMP_SLOT:
3987 return reloc_class_plt;
3988 case R_NIOS2_COPY:
3989 return reloc_class_copy;
3990 default:
3991 return reloc_class_normal;
3992 }
3993 }
3994
3995 /* Return 1 if target is one of ours. */
3996 static bfd_boolean
3997 is_nios2_elf_target (const struct bfd_target *targ)
3998 {
3999 return (targ == &bfd_elf32_littlenios2_vec
4000 || targ == &bfd_elf32_bignios2_vec);
4001 }
4002
4003 /* Implement elf_backend_add_symbol_hook.
4004 This hook is called by the linker when adding symbols from an object
4005 file. We use it to put .comm items in .sbss, and not .bss. */
4006 static bfd_boolean
4007 nios2_elf_add_symbol_hook (bfd *abfd,
4008 struct bfd_link_info *info,
4009 Elf_Internal_Sym *sym,
4010 const char **namep ATTRIBUTE_UNUSED,
4011 flagword *flagsp ATTRIBUTE_UNUSED,
4012 asection **secp,
4013 bfd_vma *valp)
4014 {
4015 bfd *dynobj;
4016
4017 if (sym->st_shndx == SHN_COMMON
4018 && !info->relocatable
4019 && sym->st_size <= elf_gp_size (abfd)
4020 && is_nios2_elf_target (info->output_bfd->xvec))
4021 {
4022 /* Common symbols less than or equal to -G nn bytes are automatically
4023 put into .sbss. */
4024 struct elf32_nios2_link_hash_table *htab;
4025
4026 htab = elf32_nios2_hash_table (info);
4027 if (htab->sbss == NULL)
4028 {
4029 flagword flags = SEC_IS_COMMON | SEC_LINKER_CREATED;
4030
4031 dynobj = elf_hash_table (info)->dynobj;
4032 if (!dynobj)
4033 dynobj = abfd;
4034
4035 htab->sbss = bfd_make_section_anyway_with_flags (dynobj, ".sbss",
4036 flags);
4037 if (htab->sbss == NULL)
4038 return FALSE;
4039 }
4040
4041 *secp = htab->sbss;
4042 *valp = sym->st_size;
4043 }
4044
4045 return TRUE;
4046 }
4047
4048 /* Implement elf_backend_can_make_relative_eh_frame:
4049 Decide whether to attempt to turn absptr or lsda encodings in
4050 shared libraries into pcrel within the given input section. */
4051 static bfd_boolean
4052 nios2_elf32_can_make_relative_eh_frame (bfd *input_bfd ATTRIBUTE_UNUSED,
4053 struct bfd_link_info *info
4054 ATTRIBUTE_UNUSED,
4055 asection *eh_frame_section
4056 ATTRIBUTE_UNUSED)
4057 {
4058 /* We can't use PC-relative encodings in the .eh_frame section. */
4059 return FALSE;
4060 }
4061
4062 /* Implement elf_backend_special_sections. */
4063 const struct bfd_elf_special_section elf32_nios2_special_sections[] =
4064 {
4065 { STRING_COMMA_LEN (".sbss"), -2, SHT_NOBITS,
4066 SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
4067 { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS,
4068 SHF_ALLOC + SHF_WRITE + SHF_NIOS2_GPREL },
4069 { NULL, 0, 0, 0, 0 }
4070 };
4071
4072 #define ELF_ARCH bfd_arch_nios2
4073 #define ELF_TARGET_ID NIOS2_ELF_DATA
4074 #define ELF_MACHINE_CODE EM_ALTERA_NIOS2
4075
4076 /* The Nios II MMU uses a 4K page size. */
4077
4078 #define ELF_MAXPAGESIZE 0x1000
4079
4080 #define bfd_elf32_bfd_link_hash_table_create \
4081 nios2_elf32_link_hash_table_create
4082
4083 /* Relocation table lookup macros. */
4084
4085 #define bfd_elf32_bfd_reloc_type_lookup nios2_elf32_bfd_reloc_type_lookup
4086 #define bfd_elf32_bfd_reloc_name_lookup nios2_elf32_bfd_reloc_name_lookup
4087
4088 /* JUMP_TABLE_LINK macros. */
4089
4090 /* elf_info_to_howto (using RELA relocations). */
4091
4092 #define elf_info_to_howto nios2_elf32_info_to_howto
4093
4094 /* elf backend functions. */
4095
4096 #define elf_backend_can_gc_sections 1
4097 #define elf_backend_can_refcount 1
4098 #define elf_backend_plt_readonly 1
4099 #define elf_backend_want_got_plt 1
4100 #define elf_backend_rela_normal 1
4101
4102 #define elf_backend_relocate_section nios2_elf32_relocate_section
4103 #define elf_backend_section_flags nios2_elf32_section_flags
4104 #define elf_backend_fake_sections nios2_elf32_fake_sections
4105 #define elf_backend_check_relocs nios2_elf32_check_relocs
4106
4107 #define elf_backend_gc_mark_hook nios2_elf32_gc_mark_hook
4108 #define elf_backend_gc_sweep_hook nios2_elf32_gc_sweep_hook
4109 #define elf_backend_create_dynamic_sections \
4110 nios2_elf32_create_dynamic_sections
4111 #define elf_backend_finish_dynamic_symbol nios2_elf32_finish_dynamic_symbol
4112 #define elf_backend_finish_dynamic_sections \
4113 nios2_elf32_finish_dynamic_sections
4114 #define elf_backend_adjust_dynamic_symbol nios2_elf32_adjust_dynamic_symbol
4115 #define elf_backend_reloc_type_class nios2_elf32_reloc_type_class
4116 #define elf_backend_size_dynamic_sections nios2_elf32_size_dynamic_sections
4117 #define elf_backend_add_symbol_hook nios2_elf_add_symbol_hook
4118 #define elf_backend_copy_indirect_symbol nios2_elf32_copy_indirect_symbol
4119
4120 #define elf_backend_grok_prstatus nios2_grok_prstatus
4121 #define elf_backend_grok_psinfo nios2_grok_psinfo
4122
4123 #undef elf_backend_can_make_relative_eh_frame
4124 #define elf_backend_can_make_relative_eh_frame \
4125 nios2_elf32_can_make_relative_eh_frame
4126
4127 #define elf_backend_special_sections elf32_nios2_special_sections
4128
4129 #define TARGET_LITTLE_SYM bfd_elf32_littlenios2_vec
4130 #define TARGET_LITTLE_NAME "elf32-littlenios2"
4131 #define TARGET_BIG_SYM bfd_elf32_bignios2_vec
4132 #define TARGET_BIG_NAME "elf32-bignios2"
4133
4134 #define elf_backend_got_header_size 12
4135
4136 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.