daily update
[binutils.git] / bfd / elf32-lm32.c
blobb6e8ba0f3995a8b129d6674598ca085eadf7a50d
1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright 2008, 2009, 2010 Free Software Foundation, Inc.
3 Contributed by Jon Beniston <jon@beniston.com>
5 This file is part of BFD, the Binary File Descriptor library.
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.
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.
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. */
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/lm32.h"
28 #define DEFAULT_STACK_SIZE 0x20000
30 #define PLT_ENTRY_SIZE 20
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
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
44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
46 extern const bfd_target bfd_elf32_lm32fdpic_vec;
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_lm32fdpic_vec)
50 static bfd_reloc_status_type lm32_elf_gprel_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
53 /* The linker needs to keep track of the number of relocs that it
54 decides to copy as dynamic relocs in check_relocs for each symbol.
55 This is so that it can later discard them if they are found to be
56 unnecessary. We store the information in a field extending the
57 regular ELF linker hash table. */
59 struct elf_lm32_dyn_relocs
61 struct elf_lm32_dyn_relocs *next;
63 /* The input section of the reloc. */
64 asection *sec;
66 /* Total number of relocs copied for the input section. */
67 bfd_size_type count;
69 /* Number of pc-relative relocs copied for the input section. */
70 bfd_size_type pc_count;
73 /* lm32 ELF linker hash entry. */
75 struct elf_lm32_link_hash_entry
77 struct elf_link_hash_entry root;
79 /* Track dynamic relocs copied for this symbol. */
80 struct elf_lm32_dyn_relocs *dyn_relocs;
83 /* lm32 ELF linker hash table. */
85 struct elf_lm32_link_hash_table
87 struct elf_link_hash_table root;
89 /* Short-cuts to get to dynamic linker sections. */
90 asection *sgot;
91 asection *sgotplt;
92 asection *srelgot;
93 asection *sfixup32;
94 asection *splt;
95 asection *srelplt;
96 asection *sdynbss;
97 asection *srelbss;
99 int relocs32;
102 /* Get the lm32 ELF linker hash table from a link_info structure. */
104 #define lm32_elf_hash_table(p) \
105 (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
106 == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
108 #define lm32fdpic_got_section(info) \
109 (lm32_elf_hash_table (info)->sgot)
110 #define lm32fdpic_gotrel_section(info) \
111 (lm32_elf_hash_table (info)->srelgot)
112 #define lm32fdpic_fixup32_section(info) \
113 (lm32_elf_hash_table (info)->sfixup32)
115 struct weak_symbol_list
117 const char *name;
118 struct weak_symbol_list *next;
121 /* Create an entry in an lm32 ELF linker hash table. */
123 static struct bfd_hash_entry *
124 lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
125 struct bfd_hash_table *table,
126 const char *string)
128 struct elf_lm32_link_hash_entry *ret =
129 (struct elf_lm32_link_hash_entry *) entry;
131 /* Allocate the structure if it has not already been allocated by a
132 subclass. */
133 if (ret == NULL)
134 ret = bfd_hash_allocate (table,
135 sizeof (struct elf_lm32_link_hash_entry));
136 if (ret == NULL)
137 return NULL;
139 /* Call the allocation method of the superclass. */
140 ret = ((struct elf_lm32_link_hash_entry *)
141 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
142 table, string));
143 if (ret != NULL)
145 struct elf_lm32_link_hash_entry *eh;
147 eh = (struct elf_lm32_link_hash_entry *) ret;
148 eh->dyn_relocs = NULL;
151 return (struct bfd_hash_entry *) ret;
154 /* Create an lm32 ELF linker hash table. */
156 static struct bfd_link_hash_table *
157 lm32_elf_link_hash_table_create (bfd *abfd)
159 struct elf_lm32_link_hash_table *ret;
160 bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
162 ret = bfd_malloc (amt);
163 if (ret == NULL)
164 return NULL;
166 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
167 lm32_elf_link_hash_newfunc,
168 sizeof (struct elf_lm32_link_hash_entry),
169 LM32_ELF_DATA))
171 free (ret);
172 return NULL;
175 ret->sgot = NULL;
176 ret->sgotplt = NULL;
177 ret->srelgot = NULL;
178 ret->sfixup32 = NULL;
179 ret->splt = NULL;
180 ret->srelplt = NULL;
181 ret->sdynbss = NULL;
182 ret->srelbss = NULL;
183 ret->relocs32 = 0;
185 return &ret->root.root;
188 /* Add a fixup to the ROFIXUP section. */
190 static bfd_vma
191 _lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
193 bfd_vma fixup_offset;
195 if (rofixup->flags & SEC_EXCLUDE)
196 return -1;
198 fixup_offset = rofixup->reloc_count * 4;
199 if (rofixup->contents)
201 BFD_ASSERT (fixup_offset < rofixup->size);
202 if (fixup_offset < rofixup->size)
203 bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
205 rofixup->reloc_count++;
207 return fixup_offset;
210 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
211 shortcuts to them in our hash table. */
213 static bfd_boolean
214 create_got_section (bfd *dynobj, struct bfd_link_info *info)
216 struct elf_lm32_link_hash_table *htab;
217 asection *s;
219 /* This function may be called more than once. */
220 s = bfd_get_section_by_name (dynobj, ".got");
221 if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
222 return TRUE;
224 htab = lm32_elf_hash_table (info);
225 if (htab == NULL)
226 return FALSE;
228 if (! _bfd_elf_create_got_section (dynobj, info))
229 return FALSE;
231 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
232 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
233 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
234 if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
235 abort ();
237 return TRUE;
240 /* Create .rofixup sections in DYNOBJ, and set up
241 shortcuts to them in our hash table. */
243 static bfd_boolean
244 create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
246 struct elf_lm32_link_hash_table *htab;
247 htab = lm32_elf_hash_table (info);
249 if (htab == NULL)
250 return FALSE;
252 /* Fixup section for R_LM32_32 relocs. */
253 lm32fdpic_fixup32_section (info) = bfd_make_section_with_flags (dynobj,
254 ".rofixup",
255 (SEC_ALLOC
256 | SEC_LOAD
257 | SEC_HAS_CONTENTS
258 | SEC_IN_MEMORY
259 | SEC_LINKER_CREATED
260 | SEC_READONLY));
261 if (lm32fdpic_fixup32_section (info) == NULL
262 || ! bfd_set_section_alignment (dynobj, lm32fdpic_fixup32_section (info), 2))
263 return FALSE;
265 return TRUE;
268 static reloc_howto_type lm32_elf_howto_table [] =
270 /* This reloc does nothing. */
271 HOWTO (R_LM32_NONE, /* type */
272 0, /* rightshift */
273 2, /* size (0 = byte, 1 = short, 2 = long) */
274 32, /* bitsize */
275 FALSE, /* pc_relative */
276 0, /* bitpos */
277 complain_overflow_bitfield,/* complain_on_overflow */
278 bfd_elf_generic_reloc, /* special_function */
279 "R_LM32_NONE", /* name */
280 FALSE, /* partial_inplace */
281 0, /* src_mask */
282 0, /* dst_mask */
283 FALSE), /* pcrel_offset */
285 /* An 8 bit absolute relocation. */
286 HOWTO (R_LM32_8, /* type */
287 0, /* rightshift */
288 0, /* size (0 = byte, 1 = short, 2 = long) */
289 8, /* bitsize */
290 FALSE, /* pc_relative */
291 0, /* bitpos */
292 complain_overflow_bitfield,/* complain_on_overflow */
293 bfd_elf_generic_reloc, /* special_function */
294 "R_LM32_8", /* name */
295 FALSE, /* partial_inplace */
296 0, /* src_mask */
297 0xff, /* dst_mask */
298 FALSE), /* pcrel_offset */
300 /* A 16 bit absolute relocation. */
301 HOWTO (R_LM32_16, /* type */
302 0, /* rightshift */
303 1, /* size (0 = byte, 1 = short, 2 = long) */
304 16, /* bitsize */
305 FALSE, /* pc_relative */
306 0, /* bitpos */
307 complain_overflow_bitfield,/* complain_on_overflow */
308 bfd_elf_generic_reloc, /* special_function */
309 "R_LM32_16", /* name */
310 FALSE, /* partial_inplace */
311 0, /* src_mask */
312 0xffff, /* dst_mask */
313 FALSE), /* pcrel_offset */
315 /* A 32 bit absolute relocation. */
316 HOWTO (R_LM32_32, /* type */
317 0, /* rightshift */
318 2, /* size (0 = byte, 1 = short, 2 = long) */
319 32, /* bitsize */
320 FALSE, /* pc_relative */
321 0, /* bitpos */
322 complain_overflow_bitfield,/* complain_on_overflow */
323 bfd_elf_generic_reloc, /* special_function */
324 "R_LM32_32", /* name */
325 FALSE, /* partial_inplace */
326 0, /* src_mask */
327 0xffffffff, /* dst_mask */
328 FALSE), /* pcrel_offset */
330 HOWTO (R_LM32_HI16, /* type */
331 16, /* rightshift */
332 2, /* size (0 = byte, 1 = short, 2 = long) */
333 16, /* bitsize */
334 FALSE, /* pc_relative */
335 0, /* bitpos */
336 complain_overflow_bitfield,/* complain_on_overflow */
337 bfd_elf_generic_reloc, /* special_function */
338 "R_LM32_HI16", /* name */
339 FALSE, /* partial_inplace */
340 0, /* src_mask */
341 0xffff, /* dst_mask */
342 FALSE), /* pcrel_offset */
344 HOWTO (R_LM32_LO16, /* type */
345 0, /* rightshift */
346 2, /* size (0 = byte, 1 = short, 2 = long) */
347 16, /* bitsize */
348 FALSE, /* pc_relative */
349 0, /* bitpos */
350 complain_overflow_dont, /* complain_on_overflow */
351 bfd_elf_generic_reloc, /* special_function */
352 "R_LM32_LO16", /* name */
353 FALSE, /* partial_inplace */
354 0, /* src_mask */
355 0xffff, /* dst_mask */
356 FALSE), /* pcrel_offset */
358 HOWTO (R_LM32_GPREL16, /* type */
359 0, /* rightshift */
360 2, /* size (0 = byte, 1 = short, 2 = long) */
361 16, /* bitsize */
362 FALSE, /* pc_relative */
363 0, /* bitpos */
364 complain_overflow_dont, /* complain_on_overflow */
365 lm32_elf_gprel_reloc, /* special_function */
366 "R_LM32_GPREL16", /* name */
367 FALSE, /* partial_inplace */
368 0, /* src_mask */
369 0xffff, /* dst_mask */
370 FALSE), /* pcrel_offset */
372 HOWTO (R_LM32_CALL, /* type */
373 2, /* rightshift */
374 2, /* size (0 = byte, 1 = short, 2 = long) */
375 26, /* bitsize */
376 TRUE, /* pc_relative */
377 0, /* bitpos */
378 complain_overflow_signed, /* complain_on_overflow */
379 bfd_elf_generic_reloc, /* special_function */
380 "R_LM32_CALL", /* name */
381 FALSE, /* partial_inplace */
382 0, /* src_mask */
383 0x3ffffff, /* dst_mask */
384 TRUE), /* pcrel_offset */
386 HOWTO (R_LM32_BRANCH, /* type */
387 2, /* rightshift */
388 2, /* size (0 = byte, 1 = short, 2 = long) */
389 16, /* bitsize */
390 TRUE, /* pc_relative */
391 0, /* bitpos */
392 complain_overflow_signed, /* complain_on_overflow */
393 bfd_elf_generic_reloc, /* special_function */
394 "R_LM32_BRANCH", /* name */
395 FALSE, /* partial_inplace */
396 0, /* src_mask */
397 0xffff, /* dst_mask */
398 TRUE), /* pcrel_offset */
400 /* GNU extension to record C++ vtable hierarchy. */
401 HOWTO (R_LM32_GNU_VTINHERIT, /* type */
402 0, /* rightshift */
403 2, /* size (0 = byte, 1 = short, 2 = long) */
404 0, /* bitsize */
405 FALSE, /* pc_relative */
406 0, /* bitpos */
407 complain_overflow_dont, /* complain_on_overflow */
408 NULL, /* special_function */
409 "R_LM32_GNU_VTINHERIT", /* name */
410 FALSE, /* partial_inplace */
411 0, /* src_mask */
412 0, /* dst_mask */
413 FALSE), /* pcrel_offset */
415 /* GNU extension to record C++ vtable member usage. */
416 HOWTO (R_LM32_GNU_VTENTRY, /* type */
417 0, /* rightshift */
418 2, /* size (0 = byte, 1 = short, 2 = long) */
419 0, /* bitsize */
420 FALSE, /* pc_relative */
421 0, /* bitpos */
422 complain_overflow_dont, /* complain_on_overflow */
423 _bfd_elf_rel_vtable_reloc_fn,/* special_function */
424 "R_LM32_GNU_VTENTRY", /* name */
425 FALSE, /* partial_inplace */
426 0, /* src_mask */
427 0, /* dst_mask */
428 FALSE), /* pcrel_offset */
430 HOWTO (R_LM32_16_GOT, /* type */
431 0, /* rightshift */
432 2, /* size (0 = byte, 1 = short, 2 = long) */
433 16, /* bitsize */
434 FALSE, /* pc_relative */
435 0, /* bitpos */
436 complain_overflow_signed, /* complain_on_overflow */
437 bfd_elf_generic_reloc, /* special_function */
438 "R_LM32_16_GOT", /* name */
439 FALSE, /* partial_inplace */
440 0, /* src_mask */
441 0xffff, /* dst_mask */
442 FALSE), /* pcrel_offset */
444 HOWTO (R_LM32_GOTOFF_HI16, /* type */
445 16, /* rightshift */
446 2, /* size (0 = byte, 1 = short, 2 = long) */
447 16, /* bitsize */
448 FALSE, /* pc_relative */
449 0, /* bitpos */
450 complain_overflow_dont, /* complain_on_overflow */
451 bfd_elf_generic_reloc, /* special_function */
452 "R_LM32_GOTOFF_HI16", /* name */
453 FALSE, /* partial_inplace */
454 0xffff, /* src_mask */
455 0xffff, /* dst_mask */
456 FALSE), /* pcrel_offset */
458 HOWTO (R_LM32_GOTOFF_LO16, /* type */
459 0, /* rightshift */
460 2, /* size (0 = byte, 1 = short, 2 = long) */
461 16, /* bitsize */
462 FALSE, /* pc_relative */
463 0, /* bitpos */
464 complain_overflow_dont, /* complain_on_overflow */
465 bfd_elf_generic_reloc, /* special_function */
466 "R_LM32_GOTOFF_LO16", /* name */
467 FALSE, /* partial_inplace */
468 0xffff, /* src_mask */
469 0xffff, /* dst_mask */
470 FALSE), /* pcrel_offset */
472 HOWTO (R_LM32_COPY, /* type */
473 0, /* rightshift */
474 2, /* size (0 = byte, 1 = short, 2 = long) */
475 32, /* bitsize */
476 FALSE, /* pc_relative */
477 0, /* bitpos */
478 complain_overflow_bitfield, /* complain_on_overflow */
479 bfd_elf_generic_reloc, /* special_function */
480 "R_LM32_COPY", /* name */
481 FALSE, /* partial_inplace */
482 0xffffffff, /* src_mask */
483 0xffffffff, /* dst_mask */
484 FALSE), /* pcrel_offset */
486 HOWTO (R_LM32_GLOB_DAT, /* type */
487 0, /* rightshift */
488 2, /* size (0 = byte, 1 = short, 2 = long) */
489 32, /* bitsize */
490 FALSE, /* pc_relative */
491 0, /* bitpos */
492 complain_overflow_bitfield, /* complain_on_overflow */
493 bfd_elf_generic_reloc, /* special_function */
494 "R_LM32_GLOB_DAT", /* name */
495 FALSE, /* partial_inplace */
496 0xffffffff, /* src_mask */
497 0xffffffff, /* dst_mask */
498 FALSE), /* pcrel_offset */
500 HOWTO (R_LM32_JMP_SLOT, /* type */
501 0, /* rightshift */
502 2, /* size (0 = byte, 1 = short, 2 = long) */
503 32, /* bitsize */
504 FALSE, /* pc_relative */
505 0, /* bitpos */
506 complain_overflow_bitfield, /* complain_on_overflow */
507 bfd_elf_generic_reloc, /* special_function */
508 "R_LM32_JMP_SLOT", /* name */
509 FALSE, /* partial_inplace */
510 0xffffffff, /* src_mask */
511 0xffffffff, /* dst_mask */
512 FALSE), /* pcrel_offset */
514 HOWTO (R_LM32_RELATIVE, /* type */
515 0, /* rightshift */
516 2, /* size (0 = byte, 1 = short, 2 = long) */
517 32, /* bitsize */
518 FALSE, /* pc_relative */
519 0, /* bitpos */
520 complain_overflow_bitfield, /* complain_on_overflow */
521 bfd_elf_generic_reloc, /* special_function */
522 "R_LM32_RELATIVE", /* name */
523 FALSE, /* partial_inplace */
524 0xffffffff, /* src_mask */
525 0xffffffff, /* dst_mask */
526 FALSE), /* pcrel_offset */
530 /* Map BFD reloc types to lm32 ELF reloc types. */
532 struct lm32_reloc_map
534 bfd_reloc_code_real_type bfd_reloc_val;
535 unsigned char elf_reloc_val;
538 static const struct lm32_reloc_map lm32_reloc_map[] =
540 { BFD_RELOC_NONE, R_LM32_NONE },
541 { BFD_RELOC_8, R_LM32_8 },
542 { BFD_RELOC_16, R_LM32_16 },
543 { BFD_RELOC_32, R_LM32_32 },
544 { BFD_RELOC_HI16, R_LM32_HI16 },
545 { BFD_RELOC_LO16, R_LM32_LO16 },
546 { BFD_RELOC_GPREL16, R_LM32_GPREL16 },
547 { BFD_RELOC_LM32_CALL, R_LM32_CALL },
548 { BFD_RELOC_LM32_BRANCH, R_LM32_BRANCH },
549 { BFD_RELOC_VTABLE_INHERIT, R_LM32_GNU_VTINHERIT },
550 { BFD_RELOC_VTABLE_ENTRY, R_LM32_GNU_VTENTRY },
551 { BFD_RELOC_LM32_16_GOT, R_LM32_16_GOT },
552 { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 },
553 { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 },
554 { BFD_RELOC_LM32_COPY, R_LM32_COPY },
555 { BFD_RELOC_LM32_GLOB_DAT, R_LM32_GLOB_DAT },
556 { BFD_RELOC_LM32_JMP_SLOT, R_LM32_JMP_SLOT },
557 { BFD_RELOC_LM32_RELATIVE, R_LM32_RELATIVE },
560 static reloc_howto_type *
561 lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
562 bfd_reloc_code_real_type code)
564 unsigned int i;
566 for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++)
567 if (lm32_reloc_map[i].bfd_reloc_val == code)
568 return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val];
569 return NULL;
572 static reloc_howto_type *
573 lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
574 const char *r_name)
576 unsigned int i;
578 for (i = 0;
579 i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]);
580 i++)
581 if (lm32_elf_howto_table[i].name != NULL
582 && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0)
583 return &lm32_elf_howto_table[i];
585 return NULL;
589 /* Set the howto pointer for an Lattice Mico32 ELF reloc. */
591 static void
592 lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
593 arelent *cache_ptr,
594 Elf_Internal_Rela *dst)
596 unsigned int r_type;
598 r_type = ELF32_R_TYPE (dst->r_info);
599 BFD_ASSERT (r_type < (unsigned int) R_LM32_max);
600 cache_ptr->howto = &lm32_elf_howto_table[r_type];
603 /* Set the right machine number for an Lattice Mico32 ELF file. */
605 static bfd_boolean
606 lm32_elf_object_p (bfd *abfd)
608 return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
611 /* Set machine type flags just before file is written out. */
613 static void
614 lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
616 elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
617 elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
618 switch (bfd_get_mach (abfd))
620 case bfd_mach_lm32:
621 elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
622 break;
623 default:
624 abort ();
628 /* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
629 dangerous relocation. */
631 static bfd_boolean
632 lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
634 unsigned int count;
635 asymbol **sym;
636 unsigned int i;
638 /* If we've already figured out what GP will be, just return it. */
639 *pgp = _bfd_get_gp_value (output_bfd);
640 if (*pgp)
641 return TRUE;
643 count = bfd_get_symcount (output_bfd);
644 sym = bfd_get_outsymbols (output_bfd);
646 /* The linker script will have created a symbol named `_gp' with the
647 appropriate value. */
648 if (sym == NULL)
649 i = count;
650 else
652 for (i = 0; i < count; i++, sym++)
654 const char *name;
656 name = bfd_asymbol_name (*sym);
657 if (*name == '_' && strcmp (name, "_gp") == 0)
659 *pgp = bfd_asymbol_value (*sym);
660 _bfd_set_gp_value (output_bfd, *pgp);
661 break;
666 if (i >= count)
668 /* Only get the error once. */
669 *pgp = 4;
670 _bfd_set_gp_value (output_bfd, *pgp);
671 return FALSE;
674 return TRUE;
677 /* We have to figure out the gp value, so that we can adjust the
678 symbol value correctly. We look up the symbol _gp in the output
679 BFD. If we can't find it, we're stuck. We cache it in the ELF
680 target data. We don't need to adjust the symbol value for an
681 external symbol if we are producing relocatable output. */
683 static bfd_reloc_status_type
684 lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
685 char **error_message, bfd_vma *pgp)
687 if (bfd_is_und_section (symbol->section) && !relocatable)
689 *pgp = 0;
690 return bfd_reloc_undefined;
693 *pgp = _bfd_get_gp_value (output_bfd);
694 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
696 if (relocatable)
698 /* Make up a value. */
699 *pgp = symbol->section->output_section->vma + 0x4000;
700 _bfd_set_gp_value (output_bfd, *pgp);
702 else if (!lm32_elf_assign_gp (output_bfd, pgp))
704 *error_message =
705 (char *)
706 _("global pointer relative relocation when _gp not defined");
707 return bfd_reloc_dangerous;
711 return bfd_reloc_ok;
714 static bfd_reloc_status_type
715 lm32_elf_do_gprel_relocate (bfd *abfd,
716 reloc_howto_type *howto,
717 asection *input_section ATTRIBUTE_UNUSED,
718 bfd_byte *data,
719 bfd_vma offset,
720 bfd_vma symbol_value,
721 bfd_vma addend)
723 return _bfd_final_link_relocate (howto, abfd, input_section,
724 data, offset, symbol_value, addend);
727 static bfd_reloc_status_type
728 lm32_elf_gprel_reloc (bfd *abfd,
729 arelent *reloc_entry,
730 asymbol *symbol,
731 void *data,
732 asection *input_section,
733 bfd *output_bfd,
734 char **msg)
736 bfd_vma relocation;
737 bfd_vma gp;
738 bfd_reloc_status_type r;
740 if (output_bfd != (bfd *) NULL
741 && (symbol->flags & BSF_SECTION_SYM) == 0
742 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
744 reloc_entry->address += input_section->output_offset;
745 return bfd_reloc_ok;
748 if (output_bfd != NULL)
749 return bfd_reloc_ok;
751 relocation = symbol->value
752 + symbol->section->output_section->vma + symbol->section->output_offset;
754 if ((r =
755 lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
757 relocation = relocation + reloc_entry->addend - gp;
758 reloc_entry->addend = 0;
759 if ((signed) relocation < -32768 || (signed) relocation > 32767)
761 *msg = _("global pointer relative address out of range");
762 r = bfd_reloc_outofrange;
764 else
766 r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
767 input_section,
768 data, reloc_entry->address,
769 relocation, reloc_entry->addend);
773 return r;
776 /* Find the segment number in which OSEC, and output section, is
777 located. */
779 static unsigned
780 _lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
782 struct elf_segment_map *m;
783 Elf_Internal_Phdr *p;
785 /* Find the segment that contains the output_section. */
786 for (m = elf_tdata (output_bfd)->segment_map,
787 p = elf_tdata (output_bfd)->phdr;
788 m != NULL;
789 m = m->next, p++)
791 int i;
793 for (i = m->count - 1; i >= 0; i--)
794 if (m->sections[i] == osec)
795 break;
797 if (i >= 0)
798 break;
801 return p - elf_tdata (output_bfd)->phdr;
804 /* Determine if an output section is read-only. */
806 inline static bfd_boolean
807 _lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
809 unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
811 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
814 /* Relocate a section */
816 static bfd_boolean
817 lm32_elf_relocate_section (bfd *output_bfd,
818 struct bfd_link_info *info,
819 bfd *input_bfd,
820 asection *input_section,
821 bfd_byte *contents,
822 Elf_Internal_Rela *relocs,
823 Elf_Internal_Sym *local_syms,
824 asection **local_sections)
826 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
827 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
828 Elf_Internal_Rela *rel, *relend;
829 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
830 bfd *dynobj;
831 bfd_vma *local_got_offsets;
832 asection *sgot;
834 if (htab == NULL)
835 return FALSE;
837 dynobj = htab->root.dynobj;
838 local_got_offsets = elf_local_got_offsets (input_bfd);
840 sgot = htab->sgot;
842 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
843 sym_hashes = elf_sym_hashes (input_bfd);
845 rel = relocs;
846 relend = relocs + input_section->reloc_count;
847 for (; rel < relend; rel++)
849 reloc_howto_type *howto;
850 unsigned int r_type;
851 unsigned long r_symndx;
852 Elf_Internal_Sym *sym;
853 asection *sec;
854 struct elf_link_hash_entry *h;
855 bfd_vma relocation;
856 bfd_vma gp;
857 bfd_reloc_status_type r;
858 const char *name = NULL;
860 r_symndx = ELF32_R_SYM (rel->r_info);
861 r_type = ELF32_R_TYPE (rel->r_info);
863 if (r_type == R_LM32_GNU_VTENTRY
864 || r_type == R_LM32_GNU_VTINHERIT )
865 continue;
867 h = NULL;
868 sym = NULL;
869 sec = NULL;
871 howto = lm32_elf_howto_table + r_type;
873 if (r_symndx < symtab_hdr->sh_info)
875 /* It's a local symbol. */
876 sym = local_syms + r_symndx;
877 sec = local_sections[r_symndx];
878 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
879 name = bfd_elf_string_from_elf_section
880 (input_bfd, symtab_hdr->sh_link, sym->st_name);
881 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
883 else
885 /* It's a global symbol. */
886 bfd_boolean unresolved_reloc;
887 bfd_boolean warned;
889 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
890 r_symndx, symtab_hdr, sym_hashes,
891 h, sec, relocation,
892 unresolved_reloc, warned);
893 name = h->root.root.string;
896 if (sec != NULL && elf_discarded_section (sec))
897 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
898 rel, relend, howto, contents);
900 if (info->relocatable)
902 /* This is a relocatable link. We don't have to change
903 anything, unless the reloc is against a section symbol,
904 in which case we have to adjust according to where the
905 section symbol winds up in the output section. */
906 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
907 continue;
909 /* If partial_inplace, we need to store any additional addend
910 back in the section. */
911 if (! howto->partial_inplace)
912 continue;
914 /* Shouldn't reach here. */
915 abort ();
916 r = bfd_reloc_ok;
918 else
920 switch (howto->type)
922 case R_LM32_GPREL16:
923 if (!lm32_elf_assign_gp (output_bfd, &gp))
924 r = bfd_reloc_dangerous;
925 else
927 relocation = relocation + rel->r_addend - gp;
928 rel->r_addend = 0;
929 if ((signed)relocation < -32768 || (signed)relocation > 32767)
930 r = bfd_reloc_outofrange;
931 else
933 r = _bfd_final_link_relocate (howto, input_bfd,
934 input_section, contents,
935 rel->r_offset, relocation,
936 rel->r_addend);
939 break;
940 case R_LM32_16_GOT:
941 /* Relocation is to the entry for this symbol in the global
942 offset table. */
943 BFD_ASSERT (sgot != NULL);
944 if (h != NULL)
946 bfd_boolean dyn;
947 bfd_vma off;
949 off = h->got.offset;
950 BFD_ASSERT (off != (bfd_vma) -1);
952 dyn = htab->root.dynamic_sections_created;
953 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
954 || (info->shared
955 && (info->symbolic
956 || h->dynindx == -1
957 || h->forced_local)
958 && h->def_regular))
960 /* This is actually a static link, or it is a
961 -Bsymbolic link and the symbol is defined
962 locally, or the symbol was forced to be local
963 because of a version file. We must initialize
964 this entry in the global offset table. Since the
965 offset must always be a multiple of 4, we use the
966 least significant bit to record whether we have
967 initialized it already.
969 When doing a dynamic link, we create a .rela.got
970 relocation entry to initialize the value. This
971 is done in the finish_dynamic_symbol routine. */
972 if ((off & 1) != 0)
973 off &= ~1;
974 else
976 /* Write entry in GOT */
977 bfd_put_32 (output_bfd, relocation,
978 sgot->contents + off);
979 /* Create entry in .rofixup pointing to GOT entry. */
980 if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
982 _lm32fdpic_add_rofixup (output_bfd,
983 lm32fdpic_fixup32_section
984 (info),
985 sgot->output_section->vma
986 + sgot->output_offset
987 + off);
989 /* Mark GOT entry as having been written. */
990 h->got.offset |= 1;
994 relocation = sgot->output_offset + off;
996 else
998 bfd_vma off;
999 bfd_byte *loc;
1001 BFD_ASSERT (local_got_offsets != NULL
1002 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1004 /* Get offset into GOT table. */
1005 off = local_got_offsets[r_symndx];
1007 /* The offset must always be a multiple of 4. We use
1008 the least significant bit to record whether we have
1009 already processed this entry. */
1010 if ((off & 1) != 0)
1011 off &= ~1;
1012 else
1014 /* Write entry in GOT. */
1015 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1016 /* Create entry in .rofixup pointing to GOT entry. */
1017 if (IS_FDPIC (output_bfd))
1019 _lm32fdpic_add_rofixup (output_bfd,
1020 lm32fdpic_fixup32_section
1021 (info),
1022 sgot->output_section->vma
1023 + sgot->output_offset
1024 + off);
1027 if (info->shared)
1029 asection *srelgot;
1030 Elf_Internal_Rela outrel;
1032 /* We need to generate a R_LM32_RELATIVE reloc
1033 for the dynamic linker. */
1034 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1035 BFD_ASSERT (srelgot != NULL);
1037 outrel.r_offset = (sgot->output_section->vma
1038 + sgot->output_offset
1039 + off);
1040 outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1041 outrel.r_addend = relocation;
1042 loc = srelgot->contents;
1043 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1044 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1045 ++srelgot->reloc_count;
1048 local_got_offsets[r_symndx] |= 1;
1052 relocation = sgot->output_offset + off;
1055 /* Addend should be zero. */
1056 if (rel->r_addend != 0)
1057 (*_bfd_error_handler) (_("internal error: addend should be zero for R_LM32_16_GOT"));
1059 r = _bfd_final_link_relocate (howto,
1060 input_bfd,
1061 input_section,
1062 contents,
1063 rel->r_offset,
1064 relocation,
1065 rel->r_addend);
1066 break;
1068 case R_LM32_GOTOFF_LO16:
1069 case R_LM32_GOTOFF_HI16:
1070 /* Relocation is offset from GOT. */
1071 BFD_ASSERT (sgot != NULL);
1072 relocation -= sgot->output_section->vma;
1073 /* Account for sign-extension. */
1074 if ((r_type == R_LM32_GOTOFF_HI16)
1075 && ((relocation + rel->r_addend) & 0x8000))
1076 rel->r_addend += 0x10000;
1077 r = _bfd_final_link_relocate (howto,
1078 input_bfd,
1079 input_section,
1080 contents,
1081 rel->r_offset,
1082 relocation,
1083 rel->r_addend);
1084 break;
1086 case R_LM32_32:
1087 if (IS_FDPIC (output_bfd))
1089 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1091 /* Only create .rofixup entries for relocs in loadable sections. */
1092 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1093 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1096 /* Check address to be modified is writable. */
1097 if (_lm32fdpic_osec_readonly_p (output_bfd,
1098 input_section
1099 ->output_section))
1101 info->callbacks->warning
1102 (info,
1103 _("cannot emit dynamic relocations in read-only section"),
1104 name, input_bfd, input_section, rel->r_offset);
1105 return FALSE;
1107 /* Create entry in .rofixup section. */
1108 _lm32fdpic_add_rofixup (output_bfd,
1109 lm32fdpic_fixup32_section (info),
1110 input_section->output_section->vma
1111 + input_section->output_offset
1112 + rel->r_offset);
1116 /* Fall through. */
1118 default:
1119 r = _bfd_final_link_relocate (howto,
1120 input_bfd,
1121 input_section,
1122 contents,
1123 rel->r_offset,
1124 relocation,
1125 rel->r_addend);
1126 break;
1130 if (r != bfd_reloc_ok)
1132 const char *msg = NULL;
1133 arelent bfd_reloc;
1135 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1136 howto = bfd_reloc.howto;
1138 if (h != NULL)
1139 name = h->root.root.string;
1140 else
1142 name = (bfd_elf_string_from_elf_section
1143 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1144 if (name == NULL || *name == '\0')
1145 name = bfd_section_name (input_bfd, sec);
1148 switch (r)
1150 case bfd_reloc_overflow:
1151 if ((h != NULL)
1152 && (h->root.type == bfd_link_hash_undefweak))
1153 break;
1154 if (! ((*info->callbacks->reloc_overflow)
1155 (info, (h ? &h->root : NULL), name, howto->name,
1156 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
1157 return FALSE;
1158 break;
1160 case bfd_reloc_undefined:
1161 if (! ((*info->callbacks->undefined_symbol)
1162 (info, name, input_bfd, input_section,
1163 rel->r_offset, TRUE)))
1164 return FALSE;
1165 break;
1167 case bfd_reloc_outofrange:
1168 msg = _("internal error: out of range error");
1169 goto common_error;
1171 case bfd_reloc_notsupported:
1172 msg = _("internal error: unsupported relocation error");
1173 goto common_error;
1175 case bfd_reloc_dangerous:
1176 msg = _("internal error: dangerous error");
1177 goto common_error;
1179 default:
1180 msg = _("internal error: unknown error");
1181 /* fall through */
1183 common_error:
1184 if (!((*info->callbacks->warning)
1185 (info, msg, name, input_bfd, input_section,
1186 rel->r_offset)))
1187 return FALSE;
1188 break;
1193 return TRUE;
1196 static asection *
1197 lm32_elf_gc_mark_hook (asection *sec,
1198 struct bfd_link_info *info,
1199 Elf_Internal_Rela *rel,
1200 struct elf_link_hash_entry *h,
1201 Elf_Internal_Sym *sym)
1203 if (h != NULL)
1204 switch (ELF32_R_TYPE (rel->r_info))
1206 case R_LM32_GNU_VTINHERIT:
1207 case R_LM32_GNU_VTENTRY:
1208 return NULL;
1211 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1214 static bfd_boolean
1215 lm32_elf_gc_sweep_hook (bfd *abfd,
1216 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1217 asection *sec,
1218 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1220 /* Update the got entry reference counts for the section being removed. */
1221 Elf_Internal_Shdr *symtab_hdr;
1222 struct elf_link_hash_entry **sym_hashes;
1223 bfd_signed_vma *local_got_refcounts;
1224 const Elf_Internal_Rela *rel, *relend;
1226 elf_section_data (sec)->local_dynrel = NULL;
1228 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1229 sym_hashes = elf_sym_hashes (abfd);
1230 local_got_refcounts = elf_local_got_refcounts (abfd);
1232 relend = relocs + sec->reloc_count;
1233 for (rel = relocs; rel < relend; rel++)
1235 unsigned long r_symndx;
1236 struct elf_link_hash_entry *h = NULL;
1238 r_symndx = ELF32_R_SYM (rel->r_info);
1239 if (r_symndx >= symtab_hdr->sh_info)
1241 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1242 while (h->root.type == bfd_link_hash_indirect
1243 || h->root.type == bfd_link_hash_warning)
1244 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1247 switch (ELF32_R_TYPE (rel->r_info))
1249 case R_LM32_16_GOT:
1250 if (h != NULL)
1252 if (h->got.refcount > 0)
1253 h->got.refcount--;
1255 else
1257 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1258 local_got_refcounts[r_symndx]--;
1260 break;
1262 default:
1263 break;
1266 return TRUE;
1269 /* Look through the relocs for a section during the first phase. */
1271 static bfd_boolean
1272 lm32_elf_check_relocs (bfd *abfd,
1273 struct bfd_link_info *info,
1274 asection *sec,
1275 const Elf_Internal_Rela *relocs)
1277 Elf_Internal_Shdr *symtab_hdr;
1278 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1279 const Elf_Internal_Rela *rel;
1280 const Elf_Internal_Rela *rel_end;
1281 struct elf_lm32_link_hash_table *htab;
1282 bfd *dynobj;
1284 if (info->relocatable)
1285 return TRUE;
1287 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1288 sym_hashes = elf_sym_hashes (abfd);
1289 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1290 if (!elf_bad_symtab (abfd))
1291 sym_hashes_end -= symtab_hdr->sh_info;
1293 htab = lm32_elf_hash_table (info);
1294 if (htab == NULL)
1295 return FALSE;
1297 dynobj = htab->root.dynobj;
1299 rel_end = relocs + sec->reloc_count;
1300 for (rel = relocs; rel < rel_end; rel++)
1302 int r_type;
1303 struct elf_link_hash_entry *h;
1304 unsigned long r_symndx;
1306 r_symndx = ELF32_R_SYM (rel->r_info);
1307 r_type = ELF32_R_TYPE (rel->r_info);
1308 if (r_symndx < symtab_hdr->sh_info)
1309 h = NULL;
1310 else
1312 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1313 while (h->root.type == bfd_link_hash_indirect
1314 || h->root.type == bfd_link_hash_warning)
1315 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1318 /* Some relocs require a global offset table. */
1319 if (htab->sgot == NULL)
1321 switch (r_type)
1323 case R_LM32_16_GOT:
1324 case R_LM32_GOTOFF_HI16:
1325 case R_LM32_GOTOFF_LO16:
1326 if (dynobj == NULL)
1327 htab->root.dynobj = dynobj = abfd;
1328 if (! create_got_section (dynobj, info))
1329 return FALSE;
1330 break;
1334 /* Some relocs require a rofixup table. */
1335 if (IS_FDPIC (abfd))
1337 switch (r_type)
1339 case R_LM32_32:
1340 /* FDPIC requires a GOT if there is a .rofixup section
1341 (Normal ELF doesn't). */
1342 if (dynobj == NULL)
1343 htab->root.dynobj = dynobj = abfd;
1344 if (! create_got_section (dynobj, info))
1345 return FALSE;
1346 /* Create .rofixup section */
1347 if (htab->sfixup32 == NULL)
1349 if (! create_rofixup_section (abfd, info))
1350 return FALSE;
1352 break;
1353 case R_LM32_16_GOT:
1354 case R_LM32_GOTOFF_HI16:
1355 case R_LM32_GOTOFF_LO16:
1356 /* Create .rofixup section. */
1357 if (htab->sfixup32 == NULL)
1359 if (! create_rofixup_section (abfd, info))
1360 return FALSE;
1362 break;
1366 switch (r_type)
1368 case R_LM32_16_GOT:
1369 if (h != NULL)
1370 h->got.refcount += 1;
1371 else
1373 bfd_signed_vma *local_got_refcounts;
1375 /* This is a global offset table entry for a local symbol. */
1376 local_got_refcounts = elf_local_got_refcounts (abfd);
1377 if (local_got_refcounts == NULL)
1379 bfd_size_type size;
1381 size = symtab_hdr->sh_info;
1382 size *= sizeof (bfd_signed_vma);
1383 local_got_refcounts = bfd_zalloc (abfd, size);
1384 if (local_got_refcounts == NULL)
1385 return FALSE;
1386 elf_local_got_refcounts (abfd) = local_got_refcounts;
1388 local_got_refcounts[r_symndx] += 1;
1390 break;
1392 /* This relocation describes the C++ object vtable hierarchy.
1393 Reconstruct it for later use during GC. */
1394 case R_LM32_GNU_VTINHERIT:
1395 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1396 return FALSE;
1397 break;
1399 /* This relocation describes which C++ vtable entries are actually
1400 used. Record for later use during GC. */
1401 case R_LM32_GNU_VTENTRY:
1402 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1403 return FALSE;
1404 break;
1409 return TRUE;
1412 /* Finish up the dynamic sections. */
1414 static bfd_boolean
1415 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1416 struct bfd_link_info *info)
1418 struct elf_lm32_link_hash_table *htab;
1419 bfd *dynobj;
1420 asection *sdyn;
1421 asection *sgot;
1423 htab = lm32_elf_hash_table (info);
1424 if (htab == NULL)
1425 return FALSE;
1427 dynobj = htab->root.dynobj;
1429 sgot = htab->sgotplt;
1430 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1432 if (htab->root.dynamic_sections_created)
1434 asection *splt;
1435 Elf32_External_Dyn *dyncon, *dynconend;
1437 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1439 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1440 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1442 for (; dyncon < dynconend; dyncon++)
1444 Elf_Internal_Dyn dyn;
1445 asection *s;
1447 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1449 switch (dyn.d_tag)
1451 default:
1452 break;
1454 case DT_PLTGOT:
1455 s = htab->sgot->output_section;
1456 goto get_vma;
1457 case DT_JMPREL:
1458 s = htab->srelplt->output_section;
1459 get_vma:
1460 BFD_ASSERT (s != NULL);
1461 dyn.d_un.d_ptr = s->vma;
1462 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1463 break;
1465 case DT_PLTRELSZ:
1466 s = htab->srelplt->output_section;
1467 BFD_ASSERT (s != NULL);
1468 dyn.d_un.d_val = s->size;
1469 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1470 break;
1472 case DT_RELASZ:
1473 /* My reading of the SVR4 ABI indicates that the
1474 procedure linkage table relocs (DT_JMPREL) should be
1475 included in the overall relocs (DT_RELA). This is
1476 what Solaris does. However, UnixWare can not handle
1477 that case. Therefore, we override the DT_RELASZ entry
1478 here to make it not include the JMPREL relocs. Since
1479 the linker script arranges for .rela.plt to follow all
1480 other relocation sections, we don't have to worry
1481 about changing the DT_RELA entry. */
1482 if (htab->srelplt != NULL)
1484 s = htab->srelplt->output_section;
1485 dyn.d_un.d_val -= s->size;
1487 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1488 break;
1492 /* Fill in the first entry in the procedure linkage table. */
1493 splt = htab->splt;
1494 if (splt && splt->size > 0)
1496 if (info->shared)
1498 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1499 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1500 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1501 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1502 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1504 else
1506 unsigned long addr;
1507 /* addr = .got + 4 */
1508 addr = sgot->output_section->vma + sgot->output_offset + 4;
1509 bfd_put_32 (output_bfd,
1510 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1511 splt->contents);
1512 bfd_put_32 (output_bfd,
1513 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1514 splt->contents + 4);
1515 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1516 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1517 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1520 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1521 PLT_ENTRY_SIZE;
1525 /* Fill in the first three entries in the global offset table. */
1526 if (sgot && sgot->size > 0)
1528 if (sdyn == NULL)
1529 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1530 else
1531 bfd_put_32 (output_bfd,
1532 sdyn->output_section->vma + sdyn->output_offset,
1533 sgot->contents);
1534 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1535 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1537 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1538 if (elf_section_data (sgot->output_section) != NULL)
1539 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1542 if (lm32fdpic_fixup32_section (info))
1544 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1545 bfd_vma got_value = hgot->root.u.def.value
1546 + hgot->root.u.def.section->output_section->vma
1547 + hgot->root.u.def.section->output_offset;
1548 struct bfd_link_hash_entry *hend;
1550 /* Last entry is pointer to GOT. */
1551 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1553 /* Check we wrote enough entries. */
1554 if (lm32fdpic_fixup32_section (info)->size
1555 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1557 (*_bfd_error_handler)
1558 ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1559 lm32fdpic_fixup32_section (info)->size/4,
1560 lm32fdpic_fixup32_section (info)->reloc_count);
1561 return FALSE;
1564 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1565 FALSE, FALSE, TRUE);
1566 if (hend
1567 && (hend->type == bfd_link_hash_defined
1568 || hend->type == bfd_link_hash_defweak))
1570 bfd_vma value =
1571 lm32fdpic_fixup32_section (info)->output_section->vma
1572 + lm32fdpic_fixup32_section (info)->output_offset
1573 + lm32fdpic_fixup32_section (info)->size
1574 - hend->u.def.section->output_section->vma
1575 - hend->u.def.section->output_offset;
1576 BFD_ASSERT (hend->u.def.value == value);
1577 if (hend->u.def.value != value)
1579 (*_bfd_error_handler)
1580 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1581 return FALSE;
1586 return TRUE;
1589 /* Finish up dynamic symbol handling. We set the contents of various
1590 dynamic sections here. */
1592 static bfd_boolean
1593 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1594 struct bfd_link_info *info,
1595 struct elf_link_hash_entry *h,
1596 Elf_Internal_Sym *sym)
1598 struct elf_lm32_link_hash_table *htab;
1599 bfd_byte *loc;
1601 htab = lm32_elf_hash_table (info);
1602 if (htab == NULL)
1603 return FALSE;
1605 if (h->plt.offset != (bfd_vma) -1)
1607 asection *splt;
1608 asection *sgot;
1609 asection *srela;
1611 bfd_vma plt_index;
1612 bfd_vma got_offset;
1613 Elf_Internal_Rela rela;
1615 /* This symbol has an entry in the procedure linkage table. Set
1616 it up. */
1617 BFD_ASSERT (h->dynindx != -1);
1619 splt = htab->splt;
1620 sgot = htab->sgotplt;
1621 srela = htab->srelplt;
1622 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1624 /* Get the index in the procedure linkage table which
1625 corresponds to this symbol. This is the index of this symbol
1626 in all the symbols for which we are making plt entries. The
1627 first entry in the procedure linkage table is reserved. */
1628 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1630 /* Get the offset into the .got table of the entry that
1631 corresponds to this function. Each .got entry is 4 bytes.
1632 The first three are reserved. */
1633 got_offset = (plt_index + 3) * 4;
1635 /* Fill in the entry in the procedure linkage table. */
1636 if (! info->shared)
1638 /* TODO */
1640 else
1642 /* TODO */
1645 /* Fill in the entry in the global offset table. */
1646 bfd_put_32 (output_bfd,
1647 (splt->output_section->vma
1648 + splt->output_offset
1649 + h->plt.offset
1650 + 12), /* same offset */
1651 sgot->contents + got_offset);
1653 /* Fill in the entry in the .rela.plt section. */
1654 rela.r_offset = (sgot->output_section->vma
1655 + sgot->output_offset
1656 + got_offset);
1657 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1658 rela.r_addend = 0;
1659 loc = srela->contents;
1660 loc += plt_index * sizeof (Elf32_External_Rela);
1661 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1663 if (!h->def_regular)
1665 /* Mark the symbol as undefined, rather than as defined in
1666 the .plt section. Leave the value alone. */
1667 sym->st_shndx = SHN_UNDEF;
1672 if (h->got.offset != (bfd_vma) -1)
1674 asection *sgot;
1675 asection *srela;
1676 Elf_Internal_Rela rela;
1678 /* This symbol has an entry in the global offset table. Set it
1679 up. */
1680 sgot = htab->sgot;
1681 srela = htab->srelgot;
1682 BFD_ASSERT (sgot != NULL && srela != NULL);
1684 rela.r_offset = (sgot->output_section->vma
1685 + sgot->output_offset
1686 + (h->got.offset &~ 1));
1688 /* If this is a -Bsymbolic link, and the symbol is defined
1689 locally, we just want to emit a RELATIVE reloc. Likewise if
1690 the symbol was forced to be local because of a version file.
1691 The entry in the global offset table will already have been
1692 initialized in the relocate_section function. */
1693 if (info->shared
1694 && (info->symbolic
1695 || h->dynindx == -1
1696 || h->forced_local)
1697 && h->def_regular)
1699 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1700 rela.r_addend = (h->root.u.def.value
1701 + h->root.u.def.section->output_section->vma
1702 + h->root.u.def.section->output_offset);
1704 else
1706 BFD_ASSERT ((h->got.offset & 1) == 0);
1707 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1708 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1709 rela.r_addend = 0;
1712 loc = srela->contents;
1713 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1714 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1715 ++srela->reloc_count;
1718 if (h->needs_copy)
1720 asection *s;
1721 Elf_Internal_Rela rela;
1723 /* This symbols needs a copy reloc. Set it up. */
1724 BFD_ASSERT (h->dynindx != -1
1725 && (h->root.type == bfd_link_hash_defined
1726 || h->root.type == bfd_link_hash_defweak));
1728 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1729 ".rela.bss");
1730 BFD_ASSERT (s != NULL);
1732 rela.r_offset = (h->root.u.def.value
1733 + h->root.u.def.section->output_section->vma
1734 + h->root.u.def.section->output_offset);
1735 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1736 rela.r_addend = 0;
1737 loc = s->contents;
1738 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1739 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1740 ++s->reloc_count;
1743 /* Mark some specially defined symbols as absolute. */
1744 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1745 || h == htab->root.hgot)
1746 sym->st_shndx = SHN_ABS;
1748 return TRUE;
1751 static enum elf_reloc_type_class
1752 lm32_elf_reloc_type_class (const Elf_Internal_Rela *rela)
1754 switch ((int) ELF32_R_TYPE (rela->r_info))
1756 case R_LM32_RELATIVE: return reloc_class_relative;
1757 case R_LM32_JMP_SLOT: return reloc_class_plt;
1758 case R_LM32_COPY: return reloc_class_copy;
1759 default: return reloc_class_normal;
1763 /* Adjust a symbol defined by a dynamic object and referenced by a
1764 regular object. The current definition is in some section of the
1765 dynamic object, but we're not including those sections. We have to
1766 change the definition to something the rest of the link can
1767 understand. */
1769 static bfd_boolean
1770 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1771 struct elf_link_hash_entry *h)
1773 struct elf_lm32_link_hash_table *htab;
1774 struct elf_lm32_link_hash_entry *eh;
1775 struct elf_lm32_dyn_relocs *p;
1776 bfd *dynobj;
1777 asection *s;
1779 dynobj = elf_hash_table (info)->dynobj;
1781 /* Make sure we know what is going on here. */
1782 BFD_ASSERT (dynobj != NULL
1783 && (h->needs_plt
1784 || h->u.weakdef != NULL
1785 || (h->def_dynamic
1786 && h->ref_regular
1787 && !h->def_regular)));
1789 /* If this is a function, put it in the procedure linkage table. We
1790 will fill in the contents of the procedure linkage table later,
1791 when we know the address of the .got section. */
1792 if (h->type == STT_FUNC
1793 || h->needs_plt)
1795 if (! info->shared
1796 && !h->def_dynamic
1797 && !h->ref_dynamic
1798 && h->root.type != bfd_link_hash_undefweak
1799 && h->root.type != bfd_link_hash_undefined)
1801 /* This case can occur if we saw a PLT reloc in an input
1802 file, but the symbol was never referred to by a dynamic
1803 object. In such a case, we don't actually need to build
1804 a procedure linkage table, and we can just do a PCREL
1805 reloc instead. */
1806 h->plt.offset = (bfd_vma) -1;
1807 h->needs_plt = 0;
1810 return TRUE;
1812 else
1813 h->plt.offset = (bfd_vma) -1;
1815 /* If this is a weak symbol, and there is a real definition, the
1816 processor independent code will have arranged for us to see the
1817 real definition first, and we can just use the same value. */
1818 if (h->u.weakdef != NULL)
1820 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1821 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1822 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1823 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1824 return TRUE;
1827 /* This is a reference to a symbol defined by a dynamic object which
1828 is not a function. */
1830 /* If we are creating a shared library, we must presume that the
1831 only references to the symbol are via the global offset table.
1832 For such cases we need not do anything here; the relocations will
1833 be handled correctly by relocate_section. */
1834 if (info->shared)
1835 return TRUE;
1837 /* If there are no references to this symbol that do not use the
1838 GOT, we don't need to generate a copy reloc. */
1839 if (!h->non_got_ref)
1840 return TRUE;
1842 /* If -z nocopyreloc was given, we won't generate them either. */
1843 if (info->nocopyreloc)
1845 h->non_got_ref = 0;
1846 return TRUE;
1849 eh = (struct elf_lm32_link_hash_entry *) h;
1850 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1852 s = p->sec->output_section;
1853 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1854 break;
1857 /* If we didn't find any dynamic relocs in sections which needs the
1858 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1859 the copy reloc. */
1860 if (p == NULL)
1862 h->non_got_ref = 0;
1863 return TRUE;
1866 if (h->size == 0)
1868 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1869 h->root.root.string);
1870 return TRUE;
1873 /* We must allocate the symbol in our .dynbss section, which will
1874 become part of the .bss section of the executable. There will be
1875 an entry for this symbol in the .dynsym section. The dynamic
1876 object will contain position independent code, so all references
1877 from the dynamic object to this symbol will go through the global
1878 offset table. The dynamic linker will use the .dynsym entry to
1879 determine the address it must put in the global offset table, so
1880 both the dynamic object and the regular object will refer to the
1881 same memory location for the variable. */
1883 htab = lm32_elf_hash_table (info);
1884 if (htab == NULL)
1885 return FALSE;
1887 s = htab->sdynbss;
1888 BFD_ASSERT (s != NULL);
1890 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1891 to copy the initial value out of the dynamic object and into the
1892 runtime process image. We need to remember the offset into the
1893 .rela.bss section we are going to use. */
1894 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1896 asection *srel;
1898 srel = htab->srelbss;
1899 BFD_ASSERT (srel != NULL);
1900 srel->size += sizeof (Elf32_External_Rela);
1901 h->needs_copy = 1;
1904 return _bfd_elf_adjust_dynamic_copy (h, s);
1907 /* Allocate space in .plt, .got and associated reloc sections for
1908 dynamic relocs. */
1910 static bfd_boolean
1911 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1913 struct bfd_link_info *info;
1914 struct elf_lm32_link_hash_table *htab;
1915 struct elf_lm32_link_hash_entry *eh;
1916 struct elf_lm32_dyn_relocs *p;
1918 if (h->root.type == bfd_link_hash_indirect)
1919 return TRUE;
1921 if (h->root.type == bfd_link_hash_warning)
1922 /* When warning symbols are created, they **replace** the "real"
1923 entry in the hash table, thus we never get to see the real
1924 symbol in a hash traversal. So look at it now. */
1925 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1927 info = (struct bfd_link_info *) inf;
1928 htab = lm32_elf_hash_table (info);
1929 if (htab == NULL)
1930 return FALSE;
1932 eh = (struct elf_lm32_link_hash_entry *) h;
1934 if (htab->root.dynamic_sections_created
1935 && h->plt.refcount > 0)
1937 /* Make sure this symbol is output as a dynamic symbol.
1938 Undefined weak syms won't yet be marked as dynamic. */
1939 if (h->dynindx == -1
1940 && !h->forced_local)
1942 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1943 return FALSE;
1946 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1948 asection *s = htab->splt;
1950 /* If this is the first .plt entry, make room for the special
1951 first entry. */
1952 if (s->size == 0)
1953 s->size += PLT_ENTRY_SIZE;
1955 h->plt.offset = s->size;
1957 /* If this symbol is not defined in a regular file, and we are
1958 not generating a shared library, then set the symbol to this
1959 location in the .plt. This is required to make function
1960 pointers compare as equal between the normal executable and
1961 the shared library. */
1962 if (! info->shared
1963 && !h->def_regular)
1965 h->root.u.def.section = s;
1966 h->root.u.def.value = h->plt.offset;
1969 /* Make room for this entry. */
1970 s->size += PLT_ENTRY_SIZE;
1972 /* We also need to make an entry in the .got.plt section, which
1973 will be placed in the .got section by the linker script. */
1974 htab->sgotplt->size += 4;
1976 /* We also need to make an entry in the .rel.plt section. */
1977 htab->srelplt->size += sizeof (Elf32_External_Rela);
1979 else
1981 h->plt.offset = (bfd_vma) -1;
1982 h->needs_plt = 0;
1985 else
1987 h->plt.offset = (bfd_vma) -1;
1988 h->needs_plt = 0;
1991 if (h->got.refcount > 0)
1993 asection *s;
1994 bfd_boolean dyn;
1996 /* Make sure this symbol is output as a dynamic symbol.
1997 Undefined weak syms won't yet be marked as dynamic. */
1998 if (h->dynindx == -1
1999 && !h->forced_local)
2001 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2002 return FALSE;
2005 s = htab->sgot;
2007 h->got.offset = s->size;
2008 s->size += 4;
2009 dyn = htab->root.dynamic_sections_created;
2010 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2011 htab->srelgot->size += sizeof (Elf32_External_Rela);
2013 else
2014 h->got.offset = (bfd_vma) -1;
2016 if (eh->dyn_relocs == NULL)
2017 return TRUE;
2019 /* In the shared -Bsymbolic case, discard space allocated for
2020 dynamic pc-relative relocs against symbols which turn out to be
2021 defined in regular objects. For the normal shared case, discard
2022 space for pc-relative relocs that have become local due to symbol
2023 visibility changes. */
2025 if (info->shared)
2027 if (h->def_regular
2028 && (h->forced_local
2029 || info->symbolic))
2031 struct elf_lm32_dyn_relocs **pp;
2033 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2035 p->count -= p->pc_count;
2036 p->pc_count = 0;
2037 if (p->count == 0)
2038 *pp = p->next;
2039 else
2040 pp = &p->next;
2044 /* Also discard relocs on undefined weak syms with non-default
2045 visibility. */
2046 if (eh->dyn_relocs != NULL
2047 && h->root.type == bfd_link_hash_undefweak)
2049 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2050 eh->dyn_relocs = NULL;
2052 /* Make sure undefined weak symbols are output as a dynamic
2053 symbol in PIEs. */
2054 else if (h->dynindx == -1
2055 && !h->forced_local)
2057 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2058 return FALSE;
2062 else
2064 /* For the non-shared case, discard space for relocs against
2065 symbols which turn out to need copy relocs or are not
2066 dynamic. */
2068 if (!h->non_got_ref
2069 && ((h->def_dynamic
2070 && !h->def_regular)
2071 || (htab->root.dynamic_sections_created
2072 && (h->root.type == bfd_link_hash_undefweak
2073 || h->root.type == bfd_link_hash_undefined))))
2075 /* Make sure this symbol is output as a dynamic symbol.
2076 Undefined weak syms won't yet be marked as dynamic. */
2077 if (h->dynindx == -1
2078 && !h->forced_local)
2080 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2081 return FALSE;
2084 /* If that succeeded, we know we'll be keeping all the
2085 relocs. */
2086 if (h->dynindx != -1)
2087 goto keep;
2090 eh->dyn_relocs = NULL;
2092 keep: ;
2095 /* Finally, allocate space. */
2096 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2098 asection *sreloc = elf_section_data (p->sec)->sreloc;
2099 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2102 return TRUE;
2105 /* Find any dynamic relocs that apply to read-only sections. */
2107 static bfd_boolean
2108 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2110 struct elf_lm32_link_hash_entry *eh;
2111 struct elf_lm32_dyn_relocs *p;
2113 if (h->root.type == bfd_link_hash_warning)
2114 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2116 eh = (struct elf_lm32_link_hash_entry *) h;
2117 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2119 asection *s = p->sec->output_section;
2121 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2123 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2125 info->flags |= DF_TEXTREL;
2127 /* Not an error, just cut short the traversal. */
2128 return FALSE;
2131 return TRUE;
2134 /* Set the sizes of the dynamic sections. */
2136 static bfd_boolean
2137 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2138 struct bfd_link_info *info)
2140 struct elf_lm32_link_hash_table *htab;
2141 bfd *dynobj;
2142 asection *s;
2143 bfd_boolean relocs;
2144 bfd *ibfd;
2146 htab = lm32_elf_hash_table (info);
2147 if (htab == NULL)
2148 return FALSE;
2150 dynobj = htab->root.dynobj;
2151 BFD_ASSERT (dynobj != NULL);
2153 if (htab->root.dynamic_sections_created)
2155 /* Set the contents of the .interp section to the interpreter. */
2156 if (info->executable)
2158 s = bfd_get_section_by_name (dynobj, ".interp");
2159 BFD_ASSERT (s != NULL);
2160 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2161 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2165 /* Set up .got offsets for local syms, and space for local dynamic
2166 relocs. */
2167 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2169 bfd_signed_vma *local_got;
2170 bfd_signed_vma *end_local_got;
2171 bfd_size_type locsymcount;
2172 Elf_Internal_Shdr *symtab_hdr;
2173 asection *srel;
2175 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2176 continue;
2178 for (s = ibfd->sections; s != NULL; s = s->next)
2180 struct elf_lm32_dyn_relocs *p;
2182 for (p = ((struct elf_lm32_dyn_relocs *)
2183 elf_section_data (s)->local_dynrel);
2184 p != NULL;
2185 p = p->next)
2187 if (! bfd_is_abs_section (p->sec)
2188 && bfd_is_abs_section (p->sec->output_section))
2190 /* Input section has been discarded, either because
2191 it is a copy of a linkonce section or due to
2192 linker script /DISCARD/, so we'll be discarding
2193 the relocs too. */
2195 else if (p->count != 0)
2197 srel = elf_section_data (p->sec)->sreloc;
2198 srel->size += p->count * sizeof (Elf32_External_Rela);
2199 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2200 info->flags |= DF_TEXTREL;
2205 local_got = elf_local_got_refcounts (ibfd);
2206 if (!local_got)
2207 continue;
2209 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2210 locsymcount = symtab_hdr->sh_info;
2211 end_local_got = local_got + locsymcount;
2212 s = htab->sgot;
2213 srel = htab->srelgot;
2214 for (; local_got < end_local_got; ++local_got)
2216 if (*local_got > 0)
2218 *local_got = s->size;
2219 s->size += 4;
2220 if (info->shared)
2221 srel->size += sizeof (Elf32_External_Rela);
2223 else
2224 *local_got = (bfd_vma) -1;
2228 /* Allocate global sym .plt and .got entries, and space for global
2229 sym dynamic relocs. */
2230 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2232 /* We now have determined the sizes of the various dynamic sections.
2233 Allocate memory for them. */
2234 relocs = FALSE;
2235 for (s = dynobj->sections; s != NULL; s = s->next)
2237 if ((s->flags & SEC_LINKER_CREATED) == 0)
2238 continue;
2240 if (s == htab->splt
2241 || s == htab->sgot
2242 || s == htab->sgotplt
2243 || s == htab->sdynbss)
2245 /* Strip this section if we don't need it; see the
2246 comment below. */
2248 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2250 if (s->size != 0 && s != htab->srelplt)
2251 relocs = TRUE;
2253 /* We use the reloc_count field as a counter if we need
2254 to copy relocs into the output file. */
2255 s->reloc_count = 0;
2257 else
2258 /* It's not one of our sections, so don't allocate space. */
2259 continue;
2261 if (s->size == 0)
2263 /* If we don't need this section, strip it from the
2264 output file. This is mostly to handle .rela.bss and
2265 .rela.plt. We must create both sections in
2266 create_dynamic_sections, because they must be created
2267 before the linker maps input sections to output
2268 sections. The linker does that before
2269 adjust_dynamic_symbol is called, and it is that
2270 function which decides whether anything needs to go
2271 into these sections. */
2272 s->flags |= SEC_EXCLUDE;
2273 continue;
2276 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2277 continue;
2279 /* Allocate memory for the section contents. We use bfd_zalloc
2280 here in case unused entries are not reclaimed before the
2281 section's contents are written out. This should not happen,
2282 but this way if it does, we get a R_LM32_NONE reloc instead
2283 of garbage. */
2284 s->contents = bfd_zalloc (dynobj, s->size);
2285 if (s->contents == NULL)
2286 return FALSE;
2289 if (htab->root.dynamic_sections_created)
2291 /* Add some entries to the .dynamic section. We fill in the
2292 values later, in lm32_elf_finish_dynamic_sections, but we
2293 must add the entries now so that we get the correct size for
2294 the .dynamic section. The DT_DEBUG entry is filled in by the
2295 dynamic linker and used by the debugger. */
2296 #define add_dynamic_entry(TAG, VAL) \
2297 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2299 if (info->executable)
2301 if (! add_dynamic_entry (DT_DEBUG, 0))
2302 return FALSE;
2305 if (htab->splt->size != 0)
2307 if (! add_dynamic_entry (DT_PLTGOT, 0)
2308 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2309 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2310 || ! add_dynamic_entry (DT_JMPREL, 0))
2311 return FALSE;
2314 if (relocs)
2316 if (! add_dynamic_entry (DT_RELA, 0)
2317 || ! add_dynamic_entry (DT_RELASZ, 0)
2318 || ! add_dynamic_entry (DT_RELAENT,
2319 sizeof (Elf32_External_Rela)))
2320 return FALSE;
2322 /* If any dynamic relocs apply to a read-only section,
2323 then we need a DT_TEXTREL entry. */
2324 if ((info->flags & DF_TEXTREL) == 0)
2325 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2326 info);
2328 if ((info->flags & DF_TEXTREL) != 0)
2330 if (! add_dynamic_entry (DT_TEXTREL, 0))
2331 return FALSE;
2335 #undef add_dynamic_entry
2337 /* Allocate .rofixup section. */
2338 if (IS_FDPIC (output_bfd))
2340 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2341 int rgot_weak_count = 0;
2342 int r32_count = 0;
2343 int rgot_count = 0;
2344 /* Look for deleted sections. */
2345 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2347 for (s = ibfd->sections; s != NULL; s = s->next)
2349 if (s->reloc_count)
2351 /* Count relocs that need .rofixup entires. */
2352 Elf_Internal_Rela *internal_relocs, *end;
2353 internal_relocs = elf_section_data (s)->relocs;
2354 if (internal_relocs == NULL)
2355 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2356 if (internal_relocs != NULL)
2358 end = internal_relocs + s->reloc_count;
2359 while (internal_relocs < end)
2361 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2362 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2363 unsigned long r_symndx;
2364 struct elf_link_hash_entry *h;
2366 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2367 sym_hashes = elf_sym_hashes (ibfd);
2368 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2369 h = NULL;
2370 if (r_symndx < symtab_hdr->sh_info)
2373 else
2375 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2376 while (h->root.type == bfd_link_hash_indirect
2377 || h->root.type == bfd_link_hash_warning)
2378 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2381 /* Don't generate entries for weak symbols. */
2382 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2384 if (!elf_discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2386 switch (ELF32_R_TYPE (internal_relocs->r_info))
2388 case R_LM32_32:
2389 r32_count++;
2390 break;
2391 case R_LM32_16_GOT:
2392 rgot_count++;
2393 break;
2397 else
2399 struct weak_symbol_list *current, *new_entry;
2400 /* Is this symbol already in the list? */
2401 for (current = list_start; current; current = current->next)
2403 if (!strcmp (current->name, h->root.root.string))
2404 break;
2406 if (!current && !elf_discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2408 /* Will this have an entry in the GOT. */
2409 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2411 /* Create a new entry. */
2412 new_entry = malloc (sizeof (struct weak_symbol_list));
2413 if (!new_entry)
2414 return FALSE;
2415 new_entry->name = h->root.root.string;
2416 new_entry->next = NULL;
2417 /* Add to list */
2418 if (list_start == NULL)
2420 list_start = new_entry;
2421 list_end = new_entry;
2423 else
2425 list_end->next = new_entry;
2426 list_end = new_entry;
2428 /* Increase count of undefined weak symbols in the got. */
2429 rgot_weak_count++;
2433 internal_relocs++;
2436 else
2437 return FALSE;
2441 /* Free list. */
2442 while (list_start)
2444 list_end = list_start->next;
2445 free (list_start);
2446 list_start = list_end;
2449 /* Size sections. */
2450 lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2451 if (lm32fdpic_fixup32_section (info)->size == 0)
2452 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2453 else
2455 lm32fdpic_fixup32_section (info)->contents =
2456 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2457 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2458 return FALSE;
2462 return TRUE;
2465 /* Create dynamic sections when linking against a dynamic object. */
2467 static bfd_boolean
2468 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2470 struct elf_lm32_link_hash_table *htab;
2471 flagword flags, pltflags;
2472 asection *s;
2473 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2474 int ptralign = 2; /* 32bit */
2476 htab = lm32_elf_hash_table (info);
2477 if (htab == NULL)
2478 return FALSE;
2480 /* Make sure we have a GOT - For the case where we have a dynamic object
2481 but none of the relocs in check_relocs */
2482 if (! create_got_section (abfd, info))
2483 return FALSE;
2484 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2486 if (! create_rofixup_section (abfd, info))
2487 return FALSE;
2490 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2491 .rel[a].bss sections. */
2492 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2493 | SEC_LINKER_CREATED);
2495 pltflags = flags;
2496 pltflags |= SEC_CODE;
2497 if (bed->plt_not_loaded)
2498 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2499 if (bed->plt_readonly)
2500 pltflags |= SEC_READONLY;
2502 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
2503 htab->splt = s;
2504 if (s == NULL
2505 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2506 return FALSE;
2508 if (bed->want_plt_sym)
2510 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2511 .plt section. */
2512 struct bfd_link_hash_entry *bh = NULL;
2513 struct elf_link_hash_entry *h;
2515 if (! (_bfd_generic_link_add_one_symbol
2516 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2517 (bfd_vma) 0, NULL, FALSE,
2518 get_elf_backend_data (abfd)->collect, &bh)))
2519 return FALSE;
2520 h = (struct elf_link_hash_entry *) bh;
2521 h->def_regular = 1;
2522 h->type = STT_OBJECT;
2523 htab->root.hplt = h;
2525 if (info->shared
2526 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2527 return FALSE;
2530 s = bfd_make_section_with_flags (abfd,
2531 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
2532 flags | SEC_READONLY);
2533 htab->srelplt = s;
2534 if (s == NULL
2535 || ! bfd_set_section_alignment (abfd, s, ptralign))
2536 return FALSE;
2538 if (htab->sgot == NULL
2539 && ! create_got_section (abfd, info))
2540 return FALSE;
2543 const char *secname;
2544 char *relname;
2545 flagword secflags;
2546 asection *sec;
2548 for (sec = abfd->sections; sec; sec = sec->next)
2550 secflags = bfd_get_section_flags (abfd, sec);
2551 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
2552 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
2553 continue;
2554 secname = bfd_get_section_name (abfd, sec);
2555 relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
2556 strcpy (relname, ".rela");
2557 strcat (relname, secname);
2558 if (bfd_get_section_by_name (abfd, secname))
2559 continue;
2560 s = bfd_make_section_with_flags (abfd, relname,
2561 flags | SEC_READONLY);
2562 if (s == NULL
2563 || ! bfd_set_section_alignment (abfd, s, ptralign))
2564 return FALSE;
2568 if (bed->want_dynbss)
2570 /* The .dynbss section is a place to put symbols which are defined
2571 by dynamic objects, are referenced by regular objects, and are
2572 not functions. We must allocate space for them in the process
2573 image and use a R_*_COPY reloc to tell the dynamic linker to
2574 initialize them at run time. The linker script puts the .dynbss
2575 section into the .bss section of the final image. */
2576 s = bfd_make_section_with_flags (abfd, ".dynbss",
2577 SEC_ALLOC | SEC_LINKER_CREATED);
2578 htab->sdynbss = s;
2579 if (s == NULL)
2580 return FALSE;
2581 /* The .rel[a].bss section holds copy relocs. This section is not
2582 normally needed. We need to create it here, though, so that the
2583 linker will map it to an output section. We can't just create it
2584 only if we need it, because we will not know whether we need it
2585 until we have seen all the input files, and the first time the
2586 main linker code calls BFD after examining all the input files
2587 (size_dynamic_sections) the input sections have already been
2588 mapped to the output sections. If the section turns out not to
2589 be needed, we can discard it later. We will never need this
2590 section when generating a shared object, since they do not use
2591 copy relocs. */
2592 if (! info->shared)
2594 s = bfd_make_section_with_flags (abfd,
2595 (bed->default_use_rela_p
2596 ? ".rela.bss" : ".rel.bss"),
2597 flags | SEC_READONLY);
2598 htab->srelbss = s;
2599 if (s == NULL
2600 || ! bfd_set_section_alignment (abfd, s, ptralign))
2601 return FALSE;
2605 return TRUE;
2608 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2610 static void
2611 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2612 struct elf_link_hash_entry *dir,
2613 struct elf_link_hash_entry *ind)
2615 struct elf_lm32_link_hash_entry * edir;
2616 struct elf_lm32_link_hash_entry * eind;
2618 edir = (struct elf_lm32_link_hash_entry *) dir;
2619 eind = (struct elf_lm32_link_hash_entry *) ind;
2621 if (eind->dyn_relocs != NULL)
2623 if (edir->dyn_relocs != NULL)
2625 struct elf_lm32_dyn_relocs **pp;
2626 struct elf_lm32_dyn_relocs *p;
2628 /* Add reloc counts against the indirect sym to the direct sym
2629 list. Merge any entries against the same section. */
2630 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2632 struct elf_lm32_dyn_relocs *q;
2634 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2635 if (q->sec == p->sec)
2637 q->pc_count += p->pc_count;
2638 q->count += p->count;
2639 *pp = p->next;
2640 break;
2642 if (q == NULL)
2643 pp = &p->next;
2645 *pp = edir->dyn_relocs;
2648 edir->dyn_relocs = eind->dyn_relocs;
2649 eind->dyn_relocs = NULL;
2652 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2655 static bfd_boolean
2656 lm32_elf_always_size_sections (bfd *output_bfd,
2657 struct bfd_link_info *info)
2659 if (!info->relocatable)
2661 struct elf_link_hash_entry *h;
2663 /* Force a PT_GNU_STACK segment to be created. */
2664 if (! elf_tdata (output_bfd)->stack_flags)
2665 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
2667 /* Define __stacksize if it's not defined yet. */
2668 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2669 FALSE, FALSE, FALSE);
2670 if (! h || h->root.type != bfd_link_hash_defined
2671 || h->type != STT_OBJECT
2672 || !h->def_regular)
2674 struct bfd_link_hash_entry *bh = NULL;
2676 if (!(_bfd_generic_link_add_one_symbol
2677 (info, output_bfd, "__stacksize",
2678 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
2679 (const char *) NULL, FALSE,
2680 get_elf_backend_data (output_bfd)->collect, &bh)))
2681 return FALSE;
2683 h = (struct elf_link_hash_entry *) bh;
2684 h->def_regular = 1;
2685 h->type = STT_OBJECT;
2686 /* This one must NOT be hidden. */
2690 return TRUE;
2693 static bfd_boolean
2694 lm32_elf_modify_segment_map (bfd *output_bfd,
2695 struct bfd_link_info *info)
2697 struct elf_segment_map *m;
2699 /* objcopy and strip preserve what's already there using elf32_lm32fdpic_copy_
2700 private_bfd_data (). */
2701 if (! info)
2702 return TRUE;
2704 for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
2705 if (m->p_type == PT_GNU_STACK)
2706 break;
2708 if (m)
2710 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2711 struct elf_link_hash_entry *h;
2713 if (sec)
2715 /* Obtain the pointer to the __stacksize symbol. */
2716 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2717 FALSE, FALSE, FALSE);
2718 while (h->root.type == bfd_link_hash_indirect
2719 || h->root.type == bfd_link_hash_warning)
2720 h = (struct elf_link_hash_entry *)h->root.u.i.link;
2721 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2723 /* Set the section size from the symbol value. We
2724 intentionally ignore the symbol section. */
2725 if (h->root.type == bfd_link_hash_defined)
2726 sec->size = h->root.u.def.value;
2727 else
2728 sec->size = DEFAULT_STACK_SIZE;
2730 /* Add the stack section to the PT_GNU_STACK segment,
2731 such that its size and alignment requirements make it
2732 to the segment. */
2733 m->sections[m->count] = sec;
2734 m->count++;
2738 return TRUE;
2741 static bfd_boolean
2742 lm32_elf_modify_program_headers (bfd *output_bfd,
2743 struct bfd_link_info *info)
2745 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
2746 struct elf_segment_map *m;
2747 Elf_Internal_Phdr *p;
2749 if (! info)
2750 return TRUE;
2752 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
2753 if (m->p_type == PT_GNU_STACK)
2754 break;
2756 if (m)
2758 struct elf_link_hash_entry *h;
2760 /* Obtain the pointer to the __stacksize symbol. */
2761 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2762 FALSE, FALSE, FALSE);
2763 if (h)
2765 while (h->root.type == bfd_link_hash_indirect
2766 || h->root.type == bfd_link_hash_warning)
2767 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2768 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2771 /* Set the header p_memsz from the symbol value. We
2772 intentionally ignore the symbol section. */
2773 if (h && h->root.type == bfd_link_hash_defined)
2774 p->p_memsz = h->root.u.def.value;
2775 else
2776 p->p_memsz = DEFAULT_STACK_SIZE;
2778 p->p_align = 8;
2781 return TRUE;
2785 static bfd_boolean
2786 lm32_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2788 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2789 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2790 return TRUE;
2792 BFD_ASSERT (!elf_flags_init (obfd)
2793 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
2795 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2796 elf_flags_init (obfd) = TRUE;
2798 /* Copy object attributes. */
2799 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2801 return TRUE;
2805 static bfd_boolean
2806 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2808 unsigned i;
2810 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2811 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2812 return TRUE;
2814 if (! lm32_elf_copy_private_bfd_data (ibfd, obfd))
2815 return FALSE;
2817 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2818 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2819 return TRUE;
2821 /* Copy the stack size. */
2822 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2823 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2825 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2827 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2828 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2830 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2832 /* Rewrite the phdrs, since we're only called after they were first written. */
2833 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2834 ->s->sizeof_ehdr, SEEK_SET) != 0
2835 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2836 elf_elfheader (obfd)->e_phnum) != 0)
2837 return FALSE;
2838 break;
2841 break;
2844 return TRUE;
2848 #define ELF_ARCH bfd_arch_lm32
2849 #define ELF_TARGET_ID LM32_ELF_DATA
2850 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2851 #define ELF_MAXPAGESIZE 0x1000
2853 #define TARGET_BIG_SYM bfd_elf32_lm32_vec
2854 #define TARGET_BIG_NAME "elf32-lm32"
2856 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2857 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2858 #define elf_info_to_howto lm32_info_to_howto_rela
2859 #define elf_info_to_howto_rel 0
2860 #define elf_backend_rela_normal 1
2861 #define elf_backend_object_p lm32_elf_object_p
2862 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2863 #define elf_backend_can_gc_sections 1
2864 #define elf_backend_can_refcount 1
2865 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2866 #define elf_backend_gc_sweep_hook lm32_elf_gc_sweep_hook
2867 #define elf_backend_plt_readonly 1
2868 #define elf_backend_want_got_plt 1
2869 #define elf_backend_want_plt_sym 0
2870 #define elf_backend_got_header_size 12
2871 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2872 #define elf_backend_check_relocs lm32_elf_check_relocs
2873 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2874 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2875 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2876 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2877 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2878 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2879 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2880 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2881 #define elf_backend_relocate_section lm32_elf_relocate_section
2883 #include "elf32-target.h"
2885 #undef ELF_MAXPAGESIZE
2886 #define ELF_MAXPAGESIZE 0x4000
2889 #undef TARGET_BIG_SYM
2890 #define TARGET_BIG_SYM bfd_elf32_lm32fdpic_vec
2891 #undef TARGET_BIG_NAME
2892 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2893 #undef elf32_bed
2894 #define elf32_bed elf32_lm32fdpic_bed
2896 #undef elf_backend_always_size_sections
2897 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2898 #undef elf_backend_modify_segment_map
2899 #define elf_backend_modify_segment_map lm32_elf_modify_segment_map
2900 #undef elf_backend_modify_program_headers
2901 #define elf_backend_modify_program_headers lm32_elf_modify_program_headers
2902 #undef bfd_elf32_bfd_copy_private_bfd_data
2903 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2905 #include "elf32-target.h"