?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
2009-07-02 Tristan Gingold <gingold@adacore.com>
[binutils.git] / bfd / elf-m10300.c
blob015e6142ef1ffd9dc68cd2aad8b35a10b6a80574
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 && sym_sec->sec_info_type == ELF_INFO_TYPE_MERGE)
2785 {
2786 symval = isym->st_value;
2787
2788 /* GAS may reduce relocations against symbols in SEC_MERGE
2789 sections to a relocation against the section symbol when
2790 the original addend was zero. When the reloc is against
2791 a section symbol we should include the addend in the
2792 offset passed to _bfd_merged_section_offset, since the
2793 location of interest is the original symbol. On the
2794 other hand, an access to "sym+addend" where "sym" is not
2795 a section symbol should not include the addend; Such an
2796 access is presumed to be an offset from "sym"; The
2797 location of interest is just "sym". */
2798 if (ELF_ST_TYPE (isym->st_info) == STT_SECTION)
2799 symval += irel->r_addend;
2800
2801 symval = _bfd_merged_section_offset (abfd, & sym_sec,
2802 elf_section_data (sym_sec)->sec_info,
2803 symval);
2804
2805 if (ELF_ST_TYPE (isym->st_info) != STT_SECTION)
2806 symval += irel->r_addend;
2807
2808 symval += sym_sec->output_section->vma
2809 + sym_sec->output_offset - irel->r_addend;
2810 }
2811 else
2812 symval = (isym->st_value
2813 + sym_sec->output_section->vma
2814 + sym_sec->output_offset);
2815
2816 /* Tack on an ID so we can uniquely identify this
2817 local symbol in the global hash table. */
2818 new_name = bfd_malloc ((bfd_size_type) strlen (sym_name) + 10);
2819 if (new_name == NULL)
2820 goto error_return;
2821 sprintf (new_name, "%s_%08x", sym_name, sym_sec->id);
2822 sym_name = new_name;
2823
2824 h = (struct elf32_mn10300_link_hash_entry *)
2825 elf_link_hash_lookup (&hash_table->static_hash_table->root,
2826 sym_name, FALSE, FALSE, FALSE);
2827 free (new_name);
2828 }
2829 else
2830 {
2831 unsigned long indx;
2832
2833 /* An external symbol. */
2834 indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2835 h = (struct elf32_mn10300_link_hash_entry *)
2836 (elf_sym_hashes (abfd)[indx]);
2837 BFD_ASSERT (h != NULL);
2838 if (h->root.root.type != bfd_link_hash_defined
2839 && h->root.root.type != bfd_link_hash_defweak)
2840 /* This appears to be a reference to an undefined
2841 symbol. Just ignore it--it will be caught by the
2842 regular reloc processing. */
2843 continue;
2844
2845 /* Check for a reference to a discarded symbol and ignore it. */
2846 if (h->root.root.u.def.section->output_section == NULL)
2847 continue;
2848
2849 sym_sec = h->root.root.u.def.section->output_section;
2850
2851 symval = (h->root.root.u.def.value
2852 + h->root.root.u.def.section->output_section->vma
2853 + h->root.root.u.def.section->output_offset);
2854 }
2855
2856 /* For simplicity of coding, we are going to modify the section
2857 contents, the section relocs, and the BFD symbol table. We
2858 must tell the rest of the code not to free up this
2859 information. It would be possible to instead create a table
2860 of changes which have to be made, as is done in coff-mips.c;
2861 that would be more work, but would require less memory when
2862 the linker is run. */
2863
2864 /* Try to turn a 32bit pc-relative branch/call into a 16bit pc-relative
2865 branch/call, also deal with "call" -> "calls" conversions and
2866 insertion of prologue data into "call" instructions. */
2867 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL32
2868 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32)
2869 {
2870 bfd_vma value = symval;
2871
2872 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PLT32
2873 && h != NULL
2874 && ELF_ST_VISIBILITY (h->root.other) != STV_INTERNAL
2875 && ELF_ST_VISIBILITY (h->root.other) != STV_HIDDEN
2876 && h->root.plt.offset != (bfd_vma) -1)
2877 {
2878 asection * splt;
2879
2880 splt = bfd_get_section_by_name (elf_hash_table (link_info)
2881 ->dynobj, ".plt");
2882
2883 value = ((splt->output_section->vma
2884 + splt->output_offset
2885 + h->root.plt.offset)
2886 - (sec->output_section->vma
2887 + sec->output_offset
2888 + irel->r_offset));
2889 }
2890
2891 /* If we've got a "call" instruction that needs to be turned
2892 into a "calls" instruction, do so now. It saves a byte. */
2893 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
2894 {
2895 unsigned char code;
2896
2897 /* Get the opcode. */
2898 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2899
2900 /* Make sure we're working with a "call" instruction! */
2901 if (code == 0xdd)
2902 {
2903 /* Note that we've changed the relocs, section contents,
2904 etc. */
2905 elf_section_data (sec)->relocs = internal_relocs;
2906 elf_section_data (sec)->this_hdr.contents = contents;
2907 symtab_hdr->contents = (unsigned char *) isymbuf;
2908
2909 /* Fix the opcode. */
2910 bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 1);
2911 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
2912
2913 /* Fix irel->r_offset and irel->r_addend. */
2914 irel->r_offset += 1;
2915 irel->r_addend += 1;
2916
2917 /* Delete one byte of data. */
2918 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2919 irel->r_offset + 3, 1))
2920 goto error_return;
2921
2922 /* That will change things, so, we should relax again.
2923 Note that this is not required, and it may be slow. */
2924 *again = TRUE;
2925 }
2926 }
2927 else if (h)
2928 {
2929 /* We've got a "call" instruction which needs some data
2930 from target function filled in. */
2931 unsigned char code;
2932
2933 /* Get the opcode. */
2934 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2935
2936 /* Insert data from the target function into the "call"
2937 instruction if needed. */
2938 if (code == 0xdd)
2939 {
2940 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 4);
2941 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
2942 contents + irel->r_offset + 5);
2943 }
2944 }
2945
2946 /* Deal with pc-relative gunk. */
2947 value -= (sec->output_section->vma + sec->output_offset);
2948 value -= irel->r_offset;
2949 value += irel->r_addend;
2950
2951 /* See if the value will fit in 16 bits, note the high value is
2952 0x7fff + 2 as the target will be two bytes closer if we are
2953 able to relax, if it's in the same section. */
2954 if (sec->output_section == sym_sec->output_section)
2955 jump_offset = 0x8001;
2956 else
2957 jump_offset = 0x7fff;
2958
2959 /* Account for jumps across alignment boundaries using
2960 align_gap_adjustment. */
2961 if ((bfd_signed_vma) value < jump_offset - (bfd_signed_vma) align_gap_adjustment
2962 && ((bfd_signed_vma) value > -0x8000 + (bfd_signed_vma) align_gap_adjustment))
2963 {
2964 unsigned char code;
2965
2966 /* Get the opcode. */
2967 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
2968
2969 if (code != 0xdc && code != 0xdd && code != 0xff)
2970 continue;
2971
2972 /* Note that we've changed the relocs, section contents, etc. */
2973 elf_section_data (sec)->relocs = internal_relocs;
2974 elf_section_data (sec)->this_hdr.contents = contents;
2975 symtab_hdr->contents = (unsigned char *) isymbuf;
2976
2977 /* Fix the opcode. */
2978 if (code == 0xdc)
2979 bfd_put_8 (abfd, 0xcc, contents + irel->r_offset - 1);
2980 else if (code == 0xdd)
2981 bfd_put_8 (abfd, 0xcd, contents + irel->r_offset - 1);
2982 else if (code == 0xff)
2983 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
2984
2985 /* Fix the relocation's type. */
2986 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2987 (ELF32_R_TYPE (irel->r_info)
2988 == (int) R_MN10300_PLT32)
2989 ? R_MN10300_PLT16 :
2990 R_MN10300_PCREL16);
2991
2992 /* Delete two bytes of data. */
2993 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
2994 irel->r_offset + 1, 2))
2995 goto error_return;
2996
2997 /* That will change things, so, we should relax again.
2998 Note that this is not required, and it may be slow. */
2999 *again = TRUE;
3000 }
3001 }
3002
3003 /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
3004 branch. */
3005 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL16)
3006 {
3007 bfd_vma value = symval;
3008
3009 /* If we've got a "call" instruction that needs to be turned
3010 into a "calls" instruction, do so now. It saves a byte. */
3011 if (h && (h->flags & MN10300_CONVERT_CALL_TO_CALLS))
3012 {
3013 unsigned char code;
3014
3015 /* Get the opcode. */
3016 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3017
3018 /* Make sure we're working with a "call" instruction! */
3019 if (code == 0xcd)
3020 {
3021 /* Note that we've changed the relocs, section contents,
3022 etc. */
3023 elf_section_data (sec)->relocs = internal_relocs;
3024 elf_section_data (sec)->this_hdr.contents = contents;
3025 symtab_hdr->contents = (unsigned char *) isymbuf;
3026
3027 /* Fix the opcode. */
3028 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 1);
3029 bfd_put_8 (abfd, 0xff, contents + irel->r_offset);
3030
3031 /* Fix irel->r_offset and irel->r_addend. */
3032 irel->r_offset += 1;
3033 irel->r_addend += 1;
3034
3035 /* Delete one byte of data. */
3036 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3037 irel->r_offset + 1, 1))
3038 goto error_return;
3039
3040 /* That will change things, so, we should relax again.
3041 Note that this is not required, and it may be slow. */
3042 *again = TRUE;
3043 }
3044 }
3045 else if (h)
3046 {
3047 unsigned char code;
3048
3049 /* Get the opcode. */
3050 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3051
3052 /* Insert data from the target function into the "call"
3053 instruction if needed. */
3054 if (code == 0xcd)
3055 {
3056 bfd_put_8 (abfd, h->movm_args, contents + irel->r_offset + 2);
3057 bfd_put_8 (abfd, h->stack_size + h->movm_stack_size,
3058 contents + irel->r_offset + 3);
3059 }
3060 }
3061
3062 /* Deal with pc-relative gunk. */
3063 value -= (sec->output_section->vma + sec->output_offset);
3064 value -= irel->r_offset;
3065 value += irel->r_addend;
3066
3067 /* See if the value will fit in 8 bits, note the high value is
3068 0x7f + 1 as the target will be one bytes closer if we are
3069 able to relax. */
3070 if ((long) value < 0x80 && (long) value > -0x80)
3071 {
3072 unsigned char code;
3073
3074 /* Get the opcode. */
3075 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3076
3077 if (code != 0xcc)
3078 continue;
3079
3080 /* Note that we've changed the relocs, section contents, etc. */
3081 elf_section_data (sec)->relocs = internal_relocs;
3082 elf_section_data (sec)->this_hdr.contents = contents;
3083 symtab_hdr->contents = (unsigned char *) isymbuf;
3084
3085 /* Fix the opcode. */
3086 bfd_put_8 (abfd, 0xca, contents + irel->r_offset - 1);
3087
3088 /* Fix the relocation's type. */
3089 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3090 R_MN10300_PCREL8);
3091
3092 /* Delete one byte of data. */
3093 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3094 irel->r_offset + 1, 1))
3095 goto error_return;
3096
3097 /* That will change things, so, we should relax again.
3098 Note that this is not required, and it may be slow. */
3099 *again = TRUE;
3100 }
3101 }
3102
3103 /* Try to eliminate an unconditional 8 bit pc-relative branch
3104 which immediately follows a conditional 8 bit pc-relative
3105 branch around the unconditional branch.
3106
3107 original: new:
3108 bCC lab1 bCC' lab2
3109 bra lab2
3110 lab1: lab1:
3111
3112 This happens when the bCC can't reach lab2 at assembly time,
3113 but due to other relaxations it can reach at link time. */
3114 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_PCREL8)
3115 {
3116 Elf_Internal_Rela *nrel;
3117 bfd_vma value = symval;
3118 unsigned char code;
3119
3120 /* Deal with pc-relative gunk. */
3121 value -= (sec->output_section->vma + sec->output_offset);
3122 value -= irel->r_offset;
3123 value += irel->r_addend;
3124
3125 /* Do nothing if this reloc is the last byte in the section. */
3126 if (irel->r_offset == sec->size)
3127 continue;
3128
3129 /* See if the next instruction is an unconditional pc-relative
3130 branch, more often than not this test will fail, so we
3131 test it first to speed things up. */
3132 code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
3133 if (code != 0xca)
3134 continue;
3135
3136 /* Also make sure the next relocation applies to the next
3137 instruction and that it's a pc-relative 8 bit branch. */
3138 nrel = irel + 1;
3139 if (nrel == irelend
3140 || irel->r_offset + 2 != nrel->r_offset
3141 || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10300_PCREL8)
3142 continue;
3143
3144 /* Make sure our destination immediately follows the
3145 unconditional branch. */
3146 if (symval != (sec->output_section->vma + sec->output_offset
3147 + irel->r_offset + 3))
3148 continue;
3149
3150 /* Now make sure we are a conditional branch. This may not
3151 be necessary, but why take the chance.
3152
3153 Note these checks assume that R_MN10300_PCREL8 relocs
3154 only occur on bCC and bCCx insns. If they occured
3155 elsewhere, we'd need to know the start of this insn
3156 for this check to be accurate. */
3157 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3158 if (code != 0xc0 && code != 0xc1 && code != 0xc2
3159 && code != 0xc3 && code != 0xc4 && code != 0xc5
3160 && code != 0xc6 && code != 0xc7 && code != 0xc8
3161 && code != 0xc9 && code != 0xe8 && code != 0xe9
3162 && code != 0xea && code != 0xeb)
3163 continue;
3164
3165 /* We also have to be sure there is no symbol/label
3166 at the unconditional branch. */
3167 if (mn10300_elf_symbol_address_p (abfd, sec, isymbuf,
3168 irel->r_offset + 1))
3169 continue;
3170
3171 /* Note that we've changed the relocs, section contents, etc. */
3172 elf_section_data (sec)->relocs = internal_relocs;
3173 elf_section_data (sec)->this_hdr.contents = contents;
3174 symtab_hdr->contents = (unsigned char *) isymbuf;
3175
3176 /* Reverse the condition of the first branch. */
3177 switch (code)
3178 {
3179 case 0xc8:
3180 code = 0xc9;
3181 break;
3182 case 0xc9:
3183 code = 0xc8;
3184 break;
3185 case 0xc0:
3186 code = 0xc2;
3187 break;
3188 case 0xc2:
3189 code = 0xc0;
3190 break;
3191 case 0xc3:
3192 code = 0xc1;
3193 break;
3194 case 0xc1:
3195 code = 0xc3;
3196 break;
3197 case 0xc4:
3198 code = 0xc6;
3199 break;
3200 case 0xc6:
3201 code = 0xc4;
3202 break;
3203 case 0xc7:
3204 code = 0xc5;
3205 break;
3206 case 0xc5:
3207 code = 0xc7;
3208 break;
3209 case 0xe8:
3210 code = 0xe9;
3211 break;
3212 case 0x9d:
3213 code = 0xe8;
3214 break;
3215 case 0xea:
3216 code = 0xeb;
3217 break;
3218 case 0xeb:
3219 code = 0xea;
3220 break;
3221 }
3222 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3223
3224 /* Set the reloc type and symbol for the first branch
3225 from the second branch. */
3226 irel->r_info = nrel->r_info;
3227
3228 /* Make the reloc for the second branch a null reloc. */
3229 nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
3230 R_MN10300_NONE);
3231
3232 /* Delete two bytes of data. */
3233 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3234 irel->r_offset + 1, 2))
3235 goto error_return;
3236
3237 /* That will change things, so, we should relax again.
3238 Note that this is not required, and it may be slow. */
3239 *again = TRUE;
3240 }
3241
3242 /* Try to turn a 24 immediate, displacement or absolute address
3243 into a 8 immediate, displacement or absolute address. */
3244 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_24)
3245 {
3246 bfd_vma value = symval;
3247 value += irel->r_addend;
3248
3249 /* See if the value will fit in 8 bits. */
3250 if ((long) value < 0x7f && (long) value > -0x80)
3251 {
3252 unsigned char code;
3253
3254 /* AM33 insns which have 24 operands are 6 bytes long and
3255 will have 0xfd as the first byte. */
3256
3257 /* Get the first opcode. */
3258 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3259
3260 if (code == 0xfd)
3261 {
3262 /* Get the second opcode. */
3263 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3264
3265 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3266 equivalent instructions exists. */
3267 if (code != 0x6b && code != 0x7b
3268 && code != 0x8b && code != 0x9b
3269 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3270 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3271 || (code & 0x0f) == 0x0e))
3272 {
3273 /* Not safe if the high bit is on as relaxing may
3274 move the value out of high mem and thus not fit
3275 in a signed 8bit value. This is currently over
3276 conservative. */
3277 if ((value & 0x80) == 0)
3278 {
3279 /* Note that we've changed the relocation contents,
3280 etc. */
3281 elf_section_data (sec)->relocs = internal_relocs;
3282 elf_section_data (sec)->this_hdr.contents = contents;
3283 symtab_hdr->contents = (unsigned char *) isymbuf;
3284
3285 /* Fix the opcode. */
3286 bfd_put_8 (abfd, 0xfb, contents + irel->r_offset - 3);
3287 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3288
3289 /* Fix the relocation's type. */
3290 irel->r_info =
3291 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3292 R_MN10300_8);
3293
3294 /* Delete two bytes of data. */
3295 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3296 irel->r_offset + 1, 2))
3297 goto error_return;
3298
3299 /* That will change things, so, we should relax
3300 again. Note that this is not required, and it
3301 may be slow. */
3302 *again = TRUE;
3303 break;
3304 }
3305 }
3306 }
3307 }
3308 }
3309
3310 /* Try to turn a 32bit immediate, displacement or absolute address
3311 into a 16bit immediate, displacement or absolute address. */
3312 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_32
3313 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32
3314 || ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3315 {
3316 bfd_vma value = symval;
3317
3318 if (ELF32_R_TYPE (irel->r_info) != (int) R_MN10300_32)
3319 {
3320 asection * sgot;
3321
3322 sgot = bfd_get_section_by_name (elf_hash_table (link_info)
3323 ->dynobj, ".got");
3324
3325 if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOT32)
3326 {
3327 value = sgot->output_offset;
3328
3329 if (h)
3330 value += h->root.got.offset;
3331 else
3332 value += (elf_local_got_offsets
3333 (abfd)[ELF32_R_SYM (irel->r_info)]);
3334 }
3335 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTOFF32)
3336 value -= sgot->output_section->vma;
3337 else if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10300_GOTPC32)
3338 value = (sgot->output_section->vma
3339 - (sec->output_section->vma
3340 + sec->output_offset
3341 + irel->r_offset));
3342 else
3343 abort ();
3344 }
3345
3346 value += irel->r_addend;
3347
3348 /* See if the value will fit in 24 bits.
3349 We allow any 16bit match here. We prune those we can't
3350 handle below. */
3351 if ((long) value < 0x7fffff && (long) value > -0x800000)
3352 {
3353 unsigned char code;
3354
3355 /* AM33 insns which have 32bit operands are 7 bytes long and
3356 will have 0xfe as the first byte. */
3357
3358 /* Get the first opcode. */
3359 code = bfd_get_8 (abfd, contents + irel->r_offset - 3);
3360
3361 if (code == 0xfe)
3362 {
3363 /* Get the second opcode. */
3364 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3365
3366 /* All the am33 32 -> 24 relaxing possibilities. */
3367 /* We can not relax 0x6b, 0x7b, 0x8b, 0x9b as no 24bit
3368 equivalent instructions exists. */
3369 if (code != 0x6b && code != 0x7b
3370 && code != 0x8b && code != 0x9b
3371 && (ELF32_R_TYPE (irel->r_info)
3372 != (int) R_MN10300_GOTPC32)
3373 && ((code & 0x0f) == 0x09 || (code & 0x0f) == 0x08
3374 || (code & 0x0f) == 0x0a || (code & 0x0f) == 0x0b
3375 || (code & 0x0f) == 0x0e))
3376 {
3377 /* Not safe if the high bit is on as relaxing may
3378 move the value out of high mem and thus not fit
3379 in a signed 16bit value. This is currently over
3380 conservative. */
3381 if ((value & 0x8000) == 0)
3382 {
3383 /* Note that we've changed the relocation contents,
3384 etc. */
3385 elf_section_data (sec)->relocs = internal_relocs;
3386 elf_section_data (sec)->this_hdr.contents = contents;
3387 symtab_hdr->contents = (unsigned char *) isymbuf;
3388
3389 /* Fix the opcode. */
3390 bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 3);
3391 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3392
3393 /* Fix the relocation's type. */
3394 irel->r_info =
3395 ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3396 (ELF32_R_TYPE (irel->r_info)
3397 == (int) R_MN10300_GOTOFF32)
3398 ? R_MN10300_GOTOFF24
3399 : (ELF32_R_TYPE (irel->r_info)
3400 == (int) R_MN10300_GOT32)
3401 ? R_MN10300_GOT24 :
3402 R_MN10300_24);
3403
3404 /* Delete one byte of data. */
3405 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3406 irel->r_offset + 3, 1))
3407 goto error_return;
3408
3409 /* That will change things, so, we should relax
3410 again. Note that this is not required, and it
3411 may be slow. */
3412 *again = TRUE;
3413 break;
3414 }
3415 }
3416 }
3417 }
3418
3419 /* See if the value will fit in 16 bits.
3420 We allow any 16bit match here. We prune those we can't
3421 handle below. */
3422 if ((long) value < 0x7fff && (long) value > -0x8000)
3423 {
3424 unsigned char code;
3425
3426 /* Most insns which have 32bit operands are 6 bytes long;
3427 exceptions are pcrel insns and bit insns.
3428
3429 We handle pcrel insns above. We don't bother trying
3430 to handle the bit insns here.
3431
3432 The first byte of the remaining insns will be 0xfc. */
3433
3434 /* Get the first opcode. */
3435 code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
3436
3437 if (code != 0xfc)
3438 continue;
3439
3440 /* Get the second opcode. */
3441 code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
3442
3443 if ((code & 0xf0) < 0x80)
3444 switch (code & 0xf0)
3445 {
3446 /* mov (d32,am),dn -> mov (d32,am),dn
3447 mov dm,(d32,am) -> mov dn,(d32,am)
3448 mov (d32,am),an -> mov (d32,am),an
3449 mov dm,(d32,am) -> mov dn,(d32,am)
3450 movbu (d32,am),dn -> movbu (d32,am),dn
3451 movbu dm,(d32,am) -> movbu dn,(d32,am)
3452 movhu (d32,am),dn -> movhu (d32,am),dn
3453 movhu dm,(d32,am) -> movhu dn,(d32,am) */
3454 case 0x00:
3455 case 0x10:
3456 case 0x20:
3457 case 0x30:
3458 case 0x40:
3459 case 0x50:
3460 case 0x60:
3461 case 0x70:
3462 /* Not safe if the high bit is on as relaxing may
3463 move the value out of high mem and thus not fit
3464 in a signed 16bit value. */
3465 if (code == 0xcc
3466 && (value & 0x8000))
3467 continue;
3468
3469 /* Note that we've changed the relocation contents, etc. */
3470 elf_section_data (sec)->relocs = internal_relocs;
3471 elf_section_data (sec)->this_hdr.contents = contents;
3472 symtab_hdr->contents = (unsigned char *) isymbuf;
3473
3474 /* Fix the opcode. */
3475 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3476 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3477
3478 /* Fix the relocation's type. */
3479 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3480 (ELF32_R_TYPE (irel->r_info)
3481 == (int) R_MN10300_GOTOFF32)
3482 ? R_MN10300_GOTOFF16
3483 : (ELF32_R_TYPE (irel->r_info)
3484 == (int) R_MN10300_GOT32)
3485 ? R_MN10300_GOT16
3486 : (ELF32_R_TYPE (irel->r_info)
3487 == (int) R_MN10300_GOTPC32)
3488 ? R_MN10300_GOTPC16 :
3489 R_MN10300_16);
3490
3491 /* Delete two bytes of data. */
3492 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3493 irel->r_offset + 2, 2))
3494 goto error_return;
3495
3496 /* That will change things, so, we should relax again.
3497 Note that this is not required, and it may be slow. */
3498 *again = TRUE;
3499 break;
3500 }
3501 else if ((code & 0xf0) == 0x80
3502 || (code & 0xf0) == 0x90)
3503 switch (code & 0xf3)
3504 {
3505 /* mov dn,(abs32) -> mov dn,(abs16)
3506 movbu dn,(abs32) -> movbu dn,(abs16)
3507 movhu dn,(abs32) -> movhu dn,(abs16) */
3508 case 0x81:
3509 case 0x82:
3510 case 0x83:
3511 /* Note that we've changed the relocation contents, etc. */
3512 elf_section_data (sec)->relocs = internal_relocs;
3513 elf_section_data (sec)->this_hdr.contents = contents;
3514 symtab_hdr->contents = (unsigned char *) isymbuf;
3515
3516 if ((code & 0xf3) == 0x81)
3517 code = 0x01 + (code & 0x0c);
3518 else if ((code & 0xf3) == 0x82)
3519 code = 0x02 + (code & 0x0c);
3520 else if ((code & 0xf3) == 0x83)
3521 code = 0x03 + (code & 0x0c);
3522 else
3523 abort ();
3524
3525 /* Fix the opcode. */
3526 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3527
3528 /* Fix the relocation's type. */
3529 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3530 (ELF32_R_TYPE (irel->r_info)
3531 == (int) R_MN10300_GOTOFF32)
3532 ? R_MN10300_GOTOFF16
3533 : (ELF32_R_TYPE (irel->r_info)
3534 == (int) R_MN10300_GOT32)
3535 ? R_MN10300_GOT16
3536 : (ELF32_R_TYPE (irel->r_info)
3537 == (int) R_MN10300_GOTPC32)
3538 ? R_MN10300_GOTPC16 :
3539 R_MN10300_16);
3540
3541 /* The opcode got shorter too, so we have to fix the
3542 addend and offset too! */
3543 irel->r_offset -= 1;
3544
3545 /* Delete three bytes of data. */
3546 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3547 irel->r_offset + 1, 3))
3548 goto error_return;
3549
3550 /* That will change things, so, we should relax again.
3551 Note that this is not required, and it may be slow. */
3552 *again = TRUE;
3553 break;
3554
3555 /* mov am,(abs32) -> mov am,(abs16)
3556 mov am,(d32,sp) -> mov am,(d16,sp)
3557 mov dm,(d32,sp) -> mov dm,(d32,sp)
3558 movbu dm,(d32,sp) -> movbu dm,(d32,sp)
3559 movhu dm,(d32,sp) -> movhu dm,(d32,sp) */
3560 case 0x80:
3561 case 0x90:
3562 case 0x91:
3563 case 0x92:
3564 case 0x93:
3565 /* sp-based offsets are zero-extended. */
3566 if (code >= 0x90 && code <= 0x93
3567 && (long) value < 0)
3568 continue;
3569
3570 /* Note that we've changed the relocation contents, etc. */
3571 elf_section_data (sec)->relocs = internal_relocs;
3572 elf_section_data (sec)->this_hdr.contents = contents;
3573 symtab_hdr->contents = (unsigned char *) isymbuf;
3574
3575 /* Fix the opcode. */
3576 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3577 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3578
3579 /* Fix the relocation's type. */
3580 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3581 (ELF32_R_TYPE (irel->r_info)
3582 == (int) R_MN10300_GOTOFF32)
3583 ? R_MN10300_GOTOFF16
3584 : (ELF32_R_TYPE (irel->r_info)
3585 == (int) R_MN10300_GOT32)
3586 ? R_MN10300_GOT16
3587 : (ELF32_R_TYPE (irel->r_info)
3588 == (int) R_MN10300_GOTPC32)
3589 ? R_MN10300_GOTPC16 :
3590 R_MN10300_16);
3591
3592 /* Delete two bytes of data. */
3593 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3594 irel->r_offset + 2, 2))
3595 goto error_return;
3596
3597 /* That will change things, so, we should relax again.
3598 Note that this is not required, and it may be slow. */
3599 *again = TRUE;
3600 break;
3601 }
3602 else if ((code & 0xf0) < 0xf0)
3603 switch (code & 0xfc)
3604 {
3605 /* mov imm32,dn -> mov imm16,dn
3606 mov imm32,an -> mov imm16,an
3607 mov (abs32),dn -> mov (abs16),dn
3608 movbu (abs32),dn -> movbu (abs16),dn
3609 movhu (abs32),dn -> movhu (abs16),dn */
3610 case 0xcc:
3611 case 0xdc:
3612 case 0xa4:
3613 case 0xa8:
3614 case 0xac:
3615 /* Not safe if the high bit is on as relaxing may
3616 move the value out of high mem and thus not fit
3617 in a signed 16bit value. */
3618 if (code == 0xcc
3619 && (value & 0x8000))
3620 continue;
3621
3622 /* mov imm16, an zero-extends the immediate. */
3623 if (code == 0xdc
3624 && (long) value < 0)
3625 continue;
3626
3627 /* Note that we've changed the relocation contents, etc. */
3628 elf_section_data (sec)->relocs = internal_relocs;
3629 elf_section_data (sec)->this_hdr.contents = contents;
3630 symtab_hdr->contents = (unsigned char *) isymbuf;
3631
3632 if ((code & 0xfc) == 0xcc)
3633 code = 0x2c + (code & 0x03);
3634 else if ((code & 0xfc) == 0xdc)
3635 code = 0x24 + (code & 0x03);
3636 else if ((code & 0xfc) == 0xa4)
3637 code = 0x30 + (code & 0x03);
3638 else if ((code & 0xfc) == 0xa8)
3639 code = 0x34 + (code & 0x03);
3640 else if ((code & 0xfc) == 0xac)
3641 code = 0x38 + (code & 0x03);
3642 else
3643 abort ();
3644
3645 /* Fix the opcode. */
3646 bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
3647
3648 /* Fix the relocation's type. */
3649 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3650 (ELF32_R_TYPE (irel->r_info)
3651 == (int) R_MN10300_GOTOFF32)
3652 ? R_MN10300_GOTOFF16
3653 : (ELF32_R_TYPE (irel->r_info)
3654 == (int) R_MN10300_GOT32)
3655 ? R_MN10300_GOT16
3656 : (ELF32_R_TYPE (irel->r_info)
3657 == (int) R_MN10300_GOTPC32)
3658 ? R_MN10300_GOTPC16 :
3659 R_MN10300_16);
3660
3661 /* The opcode got shorter too, so we have to fix the
3662 addend and offset too! */
3663 irel->r_offset -= 1;
3664
3665 /* Delete three bytes of data. */
3666 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3667 irel->r_offset + 1, 3))
3668 goto error_return;
3669
3670 /* That will change things, so, we should relax again.
3671 Note that this is not required, and it may be slow. */
3672 *again = TRUE;
3673 break;
3674
3675 /* mov (abs32),an -> mov (abs16),an
3676 mov (d32,sp),an -> mov (d16,sp),an
3677 mov (d32,sp),dn -> mov (d16,sp),dn
3678 movbu (d32,sp),dn -> movbu (d16,sp),dn
3679 movhu (d32,sp),dn -> movhu (d16,sp),dn
3680 add imm32,dn -> add imm16,dn
3681 cmp imm32,dn -> cmp imm16,dn
3682 add imm32,an -> add imm16,an
3683 cmp imm32,an -> cmp imm16,an
3684 and imm32,dn -> and imm16,dn
3685 or imm32,dn -> or imm16,dn
3686 xor imm32,dn -> xor imm16,dn
3687 btst imm32,dn -> btst imm16,dn */
3688
3689 case 0xa0:
3690 case 0xb0:
3691 case 0xb1:
3692 case 0xb2:
3693 case 0xb3:
3694 case 0xc0:
3695 case 0xc8:
3696
3697 case 0xd0:
3698 case 0xd8:
3699 case 0xe0:
3700 case 0xe1:
3701 case 0xe2:
3702 case 0xe3:
3703 /* cmp imm16, an zero-extends the immediate. */
3704 if (code == 0xdc
3705 && (long) value < 0)
3706 continue;
3707
3708 /* So do sp-based offsets. */
3709 if (code >= 0xb0 && code <= 0xb3
3710 && (long) value < 0)
3711 continue;
3712
3713 /* Note that we've changed the relocation contents, etc. */
3714 elf_section_data (sec)->relocs = internal_relocs;
3715 elf_section_data (sec)->this_hdr.contents = contents;
3716 symtab_hdr->contents = (unsigned char *) isymbuf;
3717
3718 /* Fix the opcode. */
3719 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3720 bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
3721
3722 /* Fix the relocation's type. */
3723 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3724 (ELF32_R_TYPE (irel->r_info)
3725 == (int) R_MN10300_GOTOFF32)
3726 ? R_MN10300_GOTOFF16
3727 : (ELF32_R_TYPE (irel->r_info)
3728 == (int) R_MN10300_GOT32)
3729 ? R_MN10300_GOT16
3730 : (ELF32_R_TYPE (irel->r_info)
3731 == (int) R_MN10300_GOTPC32)
3732 ? R_MN10300_GOTPC16 :
3733 R_MN10300_16);
3734
3735 /* Delete two bytes of data. */
3736 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3737 irel->r_offset + 2, 2))
3738 goto error_return;
3739
3740 /* That will change things, so, we should relax again.
3741 Note that this is not required, and it may be slow. */
3742 *again = TRUE;
3743 break;
3744 }
3745 else if (code == 0xfe)
3746 {
3747 /* add imm32,sp -> add imm16,sp */
3748
3749 /* Note that we've changed the relocation contents, etc. */
3750 elf_section_data (sec)->relocs = internal_relocs;
3751 elf_section_data (sec)->this_hdr.contents = contents;
3752 symtab_hdr->contents = (unsigned char *) isymbuf;
3753
3754 /* Fix the opcode. */
3755 bfd_put_8 (abfd, 0xfa, contents + irel->r_offset - 2);
3756 bfd_put_8 (abfd, 0xfe, contents + irel->r_offset - 1);
3757
3758 /* Fix the relocation's type. */
3759 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3760 (ELF32_R_TYPE (irel->r_info)
3761 == (int) R_MN10300_GOT32)
3762 ? R_MN10300_GOT16
3763 : (ELF32_R_TYPE (irel->r_info)
3764 == (int) R_MN10300_GOTOFF32)
3765 ? R_MN10300_GOTOFF16
3766 : (ELF32_R_TYPE (irel->r_info)
3767 == (int) R_MN10300_GOTPC32)
3768 ? R_MN10300_GOTPC16 :
3769 R_MN10300_16);
3770
3771 /* Delete two bytes of data. */
3772 if (!mn10300_elf_relax_delete_bytes (abfd, sec,
3773 irel->r_offset + 2, 2))
3774 goto error_return;
3775
3776 /* That will change things, so, we should relax again.
3777 Note that this is not required, and it may be slow. */
3778 *again = TRUE;
3779 break;
3780 }
3781 }
3782 }
3783 }
3784
3785 if (isymbuf != NULL
3786 && symtab_hdr->contents != (unsigned char *) isymbuf)
3787 {
3788 if (! link_info->keep_memory)
3789 free (isymbuf);
3790 else
3791 {
3792 /* Cache the symbols for elf_link_input_bfd. */
3793 symtab_hdr->contents = (unsigned char *) isymbuf;
3794 }
3795 }
3796
3797 if (contents != NULL
3798 && elf_section_data (sec)->this_hdr.contents != contents)
3799 {
3800 if (! link_info->keep_memory)
3801 free (contents);
3802 else
3803 {
3804 /* Cache the section contents for elf_link_input_bfd. */
3805 elf_section_data (sec)->this_hdr.contents = contents;
3806 }
3807 }
3808
3809 if (internal_relocs != NULL
3810 && elf_section_data (sec)->relocs != internal_relocs)
3811 free (internal_relocs);
3812
3813 return TRUE;
3814
3815 error_return:
3816 if (isymbuf != NULL
3817 && symtab_hdr->contents != (unsigned char *) isymbuf)
3818 free (isymbuf);
3819 if (contents != NULL
3820 && elf_section_data (section)->this_hdr.contents != contents)
3821 free (contents);
3822 if (internal_relocs != NULL
3823 && elf_section_data (section)->relocs != internal_relocs)
3824 free (internal_relocs);
3825
3826 return FALSE;
3827 }
3828
3829 /* This is a version of bfd_generic_get_relocated_section_contents
3830 which uses mn10300_elf_relocate_section. */
3831
3832 static bfd_byte *
3833 mn10300_elf_get_relocated_section_contents (bfd *output_bfd,
3834 struct bfd_link_info *link_info,
3835 struct bfd_link_order *link_order,
3836 bfd_byte *data,
3837 bfd_boolean relocatable,
3838 asymbol **symbols)
3839 {
3840 Elf_Internal_Shdr *symtab_hdr;
3841 asection *input_section = link_order->u.indirect.section;
3842 bfd *input_bfd = input_section->owner;
3843 asection **sections = NULL;
3844 Elf_Internal_Rela *internal_relocs = NULL;
3845 Elf_Internal_Sym *isymbuf = NULL;
3846
3847 /* We only need to handle the case of relaxing, or of having a
3848 particular set of section contents, specially. */
3849 if (relocatable
3850 || elf_section_data (input_section)->this_hdr.contents == NULL)
3851 return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
3852 link_order, data,
3853 relocatable,
3854 symbols);
3855
3856 symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
3857
3858 memcpy (data, elf_section_data (input_section)->this_hdr.contents,
3859 (size_t) input_section->size);
3860
3861 if ((input_section->flags & SEC_RELOC) != 0
3862 && input_section->reloc_count > 0)
3863 {
3864 asection **secpp;
3865 Elf_Internal_Sym *isym, *isymend;
3866 bfd_size_type amt;
3867
3868 internal_relocs = _bfd_elf_link_read_relocs (input_bfd, input_section,
3869 NULL, NULL, FALSE);
3870 if (internal_relocs == NULL)
3871 goto error_return;
3872
3873 if (symtab_hdr->sh_info != 0)
3874 {
3875 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3876 if (isymbuf == NULL)
3877 isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
3878 symtab_hdr->sh_info, 0,
3879 NULL, NULL, NULL);
3880 if (isymbuf == NULL)
3881 goto error_return;
3882 }
3883
3884 amt = symtab_hdr->sh_info;
3885 amt *= sizeof (asection *);
3886 sections = bfd_malloc (amt);
3887 if (sections == NULL && amt != 0)
3888 goto error_return;
3889
3890 isymend = isymbuf + symtab_hdr->sh_info;
3891 for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
3892 {
3893 asection *isec;
3894
3895 if (isym->st_shndx == SHN_UNDEF)
3896 isec = bfd_und_section_ptr;
3897 else if (isym->st_shndx == SHN_ABS)
3898 isec = bfd_abs_section_ptr;
3899 else if (isym->st_shndx == SHN_COMMON)
3900 isec = bfd_com_section_ptr;
3901 else
3902 isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
3903
3904 *secpp = isec;
3905 }
3906
3907 if (! mn10300_elf_relocate_section (output_bfd, link_info, input_bfd,
3908 input_section, data, internal_relocs,
3909 isymbuf, sections))
3910 goto error_return;
3911
3912 if (sections != NULL)
3913 free (sections);
3914 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3915 free (isymbuf);
3916 if (internal_relocs != elf_section_data (input_section)->relocs)
3917 free (internal_relocs);
3918 }
3919
3920 return data;
3921
3922 error_return:
3923 if (sections != NULL)
3924 free (sections);
3925 if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
3926 free (isymbuf);
3927 if (internal_relocs != NULL
3928 && internal_relocs != elf_section_data (input_section)->relocs)
3929 free (internal_relocs);
3930 return NULL;
3931 }
3932
3933 /* Assorted hash table functions. */
3934
3935 /* Initialize an entry in the link hash table. */
3936
3937 /* Create an entry in an MN10300 ELF linker hash table. */
3938
3939 static struct bfd_hash_entry *
3940 elf32_mn10300_link_hash_newfunc (struct bfd_hash_entry *entry,
3941 struct bfd_hash_table *table,
3942 const char *string)
3943 {
3944 struct elf32_mn10300_link_hash_entry *ret =
3945 (struct elf32_mn10300_link_hash_entry *) entry;
3946
3947 /* Allocate the structure if it has not already been allocated by a
3948 subclass. */
3949 if (ret == NULL)
3950 ret = (struct elf32_mn10300_link_hash_entry *)
3951 bfd_hash_allocate (table, sizeof (* ret));
3952 if (ret == NULL)
3953 return (struct bfd_hash_entry *) ret;
3954
3955 /* Call the allocation method of the superclass. */
3956 ret = (struct elf32_mn10300_link_hash_entry *)
3957 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
3958 table, string);
3959 if (ret != NULL)
3960 {
3961 ret->direct_calls = 0;
3962 ret->stack_size = 0;
3963 ret->movm_args = 0;
3964 ret->movm_stack_size = 0;
3965 ret->flags = 0;
3966 ret->value = 0;
3967 }
3968
3969 return (struct bfd_hash_entry *) ret;
3970 }
3971
3972 /* Create an mn10300 ELF linker hash table. */
3973
3974 static struct bfd_link_hash_table *
3975 elf32_mn10300_link_hash_table_create (bfd *abfd)
3976 {
3977 struct elf32_mn10300_link_hash_table *ret;
3978 bfd_size_type amt = sizeof (* ret);
3979
3980 ret = bfd_malloc (amt);
3981 if (ret == NULL)
3982 return NULL;
3983
3984 if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
3985 elf32_mn10300_link_hash_newfunc,
3986 sizeof (struct elf32_mn10300_link_hash_entry)))
3987 {
3988 free (ret);
3989 return NULL;
3990 }
3991
3992 ret->flags = 0;
3993 amt = sizeof (struct elf_link_hash_table);
3994 ret->static_hash_table = bfd_malloc (amt);
3995 if (ret->static_hash_table == NULL)
3996 {
3997 free (ret);
3998 return NULL;
3999 }
4000
4001 if (!_bfd_elf_link_hash_table_init (&ret->static_hash_table->root, abfd,
4002 elf32_mn10300_link_hash_newfunc,
4003 sizeof (struct elf32_mn10300_link_hash_entry)))
4004 {
4005 free (ret->static_hash_table);
4006 free (ret);
4007 return NULL;
4008 }
4009 return & ret->root.root;
4010 }
4011
4012 /* Free an mn10300 ELF linker hash table. */
4013
4014 static void
4015 elf32_mn10300_link_hash_table_free (struct bfd_link_hash_table *hash)
4016 {
4017 struct elf32_mn10300_link_hash_table *ret
4018 = (struct elf32_mn10300_link_hash_table *) hash;
4019
4020 _bfd_generic_link_hash_table_free
4021 ((struct bfd_link_hash_table *) ret->static_hash_table);
4022 _bfd_generic_link_hash_table_free
4023 ((struct bfd_link_hash_table *) ret);
4024 }
4025
4026 static unsigned long
4027 elf_mn10300_mach (flagword flags)
4028 {
4029 switch (flags & EF_MN10300_MACH)
4030 {
4031 case E_MN10300_MACH_MN10300:
4032 default:
4033 return bfd_mach_mn10300;
4034
4035 case E_MN10300_MACH_AM33:
4036 return bfd_mach_am33;
4037
4038 case E_MN10300_MACH_AM33_2:
4039 return bfd_mach_am33_2;
4040 }
4041 }
4042
4043 /* The final processing done just before writing out a MN10300 ELF object
4044 file. This gets the MN10300 architecture right based on the machine
4045 number. */
4046
4047 static void
4048 _bfd_mn10300_elf_final_write_processing (bfd *abfd,
4049 bfd_boolean linker ATTRIBUTE_UNUSED)
4050 {
4051 unsigned long val;
4052
4053 switch (bfd_get_mach (abfd))
4054 {
4055 default:
4056 case bfd_mach_mn10300:
4057 val = E_MN10300_MACH_MN10300;
4058 break;
4059
4060 case bfd_mach_am33:
4061 val = E_MN10300_MACH_AM33;
4062 break;
4063
4064 case bfd_mach_am33_2:
4065 val = E_MN10300_MACH_AM33_2;
4066 break;
4067 }
4068
4069 elf_elfheader (abfd)->e_flags &= ~ (EF_MN10300_MACH);
4070 elf_elfheader (abfd)->e_flags |= val;
4071 }
4072
4073 static bfd_boolean
4074 _bfd_mn10300_elf_object_p (bfd *abfd)
4075 {
4076 bfd_default_set_arch_mach (abfd, bfd_arch_mn10300,
4077 elf_mn10300_mach (elf_elfheader (abfd)->e_flags));
4078 return TRUE;
4079 }
4080
4081 /* Merge backend specific data from an object file to the output
4082 object file when linking. */
4083
4084 static bfd_boolean
4085 _bfd_mn10300_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4086 {
4087 if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4088 || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4089 return TRUE;
4090
4091 if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
4092 && bfd_get_mach (obfd) < bfd_get_mach (ibfd))
4093 {
4094 if (! bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
4095 bfd_get_mach (ibfd)))
4096 return FALSE;
4097 }
4098
4099 return TRUE;
4100 }
4101
4102 #define PLT0_ENTRY_SIZE 15
4103 #define PLT_ENTRY_SIZE 20
4104 #define PIC_PLT_ENTRY_SIZE 24
4105
4106 static const bfd_byte elf_mn10300_plt0_entry[PLT0_ENTRY_SIZE] =
4107 {
4108 0xfc, 0xa0, 0, 0, 0, 0, /* mov (.got+8),a0 */
4109 0xfe, 0xe, 0x10, 0, 0, 0, 0, /* mov (.got+4),r1 */
4110 0xf0, 0xf4, /* jmp (a0) */
4111 };
4112
4113 static const bfd_byte elf_mn10300_plt_entry[PLT_ENTRY_SIZE] =
4114 {
4115 0xfc, 0xa0, 0, 0, 0, 0, /* mov (nameN@GOT + .got),a0 */
4116 0xf0, 0xf4, /* jmp (a0) */
4117 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4118 0xdc, 0, 0, 0, 0, /* jmp .plt0 */
4119 };
4120
4121 static const bfd_byte elf_mn10300_pic_plt_entry[PIC_PLT_ENTRY_SIZE] =
4122 {
4123 0xfc, 0x22, 0, 0, 0, 0, /* mov (nameN@GOT,a2),a0 */
4124 0xf0, 0xf4, /* jmp (a0) */
4125 0xfe, 8, 0, 0, 0, 0, 0, /* mov reloc-table-address,r0 */
4126 0xf8, 0x22, 8, /* mov (8,a2),a0 */
4127 0xfb, 0xa, 0x1a, 4, /* mov (4,a2),r1 */
4128 0xf0, 0xf4, /* jmp (a0) */
4129 };
4130
4131 /* Return size of the first PLT entry. */
4132 #define elf_mn10300_sizeof_plt0(info) \
4133 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT0_ENTRY_SIZE)
4134
4135 /* Return size of a PLT entry. */
4136 #define elf_mn10300_sizeof_plt(info) \
4137 (info->shared ? PIC_PLT_ENTRY_SIZE : PLT_ENTRY_SIZE)
4138
4139 /* Return offset of the PLT0 address in an absolute PLT entry. */
4140 #define elf_mn10300_plt_plt0_offset(info) 16
4141
4142 /* Return offset of the linker in PLT0 entry. */
4143 #define elf_mn10300_plt0_linker_offset(info) 2
4144
4145 /* Return offset of the GOT id in PLT0 entry. */
4146 #define elf_mn10300_plt0_gotid_offset(info) 9
4147
4148 /* Return offset of the temporary in PLT entry. */
4149 #define elf_mn10300_plt_temp_offset(info) 8
4150
4151 /* Return offset of the symbol in PLT entry. */
4152 #define elf_mn10300_plt_symbol_offset(info) 2
4153
4154 /* Return offset of the relocation in PLT entry. */
4155 #define elf_mn10300_plt_reloc_offset(info) 11
4156
4157 /* The name of the dynamic interpreter. This is put in the .interp
4158 section. */
4159
4160 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
4161
4162 /* Create dynamic sections when linking against a dynamic object. */
4163
4164 static bfd_boolean
4165 _bfd_mn10300_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4166 {
4167 flagword flags;
4168 asection * s;
4169 const struct elf_backend_data * bed = get_elf_backend_data (abfd);
4170 int ptralign = 0;
4171
4172 switch (bed->s->arch_size)
4173 {
4174 case 32:
4175 ptralign = 2;
4176 break;
4177
4178 case 64:
4179 ptralign = 3;
4180 break;
4181
4182 default:
4183 bfd_set_error (bfd_error_bad_value);
4184 return FALSE;
4185 }
4186
4187 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4188 .rel[a].bss sections. */
4189 flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4190 | SEC_LINKER_CREATED);
4191
4192 s = bfd_make_section_with_flags (abfd,
4193 (bed->default_use_rela_p
4194 ? ".rela.plt" : ".rel.plt"),
4195 flags | SEC_READONLY);
4196 if (s == NULL
4197 || ! bfd_set_section_alignment (abfd, s, ptralign))
4198 return FALSE;
4199
4200 if (! _bfd_mn10300_elf_create_got_section (abfd, info))
4201 return FALSE;
4202
4203 {
4204 const char * secname;
4205 char * relname;
4206 flagword secflags;
4207 asection * sec;
4208
4209 for (sec = abfd->sections; sec; sec = sec->next)
4210 {
4211 secflags = bfd_get_section_flags (abfd, sec);
4212 if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
4213 || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
4214 continue;
4215
4216 secname = bfd_get_section_name (abfd, sec);
4217 relname = bfd_malloc (strlen (secname) + 6);
4218 strcpy (relname, ".rela");
4219 strcat (relname, secname);
4220
4221 s = bfd_make_section_with_flags (abfd, relname,
4222 flags | SEC_READONLY);
4223 if (s == NULL
4224 || ! bfd_set_section_alignment (abfd, s, ptralign))
4225 return FALSE;
4226 }
4227 }
4228
4229 if (bed->want_dynbss)
4230 {
4231 /* The .dynbss section is a place to put symbols which are defined
4232 by dynamic objects, are referenced by regular objects, and are
4233 not functions. We must allocate space for them in the process
4234 image and use a R_*_COPY reloc to tell the dynamic linker to
4235 initialize them at run time. The linker script puts the .dynbss
4236 section into the .bss section of the final image. */
4237 s = bfd_make_section_with_flags (abfd, ".dynbss",
4238 SEC_ALLOC | SEC_LINKER_CREATED);
4239 if (s == NULL)
4240 return FALSE;
4241
4242 /* The .rel[a].bss section holds copy relocs. This section is not
4243 normally needed. We need to create it here, though, so that the
4244 linker will map it to an output section. We can't just create it
4245 only if we need it, because we will not know whether we need it
4246 until we have seen all the input files, and the first time the
4247 main linker code calls BFD after examining all the input files
4248 (size_dynamic_sections) the input sections have already been
4249 mapped to the output sections. If the section turns out not to
4250 be needed, we can discard it later. We will never need this
4251 section when generating a shared object, since they do not use
4252 copy relocs. */
4253 if (! info->shared)
4254 {
4255 s = bfd_make_section_with_flags (abfd,
4256 (bed->default_use_rela_p
4257 ? ".rela.bss" : ".rel.bss"),
4258 flags | SEC_READONLY);
4259 if (s == NULL
4260 || ! bfd_set_section_alignment (abfd, s, ptralign))
4261 return FALSE;
4262 }
4263 }
4264
4265 return TRUE;
4266 }
4267 \f
4268 /* Adjust a symbol defined by a dynamic object and referenced by a
4269 regular object. The current definition is in some section of the
4270 dynamic object, but we're not including those sections. We have to
4271 change the definition to something the rest of the link can
4272 understand. */
4273
4274 static bfd_boolean
4275 _bfd_mn10300_elf_adjust_dynamic_symbol (struct bfd_link_info * info,
4276 struct elf_link_hash_entry * h)
4277 {
4278 bfd * dynobj;
4279 asection * s;
4280
4281 dynobj = elf_hash_table (info)->dynobj;
4282
4283 /* Make sure we know what is going on here. */
4284 BFD_ASSERT (dynobj != NULL
4285 && (h->needs_plt
4286 || h->u.weakdef != NULL
4287 || (h->def_dynamic
4288 && h->ref_regular
4289 && !h->def_regular)));
4290
4291 /* If this is a function, put it in the procedure linkage table. We
4292 will fill in the contents of the procedure linkage table later,
4293 when we know the address of the .got section. */
4294 if (h->type == STT_FUNC
4295 || h->needs_plt)
4296 {
4297 if (! info->shared
4298 && !h->def_dynamic
4299 && !h->ref_dynamic)
4300 {
4301 /* This case can occur if we saw a PLT reloc in an input
4302 file, but the symbol was never referred to by a dynamic
4303 object. In such a case, we don't actually need to build
4304 a procedure linkage table, and we can just do a REL32
4305 reloc instead. */
4306 BFD_ASSERT (h->needs_plt);
4307 return TRUE;
4308 }
4309
4310 /* Make sure this symbol is output as a dynamic symbol. */
4311 if (h->dynindx == -1)
4312 {
4313 if (! bfd_elf_link_record_dynamic_symbol (info, h))
4314 return FALSE;
4315 }
4316
4317 s = bfd_get_section_by_name (dynobj, ".plt");
4318 BFD_ASSERT (s != NULL);
4319
4320 /* If this is the first .plt entry, make room for the special
4321 first entry. */
4322 if (s->size == 0)
4323 s->size += elf_mn10300_sizeof_plt0 (info);
4324
4325 /* If this symbol is not defined in a regular file, and we are
4326 not generating a shared library, then set the symbol to this
4327 location in the .plt. This is required to make function
4328 pointers compare as equal between the normal executable and
4329 the shared library. */
4330 if (! info->shared
4331 && !h->def_regular)
4332 {
4333 h->root.u.def.section = s;
4334 h->root.u.def.value = s->size;
4335 }
4336
4337 h->plt.offset = s->size;
4338
4339 /* Make room for this entry. */
4340 s->size += elf_mn10300_sizeof_plt (info);
4341
4342 /* We also need to make an entry in the .got.plt section, which
4343 will be placed in the .got section by the linker script. */
4344 s = bfd_get_section_by_name (dynobj, ".got.plt");
4345 BFD_ASSERT (s != NULL);
4346 s->size += 4;
4347
4348 /* We also need to make an entry in the .rela.plt section. */
4349 s = bfd_get_section_by_name (dynobj, ".rela.plt");
4350 BFD_ASSERT (s != NULL);
4351 s->size += sizeof (Elf32_External_Rela);
4352
4353 return TRUE;
4354 }
4355
4356 /* If this is a weak symbol, and there is a real definition, the
4357 processor independent code will have arranged for us to see the
4358 real definition first, and we can just use the same value. */
4359 if (h->u.weakdef != NULL)
4360 {
4361 BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4362 || h->u.weakdef->root.type == bfd_link_hash_defweak);
4363 h->root.u.def.section = h->u.weakdef->root.u.def.section;
4364 h->root.u.def.value = h->u.weakdef->root.u.def.value;
4365 return TRUE;
4366 }
4367
4368 /* This is a reference to a symbol defined by a dynamic object which
4369 is not a function. */
4370
4371 /* If we are creating a shared library, we must presume that the
4372 only references to the symbol are via the global offset table.
4373 For such cases we need not do anything here; the relocations will
4374 be handled correctly by relocate_section. */
4375 if (info->shared)
4376 return TRUE;
4377
4378 /* If there are no references to this symbol that do not use the
4379 GOT, we don't need to generate a copy reloc. */
4380 if (!h->non_got_ref)
4381 return TRUE;
4382
4383 if (h->size == 0)
4384 {
4385 (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
4386 h->root.root.string);
4387 return TRUE;
4388 }
4389
4390 /* We must allocate the symbol in our .dynbss section, which will
4391 become part of the .bss section of the executable. There will be
4392 an entry for this symbol in the .dynsym section. The dynamic
4393 object will contain position independent code, so all references
4394 from the dynamic object to this symbol will go through the global
4395 offset table. The dynamic linker will use the .dynsym entry to
4396 determine the address it must put in the global offset table, so
4397 both the dynamic object and the regular object will refer to the
4398 same memory location for the variable. */
4399
4400 s = bfd_get_section_by_name (dynobj, ".dynbss");
4401 BFD_ASSERT (s != NULL);
4402
4403 /* We must generate a R_MN10300_COPY reloc to tell the dynamic linker to
4404 copy the initial value out of the dynamic object and into the
4405 runtime process image. We need to remember the offset into the
4406 .rela.bss section we are going to use. */
4407 if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
4408 {
4409 asection * srel;
4410
4411 srel = bfd_get_section_by_name (dynobj, ".rela.bss");
4412 BFD_ASSERT (srel != NULL);
4413 srel->size += sizeof (Elf32_External_Rela);
4414 h->needs_copy = 1;
4415 }
4416
4417 return _bfd_elf_adjust_dynamic_copy (h, s);
4418 }
4419
4420 /* Set the sizes of the dynamic sections. */
4421
4422 static bfd_boolean
4423 _bfd_mn10300_elf_size_dynamic_sections (bfd * output_bfd,
4424 struct bfd_link_info * info)
4425 {
4426 bfd * dynobj;
4427 asection * s;
4428 bfd_boolean plt;
4429 bfd_boolean relocs;
4430 bfd_boolean reltext;
4431
4432 dynobj = elf_hash_table (info)->dynobj;
4433 BFD_ASSERT (dynobj != NULL);
4434
4435 if (elf_hash_table (info)->dynamic_sections_created)
4436 {
4437 /* Set the contents of the .interp section to the interpreter. */
4438 if (info->executable)
4439 {
4440 s = bfd_get_section_by_name (dynobj, ".interp");
4441 BFD_ASSERT (s != NULL);
4442 s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4443 s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
4444 }
4445 }
4446 else
4447 {
4448 /* We may have created entries in the .rela.got section.
4449 However, if we are not creating the dynamic sections, we will
4450 not actually use these entries. Reset the size of .rela.got,
4451 which will cause it to get stripped from the output file
4452 below. */
4453 s = bfd_get_section_by_name (dynobj, ".rela.got");
4454 if (s != NULL)
4455 s->size = 0;
4456 }
4457
4458 /* The check_relocs and adjust_dynamic_symbol entry points have
4459 determined the sizes of the various dynamic sections. Allocate
4460 memory for them. */
4461 plt = FALSE;
4462 relocs = FALSE;
4463 reltext = FALSE;
4464 for (s = dynobj->sections; s != NULL; s = s->next)
4465 {
4466 const char * name;
4467
4468 if ((s->flags & SEC_LINKER_CREATED) == 0)
4469 continue;
4470
4471 /* It's OK to base decisions on the section name, because none
4472 of the dynobj section names depend upon the input files. */
4473 name = bfd_get_section_name (dynobj, s);
4474
4475 if (streq (name, ".plt"))
4476 {
4477 /* Remember whether there is a PLT. */
4478 plt = s->size != 0;
4479 }
4480 else if (CONST_STRNEQ (name, ".rela"))
4481 {
4482 if (s->size != 0)
4483 {
4484 asection * target;
4485
4486 /* Remember whether there are any reloc sections other
4487 than .rela.plt. */
4488 if (! streq (name, ".rela.plt"))
4489 {
4490 const char * outname;
4491
4492 relocs = TRUE;
4493
4494 /* If this relocation section applies to a read only
4495 section, then we probably need a DT_TEXTREL
4496 entry. The entries in the .rela.plt section
4497 really apply to the .got section, which we
4498 created ourselves and so know is not readonly. */
4499 outname = bfd_get_section_name (output_bfd,
4500 s->output_section);
4501 target = bfd_get_section_by_name (output_bfd, outname + 5);
4502 if (target != NULL
4503 && (target->flags & SEC_READONLY) != 0
4504 && (target->flags & SEC_ALLOC) != 0)
4505 reltext = TRUE;
4506 }
4507
4508 /* We use the reloc_count field as a counter if we need
4509 to copy relocs into the output file. */
4510 s->reloc_count = 0;
4511 }
4512 }
4513 else if (! CONST_STRNEQ (name, ".got")
4514 && ! streq (name, ".dynbss"))
4515 /* It's not one of our sections, so don't allocate space. */
4516 continue;
4517
4518 if (s->size == 0)
4519 {
4520 /* If we don't need this section, strip it from the
4521 output file. This is mostly to handle .rela.bss and
4522 .rela.plt. We must create both sections in
4523 create_dynamic_sections, because they must be created
4524 before the linker maps input sections to output
4525 sections. The linker does that before
4526 adjust_dynamic_symbol is called, and it is that
4527 function which decides whether anything needs to go
4528 into these sections. */
4529 s->flags |= SEC_EXCLUDE;
4530 continue;
4531 }
4532
4533 if ((s->flags & SEC_HAS_CONTENTS) == 0)
4534 continue;
4535
4536 /* Allocate memory for the section contents. We use bfd_zalloc
4537 here in case unused entries are not reclaimed before the
4538 section's contents are written out. This should not happen,
4539 but this way if it does, we get a R_MN10300_NONE reloc
4540 instead of garbage. */
4541 s->contents = bfd_zalloc (dynobj, s->size);
4542 if (s->contents == NULL)
4543 return FALSE;
4544 }
4545
4546 if (elf_hash_table (info)->dynamic_sections_created)
4547 {
4548 /* Add some entries to the .dynamic section. We fill in the
4549 values later, in _bfd_mn10300_elf_finish_dynamic_sections,
4550 but we must add the entries now so that we get the correct
4551 size for the .dynamic section. The DT_DEBUG entry is filled
4552 in by the dynamic linker and used by the debugger. */
4553 if (! info->shared)
4554 {
4555 if (!_bfd_elf_add_dynamic_entry (info, DT_DEBUG, 0))
4556 return FALSE;
4557 }
4558
4559 if (plt)
4560 {
4561 if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0)
4562 || !_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4563 || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_RELA)
4564 || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4565 return FALSE;
4566 }
4567
4568 if (relocs)
4569 {
4570 if (!_bfd_elf_add_dynamic_entry (info, DT_RELA, 0)
4571 || !_bfd_elf_add_dynamic_entry (info, DT_RELASZ, 0)
4572 || !_bfd_elf_add_dynamic_entry (info, DT_RELAENT,
4573 sizeof (Elf32_External_Rela)))
4574 return FALSE;
4575 }
4576
4577 if (reltext)
4578 {
4579 if (!_bfd_elf_add_dynamic_entry (info, DT_TEXTREL, 0))
4580 return FALSE;
4581 }
4582 }
4583
4584 return TRUE;
4585 }
4586
4587 /* Finish up dynamic symbol handling. We set the contents of various
4588 dynamic sections here. */
4589
4590 static bfd_boolean
4591 _bfd_mn10300_elf_finish_dynamic_symbol (bfd * output_bfd,
4592 struct bfd_link_info * info,
4593 struct elf_link_hash_entry * h,
4594 Elf_Internal_Sym * sym)
4595 {
4596 bfd * dynobj;
4597
4598 dynobj = elf_hash_table (info)->dynobj;
4599
4600 if (h->plt.offset != (bfd_vma) -1)
4601 {
4602 asection * splt;
4603 asection * sgot;
4604 asection * srel;
4605 bfd_vma plt_index;
4606 bfd_vma got_offset;
4607 Elf_Internal_Rela rel;
4608
4609 /* This symbol has an entry in the procedure linkage table. Set
4610 it up. */
4611
4612 BFD_ASSERT (h->dynindx != -1);
4613
4614 splt = bfd_get_section_by_name (dynobj, ".plt");
4615 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4616 srel = bfd_get_section_by_name (dynobj, ".rela.plt");
4617 BFD_ASSERT (splt != NULL && sgot != NULL && srel != NULL);
4618
4619 /* Get the index in the procedure linkage table which
4620 corresponds to this symbol. This is the index of this symbol
4621 in all the symbols for which we are making plt entries. The
4622 first entry in the procedure linkage table is reserved. */
4623 plt_index = ((h->plt.offset - elf_mn10300_sizeof_plt0 (info))
4624 / elf_mn10300_sizeof_plt (info));
4625
4626 /* Get the offset into the .got table of the entry that
4627 corresponds to this function. Each .got entry is 4 bytes.
4628 The first three are reserved. */
4629 got_offset = (plt_index + 3) * 4;
4630
4631 /* Fill in the entry in the procedure linkage table. */
4632 if (! info->shared)
4633 {
4634 memcpy (splt->contents + h->plt.offset, elf_mn10300_plt_entry,
4635 elf_mn10300_sizeof_plt (info));
4636 bfd_put_32 (output_bfd,
4637 (sgot->output_section->vma
4638 + sgot->output_offset
4639 + got_offset),
4640 (splt->contents + h->plt.offset
4641 + elf_mn10300_plt_symbol_offset (info)));
4642
4643 bfd_put_32 (output_bfd,
4644 (1 - h->plt.offset - elf_mn10300_plt_plt0_offset (info)),
4645 (splt->contents + h->plt.offset
4646 + elf_mn10300_plt_plt0_offset (info)));
4647 }
4648 else
4649 {
4650 memcpy (splt->contents + h->plt.offset, elf_mn10300_pic_plt_entry,
4651 elf_mn10300_sizeof_plt (info));
4652
4653 bfd_put_32 (output_bfd, got_offset,
4654 (splt->contents + h->plt.offset
4655 + elf_mn10300_plt_symbol_offset (info)));
4656 }
4657
4658 bfd_put_32 (output_bfd, plt_index * sizeof (Elf32_External_Rela),
4659 (splt->contents + h->plt.offset
4660 + elf_mn10300_plt_reloc_offset (info)));
4661
4662 /* Fill in the entry in the global offset table. */
4663 bfd_put_32 (output_bfd,
4664 (splt->output_section->vma
4665 + splt->output_offset
4666 + h->plt.offset
4667 + elf_mn10300_plt_temp_offset (info)),
4668 sgot->contents + got_offset);
4669
4670 /* Fill in the entry in the .rela.plt section. */
4671 rel.r_offset = (sgot->output_section->vma
4672 + sgot->output_offset
4673 + got_offset);
4674 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_JMP_SLOT);
4675 rel.r_addend = 0;
4676 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4677 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4678 + plt_index));
4679
4680 if (!h->def_regular)
4681 /* Mark the symbol as undefined, rather than as defined in
4682 the .plt section. Leave the value alone. */
4683 sym->st_shndx = SHN_UNDEF;
4684 }
4685
4686 if (h->got.offset != (bfd_vma) -1)
4687 {
4688 asection * sgot;
4689 asection * srel;
4690 Elf_Internal_Rela rel;
4691
4692 /* This symbol has an entry in the global offset table. Set it up. */
4693 sgot = bfd_get_section_by_name (dynobj, ".got");
4694 srel = bfd_get_section_by_name (dynobj, ".rela.got");
4695 BFD_ASSERT (sgot != NULL && srel != NULL);
4696
4697 rel.r_offset = (sgot->output_section->vma
4698 + sgot->output_offset
4699 + (h->got.offset & ~1));
4700
4701 /* If this is a -Bsymbolic link, and the symbol is defined
4702 locally, we just want to emit a RELATIVE reloc. Likewise if
4703 the symbol was forced to be local because of a version file.
4704 The entry in the global offset table will already have been
4705 initialized in the relocate_section function. */
4706 if (info->shared
4707 && (info->symbolic || h->dynindx == -1)
4708 && h->def_regular)
4709 {
4710 rel.r_info = ELF32_R_INFO (0, R_MN10300_RELATIVE);
4711 rel.r_addend = (h->root.u.def.value
4712 + h->root.u.def.section->output_section->vma
4713 + h->root.u.def.section->output_offset);
4714 }
4715 else
4716 {
4717 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
4718 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_GLOB_DAT);
4719 rel.r_addend = 0;
4720 }
4721
4722 bfd_elf32_swap_reloca_out (output_bfd, &rel,
4723 (bfd_byte *) ((Elf32_External_Rela *) srel->contents
4724 + srel->reloc_count));
4725 ++ srel->reloc_count;
4726 }
4727
4728 if (h->needs_copy)
4729 {
4730 asection * s;
4731 Elf_Internal_Rela rel;
4732
4733 /* This symbol needs a copy reloc. Set it up. */
4734 BFD_ASSERT (h->dynindx != -1
4735 && (h->root.type == bfd_link_hash_defined
4736 || h->root.type == bfd_link_hash_defweak));
4737
4738 s = bfd_get_section_by_name (h->root.u.def.section->owner,
4739 ".rela.bss");
4740 BFD_ASSERT (s != NULL);
4741
4742 rel.r_offset = (h->root.u.def.value
4743 + h->root.u.def.section->output_section->vma
4744 + h->root.u.def.section->output_offset);
4745 rel.r_info = ELF32_R_INFO (h->dynindx, R_MN10300_COPY);
4746 rel.r_addend = 0;
4747 bfd_elf32_swap_reloca_out (output_bfd, & rel,
4748 (bfd_byte *) ((Elf32_External_Rela *) s->contents
4749 + s->reloc_count));
4750 ++ s->reloc_count;
4751 }
4752
4753 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
4754 if (streq (h->root.root.string, "_DYNAMIC")
4755 || h == elf_hash_table (info)->hgot)
4756 sym->st_shndx = SHN_ABS;
4757
4758 return TRUE;
4759 }
4760
4761 /* Finish up the dynamic sections. */
4762
4763 static bfd_boolean
4764 _bfd_mn10300_elf_finish_dynamic_sections (bfd * output_bfd,
4765 struct bfd_link_info * info)
4766 {
4767 bfd * dynobj;
4768 asection * sgot;
4769 asection * sdyn;
4770
4771 dynobj = elf_hash_table (info)->dynobj;
4772
4773 sgot = bfd_get_section_by_name (dynobj, ".got.plt");
4774 BFD_ASSERT (sgot != NULL);
4775 sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4776
4777 if (elf_hash_table (info)->dynamic_sections_created)
4778 {
4779 asection * splt;
4780 Elf32_External_Dyn * dyncon;
4781 Elf32_External_Dyn * dynconend;
4782
4783 BFD_ASSERT (sdyn != NULL);
4784
4785 dyncon = (Elf32_External_Dyn *) sdyn->contents;
4786 dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4787
4788 for (; dyncon < dynconend; dyncon++)
4789 {
4790 Elf_Internal_Dyn dyn;
4791 const char * name;
4792 asection * s;
4793
4794 bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4795
4796 switch (dyn.d_tag)
4797 {
4798 default:
4799 break;
4800
4801 case DT_PLTGOT:
4802 name = ".got";
4803 goto get_vma;
4804
4805 case DT_JMPREL:
4806 name = ".rela.plt";
4807 get_vma:
4808 s = bfd_get_section_by_name (output_bfd, name);
4809 BFD_ASSERT (s != NULL);
4810 dyn.d_un.d_ptr = s->vma;
4811 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4812 break;
4813
4814 case DT_PLTRELSZ:
4815 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4816 BFD_ASSERT (s != NULL);
4817 dyn.d_un.d_val = s->size;
4818 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4819 break;
4820
4821 case DT_RELASZ:
4822 /* My reading of the SVR4 ABI indicates that the
4823 procedure linkage table relocs (DT_JMPREL) should be
4824 included in the overall relocs (DT_RELA). This is
4825 what Solaris does. However, UnixWare can not handle
4826 that case. Therefore, we override the DT_RELASZ entry
4827 here to make it not include the JMPREL relocs. Since
4828 the linker script arranges for .rela.plt to follow all
4829 other relocation sections, we don't have to worry
4830 about changing the DT_RELA entry. */
4831 s = bfd_get_section_by_name (output_bfd, ".rela.plt");
4832 if (s != NULL)
4833 dyn.d_un.d_val -= s->size;
4834 bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4835 break;
4836 }
4837 }
4838
4839 /* Fill in the first entry in the procedure linkage table. */
4840 splt = bfd_get_section_by_name (dynobj, ".plt");
4841 if (splt && splt->size > 0)
4842 {
4843 if (info->shared)
4844 {
4845 memcpy (splt->contents, elf_mn10300_pic_plt_entry,
4846 elf_mn10300_sizeof_plt (info));
4847 }
4848 else
4849 {
4850 memcpy (splt->contents, elf_mn10300_plt0_entry, PLT0_ENTRY_SIZE);
4851 bfd_put_32 (output_bfd,
4852 sgot->output_section->vma + sgot->output_offset + 4,
4853 splt->contents + elf_mn10300_plt0_gotid_offset (info));
4854 bfd_put_32 (output_bfd,
4855 sgot->output_section->vma + sgot->output_offset + 8,
4856 splt->contents + elf_mn10300_plt0_linker_offset (info));
4857 }
4858
4859 /* UnixWare sets the entsize of .plt to 4, although that doesn't
4860 really seem like the right value. */
4861 elf_section_data (splt->output_section)->this_hdr.sh_entsize = 4;
4862 }
4863 }
4864
4865 /* Fill in the first three entries in the global offset table. */
4866 if (sgot->size > 0)
4867 {
4868 if (sdyn == NULL)
4869 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
4870 else
4871 bfd_put_32 (output_bfd,
4872 sdyn->output_section->vma + sdyn->output_offset,
4873 sgot->contents);
4874 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
4875 bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
4876 }
4877
4878 elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
4879
4880 return TRUE;
4881 }
4882
4883 /* Classify relocation types, such that combreloc can sort them
4884 properly. */
4885
4886 static enum elf_reloc_type_class
4887 _bfd_mn10300_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4888 {
4889 switch ((int) ELF32_R_TYPE (rela->r_info))
4890 {
4891 case R_MN10300_RELATIVE: return reloc_class_relative;
4892 case R_MN10300_JMP_SLOT: return reloc_class_plt;
4893 case R_MN10300_COPY: return reloc_class_copy;
4894 default: return reloc_class_normal;
4895 }
4896 }
4897
4898 #ifndef ELF_ARCH
4899 #define TARGET_LITTLE_SYM bfd_elf32_mn10300_vec
4900 #define TARGET_LITTLE_NAME "elf32-mn10300"
4901 #define ELF_ARCH bfd_arch_mn10300
4902 #define ELF_MACHINE_CODE EM_MN10300
4903 #define ELF_MACHINE_ALT1 EM_CYGNUS_MN10300
4904 #define ELF_MAXPAGESIZE 0x1000
4905 #endif
4906
4907 #define elf_info_to_howto mn10300_info_to_howto
4908 #define elf_info_to_howto_rel 0
4909 #define elf_backend_can_gc_sections 1
4910 #define elf_backend_rela_normal 1
4911 #define elf_backend_check_relocs mn10300_elf_check_relocs
4912 #define elf_backend_gc_mark_hook mn10300_elf_gc_mark_hook
4913 #define elf_backend_relocate_section mn10300_elf_relocate_section
4914 #define bfd_elf32_bfd_relax_section mn10300_elf_relax_section
4915 #define bfd_elf32_bfd_get_relocated_section_contents \
4916 mn10300_elf_get_relocated_section_contents
4917 #define bfd_elf32_bfd_link_hash_table_create \
4918 elf32_mn10300_link_hash_table_create
4919 #define bfd_elf32_bfd_link_hash_table_free \
4920 elf32_mn10300_link_hash_table_free
4921
4922 #ifndef elf_symbol_leading_char
4923 #define elf_symbol_leading_char '_'
4924 #endif
4925
4926 /* So we can set bits in e_flags. */
4927 #define elf_backend_final_write_processing \
4928 _bfd_mn10300_elf_final_write_processing
4929 #define elf_backend_object_p _bfd_mn10300_elf_object_p
4930
4931 #define bfd_elf32_bfd_merge_private_bfd_data \
4932 _bfd_mn10300_elf_merge_private_bfd_data
4933
4934 #define elf_backend_can_gc_sections 1
4935 #define elf_backend_create_dynamic_sections \
4936 _bfd_mn10300_elf_create_dynamic_sections
4937 #define elf_backend_adjust_dynamic_symbol \
4938 _bfd_mn10300_elf_adjust_dynamic_symbol
4939 #define elf_backend_size_dynamic_sections \
4940 _bfd_mn10300_elf_size_dynamic_sections
4941 #define elf_backend_omit_section_dynsym \
4942 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4943 #define elf_backend_finish_dynamic_symbol \
4944 _bfd_mn10300_elf_finish_dynamic_symbol
4945 #define elf_backend_finish_dynamic_sections \
4946 _bfd_mn10300_elf_finish_dynamic_sections
4947
4948 #define elf_backend_reloc_type_class \
4949 _bfd_mn10300_elf_reloc_type_class
4950
4951 #define elf_backend_want_got_plt 1
4952 #define elf_backend_plt_readonly 1
4953 #define elf_backend_want_plt_sym 0
4954 #define elf_backend_got_header_size 12
4955
4956 #include "elf32-target.h"
git-cvsimport of binutils cvsroot