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