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