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