1 /* ADI Blackfin BFD support for 32-bit ELF.
2 Copyright (C) 2005-2020 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean 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 bfd_boolean elf32_bfin_code_in_l1
= 0;
1134 /* Set by ld emulation if --data-in-l1. */
1135 bfd_boolean 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
];
1202 switch (ELF32_R_TYPE (rel
->r_info
))
1204 /* This relocation describes the C++ object vtable hierarchy.
1205 Reconstruct it for later use during GC. */
1206 case R_BFIN_GNU_VTINHERIT
:
1207 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1211 /* This relocation describes which C++ vtable entries
1212 are actually used. Record for later use during GC. */
1213 case R_BFIN_GNU_VTENTRY
:
1214 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1220 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1226 /* Create the .got section. */
1227 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1228 if (!_bfd_elf_create_got_section (dynobj
, info
))
1232 sgot
= elf_hash_table (info
)->sgot
;
1233 srelgot
= elf_hash_table (info
)->srelgot
;
1234 BFD_ASSERT (sgot
!= NULL
);
1238 if (h
->got
.refcount
== 0)
1240 /* Make sure this symbol is output as a dynamic symbol. */
1241 if (h
->dynindx
== -1 && !h
->forced_local
)
1243 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
1247 /* Allocate space in the .got section. */
1249 /* Allocate relocation space. */
1250 srelgot
->size
+= sizeof (Elf32_External_Rela
);
1256 /* This is a global offset table entry for a local symbol. */
1257 if (local_got_refcounts
== NULL
)
1261 size
= symtab_hdr
->sh_info
;
1262 size
*= sizeof (bfd_signed_vma
);
1263 local_got_refcounts
= ((bfd_signed_vma
*)
1264 bfd_zalloc (abfd
, size
));
1265 if (local_got_refcounts
== NULL
)
1267 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1269 if (local_got_refcounts
[r_symndx
] == 0)
1272 if (bfd_link_pic (info
))
1274 /* If we are generating a shared object, we need to
1275 output a R_68K_RELATIVE reloc so that the dynamic
1276 linker can adjust this GOT entry. */
1277 srelgot
->size
+= sizeof (Elf32_External_Rela
);
1280 local_got_refcounts
[r_symndx
]++;
1292 static enum elf_reloc_type_class
1293 elf32_bfin_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1294 const asection
*rel_sec ATTRIBUTE_UNUSED
,
1295 const Elf_Internal_Rela
* rela
)
1297 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1300 return reloc_class_normal
;
1304 static bfd_reloc_status_type
1305 bfin_final_link_relocate (Elf_Internal_Rela
*rel
, reloc_howto_type
*howto
,
1306 bfd
*input_bfd
, asection
*input_section
,
1307 bfd_byte
*contents
, bfd_vma address
,
1308 bfd_vma value
, bfd_vma addend
)
1310 int r_type
= ELF32_R_TYPE (rel
->r_info
);
1312 if (r_type
== R_BFIN_PCREL24
|| r_type
== R_BFIN_PCREL24_JUMP_L
)
1314 bfd_reloc_status_type r
= bfd_reloc_ok
;
1317 if (address
> bfd_get_section_limit (input_bfd
, input_section
))
1318 return bfd_reloc_outofrange
;
1322 /* Perform usual pc-relative correction. */
1323 value
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
1326 /* We are getting reloc_entry->address 2 byte off from
1327 the start of instruction. Assuming absolute postion
1328 of the reloc data. But, following code had been written assuming
1329 reloc address is starting at begining of instruction.
1330 To compensate that I have increased the value of
1331 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
1336 if ((value
& 0xFF000000) != 0
1337 && (value
& 0xFF000000) != 0xFF000000)
1338 r
= bfd_reloc_overflow
;
1342 x
= bfd_get_16 (input_bfd
, contents
+ address
);
1343 x
= (x
& 0xff00) | ((value
>> 16) & 0xff);
1344 bfd_put_16 (input_bfd
, x
, contents
+ address
);
1346 x
= bfd_get_16 (input_bfd
, contents
+ address
+ 2);
1348 bfd_put_16 (input_bfd
, x
, contents
+ address
+ 2);
1352 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
1353 rel
->r_offset
, value
, addend
);
1358 bfin_relocate_section (bfd
* output_bfd
,
1359 struct bfd_link_info
*info
,
1361 asection
* input_section
,
1362 bfd_byte
* contents
,
1363 Elf_Internal_Rela
* relocs
,
1364 Elf_Internal_Sym
* local_syms
,
1365 asection
** local_sections
)
1368 Elf_Internal_Shdr
*symtab_hdr
;
1369 struct elf_link_hash_entry
**sym_hashes
;
1370 bfd_vma
*local_got_offsets
;
1372 Elf_Internal_Rela
*rel
;
1373 Elf_Internal_Rela
*relend
;
1376 dynobj
= elf_hash_table (info
)->dynobj
;
1377 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1378 sym_hashes
= elf_sym_hashes (input_bfd
);
1379 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1384 relend
= relocs
+ input_section
->reloc_count
;
1385 for (; rel
< relend
; rel
++, i
++)
1388 reloc_howto_type
*howto
;
1389 unsigned long r_symndx
;
1390 struct elf_link_hash_entry
*h
;
1391 Elf_Internal_Sym
*sym
;
1393 bfd_vma relocation
= 0;
1394 bfd_boolean unresolved_reloc
;
1395 bfd_reloc_status_type r
;
1398 r_type
= ELF32_R_TYPE (rel
->r_info
);
1399 if (r_type
< 0 || r_type
>= 243)
1401 bfd_set_error (bfd_error_bad_value
);
1405 if (r_type
== R_BFIN_GNU_VTENTRY
1406 || r_type
== R_BFIN_GNU_VTINHERIT
)
1409 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
1412 bfd_set_error (bfd_error_bad_value
);
1415 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1420 unresolved_reloc
= FALSE
;
1422 if (r_symndx
< symtab_hdr
->sh_info
)
1424 sym
= local_syms
+ r_symndx
;
1425 sec
= local_sections
[r_symndx
];
1426 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1430 bfd_boolean warned
, ignored
;
1432 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1433 r_symndx
, symtab_hdr
, sym_hashes
,
1435 unresolved_reloc
, warned
, ignored
);
1438 if (sec
!= NULL
&& discarded_section (sec
))
1439 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1440 rel
, 1, relend
, howto
, 0, contents
);
1442 if (bfd_link_relocatable (info
))
1445 address
= rel
->r_offset
;
1447 /* Then, process normally. */
1450 case R_BFIN_GNU_VTINHERIT
:
1451 case R_BFIN_GNU_VTENTRY
:
1452 return bfd_reloc_ok
;
1455 /* Relocation is to the address of the entry for this symbol
1456 in the global offset table. */
1458 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1461 /* Relocation is the offset of the entry for this symbol in
1462 the global offset table. */
1469 /* Create the .got section. */
1470 elf_hash_table (info
)->dynobj
= dynobj
= output_bfd
;
1471 if (!_bfd_elf_create_got_section (dynobj
, info
))
1475 sgot
= elf_hash_table (info
)->sgot
;
1476 BFD_ASSERT (sgot
!= NULL
);
1482 off
= h
->got
.offset
;
1483 BFD_ASSERT (off
!= (bfd_vma
) - 1);
1484 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1486 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
1487 bfd_link_pic (info
),
1489 || (bfd_link_pic (info
)
1495 /* This is actually a static link, or it is a
1496 -Bsymbolic link and the symbol is defined
1497 locally, or the symbol was forced to be local
1498 because of a version file.. We must initialize
1499 this entry in the global offset table. Since
1500 the offset must always be a multiple of 4, we
1501 use the least significant bit to record whether
1502 we have initialized it already.
1504 When doing a dynamic link, we create a .rela.got
1505 relocation entry to initialize the value. This
1506 is done in the finish_dynamic_symbol routine. */
1511 bfd_put_32 (output_bfd
, relocation
,
1512 sgot
->contents
+ off
);
1517 unresolved_reloc
= FALSE
;
1521 BFD_ASSERT (local_got_offsets
!= NULL
);
1522 off
= local_got_offsets
[r_symndx
];
1523 BFD_ASSERT (off
!= (bfd_vma
) - 1);
1525 /* The offset must always be a multiple of 4. We use
1526 the least significant bit to record whether we have
1527 already generated the necessary reloc. */
1532 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1534 if (bfd_link_pic (info
))
1537 Elf_Internal_Rela outrel
;
1540 s
= elf_hash_table (info
)->srelgot
;
1541 BFD_ASSERT (s
!= NULL
);
1543 outrel
.r_offset
= (sgot
->output_section
->vma
1544 + sgot
->output_offset
+ off
);
1546 ELF32_R_INFO (0, R_BFIN_PCREL24
);
1547 outrel
.r_addend
= relocation
;
1550 s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1551 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1554 local_got_offsets
[r_symndx
] |= 1;
1558 relocation
= sgot
->output_offset
+ off
;
1560 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */
1567 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
1569 relocation
, rel
->r_addend
);
1574 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1575 because such sections are not SEC_ALLOC and thus ld.so will
1576 not process them. */
1577 if (unresolved_reloc
1578 && !((input_section
->flags
& SEC_DEBUGGING
) != 0 && h
->def_dynamic
)
1579 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1580 rel
->r_offset
) != (bfd_vma
) -1)
1583 /* xgettext:c-format */
1584 (_("%pB(%pA+%#" PRIx64
"): "
1585 "unresolvable relocation against symbol `%s'"),
1586 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
1587 h
->root
.root
.string
);
1591 if (r
!= bfd_reloc_ok
)
1596 name
= h
->root
.root
.string
;
1599 name
= bfd_elf_string_from_elf_section (input_bfd
,
1600 symtab_hdr
->sh_link
,
1605 name
= bfd_section_name (sec
);
1608 if (r
== bfd_reloc_overflow
)
1609 (*info
->callbacks
->reloc_overflow
)
1610 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1611 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1615 /* xgettext:c-format */
1616 (_("%pB(%pA+%#" PRIx64
"): reloc against `%s': error %d"),
1617 input_bfd
, input_section
, (uint64_t) rel
->r_offset
,
1628 bfin_gc_mark_hook (asection
* sec
,
1629 struct bfd_link_info
*info
,
1630 Elf_Internal_Rela
* rel
,
1631 struct elf_link_hash_entry
*h
,
1632 Elf_Internal_Sym
* sym
)
1635 switch (ELF32_R_TYPE (rel
->r_info
))
1637 case R_BFIN_GNU_VTINHERIT
:
1638 case R_BFIN_GNU_VTENTRY
:
1642 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1645 extern const bfd_target bfin_elf32_fdpic_vec
;
1646 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfin_elf32_fdpic_vec)
1648 /* An extension of the elf hash table data structure,
1649 containing some additional Blackfin-specific data. */
1650 struct bfinfdpic_elf_link_hash_table
1652 struct elf_link_hash_table elf
;
1654 /* A pointer to the .rofixup section. */
1655 asection
*sgotfixup
;
1656 /* GOT base offset. */
1658 /* Location of the first non-lazy PLT entry, i.e., the number of
1659 bytes taken by lazy PLT entries. */
1661 /* A hash table holding information about which symbols were
1662 referenced with which PIC-related relocations. */
1663 struct htab
*relocs_info
;
1664 /* Summary reloc information collected by
1665 _bfinfdpic_count_got_plt_entries. */
1666 struct _bfinfdpic_dynamic_got_info
*g
;
1669 /* Get the Blackfin ELF linker hash table from a link_info structure. */
1671 #define bfinfdpic_hash_table(info) \
1672 (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
1673 == BFIN_ELF_DATA ? ((struct bfinfdpic_elf_link_hash_table *) ((info)->hash)) : NULL)
1675 #define bfinfdpic_got_section(info) \
1676 (bfinfdpic_hash_table (info)->elf.sgot)
1677 #define bfinfdpic_gotrel_section(info) \
1678 (bfinfdpic_hash_table (info)->elf.srelgot)
1679 #define bfinfdpic_gotfixup_section(info) \
1680 (bfinfdpic_hash_table (info)->sgotfixup)
1681 #define bfinfdpic_plt_section(info) \
1682 (bfinfdpic_hash_table (info)->elf.splt)
1683 #define bfinfdpic_pltrel_section(info) \
1684 (bfinfdpic_hash_table (info)->elf.srelplt)
1685 #define bfinfdpic_relocs_info(info) \
1686 (bfinfdpic_hash_table (info)->relocs_info)
1687 #define bfinfdpic_got_initial_offset(info) \
1688 (bfinfdpic_hash_table (info)->got0)
1689 #define bfinfdpic_plt_initial_offset(info) \
1690 (bfinfdpic_hash_table (info)->plt0)
1691 #define bfinfdpic_dynamic_got_plt_info(info) \
1692 (bfinfdpic_hash_table (info)->g)
1694 /* The name of the dynamic interpreter. This is put in the .interp
1697 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1699 #define DEFAULT_STACK_SIZE 0x20000
1701 /* This structure is used to collect the number of entries present in
1702 each addressable range of the got. */
1703 struct _bfinfdpic_dynamic_got_info
1705 /* Several bits of information about the current link. */
1706 struct bfd_link_info
*info
;
1707 /* Total size needed for GOT entries within the 18- or 32-bit
1709 bfd_vma got17m4
, gothilo
;
1710 /* Total size needed for function descriptor entries within the 18-
1711 or 32-bit ranges. */
1712 bfd_vma fd17m4
, fdhilo
;
1713 /* Total size needed function descriptor entries referenced in PLT
1714 entries, that would be profitable to place in offsets close to
1715 the PIC register. */
1717 /* Total size needed by lazy PLT entries. */
1719 /* Number of relocations carried over from input object files. */
1720 unsigned long relocs
;
1721 /* Number of fixups introduced by relocations in input object files. */
1722 unsigned long fixups
;
1725 /* Create a Blackfin ELF linker hash table. */
1727 static struct bfd_link_hash_table
*
1728 bfinfdpic_elf_link_hash_table_create (bfd
*abfd
)
1730 struct bfinfdpic_elf_link_hash_table
*ret
;
1731 size_t amt
= sizeof (struct bfinfdpic_elf_link_hash_table
);
1733 ret
= bfd_zmalloc (amt
);
1737 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1738 _bfd_elf_link_hash_newfunc
,
1739 sizeof (struct elf_link_hash_entry
),
1746 return &ret
->elf
.root
;
1749 /* Decide whether a reference to a symbol can be resolved locally or
1750 not. If the symbol is protected, we want the local address, but
1751 its function descriptor must be assigned by the dynamic linker. */
1752 #define BFINFDPIC_SYM_LOCAL(INFO, H) \
1753 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1754 || ! elf_hash_table (INFO)->dynamic_sections_created)
1755 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1756 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1758 /* This structure collects information on what kind of GOT, PLT or
1759 function descriptors are required by relocations that reference a
1761 struct bfinfdpic_relocs_info
1763 /* The index of the symbol, as stored in the relocation r_info, if
1764 we have a local symbol; -1 otherwise. */
1768 /* The input bfd in which the symbol is defined, if it's a local
1771 /* If symndx == -1, the hash table entry corresponding to a global
1772 symbol (even if it turns out to bind locally, in which case it
1773 should ideally be replaced with section's symndx + addend). */
1774 struct elf_link_hash_entry
*h
;
1776 /* The addend of the relocation that references the symbol. */
1779 /* The fields above are used to identify an entry. The fields below
1780 contain information on how an entry is used and, later on, which
1781 locations it was assigned. */
1782 /* The following 2 fields record whether the symbol+addend above was
1783 ever referenced with a GOT relocation. The 17M4 suffix indicates a
1784 GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */
1787 /* Whether a FUNCDESC relocation references symbol+addend. */
1789 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1792 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1793 unsigned fdgoff17m4
;
1794 unsigned fdgoffhilo
;
1795 /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1796 GOTOFFHI relocations. The addend doesn't really matter, since we
1797 envision that this will only be used to check whether the symbol
1798 is mapped to the same segment as the got. */
1800 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1802 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1805 /* Whether we need a PLT entry for a symbol. Should be implied by
1807 (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */
1809 /* Whether a function descriptor should be created in this link unit
1810 for symbol+addend. Should be implied by something like:
1811 (plt || fdgotoff17m4 || fdgotofflohi
1812 || ((fd || fdgot17m4 || fdgothilo)
1813 && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1815 /* Whether a lazy PLT entry is needed for this symbol+addend.
1816 Should be implied by something like:
1817 (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1818 && ! (info->flags & DF_BIND_NOW)) */
1820 /* Whether we've already emitted GOT relocations and PLT entries as
1821 needed for this symbol. */
1824 /* The number of R_BFIN_BYTE4_DATA, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1825 relocations referencing the symbol. */
1826 unsigned relocs32
, relocsfd
, relocsfdv
;
1828 /* The number of .rofixups entries and dynamic relocations allocated
1829 for this symbol, minus any that might have already been used. */
1830 unsigned fixups
, dynrelocs
;
1832 /* The offsets of the GOT entries assigned to symbol+addend, to the
1833 function descriptor's address, and to a function descriptor,
1834 respectively. Should be zero if unassigned. The offsets are
1835 counted from the value that will be assigned to the PIC register,
1836 not from the beginning of the .got section. */
1837 bfd_signed_vma got_entry
, fdgot_entry
, fd_entry
;
1838 /* The offsets of the PLT entries assigned to symbol+addend,
1839 non-lazy and lazy, respectively. If unassigned, should be
1841 bfd_vma plt_entry
, lzplt_entry
;
1844 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry. */
1846 bfinfdpic_relocs_info_hash (const void *entry_
)
1848 const struct bfinfdpic_relocs_info
*entry
= entry_
;
1850 return (entry
->symndx
== -1
1851 ? (long) entry
->d
.h
->root
.root
.hash
1852 : entry
->symndx
+ (long) entry
->d
.abfd
->id
* 257) + entry
->addend
;
1855 /* Test whether the key fields of two bfinfdpic_relocs_info entries are
1858 bfinfdpic_relocs_info_eq (const void *entry1
, const void *entry2
)
1860 const struct bfinfdpic_relocs_info
*e1
= entry1
;
1861 const struct bfinfdpic_relocs_info
*e2
= entry2
;
1863 return e1
->symndx
== e2
->symndx
&& e1
->addend
== e2
->addend
1864 && (e1
->symndx
== -1 ? e1
->d
.h
== e2
->d
.h
: e1
->d
.abfd
== e2
->d
.abfd
);
1867 /* Find or create an entry in a hash table HT that matches the key
1868 fields of the given ENTRY. If it's not found, memory for a new
1869 entry is allocated in ABFD's obstack. */
1870 static struct bfinfdpic_relocs_info
*
1871 bfinfdpic_relocs_info_find (struct htab
*ht
,
1873 const struct bfinfdpic_relocs_info
*entry
,
1874 enum insert_option insert
)
1876 struct bfinfdpic_relocs_info
**loc
;
1881 loc
= (struct bfinfdpic_relocs_info
**) htab_find_slot (ht
, entry
, insert
);
1889 *loc
= bfd_zalloc (abfd
, sizeof (**loc
));
1894 (*loc
)->symndx
= entry
->symndx
;
1895 (*loc
)->d
= entry
->d
;
1896 (*loc
)->addend
= entry
->addend
;
1897 (*loc
)->plt_entry
= (bfd_vma
)-1;
1898 (*loc
)->lzplt_entry
= (bfd_vma
)-1;
1903 /* Obtain the address of the entry in HT associated with H's symbol +
1904 addend, creating a new entry if none existed. ABFD is only used
1905 for memory allocation purposes. */
1906 inline static struct bfinfdpic_relocs_info
*
1907 bfinfdpic_relocs_info_for_global (struct htab
*ht
,
1909 struct elf_link_hash_entry
*h
,
1911 enum insert_option insert
)
1913 struct bfinfdpic_relocs_info entry
;
1917 entry
.addend
= addend
;
1919 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1922 /* Obtain the address of the entry in HT associated with the SYMNDXth
1923 local symbol of the input bfd ABFD, plus the addend, creating a new
1924 entry if none existed. */
1925 inline static struct bfinfdpic_relocs_info
*
1926 bfinfdpic_relocs_info_for_local (struct htab
*ht
,
1930 enum insert_option insert
)
1932 struct bfinfdpic_relocs_info entry
;
1934 entry
.symndx
= symndx
;
1935 entry
.d
.abfd
= abfd
;
1936 entry
.addend
= addend
;
1938 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1941 /* Merge fields set by check_relocs() of two entries that end up being
1942 mapped to the same (presumably global) symbol. */
1945 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info
*e2
,
1946 struct bfinfdpic_relocs_info
const *e1
)
1948 e2
->got17m4
|= e1
->got17m4
;
1949 e2
->gothilo
|= e1
->gothilo
;
1951 e2
->fdgot17m4
|= e1
->fdgot17m4
;
1952 e2
->fdgothilo
|= e1
->fdgothilo
;
1953 e2
->fdgoff17m4
|= e1
->fdgoff17m4
;
1954 e2
->fdgoffhilo
|= e1
->fdgoffhilo
;
1955 e2
->gotoff
|= e1
->gotoff
;
1956 e2
->call
|= e1
->call
;
1960 /* Every block of 65535 lazy PLT entries shares a single call to the
1961 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1962 32767, counting from 0). All other lazy PLT entries branch to it
1963 in a single instruction. */
1965 #define LZPLT_RESOLVER_EXTRA 10
1966 #define LZPLT_NORMAL_SIZE 6
1967 #define LZPLT_ENTRIES 1362
1969 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
1970 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
1972 /* Add a dynamic relocation to the SRELOC section. */
1974 inline static bfd_vma
1975 _bfinfdpic_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
1976 int reloc_type
, long dynindx
, bfd_vma addend
,
1977 struct bfinfdpic_relocs_info
*entry
)
1979 Elf_Internal_Rela outrel
;
1980 bfd_vma reloc_offset
;
1982 outrel
.r_offset
= offset
;
1983 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
1984 outrel
.r_addend
= addend
;
1986 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rel
);
1987 BFD_ASSERT (reloc_offset
< sreloc
->size
);
1988 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1989 sreloc
->contents
+ reloc_offset
);
1990 sreloc
->reloc_count
++;
1992 /* If the entry's index is zero, this relocation was probably to a
1993 linkonce section that got discarded. We reserved a dynamic
1994 relocation, but it was for another entry than the one we got at
1995 the time of emitting the relocation. Unfortunately there's no
1996 simple way for us to catch this situation, since the relocation
1997 is cleared right before calling relocate_section, at which point
1998 we no longer know what the relocation used to point to. */
2001 BFD_ASSERT (entry
->dynrelocs
> 0);
2005 return reloc_offset
;
2008 /* Add a fixup to the ROFIXUP section. */
2011 _bfinfdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma offset
,
2012 struct bfinfdpic_relocs_info
*entry
)
2014 bfd_vma fixup_offset
;
2016 if (rofixup
->flags
& SEC_EXCLUDE
)
2019 fixup_offset
= rofixup
->reloc_count
* 4;
2020 if (rofixup
->contents
)
2022 BFD_ASSERT (fixup_offset
< rofixup
->size
);
2023 bfd_put_32 (output_bfd
, offset
, rofixup
->contents
+ fixup_offset
);
2025 rofixup
->reloc_count
++;
2027 if (entry
&& entry
->symndx
)
2029 /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
2031 BFD_ASSERT (entry
->fixups
> 0);
2035 return fixup_offset
;
2038 /* Find the segment number in which OSEC, and output section, is
2042 _bfinfdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
2044 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
2046 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
2049 inline static bfd_boolean
2050 _bfinfdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
2052 unsigned seg
= _bfinfdpic_osec_to_segment (output_bfd
, osec
);
2054 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
2057 /* Generate relocations for GOT entries, function descriptors, and
2058 code for PLT and lazy PLT entries. */
2060 inline static bfd_boolean
2061 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info
*entry
,
2063 struct bfd_link_info
*info
,
2065 Elf_Internal_Sym
*sym
,
2068 bfd_vma fd_lazy_rel_offset
= (bfd_vma
) -1;
2075 if (entry
->got_entry
|| entry
->fdgot_entry
|| entry
->fd_entry
)
2077 /* If the symbol is dynamic, consider it for dynamic
2078 relocations, otherwise decay to section + offset. */
2079 if (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1)
2080 dynindx
= entry
->d
.h
->dynindx
;
2084 && sec
->output_section
2085 && ! bfd_is_abs_section (sec
->output_section
)
2086 && ! bfd_is_und_section (sec
->output_section
))
2087 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
2093 /* Generate relocation for GOT entry pointing to the symbol. */
2094 if (entry
->got_entry
)
2097 bfd_vma ad
= addend
;
2099 /* If the symbol is dynamic but binds locally, use
2101 if (sec
&& (entry
->symndx
!= -1
2102 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2104 if (entry
->symndx
== -1)
2105 ad
+= entry
->d
.h
->root
.u
.def
.value
;
2107 ad
+= sym
->st_value
;
2108 ad
+= sec
->output_offset
;
2109 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
2110 idx
= elf_section_data (sec
->output_section
)->dynindx
;
2115 /* If we're linking an executable at a fixed address, we can
2116 omit the dynamic relocation as long as the symbol is local to
2118 if (bfd_link_pde (info
)
2119 && (entry
->symndx
!= -1
2120 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2123 ad
+= sec
->output_section
->vma
;
2124 if (entry
->symndx
!= -1
2125 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
2126 _bfinfdpic_add_rofixup (output_bfd
,
2127 bfinfdpic_gotfixup_section (info
),
2128 bfinfdpic_got_section (info
)->output_section
2130 + bfinfdpic_got_section (info
)->output_offset
2131 + bfinfdpic_got_initial_offset (info
)
2132 + entry
->got_entry
, entry
);
2135 _bfinfdpic_add_dyn_reloc (output_bfd
, bfinfdpic_gotrel_section (info
),
2136 _bfd_elf_section_offset
2138 bfinfdpic_got_section (info
),
2139 bfinfdpic_got_initial_offset (info
)
2141 + bfinfdpic_got_section (info
)
2142 ->output_section
->vma
2143 + bfinfdpic_got_section (info
)->output_offset
,
2144 R_BFIN_BYTE4_DATA
, idx
, ad
, entry
);
2146 bfd_put_32 (output_bfd
, ad
,
2147 bfinfdpic_got_section (info
)->contents
2148 + bfinfdpic_got_initial_offset (info
)
2149 + entry
->got_entry
);
2152 /* Generate relocation for GOT entry pointing to a canonical
2153 function descriptor. */
2154 if (entry
->fdgot_entry
)
2159 if (! (entry
->symndx
== -1
2160 && entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
2161 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2163 /* If the symbol is dynamic and there may be dynamic symbol
2164 resolution because we are, or are linked with, a shared
2165 library, emit a FUNCDESC relocation such that the dynamic
2166 linker will allocate the function descriptor. If the
2167 symbol needs a non-local function descriptor but binds
2168 locally (e.g., its visibility is protected, emit a
2169 dynamic relocation decayed to section+offset. */
2170 if (entry
->symndx
== -1
2171 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)
2172 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)
2173 && !bfd_link_pde (info
))
2175 reloc
= R_BFIN_FUNCDESC
;
2176 idx
= elf_section_data (entry
->d
.h
->root
.u
.def
.section
2177 ->output_section
)->dynindx
;
2178 ad
= entry
->d
.h
->root
.u
.def
.section
->output_offset
2179 + entry
->d
.h
->root
.u
.def
.value
;
2181 else if (entry
->symndx
== -1
2182 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
))
2184 reloc
= R_BFIN_FUNCDESC
;
2192 /* Otherwise, we know we have a private function descriptor,
2193 so reference it directly. */
2194 if (elf_hash_table (info
)->dynamic_sections_created
)
2195 BFD_ASSERT (entry
->privfd
);
2196 reloc
= R_BFIN_BYTE4_DATA
;
2197 idx
= elf_section_data (bfinfdpic_got_section (info
)
2198 ->output_section
)->dynindx
;
2199 ad
= bfinfdpic_got_section (info
)->output_offset
2200 + bfinfdpic_got_initial_offset (info
) + entry
->fd_entry
;
2203 /* If there is room for dynamic symbol resolution, emit the
2204 dynamic relocation. However, if we're linking an
2205 executable at a fixed location, we won't have emitted a
2206 dynamic symbol entry for the got section, so idx will be
2207 zero, which means we can and should compute the address
2208 of the private descriptor ourselves. */
2209 if (bfd_link_pde (info
)
2210 && (entry
->symndx
!= -1
2211 || BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)))
2213 ad
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2214 _bfinfdpic_add_rofixup (output_bfd
,
2215 bfinfdpic_gotfixup_section (info
),
2216 bfinfdpic_got_section (info
)
2217 ->output_section
->vma
2218 + bfinfdpic_got_section (info
)
2220 + bfinfdpic_got_initial_offset (info
)
2221 + entry
->fdgot_entry
, entry
);
2224 _bfinfdpic_add_dyn_reloc (output_bfd
,
2225 bfinfdpic_gotrel_section (info
),
2226 _bfd_elf_section_offset
2228 bfinfdpic_got_section (info
),
2229 bfinfdpic_got_initial_offset (info
)
2230 + entry
->fdgot_entry
)
2231 + bfinfdpic_got_section (info
)
2232 ->output_section
->vma
2233 + bfinfdpic_got_section (info
)
2235 reloc
, idx
, ad
, entry
);
2238 bfd_put_32 (output_bfd
, ad
,
2239 bfinfdpic_got_section (info
)->contents
2240 + bfinfdpic_got_initial_offset (info
)
2241 + entry
->fdgot_entry
);
2244 /* Generate relocation to fill in a private function descriptor in
2246 if (entry
->fd_entry
)
2249 bfd_vma ad
= addend
;
2251 long lowword
, highword
;
2253 /* If the symbol is dynamic but binds locally, use
2255 if (sec
&& (entry
->symndx
!= -1
2256 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2258 if (entry
->symndx
== -1)
2259 ad
+= entry
->d
.h
->root
.u
.def
.value
;
2261 ad
+= sym
->st_value
;
2262 ad
+= sec
->output_offset
;
2263 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
2264 idx
= elf_section_data (sec
->output_section
)->dynindx
;
2269 /* If we're linking an executable at a fixed address, we can
2270 omit the dynamic relocation as long as the symbol is local to
2272 if (bfd_link_pde (info
)
2273 && (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2276 ad
+= sec
->output_section
->vma
;
2278 if (entry
->symndx
!= -1
2279 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
2281 _bfinfdpic_add_rofixup (output_bfd
,
2282 bfinfdpic_gotfixup_section (info
),
2283 bfinfdpic_got_section (info
)
2284 ->output_section
->vma
2285 + bfinfdpic_got_section (info
)
2287 + bfinfdpic_got_initial_offset (info
)
2288 + entry
->fd_entry
, entry
);
2289 _bfinfdpic_add_rofixup (output_bfd
,
2290 bfinfdpic_gotfixup_section (info
),
2291 bfinfdpic_got_section (info
)
2292 ->output_section
->vma
2293 + bfinfdpic_got_section (info
)
2295 + bfinfdpic_got_initial_offset (info
)
2296 + entry
->fd_entry
+ 4, entry
);
2302 = _bfinfdpic_add_dyn_reloc (output_bfd
,
2304 ? bfinfdpic_pltrel_section (info
)
2305 : bfinfdpic_gotrel_section (info
),
2306 _bfd_elf_section_offset
2308 bfinfdpic_got_section (info
),
2309 bfinfdpic_got_initial_offset (info
)
2311 + bfinfdpic_got_section (info
)
2312 ->output_section
->vma
2313 + bfinfdpic_got_section (info
)
2315 R_BFIN_FUNCDESC_VALUE
, idx
, ad
, entry
);
2318 /* If we've omitted the dynamic relocation, just emit the fixed
2319 addresses of the symbol and of the local GOT base offset. */
2320 if (bfd_link_pde (info
)
2322 && sec
->output_section
)
2325 highword
= bfinfdpic_got_section (info
)->output_section
->vma
2326 + bfinfdpic_got_section (info
)->output_offset
2327 + bfinfdpic_got_initial_offset (info
);
2329 else if (entry
->lazyplt
)
2334 fd_lazy_rel_offset
= ofst
;
2336 /* A function descriptor used for lazy or local resolving is
2337 initialized such that its high word contains the output
2338 section index in which the PLT entries are located, and
2339 the low word contains the address of the lazy PLT entry
2340 entry point, that must be within the memory region
2341 assigned to that section. */
2342 lowword
= entry
->lzplt_entry
+ 4
2343 + bfinfdpic_plt_section (info
)->output_offset
2344 + bfinfdpic_plt_section (info
)->output_section
->vma
;
2345 highword
= _bfinfdpic_osec_to_segment
2346 (output_bfd
, bfinfdpic_plt_section (info
)->output_section
);
2350 /* A function descriptor for a local function gets the index
2351 of the section. For a non-local function, it's
2355 || (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1
2356 && entry
->d
.h
->dynindx
== idx
))
2359 highword
= _bfinfdpic_osec_to_segment
2360 (output_bfd
, sec
->output_section
);
2363 bfd_put_32 (output_bfd
, lowword
,
2364 bfinfdpic_got_section (info
)->contents
2365 + bfinfdpic_got_initial_offset (info
)
2367 bfd_put_32 (output_bfd
, highword
,
2368 bfinfdpic_got_section (info
)->contents
2369 + bfinfdpic_got_initial_offset (info
)
2370 + entry
->fd_entry
+ 4);
2373 /* Generate code for the PLT entry. */
2374 if (entry
->plt_entry
!= (bfd_vma
) -1)
2376 bfd_byte
*plt_code
= bfinfdpic_plt_section (info
)->contents
2379 BFD_ASSERT (entry
->fd_entry
);
2381 /* Figure out what kind of PLT entry we need, depending on the
2382 location of the function descriptor within the GOT. */
2383 if (entry
->fd_entry
>= -(1 << (18 - 1))
2384 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
2386 /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
2387 bfd_put_32 (output_bfd
,
2388 0xe519 | ((entry
->fd_entry
<< 14) & 0xFFFF0000),
2390 bfd_put_32 (output_bfd
,
2391 0xe51b | (((entry
->fd_entry
+ 4) << 14) & 0xFFFF0000),
2397 /* P1.L = fd_entry; P1.H = fd_entry;
2401 bfd_put_32 (output_bfd
,
2402 0xe109 | (entry
->fd_entry
<< 16),
2404 bfd_put_32 (output_bfd
,
2405 0xe149 | (entry
->fd_entry
& 0xFFFF0000),
2407 bfd_put_16 (output_bfd
, 0x5ad9, plt_code
+ 8);
2408 bfd_put_16 (output_bfd
, 0x9159, plt_code
+ 10);
2409 bfd_put_16 (output_bfd
, 0xac5b, plt_code
+ 12);
2413 bfd_put_16 (output_bfd
, 0x0051, plt_code
);
2416 /* Generate code for the lazy PLT entry. */
2417 if (entry
->lzplt_entry
!= (bfd_vma
) -1)
2419 bfd_byte
*lzplt_code
= bfinfdpic_plt_section (info
)->contents
2420 + entry
->lzplt_entry
;
2421 bfd_vma resolverStub_addr
;
2423 bfd_put_32 (output_bfd
, fd_lazy_rel_offset
, lzplt_code
);
2426 resolverStub_addr
= entry
->lzplt_entry
/ BFINFDPIC_LZPLT_BLOCK_SIZE
2427 * BFINFDPIC_LZPLT_BLOCK_SIZE
+ BFINFDPIC_LZPLT_RESOLV_LOC
;
2428 if (resolverStub_addr
>= bfinfdpic_plt_initial_offset (info
))
2429 resolverStub_addr
= bfinfdpic_plt_initial_offset (info
) - LZPLT_NORMAL_SIZE
- LZPLT_RESOLVER_EXTRA
;
2431 if (entry
->lzplt_entry
== resolverStub_addr
)
2433 /* This is a lazy PLT entry that includes a resolver call.
2437 bfd_put_32 (output_bfd
,
2440 bfd_put_16 (output_bfd
, 0x0052, lzplt_code
+ 4);
2444 /* JUMP.S resolverStub */
2445 bfd_put_16 (output_bfd
,
2447 | (((resolverStub_addr
- entry
->lzplt_entry
)
2448 / 2) & (((bfd_vma
)1 << 12) - 1)),
2456 /* Relocate an Blackfin ELF section.
2458 The RELOCATE_SECTION function is called by the new ELF backend linker
2459 to handle the relocations for a section.
2461 The relocs are always passed as Rela structures; if the section
2462 actually uses Rel structures, the r_addend field will always be
2465 This function is responsible for adjusting the section contents as
2466 necessary, and (if using Rela relocs and generating a relocatable
2467 output file) adjusting the reloc addend as necessary.
2469 This function does not have to worry about setting the reloc
2470 address or the reloc symbol index.
2472 LOCAL_SYMS is a pointer to the swapped in local symbols.
2474 LOCAL_SECTIONS is an array giving the section in the input file
2475 corresponding to the st_shndx field of each local symbol.
2477 The global hash table entry for the global symbols can be found
2478 via elf_sym_hashes (input_bfd).
2480 When generating relocatable output, this function must handle
2481 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2482 going to be the section symbol corresponding to the output
2483 section, which means that the addend must be adjusted
2487 bfinfdpic_relocate_section (bfd
* output_bfd
,
2488 struct bfd_link_info
*info
,
2490 asection
* input_section
,
2491 bfd_byte
* contents
,
2492 Elf_Internal_Rela
* relocs
,
2493 Elf_Internal_Sym
* local_syms
,
2494 asection
** local_sections
)
2496 Elf_Internal_Shdr
*symtab_hdr
;
2497 struct elf_link_hash_entry
**sym_hashes
;
2498 Elf_Internal_Rela
*rel
;
2499 Elf_Internal_Rela
*relend
;
2500 unsigned isec_segment
, got_segment
, plt_segment
,
2502 int silence_segment_error
= !bfd_link_pic (info
);
2504 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2505 sym_hashes
= elf_sym_hashes (input_bfd
);
2506 relend
= relocs
+ input_section
->reloc_count
;
2508 isec_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2509 input_section
->output_section
);
2510 if (IS_FDPIC (output_bfd
) && bfinfdpic_got_section (info
))
2511 got_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2512 bfinfdpic_got_section (info
)
2516 if (IS_FDPIC (output_bfd
) && elf_hash_table (info
)->dynamic_sections_created
)
2517 plt_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2518 bfinfdpic_plt_section (info
)
2523 for (rel
= relocs
; rel
< relend
; rel
++)
2525 reloc_howto_type
*howto
;
2526 unsigned long r_symndx
;
2527 Elf_Internal_Sym
*sym
;
2529 struct elf_link_hash_entry
*h
;
2531 bfd_reloc_status_type r
;
2532 const char * name
= NULL
;
2535 struct bfinfdpic_relocs_info
*picrel
;
2536 bfd_vma orig_addend
= rel
->r_addend
;
2538 r_type
= ELF32_R_TYPE (rel
->r_info
);
2540 if (r_type
== R_BFIN_GNU_VTINHERIT
2541 || r_type
== R_BFIN_GNU_VTENTRY
)
2544 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2545 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
2548 bfd_set_error (bfd_error_bad_value
);
2557 if (r_symndx
< symtab_hdr
->sh_info
)
2559 sym
= local_syms
+ r_symndx
;
2560 osec
= sec
= local_sections
[r_symndx
];
2561 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2563 name
= bfd_elf_string_from_elf_section
2564 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2565 name
= name
== NULL
? bfd_section_name (sec
) : name
;
2569 bfd_boolean warned
, ignored
;
2570 bfd_boolean unresolved_reloc
;
2572 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2573 r_symndx
, symtab_hdr
, sym_hashes
,
2575 unresolved_reloc
, warned
, ignored
);
2579 if (sec
!= NULL
&& discarded_section (sec
))
2580 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2581 rel
, 1, relend
, howto
, 0, contents
);
2583 if (bfd_link_relocatable (info
))
2587 && (h
->root
.type
== bfd_link_hash_defined
2588 || h
->root
.type
== bfd_link_hash_defweak
)
2589 && !BFINFDPIC_SYM_LOCAL (info
, h
))
2597 case R_BFIN_PCREL24
:
2598 case R_BFIN_PCREL24_JUMP_L
:
2599 case R_BFIN_BYTE4_DATA
:
2600 if (! IS_FDPIC (output_bfd
))
2604 case R_BFIN_GOT17M4
:
2607 case R_BFIN_FUNCDESC_GOT17M4
:
2608 case R_BFIN_FUNCDESC_GOTHI
:
2609 case R_BFIN_FUNCDESC_GOTLO
:
2610 case R_BFIN_GOTOFF17M4
:
2611 case R_BFIN_GOTOFFHI
:
2612 case R_BFIN_GOTOFFLO
:
2613 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2614 case R_BFIN_FUNCDESC_GOTOFFHI
:
2615 case R_BFIN_FUNCDESC_GOTOFFLO
:
2616 case R_BFIN_FUNCDESC
:
2617 case R_BFIN_FUNCDESC_VALUE
:
2618 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2622 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2623 (info
), input_bfd
, h
,
2624 orig_addend
, INSERT
);
2626 /* In order to find the entry we created before, we must
2627 use the original addend, not the one that may have been
2628 modified by _bfd_elf_rela_local_sym(). */
2629 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2630 (info
), input_bfd
, r_symndx
,
2631 orig_addend
, INSERT
);
2635 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel
, output_bfd
, info
,
2640 /* xgettext:c-format */
2641 (_("%pB: relocation at `%pA+%#" PRIx64
"' "
2642 "references symbol `%s' with nonzero addend"),
2643 input_bfd
, input_section
, (uint64_t) rel
->r_offset
, name
);
2653 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
2654 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2655 rel
->r_offset
) != (bfd_vma
) -1)
2657 info
->callbacks
->warning
2658 (info
, _("relocation references symbol not defined in the module"),
2659 name
, input_bfd
, input_section
, rel
->r_offset
);
2667 case R_BFIN_PCREL24
:
2668 case R_BFIN_PCREL24_JUMP_L
:
2669 check_segment
[0] = isec_segment
;
2670 if (! IS_FDPIC (output_bfd
))
2671 check_segment
[1] = isec_segment
;
2672 else if (picrel
->plt
)
2674 relocation
= bfinfdpic_plt_section (info
)->output_section
->vma
2675 + bfinfdpic_plt_section (info
)->output_offset
2676 + picrel
->plt_entry
;
2677 check_segment
[1] = plt_segment
;
2679 /* We don't want to warn on calls to undefined weak symbols,
2680 as calls to them must be protected by non-NULL tests
2681 anyway, and unprotected calls would invoke undefined
2683 else if (picrel
->symndx
== -1
2684 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefweak
)
2685 check_segment
[1] = check_segment
[0];
2687 check_segment
[1] = sec
2688 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2692 case R_BFIN_GOT17M4
:
2695 relocation
= picrel
->got_entry
;
2696 check_segment
[0] = check_segment
[1] = got_segment
;
2699 case R_BFIN_FUNCDESC_GOT17M4
:
2700 case R_BFIN_FUNCDESC_GOTHI
:
2701 case R_BFIN_FUNCDESC_GOTLO
:
2702 relocation
= picrel
->fdgot_entry
;
2703 check_segment
[0] = check_segment
[1] = got_segment
;
2706 case R_BFIN_GOTOFFHI
:
2707 case R_BFIN_GOTOFF17M4
:
2708 case R_BFIN_GOTOFFLO
:
2709 relocation
-= bfinfdpic_got_section (info
)->output_section
->vma
2710 + bfinfdpic_got_section (info
)->output_offset
2711 + bfinfdpic_got_initial_offset (info
);
2712 check_segment
[0] = got_segment
;
2713 check_segment
[1] = sec
2714 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2718 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2719 case R_BFIN_FUNCDESC_GOTOFFHI
:
2720 case R_BFIN_FUNCDESC_GOTOFFLO
:
2721 relocation
= picrel
->fd_entry
;
2722 check_segment
[0] = check_segment
[1] = got_segment
;
2725 case R_BFIN_FUNCDESC
:
2728 bfd_vma addend
= rel
->r_addend
;
2730 if (! (h
&& h
->root
.type
== bfd_link_hash_undefweak
2731 && BFINFDPIC_SYM_LOCAL (info
, h
)))
2733 /* If the symbol is dynamic and there may be dynamic
2734 symbol resolution because we are or are linked with a
2735 shared library, emit a FUNCDESC relocation such that
2736 the dynamic linker will allocate the function
2737 descriptor. If the symbol needs a non-local function
2738 descriptor but binds locally (e.g., its visibility is
2739 protected, emit a dynamic relocation decayed to
2741 if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
)
2742 && BFINFDPIC_SYM_LOCAL (info
, h
)
2743 && !bfd_link_pde (info
))
2745 dynindx
= elf_section_data (h
->root
.u
.def
.section
2746 ->output_section
)->dynindx
;
2747 addend
+= h
->root
.u
.def
.section
->output_offset
2748 + h
->root
.u
.def
.value
;
2750 else if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
))
2754 info
->callbacks
->warning
2755 (info
, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2756 name
, input_bfd
, input_section
, rel
->r_offset
);
2759 dynindx
= h
->dynindx
;
2763 /* Otherwise, we know we have a private function
2764 descriptor, so reference it directly. */
2765 BFD_ASSERT (picrel
->privfd
);
2766 r_type
= R_BFIN_BYTE4_DATA
;
2767 dynindx
= elf_section_data (bfinfdpic_got_section (info
)
2768 ->output_section
)->dynindx
;
2769 addend
= bfinfdpic_got_section (info
)->output_offset
2770 + bfinfdpic_got_initial_offset (info
)
2774 /* If there is room for dynamic symbol resolution, emit
2775 the dynamic relocation. However, if we're linking an
2776 executable at a fixed location, we won't have emitted a
2777 dynamic symbol entry for the got section, so idx will
2778 be zero, which means we can and should compute the
2779 address of the private descriptor ourselves. */
2780 if (bfd_link_pde (info
)
2781 && (!h
|| BFINFDPIC_FUNCDESC_LOCAL (info
, h
)))
2785 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2786 if ((bfd_section_flags (input_section
->output_section
)
2787 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2789 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2793 info
->callbacks
->warning
2795 _("cannot emit fixups in read-only section"),
2796 name
, input_bfd
, input_section
, rel
->r_offset
);
2800 offset
= _bfd_elf_section_offset
2802 input_section
, rel
->r_offset
);
2804 if (offset
!= (bfd_vma
)-1)
2805 _bfinfdpic_add_rofixup (output_bfd
,
2806 bfinfdpic_gotfixup_section
2808 offset
+ input_section
2809 ->output_section
->vma
2810 + input_section
->output_offset
,
2814 else if ((bfd_section_flags (input_section
->output_section
)
2815 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2819 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2823 info
->callbacks
->warning
2825 _("cannot emit dynamic relocations in read-only section"),
2826 name
, input_bfd
, input_section
, rel
->r_offset
);
2829 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2830 input_section
, rel
->r_offset
);
2832 if (offset
!= (bfd_vma
)-1)
2833 _bfinfdpic_add_dyn_reloc (output_bfd
,
2834 bfinfdpic_gotrel_section (info
),
2835 offset
+ input_section
2836 ->output_section
->vma
2837 + input_section
->output_offset
,
2839 dynindx
, addend
, picrel
);
2842 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2845 /* We want the addend in-place because dynamic
2846 relocations are REL. Setting relocation to it should
2847 arrange for it to be installed. */
2848 relocation
= addend
- rel
->r_addend
;
2850 check_segment
[0] = check_segment
[1] = got_segment
;
2853 case R_BFIN_BYTE4_DATA
:
2854 if (! IS_FDPIC (output_bfd
))
2856 check_segment
[0] = check_segment
[1] = -1;
2860 case R_BFIN_FUNCDESC_VALUE
:
2863 bfd_vma addend
= rel
->r_addend
;
2865 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2866 input_section
, rel
->r_offset
);
2868 /* If the symbol is dynamic but binds locally, use
2870 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
))
2872 if (addend
&& r_type
== R_BFIN_FUNCDESC_VALUE
)
2874 info
->callbacks
->warning
2875 (info
, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2876 name
, input_bfd
, input_section
, rel
->r_offset
);
2879 dynindx
= h
->dynindx
;
2884 addend
+= h
->root
.u
.def
.value
;
2886 addend
+= sym
->st_value
;
2888 addend
+= osec
->output_offset
;
2889 if (osec
&& osec
->output_section
2890 && ! bfd_is_abs_section (osec
->output_section
)
2891 && ! bfd_is_und_section (osec
->output_section
))
2892 dynindx
= elf_section_data (osec
->output_section
)->dynindx
;
2897 /* If we're linking an executable at a fixed address, we
2898 can omit the dynamic relocation as long as the symbol
2899 is defined in the current link unit (which is implied
2900 by its output section not being NULL). */
2901 if (bfd_link_pde (info
)
2902 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
2905 addend
+= osec
->output_section
->vma
;
2906 if (IS_FDPIC (input_bfd
)
2907 && (bfd_section_flags (input_section
->output_section
)
2908 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2910 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2914 info
->callbacks
->warning
2916 _("cannot emit fixups in read-only section"),
2917 name
, input_bfd
, input_section
, rel
->r_offset
);
2920 if (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
2922 if (offset
!= (bfd_vma
)-1)
2924 _bfinfdpic_add_rofixup (output_bfd
,
2925 bfinfdpic_gotfixup_section
2927 offset
+ input_section
2928 ->output_section
->vma
2929 + input_section
->output_offset
,
2932 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
2933 _bfinfdpic_add_rofixup
2935 bfinfdpic_gotfixup_section (info
),
2936 offset
+ input_section
->output_section
->vma
2937 + input_section
->output_offset
+ 4, picrel
);
2944 if ((bfd_section_flags (input_section
->output_section
)
2945 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2947 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2951 info
->callbacks
->warning
2953 _("cannot emit dynamic relocations in read-only section"),
2954 name
, input_bfd
, input_section
, rel
->r_offset
);
2958 if (offset
!= (bfd_vma
)-1)
2959 _bfinfdpic_add_dyn_reloc (output_bfd
,
2960 bfinfdpic_gotrel_section (info
),
2962 + input_section
->output_section
->vma
2963 + input_section
->output_offset
,
2964 r_type
, dynindx
, addend
, picrel
);
2967 addend
+= osec
->output_section
->vma
;
2968 /* We want the addend in-place because dynamic
2969 relocations are REL. Setting relocation to it
2970 should arrange for it to be installed. */
2971 relocation
= addend
- rel
->r_addend
;
2974 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
2976 /* If we've omitted the dynamic relocation, just emit
2977 the fixed addresses of the symbol and of the local
2979 if (bfd_link_pde (info
)
2980 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
2981 bfd_put_32 (output_bfd
,
2982 bfinfdpic_got_section (info
)->output_section
->vma
2983 + bfinfdpic_got_section (info
)->output_offset
2984 + bfinfdpic_got_initial_offset (info
),
2985 contents
+ rel
->r_offset
+ 4);
2987 /* A function descriptor used for lazy or local
2988 resolving is initialized such that its high word
2989 contains the output section index in which the
2990 PLT entries are located, and the low word
2991 contains the offset of the lazy PLT entry entry
2992 point into that section. */
2993 bfd_put_32 (output_bfd
,
2994 h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
2996 : _bfinfdpic_osec_to_segment (output_bfd
,
2999 contents
+ rel
->r_offset
+ 4);
3002 check_segment
[0] = check_segment
[1] = got_segment
;
3006 check_segment
[0] = isec_segment
;
3007 check_segment
[1] = sec
3008 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3013 if (check_segment
[0] != check_segment
[1] && IS_FDPIC (output_bfd
))
3015 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
3016 in the ld testsuite. */
3017 /* This helps catch problems in GCC while we can't do more
3018 than static linking. The idea is to test whether the
3019 input file basename is crt0.o only once. */
3020 if (silence_segment_error
== 1)
3021 silence_segment_error
=
3022 (strlen (bfd_get_filename (input_bfd
)) == 6
3023 && filename_cmp (bfd_get_filename (input_bfd
), "crt0.o") == 0)
3024 || (strlen (bfd_get_filename (input_bfd
)) > 6
3025 && filename_cmp (bfd_get_filename (input_bfd
)
3026 + strlen (bfd_get_filename (input_bfd
)) - 7,
3030 if (!silence_segment_error
3031 /* We don't want duplicate errors for undefined
3033 && !(picrel
&& picrel
->symndx
== -1
3034 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefined
))
3035 info
->callbacks
->warning
3038 ? _("relocations between different segments are not supported")
3039 : _("warning: relocation references a different segment"),
3040 name
, input_bfd
, input_section
, rel
->r_offset
);
3041 if (!silence_segment_error
&& bfd_link_pic (info
))
3043 elf_elfheader (output_bfd
)->e_flags
|= EF_BFIN_PIC
;
3048 case R_BFIN_GOTOFFHI
:
3049 /* We need the addend to be applied before we shift the
3051 relocation
+= rel
->r_addend
;
3054 case R_BFIN_FUNCDESC_GOTHI
:
3055 case R_BFIN_FUNCDESC_GOTOFFHI
:
3060 case R_BFIN_FUNCDESC_GOTLO
:
3061 case R_BFIN_GOTOFFLO
:
3062 case R_BFIN_FUNCDESC_GOTOFFLO
:
3063 relocation
&= 0xffff;
3072 case R_BFIN_PCREL24
:
3073 case R_BFIN_PCREL24_JUMP_L
:
3074 if (! IS_FDPIC (output_bfd
) || ! picrel
->plt
)
3078 /* When referencing a GOT entry, a function descriptor or a
3079 PLT, we don't want the addend to apply to the reference,
3080 but rather to the referenced symbol. The actual entry
3081 will have already been created taking the addend into
3082 account, so cancel it out here. */
3083 case R_BFIN_GOT17M4
:
3086 case R_BFIN_FUNCDESC_GOT17M4
:
3087 case R_BFIN_FUNCDESC_GOTHI
:
3088 case R_BFIN_FUNCDESC_GOTLO
:
3089 case R_BFIN_FUNCDESC_GOTOFF17M4
:
3090 case R_BFIN_FUNCDESC_GOTOFFHI
:
3091 case R_BFIN_FUNCDESC_GOTOFFLO
:
3092 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
3093 here, since we do want to apply the addend to the others.
3094 Note that we've applied the addend to GOTOFFHI before we
3095 shifted it right. */
3096 case R_BFIN_GOTOFFHI
:
3097 relocation
-= rel
->r_addend
;
3104 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
3105 contents
, rel
->r_offset
,
3106 relocation
, rel
->r_addend
);
3108 if (r
!= bfd_reloc_ok
)
3110 const char * msg
= (const char *) NULL
;
3114 case bfd_reloc_overflow
:
3115 (*info
->callbacks
->reloc_overflow
)
3116 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3117 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
3120 case bfd_reloc_undefined
:
3121 (*info
->callbacks
->undefined_symbol
)
3122 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
3125 case bfd_reloc_outofrange
:
3126 msg
= _("internal error: out of range error");
3129 case bfd_reloc_notsupported
:
3130 msg
= _("internal error: unsupported relocation error");
3133 case bfd_reloc_dangerous
:
3134 msg
= _("internal error: dangerous relocation");
3138 msg
= _("internal error: unknown error");
3143 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
3144 input_section
, rel
->r_offset
);
3151 /* We need dynamic symbols for every section, since segments can
3152 relocate independently. */
3154 _bfinfdpic_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3155 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3158 switch (elf_section_data (p
)->this_hdr
.sh_type
)
3162 /* If sh_type is yet undecided, assume it could be
3163 SHT_PROGBITS/SHT_NOBITS. */
3167 /* There shouldn't be section relative relocations
3168 against any other section. */
3174 /* Create a .got section, as well as its additional info field. This
3175 is almost entirely copied from
3176 elflink.c:_bfd_elf_create_got_section(). */
3179 _bfin_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3181 flagword flags
, pltflags
;
3183 struct elf_link_hash_entry
*h
;
3184 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3187 /* This function may be called more than once. */
3188 s
= elf_hash_table (info
)->sgot
;
3192 /* Machine specific: although pointers are 32-bits wide, we want the
3193 GOT to be aligned to a 64-bit boundary, such that function
3194 descriptors in it can be accessed with 64-bit loads and
3198 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3199 | SEC_LINKER_CREATED
);
3202 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3203 elf_hash_table (info
)->sgot
= s
;
3205 || !bfd_set_section_alignment (s
, ptralign
))
3208 if (bed
->want_got_sym
)
3210 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3211 (or .got.plt) section. We don't do this in the linker script
3212 because we don't want to define the symbol if we are not creating
3213 a global offset table. */
3214 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "__GLOBAL_OFFSET_TABLE_");
3215 elf_hash_table (info
)->hgot
= h
;
3219 /* Machine-specific: we want the symbol for executables as
3221 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3225 /* The first bit of the global offset table is the header. */
3226 s
->size
+= bed
->got_header_size
;
3228 /* This is the machine-specific part. Create and initialize section
3229 data for the got. */
3230 if (IS_FDPIC (abfd
))
3232 bfinfdpic_relocs_info (info
) = htab_try_create (1,
3233 bfinfdpic_relocs_info_hash
,
3234 bfinfdpic_relocs_info_eq
,
3236 if (! bfinfdpic_relocs_info (info
))
3239 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.got",
3240 (flags
| SEC_READONLY
));
3242 || !bfd_set_section_alignment (s
, 2))
3245 bfinfdpic_gotrel_section (info
) = s
;
3247 /* Machine-specific. */
3248 s
= bfd_make_section_anyway_with_flags (abfd
, ".rofixup",
3249 (flags
| SEC_READONLY
));
3251 || !bfd_set_section_alignment (s
, 2))
3254 bfinfdpic_gotfixup_section (info
) = s
;
3257 pltflags
|= SEC_CODE
;
3258 if (bed
->plt_not_loaded
)
3259 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
3260 if (bed
->plt_readonly
)
3261 pltflags
|= SEC_READONLY
;
3263 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
3265 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
3267 /* Blackfin-specific: remember it. */
3268 bfinfdpic_plt_section (info
) = s
;
3270 if (bed
->want_plt_sym
)
3272 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3274 struct bfd_link_hash_entry
*bh
= NULL
;
3276 if (! (_bfd_generic_link_add_one_symbol
3277 (info
, abfd
, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, 0, NULL
,
3278 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3280 h
= (struct elf_link_hash_entry
*) bh
;
3282 h
->type
= STT_OBJECT
;
3284 if (! bfd_link_executable (info
)
3285 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3289 /* Blackfin-specific: we want rel relocations for the plt. */
3290 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.plt",
3291 flags
| SEC_READONLY
);
3293 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
3295 /* Blackfin-specific: remember it. */
3296 bfinfdpic_pltrel_section (info
) = s
;
3301 /* Make sure the got and plt sections exist, and that our pointers in
3302 the link hash table point to them. */
3305 elf32_bfinfdpic_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3307 /* This is mostly copied from
3308 elflink.c:_bfd_elf_create_dynamic_sections(). */
3311 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3313 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3314 | SEC_LINKER_CREATED
);
3316 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3317 .rel[a].bss sections. */
3319 /* Blackfin-specific: we want to create the GOT in the Blackfin way. */
3320 if (! _bfin_create_got_section (abfd
, info
))
3323 /* Blackfin-specific: make sure we created everything we wanted. */
3324 BFD_ASSERT (bfinfdpic_got_section (info
) && bfinfdpic_gotrel_section (info
)
3325 /* && bfinfdpic_gotfixup_section (info) */
3326 && bfinfdpic_plt_section (info
)
3327 && bfinfdpic_pltrel_section (info
));
3329 if (bed
->want_dynbss
)
3331 /* The .dynbss section is a place to put symbols which are defined
3332 by dynamic objects, are referenced by regular objects, and are
3333 not functions. We must allocate space for them in the process
3334 image and use a R_*_COPY reloc to tell the dynamic linker to
3335 initialize them at run time. The linker script puts the .dynbss
3336 section into the .bss section of the final image. */
3337 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
3338 SEC_ALLOC
| SEC_LINKER_CREATED
);
3342 /* The .rel[a].bss section holds copy relocs. This section is not
3343 normally needed. We need to create it here, though, so that the
3344 linker will map it to an output section. We can't just create it
3345 only if we need it, because we will not know whether we need it
3346 until we have seen all the input files, and the first time the
3347 main linker code calls BFD after examining all the input files
3348 (size_dynamic_sections) the input sections have already been
3349 mapped to the output sections. If the section turns out not to
3350 be needed, we can discard it later. We will never need this
3351 section when generating a shared object, since they do not use
3353 if (! bfd_link_pic (info
))
3355 s
= bfd_make_section_anyway_with_flags (abfd
,
3357 flags
| SEC_READONLY
);
3359 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
3367 /* Compute the total GOT size required by each symbol in each range.
3368 Symbols may require up to 4 words in the GOT: an entry pointing to
3369 the symbol, an entry pointing to its function descriptor, and a
3370 private function descriptors taking two words. */
3373 _bfinfdpic_count_nontls_entries (struct bfinfdpic_relocs_info
*entry
,
3374 struct _bfinfdpic_dynamic_got_info
*dinfo
)
3376 /* Allocate space for a GOT entry pointing to the symbol. */
3378 dinfo
->got17m4
+= 4;
3379 else if (entry
->gothilo
)
3380 dinfo
->gothilo
+= 4;
3385 /* Allocate space for a GOT entry pointing to the function
3387 if (entry
->fdgot17m4
)
3388 dinfo
->got17m4
+= 4;
3389 else if (entry
->fdgothilo
)
3390 dinfo
->gothilo
+= 4;
3395 /* Decide whether we need a PLT entry, a function descriptor in the
3396 GOT, and a lazy PLT entry for this symbol. */
3397 entry
->plt
= entry
->call
3398 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3399 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3400 entry
->privfd
= entry
->plt
3401 || entry
->fdgoff17m4
|| entry
->fdgoffhilo
3402 || ((entry
->fd
|| entry
->fdgot17m4
|| entry
->fdgothilo
)
3403 && (entry
->symndx
!= -1
3404 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
)));
3405 entry
->lazyplt
= entry
->privfd
3406 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3407 && ! (dinfo
->info
->flags
& DF_BIND_NOW
)
3408 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3410 /* Allocate space for a function descriptor. */
3411 if (entry
->fdgoff17m4
)
3413 else if (entry
->privfd
&& entry
->plt
)
3415 else if (entry
->privfd
)
3422 dinfo
->lzplt
+= LZPLT_NORMAL_SIZE
;
3425 /* Compute the number of dynamic relocations and fixups that a symbol
3426 requires, and add (or subtract) from the grand and per-symbol
3430 _bfinfdpic_count_relocs_fixups (struct bfinfdpic_relocs_info
*entry
,
3431 struct _bfinfdpic_dynamic_got_info
*dinfo
,
3432 bfd_boolean subtract
)
3434 bfd_vma relocs
= 0, fixups
= 0;
3436 if (!bfd_link_pde (dinfo
->info
))
3437 relocs
= entry
->relocs32
+ entry
->relocsfd
+ entry
->relocsfdv
;
3440 if (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
))
3442 if (entry
->symndx
!= -1
3443 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3444 fixups
+= entry
->relocs32
+ 2 * entry
->relocsfdv
;
3447 relocs
+= entry
->relocs32
+ entry
->relocsfdv
;
3449 if (entry
->symndx
!= -1
3450 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
))
3452 if (entry
->symndx
!= -1
3453 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3454 fixups
+= entry
->relocsfd
;
3457 relocs
+= entry
->relocsfd
;
3466 entry
->dynrelocs
+= relocs
;
3467 entry
->fixups
+= fixups
;
3468 dinfo
->relocs
+= relocs
;
3469 dinfo
->fixups
+= fixups
;
3472 /* Compute the total GOT and PLT size required by each symbol in each range. *
3473 Symbols may require up to 4 words in the GOT: an entry pointing to
3474 the symbol, an entry pointing to its function descriptor, and a
3475 private function descriptors taking two words. */
3478 _bfinfdpic_count_got_plt_entries (void **entryp
, void *dinfo_
)
3480 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3481 struct _bfinfdpic_dynamic_got_info
*dinfo
= dinfo_
;
3483 _bfinfdpic_count_nontls_entries (entry
, dinfo
);
3485 _bfinfdpic_count_relocs_fixups (entry
, dinfo
, FALSE
);
3490 /* This structure is used to assign offsets to got entries, function
3491 descriptors, plt entries and lazy plt entries. */
3493 struct _bfinfdpic_dynamic_got_plt_info
3495 /* Summary information collected with _bfinfdpic_count_got_plt_entries. */
3496 struct _bfinfdpic_dynamic_got_info g
;
3498 /* For each addressable range, we record a MAX (positive) and MIN
3499 (negative) value. CUR is used to assign got entries, and it's
3500 incremented from an initial positive value to MAX, then from MIN
3501 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
3502 assign function descriptors, and it's decreased from an initial
3503 non-positive value to MIN, then from MAX down to CUR (unless CUR
3504 wraps around first). All of MIN, MAX, CUR and FDCUR always point
3505 to even words. ODD, if non-zero, indicates an odd word to be
3506 used for the next got entry, otherwise CUR is used and
3507 incremented by a pair of words, wrapping around when it reaches
3508 MAX. FDCUR is decremented (and wrapped) before the next function
3509 descriptor is chosen. FDPLT indicates the number of remaining
3510 slots that can be used for function descriptors used only by PLT
3512 struct _bfinfdpic_dynamic_got_alloc_data
3514 bfd_signed_vma max
, cur
, odd
, fdcur
, min
;
3519 /* Determine the positive and negative ranges to be used by each
3520 offset range in the GOT. FDCUR and CUR, that must be aligned to a
3521 double-word boundary, are the minimum (negative) and maximum
3522 (positive) GOT offsets already used by previous ranges, except for
3523 an ODD entry that may have been left behind. GOT and FD indicate
3524 the size of GOT entries and function descriptors that must be
3525 placed within the range from -WRAP to WRAP. If there's room left,
3526 up to FDPLT bytes should be reserved for additional function
3529 inline static bfd_signed_vma
3530 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data
*gad
,
3531 bfd_signed_vma fdcur
,
3539 bfd_signed_vma wrapmin
= -wrap
;
3541 /* Start at the given initial points. */
3545 /* If we had an incoming odd word and we have any got entries that
3546 are going to use it, consume it, otherwise leave gad->odd at
3547 zero. We might force gad->odd to zero and return the incoming
3548 odd such that it is used by the next range, but then GOT entries
3549 might appear to be out of order and we wouldn't be able to
3550 shorten the GOT by one word if it turns out to end with an
3551 unpaired GOT entry. */
3561 /* If we're left with an unpaired GOT entry, compute its location
3562 such that we can return it. Otherwise, if got doesn't require an
3563 odd number of words here, either odd was already zero in the
3564 block above, or it was set to zero because got was non-zero, or
3565 got was already zero. In the latter case, we want the value of
3566 odd to carry over to the return statement, so we don't want to
3567 reset odd unless the condition below is true. */
3574 /* Compute the tentative boundaries of this range. */
3575 gad
->max
= cur
+ got
;
3576 gad
->min
= fdcur
- fd
;
3579 /* If function descriptors took too much space, wrap some of them
3581 if (gad
->min
< wrapmin
)
3583 gad
->max
+= wrapmin
- gad
->min
;
3586 /* If there is space left and we have function descriptors
3587 referenced in PLT entries that could take advantage of shorter
3588 offsets, place them here. */
3589 else if (fdplt
&& gad
->min
> wrapmin
)
3592 if ((bfd_vma
) (gad
->min
- wrapmin
) < fdplt
)
3593 fds
= gad
->min
- wrapmin
;
3602 /* If GOT entries took too much space, wrap some of them around.
3603 This may well cause gad->min to become lower than wrapmin. This
3604 will cause a relocation overflow later on, so we don't have to
3606 if ((bfd_vma
) gad
->max
> wrap
)
3608 gad
->min
-= gad
->max
- wrap
;
3611 /* If there is more space left, try to place some more function
3612 descriptors for PLT entries. */
3613 else if (fdplt
&& (bfd_vma
) gad
->max
< wrap
)
3616 if ((bfd_vma
) (wrap
- gad
->max
) < fdplt
)
3617 fds
= wrap
- gad
->max
;
3626 /* If odd was initially computed as an offset past the wrap point,
3629 odd
= gad
->min
+ odd
- gad
->max
;
3631 /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3632 before returning, so do it here too. This guarantees that,
3633 should cur and fdcur meet at the wrap point, they'll both be
3635 if (gad
->cur
== gad
->max
)
3636 gad
->cur
= gad
->min
;
3641 /* Compute the location of the next GOT entry, given the allocation
3642 data for a range. */
3644 inline static bfd_signed_vma
3645 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3651 /* If there was an odd word left behind, use it. */
3657 /* Otherwise, use the word pointed to by cur, reserve the next
3658 as an odd word, and skip to the next pair of words, possibly
3661 gad
->odd
= gad
->cur
+ 4;
3663 if (gad
->cur
== gad
->max
)
3664 gad
->cur
= gad
->min
;
3670 /* Compute the location of the next function descriptor entry in the
3671 GOT, given the allocation data for a range. */
3673 inline static bfd_signed_vma
3674 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3676 /* If we're at the bottom, wrap around, and only then allocate the
3677 next pair of words. */
3678 if (gad
->fdcur
== gad
->min
)
3679 gad
->fdcur
= gad
->max
;
3680 return gad
->fdcur
-= 8;
3683 /* Assign GOT offsets for every GOT entry and function descriptor.
3684 Doing everything in a single pass is tricky. */
3687 _bfinfdpic_assign_got_entries (void **entryp
, void *info_
)
3689 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3690 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3693 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3694 else if (entry
->gothilo
)
3695 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3697 if (entry
->fdgot17m4
)
3698 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3699 else if (entry
->fdgothilo
)
3700 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3702 if (entry
->fdgoff17m4
)
3703 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3704 else if (entry
->plt
&& dinfo
->got17m4
.fdplt
)
3706 dinfo
->got17m4
.fdplt
-= 8;
3707 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3709 else if (entry
->plt
)
3711 dinfo
->gothilo
.fdplt
-= 8;
3712 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3714 else if (entry
->privfd
)
3715 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3720 /* Assign GOT offsets to private function descriptors used by PLT
3721 entries (or referenced by 32-bit offsets), as well as PLT entries
3722 and lazy PLT entries. */
3725 _bfinfdpic_assign_plt_entries (void **entryp
, void *info_
)
3727 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3728 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3730 /* If this symbol requires a local function descriptor, allocate
3732 if (entry
->privfd
&& entry
->fd_entry
== 0)
3734 if (dinfo
->got17m4
.fdplt
)
3736 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3737 dinfo
->got17m4
.fdplt
-= 8;
3741 BFD_ASSERT (dinfo
->gothilo
.fdplt
);
3742 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3743 dinfo
->gothilo
.fdplt
-= 8;
3751 /* We use the section's raw size to mark the location of the
3753 entry
->plt_entry
= bfinfdpic_plt_section (dinfo
->g
.info
)->size
;
3755 /* Figure out the length of this PLT entry based on the
3756 addressing mode we need to reach the function descriptor. */
3757 BFD_ASSERT (entry
->fd_entry
);
3758 if (entry
->fd_entry
>= -(1 << (18 - 1))
3759 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
3764 bfinfdpic_plt_section (dinfo
->g
.info
)->size
+= size
;
3769 entry
->lzplt_entry
= dinfo
->g
.lzplt
;
3770 dinfo
->g
.lzplt
+= LZPLT_NORMAL_SIZE
;
3771 /* If this entry is the one that gets the resolver stub, account
3772 for the additional instruction. */
3773 if (entry
->lzplt_entry
% BFINFDPIC_LZPLT_BLOCK_SIZE
3774 == BFINFDPIC_LZPLT_RESOLV_LOC
)
3775 dinfo
->g
.lzplt
+= LZPLT_RESOLVER_EXTRA
;
3781 /* Cancel out any effects of calling _bfinfdpic_assign_got_entries and
3782 _bfinfdpic_assign_plt_entries. */
3785 _bfinfdpic_reset_got_plt_entries (void **entryp
, void *ignore ATTRIBUTE_UNUSED
)
3787 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3789 entry
->got_entry
= 0;
3790 entry
->fdgot_entry
= 0;
3791 entry
->fd_entry
= 0;
3792 entry
->plt_entry
= (bfd_vma
)-1;
3793 entry
->lzplt_entry
= (bfd_vma
)-1;
3798 /* Follow indirect and warning hash entries so that each got entry
3799 points to the final symbol definition. P must point to a pointer
3800 to the hash table we're traversing. Since this traversal may
3801 modify the hash table, we set this pointer to NULL to indicate
3802 we've made a potentially-destructive change to the hash table, so
3803 the traversal must be restarted. */
3805 _bfinfdpic_resolve_final_relocs_info (void **entryp
, void *p
)
3807 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3810 if (entry
->symndx
== -1)
3812 struct elf_link_hash_entry
*h
= entry
->d
.h
;
3813 struct bfinfdpic_relocs_info
*oentry
;
3815 while (h
->root
.type
== bfd_link_hash_indirect
3816 || h
->root
.type
== bfd_link_hash_warning
)
3817 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
3819 if (entry
->d
.h
== h
)
3822 oentry
= bfinfdpic_relocs_info_for_global (*htab
, 0, h
, entry
->addend
,
3827 /* Merge the two entries. */
3828 bfinfdpic_pic_merge_early_relocs_info (oentry
, entry
);
3829 htab_clear_slot (*htab
, entryp
);
3835 /* If we can't find this entry with the new bfd hash, re-insert
3836 it, and get the traversal restarted. */
3837 if (! htab_find (*htab
, entry
))
3839 htab_clear_slot (*htab
, entryp
);
3840 entryp
= htab_find_slot (*htab
, entry
, INSERT
);
3843 /* Abort the traversal, since the whole table may have
3844 moved, and leave it up to the parent to restart the
3846 *(htab_t
*)p
= NULL
;
3854 /* Compute the total size of the GOT, the PLT, the dynamic relocations
3855 section and the rofixup section. Assign locations for GOT and PLT
3859 _bfinfdpic_size_got_plt (bfd
*output_bfd
,
3860 struct _bfinfdpic_dynamic_got_plt_info
*gpinfop
)
3864 struct bfd_link_info
*info
= gpinfop
->g
.info
;
3865 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
3867 memcpy (bfinfdpic_dynamic_got_plt_info (info
), &gpinfop
->g
,
3868 sizeof (gpinfop
->g
));
3871 /* Compute the total size taken by entries in the 18-bit range,
3872 to tell how many PLT function descriptors we can bring into it
3873 without causing it to overflow. */
3874 limit
= odd
+ gpinfop
->g
.got17m4
+ gpinfop
->g
.fd17m4
;
3875 if (limit
< (bfd_vma
)1 << 18)
3876 limit
= ((bfd_vma
)1 << 18) - limit
;
3879 if (gpinfop
->g
.fdplt
< limit
)
3880 limit
= gpinfop
->g
.fdplt
;
3882 /* Determine the ranges of GOT offsets that we can use for each
3883 range of addressing modes. */
3884 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfop
->got17m4
,
3891 (bfd_vma
)1 << (18-1));
3892 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfop
->gothilo
,
3893 gpinfop
->got17m4
.min
,
3895 gpinfop
->got17m4
.max
,
3898 gpinfop
->g
.fdplt
- gpinfop
->got17m4
.fdplt
,
3899 (bfd_vma
)1 << (32-1));
3901 /* Now assign (most) GOT offsets. */
3902 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_got_entries
,
3905 bfinfdpic_got_section (info
)->size
= gpinfop
->gothilo
.max
3906 - gpinfop
->gothilo
.min
3907 /* If an odd word is the last word of the GOT, we don't need this
3908 word to be part of the GOT. */
3909 - (odd
+ 4 == gpinfop
->gothilo
.max
? 4 : 0);
3910 if (bfinfdpic_got_section (info
)->size
== 0)
3911 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
3912 else if (bfinfdpic_got_section (info
)->size
== 12
3913 && ! elf_hash_table (info
)->dynamic_sections_created
)
3915 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
3916 bfinfdpic_got_section (info
)->size
= 0;
3920 bfinfdpic_got_section (info
)->contents
=
3921 (bfd_byte
*) bfd_zalloc (dynobj
,
3922 bfinfdpic_got_section (info
)->size
);
3923 if (bfinfdpic_got_section (info
)->contents
== NULL
)
3927 if (elf_hash_table (info
)->dynamic_sections_created
)
3928 /* Subtract the number of lzplt entries, since those will generate
3929 relocations in the pltrel section. */
3930 bfinfdpic_gotrel_section (info
)->size
=
3931 (gpinfop
->g
.relocs
- gpinfop
->g
.lzplt
/ LZPLT_NORMAL_SIZE
)
3932 * get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
3934 BFD_ASSERT (gpinfop
->g
.relocs
== 0);
3935 if (bfinfdpic_gotrel_section (info
)->size
== 0)
3936 bfinfdpic_gotrel_section (info
)->flags
|= SEC_EXCLUDE
;
3939 bfinfdpic_gotrel_section (info
)->contents
=
3940 (bfd_byte
*) bfd_zalloc (dynobj
,
3941 bfinfdpic_gotrel_section (info
)->size
);
3942 if (bfinfdpic_gotrel_section (info
)->contents
== NULL
)
3946 bfinfdpic_gotfixup_section (info
)->size
= (gpinfop
->g
.fixups
+ 1) * 4;
3947 if (bfinfdpic_gotfixup_section (info
)->size
== 0)
3948 bfinfdpic_gotfixup_section (info
)->flags
|= SEC_EXCLUDE
;
3951 bfinfdpic_gotfixup_section (info
)->contents
=
3952 (bfd_byte
*) bfd_zalloc (dynobj
,
3953 bfinfdpic_gotfixup_section (info
)->size
);
3954 if (bfinfdpic_gotfixup_section (info
)->contents
== NULL
)
3958 if (elf_hash_table (info
)->dynamic_sections_created
)
3959 bfinfdpic_pltrel_section (info
)->size
=
3960 gpinfop
->g
.lzplt
/ LZPLT_NORMAL_SIZE
* get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
3961 if (bfinfdpic_pltrel_section (info
)->size
== 0)
3962 bfinfdpic_pltrel_section (info
)->flags
|= SEC_EXCLUDE
;
3965 bfinfdpic_pltrel_section (info
)->contents
=
3966 (bfd_byte
*) bfd_zalloc (dynobj
,
3967 bfinfdpic_pltrel_section (info
)->size
);
3968 if (bfinfdpic_pltrel_section (info
)->contents
== NULL
)
3972 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
3973 such that there's room for the additional instruction needed to
3974 call the resolver. Since _bfinfdpic_assign_got_entries didn't
3975 account for them, our block size is 4 bytes smaller than the real
3977 if (elf_hash_table (info
)->dynamic_sections_created
)
3979 bfinfdpic_plt_section (info
)->size
= gpinfop
->g
.lzplt
3980 + ((gpinfop
->g
.lzplt
+ (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) - LZPLT_NORMAL_SIZE
)
3981 / (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) * LZPLT_RESOLVER_EXTRA
);
3984 /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
3985 actually assign lazy PLT entries addresses. */
3986 gpinfop
->g
.lzplt
= 0;
3988 /* Save information that we're going to need to generate GOT and PLT
3990 bfinfdpic_got_initial_offset (info
) = -gpinfop
->gothilo
.min
;
3992 if (get_elf_backend_data (output_bfd
)->want_got_sym
)
3993 elf_hash_table (info
)->hgot
->root
.u
.def
.value
3994 = bfinfdpic_got_initial_offset (info
);
3996 if (elf_hash_table (info
)->dynamic_sections_created
)
3997 bfinfdpic_plt_initial_offset (info
) =
3998 bfinfdpic_plt_section (info
)->size
;
4000 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_plt_entries
,
4003 /* Allocate the PLT section contents only after
4004 _bfinfdpic_assign_plt_entries has a chance to add the size of the
4005 non-lazy PLT entries. */
4006 if (bfinfdpic_plt_section (info
)->size
== 0)
4007 bfinfdpic_plt_section (info
)->flags
|= SEC_EXCLUDE
;
4010 bfinfdpic_plt_section (info
)->contents
=
4011 (bfd_byte
*) bfd_zalloc (dynobj
,
4012 bfinfdpic_plt_section (info
)->size
);
4013 if (bfinfdpic_plt_section (info
)->contents
== NULL
)
4020 /* Set the sizes of the dynamic sections. */
4023 elf32_bfinfdpic_size_dynamic_sections (bfd
*output_bfd
,
4024 struct bfd_link_info
*info
)
4026 struct elf_link_hash_table
*htab
;
4029 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4031 htab
= elf_hash_table (info
);
4032 dynobj
= htab
->dynobj
;
4033 BFD_ASSERT (dynobj
!= NULL
);
4035 if (htab
->dynamic_sections_created
)
4037 /* Set the contents of the .interp section to the interpreter. */
4038 if (bfd_link_executable (info
) && !info
->nointerp
)
4040 s
= bfd_get_linker_section (dynobj
, ".interp");
4041 BFD_ASSERT (s
!= NULL
);
4042 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4043 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
4047 memset (&gpinfo
, 0, sizeof (gpinfo
));
4048 gpinfo
.g
.info
= info
;
4052 htab_t relocs
= bfinfdpic_relocs_info (info
);
4054 htab_traverse (relocs
, _bfinfdpic_resolve_final_relocs_info
, &relocs
);
4056 if (relocs
== bfinfdpic_relocs_info (info
))
4060 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_count_got_plt_entries
,
4063 /* Allocate space to save the summary information, we're going to
4064 use it if we're doing relaxations. */
4065 bfinfdpic_dynamic_got_plt_info (info
) = bfd_alloc (dynobj
, sizeof (gpinfo
.g
));
4067 if (!_bfinfdpic_size_got_plt (output_bfd
, &gpinfo
))
4070 if (elf_hash_table (info
)->dynamic_sections_created
)
4072 if (bfinfdpic_got_section (info
)->size
)
4073 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0))
4076 if (bfinfdpic_pltrel_section (info
)->size
)
4077 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
4078 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
4079 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
4082 if (bfinfdpic_gotrel_section (info
)->size
)
4083 if (!_bfd_elf_add_dynamic_entry (info
, DT_REL
, 0)
4084 || !_bfd_elf_add_dynamic_entry (info
, DT_RELSZ
, 0)
4085 || !_bfd_elf_add_dynamic_entry (info
, DT_RELENT
,
4086 sizeof (Elf32_External_Rel
)))
4090 s
= bfd_get_linker_section (dynobj
, ".dynbss");
4091 if (s
&& s
->size
== 0)
4092 s
->flags
|= SEC_EXCLUDE
;
4094 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
4095 if (s
&& s
->size
== 0)
4096 s
->flags
|= SEC_EXCLUDE
;
4102 elf32_bfinfdpic_always_size_sections (bfd
*output_bfd
,
4103 struct bfd_link_info
*info
)
4105 if (!bfd_link_relocatable (info
)
4106 && !bfd_elf_stack_segment_size (output_bfd
, info
,
4107 "__stacksize", DEFAULT_STACK_SIZE
))
4113 /* Check whether any of the relocations was optimized away, and
4114 subtract it from the relocation or fixup count. */
4116 _bfinfdpic_check_discarded_relocs (bfd
*abfd
, asection
*sec
,
4117 struct bfd_link_info
*info
,
4118 bfd_boolean
*changed
)
4120 Elf_Internal_Shdr
*symtab_hdr
;
4121 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4122 Elf_Internal_Rela
*rel
, *erel
;
4124 if ((sec
->flags
& SEC_RELOC
) == 0
4125 || sec
->reloc_count
== 0)
4128 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4129 sym_hashes
= elf_sym_hashes (abfd
);
4130 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
4131 if (!elf_bad_symtab (abfd
))
4132 sym_hashes_end
-= symtab_hdr
->sh_info
;
4134 rel
= elf_section_data (sec
)->relocs
;
4136 /* Now examine each relocation. */
4137 for (erel
= rel
+ sec
->reloc_count
; rel
< erel
; rel
++)
4139 struct elf_link_hash_entry
*h
;
4140 unsigned long r_symndx
;
4141 struct bfinfdpic_relocs_info
*picrel
;
4142 struct _bfinfdpic_dynamic_got_info
*dinfo
;
4144 if (ELF32_R_TYPE (rel
->r_info
) != R_BFIN_BYTE4_DATA
4145 && ELF32_R_TYPE (rel
->r_info
) != R_BFIN_FUNCDESC
)
4148 if (_bfd_elf_section_offset (sec
->output_section
->owner
,
4149 info
, sec
, rel
->r_offset
)
4153 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4154 if (r_symndx
< symtab_hdr
->sh_info
)
4158 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4159 while (h
->root
.type
== bfd_link_hash_indirect
4160 || h
->root
.type
== bfd_link_hash_warning
)
4161 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
4165 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4167 rel
->r_addend
, NO_INSERT
);
4169 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info
),
4171 rel
->r_addend
, NO_INSERT
);
4177 dinfo
= bfinfdpic_dynamic_got_plt_info (info
);
4179 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, TRUE
);
4180 if (ELF32_R_TYPE (rel
->r_info
) == R_BFIN_BYTE4_DATA
)
4182 else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4184 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, FALSE
);
4191 bfinfdpic_elf_discard_info (bfd
*ibfd
,
4192 struct elf_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
4193 struct bfd_link_info
*info
)
4195 bfd_boolean changed
= FALSE
;
4199 /* Account for relaxation of .eh_frame section. */
4200 for (s
= ibfd
->sections
; s
; s
= s
->next
)
4201 if (s
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4203 if (!_bfinfdpic_check_discarded_relocs (ibfd
, s
, info
, &changed
))
4205 obfd
= s
->output_section
->owner
;
4210 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4212 memset (&gpinfo
, 0, sizeof (gpinfo
));
4213 memcpy (&gpinfo
.g
, bfinfdpic_dynamic_got_plt_info (info
),
4216 /* Clear GOT and PLT assignments. */
4217 htab_traverse (bfinfdpic_relocs_info (info
),
4218 _bfinfdpic_reset_got_plt_entries
,
4221 if (!_bfinfdpic_size_got_plt (obfd
, &gpinfo
))
4229 elf32_bfinfdpic_finish_dynamic_sections (bfd
*output_bfd
,
4230 struct bfd_link_info
*info
)
4235 dynobj
= elf_hash_table (info
)->dynobj
;
4237 if (bfinfdpic_got_section (info
))
4239 BFD_ASSERT (bfinfdpic_gotrel_section (info
)->size
4240 /* PR 17334: It appears that the GOT section can end up
4241 being bigger than the number of relocs. Presumably
4242 because some relocs have been deleted. A test case has
4243 yet to be generated for verify this, but in the meantime
4244 the test below has been changed from == to >= so that
4245 applications can continue to be built. */
4246 >= (bfinfdpic_gotrel_section (info
)->reloc_count
4247 * sizeof (Elf32_External_Rel
)));
4249 if (bfinfdpic_gotfixup_section (info
))
4251 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
4252 bfd_vma got_value
= hgot
->root
.u
.def
.value
4253 + hgot
->root
.u
.def
.section
->output_section
->vma
4254 + hgot
->root
.u
.def
.section
->output_offset
;
4256 _bfinfdpic_add_rofixup (output_bfd
, bfinfdpic_gotfixup_section (info
),
4259 if (bfinfdpic_gotfixup_section (info
)->size
4260 != (bfinfdpic_gotfixup_section (info
)->reloc_count
* 4))
4263 ("LINKER BUG: .rofixup section size mismatch");
4268 if (elf_hash_table (info
)->dynamic_sections_created
)
4270 BFD_ASSERT (bfinfdpic_pltrel_section (info
)->size
4271 == (bfinfdpic_pltrel_section (info
)->reloc_count
4272 * sizeof (Elf32_External_Rel
)));
4275 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4277 if (elf_hash_table (info
)->dynamic_sections_created
)
4279 Elf32_External_Dyn
* dyncon
;
4280 Elf32_External_Dyn
* dynconend
;
4282 BFD_ASSERT (sdyn
!= NULL
);
4284 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4285 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4287 for (; dyncon
< dynconend
; dyncon
++)
4289 Elf_Internal_Dyn dyn
;
4291 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4299 dyn
.d_un
.d_ptr
= bfinfdpic_got_section (info
)->output_section
->vma
4300 + bfinfdpic_got_section (info
)->output_offset
4301 + bfinfdpic_got_initial_offset (info
);
4302 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4306 dyn
.d_un
.d_ptr
= bfinfdpic_pltrel_section (info
)
4307 ->output_section
->vma
4308 + bfinfdpic_pltrel_section (info
)->output_offset
;
4309 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4313 dyn
.d_un
.d_val
= bfinfdpic_pltrel_section (info
)->size
;
4314 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4323 /* Adjust a symbol defined by a dynamic object and referenced by a
4327 elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4328 struct elf_link_hash_entry
*h
)
4332 dynobj
= elf_hash_table (info
)->dynobj
;
4334 /* Make sure we know what is going on here. */
4335 BFD_ASSERT (dynobj
!= NULL
4339 && !h
->def_regular
)));
4341 /* If this is a weak symbol, and there is a real definition, the
4342 processor independent code will have arranged for us to see the
4343 real definition first, and we can just use the same value. */
4344 if (h
->is_weakalias
)
4346 struct elf_link_hash_entry
*def
= weakdef (h
);
4347 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
4348 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
4349 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
4355 /* Perform any actions needed for dynamic symbols. */
4358 elf32_bfinfdpic_finish_dynamic_symbol
4359 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4360 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4361 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
4362 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4367 /* Decide whether to attempt to turn absptr or lsda encodings in
4368 shared libraries into pcrel within the given input section. */
4371 bfinfdpic_elf_use_relative_eh_frame
4372 (bfd
*input_bfd ATTRIBUTE_UNUSED
,
4373 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4374 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
4376 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4380 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4383 bfinfdpic_elf_encode_eh_address (bfd
*abfd
,
4384 struct bfd_link_info
*info
,
4385 asection
*osec
, bfd_vma offset
,
4386 asection
*loc_sec
, bfd_vma loc_offset
,
4389 struct elf_link_hash_entry
*h
;
4391 h
= elf_hash_table (info
)->hgot
;
4392 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
4394 if (! h
|| (_bfinfdpic_osec_to_segment (abfd
, osec
)
4395 == _bfinfdpic_osec_to_segment (abfd
, loc_sec
->output_section
)))
4396 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
4397 loc_sec
, loc_offset
, encoded
);
4399 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd
, osec
)
4400 == (_bfinfdpic_osec_to_segment
4401 (abfd
, h
->root
.u
.def
.section
->output_section
)));
4403 *encoded
= osec
->vma
+ offset
4404 - (h
->root
.u
.def
.value
4405 + h
->root
.u
.def
.section
->output_section
->vma
4406 + h
->root
.u
.def
.section
->output_offset
);
4408 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
4413 /* Look through the relocs for a section during the first phase.
4415 Besides handling virtual table relocs for gc, we have to deal with
4416 all sorts of PIC-related relocations. We describe below the
4417 general plan on how to handle such relocations, even though we only
4418 collect information at this point, storing them in hash tables for
4419 perusal of later passes.
4421 32 relocations are propagated to the linker output when creating
4422 position-independent output. LO16 and HI16 relocations are not
4423 supposed to be encountered in this case.
4425 LABEL16 should always be resolvable by the linker, since it's only
4428 LABEL24, on the other hand, is used by calls. If it turns out that
4429 the target of a call is a dynamic symbol, a PLT entry must be
4430 created for it, which triggers the creation of a private function
4431 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4433 GPREL relocations require the referenced symbol to be in the same
4434 segment as _gp, but this can only be checked later.
4436 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4437 exist. LABEL24 might as well, since it may require a PLT entry,
4438 that will require a got.
4440 Non-FUNCDESC GOT relocations require a GOT entry to be created
4441 regardless of whether the symbol is dynamic. However, since a
4442 global symbol that turns out to not be exported may have the same
4443 address of a non-dynamic symbol, we don't assign GOT entries at
4444 this point, such that we can share them in this case. A relocation
4445 for the GOT entry always has to be created, be it to offset a
4446 private symbol by the section load address, be it to get the symbol
4447 resolved dynamically.
4449 FUNCDESC GOT relocations require a GOT entry to be created, and
4450 handled as if a FUNCDESC relocation was applied to the GOT entry in
4453 FUNCDESC relocations referencing a symbol that turns out to NOT be
4454 dynamic cause a private function descriptor to be created. The
4455 FUNCDESC relocation then decays to a 32 relocation that points at
4456 the private descriptor. If the symbol is dynamic, the FUNCDESC
4457 relocation is propagated to the linker output, such that the
4458 dynamic linker creates the canonical descriptor, pointing to the
4459 dynamically-resolved definition of the function.
4461 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4462 symbols that are assigned to the same segment as the GOT, but we
4463 can only check this later, after we know the complete set of
4464 symbols defined and/or exported.
4466 FUNCDESC GOTOFF relocations require a function descriptor to be
4467 created and, unless lazy binding is disabled or the symbol is not
4468 dynamic, a lazy PLT entry. Since we can't tell at this point
4469 whether a symbol is going to be dynamic, we have to decide later
4470 whether to create a lazy PLT entry or bind the descriptor directly
4471 to the private function.
4473 FUNCDESC_VALUE relocations are not supposed to be present in object
4474 files, but they may very well be simply propagated to the linker
4475 output, since they have no side effect.
4478 A function descriptor always requires a FUNCDESC_VALUE relocation.
4479 Whether it's in .plt.rel or not depends on whether lazy binding is
4480 enabled and on whether the referenced symbol is dynamic.
4482 The existence of a lazy PLT requires the resolverStub lazy PLT
4483 entry to be present.
4486 As for assignment of GOT, PLT and lazy PLT entries, and private
4487 descriptors, we might do them all sequentially, but we can do
4488 better than that. For example, we can place GOT entries and
4489 private function descriptors referenced using 12-bit operands
4490 closer to the PIC register value, such that these relocations don't
4491 overflow. Those that are only referenced with LO16 relocations
4492 could come next, but we may as well place PLT-required function
4493 descriptors in the 12-bit range to make them shorter. Symbols
4494 referenced with LO16/HI16 may come next, but we may place
4495 additional function descriptors in the 16-bit range if we can
4496 reliably tell that we've already placed entries that are ever
4497 referenced with only LO16. PLT entries are therefore generated as
4498 small as possible, while not introducing relocation overflows in
4499 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4500 generated before or after PLT entries, but not intermingled with
4501 them, such that we can have more lazy PLT entries in range for a
4502 branch to the resolverStub. The resolverStub should be emitted at
4503 the most distant location from the first lazy PLT entry such that
4504 it's still in range for a branch, or closer, if there isn't a need
4505 for so many lazy PLT entries. Additional lazy PLT entries may be
4506 emitted after the resolverStub, as long as branches are still in
4507 range. If the branch goes out of range, longer lazy PLT entries
4510 We could further optimize PLT and lazy PLT entries by giving them
4511 priority in assignment to closer-to-gr17 locations depending on the
4512 number of occurrences of references to them (assuming a function
4513 that's called more often is more important for performance, so its
4514 PLT entry should be faster), or taking hints from the compiler.
4515 Given infinite time and money... :-) */
4518 bfinfdpic_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4519 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4521 Elf_Internal_Shdr
*symtab_hdr
;
4522 struct elf_link_hash_entry
**sym_hashes
;
4523 const Elf_Internal_Rela
*rel
;
4524 const Elf_Internal_Rela
*rel_end
;
4526 struct bfinfdpic_relocs_info
*picrel
;
4528 if (bfd_link_relocatable (info
))
4531 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4532 sym_hashes
= elf_sym_hashes (abfd
);
4534 dynobj
= elf_hash_table (info
)->dynobj
;
4535 rel_end
= relocs
+ sec
->reloc_count
;
4536 for (rel
= relocs
; rel
< rel_end
; rel
++)
4538 struct elf_link_hash_entry
*h
;
4539 unsigned long r_symndx
;
4541 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4542 if (r_symndx
< symtab_hdr
->sh_info
)
4545 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4547 switch (ELF32_R_TYPE (rel
->r_info
))
4549 case R_BFIN_GOT17M4
:
4552 case R_BFIN_FUNCDESC_GOT17M4
:
4553 case R_BFIN_FUNCDESC_GOTHI
:
4554 case R_BFIN_FUNCDESC_GOTLO
:
4555 case R_BFIN_GOTOFF17M4
:
4556 case R_BFIN_GOTOFFHI
:
4557 case R_BFIN_GOTOFFLO
:
4558 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4559 case R_BFIN_FUNCDESC_GOTOFFHI
:
4560 case R_BFIN_FUNCDESC_GOTOFFLO
:
4561 case R_BFIN_FUNCDESC
:
4562 case R_BFIN_FUNCDESC_VALUE
:
4563 if (! IS_FDPIC (abfd
))
4566 case R_BFIN_PCREL24
:
4567 case R_BFIN_PCREL24_JUMP_L
:
4568 case R_BFIN_BYTE4_DATA
:
4569 if (IS_FDPIC (abfd
) && ! dynobj
)
4571 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
4572 if (! _bfin_create_got_section (abfd
, info
))
4575 if (! IS_FDPIC (abfd
))
4582 if (h
->dynindx
== -1)
4583 switch (ELF_ST_VISIBILITY (h
->other
))
4589 bfd_elf_link_record_dynamic_symbol (info
, h
);
4593 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4595 rel
->r_addend
, INSERT
);
4598 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4599 (info
), abfd
, r_symndx
,
4600 rel
->r_addend
, INSERT
);
4610 switch (ELF32_R_TYPE (rel
->r_info
))
4612 case R_BFIN_PCREL24
:
4613 case R_BFIN_PCREL24_JUMP_L
:
4614 if (IS_FDPIC (abfd
))
4618 case R_BFIN_FUNCDESC_VALUE
:
4619 picrel
->relocsfdv
++;
4620 if (bfd_section_flags (sec
) & SEC_ALLOC
)
4624 case R_BFIN_BYTE4_DATA
:
4625 if (! IS_FDPIC (abfd
))
4629 if (bfd_section_flags (sec
) & SEC_ALLOC
)
4633 case R_BFIN_GOT17M4
:
4642 case R_BFIN_FUNCDESC_GOT17M4
:
4643 picrel
->fdgot17m4
++;
4646 case R_BFIN_FUNCDESC_GOTHI
:
4647 case R_BFIN_FUNCDESC_GOTLO
:
4648 picrel
->fdgothilo
++;
4651 case R_BFIN_GOTOFF17M4
:
4652 case R_BFIN_GOTOFFHI
:
4653 case R_BFIN_GOTOFFLO
:
4657 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4658 picrel
->fdgoff17m4
++;
4661 case R_BFIN_FUNCDESC_GOTOFFHI
:
4662 case R_BFIN_FUNCDESC_GOTOFFLO
:
4663 picrel
->fdgoffhilo
++;
4666 case R_BFIN_FUNCDESC
:
4671 /* This relocation describes the C++ object vtable hierarchy.
4672 Reconstruct it for later use during GC. */
4673 case R_BFIN_GNU_VTINHERIT
:
4674 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4678 /* This relocation describes which C++ vtable entries are actually
4679 used. Record for later use during GC. */
4680 case R_BFIN_GNU_VTENTRY
:
4681 BFD_ASSERT (h
!= NULL
);
4683 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4687 case R_BFIN_HUIMM16
:
4688 case R_BFIN_LUIMM16
:
4689 case R_BFIN_PCREL12_JUMP_S
:
4690 case R_BFIN_PCREL10
:
4696 /* xgettext:c-format */
4697 (_("%pB: unsupported relocation type %#x"),
4698 abfd
, (int) ELF32_R_TYPE (rel
->r_info
));
4706 /* Set the right machine number for a Blackfin ELF file. */
4709 elf32_bfin_object_p (bfd
*abfd
)
4711 bfd_default_set_arch_mach (abfd
, bfd_arch_bfin
, 0);
4712 return (((elf_elfheader (abfd
)->e_flags
& EF_BFIN_FDPIC
) != 0)
4713 == (IS_FDPIC (abfd
)));
4717 elf32_bfin_set_private_flags (bfd
* abfd
, flagword flags
)
4719 elf_elfheader (abfd
)->e_flags
= flags
;
4720 elf_flags_init (abfd
) = TRUE
;
4724 /* Display the flags field. */
4726 elf32_bfin_print_private_bfd_data (bfd
* abfd
, void * ptr
)
4728 FILE *file
= (FILE *) ptr
;
4731 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4733 /* Print normal ELF private data. */
4734 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4736 flags
= elf_elfheader (abfd
)->e_flags
;
4738 /* xgettext:c-format */
4739 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4741 if (flags
& EF_BFIN_PIC
)
4742 fprintf (file
, " -fpic");
4744 if (flags
& EF_BFIN_FDPIC
)
4745 fprintf (file
, " -mfdpic");
4752 /* Merge backend specific data from an object file to the output
4753 object file when linking. */
4756 elf32_bfin_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4758 bfd
*obfd
= info
->output_bfd
;
4759 flagword old_flags
, new_flags
;
4760 bfd_boolean error
= FALSE
;
4762 /* FIXME: What should be checked when linking shared libraries? */
4763 if ((ibfd
->flags
& DYNAMIC
) != 0)
4766 new_flags
= elf_elfheader (ibfd
)->e_flags
;
4767 old_flags
= elf_elfheader (obfd
)->e_flags
;
4769 if (new_flags
& EF_BFIN_FDPIC
)
4770 new_flags
&= ~EF_BFIN_PIC
;
4776 ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %pB",
4777 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no", ibfd
);
4779 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
4781 elf_flags_init (obfd
) = TRUE
;
4782 elf_elfheader (obfd
)->e_flags
= new_flags
;
4785 if (((new_flags
& EF_BFIN_FDPIC
) == 0) != (! IS_FDPIC (obfd
)))
4788 if (IS_FDPIC (obfd
))
4790 (_("%pB: cannot link non-fdpic object file into fdpic executable"),
4794 (_("%pB: cannot link fdpic object file into non-fdpic executable"),
4799 bfd_set_error (bfd_error_bad_value
);
4804 /* bfin ELF linker hash entry. */
4806 struct bfin_link_hash_entry
4808 struct elf_link_hash_entry root
;
4810 /* Number of PC relative relocs copied for this symbol. */
4811 struct bfin_pcrel_relocs_copied
*pcrel_relocs_copied
;
4814 /* bfin ELF linker hash table. */
4816 struct bfin_link_hash_table
4818 struct elf_link_hash_table root
;
4820 /* Small local sym cache. */
4821 struct sym_cache sym_cache
;
4824 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4826 static struct bfd_hash_entry
*
4827 bfin_link_hash_newfunc (struct bfd_hash_entry
*entry
,
4828 struct bfd_hash_table
*table
, const char *string
)
4830 struct bfd_hash_entry
*ret
= entry
;
4832 /* Allocate the structure if it has not already been allocated by a
4835 ret
= bfd_hash_allocate (table
, sizeof (struct bfin_link_hash_entry
));
4839 /* Call the allocation method of the superclass. */
4840 ret
= _bfd_elf_link_hash_newfunc (ret
, table
, string
);
4842 bfin_hash_entry (ret
)->pcrel_relocs_copied
= NULL
;
4847 /* Create an bfin ELF linker hash table. */
4849 static struct bfd_link_hash_table
*
4850 bfin_link_hash_table_create (bfd
* abfd
)
4852 struct bfin_link_hash_table
*ret
;
4853 size_t amt
= sizeof (struct bfin_link_hash_table
);
4855 ret
= bfd_zmalloc (amt
);
4859 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
4860 bfin_link_hash_newfunc
,
4861 sizeof (struct elf_link_hash_entry
),
4868 ret
->sym_cache
.abfd
= NULL
;
4870 return &ret
->root
.root
;
4873 /* The size in bytes of an entry in the procedure linkage table. */
4875 /* Finish up the dynamic sections. */
4878 bfin_finish_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
4879 struct bfd_link_info
*info
)
4884 dynobj
= elf_hash_table (info
)->dynobj
;
4886 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4888 if (elf_hash_table (info
)->dynamic_sections_created
)
4890 Elf32_External_Dyn
*dyncon
, *dynconend
;
4892 BFD_ASSERT (sdyn
!= NULL
);
4894 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4895 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4896 for (; dyncon
< dynconend
; dyncon
++)
4898 Elf_Internal_Dyn dyn
;
4900 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4908 /* Finish up dynamic symbol handling. We set the contents of various
4909 dynamic sections here. */
4912 bfin_finish_dynamic_symbol (bfd
* output_bfd
,
4913 struct bfd_link_info
*info
,
4914 struct elf_link_hash_entry
*h
,
4915 Elf_Internal_Sym
* sym
)
4917 if (h
->got
.offset
!= (bfd_vma
) - 1)
4921 Elf_Internal_Rela rela
;
4924 /* This symbol has an entry in the global offset table.
4927 sgot
= elf_hash_table (info
)->sgot
;
4928 srela
= elf_hash_table (info
)->srelgot
;
4929 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
4931 rela
.r_offset
= (sgot
->output_section
->vma
4932 + sgot
->output_offset
4933 + (h
->got
.offset
& ~(bfd_vma
) 1));
4935 /* If this is a -Bsymbolic link, and the symbol is defined
4936 locally, we just want to emit a RELATIVE reloc. Likewise if
4937 the symbol was forced to be local because of a version file.
4938 The entry in the global offset table will already have been
4939 initialized in the relocate_section function. */
4940 if (bfd_link_pic (info
)
4942 || h
->dynindx
== -1 || h
->forced_local
) && h
->def_regular
)
4944 _bfd_error_handler (_("*** check this relocation %s"),
4946 rela
.r_info
= ELF32_R_INFO (0, R_BFIN_PCREL24
);
4947 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
4951 offset
& ~(bfd_vma
) 1)));
4955 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4956 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
4957 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_BFIN_GOT
);
4961 loc
= srela
->contents
;
4962 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4963 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4970 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4971 if (strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
4972 || h
== elf_hash_table (info
)->hgot
)
4973 sym
->st_shndx
= SHN_ABS
;
4978 /* Adjust a symbol defined by a dynamic object and referenced by a
4979 regular object. The current definition is in some section of the
4980 dynamic object, but we're not including those sections. We have to
4981 change the definition to something the rest of the link can
4985 bfin_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4986 struct elf_link_hash_entry
*h
)
4990 unsigned int power_of_two
;
4992 dynobj
= elf_hash_table (info
)->dynobj
;
4994 /* Make sure we know what is going on here. */
4995 BFD_ASSERT (dynobj
!= NULL
4998 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
5000 /* If this is a function, put it in the procedure linkage table. We
5001 will fill in the contents of the procedure linkage table later,
5002 when we know the address of the .got section. */
5003 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
5008 /* If this is a weak symbol, and there is a real definition, the
5009 processor independent code will have arranged for us to see the
5010 real definition first, and we can just use the same value. */
5011 if (h
->is_weakalias
)
5013 struct elf_link_hash_entry
*def
= weakdef (h
);
5014 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
5015 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
5016 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
5020 /* This is a reference to a symbol defined by a dynamic object which
5021 is not a function. */
5023 /* If we are creating a shared library, we must presume that the
5024 only references to the symbol are via the global offset table.
5025 For such cases we need not do anything here; the relocations will
5026 be handled correctly by relocate_section. */
5027 if (bfd_link_pic (info
))
5030 /* We must allocate the symbol in our .dynbss section, which will
5031 become part of the .bss section of the executable. There will be
5032 an entry for this symbol in the .dynsym section. The dynamic
5033 object will contain position independent code, so all references
5034 from the dynamic object to this symbol will go through the global
5035 offset table. The dynamic linker will use the .dynsym entry to
5036 determine the address it must put in the global offset table, so
5037 both the dynamic object and the regular object will refer to the
5038 same memory location for the variable. */
5040 s
= bfd_get_linker_section (dynobj
, ".dynbss");
5041 BFD_ASSERT (s
!= NULL
);
5043 #if 0 /* Bfin does not currently have a COPY reloc. */
5044 /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5045 copy the initial value out of the dynamic object and into the
5046 runtime process image. We need to remember the offset into the
5047 .rela.bss section we are going to use. */
5048 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5052 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
5053 BFD_ASSERT (srel
!= NULL
);
5054 srel
->size
+= sizeof (Elf32_External_Rela
);
5058 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5060 _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5064 /* We need to figure out the alignment required for this symbol. I
5065 have no idea how ELF linkers handle this. */
5066 power_of_two
= bfd_log2 (h
->size
);
5067 if (power_of_two
> 3)
5070 /* Apply the required alignment. */
5071 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
5072 if (power_of_two
> bfd_section_alignment (s
))
5074 if (!bfd_set_section_alignment (s
, power_of_two
))
5078 /* Define the symbol as being at this point in the section. */
5079 h
->root
.u
.def
.section
= s
;
5080 h
->root
.u
.def
.value
= s
->size
;
5082 /* Increment the section size to make room for the symbol. */
5088 /* The bfin linker needs to keep track of the number of relocs that it
5089 decides to copy in check_relocs for each symbol. This is so that it
5090 can discard PC relative relocs if it doesn't need them when linking
5091 with -Bsymbolic. We store the information in a field extending the
5092 regular ELF linker hash table. */
5094 /* This structure keeps track of the number of PC relative relocs we have
5095 copied for a given symbol. */
5097 struct bfin_pcrel_relocs_copied
5100 struct bfin_pcrel_relocs_copied
*next
;
5101 /* A section in dynobj. */
5103 /* Number of relocs copied in this section. */
5104 bfd_size_type count
;
5107 /* This function is called via elf_link_hash_traverse if we are
5108 creating a shared object. In the -Bsymbolic case it discards the
5109 space allocated to copy PC relative relocs against symbols which
5110 are defined in regular objects. For the normal shared case, it
5111 discards space for pc-relative relocs that have become local due to
5112 symbol visibility changes. We allocated space for them in the
5113 check_relocs routine, but we won't fill them in in the
5114 relocate_section routine.
5116 We also check whether any of the remaining relocations apply
5117 against a readonly section, and set the DF_TEXTREL flag in this
5121 bfin_discard_copies (struct elf_link_hash_entry
*h
, void * inf
)
5123 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5124 struct bfin_pcrel_relocs_copied
*s
;
5126 if (!h
->def_regular
|| (!info
->symbolic
&& !h
->forced_local
))
5128 if ((info
->flags
& DF_TEXTREL
) == 0)
5130 /* Look for relocations against read-only sections. */
5131 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5132 s
!= NULL
; s
= s
->next
)
5133 if ((s
->section
->flags
& SEC_READONLY
) != 0)
5135 info
->flags
|= DF_TEXTREL
;
5143 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5144 s
!= NULL
; s
= s
->next
)
5145 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
5151 bfin_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5152 struct bfd_link_info
*info
)
5158 dynobj
= elf_hash_table (info
)->dynobj
;
5159 BFD_ASSERT (dynobj
!= NULL
);
5161 if (elf_hash_table (info
)->dynamic_sections_created
)
5163 /* Set the contents of the .interp section to the interpreter. */
5164 if (bfd_link_executable (info
) && !info
->nointerp
)
5166 s
= bfd_get_linker_section (dynobj
, ".interp");
5167 BFD_ASSERT (s
!= NULL
);
5168 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5169 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5174 /* We may have created entries in the .rela.got section.
5175 However, if we are not creating the dynamic sections, we will
5176 not actually use these entries. Reset the size of .rela.got,
5177 which will cause it to get stripped from the output file
5179 s
= elf_hash_table (info
)->srelgot
;
5184 /* If this is a -Bsymbolic shared link, then we need to discard all
5185 PC relative relocs against symbols defined in a regular object.
5186 For the normal shared case we discard the PC relative relocs
5187 against symbols that have become local due to visibility changes.
5188 We allocated space for them in the check_relocs routine, but we
5189 will not fill them in in the relocate_section routine. */
5190 if (bfd_link_pic (info
))
5191 elf_link_hash_traverse (elf_hash_table (info
),
5192 bfin_discard_copies
, info
);
5194 /* The check_relocs and adjust_dynamic_symbol entry points have
5195 determined the sizes of the various dynamic sections. Allocate
5198 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5203 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5206 /* It's OK to base decisions on the section name, because none
5207 of the dynobj section names depend upon the input files. */
5208 name
= bfd_section_name (s
);
5212 if (CONST_STRNEQ (name
, ".rela"))
5216 /* If we don't need this section, strip it from the
5217 output file. This is mostly to handle .rela.bss and
5218 .rela.plt. We must create both sections in
5219 create_dynamic_sections, because they must be created
5220 before the linker maps input sections to output
5221 sections. The linker does that before
5222 adjust_dynamic_symbol is called, and it is that
5223 function which decides whether anything needs to go
5224 into these sections. */
5231 /* We use the reloc_count field as a counter if we need
5232 to copy relocs into the output file. */
5236 else if (! CONST_STRNEQ (name
, ".got"))
5238 /* It's not one of our sections, so don't allocate space. */
5244 s
->flags
|= SEC_EXCLUDE
;
5248 /* Allocate memory for the section contents. */
5249 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5250 Unused entries should be reclaimed before the section's contents
5251 are written out, but at the moment this does not happen. Thus in
5252 order to prevent writing out garbage, we initialise the section's
5253 contents to zero. */
5254 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5255 if (s
->contents
== NULL
&& s
->size
!= 0)
5259 if (elf_hash_table (info
)->dynamic_sections_created
)
5261 /* Add some entries to the .dynamic section. We fill in the
5262 values later, in bfin_finish_dynamic_sections, but we
5263 must add the entries now so that we get the correct size for
5264 the .dynamic section. The DT_DEBUG entry is filled in by the
5265 dynamic linker and used by the debugger. */
5266 #define add_dynamic_entry(TAG, VAL) \
5267 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5269 if (!bfd_link_pic (info
))
5271 if (!add_dynamic_entry (DT_DEBUG
, 0))
5278 if (!add_dynamic_entry (DT_RELA
, 0)
5279 || !add_dynamic_entry (DT_RELASZ
, 0)
5280 || !add_dynamic_entry (DT_RELAENT
,
5281 sizeof (Elf32_External_Rela
)))
5285 if ((info
->flags
& DF_TEXTREL
) != 0)
5287 if (!add_dynamic_entry (DT_TEXTREL
, 0))
5291 #undef add_dynamic_entry
5296 /* Given a .data section and a .emreloc in-memory section, store
5297 relocation information into the .emreloc section which can be
5298 used at runtime to relocate the section. This is called by the
5299 linker when the --embedded-relocs switch is used. This is called
5300 after the add_symbols entry point has been called for all the
5301 objects, and before the final_link entry point is called. */
5304 bfd_bfin_elf32_create_embedded_relocs (bfd
*abfd
,
5305 struct bfd_link_info
*info
,
5310 Elf_Internal_Shdr
*symtab_hdr
;
5311 Elf_Internal_Sym
*isymbuf
= NULL
;
5312 Elf_Internal_Rela
*internal_relocs
= NULL
;
5313 Elf_Internal_Rela
*irel
, *irelend
;
5317 BFD_ASSERT (! bfd_link_relocatable (info
));
5321 if (datasec
->reloc_count
== 0)
5324 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5326 /* Get a copy of the native relocations. */
5327 internal_relocs
= (_bfd_elf_link_read_relocs
5328 (abfd
, datasec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5329 info
->keep_memory
));
5330 if (internal_relocs
== NULL
)
5333 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
5334 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
5335 if (relsec
->contents
== NULL
)
5338 p
= relsec
->contents
;
5340 irelend
= internal_relocs
+ datasec
->reloc_count
;
5341 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
5343 asection
*targetsec
;
5345 /* We are going to write a four byte longword into the runtime
5346 reloc section. The longword will be the address in the data
5347 section which must be relocated. It is followed by the name
5348 of the target section NUL-padded or truncated to 8
5351 /* We can only relocate absolute longword relocs at run time. */
5352 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_BFIN_BYTE4_DATA
)
5354 *errmsg
= _("unsupported relocation type");
5355 bfd_set_error (bfd_error_bad_value
);
5359 /* Get the target section referred to by the reloc. */
5360 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
5362 /* A local symbol. */
5363 Elf_Internal_Sym
*isym
;
5365 /* Read this BFD's local symbols if we haven't done so already. */
5366 if (isymbuf
== NULL
)
5368 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5369 if (isymbuf
== NULL
)
5370 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5371 symtab_hdr
->sh_info
, 0,
5373 if (isymbuf
== NULL
)
5377 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
5378 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5383 struct elf_link_hash_entry
*h
;
5385 /* An external symbol. */
5386 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
5387 h
= elf_sym_hashes (abfd
)[indx
];
5388 BFD_ASSERT (h
!= NULL
);
5389 if (h
->root
.type
== bfd_link_hash_defined
5390 || h
->root
.type
== bfd_link_hash_defweak
)
5391 targetsec
= h
->root
.u
.def
.section
;
5396 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
5397 memset (p
+ 4, 0, 8);
5398 if (targetsec
!= NULL
)
5399 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
5402 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5404 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
5405 free (internal_relocs
);
5409 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5411 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
5412 free (internal_relocs
);
5416 struct bfd_elf_special_section
const elf32_bfin_special_sections
[] =
5418 { ".l1.text", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5419 { ".l1.data", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
5420 { NULL
, 0, 0, 0, 0 }
5424 #define TARGET_LITTLE_SYM bfin_elf32_vec
5425 #define TARGET_LITTLE_NAME "elf32-bfin"
5426 #define ELF_ARCH bfd_arch_bfin
5427 #define ELF_TARGET_ID BFIN_ELF_DATA
5428 #define ELF_MACHINE_CODE EM_BLACKFIN
5429 #define ELF_MAXPAGESIZE 0x1000
5430 #define elf_symbol_leading_char '_'
5432 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5433 #define bfd_elf32_bfd_reloc_name_lookup \
5434 bfin_bfd_reloc_name_lookup
5435 #define elf_info_to_howto bfin_info_to_howto
5436 #define elf_info_to_howto_rel NULL
5437 #define elf_backend_object_p elf32_bfin_object_p
5439 #define bfd_elf32_bfd_is_local_label_name \
5440 bfin_is_local_label_name
5441 #define bfin_hash_table(p) \
5442 ((struct bfin_link_hash_table *) (p)->hash)
5446 #define elf_backend_create_dynamic_sections \
5447 _bfd_elf_create_dynamic_sections
5448 #define bfd_elf32_bfd_link_hash_table_create \
5449 bfin_link_hash_table_create
5450 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5452 #define elf_backend_check_relocs bfin_check_relocs
5453 #define elf_backend_adjust_dynamic_symbol \
5454 bfin_adjust_dynamic_symbol
5455 #define elf_backend_size_dynamic_sections \
5456 bfin_size_dynamic_sections
5457 #define elf_backend_relocate_section bfin_relocate_section
5458 #define elf_backend_finish_dynamic_symbol \
5459 bfin_finish_dynamic_symbol
5460 #define elf_backend_finish_dynamic_sections \
5461 bfin_finish_dynamic_sections
5462 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5463 #define bfd_elf32_bfd_merge_private_bfd_data \
5464 elf32_bfin_merge_private_bfd_data
5465 #define bfd_elf32_bfd_set_private_flags \
5466 elf32_bfin_set_private_flags
5467 #define bfd_elf32_bfd_print_private_bfd_data \
5468 elf32_bfin_print_private_bfd_data
5469 #define elf_backend_final_write_processing \
5470 elf32_bfin_final_write_processing
5471 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5472 #define elf_backend_stack_align 8
5473 #define elf_backend_can_gc_sections 1
5474 #define elf_backend_special_sections elf32_bfin_special_sections
5475 #define elf_backend_can_refcount 1
5476 #define elf_backend_want_got_plt 0
5477 #define elf_backend_plt_readonly 1
5478 #define elf_backend_want_plt_sym 0
5479 #define elf_backend_got_header_size 12
5480 #define elf_backend_rela_normal 1
5482 #include "elf32-target.h"
5484 #undef TARGET_LITTLE_SYM
5485 #define TARGET_LITTLE_SYM bfin_elf32_fdpic_vec
5486 #undef TARGET_LITTLE_NAME
5487 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5489 #define elf32_bed elf32_bfinfdpic_bed
5491 #undef elf_backend_got_header_size
5492 #define elf_backend_got_header_size 0
5494 #undef elf_backend_relocate_section
5495 #define elf_backend_relocate_section bfinfdpic_relocate_section
5496 #undef elf_backend_check_relocs
5497 #define elf_backend_check_relocs bfinfdpic_check_relocs
5499 #undef bfd_elf32_bfd_link_hash_table_create
5500 #define bfd_elf32_bfd_link_hash_table_create \
5501 bfinfdpic_elf_link_hash_table_create
5502 #undef elf_backend_always_size_sections
5503 #define elf_backend_always_size_sections \
5504 elf32_bfinfdpic_always_size_sections
5506 #undef elf_backend_create_dynamic_sections
5507 #define elf_backend_create_dynamic_sections \
5508 elf32_bfinfdpic_create_dynamic_sections
5509 #undef elf_backend_adjust_dynamic_symbol
5510 #define elf_backend_adjust_dynamic_symbol \
5511 elf32_bfinfdpic_adjust_dynamic_symbol
5512 #undef elf_backend_size_dynamic_sections
5513 #define elf_backend_size_dynamic_sections \
5514 elf32_bfinfdpic_size_dynamic_sections
5515 #undef elf_backend_finish_dynamic_symbol
5516 #define elf_backend_finish_dynamic_symbol \
5517 elf32_bfinfdpic_finish_dynamic_symbol
5518 #undef elf_backend_finish_dynamic_sections
5519 #define elf_backend_finish_dynamic_sections \
5520 elf32_bfinfdpic_finish_dynamic_sections
5522 #undef elf_backend_discard_info
5523 #define elf_backend_discard_info \
5524 bfinfdpic_elf_discard_info
5525 #undef elf_backend_can_make_relative_eh_frame
5526 #define elf_backend_can_make_relative_eh_frame \
5527 bfinfdpic_elf_use_relative_eh_frame
5528 #undef elf_backend_can_make_lsda_relative_eh_frame
5529 #define elf_backend_can_make_lsda_relative_eh_frame \
5530 bfinfdpic_elf_use_relative_eh_frame
5531 #undef elf_backend_encode_eh_address
5532 #define elf_backend_encode_eh_address \
5533 bfinfdpic_elf_encode_eh_address
5535 #undef elf_backend_may_use_rel_p
5536 #define elf_backend_may_use_rel_p 1
5537 #undef elf_backend_may_use_rela_p
5538 #define elf_backend_may_use_rela_p 1
5539 /* We use REL for dynamic relocations only. */
5540 #undef elf_backend_default_use_rela_p
5541 #define elf_backend_default_use_rela_p 1
5543 #undef elf_backend_omit_section_dynsym
5544 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5546 #include "elf32-target.h"