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