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