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 s
= bfd_get_linker_section (dynobj
, ".dynbss");
4071 if (s
&& s
->size
== 0)
4072 s
->flags
|= SEC_EXCLUDE
;
4074 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
4075 if (s
&& s
->size
== 0)
4076 s
->flags
|= SEC_EXCLUDE
;
4078 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, TRUE
);
4082 elf32_bfinfdpic_always_size_sections (bfd
*output_bfd
,
4083 struct bfd_link_info
*info
)
4085 if (!bfd_link_relocatable (info
)
4086 && !bfd_elf_stack_segment_size (output_bfd
, info
,
4087 "__stacksize", DEFAULT_STACK_SIZE
))
4093 /* Check whether any of the relocations was optimized away, and
4094 subtract it from the relocation or fixup count. */
4096 _bfinfdpic_check_discarded_relocs (bfd
*abfd
, asection
*sec
,
4097 struct bfd_link_info
*info
,
4098 bfd_boolean
*changed
)
4100 Elf_Internal_Shdr
*symtab_hdr
;
4101 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4102 Elf_Internal_Rela
*rel
, *erel
;
4104 if ((sec
->flags
& SEC_RELOC
) == 0
4105 || sec
->reloc_count
== 0)
4108 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4109 sym_hashes
= elf_sym_hashes (abfd
);
4110 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
4111 if (!elf_bad_symtab (abfd
))
4112 sym_hashes_end
-= symtab_hdr
->sh_info
;
4114 rel
= elf_section_data (sec
)->relocs
;
4116 /* Now examine each relocation. */
4117 for (erel
= rel
+ sec
->reloc_count
; rel
< erel
; rel
++)
4119 struct elf_link_hash_entry
*h
;
4120 unsigned long r_symndx
;
4121 struct bfinfdpic_relocs_info
*picrel
;
4122 struct _bfinfdpic_dynamic_got_info
*dinfo
;
4124 if (ELF32_R_TYPE (rel
->r_info
) != R_BFIN_BYTE4_DATA
4125 && ELF32_R_TYPE (rel
->r_info
) != R_BFIN_FUNCDESC
)
4128 if (_bfd_elf_section_offset (sec
->output_section
->owner
,
4129 info
, sec
, rel
->r_offset
)
4133 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4134 if (r_symndx
< symtab_hdr
->sh_info
)
4138 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4139 while (h
->root
.type
== bfd_link_hash_indirect
4140 || h
->root
.type
== bfd_link_hash_warning
)
4141 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
4145 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4147 rel
->r_addend
, NO_INSERT
);
4149 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info
),
4151 rel
->r_addend
, NO_INSERT
);
4157 dinfo
= bfinfdpic_dynamic_got_plt_info (info
);
4159 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, TRUE
);
4160 if (ELF32_R_TYPE (rel
->r_info
) == R_BFIN_BYTE4_DATA
)
4162 else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4164 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, FALSE
);
4171 bfinfdpic_elf_discard_info (bfd
*ibfd
,
4172 struct elf_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
4173 struct bfd_link_info
*info
)
4175 bfd_boolean changed
= FALSE
;
4179 /* Account for relaxation of .eh_frame section. */
4180 for (s
= ibfd
->sections
; s
; s
= s
->next
)
4181 if (s
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4183 if (!_bfinfdpic_check_discarded_relocs (ibfd
, s
, info
, &changed
))
4185 obfd
= s
->output_section
->owner
;
4190 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4192 memset (&gpinfo
, 0, sizeof (gpinfo
));
4193 memcpy (&gpinfo
.g
, bfinfdpic_dynamic_got_plt_info (info
),
4196 /* Clear GOT and PLT assignments. */
4197 htab_traverse (bfinfdpic_relocs_info (info
),
4198 _bfinfdpic_reset_got_plt_entries
,
4201 if (!_bfinfdpic_size_got_plt (obfd
, &gpinfo
))
4209 elf32_bfinfdpic_finish_dynamic_sections (bfd
*output_bfd
,
4210 struct bfd_link_info
*info
)
4215 dynobj
= elf_hash_table (info
)->dynobj
;
4217 if (bfinfdpic_got_section (info
))
4219 BFD_ASSERT (bfinfdpic_gotrel_section (info
)->size
4220 /* PR 17334: It appears that the GOT section can end up
4221 being bigger than the number of relocs. Presumably
4222 because some relocs have been deleted. A test case has
4223 yet to be generated for verify this, but in the meantime
4224 the test below has been changed from == to >= so that
4225 applications can continue to be built. */
4226 >= (bfinfdpic_gotrel_section (info
)->reloc_count
4227 * sizeof (Elf32_External_Rel
)));
4229 if (bfinfdpic_gotfixup_section (info
))
4231 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
4232 bfd_vma got_value
= hgot
->root
.u
.def
.value
4233 + hgot
->root
.u
.def
.section
->output_section
->vma
4234 + hgot
->root
.u
.def
.section
->output_offset
;
4236 _bfinfdpic_add_rofixup (output_bfd
, bfinfdpic_gotfixup_section (info
),
4239 if (bfinfdpic_gotfixup_section (info
)->size
4240 != (bfinfdpic_gotfixup_section (info
)->reloc_count
* 4))
4243 ("LINKER BUG: .rofixup section size mismatch");
4248 if (elf_hash_table (info
)->dynamic_sections_created
)
4250 BFD_ASSERT (bfinfdpic_pltrel_section (info
)->size
4251 == (bfinfdpic_pltrel_section (info
)->reloc_count
4252 * sizeof (Elf32_External_Rel
)));
4255 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4257 if (elf_hash_table (info
)->dynamic_sections_created
)
4259 Elf32_External_Dyn
* dyncon
;
4260 Elf32_External_Dyn
* dynconend
;
4262 BFD_ASSERT (sdyn
!= NULL
);
4264 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4265 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4267 for (; dyncon
< dynconend
; dyncon
++)
4269 Elf_Internal_Dyn dyn
;
4271 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4279 dyn
.d_un
.d_ptr
= bfinfdpic_got_section (info
)->output_section
->vma
4280 + bfinfdpic_got_section (info
)->output_offset
4281 + bfinfdpic_got_initial_offset (info
);
4282 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4286 dyn
.d_un
.d_ptr
= bfinfdpic_pltrel_section (info
)
4287 ->output_section
->vma
4288 + bfinfdpic_pltrel_section (info
)->output_offset
;
4289 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4293 dyn
.d_un
.d_val
= bfinfdpic_pltrel_section (info
)->size
;
4294 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4303 /* Adjust a symbol defined by a dynamic object and referenced by a
4307 elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4308 struct elf_link_hash_entry
*h
)
4312 dynobj
= elf_hash_table (info
)->dynobj
;
4314 /* Make sure we know what is going on here. */
4315 BFD_ASSERT (dynobj
!= NULL
4319 && !h
->def_regular
)));
4321 /* If this is a weak symbol, and there is a real definition, the
4322 processor independent code will have arranged for us to see the
4323 real definition first, and we can just use the same value. */
4324 if (h
->is_weakalias
)
4326 struct elf_link_hash_entry
*def
= weakdef (h
);
4327 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
4328 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
4329 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
4335 /* Perform any actions needed for dynamic symbols. */
4338 elf32_bfinfdpic_finish_dynamic_symbol
4339 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4340 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4341 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
4342 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4347 /* Decide whether to attempt to turn absptr or lsda encodings in
4348 shared libraries into pcrel within the given input section. */
4351 bfinfdpic_elf_use_relative_eh_frame
4352 (bfd
*input_bfd ATTRIBUTE_UNUSED
,
4353 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4354 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
4356 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4360 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4363 bfinfdpic_elf_encode_eh_address (bfd
*abfd
,
4364 struct bfd_link_info
*info
,
4365 asection
*osec
, bfd_vma offset
,
4366 asection
*loc_sec
, bfd_vma loc_offset
,
4369 struct elf_link_hash_entry
*h
;
4371 h
= elf_hash_table (info
)->hgot
;
4372 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
4374 if (! h
|| (_bfinfdpic_osec_to_segment (abfd
, osec
)
4375 == _bfinfdpic_osec_to_segment (abfd
, loc_sec
->output_section
)))
4376 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
4377 loc_sec
, loc_offset
, encoded
);
4379 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd
, osec
)
4380 == (_bfinfdpic_osec_to_segment
4381 (abfd
, h
->root
.u
.def
.section
->output_section
)));
4383 *encoded
= osec
->vma
+ offset
4384 - (h
->root
.u
.def
.value
4385 + h
->root
.u
.def
.section
->output_section
->vma
4386 + h
->root
.u
.def
.section
->output_offset
);
4388 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
4393 /* Look through the relocs for a section during the first phase.
4395 Besides handling virtual table relocs for gc, we have to deal with
4396 all sorts of PIC-related relocations. We describe below the
4397 general plan on how to handle such relocations, even though we only
4398 collect information at this point, storing them in hash tables for
4399 perusal of later passes.
4401 32 relocations are propagated to the linker output when creating
4402 position-independent output. LO16 and HI16 relocations are not
4403 supposed to be encountered in this case.
4405 LABEL16 should always be resolvable by the linker, since it's only
4408 LABEL24, on the other hand, is used by calls. If it turns out that
4409 the target of a call is a dynamic symbol, a PLT entry must be
4410 created for it, which triggers the creation of a private function
4411 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4413 GPREL relocations require the referenced symbol to be in the same
4414 segment as _gp, but this can only be checked later.
4416 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4417 exist. LABEL24 might as well, since it may require a PLT entry,
4418 that will require a got.
4420 Non-FUNCDESC GOT relocations require a GOT entry to be created
4421 regardless of whether the symbol is dynamic. However, since a
4422 global symbol that turns out to not be exported may have the same
4423 address of a non-dynamic symbol, we don't assign GOT entries at
4424 this point, such that we can share them in this case. A relocation
4425 for the GOT entry always has to be created, be it to offset a
4426 private symbol by the section load address, be it to get the symbol
4427 resolved dynamically.
4429 FUNCDESC GOT relocations require a GOT entry to be created, and
4430 handled as if a FUNCDESC relocation was applied to the GOT entry in
4433 FUNCDESC relocations referencing a symbol that turns out to NOT be
4434 dynamic cause a private function descriptor to be created. The
4435 FUNCDESC relocation then decays to a 32 relocation that points at
4436 the private descriptor. If the symbol is dynamic, the FUNCDESC
4437 relocation is propagated to the linker output, such that the
4438 dynamic linker creates the canonical descriptor, pointing to the
4439 dynamically-resolved definition of the function.
4441 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4442 symbols that are assigned to the same segment as the GOT, but we
4443 can only check this later, after we know the complete set of
4444 symbols defined and/or exported.
4446 FUNCDESC GOTOFF relocations require a function descriptor to be
4447 created and, unless lazy binding is disabled or the symbol is not
4448 dynamic, a lazy PLT entry. Since we can't tell at this point
4449 whether a symbol is going to be dynamic, we have to decide later
4450 whether to create a lazy PLT entry or bind the descriptor directly
4451 to the private function.
4453 FUNCDESC_VALUE relocations are not supposed to be present in object
4454 files, but they may very well be simply propagated to the linker
4455 output, since they have no side effect.
4458 A function descriptor always requires a FUNCDESC_VALUE relocation.
4459 Whether it's in .plt.rel or not depends on whether lazy binding is
4460 enabled and on whether the referenced symbol is dynamic.
4462 The existence of a lazy PLT requires the resolverStub lazy PLT
4463 entry to be present.
4466 As for assignment of GOT, PLT and lazy PLT entries, and private
4467 descriptors, we might do them all sequentially, but we can do
4468 better than that. For example, we can place GOT entries and
4469 private function descriptors referenced using 12-bit operands
4470 closer to the PIC register value, such that these relocations don't
4471 overflow. Those that are only referenced with LO16 relocations
4472 could come next, but we may as well place PLT-required function
4473 descriptors in the 12-bit range to make them shorter. Symbols
4474 referenced with LO16/HI16 may come next, but we may place
4475 additional function descriptors in the 16-bit range if we can
4476 reliably tell that we've already placed entries that are ever
4477 referenced with only LO16. PLT entries are therefore generated as
4478 small as possible, while not introducing relocation overflows in
4479 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4480 generated before or after PLT entries, but not intermingled with
4481 them, such that we can have more lazy PLT entries in range for a
4482 branch to the resolverStub. The resolverStub should be emitted at
4483 the most distant location from the first lazy PLT entry such that
4484 it's still in range for a branch, or closer, if there isn't a need
4485 for so many lazy PLT entries. Additional lazy PLT entries may be
4486 emitted after the resolverStub, as long as branches are still in
4487 range. If the branch goes out of range, longer lazy PLT entries
4490 We could further optimize PLT and lazy PLT entries by giving them
4491 priority in assignment to closer-to-gr17 locations depending on the
4492 number of occurrences of references to them (assuming a function
4493 that's called more often is more important for performance, so its
4494 PLT entry should be faster), or taking hints from the compiler.
4495 Given infinite time and money... :-) */
4498 bfinfdpic_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4499 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4501 Elf_Internal_Shdr
*symtab_hdr
;
4502 struct elf_link_hash_entry
**sym_hashes
;
4503 const Elf_Internal_Rela
*rel
;
4504 const Elf_Internal_Rela
*rel_end
;
4506 struct bfinfdpic_relocs_info
*picrel
;
4508 if (bfd_link_relocatable (info
))
4511 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4512 sym_hashes
= elf_sym_hashes (abfd
);
4514 dynobj
= elf_hash_table (info
)->dynobj
;
4515 rel_end
= relocs
+ sec
->reloc_count
;
4516 for (rel
= relocs
; rel
< rel_end
; rel
++)
4518 struct elf_link_hash_entry
*h
;
4519 unsigned long r_symndx
;
4521 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4522 if (r_symndx
< symtab_hdr
->sh_info
)
4525 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4527 switch (ELF32_R_TYPE (rel
->r_info
))
4529 case R_BFIN_GOT17M4
:
4532 case R_BFIN_FUNCDESC_GOT17M4
:
4533 case R_BFIN_FUNCDESC_GOTHI
:
4534 case R_BFIN_FUNCDESC_GOTLO
:
4535 case R_BFIN_GOTOFF17M4
:
4536 case R_BFIN_GOTOFFHI
:
4537 case R_BFIN_GOTOFFLO
:
4538 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4539 case R_BFIN_FUNCDESC_GOTOFFHI
:
4540 case R_BFIN_FUNCDESC_GOTOFFLO
:
4541 case R_BFIN_FUNCDESC
:
4542 case R_BFIN_FUNCDESC_VALUE
:
4543 if (! IS_FDPIC (abfd
))
4546 case R_BFIN_PCREL24
:
4547 case R_BFIN_PCREL24_JUMP_L
:
4548 case R_BFIN_BYTE4_DATA
:
4549 if (IS_FDPIC (abfd
) && ! dynobj
)
4551 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
4552 if (! _bfin_create_got_section (abfd
, info
))
4555 if (! IS_FDPIC (abfd
))
4562 if (h
->dynindx
== -1)
4563 switch (ELF_ST_VISIBILITY (h
->other
))
4569 bfd_elf_link_record_dynamic_symbol (info
, h
);
4573 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4575 rel
->r_addend
, INSERT
);
4578 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4579 (info
), abfd
, r_symndx
,
4580 rel
->r_addend
, INSERT
);
4590 switch (ELF32_R_TYPE (rel
->r_info
))
4592 case R_BFIN_PCREL24
:
4593 case R_BFIN_PCREL24_JUMP_L
:
4594 if (IS_FDPIC (abfd
))
4598 case R_BFIN_FUNCDESC_VALUE
:
4599 picrel
->relocsfdv
++;
4600 if (bfd_section_flags (sec
) & SEC_ALLOC
)
4604 case R_BFIN_BYTE4_DATA
:
4605 if (! IS_FDPIC (abfd
))
4609 if (bfd_section_flags (sec
) & SEC_ALLOC
)
4613 case R_BFIN_GOT17M4
:
4622 case R_BFIN_FUNCDESC_GOT17M4
:
4623 picrel
->fdgot17m4
++;
4626 case R_BFIN_FUNCDESC_GOTHI
:
4627 case R_BFIN_FUNCDESC_GOTLO
:
4628 picrel
->fdgothilo
++;
4631 case R_BFIN_GOTOFF17M4
:
4632 case R_BFIN_GOTOFFHI
:
4633 case R_BFIN_GOTOFFLO
:
4637 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4638 picrel
->fdgoff17m4
++;
4641 case R_BFIN_FUNCDESC_GOTOFFHI
:
4642 case R_BFIN_FUNCDESC_GOTOFFLO
:
4643 picrel
->fdgoffhilo
++;
4646 case R_BFIN_FUNCDESC
:
4651 /* This relocation describes the C++ object vtable hierarchy.
4652 Reconstruct it for later use during GC. */
4653 case R_BFIN_GNU_VTINHERIT
:
4654 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4658 /* This relocation describes which C++ vtable entries are actually
4659 used. Record for later use during GC. */
4660 case R_BFIN_GNU_VTENTRY
:
4661 BFD_ASSERT (h
!= NULL
);
4663 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4667 case R_BFIN_HUIMM16
:
4668 case R_BFIN_LUIMM16
:
4669 case R_BFIN_PCREL12_JUMP_S
:
4670 case R_BFIN_PCREL10
:
4676 /* xgettext:c-format */
4677 (_("%pB: unsupported relocation type %#x"),
4678 abfd
, (int) ELF32_R_TYPE (rel
->r_info
));
4686 /* Set the right machine number for a Blackfin ELF file. */
4689 elf32_bfin_object_p (bfd
*abfd
)
4691 bfd_default_set_arch_mach (abfd
, bfd_arch_bfin
, 0);
4692 return (((elf_elfheader (abfd
)->e_flags
& EF_BFIN_FDPIC
) != 0)
4693 == (IS_FDPIC (abfd
)));
4697 elf32_bfin_set_private_flags (bfd
* abfd
, flagword flags
)
4699 elf_elfheader (abfd
)->e_flags
= flags
;
4700 elf_flags_init (abfd
) = TRUE
;
4704 /* Display the flags field. */
4706 elf32_bfin_print_private_bfd_data (bfd
* abfd
, void * ptr
)
4708 FILE *file
= (FILE *) ptr
;
4711 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4713 /* Print normal ELF private data. */
4714 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4716 flags
= elf_elfheader (abfd
)->e_flags
;
4718 /* xgettext:c-format */
4719 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4721 if (flags
& EF_BFIN_PIC
)
4722 fprintf (file
, " -fpic");
4724 if (flags
& EF_BFIN_FDPIC
)
4725 fprintf (file
, " -mfdpic");
4732 /* Merge backend specific data from an object file to the output
4733 object file when linking. */
4736 elf32_bfin_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4738 bfd
*obfd
= info
->output_bfd
;
4739 flagword old_flags
, new_flags
;
4740 bfd_boolean error
= FALSE
;
4742 /* FIXME: What should be checked when linking shared libraries? */
4743 if ((ibfd
->flags
& DYNAMIC
) != 0)
4746 new_flags
= elf_elfheader (ibfd
)->e_flags
;
4747 old_flags
= elf_elfheader (obfd
)->e_flags
;
4749 if (new_flags
& EF_BFIN_FDPIC
)
4750 new_flags
&= ~EF_BFIN_PIC
;
4756 ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %pB",
4757 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no", ibfd
);
4759 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
4761 elf_flags_init (obfd
) = TRUE
;
4762 elf_elfheader (obfd
)->e_flags
= new_flags
;
4765 if (((new_flags
& EF_BFIN_FDPIC
) == 0) != (! IS_FDPIC (obfd
)))
4768 if (IS_FDPIC (obfd
))
4770 (_("%pB: cannot link non-fdpic object file into fdpic executable"),
4774 (_("%pB: cannot link fdpic object file into non-fdpic executable"),
4779 bfd_set_error (bfd_error_bad_value
);
4784 /* bfin ELF linker hash entry. */
4786 struct bfin_link_hash_entry
4788 struct elf_link_hash_entry root
;
4790 /* Number of PC relative relocs copied for this symbol. */
4791 struct bfin_pcrel_relocs_copied
*pcrel_relocs_copied
;
4794 /* bfin ELF linker hash table. */
4796 struct bfin_link_hash_table
4798 struct elf_link_hash_table root
;
4800 /* Small local sym cache. */
4801 struct sym_cache sym_cache
;
4804 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4806 static struct bfd_hash_entry
*
4807 bfin_link_hash_newfunc (struct bfd_hash_entry
*entry
,
4808 struct bfd_hash_table
*table
, const char *string
)
4810 struct bfd_hash_entry
*ret
= entry
;
4812 /* Allocate the structure if it has not already been allocated by a
4815 ret
= bfd_hash_allocate (table
, sizeof (struct bfin_link_hash_entry
));
4819 /* Call the allocation method of the superclass. */
4820 ret
= _bfd_elf_link_hash_newfunc (ret
, table
, string
);
4822 bfin_hash_entry (ret
)->pcrel_relocs_copied
= NULL
;
4827 /* Create an bfin ELF linker hash table. */
4829 static struct bfd_link_hash_table
*
4830 bfin_link_hash_table_create (bfd
* abfd
)
4832 struct bfin_link_hash_table
*ret
;
4833 size_t amt
= sizeof (struct bfin_link_hash_table
);
4835 ret
= bfd_zmalloc (amt
);
4839 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
4840 bfin_link_hash_newfunc
,
4841 sizeof (struct elf_link_hash_entry
),
4848 ret
->sym_cache
.abfd
= NULL
;
4850 return &ret
->root
.root
;
4853 /* The size in bytes of an entry in the procedure linkage table. */
4855 /* Finish up the dynamic sections. */
4858 bfin_finish_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
4859 struct bfd_link_info
*info
)
4864 dynobj
= elf_hash_table (info
)->dynobj
;
4866 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4868 if (elf_hash_table (info
)->dynamic_sections_created
)
4870 Elf32_External_Dyn
*dyncon
, *dynconend
;
4872 BFD_ASSERT (sdyn
!= NULL
);
4874 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4875 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4876 for (; dyncon
< dynconend
; dyncon
++)
4878 Elf_Internal_Dyn dyn
;
4880 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4888 /* Finish up dynamic symbol handling. We set the contents of various
4889 dynamic sections here. */
4892 bfin_finish_dynamic_symbol (bfd
* output_bfd
,
4893 struct bfd_link_info
*info
,
4894 struct elf_link_hash_entry
*h
,
4895 Elf_Internal_Sym
* sym
)
4897 if (h
->got
.offset
!= (bfd_vma
) - 1)
4901 Elf_Internal_Rela rela
;
4904 /* This symbol has an entry in the global offset table.
4907 sgot
= elf_hash_table (info
)->sgot
;
4908 srela
= elf_hash_table (info
)->srelgot
;
4909 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
4911 rela
.r_offset
= (sgot
->output_section
->vma
4912 + sgot
->output_offset
4913 + (h
->got
.offset
& ~(bfd_vma
) 1));
4915 /* If this is a -Bsymbolic link, and the symbol is defined
4916 locally, we just want to emit a RELATIVE reloc. Likewise if
4917 the symbol was forced to be local because of a version file.
4918 The entry in the global offset table will already have been
4919 initialized in the relocate_section function. */
4920 if (bfd_link_pic (info
)
4922 || h
->dynindx
== -1 || h
->forced_local
) && h
->def_regular
)
4924 _bfd_error_handler (_("*** check this relocation %s"),
4926 rela
.r_info
= ELF32_R_INFO (0, R_BFIN_PCREL24
);
4927 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
4931 offset
& ~(bfd_vma
) 1)));
4935 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
4936 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
4937 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_BFIN_GOT
);
4941 loc
= srela
->contents
;
4942 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
4943 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
4950 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4951 if (strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
4952 || h
== elf_hash_table (info
)->hgot
)
4953 sym
->st_shndx
= SHN_ABS
;
4958 /* Adjust a symbol defined by a dynamic object and referenced by a
4959 regular object. The current definition is in some section of the
4960 dynamic object, but we're not including those sections. We have to
4961 change the definition to something the rest of the link can
4965 bfin_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4966 struct elf_link_hash_entry
*h
)
4970 unsigned int power_of_two
;
4972 dynobj
= elf_hash_table (info
)->dynobj
;
4974 /* Make sure we know what is going on here. */
4975 BFD_ASSERT (dynobj
!= NULL
4978 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
4980 /* If this is a function, put it in the procedure linkage table. We
4981 will fill in the contents of the procedure linkage table later,
4982 when we know the address of the .got section. */
4983 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
4988 /* If this is a weak symbol, and there is a real definition, the
4989 processor independent code will have arranged for us to see the
4990 real definition first, and we can just use the same value. */
4991 if (h
->is_weakalias
)
4993 struct elf_link_hash_entry
*def
= weakdef (h
);
4994 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
4995 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
4996 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
5000 /* This is a reference to a symbol defined by a dynamic object which
5001 is not a function. */
5003 /* If we are creating a shared library, we must presume that the
5004 only references to the symbol are via the global offset table.
5005 For such cases we need not do anything here; the relocations will
5006 be handled correctly by relocate_section. */
5007 if (bfd_link_pic (info
))
5010 /* We must allocate the symbol in our .dynbss section, which will
5011 become part of the .bss section of the executable. There will be
5012 an entry for this symbol in the .dynsym section. The dynamic
5013 object will contain position independent code, so all references
5014 from the dynamic object to this symbol will go through the global
5015 offset table. The dynamic linker will use the .dynsym entry to
5016 determine the address it must put in the global offset table, so
5017 both the dynamic object and the regular object will refer to the
5018 same memory location for the variable. */
5020 s
= bfd_get_linker_section (dynobj
, ".dynbss");
5021 BFD_ASSERT (s
!= NULL
);
5023 #if 0 /* Bfin does not currently have a COPY reloc. */
5024 /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5025 copy the initial value out of the dynamic object and into the
5026 runtime process image. We need to remember the offset into the
5027 .rela.bss section we are going to use. */
5028 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5032 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
5033 BFD_ASSERT (srel
!= NULL
);
5034 srel
->size
+= sizeof (Elf32_External_Rela
);
5038 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5040 _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5044 /* We need to figure out the alignment required for this symbol. I
5045 have no idea how ELF linkers handle this. */
5046 power_of_two
= bfd_log2 (h
->size
);
5047 if (power_of_two
> 3)
5050 /* Apply the required alignment. */
5051 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
5052 if (power_of_two
> bfd_section_alignment (s
))
5054 if (!bfd_set_section_alignment (s
, power_of_two
))
5058 /* Define the symbol as being at this point in the section. */
5059 h
->root
.u
.def
.section
= s
;
5060 h
->root
.u
.def
.value
= s
->size
;
5062 /* Increment the section size to make room for the symbol. */
5068 /* The bfin linker needs to keep track of the number of relocs that it
5069 decides to copy in check_relocs for each symbol. This is so that it
5070 can discard PC relative relocs if it doesn't need them when linking
5071 with -Bsymbolic. We store the information in a field extending the
5072 regular ELF linker hash table. */
5074 /* This structure keeps track of the number of PC relative relocs we have
5075 copied for a given symbol. */
5077 struct bfin_pcrel_relocs_copied
5080 struct bfin_pcrel_relocs_copied
*next
;
5081 /* A section in dynobj. */
5083 /* Number of relocs copied in this section. */
5084 bfd_size_type count
;
5087 /* This function is called via elf_link_hash_traverse if we are
5088 creating a shared object. In the -Bsymbolic case it discards the
5089 space allocated to copy PC relative relocs against symbols which
5090 are defined in regular objects. For the normal shared case, it
5091 discards space for pc-relative relocs that have become local due to
5092 symbol visibility changes. We allocated space for them in the
5093 check_relocs routine, but we won't fill them in in the
5094 relocate_section routine.
5096 We also check whether any of the remaining relocations apply
5097 against a readonly section, and set the DF_TEXTREL flag in this
5101 bfin_discard_copies (struct elf_link_hash_entry
*h
, void * inf
)
5103 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5104 struct bfin_pcrel_relocs_copied
*s
;
5106 if (!h
->def_regular
|| (!info
->symbolic
&& !h
->forced_local
))
5108 if ((info
->flags
& DF_TEXTREL
) == 0)
5110 /* Look for relocations against read-only sections. */
5111 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5112 s
!= NULL
; s
= s
->next
)
5113 if ((s
->section
->flags
& SEC_READONLY
) != 0)
5115 info
->flags
|= DF_TEXTREL
;
5123 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5124 s
!= NULL
; s
= s
->next
)
5125 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
5131 bfin_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5132 struct bfd_link_info
*info
)
5138 dynobj
= elf_hash_table (info
)->dynobj
;
5139 BFD_ASSERT (dynobj
!= NULL
);
5141 if (elf_hash_table (info
)->dynamic_sections_created
)
5143 /* Set the contents of the .interp section to the interpreter. */
5144 if (bfd_link_executable (info
) && !info
->nointerp
)
5146 s
= bfd_get_linker_section (dynobj
, ".interp");
5147 BFD_ASSERT (s
!= NULL
);
5148 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5149 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5154 /* We may have created entries in the .rela.got section.
5155 However, if we are not creating the dynamic sections, we will
5156 not actually use these entries. Reset the size of .rela.got,
5157 which will cause it to get stripped from the output file
5159 s
= elf_hash_table (info
)->srelgot
;
5164 /* If this is a -Bsymbolic shared link, then we need to discard all
5165 PC relative relocs against symbols defined in a regular object.
5166 For the normal shared case we discard the PC relative relocs
5167 against symbols that have become local due to visibility changes.
5168 We allocated space for them in the check_relocs routine, but we
5169 will not fill them in in the relocate_section routine. */
5170 if (bfd_link_pic (info
))
5171 elf_link_hash_traverse (elf_hash_table (info
),
5172 bfin_discard_copies
, info
);
5174 /* The check_relocs and adjust_dynamic_symbol entry points have
5175 determined the sizes of the various dynamic sections. Allocate
5178 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5183 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5186 /* It's OK to base decisions on the section name, because none
5187 of the dynobj section names depend upon the input files. */
5188 name
= bfd_section_name (s
);
5192 if (CONST_STRNEQ (name
, ".rela"))
5196 /* If we don't need this section, strip it from the
5197 output file. This is mostly to handle .rela.bss and
5198 .rela.plt. We must create both sections in
5199 create_dynamic_sections, because they must be created
5200 before the linker maps input sections to output
5201 sections. The linker does that before
5202 adjust_dynamic_symbol is called, and it is that
5203 function which decides whether anything needs to go
5204 into these sections. */
5211 /* We use the reloc_count field as a counter if we need
5212 to copy relocs into the output file. */
5216 else if (! CONST_STRNEQ (name
, ".got"))
5218 /* It's not one of our sections, so don't allocate space. */
5224 s
->flags
|= SEC_EXCLUDE
;
5228 /* Allocate memory for the section contents. */
5229 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5230 Unused entries should be reclaimed before the section's contents
5231 are written out, but at the moment this does not happen. Thus in
5232 order to prevent writing out garbage, we initialise the section's
5233 contents to zero. */
5234 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5235 if (s
->contents
== NULL
&& s
->size
!= 0)
5239 if (elf_hash_table (info
)->dynamic_sections_created
)
5241 /* Add some entries to the .dynamic section. We fill in the
5242 values later, in bfin_finish_dynamic_sections, but we
5243 must add the entries now so that we get the correct size for
5244 the .dynamic section. The DT_DEBUG entry is filled in by the
5245 dynamic linker and used by the debugger. */
5246 #define add_dynamic_entry(TAG, VAL) \
5247 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5249 if (!bfd_link_pic (info
))
5251 if (!add_dynamic_entry (DT_DEBUG
, 0))
5258 if (!add_dynamic_entry (DT_RELA
, 0)
5259 || !add_dynamic_entry (DT_RELASZ
, 0)
5260 || !add_dynamic_entry (DT_RELAENT
,
5261 sizeof (Elf32_External_Rela
)))
5265 if ((info
->flags
& DF_TEXTREL
) != 0)
5267 if (!add_dynamic_entry (DT_TEXTREL
, 0))
5271 #undef add_dynamic_entry
5276 /* Given a .data section and a .emreloc in-memory section, store
5277 relocation information into the .emreloc section which can be
5278 used at runtime to relocate the section. This is called by the
5279 linker when the --embedded-relocs switch is used. This is called
5280 after the add_symbols entry point has been called for all the
5281 objects, and before the final_link entry point is called. */
5284 bfd_bfin_elf32_create_embedded_relocs (bfd
*abfd
,
5285 struct bfd_link_info
*info
,
5290 Elf_Internal_Shdr
*symtab_hdr
;
5291 Elf_Internal_Sym
*isymbuf
= NULL
;
5292 Elf_Internal_Rela
*internal_relocs
= NULL
;
5293 Elf_Internal_Rela
*irel
, *irelend
;
5297 BFD_ASSERT (! bfd_link_relocatable (info
));
5301 if (datasec
->reloc_count
== 0)
5304 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5306 /* Get a copy of the native relocations. */
5307 internal_relocs
= (_bfd_elf_link_read_relocs
5308 (abfd
, datasec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5309 info
->keep_memory
));
5310 if (internal_relocs
== NULL
)
5313 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
5314 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
5315 if (relsec
->contents
== NULL
)
5318 p
= relsec
->contents
;
5320 irelend
= internal_relocs
+ datasec
->reloc_count
;
5321 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
5323 asection
*targetsec
;
5325 /* We are going to write a four byte longword into the runtime
5326 reloc section. The longword will be the address in the data
5327 section which must be relocated. It is followed by the name
5328 of the target section NUL-padded or truncated to 8
5331 /* We can only relocate absolute longword relocs at run time. */
5332 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_BFIN_BYTE4_DATA
)
5334 *errmsg
= _("unsupported relocation type");
5335 bfd_set_error (bfd_error_bad_value
);
5339 /* Get the target section referred to by the reloc. */
5340 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
5342 /* A local symbol. */
5343 Elf_Internal_Sym
*isym
;
5345 /* Read this BFD's local symbols if we haven't done so already. */
5346 if (isymbuf
== NULL
)
5348 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5349 if (isymbuf
== NULL
)
5350 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5351 symtab_hdr
->sh_info
, 0,
5353 if (isymbuf
== NULL
)
5357 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
5358 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5363 struct elf_link_hash_entry
*h
;
5365 /* An external symbol. */
5366 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
5367 h
= elf_sym_hashes (abfd
)[indx
];
5368 BFD_ASSERT (h
!= NULL
);
5369 if (h
->root
.type
== bfd_link_hash_defined
5370 || h
->root
.type
== bfd_link_hash_defweak
)
5371 targetsec
= h
->root
.u
.def
.section
;
5376 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
5377 memset (p
+ 4, 0, 8);
5378 if (targetsec
!= NULL
)
5379 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
5382 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5384 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
5385 free (internal_relocs
);
5389 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5391 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
5392 free (internal_relocs
);
5396 struct bfd_elf_special_section
const elf32_bfin_special_sections
[] =
5398 { ".l1.text", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5399 { ".l1.data", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
5400 { NULL
, 0, 0, 0, 0 }
5404 #define TARGET_LITTLE_SYM bfin_elf32_vec
5405 #define TARGET_LITTLE_NAME "elf32-bfin"
5406 #define ELF_ARCH bfd_arch_bfin
5407 #define ELF_TARGET_ID BFIN_ELF_DATA
5408 #define ELF_MACHINE_CODE EM_BLACKFIN
5409 #define ELF_MAXPAGESIZE 0x1000
5410 #define elf_symbol_leading_char '_'
5412 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5413 #define bfd_elf32_bfd_reloc_name_lookup \
5414 bfin_bfd_reloc_name_lookup
5415 #define elf_info_to_howto bfin_info_to_howto
5416 #define elf_info_to_howto_rel NULL
5417 #define elf_backend_object_p elf32_bfin_object_p
5419 #define bfd_elf32_bfd_is_local_label_name \
5420 bfin_is_local_label_name
5421 #define bfin_hash_table(p) \
5422 ((struct bfin_link_hash_table *) (p)->hash)
5426 #define elf_backend_create_dynamic_sections \
5427 _bfd_elf_create_dynamic_sections
5428 #define bfd_elf32_bfd_link_hash_table_create \
5429 bfin_link_hash_table_create
5430 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5432 #define elf_backend_check_relocs bfin_check_relocs
5433 #define elf_backend_adjust_dynamic_symbol \
5434 bfin_adjust_dynamic_symbol
5435 #define elf_backend_size_dynamic_sections \
5436 bfin_size_dynamic_sections
5437 #define elf_backend_relocate_section bfin_relocate_section
5438 #define elf_backend_finish_dynamic_symbol \
5439 bfin_finish_dynamic_symbol
5440 #define elf_backend_finish_dynamic_sections \
5441 bfin_finish_dynamic_sections
5442 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5443 #define bfd_elf32_bfd_merge_private_bfd_data \
5444 elf32_bfin_merge_private_bfd_data
5445 #define bfd_elf32_bfd_set_private_flags \
5446 elf32_bfin_set_private_flags
5447 #define bfd_elf32_bfd_print_private_bfd_data \
5448 elf32_bfin_print_private_bfd_data
5449 #define elf_backend_final_write_processing \
5450 elf32_bfin_final_write_processing
5451 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5452 #define elf_backend_stack_align 8
5453 #define elf_backend_can_gc_sections 1
5454 #define elf_backend_special_sections elf32_bfin_special_sections
5455 #define elf_backend_can_refcount 1
5456 #define elf_backend_want_got_plt 0
5457 #define elf_backend_plt_readonly 1
5458 #define elf_backend_want_plt_sym 0
5459 #define elf_backend_got_header_size 12
5460 #define elf_backend_rela_normal 1
5462 #include "elf32-target.h"
5464 #undef TARGET_LITTLE_SYM
5465 #define TARGET_LITTLE_SYM bfin_elf32_fdpic_vec
5466 #undef TARGET_LITTLE_NAME
5467 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5469 #define elf32_bed elf32_bfinfdpic_bed
5471 #undef elf_backend_got_header_size
5472 #define elf_backend_got_header_size 0
5474 #undef elf_backend_relocate_section
5475 #define elf_backend_relocate_section bfinfdpic_relocate_section
5476 #undef elf_backend_check_relocs
5477 #define elf_backend_check_relocs bfinfdpic_check_relocs
5479 #undef bfd_elf32_bfd_link_hash_table_create
5480 #define bfd_elf32_bfd_link_hash_table_create \
5481 bfinfdpic_elf_link_hash_table_create
5482 #undef elf_backend_always_size_sections
5483 #define elf_backend_always_size_sections \
5484 elf32_bfinfdpic_always_size_sections
5486 #undef elf_backend_create_dynamic_sections
5487 #define elf_backend_create_dynamic_sections \
5488 elf32_bfinfdpic_create_dynamic_sections
5489 #undef elf_backend_adjust_dynamic_symbol
5490 #define elf_backend_adjust_dynamic_symbol \
5491 elf32_bfinfdpic_adjust_dynamic_symbol
5492 #undef elf_backend_size_dynamic_sections
5493 #define elf_backend_size_dynamic_sections \
5494 elf32_bfinfdpic_size_dynamic_sections
5495 #undef elf_backend_finish_dynamic_symbol
5496 #define elf_backend_finish_dynamic_symbol \
5497 elf32_bfinfdpic_finish_dynamic_symbol
5498 #undef elf_backend_finish_dynamic_sections
5499 #define elf_backend_finish_dynamic_sections \
5500 elf32_bfinfdpic_finish_dynamic_sections
5502 #undef elf_backend_discard_info
5503 #define elf_backend_discard_info \
5504 bfinfdpic_elf_discard_info
5505 #undef elf_backend_can_make_relative_eh_frame
5506 #define elf_backend_can_make_relative_eh_frame \
5507 bfinfdpic_elf_use_relative_eh_frame
5508 #undef elf_backend_can_make_lsda_relative_eh_frame
5509 #define elf_backend_can_make_lsda_relative_eh_frame \
5510 bfinfdpic_elf_use_relative_eh_frame
5511 #undef elf_backend_encode_eh_address
5512 #define elf_backend_encode_eh_address \
5513 bfinfdpic_elf_encode_eh_address
5515 #undef elf_backend_may_use_rel_p
5516 #define elf_backend_may_use_rel_p 1
5517 #undef elf_backend_may_use_rela_p
5518 #define elf_backend_may_use_rela_p 1
5519 /* We use REL for dynamic relocations only. */
5520 #undef elf_backend_default_use_rela_p
5521 #define elf_backend_default_use_rela_p 1
5523 #undef elf_backend_omit_section_dynsym
5524 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5526 #include "elf32-target.h"