?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update my e-mail address.
[binutils-gdb.git] / bfd / elf32-lm32.c
blobf0b46c90851579c829ef5bf7427fc824eaea1196
1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright (C) 2008-2017 Free Software Foundation, Inc.
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
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/lm32.h"
27
28 #define DEFAULT_STACK_SIZE 0x20000
29
30 #define PLT_ENTRY_SIZE 20
31
32 #define PLT0_ENTRY_WORD0 0
33 #define PLT0_ENTRY_WORD1 0
34 #define PLT0_ENTRY_WORD2 0
35 #define PLT0_ENTRY_WORD3 0
36 #define PLT0_ENTRY_WORD4 0
37
38 #define PLT0_PIC_ENTRY_WORD0 0
39 #define PLT0_PIC_ENTRY_WORD1 0
40 #define PLT0_PIC_ENTRY_WORD2 0
41 #define PLT0_PIC_ENTRY_WORD3 0
42 #define PLT0_PIC_ENTRY_WORD4 0
43
44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
45
46 extern const bfd_target lm32_elf32_fdpic_vec;
47
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec)
49
50 static 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
59 struct 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
75 struct 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
85 struct elf_lm32_link_hash_table
86 {
87 struct elf_link_hash_table root;
88
89 /* Short-cuts to get to dynamic linker sections. */
90 asection *sfixup32;
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) \
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)
102
103 #define lm32fdpic_got_section(info) \
104 (lm32_elf_hash_table (info)->root.sgot)
105 #define lm32fdpic_gotrel_section(info) \
106 (lm32_elf_hash_table (info)->root.srelgot)
107 #define lm32fdpic_fixup32_section(info) \
108 (lm32_elf_hash_table (info)->sfixup32)
109
110 struct 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
118 static struct bfd_hash_entry *
119 lm32_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
151 static struct bfd_link_hash_table *
152 lm32_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
157 ret = bfd_zmalloc (amt);
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,
163 sizeof (struct elf_lm32_link_hash_entry),
164 LM32_ELF_DATA))
165 {
166 free (ret);
167 return NULL;
168 }
169
170 return &ret->root.root;
171 }
172
173 /* Add a fixup to the ROFIXUP section. */
174
175 static 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
195 /* Create .rofixup sections in DYNOBJ, and set up
196 shortcuts to them in our hash table. */
197
198 static bfd_boolean
199 create_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
204 if (htab == NULL)
205 return FALSE;
206
207 /* Fixup section for R_LM32_32 relocs. */
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));
217 if (lm32fdpic_fixup32_section (info) == NULL
218 || ! bfd_set_section_alignment (dynobj,
219 lm32fdpic_fixup32_section (info), 2))
220 return FALSE;
221
222 return TRUE;
223 }
224
225 static reloc_howto_type lm32_elf_howto_table [] =
226 {
227 /* This reloc does nothing. */
228 HOWTO (R_LM32_NONE, /* type */
229 0, /* rightshift */
230 3, /* size (0 = byte, 1 = short, 2 = long) */
231 0, /* bitsize */
232 FALSE, /* pc_relative */
233 0, /* bitpos */
234 complain_overflow_dont, /* complain_on_overflow */
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
489 struct lm32_reloc_map
490 {
491 bfd_reloc_code_real_type bfd_reloc_val;
492 unsigned char elf_reloc_val;
493 };
494
495 static 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
517 static reloc_howto_type *
518 lm32_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
529 static reloc_howto_type *
530 lm32_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
548 static void
549 lm32_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);
556 if (r_type >= (unsigned int) R_LM32_max)
557 {
558 /* xgettext:c-format */
559 _bfd_error_handler (_("%B: invalid LM32 reloc number: %d"), abfd, r_type);
560 r_type = 0;
561 }
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
567 static bfd_boolean
568 lm32_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
575 static void
576 lm32_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
593 static bfd_boolean
594 lm32_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
645 static bfd_reloc_status_type
646 lm32_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
676 static bfd_reloc_status_type
677 lm32_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
689 static bfd_reloc_status_type
690 lm32_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
741 static 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. */
748 for (m = elf_seg_map (output_bfd), p = elf_tdata (output_bfd)->phdr;
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
767 inline 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
777 static bfd_boolean
778 lm32_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;
790 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
791 bfd_vma *local_got_offsets;
792 asection *sgot;
793
794 if (htab == NULL)
795 return FALSE;
796
797 local_got_offsets = elf_local_got_offsets (input_bfd);
798
799 sgot = htab->root.sgot;
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;
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;
836 sec = local_sections[r_symndx];
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;
846 bfd_boolean warned, ignored;
847
848 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
849 r_symndx, symtab_hdr, sym_hashes,
850 h, sec, relocation,
851 unresolved_reloc, warned, ignored);
852 name = h->root.root.string;
853 }
854
855 if (sec != NULL && discarded_section (sec))
856 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
857 rel, 1, relend, howto, 0, contents);
858
859 if (bfd_link_relocatable (info))
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;
912 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
913 bfd_link_pic (info),
914 h)
915 || (bfd_link_pic (info)
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
988 if (bfd_link_pic (info))
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. */
995 srelgot = htab->root.srelgot;
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)
1018 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
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 {
1093 const char *msg = NULL;
1094 arelent bfd_reloc;
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;
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);
1118 break;
1119
1120 case bfd_reloc_undefined:
1121 (*info->callbacks->undefined_symbol)
1122 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
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:
1142 (*info->callbacks->warning) (info, msg, name, input_bfd,
1143 input_section, rel->r_offset);
1144 break;
1145 }
1146 }
1147 }
1148
1149 return TRUE;
1150 }
1151
1152 static asection *
1153 lm32_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
1170 /* Look through the relocs for a section during the first phase. */
1171
1172 static bfd_boolean
1173 lm32_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;
1184
1185 if (bfd_link_relocatable (info))
1186 return TRUE;
1187
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);
1195 if (htab == NULL)
1196 return FALSE;
1197
1198 dynobj = htab->root.dynobj;
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 /* PR15323, ref flags aren't set for references in the same
1219 object. */
1220 h->root.non_ir_ref_regular = 1;
1221 }
1222
1223 /* Some relocs require a global offset table. */
1224 if (htab->root.sgot == NULL)
1225 {
1226 switch (r_type)
1227 {
1228 case R_LM32_16_GOT:
1229 case R_LM32_GOTOFF_HI16:
1230 case R_LM32_GOTOFF_LO16:
1231 if (dynobj == NULL)
1232 htab->root.dynobj = dynobj = abfd;
1233 if (!_bfd_elf_create_got_section (dynobj, info))
1234 return FALSE;
1235 break;
1236 }
1237 }
1238
1239 /* Some relocs require a rofixup table. */
1240 if (IS_FDPIC (abfd))
1241 {
1242 switch (r_type)
1243 {
1244 case R_LM32_32:
1245 /* FDPIC requires a GOT if there is a .rofixup section
1246 (Normal ELF doesn't). */
1247 if (dynobj == NULL)
1248 htab->root.dynobj = dynobj = abfd;
1249 if (!_bfd_elf_create_got_section (dynobj, info))
1250 return FALSE;
1251 /* Create .rofixup section */
1252 if (htab->sfixup32 == NULL)
1253 {
1254 if (! create_rofixup_section (dynobj, info))
1255 return FALSE;
1256 }
1257 break;
1258 case R_LM32_16_GOT:
1259 case R_LM32_GOTOFF_HI16:
1260 case R_LM32_GOTOFF_LO16:
1261 /* Create .rofixup section. */
1262 if (htab->sfixup32 == NULL)
1263 {
1264 if (dynobj == NULL)
1265 htab->root.dynobj = dynobj = abfd;
1266 if (! create_rofixup_section (dynobj, info))
1267 return FALSE;
1268 }
1269 break;
1270 }
1271 }
1272
1273 switch (r_type)
1274 {
1275 case R_LM32_16_GOT:
1276 if (h != NULL)
1277 h->got.refcount += 1;
1278 else
1279 {
1280 bfd_signed_vma *local_got_refcounts;
1281
1282 /* This is a global offset table entry for a local symbol. */
1283 local_got_refcounts = elf_local_got_refcounts (abfd);
1284 if (local_got_refcounts == NULL)
1285 {
1286 bfd_size_type size;
1287
1288 size = symtab_hdr->sh_info;
1289 size *= sizeof (bfd_signed_vma);
1290 local_got_refcounts = bfd_zalloc (abfd, size);
1291 if (local_got_refcounts == NULL)
1292 return FALSE;
1293 elf_local_got_refcounts (abfd) = local_got_refcounts;
1294 }
1295 local_got_refcounts[r_symndx] += 1;
1296 }
1297 break;
1298
1299 /* This relocation describes the C++ object vtable hierarchy.
1300 Reconstruct it for later use during GC. */
1301 case R_LM32_GNU_VTINHERIT:
1302 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1303 return FALSE;
1304 break;
1305
1306 /* This relocation describes which C++ vtable entries are actually
1307 used. Record for later use during GC. */
1308 case R_LM32_GNU_VTENTRY:
1309 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1310 return FALSE;
1311 break;
1312
1313 }
1314 }
1315
1316 return TRUE;
1317 }
1318
1319 /* Finish up the dynamic sections. */
1320
1321 static bfd_boolean
1322 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1323 struct bfd_link_info *info)
1324 {
1325 struct elf_lm32_link_hash_table *htab;
1326 bfd *dynobj;
1327 asection *sdyn;
1328 asection *sgot;
1329
1330 htab = lm32_elf_hash_table (info);
1331 if (htab == NULL)
1332 return FALSE;
1333
1334 dynobj = htab->root.dynobj;
1335
1336 sgot = htab->root.sgotplt;
1337 sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1338
1339 if (htab->root.dynamic_sections_created)
1340 {
1341 asection *splt;
1342 Elf32_External_Dyn *dyncon, *dynconend;
1343
1344 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1345
1346 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1347 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1348
1349 for (; dyncon < dynconend; dyncon++)
1350 {
1351 Elf_Internal_Dyn dyn;
1352 asection *s;
1353
1354 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1355
1356 switch (dyn.d_tag)
1357 {
1358 default:
1359 break;
1360
1361 case DT_PLTGOT:
1362 s = htab->root.sgotplt;
1363 goto get_vma;
1364 case DT_JMPREL:
1365 s = htab->root.srelplt;
1366 get_vma:
1367 dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1368 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1369 break;
1370
1371 case DT_PLTRELSZ:
1372 s = htab->root.srelplt;
1373 dyn.d_un.d_val = s->size;
1374 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1375 break;
1376 }
1377 }
1378
1379 /* Fill in the first entry in the procedure linkage table. */
1380 splt = htab->root.splt;
1381 if (splt && splt->size > 0)
1382 {
1383 if (bfd_link_pic (info))
1384 {
1385 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1386 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1387 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1388 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1389 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1390 }
1391 else
1392 {
1393 unsigned long addr;
1394 /* addr = .got + 4 */
1395 addr = sgot->output_section->vma + sgot->output_offset + 4;
1396 bfd_put_32 (output_bfd,
1397 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1398 splt->contents);
1399 bfd_put_32 (output_bfd,
1400 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1401 splt->contents + 4);
1402 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1403 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1404 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1405 }
1406
1407 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1408 PLT_ENTRY_SIZE;
1409 }
1410 }
1411
1412 /* Fill in the first three entries in the global offset table. */
1413 if (sgot && sgot->size > 0)
1414 {
1415 if (sdyn == NULL)
1416 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1417 else
1418 bfd_put_32 (output_bfd,
1419 sdyn->output_section->vma + sdyn->output_offset,
1420 sgot->contents);
1421 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1422 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1423
1424 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1425 if (elf_section_data (sgot->output_section) != NULL)
1426 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1427 }
1428
1429 if (lm32fdpic_fixup32_section (info))
1430 {
1431 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1432 bfd_vma got_value = hgot->root.u.def.value
1433 + hgot->root.u.def.section->output_section->vma
1434 + hgot->root.u.def.section->output_offset;
1435 struct bfd_link_hash_entry *hend;
1436
1437 /* Last entry is pointer to GOT. */
1438 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1439
1440 /* Check we wrote enough entries. */
1441 if (lm32fdpic_fixup32_section (info)->size
1442 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1443 {
1444 _bfd_error_handler
1445 ("LINKER BUG: .rofixup section size mismatch: size/4 %Ld != relocs %d",
1446 lm32fdpic_fixup32_section (info)->size/4,
1447 lm32fdpic_fixup32_section (info)->reloc_count);
1448 return FALSE;
1449 }
1450
1451 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1452 FALSE, FALSE, TRUE);
1453 if (hend
1454 && (hend->type == bfd_link_hash_defined
1455 || hend->type == bfd_link_hash_defweak))
1456 {
1457 bfd_vma value =
1458 lm32fdpic_fixup32_section (info)->output_section->vma
1459 + lm32fdpic_fixup32_section (info)->output_offset
1460 + lm32fdpic_fixup32_section (info)->size
1461 - hend->u.def.section->output_section->vma
1462 - hend->u.def.section->output_offset;
1463 BFD_ASSERT (hend->u.def.value == value);
1464 if (hend->u.def.value != value)
1465 {
1466 _bfd_error_handler
1467 ("LINKER BUG: .rofixup section hend->u.def.value != value: %Ld != %Ld", hend->u.def.value, value);
1468 return FALSE;
1469 }
1470 }
1471 }
1472
1473 return TRUE;
1474 }
1475
1476 /* Finish up dynamic symbol handling. We set the contents of various
1477 dynamic sections here. */
1478
1479 static bfd_boolean
1480 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1481 struct bfd_link_info *info,
1482 struct elf_link_hash_entry *h,
1483 Elf_Internal_Sym *sym)
1484 {
1485 struct elf_lm32_link_hash_table *htab;
1486 bfd_byte *loc;
1487
1488 htab = lm32_elf_hash_table (info);
1489 if (htab == NULL)
1490 return FALSE;
1491
1492 if (h->plt.offset != (bfd_vma) -1)
1493 {
1494 asection *splt;
1495 asection *sgot;
1496 asection *srela;
1497
1498 bfd_vma plt_index;
1499 bfd_vma got_offset;
1500 Elf_Internal_Rela rela;
1501
1502 /* This symbol has an entry in the procedure linkage table. Set
1503 it up. */
1504 BFD_ASSERT (h->dynindx != -1);
1505
1506 splt = htab->root.splt;
1507 sgot = htab->root.sgotplt;
1508 srela = htab->root.srelplt;
1509 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1510
1511 /* Get the index in the procedure linkage table which
1512 corresponds to this symbol. This is the index of this symbol
1513 in all the symbols for which we are making plt entries. The
1514 first entry in the procedure linkage table is reserved. */
1515 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1516
1517 /* Get the offset into the .got table of the entry that
1518 corresponds to this function. Each .got entry is 4 bytes.
1519 The first three are reserved. */
1520 got_offset = (plt_index + 3) * 4;
1521
1522 /* Fill in the entry in the procedure linkage table. */
1523 if (! bfd_link_pic (info))
1524 {
1525 /* TODO */
1526 }
1527 else
1528 {
1529 /* TODO */
1530 }
1531
1532 /* Fill in the entry in the global offset table. */
1533 bfd_put_32 (output_bfd,
1534 (splt->output_section->vma
1535 + splt->output_offset
1536 + h->plt.offset
1537 + 12), /* same offset */
1538 sgot->contents + got_offset);
1539
1540 /* Fill in the entry in the .rela.plt section. */
1541 rela.r_offset = (sgot->output_section->vma
1542 + sgot->output_offset
1543 + got_offset);
1544 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1545 rela.r_addend = 0;
1546 loc = srela->contents;
1547 loc += plt_index * sizeof (Elf32_External_Rela);
1548 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1549
1550 if (!h->def_regular)
1551 {
1552 /* Mark the symbol as undefined, rather than as defined in
1553 the .plt section. Leave the value alone. */
1554 sym->st_shndx = SHN_UNDEF;
1555 }
1556
1557 }
1558
1559 if (h->got.offset != (bfd_vma) -1)
1560 {
1561 asection *sgot;
1562 asection *srela;
1563 Elf_Internal_Rela rela;
1564
1565 /* This symbol has an entry in the global offset table. Set it
1566 up. */
1567 sgot = htab->root.sgot;
1568 srela = htab->root.srelgot;
1569 BFD_ASSERT (sgot != NULL && srela != NULL);
1570
1571 rela.r_offset = (sgot->output_section->vma
1572 + sgot->output_offset
1573 + (h->got.offset &~ 1));
1574
1575 /* If this is a -Bsymbolic link, and the symbol is defined
1576 locally, we just want to emit a RELATIVE reloc. Likewise if
1577 the symbol was forced to be local because of a version file.
1578 The entry in the global offset table will already have been
1579 initialized in the relocate_section function. */
1580 if (bfd_link_pic (info)
1581 && (info->symbolic
1582 || h->dynindx == -1
1583 || h->forced_local)
1584 && h->def_regular)
1585 {
1586 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1587 rela.r_addend = (h->root.u.def.value
1588 + h->root.u.def.section->output_section->vma
1589 + h->root.u.def.section->output_offset);
1590 }
1591 else
1592 {
1593 BFD_ASSERT ((h->got.offset & 1) == 0);
1594 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1595 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1596 rela.r_addend = 0;
1597 }
1598
1599 loc = srela->contents;
1600 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1601 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1602 ++srela->reloc_count;
1603 }
1604
1605 if (h->needs_copy)
1606 {
1607 asection *s;
1608 Elf_Internal_Rela rela;
1609
1610 /* This symbols needs a copy reloc. Set it up. */
1611 BFD_ASSERT (h->dynindx != -1
1612 && (h->root.type == bfd_link_hash_defined
1613 || h->root.type == bfd_link_hash_defweak));
1614
1615 s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1616 BFD_ASSERT (s != NULL);
1617
1618 rela.r_offset = (h->root.u.def.value
1619 + h->root.u.def.section->output_section->vma
1620 + h->root.u.def.section->output_offset);
1621 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1622 rela.r_addend = 0;
1623 loc = s->contents;
1624 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1625 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1626 ++s->reloc_count;
1627 }
1628
1629 /* Mark some specially defined symbols as absolute. */
1630 if (h == htab->root.hdynamic || h == htab->root.hgot)
1631 sym->st_shndx = SHN_ABS;
1632
1633 return TRUE;
1634 }
1635
1636 static enum elf_reloc_type_class
1637 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1638 const asection *rel_sec ATTRIBUTE_UNUSED,
1639 const Elf_Internal_Rela *rela)
1640 {
1641 switch ((int) ELF32_R_TYPE (rela->r_info))
1642 {
1643 case R_LM32_RELATIVE: return reloc_class_relative;
1644 case R_LM32_JMP_SLOT: return reloc_class_plt;
1645 case R_LM32_COPY: return reloc_class_copy;
1646 default: return reloc_class_normal;
1647 }
1648 }
1649
1650 /* Adjust a symbol defined by a dynamic object and referenced by a
1651 regular object. The current definition is in some section of the
1652 dynamic object, but we're not including those sections. We have to
1653 change the definition to something the rest of the link can
1654 understand. */
1655
1656 static bfd_boolean
1657 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1658 struct elf_link_hash_entry *h)
1659 {
1660 struct elf_lm32_link_hash_table *htab;
1661 struct elf_lm32_link_hash_entry *eh;
1662 struct elf_lm32_dyn_relocs *p;
1663 bfd *dynobj;
1664 asection *s;
1665
1666 dynobj = elf_hash_table (info)->dynobj;
1667
1668 /* Make sure we know what is going on here. */
1669 BFD_ASSERT (dynobj != NULL
1670 && (h->needs_plt
1671 || h->u.weakdef != NULL
1672 || (h->def_dynamic
1673 && h->ref_regular
1674 && !h->def_regular)));
1675
1676 /* If this is a function, put it in the procedure linkage table. We
1677 will fill in the contents of the procedure linkage table later,
1678 when we know the address of the .got section. */
1679 if (h->type == STT_FUNC
1680 || h->needs_plt)
1681 {
1682 if (! bfd_link_pic (info)
1683 && !h->def_dynamic
1684 && !h->ref_dynamic
1685 && h->root.type != bfd_link_hash_undefweak
1686 && h->root.type != bfd_link_hash_undefined)
1687 {
1688 /* This case can occur if we saw a PLT reloc in an input
1689 file, but the symbol was never referred to by a dynamic
1690 object. In such a case, we don't actually need to build
1691 a procedure linkage table, and we can just do a PCREL
1692 reloc instead. */
1693 h->plt.offset = (bfd_vma) -1;
1694 h->needs_plt = 0;
1695 }
1696
1697 return TRUE;
1698 }
1699 else
1700 h->plt.offset = (bfd_vma) -1;
1701
1702 /* If this is a weak symbol, and there is a real definition, the
1703 processor independent code will have arranged for us to see the
1704 real definition first, and we can just use the same value. */
1705 if (h->u.weakdef != NULL)
1706 {
1707 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1708 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1709 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1710 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1711 return TRUE;
1712 }
1713
1714 /* This is a reference to a symbol defined by a dynamic object which
1715 is not a function. */
1716
1717 /* If we are creating a shared library, we must presume that the
1718 only references to the symbol are via the global offset table.
1719 For such cases we need not do anything here; the relocations will
1720 be handled correctly by relocate_section. */
1721 if (bfd_link_pic (info))
1722 return TRUE;
1723
1724 /* If there are no references to this symbol that do not use the
1725 GOT, we don't need to generate a copy reloc. */
1726 if (!h->non_got_ref)
1727 return TRUE;
1728
1729 /* If -z nocopyreloc was given, we won't generate them either. */
1730 if (info->nocopyreloc)
1731 {
1732 h->non_got_ref = 0;
1733 return TRUE;
1734 }
1735
1736 eh = (struct elf_lm32_link_hash_entry *) h;
1737 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1738 {
1739 s = p->sec->output_section;
1740 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1741 break;
1742 }
1743
1744 /* If we didn't find any dynamic relocs in sections which needs the
1745 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1746 the copy reloc. */
1747 if (p == NULL)
1748 {
1749 h->non_got_ref = 0;
1750 return TRUE;
1751 }
1752
1753 /* We must allocate the symbol in our .dynbss section, which will
1754 become part of the .bss section of the executable. There will be
1755 an entry for this symbol in the .dynsym section. The dynamic
1756 object will contain position independent code, so all references
1757 from the dynamic object to this symbol will go through the global
1758 offset table. The dynamic linker will use the .dynsym entry to
1759 determine the address it must put in the global offset table, so
1760 both the dynamic object and the regular object will refer to the
1761 same memory location for the variable. */
1762
1763 htab = lm32_elf_hash_table (info);
1764 if (htab == NULL)
1765 return FALSE;
1766
1767 s = htab->sdynbss;
1768 BFD_ASSERT (s != NULL);
1769
1770 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1771 to copy the initial value out of the dynamic object and into the
1772 runtime process image. We need to remember the offset into the
1773 .rela.bss section we are going to use. */
1774 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1775 {
1776 asection *srel;
1777
1778 srel = htab->srelbss;
1779 BFD_ASSERT (srel != NULL);
1780 srel->size += sizeof (Elf32_External_Rela);
1781 h->needs_copy = 1;
1782 }
1783
1784 return _bfd_elf_adjust_dynamic_copy (info, h, s);
1785 }
1786
1787 /* Allocate space in .plt, .got and associated reloc sections for
1788 dynamic relocs. */
1789
1790 static bfd_boolean
1791 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1792 {
1793 struct bfd_link_info *info;
1794 struct elf_lm32_link_hash_table *htab;
1795 struct elf_lm32_link_hash_entry *eh;
1796 struct elf_lm32_dyn_relocs *p;
1797
1798 if (h->root.type == bfd_link_hash_indirect)
1799 return TRUE;
1800
1801 info = (struct bfd_link_info *) inf;
1802 htab = lm32_elf_hash_table (info);
1803 if (htab == NULL)
1804 return FALSE;
1805
1806 eh = (struct elf_lm32_link_hash_entry *) h;
1807
1808 if (htab->root.dynamic_sections_created
1809 && h->plt.refcount > 0)
1810 {
1811 /* Make sure this symbol is output as a dynamic symbol.
1812 Undefined weak syms won't yet be marked as dynamic. */
1813 if (h->dynindx == -1
1814 && !h->forced_local)
1815 {
1816 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1817 return FALSE;
1818 }
1819
1820 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1821 {
1822 asection *s = htab->root.splt;
1823
1824 /* If this is the first .plt entry, make room for the special
1825 first entry. */
1826 if (s->size == 0)
1827 s->size += PLT_ENTRY_SIZE;
1828
1829 h->plt.offset = s->size;
1830
1831 /* If this symbol is not defined in a regular file, and we are
1832 not generating a shared library, then set the symbol to this
1833 location in the .plt. This is required to make function
1834 pointers compare as equal between the normal executable and
1835 the shared library. */
1836 if (! bfd_link_pic (info)
1837 && !h->def_regular)
1838 {
1839 h->root.u.def.section = s;
1840 h->root.u.def.value = h->plt.offset;
1841 }
1842
1843 /* Make room for this entry. */
1844 s->size += PLT_ENTRY_SIZE;
1845
1846 /* We also need to make an entry in the .got.plt section, which
1847 will be placed in the .got section by the linker script. */
1848 htab->root.sgotplt->size += 4;
1849
1850 /* We also need to make an entry in the .rel.plt section. */
1851 htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1852 }
1853 else
1854 {
1855 h->plt.offset = (bfd_vma) -1;
1856 h->needs_plt = 0;
1857 }
1858 }
1859 else
1860 {
1861 h->plt.offset = (bfd_vma) -1;
1862 h->needs_plt = 0;
1863 }
1864
1865 if (h->got.refcount > 0)
1866 {
1867 asection *s;
1868 bfd_boolean dyn;
1869
1870 /* Make sure this symbol is output as a dynamic symbol.
1871 Undefined weak syms won't yet be marked as dynamic. */
1872 if (h->dynindx == -1
1873 && !h->forced_local)
1874 {
1875 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1876 return FALSE;
1877 }
1878
1879 s = htab->root.sgot;
1880
1881 h->got.offset = s->size;
1882 s->size += 4;
1883 dyn = htab->root.dynamic_sections_created;
1884 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1885 htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1886 }
1887 else
1888 h->got.offset = (bfd_vma) -1;
1889
1890 if (eh->dyn_relocs == NULL)
1891 return TRUE;
1892
1893 /* In the shared -Bsymbolic case, discard space allocated for
1894 dynamic pc-relative relocs against symbols which turn out to be
1895 defined in regular objects. For the normal shared case, discard
1896 space for pc-relative relocs that have become local due to symbol
1897 visibility changes. */
1898
1899 if (bfd_link_pic (info))
1900 {
1901 if (h->def_regular
1902 && (h->forced_local
1903 || info->symbolic))
1904 {
1905 struct elf_lm32_dyn_relocs **pp;
1906
1907 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1908 {
1909 p->count -= p->pc_count;
1910 p->pc_count = 0;
1911 if (p->count == 0)
1912 *pp = p->next;
1913 else
1914 pp = &p->next;
1915 }
1916 }
1917
1918 /* Also discard relocs on undefined weak syms with non-default
1919 visibility. */
1920 if (eh->dyn_relocs != NULL
1921 && h->root.type == bfd_link_hash_undefweak)
1922 {
1923 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1924 eh->dyn_relocs = NULL;
1925
1926 /* Make sure undefined weak symbols are output as a dynamic
1927 symbol in PIEs. */
1928 else if (h->dynindx == -1
1929 && !h->forced_local)
1930 {
1931 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1932 return FALSE;
1933 }
1934 }
1935 }
1936 else
1937 {
1938 /* For the non-shared case, discard space for relocs against
1939 symbols which turn out to need copy relocs or are not
1940 dynamic. */
1941
1942 if (!h->non_got_ref
1943 && ((h->def_dynamic
1944 && !h->def_regular)
1945 || (htab->root.dynamic_sections_created
1946 && (h->root.type == bfd_link_hash_undefweak
1947 || h->root.type == bfd_link_hash_undefined))))
1948 {
1949 /* Make sure this symbol is output as a dynamic symbol.
1950 Undefined weak syms won't yet be marked as dynamic. */
1951 if (h->dynindx == -1
1952 && !h->forced_local)
1953 {
1954 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1955 return FALSE;
1956 }
1957
1958 /* If that succeeded, we know we'll be keeping all the
1959 relocs. */
1960 if (h->dynindx != -1)
1961 goto keep;
1962 }
1963
1964 eh->dyn_relocs = NULL;
1965
1966 keep: ;
1967 }
1968
1969 /* Finally, allocate space. */
1970 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1971 {
1972 asection *sreloc = elf_section_data (p->sec)->sreloc;
1973 sreloc->size += p->count * sizeof (Elf32_External_Rela);
1974 }
1975
1976 return TRUE;
1977 }
1978
1979 /* Find any dynamic relocs that apply to read-only sections. */
1980
1981 static bfd_boolean
1982 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1983 {
1984 struct elf_lm32_link_hash_entry *eh;
1985 struct elf_lm32_dyn_relocs *p;
1986
1987 eh = (struct elf_lm32_link_hash_entry *) h;
1988 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1989 {
1990 asection *s = p->sec->output_section;
1991
1992 if (s != NULL && (s->flags & SEC_READONLY) != 0)
1993 {
1994 struct bfd_link_info *info = (struct bfd_link_info *) inf;
1995
1996 info->flags |= DF_TEXTREL;
1997
1998 /* Not an error, just cut short the traversal. */
1999 return FALSE;
2000 }
2001 }
2002 return TRUE;
2003 }
2004
2005 /* Set the sizes of the dynamic sections. */
2006
2007 static bfd_boolean
2008 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2009 struct bfd_link_info *info)
2010 {
2011 struct elf_lm32_link_hash_table *htab;
2012 bfd *dynobj;
2013 asection *s;
2014 bfd_boolean relocs;
2015 bfd *ibfd;
2016
2017 htab = lm32_elf_hash_table (info);
2018 if (htab == NULL)
2019 return FALSE;
2020
2021 dynobj = htab->root.dynobj;
2022 BFD_ASSERT (dynobj != NULL);
2023
2024 if (htab->root.dynamic_sections_created)
2025 {
2026 /* Set the contents of the .interp section to the interpreter. */
2027 if (bfd_link_executable (info) && !info->nointerp)
2028 {
2029 s = bfd_get_linker_section (dynobj, ".interp");
2030 BFD_ASSERT (s != NULL);
2031 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2032 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2033 }
2034 }
2035
2036 /* Set up .got offsets for local syms, and space for local dynamic
2037 relocs. */
2038 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2039 {
2040 bfd_signed_vma *local_got;
2041 bfd_signed_vma *end_local_got;
2042 bfd_size_type locsymcount;
2043 Elf_Internal_Shdr *symtab_hdr;
2044 asection *srel;
2045
2046 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2047 continue;
2048
2049 for (s = ibfd->sections; s != NULL; s = s->next)
2050 {
2051 struct elf_lm32_dyn_relocs *p;
2052
2053 for (p = ((struct elf_lm32_dyn_relocs *)
2054 elf_section_data (s)->local_dynrel);
2055 p != NULL;
2056 p = p->next)
2057 {
2058 if (! bfd_is_abs_section (p->sec)
2059 && bfd_is_abs_section (p->sec->output_section))
2060 {
2061 /* Input section has been discarded, either because
2062 it is a copy of a linkonce section or due to
2063 linker script /DISCARD/, so we'll be discarding
2064 the relocs too. */
2065 }
2066 else if (p->count != 0)
2067 {
2068 srel = elf_section_data (p->sec)->sreloc;
2069 srel->size += p->count * sizeof (Elf32_External_Rela);
2070 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2071 info->flags |= DF_TEXTREL;
2072 }
2073 }
2074 }
2075
2076 local_got = elf_local_got_refcounts (ibfd);
2077 if (!local_got)
2078 continue;
2079
2080 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2081 locsymcount = symtab_hdr->sh_info;
2082 end_local_got = local_got + locsymcount;
2083 s = htab->root.sgot;
2084 srel = htab->root.srelgot;
2085 for (; local_got < end_local_got; ++local_got)
2086 {
2087 if (*local_got > 0)
2088 {
2089 *local_got = s->size;
2090 s->size += 4;
2091 if (bfd_link_pic (info))
2092 srel->size += sizeof (Elf32_External_Rela);
2093 }
2094 else
2095 *local_got = (bfd_vma) -1;
2096 }
2097 }
2098
2099 /* Allocate global sym .plt and .got entries, and space for global
2100 sym dynamic relocs. */
2101 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2102
2103 /* We now have determined the sizes of the various dynamic sections.
2104 Allocate memory for them. */
2105 relocs = FALSE;
2106 for (s = dynobj->sections; s != NULL; s = s->next)
2107 {
2108 if ((s->flags & SEC_LINKER_CREATED) == 0)
2109 continue;
2110
2111 if (s == htab->root.splt
2112 || s == htab->root.sgot
2113 || s == htab->root.sgotplt
2114 || s == htab->sdynbss)
2115 {
2116 /* Strip this section if we don't need it; see the
2117 comment below. */
2118 }
2119 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2120 {
2121 if (s->size != 0 && s != htab->root.srelplt)
2122 relocs = TRUE;
2123
2124 /* We use the reloc_count field as a counter if we need
2125 to copy relocs into the output file. */
2126 s->reloc_count = 0;
2127 }
2128 else
2129 /* It's not one of our sections, so don't allocate space. */
2130 continue;
2131
2132 if (s->size == 0)
2133 {
2134 /* If we don't need this section, strip it from the
2135 output file. This is mostly to handle .rela.bss and
2136 .rela.plt. We must create both sections in
2137 create_dynamic_sections, because they must be created
2138 before the linker maps input sections to output
2139 sections. The linker does that before
2140 adjust_dynamic_symbol is called, and it is that
2141 function which decides whether anything needs to go
2142 into these sections. */
2143 s->flags |= SEC_EXCLUDE;
2144 continue;
2145 }
2146
2147 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2148 continue;
2149
2150 /* Allocate memory for the section contents. We use bfd_zalloc
2151 here in case unused entries are not reclaimed before the
2152 section's contents are written out. This should not happen,
2153 but this way if it does, we get a R_LM32_NONE reloc instead
2154 of garbage. */
2155 s->contents = bfd_zalloc (dynobj, s->size);
2156 if (s->contents == NULL)
2157 return FALSE;
2158 }
2159
2160 if (htab->root.dynamic_sections_created)
2161 {
2162 /* Add some entries to the .dynamic section. We fill in the
2163 values later, in lm32_elf_finish_dynamic_sections, but we
2164 must add the entries now so that we get the correct size for
2165 the .dynamic section. The DT_DEBUG entry is filled in by the
2166 dynamic linker and used by the debugger. */
2167 #define add_dynamic_entry(TAG, VAL) \
2168 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2169
2170 if (bfd_link_executable (info))
2171 {
2172 if (! add_dynamic_entry (DT_DEBUG, 0))
2173 return FALSE;
2174 }
2175
2176 if (htab->root.splt->size != 0)
2177 {
2178 if (! add_dynamic_entry (DT_PLTGOT, 0)
2179 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2180 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2181 || ! add_dynamic_entry (DT_JMPREL, 0))
2182 return FALSE;
2183 }
2184
2185 if (relocs)
2186 {
2187 if (! add_dynamic_entry (DT_RELA, 0)
2188 || ! add_dynamic_entry (DT_RELASZ, 0)
2189 || ! add_dynamic_entry (DT_RELAENT,
2190 sizeof (Elf32_External_Rela)))
2191 return FALSE;
2192
2193 /* If any dynamic relocs apply to a read-only section,
2194 then we need a DT_TEXTREL entry. */
2195 if ((info->flags & DF_TEXTREL) == 0)
2196 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2197 info);
2198
2199 if ((info->flags & DF_TEXTREL) != 0)
2200 {
2201 if (! add_dynamic_entry (DT_TEXTREL, 0))
2202 return FALSE;
2203 }
2204 }
2205 }
2206 #undef add_dynamic_entry
2207
2208 /* Allocate .rofixup section. */
2209 if (IS_FDPIC (output_bfd))
2210 {
2211 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2212 int rgot_weak_count = 0;
2213 int r32_count = 0;
2214 int rgot_count = 0;
2215 /* Look for deleted sections. */
2216 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2217 {
2218 for (s = ibfd->sections; s != NULL; s = s->next)
2219 {
2220 if (s->reloc_count)
2221 {
2222 /* Count relocs that need .rofixup entires. */
2223 Elf_Internal_Rela *internal_relocs, *end;
2224 internal_relocs = elf_section_data (s)->relocs;
2225 if (internal_relocs == NULL)
2226 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2227 if (internal_relocs != NULL)
2228 {
2229 end = internal_relocs + s->reloc_count;
2230 while (internal_relocs < end)
2231 {
2232 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2233 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2234 unsigned long r_symndx;
2235 struct elf_link_hash_entry *h;
2236
2237 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2238 sym_hashes = elf_sym_hashes (ibfd);
2239 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2240 h = NULL;
2241 if (r_symndx < symtab_hdr->sh_info)
2242 {
2243 }
2244 else
2245 {
2246 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2247 while (h->root.type == bfd_link_hash_indirect
2248 || h->root.type == bfd_link_hash_warning)
2249 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2250 }
2251
2252 /* Don't generate entries for weak symbols. */
2253 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2254 {
2255 if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2256 {
2257 switch (ELF32_R_TYPE (internal_relocs->r_info))
2258 {
2259 case R_LM32_32:
2260 r32_count++;
2261 break;
2262 case R_LM32_16_GOT:
2263 rgot_count++;
2264 break;
2265 }
2266 }
2267 }
2268 else
2269 {
2270 struct weak_symbol_list *current, *new_entry;
2271 /* Is this symbol already in the list? */
2272 for (current = list_start; current; current = current->next)
2273 {
2274 if (!strcmp (current->name, h->root.root.string))
2275 break;
2276 }
2277 if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2278 {
2279 /* Will this have an entry in the GOT. */
2280 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2281 {
2282 /* Create a new entry. */
2283 new_entry = malloc (sizeof (struct weak_symbol_list));
2284 if (!new_entry)
2285 return FALSE;
2286 new_entry->name = h->root.root.string;
2287 new_entry->next = NULL;
2288 /* Add to list */
2289 if (list_start == NULL)
2290 {
2291 list_start = new_entry;
2292 list_end = new_entry;
2293 }
2294 else
2295 {
2296 list_end->next = new_entry;
2297 list_end = new_entry;
2298 }
2299 /* Increase count of undefined weak symbols in the got. */
2300 rgot_weak_count++;
2301 }
2302 }
2303 }
2304 internal_relocs++;
2305 }
2306 }
2307 else
2308 return FALSE;
2309 }
2310 }
2311 }
2312 /* Free list. */
2313 while (list_start)
2314 {
2315 list_end = list_start->next;
2316 free (list_start);
2317 list_start = list_end;
2318 }
2319
2320 /* Size sections. */
2321 lm32fdpic_fixup32_section (info)->size
2322 = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2323 if (lm32fdpic_fixup32_section (info)->size == 0)
2324 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2325 else
2326 {
2327 lm32fdpic_fixup32_section (info)->contents =
2328 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2329 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2330 return FALSE;
2331 }
2332 }
2333
2334 return TRUE;
2335 }
2336
2337 /* Create dynamic sections when linking against a dynamic object. */
2338
2339 static bfd_boolean
2340 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2341 {
2342 struct elf_lm32_link_hash_table *htab;
2343 flagword flags, pltflags;
2344 asection *s;
2345 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2346 int ptralign = 2; /* 32bit */
2347
2348 htab = lm32_elf_hash_table (info);
2349 if (htab == NULL)
2350 return FALSE;
2351
2352 /* Make sure we have a GOT - For the case where we have a dynamic object
2353 but none of the relocs in check_relocs */
2354 if (!_bfd_elf_create_got_section (abfd, info))
2355 return FALSE;
2356 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2357 {
2358 if (! create_rofixup_section (abfd, info))
2359 return FALSE;
2360 }
2361
2362 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2363 .rel[a].bss sections. */
2364 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2365 | SEC_LINKER_CREATED);
2366
2367 pltflags = flags;
2368 pltflags |= SEC_CODE;
2369 if (bed->plt_not_loaded)
2370 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2371 if (bed->plt_readonly)
2372 pltflags |= SEC_READONLY;
2373
2374 s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2375 htab->root.splt = s;
2376 if (s == NULL
2377 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2378 return FALSE;
2379
2380 if (bed->want_plt_sym)
2381 {
2382 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2383 .plt section. */
2384 struct bfd_link_hash_entry *bh = NULL;
2385 struct elf_link_hash_entry *h;
2386
2387 if (! (_bfd_generic_link_add_one_symbol
2388 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2389 (bfd_vma) 0, NULL, FALSE,
2390 get_elf_backend_data (abfd)->collect, &bh)))
2391 return FALSE;
2392 h = (struct elf_link_hash_entry *) bh;
2393 h->def_regular = 1;
2394 h->type = STT_OBJECT;
2395 htab->root.hplt = h;
2396
2397 if (bfd_link_pic (info)
2398 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2399 return FALSE;
2400 }
2401
2402 s = bfd_make_section_anyway_with_flags (abfd,
2403 bed->default_use_rela_p
2404 ? ".rela.plt" : ".rel.plt",
2405 flags | SEC_READONLY);
2406 htab->root.srelplt = s;
2407 if (s == NULL
2408 || ! bfd_set_section_alignment (abfd, s, ptralign))
2409 return FALSE;
2410
2411 if (htab->root.sgot == NULL
2412 && !_bfd_elf_create_got_section (abfd, info))
2413 return FALSE;
2414
2415 if (bed->want_dynbss)
2416 {
2417 /* The .dynbss section is a place to put symbols which are defined
2418 by dynamic objects, are referenced by regular objects, and are
2419 not functions. We must allocate space for them in the process
2420 image and use a R_*_COPY reloc to tell the dynamic linker to
2421 initialize them at run time. The linker script puts the .dynbss
2422 section into the .bss section of the final image. */
2423 s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2424 SEC_ALLOC | SEC_LINKER_CREATED);
2425 htab->sdynbss = s;
2426 if (s == NULL)
2427 return FALSE;
2428 /* The .rel[a].bss section holds copy relocs. This section is not
2429 normally needed. We need to create it here, though, so that the
2430 linker will map it to an output section. We can't just create it
2431 only if we need it, because we will not know whether we need it
2432 until we have seen all the input files, and the first time the
2433 main linker code calls BFD after examining all the input files
2434 (size_dynamic_sections) the input sections have already been
2435 mapped to the output sections. If the section turns out not to
2436 be needed, we can discard it later. We will never need this
2437 section when generating a shared object, since they do not use
2438 copy relocs. */
2439 if (! bfd_link_pic (info))
2440 {
2441 s = bfd_make_section_anyway_with_flags (abfd,
2442 (bed->default_use_rela_p
2443 ? ".rela.bss" : ".rel.bss"),
2444 flags | SEC_READONLY);
2445 htab->srelbss = s;
2446 if (s == NULL
2447 || ! bfd_set_section_alignment (abfd, s, ptralign))
2448 return FALSE;
2449 }
2450 }
2451
2452 return TRUE;
2453 }
2454
2455 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2456
2457 static void
2458 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2459 struct elf_link_hash_entry *dir,
2460 struct elf_link_hash_entry *ind)
2461 {
2462 struct elf_lm32_link_hash_entry * edir;
2463 struct elf_lm32_link_hash_entry * eind;
2464
2465 edir = (struct elf_lm32_link_hash_entry *) dir;
2466 eind = (struct elf_lm32_link_hash_entry *) ind;
2467
2468 if (eind->dyn_relocs != NULL)
2469 {
2470 if (edir->dyn_relocs != NULL)
2471 {
2472 struct elf_lm32_dyn_relocs **pp;
2473 struct elf_lm32_dyn_relocs *p;
2474
2475 /* Add reloc counts against the indirect sym to the direct sym
2476 list. Merge any entries against the same section. */
2477 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2478 {
2479 struct elf_lm32_dyn_relocs *q;
2480
2481 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2482 if (q->sec == p->sec)
2483 {
2484 q->pc_count += p->pc_count;
2485 q->count += p->count;
2486 *pp = p->next;
2487 break;
2488 }
2489 if (q == NULL)
2490 pp = &p->next;
2491 }
2492 *pp = edir->dyn_relocs;
2493 }
2494
2495 edir->dyn_relocs = eind->dyn_relocs;
2496 eind->dyn_relocs = NULL;
2497 }
2498
2499 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2500 }
2501
2502 static bfd_boolean
2503 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2504 {
2505 if (!bfd_link_relocatable (info))
2506 {
2507 if (!bfd_elf_stack_segment_size (output_bfd, info,
2508 "__stacksize", DEFAULT_STACK_SIZE))
2509 return FALSE;
2510
2511 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2512 if (sec)
2513 sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2514 }
2515
2516 return TRUE;
2517 }
2518
2519 static bfd_boolean
2520 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2521 {
2522 unsigned i;
2523
2524 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2525 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2526 return TRUE;
2527
2528 if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2529 return FALSE;
2530
2531 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2532 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2533 return TRUE;
2534
2535 /* Copy the stack size. */
2536 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2537 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2538 {
2539 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2540
2541 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2542 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2543 {
2544 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2545
2546 /* Rewrite the phdrs, since we're only called after they were first written. */
2547 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2548 ->s->sizeof_ehdr, SEEK_SET) != 0
2549 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2550 elf_elfheader (obfd)->e_phnum) != 0)
2551 return FALSE;
2552 break;
2553 }
2554
2555 break;
2556 }
2557
2558 return TRUE;
2559 }
2560
2561
2562 #define ELF_ARCH bfd_arch_lm32
2563 #define ELF_TARGET_ID LM32_ELF_DATA
2564 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2565 #define ELF_MAXPAGESIZE 0x1000
2566
2567 #define TARGET_BIG_SYM lm32_elf32_vec
2568 #define TARGET_BIG_NAME "elf32-lm32"
2569
2570 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2571 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2572 #define elf_info_to_howto lm32_info_to_howto_rela
2573 #define elf_info_to_howto_rel 0
2574 #define elf_backend_rela_normal 1
2575 #define elf_backend_object_p lm32_elf_object_p
2576 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2577 #define elf_backend_stack_align 8
2578 #define elf_backend_can_gc_sections 1
2579 #define elf_backend_can_refcount 1
2580 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2581 #define elf_backend_plt_readonly 1
2582 #define elf_backend_want_got_plt 1
2583 #define elf_backend_want_plt_sym 0
2584 #define elf_backend_got_header_size 12
2585 #define elf_backend_dtrel_excludes_plt 1
2586 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2587 #define elf_backend_check_relocs lm32_elf_check_relocs
2588 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2589 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2590 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2591 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2592 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2593 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2594 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2595 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2596 #define elf_backend_relocate_section lm32_elf_relocate_section
2597
2598 #include "elf32-target.h"
2599
2600 #undef ELF_MAXPAGESIZE
2601 #define ELF_MAXPAGESIZE 0x4000
2602
2603
2604 #undef TARGET_BIG_SYM
2605 #define TARGET_BIG_SYM lm32_elf32_fdpic_vec
2606 #undef TARGET_BIG_NAME
2607 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2608 #undef elf32_bed
2609 #define elf32_bed elf32_lm32fdpic_bed
2610
2611 #undef elf_backend_always_size_sections
2612 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2613 #undef bfd_elf32_bfd_copy_private_bfd_data
2614 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2615
2616 #include "elf32-target.h"
The GNU Binutils are a collection of binary tools.