projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf32-spu.c (spu_elf_size_stubs): Always use an overlay stub
[deliverable/binutils-gdb.git] / bfd / elf32-frv.c
1 /* FRV-specific support for 32-bit ELF.
2 Copyright 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
20
21 #include "bfd.h"
22 #include "sysdep.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/frv.h"
26 #include "elf/dwarf2.h"
27 #include "hashtab.h"
28
29 /* Forward declarations. */
30 static bfd_reloc_status_type elf32_frv_relocate_lo16
31 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
32 static bfd_reloc_status_type elf32_frv_relocate_hi16
33 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
34 static bfd_reloc_status_type elf32_frv_relocate_label24
35 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
36 static bfd_reloc_status_type elf32_frv_relocate_gprel12
37 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
38 bfd_byte *, bfd_vma));
39 static bfd_reloc_status_type elf32_frv_relocate_gprelu12
40 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
41 bfd_byte *, bfd_vma));
42 static bfd_reloc_status_type elf32_frv_relocate_gprello
43 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
44 bfd_byte *, bfd_vma));
45 static bfd_reloc_status_type elf32_frv_relocate_gprelhi
46 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
47 bfd_byte *, bfd_vma));
48 static reloc_howto_type *frv_reloc_type_lookup
49 PARAMS ((bfd *, bfd_reloc_code_real_type));
50 static void frv_info_to_howto_rela
51 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
52 static bfd_boolean elf32_frv_relocate_section
53 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
54 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
55 static bfd_boolean elf32_frv_add_symbol_hook
56 PARAMS (( bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
57 const char **, flagword *, asection **, bfd_vma *));
58 static bfd_reloc_status_type frv_final_link_relocate
59 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
60 Elf_Internal_Rela *, bfd_vma));
61 static bfd_boolean elf32_frv_check_relocs
62 PARAMS ((bfd *, struct bfd_link_info *, asection *,
63 const Elf_Internal_Rela *));
64 static int elf32_frv_machine
65 PARAMS ((bfd *));
66 static bfd_boolean elf32_frv_object_p
67 PARAMS ((bfd *));
68 static bfd_boolean frv_elf_set_private_flags
69 PARAMS ((bfd *, flagword));
70 static bfd_boolean frv_elf_copy_private_bfd_data
71 PARAMS ((bfd *, bfd *));
72 static bfd_boolean frv_elf_merge_private_bfd_data
73 PARAMS ((bfd *, bfd *));
74 static bfd_boolean frv_elf_print_private_bfd_data
75 PARAMS ((bfd *, PTR));
76 static bfd_boolean elf32_frv_grok_prstatus (bfd * abfd,
77 Elf_Internal_Note * note);
78 static bfd_boolean elf32_frv_grok_psinfo (bfd * abfd,
79 Elf_Internal_Note * note);
80
81 static reloc_howto_type elf32_frv_howto_table [] =
82 {
83 /* This reloc does nothing. */
84 HOWTO (R_FRV_NONE, /* type */
85 0, /* rightshift */
86 2, /* size (0 = byte, 1 = short, 2 = long) */
87 32, /* bitsize */
88 FALSE, /* pc_relative */
89 0, /* bitpos */
90 complain_overflow_bitfield, /* complain_on_overflow */
91 bfd_elf_generic_reloc, /* special_function */
92 "R_FRV_NONE", /* name */
93 FALSE, /* partial_inplace */
94 0, /* src_mask */
95 0, /* dst_mask */
96 FALSE), /* pcrel_offset */
97
98 /* A 32 bit absolute relocation. */
99 HOWTO (R_FRV_32, /* type */
100 0, /* rightshift */
101 2, /* size (0 = byte, 1 = short, 2 = long) */
102 32, /* bitsize */
103 FALSE, /* pc_relative */
104 0, /* bitpos */
105 complain_overflow_bitfield, /* complain_on_overflow */
106 bfd_elf_generic_reloc, /* special_function */
107 "R_FRV_32", /* name */
108 FALSE, /* partial_inplace */
109 0xffffffff, /* src_mask */
110 0xffffffff, /* dst_mask */
111 FALSE), /* pcrel_offset */
112
113 /* A 16 bit pc-relative relocation. */
114 HOWTO (R_FRV_LABEL16, /* type */
115 2, /* rightshift */
116 2, /* size (0 = byte, 1 = short, 2 = long) */
117 16, /* bitsize */
118 TRUE, /* pc_relative */
119 0, /* bitpos */
120 complain_overflow_signed, /* complain_on_overflow */
121 bfd_elf_generic_reloc, /* special_function */
122 "R_FRV_LABEL16", /* name */
123 FALSE, /* partial_inplace */
124 0xffff, /* src_mask */
125 0xffff, /* dst_mask */
126 TRUE), /* pcrel_offset */
127
128 /* A 24-bit pc-relative relocation. */
129 HOWTO (R_FRV_LABEL24, /* type */
130 2, /* rightshift */
131 2, /* size (0 = byte, 1 = short, 2 = long) */
132 26, /* bitsize */
133 TRUE, /* pc_relative */
134 0, /* bitpos */
135 complain_overflow_bitfield, /* complain_on_overflow */
136 bfd_elf_generic_reloc, /* special_function */
137 "R_FRV_LABEL24", /* name */
138 FALSE, /* partial_inplace */
139 0x7e03ffff, /* src_mask */
140 0x7e03ffff, /* dst_mask */
141 TRUE), /* pcrel_offset */
142
143 HOWTO (R_FRV_LO16, /* type */
144 0, /* rightshift */
145 2, /* size (0 = byte, 1 = short, 2 = long) */
146 16, /* bitsize */
147 FALSE, /* pc_relative */
148 0, /* bitpos */
149 complain_overflow_dont, /* complain_on_overflow */
150 bfd_elf_generic_reloc, /* special_function */
151 "R_FRV_LO16", /* name */
152 FALSE, /* partial_inplace */
153 0xffff, /* src_mask */
154 0xffff, /* dst_mask */
155 FALSE), /* pcrel_offset */
156
157 HOWTO (R_FRV_HI16, /* type */
158 0, /* rightshift */
159 2, /* size (0 = byte, 1 = short, 2 = long) */
160 16, /* bitsize */
161 FALSE, /* pc_relative */
162 0, /* bitpos */
163 complain_overflow_dont, /* complain_on_overflow */
164 bfd_elf_generic_reloc, /* special_function */
165 "R_FRV_HI16", /* name */
166 FALSE, /* partial_inplace */
167 0xffff, /* src_mask */
168 0xffff, /* dst_mask */
169 FALSE), /* pcrel_offset */
170
171 HOWTO (R_FRV_GPREL12, /* type */
172 0, /* rightshift */
173 2, /* size (0 = byte, 1 = short, 2 = long) */
174 12, /* bitsize */
175 FALSE, /* pc_relative */
176 0, /* bitpos */
177 complain_overflow_dont, /* complain_on_overflow */
178 bfd_elf_generic_reloc, /* special_function */
179 "R_FRV_GPREL12", /* name */
180 FALSE, /* partial_inplace */
181 0xfff, /* src_mask */
182 0xfff, /* dst_mask */
183 FALSE), /* pcrel_offset */
184
185 HOWTO (R_FRV_GPRELU12, /* type */
186 0, /* rightshift */
187 2, /* size (0 = byte, 1 = short, 2 = long) */
188 12, /* bitsize */
189 FALSE, /* pc_relative */
190 0, /* bitpos */
191 complain_overflow_dont, /* complain_on_overflow */
192 bfd_elf_generic_reloc, /* special_function */
193 "R_FRV_GPRELU12", /* name */
194 FALSE, /* partial_inplace */
195 0xfff, /* src_mask */
196 0x3f03f, /* dst_mask */
197 FALSE), /* pcrel_offset */
198
199 HOWTO (R_FRV_GPREL32, /* type */
200 0, /* rightshift */
201 2, /* size (0 = byte, 1 = short, 2 = long) */
202 32, /* bitsize */
203 FALSE, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_dont, /* complain_on_overflow */
206 bfd_elf_generic_reloc, /* special_function */
207 "R_FRV_GPREL32", /* name */
208 FALSE, /* partial_inplace */
209 0xffffffff, /* src_mask */
210 0xffffffff, /* dst_mask */
211 FALSE), /* pcrel_offset */
212
213 HOWTO (R_FRV_GPRELHI, /* type */
214 0, /* rightshift */
215 2, /* size (0 = byte, 1 = short, 2 = long) */
216 16, /* bitsize */
217 FALSE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_dont, /* complain_on_overflow */
220 bfd_elf_generic_reloc, /* special_function */
221 "R_FRV_GPRELHI", /* name */
222 FALSE, /* partial_inplace */
223 0xffff, /* src_mask */
224 0xffff, /* dst_mask */
225 FALSE), /* pcrel_offset */
226
227 HOWTO (R_FRV_GPRELLO, /* type */
228 0, /* rightshift */
229 2, /* size (0 = byte, 1 = short, 2 = long) */
230 16, /* bitsize */
231 FALSE, /* pc_relative */
232 0, /* bitpos */
233 complain_overflow_dont, /* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_FRV_GPRELLO", /* name */
236 FALSE, /* partial_inplace */
237 0xffff, /* src_mask */
238 0xffff, /* dst_mask */
239 FALSE), /* pcrel_offset */
240
241 /* A 12-bit signed operand with the GOT offset for the address of
242 the symbol. */
243 HOWTO (R_FRV_GOT12, /* type */
244 0, /* rightshift */
245 2, /* size (0 = byte, 1 = short, 2 = long) */
246 12, /* bitsize */
247 FALSE, /* pc_relative */
248 0, /* bitpos */
249 complain_overflow_signed, /* complain_on_overflow */
250 bfd_elf_generic_reloc, /* special_function */
251 "R_FRV_GOT12", /* name */
252 FALSE, /* partial_inplace */
253 0xfff, /* src_mask */
254 0xfff, /* dst_mask */
255 FALSE), /* pcrel_offset */
256
257 /* The upper 16 bits of the GOT offset for the address of the
258 symbol. */
259 HOWTO (R_FRV_GOTHI, /* type */
260 0, /* rightshift */
261 2, /* size (0 = byte, 1 = short, 2 = long) */
262 16, /* bitsize */
263 FALSE, /* pc_relative */
264 0, /* bitpos */
265 complain_overflow_dont, /* complain_on_overflow */
266 bfd_elf_generic_reloc, /* special_function */
267 "R_FRV_GOTHI", /* name */
268 FALSE, /* partial_inplace */
269 0xffff, /* src_mask */
270 0xffff, /* dst_mask */
271 FALSE), /* pcrel_offset */
272
273 /* The lower 16 bits of the GOT offset for the address of the
274 symbol. */
275 HOWTO (R_FRV_GOTLO, /* type */
276 0, /* rightshift */
277 2, /* size (0 = byte, 1 = short, 2 = long) */
278 16, /* bitsize */
279 FALSE, /* pc_relative */
280 0, /* bitpos */
281 complain_overflow_dont, /* complain_on_overflow */
282 bfd_elf_generic_reloc, /* special_function */
283 "R_FRV_GOTLO", /* name */
284 FALSE, /* partial_inplace */
285 0xffff, /* src_mask */
286 0xffff, /* dst_mask */
287 FALSE), /* pcrel_offset */
288
289 /* The 32-bit address of the canonical descriptor of a function. */
290 HOWTO (R_FRV_FUNCDESC, /* type */
291 0, /* rightshift */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
293 32, /* bitsize */
294 FALSE, /* pc_relative */
295 0, /* bitpos */
296 complain_overflow_bitfield, /* complain_on_overflow */
297 bfd_elf_generic_reloc, /* special_function */
298 "R_FRV_FUNCDESC", /* name */
299 FALSE, /* partial_inplace */
300 0xffffffff, /* src_mask */
301 0xffffffff, /* dst_mask */
302 FALSE), /* pcrel_offset */
303
304 /* A 12-bit signed operand with the GOT offset for the address of
305 canonical descriptor of a function. */
306 HOWTO (R_FRV_FUNCDESC_GOT12, /* type */
307 0, /* rightshift */
308 2, /* size (0 = byte, 1 = short, 2 = long) */
309 12, /* bitsize */
310 FALSE, /* pc_relative */
311 0, /* bitpos */
312 complain_overflow_signed, /* complain_on_overflow */
313 bfd_elf_generic_reloc, /* special_function */
314 "R_FRV_FUNCDESC_GOT12", /* name */
315 FALSE, /* partial_inplace */
316 0xfff, /* src_mask */
317 0xfff, /* dst_mask */
318 FALSE), /* pcrel_offset */
319
320 /* The upper 16 bits of the GOT offset for the address of the
321 canonical descriptor of a function. */
322 HOWTO (R_FRV_FUNCDESC_GOTHI, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 16, /* bitsize */
326 FALSE, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_dont, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_FRV_FUNCDESC_GOTHI", /* name */
331 FALSE, /* partial_inplace */
332 0xffff, /* src_mask */
333 0xffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
335
336 /* The lower 16 bits of the GOT offset for the address of the
337 canonical descriptor of a function. */
338 HOWTO (R_FRV_FUNCDESC_GOTLO, /* type */
339 0, /* rightshift */
340 2, /* size (0 = byte, 1 = short, 2 = long) */
341 16, /* bitsize */
342 FALSE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_dont, /* complain_on_overflow */
345 bfd_elf_generic_reloc, /* special_function */
346 "R_FRV_FUNCDESC_GOTLO", /* name */
347 FALSE, /* partial_inplace */
348 0xffff, /* src_mask */
349 0xffff, /* dst_mask */
350 FALSE), /* pcrel_offset */
351
352 /* The 64-bit descriptor of a function. */
353 HOWTO (R_FRV_FUNCDESC_VALUE, /* type */
354 0, /* rightshift */
355 2, /* size (0 = byte, 1 = short, 2 = long) */
356 64, /* bitsize */
357 FALSE, /* pc_relative */
358 0, /* bitpos */
359 complain_overflow_bitfield, /* complain_on_overflow */
360 bfd_elf_generic_reloc, /* special_function */
361 "R_FRV_FUNCDESC_VALUE", /* name */
362 FALSE, /* partial_inplace */
363 0xffffffff, /* src_mask */
364 0xffffffff, /* dst_mask */
365 FALSE), /* pcrel_offset */
366
367 /* A 12-bit signed operand with the GOT offset for the address of
368 canonical descriptor of a function. */
369 HOWTO (R_FRV_FUNCDESC_GOTOFF12, /* type */
370 0, /* rightshift */
371 2, /* size (0 = byte, 1 = short, 2 = long) */
372 12, /* bitsize */
373 FALSE, /* pc_relative */
374 0, /* bitpos */
375 complain_overflow_signed, /* complain_on_overflow */
376 bfd_elf_generic_reloc, /* special_function */
377 "R_FRV_FUNCDESC_GOTOFF12", /* name */
378 FALSE, /* partial_inplace */
379 0xfff, /* src_mask */
380 0xfff, /* dst_mask */
381 FALSE), /* pcrel_offset */
382
383 /* The upper 16 bits of the GOT offset for the address of the
384 canonical descriptor of a function. */
385 HOWTO (R_FRV_FUNCDESC_GOTOFFHI, /* type */
386 0, /* rightshift */
387 2, /* size (0 = byte, 1 = short, 2 = long) */
388 16, /* bitsize */
389 FALSE, /* pc_relative */
390 0, /* bitpos */
391 complain_overflow_dont, /* complain_on_overflow */
392 bfd_elf_generic_reloc, /* special_function */
393 "R_FRV_FUNCDESC_GOTOFFHI", /* name */
394 FALSE, /* partial_inplace */
395 0xffff, /* src_mask */
396 0xffff, /* dst_mask */
397 FALSE), /* pcrel_offset */
398
399 /* The lower 16 bits of the GOT offset for the address of the
400 canonical descriptor of a function. */
401 HOWTO (R_FRV_FUNCDESC_GOTOFFLO, /* type */
402 0, /* rightshift */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
404 16, /* bitsize */
405 FALSE, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_dont, /* complain_on_overflow */
408 bfd_elf_generic_reloc, /* special_function */
409 "R_FRV_FUNCDESC_GOTOFFLO", /* name */
410 FALSE, /* partial_inplace */
411 0xffff, /* src_mask */
412 0xffff, /* dst_mask */
413 FALSE), /* pcrel_offset */
414
415 /* A 12-bit signed operand with the GOT offset for the address of
416 the symbol. */
417 HOWTO (R_FRV_GOTOFF12, /* type */
418 0, /* rightshift */
419 2, /* size (0 = byte, 1 = short, 2 = long) */
420 12, /* bitsize */
421 FALSE, /* pc_relative */
422 0, /* bitpos */
423 complain_overflow_signed, /* complain_on_overflow */
424 bfd_elf_generic_reloc, /* special_function */
425 "R_FRV_GOTOFF12", /* name */
426 FALSE, /* partial_inplace */
427 0xfff, /* src_mask */
428 0xfff, /* dst_mask */
429 FALSE), /* pcrel_offset */
430
431 /* The upper 16 bits of the GOT offset for the address of the
432 symbol. */
433 HOWTO (R_FRV_GOTOFFHI, /* type */
434 0, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 16, /* bitsize */
437 FALSE, /* pc_relative */
438 0, /* bitpos */
439 complain_overflow_dont, /* complain_on_overflow */
440 bfd_elf_generic_reloc, /* special_function */
441 "R_FRV_GOTOFFHI", /* name */
442 FALSE, /* partial_inplace */
443 0xffff, /* src_mask */
444 0xffff, /* dst_mask */
445 FALSE), /* pcrel_offset */
446
447 /* The lower 16 bits of the GOT offset for the address of the
448 symbol. */
449 HOWTO (R_FRV_GOTOFFLO, /* type */
450 0, /* rightshift */
451 2, /* size (0 = byte, 1 = short, 2 = long) */
452 16, /* bitsize */
453 FALSE, /* pc_relative */
454 0, /* bitpos */
455 complain_overflow_dont, /* complain_on_overflow */
456 bfd_elf_generic_reloc, /* special_function */
457 "R_FRV_GOTOFFLO", /* name */
458 FALSE, /* partial_inplace */
459 0xffff, /* src_mask */
460 0xffff, /* dst_mask */
461 FALSE), /* pcrel_offset */
462
463 /* A 24-bit pc-relative relocation referencing the TLS PLT entry for
464 a thread-local symbol. If the symbol number is 0, it refers to
465 the module. */
466 HOWTO (R_FRV_GETTLSOFF, /* type */
467 2, /* rightshift */
468 2, /* size (0 = byte, 1 = short, 2 = long) */
469 26, /* bitsize */
470 TRUE, /* pc_relative */
471 0, /* bitpos */
472 complain_overflow_bitfield, /* complain_on_overflow */
473 bfd_elf_generic_reloc, /* special_function */
474 "R_FRV_GETTLSOFF", /* name */
475 FALSE, /* partial_inplace */
476 0x7e03ffff, /* src_mask */
477 0x7e03ffff, /* dst_mask */
478 TRUE), /* pcrel_offset */
479
480 /* A 64-bit TLS descriptor for a symbol. This relocation is only
481 valid as a REL, dynamic relocation. */
482 HOWTO (R_FRV_TLSDESC_VALUE, /* type */
483 0, /* rightshift */
484 2, /* size (0 = byte, 1 = short, 2 = long) */
485 64, /* bitsize */
486 FALSE, /* pc_relative */
487 0, /* bitpos */
488 complain_overflow_bitfield, /* complain_on_overflow */
489 bfd_elf_generic_reloc, /* special_function */
490 "R_FRV_TLSDESC_VALUE", /* name */
491 FALSE, /* partial_inplace */
492 0xffffffff, /* src_mask */
493 0xffffffff, /* dst_mask */
494 FALSE), /* pcrel_offset */
495
496 /* A 12-bit signed operand with the GOT offset for the TLS
497 descriptor of the symbol. */
498 HOWTO (R_FRV_GOTTLSDESC12, /* type */
499 0, /* rightshift */
500 2, /* size (0 = byte, 1 = short, 2 = long) */
501 12, /* bitsize */
502 FALSE, /* pc_relative */
503 0, /* bitpos */
504 complain_overflow_signed, /* complain_on_overflow */
505 bfd_elf_generic_reloc, /* special_function */
506 "R_FRV_GOTTLSDESC12", /* name */
507 FALSE, /* partial_inplace */
508 0xfff, /* src_mask */
509 0xfff, /* dst_mask */
510 FALSE), /* pcrel_offset */
511
512 /* The upper 16 bits of the GOT offset for the TLS descriptor of the
513 symbol. */
514 HOWTO (R_FRV_GOTTLSDESCHI, /* type */
515 0, /* rightshift */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
517 16, /* bitsize */
518 FALSE, /* pc_relative */
519 0, /* bitpos */
520 complain_overflow_dont, /* complain_on_overflow */
521 bfd_elf_generic_reloc, /* special_function */
522 "R_FRV_GOTTLSDESCHI", /* name */
523 FALSE, /* partial_inplace */
524 0xffff, /* src_mask */
525 0xffff, /* dst_mask */
526 FALSE), /* pcrel_offset */
527
528 /* The lower 16 bits of the GOT offset for the TLS descriptor of the
529 symbol. */
530 HOWTO (R_FRV_GOTTLSDESCLO, /* type */
531 0, /* rightshift */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
533 16, /* bitsize */
534 FALSE, /* pc_relative */
535 0, /* bitpos */
536 complain_overflow_dont, /* complain_on_overflow */
537 bfd_elf_generic_reloc, /* special_function */
538 "R_FRV_GOTTLSDESCLO", /* name */
539 FALSE, /* partial_inplace */
540 0xffff, /* src_mask */
541 0xffff, /* dst_mask */
542 FALSE), /* pcrel_offset */
543
544 /* A 12-bit signed operand with the offset from the module base
545 address to the thread-local symbol address. */
546 HOWTO (R_FRV_TLSMOFF12, /* type */
547 0, /* rightshift */
548 2, /* size (0 = byte, 1 = short, 2 = long) */
549 12, /* bitsize */
550 FALSE, /* pc_relative */
551 0, /* bitpos */
552 complain_overflow_signed, /* complain_on_overflow */
553 bfd_elf_generic_reloc, /* special_function */
554 "R_FRV_TLSMOFF12", /* name */
555 FALSE, /* partial_inplace */
556 0xfff, /* src_mask */
557 0xfff, /* dst_mask */
558 FALSE), /* pcrel_offset */
559
560 /* The upper 16 bits of the offset from the module base address to
561 the thread-local symbol address. */
562 HOWTO (R_FRV_TLSMOFFHI, /* type */
563 0, /* rightshift */
564 2, /* size (0 = byte, 1 = short, 2 = long) */
565 16, /* bitsize */
566 FALSE, /* pc_relative */
567 0, /* bitpos */
568 complain_overflow_dont, /* complain_on_overflow */
569 bfd_elf_generic_reloc, /* special_function */
570 "R_FRV_TLSMOFFHI", /* name */
571 FALSE, /* partial_inplace */
572 0xffff, /* src_mask */
573 0xffff, /* dst_mask */
574 FALSE), /* pcrel_offset */
575
576 /* The lower 16 bits of the offset from the module base address to
577 the thread-local symbol address. */
578 HOWTO (R_FRV_TLSMOFFLO, /* type */
579 0, /* rightshift */
580 2, /* size (0 = byte, 1 = short, 2 = long) */
581 16, /* bitsize */
582 FALSE, /* pc_relative */
583 0, /* bitpos */
584 complain_overflow_dont, /* complain_on_overflow */
585 bfd_elf_generic_reloc, /* special_function */
586 "R_FRV_TLSMOFFLO", /* name */
587 FALSE, /* partial_inplace */
588 0xffff, /* src_mask */
589 0xffff, /* dst_mask */
590 FALSE), /* pcrel_offset */
591
592 /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
593 for a symbol. */
594 HOWTO (R_FRV_GOTTLSOFF12, /* type */
595 0, /* rightshift */
596 2, /* size (0 = byte, 1 = short, 2 = long) */
597 12, /* bitsize */
598 FALSE, /* pc_relative */
599 0, /* bitpos */
600 complain_overflow_signed, /* complain_on_overflow */
601 bfd_elf_generic_reloc, /* special_function */
602 "R_FRV_GOTTLSOFF12", /* name */
603 FALSE, /* partial_inplace */
604 0xfff, /* src_mask */
605 0xfff, /* dst_mask */
606 FALSE), /* pcrel_offset */
607
608 /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
609 symbol. */
610 HOWTO (R_FRV_GOTTLSOFFHI, /* type */
611 0, /* rightshift */
612 2, /* size (0 = byte, 1 = short, 2 = long) */
613 16, /* bitsize */
614 FALSE, /* pc_relative */
615 0, /* bitpos */
616 complain_overflow_dont, /* complain_on_overflow */
617 bfd_elf_generic_reloc, /* special_function */
618 "R_FRV_GOTTLSOFFHI", /* name */
619 FALSE, /* partial_inplace */
620 0xffff, /* src_mask */
621 0xffff, /* dst_mask */
622 FALSE), /* pcrel_offset */
623
624 /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
625 symbol. */
626 HOWTO (R_FRV_GOTTLSOFFLO, /* type */
627 0, /* rightshift */
628 2, /* size (0 = byte, 1 = short, 2 = long) */
629 16, /* bitsize */
630 FALSE, /* pc_relative */
631 0, /* bitpos */
632 complain_overflow_dont, /* complain_on_overflow */
633 bfd_elf_generic_reloc, /* special_function */
634 "R_FRV_GOTTLSOFFLO", /* name */
635 FALSE, /* partial_inplace */
636 0xffff, /* src_mask */
637 0xffff, /* dst_mask */
638 FALSE), /* pcrel_offset */
639
640 /* The 32-bit offset from the thread pointer (not the module base
641 address) to a thread-local symbol. */
642 HOWTO (R_FRV_TLSOFF, /* type */
643 0, /* rightshift */
644 2, /* size (0 = byte, 1 = short, 2 = long) */
645 32, /* bitsize */
646 FALSE, /* pc_relative */
647 0, /* bitpos */
648 complain_overflow_dont, /* complain_on_overflow */
649 bfd_elf_generic_reloc, /* special_function */
650 "R_FRV_TLSOFF", /* name */
651 FALSE, /* partial_inplace */
652 0xffffffff, /* src_mask */
653 0xffffffff, /* dst_mask */
654 FALSE), /* pcrel_offset */
655
656 /* An annotation for linker relaxation, that denotes the
657 symbol+addend whose TLS descriptor is referenced by the sum of
658 the two input registers of an ldd instruction. */
659 HOWTO (R_FRV_TLSDESC_RELAX, /* type */
660 0, /* rightshift */
661 2, /* size (0 = byte, 1 = short, 2 = long) */
662 0, /* bitsize */
663 FALSE, /* pc_relative */
664 0, /* bitpos */
665 complain_overflow_dont, /* complain_on_overflow */
666 bfd_elf_generic_reloc, /* special_function */
667 "R_FRV_TLSDESC_RELAX", /* name */
668 FALSE, /* partial_inplace */
669 0, /* src_mask */
670 0, /* dst_mask */
671 FALSE), /* pcrel_offset */
672
673 /* An annotation for linker relaxation, that denotes the
674 symbol+addend whose TLS resolver entry point is given by the sum
675 of the two register operands of an calll instruction. */
676 HOWTO (R_FRV_GETTLSOFF_RELAX, /* type */
677 0, /* rightshift */
678 2, /* size (0 = byte, 1 = short, 2 = long) */
679 0, /* bitsize */
680 FALSE, /* pc_relative */
681 0, /* bitpos */
682 complain_overflow_dont, /* complain_on_overflow */
683 bfd_elf_generic_reloc, /* special_function */
684 "R_FRV_GETTLSOFF_RELAX", /* name */
685 FALSE, /* partial_inplace */
686 0, /* src_mask */
687 0, /* dst_mask */
688 FALSE), /* pcrel_offset */
689
690 /* An annotation for linker relaxation, that denotes the
691 symbol+addend whose TLS offset GOT entry is given by the sum of
692 the two input registers of an ld instruction. */
693 HOWTO (R_FRV_TLSOFF_RELAX, /* type */
694 0, /* rightshift */
695 2, /* size (0 = byte, 1 = short, 2 = long) */
696 0, /* bitsize */
697 FALSE, /* pc_relative */
698 0, /* bitpos */
699 complain_overflow_bitfield, /* complain_on_overflow */
700 bfd_elf_generic_reloc, /* special_function */
701 "R_FRV_TLSOFF_RELAX", /* name */
702 FALSE, /* partial_inplace */
703 0, /* src_mask */
704 0, /* dst_mask */
705 FALSE), /* pcrel_offset */
706
707 /* A 32-bit offset from the module base address to
708 the thread-local symbol address. */
709 HOWTO (R_FRV_TLSMOFF, /* type */
710 0, /* rightshift */
711 2, /* size (0 = byte, 1 = short, 2 = long) */
712 32, /* bitsize */
713 FALSE, /* pc_relative */
714 0, /* bitpos */
715 complain_overflow_dont, /* complain_on_overflow */
716 bfd_elf_generic_reloc, /* special_function */
717 "R_FRV_TLSMOFF", /* name */
718 FALSE, /* partial_inplace */
719 0xffffffff, /* src_mask */
720 0xffffffff, /* dst_mask */
721 FALSE), /* pcrel_offset */
722 };
723
724 /* GNU extension to record C++ vtable hierarchy. */
725 static reloc_howto_type elf32_frv_vtinherit_howto =
726 HOWTO (R_FRV_GNU_VTINHERIT, /* type */
727 0, /* rightshift */
728 2, /* size (0 = byte, 1 = short, 2 = long) */
729 0, /* bitsize */
730 FALSE, /* pc_relative */
731 0, /* bitpos */
732 complain_overflow_dont, /* complain_on_overflow */
733 NULL, /* special_function */
734 "R_FRV_GNU_VTINHERIT", /* name */
735 FALSE, /* partial_inplace */
736 0, /* src_mask */
737 0, /* dst_mask */
738 FALSE); /* pcrel_offset */
739
740 /* GNU extension to record C++ vtable member usage. */
741 static reloc_howto_type elf32_frv_vtentry_howto =
742 HOWTO (R_FRV_GNU_VTENTRY, /* type */
743 0, /* rightshift */
744 2, /* size (0 = byte, 1 = short, 2 = long) */
745 0, /* bitsize */
746 FALSE, /* pc_relative */
747 0, /* bitpos */
748 complain_overflow_dont, /* complain_on_overflow */
749 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
750 "R_FRV_GNU_VTENTRY", /* name */
751 FALSE, /* partial_inplace */
752 0, /* src_mask */
753 0, /* dst_mask */
754 FALSE); /* pcrel_offset */
755
756 /* The following 3 relocations are REL. The only difference to the
757 entries in the table above are that partial_inplace is TRUE. */
758 static reloc_howto_type elf32_frv_rel_32_howto =
759 HOWTO (R_FRV_32, /* type */
760 0, /* rightshift */
761 2, /* size (0 = byte, 1 = short, 2 = long) */
762 32, /* bitsize */
763 FALSE, /* pc_relative */
764 0, /* bitpos */
765 complain_overflow_bitfield, /* complain_on_overflow */
766 bfd_elf_generic_reloc, /* special_function */
767 "R_FRV_32", /* name */
768 TRUE, /* partial_inplace */
769 0xffffffff, /* src_mask */
770 0xffffffff, /* dst_mask */
771 FALSE); /* pcrel_offset */
772
773 static reloc_howto_type elf32_frv_rel_funcdesc_howto =
774 HOWTO (R_FRV_FUNCDESC, /* type */
775 0, /* rightshift */
776 2, /* size (0 = byte, 1 = short, 2 = long) */
777 32, /* bitsize */
778 FALSE, /* pc_relative */
779 0, /* bitpos */
780 complain_overflow_bitfield, /* complain_on_overflow */
781 bfd_elf_generic_reloc, /* special_function */
782 "R_FRV_FUNCDESC", /* name */
783 TRUE, /* partial_inplace */
784 0xffffffff, /* src_mask */
785 0xffffffff, /* dst_mask */
786 FALSE); /* pcrel_offset */
787
788 static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
789 HOWTO (R_FRV_FUNCDESC_VALUE, /* type */
790 0, /* rightshift */
791 2, /* size (0 = byte, 1 = short, 2 = long) */
792 64, /* bitsize */
793 FALSE, /* pc_relative */
794 0, /* bitpos */
795 complain_overflow_bitfield, /* complain_on_overflow */
796 bfd_elf_generic_reloc, /* special_function */
797 "R_FRV_FUNCDESC_VALUE", /* name */
798 TRUE, /* partial_inplace */
799 0xffffffff, /* src_mask */
800 0xffffffff, /* dst_mask */
801 FALSE); /* pcrel_offset */
802
803 static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto =
804 /* A 64-bit TLS descriptor for a symbol. The first word resolves to
805 an entry point, and the second resolves to a special argument.
806 If the symbol turns out to be in static TLS, the entry point is a
807 return instruction, and the special argument is the TLS offset
808 for the symbol. If it's in dynamic TLS, the entry point is a TLS
809 offset resolver, and the special argument is a pointer to a data
810 structure allocated by the dynamic loader, containing the GOT
811 address for the offset resolver, the module id, the offset within
812 the module, and anything else the TLS offset resolver might need
813 to determine the TLS offset for the symbol in the running
814 thread. */
815 HOWTO (R_FRV_TLSDESC_VALUE, /* type */
816 0, /* rightshift */
817 2, /* size (0 = byte, 1 = short, 2 = long) */
818 64, /* bitsize */
819 FALSE, /* pc_relative */
820 0, /* bitpos */
821 complain_overflow_bitfield, /* complain_on_overflow */
822 bfd_elf_generic_reloc, /* special_function */
823 "R_FRV_TLSDESC_VALUE", /* name */
824 TRUE, /* partial_inplace */
825 0xffffffff, /* src_mask */
826 0xffffffff, /* dst_mask */
827 FALSE); /* pcrel_offset */
828
829 static reloc_howto_type elf32_frv_rel_tlsoff_howto =
830 /* The 32-bit offset from the thread pointer (not the module base
831 address) to a thread-local symbol. */
832 HOWTO (R_FRV_TLSOFF, /* type */
833 0, /* rightshift */
834 2, /* size (0 = byte, 1 = short, 2 = long) */
835 32, /* bitsize */
836 FALSE, /* pc_relative */
837 0, /* bitpos */
838 complain_overflow_bitfield, /* complain_on_overflow */
839 bfd_elf_generic_reloc, /* special_function */
840 "R_FRV_TLSOFF", /* name */
841 TRUE, /* partial_inplace */
842 0xffffffff, /* src_mask */
843 0xffffffff, /* dst_mask */
844 FALSE); /* pcrel_offset */
845
846
847 \f
848 extern const bfd_target bfd_elf32_frvfdpic_vec;
849 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_frvfdpic_vec)
850
851 /* An extension of the elf hash table data structure, containing some
852 additional FRV-specific data. */
853 struct frvfdpic_elf_link_hash_table
854 {
855 struct elf_link_hash_table elf;
856
857 /* A pointer to the .got section. */
858 asection *sgot;
859 /* A pointer to the .rel.got section. */
860 asection *sgotrel;
861 /* A pointer to the .rofixup section. */
862 asection *sgotfixup;
863 /* A pointer to the .plt section. */
864 asection *splt;
865 /* A pointer to the .rel.plt section. */
866 asection *spltrel;
867 /* GOT base offset. */
868 bfd_vma got0;
869 /* Location of the first non-lazy PLT entry, i.e., the number of
870 bytes taken by lazy PLT entries. If locally-bound TLS
871 descriptors require a ret instruction, it will be placed at this
872 offset. */
873 bfd_vma plt0;
874 /* A hash table holding information about which symbols were
875 referenced with which PIC-related relocations. */
876 struct htab *relocs_info;
877 /* Summary reloc information collected by
878 _frvfdpic_count_got_plt_entries. */
879 struct _frvfdpic_dynamic_got_info *g;
880 };
881
882 /* Get the FRV ELF linker hash table from a link_info structure. */
883
884 #define frvfdpic_hash_table(info) \
885 ((struct frvfdpic_elf_link_hash_table *) ((info)->hash))
886
887 #define frvfdpic_got_section(info) \
888 (frvfdpic_hash_table (info)->sgot)
889 #define frvfdpic_gotrel_section(info) \
890 (frvfdpic_hash_table (info)->sgotrel)
891 #define frvfdpic_gotfixup_section(info) \
892 (frvfdpic_hash_table (info)->sgotfixup)
893 #define frvfdpic_plt_section(info) \
894 (frvfdpic_hash_table (info)->splt)
895 #define frvfdpic_pltrel_section(info) \
896 (frvfdpic_hash_table (info)->spltrel)
897 #define frvfdpic_relocs_info(info) \
898 (frvfdpic_hash_table (info)->relocs_info)
899 #define frvfdpic_got_initial_offset(info) \
900 (frvfdpic_hash_table (info)->got0)
901 #define frvfdpic_plt_initial_offset(info) \
902 (frvfdpic_hash_table (info)->plt0)
903 #define frvfdpic_dynamic_got_plt_info(info) \
904 (frvfdpic_hash_table (info)->g)
905
906 /* Currently it's the same, but if some day we have a reason to change
907 it, we'd better be using a different macro.
908
909 FIXME: if there's any TLS PLT entry that uses local-exec or
910 initial-exec models, we could use the ret at the end of any of them
911 instead of adding one more. */
912 #define frvfdpic_plt_tls_ret_offset(info) \
913 (frvfdpic_plt_initial_offset (info))
914
915 /* The name of the dynamic interpreter. This is put in the .interp
916 section. */
917
918 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
919
920 #define DEFAULT_STACK_SIZE 0x20000
921
922 /* This structure is used to collect the number of entries present in
923 each addressable range of the got. */
924 struct _frvfdpic_dynamic_got_info
925 {
926 /* Several bits of information about the current link. */
927 struct bfd_link_info *info;
928 /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit
929 ranges. */
930 bfd_vma got12, gotlos, gothilo;
931 /* Total GOT size needed for function descriptor entries within the 12-,
932 16- or 32-bit ranges. */
933 bfd_vma fd12, fdlos, fdhilo;
934 /* Total GOT size needed by function descriptor entries referenced
935 in PLT entries, that would be profitable to place in offsets
936 close to the PIC register. */
937 bfd_vma fdplt;
938 /* Total PLT size needed by lazy PLT entries. */
939 bfd_vma lzplt;
940 /* Total GOT size needed for TLS descriptor entries within the 12-,
941 16- or 32-bit ranges. */
942 bfd_vma tlsd12, tlsdlos, tlsdhilo;
943 /* Total GOT size needed by TLS descriptors referenced in PLT
944 entries, that would be profitable to place in offers close to the
945 PIC register. */
946 bfd_vma tlsdplt;
947 /* Total PLT size needed by TLS lazy PLT entries. */
948 bfd_vma tlslzplt;
949 /* Number of relocations carried over from input object files. */
950 unsigned long relocs;
951 /* Number of fixups introduced by relocations in input object files. */
952 unsigned long fixups;
953 /* The number of fixups that reference the ret instruction added to
954 the PLT for locally-resolved TLS descriptors. */
955 unsigned long tls_ret_refs;
956 };
957
958 /* This structure is used to assign offsets to got entries, function
959 descriptors, plt entries and lazy plt entries. */
960
961 struct _frvfdpic_dynamic_got_plt_info
962 {
963 /* Summary information collected with _frvfdpic_count_got_plt_entries. */
964 struct _frvfdpic_dynamic_got_info g;
965
966 /* For each addressable range, we record a MAX (positive) and MIN
967 (negative) value. CUR is used to assign got entries, and it's
968 incremented from an initial positive value to MAX, then from MIN
969 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
970 assign function descriptors, and it's decreased from an initial
971 non-positive value to MIN, then from MAX down to CUR (unless CUR
972 wraps around first). All of MIN, MAX, CUR and FDCUR always point
973 to even words. ODD, if non-zero, indicates an odd word to be
974 used for the next got entry, otherwise CUR is used and
975 incremented by a pair of words, wrapping around when it reaches
976 MAX. FDCUR is decremented (and wrapped) before the next function
977 descriptor is chosen. FDPLT indicates the number of remaining
978 slots that can be used for function descriptors used only by PLT
979 entries.
980
981 TMAX, TMIN and TCUR are used to assign TLS descriptors. TCUR
982 starts as MAX, and grows up to TMAX, then wraps around to TMIN
983 and grows up to MIN. TLSDPLT indicates the number of remaining
984 slots that can be used for TLS descriptors used only by TLS PLT
985 entries. */
986 struct _frvfdpic_dynamic_got_alloc_data
987 {
988 bfd_signed_vma max, cur, odd, fdcur, min;
989 bfd_signed_vma tmax, tcur, tmin;
990 bfd_vma fdplt, tlsdplt;
991 } got12, gotlos, gothilo;
992 };
993
994 /* Create an FRV ELF linker hash table. */
995
996 static struct bfd_link_hash_table *
997 frvfdpic_elf_link_hash_table_create (bfd *abfd)
998 {
999 struct frvfdpic_elf_link_hash_table *ret;
1000 bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
1001
1002 ret = bfd_zalloc (abfd, amt);
1003 if (ret == NULL)
1004 return NULL;
1005
1006 if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1007 _bfd_elf_link_hash_newfunc,
1008 sizeof (struct elf_link_hash_entry)))
1009 {
1010 free (ret);
1011 return NULL;
1012 }
1013
1014 return &ret->elf.root;
1015 }
1016
1017 /* Decide whether a reference to a symbol can be resolved locally or
1018 not. If the symbol is protected, we want the local address, but
1019 its function descriptor must be assigned by the dynamic linker. */
1020 #define FRVFDPIC_SYM_LOCAL(INFO, H) \
1021 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1022 || ! elf_hash_table (INFO)->dynamic_sections_created)
1023 #define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
1024 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1025
1026 /* This structure collects information on what kind of GOT, PLT or
1027 function descriptors are required by relocations that reference a
1028 certain symbol. */
1029 struct frvfdpic_relocs_info
1030 {
1031 /* The index of the symbol, as stored in the relocation r_info, if
1032 we have a local symbol; -1 otherwise. */
1033 long symndx;
1034 union
1035 {
1036 /* The input bfd in which the symbol is defined, if it's a local
1037 symbol. */
1038 bfd *abfd;
1039 /* If symndx == -1, the hash table entry corresponding to a global
1040 symbol (even if it turns out to bind locally, in which case it
1041 should ideally be replaced with section's symndx + addend). */
1042 struct elf_link_hash_entry *h;
1043 } d;
1044 /* The addend of the relocation that references the symbol. */
1045 bfd_vma addend;
1046
1047 /* The fields above are used to identify an entry. The fields below
1048 contain information on how an entry is used and, later on, which
1049 locations it was assigned. */
1050 /* The following 3 fields record whether the symbol+addend above was
1051 ever referenced with a GOT relocation. The 12 suffix indicates a
1052 GOT12 relocation; los is used for GOTLO relocations that are not
1053 matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
1054 pairs. */
1055 unsigned got12:1;
1056 unsigned gotlos:1;
1057 unsigned gothilo:1;
1058 /* Whether a FUNCDESC relocation references symbol+addend. */
1059 unsigned fd:1;
1060 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
1061 unsigned fdgot12:1;
1062 unsigned fdgotlos:1;
1063 unsigned fdgothilo:1;
1064 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
1065 unsigned fdgoff12:1;
1066 unsigned fdgofflos:1;
1067 unsigned fdgoffhilo:1;
1068 /* Whether a GETTLSOFF relocation references symbol+addend. */
1069 unsigned tlsplt:1;
1070 /* FIXME: we should probably add tlspltdesc, tlspltoff and
1071 tlspltimm, to tell what kind of TLS PLT entry we're generating.
1072 We might instead just pre-compute flags telling whether the
1073 object is suitable for local exec, initial exec or general
1074 dynamic addressing, and use that all over the place. We could
1075 also try to do a better job of merging TLSOFF and TLSDESC entries
1076 in main executables, but perhaps we can get rid of TLSDESC
1077 entirely in them instead. */
1078 /* Whether a GOTTLSDESC relocation references symbol+addend. */
1079 unsigned tlsdesc12:1;
1080 unsigned tlsdesclos:1;
1081 unsigned tlsdeschilo:1;
1082 /* Whether a GOTTLSOFF relocation references symbol+addend. */
1083 unsigned tlsoff12:1;
1084 unsigned tlsofflos:1;
1085 unsigned tlsoffhilo:1;
1086 /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
1087 GOTOFFHI relocations. The addend doesn't really matter, since we
1088 envision that this will only be used to check whether the symbol
1089 is mapped to the same segment as the got. */
1090 unsigned gotoff:1;
1091 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
1092 unsigned call:1;
1093 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1094 relocation. */
1095 unsigned sym:1;
1096 /* Whether we need a PLT entry for a symbol. Should be implied by
1097 something like:
1098 (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)) */
1099 unsigned plt:1;
1100 /* Whether a function descriptor should be created in this link unit
1101 for symbol+addend. Should be implied by something like:
1102 (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
1103 || ((fd || fdgot12 || fdgotlos || fdgothilo)
1104 && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
1105 unsigned privfd:1;
1106 /* Whether a lazy PLT entry is needed for this symbol+addend.
1107 Should be implied by something like:
1108 (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
1109 && ! (info->flags & DF_BIND_NOW)) */
1110 unsigned lazyplt:1;
1111 /* Whether we've already emitted GOT relocations and PLT entries as
1112 needed for this symbol. */
1113 unsigned done:1;
1114
1115 /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and
1116 R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing
1117 symbol+addend. */
1118 unsigned relocs32, relocsfd, relocsfdv, relocstlsd, relocstlsoff;
1119
1120 /* The number of .rofixups entries and dynamic relocations allocated
1121 for this symbol, minus any that might have already been used. */
1122 unsigned fixups, dynrelocs;
1123
1124 /* The offsets of the GOT entries assigned to symbol+addend, to the
1125 function descriptor's address, and to a function descriptor,
1126 respectively. Should be zero if unassigned. The offsets are
1127 counted from the value that will be assigned to the PIC register,
1128 not from the beginning of the .got section. */
1129 bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1130 /* The offsets of the PLT entries assigned to symbol+addend,
1131 non-lazy and lazy, respectively. If unassigned, should be
1132 (bfd_vma)-1. */
1133 bfd_vma plt_entry, lzplt_entry;
1134 /* The offsets of the GOT entries for TLS offset and TLS descriptor. */
1135 bfd_signed_vma tlsoff_entry, tlsdesc_entry;
1136 /* The offset of the TLS offset PLT entry. */
1137 bfd_vma tlsplt_entry;
1138 };
1139
1140 /* Compute a hash with the key fields of an frvfdpic_relocs_info entry. */
1141 static hashval_t
1142 frvfdpic_relocs_info_hash (const void *entry_)
1143 {
1144 const struct frvfdpic_relocs_info *entry = entry_;
1145
1146 return (entry->symndx == -1
1147 ? (long) entry->d.h->root.root.hash
1148 : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1149 }
1150
1151 /* Test whether the key fields of two frvfdpic_relocs_info entries are
1152 identical. */
1153 static int
1154 frvfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1155 {
1156 const struct frvfdpic_relocs_info *e1 = entry1;
1157 const struct frvfdpic_relocs_info *e2 = entry2;
1158
1159 return e1->symndx == e2->symndx && e1->addend == e2->addend
1160 && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1161 }
1162
1163 /* Find or create an entry in a hash table HT that matches the key
1164 fields of the given ENTRY. If it's not found, memory for a new
1165 entry is allocated in ABFD's obstack. */
1166 static struct frvfdpic_relocs_info *
1167 frvfdpic_relocs_info_find (struct htab *ht,
1168 bfd *abfd,
1169 const struct frvfdpic_relocs_info *entry,
1170 enum insert_option insert)
1171 {
1172 struct frvfdpic_relocs_info **loc =
1173 (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1174
1175 if (! loc)
1176 return NULL;
1177
1178 if (*loc)
1179 return *loc;
1180
1181 *loc = bfd_zalloc (abfd, sizeof (**loc));
1182
1183 if (! *loc)
1184 return *loc;
1185
1186 (*loc)->symndx = entry->symndx;
1187 (*loc)->d = entry->d;
1188 (*loc)->addend = entry->addend;
1189 (*loc)->plt_entry = (bfd_vma)-1;
1190 (*loc)->lzplt_entry = (bfd_vma)-1;
1191 (*loc)->tlsplt_entry = (bfd_vma)-1;
1192
1193 return *loc;
1194 }
1195
1196 /* Obtain the address of the entry in HT associated with H's symbol +
1197 addend, creating a new entry if none existed. ABFD is only used
1198 for memory allocation purposes. */
1199 inline static struct frvfdpic_relocs_info *
1200 frvfdpic_relocs_info_for_global (struct htab *ht,
1201 bfd *abfd,
1202 struct elf_link_hash_entry *h,
1203 bfd_vma addend,
1204 enum insert_option insert)
1205 {
1206 struct frvfdpic_relocs_info entry;
1207
1208 entry.symndx = -1;
1209 entry.d.h = h;
1210 entry.addend = addend;
1211
1212 return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1213 }
1214
1215 /* Obtain the address of the entry in HT associated with the SYMNDXth
1216 local symbol of the input bfd ABFD, plus the addend, creating a new
1217 entry if none existed. */
1218 inline static struct frvfdpic_relocs_info *
1219 frvfdpic_relocs_info_for_local (struct htab *ht,
1220 bfd *abfd,
1221 long symndx,
1222 bfd_vma addend,
1223 enum insert_option insert)
1224 {
1225 struct frvfdpic_relocs_info entry;
1226
1227 entry.symndx = symndx;
1228 entry.d.abfd = abfd;
1229 entry.addend = addend;
1230
1231 return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1232 }
1233
1234 /* Merge fields set by check_relocs() of two entries that end up being
1235 mapped to the same (presumably global) symbol. */
1236
1237 inline static void
1238 frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2,
1239 struct frvfdpic_relocs_info const *e1)
1240 {
1241 e2->got12 |= e1->got12;
1242 e2->gotlos |= e1->gotlos;
1243 e2->gothilo |= e1->gothilo;
1244 e2->fd |= e1->fd;
1245 e2->fdgot12 |= e1->fdgot12;
1246 e2->fdgotlos |= e1->fdgotlos;
1247 e2->fdgothilo |= e1->fdgothilo;
1248 e2->fdgoff12 |= e1->fdgoff12;
1249 e2->fdgofflos |= e1->fdgofflos;
1250 e2->fdgoffhilo |= e1->fdgoffhilo;
1251 e2->tlsplt |= e1->tlsplt;
1252 e2->tlsdesc12 |= e1->tlsdesc12;
1253 e2->tlsdesclos |= e1->tlsdesclos;
1254 e2->tlsdeschilo |= e1->tlsdeschilo;
1255 e2->tlsoff12 |= e1->tlsoff12;
1256 e2->tlsofflos |= e1->tlsofflos;
1257 e2->tlsoffhilo |= e1->tlsoffhilo;
1258 e2->gotoff |= e1->gotoff;
1259 e2->call |= e1->call;
1260 e2->sym |= e1->sym;
1261 }
1262
1263 /* Every block of 65535 lazy PLT entries shares a single call to the
1264 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1265 32767, counting from 0). All other lazy PLT entries branch to it
1266 in a single instruction. */
1267
1268 #define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
1269 #define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
1270
1271 /* Add a dynamic relocation to the SRELOC section. */
1272
1273 inline static bfd_vma
1274 _frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
1275 int reloc_type, long dynindx, bfd_vma addend,
1276 struct frvfdpic_relocs_info *entry)
1277 {
1278 Elf_Internal_Rela outrel;
1279 bfd_vma reloc_offset;
1280
1281 outrel.r_offset = offset;
1282 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
1283 outrel.r_addend = addend;
1284
1285 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
1286 BFD_ASSERT (reloc_offset < sreloc->size);
1287 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1288 sreloc->contents + reloc_offset);
1289 sreloc->reloc_count++;
1290
1291 /* If the entry's index is zero, this relocation was probably to a
1292 linkonce section that got discarded. We reserved a dynamic
1293 relocation, but it was for another entry than the one we got at
1294 the time of emitting the relocation. Unfortunately there's no
1295 simple way for us to catch this situation, since the relocation
1296 is cleared right before calling relocate_section, at which point
1297 we no longer know what the relocation used to point to. */
1298 if (entry->symndx)
1299 {
1300 BFD_ASSERT (entry->dynrelocs > 0);
1301 entry->dynrelocs--;
1302 }
1303
1304 return reloc_offset;
1305 }
1306
1307 /* Add a fixup to the ROFIXUP section. */
1308
1309 static bfd_vma
1310 _frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
1311 struct frvfdpic_relocs_info *entry)
1312 {
1313 bfd_vma fixup_offset;
1314
1315 if (rofixup->flags & SEC_EXCLUDE)
1316 return -1;
1317
1318 fixup_offset = rofixup->reloc_count * 4;
1319 if (rofixup->contents)
1320 {
1321 BFD_ASSERT (fixup_offset < rofixup->size);
1322 bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
1323 }
1324 rofixup->reloc_count++;
1325
1326 if (entry && entry->symndx)
1327 {
1328 /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
1329 above. */
1330 BFD_ASSERT (entry->fixups > 0);
1331 entry->fixups--;
1332 }
1333
1334 return fixup_offset;
1335 }
1336
1337 /* Find the segment number in which OSEC, and output section, is
1338 located. */
1339
1340 static unsigned
1341 _frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
1342 {
1343 struct elf_segment_map *m;
1344 Elf_Internal_Phdr *p;
1345
1346 /* Find the segment that contains the output_section. */
1347 for (m = elf_tdata (output_bfd)->segment_map,
1348 p = elf_tdata (output_bfd)->phdr;
1349 m != NULL;
1350 m = m->next, p++)
1351 {
1352 int i;
1353
1354 for (i = m->count - 1; i >= 0; i--)
1355 if (m->sections[i] == osec)
1356 break;
1357
1358 if (i >= 0)
1359 break;
1360 }
1361
1362 return p - elf_tdata (output_bfd)->phdr;
1363 }
1364
1365 inline static bfd_boolean
1366 _frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
1367 {
1368 unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec);
1369
1370 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
1371 }
1372
1373 #define FRVFDPIC_TLS_BIAS (2048 - 16)
1374
1375 /* Return the base VMA address which should be subtracted from real addresses
1376 when resolving TLSMOFF relocation.
1377 This is PT_TLS segment p_vaddr, plus the 2048-16 bias. */
1378
1379 static bfd_vma
1380 tls_biased_base (struct bfd_link_info *info)
1381 {
1382 /* If tls_sec is NULL, we should have signalled an error already. */
1383 if (elf_hash_table (info)->tls_sec == NULL)
1384 return FRVFDPIC_TLS_BIAS;
1385 return elf_hash_table (info)->tls_sec->vma + FRVFDPIC_TLS_BIAS;
1386 }
1387
1388 /* Generate relocations for GOT entries, function descriptors, and
1389 code for PLT and lazy PLT entries. */
1390
1391 inline static bfd_boolean
1392 _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
1393 bfd *output_bfd,
1394 struct bfd_link_info *info,
1395 asection *sec,
1396 Elf_Internal_Sym *sym,
1397 bfd_vma addend)
1398
1399 {
1400 bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
1401 int dynindx = -1;
1402
1403 if (entry->done)
1404 return TRUE;
1405 entry->done = 1;
1406
1407 if (entry->got_entry || entry->fdgot_entry || entry->fd_entry
1408 || entry->tlsoff_entry || entry->tlsdesc_entry)
1409 {
1410 /* If the symbol is dynamic, consider it for dynamic
1411 relocations, otherwise decay to section + offset. */
1412 if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1413 dynindx = entry->d.h->dynindx;
1414 else
1415 {
1416 if (sec->output_section
1417 && ! bfd_is_abs_section (sec->output_section)
1418 && ! bfd_is_und_section (sec->output_section))
1419 dynindx = elf_section_data (sec->output_section)->dynindx;
1420 else
1421 dynindx = 0;
1422 }
1423 }
1424
1425 /* Generate relocation for GOT entry pointing to the symbol. */
1426 if (entry->got_entry)
1427 {
1428 int idx = dynindx;
1429 bfd_vma ad = addend;
1430
1431 /* If the symbol is dynamic but binds locally, use
1432 section+offset. */
1433 if (sec && (entry->symndx != -1
1434 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1435 {
1436 if (entry->symndx == -1)
1437 ad += entry->d.h->root.u.def.value;
1438 else
1439 ad += sym->st_value;
1440 ad += sec->output_offset;
1441 if (sec->output_section && elf_section_data (sec->output_section))
1442 idx = elf_section_data (sec->output_section)->dynindx;
1443 else
1444 idx = 0;
1445 }
1446
1447 /* If we're linking an executable at a fixed address, we can
1448 omit the dynamic relocation as long as the symbol is local to
1449 this module. */
1450 if (info->executable && !info->pie
1451 && (entry->symndx != -1
1452 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1453 {
1454 if (sec)
1455 ad += sec->output_section->vma;
1456 if (entry->symndx != -1
1457 || entry->d.h->root.type != bfd_link_hash_undefweak)
1458 _frvfdpic_add_rofixup (output_bfd,
1459 frvfdpic_gotfixup_section (info),
1460 frvfdpic_got_section (info)->output_section
1461 ->vma
1462 + frvfdpic_got_section (info)->output_offset
1463 + frvfdpic_got_initial_offset (info)
1464 + entry->got_entry, entry);
1465 }
1466 else
1467 _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1468 _bfd_elf_section_offset
1469 (output_bfd, info,
1470 frvfdpic_got_section (info),
1471 frvfdpic_got_initial_offset (info)
1472 + entry->got_entry)
1473 + frvfdpic_got_section (info)
1474 ->output_section->vma
1475 + frvfdpic_got_section (info)->output_offset,
1476 R_FRV_32, idx, ad, entry);
1477
1478 bfd_put_32 (output_bfd, ad,
1479 frvfdpic_got_section (info)->contents
1480 + frvfdpic_got_initial_offset (info)
1481 + entry->got_entry);
1482 }
1483
1484 /* Generate relocation for GOT entry pointing to a canonical
1485 function descriptor. */
1486 if (entry->fdgot_entry)
1487 {
1488 int reloc, idx;
1489 bfd_vma ad = 0;
1490
1491 if (! (entry->symndx == -1
1492 && entry->d.h->root.type == bfd_link_hash_undefweak
1493 && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1494 {
1495 /* If the symbol is dynamic and there may be dynamic symbol
1496 resolution because we are, or are linked with, a shared
1497 library, emit a FUNCDESC relocation such that the dynamic
1498 linker will allocate the function descriptor. If the
1499 symbol needs a non-local function descriptor but binds
1500 locally (e.g., its visibility is protected, emit a
1501 dynamic relocation decayed to section+offset. */
1502 if (entry->symndx == -1
1503 && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1504 && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
1505 && !(info->executable && !info->pie))
1506 {
1507 reloc = R_FRV_FUNCDESC;
1508 idx = elf_section_data (entry->d.h->root.u.def.section
1509 ->output_section)->dynindx;
1510 ad = entry->d.h->root.u.def.section->output_offset
1511 + entry->d.h->root.u.def.value;
1512 }
1513 else if (entry->symndx == -1
1514 && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1515 {
1516 reloc = R_FRV_FUNCDESC;
1517 idx = dynindx;
1518 ad = addend;
1519 if (ad)
1520 {
1521 (*info->callbacks->reloc_dangerous)
1522 (info, _("relocation requires zero addend"),
1523 elf_hash_table (info)->dynobj,
1524 frvfdpic_got_section (info),
1525 entry->fdgot_entry);
1526 return FALSE;
1527 }
1528 }
1529 else
1530 {
1531 /* Otherwise, we know we have a private function descriptor,
1532 so reference it directly. */
1533 if (elf_hash_table (info)->dynamic_sections_created)
1534 BFD_ASSERT (entry->privfd);
1535 reloc = R_FRV_32;
1536 idx = elf_section_data (frvfdpic_got_section (info)
1537 ->output_section)->dynindx;
1538 ad = frvfdpic_got_section (info)->output_offset
1539 + frvfdpic_got_initial_offset (info) + entry->fd_entry;
1540 }
1541
1542 /* If there is room for dynamic symbol resolution, emit the
1543 dynamic relocation. However, if we're linking an
1544 executable at a fixed location, we won't have emitted a
1545 dynamic symbol entry for the got section, so idx will be
1546 zero, which means we can and should compute the address
1547 of the private descriptor ourselves. */
1548 if (info->executable && !info->pie
1549 && (entry->symndx != -1
1550 || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1551 {
1552 ad += frvfdpic_got_section (info)->output_section->vma;
1553 _frvfdpic_add_rofixup (output_bfd,
1554 frvfdpic_gotfixup_section (info),
1555 frvfdpic_got_section (info)
1556 ->output_section->vma
1557 + frvfdpic_got_section (info)
1558 ->output_offset
1559 + frvfdpic_got_initial_offset (info)
1560 + entry->fdgot_entry, entry);
1561 }
1562 else
1563 _frvfdpic_add_dyn_reloc (output_bfd,
1564 frvfdpic_gotrel_section (info),
1565 _bfd_elf_section_offset
1566 (output_bfd, info,
1567 frvfdpic_got_section (info),
1568 frvfdpic_got_initial_offset (info)
1569 + entry->fdgot_entry)
1570 + frvfdpic_got_section (info)
1571 ->output_section->vma
1572 + frvfdpic_got_section (info)
1573 ->output_offset,
1574 reloc, idx, ad, entry);
1575 }
1576
1577 bfd_put_32 (output_bfd, ad,
1578 frvfdpic_got_section (info)->contents
1579 + frvfdpic_got_initial_offset (info)
1580 + entry->fdgot_entry);
1581 }
1582
1583 /* Generate relocation to fill in a private function descriptor in
1584 the GOT. */
1585 if (entry->fd_entry)
1586 {
1587 int idx = dynindx;
1588 bfd_vma ad = addend;
1589 bfd_vma ofst;
1590 long lowword, highword;
1591
1592 /* If the symbol is dynamic but binds locally, use
1593 section+offset. */
1594 if (sec && (entry->symndx != -1
1595 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1596 {
1597 if (entry->symndx == -1)
1598 ad += entry->d.h->root.u.def.value;
1599 else
1600 ad += sym->st_value;
1601 ad += sec->output_offset;
1602 if (sec->output_section && elf_section_data (sec->output_section))
1603 idx = elf_section_data (sec->output_section)->dynindx;
1604 else
1605 idx = 0;
1606 }
1607
1608 /* If we're linking an executable at a fixed address, we can
1609 omit the dynamic relocation as long as the symbol is local to
1610 this module. */
1611 if (info->executable && !info->pie
1612 && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1613 {
1614 if (sec)
1615 ad += sec->output_section->vma;
1616 ofst = 0;
1617 if (entry->symndx != -1
1618 || entry->d.h->root.type != bfd_link_hash_undefweak)
1619 {
1620 _frvfdpic_add_rofixup (output_bfd,
1621 frvfdpic_gotfixup_section (info),
1622 frvfdpic_got_section (info)
1623 ->output_section->vma
1624 + frvfdpic_got_section (info)
1625 ->output_offset
1626 + frvfdpic_got_initial_offset (info)
1627 + entry->fd_entry, entry);
1628 _frvfdpic_add_rofixup (output_bfd,
1629 frvfdpic_gotfixup_section (info),
1630 frvfdpic_got_section (info)
1631 ->output_section->vma
1632 + frvfdpic_got_section (info)
1633 ->output_offset
1634 + frvfdpic_got_initial_offset (info)
1635 + entry->fd_entry + 4, entry);
1636 }
1637 }
1638 else
1639 {
1640 ofst =
1641 _frvfdpic_add_dyn_reloc (output_bfd,
1642 entry->lazyplt
1643 ? frvfdpic_pltrel_section (info)
1644 : frvfdpic_gotrel_section (info),
1645 _bfd_elf_section_offset
1646 (output_bfd, info,
1647 frvfdpic_got_section (info),
1648 frvfdpic_got_initial_offset (info)
1649 + entry->fd_entry)
1650 + frvfdpic_got_section (info)
1651 ->output_section->vma
1652 + frvfdpic_got_section (info)
1653 ->output_offset,
1654 R_FRV_FUNCDESC_VALUE, idx, ad, entry);
1655 }
1656
1657 /* If we've omitted the dynamic relocation, just emit the fixed
1658 addresses of the symbol and of the local GOT base offset. */
1659 if (info->executable && !info->pie && sec && sec->output_section)
1660 {
1661 lowword = ad;
1662 highword = frvfdpic_got_section (info)->output_section->vma
1663 + frvfdpic_got_section (info)->output_offset
1664 + frvfdpic_got_initial_offset (info);
1665 }
1666 else if (entry->lazyplt)
1667 {
1668 if (ad)
1669 {
1670 (*info->callbacks->reloc_dangerous)
1671 (info, _("relocation requires zero addend"),
1672 elf_hash_table (info)->dynobj,
1673 frvfdpic_got_section (info),
1674 entry->fd_entry);
1675 return FALSE;
1676 }
1677
1678 fd_lazy_rel_offset = ofst;
1679
1680 /* A function descriptor used for lazy or local resolving is
1681 initialized such that its high word contains the output
1682 section index in which the PLT entries are located, and
1683 the low word contains the address of the lazy PLT entry
1684 entry point, that must be within the memory region
1685 assigned to that section. */
1686 lowword = entry->lzplt_entry + 4
1687 + frvfdpic_plt_section (info)->output_offset
1688 + frvfdpic_plt_section (info)->output_section->vma;
1689 highword = _frvfdpic_osec_to_segment
1690 (output_bfd, frvfdpic_plt_section (info)->output_section);
1691 }
1692 else
1693 {
1694 /* A function descriptor for a local function gets the index
1695 of the section. For a non-local function, it's
1696 disregarded. */
1697 lowword = ad;
1698 if (entry->symndx == -1 && entry->d.h->dynindx != -1
1699 && entry->d.h->dynindx == idx)
1700 highword = 0;
1701 else
1702 highword = _frvfdpic_osec_to_segment
1703 (output_bfd, sec->output_section);
1704 }
1705
1706 bfd_put_32 (output_bfd, lowword,
1707 frvfdpic_got_section (info)->contents
1708 + frvfdpic_got_initial_offset (info)
1709 + entry->fd_entry);
1710 bfd_put_32 (output_bfd, highword,
1711 frvfdpic_got_section (info)->contents
1712 + frvfdpic_got_initial_offset (info)
1713 + entry->fd_entry + 4);
1714 }
1715
1716 /* Generate code for the PLT entry. */
1717 if (entry->plt_entry != (bfd_vma) -1)
1718 {
1719 bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1720 + entry->plt_entry;
1721
1722 BFD_ASSERT (entry->fd_entry);
1723
1724 /* Figure out what kind of PLT entry we need, depending on the
1725 location of the function descriptor within the GOT. */
1726 if (entry->fd_entry >= -(1 << (12 - 1))
1727 && entry->fd_entry < (1 << (12 - 1)))
1728 {
1729 /* lddi @(gr15, fd_entry), gr14 */
1730 bfd_put_32 (output_bfd,
1731 0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1732 plt_code);
1733 plt_code += 4;
1734 }
1735 else
1736 {
1737 if (entry->fd_entry >= -(1 << (16 - 1))
1738 && entry->fd_entry < (1 << (16 - 1)))
1739 {
1740 /* setlos lo(fd_entry), gr14 */
1741 bfd_put_32 (output_bfd,
1742 0x9cfc0000
1743 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1744 plt_code);
1745 plt_code += 4;
1746 }
1747 else
1748 {
1749 /* sethi.p hi(fd_entry), gr14
1750 setlo lo(fd_entry), gr14 */
1751 bfd_put_32 (output_bfd,
1752 0x1cf80000
1753 | ((entry->fd_entry >> 16)
1754 & (((bfd_vma)1 << 16) - 1)),
1755 plt_code);
1756 plt_code += 4;
1757 bfd_put_32 (output_bfd,
1758 0x9cf40000
1759 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1760 plt_code);
1761 plt_code += 4;
1762 }
1763 /* ldd @(gr14,gr15),gr14 */
1764 bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
1765 plt_code += 4;
1766 }
1767 /* jmpl @(gr14,gr0) */
1768 bfd_put_32 (output_bfd, 0x8030e000, plt_code);
1769 }
1770
1771 /* Generate code for the lazy PLT entry. */
1772 if (entry->lzplt_entry != (bfd_vma) -1)
1773 {
1774 bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents
1775 + entry->lzplt_entry;
1776 bfd_vma resolverStub_addr;
1777
1778 bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1779 lzplt_code += 4;
1780
1781 resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
1782 * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC;
1783 if (resolverStub_addr >= frvfdpic_plt_initial_offset (info))
1784 resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12;
1785
1786 if (entry->lzplt_entry == resolverStub_addr)
1787 {
1788 /* This is a lazy PLT entry that includes a resolver call. */
1789 /* ldd @(gr15,gr0), gr4
1790 jmpl @(gr4,gr0) */
1791 bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
1792 bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
1793 }
1794 else
1795 {
1796 /* bra resolverStub */
1797 bfd_put_32 (output_bfd,
1798 0xc01a0000
1799 | (((resolverStub_addr - entry->lzplt_entry)
1800 / 4) & (((bfd_vma)1 << 16) - 1)),
1801 lzplt_code);
1802 }
1803 }
1804
1805 /* Generate relocation for GOT entry holding the TLS offset. */
1806 if (entry->tlsoff_entry)
1807 {
1808 int idx = dynindx;
1809 bfd_vma ad = addend;
1810
1811 if (entry->symndx != -1
1812 || FRVFDPIC_SYM_LOCAL (info, entry->d.h))
1813 {
1814 /* If the symbol is dynamic but binds locally, use
1815 section+offset. */
1816 if (sec)
1817 {
1818 if (entry->symndx == -1)
1819 ad += entry->d.h->root.u.def.value;
1820 else
1821 ad += sym->st_value;
1822 ad += sec->output_offset;
1823 if (sec->output_section
1824 && elf_section_data (sec->output_section))
1825 idx = elf_section_data (sec->output_section)->dynindx;
1826 else
1827 idx = 0;
1828 }
1829 }
1830
1831 /* *ABS*+addend is special for TLS relocations, use only the
1832 addend. */
1833 if (info->executable
1834 && idx == 0
1835 && (bfd_is_abs_section (sec)
1836 || bfd_is_und_section (sec)))
1837 ;
1838 /* If we're linking an executable, we can entirely omit the
1839 dynamic relocation if the symbol is local to this module. */
1840 else if (info->executable
1841 && (entry->symndx != -1
1842 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1843 {
1844 if (sec)
1845 ad += sec->output_section->vma - tls_biased_base (info);
1846 }
1847 else
1848 {
1849 if (idx == 0
1850 && (bfd_is_abs_section (sec)
1851 || bfd_is_und_section (sec)))
1852 {
1853 if (! elf_hash_table (info)->tls_sec)
1854 {
1855 (*info->callbacks->undefined_symbol)
1856 (info, "TLS section", elf_hash_table (info)->dynobj,
1857 frvfdpic_got_section (info), entry->tlsoff_entry, TRUE);
1858 return FALSE;
1859 }
1860 idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1861 ad += FRVFDPIC_TLS_BIAS;
1862 }
1863 _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1864 _bfd_elf_section_offset
1865 (output_bfd, info,
1866 frvfdpic_got_section (info),
1867 frvfdpic_got_initial_offset (info)
1868 + entry->tlsoff_entry)
1869 + frvfdpic_got_section (info)
1870 ->output_section->vma
1871 + frvfdpic_got_section (info)
1872 ->output_offset,
1873 R_FRV_TLSOFF, idx, ad, entry);
1874 }
1875
1876 bfd_put_32 (output_bfd, ad,
1877 frvfdpic_got_section (info)->contents
1878 + frvfdpic_got_initial_offset (info)
1879 + entry->tlsoff_entry);
1880 }
1881
1882 if (entry->tlsdesc_entry)
1883 {
1884 int idx = dynindx;
1885 bfd_vma ad = addend;
1886
1887 /* If the symbol is dynamic but binds locally, use
1888 section+offset. */
1889 if (sec && (entry->symndx != -1
1890 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1891 {
1892 if (entry->symndx == -1)
1893 ad += entry->d.h->root.u.def.value;
1894 else
1895 ad += sym->st_value;
1896 ad += sec->output_offset;
1897 if (sec->output_section && elf_section_data (sec->output_section))
1898 idx = elf_section_data (sec->output_section)->dynindx;
1899 else
1900 idx = 0;
1901 }
1902
1903 /* If we didn't set up a TLS offset entry, but we're linking an
1904 executable and the symbol binds locally, we can use the
1905 module offset in the TLS descriptor in relaxations. */
1906 if (info->executable && ! entry->tlsoff_entry)
1907 entry->tlsoff_entry = entry->tlsdesc_entry + 4;
1908
1909 if (info->executable && !info->pie
1910 && ((idx == 0
1911 && (bfd_is_abs_section (sec)
1912 || bfd_is_und_section (sec)))
1913 || entry->symndx != -1
1914 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1915 {
1916 /* *ABS*+addend is special for TLS relocations, use only the
1917 addend for the TLS offset, and take the module id as
1918 0. */
1919 if (idx == 0
1920 && (bfd_is_abs_section (sec)
1921 || bfd_is_und_section (sec)))
1922 ;
1923 /* For other TLS symbols that bind locally, add the section
1924 TLS offset to the addend. */
1925 else if (sec)
1926 ad += sec->output_section->vma - tls_biased_base (info);
1927
1928 bfd_put_32 (output_bfd,
1929 frvfdpic_plt_section (info)->output_section->vma
1930 + frvfdpic_plt_section (info)->output_offset
1931 + frvfdpic_plt_tls_ret_offset (info),
1932 frvfdpic_got_section (info)->contents
1933 + frvfdpic_got_initial_offset (info)
1934 + entry->tlsdesc_entry);
1935
1936 _frvfdpic_add_rofixup (output_bfd,
1937 frvfdpic_gotfixup_section (info),
1938 frvfdpic_got_section (info)
1939 ->output_section->vma
1940 + frvfdpic_got_section (info)
1941 ->output_offset
1942 + frvfdpic_got_initial_offset (info)
1943 + entry->tlsdesc_entry, entry);
1944
1945 BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs);
1946
1947 /* We've used one of the reserved fixups, so discount it so
1948 that we can check at the end that we've used them
1949 all. */
1950 frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs--;
1951
1952 /* While at that, make sure the ret instruction makes to the
1953 right location in the PLT. We could do it only when we
1954 got to 0, but since the check at the end will only print
1955 a warning, make sure we have the ret in place in case the
1956 warning is missed. */
1957 bfd_put_32 (output_bfd, 0xc03a4000,
1958 frvfdpic_plt_section (info)->contents
1959 + frvfdpic_plt_tls_ret_offset (info));
1960 }
1961 else
1962 {
1963 if (idx == 0
1964 && (bfd_is_abs_section (sec)
1965 || bfd_is_und_section (sec)))
1966 {
1967 if (! elf_hash_table (info)->tls_sec)
1968 {
1969 (*info->callbacks->undefined_symbol)
1970 (info, "TLS section", elf_hash_table (info)->dynobj,
1971 frvfdpic_got_section (info), entry->tlsdesc_entry, TRUE);
1972 return FALSE;
1973 }
1974 idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1975 ad += FRVFDPIC_TLS_BIAS;
1976 }
1977
1978 _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1979 _bfd_elf_section_offset
1980 (output_bfd, info,
1981 frvfdpic_got_section (info),
1982 frvfdpic_got_initial_offset (info)
1983 + entry->tlsdesc_entry)
1984 + frvfdpic_got_section (info)
1985 ->output_section->vma
1986 + frvfdpic_got_section (info)
1987 ->output_offset,
1988 R_FRV_TLSDESC_VALUE, idx, ad, entry);
1989
1990 bfd_put_32 (output_bfd, 0,
1991 frvfdpic_got_section (info)->contents
1992 + frvfdpic_got_initial_offset (info)
1993 + entry->tlsdesc_entry);
1994 }
1995
1996 bfd_put_32 (output_bfd, ad,
1997 frvfdpic_got_section (info)->contents
1998 + frvfdpic_got_initial_offset (info)
1999 + entry->tlsdesc_entry + 4);
2000 }
2001
2002 /* Generate code for the get-TLS-offset PLT entry. */
2003 if (entry->tlsplt_entry != (bfd_vma) -1)
2004 {
2005 bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
2006 + entry->tlsplt_entry;
2007
2008 if (info->executable
2009 && (entry->symndx != -1
2010 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
2011 {
2012 int idx = dynindx;
2013 bfd_vma ad = addend;
2014
2015 /* sec may be NULL when referencing an undefweak symbol
2016 while linking a static executable. */
2017 if (!sec)
2018 {
2019 BFD_ASSERT (entry->symndx == -1
2020 && entry->d.h->root.type == bfd_link_hash_undefweak);
2021 }
2022 else
2023 {
2024 if (entry->symndx == -1)
2025 ad += entry->d.h->root.u.def.value;
2026 else
2027 ad += sym->st_value;
2028 ad += sec->output_offset;
2029 if (sec->output_section
2030 && elf_section_data (sec->output_section))
2031 idx = elf_section_data (sec->output_section)->dynindx;
2032 else
2033 idx = 0;
2034 }
2035
2036 /* *ABS*+addend is special for TLS relocations, use only the
2037 addend for the TLS offset, and take the module id as
2038 0. */
2039 if (idx == 0
2040 && (bfd_is_abs_section (sec)
2041 || bfd_is_und_section (sec)))
2042 ;
2043 /* For other TLS symbols that bind locally, add the section
2044 TLS offset to the addend. */
2045 else if (sec)
2046 ad += sec->output_section->vma - tls_biased_base (info);
2047
2048 if ((bfd_signed_vma)ad >= -(1 << (16 - 1))
2049 && (bfd_signed_vma)ad < (1 << (16 - 1)))
2050 {
2051 /* setlos lo(ad), gr9 */
2052 bfd_put_32 (output_bfd,
2053 0x92fc0000
2054 | (ad
2055 & (((bfd_vma)1 << 16) - 1)),
2056 plt_code);
2057 plt_code += 4;
2058 }
2059 else
2060 {
2061 /* sethi.p hi(ad), gr9
2062 setlo lo(ad), gr9 */
2063 bfd_put_32 (output_bfd,
2064 0x12f80000
2065 | ((ad >> 16)
2066 & (((bfd_vma)1 << 16) - 1)),
2067 plt_code);
2068 plt_code += 4;
2069 bfd_put_32 (output_bfd,
2070 0x92f40000
2071 | (ad
2072 & (((bfd_vma)1 << 16) - 1)),
2073 plt_code);
2074 plt_code += 4;
2075 }
2076 /* ret */
2077 bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2078 }
2079 else if (entry->tlsoff_entry)
2080 {
2081 /* Figure out what kind of PLT entry we need, depending on the
2082 location of the TLS descriptor within the GOT. */
2083 if (entry->tlsoff_entry >= -(1 << (12 - 1))
2084 && entry->tlsoff_entry < (1 << (12 - 1)))
2085 {
2086 /* ldi @(gr15, tlsoff_entry), gr9 */
2087 bfd_put_32 (output_bfd,
2088 0x92c8f000 | (entry->tlsoff_entry
2089 & ((1 << 12) - 1)),
2090 plt_code);
2091 plt_code += 4;
2092 }
2093 else
2094 {
2095 if (entry->tlsoff_entry >= -(1 << (16 - 1))
2096 && entry->tlsoff_entry < (1 << (16 - 1)))
2097 {
2098 /* setlos lo(tlsoff_entry), gr8 */
2099 bfd_put_32 (output_bfd,
2100 0x90fc0000
2101 | (entry->tlsoff_entry
2102 & (((bfd_vma)1 << 16) - 1)),
2103 plt_code);
2104 plt_code += 4;
2105 }
2106 else
2107 {
2108 /* sethi.p hi(tlsoff_entry), gr8
2109 setlo lo(tlsoff_entry), gr8 */
2110 bfd_put_32 (output_bfd,
2111 0x10f80000
2112 | ((entry->tlsoff_entry >> 16)
2113 & (((bfd_vma)1 << 16) - 1)),
2114 plt_code);
2115 plt_code += 4;
2116 bfd_put_32 (output_bfd,
2117 0x90f40000
2118 | (entry->tlsoff_entry
2119 & (((bfd_vma)1 << 16) - 1)),
2120 plt_code);
2121 plt_code += 4;
2122 }
2123 /* ld @(gr15,gr8),gr9 */
2124 bfd_put_32 (output_bfd, 0x9008f108, plt_code);
2125 plt_code += 4;
2126 }
2127 /* ret */
2128 bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2129 }
2130 else
2131 {
2132 BFD_ASSERT (entry->tlsdesc_entry);
2133
2134 /* Figure out what kind of PLT entry we need, depending on the
2135 location of the TLS descriptor within the GOT. */
2136 if (entry->tlsdesc_entry >= -(1 << (12 - 1))
2137 && entry->tlsdesc_entry < (1 << (12 - 1)))
2138 {
2139 /* lddi @(gr15, tlsdesc_entry), gr8 */
2140 bfd_put_32 (output_bfd,
2141 0x90ccf000 | (entry->tlsdesc_entry
2142 & ((1 << 12) - 1)),
2143 plt_code);
2144 plt_code += 4;
2145 }
2146 else
2147 {
2148 if (entry->tlsdesc_entry >= -(1 << (16 - 1))
2149 && entry->tlsdesc_entry < (1 << (16 - 1)))
2150 {
2151 /* setlos lo(tlsdesc_entry), gr8 */
2152 bfd_put_32 (output_bfd,
2153 0x90fc0000
2154 | (entry->tlsdesc_entry
2155 & (((bfd_vma)1 << 16) - 1)),
2156 plt_code);
2157 plt_code += 4;
2158 }
2159 else
2160 {
2161 /* sethi.p hi(tlsdesc_entry), gr8
2162 setlo lo(tlsdesc_entry), gr8 */
2163 bfd_put_32 (output_bfd,
2164 0x10f80000
2165 | ((entry->tlsdesc_entry >> 16)
2166 & (((bfd_vma)1 << 16) - 1)),
2167 plt_code);
2168 plt_code += 4;
2169 bfd_put_32 (output_bfd,
2170 0x90f40000
2171 | (entry->tlsdesc_entry
2172 & (((bfd_vma)1 << 16) - 1)),
2173 plt_code);
2174 plt_code += 4;
2175 }
2176 /* ldd @(gr15,gr8),gr8 */
2177 bfd_put_32 (output_bfd, 0x9008f148, plt_code);
2178 plt_code += 4;
2179 }
2180 /* jmpl @(gr8,gr0) */
2181 bfd_put_32 (output_bfd, 0x80308000, plt_code);
2182 }
2183 }
2184
2185 return TRUE;
2186 }
2187
2188 /* Handle an FRV small data reloc. */
2189
2190 static bfd_reloc_status_type
2191 elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
2192 contents, value)
2193 struct bfd_link_info *info;
2194 bfd *input_bfd;
2195 asection *input_section;
2196 Elf_Internal_Rela *relocation;
2197 bfd_byte *contents;
2198 bfd_vma value;
2199 {
2200 bfd_vma insn;
2201 bfd_vma gp;
2202 struct bfd_link_hash_entry *h;
2203
2204 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2205
2206 gp = (h->u.def.value
2207 + h->u.def.section->output_section->vma
2208 + h->u.def.section->output_offset);
2209
2210 value -= input_section->output_section->vma;
2211 value -= (gp - input_section->output_section->vma);
2212
2213 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2214
2215 value += relocation->r_addend;
2216
2217 if ((long) value > 0x7ff || (long) value < -0x800)
2218 return bfd_reloc_overflow;
2219
2220 bfd_put_32 (input_bfd,
2221 (insn & 0xfffff000) | (value & 0xfff),
2222 contents + relocation->r_offset);
2223
2224 return bfd_reloc_ok;
2225 }
2226
2227 /* Handle an FRV small data reloc. for the u12 field. */
2228
2229 static bfd_reloc_status_type
2230 elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
2231 contents, value)
2232 struct bfd_link_info *info;
2233 bfd *input_bfd;
2234 asection *input_section;
2235 Elf_Internal_Rela *relocation;
2236 bfd_byte *contents;
2237 bfd_vma value;
2238 {
2239 bfd_vma insn;
2240 bfd_vma gp;
2241 struct bfd_link_hash_entry *h;
2242 bfd_vma mask;
2243
2244 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2245
2246 gp = (h->u.def.value
2247 + h->u.def.section->output_section->vma
2248 + h->u.def.section->output_offset);
2249
2250 value -= input_section->output_section->vma;
2251 value -= (gp - input_section->output_section->vma);
2252
2253 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2254
2255 value += relocation->r_addend;
2256
2257 if ((long) value > 0x7ff || (long) value < -0x800)
2258 return bfd_reloc_overflow;
2259
2260 /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0. */
2261 mask = 0x3f03f;
2262 insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
2263
2264 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2265
2266 return bfd_reloc_ok;
2267 }
2268
2269 /* Handle an FRV ELF HI16 reloc. */
2270
2271 static bfd_reloc_status_type
2272 elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
2273 bfd *input_bfd;
2274 Elf_Internal_Rela *relhi;
2275 bfd_byte *contents;
2276 bfd_vma value;
2277 {
2278 bfd_vma insn;
2279
2280 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
2281
2282 value += relhi->r_addend;
2283 value = ((value >> 16) & 0xffff);
2284
2285 insn = (insn & 0xffff0000) | value;
2286
2287 if ((long) value > 0xffff || (long) value < -0x10000)
2288 return bfd_reloc_overflow;
2289
2290 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
2291 return bfd_reloc_ok;
2292
2293 }
2294 static bfd_reloc_status_type
2295 elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
2296 bfd *input_bfd;
2297 Elf_Internal_Rela *rello;
2298 bfd_byte *contents;
2299 bfd_vma value;
2300 {
2301 bfd_vma insn;
2302
2303 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
2304
2305 value += rello->r_addend;
2306 value = value & 0xffff;
2307
2308 insn = (insn & 0xffff0000) | value;
2309
2310 if ((long) value > 0xffff || (long) value < -0x10000)
2311 return bfd_reloc_overflow;
2312
2313 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
2314 return bfd_reloc_ok;
2315 }
2316
2317 /* Perform the relocation for the CALL label24 instruction. */
2318
2319 static bfd_reloc_status_type
2320 elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
2321 bfd *input_bfd;
2322 asection *input_section;
2323 Elf_Internal_Rela *rello;
2324 bfd_byte *contents;
2325 bfd_vma value;
2326 {
2327 bfd_vma insn;
2328 bfd_vma label6;
2329 bfd_vma label18;
2330
2331 /* The format for the call instruction is:
2332
2333 0 000000 0001111 000000000000000000
2334 label6 opcode label18
2335
2336 The branch calculation is: pc + (4*label24)
2337 where label24 is the concatenation of label6 and label18. */
2338
2339 /* Grab the instruction. */
2340 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
2341
2342 value -= input_section->output_section->vma + input_section->output_offset;
2343 value -= rello->r_offset;
2344 value += rello->r_addend;
2345
2346 value = value >> 2;
2347
2348 label6 = value & 0xfc0000;
2349 label6 = label6 << 7;
2350
2351 label18 = value & 0x3ffff;
2352
2353 insn = insn & 0x803c0000;
2354 insn = insn | label6;
2355 insn = insn | label18;
2356
2357 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
2358
2359 return bfd_reloc_ok;
2360 }
2361
2362 static bfd_reloc_status_type
2363 elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
2364 contents, value)
2365 struct bfd_link_info *info;
2366 bfd *input_bfd;
2367 asection *input_section;
2368 Elf_Internal_Rela *relocation;
2369 bfd_byte *contents;
2370 bfd_vma value;
2371 {
2372 bfd_vma insn;
2373 bfd_vma gp;
2374 struct bfd_link_hash_entry *h;
2375
2376 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2377
2378 gp = (h->u.def.value
2379 + h->u.def.section->output_section->vma
2380 + h->u.def.section->output_offset);
2381
2382 value -= input_section->output_section->vma;
2383 value -= (gp - input_section->output_section->vma);
2384 value += relocation->r_addend;
2385 value = ((value >> 16) & 0xffff);
2386
2387 if ((long) value > 0xffff || (long) value < -0x10000)
2388 return bfd_reloc_overflow;
2389
2390 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2391 insn = (insn & 0xffff0000) | value;
2392
2393 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2394 return bfd_reloc_ok;
2395 }
2396
2397 static bfd_reloc_status_type
2398 elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
2399 contents, value)
2400 struct bfd_link_info *info;
2401 bfd *input_bfd;
2402 asection *input_section;
2403 Elf_Internal_Rela *relocation;
2404 bfd_byte *contents;
2405 bfd_vma value;
2406 {
2407 bfd_vma insn;
2408 bfd_vma gp;
2409 struct bfd_link_hash_entry *h;
2410
2411 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2412
2413 gp = (h->u.def.value
2414 + h->u.def.section->output_section->vma
2415 + h->u.def.section->output_offset);
2416
2417 value -= input_section->output_section->vma;
2418 value -= (gp - input_section->output_section->vma);
2419 value += relocation->r_addend;
2420 value = value & 0xffff;
2421
2422 if ((long) value > 0xffff || (long) value < -0x10000)
2423 return bfd_reloc_overflow;
2424
2425 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2426 insn = (insn & 0xffff0000) | value;
2427
2428 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2429
2430 return bfd_reloc_ok;
2431 }
2432
2433 static reloc_howto_type *
2434 frv_reloc_type_lookup (abfd, code)
2435 bfd *abfd ATTRIBUTE_UNUSED;
2436 bfd_reloc_code_real_type code;
2437 {
2438 switch (code)
2439 {
2440 default:
2441 break;
2442
2443 case BFD_RELOC_NONE:
2444 return &elf32_frv_howto_table[ (int) R_FRV_NONE];
2445
2446 case BFD_RELOC_32:
2447 if (elf_elfheader (abfd)->e_type == ET_EXEC
2448 || elf_elfheader (abfd)->e_type == ET_DYN)
2449 return &elf32_frv_rel_32_howto;
2450 /* Fall through. */
2451 case BFD_RELOC_CTOR:
2452 return &elf32_frv_howto_table[ (int) R_FRV_32];
2453
2454 case BFD_RELOC_FRV_LABEL16:
2455 return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
2456
2457 case BFD_RELOC_FRV_LABEL24:
2458 return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
2459
2460 case BFD_RELOC_FRV_LO16:
2461 return &elf32_frv_howto_table[ (int) R_FRV_LO16];
2462
2463 case BFD_RELOC_FRV_HI16:
2464 return &elf32_frv_howto_table[ (int) R_FRV_HI16];
2465
2466 case BFD_RELOC_FRV_GPREL12:
2467 return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
2468
2469 case BFD_RELOC_FRV_GPRELU12:
2470 return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
2471
2472 case BFD_RELOC_FRV_GPREL32:
2473 return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
2474
2475 case BFD_RELOC_FRV_GPRELHI:
2476 return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
2477
2478 case BFD_RELOC_FRV_GPRELLO:
2479 return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
2480
2481 case BFD_RELOC_FRV_GOT12:
2482 return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
2483
2484 case BFD_RELOC_FRV_GOTHI:
2485 return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
2486
2487 case BFD_RELOC_FRV_GOTLO:
2488 return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
2489
2490 case BFD_RELOC_FRV_FUNCDESC:
2491 if (elf_elfheader (abfd)->e_type == ET_EXEC
2492 || elf_elfheader (abfd)->e_type == ET_DYN)
2493 return &elf32_frv_rel_funcdesc_howto;
2494 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
2495
2496 case BFD_RELOC_FRV_FUNCDESC_GOT12:
2497 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
2498
2499 case BFD_RELOC_FRV_FUNCDESC_GOTHI:
2500 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
2501
2502 case BFD_RELOC_FRV_FUNCDESC_GOTLO:
2503 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
2504
2505 case BFD_RELOC_FRV_FUNCDESC_VALUE:
2506 if (elf_elfheader (abfd)->e_type == ET_EXEC
2507 || elf_elfheader (abfd)->e_type == ET_DYN)
2508 return &elf32_frv_rel_funcdesc_value_howto;
2509 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
2510
2511 case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
2512 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
2513
2514 case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
2515 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
2516
2517 case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
2518 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
2519
2520 case BFD_RELOC_FRV_GOTOFF12:
2521 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
2522
2523 case BFD_RELOC_FRV_GOTOFFHI:
2524 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
2525
2526 case BFD_RELOC_FRV_GOTOFFLO:
2527 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
2528
2529 case BFD_RELOC_FRV_GETTLSOFF:
2530 return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF];
2531
2532 case BFD_RELOC_FRV_TLSDESC_VALUE:
2533 if (elf_elfheader (abfd)->e_type == ET_EXEC
2534 || elf_elfheader (abfd)->e_type == ET_DYN)
2535 return &elf32_frv_rel_tlsdesc_value_howto;
2536 return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_VALUE];
2537
2538 case BFD_RELOC_FRV_GOTTLSDESC12:
2539 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESC12];
2540
2541 case BFD_RELOC_FRV_GOTTLSDESCHI:
2542 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCHI];
2543
2544 case BFD_RELOC_FRV_GOTTLSDESCLO:
2545 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCLO];
2546
2547 case BFD_RELOC_FRV_TLSMOFF12:
2548 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF12];
2549
2550 case BFD_RELOC_FRV_TLSMOFFHI:
2551 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFHI];
2552
2553 case BFD_RELOC_FRV_TLSMOFFLO:
2554 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFLO];
2555
2556 case BFD_RELOC_FRV_GOTTLSOFF12:
2557 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFF12];
2558
2559 case BFD_RELOC_FRV_GOTTLSOFFHI:
2560 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFHI];
2561
2562 case BFD_RELOC_FRV_GOTTLSOFFLO:
2563 return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFLO];
2564
2565 case BFD_RELOC_FRV_TLSOFF:
2566 if (elf_elfheader (abfd)->e_type == ET_EXEC
2567 || elf_elfheader (abfd)->e_type == ET_DYN)
2568 return &elf32_frv_rel_tlsoff_howto;
2569 return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF];
2570
2571 case BFD_RELOC_FRV_TLSDESC_RELAX:
2572 return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_RELAX];
2573
2574 case BFD_RELOC_FRV_GETTLSOFF_RELAX:
2575 return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF_RELAX];
2576
2577 case BFD_RELOC_FRV_TLSOFF_RELAX:
2578 return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF_RELAX];
2579
2580 case BFD_RELOC_FRV_TLSMOFF:
2581 return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF];
2582
2583 case BFD_RELOC_VTABLE_INHERIT:
2584 return &elf32_frv_vtinherit_howto;
2585
2586 case BFD_RELOC_VTABLE_ENTRY:
2587 return &elf32_frv_vtentry_howto;
2588 }
2589
2590 return NULL;
2591 }
2592
2593 /* Set the howto pointer for an FRV ELF reloc. */
2594
2595 static void
2596 frv_info_to_howto_rela (abfd, cache_ptr, dst)
2597 bfd *abfd ATTRIBUTE_UNUSED;
2598 arelent *cache_ptr;
2599 Elf_Internal_Rela *dst;
2600 {
2601 unsigned int r_type;
2602
2603 r_type = ELF32_R_TYPE (dst->r_info);
2604 switch (r_type)
2605 {
2606 case R_FRV_GNU_VTINHERIT:
2607 cache_ptr->howto = &elf32_frv_vtinherit_howto;
2608 break;
2609
2610 case R_FRV_GNU_VTENTRY:
2611 cache_ptr->howto = &elf32_frv_vtentry_howto;
2612 break;
2613
2614 default:
2615 cache_ptr->howto = & elf32_frv_howto_table [r_type];
2616 break;
2617 }
2618 }
2619
2620 /* Set the howto pointer for an FRV ELF REL reloc. */
2621 static void
2622 frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
2623 arelent *cache_ptr, Elf_Internal_Rela *dst)
2624 {
2625 unsigned int r_type;
2626
2627 r_type = ELF32_R_TYPE (dst->r_info);
2628 switch (r_type)
2629 {
2630 case R_FRV_32:
2631 cache_ptr->howto = &elf32_frv_rel_32_howto;
2632 break;
2633
2634 case R_FRV_FUNCDESC:
2635 cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
2636 break;
2637
2638 case R_FRV_FUNCDESC_VALUE:
2639 cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
2640 break;
2641
2642 case R_FRV_TLSDESC_VALUE:
2643 cache_ptr->howto = &elf32_frv_rel_tlsdesc_value_howto;
2644 break;
2645
2646 case R_FRV_TLSOFF:
2647 cache_ptr->howto = &elf32_frv_rel_tlsoff_howto;
2648 break;
2649
2650 default:
2651 cache_ptr->howto = NULL;
2652 break;
2653 }
2654 }
2655 \f
2656 /* Perform a single relocation. By default we use the standard BFD
2657 routines, but a few relocs, we have to do them ourselves. */
2658
2659 static bfd_reloc_status_type
2660 frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
2661 relocation)
2662 reloc_howto_type *howto;
2663 bfd *input_bfd;
2664 asection *input_section;
2665 bfd_byte *contents;
2666 Elf_Internal_Rela *rel;
2667 bfd_vma relocation;
2668 {
2669 return _bfd_final_link_relocate (howto, input_bfd, input_section,
2670 contents, rel->r_offset, relocation,
2671 rel->r_addend);
2672 }
2673
2674 \f
2675 /* Relocate an FRV ELF section.
2676
2677 The RELOCATE_SECTION function is called by the new ELF backend linker
2678 to handle the relocations for a section.
2679
2680 The relocs are always passed as Rela structures; if the section
2681 actually uses Rel structures, the r_addend field will always be
2682 zero.
2683
2684 This function is responsible for adjusting the section contents as
2685 necessary, and (if using Rela relocs and generating a relocatable
2686 output file) adjusting the reloc addend as necessary.
2687
2688 This function does not have to worry about setting the reloc
2689 address or the reloc symbol index.
2690
2691 LOCAL_SYMS is a pointer to the swapped in local symbols.
2692
2693 LOCAL_SECTIONS is an array giving the section in the input file
2694 corresponding to the st_shndx field of each local symbol.
2695
2696 The global hash table entry for the global symbols can be found
2697 via elf_sym_hashes (input_bfd).
2698
2699 When generating relocatable output, this function must handle
2700 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
2701 going to be the section symbol corresponding to the output
2702 section, which means that the addend must be adjusted
2703 accordingly. */
2704
2705 static bfd_boolean
2706 elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
2707 contents, relocs, local_syms, local_sections)
2708 bfd *output_bfd ATTRIBUTE_UNUSED;
2709 struct bfd_link_info *info;
2710 bfd *input_bfd;
2711 asection *input_section;
2712 bfd_byte *contents;
2713 Elf_Internal_Rela *relocs;
2714 Elf_Internal_Sym *local_syms;
2715 asection **local_sections;
2716 {
2717 Elf_Internal_Shdr *symtab_hdr;
2718 struct elf_link_hash_entry **sym_hashes;
2719 Elf_Internal_Rela *rel;
2720 Elf_Internal_Rela *relend;
2721 unsigned isec_segment, got_segment, plt_segment, gprel_segment, tls_segment,
2722 check_segment[2];
2723 int silence_segment_error = !(info->shared || info->pie);
2724 unsigned long insn;
2725
2726 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2727 sym_hashes = elf_sym_hashes (input_bfd);
2728 relend = relocs + input_section->reloc_count;
2729
2730 isec_segment = _frvfdpic_osec_to_segment (output_bfd,
2731 input_section->output_section);
2732 if (IS_FDPIC (output_bfd) && frvfdpic_got_section (info))
2733 got_segment = _frvfdpic_osec_to_segment (output_bfd,
2734 frvfdpic_got_section (info)
2735 ->output_section);
2736 else
2737 got_segment = -1;
2738 if (IS_FDPIC (output_bfd) && frvfdpic_gotfixup_section (info))
2739 gprel_segment = _frvfdpic_osec_to_segment (output_bfd,
2740 frvfdpic_gotfixup_section (info)
2741 ->output_section);
2742 else
2743 gprel_segment = -1;
2744 if (IS_FDPIC (output_bfd) && frvfdpic_plt_section (info))
2745 plt_segment = _frvfdpic_osec_to_segment (output_bfd,
2746 frvfdpic_plt_section (info)
2747 ->output_section);
2748 else
2749 plt_segment = -1;
2750 if (elf_hash_table (info)->tls_sec)
2751 tls_segment = _frvfdpic_osec_to_segment (output_bfd,
2752 elf_hash_table (info)->tls_sec);
2753 else
2754 tls_segment = -1;
2755
2756 for (rel = relocs; rel < relend; rel ++)
2757 {
2758 reloc_howto_type *howto;
2759 unsigned long r_symndx;
2760 Elf_Internal_Sym *sym;
2761 asection *sec;
2762 struct elf_link_hash_entry *h;
2763 bfd_vma relocation;
2764 bfd_reloc_status_type r;
2765 const char * name = NULL;
2766 int r_type;
2767 asection *osec;
2768 struct frvfdpic_relocs_info *picrel;
2769 bfd_vma orig_addend = rel->r_addend;
2770
2771 r_type = ELF32_R_TYPE (rel->r_info);
2772
2773 if ( r_type == R_FRV_GNU_VTINHERIT
2774 || r_type == R_FRV_GNU_VTENTRY)
2775 continue;
2776
2777 r_symndx = ELF32_R_SYM (rel->r_info);
2778 howto = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
2779 h = NULL;
2780 sym = NULL;
2781 sec = NULL;
2782
2783 if (r_symndx < symtab_hdr->sh_info)
2784 {
2785 sym = local_syms + r_symndx;
2786 osec = sec = local_sections [r_symndx];
2787 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2788
2789 name = bfd_elf_string_from_elf_section
2790 (input_bfd, symtab_hdr->sh_link, sym->st_name);
2791 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
2792 }
2793 else
2794 {
2795 bfd_boolean warned;
2796 bfd_boolean unresolved_reloc;
2797
2798 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2799 r_symndx, symtab_hdr, sym_hashes,
2800 h, sec, relocation,
2801 unresolved_reloc, warned);
2802 osec = sec;
2803 }
2804
2805 if (sec != NULL && elf_discarded_section (sec))
2806 {
2807 /* For relocs against symbols from removed linkonce sections,
2808 or sections discarded by a linker script, we just want the
2809 section contents zeroed. Avoid any special processing. */
2810 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
2811 rel->r_info = 0;
2812 rel->r_addend = 0;
2813 continue;
2814 }
2815
2816 if (info->relocatable)
2817 continue;
2818
2819 if (r_type != R_FRV_TLSMOFF
2820 && h != NULL
2821 && (h->root.type == bfd_link_hash_defined
2822 || h->root.type == bfd_link_hash_defweak)
2823 && !FRVFDPIC_SYM_LOCAL (info, h))
2824 {
2825 osec = sec = NULL;
2826 relocation = 0;
2827 }
2828
2829 switch (r_type)
2830 {
2831 case R_FRV_LABEL24:
2832 case R_FRV_32:
2833 if (! IS_FDPIC (output_bfd))
2834 goto non_fdpic;
2835
2836 case R_FRV_GOT12:
2837 case R_FRV_GOTHI:
2838 case R_FRV_GOTLO:
2839 case R_FRV_FUNCDESC_GOT12:
2840 case R_FRV_FUNCDESC_GOTHI:
2841 case R_FRV_FUNCDESC_GOTLO:
2842 case R_FRV_GOTOFF12:
2843 case R_FRV_GOTOFFHI:
2844 case R_FRV_GOTOFFLO:
2845 case R_FRV_FUNCDESC_GOTOFF12:
2846 case R_FRV_FUNCDESC_GOTOFFHI:
2847 case R_FRV_FUNCDESC_GOTOFFLO:
2848 case R_FRV_FUNCDESC:
2849 case R_FRV_FUNCDESC_VALUE:
2850 case R_FRV_GETTLSOFF:
2851 case R_FRV_TLSDESC_VALUE:
2852 case R_FRV_GOTTLSDESC12:
2853 case R_FRV_GOTTLSDESCHI:
2854 case R_FRV_GOTTLSDESCLO:
2855 case R_FRV_TLSMOFF12:
2856 case R_FRV_TLSMOFFHI:
2857 case R_FRV_TLSMOFFLO:
2858 case R_FRV_GOTTLSOFF12:
2859 case R_FRV_GOTTLSOFFHI:
2860 case R_FRV_GOTTLSOFFLO:
2861 case R_FRV_TLSOFF:
2862 case R_FRV_TLSDESC_RELAX:
2863 case R_FRV_GETTLSOFF_RELAX:
2864 case R_FRV_TLSOFF_RELAX:
2865 case R_FRV_TLSMOFF:
2866 if (h != NULL)
2867 picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2868 (info), input_bfd, h,
2869 orig_addend, INSERT);
2870 else
2871 /* In order to find the entry we created before, we must
2872 use the original addend, not the one that may have been
2873 modified by _bfd_elf_rela_local_sym(). */
2874 picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2875 (info), input_bfd, r_symndx,
2876 orig_addend, INSERT);
2877 if (! picrel)
2878 return FALSE;
2879
2880 if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2881 osec, sym,
2882 rel->r_addend))
2883 {
2884 (*_bfd_error_handler)
2885 (_("%B(%A+0x%x): relocation to `%s+%x' may have caused the error above"),
2886 input_bfd, input_section, rel->r_offset, name, rel->r_addend);
2887 return FALSE;
2888 }
2889
2890 break;
2891
2892 default:
2893 non_fdpic:
2894 picrel = NULL;
2895 if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2896 {
2897 info->callbacks->warning
2898 (info, _("relocation references symbol not defined in the module"),
2899 name, input_bfd, input_section, rel->r_offset);
2900 return FALSE;
2901 }
2902 break;
2903 }
2904
2905 switch (r_type)
2906 {
2907 case R_FRV_GETTLSOFF:
2908 case R_FRV_TLSDESC_VALUE:
2909 case R_FRV_GOTTLSDESC12:
2910 case R_FRV_GOTTLSDESCHI:
2911 case R_FRV_GOTTLSDESCLO:
2912 case R_FRV_TLSMOFF12:
2913 case R_FRV_TLSMOFFHI:
2914 case R_FRV_TLSMOFFLO:
2915 case R_FRV_GOTTLSOFF12:
2916 case R_FRV_GOTTLSOFFHI:
2917 case R_FRV_GOTTLSOFFLO:
2918 case R_FRV_TLSOFF:
2919 case R_FRV_TLSDESC_RELAX:
2920 case R_FRV_GETTLSOFF_RELAX:
2921 case R_FRV_TLSOFF_RELAX:
2922 case R_FRV_TLSMOFF:
2923 if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec)))
2924 relocation += tls_biased_base (info);
2925 break;
2926
2927 default:
2928 break;
2929 }
2930
2931 /* Try to apply TLS relaxations. */
2932 if (1)
2933 switch (r_type)
2934 {
2935
2936 #define LOCAL_EXEC_P(info, picrel) \
2937 ((info)->executable \
2938 && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2939 #define INITIAL_EXEC_P(info, picrel) \
2940 (((info)->executable || (info)->flags & DF_STATIC_TLS) \
2941 && (picrel)->tlsoff_entry)
2942
2943 #define IN_RANGE_FOR_OFST12_P(value) \
2944 ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2945 #define IN_RANGE_FOR_SETLOS_P(value) \
2946 ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2947 #define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2948 (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2949
2950 #define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2951 (LOCAL_EXEC_P ((info), (picrel)) \
2952 && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2953 #define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2954 (INITIAL_EXEC_P ((info), (picrel)) \
2955 && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2956
2957 #define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2958 (LOCAL_EXEC_P ((info), (picrel)))
2959 #define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2960 (INITIAL_EXEC_P ((info), (picrel)))
2961
2962 #define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2963 (LOCAL_EXEC_P ((info), (picrel)) \
2964 && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2965
2966 case R_FRV_GETTLSOFF:
2967 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2968
2969 /* Is this a call instruction? */
2970 if ((insn & (unsigned long)0x01fc0000) != 0x003c0000)
2971 {
2972 r = info->callbacks->warning
2973 (info,
2974 _("R_FRV_GETTLSOFF not applied to a call instruction"),
2975 name, input_bfd, input_section, rel->r_offset);
2976 return FALSE;
2977 }
2978
2979 if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel,
2980 relocation + rel->r_addend))
2981 {
2982 /* Replace the call instruction (except the packing bit)
2983 with setlos #tlsmofflo(symbol+offset), gr9. */
2984 insn &= (unsigned long)0x80000000;
2985 insn |= (unsigned long)0x12fc0000;
2986 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2987
2988 r_type = R_FRV_TLSMOFFLO;
2989 howto = elf32_frv_howto_table + r_type;
2990 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
2991 }
2992
2993 else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel))
2994 {
2995 /* Replace the call instruction (except the packing bit)
2996 with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9. */
2997 insn &= (unsigned long)0x80000000;
2998 insn |= (unsigned long)0x12c8f000;
2999 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3000
3001 r_type = R_FRV_GOTTLSOFF12;
3002 howto = elf32_frv_howto_table + r_type;
3003 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3004 }
3005
3006 break;
3007
3008 case R_FRV_GOTTLSDESC12:
3009 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3010
3011 /* Is this an lddi instruction? */
3012 if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000)
3013 {
3014 r = info->callbacks->warning
3015 (info,
3016 _("R_FRV_GOTTLSDESC12 not applied to an lddi instruction"),
3017 name, input_bfd, input_section, rel->r_offset);
3018 return FALSE;
3019 }
3020
3021 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3022 relocation + rel->r_addend)
3023 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3024 info))
3025 {
3026 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3027 with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3028 Preserve the packing bit. */
3029 insn = (insn & (unsigned long)0x80000000)
3030 | ((insn + (unsigned long)0x02000000)
3031 & (unsigned long)0x7e000000);
3032 insn |= (unsigned long)0x00fc0000;
3033 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3034
3035 r_type = R_FRV_TLSMOFFLO;
3036 howto = elf32_frv_howto_table + r_type;
3037 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3038 }
3039
3040 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3041 relocation + rel->r_addend))
3042 {
3043 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3044 with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3045 Preserve the packing bit. */
3046 insn = (insn & (unsigned long)0x80000000)
3047 | ((insn + (unsigned long)0x02000000)
3048 & (unsigned long)0x7e000000);
3049 insn |= (unsigned long)0x00f80000;
3050 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3051
3052 r_type = R_FRV_TLSMOFFHI;
3053 howto = elf32_frv_howto_table + r_type;
3054 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3055 }
3056
3057 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3058 {
3059 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3060 with ldi @(grB, #gottlsoff12(symbol+offset),
3061 gr<C+1>. Preserve the packing bit. If gottlsoff12
3062 overflows, we'll error out, but that's sort-of ok,
3063 since we'd started with gottlsdesc12, that's actually
3064 more demanding. Compiling with -fPIE instead of
3065 -fpie would fix it; linking with --relax should fix
3066 it as well. */
3067 insn = (insn & (unsigned long)0x80cbf000)
3068 | ((insn + (unsigned long)0x02000000)
3069 & (unsigned long)0x7e000000);
3070 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3071
3072 r_type = R_FRV_GOTTLSOFF12;
3073 howto = elf32_frv_howto_table + r_type;
3074 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3075 }
3076
3077 break;
3078
3079 case R_FRV_GOTTLSDESCHI:
3080 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3081
3082 /* Is this a sethi instruction? */
3083 if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3084 {
3085 r = info->callbacks->warning
3086 (info,
3087 _("R_FRV_GOTTLSDESCHI not applied to a sethi instruction"),
3088 name, input_bfd, input_section, rel->r_offset);
3089 return FALSE;
3090 }
3091
3092 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3093 relocation + rel->r_addend)
3094 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3095 && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)))
3096 {
3097 /* Replace sethi with a nop. Preserve the packing bit. */
3098 insn &= (unsigned long)0x80000000;
3099 insn |= (unsigned long)0x00880000;
3100 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3101
3102 /* Nothing to relocate. */
3103 continue;
3104 }
3105
3106 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3107 {
3108 /* Simply decay GOTTLSDESC to GOTTLSOFF. */
3109 r_type = R_FRV_GOTTLSOFFHI;
3110 howto = elf32_frv_howto_table + r_type;
3111 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3112 }
3113
3114 break;
3115
3116 case R_FRV_GOTTLSDESCLO:
3117 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3118
3119 /* Is this a setlo or setlos instruction? */
3120 if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3121 {
3122 r = info->callbacks->warning
3123 (info,
3124 _("R_FRV_GOTTLSDESCLO"
3125 " not applied to a setlo or setlos instruction"),
3126 name, input_bfd, input_section, rel->r_offset);
3127 return FALSE;
3128 }
3129
3130 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3131 relocation + rel->r_addend)
3132 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3133 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3134 {
3135 /* Replace setlo/setlos with a nop. Preserve the
3136 packing bit. */
3137 insn &= (unsigned long)0x80000000;
3138 insn |= (unsigned long)0x00880000;
3139 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3140
3141 /* Nothing to relocate. */
3142 continue;
3143 }
3144
3145 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3146 {
3147 /* If the corresponding sethi (if it exists) decayed
3148 to a nop, make sure this becomes (or already is) a
3149 setlos, not setlo. */
3150 if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))
3151 {
3152 insn |= (unsigned long)0x00080000;
3153 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3154 }
3155
3156 /* Simply decay GOTTLSDESC to GOTTLSOFF. */
3157 r_type = R_FRV_GOTTLSOFFLO;
3158 howto = elf32_frv_howto_table + r_type;
3159 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3160 }
3161
3162 break;
3163
3164 case R_FRV_TLSDESC_RELAX:
3165 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3166
3167 /* Is this an ldd instruction? */
3168 if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140)
3169 {
3170 r = info->callbacks->warning
3171 (info,
3172 _("R_FRV_TLSDESC_RELAX not applied to an ldd instruction"),
3173 name, input_bfd, input_section, rel->r_offset);
3174 return FALSE;
3175 }
3176
3177 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3178 relocation + rel->r_addend)
3179 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3180 info))
3181 {
3182 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3183 with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3184 Preserve the packing bit. */
3185 insn = (insn & (unsigned long)0x80000000)
3186 | ((insn + (unsigned long)0x02000000)
3187 & (unsigned long)0x7e000000);
3188 insn |= (unsigned long)0x00fc0000;
3189 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3190
3191 r_type = R_FRV_TLSMOFFLO;
3192 howto = elf32_frv_howto_table + r_type;
3193 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3194 }
3195
3196 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3197 relocation + rel->r_addend))
3198 {
3199 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3200 with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3201 Preserve the packing bit. */
3202 insn = (insn & (unsigned long)0x80000000)
3203 | ((insn + (unsigned long)0x02000000)
3204 & (unsigned long)0x7e000000);
3205 insn |= (unsigned long)0x00f80000;
3206 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3207
3208 r_type = R_FRV_TLSMOFFHI;
3209 howto = elf32_frv_howto_table + r_type;
3210 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3211 }
3212
3213 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3214 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3215 {
3216 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3217 with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3218 Preserve the packing bit. */
3219 insn = (insn & (unsigned long)0x8003f000)
3220 | (unsigned long)0x00c80000
3221 | ((insn + (unsigned long)0x02000000)
3222 & (unsigned long)0x7e000000);
3223 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3224
3225 r_type = R_FRV_GOTTLSOFF12;
3226 howto = elf32_frv_howto_table + r_type;
3227 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3228 }
3229
3230 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3231 {
3232 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3233 with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3234 Preserve the packing bit. */
3235 insn = (insn & (unsigned long)0x81ffffbf)
3236 | ((insn + (unsigned long)0x02000000)
3237 & (unsigned long)0x7e000000);
3238 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3239
3240 /* #tlsoff(symbol+offset) is just a relaxation
3241 annotation, so there's nothing left to
3242 relocate. */
3243 continue;
3244 }
3245
3246 break;
3247
3248 case R_FRV_GETTLSOFF_RELAX:
3249 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3250
3251 /* Is this a calll or callil instruction? */
3252 if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000)
3253 {
3254 r = info->callbacks->warning
3255 (info,
3256 _("R_FRV_GETTLSOFF_RELAX"
3257 " not applied to a calll instruction"),
3258 name, input_bfd, input_section, rel->r_offset);
3259 return FALSE;
3260 }
3261
3262 if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3263 relocation + rel->r_addend)
3264 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3265 info))
3266 {
3267 /* Replace calll with a nop. Preserve the packing bit. */
3268 insn &= (unsigned long)0x80000000;
3269 insn |= (unsigned long)0x00880000;
3270 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3271
3272 /* Nothing to relocate. */
3273 continue;
3274 }
3275
3276 else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3277 relocation + rel->r_addend))
3278 {
3279 /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3280 Preserve the packing bit. */
3281 insn &= (unsigned long)0x80000000;
3282 insn |= (unsigned long)0x12f40000;
3283 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3284
3285 r_type = R_FRV_TLSMOFFLO;
3286 howto = elf32_frv_howto_table + r_type;
3287 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3288 }
3289
3290 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3291 {
3292 /* Replace calll with a nop. Preserve the packing bit. */
3293 insn &= (unsigned long)0x80000000;
3294 insn |= (unsigned long)0x00880000;
3295 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3296
3297 /* Nothing to relocate. */
3298 continue;
3299 }
3300
3301 break;
3302
3303 case R_FRV_GOTTLSOFF12:
3304 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3305
3306 /* Is this an ldi instruction? */
3307 if ((insn & (unsigned long)0x01fc0000) != 0x00c80000)
3308 {
3309 r = info->callbacks->warning
3310 (info,
3311 _("R_FRV_GOTTLSOFF12 not applied to an ldi instruction"),
3312 name, input_bfd, input_section, rel->r_offset);
3313 return FALSE;
3314 }
3315
3316 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3317 relocation + rel->r_addend))
3318 {
3319 /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3320 with setlos #tlsmofflo(symbol+offset), grC.
3321 Preserve the packing bit. */
3322 insn &= (unsigned long)0xfe000000;
3323 insn |= (unsigned long)0x00fc0000;
3324 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3325
3326 r_type = R_FRV_TLSMOFFLO;
3327 howto = elf32_frv_howto_table + r_type;
3328 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3329 }
3330
3331 break;
3332
3333 case R_FRV_GOTTLSOFFHI:
3334 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3335
3336 /* Is this a sethi instruction? */
3337 if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3338 {
3339 r = info->callbacks->warning
3340 (info,
3341 _("R_FRV_GOTTLSOFFHI not applied to a sethi instruction"),
3342 name, input_bfd, input_section, rel->r_offset);
3343 return FALSE;
3344 }
3345
3346 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3347 relocation + rel->r_addend)
3348 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3349 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3350 {
3351 /* Replace sethi with a nop. Preserve the packing bit. */
3352 insn &= (unsigned long)0x80000000;
3353 insn |= (unsigned long)0x00880000;
3354 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3355
3356 /* Nothing to relocate. */
3357 continue;
3358 }
3359
3360 break;
3361
3362 case R_FRV_GOTTLSOFFLO:
3363 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3364
3365 /* Is this a setlo or setlos instruction? */
3366 if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3367 {
3368 r = info->callbacks->warning
3369 (info,
3370 _("R_FRV_GOTTLSOFFLO"
3371 " not applied to a setlo or setlos instruction"),
3372 name, input_bfd, input_section, rel->r_offset);
3373 return FALSE;
3374 }
3375
3376 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3377 relocation + rel->r_addend)
3378 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3379 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3380 {
3381 /* Replace setlo/setlos with a nop. Preserve the
3382 packing bit. */
3383 insn &= (unsigned long)0x80000000;
3384 insn |= (unsigned long)0x00880000;
3385 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3386
3387 /* Nothing to relocate. */
3388 continue;
3389 }
3390
3391 break;
3392
3393 case R_FRV_TLSOFF_RELAX:
3394 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3395
3396 /* Is this an ld instruction? */
3397 if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100)
3398 {
3399 r = info->callbacks->warning
3400 (info,
3401 _("R_FRV_TLSOFF_RELAX not applied to an ld instruction"),
3402 name, input_bfd, input_section, rel->r_offset);
3403 return FALSE;
3404 }
3405
3406 if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3407 relocation + rel->r_addend))
3408 {
3409 /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3410 with setlos #tlsmofflo(symbol+offset), grC.
3411 Preserve the packing bit. */
3412 insn &= (unsigned long)0xfe000000;
3413 insn |= (unsigned long)0x00fc0000;
3414 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3415
3416 r_type = R_FRV_TLSMOFFLO;
3417 howto = elf32_frv_howto_table + r_type;
3418 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3419 }
3420
3421 else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3422 && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3423 {
3424 /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3425 with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3426 Preserve the packing bit. */
3427 insn = (insn & (unsigned long)0xfe03f000)
3428 | (unsigned long)0x00c80000;;
3429 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3430
3431 r_type = R_FRV_GOTTLSOFF12;
3432 howto = elf32_frv_howto_table + r_type;
3433 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3434 }
3435
3436 break;
3437
3438 case R_FRV_TLSMOFFHI:
3439 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3440
3441 /* Is this a sethi instruction? */
3442 if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3443 {
3444 r = info->callbacks->warning
3445 (info,
3446 _("R_FRV_TLSMOFFHI not applied to a sethi instruction"),
3447 name, input_bfd, input_section, rel->r_offset);
3448 return FALSE;
3449 }
3450
3451 if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3452 info))
3453 {
3454 /* Replace sethi with a nop. Preserve the packing bit. */
3455 insn &= (unsigned long)0x80000000;
3456 insn |= (unsigned long)0x00880000;
3457 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3458
3459 /* Nothing to relocate. */
3460 continue;
3461 }
3462
3463 break;
3464
3465 case R_FRV_TLSMOFFLO:
3466 insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3467
3468 /* Is this a setlo or setlos instruction? */
3469 if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3470 {
3471 r = info->callbacks->warning
3472 (info,
3473 _("R_FRV_TLSMOFFLO"
3474 " not applied to a setlo or setlos instruction"),
3475 name, input_bfd, input_section, rel->r_offset);
3476 return FALSE;
3477 }
3478
3479 if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3480 info))
3481 /* If the corresponding sethi (if it exists) decayed
3482 to a nop, make sure this becomes (or already is) a
3483 setlos, not setlo. */
3484 {
3485 insn |= (unsigned long)0x00080000;
3486 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3487 }
3488
3489 break;
3490
3491 /*
3492 There's nothing to relax in these:
3493 R_FRV_TLSDESC_VALUE
3494 R_FRV_TLSOFF
3495 R_FRV_TLSMOFF12
3496 R_FRV_TLSMOFFHI
3497 R_FRV_TLSMOFFLO
3498 R_FRV_TLSMOFF
3499 */
3500
3501 default:
3502 break;
3503 }
3504
3505 switch (r_type)
3506 {
3507 case R_FRV_LABEL24:
3508 check_segment[0] = isec_segment;
3509 if (! IS_FDPIC (output_bfd))
3510 check_segment[1] = isec_segment;
3511 else if (picrel->plt)
3512 {
3513 relocation = frvfdpic_plt_section (info)->output_section->vma
3514 + frvfdpic_plt_section (info)->output_offset
3515 + picrel->plt_entry;
3516 check_segment[1] = plt_segment;
3517 }
3518 /* We don't want to warn on calls to undefined weak symbols,
3519 as calls to them must be protected by non-NULL tests
3520 anyway, and unprotected calls would invoke undefined
3521 behavior. */
3522 else if (picrel->symndx == -1
3523 && picrel->d.h->root.type == bfd_link_hash_undefweak)
3524 check_segment[1] = check_segment[0];
3525 else
3526 check_segment[1] = sec
3527 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3528 : (unsigned)-1;
3529 break;
3530
3531 case R_FRV_GOT12:
3532 case R_FRV_GOTHI:
3533 case R_FRV_GOTLO:
3534 relocation = picrel->got_entry;
3535 check_segment[0] = check_segment[1] = got_segment;
3536 break;
3537
3538 case R_FRV_FUNCDESC_GOT12:
3539 case R_FRV_FUNCDESC_GOTHI:
3540 case R_FRV_FUNCDESC_GOTLO:
3541 relocation = picrel->fdgot_entry;
3542 check_segment[0] = check_segment[1] = got_segment;
3543 break;
3544
3545 case R_FRV_GOTOFFHI:
3546 case R_FRV_GOTOFF12:
3547 case R_FRV_GOTOFFLO:
3548 relocation -= frvfdpic_got_section (info)->output_section->vma
3549 + frvfdpic_got_section (info)->output_offset
3550 + frvfdpic_got_initial_offset (info);
3551 check_segment[0] = got_segment;
3552 check_segment[1] = sec
3553 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3554 : (unsigned)-1;
3555 break;
3556
3557 case R_FRV_FUNCDESC_GOTOFF12:
3558 case R_FRV_FUNCDESC_GOTOFFHI:
3559 case R_FRV_FUNCDESC_GOTOFFLO:
3560 relocation = picrel->fd_entry;
3561 check_segment[0] = check_segment[1] = got_segment;
3562 break;
3563
3564 case R_FRV_FUNCDESC:
3565 {
3566 int dynindx;
3567 bfd_vma addend = rel->r_addend;
3568
3569 if (! (h && h->root.type == bfd_link_hash_undefweak
3570 && FRVFDPIC_SYM_LOCAL (info, h)))
3571 {
3572 /* If the symbol is dynamic and there may be dynamic
3573 symbol resolution because we are or are linked with a
3574 shared library, emit a FUNCDESC relocation such that
3575 the dynamic linker will allocate the function
3576 descriptor. If the symbol needs a non-local function
3577 descriptor but binds locally (e.g., its visibility is
3578 protected, emit a dynamic relocation decayed to
3579 section+offset. */
3580 if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
3581 && FRVFDPIC_SYM_LOCAL (info, h)
3582 && !(info->executable && !info->pie))
3583 {
3584 dynindx = elf_section_data (h->root.u.def.section
3585 ->output_section)->dynindx;
3586 addend += h->root.u.def.section->output_offset
3587 + h->root.u.def.value;
3588 }
3589 else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
3590 {
3591 if (addend)
3592 {
3593 info->callbacks->warning
3594 (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
3595 name, input_bfd, input_section, rel->r_offset);
3596 return FALSE;
3597 }
3598 dynindx = h->dynindx;
3599 }
3600 else
3601 {
3602 /* Otherwise, we know we have a private function
3603 descriptor, so reference it directly. */
3604 BFD_ASSERT (picrel->privfd);
3605 r_type = R_FRV_32;
3606 dynindx = elf_section_data (frvfdpic_got_section (info)
3607 ->output_section)->dynindx;
3608 addend = frvfdpic_got_section (info)->output_offset
3609 + frvfdpic_got_initial_offset (info)
3610 + picrel->fd_entry;
3611 }
3612
3613 /* If there is room for dynamic symbol resolution, emit
3614 the dynamic relocation. However, if we're linking an
3615 executable at a fixed location, we won't have emitted a
3616 dynamic symbol entry for the got section, so idx will
3617 be zero, which means we can and should compute the
3618 address of the private descriptor ourselves. */
3619 if (info->executable && !info->pie
3620 && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
3621 {
3622 addend += frvfdpic_got_section (info)->output_section->vma;
3623 if ((bfd_get_section_flags (output_bfd,
3624 input_section->output_section)
3625 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3626 {
3627 if (_frvfdpic_osec_readonly_p (output_bfd,
3628 input_section
3629 ->output_section))
3630 {
3631 info->callbacks->warning
3632 (info,
3633 _("cannot emit fixups in read-only section"),
3634 name, input_bfd, input_section, rel->r_offset);
3635 return FALSE;
3636 }
3637 _frvfdpic_add_rofixup (output_bfd,
3638 frvfdpic_gotfixup_section
3639 (info),
3640 _bfd_elf_section_offset
3641 (output_bfd, info,
3642 input_section, rel->r_offset)
3643 + input_section
3644 ->output_section->vma
3645 + input_section->output_offset,
3646 picrel);
3647 }
3648 }
3649 else if ((bfd_get_section_flags (output_bfd,
3650 input_section->output_section)
3651 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3652 {
3653 if (_frvfdpic_osec_readonly_p (output_bfd,
3654 input_section
3655 ->output_section))
3656 {
3657 info->callbacks->warning
3658 (info,
3659 _("cannot emit dynamic relocations in read-only section"),
3660 name, input_bfd, input_section, rel->r_offset);
3661 return FALSE;
3662 }
3663 _frvfdpic_add_dyn_reloc (output_bfd,
3664 frvfdpic_gotrel_section (info),
3665 _bfd_elf_section_offset
3666 (output_bfd, info,
3667 input_section, rel->r_offset)
3668 + input_section
3669 ->output_section->vma
3670 + input_section->output_offset,
3671 r_type, dynindx, addend, picrel);
3672 }
3673 else
3674 addend += frvfdpic_got_section (info)->output_section->vma;
3675 }
3676
3677 /* We want the addend in-place because dynamic
3678 relocations are REL. Setting relocation to it should
3679 arrange for it to be installed. */
3680 relocation = addend - rel->r_addend;
3681 }
3682 check_segment[0] = check_segment[1] = got_segment;
3683 break;
3684
3685 case R_FRV_32:
3686 if (! IS_FDPIC (output_bfd))
3687 {
3688 check_segment[0] = check_segment[1] = -1;
3689 break;
3690 }
3691 /* Fall through. */
3692 case R_FRV_FUNCDESC_VALUE:
3693 {
3694 int dynindx;
3695 bfd_vma addend = rel->r_addend;
3696
3697 /* If the symbol is dynamic but binds locally, use
3698 section+offset. */
3699 if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
3700 {
3701 if (addend && r_type == R_FRV_FUNCDESC_VALUE)
3702 {
3703 info->callbacks->warning
3704 (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
3705 name, input_bfd, input_section, rel->r_offset);
3706 return FALSE;
3707 }
3708 dynindx = h->dynindx;
3709 }
3710 else
3711 {
3712 if (h)
3713 addend += h->root.u.def.value;
3714 else
3715 addend += sym->st_value;
3716 if (osec)
3717 addend += osec->output_offset;
3718 if (osec && osec->output_section
3719 && ! bfd_is_abs_section (osec->output_section)
3720 && ! bfd_is_und_section (osec->output_section))
3721 dynindx = elf_section_data (osec->output_section)->dynindx;
3722 else
3723 dynindx = 0;
3724 }
3725
3726 /* If we're linking an executable at a fixed address, we
3727 can omit the dynamic relocation as long as the symbol
3728 is defined in the current link unit (which is implied
3729 by its output section not being NULL). */
3730 if (info->executable && !info->pie
3731 && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3732 {
3733 if (osec)
3734 addend += osec->output_section->vma;
3735 if (IS_FDPIC (input_bfd)
3736 && (bfd_get_section_flags (output_bfd,
3737 input_section->output_section)
3738 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3739 {
3740 if (_frvfdpic_osec_readonly_p (output_bfd,
3741 input_section
3742 ->output_section))
3743 {
3744 info->callbacks->warning
3745 (info,
3746 _("cannot emit fixups in read-only section"),
3747 name, input_bfd, input_section, rel->r_offset);
3748 return FALSE;
3749 }
3750 if (!h || h->root.type != bfd_link_hash_undefweak)
3751 {
3752 _frvfdpic_add_rofixup (output_bfd,
3753 frvfdpic_gotfixup_section
3754 (info),
3755 _bfd_elf_section_offset
3756 (output_bfd, info,
3757 input_section, rel->r_offset)
3758 + input_section
3759 ->output_section->vma
3760 + input_section->output_offset,
3761 picrel);
3762 if (r_type == R_FRV_FUNCDESC_VALUE)
3763 _frvfdpic_add_rofixup
3764 (output_bfd,
3765 frvfdpic_gotfixup_section (info),
3766 _bfd_elf_section_offset
3767 (output_bfd, info,
3768 input_section, rel->r_offset)
3769 + input_section->output_section->vma
3770 + input_section->output_offset + 4, picrel);
3771 }
3772 }
3773 }
3774 else
3775 {
3776 if ((bfd_get_section_flags (output_bfd,
3777 input_section->output_section)
3778 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3779 {
3780 if (_frvfdpic_osec_readonly_p (output_bfd,
3781 input_section
3782 ->output_section))
3783 {
3784 info->callbacks->warning
3785 (info,
3786 _("cannot emit dynamic relocations in read-only section"),
3787 name, input_bfd, input_section, rel->r_offset);
3788 return FALSE;
3789 }
3790 _frvfdpic_add_dyn_reloc (output_bfd,
3791 frvfdpic_gotrel_section (info),
3792 _bfd_elf_section_offset
3793 (output_bfd, info,
3794 input_section, rel->r_offset)
3795 + input_section
3796 ->output_section->vma
3797 + input_section->output_offset,
3798 r_type, dynindx, addend, picrel);
3799 }
3800 else if (osec)
3801 addend += osec->output_section->vma;
3802 /* We want the addend in-place because dynamic
3803 relocations are REL. Setting relocation to it
3804 should arrange for it to be installed. */
3805 relocation = addend - rel->r_addend;
3806 }
3807
3808 if (r_type == R_FRV_FUNCDESC_VALUE)
3809 {
3810 /* If we've omitted the dynamic relocation, just emit
3811 the fixed addresses of the symbol and of the local
3812 GOT base offset. */
3813 if (info->executable && !info->pie
3814 && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3815 bfd_put_32 (output_bfd,
3816 frvfdpic_got_section (info)->output_section->vma
3817 + frvfdpic_got_section (info)->output_offset
3818 + frvfdpic_got_initial_offset (info),
3819 contents + rel->r_offset + 4);
3820 else
3821 /* A function descriptor used for lazy or local
3822 resolving is initialized such that its high word
3823 contains the output section index in which the
3824 PLT entries are located, and the low word
3825 contains the offset of the lazy PLT entry entry
3826 point into that section. */
3827 bfd_put_32 (output_bfd,
3828 h && ! FRVFDPIC_SYM_LOCAL (info, h)
3829 ? 0
3830 : _frvfdpic_osec_to_segment (output_bfd,
3831 sec
3832 ->output_section),
3833 contents + rel->r_offset + 4);
3834 }
3835 }
3836 check_segment[0] = check_segment[1] = got_segment;
3837 break;
3838
3839 case R_FRV_GPREL12:
3840 case R_FRV_GPRELU12:
3841 case R_FRV_GPREL32:
3842 case R_FRV_GPRELHI:
3843 case R_FRV_GPRELLO:
3844 check_segment[0] = gprel_segment;
3845 check_segment[1] = sec
3846 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3847 : (unsigned)-1;
3848 break;
3849
3850 case R_FRV_GETTLSOFF:
3851 relocation = frvfdpic_plt_section (info)->output_section->vma
3852 + frvfdpic_plt_section (info)->output_offset
3853 + picrel->tlsplt_entry;
3854 BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1
3855 && picrel->tlsdesc_entry);
3856 check_segment[0] = isec_segment;
3857 check_segment[1] = plt_segment;
3858 break;
3859
3860 case R_FRV_GOTTLSDESC12:
3861 case R_FRV_GOTTLSDESCHI:
3862 case R_FRV_GOTTLSDESCLO:
3863 BFD_ASSERT (picrel->tlsdesc_entry);
3864 relocation = picrel->tlsdesc_entry;
3865 check_segment[0] = tls_segment;
3866 check_segment[1] = sec
3867 && ! bfd_is_abs_section (sec)
3868 && ! bfd_is_und_section (sec)
3869 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3870 : tls_segment;
3871 break;
3872
3873 case R_FRV_TLSMOFF12:
3874 case R_FRV_TLSMOFFHI:
3875 case R_FRV_TLSMOFFLO:
3876 case R_FRV_TLSMOFF:
3877 check_segment[0] = tls_segment;
3878 if (! sec)
3879 check_segment[1] = -1;
3880 else if (bfd_is_abs_section (sec)
3881 || bfd_is_und_section (sec))
3882 {
3883 relocation = 0;
3884 check_segment[1] = tls_segment;
3885 }
3886 else if (sec->output_section)
3887 {
3888 relocation -= tls_biased_base (info);
3889 check_segment[1] =
3890 _frvfdpic_osec_to_segment (output_bfd, sec->output_section);
3891 }
3892 else
3893 check_segment[1] = -1;
3894 break;
3895
3896 case R_FRV_GOTTLSOFF12:
3897 case R_FRV_GOTTLSOFFHI:
3898 case R_FRV_GOTTLSOFFLO:
3899 BFD_ASSERT (picrel->tlsoff_entry);
3900 relocation = picrel->tlsoff_entry;
3901 check_segment[0] = tls_segment;
3902 check_segment[1] = sec
3903 && ! bfd_is_abs_section (sec)
3904 && ! bfd_is_und_section (sec)
3905 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3906 : tls_segment;
3907 break;
3908
3909 case R_FRV_TLSDESC_VALUE:
3910 case R_FRV_TLSOFF:
3911 /* These shouldn't be present in input object files. */
3912 check_segment[0] = check_segment[1] = isec_segment;
3913 break;
3914
3915 case R_FRV_TLSDESC_RELAX:
3916 case R_FRV_GETTLSOFF_RELAX:
3917 case R_FRV_TLSOFF_RELAX:
3918 /* These are just annotations for relaxation, nothing to do
3919 here. */
3920 continue;
3921
3922 default:
3923 check_segment[0] = isec_segment;
3924 check_segment[1] = sec
3925 ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3926 : (unsigned)-1;
3927 break;
3928 }
3929
3930 if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3931 {
3932 /* If you take this out, remove the #error from fdpic-static-6.d
3933 in the ld testsuite. */
3934 /* This helps catch problems in GCC while we can't do more
3935 than static linking. The idea is to test whether the
3936 input file basename is crt0.o only once. */
3937 if (silence_segment_error == 1)
3938 silence_segment_error =
3939 (strlen (input_bfd->filename) == 6
3940 && strcmp (input_bfd->filename, "crt0.o") == 0)
3941 || (strlen (input_bfd->filename) > 6
3942 && strcmp (input_bfd->filename
3943 + strlen (input_bfd->filename) - 7,
3944 "/crt0.o") == 0)
3945 ? -1 : 0;
3946 if (!silence_segment_error
3947 /* We don't want duplicate errors for undefined
3948 symbols. */
3949 && !(picrel && picrel->symndx == -1
3950 && picrel->d.h->root.type == bfd_link_hash_undefined))
3951 {
3952 if (info->shared || info->pie)
3953 (*_bfd_error_handler)
3954 (_("%B(%A+0x%lx): reloc against `%s': %s"),
3955 input_bfd, input_section, (long)rel->r_offset, name,
3956 _("relocation references a different segment"));
3957 else
3958 info->callbacks->warning
3959 (info,
3960 _("relocation references a different segment"),
3961 name, input_bfd, input_section, rel->r_offset);
3962 }
3963 if (!silence_segment_error && (info->shared || info->pie))
3964 return FALSE;
3965 elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
3966 }
3967
3968 switch (r_type)
3969 {
3970 case R_FRV_GOTOFFHI:
3971 case R_FRV_TLSMOFFHI:
3972 /* We need the addend to be applied before we shift the
3973 value right. */
3974 relocation += rel->r_addend;
3975 /* Fall through. */
3976 case R_FRV_GOTHI:
3977 case R_FRV_FUNCDESC_GOTHI:
3978 case R_FRV_FUNCDESC_GOTOFFHI:
3979 case R_FRV_GOTTLSOFFHI:
3980 case R_FRV_GOTTLSDESCHI:
3981 relocation >>= 16;
3982 /* Fall through. */
3983
3984 case R_FRV_GOTLO:
3985 case R_FRV_FUNCDESC_GOTLO:
3986 case R_FRV_GOTOFFLO:
3987 case R_FRV_FUNCDESC_GOTOFFLO:
3988 case R_FRV_GOTTLSOFFLO:
3989 case R_FRV_GOTTLSDESCLO:
3990 case R_FRV_TLSMOFFLO:
3991 relocation &= 0xffff;
3992 break;
3993
3994 default:
3995 break;
3996 }
3997
3998 switch (r_type)
3999 {
4000 case R_FRV_LABEL24:
4001 if (! IS_FDPIC (output_bfd) || ! picrel->plt)
4002 break;
4003 /* Fall through. */
4004
4005 /* When referencing a GOT entry, a function descriptor or a
4006 PLT, we don't want the addend to apply to the reference,
4007 but rather to the referenced symbol. The actual entry
4008 will have already been created taking the addend into
4009 account, so cancel it out here. */
4010 case R_FRV_GOT12:
4011 case R_FRV_GOTHI:
4012 case R_FRV_GOTLO:
4013 case R_FRV_FUNCDESC_GOT12:
4014 case R_FRV_FUNCDESC_GOTHI:
4015 case R_FRV_FUNCDESC_GOTLO:
4016 case R_FRV_FUNCDESC_GOTOFF12:
4017 case R_FRV_FUNCDESC_GOTOFFHI:
4018 case R_FRV_FUNCDESC_GOTOFFLO:
4019 case R_FRV_GETTLSOFF:
4020 case R_FRV_GOTTLSDESC12:
4021 case R_FRV_GOTTLSDESCHI:
4022 case R_FRV_GOTTLSDESCLO:
4023 case R_FRV_GOTTLSOFF12:
4024 case R_FRV_GOTTLSOFFHI:
4025 case R_FRV_GOTTLSOFFLO:
4026 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
4027 here, since we do want to apply the addend to the others.
4028 Note that we've applied the addend to GOTOFFHI before we
4029 shifted it right. */
4030 case R_FRV_GOTOFFHI:
4031 case R_FRV_TLSMOFFHI:
4032 relocation -= rel->r_addend;
4033 break;
4034
4035 default:
4036 break;
4037 }
4038
4039 if (r_type == R_FRV_HI16)
4040 r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
4041
4042 else if (r_type == R_FRV_LO16)
4043 r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
4044
4045 else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF)
4046 r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
4047 contents, relocation);
4048
4049 else if (r_type == R_FRV_GPREL12)
4050 r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
4051 contents, relocation);
4052
4053 else if (r_type == R_FRV_GPRELU12)
4054 r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
4055 contents, relocation);
4056
4057 else if (r_type == R_FRV_GPRELLO)
4058 r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
4059 contents, relocation);
4060
4061 else if (r_type == R_FRV_GPRELHI)
4062 r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
4063 contents, relocation);
4064
4065 else if (r_type == R_FRV_TLSOFF
4066 || r_type == R_FRV_TLSDESC_VALUE)
4067 r = bfd_reloc_notsupported;
4068
4069 else
4070 r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
4071 rel, relocation);
4072
4073 if (r != bfd_reloc_ok)
4074 {
4075 const char * msg = (const char *) NULL;
4076
4077 switch (r)
4078 {
4079 case bfd_reloc_overflow:
4080 r = info->callbacks->reloc_overflow
4081 (info, (h ? &h->root : NULL), name, howto->name,
4082 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4083 break;
4084
4085 case bfd_reloc_undefined:
4086 r = info->callbacks->undefined_symbol
4087 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
4088 break;
4089
4090 case bfd_reloc_outofrange:
4091 msg = _("internal error: out of range error");
4092 break;
4093
4094 case bfd_reloc_notsupported:
4095 msg = _("internal error: unsupported relocation error");
4096 break;
4097
4098 case bfd_reloc_dangerous:
4099 msg = _("internal error: dangerous relocation");
4100 break;
4101
4102 default:
4103 msg = _("internal error: unknown error");
4104 break;
4105 }
4106
4107 if (msg)
4108 {
4109 (*_bfd_error_handler)
4110 (_("%B(%A+0x%lx): reloc against `%s': %s"),
4111 input_bfd, input_section, (long)rel->r_offset, name, msg);
4112 return FALSE;
4113 }
4114
4115 if (! r)
4116 return FALSE;
4117 }
4118 }
4119
4120 return TRUE;
4121 }
4122 \f
4123 /* Return the section that should be marked against GC for a given
4124 relocation. */
4125
4126 static asection *
4127 elf32_frv_gc_mark_hook (asection *sec,
4128 struct bfd_link_info *info,
4129 Elf_Internal_Rela *rel,
4130 struct elf_link_hash_entry *h,
4131 Elf_Internal_Sym *sym)
4132 {
4133 if (h != NULL)
4134 switch (ELF32_R_TYPE (rel->r_info))
4135 {
4136 case R_FRV_GNU_VTINHERIT:
4137 case R_FRV_GNU_VTENTRY:
4138 return NULL;
4139 }
4140
4141 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4142 }
4143 \f
4144 /* Hook called by the linker routine which adds symbols from an object
4145 file. We use it to put .comm items in .scomm, and not .comm. */
4146
4147 static bfd_boolean
4148 elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4149 bfd *abfd;
4150 struct bfd_link_info *info;
4151 Elf_Internal_Sym *sym;
4152 const char **namep ATTRIBUTE_UNUSED;
4153 flagword *flagsp ATTRIBUTE_UNUSED;
4154 asection **secp;
4155 bfd_vma *valp;
4156 {
4157 if (sym->st_shndx == SHN_COMMON
4158 && !info->relocatable
4159 && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
4160 {
4161 /* Common symbols less than or equal to -G nn bytes are
4162 automatically put into .sbss. */
4163
4164 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
4165
4166 if (scomm == NULL)
4167 {
4168 scomm = bfd_make_section_with_flags (abfd, ".scommon",
4169 (SEC_ALLOC
4170 | SEC_IS_COMMON
4171 | SEC_LINKER_CREATED));
4172 if (scomm == NULL)
4173 return FALSE;
4174 }
4175
4176 *secp = scomm;
4177 *valp = sym->st_size;
4178 }
4179
4180 return TRUE;
4181 }
4182
4183 /* We need dynamic symbols for every section, since segments can
4184 relocate independently. */
4185 static bfd_boolean
4186 _frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
4187 struct bfd_link_info *info
4188 ATTRIBUTE_UNUSED,
4189 asection *p ATTRIBUTE_UNUSED)
4190 {
4191 switch (elf_section_data (p)->this_hdr.sh_type)
4192 {
4193 case SHT_PROGBITS:
4194 case SHT_NOBITS:
4195 /* If sh_type is yet undecided, assume it could be
4196 SHT_PROGBITS/SHT_NOBITS. */
4197 case SHT_NULL:
4198 return FALSE;
4199
4200 /* There shouldn't be section relative relocations
4201 against any other section. */
4202 default:
4203 return TRUE;
4204 }
4205 }
4206
4207 /* Create a .got section, as well as its additional info field. This
4208 is almost entirely copied from
4209 elflink.c:_bfd_elf_create_got_section(). */
4210
4211 static bfd_boolean
4212 _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
4213 {
4214 flagword flags, pltflags;
4215 asection *s;
4216 struct elf_link_hash_entry *h;
4217 struct bfd_link_hash_entry *bh;
4218 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4219 int ptralign;
4220 int offset;
4221
4222 /* This function may be called more than once. */
4223 s = bfd_get_section_by_name (abfd, ".got");
4224 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
4225 return TRUE;
4226
4227 /* Machine specific: although pointers are 32-bits wide, we want the
4228 GOT to be aligned to a 64-bit boundary, such that function
4229 descriptors in it can be accessed with 64-bit loads and
4230 stores. */
4231 ptralign = 3;
4232
4233 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4234 | SEC_LINKER_CREATED);
4235 pltflags = flags;
4236
4237 s = bfd_make_section_with_flags (abfd, ".got", flags);
4238 if (s == NULL
4239 || !bfd_set_section_alignment (abfd, s, ptralign))
4240 return FALSE;
4241
4242 if (bed->want_got_plt)
4243 {
4244 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
4245 if (s == NULL
4246 || !bfd_set_section_alignment (abfd, s, ptralign))
4247 return FALSE;
4248 }
4249
4250 if (bed->want_got_sym)
4251 {
4252 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4253 (or .got.plt) section. We don't do this in the linker script
4254 because we don't want to define the symbol if we are not creating
4255 a global offset table. */
4256 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
4257 elf_hash_table (info)->hgot = h;
4258 if (h == NULL)
4259 return FALSE;
4260
4261 /* Machine-specific: we want the symbol for executables as
4262 well. */
4263 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4264 return FALSE;
4265 }
4266
4267 /* The first bit of the global offset table is the header. */
4268 s->size += bed->got_header_size;
4269
4270 /* This is the machine-specific part. Create and initialize section
4271 data for the got. */
4272 if (IS_FDPIC (abfd))
4273 {
4274 frvfdpic_got_section (info) = s;
4275 frvfdpic_relocs_info (info) = htab_try_create (1,
4276 frvfdpic_relocs_info_hash,
4277 frvfdpic_relocs_info_eq,
4278 (htab_del) NULL);
4279 if (! frvfdpic_relocs_info (info))
4280 return FALSE;
4281
4282 s = bfd_make_section_with_flags (abfd, ".rel.got",
4283 (flags | SEC_READONLY));
4284 if (s == NULL
4285 || ! bfd_set_section_alignment (abfd, s, 2))
4286 return FALSE;
4287
4288 frvfdpic_gotrel_section (info) = s;
4289
4290 /* Machine-specific. */
4291 s = bfd_make_section_with_flags (abfd, ".rofixup",
4292 (flags | SEC_READONLY));
4293 if (s == NULL
4294 || ! bfd_set_section_alignment (abfd, s, 2))
4295 return FALSE;
4296
4297 frvfdpic_gotfixup_section (info) = s;
4298 offset = -2048;
4299 flags = BSF_GLOBAL;
4300 }
4301 else
4302 {
4303 offset = 2048;
4304 flags = BSF_GLOBAL | BSF_WEAK;
4305 }
4306
4307 /* Define _gp in .rofixup, for FDPIC, or .got otherwise. If it
4308 turns out that we're linking with a different linker script, the
4309 linker script will override it. */
4310 bh = NULL;
4311 if (!(_bfd_generic_link_add_one_symbol
4312 (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
4313 bed->collect, &bh)))
4314 return FALSE;
4315 h = (struct elf_link_hash_entry *) bh;
4316 h->def_regular = 1;
4317 h->type = STT_OBJECT;
4318 /* h->other = STV_HIDDEN; */ /* Should we? */
4319
4320 /* Machine-specific: we want the symbol for executables as well. */
4321 if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
4322 return FALSE;
4323
4324 if (!IS_FDPIC (abfd))
4325 return TRUE;
4326
4327 /* FDPIC supports Thread Local Storage, and this may require a
4328 procedure linkage table for TLS PLT entries. */
4329
4330 /* This is mostly copied from
4331 elflink.c:_bfd_elf_create_dynamic_sections(). */
4332
4333 flags = pltflags;
4334 pltflags |= SEC_CODE;
4335 if (bed->plt_not_loaded)
4336 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
4337 if (bed->plt_readonly)
4338 pltflags |= SEC_READONLY;
4339
4340 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
4341 if (s == NULL
4342 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
4343 return FALSE;
4344 /* FRV-specific: remember it. */
4345 frvfdpic_plt_section (info) = s;
4346
4347 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4348 .plt section. */
4349 if (bed->want_plt_sym)
4350 {
4351 h = _bfd_elf_define_linkage_sym (abfd, info, s,
4352 "_PROCEDURE_LINKAGE_TABLE_");
4353 elf_hash_table (info)->hplt = h;
4354 if (h == NULL)
4355 return FALSE;
4356 }
4357
4358 /* FRV-specific: we want rel relocations for the plt. */
4359 s = bfd_make_section_with_flags (abfd, ".rel.plt",
4360 flags | SEC_READONLY);
4361 if (s == NULL
4362 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4363 return FALSE;
4364 /* FRV-specific: remember it. */
4365 frvfdpic_pltrel_section (info) = s;
4366
4367 return TRUE;
4368 }
4369
4370 /* Make sure the got and plt sections exist, and that our pointers in
4371 the link hash table point to them. */
4372
4373 static bfd_boolean
4374 elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4375 {
4376 /* This is mostly copied from
4377 elflink.c:_bfd_elf_create_dynamic_sections(). */
4378 flagword flags;
4379 asection *s;
4380 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4381
4382 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4383 | SEC_LINKER_CREATED);
4384
4385 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4386 .rel[a].bss sections. */
4387
4388 /* FRV-specific: we want to create the GOT and the PLT in the FRV
4389 way. */
4390 if (! _frv_create_got_section (abfd, info))
4391 return FALSE;
4392
4393 /* FRV-specific: make sure we created everything we wanted. */
4394 BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
4395 && frvfdpic_gotfixup_section (info)
4396 && frvfdpic_plt_section (info)
4397 && frvfdpic_pltrel_section (info));
4398
4399 if (bed->want_dynbss)
4400 {
4401 /* The .dynbss section is a place to put symbols which are defined
4402 by dynamic objects, are referenced by regular objects, and are
4403 not functions. We must allocate space for them in the process
4404 image and use a R_*_COPY reloc to tell the dynamic linker to
4405 initialize them at run time. The linker script puts the .dynbss
4406 section into the .bss section of the final image. */
4407 s = bfd_make_section_with_flags (abfd, ".dynbss",
4408 SEC_ALLOC | SEC_LINKER_CREATED);
4409 if (s == NULL)
4410 return FALSE;
4411
4412 /* The .rel[a].bss section holds copy relocs. This section is not
4413 normally needed. We need to create it here, though, so that the
4414 linker will map it to an output section. We can't just create it
4415 only if we need it, because we will not know whether we need it
4416 until we have seen all the input files, and the first time the
4417 main linker code calls BFD after examining all the input files
4418 (size_dynamic_sections) the input sections have already been
4419 mapped to the output sections. If the section turns out not to
4420 be needed, we can discard it later. We will never need this
4421 section when generating a shared object, since they do not use
4422 copy relocs. */
4423 if (! info->shared)
4424 {
4425 s = bfd_make_section_with_flags (abfd,
4426 (bed->default_use_rela_p
4427 ? ".rela.bss" : ".rel.bss"),
4428 flags | SEC_READONLY);
4429 if (s == NULL
4430 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4431 return FALSE;
4432 }
4433 }
4434
4435 return TRUE;
4436 }
4437
4438 /* Compute the total GOT and PLT size required by each symbol in each
4439 range. Symbols may require up to 4 words in the GOT: an entry
4440 pointing to the symbol, an entry pointing to its function
4441 descriptor, and a private function descriptors taking two
4442 words. */
4443
4444 static void
4445 _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4446 struct _frvfdpic_dynamic_got_info *dinfo)
4447 {
4448 /* Allocate space for a GOT entry pointing to the symbol. */
4449 if (entry->got12)
4450 dinfo->got12 += 4;
4451 else if (entry->gotlos)
4452 dinfo->gotlos += 4;
4453 else if (entry->gothilo)
4454 dinfo->gothilo += 4;
4455 else
4456 entry->relocs32--;
4457 entry->relocs32++;
4458
4459 /* Allocate space for a GOT entry pointing to the function
4460 descriptor. */
4461 if (entry->fdgot12)
4462 dinfo->got12 += 4;
4463 else if (entry->fdgotlos)
4464 dinfo->gotlos += 4;
4465 else if (entry->fdgothilo)
4466 dinfo->gothilo += 4;
4467 else
4468 entry->relocsfd--;
4469 entry->relocsfd++;
4470
4471 /* Decide whether we need a PLT entry, a function descriptor in the
4472 GOT, and a lazy PLT entry for this symbol. */
4473 entry->plt = entry->call
4474 && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4475 && elf_hash_table (dinfo->info)->dynamic_sections_created;
4476 entry->privfd = entry->plt
4477 || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4478 || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4479 && (entry->symndx != -1
4480 || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4481 entry->lazyplt = entry->privfd
4482 && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4483 && ! (dinfo->info->flags & DF_BIND_NOW)
4484 && elf_hash_table (dinfo->info)->dynamic_sections_created;
4485
4486 /* Allocate space for a function descriptor. */
4487 if (entry->fdgoff12)
4488 dinfo->fd12 += 8;
4489 else if (entry->fdgofflos)
4490 dinfo->fdlos += 8;
4491 else if (entry->privfd && entry->plt)
4492 dinfo->fdplt += 8;
4493 else if (entry->privfd)
4494 dinfo->fdhilo += 8;
4495 else
4496 entry->relocsfdv--;
4497 entry->relocsfdv++;
4498
4499 if (entry->lazyplt)
4500 dinfo->lzplt += 8;
4501 }
4502
4503 /* Compute the total GOT size required by each TLS symbol in each
4504 range. Symbols may require up to 5 words in the GOT: an entry
4505 holding the TLS offset for the symbol, and an entry with a full TLS
4506 descriptor taking 4 words. */
4507
4508 static void
4509 _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4510 struct _frvfdpic_dynamic_got_info *dinfo,
4511 bfd_boolean subtract)
4512 {
4513 const int l = subtract ? -1 : 1;
4514
4515 /* Allocate space for a GOT entry with the TLS offset of the
4516 symbol. */
4517 if (entry->tlsoff12)
4518 dinfo->got12 += 4 * l;
4519 else if (entry->tlsofflos)
4520 dinfo->gotlos += 4 * l;
4521 else if (entry->tlsoffhilo)
4522 dinfo->gothilo += 4 * l;
4523 else
4524 entry->relocstlsoff -= l;
4525 entry->relocstlsoff += l;
4526
4527 /* If there's any TLSOFF relocation, mark the output file as not
4528 suitable for dlopening. This mark will remain even if we relax
4529 all such relocations, but this is not a problem, since we'll only
4530 do so for executables, and we definitely don't want anyone
4531 dlopening executables. */
4532 if (entry->relocstlsoff)
4533 dinfo->info->flags |= DF_STATIC_TLS;
4534
4535 /* Allocate space for a TLS descriptor. */
4536 if (entry->tlsdesc12)
4537 dinfo->tlsd12 += 8 * l;
4538 else if (entry->tlsdesclos)
4539 dinfo->tlsdlos += 8 * l;
4540 else if (entry->tlsplt)
4541 dinfo->tlsdplt += 8 * l;
4542 else if (entry->tlsdeschilo)
4543 dinfo->tlsdhilo += 8 * l;
4544 else
4545 entry->relocstlsd -= l;
4546 entry->relocstlsd += l;
4547 }
4548
4549 /* Compute the number of dynamic relocations and fixups that a symbol
4550 requires, and add (or subtract) from the grand and per-symbol
4551 totals. */
4552
4553 static void
4554 _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4555 struct _frvfdpic_dynamic_got_info *dinfo,
4556 bfd_boolean subtract)
4557 {
4558 bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
4559
4560 if (!dinfo->info->executable || dinfo->info->pie)
4561 {
4562 relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4563 + entry->relocstlsd;
4564
4565 /* In the executable, TLS relocations to symbols that bind
4566 locally (including those that resolve to global TLS offsets)
4567 are resolved immediately, without any need for fixups or
4568 dynamic relocations. In shared libraries, however, we must
4569 emit dynamic relocations even for local symbols, because we
4570 don't know the module id the library is going to get at
4571 run-time, nor its TLS base offset. */
4572 if (!dinfo->info->executable
4573 || (entry->symndx == -1
4574 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4575 relocs += entry->relocstlsoff;
4576 }
4577 else
4578 {
4579 if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4580 {
4581 if (entry->symndx != -1
4582 || entry->d.h->root.type != bfd_link_hash_undefweak)
4583 fixups += entry->relocs32 + 2 * entry->relocsfdv;
4584 fixups += entry->relocstlsd;
4585 tlsrets += entry->relocstlsd;
4586 }
4587 else
4588 {
4589 relocs += entry->relocs32 + entry->relocsfdv
4590 + entry->relocstlsoff + entry->relocstlsd;
4591 }
4592
4593 if (entry->symndx != -1
4594 || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4595 {
4596 if (entry->symndx != -1
4597 || entry->d.h->root.type != bfd_link_hash_undefweak)
4598 fixups += entry->relocsfd;
4599 }
4600 else
4601 relocs += entry->relocsfd;
4602 }
4603
4604 if (subtract)
4605 {
4606 relocs = - relocs;
4607 fixups = - fixups;
4608 tlsrets = - tlsrets;
4609 }
4610
4611 entry->dynrelocs += relocs;
4612 entry->fixups += fixups;
4613 dinfo->relocs += relocs;
4614 dinfo->fixups += fixups;
4615 dinfo->tls_ret_refs += tlsrets;
4616 }
4617
4618 /* Look for opportunities to relax TLS relocations. We can assume
4619 we're linking the main executable or a static-tls library, since
4620 otherwise we wouldn't have got here. When relaxing, we have to
4621 first undo any previous accounting of TLS uses of fixups, dynamic
4622 relocations, GOT and PLT entries. */
4623
4624 static void
4625 _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4626 struct _frvfdpic_dynamic_got_info *dinfo,
4627 bfd_boolean relaxing)
4628 {
4629 bfd_boolean changed = ! relaxing;
4630
4631 BFD_ASSERT (dinfo->info->executable
4632 || (dinfo->info->flags & DF_STATIC_TLS));
4633
4634 if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4635 {
4636 if (! changed)
4637 {
4638 _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4639 _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4640 changed = TRUE;
4641 }
4642
4643 /* When linking an executable, we can always decay GOTTLSDESC to
4644 TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4645 When linking a static-tls shared library, using TLSMOFF is
4646 not an option, but we can still use GOTTLSOFF. When decaying
4647 to GOTTLSOFF, we must keep the GOT entry in range. We know
4648 it has to fit because we'll be trading the 4 words of hte TLS
4649 descriptor for a single word in the same range. */
4650 if (! dinfo->info->executable
4651 || (entry->symndx == -1
4652 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4653 {
4654 entry->tlsoff12 |= entry->tlsdesc12;
4655 entry->tlsofflos |= entry->tlsdesclos;
4656 entry->tlsoffhilo |= entry->tlsdeschilo;
4657 }
4658
4659 entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4660 }
4661
4662 /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4663 main executable. We have to check whether the symbol's TLSOFF is
4664 in range for a setlos. For symbols with a hash entry, we can
4665 determine exactly what to do; for others locals, we don't have
4666 addresses handy, so we use the size of the TLS section as an
4667 approximation. If we get it wrong, we'll retain a GOT entry
4668 holding the TLS offset (without dynamic relocations or fixups),
4669 but we'll still optimize away the loads from it. Since TLS sizes
4670 are generally very small, it's probably not worth attempting to
4671 do better than this. */
4672 if ((entry->tlsplt
4673 || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4674 && dinfo->info->executable && relaxing
4675 && ((entry->symndx == -1
4676 && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4677 /* The above may hold for an undefweak TLS symbol, so make
4678 sure we don't have this case before accessing def.value
4679 and def.section. */
4680 && (entry->d.h->root.type == bfd_link_hash_undefweak
4681 || (bfd_vma)(entry->d.h->root.u.def.value
4682 + (entry->d.h->root.u.def.section
4683 ->output_section->vma)
4684 + entry->d.h->root.u.def.section->output_offset
4685 + entry->addend
4686 - tls_biased_base (dinfo->info)
4687 + 32768) < (bfd_vma)65536))
4688 || (entry->symndx != -1
4689 && (elf_hash_table (dinfo->info)->tls_sec->size
4690 + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
4691 {
4692 if (! changed)
4693 {
4694 _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4695 _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4696 changed = TRUE;
4697 }
4698
4699 entry->tlsplt =
4700 entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4701 }
4702
4703 /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4704 have a #gottlsoff12 relocation for this entry, or if we can fit
4705 one more in the 12-bit (and 16-bit) ranges. */
4706 if (entry->tlsplt
4707 && (entry->tlsoff12
4708 || (relaxing
4709 && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4
4710 && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12
4711 + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos
4712 <= 65536 - 12 - 4))))
4713 {
4714 if (! changed)
4715 {
4716 _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4717 _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4718 changed = TRUE;
4719 }
4720
4721 entry->tlsoff12 = 1;
4722 entry->tlsplt = 0;
4723 }
4724
4725 if (changed)
4726 {
4727 _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4728 _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4729 }
4730
4731 return;
4732 }
4733
4734 /* Compute the total GOT and PLT size required by each symbol in each range. *
4735 Symbols may require up to 4 words in the GOT: an entry pointing to
4736 the symbol, an entry pointing to its function descriptor, and a
4737 private function descriptors taking two words. */
4738
4739 static int
4740 _frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
4741 {
4742 struct frvfdpic_relocs_info *entry = *entryp;
4743 struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
4744
4745 _frvfdpic_count_nontls_entries (entry, dinfo);
4746
4747 if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
4748 _frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
4749 else
4750 {
4751 _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4752 _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4753 }
4754
4755 return 1;
4756 }
4757
4758 /* Determine the positive and negative ranges to be used by each
4759 offset range in the GOT. FDCUR and CUR, that must be aligned to a
4760 double-word boundary, are the minimum (negative) and maximum
4761 (positive) GOT offsets already used by previous ranges, except for
4762 an ODD entry that may have been left behind. GOT and FD indicate
4763 the size of GOT entries and function descriptors that must be
4764 placed within the range from -WRAP to WRAP. If there's room left,
4765 up to FDPLT bytes should be reserved for additional function
4766 descriptors. */
4767
4768 inline static bfd_signed_vma
4769 _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
4770 bfd_signed_vma fdcur,
4771 bfd_signed_vma odd,
4772 bfd_signed_vma cur,
4773 bfd_vma got,
4774 bfd_vma fd,
4775 bfd_vma fdplt,
4776 bfd_vma tlsd,
4777 bfd_vma tlsdplt,
4778 bfd_vma wrap)
4779 {
4780 bfd_signed_vma wrapmin = -wrap;
4781 const bfd_vma tdescsz = 8;
4782
4783 /* Start at the given initial points. */
4784 gad->fdcur = fdcur;
4785 gad->cur = cur;
4786
4787 /* If we had an incoming odd word and we have any got entries that
4788 are going to use it, consume it, otherwise leave gad->odd at
4789 zero. We might force gad->odd to zero and return the incoming
4790 odd such that it is used by the next range, but then GOT entries
4791 might appear to be out of order and we wouldn't be able to
4792 shorten the GOT by one word if it turns out to end with an
4793 unpaired GOT entry. */
4794 if (odd && got)
4795 {
4796 gad->odd = odd;
4797 got -= 4;
4798 odd = 0;
4799 }
4800 else
4801 gad->odd = 0;
4802
4803 /* If we're left with an unpaired GOT entry, compute its location
4804 such that we can return it. Otherwise, if got doesn't require an
4805 odd number of words here, either odd was already zero in the
4806 block above, or it was set to zero because got was non-zero, or
4807 got was already zero. In the latter case, we want the value of
4808 odd to carry over to the return statement, so we don't want to
4809 reset odd unless the condition below is true. */
4810 if (got & 4)
4811 {
4812 odd = cur + got;
4813 got += 4;
4814 }
4815
4816 /* Compute the tentative boundaries of this range. */
4817 gad->max = cur + got;
4818 gad->min = fdcur - fd;
4819 gad->fdplt = 0;
4820
4821 /* If function descriptors took too much space, wrap some of them
4822 around. */
4823 if (gad->min < wrapmin)
4824 {
4825 gad->max += wrapmin - gad->min;
4826 gad->tmin = gad->min = wrapmin;
4827 }
4828
4829 /* If GOT entries took too much space, wrap some of them around.
4830 This may well cause gad->min to become lower than wrapmin. This
4831 will cause a relocation overflow later on, so we don't have to
4832 report it here . */
4833 if ((bfd_vma) gad->max > wrap)
4834 {
4835 gad->min -= gad->max - wrap;
4836 gad->max = wrap;
4837 }
4838
4839 /* Add TLS descriptors. */
4840 gad->tmax = gad->max + tlsd;
4841 gad->tmin = gad->min;
4842 gad->tlsdplt = 0;
4843
4844 /* If TLS descriptors took too much space, wrap an integral number
4845 of them around. */
4846 if ((bfd_vma) gad->tmax > wrap)
4847 {
4848 bfd_vma wrapsize = gad->tmax - wrap;
4849
4850 wrapsize += tdescsz / 2;
4851 wrapsize &= ~ tdescsz / 2;
4852
4853 gad->tmin -= wrapsize;
4854 gad->tmax -= wrapsize;
4855 }
4856
4857 /* If there is space left and we have function descriptors
4858 referenced in PLT entries that could take advantage of shorter
4859 offsets, place them now. */
4860 if (fdplt && gad->tmin > wrapmin)
4861 {
4862 bfd_vma fds;
4863
4864 if ((bfd_vma) (gad->tmin - wrapmin) < fdplt)
4865 fds = gad->tmin - wrapmin;
4866 else
4867 fds = fdplt;
4868
4869 fdplt -= fds;
4870 gad->min -= fds;
4871 gad->tmin -= fds;
4872 gad->fdplt += fds;
4873 }
4874
4875 /* If there is more space left, try to place some more function
4876 descriptors for PLT entries. */
4877 if (fdplt && (bfd_vma) gad->tmax < wrap)
4878 {
4879 bfd_vma fds;
4880
4881 if ((bfd_vma) (wrap - gad->tmax) < fdplt)
4882 fds = wrap - gad->tmax;
4883 else
4884 fds = fdplt;
4885
4886 fdplt -= fds;
4887 gad->max += fds;
4888 gad->tmax += fds;
4889 gad->fdplt += fds;
4890 }
4891
4892 /* If there is space left and we have TLS descriptors referenced in
4893 PLT entries that could take advantage of shorter offsets, place
4894 them now. */
4895 if (tlsdplt && gad->tmin > wrapmin)
4896 {
4897 bfd_vma tlsds;
4898
4899 if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt)
4900 tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2);
4901 else
4902 tlsds = tlsdplt;
4903
4904 tlsdplt -= tlsds;
4905 gad->tmin -= tlsds;
4906 gad->tlsdplt += tlsds;
4907 }
4908
4909 /* If there is more space left, try to place some more TLS
4910 descriptors for PLT entries. Although we could try to fit an
4911 additional TLS descriptor with half of it just before before the
4912 wrap point and another right past the wrap point, this might
4913 cause us to run out of space for the next region, so don't do
4914 it. */
4915 if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2)
4916 {
4917 bfd_vma tlsds;
4918
4919 if ((bfd_vma) (wrap - gad->tmax) < tlsdplt)
4920 tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2);
4921 else
4922 tlsds = tlsdplt;
4923
4924 tlsdplt -= tlsds;
4925 gad->tmax += tlsds;
4926 gad->tlsdplt += tlsds;
4927 }
4928
4929 /* If odd was initially computed as an offset past the wrap point,
4930 wrap it around. */
4931 if (odd > gad->max)
4932 odd = gad->min + odd - gad->max;
4933
4934 /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
4935 before returning, so do it here too. This guarantees that,
4936 should cur and fdcur meet at the wrap point, they'll both be
4937 equal to min. */
4938 if (gad->cur == gad->max)
4939 gad->cur = gad->min;
4940
4941 /* Ditto for _frvfdpic_get_tlsdesc_entry(). */
4942 gad->tcur = gad->max;
4943 if (gad->tcur == gad->tmax)
4944 gad->tcur = gad->tmin;
4945
4946 return odd;
4947 }
4948
4949 /* Compute the location of the next GOT entry, given the allocation
4950 data for a range. */
4951
4952 inline static bfd_signed_vma
4953 _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4954 {
4955 bfd_signed_vma ret;
4956
4957 if (gad->odd)
4958 {
4959 /* If there was an odd word left behind, use it. */
4960 ret = gad->odd;
4961 gad->odd = 0;
4962 }
4963 else
4964 {
4965 /* Otherwise, use the word pointed to by cur, reserve the next
4966 as an odd word, and skip to the next pair of words, possibly
4967 wrapping around. */
4968 ret = gad->cur;
4969 gad->odd = gad->cur + 4;
4970 gad->cur += 8;
4971 if (gad->cur == gad->max)
4972 gad->cur = gad->min;
4973 }
4974
4975 return ret;
4976 }
4977
4978 /* Compute the location of the next function descriptor entry in the
4979 GOT, given the allocation data for a range. */
4980
4981 inline static bfd_signed_vma
4982 _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4983 {
4984 /* If we're at the bottom, wrap around, and only then allocate the
4985 next pair of words. */
4986 if (gad->fdcur == gad->min)
4987 gad->fdcur = gad->max;
4988 return gad->fdcur -= 8;
4989 }
4990
4991 /* Compute the location of the next TLS descriptor entry in the GOT,
4992 given the allocation data for a range. */
4993 inline static bfd_signed_vma
4994 _frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4995 {
4996 bfd_signed_vma ret;
4997
4998 ret = gad->tcur;
4999
5000 gad->tcur += 8;
5001
5002 /* If we're at the top of the region, wrap around to the bottom. */
5003 if (gad->tcur == gad->tmax)
5004 gad->tcur = gad->tmin;
5005
5006 return ret;
5007 }
5008
5009 /* Assign GOT offsets for every GOT entry and function descriptor.
5010 Doing everything in a single pass is tricky. */
5011
5012 static int
5013 _frvfdpic_assign_got_entries (void **entryp, void *info_)
5014 {
5015 struct frvfdpic_relocs_info *entry = *entryp;
5016 struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5017
5018 if (entry->got12)
5019 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5020 else if (entry->gotlos)
5021 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5022 else if (entry->gothilo)
5023 entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5024
5025 if (entry->fdgot12)
5026 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5027 else if (entry->fdgotlos)
5028 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5029 else if (entry->fdgothilo)
5030 entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5031
5032 if (entry->fdgoff12)
5033 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5034 else if (entry->plt && dinfo->got12.fdplt)
5035 {
5036 dinfo->got12.fdplt -= 8;
5037 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5038 }
5039 else if (entry->fdgofflos)
5040 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5041 else if (entry->plt && dinfo->gotlos.fdplt)
5042 {
5043 dinfo->gotlos.fdplt -= 8;
5044 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5045 }
5046 else if (entry->plt)
5047 {
5048 dinfo->gothilo.fdplt -= 8;
5049 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5050 }
5051 else if (entry->privfd)
5052 entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5053
5054 if (entry->tlsoff12)
5055 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5056 else if (entry->tlsofflos)
5057 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5058 else if (entry->tlsoffhilo)
5059 entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5060
5061 if (entry->tlsdesc12)
5062 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5063 else if (entry->tlsplt && dinfo->got12.tlsdplt)
5064 {
5065 dinfo->got12.tlsdplt -= 8;
5066 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5067 }
5068 else if (entry->tlsdesclos)
5069 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5070 else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5071 {
5072 dinfo->gotlos.tlsdplt -= 8;
5073 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5074 }
5075 else if (entry->tlsplt)
5076 {
5077 dinfo->gothilo.tlsdplt -= 8;
5078 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5079 }
5080 else if (entry->tlsdeschilo)
5081 entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5082
5083 return 1;
5084 }
5085
5086 /* Assign GOT offsets to private function descriptors used by PLT
5087 entries (or referenced by 32-bit offsets), as well as PLT entries
5088 and lazy PLT entries. */
5089
5090 static int
5091 _frvfdpic_assign_plt_entries (void **entryp, void *info_)
5092 {
5093 struct frvfdpic_relocs_info *entry = *entryp;
5094 struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5095
5096 if (entry->privfd)
5097 BFD_ASSERT (entry->fd_entry);
5098
5099 if (entry->plt)
5100 {
5101 int size;
5102
5103 /* We use the section's raw size to mark the location of the
5104 next PLT entry. */
5105 entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5106
5107 /* Figure out the length of this PLT entry based on the
5108 addressing mode we need to reach the function descriptor. */
5109 BFD_ASSERT (entry->fd_entry);
5110 if (entry->fd_entry >= -(1 << (12 - 1))
5111 && entry->fd_entry < (1 << (12 - 1)))
5112 size = 8;
5113 else if (entry->fd_entry >= -(1 << (16 - 1))
5114 && entry->fd_entry < (1 << (16 - 1)))
5115 size = 12;
5116 else
5117 size = 16;
5118
5119 frvfdpic_plt_section (dinfo->g.info)->size += size;
5120 }
5121
5122 if (entry->lazyplt)
5123 {
5124 entry->lzplt_entry = dinfo->g.lzplt;
5125 dinfo->g.lzplt += 8;
5126 /* If this entry is the one that gets the resolver stub, account
5127 for the additional instruction. */
5128 if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5129 == FRVFDPIC_LZPLT_RESOLV_LOC)
5130 dinfo->g.lzplt += 4;
5131 }
5132
5133 if (entry->tlsplt)
5134 {
5135 int size;
5136
5137 entry->tlsplt_entry
5138 = frvfdpic_plt_section (dinfo->g.info)->size;
5139
5140 if (dinfo->g.info->executable
5141 && (entry->symndx != -1
5142 || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5143 {
5144 if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5145 /* FIXME: here we use the size of the TLS section
5146 as an upper bound for the value of the TLS
5147 symbol, because we may not know the exact value
5148 yet. If we get it wrong, we'll just waste a
5149 word in the PLT, and we should never get even
5150 close to 32 KiB of TLS anyway. */
5151 && elf_hash_table (dinfo->g.info)->tls_sec
5152 && (elf_hash_table (dinfo->g.info)->tls_sec->size
5153 + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5154 size = 8;
5155 else
5156 size = 12;
5157 }
5158 else if (entry->tlsoff_entry)
5159 {
5160 if (entry->tlsoff_entry >= -(1 << (12 - 1))
5161 && entry->tlsoff_entry < (1 << (12 - 1)))
5162 size = 8;
5163 else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5164 && entry->tlsoff_entry < (1 << (16 - 1)))
5165 size = 12;
5166 else
5167 size = 16;
5168 }
5169 else
5170 {
5171 BFD_ASSERT (entry->tlsdesc_entry);
5172
5173 if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5174 && entry->tlsdesc_entry < (1 << (12 - 1)))
5175 size = 8;
5176 else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5177 && entry->tlsdesc_entry < (1 << (16 - 1)))
5178 size = 12;
5179 else
5180 size = 16;
5181 }
5182
5183 frvfdpic_plt_section (dinfo->g.info)->size += size;
5184 }
5185
5186 return 1;
5187 }
5188
5189 /* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5190 _frvfdpic_assign_plt_entries. */
5191
5192 static int
5193 _frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
5194 {
5195 struct frvfdpic_relocs_info *entry = *entryp;
5196
5197 entry->got_entry = 0;
5198 entry->fdgot_entry = 0;
5199 entry->fd_entry = 0;
5200 entry->plt_entry = (bfd_vma)-1;
5201 entry->lzplt_entry = (bfd_vma)-1;
5202 entry->tlsoff_entry = 0;
5203 entry->tlsdesc_entry = 0;
5204 entry->tlsplt_entry = (bfd_vma)-1;
5205
5206 return 1;
5207 }
5208
5209 /* Follow indirect and warning hash entries so that each got entry
5210 points to the final symbol definition. P must point to a pointer
5211 to the hash table we're traversing. Since this traversal may
5212 modify the hash table, we set this pointer to NULL to indicate
5213 we've made a potentially-destructive change to the hash table, so
5214 the traversal must be restarted. */
5215 static int
5216 _frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
5217 {
5218 struct frvfdpic_relocs_info *entry = *entryp;
5219 htab_t *htab = p;
5220
5221 if (entry->symndx == -1)
5222 {
5223 struct elf_link_hash_entry *h = entry->d.h;
5224 struct frvfdpic_relocs_info *oentry;
5225
5226 while (h->root.type == bfd_link_hash_indirect
5227 || h->root.type == bfd_link_hash_warning)
5228 h = (struct elf_link_hash_entry *)h->root.u.i.link;
5229
5230 if (entry->d.h == h)
5231 return 1;
5232
5233 oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5234 NO_INSERT);
5235
5236 if (oentry)
5237 {
5238 /* Merge the two entries. */
5239 frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5240 htab_clear_slot (*htab, entryp);
5241 return 1;
5242 }
5243
5244 entry->d.h = h;
5245
5246 /* If we can't find this entry with the new bfd hash, re-insert
5247 it, and get the traversal restarted. */
5248 if (! htab_find (*htab, entry))
5249 {
5250 htab_clear_slot (*htab, entryp);
5251 entryp = htab_find_slot (*htab, entry, INSERT);
5252 if (! *entryp)
5253 *entryp = entry;
5254 /* Abort the traversal, since the whole table may have
5255 moved, and leave it up to the parent to restart the
5256 process. */
5257 *(htab_t *)p = NULL;
5258 return 0;
5259 }
5260 }
5261
5262 return 1;
5263 }
5264
5265 /* Compute the total size of the GOT, the PLT, the dynamic relocations
5266 section and the rofixup section. Assign locations for GOT and PLT
5267 entries. */
5268
5269 static bfd_boolean
5270 _frvfdpic_size_got_plt (bfd *output_bfd,
5271 struct _frvfdpic_dynamic_got_plt_info *gpinfop)
5272 {
5273 bfd_signed_vma odd;
5274 bfd_vma limit, tlslimit;
5275 struct bfd_link_info *info = gpinfop->g.info;
5276 bfd *dynobj = elf_hash_table (info)->dynobj;
5277
5278 memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g,
5279 sizeof (gpinfop->g));
5280
5281 odd = 12;
5282 /* Compute the total size taken by entries in the 12-bit and 16-bit
5283 ranges, to tell how many PLT function descriptors we can bring
5284 into the 12-bit range without causing the 16-bit range to
5285 overflow. */
5286 limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos
5287 + gpinfop->g.fd12 + gpinfop->g.fdlos
5288 + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos;
5289 if (limit < (bfd_vma)1 << 16)
5290 limit = ((bfd_vma)1 << 16) - limit;
5291 else
5292 limit = 0;
5293 if (gpinfop->g.fdplt < limit)
5294 {
5295 tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8;
5296 limit = gpinfop->g.fdplt;
5297 }
5298 else
5299 tlslimit = 0;
5300 if (gpinfop->g.tlsdplt < tlslimit)
5301 tlslimit = gpinfop->g.tlsdplt;
5302
5303 /* Determine the ranges of GOT offsets that we can use for each
5304 range of addressing modes. */
5305 odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12,
5306 0,
5307 odd,
5308 16,
5309 gpinfop->g.got12,
5310 gpinfop->g.fd12,
5311 limit,
5312 gpinfop->g.tlsd12,
5313 tlslimit,
5314 (bfd_vma)1 << (12-1));
5315 odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos,
5316 gpinfop->got12.tmin,
5317 odd,
5318 gpinfop->got12.tmax,
5319 gpinfop->g.gotlos,
5320 gpinfop->g.fdlos,
5321 gpinfop->g.fdplt
5322 - gpinfop->got12.fdplt,
5323 gpinfop->g.tlsdlos,
5324 gpinfop->g.tlsdplt
5325 - gpinfop->got12.tlsdplt,
5326 (bfd_vma)1 << (16-1));
5327 odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo,
5328 gpinfop->gotlos.tmin,
5329 odd,
5330 gpinfop->gotlos.tmax,
5331 gpinfop->g.gothilo,
5332 gpinfop->g.fdhilo,
5333 gpinfop->g.fdplt
5334 - gpinfop->got12.fdplt
5335 - gpinfop->gotlos.fdplt,
5336 gpinfop->g.tlsdhilo,
5337 gpinfop->g.tlsdplt
5338 - gpinfop->got12.tlsdplt
5339 - gpinfop->gotlos.tlsdplt,
5340 (bfd_vma)1 << (32-1));
5341
5342 /* Now assign (most) GOT offsets. */
5343 htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
5344 gpinfop);
5345
5346 frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax
5347 - gpinfop->gothilo.tmin
5348 /* If an odd word is the last word of the GOT, we don't need this
5349 word to be part of the GOT. */
5350 - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0);
5351 if (frvfdpic_got_section (info)->size == 0)
5352 frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5353 else if (frvfdpic_got_section (info)->size == 12
5354 && ! elf_hash_table (info)->dynamic_sections_created)
5355 {
5356 frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5357 frvfdpic_got_section (info)->size = 0;
5358 }
5359 /* This will be non-NULL during relaxation. The assumption is that
5360 the size of one of these sections will never grow, only shrink,
5361 so we can use the larger buffer we allocated before. */
5362 else if (frvfdpic_got_section (info)->contents == NULL)
5363 {
5364 frvfdpic_got_section (info)->contents =
5365 (bfd_byte *) bfd_zalloc (dynobj,
5366 frvfdpic_got_section (info)->size);
5367 if (frvfdpic_got_section (info)->contents == NULL)
5368 return FALSE;
5369 }
5370
5371 if (frvfdpic_gotrel_section (info))
5372 /* Subtract the number of lzplt entries, since those will generate
5373 relocations in the pltrel section. */
5374 frvfdpic_gotrel_section (info)->size =
5375 (gpinfop->g.relocs - gpinfop->g.lzplt / 8)
5376 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5377 else
5378 BFD_ASSERT (gpinfop->g.relocs == 0);
5379 if (frvfdpic_gotrel_section (info)->size == 0)
5380 frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
5381 else if (frvfdpic_gotrel_section (info)->contents == NULL)
5382 {
5383 frvfdpic_gotrel_section (info)->contents =
5384 (bfd_byte *) bfd_zalloc (dynobj,
5385 frvfdpic_gotrel_section (info)->size);
5386 if (frvfdpic_gotrel_section (info)->contents == NULL)
5387 return FALSE;
5388 }
5389
5390 frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
5391 if (frvfdpic_gotfixup_section (info)->size == 0)
5392 frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
5393 else if (frvfdpic_gotfixup_section (info)->contents == NULL)
5394 {
5395 frvfdpic_gotfixup_section (info)->contents =
5396 (bfd_byte *) bfd_zalloc (dynobj,
5397 frvfdpic_gotfixup_section (info)->size);
5398 if (frvfdpic_gotfixup_section (info)->contents == NULL)
5399 return FALSE;
5400 }
5401
5402 if (frvfdpic_pltrel_section (info))
5403 {
5404 frvfdpic_pltrel_section (info)->size =
5405 gpinfop->g.lzplt / 8
5406 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5407 if (frvfdpic_pltrel_section (info)->size == 0)
5408 frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
5409 else if (frvfdpic_pltrel_section (info)->contents == NULL)
5410 {
5411 frvfdpic_pltrel_section (info)->contents =
5412 (bfd_byte *) bfd_zalloc (dynobj,
5413 frvfdpic_pltrel_section (info)->size);
5414 if (frvfdpic_pltrel_section (info)->contents == NULL)
5415 return FALSE;
5416 }
5417 }
5418
5419 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5420 such that there's room for the additional instruction needed to
5421 call the resolver. Since _frvfdpic_assign_got_entries didn't
5422 account for them, our block size is 4 bytes smaller than the real
5423 block size. */
5424 if (frvfdpic_plt_section (info))
5425 {
5426 frvfdpic_plt_section (info)->size = gpinfop->g.lzplt
5427 + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
5428 / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
5429 }
5430
5431 /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5432 actually assign lazy PLT entries addresses. */
5433 gpinfop->g.lzplt = 0;
5434
5435 /* Save information that we're going to need to generate GOT and PLT
5436 entries. */
5437 frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin;
5438
5439 if (get_elf_backend_data (output_bfd)->want_got_sym)
5440 elf_hash_table (info)->hgot->root.u.def.value
5441 = frvfdpic_got_initial_offset (info);
5442
5443 if (frvfdpic_plt_section (info))
5444 frvfdpic_plt_initial_offset (info) =
5445 frvfdpic_plt_section (info)->size;
5446
5447 /* Allocate a ret statement at plt_initial_offset, to be used by
5448 locally-resolved TLS descriptors. */
5449 if (gpinfop->g.tls_ret_refs)
5450 frvfdpic_plt_section (info)->size += 4;
5451
5452 htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
5453 gpinfop);
5454
5455 /* Allocate the PLT section contents only after
5456 _frvfdpic_assign_plt_entries has a chance to add the size of the
5457 non-lazy PLT entries. */
5458 if (frvfdpic_plt_section (info))
5459 {
5460 if (frvfdpic_plt_section (info)->size == 0)
5461 frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
5462 else if (frvfdpic_plt_section (info)->contents == NULL)
5463 {
5464 frvfdpic_plt_section (info)->contents =
5465 (bfd_byte *) bfd_zalloc (dynobj,
5466 frvfdpic_plt_section (info)->size);
5467 if (frvfdpic_plt_section (info)->contents == NULL)
5468 return FALSE;
5469 }
5470 }
5471
5472 return TRUE;
5473 }
5474
5475 /* Set the sizes of the dynamic sections. */
5476
5477 static bfd_boolean
5478 elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
5479 struct bfd_link_info *info)
5480 {
5481 bfd *dynobj;
5482 asection *s;
5483 struct _frvfdpic_dynamic_got_plt_info gpinfo;
5484
5485 dynobj = elf_hash_table (info)->dynobj;
5486 BFD_ASSERT (dynobj != NULL);
5487
5488 if (elf_hash_table (info)->dynamic_sections_created)
5489 {
5490 /* Set the contents of the .interp section to the interpreter. */
5491 if (info->executable)
5492 {
5493 s = bfd_get_section_by_name (dynobj, ".interp");
5494 BFD_ASSERT (s != NULL);
5495 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5496 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
5497 }
5498 }
5499
5500 memset (&gpinfo, 0, sizeof (gpinfo));
5501 gpinfo.g.info = info;
5502
5503 for (;;)
5504 {
5505 htab_t relocs = frvfdpic_relocs_info (info);
5506
5507 htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
5508
5509 if (relocs == frvfdpic_relocs_info (info))
5510 break;
5511 }
5512
5513 htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
5514 &gpinfo.g);
5515
5516 /* Allocate space to save the summary information, we're going to
5517 use it if we're doing relaxations. */
5518 frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
5519
5520 if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo))
5521 return FALSE;
5522
5523 if (elf_hash_table (info)->dynamic_sections_created)
5524 {
5525 if (frvfdpic_got_section (info)->size)
5526 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
5527 return FALSE;
5528
5529 if (frvfdpic_pltrel_section (info)->size)
5530 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5531 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
5532 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5533 return FALSE;
5534
5535 if (frvfdpic_gotrel_section (info)->size)
5536 if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
5537 || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
5538 || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
5539 sizeof (Elf32_External_Rel)))
5540 return FALSE;
5541 }
5542
5543 return TRUE;
5544 }
5545
5546 static bfd_boolean
5547 elf32_frvfdpic_always_size_sections (bfd *output_bfd,
5548 struct bfd_link_info *info)
5549 {
5550 if (!info->relocatable)
5551 {
5552 struct elf_link_hash_entry *h;
5553
5554 /* Force a PT_GNU_STACK segment to be created. */
5555 if (! elf_tdata (output_bfd)->stack_flags)
5556 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5557
5558 /* Define __stacksize if it's not defined yet. */
5559 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5560 FALSE, FALSE, FALSE);
5561 if (! h || h->root.type != bfd_link_hash_defined
5562 || h->type != STT_OBJECT
5563 || !h->def_regular)
5564 {
5565 struct bfd_link_hash_entry *bh = NULL;
5566
5567 if (!(_bfd_generic_link_add_one_symbol
5568 (info, output_bfd, "__stacksize",
5569 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
5570 (const char *) NULL, FALSE,
5571 get_elf_backend_data (output_bfd)->collect, &bh)))
5572 return FALSE;
5573
5574 h = (struct elf_link_hash_entry *) bh;
5575 h->def_regular = 1;
5576 h->type = STT_OBJECT;
5577 /* This one must NOT be hidden. */
5578 }
5579 }
5580
5581 return TRUE;
5582 }
5583
5584 /* Look for opportunities to relax TLS relocations. We can assume
5585 we're linking the main executable or a static-tls library, since
5586 otherwise we wouldn't have got here. */
5587
5588 static int
5589 _frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_)
5590 {
5591 struct frvfdpic_relocs_info *entry = *entryp;
5592 struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
5593
5594 _frvfdpic_relax_tls_entries (entry, dinfo, TRUE);
5595
5596 return 1;
5597 }
5598
5599 static bfd_boolean
5600 elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
5601 struct bfd_link_info *info, bfd_boolean *again)
5602 {
5603 struct _frvfdpic_dynamic_got_plt_info gpinfo;
5604
5605 /* If we return early, we didn't change anything. */
5606 *again = FALSE;
5607
5608 /* We'll do our thing when requested to relax the GOT section. */
5609 if (sec != frvfdpic_got_section (info))
5610 return TRUE;
5611
5612 /* We can only relax when linking the main executable or a library
5613 that can't be dlopened. */
5614 if (! info->executable && ! (info->flags & DF_STATIC_TLS))
5615 return TRUE;
5616
5617 /* If there isn't a TLS section for this binary, we can't do
5618 anything about its TLS relocations (it probably doesn't have
5619 any. */
5620 if (elf_hash_table (info)->tls_sec == NULL)
5621 return TRUE;
5622
5623 memset (&gpinfo, 0, sizeof (gpinfo));
5624 memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g));
5625
5626 /* Now look for opportunities to relax, adjusting the GOT usage
5627 as needed. */
5628 htab_traverse (frvfdpic_relocs_info (info),
5629 _frvfdpic_relax_got_plt_entries,
5630 &gpinfo.g);
5631
5632 /* If we changed anything, reset and re-assign GOT and PLT entries. */
5633 if (memcmp (frvfdpic_dynamic_got_plt_info (info),
5634 &gpinfo.g, sizeof (gpinfo.g)) != 0)
5635 {
5636 /* Clear GOT and PLT assignments. */
5637 htab_traverse (frvfdpic_relocs_info (info),
5638 _frvfdpic_reset_got_plt_entries,
5639 NULL);
5640
5641 /* The owner of the TLS section is the output bfd. There should
5642 be a better way to get to it. */
5643 if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner,
5644 &gpinfo))
5645 return FALSE;
5646
5647 /* Repeat until we don't make any further changes. We could fail to
5648 introduce changes in a round if, for example, the 12-bit range is
5649 full, but we later release some space by getting rid of TLS
5650 descriptors in it. We have to repeat the whole process because
5651 we might have changed the size of a section processed before this
5652 one. */
5653 *again = TRUE;
5654 }
5655
5656 return TRUE;
5657 }
5658
5659 static bfd_boolean
5660 elf32_frvfdpic_modify_program_headers (bfd *output_bfd,
5661 struct bfd_link_info *info)
5662 {
5663 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
5664 struct elf_segment_map *m;
5665 Elf_Internal_Phdr *p;
5666
5667 /* objcopy and strip preserve what's already there using
5668 elf32_frvfdpic_copy_private_bfd_data (). */
5669 if (! info)
5670 return TRUE;
5671
5672 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
5673 if (m->p_type == PT_GNU_STACK)
5674 break;
5675
5676 if (m)
5677 {
5678 struct elf_link_hash_entry *h;
5679
5680 /* Obtain the pointer to the __stacksize symbol. */
5681 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5682 FALSE, FALSE, FALSE);
5683 if (h)
5684 {
5685 while (h->root.type == bfd_link_hash_indirect
5686 || h->root.type == bfd_link_hash_warning)
5687 h = (struct elf_link_hash_entry *) h->root.u.i.link;
5688 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5689 }
5690
5691 /* Set the header p_memsz from the symbol value. We
5692 intentionally ignore the symbol section. */
5693 if (h && h->root.type == bfd_link_hash_defined)
5694 p->p_memsz = h->root.u.def.value;
5695 else
5696 p->p_memsz = DEFAULT_STACK_SIZE;
5697
5698 p->p_align = 8;
5699 }
5700
5701 return TRUE;
5702 }
5703
5704 /* Fill in code and data in dynamic sections. */
5705
5706 static bfd_boolean
5707 elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5708 struct bfd_link_info *info ATTRIBUTE_UNUSED)
5709 {
5710 /* Nothing to be done for non-FDPIC. */
5711 return TRUE;
5712 }
5713
5714 static bfd_boolean
5715 elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
5716 struct bfd_link_info *info)
5717 {
5718 bfd *dynobj;
5719 asection *sdyn;
5720
5721 dynobj = elf_hash_table (info)->dynobj;
5722
5723 if (frvfdpic_dynamic_got_plt_info (info))
5724 {
5725 BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0);
5726 }
5727 if (frvfdpic_got_section (info))
5728 {
5729 BFD_ASSERT (frvfdpic_gotrel_section (info)->size
5730 == (frvfdpic_gotrel_section (info)->reloc_count
5731 * sizeof (Elf32_External_Rel)));
5732
5733 if (frvfdpic_gotfixup_section (info))
5734 {
5735 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
5736 bfd_vma got_value = hgot->root.u.def.value
5737 + hgot->root.u.def.section->output_section->vma
5738 + hgot->root.u.def.section->output_offset;
5739 struct bfd_link_hash_entry *hend;
5740
5741 _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
5742 got_value, 0);
5743
5744 if (frvfdpic_gotfixup_section (info)->size
5745 != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
5746 {
5747 error:
5748 (*_bfd_error_handler)
5749 ("LINKER BUG: .rofixup section size mismatch");
5750 return FALSE;
5751 }
5752
5753 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
5754 FALSE, FALSE, TRUE);
5755 if (hend
5756 && (hend->type == bfd_link_hash_defined
5757 || hend->type == bfd_link_hash_defweak))
5758 {
5759 bfd_vma value =
5760 frvfdpic_gotfixup_section (info)->output_section->vma
5761 + frvfdpic_gotfixup_section (info)->output_offset
5762 + frvfdpic_gotfixup_section (info)->size
5763 - hend->u.def.section->output_section->vma
5764 - hend->u.def.section->output_offset;
5765 BFD_ASSERT (hend->u.def.value == value);
5766 if (hend->u.def.value != value)
5767 goto error;
5768 }
5769 }
5770 }
5771 if (frvfdpic_pltrel_section (info))
5772 {
5773 BFD_ASSERT (frvfdpic_pltrel_section (info)->size
5774 == (frvfdpic_pltrel_section (info)->reloc_count
5775 * sizeof (Elf32_External_Rel)));
5776 }
5777
5778
5779 if (elf_hash_table (info)->dynamic_sections_created)
5780 {
5781 Elf32_External_Dyn * dyncon;
5782 Elf32_External_Dyn * dynconend;
5783
5784 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5785
5786 BFD_ASSERT (sdyn != NULL);
5787
5788 dyncon = (Elf32_External_Dyn *) sdyn->contents;
5789 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5790
5791 for (; dyncon < dynconend; dyncon++)
5792 {
5793 Elf_Internal_Dyn dyn;
5794
5795 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5796
5797 switch (dyn.d_tag)
5798 {
5799 default:
5800 break;
5801
5802 case DT_PLTGOT:
5803 dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
5804 + frvfdpic_got_section (info)->output_offset
5805 + frvfdpic_got_initial_offset (info);
5806 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5807 break;
5808
5809 case DT_JMPREL:
5810 dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
5811 ->output_section->vma
5812 + frvfdpic_pltrel_section (info)->output_offset;
5813 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5814 break;
5815
5816 case DT_PLTRELSZ:
5817 dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
5818 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5819 break;
5820 }
5821 }
5822 }
5823
5824 return TRUE;
5825 }
5826
5827 /* Adjust a symbol defined by a dynamic object and referenced by a
5828 regular object. */
5829
5830 static bfd_boolean
5831 elf32_frvfdpic_adjust_dynamic_symbol
5832 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5833 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5834 {
5835 bfd * dynobj;
5836
5837 dynobj = elf_hash_table (info)->dynobj;
5838
5839 /* Make sure we know what is going on here. */
5840 BFD_ASSERT (dynobj != NULL
5841 && (h->u.weakdef != NULL
5842 || (h->def_dynamic
5843 && h->ref_regular
5844 && !h->def_regular)));
5845
5846 /* If this is a weak symbol, and there is a real definition, the
5847 processor independent code will have arranged for us to see the
5848 real definition first, and we can just use the same value. */
5849 if (h->u.weakdef != NULL)
5850 {
5851 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5852 || h->u.weakdef->root.type == bfd_link_hash_defweak);
5853 h->root.u.def.section = h->u.weakdef->root.u.def.section;
5854 h->root.u.def.value = h->u.weakdef->root.u.def.value;
5855 }
5856
5857 return TRUE;
5858 }
5859
5860 /* Perform any actions needed for dynamic symbols. */
5861
5862 static bfd_boolean
5863 elf32_frvfdpic_finish_dynamic_symbol
5864 (bfd *output_bfd ATTRIBUTE_UNUSED,
5865 struct bfd_link_info *info ATTRIBUTE_UNUSED,
5866 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
5867 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5868 {
5869 return TRUE;
5870 }
5871
5872 /* Decide whether to attempt to turn absptr or lsda encodings in
5873 shared libraries into pcrel within the given input section. */
5874
5875 static bfd_boolean
5876 frvfdpic_elf_use_relative_eh_frame
5877 (bfd *input_bfd ATTRIBUTE_UNUSED,
5878 struct bfd_link_info *info ATTRIBUTE_UNUSED,
5879 asection *eh_frame_section ATTRIBUTE_UNUSED)
5880 {
5881 /* We can't use PC-relative encodings in FDPIC binaries, in general. */
5882 return FALSE;
5883 }
5884
5885 /* Adjust the contents of an eh_frame_hdr section before they're output. */
5886
5887 static bfd_byte
5888 frvfdpic_elf_encode_eh_address (bfd *abfd,
5889 struct bfd_link_info *info,
5890 asection *osec, bfd_vma offset,
5891 asection *loc_sec, bfd_vma loc_offset,
5892 bfd_vma *encoded)
5893 {
5894 struct elf_link_hash_entry *h;
5895
5896 h = elf_hash_table (info)->hgot;
5897 BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
5898
5899 if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
5900 == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
5901 return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
5902 loc_sec, loc_offset, encoded);
5903
5904 BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
5905 == (_frvfdpic_osec_to_segment
5906 (abfd, h->root.u.def.section->output_section)));
5907
5908 *encoded = osec->vma + offset
5909 - (h->root.u.def.value
5910 + h->root.u.def.section->output_section->vma
5911 + h->root.u.def.section->output_offset);
5912
5913 return DW_EH_PE_datarel | DW_EH_PE_sdata4;
5914 }
5915
5916 /* Look through the relocs for a section during the first phase.
5917
5918 Besides handling virtual table relocs for gc, we have to deal with
5919 all sorts of PIC-related relocations. We describe below the
5920 general plan on how to handle such relocations, even though we only
5921 collect information at this point, storing them in hash tables for
5922 perusal of later passes.
5923
5924 32 relocations are propagated to the linker output when creating
5925 position-independent output. LO16 and HI16 relocations are not
5926 supposed to be encountered in this case.
5927
5928 LABEL16 should always be resolvable by the linker, since it's only
5929 used by branches.
5930
5931 LABEL24, on the other hand, is used by calls. If it turns out that
5932 the target of a call is a dynamic symbol, a PLT entry must be
5933 created for it, which triggers the creation of a private function
5934 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
5935
5936 GPREL relocations require the referenced symbol to be in the same
5937 segment as _gp, but this can only be checked later.
5938
5939 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
5940 exist. LABEL24 might as well, since it may require a PLT entry,
5941 that will require a got.
5942
5943 Non-FUNCDESC GOT relocations require a GOT entry to be created
5944 regardless of whether the symbol is dynamic. However, since a
5945 global symbol that turns out to not be exported may have the same
5946 address of a non-dynamic symbol, we don't assign GOT entries at
5947 this point, such that we can share them in this case. A relocation
5948 for the GOT entry always has to be created, be it to offset a
5949 private symbol by the section load address, be it to get the symbol
5950 resolved dynamically.
5951
5952 FUNCDESC GOT relocations require a GOT entry to be created, and
5953 handled as if a FUNCDESC relocation was applied to the GOT entry in
5954 an object file.
5955
5956 FUNCDESC relocations referencing a symbol that turns out to NOT be
5957 dynamic cause a private function descriptor to be created. The
5958 FUNCDESC relocation then decays to a 32 relocation that points at
5959 the private descriptor. If the symbol is dynamic, the FUNCDESC
5960 relocation is propagated to the linker output, such that the
5961 dynamic linker creates the canonical descriptor, pointing to the
5962 dynamically-resolved definition of the function.
5963
5964 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
5965 symbols that are assigned to the same segment as the GOT, but we
5966 can only check this later, after we know the complete set of
5967 symbols defined and/or exported.
5968
5969 FUNCDESC GOTOFF relocations require a function descriptor to be
5970 created and, unless lazy binding is disabled or the symbol is not
5971 dynamic, a lazy PLT entry. Since we can't tell at this point
5972 whether a symbol is going to be dynamic, we have to decide later
5973 whether to create a lazy PLT entry or bind the descriptor directly
5974 to the private function.
5975
5976 FUNCDESC_VALUE relocations are not supposed to be present in object
5977 files, but they may very well be simply propagated to the linker
5978 output, since they have no side effect.
5979
5980
5981 A function descriptor always requires a FUNCDESC_VALUE relocation.
5982 Whether it's in .plt.rel or not depends on whether lazy binding is
5983 enabled and on whether the referenced symbol is dynamic.
5984
5985 The existence of a lazy PLT requires the resolverStub lazy PLT
5986 entry to be present.
5987
5988
5989 As for assignment of GOT, PLT and lazy PLT entries, and private
5990 descriptors, we might do them all sequentially, but we can do
5991 better than that. For example, we can place GOT entries and
5992 private function descriptors referenced using 12-bit operands
5993 closer to the PIC register value, such that these relocations don't
5994 overflow. Those that are only referenced with LO16 relocations
5995 could come next, but we may as well place PLT-required function
5996 descriptors in the 12-bit range to make them shorter. Symbols
5997 referenced with LO16/HI16 may come next, but we may place
5998 additional function descriptors in the 16-bit range if we can
5999 reliably tell that we've already placed entries that are ever
6000 referenced with only LO16. PLT entries are therefore generated as
6001 small as possible, while not introducing relocation overflows in
6002 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
6003 generated before or after PLT entries, but not intermingled with
6004 them, such that we can have more lazy PLT entries in range for a
6005 branch to the resolverStub. The resolverStub should be emitted at
6006 the most distant location from the first lazy PLT entry such that
6007 it's still in range for a branch, or closer, if there isn't a need
6008 for so many lazy PLT entries. Additional lazy PLT entries may be
6009 emitted after the resolverStub, as long as branches are still in
6010 range. If the branch goes out of range, longer lazy PLT entries
6011 are emitted.
6012
6013 We could further optimize PLT and lazy PLT entries by giving them
6014 priority in assignment to closer-to-gr17 locations depending on the
6015 number of occurrences of references to them (assuming a function
6016 that's called more often is more important for performance, so its
6017 PLT entry should be faster), or taking hints from the compiler.
6018 Given infinite time and money... :-) */
6019
6020 static bfd_boolean
6021 elf32_frv_check_relocs (abfd, info, sec, relocs)
6022 bfd *abfd;
6023 struct bfd_link_info *info;
6024 asection *sec;
6025 const Elf_Internal_Rela *relocs;
6026 {
6027 Elf_Internal_Shdr *symtab_hdr;
6028 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6029 const Elf_Internal_Rela *rel;
6030 const Elf_Internal_Rela *rel_end;
6031 bfd *dynobj;
6032 struct frvfdpic_relocs_info *picrel;
6033
6034 if (info->relocatable)
6035 return TRUE;
6036
6037 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6038 sym_hashes = elf_sym_hashes (abfd);
6039 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
6040 if (!elf_bad_symtab (abfd))
6041 sym_hashes_end -= symtab_hdr->sh_info;
6042
6043 dynobj = elf_hash_table (info)->dynobj;
6044 rel_end = relocs + sec->reloc_count;
6045 for (rel = relocs; rel < rel_end; rel++)
6046 {
6047 struct elf_link_hash_entry *h;
6048 unsigned long r_symndx;
6049
6050 r_symndx = ELF32_R_SYM (rel->r_info);
6051 if (r_symndx < symtab_hdr->sh_info)
6052 h = NULL;
6053 else
6054 {
6055 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6056 while (h->root.type == bfd_link_hash_indirect
6057 || h->root.type == bfd_link_hash_warning)
6058 h = (struct elf_link_hash_entry *) h->root.u.i.link;
6059 }
6060
6061 switch (ELF32_R_TYPE (rel->r_info))
6062 {
6063 case R_FRV_GETTLSOFF:
6064 case R_FRV_TLSDESC_VALUE:
6065 case R_FRV_GOTTLSDESC12:
6066 case R_FRV_GOTTLSDESCHI:
6067 case R_FRV_GOTTLSDESCLO:
6068 case R_FRV_GOTTLSOFF12:
6069 case R_FRV_GOTTLSOFFHI:
6070 case R_FRV_GOTTLSOFFLO:
6071 case R_FRV_TLSOFF:
6072 case R_FRV_GOT12:
6073 case R_FRV_GOTHI:
6074 case R_FRV_GOTLO:
6075 case R_FRV_FUNCDESC_GOT12:
6076 case R_FRV_FUNCDESC_GOTHI:
6077 case R_FRV_FUNCDESC_GOTLO:
6078 case R_FRV_GOTOFF12:
6079 case R_FRV_GOTOFFHI:
6080 case R_FRV_GOTOFFLO:
6081 case R_FRV_FUNCDESC_GOTOFF12:
6082 case R_FRV_FUNCDESC_GOTOFFHI:
6083 case R_FRV_FUNCDESC_GOTOFFLO:
6084 case R_FRV_FUNCDESC:
6085 case R_FRV_FUNCDESC_VALUE:
6086 case R_FRV_TLSMOFF12:
6087 case R_FRV_TLSMOFFHI:
6088 case R_FRV_TLSMOFFLO:
6089 case R_FRV_TLSMOFF:
6090 if (! IS_FDPIC (abfd))
6091 goto bad_reloc;
6092 /* Fall through. */
6093 case R_FRV_GPREL12:
6094 case R_FRV_GPRELU12:
6095 case R_FRV_GPRELHI:
6096 case R_FRV_GPRELLO:
6097 case R_FRV_LABEL24:
6098 case R_FRV_32:
6099 if (! dynobj)
6100 {
6101 elf_hash_table (info)->dynobj = dynobj = abfd;
6102 if (! _frv_create_got_section (abfd, info))
6103 return FALSE;
6104 }
6105 if (! IS_FDPIC (abfd))
6106 {
6107 picrel = NULL;
6108 break;
6109 }
6110 if (h != NULL)
6111 {
6112 if (h->dynindx == -1)
6113 switch (ELF_ST_VISIBILITY (h->other))
6114 {
6115 case STV_INTERNAL:
6116 case STV_HIDDEN:
6117 break;
6118 default:
6119 bfd_elf_link_record_dynamic_symbol (info, h);
6120 break;
6121 }
6122 picrel
6123 = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
6124 abfd, h,
6125 rel->r_addend, INSERT);
6126 }
6127 else
6128 picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6129 (info), abfd, r_symndx,
6130 rel->r_addend, INSERT);
6131 if (! picrel)
6132 return FALSE;
6133 break;
6134
6135 default:
6136 picrel = NULL;
6137 break;
6138 }
6139
6140 switch (ELF32_R_TYPE (rel->r_info))
6141 {
6142 case R_FRV_LABEL24:
6143 if (IS_FDPIC (abfd))
6144 picrel->call = 1;
6145 break;
6146
6147 case R_FRV_FUNCDESC_VALUE:
6148 picrel->relocsfdv++;
6149 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6150 picrel->relocs32--;
6151 /* Fall through. */
6152
6153 case R_FRV_32:
6154 if (! IS_FDPIC (abfd))
6155 break;
6156
6157 picrel->sym = 1;
6158 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6159 picrel->relocs32++;
6160 break;
6161
6162 case R_FRV_GOT12:
6163 picrel->got12 = 1;
6164 break;
6165
6166 case R_FRV_GOTHI:
6167 case R_FRV_GOTLO:
6168 picrel->gothilo = 1;
6169 break;
6170
6171 case R_FRV_FUNCDESC_GOT12:
6172 picrel->fdgot12 = 1;
6173 break;
6174
6175 case R_FRV_FUNCDESC_GOTHI:
6176 case R_FRV_FUNCDESC_GOTLO:
6177 picrel->fdgothilo = 1;
6178 break;
6179
6180 case R_FRV_GOTOFF12:
6181 case R_FRV_GOTOFFHI:
6182 case R_FRV_GOTOFFLO:
6183 picrel->gotoff = 1;
6184 break;
6185
6186 case R_FRV_FUNCDESC_GOTOFF12:
6187 picrel->fdgoff12 = 1;
6188 break;
6189
6190 case R_FRV_FUNCDESC_GOTOFFHI:
6191 case R_FRV_FUNCDESC_GOTOFFLO:
6192 picrel->fdgoffhilo = 1;
6193 break;
6194
6195 case R_FRV_FUNCDESC:
6196 picrel->fd = 1;
6197 picrel->relocsfd++;
6198 break;
6199
6200 case R_FRV_GETTLSOFF:
6201 picrel->tlsplt = 1;
6202 break;
6203
6204 case R_FRV_TLSDESC_VALUE:
6205 picrel->relocstlsd++;
6206 goto bad_reloc;
6207
6208 case R_FRV_GOTTLSDESC12:
6209 picrel->tlsdesc12 = 1;
6210 break;
6211
6212 case R_FRV_GOTTLSDESCHI:
6213 case R_FRV_GOTTLSDESCLO:
6214 picrel->tlsdeschilo = 1;
6215 break;
6216
6217 case R_FRV_TLSMOFF12:
6218 case R_FRV_TLSMOFFHI:
6219 case R_FRV_TLSMOFFLO:
6220 case R_FRV_TLSMOFF:
6221 break;
6222
6223 case R_FRV_GOTTLSOFF12:
6224 picrel->tlsoff12 = 1;
6225 info->flags |= DF_STATIC_TLS;
6226 break;
6227
6228 case R_FRV_GOTTLSOFFHI:
6229 case R_FRV_GOTTLSOFFLO:
6230 picrel->tlsoffhilo = 1;
6231 info->flags |= DF_STATIC_TLS;
6232 break;
6233
6234 case R_FRV_TLSOFF:
6235 picrel->relocstlsoff++;
6236 info->flags |= DF_STATIC_TLS;
6237 goto bad_reloc;
6238
6239 /* This relocation describes the C++ object vtable hierarchy.
6240 Reconstruct it for later use during GC. */
6241 case R_FRV_GNU_VTINHERIT:
6242 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6243 return FALSE;
6244 break;
6245
6246 /* This relocation describes which C++ vtable entries are actually
6247 used. Record for later use during GC. */
6248 case R_FRV_GNU_VTENTRY:
6249 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6250 return FALSE;
6251 break;
6252
6253 case R_FRV_LABEL16:
6254 case R_FRV_LO16:
6255 case R_FRV_HI16:
6256 case R_FRV_GPREL12:
6257 case R_FRV_GPRELU12:
6258 case R_FRV_GPREL32:
6259 case R_FRV_GPRELHI:
6260 case R_FRV_GPRELLO:
6261 case R_FRV_TLSDESC_RELAX:
6262 case R_FRV_GETTLSOFF_RELAX:
6263 case R_FRV_TLSOFF_RELAX:
6264 break;
6265
6266 default:
6267 bad_reloc:
6268 (*_bfd_error_handler)
6269 (_("%B: unsupported relocation type %i"),
6270 abfd, ELF32_R_TYPE (rel->r_info));
6271 return FALSE;
6272 }
6273 }
6274
6275 return TRUE;
6276 }
6277
6278 \f
6279 /* Return the machine subcode from the ELF e_flags header. */
6280
6281 static int
6282 elf32_frv_machine (abfd)
6283 bfd *abfd;
6284 {
6285 switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
6286 {
6287 default: break;
6288 case EF_FRV_CPU_FR550: return bfd_mach_fr550;
6289 case EF_FRV_CPU_FR500: return bfd_mach_fr500;
6290 case EF_FRV_CPU_FR450: return bfd_mach_fr450;
6291 case EF_FRV_CPU_FR405: return bfd_mach_fr400;
6292 case EF_FRV_CPU_FR400: return bfd_mach_fr400;
6293 case EF_FRV_CPU_FR300: return bfd_mach_fr300;
6294 case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
6295 case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
6296 }
6297
6298 return bfd_mach_frv;
6299 }
6300
6301 /* Set the right machine number for a FRV ELF file. */
6302
6303 static bfd_boolean
6304 elf32_frv_object_p (abfd)
6305 bfd *abfd;
6306 {
6307 bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
6308 return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
6309 == (IS_FDPIC (abfd)));
6310 }
6311 \f
6312 /* Function to set the ELF flag bits. */
6313
6314 static bfd_boolean
6315 frv_elf_set_private_flags (abfd, flags)
6316 bfd *abfd;
6317 flagword flags;
6318 {
6319 elf_elfheader (abfd)->e_flags = flags;
6320 elf_flags_init (abfd) = TRUE;
6321 return TRUE;
6322 }
6323
6324 /* Copy backend specific data from one object module to another. */
6325
6326 static bfd_boolean
6327 frv_elf_copy_private_bfd_data (ibfd, obfd)
6328 bfd *ibfd;
6329 bfd *obfd;
6330 {
6331 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6332 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6333 return TRUE;
6334
6335 BFD_ASSERT (!elf_flags_init (obfd)
6336 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
6337
6338 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6339 elf_flags_init (obfd) = TRUE;
6340 return TRUE;
6341 }
6342
6343 /* Return true if the architecture described by elf header flag
6344 EXTENSION is an extension of the architecture described by BASE. */
6345
6346 static bfd_boolean
6347 frv_elf_arch_extension_p (flagword base, flagword extension)
6348 {
6349 if (base == extension)
6350 return TRUE;
6351
6352 /* CPU_GENERIC code can be merged with code for a specific
6353 architecture, in which case the result is marked as being
6354 for the specific architecture. Everything is therefore
6355 an extension of CPU_GENERIC. */
6356 if (base == EF_FRV_CPU_GENERIC)
6357 return TRUE;
6358
6359 if (extension == EF_FRV_CPU_FR450)
6360 if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
6361 return TRUE;
6362
6363 if (extension == EF_FRV_CPU_FR405)
6364 if (base == EF_FRV_CPU_FR400)
6365 return TRUE;
6366
6367 return FALSE;
6368 }
6369
6370 static bfd_boolean
6371 elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6372 {
6373 unsigned i;
6374
6375 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6376 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6377 return TRUE;
6378
6379 if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
6380 return FALSE;
6381
6382 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
6383 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
6384 return TRUE;
6385
6386 /* Copy the stack size. */
6387 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6388 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6389 {
6390 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6391
6392 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6393 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6394 {
6395 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6396
6397 /* Rewrite the phdrs, since we're only called after they
6398 were first written. */
6399 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
6400 ->s->sizeof_ehdr, SEEK_SET) != 0
6401 || get_elf_backend_data (obfd)->s
6402 ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6403 elf_elfheader (obfd)->e_phnum) != 0)
6404 return FALSE;
6405 break;
6406 }
6407
6408 break;
6409 }
6410
6411 return TRUE;
6412 }
6413
6414 /* Merge backend specific data from an object file to the output
6415 object file when linking. */
6416
6417 static bfd_boolean
6418 frv_elf_merge_private_bfd_data (ibfd, obfd)
6419 bfd *ibfd;
6420 bfd *obfd;
6421 {
6422 flagword old_flags, old_partial;
6423 flagword new_flags, new_partial;
6424 bfd_boolean error = FALSE;
6425 char new_opt[80];
6426 char old_opt[80];
6427
6428 new_opt[0] = old_opt[0] = '\0';
6429 new_flags = elf_elfheader (ibfd)->e_flags;
6430 old_flags = elf_elfheader (obfd)->e_flags;
6431
6432 if (new_flags & EF_FRV_FDPIC)
6433 new_flags &= ~EF_FRV_PIC;
6434
6435 #ifdef DEBUG
6436 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
6437 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
6438 bfd_get_filename (ibfd));
6439 #endif
6440
6441 if (!elf_flags_init (obfd)) /* First call, no flags set. */
6442 {
6443 elf_flags_init (obfd) = TRUE;
6444 old_flags = new_flags;
6445 }
6446
6447 else if (new_flags == old_flags) /* Compatible flags are ok. */
6448 ;
6449
6450 else /* Possibly incompatible flags. */
6451 {
6452 /* Warn if different # of gprs are used. Note, 0 means nothing is
6453 said about the size of gprs. */
6454 new_partial = (new_flags & EF_FRV_GPR_MASK);
6455 old_partial = (old_flags & EF_FRV_GPR_MASK);
6456 if (new_partial == old_partial)
6457 ;
6458
6459 else if (new_partial == 0)
6460 ;
6461
6462 else if (old_partial == 0)
6463 old_flags |= new_partial;
6464
6465 else
6466 {
6467 switch (new_partial)
6468 {
6469 default: strcat (new_opt, " -mgpr-??"); break;
6470 case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
6471 case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
6472 }
6473
6474 switch (old_partial)
6475 {
6476 default: strcat (old_opt, " -mgpr-??"); break;
6477 case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
6478 case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
6479 }
6480 }
6481
6482 /* Warn if different # of fprs are used. Note, 0 means nothing is
6483 said about the size of fprs. */
6484 new_partial = (new_flags & EF_FRV_FPR_MASK);
6485 old_partial = (old_flags & EF_FRV_FPR_MASK);
6486 if (new_partial == old_partial)
6487 ;
6488
6489 else if (new_partial == 0)
6490 ;
6491
6492 else if (old_partial == 0)
6493 old_flags |= new_partial;
6494
6495 else
6496 {
6497 switch (new_partial)
6498 {
6499 default: strcat (new_opt, " -mfpr-?"); break;
6500 case EF_FRV_FPR_32: strcat (new_opt, " -mfpr-32"); break;
6501 case EF_FRV_FPR_64: strcat (new_opt, " -mfpr-64"); break;
6502 case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
6503 }
6504
6505 switch (old_partial)
6506 {
6507 default: strcat (old_opt, " -mfpr-?"); break;
6508 case EF_FRV_FPR_32: strcat (old_opt, " -mfpr-32"); break;
6509 case EF_FRV_FPR_64: strcat (old_opt, " -mfpr-64"); break;
6510 case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
6511 }
6512 }
6513
6514 /* Warn if different dword support was used. Note, 0 means nothing is
6515 said about the dword support. */
6516 new_partial = (new_flags & EF_FRV_DWORD_MASK);
6517 old_partial = (old_flags & EF_FRV_DWORD_MASK);
6518 if (new_partial == old_partial)
6519 ;
6520
6521 else if (new_partial == 0)
6522 ;
6523
6524 else if (old_partial == 0)
6525 old_flags |= new_partial;
6526
6527 else
6528 {
6529 switch (new_partial)
6530 {
6531 default: strcat (new_opt, " -mdword-?"); break;
6532 case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword"); break;
6533 case EF_FRV_DWORD_NO: strcat (new_opt, " -mno-dword"); break;
6534 }
6535
6536 switch (old_partial)
6537 {
6538 default: strcat (old_opt, " -mdword-?"); break;
6539 case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword"); break;
6540 case EF_FRV_DWORD_NO: strcat (old_opt, " -mno-dword"); break;
6541 }
6542 }
6543
6544 /* Or in flags that accumulate (ie, if one module uses it, mark that the
6545 feature is used. */
6546 old_flags |= new_flags & (EF_FRV_DOUBLE
6547 | EF_FRV_MEDIA
6548 | EF_FRV_MULADD
6549 | EF_FRV_NON_PIC_RELOCS);
6550
6551 /* If any module was compiled without -G0, clear the G0 bit. */
6552 old_flags = ((old_flags & ~ EF_FRV_G0)
6553 | (old_flags & new_flags & EF_FRV_G0));
6554
6555 /* If any module was compiled without -mnopack, clear the mnopack bit. */
6556 old_flags = ((old_flags & ~ EF_FRV_NOPACK)
6557 | (old_flags & new_flags & EF_FRV_NOPACK));
6558
6559 /* We don't have to do anything if the pic flags are the same, or the new
6560 module(s) were compiled with -mlibrary-pic. */
6561 new_partial = (new_flags & EF_FRV_PIC_FLAGS);
6562 old_partial = (old_flags & EF_FRV_PIC_FLAGS);
6563 if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
6564 ;
6565
6566 /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
6567 flags if any from the new module. */
6568 else if ((old_partial & EF_FRV_LIBPIC) != 0)
6569 old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
6570
6571 /* If we have mixtures of -fpic and -fPIC, or in both bits. */
6572 else if (new_partial != 0 && old_partial != 0)
6573 old_flags |= new_partial;
6574
6575 /* One module was compiled for pic and the other was not, see if we have
6576 had any relocations that are not pic-safe. */
6577 else
6578 {
6579 if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
6580 old_flags |= new_partial;
6581 else
6582 {
6583 old_flags &= ~ EF_FRV_PIC_FLAGS;
6584 #ifndef FRV_NO_PIC_ERROR
6585 error = TRUE;
6586 (*_bfd_error_handler)
6587 (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
6588 bfd_get_filename (ibfd),
6589 (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
6590 #endif
6591 }
6592 }
6593
6594 /* Warn if different cpu is used (allow a specific cpu to override
6595 the generic cpu). */
6596 new_partial = (new_flags & EF_FRV_CPU_MASK);
6597 old_partial = (old_flags & EF_FRV_CPU_MASK);
6598 if (frv_elf_arch_extension_p (new_partial, old_partial))
6599 ;
6600
6601 else if (frv_elf_arch_extension_p (old_partial, new_partial))
6602 old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
6603
6604 else
6605 {
6606 switch (new_partial)
6607 {
6608 default: strcat (new_opt, " -mcpu=?"); break;
6609 case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv"); break;
6610 case EF_FRV_CPU_SIMPLE: strcat (new_opt, " -mcpu=simple"); break;
6611 case EF_FRV_CPU_FR550: strcat (new_opt, " -mcpu=fr550"); break;
6612 case EF_FRV_CPU_FR500: strcat (new_opt, " -mcpu=fr500"); break;
6613 case EF_FRV_CPU_FR450: strcat (new_opt, " -mcpu=fr450"); break;
6614 case EF_FRV_CPU_FR405: strcat (new_opt, " -mcpu=fr405"); break;
6615 case EF_FRV_CPU_FR400: strcat (new_opt, " -mcpu=fr400"); break;
6616 case EF_FRV_CPU_FR300: strcat (new_opt, " -mcpu=fr300"); break;
6617 case EF_FRV_CPU_TOMCAT: strcat (new_opt, " -mcpu=tomcat"); break;
6618 }
6619
6620 switch (old_partial)
6621 {
6622 default: strcat (old_opt, " -mcpu=?"); break;
6623 case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv"); break;
6624 case EF_FRV_CPU_SIMPLE: strcat (old_opt, " -mcpu=simple"); break;
6625 case EF_FRV_CPU_FR550: strcat (old_opt, " -mcpu=fr550"); break;
6626 case EF_FRV_CPU_FR500: strcat (old_opt, " -mcpu=fr500"); break;
6627 case EF_FRV_CPU_FR450: strcat (old_opt, " -mcpu=fr450"); break;
6628 case EF_FRV_CPU_FR405: strcat (old_opt, " -mcpu=fr405"); break;
6629 case EF_FRV_CPU_FR400: strcat (old_opt, " -mcpu=fr400"); break;
6630 case EF_FRV_CPU_FR300: strcat (old_opt, " -mcpu=fr300"); break;
6631 case EF_FRV_CPU_TOMCAT: strcat (old_opt, " -mcpu=tomcat"); break;
6632 }
6633 }
6634
6635 /* Print out any mismatches from above. */
6636 if (new_opt[0])
6637 {
6638 error = TRUE;
6639 (*_bfd_error_handler)
6640 (_("%s: compiled with %s and linked with modules compiled with %s"),
6641 bfd_get_filename (ibfd), new_opt, old_opt);
6642 }
6643
6644 /* Warn about any other mismatches */
6645 new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
6646 old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
6647 if (new_partial != old_partial)
6648 {
6649 old_flags |= new_partial;
6650 error = TRUE;
6651 (*_bfd_error_handler)
6652 (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
6653 bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
6654 }
6655 }
6656
6657 /* If the cpu is -mcpu=simple, then set the -mnopack bit. */
6658 if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
6659 old_flags |= EF_FRV_NOPACK;
6660
6661 /* Update the old flags now with changes made above. */
6662 old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
6663 elf_elfheader (obfd)->e_flags = old_flags;
6664 if (old_partial != (old_flags & EF_FRV_CPU_MASK))
6665 bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
6666
6667 if (((new_flags & EF_FRV_FDPIC) == 0)
6668 != (! IS_FDPIC (ibfd)))
6669 {
6670 error = TRUE;
6671 if (IS_FDPIC (obfd))
6672 (*_bfd_error_handler)
6673 (_("%s: cannot link non-fdpic object file into fdpic executable"),
6674 bfd_get_filename (ibfd));
6675 else
6676 (*_bfd_error_handler)
6677 (_("%s: cannot link fdpic object file into non-fdpic executable"),
6678 bfd_get_filename (ibfd));
6679 }
6680
6681 if (error)
6682 bfd_set_error (bfd_error_bad_value);
6683
6684 return !error;
6685 }
6686
6687 \f
6688 bfd_boolean
6689 frv_elf_print_private_bfd_data (abfd, ptr)
6690 bfd *abfd;
6691 PTR ptr;
6692 {
6693 FILE *file = (FILE *) ptr;
6694 flagword flags;
6695
6696 BFD_ASSERT (abfd != NULL && ptr != NULL);
6697
6698 /* Print normal ELF private data. */
6699 _bfd_elf_print_private_bfd_data (abfd, ptr);
6700
6701 flags = elf_elfheader (abfd)->e_flags;
6702 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
6703
6704 switch (flags & EF_FRV_CPU_MASK)
6705 {
6706 default: break;
6707 case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple"); break;
6708 case EF_FRV_CPU_FR550: fprintf (file, " -mcpu=fr550"); break;
6709 case EF_FRV_CPU_FR500: fprintf (file, " -mcpu=fr500"); break;
6710 case EF_FRV_CPU_FR450: fprintf (file, " -mcpu=fr450"); break;
6711 case EF_FRV_CPU_FR405: fprintf (file, " -mcpu=fr405"); break;
6712 case EF_FRV_CPU_FR400: fprintf (file, " -mcpu=fr400"); break;
6713 case EF_FRV_CPU_FR300: fprintf (file, " -mcpu=fr300"); break;
6714 case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat"); break;
6715 }
6716
6717 switch (flags & EF_FRV_GPR_MASK)
6718 {
6719 default: break;
6720 case EF_FRV_GPR_32: fprintf (file, " -mgpr-32"); break;
6721 case EF_FRV_GPR_64: fprintf (file, " -mgpr-64"); break;
6722 }
6723
6724 switch (flags & EF_FRV_FPR_MASK)
6725 {
6726 default: break;
6727 case EF_FRV_FPR_32: fprintf (file, " -mfpr-32"); break;
6728 case EF_FRV_FPR_64: fprintf (file, " -mfpr-64"); break;
6729 case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float"); break;
6730 }
6731
6732 switch (flags & EF_FRV_DWORD_MASK)
6733 {
6734 default: break;
6735 case EF_FRV_DWORD_YES: fprintf (file, " -mdword"); break;
6736 case EF_FRV_DWORD_NO: fprintf (file, " -mno-dword"); break;
6737 }
6738
6739 if (flags & EF_FRV_DOUBLE)
6740 fprintf (file, " -mdouble");
6741
6742 if (flags & EF_FRV_MEDIA)
6743 fprintf (file, " -mmedia");
6744
6745 if (flags & EF_FRV_MULADD)
6746 fprintf (file, " -mmuladd");
6747
6748 if (flags & EF_FRV_PIC)
6749 fprintf (file, " -fpic");
6750
6751 if (flags & EF_FRV_BIGPIC)
6752 fprintf (file, " -fPIC");
6753
6754 if (flags & EF_FRV_LIBPIC)
6755 fprintf (file, " -mlibrary-pic");
6756
6757 if (flags & EF_FRV_FDPIC)
6758 fprintf (file, " -mfdpic");
6759
6760 if (flags & EF_FRV_NON_PIC_RELOCS)
6761 fprintf (file, " non-pic relocations");
6762
6763 if (flags & EF_FRV_G0)
6764 fprintf (file, " -G0");
6765
6766 fputc ('\n', file);
6767 return TRUE;
6768 }
6769
6770 \f
6771 /* Support for core dump NOTE sections. */
6772
6773 static bfd_boolean
6774 elf32_frv_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6775 {
6776 int offset;
6777 unsigned int raw_size;
6778
6779 switch (note->descsz)
6780 {
6781 default:
6782 return FALSE;
6783
6784 /* The Linux/FRV elf_prstatus struct is 268 bytes long. The other
6785 hardcoded offsets and sizes listed below (and contained within
6786 this lexical block) refer to fields in the target's elf_prstatus
6787 struct. */
6788 case 268:
6789 /* `pr_cursig' is at offset 12. */
6790 elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
6791
6792 /* `pr_pid' is at offset 24. */
6793 elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 24);
6794
6795 /* `pr_reg' is at offset 72. */
6796 offset = 72;
6797
6798 /* Most grok_prstatus implementations set `raw_size' to the size
6799 of the pr_reg field. For Linux/FRV, we set `raw_size' to be
6800 the size of `pr_reg' plus the size of `pr_exec_fdpic_loadmap'
6801 and `pr_interp_fdpic_loadmap', both of which (by design)
6802 immediately follow `pr_reg'. This will allow these fields to
6803 be viewed by GDB as registers.
6804
6805 `pr_reg' is 184 bytes long. `pr_exec_fdpic_loadmap' and
6806 `pr_interp_fdpic_loadmap' are 4 bytes each. */
6807 raw_size = 184 + 4 + 4;
6808
6809 break;
6810 }
6811
6812 /* Make a ".reg/999" section. */
6813 return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
6814 note->descpos + offset);
6815 }
6816
6817 static bfd_boolean
6818 elf32_frv_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6819 {
6820 switch (note->descsz)
6821 {
6822 default:
6823 return FALSE;
6824
6825 /* The Linux/FRV elf_prpsinfo struct is 124 bytes long. */
6826 case 124:
6827
6828 /* `pr_fname' is found at offset 28 and is 16 bytes long. */
6829 elf_tdata (abfd)->core_program
6830 = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
6831
6832 /* `pr_psargs' is found at offset 44 and is 80 bytes long. */
6833 elf_tdata (abfd)->core_command
6834 = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
6835 }
6836
6837 /* Note that for some reason, a spurious space is tacked
6838 onto the end of the args in some (at least one anyway)
6839 implementations, so strip it off if it exists. */
6840
6841 {
6842 char *command = elf_tdata (abfd)->core_command;
6843 int n = strlen (command);
6844
6845 if (0 < n && command[n - 1] == ' ')
6846 command[n - 1] = '\0';
6847 }
6848
6849 return TRUE;
6850 }
6851 #define ELF_ARCH bfd_arch_frv
6852 #define ELF_MACHINE_CODE EM_CYGNUS_FRV
6853 #define ELF_MAXPAGESIZE 0x1000
6854
6855 #define TARGET_BIG_SYM bfd_elf32_frv_vec
6856 #define TARGET_BIG_NAME "elf32-frv"
6857
6858 #define elf_info_to_howto frv_info_to_howto_rela
6859 #define elf_backend_relocate_section elf32_frv_relocate_section
6860 #define elf_backend_gc_mark_hook elf32_frv_gc_mark_hook
6861 #define elf_backend_check_relocs elf32_frv_check_relocs
6862 #define elf_backend_object_p elf32_frv_object_p
6863 #define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook
6864
6865 #define elf_backend_can_gc_sections 1
6866 #define elf_backend_rela_normal 1
6867
6868 #define bfd_elf32_bfd_reloc_type_lookup frv_reloc_type_lookup
6869 #define bfd_elf32_bfd_set_private_flags frv_elf_set_private_flags
6870 #define bfd_elf32_bfd_copy_private_bfd_data frv_elf_copy_private_bfd_data
6871 #define bfd_elf32_bfd_merge_private_bfd_data frv_elf_merge_private_bfd_data
6872 #define bfd_elf32_bfd_print_private_bfd_data frv_elf_print_private_bfd_data
6873
6874 #define elf_backend_want_got_sym 1
6875 #define elf_backend_got_header_size 0
6876 #define elf_backend_want_got_plt 0
6877 #define elf_backend_plt_readonly 1
6878 #define elf_backend_want_plt_sym 0
6879 #define elf_backend_plt_header_size 0
6880
6881 #define elf_backend_finish_dynamic_sections \
6882 elf32_frv_finish_dynamic_sections
6883
6884 #define elf_backend_grok_prstatus elf32_frv_grok_prstatus
6885 #define elf_backend_grok_psinfo elf32_frv_grok_psinfo
6886
6887 #include "elf32-target.h"
6888
6889 #undef ELF_MAXPAGESIZE
6890 #define ELF_MAXPAGESIZE 0x4000
6891
6892 #undef TARGET_BIG_SYM
6893 #define TARGET_BIG_SYM bfd_elf32_frvfdpic_vec
6894 #undef TARGET_BIG_NAME
6895 #define TARGET_BIG_NAME "elf32-frvfdpic"
6896 #undef elf32_bed
6897 #define elf32_bed elf32_frvfdpic_bed
6898
6899 #undef elf_info_to_howto_rel
6900 #define elf_info_to_howto_rel frvfdpic_info_to_howto_rel
6901
6902 #undef bfd_elf32_bfd_link_hash_table_create
6903 #define bfd_elf32_bfd_link_hash_table_create \
6904 frvfdpic_elf_link_hash_table_create
6905 #undef elf_backend_always_size_sections
6906 #define elf_backend_always_size_sections \
6907 elf32_frvfdpic_always_size_sections
6908 #undef elf_backend_modify_program_headers
6909 #define elf_backend_modify_program_headers \
6910 elf32_frvfdpic_modify_program_headers
6911 #undef bfd_elf32_bfd_copy_private_bfd_data
6912 #define bfd_elf32_bfd_copy_private_bfd_data \
6913 elf32_frvfdpic_copy_private_bfd_data
6914
6915 #undef elf_backend_create_dynamic_sections
6916 #define elf_backend_create_dynamic_sections \
6917 elf32_frvfdpic_create_dynamic_sections
6918 #undef elf_backend_adjust_dynamic_symbol
6919 #define elf_backend_adjust_dynamic_symbol \
6920 elf32_frvfdpic_adjust_dynamic_symbol
6921 #undef elf_backend_size_dynamic_sections
6922 #define elf_backend_size_dynamic_sections \
6923 elf32_frvfdpic_size_dynamic_sections
6924 #undef bfd_elf32_bfd_relax_section
6925 #define bfd_elf32_bfd_relax_section \
6926 elf32_frvfdpic_relax_section
6927 #undef elf_backend_finish_dynamic_symbol
6928 #define elf_backend_finish_dynamic_symbol \
6929 elf32_frvfdpic_finish_dynamic_symbol
6930 #undef elf_backend_finish_dynamic_sections
6931 #define elf_backend_finish_dynamic_sections \
6932 elf32_frvfdpic_finish_dynamic_sections
6933
6934 #undef elf_backend_can_make_relative_eh_frame
6935 #define elf_backend_can_make_relative_eh_frame \
6936 frvfdpic_elf_use_relative_eh_frame
6937 #undef elf_backend_can_make_lsda_relative_eh_frame
6938 #define elf_backend_can_make_lsda_relative_eh_frame \
6939 frvfdpic_elf_use_relative_eh_frame
6940 #undef elf_backend_encode_eh_address
6941 #define elf_backend_encode_eh_address \
6942 frvfdpic_elf_encode_eh_address
6943
6944 #undef elf_backend_may_use_rel_p
6945 #define elf_backend_may_use_rel_p 1
6946 #undef elf_backend_may_use_rela_p
6947 #define elf_backend_may_use_rela_p 1
6948 /* We use REL for dynamic relocations only. */
6949 #undef elf_backend_default_use_rela_p
6950 #define elf_backend_default_use_rela_p 1
6951
6952 #undef elf_backend_omit_section_dynsym
6953 #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
6954
6955 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.177575 seconds and 4 git commands to generate.