1 /* ADI Blackfin BFD support for 32-bit ELF.
2 Copyright 2005, 2006, 2007 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. */
26 #include "elf/dwarf2.h"
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 PTR 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 fprintf(stderr
, "relocation should be even number\n");
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 fprintf(stderr
, "relocation should be even number\n");
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_unused0
, /* type. */
426 2, /* size (0 = byte, 1 = short, 2 = long). */
428 FALSE
, /* pc_relative. */
430 complain_overflow_bitfield
, /* complain_on_overflow. */
431 bfd_elf_generic_reloc
, /* special_function. */
432 "R_unused0", /* name. */
433 FALSE
, /* partial_inplace. */
436 FALSE
), /* pcrel_offset. */
438 HOWTO (R_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_pcrel5m2", /* name. */
447 FALSE
, /* partial_inplace. */
449 0x0000000F, /* dst_mask. */
450 FALSE
), /* pcrel_offset. */
452 HOWTO (R_unused1
, /* type. */
454 2, /* size (0 = byte, 1 = short, 2 = long). */
456 FALSE
, /* pc_relative. */
458 complain_overflow_bitfield
, /* complain_on_overflow. */
459 bfd_elf_generic_reloc
, /* special_function. */
460 "R_unused1", /* name. */
461 FALSE
, /* partial_inplace. */
464 FALSE
), /* pcrel_offset. */
466 HOWTO (R_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_pcrel10", /* name. */
475 FALSE
, /* partial_inplace. */
477 0x000003FF, /* dst_mask. */
478 TRUE
), /* pcrel_offset. */
480 HOWTO (R_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_pcrel12_jump", /* name. */
493 FALSE
, /* partial_inplace. */
495 0x0FFF, /* dst_mask. */
496 TRUE
), /* pcrel_offset. */
498 HOWTO (R_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_rimm16", /* name. */
507 FALSE
, /* partial_inplace. */
509 0x0000FFFF, /* dst_mask. */
510 TRUE
), /* pcrel_offset. */
512 HOWTO (R_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_luimm16", /* name. */
521 FALSE
, /* partial_inplace. */
523 0x0000FFFF, /* dst_mask. */
524 TRUE
), /* pcrel_offset. */
526 HOWTO (R_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_huimm16", /* name. */
535 FALSE
, /* partial_inplace. */
537 0x0000FFFF, /* dst_mask. */
538 TRUE
), /* pcrel_offset. */
540 HOWTO (R_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_pcrel12_jump_s", /* name. */
549 FALSE
, /* partial_inplace. */
551 0x00000FFF, /* dst_mask. */
552 TRUE
), /* pcrel_offset. */
554 HOWTO (R_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_pcrel24_jump_x", /* name. */
563 FALSE
, /* partial_inplace. */
565 0x00FFFFFF, /* dst_mask. */
566 TRUE
), /* pcrel_offset. */
568 HOWTO (R_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_pcrel24", /* name. */
577 FALSE
, /* partial_inplace. */
579 0x00FFFFFF, /* dst_mask. */
580 TRUE
), /* pcrel_offset. */
582 HOWTO (R_unusedb
, /* type. */
584 2, /* 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_unusedb", /* name. */
591 FALSE
, /* partial_inplace. */
594 FALSE
), /* pcrel_offset. */
596 HOWTO (R_unusedc
, /* type. */
598 2, /* 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_unusedc", /* name. */
605 FALSE
, /* partial_inplace. */
608 FALSE
), /* pcrel_offset. */
610 HOWTO (R_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_pcrel24_jump_l", /* name. */
619 FALSE
, /* partial_inplace. */
621 0x00FFFFFF, /* dst_mask. */
622 TRUE
), /* pcrel_offset. */
624 HOWTO (R_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_pcrel24_call_x", /* name. */
633 FALSE
, /* partial_inplace. */
635 0x00FFFFFF, /* dst_mask. */
636 TRUE
), /* pcrel_offset. */
638 HOWTO (R_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_var_eq_symb", /* name. */
647 FALSE
, /* partial_inplace. */
650 FALSE
), /* pcrel_offset. */
652 HOWTO (R_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_byte_data", /* name. */
661 FALSE
, /* partial_inplace. */
663 0xFF, /* dst_mask. */
664 TRUE
), /* pcrel_offset. */
666 HOWTO (R_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_byte2_data", /* name. */
675 FALSE
, /* partial_inplace. */
677 0xFFFF, /* dst_mask. */
678 TRUE
), /* pcrel_offset. */
680 HOWTO (R_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_byte4_data", /* name. */
689 FALSE
, /* partial_inplace. */
691 0xFFFFFFFF, /* dst_mask. */
692 TRUE
), /* pcrel_offset. */
694 HOWTO (R_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_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_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_pltpc", /* name. */
943 FALSE
, /* partial_inplace. */
944 0xffff, /* src_mask. */
945 0xffff, /* dst_mask. */
946 FALSE
), /* pcrel_offset. */
948 HOWTO (R_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. */
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_unused0
},
1002 { BFD_RELOC_BFIN_5_PCREL
, R_pcrel5m2
},
1003 { BFD_RELOC_NONE
, R_unused1
},
1004 { BFD_RELOC_BFIN_10_PCREL
, R_pcrel10
},
1005 { BFD_RELOC_BFIN_12_PCREL_JUMP
, R_pcrel12_jump
},
1006 { BFD_RELOC_BFIN_16_IMM
, R_rimm16
},
1007 { BFD_RELOC_BFIN_16_LOW
, R_luimm16
},
1008 { BFD_RELOC_BFIN_16_HIGH
, R_huimm16
},
1009 { BFD_RELOC_BFIN_12_PCREL_JUMP_S
, R_pcrel12_jump_s
},
1010 { BFD_RELOC_24_PCREL
, R_pcrel24
},
1011 { BFD_RELOC_24_PCREL
, R_pcrel24
},
1012 { BFD_RELOC_BFIN_24_PCREL_JUMP_L
, R_pcrel24_jump_l
},
1013 { BFD_RELOC_NONE
, R_unusedb
},
1014 { BFD_RELOC_NONE
, R_unusedc
},
1015 { BFD_RELOC_BFIN_24_PCREL_CALL_X
, R_pcrel24_call_x
},
1016 { BFD_RELOC_8
, R_byte_data
},
1017 { BFD_RELOC_16
, R_byte2_data
},
1018 { BFD_RELOC_32
, R_byte4_data
},
1019 { BFD_RELOC_BFIN_11_PCREL
, R_pcrel11
},
1020 { BFD_RELOC_BFIN_GOT
, R_got
},
1021 { BFD_RELOC_BFIN_PLTPC
, R_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
= BFIN_RELOC_MIN
;
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
&& r_type
> BFIN_RELOC_MIN
)
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 (
1142 bfd
*abfd ATTRIBUTE_UNUSED
,
1145 if (label
[0] == 'L' && label
[1] == '$' )
1148 return _bfd_elf_is_local_label_name (abfd
, label
);
1151 extern const bfd_target bfd_elf32_bfinfdpic_vec
;
1152 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_bfinfdpic_vec)
1154 /* An extension of the elf hash table data structure, containing some
1155 additional Blackfin-specific data. */
1156 struct bfinfdpic_elf_link_hash_table
1158 struct elf_link_hash_table elf
;
1160 /* A pointer to the .got section. */
1162 /* A pointer to the .rel.got section. */
1164 /* A pointer to the .rofixup section. */
1165 asection
*sgotfixup
;
1166 /* A pointer to the .plt section. */
1168 /* A pointer to the .rel.plt section. */
1170 /* GOT base offset. */
1172 /* Location of the first non-lazy PLT entry, i.e., the number of
1173 bytes taken by lazy PLT entries. */
1175 /* A hash table holding information about which symbols were
1176 referenced with which PIC-related relocations. */
1177 struct htab
*relocs_info
;
1180 /* Get the Blackfin ELF linker hash table from a link_info structure. */
1182 #define bfinfdpic_hash_table(info) \
1183 ((struct bfinfdpic_elf_link_hash_table *) ((info)->hash))
1185 #define bfinfdpic_got_section(info) \
1186 (bfinfdpic_hash_table (info)->sgot)
1187 #define bfinfdpic_gotrel_section(info) \
1188 (bfinfdpic_hash_table (info)->sgotrel)
1189 #define bfinfdpic_gotfixup_section(info) \
1190 (bfinfdpic_hash_table (info)->sgotfixup)
1191 #define bfinfdpic_plt_section(info) \
1192 (bfinfdpic_hash_table (info)->splt)
1193 #define bfinfdpic_pltrel_section(info) \
1194 (bfinfdpic_hash_table (info)->spltrel)
1195 #define bfinfdpic_relocs_info(info) \
1196 (bfinfdpic_hash_table (info)->relocs_info)
1197 #define bfinfdpic_got_initial_offset(info) \
1198 (bfinfdpic_hash_table (info)->got0)
1199 #define bfinfdpic_plt_initial_offset(info) \
1200 (bfinfdpic_hash_table (info)->plt0)
1202 /* Create a Blackfin ELF linker hash table. */
1204 static struct bfd_link_hash_table
*
1205 bfinfdpic_elf_link_hash_table_create (bfd
*abfd
)
1207 struct bfinfdpic_elf_link_hash_table
*ret
;
1208 bfd_size_type amt
= sizeof (struct bfinfdpic_elf_link_hash_table
);
1210 ret
= bfd_zalloc (abfd
, amt
);
1214 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
1215 _bfd_elf_link_hash_newfunc
,
1216 sizeof (struct elf_link_hash_entry
)))
1222 return &ret
->elf
.root
;
1225 /* Decide whether a reference to a symbol can be resolved locally or
1226 not. If the symbol is protected, we want the local address, but
1227 its function descriptor must be assigned by the dynamic linker. */
1228 #define BFINFDPIC_SYM_LOCAL(INFO, H) \
1229 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1230 || ! elf_hash_table (INFO)->dynamic_sections_created)
1231 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1232 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1234 /* This structure collects information on what kind of GOT, PLT or
1235 function descriptors are required by relocations that reference a
1237 struct bfinfdpic_relocs_info
1239 /* The index of the symbol, as stored in the relocation r_info, if
1240 we have a local symbol; -1 otherwise. */
1244 /* The input bfd in which the symbol is defined, if it's a local
1247 /* If symndx == -1, the hash table entry corresponding to a global
1248 symbol (even if it turns out to bind locally, in which case it
1249 should ideally be replaced with section's symndx + addend). */
1250 struct elf_link_hash_entry
*h
;
1252 /* The addend of the relocation that references the symbol. */
1255 /* The fields above are used to identify an entry. The fields below
1256 contain information on how an entry is used and, later on, which
1257 locations it was assigned. */
1258 /* The following 2 fields record whether the symbol+addend above was
1259 ever referenced with a GOT relocation. The 17M4 suffix indicates a
1260 GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs. */
1263 /* Whether a FUNCDESC relocation references symbol+addend. */
1265 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1268 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1269 unsigned fdgoff17m4
;
1270 unsigned fdgoffhilo
;
1271 /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1272 GOTOFFHI relocations. The addend doesn't really matter, since we
1273 envision that this will only be used to check whether the symbol
1274 is mapped to the same segment as the got. */
1276 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1278 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1281 /* Whether we need a PLT entry for a symbol. Should be implied by
1283 (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)) */
1285 /* Whether a function descriptor should be created in this link unit
1286 for symbol+addend. Should be implied by something like:
1287 (plt || fdgotoff17m4 || fdgotofflohi
1288 || ((fd || fdgot17m4 || fdgothilo)
1289 && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1291 /* Whether a lazy PLT entry is needed for this symbol+addend.
1292 Should be implied by something like:
1293 (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1294 && ! (info->flags & DF_BIND_NOW)) */
1296 /* Whether we've already emitted GOT relocations and PLT entries as
1297 needed for this symbol. */
1300 /* The number of R_byte4_data, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1301 relocations referencing the symbol. */
1302 unsigned relocs32
, relocsfd
, relocsfdv
;
1304 /* The number of .rofixups entries and dynamic relocations allocated
1305 for this symbol, minus any that might have already been used. */
1306 unsigned fixups
, dynrelocs
;
1308 /* The offsets of the GOT entries assigned to symbol+addend, to the
1309 function descriptor's address, and to a function descriptor,
1310 respectively. Should be zero if unassigned. The offsets are
1311 counted from the value that will be assigned to the PIC register,
1312 not from the beginning of the .got section. */
1313 bfd_signed_vma got_entry
, fdgot_entry
, fd_entry
;
1314 /* The offsets of the PLT entries assigned to symbol+addend,
1315 non-lazy and lazy, respectively. If unassigned, should be
1317 bfd_vma plt_entry
, lzplt_entry
;
1320 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry. */
1322 bfinfdpic_relocs_info_hash (const void *entry_
)
1324 const struct bfinfdpic_relocs_info
*entry
= entry_
;
1326 return (entry
->symndx
== -1
1327 ? (long) entry
->d
.h
->root
.root
.hash
1328 : entry
->symndx
+ (long) entry
->d
.abfd
->id
* 257) + entry
->addend
;
1331 /* Test whether the key fields of two bfinfdpic_relocs_info entries are
1334 bfinfdpic_relocs_info_eq (const void *entry1
, const void *entry2
)
1336 const struct bfinfdpic_relocs_info
*e1
= entry1
;
1337 const struct bfinfdpic_relocs_info
*e2
= entry2
;
1339 return e1
->symndx
== e2
->symndx
&& e1
->addend
== e2
->addend
1340 && (e1
->symndx
== -1 ? e1
->d
.h
== e2
->d
.h
: e1
->d
.abfd
== e2
->d
.abfd
);
1343 /* Find or create an entry in a hash table HT that matches the key
1344 fields of the given ENTRY. If it's not found, memory for a new
1345 entry is allocated in ABFD's obstack. */
1346 static struct bfinfdpic_relocs_info
*
1347 bfinfdpic_relocs_info_find (struct htab
*ht
,
1349 const struct bfinfdpic_relocs_info
*entry
,
1350 enum insert_option insert
)
1352 struct bfinfdpic_relocs_info
**loc
=
1353 (struct bfinfdpic_relocs_info
**) htab_find_slot (ht
, entry
, insert
);
1361 *loc
= bfd_zalloc (abfd
, sizeof (**loc
));
1366 (*loc
)->symndx
= entry
->symndx
;
1367 (*loc
)->d
= entry
->d
;
1368 (*loc
)->addend
= entry
->addend
;
1369 (*loc
)->plt_entry
= (bfd_vma
)-1;
1370 (*loc
)->lzplt_entry
= (bfd_vma
)-1;
1375 /* Obtain the address of the entry in HT associated with H's symbol +
1376 addend, creating a new entry if none existed. ABFD is only used
1377 for memory allocation purposes. */
1378 inline static struct bfinfdpic_relocs_info
*
1379 bfinfdpic_relocs_info_for_global (struct htab
*ht
,
1381 struct elf_link_hash_entry
*h
,
1383 enum insert_option insert
)
1385 struct bfinfdpic_relocs_info entry
;
1389 entry
.addend
= addend
;
1391 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1394 /* Obtain the address of the entry in HT associated with the SYMNDXth
1395 local symbol of the input bfd ABFD, plus the addend, creating a new
1396 entry if none existed. */
1397 inline static struct bfinfdpic_relocs_info
*
1398 bfinfdpic_relocs_info_for_local (struct htab
*ht
,
1402 enum insert_option insert
)
1404 struct bfinfdpic_relocs_info entry
;
1406 entry
.symndx
= symndx
;
1407 entry
.d
.abfd
= abfd
;
1408 entry
.addend
= addend
;
1410 return bfinfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1413 /* Merge fields set by check_relocs() of two entries that end up being
1414 mapped to the same (presumably global) symbol. */
1417 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info
*e2
,
1418 struct bfinfdpic_relocs_info
const *e1
)
1420 e2
->got17m4
|= e1
->got17m4
;
1421 e2
->gothilo
|= e1
->gothilo
;
1423 e2
->fdgot17m4
|= e1
->fdgot17m4
;
1424 e2
->fdgothilo
|= e1
->fdgothilo
;
1425 e2
->fdgoff17m4
|= e1
->fdgoff17m4
;
1426 e2
->fdgoffhilo
|= e1
->fdgoffhilo
;
1427 e2
->gotoff
|= e1
->gotoff
;
1428 e2
->call
|= e1
->call
;
1432 /* Every block of 65535 lazy PLT entries shares a single call to the
1433 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1434 32767, counting from 0). All other lazy PLT entries branch to it
1435 in a single instruction. */
1437 #define LZPLT_RESOLVER_EXTRA 10
1438 #define LZPLT_NORMAL_SIZE 6
1439 #define LZPLT_ENTRIES 1362
1441 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
1442 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
1444 /* Add a dynamic relocation to the SRELOC section. */
1446 inline static bfd_vma
1447 _bfinfdpic_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
1448 int reloc_type
, long dynindx
, bfd_vma addend
,
1449 struct bfinfdpic_relocs_info
*entry
)
1451 Elf_Internal_Rela outrel
;
1452 bfd_vma reloc_offset
;
1454 outrel
.r_offset
= offset
;
1455 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
1456 outrel
.r_addend
= addend
;
1458 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rel
);
1459 BFD_ASSERT (reloc_offset
< sreloc
->size
);
1460 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1461 sreloc
->contents
+ reloc_offset
);
1462 sreloc
->reloc_count
++;
1464 /* If the entry's index is zero, this relocation was probably to a
1465 linkonce section that got discarded. We reserved a dynamic
1466 relocation, but it was for another entry than the one we got at
1467 the time of emitting the relocation. Unfortunately there's no
1468 simple way for us to catch this situation, since the relocation
1469 is cleared right before calling relocate_section, at which point
1470 we no longer know what the relocation used to point to. */
1473 BFD_ASSERT (entry
->dynrelocs
> 0);
1477 return reloc_offset
;
1480 /* Add a fixup to the ROFIXUP section. */
1483 _bfinfdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma offset
,
1484 struct bfinfdpic_relocs_info
*entry
)
1486 bfd_vma fixup_offset
;
1488 if (rofixup
->flags
& SEC_EXCLUDE
)
1491 fixup_offset
= rofixup
->reloc_count
* 4;
1492 if (rofixup
->contents
)
1494 BFD_ASSERT (fixup_offset
< rofixup
->size
);
1495 bfd_put_32 (output_bfd
, offset
, rofixup
->contents
+ fixup_offset
);
1497 rofixup
->reloc_count
++;
1499 if (entry
&& entry
->symndx
)
1501 /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
1503 BFD_ASSERT (entry
->fixups
> 0);
1507 return fixup_offset
;
1510 /* Find the segment number in which OSEC, and output section, is
1514 _bfinfdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
1516 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
1518 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
1521 inline static bfd_boolean
1522 _bfinfdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
1524 unsigned seg
= _bfinfdpic_osec_to_segment (output_bfd
, osec
);
1526 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
1529 /* Generate relocations for GOT entries, function descriptors, and
1530 code for PLT and lazy PLT entries. */
1532 inline static bfd_boolean
1533 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info
*entry
,
1535 struct bfd_link_info
*info
,
1537 Elf_Internal_Sym
*sym
,
1541 bfd_vma fd_lazy_rel_offset
= (bfd_vma
)-1;
1548 if (entry
->got_entry
|| entry
->fdgot_entry
|| entry
->fd_entry
)
1550 /* If the symbol is dynamic, consider it for dynamic
1551 relocations, otherwise decay to section + offset. */
1552 if (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1)
1553 dynindx
= entry
->d
.h
->dynindx
;
1556 if (sec
->output_section
1557 && ! bfd_is_abs_section (sec
->output_section
)
1558 && ! bfd_is_und_section (sec
->output_section
))
1559 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
1565 /* Generate relocation for GOT entry pointing to the symbol. */
1566 if (entry
->got_entry
)
1569 bfd_vma ad
= addend
;
1571 /* If the symbol is dynamic but binds locally, use
1573 if (sec
&& (entry
->symndx
!= -1
1574 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1576 if (entry
->symndx
== -1)
1577 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1579 ad
+= sym
->st_value
;
1580 ad
+= sec
->output_offset
;
1581 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
1582 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1587 /* If we're linking an executable at a fixed address, we can
1588 omit the dynamic relocation as long as the symbol is local to
1590 if (info
->executable
&& !info
->pie
1591 && (entry
->symndx
!= -1
1592 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1595 ad
+= sec
->output_section
->vma
;
1596 if (entry
->symndx
!= -1
1597 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
1598 _bfinfdpic_add_rofixup (output_bfd
,
1599 bfinfdpic_gotfixup_section (info
),
1600 bfinfdpic_got_section (info
)->output_section
1602 + bfinfdpic_got_section (info
)->output_offset
1603 + bfinfdpic_got_initial_offset (info
)
1604 + entry
->got_entry
, entry
);
1607 _bfinfdpic_add_dyn_reloc (output_bfd
, bfinfdpic_gotrel_section (info
),
1608 _bfd_elf_section_offset
1610 bfinfdpic_got_section (info
),
1611 bfinfdpic_got_initial_offset (info
)
1613 + bfinfdpic_got_section (info
)
1614 ->output_section
->vma
1615 + bfinfdpic_got_section (info
)->output_offset
,
1616 R_byte4_data
, idx
, ad
, entry
);
1618 bfd_put_32 (output_bfd
, ad
,
1619 bfinfdpic_got_section (info
)->contents
1620 + bfinfdpic_got_initial_offset (info
)
1621 + entry
->got_entry
);
1624 /* Generate relocation for GOT entry pointing to a canonical
1625 function descriptor. */
1626 if (entry
->fdgot_entry
)
1631 if (! (entry
->symndx
== -1
1632 && entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
1633 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1635 /* If the symbol is dynamic and there may be dynamic symbol
1636 resolution because we are, or are linked with, a shared
1637 library, emit a FUNCDESC relocation such that the dynamic
1638 linker will allocate the function descriptor. If the
1639 symbol needs a non-local function descriptor but binds
1640 locally (e.g., its visibility is protected, emit a
1641 dynamic relocation decayed to section+offset. */
1642 if (entry
->symndx
== -1
1643 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)
1644 && BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)
1645 && !(info
->executable
&& !info
->pie
))
1647 reloc
= R_BFIN_FUNCDESC
;
1648 idx
= elf_section_data (entry
->d
.h
->root
.u
.def
.section
1649 ->output_section
)->dynindx
;
1650 ad
= entry
->d
.h
->root
.u
.def
.section
->output_offset
1651 + entry
->d
.h
->root
.u
.def
.value
;
1653 else if (entry
->symndx
== -1
1654 && ! BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
))
1656 reloc
= R_BFIN_FUNCDESC
;
1664 /* Otherwise, we know we have a private function descriptor,
1665 so reference it directly. */
1666 if (elf_hash_table (info
)->dynamic_sections_created
)
1667 BFD_ASSERT (entry
->privfd
);
1668 reloc
= R_byte4_data
;
1669 idx
= elf_section_data (bfinfdpic_got_section (info
)
1670 ->output_section
)->dynindx
;
1671 ad
= bfinfdpic_got_section (info
)->output_offset
1672 + bfinfdpic_got_initial_offset (info
) + entry
->fd_entry
;
1675 /* If there is room for dynamic symbol resolution, emit the
1676 dynamic relocation. However, if we're linking an
1677 executable at a fixed location, we won't have emitted a
1678 dynamic symbol entry for the got section, so idx will be
1679 zero, which means we can and should compute the address
1680 of the private descriptor ourselves. */
1681 if (info
->executable
&& !info
->pie
1682 && (entry
->symndx
!= -1
1683 || BFINFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)))
1685 ad
+= bfinfdpic_got_section (info
)->output_section
->vma
;
1686 _bfinfdpic_add_rofixup (output_bfd
,
1687 bfinfdpic_gotfixup_section (info
),
1688 bfinfdpic_got_section (info
)
1689 ->output_section
->vma
1690 + bfinfdpic_got_section (info
)
1692 + bfinfdpic_got_initial_offset (info
)
1693 + entry
->fdgot_entry
, entry
);
1696 _bfinfdpic_add_dyn_reloc (output_bfd
,
1697 bfinfdpic_gotrel_section (info
),
1698 _bfd_elf_section_offset
1700 bfinfdpic_got_section (info
),
1701 bfinfdpic_got_initial_offset (info
)
1702 + entry
->fdgot_entry
)
1703 + bfinfdpic_got_section (info
)
1704 ->output_section
->vma
1705 + bfinfdpic_got_section (info
)
1707 reloc
, idx
, ad
, entry
);
1710 bfd_put_32 (output_bfd
, ad
,
1711 bfinfdpic_got_section (info
)->contents
1712 + bfinfdpic_got_initial_offset (info
)
1713 + entry
->fdgot_entry
);
1716 /* Generate relocation to fill in a private function descriptor in
1718 if (entry
->fd_entry
)
1721 bfd_vma ad
= addend
;
1723 long lowword
, highword
;
1725 /* If the symbol is dynamic but binds locally, use
1727 if (sec
&& (entry
->symndx
!= -1
1728 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1730 if (entry
->symndx
== -1)
1731 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1733 ad
+= sym
->st_value
;
1734 ad
+= sec
->output_offset
;
1735 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
1736 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1741 /* If we're linking an executable at a fixed address, we can
1742 omit the dynamic relocation as long as the symbol is local to
1744 if (info
->executable
&& !info
->pie
1745 && (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1748 ad
+= sec
->output_section
->vma
;
1750 if (entry
->symndx
!= -1
1751 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
1753 _bfinfdpic_add_rofixup (output_bfd
,
1754 bfinfdpic_gotfixup_section (info
),
1755 bfinfdpic_got_section (info
)
1756 ->output_section
->vma
1757 + bfinfdpic_got_section (info
)
1759 + bfinfdpic_got_initial_offset (info
)
1760 + entry
->fd_entry
, entry
);
1761 _bfinfdpic_add_rofixup (output_bfd
,
1762 bfinfdpic_gotfixup_section (info
),
1763 bfinfdpic_got_section (info
)
1764 ->output_section
->vma
1765 + bfinfdpic_got_section (info
)
1767 + bfinfdpic_got_initial_offset (info
)
1768 + entry
->fd_entry
+ 4, entry
);
1774 = _bfinfdpic_add_dyn_reloc (output_bfd
,
1776 ? bfinfdpic_pltrel_section (info
)
1777 : bfinfdpic_gotrel_section (info
),
1778 _bfd_elf_section_offset
1780 bfinfdpic_got_section (info
),
1781 bfinfdpic_got_initial_offset (info
)
1783 + bfinfdpic_got_section (info
)
1784 ->output_section
->vma
1785 + bfinfdpic_got_section (info
)
1787 R_BFIN_FUNCDESC_VALUE
, idx
, ad
, entry
);
1790 /* If we've omitted the dynamic relocation, just emit the fixed
1791 addresses of the symbol and of the local GOT base offset. */
1792 if (info
->executable
&& !info
->pie
&& sec
&& sec
->output_section
)
1795 highword
= bfinfdpic_got_section (info
)->output_section
->vma
1796 + bfinfdpic_got_section (info
)->output_offset
1797 + bfinfdpic_got_initial_offset (info
);
1799 else if (entry
->lazyplt
)
1804 fd_lazy_rel_offset
= ofst
;
1806 /* A function descriptor used for lazy or local resolving is
1807 initialized such that its high word contains the output
1808 section index in which the PLT entries are located, and
1809 the low word contains the address of the lazy PLT entry
1810 entry point, that must be within the memory region
1811 assigned to that section. */
1812 lowword
= entry
->lzplt_entry
+ 4
1813 + bfinfdpic_plt_section (info
)->output_offset
1814 + bfinfdpic_plt_section (info
)->output_section
->vma
;
1815 highword
= _bfinfdpic_osec_to_segment
1816 (output_bfd
, bfinfdpic_plt_section (info
)->output_section
);
1820 /* A function descriptor for a local function gets the index
1821 of the section. For a non-local function, it's
1824 if (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1
1825 && entry
->d
.h
->dynindx
== idx
)
1828 highword
= _bfinfdpic_osec_to_segment
1829 (output_bfd
, sec
->output_section
);
1832 bfd_put_32 (output_bfd
, lowword
,
1833 bfinfdpic_got_section (info
)->contents
1834 + bfinfdpic_got_initial_offset (info
)
1836 bfd_put_32 (output_bfd
, highword
,
1837 bfinfdpic_got_section (info
)->contents
1838 + bfinfdpic_got_initial_offset (info
)
1839 + entry
->fd_entry
+ 4);
1842 /* Generate code for the PLT entry. */
1843 if (entry
->plt_entry
!= (bfd_vma
) -1)
1845 bfd_byte
*plt_code
= bfinfdpic_plt_section (info
)->contents
1848 BFD_ASSERT (entry
->fd_entry
);
1850 /* Figure out what kind of PLT entry we need, depending on the
1851 location of the function descriptor within the GOT. */
1852 if (entry
->fd_entry
>= -(1 << (18 - 1))
1853 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
1855 /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
1856 bfd_put_32 (output_bfd
,
1857 0xe519 | ((entry
->fd_entry
<< 14) & 0xFFFF0000),
1859 bfd_put_32 (output_bfd
,
1860 0xe51b | (((entry
->fd_entry
+ 4) << 14) & 0xFFFF0000),
1866 /* P1.L = fd_entry; P1.H = fd_entry;
1870 bfd_put_32 (output_bfd
,
1871 0xe109 | (entry
->fd_entry
<< 16),
1873 bfd_put_32 (output_bfd
,
1874 0xe149 | (entry
->fd_entry
& 0xFFFF0000),
1876 bfd_put_16 (output_bfd
, 0x5ad9, plt_code
+ 8);
1877 bfd_put_16 (output_bfd
, 0x9159, plt_code
+ 10);
1878 bfd_put_16 (output_bfd
, 0xac5b, plt_code
+ 12);
1882 bfd_put_16 (output_bfd
, 0x0051, plt_code
);
1885 /* Generate code for the lazy PLT entry. */
1886 if (entry
->lzplt_entry
!= (bfd_vma
) -1)
1888 bfd_byte
*lzplt_code
= bfinfdpic_plt_section (info
)->contents
1889 + entry
->lzplt_entry
;
1890 bfd_vma resolverStub_addr
;
1892 bfd_put_32 (output_bfd
, fd_lazy_rel_offset
, lzplt_code
);
1895 resolverStub_addr
= entry
->lzplt_entry
/ BFINFDPIC_LZPLT_BLOCK_SIZE
1896 * BFINFDPIC_LZPLT_BLOCK_SIZE
+ BFINFDPIC_LZPLT_RESOLV_LOC
;
1897 if (resolverStub_addr
>= bfinfdpic_plt_initial_offset (info
))
1898 resolverStub_addr
= bfinfdpic_plt_initial_offset (info
) - LZPLT_NORMAL_SIZE
- LZPLT_RESOLVER_EXTRA
;
1900 if (entry
->lzplt_entry
== resolverStub_addr
)
1902 /* This is a lazy PLT entry that includes a resolver call.
1906 bfd_put_32 (output_bfd
,
1909 bfd_put_16 (output_bfd
, 0x0052, lzplt_code
+ 4);
1913 /* JUMP.S resolverStub */
1914 bfd_put_16 (output_bfd
,
1916 | (((resolverStub_addr
- entry
->lzplt_entry
)
1917 / 2) & (((bfd_vma
)1 << 12) - 1)),
1926 /* Look through the relocs for a section during the first phase, and
1927 allocate space in the global offset table or procedure linkage
1931 bfin_check_relocs (bfd
* abfd
,
1932 struct bfd_link_info
*info
,
1934 const Elf_Internal_Rela
*relocs
)
1937 Elf_Internal_Shdr
*symtab_hdr
;
1938 struct elf_link_hash_entry
**sym_hashes
;
1939 bfd_signed_vma
*local_got_refcounts
;
1940 const Elf_Internal_Rela
*rel
;
1941 const Elf_Internal_Rela
*rel_end
;
1945 if (info
->relocatable
)
1948 dynobj
= elf_hash_table (info
)->dynobj
;
1949 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1950 sym_hashes
= elf_sym_hashes (abfd
);
1951 local_got_refcounts
= elf_local_got_refcounts (abfd
);
1957 rel_end
= relocs
+ sec
->reloc_count
;
1958 for (rel
= relocs
; rel
< rel_end
; rel
++)
1960 unsigned long r_symndx
;
1961 struct elf_link_hash_entry
*h
;
1963 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1964 if (r_symndx
< symtab_hdr
->sh_info
)
1967 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
1969 switch (ELF32_R_TYPE (rel
->r_info
))
1971 /* This relocation describes the C++ object vtable hierarchy.
1972 Reconstruct it for later use during GC. */
1973 case R_BFIN_GNU_VTINHERIT
:
1974 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
1978 /* This relocation describes which C++ vtable entries
1979 are actually used. Record for later use during GC. */
1980 case R_BFIN_GNU_VTENTRY
:
1981 BFD_ASSERT (h
!= NULL
);
1983 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
1989 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
1995 /* Create the .got section. */
1996 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
1997 if (!_bfd_elf_create_got_section (dynobj
, info
))
2003 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2004 BFD_ASSERT (sgot
!= NULL
);
2007 if (srelgot
== NULL
&& (h
!= NULL
|| info
->shared
))
2009 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
2010 if (srelgot
== NULL
)
2012 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
2013 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
2015 srelgot
= bfd_make_section_with_flags (dynobj
, ".rela.got",
2018 || !bfd_set_section_alignment (dynobj
, srelgot
, 2))
2025 if (h
->got
.refcount
== 0)
2027 /* Make sure this symbol is output as a dynamic symbol. */
2028 if (h
->dynindx
== -1 && !h
->forced_local
)
2030 if (!bfd_elf_link_record_dynamic_symbol (info
, h
))
2034 /* Allocate space in the .got section. */
2036 /* Allocate relocation space. */
2037 srelgot
->size
+= sizeof (Elf32_External_Rela
);
2043 /* This is a global offset table entry for a local symbol. */
2044 if (local_got_refcounts
== NULL
)
2048 size
= symtab_hdr
->sh_info
;
2049 size
*= sizeof (bfd_signed_vma
);
2050 local_got_refcounts
= ((bfd_signed_vma
*)
2051 bfd_zalloc (abfd
, size
));
2052 if (local_got_refcounts
== NULL
)
2054 elf_local_got_refcounts (abfd
) = local_got_refcounts
;
2056 if (local_got_refcounts
[r_symndx
] == 0)
2061 /* If we are generating a shared object, we need to
2062 output a R_68K_RELATIVE reloc so that the dynamic
2063 linker can adjust this GOT entry. */
2064 srelgot
->size
+= sizeof (Elf32_External_Rela
);
2067 local_got_refcounts
[r_symndx
]++;
2079 static enum elf_reloc_type_class
2080 elf32_bfin_reloc_type_class (const Elf_Internal_Rela
* rela
)
2082 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2085 return reloc_class_normal
;
2089 static bfd_reloc_status_type
2090 bfin_final_link_relocate (Elf_Internal_Rela
*rel
, reloc_howto_type
*howto
,
2091 bfd
*input_bfd
, asection
*input_section
,
2092 bfd_byte
*contents
, bfd_vma address
,
2093 bfd_vma value
, bfd_vma addend
)
2095 int r_type
= ELF32_R_TYPE (rel
->r_info
);
2097 if (r_type
== R_pcrel24
|| r_type
== R_pcrel24_jump_l
)
2099 bfd_reloc_status_type r
= bfd_reloc_ok
;
2102 if (address
> bfd_get_section_limit (input_bfd
, input_section
))
2103 return bfd_reloc_outofrange
;
2107 /* Perform usual pc-relative correction. */
2108 value
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
2111 /* We are getting reloc_entry->address 2 byte off from
2112 the start of instruction. Assuming absolute postion
2113 of the reloc data. But, following code had been written assuming
2114 reloc address is starting at begining of instruction.
2115 To compensate that I have increased the value of
2116 relocation by 1 (effectively 2) and used the addr -2 instead of addr. */
2121 if ((value
& 0xFF000000) != 0
2122 && (value
& 0xFF000000) != 0xFF000000)
2123 r
= bfd_reloc_overflow
;
2127 x
= bfd_get_16 (input_bfd
, contents
+ address
);
2128 x
= (x
& 0xff00) | ((value
>> 16) & 0xff);
2129 bfd_put_16 (input_bfd
, x
, contents
+ address
);
2131 x
= bfd_get_16 (input_bfd
, contents
+ address
+ 2);
2133 bfd_put_16 (input_bfd
, x
, contents
+ address
+ 2);
2137 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
2138 rel
->r_offset
, value
, addend
);
2143 /* Relocate an Blackfin ELF section.
2145 The RELOCATE_SECTION function is called by the new ELF backend linker
2146 to handle the relocations for a section.
2148 The relocs are always passed as Rela structures; if the section
2149 actually uses Rel structures, the r_addend field will always be
2152 This function is responsible for adjusting the section contents as
2153 necessary, and (if using Rela relocs and generating a relocatable
2154 output file) adjusting the reloc addend as necessary.
2156 This function does not have to worry about setting the reloc
2157 address or the reloc symbol index.
2159 LOCAL_SYMS is a pointer to the swapped in local symbols.
2161 LOCAL_SECTIONS is an array giving the section in the input file
2162 corresponding to the st_shndx field of each local symbol.
2164 The global hash table entry for the global symbols can be found
2165 via elf_sym_hashes (input_bfd).
2167 When generating relocatable output, this function must handle
2168 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2169 going to be the section symbol corresponding to the output
2170 section, which means that the addend must be adjusted
2174 bfinfdpic_relocate_section (bfd
* output_bfd
,
2175 struct bfd_link_info
*info
,
2177 asection
* input_section
,
2178 bfd_byte
* contents
,
2179 Elf_Internal_Rela
* relocs
,
2180 Elf_Internal_Sym
* local_syms
,
2181 asection
** local_sections
)
2183 Elf_Internal_Shdr
*symtab_hdr
;
2184 struct elf_link_hash_entry
**sym_hashes
;
2185 Elf_Internal_Rela
*rel
;
2186 Elf_Internal_Rela
*relend
;
2187 unsigned isec_segment
, got_segment
, plt_segment
,
2189 int silence_segment_error
= !(info
->shared
|| info
->pie
);
2191 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2192 sym_hashes
= elf_sym_hashes (input_bfd
);
2193 relend
= relocs
+ input_section
->reloc_count
;
2195 isec_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2196 input_section
->output_section
);
2197 if (IS_FDPIC (output_bfd
) && bfinfdpic_got_section (info
))
2198 got_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2199 bfinfdpic_got_section (info
)
2203 if (IS_FDPIC (output_bfd
) && elf_hash_table (info
)->dynamic_sections_created
)
2204 plt_segment
= _bfinfdpic_osec_to_segment (output_bfd
,
2205 bfinfdpic_plt_section (info
)
2210 for (rel
= relocs
; rel
< relend
; rel
++)
2212 reloc_howto_type
*howto
;
2213 unsigned long r_symndx
;
2214 Elf_Internal_Sym
*sym
;
2216 struct elf_link_hash_entry
*h
;
2218 bfd_reloc_status_type r
;
2219 const char * name
= NULL
;
2222 struct bfinfdpic_relocs_info
*picrel
;
2223 bfd_vma orig_addend
= rel
->r_addend
;
2225 r_type
= ELF32_R_TYPE (rel
->r_info
);
2227 if (r_type
== R_BFIN_GNU_VTINHERIT
2228 || r_type
== R_BFIN_GNU_VTENTRY
)
2231 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2232 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
2235 bfd_set_error (bfd_error_bad_value
);
2243 if (r_symndx
< symtab_hdr
->sh_info
)
2245 sym
= local_syms
+ r_symndx
;
2246 osec
= sec
= local_sections
[r_symndx
];
2247 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2249 name
= bfd_elf_string_from_elf_section
2250 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2251 name
= (name
== NULL
) ? bfd_section_name (input_bfd
, sec
) : name
;
2256 bfd_boolean unresolved_reloc
;
2258 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2259 r_symndx
, symtab_hdr
, sym_hashes
,
2261 unresolved_reloc
, warned
);
2265 if (sec
!= NULL
&& elf_discarded_section (sec
))
2267 /* For relocs against symbols from removed linkonce sections,
2268 or sections discarded by a linker script, we just want the
2269 section contents zeroed. Avoid any special processing. */
2270 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2276 if (info
->relocatable
)
2280 && (h
->root
.type
== bfd_link_hash_defined
2281 || h
->root
.type
== bfd_link_hash_defweak
)
2282 && !BFINFDPIC_SYM_LOCAL (info
, h
))
2291 case R_pcrel24_jump_l
:
2293 if (! IS_FDPIC (output_bfd
))
2296 case R_BFIN_GOT17M4
:
2299 case R_BFIN_FUNCDESC_GOT17M4
:
2300 case R_BFIN_FUNCDESC_GOTHI
:
2301 case R_BFIN_FUNCDESC_GOTLO
:
2302 case R_BFIN_GOTOFF17M4
:
2303 case R_BFIN_GOTOFFHI
:
2304 case R_BFIN_GOTOFFLO
:
2305 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2306 case R_BFIN_FUNCDESC_GOTOFFHI
:
2307 case R_BFIN_FUNCDESC_GOTOFFLO
:
2308 case R_BFIN_FUNCDESC
:
2309 case R_BFIN_FUNCDESC_VALUE
:
2311 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2312 (info
), input_bfd
, h
,
2313 orig_addend
, INSERT
);
2315 /* In order to find the entry we created before, we must
2316 use the original addend, not the one that may have been
2317 modified by _bfd_elf_rela_local_sym(). */
2318 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2319 (info
), input_bfd
, r_symndx
,
2320 orig_addend
, INSERT
);
2324 if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel
, output_bfd
, info
,
2328 (*_bfd_error_handler
)
2329 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2330 input_bfd
, input_section
, rel
->r_offset
, name
);
2340 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
))
2342 info
->callbacks
->warning
2343 (info
, _("relocation references symbol not defined in the module"),
2344 name
, input_bfd
, input_section
, rel
->r_offset
);
2353 case R_pcrel24_jump_l
:
2354 check_segment
[0] = isec_segment
;
2355 if (! IS_FDPIC (output_bfd
))
2356 check_segment
[1] = isec_segment
;
2357 else if (picrel
->plt
)
2359 relocation
= bfinfdpic_plt_section (info
)->output_section
->vma
2360 + bfinfdpic_plt_section (info
)->output_offset
2361 + picrel
->plt_entry
;
2362 check_segment
[1] = plt_segment
;
2364 /* We don't want to warn on calls to undefined weak symbols,
2365 as calls to them must be protected by non-NULL tests
2366 anyway, and unprotected calls would invoke undefined
2368 else if (picrel
->symndx
== -1
2369 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefweak
)
2370 check_segment
[1] = check_segment
[0];
2372 check_segment
[1] = sec
2373 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2377 case R_BFIN_GOT17M4
:
2380 relocation
= picrel
->got_entry
;
2381 check_segment
[0] = check_segment
[1] = got_segment
;
2384 case R_BFIN_FUNCDESC_GOT17M4
:
2385 case R_BFIN_FUNCDESC_GOTHI
:
2386 case R_BFIN_FUNCDESC_GOTLO
:
2387 relocation
= picrel
->fdgot_entry
;
2388 check_segment
[0] = check_segment
[1] = got_segment
;
2391 case R_BFIN_GOTOFFHI
:
2392 case R_BFIN_GOTOFF17M4
:
2393 case R_BFIN_GOTOFFLO
:
2394 relocation
-= bfinfdpic_got_section (info
)->output_section
->vma
2395 + bfinfdpic_got_section (info
)->output_offset
2396 + bfinfdpic_got_initial_offset (info
);
2397 check_segment
[0] = got_segment
;
2398 check_segment
[1] = sec
2399 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2403 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2404 case R_BFIN_FUNCDESC_GOTOFFHI
:
2405 case R_BFIN_FUNCDESC_GOTOFFLO
:
2406 relocation
= picrel
->fd_entry
;
2407 check_segment
[0] = check_segment
[1] = got_segment
;
2410 case R_BFIN_FUNCDESC
:
2413 bfd_vma addend
= rel
->r_addend
;
2415 if (! (h
&& h
->root
.type
== bfd_link_hash_undefweak
2416 && BFINFDPIC_SYM_LOCAL (info
, h
)))
2418 /* If the symbol is dynamic and there may be dynamic
2419 symbol resolution because we are or are linked with a
2420 shared library, emit a FUNCDESC relocation such that
2421 the dynamic linker will allocate the function
2422 descriptor. If the symbol needs a non-local function
2423 descriptor but binds locally (e.g., its visibility is
2424 protected, emit a dynamic relocation decayed to
2426 if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
)
2427 && BFINFDPIC_SYM_LOCAL (info
, h
)
2428 && !(info
->executable
&& !info
->pie
))
2430 dynindx
= elf_section_data (h
->root
.u
.def
.section
2431 ->output_section
)->dynindx
;
2432 addend
+= h
->root
.u
.def
.section
->output_offset
2433 + h
->root
.u
.def
.value
;
2435 else if (h
&& ! BFINFDPIC_FUNCDESC_LOCAL (info
, h
))
2439 info
->callbacks
->warning
2440 (info
, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2441 name
, input_bfd
, input_section
, rel
->r_offset
);
2444 dynindx
= h
->dynindx
;
2448 /* Otherwise, we know we have a private function
2449 descriptor, so reference it directly. */
2450 BFD_ASSERT (picrel
->privfd
);
2451 r_type
= R_byte4_data
;
2452 dynindx
= elf_section_data (bfinfdpic_got_section (info
)
2453 ->output_section
)->dynindx
;
2454 addend
= bfinfdpic_got_section (info
)->output_offset
2455 + bfinfdpic_got_initial_offset (info
)
2459 /* If there is room for dynamic symbol resolution, emit
2460 the dynamic relocation. However, if we're linking an
2461 executable at a fixed location, we won't have emitted a
2462 dynamic symbol entry for the got section, so idx will
2463 be zero, which means we can and should compute the
2464 address of the private descriptor ourselves. */
2465 if (info
->executable
&& !info
->pie
2466 && (!h
|| BFINFDPIC_FUNCDESC_LOCAL (info
, h
)))
2468 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2469 if ((bfd_get_section_flags (output_bfd
,
2470 input_section
->output_section
)
2471 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2473 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2477 info
->callbacks
->warning
2479 _("cannot emit fixups in read-only section"),
2480 name
, input_bfd
, input_section
, rel
->r_offset
);
2483 _bfinfdpic_add_rofixup (output_bfd
,
2484 bfinfdpic_gotfixup_section
2486 _bfd_elf_section_offset
2488 input_section
, rel
->r_offset
)
2490 ->output_section
->vma
2491 + input_section
->output_offset
,
2495 else if ((bfd_get_section_flags (output_bfd
,
2496 input_section
->output_section
)
2497 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2501 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2505 info
->callbacks
->warning
2507 _("cannot emit dynamic relocations in read-only section"),
2508 name
, input_bfd
, input_section
, rel
->r_offset
);
2511 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2512 input_section
, rel
->r_offset
);
2513 /* Only output a reloc for a not deleted entry. */
2514 if (offset
>= (bfd_vma
) -2)
2515 _bfinfdpic_add_dyn_reloc (output_bfd
,
2516 bfinfdpic_gotrel_section (info
),
2519 dynindx
, addend
, picrel
);
2521 _bfinfdpic_add_dyn_reloc (output_bfd
,
2522 bfinfdpic_gotrel_section (info
),
2523 offset
+ input_section
2524 ->output_section
->vma
2525 + input_section
->output_offset
,
2527 dynindx
, addend
, picrel
);
2530 addend
+= bfinfdpic_got_section (info
)->output_section
->vma
;
2533 /* We want the addend in-place because dynamic
2534 relocations are REL. Setting relocation to it should
2535 arrange for it to be installed. */
2536 relocation
= addend
- rel
->r_addend
;
2538 check_segment
[0] = check_segment
[1] = got_segment
;
2542 if (! IS_FDPIC (output_bfd
))
2544 check_segment
[0] = check_segment
[1] = -1;
2548 case R_BFIN_FUNCDESC_VALUE
:
2551 bfd_vma addend
= rel
->r_addend
;
2553 offset
= _bfd_elf_section_offset (output_bfd
, info
,
2554 input_section
, rel
->r_offset
);
2556 /* If the symbol is dynamic but binds locally, use
2558 if (h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
))
2560 if (addend
&& r_type
== R_BFIN_FUNCDESC_VALUE
)
2562 info
->callbacks
->warning
2563 (info
, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2564 name
, input_bfd
, input_section
, rel
->r_offset
);
2567 dynindx
= h
->dynindx
;
2572 addend
+= h
->root
.u
.def
.value
;
2574 addend
+= sym
->st_value
;
2576 addend
+= osec
->output_offset
;
2577 if (osec
&& osec
->output_section
2578 && ! bfd_is_abs_section (osec
->output_section
)
2579 && ! bfd_is_und_section (osec
->output_section
))
2580 dynindx
= elf_section_data (osec
->output_section
)->dynindx
;
2585 /* If we're linking an executable at a fixed address, we
2586 can omit the dynamic relocation as long as the symbol
2587 is defined in the current link unit (which is implied
2588 by its output section not being NULL). */
2589 if (info
->executable
&& !info
->pie
2590 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
2593 addend
+= osec
->output_section
->vma
;
2594 if (IS_FDPIC (input_bfd
)
2595 && (bfd_get_section_flags (output_bfd
,
2596 input_section
->output_section
)
2597 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2599 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2603 info
->callbacks
->warning
2605 _("cannot emit fixups in read-only section"),
2606 name
, input_bfd
, input_section
, rel
->r_offset
);
2609 if (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
2611 /* Only output a reloc for a not deleted entry. */
2612 if (offset
>= (bfd_vma
)-2)
2613 _bfinfdpic_add_rofixup (output_bfd
,
2614 bfinfdpic_gotfixup_section
2615 (info
), -1, picrel
);
2617 _bfinfdpic_add_rofixup (output_bfd
,
2618 bfinfdpic_gotfixup_section
2620 offset
+ input_section
2621 ->output_section
->vma
2622 + input_section
->output_offset
,
2625 if (r_type
== R_BFIN_FUNCDESC_VALUE
)
2627 if (offset
>= (bfd_vma
)-2)
2628 _bfinfdpic_add_rofixup
2630 bfinfdpic_gotfixup_section (info
),
2633 _bfinfdpic_add_rofixup
2635 bfinfdpic_gotfixup_section (info
),
2636 offset
+ input_section
->output_section
->vma
2637 + input_section
->output_offset
+ 4, picrel
);
2644 if ((bfd_get_section_flags (output_bfd
,
2645 input_section
->output_section
)
2646 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
2648 if (_bfinfdpic_osec_readonly_p (output_bfd
,
2652 info
->callbacks
->warning
2654 _("cannot emit dynamic relocations in read-only section"),
2655 name
, input_bfd
, input_section
, rel
->r_offset
);
2658 /* Only output a reloc for a not deleted entry. */
2659 if (offset
>= (bfd_vma
)-2)
2660 _bfinfdpic_add_dyn_reloc (output_bfd
,
2661 bfinfdpic_gotrel_section (info
),
2662 0, R_unused0
, dynindx
, addend
, picrel
);
2664 _bfinfdpic_add_dyn_reloc (output_bfd
,
2665 bfinfdpic_gotrel_section (info
),
2668 ->output_section
->vma
2669 + input_section
->output_offset
,
2670 r_type
, dynindx
, addend
, picrel
);
2673 addend
+= osec
->output_section
->vma
;
2674 /* We want the addend in-place because dynamic
2675 relocations are REL. Setting relocation to it
2676 should arrange for it to be installed. */
2677 relocation
= addend
- rel
->r_addend
;
2680 if (r_type
== R_BFIN_FUNCDESC_VALUE
&& offset
< (bfd_vma
)-2)
2682 /* If we've omitted the dynamic relocation, just emit
2683 the fixed addresses of the symbol and of the local
2685 if (info
->executable
&& !info
->pie
2686 && (!h
|| BFINFDPIC_SYM_LOCAL (info
, h
)))
2687 bfd_put_32 (output_bfd
,
2688 bfinfdpic_got_section (info
)->output_section
->vma
2689 + bfinfdpic_got_section (info
)->output_offset
2690 + bfinfdpic_got_initial_offset (info
),
2691 contents
+ rel
->r_offset
+ 4);
2693 /* A function descriptor used for lazy or local
2694 resolving is initialized such that its high word
2695 contains the output section index in which the
2696 PLT entries are located, and the low word
2697 contains the offset of the lazy PLT entry entry
2698 point into that section. */
2699 bfd_put_32 (output_bfd
,
2700 h
&& ! BFINFDPIC_SYM_LOCAL (info
, h
)
2702 : _bfinfdpic_osec_to_segment (output_bfd
,
2705 contents
+ rel
->r_offset
+ 4);
2708 check_segment
[0] = check_segment
[1] = got_segment
;
2712 check_segment
[0] = isec_segment
;
2713 check_segment
[1] = sec
2714 ? _bfinfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
2719 if (check_segment
[0] != check_segment
[1] && IS_FDPIC (output_bfd
))
2721 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
2722 in the ld testsuite. */
2723 /* This helps catch problems in GCC while we can't do more
2724 than static linking. The idea is to test whether the
2725 input file basename is crt0.o only once. */
2726 if (silence_segment_error
== 1)
2727 silence_segment_error
=
2728 (strlen (input_bfd
->filename
) == 6
2729 && strcmp (input_bfd
->filename
, "crt0.o") == 0)
2730 || (strlen (input_bfd
->filename
) > 6
2731 && strcmp (input_bfd
->filename
2732 + strlen (input_bfd
->filename
) - 7,
2736 if (!silence_segment_error
2737 /* We don't want duplicate errors for undefined
2739 && !(picrel
&& picrel
->symndx
== -1
2740 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefined
))
2741 info
->callbacks
->warning
2743 (info
->shared
|| info
->pie
)
2744 ? _("relocations between different segments are not supported")
2745 : _("warning: relocation references a different segment"),
2746 name
, input_bfd
, input_section
, rel
->r_offset
);
2747 if (!silence_segment_error
&& (info
->shared
|| info
->pie
))
2749 elf_elfheader (output_bfd
)->e_flags
|= EF_BFIN_PIC
;
2754 case R_BFIN_GOTOFFHI
:
2755 /* We need the addend to be applied before we shift the
2757 relocation
+= rel
->r_addend
;
2760 case R_BFIN_FUNCDESC_GOTHI
:
2761 case R_BFIN_FUNCDESC_GOTOFFHI
:
2766 case R_BFIN_FUNCDESC_GOTLO
:
2767 case R_BFIN_GOTOFFLO
:
2768 case R_BFIN_FUNCDESC_GOTOFFLO
:
2769 relocation
&= 0xffff;
2779 case R_pcrel24_jump_l
:
2780 if (! IS_FDPIC (output_bfd
) || ! picrel
->plt
)
2784 /* When referencing a GOT entry, a function descriptor or a
2785 PLT, we don't want the addend to apply to the reference,
2786 but rather to the referenced symbol. The actual entry
2787 will have already been created taking the addend into
2788 account, so cancel it out here. */
2789 case R_BFIN_GOT17M4
:
2792 case R_BFIN_FUNCDESC_GOT17M4
:
2793 case R_BFIN_FUNCDESC_GOTHI
:
2794 case R_BFIN_FUNCDESC_GOTLO
:
2795 case R_BFIN_FUNCDESC_GOTOFF17M4
:
2796 case R_BFIN_FUNCDESC_GOTOFFHI
:
2797 case R_BFIN_FUNCDESC_GOTOFFLO
:
2798 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
2799 here, since we do want to apply the addend to the others.
2800 Note that we've applied the addend to GOTOFFHI before we
2801 shifted it right. */
2802 case R_BFIN_GOTOFFHI
:
2803 relocation
-= rel
->r_addend
;
2810 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
2811 contents
, rel
->r_offset
,
2812 relocation
, rel
->r_addend
);
2814 if (r
!= bfd_reloc_ok
)
2816 const char * msg
= (const char *) NULL
;
2820 case bfd_reloc_overflow
:
2821 r
= info
->callbacks
->reloc_overflow
2822 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
2823 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
2826 case bfd_reloc_undefined
:
2827 r
= info
->callbacks
->undefined_symbol
2828 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
2831 case bfd_reloc_outofrange
:
2832 msg
= _("internal error: out of range error");
2835 case bfd_reloc_notsupported
:
2836 msg
= _("internal error: unsupported relocation error");
2839 case bfd_reloc_dangerous
:
2840 msg
= _("internal error: dangerous relocation");
2844 msg
= _("internal error: unknown error");
2849 r
= info
->callbacks
->warning
2850 (info
, msg
, name
, input_bfd
, input_section
, rel
->r_offset
);
2861 bfin_relocate_section (bfd
* output_bfd
,
2862 struct bfd_link_info
*info
,
2864 asection
* input_section
,
2865 bfd_byte
* contents
,
2866 Elf_Internal_Rela
* relocs
,
2867 Elf_Internal_Sym
* local_syms
,
2868 asection
** local_sections
)
2871 Elf_Internal_Shdr
*symtab_hdr
;
2872 struct elf_link_hash_entry
**sym_hashes
;
2873 bfd_vma
*local_got_offsets
;
2876 Elf_Internal_Rela
*rel
;
2877 Elf_Internal_Rela
*relend
;
2880 dynobj
= elf_hash_table (info
)->dynobj
;
2881 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
2882 sym_hashes
= elf_sym_hashes (input_bfd
);
2883 local_got_offsets
= elf_local_got_offsets (input_bfd
);
2889 relend
= relocs
+ input_section
->reloc_count
;
2890 for (; rel
< relend
; rel
++, i
++)
2893 reloc_howto_type
*howto
;
2894 unsigned long r_symndx
;
2895 struct elf_link_hash_entry
*h
;
2896 Elf_Internal_Sym
*sym
;
2898 bfd_vma relocation
= 0;
2899 bfd_boolean unresolved_reloc
;
2900 bfd_reloc_status_type r
;
2903 r_type
= ELF32_R_TYPE (rel
->r_info
);
2904 if (r_type
< 0 || r_type
>= 243)
2906 bfd_set_error (bfd_error_bad_value
);
2910 if (r_type
== R_BFIN_GNU_VTENTRY
2911 || r_type
== R_BFIN_GNU_VTINHERIT
)
2914 howto
= bfin_reloc_type_lookup (input_bfd
, r_type
);
2917 bfd_set_error (bfd_error_bad_value
);
2920 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2925 unresolved_reloc
= FALSE
;
2927 if (r_symndx
< symtab_hdr
->sh_info
)
2929 sym
= local_syms
+ r_symndx
;
2930 sec
= local_sections
[r_symndx
];
2931 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2937 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2938 r_symndx
, symtab_hdr
, sym_hashes
,
2940 unresolved_reloc
, warned
);
2943 if (sec
!= NULL
&& elf_discarded_section (sec
))
2945 /* For relocs against symbols from removed linkonce sections,
2946 or sections discarded by a linker script, we just want the
2947 section contents zeroed. Avoid any special processing. */
2948 _bfd_clear_contents (howto
, input_bfd
, contents
+ rel
->r_offset
);
2954 if (info
->relocatable
)
2957 address
= rel
->r_offset
;
2959 /* Then, process normally. */
2962 case R_BFIN_GNU_VTINHERIT
:
2963 case R_BFIN_GNU_VTENTRY
:
2964 return bfd_reloc_ok
;
2967 /* Relocation is to the address of the entry for this symbol
2968 in the global offset table. */
2970 && strcmp (h
->root
.root
.string
, "__GLOBAL_OFFSET_TABLE_") == 0)
2973 /* Relocation is the offset of the entry for this symbol in
2974 the global offset table. */
2981 /* Create the .got section. */
2982 elf_hash_table (info
)->dynobj
= dynobj
= output_bfd
;
2983 if (!_bfd_elf_create_got_section (dynobj
, info
))
2989 sgot
= bfd_get_section_by_name (dynobj
, ".got");
2990 BFD_ASSERT (sgot
!= NULL
);
2997 off
= h
->got
.offset
;
2998 BFD_ASSERT (off
!= (bfd_vma
) - 1);
2999 dyn
= elf_hash_table (info
)->dynamic_sections_created
;
3001 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn
, info
->shared
, h
)
3008 /* This is actually a static link, or it is a
3009 -Bsymbolic link and the symbol is defined
3010 locally, or the symbol was forced to be local
3011 because of a version file.. We must initialize
3012 this entry in the global offset table. Since
3013 the offset must always be a multiple of 4, we
3014 use the least significant bit to record whether
3015 we have initialized it already.
3017 When doing a dynamic link, we create a .rela.got
3018 relocation entry to initialize the value. This
3019 is done in the finish_dynamic_symbol routine. */
3024 bfd_put_32 (output_bfd
, relocation
,
3025 sgot
->contents
+ off
);
3030 unresolved_reloc
= FALSE
;
3034 BFD_ASSERT (local_got_offsets
!= NULL
);
3035 off
= local_got_offsets
[r_symndx
];
3036 BFD_ASSERT (off
!= (bfd_vma
) - 1);
3038 /* The offset must always be a multiple of 4. We use
3039 the least significant bit to record whether we have
3040 already generated the necessary reloc. */
3045 bfd_put_32 (output_bfd
, relocation
, sgot
->contents
+ off
);
3050 Elf_Internal_Rela outrel
;
3053 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
3054 BFD_ASSERT (s
!= NULL
);
3056 outrel
.r_offset
= (sgot
->output_section
->vma
3057 + sgot
->output_offset
+ off
);
3059 ELF32_R_INFO (0, R_pcrel24
);
3060 outrel
.r_addend
= relocation
;
3063 s
->reloc_count
++ * sizeof (Elf32_External_Rela
);
3064 bfd_elf32_swap_reloca_out (output_bfd
, &outrel
, loc
);
3067 local_got_offsets
[r_symndx
] |= 1;
3071 relocation
= sgot
->output_offset
+ off
;
3073 /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4. */
3080 r
= bfin_final_link_relocate (rel
, howto
, input_bfd
, input_section
,
3082 relocation
, rel
->r_addend
);
3087 /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
3088 because such sections are not SEC_ALLOC and thus ld.so will
3089 not process them. */
3090 if (unresolved_reloc
3091 && !((input_section
->flags
& SEC_DEBUGGING
) != 0 && h
->def_dynamic
))
3093 (*_bfd_error_handler
)
3094 (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
3096 input_section
, (long) rel
->r_offset
, h
->root
.root
.string
);
3100 if (r
!= bfd_reloc_ok
)
3105 name
= h
->root
.root
.string
;
3108 name
= bfd_elf_string_from_elf_section (input_bfd
,
3109 symtab_hdr
->sh_link
,
3114 name
= bfd_section_name (input_bfd
, sec
);
3117 if (r
== bfd_reloc_overflow
)
3119 if (!(info
->callbacks
->reloc_overflow
3120 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
3121 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
)))
3126 (*_bfd_error_handler
)
3127 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
3128 input_bfd
, input_section
,
3129 (long) rel
->r_offset
, name
, (int) r
);
3139 bfin_gc_mark_hook (asection
* sec
,
3140 struct bfd_link_info
*info
,
3141 Elf_Internal_Rela
* rel
,
3142 struct elf_link_hash_entry
*h
,
3143 Elf_Internal_Sym
* sym
)
3146 switch (ELF32_R_TYPE (rel
->r_info
))
3148 case R_BFIN_GNU_VTINHERIT
:
3149 case R_BFIN_GNU_VTENTRY
:
3153 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
3156 /* Update the relocation information for the relocations of the section
3160 bfinfdpic_gc_sweep_hook (bfd
*abfd
,
3161 struct bfd_link_info
*info
,
3163 const Elf_Internal_Rela
*relocs
)
3165 Elf_Internal_Shdr
*symtab_hdr
;
3166 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
3167 const Elf_Internal_Rela
*rel
;
3168 const Elf_Internal_Rela
*rel_end
;
3169 struct bfinfdpic_relocs_info
*picrel
;
3171 BFD_ASSERT (IS_FDPIC (abfd
));
3173 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3174 sym_hashes
= elf_sym_hashes (abfd
);
3175 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof(Elf32_External_Sym
);
3176 if (!elf_bad_symtab (abfd
))
3177 sym_hashes_end
-= symtab_hdr
->sh_info
;
3179 rel_end
= relocs
+ sec
->reloc_count
;
3180 for (rel
= relocs
; rel
< rel_end
; rel
++)
3182 struct elf_link_hash_entry
*h
;
3183 unsigned long r_symndx
;
3185 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3186 if (r_symndx
< symtab_hdr
->sh_info
)
3189 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3192 picrel
= bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
3194 rel
->r_addend
, NO_INSERT
);
3196 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
3197 (info
), abfd
, r_symndx
,
3198 rel
->r_addend
, NO_INSERT
);
3203 switch (ELF32_R_TYPE (rel
->r_info
))
3206 case R_pcrel24_jump_l
:
3210 case R_BFIN_FUNCDESC_VALUE
:
3211 picrel
->relocsfdv
--;
3212 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
3218 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
3222 case R_BFIN_GOT17M4
:
3231 case R_BFIN_FUNCDESC_GOT17M4
:
3232 picrel
->fdgot17m4
--;
3235 case R_BFIN_FUNCDESC_GOTHI
:
3236 case R_BFIN_FUNCDESC_GOTLO
:
3237 picrel
->fdgothilo
--;
3240 case R_BFIN_GOTOFF17M4
:
3241 case R_BFIN_GOTOFFHI
:
3242 case R_BFIN_GOTOFFLO
:
3246 case R_BFIN_FUNCDESC_GOTOFF17M4
:
3247 picrel
->fdgoff17m4
--;
3250 case R_BFIN_FUNCDESC_GOTOFFHI
:
3251 case R_BFIN_FUNCDESC_GOTOFFLO
:
3252 picrel
->fdgoffhilo
--;
3255 case R_BFIN_FUNCDESC
:
3268 /* Update the got entry reference counts for the section being removed. */
3271 bfin_gc_sweep_hook (bfd
* abfd
,
3272 struct bfd_link_info
*info
,
3274 const Elf_Internal_Rela
* relocs
)
3276 Elf_Internal_Shdr
*symtab_hdr
;
3277 struct elf_link_hash_entry
**sym_hashes
;
3278 bfd_signed_vma
*local_got_refcounts
;
3279 const Elf_Internal_Rela
*rel
, *relend
;
3284 dynobj
= elf_hash_table (info
)->dynobj
;
3288 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
3289 sym_hashes
= elf_sym_hashes (abfd
);
3290 local_got_refcounts
= elf_local_got_refcounts (abfd
);
3292 sgot
= bfd_get_section_by_name (dynobj
, ".got");
3293 srelgot
= bfd_get_section_by_name (dynobj
, ".rela.got");
3295 relend
= relocs
+ sec
->reloc_count
;
3296 for (rel
= relocs
; rel
< relend
; rel
++)
3298 unsigned long r_symndx
;
3299 struct elf_link_hash_entry
*h
;
3301 switch (ELF32_R_TYPE (rel
->r_info
))
3304 r_symndx
= ELF32_R_SYM (rel
->r_info
);
3305 if (r_symndx
>= symtab_hdr
->sh_info
)
3307 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
3308 if (h
->got
.refcount
> 0)
3311 if (h
->got
.refcount
== 0)
3313 /* We don't need the .got entry any more. */
3315 srelgot
->size
-= sizeof (Elf32_External_Rela
);
3319 else if (local_got_refcounts
!= NULL
)
3321 if (local_got_refcounts
[r_symndx
] > 0)
3323 --local_got_refcounts
[r_symndx
];
3324 if (local_got_refcounts
[r_symndx
] == 0)
3326 /* We don't need the .got entry any more. */
3329 srelgot
->size
-= sizeof (Elf32_External_Rela
);
3341 /* We need dynamic symbols for every section, since segments can
3342 relocate independently. */
3344 _bfinfdpic_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
3345 struct bfd_link_info
*info
3347 asection
*p ATTRIBUTE_UNUSED
)
3349 switch (elf_section_data (p
)->this_hdr
.sh_type
)
3353 /* If sh_type is yet undecided, assume it could be
3354 SHT_PROGBITS/SHT_NOBITS. */
3358 /* There shouldn't be section relative relocations
3359 against any other section. */
3365 /* Create a .got section, as well as its additional info field. This
3366 is almost entirely copied from
3367 elflink.c:_bfd_elf_create_got_section(). */
3370 _bfin_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
3372 flagword flags
, pltflags
;
3374 struct elf_link_hash_entry
*h
;
3375 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3379 /* This function may be called more than once. */
3380 s
= bfd_get_section_by_name (abfd
, ".got");
3381 if (s
!= NULL
&& (s
->flags
& SEC_LINKER_CREATED
) != 0)
3384 /* Machine specific: although pointers are 32-bits wide, we want the
3385 GOT to be aligned to a 64-bit boundary, such that function
3386 descriptors in it can be accessed with 64-bit loads and
3390 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3391 | SEC_LINKER_CREATED
);
3394 s
= bfd_make_section_with_flags (abfd
, ".got", flags
);
3396 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
3399 if (bed
->want_got_plt
)
3401 s
= bfd_make_section_with_flags (abfd
, ".got.plt", flags
);
3403 || !bfd_set_section_alignment (abfd
, s
, ptralign
))
3407 if (bed
->want_got_sym
)
3409 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3410 (or .got.plt) section. We don't do this in the linker script
3411 because we don't want to define the symbol if we are not creating
3412 a global offset table. */
3413 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "__GLOBAL_OFFSET_TABLE_");
3414 elf_hash_table (info
)->hgot
= h
;
3418 /* Machine-specific: we want the symbol for executables as
3420 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
3424 /* The first bit of the global offset table is the header. */
3425 s
->size
+= bed
->got_header_size
;
3427 /* This is the machine-specific part. Create and initialize section
3428 data for the got. */
3429 if (IS_FDPIC (abfd
))
3431 bfinfdpic_got_section (info
) = s
;
3432 bfinfdpic_relocs_info (info
) = htab_try_create (1,
3433 bfinfdpic_relocs_info_hash
,
3434 bfinfdpic_relocs_info_eq
,
3436 if (! bfinfdpic_relocs_info (info
))
3439 s
= bfd_make_section_with_flags (abfd
, ".rel.got",
3440 (flags
| SEC_READONLY
));
3442 || ! bfd_set_section_alignment (abfd
, s
, 2))
3445 bfinfdpic_gotrel_section (info
) = s
;
3447 /* Machine-specific. */
3448 s
= bfd_make_section_with_flags (abfd
, ".rofixup",
3449 (flags
| SEC_READONLY
));
3451 || ! bfd_set_section_alignment (abfd
, s
, 2))
3454 bfinfdpic_gotfixup_section (info
) = s
;
3461 flags
= BSF_GLOBAL
| BSF_WEAK
;
3467 /* Make sure the got and plt sections exist, and that our pointers in
3468 the link hash table point to them. */
3471 elf32_bfinfdpic_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
3473 /* This is mostly copied from
3474 elflink.c:_bfd_elf_create_dynamic_sections(). */
3475 flagword flags
, pltflags
;
3477 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
3479 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3480 .rel[a].bss sections. */
3482 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
3483 | SEC_LINKER_CREATED
);
3486 pltflags
|= SEC_CODE
;
3487 if (bed
->plt_not_loaded
)
3488 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
3489 if (bed
->plt_readonly
)
3490 pltflags
|= SEC_READONLY
;
3492 s
= bfd_make_section_with_flags (abfd
, ".plt", pltflags
);
3494 || ! bfd_set_section_alignment (abfd
, s
, bed
->plt_alignment
))
3496 /* Blackfin-specific: remember it. */
3497 bfinfdpic_plt_section (info
) = s
;
3499 if (bed
->want_plt_sym
)
3501 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3503 struct elf_link_hash_entry
*h
;
3504 struct bfd_link_hash_entry
*bh
= NULL
;
3506 if (! (_bfd_generic_link_add_one_symbol
3507 (info
, abfd
, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL
, s
, 0, NULL
,
3508 FALSE
, get_elf_backend_data (abfd
)->collect
, &bh
)))
3510 h
= (struct elf_link_hash_entry
*) bh
;
3512 h
->type
= STT_OBJECT
;
3514 if (! info
->executable
3515 && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
3519 /* Blackfin-specific: we want rel relocations for the plt. */
3520 s
= bfd_make_section_with_flags (abfd
, ".rel.plt", flags
| SEC_READONLY
);
3522 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
3524 /* Blackfin-specific: remember it. */
3525 bfinfdpic_pltrel_section (info
) = s
;
3527 /* Blackfin-specific: we want to create the GOT in the Blackfin way. */
3528 if (! _bfin_create_got_section (abfd
, info
))
3531 /* Blackfin-specific: make sure we created everything we wanted. */
3532 BFD_ASSERT (bfinfdpic_got_section (info
) && bfinfdpic_gotrel_section (info
)
3533 /* && bfinfdpic_gotfixup_section (info) */
3534 && bfinfdpic_plt_section (info
)
3535 && bfinfdpic_pltrel_section (info
));
3537 if (bed
->want_dynbss
)
3539 /* The .dynbss section is a place to put symbols which are defined
3540 by dynamic objects, are referenced by regular objects, and are
3541 not functions. We must allocate space for them in the process
3542 image and use a R_*_COPY reloc to tell the dynamic linker to
3543 initialize them at run time. The linker script puts the .dynbss
3544 section into the .bss section of the final image. */
3545 s
= bfd_make_section_with_flags (abfd
, ".dynbss",
3546 SEC_ALLOC
| SEC_LINKER_CREATED
);
3550 /* The .rel[a].bss section holds copy relocs. This section is not
3551 normally needed. We need to create it here, though, so that the
3552 linker will map it to an output section. We can't just create it
3553 only if we need it, because we will not know whether we need it
3554 until we have seen all the input files, and the first time the
3555 main linker code calls BFD after examining all the input files
3556 (size_dynamic_sections) the input sections have already been
3557 mapped to the output sections. If the section turns out not to
3558 be needed, we can discard it later. We will never need this
3559 section when generating a shared object, since they do not use
3563 s
= bfd_make_section_with_flags (abfd
,
3564 (bed
->default_use_rela_p
3565 ? ".rela.bss" : ".rel.bss"),
3566 flags
| SEC_READONLY
);
3568 || ! bfd_set_section_alignment (abfd
, s
, bed
->s
->log_file_align
))
3576 /* The name of the dynamic interpreter. This is put in the .interp
3579 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
3581 #define DEFAULT_STACK_SIZE 0x20000
3583 /* This structure is used to collect the number of entries present in
3584 each addressable range of the got. */
3585 struct _bfinfdpic_dynamic_got_info
3587 /* Several bits of information about the current link. */
3588 struct bfd_link_info
*info
;
3589 /* Total size needed for GOT entries within the 18- or 32-bit
3591 bfd_vma got17m4
, gothilo
;
3592 /* Total size needed for function descriptor entries within the 18-
3593 or 32-bit ranges. */
3594 bfd_vma fd17m4
, fdhilo
;
3595 /* Total size needed function descriptor entries referenced in PLT
3596 entries, that would be profitable to place in offsets close to
3597 the PIC register. */
3599 /* Total size needed by lazy PLT entries. */
3601 /* Number of relocations carried over from input object files. */
3602 unsigned long relocs
;
3603 /* Number of fixups introduced by relocations in input object files. */
3604 unsigned long fixups
;
3607 /* Compute the total GOT size required by each symbol in each range.
3608 Symbols may require up to 4 words in the GOT: an entry pointing to
3609 the symbol, an entry pointing to its function descriptor, and a
3610 private function descriptors taking two words. */
3613 _bfinfdpic_count_got_plt_entries (void **entryp
, void *dinfo_
)
3615 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3616 struct _bfinfdpic_dynamic_got_info
*dinfo
= dinfo_
;
3617 unsigned relocs
= 0, fixups
= 0;
3619 /* Allocate space for a GOT entry pointing to the symbol. */
3621 dinfo
->got17m4
+= 4;
3622 else if (entry
->gothilo
)
3623 dinfo
->gothilo
+= 4;
3628 /* Allocate space for a GOT entry pointing to the function
3630 if (entry
->fdgot17m4
)
3631 dinfo
->got17m4
+= 4;
3632 else if (entry
->fdgothilo
)
3633 dinfo
->gothilo
+= 4;
3638 /* Decide whether we need a PLT entry, a function descriptor in the
3639 GOT, and a lazy PLT entry for this symbol. */
3640 entry
->plt
= entry
->call
3641 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3642 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3643 entry
->privfd
= entry
->plt
3644 || entry
->fdgoff17m4
|| entry
->fdgoffhilo
3645 || ((entry
->fd
|| entry
->fdgot17m4
|| entry
->fdgothilo
)
3646 && (entry
->symndx
!= -1
3647 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
)));
3648 entry
->lazyplt
= entry
->privfd
3649 && entry
->symndx
== -1 && ! BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
3650 && ! (dinfo
->info
->flags
& DF_BIND_NOW
)
3651 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
3653 /* Allocate space for a function descriptor. */
3654 if (entry
->fdgoff17m4
)
3656 else if (entry
->privfd
&& entry
->plt
)
3658 else if (entry
->privfd
)
3665 dinfo
->lzplt
+= LZPLT_NORMAL_SIZE
;
3667 if (!dinfo
->info
->executable
|| dinfo
->info
->pie
)
3668 relocs
= entry
->relocs32
+ entry
->relocsfd
+ entry
->relocsfdv
;
3671 if (entry
->symndx
!= -1 || BFINFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
))
3673 if (entry
->symndx
!= -1
3674 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3675 fixups
+= entry
->relocs32
+ 2 * entry
->relocsfdv
;
3678 relocs
+= entry
->relocs32
+ entry
->relocsfdv
;
3680 if (entry
->symndx
!= -1
3681 || BFINFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
))
3683 if (entry
->symndx
!= -1
3684 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
3685 fixups
+= entry
->relocsfd
;
3688 relocs
+= entry
->relocsfd
;
3691 entry
->dynrelocs
+= relocs
;
3692 entry
->fixups
+= fixups
;
3693 dinfo
->relocs
+= relocs
;
3694 dinfo
->fixups
+= fixups
;
3699 /* This structure is used to assign offsets to got entries, function
3700 descriptors, plt entries and lazy plt entries. */
3702 struct _bfinfdpic_dynamic_got_plt_info
3704 /* Summary information collected with _bfinfdpic_count_got_plt_entries. */
3705 struct _bfinfdpic_dynamic_got_info g
;
3707 /* For each addressable range, we record a MAX (positive) and MIN
3708 (negative) value. CUR is used to assign got entries, and it's
3709 incremented from an initial positive value to MAX, then from MIN
3710 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
3711 assign function descriptors, and it's decreased from an initial
3712 non-positive value to MIN, then from MAX down to CUR (unless CUR
3713 wraps around first). All of MIN, MAX, CUR and FDCUR always point
3714 to even words. ODD, if non-zero, indicates an odd word to be
3715 used for the next got entry, otherwise CUR is used and
3716 incremented by a pair of words, wrapping around when it reaches
3717 MAX. FDCUR is decremented (and wrapped) before the next function
3718 descriptor is chosen. FDPLT indicates the number of remaining
3719 slots that can be used for function descriptors used only by PLT
3721 struct _bfinfdpic_dynamic_got_alloc_data
3723 bfd_signed_vma max
, cur
, odd
, fdcur
, min
;
3728 /* Determine the positive and negative ranges to be used by each
3729 offset range in the GOT. FDCUR and CUR, that must be aligned to a
3730 double-word boundary, are the minimum (negative) and maximum
3731 (positive) GOT offsets already used by previous ranges, except for
3732 an ODD entry that may have been left behind. GOT and FD indicate
3733 the size of GOT entries and function descriptors that must be
3734 placed within the range from -WRAP to WRAP. If there's room left,
3735 up to FDPLT bytes should be reserved for additional function
3738 inline static bfd_signed_vma
3739 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data
*gad
,
3740 bfd_signed_vma fdcur
,
3748 bfd_signed_vma wrapmin
= -wrap
;
3750 /* Start at the given initial points. */
3754 /* If we had an incoming odd word and we have any got entries that
3755 are going to use it, consume it, otherwise leave gad->odd at
3756 zero. We might force gad->odd to zero and return the incoming
3757 odd such that it is used by the next range, but then GOT entries
3758 might appear to be out of order and we wouldn't be able to
3759 shorten the GOT by one word if it turns out to end with an
3760 unpaired GOT entry. */
3770 /* If we're left with an unpaired GOT entry, compute its location
3771 such that we can return it. Otherwise, if got doesn't require an
3772 odd number of words here, either odd was already zero in the
3773 block above, or it was set to zero because got was non-zero, or
3774 got was already zero. In the latter case, we want the value of
3775 odd to carry over to the return statement, so we don't want to
3776 reset odd unless the condition below is true. */
3783 /* Compute the tentative boundaries of this range. */
3784 gad
->max
= cur
+ got
;
3785 gad
->min
= fdcur
- fd
;
3788 /* If function descriptors took too much space, wrap some of them
3790 if (gad
->min
< wrapmin
)
3792 gad
->max
+= wrapmin
- gad
->min
;
3795 /* If there is space left and we have function descriptors
3796 referenced in PLT entries that could take advantage of shorter
3797 offsets, place them here. */
3798 else if (fdplt
&& gad
->min
> wrapmin
)
3801 if ((bfd_vma
) (gad
->min
- wrapmin
) < fdplt
)
3802 fds
= gad
->min
- wrapmin
;
3811 /* If GOT entries took too much space, wrap some of them around.
3812 This may well cause gad->min to become lower than wrapmin. This
3813 will cause a relocation overflow later on, so we don't have to
3815 if ((bfd_vma
) gad
->max
> wrap
)
3817 gad
->min
-= gad
->max
- wrap
;
3820 /* If there is more space left, try to place some more function
3821 descriptors for PLT entries. */
3822 else if (fdplt
&& (bfd_vma
) gad
->max
< wrap
)
3825 if ((bfd_vma
) (wrap
- gad
->max
) < fdplt
)
3826 fds
= wrap
- gad
->max
;
3835 /* If odd was initially computed as an offset past the wrap point,
3838 odd
= gad
->min
+ odd
- gad
->max
;
3840 /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3841 before returning, so do it here too. This guarantees that,
3842 should cur and fdcur meet at the wrap point, they'll both be
3844 if (gad
->cur
== gad
->max
)
3845 gad
->cur
= gad
->min
;
3850 /* Compute the location of the next GOT entry, given the allocation
3851 data for a range. */
3853 inline static bfd_signed_vma
3854 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3860 /* If there was an odd word left behind, use it. */
3866 /* Otherwise, use the word pointed to by cur, reserve the next
3867 as an odd word, and skip to the next pair of words, possibly
3870 gad
->odd
= gad
->cur
+ 4;
3872 if (gad
->cur
== gad
->max
)
3873 gad
->cur
= gad
->min
;
3879 /* Compute the location of the next function descriptor entry in the
3880 GOT, given the allocation data for a range. */
3882 inline static bfd_signed_vma
3883 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data
*gad
)
3885 /* If we're at the bottom, wrap around, and only then allocate the
3886 next pair of words. */
3887 if (gad
->fdcur
== gad
->min
)
3888 gad
->fdcur
= gad
->max
;
3889 return gad
->fdcur
-= 8;
3892 /* Assign GOT offsets for every GOT entry and function descriptor.
3893 Doing everything in a single pass is tricky. */
3896 _bfinfdpic_assign_got_entries (void **entryp
, void *info_
)
3898 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3899 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3902 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3903 else if (entry
->gothilo
)
3904 entry
->got_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3906 if (entry
->fdgot17m4
)
3907 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->got17m4
);
3908 else if (entry
->fdgothilo
)
3909 entry
->fdgot_entry
= _bfinfdpic_get_got_entry (&dinfo
->gothilo
);
3911 if (entry
->fdgoff17m4
)
3912 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3913 else if (entry
->plt
&& dinfo
->got17m4
.fdplt
)
3915 dinfo
->got17m4
.fdplt
-= 8;
3916 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3918 else if (entry
->plt
)
3920 dinfo
->gothilo
.fdplt
-= 8;
3921 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3923 else if (entry
->privfd
)
3924 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3929 /* Assign GOT offsets to private function descriptors used by PLT
3930 entries (or referenced by 32-bit offsets), as well as PLT entries
3931 and lazy PLT entries. */
3934 _bfinfdpic_assign_plt_entries (void **entryp
, void *info_
)
3936 struct bfinfdpic_relocs_info
*entry
= *entryp
;
3937 struct _bfinfdpic_dynamic_got_plt_info
*dinfo
= info_
;
3939 /* If this symbol requires a local function descriptor, allocate
3941 if (entry
->privfd
&& entry
->fd_entry
== 0)
3943 if (dinfo
->got17m4
.fdplt
)
3945 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->got17m4
);
3946 dinfo
->got17m4
.fdplt
-= 8;
3950 BFD_ASSERT (dinfo
->gothilo
.fdplt
);
3951 entry
->fd_entry
= _bfinfdpic_get_fd_entry (&dinfo
->gothilo
);
3952 dinfo
->gothilo
.fdplt
-= 8;
3960 /* We use the section's raw size to mark the location of the
3962 entry
->plt_entry
= bfinfdpic_plt_section (dinfo
->g
.info
)->size
;
3964 /* Figure out the length of this PLT entry based on the
3965 addressing mode we need to reach the function descriptor. */
3966 BFD_ASSERT (entry
->fd_entry
);
3967 if (entry
->fd_entry
>= -(1 << (18 - 1))
3968 && entry
->fd_entry
+ 4 < (1 << (18 - 1)))
3973 bfinfdpic_plt_section (dinfo
->g
.info
)->size
+= size
;
3978 entry
->lzplt_entry
= dinfo
->g
.lzplt
;
3979 dinfo
->g
.lzplt
+= LZPLT_NORMAL_SIZE
;
3980 /* If this entry is the one that gets the resolver stub, account
3981 for the additional instruction. */
3982 if (entry
->lzplt_entry
% BFINFDPIC_LZPLT_BLOCK_SIZE
3983 == BFINFDPIC_LZPLT_RESOLV_LOC
)
3984 dinfo
->g
.lzplt
+= LZPLT_RESOLVER_EXTRA
;
3990 /* Follow indirect and warning hash entries so that each got entry
3991 points to the final symbol definition. P must point to a pointer
3992 to the hash table we're traversing. Since this traversal may
3993 modify the hash table, we set this pointer to NULL to indicate
3994 we've made a potentially-destructive change to the hash table, so
3995 the traversal must be restarted. */
3997 _bfinfdpic_resolve_final_relocs_info (void **entryp
, void *p
)
3999 struct bfinfdpic_relocs_info
*entry
= *entryp
;
4002 if (entry
->symndx
== -1)
4004 struct elf_link_hash_entry
*h
= entry
->d
.h
;
4005 struct bfinfdpic_relocs_info
*oentry
;
4007 while (h
->root
.type
== bfd_link_hash_indirect
4008 || h
->root
.type
== bfd_link_hash_warning
)
4009 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
4011 if (entry
->d
.h
== h
)
4014 oentry
= bfinfdpic_relocs_info_for_global (*htab
, 0, h
, entry
->addend
,
4019 /* Merge the two entries. */
4020 bfinfdpic_pic_merge_early_relocs_info (oentry
, entry
);
4021 htab_clear_slot (*htab
, entryp
);
4027 /* If we can't find this entry with the new bfd hash, re-insert
4028 it, and get the traversal restarted. */
4029 if (! htab_find (*htab
, entry
))
4031 htab_clear_slot (*htab
, entryp
);
4032 entryp
= htab_find_slot (*htab
, entry
, INSERT
);
4035 /* Abort the traversal, since the whole table may have
4036 moved, and leave it up to the parent to restart the
4038 *(htab_t
*)p
= NULL
;
4046 /* Set the sizes of the dynamic sections. */
4049 elf32_bfinfdpic_size_dynamic_sections (bfd
*output_bfd
,
4050 struct bfd_link_info
*info
)
4054 struct _bfinfdpic_dynamic_got_plt_info gpinfo
;
4058 dynobj
= elf_hash_table (info
)->dynobj
;
4059 BFD_ASSERT (dynobj
!= NULL
);
4061 if (elf_hash_table (info
)->dynamic_sections_created
)
4063 /* Set the contents of the .interp section to the interpreter. */
4064 if (info
->executable
)
4066 s
= bfd_get_section_by_name (dynobj
, ".interp");
4067 BFD_ASSERT (s
!= NULL
);
4068 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
4069 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
4073 memset (&gpinfo
, 0, sizeof (gpinfo
));
4074 gpinfo
.g
.info
= info
;
4078 htab_t relocs
= bfinfdpic_relocs_info (info
);
4080 htab_traverse (relocs
, _bfinfdpic_resolve_final_relocs_info
, &relocs
);
4082 if (relocs
== bfinfdpic_relocs_info (info
))
4086 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_count_got_plt_entries
,
4090 /* Compute the total size taken by entries in the 18-bit range,
4091 to tell how many PLT function descriptors we can bring into it
4092 without causing it to overflow. */
4093 limit
= odd
+ gpinfo
.g
.got17m4
+ gpinfo
.g
.fd17m4
;
4094 if (limit
< (bfd_vma
)1 << 18)
4095 limit
= ((bfd_vma
)1 << 18) - limit
;
4098 if (gpinfo
.g
.fdplt
< limit
)
4099 limit
= gpinfo
.g
.fdplt
;
4101 /* Determine the ranges of GOT offsets that we can use for each
4102 range of addressing modes. */
4103 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfo
.got17m4
,
4110 (bfd_vma
)1 << (18-1));
4111 odd
= _bfinfdpic_compute_got_alloc_data (&gpinfo
.gothilo
,
4117 gpinfo
.g
.fdplt
- gpinfo
.got17m4
.fdplt
,
4118 (bfd_vma
)1 << (32-1));
4120 /* Now assign (most) GOT offsets. */
4121 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_got_entries
,
4124 bfinfdpic_got_section (info
)->size
= gpinfo
.gothilo
.max
4125 - gpinfo
.gothilo
.min
4126 /* If an odd word is the last word of the GOT, we don't need this
4127 word to be part of the GOT. */
4128 - (odd
+ 4 == gpinfo
.gothilo
.max
? 4 : 0);
4129 if (bfinfdpic_got_section (info
)->size
== 0)
4130 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
4131 else if (bfinfdpic_got_section (info
)->size
== 12
4132 && ! elf_hash_table (info
)->dynamic_sections_created
)
4134 bfinfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
4135 bfinfdpic_got_section (info
)->size
= 0;
4139 bfinfdpic_got_section (info
)->contents
=
4140 (bfd_byte
*) bfd_zalloc (dynobj
,
4141 bfinfdpic_got_section (info
)->size
);
4142 if (bfinfdpic_got_section (info
)->contents
== NULL
)
4146 if (elf_hash_table (info
)->dynamic_sections_created
)
4147 /* Subtract the number of lzplt entries, since those will generate
4148 relocations in the pltrel section. */
4149 bfinfdpic_gotrel_section (info
)->size
=
4150 (gpinfo
.g
.relocs
- gpinfo
.g
.lzplt
/ LZPLT_NORMAL_SIZE
)
4151 * get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
4153 BFD_ASSERT (gpinfo
.g
.relocs
== 0);
4154 if (bfinfdpic_gotrel_section (info
)->size
== 0)
4155 bfinfdpic_gotrel_section (info
)->flags
|= SEC_EXCLUDE
;
4158 bfinfdpic_gotrel_section (info
)->contents
=
4159 (bfd_byte
*) bfd_zalloc (dynobj
,
4160 bfinfdpic_gotrel_section (info
)->size
);
4161 if (bfinfdpic_gotrel_section (info
)->contents
== NULL
)
4165 bfinfdpic_gotfixup_section (info
)->size
= (gpinfo
.g
.fixups
+ 1) * 4;
4166 if (bfinfdpic_gotfixup_section (info
)->size
== 0)
4167 bfinfdpic_gotfixup_section (info
)->flags
|= SEC_EXCLUDE
;
4170 bfinfdpic_gotfixup_section (info
)->contents
=
4171 (bfd_byte
*) bfd_zalloc (dynobj
,
4172 bfinfdpic_gotfixup_section (info
)->size
);
4173 if (bfinfdpic_gotfixup_section (info
)->contents
== NULL
)
4177 if (elf_hash_table (info
)->dynamic_sections_created
)
4179 bfinfdpic_pltrel_section (info
)->size
=
4180 gpinfo
.g
.lzplt
/ LZPLT_NORMAL_SIZE
* get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
4181 if (bfinfdpic_pltrel_section (info
)->size
== 0)
4182 bfinfdpic_pltrel_section (info
)->flags
|= SEC_EXCLUDE
;
4185 bfinfdpic_pltrel_section (info
)->contents
=
4186 (bfd_byte
*) bfd_zalloc (dynobj
,
4187 bfinfdpic_pltrel_section (info
)->size
);
4188 if (bfinfdpic_pltrel_section (info
)->contents
== NULL
)
4193 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4194 such that there's room for the additional instruction needed to
4195 call the resolver. Since _bfinfdpic_assign_got_entries didn't
4196 account for them, our block size is 4 bytes smaller than the real
4198 if (elf_hash_table (info
)->dynamic_sections_created
)
4200 bfinfdpic_plt_section (info
)->size
= gpinfo
.g
.lzplt
4201 + ((gpinfo
.g
.lzplt
+ (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) - LZPLT_NORMAL_SIZE
)
4202 / (BFINFDPIC_LZPLT_BLOCK_SIZE
- 4) * LZPLT_RESOLVER_EXTRA
);
4205 /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4206 actually assign lazy PLT entries addresses. */
4209 /* Save information that we're going to need to generate GOT and PLT
4211 bfinfdpic_got_initial_offset (info
) = -gpinfo
.gothilo
.min
;
4213 if (get_elf_backend_data (output_bfd
)->want_got_sym
)
4214 elf_hash_table (info
)->hgot
->root
.u
.def
.value
4215 += bfinfdpic_got_initial_offset (info
);
4217 if (elf_hash_table (info
)->dynamic_sections_created
)
4218 bfinfdpic_plt_initial_offset (info
) =
4219 bfinfdpic_plt_section (info
)->size
;
4221 htab_traverse (bfinfdpic_relocs_info (info
), _bfinfdpic_assign_plt_entries
,
4224 /* Allocate the PLT section contents only after
4225 _bfinfdpic_assign_plt_entries has a chance to add the size of the
4226 non-lazy PLT entries. */
4227 if (elf_hash_table (info
)->dynamic_sections_created
)
4229 if (bfinfdpic_plt_section (info
)->size
== 0)
4230 bfinfdpic_plt_section (info
)->flags
|= SEC_EXCLUDE
;
4233 bfinfdpic_plt_section (info
)->contents
=
4234 (bfd_byte
*) bfd_zalloc (dynobj
,
4235 bfinfdpic_plt_section (info
)->size
);
4236 if (bfinfdpic_plt_section (info
)->contents
== NULL
)
4241 if (elf_hash_table (info
)->dynamic_sections_created
)
4243 if (bfinfdpic_got_section (info
)->size
)
4244 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0))
4247 if (bfinfdpic_pltrel_section (info
)->size
)
4248 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
4249 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
4250 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
4253 if (bfinfdpic_gotrel_section (info
)->size
)
4254 if (!_bfd_elf_add_dynamic_entry (info
, DT_REL
, 0)
4255 || !_bfd_elf_add_dynamic_entry (info
, DT_RELSZ
, 0)
4256 || !_bfd_elf_add_dynamic_entry (info
, DT_RELENT
,
4257 sizeof (Elf32_External_Rel
)))
4265 elf32_bfinfdpic_always_size_sections (bfd
*output_bfd
,
4266 struct bfd_link_info
*info
)
4268 if (!info
->relocatable
)
4270 struct elf_link_hash_entry
*h
;
4272 /* Force a PT_GNU_STACK segment to be created. */
4273 if (! elf_tdata (output_bfd
)->stack_flags
)
4274 elf_tdata (output_bfd
)->stack_flags
= PF_R
| PF_W
| PF_X
;
4276 /* Define __stacksize if it's not defined yet. */
4277 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
4278 FALSE
, FALSE
, FALSE
);
4279 if (! h
|| h
->root
.type
!= bfd_link_hash_defined
4280 || h
->type
!= STT_OBJECT
4283 struct bfd_link_hash_entry
*bh
= NULL
;
4285 if (!(_bfd_generic_link_add_one_symbol
4286 (info
, output_bfd
, "__stacksize",
4287 BSF_GLOBAL
, bfd_abs_section_ptr
, DEFAULT_STACK_SIZE
,
4288 (const char *) NULL
, FALSE
,
4289 get_elf_backend_data (output_bfd
)->collect
, &bh
)))
4292 h
= (struct elf_link_hash_entry
*) bh
;
4294 h
->type
= STT_OBJECT
;
4302 elf32_bfinfdpic_modify_program_headers (bfd
*output_bfd
,
4303 struct bfd_link_info
*info
)
4305 struct elf_obj_tdata
*tdata
= elf_tdata (output_bfd
);
4306 struct elf_segment_map
*m
;
4307 Elf_Internal_Phdr
*p
;
4309 /* objcopy and strip preserve what's already there using
4310 elf32_bfinfdpic_copy_private_bfd_data (). */
4314 for (p
= tdata
->phdr
, m
= tdata
->segment_map
; m
!= NULL
; m
= m
->next
, p
++)
4315 if (m
->p_type
== PT_GNU_STACK
)
4320 struct elf_link_hash_entry
*h
;
4322 /* Obtain the pointer to the __stacksize symbol. */
4323 h
= elf_link_hash_lookup (elf_hash_table (info
), "__stacksize",
4324 FALSE
, FALSE
, FALSE
);
4327 while (h
->root
.type
== bfd_link_hash_indirect
4328 || h
->root
.type
== bfd_link_hash_warning
)
4329 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
4330 BFD_ASSERT (h
->root
.type
== bfd_link_hash_defined
);
4333 /* Set the header p_memsz from the symbol value. We
4334 intentionally ignore the symbol section. */
4335 if (h
&& h
->root
.type
== bfd_link_hash_defined
)
4336 p
->p_memsz
= h
->root
.u
.def
.value
;
4338 p
->p_memsz
= DEFAULT_STACK_SIZE
;
4347 elf32_bfinfdpic_finish_dynamic_sections (bfd
*output_bfd
,
4348 struct bfd_link_info
*info
)
4353 dynobj
= elf_hash_table (info
)->dynobj
;
4355 if (bfinfdpic_got_section (info
))
4357 BFD_ASSERT (bfinfdpic_gotrel_section (info
)->size
4358 == (bfinfdpic_gotrel_section (info
)->reloc_count
4359 * sizeof (Elf32_External_Rel
)));
4361 if (bfinfdpic_gotfixup_section (info
))
4363 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
4364 bfd_vma got_value
= hgot
->root
.u
.def
.value
4365 + hgot
->root
.u
.def
.section
->output_section
->vma
4366 + hgot
->root
.u
.def
.section
->output_offset
;
4368 _bfinfdpic_add_rofixup (output_bfd
, bfinfdpic_gotfixup_section (info
),
4371 if (bfinfdpic_gotfixup_section (info
)->size
4372 != (bfinfdpic_gotfixup_section (info
)->reloc_count
* 4))
4374 (*_bfd_error_handler
)
4375 ("LINKER BUG: .rofixup section size mismatch");
4380 if (elf_hash_table (info
)->dynamic_sections_created
)
4382 BFD_ASSERT (bfinfdpic_pltrel_section (info
)->size
4383 == (bfinfdpic_pltrel_section (info
)->reloc_count
4384 * sizeof (Elf32_External_Rel
)));
4387 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
4389 if (elf_hash_table (info
)->dynamic_sections_created
)
4391 Elf32_External_Dyn
* dyncon
;
4392 Elf32_External_Dyn
* dynconend
;
4394 BFD_ASSERT (sdyn
!= NULL
);
4396 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
4397 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
4399 for (; dyncon
< dynconend
; dyncon
++)
4401 Elf_Internal_Dyn dyn
;
4403 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
4411 dyn
.d_un
.d_ptr
= bfinfdpic_got_section (info
)->output_section
->vma
4412 + bfinfdpic_got_section (info
)->output_offset
4413 + bfinfdpic_got_initial_offset (info
);
4414 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4418 dyn
.d_un
.d_ptr
= bfinfdpic_pltrel_section (info
)
4419 ->output_section
->vma
4420 + bfinfdpic_pltrel_section (info
)->output_offset
;
4421 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4425 dyn
.d_un
.d_val
= bfinfdpic_pltrel_section (info
)->size
;
4426 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
4435 /* Adjust a symbol defined by a dynamic object and referenced by a
4439 elf32_bfinfdpic_adjust_dynamic_symbol
4440 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4441 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
4445 dynobj
= elf_hash_table (info
)->dynobj
;
4447 /* Make sure we know what is going on here. */
4448 BFD_ASSERT (dynobj
!= NULL
4449 && (h
->u
.weakdef
!= NULL
4452 && !h
->def_regular
)));
4454 /* If this is a weak symbol, and there is a real definition, the
4455 processor independent code will have arranged for us to see the
4456 real definition first, and we can just use the same value. */
4457 if (h
->u
.weakdef
!= NULL
)
4459 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
4460 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
4461 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
4462 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
4468 /* Perform any actions needed for dynamic symbols. */
4471 elf32_bfinfdpic_finish_dynamic_symbol
4472 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4473 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4474 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
4475 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
4480 /* Decide whether to attempt to turn absptr or lsda encodings in
4481 shared libraries into pcrel within the given input section. */
4484 bfinfdpic_elf_use_relative_eh_frame
4485 (bfd
*input_bfd ATTRIBUTE_UNUSED
,
4486 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
4487 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
4489 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
4493 /* Adjust the contents of an eh_frame_hdr section before they're output. */
4496 bfinfdpic_elf_encode_eh_address (bfd
*abfd
,
4497 struct bfd_link_info
*info
,
4498 asection
*osec
, bfd_vma offset
,
4499 asection
*loc_sec
, bfd_vma loc_offset
,
4502 struct elf_link_hash_entry
*h
;
4504 h
= elf_hash_table (info
)->hgot
;
4505 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
4507 if (! h
|| (_bfinfdpic_osec_to_segment (abfd
, osec
)
4508 == _bfinfdpic_osec_to_segment (abfd
, loc_sec
->output_section
)))
4509 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
4510 loc_sec
, loc_offset
, encoded
);
4512 BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd
, osec
)
4513 == (_bfinfdpic_osec_to_segment
4514 (abfd
, h
->root
.u
.def
.section
->output_section
)));
4516 *encoded
= osec
->vma
+ offset
4517 - (h
->root
.u
.def
.value
4518 + h
->root
.u
.def
.section
->output_section
->vma
4519 + h
->root
.u
.def
.section
->output_offset
);
4521 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
4526 /* Look through the relocs for a section during the first phase.
4528 Besides handling virtual table relocs for gc, we have to deal with
4529 all sorts of PIC-related relocations. We describe below the
4530 general plan on how to handle such relocations, even though we only
4531 collect information at this point, storing them in hash tables for
4532 perusal of later passes.
4534 32 relocations are propagated to the linker output when creating
4535 position-independent output. LO16 and HI16 relocations are not
4536 supposed to be encountered in this case.
4538 LABEL16 should always be resolvable by the linker, since it's only
4541 LABEL24, on the other hand, is used by calls. If it turns out that
4542 the target of a call is a dynamic symbol, a PLT entry must be
4543 created for it, which triggers the creation of a private function
4544 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4546 GPREL relocations require the referenced symbol to be in the same
4547 segment as _gp, but this can only be checked later.
4549 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4550 exist. LABEL24 might as well, since it may require a PLT entry,
4551 that will require a got.
4553 Non-FUNCDESC GOT relocations require a GOT entry to be created
4554 regardless of whether the symbol is dynamic. However, since a
4555 global symbol that turns out to not be exported may have the same
4556 address of a non-dynamic symbol, we don't assign GOT entries at
4557 this point, such that we can share them in this case. A relocation
4558 for the GOT entry always has to be created, be it to offset a
4559 private symbol by the section load address, be it to get the symbol
4560 resolved dynamically.
4562 FUNCDESC GOT relocations require a GOT entry to be created, and
4563 handled as if a FUNCDESC relocation was applied to the GOT entry in
4566 FUNCDESC relocations referencing a symbol that turns out to NOT be
4567 dynamic cause a private function descriptor to be created. The
4568 FUNCDESC relocation then decays to a 32 relocation that points at
4569 the private descriptor. If the symbol is dynamic, the FUNCDESC
4570 relocation is propagated to the linker output, such that the
4571 dynamic linker creates the canonical descriptor, pointing to the
4572 dynamically-resolved definition of the function.
4574 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4575 symbols that are assigned to the same segment as the GOT, but we
4576 can only check this later, after we know the complete set of
4577 symbols defined and/or exported.
4579 FUNCDESC GOTOFF relocations require a function descriptor to be
4580 created and, unless lazy binding is disabled or the symbol is not
4581 dynamic, a lazy PLT entry. Since we can't tell at this point
4582 whether a symbol is going to be dynamic, we have to decide later
4583 whether to create a lazy PLT entry or bind the descriptor directly
4584 to the private function.
4586 FUNCDESC_VALUE relocations are not supposed to be present in object
4587 files, but they may very well be simply propagated to the linker
4588 output, since they have no side effect.
4591 A function descriptor always requires a FUNCDESC_VALUE relocation.
4592 Whether it's in .plt.rel or not depends on whether lazy binding is
4593 enabled and on whether the referenced symbol is dynamic.
4595 The existence of a lazy PLT requires the resolverStub lazy PLT
4596 entry to be present.
4599 As for assignment of GOT, PLT and lazy PLT entries, and private
4600 descriptors, we might do them all sequentially, but we can do
4601 better than that. For example, we can place GOT entries and
4602 private function descriptors referenced using 12-bit operands
4603 closer to the PIC register value, such that these relocations don't
4604 overflow. Those that are only referenced with LO16 relocations
4605 could come next, but we may as well place PLT-required function
4606 descriptors in the 12-bit range to make them shorter. Symbols
4607 referenced with LO16/HI16 may come next, but we may place
4608 additional function descriptors in the 16-bit range if we can
4609 reliably tell that we've already placed entries that are ever
4610 referenced with only LO16. PLT entries are therefore generated as
4611 small as possible, while not introducing relocation overflows in
4612 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
4613 generated before or after PLT entries, but not intermingled with
4614 them, such that we can have more lazy PLT entries in range for a
4615 branch to the resolverStub. The resolverStub should be emitted at
4616 the most distant location from the first lazy PLT entry such that
4617 it's still in range for a branch, or closer, if there isn't a need
4618 for so many lazy PLT entries. Additional lazy PLT entries may be
4619 emitted after the resolverStub, as long as branches are still in
4620 range. If the branch goes out of range, longer lazy PLT entries
4623 We could further optimize PLT and lazy PLT entries by giving them
4624 priority in assignment to closer-to-gr17 locations depending on the
4625 number of occurrences of references to them (assuming a function
4626 that's called more often is more important for performance, so its
4627 PLT entry should be faster), or taking hints from the compiler.
4628 Given infinite time and money... :-) */
4631 bfinfdpic_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
,
4632 asection
*sec
, const Elf_Internal_Rela
*relocs
)
4634 Elf_Internal_Shdr
*symtab_hdr
;
4635 struct elf_link_hash_entry
**sym_hashes
;
4636 const Elf_Internal_Rela
*rel
;
4637 const Elf_Internal_Rela
*rel_end
;
4639 struct bfinfdpic_relocs_info
*picrel
;
4641 if (info
->relocatable
)
4644 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
4645 sym_hashes
= elf_sym_hashes (abfd
);
4647 dynobj
= elf_hash_table (info
)->dynobj
;
4648 rel_end
= relocs
+ sec
->reloc_count
;
4649 for (rel
= relocs
; rel
< rel_end
; rel
++)
4651 struct elf_link_hash_entry
*h
;
4652 unsigned long r_symndx
;
4654 r_symndx
= ELF32_R_SYM (rel
->r_info
);
4655 if (r_symndx
< symtab_hdr
->sh_info
)
4658 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
4660 switch (ELF32_R_TYPE (rel
->r_info
))
4662 case R_BFIN_GOT17M4
:
4665 case R_BFIN_FUNCDESC_GOT17M4
:
4666 case R_BFIN_FUNCDESC_GOTHI
:
4667 case R_BFIN_FUNCDESC_GOTLO
:
4668 case R_BFIN_GOTOFF17M4
:
4669 case R_BFIN_GOTOFFHI
:
4670 case R_BFIN_GOTOFFLO
:
4671 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4672 case R_BFIN_FUNCDESC_GOTOFFHI
:
4673 case R_BFIN_FUNCDESC_GOTOFFLO
:
4674 case R_BFIN_FUNCDESC
:
4675 case R_BFIN_FUNCDESC_VALUE
:
4676 if (! IS_FDPIC (abfd
))
4680 case R_pcrel24_jump_l
:
4682 if (IS_FDPIC (abfd
) && ! dynobj
)
4684 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
4685 if (! _bfin_create_got_section (abfd
, info
))
4688 if (! IS_FDPIC (abfd
))
4695 if (h
->dynindx
== -1)
4696 switch (ELF_ST_VISIBILITY (h
->other
))
4702 bfd_elf_link_record_dynamic_symbol (info
, h
);
4706 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info
),
4708 rel
->r_addend
, INSERT
);
4711 picrel
= bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4712 (info
), abfd
, r_symndx
,
4713 rel
->r_addend
, INSERT
);
4723 switch (ELF32_R_TYPE (rel
->r_info
))
4726 case R_pcrel24_jump_l
:
4727 if (IS_FDPIC (abfd
))
4731 case R_BFIN_FUNCDESC_VALUE
:
4732 picrel
->relocsfdv
++;
4733 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
4738 if (! IS_FDPIC (abfd
))
4742 if (bfd_get_section_flags (abfd
, sec
) & SEC_ALLOC
)
4746 case R_BFIN_GOT17M4
:
4755 case R_BFIN_FUNCDESC_GOT17M4
:
4756 picrel
->fdgot17m4
++;
4759 case R_BFIN_FUNCDESC_GOTHI
:
4760 case R_BFIN_FUNCDESC_GOTLO
:
4761 picrel
->fdgothilo
++;
4764 case R_BFIN_GOTOFF17M4
:
4765 case R_BFIN_GOTOFFHI
:
4766 case R_BFIN_GOTOFFLO
:
4770 case R_BFIN_FUNCDESC_GOTOFF17M4
:
4771 picrel
->fdgoff17m4
++;
4774 case R_BFIN_FUNCDESC_GOTOFFHI
:
4775 case R_BFIN_FUNCDESC_GOTOFFLO
:
4776 picrel
->fdgoffhilo
++;
4779 case R_BFIN_FUNCDESC
:
4784 /* This relocation describes the C++ object vtable hierarchy.
4785 Reconstruct it for later use during GC. */
4786 case R_BFIN_GNU_VTINHERIT
:
4787 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
4791 /* This relocation describes which C++ vtable entries are actually
4792 used. Record for later use during GC. */
4793 case R_BFIN_GNU_VTENTRY
:
4794 BFD_ASSERT (h
!= NULL
);
4796 && !bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
4802 case R_pcrel12_jump_s
:
4808 (*_bfd_error_handler
)
4809 (_("%B: unsupported relocation type %i"),
4810 abfd
, ELF32_R_TYPE (rel
->r_info
));
4818 /* Set the right machine number for a Blackfin ELF file. */
4821 elf32_bfin_object_p (bfd
*abfd
)
4823 bfd_default_set_arch_mach (abfd
, bfd_arch_bfin
, 0);
4824 return (((elf_elfheader (abfd
)->e_flags
& EF_BFIN_FDPIC
) != 0)
4825 == (IS_FDPIC (abfd
)));
4829 elf32_bfin_set_private_flags (bfd
* abfd
, flagword flags
)
4831 elf_elfheader (abfd
)->e_flags
= flags
;
4832 elf_flags_init (abfd
) = TRUE
;
4836 /* Copy backend specific data from one object module to another. */
4839 bfin_elf_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4841 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4842 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4845 BFD_ASSERT (!elf_flags_init (obfd
)
4846 || elf_elfheader (obfd
)->e_flags
== elf_elfheader (ibfd
)->e_flags
);
4848 elf_elfheader (obfd
)->e_flags
= elf_elfheader (ibfd
)->e_flags
;
4849 elf_flags_init (obfd
) = TRUE
;
4851 /* Copy object attributes. */
4852 _bfd_elf_copy_obj_attributes (ibfd
, obfd
);
4858 elf32_bfinfdpic_copy_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4862 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
4863 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
4866 if (! bfin_elf_copy_private_bfd_data (ibfd
, obfd
))
4869 if (! elf_tdata (ibfd
) || ! elf_tdata (ibfd
)->phdr
4870 || ! elf_tdata (obfd
) || ! elf_tdata (obfd
)->phdr
)
4873 /* Copy the stack size. */
4874 for (i
= 0; i
< elf_elfheader (ibfd
)->e_phnum
; i
++)
4875 if (elf_tdata (ibfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
4877 Elf_Internal_Phdr
*iphdr
= &elf_tdata (ibfd
)->phdr
[i
];
4879 for (i
= 0; i
< elf_elfheader (obfd
)->e_phnum
; i
++)
4880 if (elf_tdata (obfd
)->phdr
[i
].p_type
== PT_GNU_STACK
)
4882 memcpy (&elf_tdata (obfd
)->phdr
[i
], iphdr
, sizeof (*iphdr
));
4884 /* Rewrite the phdrs, since we're only called after they
4885 were first written. */
4886 if (bfd_seek (obfd
, (bfd_signed_vma
) get_elf_backend_data (obfd
)
4887 ->s
->sizeof_ehdr
, SEEK_SET
) != 0
4888 || get_elf_backend_data (obfd
)->s
4889 ->write_out_phdrs (obfd
, elf_tdata (obfd
)->phdr
,
4890 elf_elfheader (obfd
)->e_phnum
) != 0)
4902 /* Display the flags field. */
4904 elf32_bfin_print_private_bfd_data (bfd
* abfd
, PTR ptr
)
4906 FILE *file
= (FILE *) ptr
;
4909 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
4911 /* Print normal ELF private data. */
4912 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
4914 flags
= elf_elfheader (abfd
)->e_flags
;
4916 /* xgettext:c-format */
4917 fprintf (file
, _("private flags = %lx:"), elf_elfheader (abfd
)->e_flags
);
4919 if (flags
& EF_BFIN_PIC
)
4920 fprintf (file
, " -fpic");
4922 if (flags
& EF_BFIN_FDPIC
)
4923 fprintf (file
, " -mfdpic");
4930 /* Merge backend specific data from an object file to the output
4931 object file when linking. */
4934 elf32_bfin_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
4936 flagword old_flags
, new_flags
;
4937 bfd_boolean error
= FALSE
;
4939 new_flags
= elf_elfheader (ibfd
)->e_flags
;
4940 old_flags
= elf_elfheader (obfd
)->e_flags
;
4942 if (new_flags
& EF_BFIN_FDPIC
)
4943 new_flags
&= ~EF_BFIN_PIC
;
4946 (*_bfd_error_handler
) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4947 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
4948 bfd_get_filename (ibfd
));
4951 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
4953 elf_flags_init (obfd
) = TRUE
;
4954 elf_elfheader (obfd
)->e_flags
= new_flags
;
4957 if (((new_flags
& EF_BFIN_FDPIC
) == 0) != (! IS_FDPIC (obfd
)))
4960 if (IS_FDPIC (obfd
))
4961 (*_bfd_error_handler
)
4962 (_("%s: cannot link non-fdpic object file into fdpic executable"),
4963 bfd_get_filename (ibfd
));
4965 (*_bfd_error_handler
)
4966 (_("%s: cannot link fdpic object file into non-fdpic executable"),
4967 bfd_get_filename (ibfd
));
4971 bfd_set_error (bfd_error_bad_value
);
4976 /* bfin ELF linker hash entry. */
4978 struct bfin_link_hash_entry
4980 struct elf_link_hash_entry root
;
4982 /* Number of PC relative relocs copied for this symbol. */
4983 struct bfin_pcrel_relocs_copied
*pcrel_relocs_copied
;
4986 /* bfin ELF linker hash table. */
4988 struct bfin_link_hash_table
4990 struct elf_link_hash_table root
;
4992 /* Small local sym to section mapping cache. */
4993 struct sym_sec_cache sym_sec
;
4996 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4998 static struct bfd_hash_entry
*
4999 bfin_link_hash_newfunc (struct bfd_hash_entry
*entry
,
5000 struct bfd_hash_table
*table
, const char *string
)
5002 struct bfd_hash_entry
*ret
= entry
;
5004 /* Allocate the structure if it has not already been allocated by a
5007 ret
= bfd_hash_allocate (table
, sizeof (struct bfin_link_hash_entry
));
5011 /* Call the allocation method of the superclass. */
5012 ret
= _bfd_elf_link_hash_newfunc (ret
, table
, string
);
5014 bfin_hash_entry (ret
)->pcrel_relocs_copied
= NULL
;
5019 /* Create an bfin ELF linker hash table. */
5021 static struct bfd_link_hash_table
*
5022 bfin_link_hash_table_create (bfd
* abfd
)
5024 struct bfin_link_hash_table
*ret
;
5025 bfd_size_type amt
= sizeof (struct bfin_link_hash_table
);
5027 ret
= bfd_zalloc (abfd
, amt
);
5031 if (!_bfd_elf_link_hash_table_init (&ret
->root
, abfd
,
5032 bfin_link_hash_newfunc
,
5033 sizeof (struct elf_link_hash_entry
)))
5039 ret
->sym_sec
.abfd
= NULL
;
5041 return &ret
->root
.root
;
5044 /* The size in bytes of an entry in the procedure linkage table. */
5046 /* Finish up the dynamic sections. */
5049 bfin_finish_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5050 struct bfd_link_info
*info
)
5055 dynobj
= elf_hash_table (info
)->dynobj
;
5057 sdyn
= bfd_get_section_by_name (dynobj
, ".dynamic");
5059 if (elf_hash_table (info
)->dynamic_sections_created
)
5061 Elf32_External_Dyn
*dyncon
, *dynconend
;
5063 BFD_ASSERT (sdyn
!= NULL
);
5065 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5066 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5067 for (; dyncon
< dynconend
; dyncon
++)
5069 Elf_Internal_Dyn dyn
;
5071 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5079 /* Finish up dynamic symbol handling. We set the contents of various
5080 dynamic sections here. */
5083 bfin_finish_dynamic_symbol (bfd
* output_bfd
,
5084 struct bfd_link_info
*info
,
5085 struct elf_link_hash_entry
*h
,
5086 Elf_Internal_Sym
* sym
)
5090 dynobj
= elf_hash_table (info
)->dynobj
;
5092 if (h
->got
.offset
!= (bfd_vma
) - 1)
5096 Elf_Internal_Rela rela
;
5099 /* This symbol has an entry in the global offset table.
5102 sgot
= bfd_get_section_by_name (dynobj
, ".got");
5103 srela
= bfd_get_section_by_name (dynobj
, ".rela.got");
5104 BFD_ASSERT (sgot
!= NULL
&& srela
!= NULL
);
5106 rela
.r_offset
= (sgot
->output_section
->vma
5107 + sgot
->output_offset
5108 + (h
->got
.offset
& ~(bfd_vma
) 1));
5110 /* If this is a -Bsymbolic link, and the symbol is defined
5111 locally, we just want to emit a RELATIVE reloc. Likewise if
5112 the symbol was forced to be local because of a version file.
5113 The entry in the global offset table will already have been
5114 initialized in the relocate_section function. */
5117 || h
->dynindx
== -1 || h
->forced_local
) && h
->def_regular
)
5119 fprintf(stderr
, "*** check this relocation %s\n", __FUNCTION__
);
5120 rela
.r_info
= ELF32_R_INFO (0, R_pcrel24
);
5121 rela
.r_addend
= bfd_get_signed_32 (output_bfd
,
5125 offset
& ~(bfd_vma
) 1)));
5129 bfd_put_32 (output_bfd
, (bfd_vma
) 0,
5130 sgot
->contents
+ (h
->got
.offset
& ~(bfd_vma
) 1));
5131 rela
.r_info
= ELF32_R_INFO (h
->dynindx
, R_got
);
5135 loc
= srela
->contents
;
5136 loc
+= srela
->reloc_count
++ * sizeof (Elf32_External_Rela
);
5137 bfd_elf32_swap_reloca_out (output_bfd
, &rela
, loc
);
5144 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
5145 if (strcmp (h
->root
.root
.string
, "__DYNAMIC") == 0
5146 || h
== elf_hash_table (info
)->hgot
)
5147 sym
->st_shndx
= SHN_ABS
;
5152 /* Adjust a symbol defined by a dynamic object and referenced by a
5153 regular object. The current definition is in some section of the
5154 dynamic object, but we're not including those sections. We have to
5155 change the definition to something the rest of the link can
5159 bfin_adjust_dynamic_symbol (struct bfd_link_info
*info
,
5160 struct elf_link_hash_entry
*h
)
5164 unsigned int power_of_two
;
5166 dynobj
= elf_hash_table (info
)->dynobj
;
5168 /* Make sure we know what is going on here. */
5169 BFD_ASSERT (dynobj
!= NULL
5171 || h
->u
.weakdef
!= NULL
5172 || (h
->def_dynamic
&& h
->ref_regular
&& !h
->def_regular
)));
5174 /* If this is a function, put it in the procedure linkage table. We
5175 will fill in the contents of the procedure linkage table later,
5176 when we know the address of the .got section. */
5177 if (h
->type
== STT_FUNC
|| h
->needs_plt
)
5182 /* If this is a weak symbol, and there is a real definition, the
5183 processor independent code will have arranged for us to see the
5184 real definition first, and we can just use the same value. */
5185 if (h
->u
.weakdef
!= NULL
)
5187 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
5188 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
5189 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
5190 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
5194 /* This is a reference to a symbol defined by a dynamic object which
5195 is not a function. */
5197 /* If we are creating a shared library, we must presume that the
5198 only references to the symbol are via the global offset table.
5199 For such cases we need not do anything here; the relocations will
5200 be handled correctly by relocate_section. */
5204 /* We must allocate the symbol in our .dynbss section, which will
5205 become part of the .bss section of the executable. There will be
5206 an entry for this symbol in the .dynsym section. The dynamic
5207 object will contain position independent code, so all references
5208 from the dynamic object to this symbol will go through the global
5209 offset table. The dynamic linker will use the .dynsym entry to
5210 determine the address it must put in the global offset table, so
5211 both the dynamic object and the regular object will refer to the
5212 same memory location for the variable. */
5214 s
= bfd_get_section_by_name (dynobj
, ".dynbss");
5215 BFD_ASSERT (s
!= NULL
);
5217 /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
5218 copy the initial value out of the dynamic object and into the
5219 runtime process image. We need to remember the offset into the
5220 .rela.bss section we are going to use. */
5221 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0)
5225 srel
= bfd_get_section_by_name (dynobj
, ".rela.bss");
5226 BFD_ASSERT (srel
!= NULL
);
5227 srel
->size
+= sizeof (Elf32_External_Rela
);
5231 /* We need to figure out the alignment required for this symbol. I
5232 have no idea how ELF linkers handle this. */
5233 power_of_two
= bfd_log2 (h
->size
);
5234 if (power_of_two
> 3)
5237 /* Apply the required alignment. */
5238 s
->size
= BFD_ALIGN (s
->size
, (bfd_size_type
) (1 << power_of_two
));
5239 if (power_of_two
> bfd_get_section_alignment (dynobj
, s
))
5241 if (!bfd_set_section_alignment (dynobj
, s
, power_of_two
))
5245 /* Define the symbol as being at this point in the section. */
5246 h
->root
.u
.def
.section
= s
;
5247 h
->root
.u
.def
.value
= s
->size
;
5249 /* Increment the section size to make room for the symbol. */
5255 /* The bfin linker needs to keep track of the number of relocs that it
5256 decides to copy in check_relocs for each symbol. This is so that it
5257 can discard PC relative relocs if it doesn't need them when linking
5258 with -Bsymbolic. We store the information in a field extending the
5259 regular ELF linker hash table. */
5261 /* This structure keeps track of the number of PC relative relocs we have
5262 copied for a given symbol. */
5264 struct bfin_pcrel_relocs_copied
5267 struct bfin_pcrel_relocs_copied
*next
;
5268 /* A section in dynobj. */
5270 /* Number of relocs copied in this section. */
5271 bfd_size_type count
;
5274 /* This function is called via elf_link_hash_traverse if we are
5275 creating a shared object. In the -Bsymbolic case it discards the
5276 space allocated to copy PC relative relocs against symbols which
5277 are defined in regular objects. For the normal shared case, it
5278 discards space for pc-relative relocs that have become local due to
5279 symbol visibility changes. We allocated space for them in the
5280 check_relocs routine, but we won't fill them in in the
5281 relocate_section routine.
5283 We also check whether any of the remaining relocations apply
5284 against a readonly section, and set the DF_TEXTREL flag in this
5288 bfin_discard_copies (struct elf_link_hash_entry
*h
, PTR inf
)
5290 struct bfd_link_info
*info
= (struct bfd_link_info
*) inf
;
5291 struct bfin_pcrel_relocs_copied
*s
;
5293 if (h
->root
.type
== bfd_link_hash_warning
)
5294 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
5296 if (!h
->def_regular
|| (!info
->symbolic
&& !h
->forced_local
))
5298 if ((info
->flags
& DF_TEXTREL
) == 0)
5300 /* Look for relocations against read-only sections. */
5301 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5302 s
!= NULL
; s
= s
->next
)
5303 if ((s
->section
->flags
& SEC_READONLY
) != 0)
5305 info
->flags
|= DF_TEXTREL
;
5313 for (s
= bfin_hash_entry (h
)->pcrel_relocs_copied
;
5314 s
!= NULL
; s
= s
->next
)
5315 s
->section
->size
-= s
->count
* sizeof (Elf32_External_Rela
);
5321 bfin_size_dynamic_sections (bfd
* output_bfd ATTRIBUTE_UNUSED
,
5322 struct bfd_link_info
*info
)
5328 dynobj
= elf_hash_table (info
)->dynobj
;
5329 BFD_ASSERT (dynobj
!= NULL
);
5331 if (elf_hash_table (info
)->dynamic_sections_created
)
5333 /* Set the contents of the .interp section to the interpreter. */
5334 if (info
->executable
)
5336 s
= bfd_get_section_by_name (dynobj
, ".interp");
5337 BFD_ASSERT (s
!= NULL
);
5338 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5339 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
5344 /* We may have created entries in the .rela.got section.
5345 However, if we are not creating the dynamic sections, we will
5346 not actually use these entries. Reset the size of .rela.got,
5347 which will cause it to get stripped from the output file
5349 s
= bfd_get_section_by_name (dynobj
, ".rela.got");
5354 /* If this is a -Bsymbolic shared link, then we need to discard all
5355 PC relative relocs against symbols defined in a regular object.
5356 For the normal shared case we discard the PC relative relocs
5357 against symbols that have become local due to visibility changes.
5358 We allocated space for them in the check_relocs routine, but we
5359 will not fill them in in the relocate_section routine. */
5361 elf_link_hash_traverse (elf_hash_table (info
),
5362 bfin_discard_copies
, (PTR
) info
);
5364 /* The check_relocs and adjust_dynamic_symbol entry points have
5365 determined the sizes of the various dynamic sections. Allocate
5368 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
5373 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
5376 /* It's OK to base decisions on the section name, because none
5377 of the dynobj section names depend upon the input files. */
5378 name
= bfd_get_section_name (dynobj
, s
);
5382 if (CONST_STRNEQ (name
, ".rela"))
5386 /* If we don't need this section, strip it from the
5387 output file. This is mostly to handle .rela.bss and
5388 .rela.plt. We must create both sections in
5389 create_dynamic_sections, because they must be created
5390 before the linker maps input sections to output
5391 sections. The linker does that before
5392 adjust_dynamic_symbol is called, and it is that
5393 function which decides whether anything needs to go
5394 into these sections. */
5401 /* We use the reloc_count field as a counter if we need
5402 to copy relocs into the output file. */
5406 else if (! CONST_STRNEQ (name
, ".got"))
5408 /* It's not one of our sections, so don't allocate space. */
5414 s
->flags
|= SEC_EXCLUDE
;
5418 /* Allocate memory for the section contents. */
5419 /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5420 Unused entries should be reclaimed before the section's contents
5421 are written out, but at the moment this does not happen. Thus in
5422 order to prevent writing out garbage, we initialise the section's
5423 contents to zero. */
5424 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
5425 if (s
->contents
== NULL
&& s
->size
!= 0)
5429 if (elf_hash_table (info
)->dynamic_sections_created
)
5431 /* Add some entries to the .dynamic section. We fill in the
5432 values later, in bfin_finish_dynamic_sections, but we
5433 must add the entries now so that we get the correct size for
5434 the .dynamic section. The DT_DEBUG entry is filled in by the
5435 dynamic linker and used by the debugger. */
5436 #define add_dynamic_entry(TAG, VAL) \
5437 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5441 if (!add_dynamic_entry (DT_DEBUG
, 0))
5448 if (!add_dynamic_entry (DT_RELA
, 0)
5449 || !add_dynamic_entry (DT_RELASZ
, 0)
5450 || !add_dynamic_entry (DT_RELAENT
,
5451 sizeof (Elf32_External_Rela
)))
5455 if ((info
->flags
& DF_TEXTREL
) != 0)
5457 if (!add_dynamic_entry (DT_TEXTREL
, 0))
5461 #undef add_dynamic_entry
5466 /* Given a .data section and a .emreloc in-memory section, store
5467 relocation information into the .emreloc section which can be
5468 used at runtime to relocate the section. This is called by the
5469 linker when the --embedded-relocs switch is used. This is called
5470 after the add_symbols entry point has been called for all the
5471 objects, and before the final_link entry point is called. */
5473 bfd_boolean bfd_bfin_elf32_create_embedded_relocs
5474 PARAMS ((bfd
*, struct bfd_link_info
*, asection
*, asection
*, char **));
5477 bfd_bfin_elf32_create_embedded_relocs (
5479 struct bfd_link_info
*info
,
5484 Elf_Internal_Shdr
*symtab_hdr
;
5485 Elf_Internal_Sym
*isymbuf
= NULL
;
5486 Elf_Internal_Rela
*internal_relocs
= NULL
;
5487 Elf_Internal_Rela
*irel
, *irelend
;
5491 BFD_ASSERT (! info
->relocatable
);
5495 if (datasec
->reloc_count
== 0)
5498 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5500 /* Get a copy of the native relocations. */
5501 internal_relocs
= (_bfd_elf_link_read_relocs
5502 (abfd
, datasec
, (PTR
) NULL
, (Elf_Internal_Rela
*) NULL
,
5503 info
->keep_memory
));
5504 if (internal_relocs
== NULL
)
5507 amt
= (bfd_size_type
) datasec
->reloc_count
* 12;
5508 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
5509 if (relsec
->contents
== NULL
)
5512 p
= relsec
->contents
;
5514 irelend
= internal_relocs
+ datasec
->reloc_count
;
5515 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 12)
5517 asection
*targetsec
;
5519 /* We are going to write a four byte longword into the runtime
5520 reloc section. The longword will be the address in the data
5521 section which must be relocated. It is followed by the name
5522 of the target section NUL-padded or truncated to 8
5525 /* We can only relocate absolute longword relocs at run time. */
5526 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_byte4_data
)
5528 *errmsg
= _("unsupported reloc type");
5529 bfd_set_error (bfd_error_bad_value
);
5533 /* Get the target section referred to by the reloc. */
5534 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
5536 /* A local symbol. */
5537 Elf_Internal_Sym
*isym
;
5539 /* Read this BFD's local symbols if we haven't done so already. */
5540 if (isymbuf
== NULL
)
5542 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
5543 if (isymbuf
== NULL
)
5544 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
5545 symtab_hdr
->sh_info
, 0,
5547 if (isymbuf
== NULL
)
5551 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
5552 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
5557 struct elf_link_hash_entry
*h
;
5559 /* An external symbol. */
5560 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
5561 h
= elf_sym_hashes (abfd
)[indx
];
5562 BFD_ASSERT (h
!= NULL
);
5563 if (h
->root
.type
== bfd_link_hash_defined
5564 || h
->root
.type
== bfd_link_hash_defweak
)
5565 targetsec
= h
->root
.u
.def
.section
;
5570 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
5571 memset (p
+ 4, 0, 8);
5572 if (targetsec
!= NULL
)
5573 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 8);
5576 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5578 if (internal_relocs
!= NULL
5579 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
5580 free (internal_relocs
);
5584 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
5586 if (internal_relocs
!= NULL
5587 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
5588 free (internal_relocs
);
5592 struct bfd_elf_special_section
const elf32_bfin_special_sections
[] =
5594 { ".l1.text", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_EXECINSTR
},
5595 { ".l1.data", 8, -2, SHT_PROGBITS
, SHF_ALLOC
+ SHF_WRITE
},
5596 { NULL
, 0, 0, 0, 0 }
5600 #define TARGET_LITTLE_SYM bfd_elf32_bfin_vec
5601 #define TARGET_LITTLE_NAME "elf32-bfin"
5602 #define ELF_ARCH bfd_arch_bfin
5603 #define ELF_MACHINE_CODE EM_BLACKFIN
5604 #define ELF_MAXPAGESIZE 0x1000
5605 #define elf_symbol_leading_char '_'
5607 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5608 #define bfd_elf32_bfd_reloc_name_lookup \
5609 bfin_bfd_reloc_name_lookup
5610 #define elf_info_to_howto bfin_info_to_howto
5611 #define elf_info_to_howto_rel 0
5612 #define elf_backend_object_p elf32_bfin_object_p
5614 #define bfd_elf32_bfd_is_local_label_name \
5615 bfin_is_local_label_name
5616 #define bfin_hash_table(p) \
5617 ((struct bfin_link_hash_table *) (p)->hash)
5621 #define elf_backend_create_dynamic_sections \
5622 _bfd_elf_create_dynamic_sections
5623 #define bfd_elf32_bfd_link_hash_table_create \
5624 bfin_link_hash_table_create
5625 #define bfd_elf32_bfd_final_link bfd_elf_gc_common_final_link
5627 #define elf_backend_check_relocs bfin_check_relocs
5628 #define elf_backend_adjust_dynamic_symbol \
5629 bfin_adjust_dynamic_symbol
5630 #define elf_backend_size_dynamic_sections \
5631 bfin_size_dynamic_sections
5632 #define elf_backend_relocate_section bfin_relocate_section
5633 #define elf_backend_finish_dynamic_symbol \
5634 bfin_finish_dynamic_symbol
5635 #define elf_backend_finish_dynamic_sections \
5636 bfin_finish_dynamic_sections
5637 #define elf_backend_gc_mark_hook bfin_gc_mark_hook
5638 #define elf_backend_gc_sweep_hook bfin_gc_sweep_hook
5639 #define bfd_elf32_bfd_merge_private_bfd_data \
5640 elf32_bfin_merge_private_bfd_data
5641 #define bfd_elf32_bfd_set_private_flags \
5642 elf32_bfin_set_private_flags
5643 #define bfd_elf32_bfd_print_private_bfd_data \
5644 elf32_bfin_print_private_bfd_data
5645 #define elf_backend_final_write_processing \
5646 elf32_bfin_final_write_processing
5647 #define elf_backend_reloc_type_class elf32_bfin_reloc_type_class
5648 #define elf_backend_can_gc_sections 1
5649 #define elf_backend_special_sections elf32_bfin_special_sections
5650 #define elf_backend_can_refcount 1
5651 #define elf_backend_want_got_plt 0
5652 #define elf_backend_plt_readonly 1
5653 #define elf_backend_want_plt_sym 0
5654 #define elf_backend_got_header_size 12
5655 #define elf_backend_rela_normal 1
5657 #include "elf32-target.h"
5659 #undef TARGET_LITTLE_SYM
5660 #define TARGET_LITTLE_SYM bfd_elf32_bfinfdpic_vec
5661 #undef TARGET_LITTLE_NAME
5662 #define TARGET_LITTLE_NAME "elf32-bfinfdpic"
5664 #define elf32_bed elf32_bfinfdpic_bed
5666 #undef elf_backend_gc_sweep_hook
5667 #define elf_backend_gc_sweep_hook bfinfdpic_gc_sweep_hook
5669 #undef elf_backend_got_header_size
5670 #define elf_backend_got_header_size 0
5672 #undef elf_backend_relocate_section
5673 #define elf_backend_relocate_section bfinfdpic_relocate_section
5674 #undef elf_backend_check_relocs
5675 #define elf_backend_check_relocs bfinfdpic_check_relocs
5677 #undef bfd_elf32_bfd_link_hash_table_create
5678 #define bfd_elf32_bfd_link_hash_table_create \
5679 bfinfdpic_elf_link_hash_table_create
5680 #undef elf_backend_always_size_sections
5681 #define elf_backend_always_size_sections \
5682 elf32_bfinfdpic_always_size_sections
5683 #undef elf_backend_modify_program_headers
5684 #define elf_backend_modify_program_headers \
5685 elf32_bfinfdpic_modify_program_headers
5686 #undef bfd_elf32_bfd_copy_private_bfd_data
5687 #define bfd_elf32_bfd_copy_private_bfd_data \
5688 elf32_bfinfdpic_copy_private_bfd_data
5690 #undef elf_backend_create_dynamic_sections
5691 #define elf_backend_create_dynamic_sections \
5692 elf32_bfinfdpic_create_dynamic_sections
5693 #undef elf_backend_adjust_dynamic_symbol
5694 #define elf_backend_adjust_dynamic_symbol \
5695 elf32_bfinfdpic_adjust_dynamic_symbol
5696 #undef elf_backend_size_dynamic_sections
5697 #define elf_backend_size_dynamic_sections \
5698 elf32_bfinfdpic_size_dynamic_sections
5699 #undef elf_backend_finish_dynamic_symbol
5700 #define elf_backend_finish_dynamic_symbol \
5701 elf32_bfinfdpic_finish_dynamic_symbol
5702 #undef elf_backend_finish_dynamic_sections
5703 #define elf_backend_finish_dynamic_sections \
5704 elf32_bfinfdpic_finish_dynamic_sections
5706 #undef elf_backend_can_make_relative_eh_frame
5707 #define elf_backend_can_make_relative_eh_frame \
5708 bfinfdpic_elf_use_relative_eh_frame
5709 #undef elf_backend_can_make_lsda_relative_eh_frame
5710 #define elf_backend_can_make_lsda_relative_eh_frame \
5711 bfinfdpic_elf_use_relative_eh_frame
5712 #undef elf_backend_encode_eh_address
5713 #define elf_backend_encode_eh_address \
5714 bfinfdpic_elf_encode_eh_address
5716 #undef elf_backend_may_use_rel_p
5717 #define elf_backend_may_use_rel_p 1
5718 #undef elf_backend_may_use_rela_p
5719 #define elf_backend_may_use_rela_p 1
5720 /* We use REL for dynamic relocations only. */
5721 #undef elf_backend_default_use_rela_p
5722 #define elf_backend_default_use_rela_p 1
5724 #undef elf_backend_omit_section_dynsym
5725 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5727 #include "elf32-target.h"