1 /* FRV-specific support for 32-bit ELF.
2 Copyright (C) 2002-2020 Free Software Foundation, Inc.
4 This file is part of BFD, the Binary File Descriptor library.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
28 #include "libiberty.h"
30 /* Forward declarations. */
33 static reloc_howto_type elf32_frv_howto_table
[] =
35 /* This reloc does nothing. */
36 HOWTO (R_FRV_NONE
, /* type */
38 3, /* size (0 = byte, 1 = short, 2 = long) */
40 FALSE
, /* pc_relative */
42 complain_overflow_dont
, /* complain_on_overflow */
43 bfd_elf_generic_reloc
, /* special_function */
44 "R_FRV_NONE", /* name */
45 FALSE
, /* partial_inplace */
48 FALSE
), /* pcrel_offset */
50 /* A 32 bit absolute relocation. */
51 HOWTO (R_FRV_32
, /* type */
53 2, /* size (0 = byte, 1 = short, 2 = long) */
55 FALSE
, /* pc_relative */
57 complain_overflow_bitfield
, /* complain_on_overflow */
58 bfd_elf_generic_reloc
, /* special_function */
59 "R_FRV_32", /* name */
60 FALSE
, /* partial_inplace */
61 0xffffffff, /* src_mask */
62 0xffffffff, /* dst_mask */
63 FALSE
), /* pcrel_offset */
65 /* A 16 bit pc-relative relocation. */
66 HOWTO (R_FRV_LABEL16
, /* type */
68 2, /* size (0 = byte, 1 = short, 2 = long) */
70 TRUE
, /* pc_relative */
72 complain_overflow_signed
, /* complain_on_overflow */
73 bfd_elf_generic_reloc
, /* special_function */
74 "R_FRV_LABEL16", /* name */
75 FALSE
, /* partial_inplace */
76 0xffff, /* src_mask */
77 0xffff, /* dst_mask */
78 TRUE
), /* pcrel_offset */
80 /* A 24-bit pc-relative relocation. */
81 HOWTO (R_FRV_LABEL24
, /* type */
83 2, /* size (0 = byte, 1 = short, 2 = long) */
85 TRUE
, /* pc_relative */
87 complain_overflow_bitfield
, /* complain_on_overflow */
88 bfd_elf_generic_reloc
, /* special_function */
89 "R_FRV_LABEL24", /* name */
90 FALSE
, /* partial_inplace */
91 0x7e03ffff, /* src_mask */
92 0x7e03ffff, /* dst_mask */
93 TRUE
), /* pcrel_offset */
95 HOWTO (R_FRV_LO16
, /* type */
97 2, /* size (0 = byte, 1 = short, 2 = long) */
99 FALSE
, /* pc_relative */
101 complain_overflow_dont
, /* complain_on_overflow */
102 bfd_elf_generic_reloc
, /* special_function */
103 "R_FRV_LO16", /* name */
104 FALSE
, /* partial_inplace */
105 0xffff, /* src_mask */
106 0xffff, /* dst_mask */
107 FALSE
), /* pcrel_offset */
109 HOWTO (R_FRV_HI16
, /* type */
111 2, /* size (0 = byte, 1 = short, 2 = long) */
113 FALSE
, /* pc_relative */
115 complain_overflow_dont
, /* complain_on_overflow */
116 bfd_elf_generic_reloc
, /* special_function */
117 "R_FRV_HI16", /* name */
118 FALSE
, /* partial_inplace */
119 0xffff, /* src_mask */
120 0xffff, /* dst_mask */
121 FALSE
), /* pcrel_offset */
123 HOWTO (R_FRV_GPREL12
, /* type */
125 2, /* size (0 = byte, 1 = short, 2 = long) */
127 FALSE
, /* pc_relative */
129 complain_overflow_dont
, /* complain_on_overflow */
130 bfd_elf_generic_reloc
, /* special_function */
131 "R_FRV_GPREL12", /* name */
132 FALSE
, /* partial_inplace */
133 0xfff, /* src_mask */
134 0xfff, /* dst_mask */
135 FALSE
), /* pcrel_offset */
137 HOWTO (R_FRV_GPRELU12
, /* type */
139 2, /* size (0 = byte, 1 = short, 2 = long) */
141 FALSE
, /* pc_relative */
143 complain_overflow_dont
, /* complain_on_overflow */
144 bfd_elf_generic_reloc
, /* special_function */
145 "R_FRV_GPRELU12", /* name */
146 FALSE
, /* partial_inplace */
147 0xfff, /* src_mask */
148 0x3f03f, /* dst_mask */
149 FALSE
), /* pcrel_offset */
151 HOWTO (R_FRV_GPREL32
, /* type */
153 2, /* size (0 = byte, 1 = short, 2 = long) */
155 FALSE
, /* pc_relative */
157 complain_overflow_dont
, /* complain_on_overflow */
158 bfd_elf_generic_reloc
, /* special_function */
159 "R_FRV_GPREL32", /* name */
160 FALSE
, /* partial_inplace */
161 0xffffffff, /* src_mask */
162 0xffffffff, /* dst_mask */
163 FALSE
), /* pcrel_offset */
165 HOWTO (R_FRV_GPRELHI
, /* type */
167 2, /* size (0 = byte, 1 = short, 2 = long) */
169 FALSE
, /* pc_relative */
171 complain_overflow_dont
, /* complain_on_overflow */
172 bfd_elf_generic_reloc
, /* special_function */
173 "R_FRV_GPRELHI", /* name */
174 FALSE
, /* partial_inplace */
175 0xffff, /* src_mask */
176 0xffff, /* dst_mask */
177 FALSE
), /* pcrel_offset */
179 HOWTO (R_FRV_GPRELLO
, /* type */
181 2, /* size (0 = byte, 1 = short, 2 = long) */
183 FALSE
, /* pc_relative */
185 complain_overflow_dont
, /* complain_on_overflow */
186 bfd_elf_generic_reloc
, /* special_function */
187 "R_FRV_GPRELLO", /* name */
188 FALSE
, /* partial_inplace */
189 0xffff, /* src_mask */
190 0xffff, /* dst_mask */
191 FALSE
), /* pcrel_offset */
193 /* A 12-bit signed operand with the GOT offset for the address of
195 HOWTO (R_FRV_GOT12
, /* type */
197 2, /* size (0 = byte, 1 = short, 2 = long) */
199 FALSE
, /* pc_relative */
201 complain_overflow_signed
, /* complain_on_overflow */
202 bfd_elf_generic_reloc
, /* special_function */
203 "R_FRV_GOT12", /* name */
204 FALSE
, /* partial_inplace */
205 0xfff, /* src_mask */
206 0xfff, /* dst_mask */
207 FALSE
), /* pcrel_offset */
209 /* The upper 16 bits of the GOT offset for the address of the
211 HOWTO (R_FRV_GOTHI
, /* type */
213 2, /* size (0 = byte, 1 = short, 2 = long) */
215 FALSE
, /* pc_relative */
217 complain_overflow_dont
, /* complain_on_overflow */
218 bfd_elf_generic_reloc
, /* special_function */
219 "R_FRV_GOTHI", /* name */
220 FALSE
, /* partial_inplace */
221 0xffff, /* src_mask */
222 0xffff, /* dst_mask */
223 FALSE
), /* pcrel_offset */
225 /* The lower 16 bits of the GOT offset for the address of the
227 HOWTO (R_FRV_GOTLO
, /* type */
229 2, /* size (0 = byte, 1 = short, 2 = long) */
231 FALSE
, /* pc_relative */
233 complain_overflow_dont
, /* complain_on_overflow */
234 bfd_elf_generic_reloc
, /* special_function */
235 "R_FRV_GOTLO", /* name */
236 FALSE
, /* partial_inplace */
237 0xffff, /* src_mask */
238 0xffff, /* dst_mask */
239 FALSE
), /* pcrel_offset */
241 /* The 32-bit address of the canonical descriptor of a function. */
242 HOWTO (R_FRV_FUNCDESC
, /* type */
244 2, /* size (0 = byte, 1 = short, 2 = long) */
246 FALSE
, /* pc_relative */
248 complain_overflow_bitfield
, /* complain_on_overflow */
249 bfd_elf_generic_reloc
, /* special_function */
250 "R_FRV_FUNCDESC", /* name */
251 FALSE
, /* partial_inplace */
252 0xffffffff, /* src_mask */
253 0xffffffff, /* dst_mask */
254 FALSE
), /* pcrel_offset */
256 /* A 12-bit signed operand with the GOT offset for the address of
257 canonical descriptor of a function. */
258 HOWTO (R_FRV_FUNCDESC_GOT12
, /* type */
260 2, /* size (0 = byte, 1 = short, 2 = long) */
262 FALSE
, /* pc_relative */
264 complain_overflow_signed
, /* complain_on_overflow */
265 bfd_elf_generic_reloc
, /* special_function */
266 "R_FRV_FUNCDESC_GOT12", /* name */
267 FALSE
, /* partial_inplace */
268 0xfff, /* src_mask */
269 0xfff, /* dst_mask */
270 FALSE
), /* pcrel_offset */
272 /* The upper 16 bits of the GOT offset for the address of the
273 canonical descriptor of a function. */
274 HOWTO (R_FRV_FUNCDESC_GOTHI
, /* type */
276 2, /* size (0 = byte, 1 = short, 2 = long) */
278 FALSE
, /* pc_relative */
280 complain_overflow_dont
, /* complain_on_overflow */
281 bfd_elf_generic_reloc
, /* special_function */
282 "R_FRV_FUNCDESC_GOTHI", /* name */
283 FALSE
, /* partial_inplace */
284 0xffff, /* src_mask */
285 0xffff, /* dst_mask */
286 FALSE
), /* pcrel_offset */
288 /* The lower 16 bits of the GOT offset for the address of the
289 canonical descriptor of a function. */
290 HOWTO (R_FRV_FUNCDESC_GOTLO
, /* type */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
294 FALSE
, /* pc_relative */
296 complain_overflow_dont
, /* complain_on_overflow */
297 bfd_elf_generic_reloc
, /* special_function */
298 "R_FRV_FUNCDESC_GOTLO", /* name */
299 FALSE
, /* partial_inplace */
300 0xffff, /* src_mask */
301 0xffff, /* dst_mask */
302 FALSE
), /* pcrel_offset */
304 /* The 64-bit descriptor of a function. */
305 HOWTO (R_FRV_FUNCDESC_VALUE
, /* type */
307 2, /* size (0 = byte, 1 = short, 2 = long) */
309 FALSE
, /* pc_relative */
311 complain_overflow_bitfield
, /* complain_on_overflow */
312 bfd_elf_generic_reloc
, /* special_function */
313 "R_FRV_FUNCDESC_VALUE", /* name */
314 FALSE
, /* partial_inplace */
315 0xffffffff, /* src_mask */
316 0xffffffff, /* dst_mask */
317 FALSE
), /* pcrel_offset */
319 /* A 12-bit signed operand with the GOT offset for the address of
320 canonical descriptor of a function. */
321 HOWTO (R_FRV_FUNCDESC_GOTOFF12
, /* type */
323 2, /* size (0 = byte, 1 = short, 2 = long) */
325 FALSE
, /* pc_relative */
327 complain_overflow_signed
, /* complain_on_overflow */
328 bfd_elf_generic_reloc
, /* special_function */
329 "R_FRV_FUNCDESC_GOTOFF12", /* name */
330 FALSE
, /* partial_inplace */
331 0xfff, /* src_mask */
332 0xfff, /* dst_mask */
333 FALSE
), /* pcrel_offset */
335 /* The upper 16 bits of the GOT offset for the address of the
336 canonical descriptor of a function. */
337 HOWTO (R_FRV_FUNCDESC_GOTOFFHI
, /* type */
339 2, /* size (0 = byte, 1 = short, 2 = long) */
341 FALSE
, /* pc_relative */
343 complain_overflow_dont
, /* complain_on_overflow */
344 bfd_elf_generic_reloc
, /* special_function */
345 "R_FRV_FUNCDESC_GOTOFFHI", /* name */
346 FALSE
, /* partial_inplace */
347 0xffff, /* src_mask */
348 0xffff, /* dst_mask */
349 FALSE
), /* pcrel_offset */
351 /* The lower 16 bits of the GOT offset for the address of the
352 canonical descriptor of a function. */
353 HOWTO (R_FRV_FUNCDESC_GOTOFFLO
, /* type */
355 2, /* size (0 = byte, 1 = short, 2 = long) */
357 FALSE
, /* pc_relative */
359 complain_overflow_dont
, /* complain_on_overflow */
360 bfd_elf_generic_reloc
, /* special_function */
361 "R_FRV_FUNCDESC_GOTOFFLO", /* name */
362 FALSE
, /* partial_inplace */
363 0xffff, /* src_mask */
364 0xffff, /* dst_mask */
365 FALSE
), /* pcrel_offset */
367 /* A 12-bit signed operand with the GOT offset for the address of
369 HOWTO (R_FRV_GOTOFF12
, /* type */
371 2, /* size (0 = byte, 1 = short, 2 = long) */
373 FALSE
, /* pc_relative */
375 complain_overflow_signed
, /* complain_on_overflow */
376 bfd_elf_generic_reloc
, /* special_function */
377 "R_FRV_GOTOFF12", /* name */
378 FALSE
, /* partial_inplace */
379 0xfff, /* src_mask */
380 0xfff, /* dst_mask */
381 FALSE
), /* pcrel_offset */
383 /* The upper 16 bits of the GOT offset for the address of the
385 HOWTO (R_FRV_GOTOFFHI
, /* type */
387 2, /* size (0 = byte, 1 = short, 2 = long) */
389 FALSE
, /* pc_relative */
391 complain_overflow_dont
, /* complain_on_overflow */
392 bfd_elf_generic_reloc
, /* special_function */
393 "R_FRV_GOTOFFHI", /* name */
394 FALSE
, /* partial_inplace */
395 0xffff, /* src_mask */
396 0xffff, /* dst_mask */
397 FALSE
), /* pcrel_offset */
399 /* The lower 16 bits of the GOT offset for the address of the
401 HOWTO (R_FRV_GOTOFFLO
, /* type */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
405 FALSE
, /* pc_relative */
407 complain_overflow_dont
, /* complain_on_overflow */
408 bfd_elf_generic_reloc
, /* special_function */
409 "R_FRV_GOTOFFLO", /* name */
410 FALSE
, /* partial_inplace */
411 0xffff, /* src_mask */
412 0xffff, /* dst_mask */
413 FALSE
), /* pcrel_offset */
415 /* A 24-bit pc-relative relocation referencing the TLS PLT entry for
416 a thread-local symbol. If the symbol number is 0, it refers to
418 HOWTO (R_FRV_GETTLSOFF
, /* type */
420 2, /* size (0 = byte, 1 = short, 2 = long) */
422 TRUE
, /* pc_relative */
424 complain_overflow_bitfield
, /* complain_on_overflow */
425 bfd_elf_generic_reloc
, /* special_function */
426 "R_FRV_GETTLSOFF", /* name */
427 FALSE
, /* partial_inplace */
428 0x7e03ffff, /* src_mask */
429 0x7e03ffff, /* dst_mask */
430 TRUE
), /* pcrel_offset */
432 /* A 64-bit TLS descriptor for a symbol. This relocation is only
433 valid as a REL, dynamic relocation. */
434 HOWTO (R_FRV_TLSDESC_VALUE
, /* type */
436 2, /* size (0 = byte, 1 = short, 2 = long) */
438 FALSE
, /* pc_relative */
440 complain_overflow_bitfield
, /* complain_on_overflow */
441 bfd_elf_generic_reloc
, /* special_function */
442 "R_FRV_TLSDESC_VALUE", /* name */
443 FALSE
, /* partial_inplace */
444 0xffffffff, /* src_mask */
445 0xffffffff, /* dst_mask */
446 FALSE
), /* pcrel_offset */
448 /* A 12-bit signed operand with the GOT offset for the TLS
449 descriptor of the symbol. */
450 HOWTO (R_FRV_GOTTLSDESC12
, /* type */
452 2, /* size (0 = byte, 1 = short, 2 = long) */
454 FALSE
, /* pc_relative */
456 complain_overflow_signed
, /* complain_on_overflow */
457 bfd_elf_generic_reloc
, /* special_function */
458 "R_FRV_GOTTLSDESC12", /* name */
459 FALSE
, /* partial_inplace */
460 0xfff, /* src_mask */
461 0xfff, /* dst_mask */
462 FALSE
), /* pcrel_offset */
464 /* The upper 16 bits of the GOT offset for the TLS descriptor of the
466 HOWTO (R_FRV_GOTTLSDESCHI
, /* type */
468 2, /* size (0 = byte, 1 = short, 2 = long) */
470 FALSE
, /* pc_relative */
472 complain_overflow_dont
, /* complain_on_overflow */
473 bfd_elf_generic_reloc
, /* special_function */
474 "R_FRV_GOTTLSDESCHI", /* name */
475 FALSE
, /* partial_inplace */
476 0xffff, /* src_mask */
477 0xffff, /* dst_mask */
478 FALSE
), /* pcrel_offset */
480 /* The lower 16 bits of the GOT offset for the TLS descriptor of the
482 HOWTO (R_FRV_GOTTLSDESCLO
, /* type */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
486 FALSE
, /* pc_relative */
488 complain_overflow_dont
, /* complain_on_overflow */
489 bfd_elf_generic_reloc
, /* special_function */
490 "R_FRV_GOTTLSDESCLO", /* name */
491 FALSE
, /* partial_inplace */
492 0xffff, /* src_mask */
493 0xffff, /* dst_mask */
494 FALSE
), /* pcrel_offset */
496 /* A 12-bit signed operand with the offset from the module base
497 address to the thread-local symbol address. */
498 HOWTO (R_FRV_TLSMOFF12
, /* type */
500 2, /* size (0 = byte, 1 = short, 2 = long) */
502 FALSE
, /* pc_relative */
504 complain_overflow_signed
, /* complain_on_overflow */
505 bfd_elf_generic_reloc
, /* special_function */
506 "R_FRV_TLSMOFF12", /* name */
507 FALSE
, /* partial_inplace */
508 0xfff, /* src_mask */
509 0xfff, /* dst_mask */
510 FALSE
), /* pcrel_offset */
512 /* The upper 16 bits of the offset from the module base address to
513 the thread-local symbol address. */
514 HOWTO (R_FRV_TLSMOFFHI
, /* type */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
518 FALSE
, /* pc_relative */
520 complain_overflow_dont
, /* complain_on_overflow */
521 bfd_elf_generic_reloc
, /* special_function */
522 "R_FRV_TLSMOFFHI", /* name */
523 FALSE
, /* partial_inplace */
524 0xffff, /* src_mask */
525 0xffff, /* dst_mask */
526 FALSE
), /* pcrel_offset */
528 /* The lower 16 bits of the offset from the module base address to
529 the thread-local symbol address. */
530 HOWTO (R_FRV_TLSMOFFLO
, /* type */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
534 FALSE
, /* pc_relative */
536 complain_overflow_dont
, /* complain_on_overflow */
537 bfd_elf_generic_reloc
, /* special_function */
538 "R_FRV_TLSMOFFLO", /* name */
539 FALSE
, /* partial_inplace */
540 0xffff, /* src_mask */
541 0xffff, /* dst_mask */
542 FALSE
), /* pcrel_offset */
544 /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
546 HOWTO (R_FRV_GOTTLSOFF12
, /* type */
548 2, /* size (0 = byte, 1 = short, 2 = long) */
550 FALSE
, /* pc_relative */
552 complain_overflow_signed
, /* complain_on_overflow */
553 bfd_elf_generic_reloc
, /* special_function */
554 "R_FRV_GOTTLSOFF12", /* name */
555 FALSE
, /* partial_inplace */
556 0xfff, /* src_mask */
557 0xfff, /* dst_mask */
558 FALSE
), /* pcrel_offset */
560 /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
562 HOWTO (R_FRV_GOTTLSOFFHI
, /* type */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
566 FALSE
, /* pc_relative */
568 complain_overflow_dont
, /* complain_on_overflow */
569 bfd_elf_generic_reloc
, /* special_function */
570 "R_FRV_GOTTLSOFFHI", /* name */
571 FALSE
, /* partial_inplace */
572 0xffff, /* src_mask */
573 0xffff, /* dst_mask */
574 FALSE
), /* pcrel_offset */
576 /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
578 HOWTO (R_FRV_GOTTLSOFFLO
, /* type */
580 2, /* size (0 = byte, 1 = short, 2 = long) */
582 FALSE
, /* pc_relative */
584 complain_overflow_dont
, /* complain_on_overflow */
585 bfd_elf_generic_reloc
, /* special_function */
586 "R_FRV_GOTTLSOFFLO", /* name */
587 FALSE
, /* partial_inplace */
588 0xffff, /* src_mask */
589 0xffff, /* dst_mask */
590 FALSE
), /* pcrel_offset */
592 /* The 32-bit offset from the thread pointer (not the module base
593 address) to a thread-local symbol. */
594 HOWTO (R_FRV_TLSOFF
, /* type */
596 2, /* size (0 = byte, 1 = short, 2 = long) */
598 FALSE
, /* pc_relative */
600 complain_overflow_dont
, /* complain_on_overflow */
601 bfd_elf_generic_reloc
, /* special_function */
602 "R_FRV_TLSOFF", /* name */
603 FALSE
, /* partial_inplace */
604 0xffffffff, /* src_mask */
605 0xffffffff, /* dst_mask */
606 FALSE
), /* pcrel_offset */
608 /* An annotation for linker relaxation, that denotes the
609 symbol+addend whose TLS descriptor is referenced by the sum of
610 the two input registers of an ldd instruction. */
611 HOWTO (R_FRV_TLSDESC_RELAX
, /* type */
613 2, /* size (0 = byte, 1 = short, 2 = long) */
615 FALSE
, /* pc_relative */
617 complain_overflow_dont
, /* complain_on_overflow */
618 bfd_elf_generic_reloc
, /* special_function */
619 "R_FRV_TLSDESC_RELAX", /* name */
620 FALSE
, /* partial_inplace */
623 FALSE
), /* pcrel_offset */
625 /* An annotation for linker relaxation, that denotes the
626 symbol+addend whose TLS resolver entry point is given by the sum
627 of the two register operands of an calll instruction. */
628 HOWTO (R_FRV_GETTLSOFF_RELAX
, /* type */
630 2, /* size (0 = byte, 1 = short, 2 = long) */
632 FALSE
, /* pc_relative */
634 complain_overflow_dont
, /* complain_on_overflow */
635 bfd_elf_generic_reloc
, /* special_function */
636 "R_FRV_GETTLSOFF_RELAX", /* name */
637 FALSE
, /* partial_inplace */
640 FALSE
), /* pcrel_offset */
642 /* An annotation for linker relaxation, that denotes the
643 symbol+addend whose TLS offset GOT entry is given by the sum of
644 the two input registers of an ld instruction. */
645 HOWTO (R_FRV_TLSOFF_RELAX
, /* type */
647 2, /* size (0 = byte, 1 = short, 2 = long) */
649 FALSE
, /* pc_relative */
651 complain_overflow_bitfield
, /* complain_on_overflow */
652 bfd_elf_generic_reloc
, /* special_function */
653 "R_FRV_TLSOFF_RELAX", /* name */
654 FALSE
, /* partial_inplace */
657 FALSE
), /* pcrel_offset */
659 /* A 32-bit offset from the module base address to
660 the thread-local symbol address. */
661 HOWTO (R_FRV_TLSMOFF
, /* type */
663 2, /* size (0 = byte, 1 = short, 2 = long) */
665 FALSE
, /* pc_relative */
667 complain_overflow_dont
, /* complain_on_overflow */
668 bfd_elf_generic_reloc
, /* special_function */
669 "R_FRV_TLSMOFF", /* name */
670 FALSE
, /* partial_inplace */
671 0xffffffff, /* src_mask */
672 0xffffffff, /* dst_mask */
673 FALSE
), /* pcrel_offset */
676 /* GNU extension to record C++ vtable hierarchy. */
677 static reloc_howto_type elf32_frv_vtinherit_howto
=
678 HOWTO (R_FRV_GNU_VTINHERIT
, /* type */
680 2, /* size (0 = byte, 1 = short, 2 = long) */
682 FALSE
, /* pc_relative */
684 complain_overflow_dont
, /* complain_on_overflow */
685 NULL
, /* special_function */
686 "R_FRV_GNU_VTINHERIT", /* name */
687 FALSE
, /* partial_inplace */
690 FALSE
); /* pcrel_offset */
692 /* GNU extension to record C++ vtable member usage. */
693 static reloc_howto_type elf32_frv_vtentry_howto
=
694 HOWTO (R_FRV_GNU_VTENTRY
, /* type */
696 2, /* size (0 = byte, 1 = short, 2 = long) */
698 FALSE
, /* pc_relative */
700 complain_overflow_dont
, /* complain_on_overflow */
701 _bfd_elf_rel_vtable_reloc_fn
, /* special_function */
702 "R_FRV_GNU_VTENTRY", /* name */
703 FALSE
, /* partial_inplace */
706 FALSE
); /* pcrel_offset */
708 /* The following 3 relocations are REL. The only difference to the
709 entries in the table above are that partial_inplace is TRUE. */
710 static reloc_howto_type elf32_frv_rel_32_howto
=
711 HOWTO (R_FRV_32
, /* type */
713 2, /* size (0 = byte, 1 = short, 2 = long) */
715 FALSE
, /* pc_relative */
717 complain_overflow_bitfield
, /* complain_on_overflow */
718 bfd_elf_generic_reloc
, /* special_function */
719 "R_FRV_32", /* name */
720 TRUE
, /* partial_inplace */
721 0xffffffff, /* src_mask */
722 0xffffffff, /* dst_mask */
723 FALSE
); /* pcrel_offset */
725 static reloc_howto_type elf32_frv_rel_funcdesc_howto
=
726 HOWTO (R_FRV_FUNCDESC
, /* type */
728 2, /* size (0 = byte, 1 = short, 2 = long) */
730 FALSE
, /* pc_relative */
732 complain_overflow_bitfield
, /* complain_on_overflow */
733 bfd_elf_generic_reloc
, /* special_function */
734 "R_FRV_FUNCDESC", /* name */
735 TRUE
, /* partial_inplace */
736 0xffffffff, /* src_mask */
737 0xffffffff, /* dst_mask */
738 FALSE
); /* pcrel_offset */
740 static reloc_howto_type elf32_frv_rel_funcdesc_value_howto
=
741 HOWTO (R_FRV_FUNCDESC_VALUE
, /* type */
743 2, /* size (0 = byte, 1 = short, 2 = long) */
745 FALSE
, /* pc_relative */
747 complain_overflow_bitfield
, /* complain_on_overflow */
748 bfd_elf_generic_reloc
, /* special_function */
749 "R_FRV_FUNCDESC_VALUE", /* name */
750 TRUE
, /* partial_inplace */
751 0xffffffff, /* src_mask */
752 0xffffffff, /* dst_mask */
753 FALSE
); /* pcrel_offset */
755 static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto
=
756 /* A 64-bit TLS descriptor for a symbol. The first word resolves to
757 an entry point, and the second resolves to a special argument.
758 If the symbol turns out to be in static TLS, the entry point is a
759 return instruction, and the special argument is the TLS offset
760 for the symbol. If it's in dynamic TLS, the entry point is a TLS
761 offset resolver, and the special argument is a pointer to a data
762 structure allocated by the dynamic loader, containing the GOT
763 address for the offset resolver, the module id, the offset within
764 the module, and anything else the TLS offset resolver might need
765 to determine the TLS offset for the symbol in the running
767 HOWTO (R_FRV_TLSDESC_VALUE
, /* type */
769 2, /* size (0 = byte, 1 = short, 2 = long) */
771 FALSE
, /* pc_relative */
773 complain_overflow_bitfield
, /* complain_on_overflow */
774 bfd_elf_generic_reloc
, /* special_function */
775 "R_FRV_TLSDESC_VALUE", /* name */
776 TRUE
, /* partial_inplace */
777 0xffffffff, /* src_mask */
778 0xffffffff, /* dst_mask */
779 FALSE
); /* pcrel_offset */
781 static reloc_howto_type elf32_frv_rel_tlsoff_howto
=
782 /* The 32-bit offset from the thread pointer (not the module base
783 address) to a thread-local symbol. */
784 HOWTO (R_FRV_TLSOFF
, /* type */
786 2, /* size (0 = byte, 1 = short, 2 = long) */
788 FALSE
, /* pc_relative */
790 complain_overflow_bitfield
, /* complain_on_overflow */
791 bfd_elf_generic_reloc
, /* special_function */
792 "R_FRV_TLSOFF", /* name */
793 TRUE
, /* partial_inplace */
794 0xffffffff, /* src_mask */
795 0xffffffff, /* dst_mask */
796 FALSE
); /* pcrel_offset */
800 extern const bfd_target frv_elf32_fdpic_vec
;
801 #define IS_FDPIC(bfd) ((bfd)->xvec == &frv_elf32_fdpic_vec)
803 /* An extension of the elf hash table data structure, containing some
804 additional FRV-specific data. */
805 struct frvfdpic_elf_link_hash_table
807 struct elf_link_hash_table elf
;
809 /* A pointer to the .rofixup section. */
811 /* GOT base offset. */
813 /* Location of the first non-lazy PLT entry, i.e., the number of
814 bytes taken by lazy PLT entries. If locally-bound TLS
815 descriptors require a ret instruction, it will be placed at this
818 /* A hash table holding information about which symbols were
819 referenced with which PIC-related relocations. */
820 struct htab
*relocs_info
;
821 /* Summary reloc information collected by
822 _frvfdpic_count_got_plt_entries. */
823 struct _frvfdpic_dynamic_got_info
*g
;
826 /* Get the FRV ELF linker hash table from a link_info structure. */
828 #define frvfdpic_hash_table(p) \
829 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
830 == FRV_ELF_DATA ? ((struct frvfdpic_elf_link_hash_table *) ((p)->hash)) : NULL)
832 #define frvfdpic_got_section(info) \
833 (frvfdpic_hash_table (info)->elf.sgot)
834 #define frvfdpic_gotrel_section(info) \
835 (frvfdpic_hash_table (info)->elf.srelgot)
836 #define frvfdpic_gotfixup_section(info) \
837 (frvfdpic_hash_table (info)->sgotfixup)
838 #define frvfdpic_plt_section(info) \
839 (frvfdpic_hash_table (info)->elf.splt)
840 #define frvfdpic_pltrel_section(info) \
841 (frvfdpic_hash_table (info)->elf.srelplt)
842 #define frvfdpic_relocs_info(info) \
843 (frvfdpic_hash_table (info)->relocs_info)
844 #define frvfdpic_got_initial_offset(info) \
845 (frvfdpic_hash_table (info)->got0)
846 #define frvfdpic_plt_initial_offset(info) \
847 (frvfdpic_hash_table (info)->plt0)
848 #define frvfdpic_dynamic_got_plt_info(info) \
849 (frvfdpic_hash_table (info)->g)
851 /* Currently it's the same, but if some day we have a reason to change
852 it, we'd better be using a different macro.
854 FIXME: if there's any TLS PLT entry that uses local-exec or
855 initial-exec models, we could use the ret at the end of any of them
856 instead of adding one more. */
857 #define frvfdpic_plt_tls_ret_offset(info) \
858 (frvfdpic_plt_initial_offset (info))
860 /* The name of the dynamic interpreter. This is put in the .interp
863 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
865 #define DEFAULT_STACK_SIZE 0x20000
867 /* This structure is used to collect the number of entries present in
868 each addressable range of the got. */
869 struct _frvfdpic_dynamic_got_info
871 /* Several bits of information about the current link. */
872 struct bfd_link_info
*info
;
873 /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit
875 bfd_vma got12
, gotlos
, gothilo
;
876 /* Total GOT size needed for function descriptor entries within the 12-,
877 16- or 32-bit ranges. */
878 bfd_vma fd12
, fdlos
, fdhilo
;
879 /* Total GOT size needed by function descriptor entries referenced
880 in PLT entries, that would be profitable to place in offsets
881 close to the PIC register. */
883 /* Total PLT size needed by lazy PLT entries. */
885 /* Total GOT size needed for TLS descriptor entries within the 12-,
886 16- or 32-bit ranges. */
887 bfd_vma tlsd12
, tlsdlos
, tlsdhilo
;
888 /* Total GOT size needed by TLS descriptors referenced in PLT
889 entries, that would be profitable to place in offers close to the
892 /* Total PLT size needed by TLS lazy PLT entries. */
894 /* Number of relocations carried over from input object files. */
895 unsigned long relocs
;
896 /* Number of fixups introduced by relocations in input object files. */
897 unsigned long fixups
;
898 /* The number of fixups that reference the ret instruction added to
899 the PLT for locally-resolved TLS descriptors. */
900 unsigned long tls_ret_refs
;
903 /* This structure is used to assign offsets to got entries, function
904 descriptors, plt entries and lazy plt entries. */
906 struct _frvfdpic_dynamic_got_plt_info
908 /* Summary information collected with _frvfdpic_count_got_plt_entries. */
909 struct _frvfdpic_dynamic_got_info g
;
911 /* For each addressable range, we record a MAX (positive) and MIN
912 (negative) value. CUR is used to assign got entries, and it's
913 incremented from an initial positive value to MAX, then from MIN
914 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
915 assign function descriptors, and it's decreased from an initial
916 non-positive value to MIN, then from MAX down to CUR (unless CUR
917 wraps around first). All of MIN, MAX, CUR and FDCUR always point
918 to even words. ODD, if non-zero, indicates an odd word to be
919 used for the next got entry, otherwise CUR is used and
920 incremented by a pair of words, wrapping around when it reaches
921 MAX. FDCUR is decremented (and wrapped) before the next function
922 descriptor is chosen. FDPLT indicates the number of remaining
923 slots that can be used for function descriptors used only by PLT
926 TMAX, TMIN and TCUR are used to assign TLS descriptors. TCUR
927 starts as MAX, and grows up to TMAX, then wraps around to TMIN
928 and grows up to MIN. TLSDPLT indicates the number of remaining
929 slots that can be used for TLS descriptors used only by TLS PLT
931 struct _frvfdpic_dynamic_got_alloc_data
933 bfd_signed_vma max
, cur
, odd
, fdcur
, min
;
934 bfd_signed_vma tmax
, tcur
, tmin
;
935 bfd_vma fdplt
, tlsdplt
;
936 } got12
, gotlos
, gothilo
;
939 /* Create an FRV ELF linker hash table. */
941 static struct bfd_link_hash_table
*
942 frvfdpic_elf_link_hash_table_create (bfd
*abfd
)
944 struct frvfdpic_elf_link_hash_table
*ret
;
945 size_t amt
= sizeof (struct frvfdpic_elf_link_hash_table
);
947 ret
= bfd_zmalloc (amt
);
951 if (!_bfd_elf_link_hash_table_init (&ret
->elf
, abfd
,
952 _bfd_elf_link_hash_newfunc
,
953 sizeof (struct elf_link_hash_entry
),
960 return &ret
->elf
.root
;
963 /* Decide whether a reference to a symbol can be resolved locally or
964 not. If the symbol is protected, we want the local address, but
965 its function descriptor must be assigned by the dynamic linker. */
966 #define FRVFDPIC_SYM_LOCAL(INFO, H) \
967 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
968 || ! elf_hash_table (INFO)->dynamic_sections_created)
969 #define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
970 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
972 /* This structure collects information on what kind of GOT, PLT or
973 function descriptors are required by relocations that reference a
975 struct frvfdpic_relocs_info
977 /* The index of the symbol, as stored in the relocation r_info, if
978 we have a local symbol; -1 otherwise. */
982 /* The input bfd in which the symbol is defined, if it's a local
985 /* If symndx == -1, the hash table entry corresponding to a global
986 symbol (even if it turns out to bind locally, in which case it
987 should ideally be replaced with section's symndx + addend). */
988 struct elf_link_hash_entry
*h
;
990 /* The addend of the relocation that references the symbol. */
993 /* The fields above are used to identify an entry. The fields below
994 contain information on how an entry is used and, later on, which
995 locations it was assigned. */
996 /* The following 3 fields record whether the symbol+addend above was
997 ever referenced with a GOT relocation. The 12 suffix indicates a
998 GOT12 relocation; los is used for GOTLO relocations that are not
999 matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
1004 /* Whether a FUNCDESC relocation references symbol+addend. */
1006 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1008 unsigned fdgotlos
:1;
1009 unsigned fdgothilo
:1;
1010 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1011 unsigned fdgoff12
:1;
1012 unsigned fdgofflos
:1;
1013 unsigned fdgoffhilo
:1;
1014 /* Whether a GETTLSOFF relocation references symbol+addend. */
1016 /* FIXME: we should probably add tlspltdesc, tlspltoff and
1017 tlspltimm, to tell what kind of TLS PLT entry we're generating.
1018 We might instead just pre-compute flags telling whether the
1019 object is suitable for local exec, initial exec or general
1020 dynamic addressing, and use that all over the place. We could
1021 also try to do a better job of merging TLSOFF and TLSDESC entries
1022 in main executables, but perhaps we can get rid of TLSDESC
1023 entirely in them instead. */
1024 /* Whether a GOTTLSDESC relocation references symbol+addend. */
1025 unsigned tlsdesc12
:1;
1026 unsigned tlsdesclos
:1;
1027 unsigned tlsdeschilo
:1;
1028 /* Whether a GOTTLSOFF relocation references symbol+addend. */
1029 unsigned tlsoff12
:1;
1030 unsigned tlsofflos
:1;
1031 unsigned tlsoffhilo
:1;
1032 /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
1033 GOTOFFHI relocations. The addend doesn't really matter, since we
1034 envision that this will only be used to check whether the symbol
1035 is mapped to the same segment as the got. */
1037 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1039 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1042 /* Whether we need a PLT entry for a symbol. Should be implied by
1044 (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)) */
1046 /* Whether a function descriptor should be created in this link unit
1047 for symbol+addend. Should be implied by something like:
1048 (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
1049 || ((fd || fdgot12 || fdgotlos || fdgothilo)
1050 && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1052 /* Whether a lazy PLT entry is needed for this symbol+addend.
1053 Should be implied by something like:
1054 (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
1055 && ! (info->flags & DF_BIND_NOW)) */
1057 /* Whether we've already emitted GOT relocations and PLT entries as
1058 needed for this symbol. */
1061 /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and
1062 R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing
1064 unsigned relocs32
, relocsfd
, relocsfdv
, relocstlsd
, relocstlsoff
;
1066 /* The number of .rofixups entries and dynamic relocations allocated
1067 for this symbol, minus any that might have already been used. */
1068 unsigned fixups
, dynrelocs
;
1070 /* The offsets of the GOT entries assigned to symbol+addend, to the
1071 function descriptor's address, and to a function descriptor,
1072 respectively. Should be zero if unassigned. The offsets are
1073 counted from the value that will be assigned to the PIC register,
1074 not from the beginning of the .got section. */
1075 bfd_signed_vma got_entry
, fdgot_entry
, fd_entry
;
1076 /* The offsets of the PLT entries assigned to symbol+addend,
1077 non-lazy and lazy, respectively. If unassigned, should be
1079 bfd_vma plt_entry
, lzplt_entry
;
1080 /* The offsets of the GOT entries for TLS offset and TLS descriptor. */
1081 bfd_signed_vma tlsoff_entry
, tlsdesc_entry
;
1082 /* The offset of the TLS offset PLT entry. */
1083 bfd_vma tlsplt_entry
;
1086 /* Compute a hash with the key fields of an frvfdpic_relocs_info entry. */
1088 frvfdpic_relocs_info_hash (const void *entry_
)
1090 const struct frvfdpic_relocs_info
*entry
= entry_
;
1092 return (entry
->symndx
== -1
1093 ? (long) entry
->d
.h
->root
.root
.hash
1094 : entry
->symndx
+ (long) entry
->d
.abfd
->id
* 257) + entry
->addend
;
1097 /* Test whether the key fields of two frvfdpic_relocs_info entries are
1100 frvfdpic_relocs_info_eq (const void *entry1
, const void *entry2
)
1102 const struct frvfdpic_relocs_info
*e1
= entry1
;
1103 const struct frvfdpic_relocs_info
*e2
= entry2
;
1105 return e1
->symndx
== e2
->symndx
&& e1
->addend
== e2
->addend
1106 && (e1
->symndx
== -1 ? e1
->d
.h
== e2
->d
.h
: e1
->d
.abfd
== e2
->d
.abfd
);
1109 /* Find or create an entry in a hash table HT that matches the key
1110 fields of the given ENTRY. If it's not found, memory for a new
1111 entry is allocated in ABFD's obstack. */
1112 static struct frvfdpic_relocs_info
*
1113 frvfdpic_relocs_info_find (struct htab
*ht
,
1115 const struct frvfdpic_relocs_info
*entry
,
1116 enum insert_option insert
)
1118 struct frvfdpic_relocs_info
**loc
=
1119 (struct frvfdpic_relocs_info
**) htab_find_slot (ht
, entry
, insert
);
1127 *loc
= bfd_zalloc (abfd
, sizeof (**loc
));
1132 (*loc
)->symndx
= entry
->symndx
;
1133 (*loc
)->d
= entry
->d
;
1134 (*loc
)->addend
= entry
->addend
;
1135 (*loc
)->plt_entry
= (bfd_vma
)-1;
1136 (*loc
)->lzplt_entry
= (bfd_vma
)-1;
1137 (*loc
)->tlsplt_entry
= (bfd_vma
)-1;
1142 /* Obtain the address of the entry in HT associated with H's symbol +
1143 addend, creating a new entry if none existed. ABFD is only used
1144 for memory allocation purposes. */
1145 inline static struct frvfdpic_relocs_info
*
1146 frvfdpic_relocs_info_for_global (struct htab
*ht
,
1148 struct elf_link_hash_entry
*h
,
1150 enum insert_option insert
)
1152 struct frvfdpic_relocs_info entry
;
1156 entry
.addend
= addend
;
1158 return frvfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1161 /* Obtain the address of the entry in HT associated with the SYMNDXth
1162 local symbol of the input bfd ABFD, plus the addend, creating a new
1163 entry if none existed. */
1164 inline static struct frvfdpic_relocs_info
*
1165 frvfdpic_relocs_info_for_local (struct htab
*ht
,
1169 enum insert_option insert
)
1171 struct frvfdpic_relocs_info entry
;
1173 entry
.symndx
= symndx
;
1174 entry
.d
.abfd
= abfd
;
1175 entry
.addend
= addend
;
1177 return frvfdpic_relocs_info_find (ht
, abfd
, &entry
, insert
);
1180 /* Merge fields set by check_relocs() of two entries that end up being
1181 mapped to the same (presumably global) symbol. */
1184 frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info
*e2
,
1185 struct frvfdpic_relocs_info
const *e1
)
1187 e2
->got12
|= e1
->got12
;
1188 e2
->gotlos
|= e1
->gotlos
;
1189 e2
->gothilo
|= e1
->gothilo
;
1191 e2
->fdgot12
|= e1
->fdgot12
;
1192 e2
->fdgotlos
|= e1
->fdgotlos
;
1193 e2
->fdgothilo
|= e1
->fdgothilo
;
1194 e2
->fdgoff12
|= e1
->fdgoff12
;
1195 e2
->fdgofflos
|= e1
->fdgofflos
;
1196 e2
->fdgoffhilo
|= e1
->fdgoffhilo
;
1197 e2
->tlsplt
|= e1
->tlsplt
;
1198 e2
->tlsdesc12
|= e1
->tlsdesc12
;
1199 e2
->tlsdesclos
|= e1
->tlsdesclos
;
1200 e2
->tlsdeschilo
|= e1
->tlsdeschilo
;
1201 e2
->tlsoff12
|= e1
->tlsoff12
;
1202 e2
->tlsofflos
|= e1
->tlsofflos
;
1203 e2
->tlsoffhilo
|= e1
->tlsoffhilo
;
1204 e2
->gotoff
|= e1
->gotoff
;
1205 e2
->call
|= e1
->call
;
1209 /* Every block of 65535 lazy PLT entries shares a single call to the
1210 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1211 32767, counting from 0). All other lazy PLT entries branch to it
1212 in a single instruction. */
1214 #define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
1215 #define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
1217 /* Add a dynamic relocation to the SRELOC section. */
1219 inline static bfd_vma
1220 _frvfdpic_add_dyn_reloc (bfd
*output_bfd
, asection
*sreloc
, bfd_vma offset
,
1221 int reloc_type
, long dynindx
, bfd_vma addend
,
1222 struct frvfdpic_relocs_info
*entry
)
1224 Elf_Internal_Rela outrel
;
1225 bfd_vma reloc_offset
;
1227 outrel
.r_offset
= offset
;
1228 outrel
.r_info
= ELF32_R_INFO (dynindx
, reloc_type
);
1229 outrel
.r_addend
= addend
;
1231 reloc_offset
= sreloc
->reloc_count
* sizeof (Elf32_External_Rel
);
1232 BFD_ASSERT (reloc_offset
< sreloc
->size
);
1233 bfd_elf32_swap_reloc_out (output_bfd
, &outrel
,
1234 sreloc
->contents
+ reloc_offset
);
1235 sreloc
->reloc_count
++;
1237 /* If the entry's index is zero, this relocation was probably to a
1238 linkonce section that got discarded. We reserved a dynamic
1239 relocation, but it was for another entry than the one we got at
1240 the time of emitting the relocation. Unfortunately there's no
1241 simple way for us to catch this situation, since the relocation
1242 is cleared right before calling relocate_section, at which point
1243 we no longer know what the relocation used to point to. */
1246 BFD_ASSERT (entry
->dynrelocs
> 0);
1250 return reloc_offset
;
1253 /* Add a fixup to the ROFIXUP section. */
1256 _frvfdpic_add_rofixup (bfd
*output_bfd
, asection
*rofixup
, bfd_vma offset
,
1257 struct frvfdpic_relocs_info
*entry
)
1259 bfd_vma fixup_offset
;
1261 if (rofixup
->flags
& SEC_EXCLUDE
)
1264 fixup_offset
= rofixup
->reloc_count
* 4;
1265 if (rofixup
->contents
)
1267 BFD_ASSERT (fixup_offset
< rofixup
->size
);
1268 bfd_put_32 (output_bfd
, offset
, rofixup
->contents
+ fixup_offset
);
1270 rofixup
->reloc_count
++;
1272 if (entry
&& entry
->symndx
)
1274 /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
1276 BFD_ASSERT (entry
->fixups
> 0);
1280 return fixup_offset
;
1283 /* Find the segment number in which OSEC, and output section, is
1287 _frvfdpic_osec_to_segment (bfd
*output_bfd
, asection
*osec
)
1289 Elf_Internal_Phdr
*p
= _bfd_elf_find_segment_containing_section (output_bfd
, osec
);
1291 return (p
!= NULL
) ? p
- elf_tdata (output_bfd
)->phdr
: -1;
1294 inline static bfd_boolean
1295 _frvfdpic_osec_readonly_p (bfd
*output_bfd
, asection
*osec
)
1297 unsigned seg
= _frvfdpic_osec_to_segment (output_bfd
, osec
);
1299 return ! (elf_tdata (output_bfd
)->phdr
[seg
].p_flags
& PF_W
);
1302 #define FRVFDPIC_TLS_BIAS (2048 - 16)
1304 /* Return the base VMA address which should be subtracted from real addresses
1305 when resolving TLSMOFF relocation.
1306 This is PT_TLS segment p_vaddr, plus the 2048-16 bias. */
1309 tls_biased_base (struct bfd_link_info
*info
)
1311 /* If tls_sec is NULL, we should have signalled an error already. */
1312 if (elf_hash_table (info
)->tls_sec
== NULL
)
1313 return FRVFDPIC_TLS_BIAS
;
1314 return elf_hash_table (info
)->tls_sec
->vma
+ FRVFDPIC_TLS_BIAS
;
1317 /* Generate relocations for GOT entries, function descriptors, and
1318 code for PLT and lazy PLT entries. */
1320 inline static bfd_boolean
1321 _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info
*entry
,
1323 struct bfd_link_info
*info
,
1325 Elf_Internal_Sym
*sym
,
1329 bfd_vma fd_lazy_rel_offset
= (bfd_vma
)-1;
1336 if (entry
->got_entry
|| entry
->fdgot_entry
|| entry
->fd_entry
1337 || entry
->tlsoff_entry
|| entry
->tlsdesc_entry
)
1339 /* If the symbol is dynamic, consider it for dynamic
1340 relocations, otherwise decay to section + offset. */
1341 if (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1)
1342 dynindx
= entry
->d
.h
->dynindx
;
1346 && sec
->output_section
1347 && ! bfd_is_abs_section (sec
->output_section
)
1348 && ! bfd_is_und_section (sec
->output_section
))
1349 dynindx
= elf_section_data (sec
->output_section
)->dynindx
;
1355 /* Generate relocation for GOT entry pointing to the symbol. */
1356 if (entry
->got_entry
)
1359 bfd_vma ad
= addend
;
1361 /* If the symbol is dynamic but binds locally, use
1363 if (sec
&& (entry
->symndx
!= -1
1364 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1366 if (entry
->symndx
== -1)
1367 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1369 ad
+= sym
->st_value
;
1370 ad
+= sec
->output_offset
;
1371 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
1372 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1377 /* If we're linking an executable at a fixed address, we can
1378 omit the dynamic relocation as long as the symbol is local to
1380 if (bfd_link_pde (info
)
1381 && (entry
->symndx
!= -1
1382 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1385 ad
+= sec
->output_section
->vma
;
1386 if (entry
->symndx
!= -1
1387 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
1388 _frvfdpic_add_rofixup (output_bfd
,
1389 frvfdpic_gotfixup_section (info
),
1390 frvfdpic_got_section (info
)->output_section
1392 + frvfdpic_got_section (info
)->output_offset
1393 + frvfdpic_got_initial_offset (info
)
1394 + entry
->got_entry
, entry
);
1397 _frvfdpic_add_dyn_reloc (output_bfd
, frvfdpic_gotrel_section (info
),
1398 _bfd_elf_section_offset
1400 frvfdpic_got_section (info
),
1401 frvfdpic_got_initial_offset (info
)
1403 + frvfdpic_got_section (info
)
1404 ->output_section
->vma
1405 + frvfdpic_got_section (info
)->output_offset
,
1406 R_FRV_32
, idx
, ad
, entry
);
1408 bfd_put_32 (output_bfd
, ad
,
1409 frvfdpic_got_section (info
)->contents
1410 + frvfdpic_got_initial_offset (info
)
1411 + entry
->got_entry
);
1414 /* Generate relocation for GOT entry pointing to a canonical
1415 function descriptor. */
1416 if (entry
->fdgot_entry
)
1421 if (! (entry
->symndx
== -1
1422 && entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
1423 && FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1425 /* If the symbol is dynamic and there may be dynamic symbol
1426 resolution because we are, or are linked with, a shared
1427 library, emit a FUNCDESC relocation such that the dynamic
1428 linker will allocate the function descriptor. If the
1429 symbol needs a non-local function descriptor but binds
1430 locally (e.g., its visibility is protected, emit a
1431 dynamic relocation decayed to section+offset. */
1432 if (entry
->symndx
== -1
1433 && ! FRVFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)
1434 && FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)
1435 && !bfd_link_pde (info
))
1437 reloc
= R_FRV_FUNCDESC
;
1438 idx
= elf_section_data (entry
->d
.h
->root
.u
.def
.section
1439 ->output_section
)->dynindx
;
1440 ad
= entry
->d
.h
->root
.u
.def
.section
->output_offset
1441 + entry
->d
.h
->root
.u
.def
.value
;
1443 else if (entry
->symndx
== -1
1444 && ! FRVFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
))
1446 reloc
= R_FRV_FUNCDESC
;
1451 (*info
->callbacks
->reloc_dangerous
)
1452 (info
, _("relocation requires zero addend"),
1453 elf_hash_table (info
)->dynobj
,
1454 frvfdpic_got_section (info
),
1455 entry
->fdgot_entry
);
1461 /* Otherwise, we know we have a private function descriptor,
1462 so reference it directly. */
1463 if (elf_hash_table (info
)->dynamic_sections_created
)
1464 BFD_ASSERT (entry
->privfd
);
1466 idx
= elf_section_data (frvfdpic_got_section (info
)
1467 ->output_section
)->dynindx
;
1468 ad
= frvfdpic_got_section (info
)->output_offset
1469 + frvfdpic_got_initial_offset (info
) + entry
->fd_entry
;
1472 /* If there is room for dynamic symbol resolution, emit the
1473 dynamic relocation. However, if we're linking an
1474 executable at a fixed location, we won't have emitted a
1475 dynamic symbol entry for the got section, so idx will be
1476 zero, which means we can and should compute the address
1477 of the private descriptor ourselves. */
1478 if (bfd_link_pde (info
)
1479 && (entry
->symndx
!= -1
1480 || FRVFDPIC_FUNCDESC_LOCAL (info
, entry
->d
.h
)))
1482 ad
+= frvfdpic_got_section (info
)->output_section
->vma
;
1483 _frvfdpic_add_rofixup (output_bfd
,
1484 frvfdpic_gotfixup_section (info
),
1485 frvfdpic_got_section (info
)
1486 ->output_section
->vma
1487 + frvfdpic_got_section (info
)
1489 + frvfdpic_got_initial_offset (info
)
1490 + entry
->fdgot_entry
, entry
);
1493 _frvfdpic_add_dyn_reloc (output_bfd
,
1494 frvfdpic_gotrel_section (info
),
1495 _bfd_elf_section_offset
1497 frvfdpic_got_section (info
),
1498 frvfdpic_got_initial_offset (info
)
1499 + entry
->fdgot_entry
)
1500 + frvfdpic_got_section (info
)
1501 ->output_section
->vma
1502 + frvfdpic_got_section (info
)
1504 reloc
, idx
, ad
, entry
);
1507 bfd_put_32 (output_bfd
, ad
,
1508 frvfdpic_got_section (info
)->contents
1509 + frvfdpic_got_initial_offset (info
)
1510 + entry
->fdgot_entry
);
1513 /* Generate relocation to fill in a private function descriptor in
1515 if (entry
->fd_entry
)
1518 bfd_vma ad
= addend
;
1520 long lowword
, highword
;
1522 /* If the symbol is dynamic but binds locally, use
1524 if (sec
&& (entry
->symndx
!= -1
1525 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1527 if (entry
->symndx
== -1)
1528 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1530 ad
+= sym
->st_value
;
1531 ad
+= sec
->output_offset
;
1532 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
1533 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1538 /* If we're linking an executable at a fixed address, we can
1539 omit the dynamic relocation as long as the symbol is local to
1541 if (bfd_link_pde (info
)
1542 && (entry
->symndx
!= -1 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1545 ad
+= sec
->output_section
->vma
;
1547 if (entry
->symndx
!= -1
1548 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
1550 _frvfdpic_add_rofixup (output_bfd
,
1551 frvfdpic_gotfixup_section (info
),
1552 frvfdpic_got_section (info
)
1553 ->output_section
->vma
1554 + frvfdpic_got_section (info
)
1556 + frvfdpic_got_initial_offset (info
)
1557 + entry
->fd_entry
, entry
);
1558 _frvfdpic_add_rofixup (output_bfd
,
1559 frvfdpic_gotfixup_section (info
),
1560 frvfdpic_got_section (info
)
1561 ->output_section
->vma
1562 + frvfdpic_got_section (info
)
1564 + frvfdpic_got_initial_offset (info
)
1565 + entry
->fd_entry
+ 4, entry
);
1571 _frvfdpic_add_dyn_reloc (output_bfd
,
1573 ? frvfdpic_pltrel_section (info
)
1574 : frvfdpic_gotrel_section (info
),
1575 _bfd_elf_section_offset
1577 frvfdpic_got_section (info
),
1578 frvfdpic_got_initial_offset (info
)
1580 + frvfdpic_got_section (info
)
1581 ->output_section
->vma
1582 + frvfdpic_got_section (info
)
1584 R_FRV_FUNCDESC_VALUE
, idx
, ad
, entry
);
1587 /* If we've omitted the dynamic relocation, just emit the fixed
1588 addresses of the symbol and of the local GOT base offset. */
1589 if (bfd_link_pde (info
)
1591 && sec
->output_section
)
1594 highword
= frvfdpic_got_section (info
)->output_section
->vma
1595 + frvfdpic_got_section (info
)->output_offset
1596 + frvfdpic_got_initial_offset (info
);
1598 else if (entry
->lazyplt
)
1602 (*info
->callbacks
->reloc_dangerous
)
1603 (info
, _("relocation requires zero addend"),
1604 elf_hash_table (info
)->dynobj
,
1605 frvfdpic_got_section (info
),
1610 fd_lazy_rel_offset
= ofst
;
1612 /* A function descriptor used for lazy or local resolving is
1613 initialized such that its high word contains the output
1614 section index in which the PLT entries are located, and
1615 the low word contains the address of the lazy PLT entry
1616 entry point, that must be within the memory region
1617 assigned to that section. */
1618 lowword
= entry
->lzplt_entry
+ 4
1619 + frvfdpic_plt_section (info
)->output_offset
1620 + frvfdpic_plt_section (info
)->output_section
->vma
;
1621 highword
= _frvfdpic_osec_to_segment
1622 (output_bfd
, frvfdpic_plt_section (info
)->output_section
);
1626 /* A function descriptor for a local function gets the index
1627 of the section. For a non-local function, it's
1631 || (entry
->symndx
== -1 && entry
->d
.h
->dynindx
!= -1
1632 && entry
->d
.h
->dynindx
== idx
))
1635 highword
= _frvfdpic_osec_to_segment
1636 (output_bfd
, sec
->output_section
);
1639 bfd_put_32 (output_bfd
, lowword
,
1640 frvfdpic_got_section (info
)->contents
1641 + frvfdpic_got_initial_offset (info
)
1643 bfd_put_32 (output_bfd
, highword
,
1644 frvfdpic_got_section (info
)->contents
1645 + frvfdpic_got_initial_offset (info
)
1646 + entry
->fd_entry
+ 4);
1649 /* Generate code for the PLT entry. */
1650 if (entry
->plt_entry
!= (bfd_vma
) -1)
1652 bfd_byte
*plt_code
= frvfdpic_plt_section (info
)->contents
1655 BFD_ASSERT (entry
->fd_entry
);
1657 /* Figure out what kind of PLT entry we need, depending on the
1658 location of the function descriptor within the GOT. */
1659 if (entry
->fd_entry
>= -(1 << (12 - 1))
1660 && entry
->fd_entry
< (1 << (12 - 1)))
1662 /* lddi @(gr15, fd_entry), gr14 */
1663 bfd_put_32 (output_bfd
,
1664 0x9cccf000 | (entry
->fd_entry
& ((1 << 12) - 1)),
1670 if (entry
->fd_entry
>= -(1 << (16 - 1))
1671 && entry
->fd_entry
< (1 << (16 - 1)))
1673 /* setlos lo(fd_entry), gr14 */
1674 bfd_put_32 (output_bfd
,
1676 | (entry
->fd_entry
& (((bfd_vma
)1 << 16) - 1)),
1682 /* sethi.p hi(fd_entry), gr14
1683 setlo lo(fd_entry), gr14 */
1684 bfd_put_32 (output_bfd
,
1686 | ((entry
->fd_entry
>> 16)
1687 & (((bfd_vma
)1 << 16) - 1)),
1690 bfd_put_32 (output_bfd
,
1692 | (entry
->fd_entry
& (((bfd_vma
)1 << 16) - 1)),
1696 /* ldd @(gr14,gr15),gr14 */
1697 bfd_put_32 (output_bfd
, 0x9c08e14f, plt_code
);
1700 /* jmpl @(gr14,gr0) */
1701 bfd_put_32 (output_bfd
, 0x8030e000, plt_code
);
1704 /* Generate code for the lazy PLT entry. */
1705 if (entry
->lzplt_entry
!= (bfd_vma
) -1)
1707 bfd_byte
*lzplt_code
= frvfdpic_plt_section (info
)->contents
1708 + entry
->lzplt_entry
;
1709 bfd_vma resolverStub_addr
;
1711 bfd_put_32 (output_bfd
, fd_lazy_rel_offset
, lzplt_code
);
1714 resolverStub_addr
= entry
->lzplt_entry
/ FRVFDPIC_LZPLT_BLOCK_SIZE
1715 * FRVFDPIC_LZPLT_BLOCK_SIZE
+ FRVFDPIC_LZPLT_RESOLV_LOC
;
1716 if (resolverStub_addr
>= frvfdpic_plt_initial_offset (info
))
1717 resolverStub_addr
= frvfdpic_plt_initial_offset (info
) - 12;
1719 if (entry
->lzplt_entry
== resolverStub_addr
)
1721 /* This is a lazy PLT entry that includes a resolver call. */
1722 /* ldd @(gr15,gr0), gr4
1724 bfd_put_32 (output_bfd
, 0x8808f140, lzplt_code
);
1725 bfd_put_32 (output_bfd
, 0x80304000, lzplt_code
+ 4);
1729 /* bra resolverStub */
1730 bfd_put_32 (output_bfd
,
1732 | (((resolverStub_addr
- entry
->lzplt_entry
)
1733 / 4) & (((bfd_vma
)1 << 16) - 1)),
1738 /* Generate relocation for GOT entry holding the TLS offset. */
1739 if (entry
->tlsoff_entry
)
1742 bfd_vma ad
= addend
;
1744 if (entry
->symndx
!= -1
1745 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
))
1747 /* If the symbol is dynamic but binds locally, use
1751 if (entry
->symndx
== -1)
1752 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1754 ad
+= sym
->st_value
;
1755 ad
+= sec
->output_offset
;
1756 if (sec
->output_section
1757 && elf_section_data (sec
->output_section
))
1758 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1764 /* *ABS*+addend is special for TLS relocations, use only the
1766 if (bfd_link_executable (info
)
1768 && (bfd_is_abs_section (sec
)
1769 || bfd_is_und_section (sec
)))
1771 /* If we're linking an executable, we can entirely omit the
1772 dynamic relocation if the symbol is local to this module. */
1773 else if (bfd_link_executable (info
)
1774 && (entry
->symndx
!= -1
1775 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1778 ad
+= sec
->output_section
->vma
- tls_biased_base (info
);
1783 && (bfd_is_abs_section (sec
)
1784 || bfd_is_und_section (sec
)))
1786 if (! elf_hash_table (info
)->tls_sec
)
1788 (*info
->callbacks
->undefined_symbol
)
1789 (info
, "TLS section", elf_hash_table (info
)->dynobj
,
1790 frvfdpic_got_section (info
), entry
->tlsoff_entry
, TRUE
);
1793 idx
= elf_section_data (elf_hash_table (info
)->tls_sec
)->dynindx
;
1794 ad
+= FRVFDPIC_TLS_BIAS
;
1796 _frvfdpic_add_dyn_reloc (output_bfd
, frvfdpic_gotrel_section (info
),
1797 _bfd_elf_section_offset
1799 frvfdpic_got_section (info
),
1800 frvfdpic_got_initial_offset (info
)
1801 + entry
->tlsoff_entry
)
1802 + frvfdpic_got_section (info
)
1803 ->output_section
->vma
1804 + frvfdpic_got_section (info
)
1806 R_FRV_TLSOFF
, idx
, ad
, entry
);
1809 bfd_put_32 (output_bfd
, ad
,
1810 frvfdpic_got_section (info
)->contents
1811 + frvfdpic_got_initial_offset (info
)
1812 + entry
->tlsoff_entry
);
1815 if (entry
->tlsdesc_entry
)
1818 bfd_vma ad
= addend
;
1820 /* If the symbol is dynamic but binds locally, use
1822 if (sec
&& (entry
->symndx
!= -1
1823 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1825 if (entry
->symndx
== -1)
1826 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1828 ad
+= sym
->st_value
;
1829 ad
+= sec
->output_offset
;
1830 if (sec
->output_section
&& elf_section_data (sec
->output_section
))
1831 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1836 /* If we didn't set up a TLS offset entry, but we're linking an
1837 executable and the symbol binds locally, we can use the
1838 module offset in the TLS descriptor in relaxations. */
1839 if (bfd_link_executable (info
) && ! entry
->tlsoff_entry
)
1840 entry
->tlsoff_entry
= entry
->tlsdesc_entry
+ 4;
1842 if (bfd_link_pde (info
)
1844 && (bfd_is_abs_section (sec
)
1845 || bfd_is_und_section (sec
)))
1846 || entry
->symndx
!= -1
1847 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1849 /* *ABS*+addend is special for TLS relocations, use only the
1850 addend for the TLS offset, and take the module id as
1853 && (bfd_is_abs_section (sec
)
1854 || bfd_is_und_section (sec
)))
1856 /* For other TLS symbols that bind locally, add the section
1857 TLS offset to the addend. */
1859 ad
+= sec
->output_section
->vma
- tls_biased_base (info
);
1861 bfd_put_32 (output_bfd
,
1862 frvfdpic_plt_section (info
)->output_section
->vma
1863 + frvfdpic_plt_section (info
)->output_offset
1864 + frvfdpic_plt_tls_ret_offset (info
),
1865 frvfdpic_got_section (info
)->contents
1866 + frvfdpic_got_initial_offset (info
)
1867 + entry
->tlsdesc_entry
);
1869 _frvfdpic_add_rofixup (output_bfd
,
1870 frvfdpic_gotfixup_section (info
),
1871 frvfdpic_got_section (info
)
1872 ->output_section
->vma
1873 + frvfdpic_got_section (info
)
1875 + frvfdpic_got_initial_offset (info
)
1876 + entry
->tlsdesc_entry
, entry
);
1878 BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info
)->tls_ret_refs
);
1880 /* We've used one of the reserved fixups, so discount it so
1881 that we can check at the end that we've used them
1883 frvfdpic_dynamic_got_plt_info (info
)->tls_ret_refs
--;
1885 /* While at that, make sure the ret instruction makes to the
1886 right location in the PLT. We could do it only when we
1887 got to 0, but since the check at the end will only print
1888 a warning, make sure we have the ret in place in case the
1889 warning is missed. */
1890 bfd_put_32 (output_bfd
, 0xc03a4000,
1891 frvfdpic_plt_section (info
)->contents
1892 + frvfdpic_plt_tls_ret_offset (info
));
1897 && (bfd_is_abs_section (sec
)
1898 || bfd_is_und_section (sec
)))
1900 if (! elf_hash_table (info
)->tls_sec
)
1902 (*info
->callbacks
->undefined_symbol
)
1903 (info
, "TLS section", elf_hash_table (info
)->dynobj
,
1904 frvfdpic_got_section (info
), entry
->tlsdesc_entry
, TRUE
);
1907 idx
= elf_section_data (elf_hash_table (info
)->tls_sec
)->dynindx
;
1908 ad
+= FRVFDPIC_TLS_BIAS
;
1911 _frvfdpic_add_dyn_reloc (output_bfd
, frvfdpic_gotrel_section (info
),
1912 _bfd_elf_section_offset
1914 frvfdpic_got_section (info
),
1915 frvfdpic_got_initial_offset (info
)
1916 + entry
->tlsdesc_entry
)
1917 + frvfdpic_got_section (info
)
1918 ->output_section
->vma
1919 + frvfdpic_got_section (info
)
1921 R_FRV_TLSDESC_VALUE
, idx
, ad
, entry
);
1923 bfd_put_32 (output_bfd
, 0,
1924 frvfdpic_got_section (info
)->contents
1925 + frvfdpic_got_initial_offset (info
)
1926 + entry
->tlsdesc_entry
);
1929 bfd_put_32 (output_bfd
, ad
,
1930 frvfdpic_got_section (info
)->contents
1931 + frvfdpic_got_initial_offset (info
)
1932 + entry
->tlsdesc_entry
+ 4);
1935 /* Generate code for the get-TLS-offset PLT entry. */
1936 if (entry
->tlsplt_entry
!= (bfd_vma
) -1)
1938 bfd_byte
*plt_code
= frvfdpic_plt_section (info
)->contents
1939 + entry
->tlsplt_entry
;
1941 if (bfd_link_executable (info
)
1942 && (entry
->symndx
!= -1
1943 || FRVFDPIC_SYM_LOCAL (info
, entry
->d
.h
)))
1946 bfd_vma ad
= addend
;
1948 /* sec may be NULL when referencing an undefweak symbol
1949 while linking a static executable. */
1952 BFD_ASSERT (entry
->symndx
== -1
1953 && entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
);
1957 if (entry
->symndx
== -1)
1958 ad
+= entry
->d
.h
->root
.u
.def
.value
;
1960 ad
+= sym
->st_value
;
1961 ad
+= sec
->output_offset
;
1962 if (sec
->output_section
1963 && elf_section_data (sec
->output_section
))
1964 idx
= elf_section_data (sec
->output_section
)->dynindx
;
1969 /* *ABS*+addend is special for TLS relocations, use only the
1970 addend for the TLS offset, and take the module id as
1973 && (bfd_is_abs_section (sec
)
1974 || bfd_is_und_section (sec
)))
1976 /* For other TLS symbols that bind locally, add the section
1977 TLS offset to the addend. */
1979 ad
+= sec
->output_section
->vma
- tls_biased_base (info
);
1981 if ((bfd_signed_vma
)ad
>= -(1 << (16 - 1))
1982 && (bfd_signed_vma
)ad
< (1 << (16 - 1)))
1984 /* setlos lo(ad), gr9 */
1985 bfd_put_32 (output_bfd
,
1988 & (((bfd_vma
)1 << 16) - 1)),
1994 /* sethi.p hi(ad), gr9
1995 setlo lo(ad), gr9 */
1996 bfd_put_32 (output_bfd
,
1999 & (((bfd_vma
)1 << 16) - 1)),
2002 bfd_put_32 (output_bfd
,
2005 & (((bfd_vma
)1 << 16) - 1)),
2010 bfd_put_32 (output_bfd
, 0xc03a4000, plt_code
);
2012 else if (entry
->tlsoff_entry
)
2014 /* Figure out what kind of PLT entry we need, depending on the
2015 location of the TLS descriptor within the GOT. */
2016 if (entry
->tlsoff_entry
>= -(1 << (12 - 1))
2017 && entry
->tlsoff_entry
< (1 << (12 - 1)))
2019 /* ldi @(gr15, tlsoff_entry), gr9 */
2020 bfd_put_32 (output_bfd
,
2021 0x92c8f000 | (entry
->tlsoff_entry
2028 if (entry
->tlsoff_entry
>= -(1 << (16 - 1))
2029 && entry
->tlsoff_entry
< (1 << (16 - 1)))
2031 /* setlos lo(tlsoff_entry), gr8 */
2032 bfd_put_32 (output_bfd
,
2034 | (entry
->tlsoff_entry
2035 & (((bfd_vma
)1 << 16) - 1)),
2041 /* sethi.p hi(tlsoff_entry), gr8
2042 setlo lo(tlsoff_entry), gr8 */
2043 bfd_put_32 (output_bfd
,
2045 | ((entry
->tlsoff_entry
>> 16)
2046 & (((bfd_vma
)1 << 16) - 1)),
2049 bfd_put_32 (output_bfd
,
2051 | (entry
->tlsoff_entry
2052 & (((bfd_vma
)1 << 16) - 1)),
2056 /* ld @(gr15,gr8),gr9 */
2057 bfd_put_32 (output_bfd
, 0x9008f108, plt_code
);
2061 bfd_put_32 (output_bfd
, 0xc03a4000, plt_code
);
2065 BFD_ASSERT (entry
->tlsdesc_entry
);
2067 /* Figure out what kind of PLT entry we need, depending on the
2068 location of the TLS descriptor within the GOT. */
2069 if (entry
->tlsdesc_entry
>= -(1 << (12 - 1))
2070 && entry
->tlsdesc_entry
< (1 << (12 - 1)))
2072 /* lddi @(gr15, tlsdesc_entry), gr8 */
2073 bfd_put_32 (output_bfd
,
2074 0x90ccf000 | (entry
->tlsdesc_entry
2081 if (entry
->tlsdesc_entry
>= -(1 << (16 - 1))
2082 && entry
->tlsdesc_entry
< (1 << (16 - 1)))
2084 /* setlos lo(tlsdesc_entry), gr8 */
2085 bfd_put_32 (output_bfd
,
2087 | (entry
->tlsdesc_entry
2088 & (((bfd_vma
)1 << 16) - 1)),
2094 /* sethi.p hi(tlsdesc_entry), gr8
2095 setlo lo(tlsdesc_entry), gr8 */
2096 bfd_put_32 (output_bfd
,
2098 | ((entry
->tlsdesc_entry
>> 16)
2099 & (((bfd_vma
)1 << 16) - 1)),
2102 bfd_put_32 (output_bfd
,
2104 | (entry
->tlsdesc_entry
2105 & (((bfd_vma
)1 << 16) - 1)),
2109 /* ldd @(gr15,gr8),gr8 */
2110 bfd_put_32 (output_bfd
, 0x9008f148, plt_code
);
2113 /* jmpl @(gr8,gr0) */
2114 bfd_put_32 (output_bfd
, 0x80308000, plt_code
);
2121 /* Handle an FRV small data reloc. */
2123 static bfd_reloc_status_type
2124 elf32_frv_relocate_gprel12 (struct bfd_link_info
*info
,
2126 asection
*input_section
,
2127 Elf_Internal_Rela
*relocation
,
2133 struct bfd_link_hash_entry
*h
;
2135 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
2137 gp
= (h
->u
.def
.value
2138 + h
->u
.def
.section
->output_section
->vma
2139 + h
->u
.def
.section
->output_offset
);
2141 value
-= input_section
->output_section
->vma
;
2142 value
-= (gp
- input_section
->output_section
->vma
);
2144 insn
= bfd_get_32 (input_bfd
, contents
+ relocation
->r_offset
);
2146 value
+= relocation
->r_addend
;
2148 if ((long) value
> 0x7ff || (long) value
< -0x800)
2149 return bfd_reloc_overflow
;
2151 bfd_put_32 (input_bfd
,
2152 (insn
& 0xfffff000) | (value
& 0xfff),
2153 contents
+ relocation
->r_offset
);
2155 return bfd_reloc_ok
;
2158 /* Handle an FRV small data reloc. for the u12 field. */
2160 static bfd_reloc_status_type
2161 elf32_frv_relocate_gprelu12 (struct bfd_link_info
*info
,
2163 asection
*input_section
,
2164 Elf_Internal_Rela
*relocation
,
2170 struct bfd_link_hash_entry
*h
;
2173 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
2175 gp
= (h
->u
.def
.value
2176 + h
->u
.def
.section
->output_section
->vma
2177 + h
->u
.def
.section
->output_offset
);
2179 value
-= input_section
->output_section
->vma
;
2180 value
-= (gp
- input_section
->output_section
->vma
);
2182 insn
= bfd_get_32 (input_bfd
, contents
+ relocation
->r_offset
);
2184 value
+= relocation
->r_addend
;
2186 if ((long) value
> 0x7ff || (long) value
< -0x800)
2187 return bfd_reloc_overflow
;
2189 /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0. */
2191 insn
= (insn
& ~mask
) | ((value
& 0xfc0) << 12) | (value
& 0x3f);
2193 bfd_put_32 (input_bfd
, insn
, contents
+ relocation
->r_offset
);
2195 return bfd_reloc_ok
;
2198 /* Handle an FRV ELF HI16 reloc. */
2200 static bfd_reloc_status_type
2201 elf32_frv_relocate_hi16 (bfd
*input_bfd
,
2202 Elf_Internal_Rela
*relhi
,
2208 insn
= bfd_get_32 (input_bfd
, contents
+ relhi
->r_offset
);
2210 value
+= relhi
->r_addend
;
2211 value
= ((value
>> 16) & 0xffff);
2213 insn
= (insn
& 0xffff0000) | value
;
2215 if ((long) value
> 0xffff || (long) value
< -0x10000)
2216 return bfd_reloc_overflow
;
2218 bfd_put_32 (input_bfd
, insn
, contents
+ relhi
->r_offset
);
2219 return bfd_reloc_ok
;
2222 static bfd_reloc_status_type
2223 elf32_frv_relocate_lo16 (bfd
*input_bfd
,
2224 Elf_Internal_Rela
*rello
,
2230 insn
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
2232 value
+= rello
->r_addend
;
2233 value
= value
& 0xffff;
2235 insn
= (insn
& 0xffff0000) | value
;
2237 if ((long) value
> 0xffff || (long) value
< -0x10000)
2238 return bfd_reloc_overflow
;
2240 bfd_put_32 (input_bfd
, insn
, contents
+ rello
->r_offset
);
2241 return bfd_reloc_ok
;
2244 /* Perform the relocation for the CALL label24 instruction. */
2246 static bfd_reloc_status_type
2247 elf32_frv_relocate_label24 (bfd
*input_bfd
,
2248 asection
*input_section
,
2249 Elf_Internal_Rela
*rello
,
2257 /* The format for the call instruction is:
2259 0 000000 0001111 000000000000000000
2260 label6 opcode label18
2262 The branch calculation is: pc + (4*label24)
2263 where label24 is the concatenation of label6 and label18. */
2265 /* Grab the instruction. */
2266 insn
= bfd_get_32 (input_bfd
, contents
+ rello
->r_offset
);
2268 value
-= input_section
->output_section
->vma
+ input_section
->output_offset
;
2269 value
-= rello
->r_offset
;
2270 value
+= rello
->r_addend
;
2274 label6
= value
& 0xfc0000;
2275 label6
= label6
<< 7;
2277 label18
= value
& 0x3ffff;
2279 insn
= insn
& 0x803c0000;
2280 insn
= insn
| label6
;
2281 insn
= insn
| label18
;
2283 bfd_put_32 (input_bfd
, insn
, contents
+ rello
->r_offset
);
2285 return bfd_reloc_ok
;
2288 static bfd_reloc_status_type
2289 elf32_frv_relocate_gprelhi (struct bfd_link_info
*info
,
2291 asection
*input_section
,
2292 Elf_Internal_Rela
*relocation
,
2298 struct bfd_link_hash_entry
*h
;
2300 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
2302 gp
= (h
->u
.def
.value
2303 + h
->u
.def
.section
->output_section
->vma
2304 + h
->u
.def
.section
->output_offset
);
2306 value
-= input_section
->output_section
->vma
;
2307 value
-= (gp
- input_section
->output_section
->vma
);
2308 value
+= relocation
->r_addend
;
2309 value
= ((value
>> 16) & 0xffff);
2311 if ((long) value
> 0xffff || (long) value
< -0x10000)
2312 return bfd_reloc_overflow
;
2314 insn
= bfd_get_32 (input_bfd
, contents
+ relocation
->r_offset
);
2315 insn
= (insn
& 0xffff0000) | value
;
2317 bfd_put_32 (input_bfd
, insn
, contents
+ relocation
->r_offset
);
2318 return bfd_reloc_ok
;
2321 static bfd_reloc_status_type
2322 elf32_frv_relocate_gprello (struct bfd_link_info
*info
,
2324 asection
*input_section
,
2325 Elf_Internal_Rela
*relocation
,
2331 struct bfd_link_hash_entry
*h
;
2333 h
= bfd_link_hash_lookup (info
->hash
, "_gp", FALSE
, FALSE
, TRUE
);
2335 gp
= (h
->u
.def
.value
2336 + h
->u
.def
.section
->output_section
->vma
2337 + h
->u
.def
.section
->output_offset
);
2339 value
-= input_section
->output_section
->vma
;
2340 value
-= (gp
- input_section
->output_section
->vma
);
2341 value
+= relocation
->r_addend
;
2342 value
= value
& 0xffff;
2344 if ((long) value
> 0xffff || (long) value
< -0x10000)
2345 return bfd_reloc_overflow
;
2347 insn
= bfd_get_32 (input_bfd
, contents
+ relocation
->r_offset
);
2348 insn
= (insn
& 0xffff0000) | value
;
2350 bfd_put_32 (input_bfd
, insn
, contents
+ relocation
->r_offset
);
2352 return bfd_reloc_ok
;
2355 static reloc_howto_type
*
2356 frv_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
2357 bfd_reloc_code_real_type code
)
2364 case BFD_RELOC_NONE
:
2365 return &elf32_frv_howto_table
[ (int) R_FRV_NONE
];
2368 if (elf_elfheader (abfd
)->e_type
== ET_EXEC
2369 || elf_elfheader (abfd
)->e_type
== ET_DYN
)
2370 return &elf32_frv_rel_32_howto
;
2372 case BFD_RELOC_CTOR
:
2373 return &elf32_frv_howto_table
[ (int) R_FRV_32
];
2375 case BFD_RELOC_FRV_LABEL16
:
2376 return &elf32_frv_howto_table
[ (int) R_FRV_LABEL16
];
2378 case BFD_RELOC_FRV_LABEL24
:
2379 return &elf32_frv_howto_table
[ (int) R_FRV_LABEL24
];
2381 case BFD_RELOC_FRV_LO16
:
2382 return &elf32_frv_howto_table
[ (int) R_FRV_LO16
];
2384 case BFD_RELOC_FRV_HI16
:
2385 return &elf32_frv_howto_table
[ (int) R_FRV_HI16
];
2387 case BFD_RELOC_FRV_GPREL12
:
2388 return &elf32_frv_howto_table
[ (int) R_FRV_GPREL12
];
2390 case BFD_RELOC_FRV_GPRELU12
:
2391 return &elf32_frv_howto_table
[ (int) R_FRV_GPRELU12
];
2393 case BFD_RELOC_FRV_GPREL32
:
2394 return &elf32_frv_howto_table
[ (int) R_FRV_GPREL32
];
2396 case BFD_RELOC_FRV_GPRELHI
:
2397 return &elf32_frv_howto_table
[ (int) R_FRV_GPRELHI
];
2399 case BFD_RELOC_FRV_GPRELLO
:
2400 return &elf32_frv_howto_table
[ (int) R_FRV_GPRELLO
];
2402 case BFD_RELOC_FRV_GOT12
:
2403 return &elf32_frv_howto_table
[ (int) R_FRV_GOT12
];
2405 case BFD_RELOC_FRV_GOTHI
:
2406 return &elf32_frv_howto_table
[ (int) R_FRV_GOTHI
];
2408 case BFD_RELOC_FRV_GOTLO
:
2409 return &elf32_frv_howto_table
[ (int) R_FRV_GOTLO
];
2411 case BFD_RELOC_FRV_FUNCDESC
:
2412 if (elf_elfheader (abfd
)->e_type
== ET_EXEC
2413 || elf_elfheader (abfd
)->e_type
== ET_DYN
)
2414 return &elf32_frv_rel_funcdesc_howto
;
2415 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC
];
2417 case BFD_RELOC_FRV_FUNCDESC_GOT12
:
2418 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_GOT12
];
2420 case BFD_RELOC_FRV_FUNCDESC_GOTHI
:
2421 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_GOTHI
];
2423 case BFD_RELOC_FRV_FUNCDESC_GOTLO
:
2424 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_GOTLO
];
2426 case BFD_RELOC_FRV_FUNCDESC_VALUE
:
2427 if (elf_elfheader (abfd
)->e_type
== ET_EXEC
2428 || elf_elfheader (abfd
)->e_type
== ET_DYN
)
2429 return &elf32_frv_rel_funcdesc_value_howto
;
2430 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_VALUE
];
2432 case BFD_RELOC_FRV_FUNCDESC_GOTOFF12
:
2433 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_GOTOFF12
];
2435 case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI
:
2436 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_GOTOFFHI
];
2438 case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO
:
2439 return &elf32_frv_howto_table
[ (int) R_FRV_FUNCDESC_GOTOFFLO
];
2441 case BFD_RELOC_FRV_GOTOFF12
:
2442 return &elf32_frv_howto_table
[ (int) R_FRV_GOTOFF12
];
2444 case BFD_RELOC_FRV_GOTOFFHI
:
2445 return &elf32_frv_howto_table
[ (int) R_FRV_GOTOFFHI
];
2447 case BFD_RELOC_FRV_GOTOFFLO
:
2448 return &elf32_frv_howto_table
[ (int) R_FRV_GOTOFFLO
];
2450 case BFD_RELOC_FRV_GETTLSOFF
:
2451 return &elf32_frv_howto_table
[ (int) R_FRV_GETTLSOFF
];
2453 case BFD_RELOC_FRV_TLSDESC_VALUE
:
2454 if (elf_elfheader (abfd
)->e_type
== ET_EXEC
2455 || elf_elfheader (abfd
)->e_type
== ET_DYN
)
2456 return &elf32_frv_rel_tlsdesc_value_howto
;
2457 return &elf32_frv_howto_table
[ (int) R_FRV_TLSDESC_VALUE
];
2459 case BFD_RELOC_FRV_GOTTLSDESC12
:
2460 return &elf32_frv_howto_table
[ (int) R_FRV_GOTTLSDESC12
];
2462 case BFD_RELOC_FRV_GOTTLSDESCHI
:
2463 return &elf32_frv_howto_table
[ (int) R_FRV_GOTTLSDESCHI
];
2465 case BFD_RELOC_FRV_GOTTLSDESCLO
:
2466 return &elf32_frv_howto_table
[ (int) R_FRV_GOTTLSDESCLO
];
2468 case BFD_RELOC_FRV_TLSMOFF12
:
2469 return &elf32_frv_howto_table
[ (int) R_FRV_TLSMOFF12
];
2471 case BFD_RELOC_FRV_TLSMOFFHI
:
2472 return &elf32_frv_howto_table
[ (int) R_FRV_TLSMOFFHI
];
2474 case BFD_RELOC_FRV_TLSMOFFLO
:
2475 return &elf32_frv_howto_table
[ (int) R_FRV_TLSMOFFLO
];
2477 case BFD_RELOC_FRV_GOTTLSOFF12
:
2478 return &elf32_frv_howto_table
[ (int) R_FRV_GOTTLSOFF12
];
2480 case BFD_RELOC_FRV_GOTTLSOFFHI
:
2481 return &elf32_frv_howto_table
[ (int) R_FRV_GOTTLSOFFHI
];
2483 case BFD_RELOC_FRV_GOTTLSOFFLO
:
2484 return &elf32_frv_howto_table
[ (int) R_FRV_GOTTLSOFFLO
];
2486 case BFD_RELOC_FRV_TLSOFF
:
2487 if (elf_elfheader (abfd
)->e_type
== ET_EXEC
2488 || elf_elfheader (abfd
)->e_type
== ET_DYN
)
2489 return &elf32_frv_rel_tlsoff_howto
;
2490 return &elf32_frv_howto_table
[ (int) R_FRV_TLSOFF
];
2492 case BFD_RELOC_FRV_TLSDESC_RELAX
:
2493 return &elf32_frv_howto_table
[ (int) R_FRV_TLSDESC_RELAX
];
2495 case BFD_RELOC_FRV_GETTLSOFF_RELAX
:
2496 return &elf32_frv_howto_table
[ (int) R_FRV_GETTLSOFF_RELAX
];
2498 case BFD_RELOC_FRV_TLSOFF_RELAX
:
2499 return &elf32_frv_howto_table
[ (int) R_FRV_TLSOFF_RELAX
];
2501 case BFD_RELOC_FRV_TLSMOFF
:
2502 return &elf32_frv_howto_table
[ (int) R_FRV_TLSMOFF
];
2504 case BFD_RELOC_VTABLE_INHERIT
:
2505 return &elf32_frv_vtinherit_howto
;
2507 case BFD_RELOC_VTABLE_ENTRY
:
2508 return &elf32_frv_vtentry_howto
;
2514 static reloc_howto_type
*
2515 frv_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
, const char *r_name
)
2520 i
< sizeof (elf32_frv_howto_table
) / sizeof (elf32_frv_howto_table
[0]);
2522 if (elf32_frv_howto_table
[i
].name
!= NULL
2523 && strcasecmp (elf32_frv_howto_table
[i
].name
, r_name
) == 0)
2524 return &elf32_frv_howto_table
[i
];
2526 if (strcasecmp (elf32_frv_vtinherit_howto
.name
, r_name
) == 0)
2527 return &elf32_frv_vtinherit_howto
;
2528 if (strcasecmp (elf32_frv_vtentry_howto
.name
, r_name
) == 0)
2529 return &elf32_frv_vtentry_howto
;
2534 /* Set the howto pointer for an FRV ELF reloc. */
2537 frv_info_to_howto_rela (bfd
*abfd ATTRIBUTE_UNUSED
,
2539 Elf_Internal_Rela
*dst
)
2541 unsigned int r_type
;
2543 r_type
= ELF32_R_TYPE (dst
->r_info
);
2546 case R_FRV_GNU_VTINHERIT
:
2547 cache_ptr
->howto
= &elf32_frv_vtinherit_howto
;
2550 case R_FRV_GNU_VTENTRY
:
2551 cache_ptr
->howto
= &elf32_frv_vtentry_howto
;
2555 if (r_type
>= ARRAY_SIZE (elf32_frv_howto_table
))
2557 /* xgettext:c-format */
2558 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
2560 bfd_set_error (bfd_error_bad_value
);
2563 cache_ptr
->howto
= & elf32_frv_howto_table
[r_type
];
2569 /* Set the howto pointer for an FRV ELF REL reloc. */
2572 frvfdpic_info_to_howto_rel (bfd
*abfd ATTRIBUTE_UNUSED
,
2573 arelent
*cache_ptr
, Elf_Internal_Rela
*dst
)
2575 unsigned int r_type
;
2577 r_type
= ELF32_R_TYPE (dst
->r_info
);
2581 cache_ptr
->howto
= &elf32_frv_rel_32_howto
;
2584 case R_FRV_FUNCDESC
:
2585 cache_ptr
->howto
= &elf32_frv_rel_funcdesc_howto
;
2588 case R_FRV_FUNCDESC_VALUE
:
2589 cache_ptr
->howto
= &elf32_frv_rel_funcdesc_value_howto
;
2592 case R_FRV_TLSDESC_VALUE
:
2593 cache_ptr
->howto
= &elf32_frv_rel_tlsdesc_value_howto
;
2597 cache_ptr
->howto
= &elf32_frv_rel_tlsoff_howto
;
2601 cache_ptr
->howto
= NULL
;
2607 /* Perform a single relocation. By default we use the standard BFD
2608 routines, but a few relocs, we have to do them ourselves. */
2610 static bfd_reloc_status_type
2611 frv_final_link_relocate (reloc_howto_type
*howto
,
2613 asection
*input_section
,
2615 Elf_Internal_Rela
*rel
,
2618 return _bfd_final_link_relocate (howto
, input_bfd
, input_section
,
2619 contents
, rel
->r_offset
, relocation
,
2624 /* Relocate an FRV ELF section.
2626 The RELOCATE_SECTION function is called by the new ELF backend linker
2627 to handle the relocations for a section.
2629 The relocs are always passed as Rela structures; if the section
2630 actually uses Rel structures, the r_addend field will always be
2633 This function is responsible for adjusting the section contents as
2634 necessary, and (if using Rela relocs and generating a relocatable
2635 output file) adjusting the reloc addend as necessary.
2637 This function does not have to worry about setting the reloc
2638 address or the reloc symbol index.
2640 LOCAL_SYMS is a pointer to the swapped in local symbols.
2642 LOCAL_SECTIONS is an array giving the section in the input file
2643 corresponding to the st_shndx field of each local symbol.
2645 The global hash table entry for the global symbols can be found
2646 via elf_sym_hashes (input_bfd).
2648 When generating relocatable output, this function must handle
2649 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2650 going to be the section symbol corresponding to the output
2651 section, which means that the addend must be adjusted
2655 elf32_frv_relocate_section (bfd
*output_bfd ATTRIBUTE_UNUSED
,
2656 struct bfd_link_info
*info
,
2658 asection
*input_section
,
2660 Elf_Internal_Rela
*relocs
,
2661 Elf_Internal_Sym
*local_syms
,
2662 asection
**local_sections
)
2664 Elf_Internal_Shdr
*symtab_hdr
;
2665 struct elf_link_hash_entry
**sym_hashes
;
2666 Elf_Internal_Rela
*rel
;
2667 Elf_Internal_Rela
*relend
;
2668 unsigned isec_segment
, got_segment
, plt_segment
, gprel_segment
, tls_segment
,
2670 int silence_segment_error
= !bfd_link_pic (info
);
2673 symtab_hdr
= & elf_tdata (input_bfd
)->symtab_hdr
;
2674 sym_hashes
= elf_sym_hashes (input_bfd
);
2675 relend
= relocs
+ input_section
->reloc_count
;
2677 isec_segment
= _frvfdpic_osec_to_segment (output_bfd
,
2678 input_section
->output_section
);
2679 if (IS_FDPIC (output_bfd
) && frvfdpic_got_section (info
))
2680 got_segment
= _frvfdpic_osec_to_segment (output_bfd
,
2681 frvfdpic_got_section (info
)
2685 if (IS_FDPIC (output_bfd
) && frvfdpic_gotfixup_section (info
))
2686 gprel_segment
= _frvfdpic_osec_to_segment (output_bfd
,
2687 frvfdpic_gotfixup_section (info
)
2691 if (IS_FDPIC (output_bfd
) && frvfdpic_plt_section (info
))
2692 plt_segment
= _frvfdpic_osec_to_segment (output_bfd
,
2693 frvfdpic_plt_section (info
)
2697 if (elf_hash_table (info
)->tls_sec
)
2698 tls_segment
= _frvfdpic_osec_to_segment (output_bfd
,
2699 elf_hash_table (info
)->tls_sec
);
2703 for (rel
= relocs
; rel
< relend
; rel
++)
2705 reloc_howto_type
*howto
;
2706 unsigned long r_symndx
;
2707 Elf_Internal_Sym
*sym
;
2709 struct elf_link_hash_entry
*h
;
2711 bfd_reloc_status_type r
;
2715 struct frvfdpic_relocs_info
*picrel
= NULL
;
2716 bfd_vma orig_addend
= rel
->r_addend
;
2718 r_type
= ELF32_R_TYPE (rel
->r_info
);
2720 if ( r_type
== R_FRV_GNU_VTINHERIT
2721 || r_type
== R_FRV_GNU_VTENTRY
)
2724 r_symndx
= ELF32_R_SYM (rel
->r_info
);
2725 howto
= elf32_frv_howto_table
+ ELF32_R_TYPE (rel
->r_info
);
2730 if (r_symndx
< symtab_hdr
->sh_info
)
2732 sym
= local_syms
+ r_symndx
;
2733 osec
= sec
= local_sections
[r_symndx
];
2734 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
2736 name
= bfd_elf_string_from_elf_section
2737 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
);
2738 if (name
== NULL
|| name
[0] == 0)
2739 name
= bfd_section_name (sec
);
2743 bfd_boolean warned
, ignored
;
2744 bfd_boolean unresolved_reloc
;
2746 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
2747 r_symndx
, symtab_hdr
, sym_hashes
,
2749 unresolved_reloc
, warned
, ignored
);
2751 name
= h
->root
.root
.string
;
2754 if (sec
!= NULL
&& discarded_section (sec
))
2755 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
2756 rel
, 1, relend
, howto
, 0, contents
);
2758 if (bfd_link_relocatable (info
))
2761 if (r_type
!= R_FRV_TLSMOFF
2763 && (h
->root
.type
== bfd_link_hash_defined
2764 || h
->root
.type
== bfd_link_hash_defweak
)
2765 && !FRVFDPIC_SYM_LOCAL (info
, h
))
2775 if (! IS_FDPIC (output_bfd
))
2782 case R_FRV_FUNCDESC_GOT12
:
2783 case R_FRV_FUNCDESC_GOTHI
:
2784 case R_FRV_FUNCDESC_GOTLO
:
2785 case R_FRV_GOTOFF12
:
2786 case R_FRV_GOTOFFHI
:
2787 case R_FRV_GOTOFFLO
:
2788 case R_FRV_FUNCDESC_GOTOFF12
:
2789 case R_FRV_FUNCDESC_GOTOFFHI
:
2790 case R_FRV_FUNCDESC_GOTOFFLO
:
2791 case R_FRV_FUNCDESC
:
2792 case R_FRV_FUNCDESC_VALUE
:
2793 case R_FRV_GETTLSOFF
:
2794 case R_FRV_TLSDESC_VALUE
:
2795 case R_FRV_GOTTLSDESC12
:
2796 case R_FRV_GOTTLSDESCHI
:
2797 case R_FRV_GOTTLSDESCLO
:
2798 case R_FRV_TLSMOFF12
:
2799 case R_FRV_TLSMOFFHI
:
2800 case R_FRV_TLSMOFFLO
:
2801 case R_FRV_GOTTLSOFF12
:
2802 case R_FRV_GOTTLSOFFHI
:
2803 case R_FRV_GOTTLSOFFLO
:
2805 case R_FRV_TLSDESC_RELAX
:
2806 case R_FRV_GETTLSOFF_RELAX
:
2807 case R_FRV_TLSOFF_RELAX
:
2809 if ((input_section
->flags
& SEC_ALLOC
) == 0)
2813 picrel
= frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2814 (info
), input_bfd
, h
,
2815 orig_addend
, INSERT
);
2817 /* In order to find the entry we created before, we must
2818 use the original addend, not the one that may have been
2819 modified by _bfd_elf_rela_local_sym(). */
2820 picrel
= frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2821 (info
), input_bfd
, r_symndx
,
2822 orig_addend
, INSERT
);
2826 if (!_frvfdpic_emit_got_relocs_plt_entries (picrel
, output_bfd
, info
,
2830 info
->callbacks
->einfo
2831 /* xgettext:c-format */
2832 (_("%H: relocation to `%s+%v'"
2833 " may have caused the error above\n"),
2834 input_bfd
, input_section
, rel
->r_offset
, name
, rel
->r_addend
);
2844 && ! FRVFDPIC_SYM_LOCAL (info
, h
)
2845 && _bfd_elf_section_offset (output_bfd
, info
, input_section
,
2846 rel
->r_offset
) != (bfd_vma
) -1)
2848 info
->callbacks
->einfo
2849 (_("%H: relocation references symbol"
2850 " not defined in the module\n"),
2851 input_bfd
, input_section
, rel
->r_offset
);
2859 case R_FRV_GETTLSOFF
:
2860 case R_FRV_TLSDESC_VALUE
:
2861 case R_FRV_GOTTLSDESC12
:
2862 case R_FRV_GOTTLSDESCHI
:
2863 case R_FRV_GOTTLSDESCLO
:
2864 case R_FRV_TLSMOFF12
:
2865 case R_FRV_TLSMOFFHI
:
2866 case R_FRV_TLSMOFFLO
:
2867 case R_FRV_GOTTLSOFF12
:
2868 case R_FRV_GOTTLSOFFHI
:
2869 case R_FRV_GOTTLSOFFLO
:
2871 case R_FRV_TLSDESC_RELAX
:
2872 case R_FRV_GETTLSOFF_RELAX
:
2873 case R_FRV_TLSOFF_RELAX
:
2875 if (sec
&& (bfd_is_abs_section (sec
) || bfd_is_und_section (sec
)))
2876 relocation
+= tls_biased_base (info
);
2883 /* Try to apply TLS relaxations. */
2888 #define LOCAL_EXEC_P(info, picrel) \
2889 (bfd_link_executable (info) \
2890 && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2891 #define INITIAL_EXEC_P(info, picrel) \
2892 ((bfd_link_executable (info)|| (info)->flags & DF_STATIC_TLS) \
2893 && (picrel)->tlsoff_entry)
2895 #define IN_RANGE_FOR_OFST12_P(value) \
2896 ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2897 #define IN_RANGE_FOR_SETLOS_P(value) \
2898 ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2899 #define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2900 (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2902 #define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2903 (LOCAL_EXEC_P ((info), (picrel)) \
2904 && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2905 #define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2906 (INITIAL_EXEC_P ((info), (picrel)) \
2907 && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2909 #define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2910 (LOCAL_EXEC_P ((info), (picrel)))
2911 #define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2912 (INITIAL_EXEC_P ((info), (picrel)))
2914 #define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2915 (LOCAL_EXEC_P ((info), (picrel)) \
2916 && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2918 case R_FRV_GETTLSOFF
:
2919 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2921 /* Is this a call instruction? */
2922 if ((insn
& (unsigned long)0x01fc0000) != 0x003c0000)
2924 info
->callbacks
->einfo
2925 (_("%H: R_FRV_GETTLSOFF not applied to a call instruction\n"),
2926 input_bfd
, input_section
, rel
->r_offset
);
2930 if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info
, picrel
,
2931 relocation
+ rel
->r_addend
))
2933 /* Replace the call instruction (except the packing bit)
2934 with setlos #tlsmofflo(symbol+offset), gr9. */
2935 insn
&= (unsigned long)0x80000000;
2936 insn
|= (unsigned long)0x12fc0000;
2937 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2939 r_type
= R_FRV_TLSMOFFLO
;
2940 howto
= elf32_frv_howto_table
+ r_type
;
2941 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
2944 else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info
, picrel
))
2946 /* Replace the call instruction (except the packing bit)
2947 with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9. */
2948 insn
&= (unsigned long)0x80000000;
2949 insn
|= (unsigned long)0x12c8f000;
2950 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2952 r_type
= R_FRV_GOTTLSOFF12
;
2953 howto
= elf32_frv_howto_table
+ r_type
;
2954 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
2959 case R_FRV_GOTTLSDESC12
:
2960 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
2962 /* Is this an lddi instruction? */
2963 if ((insn
& (unsigned long)0x01fc0000) != 0x00cc0000)
2965 info
->callbacks
->einfo
2966 (_("%H: R_FRV_GOTTLSDESC12"
2967 " not applied to an lddi instruction\n"),
2968 input_bfd
, input_section
, rel
->r_offset
);
2972 if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
2973 relocation
+ rel
->r_addend
)
2974 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation
+ rel
->r_addend
,
2977 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
2978 with setlos #tlsmofflo(symbol+offset), gr<C+1>.
2979 Preserve the packing bit. */
2980 insn
= (insn
& (unsigned long)0x80000000)
2981 | ((insn
+ (unsigned long)0x02000000)
2982 & (unsigned long)0x7e000000);
2983 insn
|= (unsigned long)0x00fc0000;
2984 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
2986 r_type
= R_FRV_TLSMOFFLO
;
2987 howto
= elf32_frv_howto_table
+ r_type
;
2988 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
2991 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
2992 relocation
+ rel
->r_addend
))
2994 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
2995 with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
2996 Preserve the packing bit. */
2997 insn
= (insn
& (unsigned long)0x80000000)
2998 | ((insn
+ (unsigned long)0x02000000)
2999 & (unsigned long)0x7e000000);
3000 insn
|= (unsigned long)0x00f80000;
3001 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3003 r_type
= R_FRV_TLSMOFFHI
;
3004 howto
= elf32_frv_howto_table
+ r_type
;
3005 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3008 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
))
3010 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3011 with ldi @(grB, #gottlsoff12(symbol+offset),
3012 gr<C+1>. Preserve the packing bit. If gottlsoff12
3013 overflows, we'll error out, but that's sort-of ok,
3014 since we'd started with gottlsdesc12, that's actually
3015 more demanding. Compiling with -fPIE instead of
3016 -fpie would fix it; linking with --relax should fix
3018 insn
= (insn
& (unsigned long)0x80cbf000)
3019 | ((insn
+ (unsigned long)0x02000000)
3020 & (unsigned long)0x7e000000);
3021 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3023 r_type
= R_FRV_GOTTLSOFF12
;
3024 howto
= elf32_frv_howto_table
+ r_type
;
3025 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3030 case R_FRV_GOTTLSDESCHI
:
3031 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3033 /* Is this a sethi instruction? */
3034 if ((insn
& (unsigned long)0x01ff0000) != 0x00f80000)
3036 info
->callbacks
->einfo
3037 (_("%H: R_FRV_GOTTLSDESCHI"
3038 " not applied to a sethi instruction\n"),
3039 input_bfd
, input_section
, rel
->r_offset
);
3043 if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
3044 relocation
+ rel
->r_addend
)
3045 || (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
)
3046 && IN_RANGE_FOR_SETLOS_P (picrel
->tlsoff_entry
)))
3048 /* Replace sethi with a nop. Preserve the packing bit. */
3049 insn
&= (unsigned long)0x80000000;
3050 insn
|= (unsigned long)0x00880000;
3051 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3053 /* Nothing to relocate. */
3057 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
))
3059 /* Simply decay GOTTLSDESC to GOTTLSOFF. */
3060 r_type
= R_FRV_GOTTLSOFFHI
;
3061 howto
= elf32_frv_howto_table
+ r_type
;
3062 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3067 case R_FRV_GOTTLSDESCLO
:
3068 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3070 /* Is this a setlo or setlos instruction? */
3071 if ((insn
& (unsigned long)0x01f70000) != 0x00f40000)
3073 info
->callbacks
->einfo
3074 (_("%H: R_FRV_GOTTLSDESCLO"
3075 " not applied to a setlo or setlos instruction\n"),
3076 input_bfd
, input_section
, rel
->r_offset
);
3080 if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
3081 relocation
+ rel
->r_addend
)
3082 || (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
)
3083 && IN_RANGE_FOR_OFST12_P (picrel
->tlsoff_entry
)))
3085 /* Replace setlo/setlos with a nop. Preserve the
3087 insn
&= (unsigned long)0x80000000;
3088 insn
|= (unsigned long)0x00880000;
3089 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3091 /* Nothing to relocate. */
3095 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
))
3097 /* If the corresponding sethi (if it exists) decayed
3098 to a nop, make sure this becomes (or already is) a
3099 setlos, not setlo. */
3100 if (IN_RANGE_FOR_SETLOS_P (picrel
->tlsoff_entry
))
3102 insn
|= (unsigned long)0x00080000;
3103 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3106 /* Simply decay GOTTLSDESC to GOTTLSOFF. */
3107 r_type
= R_FRV_GOTTLSOFFLO
;
3108 howto
= elf32_frv_howto_table
+ r_type
;
3109 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3114 case R_FRV_TLSDESC_RELAX
:
3115 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3117 /* Is this an ldd instruction? */
3118 if ((insn
& (unsigned long)0x01fc0fc0) != 0x00080140)
3120 info
->callbacks
->einfo
3121 (_("%H: R_FRV_TLSDESC_RELAX"
3122 " not applied to an ldd instruction\n"),
3123 input_bfd
, input_section
, rel
->r_offset
);
3127 if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
3128 relocation
+ rel
->r_addend
)
3129 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation
+ rel
->r_addend
,
3132 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3133 with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3134 Preserve the packing bit. */
3135 insn
= (insn
& (unsigned long)0x80000000)
3136 | ((insn
+ (unsigned long)0x02000000)
3137 & (unsigned long)0x7e000000);
3138 insn
|= (unsigned long)0x00fc0000;
3139 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3141 r_type
= R_FRV_TLSMOFFLO
;
3142 howto
= elf32_frv_howto_table
+ r_type
;
3143 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3146 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
3147 relocation
+ rel
->r_addend
))
3149 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3150 with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3151 Preserve the packing bit. */
3152 insn
= (insn
& (unsigned long)0x80000000)
3153 | ((insn
+ (unsigned long)0x02000000)
3154 & (unsigned long)0x7e000000);
3155 insn
|= (unsigned long)0x00f80000;
3156 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3158 r_type
= R_FRV_TLSMOFFHI
;
3159 howto
= elf32_frv_howto_table
+ r_type
;
3160 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3163 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
)
3164 && IN_RANGE_FOR_OFST12_P (picrel
->tlsoff_entry
))
3166 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3167 with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3168 Preserve the packing bit. */
3169 insn
= (insn
& (unsigned long)0x8003f000)
3170 | (unsigned long)0x00c80000
3171 | ((insn
+ (unsigned long)0x02000000)
3172 & (unsigned long)0x7e000000);
3173 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3175 r_type
= R_FRV_GOTTLSOFF12
;
3176 howto
= elf32_frv_howto_table
+ r_type
;
3177 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3180 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
))
3182 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3183 with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3184 Preserve the packing bit. */
3185 insn
= (insn
& (unsigned long)0x81ffffbf)
3186 | ((insn
+ (unsigned long)0x02000000)
3187 & (unsigned long)0x7e000000);
3188 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3190 /* #tlsoff(symbol+offset) is just a relaxation
3191 annotation, so there's nothing left to
3198 case R_FRV_GETTLSOFF_RELAX
:
3199 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3201 /* Is this a calll or callil instruction? */
3202 if ((insn
& (unsigned long)0x7ff80fc0) != 0x02300000)
3204 info
->callbacks
->einfo
3205 (_("%H: R_FRV_GETTLSOFF_RELAX"
3206 " not applied to a calll instruction\n"),
3207 input_bfd
, input_section
, rel
->r_offset
);
3211 if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
3212 relocation
+ rel
->r_addend
)
3213 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation
+ rel
->r_addend
,
3216 /* Replace calll with a nop. Preserve the packing bit. */
3217 insn
&= (unsigned long)0x80000000;
3218 insn
|= (unsigned long)0x00880000;
3219 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3221 /* Nothing to relocate. */
3225 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info
, picrel
,
3226 relocation
+ rel
->r_addend
))
3228 /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3229 Preserve the packing bit. */
3230 insn
&= (unsigned long)0x80000000;
3231 insn
|= (unsigned long)0x12f40000;
3232 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3234 r_type
= R_FRV_TLSMOFFLO
;
3235 howto
= elf32_frv_howto_table
+ r_type
;
3236 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3239 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
))
3241 /* Replace calll with a nop. Preserve the packing bit. */
3242 insn
&= (unsigned long)0x80000000;
3243 insn
|= (unsigned long)0x00880000;
3244 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3246 /* Nothing to relocate. */
3252 case R_FRV_GOTTLSOFF12
:
3253 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3255 /* Is this an ldi instruction? */
3256 if ((insn
& (unsigned long)0x01fc0000) != 0x00c80000)
3258 info
->callbacks
->einfo
3259 (_("%H: R_FRV_GOTTLSOFF12"
3260 " not applied to an ldi instruction\n"),
3261 input_bfd
, input_section
, rel
->r_offset
);
3265 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info
, picrel
,
3266 relocation
+ rel
->r_addend
))
3268 /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3269 with setlos #tlsmofflo(symbol+offset), grC.
3270 Preserve the packing bit. */
3271 insn
&= (unsigned long)0xfe000000;
3272 insn
|= (unsigned long)0x00fc0000;
3273 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3275 r_type
= R_FRV_TLSMOFFLO
;
3276 howto
= elf32_frv_howto_table
+ r_type
;
3277 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3282 case R_FRV_GOTTLSOFFHI
:
3283 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3285 /* Is this a sethi instruction? */
3286 if ((insn
& (unsigned long)0x01ff0000) != 0x00f80000)
3288 info
->callbacks
->einfo
3289 (_("%H: R_FRV_GOTTLSOFFHI"
3290 " not applied to a sethi instruction\n"),
3291 input_bfd
, input_section
, rel
->r_offset
);
3295 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info
, picrel
,
3296 relocation
+ rel
->r_addend
)
3297 || (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
)
3298 && IN_RANGE_FOR_OFST12_P (picrel
->tlsoff_entry
)))
3300 /* Replace sethi with a nop. Preserve the packing bit. */
3301 insn
&= (unsigned long)0x80000000;
3302 insn
|= (unsigned long)0x00880000;
3303 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3305 /* Nothing to relocate. */
3311 case R_FRV_GOTTLSOFFLO
:
3312 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3314 /* Is this a setlo or setlos instruction? */
3315 if ((insn
& (unsigned long)0x01f70000) != 0x00f40000)
3317 info
->callbacks
->einfo
3318 (_("%H: R_FRV_GOTTLSOFFLO"
3319 " not applied to a setlo or setlos instruction\n"),
3320 input_bfd
, input_section
, rel
->r_offset
);
3324 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info
, picrel
,
3325 relocation
+ rel
->r_addend
)
3326 || (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
)
3327 && IN_RANGE_FOR_OFST12_P (picrel
->tlsoff_entry
)))
3329 /* Replace setlo/setlos with a nop. Preserve the
3331 insn
&= (unsigned long)0x80000000;
3332 insn
|= (unsigned long)0x00880000;
3333 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3335 /* Nothing to relocate. */
3341 case R_FRV_TLSOFF_RELAX
:
3342 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3344 /* Is this an ld instruction? */
3345 if ((insn
& (unsigned long)0x01fc0fc0) != 0x00080100)
3347 info
->callbacks
->einfo
3348 (_("%H: R_FRV_TLSOFF_RELAX"
3349 " not applied to an ld instruction\n"),
3350 input_bfd
, input_section
, rel
->r_offset
);
3354 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info
, picrel
,
3355 relocation
+ rel
->r_addend
))
3357 /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3358 with setlos #tlsmofflo(symbol+offset), grC.
3359 Preserve the packing bit. */
3360 insn
&= (unsigned long)0xfe000000;
3361 insn
|= (unsigned long)0x00fc0000;
3362 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3364 r_type
= R_FRV_TLSMOFFLO
;
3365 howto
= elf32_frv_howto_table
+ r_type
;
3366 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3369 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info
, picrel
)
3370 && IN_RANGE_FOR_OFST12_P (picrel
->tlsoff_entry
))
3372 /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3373 with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3374 Preserve the packing bit. */
3375 insn
= (insn
& (unsigned long)0xfe03f000)
3376 | (unsigned long)0x00c80000;
3377 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3379 r_type
= R_FRV_GOTTLSOFF12
;
3380 howto
= elf32_frv_howto_table
+ r_type
;
3381 rel
->r_info
= ELF32_R_INFO (r_symndx
, r_type
);
3386 case R_FRV_TLSMOFFHI
:
3387 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3389 /* Is this a sethi instruction? */
3390 if ((insn
& (unsigned long)0x01ff0000) != 0x00f80000)
3392 info
->callbacks
->einfo
3393 (_("%H: R_FRV_TLSMOFFHI"
3394 " not applied to a sethi instruction\n"),
3395 input_bfd
, input_section
, rel
->r_offset
);
3399 if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation
+ rel
->r_addend
,
3402 /* Replace sethi with a nop. Preserve the packing bit. */
3403 insn
&= (unsigned long)0x80000000;
3404 insn
|= (unsigned long)0x00880000;
3405 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3407 /* Nothing to relocate. */
3413 case R_FRV_TLSMOFFLO
:
3414 insn
= bfd_get_32 (input_bfd
, contents
+ rel
->r_offset
);
3416 /* Is this a setlo or setlos instruction? */
3417 if ((insn
& (unsigned long)0x01f70000) != 0x00f40000)
3419 info
->callbacks
->einfo
3420 (_("R_FRV_TLSMOFFLO"
3421 " not applied to a setlo or setlos instruction\n"),
3422 input_bfd
, input_section
, rel
->r_offset
);
3426 if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation
+ rel
->r_addend
,
3428 /* If the corresponding sethi (if it exists) decayed
3429 to a nop, make sure this becomes (or already is) a
3430 setlos, not setlo. */
3432 insn
|= (unsigned long)0x00080000;
3433 bfd_put_32 (input_bfd
, insn
, contents
+ rel
->r_offset
);
3439 There's nothing to relax in these:
3455 check_segment
[0] = isec_segment
;
3456 if (! IS_FDPIC (output_bfd
))
3457 check_segment
[1] = isec_segment
;
3458 else if (picrel
->plt
)
3460 relocation
= frvfdpic_plt_section (info
)->output_section
->vma
3461 + frvfdpic_plt_section (info
)->output_offset
3462 + picrel
->plt_entry
;
3463 check_segment
[1] = plt_segment
;
3465 /* We don't want to warn on calls to undefined weak symbols,
3466 as calls to them must be protected by non-NULL tests
3467 anyway, and unprotected calls would invoke undefined
3469 else if (picrel
->symndx
== -1
3470 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefweak
)
3471 check_segment
[1] = check_segment
[0];
3473 check_segment
[1] = sec
3474 ? _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3481 relocation
= picrel
->got_entry
;
3482 check_segment
[0] = check_segment
[1] = got_segment
;
3485 case R_FRV_FUNCDESC_GOT12
:
3486 case R_FRV_FUNCDESC_GOTHI
:
3487 case R_FRV_FUNCDESC_GOTLO
:
3488 relocation
= picrel
->fdgot_entry
;
3489 check_segment
[0] = check_segment
[1] = got_segment
;
3492 case R_FRV_GOTOFFHI
:
3493 case R_FRV_GOTOFF12
:
3494 case R_FRV_GOTOFFLO
:
3495 relocation
-= frvfdpic_got_section (info
)->output_section
->vma
3496 + frvfdpic_got_section (info
)->output_offset
3497 + frvfdpic_got_initial_offset (info
);
3498 check_segment
[0] = got_segment
;
3499 check_segment
[1] = sec
3500 ? _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3504 case R_FRV_FUNCDESC_GOTOFF12
:
3505 case R_FRV_FUNCDESC_GOTOFFHI
:
3506 case R_FRV_FUNCDESC_GOTOFFLO
:
3507 relocation
= picrel
->fd_entry
;
3508 check_segment
[0] = check_segment
[1] = got_segment
;
3511 case R_FRV_FUNCDESC
:
3514 bfd_vma addend
= rel
->r_addend
;
3516 if (! (h
&& h
->root
.type
== bfd_link_hash_undefweak
3517 && FRVFDPIC_SYM_LOCAL (info
, h
)))
3519 /* If the symbol is dynamic and there may be dynamic
3520 symbol resolution because we are or are linked with a
3521 shared library, emit a FUNCDESC relocation such that
3522 the dynamic linker will allocate the function
3523 descriptor. If the symbol needs a non-local function
3524 descriptor but binds locally (e.g., its visibility is
3525 protected, emit a dynamic relocation decayed to
3527 if (h
&& ! FRVFDPIC_FUNCDESC_LOCAL (info
, h
)
3528 && FRVFDPIC_SYM_LOCAL (info
, h
)
3529 && !bfd_link_pde (info
))
3531 dynindx
= elf_section_data (h
->root
.u
.def
.section
3532 ->output_section
)->dynindx
;
3533 addend
+= h
->root
.u
.def
.section
->output_offset
3534 + h
->root
.u
.def
.value
;
3536 else if (h
&& ! FRVFDPIC_FUNCDESC_LOCAL (info
, h
))
3540 info
->callbacks
->einfo
3541 (_("%H: %s references dynamic symbol"
3542 " with nonzero addend\n"),
3543 input_bfd
, input_section
, rel
->r_offset
,
3547 dynindx
= h
->dynindx
;
3551 /* Otherwise, we know we have a private function
3552 descriptor, so reference it directly. */
3553 BFD_ASSERT (picrel
->privfd
);
3555 dynindx
= elf_section_data (frvfdpic_got_section (info
)
3556 ->output_section
)->dynindx
;
3557 addend
= frvfdpic_got_section (info
)->output_offset
3558 + frvfdpic_got_initial_offset (info
)
3562 /* If there is room for dynamic symbol resolution, emit
3563 the dynamic relocation. However, if we're linking an
3564 executable at a fixed location, we won't have emitted a
3565 dynamic symbol entry for the got section, so idx will
3566 be zero, which means we can and should compute the
3567 address of the private descriptor ourselves. */
3568 if (bfd_link_pde (info
)
3569 && (!h
|| FRVFDPIC_FUNCDESC_LOCAL (info
, h
)))
3571 addend
+= frvfdpic_got_section (info
)->output_section
->vma
;
3572 if ((bfd_section_flags (input_section
->output_section
)
3573 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3577 if (_frvfdpic_osec_readonly_p (output_bfd
,
3581 info
->callbacks
->einfo
3582 (_("%H: cannot emit fixups"
3583 " in read-only section\n"),
3584 input_bfd
, input_section
, rel
->r_offset
);
3588 offset
= _bfd_elf_section_offset
3590 input_section
, rel
->r_offset
);
3592 if (offset
!= (bfd_vma
)-1)
3593 _frvfdpic_add_rofixup (output_bfd
,
3594 frvfdpic_gotfixup_section
3596 offset
+ input_section
3597 ->output_section
->vma
3598 + input_section
->output_offset
,
3602 else if ((bfd_section_flags (input_section
->output_section
)
3603 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3607 if (_frvfdpic_osec_readonly_p (output_bfd
,
3611 info
->callbacks
->einfo
3612 (_("%H: cannot emit dynamic relocations"
3613 " in read-only section\n"),
3614 input_bfd
, input_section
, rel
->r_offset
);
3618 offset
= _bfd_elf_section_offset
3620 input_section
, rel
->r_offset
);
3622 if (offset
!= (bfd_vma
)-1)
3623 _frvfdpic_add_dyn_reloc (output_bfd
,
3624 frvfdpic_gotrel_section (info
),
3625 offset
+ input_section
3626 ->output_section
->vma
3627 + input_section
->output_offset
,
3628 r_type
, dynindx
, addend
, picrel
);
3631 addend
+= frvfdpic_got_section (info
)->output_section
->vma
;
3634 /* We want the addend in-place because dynamic
3635 relocations are REL. Setting relocation to it should
3636 arrange for it to be installed. */
3637 relocation
= addend
- rel
->r_addend
;
3639 check_segment
[0] = check_segment
[1] = got_segment
;
3643 if (! IS_FDPIC (output_bfd
))
3645 check_segment
[0] = check_segment
[1] = -1;
3649 case R_FRV_FUNCDESC_VALUE
:
3652 bfd_vma addend
= rel
->r_addend
;
3654 /* If the symbol is dynamic but binds locally, use
3656 if (h
&& ! FRVFDPIC_SYM_LOCAL (info
, h
))
3658 if (addend
&& r_type
== R_FRV_FUNCDESC_VALUE
)
3660 info
->callbacks
->einfo
3661 (_("%H: %s references dynamic symbol"
3662 " with nonzero addend\n"),
3663 input_bfd
, input_section
, rel
->r_offset
,
3664 "R_FRV_FUNCDESC_VALUE");
3667 dynindx
= h
->dynindx
;
3672 addend
+= h
->root
.u
.def
.value
;
3674 addend
+= sym
->st_value
;
3676 addend
+= osec
->output_offset
;
3677 if (osec
&& osec
->output_section
3678 && ! bfd_is_abs_section (osec
->output_section
)
3679 && ! bfd_is_und_section (osec
->output_section
))
3680 dynindx
= elf_section_data (osec
->output_section
)->dynindx
;
3685 /* If we're linking an executable at a fixed address, we
3686 can omit the dynamic relocation as long as the symbol
3687 is defined in the current link unit (which is implied
3688 by its output section not being NULL). */
3689 if (bfd_link_pde (info
)
3690 && (!h
|| FRVFDPIC_SYM_LOCAL (info
, h
)))
3693 addend
+= osec
->output_section
->vma
;
3694 if (IS_FDPIC (input_bfd
)
3695 && (bfd_section_flags (input_section
->output_section
)
3696 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3698 if (_frvfdpic_osec_readonly_p (output_bfd
,
3702 info
->callbacks
->einfo
3703 (_("%H: cannot emit fixups in read-only section\n"),
3704 input_bfd
, input_section
, rel
->r_offset
);
3707 if (!h
|| h
->root
.type
!= bfd_link_hash_undefweak
)
3709 bfd_vma offset
= _bfd_elf_section_offset
3711 input_section
, rel
->r_offset
);
3713 if (offset
!= (bfd_vma
)-1)
3715 _frvfdpic_add_rofixup (output_bfd
,
3716 frvfdpic_gotfixup_section
3718 offset
+ input_section
3719 ->output_section
->vma
3720 + input_section
->output_offset
,
3722 if (r_type
== R_FRV_FUNCDESC_VALUE
)
3723 _frvfdpic_add_rofixup
3725 frvfdpic_gotfixup_section (info
),
3727 + input_section
->output_section
->vma
3728 + input_section
->output_offset
+ 4, picrel
);
3735 if ((bfd_section_flags (input_section
->output_section
)
3736 & (SEC_ALLOC
| SEC_LOAD
)) == (SEC_ALLOC
| SEC_LOAD
))
3740 if (_frvfdpic_osec_readonly_p (output_bfd
,
3744 info
->callbacks
->einfo
3745 (_("%H: cannot emit dynamic relocations"
3746 " in read-only section\n"),
3747 input_bfd
, input_section
, rel
->r_offset
);
3751 offset
= _bfd_elf_section_offset
3753 input_section
, rel
->r_offset
);
3755 if (offset
!= (bfd_vma
)-1)
3756 _frvfdpic_add_dyn_reloc (output_bfd
,
3757 frvfdpic_gotrel_section (info
),
3758 offset
+ input_section
3759 ->output_section
->vma
3760 + input_section
->output_offset
,
3761 r_type
, dynindx
, addend
, picrel
);
3764 addend
+= osec
->output_section
->vma
;
3765 /* We want the addend in-place because dynamic
3766 relocations are REL. Setting relocation to it
3767 should arrange for it to be installed. */
3768 relocation
= addend
- rel
->r_addend
;
3771 if (r_type
== R_FRV_FUNCDESC_VALUE
)
3773 /* If we've omitted the dynamic relocation, just emit
3774 the fixed addresses of the symbol and of the local
3776 if (bfd_link_pde (info
)
3777 && (!h
|| FRVFDPIC_SYM_LOCAL (info
, h
)))
3778 bfd_put_32 (output_bfd
,
3779 frvfdpic_got_section (info
)->output_section
->vma
3780 + frvfdpic_got_section (info
)->output_offset
3781 + frvfdpic_got_initial_offset (info
),
3782 contents
+ rel
->r_offset
+ 4);
3784 /* A function descriptor used for lazy or local
3785 resolving is initialized such that its high word
3786 contains the output section index in which the
3787 PLT entries are located, and the low word
3788 contains the offset of the lazy PLT entry entry
3789 point into that section. */
3790 bfd_put_32 (output_bfd
,
3791 h
&& ! FRVFDPIC_SYM_LOCAL (info
, h
)
3793 : _frvfdpic_osec_to_segment (output_bfd
,
3796 contents
+ rel
->r_offset
+ 4);
3799 check_segment
[0] = check_segment
[1] = got_segment
;
3803 case R_FRV_GPRELU12
:
3807 check_segment
[0] = gprel_segment
;
3808 check_segment
[1] = sec
3809 ? _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3813 case R_FRV_GETTLSOFF
:
3814 relocation
= frvfdpic_plt_section (info
)->output_section
->vma
3815 + frvfdpic_plt_section (info
)->output_offset
3816 + picrel
->tlsplt_entry
;
3817 BFD_ASSERT (picrel
->tlsplt_entry
!= (bfd_vma
)-1
3818 && picrel
->tlsdesc_entry
);
3819 check_segment
[0] = isec_segment
;
3820 check_segment
[1] = plt_segment
;
3823 case R_FRV_GOTTLSDESC12
:
3824 case R_FRV_GOTTLSDESCHI
:
3825 case R_FRV_GOTTLSDESCLO
:
3826 BFD_ASSERT (picrel
->tlsdesc_entry
);
3827 relocation
= picrel
->tlsdesc_entry
;
3828 check_segment
[0] = tls_segment
;
3829 check_segment
[1] = sec
3830 && ! bfd_is_abs_section (sec
)
3831 && ! bfd_is_und_section (sec
)
3832 ? _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3836 case R_FRV_TLSMOFF12
:
3837 case R_FRV_TLSMOFFHI
:
3838 case R_FRV_TLSMOFFLO
:
3840 check_segment
[0] = tls_segment
;
3842 check_segment
[1] = -1;
3843 else if (bfd_is_abs_section (sec
)
3844 || bfd_is_und_section (sec
))
3847 check_segment
[1] = tls_segment
;
3849 else if (sec
->output_section
)
3851 relocation
-= tls_biased_base (info
);
3853 _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
);
3856 check_segment
[1] = -1;
3859 case R_FRV_GOTTLSOFF12
:
3860 case R_FRV_GOTTLSOFFHI
:
3861 case R_FRV_GOTTLSOFFLO
:
3862 BFD_ASSERT (picrel
->tlsoff_entry
);
3863 relocation
= picrel
->tlsoff_entry
;
3864 check_segment
[0] = tls_segment
;
3865 check_segment
[1] = sec
3866 && ! bfd_is_abs_section (sec
)
3867 && ! bfd_is_und_section (sec
)
3868 ? _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3872 case R_FRV_TLSDESC_VALUE
:
3874 /* These shouldn't be present in input object files. */
3875 check_segment
[0] = check_segment
[1] = isec_segment
;
3878 case R_FRV_TLSDESC_RELAX
:
3879 case R_FRV_GETTLSOFF_RELAX
:
3880 case R_FRV_TLSOFF_RELAX
:
3881 /* These are just annotations for relaxation, nothing to do
3886 check_segment
[0] = isec_segment
;
3887 check_segment
[1] = sec
3888 ? _frvfdpic_osec_to_segment (output_bfd
, sec
->output_section
)
3893 if (check_segment
[0] != check_segment
[1] && IS_FDPIC (output_bfd
))
3895 /* If you take this out, remove the #error from fdpic-static-6.d
3896 in the ld testsuite. */
3897 /* This helps catch problems in GCC while we can't do more
3898 than static linking. The idea is to test whether the
3899 input file basename is crt0.o only once. */
3900 if (silence_segment_error
== 1)
3901 silence_segment_error
=
3902 (strlen (bfd_get_filename (input_bfd
)) == 6
3903 && filename_cmp (bfd_get_filename (input_bfd
), "crt0.o") == 0)
3904 || (strlen (bfd_get_filename (input_bfd
)) > 6
3905 && filename_cmp (bfd_get_filename (input_bfd
)
3906 + strlen (bfd_get_filename (input_bfd
)) - 7,
3909 if (!silence_segment_error
3910 /* We don't want duplicate errors for undefined
3912 && !(picrel
&& picrel
->symndx
== -1
3913 && picrel
->d
.h
->root
.type
== bfd_link_hash_undefined
))
3915 info
->callbacks
->einfo
3916 /* xgettext:c-format */
3917 (_("%H: reloc against `%s' references a different segment\n"),
3918 input_bfd
, input_section
, rel
->r_offset
, name
);
3920 if (!silence_segment_error
&& bfd_link_pic (info
))
3922 elf_elfheader (output_bfd
)->e_flags
|= EF_FRV_PIC
;
3927 case R_FRV_GOTOFFHI
:
3928 case R_FRV_TLSMOFFHI
:
3929 /* We need the addend to be applied before we shift the
3931 relocation
+= rel
->r_addend
;
3934 case R_FRV_FUNCDESC_GOTHI
:
3935 case R_FRV_FUNCDESC_GOTOFFHI
:
3936 case R_FRV_GOTTLSOFFHI
:
3937 case R_FRV_GOTTLSDESCHI
:
3942 case R_FRV_FUNCDESC_GOTLO
:
3943 case R_FRV_GOTOFFLO
:
3944 case R_FRV_FUNCDESC_GOTOFFLO
:
3945 case R_FRV_GOTTLSOFFLO
:
3946 case R_FRV_GOTTLSDESCLO
:
3947 case R_FRV_TLSMOFFLO
:
3948 relocation
&= 0xffff;
3958 if (! IS_FDPIC (output_bfd
) || ! picrel
->plt
)
3962 /* When referencing a GOT entry, a function descriptor or a
3963 PLT, we don't want the addend to apply to the reference,
3964 but rather to the referenced symbol. The actual entry
3965 will have already been created taking the addend into
3966 account, so cancel it out here. */
3970 case R_FRV_FUNCDESC_GOT12
:
3971 case R_FRV_FUNCDESC_GOTHI
:
3972 case R_FRV_FUNCDESC_GOTLO
:
3973 case R_FRV_FUNCDESC_GOTOFF12
:
3974 case R_FRV_FUNCDESC_GOTOFFHI
:
3975 case R_FRV_FUNCDESC_GOTOFFLO
:
3976 case R_FRV_GETTLSOFF
:
3977 case R_FRV_GOTTLSDESC12
:
3978 case R_FRV_GOTTLSDESCHI
:
3979 case R_FRV_GOTTLSDESCLO
:
3980 case R_FRV_GOTTLSOFF12
:
3981 case R_FRV_GOTTLSOFFHI
:
3982 case R_FRV_GOTTLSOFFLO
:
3983 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
3984 here, since we do want to apply the addend to the others.
3985 Note that we've applied the addend to GOTOFFHI before we
3986 shifted it right. */
3987 case R_FRV_GOTOFFHI
:
3988 case R_FRV_TLSMOFFHI
:
3989 relocation
-= rel
->r_addend
;
3996 if (r_type
== R_FRV_HI16
)
3997 r
= elf32_frv_relocate_hi16 (input_bfd
, rel
, contents
, relocation
);
3999 else if (r_type
== R_FRV_LO16
)
4000 r
= elf32_frv_relocate_lo16 (input_bfd
, rel
, contents
, relocation
);
4002 else if (r_type
== R_FRV_LABEL24
|| r_type
== R_FRV_GETTLSOFF
)
4003 r
= elf32_frv_relocate_label24 (input_bfd
, input_section
, rel
,
4004 contents
, relocation
);
4006 else if (r_type
== R_FRV_GPREL12
)
4007 r
= elf32_frv_relocate_gprel12 (info
, input_bfd
, input_section
, rel
,
4008 contents
, relocation
);
4010 else if (r_type
== R_FRV_GPRELU12
)
4011 r
= elf32_frv_relocate_gprelu12 (info
, input_bfd
, input_section
, rel
,
4012 contents
, relocation
);
4014 else if (r_type
== R_FRV_GPRELLO
)
4015 r
= elf32_frv_relocate_gprello (info
, input_bfd
, input_section
, rel
,
4016 contents
, relocation
);
4018 else if (r_type
== R_FRV_GPRELHI
)
4019 r
= elf32_frv_relocate_gprelhi (info
, input_bfd
, input_section
, rel
,
4020 contents
, relocation
);
4022 else if (r_type
== R_FRV_TLSOFF
4023 || r_type
== R_FRV_TLSDESC_VALUE
)
4024 r
= bfd_reloc_notsupported
;
4027 r
= frv_final_link_relocate (howto
, input_bfd
, input_section
, contents
,
4030 if (r
!= bfd_reloc_ok
)
4032 const char * msg
= (const char *) NULL
;
4036 case bfd_reloc_overflow
:
4037 (*info
->callbacks
->reloc_overflow
)
4038 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
4039 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
4042 case bfd_reloc_undefined
:
4043 (*info
->callbacks
->undefined_symbol
)
4044 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
4047 case bfd_reloc_outofrange
:
4048 msg
= _("internal error: out of range error");
4051 case bfd_reloc_notsupported
:
4052 msg
= _("internal error: unsupported relocation error");
4055 case bfd_reloc_dangerous
:
4056 msg
= _("internal error: dangerous relocation");
4060 msg
= _("internal error: unknown error");
4066 info
->callbacks
->einfo
4067 /* xgettext:c-format */
4068 (_("%H: reloc against `%s': %s\n"),
4069 input_bfd
, input_section
, rel
->r_offset
, name
, msg
);
4078 /* Return the section that should be marked against GC for a given
4082 elf32_frv_gc_mark_hook (asection
*sec
,
4083 struct bfd_link_info
*info
,
4084 Elf_Internal_Rela
*rel
,
4085 struct elf_link_hash_entry
*h
,
4086 Elf_Internal_Sym
*sym
)
4089 switch (ELF32_R_TYPE (rel
->r_info
))
4091 case R_FRV_GNU_VTINHERIT
:
4092 case R_FRV_GNU_VTENTRY
:
4096 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
4099 /* Hook called by the linker routine which adds symbols from an object
4100 file. We use it to put .comm items in .scomm, and not .comm. */
4103 elf32_frv_add_symbol_hook (bfd
*abfd
,
4104 struct bfd_link_info
*info
,
4105 Elf_Internal_Sym
*sym
,
4106 const char **namep ATTRIBUTE_UNUSED
,
4107 flagword
*flagsp ATTRIBUTE_UNUSED
,
4111 if (sym
->st_shndx
== SHN_COMMON
4112 && !bfd_link_relocatable (info
)
4113 && (int)sym
->st_size
<= (int)bfd_get_gp_size (abfd
))
4115 /* Common symbols less than or equal to -G nn bytes are
4116 automatically put into .sbss. */
4118 asection
*scomm
= bfd_get_section_by_name (abfd
, ".scommon");
4122 scomm
= bfd_make_section_with_flags (abfd
, ".scommon",
4125 | SEC_LINKER_CREATED
));
4131 *valp
= sym
->st_size
;
4137 /* We need dynamic symbols for every section, since segments can
4138 relocate independently. */
4140 _frvfdpic_link_omit_section_dynsym (bfd
*output_bfd ATTRIBUTE_UNUSED
,
4141 struct bfd_link_info
*info
4143 asection
*p ATTRIBUTE_UNUSED
)
4145 switch (elf_section_data (p
)->this_hdr
.sh_type
)
4149 /* If sh_type is yet undecided, assume it could be
4150 SHT_PROGBITS/SHT_NOBITS. */
4154 /* There shouldn't be section relative relocations
4155 against any other section. */
4161 /* Create a .got section, as well as its additional info field. This
4162 is almost entirely copied from
4163 elflink.c:_bfd_elf_create_got_section(). */
4166 _frv_create_got_section (bfd
*abfd
, struct bfd_link_info
*info
)
4168 flagword flags
, pltflags
;
4170 struct elf_link_hash_entry
*h
;
4171 struct bfd_link_hash_entry
*bh
;
4172 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4176 /* This function may be called more than once. */
4177 s
= elf_hash_table (info
)->sgot
;
4181 /* Machine specific: although pointers are 32-bits wide, we want the
4182 GOT to be aligned to a 64-bit boundary, such that function
4183 descriptors in it can be accessed with 64-bit loads and
4187 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4188 | SEC_LINKER_CREATED
);
4191 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
4192 elf_hash_table (info
)->sgot
= s
;
4194 || !bfd_set_section_alignment (s
, ptralign
))
4197 if (bed
->want_got_sym
)
4199 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4200 (or .got.plt) section. We don't do this in the linker script
4201 because we don't want to define the symbol if we are not creating
4202 a global offset table. */
4203 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_GLOBAL_OFFSET_TABLE_");
4204 elf_hash_table (info
)->hgot
= h
;
4208 /* Machine-specific: we want the symbol for executables as
4210 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
4214 /* The first bit of the global offset table is the header. */
4215 s
->size
+= bed
->got_header_size
;
4217 /* This is the machine-specific part. Create and initialize section
4218 data for the got. */
4219 if (IS_FDPIC (abfd
))
4221 frvfdpic_relocs_info (info
) = htab_try_create (1,
4222 frvfdpic_relocs_info_hash
,
4223 frvfdpic_relocs_info_eq
,
4225 if (! frvfdpic_relocs_info (info
))
4228 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.got",
4229 (flags
| SEC_READONLY
));
4230 elf_hash_table (info
)->srelgot
= s
;
4232 || !bfd_set_section_alignment (s
, 2))
4235 /* Machine-specific. */
4236 s
= bfd_make_section_anyway_with_flags (abfd
, ".rofixup",
4237 (flags
| SEC_READONLY
));
4239 || !bfd_set_section_alignment (s
, 2))
4242 frvfdpic_gotfixup_section (info
) = s
;
4249 flags
= BSF_GLOBAL
| BSF_WEAK
;
4252 /* Define _gp in .rofixup, for FDPIC, or .got otherwise. If it
4253 turns out that we're linking with a different linker script, the
4254 linker script will override it. */
4256 if (!(_bfd_generic_link_add_one_symbol
4257 (info
, abfd
, "_gp", flags
, s
, offset
, (const char *) NULL
, FALSE
,
4258 bed
->collect
, &bh
)))
4260 h
= (struct elf_link_hash_entry
*) bh
;
4262 h
->type
= STT_OBJECT
;
4263 /* h->other = STV_HIDDEN; */ /* Should we? */
4265 /* Machine-specific: we want the symbol for executables as well. */
4266 if (IS_FDPIC (abfd
) && ! bfd_elf_link_record_dynamic_symbol (info
, h
))
4269 if (!IS_FDPIC (abfd
))
4272 /* FDPIC supports Thread Local Storage, and this may require a
4273 procedure linkage table for TLS PLT entries. */
4275 /* This is mostly copied from
4276 elflink.c:_bfd_elf_create_dynamic_sections(). */
4279 pltflags
|= SEC_CODE
;
4280 if (bed
->plt_not_loaded
)
4281 pltflags
&= ~ (SEC_CODE
| SEC_LOAD
| SEC_HAS_CONTENTS
);
4282 if (bed
->plt_readonly
)
4283 pltflags
|= SEC_READONLY
;
4285 s
= bfd_make_section_anyway_with_flags (abfd
, ".plt", pltflags
);
4287 || !bfd_set_section_alignment (s
, bed
->plt_alignment
))
4289 /* FRV-specific: remember it. */
4290 frvfdpic_plt_section (info
) = s
;
4292 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4294 if (bed
->want_plt_sym
)
4296 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
,
4297 "_PROCEDURE_LINKAGE_TABLE_");
4298 elf_hash_table (info
)->hplt
= h
;
4303 /* FRV-specific: we want rel relocations for the plt. */
4304 s
= bfd_make_section_anyway_with_flags (abfd
, ".rel.plt",
4305 flags
| SEC_READONLY
);
4307 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
4309 /* FRV-specific: remember it. */
4310 frvfdpic_pltrel_section (info
) = s
;
4315 /* Make sure the got and plt sections exist, and that our pointers in
4316 the link hash table point to them. */
4319 elf32_frvfdpic_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
4321 /* This is mostly copied from
4322 elflink.c:_bfd_elf_create_dynamic_sections(). */
4325 const struct elf_backend_data
*bed
= get_elf_backend_data (abfd
);
4327 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
4328 | SEC_LINKER_CREATED
);
4330 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4331 .rel[a].bss sections. */
4333 /* FRV-specific: we want to create the GOT and the PLT in the FRV
4335 if (! _frv_create_got_section (abfd
, info
))
4338 /* FRV-specific: make sure we created everything we wanted. */
4339 BFD_ASSERT (frvfdpic_got_section (info
) && frvfdpic_gotrel_section (info
)
4340 && frvfdpic_gotfixup_section (info
)
4341 && frvfdpic_plt_section (info
)
4342 && frvfdpic_pltrel_section (info
));
4344 if (bed
->want_dynbss
)
4346 /* The .dynbss section is a place to put symbols which are defined
4347 by dynamic objects, are referenced by regular objects, and are
4348 not functions. We must allocate space for them in the process
4349 image and use a R_*_COPY reloc to tell the dynamic linker to
4350 initialize them at run time. The linker script puts the .dynbss
4351 section into the .bss section of the final image. */
4352 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
4353 SEC_ALLOC
| SEC_LINKER_CREATED
);
4357 /* The .rel[a].bss section holds copy relocs. This section is not
4358 normally needed. We need to create it here, though, so that the
4359 linker will map it to an output section. We can't just create it
4360 only if we need it, because we will not know whether we need it
4361 until we have seen all the input files, and the first time the
4362 main linker code calls BFD after examining all the input files
4363 (size_dynamic_sections) the input sections have already been
4364 mapped to the output sections. If the section turns out not to
4365 be needed, we can discard it later. We will never need this
4366 section when generating a shared object, since they do not use
4368 if (! bfd_link_pic (info
))
4370 s
= bfd_make_section_anyway_with_flags (abfd
,
4371 (bed
->default_use_rela_p
4372 ? ".rela.bss" : ".rel.bss"),
4373 flags
| SEC_READONLY
);
4375 || !bfd_set_section_alignment (s
, bed
->s
->log_file_align
))
4383 /* Compute the total GOT and PLT size required by each symbol in each
4384 range. Symbols may require up to 4 words in the GOT: an entry
4385 pointing to the symbol, an entry pointing to its function
4386 descriptor, and a private function descriptors taking two
4390 _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info
*entry
,
4391 struct _frvfdpic_dynamic_got_info
*dinfo
)
4393 /* Allocate space for a GOT entry pointing to the symbol. */
4396 else if (entry
->gotlos
)
4398 else if (entry
->gothilo
)
4399 dinfo
->gothilo
+= 4;
4404 /* Allocate space for a GOT entry pointing to the function
4408 else if (entry
->fdgotlos
)
4410 else if (entry
->fdgothilo
)
4411 dinfo
->gothilo
+= 4;
4416 /* Decide whether we need a PLT entry, a function descriptor in the
4417 GOT, and a lazy PLT entry for this symbol. */
4418 entry
->plt
= entry
->call
4419 && entry
->symndx
== -1 && ! FRVFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
4420 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
4421 entry
->privfd
= entry
->plt
4422 || entry
->fdgoff12
|| entry
->fdgofflos
|| entry
->fdgoffhilo
4423 || ((entry
->fd
|| entry
->fdgot12
|| entry
->fdgotlos
|| entry
->fdgothilo
)
4424 && (entry
->symndx
!= -1
4425 || FRVFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
)));
4426 entry
->lazyplt
= entry
->privfd
4427 && entry
->symndx
== -1 && ! FRVFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
4428 && ! (dinfo
->info
->flags
& DF_BIND_NOW
)
4429 && elf_hash_table (dinfo
->info
)->dynamic_sections_created
;
4431 /* Allocate space for a function descriptor. */
4432 if (entry
->fdgoff12
)
4434 else if (entry
->fdgofflos
)
4436 else if (entry
->privfd
&& entry
->plt
)
4438 else if (entry
->privfd
)
4448 /* Compute the total GOT size required by each TLS symbol in each
4449 range. Symbols may require up to 5 words in the GOT: an entry
4450 holding the TLS offset for the symbol, and an entry with a full TLS
4451 descriptor taking 4 words. */
4454 _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info
*entry
,
4455 struct _frvfdpic_dynamic_got_info
*dinfo
,
4456 bfd_boolean subtract
)
4458 const int l
= subtract
? -1 : 1;
4460 /* Allocate space for a GOT entry with the TLS offset of the
4462 if (entry
->tlsoff12
)
4463 dinfo
->got12
+= 4 * l
;
4464 else if (entry
->tlsofflos
)
4465 dinfo
->gotlos
+= 4 * l
;
4466 else if (entry
->tlsoffhilo
)
4467 dinfo
->gothilo
+= 4 * l
;
4469 entry
->relocstlsoff
-= l
;
4470 entry
->relocstlsoff
+= l
;
4472 /* If there's any TLSOFF relocation, mark the output file as not
4473 suitable for dlopening. This mark will remain even if we relax
4474 all such relocations, but this is not a problem, since we'll only
4475 do so for executables, and we definitely don't want anyone
4476 dlopening executables. */
4477 if (entry
->relocstlsoff
)
4478 dinfo
->info
->flags
|= DF_STATIC_TLS
;
4480 /* Allocate space for a TLS descriptor. */
4481 if (entry
->tlsdesc12
)
4482 dinfo
->tlsd12
+= 8 * l
;
4483 else if (entry
->tlsdesclos
)
4484 dinfo
->tlsdlos
+= 8 * l
;
4485 else if (entry
->tlsplt
)
4486 dinfo
->tlsdplt
+= 8 * l
;
4487 else if (entry
->tlsdeschilo
)
4488 dinfo
->tlsdhilo
+= 8 * l
;
4490 entry
->relocstlsd
-= l
;
4491 entry
->relocstlsd
+= l
;
4494 /* Compute the number of dynamic relocations and fixups that a symbol
4495 requires, and add (or subtract) from the grand and per-symbol
4499 _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info
*entry
,
4500 struct _frvfdpic_dynamic_got_info
*dinfo
,
4501 bfd_boolean subtract
)
4503 bfd_vma relocs
= 0, fixups
= 0, tlsrets
= 0;
4505 if (!bfd_link_pde (dinfo
->info
))
4507 relocs
= entry
->relocs32
+ entry
->relocsfd
+ entry
->relocsfdv
4508 + entry
->relocstlsd
;
4510 /* In the executable, TLS relocations to symbols that bind
4511 locally (including those that resolve to global TLS offsets)
4512 are resolved immediately, without any need for fixups or
4513 dynamic relocations. In shared libraries, however, we must
4514 emit dynamic relocations even for local symbols, because we
4515 don't know the module id the library is going to get at
4516 run-time, nor its TLS base offset. */
4517 if (!bfd_link_executable (dinfo
->info
)
4518 || (entry
->symndx
== -1
4519 && ! FRVFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)))
4520 relocs
+= entry
->relocstlsoff
;
4524 if (entry
->symndx
!= -1 || FRVFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
))
4526 if (entry
->symndx
!= -1
4527 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
4528 fixups
+= entry
->relocs32
+ 2 * entry
->relocsfdv
;
4529 fixups
+= entry
->relocstlsd
;
4530 tlsrets
+= entry
->relocstlsd
;
4534 relocs
+= entry
->relocs32
+ entry
->relocsfdv
4535 + entry
->relocstlsoff
+ entry
->relocstlsd
;
4538 if (entry
->symndx
!= -1
4539 || FRVFDPIC_FUNCDESC_LOCAL (dinfo
->info
, entry
->d
.h
))
4541 if (entry
->symndx
!= -1
4542 || entry
->d
.h
->root
.type
!= bfd_link_hash_undefweak
)
4543 fixups
+= entry
->relocsfd
;
4546 relocs
+= entry
->relocsfd
;
4553 tlsrets
= - tlsrets
;
4556 entry
->dynrelocs
+= relocs
;
4557 entry
->fixups
+= fixups
;
4558 dinfo
->relocs
+= relocs
;
4559 dinfo
->fixups
+= fixups
;
4560 dinfo
->tls_ret_refs
+= tlsrets
;
4563 /* Look for opportunities to relax TLS relocations. We can assume
4564 we're linking the main executable or a static-tls library, since
4565 otherwise we wouldn't have got here. When relaxing, we have to
4566 first undo any previous accounting of TLS uses of fixups, dynamic
4567 relocations, GOT and PLT entries. */
4570 _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info
*entry
,
4571 struct _frvfdpic_dynamic_got_info
*dinfo
,
4572 bfd_boolean relaxing
)
4574 bfd_boolean changed
= ! relaxing
;
4576 BFD_ASSERT (bfd_link_executable (dinfo
->info
)
4577 || (dinfo
->info
->flags
& DF_STATIC_TLS
));
4579 if (entry
->tlsdesc12
|| entry
->tlsdesclos
|| entry
->tlsdeschilo
)
4583 _frvfdpic_count_relocs_fixups (entry
, dinfo
, TRUE
);
4584 _frvfdpic_count_tls_entries (entry
, dinfo
, TRUE
);
4588 /* When linking an executable, we can always decay GOTTLSDESC to
4589 TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4590 When linking a static-tls shared library, using TLSMOFF is
4591 not an option, but we can still use GOTTLSOFF. When decaying
4592 to GOTTLSOFF, we must keep the GOT entry in range. We know
4593 it has to fit because we'll be trading the 4 words of hte TLS
4594 descriptor for a single word in the same range. */
4595 if (! bfd_link_executable (dinfo
->info
)
4596 || (entry
->symndx
== -1
4597 && ! FRVFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)))
4599 entry
->tlsoff12
|= entry
->tlsdesc12
;
4600 entry
->tlsofflos
|= entry
->tlsdesclos
;
4601 entry
->tlsoffhilo
|= entry
->tlsdeschilo
;
4604 entry
->tlsdesc12
= entry
->tlsdesclos
= entry
->tlsdeschilo
= 0;
4607 /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4608 main executable. We have to check whether the symbol's TLSOFF is
4609 in range for a setlos. For symbols with a hash entry, we can
4610 determine exactly what to do; for others locals, we don't have
4611 addresses handy, so we use the size of the TLS section as an
4612 approximation. If we get it wrong, we'll retain a GOT entry
4613 holding the TLS offset (without dynamic relocations or fixups),
4614 but we'll still optimize away the loads from it. Since TLS sizes
4615 are generally very small, it's probably not worth attempting to
4616 do better than this. */
4618 || entry
->tlsoff12
|| entry
->tlsofflos
|| entry
->tlsoffhilo
)
4619 && bfd_link_executable (dinfo
->info
) && relaxing
4620 && ((entry
->symndx
== -1
4621 && FRVFDPIC_SYM_LOCAL (dinfo
->info
, entry
->d
.h
)
4622 /* The above may hold for an undefweak TLS symbol, so make
4623 sure we don't have this case before accessing def.value
4625 && (entry
->d
.h
->root
.type
== bfd_link_hash_undefweak
4626 || (bfd_vma
)(entry
->d
.h
->root
.u
.def
.value
4627 + (entry
->d
.h
->root
.u
.def
.section
4628 ->output_section
->vma
)
4629 + entry
->d
.h
->root
.u
.def
.section
->output_offset
4631 - tls_biased_base (dinfo
->info
)
4632 + 32768) < (bfd_vma
)65536))
4633 || (entry
->symndx
!= -1
4634 && (elf_hash_table (dinfo
->info
)->tls_sec
->size
4635 + entry
->addend
< 32768 + FRVFDPIC_TLS_BIAS
))))
4639 _frvfdpic_count_relocs_fixups (entry
, dinfo
, TRUE
);
4640 _frvfdpic_count_tls_entries (entry
, dinfo
, TRUE
);
4645 entry
->tlsoff12
= entry
->tlsofflos
= entry
->tlsoffhilo
= 0;
4648 /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4649 have a #gottlsoff12 relocation for this entry, or if we can fit
4650 one more in the 12-bit (and 16-bit) ranges. */
4654 && dinfo
->got12
+ dinfo
->fd12
+ dinfo
->tlsd12
<= 4096 - 12 - 4
4655 && (dinfo
->got12
+ dinfo
->fd12
+ dinfo
->tlsd12
4656 + dinfo
->gotlos
+ dinfo
->fdlos
+ dinfo
->tlsdlos
4657 <= 65536 - 12 - 4))))
4661 _frvfdpic_count_relocs_fixups (entry
, dinfo
, TRUE
);
4662 _frvfdpic_count_tls_entries (entry
, dinfo
, TRUE
);
4666 entry
->tlsoff12
= 1;
4672 _frvfdpic_count_tls_entries (entry
, dinfo
, FALSE
);
4673 _frvfdpic_count_relocs_fixups (entry
, dinfo
, FALSE
);
4679 /* Compute the total GOT and PLT size required by each symbol in each range. *
4680 Symbols may require up to 4 words in the GOT: an entry pointing to
4681 the symbol, an entry pointing to its function descriptor, and a
4682 private function descriptors taking two words. */
4685 _frvfdpic_count_got_plt_entries (void **entryp
, void *dinfo_
)
4687 struct frvfdpic_relocs_info
*entry
= *entryp
;
4688 struct _frvfdpic_dynamic_got_info
*dinfo
= dinfo_
;
4690 _frvfdpic_count_nontls_entries (entry
, dinfo
);
4692 if (bfd_link_executable (dinfo
->info
)
4693 || (dinfo
->info
->flags
& DF_STATIC_TLS
))
4694 _frvfdpic_relax_tls_entries (entry
, dinfo
, FALSE
);
4697 _frvfdpic_count_tls_entries (entry
, dinfo
, FALSE
);
4698 _frvfdpic_count_relocs_fixups (entry
, dinfo
, FALSE
);
4704 /* Determine the positive and negative ranges to be used by each
4705 offset range in the GOT. FDCUR and CUR, that must be aligned to a
4706 double-word boundary, are the minimum (negative) and maximum
4707 (positive) GOT offsets already used by previous ranges, except for
4708 an ODD entry that may have been left behind. GOT and FD indicate
4709 the size of GOT entries and function descriptors that must be
4710 placed within the range from -WRAP to WRAP. If there's room left,
4711 up to FDPLT bytes should be reserved for additional function
4714 inline static bfd_signed_vma
4715 _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data
*gad
,
4716 bfd_signed_vma fdcur
,
4726 bfd_signed_vma wrapmin
= -wrap
;
4727 const bfd_vma tdescsz
= 8;
4729 /* Start at the given initial points. */
4733 /* If we had an incoming odd word and we have any got entries that
4734 are going to use it, consume it, otherwise leave gad->odd at
4735 zero. We might force gad->odd to zero and return the incoming
4736 odd such that it is used by the next range, but then GOT entries
4737 might appear to be out of order and we wouldn't be able to
4738 shorten the GOT by one word if it turns out to end with an
4739 unpaired GOT entry. */
4749 /* If we're left with an unpaired GOT entry, compute its location
4750 such that we can return it. Otherwise, if got doesn't require an
4751 odd number of words here, either odd was already zero in the
4752 block above, or it was set to zero because got was non-zero, or
4753 got was already zero. In the latter case, we want the value of
4754 odd to carry over to the return statement, so we don't want to
4755 reset odd unless the condition below is true. */
4762 /* Compute the tentative boundaries of this range. */
4763 gad
->max
= cur
+ got
;
4764 gad
->min
= fdcur
- fd
;
4767 /* If function descriptors took too much space, wrap some of them
4769 if (gad
->min
< wrapmin
)
4771 gad
->max
+= wrapmin
- gad
->min
;
4772 gad
->tmin
= gad
->min
= wrapmin
;
4775 /* If GOT entries took too much space, wrap some of them around.
4776 This may well cause gad->min to become lower than wrapmin. This
4777 will cause a relocation overflow later on, so we don't have to
4779 if ((bfd_vma
) gad
->max
> wrap
)
4781 gad
->min
-= gad
->max
- wrap
;
4785 /* Add TLS descriptors. */
4786 gad
->tmax
= gad
->max
+ tlsd
;
4787 gad
->tmin
= gad
->min
;
4790 /* If TLS descriptors took too much space, wrap an integral number
4792 if ((bfd_vma
) gad
->tmax
> wrap
)
4794 bfd_vma wrapsize
= gad
->tmax
- wrap
;
4796 wrapsize
+= tdescsz
/ 2;
4797 wrapsize
&= ~ tdescsz
/ 2;
4799 gad
->tmin
-= wrapsize
;
4800 gad
->tmax
-= wrapsize
;
4803 /* If there is space left and we have function descriptors
4804 referenced in PLT entries that could take advantage of shorter
4805 offsets, place them now. */
4806 if (fdplt
&& gad
->tmin
> wrapmin
)
4810 if ((bfd_vma
) (gad
->tmin
- wrapmin
) < fdplt
)
4811 fds
= gad
->tmin
- wrapmin
;
4821 /* If there is more space left, try to place some more function
4822 descriptors for PLT entries. */
4823 if (fdplt
&& (bfd_vma
) gad
->tmax
< wrap
)
4827 if ((bfd_vma
) (wrap
- gad
->tmax
) < fdplt
)
4828 fds
= wrap
- gad
->tmax
;
4838 /* If there is space left and we have TLS descriptors referenced in
4839 PLT entries that could take advantage of shorter offsets, place
4841 if (tlsdplt
&& gad
->tmin
> wrapmin
)
4845 if ((bfd_vma
) (gad
->tmin
- wrapmin
) < tlsdplt
)
4846 tlsds
= (gad
->tmin
- wrapmin
) & ~ (tdescsz
/ 2);
4852 gad
->tlsdplt
+= tlsds
;
4855 /* If there is more space left, try to place some more TLS
4856 descriptors for PLT entries. Although we could try to fit an
4857 additional TLS descriptor with half of it just before before the
4858 wrap point and another right past the wrap point, this might
4859 cause us to run out of space for the next region, so don't do
4861 if (tlsdplt
&& (bfd_vma
) gad
->tmax
< wrap
- tdescsz
/ 2)
4865 if ((bfd_vma
) (wrap
- gad
->tmax
) < tlsdplt
)
4866 tlsds
= (wrap
- gad
->tmax
) & ~ (tdescsz
/ 2);
4872 gad
->tlsdplt
+= tlsds
;
4875 /* If odd was initially computed as an offset past the wrap point,
4878 odd
= gad
->min
+ odd
- gad
->max
;
4880 /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
4881 before returning, so do it here too. This guarantees that,
4882 should cur and fdcur meet at the wrap point, they'll both be
4884 if (gad
->cur
== gad
->max
)
4885 gad
->cur
= gad
->min
;
4887 /* Ditto for _frvfdpic_get_tlsdesc_entry(). */
4888 gad
->tcur
= gad
->max
;
4889 if (gad
->tcur
== gad
->tmax
)
4890 gad
->tcur
= gad
->tmin
;
4895 /* Compute the location of the next GOT entry, given the allocation
4896 data for a range. */
4898 inline static bfd_signed_vma
4899 _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data
*gad
)
4905 /* If there was an odd word left behind, use it. */
4911 /* Otherwise, use the word pointed to by cur, reserve the next
4912 as an odd word, and skip to the next pair of words, possibly
4915 gad
->odd
= gad
->cur
+ 4;
4917 if (gad
->cur
== gad
->max
)
4918 gad
->cur
= gad
->min
;
4924 /* Compute the location of the next function descriptor entry in the
4925 GOT, given the allocation data for a range. */
4927 inline static bfd_signed_vma
4928 _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data
*gad
)
4930 /* If we're at the bottom, wrap around, and only then allocate the
4931 next pair of words. */
4932 if (gad
->fdcur
== gad
->min
)
4933 gad
->fdcur
= gad
->max
;
4934 return gad
->fdcur
-= 8;
4937 /* Compute the location of the next TLS descriptor entry in the GOT,
4938 given the allocation data for a range. */
4939 inline static bfd_signed_vma
4940 _frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data
*gad
)
4948 /* If we're at the top of the region, wrap around to the bottom. */
4949 if (gad
->tcur
== gad
->tmax
)
4950 gad
->tcur
= gad
->tmin
;
4955 /* Assign GOT offsets for every GOT entry and function descriptor.
4956 Doing everything in a single pass is tricky. */
4959 _frvfdpic_assign_got_entries (void **entryp
, void *info_
)
4961 struct frvfdpic_relocs_info
*entry
= *entryp
;
4962 struct _frvfdpic_dynamic_got_plt_info
*dinfo
= info_
;
4965 entry
->got_entry
= _frvfdpic_get_got_entry (&dinfo
->got12
);
4966 else if (entry
->gotlos
)
4967 entry
->got_entry
= _frvfdpic_get_got_entry (&dinfo
->gotlos
);
4968 else if (entry
->gothilo
)
4969 entry
->got_entry
= _frvfdpic_get_got_entry (&dinfo
->gothilo
);
4972 entry
->fdgot_entry
= _frvfdpic_get_got_entry (&dinfo
->got12
);
4973 else if (entry
->fdgotlos
)
4974 entry
->fdgot_entry
= _frvfdpic_get_got_entry (&dinfo
->gotlos
);
4975 else if (entry
->fdgothilo
)
4976 entry
->fdgot_entry
= _frvfdpic_get_got_entry (&dinfo
->gothilo
);
4978 if (entry
->fdgoff12
)
4979 entry
->fd_entry
= _frvfdpic_get_fd_entry (&dinfo
->got12
);
4980 else if (entry
->plt
&& dinfo
->got12
.fdplt
)
4982 dinfo
->got12
.fdplt
-= 8;
4983 entry
->fd_entry
= _frvfdpic_get_fd_entry (&dinfo
->got12
);
4985 else if (entry
->fdgofflos
)
4986 entry
->fd_entry
= _frvfdpic_get_fd_entry (&dinfo
->gotlos
);
4987 else if (entry
->plt
&& dinfo
->gotlos
.fdplt
)
4989 dinfo
->gotlos
.fdplt
-= 8;
4990 entry
->fd_entry
= _frvfdpic_get_fd_entry (&dinfo
->gotlos
);
4992 else if (entry
->plt
)
4994 dinfo
->gothilo
.fdplt
-= 8;
4995 entry
->fd_entry
= _frvfdpic_get_fd_entry (&dinfo
->gothilo
);
4997 else if (entry
->privfd
)
4998 entry
->fd_entry
= _frvfdpic_get_fd_entry (&dinfo
->gothilo
);
5000 if (entry
->tlsoff12
)
5001 entry
->tlsoff_entry
= _frvfdpic_get_got_entry (&dinfo
->got12
);
5002 else if (entry
->tlsofflos
)
5003 entry
->tlsoff_entry
= _frvfdpic_get_got_entry (&dinfo
->gotlos
);
5004 else if (entry
->tlsoffhilo
)
5005 entry
->tlsoff_entry
= _frvfdpic_get_got_entry (&dinfo
->gothilo
);
5007 if (entry
->tlsdesc12
)
5008 entry
->tlsdesc_entry
= _frvfdpic_get_tlsdesc_entry (&dinfo
->got12
);
5009 else if (entry
->tlsplt
&& dinfo
->got12
.tlsdplt
)
5011 dinfo
->got12
.tlsdplt
-= 8;
5012 entry
->tlsdesc_entry
= _frvfdpic_get_tlsdesc_entry (&dinfo
->got12
);
5014 else if (entry
->tlsdesclos
)
5015 entry
->tlsdesc_entry
= _frvfdpic_get_tlsdesc_entry (&dinfo
->gotlos
);
5016 else if (entry
->tlsplt
&& dinfo
->gotlos
.tlsdplt
)
5018 dinfo
->gotlos
.tlsdplt
-= 8;
5019 entry
->tlsdesc_entry
= _frvfdpic_get_tlsdesc_entry (&dinfo
->gotlos
);
5021 else if (entry
->tlsplt
)
5023 dinfo
->gothilo
.tlsdplt
-= 8;
5024 entry
->tlsdesc_entry
= _frvfdpic_get_tlsdesc_entry (&dinfo
->gothilo
);
5026 else if (entry
->tlsdeschilo
)
5027 entry
->tlsdesc_entry
= _frvfdpic_get_tlsdesc_entry (&dinfo
->gothilo
);
5032 /* Assign GOT offsets to private function descriptors used by PLT
5033 entries (or referenced by 32-bit offsets), as well as PLT entries
5034 and lazy PLT entries. */
5037 _frvfdpic_assign_plt_entries (void **entryp
, void *info_
)
5039 struct frvfdpic_relocs_info
*entry
= *entryp
;
5040 struct _frvfdpic_dynamic_got_plt_info
*dinfo
= info_
;
5043 BFD_ASSERT (entry
->fd_entry
);
5049 /* We use the section's raw size to mark the location of the
5051 entry
->plt_entry
= frvfdpic_plt_section (dinfo
->g
.info
)->size
;
5053 /* Figure out the length of this PLT entry based on the
5054 addressing mode we need to reach the function descriptor. */
5055 BFD_ASSERT (entry
->fd_entry
);
5056 if (entry
->fd_entry
>= -(1 << (12 - 1))
5057 && entry
->fd_entry
< (1 << (12 - 1)))
5059 else if (entry
->fd_entry
>= -(1 << (16 - 1))
5060 && entry
->fd_entry
< (1 << (16 - 1)))
5065 frvfdpic_plt_section (dinfo
->g
.info
)->size
+= size
;
5070 entry
->lzplt_entry
= dinfo
->g
.lzplt
;
5071 dinfo
->g
.lzplt
+= 8;
5072 /* If this entry is the one that gets the resolver stub, account
5073 for the additional instruction. */
5074 if (entry
->lzplt_entry
% FRVFDPIC_LZPLT_BLOCK_SIZE
5075 == FRVFDPIC_LZPLT_RESOLV_LOC
)
5076 dinfo
->g
.lzplt
+= 4;
5084 = frvfdpic_plt_section (dinfo
->g
.info
)->size
;
5086 if (bfd_link_executable (dinfo
->g
.info
)
5087 && (entry
->symndx
!= -1
5088 || FRVFDPIC_SYM_LOCAL (dinfo
->g
.info
, entry
->d
.h
)))
5090 if ((bfd_signed_vma
)entry
->addend
>= -(1 << (16 - 1))
5091 /* FIXME: here we use the size of the TLS section
5092 as an upper bound for the value of the TLS
5093 symbol, because we may not know the exact value
5094 yet. If we get it wrong, we'll just waste a
5095 word in the PLT, and we should never get even
5096 close to 32 KiB of TLS anyway. */
5097 && elf_hash_table (dinfo
->g
.info
)->tls_sec
5098 && (elf_hash_table (dinfo
->g
.info
)->tls_sec
->size
5099 + (bfd_signed_vma
)(entry
->addend
) <= (1 << (16 - 1))))
5104 else if (entry
->tlsoff_entry
)
5106 if (entry
->tlsoff_entry
>= -(1 << (12 - 1))
5107 && entry
->tlsoff_entry
< (1 << (12 - 1)))
5109 else if (entry
->tlsoff_entry
>= -(1 << (16 - 1))
5110 && entry
->tlsoff_entry
< (1 << (16 - 1)))
5117 BFD_ASSERT (entry
->tlsdesc_entry
);
5119 if (entry
->tlsdesc_entry
>= -(1 << (12 - 1))
5120 && entry
->tlsdesc_entry
< (1 << (12 - 1)))
5122 else if (entry
->tlsdesc_entry
>= -(1 << (16 - 1))
5123 && entry
->tlsdesc_entry
< (1 << (16 - 1)))
5129 frvfdpic_plt_section (dinfo
->g
.info
)->size
+= size
;
5135 /* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5136 _frvfdpic_assign_plt_entries. */
5139 _frvfdpic_reset_got_plt_entries (void **entryp
, void *ignore ATTRIBUTE_UNUSED
)
5141 struct frvfdpic_relocs_info
*entry
= *entryp
;
5143 entry
->got_entry
= 0;
5144 entry
->fdgot_entry
= 0;
5145 entry
->fd_entry
= 0;
5146 entry
->plt_entry
= (bfd_vma
)-1;
5147 entry
->lzplt_entry
= (bfd_vma
)-1;
5148 entry
->tlsoff_entry
= 0;
5149 entry
->tlsdesc_entry
= 0;
5150 entry
->tlsplt_entry
= (bfd_vma
)-1;
5155 /* Follow indirect and warning hash entries so that each got entry
5156 points to the final symbol definition. P must point to a pointer
5157 to the hash table we're traversing. Since this traversal may
5158 modify the hash table, we set this pointer to NULL to indicate
5159 we've made a potentially-destructive change to the hash table, so
5160 the traversal must be restarted. */
5162 _frvfdpic_resolve_final_relocs_info (void **entryp
, void *p
)
5164 struct frvfdpic_relocs_info
*entry
= *entryp
;
5167 if (entry
->symndx
== -1)
5169 struct elf_link_hash_entry
*h
= entry
->d
.h
;
5170 struct frvfdpic_relocs_info
*oentry
;
5172 while (h
->root
.type
== bfd_link_hash_indirect
5173 || h
->root
.type
== bfd_link_hash_warning
)
5174 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
5176 if (entry
->d
.h
== h
)
5179 oentry
= frvfdpic_relocs_info_for_global (*htab
, 0, h
, entry
->addend
,
5184 /* Merge the two entries. */
5185 frvfdpic_pic_merge_early_relocs_info (oentry
, entry
);
5186 htab_clear_slot (*htab
, entryp
);
5192 /* If we can't find this entry with the new bfd hash, re-insert
5193 it, and get the traversal restarted. */
5194 if (! htab_find (*htab
, entry
))
5196 htab_clear_slot (*htab
, entryp
);
5197 entryp
= htab_find_slot (*htab
, entry
, INSERT
);
5200 /* Abort the traversal, since the whole table may have
5201 moved, and leave it up to the parent to restart the
5203 *(htab_t
*)p
= NULL
;
5211 /* Compute the total size of the GOT, the PLT, the dynamic relocations
5212 section and the rofixup section. Assign locations for GOT and PLT
5216 _frvfdpic_size_got_plt (bfd
*output_bfd
,
5217 struct _frvfdpic_dynamic_got_plt_info
*gpinfop
)
5220 bfd_vma limit
, tlslimit
;
5221 struct bfd_link_info
*info
= gpinfop
->g
.info
;
5222 bfd
*dynobj
= elf_hash_table (info
)->dynobj
;
5224 memcpy (frvfdpic_dynamic_got_plt_info (info
), &gpinfop
->g
,
5225 sizeof (gpinfop
->g
));
5228 /* Compute the total size taken by entries in the 12-bit and 16-bit
5229 ranges, to tell how many PLT function descriptors we can bring
5230 into the 12-bit range without causing the 16-bit range to
5232 limit
= odd
+ gpinfop
->g
.got12
+ gpinfop
->g
.gotlos
5233 + gpinfop
->g
.fd12
+ gpinfop
->g
.fdlos
5234 + gpinfop
->g
.tlsd12
+ gpinfop
->g
.tlsdlos
;
5235 if (limit
< (bfd_vma
)1 << 16)
5236 limit
= ((bfd_vma
)1 << 16) - limit
;
5239 if (gpinfop
->g
.fdplt
< limit
)
5241 tlslimit
= (limit
- gpinfop
->g
.fdplt
) & ~ (bfd_vma
) 8;
5242 limit
= gpinfop
->g
.fdplt
;
5246 if (gpinfop
->g
.tlsdplt
< tlslimit
)
5247 tlslimit
= gpinfop
->g
.tlsdplt
;
5249 /* Determine the ranges of GOT offsets that we can use for each
5250 range of addressing modes. */
5251 odd
= _frvfdpic_compute_got_alloc_data (&gpinfop
->got12
,
5260 (bfd_vma
)1 << (12-1));
5261 odd
= _frvfdpic_compute_got_alloc_data (&gpinfop
->gotlos
,
5262 gpinfop
->got12
.tmin
,
5264 gpinfop
->got12
.tmax
,
5268 - gpinfop
->got12
.fdplt
,
5271 - gpinfop
->got12
.tlsdplt
,
5272 (bfd_vma
)1 << (16-1));
5273 odd
= _frvfdpic_compute_got_alloc_data (&gpinfop
->gothilo
,
5274 gpinfop
->gotlos
.tmin
,
5276 gpinfop
->gotlos
.tmax
,
5280 - gpinfop
->got12
.fdplt
5281 - gpinfop
->gotlos
.fdplt
,
5282 gpinfop
->g
.tlsdhilo
,
5284 - gpinfop
->got12
.tlsdplt
5285 - gpinfop
->gotlos
.tlsdplt
,
5286 (bfd_vma
)1 << (32-1));
5288 /* Now assign (most) GOT offsets. */
5289 htab_traverse (frvfdpic_relocs_info (info
), _frvfdpic_assign_got_entries
,
5292 frvfdpic_got_section (info
)->size
= gpinfop
->gothilo
.tmax
5293 - gpinfop
->gothilo
.tmin
5294 /* If an odd word is the last word of the GOT, we don't need this
5295 word to be part of the GOT. */
5296 - (odd
+ 4 == gpinfop
->gothilo
.tmax
? 4 : 0);
5297 if (frvfdpic_got_section (info
)->size
== 0)
5298 frvfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
5299 else if (frvfdpic_got_section (info
)->size
== 12
5300 && ! elf_hash_table (info
)->dynamic_sections_created
)
5302 frvfdpic_got_section (info
)->flags
|= SEC_EXCLUDE
;
5303 frvfdpic_got_section (info
)->size
= 0;
5305 /* This will be non-NULL during relaxation. The assumption is that
5306 the size of one of these sections will never grow, only shrink,
5307 so we can use the larger buffer we allocated before. */
5308 else if (frvfdpic_got_section (info
)->contents
== NULL
)
5310 frvfdpic_got_section (info
)->contents
=
5311 (bfd_byte
*) bfd_zalloc (dynobj
,
5312 frvfdpic_got_section (info
)->size
);
5313 if (frvfdpic_got_section (info
)->contents
== NULL
)
5317 if (frvfdpic_gotrel_section (info
))
5318 /* Subtract the number of lzplt entries, since those will generate
5319 relocations in the pltrel section. */
5320 frvfdpic_gotrel_section (info
)->size
=
5321 (gpinfop
->g
.relocs
- gpinfop
->g
.lzplt
/ 8)
5322 * get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
5324 BFD_ASSERT (gpinfop
->g
.relocs
== 0);
5325 if (frvfdpic_gotrel_section (info
)->size
== 0)
5326 frvfdpic_gotrel_section (info
)->flags
|= SEC_EXCLUDE
;
5327 else if (frvfdpic_gotrel_section (info
)->contents
== NULL
)
5329 frvfdpic_gotrel_section (info
)->contents
=
5330 (bfd_byte
*) bfd_zalloc (dynobj
,
5331 frvfdpic_gotrel_section (info
)->size
);
5332 if (frvfdpic_gotrel_section (info
)->contents
== NULL
)
5336 frvfdpic_gotfixup_section (info
)->size
= (gpinfop
->g
.fixups
+ 1) * 4;
5337 if (frvfdpic_gotfixup_section (info
)->size
== 0)
5338 frvfdpic_gotfixup_section (info
)->flags
|= SEC_EXCLUDE
;
5339 else if (frvfdpic_gotfixup_section (info
)->contents
== NULL
)
5341 frvfdpic_gotfixup_section (info
)->contents
=
5342 (bfd_byte
*) bfd_zalloc (dynobj
,
5343 frvfdpic_gotfixup_section (info
)->size
);
5344 if (frvfdpic_gotfixup_section (info
)->contents
== NULL
)
5348 if (frvfdpic_pltrel_section (info
))
5350 frvfdpic_pltrel_section (info
)->size
=
5351 gpinfop
->g
.lzplt
/ 8
5352 * get_elf_backend_data (output_bfd
)->s
->sizeof_rel
;
5353 if (frvfdpic_pltrel_section (info
)->size
== 0)
5354 frvfdpic_pltrel_section (info
)->flags
|= SEC_EXCLUDE
;
5355 else if (frvfdpic_pltrel_section (info
)->contents
== NULL
)
5357 frvfdpic_pltrel_section (info
)->contents
=
5358 (bfd_byte
*) bfd_zalloc (dynobj
,
5359 frvfdpic_pltrel_section (info
)->size
);
5360 if (frvfdpic_pltrel_section (info
)->contents
== NULL
)
5365 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5366 such that there's room for the additional instruction needed to
5367 call the resolver. Since _frvfdpic_assign_got_entries didn't
5368 account for them, our block size is 4 bytes smaller than the real
5370 if (frvfdpic_plt_section (info
))
5372 frvfdpic_plt_section (info
)->size
= gpinfop
->g
.lzplt
5373 + ((gpinfop
->g
.lzplt
+ (FRVFDPIC_LZPLT_BLOCK_SIZE
- 4) - 8)
5374 / (FRVFDPIC_LZPLT_BLOCK_SIZE
- 4) * 4);
5377 /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5378 actually assign lazy PLT entries addresses. */
5379 gpinfop
->g
.lzplt
= 0;
5381 /* Save information that we're going to need to generate GOT and PLT
5383 frvfdpic_got_initial_offset (info
) = -gpinfop
->gothilo
.tmin
;
5385 if (get_elf_backend_data (output_bfd
)->want_got_sym
)
5386 elf_hash_table (info
)->hgot
->root
.u
.def
.value
5387 = frvfdpic_got_initial_offset (info
);
5389 if (frvfdpic_plt_section (info
))
5390 frvfdpic_plt_initial_offset (info
) =
5391 frvfdpic_plt_section (info
)->size
;
5393 /* Allocate a ret statement at plt_initial_offset, to be used by
5394 locally-resolved TLS descriptors. */
5395 if (gpinfop
->g
.tls_ret_refs
)
5396 frvfdpic_plt_section (info
)->size
+= 4;
5398 htab_traverse (frvfdpic_relocs_info (info
), _frvfdpic_assign_plt_entries
,
5401 /* Allocate the PLT section contents only after
5402 _frvfdpic_assign_plt_entries has a chance to add the size of the
5403 non-lazy PLT entries. */
5404 if (frvfdpic_plt_section (info
))
5406 if (frvfdpic_plt_section (info
)->size
== 0)
5407 frvfdpic_plt_section (info
)->flags
|= SEC_EXCLUDE
;
5408 else if (frvfdpic_plt_section (info
)->contents
== NULL
)
5410 frvfdpic_plt_section (info
)->contents
=
5411 (bfd_byte
*) bfd_zalloc (dynobj
,
5412 frvfdpic_plt_section (info
)->size
);
5413 if (frvfdpic_plt_section (info
)->contents
== NULL
)
5421 /* Set the sizes of the dynamic sections. */
5424 elf32_frvfdpic_size_dynamic_sections (bfd
*output_bfd
,
5425 struct bfd_link_info
*info
)
5429 struct _frvfdpic_dynamic_got_plt_info gpinfo
;
5431 dynobj
= elf_hash_table (info
)->dynobj
;
5432 BFD_ASSERT (dynobj
!= NULL
);
5434 if (elf_hash_table (info
)->dynamic_sections_created
)
5436 /* Set the contents of the .interp section to the interpreter. */
5437 if (bfd_link_executable (info
) && !info
->nointerp
)
5439 s
= bfd_get_linker_section (dynobj
, ".interp");
5440 BFD_ASSERT (s
!= NULL
);
5441 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
5442 s
->contents
= (bfd_byte
*) ELF_DYNAMIC_INTERPRETER
;
5446 memset (&gpinfo
, 0, sizeof (gpinfo
));
5447 gpinfo
.g
.info
= info
;
5451 htab_t relocs
= frvfdpic_relocs_info (info
);
5453 htab_traverse (relocs
, _frvfdpic_resolve_final_relocs_info
, &relocs
);
5455 if (relocs
== frvfdpic_relocs_info (info
))
5459 htab_traverse (frvfdpic_relocs_info (info
), _frvfdpic_count_got_plt_entries
,
5462 /* Allocate space to save the summary information, we're going to
5463 use it if we're doing relaxations. */
5464 frvfdpic_dynamic_got_plt_info (info
) = bfd_alloc (dynobj
, sizeof (gpinfo
.g
));
5466 if (!_frvfdpic_size_got_plt (output_bfd
, &gpinfo
))
5469 if (elf_hash_table (info
)->dynamic_sections_created
)
5471 if (frvfdpic_got_section (info
)->size
)
5472 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0))
5475 if (frvfdpic_pltrel_section (info
)->size
)
5476 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
5477 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_REL
)
5478 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
5481 if (frvfdpic_gotrel_section (info
)->size
)
5482 if (!_bfd_elf_add_dynamic_entry (info
, DT_REL
, 0)
5483 || !_bfd_elf_add_dynamic_entry (info
, DT_RELSZ
, 0)
5484 || !_bfd_elf_add_dynamic_entry (info
, DT_RELENT
,
5485 sizeof (Elf32_External_Rel
)))
5493 elf32_frvfdpic_always_size_sections (bfd
*output_bfd
,
5494 struct bfd_link_info
*info
)
5496 if (!bfd_link_relocatable (info
)
5497 && !bfd_elf_stack_segment_size (output_bfd
, info
,
5498 "__stacksize", DEFAULT_STACK_SIZE
))
5504 /* Check whether any of the relocations was optimized away, and
5505 subtract it from the relocation or fixup count. */
5507 _frvfdpic_check_discarded_relocs (bfd
*abfd
, asection
*sec
,
5508 struct bfd_link_info
*info
,
5510 bfd_boolean
*changed
)
5512 Elf_Internal_Shdr
*symtab_hdr
;
5513 struct elf_link_hash_entry
**sym_hashes
;
5514 Elf_Internal_Rela
*rel
, *erel
;
5516 if ((sec
->flags
& SEC_RELOC
) == 0
5517 || sec
->reloc_count
== 0)
5520 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
5521 sym_hashes
= elf_sym_hashes (abfd
);
5523 rel
= elf_section_data (sec
)->relocs
;
5525 /* Now examine each relocation. */
5526 for (erel
= rel
+ sec
->reloc_count
; rel
< erel
; rel
++)
5528 struct elf_link_hash_entry
*h
;
5529 unsigned long r_symndx
;
5530 struct frvfdpic_relocs_info
*picrel
;
5531 struct _frvfdpic_dynamic_got_info
*dinfo
;
5533 if (ELF32_R_TYPE (rel
->r_info
) != R_FRV_32
5534 && ELF32_R_TYPE (rel
->r_info
) != R_FRV_FUNCDESC
)
5537 if (_bfd_elf_section_offset (sec
->output_section
->owner
,
5538 info
, sec
, rel
->r_offset
)
5542 r_symndx
= ELF32_R_SYM (rel
->r_info
);
5543 if (r_symndx
< symtab_hdr
->sh_info
)
5547 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
5548 while (h
->root
.type
== bfd_link_hash_indirect
5549 || h
->root
.type
== bfd_link_hash_warning
)
5550 h
= (struct elf_link_hash_entry
*)h
->root
.u
.i
.link
;
5554 picrel
= frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info
),
5556 rel
->r_addend
, NO_INSERT
);
5558 picrel
= frvfdpic_relocs_info_for_local (frvfdpic_relocs_info (info
),
5560 rel
->r_addend
, NO_INSERT
);
5566 dinfo
= frvfdpic_dynamic_got_plt_info (info
);
5568 _frvfdpic_count_relocs_fixups (picrel
, dinfo
, TRUE
);
5569 if (ELF32_R_TYPE (rel
->r_info
) == R_FRV_32
)
5571 else /* we know (ELF32_R_TYPE (rel->r_info) == R_FRV_FUNCDESC) */
5573 _frvfdpic_count_relocs_fixups (picrel
, dinfo
, FALSE
);
5580 frvfdpic_elf_discard_info (bfd
*ibfd
,
5581 struct elf_reloc_cookie
*cookie ATTRIBUTE_UNUSED
,
5582 struct bfd_link_info
*info
)
5584 bfd_boolean changed
= FALSE
;
5588 /* Account for relaxation of .eh_frame section. */
5589 for (s
= ibfd
->sections
; s
; s
= s
->next
)
5590 if (s
->sec_info_type
== SEC_INFO_TYPE_EH_FRAME
)
5592 if (!_frvfdpic_check_discarded_relocs (ibfd
, s
, info
, &changed
))
5594 obfd
= s
->output_section
->owner
;
5599 struct _frvfdpic_dynamic_got_plt_info gpinfo
;
5601 memset (&gpinfo
, 0, sizeof (gpinfo
));
5602 memcpy (&gpinfo
.g
, frvfdpic_dynamic_got_plt_info (info
),
5605 /* Clear GOT and PLT assignments. */
5606 htab_traverse (frvfdpic_relocs_info (info
),
5607 _frvfdpic_reset_got_plt_entries
,
5610 if (!_frvfdpic_size_got_plt (obfd
, &gpinfo
))
5617 /* Look for opportunities to relax TLS relocations. We can assume
5618 we're linking the main executable or a static-tls library, since
5619 otherwise we wouldn't have got here. */
5622 _frvfdpic_relax_got_plt_entries (void **entryp
, void *dinfo_
)
5624 struct frvfdpic_relocs_info
*entry
= *entryp
;
5625 struct _frvfdpic_dynamic_got_info
*dinfo
= dinfo_
;
5627 _frvfdpic_relax_tls_entries (entry
, dinfo
, TRUE
);
5633 elf32_frvfdpic_relax_section (bfd
*abfd ATTRIBUTE_UNUSED
, asection
*sec
,
5634 struct bfd_link_info
*info
, bfd_boolean
*again
)
5636 struct _frvfdpic_dynamic_got_plt_info gpinfo
;
5638 if (bfd_link_relocatable (info
))
5639 (*info
->callbacks
->einfo
)
5640 (_("%P%F: --relax and -r may not be used together\n"));
5642 /* If we return early, we didn't change anything. */
5645 /* We'll do our thing when requested to relax the GOT section. */
5646 if (sec
!= frvfdpic_got_section (info
))
5649 /* We can only relax when linking the main executable or a library
5650 that can't be dlopened. */
5651 if (! bfd_link_executable (info
) && ! (info
->flags
& DF_STATIC_TLS
))
5654 /* If there isn't a TLS section for this binary, we can't do
5655 anything about its TLS relocations (it probably doesn't have
5657 if (elf_hash_table (info
)->tls_sec
== NULL
)
5660 memset (&gpinfo
, 0, sizeof (gpinfo
));
5661 memcpy (&gpinfo
.g
, frvfdpic_dynamic_got_plt_info (info
), sizeof (gpinfo
.g
));
5663 /* Now look for opportunities to relax, adjusting the GOT usage
5665 htab_traverse (frvfdpic_relocs_info (info
),
5666 _frvfdpic_relax_got_plt_entries
,
5669 /* If we changed anything, reset and re-assign GOT and PLT entries. */
5670 if (memcmp (frvfdpic_dynamic_got_plt_info (info
),
5671 &gpinfo
.g
, sizeof (gpinfo
.g
)) != 0)
5673 /* Clear GOT and PLT assignments. */
5674 htab_traverse (frvfdpic_relocs_info (info
),
5675 _frvfdpic_reset_got_plt_entries
,
5678 /* The owner of the TLS section is the output bfd. There should
5679 be a better way to get to it. */
5680 if (!_frvfdpic_size_got_plt (elf_hash_table (info
)->tls_sec
->owner
,
5684 /* Repeat until we don't make any further changes. We could fail to
5685 introduce changes in a round if, for example, the 12-bit range is
5686 full, but we later release some space by getting rid of TLS
5687 descriptors in it. We have to repeat the whole process because
5688 we might have changed the size of a section processed before this
5696 /* Fill in code and data in dynamic sections. */
5699 elf32_frv_finish_dynamic_sections (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5700 struct bfd_link_info
*info ATTRIBUTE_UNUSED
)
5702 /* Nothing to be done for non-FDPIC. */
5707 elf32_frvfdpic_finish_dynamic_sections (bfd
*output_bfd
,
5708 struct bfd_link_info
*info
)
5713 dynobj
= elf_hash_table (info
)->dynobj
;
5715 if (frvfdpic_dynamic_got_plt_info (info
))
5717 BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info
)->tls_ret_refs
== 0);
5719 if (frvfdpic_got_section (info
))
5721 BFD_ASSERT (frvfdpic_gotrel_section (info
)->size
5722 == (frvfdpic_gotrel_section (info
)->reloc_count
5723 * sizeof (Elf32_External_Rel
)));
5725 if (frvfdpic_gotfixup_section (info
))
5727 struct elf_link_hash_entry
*hgot
= elf_hash_table (info
)->hgot
;
5728 bfd_vma got_value
= hgot
->root
.u
.def
.value
5729 + hgot
->root
.u
.def
.section
->output_section
->vma
5730 + hgot
->root
.u
.def
.section
->output_offset
;
5731 struct bfd_link_hash_entry
*hend
;
5733 _frvfdpic_add_rofixup (output_bfd
, frvfdpic_gotfixup_section (info
),
5736 if (frvfdpic_gotfixup_section (info
)->size
5737 != (frvfdpic_gotfixup_section (info
)->reloc_count
* 4))
5740 info
->callbacks
->einfo
5741 ("LINKER BUG: .rofixup section size mismatch\n");
5745 hend
= bfd_link_hash_lookup (info
->hash
, "__ROFIXUP_END__",
5746 FALSE
, FALSE
, TRUE
);
5748 && (hend
->type
== bfd_link_hash_defined
5749 || hend
->type
== bfd_link_hash_defweak
)
5750 && hend
->u
.def
.section
->output_section
!= NULL
)
5753 frvfdpic_gotfixup_section (info
)->output_section
->vma
5754 + frvfdpic_gotfixup_section (info
)->output_offset
5755 + frvfdpic_gotfixup_section (info
)->size
5756 - hend
->u
.def
.section
->output_section
->vma
5757 - hend
->u
.def
.section
->output_offset
;
5758 BFD_ASSERT (hend
->u
.def
.value
== value
);
5759 if (hend
->u
.def
.value
!= value
)
5764 if (frvfdpic_pltrel_section (info
))
5766 BFD_ASSERT (frvfdpic_pltrel_section (info
)->size
5767 == (frvfdpic_pltrel_section (info
)->reloc_count
5768 * sizeof (Elf32_External_Rel
)));
5772 if (elf_hash_table (info
)->dynamic_sections_created
)
5774 Elf32_External_Dyn
* dyncon
;
5775 Elf32_External_Dyn
* dynconend
;
5777 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
5779 BFD_ASSERT (sdyn
!= NULL
);
5781 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
5782 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
5784 for (; dyncon
< dynconend
; dyncon
++)
5786 Elf_Internal_Dyn dyn
;
5788 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
5796 dyn
.d_un
.d_ptr
= frvfdpic_got_section (info
)->output_section
->vma
5797 + frvfdpic_got_section (info
)->output_offset
5798 + frvfdpic_got_initial_offset (info
);
5799 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5803 dyn
.d_un
.d_ptr
= frvfdpic_pltrel_section (info
)
5804 ->output_section
->vma
5805 + frvfdpic_pltrel_section (info
)->output_offset
;
5806 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5810 dyn
.d_un
.d_val
= frvfdpic_pltrel_section (info
)->size
;
5811 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
5820 /* Adjust a symbol defined by a dynamic object and referenced by a
5824 elf32_frvfdpic_adjust_dynamic_symbol
5825 (struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5826 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
)
5830 dynobj
= elf_hash_table (info
)->dynobj
;
5832 /* Make sure we know what is going on here. */
5833 BFD_ASSERT (dynobj
!= NULL
5837 && !h
->def_regular
)));
5839 /* If this is a weak symbol, and there is a real definition, the
5840 processor independent code will have arranged for us to see the
5841 real definition first, and we can just use the same value. */
5842 if (h
->is_weakalias
)
5844 struct elf_link_hash_entry
*def
= weakdef (h
);
5845 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
5846 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
5847 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
5854 /* Perform any actions needed for dynamic symbols. */
5857 elf32_frvfdpic_finish_dynamic_symbol
5858 (bfd
*output_bfd ATTRIBUTE_UNUSED
,
5859 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5860 struct elf_link_hash_entry
*h ATTRIBUTE_UNUSED
,
5861 Elf_Internal_Sym
*sym ATTRIBUTE_UNUSED
)
5866 /* Decide whether to attempt to turn absptr or lsda encodings in
5867 shared libraries into pcrel within the given input section. */
5870 frvfdpic_elf_use_relative_eh_frame
5871 (bfd
*input_bfd ATTRIBUTE_UNUSED
,
5872 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
5873 asection
*eh_frame_section ATTRIBUTE_UNUSED
)
5875 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
5879 /* Adjust the contents of an eh_frame_hdr section before they're output. */
5882 frvfdpic_elf_encode_eh_address (bfd
*abfd
,
5883 struct bfd_link_info
*info
,
5884 asection
*osec
, bfd_vma offset
,
5885 asection
*loc_sec
, bfd_vma loc_offset
,
5888 struct elf_link_hash_entry
*h
;
5890 h
= elf_hash_table (info
)->hgot
;
5891 BFD_ASSERT (h
&& h
->root
.type
== bfd_link_hash_defined
);
5893 if (! h
|| (_frvfdpic_osec_to_segment (abfd
, osec
)
5894 == _frvfdpic_osec_to_segment (abfd
, loc_sec
->output_section
)))
5895 return _bfd_elf_encode_eh_address (abfd
, info
, osec
, offset
,
5896 loc_sec
, loc_offset
, encoded
);
5898 BFD_ASSERT (_frvfdpic_osec_to_segment (abfd
, osec
)
5899 == (_frvfdpic_osec_to_segment
5900 (abfd
, h
->root
.u
.def
.section
->output_section
)));
5902 *encoded
= osec
->vma
+ offset
5903 - (h
->root
.u
.def
.value
5904 + h
->root
.u
.def
.section
->output_section
->vma
5905 + h
->root
.u
.def
.section
->output_offset
);
5907 return DW_EH_PE_datarel
| DW_EH_PE_sdata4
;
5910 /* Look through the relocs for a section during the first phase.
5912 Besides handling virtual table relocs for gc, we have to deal with
5913 all sorts of PIC-related relocations. We describe below the
5914 general plan on how to handle such relocations, even though we only
5915 collect information at this point, storing them in hash tables for
5916 perusal of later passes.
5918 32 relocations are propagated to the linker output when creating
5919 position-independent output. LO16 and HI16 relocations are not
5920 supposed to be encountered in this case.
5922 LABEL16 should always be resolvable by the linker, since it's only
5925 LABEL24, on the other hand, is used by calls. If it turns out that
5926 the target of a call is a dynamic symbol, a PLT entry must be
5927 created for it, which triggers the creation of a private function
5928 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
5930 GPREL relocations require the referenced symbol to be in the same
5931 segment as _gp, but this can only be checked later.
5933 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
5934 exist. LABEL24 might as well, since it may require a PLT entry,
5935 that will require a got.
5937 Non-FUNCDESC GOT relocations require a GOT entry to be created
5938 regardless of whether the symbol is dynamic. However, since a
5939 global symbol that turns out to not be exported may have the same
5940 address of a non-dynamic symbol, we don't assign GOT entries at
5941 this point, such that we can share them in this case. A relocation
5942 for the GOT entry always has to be created, be it to offset a
5943 private symbol by the section load address, be it to get the symbol
5944 resolved dynamically.
5946 FUNCDESC GOT relocations require a GOT entry to be created, and
5947 handled as if a FUNCDESC relocation was applied to the GOT entry in
5950 FUNCDESC relocations referencing a symbol that turns out to NOT be
5951 dynamic cause a private function descriptor to be created. The
5952 FUNCDESC relocation then decays to a 32 relocation that points at
5953 the private descriptor. If the symbol is dynamic, the FUNCDESC
5954 relocation is propagated to the linker output, such that the
5955 dynamic linker creates the canonical descriptor, pointing to the
5956 dynamically-resolved definition of the function.
5958 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
5959 symbols that are assigned to the same segment as the GOT, but we
5960 can only check this later, after we know the complete set of
5961 symbols defined and/or exported.
5963 FUNCDESC GOTOFF relocations require a function descriptor to be
5964 created and, unless lazy binding is disabled or the symbol is not
5965 dynamic, a lazy PLT entry. Since we can't tell at this point
5966 whether a symbol is going to be dynamic, we have to decide later
5967 whether to create a lazy PLT entry or bind the descriptor directly
5968 to the private function.
5970 FUNCDESC_VALUE relocations are not supposed to be present in object
5971 files, but they may very well be simply propagated to the linker
5972 output, since they have no side effect.
5975 A function descriptor always requires a FUNCDESC_VALUE relocation.
5976 Whether it's in .plt.rel or not depends on whether lazy binding is
5977 enabled and on whether the referenced symbol is dynamic.
5979 The existence of a lazy PLT requires the resolverStub lazy PLT
5980 entry to be present.
5983 As for assignment of GOT, PLT and lazy PLT entries, and private
5984 descriptors, we might do them all sequentially, but we can do
5985 better than that. For example, we can place GOT entries and
5986 private function descriptors referenced using 12-bit operands
5987 closer to the PIC register value, such that these relocations don't
5988 overflow. Those that are only referenced with LO16 relocations
5989 could come next, but we may as well place PLT-required function
5990 descriptors in the 12-bit range to make them shorter. Symbols
5991 referenced with LO16/HI16 may come next, but we may place
5992 additional function descriptors in the 16-bit range if we can
5993 reliably tell that we've already placed entries that are ever
5994 referenced with only LO16. PLT entries are therefore generated as
5995 small as possible, while not introducing relocation overflows in
5996 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
5997 generated before or after PLT entries, but not intermingled with
5998 them, such that we can have more lazy PLT entries in range for a
5999 branch to the resolverStub. The resolverStub should be emitted at
6000 the most distant location from the first lazy PLT entry such that
6001 it's still in range for a branch, or closer, if there isn't a need
6002 for so many lazy PLT entries. Additional lazy PLT entries may be
6003 emitted after the resolverStub, as long as branches are still in
6004 range. If the branch goes out of range, longer lazy PLT entries
6007 We could further optimize PLT and lazy PLT entries by giving them
6008 priority in assignment to closer-to-gr17 locations depending on the
6009 number of occurrences of references to them (assuming a function
6010 that's called more often is more important for performance, so its
6011 PLT entry should be faster), or taking hints from the compiler.
6012 Given infinite time and money... :-) */
6015 elf32_frv_check_relocs (bfd
*abfd
,
6016 struct bfd_link_info
*info
,
6018 const Elf_Internal_Rela
*relocs
)
6020 Elf_Internal_Shdr
*symtab_hdr
;
6021 struct elf_link_hash_entry
**sym_hashes
;
6022 const Elf_Internal_Rela
*rel
;
6023 const Elf_Internal_Rela
*rel_end
;
6025 struct frvfdpic_relocs_info
*picrel
;
6027 if (bfd_link_relocatable (info
))
6030 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
6031 sym_hashes
= elf_sym_hashes (abfd
);
6033 dynobj
= elf_hash_table (info
)->dynobj
;
6034 rel_end
= relocs
+ sec
->reloc_count
;
6035 for (rel
= relocs
; rel
< rel_end
; rel
++)
6037 struct elf_link_hash_entry
*h
;
6038 unsigned long r_symndx
;
6040 r_symndx
= ELF32_R_SYM (rel
->r_info
);
6041 if (r_symndx
< symtab_hdr
->sh_info
)
6045 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
6046 while (h
->root
.type
== bfd_link_hash_indirect
6047 || h
->root
.type
== bfd_link_hash_warning
)
6048 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
6051 switch (ELF32_R_TYPE (rel
->r_info
))
6053 case R_FRV_GETTLSOFF
:
6054 case R_FRV_TLSDESC_VALUE
:
6055 case R_FRV_GOTTLSDESC12
:
6056 case R_FRV_GOTTLSDESCHI
:
6057 case R_FRV_GOTTLSDESCLO
:
6058 case R_FRV_GOTTLSOFF12
:
6059 case R_FRV_GOTTLSOFFHI
:
6060 case R_FRV_GOTTLSOFFLO
:
6065 case R_FRV_FUNCDESC_GOT12
:
6066 case R_FRV_FUNCDESC_GOTHI
:
6067 case R_FRV_FUNCDESC_GOTLO
:
6068 case R_FRV_GOTOFF12
:
6069 case R_FRV_GOTOFFHI
:
6070 case R_FRV_GOTOFFLO
:
6071 case R_FRV_FUNCDESC_GOTOFF12
:
6072 case R_FRV_FUNCDESC_GOTOFFHI
:
6073 case R_FRV_FUNCDESC_GOTOFFLO
:
6074 case R_FRV_FUNCDESC
:
6075 case R_FRV_FUNCDESC_VALUE
:
6076 case R_FRV_TLSMOFF12
:
6077 case R_FRV_TLSMOFFHI
:
6078 case R_FRV_TLSMOFFLO
:
6080 if (! IS_FDPIC (abfd
))
6084 case R_FRV_GPRELU12
:
6091 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
6092 if (! _frv_create_got_section (abfd
, info
))
6095 if (! IS_FDPIC (abfd
))
6102 if (h
->dynindx
== -1)
6103 switch (ELF_ST_VISIBILITY (h
->other
))
6109 bfd_elf_link_record_dynamic_symbol (info
, h
);
6113 = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info
),
6115 rel
->r_addend
, INSERT
);
6118 picrel
= frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6119 (info
), abfd
, r_symndx
,
6120 rel
->r_addend
, INSERT
);
6130 switch (ELF32_R_TYPE (rel
->r_info
))
6133 if (IS_FDPIC (abfd
))
6137 case R_FRV_FUNCDESC_VALUE
:
6138 picrel
->relocsfdv
++;
6139 if (bfd_section_flags (sec
) & SEC_ALLOC
)
6144 if (! IS_FDPIC (abfd
))
6148 if (bfd_section_flags (sec
) & SEC_ALLOC
)
6158 picrel
->gothilo
= 1;
6161 case R_FRV_FUNCDESC_GOT12
:
6162 picrel
->fdgot12
= 1;
6165 case R_FRV_FUNCDESC_GOTHI
:
6166 case R_FRV_FUNCDESC_GOTLO
:
6167 picrel
->fdgothilo
= 1;
6170 case R_FRV_GOTOFF12
:
6171 case R_FRV_GOTOFFHI
:
6172 case R_FRV_GOTOFFLO
:
6176 case R_FRV_FUNCDESC_GOTOFF12
:
6177 picrel
->fdgoff12
= 1;
6180 case R_FRV_FUNCDESC_GOTOFFHI
:
6181 case R_FRV_FUNCDESC_GOTOFFLO
:
6182 picrel
->fdgoffhilo
= 1;
6185 case R_FRV_FUNCDESC
:
6190 case R_FRV_GETTLSOFF
:
6194 case R_FRV_TLSDESC_VALUE
:
6195 picrel
->relocstlsd
++;
6198 case R_FRV_GOTTLSDESC12
:
6199 picrel
->tlsdesc12
= 1;
6202 case R_FRV_GOTTLSDESCHI
:
6203 case R_FRV_GOTTLSDESCLO
:
6204 picrel
->tlsdeschilo
= 1;
6207 case R_FRV_TLSMOFF12
:
6208 case R_FRV_TLSMOFFHI
:
6209 case R_FRV_TLSMOFFLO
:
6213 case R_FRV_GOTTLSOFF12
:
6214 picrel
->tlsoff12
= 1;
6215 info
->flags
|= DF_STATIC_TLS
;
6218 case R_FRV_GOTTLSOFFHI
:
6219 case R_FRV_GOTTLSOFFLO
:
6220 picrel
->tlsoffhilo
= 1;
6221 info
->flags
|= DF_STATIC_TLS
;
6225 picrel
->relocstlsoff
++;
6226 info
->flags
|= DF_STATIC_TLS
;
6229 /* This relocation describes the C++ object vtable hierarchy.
6230 Reconstruct it for later use during GC. */
6231 case R_FRV_GNU_VTINHERIT
:
6232 if (!bfd_elf_gc_record_vtinherit (abfd
, sec
, h
, rel
->r_offset
))
6236 /* This relocation describes which C++ vtable entries are actually
6237 used. Record for later use during GC. */
6238 case R_FRV_GNU_VTENTRY
:
6239 if (!bfd_elf_gc_record_vtentry (abfd
, sec
, h
, rel
->r_addend
))
6247 case R_FRV_GPRELU12
:
6251 case R_FRV_TLSDESC_RELAX
:
6252 case R_FRV_GETTLSOFF_RELAX
:
6253 case R_FRV_TLSOFF_RELAX
:
6258 /* xgettext:c-format */
6259 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
6260 abfd
, (unsigned int) ELF32_R_TYPE (rel
->r_info
));
6269 /* Return the machine subcode from the ELF e_flags header. */
6272 elf32_frv_machine (bfd
*abfd
)
6274 switch (elf_elfheader (abfd
)->e_flags
& EF_FRV_CPU_MASK
)
6277 case EF_FRV_CPU_FR550
: return bfd_mach_fr550
;
6278 case EF_FRV_CPU_FR500
: return bfd_mach_fr500
;
6279 case EF_FRV_CPU_FR450
: return bfd_mach_fr450
;
6280 case EF_FRV_CPU_FR405
: return bfd_mach_fr400
;
6281 case EF_FRV_CPU_FR400
: return bfd_mach_fr400
;
6282 case EF_FRV_CPU_FR300
: return bfd_mach_fr300
;
6283 case EF_FRV_CPU_SIMPLE
: return bfd_mach_frvsimple
;
6284 case EF_FRV_CPU_TOMCAT
: return bfd_mach_frvtomcat
;
6287 return bfd_mach_frv
;
6290 /* Set the right machine number for a FRV ELF file. */
6293 elf32_frv_object_p (bfd
*abfd
)
6295 bfd_default_set_arch_mach (abfd
, bfd_arch_frv
, elf32_frv_machine (abfd
));
6296 return (((elf_elfheader (abfd
)->e_flags
& EF_FRV_FDPIC
) != 0)
6297 == (IS_FDPIC (abfd
)));
6300 /* Function to set the ELF flag bits. */
6303 frv_elf_set_private_flags (bfd
*abfd
, flagword flags
)
6305 elf_elfheader (abfd
)->e_flags
= flags
;
6306 elf_flags_init (abfd
) = TRUE
;
6310 /* Return true if the architecture described by elf header flag
6311 EXTENSION is an extension of the architecture described by BASE. */
6314 frv_elf_arch_extension_p (flagword base
, flagword extension
)
6316 if (base
== extension
)
6319 /* CPU_GENERIC code can be merged with code for a specific
6320 architecture, in which case the result is marked as being
6321 for the specific architecture. Everything is therefore
6322 an extension of CPU_GENERIC. */
6323 if (base
== EF_FRV_CPU_GENERIC
)
6326 if (extension
== EF_FRV_CPU_FR450
)
6327 if (base
== EF_FRV_CPU_FR400
|| base
== EF_FRV_CPU_FR405
)
6330 if (extension
== EF_FRV_CPU_FR405
)
6331 if (base
== EF_FRV_CPU_FR400
)
6337 /* Merge backend specific data from an object file to the output
6338 object file when linking. */
6341 frv_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
6343 bfd
*obfd
= info
->output_bfd
;
6344 flagword old_flags
, old_partial
;
6345 flagword new_flags
, new_partial
;
6346 bfd_boolean error
= FALSE
;
6350 /* FIXME: What should be checked when linking shared libraries? */
6351 if ((ibfd
->flags
& DYNAMIC
) != 0)
6354 new_opt
[0] = old_opt
[0] = '\0';
6355 new_flags
= elf_elfheader (ibfd
)->e_flags
;
6356 old_flags
= elf_elfheader (obfd
)->e_flags
;
6358 if (new_flags
& EF_FRV_FDPIC
)
6359 new_flags
&= ~EF_FRV_PIC
;
6363 ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %s",
6364 old_flags
, new_flags
, elf_flags_init (obfd
) ? "yes" : "no",
6365 bfd_get_filename (ibfd
));
6368 if (!elf_flags_init (obfd
)) /* First call, no flags set. */
6370 elf_flags_init (obfd
) = TRUE
;
6371 old_flags
= new_flags
;
6374 else if (new_flags
== old_flags
) /* Compatible flags are ok. */
6377 else /* Possibly incompatible flags. */
6379 /* Warn if different # of gprs are used. Note, 0 means nothing is
6380 said about the size of gprs. */
6381 new_partial
= (new_flags
& EF_FRV_GPR_MASK
);
6382 old_partial
= (old_flags
& EF_FRV_GPR_MASK
);
6383 if (new_partial
== old_partial
)
6386 else if (new_partial
== 0)
6389 else if (old_partial
== 0)
6390 old_flags
|= new_partial
;
6394 switch (new_partial
)
6396 default: strcat (new_opt
, " -mgpr-??"); break;
6397 case EF_FRV_GPR_32
: strcat (new_opt
, " -mgpr-32"); break;
6398 case EF_FRV_GPR_64
: strcat (new_opt
, " -mgpr-64"); break;
6401 switch (old_partial
)
6403 default: strcat (old_opt
, " -mgpr-??"); break;
6404 case EF_FRV_GPR_32
: strcat (old_opt
, " -mgpr-32"); break;
6405 case EF_FRV_GPR_64
: strcat (old_opt
, " -mgpr-64"); break;
6409 /* Warn if different # of fprs are used. Note, 0 means nothing is
6410 said about the size of fprs. */
6411 new_partial
= (new_flags
& EF_FRV_FPR_MASK
);
6412 old_partial
= (old_flags
& EF_FRV_FPR_MASK
);
6413 if (new_partial
== old_partial
)
6416 else if (new_partial
== 0)
6419 else if (old_partial
== 0)
6420 old_flags
|= new_partial
;
6424 switch (new_partial
)
6426 default: strcat (new_opt
, " -mfpr-?"); break;
6427 case EF_FRV_FPR_32
: strcat (new_opt
, " -mfpr-32"); break;
6428 case EF_FRV_FPR_64
: strcat (new_opt
, " -mfpr-64"); break;
6429 case EF_FRV_FPR_NONE
: strcat (new_opt
, " -msoft-float"); break;
6432 switch (old_partial
)
6434 default: strcat (old_opt
, " -mfpr-?"); break;
6435 case EF_FRV_FPR_32
: strcat (old_opt
, " -mfpr-32"); break;
6436 case EF_FRV_FPR_64
: strcat (old_opt
, " -mfpr-64"); break;
6437 case EF_FRV_FPR_NONE
: strcat (old_opt
, " -msoft-float"); break;
6441 /* Warn if different dword support was used. Note, 0 means nothing is
6442 said about the dword support. */
6443 new_partial
= (new_flags
& EF_FRV_DWORD_MASK
);
6444 old_partial
= (old_flags
& EF_FRV_DWORD_MASK
);
6445 if (new_partial
== old_partial
)
6448 else if (new_partial
== 0)
6451 else if (old_partial
== 0)
6452 old_flags
|= new_partial
;
6456 switch (new_partial
)
6458 default: strcat (new_opt
, " -mdword-?"); break;
6459 case EF_FRV_DWORD_YES
: strcat (new_opt
, " -mdword"); break;
6460 case EF_FRV_DWORD_NO
: strcat (new_opt
, " -mno-dword"); break;
6463 switch (old_partial
)
6465 default: strcat (old_opt
, " -mdword-?"); break;
6466 case EF_FRV_DWORD_YES
: strcat (old_opt
, " -mdword"); break;
6467 case EF_FRV_DWORD_NO
: strcat (old_opt
, " -mno-dword"); break;
6471 /* Or in flags that accumulate (ie, if one module uses it, mark that the
6473 old_flags
|= new_flags
& (EF_FRV_DOUBLE
6476 | EF_FRV_NON_PIC_RELOCS
);
6478 /* If any module was compiled without -G0, clear the G0 bit. */
6479 old_flags
= ((old_flags
& ~ EF_FRV_G0
)
6480 | (old_flags
& new_flags
& EF_FRV_G0
));
6482 /* If any module was compiled without -mnopack, clear the mnopack bit. */
6483 old_flags
= ((old_flags
& ~ EF_FRV_NOPACK
)
6484 | (old_flags
& new_flags
& EF_FRV_NOPACK
));
6486 /* We don't have to do anything if the pic flags are the same, or the new
6487 module(s) were compiled with -mlibrary-pic. */
6488 new_partial
= (new_flags
& EF_FRV_PIC_FLAGS
);
6489 old_partial
= (old_flags
& EF_FRV_PIC_FLAGS
);
6490 if ((new_partial
== old_partial
) || ((new_partial
& EF_FRV_LIBPIC
) != 0))
6493 /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
6494 flags if any from the new module. */
6495 else if ((old_partial
& EF_FRV_LIBPIC
) != 0)
6496 old_flags
= (old_flags
& ~ EF_FRV_PIC_FLAGS
) | new_partial
;
6498 /* If we have mixtures of -fpic and -fPIC, or in both bits. */
6499 else if (new_partial
!= 0 && old_partial
!= 0)
6500 old_flags
|= new_partial
;
6502 /* One module was compiled for pic and the other was not, see if we have
6503 had any relocations that are not pic-safe. */
6506 if ((old_flags
& EF_FRV_NON_PIC_RELOCS
) == 0)
6507 old_flags
|= new_partial
;
6510 old_flags
&= ~ EF_FRV_PIC_FLAGS
;
6511 #ifndef FRV_NO_PIC_ERROR
6514 /* xgettext:c-format */
6515 (_("%pB: compiled with %s and linked with modules"
6516 " that use non-pic relocations"),
6517 ibfd
, (new_flags
& EF_FRV_BIGPIC
) ? "-fPIC" : "-fpic");
6522 /* Warn if different cpu is used (allow a specific cpu to override
6523 the generic cpu). */
6524 new_partial
= (new_flags
& EF_FRV_CPU_MASK
);
6525 old_partial
= (old_flags
& EF_FRV_CPU_MASK
);
6526 if (frv_elf_arch_extension_p (new_partial
, old_partial
))
6529 else if (frv_elf_arch_extension_p (old_partial
, new_partial
))
6530 old_flags
= (old_flags
& ~EF_FRV_CPU_MASK
) | new_partial
;
6534 switch (new_partial
)
6536 default: strcat (new_opt
, " -mcpu=?"); break;
6537 case EF_FRV_CPU_GENERIC
: strcat (new_opt
, " -mcpu=frv"); break;
6538 case EF_FRV_CPU_SIMPLE
: strcat (new_opt
, " -mcpu=simple"); break;
6539 case EF_FRV_CPU_FR550
: strcat (new_opt
, " -mcpu=fr550"); break;
6540 case EF_FRV_CPU_FR500
: strcat (new_opt
, " -mcpu=fr500"); break;
6541 case EF_FRV_CPU_FR450
: strcat (new_opt
, " -mcpu=fr450"); break;
6542 case EF_FRV_CPU_FR405
: strcat (new_opt
, " -mcpu=fr405"); break;
6543 case EF_FRV_CPU_FR400
: strcat (new_opt
, " -mcpu=fr400"); break;
6544 case EF_FRV_CPU_FR300
: strcat (new_opt
, " -mcpu=fr300"); break;
6545 case EF_FRV_CPU_TOMCAT
: strcat (new_opt
, " -mcpu=tomcat"); break;
6548 switch (old_partial
)
6550 default: strcat (old_opt
, " -mcpu=?"); break;
6551 case EF_FRV_CPU_GENERIC
: strcat (old_opt
, " -mcpu=frv"); break;
6552 case EF_FRV_CPU_SIMPLE
: strcat (old_opt
, " -mcpu=simple"); break;
6553 case EF_FRV_CPU_FR550
: strcat (old_opt
, " -mcpu=fr550"); break;
6554 case EF_FRV_CPU_FR500
: strcat (old_opt
, " -mcpu=fr500"); break;
6555 case EF_FRV_CPU_FR450
: strcat (old_opt
, " -mcpu=fr450"); break;
6556 case EF_FRV_CPU_FR405
: strcat (old_opt
, " -mcpu=fr405"); break;
6557 case EF_FRV_CPU_FR400
: strcat (old_opt
, " -mcpu=fr400"); break;
6558 case EF_FRV_CPU_FR300
: strcat (old_opt
, " -mcpu=fr300"); break;
6559 case EF_FRV_CPU_TOMCAT
: strcat (old_opt
, " -mcpu=tomcat"); break;
6563 /* Print out any mismatches from above. */
6568 /* xgettext:c-format */
6569 (_("%pB: compiled with %s and linked with modules compiled with %s"),
6570 ibfd
, new_opt
, old_opt
);
6573 /* Warn about any other mismatches */
6574 new_partial
= (new_flags
& ~ EF_FRV_ALL_FLAGS
);
6575 old_partial
= (old_flags
& ~ EF_FRV_ALL_FLAGS
);
6576 if (new_partial
!= old_partial
)
6578 old_flags
|= new_partial
;
6581 /* xgettext:c-format */
6582 (_("%pB: uses different unknown e_flags (%#x) fields"
6583 " than previous modules (%#x)"),
6584 ibfd
, new_partial
, old_partial
);
6588 /* If the cpu is -mcpu=simple, then set the -mnopack bit. */
6589 if ((old_flags
& EF_FRV_CPU_MASK
) == EF_FRV_CPU_SIMPLE
)
6590 old_flags
|= EF_FRV_NOPACK
;
6592 /* Update the old flags now with changes made above. */
6593 old_partial
= elf_elfheader (obfd
)->e_flags
& EF_FRV_CPU_MASK
;
6594 elf_elfheader (obfd
)->e_flags
= old_flags
;
6595 if (old_partial
!= (old_flags
& EF_FRV_CPU_MASK
))
6596 bfd_default_set_arch_mach (obfd
, bfd_arch_frv
, elf32_frv_machine (obfd
));
6598 if (((new_flags
& EF_FRV_FDPIC
) == 0)
6599 != (! IS_FDPIC (ibfd
)))
6602 if (IS_FDPIC (obfd
))
6604 (_("%pB: cannot link non-fdpic object file into fdpic executable"),
6608 (_("%pB: cannot link fdpic object file into non-fdpic executable"),
6613 bfd_set_error (bfd_error_bad_value
);
6620 frv_elf_print_private_bfd_data (bfd
*abfd
, void * ptr
)
6622 FILE *file
= (FILE *) ptr
;
6625 BFD_ASSERT (abfd
!= NULL
&& ptr
!= NULL
);
6627 /* Print normal ELF private data. */
6628 _bfd_elf_print_private_bfd_data (abfd
, ptr
);
6630 flags
= elf_elfheader (abfd
)->e_flags
;
6631 fprintf (file
, _("private flags = 0x%lx:"), (unsigned long) flags
);
6633 switch (flags
& EF_FRV_CPU_MASK
)
6636 case EF_FRV_CPU_SIMPLE
: fprintf (file
, " -mcpu=simple"); break;
6637 case EF_FRV_CPU_FR550
: fprintf (file
, " -mcpu=fr550"); break;
6638 case EF_FRV_CPU_FR500
: fprintf (file
, " -mcpu=fr500"); break;
6639 case EF_FRV_CPU_FR450
: fprintf (file
, " -mcpu=fr450"); break;
6640 case EF_FRV_CPU_FR405
: fprintf (file
, " -mcpu=fr405"); break;
6641 case EF_FRV_CPU_FR400
: fprintf (file
, " -mcpu=fr400"); break;
6642 case EF_FRV_CPU_FR300
: fprintf (file
, " -mcpu=fr300"); break;
6643 case EF_FRV_CPU_TOMCAT
: fprintf (file
, " -mcpu=tomcat"); break;
6646 switch (flags
& EF_FRV_GPR_MASK
)
6649 case EF_FRV_GPR_32
: fprintf (file
, " -mgpr-32"); break;
6650 case EF_FRV_GPR_64
: fprintf (file
, " -mgpr-64"); break;
6653 switch (flags
& EF_FRV_FPR_MASK
)
6656 case EF_FRV_FPR_32
: fprintf (file
, " -mfpr-32"); break;
6657 case EF_FRV_FPR_64
: fprintf (file
, " -mfpr-64"); break;
6658 case EF_FRV_FPR_NONE
: fprintf (file
, " -msoft-float"); break;
6661 switch (flags
& EF_FRV_DWORD_MASK
)
6664 case EF_FRV_DWORD_YES
: fprintf (file
, " -mdword"); break;
6665 case EF_FRV_DWORD_NO
: fprintf (file
, " -mno-dword"); break;
6668 if (flags
& EF_FRV_DOUBLE
)
6669 fprintf (file
, " -mdouble");
6671 if (flags
& EF_FRV_MEDIA
)
6672 fprintf (file
, " -mmedia");
6674 if (flags
& EF_FRV_MULADD
)
6675 fprintf (file
, " -mmuladd");
6677 if (flags
& EF_FRV_PIC
)
6678 fprintf (file
, " -fpic");
6680 if (flags
& EF_FRV_BIGPIC
)
6681 fprintf (file
, " -fPIC");
6683 if (flags
& EF_FRV_LIBPIC
)
6684 fprintf (file
, " -mlibrary-pic");
6686 if (flags
& EF_FRV_FDPIC
)
6687 fprintf (file
, " -mfdpic");
6689 if (flags
& EF_FRV_NON_PIC_RELOCS
)
6690 fprintf (file
, " non-pic relocations");
6692 if (flags
& EF_FRV_G0
)
6693 fprintf (file
, " -G0");
6700 /* Support for core dump NOTE sections. */
6703 elf32_frv_grok_prstatus (bfd
*abfd
, Elf_Internal_Note
*note
)
6706 unsigned int raw_size
;
6708 switch (note
->descsz
)
6713 /* The Linux/FRV elf_prstatus struct is 268 bytes long. The other
6714 hardcoded offsets and sizes listed below (and contained within
6715 this lexical block) refer to fields in the target's elf_prstatus
6718 /* `pr_cursig' is at offset 12. */
6719 elf_tdata (abfd
)->core
->signal
= bfd_get_16 (abfd
, note
->descdata
+ 12);
6721 /* `pr_pid' is at offset 24. */
6722 elf_tdata (abfd
)->core
->lwpid
= bfd_get_32 (abfd
, note
->descdata
+ 24);
6724 /* `pr_reg' is at offset 72. */
6727 /* Most grok_prstatus implementations set `raw_size' to the size
6728 of the pr_reg field. For Linux/FRV, we set `raw_size' to be
6729 the size of `pr_reg' plus the size of `pr_exec_fdpic_loadmap'
6730 and `pr_interp_fdpic_loadmap', both of which (by design)
6731 immediately follow `pr_reg'. This will allow these fields to
6732 be viewed by GDB as registers.
6734 `pr_reg' is 184 bytes long. `pr_exec_fdpic_loadmap' and
6735 `pr_interp_fdpic_loadmap' are 4 bytes each. */
6736 raw_size
= 184 + 4 + 4;
6741 /* Make a ".reg/999" section. */
6742 return _bfd_elfcore_make_pseudosection (abfd
, ".reg", raw_size
,
6743 note
->descpos
+ offset
);
6747 elf32_frv_grok_psinfo (bfd
*abfd
, Elf_Internal_Note
*note
)
6749 switch (note
->descsz
)
6754 /* The Linux/FRV elf_prpsinfo struct is 124 bytes long. */
6757 /* `pr_fname' is found at offset 28 and is 16 bytes long. */
6758 elf_tdata (abfd
)->core
->program
6759 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 28, 16);
6761 /* `pr_psargs' is found at offset 44 and is 80 bytes long. */
6762 elf_tdata (abfd
)->core
->command
6763 = _bfd_elfcore_strndup (abfd
, note
->descdata
+ 44, 80);
6766 /* Note that for some reason, a spurious space is tacked
6767 onto the end of the args in some (at least one anyway)
6768 implementations, so strip it off if it exists. */
6771 char *command
= elf_tdata (abfd
)->core
->command
;
6772 int n
= strlen (command
);
6774 if (0 < n
&& command
[n
- 1] == ' ')
6775 command
[n
- 1] = '\0';
6780 #define ELF_ARCH bfd_arch_frv
6781 #define ELF_MACHINE_CODE EM_CYGNUS_FRV
6782 #define ELF_MAXPAGESIZE 0x1000
6784 #define TARGET_BIG_SYM frv_elf32_vec
6785 #define TARGET_BIG_NAME "elf32-frv"
6787 #define elf_info_to_howto frv_info_to_howto_rela
6788 #define elf_backend_relocate_section elf32_frv_relocate_section
6789 #define elf_backend_gc_mark_hook elf32_frv_gc_mark_hook
6790 #define elf_backend_check_relocs elf32_frv_check_relocs
6791 #define elf_backend_object_p elf32_frv_object_p
6792 #define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook
6794 #define elf_backend_stack_align 8
6795 #define elf_backend_can_gc_sections 1
6796 #define elf_backend_rela_normal 1
6798 #define bfd_elf32_bfd_reloc_type_lookup frv_reloc_type_lookup
6799 #define bfd_elf32_bfd_reloc_name_lookup frv_reloc_name_lookup
6800 #define bfd_elf32_bfd_set_private_flags frv_elf_set_private_flags
6801 #define bfd_elf32_bfd_merge_private_bfd_data frv_elf_merge_private_bfd_data
6802 #define bfd_elf32_bfd_print_private_bfd_data frv_elf_print_private_bfd_data
6804 #define elf_backend_want_got_sym 1
6805 #define elf_backend_got_header_size 0
6806 #define elf_backend_want_got_plt 0
6807 #define elf_backend_plt_readonly 1
6808 #define elf_backend_want_plt_sym 0
6809 #define elf_backend_plt_header_size 0
6811 #define elf_backend_finish_dynamic_sections \
6812 elf32_frv_finish_dynamic_sections
6814 #define elf_backend_grok_prstatus elf32_frv_grok_prstatus
6815 #define elf_backend_grok_psinfo elf32_frv_grok_psinfo
6817 #define elf_backend_linux_prpsinfo32_ugid16 TRUE
6819 #include "elf32-target.h"
6821 #undef ELF_TARGET_ID
6822 #define ELF_TARGET_ID FRV_ELF_DATA
6823 #undef ELF_MAXPAGESIZE
6824 #define ELF_MAXPAGESIZE 0x4000
6826 #undef TARGET_BIG_SYM
6827 #define TARGET_BIG_SYM frv_elf32_fdpic_vec
6828 #undef TARGET_BIG_NAME
6829 #define TARGET_BIG_NAME "elf32-frvfdpic"
6831 #define elf32_bed elf32_frvfdpic_bed
6833 #undef elf_info_to_howto_rel
6834 #define elf_info_to_howto_rel frvfdpic_info_to_howto_rel
6836 #undef bfd_elf32_bfd_link_hash_table_create
6837 #define bfd_elf32_bfd_link_hash_table_create \
6838 frvfdpic_elf_link_hash_table_create
6839 #undef elf_backend_always_size_sections
6840 #define elf_backend_always_size_sections \
6841 elf32_frvfdpic_always_size_sections
6843 #undef elf_backend_create_dynamic_sections
6844 #define elf_backend_create_dynamic_sections \
6845 elf32_frvfdpic_create_dynamic_sections
6846 #undef elf_backend_adjust_dynamic_symbol
6847 #define elf_backend_adjust_dynamic_symbol \
6848 elf32_frvfdpic_adjust_dynamic_symbol
6849 #undef elf_backend_size_dynamic_sections
6850 #define elf_backend_size_dynamic_sections \
6851 elf32_frvfdpic_size_dynamic_sections
6852 #undef bfd_elf32_bfd_relax_section
6853 #define bfd_elf32_bfd_relax_section \
6854 elf32_frvfdpic_relax_section
6855 #undef elf_backend_finish_dynamic_symbol
6856 #define elf_backend_finish_dynamic_symbol \
6857 elf32_frvfdpic_finish_dynamic_symbol
6858 #undef elf_backend_finish_dynamic_sections
6859 #define elf_backend_finish_dynamic_sections \
6860 elf32_frvfdpic_finish_dynamic_sections
6862 #undef elf_backend_discard_info
6863 #define elf_backend_discard_info \
6864 frvfdpic_elf_discard_info
6865 #undef elf_backend_can_make_relative_eh_frame
6866 #define elf_backend_can_make_relative_eh_frame \
6867 frvfdpic_elf_use_relative_eh_frame
6868 #undef elf_backend_can_make_lsda_relative_eh_frame
6869 #define elf_backend_can_make_lsda_relative_eh_frame \
6870 frvfdpic_elf_use_relative_eh_frame
6871 #undef elf_backend_encode_eh_address
6872 #define elf_backend_encode_eh_address \
6873 frvfdpic_elf_encode_eh_address
6875 #undef elf_backend_may_use_rel_p
6876 #define elf_backend_may_use_rel_p 1
6877 #undef elf_backend_may_use_rela_p
6878 #define elf_backend_may_use_rela_p 1
6879 /* We use REL for dynamic relocations only. */
6880 #undef elf_backend_default_use_rela_p
6881 #define elf_backend_default_use_rela_p 1
6883 #undef elf_backend_omit_section_dynsym
6884 #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
6886 #include "elf32-target.h"