?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bfd/ChangeLog
[binutils.git] / bfd / elf32-lm32.c
blob68195c3bf2d01840ecbdfc153453b7eeefdc8a8a
1 /* Lattice Mico32-specific support for 32-bit ELF
2 Copyright 2008, 2009, 2010 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 "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
46 extern const bfd_target bfd_elf32_lm32fdpic_vec;
47
48 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_lm32fdpic_vec)
49
50 static bfd_reloc_status_type lm32_elf_gprel_reloc
51 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
52
53 /* The linker needs to keep track of the number of relocs that it
54 decides to copy as dynamic relocs in check_relocs for each symbol.
55 This is so that it can later discard them if they are found to be
56 unnecessary. We store the information in a field extending the
57 regular ELF linker hash table. */
58
59 struct elf_lm32_dyn_relocs
60 {
61 struct elf_lm32_dyn_relocs *next;
62
63 /* The input section of the reloc. */
64 asection *sec;
65
66 /* Total number of relocs copied for the input section. */
67 bfd_size_type count;
68
69 /* Number of pc-relative relocs copied for the input section. */
70 bfd_size_type pc_count;
71 };
72
73 /* lm32 ELF linker hash entry. */
74
75 struct elf_lm32_link_hash_entry
76 {
77 struct elf_link_hash_entry root;
78
79 /* Track dynamic relocs copied for this symbol. */
80 struct elf_lm32_dyn_relocs *dyn_relocs;
81 };
82
83 /* lm32 ELF linker hash table. */
84
85 struct elf_lm32_link_hash_table
86 {
87 struct elf_link_hash_table root;
88
89 /* Short-cuts to get to dynamic linker sections. */
90 asection *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) \
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)
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
115 struct 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
123 static struct bfd_hash_entry *
124 lm32_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
156 static struct bfd_link_hash_table *
157 lm32_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,
168 sizeof (struct elf_lm32_link_hash_entry),
169 LM32_ELF_DATA))
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
190 static 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
213 static bfd_boolean
214 create_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
224 htab = lm32_elf_hash_table (info);
225 if (htab == NULL)
226 return FALSE;
227
228 if (! _bfd_elf_create_got_section (dynobj, info))
229 return FALSE;
230
231 htab->sgot = bfd_get_section_by_name (dynobj, ".got");
232 htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
233 htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
234 if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
235 abort ();
236
237 return TRUE;
238 }
239
240 /* Create .rofixup sections in DYNOBJ, and set up
241 shortcuts to them in our hash table. */
242
243 static bfd_boolean
244 create_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
249 if (htab == NULL)
250 return FALSE;
251
252 /* Fixup section for R_LM32_32 relocs. */
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
268 static 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
532 struct lm32_reloc_map
533 {
534 bfd_reloc_code_real_type bfd_reloc_val;
535 unsigned char elf_reloc_val;
536 };
537
538 static 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
560 static reloc_howto_type *
561 lm32_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
572 static reloc_howto_type *
573 lm32_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
591 static void
592 lm32_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
605 static bfd_boolean
606 lm32_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
613 static void
614 lm32_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
631 static bfd_boolean
632 lm32_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
683 static bfd_reloc_status_type
684 lm32_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
714 static bfd_reloc_status_type
715 lm32_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
727 static bfd_reloc_status_type
728 lm32_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
779 static 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
806 inline 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
816 static bfd_boolean
817 lm32_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;
829 struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
830 bfd *dynobj;
831 bfd_vma *local_got_offsets;
832 asection *sgot, *splt, *sreloc;
833
834 if (htab == NULL)
835 return FALSE;
836
837 dynobj = htab->root.dynobj;
838 local_got_offsets = elf_local_got_offsets (input_bfd);
839
840 sgot = htab->sgot;
841 splt = htab->splt;
842 sreloc = NULL;
843
844 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
845 sym_hashes = elf_sym_hashes (input_bfd);
846
847 rel = relocs;
848 relend = relocs + input_section->reloc_count;
849 for (; rel < relend; rel++)
850 {
851 reloc_howto_type *howto;
852 unsigned int r_type;
853 unsigned long r_symndx;
854 Elf_Internal_Sym *sym;
855 asection *sec;
856 struct elf_link_hash_entry *h;
857 bfd_vma relocation;
858 bfd_vma gp;
859 bfd_reloc_status_type r;
860 const char *name = NULL;
861 asection *osec;
862
863 r_symndx = ELF32_R_SYM (rel->r_info);
864 r_type = ELF32_R_TYPE (rel->r_info);
865
866 if (r_type == R_LM32_GNU_VTENTRY
867 || r_type == R_LM32_GNU_VTINHERIT )
868 continue;
869
870 h = NULL;
871 sym = NULL;
872 sec = NULL;
873
874 howto = lm32_elf_howto_table + r_type;
875
876 if (r_symndx < symtab_hdr->sh_info)
877 {
878 /* It's a local symbol. */
879 sym = local_syms + r_symndx;
880 osec = sec = local_sections[r_symndx];
881 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
882 name = bfd_elf_string_from_elf_section
883 (input_bfd, symtab_hdr->sh_link, sym->st_name);
884 name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
885 }
886 else
887 {
888 /* It's a global symbol. */
889 bfd_boolean unresolved_reloc;
890 bfd_boolean warned;
891
892 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
893 r_symndx, symtab_hdr, sym_hashes,
894 h, sec, relocation,
895 unresolved_reloc, warned);
896 osec = sec;
897 name = h->root.root.string;
898 }
899
900 if (sec != NULL && elf_discarded_section (sec))
901 {
902 /* For relocs against symbols from removed linkonce sections,
903 or sections discarded by a linker script, we just want the
904 section contents zeroed. Avoid any special processing. */
905 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
906 rel->r_info = 0;
907 rel->r_addend = 0;
908 continue;
909 }
910
911 if (info->relocatable)
912 {
913 /* This is a relocatable link. We don't have to change
914 anything, unless the reloc is against a section symbol,
915 in which case we have to adjust according to where the
916 section symbol winds up in the output section. */
917 if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
918 continue;
919
920 /* If partial_inplace, we need to store any additional addend
921 back in the section. */
922 if (! howto->partial_inplace)
923 continue;
924
925 /* Shouldn't reach here. */
926 abort ();
927 r = bfd_reloc_ok;
928 }
929 else
930 {
931 switch (howto->type)
932 {
933 case R_LM32_GPREL16:
934 if (!lm32_elf_assign_gp (output_bfd, &gp))
935 r = bfd_reloc_dangerous;
936 else
937 {
938 relocation = relocation + rel->r_addend - gp;
939 rel->r_addend = 0;
940 if ((signed)relocation < -32768 || (signed)relocation > 32767)
941 r = bfd_reloc_outofrange;
942 else
943 {
944 r = _bfd_final_link_relocate (howto, input_bfd,
945 input_section, contents,
946 rel->r_offset, relocation,
947 rel->r_addend);
948 }
949 }
950 break;
951 case R_LM32_16_GOT:
952 /* Relocation is to the entry for this symbol in the global
953 offset table. */
954 BFD_ASSERT (sgot != NULL);
955 if (h != NULL)
956 {
957 bfd_boolean dyn;
958 bfd_vma off;
959
960 off = h->got.offset;
961 BFD_ASSERT (off != (bfd_vma) -1);
962
963 dyn = htab->root.dynamic_sections_created;
964 if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
965 || (info->shared
966 && (info->symbolic
967 || h->dynindx == -1
968 || h->forced_local)
969 && h->def_regular))
970 {
971 /* This is actually a static link, or it is a
972 -Bsymbolic link and the symbol is defined
973 locally, or the symbol was forced to be local
974 because of a version file. We must initialize
975 this entry in the global offset table. Since the
976 offset must always be a multiple of 4, we use the
977 least significant bit to record whether we have
978 initialized it already.
979
980 When doing a dynamic link, we create a .rela.got
981 relocation entry to initialize the value. This
982 is done in the finish_dynamic_symbol routine. */
983 if ((off & 1) != 0)
984 off &= ~1;
985 else
986 {
987 /* Write entry in GOT */
988 bfd_put_32 (output_bfd, relocation,
989 sgot->contents + off);
990 /* Create entry in .rofixup pointing to GOT entry. */
991 if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
992 {
993 _lm32fdpic_add_rofixup (output_bfd,
994 lm32fdpic_fixup32_section
995 (info),
996 sgot->output_section->vma
997 + sgot->output_offset
998 + off);
999 }
1000 /* Mark GOT entry as having been written. */
1001 h->got.offset |= 1;
1002 }
1003 }
1004
1005 relocation = sgot->output_offset + off;
1006 }
1007 else
1008 {
1009 bfd_vma off;
1010 bfd_byte *loc;
1011
1012 BFD_ASSERT (local_got_offsets != NULL
1013 && local_got_offsets[r_symndx] != (bfd_vma) -1);
1014
1015 /* Get offset into GOT table. */
1016 off = local_got_offsets[r_symndx];
1017
1018 /* The offset must always be a multiple of 4. We use
1019 the least significant bit to record whether we have
1020 already processed this entry. */
1021 if ((off & 1) != 0)
1022 off &= ~1;
1023 else
1024 {
1025 /* Write entry in GOT. */
1026 bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1027 /* Create entry in .rofixup pointing to GOT entry. */
1028 if (IS_FDPIC (output_bfd))
1029 {
1030 _lm32fdpic_add_rofixup (output_bfd,
1031 lm32fdpic_fixup32_section
1032 (info),
1033 sgot->output_section->vma
1034 + sgot->output_offset
1035 + off);
1036 }
1037
1038 if (info->shared)
1039 {
1040 asection *srelgot;
1041 Elf_Internal_Rela outrel;
1042
1043 /* We need to generate a R_LM32_RELATIVE reloc
1044 for the dynamic linker. */
1045 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1046 BFD_ASSERT (srelgot != NULL);
1047
1048 outrel.r_offset = (sgot->output_section->vma
1049 + sgot->output_offset
1050 + off);
1051 outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1052 outrel.r_addend = relocation;
1053 loc = srelgot->contents;
1054 loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1055 bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1056 ++srelgot->reloc_count;
1057 }
1058
1059 local_got_offsets[r_symndx] |= 1;
1060 }
1061
1062
1063 relocation = sgot->output_offset + off;
1064 }
1065
1066 /* Addend should be zero. */
1067 if (rel->r_addend != 0)
1068 (*_bfd_error_handler) (_("internal error: addend should be zero for R_LM32_16_GOT"));
1069
1070 r = _bfd_final_link_relocate (howto,
1071 input_bfd,
1072 input_section,
1073 contents,
1074 rel->r_offset,
1075 relocation,
1076 rel->r_addend);
1077 break;
1078
1079 case R_LM32_GOTOFF_LO16:
1080 case R_LM32_GOTOFF_HI16:
1081 /* Relocation is offset from GOT. */
1082 BFD_ASSERT (sgot != NULL);
1083 relocation -= sgot->output_section->vma;
1084 /* Account for sign-extension. */
1085 if ((r_type == R_LM32_GOTOFF_HI16)
1086 && ((relocation + rel->r_addend) & 0x8000))
1087 rel->r_addend += 0x10000;
1088 r = _bfd_final_link_relocate (howto,
1089 input_bfd,
1090 input_section,
1091 contents,
1092 rel->r_offset,
1093 relocation,
1094 rel->r_addend);
1095 break;
1096
1097 case R_LM32_32:
1098 if (IS_FDPIC (output_bfd))
1099 {
1100 if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1101 {
1102 /* Only create .rofixup entries for relocs in loadable sections. */
1103 if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1104 & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1105
1106 {
1107 /* Check address to be modified is writable. */
1108 if (_lm32fdpic_osec_readonly_p (output_bfd,
1109 input_section
1110 ->output_section))
1111 {
1112 info->callbacks->warning
1113 (info,
1114 _("cannot emit dynamic relocations in read-only section"),
1115 name, input_bfd, input_section, rel->r_offset);
1116 return FALSE;
1117 }
1118 /* Create entry in .rofixup section. */
1119 _lm32fdpic_add_rofixup (output_bfd,
1120 lm32fdpic_fixup32_section (info),
1121 input_section->output_section->vma
1122 + input_section->output_offset
1123 + rel->r_offset);
1124 }
1125 }
1126 }
1127 /* Fall through. */
1128
1129 default:
1130 r = _bfd_final_link_relocate (howto,
1131 input_bfd,
1132 input_section,
1133 contents,
1134 rel->r_offset,
1135 relocation,
1136 rel->r_addend);
1137 break;
1138 }
1139 }
1140
1141 if (r != bfd_reloc_ok)
1142 {
1143 const char *msg = NULL;
1144 arelent bfd_reloc;
1145
1146 lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1147 howto = bfd_reloc.howto;
1148
1149 if (h != NULL)
1150 name = h->root.root.string;
1151 else
1152 {
1153 name = (bfd_elf_string_from_elf_section
1154 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1155 if (name == NULL || *name == '\0')
1156 name = bfd_section_name (input_bfd, sec);
1157 }
1158
1159 switch (r)
1160 {
1161 case bfd_reloc_overflow:
1162 if ((h != NULL)
1163 && (h->root.type == bfd_link_hash_undefweak))
1164 break;
1165 if (! ((*info->callbacks->reloc_overflow)
1166 (info, (h ? &h->root : NULL), name, howto->name,
1167 (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
1168 return FALSE;
1169 break;
1170
1171 case bfd_reloc_undefined:
1172 if (! ((*info->callbacks->undefined_symbol)
1173 (info, name, input_bfd, input_section,
1174 rel->r_offset, TRUE)))
1175 return FALSE;
1176 break;
1177
1178 case bfd_reloc_outofrange:
1179 msg = _("internal error: out of range error");
1180 goto common_error;
1181
1182 case bfd_reloc_notsupported:
1183 msg = _("internal error: unsupported relocation error");
1184 goto common_error;
1185
1186 case bfd_reloc_dangerous:
1187 msg = _("internal error: dangerous error");
1188 goto common_error;
1189
1190 default:
1191 msg = _("internal error: unknown error");
1192 /* fall through */
1193
1194 common_error:
1195 if (!((*info->callbacks->warning)
1196 (info, msg, name, input_bfd, input_section,
1197 rel->r_offset)))
1198 return FALSE;
1199 break;
1200 }
1201 }
1202 }
1203
1204 return TRUE;
1205 }
1206
1207 static asection *
1208 lm32_elf_gc_mark_hook (asection *sec,
1209 struct bfd_link_info *info,
1210 Elf_Internal_Rela *rel,
1211 struct elf_link_hash_entry *h,
1212 Elf_Internal_Sym *sym)
1213 {
1214 if (h != NULL)
1215 switch (ELF32_R_TYPE (rel->r_info))
1216 {
1217 case R_LM32_GNU_VTINHERIT:
1218 case R_LM32_GNU_VTENTRY:
1219 return NULL;
1220 }
1221
1222 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1223 }
1224
1225 static bfd_boolean
1226 lm32_elf_gc_sweep_hook (bfd *abfd,
1227 struct bfd_link_info *info ATTRIBUTE_UNUSED,
1228 asection *sec,
1229 const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1230 {
1231 /* Update the got entry reference counts for the section being removed. */
1232 Elf_Internal_Shdr *symtab_hdr;
1233 struct elf_link_hash_entry **sym_hashes;
1234 bfd_signed_vma *local_got_refcounts;
1235 const Elf_Internal_Rela *rel, *relend;
1236
1237 elf_section_data (sec)->local_dynrel = NULL;
1238
1239 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1240 sym_hashes = elf_sym_hashes (abfd);
1241 local_got_refcounts = elf_local_got_refcounts (abfd);
1242
1243 relend = relocs + sec->reloc_count;
1244 for (rel = relocs; rel < relend; rel++)
1245 {
1246 unsigned long r_symndx;
1247 struct elf_link_hash_entry *h = NULL;
1248
1249 r_symndx = ELF32_R_SYM (rel->r_info);
1250 if (r_symndx >= symtab_hdr->sh_info)
1251 {
1252 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1253 while (h->root.type == bfd_link_hash_indirect
1254 || h->root.type == bfd_link_hash_warning)
1255 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1256 }
1257
1258 switch (ELF32_R_TYPE (rel->r_info))
1259 {
1260 case R_LM32_16_GOT:
1261 if (h != NULL)
1262 {
1263 if (h->got.refcount > 0)
1264 h->got.refcount--;
1265 }
1266 else
1267 {
1268 if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1269 local_got_refcounts[r_symndx]--;
1270 }
1271 break;
1272
1273 default:
1274 break;
1275 }
1276 }
1277 return TRUE;
1278 }
1279
1280 /* Look through the relocs for a section during the first phase. */
1281
1282 static bfd_boolean
1283 lm32_elf_check_relocs (bfd *abfd,
1284 struct bfd_link_info *info,
1285 asection *sec,
1286 const Elf_Internal_Rela *relocs)
1287 {
1288 Elf_Internal_Shdr *symtab_hdr;
1289 struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1290 const Elf_Internal_Rela *rel;
1291 const Elf_Internal_Rela *rel_end;
1292 struct elf_lm32_link_hash_table *htab;
1293 bfd *dynobj;
1294 bfd_vma *local_got_offsets;
1295 asection *sgot, *srelgot, *sreloc;
1296
1297 if (info->relocatable)
1298 return TRUE;
1299
1300 sgot = srelgot = sreloc = NULL;
1301
1302 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1303 sym_hashes = elf_sym_hashes (abfd);
1304 sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1305 if (!elf_bad_symtab (abfd))
1306 sym_hashes_end -= symtab_hdr->sh_info;
1307
1308 htab = lm32_elf_hash_table (info);
1309 if (htab == NULL)
1310 return FALSE;
1311
1312 dynobj = htab->root.dynobj;
1313 local_got_offsets = elf_local_got_offsets (abfd);
1314
1315 rel_end = relocs + sec->reloc_count;
1316 for (rel = relocs; rel < rel_end; rel++)
1317 {
1318 int r_type;
1319 struct elf_link_hash_entry *h;
1320 unsigned long r_symndx;
1321
1322 r_symndx = ELF32_R_SYM (rel->r_info);
1323 r_type = ELF32_R_TYPE (rel->r_info);
1324 if (r_symndx < symtab_hdr->sh_info)
1325 h = NULL;
1326 else
1327 {
1328 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1329 while (h->root.type == bfd_link_hash_indirect
1330 || h->root.type == bfd_link_hash_warning)
1331 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1332 }
1333
1334 /* Some relocs require a global offset table. */
1335 if (htab->sgot == NULL)
1336 {
1337 switch (r_type)
1338 {
1339 case R_LM32_16_GOT:
1340 case R_LM32_GOTOFF_HI16:
1341 case R_LM32_GOTOFF_LO16:
1342 if (dynobj == NULL)
1343 htab->root.dynobj = dynobj = abfd;
1344 if (! create_got_section (dynobj, info))
1345 return FALSE;
1346 break;
1347 }
1348 }
1349
1350 /* Some relocs require a rofixup table. */
1351 if (IS_FDPIC (abfd))
1352 {
1353 switch (r_type)
1354 {
1355 case R_LM32_32:
1356 /* FDPIC requires a GOT if there is a .rofixup section
1357 (Normal ELF doesn't). */
1358 if (dynobj == NULL)
1359 htab->root.dynobj = dynobj = abfd;
1360 if (! create_got_section (dynobj, info))
1361 return FALSE;
1362 /* Create .rofixup section */
1363 if (htab->sfixup32 == NULL)
1364 {
1365 if (! create_rofixup_section (abfd, info))
1366 return FALSE;
1367 }
1368 break;
1369 case R_LM32_16_GOT:
1370 case R_LM32_GOTOFF_HI16:
1371 case R_LM32_GOTOFF_LO16:
1372 /* Create .rofixup section. */
1373 if (htab->sfixup32 == NULL)
1374 {
1375 if (! create_rofixup_section (abfd, info))
1376 return FALSE;
1377 }
1378 break;
1379 }
1380 }
1381
1382 switch (r_type)
1383 {
1384 case R_LM32_16_GOT:
1385 if (h != NULL)
1386 h->got.refcount += 1;
1387 else
1388 {
1389 bfd_signed_vma *local_got_refcounts;
1390
1391 /* This is a global offset table entry for a local symbol. */
1392 local_got_refcounts = elf_local_got_refcounts (abfd);
1393 if (local_got_refcounts == NULL)
1394 {
1395 bfd_size_type size;
1396
1397 size = symtab_hdr->sh_info;
1398 size *= sizeof (bfd_signed_vma);
1399 local_got_refcounts = bfd_zalloc (abfd, size);
1400 if (local_got_refcounts == NULL)
1401 return FALSE;
1402 elf_local_got_refcounts (abfd) = local_got_refcounts;
1403 }
1404 local_got_refcounts[r_symndx] += 1;
1405 }
1406 break;
1407
1408 /* This relocation describes the C++ object vtable hierarchy.
1409 Reconstruct it for later use during GC. */
1410 case R_LM32_GNU_VTINHERIT:
1411 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1412 return FALSE;
1413 break;
1414
1415 /* This relocation describes which C++ vtable entries are actually
1416 used. Record for later use during GC. */
1417 case R_LM32_GNU_VTENTRY:
1418 if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1419 return FALSE;
1420 break;
1421
1422 }
1423 }
1424
1425 return TRUE;
1426 }
1427
1428 /* Finish up the dynamic sections. */
1429
1430 static bfd_boolean
1431 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1432 struct bfd_link_info *info)
1433 {
1434 struct elf_lm32_link_hash_table *htab;
1435 bfd *dynobj;
1436 asection *sdyn;
1437 asection *sgot;
1438
1439 htab = lm32_elf_hash_table (info);
1440 if (htab == NULL)
1441 return FALSE;
1442
1443 dynobj = htab->root.dynobj;
1444
1445 sgot = htab->sgotplt;
1446 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
1447
1448 if (htab->root.dynamic_sections_created)
1449 {
1450 asection *splt;
1451 Elf32_External_Dyn *dyncon, *dynconend;
1452
1453 BFD_ASSERT (sgot != NULL && sdyn != NULL);
1454
1455 dyncon = (Elf32_External_Dyn *) sdyn->contents;
1456 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1457
1458 for (; dyncon < dynconend; dyncon++)
1459 {
1460 Elf_Internal_Dyn dyn;
1461 const char *name;
1462 asection *s;
1463
1464 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1465
1466 switch (dyn.d_tag)
1467 {
1468 default:
1469 break;
1470
1471 case DT_PLTGOT:
1472 name = ".got";
1473 s = htab->sgot->output_section;
1474 goto get_vma;
1475 case DT_JMPREL:
1476 name = ".rela.plt";
1477 s = htab->srelplt->output_section;
1478 get_vma:
1479 BFD_ASSERT (s != NULL);
1480 dyn.d_un.d_ptr = s->vma;
1481 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1482 break;
1483
1484 case DT_PLTRELSZ:
1485 s = htab->srelplt->output_section;
1486 BFD_ASSERT (s != NULL);
1487 dyn.d_un.d_val = s->size;
1488 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1489 break;
1490
1491 case DT_RELASZ:
1492 /* My reading of the SVR4 ABI indicates that the
1493 procedure linkage table relocs (DT_JMPREL) should be
1494 included in the overall relocs (DT_RELA). This is
1495 what Solaris does. However, UnixWare can not handle
1496 that case. Therefore, we override the DT_RELASZ entry
1497 here to make it not include the JMPREL relocs. Since
1498 the linker script arranges for .rela.plt to follow all
1499 other relocation sections, we don't have to worry
1500 about changing the DT_RELA entry. */
1501 if (htab->srelplt != NULL)
1502 {
1503 s = htab->srelplt->output_section;
1504 dyn.d_un.d_val -= s->size;
1505 }
1506 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1507 break;
1508 }
1509 }
1510
1511 /* Fill in the first entry in the procedure linkage table. */
1512 splt = htab->splt;
1513 if (splt && splt->size > 0)
1514 {
1515 if (info->shared)
1516 {
1517 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1518 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1519 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1520 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1521 bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1522 }
1523 else
1524 {
1525 unsigned long addr;
1526 /* addr = .got + 4 */
1527 addr = sgot->output_section->vma + sgot->output_offset + 4;
1528 bfd_put_32 (output_bfd,
1529 PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1530 splt->contents);
1531 bfd_put_32 (output_bfd,
1532 PLT0_ENTRY_WORD1 | (addr & 0xffff),
1533 splt->contents + 4);
1534 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1535 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1536 bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1537 }
1538
1539 elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1540 PLT_ENTRY_SIZE;
1541 }
1542 }
1543
1544 /* Fill in the first three entries in the global offset table. */
1545 if (sgot && sgot->size > 0)
1546 {
1547 if (sdyn == NULL)
1548 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1549 else
1550 bfd_put_32 (output_bfd,
1551 sdyn->output_section->vma + sdyn->output_offset,
1552 sgot->contents);
1553 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1554 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1555
1556 /* FIXME: This can be null if create_dynamic_sections wasn't called. */
1557 if (elf_section_data (sgot->output_section) != NULL)
1558 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1559 }
1560
1561 if (lm32fdpic_fixup32_section (info))
1562 {
1563 struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1564 bfd_vma got_value = hgot->root.u.def.value
1565 + hgot->root.u.def.section->output_section->vma
1566 + hgot->root.u.def.section->output_offset;
1567 struct bfd_link_hash_entry *hend;
1568
1569 /* Last entry is pointer to GOT. */
1570 _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1571
1572 /* Check we wrote enough entries. */
1573 if (lm32fdpic_fixup32_section (info)->size
1574 != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1575 {
1576 (*_bfd_error_handler)
1577 ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1578 lm32fdpic_fixup32_section (info)->size/4,
1579 lm32fdpic_fixup32_section (info)->reloc_count);
1580 return FALSE;
1581 }
1582
1583 hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1584 FALSE, FALSE, TRUE);
1585 if (hend
1586 && (hend->type == bfd_link_hash_defined
1587 || hend->type == bfd_link_hash_defweak))
1588 {
1589 bfd_vma value =
1590 lm32fdpic_fixup32_section (info)->output_section->vma
1591 + lm32fdpic_fixup32_section (info)->output_offset
1592 + lm32fdpic_fixup32_section (info)->size
1593 - hend->u.def.section->output_section->vma
1594 - hend->u.def.section->output_offset;
1595 BFD_ASSERT (hend->u.def.value == value);
1596 if (hend->u.def.value != value)
1597 {
1598 (*_bfd_error_handler)
1599 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1600 return FALSE;
1601 }
1602 }
1603 }
1604
1605 return TRUE;
1606 }
1607
1608 /* Finish up dynamic symbol handling. We set the contents of various
1609 dynamic sections here. */
1610
1611 static bfd_boolean
1612 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1613 struct bfd_link_info *info,
1614 struct elf_link_hash_entry *h,
1615 Elf_Internal_Sym *sym)
1616 {
1617 struct elf_lm32_link_hash_table *htab;
1618 bfd *dynobj;
1619 bfd_byte *loc;
1620
1621 htab = lm32_elf_hash_table (info);
1622 if (htab == NULL)
1623 return FALSE;
1624
1625 dynobj = htab->root.dynobj;
1626
1627 if (h->plt.offset != (bfd_vma) -1)
1628 {
1629 asection *splt;
1630 asection *sgot;
1631 asection *srela;
1632
1633 bfd_vma plt_index;
1634 bfd_vma got_offset;
1635 Elf_Internal_Rela rela;
1636
1637 /* This symbol has an entry in the procedure linkage table. Set
1638 it up. */
1639 BFD_ASSERT (h->dynindx != -1);
1640
1641 splt = htab->splt;
1642 sgot = htab->sgotplt;
1643 srela = htab->srelplt;
1644 BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1645
1646 /* Get the index in the procedure linkage table which
1647 corresponds to this symbol. This is the index of this symbol
1648 in all the symbols for which we are making plt entries. The
1649 first entry in the procedure linkage table is reserved. */
1650 plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1651
1652 /* Get the offset into the .got table of the entry that
1653 corresponds to this function. Each .got entry is 4 bytes.
1654 The first three are reserved. */
1655 got_offset = (plt_index + 3) * 4;
1656
1657 /* Fill in the entry in the procedure linkage table. */
1658 if (! info->shared)
1659 {
1660 /* TODO */
1661 }
1662 else
1663 {
1664 /* TODO */
1665 }
1666
1667 /* Fill in the entry in the global offset table. */
1668 bfd_put_32 (output_bfd,
1669 (splt->output_section->vma
1670 + splt->output_offset
1671 + h->plt.offset
1672 + 12), /* same offset */
1673 sgot->contents + got_offset);
1674
1675 /* Fill in the entry in the .rela.plt section. */
1676 rela.r_offset = (sgot->output_section->vma
1677 + sgot->output_offset
1678 + got_offset);
1679 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1680 rela.r_addend = 0;
1681 loc = srela->contents;
1682 loc += plt_index * sizeof (Elf32_External_Rela);
1683 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1684
1685 if (!h->def_regular)
1686 {
1687 /* Mark the symbol as undefined, rather than as defined in
1688 the .plt section. Leave the value alone. */
1689 sym->st_shndx = SHN_UNDEF;
1690 }
1691
1692 }
1693
1694 if (h->got.offset != (bfd_vma) -1)
1695 {
1696 asection *sgot;
1697 asection *srela;
1698 Elf_Internal_Rela rela;
1699
1700 /* This symbol has an entry in the global offset table. Set it
1701 up. */
1702 sgot = htab->sgot;
1703 srela = htab->srelgot;
1704 BFD_ASSERT (sgot != NULL && srela != NULL);
1705
1706 rela.r_offset = (sgot->output_section->vma
1707 + sgot->output_offset
1708 + (h->got.offset &~ 1));
1709
1710 /* If this is a -Bsymbolic link, and the symbol is defined
1711 locally, we just want to emit a RELATIVE reloc. Likewise if
1712 the symbol was forced to be local because of a version file.
1713 The entry in the global offset table will already have been
1714 initialized in the relocate_section function. */
1715 if (info->shared
1716 && (info->symbolic
1717 || h->dynindx == -1
1718 || h->forced_local)
1719 && h->def_regular)
1720 {
1721 rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1722 rela.r_addend = (h->root.u.def.value
1723 + h->root.u.def.section->output_section->vma
1724 + h->root.u.def.section->output_offset);
1725 }
1726 else
1727 {
1728 BFD_ASSERT ((h->got.offset & 1) == 0);
1729 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1730 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1731 rela.r_addend = 0;
1732 }
1733
1734 loc = srela->contents;
1735 loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1736 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1737 ++srela->reloc_count;
1738 }
1739
1740 if (h->needs_copy)
1741 {
1742 asection *s;
1743 Elf_Internal_Rela rela;
1744
1745 /* This symbols needs a copy reloc. Set it up. */
1746 BFD_ASSERT (h->dynindx != -1
1747 && (h->root.type == bfd_link_hash_defined
1748 || h->root.type == bfd_link_hash_defweak));
1749
1750 s = bfd_get_section_by_name (h->root.u.def.section->owner,
1751 ".rela.bss");
1752 BFD_ASSERT (s != NULL);
1753
1754 rela.r_offset = (h->root.u.def.value
1755 + h->root.u.def.section->output_section->vma
1756 + h->root.u.def.section->output_offset);
1757 rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1758 rela.r_addend = 0;
1759 loc = s->contents;
1760 loc += s->reloc_count * sizeof (Elf32_External_Rela);
1761 bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1762 ++s->reloc_count;
1763 }
1764
1765 /* Mark some specially defined symbols as absolute. */
1766 if (strcmp (h->root.root.string, "_DYNAMIC") == 0
1767 || h == htab->root.hgot)
1768 sym->st_shndx = SHN_ABS;
1769
1770 return TRUE;
1771 }
1772
1773 static enum elf_reloc_type_class
1774 lm32_elf_reloc_type_class (const Elf_Internal_Rela *rela)
1775 {
1776 switch ((int) ELF32_R_TYPE (rela->r_info))
1777 {
1778 case R_LM32_RELATIVE: return reloc_class_relative;
1779 case R_LM32_JMP_SLOT: return reloc_class_plt;
1780 case R_LM32_COPY: return reloc_class_copy;
1781 default: return reloc_class_normal;
1782 }
1783 }
1784
1785 /* Adjust a symbol defined by a dynamic object and referenced by a
1786 regular object. The current definition is in some section of the
1787 dynamic object, but we're not including those sections. We have to
1788 change the definition to something the rest of the link can
1789 understand. */
1790
1791 static bfd_boolean
1792 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1793 struct elf_link_hash_entry *h)
1794 {
1795 struct elf_lm32_link_hash_table *htab;
1796 struct elf_lm32_link_hash_entry *eh;
1797 struct elf_lm32_dyn_relocs *p;
1798 bfd *dynobj;
1799 asection *s;
1800
1801 dynobj = elf_hash_table (info)->dynobj;
1802
1803 /* Make sure we know what is going on here. */
1804 BFD_ASSERT (dynobj != NULL
1805 && (h->needs_plt
1806 || h->u.weakdef != NULL
1807 || (h->def_dynamic
1808 && h->ref_regular
1809 && !h->def_regular)));
1810
1811 /* If this is a function, put it in the procedure linkage table. We
1812 will fill in the contents of the procedure linkage table later,
1813 when we know the address of the .got section. */
1814 if (h->type == STT_FUNC
1815 || h->needs_plt)
1816 {
1817 if (! info->shared
1818 && !h->def_dynamic
1819 && !h->ref_dynamic
1820 && h->root.type != bfd_link_hash_undefweak
1821 && h->root.type != bfd_link_hash_undefined)
1822 {
1823 /* This case can occur if we saw a PLT reloc in an input
1824 file, but the symbol was never referred to by a dynamic
1825 object. In such a case, we don't actually need to build
1826 a procedure linkage table, and we can just do a PCREL
1827 reloc instead. */
1828 h->plt.offset = (bfd_vma) -1;
1829 h->needs_plt = 0;
1830 }
1831
1832 return TRUE;
1833 }
1834 else
1835 h->plt.offset = (bfd_vma) -1;
1836
1837 /* If this is a weak symbol, and there is a real definition, the
1838 processor independent code will have arranged for us to see the
1839 real definition first, and we can just use the same value. */
1840 if (h->u.weakdef != NULL)
1841 {
1842 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1843 || h->u.weakdef->root.type == bfd_link_hash_defweak);
1844 h->root.u.def.section = h->u.weakdef->root.u.def.section;
1845 h->root.u.def.value = h->u.weakdef->root.u.def.value;
1846 return TRUE;
1847 }
1848
1849 /* This is a reference to a symbol defined by a dynamic object which
1850 is not a function. */
1851
1852 /* If we are creating a shared library, we must presume that the
1853 only references to the symbol are via the global offset table.
1854 For such cases we need not do anything here; the relocations will
1855 be handled correctly by relocate_section. */
1856 if (info->shared)
1857 return TRUE;
1858
1859 /* If there are no references to this symbol that do not use the
1860 GOT, we don't need to generate a copy reloc. */
1861 if (!h->non_got_ref)
1862 return TRUE;
1863
1864 /* If -z nocopyreloc was given, we won't generate them either. */
1865 if (info->nocopyreloc)
1866 {
1867 h->non_got_ref = 0;
1868 return TRUE;
1869 }
1870
1871 eh = (struct elf_lm32_link_hash_entry *) h;
1872 for (p = eh->dyn_relocs; p != NULL; p = p->next)
1873 {
1874 s = p->sec->output_section;
1875 if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1876 break;
1877 }
1878
1879 /* If we didn't find any dynamic relocs in sections which needs the
1880 copy reloc, then we'll be keeping the dynamic relocs and avoiding
1881 the copy reloc. */
1882 if (p == NULL)
1883 {
1884 h->non_got_ref = 0;
1885 return TRUE;
1886 }
1887
1888 if (h->size == 0)
1889 {
1890 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
1891 h->root.root.string);
1892 return TRUE;
1893 }
1894
1895 /* We must allocate the symbol in our .dynbss section, which will
1896 become part of the .bss section of the executable. There will be
1897 an entry for this symbol in the .dynsym section. The dynamic
1898 object will contain position independent code, so all references
1899 from the dynamic object to this symbol will go through the global
1900 offset table. The dynamic linker will use the .dynsym entry to
1901 determine the address it must put in the global offset table, so
1902 both the dynamic object and the regular object will refer to the
1903 same memory location for the variable. */
1904
1905 htab = lm32_elf_hash_table (info);
1906 if (htab == NULL)
1907 return FALSE;
1908
1909 s = htab->sdynbss;
1910 BFD_ASSERT (s != NULL);
1911
1912 /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1913 to copy the initial value out of the dynamic object and into the
1914 runtime process image. We need to remember the offset into the
1915 .rela.bss section we are going to use. */
1916 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
1917 {
1918 asection *srel;
1919
1920 srel = htab->srelbss;
1921 BFD_ASSERT (srel != NULL);
1922 srel->size += sizeof (Elf32_External_Rela);
1923 h->needs_copy = 1;
1924 }
1925
1926 return _bfd_elf_adjust_dynamic_copy (h, s);
1927 }
1928
1929 /* Allocate space in .plt, .got and associated reloc sections for
1930 dynamic relocs. */
1931
1932 static bfd_boolean
1933 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1934 {
1935 struct bfd_link_info *info;
1936 struct elf_lm32_link_hash_table *htab;
1937 struct elf_lm32_link_hash_entry *eh;
1938 struct elf_lm32_dyn_relocs *p;
1939
1940 if (h->root.type == bfd_link_hash_indirect)
1941 return TRUE;
1942
1943 if (h->root.type == bfd_link_hash_warning)
1944 /* When warning symbols are created, they **replace** the "real"
1945 entry in the hash table, thus we never get to see the real
1946 symbol in a hash traversal. So look at it now. */
1947 h = (struct elf_link_hash_entry *) h->root.u.i.link;
1948
1949 info = (struct bfd_link_info *) inf;
1950 htab = lm32_elf_hash_table (info);
1951 if (htab == NULL)
1952 return FALSE;
1953
1954 eh = (struct elf_lm32_link_hash_entry *) h;
1955
1956 if (htab->root.dynamic_sections_created
1957 && h->plt.refcount > 0)
1958 {
1959 /* Make sure this symbol is output as a dynamic symbol.
1960 Undefined weak syms won't yet be marked as dynamic. */
1961 if (h->dynindx == -1
1962 && !h->forced_local)
1963 {
1964 if (! bfd_elf_link_record_dynamic_symbol (info, h))
1965 return FALSE;
1966 }
1967
1968 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1969 {
1970 asection *s = htab->splt;
1971
1972 /* If this is the first .plt entry, make room for the special
1973 first entry. */
1974 if (s->size == 0)
1975 s->size += PLT_ENTRY_SIZE;
1976
1977 h->plt.offset = s->size;
1978
1979 /* If this symbol is not defined in a regular file, and we are
1980 not generating a shared library, then set the symbol to this
1981 location in the .plt. This is required to make function
1982 pointers compare as equal between the normal executable and
1983 the shared library. */
1984 if (! info->shared
1985 && !h->def_regular)
1986 {
1987 h->root.u.def.section = s;
1988 h->root.u.def.value = h->plt.offset;
1989 }
1990
1991 /* Make room for this entry. */
1992 s->size += PLT_ENTRY_SIZE;
1993
1994 /* We also need to make an entry in the .got.plt section, which
1995 will be placed in the .got section by the linker script. */
1996 htab->sgotplt->size += 4;
1997
1998 /* We also need to make an entry in the .rel.plt section. */
1999 htab->srelplt->size += sizeof (Elf32_External_Rela);
2000 }
2001 else
2002 {
2003 h->plt.offset = (bfd_vma) -1;
2004 h->needs_plt = 0;
2005 }
2006 }
2007 else
2008 {
2009 h->plt.offset = (bfd_vma) -1;
2010 h->needs_plt = 0;
2011 }
2012
2013 if (h->got.refcount > 0)
2014 {
2015 asection *s;
2016 bfd_boolean dyn;
2017
2018 /* Make sure this symbol is output as a dynamic symbol.
2019 Undefined weak syms won't yet be marked as dynamic. */
2020 if (h->dynindx == -1
2021 && !h->forced_local)
2022 {
2023 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2024 return FALSE;
2025 }
2026
2027 s = htab->sgot;
2028
2029 h->got.offset = s->size;
2030 s->size += 4;
2031 dyn = htab->root.dynamic_sections_created;
2032 if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2033 htab->srelgot->size += sizeof (Elf32_External_Rela);
2034 }
2035 else
2036 h->got.offset = (bfd_vma) -1;
2037
2038 if (eh->dyn_relocs == NULL)
2039 return TRUE;
2040
2041 /* In the shared -Bsymbolic case, discard space allocated for
2042 dynamic pc-relative relocs against symbols which turn out to be
2043 defined in regular objects. For the normal shared case, discard
2044 space for pc-relative relocs that have become local due to symbol
2045 visibility changes. */
2046
2047 if (info->shared)
2048 {
2049 if (h->def_regular
2050 && (h->forced_local
2051 || info->symbolic))
2052 {
2053 struct elf_lm32_dyn_relocs **pp;
2054
2055 for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2056 {
2057 p->count -= p->pc_count;
2058 p->pc_count = 0;
2059 if (p->count == 0)
2060 *pp = p->next;
2061 else
2062 pp = &p->next;
2063 }
2064 }
2065
2066 /* Also discard relocs on undefined weak syms with non-default
2067 visibility. */
2068 if (eh->dyn_relocs != NULL
2069 && h->root.type == bfd_link_hash_undefweak)
2070 {
2071 if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2072 eh->dyn_relocs = NULL;
2073
2074 /* Make sure undefined weak symbols are output as a dynamic
2075 symbol in PIEs. */
2076 else if (h->dynindx == -1
2077 && !h->forced_local)
2078 {
2079 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2080 return FALSE;
2081 }
2082 }
2083 }
2084 else
2085 {
2086 /* For the non-shared case, discard space for relocs against
2087 symbols which turn out to need copy relocs or are not
2088 dynamic. */
2089
2090 if (!h->non_got_ref
2091 && ((h->def_dynamic
2092 && !h->def_regular)
2093 || (htab->root.dynamic_sections_created
2094 && (h->root.type == bfd_link_hash_undefweak
2095 || h->root.type == bfd_link_hash_undefined))))
2096 {
2097 /* Make sure this symbol is output as a dynamic symbol.
2098 Undefined weak syms won't yet be marked as dynamic. */
2099 if (h->dynindx == -1
2100 && !h->forced_local)
2101 {
2102 if (! bfd_elf_link_record_dynamic_symbol (info, h))
2103 return FALSE;
2104 }
2105
2106 /* If that succeeded, we know we'll be keeping all the
2107 relocs. */
2108 if (h->dynindx != -1)
2109 goto keep;
2110 }
2111
2112 eh->dyn_relocs = NULL;
2113
2114 keep: ;
2115 }
2116
2117 /* Finally, allocate space. */
2118 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2119 {
2120 asection *sreloc = elf_section_data (p->sec)->sreloc;
2121 sreloc->size += p->count * sizeof (Elf32_External_Rela);
2122 }
2123
2124 return TRUE;
2125 }
2126
2127 /* Find any dynamic relocs that apply to read-only sections. */
2128
2129 static bfd_boolean
2130 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2131 {
2132 struct elf_lm32_link_hash_entry *eh;
2133 struct elf_lm32_dyn_relocs *p;
2134
2135 if (h->root.type == bfd_link_hash_warning)
2136 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2137
2138 eh = (struct elf_lm32_link_hash_entry *) h;
2139 for (p = eh->dyn_relocs; p != NULL; p = p->next)
2140 {
2141 asection *s = p->sec->output_section;
2142
2143 if (s != NULL && (s->flags & SEC_READONLY) != 0)
2144 {
2145 struct bfd_link_info *info = (struct bfd_link_info *) inf;
2146
2147 info->flags |= DF_TEXTREL;
2148
2149 /* Not an error, just cut short the traversal. */
2150 return FALSE;
2151 }
2152 }
2153 return TRUE;
2154 }
2155
2156 /* Set the sizes of the dynamic sections. */
2157
2158 static bfd_boolean
2159 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2160 struct bfd_link_info *info)
2161 {
2162 struct elf_lm32_link_hash_table *htab;
2163 bfd *dynobj;
2164 asection *s;
2165 bfd_boolean relocs;
2166 bfd *ibfd;
2167
2168 htab = lm32_elf_hash_table (info);
2169 if (htab == NULL)
2170 return FALSE;
2171
2172 dynobj = htab->root.dynobj;
2173 BFD_ASSERT (dynobj != NULL);
2174
2175 if (htab->root.dynamic_sections_created)
2176 {
2177 /* Set the contents of the .interp section to the interpreter. */
2178 if (info->executable)
2179 {
2180 s = bfd_get_section_by_name (dynobj, ".interp");
2181 BFD_ASSERT (s != NULL);
2182 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2183 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2184 }
2185 }
2186
2187 /* Set up .got offsets for local syms, and space for local dynamic
2188 relocs. */
2189 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2190 {
2191 bfd_signed_vma *local_got;
2192 bfd_signed_vma *end_local_got;
2193 bfd_size_type locsymcount;
2194 Elf_Internal_Shdr *symtab_hdr;
2195 asection *srel;
2196
2197 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2198 continue;
2199
2200 for (s = ibfd->sections; s != NULL; s = s->next)
2201 {
2202 struct elf_lm32_dyn_relocs *p;
2203
2204 for (p = ((struct elf_lm32_dyn_relocs *)
2205 elf_section_data (s)->local_dynrel);
2206 p != NULL;
2207 p = p->next)
2208 {
2209 if (! bfd_is_abs_section (p->sec)
2210 && bfd_is_abs_section (p->sec->output_section))
2211 {
2212 /* Input section has been discarded, either because
2213 it is a copy of a linkonce section or due to
2214 linker script /DISCARD/, so we'll be discarding
2215 the relocs too. */
2216 }
2217 else if (p->count != 0)
2218 {
2219 srel = elf_section_data (p->sec)->sreloc;
2220 srel->size += p->count * sizeof (Elf32_External_Rela);
2221 if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2222 info->flags |= DF_TEXTREL;
2223 }
2224 }
2225 }
2226
2227 local_got = elf_local_got_refcounts (ibfd);
2228 if (!local_got)
2229 continue;
2230
2231 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2232 locsymcount = symtab_hdr->sh_info;
2233 end_local_got = local_got + locsymcount;
2234 s = htab->sgot;
2235 srel = htab->srelgot;
2236 for (; local_got < end_local_got; ++local_got)
2237 {
2238 if (*local_got > 0)
2239 {
2240 *local_got = s->size;
2241 s->size += 4;
2242 if (info->shared)
2243 srel->size += sizeof (Elf32_External_Rela);
2244 }
2245 else
2246 *local_got = (bfd_vma) -1;
2247 }
2248 }
2249
2250 /* Allocate global sym .plt and .got entries, and space for global
2251 sym dynamic relocs. */
2252 elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2253
2254 /* We now have determined the sizes of the various dynamic sections.
2255 Allocate memory for them. */
2256 relocs = FALSE;
2257 for (s = dynobj->sections; s != NULL; s = s->next)
2258 {
2259 if ((s->flags & SEC_LINKER_CREATED) == 0)
2260 continue;
2261
2262 if (s == htab->splt
2263 || s == htab->sgot
2264 || s == htab->sgotplt
2265 || s == htab->sdynbss)
2266 {
2267 /* Strip this section if we don't need it; see the
2268 comment below. */
2269 }
2270 else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2271 {
2272 if (s->size != 0 && s != htab->srelplt)
2273 relocs = TRUE;
2274
2275 /* We use the reloc_count field as a counter if we need
2276 to copy relocs into the output file. */
2277 s->reloc_count = 0;
2278 }
2279 else
2280 /* It's not one of our sections, so don't allocate space. */
2281 continue;
2282
2283 if (s->size == 0)
2284 {
2285 /* If we don't need this section, strip it from the
2286 output file. This is mostly to handle .rela.bss and
2287 .rela.plt. We must create both sections in
2288 create_dynamic_sections, because they must be created
2289 before the linker maps input sections to output
2290 sections. The linker does that before
2291 adjust_dynamic_symbol is called, and it is that
2292 function which decides whether anything needs to go
2293 into these sections. */
2294 s->flags |= SEC_EXCLUDE;
2295 continue;
2296 }
2297
2298 if ((s->flags & SEC_HAS_CONTENTS) == 0)
2299 continue;
2300
2301 /* Allocate memory for the section contents. We use bfd_zalloc
2302 here in case unused entries are not reclaimed before the
2303 section's contents are written out. This should not happen,
2304 but this way if it does, we get a R_LM32_NONE reloc instead
2305 of garbage. */
2306 s->contents = bfd_zalloc (dynobj, s->size);
2307 if (s->contents == NULL)
2308 return FALSE;
2309 }
2310
2311 if (htab->root.dynamic_sections_created)
2312 {
2313 /* Add some entries to the .dynamic section. We fill in the
2314 values later, in lm32_elf_finish_dynamic_sections, but we
2315 must add the entries now so that we get the correct size for
2316 the .dynamic section. The DT_DEBUG entry is filled in by the
2317 dynamic linker and used by the debugger. */
2318 #define add_dynamic_entry(TAG, VAL) \
2319 _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2320
2321 if (info->executable)
2322 {
2323 if (! add_dynamic_entry (DT_DEBUG, 0))
2324 return FALSE;
2325 }
2326
2327 if (htab->splt->size != 0)
2328 {
2329 if (! add_dynamic_entry (DT_PLTGOT, 0)
2330 || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2331 || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2332 || ! add_dynamic_entry (DT_JMPREL, 0))
2333 return FALSE;
2334 }
2335
2336 if (relocs)
2337 {
2338 if (! add_dynamic_entry (DT_RELA, 0)
2339 || ! add_dynamic_entry (DT_RELASZ, 0)
2340 || ! add_dynamic_entry (DT_RELAENT,
2341 sizeof (Elf32_External_Rela)))
2342 return FALSE;
2343
2344 /* If any dynamic relocs apply to a read-only section,
2345 then we need a DT_TEXTREL entry. */
2346 if ((info->flags & DF_TEXTREL) == 0)
2347 elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2348 info);
2349
2350 if ((info->flags & DF_TEXTREL) != 0)
2351 {
2352 if (! add_dynamic_entry (DT_TEXTREL, 0))
2353 return FALSE;
2354 }
2355 }
2356 }
2357 #undef add_dynamic_entry
2358
2359 /* Allocate .rofixup section. */
2360 if (IS_FDPIC (output_bfd))
2361 {
2362 struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2363 int rgot_weak_count = 0;
2364 int r32_count = 0;
2365 int rgot_count = 0;
2366 /* Look for deleted sections. */
2367 for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2368 {
2369 for (s = ibfd->sections; s != NULL; s = s->next)
2370 {
2371 if (s->reloc_count)
2372 {
2373 /* Count relocs that need .rofixup entires. */
2374 Elf_Internal_Rela *internal_relocs, *end;
2375 internal_relocs = elf_section_data (s)->relocs;
2376 if (internal_relocs == NULL)
2377 internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2378 if (internal_relocs != NULL)
2379 {
2380 end = internal_relocs + s->reloc_count;
2381 while (internal_relocs < end)
2382 {
2383 Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2384 struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2385 unsigned long r_symndx;
2386 struct elf_link_hash_entry *h;
2387
2388 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2389 sym_hashes = elf_sym_hashes (ibfd);
2390 r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2391 h = NULL;
2392 if (r_symndx < symtab_hdr->sh_info)
2393 {
2394 }
2395 else
2396 {
2397 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2398 while (h->root.type == bfd_link_hash_indirect
2399 || h->root.type == bfd_link_hash_warning)
2400 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2401 }
2402
2403 /* Don't generate entries for weak symbols. */
2404 if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2405 {
2406 if (!elf_discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2407 {
2408 switch (ELF32_R_TYPE (internal_relocs->r_info))
2409 {
2410 case R_LM32_32:
2411 r32_count++;
2412 break;
2413 case R_LM32_16_GOT:
2414 rgot_count++;
2415 break;
2416 }
2417 }
2418 }
2419 else
2420 {
2421 struct weak_symbol_list *current, *new_entry;
2422 /* Is this symbol already in the list? */
2423 for (current = list_start; current; current = current->next)
2424 {
2425 if (!strcmp (current->name, h->root.root.string))
2426 break;
2427 }
2428 if (!current && !elf_discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2429 {
2430 /* Will this have an entry in the GOT. */
2431 if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2432 {
2433 /* Create a new entry. */
2434 new_entry = malloc (sizeof (struct weak_symbol_list));
2435 if (!new_entry)
2436 return FALSE;
2437 new_entry->name = h->root.root.string;
2438 new_entry->next = NULL;
2439 /* Add to list */
2440 if (list_start == NULL)
2441 {
2442 list_start = new_entry;
2443 list_end = new_entry;
2444 }
2445 else
2446 {
2447 list_end->next = new_entry;
2448 list_end = new_entry;
2449 }
2450 /* Increase count of undefined weak symbols in the got. */
2451 rgot_weak_count++;
2452 }
2453 }
2454 }
2455 internal_relocs++;
2456 }
2457 }
2458 else
2459 return FALSE;
2460 }
2461 }
2462 }
2463 /* Free list. */
2464 while (list_start)
2465 {
2466 list_end = list_start->next;
2467 free (list_start);
2468 list_start = list_end;
2469 }
2470
2471 /* Size sections. */
2472 lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2473 if (lm32fdpic_fixup32_section (info)->size == 0)
2474 lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2475 else
2476 {
2477 lm32fdpic_fixup32_section (info)->contents =
2478 bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2479 if (lm32fdpic_fixup32_section (info)->contents == NULL)
2480 return FALSE;
2481 }
2482 }
2483
2484 return TRUE;
2485 }
2486
2487 /* Create dynamic sections when linking against a dynamic object. */
2488
2489 static bfd_boolean
2490 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2491 {
2492 struct elf_lm32_link_hash_table *htab;
2493 flagword flags, pltflags;
2494 asection *s;
2495 const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2496 int ptralign = 2; /* 32bit */
2497
2498 htab = lm32_elf_hash_table (info);
2499 if (htab == NULL)
2500 return FALSE;
2501
2502 /* Make sure we have a GOT - For the case where we have a dynamic object
2503 but none of the relocs in check_relocs */
2504 if (! create_got_section (abfd, info))
2505 return FALSE;
2506 if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2507 {
2508 if (! create_rofixup_section (abfd, info))
2509 return FALSE;
2510 }
2511
2512 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2513 .rel[a].bss sections. */
2514 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2515 | SEC_LINKER_CREATED);
2516
2517 pltflags = flags;
2518 pltflags |= SEC_CODE;
2519 if (bed->plt_not_loaded)
2520 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2521 if (bed->plt_readonly)
2522 pltflags |= SEC_READONLY;
2523
2524 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
2525 htab->splt = s;
2526 if (s == NULL
2527 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2528 return FALSE;
2529
2530 if (bed->want_plt_sym)
2531 {
2532 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2533 .plt section. */
2534 struct bfd_link_hash_entry *bh = NULL;
2535 struct elf_link_hash_entry *h;
2536
2537 if (! (_bfd_generic_link_add_one_symbol
2538 (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2539 (bfd_vma) 0, NULL, FALSE,
2540 get_elf_backend_data (abfd)->collect, &bh)))
2541 return FALSE;
2542 h = (struct elf_link_hash_entry *) bh;
2543 h->def_regular = 1;
2544 h->type = STT_OBJECT;
2545 htab->root.hplt = h;
2546
2547 if (info->shared
2548 && ! bfd_elf_link_record_dynamic_symbol (info, h))
2549 return FALSE;
2550 }
2551
2552 s = bfd_make_section_with_flags (abfd,
2553 bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
2554 flags | SEC_READONLY);
2555 htab->srelplt = s;
2556 if (s == NULL
2557 || ! bfd_set_section_alignment (abfd, s, ptralign))
2558 return FALSE;
2559
2560 if (htab->sgot == NULL
2561 && ! create_got_section (abfd, info))
2562 return FALSE;
2563
2564 {
2565 const char *secname;
2566 char *relname;
2567 flagword secflags;
2568 asection *sec;
2569
2570 for (sec = abfd->sections; sec; sec = sec->next)
2571 {
2572 secflags = bfd_get_section_flags (abfd, sec);
2573 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
2574 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
2575 continue;
2576 secname = bfd_get_section_name (abfd, sec);
2577 relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
2578 strcpy (relname, ".rela");
2579 strcat (relname, secname);
2580 if (bfd_get_section_by_name (abfd, secname))
2581 continue;
2582 s = bfd_make_section_with_flags (abfd, relname,
2583 flags | SEC_READONLY);
2584 if (s == NULL
2585 || ! bfd_set_section_alignment (abfd, s, ptralign))
2586 return FALSE;
2587 }
2588 }
2589
2590 if (bed->want_dynbss)
2591 {
2592 /* The .dynbss section is a place to put symbols which are defined
2593 by dynamic objects, are referenced by regular objects, and are
2594 not functions. We must allocate space for them in the process
2595 image and use a R_*_COPY reloc to tell the dynamic linker to
2596 initialize them at run time. The linker script puts the .dynbss
2597 section into the .bss section of the final image. */
2598 s = bfd_make_section_with_flags (abfd, ".dynbss",
2599 SEC_ALLOC | SEC_LINKER_CREATED);
2600 htab->sdynbss = s;
2601 if (s == NULL)
2602 return FALSE;
2603 /* The .rel[a].bss section holds copy relocs. This section is not
2604 normally needed. We need to create it here, though, so that the
2605 linker will map it to an output section. We can't just create it
2606 only if we need it, because we will not know whether we need it
2607 until we have seen all the input files, and the first time the
2608 main linker code calls BFD after examining all the input files
2609 (size_dynamic_sections) the input sections have already been
2610 mapped to the output sections. If the section turns out not to
2611 be needed, we can discard it later. We will never need this
2612 section when generating a shared object, since they do not use
2613 copy relocs. */
2614 if (! info->shared)
2615 {
2616 s = bfd_make_section_with_flags (abfd,
2617 (bed->default_use_rela_p
2618 ? ".rela.bss" : ".rel.bss"),
2619 flags | SEC_READONLY);
2620 htab->srelbss = s;
2621 if (s == NULL
2622 || ! bfd_set_section_alignment (abfd, s, ptralign))
2623 return FALSE;
2624 }
2625 }
2626
2627 return TRUE;
2628 }
2629
2630 /* Copy the extra info we tack onto an elf_link_hash_entry. */
2631
2632 static void
2633 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2634 struct elf_link_hash_entry *dir,
2635 struct elf_link_hash_entry *ind)
2636 {
2637 struct elf_lm32_link_hash_entry * edir;
2638 struct elf_lm32_link_hash_entry * eind;
2639
2640 edir = (struct elf_lm32_link_hash_entry *) dir;
2641 eind = (struct elf_lm32_link_hash_entry *) ind;
2642
2643 if (eind->dyn_relocs != NULL)
2644 {
2645 if (edir->dyn_relocs != NULL)
2646 {
2647 struct elf_lm32_dyn_relocs **pp;
2648 struct elf_lm32_dyn_relocs *p;
2649
2650 /* Add reloc counts against the indirect sym to the direct sym
2651 list. Merge any entries against the same section. */
2652 for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2653 {
2654 struct elf_lm32_dyn_relocs *q;
2655
2656 for (q = edir->dyn_relocs; q != NULL; q = q->next)
2657 if (q->sec == p->sec)
2658 {
2659 q->pc_count += p->pc_count;
2660 q->count += p->count;
2661 *pp = p->next;
2662 break;
2663 }
2664 if (q == NULL)
2665 pp = &p->next;
2666 }
2667 *pp = edir->dyn_relocs;
2668 }
2669
2670 edir->dyn_relocs = eind->dyn_relocs;
2671 eind->dyn_relocs = NULL;
2672 }
2673
2674 _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2675 }
2676
2677 static bfd_boolean
2678 lm32_elf_always_size_sections (bfd *output_bfd,
2679 struct bfd_link_info *info)
2680 {
2681 if (!info->relocatable)
2682 {
2683 struct elf_link_hash_entry *h;
2684
2685 /* Force a PT_GNU_STACK segment to be created. */
2686 if (! elf_tdata (output_bfd)->stack_flags)
2687 elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
2688
2689 /* Define __stacksize if it's not defined yet. */
2690 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2691 FALSE, FALSE, FALSE);
2692 if (! h || h->root.type != bfd_link_hash_defined
2693 || h->type != STT_OBJECT
2694 || !h->def_regular)
2695 {
2696 struct bfd_link_hash_entry *bh = NULL;
2697
2698 if (!(_bfd_generic_link_add_one_symbol
2699 (info, output_bfd, "__stacksize",
2700 BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
2701 (const char *) NULL, FALSE,
2702 get_elf_backend_data (output_bfd)->collect, &bh)))
2703 return FALSE;
2704
2705 h = (struct elf_link_hash_entry *) bh;
2706 h->def_regular = 1;
2707 h->type = STT_OBJECT;
2708 /* This one must NOT be hidden. */
2709 }
2710 }
2711
2712 return TRUE;
2713 }
2714
2715 static bfd_boolean
2716 lm32_elf_modify_segment_map (bfd *output_bfd,
2717 struct bfd_link_info *info)
2718 {
2719 struct elf_segment_map *m;
2720
2721 /* objcopy and strip preserve what's already there using elf32_lm32fdpic_copy_
2722 private_bfd_data (). */
2723 if (! info)
2724 return TRUE;
2725
2726 for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
2727 if (m->p_type == PT_GNU_STACK)
2728 break;
2729
2730 if (m)
2731 {
2732 asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2733 struct elf_link_hash_entry *h;
2734
2735 if (sec)
2736 {
2737 /* Obtain the pointer to the __stacksize symbol. */
2738 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2739 FALSE, FALSE, FALSE);
2740 while (h->root.type == bfd_link_hash_indirect
2741 || h->root.type == bfd_link_hash_warning)
2742 h = (struct elf_link_hash_entry *)h->root.u.i.link;
2743 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2744
2745 /* Set the section size from the symbol value. We
2746 intentionally ignore the symbol section. */
2747 if (h->root.type == bfd_link_hash_defined)
2748 sec->size = h->root.u.def.value;
2749 else
2750 sec->size = DEFAULT_STACK_SIZE;
2751
2752 /* Add the stack section to the PT_GNU_STACK segment,
2753 such that its size and alignment requirements make it
2754 to the segment. */
2755 m->sections[m->count] = sec;
2756 m->count++;
2757 }
2758 }
2759
2760 return TRUE;
2761 }
2762
2763 static bfd_boolean
2764 lm32_elf_modify_program_headers (bfd *output_bfd,
2765 struct bfd_link_info *info)
2766 {
2767 struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
2768 struct elf_segment_map *m;
2769 Elf_Internal_Phdr *p;
2770
2771 if (! info)
2772 return TRUE;
2773
2774 for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
2775 if (m->p_type == PT_GNU_STACK)
2776 break;
2777
2778 if (m)
2779 {
2780 struct elf_link_hash_entry *h;
2781
2782 /* Obtain the pointer to the __stacksize symbol. */
2783 h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2784 FALSE, FALSE, FALSE);
2785 if (h)
2786 {
2787 while (h->root.type == bfd_link_hash_indirect
2788 || h->root.type == bfd_link_hash_warning)
2789 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2790 BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2791 }
2792
2793 /* Set the header p_memsz from the symbol value. We
2794 intentionally ignore the symbol section. */
2795 if (h && h->root.type == bfd_link_hash_defined)
2796 p->p_memsz = h->root.u.def.value;
2797 else
2798 p->p_memsz = DEFAULT_STACK_SIZE;
2799
2800 p->p_align = 8;
2801 }
2802
2803 return TRUE;
2804 }
2805
2806
2807 static bfd_boolean
2808 lm32_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
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 BFD_ASSERT (!elf_flags_init (obfd)
2815 || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
2816
2817 elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2818 elf_flags_init (obfd) = TRUE;
2819
2820 /* Copy object attributes. */
2821 _bfd_elf_copy_obj_attributes (ibfd, obfd);
2822
2823 return TRUE;
2824 }
2825
2826
2827 static bfd_boolean
2828 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2829 {
2830 unsigned i;
2831
2832 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2833 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2834 return TRUE;
2835
2836 if (! lm32_elf_copy_private_bfd_data (ibfd, obfd))
2837 return FALSE;
2838
2839 if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2840 || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2841 return TRUE;
2842
2843 /* Copy the stack size. */
2844 for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2845 if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2846 {
2847 Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2848
2849 for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2850 if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2851 {
2852 memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2853
2854 /* Rewrite the phdrs, since we're only called after they were first written. */
2855 if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2856 ->s->sizeof_ehdr, SEEK_SET) != 0
2857 || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2858 elf_elfheader (obfd)->e_phnum) != 0)
2859 return FALSE;
2860 break;
2861 }
2862
2863 break;
2864 }
2865
2866 return TRUE;
2867 }
2868
2869
2870 #define ELF_ARCH bfd_arch_lm32
2871 #define ELF_MACHINE_CODE EM_LATTICEMICO32
2872 #define ELF_MAXPAGESIZE 0x1000
2873
2874 #define TARGET_BIG_SYM bfd_elf32_lm32_vec
2875 #define TARGET_BIG_NAME "elf32-lm32"
2876
2877 #define bfd_elf32_bfd_reloc_type_lookup lm32_reloc_type_lookup
2878 #define bfd_elf32_bfd_reloc_name_lookup lm32_reloc_name_lookup
2879 #define elf_info_to_howto lm32_info_to_howto_rela
2880 #define elf_info_to_howto_rel 0
2881 #define elf_backend_rela_normal 1
2882 #define elf_backend_object_p lm32_elf_object_p
2883 #define elf_backend_final_write_processing lm32_elf_final_write_processing
2884 #define elf_backend_can_gc_sections 1
2885 #define elf_backend_can_refcount 1
2886 #define elf_backend_gc_mark_hook lm32_elf_gc_mark_hook
2887 #define elf_backend_gc_sweep_hook lm32_elf_gc_sweep_hook
2888 #define elf_backend_plt_readonly 1
2889 #define elf_backend_want_got_plt 1
2890 #define elf_backend_want_plt_sym 0
2891 #define elf_backend_got_header_size 12
2892 #define bfd_elf32_bfd_link_hash_table_create lm32_elf_link_hash_table_create
2893 #define elf_backend_check_relocs lm32_elf_check_relocs
2894 #define elf_backend_reloc_type_class lm32_elf_reloc_type_class
2895 #define elf_backend_copy_indirect_symbol lm32_elf_copy_indirect_symbol
2896 #define elf_backend_size_dynamic_sections lm32_elf_size_dynamic_sections
2897 #define elf_backend_omit_section_dynsym ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2898 #define elf_backend_create_dynamic_sections lm32_elf_create_dynamic_sections
2899 #define elf_backend_finish_dynamic_sections lm32_elf_finish_dynamic_sections
2900 #define elf_backend_adjust_dynamic_symbol lm32_elf_adjust_dynamic_symbol
2901 #define elf_backend_finish_dynamic_symbol lm32_elf_finish_dynamic_symbol
2902 #define elf_backend_relocate_section lm32_elf_relocate_section
2903
2904 #include "elf32-target.h"
2905
2906 #undef ELF_MAXPAGESIZE
2907 #define ELF_MAXPAGESIZE 0x4000
2908
2909
2910 #undef TARGET_BIG_SYM
2911 #define TARGET_BIG_SYM bfd_elf32_lm32fdpic_vec
2912 #undef TARGET_BIG_NAME
2913 #define TARGET_BIG_NAME "elf32-lm32fdpic"
2914 #undef elf32_bed
2915 #define elf32_bed elf32_lm32fdpic_bed
2916
2917 #undef elf_backend_always_size_sections
2918 #define elf_backend_always_size_sections lm32_elf_always_size_sections
2919 #undef elf_backend_modify_segment_map
2920 #define elf_backend_modify_segment_map lm32_elf_modify_segment_map
2921 #undef elf_backend_modify_program_headers
2922 #define elf_backend_modify_program_headers lm32_elf_modify_program_headers
2923 #undef bfd_elf32_bfd_copy_private_bfd_data
2924 #define bfd_elf32_bfd_copy_private_bfd_data lm32_elf_fdpic_copy_private_bfd_data
2925
2926 #include "elf32-target.h"
git-cvsimport of binutils cvsroot