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