Annotation of src/external/gpl3/binutils.old/dist/bfd/elf32-metag.c, Revision 1.1.1.4
1.1 christos 1: /* Meta support for 32-bit ELF
1.1.1.4 ! christos 2: Copyright (C) 2013-2020 Free Software Foundation, Inc.
1.1 christos 3: Contributed by Imagination Technologies Ltd.
4:
5: This file is part of BFD, the Binary File Descriptor library.
6:
7: This program is free software; you can redistribute it and/or modify
8: it under the terms of the GNU General Public License as published by
9: the Free Software Foundation; either version 3 of the License, or
10: (at your option) any later version.
11:
12: This program is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20: MA 02110-1301, USA. */
21:
22: #include "sysdep.h"
23: #include "bfd.h"
24: #include "libbfd.h"
25: #include "elf-bfd.h"
26: #include "elf32-metag.h"
27: #include "elf/metag.h"
28:
29: #define GOT_ENTRY_SIZE 4
30: #define ELF_DYNAMIC_INTERPRETER "/lib/ld-uClibc.so.0"
31:
32: /* ABI version:
33: 0 - original
34: 1 - with GOT offset */
35: #define METAG_ELF_ABI_VERSION 1
36:
37: static const unsigned int plt0_entry[] =
38: {
39: 0x02000005, /* MOVT D0Re0, #HI(GOT+4) */
40: 0x02000000, /* ADD D0Re0, D0Re0, #LO(GOT+4) */
41: 0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
42: 0xc600012a, /* GETD PC, [D0Re0+#4] */
43: 0xa0fffffe /* NOP */
44: };
45:
46: static const unsigned int plt0_pic_entry[] =
47: {
48: 0x82900001, /* ADDT A0.2, CPC0, #0 */
49: 0x82100000, /* ADD A0.2, A0.2, #0 */
50: 0xa3100c20, /* MOV D0Re0, A0.2 */
51: 0xb70001e3, /* SETL [A0StP++], D0Re0, D1Re0 */
52: 0xc600012a, /* GETD PC, [D0Re0+#4] */
53: };
54:
55: static const unsigned int plt_entry[] =
56: {
57: 0x82100005, /* MOVT A0.2, #HI(GOT+off) */
58: 0x82100000, /* ADD A0.2, A0.2, #LO(GOT+off) */
59: 0xc600806a, /* GETD PC, [A0.2] */
60: 0x03000004, /* MOV D1Re0, #LO(offset) */
61: 0xa0000000 /* B PLT0 */
62: };
63:
64: static const unsigned int plt_pic_entry[] =
65: {
66: 0x82900001, /* ADDT A0.2, CPC0, #HI(GOT+off) */
67: 0x82100000, /* ADD A0.2, A0.2, #LO(GOT+off) */
68: 0xc600806a, /* GETD PC, [A0.2] */
69: 0x03000004, /* MOV D1Re0, #LO(offset) */
70: 0xa0000000 /* B PLT0 */
71: };
72:
73: /* Variable names follow a coding style.
74: Please follow this (Apps Hungarian) style:
75:
1.1.1.3 christos 76: Structure/Variable Prefix
77: elf_link_hash_table "etab"
78: elf_link_hash_entry "eh"
1.1 christos 79:
1.1.1.3 christos 80: elf_metag_link_hash_table "htab"
81: elf_metag_link_hash_entry "hh"
1.1 christos 82:
1.1.1.3 christos 83: bfd_link_hash_table "btab"
84: bfd_link_hash_entry "bh"
1.1 christos 85:
86: bfd_hash_table containing stubs "bstab"
1.1.1.3 christos 87: elf_metag_stub_hash_entry "hsh"
1.1 christos 88:
89: Always remember to use GNU Coding Style. */
90:
91: #define PLT_ENTRY_SIZE sizeof(plt_entry)
92:
93: static reloc_howto_type elf_metag_howto_table[] =
94: {
95: /* High order 16 bit absolute. */
96: HOWTO (R_METAG_HIADDR16, /* type */
97: 16, /* rightshift */
98: 2, /* size (0 = byte, 1 = short, 2 = long) */
99: 16, /* bitsize */
100: FALSE, /* pc_relative */
101: 3, /* bitpos */
102: complain_overflow_dont, /* complain_on_overflow */
103: bfd_elf_generic_reloc, /* special_function */
104: "R_METAG_HIADDR16", /* name */
105: FALSE, /* partial_inplace */
106: 0, /* src_mask */
107: 0x0007fff8, /* dst_mask */
108: FALSE), /* pcrel_offset */
109:
110: /* Low order 16 bit absolute. */
111: HOWTO (R_METAG_LOADDR16, /* type */
112: 0, /* rightshift */
113: 2, /* size (0 = byte, 1 = short, 2 = long) */
114: 16, /* bitsize */
115: FALSE, /* pc_relative */
116: 3, /* bitpos */
117: complain_overflow_dont,/* complain_on_overflow */
118: bfd_elf_generic_reloc, /* special_function */
119: "R_METAG_LOADDR16", /* name */
120: FALSE, /* partial_inplace */
121: 0, /* src_mask */
122: 0x0007fff8, /* dst_mask */
123: FALSE), /* pcrel_offset */
124:
125: /* 32 bit absolute. */
126: HOWTO (R_METAG_ADDR32, /* type */
127: 0, /* rightshift */
128: 2, /* size (0 = byte, 1 = short, 2 = long) */
129: 32, /* bitsize */
130: FALSE, /* pc_relative */
131: 0, /* bitpos */
132: complain_overflow_bitfield, /* complain_on_overflow */
133: bfd_elf_generic_reloc, /* special_function */
134: "R_METAG_ADDR32", /* name */
135: FALSE, /* partial_inplace */
136: 0x00000000, /* src_mask */
137: 0xffffffff, /* dst_mask */
138: FALSE), /* pcrel_offset */
139:
140: /* No relocation. */
141: HOWTO (R_METAG_NONE, /* type */
142: 0, /* rightshift */
143: 3, /* size (0 = byte, 1 = short, 2 = long) */
144: 0, /* bitsize */
145: FALSE, /* pc_relative */
146: 0, /* bitpos */
147: complain_overflow_dont, /* complain_on_overflow */
148: bfd_elf_generic_reloc, /* special_function */
149: "R_METAG_NONE", /* name */
150: FALSE, /* partial_inplace */
151: 0, /* src_mask */
152: 0, /* dst_mask */
153: FALSE), /* pcrel_offset */
154:
155: /* 19 bit pc relative */
156: HOWTO (R_METAG_RELBRANCH, /* type */
157: 2, /* rightshift */
158: 2, /* size (0 = byte, 1 = short, 2 = long) */
159: 19, /* bitsize */
160: TRUE, /* pc_relative */
161: 5, /* bitpos */
162: complain_overflow_signed, /* complain_on_overflow */
163: bfd_elf_generic_reloc, /* special_function */
164: "R_METAG_RELBRANCH", /* name */
165: FALSE, /* partial_inplace */
166: 0, /* src_mask */
167: 0x00ffffe0, /* dst_mask */
168: FALSE), /* pcrel_offset */
169:
170: /* GET/SET offset */
171: HOWTO (R_METAG_GETSETOFF, /* type */
172: 0, /* rightshift */
173: 1, /* size (0 = byte, 1 = short, 2 = long) */
174: 12, /* bitsize */
175: FALSE, /* pc_relative */
176: 7, /* bitpos */
177: complain_overflow_dont, /* complain_on_overflow */
178: bfd_elf_generic_reloc, /* special_function */
179: "R_METAG_GETSETOFF", /* name */
180: FALSE, /* partial_inplace */
181: 0, /* src_mask */
182: 0, /* dst_mask */
183: FALSE), /* pcrel_offset */
184:
185: EMPTY_HOWTO (6),
186: EMPTY_HOWTO (7),
187: EMPTY_HOWTO (8),
188: EMPTY_HOWTO (9),
189: EMPTY_HOWTO (10),
190: EMPTY_HOWTO (11),
191: EMPTY_HOWTO (12),
192: EMPTY_HOWTO (13),
193: EMPTY_HOWTO (14),
194: EMPTY_HOWTO (15),
195: EMPTY_HOWTO (16),
196: EMPTY_HOWTO (17),
197: EMPTY_HOWTO (18),
198: EMPTY_HOWTO (19),
199: EMPTY_HOWTO (20),
200: EMPTY_HOWTO (21),
201: EMPTY_HOWTO (22),
202: EMPTY_HOWTO (23),
203: EMPTY_HOWTO (24),
204: EMPTY_HOWTO (25),
205: EMPTY_HOWTO (26),
206: EMPTY_HOWTO (27),
207: EMPTY_HOWTO (28),
208: EMPTY_HOWTO (29),
209:
210: HOWTO (R_METAG_GNU_VTINHERIT, /* type */
211: 0, /* rightshift */
212: 2, /* size (0 = byte, 1 = short, 2 = long) */
213: 0, /* bitsize */
214: FALSE, /* pc_relative */
215: 0, /* bitpos */
216: complain_overflow_dont, /* complain_on_overflow */
217: NULL, /* special_function */
218: "R_METAG_GNU_VTINHERIT", /* name */
219: FALSE, /* partial_inplace */
220: 0, /* src_mask */
221: 0, /* dst_mask */
222: FALSE), /* pcrel_offset */
223:
224: HOWTO (R_METAG_GNU_VTENTRY, /* type */
225: 0, /* rightshift */
226: 2, /* size (0 = byte, 1 = short, 2 = long) */
227: 0, /* bitsize */
228: FALSE, /* pc_relative */
229: 0, /* bitpos */
230: complain_overflow_dont, /* complain_on_overflow */
231: _bfd_elf_rel_vtable_reloc_fn, /* special_function */
232: "R_METAG_GNU_VTENTRY", /* name */
233: FALSE, /* partial_inplace */
234: 0, /* src_mask */
235: 0, /* dst_mask */
236: FALSE), /* pcrel_offset */
237:
238: /* High order 16 bit GOT offset */
239: HOWTO (R_METAG_HI16_GOTOFF, /* type */
240: 16, /* rightshift */
241: 2, /* size (0 = byte, 1 = short, 2 = long) */
242: 16, /* bitsize */
243: FALSE, /* pc_relative */
244: 3, /* bitpos */
245: complain_overflow_dont, /* complain_on_overflow */
246: bfd_elf_generic_reloc, /* special_function */
247: "R_METAG_HI16_GOTOFF", /* name */
248: FALSE, /* partial_inplace */
249: 0, /* src_mask */
250: 0x0007fff8, /* dst_mask */
251: FALSE), /* pcrel_offset */
252:
253: /* Low order 16 bit GOT offset */
254: HOWTO (R_METAG_LO16_GOTOFF, /* type */
255: 0, /* rightshift */
256: 2, /* size (0 = byte, 1 = short, 2 = long) */
257: 16, /* bitsize */
258: FALSE, /* pc_relative */
259: 3, /* bitpos */
260: complain_overflow_dont, /* complain_on_overflow */
261: bfd_elf_generic_reloc, /* special_function */
262: "R_METAG_LO16_GOTOFF", /* name */
263: FALSE, /* partial_inplace */
264: 0, /* src_mask */
265: 0x0007fff8, /* dst_mask */
266: FALSE), /* pcrel_offset */
267:
268: /* GET/SET GOT offset */
269: HOWTO (R_METAG_GETSET_GOTOFF, /* type */
270: 0, /* rightshift */
271: 1, /* size (0 = byte, 1 = short, 2 = long) */
272: 12, /* bitsize */
273: FALSE, /* pc_relative */
274: 7, /* bitpos */
275: complain_overflow_dont, /* complain_on_overflow */
276: bfd_elf_generic_reloc, /* special_function */
277: "R_METAG_GETSET_GOTOFF", /* name */
278: FALSE, /* partial_inplace */
279: 0, /* src_mask */
280: 0, /* dst_mask */
281: FALSE), /* pcrel_offset */
282:
283: /* GET/SET GOT relative */
284: HOWTO (R_METAG_GETSET_GOT, /* type */
285: 0, /* rightshift */
286: 1, /* size (0 = byte, 1 = short, 2 = long) */
287: 12, /* bitsize */
288: FALSE, /* pc_relative */
289: 7, /* bitpos */
290: complain_overflow_dont, /* complain_on_overflow */
291: bfd_elf_generic_reloc, /* special_function */
292: "R_METAG_GETSET_GOT", /* name */
293: FALSE, /* partial_inplace */
294: 0, /* src_mask */
295: 0, /* dst_mask */
296: FALSE), /* pcrel_offset */
297:
298: /* High order 16 bit GOT reference */
299: HOWTO (R_METAG_HI16_GOTPC, /* type */
300: 16, /* rightshift */
301: 2, /* size (0 = byte, 1 = short, 2 = long) */
302: 16, /* bitsize */
303: FALSE, /* pc_relative */
304: 3, /* bitpos */
305: complain_overflow_dont, /* complain_on_overflow */
306: bfd_elf_generic_reloc, /* special_function */
307: "R_METAG_HI16_GOTPC", /* name */
308: FALSE, /* partial_inplace */
309: 0, /* src_mask */
310: 0x0007fff8, /* dst_mask */
311: FALSE), /* pcrel_offset */
312:
313: /* Low order 16 bit GOT reference */
314: HOWTO (R_METAG_LO16_GOTPC, /* type */
315: 0, /* rightshift */
316: 2, /* size (0 = byte, 1 = short, 2 = long) */
317: 16, /* bitsize */
318: FALSE, /* pc_relative */
319: 3, /* bitpos */
320: complain_overflow_dont, /* complain_on_overflow */
321: bfd_elf_generic_reloc, /* special_function */
322: "R_METAG_LO16_GOTPC", /* name */
323: FALSE, /* partial_inplace */
324: 0, /* src_mask */
325: 0x0007fff8, /* dst_mask */
326: FALSE), /* pcrel_offset */
327:
328: /* High order 16 bit PLT */
329: HOWTO (R_METAG_HI16_PLT, /* type */
330: 16, /* rightshift */
331: 2, /* size (0 = byte, 1 = short, 2 = long) */
332: 16, /* bitsize */
333: FALSE, /* pc_relative */
334: 3, /* bitpos */
335: complain_overflow_dont, /* complain_on_overflow */
336: bfd_elf_generic_reloc, /* special_function */
337: "R_METAG_HI16_PLT", /* name */
338: FALSE, /* partial_inplace */
339: 0, /* src_mask */
340: 0x0007fff8, /* dst_mask */
341: FALSE), /* pcrel_offset */
342:
343: /* Low order 16 bit PLT */
344: HOWTO (R_METAG_LO16_PLT, /* type */
345: 0, /* rightshift */
346: 2, /* size (0 = byte, 1 = short, 2 = long) */
347: 16, /* bitsize */
348: FALSE, /* pc_relative */
349: 3, /* bitpos */
350: complain_overflow_dont, /* complain_on_overflow */
351: bfd_elf_generic_reloc, /* special_function */
352: "R_METAG_LO16_PLT", /* name */
353: FALSE, /* partial_inplace */
354: 0, /* src_mask */
355: 0xffffffff, /* dst_mask */
356: FALSE), /* pcrel_offset */
357:
358: HOWTO (R_METAG_RELBRANCH_PLT, /* type */
359: 2, /* rightshift */
360: 2, /* size (0 = byte, 1 = short, 2 = long) */
361: 19, /* bitsize */
362: TRUE, /* pc_relative */
363: 5, /* bitpos */
364: complain_overflow_signed, /* complain_on_overflow */
365: bfd_elf_generic_reloc, /* special_function */
366: "R_METAG_RELBRANCH_PLT", /* name */
367: FALSE, /* partial_inplace */
368: 0, /* src_mask */
369: 0x00ffffe0, /* dst_mask */
370: FALSE), /* pcrel_offset */
371:
372: /* Dummy relocs used by the linker internally. */
373: HOWTO (R_METAG_GOTOFF, /* type */
374: 0, /* rightshift */
375: 2, /* size (0 = byte, 1 = short, 2 = long) */
376: 32, /* bitsize */
377: FALSE, /* pc_relative */
378: 0, /* bitpos */
379: complain_overflow_bitfield, /* complain_on_overflow */
380: bfd_elf_generic_reloc, /* special_function */
381: "R_METAG_GOTOFF", /* name */
382: FALSE, /* partial_inplace */
383: 0xffffffff, /* src_mask */
384: 0xffffffff, /* dst_mask */
385: FALSE), /* pcrel_offset */
386:
387: HOWTO (R_METAG_PLT, /* type */
388: 0, /* rightshift */
389: 2, /* size (0 = byte, 1 = short, 2 = long) */
390: 32, /* bitsize */
391: FALSE, /* pc_relative */
392: 0, /* bitpos */
393: complain_overflow_bitfield, /* complain_on_overflow */
394: bfd_elf_generic_reloc, /* special_function */
395: "R_METAG_GOTOFF", /* name */
396: FALSE, /* partial_inplace */
397: 0xffffffff, /* src_mask */
398: 0xffffffff, /* dst_mask */
399: FALSE), /* pcrel_offset */
400:
401: /* This is used only by the dynamic linker. The symbol should exist
402: both in the object being run and in some shared library. The
403: dynamic linker copies the data addressed by the symbol from the
404: shared library into the object, because the object being
405: run has to have the data at some particular address. */
406: HOWTO (R_METAG_COPY, /* type */
407: 0, /* rightshift */
408: 2, /* size (0 = byte, 1 = short, 2 = long) */
409: 32, /* bitsize */
410: FALSE, /* pc_relative */
411: 0, /* bitpos */
412: complain_overflow_bitfield, /* complain_on_overflow */
413: bfd_elf_generic_reloc, /* special_function */
414: "R_METAG_COPY", /* name */
415: FALSE, /* partial_inplace */
416: 0xffffffff, /* src_mask */
417: 0xffffffff, /* dst_mask */
418: FALSE), /* pcrel_offset */
419:
420: /* Marks a procedure linkage table entry for a symbol. */
421: HOWTO (R_METAG_JMP_SLOT, /* type */
422: 0, /* rightshift */
423: 2, /* size (0 = byte, 1 = short, 2 = long) */
424: 32, /* bitsize */
425: FALSE, /* pc_relative */
426: 0, /* bitpos */
427: complain_overflow_bitfield, /* complain_on_overflow */
428: bfd_elf_generic_reloc, /* special_function */
429: "R_METAG_JMP_SLOT", /* name */
430: FALSE, /* partial_inplace */
431: 0xffffffff, /* src_mask */
432: 0xffffffff, /* dst_mask */
433: FALSE), /* pcrel_offset */
434:
435: /* Used only by the dynamic linker. When the object is run, this
436: longword is set to the load address of the object, plus the
437: addend. */
438: HOWTO (R_METAG_RELATIVE, /* type */
439: 0, /* rightshift */
440: 2, /* size (0 = byte, 1 = short, 2 = long) */
441: 32, /* bitsize */
442: FALSE, /* pc_relative */
443: 0, /* bitpos */
444: complain_overflow_bitfield, /* complain_on_overflow */
445: bfd_elf_generic_reloc, /* special_function */
446: "R_METAG_RELATIVE", /* name */
447: FALSE, /* partial_inplace */
448: 0xffffffff, /* src_mask */
449: 0xffffffff, /* dst_mask */
450: FALSE), /* pcrel_offset */
451:
452: HOWTO (R_METAG_GLOB_DAT, /* type */
453: 0, /* rightshift */
454: 2, /* size (0 = byte, 1 = short, 2 = long) */
455: 32, /* bitsize */
456: FALSE, /* pc_relative */
457: 0, /* bitpos */
458: complain_overflow_bitfield, /* complain_on_overflow */
459: bfd_elf_generic_reloc, /* special_function */
460: "R_METAG_GLOB_DAT", /* name */
461: FALSE, /* partial_inplace */
462: 0xffffffff, /* src_mask */
463: 0xffffffff, /* dst_mask */
464: FALSE), /* pcrel_offset */
465:
466: HOWTO (R_METAG_TLS_GD, /* type */
467: 0, /* rightshift */
468: 2, /* size (0 = byte, 1 = short, 2 = long) */
469: 16, /* bitsize */
470: FALSE, /* pc_relative */
471: 3, /* bitpos */
472: complain_overflow_dont, /* complain_on_overflow */
473: bfd_elf_generic_reloc, /* special_function */
474: "R_METAG_TLS_GD", /* name */
475: FALSE, /* partial_inplace */
476: 0, /* src_mask */
477: 0x0007fff8, /* dst_mask */
478: FALSE), /* pcrel_offset */
479:
480: HOWTO (R_METAG_TLS_LDM, /* type */
481: 0, /* rightshift */
482: 2, /* size (0 = byte, 1 = short, 2 = long) */
483: 16, /* bitsize */
484: FALSE, /* pc_relative */
485: 3, /* bitpos */
486: complain_overflow_bitfield, /* complain_on_overflow */
487: bfd_elf_generic_reloc, /* special_function */
488: "R_METAG_TLS_LDM", /* name */
489: FALSE, /* partial_inplace */
490: 0, /* src_mask */
491: 0x0007fff8, /* dst_mask */
492: FALSE), /* pcrel_offset */
493:
494: HOWTO (R_METAG_TLS_LDO_HI16, /* type */
495: 16, /* rightshift */
496: 2, /* size (0 = byte, 1 = short, 2 = long) */
497: 16, /* bitsize */
498: FALSE, /* pc_relative */
499: 3, /* bitpos */
500: complain_overflow_bitfield, /* complain_on_overflow */
501: bfd_elf_generic_reloc, /* special_function */
502: "R_METAG_TLS_LDO_HI16", /* name */
503: FALSE, /* partial_inplace */
504: 0, /* src_mask */
505: 0x0007fff8, /* dst_mask */
506: FALSE), /* pcrel_offset */
507:
508: HOWTO (R_METAG_TLS_LDO_LO16, /* type */
509: 0, /* rightshift */
510: 2, /* size (0 = byte, 1 = short, 2 = long) */
511: 16, /* bitsize */
512: FALSE, /* pc_relative */
513: 3, /* bitpos */
514: complain_overflow_bitfield, /* complain_on_overflow */
515: bfd_elf_generic_reloc, /* special_function */
516: "R_METAG_TLS_LDO_LO16", /* name */
517: FALSE, /* partial_inplace */
518: 0, /* src_mask */
519: 0x0007fff8, /* dst_mask */
520: FALSE), /* pcrel_offset */
521:
522: /* Dummy reloc used by the linker internally. */
523: HOWTO (R_METAG_TLS_LDO, /* type */
524: 0, /* rightshift */
525: 2, /* size (0 = byte, 1 = short, 2 = long) */
526: 16, /* bitsize */
527: FALSE, /* pc_relative */
528: 3, /* bitpos */
529: complain_overflow_bitfield, /* complain_on_overflow */
530: bfd_elf_generic_reloc, /* special_function */
531: "R_METAG_TLS_LDO", /* name */
532: FALSE, /* partial_inplace */
533: 0, /* src_mask */
534: 0x0007fff8, /* dst_mask */
535: FALSE), /* pcrel_offset */
536:
537: HOWTO (R_METAG_TLS_IE, /* type */
538: 2, /* rightshift */
539: 2, /* size (0 = byte, 1 = short, 2 = long) */
540: 12, /* bitsize */
541: FALSE, /* pc_relative */
542: 7, /* bitpos */
543: complain_overflow_dont, /* complain_on_overflow */
544: bfd_elf_generic_reloc, /* special_function */
545: "R_METAG_TLS_IE", /* name */
546: FALSE, /* partial_inplace */
547: 0, /* src_mask */
548: 0x0007ff80, /* dst_mask */
549: FALSE), /* pcrel_offset */
550:
551: /* Dummy reloc used by the linker internally. */
552: HOWTO (R_METAG_TLS_IENONPIC, /* type */
553: 0, /* rightshift */
554: 2, /* size (0 = byte, 1 = short, 2 = long) */
555: 16, /* bitsize */
556: FALSE, /* pc_relative */
557: 3, /* bitpos */
558: complain_overflow_dont, /* complain_on_overflow */
559: bfd_elf_generic_reloc, /* special_function */
560: "R_METAG_TLS_IENONPIC", /* name */
561: FALSE, /* partial_inplace */
562: 0, /* src_mask */
563: 0x0007fff8, /* dst_mask */
564: FALSE), /* pcrel_offset */
565:
566: HOWTO (R_METAG_TLS_IENONPIC_HI16,/* type */
567: 16, /* rightshift */
568: 2, /* size (0 = byte, 1 = short, 2 = long) */
569: 16, /* bitsize */
570: FALSE, /* pc_relative */
571: 3, /* bitpos */
572: complain_overflow_dont, /* complain_on_overflow */
573: bfd_elf_generic_reloc, /* special_function */
574: "R_METAG_TLS_IENONPIC_HI16", /* name */
575: FALSE, /* partial_inplace */
576: 0, /* src_mask */
577: 0x0007fff8, /* dst_mask */
578: FALSE), /* pcrel_offset */
579:
580: HOWTO (R_METAG_TLS_IENONPIC_LO16,/* type */
581: 0, /* rightshift */
582: 2, /* size (0 = byte, 1 = short, 2 = long) */
583: 16, /* bitsize */
584: FALSE, /* pc_relative */
585: 3, /* bitpos */
586: complain_overflow_dont, /* complain_on_overflow */
587: bfd_elf_generic_reloc, /* special_function */
588: "R_METAG_TLS_IENONPIC_LO16", /* name */
589: FALSE, /* partial_inplace */
590: 0, /* src_mask */
591: 0x0007fff8, /* dst_mask */
592: FALSE), /* pcrel_offset */
593:
594: HOWTO (R_METAG_TLS_TPOFF, /* type */
595: 0, /* rightshift */
596: 2, /* size (0 = byte, 1 = short, 2 = long) */
597: 32, /* bitsize */
598: FALSE, /* pc_relative */
599: 0, /* bitpos */
600: complain_overflow_bitfield, /* complain_on_overflow */
601: bfd_elf_generic_reloc, /* special_function */
602: "R_METAG_TLS_TPOFF", /* name */
603: FALSE, /* partial_inplace */
604: 0, /* src_mask */
605: 0xffffffff, /* dst_mask */
606: FALSE), /* pcrel_offset */
607:
608: HOWTO (R_METAG_TLS_DTPMOD, /* type */
609: 0, /* rightshift */
610: 2, /* size (0 = byte, 1 = short, 2 = long) */
611: 32, /* bitsize */
612: FALSE, /* pc_relative */
613: 0, /* bitpos */
614: complain_overflow_bitfield, /* complain_on_overflow */
615: bfd_elf_generic_reloc, /* special_function */
616: "R_METAG_TLS_DTPMOD", /* name */
617: FALSE, /* partial_inplace */
618: 0, /* src_mask */
619: 0xffffffff, /* dst_mask */
620: FALSE), /* pcrel_offset */
621:
622: HOWTO (R_METAG_TLS_DTPOFF, /* type */
623: 0, /* rightshift */
624: 2, /* size (0 = byte, 1 = short, 2 = long) */
625: 32, /* bitsize */
626: FALSE, /* pc_relative */
627: 0, /* bitpos */
628: complain_overflow_bitfield, /* complain_on_overflow */
629: bfd_elf_generic_reloc, /* special_function */
630: "R_METAG_TLS_DTPOFF", /* name */
631: FALSE, /* partial_inplace */
632: 0, /* src_mask */
633: 0xffffffff, /* dst_mask */
634: FALSE), /* pcrel_offset */
635:
636: /* Dummy reloc used by the linker internally. */
637: HOWTO (R_METAG_TLS_LE, /* type */
638: 0, /* rightshift */
639: 2, /* size (0 = byte, 1 = short, 2 = long) */
640: 32, /* bitsize */
641: FALSE, /* pc_relative */
642: 0, /* bitpos */
643: complain_overflow_bitfield, /* complain_on_overflow */
644: bfd_elf_generic_reloc, /* special_function */
645: "R_METAG_TLS_LE", /* name */
646: FALSE, /* partial_inplace */
647: 0, /* src_mask */
648: 0xffffffff, /* dst_mask */
649: FALSE), /* pcrel_offset */
650:
651: HOWTO (R_METAG_TLS_LE_HI16, /* type */
652: 16, /* rightshift */
653: 2, /* size (0 = byte, 1 = short, 2 = long) */
654: 16, /* bitsize */
655: FALSE, /* pc_relative */
656: 3, /* bitpos */
657: complain_overflow_dont, /* complain_on_overflow */
658: bfd_elf_generic_reloc, /* special_function */
659: "R_METAG_TLS_LE_HI16", /* name */
660: FALSE, /* partial_inplace */
661: 0, /* src_mask */
662: 0x0007fff8, /* dst_mask */
663: FALSE), /* pcrel_offset */
664:
665: HOWTO (R_METAG_TLS_LE_LO16, /* type */
666: 0, /* rightshift */
667: 2, /* size (0 = byte, 1 = short, 2 = long) */
668: 16, /* bitsize */
669: FALSE, /* pc_relative */
670: 3, /* bitpos */
671: complain_overflow_dont, /* complain_on_overflow */
672: bfd_elf_generic_reloc, /* special_function */
673: "R_METAG_TLS_LE_LO16", /* name */
674: FALSE, /* partial_inplace */
675: 0, /* src_mask */
676: 0x0007fff8, /* dst_mask */
677: FALSE), /* pcrel_offset */
678:
679: };
680:
681: #define BRANCH_BITS 19
682:
683: /* The GOT is typically accessed using a [GS]ETD instruction. The size of the
684: immediate offset which can be used in such instructions therefore limits
685: the usable size of the GOT. If the base register for the [GS]ETD (A1LbP)
686: is pointing to the base of the GOT then the size is limited to the maximum
687: 11 bits unsigned dword offset, or 2^13 = 0x2000 bytes. However the offset
688: in a [GS]ETD instruction is signed, so by setting the base address register
689: to an offset of that 0x2000 byte maximum unsigned offset from the base of
690: the GOT we can use negative offsets in addition to positive. This
691: effectively doubles the usable GOT size to 0x4000 bytes. */
692: #define GOT_REG_OFFSET 0x2000
693:
694: struct metag_reloc_map
695: {
696: bfd_reloc_code_real_type bfd_reloc_val;
697: unsigned int metag_reloc_val;
698: };
699:
700: static const struct metag_reloc_map metag_reloc_map [] =
701: {
1.1.1.3 christos 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 },
1.1 christos 706: { BFD_RELOC_METAG_RELBRANCH, R_METAG_RELBRANCH },
707: { BFD_RELOC_METAG_GETSETOFF, R_METAG_GETSETOFF },
1.1.1.3 christos 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 },
1.1 christos 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 },
1.1.1.3 christos 718: { BFD_RELOC_METAG_HI16_PLT, R_METAG_HI16_PLT },
719: { BFD_RELOC_METAG_LO16_PLT, R_METAG_LO16_PLT },
1.1 christos 720: { BFD_RELOC_METAG_RELBRANCH_PLT, R_METAG_RELBRANCH_PLT },
1.1.1.3 christos 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 },
1.1 christos 729: { BFD_RELOC_METAG_TLS_LDO_HI16, R_METAG_TLS_LDO_HI16 },
730: { BFD_RELOC_METAG_TLS_LDO_LO16, R_METAG_TLS_LDO_LO16 },
1.1.1.3 christos 731: { BFD_RELOC_METAG_TLS_LDO, R_METAG_TLS_LDO },
732: { BFD_RELOC_METAG_TLS_IE, R_METAG_TLS_IE },
1.1 christos 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 },
1.1.1.3 christos 739: { BFD_RELOC_METAG_TLS_LE, R_METAG_TLS_LE },
1.1 christos 740: { BFD_RELOC_METAG_TLS_LE_HI16, R_METAG_TLS_LE_HI16 },
741: { BFD_RELOC_METAG_TLS_LE_LO16, R_METAG_TLS_LE_LO16 },
742: };
743:
744: enum elf_metag_stub_type
745: {
746: metag_stub_long_branch,
747: metag_stub_long_branch_shared,
748: metag_stub_none
749: };
750:
751: struct elf_metag_stub_hash_entry
752: {
753: /* Base hash table entry structure. */
754: struct bfd_hash_entry bh_root;
755:
756: /* The stub section. */
757: asection *stub_sec;
758:
759: /* Offset within stub_sec of the beginning of this stub. */
760: bfd_vma stub_offset;
761:
762: /* Given the symbol's value and its section we can determine its final
763: value when building the stubs (so the stub knows where to jump. */
764: bfd_vma target_value;
765: asection *target_section;
766:
767: enum elf_metag_stub_type stub_type;
768:
769: /* The symbol table entry, if any, that this was derived from. */
770: struct elf_metag_link_hash_entry *hh;
771:
772: /* And the reloc addend that this was derived from. */
773: bfd_vma addend;
774:
775: /* Where this stub is being called from, or, in the case of combined
776: stub sections, the first input section in the group. */
777: asection *id_sec;
778: };
779:
780: struct elf_metag_link_hash_entry
781: {
782: struct elf_link_hash_entry eh;
783:
784: /* A pointer to the most recently used stub hash entry against this
785: symbol. */
786: struct elf_metag_stub_hash_entry *hsh_cache;
787:
788: /* Used to count relocations for delayed sizing of relocation
789: sections. */
1.1.1.3 christos 790: struct elf_dyn_relocs *dyn_relocs;
1.1 christos 791:
792: enum
793: {
794: GOT_UNKNOWN = 0, GOT_NORMAL = 1, GOT_TLS_IE = 2, GOT_TLS_LDM = 4, GOT_TLS_GD = 8
795: } tls_type;
796: };
797:
798: struct elf_metag_link_hash_table
799: {
800: /* The main hash table. */
801: struct elf_link_hash_table etab;
802:
803: /* The stub hash table. */
804: struct bfd_hash_table bstab;
805:
806: /* Linker stub bfd. */
807: bfd *stub_bfd;
808:
809: /* Linker call-backs. */
810: asection * (*add_stub_section) (const char *, asection *);
811: void (*layout_sections_again) (void);
812:
813: /* Array to keep track of which stub sections have been created, and
814: information on stub grouping. */
815: struct map_stub
816: {
817: /* This is the section to which stubs in the group will be
818: attached. */
819: asection *link_sec;
820: /* The stub section. */
821: asection *stub_sec;
822: } *stub_group;
823:
824: /* Assorted information used by elf_metag_size_stubs. */
825: unsigned int bfd_count;
826: unsigned int top_index;
827: asection **input_list;
828: Elf_Internal_Sym **all_local_syms;
829:
830: /* Small local sym cache. */
831: struct sym_cache sym_cache;
832:
833: /* Data for LDM relocations. */
834: union
835: {
836: bfd_signed_vma refcount;
837: bfd_vma offset;
838: } tls_ldm_got;
839: };
840:
841: /* Return the base vma address which should be subtracted from the
842: real address when resolving a dtpoff relocation. This is PT_TLS
843: segment p_vaddr. */
844: static bfd_vma
845: dtpoff_base (struct bfd_link_info *info)
846: {
847: /* If tls_sec is NULL, we should have signalled an error already. */
848: if (elf_hash_table (info)->tls_sec == NULL)
849: return 0;
850: return elf_hash_table (info)->tls_sec->vma;
851: }
852:
853: /* Return the relocation value for R_METAG_TLS_IE */
854: static bfd_vma
855: tpoff (struct bfd_link_info *info, bfd_vma address)
856: {
857: /* If tls_sec is NULL, we should have signalled an error already. */
858: if (elf_hash_table (info)->tls_sec == NULL)
859: return 0;
860: /* METAG TLS ABI is variant I and static TLS blocks start just after
861: tcbhead structure which has 2 pointer fields. */
862: return (address - elf_hash_table (info)->tls_sec->vma
863: + align_power ((bfd_vma) 8,
864: elf_hash_table (info)->tls_sec->alignment_power));
865: }
866:
1.1.1.3 christos 867: static bfd_boolean
868: metag_info_to_howto_rela (bfd *abfd,
1.1 christos 869: arelent *cache_ptr,
870: Elf_Internal_Rela *dst)
871: {
872: unsigned int r_type;
873:
874: r_type = ELF32_R_TYPE (dst->r_info);
875: if (r_type >= (unsigned int) R_METAG_MAX)
876: {
1.1.1.3 christos 877: /* xgettext:c-format */
878: _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
879: abfd, r_type);
880: bfd_set_error (bfd_error_bad_value);
881: return FALSE;
1.1 christos 882: }
883: cache_ptr->howto = & elf_metag_howto_table [r_type];
1.1.1.3 christos 884: return TRUE;
1.1 christos 885: }
886:
887: static reloc_howto_type *
888: metag_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:
900: static reloc_howto_type *
901: metag_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:
936: static struct bfd_hash_entry *
937: stub_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:
973: static struct bfd_hash_entry *
974: metag_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:
1004: /* Free the derived linker hash table. */
1005:
1006: static void
1007: elf_metag_link_hash_table_free (bfd *obfd)
1008: {
1009: struct elf_metag_link_hash_table *htab
1010: = (struct elf_metag_link_hash_table *) obfd->link.hash;
1011:
1012: bfd_hash_table_free (&htab->bstab);
1013: _bfd_elf_link_hash_table_free (obfd);
1014: }
1015:
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:
1020: static struct bfd_link_hash_table *
1021: elf_metag_link_hash_table_create (bfd *abfd)
1022: {
1023: struct elf_metag_link_hash_table *htab;
1024: bfd_size_type amt = sizeof (*htab);
1025:
1026: htab = bfd_zmalloc (amt);
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)))
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;
1047:
1048: return &htab->etab.root;
1049: }
1050:
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:
1057: static char *
1058: metag_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:
1097: static struct elf_metag_stub_hash_entry *
1098: metag_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:
1143: static struct elf_metag_stub_hash_entry *
1144: metag_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: {
1.1.1.3 christos 1185: /* xgettext:c-format */
1186: _bfd_error_handler (_("%pB: cannot create stub entry %s"),
1187: section->owner, stub_name);
1.1 christos 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:
1200: static bfd_boolean
1201: within_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:
1210: static bfd_reloc_status_type
1211: metag_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, \
1.1.1.4 ! christos 1399: contents, rel->r_offset); \
1.1 christos 1400: \
1401: if (bfd_link_relocatable (info) \
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:
1433: The RELOCATE_SECTION function is called by the new ELF backend linker
1434: to handle the relocations for a section.
1435:
1436: The relocs are always passed as Rela structures; if the section
1437: actually uses Rel structures, the r_addend field will always be
1438: zero.
1439:
1440: This function is responsible for adjusting the section contents as
1441: necessary, and (if using Rela relocs and generating a relocatable
1442: output file) adjusting the reloc addend as necessary.
1443:
1444: This function does not have to worry about setting the reloc
1445: address or the reloc symbol index.
1446:
1447: LOCAL_SYMS is a pointer to the swapped in local symbols.
1448:
1449: LOCAL_SECTIONS is an array giving the section in the input file
1450: corresponding to the st_shndx field of each local symbol.
1451:
1452: The global hash table entry for the global symbols can be found
1453: via elf_sym_hashes (input_bfd).
1454:
1455: When generating relocatable output, this function must handle
1456: STB_LOCAL/STT_SECTION symbols specially. The output symbol is
1457: going to be the section symbol corresponding to the output
1458: section, which means that the addend must be adjusted
1459: accordingly. */
1460:
1461: static bfd_boolean
1462: elf_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);
1.1.1.4 ! christos 1522: name = name == NULL ? bfd_section_name (sec) : name;
1.1 christos 1523: }
1524: else
1525: {
1526: struct elf_link_hash_entry *eh;
1527: bfd_boolean unresolved_reloc, warned, ignored;
1528:
1529: RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1530: r_symndx, symtab_hdr, eh_syms,
1531: eh, sec, relocation,
1532: unresolved_reloc, warned, ignored);
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:
1542: if (bfd_link_relocatable (info))
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:
1552: if ((bfd_link_pic (info)
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)))
1557: || (!bfd_link_pic (info)
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:
1.1.1.3 christos 1646: if (hh->eh.plt.offset == (bfd_vma) -1 || htab->etab.splt == NULL)
1.1 christos 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:
1.1.1.3 christos 1654: relocation = (htab->etab.splt->output_section->vma
1655: + htab->etab.splt->output_offset
1.1 christos 1656: + hh->eh.plt.offset);
1657: break;
1658: case R_METAG_HI16_GOTPC:
1659: case R_METAG_LO16_GOTPC:
1.1.1.3 christos 1660: BFD_ASSERT (htab->etab.sgot != NULL);
1.1 christos 1661:
1.1.1.3 christos 1662: relocation = (htab->etab.sgot->output_section->vma +
1663: htab->etab.sgot->output_offset);
1.1 christos 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:
1.1.1.3 christos 1672: BFD_ASSERT (htab->etab.sgot != NULL);
1.1 christos 1673:
1.1.1.3 christos 1674: relocation -= (htab->etab.sgot->output_section->vma +
1675: htab->etab.sgot->output_offset);
1.1 christos 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;
1691: if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1692: bfd_link_pic (info),
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: {
1732: if (bfd_link_pic (info))
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;
1.1.1.3 christos 1739: asection *s = htab->etab.srelgot;
1.1 christos 1740:
1741: outrel.r_offset = (off
1.1.1.3 christos 1742: + htab->etab.sgot->output_offset
1743: + htab->etab.sgot->output_section->vma);
1.1 christos 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,
1.1.1.3 christos 1752: htab->etab.sgot->contents + off);
1.1 christos 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:
1.1.1.3 christos 1770: if (htab->etab.sgot == NULL)
1.1 christos 1771: abort();
1772:
1773: indx = 0;
1774: if (hh != NULL)
1775: {
1776: bfd_boolean dyn;
1777: dyn = htab->etab.dynamic_sections_created;
1778:
1779: if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1780: bfd_link_pic (info),
1781: &hh->eh)
1782: && (!bfd_link_pic (info)
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)
1.1.1.3 christos 1801: abort ();
1.1 christos 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:
1816: if ((bfd_link_pic (info) || indx != 0)
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;
1.1.1.3 christos 1822: loc = htab->etab.srelgot->contents;
1.1 christos 1823: /* FIXME (CAO): Should this be reloc_count++ ? */
1.1.1.3 christos 1824: loc += htab->etab.srelgot->reloc_count * sizeof (Elf32_External_Rela);
1.1 christos 1825: }
1826:
1827: if (tls_type & GOT_TLS_GD)
1828: {
1829: if (need_relocs)
1830: {
1831: outrel.r_offset = (cur_off
1.1.1.3 christos 1832: + htab->etab.sgot->output_section->vma
1833: + htab->etab.sgot->output_offset);
1.1 christos 1834: outrel.r_info = ELF32_R_INFO (indx, R_METAG_TLS_DTPMOD);
1835: outrel.r_addend = 0;
1.1.1.3 christos 1836: bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + cur_off);
1.1 christos 1837:
1838: bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1.1.1.3 christos 1839: htab->etab.srelgot->reloc_count++;
1.1 christos 1840: loc += sizeof (Elf32_External_Rela);
1841:
1842: if (indx == 0)
1843: bfd_put_32 (output_bfd, 0,
1.1.1.3 christos 1844: htab->etab.sgot->contents + cur_off + 4);
1.1 christos 1845: else
1846: {
1847: bfd_put_32 (output_bfd, 0,
1.1.1.3 christos 1848: htab->etab.sgot->contents + cur_off + 4);
1.1 christos 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);
1.1.1.3 christos 1854: htab->etab.srelgot->reloc_count++;
1.1 christos 1855: loc += sizeof (Elf32_External_Rela);
1856: }
1857: }
1858: else
1859: {
1860: /* We don't support changing the TLS model. */
1.1.1.3 christos 1861: /* PR 20675 */
1862: if (bfd_link_pic (info))
1863: _bfd_error_handler (_("%pB(%pA): multiple TLS models are not supported"),
1864: input_bfd, input_section);
1865: else
1866: _bfd_error_handler (_("%pB(%pA): shared library symbol %s encountered whilst performing a static link"),
1867: input_bfd, input_section, name);
1868: return FALSE;
1.1 christos 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
1.1.1.3 christos 1879: + htab->etab.sgot->output_section->vma
1880: + htab->etab.sgot->output_offset);
1.1 christos 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);
1.1.1.3 christos 1889: htab->etab.srelgot->reloc_count++;
1.1 christos 1890: loc += sizeof (Elf32_External_Rela);
1891: }
1892: else
1893: bfd_put_32 (output_bfd, tpoff (info, relocation),
1.1.1.3 christos 1894: htab->etab.sgot->contents + cur_off);
1.1 christos 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:
1915: if (bfd_link_pic (info))
1916: {
1.1.1.3 christos 1917: _bfd_error_handler
1918: /* xgettext:c-format */
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);
1.1 christos 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:
1930: if (! bfd_link_pic (info))
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:
1.1.1.3 christos 1939: if (htab->etab.sgot == NULL)
1.1 christos 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
1.1.1.3 christos 1950: + htab->etab.sgot->output_section->vma
1951: + htab->etab.sgot->output_offset);
1.1 christos 1952:
1953: outrel.r_addend = 0;
1954: outrel.r_info = ELF32_R_INFO (0, R_METAG_TLS_DTPMOD);
1.1.1.3 christos 1955: loc = htab->etab.srelgot->contents;
1956: loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1.1 christos 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:
1.1.1.2 christos 1979: (*info->callbacks->reloc_overflow)
1.1 christos 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:
1.1.1.2 christos 1985: (*info->callbacks->undefined_symbol)
1986: (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1.1 christos 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)
1.1.1.2 christos 2007: (*info->callbacks->warning) (info, msg, name, input_bfd,
2008: input_section, rel->r_offset);
1.1 christos 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:
2018: static bfd_boolean
2019: elf_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);
1.1.1.3 christos 2028: if (htab->etab.splt != NULL)
1.1 christos 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:
1.1.1.3 christos 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;
1.1 christos 2039:
1.1.1.3 christos 2040: /* Define the symbol __GLOBAL_OFFSET_TABLE__ on the header. */
1.1 christos 2041: bh = NULL;
2042: if (!(_bfd_generic_link_add_one_symbol
1.1.1.3 christos 2043: (info, abfd, "__GLOBAL_OFFSET_TABLE__", BSF_GLOBAL, htab->etab.sgot,
1.1 christos 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:
2051: if (! bfd_link_executable (info)
2052: && ! bfd_elf_link_record_dynamic_symbol (info, eh))
2053: return FALSE;
2054:
1.1.1.3 christos 2055: htab->etab.hgot = eh;
1.1 christos 2056:
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:
2065: static bfd_boolean
2066: elf_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:
2080: if (bfd_link_relocatable (info))
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;
2097: Elf_Internal_Sym *isym;
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)
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: }
2112: else
2113: {
2114: isym = NULL;
2115:
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. */
1.1.1.3 christos 2124: if (htab->etab.sgot == NULL)
1.1 christos 2125: {
2126: switch (r_type)
2127: {
2128: case R_METAG_TLS_GD:
2129: case R_METAG_TLS_LDM:
2130: case R_METAG_TLS_IE:
2131: if (bfd_link_pic (info))
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:
2239: case R_METAG_HIADDR16:
2240: case R_METAG_LOADDR16:
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. */
2245: if (bfd_link_pic (info)
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);
1.1.1.3 christos 2255: _bfd_error_handler
2256: /* xgettext:c-format */
2257: (_("%pB: relocation %s against `%s' can not be used when making a shared object; recompile with -fPIC"),
1.1 christos 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:
2265: case R_METAG_RELBRANCH:
2266: case R_METAG_GETSETOFF:
2267: if (hh != NULL && !bfd_link_pic (info))
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. */
2292: if ((bfd_link_pic (info)
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))))
2299: || (!bfd_link_pic (info)
2300: && (sec->flags & SEC_ALLOC) != 0
2301: && hh != NULL
2302: && (hh->eh.root.type == bfd_link_hash_defweak
2303: || !hh->eh.def_regular)))
2304: {
1.1.1.3 christos 2305: struct elf_dyn_relocs *hdh_p;
2306: struct elf_dyn_relocs **hdh_head;
1.1 christos 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;
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;
1.1.1.3 christos 2343: hdh_head = (struct elf_dyn_relocs **) vpp;
1.1 christos 2344: }
2345:
2346: hdh_p = *hdh_head;
2347: if (hdh_p == NULL || hdh_p->sec != sec)
2348: {
1.1.1.3 christos 2349: hdh_p = ((struct elf_dyn_relocs *)
1.1 christos 2350: bfd_alloc (dynobj, sizeof *hdh_p));
2351: if (hdh_p == NULL)
2352: return FALSE;
1.1.1.3 christos 2353: hdh_p->next = *hdh_head;
1.1 christos 2354: *hdh_head = hdh_p;
2355: hdh_p->sec = sec;
2356: hdh_p->count = 0;
1.1.1.3 christos 2357: hdh_p->pc_count = 0;
1.1 christos 2358: }
2359:
2360: hdh_p->count += 1;
2361: if (ELF32_R_TYPE (rel->r_info) == R_METAG_RELBRANCH)
1.1.1.3 christos 2362: hdh_p->pc_count += 1;
1.1 christos 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:
1.1.1.4 ! christos 2377: if (!bfd_elf_gc_record_vtentry (abfd, sec, &hh->eh, rel->r_addend))
1.1 christos 2378: return FALSE;
2379: break;
2380: }
2381: }
2382:
2383: return TRUE;
2384: }
2385:
2386: /* Copy the extra info we tack onto an elf_link_hash_entry. */
2387:
2388: static void
2389: elf_metag_copy_indirect_symbol (struct bfd_link_info *info,
2390: struct elf_link_hash_entry *eh_dir,
2391: struct elf_link_hash_entry *eh_ind)
2392: {
2393: struct elf_metag_link_hash_entry *hh_dir, *hh_ind;
2394:
2395: hh_dir = metag_elf_hash_entry (eh_dir);
2396: hh_ind = metag_elf_hash_entry (eh_ind);
2397:
2398: if (hh_ind->dyn_relocs != NULL)
2399: {
2400: if (hh_dir->dyn_relocs != NULL)
2401: {
1.1.1.3 christos 2402: struct elf_dyn_relocs **hdh_pp;
2403: struct elf_dyn_relocs *hdh_p;
1.1 christos 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: {
1.1.1.3 christos 2412: struct elf_dyn_relocs *hdh_q;
1.1 christos 2413:
2414: for (hdh_q = hh_dir->dyn_relocs; hdh_q != NULL;
1.1.1.3 christos 2415: hdh_q = hdh_q->next)
1.1 christos 2416: if (hdh_q->sec == hdh_p->sec)
2417: {
1.1.1.3 christos 2418: hdh_q->pc_count += hdh_p->pc_count;
1.1 christos 2419: hdh_q->count += hdh_p->count;
1.1.1.3 christos 2420: *hdh_pp = hdh_p->next;
1.1 christos 2421: break;
2422: }
2423: if (hdh_q == NULL)
1.1.1.3 christos 2424: hdh_pp = &hdh_p->next;
1.1 christos 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:
1.1.1.3 christos 2443: /* Find dynamic relocs for H that apply to read-only sections. */
2444:
2445: static asection *
2446: readonly_dynrelocs (struct elf_link_hash_entry *h)
2447: {
2448: struct elf_dyn_relocs *p;
2449:
2450: for (p = metag_elf_hash_entry (h)->dyn_relocs; p != NULL; p = p->next)
2451: {
2452: asection *s = p->sec->output_section;
2453:
2454: if (s != NULL && (s->flags & SEC_READONLY) != 0)
2455: return p->sec;
2456: }
2457: return NULL;
2458: }
2459:
1.1 christos 2460: /* Adjust a symbol defined by a dynamic object and referenced by a
2461: regular object. The current definition is in some section of the
2462: dynamic object, but we're not including those sections. We have to
2463: change the definition to something the rest of the link can
2464: understand. */
2465:
2466: static bfd_boolean
2467: elf_metag_adjust_dynamic_symbol (struct bfd_link_info *info,
2468: struct elf_link_hash_entry *eh)
2469: {
2470: struct elf_metag_link_hash_table *htab;
1.1.1.3 christos 2471: asection *s, *srel;
1.1 christos 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. */
1.1.1.3 christos 2501: if (eh->is_weakalias)
1.1 christos 2502: {
1.1.1.3 christos 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;
1.1 christos 2508: return TRUE;
2509: }
2510:
2511: /* This is a reference to a symbol defined by a dynamic object which
2512: is not a function. */
2513:
2514: /* If we are creating a shared library, we must presume that the
2515: only references to the symbol are via the global offset table.
2516: For such cases we need not do anything here; the relocations will
2517: be handled correctly by relocate_section. */
2518: if (bfd_link_pic (info))
2519: return TRUE;
2520:
2521: /* If there are no references to this symbol that do not use the
2522: GOT, we don't need to generate a copy reloc. */
2523: if (!eh->non_got_ref)
2524: return TRUE;
2525:
2526: /* If -z nocopyreloc was given, we won't generate them either. */
2527: if (info->nocopyreloc)
2528: {
2529: eh->non_got_ref = 0;
2530: return TRUE;
2531: }
2532:
1.1.1.3 christos 2533: /* If we don't find any dynamic relocs in read-only sections, then
1.1 christos 2534: we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1.1.1.3 christos 2535: if (!readonly_dynrelocs (eh))
1.1 christos 2536: {
2537: eh->non_got_ref = 0;
2538: return TRUE;
2539: }
2540:
2541: /* We must allocate the symbol in our .dynbss section, which will
2542: become part of the .bss section of the executable. There will be
2543: an entry for this symbol in the .dynsym section. The dynamic
2544: object will contain position independent code, so all references
2545: from the dynamic object to this symbol will go through the global
2546: offset table. The dynamic linker will use the .dynsym entry to
2547: determine the address it must put in the global offset table, so
2548: both the dynamic object and the regular object will refer to the
2549: same memory location for the variable. */
2550:
2551: htab = metag_link_hash_table (info);
2552:
2553: /* We must generate a COPY reloc to tell the dynamic linker to
2554: copy the initial value out of the dynamic object and into the
2555: runtime process image. */
1.1.1.3 christos 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: }
1.1 christos 2566: if ((eh->root.u.def.section->flags & SEC_ALLOC) != 0 && eh->size != 0)
2567: {
1.1.1.3 christos 2568: srel->size += sizeof (Elf32_External_Rela);
1.1 christos 2569: eh->needs_copy = 1;
2570: }
2571:
2572: return _bfd_elf_adjust_dynamic_copy (info, eh, s);
2573: }
2574:
2575: /* Allocate space in .plt, .got and associated reloc sections for
2576: global syms. */
2577:
2578: static bfd_boolean
2579: allocate_dynrelocs (struct elf_link_hash_entry *eh, void *inf)
2580: {
2581: struct bfd_link_info *info;
2582: struct elf_metag_link_hash_table *htab;
2583: struct elf_metag_link_hash_entry *hh;
1.1.1.3 christos 2584: struct elf_dyn_relocs *hdh_p;
1.1 christos 2585:
2586: if (eh->root.type == bfd_link_hash_indirect)
2587: return TRUE;
2588:
2589: if (eh->root.type == bfd_link_hash_warning)
2590: eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
2591:
2592: info = inf;
2593: htab = metag_link_hash_table (info);
2594:
2595: if (htab->etab.dynamic_sections_created
2596: && eh->plt.refcount > 0)
2597: {
2598: /* Make sure this symbol is output as a dynamic symbol.
2599: Undefined weak syms won't yet be marked as dynamic. */
2600: if (eh->dynindx == -1
2601: && !eh->forced_local)
2602: {
2603: if (! bfd_elf_link_record_dynamic_symbol (info, eh))
2604: return FALSE;
2605: }
2606:
2607: if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), eh))
2608: {
1.1.1.3 christos 2609: asection *s = htab->etab.splt;
1.1 christos 2610:
2611: /* If this is the first .plt entry, make room for the special
2612: first entry. */
2613: if (s->size == 0)
2614: s->size += PLT_ENTRY_SIZE;
2615:
2616: eh->plt.offset = s->size;
2617:
2618: /* If this symbol is not defined in a regular file, and we are
2619: not generating a shared library, then set the symbol to this
2620: location in the .plt. This is required to make function
2621: pointers compare as equal between the normal executable and
2622: the shared library. */
2623: if (! bfd_link_pic (info)
2624: && !eh->def_regular)
2625: {
2626: eh->root.u.def.section = s;
2627: eh->root.u.def.value = eh->plt.offset;
2628: }
2629:
2630: /* Make room for this entry. */
2631: s->size += PLT_ENTRY_SIZE;
2632:
2633: /* We also need to make an entry in the .got.plt section, which
2634: will be placed in the .got section by the linker script. */
1.1.1.3 christos 2635: htab->etab.sgotplt->size += 4;
1.1 christos 2636:
2637: /* We also need to make an entry in the .rel.plt section. */
1.1.1.3 christos 2638: htab->etab.srelplt->size += sizeof (Elf32_External_Rela);
1.1 christos 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:
1.1.1.3 christos 2667: s = htab->etab.sgot;
1.1 christos 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))
1.1.1.3 christos 2679: htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
1.1 christos 2680: else if (tls_type == GOT_TLS_GD)
1.1.1.3 christos 2681: htab->etab.srelgot->size += 2 * sizeof (Elf32_External_Rela);
1.1 christos 2682: else if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2683: bfd_link_pic (info),
2684: eh))
1.1.1.3 christos 2685: htab->etab.srelgot->size += sizeof (Elf32_External_Rela);
1.1 christos 2686: }
2687: else
2688: eh->got.offset = (bfd_vma) -1;
2689:
2690: hh = (struct elf_metag_link_hash_entry *) eh;
2691: if (hh->dyn_relocs == NULL)
2692: return TRUE;
2693:
2694: /* If this is a -Bsymbolic shared link, then we need to discard all
2695: space allocated for dynamic pc-relative relocs against symbols
2696: defined in a regular object. For the normal shared case, discard
2697: space for relocs that have become local due to symbol visibility
2698: changes. */
2699: if (bfd_link_pic (info))
2700: {
2701: if (SYMBOL_CALLS_LOCAL (info, eh))
2702: {
1.1.1.3 christos 2703: struct elf_dyn_relocs **hdh_pp;
1.1 christos 2704:
2705: for (hdh_pp = &hh->dyn_relocs; (hdh_p = *hdh_pp) != NULL; )
2706: {
1.1.1.3 christos 2707: hdh_p->count -= hdh_p->pc_count;
2708: hdh_p->pc_count = 0;
1.1 christos 2709: if (hdh_p->count == 0)
1.1.1.3 christos 2710: *hdh_pp = hdh_p->next;
1.1 christos 2711: else
1.1.1.3 christos 2712: hdh_pp = &hdh_p->next;
1.1 christos 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. */
1.1.1.3 christos 2768: for (hdh_p = hh->dyn_relocs; hdh_p != NULL; hdh_p = hdh_p->next)
1.1 christos 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:
1.1.1.3 christos 2777: /* Set DF_TEXTREL if we find any dynamic relocs that apply to
2778: read-only sections. */
1.1 christos 2779:
2780: static bfd_boolean
1.1.1.3 christos 2781: maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1.1 christos 2782: {
1.1.1.3 christos 2783: asection *sec;
1.1 christos 2784:
1.1.1.3 christos 2785: if (h->root.type == bfd_link_hash_indirect)
2786: return TRUE;
1.1 christos 2787:
1.1.1.3 christos 2788: sec = readonly_dynrelocs (h);
2789: if (sec != NULL)
1.1 christos 2790: {
1.1.1.3 christos 2791: struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1.1 christos 2792:
1.1.1.3 christos 2793: info->flags |= DF_TEXTREL;
2794: info->callbacks->minfo
2795: (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
2796: sec->owner, h->root.root.string, sec);
1.1 christos 2797:
1.1.1.3 christos 2798: /* Not an error, just cut short the traversal. */
2799: return FALSE;
1.1 christos 2800: }
2801: return TRUE;
2802: }
2803:
2804: /* Set the sizes of the dynamic sections. */
2805:
2806: static bfd_boolean
2807: elf_metag_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2808: struct bfd_link_info *info)
2809: {
2810: struct elf_metag_link_hash_table *htab;
2811: bfd *dynobj;
2812: bfd *ibfd;
2813: asection *s;
2814: bfd_boolean relocs;
2815:
2816: htab = metag_link_hash_table (info);
2817: dynobj = htab->etab.dynobj;
2818: if (dynobj == NULL)
2819: abort ();
2820:
2821: if (htab->etab.dynamic_sections_created)
2822: {
2823: /* Set the contents of the .interp section to the interpreter. */
2824: if (bfd_link_executable (info) && !info->nointerp)
2825: {
2826: s = bfd_get_linker_section (dynobj, ".interp");
2827: if (s == NULL)
2828: abort ();
2829: s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2830: s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2831: }
2832: }
2833:
2834: /* Set up .got offsets for local syms, and space for local dynamic
2835: relocs. */
2836: for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2837: {
2838: bfd_signed_vma *local_got;
2839: bfd_signed_vma *end_local_got;
2840: bfd_size_type locsymcount;
2841: Elf_Internal_Shdr *symtab_hdr;
2842: asection *srel;
2843: char *local_tls_type;
2844:
2845: if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2846: continue;
2847:
2848: for (s = ibfd->sections; s != NULL; s = s->next)
2849: {
1.1.1.3 christos 2850: struct elf_dyn_relocs *hdh_p;
1.1 christos 2851:
1.1.1.3 christos 2852: for (hdh_p = ((struct elf_dyn_relocs *)
1.1 christos 2853: elf_section_data (s)->local_dynrel);
2854: hdh_p != NULL;
1.1.1.3 christos 2855: hdh_p = hdh_p->next)
1.1 christos 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);
1.1.1.3 christos 2883: s = htab->etab.sgot;
2884: srel = htab->etab.srelgot;
1.1 christos 2885: for (; local_got < end_local_got; ++local_got)
2886: {
2887: if (*local_got > 0)
2888: {
2889: *local_got = s->size;
2890: s->size += GOT_ENTRY_SIZE;
2891: /* R_METAG_TLS_GD relocs need 2 consecutive GOT entries. */
2892: if (*local_tls_type == GOT_TLS_GD)
2893: s->size += 4;
2894: if (bfd_link_pic (info))
2895: srel->size += sizeof (Elf32_External_Rela);
2896: }
2897: else
2898: *local_got = (bfd_vma) -1;
2899: ++local_tls_type;
2900: }
2901: }
2902:
2903: if (htab->tls_ldm_got.refcount > 0)
2904: {
2905: /* Allocate 2 got entries and 1 dynamic reloc for R_METAG_TLS_LDM
2906: reloc. */
1.1.1.3 christos 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);
1.1 christos 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:
1.1.1.3 christos 2928: if (s == htab->etab.splt
2929: || s == htab->etab.sgot
2930: || s == htab->etab.sgotplt
2931: || s == htab->etab.sdynbss
2932: || s == htab->etab.sdynrelro)
1.1 christos 2933: {
2934: /* Strip this section if we don't need it; see the
2935: comment below. */
2936: }
1.1.1.4 ! christos 2937: else if (CONST_STRNEQ (bfd_section_name (s), ".rela"))
1.1 christos 2938: {
1.1.1.3 christos 2939: if (s->size != 0 && s != htab->etab.srelplt)
1.1 christos 2940: relocs = TRUE;
2941:
2942: /* We use the reloc_count field as a counter if we need
2943: to copy relocs into the output file. */
2944: s->reloc_count = 0;
2945: reloc_section = TRUE;
2946: }
2947: else
2948: {
2949: /* It's not one of our sections, so don't allocate space. */
2950: continue;
2951: }
2952:
2953: if (s->size == 0)
2954: {
2955: /* If we don't need this section, strip it from the
2956: output file. This is mostly to handle .rela.bss and
2957: .rela.plt. We must create both sections in
2958: create_dynamic_sections, because they must be created
2959: before the linker maps input sections to output
2960: sections. The linker does that before
2961: adjust_dynamic_symbol is called, and it is that
2962: function which decides whether anything needs to go
2963: into these sections. */
2964: s->flags |= SEC_EXCLUDE;
2965: continue;
2966: }
2967:
2968: if ((s->flags & SEC_HAS_CONTENTS) == 0)
2969: continue;
2970:
2971: /* Allocate memory for the section contents. */
2972: s->contents = bfd_zalloc (dynobj, s->size);
2973: if (s->contents == NULL)
2974: return FALSE;
2975: else if (reloc_section)
2976: {
2977: unsigned char *contents = s->contents;
2978: Elf32_External_Rela reloc;
2979:
2980: /* Fill the reloc section with a R_METAG_NONE type reloc. */
2981: memset(&reloc, 0, sizeof(Elf32_External_Rela));
2982: reloc.r_info[0] = R_METAG_NONE;
2983: for (; contents < (s->contents + s->size);
2984: contents += sizeof(Elf32_External_Rela))
2985: {
2986: memcpy(contents, &reloc, sizeof(Elf32_External_Rela));
2987: }
2988: }
2989: }
2990:
2991: if (htab->etab.dynamic_sections_created)
2992: {
2993: /* Add some entries to the .dynamic section. We fill in the
2994: values later, in elf_metag_finish_dynamic_sections, but we
2995: must add the entries now so that we get the correct size for
2996: the .dynamic section. The DT_DEBUG entry is filled in by the
2997: dynamic linker and used by the debugger. */
2998: #define add_dynamic_entry(TAG, VAL) \
2999: _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3000:
3001: if (!add_dynamic_entry (DT_PLTGOT, 0))
3002: return FALSE;
3003:
3004: if (bfd_link_executable (info))
3005: {
3006: if (!add_dynamic_entry (DT_DEBUG, 0))
3007: return FALSE;
3008: }
3009:
1.1.1.3 christos 3010: if (htab->etab.srelplt->size != 0)
1.1 christos 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)
1.1.1.3 christos 3028: elf_link_hash_traverse (&htab->etab, maybe_set_textrel, info);
1.1 christos 3029:
3030: if ((info->flags & DF_TEXTREL) != 0)
3031: {
3032: if (!add_dynamic_entry (DT_TEXTREL, 0))
3033: return FALSE;
3034: }
3035: }
3036: }
3037: #undef add_dynamic_entry
3038:
3039: return TRUE;
3040: }
3041:
3042: /* Finish up dynamic symbol handling. We set the contents of various
3043: dynamic sections here. */
3044:
3045: static bfd_boolean
3046: elf_metag_finish_dynamic_symbol (bfd *output_bfd,
3047: struct bfd_link_info *info,
3048: struct elf_link_hash_entry *eh,
3049: Elf_Internal_Sym *sym)
3050: {
3051: struct elf_metag_link_hash_table *htab;
3052: Elf_Internal_Rela rel;
3053: bfd_byte *loc;
3054:
3055: htab = metag_link_hash_table (info);
3056:
3057: if (eh->plt.offset != (bfd_vma) -1)
3058: {
3059: asection *splt;
3060: asection *sgot;
3061: asection *srela;
3062:
3063: bfd_vma plt_index;
3064: bfd_vma got_offset;
3065: bfd_vma got_entry;
3066:
3067: if (eh->plt.offset & 1)
3068: abort ();
3069:
3070: BFD_ASSERT (eh->dynindx != -1);
3071:
1.1.1.3 christos 3072: splt = htab->etab.splt;
3073: sgot = htab->etab.sgotplt;
3074: srela = htab->etab.srelplt;
1.1 christos 3075: BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3076:
3077: /* Get the index in the procedure linkage table which
3078: corresponds to this symbol. This is the index of this symbol
3079: in all the symbols for which we are making plt entries. The
3080: first entry in the procedure linkage table is reserved. */
3081: plt_index = eh->plt.offset / PLT_ENTRY_SIZE - 1;
3082:
3083: /* Get the offset into the .got.plt table of the entry that
3084: corresponds to this function. */
3085: got_offset = plt_index * GOT_ENTRY_SIZE;
3086:
3087: BFD_ASSERT (got_offset < (1 << 16));
3088:
3089: got_entry = sgot->output_section->vma
3090: + sgot->output_offset
3091: + got_offset;
3092:
3093: BFD_ASSERT (plt_index < (1 << 16));
3094:
3095: /* Fill in the entry in the procedure linkage table. */
3096: if (! bfd_link_pic (info))
3097: {
3098: bfd_put_32 (output_bfd,
3099: (plt_entry[0]
3100: | (((got_entry >> 16) & 0xffff) << 3)),
3101: splt->contents + eh->plt.offset);
3102: bfd_put_32 (output_bfd,
3103: (plt_entry[1]
3104: | ((got_entry & 0xffff) << 3)),
3105: splt->contents + eh->plt.offset + 4);
3106: bfd_put_32 (output_bfd, plt_entry[2],
3107: splt->contents + eh->plt.offset + 8);
3108: bfd_put_32 (output_bfd,
3109: (plt_entry[3] | (plt_index << 3)),
3110: splt->contents + eh->plt.offset + 12);
3111: bfd_put_32 (output_bfd,
3112: (plt_entry[4]
3113: | ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
3114: splt->contents + eh->plt.offset + 16);
3115: }
3116: else
3117: {
3118: bfd_vma addr = got_entry - (splt->output_section->vma +
3119: splt->output_offset + eh->plt.offset);
3120:
3121: bfd_put_32 (output_bfd,
3122: plt_pic_entry[0] | (((addr >> 16) & 0xffff) << 3),
3123: splt->contents + eh->plt.offset);
3124: bfd_put_32 (output_bfd,
3125: plt_pic_entry[1] | ((addr & 0xffff) << 3),
3126: splt->contents + eh->plt.offset + 4);
3127: bfd_put_32 (output_bfd, plt_pic_entry[2],
3128: splt->contents + eh->plt.offset + 8);
3129: bfd_put_32 (output_bfd,
3130: (plt_pic_entry[3] | (plt_index << 3)),
3131: splt->contents + eh->plt.offset + 12);
3132: bfd_put_32 (output_bfd,
3133: (plt_pic_entry[4]
3134: + ((((unsigned int) ((- (eh->plt.offset + 16)) >> 2)) & 0x7ffff) << 5)),
3135: splt->contents + eh->plt.offset + 16);
3136: }
3137:
3138: /* Fill in the entry in the global offset table. */
3139: bfd_put_32 (output_bfd,
3140: (splt->output_section->vma
3141: + splt->output_offset
3142: + eh->plt.offset
3143: + 12), /* offset within PLT entry */
3144: sgot->contents + got_offset);
3145:
3146: /* Fill in the entry in the .rela.plt section. */
3147: rel.r_offset = (sgot->output_section->vma
3148: + sgot->output_offset
3149: + got_offset);
3150: rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_JMP_SLOT);
3151: rel.r_addend = 0;
1.1.1.3 christos 3152: loc = htab->etab.srelplt->contents;
1.1 christos 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)
1.1.1.3 christos 3172: + htab->etab.sgot->output_offset
3173: + htab->etab.sgot->output_section->vma);
1.1 christos 3174:
3175: /* If this is a -Bsymbolic link and the symbol is defined
3176: locally or was forced to be local because of a version file,
3177: we just want to emit a RELATIVE reloc. The entry in the
3178: global offset table will already have been initialized in the
3179: relocate_section function. */
3180: if (bfd_link_pic (info)
3181: && (info->symbolic || eh->dynindx == -1)
3182: && eh->def_regular)
3183: {
3184: rel.r_info = ELF32_R_INFO (0, R_METAG_RELATIVE);
3185: rel.r_addend = (eh->root.u.def.value
3186: + eh->root.u.def.section->output_offset
3187: + eh->root.u.def.section->output_section->vma);
3188: }
3189: else
3190: {
3191: if ((eh->got.offset & 1) != 0)
3192: abort ();
1.1.1.3 christos 3193: bfd_put_32 (output_bfd, 0, htab->etab.sgot->contents + eh->got.offset);
1.1 christos 3194: rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_GLOB_DAT);
3195: rel.r_addend = 0;
3196: }
3197:
1.1.1.3 christos 3198: loc = htab->etab.srelgot->contents;
3199: loc += htab->etab.srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1.1 christos 3200: bfd_elf32_swap_reloca_out (output_bfd, &rel, loc);
3201: }
3202:
3203: if (eh->needs_copy)
3204: {
3205: asection *s;
3206:
3207: /* This symbol needs a copy reloc. Set it up. */
3208:
3209: if (! (eh->dynindx != -1
3210: && (eh->root.type == bfd_link_hash_defined
3211: || eh->root.type == bfd_link_hash_defweak)))
3212: abort ();
3213:
3214: rel.r_offset = (eh->root.u.def.value
3215: + eh->root.u.def.section->output_offset
3216: + eh->root.u.def.section->output_section->vma);
3217: rel.r_addend = 0;
3218: rel.r_info = ELF32_R_INFO (eh->dynindx, R_METAG_COPY);
1.1.1.3 christos 3219: if (eh->root.u.def.section == htab->etab.sdynrelro)
3220: s = htab->etab.sreldynrelro;
3221: else
3222: s = htab->etab.srelbss;
1.1 christos 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:
1.1.1.4 ! christos 3240: static bfd_boolean
! 3241: elf_metag_init_file_header (bfd *abfd, struct bfd_link_info *link_info)
1.1 christos 3242: {
3243: Elf_Internal_Ehdr * i_ehdrp; /* ELF file header, internal form. */
3244:
1.1.1.4 ! christos 3245: if (!_bfd_elf_init_file_header (abfd, link_info))
! 3246: return FALSE;
! 3247:
1.1 christos 3248: i_ehdrp = elf_elfheader (abfd);
3249: i_ehdrp->e_ident[EI_ABIVERSION] = METAG_ELF_ABI_VERSION;
1.1.1.4 ! christos 3250: return TRUE;
1.1 christos 3251: }
3252:
3253: /* Used to decide how to sort relocs in an optimal manner for the
3254: dynamic linker, before writing them out. */
3255:
3256: static enum elf_reloc_type_class
3257: elf_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)
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:
3276: static bfd_boolean
3277: elf_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:
3287: sdyn = bfd_get_linker_section (dynobj, ".dynamic");
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:
1.1.1.3 christos 3312: s = htab->etab.sgot;
1.1.1.2 christos 3313: dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1.1 christos 3314: bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3315: break;
3316:
3317: case DT_JMPREL:
1.1.1.3 christos 3318: s = htab->etab.srelplt;
1.1.1.2 christos 3319: dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1.1 christos 3320: bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3321: break;
3322:
3323: case DT_PLTRELSZ:
1.1.1.3 christos 3324: s = htab->etab.srelplt;
1.1 christos 3325: dyn.d_un.d_val = s->size;
3326: bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3327: break;
3328: }
3329:
3330: }
3331:
3332: /* Fill in the first entry in the procedure linkage table. */
1.1.1.3 christos 3333: splt = htab->etab.splt;
1.1 christos 3334: if (splt && splt->size > 0)
3335: {
3336: unsigned long addr;
3337: /* addr = .got + 4 */
1.1.1.3 christos 3338: addr = (htab->etab.sgot->output_section->vma
3339: + htab->etab.sgot->output_offset + 4);
1.1 christos 3340: if (bfd_link_pic (info))
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:
1.1.1.3 christos 3371: if (htab->etab.sgot != NULL && htab->etab.sgot->size != 0)
1.1 christos 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,
1.1.1.3 christos 3377: htab->etab.sgot->contents);
1.1 christos 3378:
3379: /* The second entry is reserved for use by the dynamic linker. */
1.1.1.3 christos 3380: memset (htab->etab.sgot->contents + GOT_ENTRY_SIZE, 0, GOT_ENTRY_SIZE);
1.1 christos 3381:
3382: /* Set .got entry size. */
1.1.1.3 christos 3383: elf_section_data (htab->etab.sgot->output_section)
1.1 christos 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:
3393: static asection *
3394: elf_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:
3411: /* Determine the type of stub needed, if any, for a call. */
3412:
3413: static enum elf_metag_stub_type
3414: metag_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: {
3442: if (bfd_link_pic (info))
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:
3461: static bfd_boolean
3462: metag_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:
3535: static bfd_boolean
3536: metag_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:
3557: int
3558: elf_metag_setup_section_lists (bfd *output_bfd, struct bfd_link_info *info)
3559: {
3560: bfd *input_bfd;
3561: unsigned int bfd_count;
3562: unsigned int top_id, top_index;
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;
3571: input_bfd = input_bfd->link.next)
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:
3635: void
3636: elf_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:
3662: static void
3663: group_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:
3732: static int
3733: get_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;
3753: input_bfd = input_bfd->link.next, bfd_indx++)
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:
3783: The basic idea here is to examine all the relocations looking for
3784: PC-relative calls to a target that is unreachable with a "CALLR"
3785: instruction. */
3786:
3787: /* See elf32-hppa.c and elf64-ppc.c. */
3788:
3789: bfd_boolean
3790: elf_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;
3850: input_bfd = input_bfd->link.next, bfd_indx++)
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: {
1.1.1.3 christos 3970: sym_sec = htab->etab.splt;
1.1 christos 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: {
3983: if (! bfd_link_pic (info))
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:
4073: bfd_boolean
4074: elf_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:
4105: static bfd_boolean
4106: elf_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:
4116: static bfd_vma
4117: elf_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:
4130: #define TARGET_LITTLE_SYM metag_elf32_vec
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
4141: #define elf_backend_relocate_section elf_metag_relocate_section
4142: #define elf_backend_gc_mark_hook elf_metag_gc_mark_hook
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 \
1.1.1.3 christos 4150: _bfd_elf_omit_section_dynsym_all
1.1.1.4 ! christos 4151: #define elf_backend_init_file_header elf_metag_init_file_header
1.1 christos 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
1.1.1.3 christos 4158: #define elf_backend_rela_normal 1
4159: #define elf_backend_want_got_plt 1
1.1 christos 4160: #define elf_backend_want_got_sym 0
4161: #define elf_backend_want_plt_sym 0
4162: #define elf_backend_plt_readonly 1
1.1.1.3 christos 4163: #define elf_backend_dtrel_excludes_plt 1
4164: #define elf_backend_want_dynrelro 1
1.1 christos 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"
CVSweb <webmaster@jp.NetBSD.org>