?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-05-28 Nick Clifton <nickc@redhat.com>
[binutils.git] / bfd / elf-m10300.c
blobd3270c5dbb87ec502d73ab964d06a4b0f28512a0
1 /* Matsushita 10300 specific support for 32-bit ELF
2 Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
3 2006, 2007 Free Software Foundation, Inc.
4
5 This file is part of BFD, the Binary File Descriptor library.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
20 MA 02110-1301, USA. */
21
22 #include "sysdep.h"
23 #include "bfd.h"
24 #include "libbfd.h"
25 #include "elf-bfd.h"
26 #include "elf/mn10300.h"
27 #include "libiberty.h"
28
29 /* The mn10300 linker needs to keep track of the number of relocs that
30 it decides to copy in check_relocs for each symbol. This is so
31 that it can discard PC relative relocs if it doesn't need them when
32 linking with -Bsymbolic. We store the information in a field
33 extending the regular ELF linker hash table. */
34
35 struct elf32_mn10300_link_hash_entry
36 {
37 /* The basic elf link hash table entry. */
38 struct elf_link_hash_entry root;
39
40 /* For function symbols, the number of times this function is
41 called directly (ie by name). */
42 unsigned int direct_calls;
43
44 /* For function symbols, the size of this function's stack
45 (if <= 255 bytes). We stuff this into "call" instructions
46 to this target when it's valid and profitable to do so.
47
48 This does not include stack allocated by movm! */
49 unsigned char stack_size;
50
51 /* For function symbols, arguments (if any) for movm instruction
52 in the prologue. We stuff this value into "call" instructions
53 to the target when it's valid and profitable to do so. */
54 unsigned char movm_args;
55
56 /* For function symbols, the amount of stack space that would be allocated
57 by the movm instruction. This is redundant with movm_args, but we
58 add it to the hash table to avoid computing it over and over. */
59 unsigned char movm_stack_size;
60
61 /* When set, convert all "call" instructions to this target into "calls"
62 instructions. */
63 #define MN10300_CONVERT_CALL_TO_CALLS 0x1
64
65 /* Used to mark functions which have had redundant parts of their
66 prologue deleted. */
67 #define MN10300_DELETED_PROLOGUE_BYTES 0x2
68 unsigned char flags;
69
70 /* Calculated value. */
71 bfd_vma value;
72 };
73
74 /* We derive a hash table from the main elf linker hash table so
75 we can store state variables and a secondary hash table without
76 resorting to global variables. */
77 struct elf32_mn10300_link_hash_table
78 {
79 /* The main hash table. */
80 struct elf_link_hash_table root;
81
82 /* A hash table for static functions. We could derive a new hash table
83 instead of using the full elf32_mn10300_link_hash_table if we wanted
84 to save some memory. */
85 struct elf32_mn10300_link_hash_table *static_hash_table;
86
87 /* Random linker state flags. */
88 #define MN10300_HASH_ENTRIES_INITIALIZED 0x1
89 char flags;
90 };
91
92 #ifndef streq
93 #define streq(a, b) (strcmp ((a),(b)) == 0)
94 #endif
95
96 /* For MN10300 linker hash table. */
97
98 /* Get the MN10300 ELF linker hash table from a link_info structure. */
99
100 #define elf32_mn10300_hash_table(p) \
101 ((struct elf32_mn10300_link_hash_table *) ((p)->hash))
102
103 #define elf32_mn10300_link_hash_traverse(table, func, info) \
104 (elf_link_hash_traverse \
105 (&(table)->root, \
106 (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func), \
107 (info)))
108
109 static reloc_howto_type elf_mn10300_howto_table[] =
110 {
111 /* Dummy relocation. Does nothing. */
112 HOWTO (R_MN10300_NONE,
113 0,
114 2,
115 16,
116 FALSE,
117 0,
118 complain_overflow_bitfield,
119 bfd_elf_generic_reloc,
120 "R_MN10300_NONE",
121 FALSE,
122 0,
123 0,
124 FALSE),
125 /* Standard 32 bit reloc. */
126 HOWTO (R_MN10300_32,
127 0,
128 2,
129 32,
130 FALSE,
131 0,
132 complain_overflow_bitfield,
133 bfd_elf_generic_reloc,
134 "R_MN10300_32",
135 FALSE,
136 0xffffffff,
137 0xffffffff,
138 FALSE),
139 /* Standard 16 bit reloc. */
140 HOWTO (R_MN10300_16,
141 0,
142 1,
143 16,
144 FALSE,
145 0,
146 complain_overflow_bitfield,
147 bfd_elf_generic_reloc,
148 "R_MN10300_16",
149 FALSE,
150 0xffff,
151 0xffff,
152 FALSE),
153 /* Standard 8 bit reloc. */
154 HOWTO (R_MN10300_8,
155 0,
156 0,
157 8,
158 FALSE,
159 0,
160 complain_overflow_bitfield,
161 bfd_elf_generic_reloc,
162 "R_MN10300_8",
163 FALSE,
164 0xff,
165 0xff,
166 FALSE),
167 /* Standard 32bit pc-relative reloc. */
168 HOWTO (R_MN10300_PCREL32,
169 0,
170 2,
171 32,
172 TRUE,
173 0,
174 complain_overflow_bitfield,
175 bfd_elf_generic_reloc,
176 "R_MN10300_PCREL32",
177 FALSE,
178 0xffffffff,
179 0xffffffff,
180 TRUE),
181 /* Standard 16bit pc-relative reloc. */
182 HOWTO (R_MN10300_PCREL16,
183 0,
184 1,
185 16,
186 TRUE,
187 0,
188 complain_overflow_bitfield,
189 bfd_elf_generic_reloc,
190 "R_MN10300_PCREL16",
191 FALSE,
192 0xffff,
193 0xffff,
194 TRUE),
195 /* Standard 8 pc-relative reloc. */
196 HOWTO (R_MN10300_PCREL8,
197 0,
198 0,
199 8,
200 TRUE,
201 0,
202 complain_overflow_bitfield,
203 bfd_elf_generic_reloc,
204 "R_MN10300_PCREL8",
205 FALSE,
206 0xff,
207 0xff,
208 TRUE),
209
210 /* GNU extension to record C++ vtable hierarchy. */
211 HOWTO (R_MN10300_GNU_VTINHERIT, /* type */
212 0, /* rightshift */
213 0, /* size (0 = byte, 1 = short, 2 = long) */
214 0, /* bitsize */
215 FALSE, /* pc_relative */
216 0, /* bitpos */
217 complain_overflow_dont, /* complain_on_overflow */
218 NULL, /* special_function */
219 "R_MN10300_GNU_VTINHERIT", /* name */
220 FALSE, /* partial_inplace */
221 0, /* src_mask */
222 0, /* dst_mask */
223 FALSE), /* pcrel_offset */
224
225 /* GNU extension to record C++ vtable member usage */
226 HOWTO (R_MN10300_GNU_VTENTRY, /* type */
227 0, /* rightshift */
228 0, /* size (0 = byte, 1 = short, 2 = long) */
229 0, /* bitsize */
230 FALSE, /* pc_relative */
231 0, /* bitpos */
232 complain_overflow_dont, /* complain_on_overflow */
233 NULL, /* special_function */
234 "R_MN10300_GNU_VTENTRY", /* name */
235 FALSE, /* partial_inplace */
236 0, /* src_mask */
237 0, /* dst_mask */
238 FALSE), /* pcrel_offset */
239
240 /* Standard 24 bit reloc. */
241 HOWTO (R_MN10300_24,
242 0,
243 2,
244 24,
245 FALSE,
246 0,
247 complain_overflow_bitfield,
248 bfd_elf_generic_reloc,
249 "R_MN10300_24",
250 FALSE,
251 0xffffff,
252 0xffffff,
253 FALSE),
254 HOWTO (R_MN10300_GOTPC32, /* type */
255 0, /* rightshift */
256 2, /* size (0 = byte, 1 = short, 2 = long) */
257 32, /* bitsize */
258 TRUE, /* pc_relative */
259 0, /* bitpos */
260 complain_overflow_bitfield, /* complain_on_overflow */
261 bfd_elf_generic_reloc, /* */
262 "R_MN10300_GOTPC32", /* name */
263 FALSE, /* partial_inplace */
264 0xffffffff, /* src_mask */
265 0xffffffff, /* dst_mask */
266 TRUE), /* pcrel_offset */
267
268 HOWTO (R_MN10300_GOTPC16, /* type */
269 0, /* rightshift */
270 1, /* size (0 = byte, 1 = short, 2 = long) */
271 16, /* bitsize */
272 TRUE, /* pc_relative */
273 0, /* bitpos */
274 complain_overflow_bitfield, /* complain_on_overflow */
275 bfd_elf_generic_reloc, /* */
276 "R_MN10300_GOTPC16", /* name */
277 FALSE, /* partial_inplace */
278 0xffff, /* src_mask */
279 0xffff, /* dst_mask */
280 TRUE), /* pcrel_offset */
281
282 HOWTO (R_MN10300_GOTOFF32, /* type */
283 0, /* rightshift */
284 2, /* size (0 = byte, 1 = short, 2 = long) */
285 32, /* bitsize */
286 FALSE, /* pc_relative */
287 0, /* bitpos */
288 complain_overflow_bitfield, /* complain_on_overflow */
289 bfd_elf_generic_reloc, /* */
290 "R_MN10300_GOTOFF32", /* name */
291 FALSE, /* partial_inplace */
292 0xffffffff, /* src_mask */
293 0xffffffff, /* dst_mask */
294 FALSE), /* pcrel_offset */
295
296 HOWTO (R_MN10300_GOTOFF24, /* type */
297 0, /* rightshift */
298 2, /* size (0 = byte, 1 = short, 2 = long) */
299 24, /* bitsize */
300 FALSE, /* pc_relative */
301 0, /* bitpos */
302 complain_overflow_bitfield, /* complain_on_overflow */
303 bfd_elf_generic_reloc, /* */
304 "R_MN10300_GOTOFF24", /* name */
305 FALSE, /* partial_inplace */
306 0xffffff, /* src_mask */
307 0xffffff, /* dst_mask */
308 FALSE), /* pcrel_offset */
309
310 HOWTO (R_MN10300_GOTOFF16, /* type */
311 0, /* rightshift */
312 1, /* size (0 = byte, 1 = short, 2 = long) */
313 16, /* bitsize */
314 FALSE, /* pc_relative */
315 0, /* bitpos */
316 complain_overflow_bitfield, /* complain_on_overflow */
317 bfd_elf_generic_reloc, /* */
318 "R_MN10300_GOTOFF16", /* name */
319 FALSE, /* partial_inplace */
320 0xffff, /* src_mask */
321 0xffff, /* dst_mask */
322 FALSE), /* pcrel_offset */
323
324 HOWTO (R_MN10300_PLT32, /* type */
325 0, /* rightshift */
326 2, /* size (0 = byte, 1 = short, 2 = long) */
327 32, /* bitsize */
328 TRUE, /* pc_relative */
329 0, /* bitpos */
330 complain_overflow_bitfield, /* complain_on_overflow */
331 bfd_elf_generic_reloc, /* */
332 "R_MN10300_PLT32", /* name */
333 FALSE, /* partial_inplace */
334 0xffffffff, /* src_mask */
335 0xffffffff, /* dst_mask */
336 TRUE), /* pcrel_offset */
337
338 HOWTO (R_MN10300_PLT16, /* type */
339 0, /* rightshift */
340 1, /* size (0 = byte, 1 = short, 2 = long) */
341 16, /* bitsize */
342 TRUE, /* pc_relative */
343 0, /* bitpos */
344 complain_overflow_bitfield, /* complain_on_overflow */
345 bfd_elf_generic_reloc, /* */
346 "R_MN10300_PLT16", /* name */
347 FALSE, /* partial_inplace */
348 0xffff, /* src_mask */
349 0xffff, /* dst_mask */
350 TRUE), /* pcrel_offset */
351
352 HOWTO (R_MN10300_GOT32, /* type */
353 0, /* rightshift */
354 2, /* size (0 = byte, 1 = short, 2 = long) */
355 32, /* bitsize */
356 FALSE, /* pc_relative */
357 0, /* bitpos */
358 complain_overflow_bitfield, /* complain_on_overflow */
359 bfd_elf_generic_reloc, /* */
360 "R_MN10300_GOT32", /* name */
361 FALSE, /* partial_inplace */
362 0xffffffff, /* src_mask */
363 0xffffffff, /* dst_mask */
364 FALSE), /* pcrel_offset */
365
366 HOWTO (R_MN10300_GOT24, /* type */
367 0, /* rightshift */
368 2, /* size (0 = byte, 1 = short, 2 = long) */
369 24, /* bitsize */
370 FALSE, /* pc_relative */
371 0, /* bitpos */
372 complain_overflow_bitfield, /* complain_on_overflow */
373 bfd_elf_generic_reloc, /* */
374 "R_MN10300_GOT24", /* name */
375 FALSE, /* partial_inplace */
376 0xffffffff, /* src_mask */
377 0xffffffff, /* dst_mask */
378 FALSE), /* pcrel_offset */
379
380 HOWTO (R_MN10300_GOT16, /* type */
381 0, /* rightshift */
382 1, /* size (0 = byte, 1 = short, 2 = long) */
383 16, /* bitsize */
384 FALSE, /* pc_relative */
385 0, /* bitpos */
386 complain_overflow_bitfield, /* complain_on_overflow */
387 bfd_elf_generic_reloc, /* */
388 "R_MN10300_GOT16", /* name */
389 FALSE, /* partial_inplace */
390 0xffffffff, /* src_mask */
391 0xffffffff, /* dst_mask */
392 FALSE), /* pcrel_offset */
393
394 HOWTO (R_MN10300_COPY, /* type */
395 0, /* rightshift */
396 2, /* size (0 = byte, 1 = short, 2 = long) */
397 32, /* bitsize */
398 FALSE, /* pc_relative */
399 0, /* bitpos */
400 complain_overflow_bitfield, /* complain_on_overflow */
401 bfd_elf_generic_reloc, /* */
402 "R_MN10300_COPY", /* name */
403 FALSE, /* partial_inplace */
404 0xffffffff, /* src_mask */
405 0xffffffff, /* dst_mask */
406 FALSE), /* pcrel_offset */
407
408 HOWTO (R_MN10300_GLOB_DAT, /* type */
409 0, /* rightshift */
410 2, /* size (0 = byte, 1 = short, 2 = long) */
411 32, /* bitsize */
412 FALSE, /* pc_relative */
413 0, /* bitpos */
414 complain_overflow_bitfield, /* complain_on_overflow */
415 bfd_elf_generic_reloc, /* */
416 "R_MN10300_GLOB_DAT", /* name */
417 FALSE, /* partial_inplace */
418 0xffffffff, /* src_mask */
419 0xffffffff, /* dst_mask */
420 FALSE), /* pcrel_offset */
421
422 HOWTO (R_MN10300_JMP_SLOT, /* type */
423 0, /* rightshift */
424 2, /* size (0 = byte, 1 = short, 2 = long) */
425 32, /* bitsize */
426 FALSE, /* pc_relative */
427 0, /* bitpos */
428 complain_overflow_bitfield, /* complain_on_overflow */
429 bfd_elf_generic_reloc, /* */
430 "R_MN10300_JMP_SLOT", /* name */
431 FALSE, /* partial_inplace */
432 0xffffffff, /* src_mask */
433 0xffffffff, /* dst_mask */
434 FALSE), /* pcrel_offset */
435
436 HOWTO (R_MN10300_RELATIVE, /* type */
437 0, /* rightshift */
438 2, /* size (0 = byte, 1 = short, 2 = long) */
439 32, /* bitsize */
440 FALSE, /* pc_relative */
441 0, /* bitpos */
442 complain_overflow_bitfield, /* complain_on_overflow */
443 bfd_elf_generic_reloc, /* */
444 "R_MN10300_RELATIVE", /* name */
445 FALSE, /* partial_inplace */
446 0xffffffff, /* src_mask */
447 0xffffffff, /* dst_mask */
448 FALSE), /* pcrel_offset */
449
450 EMPTY_HOWTO (24),
451 EMPTY_HOWTO (25),
452 EMPTY_HOWTO (26),
453 EMPTY_HOWTO (27),
454 EMPTY_HOWTO (28),
455 EMPTY_HOWTO (29),
456 EMPTY_HOWTO (30),
457 EMPTY_HOWTO (31),
458 EMPTY_HOWTO (32),
459
460 HOWTO (R_MN10300_SYM_DIFF, /* type */
461 0, /* rightshift */
462 2, /* size (0 = byte, 1 = short, 2 = long) */
463 32, /* bitsize */
464 FALSE, /* pc_relative */
465 0, /* bitpos */
466 complain_overflow_dont,/* complain_on_overflow */
467 NULL, /* special handler. */
468 "R_MN10300_SYM_DIFF", /* name */
469 FALSE, /* partial_inplace */
470 0xffffffff, /* src_mask */
471 0xffffffff, /* dst_mask */
472 FALSE), /* pcrel_offset */
473
474 HOWTO (R_MN10300_ALIGN, /* type */
475 0, /* rightshift */
476 0, /* size (0 = byte, 1 = short, 2 = long) */
477 32, /* bitsize */
478 FALSE, /* pc_relative */
479 0, /* bitpos */
480 complain_overflow_dont,/* complain_on_overflow */
481 NULL, /* special handler. */
482 "R_MN10300_ALIGN", /* name */
483 FALSE, /* partial_inplace */
484 0, /* src_mask */
485 0, /* dst_mask */
486 FALSE) /* pcrel_offset */
487 };
488
489 struct mn10300_reloc_map
490 {
491 bfd_reloc_code_real_type bfd_reloc_val;
492 unsigned char elf_reloc_val;
493 };
494
495 static const struct mn10300_reloc_map mn10300_reloc_map[] =
496 {
497 { BFD_RELOC_NONE, R_MN10300_NONE, },
498 { BFD_RELOC_32, R_MN10300_32, },
499 { BFD_RELOC_16, R_MN10300_16, },
500 { BFD_RELOC_8, R_MN10300_8, },
501 { BFD_RELOC_32_PCREL, R_MN10300_PCREL32, },
502 { BFD_RELOC_16_PCREL, R_MN10300_PCREL16, },
503 { BFD_RELOC_8_PCREL, R_MN10300_PCREL8, },
504 { BFD_RELOC_24, R_MN10300_24, },
505 { BFD_RELOC_VTABLE_INHERIT, R_MN10300_GNU_VTINHERIT },
506 { BFD_RELOC_VTABLE_ENTRY, R_MN10300_GNU_VTENTRY },
507 { BFD_RELOC_32_GOT_PCREL, R_MN10300_GOTPC32 },
508 { BFD_RELOC_16_GOT_PCREL, R_MN10300_GOTPC16 },
509 { BFD_RELOC_32_GOTOFF, R_MN10300_GOTOFF32 },
510 { BFD_RELOC_MN10300_GOTOFF24, R_MN10300_GOTOFF24 },
511 { BFD_RELOC_16_GOTOFF, R_MN10300_GOTOFF16 },
512 { BFD_RELOC_32_PLT_PCREL, R_MN10300_PLT32 },
513 { BFD_RELOC_16_PLT_PCREL, R_MN10300_PLT16 },
514 { BFD_RELOC_MN10300_GOT32, R_MN10300_GOT32 },
515 { BFD_RELOC_MN10300_GOT24, R_MN10300_GOT24 },
516 { BFD_RELOC_MN10300_GOT16, R_MN10300_GOT16 },
517 { BFD_RELOC_MN10300_COPY, R_MN10300_COPY },
518 { BFD_RELOC_MN10300_GLOB_DAT, R_MN10300_GLOB_DAT },
519 { BFD_RELOC_MN10300_JMP_SLOT, R_MN10300_JMP_SLOT },
520 { BFD_RELOC_MN10300_RELATIVE, R_MN10300_RELATIVE },
521 { BFD_RELOC_MN10300_SYM_DIFF, R_MN10300_SYM_DIFF },
522 { BFD_RELOC_MN10300_ALIGN, R_MN10300_ALIGN }
523 };
524
525 /* Create the GOT section. */
526
527 static bfd_boolean
528 _bfd_mn10300_elf_create_got_section (bfd * abfd,
529 struct bfd_link_info * info)
530 {
531 flagword flags;
532 flagword pltflags;
533 asection * s;
534 struct elf_link_hash_entry * h;
535 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
536 int ptralign;
537
538 /* This function may be called more than once. */
539 if (bfd_get_section_by_name (abfd, ".got") != NULL)
540 return TRUE;
541
542 switch (bed->s->arch_size)
543 {
544 case 32:
545 ptralign = 2;
546 break;
547
548 case 64:
549 ptralign = 3;
550 break;
551
552 default:
553 bfd_set_error (bfd_error_bad_value);
554 return FALSE;
555 }
556
557 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
558 | SEC_LINKER_CREATED);
559
560 pltflags = flags;
561 pltflags |= SEC_CODE;
562 if (bed->plt_not_loaded)
563 pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
564 if (bed->plt_readonly)
565 pltflags |= SEC_READONLY;
566
567 s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
568 if (s == NULL
569 || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
570 return FALSE;
571
572 /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
573 .plt section. */
574 if (bed->want_plt_sym)
575 {
576 h = _bfd_elf_define_linkage_sym (abfd, info, s,
577 "_PROCEDURE_LINKAGE_TABLE_");
578 elf_hash_table (info)->hplt = h;
579 if (h == NULL)
580 return FALSE;
581 }
582
583 s = bfd_make_section_with_flags (abfd, ".got", flags);
584 if (s == NULL
585 || ! bfd_set_section_alignment (abfd, s, ptralign))
586 return FALSE;
587
588 if (bed->want_got_plt)
589 {
590 s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
591 if (s == NULL
592 || ! bfd_set_section_alignment (abfd, s, ptralign))
593 return FALSE;
594 }
595
596 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
597 (or .got.plt) section. We don't do this in the linker script
598 because we don't want to define the symbol if we are not creating
599 a global offset table. */
600 h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
601 elf_hash_table (info)->hgot = h;
602 if (h == NULL)
603 return FALSE;
604
605 /* The first bit of the global offset table is the header. */
606 s->size += bed->got_header_size;
607
608 return TRUE;
609 }
610
611 static reloc_howto_type *
612 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
613 bfd_reloc_code_real_type code)
614 {
615 unsigned int i;
616
617 for (i = ARRAY_SIZE (mn10300_reloc_map); i--;)
618 if (mn10300_reloc_map[i].bfd_reloc_val == code)
619 return &elf_mn10300_howto_table[mn10300_reloc_map[i].elf_reloc_val];
620
621 return NULL;
622 }
623
624 static reloc_howto_type *
625 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
626 const char *r_name)
627 {
628 unsigned int i;
629
630 for (i = ARRAY_SIZE (elf_mn10300_howto_table); i--;)
631 if (elf_mn10300_howto_table[i].name != NULL
632 && strcasecmp (elf_mn10300_howto_table[i].name, r_name) == 0)
633 return elf_mn10300_howto_table + i;
634
635 return NULL;
636 }
637
638 /* Set the howto pointer for an MN10300 ELF reloc. */
639
640 static void
641 mn10300_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
642 arelent *cache_ptr,
643 Elf_Internal_Rela *dst)
644 {
645 unsigned int r_type;
646
647 r_type = ELF32_R_TYPE (dst->r_info);
648 BFD_ASSERT (r_type < (unsigned int) R_MN10300_MAX);
649 cache_ptr->howto = elf_mn10300_howto_table + r_type;
650 }
651
652 /* Look through the relocs for a section during the first phase.
653 Since we don't do .gots or .plts, we just need to consider the
654 virtual table relocs for gc. */
655
656 static bfd_boolean
657 mn10300_elf_check_relocs (bfd *abfd,
658 struct bfd_link_info *info,
659 asection *sec,
660 const Elf_Internal_Rela *relocs)
661 {
662 bfd_boolean sym_diff_reloc_seen;
663 Elf_Internal_Shdr *symtab_hdr;
664 Elf_Internal_Sym * isymbuf = NULL;
665 struct elf_link_hash_entry **sym_hashes;
666 const Elf_Internal_Rela *rel;
667 const Elf_Internal_Rela *rel_end;
668 bfd * dynobj;
669 bfd_vma * local_got_offsets;
670 asection * sgot;
671 asection * srelgot;
672 asection * sreloc;
673 bfd_boolean result = FALSE;
674
675 sgot = NULL;
676 srelgot = NULL;
677 sreloc = NULL;
678
679 if (info->relocatable)
680 return TRUE;
681
682 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
683 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
684 sym_hashes = elf_sym_hashes (abfd);
685
686 dynobj = elf_hash_table (info)->dynobj;
687 local_got_offsets = elf_local_got_offsets (abfd);
688 rel_end = relocs + sec->reloc_count;
689 sym_diff_reloc_seen = FALSE;
690
691 for (rel = relocs; rel < rel_end; rel++)
692 {
693 struct elf_link_hash_entry *h;
694 unsigned long r_symndx;
695 unsigned int r_type;
696
697 r_symndx = ELF32_R_SYM (rel->r_info);
698 if (r_symndx < symtab_hdr->sh_info)
699 h = NULL;
700 else
701 {
702 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
703 while (h->root.type == bfd_link_hash_indirect
704 || h->root.type == bfd_link_hash_warning)
705 h = (struct elf_link_hash_entry *) h->root.u.i.link;
706 }
707
708 r_type = ELF32_R_TYPE (rel->r_info);
709
710 /* Some relocs require a global offset table. */
711 if (dynobj == NULL)
712 {
713 switch (r_type)
714 {
715 case R_MN10300_GOT32:
716 case R_MN10300_GOT24:
717 case R_MN10300_GOT16:
718 case R_MN10300_GOTOFF32:
719 case R_MN10300_GOTOFF24:
720 case R_MN10300_GOTOFF16:
721 case R_MN10300_GOTPC32:
722 case R_MN10300_GOTPC16:
723 elf_hash_table (info)->dynobj = dynobj = abfd;
724 if (! _bfd_mn10300_elf_create_got_section (dynobj, info))
725 goto fail;
726 break;
727
728 default:
729 break;
730 }
731 }
732
733 switch (r_type)
734 {
735 /* This relocation describes the C++ object vtable hierarchy.
736 Reconstruct it for later use during GC. */
737 case R_MN10300_GNU_VTINHERIT:
738 if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
739 goto fail;
740 break;
741
742 /* This relocation describes which C++ vtable entries are actually
743 used. Record for later use during GC. */
744 case R_MN10300_GNU_VTENTRY:
745 BFD_ASSERT (h != NULL);
746 if (h != NULL
747 && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
748 goto fail;
749 break;
750
751 case R_MN10300_GOT32:
752 case R_MN10300_GOT24:
753 case R_MN10300_GOT16:
754 /* This symbol requires a global offset table entry. */
755
756 if (sgot == NULL)
757 {
758 sgot = bfd_get_section_by_name (dynobj, ".got");
759 BFD_ASSERT (sgot != NULL);
760 }
761
762 if (srelgot == NULL
763 && (h != NULL || info->shared))
764 {
765 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
766 if (srelgot == NULL)
767 {
768 srelgot = bfd_make_section_with_flags (dynobj,
769 ".rela.got",
770 (SEC_ALLOC
771 | SEC_LOAD
772 | SEC_HAS_CONTENTS
773 | SEC_IN_MEMORY
774 | SEC_LINKER_CREATED
775 | SEC_READONLY));
776 if (srelgot == NULL
777 || ! bfd_set_section_alignment (dynobj, srelgot, 2))
778 goto fail;
779 }
780 }
781
782 if (h != NULL)
783 {
784 if (h->got.offset != (bfd_vma) -1)
785 /* We have already allocated space in the .got. */
786 break;
787
788 h->got.offset = sgot->size;
789
790 /* Make sure this symbol is output as a dynamic symbol. */
791 if (h->dynindx == -1)
792 {
793 if (! bfd_elf_link_record_dynamic_symbol (info, h))
794 goto fail;
795 }
796
797 srelgot->size += sizeof (Elf32_External_Rela);
798 }
799 else
800 {
801 /* This is a global offset table entry for a local
802 symbol. */
803 if (local_got_offsets == NULL)
804 {
805 size_t size;
806 unsigned int i;
807
808 size = symtab_hdr->sh_info * sizeof (bfd_vma);
809 local_got_offsets = bfd_alloc (abfd, size);
810
811 if (local_got_offsets == NULL)
812 goto fail;
813
814 elf_local_got_offsets (abfd) = local_got_offsets;
815
816 for (i = 0; i < symtab_hdr->sh_info; i++)
817 local_got_offsets[i] = (bfd_vma) -1;
818 }
819
820 if (local_got_offsets[r_symndx] != (bfd_vma) -1)
821 /* We have already allocated space in the .got. */
822 break;
823
824 local_got_offsets[r_symndx] = sgot->size;
825
826 if (info->shared)
827 /* If we are generating a shared object, we need to
828 output a R_MN10300_RELATIVE reloc so that the dynamic
829 linker can adjust this GOT entry. */
830 srelgot->size += sizeof (Elf32_External_Rela);
831 }
832
833 sgot->size += 4;
834 break;
835
836 case R_MN10300_PLT32:
837 case R_MN10300_PLT16:
838 /* This symbol requires a procedure linkage table entry. We
839 actually build the entry in adjust_dynamic_symbol,
840 because this might be a case of linking PIC code which is
841 never referenced by a dynamic object, in which case we
842 don't need to generate a procedure linkage table entry
843 after all. */
844
845 /* If this is a local symbol, we resolve it directly without
846 creating a procedure linkage table entry. */
847 if (h == NULL)
848 continue;
849
850 if (ELF_ST_VISIBILITY (h->other) == STV_INTERNAL
851 || ELF_ST_VISIBILITY (h->other) == STV_HIDDEN)
852 break;
853
854 h->needs_plt = 1;
855 break;
856
857 case R_MN10300_24:
858 case R_MN10300_16:
859 case R_MN10300_8:
860 case R_MN10300_PCREL32:
861 case R_MN10300_PCREL16:
862 case R_MN10300_PCREL8:
863 if (h != NULL)
864 h->non_got_ref = 1;
865 break;
866
867 case R_MN10300_SYM_DIFF:
868 sym_diff_reloc_seen = TRUE;
869 break;
870
871 case R_MN10300_32:
872 if (h != NULL)
873 h->non_got_ref = 1;
874
875 /* If we are creating a shared library, then we
876 need to copy the reloc into the shared library. */
877 if (info->shared
878 && (sec->flags & SEC_ALLOC) != 0
879 /* Do not generate a dynamic reloc for a
880 reloc associated with a SYM_DIFF operation. */
881 && ! sym_diff_reloc_seen)
882 {
883 asection * sym_section = NULL;
884
885 /* Find the section containing the
886 symbol involved in the relocation. */
887 if (h == NULL)
888 {
889 Elf_Internal_Sym * isym;
890
891 if (isymbuf == NULL)
892 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
893 symtab_hdr->sh_info, 0,
894 NULL, NULL, NULL);
895 if (isymbuf)
896 {
897 isym = isymbuf + r_symndx;
898 /* All we care about is whether this local symbol is absolute. */
899 if (isym->st_shndx == SHN_ABS)
900 sym_section = bfd_abs_section_ptr;
901 }
902 }
903 else
904 {
905 if (h->root.type == bfd_link_hash_defined
906 || h->root.type == bfd_link_hash_defweak)
907 sym_section = h->root.u.def.section;
908 }
909
910 /* If the symbol is absolute then the relocation can
911 be resolved during linking and there is no need for
912 a dynamic reloc. */
913 if (sym_section != bfd_abs_section_ptr)
914 {
915 /* When creating a shared object, we must copy these
916 reloc types into the output file. We create a reloc
917 section in dynobj and make room for this reloc. */
918 if (sreloc == NULL)
919 {
920 sreloc = _bfd_elf_make_dynamic_reloc_section
921 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
922 if (sreloc == NULL)
923 goto fail;
924 }
925
926 sreloc->size += sizeof (Elf32_External_Rela);
927 }
928 }
929
930 break;
931 }
932
933 if (ELF32_R_TYPE (rel->r_info) != R_MN10300_SYM_DIFF)
934 sym_diff_reloc_seen = FALSE;
935 }
936
937 result = TRUE;
938 fail:
939 if (isymbuf != NULL)
940 free (isymbuf);
941
942 return result;
943 }
944
945 /* Return the section that should be marked against GC for a given
946 relocation. */
947
948 static asection *
949 mn10300_elf_gc_mark_hook (asection *sec,
950 struct bfd_link_info *info,
951 Elf_Internal_Rela *rel,
952 struct elf_link_hash_entry *h,
953 Elf_Internal_Sym *sym)
954 {
955 if (h != NULL)
956 switch (ELF32_R_TYPE (rel->r_info))
957 {
958 case R_MN10300_GNU_VTINHERIT:
959 case R_MN10300_GNU_VTENTRY:
960 return NULL;
961 }
962
963 return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
964 }
965
966 /* Perform a relocation as part of a final link. */
967
968 static bfd_reloc_status_type
969 mn10300_elf_final_link_relocate (reloc_howto_type *howto,
970 bfd *input_bfd,
971 bfd *output_bfd ATTRIBUTE_UNUSED,
972 asection *input_section,
973 bfd_byte *contents,
974 bfd_vma offset,
975 bfd_vma value,
976 bfd_vma addend,
977 struct elf_link_hash_entry * h,
978 unsigned long symndx,
979 struct bfd_link_info *info,
980 asection *sym_sec ATTRIBUTE_UNUSED,
981 int is_local ATTRIBUTE_UNUSED)
982 {
983 static asection * sym_diff_section;
984 static bfd_vma sym_diff_value;
985 bfd_boolean is_sym_diff_reloc;
986 unsigned long r_type = howto->type;
987 bfd_byte * hit_data = contents + offset;
988 bfd * dynobj;
989 bfd_vma * local_got_offsets;
990 asection * sgot;
991 asection * splt;
992 asection * sreloc;
993
994 dynobj = elf_hash_table (info)->dynobj;
995 local_got_offsets = elf_local_got_offsets (input_bfd);
996
997 sgot = NULL;
998 splt = NULL;
999 sreloc = NULL;
1000
1001 switch (r_type)
1002 {
1003 case R_MN10300_24:
1004 case R_MN10300_16:
1005 case R_MN10300_8:
1006 case R_MN10300_PCREL8:
1007 case R_MN10300_PCREL16:
1008 case R_MN10300_PCREL32:
1009 case R_MN10300_GOTOFF32:
1010 case R_MN10300_GOTOFF24:
1011 case R_MN10300_GOTOFF16:
1012 if (info->shared
1013 && (input_section->flags & SEC_ALLOC) != 0
1014 && h != NULL
1015 && ! SYMBOL_REFERENCES_LOCAL (info, h))
1016 return bfd_reloc_dangerous;
1017 }
1018
1019 is_sym_diff_reloc = FALSE;
1020 if (sym_diff_section != NULL)
1021 {
1022 BFD_ASSERT (sym_diff_section == input_section);
1023
1024 switch (r_type)
1025 {
1026 case R_MN10300_32:
1027 case R_MN10300_24:
1028 case R_MN10300_16:
1029 case R_MN10300_8:
1030 value -= sym_diff_value;
1031 /* If we are computing a 32-bit value for the location lists
1032 and the result is 0 then we add one to the value. A zero
1033 value can result because of linker relaxation deleteing
1034 prologue instructions and using a value of 1 (for the begin
1035 and end offsets in the location list entry) results in a
1036 nul entry which does not prevent the following entries from
1037 being parsed. */
1038 if (r_type == R_MN10300_32
1039 && value == 0
1040 && strcmp (input_section->name, ".debug_loc") == 0)
1041 value = 1;
1042 sym_diff_section = NULL;
1043 is_sym_diff_reloc = TRUE;
1044 break;
1045
1046 default:
1047 sym_diff_section = NULL;
1048 break;
1049 }
1050 }
1051
1052 switch (r_type)
1053 {
1054 case R_MN10300_SYM_DIFF:
1055 BFD_ASSERT (addend == 0);
1056 /* Cache the input section and value.
1057 The offset is unreliable, since relaxation may
1058 have reduced the following reloc's offset. */
1059 sym_diff_section = input_section;
1060 sym_diff_value = value;
1061 return bfd_reloc_ok;
1062
1063 case R_MN10300_ALIGN:
1064 case R_MN10300_NONE:
1065 return bfd_reloc_ok;
1066
1067 case R_MN10300_32:
1068 if (info->shared
1069 /* Do not generate relocs when an R_MN10300_32 has been used
1070 with an R_MN10300_SYM_DIFF to compute a difference of two
1071 symbols. */
1072 && is_sym_diff_reloc == FALSE
1073 /* Also, do not generate a reloc when the symbol associated
1074 with the R_MN10300_32 reloc is absolute - there is no
1075 need for a run time computation in this case. */
1076 && sym_sec != bfd_abs_section_ptr
1077 /* If the section is not going to be allocated at load time
1078 then there is no need to generate relocs for it. */
1079 && (input_section->flags & SEC_ALLOC) != 0)
1080 {
1081 Elf_Internal_Rela outrel;
1082 bfd_boolean skip, relocate;
1083
1084 /* When generating a shared object, these relocations are
1085 copied into the output file to be resolved at run
1086 time. */
1087 if (sreloc == NULL)
1088 {
1089 sreloc = _bfd_elf_get_dynamic_reloc_section
1090 (input_bfd, input_section, /*rela?*/ TRUE);
1091 if (sreloc == NULL)
1092 return FALSE;
1093 }
1094
1095 skip = FALSE;
1096
1097 outrel.r_offset = _bfd_elf_section_offset (input_bfd, info,
1098 input_section, offset);
1099 if (outrel.r_offset == (bfd_vma) -1)
1100 skip = TRUE;
1101
1102 outrel.r_offset += (input_section->output_section->vma
1103 + input_section->output_offset);
1104
1105 if (skip)
1106 {
1107 memset (&outrel, 0, sizeof outrel);
1108 relocate = FALSE;
1109 }
1110 else
1111 {
1112 /* h->dynindx may be -1 if this symbol was marked to
1113 become local. */
1114 if (h == NULL
1115 || SYMBOL_REFERENCES_LOCAL (info, h))
1116 {
1117 relocate = TRUE;
1118 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1119 outrel.r_addend = value + addend;
1120 }
1121 else
1122 {
1123 BFD_ASSERT (h->dynindx != -1);
1124 relocate = FALSE;
1125 outrel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_32);
1126 outrel.r_addend = value + addend;
1127 }
1128 }
1129
1130 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1131 (bfd_byte *) (((Elf32_External_Rela *) sreloc->contents)
1132 + sreloc->reloc_count));
1133 ++sreloc->reloc_count;
1134
1135 /* If this reloc is against an external symbol, we do
1136 not want to fiddle with the addend. Otherwise, we
1137 need to include the symbol value so that it becomes
1138 an addend for the dynamic reloc. */
1139 if (! relocate)
1140 return bfd_reloc_ok;
1141 }
1142 value += addend;
1143 bfd_put_32 (input_bfd, value, hit_data);
1144 return bfd_reloc_ok;
1145
1146 case R_MN10300_24:
1147 value += addend;
1148
1149 if ((long) value > 0x7fffff || (long) value < -0x800000)
1150 return bfd_reloc_overflow;
1151
1152 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1153 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1154 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1155 return bfd_reloc_ok;
1156
1157 case R_MN10300_16:
1158 value += addend;
1159
1160 if ((long) value > 0x7fff || (long) value < -0x8000)
1161 return bfd_reloc_overflow;
1162
1163 bfd_put_16 (input_bfd, value, hit_data);
1164 return bfd_reloc_ok;
1165
1166 case R_MN10300_8:
1167 value += addend;
1168
1169 if ((long) value > 0x7f || (long) value < -0x80)
1170 return bfd_reloc_overflow;
1171
1172 bfd_put_8 (input_bfd, value, hit_data);
1173 return bfd_reloc_ok;
1174
1175 case R_MN10300_PCREL8:
1176 value -= (input_section->output_section->vma
1177 + input_section->output_offset);
1178 value -= offset;
1179 value += addend;
1180
1181 if ((long) value > 0x7f || (long) value < -0x80)
1182 return bfd_reloc_overflow;
1183
1184 bfd_put_8 (input_bfd, value, hit_data);
1185 return bfd_reloc_ok;
1186
1187 case R_MN10300_PCREL16:
1188 value -= (input_section->output_section->vma
1189 + input_section->output_offset);
1190 value -= offset;
1191 value += addend;
1192
1193 if ((long) value > 0x7fff || (long) value < -0x8000)
1194 return bfd_reloc_overflow;
1195
1196 bfd_put_16 (input_bfd, value, hit_data);
1197 return bfd_reloc_ok;
1198
1199 case R_MN10300_PCREL32:
1200 value -= (input_section->output_section->vma
1201 + input_section->output_offset);
1202 value -= offset;
1203 value += addend;
1204
1205 bfd_put_32 (input_bfd, value, hit_data);
1206 return bfd_reloc_ok;
1207
1208 case R_MN10300_GNU_VTINHERIT:
1209 case R_MN10300_GNU_VTENTRY:
1210 return bfd_reloc_ok;
1211
1212 case R_MN10300_GOTPC32:
1213 /* Use global offset table as symbol value. */
1214 value = bfd_get_section_by_name (dynobj,
1215 ".got")->output_section->vma;
1216 value -= (input_section->output_section->vma
1217 + input_section->output_offset);
1218 value -= offset;
1219 value += addend;
1220
1221 bfd_put_32 (input_bfd, value, hit_data);
1222 return bfd_reloc_ok;
1223
1224 case R_MN10300_GOTPC16:
1225 /* Use global offset table as symbol value. */
1226 value = bfd_get_section_by_name (dynobj,
1227 ".got")->output_section->vma;
1228 value -= (input_section->output_section->vma
1229 + input_section->output_offset);
1230 value -= offset;
1231 value += addend;
1232
1233 if ((long) value > 0x7fff || (long) value < -0x8000)
1234 return bfd_reloc_overflow;
1235
1236 bfd_put_16 (input_bfd, value, hit_data);
1237 return bfd_reloc_ok;
1238
1239 case R_MN10300_GOTOFF32:
1240 value -= bfd_get_section_by_name (dynobj,
1241 ".got")->output_section->vma;
1242 value += addend;
1243
1244 bfd_put_32 (input_bfd, value, hit_data);
1245 return bfd_reloc_ok;
1246
1247 case R_MN10300_GOTOFF24:
1248 value -= bfd_get_section_by_name (dynobj,
1249 ".got")->output_section->vma;
1250 value += addend;
1251
1252 if ((long) value > 0x7fffff || (long) value < -0x800000)
1253 return bfd_reloc_overflow;
1254
1255 bfd_put_8 (input_bfd, value, hit_data);
1256 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1257 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1258 return bfd_reloc_ok;
1259
1260 case R_MN10300_GOTOFF16:
1261 value -= bfd_get_section_by_name (dynobj,
1262 ".got")->output_section->vma;
1263 value += addend;
1264
1265 if ((long) value > 0x7fff || (long) value < -0x8000)
1266 return bfd_reloc_overflow;
1267
1268 bfd_put_16 (input_bfd, value, hit_data);
1269 return bfd_reloc_ok;
1270
1271 case R_MN10300_PLT32:
1272 if (h != NULL
1273 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1274 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1275 && h->plt.offset != (bfd_vma) -1)
1276 {
1277 asection * splt;
1278
1279 splt = bfd_get_section_by_name (dynobj, ".plt");
1280
1281 value = (splt->output_section->vma
1282 + splt->output_offset
1283 + h->plt.offset) - value;
1284 }
1285
1286 value -= (input_section->output_section->vma
1287 + input_section->output_offset);
1288 value -= offset;
1289 value += addend;
1290
1291 bfd_put_32 (input_bfd, value, hit_data);
1292 return bfd_reloc_ok;
1293
1294 case R_MN10300_PLT16:
1295 if (h != NULL
1296 && ELF_ST_VISIBILITY (h->other) != STV_INTERNAL
1297 && ELF_ST_VISIBILITY (h->other) != STV_HIDDEN
1298 && h->plt.offset != (bfd_vma) -1)
1299 {
1300 asection * splt;
1301
1302 splt = bfd_get_section_by_name (dynobj, ".plt");
1303
1304 value = (splt->output_section->vma
1305 + splt->output_offset
1306 + h->plt.offset) - value;
1307 }
1308
1309 value -= (input_section->output_section->vma
1310 + input_section->output_offset);
1311 value -= offset;
1312 value += addend;
1313
1314 if ((long) value > 0x7fff || (long) value < -0x8000)
1315 return bfd_reloc_overflow;
1316
1317 bfd_put_16 (input_bfd, value, hit_data);
1318 return bfd_reloc_ok;
1319
1320 case R_MN10300_GOT32:
1321 case R_MN10300_GOT24:
1322 case R_MN10300_GOT16:
1323 {
1324 asection * sgot;
1325
1326 sgot = bfd_get_section_by_name (dynobj, ".got");
1327
1328 if (h != NULL)
1329 {
1330 bfd_vma off;
1331
1332 off = h->got.offset;
1333 BFD_ASSERT (off != (bfd_vma) -1);
1334
1335 if (! elf_hash_table (info)->dynamic_sections_created
1336 || SYMBOL_REFERENCES_LOCAL (info, h))
1337 /* This is actually a static link, or it is a
1338 -Bsymbolic link and the symbol is defined
1339 locally, or the symbol was forced to be local
1340 because of a version file. We must initialize
1341 this entry in the global offset table.
1342
1343 When doing a dynamic link, we create a .rela.got
1344 relocation entry to initialize the value. This
1345 is done in the finish_dynamic_symbol routine. */
1346 bfd_put_32 (output_bfd, value,
1347 sgot->contents + off);
1348
1349 value = sgot->output_offset + off;
1350 }
1351 else
1352 {
1353 bfd_vma off;
1354
1355 off = elf_local_got_offsets (input_bfd)[symndx];
1356
1357 bfd_put_32 (output_bfd, value, sgot->contents + off);
1358
1359 if (info->shared)
1360 {
1361 asection * srelgot;
1362 Elf_Internal_Rela outrel;
1363
1364 srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1365 BFD_ASSERT (srelgot != NULL);
1366
1367 outrel.r_offset = (sgot->output_section->vma
1368 + sgot->output_offset
1369 + off);
1370 outrel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
1371 outrel.r_addend = value;
1372 bfd_elf32_swap_reloca_out (output_bfd, &outrel,
1373 (bfd_byte *) (((Elf32_External_Rela *)
1374 srelgot->contents)
1375 + srelgot->reloc_count));
1376 ++ srelgot->reloc_count;
1377 }
1378
1379 value = sgot->output_offset + off;
1380 }
1381 }
1382
1383 value += addend;
1384
1385 if (r_type == R_MN10300_GOT32)
1386 {
1387 bfd_put_32 (input_bfd, value, hit_data);
1388 return bfd_reloc_ok;
1389 }
1390 else if (r_type == R_MN10300_GOT24)
1391 {
1392 if ((long) value > 0x7fffff || (long) value < -0x800000)
1393 return bfd_reloc_overflow;
1394
1395 bfd_put_8 (input_bfd, value & 0xff, hit_data);
1396 bfd_put_8 (input_bfd, (value >> 8) & 0xff, hit_data + 1);
1397 bfd_put_8 (input_bfd, (value >> 16) & 0xff, hit_data + 2);
1398 return bfd_reloc_ok;
1399 }
1400 else if (r_type == R_MN10300_GOT16)
1401 {
1402 if ((long) value > 0x7fff || (long) value < -0x8000)
1403 return bfd_reloc_overflow;
1404
1405 bfd_put_16 (input_bfd, value, hit_data);
1406 return bfd_reloc_ok;
1407 }
1408 /* Fall through. */
1409
1410 default:
1411 return bfd_reloc_notsupported;
1412 }
1413 }
1414 \f
1415 /* Relocate an MN10300 ELF section. */
1416
1417 static bfd_boolean
1418 mn10300_elf_relocate_section (bfd *output_bfd,
1419 struct bfd_link_info *info,
1420 bfd *input_bfd,
1421 asection *input_section,
1422 bfd_byte *contents,
1423 Elf_Internal_Rela *relocs,
1424 Elf_Internal_Sym *local_syms,
1425 asection **local_sections)
1426 {
1427 Elf_Internal_Shdr *symtab_hdr;
1428 struct elf_link_hash_entry **sym_hashes;
1429 Elf_Internal_Rela *rel, *relend;
1430
1431 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1432 sym_hashes = elf_sym_hashes (input_bfd);
1433
1434 rel = relocs;
1435 relend = relocs + input_section->reloc_count;
1436 for (; rel < relend; rel++)
1437 {
1438 int r_type;
1439 reloc_howto_type *howto;
1440 unsigned long r_symndx;
1441 Elf_Internal_Sym *sym;
1442 asection *sec;
1443 struct elf32_mn10300_link_hash_entry *h;
1444 bfd_vma relocation;
1445 bfd_reloc_status_type r;
1446
1447 r_symndx = ELF32_R_SYM (rel->r_info);
1448 r_type = ELF32_R_TYPE (rel->r_info);
1449 howto = elf_mn10300_howto_table + r_type;
1450
1451 /* Just skip the vtable gc relocs. */
1452 if (r_type == R_MN10300_GNU_VTINHERIT
1453 || r_type == R_MN10300_GNU_VTENTRY)
1454 continue;
1455
1456 h = NULL;
1457 sym = NULL;
1458 sec = NULL;
1459 if (r_symndx < symtab_hdr->sh_info)
1460 {
1461 sym = local_syms + r_symndx;
1462 sec = local_sections[r_symndx];
1463 relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1464 }
1465 else
1466 {
1467 bfd_boolean unresolved_reloc;
1468 bfd_boolean warned;
1469 struct elf_link_hash_entry *hh;
1470
1471 RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1472 r_symndx, symtab_hdr, sym_hashes,
1473 hh, sec, relocation,
1474 unresolved_reloc, warned);
1475
1476 h = (struct elf32_mn10300_link_hash_entry *) hh;
1477
1478 if ((h->root.root.type == bfd_link_hash_defined
1479 || h->root.root.type == bfd_link_hash_defweak)
1480 && ( r_type == R_MN10300_GOTPC32
1481 || r_type == R_MN10300_GOTPC16
1482 || (( r_type == R_MN10300_PLT32
1483 || r_type == R_MN10300_PLT16)
1484 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
1485 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
1486 && h->root.plt.offset != (bfd_vma) -1)
1487 || (( r_type == R_MN10300_GOT32
1488 || r_type == R_MN10300_GOT24
1489 || r_type == R_MN10300_GOT16)
1490 && elf_hash_table (info)->dynamic_sections_created
1491 && !SYMBOL_REFERENCES_LOCAL (info, hh))
1492 || (r_type == R_MN10300_32
1493 /* _32 relocs in executables force _COPY relocs,
1494 such that the address of the symbol ends up
1495 being local. */
1496 && !info->executable
1497 && !SYMBOL_REFERENCES_LOCAL (info, hh)
1498 && ((input_section->flags & SEC_ALLOC) != 0
1499 /* DWARF will emit R_MN10300_32 relocations
1500 in its sections against symbols defined
1501 externally in shared libraries. We can't
1502 do anything with them here. */
1503 || ((input_section->flags & SEC_DEBUGGING) != 0
1504 && h->root.def_dynamic)))))
1505 /* In these cases, we don't need the relocation
1506 value. We check specially because in some
1507 obscure cases sec->output_section will be NULL. */
1508 relocation = 0;
1509
1510 else if (!info->relocatable && unresolved_reloc)
1511 (*_bfd_error_handler)
1512 (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
1513 input_bfd,
1514 input_section,
1515 (long) rel->r_offset,
1516 howto->name,
1517 h->root.root.root.string);
1518 }
1519
1520 if (sec != NULL && elf_discarded_section (sec))
1521 {
1522 /* For relocs against symbols from removed linkonce sections,
1523 or sections discarded by a linker script, we just want the
1524 section contents zeroed. Avoid any special processing. */
1525 _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1526 rel->r_info = 0;
1527 rel->r_addend = 0;
1528 continue;
1529 }
1530
1531 if (info->relocatable)
1532 continue;
1533
1534 r = mn10300_elf_final_link_relocate (howto, input_bfd, output_bfd,
1535 input_section,
1536 contents, rel->r_offset,
1537 relocation, rel->r_addend,
1538 (struct elf_link_hash_entry *) h,
1539 r_symndx,
1540 info, sec, h == NULL);
1541
1542 if (r != bfd_reloc_ok)
1543 {
1544 const char *name;
1545 const char *msg = NULL;
1546
1547 if (h != NULL)
1548 name = h->root.root.root.string;
1549 else
1550 {
1551 name = (bfd_elf_string_from_elf_section
1552 (input_bfd, symtab_hdr->sh_link, sym->st_name));
1553 if (name == NULL || *name == '\0')
1554 name = bfd_section_name (input_bfd, sec);
1555 }
1556
1557 switch (r)
1558 {
1559 case bfd_reloc_overflow:
1560 if (! ((*info->callbacks->reloc_overflow)
1561 (info, (h ? &h->root.root : NULL), name,
1562 howto->name, (bfd_vma) 0, input_bfd,
1563 input_section, rel->r_offset)))
1564 return FALSE;
1565 break;
1566
1567 case bfd_reloc_undefined:
1568 if (! ((*info->callbacks->undefined_symbol)
1569 (info, name, input_bfd, input_section,
1570 rel->r_offset, TRUE)))
1571 return FALSE;
1572 break;
1573
1574 case bfd_reloc_outofrange:
1575 msg = _("internal error: out of range error");
1576 goto common_error;
1577
1578 case bfd_reloc_notsupported:
1579 msg = _("internal error: unsupported relocation error");
1580 goto common_error;
1581
1582 case bfd_reloc_dangerous:
1583 if (r_type == R_MN10300_PCREL32)
1584 msg = _("error: inappropriate relocation type for shared"
1585 " library (did you forget -fpic?)");
1586 else
1587 msg = _("internal error: suspicious relocation type used"
1588 " in shared library");
1589 goto common_error;
1590
1591 default:
1592 msg = _("internal error: unknown error");
1593 /* Fall through. */
1594
1595 common_error:
1596 if (!((*info->callbacks->warning)
1597 (info, msg, name, input_bfd, input_section,
1598 rel->r_offset)))
1599 return FALSE;
1600 break;
1601 }
1602 }
1603 }
1604
1605 return TRUE;
1606 }
1607
1608 /* Finish initializing one hash table entry. */
1609
1610 static bfd_boolean
1611 elf32_mn10300_finish_hash_table_entry (struct bfd_hash_entry *gen_entry,
1612 void * in_args)
1613 {
1614 struct elf32_mn10300_link_hash_entry *entry;
1615 struct bfd_link_info *link_info = (struct bfd_link_info *) in_args;
1616 unsigned int byte_count = 0;
1617
1618 entry = (struct elf32_mn10300_link_hash_entry *) gen_entry;
1619
1620 if (entry->root.root.type == bfd_link_hash_warning)
1621 entry = (struct elf32_mn10300_link_hash_entry *) entry->root.root.u.i.link;
1622
1623 /* If we already know we want to convert "call" to "calls" for calls
1624 to this symbol, then return now. */
1625 if (entry->flags == MN10300_CONVERT_CALL_TO_CALLS)
1626 return TRUE;
1627
1628 /* If there are no named calls to this symbol, or there's nothing we
1629 can move from the function itself into the "call" instruction,
1630 then note that all "call" instructions should be converted into
1631 "calls" instructions and return. If a symbol is available for
1632 dynamic symbol resolution (overridable or overriding), avoid
1633 custom calling conventions. */
1634 if (entry->direct_calls == 0
1635 || (entry->stack_size == 0 && entry->movm_args == 0)
1636 || (elf_hash_table (link_info)->dynamic_sections_created
1637 && ELF_ST_VISIBILITY (entry->root.other) != STV_INTERNAL
1638 && ELF_ST_VISIBILITY (entry->root.other) != STV_HIDDEN))
1639 {
1640 /* Make a note that we should convert "call" instructions to "calls"
1641 instructions for calls to this symbol. */
1642 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1643 return TRUE;
1644 }
1645
1646 /* We may be able to move some instructions from the function itself into
1647 the "call" instruction. Count how many bytes we might be able to
1648 eliminate in the function itself. */
1649
1650 /* A movm instruction is two bytes. */
1651 if (entry->movm_args)
1652 byte_count += 2;
1653
1654 /* Count the insn to allocate stack space too. */
1655 if (entry->stack_size > 0)
1656 {
1657 if (entry->stack_size <= 128)
1658 byte_count += 3;
1659 else
1660 byte_count += 4;
1661 }
1662
1663 /* If using "call" will result in larger code, then turn all
1664 the associated "call" instructions into "calls" instructions. */
1665 if (byte_count < entry->direct_calls)
1666 entry->flags |= MN10300_CONVERT_CALL_TO_CALLS;
1667
1668 /* This routine never fails. */
1669 return TRUE;
1670 }
1671
1672 /* Used to count hash table entries. */
1673
1674 static bfd_boolean
1675 elf32_mn10300_count_hash_table_entries (struct bfd_hash_entry *gen_entry ATTRIBUTE_UNUSED,
1676 void * in_args)
1677 {
1678 int *count = (int *) in_args;
1679
1680 (*count) ++;
1681 return TRUE;
1682 }
1683
1684 /* Used to enumerate hash table entries into a linear array. */
1685
1686 static bfd_boolean
1687 elf32_mn10300_list_hash_table_entries (struct bfd_hash_entry *gen_entry,
1688 void * in_args)
1689 {
1690 struct bfd_hash_entry ***ptr = (struct bfd_hash_entry ***) in_args;
1691
1692 **ptr = gen_entry;
1693 (*ptr) ++;
1694 return TRUE;
1695 }
1696
1697 /* Used to sort the array created by the above. */
1698
1699 static int
1700 sort_by_value (const void *va, const void *vb)
1701 {
1702 struct elf32_mn10300_link_hash_entry *a
1703 = *(struct elf32_mn10300_link_hash_entry **) va;
1704 struct elf32_mn10300_link_hash_entry *b
1705 = *(struct elf32_mn10300_link_hash_entry **) vb;
1706
1707 return a->value - b->value;
1708 }
1709
1710 /* Compute the stack size and movm arguments for the function
1711 referred to by HASH at address ADDR in section with
1712 contents CONTENTS, store the information in the hash table. */
1713
1714 static void
1715 compute_function_info (bfd *abfd,
1716 struct elf32_mn10300_link_hash_entry *hash,
1717 bfd_vma addr,
1718 unsigned char *contents)
1719 {
1720 unsigned char byte1, byte2;
1721 /* We only care about a very small subset of the possible prologue
1722 sequences here. Basically we look for:
1723
1724 movm [d2,d3,a2,a3],sp (optional)
1725 add <size>,sp (optional, and only for sizes which fit in an unsigned
1726 8 bit number)
1727
1728 If we find anything else, we quit. */
1729
1730 /* Look for movm [regs],sp. */
1731 byte1 = bfd_get_8 (abfd, contents + addr);
1732 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1733
1734 if (byte1 == 0xcf)
1735 {
1736 hash->movm_args = byte2;
1737 addr += 2;
1738 byte1 = bfd_get_8 (abfd, contents + addr);
1739 byte2 = bfd_get_8 (abfd, contents + addr + 1);
1740 }
1741
1742 /* Now figure out how much stack space will be allocated by the movm
1743 instruction. We need this kept separate from the function's normal
1744 stack space. */
1745 if (hash->movm_args)
1746 {
1747 /* Space for d2. */
1748 if (hash->movm_args & 0x80)
1749 hash->movm_stack_size += 4;
1750
1751 /* Space for d3. */
1752 if (hash->movm_args & 0x40)
1753 hash->movm_stack_size += 4;
1754
1755 /* Space for a2. */
1756 if (hash->movm_args & 0x20)
1757 hash->movm_stack_size += 4;
1758
1759 /* Space for a3. */
1760 if (hash->movm_args & 0x10)
1761 hash->movm_stack_size += 4;
1762
1763 /* "other" space. d0, d1, a0, a1, mdr, lir, lar, 4 byte pad. */
1764 if (hash->movm_args & 0x08)
1765 hash->movm_stack_size += 8 * 4;
1766
1767 if (bfd_get_mach (abfd) == bfd_mach_am33
1768 || bfd_get_mach (abfd) == bfd_mach_am33_2)
1769 {
1770 /* "exother" space. e0, e1, mdrq, mcrh, mcrl, mcvf */
1771 if (hash->movm_args & 0x1)
1772 hash->movm_stack_size += 6 * 4;
1773
1774 /* exreg1 space. e4, e5, e6, e7 */
1775 if (hash->movm_args & 0x2)
1776 hash->movm_stack_size += 4 * 4;
1777
1778 /* exreg0 space. e2, e3 */
1779 if (hash->movm_args & 0x4)
1780 hash->movm_stack_size += 2 * 4;
1781 }
1782 }
1783
1784 /* Now look for the two stack adjustment variants. */
1785 if (byte1 == 0xf8 && byte2 == 0xfe)
1786 {
1787 int temp = bfd_get_8 (abfd, contents + addr + 2);
1788 temp = ((temp & 0xff) ^ (~0x7f)) + 0x80;
1789
1790 hash->stack_size = -temp;
1791 }
1792 else if (byte1 == 0xfa && byte2 == 0xfe)
1793 {
1794 int temp = bfd_get_16 (abfd, contents + addr + 2);
1795 temp = ((temp & 0xffff) ^ (~0x7fff)) + 0x8000;
1796 temp = -temp;
1797
1798 if (temp < 255)
1799 hash->stack_size = temp;
1800 }
1801
1802 /* If the total stack to be allocated by the call instruction is more
1803 than 255 bytes, then we can't remove the stack adjustment by using
1804 "call" (we might still be able to remove the "movm" instruction. */
1805 if (hash->stack_size + hash->movm_stack_size > 255)
1806 hash->stack_size = 0;
1807 }
1808
1809 /* Delete some bytes from a section while relaxing. */
1810
1811 static bfd_boolean
1812 mn10300_elf_relax_delete_bytes (bfd *abfd,
1813 asection *sec,
1814 bfd_vma addr,
1815 int count)
1816 {
1817 Elf_Internal_Shdr *symtab_hdr;
1818 unsigned int sec_shndx;
1819 bfd_byte *contents;
1820 Elf_Internal_Rela *irel, *irelend;
1821 Elf_Internal_Rela *irelalign;
1822 bfd_vma toaddr;
1823 Elf_Internal_Sym *isym, *isymend;
1824 struct elf_link_hash_entry **sym_hashes;
1825 struct elf_link_hash_entry **end_hashes;
1826 unsigned int symcount;
1827
1828 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1829
1830 contents = elf_section_data (sec)->this_hdr.contents;
1831
1832 irelalign = NULL;
1833 toaddr = sec->size;
1834
1835 irel = elf_section_data (sec)->relocs;
1836 irelend = irel + sec->reloc_count;
1837
1838 if (sec->reloc_count > 0)
1839 {
1840 /* If there is an align reloc at the end of the section ignore it.
1841 GAS creates these relocs for reasons of its own, and they just
1842 serve to keep the section artifically inflated. */
1843 if (ELF32_R_TYPE ((irelend - 1)->r_info) == (int) R_MN10300_ALIGN)
1844 --irelend;
1845
1846 /* The deletion must stop at the next ALIGN reloc for an aligment
1847 power larger than, or not a multiple of, the number of bytes we
1848 are deleting. */
1849 for (; irel < irelend; irel++)
1850 {
1851 int alignment = 1 << irel->r_addend;
1852
1853 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1854 && irel->r_offset > addr
1855 && irel->r_offset < toaddr
1856 && (count < alignment
1857 || alignment % count != 0))
1858 {
1859 irelalign = irel;
1860 toaddr = irel->r_offset;
1861 break;
1862 }
1863 }
1864 }
1865
1866 /* Actually delete the bytes. */
1867 memmove (contents + addr, contents + addr + count,
1868 (size_t) (toaddr - addr - count));
1869
1870 /* Adjust the section's size if we are shrinking it, or else
1871 pad the bytes between the end of the shrunken region and
1872 the start of the next region with NOP codes. */
1873 if (irelalign == NULL)
1874 {
1875 sec->size -= count;
1876 /* Include symbols at the end of the section, but
1877 not at the end of a sub-region of the section. */
1878 toaddr ++;
1879 }
1880 else
1881 {
1882 int i;
1883
1884 #define NOP_OPCODE 0xcb
1885
1886 for (i = 0; i < count; i ++)
1887 bfd_put_8 (abfd, (bfd_vma) NOP_OPCODE, contents + toaddr - count + i);
1888 }
1889
1890 /* Adjust all the relocs. */
1891 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
1892 {
1893 /* Get the new reloc address. */
1894 if ((irel->r_offset > addr
1895 && irel->r_offset < toaddr)
1896 || (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN
1897 && irel->r_offset == toaddr))
1898 irel->r_offset -= count;
1899 }
1900
1901 /* Adjust the local symbols in the section, reducing their value
1902 by the number of bytes deleted. Note - symbols within the deleted
1903 region are moved to the address of the start of the region, which
1904 actually means that they will address the byte beyond the end of
1905 the region once the deletion has been completed. */
1906 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1907 isym = (Elf_Internal_Sym *) symtab_hdr->contents;
1908 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1909 {
1910 if (isym->st_shndx == sec_shndx
1911 && isym->st_value > addr
1912 && isym->st_value < toaddr)
1913 {
1914 if (isym->st_value < addr + count)
1915 isym->st_value = addr;
1916 else
1917 isym->st_value -= count;
1918 }
1919 /* Adjust the function symbol's size as well. */
1920 else if (isym->st_shndx == sec_shndx
1921 && ELF_ST_TYPE (isym->st_info) == STT_FUNC
1922 && isym->st_value + isym->st_size > addr
1923 && isym->st_value + isym->st_size < toaddr)
1924 isym->st_size -= count;
1925 }
1926
1927 /* Now adjust the global symbols defined in this section. */
1928 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1929 - symtab_hdr->sh_info);
1930 sym_hashes = elf_sym_hashes (abfd);
1931 end_hashes = sym_hashes + symcount;
1932 for (; sym_hashes < end_hashes; sym_hashes++)
1933 {
1934 struct elf_link_hash_entry *sym_hash = *sym_hashes;
1935
1936 if ((sym_hash->root.type == bfd_link_hash_defined
1937 || sym_hash->root.type == bfd_link_hash_defweak)
1938 && sym_hash->root.u.def.section == sec
1939 && sym_hash->root.u.def.value > addr
1940 && sym_hash->root.u.def.value < toaddr)
1941 {
1942 if (sym_hash->root.u.def.value < addr + count)
1943 sym_hash->root.u.def.value = addr;
1944 else
1945 sym_hash->root.u.def.value -= count;
1946 }
1947 /* Adjust the function symbol's size as well. */
1948 else if (sym_hash->root.type == bfd_link_hash_defined
1949 && sym_hash->root.u.def.section == sec
1950 && sym_hash->type == STT_FUNC
1951 && sym_hash->root.u.def.value + sym_hash->size > addr
1952 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1953 sym_hash->size -= count;
1954 }
1955
1956 /* See if we can move the ALIGN reloc forward.
1957 We have adjusted r_offset for it already. */
1958 if (irelalign != NULL)
1959 {
1960 bfd_vma alignto, alignaddr;
1961
1962 if ((int) irelalign->r_addend > 0)
1963 {
1964 /* This is the old address. */
1965 alignto = BFD_ALIGN (toaddr, 1 << irelalign->r_addend);
1966 /* This is where the align points to now. */
1967 alignaddr = BFD_ALIGN (irelalign->r_offset,
1968 1 << irelalign->r_addend);
1969 if (alignaddr < alignto)
1970 /* Tail recursion. */
1971 return mn10300_elf_relax_delete_bytes (abfd, sec, alignaddr,
1972 (int) (alignto - alignaddr));
1973 }
1974 }
1975
1976 return TRUE;
1977 }
1978
1979 /* Return TRUE if a symbol exists at the given address, else return
1980 FALSE. */
1981
1982 static bfd_boolean
1983 mn10300_elf_symbol_address_p (bfd *abfd,
1984 asection *sec,
1985 Elf_Internal_Sym *isym,
1986 bfd_vma addr)
1987 {
1988 Elf_Internal_Shdr *symtab_hdr;
1989 unsigned int sec_shndx;
1990 Elf_Internal_Sym *isymend;
1991 struct elf_link_hash_entry **sym_hashes;
1992 struct elf_link_hash_entry **end_hashes;
1993 unsigned int symcount;
1994
1995 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1996
1997 /* Examine all the symbols. */
1998 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1999 for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
2000 if (isym->st_shndx == sec_shndx
2001 && isym->st_value == addr)
2002 return TRUE;
2003
2004 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2005 - symtab_hdr->sh_info);
2006 sym_hashes = elf_sym_hashes (abfd);
2007 end_hashes = sym_hashes + symcount;
2008 for (; sym_hashes < end_hashes; sym_hashes++)
2009 {
2010 struct elf_link_hash_entry *sym_hash = *sym_hashes;
2011
2012 if ((sym_hash->root.type == bfd_link_hash_defined
2013 || sym_hash->root.type == bfd_link_hash_defweak)
2014 && sym_hash->root.u.def.section == sec
2015 && sym_hash->root.u.def.value == addr)
2016 return TRUE;
2017 }
2018
2019 return FALSE;
2020 }
2021
2022 /* This function handles relaxing for the mn10300.
2023
2024 There are quite a few relaxing opportunities available on the mn10300:
2025
2026 * calls:32 -> calls:16 2 bytes
2027 * call:32 -> call:16 2 bytes
2028
2029 * call:32 -> calls:32 1 byte
2030 * call:16 -> calls:16 1 byte
2031 * These are done anytime using "calls" would result
2032 in smaller code, or when necessary to preserve the
2033 meaning of the program.
2034
2035 * call:32 varies
2036 * call:16
2037 * In some circumstances we can move instructions
2038 from a function prologue into a "call" instruction.
2039 This is only done if the resulting code is no larger
2040 than the original code.
2041
2042 * jmp:32 -> jmp:16 2 bytes
2043 * jmp:16 -> bra:8 1 byte
2044
2045 * If the previous instruction is a conditional branch
2046 around the jump/bra, we may be able to reverse its condition
2047 and change its target to the jump's target. The jump/bra
2048 can then be deleted. 2 bytes
2049
2050 * mov abs32 -> mov abs16 1 or 2 bytes
2051
2052 * Most instructions which accept imm32 can relax to imm16 1 or 2 bytes
2053 - Most instructions which accept imm16 can relax to imm8 1 or 2 bytes
2054
2055 * Most instructions which accept d32 can relax to d16 1 or 2 bytes
2056 - Most instructions which accept d16 can relax to d8 1 or 2 bytes
2057
2058 We don't handle imm16->imm8 or d16->d8 as they're very rare
2059 and somewhat more difficult to support. */
2060
2061 static bfd_boolean
2062 mn10300_elf_relax_section (bfd *abfd,
2063 asection *sec,
2064 struct bfd_link_info *link_info,
2065 bfd_boolean *again)
2066 {
2067 Elf_Internal_Shdr *symtab_hdr;
2068 Elf_Internal_Rela *internal_relocs = NULL;
2069 Elf_Internal_Rela *irel, *irelend;
2070 bfd_byte *contents = NULL;
2071 Elf_Internal_Sym *isymbuf = NULL;
2072 struct elf32_mn10300_link_hash_table *hash_table;
2073 asection *section = sec;
2074 bfd_vma align_gap_adjustment;
2075
2076 if (link_info->relocatable)
2077 (*link_info->callbacks->einfo)
2078 (_("%P%F: --relax and -r may not be used together\n"));
2079
2080 /* Assume nothing changes. */
2081 *again = FALSE;
2082
2083 /* We need a pointer to the mn10300 specific hash table. */
2084 hash_table = elf32_mn10300_hash_table (link_info);
2085
2086 /* Initialize fields in each hash table entry the first time through. */
2087 if ((hash_table->flags & MN10300_HASH_ENTRIES_INITIALIZED) == 0)
2088 {
2089 bfd *input_bfd;
2090
2091 /* Iterate over all the input bfds. */
2092 for (input_bfd = link_info->input_bfds;
2093 input_bfd != NULL;
2094 input_bfd = input_bfd->link_next)
2095 {
2096 /* We're going to need all the symbols for each bfd. */
2097 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2098 if (symtab_hdr->sh_info != 0)
2099 {
2100 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2101 if (isymbuf == NULL)
2102 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2103 symtab_hdr->sh_info, 0,
2104 NULL, NULL, NULL);
2105 if (isymbuf == NULL)
2106 goto error_return;
2107 }
2108
2109 /* Iterate over each section in this bfd. */
2110 for (section = input_bfd->sections;
2111 section != NULL;
2112 section = section->next)
2113 {
2114 struct elf32_mn10300_link_hash_entry *hash;
2115 Elf_Internal_Sym *sym;
2116 asection *sym_sec = NULL;
2117 const char *sym_name;
2118 char *new_name;
2119
2120 /* If there's nothing to do in this section, skip it. */
2121 if (! ((section->flags & SEC_RELOC) != 0
2122 && section->reloc_count != 0))
2123 continue;
2124 if ((section->flags & SEC_ALLOC) == 0)
2125 continue;
2126
2127 /* Get cached copy of section contents if it exists. */
2128 if (elf_section_data (section)->this_hdr.contents != NULL)
2129 contents = elf_section_data (section)->this_hdr.contents;
2130 else if (section->size != 0)
2131 {
2132 /* Go get them off disk. */
2133 if (!bfd_malloc_and_get_section (input_bfd, section,
2134 &contents))
2135 goto error_return;
2136 }
2137 else
2138 contents = NULL;
2139
2140 /* If there aren't any relocs, then there's nothing to do. */
2141 if ((section->flags & SEC_RELOC) != 0
2142 && section->reloc_count != 0)
2143 {
2144 /* Get a copy of the native relocations. */
2145 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2146 NULL, NULL,
2147 link_info->keep_memory);
2148 if (internal_relocs == NULL)
2149 goto error_return;
2150
2151 /* Now examine each relocation. */
2152 irel = internal_relocs;
2153 irelend = irel + section->reloc_count;
2154 for (; irel < irelend; irel++)
2155 {
2156 long r_type;
2157 unsigned long r_index;
2158 unsigned char code;
2159
2160 r_type = ELF32_R_TYPE (irel->r_info);
2161 r_index = ELF32_R_SYM (irel->r_info);
2162
2163 if (r_type < 0 || r_type >= (int) R_MN10300_MAX)
2164 goto error_return;
2165
2166 /* We need the name and hash table entry of the target
2167 symbol! */
2168 hash = NULL;
2169 sym = NULL;
2170 sym_sec = NULL;
2171
2172 if (r_index < symtab_hdr->sh_info)
2173 {
2174 /* A local symbol. */
2175 Elf_Internal_Sym *isym;
2176 struct elf_link_hash_table *elftab;
2177 bfd_size_type amt;
2178
2179 isym = isymbuf + r_index;
2180 if (isym->st_shndx == SHN_UNDEF)
2181 sym_sec = bfd_und_section_ptr;
2182 else if (isym->st_shndx == SHN_ABS)
2183 sym_sec = bfd_abs_section_ptr;
2184 else if (isym->st_shndx == SHN_COMMON)
2185 sym_sec = bfd_com_section_ptr;
2186 else
2187 sym_sec
2188 = bfd_section_from_elf_index (input_bfd,
2189 isym->st_shndx);
2190
2191 sym_name
2192 = bfd_elf_string_from_elf_section (input_bfd,
2193 (symtab_hdr
2194 ->sh_link),
2195 isym->st_name);
2196
2197 /* If it isn't a function, then we don't care
2198 about it. */
2199 if (ELF_ST_TYPE (isym->st_info) != STT_FUNC)
2200 continue;
2201
2202 /* Tack on an ID so we can uniquely identify this
2203 local symbol in the global hash table. */
2204 amt = strlen (sym_name) + 10;
2205 new_name = bfd_malloc (amt);
2206 if (new_name == NULL)
2207 goto error_return;
2208
2209 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2210 sym_name = new_name;
2211
2212 elftab = &hash_table->static_hash_table->root;
2213 hash = ((struct elf32_mn10300_link_hash_entry *)
2214 elf_link_hash_lookup (elftab, sym_name,
2215 TRUE, TRUE, FALSE));
2216 free (new_name);
2217 }
2218 else
2219 {
2220 r_index -= symtab_hdr->sh_info;
2221 hash = (struct elf32_mn10300_link_hash_entry *)
2222 elf_sym_hashes (input_bfd)[r_index];
2223 }
2224
2225 sym_name = hash->root.root.root.string;
2226 if ((section->flags & SEC_CODE) != 0)
2227 {
2228 /* If this is not a "call" instruction, then we
2229 should convert "call" instructions to "calls"
2230 instructions. */
2231 code = bfd_get_8 (input_bfd,
2232 contents + irel->r_offset - 1);
2233 if (code != 0xdd && code != 0xcd)
2234 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2235 }
2236
2237 /* If this is a jump/call, then bump the
2238 direct_calls counter. Else force "call" to
2239 "calls" conversions. */
2240 if (r_type == R_MN10300_PCREL32
2241 || r_type == R_MN10300_PLT32
2242 || r_type == R_MN10300_PLT16
2243 || r_type == R_MN10300_PCREL16)
2244 hash->direct_calls++;
2245 else
2246 hash->flags |= MN10300_CONVERT_CALL_TO_CALLS;
2247 }
2248 }
2249
2250 /* Now look at the actual contents to get the stack size,
2251 and a list of what registers were saved in the prologue
2252 (ie movm_args). */
2253 if ((section->flags & SEC_CODE) != 0)
2254 {
2255 Elf_Internal_Sym *isym, *isymend;
2256 unsigned int sec_shndx;
2257 struct elf_link_hash_entry **hashes;
2258 struct elf_link_hash_entry **end_hashes;
2259 unsigned int symcount;
2260
2261 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2262 section);
2263
2264 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2265 - symtab_hdr->sh_info);
2266 hashes = elf_sym_hashes (input_bfd);
2267 end_hashes = hashes + symcount;
2268
2269 /* Look at each function defined in this section and
2270 update info for that function. */
2271 isymend = isymbuf + symtab_hdr->sh_info;
2272 for (isym = isymbuf; isym < isymend; isym++)
2273 {
2274 if (isym->st_shndx == sec_shndx
2275 && ELF_ST_TYPE (isym->st_info) == STT_FUNC)
2276 {
2277 struct elf_link_hash_table *elftab;
2278 bfd_size_type amt;
2279 struct elf_link_hash_entry **lhashes = hashes;
2280
2281 /* Skip a local symbol if it aliases a
2282 global one. */
2283 for (; lhashes < end_hashes; lhashes++)
2284 {
2285 hash = (struct elf32_mn10300_link_hash_entry *) *lhashes;
2286 if ((hash->root.root.type == bfd_link_hash_defined
2287 || hash->root.root.type == bfd_link_hash_defweak)
2288 && hash->root.root.u.def.section == section
2289 && hash->root.type == STT_FUNC
2290 && hash->root.root.u.def.value == isym->st_value)
2291 break;
2292 }
2293 if (lhashes != end_hashes)
2294 continue;
2295
2296 if (isym->st_shndx == SHN_UNDEF)
2297 sym_sec = bfd_und_section_ptr;
2298 else if (isym->st_shndx == SHN_ABS)
2299 sym_sec = bfd_abs_section_ptr;
2300 else if (isym->st_shndx == SHN_COMMON)
2301 sym_sec = bfd_com_section_ptr;
2302 else
2303 sym_sec
2304 = bfd_section_from_elf_index (input_bfd,
2305 isym->st_shndx);
2306
2307 sym_name = (bfd_elf_string_from_elf_section
2308 (input_bfd, symtab_hdr->sh_link,
2309 isym->st_name));
2310
2311 /* Tack on an ID so we can uniquely identify this
2312 local symbol in the global hash table. */
2313 amt = strlen (sym_name) + 10;
2314 new_name = bfd_malloc (amt);
2315 if (new_name == NULL)
2316 goto error_return;
2317
2318 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2319 sym_name = new_name;
2320
2321 elftab = &hash_table->static_hash_table->root;
2322 hash = ((struct elf32_mn10300_link_hash_entry *)
2323 elf_link_hash_lookup (elftab, sym_name,
2324 TRUE, TRUE, FALSE));
2325 free (new_name);
2326 compute_function_info (input_bfd, hash,
2327 isym->st_value, contents);
2328 hash->value = isym->st_value;
2329 }
2330 }
2331
2332 for (; hashes < end_hashes; hashes++)
2333 {
2334 hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2335 if ((hash->root.root.type == bfd_link_hash_defined
2336 || hash->root.root.type == bfd_link_hash_defweak)
2337 && hash->root.root.u.def.section == section
2338 && hash->root.type == STT_FUNC)
2339 compute_function_info (input_bfd, hash,
2340 (hash)->root.root.u.def.value,
2341 contents);
2342 }
2343 }
2344
2345 /* Cache or free any memory we allocated for the relocs. */
2346 if (internal_relocs != NULL
2347 && elf_section_data (section)->relocs != internal_relocs)
2348 free (internal_relocs);
2349 internal_relocs = NULL;
2350
2351 /* Cache or free any memory we allocated for the contents. */
2352 if (contents != NULL
2353 && elf_section_data (section)->this_hdr.contents != contents)
2354 {
2355 if (! link_info->keep_memory)
2356 free (contents);
2357 else
2358 {
2359 /* Cache the section contents for elf_link_input_bfd. */
2360 elf_section_data (section)->this_hdr.contents = contents;
2361 }
2362 }
2363 contents = NULL;
2364 }
2365
2366 /* Cache or free any memory we allocated for the symbols. */
2367 if (isymbuf != NULL
2368 && symtab_hdr->contents != (unsigned char *) isymbuf)
2369 {
2370 if (! link_info->keep_memory)
2371 free (isymbuf);
2372 else
2373 {
2374 /* Cache the symbols for elf_link_input_bfd. */
2375 symtab_hdr->contents = (unsigned char *) isymbuf;
2376 }
2377 }
2378 isymbuf = NULL;
2379 }
2380
2381 /* Now iterate on each symbol in the hash table and perform
2382 the final initialization steps on each. */
2383 elf32_mn10300_link_hash_traverse (hash_table,
2384 elf32_mn10300_finish_hash_table_entry,
2385 link_info);
2386 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2387 elf32_mn10300_finish_hash_table_entry,
2388 link_info);
2389
2390 {
2391 /* This section of code collects all our local symbols, sorts
2392 them by value, and looks for multiple symbols referring to
2393 the same address. For those symbols, the flags are merged.
2394 At this point, the only flag that can be set is
2395 MN10300_CONVERT_CALL_TO_CALLS, so we simply OR the flags
2396 together. */
2397 int static_count = 0, i;
2398 struct elf32_mn10300_link_hash_entry **entries;
2399 struct elf32_mn10300_link_hash_entry **ptr;
2400
2401 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2402 elf32_mn10300_count_hash_table_entries,
2403 &static_count);
2404
2405 entries = bfd_malloc (static_count * sizeof (* ptr));
2406
2407 ptr = entries;
2408 elf32_mn10300_link_hash_traverse (hash_table->static_hash_table,
2409 elf32_mn10300_list_hash_table_entries,
2410 & ptr);
2411
2412 qsort (entries, static_count, sizeof (entries[0]), sort_by_value);
2413
2414 for (i = 0; i < static_count - 1; i++)
2415 if (entries[i]->value && entries[i]->value == entries[i+1]->value)
2416 {
2417 int v = entries[i]->flags;
2418 int j;
2419
2420 for (j = i + 1; j < static_count && entries[j]->value == entries[i]->value; j++)
2421 v |= entries[j]->flags;
2422
2423 for (j = i; j < static_count && entries[j]->value == entries[i]->value; j++)
2424 entries[j]->flags = v;
2425
2426 i = j - 1;
2427 }
2428 }
2429
2430 /* All entries in the hash table are fully initialized. */
2431 hash_table->flags |= MN10300_HASH_ENTRIES_INITIALIZED;
2432
2433 /* Now that everything has been initialized, go through each
2434 code section and delete any prologue insns which will be
2435 redundant because their operations will be performed by
2436 a "call" instruction. */
2437 for (input_bfd = link_info->input_bfds;
2438 input_bfd != NULL;
2439 input_bfd = input_bfd->link_next)
2440 {
2441 /* We're going to need all the local symbols for each bfd. */
2442 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2443 if (symtab_hdr->sh_info != 0)
2444 {
2445 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2446 if (isymbuf == NULL)
2447 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
2448 symtab_hdr->sh_info, 0,
2449 NULL, NULL, NULL);
2450 if (isymbuf == NULL)
2451 goto error_return;
2452 }
2453
2454 /* Walk over each section in this bfd. */
2455 for (section = input_bfd->sections;
2456 section != NULL;
2457 section = section->next)
2458 {
2459 unsigned int sec_shndx;
2460 Elf_Internal_Sym *isym, *isymend;
2461 struct elf_link_hash_entry **hashes;
2462 struct elf_link_hash_entry **end_hashes;
2463 unsigned int symcount;
2464
2465 /* Skip non-code sections and empty sections. */
2466 if ((section->flags & SEC_CODE) == 0 || section->size == 0)
2467 continue;
2468
2469 if (section->reloc_count != 0)
2470 {
2471 /* Get a copy of the native relocations. */
2472 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, section,
2473 NULL, NULL,
2474 link_info->keep_memory);
2475 if (internal_relocs == NULL)
2476 goto error_return;
2477 }
2478
2479 /* Get cached copy of section contents if it exists. */
2480 if (elf_section_data (section)->this_hdr.contents != NULL)
2481 contents = elf_section_data (section)->this_hdr.contents;
2482 else
2483 {
2484 /* Go get them off disk. */
2485 if (!bfd_malloc_and_get_section (input_bfd, section,
2486 &contents))
2487 goto error_return;
2488 }
2489
2490 sec_shndx = _bfd_elf_section_from_bfd_section (input_bfd,
2491 section);
2492
2493 /* Now look for any function in this section which needs
2494 insns deleted from its prologue. */
2495 isymend = isymbuf + symtab_hdr->sh_info;
2496 for (isym = isymbuf; isym < isymend; isym++)
2497 {
2498 struct elf32_mn10300_link_hash_entry *sym_hash;
2499 asection *sym_sec = NULL;
2500 const char *sym_name;
2501 char *new_name;
2502 struct elf_link_hash_table *elftab;
2503 bfd_size_type amt;
2504
2505 if (isym->st_shndx != sec_shndx)
2506 continue;
2507
2508 if (isym->st_shndx == SHN_UNDEF)
2509 sym_sec = bfd_und_section_ptr;
2510 else if (isym->st_shndx == SHN_ABS)
2511 sym_sec = bfd_abs_section_ptr;
2512 else if (isym->st_shndx == SHN_COMMON)
2513 sym_sec = bfd_com_section_ptr;
2514 else
2515 sym_sec
2516 = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
2517
2518 sym_name
2519 = bfd_elf_string_from_elf_section (input_bfd,
2520 symtab_hdr->sh_link,
2521 isym->st_name);
2522
2523 /* Tack on an ID so we can uniquely identify this
2524 local symbol in the global hash table. */
2525 amt = strlen (sym_name) + 10;
2526 new_name = bfd_malloc (amt);
2527 if (new_name == NULL)
2528 goto error_return;
2529 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2530 sym_name = new_name;
2531
2532 elftab = & hash_table->static_hash_table->root;
2533 sym_hash = (struct elf32_mn10300_link_hash_entry *)
2534 elf_link_hash_lookup (elftab, sym_name,
2535 FALSE, FALSE, FALSE);
2536
2537 free (new_name);
2538 if (sym_hash == NULL)
2539 continue;
2540
2541 if (! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2542 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2543 {
2544 int bytes = 0;
2545
2546 /* Note that we've changed things. */
2547 elf_section_data (section)->relocs = internal_relocs;
2548 elf_section_data (section)->this_hdr.contents = contents;
2549 symtab_hdr->contents = (unsigned char *) isymbuf;
2550
2551 /* Count how many bytes we're going to delete. */
2552 if (sym_hash->movm_args)
2553 bytes += 2;
2554
2555 if (sym_hash->stack_size > 0)
2556 {
2557 if (sym_hash->stack_size <= 128)
2558 bytes += 3;
2559 else
2560 bytes += 4;
2561 }
2562
2563 /* Note that we've deleted prologue bytes for this
2564 function. */
2565 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2566
2567 /* Actually delete the bytes. */
2568 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2569 section,
2570 isym->st_value,
2571 bytes))
2572 goto error_return;
2573
2574 /* Something changed. Not strictly necessary, but
2575 may lead to more relaxing opportunities. */
2576 *again = TRUE;
2577 }
2578 }
2579
2580 /* Look for any global functions in this section which
2581 need insns deleted from their prologues. */
2582 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2583 - symtab_hdr->sh_info);
2584 hashes = elf_sym_hashes (input_bfd);
2585 end_hashes = hashes + symcount;
2586 for (; hashes < end_hashes; hashes++)
2587 {
2588 struct elf32_mn10300_link_hash_entry *sym_hash;
2589
2590 sym_hash = (struct elf32_mn10300_link_hash_entry *) *hashes;
2591 if ((sym_hash->root.root.type == bfd_link_hash_defined
2592 || sym_hash->root.root.type == bfd_link_hash_defweak)
2593 && sym_hash->root.root.u.def.section == section
2594 && ! (sym_hash->flags & MN10300_CONVERT_CALL_TO_CALLS)
2595 && ! (sym_hash->flags & MN10300_DELETED_PROLOGUE_BYTES))
2596 {
2597 int bytes = 0;
2598 bfd_vma symval;
2599
2600 /* Note that we've changed things. */
2601 elf_section_data (section)->relocs = internal_relocs;
2602 elf_section_data (section)->this_hdr.contents = contents;
2603 symtab_hdr->contents = (unsigned char *) isymbuf;
2604
2605 /* Count how many bytes we're going to delete. */
2606 if (sym_hash->movm_args)
2607 bytes += 2;
2608
2609 if (sym_hash->stack_size > 0)
2610 {
2611 if (sym_hash->stack_size <= 128)
2612 bytes += 3;
2613 else
2614 bytes += 4;
2615 }
2616
2617 /* Note that we've deleted prologue bytes for this
2618 function. */
2619 sym_hash->flags |= MN10300_DELETED_PROLOGUE_BYTES;
2620
2621 /* Actually delete the bytes. */
2622 symval = sym_hash->root.root.u.def.value;
2623 if (!mn10300_elf_relax_delete_bytes (input_bfd,
2624 section,
2625 symval,
2626 bytes))
2627 goto error_return;
2628
2629 /* Something changed. Not strictly necessary, but
2630 may lead to more relaxing opportunities. */
2631 *again = TRUE;
2632 }
2633 }
2634
2635 /* Cache or free any memory we allocated for the relocs. */
2636 if (internal_relocs != NULL
2637 && elf_section_data (section)->relocs != internal_relocs)
2638 free (internal_relocs);
2639 internal_relocs = NULL;
2640
2641 /* Cache or free any memory we allocated for the contents. */
2642 if (contents != NULL
2643 && elf_section_data (section)->this_hdr.contents != contents)
2644 {
2645 if (! link_info->keep_memory)
2646 free (contents);
2647 else
2648 /* Cache the section contents for elf_link_input_bfd. */
2649 elf_section_data (section)->this_hdr.contents = contents;
2650 }
2651 contents = NULL;
2652 }
2653
2654 /* Cache or free any memory we allocated for the symbols. */
2655 if (isymbuf != NULL
2656 && symtab_hdr->contents != (unsigned char *) isymbuf)
2657 {
2658 if (! link_info->keep_memory)
2659 free (isymbuf);
2660 else
2661 /* Cache the symbols for elf_link_input_bfd. */
2662 symtab_hdr->contents = (unsigned char *) isymbuf;
2663 }
2664 isymbuf = NULL;
2665 }
2666 }
2667
2668 /* (Re)initialize for the basic instruction shortening/relaxing pass. */
2669 contents = NULL;
2670 internal_relocs = NULL;
2671 isymbuf = NULL;
2672 /* For error_return. */
2673 section = sec;
2674
2675 /* We don't have to do anything for a relocatable link, if
2676 this section does not have relocs, or if this is not a
2677 code section. */
2678 if (link_info->relocatable
2679 || (sec->flags & SEC_RELOC) == 0
2680 || sec->reloc_count == 0
2681 || (sec->flags & SEC_CODE) == 0)
2682 return TRUE;
2683
2684 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2685
2686 /* Get a copy of the native relocations. */
2687 internal_relocs = _bfd_elf_link_read_relocs (abfd, sec, NULL, NULL,
2688 link_info->keep_memory);
2689 if (internal_relocs == NULL)
2690 goto error_return;
2691
2692 /* Scan for worst case alignment gap changes. Note that this logic
2693 is not ideal; what we should do is run this scan for every
2694 opcode/address range and adjust accordingly, but that's
2695 expensive. Worst case is that for an alignment of N bytes, we
2696 move by 2*N-N-1 bytes, assuming we have aligns of 1, 2, 4, 8, etc
2697 all before it. Plus, this still doesn't cover cross-section
2698 jumps with section alignment. */
2699 irelend = internal_relocs + sec->reloc_count;
2700 align_gap_adjustment = 0;
2701 for (irel = internal_relocs; irel < irelend; irel++)
2702 {
2703 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_ALIGN)
2704 {
2705 bfd_vma adj = 1 << irel->r_addend;
2706 bfd_vma aend = irel->r_offset;
2707
2708 aend = BFD_ALIGN (aend, 1 << irel->r_addend);
2709 adj = 2 * adj - adj - 1;
2710
2711 /* Record the biggest adjustmnet. Skip any alignment at the
2712 end of our section. */
2713 if (align_gap_adjustment < adj
2714 && aend < sec->output_section->vma + sec->output_offset + sec->size)
2715 align_gap_adjustment = adj;
2716 }
2717 }
2718
2719 /* Walk through them looking for relaxing opportunities. */
2720 irelend = internal_relocs + sec->reloc_count;
2721 for (irel = internal_relocs; irel < irelend; irel++)
2722 {
2723 bfd_vma symval;
2724 bfd_signed_vma jump_offset;
2725 asection *sym_sec = NULL;
2726 struct elf32_mn10300_link_hash_entry *h = NULL;
2727
2728 /* If this isn't something that can be relaxed, then ignore
2729 this reloc. */
2730 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_NONE
2731 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_8
2732 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_MAX)
2733 continue;
2734
2735 /* Get the section contents if we haven't done so already. */
2736 if (contents == NULL)
2737 {
2738 /* Get cached copy if it exists. */
2739 if (elf_section_data (sec)->this_hdr.contents != NULL)
2740 contents = elf_section_data (sec)->this_hdr.contents;
2741 else
2742 {
2743 /* Go get them off disk. */
2744 if (!bfd_malloc_and_get_section (abfd, sec, &contents))
2745 goto error_return;
2746 }
2747 }
2748
2749 /* Read this BFD's symbols if we haven't done so already. */
2750 if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2751 {
2752 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2753 if (isymbuf == NULL)
2754 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2755 symtab_hdr->sh_info, 0,
2756 NULL, NULL, NULL);
2757 if (isymbuf == NULL)
2758 goto error_return;
2759 }
2760
2761 /* Get the value of the symbol referred to by the reloc. */
2762 if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2763 {
2764 Elf_Internal_Sym *isym;
2765 const char *sym_name;
2766 char *new_name;
2767
2768 /* A local symbol. */
2769 isym = isymbuf + ELF32_R_SYM (irel->r_info);
2770 if (isym->st_shndx == SHN_UNDEF)
2771 sym_sec = bfd_und_section_ptr;
2772 else if (isym->st_shndx == SHN_ABS)
2773 sym_sec = bfd_abs_section_ptr;
2774 else if (isym->st_shndx == SHN_COMMON)
2775 sym_sec = bfd_com_section_ptr;
2776 else
2777 sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2778
2779 sym_name = bfd_elf_string_from_elf_section (abfd,
2780 symtab_hdr->sh_link,
2781 isym->st_name);
2782
2783 if ((sym_sec->flags & SEC_MERGE)
2784 && ELF_ST_TYPE (isym->st_info) == STT_SECTION
2785 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2786 {
2787 symval = isym->st_value + irel->r_addend;
2788 symval = _bfd_merged_section_offset (abfd, & sym_sec,
2789 elf_section_data (sym_sec)->sec_info,
2790 symval);
2791 symval += sym_sec->output_section->vma + sym_sec->output_offset - irel->r_addend;
2792 }
2793 else
2794 symval = (isym->st_value
2795 + sym_sec->output_section->vma
2796 + sym_sec->output_offset);
2797
2798 /* Tack on an ID so we can uniquely identify this
2799 local symbol in the global hash table. */
2800 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2801 if (new_name == NULL)
2802 goto error_return;
2803 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2804 sym_name = new_name;
2805
2806 h = (struct elf32_mn10300_link_hash_entry *)
2807 elf_link_hash_lookup (&hash_table->static_hash_table->root,
2808 sym_name, FALSE, FALSE, FALSE);
2809 free (new_name);
2810 }
2811 else
2812 {
2813 unsigned long indx;
2814
2815 /* An external symbol. */
2816 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2817 h = (struct elf32_mn10300_link_hash_entry *)
2818 (elf_sym_hashes (abfd)[indx]);
2819 BFD_ASSERT (h != NULL);
2820 if (h->root.root.type != bfd_link_hash_defined
2821 && h->root.root.type != bfd_link_hash_defweak)
2822 /* This appears to be a reference to an undefined
2823 symbol. Just ignore it--it will be caught by the
2824 regular reloc processing. */
2825 continue;
2826
2827 /* Check for a reference to a discarded symbol and ignore it. */
2828 if (h->root.root.u.def.section->output_section == NULL)
2829 continue;
2830
2831 sym_sec = h->root.root.u.def.section->output_section;
2832
2833 symval = (h->root.root.u.def.value
2834 + h->root.root.u.def.section->output_section->vma
2835 + h->root.root.u.def.section->output_offset);
2836 }
2837
2838 /* For simplicity of coding, we are going to modify the section
2839 contents, the section relocs, and the BFD symbol table. We
2840 must tell the rest of the code not to free up this
2841 information. It would be possible to instead create a table
2842 of changes which have to be made, as is done in coff-mips.c;
2843 that would be more work, but would require less memory when
2844 the linker is run. */
2845
2846 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2847 branch/call, also deal with "call" -> "calls" conversions and
2848 insertion of prologue data into "call" instructions. */
2849 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2850 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2851 {
2852 bfd_vma value = symval;
2853
2854 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2855 && h != NULL
2856 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2857 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2858 && h->root.plt.offset != (bfd_vma) -1)
2859 {
2860 asection * splt;
2861
2862 splt = bfd_get_section_by_name (elf_hash_table (link_info)
2863 ->dynobj, ".plt");
2864
2865 value = ((splt->output_section->vma
2866 + splt->output_offset
2867 + h->root.plt.offset)
2868 - (sec->output_section->vma
2869 + sec->output_offset
2870 + irel->r_offset));
2871 }
2872
2873 /* If we've got a "call" instruction that needs to be turned
2874 into a "calls" instruction, do so now. It saves a byte. */
2875 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2876 {
2877 unsigned char code;
2878
2879 /* Get the opcode. */
2880 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2881
2882 /* Make sure we're working with a "call" instruction! */
2883 if (code == 0xdd)
2884 {
2885 /* Note that we've changed the relocs, section contents,
2886 etc. */
2887 elf_section_data (sec)->relocs = internal_relocs;
2888 elf_section_data (sec)->this_hdr.contents = contents;
2889 symtab_hdr->contents = (unsigned char *) isymbuf;
2890
2891 /* Fix the opcode. */
2892 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2893 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2894
2895 /* Fix irel->r_offset and irel->r_addend. */
2896 irel->r_offset += 1;
2897 irel->r_addend += 1;
2898
2899 /* Delete one byte of data. */
2900 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2901 irel->r_offset + 3, 1))
2902 goto error_return;
2903
2904 /* That will change things, so, we should relax again.
2905 Note that this is not required, and it may be slow. */
2906 *again = TRUE;
2907 }
2908 }
2909 else if (h)
2910 {
2911 /* We've got a "call" instruction which needs some data
2912 from target function filled in. */
2913 unsigned char code;
2914
2915 /* Get the opcode. */
2916 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2917
2918 /* Insert data from the target function into the "call"
2919 instruction if needed. */
2920 if (code == 0xdd)
2921 {
2922 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2923 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2924 contents + irel->r_offset + 5);
2925 }
2926 }
2927
2928 /* Deal with pc-relative gunk. */
2929 value -= (sec->output_section->vma + sec->output_offset);
2930 value -= irel->r_offset;
2931 value += irel->r_addend;
2932
2933 /* See if the value will fit in 16 bits, note the high value is
2934 0x7fff + 2 as the target will be two bytes closer if we are
2935 able to relax, if it's in the same section. */
2936 if (sec->output_section == sym_sec->output_section)
2937 jump_offset = 0x8001;
2938 else
2939 jump_offset = 0x7fff;
2940
2941 /* Account for jumps across alignment boundaries using
2942 align_gap_adjustment. */
2943 if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
2944 && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
2945 {
2946 unsigned char code;
2947
2948 /* Get the opcode. */
2949 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2950
2951 if (code != 0xdc && code != 0xdd && code != 0xff)
2952 continue;
2953
2954 /* Note that we've changed the relocs, section contents, etc. */
2955 elf_section_data (sec)->relocs = internal_relocs;
2956 elf_section_data (sec)->this_hdr.contents = contents;
2957 symtab_hdr->contents = (unsigned char *) isymbuf;
2958
2959 /* Fix the opcode. */
2960 if (code == 0xdc)
2961 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2962 else if (code == 0xdd)
2963 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2964 else if (code == 0xff)
2965 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2966
2967 /* Fix the relocation's type. */
2968 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2969 (ELF32_R_TYPE (irel->r_info)
2970 == (int) R_MN10300_PLT32)
2971 ? R_MN10300_PLT16 :
2972 R_MN10300_PCREL16);
2973
2974 /* Delete two bytes of data. */
2975 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2976 irel->r_offset + 1, 2))
2977 goto error_return;
2978
2979 /* That will change things, so, we should relax again.
2980 Note that this is not required, and it may be slow. */
2981 *again = TRUE;
2982 }
2983 }
2984
2985 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
2986 branch. */
2987 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
2988 {
2989 bfd_vma value = symval;
2990
2991 /* If we've got a "call" instruction that needs to be turned
2992 into a "calls" instruction, do so now. It saves a byte. */
2993 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2994 {
2995 unsigned char code;
2996
2997 /* Get the opcode. */
2998 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2999
3000 /* Make sure we're working with a "call" instruction! */
3001 if (code == 0xcd)
3002 {
3003 /* Note that we've changed the relocs, section contents,
3004 etc. */
3005 elf_section_data (sec)->relocs = internal_relocs;
3006 elf_section_data (sec)->this_hdr.contents = contents;
3007 symtab_hdr->contents = (unsigned char *) isymbuf;
3008
3009 /* Fix the opcode. */
3010 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3011 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3012
3013 /* Fix irel->r_offset and irel->r_addend. */
3014 irel->r_offset += 1;
3015 irel->r_addend += 1;
3016
3017 /* Delete one byte of data. */
3018 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3019 irel->r_offset + 1, 1))
3020 goto error_return;
3021
3022 /* That will change things, so, we should relax again.
3023 Note that this is not required, and it may be slow. */
3024 *again = TRUE;
3025 }
3026 }
3027 else if (h)
3028 {
3029 unsigned char code;
3030
3031 /* Get the opcode. */
3032 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3033
3034 /* Insert data from the target function into the "call"
3035 instruction if needed. */
3036 if (code == 0xcd)
3037 {
3038 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3039 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3040 contents + irel->r_offset + 3);
3041 }
3042 }
3043
3044 /* Deal with pc-relative gunk. */
3045 value -= (sec->output_section->vma + sec->output_offset);
3046 value -= irel->r_offset;
3047 value += irel->r_addend;
3048
3049 /* See if the value will fit in 8 bits, note the high value is
3050 0x7f + 1 as the target will be one bytes closer if we are
3051 able to relax. */
3052 if ((long) value < 0x80 && (long) value > -0x80)
3053 {
3054 unsigned char code;
3055
3056 /* Get the opcode. */
3057 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3058
3059 if (code != 0xcc)
3060 continue;
3061
3062 /* Note that we've changed the relocs, section contents, etc. */
3063 elf_section_data (sec)->relocs = internal_relocs;
3064 elf_section_data (sec)->this_hdr.contents = contents;
3065 symtab_hdr->contents = (unsigned char *) isymbuf;
3066
3067 /* Fix the opcode. */
3068 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3069
3070 /* Fix the relocation's type. */
3071 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3072 R_MN10300_PCREL8);
3073
3074 /* Delete one byte of data. */
3075 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3076 irel->r_offset + 1, 1))
3077 goto error_return;
3078
3079 /* That will change things, so, we should relax again.
3080 Note that this is not required, and it may be slow. */
3081 *again = TRUE;
3082 }
3083 }
3084
3085 /* Try to eliminate an unconditional 8 bit pc-relative branch
3086 which immediately follows a conditional 8 bit pc-relative
3087 branch around the unconditional branch.
3088
3089 original: new:
3090 bCC lab1 bCC' lab2
3091 bra lab2
3092 lab1: lab1:
3093
3094 This happens when the bCC can't reach lab2 at assembly time,
3095 but due to other relaxations it can reach at link time. */
3096 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3097 {
3098 Elf_Internal_Rela *nrel;
3099 bfd_vma value = symval;
3100 unsigned char code;
3101
3102 /* Deal with pc-relative gunk. */
3103 value -= (sec->output_section->vma + sec->output_offset);
3104 value -= irel->r_offset;
3105 value += irel->r_addend;
3106
3107 /* Do nothing if this reloc is the last byte in the section. */
3108 if (irel->r_offset == sec->size)
3109 continue;
3110
3111 /* See if the next instruction is an unconditional pc-relative
3112 branch, more often than not this test will fail, so we
3113 test it first to speed things up. */
3114 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3115 if (code != 0xca)
3116 continue;
3117
3118 /* Also make sure the next relocation applies to the next
3119 instruction and that it's a pc-relative 8 bit branch. */
3120 nrel = irel + 1;
3121 if (nrel == irelend
3122 || irel->r_offset + 2 != nrel->r_offset
3123 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3124 continue;
3125
3126 /* Make sure our destination immediately follows the
3127 unconditional branch. */
3128 if (symval != (sec->output_section->vma + sec->output_offset
3129 + irel->r_offset + 3))
3130 continue;
3131
3132 /* Now make sure we are a conditional branch. This may not
3133 be necessary, but why take the chance.
3134
3135 Note these checks assume that R_MN10300_PCREL8 relocs
3136 only occur on bCC and bCCx insns. If they occured
3137 elsewhere, we'd need to know the start of this insn
3138 for this check to be accurate. */
3139 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3140 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3141 && code != 0xc3 && code != 0xc4 && code != 0xc5
3142 && code != 0xc6 && code != 0xc7 && code != 0xc8
3143 && code != 0xc9 && code != 0xe8 && code != 0xe9
3144 && code != 0xea && code != 0xeb)
3145 continue;
3146
3147 /* We also have to be sure there is no symbol/label
3148 at the unconditional branch. */
3149 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3150 irel->r_offset + 1))
3151 continue;
3152
3153 /* Note that we've changed the relocs, section contents, etc. */
3154 elf_section_data (sec)->relocs = internal_relocs;
3155 elf_section_data (sec)->this_hdr.contents = contents;
3156 symtab_hdr->contents = (unsigned char *) isymbuf;
3157
3158 /* Reverse the condition of the first branch. */
3159 switch (code)
3160 {
3161 case 0xc8:
3162 code = 0xc9;
3163 break;
3164 case 0xc9:
3165 code = 0xc8;
3166 break;
3167 case 0xc0:
3168 code = 0xc2;
3169 break;
3170 case 0xc2:
3171 code = 0xc0;
3172 break;
3173 case 0xc3:
3174 code = 0xc1;
3175 break;
3176 case 0xc1:
3177 code = 0xc3;
3178 break;
3179 case 0xc4:
3180 code = 0xc6;
3181 break;
3182 case 0xc6:
3183 code = 0xc4;
3184 break;
3185 case 0xc7:
3186 code = 0xc5;
3187 break;
3188 case 0xc5:
3189 code = 0xc7;
3190 break;
3191 case 0xe8:
3192 code = 0xe9;
3193 break;
3194 case 0x9d:
3195 code = 0xe8;
3196 break;
3197 case 0xea:
3198 code = 0xeb;
3199 break;
3200 case 0xeb:
3201 code = 0xea;
3202 break;
3203 }
3204 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3205
3206 /* Set the reloc type and symbol for the first branch
3207 from the second branch. */
3208 irel->r_info = nrel->r_info;
3209
3210 /* Make the reloc for the second branch a null reloc. */
3211 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3212 R_MN10300_NONE);
3213
3214 /* Delete two bytes of data. */
3215 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3216 irel->r_offset + 1, 2))
3217 goto error_return;
3218
3219 /* That will change things, so, we should relax again.
3220 Note that this is not required, and it may be slow. */
3221 *again = TRUE;
3222 }
3223
3224 /* Try to turn a 24 immediate, displacement or absolute address
3225 into a 8 immediate, displacement or absolute address. */
3226 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3227 {
3228 bfd_vma value = symval;
3229 value += irel->r_addend;
3230
3231 /* See if the value will fit in 8 bits. */
3232 if ((long) value < 0x7f && (long) value > -0x80)
3233 {
3234 unsigned char code;
3235
3236 /* AM33 insns which have 24 operands are 6 bytes long and
3237 will have 0xfd as the first byte. */
3238
3239 /* Get the first opcode. */
3240 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3241
3242 if (code == 0xfd)
3243 {
3244 /* Get the second opcode. */
3245 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3246
3247 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3248 equivalent instructions exists. */
3249 if (code != 0x6b && code != 0x7b
3250 && code != 0x8b && code != 0x9b
3251 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3252 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3253 || (code & 0x0f) == 0x0e))
3254 {
3255 /* Not safe if the high bit is on as relaxing may
3256 move the value out of high mem and thus not fit
3257 in a signed 8bit value. This is currently over
3258 conservative. */
3259 if ((value & 0x80) == 0)
3260 {
3261 /* Note that we've changed the relocation contents,
3262 etc. */
3263 elf_section_data (sec)->relocs = internal_relocs;
3264 elf_section_data (sec)->this_hdr.contents = contents;
3265 symtab_hdr->contents = (unsigned char *) isymbuf;
3266
3267 /* Fix the opcode. */
3268 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3269 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3270
3271 /* Fix the relocation's type. */
3272 irel->r_info =
3273 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3274 R_MN10300_8);
3275
3276 /* Delete two bytes of data. */
3277 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3278 irel->r_offset + 1, 2))
3279 goto error_return;
3280
3281 /* That will change things, so, we should relax
3282 again. Note that this is not required, and it
3283 may be slow. */
3284 *again = TRUE;
3285 break;
3286 }
3287 }
3288 }
3289 }
3290 }
3291
3292 /* Try to turn a 32bit immediate, displacement or absolute address
3293 into a 16bit immediate, displacement or absolute address. */
3294 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3295 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3296 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3297 {
3298 bfd_vma value = symval;
3299
3300 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3301 {
3302 asection * sgot;
3303
3304 sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3305 ->dynobj, ".got");
3306
3307 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3308 {
3309 value = sgot->output_offset;
3310
3311 if (h)
3312 value += h->root.got.offset;
3313 else
3314 value += (elf_local_got_offsets
3315 (abfd)[ELF32_R_SYM (irel->r_info)]);
3316 }
3317 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3318 value -= sgot->output_section->vma;
3319 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3320 value = (sgot->output_section->vma
3321 - (sec->output_section->vma
3322 + sec->output_offset
3323 + irel->r_offset));
3324 else
3325 abort ();
3326 }
3327
3328 value += irel->r_addend;
3329
3330 /* See if the value will fit in 24 bits.
3331 We allow any 16bit match here. We prune those we can't
3332 handle below. */
3333 if ((long) value < 0x7fffff && (long) value > -0x800000)
3334 {
3335 unsigned char code;
3336
3337 /* AM33 insns which have 32bit operands are 7 bytes long and
3338 will have 0xfe as the first byte. */
3339
3340 /* Get the first opcode. */
3341 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3342
3343 if (code == 0xfe)
3344 {
3345 /* Get the second opcode. */
3346 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3347
3348 /* All the am33 32 -> 24 relaxing possibilities. */
3349 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3350 equivalent instructions exists. */
3351 if (code != 0x6b && code != 0x7b
3352 && code != 0x8b && code != 0x9b
3353 && (ELF32_R_TYPE (irel->r_info)
3354 != (int) R_MN10300_GOTPC32)
3355 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3356 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3357 || (code & 0x0f) == 0x0e))
3358 {
3359 /* Not safe if the high bit is on as relaxing may
3360 move the value out of high mem and thus not fit
3361 in a signed 16bit value. This is currently over
3362 conservative. */
3363 if ((value & 0x8000) == 0)
3364 {
3365 /* Note that we've changed the relocation contents,
3366 etc. */
3367 elf_section_data (sec)->relocs = internal_relocs;
3368 elf_section_data (sec)->this_hdr.contents = contents;
3369 symtab_hdr->contents = (unsigned char *) isymbuf;
3370
3371 /* Fix the opcode. */
3372 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3373 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3374
3375 /* Fix the relocation's type. */
3376 irel->r_info =
3377 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3378 (ELF32_R_TYPE (irel->r_info)
3379 == (int) R_MN10300_GOTOFF32)
3380 ? R_MN10300_GOTOFF24
3381 : (ELF32_R_TYPE (irel->r_info)
3382 == (int) R_MN10300_GOT32)
3383 ? R_MN10300_GOT24 :
3384 R_MN10300_24);
3385
3386 /* Delete one byte of data. */
3387 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3388 irel->r_offset + 3, 1))
3389 goto error_return;
3390
3391 /* That will change things, so, we should relax
3392 again. Note that this is not required, and it
3393 may be slow. */
3394 *again = TRUE;
3395 break;
3396 }
3397 }
3398 }
3399 }
3400
3401 /* See if the value will fit in 16 bits.
3402 We allow any 16bit match here. We prune those we can't
3403 handle below. */
3404 if ((long) value < 0x7fff && (long) value > -0x8000)
3405 {
3406 unsigned char code;
3407
3408 /* Most insns which have 32bit operands are 6 bytes long;
3409 exceptions are pcrel insns and bit insns.
3410
3411 We handle pcrel insns above. We don't bother trying
3412 to handle the bit insns here.
3413
3414 The first byte of the remaining insns will be 0xfc. */
3415
3416 /* Get the first opcode. */
3417 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3418
3419 if (code != 0xfc)
3420 continue;
3421
3422 /* Get the second opcode. */
3423 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3424
3425 if ((code & 0xf0) < 0x80)
3426 switch (code & 0xf0)
3427 {
3428 /* mov (d32,am),dn -> mov (d32,am),dn
3429 mov dm,(d32,am) -> mov dn,(d32,am)
3430 mov (d32,am),an -> mov (d32,am),an
3431 mov dm,(d32,am) -> mov dn,(d32,am)
3432 movbu (d32,am),dn -> movbu (d32,am),dn
3433 movbu dm,(d32,am) -> movbu dn,(d32,am)
3434 movhu (d32,am),dn -> movhu (d32,am),dn
3435 movhu dm,(d32,am) -> movhu dn,(d32,am) */
3436 case 0x00:
3437 case 0x10:
3438 case 0x20:
3439 case 0x30:
3440 case 0x40:
3441 case 0x50:
3442 case 0x60:
3443 case 0x70:
3444 /* Not safe if the high bit is on as relaxing may
3445 move the value out of high mem and thus not fit
3446 in a signed 16bit value. */
3447 if (code == 0xcc
3448 && (value & 0x8000))
3449 continue;
3450
3451 /* Note that we've changed the relocation contents, etc. */
3452 elf_section_data (sec)->relocs = internal_relocs;
3453 elf_section_data (sec)->this_hdr.contents = contents;
3454 symtab_hdr->contents = (unsigned char *) isymbuf;
3455
3456 /* Fix the opcode. */
3457 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3458 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3459
3460 /* Fix the relocation's type. */
3461 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3462 (ELF32_R_TYPE (irel->r_info)
3463 == (int) R_MN10300_GOTOFF32)
3464 ? R_MN10300_GOTOFF16
3465 : (ELF32_R_TYPE (irel->r_info)
3466 == (int) R_MN10300_GOT32)
3467 ? R_MN10300_GOT16
3468 : (ELF32_R_TYPE (irel->r_info)
3469 == (int) R_MN10300_GOTPC32)
3470 ? R_MN10300_GOTPC16 :
3471 R_MN10300_16);
3472
3473 /* Delete two bytes of data. */
3474 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3475 irel->r_offset + 2, 2))
3476 goto error_return;
3477
3478 /* That will change things, so, we should relax again.
3479 Note that this is not required, and it may be slow. */
3480 *again = TRUE;
3481 break;
3482 }
3483 else if ((code & 0xf0) == 0x80
3484 || (code & 0xf0) == 0x90)
3485 switch (code & 0xf3)
3486 {
3487 /* mov dn,(abs32) -> mov dn,(abs16)
3488 movbu dn,(abs32) -> movbu dn,(abs16)
3489 movhu dn,(abs32) -> movhu dn,(abs16) */
3490 case 0x81:
3491 case 0x82:
3492 case 0x83:
3493 /* Note that we've changed the relocation contents, etc. */
3494 elf_section_data (sec)->relocs = internal_relocs;
3495 elf_section_data (sec)->this_hdr.contents = contents;
3496 symtab_hdr->contents = (unsigned char *) isymbuf;
3497
3498 if ((code & 0xf3) == 0x81)
3499 code = 0x01 + (code & 0x0c);
3500 else if ((code & 0xf3) == 0x82)
3501 code = 0x02 + (code & 0x0c);
3502 else if ((code & 0xf3) == 0x83)
3503 code = 0x03 + (code & 0x0c);
3504 else
3505 abort ();
3506
3507 /* Fix the opcode. */
3508 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3509
3510 /* Fix the relocation's type. */
3511 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3512 (ELF32_R_TYPE (irel->r_info)
3513 == (int) R_MN10300_GOTOFF32)
3514 ? R_MN10300_GOTOFF16
3515 : (ELF32_R_TYPE (irel->r_info)
3516 == (int) R_MN10300_GOT32)
3517 ? R_MN10300_GOT16
3518 : (ELF32_R_TYPE (irel->r_info)
3519 == (int) R_MN10300_GOTPC32)
3520 ? R_MN10300_GOTPC16 :
3521 R_MN10300_16);
3522
3523 /* The opcode got shorter too, so we have to fix the
3524 addend and offset too! */
3525 irel->r_offset -= 1;
3526
3527 /* Delete three bytes of data. */
3528 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3529 irel->r_offset + 1, 3))
3530 goto error_return;
3531
3532 /* That will change things, so, we should relax again.
3533 Note that this is not required, and it may be slow. */
3534 *again = TRUE;
3535 break;
3536
3537 /* mov am,(abs32) -> mov am,(abs16)
3538 mov am,(d32,sp) -> mov am,(d16,sp)
3539 mov dm,(d32,sp) -> mov dm,(d32,sp)
3540 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3541 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3542 case 0x80:
3543 case 0x90:
3544 case 0x91:
3545 case 0x92:
3546 case 0x93:
3547 /* sp-based offsets are zero-extended. */
3548 if (code >= 0x90 && code <= 0x93
3549 && (long) value < 0)
3550 continue;
3551
3552 /* Note that we've changed the relocation contents, etc. */
3553 elf_section_data (sec)->relocs = internal_relocs;
3554 elf_section_data (sec)->this_hdr.contents = contents;
3555 symtab_hdr->contents = (unsigned char *) isymbuf;
3556
3557 /* Fix the opcode. */
3558 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3559 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3560
3561 /* Fix the relocation's type. */
3562 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3563 (ELF32_R_TYPE (irel->r_info)
3564 == (int) R_MN10300_GOTOFF32)
3565 ? R_MN10300_GOTOFF16
3566 : (ELF32_R_TYPE (irel->r_info)
3567 == (int) R_MN10300_GOT32)
3568 ? R_MN10300_GOT16
3569 : (ELF32_R_TYPE (irel->r_info)
3570 == (int) R_MN10300_GOTPC32)
3571 ? R_MN10300_GOTPC16 :
3572 R_MN10300_16);
3573
3574 /* Delete two bytes of data. */
3575 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3576 irel->r_offset + 2, 2))
3577 goto error_return;
3578
3579 /* That will change things, so, we should relax again.
3580 Note that this is not required, and it may be slow. */
3581 *again = TRUE;
3582 break;
3583 }
3584 else if ((code & 0xf0) < 0xf0)
3585 switch (code & 0xfc)
3586 {
3587 /* mov imm32,dn -> mov imm16,dn
3588 mov imm32,an -> mov imm16,an
3589 mov (abs32),dn -> mov (abs16),dn
3590 movbu (abs32),dn -> movbu (abs16),dn
3591 movhu (abs32),dn -> movhu (abs16),dn */
3592 case 0xcc:
3593 case 0xdc:
3594 case 0xa4:
3595 case 0xa8:
3596 case 0xac:
3597 /* Not safe if the high bit is on as relaxing may
3598 move the value out of high mem and thus not fit
3599 in a signed 16bit value. */
3600 if (code == 0xcc
3601 && (value & 0x8000))
3602 continue;
3603
3604 /* mov imm16, an zero-extends the immediate. */
3605 if (code == 0xdc
3606 && (long) value < 0)
3607 continue;
3608
3609 /* Note that we've changed the relocation contents, etc. */
3610 elf_section_data (sec)->relocs = internal_relocs;
3611 elf_section_data (sec)->this_hdr.contents = contents;
3612 symtab_hdr->contents = (unsigned char *) isymbuf;
3613
3614 if ((code & 0xfc) == 0xcc)
3615 code = 0x2c + (code & 0x03);
3616 else if ((code & 0xfc) == 0xdc)
3617 code = 0x24 + (code & 0x03);
3618 else if ((code & 0xfc) == 0xa4)
3619 code = 0x30 + (code & 0x03);
3620 else if ((code & 0xfc) == 0xa8)
3621 code = 0x34 + (code & 0x03);
3622 else if ((code & 0xfc) == 0xac)
3623 code = 0x38 + (code & 0x03);
3624 else
3625 abort ();
3626
3627 /* Fix the opcode. */
3628 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3629
3630 /* Fix the relocation's type. */
3631 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3632 (ELF32_R_TYPE (irel->r_info)
3633 == (int) R_MN10300_GOTOFF32)
3634 ? R_MN10300_GOTOFF16
3635 : (ELF32_R_TYPE (irel->r_info)
3636 == (int) R_MN10300_GOT32)
3637 ? R_MN10300_GOT16
3638 : (ELF32_R_TYPE (irel->r_info)
3639 == (int) R_MN10300_GOTPC32)
3640 ? R_MN10300_GOTPC16 :
3641 R_MN10300_16);
3642
3643 /* The opcode got shorter too, so we have to fix the
3644 addend and offset too! */
3645 irel->r_offset -= 1;
3646
3647 /* Delete three bytes of data. */
3648 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3649 irel->r_offset + 1, 3))
3650 goto error_return;
3651
3652 /* That will change things, so, we should relax again.
3653 Note that this is not required, and it may be slow. */
3654 *again = TRUE;
3655 break;
3656
3657 /* mov (abs32),an -> mov (abs16),an
3658 mov (d32,sp),an -> mov (d16,sp),an
3659 mov (d32,sp),dn -> mov (d16,sp),dn
3660 movbu (d32,sp),dn -> movbu (d16,sp),dn
3661 movhu (d32,sp),dn -> movhu (d16,sp),dn
3662 add imm32,dn -> add imm16,dn
3663 cmp imm32,dn -> cmp imm16,dn
3664 add imm32,an -> add imm16,an
3665 cmp imm32,an -> cmp imm16,an
3666 and imm32,dn -> and imm16,dn
3667 or imm32,dn -> or imm16,dn
3668 xor imm32,dn -> xor imm16,dn
3669 btst imm32,dn -> btst imm16,dn */
3670
3671 case 0xa0:
3672 case 0xb0:
3673 case 0xb1:
3674 case 0xb2:
3675 case 0xb3:
3676 case 0xc0:
3677 case 0xc8:
3678
3679 case 0xd0:
3680 case 0xd8:
3681 case 0xe0:
3682 case 0xe1:
3683 case 0xe2:
3684 case 0xe3:
3685 /* cmp imm16, an zero-extends the immediate. */
3686 if (code == 0xdc
3687 && (long) value < 0)
3688 continue;
3689
3690 /* So do sp-based offsets. */
3691 if (code >= 0xb0 && code <= 0xb3
3692 && (long) value < 0)
3693 continue;
3694
3695 /* Note that we've changed the relocation contents, etc. */
3696 elf_section_data (sec)->relocs = internal_relocs;
3697 elf_section_data (sec)->this_hdr.contents = contents;
3698 symtab_hdr->contents = (unsigned char *) isymbuf;
3699
3700 /* Fix the opcode. */
3701 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3702 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3703
3704 /* Fix the relocation's type. */
3705 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3706 (ELF32_R_TYPE (irel->r_info)
3707 == (int) R_MN10300_GOTOFF32)
3708 ? R_MN10300_GOTOFF16
3709 : (ELF32_R_TYPE (irel->r_info)
3710 == (int) R_MN10300_GOT32)
3711 ? R_MN10300_GOT16
3712 : (ELF32_R_TYPE (irel->r_info)
3713 == (int) R_MN10300_GOTPC32)
3714 ? R_MN10300_GOTPC16 :
3715 R_MN10300_16);
3716
3717 /* Delete two bytes of data. */
3718 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3719 irel->r_offset + 2, 2))
3720 goto error_return;
3721
3722 /* That will change things, so, we should relax again.
3723 Note that this is not required, and it may be slow. */
3724 *again = TRUE;
3725 break;
3726 }
3727 else if (code == 0xfe)
3728 {
3729 /* add imm32,sp -> add imm16,sp */
3730
3731 /* Note that we've changed the relocation contents, etc. */
3732 elf_section_data (sec)->relocs = internal_relocs;
3733 elf_section_data (sec)->this_hdr.contents = contents;
3734 symtab_hdr->contents = (unsigned char *) isymbuf;
3735
3736 /* Fix the opcode. */
3737 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3738 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3739
3740 /* Fix the relocation's type. */
3741 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3742 (ELF32_R_TYPE (irel->r_info)
3743 == (int) R_MN10300_GOT32)
3744 ? R_MN10300_GOT16
3745 : (ELF32_R_TYPE (irel->r_info)
3746 == (int) R_MN10300_GOTOFF32)
3747 ? R_MN10300_GOTOFF16
3748 : (ELF32_R_TYPE (irel->r_info)
3749 == (int) R_MN10300_GOTPC32)
3750 ? R_MN10300_GOTPC16 :
3751 R_MN10300_16);
3752
3753 /* Delete two bytes of data. */
3754 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3755 irel->r_offset + 2, 2))
3756 goto error_return;
3757
3758 /* That will change things, so, we should relax again.
3759 Note that this is not required, and it may be slow. */
3760 *again = TRUE;
3761 break;
3762 }
3763 }
3764 }
3765 }
3766
3767 if (isymbuf != NULL
3768 && symtab_hdr->contents != (unsigned char *) isymbuf)
3769 {
3770 if (! link_info->keep_memory)
3771 free (isymbuf);
3772 else
3773 {
3774 /* Cache the symbols for elf_link_input_bfd. */
3775 symtab_hdr->contents = (unsigned char *) isymbuf;
3776 }
3777 }
3778
3779 if (contents != NULL
3780 && elf_section_data (sec)->this_hdr.contents != contents)
3781 {
3782 if (! link_info->keep_memory)
3783 free (contents);
3784 else
3785 {
3786 /* Cache the section contents for elf_link_input_bfd. */
3787 elf_section_data (sec)->this_hdr.contents = contents;
3788 }
3789 }
3790
3791 if (internal_relocs != NULL
3792 && elf_section_data (sec)->relocs != internal_relocs)
3793 free (internal_relocs);
3794
3795 return TRUE;
3796
3797 error_return:
3798 if (isymbuf != NULL
3799 && symtab_hdr->contents != (unsigned char *) isymbuf)
3800 free (isymbuf);
3801 if (contents != NULL
3802 && elf_section_data (section)->this_hdr.contents != contents)
3803 free (contents);
3804 if (internal_relocs != NULL
3805 && elf_section_data (section)->relocs != internal_relocs)
3806 free (internal_relocs);
3807
3808 return FALSE;
3809 }
3810
3811 /* This is a version of bfd_generic_get_relocated_section_contents
3812 which uses mn10300_elf_relocate_section. */
3813
3814 static bfd_byte *
3815 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3816 struct bfd_link_info *link_info,
3817 struct bfd_link_order *link_order,
3818 bfd_byte *data,
3819 bfd_boolean relocatable,
3820 asymbol **symbols)
3821 {
3822 Elf_Internal_Shdr *symtab_hdr;
3823 asection *input_section = link_order->u.indirect.section;
3824 bfd *input_bfd = input_section->owner;
3825 asection **sections = NULL;
3826 Elf_Internal_Rela *internal_relocs = NULL;
3827 Elf_Internal_Sym *isymbuf = NULL;
3828
3829 /* We only need to handle the case of relaxing, or of having a
3830 particular set of section contents, specially. */
3831 if (relocatable
3832 || elf_section_data (input_section)->this_hdr.contents == NULL)
3833 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3834 link_order, data,
3835 relocatable,
3836 symbols);
3837
3838 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3839
3840 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3841 (size_t) input_section->size);
3842
3843 if ((input_section->flags & SEC_RELOC) != 0
3844 && input_section->reloc_count > 0)
3845 {
3846 asection **secpp;
3847 Elf_Internal_Sym *isym, *isymend;
3848 bfd_size_type amt;
3849
3850 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3851 NULL, NULL, FALSE);
3852 if (internal_relocs == NULL)
3853 goto error_return;
3854
3855 if (symtab_hdr->sh_info != 0)
3856 {
3857 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3858 if (isymbuf == NULL)
3859 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3860 symtab_hdr->sh_info, 0,
3861 NULL, NULL, NULL);
3862 if (isymbuf == NULL)
3863 goto error_return;
3864 }
3865
3866 amt = symtab_hdr->sh_info;
3867 amt *= sizeof (asection *);
3868 sections = bfd_malloc (amt);
3869 if (sections == NULL && amt != 0)
3870 goto error_return;
3871
3872 isymend = isymbuf + symtab_hdr->sh_info;
3873 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3874 {
3875 asection *isec;
3876
3877 if (isym->st_shndx == SHN_UNDEF)
3878 isec = bfd_und_section_ptr;
3879 else if (isym->st_shndx == SHN_ABS)
3880 isec = bfd_abs_section_ptr;
3881 else if (isym->st_shndx == SHN_COMMON)
3882 isec = bfd_com_section_ptr;
3883 else
3884 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3885
3886 *secpp = isec;
3887 }
3888
3889 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3890 input_section, data, internal_relocs,
3891 isymbuf, sections))
3892 goto error_return;
3893
3894 if (sections != NULL)
3895 free (sections);
3896 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3897 free (isymbuf);
3898 if (internal_relocs != elf_section_data (input_section)->relocs)
3899 free (internal_relocs);
3900 }
3901
3902 return data;
3903
3904 error_return:
3905 if (sections != NULL)
3906 free (sections);
3907 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3908 free (isymbuf);
3909 if (internal_relocs != NULL
3910 && internal_relocs != elf_section_data (input_section)->relocs)
3911 free (internal_relocs);
3912 return NULL;
3913 }
3914
3915 /* Assorted hash table functions. */
3916
3917 /* Initialize an entry in the link hash table. */
3918
3919 /* Create an entry in an MN10300 ELF linker hash table. */
3920
3921 static struct bfd_hash_entry *
3922 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3923 struct bfd_hash_table *table,
3924 const char *string)
3925 {
3926 struct elf32_mn10300_link_hash_entry *ret =
3927 (struct elf32_mn10300_link_hash_entry *) entry;
3928
3929 /* Allocate the structure if it has not already been allocated by a
3930 subclass. */
3931 if (ret == NULL)
3932 ret = (struct elf32_mn10300_link_hash_entry *)
3933 bfd_hash_allocate (table, sizeof (* ret));
3934 if (ret == NULL)
3935 return (struct bfd_hash_entry *) ret;
3936
3937 /* Call the allocation method of the superclass. */
3938 ret = (struct elf32_mn10300_link_hash_entry *)
3939 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3940 table, string);
3941 if (ret != NULL)
3942 {
3943 ret->direct_calls = 0;
3944 ret->stack_size = 0;
3945 ret->movm_args = 0;
3946 ret->movm_stack_size = 0;
3947 ret->flags = 0;
3948 ret->value = 0;
3949 }
3950
3951 return (struct bfd_hash_entry *) ret;
3952 }
3953
3954 /* Create an mn10300 ELF linker hash table. */
3955
3956 static struct bfd_link_hash_table *
3957 elf32_mn10300_link_hash_table_create (bfd *abfd)
3958 {
3959 struct elf32_mn10300_link_hash_table *ret;
3960 bfd_size_type amt = sizeof (* ret);
3961
3962 ret = bfd_malloc (amt);
3963 if (ret == NULL)
3964 return NULL;
3965
3966 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3967 elf32_mn10300_link_hash_newfunc,
3968 sizeof (struct elf32_mn10300_link_hash_entry)))
3969 {
3970 free (ret);
3971 return NULL;
3972 }
3973
3974 ret->flags = 0;
3975 amt = sizeof (struct elf_link_hash_table);
3976 ret->static_hash_table = bfd_malloc (amt);
3977 if (ret->static_hash_table == NULL)
3978 {
3979 free (ret);
3980 return NULL;
3981 }
3982
3983 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
3984 elf32_mn10300_link_hash_newfunc,
3985 sizeof (struct elf32_mn10300_link_hash_entry)))
3986 {
3987 free (ret->static_hash_table);
3988 free (ret);
3989 return NULL;
3990 }
3991 return & ret->root.root;
3992 }
3993
3994 /* Free an mn10300 ELF linker hash table. */
3995
3996 static void
3997 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
3998 {
3999 struct elf32_mn10300_link_hash_table *ret
4000 = (struct elf32_mn10300_link_hash_table *) hash;
4001
4002 _bfd_generic_link_hash_table_free
4003 ((struct bfd_link_hash_table *) ret->static_hash_table);
4004 _bfd_generic_link_hash_table_free
4005 ((struct bfd_link_hash_table *) ret);
4006 }
4007
4008 static unsigned long
4009 elf_mn10300_mach (flagword flags)
4010 {
4011 switch (flags & EF_MN10300_MACH)
4012 {
4013 case E_MN10300_MACH_MN10300:
4014 default:
4015 return bfd_mach_mn10300;
4016
4017 case E_MN10300_MACH_AM33:
4018 return bfd_mach_am33;
4019
4020 case E_MN10300_MACH_AM33_2:
4021 return bfd_mach_am33_2;
4022 }
4023 }
4024
4025 /* The final processing done just before writing out a MN10300 ELF object
4026 file. This gets the MN10300 architecture right based on the machine
4027 number. */
4028
4029 static void
4030 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
4031 bfd_boolean linker ATTRIBUTE_UNUSED)
4032 {
4033 unsigned long val;
4034
4035 switch (bfd_get_mach (abfd))
4036 {
4037 default:
4038 case bfd_mach_mn10300:
4039 val = E_MN10300_MACH_MN10300;
4040 break;
4041
4042 case bfd_mach_am33:
4043 val = E_MN10300_MACH_AM33;
4044 break;
4045
4046 case bfd_mach_am33_2:
4047 val = E_MN10300_MACH_AM33_2;
4048 break;
4049 }
4050
4051 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4052 elf_elfheader (abfd)->e_flags |= val;
4053 }
4054
4055 static bfd_boolean
4056 _bfd_mn10300_elf_object_p (bfd *abfd)
4057 {
4058 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
4059 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
4060 return TRUE;
4061 }
4062
4063 /* Merge backend specific data from an object file to the output
4064 object file when linking. */
4065
4066 static bfd_boolean
4067 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4068 {
4069 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4070 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4071 return TRUE;
4072
4073 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4074 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4075 {
4076 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4077 bfd_get_mach (ibfd)))
4078 return FALSE;
4079 }
4080
4081 return TRUE;
4082 }
4083
4084 #define PLT0_ENTRY_SIZE 15
4085 #define PLT_ENTRY_SIZE 20
4086 #define PIC_PLT_ENTRY_SIZE 24
4087
4088 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4089 {
4090 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4091 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4092 0xf0, 0xf4, /* jmp (a0) */
4093 };
4094
4095 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4096 {
4097 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4098 0xf0, 0xf4, /* jmp (a0) */
4099 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4100 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4101 };
4102
4103 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4104 {
4105 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4106 0xf0, 0xf4, /* jmp (a0) */
4107 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4108 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4109 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4110 0xf0, 0xf4, /* jmp (a0) */
4111 };
4112
4113 /* Return size of the first PLT entry. */
4114 #define elf_mn10300_sizeof_plt0(info) \
4115 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4116
4117 /* Return size of a PLT entry. */
4118 #define elf_mn10300_sizeof_plt(info) \
4119 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4120
4121 /* Return offset of the PLT0 address in an absolute PLT entry. */
4122 #define elf_mn10300_plt_plt0_offset(info) 16
4123
4124 /* Return offset of the linker in PLT0 entry. */
4125 #define elf_mn10300_plt0_linker_offset(info) 2
4126
4127 /* Return offset of the GOT id in PLT0 entry. */
4128 #define elf_mn10300_plt0_gotid_offset(info) 9
4129
4130 /* Return offset of the temporary in PLT entry. */
4131 #define elf_mn10300_plt_temp_offset(info) 8
4132
4133 /* Return offset of the symbol in PLT entry. */
4134 #define elf_mn10300_plt_symbol_offset(info) 2
4135
4136 /* Return offset of the relocation in PLT entry. */
4137 #define elf_mn10300_plt_reloc_offset(info) 11
4138
4139 /* The name of the dynamic interpreter. This is put in the .interp
4140 section. */
4141
4142 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4143
4144 /* Create dynamic sections when linking against a dynamic object. */
4145
4146 static bfd_boolean
4147 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4148 {
4149 flagword flags;
4150 asection * s;
4151 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4152 int ptralign = 0;
4153
4154 switch (bed->s->arch_size)
4155 {
4156 case 32:
4157 ptralign = 2;
4158 break;
4159
4160 case 64:
4161 ptralign = 3;
4162 break;
4163
4164 default:
4165 bfd_set_error (bfd_error_bad_value);
4166 return FALSE;
4167 }
4168
4169 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4170 .rel[a].bss sections. */
4171 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4172 | SEC_LINKER_CREATED);
4173
4174 s = bfd_make_section_with_flags (abfd,
4175 (bed->default_use_rela_p
4176 ? ".rela.plt" : ".rel.plt"),
4177 flags | SEC_READONLY);
4178 if (s == NULL
4179 || ! bfd_set_section_alignment (abfd, s, ptralign))
4180 return FALSE;
4181
4182 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4183 return FALSE;
4184
4185 {
4186 const char * secname;
4187 char * relname;
4188 flagword secflags;
4189 asection * sec;
4190
4191 for (sec = abfd->sections; sec; sec = sec->next)
4192 {
4193 secflags = bfd_get_section_flags (abfd, sec);
4194 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4195 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4196 continue;
4197
4198 secname = bfd_get_section_name (abfd, sec);
4199 relname = bfd_malloc (strlen (secname) + 6);
4200 strcpy (relname, ".rela");
4201 strcat (relname, secname);
4202
4203 s = bfd_make_section_with_flags (abfd, relname,
4204 flags | SEC_READONLY);
4205 if (s == NULL
4206 || ! bfd_set_section_alignment (abfd, s, ptralign))
4207 return FALSE;
4208 }
4209 }
4210
4211 if (bed->want_dynbss)
4212 {
4213 /* The .dynbss section is a place to put symbols which are defined
4214 by dynamic objects, are referenced by regular objects, and are
4215 not functions. We must allocate space for them in the process
4216 image and use a R_*_COPY reloc to tell the dynamic linker to
4217 initialize them at run time. The linker script puts the .dynbss
4218 section into the .bss section of the final image. */
4219 s = bfd_make_section_with_flags (abfd, ".dynbss",
4220 SEC_ALLOC | SEC_LINKER_CREATED);
4221 if (s == NULL)
4222 return FALSE;
4223
4224 /* The .rel[a].bss section holds copy relocs. This section is not
4225 normally needed. We need to create it here, though, so that the
4226 linker will map it to an output section. We can't just create it
4227 only if we need it, because we will not know whether we need it
4228 until we have seen all the input files, and the first time the
4229 main linker code calls BFD after examining all the input files
4230 (size_dynamic_sections) the input sections have already been
4231 mapped to the output sections. If the section turns out not to
4232 be needed, we can discard it later. We will never need this
4233 section when generating a shared object, since they do not use
4234 copy relocs. */
4235 if (! info->shared)
4236 {
4237 s = bfd_make_section_with_flags (abfd,
4238 (bed->default_use_rela_p
4239 ? ".rela.bss" : ".rel.bss"),
4240 flags | SEC_READONLY);
4241 if (s == NULL
4242 || ! bfd_set_section_alignment (abfd, s, ptralign))
4243 return FALSE;
4244 }
4245 }
4246
4247 return TRUE;
4248 }
4249 \f
4250 /* Adjust a symbol defined by a dynamic object and referenced by a
4251 regular object. The current definition is in some section of the
4252 dynamic object, but we're not including those sections. We have to
4253 change the definition to something the rest of the link can
4254 understand. */
4255
4256 static bfd_boolean
4257 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4258 struct elf_link_hash_entry * h)
4259 {
4260 bfd * dynobj;
4261 asection * s;
4262
4263 dynobj = elf_hash_table (info)->dynobj;
4264
4265 /* Make sure we know what is going on here. */
4266 BFD_ASSERT (dynobj != NULL
4267 && (h->needs_plt
4268 || h->u.weakdef != NULL
4269 || (h->def_dynamic
4270 && h->ref_regular
4271 && !h->def_regular)));
4272
4273 /* If this is a function, put it in the procedure linkage table. We
4274 will fill in the contents of the procedure linkage table later,
4275 when we know the address of the .got section. */
4276 if (h->type == STT_FUNC
4277 || h->needs_plt)
4278 {
4279 if (! info->shared
4280 && !h->def_dynamic
4281 && !h->ref_dynamic)
4282 {
4283 /* This case can occur if we saw a PLT reloc in an input
4284 file, but the symbol was never referred to by a dynamic
4285 object. In such a case, we don't actually need to build
4286 a procedure linkage table, and we can just do a REL32
4287 reloc instead. */
4288 BFD_ASSERT (h->needs_plt);
4289 return TRUE;
4290 }
4291
4292 /* Make sure this symbol is output as a dynamic symbol. */
4293 if (h->dynindx == -1)
4294 {
4295 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4296 return FALSE;
4297 }
4298
4299 s = bfd_get_section_by_name (dynobj, ".plt");
4300 BFD_ASSERT (s != NULL);
4301
4302 /* If this is the first .plt entry, make room for the special
4303 first entry. */
4304 if (s->size == 0)
4305 s->size += elf_mn10300_sizeof_plt0 (info);
4306
4307 /* If this symbol is not defined in a regular file, and we are
4308 not generating a shared library, then set the symbol to this
4309 location in the .plt. This is required to make function
4310 pointers compare as equal between the normal executable and
4311 the shared library. */
4312 if (! info->shared
4313 && !h->def_regular)
4314 {
4315 h->root.u.def.section = s;
4316 h->root.u.def.value = s->size;
4317 }
4318
4319 h->plt.offset = s->size;
4320
4321 /* Make room for this entry. */
4322 s->size += elf_mn10300_sizeof_plt (info);
4323
4324 /* We also need to make an entry in the .got.plt section, which
4325 will be placed in the .got section by the linker script. */
4326 s = bfd_get_section_by_name (dynobj, ".got.plt");
4327 BFD_ASSERT (s != NULL);
4328 s->size += 4;
4329
4330 /* We also need to make an entry in the .rela.plt section. */
4331 s = bfd_get_section_by_name (dynobj, ".rela.plt");
4332 BFD_ASSERT (s != NULL);
4333 s->size += sizeof (Elf32_External_Rela);
4334
4335 return TRUE;
4336 }
4337
4338 /* If this is a weak symbol, and there is a real definition, the
4339 processor independent code will have arranged for us to see the
4340 real definition first, and we can just use the same value. */
4341 if (h->u.weakdef != NULL)
4342 {
4343 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4344 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4345 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4346 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4347 return TRUE;
4348 }
4349
4350 /* This is a reference to a symbol defined by a dynamic object which
4351 is not a function. */
4352
4353 /* If we are creating a shared library, we must presume that the
4354 only references to the symbol are via the global offset table.
4355 For such cases we need not do anything here; the relocations will
4356 be handled correctly by relocate_section. */
4357 if (info->shared)
4358 return TRUE;
4359
4360 /* If there are no references to this symbol that do not use the
4361 GOT, we don't need to generate a copy reloc. */
4362 if (!h->non_got_ref)
4363 return TRUE;
4364
4365 if (h->size == 0)
4366 {
4367 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4368 h->root.root.string);
4369 return TRUE;
4370 }
4371
4372 /* We must allocate the symbol in our .dynbss section, which will
4373 become part of the .bss section of the executable. There will be
4374 an entry for this symbol in the .dynsym section. The dynamic
4375 object will contain position independent code, so all references
4376 from the dynamic object to this symbol will go through the global
4377 offset table. The dynamic linker will use the .dynsym entry to
4378 determine the address it must put in the global offset table, so
4379 both the dynamic object and the regular object will refer to the
4380 same memory location for the variable. */
4381
4382 s = bfd_get_section_by_name (dynobj, ".dynbss");
4383 BFD_ASSERT (s != NULL);
4384
4385 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4386 copy the initial value out of the dynamic object and into the
4387 runtime process image. We need to remember the offset into the
4388 .rela.bss section we are going to use. */
4389 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4390 {
4391 asection * srel;
4392
4393 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4394 BFD_ASSERT (srel != NULL);
4395 srel->size += sizeof (Elf32_External_Rela);
4396 h->needs_copy = 1;
4397 }
4398
4399 return _bfd_elf_adjust_dynamic_copy (h, s);
4400 }
4401
4402 /* Set the sizes of the dynamic sections. */
4403
4404 static bfd_boolean
4405 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4406 struct bfd_link_info * info)
4407 {
4408 bfd * dynobj;
4409 asection * s;
4410 bfd_boolean plt;
4411 bfd_boolean relocs;
4412 bfd_boolean reltext;
4413
4414 dynobj = elf_hash_table (info)->dynobj;
4415 BFD_ASSERT (dynobj != NULL);
4416
4417 if (elf_hash_table (info)->dynamic_sections_created)
4418 {
4419 /* Set the contents of the .interp section to the interpreter. */
4420 if (info->executable)
4421 {
4422 s = bfd_get_section_by_name (dynobj, ".interp");
4423 BFD_ASSERT (s != NULL);
4424 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4425 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4426 }
4427 }
4428 else
4429 {
4430 /* We may have created entries in the .rela.got section.
4431 However, if we are not creating the dynamic sections, we will
4432 not actually use these entries. Reset the size of .rela.got,
4433 which will cause it to get stripped from the output file
4434 below. */
4435 s = bfd_get_section_by_name (dynobj, ".rela.got");
4436 if (s != NULL)
4437 s->size = 0;
4438 }
4439
4440 /* The check_relocs and adjust_dynamic_symbol entry points have
4441 determined the sizes of the various dynamic sections. Allocate
4442 memory for them. */
4443 plt = FALSE;
4444 relocs = FALSE;
4445 reltext = FALSE;
4446 for (s = dynobj->sections; s != NULL; s = s->next)
4447 {
4448 const char * name;
4449
4450 if ((s->flags & SEC_LINKER_CREATED) == 0)
4451 continue;
4452
4453 /* It's OK to base decisions on the section name, because none
4454 of the dynobj section names depend upon the input files. */
4455 name = bfd_get_section_name (dynobj, s);
4456
4457 if (streq (name, ".plt"))
4458 {
4459 /* Remember whether there is a PLT. */
4460 plt = s->size != 0;
4461 }
4462 else if (CONST_STRNEQ (name, ".rela"))
4463 {
4464 if (s->size != 0)
4465 {
4466 asection * target;
4467
4468 /* Remember whether there are any reloc sections other
4469 than .rela.plt. */
4470 if (! streq (name, ".rela.plt"))
4471 {
4472 const char * outname;
4473
4474 relocs = TRUE;
4475
4476 /* If this relocation section applies to a read only
4477 section, then we probably need a DT_TEXTREL
4478 entry. The entries in the .rela.plt section
4479 really apply to the .got section, which we
4480 created ourselves and so know is not readonly. */
4481 outname = bfd_get_section_name (output_bfd,
4482 s->output_section);
4483 target = bfd_get_section_by_name (output_bfd, outname + 5);
4484 if (target != NULL
4485 && (target->flags & SEC_READONLY) != 0
4486 && (target->flags & SEC_ALLOC) != 0)
4487 reltext = TRUE;
4488 }
4489
4490 /* We use the reloc_count field as a counter if we need
4491 to copy relocs into the output file. */
4492 s->reloc_count = 0;
4493 }
4494 }
4495 else if (! CONST_STRNEQ (name, ".got")
4496 && ! streq (name, ".dynbss"))
4497 /* It's not one of our sections, so don't allocate space. */
4498 continue;
4499
4500 if (s->size == 0)
4501 {
4502 /* If we don't need this section, strip it from the
4503 output file. This is mostly to handle .rela.bss and
4504 .rela.plt. We must create both sections in
4505 create_dynamic_sections, because they must be created
4506 before the linker maps input sections to output
4507 sections. The linker does that before
4508 adjust_dynamic_symbol is called, and it is that
4509 function which decides whether anything needs to go
4510 into these sections. */
4511 s->flags |= SEC_EXCLUDE;
4512 continue;
4513 }
4514
4515 if ((s->flags & SEC_HAS_CONTENTS) == 0)
4516 continue;
4517
4518 /* Allocate memory for the section contents. We use bfd_zalloc
4519 here in case unused entries are not reclaimed before the
4520 section's contents are written out. This should not happen,
4521 but this way if it does, we get a R_MN10300_NONE reloc
4522 instead of garbage. */
4523 s->contents = bfd_zalloc (dynobj, s->size);
4524 if (s->contents == NULL)
4525 return FALSE;
4526 }
4527
4528 if (elf_hash_table (info)->dynamic_sections_created)
4529 {
4530 /* Add some entries to the .dynamic section. We fill in the
4531 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4532 but we must add the entries now so that we get the correct
4533 size for the .dynamic section. The DT_DEBUG entry is filled
4534 in by the dynamic linker and used by the debugger. */
4535 if (! info->shared)
4536 {
4537 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
4538 return FALSE;
4539 }
4540
4541 if (plt)
4542 {
4543 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4544 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4545 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4546 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4547 return FALSE;
4548 }
4549
4550 if (relocs)
4551 {
4552 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4553 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4554 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4555 sizeof (Elf32_External_Rela)))
4556 return FALSE;
4557 }
4558
4559 if (reltext)
4560 {
4561 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
4562 return FALSE;
4563 }
4564 }
4565
4566 return TRUE;
4567 }
4568
4569 /* Finish up dynamic symbol handling. We set the contents of various
4570 dynamic sections here. */
4571
4572 static bfd_boolean
4573 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4574 struct bfd_link_info * info,
4575 struct elf_link_hash_entry * h,
4576 Elf_Internal_Sym * sym)
4577 {
4578 bfd * dynobj;
4579
4580 dynobj = elf_hash_table (info)->dynobj;
4581
4582 if (h->plt.offset != (bfd_vma) -1)
4583 {
4584 asection * splt;
4585 asection * sgot;
4586 asection * srel;
4587 bfd_vma plt_index;
4588 bfd_vma got_offset;
4589 Elf_Internal_Rela rel;
4590
4591 /* This symbol has an entry in the procedure linkage table. Set
4592 it up. */
4593
4594 BFD_ASSERT (h->dynindx != -1);
4595
4596 splt = bfd_get_section_by_name (dynobj, ".plt");
4597 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4598 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4599 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4600
4601 /* Get the index in the procedure linkage table which
4602 corresponds to this symbol. This is the index of this symbol
4603 in all the symbols for which we are making plt entries. The
4604 first entry in the procedure linkage table is reserved. */
4605 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4606 / elf_mn10300_sizeof_plt (info));
4607
4608 /* Get the offset into the .got table of the entry that
4609 corresponds to this function. Each .got entry is 4 bytes.
4610 The first three are reserved. */
4611 got_offset = (plt_index + 3) * 4;
4612
4613 /* Fill in the entry in the procedure linkage table. */
4614 if (! info->shared)
4615 {
4616 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4617 elf_mn10300_sizeof_plt (info));
4618 bfd_put_32 (output_bfd,
4619 (sgot->output_section->vma
4620 + sgot->output_offset
4621 + got_offset),
4622 (splt->contents + h->plt.offset
4623 + elf_mn10300_plt_symbol_offset (info)));
4624
4625 bfd_put_32 (output_bfd,
4626 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4627 (splt->contents + h->plt.offset
4628 + elf_mn10300_plt_plt0_offset (info)));
4629 }
4630 else
4631 {
4632 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4633 elf_mn10300_sizeof_plt (info));
4634
4635 bfd_put_32 (output_bfd, got_offset,
4636 (splt->contents + h->plt.offset
4637 + elf_mn10300_plt_symbol_offset (info)));
4638 }
4639
4640 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4641 (splt->contents + h->plt.offset
4642 + elf_mn10300_plt_reloc_offset (info)));
4643
4644 /* Fill in the entry in the global offset table. */
4645 bfd_put_32 (output_bfd,
4646 (splt->output_section->vma
4647 + splt->output_offset
4648 + h->plt.offset
4649 + elf_mn10300_plt_temp_offset (info)),
4650 sgot->contents + got_offset);
4651
4652 /* Fill in the entry in the .rela.plt section. */
4653 rel.r_offset = (sgot->output_section->vma
4654 + sgot->output_offset
4655 + got_offset);
4656 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4657 rel.r_addend = 0;
4658 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4659 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4660 + plt_index));
4661
4662 if (!h->def_regular)
4663 /* Mark the symbol as undefined, rather than as defined in
4664 the .plt section. Leave the value alone. */
4665 sym->st_shndx = SHN_UNDEF;
4666 }
4667
4668 if (h->got.offset != (bfd_vma) -1)
4669 {
4670 asection * sgot;
4671 asection * srel;
4672 Elf_Internal_Rela rel;
4673
4674 /* This symbol has an entry in the global offset table. Set it up. */
4675 sgot = bfd_get_section_by_name (dynobj, ".got");
4676 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4677 BFD_ASSERT (sgot != NULL && srel != NULL);
4678
4679 rel.r_offset = (sgot->output_section->vma
4680 + sgot->output_offset
4681 + (h->got.offset & ~1));
4682
4683 /* If this is a -Bsymbolic link, and the symbol is defined
4684 locally, we just want to emit a RELATIVE reloc. Likewise if
4685 the symbol was forced to be local because of a version file.
4686 The entry in the global offset table will already have been
4687 initialized in the relocate_section function. */
4688 if (info->shared
4689 && (info->symbolic || h->dynindx == -1)
4690 && h->def_regular)
4691 {
4692 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4693 rel.r_addend = (h->root.u.def.value
4694 + h->root.u.def.section->output_section->vma
4695 + h->root.u.def.section->output_offset);
4696 }
4697 else
4698 {
4699 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4700 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4701 rel.r_addend = 0;
4702 }
4703
4704 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4705 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4706 + srel->reloc_count));
4707 ++ srel->reloc_count;
4708 }
4709
4710 if (h->needs_copy)
4711 {
4712 asection * s;
4713 Elf_Internal_Rela rel;
4714
4715 /* This symbol needs a copy reloc. Set it up. */
4716 BFD_ASSERT (h->dynindx != -1
4717 && (h->root.type == bfd_link_hash_defined
4718 || h->root.type == bfd_link_hash_defweak));
4719
4720 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4721 ".rela.bss");
4722 BFD_ASSERT (s != NULL);
4723
4724 rel.r_offset = (h->root.u.def.value
4725 + h->root.u.def.section->output_section->vma
4726 + h->root.u.def.section->output_offset);
4727 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4728 rel.r_addend = 0;
4729 bfd_elf32_swap_reloca_out (output_bfd, & rel,
4730 (bfd_byte *) ((Elf32_External_Rela *) s->contents
4731 + s->reloc_count));
4732 ++ s->reloc_count;
4733 }
4734
4735 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4736 if (streq (h->root.root.string, "_DYNAMIC")
4737 || h == elf_hash_table (info)->hgot)
4738 sym->st_shndx = SHN_ABS;
4739
4740 return TRUE;
4741 }
4742
4743 /* Finish up the dynamic sections. */
4744
4745 static bfd_boolean
4746 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4747 struct bfd_link_info * info)
4748 {
4749 bfd * dynobj;
4750 asection * sgot;
4751 asection * sdyn;
4752
4753 dynobj = elf_hash_table (info)->dynobj;
4754
4755 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4756 BFD_ASSERT (sgot != NULL);
4757 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4758
4759 if (elf_hash_table (info)->dynamic_sections_created)
4760 {
4761 asection * splt;
4762 Elf32_External_Dyn * dyncon;
4763 Elf32_External_Dyn * dynconend;
4764
4765 BFD_ASSERT (sdyn != NULL);
4766
4767 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4768 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4769
4770 for (; dyncon < dynconend; dyncon++)
4771 {
4772 Elf_Internal_Dyn dyn;
4773 const char * name;
4774 asection * s;
4775
4776 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4777
4778 switch (dyn.d_tag)
4779 {
4780 default:
4781 break;
4782
4783 case DT_PLTGOT:
4784 name = ".got";
4785 goto get_vma;
4786
4787 case DT_JMPREL:
4788 name = ".rela.plt";
4789 get_vma:
4790 s = bfd_get_section_by_name (output_bfd, name);
4791 BFD_ASSERT (s != NULL);
4792 dyn.d_un.d_ptr = s->vma;
4793 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4794 break;
4795
4796 case DT_PLTRELSZ:
4797 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4798 BFD_ASSERT (s != NULL);
4799 dyn.d_un.d_val = s->size;
4800 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4801 break;
4802
4803 case DT_RELASZ:
4804 /* My reading of the SVR4 ABI indicates that the
4805 procedure linkage table relocs (DT_JMPREL) should be
4806 included in the overall relocs (DT_RELA). This is
4807 what Solaris does. However, UnixWare can not handle
4808 that case. Therefore, we override the DT_RELASZ entry
4809 here to make it not include the JMPREL relocs. Since
4810 the linker script arranges for .rela.plt to follow all
4811 other relocation sections, we don't have to worry
4812 about changing the DT_RELA entry. */
4813 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4814 if (s != NULL)
4815 dyn.d_un.d_val -= s->size;
4816 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4817 break;
4818 }
4819 }
4820
4821 /* Fill in the first entry in the procedure linkage table. */
4822 splt = bfd_get_section_by_name (dynobj, ".plt");
4823 if (splt && splt->size > 0)
4824 {
4825 if (info->shared)
4826 {
4827 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4828 elf_mn10300_sizeof_plt (info));
4829 }
4830 else
4831 {
4832 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4833 bfd_put_32 (output_bfd,
4834 sgot->output_section->vma + sgot->output_offset + 4,
4835 splt->contents + elf_mn10300_plt0_gotid_offset (info));
4836 bfd_put_32 (output_bfd,
4837 sgot->output_section->vma + sgot->output_offset + 8,
4838 splt->contents + elf_mn10300_plt0_linker_offset (info));
4839 }
4840
4841 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4842 really seem like the right value. */
4843 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4844 }
4845 }
4846
4847 /* Fill in the first three entries in the global offset table. */
4848 if (sgot->size > 0)
4849 {
4850 if (sdyn == NULL)
4851 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4852 else
4853 bfd_put_32 (output_bfd,
4854 sdyn->output_section->vma + sdyn->output_offset,
4855 sgot->contents);
4856 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4857 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4858 }
4859
4860 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4861
4862 return TRUE;
4863 }
4864
4865 /* Classify relocation types, such that combreloc can sort them
4866 properly. */
4867
4868 static enum elf_reloc_type_class
4869 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4870 {
4871 switch ((int) ELF32_R_TYPE (rela->r_info))
4872 {
4873 case R_MN10300_RELATIVE: return reloc_class_relative;
4874 case R_MN10300_JMP_SLOT: return reloc_class_plt;
4875 case R_MN10300_COPY: return reloc_class_copy;
4876 default: return reloc_class_normal;
4877 }
4878 }
4879
4880 #ifndef ELF_ARCH
4881 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
4882 #define TARGET_LITTLE_NAME "elf32-mn10300"
4883 #define ELF_ARCH bfd_arch_mn10300
4884 #define ELF_MACHINE_CODE EM_MN10300
4885 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
4886 #define ELF_MAXPAGESIZE 0x1000
4887 #endif
4888
4889 #define elf_info_to_howto mn10300_info_to_howto
4890 #define elf_info_to_howto_rel 0
4891 #define elf_backend_can_gc_sections 1
4892 #define elf_backend_rela_normal 1
4893 #define elf_backend_check_relocs mn10300_elf_check_relocs
4894 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
4895 #define elf_backend_relocate_section mn10300_elf_relocate_section
4896 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
4897 #define bfd_elf32_bfd_get_relocated_section_contents \
4898 mn10300_elf_get_relocated_section_contents
4899 #define bfd_elf32_bfd_link_hash_table_create \
4900 elf32_mn10300_link_hash_table_create
4901 #define bfd_elf32_bfd_link_hash_table_free \
4902 elf32_mn10300_link_hash_table_free
4903
4904 #ifndef elf_symbol_leading_char
4905 #define elf_symbol_leading_char '_'
4906 #endif
4907
4908 /* So we can set bits in e_flags. */
4909 #define elf_backend_final_write_processing \
4910 _bfd_mn10300_elf_final_write_processing
4911 #define elf_backend_object_p _bfd_mn10300_elf_object_p
4912
4913 #define bfd_elf32_bfd_merge_private_bfd_data \
4914 _bfd_mn10300_elf_merge_private_bfd_data
4915
4916 #define elf_backend_can_gc_sections 1
4917 #define elf_backend_create_dynamic_sections \
4918 _bfd_mn10300_elf_create_dynamic_sections
4919 #define elf_backend_adjust_dynamic_symbol \
4920 _bfd_mn10300_elf_adjust_dynamic_symbol
4921 #define elf_backend_size_dynamic_sections \
4922 _bfd_mn10300_elf_size_dynamic_sections
4923 #define elf_backend_omit_section_dynsym \
4924 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4925 #define elf_backend_finish_dynamic_symbol \
4926 _bfd_mn10300_elf_finish_dynamic_symbol
4927 #define elf_backend_finish_dynamic_sections \
4928 _bfd_mn10300_elf_finish_dynamic_sections
4929
4930 #define elf_backend_reloc_type_class \
4931 _bfd_mn10300_elf_reloc_type_class
4932
4933 #define elf_backend_want_got_plt 1
4934 #define elf_backend_plt_readonly 1
4935 #define elf_backend_want_plt_sym 0
4936 #define elf_backend_got_header_size 12
4937
4938 #include "elf32-target.h"
git-cvsimport of binutils cvsroot