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