projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
unrecognized/unsupported reloc message
[deliverable/binutils-gdb.git] / bfd / elf32-metag.c
1 /* Meta support for 32-bit ELF
2 Copyright (C) 2013-2018 Free Software Foundation, Inc.
3 Contributed by Imagination Technologies Ltd.
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 "elf32-metag.h"
27 #include "elf/metag.h"
28
29 #define GOT_ENTRY_SIZE 4
30 #define ELF_DYNAMIC_INTERPRETER "/lib/ld-uClibc.so.0"
31
32 /* ABI version:
33 0 - original
34 1 - with GOT offset */
35 #define METAG_ELF_ABI_VERSION 1
36
37 static const unsigned int plt0_entry[] =
38 {
39 0x02000005, /* MOVT D0Re0, #HI(GOT+4) */
40 0x02000000, /* ADD D0Re0, D0Re0, #LO(GOT+4) */
41 0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
42 0xc600012a, /* GETD PC, [D0Re0+#4] */
43 0xa0fffffe /* NOP */
44 };
45
46 static const unsigned int plt0_pic_entry[] =
47 {
48 0x82900001, /* ADDT A0.2, CPC0, #0 */
49 0x82100000, /* ADD A0.2, A0.2, #0 */
50 0xa3100c20, /* MOV D0Re0, A0.2 */
51 0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
52 0xc600012a, /* GETD PC, [D0Re0+#4] */
53 };
54
55 static const unsigned int plt_entry[] =
56 {
57 0x82100005, /* MOVT A0.2, #HI(GOT+off) */
58 0x82100000, /* ADD A0.2, A0.2, #LO(GOT+off) */
59 0xc600806a, /* GETD PC, [A0.2] */
60 0x03000004, /* MOV D1Re0, #LO(offset) */
61 0xa0000000 /* B PLT0 */
62 };
63
64 static const unsigned int plt_pic_entry[] =
65 {
66 0x82900001, /* ADDT A0.2, CPC0, #HI(GOT+off) */
67 0x82100000, /* ADD A0.2, A0.2, #LO(GOT+off) */
68 0xc600806a, /* GETD PC, [A0.2] */
69 0x03000004, /* MOV D1Re0, #LO(offset) */
70 0xa0000000 /* B PLT0 */
71 };
72
73 /* Variable names follow a coding style.
74 Please follow this (Apps Hungarian) style:
75
76 Structure/Variable Prefix
77 elf_link_hash_table "etab"
78 elf_link_hash_entry "eh"
79
80 elf_metag_link_hash_table "htab"
81 elf_metag_link_hash_entry "hh"
82
83 bfd_link_hash_table "btab"
84 bfd_link_hash_entry "bh"
85
86 bfd_hash_table containing stubs "bstab"
87 elf_metag_stub_hash_entry "hsh"
88
89 Always remember to use GNU Coding Style. */
90
91 #define PLT_ENTRY_SIZE sizeof(plt_entry)
92
93 static reloc_howto_type elf_metag_howto_table[] =
94 {
95 /* High order 16 bit absolute. */
96 HOWTO (R_METAG_HIADDR16, /* type */
97 16, /* rightshift */
98 2, /* size (0 = byte, 1 = short, 2 = long) */
99 16, /* bitsize */
100 FALSE, /* pc_relative */
101 3, /* bitpos */
102 complain_overflow_dont, /* complain_on_overflow */
103 bfd_elf_generic_reloc, /* special_function */
104 "R_METAG_HIADDR16", /* name */
105 FALSE, /* partial_inplace */
106 0, /* src_mask */
107 0x0007fff8, /* dst_mask */
108 FALSE), /* pcrel_offset */
109
110 /* Low order 16 bit absolute. */
111 HOWTO (R_METAG_LOADDR16, /* type */
112 0, /* rightshift */
113 2, /* size (0 = byte, 1 = short, 2 = long) */
114 16, /* bitsize */
115 FALSE, /* pc_relative */
116 3, /* bitpos */
117 complain_overflow_dont,/* complain_on_overflow */
118 bfd_elf_generic_reloc, /* special_function */
119 "R_METAG_LOADDR16", /* name */
120 FALSE, /* partial_inplace */
121 0, /* src_mask */
122 0x0007fff8, /* dst_mask */
123 FALSE), /* pcrel_offset */
124
125 /* 32 bit absolute. */
126 HOWTO (R_METAG_ADDR32, /* type */
127 0, /* rightshift */
128 2, /* size (0 = byte, 1 = short, 2 = long) */
129 32, /* bitsize */
130 FALSE, /* pc_relative */
131 0, /* bitpos */
132 complain_overflow_bitfield, /* complain_on_overflow */
133 bfd_elf_generic_reloc, /* special_function */
134 "R_METAG_ADDR32", /* name */
135 FALSE, /* partial_inplace */
136 0x00000000, /* src_mask */
137 0xffffffff, /* dst_mask */
138 FALSE), /* pcrel_offset */
139
140 /* No relocation. */
141 HOWTO (R_METAG_NONE, /* type */
142 0, /* rightshift */
143 3, /* size (0 = byte, 1 = short, 2 = long) */
144 0, /* bitsize */
145 FALSE, /* pc_relative */
146 0, /* bitpos */
147 complain_overflow_dont, /* complain_on_overflow */
148 bfd_elf_generic_reloc, /* special_function */
149 "R_METAG_NONE", /* name */
150 FALSE, /* partial_inplace */
151 0, /* src_mask */
152 0, /* dst_mask */
153 FALSE), /* pcrel_offset */
154
155 /* 19 bit pc relative */
156 HOWTO (R_METAG_RELBRANCH, /* type */
157 2, /* rightshift */
158 2, /* size (0 = byte, 1 = short, 2 = long) */
159 19, /* bitsize */
160 TRUE, /* pc_relative */
161 5, /* bitpos */
162 complain_overflow_signed, /* complain_on_overflow */
163 bfd_elf_generic_reloc, /* special_function */
164 "R_METAG_RELBRANCH", /* name */
165 FALSE, /* partial_inplace */
166 0, /* src_mask */
167 0x00ffffe0, /* dst_mask */
168 FALSE), /* pcrel_offset */
169
170 /* GET/SET offset */
171 HOWTO (R_METAG_GETSETOFF, /* type */
172 0, /* rightshift */
173 1, /* size (0 = byte, 1 = short, 2 = long) */
174 12, /* bitsize */
175 FALSE, /* pc_relative */
176 7, /* bitpos */
177 complain_overflow_dont, /* complain_on_overflow */
178 bfd_elf_generic_reloc, /* special_function */
179 "R_METAG_GETSETOFF", /* name */
180 FALSE, /* partial_inplace */
181 0, /* src_mask */
182 0, /* dst_mask */
183 FALSE), /* pcrel_offset */
184
185 EMPTY_HOWTO (6),
186 EMPTY_HOWTO (7),
187 EMPTY_HOWTO (8),
188 EMPTY_HOWTO (9),
189 EMPTY_HOWTO (10),
190 EMPTY_HOWTO (11),
191 EMPTY_HOWTO (12),
192 EMPTY_HOWTO (13),
193 EMPTY_HOWTO (14),
194 EMPTY_HOWTO (15),
195 EMPTY_HOWTO (16),
196 EMPTY_HOWTO (17),
197 EMPTY_HOWTO (18),
198 EMPTY_HOWTO (19),
199 EMPTY_HOWTO (20),
200 EMPTY_HOWTO (21),
201 EMPTY_HOWTO (22),
202 EMPTY_HOWTO (23),
203 EMPTY_HOWTO (24),
204 EMPTY_HOWTO (25),
205 EMPTY_HOWTO (26),
206 EMPTY_HOWTO (27),
207 EMPTY_HOWTO (28),
208 EMPTY_HOWTO (29),
209
210 HOWTO (R_METAG_GNU_VTINHERIT, /* type */
211 0, /* rightshift */
212 2, /* size (0 = byte, 1 = short, 2 = long) */
213 0, /* bitsize */
214 FALSE, /* pc_relative */
215 0, /* bitpos */
216 complain_overflow_dont, /* complain_on_overflow */
217 NULL, /* special_function */
218 "R_METAG_GNU_VTINHERIT", /* name */
219 FALSE, /* partial_inplace */
220 0, /* src_mask */
221 0, /* dst_mask */
222 FALSE), /* pcrel_offset */
223
224 HOWTO (R_METAG_GNU_VTENTRY, /* type */
225 0, /* rightshift */
226 2, /* size (0 = byte, 1 = short, 2 = long) */
227 0, /* bitsize */
228 FALSE, /* pc_relative */
229 0, /* bitpos */
230 complain_overflow_dont, /* complain_on_overflow */
231 _bfd_elf_rel_vtable_reloc_fn, /* special_function */
232 "R_METAG_GNU_VTENTRY", /* name */
233 FALSE, /* partial_inplace */
234 0, /* src_mask */
235 0, /* dst_mask */
236 FALSE), /* pcrel_offset */
237
238 /* High order 16 bit GOT offset */
239 HOWTO (R_METAG_HI16_GOTOFF, /* type */
240 16, /* rightshift */
241 2, /* size (0 = byte, 1 = short, 2 = long) */
242 16, /* bitsize */
243 FALSE, /* pc_relative */
244 3, /* bitpos */
245 complain_overflow_dont, /* complain_on_overflow */
246 bfd_elf_generic_reloc, /* special_function */
247 "R_METAG_HI16_GOTOFF", /* name */
248 FALSE, /* partial_inplace */
249 0, /* src_mask */
250 0x0007fff8, /* dst_mask */
251 FALSE), /* pcrel_offset */
252
253 /* Low order 16 bit GOT offset */
254 HOWTO (R_METAG_LO16_GOTOFF, /* type */
255 0, /* rightshift */
256 2, /* size (0 = byte, 1 = short, 2 = long) */
257 16, /* bitsize */
258 FALSE, /* pc_relative */
259 3, /* bitpos */
260 complain_overflow_dont, /* complain_on_overflow */
261 bfd_elf_generic_reloc, /* special_function */
262 "R_METAG_LO16_GOTOFF", /* name */
263 FALSE, /* partial_inplace */
264 0, /* src_mask */
265 0x0007fff8, /* dst_mask */
266 FALSE), /* pcrel_offset */
267
268 /* GET/SET GOT offset */
269 HOWTO (R_METAG_GETSET_GOTOFF, /* type */
270 0, /* rightshift */
271 1, /* size (0 = byte, 1 = short, 2 = long) */
272 12, /* bitsize */
273 FALSE, /* pc_relative */
274 7, /* bitpos */
275 complain_overflow_dont, /* complain_on_overflow */
276 bfd_elf_generic_reloc, /* special_function */
277 "R_METAG_GETSET_GOTOFF", /* name */
278 FALSE, /* partial_inplace */
279 0, /* src_mask */
280 0, /* dst_mask */
281 FALSE), /* pcrel_offset */
282
283 /* GET/SET GOT relative */
284 HOWTO (R_METAG_GETSET_GOT, /* type */
285 0, /* rightshift */
286 1, /* size (0 = byte, 1 = short, 2 = long) */
287 12, /* bitsize */
288 FALSE, /* pc_relative */
289 7, /* bitpos */
290 complain_overflow_dont, /* complain_on_overflow */
291 bfd_elf_generic_reloc, /* special_function */
292 "R_METAG_GETSET_GOT", /* name */
293 FALSE, /* partial_inplace */
294 0, /* src_mask */
295 0, /* dst_mask */
296 FALSE), /* pcrel_offset */
297
298 /* High order 16 bit GOT reference */
299 HOWTO (R_METAG_HI16_GOTPC, /* type */
300 16, /* rightshift */
301 2, /* size (0 = byte, 1 = short, 2 = long) */
302 16, /* bitsize */
303 FALSE, /* pc_relative */
304 3, /* bitpos */
305 complain_overflow_dont, /* complain_on_overflow */
306 bfd_elf_generic_reloc, /* special_function */
307 "R_METAG_HI16_GOTPC", /* name */
308 FALSE, /* partial_inplace */
309 0, /* src_mask */
310 0x0007fff8, /* dst_mask */
311 FALSE), /* pcrel_offset */
312
313 /* Low order 16 bit GOT reference */
314 HOWTO (R_METAG_LO16_GOTPC, /* type */
315 0, /* rightshift */
316 2, /* size (0 = byte, 1 = short, 2 = long) */
317 16, /* bitsize */
318 FALSE, /* pc_relative */
319 3, /* bitpos */
320 complain_overflow_dont, /* complain_on_overflow */
321 bfd_elf_generic_reloc, /* special_function */
322 "R_METAG_LO16_GOTPC", /* name */
323 FALSE, /* partial_inplace */
324 0, /* src_mask */
325 0x0007fff8, /* dst_mask */
326 FALSE), /* pcrel_offset */
327
328 /* High order 16 bit PLT */
329 HOWTO (R_METAG_HI16_PLT, /* type */
330 16, /* rightshift */
331 2, /* size (0 = byte, 1 = short, 2 = long) */
332 16, /* bitsize */
333 FALSE, /* pc_relative */
334 3, /* bitpos */
335 complain_overflow_dont, /* complain_on_overflow */
336 bfd_elf_generic_reloc, /* special_function */
337 "R_METAG_HI16_PLT", /* name */
338 FALSE, /* partial_inplace */
339 0, /* src_mask */
340 0x0007fff8, /* dst_mask */
341 FALSE), /* pcrel_offset */
342
343 /* Low order 16 bit PLT */
344 HOWTO (R_METAG_LO16_PLT, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 3, /* bitpos */
350 complain_overflow_dont, /* complain_on_overflow */
351 bfd_elf_generic_reloc, /* special_function */
352 "R_METAG_LO16_PLT", /* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0xffffffff, /* dst_mask */
356 FALSE), /* pcrel_offset */
357
358 HOWTO (R_METAG_RELBRANCH_PLT, /* type */
359 2, /* rightshift */
360 2, /* size (0 = byte, 1 = short, 2 = long) */
361 19, /* bitsize */
362 TRUE, /* pc_relative */
363 5, /* bitpos */
364 complain_overflow_signed, /* complain_on_overflow */
365 bfd_elf_generic_reloc, /* special_function */
366 "R_METAG_RELBRANCH_PLT", /* name */
367 FALSE, /* partial_inplace */
368 0, /* src_mask */
369 0x00ffffe0, /* dst_mask */
370 FALSE), /* pcrel_offset */
371
372 /* Dummy relocs used by the linker internally. */
373 HOWTO (R_METAG_GOTOFF, /* type */
374 0, /* rightshift */
375 2, /* size (0 = byte, 1 = short, 2 = long) */
376 32, /* bitsize */
377 FALSE, /* pc_relative */
378 0, /* bitpos */
379 complain_overflow_bitfield, /* complain_on_overflow */
380 bfd_elf_generic_reloc, /* special_function */
381 "R_METAG_GOTOFF", /* name */
382 FALSE, /* partial_inplace */
383 0xffffffff, /* src_mask */
384 0xffffffff, /* dst_mask */
385 FALSE), /* pcrel_offset */
386
387 HOWTO (R_METAG_PLT, /* type */
388 0, /* rightshift */
389 2, /* size (0 = byte, 1 = short, 2 = long) */
390 32, /* bitsize */
391 FALSE, /* pc_relative */
392 0, /* bitpos */
393 complain_overflow_bitfield, /* complain_on_overflow */
394 bfd_elf_generic_reloc, /* special_function */
395 "R_METAG_GOTOFF", /* name */
396 FALSE, /* partial_inplace */
397 0xffffffff, /* src_mask */
398 0xffffffff, /* dst_mask */
399 FALSE), /* pcrel_offset */
400
401 /* This is used only by the dynamic linker. The symbol should exist
402 both in the object being run and in some shared library. The
403 dynamic linker copies the data addressed by the symbol from the
404 shared library into the object, because the object being
405 run has to have the data at some particular address. */
406 HOWTO (R_METAG_COPY, /* type */
407 0, /* rightshift */
408 2, /* size (0 = byte, 1 = short, 2 = long) */
409 32, /* bitsize */
410 FALSE, /* pc_relative */
411 0, /* bitpos */
412 complain_overflow_bitfield, /* complain_on_overflow */
413 bfd_elf_generic_reloc, /* special_function */
414 "R_METAG_COPY", /* name */
415 FALSE, /* partial_inplace */
416 0xffffffff, /* src_mask */
417 0xffffffff, /* dst_mask */
418 FALSE), /* pcrel_offset */
419
420 /* Marks a procedure linkage table entry for a symbol. */
421 HOWTO (R_METAG_JMP_SLOT, /* type */
422 0, /* rightshift */
423 2, /* size (0 = byte, 1 = short, 2 = long) */
424 32, /* bitsize */
425 FALSE, /* pc_relative */
426 0, /* bitpos */
427 complain_overflow_bitfield, /* complain_on_overflow */
428 bfd_elf_generic_reloc, /* special_function */
429 "R_METAG_JMP_SLOT", /* name */
430 FALSE, /* partial_inplace */
431 0xffffffff, /* src_mask */
432 0xffffffff, /* dst_mask */
433 FALSE), /* pcrel_offset */
434
435 /* Used only by the dynamic linker. When the object is run, this
436 longword is set to the load address of the object, plus the
437 addend. */
438 HOWTO (R_METAG_RELATIVE, /* type */
439 0, /* rightshift */
440 2, /* size (0 = byte, 1 = short, 2 = long) */
441 32, /* bitsize */
442 FALSE, /* pc_relative */
443 0, /* bitpos */
444 complain_overflow_bitfield, /* complain_on_overflow */
445 bfd_elf_generic_reloc, /* special_function */
446 "R_METAG_RELATIVE", /* name */
447 FALSE, /* partial_inplace */
448 0xffffffff, /* src_mask */
449 0xffffffff, /* dst_mask */
450 FALSE), /* pcrel_offset */
451
452 HOWTO (R_METAG_GLOB_DAT, /* type */
453 0, /* rightshift */
454 2, /* size (0 = byte, 1 = short, 2 = long) */
455 32, /* bitsize */
456 FALSE, /* pc_relative */
457 0, /* bitpos */
458 complain_overflow_bitfield, /* complain_on_overflow */
459 bfd_elf_generic_reloc, /* special_function */
460 "R_METAG_GLOB_DAT", /* name */
461 FALSE, /* partial_inplace */
462 0xffffffff, /* src_mask */
463 0xffffffff, /* dst_mask */
464 FALSE), /* pcrel_offset */
465
466 HOWTO (R_METAG_TLS_GD, /* type */
467 0, /* rightshift */
468 2, /* size (0 = byte, 1 = short, 2 = long) */
469 16, /* bitsize */
470 FALSE, /* pc_relative */
471 3, /* bitpos */
472 complain_overflow_dont, /* complain_on_overflow */
473 bfd_elf_generic_reloc, /* special_function */
474 "R_METAG_TLS_GD", /* name */
475 FALSE, /* partial_inplace */
476 0, /* src_mask */
477 0x0007fff8, /* dst_mask */
478 FALSE), /* pcrel_offset */
479
480 HOWTO (R_METAG_TLS_LDM, /* type */
481 0, /* rightshift */
482 2, /* size (0 = byte, 1 = short, 2 = long) */
483 16, /* bitsize */
484 FALSE, /* pc_relative */
485 3, /* bitpos */
486 complain_overflow_bitfield, /* complain_on_overflow */
487 bfd_elf_generic_reloc, /* special_function */
488 "R_METAG_TLS_LDM", /* name */
489 FALSE, /* partial_inplace */
490 0, /* src_mask */
491 0x0007fff8, /* dst_mask */
492 FALSE), /* pcrel_offset */
493
494 HOWTO (R_METAG_TLS_LDO_HI16, /* type */
495 16, /* rightshift */
496 2, /* size (0 = byte, 1 = short, 2 = long) */
497 16, /* bitsize */
498 FALSE, /* pc_relative */
499 3, /* bitpos */
500 complain_overflow_bitfield, /* complain_on_overflow */
501 bfd_elf_generic_reloc, /* special_function */
502 "R_METAG_TLS_LDO_HI16", /* name */
503 FALSE, /* partial_inplace */
504 0, /* src_mask */
505 0x0007fff8, /* dst_mask */
506 FALSE), /* pcrel_offset */
507
508 HOWTO (R_METAG_TLS_LDO_LO16, /* type */
509 0, /* rightshift */
510 2, /* size (0 = byte, 1 = short, 2 = long) */
511 16, /* bitsize */
512 FALSE, /* pc_relative */
513 3, /* bitpos */
514 complain_overflow_bitfield, /* complain_on_overflow */
515 bfd_elf_generic_reloc, /* special_function */
516 "R_METAG_TLS_LDO_LO16", /* name */
517 FALSE, /* partial_inplace */
518 0, /* src_mask */
519 0x0007fff8, /* dst_mask */
520 FALSE), /* pcrel_offset */
521
522 /* Dummy reloc used by the linker internally. */
523 HOWTO (R_METAG_TLS_LDO, /* type */
524 0, /* rightshift */
525 2, /* size (0 = byte, 1 = short, 2 = long) */
526 16, /* bitsize */
527 FALSE, /* pc_relative */
528 3, /* bitpos */
529 complain_overflow_bitfield, /* complain_on_overflow */
530 bfd_elf_generic_reloc, /* special_function */
531 "R_METAG_TLS_LDO", /* name */
532 FALSE, /* partial_inplace */
533 0, /* src_mask */
534 0x0007fff8, /* dst_mask */
535 FALSE), /* pcrel_offset */
536
537 HOWTO (R_METAG_TLS_IE, /* type */
538 2, /* rightshift */
539 2, /* size (0 = byte, 1 = short, 2 = long) */
540 12, /* bitsize */
541 FALSE, /* pc_relative */
542 7, /* bitpos */
543 complain_overflow_dont, /* complain_on_overflow */
544 bfd_elf_generic_reloc, /* special_function */
545 "R_METAG_TLS_IE", /* name */
546 FALSE, /* partial_inplace */
547 0, /* src_mask */
548 0x0007ff80, /* dst_mask */
549 FALSE), /* pcrel_offset */
550
551 /* Dummy reloc used by the linker internally. */
552 HOWTO (R_METAG_TLS_IENONPIC, /* type */
553 0, /* rightshift */
554 2, /* size (0 = byte, 1 = short, 2 = long) */
555 16, /* bitsize */
556 FALSE, /* pc_relative */
557 3, /* bitpos */
558 complain_overflow_dont, /* complain_on_overflow */
559 bfd_elf_generic_reloc, /* special_function */
560 "R_METAG_TLS_IENONPIC", /* name */
561 FALSE, /* partial_inplace */
562 0, /* src_mask */
563 0x0007fff8, /* dst_mask */
564 FALSE), /* pcrel_offset */
565
566 HOWTO (R_METAG_TLS_IENONPIC_HI16,/* type */
567 16, /* rightshift */
568 2, /* size (0 = byte, 1 = short, 2 = long) */
569 16, /* bitsize */
570 FALSE, /* pc_relative */
571 3, /* bitpos */
572 complain_overflow_dont, /* complain_on_overflow */
573 bfd_elf_generic_reloc, /* special_function */
574 "R_METAG_TLS_IENONPIC_HI16", /* name */
575 FALSE, /* partial_inplace */
576 0, /* src_mask */
577 0x0007fff8, /* dst_mask */
578 FALSE), /* pcrel_offset */
579
580 HOWTO (R_METAG_TLS_IENONPIC_LO16,/* type */
581 0, /* rightshift */
582 2, /* size (0 = byte, 1 = short, 2 = long) */
583 16, /* bitsize */
584 FALSE, /* pc_relative */
585 3, /* bitpos */
586 complain_overflow_dont, /* complain_on_overflow */
587 bfd_elf_generic_reloc, /* special_function */
588 "R_METAG_TLS_IENONPIC_LO16", /* name */
589 FALSE, /* partial_inplace */
590 0, /* src_mask */
591 0x0007fff8, /* dst_mask */
592 FALSE), /* pcrel_offset */
593
594 HOWTO (R_METAG_TLS_TPOFF, /* 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_bitfield, /* complain_on_overflow */
601 bfd_elf_generic_reloc, /* special_function */
602 "R_METAG_TLS_TPOFF", /* name */
603 FALSE, /* partial_inplace */
604 0, /* src_mask */
605 0xffffffff, /* dst_mask */
606 FALSE), /* pcrel_offset */
607
608 HOWTO (R_METAG_TLS_DTPMOD, /* type */
609 0, /* rightshift */
610 2, /* size (0 = byte, 1 = short, 2 = long) */
611 32, /* bitsize */
612 FALSE, /* pc_relative */
613 0, /* bitpos */
614 complain_overflow_bitfield, /* complain_on_overflow */
615 bfd_elf_generic_reloc, /* special_function */
616 "R_METAG_TLS_DTPMOD", /* name */
617 FALSE, /* partial_inplace */
618 0, /* src_mask */
619 0xffffffff, /* dst_mask */
620 FALSE), /* pcrel_offset */
621
622 HOWTO (R_METAG_TLS_DTPOFF, /* type */
623 0, /* rightshift */
624 2, /* size (0 = byte, 1 = short, 2 = long) */
625 32, /* bitsize */
626 FALSE, /* pc_relative */
627 0, /* bitpos */
628 complain_overflow_bitfield, /* complain_on_overflow */
629 bfd_elf_generic_reloc, /* special_function */
630 "R_METAG_TLS_DTPOFF", /* name */
631 FALSE, /* partial_inplace */
632 0, /* src_mask */
633 0xffffffff, /* dst_mask */
634 FALSE), /* pcrel_offset */
635
636 /* Dummy reloc used by the linker internally. */
637 HOWTO (R_METAG_TLS_LE, /* type */
638 0, /* rightshift */
639 2, /* size (0 = byte, 1 = short, 2 = long) */
640 32, /* bitsize */
641 FALSE, /* pc_relative */
642 0, /* bitpos */
643 complain_overflow_bitfield, /* complain_on_overflow */
644 bfd_elf_generic_reloc, /* special_function */
645 "R_METAG_TLS_LE", /* name */
646 FALSE, /* partial_inplace */
647 0, /* src_mask */
648 0xffffffff, /* dst_mask */
649 FALSE), /* pcrel_offset */
650
651 HOWTO (R_METAG_TLS_LE_HI16, /* type */
652 16, /* rightshift */
653 2, /* size (0 = byte, 1 = short, 2 = long) */
654 16, /* bitsize */
655 FALSE, /* pc_relative */
656 3, /* bitpos */
657 complain_overflow_dont, /* complain_on_overflow */
658 bfd_elf_generic_reloc, /* special_function */
659 "R_METAG_TLS_LE_HI16", /* name */
660 FALSE, /* partial_inplace */
661 0, /* src_mask */
662 0x0007fff8, /* dst_mask */
663 FALSE), /* pcrel_offset */
664
665 HOWTO (R_METAG_TLS_LE_LO16, /* type */
666 0, /* rightshift */
667 2, /* size (0 = byte, 1 = short, 2 = long) */
668 16, /* bitsize */
669 FALSE, /* pc_relative */
670 3, /* bitpos */
671 complain_overflow_dont, /* complain_on_overflow */
672 bfd_elf_generic_reloc, /* special_function */
673 "R_METAG_TLS_LE_LO16", /* name */
674 FALSE, /* partial_inplace */
675 0, /* src_mask */
676 0x0007fff8, /* dst_mask */
677 FALSE), /* pcrel_offset */
678
679 };
680
681 #define BRANCH_BITS 19
682
683 /* The GOT is typically accessed using a [GS]ETD instruction. The size of the
684 immediate offset which can be used in such instructions therefore limits
685 the usable size of the GOT. If the base register for the [GS]ETD (A1LbP)
686 is pointing to the base of the GOT then the size is limited to the maximum
687 11 bits unsigned dword offset, or 2^13 = 0x2000 bytes. However the offset
688 in a [GS]ETD instruction is signed, so by setting the base address register
689 to an offset of that 0x2000 byte maximum unsigned offset from the base of
690 the GOT we can use negative offsets in addition to positive. This
691 effectively doubles the usable GOT size to 0x4000 bytes. */
692 #define GOT_REG_OFFSET 0x2000
693
694 struct metag_reloc_map
695 {
696 bfd_reloc_code_real_type bfd_reloc_val;
697 unsigned int metag_reloc_val;
698 };
699
700 static const struct metag_reloc_map metag_reloc_map [] =
701 {
702 { BFD_RELOC_NONE, R_METAG_NONE },
703 { BFD_RELOC_32, R_METAG_ADDR32 },
704 { BFD_RELOC_METAG_HIADDR16, R_METAG_HIADDR16 },
705 { BFD_RELOC_METAG_LOADDR16, R_METAG_LOADDR16 },
706 { BFD_RELOC_METAG_RELBRANCH, R_METAG_RELBRANCH },
707 { BFD_RELOC_METAG_GETSETOFF, R_METAG_GETSETOFF },
708 { BFD_RELOC_VTABLE_INHERIT, R_METAG_GNU_VTINHERIT },
709 { BFD_RELOC_VTABLE_ENTRY, R_METAG_GNU_VTENTRY },
710 { BFD_RELOC_METAG_REL8, R_METAG_REL8 },
711 { BFD_RELOC_METAG_REL16, R_METAG_REL16 },
712 { BFD_RELOC_METAG_HI16_GOTOFF, R_METAG_HI16_GOTOFF },
713 { BFD_RELOC_METAG_LO16_GOTOFF, R_METAG_LO16_GOTOFF },
714 { BFD_RELOC_METAG_GETSET_GOTOFF, R_METAG_GETSET_GOTOFF },
715 { BFD_RELOC_METAG_GETSET_GOT, R_METAG_GETSET_GOT },
716 { BFD_RELOC_METAG_HI16_GOTPC, R_METAG_HI16_GOTPC },
717 { BFD_RELOC_METAG_LO16_GOTPC, R_METAG_LO16_GOTPC },
718 { BFD_RELOC_METAG_HI16_PLT, R_METAG_HI16_PLT },
719 { BFD_RELOC_METAG_LO16_PLT, R_METAG_LO16_PLT },
720 { BFD_RELOC_METAG_RELBRANCH_PLT, R_METAG_RELBRANCH_PLT },
721 { BFD_RELOC_METAG_GOTOFF, R_METAG_GOTOFF },
722 { BFD_RELOC_METAG_PLT, R_METAG_PLT },
723 { BFD_RELOC_METAG_COPY, R_METAG_COPY },
724 { BFD_RELOC_METAG_JMP_SLOT, R_METAG_JMP_SLOT },
725 { BFD_RELOC_METAG_RELATIVE, R_METAG_RELATIVE },
726 { BFD_RELOC_METAG_GLOB_DAT, R_METAG_GLOB_DAT },
727 { BFD_RELOC_METAG_TLS_GD, R_METAG_TLS_GD },
728 { BFD_RELOC_METAG_TLS_LDM, R_METAG_TLS_LDM },
729 { BFD_RELOC_METAG_TLS_LDO_HI16, R_METAG_TLS_LDO_HI16 },
730 { BFD_RELOC_METAG_TLS_LDO_LO16, R_METAG_TLS_LDO_LO16 },
731 { BFD_RELOC_METAG_TLS_LDO, R_METAG_TLS_LDO },
732 { BFD_RELOC_METAG_TLS_IE, R_METAG_TLS_IE },
733 { BFD_RELOC_METAG_TLS_IENONPIC, R_METAG_TLS_IENONPIC },
734 { BFD_RELOC_METAG_TLS_IENONPIC_HI16, R_METAG_TLS_IENONPIC_HI16 },
735 { BFD_RELOC_METAG_TLS_IENONPIC_LO16, R_METAG_TLS_IENONPIC_LO16 },
736 { BFD_RELOC_METAG_TLS_TPOFF, R_METAG_TLS_TPOFF },
737 { BFD_RELOC_METAG_TLS_DTPMOD, R_METAG_TLS_DTPMOD },
738 { BFD_RELOC_METAG_TLS_DTPOFF, R_METAG_TLS_DTPOFF },
739 { BFD_RELOC_METAG_TLS_LE, R_METAG_TLS_LE },
740 { BFD_RELOC_METAG_TLS_LE_HI16, R_METAG_TLS_LE_HI16 },
741 { BFD_RELOC_METAG_TLS_LE_LO16, R_METAG_TLS_LE_LO16 },
742 };
743
744 enum elf_metag_stub_type
745 {
746 metag_stub_long_branch,
747 metag_stub_long_branch_shared,
748 metag_stub_none
749 };
750
751 struct elf_metag_stub_hash_entry
752 {
753 /* Base hash table entry structure. */
754 struct bfd_hash_entry bh_root;
755
756 /* The stub section. */
757 asection *stub_sec;
758
759 /* Offset within stub_sec of the beginning of this stub. */
760 bfd_vma stub_offset;
761
762 /* Given the symbol's value and its section we can determine its final
763 value when building the stubs (so the stub knows where to jump. */
764 bfd_vma target_value;
765 asection *target_section;
766
767 enum elf_metag_stub_type stub_type;
768
769 /* The symbol table entry, if any, that this was derived from. */
770 struct elf_metag_link_hash_entry *hh;
771
772 /* And the reloc addend that this was derived from. */
773 bfd_vma addend;
774
775 /* Where this stub is being called from, or, in the case of combined
776 stub sections, the first input section in the group. */
777 asection *id_sec;
778 };
779
780 struct elf_metag_link_hash_entry
781 {
782 struct elf_link_hash_entry eh;
783
784 /* A pointer to the most recently used stub hash entry against this
785 symbol. */
786 struct elf_metag_stub_hash_entry *hsh_cache;
787
788 /* Used to count relocations for delayed sizing of relocation
789 sections. */
790 struct elf_dyn_relocs *dyn_relocs;
791
792 enum
793 {
794 GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_IE = 2, GOT_TLS_LDM = 4, GOT_TLS_GD = 8
795 } tls_type;
796 };
797
798 struct elf_metag_link_hash_table
799 {
800 /* The main hash table. */
801 struct elf_link_hash_table etab;
802
803 /* The stub hash table. */
804 struct bfd_hash_table bstab;
805
806 /* Linker stub bfd. */
807 bfd *stub_bfd;
808
809 /* Linker call-backs. */
810 asection * (*add_stub_section) (const char *, asection *);
811 void (*layout_sections_again) (void);
812
813 /* Array to keep track of which stub sections have been created, and
814 information on stub grouping. */
815 struct map_stub
816 {
817 /* This is the section to which stubs in the group will be
818 attached. */
819 asection *link_sec;
820 /* The stub section. */
821 asection *stub_sec;
822 } *stub_group;
823
824 /* Assorted information used by elf_metag_size_stubs. */
825 unsigned int bfd_count;
826 unsigned int top_index;
827 asection **input_list;
828 Elf_Internal_Sym **all_local_syms;
829
830 /* Small local sym cache. */
831 struct sym_cache sym_cache;
832
833 /* Data for LDM relocations. */
834 union
835 {
836 bfd_signed_vma refcount;
837 bfd_vma offset;
838 } tls_ldm_got;
839 };
840
841 /* Return the base vma address which should be subtracted from the
842 real address when resolving a dtpoff relocation. This is PT_TLS
843 segment p_vaddr. */
844 static bfd_vma
845 dtpoff_base (struct bfd_link_info *info)
846 {
847 /* If tls_sec is NULL, we should have signalled an error already. */
848 if (elf_hash_table (info)->tls_sec == NULL)
849 return 0;
850 return elf_hash_table (info)->tls_sec->vma;
851 }
852
853 /* Return the relocation value for R_METAG_TLS_IE */
854 static bfd_vma
855 tpoff (struct bfd_link_info *info, bfd_vma address)
856 {
857 /* If tls_sec is NULL, we should have signalled an error already. */
858 if (elf_hash_table (info)->tls_sec == NULL)
859 return 0;
860 /* METAG TLS ABI is variant I and static TLS blocks start just after
861 tcbhead structure which has 2 pointer fields. */
862 return (address - elf_hash_table (info)->tls_sec->vma
863 + align_power ((bfd_vma) 8,
864 elf_hash_table (info)->tls_sec->alignment_power));
865 }
866
867 static void
868 metag_info_to_howto_rela (bfd *abfd,
869 arelent *cache_ptr,
870 Elf_Internal_Rela *dst)
871 {
872 unsigned int r_type;
873
874 r_type = ELF32_R_TYPE (dst->r_info);
875 if (r_type >= (unsigned int) R_METAG_MAX)
876 {
877 /* xgettext:c-format */
878 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
879 abfd, r_type);
880 r_type = 0;
881 }
882 cache_ptr->howto = & elf_metag_howto_table [r_type];
883 }
884
885 static reloc_howto_type *
886 metag_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
887 bfd_reloc_code_real_type code)
888 {
889 unsigned int i;
890
891 for (i = 0; i < sizeof (metag_reloc_map) / sizeof (metag_reloc_map[0]); i++)
892 if (metag_reloc_map [i].bfd_reloc_val == code)
893 return & elf_metag_howto_table [metag_reloc_map[i].metag_reloc_val];
894
895 return NULL;
896 }
897
898 static reloc_howto_type *
899 metag_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
900 const char *r_name)
901 {
902 unsigned int i;
903
904 for (i = 0; i < sizeof (elf_metag_howto_table) / sizeof (elf_metag_howto_table[0]); i++)
905 if (elf_metag_howto_table[i].name != NULL
906 && strcasecmp (elf_metag_howto_table[i].name, r_name) == 0)
907 return &elf_metag_howto_table[i];
908
909 return NULL;
910 }
911
912 /* Various hash macros and functions. */
913 #define metag_link_hash_table(p) \
914 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
915 == METAG_ELF_DATA ? ((struct elf_metag_link_hash_table *) ((p)->hash)) : NULL)
916
917 #define metag_elf_hash_entry(ent) \
918 ((struct elf_metag_link_hash_entry *)(ent))
919
920 #define metag_stub_hash_entry(ent) \
921 ((struct elf_metag_stub_hash_entry *)(ent))
922
923 #define metag_stub_hash_lookup(table, string, create, copy) \
924 ((struct elf_metag_stub_hash_entry *) \
925 bfd_hash_lookup ((table), (string), (create), (copy)))
926
927 #define metag_elf_local_got_tls_type(abfd) \
928 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info)))
929
930 /* Assorted hash table functions. */
931
932 /* Initialize an entry in the stub hash table. */
933
934 static struct bfd_hash_entry *
935 stub_hash_newfunc (struct bfd_hash_entry *entry,
936 struct bfd_hash_table *table,
937 const char *string)
938 {
939 /* Allocate the structure if it has not already been allocated by a
940 subclass. */
941 if (entry == NULL)
942 {
943 entry = bfd_hash_allocate (table,
944 sizeof (struct elf_metag_stub_hash_entry));
945 if (entry == NULL)
946 return entry;
947 }
948
949 /* Call the allocation method of the superclass. */
950 entry = bfd_hash_newfunc (entry, table, string);
951 if (entry != NULL)
952 {
953 struct elf_metag_stub_hash_entry *hsh;
954
955 /* Initialize the local fields. */
956 hsh = (struct elf_metag_stub_hash_entry *) entry;
957 hsh->stub_sec = NULL;
958 hsh->stub_offset = 0;
959 hsh->target_value = 0;
960 hsh->target_section = NULL;
961 hsh->stub_type = metag_stub_long_branch;
962 hsh->hh = NULL;
963 hsh->id_sec = NULL;
964 }
965
966 return entry;
967 }
968
969 /* Initialize an entry in the link hash table. */
970
971 static struct bfd_hash_entry *
972 metag_link_hash_newfunc (struct bfd_hash_entry *entry,
973 struct bfd_hash_table *table,
974 const char *string)
975 {
976 /* Allocate the structure if it has not already been allocated by a
977 subclass. */
978 if (entry == NULL)
979 {
980 entry = bfd_hash_allocate (table,
981 sizeof (struct elf_metag_link_hash_entry));
982 if (entry == NULL)
983 return entry;
984 }
985
986 /* Call the allocation method of the superclass. */
987 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
988 if (entry != NULL)
989 {
990 struct elf_metag_link_hash_entry *hh;
991
992 /* Initialize the local fields. */
993 hh = (struct elf_metag_link_hash_entry *) entry;
994 hh->hsh_cache = NULL;
995 hh->dyn_relocs = NULL;
996 hh->tls_type = GOT_UNKNOWN;
997 }
998
999 return entry;
1000 }
1001
1002 /* Free the derived linker hash table. */
1003
1004 static void
1005 elf_metag_link_hash_table_free (bfd *obfd)
1006 {
1007 struct elf_metag_link_hash_table *htab
1008 = (struct elf_metag_link_hash_table *) obfd->link.hash;
1009
1010 bfd_hash_table_free (&htab->bstab);
1011 _bfd_elf_link_hash_table_free (obfd);
1012 }
1013
1014 /* Create the derived linker hash table. The Meta ELF port uses the derived
1015 hash table to keep information specific to the Meta ELF linker (without
1016 using static variables). */
1017
1018 static struct bfd_link_hash_table *
1019 elf_metag_link_hash_table_create (bfd *abfd)
1020 {
1021 struct elf_metag_link_hash_table *htab;
1022 bfd_size_type amt = sizeof (*htab);
1023
1024 htab = bfd_zmalloc (amt);
1025 if (htab == NULL)
1026 return NULL;
1027
1028 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
1029 metag_link_hash_newfunc,
1030 sizeof (struct elf_metag_link_hash_entry),
1031 METAG_ELF_DATA))
1032 {
1033 free (htab);
1034 return NULL;
1035 }
1036
1037 /* Init the stub hash table too. */
1038 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
1039 sizeof (struct elf_metag_stub_hash_entry)))
1040 {
1041 _bfd_elf_link_hash_table_free (abfd);
1042 return NULL;
1043 }
1044 htab->etab.root.hash_table_free = elf_metag_link_hash_table_free;
1045
1046 return &htab->etab.root;
1047 }
1048
1049 /* Section name for stubs is the associated section name plus this
1050 string. */
1051 #define STUB_SUFFIX ".stub"
1052
1053 /* Build a name for an entry in the stub hash table. */
1054
1055 static char *
1056 metag_stub_name (const asection *input_section,
1057 const asection *sym_sec,
1058 const struct elf_metag_link_hash_entry *hh,
1059 const Elf_Internal_Rela *rel)
1060 {
1061 char *stub_name;
1062 bfd_size_type len;
1063
1064 if (hh)
1065 {
1066 len = 8 + 1 + strlen (hh->eh.root.root.string) + 1 + 8 + 1;
1067 stub_name = bfd_malloc (len);
1068 if (stub_name != NULL)
1069 {
1070 sprintf (stub_name, "%08x_%s+%x",
1071 input_section->id & 0xffffffff,
1072 hh->eh.root.root.string,
1073 (int) rel->r_addend & 0xffffffff);
1074 }
1075 }
1076 else
1077 {
1078 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
1079 stub_name = bfd_malloc (len);
1080 if (stub_name != NULL)
1081 {
1082 sprintf (stub_name, "%08x_%x:%x+%x",
1083 input_section->id & 0xffffffff,
1084 sym_sec->id & 0xffffffff,
1085 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
1086 (int) rel->r_addend & 0xffffffff);
1087 }
1088 }
1089 return stub_name;
1090 }
1091
1092 /* Look up an entry in the stub hash. Stub entries are cached because
1093 creating the stub name takes a bit of time. */
1094
1095 static struct elf_metag_stub_hash_entry *
1096 metag_get_stub_entry (const asection *input_section,
1097 const asection *sym_sec,
1098 struct elf_metag_link_hash_entry *hh,
1099 const Elf_Internal_Rela *rel,
1100 struct elf_metag_link_hash_table *htab)
1101 {
1102 struct elf_metag_stub_hash_entry *hsh;
1103 const asection *id_sec;
1104
1105 /* If this input section is part of a group of sections sharing one
1106 stub section, then use the id of the first section in the group.
1107 Stub names need to include a section id, as there may well be
1108 more than one stub used to reach say, printf, and we need to
1109 distinguish between them. */
1110 id_sec = htab->stub_group[input_section->id].link_sec;
1111
1112 if (hh != NULL && hh->hsh_cache != NULL
1113 && hh->hsh_cache->hh == hh
1114 && hh->hsh_cache->id_sec == id_sec)
1115 {
1116 hsh = hh->hsh_cache;
1117 }
1118 else
1119 {
1120 char *stub_name;
1121
1122 stub_name = metag_stub_name (id_sec, sym_sec, hh, rel);
1123 if (stub_name == NULL)
1124 return NULL;
1125
1126 hsh = metag_stub_hash_lookup (&htab->bstab,
1127 stub_name, FALSE, FALSE);
1128
1129 if (hh != NULL)
1130 hh->hsh_cache = hsh;
1131
1132 free (stub_name);
1133 }
1134
1135 return hsh;
1136 }
1137
1138 /* Add a new stub entry to the stub hash. Not all fields of the new
1139 stub entry are initialised. */
1140
1141 static struct elf_metag_stub_hash_entry *
1142 metag_add_stub (const char *stub_name,
1143 asection *section,
1144 struct elf_metag_link_hash_table *htab)
1145 {
1146 asection *link_sec;
1147 asection *stub_sec;
1148 struct elf_metag_stub_hash_entry *hsh;
1149
1150 link_sec = htab->stub_group[section->id].link_sec;
1151 stub_sec = htab->stub_group[section->id].stub_sec;
1152 if (stub_sec == NULL)
1153 {
1154 stub_sec = htab->stub_group[link_sec->id].stub_sec;
1155 if (stub_sec == NULL)
1156 {
1157 size_t namelen;
1158 bfd_size_type len;
1159 char *s_name;
1160
1161 namelen = strlen (link_sec->name);
1162 len = namelen + sizeof (STUB_SUFFIX);
1163 s_name = bfd_alloc (htab->stub_bfd, len);
1164 if (s_name == NULL)
1165 return NULL;
1166
1167 memcpy (s_name, link_sec->name, namelen);
1168 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
1169
1170 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
1171 if (stub_sec == NULL)
1172 return NULL;
1173 htab->stub_group[link_sec->id].stub_sec = stub_sec;
1174 }
1175 htab->stub_group[section->id].stub_sec = stub_sec;
1176 }
1177
1178 /* Enter this entry into the linker stub hash table. */
1179 hsh = metag_stub_hash_lookup (&htab->bstab, stub_name,
1180 TRUE, FALSE);
1181 if (hsh == NULL)
1182 {
1183 /* xgettext:c-format */
1184 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
1185 section->owner, stub_name);
1186 return NULL;
1187 }
1188
1189 hsh->stub_sec = stub_sec;
1190 hsh->stub_offset = 0;
1191 hsh->id_sec = link_sec;
1192 return hsh;
1193 }
1194
1195 /* Check a signed integer value can be represented in the given number
1196 of bits. */
1197
1198 static bfd_boolean
1199 within_signed_range (int value, unsigned int bits)
1200 {
1201 int min_val = -(1 << (bits - 1));
1202 int max_val = (1 << (bits - 1)) - 1;
1203 return (value <= max_val) && (value >= min_val);
1204 }
1205
1206 /* Perform a relocation as part of a final link. */
1207
1208 static bfd_reloc_status_type
1209 metag_final_link_relocate (reloc_howto_type *howto,
1210 bfd *input_bfd,
1211 asection *input_section,
1212 bfd_byte *contents,
1213 Elf_Internal_Rela *rel,
1214 bfd_vma relocation,
1215 struct elf_metag_link_hash_entry *hh,
1216 struct elf_metag_link_hash_table *htab,
1217 asection *sym_sec)
1218 {
1219 bfd_reloc_status_type r = bfd_reloc_ok;
1220 bfd_byte *hit_data = contents + rel->r_offset;
1221 int opcode, op_shift, op_extended, l1, l2;
1222 bfd_signed_vma srel, addend = rel->r_addend;
1223 struct elf_metag_stub_hash_entry *hsh = NULL;
1224 bfd_vma location;
1225
1226 /* Find out where we are and where we're going. */
1227 location = (rel->r_offset +
1228 input_section->output_offset +
1229 input_section->output_section->vma);
1230
1231 switch (howto->type)
1232 {
1233 case R_METAG_RELBRANCH:
1234 case R_METAG_RELBRANCH_PLT:
1235 /* Make it a pc relative offset. */
1236 relocation -= location;
1237 break;
1238 case R_METAG_TLS_GD:
1239 case R_METAG_TLS_IE:
1240 relocation -= elf_gp (input_section->output_section->owner);
1241 break;
1242 default:
1243 break;
1244 }
1245
1246 switch (howto->type)
1247 {
1248 case R_METAG_RELBRANCH_PLT:
1249 case R_METAG_RELBRANCH:
1250 opcode = bfd_get_32 (input_bfd, hit_data);
1251
1252 srel = (bfd_signed_vma) relocation;
1253 srel += addend;
1254
1255 /* If the branch is out of reach, then redirect the
1256 call to the local stub for this function. */
1257 if (srel > ((1 << (BRANCH_BITS + 1)) - 1) ||
1258 (srel < - (1 << (BRANCH_BITS + 1))))
1259 {
1260 if (sym_sec == NULL)
1261 break;
1262
1263 hsh = metag_get_stub_entry (input_section, sym_sec,
1264 hh, rel, htab);
1265 if (hsh == NULL)
1266 return bfd_reloc_undefined;
1267
1268 /* Munge up the value and addend so that we call the stub
1269 rather than the procedure directly. */
1270 srel = (hsh->stub_offset
1271 + hsh->stub_sec->output_offset
1272 + hsh->stub_sec->output_section->vma);
1273 srel -= location;
1274 }
1275
1276 srel = srel >> 2;
1277
1278 if (!within_signed_range (srel, BRANCH_BITS))
1279 {
1280 if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1281 srel = 0;
1282 else
1283 return bfd_reloc_overflow;
1284 }
1285
1286 opcode &= ~(0x7ffff << 5);
1287 opcode |= ((srel & 0x7ffff) << 5);
1288
1289 bfd_put_32 (input_bfd, opcode, hit_data);
1290 break;
1291 case R_METAG_GETSETOFF:
1292 case R_METAG_GETSET_GOT:
1293 case R_METAG_GETSET_GOTOFF:
1294 opcode = bfd_get_32 (input_bfd, hit_data);
1295
1296 srel = (bfd_signed_vma) relocation;
1297 srel += addend;
1298
1299 /* Is this a standard or extended GET/SET? */
1300 if ((opcode & 0xf0000000) == 0xa0000000)
1301 {
1302 /* Extended GET/SET. */
1303 l1 = opcode & 0x2;
1304 l2 = opcode & 0x4;
1305 op_extended = 1;
1306 }
1307 else
1308 {
1309 /* Standard GET/SET. */
1310 l1 = opcode & 0x01000000;
1311 l2 = opcode & 0x04000000;
1312 op_extended = 0;
1313 }
1314
1315 /* Calculate the width of the GET/SET and how much we need to
1316 shift the result by. */
1317 if (l2)
1318 if (l1)
1319 op_shift = 3;
1320 else
1321 op_shift = 2;
1322 else
1323 if (l1)
1324 op_shift = 1;
1325 else
1326 op_shift = 0;
1327
1328 /* GET/SET offsets are scaled by the width of the transfer. */
1329 srel = srel >> op_shift;
1330
1331 /* Extended GET/SET has signed 12 bits of offset, standard has
1332 signed 6 bits. */
1333 if (op_extended)
1334 {
1335 if (!within_signed_range (srel, 12))
1336 {
1337 if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1338 srel = 0;
1339 else
1340 return bfd_reloc_overflow;
1341 }
1342 opcode &= ~(0xfff << 7);
1343 opcode |= ((srel & 0xfff) << 7);
1344 }
1345 else
1346 {
1347 if (!within_signed_range (srel, 5))
1348 {
1349 if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1350 srel = 0;
1351 else
1352 return bfd_reloc_overflow;
1353 }
1354 opcode &= ~(0x3f << 8);
1355 opcode |= ((srel & 0x3f) << 8);
1356 }
1357
1358 bfd_put_32 (input_bfd, opcode, hit_data);
1359 break;
1360 case R_METAG_TLS_GD:
1361 case R_METAG_TLS_LDM:
1362 opcode = bfd_get_32 (input_bfd, hit_data);
1363
1364 if ((bfd_signed_vma)relocation < 0)
1365 {
1366 /* sign extend immediate */
1367 if ((opcode & 0xf2000001) == 0x02000000)
1368 {
1369 /* ADD De.e,Dx.r,#I16 */
1370 /* set SE bit */
1371 opcode |= (1 << 1);
1372 } else
1373 return bfd_reloc_overflow;
1374 }
1375
1376 bfd_put_32 (input_bfd, opcode, hit_data);
1377
1378 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1379 contents, rel->r_offset,
1380 relocation, rel->r_addend);
1381 break;
1382 default:
1383 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1384 contents, rel->r_offset,
1385 relocation, rel->r_addend);
1386 }
1387
1388 return r;
1389 }
1390
1391 /* This is defined because R_METAG_NONE != 0...
1392 See RELOC_AGAINST_DISCARDED_SECTION for details. */
1393 #define METAG_RELOC_AGAINST_DISCARDED_SECTION(info, input_bfd, input_section, \
1394 rel, relend, howto, contents) \
1395 { \
1396 _bfd_clear_contents (howto, input_bfd, input_section, \
1397 contents + rel->r_offset); \
1398 \
1399 if (bfd_link_relocatable (info) \
1400 && (input_section->flags & SEC_DEBUGGING)) \
1401 { \
1402 /* Only remove relocations in debug sections since other \
1403 sections may require relocations. */ \
1404 Elf_Internal_Shdr *rel_hdr; \
1405 \
1406 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); \
1407 \
1408 /* Avoid empty output section. */ \
1409 if (rel_hdr->sh_size > rel_hdr->sh_entsize) \
1410 { \
1411 rel_hdr->sh_size -= rel_hdr->sh_entsize; \
1412 rel_hdr = _bfd_elf_single_rel_hdr (input_section); \
1413 rel_hdr->sh_size -= rel_hdr->sh_entsize; \
1414 \
1415 memmove (rel, rel + 1, (relend - rel) * sizeof (*rel)); \
1416 \
1417 input_section->reloc_count--; \
1418 relend--; \
1419 rel--; \
1420 continue; \
1421 } \
1422 } \
1423 \
1424 rel->r_info = R_METAG_NONE; \
1425 rel->r_addend = 0; \
1426 continue; \
1427 }
1428
1429 /* Relocate a META ELF section.
1430
1431 The RELOCATE_SECTION function is called by the new ELF backend linker
1432 to handle the relocations for a section.
1433
1434 The relocs are always passed as Rela structures; if the section
1435 actually uses Rel structures, the r_addend field will always be
1436 zero.
1437
1438 This function is responsible for adjusting the section contents as
1439 necessary, and (if using Rela relocs and generating a relocatable
1440 output file) adjusting the reloc addend as necessary.
1441
1442 This function does not have to worry about setting the reloc
1443 address or the reloc symbol index.
1444
1445 LOCAL_SYMS is a pointer to the swapped in local symbols.
1446
1447 LOCAL_SECTIONS is an array giving the section in the input file
1448 corresponding to the st_shndx field of each local symbol.
1449
1450 The global hash table entry for the global symbols can be found
1451 via elf_sym_hashes (input_bfd).
1452
1453 When generating relocatable output, this function must handle
1454 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1455 going to be the section symbol corresponding to the output
1456 section, which means that the addend must be adjusted
1457 accordingly. */
1458
1459 static bfd_boolean
1460 elf_metag_relocate_section (bfd *output_bfd,
1461 struct bfd_link_info *info,
1462 bfd *input_bfd,
1463 asection *input_section,
1464 bfd_byte *contents,
1465 Elf_Internal_Rela *relocs,
1466 Elf_Internal_Sym *local_syms,
1467 asection **local_sections)
1468 {
1469 bfd_vma *local_got_offsets;
1470 Elf_Internal_Shdr *symtab_hdr;
1471 struct elf_link_hash_entry **eh_syms;
1472 struct elf_metag_link_hash_table *htab;
1473 Elf_Internal_Rela *rel;
1474 Elf_Internal_Rela *relend;
1475 asection *sreloc;
1476
1477 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1478 eh_syms = elf_sym_hashes (input_bfd);
1479 relend = relocs + input_section->reloc_count;
1480
1481 htab = metag_link_hash_table (info);
1482 local_got_offsets = elf_local_got_offsets (input_bfd);
1483
1484 sreloc = NULL;
1485
1486 for (rel = relocs; rel < relend; rel ++)
1487 {
1488 reloc_howto_type *howto;
1489 unsigned long r_symndx;
1490 Elf_Internal_Sym *sym;
1491 asection *sec;
1492 struct elf_metag_link_hash_entry *hh;
1493 bfd_vma relocation;
1494 bfd_reloc_status_type r;
1495 const char *name;
1496 int r_type;
1497
1498 r_type = ELF32_R_TYPE (rel->r_info);
1499
1500 if (r_type == R_METAG_GNU_VTINHERIT
1501 || r_type == R_METAG_GNU_VTENTRY
1502 || r_type == R_METAG_NONE)
1503 continue;
1504
1505 r_symndx = ELF32_R_SYM (rel->r_info);
1506
1507 howto = elf_metag_howto_table + ELF32_R_TYPE (rel->r_info);
1508 hh = NULL;
1509 sym = NULL;
1510 sec = NULL;
1511
1512 if (r_symndx < symtab_hdr->sh_info)
1513 {
1514 sym = local_syms + r_symndx;
1515 sec = local_sections [r_symndx];
1516 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1517
1518 name = bfd_elf_string_from_elf_section
1519 (input_bfd, symtab_hdr->sh_link, sym->st_name);
1520 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1521 }
1522 else
1523 {
1524 struct elf_link_hash_entry *eh;
1525 bfd_boolean unresolved_reloc, warned, ignored;
1526
1527 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1528 r_symndx, symtab_hdr, eh_syms,
1529 eh, sec, relocation,
1530 unresolved_reloc, warned, ignored);
1531
1532 name = eh->root.root.string;
1533 hh = (struct elf_metag_link_hash_entry *) eh;
1534 }
1535
1536 if (sec != NULL && discarded_section (sec))
1537 METAG_RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1538 rel, relend, howto, contents);
1539
1540 if (bfd_link_relocatable (info))
1541 continue;
1542
1543 switch (r_type)
1544 {
1545 case R_METAG_ADDR32:
1546 case R_METAG_RELBRANCH:
1547 if ((input_section->flags & SEC_ALLOC) == 0)
1548 break;
1549
1550 if ((bfd_link_pic (info)
1551 && r_symndx != STN_UNDEF
1552 && (input_section->flags & SEC_ALLOC) != 0
1553 && (r_type != R_METAG_RELBRANCH
1554 || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
1555 || (!bfd_link_pic (info)
1556 && hh != NULL
1557 && hh->eh.dynindx != -1
1558 && !hh->eh.non_got_ref
1559 && ((hh->eh.def_dynamic
1560 && !hh->eh.def_regular)
1561 || hh->eh.root.type == bfd_link_hash_undefweak
1562 || hh->eh.root.type == bfd_link_hash_undefined)))
1563 {
1564 Elf_Internal_Rela outrel;
1565 bfd_boolean skip, relocate;
1566 bfd_byte *loc;
1567
1568 /* When generating a shared object, these relocations
1569 are copied into the output file to be resolved at run
1570 time. */
1571
1572 sreloc = elf_section_data (input_section)->sreloc;
1573 BFD_ASSERT (sreloc != NULL);
1574
1575 skip = FALSE;
1576 relocate = FALSE;
1577
1578 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
1579 info,
1580 input_section,
1581 rel->r_offset);
1582 if (outrel.r_offset == (bfd_vma) -1)
1583 skip = TRUE;
1584 else if (outrel.r_offset == (bfd_vma) -2)
1585 skip = TRUE, relocate = TRUE;
1586 outrel.r_offset += (input_section->output_section->vma
1587 + input_section->output_offset);
1588
1589 if (skip)
1590 {
1591 memset (&outrel, 0, sizeof outrel);
1592 outrel.r_info = ELF32_R_INFO (0, R_METAG_NONE);
1593 }
1594 else if (r_type == R_METAG_RELBRANCH)
1595 {
1596 BFD_ASSERT (hh != NULL && hh->eh.dynindx != -1);
1597 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
1598 outrel.r_addend = rel->r_addend;
1599 }
1600 else
1601 {
1602 /* h->dynindx may be -1 if this symbol was marked to
1603 become local. */
1604 if (hh == NULL
1605 || ((info->symbolic || hh->eh.dynindx == -1)
1606 && hh->eh.def_regular))
1607 {
1608 relocate = TRUE;
1609 outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
1610 outrel.r_addend = relocation + rel->r_addend;
1611 }
1612 else
1613 {
1614 BFD_ASSERT (hh->eh.dynindx != -1);
1615 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
1616 outrel.r_addend = rel->r_addend;
1617 }
1618 }
1619
1620 loc = sreloc->contents;
1621 loc += sreloc->reloc_count * sizeof(Elf32_External_Rela);
1622 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1623 ++sreloc->reloc_count;
1624
1625 /* If this reloc is against an external symbol, we do
1626 not want to fiddle with the addend. Otherwise, we
1627 need to include the symbol value so that it becomes
1628 an addend for the dynamic reloc. */
1629 if (! relocate)
1630 continue;
1631 }
1632 break;
1633
1634 case R_METAG_RELBRANCH_PLT:
1635 /* Relocation is to the entry for this symbol in the
1636 procedure linkage table. */
1637
1638 if (hh == NULL)
1639 break;
1640
1641 if (hh->eh.forced_local)
1642 break;
1643
1644 if (hh->eh.plt.offset == (bfd_vma) -1 || htab->etab.splt == NULL)
1645 {
1646 /* We didn't make a PLT entry for this symbol. This
1647 happens when statically linking PIC code, or when
1648 using -Bsymbolic. */
1649 break;
1650 }
1651
1652 relocation = (htab->etab.splt->output_section->vma
1653 + htab->etab.splt->output_offset
1654 + hh->eh.plt.offset);
1655 break;
1656 case R_METAG_HI16_GOTPC:
1657 case R_METAG_LO16_GOTPC:
1658 BFD_ASSERT (htab->etab.sgot != NULL);
1659
1660 relocation = (htab->etab.sgot->output_section->vma +
1661 htab->etab.sgot->output_offset);
1662 relocation += GOT_REG_OFFSET;
1663 relocation -= (input_section->output_section->vma
1664 + input_section->output_offset
1665 + rel->r_offset);
1666 break;
1667 case R_METAG_HI16_GOTOFF:
1668 case R_METAG_LO16_GOTOFF:
1669 case R_METAG_GETSET_GOTOFF:
1670 BFD_ASSERT (htab->etab.sgot != NULL);
1671
1672 relocation -= (htab->etab.sgot->output_section->vma +
1673 htab->etab.sgot->output_offset);
1674 relocation -= GOT_REG_OFFSET;
1675 break;
1676 case R_METAG_GETSET_GOT:
1677 {
1678 bfd_vma off;
1679 bfd_boolean do_got = 0;
1680
1681 /* Relocation is to the entry for this symbol in the
1682 global offset table. */
1683 if (hh != NULL)
1684 {
1685 bfd_boolean dyn;
1686
1687 off = hh->eh.got.offset;
1688 dyn = htab->etab.dynamic_sections_created;
1689 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1690 bfd_link_pic (info),
1691 &hh->eh))
1692 {
1693 /* If we aren't going to call finish_dynamic_symbol,
1694 then we need to handle initialisation of the .got
1695 entry and create needed relocs here. Since the
1696 offset must always be a multiple of 4, we use the
1697 least significant bit to record whether we have
1698 initialised it already. */
1699 if ((off & 1) != 0)
1700 off &= ~1;
1701 else
1702 {
1703 hh->eh.got.offset |= 1;
1704 do_got = 1;
1705 }
1706 }
1707 }
1708 else
1709 {
1710 /* Local symbol case. */
1711 if (local_got_offsets == NULL)
1712 abort ();
1713
1714 off = local_got_offsets[r_symndx];
1715
1716 /* The offset must always be a multiple of 4. We use
1717 the least significant bit to record whether we have
1718 already generated the necessary reloc. */
1719 if ((off & 1) != 0)
1720 off &= ~1;
1721 else
1722 {
1723 local_got_offsets[r_symndx] |= 1;
1724 do_got = 1;
1725 }
1726 }
1727
1728 if (do_got)
1729 {
1730 if (bfd_link_pic (info))
1731 {
1732 /* Output a dynamic relocation for this GOT entry.
1733 In this case it is relative to the base of the
1734 object because the symbol index is zero. */
1735 Elf_Internal_Rela outrel;
1736 bfd_byte *loc;
1737 asection *s = htab->etab.srelgot;
1738
1739 outrel.r_offset = (off
1740 + htab->etab.sgot->output_offset
1741 + htab->etab.sgot->output_section->vma);
1742 outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
1743 outrel.r_addend = relocation;
1744 loc = s->contents;
1745 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1746 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1747 }
1748 else
1749 bfd_put_32 (output_bfd, relocation,
1750 htab->etab.sgot->contents + off);
1751 }
1752
1753 if (off >= (bfd_vma) -2)
1754 abort ();
1755
1756 relocation = off - GOT_REG_OFFSET;
1757 }
1758 break;
1759 case R_METAG_TLS_GD:
1760 case R_METAG_TLS_IE:
1761 {
1762 /* XXXMJF There is room here for optimisations. For example
1763 converting from GD->IE, etc. */
1764 bfd_vma off;
1765 int indx;
1766 char tls_type;
1767
1768 if (htab->etab.sgot == NULL)
1769 abort();
1770
1771 indx = 0;
1772 if (hh != NULL)
1773 {
1774 bfd_boolean dyn;
1775 dyn = htab->etab.dynamic_sections_created;
1776
1777 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1778 bfd_link_pic (info),
1779 &hh->eh)
1780 && (!bfd_link_pic (info)
1781 || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
1782 {
1783 indx = hh->eh.dynindx;
1784 }
1785 off = hh->eh.got.offset;
1786 tls_type = hh->tls_type;
1787 }
1788 else
1789 {
1790 /* Local symbol case. */
1791 if (local_got_offsets == NULL)
1792 abort ();
1793
1794 off = local_got_offsets[r_symndx];
1795 tls_type = metag_elf_local_got_tls_type (input_bfd) [r_symndx];
1796 }
1797
1798 if (tls_type == GOT_UNKNOWN)
1799 abort ();
1800
1801 if ((off & 1) != 0)
1802 off &= ~1;
1803 else
1804 {
1805 bfd_boolean need_relocs = FALSE;
1806 Elf_Internal_Rela outrel;
1807 bfd_byte *loc = NULL;
1808 int cur_off = off;
1809
1810 /* The GOT entries have not been initialized yet. Do it
1811 now, and emit any relocations. If both an IE GOT and a
1812 GD GOT are necessary, we emit the GD first. */
1813
1814 if ((bfd_link_pic (info) || indx != 0)
1815 && (hh == NULL
1816 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
1817 || hh->eh.root.type != bfd_link_hash_undefweak))
1818 {
1819 need_relocs = TRUE;
1820 loc = htab->etab.srelgot->contents;
1821 /* FIXME (CAO): Should this be reloc_count++ ? */
1822 loc += htab->etab.srelgot->reloc_count * sizeof (Elf32_External_Rela);
1823 }
1824
1825 if (tls_type & GOT_TLS_GD)
1826 {
1827 if (need_relocs)
1828 {
1829 outrel.r_offset = (cur_off
1830 + htab->etab.sgot->output_section->vma
1831 + htab->etab.sgot->output_offset);
1832 outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_DTPMOD);
1833 outrel.r_addend = 0;
1834 bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + cur_off);
1835
1836 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1837 htab->etab.srelgot->reloc_count++;
1838 loc += sizeof (Elf32_External_Rela);
1839
1840 if (indx == 0)
1841 bfd_put_32 (output_bfd, 0,
1842 htab->etab.sgot->contents + cur_off + 4);
1843 else
1844 {
1845 bfd_put_32 (output_bfd, 0,
1846 htab->etab.sgot->contents + cur_off + 4);
1847 outrel.r_info = ELF32_R_INFO (indx,
1848 R_METAG_TLS_DTPOFF);
1849 outrel.r_offset += 4;
1850 bfd_elf32_swap_reloca_out (output_bfd,
1851 &outrel, loc);
1852 htab->etab.srelgot->reloc_count++;
1853 loc += sizeof (Elf32_External_Rela);
1854 }
1855 }
1856 else
1857 {
1858 /* We don't support changing the TLS model. */
1859 /* PR 20675 */
1860 if (bfd_link_pic (info))
1861 _bfd_error_handler (_("%pB(%pA): multiple TLS models are not supported"),
1862 input_bfd, input_section);
1863 else
1864 _bfd_error_handler (_("%pB(%pA): shared library symbol %s encountered whilst performing a static link"),
1865 input_bfd, input_section, name);
1866 return FALSE;
1867 }
1868
1869 cur_off += 8;
1870 }
1871
1872 if (tls_type & GOT_TLS_IE)
1873 {
1874 if (need_relocs)
1875 {
1876 outrel.r_offset = (cur_off
1877 + htab->etab.sgot->output_section->vma
1878 + htab->etab.sgot->output_offset);
1879 outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_TPOFF);
1880
1881 if (indx == 0)
1882 outrel.r_addend = relocation - dtpoff_base (info);
1883 else
1884 outrel.r_addend = 0;
1885
1886 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1887 htab->etab.srelgot->reloc_count++;
1888 loc += sizeof (Elf32_External_Rela);
1889 }
1890 else
1891 bfd_put_32 (output_bfd, tpoff (info, relocation),
1892 htab->etab.sgot->contents + cur_off);
1893
1894 cur_off += 4;
1895 }
1896
1897 if (hh != NULL)
1898 hh->eh.got.offset |= 1;
1899 else
1900 local_got_offsets[r_symndx] |= 1;
1901 }
1902
1903 /* Add the base of the GOT to the relocation value. */
1904 relocation = off - GOT_REG_OFFSET;
1905
1906 break;
1907 }
1908
1909 case R_METAG_TLS_IENONPIC_HI16:
1910 case R_METAG_TLS_IENONPIC_LO16:
1911 case R_METAG_TLS_LE_HI16:
1912 case R_METAG_TLS_LE_LO16:
1913 if (bfd_link_pic (info))
1914 {
1915 _bfd_error_handler
1916 /* xgettext:c-format */
1917 (_("%pB(%pA+%#" PRIx64 "): "
1918 "%s relocation not permitted in shared object"),
1919 input_bfd, input_section, (uint64_t) rel->r_offset,
1920 howto->name);
1921 return FALSE;
1922 }
1923 else
1924 relocation = tpoff (info, relocation);
1925 break;
1926 case R_METAG_TLS_LDO_HI16:
1927 case R_METAG_TLS_LDO_LO16:
1928 if (! bfd_link_pic (info))
1929 relocation = tpoff (info, relocation);
1930 else
1931 relocation -= dtpoff_base (info);
1932 break;
1933 case R_METAG_TLS_LDM:
1934 {
1935 bfd_vma off;
1936
1937 if (htab->etab.sgot == NULL)
1938 abort();
1939 off = htab->tls_ldm_got.offset;
1940 if (off & 1)
1941 off &= ~1;
1942 else
1943 {
1944 Elf_Internal_Rela outrel;
1945 bfd_byte *loc;
1946
1947 outrel.r_offset = (off
1948 + htab->etab.sgot->output_section->vma
1949 + htab->etab.sgot->output_offset);
1950
1951 outrel.r_addend = 0;
1952 outrel.r_info = ELF32_R_INFO (0, R_METAG_TLS_DTPMOD);
1953 loc = htab->etab.srelgot->contents;
1954 loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1955 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1956 htab->tls_ldm_got.offset |= 1;
1957 }
1958
1959 relocation = off - GOT_REG_OFFSET;
1960 break;
1961 }
1962 default:
1963 break;
1964 }
1965
1966 r = metag_final_link_relocate (howto, input_bfd, input_section,
1967 contents, rel, relocation, hh, htab,
1968 sec);
1969
1970 if (r != bfd_reloc_ok)
1971 {
1972 const char * msg = (const char *) NULL;
1973
1974 switch (r)
1975 {
1976 case bfd_reloc_overflow:
1977 (*info->callbacks->reloc_overflow)
1978 (info, (hh ? &hh->eh.root : NULL), name, howto->name,
1979 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1980 break;
1981
1982 case bfd_reloc_undefined:
1983 (*info->callbacks->undefined_symbol)
1984 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1985 break;
1986
1987 case bfd_reloc_outofrange:
1988 msg = _("internal error: out of range error");
1989 break;
1990
1991 case bfd_reloc_notsupported:
1992 msg = _("internal error: unsupported relocation error");
1993 break;
1994
1995 case bfd_reloc_dangerous:
1996 msg = _("internal error: dangerous relocation");
1997 break;
1998
1999 default:
2000 msg = _("internal error: unknown error");
2001 break;
2002 }
2003
2004 if (msg)
2005 (*info->callbacks->warning) (info, msg, name, input_bfd,
2006 input_section, rel->r_offset);
2007 }
2008 }
2009
2010 return TRUE;
2011 }
2012
2013 /* Create the .plt and .got sections, and set up our hash table
2014 short-cuts to various dynamic sections. */
2015
2016 static bfd_boolean
2017 elf_metag_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2018 {
2019 struct elf_metag_link_hash_table *htab;
2020 struct elf_link_hash_entry *eh;
2021 struct bfd_link_hash_entry *bh;
2022 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2023
2024 /* Don't try to create the .plt and .got twice. */
2025 htab = metag_link_hash_table (info);
2026 if (htab->etab.splt != NULL)
2027 return TRUE;
2028
2029 /* Call the generic code to do most of the work. */
2030 if (! _bfd_elf_create_dynamic_sections (abfd, info))
2031 return FALSE;
2032
2033 /* The header goes at the start of the dynamic .got section, which
2034 is placed after the dynamic .got.plt section. ie. The header is
2035 not necessarily at the start of the output .got section. */
2036 htab->etab.sgot->size += 12;
2037
2038 /* Define the symbol __GLOBAL_OFFSET_TABLE__ on the header. */
2039 bh = NULL;
2040 if (!(_bfd_generic_link_add_one_symbol
2041 (info, abfd, "__GLOBAL_OFFSET_TABLE__", BSF_GLOBAL, htab->etab.sgot,
2042 (bfd_vma) 0, NULL, FALSE, bed->collect, &bh)))
2043 return FALSE;
2044 eh = (struct elf_link_hash_entry *) bh;
2045 eh->def_regular = 1;
2046 eh->type = STT_OBJECT;
2047 eh->other = STV_HIDDEN;
2048
2049 if (! bfd_link_executable (info)
2050 && ! bfd_elf_link_record_dynamic_symbol (info, eh))
2051 return FALSE;
2052
2053 htab->etab.hgot = eh;
2054
2055 return TRUE;
2056 }
2057
2058 /* Look through the relocs for a section during the first phase, and
2059 calculate needed space in the global offset table, procedure linkage
2060 table, and dynamic reloc sections. At this point we haven't
2061 necessarily read all the input files. */
2062
2063 static bfd_boolean
2064 elf_metag_check_relocs (bfd *abfd,
2065 struct bfd_link_info *info,
2066 asection *sec,
2067 const Elf_Internal_Rela *relocs)
2068 {
2069 Elf_Internal_Shdr *symtab_hdr;
2070 struct elf_link_hash_entry **eh_syms;
2071 const Elf_Internal_Rela *rel;
2072 const Elf_Internal_Rela *rel_end;
2073 struct elf_metag_link_hash_table *htab;
2074 asection *sreloc;
2075 bfd *dynobj;
2076 int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
2077
2078 if (bfd_link_relocatable (info))
2079 return TRUE;
2080
2081 htab = metag_link_hash_table (info);
2082 dynobj = htab->etab.dynobj;
2083 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2084 eh_syms = elf_sym_hashes (abfd);
2085 sreloc = NULL;
2086
2087 if (htab == NULL)
2088 return FALSE;
2089
2090 rel_end = relocs + sec->reloc_count;
2091 for (rel = relocs; rel < rel_end; rel++)
2092 {
2093 int r_type;
2094 struct elf_metag_link_hash_entry *hh;
2095 Elf_Internal_Sym *isym;
2096 unsigned long r_symndx;
2097
2098 r_symndx = ELF32_R_SYM (rel->r_info);
2099 r_type = ELF32_R_TYPE (rel->r_info);
2100 if (r_symndx < symtab_hdr->sh_info)
2101 {
2102 /* A local symbol. */
2103 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2104 abfd, r_symndx);
2105 if (isym == NULL)
2106 return FALSE;
2107
2108 hh = NULL;
2109 }
2110 else
2111 {
2112 isym = NULL;
2113
2114 hh = (struct elf_metag_link_hash_entry *)
2115 eh_syms[r_symndx - symtab_hdr->sh_info];
2116 while (hh->eh.root.type == bfd_link_hash_indirect
2117 || hh->eh.root.type == bfd_link_hash_warning)
2118 hh = (struct elf_metag_link_hash_entry *) hh->eh.root.u.i.link;
2119 }
2120
2121 /* Some relocs require a global offset table. */
2122 if (htab->etab.sgot == NULL)
2123 {
2124 switch (r_type)
2125 {
2126 case R_METAG_TLS_GD:
2127 case R_METAG_TLS_LDM:
2128 case R_METAG_TLS_IE:
2129 if (bfd_link_pic (info))
2130 info->flags |= DF_STATIC_TLS;
2131 /* Fall through. */
2132
2133 case R_METAG_HI16_GOTOFF:
2134 case R_METAG_LO16_GOTOFF:
2135 case R_METAG_GETSET_GOTOFF:
2136 case R_METAG_GETSET_GOT:
2137 case R_METAG_HI16_GOTPC:
2138 case R_METAG_LO16_GOTPC:
2139 if (dynobj == NULL)
2140 htab->etab.dynobj = dynobj = abfd;
2141 if (!elf_metag_create_dynamic_sections (dynobj, info))
2142 return FALSE;
2143 break;
2144
2145 default:
2146 break;
2147 }
2148 }
2149
2150 switch (r_type)
2151 {
2152 case R_METAG_TLS_IE:
2153 case R_METAG_TLS_GD:
2154 case R_METAG_GETSET_GOT:
2155 switch (r_type)
2156 {
2157 default:
2158 tls_type = GOT_NORMAL;
2159 break;
2160 case R_METAG_TLS_IE:
2161 tls_type = GOT_TLS_IE;
2162 break;
2163 case R_METAG_TLS_GD:
2164 tls_type = GOT_TLS_GD;
2165 break;
2166 }
2167
2168 if (hh != NULL)
2169 {
2170 hh->eh.got.refcount += 1;
2171 old_tls_type = hh->tls_type;
2172 }
2173 else
2174 {
2175 bfd_signed_vma *local_got_refcounts;
2176
2177 /* This is a global offset table entry for a local
2178 symbol. */
2179 local_got_refcounts = elf_local_got_refcounts (abfd);
2180 if (local_got_refcounts == NULL)
2181 {
2182 bfd_size_type size;
2183
2184 size = symtab_hdr->sh_info;
2185 size *= sizeof (bfd_signed_vma);
2186 /* Add in space to store the local GOT TLS types. */
2187 size += symtab_hdr->sh_info;
2188 local_got_refcounts = ((bfd_signed_vma *)
2189 bfd_zalloc (abfd, size));
2190 if (local_got_refcounts == NULL)
2191 return FALSE;
2192 elf_local_got_refcounts (abfd) = local_got_refcounts;
2193 memset (metag_elf_local_got_tls_type (abfd),
2194 GOT_UNKNOWN, symtab_hdr->sh_info);
2195 }
2196 local_got_refcounts[r_symndx] += 1;
2197 old_tls_type = metag_elf_local_got_tls_type (abfd) [r_symndx];
2198 }
2199
2200 if (old_tls_type != tls_type)
2201 {
2202 if (hh != NULL)
2203 {
2204 hh->tls_type = tls_type;
2205 }
2206 else
2207 {
2208 metag_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
2209 }
2210 }
2211
2212 break;
2213
2214 case R_METAG_TLS_LDM:
2215 metag_link_hash_table (info)->tls_ldm_got.refcount += 1;
2216 break;
2217
2218 case R_METAG_RELBRANCH_PLT:
2219 /* This symbol requires a procedure linkage table entry. We
2220 actually build the entry in adjust_dynamic_symbol,
2221 because this might be a case of linking PIC code without
2222 linking in any dynamic objects, in which case we don't
2223 need to generate a procedure linkage table after all. */
2224
2225 /* If this is a local symbol, we resolve it directly without
2226 creating a procedure linkage table entry. */
2227 if (hh == NULL)
2228 continue;
2229
2230 if (hh->eh.forced_local)
2231 break;
2232
2233 hh->eh.needs_plt = 1;
2234 hh->eh.plt.refcount += 1;
2235 break;
2236
2237 case R_METAG_HIADDR16:
2238 case R_METAG_LOADDR16:
2239 /* Let's help debug shared library creation. These relocs
2240 cannot be used in shared libs. Don't error out for
2241 sections we don't care about, such as debug sections or
2242 non-constant sections. */
2243 if (bfd_link_pic (info)
2244 && (sec->flags & SEC_ALLOC) != 0
2245 && (sec->flags & SEC_READONLY) != 0)
2246 {
2247 const char *name;
2248
2249 if (hh)
2250 name = hh->eh.root.root.string;
2251 else
2252 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
2253 _bfd_error_handler
2254 /* xgettext:c-format */
2255 (_("%pB: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
2256 abfd, elf_metag_howto_table[r_type].name, name);
2257 bfd_set_error (bfd_error_bad_value);
2258 return FALSE;
2259 }
2260
2261 /* Fall through. */
2262 case R_METAG_ADDR32:
2263 case R_METAG_RELBRANCH:
2264 case R_METAG_GETSETOFF:
2265 if (hh != NULL && !bfd_link_pic (info))
2266 {
2267 hh->eh.non_got_ref = 1;
2268 hh->eh.plt.refcount += 1;
2269 }
2270
2271 /* If we are creating a shared library, and this is a reloc
2272 against a global symbol, or a non PC relative reloc
2273 against a local symbol, then we need to copy the reloc
2274 into the shared library. However, if we are linking with
2275 -Bsymbolic, we do not need to copy a reloc against a
2276 global symbol which is defined in an object we are
2277 including in the link (i.e., DEF_REGULAR is set). At
2278 this point we have not seen all the input files, so it is
2279 possible that DEF_REGULAR is not set now but will be set
2280 later (it is never cleared). We account for that
2281 possibility below by storing information in the
2282 dyn_relocs field of the hash table entry. A similar
2283 situation occurs when creating shared libraries and symbol
2284 visibility changes render the symbol local.
2285
2286 If on the other hand, we are creating an executable, we
2287 may need to keep relocations for symbols satisfied by a
2288 dynamic library if we manage to avoid copy relocs for the
2289 symbol. */
2290 if ((bfd_link_pic (info)
2291 && (sec->flags & SEC_ALLOC) != 0
2292 && (r_type != R_METAG_RELBRANCH
2293 || (hh != NULL
2294 && (! info->symbolic
2295 || hh->eh.root.type == bfd_link_hash_defweak
2296 || !hh->eh.def_regular))))
2297 || (!bfd_link_pic (info)
2298 && (sec->flags & SEC_ALLOC) != 0
2299 && hh != NULL
2300 && (hh->eh.root.type == bfd_link_hash_defweak
2301 || !hh->eh.def_regular)))
2302 {
2303 struct elf_dyn_relocs *hdh_p;
2304 struct elf_dyn_relocs **hdh_head;
2305
2306 if (dynobj == NULL)
2307 htab->etab.dynobj = dynobj = abfd;
2308
2309 /* When creating a shared object, we must copy these
2310 relocs into the output file. We create a reloc
2311 section in dynobj and make room for the reloc. */
2312 if (sreloc == NULL)
2313 {
2314 sreloc = _bfd_elf_make_dynamic_reloc_section
2315 (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
2316
2317 if (sreloc == NULL)
2318 {
2319 bfd_set_error (bfd_error_bad_value);
2320 return FALSE;
2321 }
2322
2323 elf_section_data (sec)->sreloc = sreloc;
2324 }
2325
2326 /* If this is a global symbol, we count the number of
2327 relocations we need for this symbol. */
2328 if (hh != NULL)
2329 hdh_head = &((struct elf_metag_link_hash_entry *) hh)->dyn_relocs;
2330 else
2331 {
2332 /* Track dynamic relocs needed for local syms too. */
2333 asection *sr;
2334 void *vpp;
2335
2336 sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
2337 if (sr == NULL)
2338 sr = sec;
2339
2340 vpp = &elf_section_data (sr)->local_dynrel;
2341 hdh_head = (struct elf_dyn_relocs **) vpp;
2342 }
2343
2344 hdh_p = *hdh_head;
2345 if (hdh_p == NULL || hdh_p->sec != sec)
2346 {
2347 hdh_p = ((struct elf_dyn_relocs *)
2348 bfd_alloc (dynobj, sizeof *hdh_p));
2349 if (hdh_p == NULL)
2350 return FALSE;
2351 hdh_p->next = *hdh_head;
2352 *hdh_head = hdh_p;
2353 hdh_p->sec = sec;
2354 hdh_p->count = 0;
2355 hdh_p->pc_count = 0;
2356 }
2357
2358 hdh_p->count += 1;
2359 if (ELF32_R_TYPE (rel->r_info) == R_METAG_RELBRANCH)
2360 hdh_p->pc_count += 1;
2361 }
2362 break;
2363
2364 /* This relocation describes the C++ object vtable hierarchy.
2365 Reconstruct it for later use during GC. */
2366 case R_METAG_GNU_VTINHERIT:
2367 if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh,
2368 rel->r_offset))
2369 return FALSE;
2370 break;
2371
2372 /* This relocation describes which C++ vtable entries are actually
2373 used. Record for later use during GC. */
2374 case R_METAG_GNU_VTENTRY:
2375 BFD_ASSERT (hh != NULL);
2376 if (hh != NULL
2377 && !bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
2378 return FALSE;
2379 break;
2380 }
2381 }
2382
2383 return TRUE;
2384 }
2385
2386 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2387
2388 static void
2389 elf_metag_copy_indirect_symbol (struct bfd_link_info *info,
2390 struct elf_link_hash_entry *eh_dir,
2391 struct elf_link_hash_entry *eh_ind)
2392 {
2393 struct elf_metag_link_hash_entry *hh_dir, *hh_ind;
2394
2395 hh_dir = metag_elf_hash_entry (eh_dir);
2396 hh_ind = metag_elf_hash_entry (eh_ind);
2397
2398 if (hh_ind->dyn_relocs != NULL)
2399 {
2400 if (hh_dir->dyn_relocs != NULL)
2401 {
2402 struct elf_dyn_relocs **hdh_pp;
2403 struct elf_dyn_relocs *hdh_p;
2404
2405 if (eh_ind->root.type == bfd_link_hash_indirect)
2406 abort ();
2407
2408 /* Add reloc counts against the weak sym to the strong sym
2409 list. Merge any entries against the same section. */
2410 for (hdh_pp = &hh_ind->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2411 {
2412 struct elf_dyn_relocs *hdh_q;
2413
2414 for (hdh_q = hh_dir->dyn_relocs; hdh_q != NULL;
2415 hdh_q = hdh_q->next)
2416 if (hdh_q->sec == hdh_p->sec)
2417 {
2418 hdh_q->pc_count += hdh_p->pc_count;
2419 hdh_q->count += hdh_p->count;
2420 *hdh_pp = hdh_p->next;
2421 break;
2422 }
2423 if (hdh_q == NULL)
2424 hdh_pp = &hdh_p->next;
2425 }
2426 *hdh_pp = hh_dir->dyn_relocs;
2427 }
2428
2429 hh_dir->dyn_relocs = hh_ind->dyn_relocs;
2430 hh_ind->dyn_relocs = NULL;
2431 }
2432
2433 if (eh_ind->root.type == bfd_link_hash_indirect
2434 && eh_dir->got.refcount <= 0)
2435 {
2436 hh_dir->tls_type = hh_ind->tls_type;
2437 hh_ind->tls_type = GOT_UNKNOWN;
2438 }
2439
2440 _bfd_elf_link_hash_copy_indirect (info, eh_dir, eh_ind);
2441 }
2442
2443 /* Find dynamic relocs for H that apply to read-only sections. */
2444
2445 static asection *
2446 readonly_dynrelocs (struct elf_link_hash_entry *h)
2447 {
2448 struct elf_dyn_relocs *p;
2449
2450 for (p = metag_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2451 {
2452 asection *s = p->sec->output_section;
2453
2454 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2455 return p->sec;
2456 }
2457 return NULL;
2458 }
2459
2460 /* Adjust a symbol defined by a dynamic object and referenced by a
2461 regular object. The current definition is in some section of the
2462 dynamic object, but we're not including those sections. We have to
2463 change the definition to something the rest of the link can
2464 understand. */
2465
2466 static bfd_boolean
2467 elf_metag_adjust_dynamic_symbol (struct bfd_link_info *info,
2468 struct elf_link_hash_entry *eh)
2469 {
2470 struct elf_metag_link_hash_table *htab;
2471 asection *s, *srel;
2472
2473 /* If this is a function, put it in the procedure linkage table. We
2474 will fill in the contents of the procedure linkage table later,
2475 when we know the address of the .got section. */
2476 if (eh->type == STT_FUNC
2477 || eh->needs_plt)
2478 {
2479 if (eh->plt.refcount <= 0
2480 || SYMBOL_CALLS_LOCAL (info, eh)
2481 || (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT
2482 && eh->root.type == bfd_link_hash_undefweak))
2483 {
2484 /* This case can occur if we saw a PLT reloc in an input
2485 file, but the symbol was never referred to by a dynamic
2486 object. In such a case, we don't actually need to build
2487 a procedure linkage table, and we can just do a PCREL
2488 reloc instead. */
2489 eh->plt.offset = (bfd_vma) -1;
2490 eh->needs_plt = 0;
2491 }
2492
2493 return TRUE;
2494 }
2495 else
2496 eh->plt.offset = (bfd_vma) -1;
2497
2498 /* If this is a weak symbol, and there is a real definition, the
2499 processor independent code will have arranged for us to see the
2500 real definition first, and we can just use the same value. */
2501 if (eh->is_weakalias)
2502 {
2503 struct elf_link_hash_entry *def = weakdef (eh);
2504 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
2505 eh->root.u.def.section = def->root.u.def.section;
2506 eh->root.u.def.value = def->root.u.def.value;
2507 eh->non_got_ref = def->non_got_ref;
2508 return TRUE;
2509 }
2510
2511 /* This is a reference to a symbol defined by a dynamic object which
2512 is not a function. */
2513
2514 /* If we are creating a shared library, we must presume that the
2515 only references to the symbol are via the global offset table.
2516 For such cases we need not do anything here; the relocations will
2517 be handled correctly by relocate_section. */
2518 if (bfd_link_pic (info))
2519 return TRUE;
2520
2521 /* If there are no references to this symbol that do not use the
2522 GOT, we don't need to generate a copy reloc. */
2523 if (!eh->non_got_ref)
2524 return TRUE;
2525
2526 /* If -z nocopyreloc was given, we won't generate them either. */
2527 if (info->nocopyreloc)
2528 {
2529 eh->non_got_ref = 0;
2530 return TRUE;
2531 }
2532
2533 /* If we don't find any dynamic relocs in read-only sections, then
2534 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
2535 if (!readonly_dynrelocs (eh))
2536 {
2537 eh->non_got_ref = 0;
2538 return TRUE;
2539 }
2540
2541 /* We must allocate the symbol in our .dynbss section, which will
2542 become part of the .bss section of the executable. There will be
2543 an entry for this symbol in the .dynsym section. The dynamic
2544 object will contain position independent code, so all references
2545 from the dynamic object to this symbol will go through the global
2546 offset table. The dynamic linker will use the .dynsym entry to
2547 determine the address it must put in the global offset table, so
2548 both the dynamic object and the regular object will refer to the
2549 same memory location for the variable. */
2550
2551 htab = metag_link_hash_table (info);
2552
2553 /* We must generate a COPY reloc to tell the dynamic linker to
2554 copy the initial value out of the dynamic object and into the
2555 runtime process image. */
2556 if ((eh->root.u.def.section->flags & SEC_READONLY) != 0)
2557 {
2558 s = htab->etab.sdynrelro;
2559 srel = htab->etab.sreldynrelro;
2560 }
2561 else
2562 {
2563 s = htab->etab.sdynbss;
2564 srel = htab->etab.srelbss;
2565 }
2566 if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
2567 {
2568 srel->size += sizeof (Elf32_External_Rela);
2569 eh->needs_copy = 1;
2570 }
2571
2572 return _bfd_elf_adjust_dynamic_copy (info, eh, s);
2573 }
2574
2575 /* Allocate space in .plt, .got and associated reloc sections for
2576 global syms. */
2577
2578 static bfd_boolean
2579 allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2580 {
2581 struct bfd_link_info *info;
2582 struct elf_metag_link_hash_table *htab;
2583 struct elf_metag_link_hash_entry *hh;
2584 struct elf_dyn_relocs *hdh_p;
2585
2586 if (eh->root.type == bfd_link_hash_indirect)
2587 return TRUE;
2588
2589 if (eh->root.type == bfd_link_hash_warning)
2590 eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2591
2592 info = inf;
2593 htab = metag_link_hash_table (info);
2594
2595 if (htab->etab.dynamic_sections_created
2596 && eh->plt.refcount > 0)
2597 {
2598 /* Make sure this symbol is output as a dynamic symbol.
2599 Undefined weak syms won't yet be marked as dynamic. */
2600 if (eh->dynindx == -1
2601 && !eh->forced_local)
2602 {
2603 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2604 return FALSE;
2605 }
2606
2607 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
2608 {
2609 asection *s = htab->etab.splt;
2610
2611 /* If this is the first .plt entry, make room for the special
2612 first entry. */
2613 if (s->size == 0)
2614 s->size += PLT_ENTRY_SIZE;
2615
2616 eh->plt.offset = s->size;
2617
2618 /* If this symbol is not defined in a regular file, and we are
2619 not generating a shared library, then set the symbol to this
2620 location in the .plt. This is required to make function
2621 pointers compare as equal between the normal executable and
2622 the shared library. */
2623 if (! bfd_link_pic (info)
2624 && !eh->def_regular)
2625 {
2626 eh->root.u.def.section = s;
2627 eh->root.u.def.value = eh->plt.offset;
2628 }
2629
2630 /* Make room for this entry. */
2631 s->size += PLT_ENTRY_SIZE;
2632
2633 /* We also need to make an entry in the .got.plt section, which
2634 will be placed in the .got section by the linker script. */
2635 htab->etab.sgotplt->size += 4;
2636
2637 /* We also need to make an entry in the .rel.plt section. */
2638 htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
2639 }
2640 else
2641 {
2642 eh->plt.offset = (bfd_vma) -1;
2643 eh->needs_plt = 0;
2644 }
2645 }
2646 else
2647 {
2648 eh->plt.offset = (bfd_vma) -1;
2649 eh->needs_plt = 0;
2650 }
2651
2652 if (eh->got.refcount > 0)
2653 {
2654 asection *s;
2655 bfd_boolean dyn;
2656 int tls_type = metag_elf_hash_entry (eh)->tls_type;
2657
2658 /* Make sure this symbol is output as a dynamic symbol.
2659 Undefined weak syms won't yet be marked as dynamic. */
2660 if (eh->dynindx == -1
2661 && !eh->forced_local)
2662 {
2663 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2664 return FALSE;
2665 }
2666
2667 s = htab->etab.sgot;
2668
2669 eh->got.offset = s->size;
2670 s->size += 4;
2671 /* R_METAG_TLS_GD needs 2 consecutive GOT slots. */
2672 if (tls_type == GOT_TLS_GD)
2673 s->size += 4;
2674 dyn = htab->etab.dynamic_sections_created;
2675 /* R_METAG_TLS_IE needs one dynamic relocation if dynamic,
2676 R_METAG_TLS_GD needs one if local symbol and two if global. */
2677 if ((tls_type == GOT_TLS_GD && eh->dynindx == -1)
2678 || (tls_type == GOT_TLS_IE && dyn))
2679 htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2680 else if (tls_type == GOT_TLS_GD)
2681 htab->etab.srelgot->size += 2 * sizeof (Elf32_External_Rela);
2682 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2683 bfd_link_pic (info),
2684 eh))
2685 htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2686 }
2687 else
2688 eh->got.offset = (bfd_vma) -1;
2689
2690 hh = (struct elf_metag_link_hash_entry *) eh;
2691 if (hh->dyn_relocs == NULL)
2692 return TRUE;
2693
2694 /* If this is a -Bsymbolic shared link, then we need to discard all
2695 space allocated for dynamic pc-relative relocs against symbols
2696 defined in a regular object. For the normal shared case, discard
2697 space for relocs that have become local due to symbol visibility
2698 changes. */
2699 if (bfd_link_pic (info))
2700 {
2701 if (SYMBOL_CALLS_LOCAL (info, eh))
2702 {
2703 struct elf_dyn_relocs **hdh_pp;
2704
2705 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2706 {
2707 hdh_p->count -= hdh_p->pc_count;
2708 hdh_p->pc_count = 0;
2709 if (hdh_p->count == 0)
2710 *hdh_pp = hdh_p->next;
2711 else
2712 hdh_pp = &hdh_p->next;
2713 }
2714 }
2715
2716 /* Also discard relocs on undefined weak syms with non-default
2717 visibility. */
2718 if (hh->dyn_relocs != NULL
2719 && eh->root.type == bfd_link_hash_undefweak)
2720 {
2721 if (ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT)
2722 hh->dyn_relocs = NULL;
2723
2724 /* Make sure undefined weak symbols are output as a dynamic
2725 symbol in PIEs. */
2726 else if (eh->dynindx == -1
2727 && !eh->forced_local)
2728 {
2729 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2730 return FALSE;
2731 }
2732 }
2733 }
2734 else
2735 {
2736 /* For the non-shared case, discard space for relocs against
2737 symbols which turn out to need copy relocs or are not
2738 dynamic. */
2739 if (!eh->non_got_ref
2740 && ((eh->def_dynamic
2741 && !eh->def_regular)
2742 || (htab->etab.dynamic_sections_created
2743 && (eh->root.type == bfd_link_hash_undefweak
2744 || eh->root.type == bfd_link_hash_undefined))))
2745 {
2746 /* Make sure this symbol is output as a dynamic symbol.
2747 Undefined weak syms won't yet be marked as dynamic. */
2748 if (eh->dynindx == -1
2749 && !eh->forced_local)
2750 {
2751 if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2752 return FALSE;
2753 }
2754
2755 /* If that succeeded, we know we'll be keeping all the
2756 relocs. */
2757 if (eh->dynindx != -1)
2758 goto keep;
2759 }
2760
2761 hh->dyn_relocs = NULL;
2762 return TRUE;
2763
2764 keep: ;
2765 }
2766
2767 /* Finally, allocate space. */
2768 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
2769 {
2770 asection *sreloc = elf_section_data (hdh_p->sec)->sreloc;
2771 sreloc->size += hdh_p->count * sizeof (Elf32_External_Rela);
2772 }
2773
2774 return TRUE;
2775 }
2776
2777 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2778 read-only sections. */
2779
2780 static bfd_boolean
2781 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
2782 {
2783 asection *sec;
2784
2785 if (h->root.type == bfd_link_hash_indirect)
2786 return TRUE;
2787
2788 sec = readonly_dynrelocs (h);
2789 if (sec != NULL)
2790 {
2791 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
2792
2793 info->flags |= DF_TEXTREL;
2794 info->callbacks->minfo
2795 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2796 sec->owner, h->root.root.string, sec);
2797
2798 /* Not an error, just cut short the traversal. */
2799 return FALSE;
2800 }
2801 return TRUE;
2802 }
2803
2804 /* Set the sizes of the dynamic sections. */
2805
2806 static bfd_boolean
2807 elf_metag_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2808 struct bfd_link_info *info)
2809 {
2810 struct elf_metag_link_hash_table *htab;
2811 bfd *dynobj;
2812 bfd *ibfd;
2813 asection *s;
2814 bfd_boolean relocs;
2815
2816 htab = metag_link_hash_table (info);
2817 dynobj = htab->etab.dynobj;
2818 if (dynobj == NULL)
2819 abort ();
2820
2821 if (htab->etab.dynamic_sections_created)
2822 {
2823 /* Set the contents of the .interp section to the interpreter. */
2824 if (bfd_link_executable (info) && !info->nointerp)
2825 {
2826 s = bfd_get_linker_section (dynobj, ".interp");
2827 if (s == NULL)
2828 abort ();
2829 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2830 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2831 }
2832 }
2833
2834 /* Set up .got offsets for local syms, and space for local dynamic
2835 relocs. */
2836 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2837 {
2838 bfd_signed_vma *local_got;
2839 bfd_signed_vma *end_local_got;
2840 bfd_size_type locsymcount;
2841 Elf_Internal_Shdr *symtab_hdr;
2842 asection *srel;
2843 char *local_tls_type;
2844
2845 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2846 continue;
2847
2848 for (s = ibfd->sections; s != NULL; s = s->next)
2849 {
2850 struct elf_dyn_relocs *hdh_p;
2851
2852 for (hdh_p = ((struct elf_dyn_relocs *)
2853 elf_section_data (s)->local_dynrel);
2854 hdh_p != NULL;
2855 hdh_p = hdh_p->next)
2856 {
2857 if (!bfd_is_abs_section (hdh_p->sec)
2858 && bfd_is_abs_section (hdh_p->sec->output_section))
2859 {
2860 /* Input section has been discarded, either because
2861 it is a copy of a linkonce section or due to
2862 linker script /DISCARD/, so we'll be discarding
2863 the relocs too. */
2864 }
2865 else if (hdh_p->count != 0)
2866 {
2867 srel = elf_section_data (hdh_p->sec)->sreloc;
2868 srel->size += hdh_p->count * sizeof (Elf32_External_Rela);
2869 if ((hdh_p->sec->output_section->flags & SEC_READONLY) != 0)
2870 info->flags |= DF_TEXTREL;
2871 }
2872 }
2873 }
2874
2875 local_got = elf_local_got_refcounts (ibfd);
2876 if (!local_got)
2877 continue;
2878
2879 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2880 locsymcount = symtab_hdr->sh_info;
2881 end_local_got = local_got + locsymcount;
2882 local_tls_type = metag_elf_local_got_tls_type (ibfd);
2883 s = htab->etab.sgot;
2884 srel = htab->etab.srelgot;
2885 for (; local_got < end_local_got; ++local_got)
2886 {
2887 if (*local_got > 0)
2888 {
2889 *local_got = s->size;
2890 s->size += GOT_ENTRY_SIZE;
2891 /* R_METAG_TLS_GD relocs need 2 consecutive GOT entries. */
2892 if (*local_tls_type == GOT_TLS_GD)
2893 s->size += 4;
2894 if (bfd_link_pic (info))
2895 srel->size += sizeof (Elf32_External_Rela);
2896 }
2897 else
2898 *local_got = (bfd_vma) -1;
2899 ++local_tls_type;
2900 }
2901 }
2902
2903 if (htab->tls_ldm_got.refcount > 0)
2904 {
2905 /* Allocate 2 got entries and 1 dynamic reloc for R_METAG_TLS_LDM
2906 reloc. */
2907 htab->tls_ldm_got.offset = htab->etab.sgot->size;
2908 htab->etab.sgot->size += 8;
2909 htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
2910 }
2911 else
2912 htab->tls_ldm_got.offset = -1;
2913
2914 /* Allocate global sym .plt and .got entries, and space for global
2915 sym dynamic relocs. */
2916 elf_link_hash_traverse (&htab->etab, allocate_dynrelocs, info);
2917
2918 /* We now have determined the sizes of the various dynamic sections.
2919 Allocate memory for them. */
2920 relocs = FALSE;
2921 for (s = dynobj->sections; s != NULL; s = s->next)
2922 {
2923 bfd_boolean reloc_section = FALSE;
2924
2925 if ((s->flags & SEC_LINKER_CREATED) == 0)
2926 continue;
2927
2928 if (s == htab->etab.splt
2929 || s == htab->etab.sgot
2930 || s == htab->etab.sgotplt
2931 || s == htab->etab.sdynbss
2932 || s == htab->etab.sdynrelro)
2933 {
2934 /* Strip this section if we don't need it; see the
2935 comment below. */
2936 }
2937 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2938 {
2939 if (s->size != 0 && s != htab->etab.srelplt)
2940 relocs = TRUE;
2941
2942 /* We use the reloc_count field as a counter if we need
2943 to copy relocs into the output file. */
2944 s->reloc_count = 0;
2945 reloc_section = TRUE;
2946 }
2947 else
2948 {
2949 /* It's not one of our sections, so don't allocate space. */
2950 continue;
2951 }
2952
2953 if (s->size == 0)
2954 {
2955 /* If we don't need this section, strip it from the
2956 output file. This is mostly to handle .rela.bss and
2957 .rela.plt. We must create both sections in
2958 create_dynamic_sections, because they must be created
2959 before the linker maps input sections to output
2960 sections. The linker does that before
2961 adjust_dynamic_symbol is called, and it is that
2962 function which decides whether anything needs to go
2963 into these sections. */
2964 s->flags |= SEC_EXCLUDE;
2965 continue;
2966 }
2967
2968 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2969 continue;
2970
2971 /* Allocate memory for the section contents. */
2972 s->contents = bfd_zalloc (dynobj, s->size);
2973 if (s->contents == NULL)
2974 return FALSE;
2975 else if (reloc_section)
2976 {
2977 unsigned char *contents = s->contents;
2978 Elf32_External_Rela reloc;
2979
2980 /* Fill the reloc section with a R_METAG_NONE type reloc. */
2981 memset(&reloc, 0, sizeof(Elf32_External_Rela));
2982 reloc.r_info[0] = R_METAG_NONE;
2983 for (; contents < (s->contents + s->size);
2984 contents += sizeof(Elf32_External_Rela))
2985 {
2986 memcpy(contents, &reloc, sizeof(Elf32_External_Rela));
2987 }
2988 }
2989 }
2990
2991 if (htab->etab.dynamic_sections_created)
2992 {
2993 /* Add some entries to the .dynamic section. We fill in the
2994 values later, in elf_metag_finish_dynamic_sections, but we
2995 must add the entries now so that we get the correct size for
2996 the .dynamic section. The DT_DEBUG entry is filled in by the
2997 dynamic linker and used by the debugger. */
2998 #define add_dynamic_entry(TAG, VAL) \
2999 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3000
3001 if (!add_dynamic_entry (DT_PLTGOT, 0))
3002 return FALSE;
3003
3004 if (bfd_link_executable (info))
3005 {
3006 if (!add_dynamic_entry (DT_DEBUG, 0))
3007 return FALSE;
3008 }
3009
3010 if (htab->etab.srelplt->size != 0)
3011 {
3012 if (!add_dynamic_entry (DT_PLTRELSZ, 0)
3013 || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3014 || !add_dynamic_entry (DT_JMPREL, 0))
3015 return FALSE;
3016 }
3017
3018 if (relocs)
3019 {
3020 if (!add_dynamic_entry (DT_RELA, 0)
3021 || !add_dynamic_entry (DT_RELASZ, 0)
3022 || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3023 return FALSE;
3024
3025 /* If any dynamic relocs apply to a read-only section,
3026 then we need a DT_TEXTREL entry. */
3027 if ((info->flags & DF_TEXTREL) == 0)
3028 elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
3029
3030 if ((info->flags & DF_TEXTREL) != 0)
3031 {
3032 if (!add_dynamic_entry (DT_TEXTREL, 0))
3033 return FALSE;
3034 }
3035 }
3036 }
3037 #undef add_dynamic_entry
3038
3039 return TRUE;
3040 }
3041
3042 /* Finish up dynamic symbol handling. We set the contents of various
3043 dynamic sections here. */
3044
3045 static bfd_boolean
3046 elf_metag_finish_dynamic_symbol (bfd *output_bfd,
3047 struct bfd_link_info *info,
3048 struct elf_link_hash_entry *eh,
3049 Elf_Internal_Sym *sym)
3050 {
3051 struct elf_metag_link_hash_table *htab;
3052 Elf_Internal_Rela rel;
3053 bfd_byte *loc;
3054
3055 htab = metag_link_hash_table (info);
3056
3057 if (eh->plt.offset != (bfd_vma) -1)
3058 {
3059 asection *splt;
3060 asection *sgot;
3061 asection *srela;
3062
3063 bfd_vma plt_index;
3064 bfd_vma got_offset;
3065 bfd_vma got_entry;
3066
3067 if (eh->plt.offset & 1)
3068 abort ();
3069
3070 BFD_ASSERT (eh->dynindx != -1);
3071
3072 splt = htab->etab.splt;
3073 sgot = htab->etab.sgotplt;
3074 srela = htab->etab.srelplt;
3075 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3076
3077 /* Get the index in the procedure linkage table which
3078 corresponds to this symbol. This is the index of this symbol
3079 in all the symbols for which we are making plt entries. The
3080 first entry in the procedure linkage table is reserved. */
3081 plt_index = eh->plt.offset / PLT_ENTRY_SIZE - 1;
3082
3083 /* Get the offset into the .got.plt table of the entry that
3084 corresponds to this function. */
3085 got_offset = plt_index * GOT_ENTRY_SIZE;
3086
3087 BFD_ASSERT (got_offset < (1 << 16));
3088
3089 got_entry = sgot->output_section->vma
3090 + sgot->output_offset
3091 + got_offset;
3092
3093 BFD_ASSERT (plt_index < (1 << 16));
3094
3095 /* Fill in the entry in the procedure linkage table. */
3096 if (! bfd_link_pic (info))
3097 {
3098 bfd_put_32 (output_bfd,
3099 (plt_entry[0]
3100 | (((got_entry >> 16) & 0xffff) << 3)),
3101 splt->contents + eh->plt.offset);
3102 bfd_put_32 (output_bfd,
3103 (plt_entry[1]
3104 | ((got_entry & 0xffff) << 3)),
3105 splt->contents + eh->plt.offset + 4);
3106 bfd_put_32 (output_bfd, plt_entry[2],
3107 splt->contents + eh->plt.offset + 8);
3108 bfd_put_32 (output_bfd,
3109 (plt_entry[3] | (plt_index << 3)),
3110 splt->contents + eh->plt.offset + 12);
3111 bfd_put_32 (output_bfd,
3112 (plt_entry[4]
3113 | ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
3114 splt->contents + eh->plt.offset + 16);
3115 }
3116 else
3117 {
3118 bfd_vma addr = got_entry - (splt->output_section->vma +
3119 splt->output_offset + eh->plt.offset);
3120
3121 bfd_put_32 (output_bfd,
3122 plt_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
3123 splt->contents + eh->plt.offset);
3124 bfd_put_32 (output_bfd,
3125 plt_pic_entry[1] | ((addr & 0xffff) << 3),
3126 splt->contents + eh->plt.offset + 4);
3127 bfd_put_32 (output_bfd, plt_pic_entry[2],
3128 splt->contents + eh->plt.offset + 8);
3129 bfd_put_32 (output_bfd,
3130 (plt_pic_entry[3] | (plt_index << 3)),
3131 splt->contents + eh->plt.offset + 12);
3132 bfd_put_32 (output_bfd,
3133 (plt_pic_entry[4]
3134 + ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
3135 splt->contents + eh->plt.offset + 16);
3136 }
3137
3138 /* Fill in the entry in the global offset table. */
3139 bfd_put_32 (output_bfd,
3140 (splt->output_section->vma
3141 + splt->output_offset
3142 + eh->plt.offset
3143 + 12), /* offset within PLT entry */
3144 sgot->contents + got_offset);
3145
3146 /* Fill in the entry in the .rela.plt section. */
3147 rel.r_offset = (sgot->output_section->vma
3148 + sgot->output_offset
3149 + got_offset);
3150 rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_JMP_SLOT);
3151 rel.r_addend = 0;
3152 loc = htab->etab.srelplt->contents;
3153 loc += plt_index * sizeof(Elf32_External_Rela);
3154 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3155
3156 if (!eh->def_regular)
3157 {
3158 /* Mark the symbol as undefined, rather than as defined in
3159 the .plt section. Leave the value alone. */
3160 sym->st_shndx = SHN_UNDEF;
3161 }
3162 }
3163
3164 if (eh->got.offset != (bfd_vma) -1
3165 && (metag_elf_hash_entry (eh)->tls_type & GOT_TLS_GD) == 0
3166 && (metag_elf_hash_entry (eh)->tls_type & GOT_TLS_IE) == 0)
3167 {
3168 /* This symbol has an entry in the global offset table. Set it
3169 up. */
3170
3171 rel.r_offset = ((eh->got.offset &~ (bfd_vma) 1)
3172 + htab->etab.sgot->output_offset
3173 + htab->etab.sgot->output_section->vma);
3174
3175 /* If this is a -Bsymbolic link and the symbol is defined
3176 locally or was forced to be local because of a version file,
3177 we just want to emit a RELATIVE reloc. The entry in the
3178 global offset table will already have been initialized in the
3179 relocate_section function. */
3180 if (bfd_link_pic (info)
3181 && (info->symbolic || eh->dynindx == -1)
3182 && eh->def_regular)
3183 {
3184 rel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
3185 rel.r_addend = (eh->root.u.def.value
3186 + eh->root.u.def.section->output_offset
3187 + eh->root.u.def.section->output_section->vma);
3188 }
3189 else
3190 {
3191 if ((eh->got.offset & 1) != 0)
3192 abort ();
3193 bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + eh->got.offset);
3194 rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_GLOB_DAT);
3195 rel.r_addend = 0;
3196 }
3197
3198 loc = htab->etab.srelgot->contents;
3199 loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
3200 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3201 }
3202
3203 if (eh->needs_copy)
3204 {
3205 asection *s;
3206
3207 /* This symbol needs a copy reloc. Set it up. */
3208
3209 if (! (eh->dynindx != -1
3210 && (eh->root.type == bfd_link_hash_defined
3211 || eh->root.type == bfd_link_hash_defweak)))
3212 abort ();
3213
3214 rel.r_offset = (eh->root.u.def.value
3215 + eh->root.u.def.section->output_offset
3216 + eh->root.u.def.section->output_section->vma);
3217 rel.r_addend = 0;
3218 rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_COPY);
3219 if (eh->root.u.def.section == htab->etab.sdynrelro)
3220 s = htab->etab.sreldynrelro;
3221 else
3222 s = htab->etab.srelbss;
3223 loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
3224 bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3225 }
3226
3227 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
3228 if (eh->root.root.string[0] == '_'
3229 && (strcmp (eh->root.root.string, "_DYNAMIC") == 0
3230 || eh == htab->etab.hgot))
3231 {
3232 sym->st_shndx = SHN_ABS;
3233 }
3234
3235 return TRUE;
3236 }
3237
3238 /* Set the Meta ELF ABI version. */
3239
3240 static void
3241 elf_metag_post_process_headers (bfd * abfd, struct bfd_link_info * link_info)
3242 {
3243 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
3244
3245 _bfd_elf_post_process_headers (abfd, link_info);
3246 i_ehdrp = elf_elfheader (abfd);
3247 i_ehdrp->e_ident[EI_ABIVERSION] = METAG_ELF_ABI_VERSION;
3248 }
3249
3250 /* Used to decide how to sort relocs in an optimal manner for the
3251 dynamic linker, before writing them out. */
3252
3253 static enum elf_reloc_type_class
3254 elf_metag_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3255 const asection *rel_sec ATTRIBUTE_UNUSED,
3256 const Elf_Internal_Rela *rela)
3257 {
3258 switch ((int) ELF32_R_TYPE (rela->r_info))
3259 {
3260 case R_METAG_RELATIVE:
3261 return reloc_class_relative;
3262 case R_METAG_JMP_SLOT:
3263 return reloc_class_plt;
3264 case R_METAG_COPY:
3265 return reloc_class_copy;
3266 default:
3267 return reloc_class_normal;
3268 }
3269 }
3270
3271 /* Finish up the dynamic sections. */
3272
3273 static bfd_boolean
3274 elf_metag_finish_dynamic_sections (bfd *output_bfd,
3275 struct bfd_link_info *info)
3276 {
3277 bfd *dynobj;
3278 struct elf_metag_link_hash_table *htab;
3279 asection *sdyn;
3280
3281 htab = metag_link_hash_table (info);
3282 dynobj = htab->etab.dynobj;
3283
3284 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3285
3286 if (htab->etab.dynamic_sections_created)
3287 {
3288 asection *splt;
3289 Elf32_External_Dyn *dyncon, *dynconend;
3290
3291 if (sdyn == NULL)
3292 abort ();
3293
3294 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3295 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3296 for (; dyncon < dynconend; dyncon++)
3297 {
3298 Elf_Internal_Dyn dyn;
3299 asection *s;
3300
3301 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3302
3303 switch (dyn.d_tag)
3304 {
3305 default:
3306 continue;
3307
3308 case DT_PLTGOT:
3309 s = htab->etab.sgot;
3310 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3311 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3312 break;
3313
3314 case DT_JMPREL:
3315 s = htab->etab.srelplt;
3316 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
3317 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3318 break;
3319
3320 case DT_PLTRELSZ:
3321 s = htab->etab.srelplt;
3322 dyn.d_un.d_val = s->size;
3323 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3324 break;
3325 }
3326
3327 }
3328
3329 /* Fill in the first entry in the procedure linkage table. */
3330 splt = htab->etab.splt;
3331 if (splt && splt->size > 0)
3332 {
3333 unsigned long addr;
3334 /* addr = .got + 4 */
3335 addr = (htab->etab.sgot->output_section->vma
3336 + htab->etab.sgot->output_offset + 4);
3337 if (bfd_link_pic (info))
3338 {
3339 addr -= splt->output_section->vma + splt->output_offset;
3340 bfd_put_32 (output_bfd,
3341 plt0_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
3342 splt->contents);
3343 bfd_put_32 (output_bfd,
3344 plt0_pic_entry[1] | ((addr & 0xffff) << 3),
3345 splt->contents + 4);
3346 bfd_put_32 (output_bfd, plt0_pic_entry[2], splt->contents + 8);
3347 bfd_put_32 (output_bfd, plt0_pic_entry[3], splt->contents + 12);
3348 bfd_put_32 (output_bfd, plt0_pic_entry[4], splt->contents + 16);
3349 }
3350 else
3351 {
3352 bfd_put_32 (output_bfd,
3353 plt0_entry[0] | (((addr >> 16) & 0xffff) << 3),
3354 splt->contents);
3355 bfd_put_32 (output_bfd,
3356 plt0_entry[1] | ((addr & 0xffff) << 3),
3357 splt->contents + 4);
3358 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
3359 bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
3360 bfd_put_32 (output_bfd, plt0_entry[4], splt->contents + 16);
3361 }
3362
3363 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3364 PLT_ENTRY_SIZE;
3365 }
3366 }
3367
3368 if (htab->etab.sgot != NULL && htab->etab.sgot->size != 0)
3369 {
3370 /* Fill in the first entry in the global offset table.
3371 We use it to point to our dynamic section, if we have one. */
3372 bfd_put_32 (output_bfd,
3373 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
3374 htab->etab.sgot->contents);
3375
3376 /* The second entry is reserved for use by the dynamic linker. */
3377 memset (htab->etab.sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
3378
3379 /* Set .got entry size. */
3380 elf_section_data (htab->etab.sgot->output_section)
3381 ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
3382 }
3383
3384 return TRUE;
3385 }
3386
3387 /* Return the section that should be marked against GC for a given
3388 relocation. */
3389
3390 static asection *
3391 elf_metag_gc_mark_hook (asection *sec,
3392 struct bfd_link_info *info,
3393 Elf_Internal_Rela *rela,
3394 struct elf_link_hash_entry *hh,
3395 Elf_Internal_Sym *sym)
3396 {
3397 if (hh != NULL)
3398 switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
3399 {
3400 case R_METAG_GNU_VTINHERIT:
3401 case R_METAG_GNU_VTENTRY:
3402 return NULL;
3403 }
3404
3405 return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
3406 }
3407
3408 /* Determine the type of stub needed, if any, for a call. */
3409
3410 static enum elf_metag_stub_type
3411 metag_type_of_stub (asection *input_sec,
3412 const Elf_Internal_Rela *rel,
3413 struct elf_metag_link_hash_entry *hh,
3414 bfd_vma destination,
3415 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3416 {
3417 bfd_vma location;
3418 bfd_vma branch_offset;
3419 bfd_vma max_branch_offset;
3420
3421 if (hh != NULL &&
3422 !(hh->eh.root.type == bfd_link_hash_defined
3423 || hh->eh.root.type == bfd_link_hash_defweak))
3424 return metag_stub_none;
3425
3426 /* Determine where the call point is. */
3427 location = (input_sec->output_offset
3428 + input_sec->output_section->vma
3429 + rel->r_offset);
3430
3431 branch_offset = destination - location;
3432
3433 /* Determine if a long branch stub is needed. Meta branch offsets
3434 are signed 19 bits 4 byte aligned. */
3435 max_branch_offset = (1 << (BRANCH_BITS-1)) << 2;
3436
3437 if (branch_offset + max_branch_offset >= 2*max_branch_offset)
3438 {
3439 if (bfd_link_pic (info))
3440 return metag_stub_long_branch_shared;
3441 else
3442 return metag_stub_long_branch;
3443 }
3444
3445 return metag_stub_none;
3446 }
3447
3448 #define MOVT_A0_3 0x82180005
3449 #define JUMP_A0_3 0xac180003
3450
3451 #define MOVT_A1LBP 0x83080005
3452 #define ADD_A1LBP 0x83080000
3453
3454 #define ADDT_A0_3_CPC 0x82980001
3455 #define ADD_A0_3_A0_3 0x82180000
3456 #define MOV_PC_A0_3 0xa3180ca0
3457
3458 static bfd_boolean
3459 metag_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
3460 {
3461 struct elf_metag_stub_hash_entry *hsh;
3462 asection *stub_sec;
3463 bfd *stub_bfd;
3464 bfd_byte *loc;
3465 bfd_vma sym_value;
3466 int size;
3467
3468 /* Massage our args to the form they really have. */
3469 hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
3470
3471 stub_sec = hsh->stub_sec;
3472
3473 /* Make a note of the offset within the stubs for this entry. */
3474 hsh->stub_offset = stub_sec->size;
3475 loc = stub_sec->contents + hsh->stub_offset;
3476
3477 stub_bfd = stub_sec->owner;
3478
3479 switch (hsh->stub_type)
3480 {
3481 case metag_stub_long_branch_shared:
3482 /* A PIC long branch stub is an ADDT and an ADD instruction used to
3483 calculate the jump target using A0.3 as a temporary. Then a MOV
3484 to PC carries out the jump. */
3485 sym_value = (hsh->target_value
3486 + hsh->target_section->output_offset
3487 + hsh->target_section->output_section->vma
3488 + hsh->addend);
3489
3490 sym_value -= (hsh->stub_offset
3491 + stub_sec->output_offset
3492 + stub_sec->output_section->vma);
3493
3494 bfd_put_32 (stub_bfd, ADDT_A0_3_CPC | (((sym_value >> 16) & 0xffff) << 3),
3495 loc);
3496
3497 bfd_put_32 (stub_bfd, ADD_A0_3_A0_3 | ((sym_value & 0xffff) << 3),
3498 loc + 4);
3499
3500 bfd_put_32 (stub_bfd, MOV_PC_A0_3, loc + 8);
3501
3502 size = 12;
3503 break;
3504 case metag_stub_long_branch:
3505 /* A standard long branch stub is a MOVT instruction followed by a
3506 JUMP instruction using the A0.3 register as a temporary. This is
3507 the same method used by the LDLK linker (patch.c). */
3508 sym_value = (hsh->target_value
3509 + hsh->target_section->output_offset
3510 + hsh->target_section->output_section->vma
3511 + hsh->addend);
3512
3513 bfd_put_32 (stub_bfd, MOVT_A0_3 | (((sym_value >> 16) & 0xffff) << 3),
3514 loc);
3515
3516 bfd_put_32 (stub_bfd, JUMP_A0_3 | ((sym_value & 0xffff) << 3), loc + 4);
3517
3518 size = 8;
3519 break;
3520 default:
3521 BFD_FAIL ();
3522 return FALSE;
3523 }
3524
3525 stub_sec->size += size;
3526 return TRUE;
3527 }
3528
3529 /* As above, but don't actually build the stub. Just bump offset so
3530 we know stub section sizes. */
3531
3532 static bfd_boolean
3533 metag_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
3534 {
3535 struct elf_metag_stub_hash_entry *hsh;
3536 int size = 0;
3537
3538 /* Massage our args to the form they really have. */
3539 hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
3540
3541 if (hsh->stub_type == metag_stub_long_branch)
3542 size = 8;
3543 else if (hsh->stub_type == metag_stub_long_branch_shared)
3544 size = 12;
3545
3546 hsh->stub_sec->size += size;
3547 return TRUE;
3548 }
3549
3550 /* Set up various things so that we can make a list of input sections
3551 for each output section included in the link. Returns -1 on error,
3552 0 when no stubs will be needed, and 1 on success. */
3553
3554 int
3555 elf_metag_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3556 {
3557 bfd *input_bfd;
3558 unsigned int bfd_count;
3559 unsigned int top_id, top_index;
3560 asection *section;
3561 asection **input_list, **list;
3562 bfd_size_type amt;
3563 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3564
3565 /* Count the number of input BFDs and find the top input section id. */
3566 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3567 input_bfd != NULL;
3568 input_bfd = input_bfd->link.next)
3569 {
3570 bfd_count += 1;
3571 for (section = input_bfd->sections;
3572 section != NULL;
3573 section = section->next)
3574 {
3575 if (top_id < section->id)
3576 top_id = section->id;
3577 }
3578 }
3579
3580 htab->bfd_count = bfd_count;
3581
3582 amt = sizeof (struct map_stub) * (top_id + 1);
3583 htab->stub_group = bfd_zmalloc (amt);
3584 if (htab->stub_group == NULL)
3585 return -1;
3586
3587 /* We can't use output_bfd->section_count here to find the top output
3588 section index as some sections may have been removed, and
3589 strip_excluded_output_sections doesn't renumber the indices. */
3590 for (section = output_bfd->sections, top_index = 0;
3591 section != NULL;
3592 section = section->next)
3593 {
3594 if (top_index < section->index)
3595 top_index = section->index;
3596 }
3597
3598 htab->top_index = top_index;
3599 amt = sizeof (asection *) * (top_index + 1);
3600 input_list = bfd_malloc (amt);
3601 htab->input_list = input_list;
3602 if (input_list == NULL)
3603 return -1;
3604
3605 /* For sections we aren't interested in, mark their entries with a
3606 value we can check later. */
3607 list = input_list + top_index;
3608 do
3609 *list = bfd_abs_section_ptr;
3610 while (list-- != input_list);
3611
3612 for (section = output_bfd->sections;
3613 section != NULL;
3614 section = section->next)
3615 {
3616 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
3617 * have PC relative relocs in them but no code flag set. */
3618 if (((section->flags & SEC_CODE) != 0) ||
3619 strcmp(".ctors", section->name) ||
3620 strcmp(".dtors", section->name))
3621 input_list[section->index] = NULL;
3622 }
3623
3624 return 1;
3625 }
3626
3627 /* The linker repeatedly calls this function for each input section,
3628 in the order that input sections are linked into output sections.
3629 Build lists of input sections to determine groupings between which
3630 we may insert linker stubs. */
3631
3632 void
3633 elf_metag_next_input_section (struct bfd_link_info *info, asection *isec)
3634 {
3635 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3636
3637 if (isec->output_section->index <= htab->top_index)
3638 {
3639 asection **list = htab->input_list + isec->output_section->index;
3640 if (*list != bfd_abs_section_ptr)
3641 {
3642 /* Steal the link_sec pointer for our list. */
3643 #define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3644 /* This happens to make the list in reverse order,
3645 which is what we want. */
3646 PREV_SEC (isec) = *list;
3647 *list = isec;
3648 }
3649 }
3650 }
3651
3652 /* See whether we can group stub sections together. Grouping stub
3653 sections may result in fewer stubs. More importantly, we need to
3654 put all .init* and .fini* stubs at the beginning of the .init or
3655 .fini output sections respectively, because glibc splits the
3656 _init and _fini functions into multiple parts. Putting a stub in
3657 the middle of a function is not a good idea. */
3658
3659 static void
3660 group_sections (struct elf_metag_link_hash_table *htab,
3661 bfd_size_type stub_group_size,
3662 bfd_boolean stubs_always_before_branch)
3663 {
3664 asection **list = htab->input_list + htab->top_index;
3665 do
3666 {
3667 asection *tail = *list;
3668 if (tail == bfd_abs_section_ptr)
3669 continue;
3670 while (tail != NULL)
3671 {
3672 asection *curr;
3673 asection *prev;
3674 bfd_size_type total;
3675 bfd_boolean big_sec;
3676
3677 curr = tail;
3678 total = tail->size;
3679 big_sec = total >= stub_group_size;
3680
3681 while ((prev = PREV_SEC (curr)) != NULL
3682 && ((total += curr->output_offset - prev->output_offset)
3683 < stub_group_size))
3684 curr = prev;
3685
3686 /* OK, the size from the start of CURR to the end is less
3687 than stub_group_size bytes and thus can be handled by one stub
3688 section. (or the tail section is itself larger than
3689 stub_group_size bytes, in which case we may be toast.)
3690 We should really be keeping track of the total size of
3691 stubs added here, as stubs contribute to the final output
3692 section size. */
3693 do
3694 {
3695 prev = PREV_SEC (tail);
3696 /* Set up this stub group. */
3697 htab->stub_group[tail->id].link_sec = curr;
3698 }
3699 while (tail != curr && (tail = prev) != NULL);
3700
3701 /* But wait, there's more! Input sections up to stub_group_size
3702 bytes before the stub section can be handled by it too.
3703 Don't do this if we have a really large section after the
3704 stubs, as adding more stubs increases the chance that
3705 branches may not reach into the stub section. */
3706 if (!stubs_always_before_branch && !big_sec)
3707 {
3708 total = 0;
3709 while (prev != NULL
3710 && ((total += tail->output_offset - prev->output_offset)
3711 < stub_group_size))
3712 {
3713 tail = prev;
3714 prev = PREV_SEC (tail);
3715 htab->stub_group[tail->id].link_sec = curr;
3716 }
3717 }
3718 tail = prev;
3719 }
3720 }
3721 while (list-- != htab->input_list);
3722 free (htab->input_list);
3723 #undef PREV_SEC
3724 }
3725
3726 /* Read in all local syms for all input bfds.
3727 Returns -1 on error, 0 otherwise. */
3728
3729 static int
3730 get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
3731 struct bfd_link_info *info)
3732 {
3733 unsigned int bfd_indx;
3734 Elf_Internal_Sym *local_syms, **all_local_syms;
3735 int stub_changed = 0;
3736 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3737
3738 /* We want to read in symbol extension records only once. To do this
3739 we need to read in the local symbols in parallel and save them for
3740 later use; so hold pointers to the local symbols in an array. */
3741 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3742 all_local_syms = bfd_zmalloc (amt);
3743 htab->all_local_syms = all_local_syms;
3744 if (all_local_syms == NULL)
3745 return -1;
3746
3747 /* Walk over all the input BFDs, swapping in local symbols. */
3748 for (bfd_indx = 0;
3749 input_bfd != NULL;
3750 input_bfd = input_bfd->link.next, bfd_indx++)
3751 {
3752 Elf_Internal_Shdr *symtab_hdr;
3753
3754 /* We'll need the symbol table in a second. */
3755 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3756 if (symtab_hdr->sh_info == 0)
3757 continue;
3758
3759 /* We need an array of the local symbols attached to the input bfd. */
3760 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3761 if (local_syms == NULL)
3762 {
3763 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3764 symtab_hdr->sh_info, 0,
3765 NULL, NULL, NULL);
3766 /* Cache them for elf_link_input_bfd. */
3767 symtab_hdr->contents = (unsigned char *) local_syms;
3768 }
3769 if (local_syms == NULL)
3770 return -1;
3771
3772 all_local_syms[bfd_indx] = local_syms;
3773 }
3774
3775 return stub_changed;
3776 }
3777
3778 /* Determine and set the size of the stub section for a final link.
3779
3780 The basic idea here is to examine all the relocations looking for
3781 PC-relative calls to a target that is unreachable with a "CALLR"
3782 instruction. */
3783
3784 /* See elf32-hppa.c and elf64-ppc.c. */
3785
3786 bfd_boolean
3787 elf_metag_size_stubs(bfd *output_bfd, bfd *stub_bfd,
3788 struct bfd_link_info *info,
3789 bfd_signed_vma group_size,
3790 asection * (*add_stub_section) (const char *, asection *),
3791 void (*layout_sections_again) (void))
3792 {
3793 bfd_size_type stub_group_size;
3794 bfd_boolean stubs_always_before_branch;
3795 bfd_boolean stub_changed;
3796 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3797
3798 /* Stash our params away. */
3799 htab->stub_bfd = stub_bfd;
3800 htab->add_stub_section = add_stub_section;
3801 htab->layout_sections_again = layout_sections_again;
3802 stubs_always_before_branch = group_size < 0;
3803 if (group_size < 0)
3804 stub_group_size = -group_size;
3805 else
3806 stub_group_size = group_size;
3807 if (stub_group_size == 1)
3808 {
3809 /* Default values. */
3810 /* FIXME: not sure what these values should be */
3811 if (stubs_always_before_branch)
3812 {
3813 stub_group_size = (1 << BRANCH_BITS);
3814 }
3815 else
3816 {
3817 stub_group_size = (1 << BRANCH_BITS);
3818 }
3819 }
3820
3821 group_sections (htab, stub_group_size, stubs_always_before_branch);
3822
3823 switch (get_local_syms (output_bfd, info->input_bfds, info))
3824 {
3825 default:
3826 if (htab->all_local_syms)
3827 goto error_ret_free_local;
3828 return FALSE;
3829
3830 case 0:
3831 stub_changed = FALSE;
3832 break;
3833
3834 case 1:
3835 stub_changed = TRUE;
3836 break;
3837 }
3838
3839 while (1)
3840 {
3841 bfd *input_bfd;
3842 unsigned int bfd_indx;
3843 asection *stub_sec;
3844
3845 for (input_bfd = info->input_bfds, bfd_indx = 0;
3846 input_bfd != NULL;
3847 input_bfd = input_bfd->link.next, bfd_indx++)
3848 {
3849 Elf_Internal_Shdr *symtab_hdr;
3850 asection *section;
3851 Elf_Internal_Sym *local_syms;
3852
3853 /* We'll need the symbol table in a second. */
3854 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3855 if (symtab_hdr->sh_info == 0)
3856 continue;
3857
3858 local_syms = htab->all_local_syms[bfd_indx];
3859
3860 /* Walk over each section attached to the input bfd. */
3861 for (section = input_bfd->sections;
3862 section != NULL;
3863 section = section->next)
3864 {
3865 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3866
3867 /* If there aren't any relocs, then there's nothing more
3868 to do. */
3869 if ((section->flags & SEC_RELOC) == 0
3870 || section->reloc_count == 0)
3871 continue;
3872
3873 /* If this section is a link-once section that will be
3874 discarded, then don't create any stubs. */
3875 if (section->output_section == NULL
3876 || section->output_section->owner != output_bfd)
3877 continue;
3878
3879 /* Get the relocs. */
3880 internal_relocs
3881 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3882 info->keep_memory);
3883 if (internal_relocs == NULL)
3884 goto error_ret_free_local;
3885
3886 /* Now examine each relocation. */
3887 irela = internal_relocs;
3888 irelaend = irela + section->reloc_count;
3889 for (; irela < irelaend; irela++)
3890 {
3891 unsigned int r_type, r_indx;
3892 enum elf_metag_stub_type stub_type;
3893 struct elf_metag_stub_hash_entry *hsh;
3894 asection *sym_sec;
3895 bfd_vma sym_value;
3896 bfd_vma destination;
3897 struct elf_metag_link_hash_entry *hh;
3898 char *stub_name;
3899 const asection *id_sec;
3900
3901 r_type = ELF32_R_TYPE (irela->r_info);
3902 r_indx = ELF32_R_SYM (irela->r_info);
3903
3904 if (r_type >= (unsigned int) R_METAG_MAX)
3905 {
3906 bfd_set_error (bfd_error_bad_value);
3907 error_ret_free_internal:
3908 if (elf_section_data (section)->relocs == NULL)
3909 free (internal_relocs);
3910 goto error_ret_free_local;
3911 }
3912
3913 /* Only look for stubs on CALLR and B instructions. */
3914 if (!(r_type == (unsigned int) R_METAG_RELBRANCH ||
3915 r_type == (unsigned int) R_METAG_RELBRANCH_PLT))
3916 continue;
3917
3918 /* Now determine the call target, its name, value,
3919 section. */
3920 sym_sec = NULL;
3921 sym_value = 0;
3922 destination = 0;
3923 hh = NULL;
3924 if (r_indx < symtab_hdr->sh_info)
3925 {
3926 /* It's a local symbol. */
3927 Elf_Internal_Sym *sym;
3928 Elf_Internal_Shdr *hdr;
3929 unsigned int shndx;
3930
3931 sym = local_syms + r_indx;
3932 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3933 sym_value = sym->st_value;
3934 shndx = sym->st_shndx;
3935 if (shndx < elf_numsections (input_bfd))
3936 {
3937 hdr = elf_elfsections (input_bfd)[shndx];
3938 sym_sec = hdr->bfd_section;
3939 destination = (sym_value + irela->r_addend
3940 + sym_sec->output_offset
3941 + sym_sec->output_section->vma);
3942 }
3943 }
3944 else
3945 {
3946 /* It's an external symbol. */
3947 int e_indx;
3948
3949 e_indx = r_indx - symtab_hdr->sh_info;
3950 hh = ((struct elf_metag_link_hash_entry *)
3951 elf_sym_hashes (input_bfd)[e_indx]);
3952
3953 while (hh->eh.root.type == bfd_link_hash_indirect
3954 || hh->eh.root.type == bfd_link_hash_warning)
3955 hh = ((struct elf_metag_link_hash_entry *)
3956 hh->eh.root.u.i.link);
3957
3958 if (hh->eh.root.type == bfd_link_hash_defined
3959 || hh->eh.root.type == bfd_link_hash_defweak)
3960 {
3961 sym_sec = hh->eh.root.u.def.section;
3962 sym_value = hh->eh.root.u.def.value;
3963 if (hh->eh.plt.offset != (bfd_vma) -1
3964 && hh->eh.dynindx != -1
3965 && r_type == (unsigned int) R_METAG_RELBRANCH_PLT)
3966 {
3967 sym_sec = htab->etab.splt;
3968 sym_value = hh->eh.plt.offset;
3969 }
3970
3971 if (sym_sec->output_section != NULL)
3972 destination = (sym_value + irela->r_addend
3973 + sym_sec->output_offset
3974 + sym_sec->output_section->vma);
3975 else
3976 continue;
3977 }
3978 else if (hh->eh.root.type == bfd_link_hash_undefweak)
3979 {
3980 if (! bfd_link_pic (info))
3981 continue;
3982 }
3983 else if (hh->eh.root.type == bfd_link_hash_undefined)
3984 {
3985 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3986 && (ELF_ST_VISIBILITY (hh->eh.other)
3987 == STV_DEFAULT)))
3988 continue;
3989 }
3990 else
3991 {
3992 bfd_set_error (bfd_error_bad_value);
3993 goto error_ret_free_internal;
3994 }
3995 }
3996
3997 /* Determine what (if any) linker stub is needed. */
3998 stub_type = metag_type_of_stub (section, irela, hh,
3999 destination, info);
4000 if (stub_type == metag_stub_none)
4001 continue;
4002
4003 /* Support for grouping stub sections. */
4004 id_sec = htab->stub_group[section->id].link_sec;
4005
4006 /* Get the name of this stub. */
4007 stub_name = metag_stub_name (id_sec, sym_sec, hh, irela);
4008 if (!stub_name)
4009 goto error_ret_free_internal;
4010
4011 hsh = metag_stub_hash_lookup (&htab->bstab,
4012 stub_name,
4013 FALSE, FALSE);
4014 if (hsh != NULL)
4015 {
4016 /* The proper stub has already been created. */
4017 free (stub_name);
4018 continue;
4019 }
4020
4021 hsh = metag_add_stub (stub_name, section, htab);
4022 if (hsh == NULL)
4023 {
4024 free (stub_name);
4025 goto error_ret_free_internal;
4026 }
4027 hsh->target_value = sym_value;
4028 hsh->target_section = sym_sec;
4029 hsh->stub_type = stub_type;
4030 hsh->hh = hh;
4031 hsh->addend = irela->r_addend;
4032 stub_changed = TRUE;
4033 }
4034
4035 /* We're done with the internal relocs, free them. */
4036 if (elf_section_data (section)->relocs == NULL)
4037 free (internal_relocs);
4038 }
4039 }
4040
4041 if (!stub_changed)
4042 break;
4043
4044 /* OK, we've added some stubs. Find out the new size of the
4045 stub sections. */
4046 for (stub_sec = htab->stub_bfd->sections;
4047 stub_sec != NULL;
4048 stub_sec = stub_sec->next)
4049 stub_sec->size = 0;
4050
4051 bfd_hash_traverse (&htab->bstab, metag_size_one_stub, htab);
4052
4053 /* Ask the linker to do its stuff. */
4054 (*htab->layout_sections_again) ();
4055 stub_changed = FALSE;
4056 }
4057
4058 free (htab->all_local_syms);
4059 return TRUE;
4060
4061 error_ret_free_local:
4062 free (htab->all_local_syms);
4063 return FALSE;
4064 }
4065
4066 /* Build all the stubs associated with the current output file. The
4067 stubs are kept in a hash table attached to the main linker hash
4068 table. This function is called via metagelf_finish in the linker. */
4069
4070 bfd_boolean
4071 elf_metag_build_stubs (struct bfd_link_info *info)
4072 {
4073 asection *stub_sec;
4074 struct bfd_hash_table *table;
4075 struct elf_metag_link_hash_table *htab;
4076
4077 htab = metag_link_hash_table (info);
4078
4079 for (stub_sec = htab->stub_bfd->sections;
4080 stub_sec != NULL;
4081 stub_sec = stub_sec->next)
4082 {
4083 bfd_size_type size;
4084
4085 /* Allocate memory to hold the linker stubs. */
4086 size = stub_sec->size;
4087 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
4088 if (stub_sec->contents == NULL && size != 0)
4089 return FALSE;
4090 stub_sec->size = 0;
4091 }
4092
4093 /* Build the stubs as directed by the stub hash table. */
4094 table = &htab->bstab;
4095 bfd_hash_traverse (table, metag_build_one_stub, info);
4096
4097 return TRUE;
4098 }
4099
4100 /* Return TRUE if SYM represents a local label symbol. */
4101
4102 static bfd_boolean
4103 elf_metag_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
4104 {
4105 if (name[0] == '$' && name[1] == 'L')
4106 return 1;
4107 return _bfd_elf_is_local_label_name (abfd, name);
4108 }
4109
4110 /* Return address for Ith PLT stub in section PLT, for relocation REL
4111 or (bfd_vma) -1 if it should not be included. */
4112
4113 static bfd_vma
4114 elf_metag_plt_sym_val (bfd_vma i, const asection *plt,
4115 const arelent *rel ATTRIBUTE_UNUSED)
4116 {
4117 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4118 }
4119
4120 #define ELF_ARCH bfd_arch_metag
4121 #define ELF_TARGET_ID METAG_ELF_DATA
4122 #define ELF_MACHINE_CODE EM_METAG
4123 #define ELF_MINPAGESIZE 0x1000
4124 #define ELF_MAXPAGESIZE 0x4000
4125 #define ELF_COMMONPAGESIZE 0x1000
4126
4127 #define TARGET_LITTLE_SYM metag_elf32_vec
4128 #define TARGET_LITTLE_NAME "elf32-metag"
4129
4130 #define elf_symbol_leading_char '_'
4131
4132 #define elf_info_to_howto_rel NULL
4133 #define elf_info_to_howto metag_info_to_howto_rela
4134
4135 #define bfd_elf32_bfd_is_local_label_name elf_metag_is_local_label_name
4136 #define bfd_elf32_bfd_link_hash_table_create \
4137 elf_metag_link_hash_table_create
4138 #define elf_backend_relocate_section elf_metag_relocate_section
4139 #define elf_backend_gc_mark_hook elf_metag_gc_mark_hook
4140 #define elf_backend_check_relocs elf_metag_check_relocs
4141 #define elf_backend_create_dynamic_sections elf_metag_create_dynamic_sections
4142 #define elf_backend_adjust_dynamic_symbol elf_metag_adjust_dynamic_symbol
4143 #define elf_backend_finish_dynamic_symbol elf_metag_finish_dynamic_symbol
4144 #define elf_backend_finish_dynamic_sections elf_metag_finish_dynamic_sections
4145 #define elf_backend_size_dynamic_sections elf_metag_size_dynamic_sections
4146 #define elf_backend_omit_section_dynsym \
4147 _bfd_elf_omit_section_dynsym_all
4148 #define elf_backend_post_process_headers elf_metag_post_process_headers
4149 #define elf_backend_reloc_type_class elf_metag_reloc_type_class
4150 #define elf_backend_copy_indirect_symbol elf_metag_copy_indirect_symbol
4151 #define elf_backend_plt_sym_val elf_metag_plt_sym_val
4152
4153 #define elf_backend_can_gc_sections 1
4154 #define elf_backend_can_refcount 1
4155 #define elf_backend_rela_normal 1
4156 #define elf_backend_want_got_plt 1
4157 #define elf_backend_want_got_sym 0
4158 #define elf_backend_want_plt_sym 0
4159 #define elf_backend_plt_readonly 1
4160 #define elf_backend_dtrel_excludes_plt 1
4161 #define elf_backend_want_dynrelro 1
4162
4163 #define bfd_elf32_bfd_reloc_type_lookup metag_reloc_type_lookup
4164 #define bfd_elf32_bfd_reloc_name_lookup metag_reloc_name_lookup
4165
4166 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.122383 seconds and 4 git commands to generate.