projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
unrecognized/unsupported reloc message
[deliverable/binutils-gdb.git] / bfd / elf32-lm32.c
1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright (C) 2008-2018 Free Software Foundation, Inc.
3 Contributed by Jon Beniston <jon@beniston.com>
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/lm32.h"
27
28 #define DEFAULT_STACK_SIZE 0x20000
29
30 #define PLT_ENTRY_SIZE 20
31
32 #define PLT0_ENTRY_WORD0 0
33 #define PLT0_ENTRY_WORD1 0
34 #define PLT0_ENTRY_WORD2 0
35 #define PLT0_ENTRY_WORD3 0
36 #define PLT0_ENTRY_WORD4 0
37
38 #define PLT0_PIC_ENTRY_WORD0 0
39 #define PLT0_PIC_ENTRY_WORD1 0
40 #define PLT0_PIC_ENTRY_WORD2 0
41 #define PLT0_PIC_ENTRY_WORD3 0
42 #define PLT0_PIC_ENTRY_WORD4 0
43
44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
45
46 extern const bfd_target lm32_elf32_fdpic_vec;
47
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec)
49
50 static bfd_reloc_status_type lm32_elf_gprel_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52
53 /* lm32 ELF linker hash entry. */
54
55 struct elf_lm32_link_hash_entry
56 {
57 struct elf_link_hash_entry root;
58
59 /* Track dynamic relocs copied for this symbol. */
60 struct elf_dyn_relocs *dyn_relocs;
61 };
62
63 /* lm32 ELF linker hash table. */
64
65 struct elf_lm32_link_hash_table
66 {
67 struct elf_link_hash_table root;
68
69 /* Short-cuts to get to dynamic linker sections. */
70 asection *sfixup32;
71 asection *sdynbss;
72 asection *srelbss;
73
74 int relocs32;
75 };
76
77 /* Get the lm32 ELF linker hash table from a link_info structure. */
78
79 #define lm32_elf_hash_table(p) \
80 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
81 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
82
83 #define lm32fdpic_got_section(info) \
84 (lm32_elf_hash_table (info)->root.sgot)
85 #define lm32fdpic_gotrel_section(info) \
86 (lm32_elf_hash_table (info)->root.srelgot)
87 #define lm32fdpic_fixup32_section(info) \
88 (lm32_elf_hash_table (info)->sfixup32)
89
90 struct weak_symbol_list
91 {
92 const char *name;
93 struct weak_symbol_list *next;
94 };
95
96 /* Create an entry in an lm32 ELF linker hash table. */
97
98 static struct bfd_hash_entry *
99 lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
100 struct bfd_hash_table *table,
101 const char *string)
102 {
103 struct elf_lm32_link_hash_entry *ret =
104 (struct elf_lm32_link_hash_entry *) entry;
105
106 /* Allocate the structure if it has not already been allocated by a
107 subclass. */
108 if (ret == NULL)
109 ret = bfd_hash_allocate (table,
110 sizeof (struct elf_lm32_link_hash_entry));
111 if (ret == NULL)
112 return NULL;
113
114 /* Call the allocation method of the superclass. */
115 ret = ((struct elf_lm32_link_hash_entry *)
116 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
117 table, string));
118 if (ret != NULL)
119 {
120 struct elf_lm32_link_hash_entry *eh;
121
122 eh = (struct elf_lm32_link_hash_entry *) ret;
123 eh->dyn_relocs = NULL;
124 }
125
126 return (struct bfd_hash_entry *) ret;
127 }
128
129 /* Create an lm32 ELF linker hash table. */
130
131 static struct bfd_link_hash_table *
132 lm32_elf_link_hash_table_create (bfd *abfd)
133 {
134 struct elf_lm32_link_hash_table *ret;
135 bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
136
137 ret = bfd_zmalloc (amt);
138 if (ret == NULL)
139 return NULL;
140
141 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
142 lm32_elf_link_hash_newfunc,
143 sizeof (struct elf_lm32_link_hash_entry),
144 LM32_ELF_DATA))
145 {
146 free (ret);
147 return NULL;
148 }
149
150 return &ret->root.root;
151 }
152
153 /* Add a fixup to the ROFIXUP section. */
154
155 static bfd_vma
156 _lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
157 {
158 bfd_vma fixup_offset;
159
160 if (rofixup->flags & SEC_EXCLUDE)
161 return -1;
162
163 fixup_offset = rofixup->reloc_count * 4;
164 if (rofixup->contents)
165 {
166 BFD_ASSERT (fixup_offset < rofixup->size);
167 if (fixup_offset < rofixup->size)
168 bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
169 }
170 rofixup->reloc_count++;
171
172 return fixup_offset;
173 }
174
175 /* Create .rofixup sections in DYNOBJ, and set up
176 shortcuts to them in our hash table. */
177
178 static bfd_boolean
179 create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
180 {
181 struct elf_lm32_link_hash_table *htab;
182 htab = lm32_elf_hash_table (info);
183
184 if (htab == NULL)
185 return FALSE;
186
187 /* Fixup section for R_LM32_32 relocs. */
188 lm32fdpic_fixup32_section (info)
189 = bfd_make_section_anyway_with_flags (dynobj,
190 ".rofixup",
191 (SEC_ALLOC
192 | SEC_LOAD
193 | SEC_HAS_CONTENTS
194 | SEC_IN_MEMORY
195 | SEC_LINKER_CREATED
196 | SEC_READONLY));
197 if (lm32fdpic_fixup32_section (info) == NULL
198 || ! bfd_set_section_alignment (dynobj,
199 lm32fdpic_fixup32_section (info), 2))
200 return FALSE;
201
202 return TRUE;
203 }
204
205 static reloc_howto_type lm32_elf_howto_table [] =
206 {
207 /* This reloc does nothing. */
208 HOWTO (R_LM32_NONE, /* type */
209 0, /* rightshift */
210 3, /* size (0 = byte, 1 = short, 2 = long) */
211 0, /* bitsize */
212 FALSE, /* pc_relative */
213 0, /* bitpos */
214 complain_overflow_dont, /* complain_on_overflow */
215 bfd_elf_generic_reloc, /* special_function */
216 "R_LM32_NONE", /* name */
217 FALSE, /* partial_inplace */
218 0, /* src_mask */
219 0, /* dst_mask */
220 FALSE), /* pcrel_offset */
221
222 /* An 8 bit absolute relocation. */
223 HOWTO (R_LM32_8, /* type */
224 0, /* rightshift */
225 0, /* size (0 = byte, 1 = short, 2 = long) */
226 8, /* bitsize */
227 FALSE, /* pc_relative */
228 0, /* bitpos */
229 complain_overflow_bitfield,/* complain_on_overflow */
230 bfd_elf_generic_reloc, /* special_function */
231 "R_LM32_8", /* name */
232 FALSE, /* partial_inplace */
233 0, /* src_mask */
234 0xff, /* dst_mask */
235 FALSE), /* pcrel_offset */
236
237 /* A 16 bit absolute relocation. */
238 HOWTO (R_LM32_16, /* type */
239 0, /* rightshift */
240 1, /* size (0 = byte, 1 = short, 2 = long) */
241 16, /* bitsize */
242 FALSE, /* pc_relative */
243 0, /* bitpos */
244 complain_overflow_bitfield,/* complain_on_overflow */
245 bfd_elf_generic_reloc, /* special_function */
246 "R_LM32_16", /* name */
247 FALSE, /* partial_inplace */
248 0, /* src_mask */
249 0xffff, /* dst_mask */
250 FALSE), /* pcrel_offset */
251
252 /* A 32 bit absolute relocation. */
253 HOWTO (R_LM32_32, /* type */
254 0, /* rightshift */
255 2, /* size (0 = byte, 1 = short, 2 = long) */
256 32, /* bitsize */
257 FALSE, /* pc_relative */
258 0, /* bitpos */
259 complain_overflow_bitfield,/* complain_on_overflow */
260 bfd_elf_generic_reloc, /* special_function */
261 "R_LM32_32", /* name */
262 FALSE, /* partial_inplace */
263 0, /* src_mask */
264 0xffffffff, /* dst_mask */
265 FALSE), /* pcrel_offset */
266
267 HOWTO (R_LM32_HI16, /* type */
268 16, /* rightshift */
269 2, /* size (0 = byte, 1 = short, 2 = long) */
270 16, /* bitsize */
271 FALSE, /* pc_relative */
272 0, /* bitpos */
273 complain_overflow_bitfield,/* complain_on_overflow */
274 bfd_elf_generic_reloc, /* special_function */
275 "R_LM32_HI16", /* name */
276 FALSE, /* partial_inplace */
277 0, /* src_mask */
278 0xffff, /* dst_mask */
279 FALSE), /* pcrel_offset */
280
281 HOWTO (R_LM32_LO16, /* type */
282 0, /* rightshift */
283 2, /* size (0 = byte, 1 = short, 2 = long) */
284 16, /* bitsize */
285 FALSE, /* pc_relative */
286 0, /* bitpos */
287 complain_overflow_dont, /* complain_on_overflow */
288 bfd_elf_generic_reloc, /* special_function */
289 "R_LM32_LO16", /* name */
290 FALSE, /* partial_inplace */
291 0, /* src_mask */
292 0xffff, /* dst_mask */
293 FALSE), /* pcrel_offset */
294
295 HOWTO (R_LM32_GPREL16, /* type */
296 0, /* rightshift */
297 2, /* size (0 = byte, 1 = short, 2 = long) */
298 16, /* bitsize */
299 FALSE, /* pc_relative */
300 0, /* bitpos */
301 complain_overflow_dont, /* complain_on_overflow */
302 lm32_elf_gprel_reloc, /* special_function */
303 "R_LM32_GPREL16", /* name */
304 FALSE, /* partial_inplace */
305 0, /* src_mask */
306 0xffff, /* dst_mask */
307 FALSE), /* pcrel_offset */
308
309 HOWTO (R_LM32_CALL, /* type */
310 2, /* rightshift */
311 2, /* size (0 = byte, 1 = short, 2 = long) */
312 26, /* bitsize */
313 TRUE, /* pc_relative */
314 0, /* bitpos */
315 complain_overflow_signed, /* complain_on_overflow */
316 bfd_elf_generic_reloc, /* special_function */
317 "R_LM32_CALL", /* name */
318 FALSE, /* partial_inplace */
319 0, /* src_mask */
320 0x3ffffff, /* dst_mask */
321 TRUE), /* pcrel_offset */
322
323 HOWTO (R_LM32_BRANCH, /* type */
324 2, /* rightshift */
325 2, /* size (0 = byte, 1 = short, 2 = long) */
326 16, /* bitsize */
327 TRUE, /* pc_relative */
328 0, /* bitpos */
329 complain_overflow_signed, /* complain_on_overflow */
330 bfd_elf_generic_reloc, /* special_function */
331 "R_LM32_BRANCH", /* name */
332 FALSE, /* partial_inplace */
333 0, /* src_mask */
334 0xffff, /* dst_mask */
335 TRUE), /* pcrel_offset */
336
337 /* GNU extension to record C++ vtable hierarchy. */
338 HOWTO (R_LM32_GNU_VTINHERIT, /* type */
339 0, /* rightshift */
340 2, /* size (0 = byte, 1 = short, 2 = long) */
341 0, /* bitsize */
342 FALSE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_dont, /* complain_on_overflow */
345 NULL, /* special_function */
346 "R_LM32_GNU_VTINHERIT", /* name */
347 FALSE, /* partial_inplace */
348 0, /* src_mask */
349 0, /* dst_mask */
350 FALSE), /* pcrel_offset */
351
352 /* GNU extension to record C++ vtable member usage. */
353 HOWTO (R_LM32_GNU_VTENTRY, /* type */
354 0, /* rightshift */
355 2, /* size (0 = byte, 1 = short, 2 = long) */
356 0, /* bitsize */
357 FALSE, /* pc_relative */
358 0, /* bitpos */
359 complain_overflow_dont, /* complain_on_overflow */
360 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
361 "R_LM32_GNU_VTENTRY", /* name */
362 FALSE, /* partial_inplace */
363 0, /* src_mask */
364 0, /* dst_mask */
365 FALSE), /* pcrel_offset */
366
367 HOWTO (R_LM32_16_GOT, /* type */
368 0, /* rightshift */
369 2, /* size (0 = byte, 1 = short, 2 = long) */
370 16, /* bitsize */
371 FALSE, /* pc_relative */
372 0, /* bitpos */
373 complain_overflow_signed, /* complain_on_overflow */
374 bfd_elf_generic_reloc, /* special_function */
375 "R_LM32_16_GOT", /* name */
376 FALSE, /* partial_inplace */
377 0, /* src_mask */
378 0xffff, /* dst_mask */
379 FALSE), /* pcrel_offset */
380
381 HOWTO (R_LM32_GOTOFF_HI16, /* type */
382 16, /* rightshift */
383 2, /* size (0 = byte, 1 = short, 2 = long) */
384 16, /* bitsize */
385 FALSE, /* pc_relative */
386 0, /* bitpos */
387 complain_overflow_dont, /* complain_on_overflow */
388 bfd_elf_generic_reloc, /* special_function */
389 "R_LM32_GOTOFF_HI16", /* name */
390 FALSE, /* partial_inplace */
391 0xffff, /* src_mask */
392 0xffff, /* dst_mask */
393 FALSE), /* pcrel_offset */
394
395 HOWTO (R_LM32_GOTOFF_LO16, /* type */
396 0, /* rightshift */
397 2, /* size (0 = byte, 1 = short, 2 = long) */
398 16, /* bitsize */
399 FALSE, /* pc_relative */
400 0, /* bitpos */
401 complain_overflow_dont, /* complain_on_overflow */
402 bfd_elf_generic_reloc, /* special_function */
403 "R_LM32_GOTOFF_LO16", /* name */
404 FALSE, /* partial_inplace */
405 0xffff, /* src_mask */
406 0xffff, /* dst_mask */
407 FALSE), /* pcrel_offset */
408
409 HOWTO (R_LM32_COPY, /* type */
410 0, /* rightshift */
411 2, /* size (0 = byte, 1 = short, 2 = long) */
412 32, /* bitsize */
413 FALSE, /* pc_relative */
414 0, /* bitpos */
415 complain_overflow_bitfield, /* complain_on_overflow */
416 bfd_elf_generic_reloc, /* special_function */
417 "R_LM32_COPY", /* name */
418 FALSE, /* partial_inplace */
419 0xffffffff, /* src_mask */
420 0xffffffff, /* dst_mask */
421 FALSE), /* pcrel_offset */
422
423 HOWTO (R_LM32_GLOB_DAT, /* type */
424 0, /* rightshift */
425 2, /* size (0 = byte, 1 = short, 2 = long) */
426 32, /* bitsize */
427 FALSE, /* pc_relative */
428 0, /* bitpos */
429 complain_overflow_bitfield, /* complain_on_overflow */
430 bfd_elf_generic_reloc, /* special_function */
431 "R_LM32_GLOB_DAT", /* name */
432 FALSE, /* partial_inplace */
433 0xffffffff, /* src_mask */
434 0xffffffff, /* dst_mask */
435 FALSE), /* pcrel_offset */
436
437 HOWTO (R_LM32_JMP_SLOT, /* type */
438 0, /* rightshift */
439 2, /* size (0 = byte, 1 = short, 2 = long) */
440 32, /* bitsize */
441 FALSE, /* pc_relative */
442 0, /* bitpos */
443 complain_overflow_bitfield, /* complain_on_overflow */
444 bfd_elf_generic_reloc, /* special_function */
445 "R_LM32_JMP_SLOT", /* name */
446 FALSE, /* partial_inplace */
447 0xffffffff, /* src_mask */
448 0xffffffff, /* dst_mask */
449 FALSE), /* pcrel_offset */
450
451 HOWTO (R_LM32_RELATIVE, /* type */
452 0, /* rightshift */
453 2, /* size (0 = byte, 1 = short, 2 = long) */
454 32, /* bitsize */
455 FALSE, /* pc_relative */
456 0, /* bitpos */
457 complain_overflow_bitfield, /* complain_on_overflow */
458 bfd_elf_generic_reloc, /* special_function */
459 "R_LM32_RELATIVE", /* name */
460 FALSE, /* partial_inplace */
461 0xffffffff, /* src_mask */
462 0xffffffff, /* dst_mask */
463 FALSE), /* pcrel_offset */
464
465 };
466
467 /* Map BFD reloc types to lm32 ELF reloc types. */
468
469 struct lm32_reloc_map
470 {
471 bfd_reloc_code_real_type bfd_reloc_val;
472 unsigned char elf_reloc_val;
473 };
474
475 static const struct lm32_reloc_map lm32_reloc_map[] =
476 {
477 { BFD_RELOC_NONE, R_LM32_NONE },
478 { BFD_RELOC_8, R_LM32_8 },
479 { BFD_RELOC_16, R_LM32_16 },
480 { BFD_RELOC_32, R_LM32_32 },
481 { BFD_RELOC_HI16, R_LM32_HI16 },
482 { BFD_RELOC_LO16, R_LM32_LO16 },
483 { BFD_RELOC_GPREL16, R_LM32_GPREL16 },
484 { BFD_RELOC_LM32_CALL, R_LM32_CALL },
485 { BFD_RELOC_LM32_BRANCH, R_LM32_BRANCH },
486 { BFD_RELOC_VTABLE_INHERIT, R_LM32_GNU_VTINHERIT },
487 { BFD_RELOC_VTABLE_ENTRY, R_LM32_GNU_VTENTRY },
488 { BFD_RELOC_LM32_16_GOT, R_LM32_16_GOT },
489 { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 },
490 { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 },
491 { BFD_RELOC_LM32_COPY, R_LM32_COPY },
492 { BFD_RELOC_LM32_GLOB_DAT, R_LM32_GLOB_DAT },
493 { BFD_RELOC_LM32_JMP_SLOT, R_LM32_JMP_SLOT },
494 { BFD_RELOC_LM32_RELATIVE, R_LM32_RELATIVE },
495 };
496
497 static reloc_howto_type *
498 lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
499 bfd_reloc_code_real_type code)
500 {
501 unsigned int i;
502
503 for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++)
504 if (lm32_reloc_map[i].bfd_reloc_val == code)
505 return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val];
506 return NULL;
507 }
508
509 static reloc_howto_type *
510 lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
511 const char *r_name)
512 {
513 unsigned int i;
514
515 for (i = 0;
516 i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]);
517 i++)
518 if (lm32_elf_howto_table[i].name != NULL
519 && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0)
520 return &lm32_elf_howto_table[i];
521
522 return NULL;
523 }
524
525
526 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
527
528 static void
529 lm32_info_to_howto_rela (bfd *abfd,
530 arelent *cache_ptr,
531 Elf_Internal_Rela *dst)
532 {
533 unsigned int r_type;
534
535 r_type = ELF32_R_TYPE (dst->r_info);
536 if (r_type >= (unsigned int) R_LM32_max)
537 {
538 /* xgettext:c-format */
539 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
540 abfd, r_type);
541 r_type = 0;
542 }
543 cache_ptr->howto = &lm32_elf_howto_table[r_type];
544 }
545
546 /* Set the right machine number for an Lattice Mico32 ELF file. */
547
548 static bfd_boolean
549 lm32_elf_object_p (bfd *abfd)
550 {
551 return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
552 }
553
554 /* Set machine type flags just before file is written out. */
555
556 static void
557 lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
558 {
559 elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
560 elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
561 switch (bfd_get_mach (abfd))
562 {
563 case bfd_mach_lm32:
564 elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
565 break;
566 default:
567 abort ();
568 }
569 }
570
571 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
572 dangerous relocation. */
573
574 static bfd_boolean
575 lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
576 {
577 unsigned int count;
578 asymbol **sym;
579 unsigned int i;
580
581 /* If we've already figured out what GP will be, just return it. */
582 *pgp = _bfd_get_gp_value (output_bfd);
583 if (*pgp)
584 return TRUE;
585
586 count = bfd_get_symcount (output_bfd);
587 sym = bfd_get_outsymbols (output_bfd);
588
589 /* The linker script will have created a symbol named `_gp' with the
590 appropriate value. */
591 if (sym == NULL)
592 i = count;
593 else
594 {
595 for (i = 0; i < count; i++, sym++)
596 {
597 const char *name;
598
599 name = bfd_asymbol_name (*sym);
600 if (*name == '_' && strcmp (name, "_gp") == 0)
601 {
602 *pgp = bfd_asymbol_value (*sym);
603 _bfd_set_gp_value (output_bfd, *pgp);
604 break;
605 }
606 }
607 }
608
609 if (i >= count)
610 {
611 /* Only get the error once. */
612 *pgp = 4;
613 _bfd_set_gp_value (output_bfd, *pgp);
614 return FALSE;
615 }
616
617 return TRUE;
618 }
619
620 /* We have to figure out the gp value, so that we can adjust the
621 symbol value correctly. We look up the symbol _gp in the output
622 BFD. If we can't find it, we're stuck. We cache it in the ELF
623 target data. We don't need to adjust the symbol value for an
624 external symbol if we are producing relocatable output. */
625
626 static bfd_reloc_status_type
627 lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
628 char **error_message, bfd_vma *pgp)
629 {
630 if (bfd_is_und_section (symbol->section) && !relocatable)
631 {
632 *pgp = 0;
633 return bfd_reloc_undefined;
634 }
635
636 *pgp = _bfd_get_gp_value (output_bfd);
637 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
638 {
639 if (relocatable)
640 {
641 /* Make up a value. */
642 *pgp = symbol->section->output_section->vma + 0x4000;
643 _bfd_set_gp_value (output_bfd, *pgp);
644 }
645 else if (!lm32_elf_assign_gp (output_bfd, pgp))
646 {
647 *error_message =
648 (char *)
649 _("global pointer relative relocation when _gp not defined");
650 return bfd_reloc_dangerous;
651 }
652 }
653
654 return bfd_reloc_ok;
655 }
656
657 static bfd_reloc_status_type
658 lm32_elf_do_gprel_relocate (bfd *abfd,
659 reloc_howto_type *howto,
660 asection *input_section ATTRIBUTE_UNUSED,
661 bfd_byte *data,
662 bfd_vma offset,
663 bfd_vma symbol_value,
664 bfd_vma addend)
665 {
666 return _bfd_final_link_relocate (howto, abfd, input_section,
667 data, offset, symbol_value, addend);
668 }
669
670 static bfd_reloc_status_type
671 lm32_elf_gprel_reloc (bfd *abfd,
672 arelent *reloc_entry,
673 asymbol *symbol,
674 void *data,
675 asection *input_section,
676 bfd *output_bfd,
677 char **msg)
678 {
679 bfd_vma relocation;
680 bfd_vma gp;
681 bfd_reloc_status_type r;
682
683 if (output_bfd != (bfd *) NULL
684 && (symbol->flags & BSF_SECTION_SYM) == 0
685 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
686 {
687 reloc_entry->address += input_section->output_offset;
688 return bfd_reloc_ok;
689 }
690
691 if (output_bfd != NULL)
692 return bfd_reloc_ok;
693
694 relocation = symbol->value
695 + symbol->section->output_section->vma + symbol->section->output_offset;
696
697 if ((r =
698 lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
699 {
700 relocation = relocation + reloc_entry->addend - gp;
701 reloc_entry->addend = 0;
702 if ((signed) relocation < -32768 || (signed) relocation > 32767)
703 {
704 *msg = _("global pointer relative address out of range");
705 r = bfd_reloc_outofrange;
706 }
707 else
708 {
709 r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
710 input_section,
711 data, reloc_entry->address,
712 relocation, reloc_entry->addend);
713 }
714 }
715
716 return r;
717 }
718
719 /* Find the segment number in which OSEC, and output section, is
720 located. */
721
722 static unsigned
723 _lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
724 {
725 struct elf_segment_map *m;
726 Elf_Internal_Phdr *p;
727
728 /* Find the segment that contains the output_section. */
729 for (m = elf_seg_map (output_bfd), p = elf_tdata (output_bfd)->phdr;
730 m != NULL;
731 m = m->next, p++)
732 {
733 int i;
734
735 for (i = m->count - 1; i >= 0; i--)
736 if (m->sections[i] == osec)
737 break;
738
739 if (i >= 0)
740 break;
741 }
742
743 return p - elf_tdata (output_bfd)->phdr;
744 }
745
746 /* Determine if an output section is read-only. */
747
748 inline static bfd_boolean
749 _lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
750 {
751 unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
752
753 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
754 }
755
756 /* Relocate a section */
757
758 static bfd_boolean
759 lm32_elf_relocate_section (bfd *output_bfd,
760 struct bfd_link_info *info,
761 bfd *input_bfd,
762 asection *input_section,
763 bfd_byte *contents,
764 Elf_Internal_Rela *relocs,
765 Elf_Internal_Sym *local_syms,
766 asection **local_sections)
767 {
768 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
769 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
770 Elf_Internal_Rela *rel, *relend;
771 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
772 bfd_vma *local_got_offsets;
773 asection *sgot;
774
775 if (htab == NULL)
776 return FALSE;
777
778 local_got_offsets = elf_local_got_offsets (input_bfd);
779
780 sgot = htab->root.sgot;
781
782 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
783 sym_hashes = elf_sym_hashes (input_bfd);
784
785 rel = relocs;
786 relend = relocs + input_section->reloc_count;
787 for (; rel < relend; rel++)
788 {
789 reloc_howto_type *howto;
790 unsigned int r_type;
791 unsigned long r_symndx;
792 Elf_Internal_Sym *sym;
793 asection *sec;
794 struct elf_link_hash_entry *h;
795 bfd_vma relocation;
796 bfd_vma gp;
797 bfd_reloc_status_type r;
798 const char *name = NULL;
799
800 r_symndx = ELF32_R_SYM (rel->r_info);
801 r_type = ELF32_R_TYPE (rel->r_info);
802
803 if (r_type == R_LM32_GNU_VTENTRY
804 || r_type == R_LM32_GNU_VTINHERIT )
805 continue;
806
807 h = NULL;
808 sym = NULL;
809 sec = NULL;
810
811 howto = lm32_elf_howto_table + r_type;
812
813 if (r_symndx < symtab_hdr->sh_info)
814 {
815 /* It's a local symbol. */
816 sym = local_syms + r_symndx;
817 sec = local_sections[r_symndx];
818 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
819 name = bfd_elf_string_from_elf_section
820 (input_bfd, symtab_hdr->sh_link, sym->st_name);
821 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
822 }
823 else
824 {
825 /* It's a global symbol. */
826 bfd_boolean unresolved_reloc;
827 bfd_boolean warned, ignored;
828
829 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
830 r_symndx, symtab_hdr, sym_hashes,
831 h, sec, relocation,
832 unresolved_reloc, warned, ignored);
833 name = h->root.root.string;
834 }
835
836 if (sec != NULL && discarded_section (sec))
837 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
838 rel, 1, relend, howto, 0, contents);
839
840 if (bfd_link_relocatable (info))
841 {
842 /* This is a relocatable link. We don't have to change
843 anything, unless the reloc is against a section symbol,
844 in which case we have to adjust according to where the
845 section symbol winds up in the output section. */
846 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
847 continue;
848
849 /* If partial_inplace, we need to store any additional addend
850 back in the section. */
851 if (! howto->partial_inplace)
852 continue;
853
854 /* Shouldn't reach here. */
855 abort ();
856 r = bfd_reloc_ok;
857 }
858 else
859 {
860 switch (howto->type)
861 {
862 case R_LM32_GPREL16:
863 if (!lm32_elf_assign_gp (output_bfd, &gp))
864 r = bfd_reloc_dangerous;
865 else
866 {
867 relocation = relocation + rel->r_addend - gp;
868 rel->r_addend = 0;
869 if ((signed)relocation < -32768 || (signed)relocation > 32767)
870 r = bfd_reloc_outofrange;
871 else
872 {
873 r = _bfd_final_link_relocate (howto, input_bfd,
874 input_section, contents,
875 rel->r_offset, relocation,
876 rel->r_addend);
877 }
878 }
879 break;
880 case R_LM32_16_GOT:
881 /* Relocation is to the entry for this symbol in the global
882 offset table. */
883 BFD_ASSERT (sgot != NULL);
884 if (h != NULL)
885 {
886 bfd_boolean dyn;
887 bfd_vma off;
888
889 off = h->got.offset;
890 BFD_ASSERT (off != (bfd_vma) -1);
891
892 dyn = htab->root.dynamic_sections_created;
893 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
894 bfd_link_pic (info),
895 h)
896 || (bfd_link_pic (info)
897 && (info->symbolic
898 || h->dynindx == -1
899 || h->forced_local)
900 && h->def_regular))
901 {
902 /* This is actually a static link, or it is a
903 -Bsymbolic link and the symbol is defined
904 locally, or the symbol was forced to be local
905 because of a version file. We must initialize
906 this entry in the global offset table. Since the
907 offset must always be a multiple of 4, we use the
908 least significant bit to record whether we have
909 initialized it already.
910
911 When doing a dynamic link, we create a .rela.got
912 relocation entry to initialize the value. This
913 is done in the finish_dynamic_symbol routine. */
914 if ((off & 1) != 0)
915 off &= ~1;
916 else
917 {
918 /* Write entry in GOT */
919 bfd_put_32 (output_bfd, relocation,
920 sgot->contents + off);
921 /* Create entry in .rofixup pointing to GOT entry. */
922 if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
923 {
924 _lm32fdpic_add_rofixup (output_bfd,
925 lm32fdpic_fixup32_section
926 (info),
927 sgot->output_section->vma
928 + sgot->output_offset
929 + off);
930 }
931 /* Mark GOT entry as having been written. */
932 h->got.offset |= 1;
933 }
934 }
935
936 relocation = sgot->output_offset + off;
937 }
938 else
939 {
940 bfd_vma off;
941 bfd_byte *loc;
942
943 BFD_ASSERT (local_got_offsets != NULL
944 && local_got_offsets[r_symndx] != (bfd_vma) -1);
945
946 /* Get offset into GOT table. */
947 off = local_got_offsets[r_symndx];
948
949 /* The offset must always be a multiple of 4. We use
950 the least significant bit to record whether we have
951 already processed this entry. */
952 if ((off & 1) != 0)
953 off &= ~1;
954 else
955 {
956 /* Write entry in GOT. */
957 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
958 /* Create entry in .rofixup pointing to GOT entry. */
959 if (IS_FDPIC (output_bfd))
960 {
961 _lm32fdpic_add_rofixup (output_bfd,
962 lm32fdpic_fixup32_section
963 (info),
964 sgot->output_section->vma
965 + sgot->output_offset
966 + off);
967 }
968
969 if (bfd_link_pic (info))
970 {
971 asection *srelgot;
972 Elf_Internal_Rela outrel;
973
974 /* We need to generate a R_LM32_RELATIVE reloc
975 for the dynamic linker. */
976 srelgot = htab->root.srelgot;
977 BFD_ASSERT (srelgot != NULL);
978
979 outrel.r_offset = (sgot->output_section->vma
980 + sgot->output_offset
981 + off);
982 outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
983 outrel.r_addend = relocation;
984 loc = srelgot->contents;
985 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
986 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
987 ++srelgot->reloc_count;
988 }
989
990 local_got_offsets[r_symndx] |= 1;
991 }
992
993
994 relocation = sgot->output_offset + off;
995 }
996
997 /* Addend should be zero. */
998 if (rel->r_addend != 0)
999 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
1000
1001 r = _bfd_final_link_relocate (howto,
1002 input_bfd,
1003 input_section,
1004 contents,
1005 rel->r_offset,
1006 relocation,
1007 rel->r_addend);
1008 break;
1009
1010 case R_LM32_GOTOFF_LO16:
1011 case R_LM32_GOTOFF_HI16:
1012 /* Relocation is offset from GOT. */
1013 BFD_ASSERT (sgot != NULL);
1014 relocation -= sgot->output_section->vma;
1015 /* Account for sign-extension. */
1016 if ((r_type == R_LM32_GOTOFF_HI16)
1017 && ((relocation + rel->r_addend) & 0x8000))
1018 rel->r_addend += 0x10000;
1019 r = _bfd_final_link_relocate (howto,
1020 input_bfd,
1021 input_section,
1022 contents,
1023 rel->r_offset,
1024 relocation,
1025 rel->r_addend);
1026 break;
1027
1028 case R_LM32_32:
1029 if (IS_FDPIC (output_bfd))
1030 {
1031 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1032 {
1033 /* Only create .rofixup entries for relocs in loadable sections. */
1034 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1035 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1036
1037 {
1038 /* Check address to be modified is writable. */
1039 if (_lm32fdpic_osec_readonly_p (output_bfd,
1040 input_section
1041 ->output_section))
1042 {
1043 info->callbacks->warning
1044 (info,
1045 _("cannot emit dynamic relocations in read-only section"),
1046 name, input_bfd, input_section, rel->r_offset);
1047 return FALSE;
1048 }
1049 /* Create entry in .rofixup section. */
1050 _lm32fdpic_add_rofixup (output_bfd,
1051 lm32fdpic_fixup32_section (info),
1052 input_section->output_section->vma
1053 + input_section->output_offset
1054 + rel->r_offset);
1055 }
1056 }
1057 }
1058 /* Fall through. */
1059
1060 default:
1061 r = _bfd_final_link_relocate (howto,
1062 input_bfd,
1063 input_section,
1064 contents,
1065 rel->r_offset,
1066 relocation,
1067 rel->r_addend);
1068 break;
1069 }
1070 }
1071
1072 if (r != bfd_reloc_ok)
1073 {
1074 const char *msg = NULL;
1075 arelent bfd_reloc;
1076
1077 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1078 howto = bfd_reloc.howto;
1079
1080 if (h != NULL)
1081 name = h->root.root.string;
1082 else
1083 {
1084 name = (bfd_elf_string_from_elf_section
1085 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1086 if (name == NULL || *name == '\0')
1087 name = bfd_section_name (input_bfd, sec);
1088 }
1089
1090 switch (r)
1091 {
1092 case bfd_reloc_overflow:
1093 if ((h != NULL)
1094 && (h->root.type == bfd_link_hash_undefweak))
1095 break;
1096 (*info->callbacks->reloc_overflow)
1097 (info, (h ? &h->root : NULL), name, howto->name,
1098 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1099 break;
1100
1101 case bfd_reloc_undefined:
1102 (*info->callbacks->undefined_symbol)
1103 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1104 break;
1105
1106 case bfd_reloc_outofrange:
1107 msg = _("internal error: out of range error");
1108 goto common_error;
1109
1110 case bfd_reloc_notsupported:
1111 msg = _("internal error: unsupported relocation error");
1112 goto common_error;
1113
1114 case bfd_reloc_dangerous:
1115 msg = _("internal error: dangerous error");
1116 goto common_error;
1117
1118 default:
1119 msg = _("internal error: unknown error");
1120 /* fall through */
1121
1122 common_error:
1123 (*info->callbacks->warning) (info, msg, name, input_bfd,
1124 input_section, rel->r_offset);
1125 break;
1126 }
1127 }
1128 }
1129
1130 return TRUE;
1131 }
1132
1133 static asection *
1134 lm32_elf_gc_mark_hook (asection *sec,
1135 struct bfd_link_info *info,
1136 Elf_Internal_Rela *rel,
1137 struct elf_link_hash_entry *h,
1138 Elf_Internal_Sym *sym)
1139 {
1140 if (h != NULL)
1141 switch (ELF32_R_TYPE (rel->r_info))
1142 {
1143 case R_LM32_GNU_VTINHERIT:
1144 case R_LM32_GNU_VTENTRY:
1145 return NULL;
1146 }
1147
1148 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1149 }
1150
1151 /* Look through the relocs for a section during the first phase. */
1152
1153 static bfd_boolean
1154 lm32_elf_check_relocs (bfd *abfd,
1155 struct bfd_link_info *info,
1156 asection *sec,
1157 const Elf_Internal_Rela *relocs)
1158 {
1159 Elf_Internal_Shdr *symtab_hdr;
1160 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1161 const Elf_Internal_Rela *rel;
1162 const Elf_Internal_Rela *rel_end;
1163 struct elf_lm32_link_hash_table *htab;
1164 bfd *dynobj;
1165
1166 if (bfd_link_relocatable (info))
1167 return TRUE;
1168
1169 /* Don't do anything special with non-loaded, non-alloced sections.
1170 In particular, any relocs in such sections should not affect GOT
1171 and PLT reference counting (ie. we don't allow them to create GOT
1172 or PLT entries), there's no possibility or desire to optimize TLS
1173 relocs, and there's not much point in propagating relocs to shared
1174 libs that the dynamic linker won't relocate. */
1175 if ((sec->flags & SEC_ALLOC) == 0)
1176 return TRUE;
1177
1178 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1179 sym_hashes = elf_sym_hashes (abfd);
1180 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1181 if (!elf_bad_symtab (abfd))
1182 sym_hashes_end -= symtab_hdr->sh_info;
1183
1184 htab = lm32_elf_hash_table (info);
1185 if (htab == NULL)
1186 return FALSE;
1187
1188 dynobj = htab->root.dynobj;
1189
1190 rel_end = relocs + sec->reloc_count;
1191 for (rel = relocs; rel < rel_end; rel++)
1192 {
1193 int r_type;
1194 struct elf_link_hash_entry *h;
1195 unsigned long r_symndx;
1196
1197 r_symndx = ELF32_R_SYM (rel->r_info);
1198 r_type = ELF32_R_TYPE (rel->r_info);
1199 if (r_symndx < symtab_hdr->sh_info)
1200 h = NULL;
1201 else
1202 {
1203 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1204 while (h->root.type == bfd_link_hash_indirect
1205 || h->root.type == bfd_link_hash_warning)
1206 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1207 }
1208
1209 /* Some relocs require a global offset table. */
1210 if (htab->root.sgot == NULL)
1211 {
1212 switch (r_type)
1213 {
1214 case R_LM32_16_GOT:
1215 case R_LM32_GOTOFF_HI16:
1216 case R_LM32_GOTOFF_LO16:
1217 if (dynobj == NULL)
1218 htab->root.dynobj = dynobj = abfd;
1219 if (!_bfd_elf_create_got_section (dynobj, info))
1220 return FALSE;
1221 break;
1222 }
1223 }
1224
1225 /* Some relocs require a rofixup table. */
1226 if (IS_FDPIC (abfd))
1227 {
1228 switch (r_type)
1229 {
1230 case R_LM32_32:
1231 /* FDPIC requires a GOT if there is a .rofixup section
1232 (Normal ELF doesn't). */
1233 if (dynobj == NULL)
1234 htab->root.dynobj = dynobj = abfd;
1235 if (!_bfd_elf_create_got_section (dynobj, info))
1236 return FALSE;
1237 /* Create .rofixup section */
1238 if (htab->sfixup32 == NULL)
1239 {
1240 if (! create_rofixup_section (dynobj, info))
1241 return FALSE;
1242 }
1243 break;
1244 case R_LM32_16_GOT:
1245 case R_LM32_GOTOFF_HI16:
1246 case R_LM32_GOTOFF_LO16:
1247 /* Create .rofixup section. */
1248 if (htab->sfixup32 == NULL)
1249 {
1250 if (dynobj == NULL)
1251 htab->root.dynobj = dynobj = abfd;
1252 if (! create_rofixup_section (dynobj, info))
1253 return FALSE;
1254 }
1255 break;
1256 }
1257 }
1258
1259 switch (r_type)
1260 {
1261 case R_LM32_16_GOT:
1262 if (h != NULL)
1263 h->got.refcount += 1;
1264 else
1265 {
1266 bfd_signed_vma *local_got_refcounts;
1267
1268 /* This is a global offset table entry for a local symbol. */
1269 local_got_refcounts = elf_local_got_refcounts (abfd);
1270 if (local_got_refcounts == NULL)
1271 {
1272 bfd_size_type size;
1273
1274 size = symtab_hdr->sh_info;
1275 size *= sizeof (bfd_signed_vma);
1276 local_got_refcounts = bfd_zalloc (abfd, size);
1277 if (local_got_refcounts == NULL)
1278 return FALSE;
1279 elf_local_got_refcounts (abfd) = local_got_refcounts;
1280 }
1281 local_got_refcounts[r_symndx] += 1;
1282 }
1283 break;
1284
1285 /* This relocation describes the C++ object vtable hierarchy.
1286 Reconstruct it for later use during GC. */
1287 case R_LM32_GNU_VTINHERIT:
1288 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1289 return FALSE;
1290 break;
1291
1292 /* This relocation describes which C++ vtable entries are actually
1293 used. Record for later use during GC. */
1294 case R_LM32_GNU_VTENTRY:
1295 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1296 return FALSE;
1297 break;
1298
1299 }
1300 }
1301
1302 return TRUE;
1303 }
1304
1305 /* Finish up the dynamic sections. */
1306
1307 static bfd_boolean
1308 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1309 struct bfd_link_info *info)
1310 {
1311 struct elf_lm32_link_hash_table *htab;
1312 bfd *dynobj;
1313 asection *sdyn;
1314 asection *sgot;
1315
1316 htab = lm32_elf_hash_table (info);
1317 if (htab == NULL)
1318 return FALSE;
1319
1320 dynobj = htab->root.dynobj;
1321
1322 sgot = htab->root.sgotplt;
1323 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1324
1325 if (htab->root.dynamic_sections_created)
1326 {
1327 asection *splt;
1328 Elf32_External_Dyn *dyncon, *dynconend;
1329
1330 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1331
1332 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1333 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1334
1335 for (; dyncon < dynconend; dyncon++)
1336 {
1337 Elf_Internal_Dyn dyn;
1338 asection *s;
1339
1340 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1341
1342 switch (dyn.d_tag)
1343 {
1344 default:
1345 break;
1346
1347 case DT_PLTGOT:
1348 s = htab->root.sgotplt;
1349 goto get_vma;
1350 case DT_JMPREL:
1351 s = htab->root.srelplt;
1352 get_vma:
1353 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1354 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1355 break;
1356
1357 case DT_PLTRELSZ:
1358 s = htab->root.srelplt;
1359 dyn.d_un.d_val = s->size;
1360 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1361 break;
1362 }
1363 }
1364
1365 /* Fill in the first entry in the procedure linkage table. */
1366 splt = htab->root.splt;
1367 if (splt && splt->size > 0)
1368 {
1369 if (bfd_link_pic (info))
1370 {
1371 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1372 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1373 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1374 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1375 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1376 }
1377 else
1378 {
1379 unsigned long addr;
1380 /* addr = .got + 4 */
1381 addr = sgot->output_section->vma + sgot->output_offset + 4;
1382 bfd_put_32 (output_bfd,
1383 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1384 splt->contents);
1385 bfd_put_32 (output_bfd,
1386 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1387 splt->contents + 4);
1388 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1389 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1390 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1391 }
1392
1393 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1394 PLT_ENTRY_SIZE;
1395 }
1396 }
1397
1398 /* Fill in the first three entries in the global offset table. */
1399 if (sgot && sgot->size > 0)
1400 {
1401 if (sdyn == NULL)
1402 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1403 else
1404 bfd_put_32 (output_bfd,
1405 sdyn->output_section->vma + sdyn->output_offset,
1406 sgot->contents);
1407 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1408 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1409
1410 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1411 if (elf_section_data (sgot->output_section) != NULL)
1412 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1413 }
1414
1415 if (lm32fdpic_fixup32_section (info))
1416 {
1417 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1418 bfd_vma got_value = hgot->root.u.def.value
1419 + hgot->root.u.def.section->output_section->vma
1420 + hgot->root.u.def.section->output_offset;
1421 struct bfd_link_hash_entry *hend;
1422
1423 /* Last entry is pointer to GOT. */
1424 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1425
1426 /* Check we wrote enough entries. */
1427 if (lm32fdpic_fixup32_section (info)->size
1428 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1429 {
1430 _bfd_error_handler
1431 ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1432 " != relocs %d",
1433 (int64_t) (lm32fdpic_fixup32_section (info)->size / 4),
1434 lm32fdpic_fixup32_section (info)->reloc_count);
1435 return FALSE;
1436 }
1437
1438 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1439 FALSE, FALSE, TRUE);
1440 if (hend
1441 && (hend->type == bfd_link_hash_defined
1442 || hend->type == bfd_link_hash_defweak))
1443 {
1444 bfd_vma value =
1445 lm32fdpic_fixup32_section (info)->output_section->vma
1446 + lm32fdpic_fixup32_section (info)->output_offset
1447 + lm32fdpic_fixup32_section (info)->size
1448 - hend->u.def.section->output_section->vma
1449 - hend->u.def.section->output_offset;
1450 BFD_ASSERT (hend->u.def.value == value);
1451 if (hend->u.def.value != value)
1452 {
1453 _bfd_error_handler
1454 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1455 PRId64 " != %" PRId64,
1456 (int64_t) hend->u.def.value, (int64_t) value);
1457 return FALSE;
1458 }
1459 }
1460 }
1461
1462 return TRUE;
1463 }
1464
1465 /* Finish up dynamic symbol handling. We set the contents of various
1466 dynamic sections here. */
1467
1468 static bfd_boolean
1469 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1470 struct bfd_link_info *info,
1471 struct elf_link_hash_entry *h,
1472 Elf_Internal_Sym *sym)
1473 {
1474 struct elf_lm32_link_hash_table *htab;
1475 bfd_byte *loc;
1476
1477 htab = lm32_elf_hash_table (info);
1478 if (htab == NULL)
1479 return FALSE;
1480
1481 if (h->plt.offset != (bfd_vma) -1)
1482 {
1483 asection *splt;
1484 asection *sgot;
1485 asection *srela;
1486
1487 bfd_vma plt_index;
1488 bfd_vma got_offset;
1489 Elf_Internal_Rela rela;
1490
1491 /* This symbol has an entry in the procedure linkage table. Set
1492 it up. */
1493 BFD_ASSERT (h->dynindx != -1);
1494
1495 splt = htab->root.splt;
1496 sgot = htab->root.sgotplt;
1497 srela = htab->root.srelplt;
1498 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1499
1500 /* Get the index in the procedure linkage table which
1501 corresponds to this symbol. This is the index of this symbol
1502 in all the symbols for which we are making plt entries. The
1503 first entry in the procedure linkage table is reserved. */
1504 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1505
1506 /* Get the offset into the .got table of the entry that
1507 corresponds to this function. Each .got entry is 4 bytes.
1508 The first three are reserved. */
1509 got_offset = (plt_index + 3) * 4;
1510
1511 /* Fill in the entry in the procedure linkage table. */
1512 if (! bfd_link_pic (info))
1513 {
1514 /* TODO */
1515 }
1516 else
1517 {
1518 /* TODO */
1519 }
1520
1521 /* Fill in the entry in the global offset table. */
1522 bfd_put_32 (output_bfd,
1523 (splt->output_section->vma
1524 + splt->output_offset
1525 + h->plt.offset
1526 + 12), /* same offset */
1527 sgot->contents + got_offset);
1528
1529 /* Fill in the entry in the .rela.plt section. */
1530 rela.r_offset = (sgot->output_section->vma
1531 + sgot->output_offset
1532 + got_offset);
1533 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1534 rela.r_addend = 0;
1535 loc = srela->contents;
1536 loc += plt_index * sizeof (Elf32_External_Rela);
1537 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1538
1539 if (!h->def_regular)
1540 {
1541 /* Mark the symbol as undefined, rather than as defined in
1542 the .plt section. Leave the value alone. */
1543 sym->st_shndx = SHN_UNDEF;
1544 }
1545
1546 }
1547
1548 if (h->got.offset != (bfd_vma) -1)
1549 {
1550 asection *sgot;
1551 asection *srela;
1552 Elf_Internal_Rela rela;
1553
1554 /* This symbol has an entry in the global offset table. Set it
1555 up. */
1556 sgot = htab->root.sgot;
1557 srela = htab->root.srelgot;
1558 BFD_ASSERT (sgot != NULL && srela != NULL);
1559
1560 rela.r_offset = (sgot->output_section->vma
1561 + sgot->output_offset
1562 + (h->got.offset &~ 1));
1563
1564 /* If this is a -Bsymbolic link, and the symbol is defined
1565 locally, we just want to emit a RELATIVE reloc. Likewise if
1566 the symbol was forced to be local because of a version file.
1567 The entry in the global offset table will already have been
1568 initialized in the relocate_section function. */
1569 if (bfd_link_pic (info)
1570 && (info->symbolic
1571 || h->dynindx == -1
1572 || h->forced_local)
1573 && h->def_regular)
1574 {
1575 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1576 rela.r_addend = (h->root.u.def.value
1577 + h->root.u.def.section->output_section->vma
1578 + h->root.u.def.section->output_offset);
1579 }
1580 else
1581 {
1582 BFD_ASSERT ((h->got.offset & 1) == 0);
1583 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1584 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1585 rela.r_addend = 0;
1586 }
1587
1588 loc = srela->contents;
1589 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1590 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1591 ++srela->reloc_count;
1592 }
1593
1594 if (h->needs_copy)
1595 {
1596 asection *s;
1597 Elf_Internal_Rela rela;
1598
1599 /* This symbols needs a copy reloc. Set it up. */
1600 BFD_ASSERT (h->dynindx != -1
1601 && (h->root.type == bfd_link_hash_defined
1602 || h->root.type == bfd_link_hash_defweak));
1603
1604 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1605 BFD_ASSERT (s != NULL);
1606
1607 rela.r_offset = (h->root.u.def.value
1608 + h->root.u.def.section->output_section->vma
1609 + h->root.u.def.section->output_offset);
1610 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1611 rela.r_addend = 0;
1612 loc = s->contents;
1613 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1614 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1615 ++s->reloc_count;
1616 }
1617
1618 /* Mark some specially defined symbols as absolute. */
1619 if (h == htab->root.hdynamic || h == htab->root.hgot)
1620 sym->st_shndx = SHN_ABS;
1621
1622 return TRUE;
1623 }
1624
1625 static enum elf_reloc_type_class
1626 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1627 const asection *rel_sec ATTRIBUTE_UNUSED,
1628 const Elf_Internal_Rela *rela)
1629 {
1630 switch ((int) ELF32_R_TYPE (rela->r_info))
1631 {
1632 case R_LM32_RELATIVE: return reloc_class_relative;
1633 case R_LM32_JMP_SLOT: return reloc_class_plt;
1634 case R_LM32_COPY: return reloc_class_copy;
1635 default: return reloc_class_normal;
1636 }
1637 }
1638
1639 /* Find dynamic relocs for H that apply to read-only sections. */
1640
1641 static asection *
1642 readonly_dynrelocs (struct elf_link_hash_entry *h)
1643 {
1644 struct elf_dyn_relocs *p;
1645 struct elf_lm32_link_hash_entry *eh = (struct elf_lm32_link_hash_entry *) h;
1646
1647 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1648 {
1649 asection *s = p->sec->output_section;
1650
1651 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1652 return p->sec;
1653 }
1654 return NULL;
1655 }
1656
1657 /* Adjust a symbol defined by a dynamic object and referenced by a
1658 regular object. The current definition is in some section of the
1659 dynamic object, but we're not including those sections. We have to
1660 change the definition to something the rest of the link can
1661 understand. */
1662
1663 static bfd_boolean
1664 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1665 struct elf_link_hash_entry *h)
1666 {
1667 struct elf_lm32_link_hash_table *htab;
1668 bfd *dynobj;
1669 asection *s;
1670
1671 dynobj = elf_hash_table (info)->dynobj;
1672
1673 /* Make sure we know what is going on here. */
1674 BFD_ASSERT (dynobj != NULL
1675 && (h->needs_plt
1676 || h->is_weakalias
1677 || (h->def_dynamic
1678 && h->ref_regular
1679 && !h->def_regular)));
1680
1681 /* If this is a function, put it in the procedure linkage table. We
1682 will fill in the contents of the procedure linkage table later,
1683 when we know the address of the .got section. */
1684 if (h->type == STT_FUNC
1685 || h->needs_plt)
1686 {
1687 if (! bfd_link_pic (info)
1688 && !h->def_dynamic
1689 && !h->ref_dynamic
1690 && h->root.type != bfd_link_hash_undefweak
1691 && h->root.type != bfd_link_hash_undefined)
1692 {
1693 /* This case can occur if we saw a PLT reloc in an input
1694 file, but the symbol was never referred to by a dynamic
1695 object. In such a case, we don't actually need to build
1696 a procedure linkage table, and we can just do a PCREL
1697 reloc instead. */
1698 h->plt.offset = (bfd_vma) -1;
1699 h->needs_plt = 0;
1700 }
1701
1702 return TRUE;
1703 }
1704 else
1705 h->plt.offset = (bfd_vma) -1;
1706
1707 /* If this is a weak symbol, and there is a real definition, the
1708 processor independent code will have arranged for us to see the
1709 real definition first, and we can just use the same value. */
1710 if (h->is_weakalias)
1711 {
1712 struct elf_link_hash_entry *def = weakdef (h);
1713 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1714 h->root.u.def.section = def->root.u.def.section;
1715 h->root.u.def.value = def->root.u.def.value;
1716 return TRUE;
1717 }
1718
1719 /* This is a reference to a symbol defined by a dynamic object which
1720 is not a function. */
1721
1722 /* If we are creating a shared library, we must presume that the
1723 only references to the symbol are via the global offset table.
1724 For such cases we need not do anything here; the relocations will
1725 be handled correctly by relocate_section. */
1726 if (bfd_link_pic (info))
1727 return TRUE;
1728
1729 /* If there are no references to this symbol that do not use the
1730 GOT, we don't need to generate a copy reloc. */
1731 if (!h->non_got_ref)
1732 return TRUE;
1733
1734 /* If -z nocopyreloc was given, we won't generate them either. */
1735 if (0 && info->nocopyreloc)
1736 {
1737 h->non_got_ref = 0;
1738 return TRUE;
1739 }
1740
1741 /* If we don't find any dynamic relocs in read-only sections, then
1742 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1743 if (0 && !readonly_dynrelocs (h))
1744 {
1745 h->non_got_ref = 0;
1746 return TRUE;
1747 }
1748
1749 /* We must allocate the symbol in our .dynbss section, which will
1750 become part of the .bss section of the executable. There will be
1751 an entry for this symbol in the .dynsym section. The dynamic
1752 object will contain position independent code, so all references
1753 from the dynamic object to this symbol will go through the global
1754 offset table. The dynamic linker will use the .dynsym entry to
1755 determine the address it must put in the global offset table, so
1756 both the dynamic object and the regular object will refer to the
1757 same memory location for the variable. */
1758
1759 htab = lm32_elf_hash_table (info);
1760 if (htab == NULL)
1761 return FALSE;
1762
1763 s = htab->sdynbss;
1764 BFD_ASSERT (s != NULL);
1765
1766 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1767 to copy the initial value out of the dynamic object and into the
1768 runtime process image. We need to remember the offset into the
1769 .rela.bss section we are going to use. */
1770 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1771 {
1772 asection *srel;
1773
1774 srel = htab->srelbss;
1775 BFD_ASSERT (srel != NULL);
1776 srel->size += sizeof (Elf32_External_Rela);
1777 h->needs_copy = 1;
1778 }
1779
1780 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1781 }
1782
1783 /* Allocate space in .plt, .got and associated reloc sections for
1784 dynamic relocs. */
1785
1786 static bfd_boolean
1787 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1788 {
1789 struct bfd_link_info *info;
1790 struct elf_lm32_link_hash_table *htab;
1791 struct elf_lm32_link_hash_entry *eh;
1792 struct elf_dyn_relocs *p;
1793
1794 if (h->root.type == bfd_link_hash_indirect)
1795 return TRUE;
1796
1797 info = (struct bfd_link_info *) inf;
1798 htab = lm32_elf_hash_table (info);
1799 if (htab == NULL)
1800 return FALSE;
1801
1802 eh = (struct elf_lm32_link_hash_entry *) h;
1803
1804 if (htab->root.dynamic_sections_created
1805 && h->plt.refcount > 0)
1806 {
1807 /* Make sure this symbol is output as a dynamic symbol.
1808 Undefined weak syms won't yet be marked as dynamic. */
1809 if (h->dynindx == -1
1810 && !h->forced_local)
1811 {
1812 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1813 return FALSE;
1814 }
1815
1816 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1817 {
1818 asection *s = htab->root.splt;
1819
1820 /* If this is the first .plt entry, make room for the special
1821 first entry. */
1822 if (s->size == 0)
1823 s->size += PLT_ENTRY_SIZE;
1824
1825 h->plt.offset = s->size;
1826
1827 /* If this symbol is not defined in a regular file, and we are
1828 not generating a shared library, then set the symbol to this
1829 location in the .plt. This is required to make function
1830 pointers compare as equal between the normal executable and
1831 the shared library. */
1832 if (! bfd_link_pic (info)
1833 && !h->def_regular)
1834 {
1835 h->root.u.def.section = s;
1836 h->root.u.def.value = h->plt.offset;
1837 }
1838
1839 /* Make room for this entry. */
1840 s->size += PLT_ENTRY_SIZE;
1841
1842 /* We also need to make an entry in the .got.plt section, which
1843 will be placed in the .got section by the linker script. */
1844 htab->root.sgotplt->size += 4;
1845
1846 /* We also need to make an entry in the .rel.plt section. */
1847 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1848 }
1849 else
1850 {
1851 h->plt.offset = (bfd_vma) -1;
1852 h->needs_plt = 0;
1853 }
1854 }
1855 else
1856 {
1857 h->plt.offset = (bfd_vma) -1;
1858 h->needs_plt = 0;
1859 }
1860
1861 if (h->got.refcount > 0)
1862 {
1863 asection *s;
1864 bfd_boolean dyn;
1865
1866 /* Make sure this symbol is output as a dynamic symbol.
1867 Undefined weak syms won't yet be marked as dynamic. */
1868 if (h->dynindx == -1
1869 && !h->forced_local)
1870 {
1871 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1872 return FALSE;
1873 }
1874
1875 s = htab->root.sgot;
1876
1877 h->got.offset = s->size;
1878 s->size += 4;
1879 dyn = htab->root.dynamic_sections_created;
1880 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1881 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1882 }
1883 else
1884 h->got.offset = (bfd_vma) -1;
1885
1886 if (eh->dyn_relocs == NULL)
1887 return TRUE;
1888
1889 /* In the shared -Bsymbolic case, discard space allocated for
1890 dynamic pc-relative relocs against symbols which turn out to be
1891 defined in regular objects. For the normal shared case, discard
1892 space for pc-relative relocs that have become local due to symbol
1893 visibility changes. */
1894
1895 if (bfd_link_pic (info))
1896 {
1897 if (h->def_regular
1898 && (h->forced_local
1899 || info->symbolic))
1900 {
1901 struct elf_dyn_relocs **pp;
1902
1903 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1904 {
1905 p->count -= p->pc_count;
1906 p->pc_count = 0;
1907 if (p->count == 0)
1908 *pp = p->next;
1909 else
1910 pp = &p->next;
1911 }
1912 }
1913
1914 /* Also discard relocs on undefined weak syms with non-default
1915 visibility. */
1916 if (eh->dyn_relocs != NULL
1917 && h->root.type == bfd_link_hash_undefweak)
1918 {
1919 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1920 eh->dyn_relocs = NULL;
1921
1922 /* Make sure undefined weak symbols are output as a dynamic
1923 symbol in PIEs. */
1924 else if (h->dynindx == -1
1925 && !h->forced_local)
1926 {
1927 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1928 return FALSE;
1929 }
1930 }
1931 }
1932 else
1933 {
1934 /* For the non-shared case, discard space for relocs against
1935 symbols which turn out to need copy relocs or are not
1936 dynamic. */
1937
1938 if (!h->non_got_ref
1939 && ((h->def_dynamic
1940 && !h->def_regular)
1941 || (htab->root.dynamic_sections_created
1942 && (h->root.type == bfd_link_hash_undefweak
1943 || h->root.type == bfd_link_hash_undefined))))
1944 {
1945 /* Make sure this symbol is output as a dynamic symbol.
1946 Undefined weak syms won't yet be marked as dynamic. */
1947 if (h->dynindx == -1
1948 && !h->forced_local)
1949 {
1950 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1951 return FALSE;
1952 }
1953
1954 /* If that succeeded, we know we'll be keeping all the
1955 relocs. */
1956 if (h->dynindx != -1)
1957 goto keep;
1958 }
1959
1960 eh->dyn_relocs = NULL;
1961
1962 keep: ;
1963 }
1964
1965 /* Finally, allocate space. */
1966 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1967 {
1968 asection *sreloc = elf_section_data (p->sec)->sreloc;
1969 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1970 }
1971
1972 return TRUE;
1973 }
1974
1975 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1976 read-only sections. */
1977
1978 static bfd_boolean
1979 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1980 {
1981 asection *sec;
1982
1983 if (h->root.type == bfd_link_hash_indirect)
1984 return TRUE;
1985
1986 sec = readonly_dynrelocs (h);
1987 if (sec != NULL)
1988 {
1989 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1990
1991 info->flags |= DF_TEXTREL;
1992 info->callbacks->minfo
1993 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1994 sec->owner, h->root.root.string, sec);
1995
1996 /* Not an error, just cut short the traversal. */
1997 return FALSE;
1998 }
1999 return TRUE;
2000 }
2001
2002 /* Set the sizes of the dynamic sections. */
2003
2004 static bfd_boolean
2005 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2006 struct bfd_link_info *info)
2007 {
2008 struct elf_lm32_link_hash_table *htab;
2009 bfd *dynobj;
2010 asection *s;
2011 bfd_boolean relocs;
2012 bfd *ibfd;
2013
2014 htab = lm32_elf_hash_table (info);
2015 if (htab == NULL)
2016 return FALSE;
2017
2018 dynobj = htab->root.dynobj;
2019 BFD_ASSERT (dynobj != NULL);
2020
2021 if (htab->root.dynamic_sections_created)
2022 {
2023 /* Set the contents of the .interp section to the interpreter. */
2024 if (bfd_link_executable (info) && !info->nointerp)
2025 {
2026 s = bfd_get_linker_section (dynobj, ".interp");
2027 BFD_ASSERT (s != NULL);
2028 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2029 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2030 }
2031 }
2032
2033 /* Set up .got offsets for local syms, and space for local dynamic
2034 relocs. */
2035 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2036 {
2037 bfd_signed_vma *local_got;
2038 bfd_signed_vma *end_local_got;
2039 bfd_size_type locsymcount;
2040 Elf_Internal_Shdr *symtab_hdr;
2041 asection *srel;
2042
2043 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2044 continue;
2045
2046 for (s = ibfd->sections; s != NULL; s = s->next)
2047 {
2048 struct elf_dyn_relocs *p;
2049
2050 for (p = ((struct elf_dyn_relocs *)
2051 elf_section_data (s)->local_dynrel);
2052 p != NULL;
2053 p = p->next)
2054 {
2055 if (! bfd_is_abs_section (p->sec)
2056 && bfd_is_abs_section (p->sec->output_section))
2057 {
2058 /* Input section has been discarded, either because
2059 it is a copy of a linkonce section or due to
2060 linker script /DISCARD/, so we'll be discarding
2061 the relocs too. */
2062 }
2063 else if (p->count != 0)
2064 {
2065 srel = elf_section_data (p->sec)->sreloc;
2066 srel->size += p->count * sizeof (Elf32_External_Rela);
2067 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2068 info->flags |= DF_TEXTREL;
2069 }
2070 }
2071 }
2072
2073 local_got = elf_local_got_refcounts (ibfd);
2074 if (!local_got)
2075 continue;
2076
2077 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2078 locsymcount = symtab_hdr->sh_info;
2079 end_local_got = local_got + locsymcount;
2080 s = htab->root.sgot;
2081 srel = htab->root.srelgot;
2082 for (; local_got < end_local_got; ++local_got)
2083 {
2084 if (*local_got > 0)
2085 {
2086 *local_got = s->size;
2087 s->size += 4;
2088 if (bfd_link_pic (info))
2089 srel->size += sizeof (Elf32_External_Rela);
2090 }
2091 else
2092 *local_got = (bfd_vma) -1;
2093 }
2094 }
2095
2096 /* Allocate global sym .plt and .got entries, and space for global
2097 sym dynamic relocs. */
2098 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2099
2100 /* We now have determined the sizes of the various dynamic sections.
2101 Allocate memory for them. */
2102 relocs = FALSE;
2103 for (s = dynobj->sections; s != NULL; s = s->next)
2104 {
2105 if ((s->flags & SEC_LINKER_CREATED) == 0)
2106 continue;
2107
2108 if (s == htab->root.splt
2109 || s == htab->root.sgot
2110 || s == htab->root.sgotplt
2111 || s == htab->sdynbss)
2112 {
2113 /* Strip this section if we don't need it; see the
2114 comment below. */
2115 }
2116 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2117 {
2118 if (s->size != 0 && s != htab->root.srelplt)
2119 relocs = TRUE;
2120
2121 /* We use the reloc_count field as a counter if we need
2122 to copy relocs into the output file. */
2123 s->reloc_count = 0;
2124 }
2125 else
2126 /* It's not one of our sections, so don't allocate space. */
2127 continue;
2128
2129 if (s->size == 0)
2130 {
2131 /* If we don't need this section, strip it from the
2132 output file. This is mostly to handle .rela.bss and
2133 .rela.plt. We must create both sections in
2134 create_dynamic_sections, because they must be created
2135 before the linker maps input sections to output
2136 sections. The linker does that before
2137 adjust_dynamic_symbol is called, and it is that
2138 function which decides whether anything needs to go
2139 into these sections. */
2140 s->flags |= SEC_EXCLUDE;
2141 continue;
2142 }
2143
2144 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2145 continue;
2146
2147 /* Allocate memory for the section contents. We use bfd_zalloc
2148 here in case unused entries are not reclaimed before the
2149 section's contents are written out. This should not happen,
2150 but this way if it does, we get a R_LM32_NONE reloc instead
2151 of garbage. */
2152 s->contents = bfd_zalloc (dynobj, s->size);
2153 if (s->contents == NULL)
2154 return FALSE;
2155 }
2156
2157 if (htab->root.dynamic_sections_created)
2158 {
2159 /* Add some entries to the .dynamic section. We fill in the
2160 values later, in lm32_elf_finish_dynamic_sections, but we
2161 must add the entries now so that we get the correct size for
2162 the .dynamic section. The DT_DEBUG entry is filled in by the
2163 dynamic linker and used by the debugger. */
2164 #define add_dynamic_entry(TAG, VAL) \
2165 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2166
2167 if (bfd_link_executable (info))
2168 {
2169 if (! add_dynamic_entry (DT_DEBUG, 0))
2170 return FALSE;
2171 }
2172
2173 if (htab->root.splt->size != 0)
2174 {
2175 if (! add_dynamic_entry (DT_PLTGOT, 0)
2176 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2177 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2178 || ! add_dynamic_entry (DT_JMPREL, 0))
2179 return FALSE;
2180 }
2181
2182 if (relocs)
2183 {
2184 if (! add_dynamic_entry (DT_RELA, 0)
2185 || ! add_dynamic_entry (DT_RELASZ, 0)
2186 || ! add_dynamic_entry (DT_RELAENT,
2187 sizeof (Elf32_External_Rela)))
2188 return FALSE;
2189
2190 /* If any dynamic relocs apply to a read-only section,
2191 then we need a DT_TEXTREL entry. */
2192 if ((info->flags & DF_TEXTREL) == 0)
2193 elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2194
2195 if ((info->flags & DF_TEXTREL) != 0)
2196 {
2197 if (! add_dynamic_entry (DT_TEXTREL, 0))
2198 return FALSE;
2199 }
2200 }
2201 }
2202 #undef add_dynamic_entry
2203
2204 /* Allocate .rofixup section. */
2205 if (IS_FDPIC (output_bfd))
2206 {
2207 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2208 int rgot_weak_count = 0;
2209 int r32_count = 0;
2210 int rgot_count = 0;
2211 /* Look for deleted sections. */
2212 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2213 {
2214 for (s = ibfd->sections; s != NULL; s = s->next)
2215 {
2216 if (s->reloc_count)
2217 {
2218 /* Count relocs that need .rofixup entires. */
2219 Elf_Internal_Rela *internal_relocs, *end;
2220 internal_relocs = elf_section_data (s)->relocs;
2221 if (internal_relocs == NULL)
2222 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2223 if (internal_relocs != NULL)
2224 {
2225 end = internal_relocs + s->reloc_count;
2226 while (internal_relocs < end)
2227 {
2228 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2229 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2230 unsigned long r_symndx;
2231 struct elf_link_hash_entry *h;
2232
2233 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2234 sym_hashes = elf_sym_hashes (ibfd);
2235 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2236 h = NULL;
2237 if (r_symndx < symtab_hdr->sh_info)
2238 {
2239 }
2240 else
2241 {
2242 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2243 while (h->root.type == bfd_link_hash_indirect
2244 || h->root.type == bfd_link_hash_warning)
2245 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2246 }
2247
2248 /* Don't generate entries for weak symbols. */
2249 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2250 {
2251 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2252 {
2253 switch (ELF32_R_TYPE (internal_relocs->r_info))
2254 {
2255 case R_LM32_32:
2256 r32_count++;
2257 break;
2258 case R_LM32_16_GOT:
2259 rgot_count++;
2260 break;
2261 }
2262 }
2263 }
2264 else
2265 {
2266 struct weak_symbol_list *current, *new_entry;
2267 /* Is this symbol already in the list? */
2268 for (current = list_start; current; current = current->next)
2269 {
2270 if (!strcmp (current->name, h->root.root.string))
2271 break;
2272 }
2273 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2274 {
2275 /* Will this have an entry in the GOT. */
2276 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2277 {
2278 /* Create a new entry. */
2279 new_entry = malloc (sizeof (struct weak_symbol_list));
2280 if (!new_entry)
2281 return FALSE;
2282 new_entry->name = h->root.root.string;
2283 new_entry->next = NULL;
2284 /* Add to list */
2285 if (list_start == NULL)
2286 {
2287 list_start = new_entry;
2288 list_end = new_entry;
2289 }
2290 else
2291 {
2292 list_end->next = new_entry;
2293 list_end = new_entry;
2294 }
2295 /* Increase count of undefined weak symbols in the got. */
2296 rgot_weak_count++;
2297 }
2298 }
2299 }
2300 internal_relocs++;
2301 }
2302 }
2303 else
2304 return FALSE;
2305 }
2306 }
2307 }
2308 /* Free list. */
2309 while (list_start)
2310 {
2311 list_end = list_start->next;
2312 free (list_start);
2313 list_start = list_end;
2314 }
2315
2316 /* Size sections. */
2317 lm32fdpic_fixup32_section (info)->size
2318 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2319 if (lm32fdpic_fixup32_section (info)->size == 0)
2320 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2321 else
2322 {
2323 lm32fdpic_fixup32_section (info)->contents =
2324 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2325 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2326 return FALSE;
2327 }
2328 }
2329
2330 return TRUE;
2331 }
2332
2333 /* Create dynamic sections when linking against a dynamic object. */
2334
2335 static bfd_boolean
2336 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2337 {
2338 struct elf_lm32_link_hash_table *htab;
2339 flagword flags, pltflags;
2340 asection *s;
2341 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2342 int ptralign = 2; /* 32bit */
2343
2344 htab = lm32_elf_hash_table (info);
2345 if (htab == NULL)
2346 return FALSE;
2347
2348 /* Make sure we have a GOT - For the case where we have a dynamic object
2349 but none of the relocs in check_relocs */
2350 if (!_bfd_elf_create_got_section (abfd, info))
2351 return FALSE;
2352 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2353 {
2354 if (! create_rofixup_section (abfd, info))
2355 return FALSE;
2356 }
2357
2358 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2359 .rel[a].bss sections. */
2360 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2361 | SEC_LINKER_CREATED);
2362
2363 pltflags = flags;
2364 pltflags |= SEC_CODE;
2365 if (bed->plt_not_loaded)
2366 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2367 if (bed->plt_readonly)
2368 pltflags |= SEC_READONLY;
2369
2370 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2371 htab->root.splt = s;
2372 if (s == NULL
2373 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2374 return FALSE;
2375
2376 if (bed->want_plt_sym)
2377 {
2378 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2379 .plt section. */
2380 struct bfd_link_hash_entry *bh = NULL;
2381 struct elf_link_hash_entry *h;
2382
2383 if (! (_bfd_generic_link_add_one_symbol
2384 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2385 (bfd_vma) 0, NULL, FALSE,
2386 get_elf_backend_data (abfd)->collect, &bh)))
2387 return FALSE;
2388 h = (struct elf_link_hash_entry *) bh;
2389 h->def_regular = 1;
2390 h->type = STT_OBJECT;
2391 htab->root.hplt = h;
2392
2393 if (bfd_link_pic (info)
2394 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2395 return FALSE;
2396 }
2397
2398 s = bfd_make_section_anyway_with_flags (abfd,
2399 bed->default_use_rela_p
2400 ? ".rela.plt" : ".rel.plt",
2401 flags | SEC_READONLY);
2402 htab->root.srelplt = s;
2403 if (s == NULL
2404 || ! bfd_set_section_alignment (abfd, s, ptralign))
2405 return FALSE;
2406
2407 if (htab->root.sgot == NULL
2408 && !_bfd_elf_create_got_section (abfd, info))
2409 return FALSE;
2410
2411 if (bed->want_dynbss)
2412 {
2413 /* The .dynbss section is a place to put symbols which are defined
2414 by dynamic objects, are referenced by regular objects, and are
2415 not functions. We must allocate space for them in the process
2416 image and use a R_*_COPY reloc to tell the dynamic linker to
2417 initialize them at run time. The linker script puts the .dynbss
2418 section into the .bss section of the final image. */
2419 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2420 SEC_ALLOC | SEC_LINKER_CREATED);
2421 htab->sdynbss = s;
2422 if (s == NULL)
2423 return FALSE;
2424 /* The .rel[a].bss section holds copy relocs. This section is not
2425 normally needed. We need to create it here, though, so that the
2426 linker will map it to an output section. We can't just create it
2427 only if we need it, because we will not know whether we need it
2428 until we have seen all the input files, and the first time the
2429 main linker code calls BFD after examining all the input files
2430 (size_dynamic_sections) the input sections have already been
2431 mapped to the output sections. If the section turns out not to
2432 be needed, we can discard it later. We will never need this
2433 section when generating a shared object, since they do not use
2434 copy relocs. */
2435 if (! bfd_link_pic (info))
2436 {
2437 s = bfd_make_section_anyway_with_flags (abfd,
2438 (bed->default_use_rela_p
2439 ? ".rela.bss" : ".rel.bss"),
2440 flags | SEC_READONLY);
2441 htab->srelbss = s;
2442 if (s == NULL
2443 || ! bfd_set_section_alignment (abfd, s, ptralign))
2444 return FALSE;
2445 }
2446 }
2447
2448 return TRUE;
2449 }
2450
2451 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2452
2453 static void
2454 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2455 struct elf_link_hash_entry *dir,
2456 struct elf_link_hash_entry *ind)
2457 {
2458 struct elf_lm32_link_hash_entry * edir;
2459 struct elf_lm32_link_hash_entry * eind;
2460
2461 edir = (struct elf_lm32_link_hash_entry *) dir;
2462 eind = (struct elf_lm32_link_hash_entry *) ind;
2463
2464 if (eind->dyn_relocs != NULL)
2465 {
2466 if (edir->dyn_relocs != NULL)
2467 {
2468 struct elf_dyn_relocs **pp;
2469 struct elf_dyn_relocs *p;
2470
2471 /* Add reloc counts against the indirect sym to the direct sym
2472 list. Merge any entries against the same section. */
2473 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2474 {
2475 struct elf_dyn_relocs *q;
2476
2477 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2478 if (q->sec == p->sec)
2479 {
2480 q->pc_count += p->pc_count;
2481 q->count += p->count;
2482 *pp = p->next;
2483 break;
2484 }
2485 if (q == NULL)
2486 pp = &p->next;
2487 }
2488 *pp = edir->dyn_relocs;
2489 }
2490
2491 edir->dyn_relocs = eind->dyn_relocs;
2492 eind->dyn_relocs = NULL;
2493 }
2494
2495 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2496 }
2497
2498 static bfd_boolean
2499 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2500 {
2501 if (!bfd_link_relocatable (info))
2502 {
2503 if (!bfd_elf_stack_segment_size (output_bfd, info,
2504 "__stacksize", DEFAULT_STACK_SIZE))
2505 return FALSE;
2506
2507 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2508 if (sec)
2509 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2510 }
2511
2512 return TRUE;
2513 }
2514
2515 static bfd_boolean
2516 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2517 {
2518 unsigned i;
2519
2520 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2521 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2522 return TRUE;
2523
2524 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2525 return FALSE;
2526
2527 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2528 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2529 return TRUE;
2530
2531 /* Copy the stack size. */
2532 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2533 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2534 {
2535 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2536
2537 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2538 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2539 {
2540 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2541
2542 /* Rewrite the phdrs, since we're only called after they were first written. */
2543 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2544 ->s->sizeof_ehdr, SEEK_SET) != 0
2545 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2546 elf_elfheader (obfd)->e_phnum) != 0)
2547 return FALSE;
2548 break;
2549 }
2550
2551 break;
2552 }
2553
2554 return TRUE;
2555 }
2556
2557
2558 #define ELF_ARCH bfd_arch_lm32
2559 #define ELF_TARGET_ID LM32_ELF_DATA
2560 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2561 #define ELF_MAXPAGESIZE 0x1000
2562
2563 #define TARGET_BIG_SYM lm32_elf32_vec
2564 #define TARGET_BIG_NAME "elf32-lm32"
2565
2566 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2567 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2568 #define elf_info_to_howto lm32_info_to_howto_rela
2569 #define elf_info_to_howto_rel 0
2570 #define elf_backend_rela_normal 1
2571 #define elf_backend_object_p lm32_elf_object_p
2572 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2573 #define elf_backend_stack_align 8
2574 #define elf_backend_can_gc_sections 1
2575 #define elf_backend_can_refcount 1
2576 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2577 #define elf_backend_plt_readonly 1
2578 #define elf_backend_want_got_plt 1
2579 #define elf_backend_want_plt_sym 0
2580 #define elf_backend_got_header_size 12
2581 #define elf_backend_dtrel_excludes_plt 1
2582 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2583 #define elf_backend_check_relocs lm32_elf_check_relocs
2584 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2585 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2586 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2587 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2588 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2589 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2590 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2591 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2592 #define elf_backend_relocate_section lm32_elf_relocate_section
2593
2594 #include "elf32-target.h"
2595
2596 #undef ELF_MAXPAGESIZE
2597 #define ELF_MAXPAGESIZE 0x4000
2598
2599
2600 #undef TARGET_BIG_SYM
2601 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2602 #undef TARGET_BIG_NAME
2603 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2604 #undef elf32_bed
2605 #define elf32_bed elf32_lm32fdpic_bed
2606
2607 #undef elf_backend_always_size_sections
2608 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2609 #undef bfd_elf32_bfd_copy_private_bfd_data
2610 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2611
2612 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.101645 seconds and 5 git commands to generate.