]> 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
ELF: Don't set non_ir_ref_regular in check_relocs
[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
1646/* Adjust a symbol defined by a dynamic object and referenced by a
1647 regular object. The current definition is in some section of the
1648 dynamic object, but we're not including those sections. We have to
1649 change the definition to something the rest of the link can
1650 understand. */
1651
1652static bfd_boolean
1653lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1654 struct elf_link_hash_entry *h)
1655{
1656 struct elf_lm32_link_hash_table *htab;
1657 struct elf_lm32_link_hash_entry *eh;
1658 struct elf_lm32_dyn_relocs *p;
1659 bfd *dynobj;
1660 asection *s;
1661
1662 dynobj = elf_hash_table (info)->dynobj;
1663
1664 /* Make sure we know what is going on here. */
1665 BFD_ASSERT (dynobj != NULL
1666 && (h->needs_plt
60d67dc8 1667 || h->is_weakalias
84e94c90
NC		 1668 || (h->def_dynamic
1669 && h->ref_regular
1670 && !h->def_regular)));
1671
1672 /* If this is a function, put it in the procedure linkage table. We
1673 will fill in the contents of the procedure linkage table later,
1674 when we know the address of the .got section. */
1675 if (h->type == STT_FUNC
1676 || h->needs_plt)
1677 {
0e1862bb 1678 if (! bfd_link_pic (info)
84e94c90
NC		 1679 && !h->def_dynamic
1680 && !h->ref_dynamic
1681 && h->root.type != bfd_link_hash_undefweak
1682 && h->root.type != bfd_link_hash_undefined)
1683 {
1684 /* This case can occur if we saw a PLT reloc in an input
1685 file, but the symbol was never referred to by a dynamic
1686 object. In such a case, we don't actually need to build
1687 a procedure linkage table, and we can just do a PCREL
1688 reloc instead. */
1689 h->plt.offset = (bfd_vma) -1;
1690 h->needs_plt = 0;
1691 }
1692
1693 return TRUE;
1694 }
1695 else
1696 h->plt.offset = (bfd_vma) -1;
1697
1698 /* If this is a weak symbol, and there is a real definition, the
1699 processor independent code will have arranged for us to see the
1700 real definition first, and we can just use the same value. */
60d67dc8 1701 if (h->is_weakalias)
84e94c90 1702 {
60d67dc8
AM		 1703 struct elf_link_hash_entry *def = weakdef (h);
1704 BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1705 h->root.u.def.section = def->root.u.def.section;
1706 h->root.u.def.value = def->root.u.def.value;
84e94c90
NC		 1707 return TRUE;
1708 }
1709
1710 /* This is a reference to a symbol defined by a dynamic object which
1711 is not a function. */
1712
1713 /* If we are creating a shared library, we must presume that the
1714 only references to the symbol are via the global offset table.
1715 For such cases we need not do anything here; the relocations will
1716 be handled correctly by relocate_section. */
0e1862bb 1717 if (bfd_link_pic (info))
84e94c90
NC		 1718 return TRUE;
1719
1720 /* If there are no references to this symbol that do not use the
1721 GOT, we don't need to generate a copy reloc. */
1722 if (!h->non_got_ref)
1723 return TRUE;
1724
1725 /* If -z nocopyreloc was given, we won't generate them either. */
1726 if (info->nocopyreloc)
1727 {
1728 h->non_got_ref = 0;
1729 return TRUE;
1730 }
1731
1732 eh = (struct elf_lm32_link_hash_entry *) h;
1733 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1734 {
1735 s = p->sec->output_section;
1736 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1737 break;
1738 }
1739
1740 /* If we didn't find any dynamic relocs in sections which needs the
1741 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1742 the copy reloc. */
1743 if (p == NULL)
1744 {
1745 h->non_got_ref = 0;
1746 return TRUE;
1747 }
1748
84e94c90
NC		 1749 /* We must allocate the symbol in our .dynbss section, which will
1750 become part of the .bss section of the executable. There will be
1751 an entry for this symbol in the .dynsym section. The dynamic
1752 object will contain position independent code, so all references
1753 from the dynamic object to this symbol will go through the global
1754 offset table. The dynamic linker will use the .dynsym entry to
1755 determine the address it must put in the global offset table, so
1756 both the dynamic object and the regular object will refer to the
1757 same memory location for the variable. */
1758
1759 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1760 if (htab == NULL)
1761 return FALSE;
1762
84e94c90
NC		 1763 s = htab->sdynbss;
1764 BFD_ASSERT (s != NULL);
1765
1766 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1767 to copy the initial value out of the dynamic object and into the
1768 runtime process image. We need to remember the offset into the
1769 .rela.bss section we are going to use. */
1d7e9d18 1770 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
84e94c90
NC		 1771 {
1772 asection *srel;
1773
1774 srel = htab->srelbss;
1775 BFD_ASSERT (srel != NULL);
1776 srel->size += sizeof (Elf32_External_Rela);
1777 h->needs_copy = 1;
1778 }
1779
6cabe1ea 1780 return _bfd_elf_adjust_dynamic_copy (info, h, s);
84e94c90
NC		 1781}
1782
1783/* Allocate space in .plt, .got and associated reloc sections for
1784 dynamic relocs. */
1785
1786static bfd_boolean
1787allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1788{
1789 struct bfd_link_info *info;
1790 struct elf_lm32_link_hash_table *htab;
1791 struct elf_lm32_link_hash_entry *eh;
1792 struct elf_lm32_dyn_relocs *p;
1793
1794 if (h->root.type == bfd_link_hash_indirect)
1795 return TRUE;
1796
84e94c90
NC		 1797 info = (struct bfd_link_info *) inf;
1798 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 1799 if (htab == NULL)
1800 return FALSE;
84e94c90
NC		 1801
1802 eh = (struct elf_lm32_link_hash_entry *) h;
1803
1804 if (htab->root.dynamic_sections_created
1805 && h->plt.refcount > 0)
1806 {
1807 /* Make sure this symbol is output as a dynamic symbol.
1808 Undefined weak syms won't yet be marked as dynamic. */
1809 if (h->dynindx == -1
1810 && !h->forced_local)
1811 {
1812 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1813 return FALSE;
1814 }
1815
0e1862bb 1816 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
84e94c90 1817 {
ce558b89 1818 asection *s = htab->root.splt;
84e94c90
NC		 1819
1820 /* If this is the first .plt entry, make room for the special
1821 first entry. */
1822 if (s->size == 0)
1823 s->size += PLT_ENTRY_SIZE;
1824
1825 h->plt.offset = s->size;
1826
1827 /* If this symbol is not defined in a regular file, and we are
1828 not generating a shared library, then set the symbol to this
1829 location in the .plt. This is required to make function
1830 pointers compare as equal between the normal executable and
1831 the shared library. */
0e1862bb 1832 if (! bfd_link_pic (info)
84e94c90
NC		 1833 && !h->def_regular)
1834 {
1835 h->root.u.def.section = s;
1836 h->root.u.def.value = h->plt.offset;
1837 }
1838
1839 /* Make room for this entry. */
1840 s->size += PLT_ENTRY_SIZE;
1841
1842 /* We also need to make an entry in the .got.plt section, which
1843 will be placed in the .got section by the linker script. */
ce558b89 1844 htab->root.sgotplt->size += 4;
84e94c90
NC		 1845
1846 /* We also need to make an entry in the .rel.plt section. */
ce558b89 1847 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
84e94c90
NC		 1848 }
1849 else
1850 {
1851 h->plt.offset = (bfd_vma) -1;
1852 h->needs_plt = 0;
1853 }
1854 }
1855 else
1856 {
1857 h->plt.offset = (bfd_vma) -1;
1858 h->needs_plt = 0;
1859 }
1860
1861 if (h->got.refcount > 0)
1862 {
1863 asection *s;
1864 bfd_boolean dyn;
1865
1866 /* Make sure this symbol is output as a dynamic symbol.
1867 Undefined weak syms won't yet be marked as dynamic. */
1868 if (h->dynindx == -1
1869 && !h->forced_local)
1870 {
1871 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1872 return FALSE;
1873 }
1874
ce558b89 1875 s = htab->root.sgot;
84e94c90
NC		 1876
1877 h->got.offset = s->size;
1878 s->size += 4;
1879 dyn = htab->root.dynamic_sections_created;
0e1862bb 1880 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
ce558b89 1881 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
84e94c90
NC		 1882 }
1883 else
1884 h->got.offset = (bfd_vma) -1;
1885
1886 if (eh->dyn_relocs == NULL)
1887 return TRUE;
1888
1889 /* In the shared -Bsymbolic case, discard space allocated for
1890 dynamic pc-relative relocs against symbols which turn out to be
1891 defined in regular objects. For the normal shared case, discard
1892 space for pc-relative relocs that have become local due to symbol
1893 visibility changes. */
1894
0e1862bb 1895 if (bfd_link_pic (info))
84e94c90
NC		 1896 {
1897 if (h->def_regular
1898 && (h->forced_local
1899 || info->symbolic))
1900 {
1901 struct elf_lm32_dyn_relocs **pp;
1902
1903 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1904 {
1905 p->count -= p->pc_count;
1906 p->pc_count = 0;
1907 if (p->count == 0)
1908 *pp = p->next;
1909 else
1910 pp = &p->next;
1911 }
1912 }
1913
1914 /* Also discard relocs on undefined weak syms with non-default
1915 visibility. */
1916 if (eh->dyn_relocs != NULL
1917 && h->root.type == bfd_link_hash_undefweak)
1918 {
1919 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1920 eh->dyn_relocs = NULL;
1921
1922 /* Make sure undefined weak symbols are output as a dynamic
1923 symbol in PIEs. */
1924 else if (h->dynindx == -1
1925 && !h->forced_local)
1926 {
1927 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1928 return FALSE;
1929 }
1930 }
1931 }
1932 else
1933 {
1934 /* For the non-shared case, discard space for relocs against
1935 symbols which turn out to need copy relocs or are not
1936 dynamic. */
1937
1938 if (!h->non_got_ref
1939 && ((h->def_dynamic
1940 && !h->def_regular)
1941 || (htab->root.dynamic_sections_created
1942 && (h->root.type == bfd_link_hash_undefweak
1943 || h->root.type == bfd_link_hash_undefined))))
1944 {
1945 /* Make sure this symbol is output as a dynamic symbol.
1946 Undefined weak syms won't yet be marked as dynamic. */
1947 if (h->dynindx == -1
1948 && !h->forced_local)
1949 {
1950 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1951 return FALSE;
1952 }
1953
1954 /* If that succeeded, we know we'll be keeping all the
1955 relocs. */
1956 if (h->dynindx != -1)
1957 goto keep;
1958 }
1959
1960 eh->dyn_relocs = NULL;
1961
1962 keep: ;
1963 }
1964
1965 /* Finally, allocate space. */
1966 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1967 {
1968 asection *sreloc = elf_section_data (p->sec)->sreloc;
1969 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1970 }
1971
1972 return TRUE;
1973}
1974
1975/* Find any dynamic relocs that apply to read-only sections. */
1976
1977static bfd_boolean
1978readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1979{
1980 struct elf_lm32_link_hash_entry *eh;
1981 struct elf_lm32_dyn_relocs *p;
1982
84e94c90
NC		 1983 eh = (struct elf_lm32_link_hash_entry *) h;
1984 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1985 {
1986 asection *s = p->sec->output_section;
1987
1988 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1989 {
1990 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1991
1992 info->flags |= DF_TEXTREL;
1993
1994 /* Not an error, just cut short the traversal. */
1995 return FALSE;
1996 }
1997 }
1998 return TRUE;
1999}
2000
2001/* Set the sizes of the dynamic sections. */
2002
2003static bfd_boolean
2004lm32_elf_size_dynamic_sections (bfd *output_bfd,
2005 struct bfd_link_info *info)
2006{
2007 struct elf_lm32_link_hash_table *htab;
2008 bfd *dynobj;
2009 asection *s;
2010 bfd_boolean relocs;
2011 bfd *ibfd;
2012
2013 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 2014 if (htab == NULL)
2015 return FALSE;
2016
84e94c90
NC		 2017 dynobj = htab->root.dynobj;
2018 BFD_ASSERT (dynobj != NULL);
2019
2020 if (htab->root.dynamic_sections_created)
2021 {
2022 /* Set the contents of the .interp section to the interpreter. */
9b8b325a 2023 if (bfd_link_executable (info) && !info->nointerp)
84e94c90 2024 {
3d4d4302 2025 s = bfd_get_linker_section (dynobj, ".interp");
84e94c90
NC		 2026 BFD_ASSERT (s != NULL);
2027 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2028 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2029 }
2030 }
2031
2032 /* Set up .got offsets for local syms, and space for local dynamic
2033 relocs. */
c72f2fb2 2034 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
84e94c90
NC		 2035 {
2036 bfd_signed_vma *local_got;
2037 bfd_signed_vma *end_local_got;
2038 bfd_size_type locsymcount;
2039 Elf_Internal_Shdr *symtab_hdr;
2040 asection *srel;
2041
2042 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2043 continue;
2044
2045 for (s = ibfd->sections; s != NULL; s = s->next)
2046 {
2047 struct elf_lm32_dyn_relocs *p;
2048
2049 for (p = ((struct elf_lm32_dyn_relocs *)
2050 elf_section_data (s)->local_dynrel);
2051 p != NULL;
2052 p = p->next)
2053 {
2054 if (! bfd_is_abs_section (p->sec)
2055 && bfd_is_abs_section (p->sec->output_section))
2056 {
2057 /* Input section has been discarded, either because
2058 it is a copy of a linkonce section or due to
2059 linker script /DISCARD/, so we'll be discarding
2060 the relocs too. */
2061 }
2062 else if (p->count != 0)
2063 {
2064 srel = elf_section_data (p->sec)->sreloc;
2065 srel->size += p->count * sizeof (Elf32_External_Rela);
2066 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2067 info->flags |= DF_TEXTREL;
2068 }
2069 }
2070 }
2071
2072 local_got = elf_local_got_refcounts (ibfd);
2073 if (!local_got)
2074 continue;
2075
2076 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2077 locsymcount = symtab_hdr->sh_info;
2078 end_local_got = local_got + locsymcount;
ce558b89
AM		 2079 s = htab->root.sgot;
2080 srel = htab->root.srelgot;
84e94c90
NC		 2081 for (; local_got < end_local_got; ++local_got)
2082 {
2083 if (*local_got > 0)
2084 {
2085 *local_got = s->size;
2086 s->size += 4;
0e1862bb 2087 if (bfd_link_pic (info))
84e94c90
NC		 2088 srel->size += sizeof (Elf32_External_Rela);
2089 }
2090 else
2091 *local_got = (bfd_vma) -1;
2092 }
2093 }
2094
2095 /* Allocate global sym .plt and .got entries, and space for global
2096 sym dynamic relocs. */
2097 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2098
2099 /* We now have determined the sizes of the various dynamic sections.
2100 Allocate memory for them. */
2101 relocs = FALSE;
2102 for (s = dynobj->sections; s != NULL; s = s->next)
2103 {
2104 if ((s->flags & SEC_LINKER_CREATED) == 0)
2105 continue;
2106
ce558b89
AM		 2107 if (s == htab->root.splt
2108 || s == htab->root.sgot
2109 || s == htab->root.sgotplt
84e94c90
NC		 2110 || s == htab->sdynbss)
2111 {
2112 /* Strip this section if we don't need it; see the
2113 comment below. */
2114 }
2115 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2116 {
ce558b89 2117 if (s->size != 0 && s != htab->root.srelplt)
84e94c90
NC		 2118 relocs = TRUE;
2119
2120 /* We use the reloc_count field as a counter if we need
2121 to copy relocs into the output file. */
2122 s->reloc_count = 0;
2123 }
2124 else
2125 /* It's not one of our sections, so don't allocate space. */
2126 continue;
2127
2128 if (s->size == 0)
2129 {
2130 /* If we don't need this section, strip it from the
2131 output file. This is mostly to handle .rela.bss and
2132 .rela.plt. We must create both sections in
2133 create_dynamic_sections, because they must be created
2134 before the linker maps input sections to output
2135 sections. The linker does that before
2136 adjust_dynamic_symbol is called, and it is that
2137 function which decides whether anything needs to go
2138 into these sections. */
2139 s->flags |= SEC_EXCLUDE;
2140 continue;
2141 }
2142
2143 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2144 continue;
2145
2146 /* Allocate memory for the section contents. We use bfd_zalloc
2147 here in case unused entries are not reclaimed before the
2148 section's contents are written out. This should not happen,
2149 but this way if it does, we get a R_LM32_NONE reloc instead
2150 of garbage. */
2151 s->contents = bfd_zalloc (dynobj, s->size);
2152 if (s->contents == NULL)
2153 return FALSE;
2154 }
2155
2156 if (htab->root.dynamic_sections_created)
2157 {
2158 /* Add some entries to the .dynamic section. We fill in the
2159 values later, in lm32_elf_finish_dynamic_sections, but we
2160 must add the entries now so that we get the correct size for
2161 the .dynamic section. The DT_DEBUG entry is filled in by the
2162 dynamic linker and used by the debugger. */
2163#define add_dynamic_entry(TAG, VAL) \
2164 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2165
0e1862bb 2166 if (bfd_link_executable (info))
84e94c90
NC		 2167 {
2168 if (! add_dynamic_entry (DT_DEBUG, 0))
2169 return FALSE;
2170 }
2171
ce558b89 2172 if (htab->root.splt->size != 0)
84e94c90
NC		 2173 {
2174 if (! add_dynamic_entry (DT_PLTGOT, 0)
2175 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2176 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2177 || ! add_dynamic_entry (DT_JMPREL, 0))
2178 return FALSE;
2179 }
2180
2181 if (relocs)
2182 {
2183 if (! add_dynamic_entry (DT_RELA, 0)
2184 || ! add_dynamic_entry (DT_RELASZ, 0)
2185 || ! add_dynamic_entry (DT_RELAENT,
2186 sizeof (Elf32_External_Rela)))
2187 return FALSE;
2188
2189 /* If any dynamic relocs apply to a read-only section,
2190 then we need a DT_TEXTREL entry. */
2191 if ((info->flags & DF_TEXTREL) == 0)
2192 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2193 info);
2194
2195 if ((info->flags & DF_TEXTREL) != 0)
2196 {
2197 if (! add_dynamic_entry (DT_TEXTREL, 0))
2198 return FALSE;
2199 }
2200 }
2201 }
2202#undef add_dynamic_entry
2203
2204 /* Allocate .rofixup section. */
2205 if (IS_FDPIC (output_bfd))
2206 {
2207 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2208 int rgot_weak_count = 0;
2209 int r32_count = 0;
2210 int rgot_count = 0;
2211 /* Look for deleted sections. */
c72f2fb2 2212 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
84e94c90
NC		 2213 {
2214 for (s = ibfd->sections; s != NULL; s = s->next)
2215 {
2216 if (s->reloc_count)
2217 {
2218 /* Count relocs that need .rofixup entires. */
2219 Elf_Internal_Rela *internal_relocs, *end;
2220 internal_relocs = elf_section_data (s)->relocs;
2221 if (internal_relocs == NULL)
2222 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2223 if (internal_relocs != NULL)
2224 {
2225 end = internal_relocs + s->reloc_count;
2226 while (internal_relocs < end)
2227 {
2228 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2229 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2230 unsigned long r_symndx;
2231 struct elf_link_hash_entry *h;
2232
2233 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2234 sym_hashes = elf_sym_hashes (ibfd);
2235 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2236 h = NULL;
2237 if (r_symndx < symtab_hdr->sh_info)
2238 {
2239 }
2240 else
2241 {
2242 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2243 while (h->root.type == bfd_link_hash_indirect
2244 || h->root.type == bfd_link_hash_warning)
2245 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2246 }
2247
2248 /* Don't generate entries for weak symbols. */
2249 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2250 {
dbaa2011 2251 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
84e94c90
NC		 2252 {
2253 switch (ELF32_R_TYPE (internal_relocs->r_info))
2254 {
2255 case R_LM32_32:
2256 r32_count++;
2257 break;
2258 case R_LM32_16_GOT:
2259 rgot_count++;
2260 break;
2261 }
2262 }
2263 }
2264 else
2265 {
2266 struct weak_symbol_list *current, *new_entry;
2267 /* Is this symbol already in the list? */
2268 for (current = list_start; current; current = current->next)
2269 {
2270 if (!strcmp (current->name, h->root.root.string))
2271 break;
2272 }
dbaa2011 2273 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
84e94c90
NC		 2274 {
2275 /* Will this have an entry in the GOT. */
2276 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2277 {
2278 /* Create a new entry. */
2279 new_entry = malloc (sizeof (struct weak_symbol_list));
2280 if (!new_entry)
2281 return FALSE;
2282 new_entry->name = h->root.root.string;
2283 new_entry->next = NULL;
2284 /* Add to list */
2285 if (list_start == NULL)
2286 {
2287 list_start = new_entry;
2288 list_end = new_entry;
2289 }
2290 else
2291 {
2292 list_end->next = new_entry;
2293 list_end = new_entry;
2294 }
2295 /* Increase count of undefined weak symbols in the got. */
2296 rgot_weak_count++;
2297 }
2298 }
2299 }
2300 internal_relocs++;
2301 }
2302 }
2303 else
2304 return FALSE;
2305 }
2306 }
2307 }
2308 /* Free list. */
2309 while (list_start)
2310 {
2311 list_end = list_start->next;
2312 free (list_start);
2313 list_start = list_end;
2314 }
2315
2316 /* Size sections. */
ce558b89
AM		 2317 lm32fdpic_fixup32_section (info)->size
2318 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
84e94c90
NC		 2319 if (lm32fdpic_fixup32_section (info)->size == 0)
2320 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2321 else
2322 {
2323 lm32fdpic_fixup32_section (info)->contents =
2324 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2325 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2326 return FALSE;
2327 }
2328 }
2329
2330 return TRUE;
2331}
2332
2333/* Create dynamic sections when linking against a dynamic object. */
2334
2335static bfd_boolean
2336lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2337{
2338 struct elf_lm32_link_hash_table *htab;
2339 flagword flags, pltflags;
2340 asection *s;
2341 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2342 int ptralign = 2; /* 32bit */
2343
2344 htab = lm32_elf_hash_table (info);
4dfe6ac6
NC		 2345 if (htab == NULL)
2346 return FALSE;
84e94c90
NC		 2347
2348 /* Make sure we have a GOT - For the case where we have a dynamic object
2349 but none of the relocs in check_relocs */
ce558b89 2350 if (!_bfd_elf_create_got_section (abfd, info))
84e94c90
NC		 2351 return FALSE;
2352 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2353 {
2354 if (! create_rofixup_section (abfd, info))
2355 return FALSE;
2356 }
2357
2358 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2359 .rel[a].bss sections. */
2360 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2361 | SEC_LINKER_CREATED);
2362
2363 pltflags = flags;
2364 pltflags |= SEC_CODE;
2365 if (bed->plt_not_loaded)
2366 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2367 if (bed->plt_readonly)
2368 pltflags |= SEC_READONLY;
2369
3d4d4302 2370 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
ce558b89 2371 htab->root.splt = s;
84e94c90
NC		 2372 if (s == NULL
2373 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2374 return FALSE;
2375
2376 if (bed->want_plt_sym)
2377 {
2378 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2379 .plt section. */
2380 struct bfd_link_hash_entry *bh = NULL;
2381 struct elf_link_hash_entry *h;
2382
2383 if (! (_bfd_generic_link_add_one_symbol
2384 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2385 (bfd_vma) 0, NULL, FALSE,
2386 get_elf_backend_data (abfd)->collect, &bh)))
2387 return FALSE;
2388 h = (struct elf_link_hash_entry *) bh;
2389 h->def_regular = 1;
2390 h->type = STT_OBJECT;
2391 htab->root.hplt = h;
2392
0e1862bb 2393 if (bfd_link_pic (info)
84e94c90
NC		 2394 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2395 return FALSE;
2396 }
2397
3d4d4302
AM		 2398 s = bfd_make_section_anyway_with_flags (abfd,
2399 bed->default_use_rela_p
2400 ? ".rela.plt" : ".rel.plt",
2401 flags | SEC_READONLY);
ce558b89 2402 htab->root.srelplt = s;
84e94c90
NC		 2403 if (s == NULL
2404 || ! bfd_set_section_alignment (abfd, s, ptralign))
2405 return FALSE;
2406
ce558b89
AM		 2407 if (htab->root.sgot == NULL
2408 && !_bfd_elf_create_got_section (abfd, info))
84e94c90
NC		 2409 return FALSE;
2410
84e94c90
NC		 2411 if (bed->want_dynbss)
2412 {
2413 /* The .dynbss section is a place to put symbols which are defined
2414 by dynamic objects, are referenced by regular objects, and are
2415 not functions. We must allocate space for them in the process
2416 image and use a R_*_COPY reloc to tell the dynamic linker to
2417 initialize them at run time. The linker script puts the .dynbss
2418 section into the .bss section of the final image. */
3d4d4302
AM		 2419 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2420 SEC_ALLOC | SEC_LINKER_CREATED);
84e94c90
NC		 2421 htab->sdynbss = s;
2422 if (s == NULL)
2423 return FALSE;
2424 /* The .rel[a].bss section holds copy relocs. This section is not
2425 normally needed. We need to create it here, though, so that the
2426 linker will map it to an output section. We can't just create it
2427 only if we need it, because we will not know whether we need it
2428 until we have seen all the input files, and the first time the
2429 main linker code calls BFD after examining all the input files
2430 (size_dynamic_sections) the input sections have already been
2431 mapped to the output sections. If the section turns out not to
2432 be needed, we can discard it later. We will never need this
2433 section when generating a shared object, since they do not use
2434 copy relocs. */
0e1862bb 2435 if (! bfd_link_pic (info))
84e94c90 2436 {
3d4d4302
AM		 2437 s = bfd_make_section_anyway_with_flags (abfd,
2438 (bed->default_use_rela_p
2439 ? ".rela.bss" : ".rel.bss"),
2440 flags | SEC_READONLY);
84e94c90
NC		 2441 htab->srelbss = s;
2442 if (s == NULL
2443 || ! bfd_set_section_alignment (abfd, s, ptralign))
2444 return FALSE;
2445 }
2446 }
2447
2448 return TRUE;
2449}
2450
2451/* Copy the extra info we tack onto an elf_link_hash_entry. */
2452
2453static void
2454lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2455 struct elf_link_hash_entry *dir,
2456 struct elf_link_hash_entry *ind)
2457{
2458 struct elf_lm32_link_hash_entry * edir;
2459 struct elf_lm32_link_hash_entry * eind;
2460
2461 edir = (struct elf_lm32_link_hash_entry *) dir;
2462 eind = (struct elf_lm32_link_hash_entry *) ind;
2463
2464 if (eind->dyn_relocs != NULL)
2465 {
2466 if (edir->dyn_relocs != NULL)
2467 {
2468 struct elf_lm32_dyn_relocs **pp;
2469 struct elf_lm32_dyn_relocs *p;
2470
2471 /* Add reloc counts against the indirect sym to the direct sym
2472 list. Merge any entries against the same section. */
2473 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2474 {
2475 struct elf_lm32_dyn_relocs *q;
2476
2477 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2478 if (q->sec == p->sec)
2479 {
2480 q->pc_count += p->pc_count;
2481 q->count += p->count;
2482 *pp = p->next;
2483 break;
2484 }
2485 if (q == NULL)
2486 pp = &p->next;
2487 }
2488 *pp = edir->dyn_relocs;
2489 }
2490
2491 edir->dyn_relocs = eind->dyn_relocs;
2492 eind->dyn_relocs = NULL;
2493 }
2494
2495 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2496}
2497
2498static bfd_boolean
04c3a755 2499lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
84e94c90 2500{
0e1862bb 2501 if (!bfd_link_relocatable (info))
84e94c90 2502 {
04c3a755
NS		 2503 if (!bfd_elf_stack_segment_size (output_bfd, info,
2504 "__stacksize", DEFAULT_STACK_SIZE))
2505 return FALSE;
84e94c90 2506
84e94c90 2507 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
84e94c90 2508 if (sec)
04c3a755 2509 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
84e94c90
NC		 2510 }
2511
2512 return TRUE;
2513}
2514
84e94c90
NC		 2515static bfd_boolean
2516lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2517{
2518 unsigned i;
2519
2520 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2521 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2522 return TRUE;
2523
e2349352 2524 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
84e94c90
NC		 2525 return FALSE;
2526
2527 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2528 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2529 return TRUE;
2530
2531 /* Copy the stack size. */
2532 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2533 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2534 {
2535 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2536
2537 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2538 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2539 {
2540 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2541
2542 /* Rewrite the phdrs, since we're only called after they were first written. */
2543 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2544 ->s->sizeof_ehdr, SEEK_SET) != 0
2545 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2546 elf_elfheader (obfd)->e_phnum) != 0)
2547 return FALSE;
2548 break;
2549 }
2550
2551 break;
2552 }
2553
2554 return TRUE;
2555}
2556
2557
2558#define ELF_ARCH bfd_arch_lm32
ae95ffa6 2559#define ELF_TARGET_ID LM32_ELF_DATA
84e94c90
NC		 2560#define ELF_MACHINE_CODE EM_LATTICEMICO32
2561#define ELF_MAXPAGESIZE 0x1000
2562
6d00b590 2563#define TARGET_BIG_SYM lm32_elf32_vec
84e94c90
NC		 2564#define TARGET_BIG_NAME "elf32-lm32"
2565
2566#define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2567#define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2568#define elf_info_to_howto lm32_info_to_howto_rela
2569#define elf_info_to_howto_rel 0
2570#define elf_backend_rela_normal 1
2571#define elf_backend_object_p lm32_elf_object_p
2572#define elf_backend_final_write_processing lm32_elf_final_write_processing
04c3a755 2573#define elf_backend_stack_align 8
84e94c90
NC		 2574#define elf_backend_can_gc_sections 1
2575#define elf_backend_can_refcount 1
2576#define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
84e94c90
NC		 2577#define elf_backend_plt_readonly 1
2578#define elf_backend_want_got_plt 1
2579#define elf_backend_want_plt_sym 0
2580#define elf_backend_got_header_size 12
64f52338 2581#define elf_backend_dtrel_excludes_plt 1
84e94c90
NC		 2582#define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2583#define elf_backend_check_relocs lm32_elf_check_relocs
2584#define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2585#define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2586#define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2587#define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2588#define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2589#define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2590#define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2591#define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2592#define elf_backend_relocate_section lm32_elf_relocate_section
2593
2594#include "elf32-target.h"
2595
2596#undef ELF_MAXPAGESIZE
2597#define ELF_MAXPAGESIZE 0x4000
2598
2599
2600#undef TARGET_BIG_SYM
6d00b590 2601#define TARGET_BIG_SYM lm32_elf32_fdpic_vec
84e94c90
NC		 2602#undef TARGET_BIG_NAME
2603#define TARGET_BIG_NAME "elf32-lm32fdpic"
2604#undef elf32_bed
2605#define elf32_bed elf32_lm32fdpic_bed
2606
2607#undef elf_backend_always_size_sections
2608#define elf_backend_always_size_sections lm32_elf_always_size_sections
84e94c90
NC		 2609#undef bfd_elf32_bfd_copy_private_bfd_data
2610#define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2611
2612#include "elf32-target.h"
A mirror of the official binutils-gdb repository