projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix reconnecting to a gdbserver already debugging multiple processes, II
[deliverable/binutils-gdb.git] / bfd / elf32-metag.c
CommitLineData
a3c62988 1/* Meta support for 32-bit ELF
b3adc24a 2 Copyright (C) 2013-2020 Free Software Foundation, Inc.
a3c62988
NC		 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
37static 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
46static 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
55static 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
64static 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
07d6d2b8
AM		 76 Structure/Variable Prefix
77 elf_link_hash_table "etab"
78 elf_link_hash_entry "eh"
a3c62988 79
07d6d2b8
AM		 80 elf_metag_link_hash_table "htab"
81 elf_metag_link_hash_entry "hh"
a3c62988 82
07d6d2b8
AM		 83 bfd_link_hash_table "btab"
84 bfd_link_hash_entry "bh"
a3c62988
NC		 85
86 bfd_hash_table containing stubs "bstab"
07d6d2b8 87 elf_metag_stub_hash_entry "hsh"
a3c62988 88
a3c62988
NC		 89 Always remember to use GNU Coding Style. */
90
91#define PLT_ENTRY_SIZE sizeof(plt_entry)
92
93static 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 */
6346d5ca 143 3, /* size (0 = byte, 1 = short, 2 = long) */
a3c62988
NC		 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
694struct metag_reloc_map
695{
696 bfd_reloc_code_real_type bfd_reloc_val;
697 unsigned int metag_reloc_val;
698};
699
700static const struct metag_reloc_map metag_reloc_map [] =
701 {
07d6d2b8
AM		 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 },
a3c62988
NC		 706 { BFD_RELOC_METAG_RELBRANCH, R_METAG_RELBRANCH },
707 { BFD_RELOC_METAG_GETSETOFF, R_METAG_GETSETOFF },
07d6d2b8
AM		 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 },
a3c62988
NC		 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 },
07d6d2b8
AM		 718 { BFD_RELOC_METAG_HI16_PLT, R_METAG_HI16_PLT },
719 { BFD_RELOC_METAG_LO16_PLT, R_METAG_LO16_PLT },
a3c62988 720 { BFD_RELOC_METAG_RELBRANCH_PLT, R_METAG_RELBRANCH_PLT },
07d6d2b8
AM		 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 },
a3c62988
NC		 729 { BFD_RELOC_METAG_TLS_LDO_HI16, R_METAG_TLS_LDO_HI16 },
730 { BFD_RELOC_METAG_TLS_LDO_LO16, R_METAG_TLS_LDO_LO16 },
07d6d2b8
AM		 731 { BFD_RELOC_METAG_TLS_LDO, R_METAG_TLS_LDO },
732 { BFD_RELOC_METAG_TLS_IE, R_METAG_TLS_IE },
a3c62988
NC		 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 },
07d6d2b8 739 { BFD_RELOC_METAG_TLS_LE, R_METAG_TLS_LE },
a3c62988
NC		 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
744enum elf_metag_stub_type
745{
746 metag_stub_long_branch,
747 metag_stub_long_branch_shared,
748 metag_stub_none
749};
750
751struct 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
780struct 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. */
3bf083ed 790 struct elf_dyn_relocs *dyn_relocs;
a3c62988
NC		 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
798struct 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;
7292b3ac 826 unsigned int top_index;
a3c62988
NC		 827 asection **input_list;
828 Elf_Internal_Sym **all_local_syms;
829
a3c62988
NC		 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. */
844static bfd_vma
845dtpoff_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 */
854static bfd_vma
855tpoff (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
f3185997 867static bfd_boolean
0aa13fee 868metag_info_to_howto_rela (bfd *abfd,
a3c62988
NC		 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);
5860e3f8
NC		 875 if (r_type >= (unsigned int) R_METAG_MAX)
876 {
695344c0 877 /* xgettext:c-format */
0aa13fee
AM		 878 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
879 abfd, r_type);
f3185997
NC		 880 bfd_set_error (bfd_error_bad_value);
881 return FALSE;
5860e3f8 882 }
a3c62988 883 cache_ptr->howto = & elf_metag_howto_table [r_type];
f3185997 884 return TRUE;
a3c62988
NC		 885}
886
887static reloc_howto_type *
888metag_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
889 bfd_reloc_code_real_type code)
890{
891 unsigned int i;
892
893 for (i = 0; i < sizeof (metag_reloc_map) / sizeof (metag_reloc_map[0]); i++)
894 if (metag_reloc_map [i].bfd_reloc_val == code)
895 return & elf_metag_howto_table [metag_reloc_map[i].metag_reloc_val];
896
897 return NULL;
898}
899
900static reloc_howto_type *
901metag_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
902 const char *r_name)
903{
904 unsigned int i;
905
906 for (i = 0; i < sizeof (elf_metag_howto_table) / sizeof (elf_metag_howto_table[0]); i++)
907 if (elf_metag_howto_table[i].name != NULL
908 && strcasecmp (elf_metag_howto_table[i].name, r_name) == 0)
909 return &elf_metag_howto_table[i];
910
911 return NULL;
912}
913
914/* Various hash macros and functions. */
915#define metag_link_hash_table(p) \
916 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
917 == METAG_ELF_DATA ? ((struct elf_metag_link_hash_table *) ((p)->hash)) : NULL)
918
919#define metag_elf_hash_entry(ent) \
920 ((struct elf_metag_link_hash_entry *)(ent))
921
922#define metag_stub_hash_entry(ent) \
923 ((struct elf_metag_stub_hash_entry *)(ent))
924
925#define metag_stub_hash_lookup(table, string, create, copy) \
926 ((struct elf_metag_stub_hash_entry *) \
927 bfd_hash_lookup ((table), (string), (create), (copy)))
928
929#define metag_elf_local_got_tls_type(abfd) \
930 ((char *)(elf_local_got_offsets (abfd) + (elf_tdata (abfd)->symtab_hdr.sh_info)))
931
932/* Assorted hash table functions. */
933
934/* Initialize an entry in the stub hash table. */
935
936static struct bfd_hash_entry *
937stub_hash_newfunc (struct bfd_hash_entry *entry,
938 struct bfd_hash_table *table,
939 const char *string)
940{
941 /* Allocate the structure if it has not already been allocated by a
942 subclass. */
943 if (entry == NULL)
944 {
945 entry = bfd_hash_allocate (table,
946 sizeof (struct elf_metag_stub_hash_entry));
947 if (entry == NULL)
948 return entry;
949 }
950
951 /* Call the allocation method of the superclass. */
952 entry = bfd_hash_newfunc (entry, table, string);
953 if (entry != NULL)
954 {
955 struct elf_metag_stub_hash_entry *hsh;
956
957 /* Initialize the local fields. */
958 hsh = (struct elf_metag_stub_hash_entry *) entry;
959 hsh->stub_sec = NULL;
960 hsh->stub_offset = 0;
961 hsh->target_value = 0;
962 hsh->target_section = NULL;
963 hsh->stub_type = metag_stub_long_branch;
964 hsh->hh = NULL;
965 hsh->id_sec = NULL;
966 }
967
968 return entry;
969}
970
971/* Initialize an entry in the link hash table. */
972
973static struct bfd_hash_entry *
974metag_link_hash_newfunc (struct bfd_hash_entry *entry,
975 struct bfd_hash_table *table,
976 const char *string)
977{
978 /* Allocate the structure if it has not already been allocated by a
979 subclass. */
980 if (entry == NULL)
981 {
982 entry = bfd_hash_allocate (table,
983 sizeof (struct elf_metag_link_hash_entry));
984 if (entry == NULL)
985 return entry;
986 }
987
988 /* Call the allocation method of the superclass. */
989 entry = _bfd_elf_link_hash_newfunc (entry, table, string);
990 if (entry != NULL)
991 {
992 struct elf_metag_link_hash_entry *hh;
993
994 /* Initialize the local fields. */
995 hh = (struct elf_metag_link_hash_entry *) entry;
996 hh->hsh_cache = NULL;
997 hh->dyn_relocs = NULL;
998 hh->tls_type = GOT_UNKNOWN;
999 }
1000
1001 return entry;
1002}
1003
68faa637
AM		 1004/* Free the derived linker hash table. */
1005
1006static void
d495ab0d 1007elf_metag_link_hash_table_free (bfd *obfd)
68faa637
AM		 1008{
1009 struct elf_metag_link_hash_table *htab
d495ab0d 1010 = (struct elf_metag_link_hash_table *) obfd->link.hash;
68faa637
AM		 1011
1012 bfd_hash_table_free (&htab->bstab);
d495ab0d 1013 _bfd_elf_link_hash_table_free (obfd);
68faa637
AM		 1014}
1015
a3c62988
NC		 1016/* Create the derived linker hash table. The Meta ELF port uses the derived
1017 hash table to keep information specific to the Meta ELF linker (without
1018 using static variables). */
1019
1020static struct bfd_link_hash_table *
1021elf_metag_link_hash_table_create (bfd *abfd)
1022{
1023 struct elf_metag_link_hash_table *htab;
1024 bfd_size_type amt = sizeof (*htab);
1025
7bf52ea2 1026 htab = bfd_zmalloc (amt);
a3c62988
NC		 1027 if (htab == NULL)
1028 return NULL;
1029
1030 if (!_bfd_elf_link_hash_table_init (&htab->etab, abfd,
1031 metag_link_hash_newfunc,
1032 sizeof (struct elf_metag_link_hash_entry),
1033 METAG_ELF_DATA))
1034 {
1035 free (htab);
1036 return NULL;
1037 }
1038
1039 /* Init the stub hash table too. */
1040 if (!bfd_hash_table_init (&htab->bstab, stub_hash_newfunc,
1041 sizeof (struct elf_metag_stub_hash_entry)))
d495ab0d
AM		 1042 {
1043 _bfd_elf_link_hash_table_free (abfd);
1044 return NULL;
1045 }
1046 htab->etab.root.hash_table_free = elf_metag_link_hash_table_free;
a3c62988 1047
a3c62988
NC		 1048 return &htab->etab.root;
1049}
1050
a3c62988
NC		 1051/* Section name for stubs is the associated section name plus this
1052 string. */
1053#define STUB_SUFFIX ".stub"
1054
1055/* Build a name for an entry in the stub hash table. */
1056
1057static char *
1058metag_stub_name (const asection *input_section,
1059 const asection *sym_sec,
1060 const struct elf_metag_link_hash_entry *hh,
1061 const Elf_Internal_Rela *rel)
1062{
1063 char *stub_name;
1064 bfd_size_type len;
1065
1066 if (hh)
1067 {
1068 len = 8 + 1 + strlen (hh->eh.root.root.string) + 1 + 8 + 1;
1069 stub_name = bfd_malloc (len);
1070 if (stub_name != NULL)
1071 {
1072 sprintf (stub_name, "%08x_%s+%x",
1073 input_section->id & 0xffffffff,
1074 hh->eh.root.root.string,
1075 (int) rel->r_addend & 0xffffffff);
1076 }
1077 }
1078 else
1079 {
1080 len = 8 + 1 + 8 + 1 + 8 + 1 + 8 + 1;
1081 stub_name = bfd_malloc (len);
1082 if (stub_name != NULL)
1083 {
1084 sprintf (stub_name, "%08x_%x:%x+%x",
1085 input_section->id & 0xffffffff,
1086 sym_sec->id & 0xffffffff,
1087 (int) ELF32_R_SYM (rel->r_info) & 0xffffffff,
1088 (int) rel->r_addend & 0xffffffff);
1089 }
1090 }
1091 return stub_name;
1092}
1093
1094/* Look up an entry in the stub hash. Stub entries are cached because
1095 creating the stub name takes a bit of time. */
1096
1097static struct elf_metag_stub_hash_entry *
1098metag_get_stub_entry (const asection *input_section,
1099 const asection *sym_sec,
1100 struct elf_metag_link_hash_entry *hh,
1101 const Elf_Internal_Rela *rel,
1102 struct elf_metag_link_hash_table *htab)
1103{
1104 struct elf_metag_stub_hash_entry *hsh;
1105 const asection *id_sec;
1106
1107 /* If this input section is part of a group of sections sharing one
1108 stub section, then use the id of the first section in the group.
1109 Stub names need to include a section id, as there may well be
1110 more than one stub used to reach say, printf, and we need to
1111 distinguish between them. */
1112 id_sec = htab->stub_group[input_section->id].link_sec;
1113
1114 if (hh != NULL && hh->hsh_cache != NULL
1115 && hh->hsh_cache->hh == hh
1116 && hh->hsh_cache->id_sec == id_sec)
1117 {
1118 hsh = hh->hsh_cache;
1119 }
1120 else
1121 {
1122 char *stub_name;
1123
1124 stub_name = metag_stub_name (id_sec, sym_sec, hh, rel);
1125 if (stub_name == NULL)
1126 return NULL;
1127
1128 hsh = metag_stub_hash_lookup (&htab->bstab,
1129 stub_name, FALSE, FALSE);
1130
1131 if (hh != NULL)
1132 hh->hsh_cache = hsh;
1133
1134 free (stub_name);
1135 }
1136
1137 return hsh;
1138}
1139
1140/* Add a new stub entry to the stub hash. Not all fields of the new
1141 stub entry are initialised. */
1142
1143static struct elf_metag_stub_hash_entry *
1144metag_add_stub (const char *stub_name,
1145 asection *section,
1146 struct elf_metag_link_hash_table *htab)
1147{
1148 asection *link_sec;
1149 asection *stub_sec;
1150 struct elf_metag_stub_hash_entry *hsh;
1151
1152 link_sec = htab->stub_group[section->id].link_sec;
1153 stub_sec = htab->stub_group[section->id].stub_sec;
1154 if (stub_sec == NULL)
1155 {
1156 stub_sec = htab->stub_group[link_sec->id].stub_sec;
1157 if (stub_sec == NULL)
1158 {
1159 size_t namelen;
1160 bfd_size_type len;
1161 char *s_name;
1162
1163 namelen = strlen (link_sec->name);
1164 len = namelen + sizeof (STUB_SUFFIX);
1165 s_name = bfd_alloc (htab->stub_bfd, len);
1166 if (s_name == NULL)
1167 return NULL;
1168
1169 memcpy (s_name, link_sec->name, namelen);
1170 memcpy (s_name + namelen, STUB_SUFFIX, sizeof (STUB_SUFFIX));
1171
1172 stub_sec = (*htab->add_stub_section) (s_name, link_sec);
1173 if (stub_sec == NULL)
1174 return NULL;
1175 htab->stub_group[link_sec->id].stub_sec = stub_sec;
1176 }
1177 htab->stub_group[section->id].stub_sec = stub_sec;
1178 }
1179
1180 /* Enter this entry into the linker stub hash table. */
1181 hsh = metag_stub_hash_lookup (&htab->bstab, stub_name,
1182 TRUE, FALSE);
1183 if (hsh == NULL)
1184 {
695344c0 1185 /* xgettext:c-format */
871b3ab2 1186 _bfd_error_handler (_("%pB: cannot create stub entry %s"),
4eca0228 1187 section->owner, stub_name);
a3c62988
NC		 1188 return NULL;
1189 }
1190
1191 hsh->stub_sec = stub_sec;
1192 hsh->stub_offset = 0;
1193 hsh->id_sec = link_sec;
1194 return hsh;
1195}
1196
1197/* Check a signed integer value can be represented in the given number
1198 of bits. */
1199
1200static bfd_boolean
1201within_signed_range (int value, unsigned int bits)
1202{
1203 int min_val = -(1 << (bits - 1));
1204 int max_val = (1 << (bits - 1)) - 1;
1205 return (value <= max_val) && (value >= min_val);
1206}
1207
1208/* Perform a relocation as part of a final link. */
1209
1210static bfd_reloc_status_type
1211metag_final_link_relocate (reloc_howto_type *howto,
1212 bfd *input_bfd,
1213 asection *input_section,
1214 bfd_byte *contents,
1215 Elf_Internal_Rela *rel,
1216 bfd_vma relocation,
1217 struct elf_metag_link_hash_entry *hh,
1218 struct elf_metag_link_hash_table *htab,
1219 asection *sym_sec)
1220{
1221 bfd_reloc_status_type r = bfd_reloc_ok;
1222 bfd_byte *hit_data = contents + rel->r_offset;
1223 int opcode, op_shift, op_extended, l1, l2;
1224 bfd_signed_vma srel, addend = rel->r_addend;
1225 struct elf_metag_stub_hash_entry *hsh = NULL;
1226 bfd_vma location;
1227
1228 /* Find out where we are and where we're going. */
1229 location = (rel->r_offset +
1230 input_section->output_offset +
1231 input_section->output_section->vma);
1232
1233 switch (howto->type)
1234 {
1235 case R_METAG_RELBRANCH:
1236 case R_METAG_RELBRANCH_PLT:
1237 /* Make it a pc relative offset. */
1238 relocation -= location;
1239 break;
1240 case R_METAG_TLS_GD:
1241 case R_METAG_TLS_IE:
1242 relocation -= elf_gp (input_section->output_section->owner);
1243 break;
1244 default:
1245 break;
1246 }
1247
1248 switch (howto->type)
1249 {
1250 case R_METAG_RELBRANCH_PLT:
1251 case R_METAG_RELBRANCH:
1252 opcode = bfd_get_32 (input_bfd, hit_data);
1253
1254 srel = (bfd_signed_vma) relocation;
1255 srel += addend;
1256
1257 /* If the branch is out of reach, then redirect the
1258 call to the local stub for this function. */
1259 if (srel > ((1 << (BRANCH_BITS + 1)) - 1) ||
1260 (srel < - (1 << (BRANCH_BITS + 1))))
1261 {
1262 if (sym_sec == NULL)
1263 break;
1264
1265 hsh = metag_get_stub_entry (input_section, sym_sec,
1266 hh, rel, htab);
1267 if (hsh == NULL)
1268 return bfd_reloc_undefined;
1269
1270 /* Munge up the value and addend so that we call the stub
1271 rather than the procedure directly. */
1272 srel = (hsh->stub_offset
1273 + hsh->stub_sec->output_offset
1274 + hsh->stub_sec->output_section->vma);
1275 srel -= location;
1276 }
1277
1278 srel = srel >> 2;
1279
1280 if (!within_signed_range (srel, BRANCH_BITS))
1281 {
1282 if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1283 srel = 0;
1284 else
1285 return bfd_reloc_overflow;
1286 }
1287
1288 opcode &= ~(0x7ffff << 5);
1289 opcode |= ((srel & 0x7ffff) << 5);
1290
1291 bfd_put_32 (input_bfd, opcode, hit_data);
1292 break;
1293 case R_METAG_GETSETOFF:
1294 case R_METAG_GETSET_GOT:
1295 case R_METAG_GETSET_GOTOFF:
1296 opcode = bfd_get_32 (input_bfd, hit_data);
1297
1298 srel = (bfd_signed_vma) relocation;
1299 srel += addend;
1300
1301 /* Is this a standard or extended GET/SET? */
1302 if ((opcode & 0xf0000000) == 0xa0000000)
1303 {
1304 /* Extended GET/SET. */
1305 l1 = opcode & 0x2;
1306 l2 = opcode & 0x4;
1307 op_extended = 1;
1308 }
1309 else
1310 {
1311 /* Standard GET/SET. */
1312 l1 = opcode & 0x01000000;
1313 l2 = opcode & 0x04000000;
1314 op_extended = 0;
1315 }
1316
1317 /* Calculate the width of the GET/SET and how much we need to
1318 shift the result by. */
1319 if (l2)
1320 if (l1)
1321 op_shift = 3;
1322 else
1323 op_shift = 2;
1324 else
1325 if (l1)
1326 op_shift = 1;
1327 else
1328 op_shift = 0;
1329
1330 /* GET/SET offsets are scaled by the width of the transfer. */
1331 srel = srel >> op_shift;
1332
1333 /* Extended GET/SET has signed 12 bits of offset, standard has
1334 signed 6 bits. */
1335 if (op_extended)
1336 {
1337 if (!within_signed_range (srel, 12))
1338 {
1339 if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1340 srel = 0;
1341 else
1342 return bfd_reloc_overflow;
1343 }
1344 opcode &= ~(0xfff << 7);
1345 opcode |= ((srel & 0xfff) << 7);
1346 }
1347 else
1348 {
1349 if (!within_signed_range (srel, 5))
1350 {
1351 if (hh && hh->eh.root.type == bfd_link_hash_undefweak)
1352 srel = 0;
1353 else
1354 return bfd_reloc_overflow;
1355 }
1356 opcode &= ~(0x3f << 8);
1357 opcode |= ((srel & 0x3f) << 8);
1358 }
1359
1360 bfd_put_32 (input_bfd, opcode, hit_data);
1361 break;
1362 case R_METAG_TLS_GD:
1363 case R_METAG_TLS_LDM:
1364 opcode = bfd_get_32 (input_bfd, hit_data);
1365
1366 if ((bfd_signed_vma)relocation < 0)
1367 {
1368 /* sign extend immediate */
1369 if ((opcode & 0xf2000001) == 0x02000000)
1370 {
1371 /* ADD De.e,Dx.r,#I16 */
1372 /* set SE bit */
1373 opcode |= (1 << 1);
1374 } else
1375 return bfd_reloc_overflow;
1376 }
1377
1378 bfd_put_32 (input_bfd, opcode, hit_data);
1379
1380 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1381 contents, rel->r_offset,
1382 relocation, rel->r_addend);
1383 break;
1384 default:
1385 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1386 contents, rel->r_offset,
1387 relocation, rel->r_addend);
1388 }
1389
1390 return r;
1391}
1392
1393/* This is defined because R_METAG_NONE != 0...
1394 See RELOC_AGAINST_DISCARDED_SECTION for details. */
1395#define METAG_RELOC_AGAINST_DISCARDED_SECTION(info, input_bfd, input_section, \
1396 rel, relend, howto, contents) \
1397 { \
1398 _bfd_clear_contents (howto, input_bfd, input_section, \
0930cb30 1399 contents, rel->r_offset); \
a3c62988 1400 \
0e1862bb 1401 if (bfd_link_relocatable (info) \
a3c62988
NC		 1402 && (input_section->flags & SEC_DEBUGGING)) \
1403 { \
1404 /* Only remove relocations in debug sections since other \
1405 sections may require relocations. */ \
1406 Elf_Internal_Shdr *rel_hdr; \
1407 \
1408 rel_hdr = _bfd_elf_single_rel_hdr (input_section->output_section); \
1409 \
1410 /* Avoid empty output section. */ \
1411 if (rel_hdr->sh_size > rel_hdr->sh_entsize) \
1412 { \
1413 rel_hdr->sh_size -= rel_hdr->sh_entsize; \
1414 rel_hdr = _bfd_elf_single_rel_hdr (input_section); \
1415 rel_hdr->sh_size -= rel_hdr->sh_entsize; \
1416 \
1417 memmove (rel, rel + 1, (relend - rel) * sizeof (*rel)); \
1418 \
1419 input_section->reloc_count--; \
1420 relend--; \
1421 rel--; \
1422 continue; \
1423 } \
1424 } \
1425 \
1426 rel->r_info = R_METAG_NONE; \
1427 rel->r_addend = 0; \
1428 continue; \
1429 }
1430
1431/* Relocate a META ELF section.
1432
1433The RELOCATE_SECTION function is called by the new ELF backend linker
1434to handle the relocations for a section.
1435
1436The relocs are always passed as Rela structures; if the section
1437actually uses Rel structures, the r_addend field will always be
1438zero.
1439
1440This function is responsible for adjusting the section contents as
1441necessary, and (if using Rela relocs and generating a relocatable
1442output file) adjusting the reloc addend as necessary.
1443
1444This function does not have to worry about setting the reloc
1445address or the reloc symbol index.
1446
1447LOCAL_SYMS is a pointer to the swapped in local symbols.
1448
1449LOCAL_SECTIONS is an array giving the section in the input file
1450corresponding to the st_shndx field of each local symbol.
1451
1452The global hash table entry for the global symbols can be found
1453via elf_sym_hashes (input_bfd).
1454
1455When generating relocatable output, this function must handle
1456STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1457going to be the section symbol corresponding to the output
1458section, which means that the addend must be adjusted
1459accordingly. */
1460
1461static bfd_boolean
1462elf_metag_relocate_section (bfd *output_bfd,
1463 struct bfd_link_info *info,
1464 bfd *input_bfd,
1465 asection *input_section,
1466 bfd_byte *contents,
1467 Elf_Internal_Rela *relocs,
1468 Elf_Internal_Sym *local_syms,
1469 asection **local_sections)
1470{
1471 bfd_vma *local_got_offsets;
1472 Elf_Internal_Shdr *symtab_hdr;
1473 struct elf_link_hash_entry **eh_syms;
1474 struct elf_metag_link_hash_table *htab;
1475 Elf_Internal_Rela *rel;
1476 Elf_Internal_Rela *relend;
1477 asection *sreloc;
1478
1479 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1480 eh_syms = elf_sym_hashes (input_bfd);
1481 relend = relocs + input_section->reloc_count;
1482
1483 htab = metag_link_hash_table (info);
1484 local_got_offsets = elf_local_got_offsets (input_bfd);
1485
1486 sreloc = NULL;
1487
1488 for (rel = relocs; rel < relend; rel ++)
1489 {
1490 reloc_howto_type *howto;
1491 unsigned long r_symndx;
1492 Elf_Internal_Sym *sym;
1493 asection *sec;
1494 struct elf_metag_link_hash_entry *hh;
1495 bfd_vma relocation;
1496 bfd_reloc_status_type r;
1497 const char *name;
1498 int r_type;
1499
1500 r_type = ELF32_R_TYPE (rel->r_info);
1501
1502 if (r_type == R_METAG_GNU_VTINHERIT
1503 || r_type == R_METAG_GNU_VTENTRY
1504 || r_type == R_METAG_NONE)
1505 continue;
1506
1507 r_symndx = ELF32_R_SYM (rel->r_info);
1508
1509 howto = elf_metag_howto_table + ELF32_R_TYPE (rel->r_info);
1510 hh = NULL;
1511 sym = NULL;
1512 sec = NULL;
1513
1514 if (r_symndx < symtab_hdr->sh_info)
1515 {
1516 sym = local_syms + r_symndx;
1517 sec = local_sections [r_symndx];
1518 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1519
1520 name = bfd_elf_string_from_elf_section
1521 (input_bfd, symtab_hdr->sh_link, sym->st_name);
fd361982 1522 name = name == NULL ? bfd_section_name (sec) : name;
a3c62988
NC		 1523 }
1524 else
1525 {
1526 struct elf_link_hash_entry *eh;
62d887d4 1527 bfd_boolean unresolved_reloc, warned, ignored;
a3c62988
NC		 1528
1529 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1530 r_symndx, symtab_hdr, eh_syms,
1531 eh, sec, relocation,
62d887d4 1532 unresolved_reloc, warned, ignored);
a3c62988
NC		 1533
1534 name = eh->root.root.string;
1535 hh = (struct elf_metag_link_hash_entry *) eh;
1536 }
1537
1538 if (sec != NULL && discarded_section (sec))
1539 METAG_RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1540 rel, relend, howto, contents);
1541
0e1862bb 1542 if (bfd_link_relocatable (info))
a3c62988
NC		 1543 continue;
1544
1545 switch (r_type)
1546 {
1547 case R_METAG_ADDR32:
1548 case R_METAG_RELBRANCH:
1549 if ((input_section->flags & SEC_ALLOC) == 0)
1550 break;
1551
0e1862bb 1552 if ((bfd_link_pic (info)
a3c62988
NC		 1553 && r_symndx != STN_UNDEF
1554 && (input_section->flags & SEC_ALLOC) != 0
1555 && (r_type != R_METAG_RELBRANCH
1556 || !SYMBOL_CALLS_LOCAL (info, &hh->eh)))
0e1862bb 1557 || (!bfd_link_pic (info)
a3c62988
NC		 1558 && hh != NULL
1559 && hh->eh.dynindx != -1
1560 && !hh->eh.non_got_ref
1561 && ((hh->eh.def_dynamic
1562 && !hh->eh.def_regular)
1563 || hh->eh.root.type == bfd_link_hash_undefweak
1564 || hh->eh.root.type == bfd_link_hash_undefined)))
1565 {
1566 Elf_Internal_Rela outrel;
1567 bfd_boolean skip, relocate;
1568 bfd_byte *loc;
1569
1570 /* When generating a shared object, these relocations
1571 are copied into the output file to be resolved at run
1572 time. */
1573
1574 sreloc = elf_section_data (input_section)->sreloc;
1575 BFD_ASSERT (sreloc != NULL);
1576
1577 skip = FALSE;
1578 relocate = FALSE;
1579
1580 outrel.r_offset = _bfd_elf_section_offset (output_bfd,
1581 info,
1582 input_section,
1583 rel->r_offset);
1584 if (outrel.r_offset == (bfd_vma) -1)
1585 skip = TRUE;
1586 else if (outrel.r_offset == (bfd_vma) -2)
1587 skip = TRUE, relocate = TRUE;
1588 outrel.r_offset += (input_section->output_section->vma
1589 + input_section->output_offset);
1590
1591 if (skip)
1592 {
1593 memset (&outrel, 0, sizeof outrel);
1594 outrel.r_info = ELF32_R_INFO (0, R_METAG_NONE);
1595 }
1596 else if (r_type == R_METAG_RELBRANCH)
1597 {
1598 BFD_ASSERT (hh != NULL && hh->eh.dynindx != -1);
1599 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
1600 outrel.r_addend = rel->r_addend;
1601 }
1602 else
1603 {
1604 /* h->dynindx may be -1 if this symbol was marked to
1605 become local. */
1606 if (hh == NULL
1607 || ((info->symbolic || hh->eh.dynindx == -1)
1608 && hh->eh.def_regular))
1609 {
1610 relocate = TRUE;
1611 outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
1612 outrel.r_addend = relocation + rel->r_addend;
1613 }
1614 else
1615 {
1616 BFD_ASSERT (hh->eh.dynindx != -1);
1617 outrel.r_info = ELF32_R_INFO (hh->eh.dynindx, r_type);
1618 outrel.r_addend = rel->r_addend;
1619 }
1620 }
1621
1622 loc = sreloc->contents;
1623 loc += sreloc->reloc_count * sizeof(Elf32_External_Rela);
1624 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1625 ++sreloc->reloc_count;
1626
1627 /* If this reloc is against an external symbol, we do
1628 not want to fiddle with the addend. Otherwise, we
1629 need to include the symbol value so that it becomes
1630 an addend for the dynamic reloc. */
1631 if (! relocate)
1632 continue;
1633 }
1634 break;
1635
1636 case R_METAG_RELBRANCH_PLT:
1637 /* Relocation is to the entry for this symbol in the
1638 procedure linkage table. */
1639
1640 if (hh == NULL)
1641 break;
1642
1643 if (hh->eh.forced_local)
1644 break;
1645
ce558b89 1646 if (hh->eh.plt.offset == (bfd_vma) -1 || htab->etab.splt == NULL)
a3c62988
NC		 1647 {
1648 /* We didn't make a PLT entry for this symbol. This
1649 happens when statically linking PIC code, or when
1650 using -Bsymbolic. */
1651 break;
1652 }
1653
ce558b89
AM		 1654 relocation = (htab->etab.splt->output_section->vma
1655 + htab->etab.splt->output_offset
a3c62988
NC		 1656 + hh->eh.plt.offset);
1657 break;
1658 case R_METAG_HI16_GOTPC:
1659 case R_METAG_LO16_GOTPC:
ce558b89 1660 BFD_ASSERT (htab->etab.sgot != NULL);
a3c62988 1661
ce558b89
AM		 1662 relocation = (htab->etab.sgot->output_section->vma +
1663 htab->etab.sgot->output_offset);
a3c62988
NC		 1664 relocation += GOT_REG_OFFSET;
1665 relocation -= (input_section->output_section->vma
1666 + input_section->output_offset
1667 + rel->r_offset);
1668 break;
1669 case R_METAG_HI16_GOTOFF:
1670 case R_METAG_LO16_GOTOFF:
1671 case R_METAG_GETSET_GOTOFF:
ce558b89 1672 BFD_ASSERT (htab->etab.sgot != NULL);
a3c62988 1673
ce558b89
AM		 1674 relocation -= (htab->etab.sgot->output_section->vma +
1675 htab->etab.sgot->output_offset);
a3c62988
NC		 1676 relocation -= GOT_REG_OFFSET;
1677 break;
1678 case R_METAG_GETSET_GOT:
1679 {
1680 bfd_vma off;
1681 bfd_boolean do_got = 0;
1682
1683 /* Relocation is to the entry for this symbol in the
1684 global offset table. */
1685 if (hh != NULL)
1686 {
1687 bfd_boolean dyn;
1688
1689 off = hh->eh.got.offset;
1690 dyn = htab->etab.dynamic_sections_created;
0e1862bb
L		 1691 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1692 bfd_link_pic (info),
a3c62988
NC		 1693 &hh->eh))
1694 {
1695 /* If we aren't going to call finish_dynamic_symbol,
1696 then we need to handle initialisation of the .got
1697 entry and create needed relocs here. Since the
1698 offset must always be a multiple of 4, we use the
1699 least significant bit to record whether we have
1700 initialised it already. */
1701 if ((off & 1) != 0)
1702 off &= ~1;
1703 else
1704 {
1705 hh->eh.got.offset |= 1;
1706 do_got = 1;
1707 }
1708 }
1709 }
1710 else
1711 {
1712 /* Local symbol case. */
1713 if (local_got_offsets == NULL)
1714 abort ();
1715
1716 off = local_got_offsets[r_symndx];
1717
1718 /* The offset must always be a multiple of 4. We use
1719 the least significant bit to record whether we have
1720 already generated the necessary reloc. */
1721 if ((off & 1) != 0)
1722 off &= ~1;
1723 else
1724 {
1725 local_got_offsets[r_symndx] |= 1;
1726 do_got = 1;
1727 }
1728 }
1729
1730 if (do_got)
1731 {
0e1862bb 1732 if (bfd_link_pic (info))
a3c62988
NC		 1733 {
1734 /* Output a dynamic relocation for this GOT entry.
1735 In this case it is relative to the base of the
1736 object because the symbol index is zero. */
1737 Elf_Internal_Rela outrel;
1738 bfd_byte *loc;
ce558b89 1739 asection *s = htab->etab.srelgot;
a3c62988
NC		 1740
1741 outrel.r_offset = (off
ce558b89
AM		 1742 + htab->etab.sgot->output_offset
1743 + htab->etab.sgot->output_section->vma);
a3c62988
NC		 1744 outrel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
1745 outrel.r_addend = relocation;
1746 loc = s->contents;
1747 loc += s->reloc_count++ * sizeof (Elf32_External_Rela);
1748 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1749 }
1750 else
1751 bfd_put_32 (output_bfd, relocation,
ce558b89 1752 htab->etab.sgot->contents + off);
a3c62988
NC		 1753 }
1754
1755 if (off >= (bfd_vma) -2)
1756 abort ();
1757
1758 relocation = off - GOT_REG_OFFSET;
1759 }
1760 break;
1761 case R_METAG_TLS_GD:
1762 case R_METAG_TLS_IE:
1763 {
1764 /* XXXMJF There is room here for optimisations. For example
1765 converting from GD->IE, etc. */
1766 bfd_vma off;
1767 int indx;
1768 char tls_type;
1769
ce558b89 1770 if (htab->etab.sgot == NULL)
a3c62988
NC		 1771 abort();
1772
1773 indx = 0;
1774 if (hh != NULL)
1775 {
1776 bfd_boolean dyn;
1777 dyn = htab->etab.dynamic_sections_created;
1778
0e1862bb
L		 1779 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1780 bfd_link_pic (info),
1781 &hh->eh)
1782 && (!bfd_link_pic (info)
a3c62988
NC		 1783 || !SYMBOL_REFERENCES_LOCAL (info, &hh->eh)))
1784 {
1785 indx = hh->eh.dynindx;
1786 }
1787 off = hh->eh.got.offset;
1788 tls_type = hh->tls_type;
1789 }
1790 else
1791 {
1792 /* Local symbol case. */
1793 if (local_got_offsets == NULL)
1794 abort ();
1795
1796 off = local_got_offsets[r_symndx];
1797 tls_type = metag_elf_local_got_tls_type (input_bfd) [r_symndx];
1798 }
1799
1800 if (tls_type == GOT_UNKNOWN)
6ec49e7c 1801 abort ();
a3c62988
NC		 1802
1803 if ((off & 1) != 0)
1804 off &= ~1;
1805 else
1806 {
1807 bfd_boolean need_relocs = FALSE;
1808 Elf_Internal_Rela outrel;
1809 bfd_byte *loc = NULL;
1810 int cur_off = off;
1811
1812 /* The GOT entries have not been initialized yet. Do it
1813 now, and emit any relocations. If both an IE GOT and a
1814 GD GOT are necessary, we emit the GD first. */
1815
0e1862bb 1816 if ((bfd_link_pic (info) || indx != 0)
a3c62988
NC		 1817 && (hh == NULL
1818 || ELF_ST_VISIBILITY (hh->eh.other) == STV_DEFAULT
1819 || hh->eh.root.type != bfd_link_hash_undefweak))
1820 {
1821 need_relocs = TRUE;
ce558b89 1822 loc = htab->etab.srelgot->contents;
a3c62988 1823 /* FIXME (CAO): Should this be reloc_count++ ? */
ce558b89 1824 loc += htab->etab.srelgot->reloc_count * sizeof (Elf32_External_Rela);
a3c62988
NC		 1825 }
1826
1827 if (tls_type & GOT_TLS_GD)
1828 {
1829 if (need_relocs)
1830 {
1831 outrel.r_offset = (cur_off
ce558b89
AM		 1832 + htab->etab.sgot->output_section->vma
1833 + htab->etab.sgot->output_offset);
a3c62988
NC		 1834 outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_DTPMOD);
1835 outrel.r_addend = 0;
ce558b89 1836 bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + cur_off);
a3c62988
NC		 1837
1838 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
ce558b89 1839 htab->etab.srelgot->reloc_count++;
a3c62988
NC		 1840 loc += sizeof (Elf32_External_Rela);
1841
1842 if (indx == 0)
1843 bfd_put_32 (output_bfd, 0,
ce558b89 1844 htab->etab.sgot->contents + cur_off + 4);
a3c62988
NC		 1845 else
1846 {
1847 bfd_put_32 (output_bfd, 0,
ce558b89 1848 htab->etab.sgot->contents + cur_off + 4);
a3c62988
NC		 1849 outrel.r_info = ELF32_R_INFO (indx,
1850 R_METAG_TLS_DTPOFF);
1851 outrel.r_offset += 4;
1852 bfd_elf32_swap_reloca_out (output_bfd,
1853 &outrel, loc);
ce558b89 1854 htab->etab.srelgot->reloc_count++;
a3c62988
NC		 1855 loc += sizeof (Elf32_External_Rela);
1856 }
1857 }
1858 else
1859 {
1860 /* We don't support changing the TLS model. */
6ec49e7c
NC		 1861 /* PR 20675 */
1862 if (bfd_link_pic (info))
871b3ab2 1863 _bfd_error_handler (_("%pB(%pA): multiple TLS models are not supported"),
d42c267e 1864 input_bfd, input_section);
6ec49e7c 1865 else
871b3ab2 1866 _bfd_error_handler (_("%pB(%pA): shared library symbol %s encountered whilst performing a static link"),
6ec49e7c
NC		 1867 input_bfd, input_section, name);
1868 return FALSE;
a3c62988
NC		 1869 }
1870
1871 cur_off += 8;
1872 }
1873
1874 if (tls_type & GOT_TLS_IE)
1875 {
1876 if (need_relocs)
1877 {
1878 outrel.r_offset = (cur_off
ce558b89
AM		 1879 + htab->etab.sgot->output_section->vma
1880 + htab->etab.sgot->output_offset);
a3c62988
NC		 1881 outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_TPOFF);
1882
1883 if (indx == 0)
1884 outrel.r_addend = relocation - dtpoff_base (info);
1885 else
1886 outrel.r_addend = 0;
1887
1888 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
ce558b89 1889 htab->etab.srelgot->reloc_count++;
a3c62988
NC		 1890 loc += sizeof (Elf32_External_Rela);
1891 }
1892 else
1893 bfd_put_32 (output_bfd, tpoff (info, relocation),
ce558b89 1894 htab->etab.sgot->contents + cur_off);
a3c62988
NC		 1895
1896 cur_off += 4;
1897 }
1898
1899 if (hh != NULL)
1900 hh->eh.got.offset |= 1;
1901 else
1902 local_got_offsets[r_symndx] |= 1;
1903 }
1904
1905 /* Add the base of the GOT to the relocation value. */
1906 relocation = off - GOT_REG_OFFSET;
1907
1908 break;
1909 }
1910
1911 case R_METAG_TLS_IENONPIC_HI16:
1912 case R_METAG_TLS_IENONPIC_LO16:
1913 case R_METAG_TLS_LE_HI16:
1914 case R_METAG_TLS_LE_LO16:
0e1862bb 1915 if (bfd_link_pic (info))
a3c62988 1916 {
4eca0228 1917 _bfd_error_handler
695344c0 1918 /* xgettext:c-format */
2dcf00ce
AM		 1919 (_("%pB(%pA+%#" PRIx64 "): "
1920 "%s relocation not permitted in shared object"),
1921 input_bfd, input_section, (uint64_t) rel->r_offset,
1922 howto->name);
a3c62988
NC		 1923 return FALSE;
1924 }
1925 else
1926 relocation = tpoff (info, relocation);
1927 break;
1928 case R_METAG_TLS_LDO_HI16:
1929 case R_METAG_TLS_LDO_LO16:
0e1862bb 1930 if (! bfd_link_pic (info))
a3c62988
NC		 1931 relocation = tpoff (info, relocation);
1932 else
1933 relocation -= dtpoff_base (info);
1934 break;
1935 case R_METAG_TLS_LDM:
1936 {
1937 bfd_vma off;
1938
ce558b89 1939 if (htab->etab.sgot == NULL)
a3c62988
NC		 1940 abort();
1941 off = htab->tls_ldm_got.offset;
1942 if (off & 1)
1943 off &= ~1;
1944 else
1945 {
1946 Elf_Internal_Rela outrel;
1947 bfd_byte *loc;
1948
1949 outrel.r_offset = (off
ce558b89
AM		 1950 + htab->etab.sgot->output_section->vma
1951 + htab->etab.sgot->output_offset);
a3c62988
NC		 1952
1953 outrel.r_addend = 0;
1954 outrel.r_info = ELF32_R_INFO (0, R_METAG_TLS_DTPMOD);
ce558b89
AM		 1955 loc = htab->etab.srelgot->contents;
1956 loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
a3c62988
NC		 1957 bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1958 htab->tls_ldm_got.offset |= 1;
1959 }
1960
1961 relocation = off - GOT_REG_OFFSET;
1962 break;
1963 }
1964 default:
1965 break;
1966 }
1967
1968 r = metag_final_link_relocate (howto, input_bfd, input_section,
1969 contents, rel, relocation, hh, htab,
1970 sec);
1971
1972 if (r != bfd_reloc_ok)
1973 {
1974 const char * msg = (const char *) NULL;
1975
1976 switch (r)
1977 {
1978 case bfd_reloc_overflow:
1a72702b 1979 (*info->callbacks->reloc_overflow)
a3c62988
NC		 1980 (info, (hh ? &hh->eh.root : NULL), name, howto->name,
1981 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1982 break;
1983
1984 case bfd_reloc_undefined:
1a72702b
AM		 1985 (*info->callbacks->undefined_symbol)
1986 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
a3c62988
NC		 1987 break;
1988
1989 case bfd_reloc_outofrange:
1990 msg = _("internal error: out of range error");
1991 break;
1992
1993 case bfd_reloc_notsupported:
1994 msg = _("internal error: unsupported relocation error");
1995 break;
1996
1997 case bfd_reloc_dangerous:
1998 msg = _("internal error: dangerous relocation");
1999 break;
2000
2001 default:
2002 msg = _("internal error: unknown error");
2003 break;
2004 }
2005
2006 if (msg)
1a72702b
AM		 2007 (*info->callbacks->warning) (info, msg, name, input_bfd,
2008 input_section, rel->r_offset);
a3c62988
NC		 2009 }
2010 }
2011
2012 return TRUE;
2013}
2014
2015/* Create the .plt and .got sections, and set up our hash table
2016 short-cuts to various dynamic sections. */
2017
2018static bfd_boolean
2019elf_metag_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2020{
2021 struct elf_metag_link_hash_table *htab;
2022 struct elf_link_hash_entry *eh;
2023 struct bfd_link_hash_entry *bh;
2024 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2025
2026 /* Don't try to create the .plt and .got twice. */
2027 htab = metag_link_hash_table (info);
ce558b89 2028 if (htab->etab.splt != NULL)
a3c62988
NC		 2029 return TRUE;
2030
2031 /* Call the generic code to do most of the work. */
2032 if (! _bfd_elf_create_dynamic_sections (abfd, info))
2033 return FALSE;
2034
ce558b89
AM		 2035 /* The header goes at the start of the dynamic .got section, which
2036 is placed after the dynamic .got.plt section. ie. The header is
2037 not necessarily at the start of the output .got section. */
2038 htab->etab.sgot->size += 12;
a3c62988 2039
ce558b89 2040 /* Define the symbol __GLOBAL_OFFSET_TABLE__ on the header. */
a3c62988
NC		 2041 bh = NULL;
2042 if (!(_bfd_generic_link_add_one_symbol
ce558b89 2043 (info, abfd, "__GLOBAL_OFFSET_TABLE__", BSF_GLOBAL, htab->etab.sgot,
a3c62988
NC		 2044 (bfd_vma) 0, NULL, FALSE, bed->collect, &bh)))
2045 return FALSE;
2046 eh = (struct elf_link_hash_entry *) bh;
2047 eh->def_regular = 1;
2048 eh->type = STT_OBJECT;
2049 eh->other = STV_HIDDEN;
2050
0e1862bb 2051 if (! bfd_link_executable (info)
a3c62988
NC		 2052 && ! bfd_elf_link_record_dynamic_symbol (info, eh))
2053 return FALSE;
2054
ce558b89 2055 htab->etab.hgot = eh;
a3c62988 2056
a3c62988
NC		 2057 return TRUE;
2058}
2059
2060/* Look through the relocs for a section during the first phase, and
2061 calculate needed space in the global offset table, procedure linkage
2062 table, and dynamic reloc sections. At this point we haven't
2063 necessarily read all the input files. */
2064
2065static bfd_boolean
2066elf_metag_check_relocs (bfd *abfd,
2067 struct bfd_link_info *info,
2068 asection *sec,
2069 const Elf_Internal_Rela *relocs)
2070{
2071 Elf_Internal_Shdr *symtab_hdr;
2072 struct elf_link_hash_entry **eh_syms;
2073 const Elf_Internal_Rela *rel;
2074 const Elf_Internal_Rela *rel_end;
2075 struct elf_metag_link_hash_table *htab;
2076 asection *sreloc;
2077 bfd *dynobj;
2078 int tls_type = GOT_UNKNOWN, old_tls_type = GOT_UNKNOWN;
2079
0e1862bb 2080 if (bfd_link_relocatable (info))
a3c62988
NC		 2081 return TRUE;
2082
2083 htab = metag_link_hash_table (info);
2084 dynobj = htab->etab.dynobj;
2085 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2086 eh_syms = elf_sym_hashes (abfd);
2087 sreloc = NULL;
2088
2089 if (htab == NULL)
2090 return FALSE;
2091
2092 rel_end = relocs + sec->reloc_count;
2093 for (rel = relocs; rel < rel_end; rel++)
2094 {
2095 int r_type;
2096 struct elf_metag_link_hash_entry *hh;
1a18f0ae 2097 Elf_Internal_Sym *isym;
a3c62988
NC		 2098 unsigned long r_symndx;
2099
2100 r_symndx = ELF32_R_SYM (rel->r_info);
2101 r_type = ELF32_R_TYPE (rel->r_info);
2102 if (r_symndx < symtab_hdr->sh_info)
1a18f0ae
NC		 2103 {
2104 /* A local symbol. */
2105 isym = bfd_sym_from_r_symndx (&htab->sym_cache,
2106 abfd, r_symndx);
2107 if (isym == NULL)
2108 return FALSE;
2109
2110 hh = NULL;
2111 }
a3c62988
NC		 2112 else
2113 {
1a18f0ae
NC		 2114 isym = NULL;
2115
a3c62988
NC		 2116 hh = (struct elf_metag_link_hash_entry *)
2117 eh_syms[r_symndx - symtab_hdr->sh_info];
2118 while (hh->eh.root.type == bfd_link_hash_indirect
2119 || hh->eh.root.type == bfd_link_hash_warning)
2120 hh = (struct elf_metag_link_hash_entry *) hh->eh.root.u.i.link;
2121 }
2122
2123 /* Some relocs require a global offset table. */
ce558b89 2124 if (htab->etab.sgot == NULL)
a3c62988
NC		 2125 {
2126 switch (r_type)
2127 {
2128 case R_METAG_TLS_GD:
2129 case R_METAG_TLS_LDM:
2130 case R_METAG_TLS_IE:
0e1862bb 2131 if (bfd_link_pic (info))
a3c62988
NC		 2132 info->flags |= DF_STATIC_TLS;
2133 /* Fall through. */
2134
2135 case R_METAG_HI16_GOTOFF:
2136 case R_METAG_LO16_GOTOFF:
2137 case R_METAG_GETSET_GOTOFF:
2138 case R_METAG_GETSET_GOT:
2139 case R_METAG_HI16_GOTPC:
2140 case R_METAG_LO16_GOTPC:
2141 if (dynobj == NULL)
2142 htab->etab.dynobj = dynobj = abfd;
2143 if (!elf_metag_create_dynamic_sections (dynobj, info))
2144 return FALSE;
2145 break;
2146
2147 default:
2148 break;
2149 }
2150 }
2151
2152 switch (r_type)
2153 {
2154 case R_METAG_TLS_IE:
2155 case R_METAG_TLS_GD:
2156 case R_METAG_GETSET_GOT:
2157 switch (r_type)
2158 {
2159 default:
2160 tls_type = GOT_NORMAL;
2161 break;
2162 case R_METAG_TLS_IE:
2163 tls_type = GOT_TLS_IE;
2164 break;
2165 case R_METAG_TLS_GD:
2166 tls_type = GOT_TLS_GD;
2167 break;
2168 }
2169
2170 if (hh != NULL)
2171 {
2172 hh->eh.got.refcount += 1;
2173 old_tls_type = hh->tls_type;
2174 }
2175 else
2176 {
2177 bfd_signed_vma *local_got_refcounts;
2178
2179 /* This is a global offset table entry for a local
2180 symbol. */
2181 local_got_refcounts = elf_local_got_refcounts (abfd);
2182 if (local_got_refcounts == NULL)
2183 {
2184 bfd_size_type size;
2185
2186 size = symtab_hdr->sh_info;
2187 size *= sizeof (bfd_signed_vma);
2188 /* Add in space to store the local GOT TLS types. */
2189 size += symtab_hdr->sh_info;
2190 local_got_refcounts = ((bfd_signed_vma *)
2191 bfd_zalloc (abfd, size));
2192 if (local_got_refcounts == NULL)
2193 return FALSE;
2194 elf_local_got_refcounts (abfd) = local_got_refcounts;
2195 memset (metag_elf_local_got_tls_type (abfd),
2196 GOT_UNKNOWN, symtab_hdr->sh_info);
2197 }
2198 local_got_refcounts[r_symndx] += 1;
2199 old_tls_type = metag_elf_local_got_tls_type (abfd) [r_symndx];
2200 }
2201
2202 if (old_tls_type != tls_type)
2203 {
2204 if (hh != NULL)
2205 {
2206 hh->tls_type = tls_type;
2207 }
2208 else
2209 {
2210 metag_elf_local_got_tls_type (abfd) [r_symndx] = tls_type;
2211 }
2212 }
2213
2214 break;
2215
2216 case R_METAG_TLS_LDM:
2217 metag_link_hash_table (info)->tls_ldm_got.refcount += 1;
2218 break;
2219
2220 case R_METAG_RELBRANCH_PLT:
2221 /* This symbol requires a procedure linkage table entry. We
2222 actually build the entry in adjust_dynamic_symbol,
2223 because this might be a case of linking PIC code without
2224 linking in any dynamic objects, in which case we don't
2225 need to generate a procedure linkage table after all. */
2226
2227 /* If this is a local symbol, we resolve it directly without
2228 creating a procedure linkage table entry. */
2229 if (hh == NULL)
2230 continue;
2231
2232 if (hh->eh.forced_local)
2233 break;
2234
2235 hh->eh.needs_plt = 1;
2236 hh->eh.plt.refcount += 1;
2237 break;
2238
a3c62988
NC		 2239 case R_METAG_HIADDR16:
2240 case R_METAG_LOADDR16:
1a18f0ae
NC		 2241 /* Let's help debug shared library creation. These relocs
2242 cannot be used in shared libs. Don't error out for
2243 sections we don't care about, such as debug sections or
2244 non-constant sections. */
0e1862bb 2245 if (bfd_link_pic (info)
1a18f0ae
NC		 2246 && (sec->flags & SEC_ALLOC) != 0
2247 && (sec->flags & SEC_READONLY) != 0)
2248 {
2249 const char *name;
2250
2251 if (hh)
2252 name = hh->eh.root.root.string;
2253 else
2254 name = bfd_elf_sym_name (abfd, symtab_hdr, isym, NULL);
4eca0228 2255 _bfd_error_handler
695344c0 2256 /* xgettext:c-format */
871b3ab2 2257 (_("%pB: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1a18f0ae
NC		 2258 abfd, elf_metag_howto_table[r_type].name, name);
2259 bfd_set_error (bfd_error_bad_value);
2260 return FALSE;
2261 }
2262
2263 /* Fall through. */
2264 case R_METAG_ADDR32:
a3c62988
NC		 2265 case R_METAG_RELBRANCH:
2266 case R_METAG_GETSETOFF:
0e1862bb 2267 if (hh != NULL && !bfd_link_pic (info))
a3c62988
NC		 2268 {
2269 hh->eh.non_got_ref = 1;
2270 hh->eh.plt.refcount += 1;
2271 }
2272
2273 /* If we are creating a shared library, and this is a reloc
2274 against a global symbol, or a non PC relative reloc
2275 against a local symbol, then we need to copy the reloc
2276 into the shared library. However, if we are linking with
2277 -Bsymbolic, we do not need to copy a reloc against a
2278 global symbol which is defined in an object we are
2279 including in the link (i.e., DEF_REGULAR is set). At
2280 this point we have not seen all the input files, so it is
2281 possible that DEF_REGULAR is not set now but will be set
2282 later (it is never cleared). We account for that
2283 possibility below by storing information in the
2284 dyn_relocs field of the hash table entry. A similar
2285 situation occurs when creating shared libraries and symbol
2286 visibility changes render the symbol local.
2287
2288 If on the other hand, we are creating an executable, we
2289 may need to keep relocations for symbols satisfied by a
2290 dynamic library if we manage to avoid copy relocs for the
2291 symbol. */
0e1862bb 2292 if ((bfd_link_pic (info)
a3c62988
NC		 2293 && (sec->flags & SEC_ALLOC) != 0
2294 && (r_type != R_METAG_RELBRANCH
2295 || (hh != NULL
2296 && (! info->symbolic
2297 || hh->eh.root.type == bfd_link_hash_defweak
2298 || !hh->eh.def_regular))))
0e1862bb 2299 || (!bfd_link_pic (info)
a3c62988
NC		 2300 && (sec->flags & SEC_ALLOC) != 0
2301 && hh != NULL
2302 && (hh->eh.root.type == bfd_link_hash_defweak
2303 || !hh->eh.def_regular)))
2304 {
3bf083ed
AM		 2305 struct elf_dyn_relocs *hdh_p;
2306 struct elf_dyn_relocs **hdh_head;
a3c62988
NC		 2307
2308 if (dynobj == NULL)
2309 htab->etab.dynobj = dynobj = abfd;
2310
2311 /* When creating a shared object, we must copy these
2312 relocs into the output file. We create a reloc
2313 section in dynobj and make room for the reloc. */
2314 if (sreloc == NULL)
2315 {
2316 sreloc = _bfd_elf_make_dynamic_reloc_section
2317 (sec, htab->etab.dynobj, 2, abfd, /*rela?*/ TRUE);
2318
2319 if (sreloc == NULL)
2320 {
2321 bfd_set_error (bfd_error_bad_value);
2322 return FALSE;
2323 }
2324
2325 elf_section_data (sec)->sreloc = sreloc;
2326 }
2327
2328 /* If this is a global symbol, we count the number of
2329 relocations we need for this symbol. */
2330 if (hh != NULL)
2331 hdh_head = &((struct elf_metag_link_hash_entry *) hh)->dyn_relocs;
2332 else
2333 {
2334 /* Track dynamic relocs needed for local syms too. */
2335 asection *sr;
2336 void *vpp;
a3c62988
NC		 2337
2338 sr = bfd_section_from_elf_index (abfd, isym->st_shndx);
2339 if (sr == NULL)
2340 sr = sec;
2341
2342 vpp = &elf_section_data (sr)->local_dynrel;
3bf083ed 2343 hdh_head = (struct elf_dyn_relocs **) vpp;
a3c62988
NC		 2344 }
2345
2346 hdh_p = *hdh_head;
2347 if (hdh_p == NULL || hdh_p->sec != sec)
2348 {
3bf083ed 2349 hdh_p = ((struct elf_dyn_relocs *)
a3c62988
NC		 2350 bfd_alloc (dynobj, sizeof *hdh_p));
2351 if (hdh_p == NULL)
2352 return FALSE;
3bf083ed 2353 hdh_p->next = *hdh_head;
a3c62988
NC		 2354 *hdh_head = hdh_p;
2355 hdh_p->sec = sec;
2356 hdh_p->count = 0;
3bf083ed 2357 hdh_p->pc_count = 0;
a3c62988
NC		 2358 }
2359
2360 hdh_p->count += 1;
2361 if (ELF32_R_TYPE (rel->r_info) == R_METAG_RELBRANCH)
3bf083ed 2362 hdh_p->pc_count += 1;
a3c62988
NC		 2363 }
2364 break;
2365
2366 /* This relocation describes the C++ object vtable hierarchy.
2367 Reconstruct it for later use during GC. */
2368 case R_METAG_GNU_VTINHERIT:
2369 if (!bfd_elf_gc_record_vtinherit (abfd, sec, &hh->eh,
2370 rel->r_offset))
2371 return FALSE;
2372 break;
2373
2374 /* This relocation describes which C++ vtable entries are actually
2375 used. Record for later use during GC. */
2376 case R_METAG_GNU_VTENTRY:
a0ea3a14 2377 if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
a3c62988
NC		 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
2388static void
2389elf_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 {
3bf083ed
AM		 2402 struct elf_dyn_relocs **hdh_pp;
2403 struct elf_dyn_relocs *hdh_p;
a3c62988
NC		 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 {
3bf083ed 2412 struct elf_dyn_relocs *hdh_q;
a3c62988
NC		 2413
2414 for (hdh_q = hh_dir->dyn_relocs; hdh_q != NULL;
3bf083ed 2415 hdh_q = hdh_q->next)
a3c62988
NC		 2416 if (hdh_q->sec == hdh_p->sec)
2417 {
3bf083ed 2418 hdh_q->pc_count += hdh_p->pc_count;
a3c62988 2419 hdh_q->count += hdh_p->count;
3bf083ed 2420 *hdh_pp = hdh_p->next;
a3c62988
NC		 2421 break;
2422 }
2423 if (hdh_q == NULL)
3bf083ed 2424 hdh_pp = &hdh_p->next;
a3c62988
NC		 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
63c1f59d
AM		 2443/* Find dynamic relocs for H that apply to read-only sections. */
2444
2445static asection *
2446readonly_dynrelocs (struct elf_link_hash_entry *h)
2447{
3bf083ed 2448 struct elf_dyn_relocs *p;
63c1f59d 2449
3bf083ed 2450 for (p = metag_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
63c1f59d
AM		 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
a3c62988
NC		 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
2466static bfd_boolean
2467elf_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;
5474d94f 2471 asection *s, *srel;
a3c62988
NC		 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. */
60d67dc8 2501 if (eh->is_weakalias)
a3c62988 2502 {
60d67dc8
AM		 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;
a3c62988
NC		 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. */
0e1862bb 2518 if (bfd_link_pic (info))
a3c62988
NC		 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
3bf083ed 2533 /* If we don't find any dynamic relocs in read-only sections, then
a3c62988 2534 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
3bf083ed 2535 if (!readonly_dynrelocs (eh))
a3c62988
NC		 2536 {
2537 eh->non_got_ref = 0;
2538 return TRUE;
2539 }
2540
a3c62988
NC		 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. */
5474d94f
AM		 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 }
34c67f14 2566 if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
a3c62988 2567 {
5474d94f 2568 srel->size += sizeof (Elf32_External_Rela);
a3c62988
NC		 2569 eh->needs_copy = 1;
2570 }
2571
6cabe1ea 2572 return _bfd_elf_adjust_dynamic_copy (info, eh, s);
a3c62988
NC		 2573}
2574
2575/* Allocate space in .plt, .got and associated reloc sections for
2576 global syms. */
2577
2578static bfd_boolean
2579allocate_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;
3bf083ed 2584 struct elf_dyn_relocs *hdh_p;
a3c62988
NC		 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
0e1862bb 2607 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
a3c62988 2608 {
ce558b89 2609 asection *s = htab->etab.splt;
a3c62988
NC		 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. */
0e1862bb 2623 if (! bfd_link_pic (info)
a3c62988
NC		 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. */
ce558b89 2635 htab->etab.sgotplt->size += 4;
a3c62988
NC		 2636
2637 /* We also need to make an entry in the .rel.plt section. */
ce558b89 2638 htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
a3c62988
NC		 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
ce558b89 2667 s = htab->etab.sgot;
a3c62988
NC		 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))
ce558b89 2679 htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
a3c62988 2680 else if (tls_type == GOT_TLS_GD)
ce558b89 2681 htab->etab.srelgot->size += 2 * sizeof (Elf32_External_Rela);
0e1862bb
L		 2682 else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2683 bfd_link_pic (info),
2684 eh))
ce558b89 2685 htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
a3c62988
NC		 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. */
0e1862bb 2699 if (bfd_link_pic (info))
a3c62988
NC		 2700 {
2701 if (SYMBOL_CALLS_LOCAL (info, eh))
2702 {
3bf083ed 2703 struct elf_dyn_relocs **hdh_pp;
a3c62988
NC		 2704
2705 for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2706 {
3bf083ed
AM		 2707 hdh_p->count -= hdh_p->pc_count;
2708 hdh_p->pc_count = 0;
a3c62988 2709 if (hdh_p->count == 0)
3bf083ed 2710 *hdh_pp = hdh_p->next;
a3c62988 2711 else
3bf083ed 2712 hdh_pp = &hdh_p->next;
a3c62988
NC		 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. */
3bf083ed 2768 for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
a3c62988
NC		 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
63c1f59d
AM		 2777/* Set DF_TEXTREL if we find any dynamic relocs that apply to
2778 read-only sections. */
a3c62988
NC		 2779
2780static bfd_boolean
63c1f59d 2781maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
a3c62988 2782{
63c1f59d 2783 asection *sec;
a3c62988 2784
63c1f59d
AM		 2785 if (h->root.type == bfd_link_hash_indirect)
2786 return TRUE;
a3c62988 2787
63c1f59d
AM		 2788 sec = readonly_dynrelocs (h);
2789 if (sec != NULL)
a3c62988 2790 {
63c1f59d 2791 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
a3c62988 2792
63c1f59d
AM		 2793 info->flags |= DF_TEXTREL;
2794 info->callbacks->minfo
c1c8c1ef 2795 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
63c1f59d 2796 sec->owner, h->root.root.string, sec);
a3c62988 2797
63c1f59d
AM		 2798 /* Not an error, just cut short the traversal. */
2799 return FALSE;
a3c62988
NC		 2800 }
2801 return TRUE;
2802}
2803
2804/* Set the sizes of the dynamic sections. */
2805
2806static bfd_boolean
2807elf_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. */
9b8b325a 2824 if (bfd_link_executable (info) && !info->nointerp)
a3c62988 2825 {
ad1fc92a 2826 s = bfd_get_linker_section (dynobj, ".interp");
a3c62988
NC		 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. */
c72f2fb2 2836 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
a3c62988
NC		 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 {
3bf083ed 2850 struct elf_dyn_relocs *hdh_p;
a3c62988 2851
3bf083ed 2852 for (hdh_p = ((struct elf_dyn_relocs *)
a3c62988
NC		 2853 elf_section_data (s)->local_dynrel);
2854 hdh_p != NULL;
3bf083ed 2855 hdh_p = hdh_p->next)
a3c62988
NC		 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);
ce558b89
AM		 2883 s = htab->etab.sgot;
2884 srel = htab->etab.srelgot;
a3c62988
NC		 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;
0e1862bb 2894 if (bfd_link_pic (info))
a3c62988
NC		 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. */
ce558b89
AM		 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);
a3c62988
NC		 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
ce558b89
AM		 2928 if (s == htab->etab.splt
2929 || s == htab->etab.sgot
2930 || s == htab->etab.sgotplt
5474d94f
AM		 2931 || s == htab->etab.sdynbss
2932 || s == htab->etab.sdynrelro)
a3c62988
NC		 2933 {
2934 /* Strip this section if we don't need it; see the
2935 comment below. */
2936 }
fd361982 2937 else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
a3c62988 2938 {
ce558b89 2939 if (s->size != 0 && s != htab->etab.srelplt)
a3c62988
NC		 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
0e1862bb 3004 if (bfd_link_executable (info))
a3c62988
NC		 3005 {
3006 if (!add_dynamic_entry (DT_DEBUG, 0))
3007 return FALSE;
3008 }
3009
ce558b89 3010 if (htab->etab.srelplt->size != 0)
a3c62988
NC		 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)
63c1f59d 3028 elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
a3c62988
NC		 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
3045static bfd_boolean
3046elf_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
ce558b89
AM		 3072 splt = htab->etab.splt;
3073 sgot = htab->etab.sgotplt;
3074 srela = htab->etab.srelplt;
a3c62988
NC		 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. */
0e1862bb 3096 if (! bfd_link_pic (info))
a3c62988
NC		 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;
ce558b89 3152 loc = htab->etab.srelplt->contents;
a3c62988
NC		 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)
ce558b89
AM		 3172 + htab->etab.sgot->output_offset
3173 + htab->etab.sgot->output_section->vma);
a3c62988
NC		 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. */
0e1862bb 3180 if (bfd_link_pic (info)
a3c62988
NC		 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 ();
ce558b89 3193 bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + eh->got.offset);
a3c62988
NC		 3194 rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_GLOB_DAT);
3195 rel.r_addend = 0;
3196 }
3197
ce558b89
AM		 3198 loc = htab->etab.srelgot->contents;
3199 loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
a3c62988
NC		 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
a3c62988
NC		 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);
afbf7e8e 3219 if (eh->root.u.def.section == htab->etab.sdynrelro)
5474d94f
AM		 3220 s = htab->etab.sreldynrelro;
3221 else
3222 s = htab->etab.srelbss;
a3c62988
NC		 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
ed7e9d0b
AM		 3240static bfd_boolean
3241elf_metag_init_file_header (bfd *abfd, struct bfd_link_info *link_info)
a3c62988
NC		 3242{
3243 Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
3244
ed7e9d0b
AM		 3245 if (!_bfd_elf_init_file_header (abfd, link_info))
3246 return FALSE;
3247
a3c62988
NC		 3248 i_ehdrp = elf_elfheader (abfd);
3249 i_ehdrp->e_ident[EI_ABIVERSION] = METAG_ELF_ABI_VERSION;
ed7e9d0b 3250 return TRUE;
a3c62988
NC		 3251}
3252
3253/* Used to decide how to sort relocs in an optimal manner for the
3254 dynamic linker, before writing them out. */
3255
3256static enum elf_reloc_type_class
7e612e98
AM		 3257elf_metag_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3258 const asection *rel_sec ATTRIBUTE_UNUSED,
3259 const Elf_Internal_Rela *rela)
a3c62988
NC		 3260{
3261 switch ((int) ELF32_R_TYPE (rela->r_info))
3262 {
3263 case R_METAG_RELATIVE:
3264 return reloc_class_relative;
3265 case R_METAG_JMP_SLOT:
3266 return reloc_class_plt;
3267 case R_METAG_COPY:
3268 return reloc_class_copy;
3269 default:
3270 return reloc_class_normal;
3271 }
3272}
3273
3274/* Finish up the dynamic sections. */
3275
3276static bfd_boolean
3277elf_metag_finish_dynamic_sections (bfd *output_bfd,
3278 struct bfd_link_info *info)
3279{
3280 bfd *dynobj;
3281 struct elf_metag_link_hash_table *htab;
3282 asection *sdyn;
3283
3284 htab = metag_link_hash_table (info);
3285 dynobj = htab->etab.dynobj;
3286
ad1fc92a 3287 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
a3c62988
NC		 3288
3289 if (htab->etab.dynamic_sections_created)
3290 {
3291 asection *splt;
3292 Elf32_External_Dyn *dyncon, *dynconend;
3293
3294 if (sdyn == NULL)
3295 abort ();
3296
3297 dyncon = (Elf32_External_Dyn *) sdyn->contents;
3298 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3299 for (; dyncon < dynconend; dyncon++)
3300 {
3301 Elf_Internal_Dyn dyn;
3302 asection *s;
3303
3304 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3305
3306 switch (dyn.d_tag)
3307 {
3308 default:
3309 continue;
3310
3311 case DT_PLTGOT:
ce558b89 3312 s = htab->etab.sgot;
4ade44b7 3313 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
a3c62988
NC		 3314 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3315 break;
3316
3317 case DT_JMPREL:
ce558b89 3318 s = htab->etab.srelplt;
4ade44b7 3319 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
a3c62988
NC		 3320 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3321 break;
3322
3323 case DT_PLTRELSZ:
ce558b89 3324 s = htab->etab.srelplt;
a3c62988
NC		 3325 dyn.d_un.d_val = s->size;
3326 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3327 break;
a3c62988
NC		 3328 }
3329
3330 }
3331
3332 /* Fill in the first entry in the procedure linkage table. */
ce558b89 3333 splt = htab->etab.splt;
a3c62988
NC		 3334 if (splt && splt->size > 0)
3335 {
3336 unsigned long addr;
3337 /* addr = .got + 4 */
ce558b89
AM		 3338 addr = (htab->etab.sgot->output_section->vma
3339 + htab->etab.sgot->output_offset + 4);
0e1862bb 3340 if (bfd_link_pic (info))
a3c62988
NC		 3341 {
3342 addr -= splt->output_section->vma + splt->output_offset;
3343 bfd_put_32 (output_bfd,
3344 plt0_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
3345 splt->contents);
3346 bfd_put_32 (output_bfd,
3347 plt0_pic_entry[1] | ((addr & 0xffff) << 3),
3348 splt->contents + 4);
3349 bfd_put_32 (output_bfd, plt0_pic_entry[2], splt->contents + 8);
3350 bfd_put_32 (output_bfd, plt0_pic_entry[3], splt->contents + 12);
3351 bfd_put_32 (output_bfd, plt0_pic_entry[4], splt->contents + 16);
3352 }
3353 else
3354 {
3355 bfd_put_32 (output_bfd,
3356 plt0_entry[0] | (((addr >> 16) & 0xffff) << 3),
3357 splt->contents);
3358 bfd_put_32 (output_bfd,
3359 plt0_entry[1] | ((addr & 0xffff) << 3),
3360 splt->contents + 4);
3361 bfd_put_32 (output_bfd, plt0_entry[2], splt->contents + 8);
3362 bfd_put_32 (output_bfd, plt0_entry[3], splt->contents + 12);
3363 bfd_put_32 (output_bfd, plt0_entry[4], splt->contents + 16);
3364 }
3365
3366 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3367 PLT_ENTRY_SIZE;
3368 }
3369 }
3370
ce558b89 3371 if (htab->etab.sgot != NULL && htab->etab.sgot->size != 0)
a3c62988
NC		 3372 {
3373 /* Fill in the first entry in the global offset table.
3374 We use it to point to our dynamic section, if we have one. */
3375 bfd_put_32 (output_bfd,
3376 sdyn ? sdyn->output_section->vma + sdyn->output_offset : 0,
ce558b89 3377 htab->etab.sgot->contents);
a3c62988
NC		 3378
3379 /* The second entry is reserved for use by the dynamic linker. */
ce558b89 3380 memset (htab->etab.sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
a3c62988
NC		 3381
3382 /* Set .got entry size. */
ce558b89 3383 elf_section_data (htab->etab.sgot->output_section)
a3c62988
NC		 3384 ->this_hdr.sh_entsize = GOT_ENTRY_SIZE;
3385 }
3386
3387 return TRUE;
3388}
3389
3390/* Return the section that should be marked against GC for a given
3391 relocation. */
3392
3393static asection *
3394elf_metag_gc_mark_hook (asection *sec,
3395 struct bfd_link_info *info,
3396 Elf_Internal_Rela *rela,
3397 struct elf_link_hash_entry *hh,
3398 Elf_Internal_Sym *sym)
3399{
3400 if (hh != NULL)
3401 switch ((unsigned int) ELF32_R_TYPE (rela->r_info))
3402 {
3403 case R_METAG_GNU_VTINHERIT:
3404 case R_METAG_GNU_VTENTRY:
3405 return NULL;
3406 }
3407
3408 return _bfd_elf_gc_mark_hook (sec, info, rela, hh, sym);
3409}
3410
a3c62988
NC		 3411/* Determine the type of stub needed, if any, for a call. */
3412
3413static enum elf_metag_stub_type
3414metag_type_of_stub (asection *input_sec,
3415 const Elf_Internal_Rela *rel,
3416 struct elf_metag_link_hash_entry *hh,
3417 bfd_vma destination,
3418 struct bfd_link_info *info ATTRIBUTE_UNUSED)
3419{
3420 bfd_vma location;
3421 bfd_vma branch_offset;
3422 bfd_vma max_branch_offset;
3423
3424 if (hh != NULL &&
3425 !(hh->eh.root.type == bfd_link_hash_defined
3426 || hh->eh.root.type == bfd_link_hash_defweak))
3427 return metag_stub_none;
3428
3429 /* Determine where the call point is. */
3430 location = (input_sec->output_offset
3431 + input_sec->output_section->vma
3432 + rel->r_offset);
3433
3434 branch_offset = destination - location;
3435
3436 /* Determine if a long branch stub is needed. Meta branch offsets
3437 are signed 19 bits 4 byte aligned. */
3438 max_branch_offset = (1 << (BRANCH_BITS-1)) << 2;
3439
3440 if (branch_offset + max_branch_offset >= 2*max_branch_offset)
3441 {
0e1862bb 3442 if (bfd_link_pic (info))
a3c62988
NC		 3443 return metag_stub_long_branch_shared;
3444 else
3445 return metag_stub_long_branch;
3446 }
3447
3448 return metag_stub_none;
3449}
3450
3451#define MOVT_A0_3 0x82180005
3452#define JUMP_A0_3 0xac180003
3453
3454#define MOVT_A1LBP 0x83080005
3455#define ADD_A1LBP 0x83080000
3456
3457#define ADDT_A0_3_CPC 0x82980001
3458#define ADD_A0_3_A0_3 0x82180000
3459#define MOV_PC_A0_3 0xa3180ca0
3460
3461static bfd_boolean
3462metag_build_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
3463{
3464 struct elf_metag_stub_hash_entry *hsh;
3465 asection *stub_sec;
3466 bfd *stub_bfd;
3467 bfd_byte *loc;
3468 bfd_vma sym_value;
3469 int size;
3470
3471 /* Massage our args to the form they really have. */
3472 hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
3473
3474 stub_sec = hsh->stub_sec;
3475
3476 /* Make a note of the offset within the stubs for this entry. */
3477 hsh->stub_offset = stub_sec->size;
3478 loc = stub_sec->contents + hsh->stub_offset;
3479
3480 stub_bfd = stub_sec->owner;
3481
3482 switch (hsh->stub_type)
3483 {
3484 case metag_stub_long_branch_shared:
3485 /* A PIC long branch stub is an ADDT and an ADD instruction used to
3486 calculate the jump target using A0.3 as a temporary. Then a MOV
3487 to PC carries out the jump. */
3488 sym_value = (hsh->target_value
3489 + hsh->target_section->output_offset
3490 + hsh->target_section->output_section->vma
3491 + hsh->addend);
3492
3493 sym_value -= (hsh->stub_offset
3494 + stub_sec->output_offset
3495 + stub_sec->output_section->vma);
3496
3497 bfd_put_32 (stub_bfd, ADDT_A0_3_CPC | (((sym_value >> 16) & 0xffff) << 3),
3498 loc);
3499
3500 bfd_put_32 (stub_bfd, ADD_A0_3_A0_3 | ((sym_value & 0xffff) << 3),
3501 loc + 4);
3502
3503 bfd_put_32 (stub_bfd, MOV_PC_A0_3, loc + 8);
3504
3505 size = 12;
3506 break;
3507 case metag_stub_long_branch:
3508 /* A standard long branch stub is a MOVT instruction followed by a
3509 JUMP instruction using the A0.3 register as a temporary. This is
3510 the same method used by the LDLK linker (patch.c). */
3511 sym_value = (hsh->target_value
3512 + hsh->target_section->output_offset
3513 + hsh->target_section->output_section->vma
3514 + hsh->addend);
3515
3516 bfd_put_32 (stub_bfd, MOVT_A0_3 | (((sym_value >> 16) & 0xffff) << 3),
3517 loc);
3518
3519 bfd_put_32 (stub_bfd, JUMP_A0_3 | ((sym_value & 0xffff) << 3), loc + 4);
3520
3521 size = 8;
3522 break;
3523 default:
3524 BFD_FAIL ();
3525 return FALSE;
3526 }
3527
3528 stub_sec->size += size;
3529 return TRUE;
3530}
3531
3532/* As above, but don't actually build the stub. Just bump offset so
3533 we know stub section sizes. */
3534
3535static bfd_boolean
3536metag_size_one_stub (struct bfd_hash_entry *gen_entry, void *in_arg ATTRIBUTE_UNUSED)
3537{
3538 struct elf_metag_stub_hash_entry *hsh;
3539 int size = 0;
3540
3541 /* Massage our args to the form they really have. */
3542 hsh = (struct elf_metag_stub_hash_entry *) gen_entry;
3543
3544 if (hsh->stub_type == metag_stub_long_branch)
3545 size = 8;
3546 else if (hsh->stub_type == metag_stub_long_branch_shared)
3547 size = 12;
3548
3549 hsh->stub_sec->size += size;
3550 return TRUE;
3551}
3552
3553/* Set up various things so that we can make a list of input sections
3554 for each output section included in the link. Returns -1 on error,
3555 0 when no stubs will be needed, and 1 on success. */
3556
3557int
3558elf_metag_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3559{
3560 bfd *input_bfd;
3561 unsigned int bfd_count;
7292b3ac 3562 unsigned int top_id, top_index;
a3c62988
NC		 3563 asection *section;
3564 asection **input_list, **list;
3565 bfd_size_type amt;
3566 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3567
3568 /* Count the number of input BFDs and find the top input section id. */
3569 for (input_bfd = info->input_bfds, bfd_count = 0, top_id = 0;
3570 input_bfd != NULL;
c72f2fb2 3571 input_bfd = input_bfd->link.next)
a3c62988
NC		 3572 {
3573 bfd_count += 1;
3574 for (section = input_bfd->sections;
3575 section != NULL;
3576 section = section->next)
3577 {
3578 if (top_id < section->id)
3579 top_id = section->id;
3580 }
3581 }
3582
3583 htab->bfd_count = bfd_count;
3584
3585 amt = sizeof (struct map_stub) * (top_id + 1);
3586 htab->stub_group = bfd_zmalloc (amt);
3587 if (htab->stub_group == NULL)
3588 return -1;
3589
3590 /* We can't use output_bfd->section_count here to find the top output
3591 section index as some sections may have been removed, and
3592 strip_excluded_output_sections doesn't renumber the indices. */
3593 for (section = output_bfd->sections, top_index = 0;
3594 section != NULL;
3595 section = section->next)
3596 {
3597 if (top_index < section->index)
3598 top_index = section->index;
3599 }
3600
3601 htab->top_index = top_index;
3602 amt = sizeof (asection *) * (top_index + 1);
3603 input_list = bfd_malloc (amt);
3604 htab->input_list = input_list;
3605 if (input_list == NULL)
3606 return -1;
3607
3608 /* For sections we aren't interested in, mark their entries with a
3609 value we can check later. */
3610 list = input_list + top_index;
3611 do
3612 *list = bfd_abs_section_ptr;
3613 while (list-- != input_list);
3614
3615 for (section = output_bfd->sections;
3616 section != NULL;
3617 section = section->next)
3618 {
3619 /* FIXME: This is a bit of hack. Currently our .ctors and .dtors
3620 * have PC relative relocs in them but no code flag set. */
3621 if (((section->flags & SEC_CODE) != 0) ||
3622 strcmp(".ctors", section->name) ||
3623 strcmp(".dtors", section->name))
3624 input_list[section->index] = NULL;
3625 }
3626
3627 return 1;
3628}
3629
3630/* The linker repeatedly calls this function for each input section,
3631 in the order that input sections are linked into output sections.
3632 Build lists of input sections to determine groupings between which
3633 we may insert linker stubs. */
3634
3635void
3636elf_metag_next_input_section (struct bfd_link_info *info, asection *isec)
3637{
3638 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3639
3640 if (isec->output_section->index <= htab->top_index)
3641 {
3642 asection **list = htab->input_list + isec->output_section->index;
3643 if (*list != bfd_abs_section_ptr)
3644 {
3645 /* Steal the link_sec pointer for our list. */
3646#define PREV_SEC(sec) (htab->stub_group[(sec)->id].link_sec)
3647 /* This happens to make the list in reverse order,
3648 which is what we want. */
3649 PREV_SEC (isec) = *list;
3650 *list = isec;
3651 }
3652 }
3653}
3654
3655/* See whether we can group stub sections together. Grouping stub
3656 sections may result in fewer stubs. More importantly, we need to
3657 put all .init* and .fini* stubs at the beginning of the .init or
3658 .fini output sections respectively, because glibc splits the
3659 _init and _fini functions into multiple parts. Putting a stub in
3660 the middle of a function is not a good idea. */
3661
3662static void
3663group_sections (struct elf_metag_link_hash_table *htab,
3664 bfd_size_type stub_group_size,
3665 bfd_boolean stubs_always_before_branch)
3666{
3667 asection **list = htab->input_list + htab->top_index;
3668 do
3669 {
3670 asection *tail = *list;
3671 if (tail == bfd_abs_section_ptr)
3672 continue;
3673 while (tail != NULL)
3674 {
3675 asection *curr;
3676 asection *prev;
3677 bfd_size_type total;
3678 bfd_boolean big_sec;
3679
3680 curr = tail;
3681 total = tail->size;
3682 big_sec = total >= stub_group_size;
3683
3684 while ((prev = PREV_SEC (curr)) != NULL
3685 && ((total += curr->output_offset - prev->output_offset)
3686 < stub_group_size))
3687 curr = prev;
3688
3689 /* OK, the size from the start of CURR to the end is less
3690 than stub_group_size bytes and thus can be handled by one stub
3691 section. (or the tail section is itself larger than
3692 stub_group_size bytes, in which case we may be toast.)
3693 We should really be keeping track of the total size of
3694 stubs added here, as stubs contribute to the final output
3695 section size. */
3696 do
3697 {
3698 prev = PREV_SEC (tail);
3699 /* Set up this stub group. */
3700 htab->stub_group[tail->id].link_sec = curr;
3701 }
3702 while (tail != curr && (tail = prev) != NULL);
3703
3704 /* But wait, there's more! Input sections up to stub_group_size
3705 bytes before the stub section can be handled by it too.
3706 Don't do this if we have a really large section after the
3707 stubs, as adding more stubs increases the chance that
3708 branches may not reach into the stub section. */
3709 if (!stubs_always_before_branch && !big_sec)
3710 {
3711 total = 0;
3712 while (prev != NULL
3713 && ((total += tail->output_offset - prev->output_offset)
3714 < stub_group_size))
3715 {
3716 tail = prev;
3717 prev = PREV_SEC (tail);
3718 htab->stub_group[tail->id].link_sec = curr;
3719 }
3720 }
3721 tail = prev;
3722 }
3723 }
3724 while (list-- != htab->input_list);
3725 free (htab->input_list);
3726#undef PREV_SEC
3727}
3728
3729/* Read in all local syms for all input bfds.
3730 Returns -1 on error, 0 otherwise. */
3731
3732static int
3733get_local_syms (bfd *output_bfd ATTRIBUTE_UNUSED, bfd *input_bfd,
3734 struct bfd_link_info *info)
3735{
3736 unsigned int bfd_indx;
3737 Elf_Internal_Sym *local_syms, **all_local_syms;
3738 int stub_changed = 0;
3739 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3740
3741 /* We want to read in symbol extension records only once. To do this
3742 we need to read in the local symbols in parallel and save them for
3743 later use; so hold pointers to the local symbols in an array. */
3744 bfd_size_type amt = sizeof (Elf_Internal_Sym *) * htab->bfd_count;
3745 all_local_syms = bfd_zmalloc (amt);
3746 htab->all_local_syms = all_local_syms;
3747 if (all_local_syms == NULL)
3748 return -1;
3749
3750 /* Walk over all the input BFDs, swapping in local symbols. */
3751 for (bfd_indx = 0;
3752 input_bfd != NULL;
c72f2fb2 3753 input_bfd = input_bfd->link.next, bfd_indx++)
a3c62988
NC		 3754 {
3755 Elf_Internal_Shdr *symtab_hdr;
3756
3757 /* We'll need the symbol table in a second. */
3758 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3759 if (symtab_hdr->sh_info == 0)
3760 continue;
3761
3762 /* We need an array of the local symbols attached to the input bfd. */
3763 local_syms = (Elf_Internal_Sym *) symtab_hdr->contents;
3764 if (local_syms == NULL)
3765 {
3766 local_syms = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3767 symtab_hdr->sh_info, 0,
3768 NULL, NULL, NULL);
3769 /* Cache them for elf_link_input_bfd. */
3770 symtab_hdr->contents = (unsigned char *) local_syms;
3771 }
3772 if (local_syms == NULL)
3773 return -1;
3774
3775 all_local_syms[bfd_indx] = local_syms;
3776 }
3777
3778 return stub_changed;
3779}
3780
3781/* Determine and set the size of the stub section for a final link.
3782
3783The basic idea here is to examine all the relocations looking for
3784PC-relative calls to a target that is unreachable with a "CALLR"
3785instruction. */
3786
3787/* See elf32-hppa.c and elf64-ppc.c. */
3788
3789bfd_boolean
3790elf_metag_size_stubs(bfd *output_bfd, bfd *stub_bfd,
3791 struct bfd_link_info *info,
3792 bfd_signed_vma group_size,
3793 asection * (*add_stub_section) (const char *, asection *),
3794 void (*layout_sections_again) (void))
3795{
3796 bfd_size_type stub_group_size;
3797 bfd_boolean stubs_always_before_branch;
3798 bfd_boolean stub_changed;
3799 struct elf_metag_link_hash_table *htab = metag_link_hash_table (info);
3800
3801 /* Stash our params away. */
3802 htab->stub_bfd = stub_bfd;
3803 htab->add_stub_section = add_stub_section;
3804 htab->layout_sections_again = layout_sections_again;
3805 stubs_always_before_branch = group_size < 0;
3806 if (group_size < 0)
3807 stub_group_size = -group_size;
3808 else
3809 stub_group_size = group_size;
3810 if (stub_group_size == 1)
3811 {
3812 /* Default values. */
3813 /* FIXME: not sure what these values should be */
3814 if (stubs_always_before_branch)
3815 {
3816 stub_group_size = (1 << BRANCH_BITS);
3817 }
3818 else
3819 {
3820 stub_group_size = (1 << BRANCH_BITS);
3821 }
3822 }
3823
3824 group_sections (htab, stub_group_size, stubs_always_before_branch);
3825
3826 switch (get_local_syms (output_bfd, info->input_bfds, info))
3827 {
3828 default:
3829 if (htab->all_local_syms)
3830 goto error_ret_free_local;
3831 return FALSE;
3832
3833 case 0:
3834 stub_changed = FALSE;
3835 break;
3836
3837 case 1:
3838 stub_changed = TRUE;
3839 break;
3840 }
3841
3842 while (1)
3843 {
3844 bfd *input_bfd;
3845 unsigned int bfd_indx;
3846 asection *stub_sec;
3847
3848 for (input_bfd = info->input_bfds, bfd_indx = 0;
3849 input_bfd != NULL;
c72f2fb2 3850 input_bfd = input_bfd->link.next, bfd_indx++)
a3c62988
NC		 3851 {
3852 Elf_Internal_Shdr *symtab_hdr;
3853 asection *section;
3854 Elf_Internal_Sym *local_syms;
3855
3856 /* We'll need the symbol table in a second. */
3857 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3858 if (symtab_hdr->sh_info == 0)
3859 continue;
3860
3861 local_syms = htab->all_local_syms[bfd_indx];
3862
3863 /* Walk over each section attached to the input bfd. */
3864 for (section = input_bfd->sections;
3865 section != NULL;
3866 section = section->next)
3867 {
3868 Elf_Internal_Rela *internal_relocs, *irelaend, *irela;
3869
3870 /* If there aren't any relocs, then there's nothing more
3871 to do. */
3872 if ((section->flags & SEC_RELOC) == 0
3873 || section->reloc_count == 0)
3874 continue;
3875
3876 /* If this section is a link-once section that will be
3877 discarded, then don't create any stubs. */
3878 if (section->output_section == NULL
3879 || section->output_section->owner != output_bfd)
3880 continue;
3881
3882 /* Get the relocs. */
3883 internal_relocs
3884 = _bfd_elf_link_read_relocs (input_bfd, section, NULL, NULL,
3885 info->keep_memory);
3886 if (internal_relocs == NULL)
3887 goto error_ret_free_local;
3888
3889 /* Now examine each relocation. */
3890 irela = internal_relocs;
3891 irelaend = irela + section->reloc_count;
3892 for (; irela < irelaend; irela++)
3893 {
3894 unsigned int r_type, r_indx;
3895 enum elf_metag_stub_type stub_type;
3896 struct elf_metag_stub_hash_entry *hsh;
3897 asection *sym_sec;
3898 bfd_vma sym_value;
3899 bfd_vma destination;
3900 struct elf_metag_link_hash_entry *hh;
3901 char *stub_name;
3902 const asection *id_sec;
3903
3904 r_type = ELF32_R_TYPE (irela->r_info);
3905 r_indx = ELF32_R_SYM (irela->r_info);
3906
3907 if (r_type >= (unsigned int) R_METAG_MAX)
3908 {
3909 bfd_set_error (bfd_error_bad_value);
3910 error_ret_free_internal:
3911 if (elf_section_data (section)->relocs == NULL)
3912 free (internal_relocs);
3913 goto error_ret_free_local;
3914 }
3915
3916 /* Only look for stubs on CALLR and B instructions. */
3917 if (!(r_type == (unsigned int) R_METAG_RELBRANCH ||
3918 r_type == (unsigned int) R_METAG_RELBRANCH_PLT))
3919 continue;
3920
3921 /* Now determine the call target, its name, value,
3922 section. */
3923 sym_sec = NULL;
3924 sym_value = 0;
3925 destination = 0;
3926 hh = NULL;
3927 if (r_indx < symtab_hdr->sh_info)
3928 {
3929 /* It's a local symbol. */
3930 Elf_Internal_Sym *sym;
3931 Elf_Internal_Shdr *hdr;
3932 unsigned int shndx;
3933
3934 sym = local_syms + r_indx;
3935 if (ELF_ST_TYPE (sym->st_info) != STT_SECTION)
3936 sym_value = sym->st_value;
3937 shndx = sym->st_shndx;
3938 if (shndx < elf_numsections (input_bfd))
3939 {
3940 hdr = elf_elfsections (input_bfd)[shndx];
3941 sym_sec = hdr->bfd_section;
3942 destination = (sym_value + irela->r_addend
3943 + sym_sec->output_offset
3944 + sym_sec->output_section->vma);
3945 }
3946 }
3947 else
3948 {
3949 /* It's an external symbol. */
3950 int e_indx;
3951
3952 e_indx = r_indx - symtab_hdr->sh_info;
3953 hh = ((struct elf_metag_link_hash_entry *)
3954 elf_sym_hashes (input_bfd)[e_indx]);
3955
3956 while (hh->eh.root.type == bfd_link_hash_indirect
3957 || hh->eh.root.type == bfd_link_hash_warning)
3958 hh = ((struct elf_metag_link_hash_entry *)
3959 hh->eh.root.u.i.link);
3960
3961 if (hh->eh.root.type == bfd_link_hash_defined
3962 || hh->eh.root.type == bfd_link_hash_defweak)
3963 {
3964 sym_sec = hh->eh.root.u.def.section;
3965 sym_value = hh->eh.root.u.def.value;
3966 if (hh->eh.plt.offset != (bfd_vma) -1
3967 && hh->eh.dynindx != -1
3968 && r_type == (unsigned int) R_METAG_RELBRANCH_PLT)
3969 {
ce558b89 3970 sym_sec = htab->etab.splt;
a3c62988
NC		 3971 sym_value = hh->eh.plt.offset;
3972 }
3973
3974 if (sym_sec->output_section != NULL)
3975 destination = (sym_value + irela->r_addend
3976 + sym_sec->output_offset
3977 + sym_sec->output_section->vma);
3978 else
3979 continue;
3980 }
3981 else if (hh->eh.root.type == bfd_link_hash_undefweak)
3982 {
0e1862bb 3983 if (! bfd_link_pic (info))
a3c62988
NC		 3984 continue;
3985 }
3986 else if (hh->eh.root.type == bfd_link_hash_undefined)
3987 {
3988 if (! (info->unresolved_syms_in_objects == RM_IGNORE
3989 && (ELF_ST_VISIBILITY (hh->eh.other)
3990 == STV_DEFAULT)))
3991 continue;
3992 }
3993 else
3994 {
3995 bfd_set_error (bfd_error_bad_value);
3996 goto error_ret_free_internal;
3997 }
3998 }
3999
4000 /* Determine what (if any) linker stub is needed. */
4001 stub_type = metag_type_of_stub (section, irela, hh,
4002 destination, info);
4003 if (stub_type == metag_stub_none)
4004 continue;
4005
4006 /* Support for grouping stub sections. */
4007 id_sec = htab->stub_group[section->id].link_sec;
4008
4009 /* Get the name of this stub. */
4010 stub_name = metag_stub_name (id_sec, sym_sec, hh, irela);
4011 if (!stub_name)
4012 goto error_ret_free_internal;
4013
4014 hsh = metag_stub_hash_lookup (&htab->bstab,
4015 stub_name,
4016 FALSE, FALSE);
4017 if (hsh != NULL)
4018 {
4019 /* The proper stub has already been created. */
4020 free (stub_name);
4021 continue;
4022 }
4023
4024 hsh = metag_add_stub (stub_name, section, htab);
4025 if (hsh == NULL)
4026 {
4027 free (stub_name);
4028 goto error_ret_free_internal;
4029 }
4030 hsh->target_value = sym_value;
4031 hsh->target_section = sym_sec;
4032 hsh->stub_type = stub_type;
4033 hsh->hh = hh;
4034 hsh->addend = irela->r_addend;
4035 stub_changed = TRUE;
4036 }
4037
4038 /* We're done with the internal relocs, free them. */
4039 if (elf_section_data (section)->relocs == NULL)
4040 free (internal_relocs);
4041 }
4042 }
4043
4044 if (!stub_changed)
4045 break;
4046
4047 /* OK, we've added some stubs. Find out the new size of the
4048 stub sections. */
4049 for (stub_sec = htab->stub_bfd->sections;
4050 stub_sec != NULL;
4051 stub_sec = stub_sec->next)
4052 stub_sec->size = 0;
4053
4054 bfd_hash_traverse (&htab->bstab, metag_size_one_stub, htab);
4055
4056 /* Ask the linker to do its stuff. */
4057 (*htab->layout_sections_again) ();
4058 stub_changed = FALSE;
4059 }
4060
4061 free (htab->all_local_syms);
4062 return TRUE;
4063
4064 error_ret_free_local:
4065 free (htab->all_local_syms);
4066 return FALSE;
4067}
4068
4069/* Build all the stubs associated with the current output file. The
4070 stubs are kept in a hash table attached to the main linker hash
4071 table. This function is called via metagelf_finish in the linker. */
4072
4073bfd_boolean
4074elf_metag_build_stubs (struct bfd_link_info *info)
4075{
4076 asection *stub_sec;
4077 struct bfd_hash_table *table;
4078 struct elf_metag_link_hash_table *htab;
4079
4080 htab = metag_link_hash_table (info);
4081
4082 for (stub_sec = htab->stub_bfd->sections;
4083 stub_sec != NULL;
4084 stub_sec = stub_sec->next)
4085 {
4086 bfd_size_type size;
4087
4088 /* Allocate memory to hold the linker stubs. */
4089 size = stub_sec->size;
4090 stub_sec->contents = bfd_zalloc (htab->stub_bfd, size);
4091 if (stub_sec->contents == NULL && size != 0)
4092 return FALSE;
4093 stub_sec->size = 0;
4094 }
4095
4096 /* Build the stubs as directed by the stub hash table. */
4097 table = &htab->bstab;
4098 bfd_hash_traverse (table, metag_build_one_stub, info);
4099
4100 return TRUE;
4101}
4102
4103/* Return TRUE if SYM represents a local label symbol. */
4104
4105static bfd_boolean
4106elf_metag_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
4107{
4108 if (name[0] == '$' && name[1] == 'L')
4109 return 1;
4110 return _bfd_elf_is_local_label_name (abfd, name);
4111}
4112
4113/* Return address for Ith PLT stub in section PLT, for relocation REL
4114 or (bfd_vma) -1 if it should not be included. */
4115
4116static bfd_vma
4117elf_metag_plt_sym_val (bfd_vma i, const asection *plt,
4118 const arelent *rel ATTRIBUTE_UNUSED)
4119{
4120 return plt->vma + (i + 1) * PLT_ENTRY_SIZE;
4121}
4122
4123#define ELF_ARCH bfd_arch_metag
4124#define ELF_TARGET_ID METAG_ELF_DATA
4125#define ELF_MACHINE_CODE EM_METAG
4126#define ELF_MINPAGESIZE 0x1000
4127#define ELF_MAXPAGESIZE 0x4000
4128#define ELF_COMMONPAGESIZE 0x1000
4129
6d00b590 4130#define TARGET_LITTLE_SYM metag_elf32_vec
a3c62988
NC		 4131#define TARGET_LITTLE_NAME "elf32-metag"
4132
4133#define elf_symbol_leading_char '_'
4134
4135#define elf_info_to_howto_rel NULL
4136#define elf_info_to_howto metag_info_to_howto_rela
4137
4138#define bfd_elf32_bfd_is_local_label_name elf_metag_is_local_label_name
4139#define bfd_elf32_bfd_link_hash_table_create \
4140 elf_metag_link_hash_table_create
a3c62988
NC		 4141#define elf_backend_relocate_section elf_metag_relocate_section
4142#define elf_backend_gc_mark_hook elf_metag_gc_mark_hook
a3c62988
NC		 4143#define elf_backend_check_relocs elf_metag_check_relocs
4144#define elf_backend_create_dynamic_sections elf_metag_create_dynamic_sections
4145#define elf_backend_adjust_dynamic_symbol elf_metag_adjust_dynamic_symbol
4146#define elf_backend_finish_dynamic_symbol elf_metag_finish_dynamic_symbol
4147#define elf_backend_finish_dynamic_sections elf_metag_finish_dynamic_sections
4148#define elf_backend_size_dynamic_sections elf_metag_size_dynamic_sections
4149#define elf_backend_omit_section_dynsym \
d00dd7dc 4150 _bfd_elf_omit_section_dynsym_all
ed7e9d0b 4151#define elf_backend_init_file_header elf_metag_init_file_header
a3c62988
NC		 4152#define elf_backend_reloc_type_class elf_metag_reloc_type_class
4153#define elf_backend_copy_indirect_symbol elf_metag_copy_indirect_symbol
4154#define elf_backend_plt_sym_val elf_metag_plt_sym_val
4155
4156#define elf_backend_can_gc_sections 1
4157#define elf_backend_can_refcount 1
ce558b89
AM		 4158#define elf_backend_rela_normal 1
4159#define elf_backend_want_got_plt 1
a3c62988
NC		 4160#define elf_backend_want_got_sym 0
4161#define elf_backend_want_plt_sym 0
4162#define elf_backend_plt_readonly 1
64f52338 4163#define elf_backend_dtrel_excludes_plt 1
5474d94f 4164#define elf_backend_want_dynrelro 1
a3c62988
NC		 4165
4166#define bfd_elf32_bfd_reloc_type_lookup metag_reloc_type_lookup
4167#define bfd_elf32_bfd_reloc_name_lookup metag_reloc_name_lookup
4168
4169#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.620968 seconds and 4 git commands to generate.