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