]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - bfd/elf32-lm32.c
projects / thirdparty / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* gdb.texinfo (Index Section Format): Update for version 7.
[thirdparty/binutils-gdb.git] / bfd / elf32-lm32.c
CommitLineData
84e94c90 1/* Lattice Mico32-specific support for 32-bit ELF
1d7e9d18 2 Copyright 2008, 2009, 2010, 2011, 2012 Free Software Foundation, Inc.
84e94c90
NC		 3 Contributed by Jon Beniston <jon@beniston.com>
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
84e94c90 22#include "sysdep.h"
691bf19c 23#include "bfd.h"
84e94c90
NC		 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) \
4dfe6ac6
NC		 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)
84e94c90
NC		 107
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)
114
115struct weak_symbol_list
116{
117 const char *name;
118 struct weak_symbol_list *next;
119};
120
121/* Create an entry in an lm32 ELF linker hash table. */
122
123static struct bfd_hash_entry *
124lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
125 struct bfd_hash_table *table,
126 const char *string)
127{
128 struct elf_lm32_link_hash_entry *ret =
129 (struct elf_lm32_link_hash_entry *) entry;
130
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;
138
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)
144 {
145 struct elf_lm32_link_hash_entry *eh;
146
147 eh = (struct elf_lm32_link_hash_entry *) ret;
148 eh->dyn_relocs = NULL;
149 }
150
151 return (struct bfd_hash_entry *) ret;
152}
153
154/* Create an lm32 ELF linker hash table. */
155
156static struct bfd_link_hash_table *
157lm32_elf_link_hash_table_create (bfd *abfd)
158{
159 struct elf_lm32_link_hash_table *ret;
160 bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
161
162 ret = bfd_malloc (amt);
163 if (ret == NULL)
164 return NULL;
165
166 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
167 lm32_elf_link_hash_newfunc,
4dfe6ac6
NC		 168 sizeof (struct elf_lm32_link_hash_entry),
169 LM32_ELF_DATA))
84e94c90
NC		 170 {
171 free (ret);
172 return NULL;
173 }
174
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;
184
185 return &ret->root.root;
186}
187
188/* Add a fixup to the ROFIXUP section. */
189
190static bfd_vma
191_lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
192{
193 bfd_vma fixup_offset;
194
195 if (rofixup->flags & SEC_EXCLUDE)
196 return -1;
197
198 fixup_offset = rofixup->reloc_count * 4;
199 if (rofixup->contents)
200 {
201 BFD_ASSERT (fixup_offset < rofixup->size);
202 if (fixup_offset < rofixup->size)
203 bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
204 }
205 rofixup->reloc_count++;
206
207 return fixup_offset;
208}
209
210/* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
211 shortcuts to them in our hash table. */
212
213static bfd_boolean
214create_got_section (bfd *dynobj, struct bfd_link_info *info)
215{
216 struct elf_lm32_link_hash_table *htab;
217 asection *s;
218
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;
223
4dfe6ac6
NC		 224 htab = lm32_elf_hash_table (info);
225 if (htab == NULL)
226 return FALSE;
227
84e94c90
NC		 228 if (! _bfd_elf_create_got_section (dynobj, info))
229 return FALSE;
230
84e94c90
NC		 231 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
232 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
64e77c6d
L		 233 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
234 if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
84e94c90
NC		 235 abort ();
236
84e94c90
NC		 237 return TRUE;
238}
239
240/* Create .rofixup sections in DYNOBJ, and set up
241 shortcuts to them in our hash table. */
242
243static bfd_boolean
244create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
245{
246 struct elf_lm32_link_hash_table *htab;
247 htab = lm32_elf_hash_table (info);
248
4dfe6ac6
NC		 249 if (htab == NULL)
250 return FALSE;
251
252 /* Fixup section for R_LM32_32 relocs. */
84e94c90
NC		 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;
264
265 return TRUE;
266}
267
268static reloc_howto_type lm32_elf_howto_table [] =
269{
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 */
284
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 */
299
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 */
314
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 */
329
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 */
343
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 */
357
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 */
371
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 */
385
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 */
399
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 */
414
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 */
429
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 */
443
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 */
457
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 */
471
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 */
485
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 */
499
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 */
513
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 */
527
528};
529
530/* Map BFD reloc types to lm32 ELF reloc types. */
531
532struct lm32_reloc_map
533{
534 bfd_reloc_code_real_type bfd_reloc_val;
535 unsigned char elf_reloc_val;
536};
537
538static const struct lm32_reloc_map lm32_reloc_map[] =
539{
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 },
558};
559
560static reloc_howto_type *
561lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
562 bfd_reloc_code_real_type code)
563{
564 unsigned int i;
565
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;
570}
571
572static reloc_howto_type *
573lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
574 const char *r_name)
575{
576 unsigned int i;
577
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];
584
585 return NULL;
586}
587
588
589/* Set the howto pointer for an Lattice Mico32 ELF reloc. */
590
591static void
592lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
593 arelent *cache_ptr,
594 Elf_Internal_Rela *dst)
595{
596 unsigned int r_type;
597
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];
601}
602
603/* Set the right machine number for an Lattice Mico32 ELF file. */
604
605static bfd_boolean
606lm32_elf_object_p (bfd *abfd)
607{
608 return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
609}
610
611/* Set machine type flags just before file is written out. */
612
613static void
614lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
615{
616 elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
617 elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
618 switch (bfd_get_mach (abfd))
619 {
620 case bfd_mach_lm32:
621 elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
622 break;
623 default:
624 abort ();
625 }
626}
627
628/* Set the GP value for OUTPUT_BFD. Returns FALSE if this is a
629 dangerous relocation. */
630
631static bfd_boolean
632lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
633{
634 unsigned int count;
635 asymbol **sym;
636 unsigned int i;
637
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;
642
643 count = bfd_get_symcount (output_bfd);
644 sym = bfd_get_outsymbols (output_bfd);
645
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
651 {
652 for (i = 0; i < count; i++, sym++)
653 {
654 const char *name;
655
656 name = bfd_asymbol_name (*sym);
657 if (*name == '_' && strcmp (name, "_gp") == 0)
658 {
659 *pgp = bfd_asymbol_value (*sym);
660 _bfd_set_gp_value (output_bfd, *pgp);
661 break;
662 }
663 }
664 }
665
666 if (i >= count)
667 {
668 /* Only get the error once. */
669 *pgp = 4;
670 _bfd_set_gp_value (output_bfd, *pgp);
671 return FALSE;
672 }
673
674 return TRUE;
675}
676
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. */
682
683static bfd_reloc_status_type
684lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
685 char **error_message, bfd_vma *pgp)
686{
687 if (bfd_is_und_section (symbol->section) && !relocatable)
688 {
689 *pgp = 0;
690 return bfd_reloc_undefined;
691 }
692
693 *pgp = _bfd_get_gp_value (output_bfd);
694 if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
695 {
696 if (relocatable)
697 {
698 /* Make up a value. */
699 *pgp = symbol->section->output_section->vma + 0x4000;
700 _bfd_set_gp_value (output_bfd, *pgp);
701 }
702 else if (!lm32_elf_assign_gp (output_bfd, pgp))
703 {
704 *error_message =
705 (char *)
706 _("global pointer relative relocation when _gp not defined");
707 return bfd_reloc_dangerous;
708 }
709 }
710
711 return bfd_reloc_ok;
712}
713
714static bfd_reloc_status_type
715lm32_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)
722{
723 return _bfd_final_link_relocate (howto, abfd, input_section,
724 data, offset, symbol_value, addend);
725}
726
727static bfd_reloc_status_type
728lm32_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)
735{
736 bfd_vma relocation;
737 bfd_vma gp;
738 bfd_reloc_status_type r;
739
740 if (output_bfd != (bfd *) NULL
741 && (symbol->flags & BSF_SECTION_SYM) == 0
742 && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
743 {
744 reloc_entry->address += input_section->output_offset;
745 return bfd_reloc_ok;
746 }
747
748 if (output_bfd != NULL)
749 return bfd_reloc_ok;
750
751 relocation = symbol->value
752 + symbol->section->output_section->vma + symbol->section->output_offset;
753
754 if ((r =
755 lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
756 {
757 relocation = relocation + reloc_entry->addend - gp;
758 reloc_entry->addend = 0;
759 if ((signed) relocation < -32768 || (signed) relocation > 32767)
760 {
761 *msg = _("global pointer relative address out of range");
762 r = bfd_reloc_outofrange;
763 }
764 else
765 {
766 r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
767 input_section,
768 data, reloc_entry->address,
769 relocation, reloc_entry->addend);
770 }
771 }
772
773 return r;
774}
775
776/* Find the segment number in which OSEC, and output section, is
777 located. */
778
779static unsigned
780_lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
781{
782 struct elf_segment_map *m;
783 Elf_Internal_Phdr *p;
784
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++)
790 {
791 int i;
792
793 for (i = m->count - 1; i >= 0; i--)
794 if (m->sections[i] == osec)
795 break;
796
797 if (i >= 0)
798 break;
799 }
800
801 return p - elf_tdata (output_bfd)->phdr;
802}
803
804/* Determine if an output section is read-only. */
805
806inline static bfd_boolean
807_lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
808{
809 unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
810
811 return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
812}
813
814/* Relocate a section */
815
816static bfd_boolean
817lm32_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)
825{
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;
84e94c90
NC		 829 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
830 bfd *dynobj;
831 bfd_vma *local_got_offsets;
c7e2358a 832 asection *sgot;
84e94c90 833
4dfe6ac6
NC		 834 if (htab == NULL)
835 return FALSE;
836
84e94c90
NC		 837 dynobj = htab->root.dynobj;
838 local_got_offsets = elf_local_got_offsets (input_bfd);
839
840 sgot = htab->sgot;
84e94c90
NC		 841
842 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
843 sym_hashes = elf_sym_hashes (input_bfd);
844
845 rel = relocs;
846 relend = relocs + input_section->reloc_count;
847 for (; rel < relend; rel++)
848 {
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;
84e94c90
NC		 859
860 r_symndx = ELF32_R_SYM (rel->r_info);
861 r_type = ELF32_R_TYPE (rel->r_info);
862
863 if (r_type == R_LM32_GNU_VTENTRY
864 || r_type == R_LM32_GNU_VTINHERIT )
865 continue;
866
867 h = NULL;
868 sym = NULL;
869 sec = NULL;
870
871 howto = lm32_elf_howto_table + r_type;
872
873 if (r_symndx < symtab_hdr->sh_info)
874 {
875 /* It's a local symbol. */
876 sym = local_syms + r_symndx;
c7e2358a 877 sec = local_sections[r_symndx];
84e94c90
NC		 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;
882 }
883 else
884 {
885 /* It's a global symbol. */
886 bfd_boolean unresolved_reloc;
887 bfd_boolean warned;
888
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);
84e94c90
NC		 893 name = h->root.root.string;
894 }
895
dbaa2011 896 if (sec != NULL && discarded_section (sec))
e4067dbb 897 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 898 rel, 1, relend, howto, 0, contents);
84e94c90
NC		 899
900 if (info->relocatable)
901 {
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;
908
909 /* If partial_inplace, we need to store any additional addend
910 back in the section. */
911 if (! howto->partial_inplace)
912 continue;
913
914 /* Shouldn't reach here. */
915 abort ();
916 r = bfd_reloc_ok;
917 }
918 else
919 {
920 switch (howto->type)
921 {
922 case R_LM32_GPREL16:
923 if (!lm32_elf_assign_gp (output_bfd, &gp))
924 r = bfd_reloc_dangerous;
925 else
926 {
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
932 {
933 r = _bfd_final_link_relocate (howto, input_bfd,
934 input_section, contents,
935 rel->r_offset, relocation,
936 rel->r_addend);
937 }
938 }
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)
945 {
946 bfd_boolean dyn;
947 bfd_vma off;
948
949 off = h->got.offset;
950 BFD_ASSERT (off != (bfd_vma) -1);
951
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))
959 {
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.
968
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
975 {
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)
981 {
982 _lm32fdpic_add_rofixup (output_bfd,
983 lm32fdpic_fixup32_section
984 (info),
985 sgot->output_section->vma
986 + sgot->output_offset
987 + off);
988 }
989 /* Mark GOT entry as having been written. */
990 h->got.offset |= 1;
991 }
992 }
993
994 relocation = sgot->output_offset + off;
995 }
996 else
997 {
998 bfd_vma off;
999 bfd_byte *loc;
1000
1001 BFD_ASSERT (local_got_offsets != NULL
1002 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1003
1004 /* Get offset into GOT table. */
1005 off = local_got_offsets[r_symndx];
1006
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
1013 {
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))
1018 {
1019 _lm32fdpic_add_rofixup (output_bfd,
1020 lm32fdpic_fixup32_section
1021 (info),
1022 sgot->output_section->vma
1023 + sgot->output_offset
1024 + off);
1025 }
1026
1027 if (info->shared)
1028 {
1029 asection *srelgot;
1030 Elf_Internal_Rela outrel;
1031
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);
1036
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;
1046 }
1047
1048 local_got_offsets[r_symndx] |= 1;
1049 }
1050
1051
1052 relocation = sgot->output_offset + off;
1053 }
1054
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"));
1058
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;
1067
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;
1085
1086 case R_LM32_32:
1087 if (IS_FDPIC (output_bfd))
1088 {
1089 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1090 {
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))
1094
1095 {
1096 /* Check address to be modified is writable. */
1097 if (_lm32fdpic_osec_readonly_p (output_bfd,
1098 input_section
1099 ->output_section))
1100 {
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;
1106 }
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);
1113 }
1114 }
1115 }
1116 /* Fall through. */
1117
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;
1127 }
1128 }
1129
1130 if (r != bfd_reloc_ok)
1131 {
84e94c90
NC		 1132 const char *msg = NULL;
1133 arelent bfd_reloc;
84e94c90
NC		 1134
1135 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1136 howto = bfd_reloc.howto;
1137
1138 if (h != NULL)
1139 name = h->root.root.string;
1140 else
1141 {
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);
1146 }
1147
1148 switch (r)
1149 {
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;
1159
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;
1166
1167 case bfd_reloc_outofrange:
1168 msg = _("internal error: out of range error");
1169 goto common_error;
1170
1171 case bfd_reloc_notsupported:
1172 msg = _("internal error: unsupported relocation error");
1173 goto common_error;
1174
1175 case bfd_reloc_dangerous:
1176 msg = _("internal error: dangerous error");
1177 goto common_error;
1178
1179 default:
1180 msg = _("internal error: unknown error");
1181 /* fall through */
1182
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;
1189 }
1190 }
1191 }
1192
1193 return TRUE;
1194}
1195
1196static asection *
1197lm32_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)
1202{
1203 if (h != NULL)
1204 switch (ELF32_R_TYPE (rel->r_info))
1205 {
1206 case R_LM32_GNU_VTINHERIT:
1207 case R_LM32_GNU_VTENTRY:
1208 return NULL;
1209 }
1210
1211 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1212}
1213
1214static bfd_boolean
1215lm32_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)
1219{
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;
1225
1226 elf_section_data (sec)->local_dynrel = NULL;
1227
1228 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1229 sym_hashes = elf_sym_hashes (abfd);
1230 local_got_refcounts = elf_local_got_refcounts (abfd);
1231
1232 relend = relocs + sec->reloc_count;
1233 for (rel = relocs; rel < relend; rel++)
1234 {
1235 unsigned long r_symndx;
1236 struct elf_link_hash_entry *h = NULL;
1237
1238 r_symndx = ELF32_R_SYM (rel->r_info);
1239 if (r_symndx >= symtab_hdr->sh_info)
1240 {
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;
1245 }
1246
1247 switch (ELF32_R_TYPE (rel->r_info))
1248 {
1249 case R_LM32_16_GOT:
1250 if (h != NULL)
1251 {
1252 if (h->got.refcount > 0)
1253 h->got.refcount--;
1254 }
1255 else
1256 {
1257 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1258 local_got_refcounts[r_symndx]--;
1259 }
1260 break;
1261
1262 default:
1263 break;
1264 }
1265 }
1266 return TRUE;
1267}
1268
1269/* Look through the relocs for a section during the first phase. */
1270
1271static bfd_boolean
1272lm32_elf_check_relocs (bfd *abfd,
1273 struct bfd_link_info *info,
1274 asection *sec,
1275 const Elf_Internal_Rela *relocs)
1276{
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;
84e94c90
NC		 1283
1284 if (info->relocatable)
1285 return TRUE;
1286
84e94c90
NC		 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;
1292
1293 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1294 if (htab == NULL)
1295 return FALSE;
1296
84e94c90 1297 dynobj = htab->root.dynobj;
84e94c90
NC		 1298
1299 rel_end = relocs + sec->reloc_count;
1300 for (rel = relocs; rel < rel_end; rel++)
1301 {
1302 int r_type;
1303 struct elf_link_hash_entry *h;
1304 unsigned long r_symndx;
1305
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
1311 {
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;
1316 }
1317
1318 /* Some relocs require a global offset table. */
1319 if (htab->sgot == NULL)
1320 {
1321 switch (r_type)
1322 {
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;
1331 }
1332 }
1333
1334 /* Some relocs require a rofixup table. */
1335 if (IS_FDPIC (abfd))
1336 {
1337 switch (r_type)
1338 {
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)
1348 {
1349 if (! create_rofixup_section (abfd, info))
1350 return FALSE;
1351 }
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)
1358 {
1359 if (! create_rofixup_section (abfd, info))
1360 return FALSE;
1361 }
1362 break;
1363 }
1364 }
1365
1366 switch (r_type)
1367 {
1368 case R_LM32_16_GOT:
1369 if (h != NULL)
1370 h->got.refcount += 1;
1371 else
1372 {
1373 bfd_signed_vma *local_got_refcounts;
1374
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)
1378 {
1379 bfd_size_type size;
1380
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;
1387 }
1388 local_got_refcounts[r_symndx] += 1;
1389 }
1390 break;
1391
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;
1398
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;
1405
1406 }
1407 }
1408
1409 return TRUE;
1410}
1411
1412/* Finish up the dynamic sections. */
1413
1414static bfd_boolean
1415lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1416 struct bfd_link_info *info)
1417{
1418 struct elf_lm32_link_hash_table *htab;
1419 bfd *dynobj;
1420 asection *sdyn;
1421 asection *sgot;
1422
1423 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1424 if (htab == NULL)
1425 return FALSE;
1426
84e94c90
NC		 1427 dynobj = htab->root.dynobj;
1428
1429 sgot = htab->sgotplt;
1430 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1431
1432 if (htab->root.dynamic_sections_created)
1433 {
1434 asection *splt;
1435 Elf32_External_Dyn *dyncon, *dynconend;
1436
1437 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1438
1439 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1440 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1441
1442 for (; dyncon < dynconend; dyncon++)
1443 {
1444 Elf_Internal_Dyn dyn;
84e94c90
NC		 1445 asection *s;
1446
1447 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1448
1449 switch (dyn.d_tag)
1450 {
1451 default:
1452 break;
1453
1454 case DT_PLTGOT:
84e94c90
NC		 1455 s = htab->sgot->output_section;
1456 goto get_vma;
1457 case DT_JMPREL:
84e94c90
NC		 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;
1464
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;
1471
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)
1483 {
1484 s = htab->srelplt->output_section;
1485 dyn.d_un.d_val -= s->size;
1486 }
1487 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1488 break;
1489 }
1490 }
1491
1492 /* Fill in the first entry in the procedure linkage table. */
1493 splt = htab->splt;
1494 if (splt && splt->size > 0)
1495 {
1496 if (info->shared)
1497 {
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);
1503 }
1504 else
1505 {
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);
1518 }
1519
1520 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1521 PLT_ENTRY_SIZE;
1522 }
1523 }
1524
1525 /* Fill in the first three entries in the global offset table. */
1526 if (sgot && sgot->size > 0)
1527 {
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);
1536
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;
1540 }
1541
1542 if (lm32fdpic_fixup32_section (info))
1543 {
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;
1549
1550 /* Last entry is pointer to GOT. */
1551 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1552
1553 /* Check we wrote enough entries. */
1554 if (lm32fdpic_fixup32_section (info)->size
1555 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1556 {
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;
1562 }
1563
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))
1569 {
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)
1578 {
1579 (*_bfd_error_handler)
1580 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1581 return FALSE;
1582 }
1583 }
1584 }
1585
1586 return TRUE;
1587}
1588
1589/* Finish up dynamic symbol handling. We set the contents of various
1590 dynamic sections here. */
1591
1592static bfd_boolean
1593lm32_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)
1597{
1598 struct elf_lm32_link_hash_table *htab;
84e94c90
NC		 1599 bfd_byte *loc;
1600
1601 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1602 if (htab == NULL)
1603 return FALSE;
1604
84e94c90
NC		 1605 if (h->plt.offset != (bfd_vma) -1)
1606 {
1607 asection *splt;
1608 asection *sgot;
1609 asection *srela;
1610
1611 bfd_vma plt_index;
1612 bfd_vma got_offset;
1613 Elf_Internal_Rela rela;
1614
1615 /* This symbol has an entry in the procedure linkage table. Set
1616 it up. */
1617 BFD_ASSERT (h->dynindx != -1);
1618
1619 splt = htab->splt;
1620 sgot = htab->sgotplt;
1621 srela = htab->srelplt;
1622 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1623
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;
1629
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;
1634
1635 /* Fill in the entry in the procedure linkage table. */
1636 if (! info->shared)
1637 {
1638 /* TODO */
1639 }
1640 else
1641 {
1642 /* TODO */
1643 }
1644
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);
1652
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);
1662
1663 if (!h->def_regular)
1664 {
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;
1668 }
1669
1670 }
1671
1672 if (h->got.offset != (bfd_vma) -1)
1673 {
1674 asection *sgot;
1675 asection *srela;
1676 Elf_Internal_Rela rela;
1677
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);
1683
1684 rela.r_offset = (sgot->output_section->vma
1685 + sgot->output_offset
1686 + (h->got.offset &~ 1));
1687
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)
1698 {
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);
1703 }
1704 else
1705 {
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;
1710 }
1711
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;
1716 }
1717
1718 if (h->needs_copy)
1719 {
1720 asection *s;
1721 Elf_Internal_Rela rela;
1722
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));
1727
1728 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1729 ".rela.bss");
1730 BFD_ASSERT (s != NULL);
1731
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;
1741 }
1742
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;
1747
1748 return TRUE;
1749}
1750
1751static enum elf_reloc_type_class
1752lm32_elf_reloc_type_class (const Elf_Internal_Rela *rela)
1753{
1754 switch ((int) ELF32_R_TYPE (rela->r_info))
1755 {
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;
1760 }
1761}
1762
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. */
1768
1769static bfd_boolean
1770lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1771 struct elf_link_hash_entry *h)
1772{
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;
1778
1779 dynobj = elf_hash_table (info)->dynobj;
1780
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)));
1788
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)
1794 {
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)
1800 {
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;
1808 }
1809
1810 return TRUE;
1811 }
1812 else
1813 h->plt.offset = (bfd_vma) -1;
1814
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)
1819 {
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;
1825 }
1826
1827 /* This is a reference to a symbol defined by a dynamic object which
1828 is not a function. */
1829
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;
1836
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;
1841
1842 /* If -z nocopyreloc was given, we won't generate them either. */
1843 if (info->nocopyreloc)
1844 {
1845 h->non_got_ref = 0;
1846 return TRUE;
1847 }
1848
1849 eh = (struct elf_lm32_link_hash_entry *) h;
1850 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1851 {
1852 s = p->sec->output_section;
1853 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1854 break;
1855 }
1856
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)
1861 {
1862 h->non_got_ref = 0;
1863 return TRUE;
1864 }
1865
84e94c90
NC		 1866 /* We must allocate the symbol in our .dynbss section, which will
1867 become part of the .bss section of the executable. There will be
1868 an entry for this symbol in the .dynsym section. The dynamic
1869 object will contain position independent code, so all references
1870 from the dynamic object to this symbol will go through the global
1871 offset table. The dynamic linker will use the .dynsym entry to
1872 determine the address it must put in the global offset table, so
1873 both the dynamic object and the regular object will refer to the
1874 same memory location for the variable. */
1875
1876 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1877 if (htab == NULL)
1878 return FALSE;
1879
84e94c90
NC		 1880 s = htab->sdynbss;
1881 BFD_ASSERT (s != NULL);
1882
1883 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1884 to copy the initial value out of the dynamic object and into the
1885 runtime process image. We need to remember the offset into the
1886 .rela.bss section we are going to use. */
1d7e9d18 1887 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
84e94c90
NC		 1888 {
1889 asection *srel;
1890
1891 srel = htab->srelbss;
1892 BFD_ASSERT (srel != NULL);
1893 srel->size += sizeof (Elf32_External_Rela);
1894 h->needs_copy = 1;
1895 }
1896
1897 return _bfd_elf_adjust_dynamic_copy (h, s);
1898}
1899
1900/* Allocate space in .plt, .got and associated reloc sections for
1901 dynamic relocs. */
1902
1903static bfd_boolean
1904allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1905{
1906 struct bfd_link_info *info;
1907 struct elf_lm32_link_hash_table *htab;
1908 struct elf_lm32_link_hash_entry *eh;
1909 struct elf_lm32_dyn_relocs *p;
1910
1911 if (h->root.type == bfd_link_hash_indirect)
1912 return TRUE;
1913
84e94c90
NC		 1914 info = (struct bfd_link_info *) inf;
1915 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1916 if (htab == NULL)
1917 return FALSE;
84e94c90
NC		 1918
1919 eh = (struct elf_lm32_link_hash_entry *) h;
1920
1921 if (htab->root.dynamic_sections_created
1922 && h->plt.refcount > 0)
1923 {
1924 /* Make sure this symbol is output as a dynamic symbol.
1925 Undefined weak syms won't yet be marked as dynamic. */
1926 if (h->dynindx == -1
1927 && !h->forced_local)
1928 {
1929 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1930 return FALSE;
1931 }
1932
1933 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1934 {
1935 asection *s = htab->splt;
1936
1937 /* If this is the first .plt entry, make room for the special
1938 first entry. */
1939 if (s->size == 0)
1940 s->size += PLT_ENTRY_SIZE;
1941
1942 h->plt.offset = s->size;
1943
1944 /* If this symbol is not defined in a regular file, and we are
1945 not generating a shared library, then set the symbol to this
1946 location in the .plt. This is required to make function
1947 pointers compare as equal between the normal executable and
1948 the shared library. */
1949 if (! info->shared
1950 && !h->def_regular)
1951 {
1952 h->root.u.def.section = s;
1953 h->root.u.def.value = h->plt.offset;
1954 }
1955
1956 /* Make room for this entry. */
1957 s->size += PLT_ENTRY_SIZE;
1958
1959 /* We also need to make an entry in the .got.plt section, which
1960 will be placed in the .got section by the linker script. */
1961 htab->sgotplt->size += 4;
1962
1963 /* We also need to make an entry in the .rel.plt section. */
1964 htab->srelplt->size += sizeof (Elf32_External_Rela);
1965 }
1966 else
1967 {
1968 h->plt.offset = (bfd_vma) -1;
1969 h->needs_plt = 0;
1970 }
1971 }
1972 else
1973 {
1974 h->plt.offset = (bfd_vma) -1;
1975 h->needs_plt = 0;
1976 }
1977
1978 if (h->got.refcount > 0)
1979 {
1980 asection *s;
1981 bfd_boolean dyn;
1982
1983 /* Make sure this symbol is output as a dynamic symbol.
1984 Undefined weak syms won't yet be marked as dynamic. */
1985 if (h->dynindx == -1
1986 && !h->forced_local)
1987 {
1988 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1989 return FALSE;
1990 }
1991
1992 s = htab->sgot;
1993
1994 h->got.offset = s->size;
1995 s->size += 4;
1996 dyn = htab->root.dynamic_sections_created;
1997 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
1998 htab->srelgot->size += sizeof (Elf32_External_Rela);
1999 }
2000 else
2001 h->got.offset = (bfd_vma) -1;
2002
2003 if (eh->dyn_relocs == NULL)
2004 return TRUE;
2005
2006 /* In the shared -Bsymbolic case, discard space allocated for
2007 dynamic pc-relative relocs against symbols which turn out to be
2008 defined in regular objects. For the normal shared case, discard
2009 space for pc-relative relocs that have become local due to symbol
2010 visibility changes. */
2011
2012 if (info->shared)
2013 {
2014 if (h->def_regular
2015 && (h->forced_local
2016 || info->symbolic))
2017 {
2018 struct elf_lm32_dyn_relocs **pp;
2019
2020 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2021 {
2022 p->count -= p->pc_count;
2023 p->pc_count = 0;
2024 if (p->count == 0)
2025 *pp = p->next;
2026 else
2027 pp = &p->next;
2028 }
2029 }
2030
2031 /* Also discard relocs on undefined weak syms with non-default
2032 visibility. */
2033 if (eh->dyn_relocs != NULL
2034 && h->root.type == bfd_link_hash_undefweak)
2035 {
2036 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2037 eh->dyn_relocs = NULL;
2038
2039 /* Make sure undefined weak symbols are output as a dynamic
2040 symbol in PIEs. */
2041 else if (h->dynindx == -1
2042 && !h->forced_local)
2043 {
2044 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2045 return FALSE;
2046 }
2047 }
2048 }
2049 else
2050 {
2051 /* For the non-shared case, discard space for relocs against
2052 symbols which turn out to need copy relocs or are not
2053 dynamic. */
2054
2055 if (!h->non_got_ref
2056 && ((h->def_dynamic
2057 && !h->def_regular)
2058 || (htab->root.dynamic_sections_created
2059 && (h->root.type == bfd_link_hash_undefweak
2060 || h->root.type == bfd_link_hash_undefined))))
2061 {
2062 /* Make sure this symbol is output as a dynamic symbol.
2063 Undefined weak syms won't yet be marked as dynamic. */
2064 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 /* If that succeeded, we know we'll be keeping all the
2072 relocs. */
2073 if (h->dynindx != -1)
2074 goto keep;
2075 }
2076
2077 eh->dyn_relocs = NULL;
2078
2079 keep: ;
2080 }
2081
2082 /* Finally, allocate space. */
2083 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2084 {
2085 asection *sreloc = elf_section_data (p->sec)->sreloc;
2086 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2087 }
2088
2089 return TRUE;
2090}
2091
2092/* Find any dynamic relocs that apply to read-only sections. */
2093
2094static bfd_boolean
2095readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2096{
2097 struct elf_lm32_link_hash_entry *eh;
2098 struct elf_lm32_dyn_relocs *p;
2099
84e94c90
NC		 2100 eh = (struct elf_lm32_link_hash_entry *) h;
2101 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2102 {
2103 asection *s = p->sec->output_section;
2104
2105 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2106 {
2107 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2108
2109 info->flags |= DF_TEXTREL;
2110
2111 /* Not an error, just cut short the traversal. */
2112 return FALSE;
2113 }
2114 }
2115 return TRUE;
2116}
2117
2118/* Set the sizes of the dynamic sections. */
2119
2120static bfd_boolean
2121lm32_elf_size_dynamic_sections (bfd *output_bfd,
2122 struct bfd_link_info *info)
2123{
2124 struct elf_lm32_link_hash_table *htab;
2125 bfd *dynobj;
2126 asection *s;
2127 bfd_boolean relocs;
2128 bfd *ibfd;
2129
2130 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 2131 if (htab == NULL)
2132 return FALSE;
2133
84e94c90
NC		 2134 dynobj = htab->root.dynobj;
2135 BFD_ASSERT (dynobj != NULL);
2136
2137 if (htab->root.dynamic_sections_created)
2138 {
2139 /* Set the contents of the .interp section to the interpreter. */
2140 if (info->executable)
2141 {
2142 s = bfd_get_section_by_name (dynobj, ".interp");
2143 BFD_ASSERT (s != NULL);
2144 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2145 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2146 }
2147 }
2148
2149 /* Set up .got offsets for local syms, and space for local dynamic
2150 relocs. */
2151 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2152 {
2153 bfd_signed_vma *local_got;
2154 bfd_signed_vma *end_local_got;
2155 bfd_size_type locsymcount;
2156 Elf_Internal_Shdr *symtab_hdr;
2157 asection *srel;
2158
2159 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2160 continue;
2161
2162 for (s = ibfd->sections; s != NULL; s = s->next)
2163 {
2164 struct elf_lm32_dyn_relocs *p;
2165
2166 for (p = ((struct elf_lm32_dyn_relocs *)
2167 elf_section_data (s)->local_dynrel);
2168 p != NULL;
2169 p = p->next)
2170 {
2171 if (! bfd_is_abs_section (p->sec)
2172 && bfd_is_abs_section (p->sec->output_section))
2173 {
2174 /* Input section has been discarded, either because
2175 it is a copy of a linkonce section or due to
2176 linker script /DISCARD/, so we'll be discarding
2177 the relocs too. */
2178 }
2179 else if (p->count != 0)
2180 {
2181 srel = elf_section_data (p->sec)->sreloc;
2182 srel->size += p->count * sizeof (Elf32_External_Rela);
2183 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2184 info->flags |= DF_TEXTREL;
2185 }
2186 }
2187 }
2188
2189 local_got = elf_local_got_refcounts (ibfd);
2190 if (!local_got)
2191 continue;
2192
2193 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2194 locsymcount = symtab_hdr->sh_info;
2195 end_local_got = local_got + locsymcount;
2196 s = htab->sgot;
2197 srel = htab->srelgot;
2198 for (; local_got < end_local_got; ++local_got)
2199 {
2200 if (*local_got > 0)
2201 {
2202 *local_got = s->size;
2203 s->size += 4;
2204 if (info->shared)
2205 srel->size += sizeof (Elf32_External_Rela);
2206 }
2207 else
2208 *local_got = (bfd_vma) -1;
2209 }
2210 }
2211
2212 /* Allocate global sym .plt and .got entries, and space for global
2213 sym dynamic relocs. */
2214 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2215
2216 /* We now have determined the sizes of the various dynamic sections.
2217 Allocate memory for them. */
2218 relocs = FALSE;
2219 for (s = dynobj->sections; s != NULL; s = s->next)
2220 {
2221 if ((s->flags & SEC_LINKER_CREATED) == 0)
2222 continue;
2223
2224 if (s == htab->splt
2225 || s == htab->sgot
2226 || s == htab->sgotplt
2227 || s == htab->sdynbss)
2228 {
2229 /* Strip this section if we don't need it; see the
2230 comment below. */
2231 }
2232 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2233 {
2234 if (s->size != 0 && s != htab->srelplt)
2235 relocs = TRUE;
2236
2237 /* We use the reloc_count field as a counter if we need
2238 to copy relocs into the output file. */
2239 s->reloc_count = 0;
2240 }
2241 else
2242 /* It's not one of our sections, so don't allocate space. */
2243 continue;
2244
2245 if (s->size == 0)
2246 {
2247 /* If we don't need this section, strip it from the
2248 output file. This is mostly to handle .rela.bss and
2249 .rela.plt. We must create both sections in
2250 create_dynamic_sections, because they must be created
2251 before the linker maps input sections to output
2252 sections. The linker does that before
2253 adjust_dynamic_symbol is called, and it is that
2254 function which decides whether anything needs to go
2255 into these sections. */
2256 s->flags |= SEC_EXCLUDE;
2257 continue;
2258 }
2259
2260 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2261 continue;
2262
2263 /* Allocate memory for the section contents. We use bfd_zalloc
2264 here in case unused entries are not reclaimed before the
2265 section's contents are written out. This should not happen,
2266 but this way if it does, we get a R_LM32_NONE reloc instead
2267 of garbage. */
2268 s->contents = bfd_zalloc (dynobj, s->size);
2269 if (s->contents == NULL)
2270 return FALSE;
2271 }
2272
2273 if (htab->root.dynamic_sections_created)
2274 {
2275 /* Add some entries to the .dynamic section. We fill in the
2276 values later, in lm32_elf_finish_dynamic_sections, but we
2277 must add the entries now so that we get the correct size for
2278 the .dynamic section. The DT_DEBUG entry is filled in by the
2279 dynamic linker and used by the debugger. */
2280#define add_dynamic_entry(TAG, VAL) \
2281 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2282
2283 if (info->executable)
2284 {
2285 if (! add_dynamic_entry (DT_DEBUG, 0))
2286 return FALSE;
2287 }
2288
2289 if (htab->splt->size != 0)
2290 {
2291 if (! add_dynamic_entry (DT_PLTGOT, 0)
2292 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2293 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2294 || ! add_dynamic_entry (DT_JMPREL, 0))
2295 return FALSE;
2296 }
2297
2298 if (relocs)
2299 {
2300 if (! add_dynamic_entry (DT_RELA, 0)
2301 || ! add_dynamic_entry (DT_RELASZ, 0)
2302 || ! add_dynamic_entry (DT_RELAENT,
2303 sizeof (Elf32_External_Rela)))
2304 return FALSE;
2305
2306 /* If any dynamic relocs apply to a read-only section,
2307 then we need a DT_TEXTREL entry. */
2308 if ((info->flags & DF_TEXTREL) == 0)
2309 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2310 info);
2311
2312 if ((info->flags & DF_TEXTREL) != 0)
2313 {
2314 if (! add_dynamic_entry (DT_TEXTREL, 0))
2315 return FALSE;
2316 }
2317 }
2318 }
2319#undef add_dynamic_entry
2320
2321 /* Allocate .rofixup section. */
2322 if (IS_FDPIC (output_bfd))
2323 {
2324 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2325 int rgot_weak_count = 0;
2326 int r32_count = 0;
2327 int rgot_count = 0;
2328 /* Look for deleted sections. */
2329 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2330 {
2331 for (s = ibfd->sections; s != NULL; s = s->next)
2332 {
2333 if (s->reloc_count)
2334 {
2335 /* Count relocs that need .rofixup entires. */
2336 Elf_Internal_Rela *internal_relocs, *end;
2337 internal_relocs = elf_section_data (s)->relocs;
2338 if (internal_relocs == NULL)
2339 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2340 if (internal_relocs != NULL)
2341 {
2342 end = internal_relocs + s->reloc_count;
2343 while (internal_relocs < end)
2344 {
2345 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2346 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2347 unsigned long r_symndx;
2348 struct elf_link_hash_entry *h;
2349
2350 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2351 sym_hashes = elf_sym_hashes (ibfd);
2352 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2353 h = NULL;
2354 if (r_symndx < symtab_hdr->sh_info)
2355 {
2356 }
2357 else
2358 {
2359 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2360 while (h->root.type == bfd_link_hash_indirect
2361 || h->root.type == bfd_link_hash_warning)
2362 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2363 }
2364
2365 /* Don't generate entries for weak symbols. */
2366 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2367 {
dbaa2011 2368 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
84e94c90
NC		 2369 {
2370 switch (ELF32_R_TYPE (internal_relocs->r_info))
2371 {
2372 case R_LM32_32:
2373 r32_count++;
2374 break;
2375 case R_LM32_16_GOT:
2376 rgot_count++;
2377 break;
2378 }
2379 }
2380 }
2381 else
2382 {
2383 struct weak_symbol_list *current, *new_entry;
2384 /* Is this symbol already in the list? */
2385 for (current = list_start; current; current = current->next)
2386 {
2387 if (!strcmp (current->name, h->root.root.string))
2388 break;
2389 }
dbaa2011 2390 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
84e94c90
NC		 2391 {
2392 /* Will this have an entry in the GOT. */
2393 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2394 {
2395 /* Create a new entry. */
2396 new_entry = malloc (sizeof (struct weak_symbol_list));
2397 if (!new_entry)
2398 return FALSE;
2399 new_entry->name = h->root.root.string;
2400 new_entry->next = NULL;
2401 /* Add to list */
2402 if (list_start == NULL)
2403 {
2404 list_start = new_entry;
2405 list_end = new_entry;
2406 }
2407 else
2408 {
2409 list_end->next = new_entry;
2410 list_end = new_entry;
2411 }
2412 /* Increase count of undefined weak symbols in the got. */
2413 rgot_weak_count++;
2414 }
2415 }
2416 }
2417 internal_relocs++;
2418 }
2419 }
2420 else
2421 return FALSE;
2422 }
2423 }
2424 }
2425 /* Free list. */
2426 while (list_start)
2427 {
2428 list_end = list_start->next;
2429 free (list_start);
2430 list_start = list_end;
2431 }
2432
2433 /* Size sections. */
2434 lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2435 if (lm32fdpic_fixup32_section (info)->size == 0)
2436 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2437 else
2438 {
2439 lm32fdpic_fixup32_section (info)->contents =
2440 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2441 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2442 return FALSE;
2443 }
2444 }
2445
2446 return TRUE;
2447}
2448
2449/* Create dynamic sections when linking against a dynamic object. */
2450
2451static bfd_boolean
2452lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2453{
2454 struct elf_lm32_link_hash_table *htab;
2455 flagword flags, pltflags;
2456 asection *s;
2457 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2458 int ptralign = 2; /* 32bit */
2459
2460 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 2461 if (htab == NULL)
2462 return FALSE;
84e94c90
NC		 2463
2464 /* Make sure we have a GOT - For the case where we have a dynamic object
2465 but none of the relocs in check_relocs */
2466 if (! create_got_section (abfd, info))
2467 return FALSE;
2468 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2469 {
2470 if (! create_rofixup_section (abfd, info))
2471 return FALSE;
2472 }
2473
2474 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2475 .rel[a].bss sections. */
2476 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2477 | SEC_LINKER_CREATED);
2478
2479 pltflags = flags;
2480 pltflags |= SEC_CODE;
2481 if (bed->plt_not_loaded)
2482 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2483 if (bed->plt_readonly)
2484 pltflags |= SEC_READONLY;
2485
2486 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
2487 htab->splt = s;
2488 if (s == NULL
2489 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2490 return FALSE;
2491
2492 if (bed->want_plt_sym)
2493 {
2494 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2495 .plt section. */
2496 struct bfd_link_hash_entry *bh = NULL;
2497 struct elf_link_hash_entry *h;
2498
2499 if (! (_bfd_generic_link_add_one_symbol
2500 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2501 (bfd_vma) 0, NULL, FALSE,
2502 get_elf_backend_data (abfd)->collect, &bh)))
2503 return FALSE;
2504 h = (struct elf_link_hash_entry *) bh;
2505 h->def_regular = 1;
2506 h->type = STT_OBJECT;
2507 htab->root.hplt = h;
2508
2509 if (info->shared
2510 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2511 return FALSE;
2512 }
2513
2514 s = bfd_make_section_with_flags (abfd,
2515 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
2516 flags | SEC_READONLY);
2517 htab->srelplt = s;
2518 if (s == NULL
2519 || ! bfd_set_section_alignment (abfd, s, ptralign))
2520 return FALSE;
2521
2522 if (htab->sgot == NULL
2523 && ! create_got_section (abfd, info))
2524 return FALSE;
2525
84e94c90
NC		 2526 if (bed->want_dynbss)
2527 {
2528 /* The .dynbss section is a place to put symbols which are defined
2529 by dynamic objects, are referenced by regular objects, and are
2530 not functions. We must allocate space for them in the process
2531 image and use a R_*_COPY reloc to tell the dynamic linker to
2532 initialize them at run time. The linker script puts the .dynbss
2533 section into the .bss section of the final image. */
2534 s = bfd_make_section_with_flags (abfd, ".dynbss",
2535 SEC_ALLOC | SEC_LINKER_CREATED);
2536 htab->sdynbss = s;
2537 if (s == NULL)
2538 return FALSE;
2539 /* The .rel[a].bss section holds copy relocs. This section is not
2540 normally needed. We need to create it here, though, so that the
2541 linker will map it to an output section. We can't just create it
2542 only if we need it, because we will not know whether we need it
2543 until we have seen all the input files, and the first time the
2544 main linker code calls BFD after examining all the input files
2545 (size_dynamic_sections) the input sections have already been
2546 mapped to the output sections. If the section turns out not to
2547 be needed, we can discard it later. We will never need this
2548 section when generating a shared object, since they do not use
2549 copy relocs. */
2550 if (! info->shared)
2551 {
2552 s = bfd_make_section_with_flags (abfd,
2553 (bed->default_use_rela_p
2554 ? ".rela.bss" : ".rel.bss"),
2555 flags | SEC_READONLY);
2556 htab->srelbss = s;
2557 if (s == NULL
2558 || ! bfd_set_section_alignment (abfd, s, ptralign))
2559 return FALSE;
2560 }
2561 }
2562
2563 return TRUE;
2564}
2565
2566/* Copy the extra info we tack onto an elf_link_hash_entry. */
2567
2568static void
2569lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2570 struct elf_link_hash_entry *dir,
2571 struct elf_link_hash_entry *ind)
2572{
2573 struct elf_lm32_link_hash_entry * edir;
2574 struct elf_lm32_link_hash_entry * eind;
2575
2576 edir = (struct elf_lm32_link_hash_entry *) dir;
2577 eind = (struct elf_lm32_link_hash_entry *) ind;
2578
2579 if (eind->dyn_relocs != NULL)
2580 {
2581 if (edir->dyn_relocs != NULL)
2582 {
2583 struct elf_lm32_dyn_relocs **pp;
2584 struct elf_lm32_dyn_relocs *p;
2585
2586 /* Add reloc counts against the indirect sym to the direct sym
2587 list. Merge any entries against the same section. */
2588 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2589 {
2590 struct elf_lm32_dyn_relocs *q;
2591
2592 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2593 if (q->sec == p->sec)
2594 {
2595 q->pc_count += p->pc_count;
2596 q->count += p->count;
2597 *pp = p->next;
2598 break;
2599 }
2600 if (q == NULL)
2601 pp = &p->next;
2602 }
2603 *pp = edir->dyn_relocs;
2604 }
2605
2606 edir->dyn_relocs = eind->dyn_relocs;
2607 eind->dyn_relocs = NULL;
2608 }
2609
2610 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2611}
2612
2613static bfd_boolean
2614lm32_elf_always_size_sections (bfd *output_bfd,
2615 struct bfd_link_info *info)
2616{
2617 if (!info->relocatable)
2618 {
2619 struct elf_link_hash_entry *h;
2620
2621 /* Force a PT_GNU_STACK segment to be created. */
2622 if (! elf_tdata (output_bfd)->stack_flags)
2623 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
2624
2625 /* Define __stacksize if it's not defined yet. */
2626 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2627 FALSE, FALSE, FALSE);
2628 if (! h || h->root.type != bfd_link_hash_defined
2629 || h->type != STT_OBJECT
2630 || !h->def_regular)
2631 {
2632 struct bfd_link_hash_entry *bh = NULL;
2633
2634 if (!(_bfd_generic_link_add_one_symbol
2635 (info, output_bfd, "__stacksize",
2636 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
2637 (const char *) NULL, FALSE,
2638 get_elf_backend_data (output_bfd)->collect, &bh)))
2639 return FALSE;
2640
2641 h = (struct elf_link_hash_entry *) bh;
2642 h->def_regular = 1;
2643 h->type = STT_OBJECT;
2644 /* This one must NOT be hidden. */
2645 }
2646 }
2647
2648 return TRUE;
2649}
2650
2651static bfd_boolean
2652lm32_elf_modify_segment_map (bfd *output_bfd,
2653 struct bfd_link_info *info)
2654{
2655 struct elf_segment_map *m;
2656
2657 /* objcopy and strip preserve what's already there using elf32_lm32fdpic_copy_
2658 private_bfd_data (). */
2659 if (! info)
2660 return TRUE;
2661
2662 for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
2663 if (m->p_type == PT_GNU_STACK)
2664 break;
2665
2666 if (m)
2667 {
2668 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2669 struct elf_link_hash_entry *h;
2670
2671 if (sec)
2672 {
2673 /* Obtain the pointer to the __stacksize symbol. */
2674 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2675 FALSE, FALSE, FALSE);
2676 while (h->root.type == bfd_link_hash_indirect
2677 || h->root.type == bfd_link_hash_warning)
2678 h = (struct elf_link_hash_entry *)h->root.u.i.link;
2679 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2680
2681 /* Set the section size from the symbol value. We
2682 intentionally ignore the symbol section. */
2683 if (h->root.type == bfd_link_hash_defined)
2684 sec->size = h->root.u.def.value;
2685 else
2686 sec->size = DEFAULT_STACK_SIZE;
2687
2688 /* Add the stack section to the PT_GNU_STACK segment,
2689 such that its size and alignment requirements make it
2690 to the segment. */
2691 m->sections[m->count] = sec;
2692 m->count++;
2693 }
2694 }
2695
2696 return TRUE;
2697}
2698
2699static bfd_boolean
2700lm32_elf_modify_program_headers (bfd *output_bfd,
2701 struct bfd_link_info *info)
2702{
2703 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
2704 struct elf_segment_map *m;
2705 Elf_Internal_Phdr *p;
2706
2707 if (! info)
2708 return TRUE;
2709
2710 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
2711 if (m->p_type == PT_GNU_STACK)
2712 break;
2713
2714 if (m)
2715 {
2716 struct elf_link_hash_entry *h;
2717
2718 /* Obtain the pointer to the __stacksize symbol. */
2719 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2720 FALSE, FALSE, FALSE);
2721 if (h)
2722 {
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
2729 /* Set the header p_memsz from the symbol value. We
2730 intentionally ignore the symbol section. */
2731 if (h && h->root.type == bfd_link_hash_defined)
2732 p->p_memsz = h->root.u.def.value;
2733 else
2734 p->p_memsz = DEFAULT_STACK_SIZE;
2735
2736 p->p_align = 8;
2737 }
2738
2739 return TRUE;
2740}
2741
2742
2743static bfd_boolean
2744lm32_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2745{
2746 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2747 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2748 return TRUE;
2749
2750 BFD_ASSERT (!elf_flags_init (obfd)
2751 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
2752
2753 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2754 elf_flags_init (obfd) = TRUE;
2755
2756 /* Copy object attributes. */
2757 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2758
2759 return TRUE;
2760}
2761
2762
2763static bfd_boolean
2764lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2765{
2766 unsigned i;
2767
2768 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2769 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2770 return TRUE;
2771
2772 if (! lm32_elf_copy_private_bfd_data (ibfd, obfd))
2773 return FALSE;
2774
2775 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2776 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2777 return TRUE;
2778
2779 /* Copy the stack size. */
2780 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2781 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2782 {
2783 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2784
2785 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2786 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2787 {
2788 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2789
2790 /* Rewrite the phdrs, since we're only called after they were first written. */
2791 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2792 ->s->sizeof_ehdr, SEEK_SET) != 0
2793 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2794 elf_elfheader (obfd)->e_phnum) != 0)
2795 return FALSE;
2796 break;
2797 }
2798
2799 break;
2800 }
2801
2802 return TRUE;
2803}
2804
2805
2806#define ELF_ARCH bfd_arch_lm32
ae95ffa6 2807#define ELF_TARGET_ID LM32_ELF_DATA
84e94c90
NC		 2808#define ELF_MACHINE_CODE EM_LATTICEMICO32
2809#define ELF_MAXPAGESIZE 0x1000
2810
2811#define TARGET_BIG_SYM bfd_elf32_lm32_vec
2812#define TARGET_BIG_NAME "elf32-lm32"
2813
2814#define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2815#define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2816#define elf_info_to_howto lm32_info_to_howto_rela
2817#define elf_info_to_howto_rel 0
2818#define elf_backend_rela_normal 1
2819#define elf_backend_object_p lm32_elf_object_p
2820#define elf_backend_final_write_processing lm32_elf_final_write_processing
2821#define elf_backend_can_gc_sections 1
2822#define elf_backend_can_refcount 1
2823#define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2824#define elf_backend_gc_sweep_hook lm32_elf_gc_sweep_hook
2825#define elf_backend_plt_readonly 1
2826#define elf_backend_want_got_plt 1
2827#define elf_backend_want_plt_sym 0
2828#define elf_backend_got_header_size 12
2829#define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2830#define elf_backend_check_relocs lm32_elf_check_relocs
2831#define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2832#define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2833#define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2834#define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2835#define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2836#define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2837#define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2838#define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2839#define elf_backend_relocate_section lm32_elf_relocate_section
2840
2841#include "elf32-target.h"
2842
2843#undef ELF_MAXPAGESIZE
2844#define ELF_MAXPAGESIZE 0x4000
2845
2846
2847#undef TARGET_BIG_SYM
2848#define TARGET_BIG_SYM bfd_elf32_lm32fdpic_vec
2849#undef TARGET_BIG_NAME
2850#define TARGET_BIG_NAME "elf32-lm32fdpic"
2851#undef elf32_bed
2852#define elf32_bed elf32_lm32fdpic_bed
2853
2854#undef elf_backend_always_size_sections
2855#define elf_backend_always_size_sections lm32_elf_always_size_sections
2856#undef elf_backend_modify_segment_map
2857#define elf_backend_modify_segment_map lm32_elf_modify_segment_map
2858#undef elf_backend_modify_program_headers
2859#define elf_backend_modify_program_headers lm32_elf_modify_program_headers
2860#undef bfd_elf32_bfd_copy_private_bfd_data
2861#define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2862
2863#include "elf32-target.h"
A mirror of the official binutils-gdb repository