projects / deliverable / binutils-gdb.git / blob
? search:


0cd67b4947c73fb36056492155675097a72440fc
[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
1000 (_("internal error: addend should be zero for %s"),
1001 "R_LM32_16_GOT");
1002
1003 r = _bfd_final_link_relocate (howto,
1004 input_bfd,
1005 input_section,
1006 contents,
1007 rel->r_offset,
1008 relocation,
1009 rel->r_addend);
1010 break;
1011
1012 case R_LM32_GOTOFF_LO16:
1013 case R_LM32_GOTOFF_HI16:
1014 /* Relocation is offset from GOT. */
1015 BFD_ASSERT (sgot != NULL);
1016 relocation -= sgot->output_section->vma;
1017 /* Account for sign-extension. */
1018 if ((r_type == R_LM32_GOTOFF_HI16)
1019 && ((relocation + rel->r_addend) & 0x8000))
1020 rel->r_addend += 0x10000;
1021 r = _bfd_final_link_relocate (howto,
1022 input_bfd,
1023 input_section,
1024 contents,
1025 rel->r_offset,
1026 relocation,
1027 rel->r_addend);
1028 break;
1029
1030 case R_LM32_32:
1031 if (IS_FDPIC (output_bfd))
1032 {
1033 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1034 {
1035 /* Only create .rofixup entries for relocs in loadable sections. */
1036 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1037 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1038
1039 {
1040 /* Check address to be modified is writable. */
1041 if (_lm32fdpic_osec_readonly_p (output_bfd,
1042 input_section
1043 ->output_section))
1044 {
1045 info->callbacks->warning
1046 (info,
1047 _("cannot emit dynamic relocations in read-only section"),
1048 name, input_bfd, input_section, rel->r_offset);
1049 return FALSE;
1050 }
1051 /* Create entry in .rofixup section. */
1052 _lm32fdpic_add_rofixup (output_bfd,
1053 lm32fdpic_fixup32_section (info),
1054 input_section->output_section->vma
1055 + input_section->output_offset
1056 + rel->r_offset);
1057 }
1058 }
1059 }
1060 /* Fall through. */
1061
1062 default:
1063 r = _bfd_final_link_relocate (howto,
1064 input_bfd,
1065 input_section,
1066 contents,
1067 rel->r_offset,
1068 relocation,
1069 rel->r_addend);
1070 break;
1071 }
1072 }
1073
1074 if (r != bfd_reloc_ok)
1075 {
1076 const char *msg = NULL;
1077 arelent bfd_reloc;
1078
1079 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1080 howto = bfd_reloc.howto;
1081
1082 if (h != NULL)
1083 name = h->root.root.string;
1084 else
1085 {
1086 name = (bfd_elf_string_from_elf_section
1087 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1088 if (name == NULL || *name == '\0')
1089 name = bfd_section_name (input_bfd, sec);
1090 }
1091
1092 switch (r)
1093 {
1094 case bfd_reloc_overflow:
1095 if ((h != NULL)
1096 && (h->root.type == bfd_link_hash_undefweak))
1097 break;
1098 (*info->callbacks->reloc_overflow)
1099 (info, (h ? &h->root : NULL), name, howto->name,
1100 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1101 break;
1102
1103 case bfd_reloc_undefined:
1104 (*info->callbacks->undefined_symbol)
1105 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1106 break;
1107
1108 case bfd_reloc_outofrange:
1109 msg = _("internal error: out of range error");
1110 goto common_error;
1111
1112 case bfd_reloc_notsupported:
1113 msg = _("internal error: unsupported relocation error");
1114 goto common_error;
1115
1116 case bfd_reloc_dangerous:
1117 msg = _("internal error: dangerous error");
1118 goto common_error;
1119
1120 default:
1121 msg = _("internal error: unknown error");
1122 /* fall through */
1123
1124 common_error:
1125 (*info->callbacks->warning) (info, msg, name, input_bfd,
1126 input_section, rel->r_offset);
1127 break;
1128 }
1129 }
1130 }
1131
1132 return TRUE;
1133 }
1134
1135 static asection *
1136 lm32_elf_gc_mark_hook (asection *sec,
1137 struct bfd_link_info *info,
1138 Elf_Internal_Rela *rel,
1139 struct elf_link_hash_entry *h,
1140 Elf_Internal_Sym *sym)
1141 {
1142 if (h != NULL)
1143 switch (ELF32_R_TYPE (rel->r_info))
1144 {
1145 case R_LM32_GNU_VTINHERIT:
1146 case R_LM32_GNU_VTENTRY:
1147 return NULL;
1148 }
1149
1150 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1151 }
1152
1153 /* Look through the relocs for a section during the first phase. */
1154
1155 static bfd_boolean
1156 lm32_elf_check_relocs (bfd *abfd,
1157 struct bfd_link_info *info,
1158 asection *sec,
1159 const Elf_Internal_Rela *relocs)
1160 {
1161 Elf_Internal_Shdr *symtab_hdr;
1162 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1163 const Elf_Internal_Rela *rel;
1164 const Elf_Internal_Rela *rel_end;
1165 struct elf_lm32_link_hash_table *htab;
1166 bfd *dynobj;
1167
1168 if (bfd_link_relocatable (info))
1169 return TRUE;
1170
1171 /* Don't do anything special with non-loaded, non-alloced sections.
1172 In particular, any relocs in such sections should not affect GOT
1173 and PLT reference counting (ie. we don't allow them to create GOT
1174 or PLT entries), there's no possibility or desire to optimize TLS
1175 relocs, and there's not much point in propagating relocs to shared
1176 libs that the dynamic linker won't relocate. */
1177 if ((sec->flags & SEC_ALLOC) == 0)
1178 return TRUE;
1179
1180 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1181 sym_hashes = elf_sym_hashes (abfd);
1182 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1183 if (!elf_bad_symtab (abfd))
1184 sym_hashes_end -= symtab_hdr->sh_info;
1185
1186 htab = lm32_elf_hash_table (info);
1187 if (htab == NULL)
1188 return FALSE;
1189
1190 dynobj = htab->root.dynobj;
1191
1192 rel_end = relocs + sec->reloc_count;
1193 for (rel = relocs; rel < rel_end; rel++)
1194 {
1195 int r_type;
1196 struct elf_link_hash_entry *h;
1197 unsigned long r_symndx;
1198
1199 r_symndx = ELF32_R_SYM (rel->r_info);
1200 r_type = ELF32_R_TYPE (rel->r_info);
1201 if (r_symndx < symtab_hdr->sh_info)
1202 h = NULL;
1203 else
1204 {
1205 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1206 while (h->root.type == bfd_link_hash_indirect
1207 || h->root.type == bfd_link_hash_warning)
1208 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1209 }
1210
1211 /* Some relocs require a global offset table. */
1212 if (htab->root.sgot == NULL)
1213 {
1214 switch (r_type)
1215 {
1216 case R_LM32_16_GOT:
1217 case R_LM32_GOTOFF_HI16:
1218 case R_LM32_GOTOFF_LO16:
1219 if (dynobj == NULL)
1220 htab->root.dynobj = dynobj = abfd;
1221 if (!_bfd_elf_create_got_section (dynobj, info))
1222 return FALSE;
1223 break;
1224 }
1225 }
1226
1227 /* Some relocs require a rofixup table. */
1228 if (IS_FDPIC (abfd))
1229 {
1230 switch (r_type)
1231 {
1232 case R_LM32_32:
1233 /* FDPIC requires a GOT if there is a .rofixup section
1234 (Normal ELF doesn't). */
1235 if (dynobj == NULL)
1236 htab->root.dynobj = dynobj = abfd;
1237 if (!_bfd_elf_create_got_section (dynobj, info))
1238 return FALSE;
1239 /* Create .rofixup section */
1240 if (htab->sfixup32 == NULL)
1241 {
1242 if (! create_rofixup_section (dynobj, info))
1243 return FALSE;
1244 }
1245 break;
1246 case R_LM32_16_GOT:
1247 case R_LM32_GOTOFF_HI16:
1248 case R_LM32_GOTOFF_LO16:
1249 /* Create .rofixup section. */
1250 if (htab->sfixup32 == NULL)
1251 {
1252 if (dynobj == NULL)
1253 htab->root.dynobj = dynobj = abfd;
1254 if (! create_rofixup_section (dynobj, info))
1255 return FALSE;
1256 }
1257 break;
1258 }
1259 }
1260
1261 switch (r_type)
1262 {
1263 case R_LM32_16_GOT:
1264 if (h != NULL)
1265 h->got.refcount += 1;
1266 else
1267 {
1268 bfd_signed_vma *local_got_refcounts;
1269
1270 /* This is a global offset table entry for a local symbol. */
1271 local_got_refcounts = elf_local_got_refcounts (abfd);
1272 if (local_got_refcounts == NULL)
1273 {
1274 bfd_size_type size;
1275
1276 size = symtab_hdr->sh_info;
1277 size *= sizeof (bfd_signed_vma);
1278 local_got_refcounts = bfd_zalloc (abfd, size);
1279 if (local_got_refcounts == NULL)
1280 return FALSE;
1281 elf_local_got_refcounts (abfd) = local_got_refcounts;
1282 }
1283 local_got_refcounts[r_symndx] += 1;
1284 }
1285 break;
1286
1287 /* This relocation describes the C++ object vtable hierarchy.
1288 Reconstruct it for later use during GC. */
1289 case R_LM32_GNU_VTINHERIT:
1290 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1291 return FALSE;
1292 break;
1293
1294 /* This relocation describes which C++ vtable entries are actually
1295 used. Record for later use during GC. */
1296 case R_LM32_GNU_VTENTRY:
1297 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1298 return FALSE;
1299 break;
1300
1301 }
1302 }
1303
1304 return TRUE;
1305 }
1306
1307 /* Finish up the dynamic sections. */
1308
1309 static bfd_boolean
1310 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1311 struct bfd_link_info *info)
1312 {
1313 struct elf_lm32_link_hash_table *htab;
1314 bfd *dynobj;
1315 asection *sdyn;
1316 asection *sgot;
1317
1318 htab = lm32_elf_hash_table (info);
1319 if (htab == NULL)
1320 return FALSE;
1321
1322 dynobj = htab->root.dynobj;
1323
1324 sgot = htab->root.sgotplt;
1325 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1326
1327 if (htab->root.dynamic_sections_created)
1328 {
1329 asection *splt;
1330 Elf32_External_Dyn *dyncon, *dynconend;
1331
1332 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1333
1334 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1335 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1336
1337 for (; dyncon < dynconend; dyncon++)
1338 {
1339 Elf_Internal_Dyn dyn;
1340 asection *s;
1341
1342 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1343
1344 switch (dyn.d_tag)
1345 {
1346 default:
1347 break;
1348
1349 case DT_PLTGOT:
1350 s = htab->root.sgotplt;
1351 goto get_vma;
1352 case DT_JMPREL:
1353 s = htab->root.srelplt;
1354 get_vma:
1355 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1356 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1357 break;
1358
1359 case DT_PLTRELSZ:
1360 s = htab->root.srelplt;
1361 dyn.d_un.d_val = s->size;
1362 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1363 break;
1364 }
1365 }
1366
1367 /* Fill in the first entry in the procedure linkage table. */
1368 splt = htab->root.splt;
1369 if (splt && splt->size > 0)
1370 {
1371 if (bfd_link_pic (info))
1372 {
1373 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1374 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1375 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1376 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1377 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1378 }
1379 else
1380 {
1381 unsigned long addr;
1382 /* addr = .got + 4 */
1383 addr = sgot->output_section->vma + sgot->output_offset + 4;
1384 bfd_put_32 (output_bfd,
1385 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1386 splt->contents);
1387 bfd_put_32 (output_bfd,
1388 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1389 splt->contents + 4);
1390 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1391 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1392 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1393 }
1394
1395 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1396 PLT_ENTRY_SIZE;
1397 }
1398 }
1399
1400 /* Fill in the first three entries in the global offset table. */
1401 if (sgot && sgot->size > 0)
1402 {
1403 if (sdyn == NULL)
1404 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1405 else
1406 bfd_put_32 (output_bfd,
1407 sdyn->output_section->vma + sdyn->output_offset,
1408 sgot->contents);
1409 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1410 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1411
1412 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1413 if (elf_section_data (sgot->output_section) != NULL)
1414 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1415 }
1416
1417 if (lm32fdpic_fixup32_section (info))
1418 {
1419 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1420 bfd_vma got_value = hgot->root.u.def.value
1421 + hgot->root.u.def.section->output_section->vma
1422 + hgot->root.u.def.section->output_offset;
1423 struct bfd_link_hash_entry *hend;
1424
1425 /* Last entry is pointer to GOT. */
1426 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1427
1428 /* Check we wrote enough entries. */
1429 if (lm32fdpic_fixup32_section (info)->size
1430 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1431 {
1432 _bfd_error_handler
1433 ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1434 " != relocs %d",
1435 (int64_t) (lm32fdpic_fixup32_section (info)->size / 4),
1436 lm32fdpic_fixup32_section (info)->reloc_count);
1437 return FALSE;
1438 }
1439
1440 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1441 FALSE, FALSE, TRUE);
1442 if (hend
1443 && (hend->type == bfd_link_hash_defined
1444 || hend->type == bfd_link_hash_defweak))
1445 {
1446 bfd_vma value =
1447 lm32fdpic_fixup32_section (info)->output_section->vma
1448 + lm32fdpic_fixup32_section (info)->output_offset
1449 + lm32fdpic_fixup32_section (info)->size
1450 - hend->u.def.section->output_section->vma
1451 - hend->u.def.section->output_offset;
1452 BFD_ASSERT (hend->u.def.value == value);
1453 if (hend->u.def.value != value)
1454 {
1455 _bfd_error_handler
1456 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1457 PRId64 " != %" PRId64,
1458 (int64_t) hend->u.def.value, (int64_t) value);
1459 return FALSE;
1460 }
1461 }
1462 }
1463
1464 return TRUE;
1465 }
1466
1467 /* Finish up dynamic symbol handling. We set the contents of various
1468 dynamic sections here. */
1469
1470 static bfd_boolean
1471 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1472 struct bfd_link_info *info,
1473 struct elf_link_hash_entry *h,
1474 Elf_Internal_Sym *sym)
1475 {
1476 struct elf_lm32_link_hash_table *htab;
1477 bfd_byte *loc;
1478
1479 htab = lm32_elf_hash_table (info);
1480 if (htab == NULL)
1481 return FALSE;
1482
1483 if (h->plt.offset != (bfd_vma) -1)
1484 {
1485 asection *splt;
1486 asection *sgot;
1487 asection *srela;
1488
1489 bfd_vma plt_index;
1490 bfd_vma got_offset;
1491 Elf_Internal_Rela rela;
1492
1493 /* This symbol has an entry in the procedure linkage table. Set
1494 it up. */
1495 BFD_ASSERT (h->dynindx != -1);
1496
1497 splt = htab->root.splt;
1498 sgot = htab->root.sgotplt;
1499 srela = htab->root.srelplt;
1500 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1501
1502 /* Get the index in the procedure linkage table which
1503 corresponds to this symbol. This is the index of this symbol
1504 in all the symbols for which we are making plt entries. The
1505 first entry in the procedure linkage table is reserved. */
1506 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1507
1508 /* Get the offset into the .got table of the entry that
1509 corresponds to this function. Each .got entry is 4 bytes.
1510 The first three are reserved. */
1511 got_offset = (plt_index + 3) * 4;
1512
1513 /* Fill in the entry in the procedure linkage table. */
1514 if (! bfd_link_pic (info))
1515 {
1516 /* TODO */
1517 }
1518 else
1519 {
1520 /* TODO */
1521 }
1522
1523 /* Fill in the entry in the global offset table. */
1524 bfd_put_32 (output_bfd,
1525 (splt->output_section->vma
1526 + splt->output_offset
1527 + h->plt.offset
1528 + 12), /* same offset */
1529 sgot->contents + got_offset);
1530
1531 /* Fill in the entry in the .rela.plt section. */
1532 rela.r_offset = (sgot->output_section->vma
1533 + sgot->output_offset
1534 + got_offset);
1535 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1536 rela.r_addend = 0;
1537 loc = srela->contents;
1538 loc += plt_index * sizeof (Elf32_External_Rela);
1539 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1540
1541 if (!h->def_regular)
1542 {
1543 /* Mark the symbol as undefined, rather than as defined in
1544 the .plt section. Leave the value alone. */
1545 sym->st_shndx = SHN_UNDEF;
1546 }
1547
1548 }
1549
1550 if (h->got.offset != (bfd_vma) -1)
1551 {
1552 asection *sgot;
1553 asection *srela;
1554 Elf_Internal_Rela rela;
1555
1556 /* This symbol has an entry in the global offset table. Set it
1557 up. */
1558 sgot = htab->root.sgot;
1559 srela = htab->root.srelgot;
1560 BFD_ASSERT (sgot != NULL && srela != NULL);
1561
1562 rela.r_offset = (sgot->output_section->vma
1563 + sgot->output_offset
1564 + (h->got.offset &~ 1));
1565
1566 /* If this is a -Bsymbolic link, and the symbol is defined
1567 locally, we just want to emit a RELATIVE reloc. Likewise if
1568 the symbol was forced to be local because of a version file.
1569 The entry in the global offset table will already have been
1570 initialized in the relocate_section function. */
1571 if (bfd_link_pic (info)
1572 && (info->symbolic
1573 || h->dynindx == -1
1574 || h->forced_local)
1575 && h->def_regular)
1576 {
1577 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1578 rela.r_addend = (h->root.u.def.value
1579 + h->root.u.def.section->output_section->vma
1580 + h->root.u.def.section->output_offset);
1581 }
1582 else
1583 {
1584 BFD_ASSERT ((h->got.offset & 1) == 0);
1585 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1586 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1587 rela.r_addend = 0;
1588 }
1589
1590 loc = srela->contents;
1591 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1592 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1593 ++srela->reloc_count;
1594 }
1595
1596 if (h->needs_copy)
1597 {
1598 asection *s;
1599 Elf_Internal_Rela rela;
1600
1601 /* This symbols needs a copy reloc. Set it up. */
1602 BFD_ASSERT (h->dynindx != -1
1603 && (h->root.type == bfd_link_hash_defined
1604 || h->root.type == bfd_link_hash_defweak));
1605
1606 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1607 BFD_ASSERT (s != NULL);
1608
1609 rela.r_offset = (h->root.u.def.value
1610 + h->root.u.def.section->output_section->vma
1611 + h->root.u.def.section->output_offset);
1612 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1613 rela.r_addend = 0;
1614 loc = s->contents;
1615 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1616 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1617 ++s->reloc_count;
1618 }
1619
1620 /* Mark some specially defined symbols as absolute. */
1621 if (h == htab->root.hdynamic || h == htab->root.hgot)
1622 sym->st_shndx = SHN_ABS;
1623
1624 return TRUE;
1625 }
1626
1627 static enum elf_reloc_type_class
1628 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1629 const asection *rel_sec ATTRIBUTE_UNUSED,
1630 const Elf_Internal_Rela *rela)
1631 {
1632 switch ((int) ELF32_R_TYPE (rela->r_info))
1633 {
1634 case R_LM32_RELATIVE: return reloc_class_relative;
1635 case R_LM32_JMP_SLOT: return reloc_class_plt;
1636 case R_LM32_COPY: return reloc_class_copy;
1637 default: return reloc_class_normal;
1638 }
1639 }
1640
1641 /* Find dynamic relocs for H that apply to read-only sections. */
1642
1643 static asection *
1644 readonly_dynrelocs (struct elf_link_hash_entry *h)
1645 {
1646 struct elf_dyn_relocs *p;
1647 struct elf_lm32_link_hash_entry *eh = (struct elf_lm32_link_hash_entry *) h;
1648
1649 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1650 {
1651 asection *s = p->sec->output_section;
1652
1653 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1654 return p->sec;
1655 }
1656 return NULL;
1657 }
1658
1659 /* Adjust a symbol defined by a dynamic object and referenced by a
1660 regular object. The current definition is in some section of the
1661 dynamic object, but we're not including those sections. We have to
1662 change the definition to something the rest of the link can
1663 understand. */
1664
1665 static bfd_boolean
1666 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1667 struct elf_link_hash_entry *h)
1668 {
1669 struct elf_lm32_link_hash_table *htab;
1670 bfd *dynobj;
1671 asection *s;
1672
1673 dynobj = elf_hash_table (info)->dynobj;
1674
1675 /* Make sure we know what is going on here. */
1676 BFD_ASSERT (dynobj != NULL
1677 && (h->needs_plt
1678 || h->is_weakalias
1679 || (h->def_dynamic
1680 && h->ref_regular
1681 && !h->def_regular)));
1682
1683 /* If this is a function, put it in the procedure linkage table. We
1684 will fill in the contents of the procedure linkage table later,
1685 when we know the address of the .got section. */
1686 if (h->type == STT_FUNC
1687 || h->needs_plt)
1688 {
1689 if (! bfd_link_pic (info)
1690 && !h->def_dynamic
1691 && !h->ref_dynamic
1692 && h->root.type != bfd_link_hash_undefweak
1693 && h->root.type != bfd_link_hash_undefined)
1694 {
1695 /* This case can occur if we saw a PLT reloc in an input
1696 file, but the symbol was never referred to by a dynamic
1697 object. In such a case, we don't actually need to build
1698 a procedure linkage table, and we can just do a PCREL
1699 reloc instead. */
1700 h->plt.offset = (bfd_vma) -1;
1701 h->needs_plt = 0;
1702 }
1703
1704 return TRUE;
1705 }
1706 else
1707 h->plt.offset = (bfd_vma) -1;
1708
1709 /* If this is a weak symbol, and there is a real definition, the
1710 processor independent code will have arranged for us to see the
1711 real definition first, and we can just use the same value. */
1712 if (h->is_weakalias)
1713 {
1714 struct elf_link_hash_entry *def = weakdef (h);
1715 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1716 h->root.u.def.section = def->root.u.def.section;
1717 h->root.u.def.value = def->root.u.def.value;
1718 return TRUE;
1719 }
1720
1721 /* This is a reference to a symbol defined by a dynamic object which
1722 is not a function. */
1723
1724 /* If we are creating a shared library, we must presume that the
1725 only references to the symbol are via the global offset table.
1726 For such cases we need not do anything here; the relocations will
1727 be handled correctly by relocate_section. */
1728 if (bfd_link_pic (info))
1729 return TRUE;
1730
1731 /* If there are no references to this symbol that do not use the
1732 GOT, we don't need to generate a copy reloc. */
1733 if (!h->non_got_ref)
1734 return TRUE;
1735
1736 /* If -z nocopyreloc was given, we won't generate them either. */
1737 if (0 && info->nocopyreloc)
1738 {
1739 h->non_got_ref = 0;
1740 return TRUE;
1741 }
1742
1743 /* If we don't find any dynamic relocs in read-only sections, then
1744 we'll be keeping the dynamic relocs and avoiding the copy reloc. */
1745 if (0 && !readonly_dynrelocs (h))
1746 {
1747 h->non_got_ref = 0;
1748 return TRUE;
1749 }
1750
1751 /* We must allocate the symbol in our .dynbss section, which will
1752 become part of the .bss section of the executable. There will be
1753 an entry for this symbol in the .dynsym section. The dynamic
1754 object will contain position independent code, so all references
1755 from the dynamic object to this symbol will go through the global
1756 offset table. The dynamic linker will use the .dynsym entry to
1757 determine the address it must put in the global offset table, so
1758 both the dynamic object and the regular object will refer to the
1759 same memory location for the variable. */
1760
1761 htab = lm32_elf_hash_table (info);
1762 if (htab == NULL)
1763 return FALSE;
1764
1765 s = htab->sdynbss;
1766 BFD_ASSERT (s != NULL);
1767
1768 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1769 to copy the initial value out of the dynamic object and into the
1770 runtime process image. We need to remember the offset into the
1771 .rela.bss section we are going to use. */
1772 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1773 {
1774 asection *srel;
1775
1776 srel = htab->srelbss;
1777 BFD_ASSERT (srel != NULL);
1778 srel->size += sizeof (Elf32_External_Rela);
1779 h->needs_copy = 1;
1780 }
1781
1782 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1783 }
1784
1785 /* Allocate space in .plt, .got and associated reloc sections for
1786 dynamic relocs. */
1787
1788 static bfd_boolean
1789 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1790 {
1791 struct bfd_link_info *info;
1792 struct elf_lm32_link_hash_table *htab;
1793 struct elf_lm32_link_hash_entry *eh;
1794 struct elf_dyn_relocs *p;
1795
1796 if (h->root.type == bfd_link_hash_indirect)
1797 return TRUE;
1798
1799 info = (struct bfd_link_info *) inf;
1800 htab = lm32_elf_hash_table (info);
1801 if (htab == NULL)
1802 return FALSE;
1803
1804 eh = (struct elf_lm32_link_hash_entry *) h;
1805
1806 if (htab->root.dynamic_sections_created
1807 && h->plt.refcount > 0)
1808 {
1809 /* Make sure this symbol is output as a dynamic symbol.
1810 Undefined weak syms won't yet be marked as dynamic. */
1811 if (h->dynindx == -1
1812 && !h->forced_local)
1813 {
1814 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1815 return FALSE;
1816 }
1817
1818 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1819 {
1820 asection *s = htab->root.splt;
1821
1822 /* If this is the first .plt entry, make room for the special
1823 first entry. */
1824 if (s->size == 0)
1825 s->size += PLT_ENTRY_SIZE;
1826
1827 h->plt.offset = s->size;
1828
1829 /* If this symbol is not defined in a regular file, and we are
1830 not generating a shared library, then set the symbol to this
1831 location in the .plt. This is required to make function
1832 pointers compare as equal between the normal executable and
1833 the shared library. */
1834 if (! bfd_link_pic (info)
1835 && !h->def_regular)
1836 {
1837 h->root.u.def.section = s;
1838 h->root.u.def.value = h->plt.offset;
1839 }
1840
1841 /* Make room for this entry. */
1842 s->size += PLT_ENTRY_SIZE;
1843
1844 /* We also need to make an entry in the .got.plt section, which
1845 will be placed in the .got section by the linker script. */
1846 htab->root.sgotplt->size += 4;
1847
1848 /* We also need to make an entry in the .rel.plt section. */
1849 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1850 }
1851 else
1852 {
1853 h->plt.offset = (bfd_vma) -1;
1854 h->needs_plt = 0;
1855 }
1856 }
1857 else
1858 {
1859 h->plt.offset = (bfd_vma) -1;
1860 h->needs_plt = 0;
1861 }
1862
1863 if (h->got.refcount > 0)
1864 {
1865 asection *s;
1866 bfd_boolean dyn;
1867
1868 /* Make sure this symbol is output as a dynamic symbol.
1869 Undefined weak syms won't yet be marked as dynamic. */
1870 if (h->dynindx == -1
1871 && !h->forced_local)
1872 {
1873 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1874 return FALSE;
1875 }
1876
1877 s = htab->root.sgot;
1878
1879 h->got.offset = s->size;
1880 s->size += 4;
1881 dyn = htab->root.dynamic_sections_created;
1882 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1883 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1884 }
1885 else
1886 h->got.offset = (bfd_vma) -1;
1887
1888 if (eh->dyn_relocs == NULL)
1889 return TRUE;
1890
1891 /* In the shared -Bsymbolic case, discard space allocated for
1892 dynamic pc-relative relocs against symbols which turn out to be
1893 defined in regular objects. For the normal shared case, discard
1894 space for pc-relative relocs that have become local due to symbol
1895 visibility changes. */
1896
1897 if (bfd_link_pic (info))
1898 {
1899 if (h->def_regular
1900 && (h->forced_local
1901 || info->symbolic))
1902 {
1903 struct elf_dyn_relocs **pp;
1904
1905 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1906 {
1907 p->count -= p->pc_count;
1908 p->pc_count = 0;
1909 if (p->count == 0)
1910 *pp = p->next;
1911 else
1912 pp = &p->next;
1913 }
1914 }
1915
1916 /* Also discard relocs on undefined weak syms with non-default
1917 visibility. */
1918 if (eh->dyn_relocs != NULL
1919 && h->root.type == bfd_link_hash_undefweak)
1920 {
1921 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1922 eh->dyn_relocs = NULL;
1923
1924 /* Make sure undefined weak symbols are output as a dynamic
1925 symbol in PIEs. */
1926 else if (h->dynindx == -1
1927 && !h->forced_local)
1928 {
1929 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1930 return FALSE;
1931 }
1932 }
1933 }
1934 else
1935 {
1936 /* For the non-shared case, discard space for relocs against
1937 symbols which turn out to need copy relocs or are not
1938 dynamic. */
1939
1940 if (!h->non_got_ref
1941 && ((h->def_dynamic
1942 && !h->def_regular)
1943 || (htab->root.dynamic_sections_created
1944 && (h->root.type == bfd_link_hash_undefweak
1945 || h->root.type == bfd_link_hash_undefined))))
1946 {
1947 /* Make sure this symbol is output as a dynamic symbol.
1948 Undefined weak syms won't yet be marked as dynamic. */
1949 if (h->dynindx == -1
1950 && !h->forced_local)
1951 {
1952 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1953 return FALSE;
1954 }
1955
1956 /* If that succeeded, we know we'll be keeping all the
1957 relocs. */
1958 if (h->dynindx != -1)
1959 goto keep;
1960 }
1961
1962 eh->dyn_relocs = NULL;
1963
1964 keep: ;
1965 }
1966
1967 /* Finally, allocate space. */
1968 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1969 {
1970 asection *sreloc = elf_section_data (p->sec)->sreloc;
1971 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1972 }
1973
1974 return TRUE;
1975 }
1976
1977 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1978 read-only sections. */
1979
1980 static bfd_boolean
1981 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1982 {
1983 asection *sec;
1984
1985 if (h->root.type == bfd_link_hash_indirect)
1986 return TRUE;
1987
1988 sec = readonly_dynrelocs (h);
1989 if (sec != NULL)
1990 {
1991 struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1992
1993 info->flags |= DF_TEXTREL;
1994 info->callbacks->minfo
1995 (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1996 sec->owner, h->root.root.string, sec);
1997
1998 /* Not an error, just cut short the traversal. */
1999 return FALSE;
2000 }
2001 return TRUE;
2002 }
2003
2004 /* Set the sizes of the dynamic sections. */
2005
2006 static bfd_boolean
2007 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2008 struct bfd_link_info *info)
2009 {
2010 struct elf_lm32_link_hash_table *htab;
2011 bfd *dynobj;
2012 asection *s;
2013 bfd_boolean relocs;
2014 bfd *ibfd;
2015
2016 htab = lm32_elf_hash_table (info);
2017 if (htab == NULL)
2018 return FALSE;
2019
2020 dynobj = htab->root.dynobj;
2021 BFD_ASSERT (dynobj != NULL);
2022
2023 if (htab->root.dynamic_sections_created)
2024 {
2025 /* Set the contents of the .interp section to the interpreter. */
2026 if (bfd_link_executable (info) && !info->nointerp)
2027 {
2028 s = bfd_get_linker_section (dynobj, ".interp");
2029 BFD_ASSERT (s != NULL);
2030 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2031 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2032 }
2033 }
2034
2035 /* Set up .got offsets for local syms, and space for local dynamic
2036 relocs. */
2037 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2038 {
2039 bfd_signed_vma *local_got;
2040 bfd_signed_vma *end_local_got;
2041 bfd_size_type locsymcount;
2042 Elf_Internal_Shdr *symtab_hdr;
2043 asection *srel;
2044
2045 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2046 continue;
2047
2048 for (s = ibfd->sections; s != NULL; s = s->next)
2049 {
2050 struct elf_dyn_relocs *p;
2051
2052 for (p = ((struct elf_dyn_relocs *)
2053 elf_section_data (s)->local_dynrel);
2054 p != NULL;
2055 p = p->next)
2056 {
2057 if (! bfd_is_abs_section (p->sec)
2058 && bfd_is_abs_section (p->sec->output_section))
2059 {
2060 /* Input section has been discarded, either because
2061 it is a copy of a linkonce section or due to
2062 linker script /DISCARD/, so we'll be discarding
2063 the relocs too. */
2064 }
2065 else if (p->count != 0)
2066 {
2067 srel = elf_section_data (p->sec)->sreloc;
2068 srel->size += p->count * sizeof (Elf32_External_Rela);
2069 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2070 info->flags |= DF_TEXTREL;
2071 }
2072 }
2073 }
2074
2075 local_got = elf_local_got_refcounts (ibfd);
2076 if (!local_got)
2077 continue;
2078
2079 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2080 locsymcount = symtab_hdr->sh_info;
2081 end_local_got = local_got + locsymcount;
2082 s = htab->root.sgot;
2083 srel = htab->root.srelgot;
2084 for (; local_got < end_local_got; ++local_got)
2085 {
2086 if (*local_got > 0)
2087 {
2088 *local_got = s->size;
2089 s->size += 4;
2090 if (bfd_link_pic (info))
2091 srel->size += sizeof (Elf32_External_Rela);
2092 }
2093 else
2094 *local_got = (bfd_vma) -1;
2095 }
2096 }
2097
2098 /* Allocate global sym .plt and .got entries, and space for global
2099 sym dynamic relocs. */
2100 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2101
2102 /* We now have determined the sizes of the various dynamic sections.
2103 Allocate memory for them. */
2104 relocs = FALSE;
2105 for (s = dynobj->sections; s != NULL; s = s->next)
2106 {
2107 if ((s->flags & SEC_LINKER_CREATED) == 0)
2108 continue;
2109
2110 if (s == htab->root.splt
2111 || s == htab->root.sgot
2112 || s == htab->root.sgotplt
2113 || s == htab->sdynbss)
2114 {
2115 /* Strip this section if we don't need it; see the
2116 comment below. */
2117 }
2118 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2119 {
2120 if (s->size != 0 && s != htab->root.srelplt)
2121 relocs = TRUE;
2122
2123 /* We use the reloc_count field as a counter if we need
2124 to copy relocs into the output file. */
2125 s->reloc_count = 0;
2126 }
2127 else
2128 /* It's not one of our sections, so don't allocate space. */
2129 continue;
2130
2131 if (s->size == 0)
2132 {
2133 /* If we don't need this section, strip it from the
2134 output file. This is mostly to handle .rela.bss and
2135 .rela.plt. We must create both sections in
2136 create_dynamic_sections, because they must be created
2137 before the linker maps input sections to output
2138 sections. The linker does that before
2139 adjust_dynamic_symbol is called, and it is that
2140 function which decides whether anything needs to go
2141 into these sections. */
2142 s->flags |= SEC_EXCLUDE;
2143 continue;
2144 }
2145
2146 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2147 continue;
2148
2149 /* Allocate memory for the section contents. We use bfd_zalloc
2150 here in case unused entries are not reclaimed before the
2151 section's contents are written out. This should not happen,
2152 but this way if it does, we get a R_LM32_NONE reloc instead
2153 of garbage. */
2154 s->contents = bfd_zalloc (dynobj, s->size);
2155 if (s->contents == NULL)
2156 return FALSE;
2157 }
2158
2159 if (htab->root.dynamic_sections_created)
2160 {
2161 /* Add some entries to the .dynamic section. We fill in the
2162 values later, in lm32_elf_finish_dynamic_sections, but we
2163 must add the entries now so that we get the correct size for
2164 the .dynamic section. The DT_DEBUG entry is filled in by the
2165 dynamic linker and used by the debugger. */
2166 #define add_dynamic_entry(TAG, VAL) \
2167 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2168
2169 if (bfd_link_executable (info))
2170 {
2171 if (! add_dynamic_entry (DT_DEBUG, 0))
2172 return FALSE;
2173 }
2174
2175 if (htab->root.splt->size != 0)
2176 {
2177 if (! add_dynamic_entry (DT_PLTGOT, 0)
2178 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2179 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2180 || ! add_dynamic_entry (DT_JMPREL, 0))
2181 return FALSE;
2182 }
2183
2184 if (relocs)
2185 {
2186 if (! add_dynamic_entry (DT_RELA, 0)
2187 || ! add_dynamic_entry (DT_RELASZ, 0)
2188 || ! add_dynamic_entry (DT_RELAENT,
2189 sizeof (Elf32_External_Rela)))
2190 return FALSE;
2191
2192 /* If any dynamic relocs apply to a read-only section,
2193 then we need a DT_TEXTREL entry. */
2194 if ((info->flags & DF_TEXTREL) == 0)
2195 elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2196
2197 if ((info->flags & DF_TEXTREL) != 0)
2198 {
2199 if (! add_dynamic_entry (DT_TEXTREL, 0))
2200 return FALSE;
2201 }
2202 }
2203 }
2204 #undef add_dynamic_entry
2205
2206 /* Allocate .rofixup section. */
2207 if (IS_FDPIC (output_bfd))
2208 {
2209 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2210 int rgot_weak_count = 0;
2211 int r32_count = 0;
2212 int rgot_count = 0;
2213 /* Look for deleted sections. */
2214 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2215 {
2216 for (s = ibfd->sections; s != NULL; s = s->next)
2217 {
2218 if (s->reloc_count)
2219 {
2220 /* Count relocs that need .rofixup entires. */
2221 Elf_Internal_Rela *internal_relocs, *end;
2222 internal_relocs = elf_section_data (s)->relocs;
2223 if (internal_relocs == NULL)
2224 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2225 if (internal_relocs != NULL)
2226 {
2227 end = internal_relocs + s->reloc_count;
2228 while (internal_relocs < end)
2229 {
2230 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2231 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2232 unsigned long r_symndx;
2233 struct elf_link_hash_entry *h;
2234
2235 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2236 sym_hashes = elf_sym_hashes (ibfd);
2237 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2238 h = NULL;
2239 if (r_symndx < symtab_hdr->sh_info)
2240 {
2241 }
2242 else
2243 {
2244 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2245 while (h->root.type == bfd_link_hash_indirect
2246 || h->root.type == bfd_link_hash_warning)
2247 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2248 }
2249
2250 /* Don't generate entries for weak symbols. */
2251 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2252 {
2253 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2254 {
2255 switch (ELF32_R_TYPE (internal_relocs->r_info))
2256 {
2257 case R_LM32_32:
2258 r32_count++;
2259 break;
2260 case R_LM32_16_GOT:
2261 rgot_count++;
2262 break;
2263 }
2264 }
2265 }
2266 else
2267 {
2268 struct weak_symbol_list *current, *new_entry;
2269 /* Is this symbol already in the list? */
2270 for (current = list_start; current; current = current->next)
2271 {
2272 if (!strcmp (current->name, h->root.root.string))
2273 break;
2274 }
2275 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2276 {
2277 /* Will this have an entry in the GOT. */
2278 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2279 {
2280 /* Create a new entry. */
2281 new_entry = malloc (sizeof (struct weak_symbol_list));
2282 if (!new_entry)
2283 return FALSE;
2284 new_entry->name = h->root.root.string;
2285 new_entry->next = NULL;
2286 /* Add to list */
2287 if (list_start == NULL)
2288 {
2289 list_start = new_entry;
2290 list_end = new_entry;
2291 }
2292 else
2293 {
2294 list_end->next = new_entry;
2295 list_end = new_entry;
2296 }
2297 /* Increase count of undefined weak symbols in the got. */
2298 rgot_weak_count++;
2299 }
2300 }
2301 }
2302 internal_relocs++;
2303 }
2304 }
2305 else
2306 return FALSE;
2307 }
2308 }
2309 }
2310 /* Free list. */
2311 while (list_start)
2312 {
2313 list_end = list_start->next;
2314 free (list_start);
2315 list_start = list_end;
2316 }
2317
2318 /* Size sections. */
2319 lm32fdpic_fixup32_section (info)->size
2320 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2321 if (lm32fdpic_fixup32_section (info)->size == 0)
2322 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2323 else
2324 {
2325 lm32fdpic_fixup32_section (info)->contents =
2326 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2327 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2328 return FALSE;
2329 }
2330 }
2331
2332 return TRUE;
2333 }
2334
2335 /* Create dynamic sections when linking against a dynamic object. */
2336
2337 static bfd_boolean
2338 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2339 {
2340 struct elf_lm32_link_hash_table *htab;
2341 flagword flags, pltflags;
2342 asection *s;
2343 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2344 int ptralign = 2; /* 32bit */
2345
2346 htab = lm32_elf_hash_table (info);
2347 if (htab == NULL)
2348 return FALSE;
2349
2350 /* Make sure we have a GOT - For the case where we have a dynamic object
2351 but none of the relocs in check_relocs */
2352 if (!_bfd_elf_create_got_section (abfd, info))
2353 return FALSE;
2354 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2355 {
2356 if (! create_rofixup_section (abfd, info))
2357 return FALSE;
2358 }
2359
2360 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2361 .rel[a].bss sections. */
2362 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2363 | SEC_LINKER_CREATED);
2364
2365 pltflags = flags;
2366 pltflags |= SEC_CODE;
2367 if (bed->plt_not_loaded)
2368 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2369 if (bed->plt_readonly)
2370 pltflags |= SEC_READONLY;
2371
2372 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2373 htab->root.splt = s;
2374 if (s == NULL
2375 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2376 return FALSE;
2377
2378 if (bed->want_plt_sym)
2379 {
2380 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2381 .plt section. */
2382 struct bfd_link_hash_entry *bh = NULL;
2383 struct elf_link_hash_entry *h;
2384
2385 if (! (_bfd_generic_link_add_one_symbol
2386 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2387 (bfd_vma) 0, NULL, FALSE,
2388 get_elf_backend_data (abfd)->collect, &bh)))
2389 return FALSE;
2390 h = (struct elf_link_hash_entry *) bh;
2391 h->def_regular = 1;
2392 h->type = STT_OBJECT;
2393 htab->root.hplt = h;
2394
2395 if (bfd_link_pic (info)
2396 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2397 return FALSE;
2398 }
2399
2400 s = bfd_make_section_anyway_with_flags (abfd,
2401 bed->default_use_rela_p
2402 ? ".rela.plt" : ".rel.plt",
2403 flags | SEC_READONLY);
2404 htab->root.srelplt = s;
2405 if (s == NULL
2406 || ! bfd_set_section_alignment (abfd, s, ptralign))
2407 return FALSE;
2408
2409 if (htab->root.sgot == NULL
2410 && !_bfd_elf_create_got_section (abfd, info))
2411 return FALSE;
2412
2413 if (bed->want_dynbss)
2414 {
2415 /* The .dynbss section is a place to put symbols which are defined
2416 by dynamic objects, are referenced by regular objects, and are
2417 not functions. We must allocate space for them in the process
2418 image and use a R_*_COPY reloc to tell the dynamic linker to
2419 initialize them at run time. The linker script puts the .dynbss
2420 section into the .bss section of the final image. */
2421 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2422 SEC_ALLOC | SEC_LINKER_CREATED);
2423 htab->sdynbss = s;
2424 if (s == NULL)
2425 return FALSE;
2426 /* The .rel[a].bss section holds copy relocs. This section is not
2427 normally needed. We need to create it here, though, so that the
2428 linker will map it to an output section. We can't just create it
2429 only if we need it, because we will not know whether we need it
2430 until we have seen all the input files, and the first time the
2431 main linker code calls BFD after examining all the input files
2432 (size_dynamic_sections) the input sections have already been
2433 mapped to the output sections. If the section turns out not to
2434 be needed, we can discard it later. We will never need this
2435 section when generating a shared object, since they do not use
2436 copy relocs. */
2437 if (! bfd_link_pic (info))
2438 {
2439 s = bfd_make_section_anyway_with_flags (abfd,
2440 (bed->default_use_rela_p
2441 ? ".rela.bss" : ".rel.bss"),
2442 flags | SEC_READONLY);
2443 htab->srelbss = s;
2444 if (s == NULL
2445 || ! bfd_set_section_alignment (abfd, s, ptralign))
2446 return FALSE;
2447 }
2448 }
2449
2450 return TRUE;
2451 }
2452
2453 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2454
2455 static void
2456 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2457 struct elf_link_hash_entry *dir,
2458 struct elf_link_hash_entry *ind)
2459 {
2460 struct elf_lm32_link_hash_entry * edir;
2461 struct elf_lm32_link_hash_entry * eind;
2462
2463 edir = (struct elf_lm32_link_hash_entry *) dir;
2464 eind = (struct elf_lm32_link_hash_entry *) ind;
2465
2466 if (eind->dyn_relocs != NULL)
2467 {
2468 if (edir->dyn_relocs != NULL)
2469 {
2470 struct elf_dyn_relocs **pp;
2471 struct elf_dyn_relocs *p;
2472
2473 /* Add reloc counts against the indirect sym to the direct sym
2474 list. Merge any entries against the same section. */
2475 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2476 {
2477 struct elf_dyn_relocs *q;
2478
2479 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2480 if (q->sec == p->sec)
2481 {
2482 q->pc_count += p->pc_count;
2483 q->count += p->count;
2484 *pp = p->next;
2485 break;
2486 }
2487 if (q == NULL)
2488 pp = &p->next;
2489 }
2490 *pp = edir->dyn_relocs;
2491 }
2492
2493 edir->dyn_relocs = eind->dyn_relocs;
2494 eind->dyn_relocs = NULL;
2495 }
2496
2497 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2498 }
2499
2500 static bfd_boolean
2501 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2502 {
2503 if (!bfd_link_relocatable (info))
2504 {
2505 if (!bfd_elf_stack_segment_size (output_bfd, info,
2506 "__stacksize", DEFAULT_STACK_SIZE))
2507 return FALSE;
2508
2509 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2510 if (sec)
2511 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2512 }
2513
2514 return TRUE;
2515 }
2516
2517 static bfd_boolean
2518 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2519 {
2520 unsigned i;
2521
2522 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2523 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2524 return TRUE;
2525
2526 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2527 return FALSE;
2528
2529 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2530 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2531 return TRUE;
2532
2533 /* Copy the stack size. */
2534 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2535 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2536 {
2537 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2538
2539 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2540 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2541 {
2542 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2543
2544 /* Rewrite the phdrs, since we're only called after they were first written. */
2545 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2546 ->s->sizeof_ehdr, SEEK_SET) != 0
2547 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2548 elf_elfheader (obfd)->e_phnum) != 0)
2549 return FALSE;
2550 break;
2551 }
2552
2553 break;
2554 }
2555
2556 return TRUE;
2557 }
2558
2559
2560 #define ELF_ARCH bfd_arch_lm32
2561 #define ELF_TARGET_ID LM32_ELF_DATA
2562 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2563 #define ELF_MAXPAGESIZE 0x1000
2564
2565 #define TARGET_BIG_SYM lm32_elf32_vec
2566 #define TARGET_BIG_NAME "elf32-lm32"
2567
2568 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2569 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2570 #define elf_info_to_howto lm32_info_to_howto_rela
2571 #define elf_info_to_howto_rel 0
2572 #define elf_backend_rela_normal 1
2573 #define elf_backend_object_p lm32_elf_object_p
2574 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2575 #define elf_backend_stack_align 8
2576 #define elf_backend_can_gc_sections 1
2577 #define elf_backend_can_refcount 1
2578 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2579 #define elf_backend_plt_readonly 1
2580 #define elf_backend_want_got_plt 1
2581 #define elf_backend_want_plt_sym 0
2582 #define elf_backend_got_header_size 12
2583 #define elf_backend_dtrel_excludes_plt 1
2584 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2585 #define elf_backend_check_relocs lm32_elf_check_relocs
2586 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2587 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2588 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2589 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2590 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2591 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2592 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2593 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2594 #define elf_backend_relocate_section lm32_elf_relocate_section
2595
2596 #include "elf32-target.h"
2597
2598 #undef ELF_MAXPAGESIZE
2599 #define ELF_MAXPAGESIZE 0x4000
2600
2601
2602 #undef TARGET_BIG_SYM
2603 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2604 #undef TARGET_BIG_NAME
2605 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2606 #undef elf32_bed
2607 #define elf32_bed elf32_lm32fdpic_bed
2608
2609 #undef elf_backend_always_size_sections
2610 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2611 #undef bfd_elf32_bfd_copy_private_bfd_data
2612 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2613
2614 #include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.084591 seconds and 4 git commands to generate.