1 /* ADI Blackfin BFD support for 32-bit ELF.
2 Copyright (C) 2005-2021 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
28 #include "elf32-bfin.h"
30 /* FUNCTION : bfin_pltpc_reloc
31 ABSTRACT : TODO : figure out how to handle pltpc relocs. */
32 static bfd_reloc_status_type
34 bfd
*abfd ATTRIBUTE_UNUSED
,
35 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
36 asymbol
*symbol ATTRIBUTE_UNUSED
,
37 void * data ATTRIBUTE_UNUSED
,
38 asection
*input_section ATTRIBUTE_UNUSED
,
39 bfd
*output_bfd ATTRIBUTE_UNUSED
,
40 char **error_message ATTRIBUTE_UNUSED
)
42 bfd_reloc_status_type flag
= bfd_reloc_ok
;
47 static bfd_reloc_status_type
48 bfin_pcrel24_reloc (bfd
*abfd
,
52 asection
*input_section
,
54 char **error_message ATTRIBUTE_UNUSED
)
57 bfd_size_type addr
= reloc_entry
->address
;
58 bfd_vma output_base
= 0;
59 reloc_howto_type
*howto
= reloc_entry
->howto
;
60 asection
*output_section
;
61 bool relocatable
= (output_bfd
!= NULL
);
63 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
64 return bfd_reloc_outofrange
;
66 if (bfd_is_und_section (symbol
->section
)
67 && (symbol
->flags
& BSF_WEAK
) == 0
69 return bfd_reloc_undefined
;
71 if (bfd_is_com_section (symbol
->section
))
74 relocation
= symbol
->value
;
76 output_section
= symbol
->section
->output_section
;
81 output_base
= output_section
->vma
;
83 if (!relocatable
|| !strcmp (symbol
->name
, symbol
->section
->name
))
84 relocation
+= output_base
+ symbol
->section
->output_offset
;
86 if (!relocatable
&& !strcmp (symbol
->name
, symbol
->section
->name
))
87 relocation
+= reloc_entry
->addend
;
89 relocation
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
90 relocation
-= reloc_entry
->address
;
92 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
94 bfd_reloc_status_type status
;
95 status
= bfd_check_overflow (howto
->complain_on_overflow
,
98 bfd_arch_bits_per_address(abfd
),
100 if (status
!= bfd_reloc_ok
)
104 /* if rightshift is 1 and the number odd, return error. */
105 if (howto
->rightshift
&& (relocation
& 0x01))
107 _bfd_error_handler (_("relocation should be even number"));
108 return bfd_reloc_overflow
;
111 relocation
>>= (bfd_vma
) howto
->rightshift
;
112 /* Shift everything up to where it's going to be used. */
114 relocation
<<= (bfd_vma
) howto
->bitpos
;
118 reloc_entry
->address
+= input_section
->output_offset
;
119 reloc_entry
->addend
+= symbol
->section
->output_offset
;
125 /* We are getting reloc_entry->address 2 byte off from
126 the start of instruction. Assuming absolute postion
127 of the reloc data. But, following code had been written assuming
128 reloc address is starting at begining of instruction.
129 To compensate that I have increased the value of
130 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
133 x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
- 2);
134 x
= (x
& 0xff00) | ((relocation
>> 16) & 0xff);
135 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
- 2);
137 x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
);
138 x
= relocation
& 0xFFFF;
139 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
);
144 static bfd_reloc_status_type
145 bfin_imm16_reloc (bfd
*abfd
,
146 arelent
*reloc_entry
,
149 asection
*input_section
,
151 char **error_message ATTRIBUTE_UNUSED
)
153 bfd_vma relocation
, x
;
154 bfd_size_type reloc_addr
= reloc_entry
->address
;
155 bfd_vma output_base
= 0;
156 reloc_howto_type
*howto
= reloc_entry
->howto
;
157 asection
*output_section
;
158 bool relocatable
= (output_bfd
!= NULL
);
160 /* Is the address of the relocation really within the section? */
161 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
162 return bfd_reloc_outofrange
;
164 if (bfd_is_und_section (symbol
->section
)
165 && (symbol
->flags
& BSF_WEAK
) == 0
167 return bfd_reloc_undefined
;
169 output_section
= symbol
->section
->output_section
;
170 relocation
= symbol
->value
;
172 /* Convert input-section-relative symbol value to absolute. */
176 output_base
= output_section
->vma
;
178 if (!relocatable
|| !strcmp (symbol
->name
, symbol
->section
->name
))
179 relocation
+= output_base
+ symbol
->section
->output_offset
;
181 /* Add in supplied addend. */
182 relocation
+= reloc_entry
->addend
;
186 reloc_entry
->address
+= input_section
->output_offset
;
187 reloc_entry
->addend
+= symbol
->section
->output_offset
;
191 reloc_entry
->addend
= 0;
194 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
196 bfd_reloc_status_type flag
;
197 flag
= bfd_check_overflow (howto
->complain_on_overflow
,
200 bfd_arch_bits_per_address(abfd
),
202 if (flag
!= bfd_reloc_ok
)
206 /* Here the variable relocation holds the final address of the
207 symbol we are relocating against, plus any addend. */
209 relocation
>>= (bfd_vma
) howto
->rightshift
;
211 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ reloc_addr
);
216 static bfd_reloc_status_type
217 bfin_byte4_reloc (bfd
*abfd
,
218 arelent
*reloc_entry
,
221 asection
*input_section
,
223 char **error_message ATTRIBUTE_UNUSED
)
225 bfd_vma relocation
, x
;
226 bfd_size_type addr
= reloc_entry
->address
;
227 bfd_vma output_base
= 0;
228 asection
*output_section
;
229 bool relocatable
= (output_bfd
!= NULL
);
231 /* Is the address of the relocation really within the section? */
232 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
233 return bfd_reloc_outofrange
;
235 if (bfd_is_und_section (symbol
->section
)
236 && (symbol
->flags
& BSF_WEAK
) == 0
238 return bfd_reloc_undefined
;
240 output_section
= symbol
->section
->output_section
;
241 relocation
= symbol
->value
;
242 /* Convert input-section-relative symbol value to absolute. */
246 output_base
= output_section
->vma
;
249 && symbol
->section
->name
250 && !strcmp (symbol
->name
, symbol
->section
->name
))
253 relocation
+= output_base
+ symbol
->section
->output_offset
;
256 relocation
+= reloc_entry
->addend
;
260 /* This output will be relocatable ... like ld -r. */
261 reloc_entry
->address
+= input_section
->output_offset
;
262 reloc_entry
->addend
+= symbol
->section
->output_offset
;
266 reloc_entry
->addend
= 0;
269 /* Here the variable relocation holds the final address of the
270 symbol we are relocating against, plus any addend. */
271 x
= relocation
& 0xFFFF0000;
273 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
+ 2);
275 x
= relocation
& 0x0000FFFF;
276 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
);
280 /* bfin_bfd_reloc handles the blackfin arithmetic relocations.
281 Use this instead of bfd_perform_relocation. */
282 static bfd_reloc_status_type
283 bfin_bfd_reloc (bfd
*abfd
,
284 arelent
*reloc_entry
,
287 asection
*input_section
,
289 char **error_message ATTRIBUTE_UNUSED
)
292 bfd_size_type addr
= reloc_entry
->address
;
293 bfd_vma output_base
= 0;
294 reloc_howto_type
*howto
= reloc_entry
->howto
;
295 asection
*output_section
;
296 bool relocatable
= (output_bfd
!= NULL
);
298 /* Is the address of the relocation really within the section? */
299 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
300 return bfd_reloc_outofrange
;
302 if (bfd_is_und_section (symbol
->section
)
303 && (symbol
->flags
& BSF_WEAK
) == 0
305 return bfd_reloc_undefined
;
307 /* Get symbol value. (Common symbols are special.) */
308 if (bfd_is_com_section (symbol
->section
))
311 relocation
= symbol
->value
;
313 output_section
= symbol
->section
->output_section
;
315 /* Convert input-section-relative symbol value to absolute. */
319 output_base
= output_section
->vma
;
321 if (!relocatable
|| !strcmp (symbol
->name
, symbol
->section
->name
))
322 relocation
+= output_base
+ symbol
->section
->output_offset
;
324 if (!relocatable
&& !strcmp (symbol
->name
, symbol
->section
->name
))
326 /* Add in supplied addend. */
327 relocation
+= reloc_entry
->addend
;
330 /* Here the variable relocation holds the final address of the
331 symbol we are relocating against, plus any addend. */
333 if (howto
->pc_relative
)
335 relocation
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
337 if (howto
->pcrel_offset
)
338 relocation
-= reloc_entry
->address
;
343 reloc_entry
->address
+= input_section
->output_offset
;
344 reloc_entry
->addend
+= symbol
->section
->output_offset
;
347 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
349 bfd_reloc_status_type status
;
351 status
= bfd_check_overflow (howto
->complain_on_overflow
,
354 bfd_arch_bits_per_address(abfd
),
356 if (status
!= bfd_reloc_ok
)
360 /* If rightshift is 1 and the number odd, return error. */
361 if (howto
->rightshift
&& (relocation
& 0x01))
363 _bfd_error_handler (_("relocation should be even number"));
364 return bfd_reloc_overflow
;
367 relocation
>>= (bfd_vma
) howto
->rightshift
;
369 /* Shift everything up to where it's going to be used. */
371 relocation
<<= (bfd_vma
) howto
->bitpos
;
374 x = ( (x & ~howto->dst_mask) | (relocation & howto->dst_mask))
376 /* handle 8 and 16 bit relocations here. */
381 char x
= bfd_get_8 (abfd
, (char *) data
+ addr
);
383 bfd_put_8 (abfd
, x
, (unsigned char *) data
+ addr
);
389 unsigned short x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
);
391 bfd_put_16 (abfd
, (bfd_vma
) x
, (unsigned char *) data
+ addr
);
396 return bfd_reloc_other
;
402 /* HOWTO Table for blackfin.
403 Blackfin relocations are fairly complicated.
404 Some of the salient features are
405 a. Even numbered offsets. A number of (not all) relocations are
406 even numbered. This means that the rightmost bit is not stored.
407 Needs to right shift by 1 and check to see if value is not odd
408 b. A relocation can be an expression. An expression takes on
409 a variety of relocations arranged in a stack.
410 As a result, we cannot use the standard generic function as special
411 function. We will have our own, which is very similar to the standard
412 generic function except that it understands how to get the value from
413 the relocation stack. . */
415 #define BFIN_RELOC_MIN 0
416 #define BFIN_RELOC_MAX 0x21
417 #define BFIN_GNUEXT_RELOC_MIN 0x40
418 #define BFIN_GNUEXT_RELOC_MAX 0x43
419 #define BFIN_ARELOC_MIN 0xE0
420 #define BFIN_ARELOC_MAX 0xF3
422 static reloc_howto_type bfin_howto_table
[] =
424 /* This reloc does nothing. . */
425 HOWTO (R_BFIN_UNUSED0
, /* type. */
427 3, /* size (0 = byte, 1 = short, 2 = long). */
429 false, /* pc_relative. */
431 complain_overflow_dont
, /* complain_on_overflow. */
432 bfd_elf_generic_reloc
, /* special_function. */
433 "R_BFIN_UNUSED0", /* name. */
434 false, /* partial_inplace. */
437 false), /* pcrel_offset. */
439 HOWTO (R_BFIN_PCREL5M2
, /* type. */
441 1, /* size (0 = byte, 1 = short, 2 = long).. */
443 true, /* pc_relative. */
445 complain_overflow_unsigned
, /* complain_on_overflow. */
446 bfin_bfd_reloc
, /* special_function. */
447 "R_BFIN_PCREL5M2", /* name. */
448 false, /* partial_inplace. */
450 0x0000000F, /* dst_mask. */
451 false), /* pcrel_offset. */
453 HOWTO (R_BFIN_UNUSED1
, /* type. */
455 3, /* size (0 = byte, 1 = short, 2 = long). */
457 false, /* pc_relative. */
459 complain_overflow_dont
, /* complain_on_overflow. */
460 bfd_elf_generic_reloc
, /* special_function. */
461 "R_BFIN_UNUSED1", /* name. */
462 false, /* partial_inplace. */
465 false), /* pcrel_offset. */
467 HOWTO (R_BFIN_PCREL10
, /* type. */
469 1, /* size (0 = byte, 1 = short, 2 = long). */
471 true, /* pc_relative. */
473 complain_overflow_signed
, /* complain_on_overflow. */
474 bfin_bfd_reloc
, /* special_function. */
475 "R_BFIN_PCREL10", /* name. */
476 false, /* partial_inplace. */
478 0x000003FF, /* dst_mask. */
479 true), /* pcrel_offset. */
481 HOWTO (R_BFIN_PCREL12_JUMP
, /* type. */
483 /* the offset is actually 13 bit
484 aligned on a word boundary so
485 only 12 bits have to be used.
486 Right shift the rightmost bit.. */
487 1, /* size (0 = byte, 1 = short, 2 = long). */
489 true, /* pc_relative. */
491 complain_overflow_signed
, /* complain_on_overflow. */
492 bfin_bfd_reloc
, /* special_function. */
493 "R_BFIN_PCREL12_JUMP", /* name. */
494 false, /* partial_inplace. */
496 0x0FFF, /* dst_mask. */
497 true), /* pcrel_offset. */
499 HOWTO (R_BFIN_RIMM16
, /* type. */
501 1, /* size (0 = byte, 1 = short, 2 = long). */
503 false, /* pc_relative. */
505 complain_overflow_signed
, /* complain_on_overflow. */
506 bfin_imm16_reloc
, /* special_function. */
507 "R_BFIN_RIMM16", /* name. */
508 false, /* partial_inplace. */
510 0x0000FFFF, /* dst_mask. */
511 true), /* pcrel_offset. */
513 HOWTO (R_BFIN_LUIMM16
, /* type. */
515 1, /* size (0 = byte, 1 = short, 2 = long). */
517 false, /* pc_relative. */
519 complain_overflow_dont
, /* complain_on_overflow. */
520 bfin_imm16_reloc
, /* special_function. */
521 "R_BFIN_LUIMM16", /* name. */
522 false, /* partial_inplace. */
524 0x0000FFFF, /* dst_mask. */
525 true), /* pcrel_offset. */
527 HOWTO (R_BFIN_HUIMM16
, /* type. */
528 16, /* rightshift. */
529 1, /* size (0 = byte, 1 = short, 2 = long). */
531 false, /* pc_relative. */
533 complain_overflow_unsigned
, /* complain_on_overflow. */
534 bfin_imm16_reloc
, /* special_function. */
535 "R_BFIN_HUIMM16", /* name. */
536 false, /* partial_inplace. */
538 0x0000FFFF, /* dst_mask. */
539 true), /* pcrel_offset. */
541 HOWTO (R_BFIN_PCREL12_JUMP_S
, /* type. */
543 1, /* size (0 = byte, 1 = short, 2 = long). */
545 true, /* pc_relative. */
547 complain_overflow_signed
, /* complain_on_overflow. */
548 bfin_bfd_reloc
, /* special_function. */
549 "R_BFIN_PCREL12_JUMP_S", /* name. */
550 false, /* partial_inplace. */
552 0x00000FFF, /* dst_mask. */
553 true), /* pcrel_offset. */
555 HOWTO (R_BFIN_PCREL24_JUMP_X
, /* type. */
557 2, /* size (0 = byte, 1 = short, 2 = long). */
559 true, /* pc_relative. */
561 complain_overflow_signed
, /* complain_on_overflow. */
562 bfin_pcrel24_reloc
, /* special_function. */
563 "R_BFIN_PCREL24_JUMP_X", /* name. */
564 false, /* partial_inplace. */
566 0x00FFFFFF, /* dst_mask. */
567 true), /* pcrel_offset. */
569 HOWTO (R_BFIN_PCREL24
, /* type. */
571 2, /* size (0 = byte, 1 = short, 2 = long). */
573 true, /* pc_relative. */
575 complain_overflow_signed
, /* complain_on_overflow. */
576 bfin_pcrel24_reloc
, /* special_function. */
577 "R_BFIN_PCREL24", /* name. */
578 false, /* partial_inplace. */
580 0x00FFFFFF, /* dst_mask. */
581 true), /* pcrel_offset. */
583 HOWTO (R_BFIN_UNUSEDB
, /* type. */
585 3, /* size (0 = byte, 1 = short, 2 = long). */
587 false, /* pc_relative. */
589 complain_overflow_dont
, /* complain_on_overflow. */
590 bfd_elf_generic_reloc
, /* special_function. */
591 "R_BFIN_UNUSEDB", /* name. */
592 false, /* partial_inplace. */
595 false), /* pcrel_offset. */
597 HOWTO (R_BFIN_UNUSEDC
, /* type. */
599 3, /* size (0 = byte, 1 = short, 2 = long). */
601 false, /* pc_relative. */
603 complain_overflow_dont
, /* complain_on_overflow. */
604 bfd_elf_generic_reloc
, /* special_function. */
605 "R_BFIN_UNUSEDC", /* name. */
606 false, /* partial_inplace. */
609 false), /* pcrel_offset. */
611 HOWTO (R_BFIN_PCREL24_JUMP_L
, /* type. */
613 2, /* size (0 = byte, 1 = short, 2 = long). */
615 true, /* pc_relative. */
617 complain_overflow_signed
, /* complain_on_overflow. */
618 bfin_pcrel24_reloc
, /* special_function. */
619 "R_BFIN_PCREL24_JUMP_L", /* name. */
620 false, /* partial_inplace. */
622 0x00FFFFFF, /* dst_mask. */
623 true), /* pcrel_offset. */
625 HOWTO (R_BFIN_PCREL24_CALL_X
, /* type. */
627 2, /* size (0 = byte, 1 = short, 2 = long). */
629 true, /* pc_relative. */
631 complain_overflow_signed
, /* complain_on_overflow. */
632 bfin_pcrel24_reloc
, /* special_function. */
633 "R_BFIN_PCREL24_CALL_X", /* name. */
634 false, /* partial_inplace. */
636 0x00FFFFFF, /* dst_mask. */
637 true), /* pcrel_offset. */
639 HOWTO (R_BFIN_VAR_EQ_SYMB
, /* type. */
641 2, /* size (0 = byte, 1 = short, 2 = long). */
643 false, /* pc_relative. */
645 complain_overflow_bitfield
, /* complain_on_overflow. */
646 bfin_bfd_reloc
, /* special_function. */
647 "R_BFIN_VAR_EQ_SYMB", /* name. */
648 false, /* partial_inplace. */
651 false), /* pcrel_offset. */
653 HOWTO (R_BFIN_BYTE_DATA
, /* type. */
655 0, /* size (0 = byte, 1 = short, 2 = long). */
657 false, /* pc_relative. */
659 complain_overflow_unsigned
, /* complain_on_overflow. */
660 bfin_bfd_reloc
, /* special_function. */
661 "R_BFIN_BYTE_DATA", /* name. */
662 false, /* partial_inplace. */
664 0xFF, /* dst_mask. */
665 true), /* pcrel_offset. */
667 HOWTO (R_BFIN_BYTE2_DATA
, /* type. */
669 1, /* size (0 = byte, 1 = short, 2 = long). */
671 false, /* pc_relative. */
673 complain_overflow_signed
, /* complain_on_overflow. */
674 bfin_bfd_reloc
, /* special_function. */
675 "R_BFIN_BYTE2_DATA", /* name. */
676 false, /* partial_inplace. */
678 0xFFFF, /* dst_mask. */
679 true), /* pcrel_offset. */
681 HOWTO (R_BFIN_BYTE4_DATA
, /* type. */
683 2, /* size (0 = byte, 1 = short, 2 = long). */
685 false, /* pc_relative. */
687 complain_overflow_unsigned
, /* complain_on_overflow. */
688 bfin_byte4_reloc
, /* special_function. */
689 "R_BFIN_BYTE4_DATA", /* name. */
690 false, /* partial_inplace. */
692 0xFFFFFFFF, /* dst_mask. */
693 true), /* pcrel_offset. */
695 HOWTO (R_BFIN_PCREL11
, /* type. */
697 1, /* size (0 = byte, 1 = short, 2 = long). */
699 true, /* pc_relative. */
701 complain_overflow_unsigned
, /* complain_on_overflow. */
702 bfin_bfd_reloc
, /* special_function. */
703 "R_BFIN_PCREL11", /* name. */
704 false, /* partial_inplace. */
706 0x000003FF, /* dst_mask. */
707 false), /* pcrel_offset. */
710 /* A 18-bit signed operand with the GOT offset for the address of
712 HOWTO (R_BFIN_GOT17M4
, /* type */
714 1, /* size (0 = byte, 1 = short, 2 = long) */
716 false, /* pc_relative */
718 complain_overflow_signed
, /* complain_on_overflow */
719 bfd_elf_generic_reloc
, /* special_function */
720 "R_BFIN_GOT17M4", /* name */
721 false, /* partial_inplace */
722 0xffff, /* src_mask */
723 0xffff, /* dst_mask */
724 false), /* pcrel_offset */
726 /* The upper 16 bits of the GOT offset for the address of the
728 HOWTO (R_BFIN_GOTHI
, /* type */
730 1, /* size (0 = byte, 1 = short, 2 = long) */
732 false, /* pc_relative */
734 complain_overflow_dont
, /* complain_on_overflow */
735 bfd_elf_generic_reloc
, /* special_function */
736 "R_BFIN_GOTHI", /* name */
737 false, /* partial_inplace */
738 0xffff, /* src_mask */
739 0xffff, /* dst_mask */
740 false), /* pcrel_offset */
742 /* The lower 16 bits of the GOT offset for the address of the
744 HOWTO (R_BFIN_GOTLO
, /* type */
746 1, /* size (0 = byte, 1 = short, 2 = long) */
748 false, /* pc_relative */
750 complain_overflow_dont
, /* complain_on_overflow */
751 bfd_elf_generic_reloc
, /* special_function */
752 "R_BFIN_GOTLO", /* name */
753 false, /* partial_inplace */
754 0xffff, /* src_mask */
755 0xffff, /* dst_mask */
756 false), /* pcrel_offset */
758 /* The 32-bit address of the canonical descriptor of a function. */
759 HOWTO (R_BFIN_FUNCDESC
, /* type */
761 2, /* size (0 = byte, 1 = short, 2 = long) */
763 false, /* pc_relative */
765 complain_overflow_bitfield
, /* complain_on_overflow */
766 bfd_elf_generic_reloc
, /* special_function */
767 "R_BFIN_FUNCDESC", /* name */
768 false, /* partial_inplace */
769 0xffffffff, /* src_mask */
770 0xffffffff, /* dst_mask */
771 false), /* pcrel_offset */
773 /* A 12-bit signed operand with the GOT offset for the address of
774 canonical descriptor of a function. */
775 HOWTO (R_BFIN_FUNCDESC_GOT17M4
, /* type */
777 1, /* size (0 = byte, 1 = short, 2 = long) */
779 false, /* pc_relative */
781 complain_overflow_signed
, /* complain_on_overflow */
782 bfd_elf_generic_reloc
, /* special_function */
783 "R_BFIN_FUNCDESC_GOT17M4", /* name */
784 false, /* partial_inplace */
785 0xffff, /* src_mask */
786 0xffff, /* dst_mask */
787 false), /* pcrel_offset */
789 /* The upper 16 bits of the GOT offset for the address of the
790 canonical descriptor of a function. */
791 HOWTO (R_BFIN_FUNCDESC_GOTHI
, /* type */
793 1, /* size (0 = byte, 1 = short, 2 = long) */
795 false, /* pc_relative */
797 complain_overflow_dont
, /* complain_on_overflow */
798 bfd_elf_generic_reloc
, /* special_function */
799 "R_BFIN_FUNCDESC_GOTHI", /* name */
800 false, /* partial_inplace */
801 0xffff, /* src_mask */
802 0xffff, /* dst_mask */
803 false), /* pcrel_offset */
805 /* The lower 16 bits of the GOT offset for the address of the
806 canonical descriptor of a function. */
807 HOWTO (R_BFIN_FUNCDESC_GOTLO
, /* type */
809 1, /* size (0 = byte, 1 = short, 2 = long) */
811 false, /* pc_relative */
813 complain_overflow_dont
, /* complain_on_overflow */
814 bfd_elf_generic_reloc
, /* special_function */
815 "R_BFIN_FUNCDESC_GOTLO", /* name */
816 false, /* partial_inplace */
817 0xffff, /* src_mask */
818 0xffff, /* dst_mask */
819 false), /* pcrel_offset */
821 /* The 32-bit address of the canonical descriptor of a function. */
822 HOWTO (R_BFIN_FUNCDESC_VALUE
, /* type */
824 2, /* size (0 = byte, 1 = short, 2 = long) */
826 false, /* pc_relative */
828 complain_overflow_bitfield
, /* complain_on_overflow */
829 bfd_elf_generic_reloc
, /* special_function */
830 "R_BFIN_FUNCDESC_VALUE", /* name */
831 false, /* partial_inplace */
832 0xffffffff, /* src_mask */
833 0xffffffff, /* dst_mask */
834 false), /* pcrel_offset */
836 /* A 12-bit signed operand with the GOT offset for the address of
837 canonical descriptor of a function. */
838 HOWTO (R_BFIN_FUNCDESC_GOTOFF17M4
, /* type */
840 1, /* size (0 = byte, 1 = short, 2 = long) */
842 false, /* pc_relative */
844 complain_overflow_signed
, /* complain_on_overflow */
845 bfd_elf_generic_reloc
, /* special_function */
846 "R_BFIN_FUNCDESC_GOTOFF17M4", /* name */
847 false, /* partial_inplace */
848 0xffff, /* src_mask */
849 0xffff, /* dst_mask */
850 false), /* pcrel_offset */
852 /* The upper 16 bits of the GOT offset for the address of the
853 canonical descriptor of a function. */
854 HOWTO (R_BFIN_FUNCDESC_GOTOFFHI
, /* type */
856 1, /* size (0 = byte, 1 = short, 2 = long) */
858 false, /* pc_relative */
860 complain_overflow_dont
, /* complain_on_overflow */
861 bfd_elf_generic_reloc
, /* special_function */
862 "R_BFIN_FUNCDESC_GOTOFFHI", /* name */
863 false, /* partial_inplace */
864 0xffff, /* src_mask */
865 0xffff, /* dst_mask */
866 false), /* pcrel_offset */
868 /* The lower 16 bits of the GOT offset for the address of the
869 canonical descriptor of a function. */
870 HOWTO (R_BFIN_FUNCDESC_GOTOFFLO
, /* type */
872 1, /* size (0 = byte, 1 = short, 2 = long) */
874 false, /* pc_relative */
876 complain_overflow_dont
, /* complain_on_overflow */
877 bfd_elf_generic_reloc
, /* special_function */
878 "R_BFIN_FUNCDESC_GOTOFFLO", /* name */
879 false, /* partial_inplace */
880 0xffff, /* src_mask */
881 0xffff, /* dst_mask */
882 false), /* pcrel_offset */
884 /* A 12-bit signed operand with the GOT offset for the address of
886 HOWTO (R_BFIN_GOTOFF17M4
, /* type */
888 1, /* size (0 = byte, 1 = short, 2 = long) */
890 false, /* pc_relative */
892 complain_overflow_signed
, /* complain_on_overflow */
893 bfd_elf_generic_reloc
, /* special_function */
894 "R_BFIN_GOTOFF17M4", /* name */
895 false, /* partial_inplace */
896 0xffff, /* src_mask */
897 0xffff, /* dst_mask */
898 false), /* pcrel_offset */
900 /* The upper 16 bits of the GOT offset for the address of the
902 HOWTO (R_BFIN_GOTOFFHI
, /* type */
904 1, /* size (0 = byte, 1 = short, 2 = long) */
906 false, /* pc_relative */
908 complain_overflow_dont
, /* complain_on_overflow */
909 bfd_elf_generic_reloc
, /* special_function */
910 "R_BFIN_GOTOFFHI", /* name */
911 false, /* partial_inplace */
912 0xffff, /* src_mask */
913 0xffff, /* dst_mask */
914 false), /* pcrel_offset */
916 /* The lower 16 bits of the GOT offset for the address of the
918 HOWTO (R_BFIN_GOTOFFLO
, /* type */
920 1, /* size (0 = byte, 1 = short, 2 = long) */
922 false, /* pc_relative */
924 complain_overflow_dont
, /* complain_on_overflow */
925 bfd_elf_generic_reloc
, /* special_function */
926 "R_BFIN_GOTOFFLO", /* name */
927 false, /* partial_inplace */
928 0xffff, /* src_mask */
929 0xffff, /* dst_mask */
930 false), /* pcrel_offset */
933 static reloc_howto_type bfin_gnuext_howto_table
[] =
935 HOWTO (R_BFIN_PLTPC
, /* type. */
937 1, /* size (0 = byte, 1 = short, 2 = long). */
939 false, /* pc_relative. */
941 complain_overflow_bitfield
, /* complain_on_overflow. */
942 bfin_pltpc_reloc
, /* special_function. */
943 "R_BFIN_PLTPC", /* name. */
944 false, /* partial_inplace. */
945 0xffff, /* src_mask. */
946 0xffff, /* dst_mask. */
947 false), /* pcrel_offset. */
949 HOWTO (R_BFIN_GOT
, /* type. */
951 1, /* size (0 = byte, 1 = short, 2 = long). */
953 false, /* pc_relative. */
955 complain_overflow_bitfield
, /* complain_on_overflow. */
956 bfd_elf_generic_reloc
, /* special_function. */
957 "R_BFIN_GOT", /* name. */
958 false, /* partial_inplace. */
959 0x7fff, /* src_mask. */
960 0x7fff, /* dst_mask. */
961 false), /* pcrel_offset. */
963 /* GNU extension to record C++ vtable hierarchy. */
964 HOWTO (R_BFIN_GNU_VTINHERIT
, /* type. */
966 2, /* size (0 = byte, 1 = short, 2 = long). */
968 false, /* pc_relative. */
970 complain_overflow_dont
, /* complain_on_overflow. */
971 NULL
, /* special_function. */
972 "R_BFIN_GNU_VTINHERIT", /* name. */
973 false, /* partial_inplace. */
976 false), /* pcrel_offset. */
978 /* GNU extension to record C++ vtable member usage. */
979 HOWTO (R_BFIN_GNU_VTENTRY
, /* type. */
981 2, /* size (0 = byte, 1 = short, 2 = long). */
983 false, /* pc_relative. */
985 complain_overflow_dont
, /* complain_on_overflow. */
986 _bfd_elf_rel_vtable_reloc_fn
, /* special_function. */
987 "R_BFIN_GNU_VTENTRY", /* name. */
988 false, /* partial_inplace. */
991 false) /* pcrel_offset. */
994 struct bfin_reloc_map
996 bfd_reloc_code_real_type bfd_reloc_val
;
997 unsigned int bfin_reloc_val
;
1000 static const struct bfin_reloc_map bfin_reloc_map
[] =
1002 { BFD_RELOC_NONE
, R_BFIN_UNUSED0
},
1003 { BFD_RELOC_BFIN_5_PCREL
, R_BFIN_PCREL5M2
},
1004 { BFD_RELOC_NONE
, R_BFIN_UNUSED1
},
1005 { BFD_RELOC_BFIN_10_PCREL
, R_BFIN_PCREL10
},
1006 { BFD_RELOC_BFIN_12_PCREL_JUMP
, R_BFIN_PCREL12_JUMP
},
1007 { BFD_RELOC_BFIN_16_IMM
, R_BFIN_RIMM16
},
1008 { BFD_RELOC_BFIN_16_LOW
, R_BFIN_LUIMM16
},
1009 { BFD_RELOC_BFIN_16_HIGH
, R_BFIN_HUIMM16
},
1010 { BFD_RELOC_BFIN_12_PCREL_JUMP_S
, R_BFIN_PCREL12_JUMP_S
},
1011 { BFD_RELOC_24_PCREL
, R_BFIN_PCREL24
},
1012 { BFD_RELOC_24_PCREL
, R_BFIN_PCREL24
},
1013 { BFD_RELOC_BFIN_24_PCREL_JUMP_L
, R_BFIN_PCREL24_JUMP_L
},
1014 { BFD_RELOC_NONE
, R_BFIN_UNUSEDB
},
1015 { BFD_RELOC_NONE
, R_BFIN_UNUSEDC
},
1016 { BFD_RELOC_BFIN_24_PCREL_CALL_X
, R_BFIN_PCREL24_CALL_X
},
1017 { BFD_RELOC_8
, R_BFIN_BYTE_DATA
},
1018 { BFD_RELOC_16
, R_BFIN_BYTE2_DATA
},
1019 { BFD_RELOC_32
, R_BFIN_BYTE4_DATA
},
1020 { BFD_RELOC_BFIN_11_PCREL
, R_BFIN_PCREL11
},
1021 { BFD_RELOC_BFIN_GOT
, R_BFIN_GOT
},
1022 { BFD_RELOC_BFIN_PLTPC
, R_BFIN_PLTPC
},
1024 { BFD_RELOC_BFIN_GOT17M4
, R_BFIN_GOT17M4
},
1025 { BFD_RELOC_BFIN_GOTHI
, R_BFIN_GOTHI
},
1026 { BFD_RELOC_BFIN_GOTLO
, R_BFIN_GOTLO
},
1027 { BFD_RELOC_BFIN_FUNCDESC
, R_BFIN_FUNCDESC
},
1028 { BFD_RELOC_BFIN_FUNCDESC_GOT17M4
, R_BFIN_FUNCDESC_GOT17M4
},
1029 { BFD_RELOC_BFIN_FUNCDESC_GOTHI
, R_BFIN_FUNCDESC_GOTHI
},
1030 { BFD_RELOC_BFIN_FUNCDESC_GOTLO
, R_BFIN_FUNCDESC_GOTLO
},
1031 { BFD_RELOC_BFIN_FUNCDESC_VALUE
, R_BFIN_FUNCDESC_VALUE
},
1032 { BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4
, R_BFIN_FUNCDESC_GOTOFF17M4
},
1033 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI
, R_BFIN_FUNCDESC_GOTOFFHI
},
1034 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO
, R_BFIN_FUNCDESC_GOTOFFLO
},
1035 { BFD_RELOC_BFIN_GOTOFF17M4
, R_BFIN_GOTOFF17M4
},
1036 { BFD_RELOC_BFIN_GOTOFFHI
, R_BFIN_GOTOFFHI
},
1037 { BFD_RELOC_BFIN_GOTOFFLO
, R_BFIN_GOTOFFLO
},
1039 { BFD_RELOC_VTABLE_INHERIT
, R_BFIN_GNU_VTINHERIT
},
1040 { BFD_RELOC_VTABLE_ENTRY
, R_BFIN_GNU_VTENTRY
},
1045 bfin_info_to_howto (bfd
*abfd
,
1047 Elf_Internal_Rela
*dst
)
1049 unsigned int r_type
;
1051 r_type
= ELF32_R_TYPE (dst
->r_info
);
1053 if (r_type
<= BFIN_RELOC_MAX
)
1054 cache_ptr
->howto
= &bfin_howto_table
[r_type
];
1056 else if (r_type
>= BFIN_GNUEXT_RELOC_MIN
&& r_type
<= BFIN_GNUEXT_RELOC_MAX
)
1057 cache_ptr
->howto
= &bfin_gnuext_howto_table
[r_type
- BFIN_GNUEXT_RELOC_MIN
];
1061 /* xgettext:c-format */
1062 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
1064 bfd_set_error (bfd_error_bad_value
);
1071 /* Given a BFD reloc type, return the howto. */
1072 static reloc_howto_type
*
1073 bfin_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
1074 bfd_reloc_code_real_type code
)
1077 unsigned int r_type
= (unsigned int) -1;
1079 for (i
= sizeof (bfin_reloc_map
) / sizeof (bfin_reloc_map
[0]); i
--;)
1080 if (bfin_reloc_map
[i
].bfd_reloc_val
== code
)
1081 r_type
= bfin_reloc_map
[i
].bfin_reloc_val
;
1083 if (r_type
<= BFIN_RELOC_MAX
)
1084 return &bfin_howto_table
[r_type
];
1086 else if (r_type
>= BFIN_GNUEXT_RELOC_MIN
&& r_type
<= BFIN_GNUEXT_RELOC_MAX
)
1087 return &bfin_gnuext_howto_table
[r_type
- BFIN_GNUEXT_RELOC_MIN
];
1089 return (reloc_howto_type
*) NULL
;
1092 static reloc_howto_type
*
1093 bfin_bfd_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1099 i
< (sizeof (bfin_howto_table
)
1100 / sizeof (bfin_howto_table
[0]));
1102 if (bfin_howto_table
[i
].name
!= NULL
1103 && strcasecmp (bfin_howto_table
[i
].name
, r_name
) == 0)
1104 return &bfin_howto_table
[i
];
1107 i
< (sizeof (bfin_gnuext_howto_table
)
1108 / sizeof (bfin_gnuext_howto_table
[0]));
1110 if (bfin_gnuext_howto_table
[i
].name
!= NULL
1111 && strcasecmp (bfin_gnuext_howto_table
[i
].name
, r_name
) == 0)
1112 return &bfin_gnuext_howto_table
[i
];
1117 /* Given a bfin relocation type, return the howto. */
1118 static reloc_howto_type
*
1119 bfin_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
1120 unsigned int r_type
)
1122 if (r_type
<= BFIN_RELOC_MAX
)
1123 return &bfin_howto_table
[r_type
];
1125 else if (r_type
>= BFIN_GNUEXT_RELOC_MIN
&& r_type
<= BFIN_GNUEXT_RELOC_MAX
)
1126 return &bfin_gnuext_howto_table
[r_type
- BFIN_GNUEXT_RELOC_MIN
];
1128 return (reloc_howto_type
*) NULL
;
1131 /* Set by ld emulation if --code-in-l1. */
1132 bool elf32_bfin_code_in_l1
= 0;
1134 /* Set by ld emulation if --data-in-l1. */
1135 bool elf32_bfin_data_in_l1
= 0;
1138 elf32_bfin_final_write_processing (bfd
*abfd
)
1140 if (elf32_bfin_code_in_l1
)
1141 elf_elfheader (abfd
)->e_flags
|= EF_BFIN_CODE_IN_L1
;
1142 if (elf32_bfin_data_in_l1
)
1143 elf_elfheader (abfd
)->e_flags
|= EF_BFIN_DATA_IN_L1
;
1144 return _bfd_elf_final_write_processing (abfd
);
1147 /* Return TRUE if the name is a local label.
1148 bfin local labels begin with L$. */
1150 bfin_is_local_label_name (bfd
*abfd
, const char *label
)
1152 if (label
[0] == 'L' && label
[1] == '$' )
1155 return _bfd_elf_is_local_label_name (abfd
, label
);
1158 /* Look through the relocs for a section during the first phase, and
1159 allocate space in the global offset table or procedure linkage
1163 bfin_check_relocs (bfd
* abfd
,
1164 struct bfd_link_info
*info
,
1166 const Elf_Internal_Rela
*relocs
)
1169 Elf_Internal_Shdr
*symtab_hdr
;
1170 struct elf_link_hash_entry
**sym_hashes
;
1171 bfd_signed_vma
*local_got_refcounts
;
1172 const Elf_Internal_Rela
*rel
;
1173 const Elf_Internal_Rela
*rel_end
;
1177 if (bfd_link_relocatable (info
))
1180 dynobj
= elf_hash_table (info
)->dynobj
;
1181 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1182 sym_hashes
= elf_sym_hashes (abfd
);
1183 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1188 rel_end
= relocs
+ sec
->reloc_count
;
1189 for (rel
= relocs
; rel
< rel_end
; rel
++)
1191 unsigned long r_symndx
;
1192 struct elf_link_hash_entry
*h
;
1194 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1195 if (r_symndx
< symtab_hdr
->sh_info
)
1199 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1200 while (h
->root
.type
== bfd_link_hash_indirect
1201 || h
->root
.type
== bfd_link_hash_warning
)
1202 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
1205 switch (ELF32_R_TYPE (rel
->r_info
))
1207 /* This relocation describes the C++ object vtable hierarchy.
1208 Reconstruct it for later use during GC. */
1209 case R_BFIN_GNU_VTINHERIT
:
1210 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1214 /* This relocation describes which C++ vtable entries
1215 are actually used. Record for later use during GC. */
1216 case R_BFIN_GNU_VTENTRY
:
1217 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1223 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1229 /* Create the .got section. */
1230 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1231 if (!_bfd_elf_create_got_section (dynobj
, info
))
1235 sgot
= elf_hash_table (info
)->sgot
;
1236 srelgot
= elf_hash_table (info
)->srelgot
;
1237 BFD_ASSERT (sgot
!= NULL
);
1241 if (h
->got
.refcount
== 0)
1243 /* Make sure this symbol is output as a dynamic symbol. */
1244 if (h
->dynindx
== -1 && !h
->forced_local
)
1246 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
1250 /* Allocate space in the .got section. */
1252 /* Allocate relocation space. */
1253 srelgot
->size
+= sizeof (Elf32_External_Rela
);
1259 /* This is a global offset table entry for a local symbol. */
1260 if (local_got_refcounts
== NULL
)
1264 size
= symtab_hdr
->sh_info
;
1265 size
*= sizeof (bfd_signed_vma
);
1266 local_got_refcounts
= ((bfd_signed_vma
*)
1267 bfd_zalloc (abfd
, size
));
1268 if (local_got_refcounts
== NULL
)
1270 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1272 if (local_got_refcounts
[r_symndx
] == 0)
1275 if (bfd_link_pic (info
))
1277 /* If we are generating a shared object, we need to
1278 output a R_68K_RELATIVE reloc so that the dynamic
1279 linker can adjust this GOT entry. */
1280 srelgot
->size
+= sizeof (Elf32_External_Rela
);
1283 local_got_refcounts
[r_symndx
]++;
1295 static enum elf_reloc_type_class
1296 elf32_bfin_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1297 const asection
*rel_sec ATTRIBUTE_UNUSED
,
1298 const Elf_Internal_Rela
* rela
)
1300 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1303 return reloc_class_normal
;
1307 static bfd_reloc_status_type
1308 bfin_final_link_relocate (Elf_Internal_Rela
*rel
, reloc_howto_type
*howto
,
1309 bfd
*input_bfd
, asection
*input_section
,
1310 bfd_byte
*contents
, bfd_vma address
,
1311 bfd_vma value
, bfd_vma addend
)
1313 int r_type
= ELF32_R_TYPE (rel
->r_info
);
1315 if (r_type
== R_BFIN_PCREL24
|| r_type
== R_BFIN_PCREL24_JUMP_L
)
1317 bfd_reloc_status_type r
= bfd_reloc_ok
;
1320 if (address
> bfd_get_section_limit (input_bfd
, input_section
))
1321 return bfd_reloc_outofrange
;
1325 /* Perform usual pc-relative correction. */
1326 value
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
1329 /* We are getting reloc_entry->address 2 byte off from
1330 the start of instruction. Assuming absolute postion
1331 of the reloc data. But, following code had been written assuming
1332 reloc address is starting at begining of instruction.
1333 To compensate that I have increased the value of
1334 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
1339 if ((value
& 0xFF000000) != 0
1340 && (value
& 0xFF000000) != 0xFF000000)
1341 r
= bfd_reloc_overflow
;
1345 x
= bfd_get_16 (input_bfd
, contents
+ address
);
1346 x
= (x
& 0xff00) | ((value
>> 16) & 0xff);
1347 bfd_put_16 (input_bfd
, x
, contents
+ address
);
1349 x
= bfd_get_16 (input_bfd
, contents
+ address
+ 2);
1351 bfd_put_16 (input_bfd
, x
, contents
+ address
+ 2);
1355 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
1356 rel
->r_offset
, value
, addend
);
1361 bfin_relocate_section (bfd
* output_bfd
,
1362 struct bfd_link_info
*info
,
1364 asection
* input_section
,
1365 bfd_byte
* contents
,
1366 Elf_Internal_Rela
* relocs
,
1367 Elf_Internal_Sym
* local_syms
,
1368 asection
** local_sections
)
1371 Elf_Internal_Shdr
*symtab_hdr
;
1372 struct elf_link_hash_entry
**sym_hashes
;
1373 bfd_vma
*local_got_offsets
;
1375 Elf_Internal_Rela
*rel
;
1376 Elf_Internal_Rela
*relend
;
1379 dynobj
= elf_hash_table (info
)->dynobj
;
1380 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1381 sym_hashes
= elf_sym_hashes (input_bfd
);
1382 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1387 relend
= relocs
+ input_section
->reloc_count
;
1388 for (; rel
< relend
; rel
++, i
++)
1391 reloc_howto_type
*howto
;
1392 unsigned long r_symndx
;
1393 struct elf_link_hash_entry
*h
;
1394 Elf_Internal_Sym
*sym
;
1396 bfd_vma relocation
= 0;
1397 bool unresolved_reloc
;
1398 bfd_reloc_status_type r
;
1401 r_type
= ELF32_R_TYPE (rel
->r_info
);
1402 if (r_type
< 0 || r_type
>= 243)
1404 bfd_set_error (bfd_error_bad_value
);
1408 if (r_type
== R_BFIN_GNU_VTENTRY
1409 || r_type
== R_BFIN_GNU_VTINHERIT
)
1412 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
1415 bfd_set_error (bfd_error_bad_value
);
1418 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1423 unresolved_reloc
= false;
1425 if (r_symndx
< symtab_hdr
->sh_info
)
1427 sym
= local_syms
+ r_symndx
;
1428 sec
= local_sections
[r_symndx
];
1429 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1433 bool warned
, ignored
;
1435 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1436 r_symndx
, symtab_hdr
, sym_hashes
,
1438 unresolved_reloc
, warned
, ignored
);
1441 if (sec
!= NULL
&& discarded_section (sec
))
1442 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1443 rel
, 1, relend
, howto
, 0, contents
);
1445 if (bfd_link_relocatable (info
))
1448 address
= rel
->r_offset
;
1450 /* Then, process normally. */
1453 case R_BFIN_GNU_VTINHERIT
:
1454 case R_BFIN_GNU_VTENTRY
:
1455 return bfd_reloc_ok
;
1458 /* Relocation is to the address of the entry for this symbol
1459 in the global offset table. */
1461 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1464 /* Relocation is the offset of the entry for this symbol in
1465 the global offset table. */
1472 /* Create the .got section. */
1473 elf_hash_table (info
)->dynobj
= dynobj
= output_bfd
;
1474 if (!_bfd_elf_create_got_section (dynobj
, info
))
1478 sgot
= elf_hash_table (info
)->sgot
;
1479 BFD_ASSERT (sgot
!= NULL
);
1485 off
= h
->got
.offset
;
1486 BFD_ASSERT (off
!= (bfd_vma
) - 1);
1487 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1489 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
1490 bfd_link_pic (info
),
1492 || (bfd_link_pic (info
)
1498 /* This is actually a static link, or it is a
1499 -Bsymbolic link and the symbol is defined
1500 locally, or the symbol was forced to be local
1501 because of a version file.. We must initialize
1502 this entry in the global offset table. Since
1503 the offset must always be a multiple of 4, we
1504 use the least significant bit to record whether
1505 we have initialized it already.
1507 When doing a dynamic link, we create a .rela.got
1508 relocation entry to initialize the value. This
1509 is done in the finish_dynamic_symbol routine. */
1514 bfd_put_32 (output_bfd
, relocation
,
1515 sgot
->contents
+ off
);
1520 unresolved_reloc
= false;
1524 BFD_ASSERT (local_got_offsets
!= NULL
);
1525 off
= local_got_offsets
[r_symndx
];
1526 BFD_ASSERT (off
!= (bfd_vma
) - 1);
1528 /* The offset must always be a multiple of 4. We use
1529 the least significant bit to record whether we have
1530 already generated the necessary reloc. */
1535 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1537 if (bfd_link_pic (info
))
1540 Elf_Internal_Rela outrel
;
1543 s
= elf_hash_table (info
)->srelgot
;
1544 BFD_ASSERT (s
!= NULL
);
1546 outrel
.r_offset
= (sgot
->output_section
->vma
1547 + sgot
->output_offset
+ off
);
1549 ELF32_R_INFO (0, R_BFIN_PCREL24
);
1550 outrel
.r_addend
= relocation
;
1553 s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1554 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1557 local_got_offsets
[r_symndx
] |= 1;
1561 relocation
= sgot
->output_offset
+ off
;
1563 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */
1570 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
1572 relocation
, rel
->r_addend
);
1577 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1578 because such sections are not SEC_ALLOC and thus ld.so will
1579 not process them. */
1580 if (unresolved_reloc
1581 && !((input_section
->flags
& SEC_DEBUGGING
) != 0 && h
->def_dynamic
)
1582 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1583 rel
->r_offset
) != (bfd_vma
) -1)
1586 /* xgettext:c-format */
1587 (_("%pB(%pA+%#" PRIx64
"): "
1588 "unresolvable relocation against symbol `%s'"),
1589 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
1590 h
->root
.root
.string
);
1594 if (r
!= bfd_reloc_ok
)
1599 name
= h
->root
.root
.string
;
1602 name
= bfd_elf_string_from_elf_section (input_bfd
,
1603 symtab_hdr
->sh_link
,
1608 name
= bfd_section_name (sec
);
1611 if (r
== bfd_reloc_overflow
)
1612 (*info
->callbacks
->reloc_overflow
)
1613 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1614 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1618 /* xgettext:c-format */
1619 (_("%pB(%pA+%#" PRIx64
"): reloc against `%s': error %d"),
1620 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
1631 bfin_gc_mark_hook (asection
* sec
,
1632 struct bfd_link_info
*info
,
1633 Elf_Internal_Rela
* rel
,
1634 struct elf_link_hash_entry
*h
,
1635 Elf_Internal_Sym
* sym
)
1638 switch (ELF32_R_TYPE (rel
->r_info
))
1640 case R_BFIN_GNU_VTINHERIT
:
1641 case R_BFIN_GNU_VTENTRY
:
1645 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1648 extern const bfd_target bfin_elf32_fdpic_vec
;
1649 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfin_elf32_fdpic_vec)
1651 /* An extension of the elf hash table data structure,
1652 containing some additional Blackfin-specific data. */
1653 struct bfinfdpic_elf_link_hash_table
1655 struct elf_link_hash_table elf
;
1657 /* A pointer to the .rofixup section. */
1658 asection
*sgotfixup
;
1659 /* GOT base offset. */
1661 /* Location of the first non-lazy PLT entry, i.e., the number of
1662 bytes taken by lazy PLT entries. */
1664 /* A hash table holding information about which symbols were
1665 referenced with which PIC-related relocations. */
1666 struct htab
*relocs_info
;
1667 /* Summary reloc information collected by
1668 _bfinfdpic_count_got_plt_entries. */
1669 struct _bfinfdpic_dynamic_got_info
*g
;
1672 /* Get the Blackfin ELF linker hash table from a link_info structure. */
1674 #define bfinfdpic_hash_table(p) \
1675 ((is_elf_hash_table ((p)->hash) \
1676 && elf_hash_table_id (elf_hash_table (p)) == BFIN_ELF_DATA) \
1677 ? (struct bfinfdpic_elf_link_hash_table *) (p)->hash : NULL)
1679 #define bfinfdpic_got_section(info) \
1680 (bfinfdpic_hash_table (info)->elf.sgot)
1681 #define bfinfdpic_gotrel_section(info) \
1682 (bfinfdpic_hash_table (info)->elf.srelgot)
1683 #define bfinfdpic_gotfixup_section(info) \
1684 (bfinfdpic_hash_table (info)->sgotfixup)
1685 #define bfinfdpic_plt_section(info) \
1686 (bfinfdpic_hash_table (info)->elf.splt)
1687 #define bfinfdpic_pltrel_section(info) \
1688 (bfinfdpic_hash_table (info)->elf.srelplt)
1689 #define bfinfdpic_relocs_info(info) \
1690 (bfinfdpic_hash_table (info)->relocs_info)
1691 #define bfinfdpic_got_initial_offset(info) \
1692 (bfinfdpic_hash_table (info)->got0)
1693 #define bfinfdpic_plt_initial_offset(info) \
1694 (bfinfdpic_hash_table (info)->plt0)
1695 #define bfinfdpic_dynamic_got_plt_info(info) \
1696 (bfinfdpic_hash_table (info)->g)
1698 /* The name of the dynamic interpreter. This is put in the .interp
1701 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1703 #define DEFAULT_STACK_SIZE 0x20000
1705 /* This structure is used to collect the number of entries present in
1706 each addressable range of the got. */
1707 struct _bfinfdpic_dynamic_got_info
1709 /* Several bits of information about the current link. */
1710 struct bfd_link_info
*info
;
1711 /* Total size needed for GOT entries within the 18- or 32-bit
1713 bfd_vma got17m4
, gothilo
;
1714 /* Total size needed for function descriptor entries within the 18-
1715 or 32-bit ranges. */
1716 bfd_vma fd17m4
, fdhilo
;
1717 /* Total size needed function descriptor entries referenced in PLT
1718 entries, that would be profitable to place in offsets close to
1719 the PIC register. */
1721 /* Total size needed by lazy PLT entries. */
1723 /* Number of relocations carried over from input object files. */
1724 unsigned long relocs
;
1725 /* Number of fixups introduced by relocations in input object files. */
1726 unsigned long fixups
;
1729 /* Create a Blackfin ELF linker hash table. */
1731 static struct bfd_link_hash_table
*
1732 bfinfdpic_elf_link_hash_table_create (bfd
*abfd
)
1734 struct bfinfdpic_elf_link_hash_table
*ret
;
1735 size_t amt
= sizeof (struct bfinfdpic_elf_link_hash_table
);
1737 ret
= bfd_zmalloc (amt
);
1741 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1742 _bfd_elf_link_hash_newfunc
,
1743 sizeof (struct elf_link_hash_entry
),
1750 return &ret
->elf
.root
;
1753 /* Decide whether a reference to a symbol can be resolved locally or
1754 not. If the symbol is protected, we want the local address, but
1755 its function descriptor must be assigned by the dynamic linker. */
1756 #define BFINFDPIC_SYM_LOCAL(INFO, H) \
1757 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1758 || ! elf_hash_table (INFO)->dynamic_sections_created)
1759 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1760 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1762 /* This structure collects information on what kind of GOT, PLT or
1763 function descriptors are required by relocations that reference a
1765 struct bfinfdpic_relocs_info
1767 /* The index of the symbol, as stored in the relocation r_info, if
1768 we have a local symbol; -1 otherwise. */
1772 /* The input bfd in which the symbol is defined, if it's a local
1775 /* If symndx == -1, the hash table entry corresponding to a global
1776 symbol (even if it turns out to bind locally, in which case it
1777 should ideally be replaced with section's symndx + addend). */
1778 struct elf_link_hash_entry
*h
;
1780 /* The addend of the relocation that references the symbol. */
1783 /* The fields above are used to identify an entry. The fields below
1784 contain information on how an entry is used and, later on, which
1785 locations it was assigned. */
1786 /* The following 2 fields record whether the symbol+addend above was
1787 ever referenced with a GOT relocation. The 17M4 suffix indicates a
1788 GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */
1791 /* Whether a FUNCDESC relocation references symbol+addend. */
1793 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1796 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1797 unsigned fdgoff17m4
;
1798 unsigned fdgoffhilo
;
1799 /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1800 GOTOFFHI relocations. The addend doesn't really matter, since we
1801 envision that this will only be used to check whether the symbol
1802 is mapped to the same segment as the got. */
1804 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1806 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1809 /* Whether we need a PLT entry for a symbol. Should be implied by
1811 (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */
1813 /* Whether a function descriptor should be created in this link unit
1814 for symbol+addend. Should be implied by something like:
1815 (plt || fdgotoff17m4 || fdgotofflohi
1816 || ((fd || fdgot17m4 || fdgothilo)
1817 && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1819 /* Whether a lazy PLT entry is needed for this symbol+addend.
1820 Should be implied by something like:
1821 (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1822 && ! (info->flags & DF_BIND_NOW)) */
1824 /* Whether we've already emitted GOT relocations and PLT entries as
1825 needed for this symbol. */
1828 /* The number of R_BFIN_BYTE4_DATA, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1829 relocations referencing the symbol. */
1830 unsigned relocs32
, relocsfd
, relocsfdv
;
1832 /* The number of .rofixups entries and dynamic relocations allocated
1833 for this symbol, minus any that might have already been used. */
1834 unsigned fixups
, dynrelocs
;
1836 /* The offsets of the GOT entries assigned to symbol+addend, to the
1837 function descriptor's address, and to a function descriptor,
1838 respectively. Should be zero if unassigned. The offsets are
1839 counted from the value that will be assigned to the PIC register,
1840 not from the beginning of the .got section. */
1841 bfd_signed_vma got_entry
, fdgot_entry
, fd_entry
;
1842 /* The offsets of the PLT entries assigned to symbol+addend,
1843 non-lazy and lazy, respectively. If unassigned, should be
1845 bfd_vma plt_entry
, lzplt_entry
;
1848 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry. */
1850 bfinfdpic_relocs_info_hash (const void *entry_
)
1852 const struct bfinfdpic_relocs_info
*entry
= entry_
;
1854 return (entry
->symndx
== -1
1855 ? (long) entry
->d
.h
->root
.root
.hash
1856 : entry
->symndx
+ (long) entry
->d
.abfd
->id
* 257) + entry
->addend
;
1859 /* Test whether the key fields of two bfinfdpic_relocs_info entries are
1862 bfinfdpic_relocs_info_eq (const void *entry1
, const void *entry2
)
1864 const struct bfinfdpic_relocs_info
*e1
= entry1
;
1865 const struct bfinfdpic_relocs_info
*e2
= entry2
;
1867 return e1
->symndx
== e2
->symndx
&& e1
->addend
== e2
->addend
1868 && (e1
->symndx
== -1 ? e1
->d
.h
== e2
->d
.h
: e1
->d
.abfd
== e2
->d
.abfd
);
1871 /* Find or create an entry in a hash table HT that matches the key
1872 fields of the given ENTRY. If it's not found, memory for a new
1873 entry is allocated in ABFD's obstack. */
1874 static struct bfinfdpic_relocs_info
*
1875 bfinfdpic_relocs_info_find (struct htab
*ht
,
1877 const struct bfinfdpic_relocs_info
*entry
,
1878 enum insert_option insert
)
1880 struct bfinfdpic_relocs_info
**loc
;
1885 loc
= (struct bfinfdpic_relocs_info
**) htab_find_slot (ht
, entry
, insert
);
1893 *loc
= bfd_zalloc (abfd
, sizeof (**loc
));
1898 (*loc
)->symndx
= entry
->symndx
;
1899 (*loc
)->d
= entry
->d
;
1900 (*loc
)->addend
= entry
->addend
;
1901 (*loc
)->plt_entry
= (bfd_vma
)-1;
1902 (*loc
)->lzplt_entry
= (bfd_vma
)-1;
1907 /* Obtain the address of the entry in HT associated with H's symbol +
1908 addend, creating a new entry if none existed. ABFD is only used
1909 for memory allocation purposes. */
1910 inline static struct bfinfdpic_relocs_info
*
1911 bfinfdpic_relocs_info_for_global (struct htab
*ht
,
1913 struct elf_link_hash_entry
*h
,
1915 enum insert_option insert
)
1917 struct bfinfdpic_relocs_info entry
;
1921 entry
.addend
= addend
;
1923 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1926 /* Obtain the address of the entry in HT associated with the SYMNDXth
1927 local symbol of the input bfd ABFD, plus the addend, creating a new
1928 entry if none existed. */
1929 inline static struct bfinfdpic_relocs_info
*
1930 bfinfdpic_relocs_info_for_local (struct htab
*ht
,
1934 enum insert_option insert
)
1936 struct bfinfdpic_relocs_info entry
;
1938 entry
.symndx
= symndx
;
1939 entry
.d
.abfd
= abfd
;
1940 entry
.addend
= addend
;
1942 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1945 /* Merge fields set by check_relocs() of two entries that end up being
1946 mapped to the same (presumably global) symbol. */
1949 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info
*e2
,
1950 struct bfinfdpic_relocs_info
const *e1
)
1952 e2
->got17m4
|= e1
->got17m4
;
1953 e2
->gothilo
|= e1
->gothilo
;
1955 e2
->fdgot17m4
|= e1
->fdgot17m4
;
1956 e2
->fdgothilo
|= e1
->fdgothilo
;
1957 e2
->fdgoff17m4
|= e1
->fdgoff17m4
;
1958 e2
->fdgoffhilo
|= e1
->fdgoffhilo
;
1959 e2
->gotoff
|= e1
->gotoff
;
1960 e2
->call
|= e1
->call
;
1964 /* Every block of 65535 lazy PLT entries shares a single call to the
1965 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1966 32767, counting from 0). All other lazy PLT entries branch to it
1967 in a single instruction. */
1969 #define LZPLT_RESOLVER_EXTRA 10
1970 #define LZPLT_NORMAL_SIZE 6
1971 #define LZPLT_ENTRIES 1362
1973 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
1974 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
1976 /* Add a dynamic relocation to the SRELOC section. */
1978 inline static bfd_vma
1979 _bfinfdpic_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
1980 int reloc_type
, long dynindx
, bfd_vma addend
,
1981 struct bfinfdpic_relocs_info
*entry
)
1983 Elf_Internal_Rela outrel
;
1984 bfd_vma reloc_offset
;
1986 outrel
.r_offset
= offset
;
1987 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
1988 outrel
.r_addend
= addend
;
1990 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rel
);
1991 BFD_ASSERT (reloc_offset
< sreloc
->size
);
1992 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1993 sreloc
->contents
+ reloc_offset
);
1994 sreloc
->reloc_count
++;
1996 /* If the entry's index is zero, this relocation was probably to a
1997 linkonce section that got discarded. We reserved a dynamic
1998 relocation, but it was for another entry than the one we got at
1999 the time of emitting the relocation. Unfortunately there's no
2000 simple way for us to catch this situation, since the relocation
2001 is cleared right before calling relocate_section, at which point
2002 we no longer know what the relocation used to point to. */
2005 BFD_ASSERT (entry
->dynrelocs
> 0);
2009 return reloc_offset
;
2012 /* Add a fixup to the ROFIXUP section. */
2015 _bfinfdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma offset
,
2016 struct bfinfdpic_relocs_info
*entry
)
2018 bfd_vma fixup_offset
;
2020 if (rofixup
->flags
& SEC_EXCLUDE
)
2023 fixup_offset
= rofixup
->reloc_count
* 4;
2024 if (rofixup
->contents
)
2026 BFD_ASSERT (fixup_offset
< rofixup
->size
);
2027 bfd_put_32 (output_bfd
, offset
, rofixup
->contents
+ fixup_offset
);
2029 rofixup
->reloc_count
++;
2031 if (entry
&& entry
->symndx
)
2033 /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
2035 BFD_ASSERT (entry
->fixups
> 0);
2039 return fixup_offset
;
2042 /* Find the segment number in which OSEC, and output section, is
2046 _bfinfdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
2048 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
2050 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
2054 _bfinfdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
2056 unsigned seg
= _bfinfdpic_osec_to_segment (output_bfd
, osec
);
2058 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
2061 /* Generate relocations for GOT entries, function descriptors, and
2062 code for PLT and lazy PLT entries. */
2065 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info
*entry
,
2067 struct bfd_link_info
*info
,
2069 Elf_Internal_Sym
*sym
,
2072 bfd_vma fd_lazy_rel_offset
= (bfd_vma
) -1;
2079 if (entry
->got_entry
|| entry
->fdgot_entry
|| entry
->fd_entry
)
2081 /* If the symbol is dynamic, consider it for dynamic
2082 relocations, otherwise decay to section + offset. */
2083 if (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1)
2084 dynindx
= entry
->d
.h
->dynindx
;
2088 && sec
->output_section
2089 && ! bfd_is_abs_section (sec
->output_section
)
2090 && ! bfd_is_und_section (sec
->output_section
))
2091 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
2097 /* Generate relocation for GOT entry pointing to the symbol. */
2098 if (entry
->got_entry
)
2101 bfd_vma ad
= addend
;
2103 /* If the symbol is dynamic but binds locally, use
2105 if (sec
&& (entry
->symndx
!= -1
2106 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2108 if (entry
->symndx
== -1)
2109 ad
+= entry
->d
.h
->root
.u
.def
.value
;
2111 ad
+= sym
->st_value
;
2112 ad
+= sec
->output_offset
;
2113 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
2114 idx
= elf_section_data (sec
->output_section
)->dynindx
;
2119 /* If we're linking an executable at a fixed address, we can
2120 omit the dynamic relocation as long as the symbol is local to
2122 if (bfd_link_pde (info
)
2123 && (entry
->symndx
!= -1
2124 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2127 ad
+= sec
->output_section
->vma
;
2128 if (entry
->symndx
!= -1
2129 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
2130 _bfinfdpic_add_rofixup (output_bfd
,
2131 bfinfdpic_gotfixup_section (info
),
2132 bfinfdpic_got_section (info
)->output_section
2134 + bfinfdpic_got_section (info
)->output_offset
2135 + bfinfdpic_got_initial_offset (info
)
2136 + entry
->got_entry
, entry
);
2139 _bfinfdpic_add_dyn_reloc (output_bfd
, bfinfdpic_gotrel_section (info
),
2140 _bfd_elf_section_offset
2142 bfinfdpic_got_section (info
),
2143 bfinfdpic_got_initial_offset (info
)
2145 + bfinfdpic_got_section (info
)
2146 ->output_section
->vma
2147 + bfinfdpic_got_section (info
)->output_offset
,
2148 R_BFIN_BYTE4_DATA
, idx
, ad
, entry
);
2150 bfd_put_32 (output_bfd
, ad
,
2151 bfinfdpic_got_section (info
)->contents
2152 + bfinfdpic_got_initial_offset (info
)
2153 + entry
->got_entry
);
2156 /* Generate relocation for GOT entry pointing to a canonical
2157 function descriptor. */
2158 if (entry
->fdgot_entry
)
2163 if (! (entry
->symndx
== -1
2164 && entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
2165 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2167 /* If the symbol is dynamic and there may be dynamic symbol
2168 resolution because we are, or are linked with, a shared
2169 library, emit a FUNCDESC relocation such that the dynamic
2170 linker will allocate the function descriptor. If the
2171 symbol needs a non-local function descriptor but binds
2172 locally (e.g., its visibility is protected, emit a
2173 dynamic relocation decayed to section+offset. */
2174 if (entry
->symndx
== -1
2175 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)
2176 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)
2177 && !bfd_link_pde (info
))
2179 reloc
= R_BFIN_FUNCDESC
;
2180 idx
= elf_section_data (entry
->d
.h
->root
.u
.def
.section
2181 ->output_section
)->dynindx
;
2182 ad
= entry
->d
.h
->root
.u
.def
.section
->output_offset
2183 + entry
->d
.h
->root
.u
.def
.value
;
2185 else if (entry
->symndx
== -1
2186 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
))
2188 reloc
= R_BFIN_FUNCDESC
;
2196 /* Otherwise, we know we have a private function descriptor,
2197 so reference it directly. */
2198 if (elf_hash_table (info
)->dynamic_sections_created
)
2199 BFD_ASSERT (entry
->privfd
);
2200 reloc
= R_BFIN_BYTE4_DATA
;
2201 idx
= elf_section_data (bfinfdpic_got_section (info
)
2202 ->output_section
)->dynindx
;
2203 ad
= bfinfdpic_got_section (info
)->output_offset
2204 + bfinfdpic_got_initial_offset (info
) + entry
->fd_entry
;
2207 /* If there is room for dynamic symbol resolution, emit the
2208 dynamic relocation. However, if we're linking an
2209 executable at a fixed location, we won't have emitted a
2210 dynamic symbol entry for the got section, so idx will be
2211 zero, which means we can and should compute the address
2212 of the private descriptor ourselves. */
2213 if (bfd_link_pde (info
)
2214 && (entry
->symndx
!= -1
2215 || BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)))
2217 ad
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2218 _bfinfdpic_add_rofixup (output_bfd
,
2219 bfinfdpic_gotfixup_section (info
),
2220 bfinfdpic_got_section (info
)
2221 ->output_section
->vma
2222 + bfinfdpic_got_section (info
)
2224 + bfinfdpic_got_initial_offset (info
)
2225 + entry
->fdgot_entry
, entry
);
2228 _bfinfdpic_add_dyn_reloc (output_bfd
,
2229 bfinfdpic_gotrel_section (info
),
2230 _bfd_elf_section_offset
2232 bfinfdpic_got_section (info
),
2233 bfinfdpic_got_initial_offset (info
)
2234 + entry
->fdgot_entry
)
2235 + bfinfdpic_got_section (info
)
2236 ->output_section
->vma
2237 + bfinfdpic_got_section (info
)
2239 reloc
, idx
, ad
, entry
);
2242 bfd_put_32 (output_bfd
, ad
,
2243 bfinfdpic_got_section (info
)->contents
2244 + bfinfdpic_got_initial_offset (info
)
2245 + entry
->fdgot_entry
);
2248 /* Generate relocation to fill in a private function descriptor in
2250 if (entry
->fd_entry
)
2253 bfd_vma ad
= addend
;
2255 long lowword
, highword
;
2257 /* If the symbol is dynamic but binds locally, use
2259 if (sec
&& (entry
->symndx
!= -1
2260 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2262 if (entry
->symndx
== -1)
2263 ad
+= entry
->d
.h
->root
.u
.def
.value
;
2265 ad
+= sym
->st_value
;
2266 ad
+= sec
->output_offset
;
2267 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
2268 idx
= elf_section_data (sec
->output_section
)->dynindx
;
2273 /* If we're linking an executable at a fixed address, we can
2274 omit the dynamic relocation as long as the symbol is local to
2276 if (bfd_link_pde (info
)
2277 && (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2280 ad
+= sec
->output_section
->vma
;
2282 if (entry
->symndx
!= -1
2283 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
2285 _bfinfdpic_add_rofixup (output_bfd
,
2286 bfinfdpic_gotfixup_section (info
),
2287 bfinfdpic_got_section (info
)
2288 ->output_section
->vma
2289 + bfinfdpic_got_section (info
)
2291 + bfinfdpic_got_initial_offset (info
)
2292 + entry
->fd_entry
, entry
);
2293 _bfinfdpic_add_rofixup (output_bfd
,
2294 bfinfdpic_gotfixup_section (info
),
2295 bfinfdpic_got_section (info
)
2296 ->output_section
->vma
2297 + bfinfdpic_got_section (info
)
2299 + bfinfdpic_got_initial_offset (info
)
2300 + entry
->fd_entry
+ 4, entry
);
2306 = _bfinfdpic_add_dyn_reloc (output_bfd
,
2308 ? bfinfdpic_pltrel_section (info
)
2309 : bfinfdpic_gotrel_section (info
),
2310 _bfd_elf_section_offset
2312 bfinfdpic_got_section (info
),
2313 bfinfdpic_got_initial_offset (info
)
2315 + bfinfdpic_got_section (info
)
2316 ->output_section
->vma
2317 + bfinfdpic_got_section (info
)
2319 R_BFIN_FUNCDESC_VALUE
, idx
, ad
, entry
);
2322 /* If we've omitted the dynamic relocation, just emit the fixed
2323 addresses of the symbol and of the local GOT base offset. */
2324 if (bfd_link_pde (info
)
2326 && sec
->output_section
)
2329 highword
= bfinfdpic_got_section (info
)->output_section
->vma
2330 + bfinfdpic_got_section (info
)->output_offset
2331 + bfinfdpic_got_initial_offset (info
);
2333 else if (entry
->lazyplt
)
2338 fd_lazy_rel_offset
= ofst
;
2340 /* A function descriptor used for lazy or local resolving is
2341 initialized such that its high word contains the output
2342 section index in which the PLT entries are located, and
2343 the low word contains the address of the lazy PLT entry
2344 entry point, that must be within the memory region
2345 assigned to that section. */
2346 lowword
= entry
->lzplt_entry
+ 4
2347 + bfinfdpic_plt_section (info
)->output_offset
2348 + bfinfdpic_plt_section (info
)->output_section
->vma
;
2349 highword
= _bfinfdpic_osec_to_segment
2350 (output_bfd
, bfinfdpic_plt_section (info
)->output_section
);
2354 /* A function descriptor for a local function gets the index
2355 of the section. For a non-local function, it's
2359 || (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1
2360 && entry
->d
.h
->dynindx
== idx
))
2363 highword
= _bfinfdpic_osec_to_segment
2364 (output_bfd
, sec
->output_section
);
2367 bfd_put_32 (output_bfd
, lowword
,
2368 bfinfdpic_got_section (info
)->contents
2369 + bfinfdpic_got_initial_offset (info
)
2371 bfd_put_32 (output_bfd
, highword
,
2372 bfinfdpic_got_section (info
)->contents
2373 + bfinfdpic_got_initial_offset (info
)
2374 + entry
->fd_entry
+ 4);
2377 /* Generate code for the PLT entry. */
2378 if (entry
->plt_entry
!= (bfd_vma
) -1)
2380 bfd_byte
*plt_code
= bfinfdpic_plt_section (info
)->contents
2383 BFD_ASSERT (entry
->fd_entry
);
2385 /* Figure out what kind of PLT entry we need, depending on the
2386 location of the function descriptor within the GOT. */
2387 if (entry
->fd_entry
>= -(1 << (18 - 1))
2388 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
2390 /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
2391 bfd_put_32 (output_bfd
,
2392 0xe519 | ((entry
->fd_entry
<< 14) & 0xFFFF0000),
2394 bfd_put_32 (output_bfd
,
2395 0xe51b | (((entry
->fd_entry
+ 4) << 14) & 0xFFFF0000),
2401 /* P1.L = fd_entry; P1.H = fd_entry;
2405 bfd_put_32 (output_bfd
,
2406 0xe109 | (entry
->fd_entry
<< 16),
2408 bfd_put_32 (output_bfd
,
2409 0xe149 | (entry
->fd_entry
& 0xFFFF0000),
2411 bfd_put_16 (output_bfd
, 0x5ad9, plt_code
+ 8);
2412 bfd_put_16 (output_bfd
, 0x9159, plt_code
+ 10);
2413 bfd_put_16 (output_bfd
, 0xac5b, plt_code
+ 12);
2417 bfd_put_16 (output_bfd
, 0x0051, plt_code
);
2420 /* Generate code for the lazy PLT entry. */
2421 if (entry
->lzplt_entry
!= (bfd_vma
) -1)
2423 bfd_byte
*lzplt_code
= bfinfdpic_plt_section (info
)->contents
2424 + entry
->lzplt_entry
;
2425 bfd_vma resolverStub_addr
;
2427 bfd_put_32 (output_bfd
, fd_lazy_rel_offset
, lzplt_code
);
2430 resolverStub_addr
= entry
->lzplt_entry
/ BFINFDPIC_LZPLT_BLOCK_SIZE
2431 * BFINFDPIC_LZPLT_BLOCK_SIZE
+ BFINFDPIC_LZPLT_RESOLV_LOC
;
2432 if (resolverStub_addr
>= bfinfdpic_plt_initial_offset (info
))
2433 resolverStub_addr
= bfinfdpic_plt_initial_offset (info
) - LZPLT_NORMAL_SIZE
- LZPLT_RESOLVER_EXTRA
;
2435 if (entry
->lzplt_entry
== resolverStub_addr
)
2437 /* This is a lazy PLT entry that includes a resolver call.
2441 bfd_put_32 (output_bfd
,
2444 bfd_put_16 (output_bfd
, 0x0052, lzplt_code
+ 4);
2448 /* JUMP.S resolverStub */
2449 bfd_put_16 (output_bfd
,
2451 | (((resolverStub_addr
- entry
->lzplt_entry
)
2452 / 2) & (((bfd_vma
)1 << 12) - 1)),
2460 /* Relocate an Blackfin ELF section.
2462 The RELOCATE_SECTION function is called by the new ELF backend linker
2463 to handle the relocations for a section.
2465 The relocs are always passed as Rela structures; if the section
2466 actually uses Rel structures, the r_addend field will always be
2469 This function is responsible for adjusting the section contents as
2470 necessary, and (if using Rela relocs and generating a relocatable
2471 output file) adjusting the reloc addend as necessary.
2473 This function does not have to worry about setting the reloc
2474 address or the reloc symbol index.
2476 LOCAL_SYMS is a pointer to the swapped in local symbols.
2478 LOCAL_SECTIONS is an array giving the section in the input file
2479 corresponding to the st_shndx field of each local symbol.
2481 The global hash table entry for the global symbols can be found
2482 via elf_sym_hashes (input_bfd).
2484 When generating relocatable output, this function must handle
2485 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2486 going to be the section symbol corresponding to the output
2487 section, which means that the addend must be adjusted
2491 bfinfdpic_relocate_section (bfd
* output_bfd
,
2492 struct bfd_link_info
*info
,
2494 asection
* input_section
,
2495 bfd_byte
* contents
,
2496 Elf_Internal_Rela
* relocs
,
2497 Elf_Internal_Sym
* local_syms
,
2498 asection
** local_sections
)
2500 Elf_Internal_Shdr
*symtab_hdr
;
2501 struct elf_link_hash_entry
**sym_hashes
;
2502 Elf_Internal_Rela
*rel
;
2503 Elf_Internal_Rela
*relend
;
2504 unsigned isec_segment
, got_segment
, plt_segment
,
2506 int silence_segment_error
= !bfd_link_pic (info
);
2508 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2509 sym_hashes
= elf_sym_hashes (input_bfd
);
2510 relend
= relocs
+ input_section
->reloc_count
;
2512 isec_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2513 input_section
->output_section
);
2514 if (IS_FDPIC (output_bfd
) && bfinfdpic_got_section (info
))
2515 got_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2516 bfinfdpic_got_section (info
)
2520 if (IS_FDPIC (output_bfd
) && elf_hash_table (info
)->dynamic_sections_created
)
2521 plt_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2522 bfinfdpic_plt_section (info
)
2527 for (rel
= relocs
; rel
< relend
; rel
++)
2529 reloc_howto_type
*howto
;
2530 unsigned long r_symndx
;
2531 Elf_Internal_Sym
*sym
;
2533 struct elf_link_hash_entry
*h
;
2535 bfd_reloc_status_type r
;
2536 const char * name
= NULL
;
2539 struct bfinfdpic_relocs_info
*picrel
;
2540 bfd_vma orig_addend
= rel
->r_addend
;
2542 r_type
= ELF32_R_TYPE (rel
->r_info
);
2544 if (r_type
== R_BFIN_GNU_VTINHERIT
2545 || r_type
== R_BFIN_GNU_VTENTRY
)
2548 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2549 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
2552 bfd_set_error (bfd_error_bad_value
);
2561 if (r_symndx
< symtab_hdr
->sh_info
)
2563 sym
= local_syms
+ r_symndx
;
2564 osec
= sec
= local_sections
[r_symndx
];
2565 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2567 name
= bfd_elf_string_from_elf_section
2568 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2569 name
= name
== NULL
? bfd_section_name (sec
) : name
;
2573 bool warned
, ignored
;
2574 bool unresolved_reloc
;
2576 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2577 r_symndx
, symtab_hdr
, sym_hashes
,
2579 unresolved_reloc
, warned
, ignored
);
2583 if (sec
!= NULL
&& discarded_section (sec
))
2584 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2585 rel
, 1, relend
, howto
, 0, contents
);
2587 if (bfd_link_relocatable (info
))
2591 && (h
->root
.type
== bfd_link_hash_defined
2592 || h
->root
.type
== bfd_link_hash_defweak
)
2593 && !BFINFDPIC_SYM_LOCAL (info
, h
))
2601 case R_BFIN_PCREL24
:
2602 case R_BFIN_PCREL24_JUMP_L
:
2603 case R_BFIN_BYTE4_DATA
:
2604 if (! IS_FDPIC (output_bfd
))
2608 case R_BFIN_GOT17M4
:
2611 case R_BFIN_FUNCDESC_GOT17M4
:
2612 case R_BFIN_FUNCDESC_GOTHI
:
2613 case R_BFIN_FUNCDESC_GOTLO
:
2614 case R_BFIN_GOTOFF17M4
:
2615 case R_BFIN_GOTOFFHI
:
2616 case R_BFIN_GOTOFFLO
:
2617 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2618 case R_BFIN_FUNCDESC_GOTOFFHI
:
2619 case R_BFIN_FUNCDESC_GOTOFFLO
:
2620 case R_BFIN_FUNCDESC
:
2621 case R_BFIN_FUNCDESC_VALUE
:
2622 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2626 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2627 (info
), input_bfd
, h
,
2628 orig_addend
, INSERT
);
2630 /* In order to find the entry we created before, we must
2631 use the original addend, not the one that may have been
2632 modified by _bfd_elf_rela_local_sym(). */
2633 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2634 (info
), input_bfd
, r_symndx
,
2635 orig_addend
, INSERT
);
2639 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel
, output_bfd
, info
,
2644 /* xgettext:c-format */
2645 (_("%pB: relocation at `%pA+%#" PRIx64
"' "
2646 "references symbol `%s' with nonzero addend"),
2647 input_bfd
, input_section
, (uint64_t) rel
->r_offset
, name
);
2657 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
2658 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2659 rel
->r_offset
) != (bfd_vma
) -1)
2661 info
->callbacks
->warning
2662 (info
, _("relocation references symbol not defined in the module"),
2663 name
, input_bfd
, input_section
, rel
->r_offset
);
2671 case R_BFIN_PCREL24
:
2672 case R_BFIN_PCREL24_JUMP_L
:
2673 check_segment
[0] = isec_segment
;
2674 if (! IS_FDPIC (output_bfd
))
2675 check_segment
[1] = isec_segment
;
2676 else if (picrel
->plt
)
2678 relocation
= bfinfdpic_plt_section (info
)->output_section
->vma
2679 + bfinfdpic_plt_section (info
)->output_offset
2680 + picrel
->plt_entry
;
2681 check_segment
[1] = plt_segment
;
2683 /* We don't want to warn on calls to undefined weak symbols,
2684 as calls to them must be protected by non-NULL tests
2685 anyway, and unprotected calls would invoke undefined
2687 else if (picrel
->symndx
== -1
2688 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefweak
)
2689 check_segment
[1] = check_segment
[0];
2691 check_segment
[1] = sec
2692 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2696 case R_BFIN_GOT17M4
:
2699 relocation
= picrel
->got_entry
;
2700 check_segment
[0] = check_segment
[1] = got_segment
;
2703 case R_BFIN_FUNCDESC_GOT17M4
:
2704 case R_BFIN_FUNCDESC_GOTHI
:
2705 case R_BFIN_FUNCDESC_GOTLO
:
2706 relocation
= picrel
->fdgot_entry
;
2707 check_segment
[0] = check_segment
[1] = got_segment
;
2710 case R_BFIN_GOTOFFHI
:
2711 case R_BFIN_GOTOFF17M4
:
2712 case R_BFIN_GOTOFFLO
:
2713 relocation
-= bfinfdpic_got_section (info
)->output_section
->vma
2714 + bfinfdpic_got_section (info
)->output_offset
2715 + bfinfdpic_got_initial_offset (info
);
2716 check_segment
[0] = got_segment
;
2717 check_segment
[1] = sec
2718 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2722 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2723 case R_BFIN_FUNCDESC_GOTOFFHI
:
2724 case R_BFIN_FUNCDESC_GOTOFFLO
:
2725 relocation
= picrel
->fd_entry
;
2726 check_segment
[0] = check_segment
[1] = got_segment
;
2729 case R_BFIN_FUNCDESC
:
2730 if ((input_section
->flags
& SEC_ALLOC
) != 0)
2733 bfd_vma addend
= rel
->r_addend
;
2735 if (! (h
&& h
->root
.type
== bfd_link_hash_undefweak
2736 && BFINFDPIC_SYM_LOCAL (info
, h
)))
2738 /* If the symbol is dynamic and there may be dynamic
2739 symbol resolution because we are or are linked with a
2740 shared library, emit a FUNCDESC relocation such that
2741 the dynamic linker will allocate the function
2742 descriptor. If the symbol needs a non-local function
2743 descriptor but binds locally (e.g., its visibility is
2744 protected, emit a dynamic relocation decayed to
2746 if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
)
2747 && BFINFDPIC_SYM_LOCAL (info
, h
)
2748 && !bfd_link_pde (info
))
2750 dynindx
= elf_section_data (h
->root
.u
.def
.section
2751 ->output_section
)->dynindx
;
2752 addend
+= h
->root
.u
.def
.section
->output_offset
2753 + h
->root
.u
.def
.value
;
2755 else if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
))
2759 info
->callbacks
->warning
2760 (info
, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2761 name
, input_bfd
, input_section
, rel
->r_offset
);
2764 dynindx
= h
->dynindx
;
2768 /* Otherwise, we know we have a private function
2769 descriptor, so reference it directly. */
2770 BFD_ASSERT (picrel
->privfd
);
2771 r_type
= R_BFIN_BYTE4_DATA
;
2772 dynindx
= elf_section_data (bfinfdpic_got_section (info
)
2773 ->output_section
)->dynindx
;
2774 addend
= bfinfdpic_got_section (info
)->output_offset
2775 + bfinfdpic_got_initial_offset (info
)
2779 /* If there is room for dynamic symbol resolution, emit
2780 the dynamic relocation. However, if we're linking an
2781 executable at a fixed location, we won't have emitted a
2782 dynamic symbol entry for the got section, so idx will
2783 be zero, which means we can and should compute the
2784 address of the private descriptor ourselves. */
2785 if (bfd_link_pde (info
)
2786 && (!h
|| BFINFDPIC_FUNCDESC_LOCAL (info
, h
)))
2790 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2791 if ((bfd_section_flags (input_section
->output_section
)
2792 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2794 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2798 info
->callbacks
->warning
2800 _("cannot emit fixups in read-only section"),
2801 name
, input_bfd
, input_section
, rel
->r_offset
);
2805 offset
= _bfd_elf_section_offset
2807 input_section
, rel
->r_offset
);
2809 if (offset
!= (bfd_vma
)-1)
2810 _bfinfdpic_add_rofixup (output_bfd
,
2811 bfinfdpic_gotfixup_section
2813 offset
+ input_section
2814 ->output_section
->vma
2815 + input_section
->output_offset
,
2819 else if ((bfd_section_flags (input_section
->output_section
)
2820 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2824 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2828 info
->callbacks
->warning
2830 _("cannot emit dynamic relocations in read-only section"),
2831 name
, input_bfd
, input_section
, rel
->r_offset
);
2834 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2835 input_section
, rel
->r_offset
);
2837 if (offset
!= (bfd_vma
)-1)
2838 _bfinfdpic_add_dyn_reloc (output_bfd
,
2839 bfinfdpic_gotrel_section (info
),
2840 offset
+ input_section
2841 ->output_section
->vma
2842 + input_section
->output_offset
,
2844 dynindx
, addend
, picrel
);
2847 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2850 /* We want the addend in-place because dynamic
2851 relocations are REL. Setting relocation to it should
2852 arrange for it to be installed. */
2853 relocation
= addend
- rel
->r_addend
;
2855 check_segment
[0] = check_segment
[1] = got_segment
;
2858 case R_BFIN_BYTE4_DATA
:
2859 if (! IS_FDPIC (output_bfd
))
2861 check_segment
[0] = check_segment
[1] = -1;
2865 case R_BFIN_FUNCDESC_VALUE
:
2868 bfd_vma addend
= rel
->r_addend
;
2870 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2871 input_section
, rel
->r_offset
);
2873 /* If the symbol is dynamic but binds locally, use
2875 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
))
2877 if (addend
&& r_type
== R_BFIN_FUNCDESC_VALUE
)
2879 info
->callbacks
->warning
2880 (info
, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2881 name
, input_bfd
, input_section
, rel
->r_offset
);
2884 dynindx
= h
->dynindx
;
2889 addend
+= h
->root
.u
.def
.value
;
2891 addend
+= sym
->st_value
;
2893 addend
+= osec
->output_offset
;
2894 if (osec
&& osec
->output_section
2895 && ! bfd_is_abs_section (osec
->output_section
)
2896 && ! bfd_is_und_section (osec
->output_section
))
2897 dynindx
= elf_section_data (osec
->output_section
)->dynindx
;
2902 /* If we're linking an executable at a fixed address, we
2903 can omit the dynamic relocation as long as the symbol
2904 is defined in the current link unit (which is implied
2905 by its output section not being NULL). */
2906 if (bfd_link_pde (info
)
2907 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
2910 addend
+= osec
->output_section
->vma
;
2911 if (IS_FDPIC (input_bfd
)
2912 && (bfd_section_flags (input_section
->output_section
)
2913 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2915 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2919 info
->callbacks
->warning
2921 _("cannot emit fixups in read-only section"),
2922 name
, input_bfd
, input_section
, rel
->r_offset
);
2925 if (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
2927 if (offset
!= (bfd_vma
)-1)
2929 _bfinfdpic_add_rofixup (output_bfd
,
2930 bfinfdpic_gotfixup_section
2932 offset
+ input_section
2933 ->output_section
->vma
2934 + input_section
->output_offset
,
2937 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
2938 _bfinfdpic_add_rofixup
2940 bfinfdpic_gotfixup_section (info
),
2941 offset
+ input_section
->output_section
->vma
2942 + input_section
->output_offset
+ 4, picrel
);
2949 if ((bfd_section_flags (input_section
->output_section
)
2950 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2952 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2956 info
->callbacks
->warning
2958 _("cannot emit dynamic relocations in read-only section"),
2959 name
, input_bfd
, input_section
, rel
->r_offset
);
2963 if (offset
!= (bfd_vma
)-1)
2964 _bfinfdpic_add_dyn_reloc (output_bfd
,
2965 bfinfdpic_gotrel_section (info
),
2967 + input_section
->output_section
->vma
2968 + input_section
->output_offset
,
2969 r_type
, dynindx
, addend
, picrel
);
2972 addend
+= osec
->output_section
->vma
;
2973 /* We want the addend in-place because dynamic
2974 relocations are REL. Setting relocation to it
2975 should arrange for it to be installed. */
2976 relocation
= addend
- rel
->r_addend
;
2979 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
2981 /* If we've omitted the dynamic relocation, just emit
2982 the fixed addresses of the symbol and of the local
2984 if (bfd_link_pde (info
)
2985 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
2986 bfd_put_32 (output_bfd
,
2987 bfinfdpic_got_section (info
)->output_section
->vma
2988 + bfinfdpic_got_section (info
)->output_offset
2989 + bfinfdpic_got_initial_offset (info
),
2990 contents
+ rel
->r_offset
+ 4);
2992 /* A function descriptor used for lazy or local
2993 resolving is initialized such that its high word
2994 contains the output section index in which the
2995 PLT entries are located, and the low word
2996 contains the offset of the lazy PLT entry entry
2997 point into that section. */
2998 bfd_put_32 (output_bfd
,
2999 h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
3001 : _bfinfdpic_osec_to_segment (output_bfd
,
3004 contents
+ rel
->r_offset
+ 4);
3007 check_segment
[0] = check_segment
[1] = got_segment
;
3011 check_segment
[0] = isec_segment
;
3012 check_segment
[1] = sec
3013 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3018 if (check_segment
[0] != check_segment
[1] && IS_FDPIC (output_bfd
))
3020 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
3021 in the ld testsuite. */
3022 /* This helps catch problems in GCC while we can't do more
3023 than static linking. The idea is to test whether the
3024 input file basename is crt0.o only once. */
3025 if (silence_segment_error
== 1)
3026 silence_segment_error
=
3027 (strlen (bfd_get_filename (input_bfd
)) == 6
3028 && filename_cmp (bfd_get_filename (input_bfd
), "crt0.o") == 0)
3029 || (strlen (bfd_get_filename (input_bfd
)) > 6
3030 && filename_cmp (bfd_get_filename (input_bfd
)
3031 + strlen (bfd_get_filename (input_bfd
)) - 7,
3035 if (!silence_segment_error
3036 /* We don't want duplicate errors for undefined
3038 && !(picrel
&& picrel
->symndx
== -1
3039 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefined
))
3040 info
->callbacks
->warning
3043 ? _("relocations between different segments are not supported")
3044 : _("warning: relocation references a different segment"),
3045 name
, input_bfd
, input_section
, rel
->r_offset
);
3046 if (!silence_segment_error
&& bfd_link_pic (info
))
3048 elf_elfheader (output_bfd
)->e_flags
|= EF_BFIN_PIC
;
3053 case R_BFIN_GOTOFFHI
:
3054 /* We need the addend to be applied before we shift the
3056 relocation
+= rel
->r_addend
;
3059 case R_BFIN_FUNCDESC_GOTHI
:
3060 case R_BFIN_FUNCDESC_GOTOFFHI
:
3065 case R_BFIN_FUNCDESC_GOTLO
:
3066 case R_BFIN_GOTOFFLO
:
3067 case R_BFIN_FUNCDESC_GOTOFFLO
:
3068 relocation
&= 0xffff;
3077 case R_BFIN_PCREL24
:
3078 case R_BFIN_PCREL24_JUMP_L
:
3079 if (! IS_FDPIC (output_bfd
) || ! picrel
->plt
)
3083 /* When referencing a GOT entry, a function descriptor or a
3084 PLT, we don't want the addend to apply to the reference,
3085 but rather to the referenced symbol. The actual entry
3086 will have already been created taking the addend into
3087 account, so cancel it out here. */
3088 case R_BFIN_GOT17M4
:
3091 case R_BFIN_FUNCDESC_GOT17M4
:
3092 case R_BFIN_FUNCDESC_GOTHI
:
3093 case R_BFIN_FUNCDESC_GOTLO
:
3094 case R_BFIN_FUNCDESC_GOTOFF17M4
:
3095 case R_BFIN_FUNCDESC_GOTOFFHI
:
3096 case R_BFIN_FUNCDESC_GOTOFFLO
:
3097 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
3098 here, since we do want to apply the addend to the others.
3099 Note that we've applied the addend to GOTOFFHI before we
3100 shifted it right. */
3101 case R_BFIN_GOTOFFHI
:
3102 relocation
-= rel
->r_addend
;
3109 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
3110 contents
, rel
->r_offset
,
3111 relocation
, rel
->r_addend
);
3113 if (r
!= bfd_reloc_ok
)
3115 const char * msg
= (const char *) NULL
;
3119 case bfd_reloc_overflow
:
3120 (*info
->callbacks
->reloc_overflow
)
3121 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3122 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
3125 case bfd_reloc_undefined
:
3126 (*info
->callbacks
->undefined_symbol
)
3127 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, true);
3130 case bfd_reloc_outofrange
:
3131 msg
= _("internal error: out of range error");
3134 case bfd_reloc_notsupported
:
3135 msg
= _("internal error: unsupported relocation error");
3138 case bfd_reloc_dangerous
:
3139 msg
= _("internal error: dangerous relocation");
3143 msg
= _("internal error: unknown error");
3148 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
3149 input_section
, rel
->r_offset
);
3156 /* We need dynamic symbols for every section, since segments can
3157 relocate independently. */
3159 _bfinfdpic_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3160 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3163 switch (elf_section_data (p
)->this_hdr
.sh_type
)
3167 /* If sh_type is yet undecided, assume it could be
3168 SHT_PROGBITS/SHT_NOBITS. */
3172 /* There shouldn't be section relative relocations
3173 against any other section. */
3179 /* Create a .got section, as well as its additional info field. This
3180 is almost entirely copied from
3181 elflink.c:_bfd_elf_create_got_section(). */
3184 _bfin_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3186 flagword flags
, pltflags
;
3188 struct elf_link_hash_entry
*h
;
3189 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3192 /* This function may be called more than once. */
3193 s
= elf_hash_table (info
)->sgot
;
3197 /* Machine specific: although pointers are 32-bits wide, we want the
3198 GOT to be aligned to a 64-bit boundary, such that function
3199 descriptors in it can be accessed with 64-bit loads and
3203 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3204 | SEC_LINKER_CREATED
);
3207 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3208 elf_hash_table (info
)->sgot
= s
;
3210 || !bfd_set_section_alignment (s
, ptralign
))
3213 if (bed
->want_got_sym
)
3215 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3216 (or .got.plt) section. We don't do this in the linker script
3217 because we don't want to define the symbol if we are not creating
3218 a global offset table. */
3219 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "__GLOBAL_OFFSET_TABLE_");
3220 elf_hash_table (info
)->hgot
= h
;
3224 /* Machine-specific: we want the symbol for executables as
3226 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3230 /* The first bit of the global offset table is the header. */
3231 s
->size
+= bed
->got_header_size
;
3233 /* This is the machine-specific part. Create and initialize section
3234 data for the got. */
3235 if (IS_FDPIC (abfd
))
3237 bfinfdpic_relocs_info (info
) = htab_try_create (1,
3238 bfinfdpic_relocs_info_hash
,
3239 bfinfdpic_relocs_info_eq
,
3241 if (! bfinfdpic_relocs_info (info
))
3244 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.got",
3245 (flags
| SEC_READONLY
));
3247 || !bfd_set_section_alignment (s
, 2))
3250 bfinfdpic_gotrel_section (info
) = s
;
3252 /* Machine-specific. */
3253 s
= bfd_make_section_anyway_with_flags (abfd
, ".rofixup",
3254 (flags
| SEC_READONLY
));
3256 || !bfd_set_section_alignment (s
, 2))
3259 bfinfdpic_gotfixup_section (info
) = s
;
3262 pltflags
|= SEC_CODE
;
3263 if (bed
->plt_not_loaded
)
3264 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
3265 if (bed
->plt_readonly
)
3266 pltflags
|= SEC_READONLY
;
3268 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
3270 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
3272 /* Blackfin-specific: remember it. */
3273 bfinfdpic_plt_section (info
) = s
;
3275 if (bed
->want_plt_sym
)
3277 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3279 struct bfd_link_hash_entry
*bh
= NULL
;
3281 if (! (_bfd_generic_link_add_one_symbol
3282 (info
, abfd
, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, 0, NULL
,
3283 false, get_elf_backend_data (abfd
)->collect
, &bh
)))
3285 h
= (struct elf_link_hash_entry
*) bh
;
3287 h
->type
= STT_OBJECT
;
3289 if (! bfd_link_executable (info
)
3290 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3294 /* Blackfin-specific: we want rel relocations for the plt. */
3295 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.plt",
3296 flags
| SEC_READONLY
);
3298 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
3300 /* Blackfin-specific: remember it. */
3301 bfinfdpic_pltrel_section (info
) = s
;
3306 /* Make sure the got and plt sections exist, and that our pointers in
3307 the link hash table point to them. */
3310 elf32_bfinfdpic_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3312 /* This is mostly copied from
3313 elflink.c:_bfd_elf_create_dynamic_sections(). */
3316 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3318 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3319 | SEC_LINKER_CREATED
);
3321 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3322 .rel[a].bss sections. */
3324 /* Blackfin-specific: we want to create the GOT in the Blackfin way. */
3325 if (! _bfin_create_got_section (abfd
, info
))
3328 /* Blackfin-specific: make sure we created everything we wanted. */
3329 BFD_ASSERT (bfinfdpic_got_section (info
) && bfinfdpic_gotrel_section (info
)
3330 /* && bfinfdpic_gotfixup_section (info) */
3331 && bfinfdpic_plt_section (info
)
3332 && bfinfdpic_pltrel_section (info
));
3334 if (bed
->want_dynbss
)
3336 /* The .dynbss section is a place to put symbols which are defined
3337 by dynamic objects, are referenced by regular objects, and are
3338 not functions. We must allocate space for them in the process
3339 image and use a R_*_COPY reloc to tell the dynamic linker to
3340 initialize them at run time. The linker script puts the .dynbss
3341 section into the .bss section of the final image. */
3342 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
3343 SEC_ALLOC
| SEC_LINKER_CREATED
);
3347 /* The .rel[a].bss section holds copy relocs. This section is not
3348 normally needed. We need to create it here, though, so that the
3349 linker will map it to an output section. We can't just create it
3350 only if we need it, because we will not know whether we need it
3351 until we have seen all the input files, and the first time the
3352 main linker code calls BFD after examining all the input files
3353 (size_dynamic_sections) the input sections have already been
3354 mapped to the output sections. If the section turns out not to
3355 be needed, we can discard it later. We will never need this
3356 section when generating a shared object, since they do not use
3358 if (! bfd_link_pic (info
))
3360 s
= bfd_make_section_anyway_with_flags (abfd
,
3362 flags
| SEC_READONLY
);
3364 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
3372 /* Compute the total GOT size required by each symbol in each range.
3373 Symbols may require up to 4 words in the GOT: an entry pointing to
3374 the symbol, an entry pointing to its function descriptor, and a
3375 private function descriptors taking two words. */
3378 _bfinfdpic_count_nontls_entries (struct bfinfdpic_relocs_info
*entry
,
3379 struct _bfinfdpic_dynamic_got_info
*dinfo
)
3381 /* Allocate space for a GOT entry pointing to the symbol. */
3383 dinfo
->got17m4
+= 4;
3384 else if (entry
->gothilo
)
3385 dinfo
->gothilo
+= 4;
3390 /* Allocate space for a GOT entry pointing to the function
3392 if (entry
->fdgot17m4
)
3393 dinfo
->got17m4
+= 4;
3394 else if (entry
->fdgothilo
)
3395 dinfo
->gothilo
+= 4;
3400 /* Decide whether we need a PLT entry, a function descriptor in the
3401 GOT, and a lazy PLT entry for this symbol. */
3402 entry
->plt
= entry
->call
3403 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3404 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3405 entry
->privfd
= entry
->plt
3406 || entry
->fdgoff17m4
|| entry
->fdgoffhilo
3407 || ((entry
->fd
|| entry
->fdgot17m4
|| entry
->fdgothilo
)
3408 && (entry
->symndx
!= -1
3409 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
)));
3410 entry
->lazyplt
= entry
->privfd
3411 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3412 && ! (dinfo
->info
->flags
& DF_BIND_NOW
)
3413 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3415 /* Allocate space for a function descriptor. */
3416 if (entry
->fdgoff17m4
)
3418 else if (entry
->privfd
&& entry
->plt
)
3420 else if (entry
->privfd
)
3427 dinfo
->lzplt
+= LZPLT_NORMAL_SIZE
;
3430 /* Compute the number of dynamic relocations and fixups that a symbol
3431 requires, and add (or subtract) from the grand and per-symbol
3435 _bfinfdpic_count_relocs_fixups (struct bfinfdpic_relocs_info
*entry
,
3436 struct _bfinfdpic_dynamic_got_info
*dinfo
,
3439 bfd_vma relocs
= 0, fixups
= 0;
3441 if (!bfd_link_pde (dinfo
->info
))
3442 relocs
= entry
->relocs32
+ entry
->relocsfd
+ entry
->relocsfdv
;
3445 if (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
))
3447 if (entry
->symndx
!= -1
3448 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3449 fixups
+= entry
->relocs32
+ 2 * entry
->relocsfdv
;
3452 relocs
+= entry
->relocs32
+ entry
->relocsfdv
;
3454 if (entry
->symndx
!= -1
3455 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
))
3457 if (entry
->symndx
!= -1
3458 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3459 fixups
+= entry
->relocsfd
;
3462 relocs
+= entry
->relocsfd
;
3471 entry
->dynrelocs
+= relocs
;
3472 entry
->fixups
+= fixups
;
3473 dinfo
->relocs
+= relocs
;
3474 dinfo
->fixups
+= fixups
;
3477 /* Compute the total GOT and PLT size required by each symbol in each range. *
3478 Symbols may require up to 4 words in the GOT: an entry pointing to
3479 the symbol, an entry pointing to its function descriptor, and a
3480 private function descriptors taking two words. */
3483 _bfinfdpic_count_got_plt_entries (void **entryp
, void *dinfo_
)
3485 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3486 struct _bfinfdpic_dynamic_got_info
*dinfo
= dinfo_
;
3488 _bfinfdpic_count_nontls_entries (entry
, dinfo
);
3490 _bfinfdpic_count_relocs_fixups (entry
, dinfo
, false);
3495 /* This structure is used to assign offsets to got entries, function
3496 descriptors, plt entries and lazy plt entries. */
3498 struct _bfinfdpic_dynamic_got_plt_info
3500 /* Summary information collected with _bfinfdpic_count_got_plt_entries. */
3501 struct _bfinfdpic_dynamic_got_info g
;
3503 /* For each addressable range, we record a MAX (positive) and MIN
3504 (negative) value. CUR is used to assign got entries, and it's
3505 incremented from an initial positive value to MAX, then from MIN
3506 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
3507 assign function descriptors, and it's decreased from an initial
3508 non-positive value to MIN, then from MAX down to CUR (unless CUR
3509 wraps around first). All of MIN, MAX, CUR and FDCUR always point
3510 to even words. ODD, if non-zero, indicates an odd word to be
3511 used for the next got entry, otherwise CUR is used and
3512 incremented by a pair of words, wrapping around when it reaches
3513 MAX. FDCUR is decremented (and wrapped) before the next function
3514 descriptor is chosen. FDPLT indicates the number of remaining
3515 slots that can be used for function descriptors used only by PLT
3517 struct _bfinfdpic_dynamic_got_alloc_data
3519 bfd_signed_vma max
, cur
, odd
, fdcur
, min
;
3524 /* Determine the positive and negative ranges to be used by each
3525 offset range in the GOT. FDCUR and CUR, that must be aligned to a
3526 double-word boundary, are the minimum (negative) and maximum
3527 (positive) GOT offsets already used by previous ranges, except for
3528 an ODD entry that may have been left behind. GOT and FD indicate
3529 the size of GOT entries and function descriptors that must be
3530 placed within the range from -WRAP to WRAP. If there's room left,
3531 up to FDPLT bytes should be reserved for additional function
3534 inline static bfd_signed_vma
3535 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data
*gad
,
3536 bfd_signed_vma fdcur
,
3544 bfd_signed_vma wrapmin
= -wrap
;
3546 /* Start at the given initial points. */
3550 /* If we had an incoming odd word and we have any got entries that
3551 are going to use it, consume it, otherwise leave gad->odd at
3552 zero. We might force gad->odd to zero and return the incoming
3553 odd such that it is used by the next range, but then GOT entries
3554 might appear to be out of order and we wouldn't be able to
3555 shorten the GOT by one word if it turns out to end with an
3556 unpaired GOT entry. */
3566 /* If we're left with an unpaired GOT entry, compute its location
3567 such that we can return it. Otherwise, if got doesn't require an
3568 odd number of words here, either odd was already zero in the
3569 block above, or it was set to zero because got was non-zero, or
3570 got was already zero. In the latter case, we want the value of
3571 odd to carry over to the return statement, so we don't want to
3572 reset odd unless the condition below is true. */
3579 /* Compute the tentative boundaries of this range. */
3580 gad
->max
= cur
+ got
;
3581 gad
->min
= fdcur
- fd
;
3584 /* If function descriptors took too much space, wrap some of them
3586 if (gad
->min
< wrapmin
)
3588 gad
->max
+= wrapmin
- gad
->min
;
3591 /* If there is space left and we have function descriptors
3592 referenced in PLT entries that could take advantage of shorter
3593 offsets, place them here. */
3594 else if (fdplt
&& gad
->min
> wrapmin
)
3597 if ((bfd_vma
) (gad
->min
- wrapmin
) < fdplt
)
3598 fds
= gad
->min
- wrapmin
;
3607 /* If GOT entries took too much space, wrap some of them around.
3608 This may well cause gad->min to become lower than wrapmin. This
3609 will cause a relocation overflow later on, so we don't have to
3611 if ((bfd_vma
) gad
->max
> wrap
)
3613 gad
->min
-= gad
->max
- wrap
;
3616 /* If there is more space left, try to place some more function
3617 descriptors for PLT entries. */
3618 else if (fdplt
&& (bfd_vma
) gad
->max
< wrap
)
3621 if ((bfd_vma
) (wrap
- gad
->max
) < fdplt
)
3622 fds
= wrap
- gad
->max
;
3631 /* If odd was initially computed as an offset past the wrap point,
3634 odd
= gad
->min
+ odd
- gad
->max
;
3636 /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3637 before returning, so do it here too. This guarantees that,
3638 should cur and fdcur meet at the wrap point, they'll both be
3640 if (gad
->cur
== gad
->max
)
3641 gad
->cur
= gad
->min
;
3646 /* Compute the location of the next GOT entry, given the allocation
3647 data for a range. */
3649 inline static bfd_signed_vma
3650 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3656 /* If there was an odd word left behind, use it. */
3662 /* Otherwise, use the word pointed to by cur, reserve the next
3663 as an odd word, and skip to the next pair of words, possibly
3666 gad
->odd
= gad
->cur
+ 4;
3668 if (gad
->cur
== gad
->max
)
3669 gad
->cur
= gad
->min
;
3675 /* Compute the location of the next function descriptor entry in the
3676 GOT, given the allocation data for a range. */
3678 inline static bfd_signed_vma
3679 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3681 /* If we're at the bottom, wrap around, and only then allocate the
3682 next pair of words. */
3683 if (gad
->fdcur
== gad
->min
)
3684 gad
->fdcur
= gad
->max
;
3685 return gad
->fdcur
-= 8;
3688 /* Assign GOT offsets for every GOT entry and function descriptor.
3689 Doing everything in a single pass is tricky. */
3692 _bfinfdpic_assign_got_entries (void **entryp
, void *info_
)
3694 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3695 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3698 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3699 else if (entry
->gothilo
)
3700 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3702 if (entry
->fdgot17m4
)
3703 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3704 else if (entry
->fdgothilo
)
3705 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3707 if (entry
->fdgoff17m4
)
3708 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3709 else if (entry
->plt
&& dinfo
->got17m4
.fdplt
)
3711 dinfo
->got17m4
.fdplt
-= 8;
3712 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3714 else if (entry
->plt
)
3716 dinfo
->gothilo
.fdplt
-= 8;
3717 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3719 else if (entry
->privfd
)
3720 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3725 /* Assign GOT offsets to private function descriptors used by PLT
3726 entries (or referenced by 32-bit offsets), as well as PLT entries
3727 and lazy PLT entries. */
3730 _bfinfdpic_assign_plt_entries (void **entryp
, void *info_
)
3732 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3733 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3735 /* If this symbol requires a local function descriptor, allocate
3737 if (entry
->privfd
&& entry
->fd_entry
== 0)
3739 if (dinfo
->got17m4
.fdplt
)
3741 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3742 dinfo
->got17m4
.fdplt
-= 8;
3746 BFD_ASSERT (dinfo
->gothilo
.fdplt
);
3747 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3748 dinfo
->gothilo
.fdplt
-= 8;
3756 /* We use the section's raw size to mark the location of the
3758 entry
->plt_entry
= bfinfdpic_plt_section (dinfo
->g
.info
)->size
;
3760 /* Figure out the length of this PLT entry based on the
3761 addressing mode we need to reach the function descriptor. */
3762 BFD_ASSERT (entry
->fd_entry
);
3763 if (entry
->fd_entry
>= -(1 << (18 - 1))
3764 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
3769 bfinfdpic_plt_section (dinfo
->g
.info
)->size
+= size
;
3774 entry
->lzplt_entry
= dinfo
->g
.lzplt
;
3775 dinfo
->g
.lzplt
+= LZPLT_NORMAL_SIZE
;
3776 /* If this entry is the one that gets the resolver stub, account
3777 for the additional instruction. */
3778 if (entry
->lzplt_entry
% BFINFDPIC_LZPLT_BLOCK_SIZE
3779 == BFINFDPIC_LZPLT_RESOLV_LOC
)
3780 dinfo
->g
.lzplt
+= LZPLT_RESOLVER_EXTRA
;
3786 /* Cancel out any effects of calling _bfinfdpic_assign_got_entries and
3787 _bfinfdpic_assign_plt_entries. */
3790 _bfinfdpic_reset_got_plt_entries (void **entryp
, void *ignore ATTRIBUTE_UNUSED
)
3792 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3794 entry
->got_entry
= 0;
3795 entry
->fdgot_entry
= 0;
3796 entry
->fd_entry
= 0;
3797 entry
->plt_entry
= (bfd_vma
)-1;
3798 entry
->lzplt_entry
= (bfd_vma
)-1;
3803 /* Follow indirect and warning hash entries so that each got entry
3804 points to the final symbol definition. P must point to a pointer
3805 to the hash table we're traversing. Since this traversal may
3806 modify the hash table, we set this pointer to NULL to indicate
3807 we've made a potentially-destructive change to the hash table, so
3808 the traversal must be restarted. */
3810 _bfinfdpic_resolve_final_relocs_info (void **entryp
, void *p
)
3812 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3815 if (entry
->symndx
== -1)
3817 struct elf_link_hash_entry
*h
= entry
->d
.h
;
3818 struct bfinfdpic_relocs_info
*oentry
;
3820 while (h
->root
.type
== bfd_link_hash_indirect
3821 || h
->root
.type
== bfd_link_hash_warning
)
3822 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
3824 if (entry
->d
.h
== h
)
3827 oentry
= bfinfdpic_relocs_info_for_global (*htab
, 0, h
, entry
->addend
,
3832 /* Merge the two entries. */
3833 bfinfdpic_pic_merge_early_relocs_info (oentry
, entry
);
3834 htab_clear_slot (*htab
, entryp
);
3840 /* If we can't find this entry with the new bfd hash, re-insert
3841 it, and get the traversal restarted. */
3842 if (! htab_find (*htab
, entry
))
3844 htab_clear_slot (*htab
, entryp
);
3845 entryp
= htab_find_slot (*htab
, entry
, INSERT
);
3848 /* Abort the traversal, since the whole table may have
3849 moved, and leave it up to the parent to restart the
3851 *(htab_t
*)p
= NULL
;
3859 /* Compute the total size of the GOT, the PLT, the dynamic relocations
3860 section and the rofixup section. Assign locations for GOT and PLT
3864 _bfinfdpic_size_got_plt (bfd
*output_bfd
,
3865 struct _bfinfdpic_dynamic_got_plt_info
*gpinfop
)
3869 struct bfd_link_info
*info
= gpinfop
->g
.info
;
3870 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
3872 memcpy (bfinfdpic_dynamic_got_plt_info (info
), &gpinfop
->g
,
3873 sizeof (gpinfop
->g
));
3876 /* Compute the total size taken by entries in the 18-bit range,
3877 to tell how many PLT function descriptors we can bring into it
3878 without causing it to overflow. */
3879 limit
= odd
+ gpinfop
->g
.got17m4
+ gpinfop
->g
.fd17m4
;
3880 if (limit
< (bfd_vma
)1 << 18)
3881 limit
= ((bfd_vma
)1 << 18) - limit
;
3884 if (gpinfop
->g
.fdplt
< limit
)
3885 limit
= gpinfop
->g
.fdplt
;
3887 /* Determine the ranges of GOT offsets that we can use for each
3888 range of addressing modes. */
3889 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfop
->got17m4
,
3896 (bfd_vma
)1 << (18-1));
3897 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfop
->gothilo
,
3898 gpinfop
->got17m4
.min
,
3900 gpinfop
->got17m4
.max
,
3903 gpinfop
->g
.fdplt
- gpinfop
->got17m4
.fdplt
,
3904 (bfd_vma
)1 << (32-1));
3906 /* Now assign (most) GOT offsets. */
3907 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_got_entries
,
3910 bfinfdpic_got_section (info
)->size
= gpinfop
->gothilo
.max
3911 - gpinfop
->gothilo
.min
3912 /* If an odd word is the last word of the GOT, we don't need this
3913 word to be part of the GOT. */
3914 - (odd
+ 4 == gpinfop
->gothilo
.max
? 4 : 0);
3915 if (bfinfdpic_got_section (info
)->size
== 0)
3916 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
3917 else if (bfinfdpic_got_section (info
)->size
== 12
3918 && ! elf_hash_table (info
)->dynamic_sections_created
)
3920 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
3921 bfinfdpic_got_section (info
)->size
= 0;
3925 bfinfdpic_got_section (info
)->contents
=
3926 (bfd_byte
*) bfd_zalloc (dynobj
,
3927 bfinfdpic_got_section (info
)->size
);
3928 if (bfinfdpic_got_section (info
)->contents
== NULL
)
3932 if (elf_hash_table (info
)->dynamic_sections_created
)
3933 /* Subtract the number of lzplt entries, since those will generate
3934 relocations in the pltrel section. */
3935 bfinfdpic_gotrel_section (info
)->size
=
3936 (gpinfop
->g
.relocs
- gpinfop
->g
.lzplt
/ LZPLT_NORMAL_SIZE
)
3937 * get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
3939 BFD_ASSERT (gpinfop
->g
.relocs
== 0);
3940 if (bfinfdpic_gotrel_section (info
)->size
== 0)
3941 bfinfdpic_gotrel_section (info
)->flags
|= SEC_EXCLUDE
;
3944 bfinfdpic_gotrel_section (info
)->contents
=
3945 (bfd_byte
*) bfd_zalloc (dynobj
,
3946 bfinfdpic_gotrel_section (info
)->size
);
3947 if (bfinfdpic_gotrel_section (info
)->contents
== NULL
)
3951 bfinfdpic_gotfixup_section (info
)->size
= (gpinfop
->g
.fixups
+ 1) * 4;
3952 if (bfinfdpic_gotfixup_section (info
)->size
== 0)
3953 bfinfdpic_gotfixup_section (info
)->flags
|= SEC_EXCLUDE
;
3956 bfinfdpic_gotfixup_section (info
)->contents
=
3957 (bfd_byte
*) bfd_zalloc (dynobj
,
3958 bfinfdpic_gotfixup_section (info
)->size
);
3959 if (bfinfdpic_gotfixup_section (info
)->contents
== NULL
)
3963 if (elf_hash_table (info
)->dynamic_sections_created
)
3964 bfinfdpic_pltrel_section (info
)->size
=
3965 gpinfop
->g
.lzplt
/ LZPLT_NORMAL_SIZE
* get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
3966 if (bfinfdpic_pltrel_section (info
)->size
== 0)
3967 bfinfdpic_pltrel_section (info
)->flags
|= SEC_EXCLUDE
;
3970 bfinfdpic_pltrel_section (info
)->contents
=
3971 (bfd_byte
*) bfd_zalloc (dynobj
,
3972 bfinfdpic_pltrel_section (info
)->size
);
3973 if (bfinfdpic_pltrel_section (info
)->contents
== NULL
)
3977 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
3978 such that there's room for the additional instruction needed to
3979 call the resolver. Since _bfinfdpic_assign_got_entries didn't
3980 account for them, our block size is 4 bytes smaller than the real
3982 if (elf_hash_table (info
)->dynamic_sections_created
)
3984 bfinfdpic_plt_section (info
)->size
= gpinfop
->g
.lzplt
3985 + ((gpinfop
->g
.lzplt
+ (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) - LZPLT_NORMAL_SIZE
)
3986 / (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) * LZPLT_RESOLVER_EXTRA
);
3989 /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
3990 actually assign lazy PLT entries addresses. */
3991 gpinfop
->g
.lzplt
= 0;
3993 /* Save information that we're going to need to generate GOT and PLT
3995 bfinfdpic_got_initial_offset (info
) = -gpinfop
->gothilo
.min
;
3997 if (get_elf_backend_data (output_bfd
)->want_got_sym
)
3998 elf_hash_table (info
)->hgot
->root
.u
.def
.value
3999 = bfinfdpic_got_initial_offset (info
);
4001 if (elf_hash_table (info
)->dynamic_sections_created
)
4002 bfinfdpic_plt_initial_offset (info
) =
4003 bfinfdpic_plt_section (info
)->size
;
4005 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_plt_entries
,
4008 /* Allocate the PLT section contents only after
4009 _bfinfdpic_assign_plt_entries has a chance to add the size of the
4010 non-lazy PLT entries. */
4011 if (bfinfdpic_plt_section (info
)->size
== 0)
4012 bfinfdpic_plt_section (info
)->flags
|= SEC_EXCLUDE
;
4015 bfinfdpic_plt_section (info
)->contents
=
4016 (bfd_byte
*) bfd_zalloc (dynobj
,
4017 bfinfdpic_plt_section (info
)->size
);
4018 if (bfinfdpic_plt_section (info
)->contents
== NULL
)
4025 /* Set the sizes of the dynamic sections. */
4028 elf32_bfinfdpic_size_dynamic_sections (bfd
*output_bfd
,
4029 struct bfd_link_info
*info
)
4031 struct elf_link_hash_table
*htab
;
4034 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4036 htab
= elf_hash_table (info
);
4037 dynobj
= htab
->dynobj
;
4038 BFD_ASSERT (dynobj
!= NULL
);
4040 if (htab
->dynamic_sections_created
)
4042 /* Set the contents of the .interp section to the interpreter. */
4043 if (bfd_link_executable (info
) && !info
->nointerp
)
4045 s
= bfd_get_linker_section (dynobj
, ".interp");
4046 BFD_ASSERT (s
!= NULL
);
4047 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4048 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
4052 memset (&gpinfo
, 0, sizeof (gpinfo
));
4053 gpinfo
.g
.info
= info
;
4057 htab_t relocs
= bfinfdpic_relocs_info (info
);
4059 htab_traverse (relocs
, _bfinfdpic_resolve_final_relocs_info
, &relocs
);
4061 if (relocs
== bfinfdpic_relocs_info (info
))
4065 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_count_got_plt_entries
,
4068 /* Allocate space to save the summary information, we're going to
4069 use it if we're doing relaxations. */
4070 bfinfdpic_dynamic_got_plt_info (info
) = bfd_alloc (dynobj
, sizeof (gpinfo
.g
));
4072 if (!_bfinfdpic_size_got_plt (output_bfd
, &gpinfo
))
4075 s
= bfd_get_linker_section (dynobj
, ".dynbss");
4076 if (s
&& s
->size
== 0)
4077 s
->flags
|= SEC_EXCLUDE
;
4079 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
4080 if (s
&& s
->size
== 0)
4081 s
->flags
|= SEC_EXCLUDE
;
4083 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, true);
4087 elf32_bfinfdpic_always_size_sections (bfd
*output_bfd
,
4088 struct bfd_link_info
*info
)
4090 if (!bfd_link_relocatable (info
)
4091 && !bfd_elf_stack_segment_size (output_bfd
, info
,
4092 "__stacksize", DEFAULT_STACK_SIZE
))
4098 /* Check whether any of the relocations was optimized away, and
4099 subtract it from the relocation or fixup count. */
4101 _bfinfdpic_check_discarded_relocs (bfd
*abfd
, asection
*sec
,
4102 struct bfd_link_info
*info
,
4105 Elf_Internal_Shdr
*symtab_hdr
;
4106 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4107 Elf_Internal_Rela
*rel
, *erel
;
4109 if ((sec
->flags
& SEC_RELOC
) == 0
4110 || sec
->reloc_count
== 0)
4113 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4114 sym_hashes
= elf_sym_hashes (abfd
);
4115 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
4116 if (!elf_bad_symtab (abfd
))
4117 sym_hashes_end
-= symtab_hdr
->sh_info
;
4119 rel
= elf_section_data (sec
)->relocs
;
4121 /* Now examine each relocation. */
4122 for (erel
= rel
+ sec
->reloc_count
; rel
< erel
; rel
++)
4124 struct elf_link_hash_entry
*h
;
4125 unsigned long r_symndx
;
4126 struct bfinfdpic_relocs_info
*picrel
;
4127 struct _bfinfdpic_dynamic_got_info
*dinfo
;
4129 if (ELF32_R_TYPE (rel
->r_info
) != R_BFIN_BYTE4_DATA
4130 && ELF32_R_TYPE (rel
->r_info
) != R_BFIN_FUNCDESC
)
4133 if (_bfd_elf_section_offset (sec
->output_section
->owner
,
4134 info
, sec
, rel
->r_offset
)
4138 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4139 if (r_symndx
< symtab_hdr
->sh_info
)
4143 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4144 while (h
->root
.type
== bfd_link_hash_indirect
4145 || h
->root
.type
== bfd_link_hash_warning
)
4146 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
4150 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4152 rel
->r_addend
, NO_INSERT
);
4154 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info
),
4156 rel
->r_addend
, NO_INSERT
);
4162 dinfo
= bfinfdpic_dynamic_got_plt_info (info
);
4164 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, true);
4165 if (ELF32_R_TYPE (rel
->r_info
) == R_BFIN_BYTE4_DATA
)
4167 else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4169 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, false);
4176 bfinfdpic_elf_discard_info (bfd
*ibfd
,
4177 struct elf_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
4178 struct bfd_link_info
*info
)
4180 bool changed
= false;
4184 /* Account for relaxation of .eh_frame section. */
4185 for (s
= ibfd
->sections
; s
; s
= s
->next
)
4186 if (s
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4188 if (!_bfinfdpic_check_discarded_relocs (ibfd
, s
, info
, &changed
))
4190 obfd
= s
->output_section
->owner
;
4195 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4197 memset (&gpinfo
, 0, sizeof (gpinfo
));
4198 memcpy (&gpinfo
.g
, bfinfdpic_dynamic_got_plt_info (info
),
4201 /* Clear GOT and PLT assignments. */
4202 htab_traverse (bfinfdpic_relocs_info (info
),
4203 _bfinfdpic_reset_got_plt_entries
,
4206 if (!_bfinfdpic_size_got_plt (obfd
, &gpinfo
))
4214 elf32_bfinfdpic_finish_dynamic_sections (bfd
*output_bfd
,
4215 struct bfd_link_info
*info
)
4220 dynobj
= elf_hash_table (info
)->dynobj
;
4222 if (bfinfdpic_got_section (info
))
4224 BFD_ASSERT (bfinfdpic_gotrel_section (info
)->size
4225 /* PR 17334: It appears that the GOT section can end up
4226 being bigger than the number of relocs. Presumably
4227 because some relocs have been deleted. A test case has
4228 yet to be generated for verify this, but in the meantime
4229 the test below has been changed from == to >= so that
4230 applications can continue to be built. */
4231 >= (bfinfdpic_gotrel_section (info
)->reloc_count
4232 * sizeof (Elf32_External_Rel
)));
4234 if (bfinfdpic_gotfixup_section (info
))
4236 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
4237 bfd_vma got_value
= hgot
->root
.u
.def
.value
4238 + hgot
->root
.u
.def
.section
->output_section
->vma
4239 + hgot
->root
.u
.def
.section
->output_offset
;
4241 _bfinfdpic_add_rofixup (output_bfd
, bfinfdpic_gotfixup_section (info
),
4244 if (bfinfdpic_gotfixup_section (info
)->size
4245 != (bfinfdpic_gotfixup_section (info
)->reloc_count
* 4))
4248 ("LINKER BUG: .rofixup section size mismatch");
4253 if (elf_hash_table (info
)->dynamic_sections_created
)
4255 BFD_ASSERT (bfinfdpic_pltrel_section (info
)->size
4256 == (bfinfdpic_pltrel_section (info
)->reloc_count
4257 * sizeof (Elf32_External_Rel
)));
4260 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4262 if (elf_hash_table (info
)->dynamic_sections_created
)
4264 Elf32_External_Dyn
* dyncon
;
4265 Elf32_External_Dyn
* dynconend
;
4267 BFD_ASSERT (sdyn
!= NULL
);
4269 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4270 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4272 for (; dyncon
< dynconend
; dyncon
++)
4274 Elf_Internal_Dyn dyn
;
4276 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4284 dyn
.d_un
.d_ptr
= bfinfdpic_got_section (info
)->output_section
->vma
4285 + bfinfdpic_got_section (info
)->output_offset
4286 + bfinfdpic_got_initial_offset (info
);
4287 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4291 dyn
.d_un
.d_ptr
= bfinfdpic_pltrel_section (info
)
4292 ->output_section
->vma
4293 + bfinfdpic_pltrel_section (info
)->output_offset
;
4294 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4298 dyn
.d_un
.d_val
= bfinfdpic_pltrel_section (info
)->size
;
4299 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4308 /* Adjust a symbol defined by a dynamic object and referenced by a
4312 elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4313 struct elf_link_hash_entry
*h
)
4317 dynobj
= elf_hash_table (info
)->dynobj
;
4319 /* Make sure we know what is going on here. */
4320 BFD_ASSERT (dynobj
!= NULL
4324 && !h
->def_regular
)));
4326 /* If this is a weak symbol, and there is a real definition, the
4327 processor independent code will have arranged for us to see the
4328 real definition first, and we can just use the same value. */
4329 if (h
->is_weakalias
)
4331 struct elf_link_hash_entry
*def
= weakdef (h
);
4332 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
4333 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
4334 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
4340 /* Perform any actions needed for dynamic symbols. */
4343 elf32_bfinfdpic_finish_dynamic_symbol
4344 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4345 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4346 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
4347 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4352 /* Decide whether to attempt to turn absptr or lsda encodings in
4353 shared libraries into pcrel within the given input section. */
4356 bfinfdpic_elf_use_relative_eh_frame
4357 (bfd
*input_bfd ATTRIBUTE_UNUSED
,
4358 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4359 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
4361 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4365 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4368 bfinfdpic_elf_encode_eh_address (bfd
*abfd
,
4369 struct bfd_link_info
*info
,
4370 asection
*osec
, bfd_vma offset
,
4371 asection
*loc_sec
, bfd_vma loc_offset
,
4374 struct elf_link_hash_entry
*h
;
4376 h
= elf_hash_table (info
)->hgot
;
4377 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
4379 if (! h
|| (_bfinfdpic_osec_to_segment (abfd
, osec
)
4380 == _bfinfdpic_osec_to_segment (abfd
, loc_sec
->output_section
)))
4381 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
4382 loc_sec
, loc_offset
, encoded
);
4384 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd
, osec
)
4385 == (_bfinfdpic_osec_to_segment
4386 (abfd
, h
->root
.u
.def
.section
->output_section
)));
4388 *encoded
= osec
->vma
+ offset
4389 - (h
->root
.u
.def
.value
4390 + h
->root
.u
.def
.section
->output_section
->vma
4391 + h
->root
.u
.def
.section
->output_offset
);
4393 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
4398 /* Look through the relocs for a section during the first phase.
4400 Besides handling virtual table relocs for gc, we have to deal with
4401 all sorts of PIC-related relocations. We describe below the
4402 general plan on how to handle such relocations, even though we only
4403 collect information at this point, storing them in hash tables for
4404 perusal of later passes.
4406 32 relocations are propagated to the linker output when creating
4407 position-independent output. LO16 and HI16 relocations are not
4408 supposed to be encountered in this case.
4410 LABEL16 should always be resolvable by the linker, since it's only
4413 LABEL24, on the other hand, is used by calls. If it turns out that
4414 the target of a call is a dynamic symbol, a PLT entry must be
4415 created for it, which triggers the creation of a private function
4416 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4418 GPREL relocations require the referenced symbol to be in the same
4419 segment as _gp, but this can only be checked later.
4421 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4422 exist. LABEL24 might as well, since it may require a PLT entry,
4423 that will require a got.
4425 Non-FUNCDESC GOT relocations require a GOT entry to be created
4426 regardless of whether the symbol is dynamic. However, since a
4427 global symbol that turns out to not be exported may have the same
4428 address of a non-dynamic symbol, we don't assign GOT entries at
4429 this point, such that we can share them in this case. A relocation
4430 for the GOT entry always has to be created, be it to offset a
4431 private symbol by the section load address, be it to get the symbol
4432 resolved dynamically.
4434 FUNCDESC GOT relocations require a GOT entry to be created, and
4435 handled as if a FUNCDESC relocation was applied to the GOT entry in
4438 FUNCDESC relocations referencing a symbol that turns out to NOT be
4439 dynamic cause a private function descriptor to be created. The
4440 FUNCDESC relocation then decays to a 32 relocation that points at
4441 the private descriptor. If the symbol is dynamic, the FUNCDESC
4442 relocation is propagated to the linker output, such that the
4443 dynamic linker creates the canonical descriptor, pointing to the
4444 dynamically-resolved definition of the function.
4446 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4447 symbols that are assigned to the same segment as the GOT, but we
4448 can only check this later, after we know the complete set of
4449 symbols defined and/or exported.
4451 FUNCDESC GOTOFF relocations require a function descriptor to be
4452 created and, unless lazy binding is disabled or the symbol is not
4453 dynamic, a lazy PLT entry. Since we can't tell at this point
4454 whether a symbol is going to be dynamic, we have to decide later
4455 whether to create a lazy PLT entry or bind the descriptor directly
4456 to the private function.
4458 FUNCDESC_VALUE relocations are not supposed to be present in object
4459 files, but they may very well be simply propagated to the linker
4460 output, since they have no side effect.
4463 A function descriptor always requires a FUNCDESC_VALUE relocation.
4464 Whether it's in .plt.rel or not depends on whether lazy binding is
4465 enabled and on whether the referenced symbol is dynamic.
4467 The existence of a lazy PLT requires the resolverStub lazy PLT
4468 entry to be present.
4471 As for assignment of GOT, PLT and lazy PLT entries, and private
4472 descriptors, we might do them all sequentially, but we can do
4473 better than that. For example, we can place GOT entries and
4474 private function descriptors referenced using 12-bit operands
4475 closer to the PIC register value, such that these relocations don't
4476 overflow. Those that are only referenced with LO16 relocations
4477 could come next, but we may as well place PLT-required function
4478 descriptors in the 12-bit range to make them shorter. Symbols
4479 referenced with LO16/HI16 may come next, but we may place
4480 additional function descriptors in the 16-bit range if we can
4481 reliably tell that we've already placed entries that are ever
4482 referenced with only LO16. PLT entries are therefore generated as
4483 small as possible, while not introducing relocation overflows in
4484 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4485 generated before or after PLT entries, but not intermingled with
4486 them, such that we can have more lazy PLT entries in range for a
4487 branch to the resolverStub. The resolverStub should be emitted at
4488 the most distant location from the first lazy PLT entry such that
4489 it's still in range for a branch, or closer, if there isn't a need
4490 for so many lazy PLT entries. Additional lazy PLT entries may be
4491 emitted after the resolverStub, as long as branches are still in
4492 range. If the branch goes out of range, longer lazy PLT entries
4495 We could further optimize PLT and lazy PLT entries by giving them
4496 priority in assignment to closer-to-gr17 locations depending on the
4497 number of occurrences of references to them (assuming a function
4498 that's called more often is more important for performance, so its
4499 PLT entry should be faster), or taking hints from the compiler.
4500 Given infinite time and money... :-) */
4503 bfinfdpic_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4504 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4506 Elf_Internal_Shdr
*symtab_hdr
;
4507 struct elf_link_hash_entry
**sym_hashes
;
4508 const Elf_Internal_Rela
*rel
;
4509 const Elf_Internal_Rela
*rel_end
;
4511 struct bfinfdpic_relocs_info
*picrel
;
4513 if (bfd_link_relocatable (info
))
4516 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4517 sym_hashes
= elf_sym_hashes (abfd
);
4519 dynobj
= elf_hash_table (info
)->dynobj
;
4520 rel_end
= relocs
+ sec
->reloc_count
;
4521 for (rel
= relocs
; rel
< rel_end
; rel
++)
4523 struct elf_link_hash_entry
*h
;
4524 unsigned long r_symndx
;
4526 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4527 if (r_symndx
< symtab_hdr
->sh_info
)
4531 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4532 while (h
->root
.type
== bfd_link_hash_indirect
4533 || h
->root
.type
== bfd_link_hash_warning
)
4534 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4537 switch (ELF32_R_TYPE (rel
->r_info
))
4539 case R_BFIN_GOT17M4
:
4542 case R_BFIN_FUNCDESC_GOT17M4
:
4543 case R_BFIN_FUNCDESC_GOTHI
:
4544 case R_BFIN_FUNCDESC_GOTLO
:
4545 case R_BFIN_GOTOFF17M4
:
4546 case R_BFIN_GOTOFFHI
:
4547 case R_BFIN_GOTOFFLO
:
4548 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4549 case R_BFIN_FUNCDESC_GOTOFFHI
:
4550 case R_BFIN_FUNCDESC_GOTOFFLO
:
4551 case R_BFIN_FUNCDESC
:
4552 case R_BFIN_FUNCDESC_VALUE
:
4553 if (! IS_FDPIC (abfd
))
4556 case R_BFIN_PCREL24
:
4557 case R_BFIN_PCREL24_JUMP_L
:
4558 case R_BFIN_BYTE4_DATA
:
4559 if (IS_FDPIC (abfd
) && ! dynobj
)
4561 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
4562 if (! _bfin_create_got_section (abfd
, info
))
4565 if (! IS_FDPIC (abfd
))
4572 if (h
->dynindx
== -1)
4573 switch (ELF_ST_VISIBILITY (h
->other
))
4579 bfd_elf_link_record_dynamic_symbol (info
, h
);
4583 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4585 rel
->r_addend
, INSERT
);
4588 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4589 (info
), abfd
, r_symndx
,
4590 rel
->r_addend
, INSERT
);
4600 switch (ELF32_R_TYPE (rel
->r_info
))
4602 case R_BFIN_PCREL24
:
4603 case R_BFIN_PCREL24_JUMP_L
:
4604 if (IS_FDPIC (abfd
))
4608 case R_BFIN_FUNCDESC_VALUE
:
4609 picrel
->relocsfdv
++;
4610 if (bfd_section_flags (sec
) & SEC_ALLOC
)
4614 case R_BFIN_BYTE4_DATA
:
4615 if (! IS_FDPIC (abfd
))
4619 if (bfd_section_flags (sec
) & SEC_ALLOC
)
4623 case R_BFIN_GOT17M4
:
4632 case R_BFIN_FUNCDESC_GOT17M4
:
4633 picrel
->fdgot17m4
++;
4636 case R_BFIN_FUNCDESC_GOTHI
:
4637 case R_BFIN_FUNCDESC_GOTLO
:
4638 picrel
->fdgothilo
++;
4641 case R_BFIN_GOTOFF17M4
:
4642 case R_BFIN_GOTOFFHI
:
4643 case R_BFIN_GOTOFFLO
:
4647 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4648 picrel
->fdgoff17m4
++;
4651 case R_BFIN_FUNCDESC_GOTOFFHI
:
4652 case R_BFIN_FUNCDESC_GOTOFFLO
:
4653 picrel
->fdgoffhilo
++;
4656 case R_BFIN_FUNCDESC
:
4661 /* This relocation describes the C++ object vtable hierarchy.
4662 Reconstruct it for later use during GC. */
4663 case R_BFIN_GNU_VTINHERIT
:
4664 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4668 /* This relocation describes which C++ vtable entries are actually
4669 used. Record for later use during GC. */
4670 case R_BFIN_GNU_VTENTRY
:
4671 BFD_ASSERT (h
!= NULL
);
4673 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4677 case R_BFIN_HUIMM16
:
4678 case R_BFIN_LUIMM16
:
4679 case R_BFIN_PCREL12_JUMP_S
:
4680 case R_BFIN_PCREL10
:
4686 /* xgettext:c-format */
4687 (_("%pB: unsupported relocation type %#x"),
4688 abfd
, (int) ELF32_R_TYPE (rel
->r_info
));
4696 /* Set the right machine number for a Blackfin ELF file. */
4699 elf32_bfin_object_p (bfd
*abfd
)
4701 bfd_default_set_arch_mach (abfd
, bfd_arch_bfin
, 0);
4702 return (((elf_elfheader (abfd
)->e_flags
& EF_BFIN_FDPIC
) != 0)
4703 == (IS_FDPIC (abfd
)));
4707 elf32_bfin_set_private_flags (bfd
* abfd
, flagword flags
)
4709 elf_elfheader (abfd
)->e_flags
= flags
;
4710 elf_flags_init (abfd
) = true;
4714 /* Display the flags field. */
4716 elf32_bfin_print_private_bfd_data (bfd
* abfd
, void * ptr
)
4718 FILE *file
= (FILE *) ptr
;
4721 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4723 /* Print normal ELF private data. */
4724 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4726 flags
= elf_elfheader (abfd
)->e_flags
;
4728 /* xgettext:c-format */
4729 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4731 if (flags
& EF_BFIN_PIC
)
4732 fprintf (file
, " -fpic");
4734 if (flags
& EF_BFIN_FDPIC
)
4735 fprintf (file
, " -mfdpic");
4742 /* Merge backend specific data from an object file to the output
4743 object file when linking. */
4746 elf32_bfin_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4748 bfd
*obfd
= info
->output_bfd
;
4749 flagword old_flags
, new_flags
;
4752 /* FIXME: What should be checked when linking shared libraries? */
4753 if ((ibfd
->flags
& DYNAMIC
) != 0)
4756 new_flags
= elf_elfheader (ibfd
)->e_flags
;
4757 old_flags
= elf_elfheader (obfd
)->e_flags
;
4759 if (new_flags
& EF_BFIN_FDPIC
)
4760 new_flags
&= ~EF_BFIN_PIC
;
4766 ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %pB",
4767 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no", ibfd
);
4769 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
4771 elf_flags_init (obfd
) = true;
4772 elf_elfheader (obfd
)->e_flags
= new_flags
;
4775 if (((new_flags
& EF_BFIN_FDPIC
) == 0) != (! IS_FDPIC (obfd
)))
4778 if (IS_FDPIC (obfd
))
4780 (_("%pB: cannot link non-fdpic object file into fdpic executable"),
4784 (_("%pB: cannot link fdpic object file into non-fdpic executable"),
4789 bfd_set_error (bfd_error_bad_value
);
4794 /* bfin ELF linker hash entry. */
4796 struct bfin_link_hash_entry
4798 struct elf_link_hash_entry root
;
4800 /* Number of PC relative relocs copied for this symbol. */
4801 struct bfin_pcrel_relocs_copied
*pcrel_relocs_copied
;
4804 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4806 static struct bfd_hash_entry
*
4807 bfin_link_hash_newfunc (struct bfd_hash_entry
*entry
,
4808 struct bfd_hash_table
*table
, const char *string
)
4810 struct bfd_hash_entry
*ret
= entry
;
4812 /* Allocate the structure if it has not already been allocated by a
4815 ret
= bfd_hash_allocate (table
, sizeof (struct bfin_link_hash_entry
));
4819 /* Call the allocation method of the superclass. */
4820 ret
= _bfd_elf_link_hash_newfunc (ret
, table
, string
);
4822 bfin_hash_entry (ret
)->pcrel_relocs_copied
= NULL
;
4827 /* Create an bfin ELF linker hash table. */
4829 static struct bfd_link_hash_table
*
4830 bfin_link_hash_table_create (bfd
* abfd
)
4832 struct elf_link_hash_table
*ret
;
4833 size_t amt
= sizeof (struct elf_link_hash_table
);
4835 ret
= bfd_zmalloc (amt
);
4839 if (!_bfd_elf_link_hash_table_init (ret
, abfd
, bfin_link_hash_newfunc
,
4840 sizeof (struct elf_link_hash_entry
),
4850 /* The size in bytes of an entry in the procedure linkage table. */
4852 /* Finish up the dynamic sections. */
4855 bfin_finish_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
4856 struct bfd_link_info
*info
)
4861 dynobj
= elf_hash_table (info
)->dynobj
;
4863 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4865 if (elf_hash_table (info
)->dynamic_sections_created
)
4867 Elf32_External_Dyn
*dyncon
, *dynconend
;
4869 BFD_ASSERT (sdyn
!= NULL
);
4871 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4872 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4873 for (; dyncon
< dynconend
; dyncon
++)
4875 Elf_Internal_Dyn dyn
;
4877 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4885 /* Finish up dynamic symbol handling. We set the contents of various
4886 dynamic sections here. */
4889 bfin_finish_dynamic_symbol (bfd
* output_bfd
,
4890 struct bfd_link_info
*info
,
4891 struct elf_link_hash_entry
*h
,
4892 Elf_Internal_Sym
* sym
)
4894 if (h
->got
.offset
!= (bfd_vma
) - 1)
4898 Elf_Internal_Rela rela
;
4901 /* This symbol has an entry in the global offset table.
4904 sgot
= elf_hash_table (info
)->sgot
;
4905 srela
= elf_hash_table (info
)->srelgot
;
4906 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
4908 rela
.r_offset
= (sgot
->output_section
->vma
4909 + sgot
->output_offset
4910 + (h
->got
.offset
& ~(bfd_vma
) 1));
4912 /* If this is a -Bsymbolic link, and the symbol is defined
4913 locally, we just want to emit a RELATIVE reloc. Likewise if
4914 the symbol was forced to be local because of a version file.
4915 The entry in the global offset table will already have been
4916 initialized in the relocate_section function. */
4917 if (bfd_link_pic (info
)
4919 || h
->dynindx
== -1 || h
->forced_local
) && h
->def_regular
)
4921 _bfd_error_handler (_("*** check this relocation %s"),
4923 rela
.r_info
= ELF32_R_INFO (0, R_BFIN_PCREL24
);
4924 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
4928 offset
& ~(bfd_vma
) 1)));
4932 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4933 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
4934 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_BFIN_GOT
);
4938 loc
= srela
->contents
;
4939 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4940 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4947 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4948 if (strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
4949 || h
== elf_hash_table (info
)->hgot
)
4950 sym
->st_shndx
= SHN_ABS
;
4955 /* Adjust a symbol defined by a dynamic object and referenced by a
4956 regular object. The current definition is in some section of the
4957 dynamic object, but we're not including those sections. We have to
4958 change the definition to something the rest of the link can
4962 bfin_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4963 struct elf_link_hash_entry
*h
)
4967 unsigned int power_of_two
;
4969 dynobj
= elf_hash_table (info
)->dynobj
;
4971 /* Make sure we know what is going on here. */
4972 BFD_ASSERT (dynobj
!= NULL
4975 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
4977 /* If this is a function, put it in the procedure linkage table. We
4978 will fill in the contents of the procedure linkage table later,
4979 when we know the address of the .got section. */
4980 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
4985 /* If this is a weak symbol, and there is a real definition, the
4986 processor independent code will have arranged for us to see the
4987 real definition first, and we can just use the same value. */
4988 if (h
->is_weakalias
)
4990 struct elf_link_hash_entry
*def
= weakdef (h
);
4991 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
4992 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
4993 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
4997 /* This is a reference to a symbol defined by a dynamic object which
4998 is not a function. */
5000 /* If we are creating a shared library, we must presume that the
5001 only references to the symbol are via the global offset table.
5002 For such cases we need not do anything here; the relocations will
5003 be handled correctly by relocate_section. */
5004 if (bfd_link_pic (info
))
5007 /* We must allocate the symbol in our .dynbss section, which will
5008 become part of the .bss section of the executable. There will be
5009 an entry for this symbol in the .dynsym section. The dynamic
5010 object will contain position independent code, so all references
5011 from the dynamic object to this symbol will go through the global
5012 offset table. The dynamic linker will use the .dynsym entry to
5013 determine the address it must put in the global offset table, so
5014 both the dynamic object and the regular object will refer to the
5015 same memory location for the variable. */
5017 s
= bfd_get_linker_section (dynobj
, ".dynbss");
5018 BFD_ASSERT (s
!= NULL
);
5020 #if 0 /* Bfin does not currently have a COPY reloc. */
5021 /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5022 copy the initial value out of the dynamic object and into the
5023 runtime process image. We need to remember the offset into the
5024 .rela.bss section we are going to use. */
5025 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5029 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
5030 BFD_ASSERT (srel
!= NULL
);
5031 srel
->size
+= sizeof (Elf32_External_Rela
);
5035 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5037 _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5041 /* We need to figure out the alignment required for this symbol. I
5042 have no idea how ELF linkers handle this. */
5043 power_of_two
= bfd_log2 (h
->size
);
5044 if (power_of_two
> 3)
5047 /* Apply the required alignment. */
5048 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
5049 if (power_of_two
> bfd_section_alignment (s
))
5051 if (!bfd_set_section_alignment (s
, power_of_two
))
5055 /* Define the symbol as being at this point in the section. */
5056 h
->root
.u
.def
.section
= s
;
5057 h
->root
.u
.def
.value
= s
->size
;
5059 /* Increment the section size to make room for the symbol. */
5065 /* The bfin linker needs to keep track of the number of relocs that it
5066 decides to copy in check_relocs for each symbol. This is so that it
5067 can discard PC relative relocs if it doesn't need them when linking
5068 with -Bsymbolic. We store the information in a field extending the
5069 regular ELF linker hash table. */
5071 /* This structure keeps track of the number of PC relative relocs we have
5072 copied for a given symbol. */
5074 struct bfin_pcrel_relocs_copied
5077 struct bfin_pcrel_relocs_copied
*next
;
5078 /* A section in dynobj. */
5080 /* Number of relocs copied in this section. */
5081 bfd_size_type count
;
5084 /* This function is called via elf_link_hash_traverse if we are
5085 creating a shared object. In the -Bsymbolic case it discards the
5086 space allocated to copy PC relative relocs against symbols which
5087 are defined in regular objects. For the normal shared case, it
5088 discards space for pc-relative relocs that have become local due to
5089 symbol visibility changes. We allocated space for them in the
5090 check_relocs routine, but we won't fill them in in the
5091 relocate_section routine.
5093 We also check whether any of the remaining relocations apply
5094 against a readonly section, and set the DF_TEXTREL flag in this
5098 bfin_discard_copies (struct elf_link_hash_entry
*h
, void * inf
)
5100 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5101 struct bfin_pcrel_relocs_copied
*s
;
5103 if (!h
->def_regular
|| (!info
->symbolic
&& !h
->forced_local
))
5105 if ((info
->flags
& DF_TEXTREL
) == 0)
5107 /* Look for relocations against read-only sections. */
5108 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5109 s
!= NULL
; s
= s
->next
)
5110 if ((s
->section
->flags
& SEC_READONLY
) != 0)
5112 info
->flags
|= DF_TEXTREL
;
5120 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5121 s
!= NULL
; s
= s
->next
)
5122 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
5128 bfin_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5129 struct bfd_link_info
*info
)
5135 dynobj
= elf_hash_table (info
)->dynobj
;
5136 BFD_ASSERT (dynobj
!= NULL
);
5138 if (elf_hash_table (info
)->dynamic_sections_created
)
5140 /* Set the contents of the .interp section to the interpreter. */
5141 if (bfd_link_executable (info
) && !info
->nointerp
)
5143 s
= bfd_get_linker_section (dynobj
, ".interp");
5144 BFD_ASSERT (s
!= NULL
);
5145 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5146 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5151 /* We may have created entries in the .rela.got section.
5152 However, if we are not creating the dynamic sections, we will
5153 not actually use these entries. Reset the size of .rela.got,
5154 which will cause it to get stripped from the output file
5156 s
= elf_hash_table (info
)->srelgot
;
5161 /* If this is a -Bsymbolic shared link, then we need to discard all
5162 PC relative relocs against symbols defined in a regular object.
5163 For the normal shared case we discard the PC relative relocs
5164 against symbols that have become local due to visibility changes.
5165 We allocated space for them in the check_relocs routine, but we
5166 will not fill them in in the relocate_section routine. */
5167 if (bfd_link_pic (info
))
5168 elf_link_hash_traverse (elf_hash_table (info
),
5169 bfin_discard_copies
, info
);
5171 /* The check_relocs and adjust_dynamic_symbol entry points have
5172 determined the sizes of the various dynamic sections. Allocate
5175 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5180 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5183 /* It's OK to base decisions on the section name, because none
5184 of the dynobj section names depend upon the input files. */
5185 name
= bfd_section_name (s
);
5189 if (startswith (name
, ".rela"))
5193 /* If we don't need this section, strip it from the
5194 output file. This is mostly to handle .rela.bss and
5195 .rela.plt. We must create both sections in
5196 create_dynamic_sections, because they must be created
5197 before the linker maps input sections to output
5198 sections. The linker does that before
5199 adjust_dynamic_symbol is called, and it is that
5200 function which decides whether anything needs to go
5201 into these sections. */
5208 /* We use the reloc_count field as a counter if we need
5209 to copy relocs into the output file. */
5213 else if (! startswith (name
, ".got"))
5215 /* It's not one of our sections, so don't allocate space. */
5221 s
->flags
|= SEC_EXCLUDE
;
5225 /* Allocate memory for the section contents. */
5226 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5227 Unused entries should be reclaimed before the section's contents
5228 are written out, but at the moment this does not happen. Thus in
5229 order to prevent writing out garbage, we initialise the section's
5230 contents to zero. */
5231 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5232 if (s
->contents
== NULL
&& s
->size
!= 0)
5236 if (elf_hash_table (info
)->dynamic_sections_created
)
5238 /* Add some entries to the .dynamic section. We fill in the
5239 values later, in bfin_finish_dynamic_sections, but we
5240 must add the entries now so that we get the correct size for
5241 the .dynamic section. The DT_DEBUG entry is filled in by the
5242 dynamic linker and used by the debugger. */
5243 #define add_dynamic_entry(TAG, VAL) \
5244 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5246 if (!bfd_link_pic (info
))
5248 if (!add_dynamic_entry (DT_DEBUG
, 0))
5255 if (!add_dynamic_entry (DT_RELA
, 0)
5256 || !add_dynamic_entry (DT_RELASZ
, 0)
5257 || !add_dynamic_entry (DT_RELAENT
,
5258 sizeof (Elf32_External_Rela
)))
5262 if ((info
->flags
& DF_TEXTREL
) != 0)
5264 if (!add_dynamic_entry (DT_TEXTREL
, 0))
5268 #undef add_dynamic_entry
5273 /* Given a .data section and a .emreloc in-memory section, store
5274 relocation information into the .emreloc section which can be
5275 used at runtime to relocate the section. This is called by the
5276 linker when the --embedded-relocs switch is used. This is called
5277 after the add_symbols entry point has been called for all the
5278 objects, and before the final_link entry point is called. */
5281 bfd_bfin_elf32_create_embedded_relocs (bfd
*abfd
,
5282 struct bfd_link_info
*info
,
5287 Elf_Internal_Shdr
*symtab_hdr
;
5288 Elf_Internal_Sym
*isymbuf
= NULL
;
5289 Elf_Internal_Rela
*internal_relocs
= NULL
;
5290 Elf_Internal_Rela
*irel
, *irelend
;
5294 BFD_ASSERT (! bfd_link_relocatable (info
));
5298 if (datasec
->reloc_count
== 0)
5301 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5303 /* Get a copy of the native relocations. */
5304 internal_relocs
= (_bfd_elf_link_read_relocs
5305 (abfd
, datasec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5306 info
->keep_memory
));
5307 if (internal_relocs
== NULL
)
5310 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
5311 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
5312 if (relsec
->contents
== NULL
)
5315 p
= relsec
->contents
;
5317 irelend
= internal_relocs
+ datasec
->reloc_count
;
5318 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
5320 asection
*targetsec
;
5322 /* We are going to write a four byte longword into the runtime
5323 reloc section. The longword will be the address in the data
5324 section which must be relocated. It is followed by the name
5325 of the target section NUL-padded or truncated to 8
5328 /* We can only relocate absolute longword relocs at run time. */
5329 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_BFIN_BYTE4_DATA
)
5331 *errmsg
= _("unsupported relocation type");
5332 bfd_set_error (bfd_error_bad_value
);
5336 /* Get the target section referred to by the reloc. */
5337 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
5339 /* A local symbol. */
5340 Elf_Internal_Sym
*isym
;
5342 /* Read this BFD's local symbols if we haven't done so already. */
5343 if (isymbuf
== NULL
)
5345 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5346 if (isymbuf
== NULL
)
5347 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5348 symtab_hdr
->sh_info
, 0,
5350 if (isymbuf
== NULL
)
5354 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
5355 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5360 struct elf_link_hash_entry
*h
;
5362 /* An external symbol. */
5363 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
5364 h
= elf_sym_hashes (abfd
)[indx
];
5365 BFD_ASSERT (h
!= NULL
);
5366 if (h
->root
.type
== bfd_link_hash_defined
5367 || h
->root
.type
== bfd_link_hash_defweak
)
5368 targetsec
= h
->root
.u
.def
.section
;
5373 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
5374 memset (p
+ 4, 0, 8);
5375 if (targetsec
!= NULL
)
5376 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
5379 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5381 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
5382 free (internal_relocs
);
5386 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5388 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
5389 free (internal_relocs
);
5393 struct bfd_elf_special_section
const elf32_bfin_special_sections
[] =
5395 { ".l1.text", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5396 { ".l1.data", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
5397 { NULL
, 0, 0, 0, 0 }
5401 #define TARGET_LITTLE_SYM bfin_elf32_vec
5402 #define TARGET_LITTLE_NAME "elf32-bfin"
5403 #define ELF_ARCH bfd_arch_bfin
5404 #define ELF_TARGET_ID BFIN_ELF_DATA
5405 #define ELF_MACHINE_CODE EM_BLACKFIN
5406 #define ELF_MAXPAGESIZE 0x1000
5407 #define elf_symbol_leading_char '_'
5409 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5410 #define bfd_elf32_bfd_reloc_name_lookup \
5411 bfin_bfd_reloc_name_lookup
5412 #define elf_info_to_howto bfin_info_to_howto
5413 #define elf_info_to_howto_rel NULL
5414 #define elf_backend_object_p elf32_bfin_object_p
5416 #define bfd_elf32_bfd_is_local_label_name \
5417 bfin_is_local_label_name
5419 #define elf_backend_create_dynamic_sections \
5420 _bfd_elf_create_dynamic_sections
5421 #define bfd_elf32_bfd_link_hash_table_create \
5422 bfin_link_hash_table_create
5423 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5425 #define elf_backend_check_relocs bfin_check_relocs
5426 #define elf_backend_adjust_dynamic_symbol \
5427 bfin_adjust_dynamic_symbol
5428 #define elf_backend_size_dynamic_sections \
5429 bfin_size_dynamic_sections
5430 #define elf_backend_relocate_section bfin_relocate_section
5431 #define elf_backend_finish_dynamic_symbol \
5432 bfin_finish_dynamic_symbol
5433 #define elf_backend_finish_dynamic_sections \
5434 bfin_finish_dynamic_sections
5435 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5436 #define bfd_elf32_bfd_merge_private_bfd_data \
5437 elf32_bfin_merge_private_bfd_data
5438 #define bfd_elf32_bfd_set_private_flags \
5439 elf32_bfin_set_private_flags
5440 #define bfd_elf32_bfd_print_private_bfd_data \
5441 elf32_bfin_print_private_bfd_data
5442 #define elf_backend_final_write_processing \
5443 elf32_bfin_final_write_processing
5444 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5445 #define elf_backend_stack_align 8
5446 #define elf_backend_can_gc_sections 1
5447 #define elf_backend_special_sections elf32_bfin_special_sections
5448 #define elf_backend_can_refcount 1
5449 #define elf_backend_want_got_plt 0
5450 #define elf_backend_plt_readonly 1
5451 #define elf_backend_want_plt_sym 0
5452 #define elf_backend_got_header_size 12
5453 #define elf_backend_rela_normal 1
5455 #include "elf32-target.h"
5457 #undef TARGET_LITTLE_SYM
5458 #define TARGET_LITTLE_SYM bfin_elf32_fdpic_vec
5459 #undef TARGET_LITTLE_NAME
5460 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5462 #define elf32_bed elf32_bfinfdpic_bed
5464 #undef elf_backend_got_header_size
5465 #define elf_backend_got_header_size 0
5467 #undef elf_backend_relocate_section
5468 #define elf_backend_relocate_section bfinfdpic_relocate_section
5469 #undef elf_backend_check_relocs
5470 #define elf_backend_check_relocs bfinfdpic_check_relocs
5472 #undef bfd_elf32_bfd_link_hash_table_create
5473 #define bfd_elf32_bfd_link_hash_table_create \
5474 bfinfdpic_elf_link_hash_table_create
5475 #undef elf_backend_always_size_sections
5476 #define elf_backend_always_size_sections \
5477 elf32_bfinfdpic_always_size_sections
5479 #undef elf_backend_create_dynamic_sections
5480 #define elf_backend_create_dynamic_sections \
5481 elf32_bfinfdpic_create_dynamic_sections
5482 #undef elf_backend_adjust_dynamic_symbol
5483 #define elf_backend_adjust_dynamic_symbol \
5484 elf32_bfinfdpic_adjust_dynamic_symbol
5485 #undef elf_backend_size_dynamic_sections
5486 #define elf_backend_size_dynamic_sections \
5487 elf32_bfinfdpic_size_dynamic_sections
5488 #undef elf_backend_finish_dynamic_symbol
5489 #define elf_backend_finish_dynamic_symbol \
5490 elf32_bfinfdpic_finish_dynamic_symbol
5491 #undef elf_backend_finish_dynamic_sections
5492 #define elf_backend_finish_dynamic_sections \
5493 elf32_bfinfdpic_finish_dynamic_sections
5495 #undef elf_backend_discard_info
5496 #define elf_backend_discard_info \
5497 bfinfdpic_elf_discard_info
5498 #undef elf_backend_can_make_relative_eh_frame
5499 #define elf_backend_can_make_relative_eh_frame \
5500 bfinfdpic_elf_use_relative_eh_frame
5501 #undef elf_backend_can_make_lsda_relative_eh_frame
5502 #define elf_backend_can_make_lsda_relative_eh_frame \
5503 bfinfdpic_elf_use_relative_eh_frame
5504 #undef elf_backend_encode_eh_address
5505 #define elf_backend_encode_eh_address \
5506 bfinfdpic_elf_encode_eh_address
5508 #undef elf_backend_may_use_rel_p
5509 #define elf_backend_may_use_rel_p 1
5510 #undef elf_backend_may_use_rela_p
5511 #define elf_backend_may_use_rela_p 1
5512 /* We use REL for dynamic relocations only. */
5513 #undef elf_backend_default_use_rela_p
5514 #define elf_backend_default_use_rela_p 1
5516 #undef elf_backend_omit_section_dynsym
5517 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5519 #include "elf32-target.h"