1 /* ADI Blackfin BFD support for 32-bit ELF.
2 Copyright (C) 2005-2016 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. */
29 /* FUNCTION : bfin_pltpc_reloc
30 ABSTRACT : TODO : figure out how to handle pltpc relocs. */
31 static bfd_reloc_status_type
33 bfd
*abfd ATTRIBUTE_UNUSED
,
34 arelent
*reloc_entry ATTRIBUTE_UNUSED
,
35 asymbol
*symbol ATTRIBUTE_UNUSED
,
36 void * data ATTRIBUTE_UNUSED
,
37 asection
*input_section ATTRIBUTE_UNUSED
,
38 bfd
*output_bfd ATTRIBUTE_UNUSED
,
39 char **error_message ATTRIBUTE_UNUSED
)
41 bfd_reloc_status_type flag
= bfd_reloc_ok
;
46 static bfd_reloc_status_type
47 bfin_pcrel24_reloc (bfd
*abfd
,
51 asection
*input_section
,
53 char **error_message ATTRIBUTE_UNUSED
)
56 bfd_size_type addr
= reloc_entry
->address
;
57 bfd_vma output_base
= 0;
58 reloc_howto_type
*howto
= reloc_entry
->howto
;
59 asection
*output_section
;
60 bfd_boolean relocatable
= (output_bfd
!= NULL
);
62 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
63 return bfd_reloc_outofrange
;
65 if (bfd_is_und_section (symbol
->section
)
66 && (symbol
->flags
& BSF_WEAK
) == 0
68 return bfd_reloc_undefined
;
70 if (bfd_is_com_section (symbol
->section
))
73 relocation
= symbol
->value
;
75 output_section
= symbol
->section
->output_section
;
80 output_base
= output_section
->vma
;
82 if (!relocatable
|| !strcmp (symbol
->name
, symbol
->section
->name
))
83 relocation
+= output_base
+ symbol
->section
->output_offset
;
85 if (!relocatable
&& !strcmp (symbol
->name
, symbol
->section
->name
))
86 relocation
+= reloc_entry
->addend
;
88 relocation
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
89 relocation
-= reloc_entry
->address
;
91 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
93 bfd_reloc_status_type status
;
94 status
= bfd_check_overflow (howto
->complain_on_overflow
,
97 bfd_arch_bits_per_address(abfd
),
99 if (status
!= bfd_reloc_ok
)
103 /* if rightshift is 1 and the number odd, return error. */
104 if (howto
->rightshift
&& (relocation
& 0x01))
106 _bfd_error_handler (_("relocation should be even number"));
107 return bfd_reloc_overflow
;
110 relocation
>>= (bfd_vma
) howto
->rightshift
;
111 /* Shift everything up to where it's going to be used. */
113 relocation
<<= (bfd_vma
) howto
->bitpos
;
117 reloc_entry
->address
+= input_section
->output_offset
;
118 reloc_entry
->addend
+= symbol
->section
->output_offset
;
124 /* We are getting reloc_entry->address 2 byte off from
125 the start of instruction. Assuming absolute postion
126 of the reloc data. But, following code had been written assuming
127 reloc address is starting at begining of instruction.
128 To compensate that I have increased the value of
129 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
132 x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
- 2);
133 x
= (x
& 0xff00) | ((relocation
>> 16) & 0xff);
134 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
- 2);
136 x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
);
137 x
= relocation
& 0xFFFF;
138 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
);
143 static bfd_reloc_status_type
144 bfin_imm16_reloc (bfd
*abfd
,
145 arelent
*reloc_entry
,
148 asection
*input_section
,
150 char **error_message ATTRIBUTE_UNUSED
)
152 bfd_vma relocation
, x
;
153 bfd_size_type reloc_addr
= reloc_entry
->address
;
154 bfd_vma output_base
= 0;
155 reloc_howto_type
*howto
= reloc_entry
->howto
;
156 asection
*output_section
;
157 bfd_boolean relocatable
= (output_bfd
!= NULL
);
159 /* Is the address of the relocation really within the section? */
160 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
161 return bfd_reloc_outofrange
;
163 if (bfd_is_und_section (symbol
->section
)
164 && (symbol
->flags
& BSF_WEAK
) == 0
166 return bfd_reloc_undefined
;
168 output_section
= symbol
->section
->output_section
;
169 relocation
= symbol
->value
;
171 /* Convert input-section-relative symbol value to absolute. */
175 output_base
= output_section
->vma
;
177 if (!relocatable
|| !strcmp (symbol
->name
, symbol
->section
->name
))
178 relocation
+= output_base
+ symbol
->section
->output_offset
;
180 /* Add in supplied addend. */
181 relocation
+= reloc_entry
->addend
;
185 reloc_entry
->address
+= input_section
->output_offset
;
186 reloc_entry
->addend
+= symbol
->section
->output_offset
;
190 reloc_entry
->addend
= 0;
193 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
195 bfd_reloc_status_type flag
;
196 flag
= bfd_check_overflow (howto
->complain_on_overflow
,
199 bfd_arch_bits_per_address(abfd
),
201 if (flag
!= bfd_reloc_ok
)
205 /* Here the variable relocation holds the final address of the
206 symbol we are relocating against, plus any addend. */
208 relocation
>>= (bfd_vma
) howto
->rightshift
;
210 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ reloc_addr
);
215 static bfd_reloc_status_type
216 bfin_byte4_reloc (bfd
*abfd
,
217 arelent
*reloc_entry
,
220 asection
*input_section
,
222 char **error_message ATTRIBUTE_UNUSED
)
224 bfd_vma relocation
, x
;
225 bfd_size_type addr
= reloc_entry
->address
;
226 bfd_vma output_base
= 0;
227 asection
*output_section
;
228 bfd_boolean relocatable
= (output_bfd
!= NULL
);
230 /* Is the address of the relocation really within the section? */
231 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
232 return bfd_reloc_outofrange
;
234 if (bfd_is_und_section (symbol
->section
)
235 && (symbol
->flags
& BSF_WEAK
) == 0
237 return bfd_reloc_undefined
;
239 output_section
= symbol
->section
->output_section
;
240 relocation
= symbol
->value
;
241 /* Convert input-section-relative symbol value to absolute. */
245 output_base
= output_section
->vma
;
248 && symbol
->section
->name
249 && !strcmp (symbol
->name
, symbol
->section
->name
))
252 relocation
+= output_base
+ symbol
->section
->output_offset
;
255 relocation
+= reloc_entry
->addend
;
259 /* This output will be relocatable ... like ld -r. */
260 reloc_entry
->address
+= input_section
->output_offset
;
261 reloc_entry
->addend
+= symbol
->section
->output_offset
;
265 reloc_entry
->addend
= 0;
268 /* Here the variable relocation holds the final address of the
269 symbol we are relocating against, plus any addend. */
270 x
= relocation
& 0xFFFF0000;
272 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
+ 2);
274 x
= relocation
& 0x0000FFFF;
275 bfd_put_16 (abfd
, x
, (unsigned char *) data
+ addr
);
279 /* bfin_bfd_reloc handles the blackfin arithmetic relocations.
280 Use this instead of bfd_perform_relocation. */
281 static bfd_reloc_status_type
282 bfin_bfd_reloc (bfd
*abfd
,
283 arelent
*reloc_entry
,
286 asection
*input_section
,
288 char **error_message ATTRIBUTE_UNUSED
)
291 bfd_size_type addr
= reloc_entry
->address
;
292 bfd_vma output_base
= 0;
293 reloc_howto_type
*howto
= reloc_entry
->howto
;
294 asection
*output_section
;
295 bfd_boolean relocatable
= (output_bfd
!= NULL
);
297 /* Is the address of the relocation really within the section? */
298 if (reloc_entry
->address
> bfd_get_section_limit (abfd
, input_section
))
299 return bfd_reloc_outofrange
;
301 if (bfd_is_und_section (symbol
->section
)
302 && (symbol
->flags
& BSF_WEAK
) == 0
304 return bfd_reloc_undefined
;
306 /* Get symbol value. (Common symbols are special.) */
307 if (bfd_is_com_section (symbol
->section
))
310 relocation
= symbol
->value
;
312 output_section
= symbol
->section
->output_section
;
314 /* Convert input-section-relative symbol value to absolute. */
318 output_base
= output_section
->vma
;
320 if (!relocatable
|| !strcmp (symbol
->name
, symbol
->section
->name
))
321 relocation
+= output_base
+ symbol
->section
->output_offset
;
323 if (!relocatable
&& !strcmp (symbol
->name
, symbol
->section
->name
))
325 /* Add in supplied addend. */
326 relocation
+= reloc_entry
->addend
;
329 /* Here the variable relocation holds the final address of the
330 symbol we are relocating against, plus any addend. */
332 if (howto
->pc_relative
== TRUE
)
334 relocation
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
336 if (howto
->pcrel_offset
== TRUE
)
337 relocation
-= reloc_entry
->address
;
342 reloc_entry
->address
+= input_section
->output_offset
;
343 reloc_entry
->addend
+= symbol
->section
->output_offset
;
346 if (howto
->complain_on_overflow
!= complain_overflow_dont
)
348 bfd_reloc_status_type status
;
350 status
= bfd_check_overflow (howto
->complain_on_overflow
,
353 bfd_arch_bits_per_address(abfd
),
355 if (status
!= bfd_reloc_ok
)
359 /* If rightshift is 1 and the number odd, return error. */
360 if (howto
->rightshift
&& (relocation
& 0x01))
362 _bfd_error_handler (_("relocation should be even number"));
363 return bfd_reloc_overflow
;
366 relocation
>>= (bfd_vma
) howto
->rightshift
;
368 /* Shift everything up to where it's going to be used. */
370 relocation
<<= (bfd_vma
) howto
->bitpos
;
373 x = ( (x & ~howto->dst_mask) | (relocation & howto->dst_mask))
375 /* handle 8 and 16 bit relocations here. */
380 char x
= bfd_get_8 (abfd
, (char *) data
+ addr
);
382 bfd_put_8 (abfd
, x
, (unsigned char *) data
+ addr
);
388 unsigned short x
= bfd_get_16 (abfd
, (bfd_byte
*) data
+ addr
);
390 bfd_put_16 (abfd
, (bfd_vma
) x
, (unsigned char *) data
+ addr
);
395 return bfd_reloc_other
;
401 /* HOWTO Table for blackfin.
402 Blackfin relocations are fairly complicated.
403 Some of the salient features are
404 a. Even numbered offsets. A number of (not all) relocations are
405 even numbered. This means that the rightmost bit is not stored.
406 Needs to right shift by 1 and check to see if value is not odd
407 b. A relocation can be an expression. An expression takes on
408 a variety of relocations arranged in a stack.
409 As a result, we cannot use the standard generic function as special
410 function. We will have our own, which is very similar to the standard
411 generic function except that it understands how to get the value from
412 the relocation stack. . */
414 #define BFIN_RELOC_MIN 0
415 #define BFIN_RELOC_MAX 0x21
416 #define BFIN_GNUEXT_RELOC_MIN 0x40
417 #define BFIN_GNUEXT_RELOC_MAX 0x43
418 #define BFIN_ARELOC_MIN 0xE0
419 #define BFIN_ARELOC_MAX 0xF3
421 static reloc_howto_type bfin_howto_table
[] =
423 /* This reloc does nothing. . */
424 HOWTO (R_BFIN_UNUSED0
, /* type. */
426 3, /* size (0 = byte, 1 = short, 2 = long). */
428 FALSE
, /* pc_relative. */
430 complain_overflow_dont
, /* complain_on_overflow. */
431 bfd_elf_generic_reloc
, /* special_function. */
432 "R_BFIN_UNUSED0", /* name. */
433 FALSE
, /* partial_inplace. */
436 FALSE
), /* pcrel_offset. */
438 HOWTO (R_BFIN_PCREL5M2
, /* type. */
440 1, /* size (0 = byte, 1 = short, 2 = long).. */
442 TRUE
, /* pc_relative. */
444 complain_overflow_unsigned
, /* complain_on_overflow. */
445 bfin_bfd_reloc
, /* special_function. */
446 "R_BFIN_PCREL5M2", /* name. */
447 FALSE
, /* partial_inplace. */
449 0x0000000F, /* dst_mask. */
450 FALSE
), /* pcrel_offset. */
452 HOWTO (R_BFIN_UNUSED1
, /* type. */
454 3, /* size (0 = byte, 1 = short, 2 = long). */
456 FALSE
, /* pc_relative. */
458 complain_overflow_dont
, /* complain_on_overflow. */
459 bfd_elf_generic_reloc
, /* special_function. */
460 "R_BFIN_UNUSED1", /* name. */
461 FALSE
, /* partial_inplace. */
464 FALSE
), /* pcrel_offset. */
466 HOWTO (R_BFIN_PCREL10
, /* type. */
468 1, /* size (0 = byte, 1 = short, 2 = long). */
470 TRUE
, /* pc_relative. */
472 complain_overflow_signed
, /* complain_on_overflow. */
473 bfin_bfd_reloc
, /* special_function. */
474 "R_BFIN_PCREL10", /* name. */
475 FALSE
, /* partial_inplace. */
477 0x000003FF, /* dst_mask. */
478 TRUE
), /* pcrel_offset. */
480 HOWTO (R_BFIN_PCREL12_JUMP
, /* type. */
482 /* the offset is actually 13 bit
483 aligned on a word boundary so
484 only 12 bits have to be used.
485 Right shift the rightmost bit.. */
486 1, /* size (0 = byte, 1 = short, 2 = long). */
488 TRUE
, /* pc_relative. */
490 complain_overflow_signed
, /* complain_on_overflow. */
491 bfin_bfd_reloc
, /* special_function. */
492 "R_BFIN_PCREL12_JUMP", /* name. */
493 FALSE
, /* partial_inplace. */
495 0x0FFF, /* dst_mask. */
496 TRUE
), /* pcrel_offset. */
498 HOWTO (R_BFIN_RIMM16
, /* type. */
500 1, /* size (0 = byte, 1 = short, 2 = long). */
502 FALSE
, /* pc_relative. */
504 complain_overflow_signed
, /* complain_on_overflow. */
505 bfin_imm16_reloc
, /* special_function. */
506 "R_BFIN_RIMM16", /* name. */
507 FALSE
, /* partial_inplace. */
509 0x0000FFFF, /* dst_mask. */
510 TRUE
), /* pcrel_offset. */
512 HOWTO (R_BFIN_LUIMM16
, /* type. */
514 1, /* size (0 = byte, 1 = short, 2 = long). */
516 FALSE
, /* pc_relative. */
518 complain_overflow_dont
, /* complain_on_overflow. */
519 bfin_imm16_reloc
, /* special_function. */
520 "R_BFIN_LUIMM16", /* name. */
521 FALSE
, /* partial_inplace. */
523 0x0000FFFF, /* dst_mask. */
524 TRUE
), /* pcrel_offset. */
526 HOWTO (R_BFIN_HUIMM16
, /* type. */
527 16, /* rightshift. */
528 1, /* size (0 = byte, 1 = short, 2 = long). */
530 FALSE
, /* pc_relative. */
532 complain_overflow_unsigned
, /* complain_on_overflow. */
533 bfin_imm16_reloc
, /* special_function. */
534 "R_BFIN_HUIMM16", /* name. */
535 FALSE
, /* partial_inplace. */
537 0x0000FFFF, /* dst_mask. */
538 TRUE
), /* pcrel_offset. */
540 HOWTO (R_BFIN_PCREL12_JUMP_S
, /* type. */
542 1, /* size (0 = byte, 1 = short, 2 = long). */
544 TRUE
, /* pc_relative. */
546 complain_overflow_signed
, /* complain_on_overflow. */
547 bfin_bfd_reloc
, /* special_function. */
548 "R_BFIN_PCREL12_JUMP_S", /* name. */
549 FALSE
, /* partial_inplace. */
551 0x00000FFF, /* dst_mask. */
552 TRUE
), /* pcrel_offset. */
554 HOWTO (R_BFIN_PCREL24_JUMP_X
, /* type. */
556 2, /* size (0 = byte, 1 = short, 2 = long). */
558 TRUE
, /* pc_relative. */
560 complain_overflow_signed
, /* complain_on_overflow. */
561 bfin_pcrel24_reloc
, /* special_function. */
562 "R_BFIN_PCREL24_JUMP_X", /* name. */
563 FALSE
, /* partial_inplace. */
565 0x00FFFFFF, /* dst_mask. */
566 TRUE
), /* pcrel_offset. */
568 HOWTO (R_BFIN_PCREL24
, /* type. */
570 2, /* size (0 = byte, 1 = short, 2 = long). */
572 TRUE
, /* pc_relative. */
574 complain_overflow_signed
, /* complain_on_overflow. */
575 bfin_pcrel24_reloc
, /* special_function. */
576 "R_BFIN_PCREL24", /* name. */
577 FALSE
, /* partial_inplace. */
579 0x00FFFFFF, /* dst_mask. */
580 TRUE
), /* pcrel_offset. */
582 HOWTO (R_BFIN_UNUSEDB
, /* type. */
584 3, /* size (0 = byte, 1 = short, 2 = long). */
586 FALSE
, /* pc_relative. */
588 complain_overflow_dont
, /* complain_on_overflow. */
589 bfd_elf_generic_reloc
, /* special_function. */
590 "R_BFIN_UNUSEDB", /* name. */
591 FALSE
, /* partial_inplace. */
594 FALSE
), /* pcrel_offset. */
596 HOWTO (R_BFIN_UNUSEDC
, /* type. */
598 3, /* size (0 = byte, 1 = short, 2 = long). */
600 FALSE
, /* pc_relative. */
602 complain_overflow_dont
, /* complain_on_overflow. */
603 bfd_elf_generic_reloc
, /* special_function. */
604 "R_BFIN_UNUSEDC", /* name. */
605 FALSE
, /* partial_inplace. */
608 FALSE
), /* pcrel_offset. */
610 HOWTO (R_BFIN_PCREL24_JUMP_L
, /* type. */
612 2, /* size (0 = byte, 1 = short, 2 = long). */
614 TRUE
, /* pc_relative. */
616 complain_overflow_signed
, /* complain_on_overflow. */
617 bfin_pcrel24_reloc
, /* special_function. */
618 "R_BFIN_PCREL24_JUMP_L", /* name. */
619 FALSE
, /* partial_inplace. */
621 0x00FFFFFF, /* dst_mask. */
622 TRUE
), /* pcrel_offset. */
624 HOWTO (R_BFIN_PCREL24_CALL_X
, /* type. */
626 2, /* size (0 = byte, 1 = short, 2 = long). */
628 TRUE
, /* pc_relative. */
630 complain_overflow_signed
, /* complain_on_overflow. */
631 bfin_pcrel24_reloc
, /* special_function. */
632 "R_BFIN_PCREL24_CALL_X", /* name. */
633 FALSE
, /* partial_inplace. */
635 0x00FFFFFF, /* dst_mask. */
636 TRUE
), /* pcrel_offset. */
638 HOWTO (R_BFIN_VAR_EQ_SYMB
, /* type. */
640 2, /* size (0 = byte, 1 = short, 2 = long). */
642 FALSE
, /* pc_relative. */
644 complain_overflow_bitfield
, /* complain_on_overflow. */
645 bfin_bfd_reloc
, /* special_function. */
646 "R_BFIN_VAR_EQ_SYMB", /* name. */
647 FALSE
, /* partial_inplace. */
650 FALSE
), /* pcrel_offset. */
652 HOWTO (R_BFIN_BYTE_DATA
, /* type. */
654 0, /* size (0 = byte, 1 = short, 2 = long). */
656 FALSE
, /* pc_relative. */
658 complain_overflow_unsigned
, /* complain_on_overflow. */
659 bfin_bfd_reloc
, /* special_function. */
660 "R_BFIN_BYTE_DATA", /* name. */
661 FALSE
, /* partial_inplace. */
663 0xFF, /* dst_mask. */
664 TRUE
), /* pcrel_offset. */
666 HOWTO (R_BFIN_BYTE2_DATA
, /* type. */
668 1, /* size (0 = byte, 1 = short, 2 = long). */
670 FALSE
, /* pc_relative. */
672 complain_overflow_signed
, /* complain_on_overflow. */
673 bfin_bfd_reloc
, /* special_function. */
674 "R_BFIN_BYTE2_DATA", /* name. */
675 FALSE
, /* partial_inplace. */
677 0xFFFF, /* dst_mask. */
678 TRUE
), /* pcrel_offset. */
680 HOWTO (R_BFIN_BYTE4_DATA
, /* type. */
682 2, /* size (0 = byte, 1 = short, 2 = long). */
684 FALSE
, /* pc_relative. */
686 complain_overflow_unsigned
, /* complain_on_overflow. */
687 bfin_byte4_reloc
, /* special_function. */
688 "R_BFIN_BYTE4_DATA", /* name. */
689 FALSE
, /* partial_inplace. */
691 0xFFFFFFFF, /* dst_mask. */
692 TRUE
), /* pcrel_offset. */
694 HOWTO (R_BFIN_PCREL11
, /* type. */
696 1, /* size (0 = byte, 1 = short, 2 = long). */
698 TRUE
, /* pc_relative. */
700 complain_overflow_unsigned
, /* complain_on_overflow. */
701 bfin_bfd_reloc
, /* special_function. */
702 "R_BFIN_PCREL11", /* name. */
703 FALSE
, /* partial_inplace. */
705 0x000003FF, /* dst_mask. */
706 FALSE
), /* pcrel_offset. */
709 /* A 18-bit signed operand with the GOT offset for the address of
711 HOWTO (R_BFIN_GOT17M4
, /* type */
713 1, /* size (0 = byte, 1 = short, 2 = long) */
715 FALSE
, /* pc_relative */
717 complain_overflow_signed
, /* complain_on_overflow */
718 bfd_elf_generic_reloc
, /* special_function */
719 "R_BFIN_GOT17M4", /* name */
720 FALSE
, /* partial_inplace */
721 0xffff, /* src_mask */
722 0xffff, /* dst_mask */
723 FALSE
), /* pcrel_offset */
725 /* The upper 16 bits of the GOT offset for the address of the
727 HOWTO (R_BFIN_GOTHI
, /* type */
729 1, /* size (0 = byte, 1 = short, 2 = long) */
731 FALSE
, /* pc_relative */
733 complain_overflow_dont
, /* complain_on_overflow */
734 bfd_elf_generic_reloc
, /* special_function */
735 "R_BFIN_GOTHI", /* name */
736 FALSE
, /* partial_inplace */
737 0xffff, /* src_mask */
738 0xffff, /* dst_mask */
739 FALSE
), /* pcrel_offset */
741 /* The lower 16 bits of the GOT offset for the address of the
743 HOWTO (R_BFIN_GOTLO
, /* type */
745 1, /* size (0 = byte, 1 = short, 2 = long) */
747 FALSE
, /* pc_relative */
749 complain_overflow_dont
, /* complain_on_overflow */
750 bfd_elf_generic_reloc
, /* special_function */
751 "R_BFIN_GOTLO", /* name */
752 FALSE
, /* partial_inplace */
753 0xffff, /* src_mask */
754 0xffff, /* dst_mask */
755 FALSE
), /* pcrel_offset */
757 /* The 32-bit address of the canonical descriptor of a function. */
758 HOWTO (R_BFIN_FUNCDESC
, /* type */
760 2, /* size (0 = byte, 1 = short, 2 = long) */
762 FALSE
, /* pc_relative */
764 complain_overflow_bitfield
, /* complain_on_overflow */
765 bfd_elf_generic_reloc
, /* special_function */
766 "R_BFIN_FUNCDESC", /* name */
767 FALSE
, /* partial_inplace */
768 0xffffffff, /* src_mask */
769 0xffffffff, /* dst_mask */
770 FALSE
), /* pcrel_offset */
772 /* A 12-bit signed operand with the GOT offset for the address of
773 canonical descriptor of a function. */
774 HOWTO (R_BFIN_FUNCDESC_GOT17M4
, /* type */
776 1, /* size (0 = byte, 1 = short, 2 = long) */
778 FALSE
, /* pc_relative */
780 complain_overflow_signed
, /* complain_on_overflow */
781 bfd_elf_generic_reloc
, /* special_function */
782 "R_BFIN_FUNCDESC_GOT17M4", /* name */
783 FALSE
, /* partial_inplace */
784 0xffff, /* src_mask */
785 0xffff, /* dst_mask */
786 FALSE
), /* pcrel_offset */
788 /* The upper 16 bits of the GOT offset for the address of the
789 canonical descriptor of a function. */
790 HOWTO (R_BFIN_FUNCDESC_GOTHI
, /* type */
792 1, /* size (0 = byte, 1 = short, 2 = long) */
794 FALSE
, /* pc_relative */
796 complain_overflow_dont
, /* complain_on_overflow */
797 bfd_elf_generic_reloc
, /* special_function */
798 "R_BFIN_FUNCDESC_GOTHI", /* name */
799 FALSE
, /* partial_inplace */
800 0xffff, /* src_mask */
801 0xffff, /* dst_mask */
802 FALSE
), /* pcrel_offset */
804 /* The lower 16 bits of the GOT offset for the address of the
805 canonical descriptor of a function. */
806 HOWTO (R_BFIN_FUNCDESC_GOTLO
, /* type */
808 1, /* size (0 = byte, 1 = short, 2 = long) */
810 FALSE
, /* pc_relative */
812 complain_overflow_dont
, /* complain_on_overflow */
813 bfd_elf_generic_reloc
, /* special_function */
814 "R_BFIN_FUNCDESC_GOTLO", /* name */
815 FALSE
, /* partial_inplace */
816 0xffff, /* src_mask */
817 0xffff, /* dst_mask */
818 FALSE
), /* pcrel_offset */
820 /* The 32-bit address of the canonical descriptor of a function. */
821 HOWTO (R_BFIN_FUNCDESC_VALUE
, /* type */
823 2, /* size (0 = byte, 1 = short, 2 = long) */
825 FALSE
, /* pc_relative */
827 complain_overflow_bitfield
, /* complain_on_overflow */
828 bfd_elf_generic_reloc
, /* special_function */
829 "R_BFIN_FUNCDESC_VALUE", /* name */
830 FALSE
, /* partial_inplace */
831 0xffffffff, /* src_mask */
832 0xffffffff, /* dst_mask */
833 FALSE
), /* pcrel_offset */
835 /* A 12-bit signed operand with the GOT offset for the address of
836 canonical descriptor of a function. */
837 HOWTO (R_BFIN_FUNCDESC_GOTOFF17M4
, /* type */
839 1, /* size (0 = byte, 1 = short, 2 = long) */
841 FALSE
, /* pc_relative */
843 complain_overflow_signed
, /* complain_on_overflow */
844 bfd_elf_generic_reloc
, /* special_function */
845 "R_BFIN_FUNCDESC_GOTOFF17M4", /* name */
846 FALSE
, /* partial_inplace */
847 0xffff, /* src_mask */
848 0xffff, /* dst_mask */
849 FALSE
), /* pcrel_offset */
851 /* The upper 16 bits of the GOT offset for the address of the
852 canonical descriptor of a function. */
853 HOWTO (R_BFIN_FUNCDESC_GOTOFFHI
, /* type */
855 1, /* size (0 = byte, 1 = short, 2 = long) */
857 FALSE
, /* pc_relative */
859 complain_overflow_dont
, /* complain_on_overflow */
860 bfd_elf_generic_reloc
, /* special_function */
861 "R_BFIN_FUNCDESC_GOTOFFHI", /* name */
862 FALSE
, /* partial_inplace */
863 0xffff, /* src_mask */
864 0xffff, /* dst_mask */
865 FALSE
), /* pcrel_offset */
867 /* The lower 16 bits of the GOT offset for the address of the
868 canonical descriptor of a function. */
869 HOWTO (R_BFIN_FUNCDESC_GOTOFFLO
, /* type */
871 1, /* size (0 = byte, 1 = short, 2 = long) */
873 FALSE
, /* pc_relative */
875 complain_overflow_dont
, /* complain_on_overflow */
876 bfd_elf_generic_reloc
, /* special_function */
877 "R_BFIN_FUNCDESC_GOTOFFLO", /* name */
878 FALSE
, /* partial_inplace */
879 0xffff, /* src_mask */
880 0xffff, /* dst_mask */
881 FALSE
), /* pcrel_offset */
883 /* A 12-bit signed operand with the GOT offset for the address of
885 HOWTO (R_BFIN_GOTOFF17M4
, /* type */
887 1, /* size (0 = byte, 1 = short, 2 = long) */
889 FALSE
, /* pc_relative */
891 complain_overflow_signed
, /* complain_on_overflow */
892 bfd_elf_generic_reloc
, /* special_function */
893 "R_BFIN_GOTOFF17M4", /* name */
894 FALSE
, /* partial_inplace */
895 0xffff, /* src_mask */
896 0xffff, /* dst_mask */
897 FALSE
), /* pcrel_offset */
899 /* The upper 16 bits of the GOT offset for the address of the
901 HOWTO (R_BFIN_GOTOFFHI
, /* type */
903 1, /* size (0 = byte, 1 = short, 2 = long) */
905 FALSE
, /* pc_relative */
907 complain_overflow_dont
, /* complain_on_overflow */
908 bfd_elf_generic_reloc
, /* special_function */
909 "R_BFIN_GOTOFFHI", /* name */
910 FALSE
, /* partial_inplace */
911 0xffff, /* src_mask */
912 0xffff, /* dst_mask */
913 FALSE
), /* pcrel_offset */
915 /* The lower 16 bits of the GOT offset for the address of the
917 HOWTO (R_BFIN_GOTOFFLO
, /* type */
919 1, /* size (0 = byte, 1 = short, 2 = long) */
921 FALSE
, /* pc_relative */
923 complain_overflow_dont
, /* complain_on_overflow */
924 bfd_elf_generic_reloc
, /* special_function */
925 "R_BFIN_GOTOFFLO", /* name */
926 FALSE
, /* partial_inplace */
927 0xffff, /* src_mask */
928 0xffff, /* dst_mask */
929 FALSE
), /* pcrel_offset */
932 static reloc_howto_type bfin_gnuext_howto_table
[] =
934 HOWTO (R_BFIN_PLTPC
, /* type. */
936 1, /* size (0 = byte, 1 = short, 2 = long). */
938 FALSE
, /* pc_relative. */
940 complain_overflow_bitfield
, /* complain_on_overflow. */
941 bfin_pltpc_reloc
, /* special_function. */
942 "R_BFIN_PLTPC", /* name. */
943 FALSE
, /* partial_inplace. */
944 0xffff, /* src_mask. */
945 0xffff, /* dst_mask. */
946 FALSE
), /* pcrel_offset. */
948 HOWTO (R_BFIN_GOT
, /* type. */
950 1, /* size (0 = byte, 1 = short, 2 = long). */
952 FALSE
, /* pc_relative. */
954 complain_overflow_bitfield
, /* complain_on_overflow. */
955 bfd_elf_generic_reloc
, /* special_function. */
956 "R_BFIN_GOT", /* name. */
957 FALSE
, /* partial_inplace. */
958 0x7fff, /* src_mask. */
959 0x7fff, /* dst_mask. */
960 FALSE
), /* pcrel_offset. */
962 /* GNU extension to record C++ vtable hierarchy. */
963 HOWTO (R_BFIN_GNU_VTINHERIT
, /* type. */
965 2, /* size (0 = byte, 1 = short, 2 = long). */
967 FALSE
, /* pc_relative. */
969 complain_overflow_dont
, /* complain_on_overflow. */
970 NULL
, /* special_function. */
971 "R_BFIN_GNU_VTINHERIT", /* name. */
972 FALSE
, /* partial_inplace. */
975 FALSE
), /* pcrel_offset. */
977 /* GNU extension to record C++ vtable member usage. */
978 HOWTO (R_BFIN_GNU_VTENTRY
, /* type. */
980 2, /* size (0 = byte, 1 = short, 2 = long). */
982 FALSE
, /* pc_relative. */
984 complain_overflow_dont
, /* complain_on_overflow. */
985 _bfd_elf_rel_vtable_reloc_fn
, /* special_function. */
986 "R_BFIN_GNU_VTENTRY", /* name. */
987 FALSE
, /* partial_inplace. */
990 FALSE
) /* pcrel_offset. */
993 struct bfin_reloc_map
995 bfd_reloc_code_real_type bfd_reloc_val
;
996 unsigned int bfin_reloc_val
;
999 static const struct bfin_reloc_map bfin_reloc_map
[] =
1001 { BFD_RELOC_NONE
, R_BFIN_UNUSED0
},
1002 { BFD_RELOC_BFIN_5_PCREL
, R_BFIN_PCREL5M2
},
1003 { BFD_RELOC_NONE
, R_BFIN_UNUSED1
},
1004 { BFD_RELOC_BFIN_10_PCREL
, R_BFIN_PCREL10
},
1005 { BFD_RELOC_BFIN_12_PCREL_JUMP
, R_BFIN_PCREL12_JUMP
},
1006 { BFD_RELOC_BFIN_16_IMM
, R_BFIN_RIMM16
},
1007 { BFD_RELOC_BFIN_16_LOW
, R_BFIN_LUIMM16
},
1008 { BFD_RELOC_BFIN_16_HIGH
, R_BFIN_HUIMM16
},
1009 { BFD_RELOC_BFIN_12_PCREL_JUMP_S
, R_BFIN_PCREL12_JUMP_S
},
1010 { BFD_RELOC_24_PCREL
, R_BFIN_PCREL24
},
1011 { BFD_RELOC_24_PCREL
, R_BFIN_PCREL24
},
1012 { BFD_RELOC_BFIN_24_PCREL_JUMP_L
, R_BFIN_PCREL24_JUMP_L
},
1013 { BFD_RELOC_NONE
, R_BFIN_UNUSEDB
},
1014 { BFD_RELOC_NONE
, R_BFIN_UNUSEDC
},
1015 { BFD_RELOC_BFIN_24_PCREL_CALL_X
, R_BFIN_PCREL24_CALL_X
},
1016 { BFD_RELOC_8
, R_BFIN_BYTE_DATA
},
1017 { BFD_RELOC_16
, R_BFIN_BYTE2_DATA
},
1018 { BFD_RELOC_32
, R_BFIN_BYTE4_DATA
},
1019 { BFD_RELOC_BFIN_11_PCREL
, R_BFIN_PCREL11
},
1020 { BFD_RELOC_BFIN_GOT
, R_BFIN_GOT
},
1021 { BFD_RELOC_BFIN_PLTPC
, R_BFIN_PLTPC
},
1023 { BFD_RELOC_BFIN_GOT17M4
, R_BFIN_GOT17M4
},
1024 { BFD_RELOC_BFIN_GOTHI
, R_BFIN_GOTHI
},
1025 { BFD_RELOC_BFIN_GOTLO
, R_BFIN_GOTLO
},
1026 { BFD_RELOC_BFIN_FUNCDESC
, R_BFIN_FUNCDESC
},
1027 { BFD_RELOC_BFIN_FUNCDESC_GOT17M4
, R_BFIN_FUNCDESC_GOT17M4
},
1028 { BFD_RELOC_BFIN_FUNCDESC_GOTHI
, R_BFIN_FUNCDESC_GOTHI
},
1029 { BFD_RELOC_BFIN_FUNCDESC_GOTLO
, R_BFIN_FUNCDESC_GOTLO
},
1030 { BFD_RELOC_BFIN_FUNCDESC_VALUE
, R_BFIN_FUNCDESC_VALUE
},
1031 { BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4
, R_BFIN_FUNCDESC_GOTOFF17M4
},
1032 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI
, R_BFIN_FUNCDESC_GOTOFFHI
},
1033 { BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO
, R_BFIN_FUNCDESC_GOTOFFLO
},
1034 { BFD_RELOC_BFIN_GOTOFF17M4
, R_BFIN_GOTOFF17M4
},
1035 { BFD_RELOC_BFIN_GOTOFFHI
, R_BFIN_GOTOFFHI
},
1036 { BFD_RELOC_BFIN_GOTOFFLO
, R_BFIN_GOTOFFLO
},
1038 { BFD_RELOC_VTABLE_INHERIT
, R_BFIN_GNU_VTINHERIT
},
1039 { BFD_RELOC_VTABLE_ENTRY
, R_BFIN_GNU_VTENTRY
},
1044 bfin_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
,
1046 Elf_Internal_Rela
*dst
)
1048 unsigned int r_type
;
1050 r_type
= ELF32_R_TYPE (dst
->r_info
);
1052 if (r_type
<= BFIN_RELOC_MAX
)
1053 cache_ptr
->howto
= &bfin_howto_table
[r_type
];
1055 else if (r_type
>= BFIN_GNUEXT_RELOC_MIN
&& r_type
<= BFIN_GNUEXT_RELOC_MAX
)
1056 cache_ptr
->howto
= &bfin_gnuext_howto_table
[r_type
- BFIN_GNUEXT_RELOC_MIN
];
1059 cache_ptr
->howto
= (reloc_howto_type
*) NULL
;
1062 /* Given a BFD reloc type, return the howto. */
1063 static reloc_howto_type
*
1064 bfin_bfd_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
1065 bfd_reloc_code_real_type code
)
1068 unsigned int r_type
= (unsigned int) -1;
1070 for (i
= sizeof (bfin_reloc_map
) / sizeof (bfin_reloc_map
[0]); i
--;)
1071 if (bfin_reloc_map
[i
].bfd_reloc_val
== code
)
1072 r_type
= bfin_reloc_map
[i
].bfin_reloc_val
;
1074 if (r_type
<= BFIN_RELOC_MAX
)
1075 return &bfin_howto_table
[r_type
];
1077 else if (r_type
>= BFIN_GNUEXT_RELOC_MIN
&& r_type
<= BFIN_GNUEXT_RELOC_MAX
)
1078 return &bfin_gnuext_howto_table
[r_type
- BFIN_GNUEXT_RELOC_MIN
];
1080 return (reloc_howto_type
*) NULL
;
1083 static reloc_howto_type
*
1084 bfin_bfd_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
1090 i
< (sizeof (bfin_howto_table
)
1091 / sizeof (bfin_howto_table
[0]));
1093 if (bfin_howto_table
[i
].name
!= NULL
1094 && strcasecmp (bfin_howto_table
[i
].name
, r_name
) == 0)
1095 return &bfin_howto_table
[i
];
1098 i
< (sizeof (bfin_gnuext_howto_table
)
1099 / sizeof (bfin_gnuext_howto_table
[0]));
1101 if (bfin_gnuext_howto_table
[i
].name
!= NULL
1102 && strcasecmp (bfin_gnuext_howto_table
[i
].name
, r_name
) == 0)
1103 return &bfin_gnuext_howto_table
[i
];
1108 /* Given a bfin relocation type, return the howto. */
1109 static reloc_howto_type
*
1110 bfin_reloc_type_lookup (bfd
* abfd ATTRIBUTE_UNUSED
,
1111 unsigned int r_type
)
1113 if (r_type
<= BFIN_RELOC_MAX
)
1114 return &bfin_howto_table
[r_type
];
1116 else if (r_type
>= BFIN_GNUEXT_RELOC_MIN
&& r_type
<= BFIN_GNUEXT_RELOC_MAX
)
1117 return &bfin_gnuext_howto_table
[r_type
- BFIN_GNUEXT_RELOC_MIN
];
1119 return (reloc_howto_type
*) NULL
;
1122 /* Set by ld emulation if --code-in-l1. */
1123 bfd_boolean elf32_bfin_code_in_l1
= 0;
1125 /* Set by ld emulation if --data-in-l1. */
1126 bfd_boolean elf32_bfin_data_in_l1
= 0;
1129 elf32_bfin_final_write_processing (bfd
*abfd
,
1130 bfd_boolean linker ATTRIBUTE_UNUSED
)
1132 if (elf32_bfin_code_in_l1
)
1133 elf_elfheader (abfd
)->e_flags
|= EF_BFIN_CODE_IN_L1
;
1134 if (elf32_bfin_data_in_l1
)
1135 elf_elfheader (abfd
)->e_flags
|= EF_BFIN_DATA_IN_L1
;
1138 /* Return TRUE if the name is a local label.
1139 bfin local labels begin with L$. */
1141 bfin_is_local_label_name (bfd
*abfd
, const char *label
)
1143 if (label
[0] == 'L' && label
[1] == '$' )
1146 return _bfd_elf_is_local_label_name (abfd
, label
);
1149 /* Look through the relocs for a section during the first phase, and
1150 allocate space in the global offset table or procedure linkage
1154 bfin_check_relocs (bfd
* abfd
,
1155 struct bfd_link_info
*info
,
1157 const Elf_Internal_Rela
*relocs
)
1160 Elf_Internal_Shdr
*symtab_hdr
;
1161 struct elf_link_hash_entry
**sym_hashes
;
1162 bfd_signed_vma
*local_got_refcounts
;
1163 const Elf_Internal_Rela
*rel
;
1164 const Elf_Internal_Rela
*rel_end
;
1168 if (bfd_link_relocatable (info
))
1171 dynobj
= elf_hash_table (info
)->dynobj
;
1172 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1173 sym_hashes
= elf_sym_hashes (abfd
);
1174 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1179 rel_end
= relocs
+ sec
->reloc_count
;
1180 for (rel
= relocs
; rel
< rel_end
; rel
++)
1182 unsigned long r_symndx
;
1183 struct elf_link_hash_entry
*h
;
1185 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1186 if (r_symndx
< symtab_hdr
->sh_info
)
1190 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1192 /* PR15323, ref flags aren't set for references in the same
1194 h
->root
.non_ir_ref
= 1;
1197 switch (ELF32_R_TYPE (rel
->r_info
))
1199 /* This relocation describes the C++ object vtable hierarchy.
1200 Reconstruct it for later use during GC. */
1201 case R_BFIN_GNU_VTINHERIT
:
1202 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1206 /* This relocation describes which C++ vtable entries
1207 are actually used. Record for later use during GC. */
1208 case R_BFIN_GNU_VTENTRY
:
1209 BFD_ASSERT (h
!= NULL
);
1211 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1217 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1223 /* Create the .got section. */
1224 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1225 if (!_bfd_elf_create_got_section (dynobj
, info
))
1231 sgot
= bfd_get_linker_section (dynobj
, ".got");
1232 BFD_ASSERT (sgot
!= NULL
);
1235 if (srelgot
== NULL
&& (h
!= NULL
|| bfd_link_pic (info
)))
1237 srelgot
= bfd_get_linker_section (dynobj
, ".rela.got");
1238 if (srelgot
== NULL
)
1240 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
1241 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
1243 srelgot
= bfd_make_section_anyway_with_flags (dynobj
,
1247 || !bfd_set_section_alignment (dynobj
, srelgot
, 2))
1254 if (h
->got
.refcount
== 0)
1256 /* Make sure this symbol is output as a dynamic symbol. */
1257 if (h
->dynindx
== -1 && !h
->forced_local
)
1259 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
1263 /* Allocate space in the .got section. */
1265 /* Allocate relocation space. */
1266 srelgot
->size
+= sizeof (Elf32_External_Rela
);
1272 /* This is a global offset table entry for a local symbol. */
1273 if (local_got_refcounts
== NULL
)
1277 size
= symtab_hdr
->sh_info
;
1278 size
*= sizeof (bfd_signed_vma
);
1279 local_got_refcounts
= ((bfd_signed_vma
*)
1280 bfd_zalloc (abfd
, size
));
1281 if (local_got_refcounts
== NULL
)
1283 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
1285 if (local_got_refcounts
[r_symndx
] == 0)
1288 if (bfd_link_pic (info
))
1290 /* If we are generating a shared object, we need to
1291 output a R_68K_RELATIVE reloc so that the dynamic
1292 linker can adjust this GOT entry. */
1293 srelgot
->size
+= sizeof (Elf32_External_Rela
);
1296 local_got_refcounts
[r_symndx
]++;
1308 static enum elf_reloc_type_class
1309 elf32_bfin_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
1310 const asection
*rel_sec ATTRIBUTE_UNUSED
,
1311 const Elf_Internal_Rela
* rela
)
1313 switch ((int) ELF32_R_TYPE (rela
->r_info
))
1316 return reloc_class_normal
;
1320 static bfd_reloc_status_type
1321 bfin_final_link_relocate (Elf_Internal_Rela
*rel
, reloc_howto_type
*howto
,
1322 bfd
*input_bfd
, asection
*input_section
,
1323 bfd_byte
*contents
, bfd_vma address
,
1324 bfd_vma value
, bfd_vma addend
)
1326 int r_type
= ELF32_R_TYPE (rel
->r_info
);
1328 if (r_type
== R_BFIN_PCREL24
|| r_type
== R_BFIN_PCREL24_JUMP_L
)
1330 bfd_reloc_status_type r
= bfd_reloc_ok
;
1333 if (address
> bfd_get_section_limit (input_bfd
, input_section
))
1334 return bfd_reloc_outofrange
;
1338 /* Perform usual pc-relative correction. */
1339 value
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
1342 /* We are getting reloc_entry->address 2 byte off from
1343 the start of instruction. Assuming absolute postion
1344 of the reloc data. But, following code had been written assuming
1345 reloc address is starting at begining of instruction.
1346 To compensate that I have increased the value of
1347 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
1352 if ((value
& 0xFF000000) != 0
1353 && (value
& 0xFF000000) != 0xFF000000)
1354 r
= bfd_reloc_overflow
;
1358 x
= bfd_get_16 (input_bfd
, contents
+ address
);
1359 x
= (x
& 0xff00) | ((value
>> 16) & 0xff);
1360 bfd_put_16 (input_bfd
, x
, contents
+ address
);
1362 x
= bfd_get_16 (input_bfd
, contents
+ address
+ 2);
1364 bfd_put_16 (input_bfd
, x
, contents
+ address
+ 2);
1368 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
1369 rel
->r_offset
, value
, addend
);
1374 bfin_relocate_section (bfd
* output_bfd
,
1375 struct bfd_link_info
*info
,
1377 asection
* input_section
,
1378 bfd_byte
* contents
,
1379 Elf_Internal_Rela
* relocs
,
1380 Elf_Internal_Sym
* local_syms
,
1381 asection
** local_sections
)
1384 Elf_Internal_Shdr
*symtab_hdr
;
1385 struct elf_link_hash_entry
**sym_hashes
;
1386 bfd_vma
*local_got_offsets
;
1388 Elf_Internal_Rela
*rel
;
1389 Elf_Internal_Rela
*relend
;
1392 dynobj
= elf_hash_table (info
)->dynobj
;
1393 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1394 sym_hashes
= elf_sym_hashes (input_bfd
);
1395 local_got_offsets
= elf_local_got_offsets (input_bfd
);
1400 relend
= relocs
+ input_section
->reloc_count
;
1401 for (; rel
< relend
; rel
++, i
++)
1404 reloc_howto_type
*howto
;
1405 unsigned long r_symndx
;
1406 struct elf_link_hash_entry
*h
;
1407 Elf_Internal_Sym
*sym
;
1409 bfd_vma relocation
= 0;
1410 bfd_boolean unresolved_reloc
;
1411 bfd_reloc_status_type r
;
1414 r_type
= ELF32_R_TYPE (rel
->r_info
);
1415 if (r_type
< 0 || r_type
>= 243)
1417 bfd_set_error (bfd_error_bad_value
);
1421 if (r_type
== R_BFIN_GNU_VTENTRY
1422 || r_type
== R_BFIN_GNU_VTINHERIT
)
1425 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
1428 bfd_set_error (bfd_error_bad_value
);
1431 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1436 unresolved_reloc
= FALSE
;
1438 if (r_symndx
< symtab_hdr
->sh_info
)
1440 sym
= local_syms
+ r_symndx
;
1441 sec
= local_sections
[r_symndx
];
1442 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1446 bfd_boolean warned
, ignored
;
1448 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1449 r_symndx
, symtab_hdr
, sym_hashes
,
1451 unresolved_reloc
, warned
, ignored
);
1454 if (sec
!= NULL
&& discarded_section (sec
))
1455 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1456 rel
, 1, relend
, howto
, 0, contents
);
1458 if (bfd_link_relocatable (info
))
1461 address
= rel
->r_offset
;
1463 /* Then, process normally. */
1466 case R_BFIN_GNU_VTINHERIT
:
1467 case R_BFIN_GNU_VTENTRY
:
1468 return bfd_reloc_ok
;
1471 /* Relocation is to the address of the entry for this symbol
1472 in the global offset table. */
1474 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1477 /* Relocation is the offset of the entry for this symbol in
1478 the global offset table. */
1485 /* Create the .got section. */
1486 elf_hash_table (info
)->dynobj
= dynobj
= output_bfd
;
1487 if (!_bfd_elf_create_got_section (dynobj
, info
))
1493 sgot
= bfd_get_linker_section (dynobj
, ".got");
1494 BFD_ASSERT (sgot
!= NULL
);
1501 off
= h
->got
.offset
;
1502 BFD_ASSERT (off
!= (bfd_vma
) - 1);
1503 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
1505 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
,
1506 bfd_link_pic (info
),
1508 || (bfd_link_pic (info
)
1514 /* This is actually a static link, or it is a
1515 -Bsymbolic link and the symbol is defined
1516 locally, or the symbol was forced to be local
1517 because of a version file.. We must initialize
1518 this entry in the global offset table. Since
1519 the offset must always be a multiple of 4, we
1520 use the least significant bit to record whether
1521 we have initialized it already.
1523 When doing a dynamic link, we create a .rela.got
1524 relocation entry to initialize the value. This
1525 is done in the finish_dynamic_symbol routine. */
1530 bfd_put_32 (output_bfd
, relocation
,
1531 sgot
->contents
+ off
);
1536 unresolved_reloc
= FALSE
;
1540 BFD_ASSERT (local_got_offsets
!= NULL
);
1541 off
= local_got_offsets
[r_symndx
];
1542 BFD_ASSERT (off
!= (bfd_vma
) - 1);
1544 /* The offset must always be a multiple of 4. We use
1545 the least significant bit to record whether we have
1546 already generated the necessary reloc. */
1551 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
1553 if (bfd_link_pic (info
))
1556 Elf_Internal_Rela outrel
;
1559 s
= bfd_get_linker_section (dynobj
, ".rela.got");
1560 BFD_ASSERT (s
!= NULL
);
1562 outrel
.r_offset
= (sgot
->output_section
->vma
1563 + sgot
->output_offset
+ off
);
1565 ELF32_R_INFO (0, R_BFIN_PCREL24
);
1566 outrel
.r_addend
= relocation
;
1569 s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
1570 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
1573 local_got_offsets
[r_symndx
] |= 1;
1577 relocation
= sgot
->output_offset
+ off
;
1579 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */
1586 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
1588 relocation
, rel
->r_addend
);
1593 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1594 because such sections are not SEC_ALLOC and thus ld.so will
1595 not process them. */
1596 if (unresolved_reloc
1597 && !((input_section
->flags
& SEC_DEBUGGING
) != 0 && h
->def_dynamic
)
1598 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
1599 rel
->r_offset
) != (bfd_vma
) -1)
1602 /* xgettext:c-format */
1603 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
1605 input_section
, (long) rel
->r_offset
, h
->root
.root
.string
);
1609 if (r
!= bfd_reloc_ok
)
1614 name
= h
->root
.root
.string
;
1617 name
= bfd_elf_string_from_elf_section (input_bfd
,
1618 symtab_hdr
->sh_link
,
1623 name
= bfd_section_name (input_bfd
, sec
);
1626 if (r
== bfd_reloc_overflow
)
1627 (*info
->callbacks
->reloc_overflow
)
1628 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1629 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1633 /* xgettext:c-format */
1634 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1635 input_bfd
, input_section
,
1636 (long) rel
->r_offset
, name
, (int) r
);
1646 bfin_gc_mark_hook (asection
* sec
,
1647 struct bfd_link_info
*info
,
1648 Elf_Internal_Rela
* rel
,
1649 struct elf_link_hash_entry
*h
,
1650 Elf_Internal_Sym
* sym
)
1653 switch (ELF32_R_TYPE (rel
->r_info
))
1655 case R_BFIN_GNU_VTINHERIT
:
1656 case R_BFIN_GNU_VTENTRY
:
1660 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
1663 /* Update the got entry reference counts for the section being removed. */
1666 bfin_gc_sweep_hook (bfd
* abfd
,
1667 struct bfd_link_info
*info
,
1669 const Elf_Internal_Rela
* relocs
)
1671 Elf_Internal_Shdr
*symtab_hdr
;
1672 struct elf_link_hash_entry
**sym_hashes
;
1673 bfd_signed_vma
*local_got_refcounts
;
1674 const Elf_Internal_Rela
*rel
, *relend
;
1679 dynobj
= elf_hash_table (info
)->dynobj
;
1683 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1684 sym_hashes
= elf_sym_hashes (abfd
);
1685 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1687 sgot
= bfd_get_linker_section (dynobj
, ".got");
1688 srelgot
= bfd_get_linker_section (dynobj
, ".rela.got");
1690 relend
= relocs
+ sec
->reloc_count
;
1691 for (rel
= relocs
; rel
< relend
; rel
++)
1693 unsigned long r_symndx
;
1694 struct elf_link_hash_entry
*h
;
1696 switch (ELF32_R_TYPE (rel
->r_info
))
1699 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1700 if (r_symndx
>= symtab_hdr
->sh_info
)
1702 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1703 if (h
->got
.refcount
> 0)
1706 if (h
->got
.refcount
== 0)
1708 /* We don't need the .got entry any more. */
1710 srelgot
->size
-= sizeof (Elf32_External_Rela
);
1714 else if (local_got_refcounts
!= NULL
)
1716 if (local_got_refcounts
[r_symndx
] > 0)
1718 --local_got_refcounts
[r_symndx
];
1719 if (local_got_refcounts
[r_symndx
] == 0)
1721 /* We don't need the .got entry any more. */
1723 if (bfd_link_pic (info
))
1724 srelgot
->size
-= sizeof (Elf32_External_Rela
);
1736 extern const bfd_target bfin_elf32_fdpic_vec
;
1737 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfin_elf32_fdpic_vec)
1739 /* An extension of the elf hash table data structure,
1740 containing some additional Blackfin-specific data. */
1741 struct bfinfdpic_elf_link_hash_table
1743 struct elf_link_hash_table elf
;
1745 /* A pointer to the .got section. */
1747 /* A pointer to the .rel.got section. */
1749 /* A pointer to the .rofixup section. */
1750 asection
*sgotfixup
;
1751 /* A pointer to the .plt section. */
1753 /* A pointer to the .rel.plt section. */
1755 /* GOT base offset. */
1757 /* Location of the first non-lazy PLT entry, i.e., the number of
1758 bytes taken by lazy PLT entries. */
1760 /* A hash table holding information about which symbols were
1761 referenced with which PIC-related relocations. */
1762 struct htab
*relocs_info
;
1763 /* Summary reloc information collected by
1764 _bfinfdpic_count_got_plt_entries. */
1765 struct _bfinfdpic_dynamic_got_info
*g
;
1768 /* Get the Blackfin ELF linker hash table from a link_info structure. */
1770 #define bfinfdpic_hash_table(info) \
1771 (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
1772 == BFIN_ELF_DATA ? ((struct bfinfdpic_elf_link_hash_table *) ((info)->hash)) : NULL)
1774 #define bfinfdpic_got_section(info) \
1775 (bfinfdpic_hash_table (info)->sgot)
1776 #define bfinfdpic_gotrel_section(info) \
1777 (bfinfdpic_hash_table (info)->sgotrel)
1778 #define bfinfdpic_gotfixup_section(info) \
1779 (bfinfdpic_hash_table (info)->sgotfixup)
1780 #define bfinfdpic_plt_section(info) \
1781 (bfinfdpic_hash_table (info)->splt)
1782 #define bfinfdpic_pltrel_section(info) \
1783 (bfinfdpic_hash_table (info)->spltrel)
1784 #define bfinfdpic_relocs_info(info) \
1785 (bfinfdpic_hash_table (info)->relocs_info)
1786 #define bfinfdpic_got_initial_offset(info) \
1787 (bfinfdpic_hash_table (info)->got0)
1788 #define bfinfdpic_plt_initial_offset(info) \
1789 (bfinfdpic_hash_table (info)->plt0)
1790 #define bfinfdpic_dynamic_got_plt_info(info) \
1791 (bfinfdpic_hash_table (info)->g)
1793 /* The name of the dynamic interpreter. This is put in the .interp
1796 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1798 #define DEFAULT_STACK_SIZE 0x20000
1800 /* This structure is used to collect the number of entries present in
1801 each addressable range of the got. */
1802 struct _bfinfdpic_dynamic_got_info
1804 /* Several bits of information about the current link. */
1805 struct bfd_link_info
*info
;
1806 /* Total size needed for GOT entries within the 18- or 32-bit
1808 bfd_vma got17m4
, gothilo
;
1809 /* Total size needed for function descriptor entries within the 18-
1810 or 32-bit ranges. */
1811 bfd_vma fd17m4
, fdhilo
;
1812 /* Total size needed function descriptor entries referenced in PLT
1813 entries, that would be profitable to place in offsets close to
1814 the PIC register. */
1816 /* Total size needed by lazy PLT entries. */
1818 /* Number of relocations carried over from input object files. */
1819 unsigned long relocs
;
1820 /* Number of fixups introduced by relocations in input object files. */
1821 unsigned long fixups
;
1824 /* Create a Blackfin ELF linker hash table. */
1826 static struct bfd_link_hash_table
*
1827 bfinfdpic_elf_link_hash_table_create (bfd
*abfd
)
1829 struct bfinfdpic_elf_link_hash_table
*ret
;
1830 bfd_size_type amt
= sizeof (struct bfinfdpic_elf_link_hash_table
);
1832 ret
= bfd_zmalloc (amt
);
1836 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1837 _bfd_elf_link_hash_newfunc
,
1838 sizeof (struct elf_link_hash_entry
),
1845 return &ret
->elf
.root
;
1848 /* Decide whether a reference to a symbol can be resolved locally or
1849 not. If the symbol is protected, we want the local address, but
1850 its function descriptor must be assigned by the dynamic linker. */
1851 #define BFINFDPIC_SYM_LOCAL(INFO, H) \
1852 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1853 || ! elf_hash_table (INFO)->dynamic_sections_created)
1854 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1855 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1857 /* This structure collects information on what kind of GOT, PLT or
1858 function descriptors are required by relocations that reference a
1860 struct bfinfdpic_relocs_info
1862 /* The index of the symbol, as stored in the relocation r_info, if
1863 we have a local symbol; -1 otherwise. */
1867 /* The input bfd in which the symbol is defined, if it's a local
1870 /* If symndx == -1, the hash table entry corresponding to a global
1871 symbol (even if it turns out to bind locally, in which case it
1872 should ideally be replaced with section's symndx + addend). */
1873 struct elf_link_hash_entry
*h
;
1875 /* The addend of the relocation that references the symbol. */
1878 /* The fields above are used to identify an entry. The fields below
1879 contain information on how an entry is used and, later on, which
1880 locations it was assigned. */
1881 /* The following 2 fields record whether the symbol+addend above was
1882 ever referenced with a GOT relocation. The 17M4 suffix indicates a
1883 GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */
1886 /* Whether a FUNCDESC relocation references symbol+addend. */
1888 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1891 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1892 unsigned fdgoff17m4
;
1893 unsigned fdgoffhilo
;
1894 /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1895 GOTOFFHI relocations. The addend doesn't really matter, since we
1896 envision that this will only be used to check whether the symbol
1897 is mapped to the same segment as the got. */
1899 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1901 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1904 /* Whether we need a PLT entry for a symbol. Should be implied by
1906 (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */
1908 /* Whether a function descriptor should be created in this link unit
1909 for symbol+addend. Should be implied by something like:
1910 (plt || fdgotoff17m4 || fdgotofflohi
1911 || ((fd || fdgot17m4 || fdgothilo)
1912 && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1914 /* Whether a lazy PLT entry is needed for this symbol+addend.
1915 Should be implied by something like:
1916 (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1917 && ! (info->flags & DF_BIND_NOW)) */
1919 /* Whether we've already emitted GOT relocations and PLT entries as
1920 needed for this symbol. */
1923 /* The number of R_BFIN_BYTE4_DATA, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1924 relocations referencing the symbol. */
1925 unsigned relocs32
, relocsfd
, relocsfdv
;
1927 /* The number of .rofixups entries and dynamic relocations allocated
1928 for this symbol, minus any that might have already been used. */
1929 unsigned fixups
, dynrelocs
;
1931 /* The offsets of the GOT entries assigned to symbol+addend, to the
1932 function descriptor's address, and to a function descriptor,
1933 respectively. Should be zero if unassigned. The offsets are
1934 counted from the value that will be assigned to the PIC register,
1935 not from the beginning of the .got section. */
1936 bfd_signed_vma got_entry
, fdgot_entry
, fd_entry
;
1937 /* The offsets of the PLT entries assigned to symbol+addend,
1938 non-lazy and lazy, respectively. If unassigned, should be
1940 bfd_vma plt_entry
, lzplt_entry
;
1943 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry. */
1945 bfinfdpic_relocs_info_hash (const void *entry_
)
1947 const struct bfinfdpic_relocs_info
*entry
= entry_
;
1949 return (entry
->symndx
== -1
1950 ? (long) entry
->d
.h
->root
.root
.hash
1951 : entry
->symndx
+ (long) entry
->d
.abfd
->id
* 257) + entry
->addend
;
1954 /* Test whether the key fields of two bfinfdpic_relocs_info entries are
1957 bfinfdpic_relocs_info_eq (const void *entry1
, const void *entry2
)
1959 const struct bfinfdpic_relocs_info
*e1
= entry1
;
1960 const struct bfinfdpic_relocs_info
*e2
= entry2
;
1962 return e1
->symndx
== e2
->symndx
&& e1
->addend
== e2
->addend
1963 && (e1
->symndx
== -1 ? e1
->d
.h
== e2
->d
.h
: e1
->d
.abfd
== e2
->d
.abfd
);
1966 /* Find or create an entry in a hash table HT that matches the key
1967 fields of the given ENTRY. If it's not found, memory for a new
1968 entry is allocated in ABFD's obstack. */
1969 static struct bfinfdpic_relocs_info
*
1970 bfinfdpic_relocs_info_find (struct htab
*ht
,
1972 const struct bfinfdpic_relocs_info
*entry
,
1973 enum insert_option insert
)
1975 struct bfinfdpic_relocs_info
**loc
;
1980 loc
= (struct bfinfdpic_relocs_info
**) htab_find_slot (ht
, entry
, insert
);
1988 *loc
= bfd_zalloc (abfd
, sizeof (**loc
));
1993 (*loc
)->symndx
= entry
->symndx
;
1994 (*loc
)->d
= entry
->d
;
1995 (*loc
)->addend
= entry
->addend
;
1996 (*loc
)->plt_entry
= (bfd_vma
)-1;
1997 (*loc
)->lzplt_entry
= (bfd_vma
)-1;
2002 /* Obtain the address of the entry in HT associated with H's symbol +
2003 addend, creating a new entry if none existed. ABFD is only used
2004 for memory allocation purposes. */
2005 inline static struct bfinfdpic_relocs_info
*
2006 bfinfdpic_relocs_info_for_global (struct htab
*ht
,
2008 struct elf_link_hash_entry
*h
,
2010 enum insert_option insert
)
2012 struct bfinfdpic_relocs_info entry
;
2016 entry
.addend
= addend
;
2018 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
2021 /* Obtain the address of the entry in HT associated with the SYMNDXth
2022 local symbol of the input bfd ABFD, plus the addend, creating a new
2023 entry if none existed. */
2024 inline static struct bfinfdpic_relocs_info
*
2025 bfinfdpic_relocs_info_for_local (struct htab
*ht
,
2029 enum insert_option insert
)
2031 struct bfinfdpic_relocs_info entry
;
2033 entry
.symndx
= symndx
;
2034 entry
.d
.abfd
= abfd
;
2035 entry
.addend
= addend
;
2037 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
2040 /* Merge fields set by check_relocs() of two entries that end up being
2041 mapped to the same (presumably global) symbol. */
2044 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info
*e2
,
2045 struct bfinfdpic_relocs_info
const *e1
)
2047 e2
->got17m4
|= e1
->got17m4
;
2048 e2
->gothilo
|= e1
->gothilo
;
2050 e2
->fdgot17m4
|= e1
->fdgot17m4
;
2051 e2
->fdgothilo
|= e1
->fdgothilo
;
2052 e2
->fdgoff17m4
|= e1
->fdgoff17m4
;
2053 e2
->fdgoffhilo
|= e1
->fdgoffhilo
;
2054 e2
->gotoff
|= e1
->gotoff
;
2055 e2
->call
|= e1
->call
;
2059 /* Every block of 65535 lazy PLT entries shares a single call to the
2060 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
2061 32767, counting from 0). All other lazy PLT entries branch to it
2062 in a single instruction. */
2064 #define LZPLT_RESOLVER_EXTRA 10
2065 #define LZPLT_NORMAL_SIZE 6
2066 #define LZPLT_ENTRIES 1362
2068 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
2069 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
2071 /* Add a dynamic relocation to the SRELOC section. */
2073 inline static bfd_vma
2074 _bfinfdpic_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
2075 int reloc_type
, long dynindx
, bfd_vma addend
,
2076 struct bfinfdpic_relocs_info
*entry
)
2078 Elf_Internal_Rela outrel
;
2079 bfd_vma reloc_offset
;
2081 outrel
.r_offset
= offset
;
2082 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
2083 outrel
.r_addend
= addend
;
2085 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rel
);
2086 BFD_ASSERT (reloc_offset
< sreloc
->size
);
2087 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
2088 sreloc
->contents
+ reloc_offset
);
2089 sreloc
->reloc_count
++;
2091 /* If the entry's index is zero, this relocation was probably to a
2092 linkonce section that got discarded. We reserved a dynamic
2093 relocation, but it was for another entry than the one we got at
2094 the time of emitting the relocation. Unfortunately there's no
2095 simple way for us to catch this situation, since the relocation
2096 is cleared right before calling relocate_section, at which point
2097 we no longer know what the relocation used to point to. */
2100 BFD_ASSERT (entry
->dynrelocs
> 0);
2104 return reloc_offset
;
2107 /* Add a fixup to the ROFIXUP section. */
2110 _bfinfdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma offset
,
2111 struct bfinfdpic_relocs_info
*entry
)
2113 bfd_vma fixup_offset
;
2115 if (rofixup
->flags
& SEC_EXCLUDE
)
2118 fixup_offset
= rofixup
->reloc_count
* 4;
2119 if (rofixup
->contents
)
2121 BFD_ASSERT (fixup_offset
< rofixup
->size
);
2122 bfd_put_32 (output_bfd
, offset
, rofixup
->contents
+ fixup_offset
);
2124 rofixup
->reloc_count
++;
2126 if (entry
&& entry
->symndx
)
2128 /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
2130 BFD_ASSERT (entry
->fixups
> 0);
2134 return fixup_offset
;
2137 /* Find the segment number in which OSEC, and output section, is
2141 _bfinfdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
2143 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
2145 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
2148 inline static bfd_boolean
2149 _bfinfdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
2151 unsigned seg
= _bfinfdpic_osec_to_segment (output_bfd
, osec
);
2153 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
2156 /* Generate relocations for GOT entries, function descriptors, and
2157 code for PLT and lazy PLT entries. */
2159 inline static bfd_boolean
2160 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info
*entry
,
2162 struct bfd_link_info
*info
,
2164 Elf_Internal_Sym
*sym
,
2167 bfd_vma fd_lazy_rel_offset
= (bfd_vma
) -1;
2174 if (entry
->got_entry
|| entry
->fdgot_entry
|| entry
->fd_entry
)
2176 /* If the symbol is dynamic, consider it for dynamic
2177 relocations, otherwise decay to section + offset. */
2178 if (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1)
2179 dynindx
= entry
->d
.h
->dynindx
;
2183 && sec
->output_section
2184 && ! bfd_is_abs_section (sec
->output_section
)
2185 && ! bfd_is_und_section (sec
->output_section
))
2186 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
2192 /* Generate relocation for GOT entry pointing to the symbol. */
2193 if (entry
->got_entry
)
2196 bfd_vma ad
= addend
;
2198 /* If the symbol is dynamic but binds locally, use
2200 if (sec
&& (entry
->symndx
!= -1
2201 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2203 if (entry
->symndx
== -1)
2204 ad
+= entry
->d
.h
->root
.u
.def
.value
;
2206 ad
+= sym
->st_value
;
2207 ad
+= sec
->output_offset
;
2208 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
2209 idx
= elf_section_data (sec
->output_section
)->dynindx
;
2214 /* If we're linking an executable at a fixed address, we can
2215 omit the dynamic relocation as long as the symbol is local to
2217 if (bfd_link_pde (info
)
2218 && (entry
->symndx
!= -1
2219 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2222 ad
+= sec
->output_section
->vma
;
2223 if (entry
->symndx
!= -1
2224 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
2225 _bfinfdpic_add_rofixup (output_bfd
,
2226 bfinfdpic_gotfixup_section (info
),
2227 bfinfdpic_got_section (info
)->output_section
2229 + bfinfdpic_got_section (info
)->output_offset
2230 + bfinfdpic_got_initial_offset (info
)
2231 + entry
->got_entry
, entry
);
2234 _bfinfdpic_add_dyn_reloc (output_bfd
, bfinfdpic_gotrel_section (info
),
2235 _bfd_elf_section_offset
2237 bfinfdpic_got_section (info
),
2238 bfinfdpic_got_initial_offset (info
)
2240 + bfinfdpic_got_section (info
)
2241 ->output_section
->vma
2242 + bfinfdpic_got_section (info
)->output_offset
,
2243 R_BFIN_BYTE4_DATA
, idx
, ad
, entry
);
2245 bfd_put_32 (output_bfd
, ad
,
2246 bfinfdpic_got_section (info
)->contents
2247 + bfinfdpic_got_initial_offset (info
)
2248 + entry
->got_entry
);
2251 /* Generate relocation for GOT entry pointing to a canonical
2252 function descriptor. */
2253 if (entry
->fdgot_entry
)
2258 if (! (entry
->symndx
== -1
2259 && entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
2260 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2262 /* If the symbol is dynamic and there may be dynamic symbol
2263 resolution because we are, or are linked with, a shared
2264 library, emit a FUNCDESC relocation such that the dynamic
2265 linker will allocate the function descriptor. If the
2266 symbol needs a non-local function descriptor but binds
2267 locally (e.g., its visibility is protected, emit a
2268 dynamic relocation decayed to section+offset. */
2269 if (entry
->symndx
== -1
2270 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)
2271 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)
2272 && !bfd_link_pde (info
))
2274 reloc
= R_BFIN_FUNCDESC
;
2275 idx
= elf_section_data (entry
->d
.h
->root
.u
.def
.section
2276 ->output_section
)->dynindx
;
2277 ad
= entry
->d
.h
->root
.u
.def
.section
->output_offset
2278 + entry
->d
.h
->root
.u
.def
.value
;
2280 else if (entry
->symndx
== -1
2281 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
))
2283 reloc
= R_BFIN_FUNCDESC
;
2291 /* Otherwise, we know we have a private function descriptor,
2292 so reference it directly. */
2293 if (elf_hash_table (info
)->dynamic_sections_created
)
2294 BFD_ASSERT (entry
->privfd
);
2295 reloc
= R_BFIN_BYTE4_DATA
;
2296 idx
= elf_section_data (bfinfdpic_got_section (info
)
2297 ->output_section
)->dynindx
;
2298 ad
= bfinfdpic_got_section (info
)->output_offset
2299 + bfinfdpic_got_initial_offset (info
) + entry
->fd_entry
;
2302 /* If there is room for dynamic symbol resolution, emit the
2303 dynamic relocation. However, if we're linking an
2304 executable at a fixed location, we won't have emitted a
2305 dynamic symbol entry for the got section, so idx will be
2306 zero, which means we can and should compute the address
2307 of the private descriptor ourselves. */
2308 if (bfd_link_pde (info
)
2309 && (entry
->symndx
!= -1
2310 || BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)))
2312 ad
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2313 _bfinfdpic_add_rofixup (output_bfd
,
2314 bfinfdpic_gotfixup_section (info
),
2315 bfinfdpic_got_section (info
)
2316 ->output_section
->vma
2317 + bfinfdpic_got_section (info
)
2319 + bfinfdpic_got_initial_offset (info
)
2320 + entry
->fdgot_entry
, entry
);
2323 _bfinfdpic_add_dyn_reloc (output_bfd
,
2324 bfinfdpic_gotrel_section (info
),
2325 _bfd_elf_section_offset
2327 bfinfdpic_got_section (info
),
2328 bfinfdpic_got_initial_offset (info
)
2329 + entry
->fdgot_entry
)
2330 + bfinfdpic_got_section (info
)
2331 ->output_section
->vma
2332 + bfinfdpic_got_section (info
)
2334 reloc
, idx
, ad
, entry
);
2337 bfd_put_32 (output_bfd
, ad
,
2338 bfinfdpic_got_section (info
)->contents
2339 + bfinfdpic_got_initial_offset (info
)
2340 + entry
->fdgot_entry
);
2343 /* Generate relocation to fill in a private function descriptor in
2345 if (entry
->fd_entry
)
2348 bfd_vma ad
= addend
;
2350 long lowword
, highword
;
2352 /* If the symbol is dynamic but binds locally, use
2354 if (sec
&& (entry
->symndx
!= -1
2355 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2357 if (entry
->symndx
== -1)
2358 ad
+= entry
->d
.h
->root
.u
.def
.value
;
2360 ad
+= sym
->st_value
;
2361 ad
+= sec
->output_offset
;
2362 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
2363 idx
= elf_section_data (sec
->output_section
)->dynindx
;
2368 /* If we're linking an executable at a fixed address, we can
2369 omit the dynamic relocation as long as the symbol is local to
2371 if (bfd_link_pde (info
)
2372 && (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
2375 ad
+= sec
->output_section
->vma
;
2377 if (entry
->symndx
!= -1
2378 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
2380 _bfinfdpic_add_rofixup (output_bfd
,
2381 bfinfdpic_gotfixup_section (info
),
2382 bfinfdpic_got_section (info
)
2383 ->output_section
->vma
2384 + bfinfdpic_got_section (info
)
2386 + bfinfdpic_got_initial_offset (info
)
2387 + entry
->fd_entry
, entry
);
2388 _bfinfdpic_add_rofixup (output_bfd
,
2389 bfinfdpic_gotfixup_section (info
),
2390 bfinfdpic_got_section (info
)
2391 ->output_section
->vma
2392 + bfinfdpic_got_section (info
)
2394 + bfinfdpic_got_initial_offset (info
)
2395 + entry
->fd_entry
+ 4, entry
);
2401 = _bfinfdpic_add_dyn_reloc (output_bfd
,
2403 ? bfinfdpic_pltrel_section (info
)
2404 : bfinfdpic_gotrel_section (info
),
2405 _bfd_elf_section_offset
2407 bfinfdpic_got_section (info
),
2408 bfinfdpic_got_initial_offset (info
)
2410 + bfinfdpic_got_section (info
)
2411 ->output_section
->vma
2412 + bfinfdpic_got_section (info
)
2414 R_BFIN_FUNCDESC_VALUE
, idx
, ad
, entry
);
2417 /* If we've omitted the dynamic relocation, just emit the fixed
2418 addresses of the symbol and of the local GOT base offset. */
2419 if (bfd_link_pde (info
)
2421 && sec
->output_section
)
2424 highword
= bfinfdpic_got_section (info
)->output_section
->vma
2425 + bfinfdpic_got_section (info
)->output_offset
2426 + bfinfdpic_got_initial_offset (info
);
2428 else if (entry
->lazyplt
)
2433 fd_lazy_rel_offset
= ofst
;
2435 /* A function descriptor used for lazy or local resolving is
2436 initialized such that its high word contains the output
2437 section index in which the PLT entries are located, and
2438 the low word contains the address of the lazy PLT entry
2439 entry point, that must be within the memory region
2440 assigned to that section. */
2441 lowword
= entry
->lzplt_entry
+ 4
2442 + bfinfdpic_plt_section (info
)->output_offset
2443 + bfinfdpic_plt_section (info
)->output_section
->vma
;
2444 highword
= _bfinfdpic_osec_to_segment
2445 (output_bfd
, bfinfdpic_plt_section (info
)->output_section
);
2449 /* A function descriptor for a local function gets the index
2450 of the section. For a non-local function, it's
2454 || (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1
2455 && entry
->d
.h
->dynindx
== idx
))
2458 highword
= _bfinfdpic_osec_to_segment
2459 (output_bfd
, sec
->output_section
);
2462 bfd_put_32 (output_bfd
, lowword
,
2463 bfinfdpic_got_section (info
)->contents
2464 + bfinfdpic_got_initial_offset (info
)
2466 bfd_put_32 (output_bfd
, highword
,
2467 bfinfdpic_got_section (info
)->contents
2468 + bfinfdpic_got_initial_offset (info
)
2469 + entry
->fd_entry
+ 4);
2472 /* Generate code for the PLT entry. */
2473 if (entry
->plt_entry
!= (bfd_vma
) -1)
2475 bfd_byte
*plt_code
= bfinfdpic_plt_section (info
)->contents
2478 BFD_ASSERT (entry
->fd_entry
);
2480 /* Figure out what kind of PLT entry we need, depending on the
2481 location of the function descriptor within the GOT. */
2482 if (entry
->fd_entry
>= -(1 << (18 - 1))
2483 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
2485 /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
2486 bfd_put_32 (output_bfd
,
2487 0xe519 | ((entry
->fd_entry
<< 14) & 0xFFFF0000),
2489 bfd_put_32 (output_bfd
,
2490 0xe51b | (((entry
->fd_entry
+ 4) << 14) & 0xFFFF0000),
2496 /* P1.L = fd_entry; P1.H = fd_entry;
2500 bfd_put_32 (output_bfd
,
2501 0xe109 | (entry
->fd_entry
<< 16),
2503 bfd_put_32 (output_bfd
,
2504 0xe149 | (entry
->fd_entry
& 0xFFFF0000),
2506 bfd_put_16 (output_bfd
, 0x5ad9, plt_code
+ 8);
2507 bfd_put_16 (output_bfd
, 0x9159, plt_code
+ 10);
2508 bfd_put_16 (output_bfd
, 0xac5b, plt_code
+ 12);
2512 bfd_put_16 (output_bfd
, 0x0051, plt_code
);
2515 /* Generate code for the lazy PLT entry. */
2516 if (entry
->lzplt_entry
!= (bfd_vma
) -1)
2518 bfd_byte
*lzplt_code
= bfinfdpic_plt_section (info
)->contents
2519 + entry
->lzplt_entry
;
2520 bfd_vma resolverStub_addr
;
2522 bfd_put_32 (output_bfd
, fd_lazy_rel_offset
, lzplt_code
);
2525 resolverStub_addr
= entry
->lzplt_entry
/ BFINFDPIC_LZPLT_BLOCK_SIZE
2526 * BFINFDPIC_LZPLT_BLOCK_SIZE
+ BFINFDPIC_LZPLT_RESOLV_LOC
;
2527 if (resolverStub_addr
>= bfinfdpic_plt_initial_offset (info
))
2528 resolverStub_addr
= bfinfdpic_plt_initial_offset (info
) - LZPLT_NORMAL_SIZE
- LZPLT_RESOLVER_EXTRA
;
2530 if (entry
->lzplt_entry
== resolverStub_addr
)
2532 /* This is a lazy PLT entry that includes a resolver call.
2536 bfd_put_32 (output_bfd
,
2539 bfd_put_16 (output_bfd
, 0x0052, lzplt_code
+ 4);
2543 /* JUMP.S resolverStub */
2544 bfd_put_16 (output_bfd
,
2546 | (((resolverStub_addr
- entry
->lzplt_entry
)
2547 / 2) & (((bfd_vma
)1 << 12) - 1)),
2555 /* Relocate an Blackfin ELF section.
2557 The RELOCATE_SECTION function is called by the new ELF backend linker
2558 to handle the relocations for a section.
2560 The relocs are always passed as Rela structures; if the section
2561 actually uses Rel structures, the r_addend field will always be
2564 This function is responsible for adjusting the section contents as
2565 necessary, and (if using Rela relocs and generating a relocatable
2566 output file) adjusting the reloc addend as necessary.
2568 This function does not have to worry about setting the reloc
2569 address or the reloc symbol index.
2571 LOCAL_SYMS is a pointer to the swapped in local symbols.
2573 LOCAL_SECTIONS is an array giving the section in the input file
2574 corresponding to the st_shndx field of each local symbol.
2576 The global hash table entry for the global symbols can be found
2577 via elf_sym_hashes (input_bfd).
2579 When generating relocatable output, this function must handle
2580 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2581 going to be the section symbol corresponding to the output
2582 section, which means that the addend must be adjusted
2586 bfinfdpic_relocate_section (bfd
* output_bfd
,
2587 struct bfd_link_info
*info
,
2589 asection
* input_section
,
2590 bfd_byte
* contents
,
2591 Elf_Internal_Rela
* relocs
,
2592 Elf_Internal_Sym
* local_syms
,
2593 asection
** local_sections
)
2595 Elf_Internal_Shdr
*symtab_hdr
;
2596 struct elf_link_hash_entry
**sym_hashes
;
2597 Elf_Internal_Rela
*rel
;
2598 Elf_Internal_Rela
*relend
;
2599 unsigned isec_segment
, got_segment
, plt_segment
,
2601 int silence_segment_error
= !bfd_link_pic (info
);
2603 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2604 sym_hashes
= elf_sym_hashes (input_bfd
);
2605 relend
= relocs
+ input_section
->reloc_count
;
2607 isec_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2608 input_section
->output_section
);
2609 if (IS_FDPIC (output_bfd
) && bfinfdpic_got_section (info
))
2610 got_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2611 bfinfdpic_got_section (info
)
2615 if (IS_FDPIC (output_bfd
) && elf_hash_table (info
)->dynamic_sections_created
)
2616 plt_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2617 bfinfdpic_plt_section (info
)
2622 for (rel
= relocs
; rel
< relend
; rel
++)
2624 reloc_howto_type
*howto
;
2625 unsigned long r_symndx
;
2626 Elf_Internal_Sym
*sym
;
2628 struct elf_link_hash_entry
*h
;
2630 bfd_reloc_status_type r
;
2631 const char * name
= NULL
;
2634 struct bfinfdpic_relocs_info
*picrel
;
2635 bfd_vma orig_addend
= rel
->r_addend
;
2637 r_type
= ELF32_R_TYPE (rel
->r_info
);
2639 if (r_type
== R_BFIN_GNU_VTINHERIT
2640 || r_type
== R_BFIN_GNU_VTENTRY
)
2643 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2644 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
2647 bfd_set_error (bfd_error_bad_value
);
2655 if (r_symndx
< symtab_hdr
->sh_info
)
2657 sym
= local_syms
+ r_symndx
;
2658 osec
= sec
= local_sections
[r_symndx
];
2659 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2661 name
= bfd_elf_string_from_elf_section
2662 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2663 name
= (name
== NULL
) ? bfd_section_name (input_bfd
, sec
) : name
;
2667 bfd_boolean warned
, ignored
;
2668 bfd_boolean unresolved_reloc
;
2670 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2671 r_symndx
, symtab_hdr
, sym_hashes
,
2673 unresolved_reloc
, warned
, ignored
);
2677 if (sec
!= NULL
&& discarded_section (sec
))
2678 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2679 rel
, 1, relend
, howto
, 0, contents
);
2681 if (bfd_link_relocatable (info
))
2685 && (h
->root
.type
== bfd_link_hash_defined
2686 || h
->root
.type
== bfd_link_hash_defweak
)
2687 && !BFINFDPIC_SYM_LOCAL (info
, h
))
2695 case R_BFIN_PCREL24
:
2696 case R_BFIN_PCREL24_JUMP_L
:
2697 case R_BFIN_BYTE4_DATA
:
2698 if (! IS_FDPIC (output_bfd
))
2702 case R_BFIN_GOT17M4
:
2705 case R_BFIN_FUNCDESC_GOT17M4
:
2706 case R_BFIN_FUNCDESC_GOTHI
:
2707 case R_BFIN_FUNCDESC_GOTLO
:
2708 case R_BFIN_GOTOFF17M4
:
2709 case R_BFIN_GOTOFFHI
:
2710 case R_BFIN_GOTOFFLO
:
2711 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2712 case R_BFIN_FUNCDESC_GOTOFFHI
:
2713 case R_BFIN_FUNCDESC_GOTOFFLO
:
2714 case R_BFIN_FUNCDESC
:
2715 case R_BFIN_FUNCDESC_VALUE
:
2717 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2718 (info
), input_bfd
, h
,
2719 orig_addend
, INSERT
);
2721 /* In order to find the entry we created before, we must
2722 use the original addend, not the one that may have been
2723 modified by _bfd_elf_rela_local_sym(). */
2724 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2725 (info
), input_bfd
, r_symndx
,
2726 orig_addend
, INSERT
);
2730 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel
, output_bfd
, info
,
2735 /* xgettext:c-format */
2736 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2737 input_bfd
, input_section
, rel
->r_offset
, name
);
2747 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
2748 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2749 rel
->r_offset
) != (bfd_vma
) -1)
2751 info
->callbacks
->warning
2752 (info
, _("relocation references symbol not defined in the module"),
2753 name
, input_bfd
, input_section
, rel
->r_offset
);
2761 case R_BFIN_PCREL24
:
2762 case R_BFIN_PCREL24_JUMP_L
:
2763 check_segment
[0] = isec_segment
;
2764 if (! IS_FDPIC (output_bfd
))
2765 check_segment
[1] = isec_segment
;
2766 else if (picrel
->plt
)
2768 relocation
= bfinfdpic_plt_section (info
)->output_section
->vma
2769 + bfinfdpic_plt_section (info
)->output_offset
2770 + picrel
->plt_entry
;
2771 check_segment
[1] = plt_segment
;
2773 /* We don't want to warn on calls to undefined weak symbols,
2774 as calls to them must be protected by non-NULL tests
2775 anyway, and unprotected calls would invoke undefined
2777 else if (picrel
->symndx
== -1
2778 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefweak
)
2779 check_segment
[1] = check_segment
[0];
2781 check_segment
[1] = sec
2782 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2786 case R_BFIN_GOT17M4
:
2789 relocation
= picrel
->got_entry
;
2790 check_segment
[0] = check_segment
[1] = got_segment
;
2793 case R_BFIN_FUNCDESC_GOT17M4
:
2794 case R_BFIN_FUNCDESC_GOTHI
:
2795 case R_BFIN_FUNCDESC_GOTLO
:
2796 relocation
= picrel
->fdgot_entry
;
2797 check_segment
[0] = check_segment
[1] = got_segment
;
2800 case R_BFIN_GOTOFFHI
:
2801 case R_BFIN_GOTOFF17M4
:
2802 case R_BFIN_GOTOFFLO
:
2803 relocation
-= bfinfdpic_got_section (info
)->output_section
->vma
2804 + bfinfdpic_got_section (info
)->output_offset
2805 + bfinfdpic_got_initial_offset (info
);
2806 check_segment
[0] = got_segment
;
2807 check_segment
[1] = sec
2808 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2812 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2813 case R_BFIN_FUNCDESC_GOTOFFHI
:
2814 case R_BFIN_FUNCDESC_GOTOFFLO
:
2815 relocation
= picrel
->fd_entry
;
2816 check_segment
[0] = check_segment
[1] = got_segment
;
2819 case R_BFIN_FUNCDESC
:
2822 bfd_vma addend
= rel
->r_addend
;
2824 if (! (h
&& h
->root
.type
== bfd_link_hash_undefweak
2825 && BFINFDPIC_SYM_LOCAL (info
, h
)))
2827 /* If the symbol is dynamic and there may be dynamic
2828 symbol resolution because we are or are linked with a
2829 shared library, emit a FUNCDESC relocation such that
2830 the dynamic linker will allocate the function
2831 descriptor. If the symbol needs a non-local function
2832 descriptor but binds locally (e.g., its visibility is
2833 protected, emit a dynamic relocation decayed to
2835 if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
)
2836 && BFINFDPIC_SYM_LOCAL (info
, h
)
2837 && !bfd_link_pde (info
))
2839 dynindx
= elf_section_data (h
->root
.u
.def
.section
2840 ->output_section
)->dynindx
;
2841 addend
+= h
->root
.u
.def
.section
->output_offset
2842 + h
->root
.u
.def
.value
;
2844 else if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
))
2848 info
->callbacks
->warning
2849 (info
, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2850 name
, input_bfd
, input_section
, rel
->r_offset
);
2853 dynindx
= h
->dynindx
;
2857 /* Otherwise, we know we have a private function
2858 descriptor, so reference it directly. */
2859 BFD_ASSERT (picrel
->privfd
);
2860 r_type
= R_BFIN_BYTE4_DATA
;
2861 dynindx
= elf_section_data (bfinfdpic_got_section (info
)
2862 ->output_section
)->dynindx
;
2863 addend
= bfinfdpic_got_section (info
)->output_offset
2864 + bfinfdpic_got_initial_offset (info
)
2868 /* If there is room for dynamic symbol resolution, emit
2869 the dynamic relocation. However, if we're linking an
2870 executable at a fixed location, we won't have emitted a
2871 dynamic symbol entry for the got section, so idx will
2872 be zero, which means we can and should compute the
2873 address of the private descriptor ourselves. */
2874 if (bfd_link_pde (info
)
2875 && (!h
|| BFINFDPIC_FUNCDESC_LOCAL (info
, h
)))
2879 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2880 if ((bfd_get_section_flags (output_bfd
,
2881 input_section
->output_section
)
2882 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2884 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2888 info
->callbacks
->warning
2890 _("cannot emit fixups in read-only section"),
2891 name
, input_bfd
, input_section
, rel
->r_offset
);
2895 offset
= _bfd_elf_section_offset
2897 input_section
, rel
->r_offset
);
2899 if (offset
!= (bfd_vma
)-1)
2900 _bfinfdpic_add_rofixup (output_bfd
,
2901 bfinfdpic_gotfixup_section
2903 offset
+ input_section
2904 ->output_section
->vma
2905 + input_section
->output_offset
,
2909 else if ((bfd_get_section_flags (output_bfd
,
2910 input_section
->output_section
)
2911 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2915 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2919 info
->callbacks
->warning
2921 _("cannot emit dynamic relocations in read-only section"),
2922 name
, input_bfd
, input_section
, rel
->r_offset
);
2925 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2926 input_section
, rel
->r_offset
);
2928 if (offset
!= (bfd_vma
)-1)
2929 _bfinfdpic_add_dyn_reloc (output_bfd
,
2930 bfinfdpic_gotrel_section (info
),
2931 offset
+ input_section
2932 ->output_section
->vma
2933 + input_section
->output_offset
,
2935 dynindx
, addend
, picrel
);
2938 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2941 /* We want the addend in-place because dynamic
2942 relocations are REL. Setting relocation to it should
2943 arrange for it to be installed. */
2944 relocation
= addend
- rel
->r_addend
;
2946 check_segment
[0] = check_segment
[1] = got_segment
;
2949 case R_BFIN_BYTE4_DATA
:
2950 if (! IS_FDPIC (output_bfd
))
2952 check_segment
[0] = check_segment
[1] = -1;
2956 case R_BFIN_FUNCDESC_VALUE
:
2959 bfd_vma addend
= rel
->r_addend
;
2961 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2962 input_section
, rel
->r_offset
);
2964 /* If the symbol is dynamic but binds locally, use
2966 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
))
2968 if (addend
&& r_type
== R_BFIN_FUNCDESC_VALUE
)
2970 info
->callbacks
->warning
2971 (info
, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2972 name
, input_bfd
, input_section
, rel
->r_offset
);
2975 dynindx
= h
->dynindx
;
2980 addend
+= h
->root
.u
.def
.value
;
2982 addend
+= sym
->st_value
;
2984 addend
+= osec
->output_offset
;
2985 if (osec
&& osec
->output_section
2986 && ! bfd_is_abs_section (osec
->output_section
)
2987 && ! bfd_is_und_section (osec
->output_section
))
2988 dynindx
= elf_section_data (osec
->output_section
)->dynindx
;
2993 /* If we're linking an executable at a fixed address, we
2994 can omit the dynamic relocation as long as the symbol
2995 is defined in the current link unit (which is implied
2996 by its output section not being NULL). */
2997 if (bfd_link_pde (info
)
2998 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
3001 addend
+= osec
->output_section
->vma
;
3002 if (IS_FDPIC (input_bfd
)
3003 && (bfd_get_section_flags (output_bfd
,
3004 input_section
->output_section
)
3005 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3007 if (_bfinfdpic_osec_readonly_p (output_bfd
,
3011 info
->callbacks
->warning
3013 _("cannot emit fixups in read-only section"),
3014 name
, input_bfd
, input_section
, rel
->r_offset
);
3017 if (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3019 if (offset
!= (bfd_vma
)-1)
3021 _bfinfdpic_add_rofixup (output_bfd
,
3022 bfinfdpic_gotfixup_section
3024 offset
+ input_section
3025 ->output_section
->vma
3026 + input_section
->output_offset
,
3029 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
3030 _bfinfdpic_add_rofixup
3032 bfinfdpic_gotfixup_section (info
),
3033 offset
+ input_section
->output_section
->vma
3034 + input_section
->output_offset
+ 4, picrel
);
3041 if ((bfd_get_section_flags (output_bfd
,
3042 input_section
->output_section
)
3043 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3045 if (_bfinfdpic_osec_readonly_p (output_bfd
,
3049 info
->callbacks
->warning
3051 _("cannot emit dynamic relocations in read-only section"),
3052 name
, input_bfd
, input_section
, rel
->r_offset
);
3056 if (offset
!= (bfd_vma
)-1)
3057 _bfinfdpic_add_dyn_reloc (output_bfd
,
3058 bfinfdpic_gotrel_section (info
),
3060 + input_section
->output_section
->vma
3061 + input_section
->output_offset
,
3062 r_type
, dynindx
, addend
, picrel
);
3065 addend
+= osec
->output_section
->vma
;
3066 /* We want the addend in-place because dynamic
3067 relocations are REL. Setting relocation to it
3068 should arrange for it to be installed. */
3069 relocation
= addend
- rel
->r_addend
;
3072 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
3074 /* If we've omitted the dynamic relocation, just emit
3075 the fixed addresses of the symbol and of the local
3077 if (bfd_link_pde (info
)
3078 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
3079 bfd_put_32 (output_bfd
,
3080 bfinfdpic_got_section (info
)->output_section
->vma
3081 + bfinfdpic_got_section (info
)->output_offset
3082 + bfinfdpic_got_initial_offset (info
),
3083 contents
+ rel
->r_offset
+ 4);
3085 /* A function descriptor used for lazy or local
3086 resolving is initialized such that its high word
3087 contains the output section index in which the
3088 PLT entries are located, and the low word
3089 contains the offset of the lazy PLT entry entry
3090 point into that section. */
3091 bfd_put_32 (output_bfd
,
3092 h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
3094 : _bfinfdpic_osec_to_segment (output_bfd
,
3097 contents
+ rel
->r_offset
+ 4);
3100 check_segment
[0] = check_segment
[1] = got_segment
;
3104 check_segment
[0] = isec_segment
;
3105 check_segment
[1] = sec
3106 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3111 if (check_segment
[0] != check_segment
[1] && IS_FDPIC (output_bfd
))
3113 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
3114 in the ld testsuite. */
3115 /* This helps catch problems in GCC while we can't do more
3116 than static linking. The idea is to test whether the
3117 input file basename is crt0.o only once. */
3118 if (silence_segment_error
== 1)
3119 silence_segment_error
=
3120 (strlen (input_bfd
->filename
) == 6
3121 && filename_cmp (input_bfd
->filename
, "crt0.o") == 0)
3122 || (strlen (input_bfd
->filename
) > 6
3123 && filename_cmp (input_bfd
->filename
3124 + strlen (input_bfd
->filename
) - 7,
3128 if (!silence_segment_error
3129 /* We don't want duplicate errors for undefined
3131 && !(picrel
&& picrel
->symndx
== -1
3132 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefined
))
3133 info
->callbacks
->warning
3136 ? _("relocations between different segments are not supported")
3137 : _("warning: relocation references a different segment"),
3138 name
, input_bfd
, input_section
, rel
->r_offset
);
3139 if (!silence_segment_error
&& bfd_link_pic (info
))
3141 elf_elfheader (output_bfd
)->e_flags
|= EF_BFIN_PIC
;
3146 case R_BFIN_GOTOFFHI
:
3147 /* We need the addend to be applied before we shift the
3149 relocation
+= rel
->r_addend
;
3152 case R_BFIN_FUNCDESC_GOTHI
:
3153 case R_BFIN_FUNCDESC_GOTOFFHI
:
3158 case R_BFIN_FUNCDESC_GOTLO
:
3159 case R_BFIN_GOTOFFLO
:
3160 case R_BFIN_FUNCDESC_GOTOFFLO
:
3161 relocation
&= 0xffff;
3170 case R_BFIN_PCREL24
:
3171 case R_BFIN_PCREL24_JUMP_L
:
3172 if (! IS_FDPIC (output_bfd
) || ! picrel
->plt
)
3176 /* When referencing a GOT entry, a function descriptor or a
3177 PLT, we don't want the addend to apply to the reference,
3178 but rather to the referenced symbol. The actual entry
3179 will have already been created taking the addend into
3180 account, so cancel it out here. */
3181 case R_BFIN_GOT17M4
:
3184 case R_BFIN_FUNCDESC_GOT17M4
:
3185 case R_BFIN_FUNCDESC_GOTHI
:
3186 case R_BFIN_FUNCDESC_GOTLO
:
3187 case R_BFIN_FUNCDESC_GOTOFF17M4
:
3188 case R_BFIN_FUNCDESC_GOTOFFHI
:
3189 case R_BFIN_FUNCDESC_GOTOFFLO
:
3190 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
3191 here, since we do want to apply the addend to the others.
3192 Note that we've applied the addend to GOTOFFHI before we
3193 shifted it right. */
3194 case R_BFIN_GOTOFFHI
:
3195 relocation
-= rel
->r_addend
;
3202 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
3203 contents
, rel
->r_offset
,
3204 relocation
, rel
->r_addend
);
3206 if (r
!= bfd_reloc_ok
)
3208 const char * msg
= (const char *) NULL
;
3212 case bfd_reloc_overflow
:
3213 (*info
->callbacks
->reloc_overflow
)
3214 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3215 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
3218 case bfd_reloc_undefined
:
3219 (*info
->callbacks
->undefined_symbol
)
3220 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
3223 case bfd_reloc_outofrange
:
3224 msg
= _("internal error: out of range error");
3227 case bfd_reloc_notsupported
:
3228 msg
= _("internal error: unsupported relocation error");
3231 case bfd_reloc_dangerous
:
3232 msg
= _("internal error: dangerous relocation");
3236 msg
= _("internal error: unknown error");
3241 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
3242 input_section
, rel
->r_offset
);
3249 /* Update the relocation information for the relocations of the section
3253 bfinfdpic_gc_sweep_hook (bfd
*abfd
,
3254 struct bfd_link_info
*info
,
3256 const Elf_Internal_Rela
*relocs
)
3258 Elf_Internal_Shdr
*symtab_hdr
;
3259 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
3260 const Elf_Internal_Rela
*rel
;
3261 const Elf_Internal_Rela
*rel_end
;
3262 struct bfinfdpic_relocs_info
*picrel
;
3264 BFD_ASSERT (IS_FDPIC (abfd
));
3266 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3267 sym_hashes
= elf_sym_hashes (abfd
);
3268 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
3269 if (!elf_bad_symtab (abfd
))
3270 sym_hashes_end
-= symtab_hdr
->sh_info
;
3272 rel_end
= relocs
+ sec
->reloc_count
;
3273 for (rel
= relocs
; rel
< rel_end
; rel
++)
3275 struct elf_link_hash_entry
*h
;
3276 unsigned long r_symndx
;
3278 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3279 if (r_symndx
< symtab_hdr
->sh_info
)
3282 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3285 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
3287 rel
->r_addend
, NO_INSERT
);
3289 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
3290 (info
), abfd
, r_symndx
,
3291 rel
->r_addend
, NO_INSERT
);
3296 switch (ELF32_R_TYPE (rel
->r_info
))
3298 case R_BFIN_PCREL24
:
3299 case R_BFIN_PCREL24_JUMP_L
:
3303 case R_BFIN_FUNCDESC_VALUE
:
3304 picrel
->relocsfdv
--;
3305 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
3309 case R_BFIN_BYTE4_DATA
:
3311 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
3315 case R_BFIN_GOT17M4
:
3324 case R_BFIN_FUNCDESC_GOT17M4
:
3325 picrel
->fdgot17m4
--;
3328 case R_BFIN_FUNCDESC_GOTHI
:
3329 case R_BFIN_FUNCDESC_GOTLO
:
3330 picrel
->fdgothilo
--;
3333 case R_BFIN_GOTOFF17M4
:
3334 case R_BFIN_GOTOFFHI
:
3335 case R_BFIN_GOTOFFLO
:
3339 case R_BFIN_FUNCDESC_GOTOFF17M4
:
3340 picrel
->fdgoff17m4
--;
3343 case R_BFIN_FUNCDESC_GOTOFFHI
:
3344 case R_BFIN_FUNCDESC_GOTOFFLO
:
3345 picrel
->fdgoffhilo
--;
3348 case R_BFIN_FUNCDESC
:
3361 /* We need dynamic symbols for every section, since segments can
3362 relocate independently. */
3364 _bfinfdpic_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3365 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
3368 switch (elf_section_data (p
)->this_hdr
.sh_type
)
3372 /* If sh_type is yet undecided, assume it could be
3373 SHT_PROGBITS/SHT_NOBITS. */
3377 /* There shouldn't be section relative relocations
3378 against any other section. */
3384 /* Create a .got section, as well as its additional info field. This
3385 is almost entirely copied from
3386 elflink.c:_bfd_elf_create_got_section(). */
3389 _bfin_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3391 flagword flags
, pltflags
;
3393 struct elf_link_hash_entry
*h
;
3394 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3397 /* This function may be called more than once. */
3398 s
= bfd_get_linker_section (abfd
, ".got");
3402 /* Machine specific: although pointers are 32-bits wide, we want the
3403 GOT to be aligned to a 64-bit boundary, such that function
3404 descriptors in it can be accessed with 64-bit loads and
3408 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3409 | SEC_LINKER_CREATED
);
3412 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
3414 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
3417 if (bed
->want_got_plt
)
3419 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
3421 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
3425 if (bed
->want_got_sym
)
3427 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3428 (or .got.plt) section. We don't do this in the linker script
3429 because we don't want to define the symbol if we are not creating
3430 a global offset table. */
3431 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "__GLOBAL_OFFSET_TABLE_");
3432 elf_hash_table (info
)->hgot
= h
;
3436 /* Machine-specific: we want the symbol for executables as
3438 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3442 /* The first bit of the global offset table is the header. */
3443 s
->size
+= bed
->got_header_size
;
3445 /* This is the machine-specific part. Create and initialize section
3446 data for the got. */
3447 if (IS_FDPIC (abfd
))
3449 bfinfdpic_got_section (info
) = s
;
3450 bfinfdpic_relocs_info (info
) = htab_try_create (1,
3451 bfinfdpic_relocs_info_hash
,
3452 bfinfdpic_relocs_info_eq
,
3454 if (! bfinfdpic_relocs_info (info
))
3457 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.got",
3458 (flags
| SEC_READONLY
));
3460 || ! bfd_set_section_alignment (abfd
, s
, 2))
3463 bfinfdpic_gotrel_section (info
) = s
;
3465 /* Machine-specific. */
3466 s
= bfd_make_section_anyway_with_flags (abfd
, ".rofixup",
3467 (flags
| SEC_READONLY
));
3469 || ! bfd_set_section_alignment (abfd
, s
, 2))
3472 bfinfdpic_gotfixup_section (info
) = s
;
3475 pltflags
|= SEC_CODE
;
3476 if (bed
->plt_not_loaded
)
3477 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
3478 if (bed
->plt_readonly
)
3479 pltflags
|= SEC_READONLY
;
3481 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
3483 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
3485 /* Blackfin-specific: remember it. */
3486 bfinfdpic_plt_section (info
) = s
;
3488 if (bed
->want_plt_sym
)
3490 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3492 struct bfd_link_hash_entry
*bh
= NULL
;
3494 if (! (_bfd_generic_link_add_one_symbol
3495 (info
, abfd
, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, 0, NULL
,
3496 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3498 h
= (struct elf_link_hash_entry
*) bh
;
3500 h
->type
= STT_OBJECT
;
3502 if (! bfd_link_executable (info
)
3503 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3507 /* Blackfin-specific: we want rel relocations for the plt. */
3508 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.plt",
3509 flags
| SEC_READONLY
);
3511 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
3513 /* Blackfin-specific: remember it. */
3514 bfinfdpic_pltrel_section (info
) = s
;
3519 /* Make sure the got and plt sections exist, and that our pointers in
3520 the link hash table point to them. */
3523 elf32_bfinfdpic_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3525 /* This is mostly copied from
3526 elflink.c:_bfd_elf_create_dynamic_sections(). */
3529 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3531 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3532 | SEC_LINKER_CREATED
);
3534 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3535 .rel[a].bss sections. */
3537 /* Blackfin-specific: we want to create the GOT in the Blackfin way. */
3538 if (! _bfin_create_got_section (abfd
, info
))
3541 /* Blackfin-specific: make sure we created everything we wanted. */
3542 BFD_ASSERT (bfinfdpic_got_section (info
) && bfinfdpic_gotrel_section (info
)
3543 /* && bfinfdpic_gotfixup_section (info) */
3544 && bfinfdpic_plt_section (info
)
3545 && bfinfdpic_pltrel_section (info
));
3547 if (bed
->want_dynbss
)
3549 /* The .dynbss section is a place to put symbols which are defined
3550 by dynamic objects, are referenced by regular objects, and are
3551 not functions. We must allocate space for them in the process
3552 image and use a R_*_COPY reloc to tell the dynamic linker to
3553 initialize them at run time. The linker script puts the .dynbss
3554 section into the .bss section of the final image. */
3555 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
3556 SEC_ALLOC
| SEC_LINKER_CREATED
);
3560 /* The .rel[a].bss section holds copy relocs. This section is not
3561 normally needed. We need to create it here, though, so that the
3562 linker will map it to an output section. We can't just create it
3563 only if we need it, because we will not know whether we need it
3564 until we have seen all the input files, and the first time the
3565 main linker code calls BFD after examining all the input files
3566 (size_dynamic_sections) the input sections have already been
3567 mapped to the output sections. If the section turns out not to
3568 be needed, we can discard it later. We will never need this
3569 section when generating a shared object, since they do not use
3571 if (! bfd_link_pic (info
))
3573 s
= bfd_make_section_anyway_with_flags (abfd
,
3575 flags
| SEC_READONLY
);
3577 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
3585 /* Compute the total GOT size required by each symbol in each range.
3586 Symbols may require up to 4 words in the GOT: an entry pointing to
3587 the symbol, an entry pointing to its function descriptor, and a
3588 private function descriptors taking two words. */
3591 _bfinfdpic_count_nontls_entries (struct bfinfdpic_relocs_info
*entry
,
3592 struct _bfinfdpic_dynamic_got_info
*dinfo
)
3594 /* Allocate space for a GOT entry pointing to the symbol. */
3596 dinfo
->got17m4
+= 4;
3597 else if (entry
->gothilo
)
3598 dinfo
->gothilo
+= 4;
3603 /* Allocate space for a GOT entry pointing to the function
3605 if (entry
->fdgot17m4
)
3606 dinfo
->got17m4
+= 4;
3607 else if (entry
->fdgothilo
)
3608 dinfo
->gothilo
+= 4;
3613 /* Decide whether we need a PLT entry, a function descriptor in the
3614 GOT, and a lazy PLT entry for this symbol. */
3615 entry
->plt
= entry
->call
3616 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3617 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3618 entry
->privfd
= entry
->plt
3619 || entry
->fdgoff17m4
|| entry
->fdgoffhilo
3620 || ((entry
->fd
|| entry
->fdgot17m4
|| entry
->fdgothilo
)
3621 && (entry
->symndx
!= -1
3622 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
)));
3623 entry
->lazyplt
= entry
->privfd
3624 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3625 && ! (dinfo
->info
->flags
& DF_BIND_NOW
)
3626 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3628 /* Allocate space for a function descriptor. */
3629 if (entry
->fdgoff17m4
)
3631 else if (entry
->privfd
&& entry
->plt
)
3633 else if (entry
->privfd
)
3640 dinfo
->lzplt
+= LZPLT_NORMAL_SIZE
;
3643 /* Compute the number of dynamic relocations and fixups that a symbol
3644 requires, and add (or subtract) from the grand and per-symbol
3648 _bfinfdpic_count_relocs_fixups (struct bfinfdpic_relocs_info
*entry
,
3649 struct _bfinfdpic_dynamic_got_info
*dinfo
,
3650 bfd_boolean subtract
)
3652 bfd_vma relocs
= 0, fixups
= 0;
3654 if (!bfd_link_pde (dinfo
->info
))
3655 relocs
= entry
->relocs32
+ entry
->relocsfd
+ entry
->relocsfdv
;
3658 if (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
))
3660 if (entry
->symndx
!= -1
3661 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3662 fixups
+= entry
->relocs32
+ 2 * entry
->relocsfdv
;
3665 relocs
+= entry
->relocs32
+ entry
->relocsfdv
;
3667 if (entry
->symndx
!= -1
3668 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
))
3670 if (entry
->symndx
!= -1
3671 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3672 fixups
+= entry
->relocsfd
;
3675 relocs
+= entry
->relocsfd
;
3684 entry
->dynrelocs
+= relocs
;
3685 entry
->fixups
+= fixups
;
3686 dinfo
->relocs
+= relocs
;
3687 dinfo
->fixups
+= fixups
;
3690 /* Compute the total GOT and PLT size required by each symbol in each range. *
3691 Symbols may require up to 4 words in the GOT: an entry pointing to
3692 the symbol, an entry pointing to its function descriptor, and a
3693 private function descriptors taking two words. */
3696 _bfinfdpic_count_got_plt_entries (void **entryp
, void *dinfo_
)
3698 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3699 struct _bfinfdpic_dynamic_got_info
*dinfo
= dinfo_
;
3701 _bfinfdpic_count_nontls_entries (entry
, dinfo
);
3703 _bfinfdpic_count_relocs_fixups (entry
, dinfo
, FALSE
);
3708 /* This structure is used to assign offsets to got entries, function
3709 descriptors, plt entries and lazy plt entries. */
3711 struct _bfinfdpic_dynamic_got_plt_info
3713 /* Summary information collected with _bfinfdpic_count_got_plt_entries. */
3714 struct _bfinfdpic_dynamic_got_info g
;
3716 /* For each addressable range, we record a MAX (positive) and MIN
3717 (negative) value. CUR is used to assign got entries, and it's
3718 incremented from an initial positive value to MAX, then from MIN
3719 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
3720 assign function descriptors, and it's decreased from an initial
3721 non-positive value to MIN, then from MAX down to CUR (unless CUR
3722 wraps around first). All of MIN, MAX, CUR and FDCUR always point
3723 to even words. ODD, if non-zero, indicates an odd word to be
3724 used for the next got entry, otherwise CUR is used and
3725 incremented by a pair of words, wrapping around when it reaches
3726 MAX. FDCUR is decremented (and wrapped) before the next function
3727 descriptor is chosen. FDPLT indicates the number of remaining
3728 slots that can be used for function descriptors used only by PLT
3730 struct _bfinfdpic_dynamic_got_alloc_data
3732 bfd_signed_vma max
, cur
, odd
, fdcur
, min
;
3737 /* Determine the positive and negative ranges to be used by each
3738 offset range in the GOT. FDCUR and CUR, that must be aligned to a
3739 double-word boundary, are the minimum (negative) and maximum
3740 (positive) GOT offsets already used by previous ranges, except for
3741 an ODD entry that may have been left behind. GOT and FD indicate
3742 the size of GOT entries and function descriptors that must be
3743 placed within the range from -WRAP to WRAP. If there's room left,
3744 up to FDPLT bytes should be reserved for additional function
3747 inline static bfd_signed_vma
3748 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data
*gad
,
3749 bfd_signed_vma fdcur
,
3757 bfd_signed_vma wrapmin
= -wrap
;
3759 /* Start at the given initial points. */
3763 /* If we had an incoming odd word and we have any got entries that
3764 are going to use it, consume it, otherwise leave gad->odd at
3765 zero. We might force gad->odd to zero and return the incoming
3766 odd such that it is used by the next range, but then GOT entries
3767 might appear to be out of order and we wouldn't be able to
3768 shorten the GOT by one word if it turns out to end with an
3769 unpaired GOT entry. */
3779 /* If we're left with an unpaired GOT entry, compute its location
3780 such that we can return it. Otherwise, if got doesn't require an
3781 odd number of words here, either odd was already zero in the
3782 block above, or it was set to zero because got was non-zero, or
3783 got was already zero. In the latter case, we want the value of
3784 odd to carry over to the return statement, so we don't want to
3785 reset odd unless the condition below is true. */
3792 /* Compute the tentative boundaries of this range. */
3793 gad
->max
= cur
+ got
;
3794 gad
->min
= fdcur
- fd
;
3797 /* If function descriptors took too much space, wrap some of them
3799 if (gad
->min
< wrapmin
)
3801 gad
->max
+= wrapmin
- gad
->min
;
3804 /* If there is space left and we have function descriptors
3805 referenced in PLT entries that could take advantage of shorter
3806 offsets, place them here. */
3807 else if (fdplt
&& gad
->min
> wrapmin
)
3810 if ((bfd_vma
) (gad
->min
- wrapmin
) < fdplt
)
3811 fds
= gad
->min
- wrapmin
;
3820 /* If GOT entries took too much space, wrap some of them around.
3821 This may well cause gad->min to become lower than wrapmin. This
3822 will cause a relocation overflow later on, so we don't have to
3824 if ((bfd_vma
) gad
->max
> wrap
)
3826 gad
->min
-= gad
->max
- wrap
;
3829 /* If there is more space left, try to place some more function
3830 descriptors for PLT entries. */
3831 else if (fdplt
&& (bfd_vma
) gad
->max
< wrap
)
3834 if ((bfd_vma
) (wrap
- gad
->max
) < fdplt
)
3835 fds
= wrap
- gad
->max
;
3844 /* If odd was initially computed as an offset past the wrap point,
3847 odd
= gad
->min
+ odd
- gad
->max
;
3849 /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3850 before returning, so do it here too. This guarantees that,
3851 should cur and fdcur meet at the wrap point, they'll both be
3853 if (gad
->cur
== gad
->max
)
3854 gad
->cur
= gad
->min
;
3859 /* Compute the location of the next GOT entry, given the allocation
3860 data for a range. */
3862 inline static bfd_signed_vma
3863 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3869 /* If there was an odd word left behind, use it. */
3875 /* Otherwise, use the word pointed to by cur, reserve the next
3876 as an odd word, and skip to the next pair of words, possibly
3879 gad
->odd
= gad
->cur
+ 4;
3881 if (gad
->cur
== gad
->max
)
3882 gad
->cur
= gad
->min
;
3888 /* Compute the location of the next function descriptor entry in the
3889 GOT, given the allocation data for a range. */
3891 inline static bfd_signed_vma
3892 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3894 /* If we're at the bottom, wrap around, and only then allocate the
3895 next pair of words. */
3896 if (gad
->fdcur
== gad
->min
)
3897 gad
->fdcur
= gad
->max
;
3898 return gad
->fdcur
-= 8;
3901 /* Assign GOT offsets for every GOT entry and function descriptor.
3902 Doing everything in a single pass is tricky. */
3905 _bfinfdpic_assign_got_entries (void **entryp
, void *info_
)
3907 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3908 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3911 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3912 else if (entry
->gothilo
)
3913 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3915 if (entry
->fdgot17m4
)
3916 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3917 else if (entry
->fdgothilo
)
3918 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3920 if (entry
->fdgoff17m4
)
3921 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3922 else if (entry
->plt
&& dinfo
->got17m4
.fdplt
)
3924 dinfo
->got17m4
.fdplt
-= 8;
3925 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3927 else if (entry
->plt
)
3929 dinfo
->gothilo
.fdplt
-= 8;
3930 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3932 else if (entry
->privfd
)
3933 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3938 /* Assign GOT offsets to private function descriptors used by PLT
3939 entries (or referenced by 32-bit offsets), as well as PLT entries
3940 and lazy PLT entries. */
3943 _bfinfdpic_assign_plt_entries (void **entryp
, void *info_
)
3945 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3946 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3948 /* If this symbol requires a local function descriptor, allocate
3950 if (entry
->privfd
&& entry
->fd_entry
== 0)
3952 if (dinfo
->got17m4
.fdplt
)
3954 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3955 dinfo
->got17m4
.fdplt
-= 8;
3959 BFD_ASSERT (dinfo
->gothilo
.fdplt
);
3960 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3961 dinfo
->gothilo
.fdplt
-= 8;
3969 /* We use the section's raw size to mark the location of the
3971 entry
->plt_entry
= bfinfdpic_plt_section (dinfo
->g
.info
)->size
;
3973 /* Figure out the length of this PLT entry based on the
3974 addressing mode we need to reach the function descriptor. */
3975 BFD_ASSERT (entry
->fd_entry
);
3976 if (entry
->fd_entry
>= -(1 << (18 - 1))
3977 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
3982 bfinfdpic_plt_section (dinfo
->g
.info
)->size
+= size
;
3987 entry
->lzplt_entry
= dinfo
->g
.lzplt
;
3988 dinfo
->g
.lzplt
+= LZPLT_NORMAL_SIZE
;
3989 /* If this entry is the one that gets the resolver stub, account
3990 for the additional instruction. */
3991 if (entry
->lzplt_entry
% BFINFDPIC_LZPLT_BLOCK_SIZE
3992 == BFINFDPIC_LZPLT_RESOLV_LOC
)
3993 dinfo
->g
.lzplt
+= LZPLT_RESOLVER_EXTRA
;
3999 /* Cancel out any effects of calling _bfinfdpic_assign_got_entries and
4000 _bfinfdpic_assign_plt_entries. */
4003 _bfinfdpic_reset_got_plt_entries (void **entryp
, void *ignore ATTRIBUTE_UNUSED
)
4005 struct bfinfdpic_relocs_info
*entry
= *entryp
;
4007 entry
->got_entry
= 0;
4008 entry
->fdgot_entry
= 0;
4009 entry
->fd_entry
= 0;
4010 entry
->plt_entry
= (bfd_vma
)-1;
4011 entry
->lzplt_entry
= (bfd_vma
)-1;
4016 /* Follow indirect and warning hash entries so that each got entry
4017 points to the final symbol definition. P must point to a pointer
4018 to the hash table we're traversing. Since this traversal may
4019 modify the hash table, we set this pointer to NULL to indicate
4020 we've made a potentially-destructive change to the hash table, so
4021 the traversal must be restarted. */
4023 _bfinfdpic_resolve_final_relocs_info (void **entryp
, void *p
)
4025 struct bfinfdpic_relocs_info
*entry
= *entryp
;
4028 if (entry
->symndx
== -1)
4030 struct elf_link_hash_entry
*h
= entry
->d
.h
;
4031 struct bfinfdpic_relocs_info
*oentry
;
4033 while (h
->root
.type
== bfd_link_hash_indirect
4034 || h
->root
.type
== bfd_link_hash_warning
)
4035 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
4037 if (entry
->d
.h
== h
)
4040 oentry
= bfinfdpic_relocs_info_for_global (*htab
, 0, h
, entry
->addend
,
4045 /* Merge the two entries. */
4046 bfinfdpic_pic_merge_early_relocs_info (oentry
, entry
);
4047 htab_clear_slot (*htab
, entryp
);
4053 /* If we can't find this entry with the new bfd hash, re-insert
4054 it, and get the traversal restarted. */
4055 if (! htab_find (*htab
, entry
))
4057 htab_clear_slot (*htab
, entryp
);
4058 entryp
= htab_find_slot (*htab
, entry
, INSERT
);
4061 /* Abort the traversal, since the whole table may have
4062 moved, and leave it up to the parent to restart the
4064 *(htab_t
*)p
= NULL
;
4072 /* Compute the total size of the GOT, the PLT, the dynamic relocations
4073 section and the rofixup section. Assign locations for GOT and PLT
4077 _bfinfdpic_size_got_plt (bfd
*output_bfd
,
4078 struct _bfinfdpic_dynamic_got_plt_info
*gpinfop
)
4082 struct bfd_link_info
*info
= gpinfop
->g
.info
;
4083 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
4085 memcpy (bfinfdpic_dynamic_got_plt_info (info
), &gpinfop
->g
,
4086 sizeof (gpinfop
->g
));
4089 /* Compute the total size taken by entries in the 18-bit range,
4090 to tell how many PLT function descriptors we can bring into it
4091 without causing it to overflow. */
4092 limit
= odd
+ gpinfop
->g
.got17m4
+ gpinfop
->g
.fd17m4
;
4093 if (limit
< (bfd_vma
)1 << 18)
4094 limit
= ((bfd_vma
)1 << 18) - limit
;
4097 if (gpinfop
->g
.fdplt
< limit
)
4098 limit
= gpinfop
->g
.fdplt
;
4100 /* Determine the ranges of GOT offsets that we can use for each
4101 range of addressing modes. */
4102 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfop
->got17m4
,
4109 (bfd_vma
)1 << (18-1));
4110 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfop
->gothilo
,
4111 gpinfop
->got17m4
.min
,
4113 gpinfop
->got17m4
.max
,
4116 gpinfop
->g
.fdplt
- gpinfop
->got17m4
.fdplt
,
4117 (bfd_vma
)1 << (32-1));
4119 /* Now assign (most) GOT offsets. */
4120 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_got_entries
,
4123 bfinfdpic_got_section (info
)->size
= gpinfop
->gothilo
.max
4124 - gpinfop
->gothilo
.min
4125 /* If an odd word is the last word of the GOT, we don't need this
4126 word to be part of the GOT. */
4127 - (odd
+ 4 == gpinfop
->gothilo
.max
? 4 : 0);
4128 if (bfinfdpic_got_section (info
)->size
== 0)
4129 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
4130 else if (bfinfdpic_got_section (info
)->size
== 12
4131 && ! elf_hash_table (info
)->dynamic_sections_created
)
4133 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
4134 bfinfdpic_got_section (info
)->size
= 0;
4138 bfinfdpic_got_section (info
)->contents
=
4139 (bfd_byte
*) bfd_zalloc (dynobj
,
4140 bfinfdpic_got_section (info
)->size
);
4141 if (bfinfdpic_got_section (info
)->contents
== NULL
)
4145 if (elf_hash_table (info
)->dynamic_sections_created
)
4146 /* Subtract the number of lzplt entries, since those will generate
4147 relocations in the pltrel section. */
4148 bfinfdpic_gotrel_section (info
)->size
=
4149 (gpinfop
->g
.relocs
- gpinfop
->g
.lzplt
/ LZPLT_NORMAL_SIZE
)
4150 * get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
4152 BFD_ASSERT (gpinfop
->g
.relocs
== 0);
4153 if (bfinfdpic_gotrel_section (info
)->size
== 0)
4154 bfinfdpic_gotrel_section (info
)->flags
|= SEC_EXCLUDE
;
4157 bfinfdpic_gotrel_section (info
)->contents
=
4158 (bfd_byte
*) bfd_zalloc (dynobj
,
4159 bfinfdpic_gotrel_section (info
)->size
);
4160 if (bfinfdpic_gotrel_section (info
)->contents
== NULL
)
4164 bfinfdpic_gotfixup_section (info
)->size
= (gpinfop
->g
.fixups
+ 1) * 4;
4165 if (bfinfdpic_gotfixup_section (info
)->size
== 0)
4166 bfinfdpic_gotfixup_section (info
)->flags
|= SEC_EXCLUDE
;
4169 bfinfdpic_gotfixup_section (info
)->contents
=
4170 (bfd_byte
*) bfd_zalloc (dynobj
,
4171 bfinfdpic_gotfixup_section (info
)->size
);
4172 if (bfinfdpic_gotfixup_section (info
)->contents
== NULL
)
4176 if (elf_hash_table (info
)->dynamic_sections_created
)
4177 bfinfdpic_pltrel_section (info
)->size
=
4178 gpinfop
->g
.lzplt
/ LZPLT_NORMAL_SIZE
* get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
4179 if (bfinfdpic_pltrel_section (info
)->size
== 0)
4180 bfinfdpic_pltrel_section (info
)->flags
|= SEC_EXCLUDE
;
4183 bfinfdpic_pltrel_section (info
)->contents
=
4184 (bfd_byte
*) bfd_zalloc (dynobj
,
4185 bfinfdpic_pltrel_section (info
)->size
);
4186 if (bfinfdpic_pltrel_section (info
)->contents
== NULL
)
4190 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4191 such that there's room for the additional instruction needed to
4192 call the resolver. Since _bfinfdpic_assign_got_entries didn't
4193 account for them, our block size is 4 bytes smaller than the real
4195 if (elf_hash_table (info
)->dynamic_sections_created
)
4197 bfinfdpic_plt_section (info
)->size
= gpinfop
->g
.lzplt
4198 + ((gpinfop
->g
.lzplt
+ (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) - LZPLT_NORMAL_SIZE
)
4199 / (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) * LZPLT_RESOLVER_EXTRA
);
4202 /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4203 actually assign lazy PLT entries addresses. */
4204 gpinfop
->g
.lzplt
= 0;
4206 /* Save information that we're going to need to generate GOT and PLT
4208 bfinfdpic_got_initial_offset (info
) = -gpinfop
->gothilo
.min
;
4210 if (get_elf_backend_data (output_bfd
)->want_got_sym
)
4211 elf_hash_table (info
)->hgot
->root
.u
.def
.value
4212 = bfinfdpic_got_initial_offset (info
);
4214 if (elf_hash_table (info
)->dynamic_sections_created
)
4215 bfinfdpic_plt_initial_offset (info
) =
4216 bfinfdpic_plt_section (info
)->size
;
4218 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_plt_entries
,
4221 /* Allocate the PLT section contents only after
4222 _bfinfdpic_assign_plt_entries has a chance to add the size of the
4223 non-lazy PLT entries. */
4224 if (bfinfdpic_plt_section (info
)->size
== 0)
4225 bfinfdpic_plt_section (info
)->flags
|= SEC_EXCLUDE
;
4228 bfinfdpic_plt_section (info
)->contents
=
4229 (bfd_byte
*) bfd_zalloc (dynobj
,
4230 bfinfdpic_plt_section (info
)->size
);
4231 if (bfinfdpic_plt_section (info
)->contents
== NULL
)
4238 /* Set the sizes of the dynamic sections. */
4241 elf32_bfinfdpic_size_dynamic_sections (bfd
*output_bfd
,
4242 struct bfd_link_info
*info
)
4244 struct elf_link_hash_table
*htab
;
4247 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4249 htab
= elf_hash_table (info
);
4250 dynobj
= htab
->dynobj
;
4251 BFD_ASSERT (dynobj
!= NULL
);
4253 if (htab
->dynamic_sections_created
)
4255 /* Set the contents of the .interp section to the interpreter. */
4256 if (bfd_link_executable (info
) && !info
->nointerp
)
4258 s
= bfd_get_linker_section (dynobj
, ".interp");
4259 BFD_ASSERT (s
!= NULL
);
4260 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4261 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
4265 memset (&gpinfo
, 0, sizeof (gpinfo
));
4266 gpinfo
.g
.info
= info
;
4270 htab_t relocs
= bfinfdpic_relocs_info (info
);
4272 htab_traverse (relocs
, _bfinfdpic_resolve_final_relocs_info
, &relocs
);
4274 if (relocs
== bfinfdpic_relocs_info (info
))
4278 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_count_got_plt_entries
,
4281 /* Allocate space to save the summary information, we're going to
4282 use it if we're doing relaxations. */
4283 bfinfdpic_dynamic_got_plt_info (info
) = bfd_alloc (dynobj
, sizeof (gpinfo
.g
));
4285 if (!_bfinfdpic_size_got_plt (output_bfd
, &gpinfo
))
4288 if (elf_hash_table (info
)->dynamic_sections_created
)
4290 if (bfinfdpic_got_section (info
)->size
)
4291 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0))
4294 if (bfinfdpic_pltrel_section (info
)->size
)
4295 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
4296 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
4297 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
4300 if (bfinfdpic_gotrel_section (info
)->size
)
4301 if (!_bfd_elf_add_dynamic_entry (info
, DT_REL
, 0)
4302 || !_bfd_elf_add_dynamic_entry (info
, DT_RELSZ
, 0)
4303 || !_bfd_elf_add_dynamic_entry (info
, DT_RELENT
,
4304 sizeof (Elf32_External_Rel
)))
4308 s
= bfd_get_linker_section (dynobj
, ".dynbss");
4309 if (s
&& s
->size
== 0)
4310 s
->flags
|= SEC_EXCLUDE
;
4312 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
4313 if (s
&& s
->size
== 0)
4314 s
->flags
|= SEC_EXCLUDE
;
4320 elf32_bfinfdpic_always_size_sections (bfd
*output_bfd
,
4321 struct bfd_link_info
*info
)
4323 if (!bfd_link_relocatable (info
)
4324 && !bfd_elf_stack_segment_size (output_bfd
, info
,
4325 "__stacksize", DEFAULT_STACK_SIZE
))
4331 /* Check whether any of the relocations was optimized away, and
4332 subtract it from the relocation or fixup count. */
4334 _bfinfdpic_check_discarded_relocs (bfd
*abfd
, asection
*sec
,
4335 struct bfd_link_info
*info
,
4336 bfd_boolean
*changed
)
4338 Elf_Internal_Shdr
*symtab_hdr
;
4339 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
4340 Elf_Internal_Rela
*rel
, *erel
;
4342 if ((sec
->flags
& SEC_RELOC
) == 0
4343 || sec
->reloc_count
== 0)
4346 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4347 sym_hashes
= elf_sym_hashes (abfd
);
4348 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
4349 if (!elf_bad_symtab (abfd
))
4350 sym_hashes_end
-= symtab_hdr
->sh_info
;
4352 rel
= elf_section_data (sec
)->relocs
;
4354 /* Now examine each relocation. */
4355 for (erel
= rel
+ sec
->reloc_count
; rel
< erel
; rel
++)
4357 struct elf_link_hash_entry
*h
;
4358 unsigned long r_symndx
;
4359 struct bfinfdpic_relocs_info
*picrel
;
4360 struct _bfinfdpic_dynamic_got_info
*dinfo
;
4362 if (ELF32_R_TYPE (rel
->r_info
) != R_BFIN_BYTE4_DATA
4363 && ELF32_R_TYPE (rel
->r_info
) != R_BFIN_FUNCDESC
)
4366 if (_bfd_elf_section_offset (sec
->output_section
->owner
,
4367 info
, sec
, rel
->r_offset
)
4371 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4372 if (r_symndx
< symtab_hdr
->sh_info
)
4376 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4377 while (h
->root
.type
== bfd_link_hash_indirect
4378 || h
->root
.type
== bfd_link_hash_warning
)
4379 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
4383 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4385 rel
->r_addend
, NO_INSERT
);
4387 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info
),
4389 rel
->r_addend
, NO_INSERT
);
4395 dinfo
= bfinfdpic_dynamic_got_plt_info (info
);
4397 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, TRUE
);
4398 if (ELF32_R_TYPE (rel
->r_info
) == R_BFIN_BYTE4_DATA
)
4400 else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4402 _bfinfdpic_count_relocs_fixups (picrel
, dinfo
, FALSE
);
4409 bfinfdpic_elf_discard_info (bfd
*ibfd
,
4410 struct elf_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
4411 struct bfd_link_info
*info
)
4413 bfd_boolean changed
= FALSE
;
4417 /* Account for relaxation of .eh_frame section. */
4418 for (s
= ibfd
->sections
; s
; s
= s
->next
)
4419 if (s
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
4421 if (!_bfinfdpic_check_discarded_relocs (ibfd
, s
, info
, &changed
))
4423 obfd
= s
->output_section
->owner
;
4428 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4430 memset (&gpinfo
, 0, sizeof (gpinfo
));
4431 memcpy (&gpinfo
.g
, bfinfdpic_dynamic_got_plt_info (info
),
4434 /* Clear GOT and PLT assignments. */
4435 htab_traverse (bfinfdpic_relocs_info (info
),
4436 _bfinfdpic_reset_got_plt_entries
,
4439 if (!_bfinfdpic_size_got_plt (obfd
, &gpinfo
))
4447 elf32_bfinfdpic_finish_dynamic_sections (bfd
*output_bfd
,
4448 struct bfd_link_info
*info
)
4453 dynobj
= elf_hash_table (info
)->dynobj
;
4455 if (bfinfdpic_got_section (info
))
4457 BFD_ASSERT (bfinfdpic_gotrel_section (info
)->size
4458 /* PR 17334: It appears that the GOT section can end up
4459 being bigger than the number of relocs. Presumably
4460 because some relocs have been deleted. A test case has
4461 yet to be generated for verify this, but in the meantime
4462 the test below has been changed from == to >= so that
4463 applications can continue to be built. */
4464 >= (bfinfdpic_gotrel_section (info
)->reloc_count
4465 * sizeof (Elf32_External_Rel
)));
4467 if (bfinfdpic_gotfixup_section (info
))
4469 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
4470 bfd_vma got_value
= hgot
->root
.u
.def
.value
4471 + hgot
->root
.u
.def
.section
->output_section
->vma
4472 + hgot
->root
.u
.def
.section
->output_offset
;
4474 _bfinfdpic_add_rofixup (output_bfd
, bfinfdpic_gotfixup_section (info
),
4477 if (bfinfdpic_gotfixup_section (info
)->size
4478 != (bfinfdpic_gotfixup_section (info
)->reloc_count
* 4))
4481 ("LINKER BUG: .rofixup section size mismatch");
4486 if (elf_hash_table (info
)->dynamic_sections_created
)
4488 BFD_ASSERT (bfinfdpic_pltrel_section (info
)->size
4489 == (bfinfdpic_pltrel_section (info
)->reloc_count
4490 * sizeof (Elf32_External_Rel
)));
4493 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
4495 if (elf_hash_table (info
)->dynamic_sections_created
)
4497 Elf32_External_Dyn
* dyncon
;
4498 Elf32_External_Dyn
* dynconend
;
4500 BFD_ASSERT (sdyn
!= NULL
);
4502 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4503 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4505 for (; dyncon
< dynconend
; dyncon
++)
4507 Elf_Internal_Dyn dyn
;
4509 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4517 dyn
.d_un
.d_ptr
= bfinfdpic_got_section (info
)->output_section
->vma
4518 + bfinfdpic_got_section (info
)->output_offset
4519 + bfinfdpic_got_initial_offset (info
);
4520 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4524 dyn
.d_un
.d_ptr
= bfinfdpic_pltrel_section (info
)
4525 ->output_section
->vma
4526 + bfinfdpic_pltrel_section (info
)->output_offset
;
4527 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4531 dyn
.d_un
.d_val
= bfinfdpic_pltrel_section (info
)->size
;
4532 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4541 /* Adjust a symbol defined by a dynamic object and referenced by a
4545 elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info
*info
,
4546 struct elf_link_hash_entry
*h
)
4550 dynobj
= elf_hash_table (info
)->dynobj
;
4552 /* Make sure we know what is going on here. */
4553 BFD_ASSERT (dynobj
!= NULL
4554 && (h
->u
.weakdef
!= NULL
4557 && !h
->def_regular
)));
4559 /* If this is a weak symbol, and there is a real definition, the
4560 processor independent code will have arranged for us to see the
4561 real definition first, and we can just use the same value. */
4562 if (h
->u
.weakdef
!= NULL
)
4564 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
4565 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
4566 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
4567 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
4573 /* Perform any actions needed for dynamic symbols. */
4576 elf32_bfinfdpic_finish_dynamic_symbol
4577 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4578 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4579 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
4580 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4585 /* Decide whether to attempt to turn absptr or lsda encodings in
4586 shared libraries into pcrel within the given input section. */
4589 bfinfdpic_elf_use_relative_eh_frame
4590 (bfd
*input_bfd ATTRIBUTE_UNUSED
,
4591 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4592 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
4594 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4598 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4601 bfinfdpic_elf_encode_eh_address (bfd
*abfd
,
4602 struct bfd_link_info
*info
,
4603 asection
*osec
, bfd_vma offset
,
4604 asection
*loc_sec
, bfd_vma loc_offset
,
4607 struct elf_link_hash_entry
*h
;
4609 h
= elf_hash_table (info
)->hgot
;
4610 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
4612 if (! h
|| (_bfinfdpic_osec_to_segment (abfd
, osec
)
4613 == _bfinfdpic_osec_to_segment (abfd
, loc_sec
->output_section
)))
4614 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
4615 loc_sec
, loc_offset
, encoded
);
4617 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd
, osec
)
4618 == (_bfinfdpic_osec_to_segment
4619 (abfd
, h
->root
.u
.def
.section
->output_section
)));
4621 *encoded
= osec
->vma
+ offset
4622 - (h
->root
.u
.def
.value
4623 + h
->root
.u
.def
.section
->output_section
->vma
4624 + h
->root
.u
.def
.section
->output_offset
);
4626 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
4631 /* Look through the relocs for a section during the first phase.
4633 Besides handling virtual table relocs for gc, we have to deal with
4634 all sorts of PIC-related relocations. We describe below the
4635 general plan on how to handle such relocations, even though we only
4636 collect information at this point, storing them in hash tables for
4637 perusal of later passes.
4639 32 relocations are propagated to the linker output when creating
4640 position-independent output. LO16 and HI16 relocations are not
4641 supposed to be encountered in this case.
4643 LABEL16 should always be resolvable by the linker, since it's only
4646 LABEL24, on the other hand, is used by calls. If it turns out that
4647 the target of a call is a dynamic symbol, a PLT entry must be
4648 created for it, which triggers the creation of a private function
4649 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4651 GPREL relocations require the referenced symbol to be in the same
4652 segment as _gp, but this can only be checked later.
4654 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4655 exist. LABEL24 might as well, since it may require a PLT entry,
4656 that will require a got.
4658 Non-FUNCDESC GOT relocations require a GOT entry to be created
4659 regardless of whether the symbol is dynamic. However, since a
4660 global symbol that turns out to not be exported may have the same
4661 address of a non-dynamic symbol, we don't assign GOT entries at
4662 this point, such that we can share them in this case. A relocation
4663 for the GOT entry always has to be created, be it to offset a
4664 private symbol by the section load address, be it to get the symbol
4665 resolved dynamically.
4667 FUNCDESC GOT relocations require a GOT entry to be created, and
4668 handled as if a FUNCDESC relocation was applied to the GOT entry in
4671 FUNCDESC relocations referencing a symbol that turns out to NOT be
4672 dynamic cause a private function descriptor to be created. The
4673 FUNCDESC relocation then decays to a 32 relocation that points at
4674 the private descriptor. If the symbol is dynamic, the FUNCDESC
4675 relocation is propagated to the linker output, such that the
4676 dynamic linker creates the canonical descriptor, pointing to the
4677 dynamically-resolved definition of the function.
4679 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4680 symbols that are assigned to the same segment as the GOT, but we
4681 can only check this later, after we know the complete set of
4682 symbols defined and/or exported.
4684 FUNCDESC GOTOFF relocations require a function descriptor to be
4685 created and, unless lazy binding is disabled or the symbol is not
4686 dynamic, a lazy PLT entry. Since we can't tell at this point
4687 whether a symbol is going to be dynamic, we have to decide later
4688 whether to create a lazy PLT entry or bind the descriptor directly
4689 to the private function.
4691 FUNCDESC_VALUE relocations are not supposed to be present in object
4692 files, but they may very well be simply propagated to the linker
4693 output, since they have no side effect.
4696 A function descriptor always requires a FUNCDESC_VALUE relocation.
4697 Whether it's in .plt.rel or not depends on whether lazy binding is
4698 enabled and on whether the referenced symbol is dynamic.
4700 The existence of a lazy PLT requires the resolverStub lazy PLT
4701 entry to be present.
4704 As for assignment of GOT, PLT and lazy PLT entries, and private
4705 descriptors, we might do them all sequentially, but we can do
4706 better than that. For example, we can place GOT entries and
4707 private function descriptors referenced using 12-bit operands
4708 closer to the PIC register value, such that these relocations don't
4709 overflow. Those that are only referenced with LO16 relocations
4710 could come next, but we may as well place PLT-required function
4711 descriptors in the 12-bit range to make them shorter. Symbols
4712 referenced with LO16/HI16 may come next, but we may place
4713 additional function descriptors in the 16-bit range if we can
4714 reliably tell that we've already placed entries that are ever
4715 referenced with only LO16. PLT entries are therefore generated as
4716 small as possible, while not introducing relocation overflows in
4717 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4718 generated before or after PLT entries, but not intermingled with
4719 them, such that we can have more lazy PLT entries in range for a
4720 branch to the resolverStub. The resolverStub should be emitted at
4721 the most distant location from the first lazy PLT entry such that
4722 it's still in range for a branch, or closer, if there isn't a need
4723 for so many lazy PLT entries. Additional lazy PLT entries may be
4724 emitted after the resolverStub, as long as branches are still in
4725 range. If the branch goes out of range, longer lazy PLT entries
4728 We could further optimize PLT and lazy PLT entries by giving them
4729 priority in assignment to closer-to-gr17 locations depending on the
4730 number of occurrences of references to them (assuming a function
4731 that's called more often is more important for performance, so its
4732 PLT entry should be faster), or taking hints from the compiler.
4733 Given infinite time and money... :-) */
4736 bfinfdpic_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4737 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4739 Elf_Internal_Shdr
*symtab_hdr
;
4740 struct elf_link_hash_entry
**sym_hashes
;
4741 const Elf_Internal_Rela
*rel
;
4742 const Elf_Internal_Rela
*rel_end
;
4744 struct bfinfdpic_relocs_info
*picrel
;
4746 if (bfd_link_relocatable (info
))
4749 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4750 sym_hashes
= elf_sym_hashes (abfd
);
4752 dynobj
= elf_hash_table (info
)->dynobj
;
4753 rel_end
= relocs
+ sec
->reloc_count
;
4754 for (rel
= relocs
; rel
< rel_end
; rel
++)
4756 struct elf_link_hash_entry
*h
;
4757 unsigned long r_symndx
;
4759 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4760 if (r_symndx
< symtab_hdr
->sh_info
)
4763 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4765 switch (ELF32_R_TYPE (rel
->r_info
))
4767 case R_BFIN_GOT17M4
:
4770 case R_BFIN_FUNCDESC_GOT17M4
:
4771 case R_BFIN_FUNCDESC_GOTHI
:
4772 case R_BFIN_FUNCDESC_GOTLO
:
4773 case R_BFIN_GOTOFF17M4
:
4774 case R_BFIN_GOTOFFHI
:
4775 case R_BFIN_GOTOFFLO
:
4776 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4777 case R_BFIN_FUNCDESC_GOTOFFHI
:
4778 case R_BFIN_FUNCDESC_GOTOFFLO
:
4779 case R_BFIN_FUNCDESC
:
4780 case R_BFIN_FUNCDESC_VALUE
:
4781 if (! IS_FDPIC (abfd
))
4784 case R_BFIN_PCREL24
:
4785 case R_BFIN_PCREL24_JUMP_L
:
4786 case R_BFIN_BYTE4_DATA
:
4787 if (IS_FDPIC (abfd
) && ! dynobj
)
4789 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
4790 if (! _bfin_create_got_section (abfd
, info
))
4793 if (! IS_FDPIC (abfd
))
4800 if (h
->dynindx
== -1)
4801 switch (ELF_ST_VISIBILITY (h
->other
))
4807 bfd_elf_link_record_dynamic_symbol (info
, h
);
4811 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4813 rel
->r_addend
, INSERT
);
4816 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4817 (info
), abfd
, r_symndx
,
4818 rel
->r_addend
, INSERT
);
4828 switch (ELF32_R_TYPE (rel
->r_info
))
4830 case R_BFIN_PCREL24
:
4831 case R_BFIN_PCREL24_JUMP_L
:
4832 if (IS_FDPIC (abfd
))
4836 case R_BFIN_FUNCDESC_VALUE
:
4837 picrel
->relocsfdv
++;
4838 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
4842 case R_BFIN_BYTE4_DATA
:
4843 if (! IS_FDPIC (abfd
))
4847 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
4851 case R_BFIN_GOT17M4
:
4860 case R_BFIN_FUNCDESC_GOT17M4
:
4861 picrel
->fdgot17m4
++;
4864 case R_BFIN_FUNCDESC_GOTHI
:
4865 case R_BFIN_FUNCDESC_GOTLO
:
4866 picrel
->fdgothilo
++;
4869 case R_BFIN_GOTOFF17M4
:
4870 case R_BFIN_GOTOFFHI
:
4871 case R_BFIN_GOTOFFLO
:
4875 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4876 picrel
->fdgoff17m4
++;
4879 case R_BFIN_FUNCDESC_GOTOFFHI
:
4880 case R_BFIN_FUNCDESC_GOTOFFLO
:
4881 picrel
->fdgoffhilo
++;
4884 case R_BFIN_FUNCDESC
:
4889 /* This relocation describes the C++ object vtable hierarchy.
4890 Reconstruct it for later use during GC. */
4891 case R_BFIN_GNU_VTINHERIT
:
4892 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4896 /* This relocation describes which C++ vtable entries are actually
4897 used. Record for later use during GC. */
4898 case R_BFIN_GNU_VTENTRY
:
4899 BFD_ASSERT (h
!= NULL
);
4901 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4905 case R_BFIN_HUIMM16
:
4906 case R_BFIN_LUIMM16
:
4907 case R_BFIN_PCREL12_JUMP_S
:
4908 case R_BFIN_PCREL10
:
4914 /* xgettext:c-format */
4915 (_("%B: unsupported relocation type %i"),
4916 abfd
, ELF32_R_TYPE (rel
->r_info
));
4924 /* Set the right machine number for a Blackfin ELF file. */
4927 elf32_bfin_object_p (bfd
*abfd
)
4929 bfd_default_set_arch_mach (abfd
, bfd_arch_bfin
, 0);
4930 return (((elf_elfheader (abfd
)->e_flags
& EF_BFIN_FDPIC
) != 0)
4931 == (IS_FDPIC (abfd
)));
4935 elf32_bfin_set_private_flags (bfd
* abfd
, flagword flags
)
4937 elf_elfheader (abfd
)->e_flags
= flags
;
4938 elf_flags_init (abfd
) = TRUE
;
4942 /* Display the flags field. */
4944 elf32_bfin_print_private_bfd_data (bfd
* abfd
, void * ptr
)
4946 FILE *file
= (FILE *) ptr
;
4949 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4951 /* Print normal ELF private data. */
4952 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4954 flags
= elf_elfheader (abfd
)->e_flags
;
4956 /* xgettext:c-format */
4957 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4959 if (flags
& EF_BFIN_PIC
)
4960 fprintf (file
, " -fpic");
4962 if (flags
& EF_BFIN_FDPIC
)
4963 fprintf (file
, " -mfdpic");
4970 /* Merge backend specific data from an object file to the output
4971 object file when linking. */
4974 elf32_bfin_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
4976 bfd
*obfd
= info
->output_bfd
;
4977 flagword old_flags
, new_flags
;
4978 bfd_boolean error
= FALSE
;
4980 new_flags
= elf_elfheader (ibfd
)->e_flags
;
4981 old_flags
= elf_elfheader (obfd
)->e_flags
;
4983 if (new_flags
& EF_BFIN_FDPIC
)
4984 new_flags
&= ~EF_BFIN_PIC
;
4990 ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4991 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
4992 bfd_get_filename (ibfd
));
4994 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
4996 elf_flags_init (obfd
) = TRUE
;
4997 elf_elfheader (obfd
)->e_flags
= new_flags
;
5000 if (((new_flags
& EF_BFIN_FDPIC
) == 0) != (! IS_FDPIC (obfd
)))
5003 if (IS_FDPIC (obfd
))
5005 (_("%s: cannot link non-fdpic object file into fdpic executable"),
5006 bfd_get_filename (ibfd
));
5009 (_("%s: cannot link fdpic object file into non-fdpic executable"),
5010 bfd_get_filename (ibfd
));
5014 bfd_set_error (bfd_error_bad_value
);
5019 /* bfin ELF linker hash entry. */
5021 struct bfin_link_hash_entry
5023 struct elf_link_hash_entry root
;
5025 /* Number of PC relative relocs copied for this symbol. */
5026 struct bfin_pcrel_relocs_copied
*pcrel_relocs_copied
;
5029 /* bfin ELF linker hash table. */
5031 struct bfin_link_hash_table
5033 struct elf_link_hash_table root
;
5035 /* Small local sym cache. */
5036 struct sym_cache sym_cache
;
5039 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
5041 static struct bfd_hash_entry
*
5042 bfin_link_hash_newfunc (struct bfd_hash_entry
*entry
,
5043 struct bfd_hash_table
*table
, const char *string
)
5045 struct bfd_hash_entry
*ret
= entry
;
5047 /* Allocate the structure if it has not already been allocated by a
5050 ret
= bfd_hash_allocate (table
, sizeof (struct bfin_link_hash_entry
));
5054 /* Call the allocation method of the superclass. */
5055 ret
= _bfd_elf_link_hash_newfunc (ret
, table
, string
);
5057 bfin_hash_entry (ret
)->pcrel_relocs_copied
= NULL
;
5062 /* Create an bfin ELF linker hash table. */
5064 static struct bfd_link_hash_table
*
5065 bfin_link_hash_table_create (bfd
* abfd
)
5067 struct bfin_link_hash_table
*ret
;
5068 bfd_size_type amt
= sizeof (struct bfin_link_hash_table
);
5070 ret
= bfd_zmalloc (amt
);
5074 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
5075 bfin_link_hash_newfunc
,
5076 sizeof (struct elf_link_hash_entry
),
5083 ret
->sym_cache
.abfd
= NULL
;
5085 return &ret
->root
.root
;
5088 /* The size in bytes of an entry in the procedure linkage table. */
5090 /* Finish up the dynamic sections. */
5093 bfin_finish_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5094 struct bfd_link_info
*info
)
5099 dynobj
= elf_hash_table (info
)->dynobj
;
5101 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5103 if (elf_hash_table (info
)->dynamic_sections_created
)
5105 Elf32_External_Dyn
*dyncon
, *dynconend
;
5107 BFD_ASSERT (sdyn
!= NULL
);
5109 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5110 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5111 for (; dyncon
< dynconend
; dyncon
++)
5113 Elf_Internal_Dyn dyn
;
5115 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5123 /* Finish up dynamic symbol handling. We set the contents of various
5124 dynamic sections here. */
5127 bfin_finish_dynamic_symbol (bfd
* output_bfd
,
5128 struct bfd_link_info
*info
,
5129 struct elf_link_hash_entry
*h
,
5130 Elf_Internal_Sym
* sym
)
5134 dynobj
= elf_hash_table (info
)->dynobj
;
5136 if (h
->got
.offset
!= (bfd_vma
) - 1)
5140 Elf_Internal_Rela rela
;
5143 /* This symbol has an entry in the global offset table.
5146 sgot
= bfd_get_linker_section (dynobj
, ".got");
5147 srela
= bfd_get_linker_section (dynobj
, ".rela.got");
5148 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
5150 rela
.r_offset
= (sgot
->output_section
->vma
5151 + sgot
->output_offset
5152 + (h
->got
.offset
& ~(bfd_vma
) 1));
5154 /* If this is a -Bsymbolic link, and the symbol is defined
5155 locally, we just want to emit a RELATIVE reloc. Likewise if
5156 the symbol was forced to be local because of a version file.
5157 The entry in the global offset table will already have been
5158 initialized in the relocate_section function. */
5159 if (bfd_link_pic (info
)
5161 || h
->dynindx
== -1 || h
->forced_local
) && h
->def_regular
)
5163 _bfd_error_handler (_("*** check this relocation %s"),
5165 rela
.r_info
= ELF32_R_INFO (0, R_BFIN_PCREL24
);
5166 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
5170 offset
& ~(bfd_vma
) 1)));
5174 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5175 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
5176 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_BFIN_GOT
);
5180 loc
= srela
->contents
;
5181 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5182 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5189 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5190 if (strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
5191 || h
== elf_hash_table (info
)->hgot
)
5192 sym
->st_shndx
= SHN_ABS
;
5197 /* Adjust a symbol defined by a dynamic object and referenced by a
5198 regular object. The current definition is in some section of the
5199 dynamic object, but we're not including those sections. We have to
5200 change the definition to something the rest of the link can
5204 bfin_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5205 struct elf_link_hash_entry
*h
)
5209 unsigned int power_of_two
;
5211 dynobj
= elf_hash_table (info
)->dynobj
;
5213 /* Make sure we know what is going on here. */
5214 BFD_ASSERT (dynobj
!= NULL
5216 || h
->u
.weakdef
!= NULL
5217 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
5219 /* If this is a function, put it in the procedure linkage table. We
5220 will fill in the contents of the procedure linkage table later,
5221 when we know the address of the .got section. */
5222 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
5227 /* If this is a weak symbol, and there is a real definition, the
5228 processor independent code will have arranged for us to see the
5229 real definition first, and we can just use the same value. */
5230 if (h
->u
.weakdef
!= NULL
)
5232 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
5233 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
5234 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
5235 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
5239 /* This is a reference to a symbol defined by a dynamic object which
5240 is not a function. */
5242 /* If we are creating a shared library, we must presume that the
5243 only references to the symbol are via the global offset table.
5244 For such cases we need not do anything here; the relocations will
5245 be handled correctly by relocate_section. */
5246 if (bfd_link_pic (info
))
5249 /* We must allocate the symbol in our .dynbss section, which will
5250 become part of the .bss section of the executable. There will be
5251 an entry for this symbol in the .dynsym section. The dynamic
5252 object will contain position independent code, so all references
5253 from the dynamic object to this symbol will go through the global
5254 offset table. The dynamic linker will use the .dynsym entry to
5255 determine the address it must put in the global offset table, so
5256 both the dynamic object and the regular object will refer to the
5257 same memory location for the variable. */
5259 s
= bfd_get_linker_section (dynobj
, ".dynbss");
5260 BFD_ASSERT (s
!= NULL
);
5262 #if 0 /* Bfin does not currently have a COPY reloc. */
5263 /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5264 copy the initial value out of the dynamic object and into the
5265 runtime process image. We need to remember the offset into the
5266 .rela.bss section we are going to use. */
5267 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5271 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
5272 BFD_ASSERT (srel
!= NULL
);
5273 srel
->size
+= sizeof (Elf32_External_Rela
);
5277 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5279 _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5283 /* We need to figure out the alignment required for this symbol. I
5284 have no idea how ELF linkers handle this. */
5285 power_of_two
= bfd_log2 (h
->size
);
5286 if (power_of_two
> 3)
5289 /* Apply the required alignment. */
5290 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
5291 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
5293 if (!bfd_set_section_alignment (dynobj
, s
, power_of_two
))
5297 /* Define the symbol as being at this point in the section. */
5298 h
->root
.u
.def
.section
= s
;
5299 h
->root
.u
.def
.value
= s
->size
;
5301 /* Increment the section size to make room for the symbol. */
5307 /* The bfin linker needs to keep track of the number of relocs that it
5308 decides to copy in check_relocs for each symbol. This is so that it
5309 can discard PC relative relocs if it doesn't need them when linking
5310 with -Bsymbolic. We store the information in a field extending the
5311 regular ELF linker hash table. */
5313 /* This structure keeps track of the number of PC relative relocs we have
5314 copied for a given symbol. */
5316 struct bfin_pcrel_relocs_copied
5319 struct bfin_pcrel_relocs_copied
*next
;
5320 /* A section in dynobj. */
5322 /* Number of relocs copied in this section. */
5323 bfd_size_type count
;
5326 /* This function is called via elf_link_hash_traverse if we are
5327 creating a shared object. In the -Bsymbolic case it discards the
5328 space allocated to copy PC relative relocs against symbols which
5329 are defined in regular objects. For the normal shared case, it
5330 discards space for pc-relative relocs that have become local due to
5331 symbol visibility changes. We allocated space for them in the
5332 check_relocs routine, but we won't fill them in in the
5333 relocate_section routine.
5335 We also check whether any of the remaining relocations apply
5336 against a readonly section, and set the DF_TEXTREL flag in this
5340 bfin_discard_copies (struct elf_link_hash_entry
*h
, void * inf
)
5342 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5343 struct bfin_pcrel_relocs_copied
*s
;
5345 if (!h
->def_regular
|| (!info
->symbolic
&& !h
->forced_local
))
5347 if ((info
->flags
& DF_TEXTREL
) == 0)
5349 /* Look for relocations against read-only sections. */
5350 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5351 s
!= NULL
; s
= s
->next
)
5352 if ((s
->section
->flags
& SEC_READONLY
) != 0)
5354 info
->flags
|= DF_TEXTREL
;
5362 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5363 s
!= NULL
; s
= s
->next
)
5364 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
5370 bfin_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5371 struct bfd_link_info
*info
)
5377 dynobj
= elf_hash_table (info
)->dynobj
;
5378 BFD_ASSERT (dynobj
!= NULL
);
5380 if (elf_hash_table (info
)->dynamic_sections_created
)
5382 /* Set the contents of the .interp section to the interpreter. */
5383 if (bfd_link_executable (info
))
5385 s
= bfd_get_linker_section (dynobj
, ".interp");
5386 BFD_ASSERT (s
!= NULL
);
5387 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5388 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5393 /* We may have created entries in the .rela.got section.
5394 However, if we are not creating the dynamic sections, we will
5395 not actually use these entries. Reset the size of .rela.got,
5396 which will cause it to get stripped from the output file
5398 s
= bfd_get_linker_section (dynobj
, ".rela.got");
5403 /* If this is a -Bsymbolic shared link, then we need to discard all
5404 PC relative relocs against symbols defined in a regular object.
5405 For the normal shared case we discard the PC relative relocs
5406 against symbols that have become local due to visibility changes.
5407 We allocated space for them in the check_relocs routine, but we
5408 will not fill them in in the relocate_section routine. */
5409 if (bfd_link_pic (info
))
5410 elf_link_hash_traverse (elf_hash_table (info
),
5411 bfin_discard_copies
, info
);
5413 /* The check_relocs and adjust_dynamic_symbol entry points have
5414 determined the sizes of the various dynamic sections. Allocate
5417 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5422 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5425 /* It's OK to base decisions on the section name, because none
5426 of the dynobj section names depend upon the input files. */
5427 name
= bfd_get_section_name (dynobj
, s
);
5431 if (CONST_STRNEQ (name
, ".rela"))
5435 /* If we don't need this section, strip it from the
5436 output file. This is mostly to handle .rela.bss and
5437 .rela.plt. We must create both sections in
5438 create_dynamic_sections, because they must be created
5439 before the linker maps input sections to output
5440 sections. The linker does that before
5441 adjust_dynamic_symbol is called, and it is that
5442 function which decides whether anything needs to go
5443 into these sections. */
5450 /* We use the reloc_count field as a counter if we need
5451 to copy relocs into the output file. */
5455 else if (! CONST_STRNEQ (name
, ".got"))
5457 /* It's not one of our sections, so don't allocate space. */
5463 s
->flags
|= SEC_EXCLUDE
;
5467 /* Allocate memory for the section contents. */
5468 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5469 Unused entries should be reclaimed before the section's contents
5470 are written out, but at the moment this does not happen. Thus in
5471 order to prevent writing out garbage, we initialise the section's
5472 contents to zero. */
5473 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5474 if (s
->contents
== NULL
&& s
->size
!= 0)
5478 if (elf_hash_table (info
)->dynamic_sections_created
)
5480 /* Add some entries to the .dynamic section. We fill in the
5481 values later, in bfin_finish_dynamic_sections, but we
5482 must add the entries now so that we get the correct size for
5483 the .dynamic section. The DT_DEBUG entry is filled in by the
5484 dynamic linker and used by the debugger. */
5485 #define add_dynamic_entry(TAG, VAL) \
5486 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5488 if (!bfd_link_pic (info
))
5490 if (!add_dynamic_entry (DT_DEBUG
, 0))
5497 if (!add_dynamic_entry (DT_RELA
, 0)
5498 || !add_dynamic_entry (DT_RELASZ
, 0)
5499 || !add_dynamic_entry (DT_RELAENT
,
5500 sizeof (Elf32_External_Rela
)))
5504 if ((info
->flags
& DF_TEXTREL
) != 0)
5506 if (!add_dynamic_entry (DT_TEXTREL
, 0))
5510 #undef add_dynamic_entry
5515 /* Given a .data section and a .emreloc in-memory section, store
5516 relocation information into the .emreloc section which can be
5517 used at runtime to relocate the section. This is called by the
5518 linker when the --embedded-relocs switch is used. This is called
5519 after the add_symbols entry point has been called for all the
5520 objects, and before the final_link entry point is called. */
5523 bfd_bfin_elf32_create_embedded_relocs (bfd
*abfd
,
5524 struct bfd_link_info
*info
,
5529 Elf_Internal_Shdr
*symtab_hdr
;
5530 Elf_Internal_Sym
*isymbuf
= NULL
;
5531 Elf_Internal_Rela
*internal_relocs
= NULL
;
5532 Elf_Internal_Rela
*irel
, *irelend
;
5536 BFD_ASSERT (! bfd_link_relocatable (info
));
5540 if (datasec
->reloc_count
== 0)
5543 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5545 /* Get a copy of the native relocations. */
5546 internal_relocs
= (_bfd_elf_link_read_relocs
5547 (abfd
, datasec
, NULL
, (Elf_Internal_Rela
*) NULL
,
5548 info
->keep_memory
));
5549 if (internal_relocs
== NULL
)
5552 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
5553 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
5554 if (relsec
->contents
== NULL
)
5557 p
= relsec
->contents
;
5559 irelend
= internal_relocs
+ datasec
->reloc_count
;
5560 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
5562 asection
*targetsec
;
5564 /* We are going to write a four byte longword into the runtime
5565 reloc section. The longword will be the address in the data
5566 section which must be relocated. It is followed by the name
5567 of the target section NUL-padded or truncated to 8
5570 /* We can only relocate absolute longword relocs at run time. */
5571 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_BFIN_BYTE4_DATA
)
5573 *errmsg
= _("unsupported reloc type");
5574 bfd_set_error (bfd_error_bad_value
);
5578 /* Get the target section referred to by the reloc. */
5579 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
5581 /* A local symbol. */
5582 Elf_Internal_Sym
*isym
;
5584 /* Read this BFD's local symbols if we haven't done so already. */
5585 if (isymbuf
== NULL
)
5587 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5588 if (isymbuf
== NULL
)
5589 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5590 symtab_hdr
->sh_info
, 0,
5592 if (isymbuf
== NULL
)
5596 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
5597 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5602 struct elf_link_hash_entry
*h
;
5604 /* An external symbol. */
5605 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
5606 h
= elf_sym_hashes (abfd
)[indx
];
5607 BFD_ASSERT (h
!= NULL
);
5608 if (h
->root
.type
== bfd_link_hash_defined
5609 || h
->root
.type
== bfd_link_hash_defweak
)
5610 targetsec
= h
->root
.u
.def
.section
;
5615 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
5616 memset (p
+ 4, 0, 8);
5617 if (targetsec
!= NULL
)
5618 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
5621 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5623 if (internal_relocs
!= NULL
5624 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
5625 free (internal_relocs
);
5629 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5631 if (internal_relocs
!= NULL
5632 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
5633 free (internal_relocs
);
5637 struct bfd_elf_special_section
const elf32_bfin_special_sections
[] =
5639 { ".l1.text", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5640 { ".l1.data", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
5641 { NULL
, 0, 0, 0, 0 }
5645 #define TARGET_LITTLE_SYM bfin_elf32_vec
5646 #define TARGET_LITTLE_NAME "elf32-bfin"
5647 #define ELF_ARCH bfd_arch_bfin
5648 #define ELF_TARGET_ID BFIN_ELF_DATA
5649 #define ELF_MACHINE_CODE EM_BLACKFIN
5650 #define ELF_MAXPAGESIZE 0x1000
5651 #define elf_symbol_leading_char '_'
5653 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5654 #define bfd_elf32_bfd_reloc_name_lookup \
5655 bfin_bfd_reloc_name_lookup
5656 #define elf_info_to_howto bfin_info_to_howto
5657 #define elf_info_to_howto_rel 0
5658 #define elf_backend_object_p elf32_bfin_object_p
5660 #define bfd_elf32_bfd_is_local_label_name \
5661 bfin_is_local_label_name
5662 #define bfin_hash_table(p) \
5663 ((struct bfin_link_hash_table *) (p)->hash)
5667 #define elf_backend_create_dynamic_sections \
5668 _bfd_elf_create_dynamic_sections
5669 #define bfd_elf32_bfd_link_hash_table_create \
5670 bfin_link_hash_table_create
5671 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5673 #define elf_backend_check_relocs bfin_check_relocs
5674 #define elf_backend_adjust_dynamic_symbol \
5675 bfin_adjust_dynamic_symbol
5676 #define elf_backend_size_dynamic_sections \
5677 bfin_size_dynamic_sections
5678 #define elf_backend_relocate_section bfin_relocate_section
5679 #define elf_backend_finish_dynamic_symbol \
5680 bfin_finish_dynamic_symbol
5681 #define elf_backend_finish_dynamic_sections \
5682 bfin_finish_dynamic_sections
5683 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5684 #define elf_backend_gc_sweep_hook bfin_gc_sweep_hook
5685 #define bfd_elf32_bfd_merge_private_bfd_data \
5686 elf32_bfin_merge_private_bfd_data
5687 #define bfd_elf32_bfd_set_private_flags \
5688 elf32_bfin_set_private_flags
5689 #define bfd_elf32_bfd_print_private_bfd_data \
5690 elf32_bfin_print_private_bfd_data
5691 #define elf_backend_final_write_processing \
5692 elf32_bfin_final_write_processing
5693 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5694 #define elf_backend_stack_align 8
5695 #define elf_backend_can_gc_sections 1
5696 #define elf_backend_special_sections elf32_bfin_special_sections
5697 #define elf_backend_can_refcount 1
5698 #define elf_backend_want_got_plt 0
5699 #define elf_backend_plt_readonly 1
5700 #define elf_backend_want_plt_sym 0
5701 #define elf_backend_got_header_size 12
5702 #define elf_backend_rela_normal 1
5704 #include "elf32-target.h"
5706 #undef TARGET_LITTLE_SYM
5707 #define TARGET_LITTLE_SYM bfin_elf32_fdpic_vec
5708 #undef TARGET_LITTLE_NAME
5709 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5711 #define elf32_bed elf32_bfinfdpic_bed
5713 #undef elf_backend_gc_sweep_hook
5714 #define elf_backend_gc_sweep_hook bfinfdpic_gc_sweep_hook
5716 #undef elf_backend_got_header_size
5717 #define elf_backend_got_header_size 0
5719 #undef elf_backend_relocate_section
5720 #define elf_backend_relocate_section bfinfdpic_relocate_section
5721 #undef elf_backend_check_relocs
5722 #define elf_backend_check_relocs bfinfdpic_check_relocs
5724 #undef bfd_elf32_bfd_link_hash_table_create
5725 #define bfd_elf32_bfd_link_hash_table_create \
5726 bfinfdpic_elf_link_hash_table_create
5727 #undef elf_backend_always_size_sections
5728 #define elf_backend_always_size_sections \
5729 elf32_bfinfdpic_always_size_sections
5731 #undef elf_backend_create_dynamic_sections
5732 #define elf_backend_create_dynamic_sections \
5733 elf32_bfinfdpic_create_dynamic_sections
5734 #undef elf_backend_adjust_dynamic_symbol
5735 #define elf_backend_adjust_dynamic_symbol \
5736 elf32_bfinfdpic_adjust_dynamic_symbol
5737 #undef elf_backend_size_dynamic_sections
5738 #define elf_backend_size_dynamic_sections \
5739 elf32_bfinfdpic_size_dynamic_sections
5740 #undef elf_backend_finish_dynamic_symbol
5741 #define elf_backend_finish_dynamic_symbol \
5742 elf32_bfinfdpic_finish_dynamic_symbol
5743 #undef elf_backend_finish_dynamic_sections
5744 #define elf_backend_finish_dynamic_sections \
5745 elf32_bfinfdpic_finish_dynamic_sections
5747 #undef elf_backend_discard_info
5748 #define elf_backend_discard_info \
5749 bfinfdpic_elf_discard_info
5750 #undef elf_backend_can_make_relative_eh_frame
5751 #define elf_backend_can_make_relative_eh_frame \
5752 bfinfdpic_elf_use_relative_eh_frame
5753 #undef elf_backend_can_make_lsda_relative_eh_frame
5754 #define elf_backend_can_make_lsda_relative_eh_frame \
5755 bfinfdpic_elf_use_relative_eh_frame
5756 #undef elf_backend_encode_eh_address
5757 #define elf_backend_encode_eh_address \
5758 bfinfdpic_elf_encode_eh_address
5760 #undef elf_backend_may_use_rel_p
5761 #define elf_backend_may_use_rel_p 1
5762 #undef elf_backend_may_use_rela_p
5763 #define elf_backend_may_use_rela_p 1
5764 /* We use REL for dynamic relocations only. */
5765 #undef elf_backend_default_use_rela_p
5766 #define elf_backend_default_use_rela_p 1
5768 #undef elf_backend_omit_section_dynsym
5769 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5771 #include "elf32-target.h"