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