projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* elf32-ppc.c (allocate_dynrelocs): Create dynsym for undef weak
[deliverable/binutils-gdb.git] / bfd / elf32-frv.c
1 /* FRV-specific support for 32-bit ELF.
2 Copyright 2002, 2003 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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 "hashtab.h"
26
27 /* Forward declarations. */
28 static bfd_reloc_status_type elf32_frv_relocate_lo16
29 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
30 static bfd_reloc_status_type elf32_frv_relocate_hi16
31 PARAMS ((bfd *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
32 static bfd_reloc_status_type elf32_frv_relocate_label24
33 PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
34 static bfd_reloc_status_type elf32_frv_relocate_gprel12
35 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
36 bfd_byte *, bfd_vma));
37 static bfd_reloc_status_type elf32_frv_relocate_gprelu12
38 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
39 bfd_byte *, bfd_vma));
40 static bfd_reloc_status_type elf32_frv_relocate_gprello
41 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
42 bfd_byte *, bfd_vma));
43 static bfd_reloc_status_type elf32_frv_relocate_gprelhi
44 PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
45 bfd_byte *, bfd_vma));
46 static reloc_howto_type *frv_reloc_type_lookup
47 PARAMS ((bfd *, bfd_reloc_code_real_type));
48 static void frv_info_to_howto_rela
49 PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
50 static bfd_boolean elf32_frv_relocate_section
51 PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
52 Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
53 static bfd_boolean elf32_frv_add_symbol_hook
54 PARAMS (( bfd *, struct bfd_link_info *, const Elf_Internal_Sym *,
55 const char **, flagword *, asection **, bfd_vma *));
56 static bfd_reloc_status_type frv_final_link_relocate
57 PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
58 Elf_Internal_Rela *, bfd_vma));
59 static bfd_boolean elf32_frv_gc_sweep_hook
60 PARAMS ((bfd *, struct bfd_link_info *, asection *, const
61 Elf_Internal_Rela *));
62 static asection * elf32_frv_gc_mark_hook
63 PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
64 struct elf_link_hash_entry *, Elf_Internal_Sym *));
65 static bfd_boolean elf32_frv_check_relocs
66 PARAMS ((bfd *, struct bfd_link_info *, asection *,
67 const Elf_Internal_Rela *));
68 static int elf32_frv_machine
69 PARAMS ((bfd *));
70 static bfd_boolean elf32_frv_object_p
71 PARAMS ((bfd *));
72 static bfd_boolean frv_elf_set_private_flags
73 PARAMS ((bfd *, flagword));
74 static bfd_boolean frv_elf_copy_private_bfd_data
75 PARAMS ((bfd *, bfd *));
76 static bfd_boolean frv_elf_merge_private_bfd_data
77 PARAMS ((bfd *, bfd *));
78 static bfd_boolean frv_elf_print_private_bfd_data
79 PARAMS ((bfd *, PTR));
80
81 static reloc_howto_type elf32_frv_howto_table [] =
82 {
83 /* This reloc does nothing. */
84 HOWTO (R_FRV_NONE, /* type */
85 0, /* rightshift */
86 2, /* size (0 = byte, 1 = short, 2 = long) */
87 32, /* bitsize */
88 FALSE, /* pc_relative */
89 0, /* bitpos */
90 complain_overflow_bitfield, /* complain_on_overflow */
91 bfd_elf_generic_reloc, /* special_function */
92 "R_FRV_NONE", /* name */
93 FALSE, /* partial_inplace */
94 0, /* src_mask */
95 0, /* dst_mask */
96 FALSE), /* pcrel_offset */
97
98 /* A 32 bit absolute relocation. */
99 HOWTO (R_FRV_32, /* type */
100 0, /* rightshift */
101 2, /* size (0 = byte, 1 = short, 2 = long) */
102 32, /* bitsize */
103 FALSE, /* pc_relative */
104 0, /* bitpos */
105 complain_overflow_bitfield, /* complain_on_overflow */
106 bfd_elf_generic_reloc, /* special_function */
107 "R_FRV_32", /* name */
108 FALSE, /* partial_inplace */
109 0xffffffff, /* src_mask */
110 0xffffffff, /* dst_mask */
111 FALSE), /* pcrel_offset */
112
113 /* A 16 bit pc-relative relocation. */
114 HOWTO (R_FRV_LABEL16, /* type */
115 2, /* rightshift */
116 2, /* size (0 = byte, 1 = short, 2 = long) */
117 16, /* bitsize */
118 TRUE, /* pc_relative */
119 0, /* bitpos */
120 complain_overflow_bitfield, /* complain_on_overflow */
121 bfd_elf_generic_reloc, /* special_function */
122 "R_FRV_LABEL16", /* name */
123 FALSE, /* partial_inplace */
124 0xffff, /* src_mask */
125 0xffff, /* dst_mask */
126 TRUE), /* pcrel_offset */
127
128 /* A 24-bit pc-relative relocation. */
129 HOWTO (R_FRV_LABEL24, /* type */
130 2, /* rightshift */
131 2, /* size (0 = byte, 1 = short, 2 = long) */
132 26, /* bitsize */
133 TRUE, /* pc_relative */
134 0, /* bitpos */
135 complain_overflow_bitfield, /* complain_on_overflow */
136 bfd_elf_generic_reloc, /* special_function */
137 "R_FRV_LABEL24", /* name */
138 FALSE, /* partial_inplace */
139 0x7e03ffff, /* src_mask */
140 0x7e03ffff, /* dst_mask */
141 TRUE), /* pcrel_offset */
142
143 HOWTO (R_FRV_LO16, /* type */
144 0, /* rightshift */
145 2, /* size (0 = byte, 1 = short, 2 = long) */
146 16, /* bitsize */
147 FALSE, /* pc_relative */
148 0, /* bitpos */
149 complain_overflow_dont, /* complain_on_overflow */
150 bfd_elf_generic_reloc, /* special_function */
151 "R_FRV_LO16", /* name */
152 FALSE, /* partial_inplace */
153 0xffff, /* src_mask */
154 0xffff, /* dst_mask */
155 FALSE), /* pcrel_offset */
156
157 HOWTO (R_FRV_HI16, /* type */
158 0, /* rightshift */
159 2, /* size (0 = byte, 1 = short, 2 = long) */
160 16, /* bitsize */
161 FALSE, /* pc_relative */
162 0, /* bitpos */
163 complain_overflow_dont, /* complain_on_overflow */
164 bfd_elf_generic_reloc, /* special_function */
165 "R_FRV_HI16", /* name */
166 FALSE, /* partial_inplace */
167 0xffff, /* src_mask */
168 0xffff, /* dst_mask */
169 FALSE), /* pcrel_offset */
170
171 HOWTO (R_FRV_GPREL12, /* type */
172 0, /* rightshift */
173 2, /* size (0 = byte, 1 = short, 2 = long) */
174 12, /* bitsize */
175 FALSE, /* pc_relative */
176 0, /* bitpos */
177 complain_overflow_dont, /* complain_on_overflow */
178 bfd_elf_generic_reloc, /* special_function */
179 "R_FRV_GPREL12", /* name */
180 FALSE, /* partial_inplace */
181 0xfff, /* src_mask */
182 0xfff, /* dst_mask */
183 FALSE), /* pcrel_offset */
184
185 HOWTO (R_FRV_GPRELU12, /* type */
186 0, /* rightshift */
187 2, /* size (0 = byte, 1 = short, 2 = long) */
188 12, /* bitsize */
189 FALSE, /* pc_relative */
190 0, /* bitpos */
191 complain_overflow_dont, /* complain_on_overflow */
192 bfd_elf_generic_reloc, /* special_function */
193 "R_FRV_GPRELU12", /* name */
194 FALSE, /* partial_inplace */
195 0xfff, /* src_mask */
196 0x3f03f, /* dst_mask */
197 FALSE), /* pcrel_offset */
198
199 HOWTO (R_FRV_GPREL32, /* type */
200 0, /* rightshift */
201 2, /* size (0 = byte, 1 = short, 2 = long) */
202 32, /* bitsize */
203 FALSE, /* pc_relative */
204 0, /* bitpos */
205 complain_overflow_dont, /* complain_on_overflow */
206 bfd_elf_generic_reloc, /* special_function */
207 "R_FRV_GPREL32", /* name */
208 FALSE, /* partial_inplace */
209 0xffffffff, /* src_mask */
210 0xffffffff, /* dst_mask */
211 FALSE), /* pcrel_offset */
212
213 HOWTO (R_FRV_GPRELHI, /* type */
214 0, /* rightshift */
215 2, /* size (0 = byte, 1 = short, 2 = long) */
216 16, /* bitsize */
217 FALSE, /* pc_relative */
218 0, /* bitpos */
219 complain_overflow_dont, /* complain_on_overflow */
220 bfd_elf_generic_reloc, /* special_function */
221 "R_FRV_GPRELHI", /* name */
222 FALSE, /* partial_inplace */
223 0xffff, /* src_mask */
224 0xffff, /* dst_mask */
225 FALSE), /* pcrel_offset */
226
227 HOWTO (R_FRV_GPRELLO, /* type */
228 0, /* rightshift */
229 2, /* size (0 = byte, 1 = short, 2 = long) */
230 16, /* bitsize */
231 FALSE, /* pc_relative */
232 0, /* bitpos */
233 complain_overflow_dont, /* complain_on_overflow */
234 bfd_elf_generic_reloc, /* special_function */
235 "R_FRV_GPRELLO", /* name */
236 FALSE, /* partial_inplace */
237 0xffff, /* src_mask */
238 0xffff, /* dst_mask */
239 FALSE), /* pcrel_offset */
240
241 /* A 12-bit signed operand with the GOT offset for the address of
242 the symbol. */
243 HOWTO (R_FRV_GOT12, /* type */
244 0, /* rightshift */
245 2, /* size (0 = byte, 1 = short, 2 = long) */
246 12, /* bitsize */
247 FALSE, /* pc_relative */
248 0, /* bitpos */
249 complain_overflow_signed, /* complain_on_overflow */
250 bfd_elf_generic_reloc, /* special_function */
251 "R_FRV_GOT12", /* name */
252 FALSE, /* partial_inplace */
253 0xfff, /* src_mask */
254 0xfff, /* dst_mask */
255 FALSE), /* pcrel_offset */
256
257 /* The upper 16 bits of the GOT offset for the address of the
258 symbol. */
259 HOWTO (R_FRV_GOTHI, /* type */
260 0, /* rightshift */
261 2, /* size (0 = byte, 1 = short, 2 = long) */
262 16, /* bitsize */
263 FALSE, /* pc_relative */
264 0, /* bitpos */
265 complain_overflow_dont, /* complain_on_overflow */
266 bfd_elf_generic_reloc, /* special_function */
267 "R_FRV_GOTHI", /* name */
268 FALSE, /* partial_inplace */
269 0xffff, /* src_mask */
270 0xffff, /* dst_mask */
271 FALSE), /* pcrel_offset */
272
273 /* The lower 16 bits of the GOT offset for the address of the
274 symbol. */
275 HOWTO (R_FRV_GOTLO, /* type */
276 0, /* rightshift */
277 2, /* size (0 = byte, 1 = short, 2 = long) */
278 16, /* bitsize */
279 FALSE, /* pc_relative */
280 0, /* bitpos */
281 complain_overflow_dont, /* complain_on_overflow */
282 bfd_elf_generic_reloc, /* special_function */
283 "R_FRV_GOTLO", /* name */
284 FALSE, /* partial_inplace */
285 0xffff, /* src_mask */
286 0xffff, /* dst_mask */
287 FALSE), /* pcrel_offset */
288
289 /* The 32-bit address of the canonical descriptor of a function. */
290 HOWTO (R_FRV_FUNCDESC, /* type */
291 0, /* rightshift */
292 2, /* size (0 = byte, 1 = short, 2 = long) */
293 32, /* bitsize */
294 FALSE, /* pc_relative */
295 0, /* bitpos */
296 complain_overflow_bitfield, /* complain_on_overflow */
297 bfd_elf_generic_reloc, /* special_function */
298 "R_FRV_FUNCDESC", /* name */
299 FALSE, /* partial_inplace */
300 0xffffffff, /* src_mask */
301 0xffffffff, /* dst_mask */
302 FALSE), /* pcrel_offset */
303
304 /* A 12-bit signed operand with the GOT offset for the address of
305 canonical descriptor of a function. */
306 HOWTO (R_FRV_FUNCDESC_GOT12, /* type */
307 0, /* rightshift */
308 2, /* size (0 = byte, 1 = short, 2 = long) */
309 12, /* bitsize */
310 FALSE, /* pc_relative */
311 0, /* bitpos */
312 complain_overflow_signed, /* complain_on_overflow */
313 bfd_elf_generic_reloc, /* special_function */
314 "R_FRV_FUNCDESC_GOT12", /* name */
315 FALSE, /* partial_inplace */
316 0xfff, /* src_mask */
317 0xfff, /* dst_mask */
318 FALSE), /* pcrel_offset */
319
320 /* The upper 16 bits of the GOT offset for the address of the
321 canonical descriptor of a function. */
322 HOWTO (R_FRV_FUNCDESC_GOTHI, /* type */
323 0, /* rightshift */
324 2, /* size (0 = byte, 1 = short, 2 = long) */
325 16, /* bitsize */
326 FALSE, /* pc_relative */
327 0, /* bitpos */
328 complain_overflow_dont, /* complain_on_overflow */
329 bfd_elf_generic_reloc, /* special_function */
330 "R_FRV_FUNCDESC_GOTHI", /* name */
331 FALSE, /* partial_inplace */
332 0xffff, /* src_mask */
333 0xffff, /* dst_mask */
334 FALSE), /* pcrel_offset */
335
336 /* The lower 16 bits of the GOT offset for the address of the
337 canonical descriptor of a function. */
338 HOWTO (R_FRV_FUNCDESC_GOTLO, /* type */
339 0, /* rightshift */
340 2, /* size (0 = byte, 1 = short, 2 = long) */
341 16, /* bitsize */
342 FALSE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_dont, /* complain_on_overflow */
345 bfd_elf_generic_reloc, /* special_function */
346 "R_FRV_FUNCDESC_GOTLO", /* name */
347 FALSE, /* partial_inplace */
348 0xffff, /* src_mask */
349 0xffff, /* dst_mask */
350 FALSE), /* pcrel_offset */
351
352 /* The 32-bit address of the canonical descriptor of a function. */
353 HOWTO (R_FRV_FUNCDESC_VALUE, /* type */
354 0, /* rightshift */
355 2, /* size (0 = byte, 1 = short, 2 = long) */
356 64, /* bitsize */
357 FALSE, /* pc_relative */
358 0, /* bitpos */
359 complain_overflow_bitfield, /* complain_on_overflow */
360 bfd_elf_generic_reloc, /* special_function */
361 "R_FRV_FUNCDESC_VALUE", /* name */
362 FALSE, /* partial_inplace */
363 0xffffffff, /* src_mask */
364 0xffffffff, /* dst_mask */
365 FALSE), /* pcrel_offset */
366
367 /* A 12-bit signed operand with the GOT offset for the address of
368 canonical descriptor of a function. */
369 HOWTO (R_FRV_FUNCDESC_GOTOFF12, /* type */
370 0, /* rightshift */
371 2, /* size (0 = byte, 1 = short, 2 = long) */
372 12, /* bitsize */
373 FALSE, /* pc_relative */
374 0, /* bitpos */
375 complain_overflow_signed, /* complain_on_overflow */
376 bfd_elf_generic_reloc, /* special_function */
377 "R_FRV_FUNCDESC_GOTOFF12", /* name */
378 FALSE, /* partial_inplace */
379 0xfff, /* src_mask */
380 0xfff, /* dst_mask */
381 FALSE), /* pcrel_offset */
382
383 /* The upper 16 bits of the GOT offset for the address of the
384 canonical descriptor of a function. */
385 HOWTO (R_FRV_FUNCDESC_GOTOFFHI, /* type */
386 0, /* rightshift */
387 2, /* size (0 = byte, 1 = short, 2 = long) */
388 16, /* bitsize */
389 FALSE, /* pc_relative */
390 0, /* bitpos */
391 complain_overflow_dont, /* complain_on_overflow */
392 bfd_elf_generic_reloc, /* special_function */
393 "R_FRV_FUNCDESC_GOTOFFHI", /* name */
394 FALSE, /* partial_inplace */
395 0xffff, /* src_mask */
396 0xffff, /* dst_mask */
397 FALSE), /* pcrel_offset */
398
399 /* The lower 16 bits of the GOT offset for the address of the
400 canonical descriptor of a function. */
401 HOWTO (R_FRV_FUNCDESC_GOTOFFLO, /* type */
402 0, /* rightshift */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
404 16, /* bitsize */
405 FALSE, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_dont, /* complain_on_overflow */
408 bfd_elf_generic_reloc, /* special_function */
409 "R_FRV_FUNCDESC_GOTOFFLO", /* name */
410 FALSE, /* partial_inplace */
411 0xffff, /* src_mask */
412 0xffff, /* dst_mask */
413 FALSE), /* pcrel_offset */
414
415 /* A 12-bit signed operand with the GOT offset for the address of
416 the symbol. */
417 HOWTO (R_FRV_GOTOFF12, /* type */
418 0, /* rightshift */
419 2, /* size (0 = byte, 1 = short, 2 = long) */
420 12, /* bitsize */
421 FALSE, /* pc_relative */
422 0, /* bitpos */
423 complain_overflow_signed, /* complain_on_overflow */
424 bfd_elf_generic_reloc, /* special_function */
425 "R_FRV_GOTOFF12", /* name */
426 FALSE, /* partial_inplace */
427 0xfff, /* src_mask */
428 0xfff, /* dst_mask */
429 FALSE), /* pcrel_offset */
430
431 /* The upper 16 bits of the GOT offset for the address of the
432 symbol. */
433 HOWTO (R_FRV_GOTOFFHI, /* type */
434 0, /* rightshift */
435 2, /* size (0 = byte, 1 = short, 2 = long) */
436 16, /* bitsize */
437 FALSE, /* pc_relative */
438 0, /* bitpos */
439 complain_overflow_dont, /* complain_on_overflow */
440 bfd_elf_generic_reloc, /* special_function */
441 "R_FRV_GOTOFFHI", /* name */
442 FALSE, /* partial_inplace */
443 0xffff, /* src_mask */
444 0xffff, /* dst_mask */
445 FALSE), /* pcrel_offset */
446
447 /* The lower 16 bits of the GOT offset for the address of the
448 symbol. */
449 HOWTO (R_FRV_GOTOFFLO, /* type */
450 0, /* rightshift */
451 2, /* size (0 = byte, 1 = short, 2 = long) */
452 16, /* bitsize */
453 FALSE, /* pc_relative */
454 0, /* bitpos */
455 complain_overflow_dont, /* complain_on_overflow */
456 bfd_elf_generic_reloc, /* special_function */
457 "R_FRV_GOTOFFLO", /* name */
458 FALSE, /* partial_inplace */
459 0xffff, /* src_mask */
460 0xffff, /* dst_mask */
461 FALSE), /* pcrel_offset */
462
463 };
464
465 /* GNU extension to record C++ vtable hierarchy. */
466 static reloc_howto_type elf32_frv_vtinherit_howto =
467 HOWTO (R_FRV_GNU_VTINHERIT, /* type */
468 0, /* rightshift */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
470 0, /* bitsize */
471 FALSE, /* pc_relative */
472 0, /* bitpos */
473 complain_overflow_dont, /* complain_on_overflow */
474 NULL, /* special_function */
475 "R_FRV_GNU_VTINHERIT", /* name */
476 FALSE, /* partial_inplace */
477 0, /* src_mask */
478 0, /* dst_mask */
479 FALSE); /* pcrel_offset */
480
481 /* GNU extension to record C++ vtable member usage. */
482 static reloc_howto_type elf32_frv_vtentry_howto =
483 HOWTO (R_FRV_GNU_VTENTRY, /* type */
484 0, /* rightshift */
485 2, /* size (0 = byte, 1 = short, 2 = long) */
486 0, /* bitsize */
487 FALSE, /* pc_relative */
488 0, /* bitpos */
489 complain_overflow_dont, /* complain_on_overflow */
490 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
491 "R_FRV_GNU_VTENTRY", /* name */
492 FALSE, /* partial_inplace */
493 0, /* src_mask */
494 0, /* dst_mask */
495 FALSE); /* pcrel_offset */
496
497 /* The following 3 relocations are REL. The only difference to the
498 entries in the table above are that partial_inplace is TRUE. */
499 static reloc_howto_type elf32_frv_rel_32_howto =
500 HOWTO (R_FRV_32, /* type */
501 0, /* rightshift */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
503 32, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_bitfield, /* complain_on_overflow */
507 bfd_elf_generic_reloc, /* special_function */
508 "R_FRV_32", /* name */
509 TRUE, /* partial_inplace */
510 0xffffffff, /* src_mask */
511 0xffffffff, /* dst_mask */
512 FALSE); /* pcrel_offset */
513
514 static reloc_howto_type elf32_frv_rel_funcdesc_howto =
515 HOWTO (R_FRV_FUNCDESC, /* type */
516 0, /* rightshift */
517 2, /* size (0 = byte, 1 = short, 2 = long) */
518 32, /* bitsize */
519 FALSE, /* pc_relative */
520 0, /* bitpos */
521 complain_overflow_bitfield, /* complain_on_overflow */
522 bfd_elf_generic_reloc, /* special_function */
523 "R_FRV_FUNCDESC", /* name */
524 TRUE, /* partial_inplace */
525 0xffffffff, /* src_mask */
526 0xffffffff, /* dst_mask */
527 FALSE); /* pcrel_offset */
528
529 static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
530 HOWTO (R_FRV_FUNCDESC_VALUE, /* type */
531 0, /* rightshift */
532 2, /* size (0 = byte, 1 = short, 2 = long) */
533 64, /* bitsize */
534 FALSE, /* pc_relative */
535 0, /* bitpos */
536 complain_overflow_bitfield, /* complain_on_overflow */
537 bfd_elf_generic_reloc, /* special_function */
538 "R_FRV_FUNCDESC_VALUE", /* name */
539 TRUE, /* partial_inplace */
540 0xffffffff, /* src_mask */
541 0xffffffff, /* dst_mask */
542 FALSE); /* pcrel_offset */
543
544 \f
545 /* Map BFD reloc types to FRV ELF reloc types. */
546 #if 0
547 struct frv_reloc_map
548 {
549 unsigned int bfd_reloc_val;
550 unsigned int frv_reloc_val;
551 };
552
553 static const struct frv_reloc_map frv_reloc_map [] =
554 {
555 { BFD_RELOC_NONE, R_FRV_NONE },
556 { BFD_RELOC_32, R_FRV_32 },
557 { BFD_RELOC_FRV_LABEL16, R_FRV_LABEL16 },
558 { BFD_RELOC_FRV_LABEL24, R_FRV_LABEL24 },
559 { BFD_RELOC_FRV_LO16, R_FRV_LO16 },
560 { BFD_RELOC_FRV_HI16, R_FRV_HI16 },
561 { BFD_RELOC_FRV_GPREL12, R_FRV_GPREL12 },
562 { BFD_RELOC_FRV_GPRELU12, R_FRV_GPRELU12 },
563 { BFD_RELOC_FRV_GPREL32, R_FRV_GPREL32 },
564 { BFD_RELOC_FRV_GPRELHI, R_FRV_GPRELHI },
565 { BFD_RELOC_FRV_GPRELLO, R_FRV_GPRELLO },
566 { BFD_RELOC_FRV_GOT12, R_FRV_GOT12 },
567 { BFD_RELOC_FRV_GOTHI, R_FRV_GOTHI },
568 { BFD_RELOC_FRV_GOTLO, R_FRV_GOTLO },
569 { BFD_RELOC_FRV_FUNCDESC, R_FRV_FUNCDESC },
570 { BFD_RELOC_FRV_FUNCDESC_GOT12, R_FRV_FUNCDESC_GOT12 },
571 { BFD_RELOC_FRV_FUNCDESC_GOTHI, R_FRV_FUNCDESC_GOTHI },
572 { BFD_RELOC_FRV_FUNCDESC_GOTLO, R_FRV_FUNCDESC_GOTLO },
573 { BFD_RELOC_FRV_FUNCDESC_VALUE, R_FRV_FUNCDESC_VALUE },
574 { BFD_RELOC_FRV_FUNCDESC_GOTOFF12, R_FRV_FUNCDESC_GOTOFF12 },
575 { BFD_RELOC_FRV_FUNCDESC_GOTOFFHI, R_FRV_FUNCDESC_GOTOFFHI },
576 { BFD_RELOC_FRV_FUNCDESC_GOTOFFLO, R_FRV_FUNCDESC_GOTOFFLO },
577 { BFD_RELOC_FRV_GOTOFF12, R_FRV_GOTOFF12 },
578 { BFD_RELOC_FRV_GOTOFFHI, R_FRV_GOTOFFHI },
579 { BFD_RELOC_FRV_GOTOFFLO, R_FRV_GOTOFFLO },
580 { BFD_RELOC_VTABLE_INHERIT, R_FRV_GNU_VTINHERIT },
581 { BFD_RELOC_VTABLE_ENTRY, R_FRV_GNU_VTENTRY },
582 };
583 #endif
584
585
586 /* An extension of the elf hash table data structure, containing some
587 additional FRV-specific data. */
588 struct frv_elf_link_hash_table
589 {
590 struct elf_link_hash_table elf;
591
592 /* A pointer to the .got section. */
593 asection *sgot;
594 /* A pointer to the .rel.got section. */
595 asection *sgotrel;
596 /* A pointer to the .rofixup section. */
597 asection *sgotfixup;
598 /* A pointer to the .plt section. */
599 asection *splt;
600 /* A pointer to the .rel.plt section. */
601 asection *spltrel;
602 /* GOT base offset. */
603 bfd_vma got0;
604 /* Location of the first non-lazy PLT entry, i.e., the number of
605 bytes taken by lazy PLT entries. */
606 bfd_vma plt0;
607 /* A hash table holding information about which symbols were
608 referenced with which PIC-related relocations. */
609 struct htab *relocs_info;
610 };
611
612 /* Get the FRV ELF linker hash table from a link_info structure. */
613
614 #define frv_hash_table(info) \
615 ((struct frv_elf_link_hash_table *) ((info)->hash))
616
617 #define frv_got_section(info) \
618 (frv_hash_table (info)->sgot)
619 #define frv_gotrel_section(info) \
620 (frv_hash_table (info)->sgotrel)
621 #define frv_gotfixup_section(info) \
622 (frv_hash_table (info)->sgotfixup)
623 #define frv_plt_section(info) \
624 (frv_hash_table (info)->splt)
625 #define frv_pltrel_section(info) \
626 (frv_hash_table (info)->spltrel)
627 #define frv_relocs_info(info) \
628 (frv_hash_table (info)->relocs_info)
629 #define frv_got_initial_offset(info) \
630 (frv_hash_table (info)->got0)
631 #define frv_plt_initial_offset(info) \
632 (frv_hash_table (info)->plt0)
633
634 /* Create an FRV ELF linker hash table. */
635
636 static struct bfd_link_hash_table *
637 frv_elf_link_hash_table_create (bfd *abfd)
638 {
639 struct frv_elf_link_hash_table *ret;
640 bfd_size_type amt = sizeof (struct frv_elf_link_hash_table);
641
642 ret = bfd_zalloc (abfd, amt);
643 if (ret == NULL)
644 return NULL;
645
646 if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
647 _bfd_elf_link_hash_newfunc))
648 {
649 free (ret);
650 return NULL;
651 }
652
653 return &ret->elf.root;
654 }
655
656 /* Decide whether a reference to a symbol can be resolved locally or
657 not. If the symbol is protected, we want the local address, but
658 its function descriptor must be assigned by the dynamic linker. */
659 #define FRV_SYM_LOCAL(INFO, H) \
660 (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
661 || ! elf_hash_table (INFO)->dynamic_sections_created \
662 || (H)->root.type == bfd_link_hash_undefweak \
663 || (/* The condition below is an ugly hack to get .scommon data to
664 be regarded as local. For some reason the
665 ELF_LINK_HASH_DEF_REGULAR bit is not set on such common
666 symbols, and the SEC_IS_COMMON bit is not set any longer
667 when we need to perform this test. Hopefully this
668 approximation is good enough. */ \
669 ((H)->root.type == bfd_link_hash_defined \
670 || (H)->root.type == bfd_link_hash_defweak) \
671 && (H)->root.u.def.section->output_section \
672 && ((H)->root.u.def.section->flags & SEC_LINKER_CREATED)))
673 #define FRV_FUNCDESC_LOCAL(INFO, H) \
674 ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
675
676 /* This structure collects information on what kind of GOT, PLT or
677 function descriptors are required by relocations that reference a
678 certain symbol. */
679 struct frv_pic_relocs_info
680 {
681 /* The index of the symbol, as stored in the relocation r_info, if
682 we have a local symbol; -1 otherwise. */
683 long symndx;
684 union
685 {
686 /* The input bfd in which the symbol is defined, if it's a local
687 symbol. */
688 bfd *abfd;
689 /* If symndx == -1, the hash table entry corresponding to a global
690 symbol (even if it turns out to bind locally, in which case it
691 should ideally be replaced with section's symndx + addend). */
692 struct elf_link_hash_entry *h;
693 } d;
694 /* The addend of the relocation that references the symbol. */
695 bfd_vma addend;
696
697 /* The fields above are used to identify an entry. The fields below
698 contain information on how an entry is used and, later on, which
699 locations it was assigned. */
700 /* The following 3 fields record whether the symbol+addend above was
701 ever referenced with a GOT relocation. The 12 suffix indicates a
702 GOT12 relocation; los is used for GOTLO relocations that are not
703 matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
704 pairs. */
705 unsigned got12:1;
706 unsigned gotlos:1;
707 unsigned gothilo:1;
708 /* Whether a FUNCDESC relocation references symbol+addend. */
709 unsigned fd:1;
710 /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
711 unsigned fdgot12:1;
712 unsigned fdgotlos:1;
713 unsigned fdgothilo:1;
714 /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
715 unsigned fdgoff12:1;
716 unsigned fdgofflos:1;
717 unsigned fdgoffhilo:1;
718 /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
719 GOTOFFHI relocations. The addend doesn't really matter, since we
720 envision that this will only be used to check whether the symbol
721 is mapped to the same segment as the got. */
722 unsigned gotoff:1;
723 /* Whether symbol+addend is referenced by a LABEL24 relocation. */
724 unsigned call:1;
725 /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
726 relocation. */
727 unsigned sym:1;
728 /* Whether we need a PLT entry for a symbol. Should be implied by
729 something like:
730 (call && symndx == -1 && ! FRV_SYM_LOCAL (info, d.h)) */
731 unsigned plt:1;
732 /* Whether a function descriptor should be created in this link unit
733 for symbol+addend. Should be implied by something like:
734 (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
735 || ((fd || fdgot12 || fdgotlos || fdgothilo)
736 && (symndx != -1 || FRV_FUNCDESC_LOCAL (info, d.h)))) */
737 unsigned privfd:1;
738 /* Whether a lazy PLT entry is needed for this symbol+addend.
739 Should be implied by something like:
740 (privfd && symndx == -1 && ! FRV_SYM_LOCAL (info, d.h)
741 && ! (info->flags & DF_BIND_NOW)) */
742 unsigned lazyplt:1;
743 /* Whether we've already emitted GOT relocations and PLT entries as
744 needed for this symbol. */
745 unsigned done:1;
746
747 /* The number of R_FRV_32, R_FRV_FUNCDESC and R_FRV_FUNCDESC_VALUE
748 relocations referencing the symbol. */
749 unsigned relocs32, relocsfd, relocsfdv;
750
751 /* The offsets of the GOT entries assigned to symbol+addend, to the
752 function descriptor's address, and to a function descriptor,
753 respectively. Should be zero if unassigned. The offsets are
754 counted from the value that will be assigned to the PIC register,
755 not from the beginning of the .got section. */
756 bfd_signed_vma got_entry, fdgot_entry, fd_entry;
757 /* The offsets of the PLT entries assigned to symbol+addend,
758 non-lazy and lazy, respectively. If unassigned, should be
759 (bfd_vma)-1. */
760 bfd_vma plt_entry, lzplt_entry;
761 };
762
763 /* Compute a hash with the key fields of an frv_pic_relocs_info entry. */
764 static hashval_t
765 frv_pic_relocs_info_hash (const void *entry_)
766 {
767 const struct frv_pic_relocs_info *entry = entry_;
768
769 return (entry->symndx == -1
770 ? entry->d.h->root.root.hash
771 : entry->symndx + entry->d.abfd->id * 257) + entry->addend;
772 }
773
774 /* Test whether the key fields of two frv_pic_relocs_info entries are
775 identical. */
776 static int
777 frv_pic_relocs_info_eq (const void *entry1, const void *entry2)
778 {
779 const struct frv_pic_relocs_info *e1 = entry1;
780 const struct frv_pic_relocs_info *e2 = entry2;
781
782 return e1->symndx == e2->symndx && e1->addend == e2->addend
783 && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
784 }
785
786 /* Find or create an entry in a hash table HT that matches the key
787 fields of the given ENTRY. If it's not found, memory for a new
788 entry is allocated in ABFD's obstack. */
789 static struct frv_pic_relocs_info *
790 frv_pic_relocs_info_find (struct htab *ht,
791 bfd *abfd,
792 const struct frv_pic_relocs_info *entry)
793 {
794 struct frv_pic_relocs_info **loc =
795 (struct frv_pic_relocs_info **) htab_find_slot (ht, entry, INSERT);
796
797 if (*loc)
798 return *loc;
799
800 *loc = bfd_zalloc (abfd, sizeof (**loc));
801
802 if (! *loc)
803 return *loc;
804
805 (*loc)->symndx = entry->symndx;
806 (*loc)->d = entry->d;
807 (*loc)->addend = entry->addend;
808 (*loc)->plt_entry = (bfd_vma)-1;
809 (*loc)->lzplt_entry = (bfd_vma)-1;
810
811 return *loc;
812 }
813
814 /* Obtain the address of the entry in HT associated with H's symbol +
815 addend, creating a new entry if none existed. ABFD is only used
816 for memory allocation purposes. */
817 inline static struct frv_pic_relocs_info *
818 frv_pic_relocs_info_for_global (struct htab *ht,
819 bfd *abfd,
820 struct elf_link_hash_entry *h,
821 bfd_vma addend)
822 {
823 struct frv_pic_relocs_info entry;
824
825 entry.symndx = -1;
826 entry.d.h = h;
827 entry.addend = addend;
828
829 return frv_pic_relocs_info_find (ht, abfd, &entry);
830 }
831
832 /* Obtain the address of the entry in HT associated with the SYMNDXth
833 local symbol of the input bfd ABFD, plus the addend, creating a new
834 entry if none existed. */
835 inline static struct frv_pic_relocs_info *
836 frv_pic_relocs_info_for_local (struct htab *ht,
837 bfd *abfd,
838 long symndx,
839 bfd_vma addend)
840 {
841 struct frv_pic_relocs_info entry;
842
843 entry.symndx = symndx;
844 entry.d.abfd = abfd;
845 entry.addend = addend;
846
847 return frv_pic_relocs_info_find (ht, abfd, &entry);
848 }
849
850 /* Every block of 65535 lazy PLT entries shares a single call to the
851 resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
852 32767, counting from 0). All other lazy PLT entries branch to it
853 in a single instruction. */
854
855 #define FRV_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
856 #define FRV_LZPLT_RESOLV_LOC (8 * 32767)
857
858 /* Add a dynamic relocation to the SRELOC section. */
859
860 inline static bfd_vma
861 _frv_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
862 int reloc_type, long dynindx, bfd_vma addend)
863 {
864 Elf_Internal_Rela outrel;
865 bfd_vma reloc_offset;
866
867 outrel.r_offset = offset;
868 outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
869 outrel.r_addend = addend;
870
871 reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
872 BFD_ASSERT (reloc_offset < sreloc->_raw_size);
873 bfd_elf32_swap_reloc_out (output_bfd, &outrel,
874 sreloc->contents + reloc_offset);
875 sreloc->reloc_count++;
876
877 return reloc_offset;
878 }
879
880 /* Add a fixup to the ROFIXUP section. */
881
882 static bfd_vma
883 _frv_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset)
884 {
885 bfd_vma fixup_offset;
886
887 if (rofixup->flags & SEC_EXCLUDE)
888 return -1;
889
890 fixup_offset = rofixup->reloc_count * 4;
891 if (rofixup->contents)
892 {
893 BFD_ASSERT (fixup_offset < rofixup->_raw_size);
894 bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
895 }
896 rofixup->reloc_count++;
897
898 return fixup_offset;
899 }
900
901 /* Find the segment number in which OSEC, and output section, is
902 located. */
903
904 static unsigned
905 _frv_osec_to_segment (bfd *output_bfd, asection *osec)
906 {
907 struct elf_segment_map *m;
908 Elf_Internal_Phdr *p;
909
910 /* Find the segment that contains the output_section. */
911 for (m = elf_tdata (output_bfd)->segment_map,
912 p = elf_tdata (output_bfd)->phdr;
913 m != NULL;
914 m = m->next, p++)
915 {
916 int i;
917
918 for (i = m->count - 1; i >= 0; i--)
919 if (m->sections[i] == osec)
920 break;
921
922 if (i >= 0)
923 break;
924 }
925
926 return p - elf_tdata (output_bfd)->phdr;
927 }
928
929 inline static bfd_boolean
930 _frv_osec_readonly_p (bfd *output_bfd, asection *osec)
931 {
932 unsigned seg = _frv_osec_to_segment (output_bfd, osec);
933
934 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
935 }
936
937 /* Generate relocations for GOT entries, function descriptors, and
938 code for PLT and lazy PLT entries. */
939
940 inline static bfd_boolean
941 _frv_emit_got_relocs_plt_entries (struct frv_pic_relocs_info *entry,
942 bfd *output_bfd,
943 struct bfd_link_info *info,
944 asection *sec,
945 Elf_Internal_Sym *sym,
946 bfd_vma addend)
947
948 {
949 bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
950 int dynindx = -1;
951
952 if (entry->done)
953 return TRUE;
954 entry->done = 1;
955
956 if (entry->got_entry || entry->fdgot_entry || entry->fd_entry)
957 {
958 /* If the symbol is dynamic, consider it for dynamic
959 relocations, otherwise decay to section + offset. */
960 if (entry->symndx == -1 && entry->d.h->dynindx != -1)
961 dynindx = entry->d.h->dynindx;
962 else
963 {
964 if (sec->output_section
965 && ! bfd_is_abs_section (sec->output_section)
966 && ! bfd_is_und_section (sec->output_section))
967 dynindx = elf_section_data (sec->output_section)->dynindx;
968 else
969 dynindx = 0;
970 }
971 }
972
973 /* Generate relocation for GOT entry pointing to the symbol. */
974 if (entry->got_entry)
975 {
976 int idx = dynindx;
977 bfd_vma ad = addend;
978
979 /* If the symbol is dynamic but binds locally, use
980 section+offset. */
981 if (sec && (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
982 {
983 if (entry->symndx == -1)
984 ad += entry->d.h->root.u.def.value;
985 else
986 ad += sym->st_value;
987 ad += sec->output_offset;
988 if (sec->output_section && elf_section_data (sec->output_section))
989 idx = elf_section_data (sec->output_section)->dynindx;
990 else
991 idx = 0;
992 }
993
994 /* If we're linking an executable at a fixed address, we can
995 omit the dynamic relocation as long as the symbol is local to
996 this module. */
997 if (info->executable && !info->pie
998 && (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
999 {
1000 if (sec)
1001 ad += sec->output_section->vma;
1002 if (entry->symndx != -1 ||
1003 entry->d.h->root.type != bfd_link_hash_undefweak)
1004 _frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
1005 frv_got_section (info)->output_section->vma
1006 + frv_got_section (info)->output_offset
1007 + frv_got_initial_offset (info)
1008 + entry->got_entry);
1009 }
1010 else
1011 _frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
1012 _bfd_elf_section_offset
1013 (output_bfd, info,
1014 frv_got_section (info),
1015 frv_got_initial_offset (info)
1016 + entry->got_entry)
1017 + frv_got_section (info)->output_section->vma
1018 + frv_got_section (info)->output_offset,
1019 R_FRV_32, idx, ad);
1020
1021 bfd_put_32 (output_bfd, ad,
1022 frv_got_section (info)->contents
1023 + frv_got_initial_offset (info)
1024 + entry->got_entry);
1025 }
1026
1027 /* Generate relocation for GOT entry pointing to a canonical
1028 function descriptor. */
1029 if (entry->fdgot_entry)
1030 {
1031 int reloc, idx;
1032 bfd_vma ad;
1033
1034 /* If the symbol is dynamic and there may be dynamic symbol
1035 resolution because we are or are linked with a shared
1036 library, emit a FUNCDESC relocation such that the dynamic
1037 linker will allocate the function descriptor. */
1038 if (entry->symndx == -1 && ! FRV_FUNCDESC_LOCAL (info, entry->d.h))
1039 {
1040 reloc = R_FRV_FUNCDESC;
1041 idx = dynindx;
1042 ad = addend;
1043 if (ad)
1044 return FALSE;
1045 }
1046 else
1047 {
1048 /* Otherwise, we know we have a private function descriptor,
1049 so reference it directly. */
1050 if (elf_hash_table (info)->dynamic_sections_created)
1051 BFD_ASSERT (entry->privfd);
1052 reloc = R_FRV_32;
1053 idx = elf_section_data (frv_got_section (info)->output_section)
1054 ->dynindx;
1055 ad = frv_got_section (info)->output_offset +
1056 frv_got_initial_offset (info) + entry->fd_entry;
1057 }
1058
1059 /* If there is room for dynamic symbol resolution, emit the
1060 dynamic relocation. However, if we're linking an executable
1061 at a fixed location, we won't have emitted a dynamic symbol
1062 entry for the got section, so idx will be zero, which means
1063 we can and should compute the address of the private
1064 descriptor ourselves. */
1065 if (info->executable && !info->pie
1066 && (entry->symndx != -1 || FRV_FUNCDESC_LOCAL (info, entry->d.h)))
1067 {
1068 if (entry->symndx == -1
1069 && entry->d.h->root.type == bfd_link_hash_undefweak)
1070 ad = 0;
1071 else
1072 {
1073 ad += frv_got_section (info)->output_section->vma;
1074 _frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
1075 frv_got_section (info)->output_section->vma
1076 + frv_got_section (info)->output_offset
1077 + frv_got_initial_offset (info)
1078 + entry->fdgot_entry);
1079 }
1080 }
1081 else
1082 _frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
1083 _bfd_elf_section_offset
1084 (output_bfd, info,
1085 frv_got_section (info),
1086 frv_got_initial_offset (info)
1087 + entry->fdgot_entry)
1088 + frv_got_section (info)->output_section->vma
1089 + frv_got_section (info)->output_offset,
1090 reloc, idx, ad);
1091
1092 bfd_put_32 (output_bfd, ad,
1093 frv_got_section (info)->contents
1094 + frv_got_initial_offset (info)
1095 + entry->fdgot_entry);
1096 }
1097
1098 /* Generate relocation to fill in a private function descriptor in
1099 the GOT. */
1100 if (entry->fd_entry)
1101 {
1102 int idx = dynindx;
1103 bfd_vma ad = addend;
1104 bfd_vma ofst;
1105 long lowword, highword;
1106
1107 /* If the symbol is dynamic but binds locally, use
1108 section+offset. */
1109 if (sec && (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
1110 {
1111 if (entry->symndx == -1)
1112 ad += entry->d.h->root.u.def.value;
1113 else
1114 ad += sym->st_value;
1115 ad += sec->output_offset;
1116 if (sec->output_section && elf_section_data (sec->output_section))
1117 idx = elf_section_data (sec->output_section)->dynindx;
1118 else
1119 idx = 0;
1120 }
1121
1122 /* If we're linking an executable at a fixed address, we can
1123 omit the dynamic relocation as long as the symbol is local to
1124 this module. */
1125 if (info->executable && !info->pie
1126 && (entry->symndx != -1 || FRV_SYM_LOCAL (info, entry->d.h)))
1127 {
1128 if (sec)
1129 ad += sec->output_section->vma;
1130 ofst = 0;
1131 if (entry->symndx != -1 ||
1132 entry->d.h->root.type != bfd_link_hash_undefweak)
1133 {
1134 _frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
1135 frv_got_section (info)->output_section->vma
1136 + frv_got_section (info)->output_offset
1137 + frv_got_initial_offset (info)
1138 + entry->fd_entry);
1139 _frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
1140 frv_got_section (info)->output_section->vma
1141 + frv_got_section (info)->output_offset
1142 + frv_got_initial_offset (info)
1143 + entry->fd_entry + 4);
1144 }
1145 }
1146 else
1147 {
1148 ofst =
1149 _frv_add_dyn_reloc (output_bfd,
1150 entry->lazyplt ? frv_pltrel_section (info)
1151 : frv_gotrel_section (info),
1152 _bfd_elf_section_offset
1153 (output_bfd, info,
1154 frv_got_section (info),
1155 frv_got_initial_offset (info)
1156 + entry->fd_entry)
1157 + frv_got_section (info)->output_section->vma
1158 + frv_got_section (info)->output_offset,
1159 R_FRV_FUNCDESC_VALUE, idx, ad);
1160 }
1161
1162 /* If we've omitted the dynamic relocation, just emit the fixed
1163 addresses of the symbol and of the local GOT base offset. */
1164 if (info->executable && !info->pie && sec && sec->output_section)
1165 {
1166 lowword = ad;
1167 highword = frv_got_section (info)->output_section->vma
1168 + frv_got_section (info)->output_offset
1169 + frv_got_initial_offset (info);
1170 }
1171 else if (entry->lazyplt)
1172 {
1173 if (ad)
1174 return FALSE;
1175
1176 fd_lazy_rel_offset = ofst;
1177
1178 /* A function descriptor used for lazy or local resolving is
1179 initialized such that its high word contains the output
1180 section index in which the PLT entries are located, and
1181 the low word contains the address of the lazy PLT entry
1182 entry point, that must be within the memory region
1183 assigned to that section. */
1184 lowword = entry->lzplt_entry + 4
1185 + frv_plt_section (info)->output_offset
1186 + frv_plt_section (info)->output_section->vma;
1187 highword = _frv_osec_to_segment
1188 (output_bfd, frv_plt_section (info)->output_section);
1189 }
1190 else
1191 {
1192 /* A function descriptor for a local function gets the index
1193 of the section. For a non-local function, it's
1194 disregarded. */
1195 lowword = ad;
1196 if (entry->symndx == -1 && entry->d.h->dynindx != -1
1197 && entry->d.h->dynindx == idx)
1198 highword = 0;
1199 else
1200 highword = _frv_osec_to_segment (output_bfd, sec->output_section);
1201 }
1202
1203 bfd_put_32 (output_bfd, lowword,
1204 frv_got_section (info)->contents
1205 + frv_got_initial_offset (info)
1206 + entry->fd_entry);
1207 bfd_put_32 (output_bfd, highword,
1208 frv_got_section (info)->contents
1209 + frv_got_initial_offset (info)
1210 + entry->fd_entry + 4);
1211 }
1212
1213 /* Generate code for the PLT entry. */
1214 if (entry->plt_entry != (bfd_vma) -1)
1215 {
1216 bfd_byte *plt_code = frv_plt_section (info)->contents + entry->plt_entry;
1217
1218 BFD_ASSERT (entry->fd_entry);
1219
1220 /* Figure out what kind of PLT entry we need, depending on the
1221 location of the function descriptor within the GOT. */
1222 if (entry->fd_entry >= -(1 << (12 - 1))
1223 && entry->fd_entry < (1 << (12 - 1)))
1224 {
1225 /* lddi @(gr15, fd_entry), gr14 */
1226 bfd_put_32 (output_bfd,
1227 0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1228 plt_code);
1229 plt_code += 4;
1230 }
1231 else
1232 {
1233 if (entry->fd_entry >= -(1 << (16 - 1))
1234 && entry->fd_entry < (1 << (16 - 1)))
1235 {
1236 /* setlos lo(fd_entry), gr14 */
1237 bfd_put_32 (output_bfd,
1238 0x9cfc0000
1239 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1240 plt_code);
1241 plt_code += 4;
1242 }
1243 else
1244 {
1245 /* sethi.p hi(fd_entry), gr14
1246 setlo lo(fd_entry), gr14 */
1247 bfd_put_32 (output_bfd,
1248 0x1cf80000
1249 | ((entry->fd_entry >> 16)
1250 & (((bfd_vma)1 << 16) - 1)),
1251 plt_code);
1252 bfd_put_32 (output_bfd,
1253 0x9cf40000
1254 | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1255 plt_code);
1256 plt_code += 8;
1257 }
1258 /* ldd @(gr14,gr15),gr14 */
1259 bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
1260 plt_code += 4;
1261 }
1262 /* jmpl @(gr14,gr0) */
1263 bfd_put_32 (output_bfd, 0x8030e000, plt_code);
1264 }
1265
1266 /* Generate code for the lazy PLT entry. */
1267 if (entry->lzplt_entry != (bfd_vma) -1)
1268 {
1269 bfd_byte *lzplt_code = frv_plt_section (info)->contents
1270 + entry->lzplt_entry;
1271 bfd_vma resolverStub_addr;
1272
1273 bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1274 lzplt_code += 4;
1275
1276 resolverStub_addr = entry->lzplt_entry / FRV_LZPLT_BLOCK_SIZE
1277 * FRV_LZPLT_BLOCK_SIZE + FRV_LZPLT_RESOLV_LOC;
1278 if (resolverStub_addr >= frv_plt_initial_offset (info))
1279 resolverStub_addr = frv_plt_initial_offset (info) - 12;
1280
1281 if (entry->lzplt_entry == resolverStub_addr)
1282 {
1283 /* This is a lazy PLT entry that includes a resolver call. */
1284 /* ldd @(gr15,gr0), gr4
1285 jmpl @(gr4,gr0) */
1286 bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
1287 bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
1288 }
1289 else
1290 {
1291 /* bra resolverStub */
1292 bfd_put_32 (output_bfd,
1293 0xc01a0000
1294 | (((resolverStub_addr - entry->lzplt_entry)
1295 / 4) & (((bfd_vma)1 << 16) - 1)),
1296 lzplt_code);
1297 }
1298 }
1299
1300 return TRUE;
1301 }
1302
1303 /* Handle an FRV small data reloc. */
1304
1305 static bfd_reloc_status_type
1306 elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
1307 contents, value)
1308 struct bfd_link_info *info;
1309 bfd *input_bfd;
1310 asection *input_section;
1311 Elf_Internal_Rela *relocation;
1312 bfd_byte *contents;
1313 bfd_vma value;
1314 {
1315 bfd_vma insn;
1316 bfd_vma gp;
1317 struct bfd_link_hash_entry *h;
1318
1319 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1320
1321 gp = (h->u.def.value
1322 + h->u.def.section->output_section->vma
1323 + h->u.def.section->output_offset);
1324
1325 value -= input_section->output_section->vma;
1326 value -= (gp - input_section->output_section->vma);
1327
1328 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1329
1330 value += relocation->r_addend;
1331
1332 if ((long) value > 0x7ff || (long) value < -0x800)
1333 return bfd_reloc_overflow;
1334
1335 bfd_put_32 (input_bfd,
1336 (insn & 0xfffff000) | (value & 0xfff),
1337 contents + relocation->r_offset);
1338
1339 return bfd_reloc_ok;
1340 }
1341
1342 /* Handle an FRV small data reloc. for the u12 field. */
1343
1344 static bfd_reloc_status_type
1345 elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
1346 contents, value)
1347 struct bfd_link_info *info;
1348 bfd *input_bfd;
1349 asection *input_section;
1350 Elf_Internal_Rela *relocation;
1351 bfd_byte *contents;
1352 bfd_vma value;
1353 {
1354 bfd_vma insn;
1355 bfd_vma gp;
1356 struct bfd_link_hash_entry *h;
1357 bfd_vma mask;
1358
1359 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1360
1361 gp = (h->u.def.value
1362 + h->u.def.section->output_section->vma
1363 + h->u.def.section->output_offset);
1364
1365 value -= input_section->output_section->vma;
1366 value -= (gp - input_section->output_section->vma);
1367
1368 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1369
1370 value += relocation->r_addend;
1371
1372 if ((long) value > 0x7ff || (long) value < -0x800)
1373 return bfd_reloc_overflow;
1374
1375 /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0. */
1376 mask = 0x3f03f;
1377 insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
1378
1379 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
1380
1381 return bfd_reloc_ok;
1382 }
1383
1384 /* Handle an FRV ELF HI16 reloc. */
1385
1386 static bfd_reloc_status_type
1387 elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
1388 bfd *input_bfd;
1389 Elf_Internal_Rela *relhi;
1390 bfd_byte *contents;
1391 bfd_vma value;
1392 {
1393 bfd_vma insn;
1394
1395 insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
1396
1397 value += relhi->r_addend;
1398 value = ((value >> 16) & 0xffff);
1399
1400 insn = (insn & 0xffff0000) | value;
1401
1402 if ((long) value > 0xffff || (long) value < -0x10000)
1403 return bfd_reloc_overflow;
1404
1405 bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
1406 return bfd_reloc_ok;
1407
1408 }
1409 static bfd_reloc_status_type
1410 elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
1411 bfd *input_bfd;
1412 Elf_Internal_Rela *rello;
1413 bfd_byte *contents;
1414 bfd_vma value;
1415 {
1416 bfd_vma insn;
1417
1418 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
1419
1420 value += rello->r_addend;
1421 value = value & 0xffff;
1422
1423 insn = (insn & 0xffff0000) | value;
1424
1425 if ((long) value > 0xffff || (long) value < -0x10000)
1426 return bfd_reloc_overflow;
1427
1428 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
1429 return bfd_reloc_ok;
1430 }
1431
1432 /* Perform the relocation for the CALL label24 instruction. */
1433
1434 static bfd_reloc_status_type
1435 elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
1436 bfd *input_bfd;
1437 asection *input_section;
1438 Elf_Internal_Rela *rello;
1439 bfd_byte *contents;
1440 bfd_vma value;
1441 {
1442 bfd_vma insn;
1443 bfd_vma label6;
1444 bfd_vma label18;
1445
1446 /* The format for the call instruction is:
1447
1448 0 000000 0001111 000000000000000000
1449 label6 opcode label18
1450
1451 The branch calculation is: pc + (4*label24)
1452 where label24 is the concatenation of label6 and label18. */
1453
1454 /* Grab the instruction. */
1455 insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
1456
1457 value -= input_section->output_section->vma + input_section->output_offset;
1458 value -= rello->r_offset;
1459 value += rello->r_addend;
1460
1461 value = value >> 2;
1462
1463 label6 = value & 0xfc0000;
1464 label6 = label6 << 7;
1465
1466 label18 = value & 0x3ffff;
1467
1468 insn = insn & 0x803c0000;
1469 insn = insn | label6;
1470 insn = insn | label18;
1471
1472 bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
1473
1474 return bfd_reloc_ok;
1475 }
1476
1477 static bfd_reloc_status_type
1478 elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
1479 contents, value)
1480 struct bfd_link_info *info;
1481 bfd *input_bfd;
1482 asection *input_section;
1483 Elf_Internal_Rela *relocation;
1484 bfd_byte *contents;
1485 bfd_vma value;
1486 {
1487 bfd_vma insn;
1488 bfd_vma gp;
1489 struct bfd_link_hash_entry *h;
1490
1491 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1492
1493 gp = (h->u.def.value
1494 + h->u.def.section->output_section->vma
1495 + h->u.def.section->output_offset);
1496
1497 value -= input_section->output_section->vma;
1498 value -= (gp - input_section->output_section->vma);
1499 value += relocation->r_addend;
1500 value = ((value >> 16) & 0xffff);
1501
1502 if ((long) value > 0xffff || (long) value < -0x10000)
1503 return bfd_reloc_overflow;
1504
1505 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1506 insn = (insn & 0xffff0000) | value;
1507
1508 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
1509 return bfd_reloc_ok;
1510 }
1511
1512 static bfd_reloc_status_type
1513 elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
1514 contents, value)
1515 struct bfd_link_info *info;
1516 bfd *input_bfd;
1517 asection *input_section;
1518 Elf_Internal_Rela *relocation;
1519 bfd_byte *contents;
1520 bfd_vma value;
1521 {
1522 bfd_vma insn;
1523 bfd_vma gp;
1524 struct bfd_link_hash_entry *h;
1525
1526 h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1527
1528 gp = (h->u.def.value
1529 + h->u.def.section->output_section->vma
1530 + h->u.def.section->output_offset);
1531
1532 value -= input_section->output_section->vma;
1533 value -= (gp - input_section->output_section->vma);
1534 value += relocation->r_addend;
1535 value = value & 0xffff;
1536
1537 if ((long) value > 0xffff || (long) value < -0x10000)
1538 return bfd_reloc_overflow;
1539
1540 insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1541 insn = (insn & 0xffff0000) | value;
1542
1543 bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
1544
1545 return bfd_reloc_ok;
1546 }
1547
1548 static reloc_howto_type *
1549 frv_reloc_type_lookup (abfd, code)
1550 bfd *abfd ATTRIBUTE_UNUSED;
1551 bfd_reloc_code_real_type code;
1552 {
1553 switch (code)
1554 {
1555 default:
1556 break;
1557
1558 case BFD_RELOC_NONE:
1559 return &elf32_frv_howto_table[ (int) R_FRV_NONE];
1560
1561 case BFD_RELOC_32:
1562 if (elf_elfheader (abfd)->e_type == ET_EXEC
1563 || elf_elfheader (abfd)->e_type == ET_DYN)
1564 return &elf32_frv_rel_32_howto;
1565 /* Fall through. */
1566 case BFD_RELOC_CTOR:
1567 return &elf32_frv_howto_table[ (int) R_FRV_32];
1568
1569 case BFD_RELOC_FRV_LABEL16:
1570 return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
1571
1572 case BFD_RELOC_FRV_LABEL24:
1573 return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
1574
1575 case BFD_RELOC_FRV_LO16:
1576 return &elf32_frv_howto_table[ (int) R_FRV_LO16];
1577
1578 case BFD_RELOC_FRV_HI16:
1579 return &elf32_frv_howto_table[ (int) R_FRV_HI16];
1580
1581 case BFD_RELOC_FRV_GPREL12:
1582 return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
1583
1584 case BFD_RELOC_FRV_GPRELU12:
1585 return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
1586
1587 case BFD_RELOC_FRV_GPREL32:
1588 return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
1589
1590 case BFD_RELOC_FRV_GPRELHI:
1591 return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
1592
1593 case BFD_RELOC_FRV_GPRELLO:
1594 return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
1595
1596 case BFD_RELOC_FRV_GOT12:
1597 return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
1598
1599 case BFD_RELOC_FRV_GOTHI:
1600 return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
1601
1602 case BFD_RELOC_FRV_GOTLO:
1603 return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
1604
1605 case BFD_RELOC_FRV_FUNCDESC:
1606 if (elf_elfheader (abfd)->e_type == ET_EXEC
1607 || elf_elfheader (abfd)->e_type == ET_DYN)
1608 return &elf32_frv_rel_funcdesc_howto;
1609 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
1610
1611 case BFD_RELOC_FRV_FUNCDESC_GOT12:
1612 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
1613
1614 case BFD_RELOC_FRV_FUNCDESC_GOTHI:
1615 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
1616
1617 case BFD_RELOC_FRV_FUNCDESC_GOTLO:
1618 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
1619
1620 case BFD_RELOC_FRV_FUNCDESC_VALUE:
1621 if (elf_elfheader (abfd)->e_type == ET_EXEC
1622 || elf_elfheader (abfd)->e_type == ET_DYN)
1623 return &elf32_frv_rel_funcdesc_value_howto;
1624 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
1625
1626 case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
1627 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
1628
1629 case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
1630 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
1631
1632 case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
1633 return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
1634
1635 case BFD_RELOC_FRV_GOTOFF12:
1636 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
1637
1638 case BFD_RELOC_FRV_GOTOFFHI:
1639 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
1640
1641 case BFD_RELOC_FRV_GOTOFFLO:
1642 return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
1643
1644 case BFD_RELOC_VTABLE_INHERIT:
1645 return &elf32_frv_vtinherit_howto;
1646
1647 case BFD_RELOC_VTABLE_ENTRY:
1648 return &elf32_frv_vtentry_howto;
1649 }
1650
1651 return NULL;
1652 }
1653
1654 /* Set the howto pointer for an FRV ELF reloc. */
1655
1656 static void
1657 frv_info_to_howto_rela (abfd, cache_ptr, dst)
1658 bfd *abfd ATTRIBUTE_UNUSED;
1659 arelent *cache_ptr;
1660 Elf_Internal_Rela *dst;
1661 {
1662 unsigned int r_type;
1663
1664 r_type = ELF32_R_TYPE (dst->r_info);
1665 switch (r_type)
1666 {
1667 case R_FRV_GNU_VTINHERIT:
1668 cache_ptr->howto = &elf32_frv_vtinherit_howto;
1669 break;
1670
1671 case R_FRV_GNU_VTENTRY:
1672 cache_ptr->howto = &elf32_frv_vtentry_howto;
1673 break;
1674
1675 default:
1676 cache_ptr->howto = & elf32_frv_howto_table [r_type];
1677 break;
1678 }
1679 }
1680
1681 /* Set the howto pointer for an FRV ELF REL reloc. */
1682 static void
1683 frv_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1684 arelent *cache_ptr, Elf_Internal_Rela *dst)
1685 {
1686 unsigned int r_type;
1687
1688 r_type = ELF32_R_TYPE (dst->r_info);
1689 switch (r_type)
1690 {
1691 case R_FRV_32:
1692 cache_ptr->howto = &elf32_frv_rel_32_howto;
1693 break;
1694
1695 case R_FRV_FUNCDESC:
1696 cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
1697 break;
1698
1699 case R_FRV_FUNCDESC_VALUE:
1700 cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
1701 break;
1702
1703 default:
1704 cache_ptr->howto = NULL;
1705 break;
1706 }
1707 }
1708 \f
1709 /* Perform a single relocation. By default we use the standard BFD
1710 routines, but a few relocs, we have to do them ourselves. */
1711
1712 static bfd_reloc_status_type
1713 frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
1714 relocation)
1715 reloc_howto_type *howto;
1716 bfd *input_bfd;
1717 asection *input_section;
1718 bfd_byte *contents;
1719 Elf_Internal_Rela *rel;
1720 bfd_vma relocation;
1721 {
1722 return _bfd_final_link_relocate (howto, input_bfd, input_section,
1723 contents, rel->r_offset, relocation,
1724 rel->r_addend);
1725 }
1726
1727 \f
1728 /* Relocate an FRV ELF section.
1729
1730 The RELOCATE_SECTION function is called by the new ELF backend linker
1731 to handle the relocations for a section.
1732
1733 The relocs are always passed as Rela structures; if the section
1734 actually uses Rel structures, the r_addend field will always be
1735 zero.
1736
1737 This function is responsible for adjusting the section contents as
1738 necessary, and (if using Rela relocs and generating a relocatable
1739 output file) adjusting the reloc addend as necessary.
1740
1741 This function does not have to worry about setting the reloc
1742 address or the reloc symbol index.
1743
1744 LOCAL_SYMS is a pointer to the swapped in local symbols.
1745
1746 LOCAL_SECTIONS is an array giving the section in the input file
1747 corresponding to the st_shndx field of each local symbol.
1748
1749 The global hash table entry for the global symbols can be found
1750 via elf_sym_hashes (input_bfd).
1751
1752 When generating relocatable output, this function must handle
1753 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1754 going to be the section symbol corresponding to the output
1755 section, which means that the addend must be adjusted
1756 accordingly. */
1757
1758 static bfd_boolean
1759 elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
1760 contents, relocs, local_syms, local_sections)
1761 bfd *output_bfd ATTRIBUTE_UNUSED;
1762 struct bfd_link_info *info;
1763 bfd *input_bfd;
1764 asection *input_section;
1765 bfd_byte *contents;
1766 Elf_Internal_Rela *relocs;
1767 Elf_Internal_Sym *local_syms;
1768 asection **local_sections;
1769 {
1770 Elf_Internal_Shdr *symtab_hdr;
1771 struct elf_link_hash_entry **sym_hashes;
1772 Elf_Internal_Rela *rel;
1773 Elf_Internal_Rela *relend;
1774 unsigned isec_segment, got_segment, plt_segment, gprel_segment,
1775 check_segment[2];
1776 int silence_segment_error = !(info->shared || info->pie);
1777
1778 if (info->relocatable)
1779 return TRUE;
1780
1781 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1782 sym_hashes = elf_sym_hashes (input_bfd);
1783 relend = relocs + input_section->reloc_count;
1784
1785 isec_segment = _frv_osec_to_segment (output_bfd,
1786 input_section->output_section);
1787 if (frv_got_section (info))
1788 got_segment = _frv_osec_to_segment (output_bfd,
1789 frv_got_section (info)
1790 ->output_section);
1791 else
1792 got_segment = -1;
1793 if (frv_gotfixup_section (info))
1794 gprel_segment = _frv_osec_to_segment (output_bfd,
1795 frv_gotfixup_section (info)
1796 ->output_section);
1797 else
1798 gprel_segment = -1;
1799 if (elf_hash_table (info)->dynamic_sections_created)
1800 plt_segment = _frv_osec_to_segment (output_bfd,
1801 frv_plt_section (info)
1802 ->output_section);
1803 else
1804 plt_segment = -1;
1805
1806 for (rel = relocs; rel < relend; rel ++)
1807 {
1808 reloc_howto_type *howto;
1809 unsigned long r_symndx;
1810 Elf_Internal_Sym *sym;
1811 asection *sec;
1812 struct elf_link_hash_entry *h;
1813 bfd_vma relocation;
1814 bfd_reloc_status_type r;
1815 const char * name = NULL;
1816 int r_type;
1817 asection *osec;
1818 struct frv_pic_relocs_info *picrel;
1819 bfd_vma orig_addend = rel->r_addend;
1820
1821 r_type = ELF32_R_TYPE (rel->r_info);
1822
1823 if ( r_type == R_FRV_GNU_VTINHERIT
1824 || r_type == R_FRV_GNU_VTENTRY)
1825 continue;
1826
1827 /* This is a final link. */
1828 r_symndx = ELF32_R_SYM (rel->r_info);
1829 howto = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
1830 h = NULL;
1831 sym = NULL;
1832 sec = NULL;
1833
1834 if (r_symndx < symtab_hdr->sh_info)
1835 {
1836 sym = local_syms + r_symndx;
1837 osec = sec = local_sections [r_symndx];
1838 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1839
1840 name = bfd_elf_string_from_elf_section
1841 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1842 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1843 }
1844 else
1845 {
1846 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
1847
1848 while (h->root.type == bfd_link_hash_indirect
1849 || h->root.type == bfd_link_hash_warning)
1850 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1851
1852 name = h->root.root.string;
1853
1854 if ((h->root.type == bfd_link_hash_defined
1855 || h->root.type == bfd_link_hash_defweak)
1856 && ! FRV_SYM_LOCAL (info, h))
1857 {
1858 sec = NULL;
1859 relocation = 0;
1860 }
1861 else
1862 if (h->root.type == bfd_link_hash_defined
1863 || h->root.type == bfd_link_hash_defweak)
1864 {
1865 sec = h->root.u.def.section;
1866 relocation = (h->root.u.def.value
1867 + sec->output_section->vma
1868 + sec->output_offset);
1869 }
1870 else if (h->root.type == bfd_link_hash_undefweak)
1871 {
1872 relocation = 0;
1873 }
1874 else if ( ! info->executable
1875 && ! info->symbolic
1876 && info->unresolved_syms_in_objects == RM_IGNORE
1877 && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1878 relocation = 0;
1879 else
1880 {
1881 if (! ((*info->callbacks->undefined_symbol)
1882 (info, h->root.root.string, input_bfd,
1883 input_section, rel->r_offset, TRUE)))
1884 return FALSE;
1885 relocation = 0;
1886 }
1887 osec = sec;
1888 }
1889
1890 switch (r_type)
1891 {
1892 case R_FRV_LABEL24:
1893 case R_FRV_32:
1894 case R_FRV_GOT12:
1895 case R_FRV_GOTHI:
1896 case R_FRV_GOTLO:
1897 case R_FRV_FUNCDESC_GOT12:
1898 case R_FRV_FUNCDESC_GOTHI:
1899 case R_FRV_FUNCDESC_GOTLO:
1900 case R_FRV_GOTOFF12:
1901 case R_FRV_GOTOFFHI:
1902 case R_FRV_GOTOFFLO:
1903 case R_FRV_FUNCDESC_GOTOFF12:
1904 case R_FRV_FUNCDESC_GOTOFFHI:
1905 case R_FRV_FUNCDESC_GOTOFFLO:
1906 case R_FRV_FUNCDESC:
1907 case R_FRV_FUNCDESC_VALUE:
1908 if (h != NULL)
1909 picrel = frv_pic_relocs_info_for_global (frv_relocs_info (info),
1910 input_bfd, h,
1911 orig_addend);
1912 else
1913 /* In order to find the entry we created before, we must
1914 use the original addend, not the one that may have been
1915 modified by _bfd_elf_rela_local_sym(). */
1916 picrel = frv_pic_relocs_info_for_local (frv_relocs_info (info),
1917 input_bfd, r_symndx,
1918 orig_addend);
1919 if (! picrel)
1920 return FALSE;
1921
1922 if (!_frv_emit_got_relocs_plt_entries (picrel, output_bfd, info,
1923 osec, sym, rel->r_addend))
1924 {
1925 info->callbacks->warning
1926 (info, _("Dynamic relocation references symbol with nonzero addend"),
1927 name, input_bfd, input_section, rel->r_offset);
1928 return FALSE;
1929
1930 }
1931
1932 break;
1933
1934 default:
1935 picrel = NULL;
1936 if (h && ! FRV_SYM_LOCAL (info, h))
1937 {
1938 info->callbacks->warning
1939 (info, _("relocation references symbol not defined in the module"),
1940 name, input_bfd, input_section, rel->r_offset);
1941 return FALSE;
1942 }
1943 break;
1944 }
1945
1946 switch (r_type)
1947 {
1948 case R_FRV_LABEL24:
1949 check_segment[0] = isec_segment;
1950 if (picrel->plt)
1951 {
1952 relocation = frv_plt_section (info)->output_section->vma
1953 + frv_plt_section (info)->output_offset
1954 + picrel->plt_entry;
1955 check_segment[1] = plt_segment;
1956 }
1957 /* We don't want to warn on calls to undefined weak symbols,
1958 as calls to them must be protected by non-NULL tests
1959 anyway, and unprotected calls would invoke undefined
1960 behavior. */
1961 else if (picrel->symndx == -1
1962 && picrel->d.h->root.type == bfd_link_hash_undefweak)
1963 check_segment[1] = check_segment[0];
1964 else
1965 check_segment[1] = sec
1966 ? _frv_osec_to_segment (output_bfd, sec->output_section)
1967 : (unsigned)-1;
1968 break;
1969
1970 case R_FRV_GOT12:
1971 case R_FRV_GOTHI:
1972 case R_FRV_GOTLO:
1973 relocation = picrel->got_entry;
1974 check_segment[0] = check_segment[1] = got_segment;
1975 break;
1976
1977 case R_FRV_FUNCDESC_GOT12:
1978 case R_FRV_FUNCDESC_GOTHI:
1979 case R_FRV_FUNCDESC_GOTLO:
1980 relocation = picrel->fdgot_entry;
1981 check_segment[0] = check_segment[1] = got_segment;
1982 break;
1983
1984 case R_FRV_GOTOFFHI:
1985 case R_FRV_GOTOFF12:
1986 case R_FRV_GOTOFFLO:
1987 relocation -= frv_got_section (info)->output_section->vma
1988 + frv_got_section (info)->output_offset
1989 + frv_got_initial_offset (info);
1990 check_segment[0] = got_segment;
1991 check_segment[1] = sec
1992 ? _frv_osec_to_segment (output_bfd, sec->output_section)
1993 : (unsigned)-1;
1994 break;
1995
1996 case R_FRV_FUNCDESC_GOTOFF12:
1997 case R_FRV_FUNCDESC_GOTOFFHI:
1998 case R_FRV_FUNCDESC_GOTOFFLO:
1999 relocation = picrel->fd_entry;
2000 check_segment[0] = check_segment[1] = got_segment;
2001 break;
2002
2003 case R_FRV_FUNCDESC:
2004 {
2005 int dynindx;
2006 bfd_vma addend = rel->r_addend;
2007
2008 /* If the symbol is dynamic and there may be dynamic
2009 symbol resolution because we are or are linked with a
2010 shared library, emit a FUNCDESC relocation such that
2011 the dynamic linker will allocate the function
2012 descriptor. */
2013 if (h && ! FRV_FUNCDESC_LOCAL (info, h))
2014 {
2015 if (addend)
2016 {
2017 info->callbacks->warning
2018 (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
2019 name, input_bfd, input_section, rel->r_offset);
2020 return FALSE;
2021 }
2022 dynindx = h->dynindx;
2023 }
2024 else
2025 {
2026 /* Otherwise, we know we have a private function
2027 descriptor, so reference it directly. */
2028 BFD_ASSERT (picrel->privfd);
2029 r_type = R_FRV_32;
2030 dynindx = elf_section_data (frv_got_section
2031 (info)->output_section)->dynindx;
2032 addend = frv_got_section (info)->output_offset
2033 + frv_got_initial_offset (info)
2034 + picrel->fd_entry;
2035 }
2036
2037 /* If there is room for dynamic symbol resolution, emit
2038 the dynamic relocation. However, if we're linking an
2039 executable at a fixed location, we won't have emitted a
2040 dynamic symbol entry for the got section, so idx will
2041 be zero, which means we can and should compute the
2042 address of the private descriptor ourselves. */
2043 if (info->executable && !info->pie
2044 && (!h || FRV_FUNCDESC_LOCAL (info, h)))
2045 {
2046 addend += frv_got_section (info)->output_section->vma;
2047 if ((bfd_get_section_flags (output_bfd,
2048 input_section->output_section)
2049 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2050 {
2051 if (_frv_osec_readonly_p (output_bfd,
2052 input_section->output_section))
2053 {
2054 info->callbacks->warning
2055 (info,
2056 _("cannot emit fixups in read-only section"),
2057 name, input_bfd, input_section, rel->r_offset);
2058 return FALSE;
2059 }
2060 if (! h || h->root.type != bfd_link_hash_undefweak)
2061 _frv_add_rofixup (output_bfd,
2062 frv_gotfixup_section (info),
2063 _bfd_elf_section_offset
2064 (output_bfd, info,
2065 input_section, rel->r_offset)
2066 + input_section->output_section->vma
2067 + input_section->output_offset);
2068 }
2069 }
2070 else if ((bfd_get_section_flags (output_bfd,
2071 input_section->output_section)
2072 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2073 {
2074 if (_frv_osec_readonly_p (output_bfd,
2075 input_section->output_section))
2076 {
2077 info->callbacks->warning
2078 (info,
2079 _("cannot emit dynamic relocations in read-only section"),
2080 name, input_bfd, input_section, rel->r_offset);
2081 return FALSE;
2082 }
2083 _frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
2084 _bfd_elf_section_offset
2085 (output_bfd, info,
2086 input_section, rel->r_offset)
2087 + input_section->output_section->vma
2088 + input_section->output_offset,
2089 r_type, dynindx, addend);
2090 }
2091
2092 /* We want the addend in-place because dynamic
2093 relocations are REL. Setting relocation to it should
2094 arrange for it to be installed. */
2095 relocation = addend - rel->r_addend;
2096 }
2097 check_segment[0] = check_segment[1] = got_segment;
2098 break;
2099
2100 case R_FRV_32:
2101 case R_FRV_FUNCDESC_VALUE:
2102 {
2103 int dynindx;
2104 bfd_vma addend = rel->r_addend;
2105
2106 /* If the symbol is dynamic but binds locally, use
2107 section+offset. */
2108 if (h && ! FRV_SYM_LOCAL (info, h))
2109 {
2110 if (addend && r_type == R_FRV_FUNCDESC_VALUE)
2111 {
2112 info->callbacks->warning
2113 (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2114 name, input_bfd, input_section, rel->r_offset);
2115 return FALSE;
2116 }
2117 dynindx = h->dynindx;
2118 }
2119 else
2120 {
2121 if (h)
2122 addend += h->root.u.def.value;
2123 else
2124 addend += sym->st_value;
2125 if (osec)
2126 addend += osec->output_offset;
2127 if (osec && osec->output_section
2128 && ! bfd_is_abs_section (osec->output_section)
2129 && ! bfd_is_und_section (osec->output_section))
2130 dynindx = elf_section_data (osec->output_section)->dynindx;
2131 else
2132 dynindx = 0;
2133 }
2134
2135 /* If we're linking an executable at a fixed address, we
2136 can omit the dynamic relocation as long as the symbol
2137 is defined in the current link unit (which is implied
2138 by its output section not being NULL). */
2139 if (info->executable && !info->pie
2140 && (!h || FRV_SYM_LOCAL (info, h)))
2141 {
2142 if (osec)
2143 addend += osec->output_section->vma;
2144 if ((elf_elfheader (input_bfd)->e_flags & EF_FRV_FDPIC)
2145 && (bfd_get_section_flags (output_bfd,
2146 input_section->output_section)
2147 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2148 {
2149 if (_frv_osec_readonly_p (output_bfd,
2150 input_section->output_section))
2151 {
2152 info->callbacks->warning
2153 (info,
2154 _("cannot emit fixups in read-only section"),
2155 name, input_bfd, input_section, rel->r_offset);
2156 return FALSE;
2157 }
2158 if (!h || h->root.type != bfd_link_hash_undefweak)
2159 {
2160 _frv_add_rofixup (output_bfd,
2161 frv_gotfixup_section (info),
2162 _bfd_elf_section_offset
2163 (output_bfd, info,
2164 input_section, rel->r_offset)
2165 + input_section->output_section->vma
2166 + input_section->output_offset);
2167 if (r_type == R_FRV_FUNCDESC_VALUE)
2168 _frv_add_rofixup
2169 (output_bfd,
2170 frv_gotfixup_section (info),
2171 _bfd_elf_section_offset
2172 (output_bfd, info,
2173 input_section, rel->r_offset)
2174 + input_section->output_section->vma
2175 + input_section->output_offset + 4);
2176 }
2177 }
2178 }
2179 else
2180 {
2181 if ((bfd_get_section_flags (output_bfd,
2182 input_section->output_section)
2183 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2184 {
2185 if (_frv_osec_readonly_p (output_bfd,
2186 input_section->output_section))
2187 {
2188 info->callbacks->warning
2189 (info,
2190 _("cannot emit dynamic relocations in read-only section"),
2191 name, input_bfd, input_section, rel->r_offset);
2192 return FALSE;
2193 }
2194 _frv_add_dyn_reloc (output_bfd, frv_gotrel_section (info),
2195 _bfd_elf_section_offset
2196 (output_bfd, info,
2197 input_section, rel->r_offset)
2198 + input_section->output_section->vma
2199 + input_section->output_offset,
2200 r_type, dynindx, addend);
2201 }
2202 /* We want the addend in-place because dynamic
2203 relocations are REL. Setting relocation to it
2204 should arrange for it to be installed. */
2205 relocation = addend - rel->r_addend;
2206 }
2207
2208 if (r_type == R_FRV_FUNCDESC_VALUE)
2209 {
2210 /* If we've omitted the dynamic relocation, just emit
2211 the fixed addresses of the symbol and of the local
2212 GOT base offset. */
2213 if (info->executable && !info->pie
2214 && (!h || FRV_SYM_LOCAL (info, h)))
2215 bfd_put_32 (output_bfd,
2216 frv_got_section (info)->output_section->vma
2217 + frv_got_section (info)->output_offset
2218 + frv_got_initial_offset (info),
2219 contents + rel->r_offset + 4);
2220 else
2221 /* A function descriptor used for lazy or local
2222 resolving is initialized such that its high word
2223 contains the output section index in which the
2224 PLT entries are located, and the low word
2225 contains the offset of the lazy PLT entry entry
2226 point into that section. */
2227 bfd_put_32 (output_bfd,
2228 h && ! FRV_SYM_LOCAL (info, h)
2229 ? 0
2230 : _frv_osec_to_segment (output_bfd,
2231 sec->output_section),
2232 contents + rel->r_offset + 4);
2233 }
2234 }
2235 check_segment[0] = check_segment[1] = got_segment;
2236 break;
2237
2238 case R_FRV_GPREL12:
2239 case R_FRV_GPRELU12:
2240 case R_FRV_GPREL32:
2241 case R_FRV_GPRELHI:
2242 case R_FRV_GPRELLO:
2243 check_segment[0] = gprel_segment;
2244 check_segment[1] = sec
2245 ? _frv_osec_to_segment (output_bfd, sec->output_section)
2246 : (unsigned)-1;
2247 break;
2248
2249 default:
2250 check_segment[0] = isec_segment;
2251 check_segment[1] = sec
2252 ? _frv_osec_to_segment (output_bfd, sec->output_section)
2253 : (unsigned)-1;
2254 break;
2255 }
2256
2257 if (check_segment[0] != check_segment[1]
2258 && (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC))
2259 {
2260 #if 1
2261 /* This helps catch problems in GCC while we can't do more
2262 than static linking. The idea is to test whether the
2263 input file basename is crt0.o only once. */
2264 if (silence_segment_error == 1)
2265 silence_segment_error =
2266 (strlen (input_bfd->filename) == 6
2267 && strcmp (input_bfd->filename, "crt0.o") == 0)
2268 || (strlen (input_bfd->filename) > 6
2269 && strcmp (input_bfd->filename
2270 + strlen (input_bfd->filename) - 7,
2271 "/crt0.o") == 0)
2272 ? -1 : 0;
2273 #endif
2274 if (!silence_segment_error
2275 /* We don't want duplicate errors for undefined
2276 symbols. */
2277 && !(picrel && picrel->symndx == -1
2278 && picrel->d.h->root.type == bfd_link_hash_undefined))
2279 info->callbacks->warning
2280 (info,
2281 (info->shared || info->pie)
2282 ? _("relocations between different segments are not supported")
2283 : _("warning: relocation references a different segment"),
2284 name, input_bfd, input_section, rel->r_offset);
2285 if (!silence_segment_error && (info->shared || info->pie))
2286 return FALSE;
2287 elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
2288 }
2289
2290 switch (r_type)
2291 {
2292 case R_FRV_GOTOFFHI:
2293 /* We need the addend to be applied before we shift the
2294 value right. */
2295 relocation += rel->r_addend;
2296 /* Fall through. */
2297 case R_FRV_GOTHI:
2298 case R_FRV_FUNCDESC_GOTHI:
2299 case R_FRV_FUNCDESC_GOTOFFHI:
2300 relocation >>= 16;
2301 /* Fall through. */
2302
2303 case R_FRV_GOTLO:
2304 case R_FRV_FUNCDESC_GOTLO:
2305 case R_FRV_GOTOFFLO:
2306 case R_FRV_FUNCDESC_GOTOFFLO:
2307 relocation &= 0xffff;
2308 break;
2309
2310 default:
2311 break;
2312 }
2313
2314 switch (r_type)
2315 {
2316 case R_FRV_LABEL24:
2317 if (! picrel->plt)
2318 break;
2319 /* Fall through. */
2320
2321 /* When referencing a GOT entry, a function descriptor or a
2322 PLT, we don't want the addend to apply to the reference,
2323 but rather to the referenced symbol. The actual entry
2324 will have already been created taking the addend into
2325 account, so cancel it out here. */
2326 case R_FRV_GOT12:
2327 case R_FRV_GOTHI:
2328 case R_FRV_GOTLO:
2329 case R_FRV_FUNCDESC_GOT12:
2330 case R_FRV_FUNCDESC_GOTHI:
2331 case R_FRV_FUNCDESC_GOTLO:
2332 case R_FRV_FUNCDESC_GOTOFF12:
2333 case R_FRV_FUNCDESC_GOTOFFHI:
2334 case R_FRV_FUNCDESC_GOTOFFLO:
2335 /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
2336 here, since we do want to apply the addend to the others.
2337 Note that we've applied the addend to GOTOFFHI before we
2338 shifted it right. */
2339 case R_FRV_GOTOFFHI:
2340 relocation -= rel->r_addend;
2341 break;
2342
2343 default:
2344 break;
2345 }
2346
2347 if (r_type == R_FRV_HI16)
2348 r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
2349
2350 else if (r_type == R_FRV_LO16)
2351 r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
2352
2353 else if (r_type == R_FRV_LABEL24)
2354 r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
2355 contents, relocation);
2356
2357 else if (r_type == R_FRV_GPREL12)
2358 r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
2359 contents, relocation);
2360
2361 else if (r_type == R_FRV_GPRELU12)
2362 r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
2363 contents, relocation);
2364
2365 else if (r_type == R_FRV_GPRELLO)
2366 r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
2367 contents, relocation);
2368
2369 else if (r_type == R_FRV_GPRELHI)
2370 r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
2371 contents, relocation);
2372
2373 else
2374 r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
2375 rel, relocation);
2376
2377 if (r != bfd_reloc_ok)
2378 {
2379 const char * msg = (const char *) NULL;
2380
2381 switch (r)
2382 {
2383 case bfd_reloc_overflow:
2384 r = info->callbacks->reloc_overflow
2385 (info, name, howto->name, (bfd_vma) 0,
2386 input_bfd, input_section, rel->r_offset);
2387 break;
2388
2389 case bfd_reloc_undefined:
2390 r = info->callbacks->undefined_symbol
2391 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2392 break;
2393
2394 case bfd_reloc_outofrange:
2395 msg = _("internal error: out of range error");
2396 break;
2397
2398 case bfd_reloc_notsupported:
2399 msg = _("internal error: unsupported relocation error");
2400 break;
2401
2402 case bfd_reloc_dangerous:
2403 msg = _("internal error: dangerous relocation");
2404 break;
2405
2406 default:
2407 msg = _("internal error: unknown error");
2408 break;
2409 }
2410
2411 if (msg)
2412 r = info->callbacks->warning
2413 (info, msg, name, input_bfd, input_section, rel->r_offset);
2414
2415 if (! r)
2416 return FALSE;
2417 }
2418 }
2419
2420 return TRUE;
2421 }
2422 \f
2423 /* Return the section that should be marked against GC for a given
2424 relocation. */
2425
2426 static asection *
2427 elf32_frv_gc_mark_hook (sec, info, rel, h, sym)
2428 asection *sec;
2429 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2430 Elf_Internal_Rela *rel;
2431 struct elf_link_hash_entry *h;
2432 Elf_Internal_Sym *sym;
2433 {
2434 if (h != NULL)
2435 {
2436 switch (ELF32_R_TYPE (rel->r_info))
2437 {
2438 case R_FRV_GNU_VTINHERIT:
2439 case R_FRV_GNU_VTENTRY:
2440 break;
2441
2442 default:
2443 switch (h->root.type)
2444 {
2445 default:
2446 break;
2447
2448 case bfd_link_hash_defined:
2449 case bfd_link_hash_defweak:
2450 return h->root.u.def.section;
2451
2452 case bfd_link_hash_common:
2453 return h->root.u.c.p->section;
2454 }
2455 }
2456 }
2457 else
2458 return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
2459
2460 return NULL;
2461 }
2462
2463 /* Update the got entry reference counts for the section being removed. */
2464
2465 static bfd_boolean
2466 elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)
2467 bfd *abfd ATTRIBUTE_UNUSED;
2468 struct bfd_link_info *info ATTRIBUTE_UNUSED;
2469 asection *sec ATTRIBUTE_UNUSED;
2470 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2471 {
2472 return TRUE;
2473 }
2474
2475 \f
2476 /* Hook called by the linker routine which adds symbols from an object
2477 file. We use it to put .comm items in .scomm, and not .comm. */
2478
2479 static bfd_boolean
2480 elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2481 bfd *abfd;
2482 struct bfd_link_info *info;
2483 const Elf_Internal_Sym *sym;
2484 const char **namep ATTRIBUTE_UNUSED;
2485 flagword *flagsp ATTRIBUTE_UNUSED;
2486 asection **secp;
2487 bfd_vma *valp;
2488 {
2489 if (sym->st_shndx == SHN_COMMON
2490 && !info->relocatable
2491 && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
2492 {
2493 /* Common symbols less than or equal to -G nn bytes are
2494 automatically put into .sbss. */
2495
2496 asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
2497
2498 if (scomm == NULL)
2499 {
2500 scomm = bfd_make_section (abfd, ".scommon");
2501 if (scomm == NULL
2502 || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
2503 | SEC_IS_COMMON
2504 | SEC_LINKER_CREATED)))
2505 return FALSE;
2506 }
2507
2508 *secp = scomm;
2509 *valp = sym->st_size;
2510 }
2511
2512 return TRUE;
2513 }
2514 /* Create a .got section, as well as its additional info field. This
2515 is almost entirely copied from
2516 elflink.c:_bfd_elf_create_got_section(). */
2517
2518 static bfd_boolean
2519 _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
2520 {
2521 flagword flags;
2522 asection *s;
2523 struct elf_link_hash_entry *h;
2524 struct bfd_link_hash_entry *bh;
2525 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2526 int ptralign;
2527
2528 /* This function may be called more than once. */
2529 s = bfd_get_section_by_name (abfd, ".got");
2530 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
2531 return TRUE;
2532
2533 /* Machine specific: although pointers are 32-bits wide, we want the
2534 GOT to be aligned to a 64-bit boundary, such that function
2535 descriptors in it can be accessed with 64-bit loads and
2536 stores. */
2537 ptralign = 3;
2538
2539 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2540 | SEC_LINKER_CREATED);
2541
2542 s = bfd_make_section (abfd, ".got");
2543 if (s == NULL
2544 || !bfd_set_section_flags (abfd, s, flags)
2545 || !bfd_set_section_alignment (abfd, s, ptralign))
2546 return FALSE;
2547
2548 if (bed->want_got_plt)
2549 {
2550 s = bfd_make_section (abfd, ".got.plt");
2551 if (s == NULL
2552 || !bfd_set_section_flags (abfd, s, flags)
2553 || !bfd_set_section_alignment (abfd, s, ptralign))
2554 return FALSE;
2555 }
2556
2557 if (bed->want_got_sym)
2558 {
2559 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
2560 (or .got.plt) section. We don't do this in the linker script
2561 because we don't want to define the symbol if we are not creating
2562 a global offset table. */
2563 bh = NULL;
2564 if (!(_bfd_generic_link_add_one_symbol
2565 (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
2566 bed->got_symbol_offset, (const char *) NULL, FALSE,
2567 bed->collect, &bh)))
2568 return FALSE;
2569 h = (struct elf_link_hash_entry *) bh;
2570 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2571 h->type = STT_OBJECT;
2572
2573 /* Machine-specific: we want the symbol for executables as
2574 well. */
2575 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2576 return FALSE;
2577
2578 elf_hash_table (info)->hgot = h;
2579 }
2580
2581 /* The first bit of the global offset table is the header. */
2582 s->_raw_size += bed->got_header_size + bed->got_symbol_offset;
2583
2584 /* This is the machine-specific part. Create and initialize section
2585 data for the got. */
2586 frv_got_section (info) = s;
2587 frv_relocs_info (info) = htab_try_create (1, frv_pic_relocs_info_hash,
2588 frv_pic_relocs_info_eq,
2589 (htab_del) NULL);
2590 if (! frv_relocs_info (info))
2591 return FALSE;
2592
2593 s = bfd_make_section (abfd, ".rel.got");
2594 if (s == NULL
2595 || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
2596 || ! bfd_set_section_alignment (abfd, s, 2))
2597 return FALSE;
2598
2599 frv_gotrel_section (info) = s;
2600
2601 /* Machine-specific. */
2602 s = bfd_make_section (abfd, ".rofixup");
2603 if (s == NULL
2604 || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
2605 || ! bfd_set_section_alignment (abfd, s, 2))
2606 return FALSE;
2607
2608 frv_gotfixup_section (info) = s;
2609
2610 /* Define _gp in .rofixup, for FDPIC. If it turns out that
2611 we're linking with a different linker script, the linker script
2612 will override it. */
2613 bh = NULL;
2614 if (!(_bfd_generic_link_add_one_symbol
2615 (info, abfd, "_gp", BSF_GLOBAL, s, -2048, (const char *) NULL, FALSE,
2616 bed->collect, &bh)))
2617 return FALSE;
2618 h = (struct elf_link_hash_entry *) bh;
2619 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2620 h->type = STT_OBJECT;
2621
2622 /* Machine-specific: we want the symbol for executables as well. */
2623 if (! _bfd_elf_link_record_dynamic_symbol (info, h))
2624 return FALSE;
2625
2626 return TRUE;
2627 }
2628
2629 /* Make sure the got and plt sections exist, and that our pointers in
2630 the link hash table point to them. */
2631
2632 static bfd_boolean
2633 elf32_frv_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2634 {
2635 /* This is mostly copied from
2636 elflink.c:_bfd_elf_create_dynamic_sections(). */
2637 flagword flags, pltflags;
2638 asection *s;
2639 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2640
2641 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2642 .rel[a].bss sections. */
2643
2644 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2645 | SEC_LINKER_CREATED);
2646
2647 pltflags = flags;
2648 pltflags |= SEC_CODE;
2649 if (bed->plt_not_loaded)
2650 pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
2651 if (bed->plt_readonly)
2652 pltflags |= SEC_READONLY;
2653
2654 s = bfd_make_section (abfd, ".plt");
2655 if (s == NULL
2656 || ! bfd_set_section_flags (abfd, s, pltflags)
2657 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2658 return FALSE;
2659 /* FRV-specific: remember it. */
2660 frv_plt_section (info) = s;
2661
2662 if (bed->want_plt_sym)
2663 {
2664 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2665 .plt section. */
2666 struct elf_link_hash_entry *h;
2667 struct bfd_link_hash_entry *bh = NULL;
2668
2669 if (! (_bfd_generic_link_add_one_symbol
2670 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
2671 FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2672 return FALSE;
2673 h = (struct elf_link_hash_entry *) bh;
2674 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2675 h->type = STT_OBJECT;
2676
2677 if (! info->executable
2678 && ! _bfd_elf_link_record_dynamic_symbol (info, h))
2679 return FALSE;
2680 }
2681
2682 /* FRV-specific: we want rel relocations for the plt. */
2683 s = bfd_make_section (abfd, ".rel.plt");
2684 if (s == NULL
2685 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2686 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
2687 return FALSE;
2688 /* FRV-specific: remember it. */
2689 frv_pltrel_section (info) = s;
2690
2691 /* FRV-specific: we want to create the GOT in the FRV way. */
2692 if (! _frv_create_got_section (abfd, info))
2693 return FALSE;
2694
2695 /* FRV-specific: make sure we created everything we wanted. */
2696 BFD_ASSERT (frv_got_section (info) && frv_gotrel_section (info)
2697 && frv_gotfixup_section (info)
2698 && frv_plt_section (info) && frv_pltrel_section (info));
2699
2700 if (bed->want_dynbss)
2701 {
2702 /* The .dynbss section is a place to put symbols which are defined
2703 by dynamic objects, are referenced by regular objects, and are
2704 not functions. We must allocate space for them in the process
2705 image and use a R_*_COPY reloc to tell the dynamic linker to
2706 initialize them at run time. The linker script puts the .dynbss
2707 section into the .bss section of the final image. */
2708 s = bfd_make_section (abfd, ".dynbss");
2709 if (s == NULL
2710 || ! bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
2711 return FALSE;
2712
2713 /* The .rel[a].bss section holds copy relocs. This section is not
2714 normally needed. We need to create it here, though, so that the
2715 linker will map it to an output section. We can't just create it
2716 only if we need it, because we will not know whether we need it
2717 until we have seen all the input files, and the first time the
2718 main linker code calls BFD after examining all the input files
2719 (size_dynamic_sections) the input sections have already been
2720 mapped to the output sections. If the section turns out not to
2721 be needed, we can discard it later. We will never need this
2722 section when generating a shared object, since they do not use
2723 copy relocs. */
2724 if (! info->shared)
2725 {
2726 s = bfd_make_section (abfd,
2727 (bed->default_use_rela_p
2728 ? ".rela.bss" : ".rel.bss"));
2729 if (s == NULL
2730 || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2731 || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
2732 return FALSE;
2733 }
2734 }
2735
2736 return TRUE;
2737 }
2738
2739 /* The name of the dynamic interpreter. This is put in the .interp
2740 section. */
2741
2742 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
2743
2744 #define DEFAULT_STACK_SIZE 0x20000
2745
2746 /* This structure is used to collect the number of entries present in
2747 each addressable range of the got. */
2748 struct _frv_dynamic_got_info
2749 {
2750 /* Several bits of information about the current link. */
2751 struct bfd_link_info *info;
2752 /* Total size needed for GOT entries within the 12-, 16- or 32-bit
2753 ranges. */
2754 bfd_vma got12, gotlos, gothilo;
2755 /* Total size needed for function descriptor entries within the 12-,
2756 16- or 32-bit ranges. */
2757 bfd_vma fd12, fdlos, fdhilo;
2758 /* Total size needed function descriptor entries referenced in PLT
2759 entries, that would be profitable to place in offsets close to
2760 the PIC register. */
2761 bfd_vma fdplt;
2762 /* Total size needed by lazy PLT entries. */
2763 bfd_vma lzplt;
2764 /* Number of relocations carried over from input object files. */
2765 unsigned long relocs;
2766 /* Number of fixups introduced by relocations in input object files. */
2767 unsigned long fixups;
2768 };
2769
2770 /* Compute the total GOT size required by each symbol in each range.
2771 Symbols may require up to 4 words in the GOT: an entry pointing to
2772 the symbol, an entry pointing to its function descriptor, and a
2773 private function descriptors taking two words. */
2774
2775 static int
2776 _frv_count_got_plt_entries (void **entryp, void *dinfo_)
2777 {
2778 struct frv_pic_relocs_info *entry = *entryp;
2779 struct _frv_dynamic_got_info *dinfo = dinfo_;
2780
2781 /* Allocate space for a GOT entry pointing to the symbol. */
2782 if (entry->got12)
2783 dinfo->got12 += 4;
2784 else if (entry->gotlos)
2785 dinfo->gotlos += 4;
2786 else if (entry->gothilo)
2787 dinfo->gothilo += 4;
2788 else
2789 entry->relocs32--;
2790 entry->relocs32++;
2791
2792 /* Allocate space for a GOT entry pointing to the function
2793 descriptor. */
2794 if (entry->fdgot12)
2795 dinfo->got12 += 4;
2796 else if (entry->fdgotlos)
2797 dinfo->gotlos += 4;
2798 else if (entry->fdgothilo)
2799 dinfo->gothilo += 4;
2800 else
2801 entry->relocsfd--;
2802 entry->relocsfd++;
2803
2804 /* Decide whether we need a PLT entry, a function descriptor in the
2805 GOT, and a lazy PLT entry for this symbol. */
2806 entry->plt = entry->call
2807 && entry->symndx == -1 && ! FRV_SYM_LOCAL (dinfo->info, entry->d.h)
2808 && elf_hash_table (dinfo->info)->dynamic_sections_created;
2809 entry->privfd = entry->plt
2810 || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
2811 || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
2812 && (entry->symndx != -1
2813 || FRV_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
2814 entry->lazyplt = entry->privfd
2815 && entry->symndx == -1 && ! FRV_SYM_LOCAL (dinfo->info, entry->d.h)
2816 && ! (dinfo->info->flags & DF_BIND_NOW)
2817 && elf_hash_table (dinfo->info)->dynamic_sections_created;
2818
2819 /* Allocate space for a function descriptor. */
2820 if (entry->fdgoff12)
2821 dinfo->fd12 += 8;
2822 else if (entry->fdgofflos)
2823 dinfo->fdlos += 8;
2824 else if (entry->privfd && entry->plt)
2825 dinfo->fdplt += 8;
2826 else if (entry->privfd)
2827 dinfo->fdhilo += 8;
2828 else
2829 entry->relocsfdv--;
2830 entry->relocsfdv++;
2831
2832 if (entry->lazyplt)
2833 dinfo->lzplt += 8;
2834
2835 if (!dinfo->info->executable || dinfo->info->pie)
2836 dinfo->relocs += entry->relocs32 + entry->relocsfd + entry->relocsfdv;
2837 else
2838 {
2839 if (entry->symndx != -1 || FRV_SYM_LOCAL (dinfo->info, entry->d.h))
2840 {
2841 if (entry->symndx != -1
2842 || entry->d.h->root.type != bfd_link_hash_undefweak)
2843 dinfo->fixups += entry->relocs32 + 2 * entry->relocsfdv;
2844 }
2845 else
2846 dinfo->relocs += entry->relocs32 + entry->relocsfdv;
2847 if (entry->symndx != -1 || FRV_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
2848 {
2849 if (entry->symndx != -1
2850 || entry->d.h->root.type != bfd_link_hash_undefweak)
2851 dinfo->fixups += entry->relocsfd;
2852 }
2853 else
2854 dinfo->relocs += entry->relocsfd;
2855 }
2856
2857 return 1;
2858 }
2859
2860 /* This structure is used to assign offsets to got entries, function
2861 descriptors, plt entries and lazy plt entries. */
2862
2863 struct _frv_dynamic_got_plt_info
2864 {
2865 /* Summary information collected with _frv_count_got_plt_entries. */
2866 struct _frv_dynamic_got_info g;
2867
2868 /* For each addressable range, we record a MAX (positive) and MIN
2869 (negative) value. CUR is used to assign got entries, and it's
2870 incremented from an initial positive value to MAX, then from MIN
2871 to FDCUR (unless FDCUR wraps around first). FDCUR is used to
2872 assign function descriptors, and it's decreased from an initial
2873 non-positive value to MIN, then from MAX down to CUR (unless CUR
2874 wraps around first). All of MIN, MAX, CUR and FDCUR always point
2875 to even words. ODD, if non-zero, indicates an odd word to be
2876 used for the next got entry, otherwise CUR is used and
2877 incremented by a pair of words, wrapping around when it reaches
2878 MAX. FDCUR is decremented (and wrapped) before the next function
2879 descriptor is chosen. FDPLT indicates the number of remaining
2880 slots that can be used for function descriptors used only by PLT
2881 entries. */
2882 struct _frv_dynamic_got_alloc_data
2883 {
2884 bfd_signed_vma max, cur, odd, fdcur, min;
2885 bfd_vma fdplt;
2886 } got12, gotlos, gothilo;
2887 };
2888
2889 /* Determine the positive and negative ranges to be used by each
2890 offset range in the GOT. FDCUR and CUR, that must be aligned to a
2891 double-word boundary, are the minimum (negative) and maximum
2892 (positive) GOT offsets already used by previous ranges, except for
2893 an ODD entry that may have been left behind. GOT and FD indicate
2894 the size of GOT entries and function descriptors that must be
2895 placed within the range from -WRAP to WRAP. If there's room left,
2896 up to FDPLT bytes should be reserved for additional function
2897 descriptors. */
2898
2899 inline static bfd_signed_vma
2900 _frv_compute_got_alloc_data (struct _frv_dynamic_got_alloc_data *gad,
2901 bfd_signed_vma fdcur,
2902 bfd_signed_vma odd,
2903 bfd_signed_vma cur,
2904 bfd_vma got,
2905 bfd_vma fd,
2906 bfd_vma fdplt,
2907 bfd_vma wrap)
2908 {
2909 bfd_signed_vma wrapmin = -wrap;
2910
2911 /* Start at the given initial points. */
2912 gad->fdcur = fdcur;
2913 gad->cur = cur;
2914
2915 /* If we had an incoming odd word and we have any got entries that
2916 are going to use it, consume it, otherwise leave gad->odd at
2917 zero. We might force gad->odd to zero and return the incoming
2918 odd such that it is used by the next range, but then GOT entries
2919 might appear to be out of order and we wouldn't be able to
2920 shorten the GOT by one word if it turns out to end with an
2921 unpaired GOT entry. */
2922 if (odd && got)
2923 {
2924 gad->odd = odd;
2925 got -= 4;
2926 odd = 0;
2927 }
2928 else
2929 gad->odd = 0;
2930
2931 /* If we're left with an unpaired GOT entry, compute its location
2932 such that we can return it. Otherwise, if got doesn't require an
2933 odd number of words here, either odd was already zero in the
2934 block above, or it was set to zero because got was non-zero, or
2935 got was already zero. In the latter case, we want the value of
2936 odd to carry over to the return statement, so we don't want to
2937 reset odd unless the condition below is true. */
2938 if (got & 4)
2939 {
2940 odd = cur + got;
2941 got += 4;
2942 }
2943
2944 /* Compute the tentative boundaries of this range. */
2945 gad->max = cur + got;
2946 gad->min = fdcur - fd;
2947 gad->fdplt = 0;
2948
2949 /* If function descriptors took too much space, wrap some of them
2950 around. */
2951 if (gad->min < wrapmin)
2952 {
2953 gad->max += wrapmin - gad->min;
2954 gad->min = wrapmin;
2955 }
2956 /* If there is space left and we have function descriptors
2957 referenced in PLT entries that could take advantage of shorter
2958 offsets, place them here. */
2959 else if (fdplt && gad->min > wrapmin)
2960 {
2961 bfd_vma fds;
2962 if ((bfd_vma) (gad->min - wrapmin) < fdplt)
2963 fds = gad->min - wrapmin;
2964 else
2965 fds = fdplt;
2966
2967 fdplt -= fds;
2968 gad->min -= fds;
2969 gad->fdplt += fds;
2970 }
2971
2972 /* If GOT entries took too much space, wrap some of them around.
2973 This may well cause gad->min to become lower than wrapmin. This
2974 will cause a relocation overflow later on, so we don't have to
2975 report it here . */
2976 if ((bfd_vma) gad->max > wrap)
2977 {
2978 gad->min -= gad->max - wrap;
2979 gad->max = wrap;
2980 }
2981 /* If there is more space left, try to place some more function
2982 descriptors for PLT entries. */
2983 else if (fdplt && (bfd_vma) gad->max < wrap)
2984 {
2985 bfd_vma fds;
2986 if ((bfd_vma) (wrap - gad->max) < fdplt)
2987 fds = wrap - gad->max;
2988 else
2989 fds = fdplt;
2990
2991 fdplt -= fds;
2992 gad->max += fds;
2993 gad->fdplt += fds;
2994 }
2995
2996 /* If odd was initially computed as an offset past the wrap point,
2997 wrap it around. */
2998 if (odd > gad->max)
2999 odd = gad->min + odd - gad->max;
3000
3001 /* _frv_get_got_entry() below will always wrap gad->cur if needed
3002 before returning, so do it here too. This guarantees that,
3003 should cur and fdcur meet at the wrap point, they'll both be
3004 equal to min. */
3005 if (gad->cur == gad->max)
3006 gad->cur = gad->min;
3007
3008 return odd;
3009 }
3010
3011 /* Compute the location of the next GOT entry, given the allocation
3012 data for a range. */
3013
3014 inline static bfd_signed_vma
3015 _frv_get_got_entry (struct _frv_dynamic_got_alloc_data *gad)
3016 {
3017 bfd_signed_vma ret;
3018
3019 if (gad->odd)
3020 {
3021 /* If there was an odd word left behind, use it. */
3022 ret = gad->odd;
3023 gad->odd = 0;
3024 }
3025 else
3026 {
3027 /* Otherwise, use the word pointed to by cur, reserve the next
3028 as an odd word, and skip to the next pair of words, possibly
3029 wrapping around. */
3030 ret = gad->cur;
3031 gad->odd = gad->cur + 4;
3032 gad->cur += 8;
3033 if (gad->cur == gad->max)
3034 gad->cur = gad->min;
3035 }
3036
3037 return ret;
3038 }
3039
3040 /* Compute the location of the next function descriptor entry in the
3041 GOT, given the allocation data for a range. */
3042
3043 inline static bfd_signed_vma
3044 _frv_get_fd_entry (struct _frv_dynamic_got_alloc_data *gad)
3045 {
3046 /* If we're at the bottom, wrap around, and only then allocate the
3047 next pair of words. */
3048 if (gad->fdcur == gad->min)
3049 gad->fdcur = gad->max;
3050 return gad->fdcur -= 8;
3051 }
3052
3053 /* Assign GOT offsets for every GOT entry and function descriptor.
3054 Doing everything in a single pass is tricky. */
3055
3056 static int
3057 _frv_assign_got_entries (void **entryp, void *info_)
3058 {
3059 struct frv_pic_relocs_info *entry = *entryp;
3060 struct _frv_dynamic_got_plt_info *dinfo = info_;
3061
3062 if (entry->got12)
3063 entry->got_entry = _frv_get_got_entry (&dinfo->got12);
3064 else if (entry->gotlos)
3065 entry->got_entry = _frv_get_got_entry (&dinfo->gotlos);
3066 else if (entry->gothilo)
3067 entry->got_entry = _frv_get_got_entry (&dinfo->gothilo);
3068
3069 if (entry->fdgot12)
3070 entry->fdgot_entry = _frv_get_got_entry (&dinfo->got12);
3071 else if (entry->fdgotlos)
3072 entry->fdgot_entry = _frv_get_got_entry (&dinfo->gotlos);
3073 else if (entry->fdgothilo)
3074 entry->fdgot_entry = _frv_get_got_entry (&dinfo->gothilo);
3075
3076 if (entry->fdgoff12)
3077 entry->fd_entry = _frv_get_fd_entry (&dinfo->got12);
3078 else if (entry->plt && dinfo->got12.fdplt)
3079 {
3080 dinfo->got12.fdplt -= 8;
3081 entry->fd_entry = _frv_get_fd_entry (&dinfo->got12);
3082 }
3083 else if (entry->fdgofflos)
3084 entry->fd_entry = _frv_get_fd_entry (&dinfo->gotlos);
3085 else if (entry->plt && dinfo->gotlos.fdplt)
3086 {
3087 dinfo->gotlos.fdplt -= 8;
3088 entry->fd_entry = _frv_get_fd_entry (&dinfo->gotlos);
3089 }
3090 else if (entry->plt)
3091 {
3092 dinfo->gothilo.fdplt -= 8;
3093 entry->fd_entry = _frv_get_fd_entry (&dinfo->gothilo);
3094 }
3095 else if (entry->privfd)
3096 entry->fd_entry = _frv_get_fd_entry (&dinfo->gothilo);
3097
3098 return 1;
3099 }
3100
3101 /* Assign GOT offsets to private function descriptors used by PLT
3102 entries (or referenced by 32-bit offsets), as well as PLT entries
3103 and lazy PLT entries. */
3104
3105 static int
3106 _frv_assign_plt_entries (void **entryp, void *info_)
3107 {
3108 struct frv_pic_relocs_info *entry = *entryp;
3109 struct _frv_dynamic_got_plt_info *dinfo = info_;
3110
3111 /* If this symbol requires a local function descriptor, allocate
3112 one. */
3113 if (entry->privfd && entry->fd_entry == 0)
3114 {
3115 if (dinfo->got12.fdplt)
3116 {
3117 entry->fd_entry = _frv_get_fd_entry (&dinfo->got12);
3118 dinfo->got12.fdplt -= 8;
3119 }
3120 else if (dinfo->gotlos.fdplt)
3121 {
3122 entry->fd_entry = _frv_get_fd_entry (&dinfo->gotlos);
3123 dinfo->gotlos.fdplt -= 8;
3124 }
3125 else
3126 {
3127 BFD_ASSERT (dinfo->gothilo.fdplt)
3128 entry->fd_entry = _frv_get_fd_entry (&dinfo->gothilo);
3129 dinfo->gothilo.fdplt -= 8;
3130 }
3131 }
3132
3133 if (entry->plt)
3134 {
3135 int size;
3136
3137 /* We use the section's raw size to mark the location of the
3138 next PLT entry. */
3139 entry->plt_entry = frv_plt_section (dinfo->g.info)->_raw_size;
3140
3141 /* Figure out the length of this PLT entry based on the
3142 addressing mode we need to reach the function descriptor. */
3143 BFD_ASSERT (entry->fd_entry);
3144 if (entry->fd_entry >= -(1 << (12 - 1))
3145 && entry->fd_entry < (1 << (12 - 1)))
3146 size = 8;
3147 else if (entry->fd_entry >= -(1 << (16 - 1))
3148 && entry->fd_entry < (1 << (16 - 1)))
3149 size = 12;
3150 else
3151 size = 16;
3152
3153 frv_plt_section (dinfo->g.info)->_raw_size += size;
3154 }
3155
3156 if (entry->lazyplt)
3157 {
3158 entry->lzplt_entry = dinfo->g.lzplt;
3159 dinfo->g.lzplt += 8;
3160 /* If this entry is the one that gets the resolver stub, account
3161 for the additional instruction. */
3162 if (entry->lzplt_entry % FRV_LZPLT_BLOCK_SIZE == FRV_LZPLT_RESOLV_LOC)
3163 dinfo->g.lzplt += 4;
3164 }
3165
3166 return 1;
3167 }
3168
3169 /* Follow indirect and warning hash entries so that each got entry
3170 points to the final symbol definition. P must point to a pointer
3171 to the hash table we're traversing. Since this traversal may
3172 modify the hash table, we set this pointer to NULL to indicate
3173 we've made a potentially-destructive change to the hash table, so
3174 the traversal must be restarted. */
3175 static int
3176 _frv_resolve_final_relocs_info (void **entryp, void *p)
3177 {
3178 struct frv_pic_relocs_info *entry = *entryp;
3179 htab_t *htab = p;
3180
3181 if (entry->symndx == -1)
3182 {
3183 struct elf_link_hash_entry *h = entry->d.h;
3184
3185 while (h->root.type == bfd_link_hash_indirect
3186 || h->root.type == bfd_link_hash_warning)
3187 h = (struct elf_link_hash_entry *)h->root.u.i.link;
3188
3189 if (entry->d.h == h)
3190 return 1;
3191
3192 entry->d.h = h;
3193
3194 /* If we can't find this entry with the new bfd hash, re-insert
3195 it, and get the traversal restarted. */
3196 if (! htab_find (*htab, entry))
3197 {
3198 htab_clear_slot (*htab, entryp);
3199 entryp = htab_find_slot (*htab, entry, INSERT);
3200 if (! *entryp)
3201 *entryp = entry;
3202 /* Abort the traversal, since the whole table may have
3203 moved, and leave it up to the parent to restart the
3204 process. */
3205 *(htab_t *)p = NULL;
3206 return 0;
3207 }
3208 }
3209
3210 return 1;
3211 }
3212
3213 /* Set the sizes of the dynamic sections. */
3214
3215 static bfd_boolean
3216 elf32_frv_size_dynamic_sections (bfd *output_bfd,
3217 struct bfd_link_info *info)
3218 {
3219 bfd *dynobj;
3220 asection *s;
3221 struct _frv_dynamic_got_plt_info gpinfo;
3222 bfd_signed_vma odd;
3223 bfd_vma limit;
3224
3225 dynobj = elf_hash_table (info)->dynobj;
3226 BFD_ASSERT (dynobj != NULL);
3227
3228 if (elf_hash_table (info)->dynamic_sections_created)
3229 {
3230 /* Set the contents of the .interp section to the interpreter. */
3231 if (info->executable)
3232 {
3233 s = bfd_get_section_by_name (dynobj, ".interp");
3234 BFD_ASSERT (s != NULL);
3235 s->_raw_size = sizeof ELF_DYNAMIC_INTERPRETER;
3236 s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3237 }
3238 }
3239
3240 memset (&gpinfo, 0, sizeof (gpinfo));
3241 gpinfo.g.info = info;
3242
3243 for (;;)
3244 {
3245 htab_t relocs = frv_relocs_info (info);
3246
3247 htab_traverse (relocs, _frv_resolve_final_relocs_info, &relocs);
3248
3249 if (relocs == frv_relocs_info (info))
3250 break;
3251 }
3252
3253 htab_traverse (frv_relocs_info (info), _frv_count_got_plt_entries,
3254 &gpinfo.g);
3255
3256 odd = 12;
3257 /* Compute the total size taken by entries in the 12-bit and 16-bit
3258 ranges, to tell how many PLT function descriptors we can bring
3259 into the 12-bit range without causing the 16-bit range to
3260 overflow. */
3261 limit = odd + gpinfo.g.got12 + gpinfo.g.gotlos
3262 + gpinfo.g.fd12 + gpinfo.g.fdlos;
3263 if (limit < (bfd_vma)1 << 16)
3264 limit = ((bfd_vma)1 << 16) - limit;
3265 else
3266 limit = 0;
3267 if (gpinfo.g.fdplt < limit)
3268 limit = gpinfo.g.fdplt;
3269
3270 /* Determine the ranges of GOT offsets that we can use for each
3271 range of addressing modes. */
3272 odd = _frv_compute_got_alloc_data (&gpinfo.got12,
3273 0,
3274 odd,
3275 16,
3276 gpinfo.g.got12,
3277 gpinfo.g.fd12,
3278 limit,
3279 (bfd_vma)1 << (12-1));
3280 odd = _frv_compute_got_alloc_data (&gpinfo.gotlos,
3281 gpinfo.got12.min,
3282 odd,
3283 gpinfo.got12.max,
3284 gpinfo.g.gotlos,
3285 gpinfo.g.fdlos,
3286 gpinfo.g.fdplt - gpinfo.got12.fdplt,
3287 (bfd_vma)1 << (16-1));
3288 odd = _frv_compute_got_alloc_data (&gpinfo.gothilo,
3289 gpinfo.gotlos.min,
3290 odd,
3291 gpinfo.gotlos.max,
3292 gpinfo.g.gothilo,
3293 gpinfo.g.fdhilo,
3294 gpinfo.g.fdplt - gpinfo.got12.fdplt
3295 - gpinfo.gotlos.fdplt,
3296 (bfd_vma)1 << (32-1));
3297
3298 /* Now assign (most) GOT offsets. */
3299 htab_traverse (frv_relocs_info (info), _frv_assign_got_entries, &gpinfo);
3300
3301 frv_got_section (info)->_raw_size = gpinfo.gothilo.max - gpinfo.gothilo.min
3302 /* If an odd word is the last word of the GOT, we don't need this
3303 word to be part of the GOT. */
3304 - (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
3305 if (frv_got_section (info)->_raw_size == 0)
3306 frv_got_section (info)->flags |= SEC_EXCLUDE;
3307 else if (frv_got_section (info)->_raw_size == 12
3308 && ! elf_hash_table (info)->dynamic_sections_created)
3309 {
3310 frv_got_section (info)->flags |= SEC_EXCLUDE;
3311 frv_got_section (info)->_raw_size = 0;
3312 }
3313 else
3314 {
3315 frv_got_section (info)->contents =
3316 (bfd_byte *) bfd_zalloc (dynobj, frv_got_section (info)->_raw_size);
3317 if (frv_got_section (info)->contents == NULL)
3318 return FALSE;
3319 }
3320
3321 if (elf_hash_table (info)->dynamic_sections_created)
3322 /* Subtract the number of lzplt entries, since those will generate
3323 relocations in the pltrel section. */
3324 frv_gotrel_section (info)->_raw_size =
3325 (gpinfo.g.relocs - gpinfo.g.lzplt / 8)
3326 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
3327 else
3328 BFD_ASSERT (gpinfo.g.relocs == 0);
3329 if (frv_gotrel_section (info)->_raw_size == 0)
3330 frv_gotrel_section (info)->flags |= SEC_EXCLUDE;
3331 else
3332 {
3333 frv_gotrel_section (info)->contents =
3334 (bfd_byte *) bfd_zalloc (dynobj, frv_gotrel_section (info)->_raw_size);
3335 if (frv_gotrel_section (info)->contents == NULL)
3336 return FALSE;
3337 }
3338
3339 if (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
3340 frv_gotfixup_section (info)->_raw_size = (gpinfo.g.fixups + 1) * 4;
3341 if (frv_gotfixup_section (info)->_raw_size == 0)
3342 frv_gotfixup_section (info)->flags |= SEC_EXCLUDE;
3343 else
3344 {
3345 frv_gotfixup_section (info)->contents =
3346 (bfd_byte *) bfd_zalloc (dynobj,
3347 frv_gotfixup_section (info)->_raw_size);
3348 if (frv_gotfixup_section (info)->contents == NULL)
3349 return FALSE;
3350 }
3351
3352 if (elf_hash_table (info)->dynamic_sections_created)
3353 {
3354 frv_pltrel_section (info)->_raw_size =
3355 gpinfo.g.lzplt / 8 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
3356 if (frv_pltrel_section (info)->_raw_size == 0)
3357 frv_pltrel_section (info)->flags |= SEC_EXCLUDE;
3358 else
3359 {
3360 frv_pltrel_section (info)->contents =
3361 (bfd_byte *) bfd_zalloc (dynobj,
3362 frv_pltrel_section (info)->_raw_size);
3363 if (frv_pltrel_section (info)->contents == NULL)
3364 return FALSE;
3365 }
3366 }
3367
3368 /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
3369 such that there's room for the additional instruction needed to
3370 call the resolver. Since _frv_assign_got_entries didn't account
3371 for them, our block size is 4 bytes smaller than the real block
3372 size. */
3373 if (elf_hash_table (info)->dynamic_sections_created)
3374 {
3375 frv_plt_section (info)->_raw_size = gpinfo.g.lzplt
3376 + ((gpinfo.g.lzplt + (FRV_LZPLT_BLOCK_SIZE - 4) - 8)
3377 / (FRV_LZPLT_BLOCK_SIZE - 4) * 4);
3378 }
3379
3380 /* Reset it, such that _frv_assign_plt_entries() can use it to
3381 actually assign lazy PLT entries addresses. */
3382 gpinfo.g.lzplt = 0;
3383
3384 /* Save information that we're going to need to generate GOT and PLT
3385 entries. */
3386 frv_got_initial_offset (info) = -gpinfo.gothilo.min;
3387
3388 if (get_elf_backend_data (output_bfd)->want_got_sym)
3389 elf_hash_table (info)->hgot->root.u.def.value
3390 += frv_got_initial_offset (info);
3391
3392 if (elf_hash_table (info)->dynamic_sections_created)
3393 frv_plt_initial_offset (info) = frv_plt_section (info)->_raw_size;
3394
3395 htab_traverse (frv_relocs_info (info), _frv_assign_plt_entries, &gpinfo);
3396
3397 /* Allocate the PLT section contents only after
3398 _frv_assign_plt_entries has a chance to add the size of the
3399 non-lazy PLT entries. */
3400 if (elf_hash_table (info)->dynamic_sections_created)
3401 {
3402 if (frv_plt_section (info)->_raw_size == 0)
3403 frv_plt_section (info)->flags |= SEC_EXCLUDE;
3404 else
3405 {
3406 frv_plt_section (info)->contents =
3407 (bfd_byte *) bfd_zalloc (dynobj, frv_plt_section (info)->_raw_size);
3408 if (frv_plt_section (info)->contents == NULL)
3409 return FALSE;
3410 }
3411 }
3412
3413 if (elf_hash_table (info)->dynamic_sections_created)
3414 {
3415 if (frv_got_section (info)->_raw_size)
3416 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTGOT, 0))
3417 return FALSE;
3418
3419 if (frv_pltrel_section (info)->_raw_size)
3420 if (! bfd_elf32_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3421 || ! bfd_elf32_add_dynamic_entry (info, DT_PLTREL, DT_REL)
3422 || ! bfd_elf32_add_dynamic_entry (info, DT_JMPREL, 0))
3423 return FALSE;
3424
3425 if (frv_gotrel_section (info)->_raw_size)
3426 if (! bfd_elf32_add_dynamic_entry (info, DT_REL, 0)
3427 || ! bfd_elf32_add_dynamic_entry (info, DT_RELSZ, 0)
3428 || ! bfd_elf32_add_dynamic_entry (info, DT_RELENT,
3429 sizeof (Elf32_External_Rel)))
3430 return FALSE;
3431 }
3432
3433 return TRUE;
3434 }
3435
3436 static bfd_boolean
3437 elf32_frv_always_size_sections (bfd *output_bfd,
3438 struct bfd_link_info *info)
3439 {
3440 if (!info->relocatable
3441 && elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
3442 {
3443 struct elf_link_hash_entry *h;
3444 asection *sec;
3445
3446 /* Force a PT_GNU_STACK segment to be created. */
3447 if (! elf_tdata (output_bfd)->stack_flags)
3448 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
3449
3450 /* Define __stacksize if it's not defined yet. */
3451 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3452 FALSE, FALSE, FALSE);
3453 if (! h || h->root.type != bfd_link_hash_defined
3454 || h->type != STT_OBJECT
3455 || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3456 {
3457 struct bfd_link_hash_entry *bh = NULL;
3458
3459 if (!(_bfd_generic_link_add_one_symbol
3460 (info, output_bfd, "__stacksize",
3461 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
3462 (const char *) NULL, FALSE,
3463 get_elf_backend_data (output_bfd)->collect, &bh)))
3464 return FALSE;
3465
3466 h = (struct elf_link_hash_entry *) bh;
3467 h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3468 h->type = STT_OBJECT;
3469 }
3470
3471 /* Create a stack section, and set its alignment. */
3472 sec = bfd_make_section (output_bfd, ".stack");
3473
3474 if (sec == NULL
3475 || ! bfd_set_section_alignment (output_bfd, sec, 3))
3476 return FALSE;
3477 }
3478
3479 return TRUE;
3480 }
3481
3482 static bfd_boolean
3483 elf32_frv_modify_segment_map (bfd *output_bfd,
3484 struct bfd_link_info *info)
3485 {
3486 if (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
3487 {
3488 struct elf_segment_map *m;
3489
3490 for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
3491 if (m->p_type == PT_GNU_STACK)
3492 break;
3493
3494 if (m)
3495 {
3496 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
3497 struct elf_link_hash_entry *h;
3498
3499 if (sec)
3500 {
3501 /* Obtain the pointer to the __stacksize symbol. */
3502 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3503 FALSE, FALSE, FALSE);
3504 while (h->root.type == bfd_link_hash_indirect
3505 || h->root.type == bfd_link_hash_warning)
3506 h = (struct elf_link_hash_entry *)h->root.u.i.link;
3507 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
3508
3509 /* Set the section size from the symbol value. We
3510 intentionally ignore the symbol section. */
3511 if (h->root.type == bfd_link_hash_defined)
3512 sec->_raw_size = h->root.u.def.value;
3513 else
3514 sec->_raw_size = DEFAULT_STACK_SIZE;
3515
3516 /* Add the stack section to the PT_GNU_STACK segment,
3517 such that its size and alignment requirements make it
3518 to the segment. */
3519 m->sections[m->count] = sec;
3520 m->count++;
3521 }
3522 }
3523 }
3524
3525 return TRUE;
3526 }
3527
3528 /* Fill in code and data in dynamic sections. */
3529
3530 static bfd_boolean
3531 elf32_frv_finish_dynamic_sections (bfd *output_bfd,
3532 struct bfd_link_info *info)
3533 {
3534 bfd *dynobj;
3535 asection *sdyn;
3536
3537 dynobj = elf_hash_table (info)->dynobj;
3538
3539 if (frv_got_section (info))
3540 {
3541 BFD_ASSERT (frv_gotrel_section (info)->_raw_size
3542 == (frv_gotrel_section (info)->reloc_count
3543 * sizeof (Elf32_External_Rel)));
3544
3545 if (frv_gotfixup_section (info))
3546 {
3547 if (elf_elfheader (output_bfd)->e_flags & EF_FRV_FDPIC)
3548 {
3549 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
3550 bfd_vma got_value = hgot->root.u.def.value
3551 + hgot->root.u.def.section->output_section->vma
3552 + hgot->root.u.def.section->output_offset;
3553
3554 _frv_add_rofixup (output_bfd, frv_gotfixup_section (info),
3555 got_value);
3556 }
3557
3558 if (frv_gotfixup_section (info)->_raw_size
3559 != (frv_gotfixup_section (info)->reloc_count * 4))
3560 {
3561 if (!elf_hash_table (info)->dynamic_sections_created)
3562 {
3563 info->callbacks->warning
3564 (info, "no dynamic sections, missing -melf32frvfd?",
3565 ".rofixup", NULL, NULL, 0);
3566 return FALSE;
3567 }
3568 BFD_ASSERT (0);
3569 }
3570 }
3571 }
3572 if (elf_hash_table (info)->dynamic_sections_created)
3573 {
3574 BFD_ASSERT (frv_pltrel_section (info)->_raw_size
3575 == (frv_pltrel_section (info)->reloc_count
3576 * sizeof (Elf32_External_Rel)));
3577 }
3578
3579 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3580
3581 if (elf_hash_table (info)->dynamic_sections_created)
3582 {
3583 Elf32_External_Dyn * dyncon;
3584 Elf32_External_Dyn * dynconend;
3585
3586 BFD_ASSERT (sdyn != NULL);
3587
3588 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3589 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->_raw_size);
3590
3591 for (; dyncon < dynconend; dyncon++)
3592 {
3593 Elf_Internal_Dyn dyn;
3594
3595 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3596
3597 switch (dyn.d_tag)
3598 {
3599 default:
3600 break;
3601
3602 case DT_PLTGOT:
3603 dyn.d_un.d_ptr = frv_got_section (info)->output_section->vma
3604 + frv_got_section (info)->output_offset
3605 + frv_got_initial_offset (info);
3606 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3607 break;
3608
3609 case DT_JMPREL:
3610 dyn.d_un.d_ptr = frv_pltrel_section (info)->output_section->vma
3611 + frv_pltrel_section (info)->output_offset;
3612 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3613 break;
3614
3615 case DT_PLTRELSZ:
3616 if (frv_pltrel_section (info)->_cooked_size != 0)
3617 dyn.d_un.d_val = frv_pltrel_section (info)->_cooked_size;
3618 else
3619 dyn.d_un.d_val = frv_pltrel_section (info)->_raw_size;
3620 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3621 break;
3622 }
3623 }
3624 }
3625
3626 return TRUE;
3627 }
3628
3629 /* Adjust a symbol defined by a dynamic object and referenced by a
3630 regular object. */
3631
3632 static bfd_boolean
3633 elf32_frv_adjust_dynamic_symbol (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3634 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
3635 {
3636 bfd * dynobj;
3637
3638 dynobj = elf_hash_table (info)->dynobj;
3639
3640 /* Make sure we know what is going on here. */
3641 BFD_ASSERT (dynobj != NULL
3642 && (h->weakdef != NULL
3643 || ((h->elf_link_hash_flags
3644 & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3645 && (h->elf_link_hash_flags
3646 & ELF_LINK_HASH_REF_REGULAR) != 0
3647 && (h->elf_link_hash_flags
3648 & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3649
3650 /* If this is a weak symbol, and there is a real definition, the
3651 processor independent code will have arranged for us to see the
3652 real definition first, and we can just use the same value. */
3653 if (h->weakdef != NULL)
3654 {
3655 BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3656 || h->weakdef->root.type == bfd_link_hash_defweak);
3657 h->root.u.def.section = h->weakdef->root.u.def.section;
3658 h->root.u.def.value = h->weakdef->root.u.def.value;
3659 }
3660
3661 return TRUE;
3662 }
3663
3664 /* Perform any actions needed for dynamic symbols. */
3665
3666 static bfd_boolean
3667 elf32_frv_finish_dynamic_symbol (bfd *output_bfd ATTRIBUTE_UNUSED,
3668 struct bfd_link_info *info ATTRIBUTE_UNUSED,
3669 struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
3670 Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
3671 {
3672 return TRUE;
3673 }
3674
3675 /* Look through the relocs for a section during the first phase.
3676
3677 Besides handling virtual table relocs for gc, we have to deal with
3678 all sorts of PIC-related relocations. We describe below the
3679 general plan on how to handle such relocations, even though we only
3680 collect information at this point, storing them in hash tables for
3681 perusal of later passes.
3682
3683 32 relocations are propagated to the linker output when creating
3684 position-independent output. LO16 and HI16 relocations are not
3685 supposed to be encountered in this case.
3686
3687 LABEL16 should always be resolvable by the linker, since it's only
3688 used by branches.
3689
3690 LABEL24, on the other hand, is used by calls. If it turns out that
3691 the target of a call is a dynamic symbol, a PLT entry must be
3692 created for it, which triggers the creation of a private function
3693 descriptor and, unless lazy binding is disabled, a lazy PLT entry.
3694
3695 GPREL relocations require the referenced symbol to be in the same
3696 segment as _gp, but this can only be checked later.
3697
3698 All GOT, GOTOFF and FUNCDESC relocations require a .got section to
3699 exist. LABEL24 might as well, since it may require a PLT entry,
3700 that will require a got.
3701
3702 Non-FUNCDESC GOT relocations require a GOT entry to be created
3703 regardless of whether the symbol is dynamic. However, since a
3704 global symbol that turns out to not be exported may have the same
3705 address of a non-dynamic symbol, we don't assign GOT entries at
3706 this point, such that we can share them in this case. A relocation
3707 for the GOT entry always has to be created, be it to offset a
3708 private symbol by the section load address, be it to get the symbol
3709 resolved dynamically.
3710
3711 FUNCDESC GOT relocations require a GOT entry to be created, and
3712 handled as if a FUNCDESC relocation was applied to the GOT entry in
3713 an object file.
3714
3715 FUNCDESC relocations referencing a symbol that turns out to NOT be
3716 dynamic cause a private function descriptor to be created. The
3717 FUNCDESC relocation then decays to a 32 relocation that points at
3718 the private descriptor. If the symbol is dynamic, the FUNCDESC
3719 relocation is propagated to the linker output, such that the
3720 dynamic linker creates the canonical descriptor, pointing to the
3721 dynamically-resolved definition of the function.
3722
3723 Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
3724 symbols that are assigned to the same segment as the GOT, but we
3725 can only check this later, after we know the complete set of
3726 symbols defined and/or exported.
3727
3728 FUNCDESC GOTOFF relocations require a function descriptor to be
3729 created and, unless lazy binding is disabled or the symbol is not
3730 dynamic, a lazy PLT entry. Since we can't tell at this point
3731 whether a symbol is going to be dynamic, we have to decide later
3732 whether to create a lazy PLT entry or bind the descriptor directly
3733 to the private function.
3734
3735 FUNCDESC_VALUE relocations are not supposed to be present in object
3736 files, but they may very well be simply propagated to the linker
3737 output, since they have no side effect.
3738
3739
3740 A function descriptor always requires a FUNCDESC_VALUE relocation.
3741 Whether it's in .plt.rel or not depends on whether lazy binding is
3742 enabled and on whether the referenced symbol is dynamic.
3743
3744 The existence of a lazy PLT requires the resolverStub lazy PLT
3745 entry to be present.
3746
3747
3748 As for assignment of GOT, PLT and lazy PLT entries, and private
3749 descriptors, we might do them all sequentially, but we can do
3750 better than that. For example, we can place GOT entries and
3751 private function descriptors referenced using 12-bit operands
3752 closer to the PIC register value, such that these relocations don't
3753 overflow. Those that are only referenced with LO16 relocations
3754 could come next, but we may as well place PLT-required function
3755 descriptors in the 12-bit range to make them shorter. Symbols
3756 referenced with LO16/HI16 may come next, but we may place
3757 additional function descriptors in the 16-bit range if we can
3758 reliably tell that we've already placed entries that are ever
3759 referenced with only LO16. PLT entries are therefore generated as
3760 small as possible, while not introducing relocation overflows in
3761 GOT or FUNCDESC_GOTOFF relocations. Lazy PLT entries could be
3762 generated before or after PLT entries, but not intermingled with
3763 them, such that we can have more lazy PLT entries in range for a
3764 branch to the resolverStub. The resolverStub should be emitted at
3765 the most distant location from the first lazy PLT entry such that
3766 it's still in range for a branch, or closer, if there isn't a need
3767 for so many lazy PLT entries. Additional lazy PLT entries may be
3768 emitted after the resolverStub, as long as branches are still in
3769 range. If the branch goes out of range, longer lazy PLT entries
3770 are emitted.
3771
3772 We could further optimize PLT and lazy PLT entries by giving them
3773 priority in assignment to closer-to-gr17 locations depending on the
3774 number of occurrences of references to them (assuming a function
3775 that's called more often is more important for performance, so its
3776 PLT entry should be faster), or taking hints from the compiler.
3777 Given infinite time and money... :-) */
3778
3779 static bfd_boolean
3780 elf32_frv_check_relocs (abfd, info, sec, relocs)
3781 bfd *abfd;
3782 struct bfd_link_info *info;
3783 asection *sec;
3784 const Elf_Internal_Rela *relocs;
3785 {
3786 Elf_Internal_Shdr *symtab_hdr;
3787 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3788 const Elf_Internal_Rela *rel;
3789 const Elf_Internal_Rela *rel_end;
3790 bfd *dynobj;
3791 struct frv_pic_relocs_info *picrel;
3792
3793 if (info->relocatable)
3794 return TRUE;
3795
3796 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3797 sym_hashes = elf_sym_hashes (abfd);
3798 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
3799 if (!elf_bad_symtab (abfd))
3800 sym_hashes_end -= symtab_hdr->sh_info;
3801
3802 dynobj = elf_hash_table (info)->dynobj;
3803 rel_end = relocs + sec->reloc_count;
3804 for (rel = relocs; rel < rel_end; rel++)
3805 {
3806 struct elf_link_hash_entry *h;
3807 unsigned long r_symndx;
3808
3809 r_symndx = ELF32_R_SYM (rel->r_info);
3810 if (r_symndx < symtab_hdr->sh_info)
3811 h = NULL;
3812 else
3813 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3814
3815 switch (ELF32_R_TYPE (rel->r_info))
3816 {
3817 case R_FRV_LABEL24:
3818 case R_FRV_32:
3819 case R_FRV_GOT12:
3820 case R_FRV_GOTHI:
3821 case R_FRV_GOTLO:
3822 case R_FRV_FUNCDESC_GOT12:
3823 case R_FRV_FUNCDESC_GOTHI:
3824 case R_FRV_FUNCDESC_GOTLO:
3825 case R_FRV_GOTOFF12:
3826 case R_FRV_GOTOFFHI:
3827 case R_FRV_GOTOFFLO:
3828 case R_FRV_FUNCDESC_GOTOFF12:
3829 case R_FRV_FUNCDESC_GOTOFFHI:
3830 case R_FRV_FUNCDESC_GOTOFFLO:
3831 case R_FRV_FUNCDESC:
3832 case R_FRV_FUNCDESC_VALUE:
3833 if (! dynobj)
3834 {
3835 elf_hash_table (info)->dynobj = dynobj = abfd;
3836 if (! _frv_create_got_section (abfd, info))
3837 return FALSE;
3838 }
3839 if (h != NULL)
3840 {
3841 if (h->dynindx == -1)
3842 switch (ELF_ST_VISIBILITY (h->other))
3843 {
3844 case STV_INTERNAL:
3845 case STV_HIDDEN:
3846 break;
3847 default:
3848 bfd_elf32_link_record_dynamic_symbol (info, h);
3849 break;
3850 }
3851 picrel
3852 = frv_pic_relocs_info_for_global (frv_relocs_info (info),
3853 abfd, h,
3854 rel->r_addend);
3855 }
3856 else
3857 picrel = frv_pic_relocs_info_for_local (frv_relocs_info (info),
3858 abfd, r_symndx,
3859 rel->r_addend);
3860 if (! picrel)
3861 return FALSE;
3862 break;
3863
3864 default:
3865 picrel = NULL;
3866 break;
3867 }
3868
3869 switch (ELF32_R_TYPE (rel->r_info))
3870 {
3871 case R_FRV_LABEL24:
3872 picrel->call = 1;
3873 break;
3874
3875 case R_FRV_FUNCDESC_VALUE:
3876 picrel->relocsfdv++;
3877 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
3878 picrel->relocs32--;
3879 /* Fall through. */
3880 case R_FRV_32:
3881 picrel->sym = 1;
3882 if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
3883 picrel->relocs32++;
3884 break;
3885
3886 case R_FRV_GOT12:
3887 picrel->got12 = 1;
3888 break;
3889
3890 case R_FRV_GOTHI:
3891 case R_FRV_GOTLO:
3892 picrel->gothilo = 1;
3893 break;
3894
3895 case R_FRV_FUNCDESC_GOT12:
3896 picrel->fdgot12 = 1;
3897 break;
3898
3899 case R_FRV_FUNCDESC_GOTHI:
3900 case R_FRV_FUNCDESC_GOTLO:
3901 picrel->fdgothilo = 1;
3902 break;
3903
3904 case R_FRV_GOTOFF12:
3905 case R_FRV_GOTOFFHI:
3906 case R_FRV_GOTOFFLO:
3907 picrel->gotoff = 1;
3908 break;
3909
3910 case R_FRV_FUNCDESC_GOTOFF12:
3911 picrel->fdgoff12 = 1;
3912 break;
3913
3914 case R_FRV_FUNCDESC_GOTOFFHI:
3915 case R_FRV_FUNCDESC_GOTOFFLO:
3916 picrel->fdgoffhilo = 1;
3917 break;
3918
3919 case R_FRV_FUNCDESC:
3920 picrel->fd = 1;
3921 picrel->relocsfd++;
3922 break;
3923
3924 /* This relocation describes the C++ object vtable hierarchy.
3925 Reconstruct it for later use during GC. */
3926 case R_FRV_GNU_VTINHERIT:
3927 if (!_bfd_elf32_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3928 return FALSE;
3929 break;
3930
3931 /* This relocation describes which C++ vtable entries are actually
3932 used. Record for later use during GC. */
3933 case R_FRV_GNU_VTENTRY:
3934 if (!_bfd_elf32_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3935 return FALSE;
3936 break;
3937 }
3938 }
3939
3940 return TRUE;
3941 }
3942
3943 \f
3944 /* Return the machine subcode from the ELF e_flags header. */
3945
3946 static int
3947 elf32_frv_machine (abfd)
3948 bfd *abfd;
3949 {
3950 switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
3951 {
3952 default: break;
3953 case EF_FRV_CPU_FR550: return bfd_mach_fr550;
3954 case EF_FRV_CPU_FR500: return bfd_mach_fr500;
3955 case EF_FRV_CPU_FR400: return bfd_mach_fr400;
3956 case EF_FRV_CPU_FR300: return bfd_mach_fr300;
3957 case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
3958 case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
3959 }
3960
3961 return bfd_mach_frv;
3962 }
3963
3964 /* Set the right machine number for a FRV ELF file. */
3965
3966 static bfd_boolean
3967 elf32_frv_object_p (abfd)
3968 bfd *abfd;
3969 {
3970 bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
3971 return TRUE;
3972 }
3973 \f
3974 /* Function to set the ELF flag bits. */
3975
3976 static bfd_boolean
3977 frv_elf_set_private_flags (abfd, flags)
3978 bfd *abfd;
3979 flagword flags;
3980 {
3981 elf_elfheader (abfd)->e_flags = flags;
3982 elf_flags_init (abfd) = TRUE;
3983 return TRUE;
3984 }
3985
3986 /* Copy backend specific data from one object module to another. */
3987
3988 static bfd_boolean
3989 frv_elf_copy_private_bfd_data (ibfd, obfd)
3990 bfd *ibfd;
3991 bfd *obfd;
3992 {
3993 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3994 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3995 return TRUE;
3996
3997 BFD_ASSERT (!elf_flags_init (obfd)
3998 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
3999
4000 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4001 elf_flags_init (obfd) = TRUE;
4002 return TRUE;
4003 }
4004
4005 /* Merge backend specific data from an object file to the output
4006 object file when linking. */
4007
4008 static bfd_boolean
4009 frv_elf_merge_private_bfd_data (ibfd, obfd)
4010 bfd *ibfd;
4011 bfd *obfd;
4012 {
4013 flagword old_flags, old_partial;
4014 flagword new_flags, new_partial;
4015 bfd_boolean error = FALSE;
4016 char new_opt[80];
4017 char old_opt[80];
4018
4019 new_opt[0] = old_opt[0] = '\0';
4020 new_flags = elf_elfheader (ibfd)->e_flags;
4021 old_flags = elf_elfheader (obfd)->e_flags;
4022
4023 if (new_flags & EF_FRV_FDPIC)
4024 new_flags &= ~EF_FRV_PIC;
4025
4026 #ifdef DEBUG
4027 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4028 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4029 bfd_get_filename (ibfd));
4030 #endif
4031
4032 if (!elf_flags_init (obfd)) /* First call, no flags set. */
4033 {
4034 elf_flags_init (obfd) = TRUE;
4035 old_flags = new_flags;
4036 }
4037
4038 else if (new_flags == old_flags) /* Compatible flags are ok. */
4039 ;
4040
4041 else /* Possibly incompatible flags. */
4042 {
4043 /* Warn if different # of gprs are used. Note, 0 means nothing is
4044 said about the size of gprs. */
4045 new_partial = (new_flags & EF_FRV_GPR_MASK);
4046 old_partial = (old_flags & EF_FRV_GPR_MASK);
4047 if (new_partial == old_partial)
4048 ;
4049
4050 else if (new_partial == 0)
4051 ;
4052
4053 else if (old_partial == 0)
4054 old_flags |= new_partial;
4055
4056 else
4057 {
4058 switch (new_partial)
4059 {
4060 default: strcat (new_opt, " -mgpr-??"); break;
4061 case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
4062 case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
4063 }
4064
4065 switch (old_partial)
4066 {
4067 default: strcat (old_opt, " -mgpr-??"); break;
4068 case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
4069 case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
4070 }
4071 }
4072
4073 /* Warn if different # of fprs are used. Note, 0 means nothing is
4074 said about the size of fprs. */
4075 new_partial = (new_flags & EF_FRV_FPR_MASK);
4076 old_partial = (old_flags & EF_FRV_FPR_MASK);
4077 if (new_partial == old_partial)
4078 ;
4079
4080 else if (new_partial == 0)
4081 ;
4082
4083 else if (old_partial == 0)
4084 old_flags |= new_partial;
4085
4086 else
4087 {
4088 switch (new_partial)
4089 {
4090 default: strcat (new_opt, " -mfpr-?"); break;
4091 case EF_FRV_FPR_32: strcat (new_opt, " -mfpr-32"); break;
4092 case EF_FRV_FPR_64: strcat (new_opt, " -mfpr-64"); break;
4093 case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
4094 }
4095
4096 switch (old_partial)
4097 {
4098 default: strcat (old_opt, " -mfpr-?"); break;
4099 case EF_FRV_FPR_32: strcat (old_opt, " -mfpr-32"); break;
4100 case EF_FRV_FPR_64: strcat (old_opt, " -mfpr-64"); break;
4101 case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
4102 }
4103 }
4104
4105 /* Warn if different dword support was used. Note, 0 means nothing is
4106 said about the dword support. */
4107 new_partial = (new_flags & EF_FRV_DWORD_MASK);
4108 old_partial = (old_flags & EF_FRV_DWORD_MASK);
4109 if (new_partial == old_partial)
4110 ;
4111
4112 else if (new_partial == 0)
4113 ;
4114
4115 else if (old_partial == 0)
4116 old_flags |= new_partial;
4117
4118 else
4119 {
4120 switch (new_partial)
4121 {
4122 default: strcat (new_opt, " -mdword-?"); break;
4123 case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword"); break;
4124 case EF_FRV_DWORD_NO: strcat (new_opt, " -mno-dword"); break;
4125 }
4126
4127 switch (old_partial)
4128 {
4129 default: strcat (old_opt, " -mdword-?"); break;
4130 case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword"); break;
4131 case EF_FRV_DWORD_NO: strcat (old_opt, " -mno-dword"); break;
4132 }
4133 }
4134
4135 /* Or in flags that accumulate (ie, if one module uses it, mark that the
4136 feature is used. */
4137 old_flags |= new_flags & (EF_FRV_DOUBLE
4138 | EF_FRV_MEDIA
4139 | EF_FRV_MULADD
4140 | EF_FRV_NON_PIC_RELOCS);
4141
4142 /* If any module was compiled without -G0, clear the G0 bit. */
4143 old_flags = ((old_flags & ~ EF_FRV_G0)
4144 | (old_flags & new_flags & EF_FRV_G0));
4145
4146 /* If any module was compiled without -mnopack, clear the mnopack bit. */
4147 old_flags = ((old_flags & ~ EF_FRV_NOPACK)
4148 | (old_flags & new_flags & EF_FRV_NOPACK));
4149
4150 /* We don't have to do anything if the pic flags are the same, or the new
4151 module(s) were compiled with -mlibrary-pic. */
4152 new_partial = (new_flags & EF_FRV_PIC_FLAGS);
4153 old_partial = (old_flags & EF_FRV_PIC_FLAGS);
4154 if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
4155 ;
4156
4157 /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
4158 flags if any from the new module. */
4159 else if ((old_partial & EF_FRV_LIBPIC) != 0)
4160 old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
4161
4162 /* If we have mixtures of -fpic and -fPIC, or in both bits. */
4163 else if (new_partial != 0 && old_partial != 0)
4164 old_flags |= new_partial;
4165
4166 /* One module was compiled for pic and the other was not, see if we have
4167 had any relocations that are not pic-safe. */
4168 else
4169 {
4170 if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
4171 old_flags |= new_partial;
4172 else
4173 {
4174 old_flags &= ~ EF_FRV_PIC_FLAGS;
4175 #ifndef FRV_NO_PIC_ERROR
4176 error = TRUE;
4177 (*_bfd_error_handler)
4178 (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
4179 bfd_get_filename (ibfd),
4180 (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
4181 #endif
4182 }
4183 }
4184
4185 /* Warn if different cpu is used (allow a specific cpu to override
4186 the generic cpu). */
4187 new_partial = (new_flags & EF_FRV_CPU_MASK);
4188 old_partial = (old_flags & EF_FRV_CPU_MASK);
4189 if (new_partial == old_partial)
4190 ;
4191
4192 else if (new_partial == EF_FRV_CPU_GENERIC)
4193 ;
4194
4195 else if (old_partial == EF_FRV_CPU_GENERIC)
4196 old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
4197
4198 else
4199 {
4200 switch (new_partial)
4201 {
4202 default: strcat (new_opt, " -mcpu=?"); break;
4203 case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv"); break;
4204 case EF_FRV_CPU_SIMPLE: strcat (new_opt, " -mcpu=simple"); break;
4205 case EF_FRV_CPU_FR550: strcat (new_opt, " -mcpu=fr550"); break;
4206 case EF_FRV_CPU_FR500: strcat (new_opt, " -mcpu=fr500"); break;
4207 case EF_FRV_CPU_FR400: strcat (new_opt, " -mcpu=fr400"); break;
4208 case EF_FRV_CPU_FR300: strcat (new_opt, " -mcpu=fr300"); break;
4209 case EF_FRV_CPU_TOMCAT: strcat (new_opt, " -mcpu=tomcat"); break;
4210 }
4211
4212 switch (old_partial)
4213 {
4214 default: strcat (old_opt, " -mcpu=?"); break;
4215 case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv"); break;
4216 case EF_FRV_CPU_SIMPLE: strcat (old_opt, " -mcpu=simple"); break;
4217 case EF_FRV_CPU_FR550: strcat (old_opt, " -mcpu=fr550"); break;
4218 case EF_FRV_CPU_FR500: strcat (old_opt, " -mcpu=fr500"); break;
4219 case EF_FRV_CPU_FR400: strcat (old_opt, " -mcpu=fr400"); break;
4220 case EF_FRV_CPU_FR300: strcat (old_opt, " -mcpu=fr300"); break;
4221 case EF_FRV_CPU_TOMCAT: strcat (old_opt, " -mcpu=tomcat"); break;
4222 }
4223 }
4224
4225 /* Print out any mismatches from above. */
4226 if (new_opt[0])
4227 {
4228 error = TRUE;
4229 (*_bfd_error_handler)
4230 (_("%s: compiled with %s and linked with modules compiled with %s"),
4231 bfd_get_filename (ibfd), new_opt, old_opt);
4232 }
4233
4234 /* Warn about any other mismatches */
4235 new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
4236 old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
4237 if (new_partial != old_partial)
4238 {
4239 old_flags |= new_partial;
4240 error = TRUE;
4241 (*_bfd_error_handler)
4242 (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
4243 bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
4244 }
4245 }
4246
4247 /* If the cpu is -mcpu=simple, then set the -mnopack bit. */
4248 if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
4249 old_flags |= EF_FRV_NOPACK;
4250
4251 /* Update the old flags now with changes made above. */
4252 old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
4253 elf_elfheader (obfd)->e_flags = old_flags;
4254 if (old_partial != (old_flags & EF_FRV_CPU_MASK))
4255 bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
4256
4257 if (error)
4258 bfd_set_error (bfd_error_bad_value);
4259
4260 return !error;
4261 }
4262
4263 \f
4264 bfd_boolean
4265 frv_elf_print_private_bfd_data (abfd, ptr)
4266 bfd *abfd;
4267 PTR ptr;
4268 {
4269 FILE *file = (FILE *) ptr;
4270 flagword flags;
4271
4272 BFD_ASSERT (abfd != NULL && ptr != NULL);
4273
4274 /* Print normal ELF private data. */
4275 _bfd_elf_print_private_bfd_data (abfd, ptr);
4276
4277 flags = elf_elfheader (abfd)->e_flags;
4278 fprintf (file, _("private flags = 0x%lx:"), (long)flags);
4279
4280 switch (flags & EF_FRV_CPU_MASK)
4281 {
4282 default: break;
4283 case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple"); break;
4284 case EF_FRV_CPU_FR550: fprintf (file, " -mcpu=fr550"); break;
4285 case EF_FRV_CPU_FR500: fprintf (file, " -mcpu=fr500"); break;
4286 case EF_FRV_CPU_FR400: fprintf (file, " -mcpu=fr400"); break;
4287 case EF_FRV_CPU_FR300: fprintf (file, " -mcpu=fr300"); break;
4288 case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat"); break;
4289 }
4290
4291 switch (flags & EF_FRV_GPR_MASK)
4292 {
4293 default: break;
4294 case EF_FRV_GPR_32: fprintf (file, " -mgpr-32"); break;
4295 case EF_FRV_GPR_64: fprintf (file, " -mgpr-64"); break;
4296 }
4297
4298 switch (flags & EF_FRV_FPR_MASK)
4299 {
4300 default: break;
4301 case EF_FRV_FPR_32: fprintf (file, " -mfpr-32"); break;
4302 case EF_FRV_FPR_64: fprintf (file, " -mfpr-64"); break;
4303 case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float"); break;
4304 }
4305
4306 switch (flags & EF_FRV_DWORD_MASK)
4307 {
4308 default: break;
4309 case EF_FRV_DWORD_YES: fprintf (file, " -mdword"); break;
4310 case EF_FRV_DWORD_NO: fprintf (file, " -mno-dword"); break;
4311 }
4312
4313 if (flags & EF_FRV_DOUBLE)
4314 fprintf (file, " -mdouble");
4315
4316 if (flags & EF_FRV_MEDIA)
4317 fprintf (file, " -mmedia");
4318
4319 if (flags & EF_FRV_MULADD)
4320 fprintf (file, " -mmuladd");
4321
4322 if (flags & EF_FRV_PIC)
4323 fprintf (file, " -fpic");
4324
4325 if (flags & EF_FRV_BIGPIC)
4326 fprintf (file, " -fPIC");
4327
4328 if (flags & EF_FRV_LIBPIC)
4329 fprintf (file, " -mlibrary-pic");
4330
4331 if (flags & EF_FRV_FDPIC)
4332 fprintf (file, " -mfdpic");
4333
4334 if (flags & EF_FRV_NON_PIC_RELOCS)
4335 fprintf (file, " non-pic relocations");
4336
4337 if (flags & EF_FRV_G0)
4338 fprintf (file, " -G0");
4339
4340 fputc ('\n', file);
4341 return TRUE;
4342 }
4343
4344 \f
4345 #define ELF_ARCH bfd_arch_frv
4346 #define ELF_MACHINE_CODE EM_CYGNUS_FRV
4347 #define ELF_MAXPAGESIZE 0x1000
4348
4349 #define TARGET_BIG_SYM bfd_elf32_frv_vec
4350 #define TARGET_BIG_NAME "elf32-frv"
4351
4352 #define elf_info_to_howto_rel frv_info_to_howto_rel
4353 #define elf_info_to_howto frv_info_to_howto_rela
4354 #define elf_backend_relocate_section elf32_frv_relocate_section
4355 #define elf_backend_gc_mark_hook elf32_frv_gc_mark_hook
4356 #define elf_backend_gc_sweep_hook elf32_frv_gc_sweep_hook
4357 #define elf_backend_check_relocs elf32_frv_check_relocs
4358 #define elf_backend_object_p elf32_frv_object_p
4359 #define elf_backend_add_symbol_hook elf32_frv_add_symbol_hook
4360
4361 #define elf_backend_can_gc_sections 1
4362 #define elf_backend_rela_normal 1
4363
4364 #define bfd_elf32_bfd_reloc_type_lookup frv_reloc_type_lookup
4365 #define bfd_elf32_bfd_set_private_flags frv_elf_set_private_flags
4366 #define bfd_elf32_bfd_copy_private_bfd_data frv_elf_copy_private_bfd_data
4367 #define bfd_elf32_bfd_merge_private_bfd_data frv_elf_merge_private_bfd_data
4368 #define bfd_elf32_bfd_print_private_bfd_data frv_elf_print_private_bfd_data
4369
4370 #define bfd_elf32_bfd_link_hash_table_create frv_elf_link_hash_table_create
4371 #define elf_backend_always_size_sections \
4372 elf32_frv_always_size_sections
4373 #define elf_backend_modify_segment_map \
4374 elf32_frv_modify_segment_map
4375
4376 #define elf_backend_create_dynamic_sections \
4377 elf32_frv_create_dynamic_sections
4378 #define elf_backend_adjust_dynamic_symbol \
4379 elf32_frv_adjust_dynamic_symbol
4380 #define elf_backend_size_dynamic_sections \
4381 elf32_frv_size_dynamic_sections
4382 #define elf_backend_finish_dynamic_symbol \
4383 elf32_frv_finish_dynamic_symbol
4384 #define elf_backend_finish_dynamic_sections \
4385 elf32_frv_finish_dynamic_sections
4386
4387 #define elf_backend_want_got_sym 1
4388 #define elf_backend_got_header_size 0
4389 #define elf_backend_want_got_plt 0
4390 #define elf_backend_plt_readonly 1
4391 #define elf_backend_want_plt_sym 0
4392 #define elf_backend_plt_header_size 0
4393
4394 #define elf_backend_may_use_rel_p 1
4395 #define elf_backend_may_use_rela_p 1
4396 /* We use REL for dynamic relocations only. */
4397 #define elf_backend_default_use_rela_p 1
4398
4399 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.324179 seconds and 4 git commands to generate.