1 /* BFD back-end for National Semiconductor's CR16 ELF
2 Copyright (C) 2007-2016 Free Software Foundation, Inc.
3 Written by M R Swami Reddy.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software Foundation,
19 Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
25 #include "libiberty.h"
29 /* The cr16 linker needs to keep track of the number of relocs that
30 it decides to copy in check_relocs for each symbol. This is so
31 that it can discard PC relative relocs if it doesn't need them when
32 linking with -Bsymbolic. We store the information in a field
33 extending the regular ELF linker hash table. */
35 struct elf32_cr16_link_hash_entry
37 /* The basic elf link hash table entry. */
38 struct elf_link_hash_entry root
;
40 /* For function symbols, the number of times this function is
41 called directly (ie by name). */
42 unsigned int direct_calls
;
44 /* For function symbols, the size of this function's stack
45 (if <= 255 bytes). We stuff this into "call" instructions
46 to this target when it's valid and profitable to do so.
48 This does not include stack allocated by movm! */
49 unsigned char stack_size
;
51 /* For function symbols, arguments (if any) for movm instruction
52 in the prologue. We stuff this value into "call" instructions
53 to the target when it's valid and profitable to do so. */
54 unsigned char movm_args
;
56 /* For function symbols, the amount of stack space that would be allocated
57 by the movm instruction. This is redundant with movm_args, but we
58 add it to the hash table to avoid computing it over and over. */
59 unsigned char movm_stack_size
;
61 /* Used to mark functions which have had redundant parts of their
63 #define CR16_DELETED_PROLOGUE_BYTES 0x1
66 /* Calculated value. */
70 /* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */
74 bfd_reloc_code_real_type bfd_reloc_enum
; /* BFD relocation enum. */
75 unsigned short cr16_reloc_type
; /* CR16 relocation type. */
78 static const struct cr16_reloc_map cr16_reloc_map
[R_CR16_MAX
] =
80 {BFD_RELOC_NONE
, R_CR16_NONE
},
81 {BFD_RELOC_CR16_NUM8
, R_CR16_NUM8
},
82 {BFD_RELOC_CR16_NUM16
, R_CR16_NUM16
},
83 {BFD_RELOC_CR16_NUM32
, R_CR16_NUM32
},
84 {BFD_RELOC_CR16_NUM32a
, R_CR16_NUM32a
},
85 {BFD_RELOC_CR16_REGREL4
, R_CR16_REGREL4
},
86 {BFD_RELOC_CR16_REGREL4a
, R_CR16_REGREL4a
},
87 {BFD_RELOC_CR16_REGREL14
, R_CR16_REGREL14
},
88 {BFD_RELOC_CR16_REGREL14a
, R_CR16_REGREL14a
},
89 {BFD_RELOC_CR16_REGREL16
, R_CR16_REGREL16
},
90 {BFD_RELOC_CR16_REGREL20
, R_CR16_REGREL20
},
91 {BFD_RELOC_CR16_REGREL20a
, R_CR16_REGREL20a
},
92 {BFD_RELOC_CR16_ABS20
, R_CR16_ABS20
},
93 {BFD_RELOC_CR16_ABS24
, R_CR16_ABS24
},
94 {BFD_RELOC_CR16_IMM4
, R_CR16_IMM4
},
95 {BFD_RELOC_CR16_IMM8
, R_CR16_IMM8
},
96 {BFD_RELOC_CR16_IMM16
, R_CR16_IMM16
},
97 {BFD_RELOC_CR16_IMM20
, R_CR16_IMM20
},
98 {BFD_RELOC_CR16_IMM24
, R_CR16_IMM24
},
99 {BFD_RELOC_CR16_IMM32
, R_CR16_IMM32
},
100 {BFD_RELOC_CR16_IMM32a
, R_CR16_IMM32a
},
101 {BFD_RELOC_CR16_DISP4
, R_CR16_DISP4
},
102 {BFD_RELOC_CR16_DISP8
, R_CR16_DISP8
},
103 {BFD_RELOC_CR16_DISP16
, R_CR16_DISP16
},
104 {BFD_RELOC_CR16_DISP24
, R_CR16_DISP24
},
105 {BFD_RELOC_CR16_DISP24a
, R_CR16_DISP24a
},
106 {BFD_RELOC_CR16_SWITCH8
, R_CR16_SWITCH8
},
107 {BFD_RELOC_CR16_SWITCH16
, R_CR16_SWITCH16
},
108 {BFD_RELOC_CR16_SWITCH32
, R_CR16_SWITCH32
},
109 {BFD_RELOC_CR16_GOT_REGREL20
, R_CR16_GOT_REGREL20
},
110 {BFD_RELOC_CR16_GOTC_REGREL20
, R_CR16_GOTC_REGREL20
},
111 {BFD_RELOC_CR16_GLOB_DAT
, R_CR16_GLOB_DAT
}
114 static reloc_howto_type cr16_elf_howto_table
[] =
116 HOWTO (R_CR16_NONE
, /* type */
120 FALSE
, /* pc_relative */
122 complain_overflow_dont
, /* complain_on_overflow */
123 bfd_elf_generic_reloc
, /* special_function */
124 "R_CR16_NONE", /* name */
125 FALSE
, /* partial_inplace */
128 FALSE
), /* pcrel_offset */
130 HOWTO (R_CR16_NUM8
, /* type */
134 FALSE
, /* pc_relative */
136 complain_overflow_bitfield
,/* complain_on_overflow */
137 bfd_elf_generic_reloc
, /* special_function */
138 "R_CR16_NUM8", /* name */
139 FALSE
, /* partial_inplace */
142 FALSE
), /* pcrel_offset */
144 HOWTO (R_CR16_NUM16
, /* type */
148 FALSE
, /* pc_relative */
150 complain_overflow_bitfield
,/* complain_on_overflow */
151 bfd_elf_generic_reloc
, /* special_function */
152 "R_CR16_NUM16", /* name */
153 FALSE
, /* partial_inplace */
155 0xffff, /* dst_mask */
156 FALSE
), /* pcrel_offset */
158 HOWTO (R_CR16_NUM32
, /* type */
162 FALSE
, /* pc_relative */
164 complain_overflow_bitfield
,/* complain_on_overflow */
165 bfd_elf_generic_reloc
, /* special_function */
166 "R_CR16_NUM32", /* name */
167 FALSE
, /* partial_inplace */
169 0xffffffff, /* dst_mask */
170 FALSE
), /* pcrel_offset */
172 HOWTO (R_CR16_NUM32a
, /* type */
176 FALSE
, /* pc_relative */
178 complain_overflow_bitfield
,/* complain_on_overflow */
179 bfd_elf_generic_reloc
, /* special_function */
180 "R_CR16_NUM32a", /* name */
181 FALSE
, /* partial_inplace */
183 0xffffffff, /* dst_mask */
184 FALSE
), /* pcrel_offset */
186 HOWTO (R_CR16_REGREL4
, /* type */
190 FALSE
, /* pc_relative */
192 complain_overflow_bitfield
,/* complain_on_overflow */
193 bfd_elf_generic_reloc
, /* special_function */
194 "R_CR16_REGREL4", /* name */
195 FALSE
, /* partial_inplace */
198 FALSE
), /* pcrel_offset */
200 HOWTO (R_CR16_REGREL4a
, /* type */
204 FALSE
, /* pc_relative */
206 complain_overflow_bitfield
,/* complain_on_overflow */
207 bfd_elf_generic_reloc
, /* special_function */
208 "R_CR16_REGREL4a", /* name */
209 FALSE
, /* partial_inplace */
212 FALSE
), /* pcrel_offset */
214 HOWTO (R_CR16_REGREL14
, /* type */
218 FALSE
, /* pc_relative */
220 complain_overflow_bitfield
,/* complain_on_overflow */
221 bfd_elf_generic_reloc
, /* special_function */
222 "R_CR16_REGREL14", /* name */
223 FALSE
, /* partial_inplace */
225 0x3fff, /* dst_mask */
226 FALSE
), /* pcrel_offset */
228 HOWTO (R_CR16_REGREL14a
, /* type */
232 FALSE
, /* pc_relative */
234 complain_overflow_bitfield
,/* complain_on_overflow */
235 bfd_elf_generic_reloc
, /* special_function */
236 "R_CR16_REGREL14a", /* name */
237 FALSE
, /* partial_inplace */
239 0x3fff, /* dst_mask */
240 FALSE
), /* pcrel_offset */
242 HOWTO (R_CR16_REGREL16
, /* type */
246 FALSE
, /* pc_relative */
248 complain_overflow_bitfield
,/* complain_on_overflow */
249 bfd_elf_generic_reloc
, /* special_function */
250 "R_CR16_REGREL16", /* name */
251 FALSE
, /* partial_inplace */
253 0xffff, /* dst_mask */
254 FALSE
), /* pcrel_offset */
256 HOWTO (R_CR16_REGREL20
, /* type */
260 FALSE
, /* pc_relative */
262 complain_overflow_bitfield
,/* complain_on_overflow */
263 bfd_elf_generic_reloc
, /* special_function */
264 "R_CR16_REGREL20", /* name */
265 FALSE
, /* partial_inplace */
267 0xfffff, /* dst_mask */
268 FALSE
), /* pcrel_offset */
270 HOWTO (R_CR16_REGREL20a
, /* type */
274 FALSE
, /* pc_relative */
276 complain_overflow_bitfield
,/* complain_on_overflow */
277 bfd_elf_generic_reloc
, /* special_function */
278 "R_CR16_REGREL20a", /* name */
279 FALSE
, /* partial_inplace */
281 0xfffff, /* dst_mask */
282 FALSE
), /* pcrel_offset */
284 HOWTO (R_CR16_ABS20
, /* type */
288 FALSE
, /* pc_relative */
290 complain_overflow_bitfield
,/* complain_on_overflow */
291 bfd_elf_generic_reloc
, /* special_function */
292 "R_CR16_ABS20", /* name */
293 FALSE
, /* partial_inplace */
295 0xfffff, /* dst_mask */
296 FALSE
), /* pcrel_offset */
298 HOWTO (R_CR16_ABS24
, /* type */
302 FALSE
, /* pc_relative */
304 complain_overflow_bitfield
,/* complain_on_overflow */
305 bfd_elf_generic_reloc
, /* special_function */
306 "R_CR16_ABS24", /* name */
307 FALSE
, /* partial_inplace */
309 0xffffff, /* dst_mask */
310 FALSE
), /* pcrel_offset */
312 HOWTO (R_CR16_IMM4
, /* type */
316 FALSE
, /* pc_relative */
318 complain_overflow_bitfield
,/* complain_on_overflow */
319 bfd_elf_generic_reloc
, /* special_function */
320 "R_CR16_IMM4", /* name */
321 FALSE
, /* partial_inplace */
324 FALSE
), /* pcrel_offset */
326 HOWTO (R_CR16_IMM8
, /* type */
330 FALSE
, /* pc_relative */
332 complain_overflow_bitfield
,/* complain_on_overflow */
333 bfd_elf_generic_reloc
, /* special_function */
334 "R_CR16_IMM8", /* name */
335 FALSE
, /* partial_inplace */
338 FALSE
), /* pcrel_offset */
340 HOWTO (R_CR16_IMM16
, /* type */
344 FALSE
, /* pc_relative */
346 complain_overflow_bitfield
,/* complain_on_overflow */
347 bfd_elf_generic_reloc
, /* special_function */
348 "R_CR16_IMM16", /* name */
349 FALSE
, /* partial_inplace */
351 0xffff, /* dst_mask */
352 FALSE
), /* pcrel_offset */
354 HOWTO (R_CR16_IMM20
, /* type */
358 FALSE
, /* pc_relative */
360 complain_overflow_bitfield
,/* complain_on_overflow */
361 bfd_elf_generic_reloc
, /* special_function */
362 "R_CR16_IMM20", /* name */
363 FALSE
, /* partial_inplace */
365 0xfffff, /* dst_mask */
366 FALSE
), /* pcrel_offset */
368 HOWTO (R_CR16_IMM24
, /* type */
372 FALSE
, /* pc_relative */
374 complain_overflow_bitfield
,/* complain_on_overflow */
375 bfd_elf_generic_reloc
, /* special_function */
376 "R_CR16_IMM24", /* name */
377 FALSE
, /* partial_inplace */
379 0xffffff, /* dst_mask */
380 FALSE
), /* pcrel_offset */
382 HOWTO (R_CR16_IMM32
, /* type */
386 FALSE
, /* pc_relative */
388 complain_overflow_bitfield
,/* complain_on_overflow */
389 bfd_elf_generic_reloc
, /* special_function */
390 "R_CR16_IMM32", /* name */
391 FALSE
, /* partial_inplace */
393 0xffffffff, /* dst_mask */
394 FALSE
), /* pcrel_offset */
396 HOWTO (R_CR16_IMM32a
, /* type */
400 FALSE
, /* pc_relative */
402 complain_overflow_bitfield
,/* complain_on_overflow */
403 bfd_elf_generic_reloc
, /* special_function */
404 "R_CR16_IMM32a", /* name */
405 FALSE
, /* partial_inplace */
407 0xffffffff, /* dst_mask */
408 FALSE
), /* pcrel_offset */
410 HOWTO (R_CR16_DISP4
, /* type */
412 0, /* size (0 = byte, 1 = short, 2 = long) */
414 TRUE
, /* pc_relative */
416 complain_overflow_unsigned
, /* complain_on_overflow */
417 bfd_elf_generic_reloc
, /* special_function */
418 "R_CR16_DISP4", /* name */
419 FALSE
, /* partial_inplace */
422 FALSE
), /* pcrel_offset */
424 HOWTO (R_CR16_DISP8
, /* type */
426 0, /* size (0 = byte, 1 = short, 2 = long) */
428 TRUE
, /* pc_relative */
430 complain_overflow_unsigned
, /* complain_on_overflow */
431 bfd_elf_generic_reloc
, /* special_function */
432 "R_CR16_DISP8", /* name */
433 FALSE
, /* partial_inplace */
435 0x1ff, /* dst_mask */
436 FALSE
), /* pcrel_offset */
438 HOWTO (R_CR16_DISP16
, /* type */
439 0, /* rightshift REVIITS: To sync with WinIDEA*/
440 1, /* size (0 = byte, 1 = short, 2 = long) */
442 TRUE
, /* pc_relative */
444 complain_overflow_unsigned
, /* complain_on_overflow */
445 bfd_elf_generic_reloc
, /* special_function */
446 "R_CR16_DISP16", /* name */
447 FALSE
, /* partial_inplace */
449 0x1ffff, /* dst_mask */
450 FALSE
), /* pcrel_offset */
451 /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc
452 but its not done, to sync with WinIDEA and CR16 4.1 tools */
453 HOWTO (R_CR16_DISP24
, /* type */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
457 TRUE
, /* pc_relative */
459 complain_overflow_unsigned
, /* complain_on_overflow */
460 bfd_elf_generic_reloc
, /* special_function */
461 "R_CR16_DISP24", /* name */
462 FALSE
, /* partial_inplace */
464 0x1ffffff, /* dst_mask */
465 FALSE
), /* pcrel_offset */
467 HOWTO (R_CR16_DISP24a
, /* type */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
471 TRUE
, /* pc_relative */
473 complain_overflow_unsigned
, /* complain_on_overflow */
474 bfd_elf_generic_reloc
, /* special_function */
475 "R_CR16_DISP24a", /* name */
476 FALSE
, /* partial_inplace */
478 0xffffff, /* dst_mask */
479 FALSE
), /* pcrel_offset */
481 /* An 8 bit switch table entry. This is generated for an expression
482 such as ``.byte L1 - L2''. The offset holds the difference
483 between the reloc address and L2. */
484 HOWTO (R_CR16_SWITCH8
, /* type */
486 0, /* size (0 = byte, 1 = short, 2 = long) */
488 FALSE
, /* pc_relative */
490 complain_overflow_unsigned
, /* complain_on_overflow */
491 bfd_elf_generic_reloc
, /* special_function */
492 "R_CR16_SWITCH8", /* name */
493 FALSE
, /* partial_inplace */
496 TRUE
), /* pcrel_offset */
498 /* A 16 bit switch table entry. This is generated for an expression
499 such as ``.word L1 - L2''. The offset holds the difference
500 between the reloc address and L2. */
501 HOWTO (R_CR16_SWITCH16
, /* type */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
505 FALSE
, /* pc_relative */
507 complain_overflow_unsigned
, /* complain_on_overflow */
508 bfd_elf_generic_reloc
, /* special_function */
509 "R_CR16_SWITCH16", /* name */
510 FALSE
, /* partial_inplace */
512 0xffff, /* dst_mask */
513 TRUE
), /* pcrel_offset */
515 /* A 32 bit switch table entry. This is generated for an expression
516 such as ``.long L1 - L2''. The offset holds the difference
517 between the reloc address and L2. */
518 HOWTO (R_CR16_SWITCH32
, /* type */
520 2, /* size (0 = byte, 1 = short, 2 = long) */
522 FALSE
, /* pc_relative */
524 complain_overflow_unsigned
, /* complain_on_overflow */
525 bfd_elf_generic_reloc
, /* special_function */
526 "R_CR16_SWITCH32", /* name */
527 FALSE
, /* partial_inplace */
529 0xffffffff, /* dst_mask */
530 TRUE
), /* pcrel_offset */
532 HOWTO (R_CR16_GOT_REGREL20
, /* type */
536 FALSE
, /* pc_relative */
538 complain_overflow_bitfield
,/* complain_on_overflow */
539 bfd_elf_generic_reloc
, /* special_function */
540 "R_CR16_GOT_REGREL20", /* name */
541 TRUE
, /* partial_inplace */
543 0xfffff, /* dst_mask */
544 FALSE
), /* pcrel_offset */
546 HOWTO (R_CR16_GOTC_REGREL20
, /* type */
550 FALSE
, /* pc_relative */
552 complain_overflow_bitfield
,/* complain_on_overflow */
553 bfd_elf_generic_reloc
, /* special_function */
554 "R_CR16_GOTC_REGREL20", /* name */
555 TRUE
, /* partial_inplace */
557 0xfffff, /* dst_mask */
558 FALSE
), /* pcrel_offset */
560 HOWTO (R_CR16_GLOB_DAT
, /* type */
562 2, /* size (0 = byte, 1 = short, 2 = long) */
564 FALSE
, /* pc_relative */
566 complain_overflow_unsigned
, /* complain_on_overflow */
567 bfd_elf_generic_reloc
, /* special_function */
568 "R_CR16_GLOB_DAT", /* name */
569 FALSE
, /* partial_inplace */
571 0xffffffff, /* dst_mask */
572 TRUE
) /* pcrel_offset */
576 /* Create the GOT section. */
579 _bfd_cr16_elf_create_got_section (bfd
* abfd
, struct bfd_link_info
* info
)
583 struct elf_link_hash_entry
* h
;
584 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
587 /* This function may be called more than once. */
588 if (bfd_get_linker_section (abfd
, ".got") != NULL
)
591 switch (bed
->s
->arch_size
)
602 bfd_set_error (bfd_error_bad_value
);
606 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
607 | SEC_LINKER_CREATED
);
609 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
611 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
614 if (bed
->want_got_plt
)
616 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
618 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
622 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
623 (or .got.plt) section. We don't do this in the linker script
624 because we don't want to define the symbol if we are not creating
625 a global offset table. */
626 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_GLOBAL_OFFSET_TABLE_");
627 elf_hash_table (info
)->hgot
= h
;
631 /* The first bit of the global offset table is the header. */
632 s
->size
+= bed
->got_header_size
;
638 /* Retrieve a howto ptr using a BFD reloc_code. */
640 static reloc_howto_type
*
641 elf_cr16_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
642 bfd_reloc_code_real_type code
)
646 for (i
= 0; i
< R_CR16_MAX
; i
++)
647 if (code
== cr16_reloc_map
[i
].bfd_reloc_enum
)
648 return &cr16_elf_howto_table
[cr16_reloc_map
[i
].cr16_reloc_type
];
650 _bfd_error_handler ("Unsupported CR16 relocation type: 0x%x\n", code
);
654 static reloc_howto_type
*
655 elf_cr16_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
660 for (i
= 0; ARRAY_SIZE (cr16_elf_howto_table
); i
++)
661 if (cr16_elf_howto_table
[i
].name
!= NULL
662 && strcasecmp (cr16_elf_howto_table
[i
].name
, r_name
) == 0)
663 return cr16_elf_howto_table
+ i
;
668 /* Retrieve a howto ptr using an internal relocation entry. */
671 elf_cr16_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
672 Elf_Internal_Rela
*dst
)
674 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
676 if (r_type
>= R_CR16_MAX
)
678 (*_bfd_error_handler
) (_("%B: unrecognised CR16 reloc number: %d"),
680 bfd_set_error (bfd_error_bad_value
);
681 r_type
= R_CR16_NONE
;
683 cache_ptr
->howto
= cr16_elf_howto_table
+ r_type
;
686 /* Look through the relocs for a section during the first phase.
687 Since we don't do .gots or .plts, we just need to consider the
688 virtual table relocs for gc. */
691 cr16_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
692 const Elf_Internal_Rela
*relocs
)
694 Elf_Internal_Shdr
*symtab_hdr
;
695 Elf_Internal_Sym
* isymbuf
= NULL
;
696 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
697 const Elf_Internal_Rela
*rel
;
698 const Elf_Internal_Rela
*rel_end
;
700 bfd_vma
* local_got_offsets
;
706 bfd_boolean result
= FALSE
;
708 if (bfd_link_relocatable (info
))
711 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
712 sym_hashes
= elf_sym_hashes (abfd
);
713 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
714 if (!elf_bad_symtab (abfd
))
715 sym_hashes_end
-= symtab_hdr
->sh_info
;
717 dynobj
= elf_hash_table (info
)->dynobj
;
718 local_got_offsets
= elf_local_got_offsets (abfd
);
719 rel_end
= relocs
+ sec
->reloc_count
;
720 for (rel
= relocs
; rel
< rel_end
; rel
++)
722 struct elf_link_hash_entry
*h
;
723 unsigned long r_symndx
;
725 r_symndx
= ELF32_R_SYM (rel
->r_info
);
726 if (r_symndx
< symtab_hdr
->sh_info
)
730 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
731 while (h
->root
.type
== bfd_link_hash_indirect
732 || h
->root
.type
== bfd_link_hash_warning
)
733 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
735 /* PR15323, ref flags aren't set for references in the same
737 h
->root
.non_ir_ref
= 1;
740 /* Some relocs require a global offset table. */
743 switch (ELF32_R_TYPE (rel
->r_info
))
745 case R_CR16_GOT_REGREL20
:
746 case R_CR16_GOTC_REGREL20
:
747 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
748 if (! _bfd_cr16_elf_create_got_section (dynobj
, info
))
757 switch (ELF32_R_TYPE (rel
->r_info
))
759 case R_CR16_GOT_REGREL20
:
760 case R_CR16_GOTC_REGREL20
:
761 /* This symbol requires a global offset table entry. */
765 sgot
= bfd_get_linker_section (dynobj
, ".got");
766 BFD_ASSERT (sgot
!= NULL
);
770 && (h
!= NULL
|| bfd_link_executable (info
)))
772 srelgot
= bfd_get_linker_section (dynobj
, ".rela.got");
775 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
776 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
778 srelgot
= bfd_make_section_anyway_with_flags (dynobj
,
782 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
789 if (h
->got
.offset
!= (bfd_vma
) -1)
790 /* We have already allocated space in the .got. */
793 h
->got
.offset
= sgot
->size
;
795 /* Make sure this symbol is output as a dynamic symbol. */
796 if (h
->dynindx
== -1)
798 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
802 srelgot
->size
+= sizeof (Elf32_External_Rela
);
806 /* This is a global offset table entry for a local
808 if (local_got_offsets
== NULL
)
813 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
814 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
816 if (local_got_offsets
== NULL
)
819 elf_local_got_offsets (abfd
) = local_got_offsets
;
821 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
822 local_got_offsets
[i
] = (bfd_vma
) -1;
825 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
826 /* We have already allocated space in the .got. */
829 local_got_offsets
[r_symndx
] = sgot
->size
;
831 if (bfd_link_executable (info
))
832 /* If we are generating a shared object, we need to
833 output a R_CR16_RELATIVE reloc so that the dynamic
834 linker can adjust this GOT entry. */
835 srelgot
->size
+= sizeof (Elf32_External_Rela
);
852 /* Perform a relocation as part of a final link. */
854 static bfd_reloc_status_type
855 cr16_elf_final_link_relocate (reloc_howto_type
*howto
,
857 bfd
*output_bfd ATTRIBUTE_UNUSED
,
858 asection
*input_section
,
863 struct elf_link_hash_entry
* h
,
864 unsigned long symndx ATTRIBUTE_UNUSED
,
865 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
866 asection
*sec ATTRIBUTE_UNUSED
,
867 int is_local ATTRIBUTE_UNUSED
)
869 unsigned short r_type
= howto
->type
;
870 bfd_byte
*hit_data
= contents
+ offset
;
871 bfd_vma reloc_bits
, check
, Rvalue1
;
874 dynobj
= elf_hash_table (info
)->dynobj
;
888 case R_CR16_REGREL4a
:
889 case R_CR16_REGREL14
:
890 case R_CR16_REGREL14a
:
891 case R_CR16_REGREL16
:
892 case R_CR16_REGREL20
:
893 case R_CR16_REGREL20a
:
894 case R_CR16_GOT_REGREL20
:
895 case R_CR16_GOTC_REGREL20
:
899 /* 'hit_data' is relative to the start of the instruction, not the
900 relocation offset. Advance it to account for the exact offset. */
920 case R_CR16_SWITCH16
:
921 case R_CR16_SWITCH32
:
922 /* We only care about the addend, where the difference between
923 expressions is kept. */
930 if (howto
->pc_relative
)
932 /* Subtract the address of the section containing the location. */
933 Rvalue
-= (input_section
->output_section
->vma
934 + input_section
->output_offset
);
935 /* Subtract the position of the location within the section. */
939 /* Add in supplied addend. */
942 /* Complain if the bitfield overflows, whether it is considered
943 as signed or unsigned. */
944 check
= Rvalue
>> howto
->rightshift
;
946 /* Assumes two's complement. This expression avoids
947 overflow if howto->bitsize is the number of bits in
949 reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
951 /* For GOT and GOTC relocs no boundary checks applied. */
952 if (!((r_type
== R_CR16_GOT_REGREL20
)
953 || (r_type
== R_CR16_GOTC_REGREL20
)))
955 if (((bfd_vma
) check
& ~reloc_bits
) != 0
956 && (((bfd_vma
) check
& ~reloc_bits
)
957 != (-(bfd_vma
) 1 & ~reloc_bits
)))
959 /* The above right shift is incorrect for a signed
960 value. See if turning on the upper bits fixes the
962 if (howto
->rightshift
&& (bfd_signed_vma
) Rvalue
< 0)
964 check
|= ((bfd_vma
) - 1
966 >> howto
->rightshift
));
968 if (((bfd_vma
) check
& ~reloc_bits
)
969 != (-(bfd_vma
) 1 & ~reloc_bits
))
970 return bfd_reloc_overflow
;
973 return bfd_reloc_overflow
;
976 /* Drop unwanted bits from the value we are relocating to. */
977 Rvalue
>>= (bfd_vma
) howto
->rightshift
;
979 /* Apply dst_mask to select only relocatable part of the insn. */
980 Rvalue
&= howto
->dst_mask
;
986 if (r_type
== R_CR16_DISP8
)
988 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
989 Rvalue
= ((Rvalue1
& 0xf000) | ((Rvalue
<< 4) & 0xf00)
990 | (Rvalue1
& 0x00f0) | (Rvalue
& 0xf));
991 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
993 else if (r_type
== R_CR16_IMM4
)
995 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
996 Rvalue
= (((Rvalue1
& 0xff) << 8) | ((Rvalue
<< 4) & 0xf0)
997 | ((Rvalue1
& 0x0f00) >> 8));
998 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1000 else if (r_type
== R_CR16_DISP4
)
1002 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
1003 Rvalue
= (Rvalue1
| ((Rvalue
& 0xf) << 4));
1004 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1008 bfd_put_8 (input_bfd
, (unsigned char) Rvalue
, hit_data
);
1013 if (r_type
== R_CR16_DISP16
)
1015 Rvalue
|= (bfd_get_16 (input_bfd
, hit_data
));
1016 Rvalue
= ((Rvalue
& 0xfffe) | ((Rvalue
>> 16) & 0x1));
1018 if (r_type
== R_CR16_IMM16
)
1020 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
1022 /* Add or subtract the offset value. */
1023 if (Rvalue1
& 0x8000)
1024 Rvalue
-= (~Rvalue1
+ 1) & 0xffff;
1028 /* Check for range. */
1029 if ((long) Rvalue
> 0xffff || (long) Rvalue
< 0x0)
1030 return bfd_reloc_overflow
;
1033 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1037 if ((r_type
== R_CR16_ABS20
) || (r_type
== R_CR16_IMM20
))
1039 Rvalue1
= (bfd_get_16 (input_bfd
, hit_data
+ 2)
1040 | (((bfd_get_16 (input_bfd
, hit_data
) & 0xf) <<16)));
1042 /* Add or subtract the offset value. */
1043 if (Rvalue1
& 0x80000)
1044 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1048 /* Check for range. */
1049 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1050 return bfd_reloc_overflow
;
1052 bfd_put_16 (input_bfd
, ((bfd_get_16 (input_bfd
, hit_data
) & 0xfff0)
1053 | ((Rvalue
>> 16) & 0xf)), hit_data
);
1054 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1056 else if (r_type
== R_CR16_GOT_REGREL20
)
1058 asection
* sgot
= bfd_get_linker_section (dynobj
, ".got");
1064 off
= h
->got
.offset
;
1065 BFD_ASSERT (off
!= (bfd_vma
) -1);
1067 if (! elf_hash_table (info
)->dynamic_sections_created
1068 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1069 /* This is actually a static link, or it is a
1070 -Bsymbolic link and the symbol is defined
1071 locally, or the symbol was forced to be local
1072 because of a version file. We must initialize
1073 this entry in the global offset table.
1074 When doing a dynamic link, we create a .rela.got
1075 relocation entry to initialize the value. This
1076 is done in the finish_dynamic_symbol routine. */
1077 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1079 Rvalue
= sgot
->output_offset
+ off
;
1085 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1086 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1088 Rvalue
= sgot
->output_offset
+ off
;
1093 /* REVISIT: if ((long) Rvalue > 0xffffff ||
1094 (long) Rvalue < -0x800000). */
1095 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1096 return bfd_reloc_overflow
;
1099 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1100 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1101 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1104 else if (r_type
== R_CR16_GOTC_REGREL20
)
1107 sgot
= bfd_get_linker_section (dynobj
, ".got");
1113 off
= h
->got
.offset
;
1114 BFD_ASSERT (off
!= (bfd_vma
) -1);
1116 Rvalue
>>=1; /* For code symbols. */
1118 if (! elf_hash_table (info
)->dynamic_sections_created
1119 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1120 /* This is actually a static link, or it is a
1121 -Bsymbolic link and the symbol is defined
1122 locally, or the symbol was forced to be local
1123 because of a version file. We must initialize
1124 this entry in the global offset table.
1125 When doing a dynamic link, we create a .rela.got
1126 relocation entry to initialize the value. This
1127 is done in the finish_dynamic_symbol routine. */
1128 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1130 Rvalue
= sgot
->output_offset
+ off
;
1136 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1138 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1139 Rvalue
= sgot
->output_offset
+ off
;
1144 /* Check if any value in DISP. */
1145 Rvalue1
=((bfd_get_32 (input_bfd
, hit_data
) >>16)
1146 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1148 /* Add or subtract the offset value. */
1149 if (Rvalue1
& 0x80000)
1150 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1154 /* Check for range. */
1155 /* REVISIT: if ((long) Rvalue > 0xffffff
1156 || (long) Rvalue < -0x800000). */
1157 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1158 return bfd_reloc_overflow
;
1160 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1161 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1162 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1166 if (r_type
== R_CR16_ABS24
)
1168 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1169 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16)
1170 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xf) <<20)));
1172 /* Add or subtract the offset value. */
1173 if (Rvalue1
& 0x800000)
1174 Rvalue
-= (~Rvalue1
+ 1) & 0xffffff;
1178 /* Check for Range. */
1179 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0x0)
1180 return bfd_reloc_overflow
;
1182 Rvalue
= ((((Rvalue
>> 20) & 0xf) | (((Rvalue
>> 16) & 0xf)<<8)
1183 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0f0))
1184 | ((Rvalue
& 0xffff) << 16));
1186 else if (r_type
== R_CR16_DISP24
)
1188 Rvalue
= ((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1189 | (bfd_get_16 (input_bfd
, hit_data
)))
1190 | (((Rvalue
& 0xfffe) | ((Rvalue
>> 24) & 0x1)) << 16));
1192 else if ((r_type
== R_CR16_IMM32
) || (r_type
== R_CR16_IMM32a
))
1194 Rvalue1
=((((bfd_get_32 (input_bfd
, hit_data
)) >> 16) &0xffff)
1195 | (((bfd_get_32 (input_bfd
, hit_data
)) &0xffff)) << 16);
1197 /* Add or subtract the offset value. */
1198 if (Rvalue1
& 0x80000000)
1199 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1203 /* Check for range. */
1204 if (Rvalue
> 0xffffffff || (long) Rvalue
< 0x0)
1205 return bfd_reloc_overflow
;
1207 Rvalue
= (((Rvalue
>> 16)& 0xffff) | (Rvalue
& 0xffff) << 16);
1209 else if (r_type
== R_CR16_DISP24a
)
1211 Rvalue
= (((Rvalue
& 0xfffffe) | (Rvalue
>> 23)));
1212 Rvalue
= ((Rvalue
>> 16) & 0xff) | ((Rvalue
& 0xffff) << 16)
1213 | (bfd_get_32 (input_bfd
, hit_data
));
1215 else if ((r_type
== R_CR16_REGREL20
)
1216 || (r_type
== R_CR16_REGREL20a
))
1218 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1219 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1220 /* Add or subtract the offset value. */
1221 if (Rvalue1
& 0x80000)
1222 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1226 /* Check for range. */
1227 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1228 return bfd_reloc_overflow
;
1230 Rvalue
= (((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1231 | ((Rvalue
& 0xffff) << 16)))
1232 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0ff));
1235 else if (r_type
== R_CR16_NUM32
)
1237 Rvalue1
= (bfd_get_32 (input_bfd
, hit_data
));
1239 /* Add or subtract the offset value */
1240 if (Rvalue1
& 0x80000000)
1241 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1245 /* Check for Ranga */
1246 if (Rvalue
> 0xffffffff)
1247 return bfd_reloc_overflow
;
1250 bfd_put_32 (input_bfd
, Rvalue
, hit_data
);
1255 return bfd_reloc_notsupported
;
1258 return bfd_reloc_ok
;
1261 /* Delete some bytes from a section while relaxing. */
1264 elf32_cr16_relax_delete_bytes (struct bfd_link_info
*link_info
, bfd
*abfd
,
1265 asection
*sec
, bfd_vma addr
, int count
)
1267 Elf_Internal_Shdr
*symtab_hdr
;
1268 unsigned int sec_shndx
;
1270 Elf_Internal_Rela
*irel
, *irelend
;
1272 Elf_Internal_Sym
*isym
;
1273 Elf_Internal_Sym
*isymend
;
1274 struct elf_link_hash_entry
**sym_hashes
;
1275 struct elf_link_hash_entry
**end_hashes
;
1276 struct elf_link_hash_entry
**start_hashes
;
1277 unsigned int symcount
;
1279 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1281 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1285 irel
= elf_section_data (sec
)->relocs
;
1286 irelend
= irel
+ sec
->reloc_count
;
1288 /* Actually delete the bytes. */
1289 memmove (contents
+ addr
, contents
+ addr
+ count
,
1290 (size_t) (toaddr
- addr
- count
));
1293 /* Adjust all the relocs. */
1294 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1295 /* Get the new reloc address. */
1296 if ((irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
))
1297 irel
->r_offset
-= count
;
1299 /* Adjust the local symbols defined in this section. */
1300 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1301 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1302 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1304 if (isym
->st_shndx
== sec_shndx
1305 && isym
->st_value
> addr
1306 && isym
->st_value
< toaddr
)
1308 /* Adjust the addend of SWITCH relocations in this section,
1309 which reference this local symbol. */
1311 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1313 unsigned long r_symndx
;
1314 Elf_Internal_Sym
*rsym
;
1315 bfd_vma addsym
, subsym
;
1317 /* Skip if not a SWITCH relocation. */
1318 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH8
1319 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH16
1320 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH32
)
1323 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1324 rsym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ r_symndx
;
1326 /* Skip if not the local adjusted symbol. */
1330 addsym
= isym
->st_value
;
1331 subsym
= addsym
- irel
->r_addend
;
1333 /* Fix the addend only when -->> (addsym > addr >= subsym). */
1335 irel
->r_addend
-= count
;
1341 isym
->st_value
-= count
;
1345 /* Now adjust the global symbols defined in this section. */
1346 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1347 - symtab_hdr
->sh_info
);
1348 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
1349 end_hashes
= sym_hashes
+ symcount
;
1351 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1353 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1355 /* The '--wrap SYMBOL' option is causing a pain when the object file,
1356 containing the definition of __wrap_SYMBOL, includes a direct
1357 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1358 the same symbol (which is __wrap_SYMBOL), but still exist as two
1359 different symbols in 'sym_hashes', we don't want to adjust
1360 the global symbol __wrap_SYMBOL twice.
1361 This check is only relevant when symbols are being wrapped. */
1362 if (link_info
->wrap_hash
!= NULL
)
1364 struct elf_link_hash_entry
**cur_sym_hashes
;
1366 /* Loop only over the symbols whom been already checked. */
1367 for (cur_sym_hashes
= start_hashes
; cur_sym_hashes
< sym_hashes
;
1369 /* If the current symbol is identical to 'sym_hash', that means
1370 the symbol was already adjusted (or at least checked). */
1371 if (*cur_sym_hashes
== sym_hash
)
1374 /* Don't adjust the symbol again. */
1375 if (cur_sym_hashes
< sym_hashes
)
1379 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1380 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1381 && sym_hash
->root
.u
.def
.section
== sec
1382 && sym_hash
->root
.u
.def
.value
> addr
1383 && sym_hash
->root
.u
.def
.value
< toaddr
)
1384 sym_hash
->root
.u
.def
.value
-= count
;
1390 /* Relocate a CR16 ELF section. */
1393 elf32_cr16_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1394 bfd
*input_bfd
, asection
*input_section
,
1395 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1396 Elf_Internal_Sym
*local_syms
,
1397 asection
**local_sections
)
1399 Elf_Internal_Shdr
*symtab_hdr
;
1400 struct elf_link_hash_entry
**sym_hashes
;
1401 Elf_Internal_Rela
*rel
, *relend
;
1403 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1404 sym_hashes
= elf_sym_hashes (input_bfd
);
1407 relend
= relocs
+ input_section
->reloc_count
;
1408 for (; rel
< relend
; rel
++)
1411 reloc_howto_type
*howto
;
1412 unsigned long r_symndx
;
1413 Elf_Internal_Sym
*sym
;
1415 struct elf_link_hash_entry
*h
;
1417 bfd_reloc_status_type r
;
1419 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1420 r_type
= ELF32_R_TYPE (rel
->r_info
);
1421 howto
= cr16_elf_howto_table
+ (r_type
);
1426 if (r_symndx
< symtab_hdr
->sh_info
)
1428 sym
= local_syms
+ r_symndx
;
1429 sec
= local_sections
[r_symndx
];
1430 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1434 bfd_boolean unresolved_reloc
, warned
, ignored
;
1436 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1437 r_symndx
, symtab_hdr
, sym_hashes
,
1439 unresolved_reloc
, warned
, ignored
);
1442 if (sec
!= NULL
&& discarded_section (sec
))
1443 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1444 rel
, 1, relend
, howto
, 0, contents
);
1446 if (bfd_link_relocatable (info
))
1449 r
= cr16_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
1451 contents
, rel
->r_offset
,
1452 relocation
, rel
->r_addend
,
1453 (struct elf_link_hash_entry
*) h
,
1455 info
, sec
, h
== NULL
);
1457 if (r
!= bfd_reloc_ok
)
1460 const char *msg
= NULL
;
1463 name
= h
->root
.root
.string
;
1466 name
= (bfd_elf_string_from_elf_section
1467 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1468 if (name
== NULL
|| *name
== '\0')
1469 name
= bfd_section_name (input_bfd
, sec
);
1474 case bfd_reloc_overflow
:
1475 (*info
->callbacks
->reloc_overflow
)
1476 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1477 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1480 case bfd_reloc_undefined
:
1481 (*info
->callbacks
->undefined_symbol
)
1482 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1485 case bfd_reloc_outofrange
:
1486 msg
= _("internal error: out of range error");
1489 case bfd_reloc_notsupported
:
1490 msg
= _("internal error: unsupported relocation error");
1493 case bfd_reloc_dangerous
:
1494 msg
= _("internal error: dangerous error");
1498 msg
= _("internal error: unknown error");
1502 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
1503 input_section
, rel
->r_offset
);
1512 /* This is a version of bfd_generic_get_relocated_section_contents
1513 which uses elf32_cr16_relocate_section. */
1516 elf32_cr16_get_relocated_section_contents (bfd
*output_bfd
,
1517 struct bfd_link_info
*link_info
,
1518 struct bfd_link_order
*link_order
,
1520 bfd_boolean relocatable
,
1523 Elf_Internal_Shdr
*symtab_hdr
;
1524 asection
*input_section
= link_order
->u
.indirect
.section
;
1525 bfd
*input_bfd
= input_section
->owner
;
1526 asection
**sections
= NULL
;
1527 Elf_Internal_Rela
*internal_relocs
= NULL
;
1528 Elf_Internal_Sym
*isymbuf
= NULL
;
1530 /* We only need to handle the case of relaxing, or of having a
1531 particular set of section contents, specially. */
1533 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1534 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1539 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1541 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1542 (size_t) input_section
->size
);
1544 if ((input_section
->flags
& SEC_RELOC
) != 0
1545 && input_section
->reloc_count
> 0)
1547 Elf_Internal_Sym
*isym
;
1548 Elf_Internal_Sym
*isymend
;
1552 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, input_section
,
1554 if (internal_relocs
== NULL
)
1557 if (symtab_hdr
->sh_info
!= 0)
1559 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1560 if (isymbuf
== NULL
)
1561 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1562 symtab_hdr
->sh_info
, 0,
1564 if (isymbuf
== NULL
)
1568 amt
= symtab_hdr
->sh_info
;
1569 amt
*= sizeof (asection
*);
1570 sections
= bfd_malloc (amt
);
1571 if (sections
== NULL
&& amt
!= 0)
1574 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1575 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1579 if (isym
->st_shndx
== SHN_UNDEF
)
1580 isec
= bfd_und_section_ptr
;
1581 else if (isym
->st_shndx
== SHN_ABS
)
1582 isec
= bfd_abs_section_ptr
;
1583 else if (isym
->st_shndx
== SHN_COMMON
)
1584 isec
= bfd_com_section_ptr
;
1586 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1591 if (! elf32_cr16_relocate_section (output_bfd
, link_info
, input_bfd
,
1592 input_section
, data
, internal_relocs
,
1596 if (sections
!= NULL
)
1599 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1601 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1602 free (internal_relocs
);
1608 if (sections
!= NULL
)
1611 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1613 if (internal_relocs
!= NULL
1614 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
1615 free (internal_relocs
);
1619 /* Assorted hash table functions. */
1621 /* Initialize an entry in the link hash table. */
1623 /* Create an entry in an CR16 ELF linker hash table. */
1625 static struct bfd_hash_entry
*
1626 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1627 struct bfd_hash_table
*table
,
1630 struct elf32_cr16_link_hash_entry
*ret
=
1631 (struct elf32_cr16_link_hash_entry
*) entry
;
1633 /* Allocate the structure if it has not already been allocated by a
1635 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1636 ret
= ((struct elf32_cr16_link_hash_entry
*)
1637 bfd_hash_allocate (table
,
1638 sizeof (struct elf32_cr16_link_hash_entry
)));
1639 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1640 return (struct bfd_hash_entry
*) ret
;
1642 /* Call the allocation method of the superclass. */
1643 ret
= ((struct elf32_cr16_link_hash_entry
*)
1644 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1646 if (ret
!= (struct elf32_cr16_link_hash_entry
*) NULL
)
1648 ret
->direct_calls
= 0;
1649 ret
->stack_size
= 0;
1651 ret
->movm_stack_size
= 0;
1656 return (struct bfd_hash_entry
*) ret
;
1659 /* Create an cr16 ELF linker hash table. */
1661 static struct bfd_link_hash_table
*
1662 elf32_cr16_link_hash_table_create (bfd
*abfd
)
1664 struct elf_link_hash_table
*ret
;
1665 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1667 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
1668 if (ret
== (struct elf_link_hash_table
*) NULL
)
1671 if (!_bfd_elf_link_hash_table_init (ret
, abfd
,
1672 elf32_cr16_link_hash_newfunc
,
1673 sizeof (struct elf32_cr16_link_hash_entry
),
1683 static unsigned long
1684 elf_cr16_mach (flagword flags
)
1690 return bfd_mach_cr16
;
1694 /* The final processing done just before writing out a CR16 ELF object
1695 file. This gets the CR16 architecture right based on the machine
1699 _bfd_cr16_elf_final_write_processing (bfd
*abfd
,
1700 bfd_boolean linker ATTRIBUTE_UNUSED
)
1703 switch (bfd_get_mach (abfd
))
1712 elf_elfheader (abfd
)->e_flags
|= val
;
1717 _bfd_cr16_elf_object_p (bfd
*abfd
)
1719 bfd_default_set_arch_mach (abfd
, bfd_arch_cr16
,
1720 elf_cr16_mach (elf_elfheader (abfd
)->e_flags
));
1724 /* Merge backend specific data from an object file to the output
1725 object file when linking. */
1728 _bfd_cr16_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1730 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1731 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1734 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1735 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
1737 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1738 bfd_get_mach (ibfd
)))
1746 /* This function handles relaxing for the CR16.
1748 There's quite a few relaxing opportunites available on the CR16:
1750 * bcond:24 -> bcond:16 1 byte
1751 * bcond:16 -> bcond:8 1 byte
1752 * arithmetic imm32 -> arithmetic imm20 12 bits
1753 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits
1755 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
1758 elf32_cr16_relax_section (bfd
*abfd
, asection
*sec
,
1759 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
1761 Elf_Internal_Shdr
*symtab_hdr
;
1762 Elf_Internal_Rela
*internal_relocs
;
1763 Elf_Internal_Rela
*irel
, *irelend
;
1764 bfd_byte
*contents
= NULL
;
1765 Elf_Internal_Sym
*isymbuf
= NULL
;
1767 /* Assume nothing changes. */
1770 /* We don't have to do anything for a relocatable link, if
1771 this section does not have relocs, or if this is not a
1773 if (bfd_link_relocatable (link_info
)
1774 || (sec
->flags
& SEC_RELOC
) == 0
1775 || sec
->reloc_count
== 0
1776 || (sec
->flags
& SEC_CODE
) == 0)
1779 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1781 /* Get a copy of the native relocations. */
1782 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
1783 link_info
->keep_memory
);
1784 if (internal_relocs
== NULL
)
1787 /* Walk through them looking for relaxing opportunities. */
1788 irelend
= internal_relocs
+ sec
->reloc_count
;
1789 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1793 /* If this isn't something that can be relaxed, then ignore
1795 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP16
1796 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP24
1797 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM32
1798 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM20
1799 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM16
)
1802 /* Get the section contents if we haven't done so already. */
1803 if (contents
== NULL
)
1805 /* Get cached copy if it exists. */
1806 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1807 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1808 /* Go get them off disk. */
1809 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1813 /* Read this BFD's local symbols if we haven't done so already. */
1814 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1816 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1817 if (isymbuf
== NULL
)
1818 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1819 symtab_hdr
->sh_info
, 0,
1821 if (isymbuf
== NULL
)
1825 /* Get the value of the symbol referred to by the reloc. */
1826 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1828 /* A local symbol. */
1829 Elf_Internal_Sym
*isym
;
1832 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1833 if (isym
->st_shndx
== SHN_UNDEF
)
1834 sym_sec
= bfd_und_section_ptr
;
1835 else if (isym
->st_shndx
== SHN_ABS
)
1836 sym_sec
= bfd_abs_section_ptr
;
1837 else if (isym
->st_shndx
== SHN_COMMON
)
1838 sym_sec
= bfd_com_section_ptr
;
1840 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1841 symval
= (isym
->st_value
1842 + sym_sec
->output_section
->vma
1843 + sym_sec
->output_offset
);
1848 struct elf_link_hash_entry
*h
;
1850 /* An external symbol. */
1851 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1852 h
= elf_sym_hashes (abfd
)[indx
];
1853 BFD_ASSERT (h
!= NULL
);
1855 if (h
->root
.type
!= bfd_link_hash_defined
1856 && h
->root
.type
!= bfd_link_hash_defweak
)
1857 /* This appears to be a reference to an undefined
1858 symbol. Just ignore it--it will be caught by the
1859 regular reloc processing. */
1862 symval
= (h
->root
.u
.def
.value
1863 + h
->root
.u
.def
.section
->output_section
->vma
1864 + h
->root
.u
.def
.section
->output_offset
);
1867 /* For simplicity of coding, we are going to modify the section
1868 contents, the section relocs, and the BFD symbol table. We
1869 must tell the rest of the code not to free up this
1870 information. It would be possible to instead create a table
1871 of changes which have to be made, as is done in coff-mips.c;
1872 that would be more work, but would require less memory when
1873 the linker is run. */
1875 /* Try to turn a 24 branch/call into a 16bit relative
1877 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP24
)
1879 bfd_vma value
= symval
;
1881 /* Deal with pc-relative gunk. */
1882 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1883 value
-= irel
->r_offset
;
1884 value
+= irel
->r_addend
;
1886 /* See if the value will fit in 16 bits, note the high value is
1887 0xfffe + 2 as the target will be two bytes closer if we are
1889 if ((long) value
< 0x10000 && (long) value
> -0x10002)
1893 /* Get the opcode. */
1894 code
= (unsigned int) bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1896 /* Verify it's a 'bcond' and fix the opcode. */
1897 if ((code
& 0xffff) == 0x0010)
1898 bfd_put_16 (abfd
, 0x1800 | ((0xf & (code
>> 20)) << 4), contents
+ irel
->r_offset
);
1902 /* Note that we've changed the relocs, section contents, etc. */
1903 elf_section_data (sec
)->relocs
= internal_relocs
;
1904 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1905 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1907 /* Fix the relocation's type. */
1908 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1911 /* Delete two bytes of data. */
1912 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1913 irel
->r_offset
+ 2, 2))
1916 /* That will change things, so, we should relax again.
1917 Note that this is not required, and it may be slow. */
1922 /* Try to turn a 16bit pc-relative branch into an
1923 8bit pc-relative branch. */
1924 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP16
)
1926 bfd_vma value
= symval
;
1928 /* Deal with pc-relative gunk. */
1929 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1930 value
-= irel
->r_offset
;
1931 value
+= irel
->r_addend
;
1933 /* See if the value will fit in 8 bits, note the high value is
1934 0xfc + 2 as the target will be two bytes closer if we are
1936 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1937 if ((long) value
< 0xfa && (long) value
> -0x100)
1939 unsigned short code
;
1941 /* Get the opcode. */
1942 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1944 /* Verify it's a 'bcond' and fix the opcode. */
1945 if ((code
& 0xff0f) == 0x1800)
1946 bfd_put_16 (abfd
, (code
& 0xf0f0), contents
+ irel
->r_offset
);
1950 /* Note that we've changed the relocs, section contents, etc. */
1951 elf_section_data (sec
)->relocs
= internal_relocs
;
1952 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1953 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1955 /* Fix the relocation's type. */
1956 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1959 /* Delete two bytes of data. */
1960 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1961 irel
->r_offset
+ 2, 2))
1964 /* That will change things, so, we should relax again.
1965 Note that this is not required, and it may be slow. */
1970 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1971 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM32
)
1973 bfd_vma value
= symval
;
1974 unsigned short is_add_mov
= 0;
1977 /* Get the existing value from the mcode */
1978 value1
= ((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) >> 16)
1979 |(((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff) << 16)));
1981 /* See if the value will fit in 20 bits. */
1982 if ((long) (value
+ value1
) < 0xfffff && (long) (value
+ value1
) > 0)
1984 unsigned short code
;
1986 /* Get the opcode. */
1987 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1989 /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1990 For ADDD and MOVD only, convert to IMM32 -> IMM20. */
1992 if (((code
& 0xfff0) == 0x0070) || ((code
& 0xfff0) == 0x0020))
1997 /* Note that we've changed the relocs, section contents,
1999 elf_section_data (sec
)->relocs
= internal_relocs
;
2000 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2001 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2003 /* Fix the opcode. */
2004 if ((code
& 0xfff0) == 0x0070) /* For movd. */
2005 bfd_put_8 (abfd
, 0x05, contents
+ irel
->r_offset
+ 1);
2006 else /* code == 0x0020 for addd. */
2007 bfd_put_8 (abfd
, 0x04, contents
+ irel
->r_offset
+ 1);
2009 bfd_put_8 (abfd
, (code
& 0xf) << 4, contents
+ irel
->r_offset
);
2011 /* If existing value is nagavive adjust approriately
2012 place the 16-20bits (ie 4 bit) in new opcode,
2013 as the 0xffffxxxx, the higher 2 byte values removed. */
2014 if (value1
& 0x80000000)
2015 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2017 bfd_put_8 (abfd
, (((value1
>> 16)&0xf) | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2019 /* Fix the relocation's type. */
2020 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2023 /* Delete two bytes of data. */
2024 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2025 irel
->r_offset
+ 2, 2))
2028 /* That will change things, so, we should relax again.
2029 Note that this is not required, and it may be slow. */
2034 /* See if the value will fit in 16 bits. */
2036 && ((long)(value
+ value1
) < 0x7fff && (long)(value
+ value1
) > 0))
2038 unsigned short code
;
2040 /* Get the opcode. */
2041 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2043 /* Note that we've changed the relocs, section contents, etc. */
2044 elf_section_data (sec
)->relocs
= internal_relocs
;
2045 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2046 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2048 /* Fix the opcode. */
2049 if ((code
& 0xf0) == 0x70) /* For movd. */
2050 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
+ 1);
2051 else if ((code
& 0xf0) == 0x20) /* For addd. */
2052 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
+ 1);
2053 else if ((code
& 0xf0) == 0x90) /* For cmpd. */
2054 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
+ 1);
2058 bfd_put_8 (abfd
, 0xb0 | (code
& 0xf), contents
+ irel
->r_offset
);
2060 /* If existing value is nagavive adjust approriately
2061 place the 12-16bits (ie 4 bit) in new opcode,
2062 as the 0xfffffxxx, the higher 2 byte values removed. */
2063 if (value1
& 0x80000000)
2064 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2066 bfd_put_16 (abfd
, value1
, contents
+ irel
->r_offset
+ 2);
2069 /* Fix the relocation's type. */
2070 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2073 /* Delete two bytes of data. */
2074 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2075 irel
->r_offset
+ 2, 2))
2078 /* That will change things, so, we should relax again.
2079 Note that this is not required, and it may be slow. */
2085 /* Try to turn a 16bit immediate address into a 4bit
2086 immediate address. */
2087 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2088 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM16
))
2090 bfd_vma value
= symval
;
2093 /* Get the existing value from the mcode */
2094 value1
= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff));
2096 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2098 value1
|= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 1) & 0xf000) << 0x4);
2101 /* See if the value will fit in 4 bits. */
2102 if ((((long) (value
+ value1
)) < 0xf)
2103 && (((long) (value
+ value1
)) > 0))
2105 unsigned short code
;
2107 /* Get the opcode. */
2108 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2110 /* Note that we've changed the relocs, section contents, etc. */
2111 elf_section_data (sec
)->relocs
= internal_relocs
;
2112 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2113 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2115 /* Fix the opcode. */
2116 if (((code
& 0x0f00) == 0x0400) || ((code
& 0x0f00) == 0x0500))
2118 if ((code
& 0x0f00) == 0x0400) /* For movd imm20. */
2119 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2120 else /* For addd imm20. */
2121 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2122 bfd_put_8 (abfd
, (code
& 0xf0) >> 4, contents
+ irel
->r_offset
+ 1);
2126 if ((code
& 0xfff0) == 0x56b0) /* For cmpd imm16. */
2127 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
);
2128 else if ((code
& 0xfff0) == 0x54b0) /* For movd imm16. */
2129 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2130 else if ((code
& 0xfff0) == 0x58b0) /* For movb imm16. */
2131 bfd_put_8 (abfd
, 0x58, contents
+ irel
->r_offset
);
2132 else if ((code
& 0xfff0) == 0x5Ab0) /* For movw imm16. */
2133 bfd_put_8 (abfd
, 0x5A, contents
+ irel
->r_offset
);
2134 else if ((code
& 0xfff0) == 0x60b0) /* For addd imm16. */
2135 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2136 else if ((code
& 0xfff0) == 0x30b0) /* For addb imm16. */
2137 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
);
2138 else if ((code
& 0xfff0) == 0x2Cb0) /* For addub imm16. */
2139 bfd_put_8 (abfd
, 0x2C, contents
+ irel
->r_offset
);
2140 else if ((code
& 0xfff0) == 0x32b0) /* For adduw imm16. */
2141 bfd_put_8 (abfd
, 0x32, contents
+ irel
->r_offset
);
2142 else if ((code
& 0xfff0) == 0x38b0) /* For subb imm16. */
2143 bfd_put_8 (abfd
, 0x38, contents
+ irel
->r_offset
);
2144 else if ((code
& 0xfff0) == 0x3Cb0) /* For subcb imm16. */
2145 bfd_put_8 (abfd
, 0x3C, contents
+ irel
->r_offset
);
2146 else if ((code
& 0xfff0) == 0x3Fb0) /* For subcw imm16. */
2147 bfd_put_8 (abfd
, 0x3F, contents
+ irel
->r_offset
);
2148 else if ((code
& 0xfff0) == 0x3Ab0) /* For subw imm16. */
2149 bfd_put_8 (abfd
, 0x3A, contents
+ irel
->r_offset
);
2150 else if ((code
& 0xfff0) == 0x50b0) /* For cmpb imm16. */
2151 bfd_put_8 (abfd
, 0x50, contents
+ irel
->r_offset
);
2152 else if ((code
& 0xfff0) == 0x52b0) /* For cmpw imm16. */
2153 bfd_put_8 (abfd
, 0x52, contents
+ irel
->r_offset
);
2157 bfd_put_8 (abfd
, (code
& 0xf), contents
+ irel
->r_offset
+ 1);
2160 /* Fix the relocation's type. */
2161 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2164 /* Delete two bytes of data. */
2165 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2166 irel
->r_offset
+ 2, 2))
2169 /* That will change things, so, we should relax again.
2170 Note that this is not required, and it may be slow. */
2178 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2180 if (! link_info
->keep_memory
)
2183 /* Cache the symbols for elf_link_input_bfd. */
2184 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2187 if (contents
!= NULL
2188 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2190 if (! link_info
->keep_memory
)
2193 /* Cache the section contents for elf_link_input_bfd. */
2194 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2198 if (internal_relocs
!= NULL
2199 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2200 free (internal_relocs
);
2206 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2208 if (contents
!= NULL
2209 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2211 if (internal_relocs
!= NULL
2212 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2213 free (internal_relocs
);
2219 elf32_cr16_gc_mark_hook (asection
*sec
,
2220 struct bfd_link_info
*info
,
2221 Elf_Internal_Rela
*rel
,
2222 struct elf_link_hash_entry
*h
,
2223 Elf_Internal_Sym
*sym
)
2225 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2228 /* Update the got entry reference counts for the section being removed. */
2231 elf32_cr16_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2232 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2233 asection
*sec ATTRIBUTE_UNUSED
,
2234 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
2236 /* We don't support garbage collection of GOT and PLT relocs yet. */
2240 /* Create dynamic sections when linking against a dynamic object. */
2243 _bfd_cr16_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2247 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
2250 switch (bed
->s
->arch_size
)
2261 bfd_set_error (bfd_error_bad_value
);
2265 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2266 .rel[a].bss sections. */
2268 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2269 | SEC_LINKER_CREATED
);
2271 s
= bfd_make_section_anyway_with_flags (abfd
,
2272 (bed
->default_use_rela_p
2273 ? ".rela.plt" : ".rel.plt"),
2274 flags
| SEC_READONLY
);
2276 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2279 if (! _bfd_cr16_elf_create_got_section (abfd
, info
))
2282 if (bed
->want_dynbss
)
2284 /* The .dynbss section is a place to put symbols which are defined
2285 by dynamic objects, are referenced by regular objects, and are
2286 not functions. We must allocate space for them in the process
2287 image and use a R_*_COPY reloc to tell the dynamic linker to
2288 initialize them at run time. The linker script puts the .dynbss
2289 section into the .bss section of the final image. */
2290 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2291 SEC_ALLOC
| SEC_LINKER_CREATED
);
2295 /* The .rel[a].bss section holds copy relocs. This section is not
2296 normally needed. We need to create it here, though, so that the
2297 linker will map it to an output section. We can't just create it
2298 only if we need it, because we will not know whether we need it
2299 until we have seen all the input files, and the first time the
2300 main linker code calls BFD after examining all the input files
2301 (size_dynamic_sections) the input sections have already been
2302 mapped to the output sections. If the section turns out not to
2303 be needed, we can discard it later. We will never need this
2304 section when generating a shared object, since they do not use
2306 if (! bfd_link_executable (info
))
2308 s
= bfd_make_section_anyway_with_flags (abfd
,
2309 (bed
->default_use_rela_p
2310 ? ".rela.bss" : ".rel.bss"),
2311 flags
| SEC_READONLY
);
2313 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2321 /* Adjust a symbol defined by a dynamic object and referenced by a
2322 regular object. The current definition is in some section of the
2323 dynamic object, but we're not including those sections. We have to
2324 change the definition to something the rest of the link can
2328 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info
* info
,
2329 struct elf_link_hash_entry
* h
)
2334 dynobj
= elf_hash_table (info
)->dynobj
;
2336 /* Make sure we know what is going on here. */
2337 BFD_ASSERT (dynobj
!= NULL
2339 || h
->u
.weakdef
!= NULL
2342 && !h
->def_regular
)));
2344 /* If this is a function, put it in the procedure linkage table. We
2345 will fill in the contents of the procedure linkage table later,
2346 when we know the address of the .got section. */
2347 if (h
->type
== STT_FUNC
2350 if (! bfd_link_executable (info
)
2354 /* This case can occur if we saw a PLT reloc in an input
2355 file, but the symbol was never referred to by a dynamic
2356 object. In such a case, we don't actually need to build
2357 a procedure linkage table, and we can just do a REL32
2359 BFD_ASSERT (h
->needs_plt
);
2363 /* Make sure this symbol is output as a dynamic symbol. */
2364 if (h
->dynindx
== -1)
2366 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2370 /* We also need to make an entry in the .got.plt section, which
2371 will be placed in the .got section by the linker script. */
2373 s
= bfd_get_linker_section (dynobj
, ".got.plt");
2374 BFD_ASSERT (s
!= NULL
);
2377 /* We also need to make an entry in the .rela.plt section. */
2379 s
= bfd_get_linker_section (dynobj
, ".rela.plt");
2380 BFD_ASSERT (s
!= NULL
);
2381 s
->size
+= sizeof (Elf32_External_Rela
);
2386 /* If this is a weak symbol, and there is a real definition, the
2387 processor independent code will have arranged for us to see the
2388 real definition first, and we can just use the same value. */
2389 if (h
->u
.weakdef
!= NULL
)
2391 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2392 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2393 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2394 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2398 /* This is a reference to a symbol defined by a dynamic object which
2399 is not a function. */
2401 /* If we are creating a shared library, we must presume that the
2402 only references to the symbol are via the global offset table.
2403 For such cases we need not do anything here; the relocations will
2404 be handled correctly by relocate_section. */
2405 if (bfd_link_executable (info
))
2408 /* If there are no references to this symbol that do not use the
2409 GOT, we don't need to generate a copy reloc. */
2410 if (!h
->non_got_ref
)
2413 /* We must allocate the symbol in our .dynbss section, which will
2414 become part of the .bss section of the executable. There will be
2415 an entry for this symbol in the .dynsym section. The dynamic
2416 object will contain position independent code, so all references
2417 from the dynamic object to this symbol will go through the global
2418 offset table. The dynamic linker will use the .dynsym entry to
2419 determine the address it must put in the global offset table, so
2420 both the dynamic object and the regular object will refer to the
2421 same memory location for the variable. */
2423 s
= bfd_get_linker_section (dynobj
, ".dynbss");
2424 BFD_ASSERT (s
!= NULL
);
2426 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2427 copy the initial value out of the dynamic object and into the
2428 runtime process image. We need to remember the offset into the
2429 .rela.bss section we are going to use. */
2430 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2434 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
2435 BFD_ASSERT (srel
!= NULL
);
2436 srel
->size
+= sizeof (Elf32_External_Rela
);
2440 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2443 /* Set the sizes of the dynamic sections. */
2446 _bfd_cr16_elf_size_dynamic_sections (bfd
* output_bfd
,
2447 struct bfd_link_info
* info
)
2453 bfd_boolean reltext
;
2455 dynobj
= elf_hash_table (info
)->dynobj
;
2456 BFD_ASSERT (dynobj
!= NULL
);
2458 if (elf_hash_table (info
)->dynamic_sections_created
)
2460 /* Set the contents of the .interp section to the interpreter. */
2461 if (bfd_link_executable (info
) && !info
->nointerp
)
2464 s
= bfd_get_linker_section (dynobj
, ".interp");
2465 BFD_ASSERT (s
!= NULL
);
2466 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2467 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2473 /* We may have created entries in the .rela.got section.
2474 However, if we are not creating the dynamic sections, we will
2475 not actually use these entries. Reset the size of .rela.got,
2476 which will cause it to get stripped from the output file
2478 s
= bfd_get_linker_section (dynobj
, ".rela.got");
2483 /* The check_relocs and adjust_dynamic_symbol entry points have
2484 determined the sizes of the various dynamic sections. Allocate
2489 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2493 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2496 /* It's OK to base decisions on the section name, because none
2497 of the dynobj section names depend upon the input files. */
2498 name
= bfd_get_section_name (dynobj
, s
);
2500 if (strcmp (name
, ".plt") == 0)
2502 /* Remember whether there is a PLT. */
2505 else if (CONST_STRNEQ (name
, ".rela"))
2511 /* Remember whether there are any reloc sections other
2513 if (strcmp (name
, ".rela.plt") != 0)
2515 const char * outname
;
2519 /* If this relocation section applies to a read only
2520 section, then we probably need a DT_TEXTREL
2521 entry. The entries in the .rela.plt section
2522 really apply to the .got section, which we
2523 created ourselves and so know is not readonly. */
2524 outname
= bfd_get_section_name (output_bfd
,
2526 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
2528 && (target
->flags
& SEC_READONLY
) != 0
2529 && (target
->flags
& SEC_ALLOC
) != 0)
2533 /* We use the reloc_count field as a counter if we need
2534 to copy relocs into the output file. */
2538 else if (! CONST_STRNEQ (name
, ".got")
2539 && strcmp (name
, ".dynbss") != 0)
2540 /* It's not one of our sections, so don't allocate space. */
2545 /* If we don't need this section, strip it from the
2546 output file. This is mostly to handle .rela.bss and
2547 .rela.plt. We must create both sections in
2548 create_dynamic_sections, because they must be created
2549 before the linker maps input sections to output
2550 sections. The linker does that before
2551 adjust_dynamic_symbol is called, and it is that
2552 function which decides whether anything needs to go
2553 into these sections. */
2554 s
->flags
|= SEC_EXCLUDE
;
2558 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2561 /* Allocate memory for the section contents. We use bfd_zalloc
2562 here in case unused entries are not reclaimed before the
2563 section's contents are written out. This should not happen,
2564 but this way if it does, we get a R_CR16_NONE reloc
2565 instead of garbage. */
2566 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2567 if (s
->contents
== NULL
)
2571 if (elf_hash_table (info
)->dynamic_sections_created
)
2573 /* Add some entries to the .dynamic section. We fill in the
2574 values later, in _bfd_cr16_elf_finish_dynamic_sections,
2575 but we must add the entries now so that we get the correct
2576 size for the .dynamic section. The DT_DEBUG entry is filled
2577 in by the dynamic linker and used by the debugger. */
2578 if (! bfd_link_executable (info
))
2580 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2586 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2587 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2588 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2589 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2595 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2596 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2597 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2598 sizeof (Elf32_External_Rela
)))
2604 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2612 /* Finish up dynamic symbol handling. We set the contents of various
2613 dynamic sections here. */
2616 _bfd_cr16_elf_finish_dynamic_symbol (bfd
* output_bfd
,
2617 struct bfd_link_info
* info
,
2618 struct elf_link_hash_entry
* h
,
2619 Elf_Internal_Sym
* sym
)
2623 dynobj
= elf_hash_table (info
)->dynobj
;
2625 if (h
->got
.offset
!= (bfd_vma
) -1)
2629 Elf_Internal_Rela rel
;
2631 /* This symbol has an entry in the global offset table. Set it up. */
2633 sgot
= bfd_get_linker_section (dynobj
, ".got");
2634 srel
= bfd_get_linker_section (dynobj
, ".rela.got");
2635 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2637 rel
.r_offset
= (sgot
->output_section
->vma
2638 + sgot
->output_offset
2639 + (h
->got
.offset
& ~1));
2641 /* If this is a -Bsymbolic link, and the symbol is defined
2642 locally, we just want to emit a RELATIVE reloc. Likewise if
2643 the symbol was forced to be local because of a version file.
2644 The entry in the global offset table will already have been
2645 initialized in the relocate_section function. */
2646 if (bfd_link_executable (info
)
2647 && (info
->symbolic
|| h
->dynindx
== -1)
2650 rel
.r_info
= ELF32_R_INFO (0, R_CR16_GOT_REGREL20
);
2651 rel
.r_addend
= (h
->root
.u
.def
.value
2652 + h
->root
.u
.def
.section
->output_section
->vma
2653 + h
->root
.u
.def
.section
->output_offset
);
2657 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2658 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2662 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2663 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
2664 + srel
->reloc_count
));
2665 ++ srel
->reloc_count
;
2671 Elf_Internal_Rela rel
;
2673 /* This symbol needs a copy reloc. Set it up. */
2674 BFD_ASSERT (h
->dynindx
!= -1
2675 && (h
->root
.type
== bfd_link_hash_defined
2676 || h
->root
.type
== bfd_link_hash_defweak
));
2678 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
2679 BFD_ASSERT (s
!= NULL
);
2681 rel
.r_offset
= (h
->root
.u
.def
.value
2682 + h
->root
.u
.def
.section
->output_section
->vma
2683 + h
->root
.u
.def
.section
->output_offset
);
2684 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2686 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2687 (bfd_byte
*) ((Elf32_External_Rela
*) s
->contents
2692 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2693 if (h
== elf_hash_table (info
)->hdynamic
2694 || h
== elf_hash_table (info
)->hgot
)
2695 sym
->st_shndx
= SHN_ABS
;
2700 /* Finish up the dynamic sections. */
2703 _bfd_cr16_elf_finish_dynamic_sections (bfd
* output_bfd
,
2704 struct bfd_link_info
* info
)
2710 dynobj
= elf_hash_table (info
)->dynobj
;
2712 sgot
= bfd_get_linker_section (dynobj
, ".got.plt");
2713 BFD_ASSERT (sgot
!= NULL
);
2714 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2716 if (elf_hash_table (info
)->dynamic_sections_created
)
2718 Elf32_External_Dyn
* dyncon
;
2719 Elf32_External_Dyn
* dynconend
;
2721 BFD_ASSERT (sdyn
!= NULL
);
2723 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2724 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2726 for (; dyncon
< dynconend
; dyncon
++)
2728 Elf_Internal_Dyn dyn
;
2732 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2746 s
= bfd_get_linker_section (dynobj
, name
);
2747 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2748 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2752 s
= bfd_get_linker_section (dynobj
, ".rela.plt");
2753 dyn
.d_un
.d_val
= s
->size
;
2754 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2758 /* My reading of the SVR4 ABI indicates that the
2759 procedure linkage table relocs (DT_JMPREL) should be
2760 included in the overall relocs (DT_RELA). This is
2761 what Solaris does. However, UnixWare can not handle
2762 that case. Therefore, we override the DT_RELASZ entry
2763 here to make it not include the JMPREL relocs. Since
2764 the linker script arranges for .rela.plt to follow all
2765 other relocation sections, we don't have to worry
2766 about changing the DT_RELA entry. */
2767 s
= bfd_get_linker_section (dynobj
, ".rela.plt");
2769 dyn
.d_un
.d_val
-= s
->size
;
2770 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2777 /* Fill in the first three entries in the global offset table. */
2781 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2783 bfd_put_32 (output_bfd
,
2784 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2788 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2793 /* Given a .data.rel section and a .emreloc in-memory section, store
2794 relocation information into the .emreloc section which can be
2795 used at runtime to relocate the section. This is called by the
2796 linker when the --embedded-relocs switch is used. This is called
2797 after the add_symbols entry point has been called for all the
2798 objects, and before the final_link entry point is called. */
2801 bfd_cr16_elf32_create_embedded_relocs (bfd
*abfd
,
2802 struct bfd_link_info
*info
,
2807 Elf_Internal_Shdr
*symtab_hdr
;
2808 Elf_Internal_Sym
*isymbuf
= NULL
;
2809 Elf_Internal_Rela
*internal_relocs
= NULL
;
2810 Elf_Internal_Rela
*irel
, *irelend
;
2814 BFD_ASSERT (! bfd_link_relocatable (info
));
2818 if (datasec
->reloc_count
== 0)
2821 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2823 /* Get a copy of the native relocations. */
2824 internal_relocs
= (_bfd_elf_link_read_relocs
2825 (abfd
, datasec
, NULL
, NULL
, info
->keep_memory
));
2826 if (internal_relocs
== NULL
)
2829 amt
= (bfd_size_type
) datasec
->reloc_count
* 8;
2830 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2831 if (relsec
->contents
== NULL
)
2834 p
= relsec
->contents
;
2836 irelend
= internal_relocs
+ datasec
->reloc_count
;
2837 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 8)
2839 asection
*targetsec
;
2841 /* We are going to write a four byte longword into the runtime
2842 reloc section. The longword will be the address in the data
2843 section which must be relocated. It is followed by the name
2844 of the target section NUL-padded or truncated to 8
2847 /* We can only relocate absolute longword relocs at run time. */
2848 if (!((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2849 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32
)))
2851 *errmsg
= _("unsupported reloc type");
2852 bfd_set_error (bfd_error_bad_value
);
2856 /* Get the target section referred to by the reloc. */
2857 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2859 /* A local symbol. */
2860 Elf_Internal_Sym
*isym
;
2862 /* Read this BFD's local symbols if we haven't done so already. */
2863 if (isymbuf
== NULL
)
2865 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2866 if (isymbuf
== NULL
)
2867 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2868 symtab_hdr
->sh_info
, 0,
2870 if (isymbuf
== NULL
)
2874 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2875 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2880 struct elf_link_hash_entry
*h
;
2882 /* An external symbol. */
2883 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2884 h
= elf_sym_hashes (abfd
)[indx
];
2885 BFD_ASSERT (h
!= NULL
);
2886 if (h
->root
.type
== bfd_link_hash_defined
2887 || h
->root
.type
== bfd_link_hash_defweak
)
2888 targetsec
= h
->root
.u
.def
.section
;
2893 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2894 memset (p
+ 4, 0, 4);
2895 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2896 && (targetsec
!= NULL
) )
2897 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 4);
2900 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2902 if (internal_relocs
!= NULL
2903 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2904 free (internal_relocs
);
2908 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2910 if (internal_relocs
!= NULL
2911 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2912 free (internal_relocs
);
2917 /* Classify relocation types, such that combreloc can sort them
2920 static enum elf_reloc_type_class
2921 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2922 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2923 const Elf_Internal_Rela
*rela
)
2925 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2927 case R_CR16_GOT_REGREL20
:
2928 case R_CR16_GOTC_REGREL20
:
2929 return reloc_class_relative
;
2931 return reloc_class_normal
;
2935 /* Definitions for setting CR16 target vector. */
2936 #define TARGET_LITTLE_SYM cr16_elf32_vec
2937 #define TARGET_LITTLE_NAME "elf32-cr16"
2938 #define ELF_ARCH bfd_arch_cr16
2939 #define ELF_MACHINE_CODE EM_CR16
2940 #define ELF_MACHINE_ALT1 EM_CR16_OLD
2941 #define ELF_MAXPAGESIZE 0x1
2942 #define elf_symbol_leading_char '_'
2944 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup
2945 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup
2946 #define elf_info_to_howto elf_cr16_info_to_howto
2947 #define elf_info_to_howto_rel 0
2948 #define elf_backend_relocate_section elf32_cr16_relocate_section
2949 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section
2950 #define bfd_elf32_bfd_get_relocated_section_contents \
2951 elf32_cr16_get_relocated_section_contents
2952 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook
2953 #define elf_backend_gc_sweep_hook elf32_cr16_gc_sweep_hook
2954 #define elf_backend_can_gc_sections 1
2955 #define elf_backend_rela_normal 1
2956 #define elf_backend_check_relocs cr16_elf_check_relocs
2957 /* So we can set bits in e_flags. */
2958 #define elf_backend_final_write_processing \
2959 _bfd_cr16_elf_final_write_processing
2960 #define elf_backend_object_p _bfd_cr16_elf_object_p
2962 #define bfd_elf32_bfd_merge_private_bfd_data \
2963 _bfd_cr16_elf_merge_private_bfd_data
2966 #define bfd_elf32_bfd_link_hash_table_create \
2967 elf32_cr16_link_hash_table_create
2969 #define elf_backend_create_dynamic_sections \
2970 _bfd_cr16_elf_create_dynamic_sections
2971 #define elf_backend_adjust_dynamic_symbol \
2972 _bfd_cr16_elf_adjust_dynamic_symbol
2973 #define elf_backend_size_dynamic_sections \
2974 _bfd_cr16_elf_size_dynamic_sections
2975 #define elf_backend_omit_section_dynsym \
2976 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2977 #define elf_backend_finish_dynamic_symbol \
2978 _bfd_cr16_elf_finish_dynamic_symbol
2979 #define elf_backend_finish_dynamic_sections \
2980 _bfd_cr16_elf_finish_dynamic_sections
2982 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class
2985 #define elf_backend_want_got_plt 1
2986 #define elf_backend_plt_readonly 1
2987 #define elf_backend_want_plt_sym 0
2988 #define elf_backend_got_header_size 12
2990 #include "elf32-target.h"