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