1 /* BFD back-end for National Semiconductor's CR16 ELF
2 Copyright (C) 2007-2017 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
);
585 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
588 /* This function may be called more than once. */
589 if (htab
->sgot
!= NULL
)
592 switch (bed
->s
->arch_size
)
603 bfd_set_error (bfd_error_bad_value
);
607 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
608 | SEC_LINKER_CREATED
);
610 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
613 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
616 if (bed
->want_got_plt
)
618 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
621 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
625 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
626 (or .got.plt) section. We don't do this in the linker script
627 because we don't want to define the symbol if we are not creating
628 a global offset table. */
629 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_GLOBAL_OFFSET_TABLE_");
634 /* The first bit of the global offset table is the header. */
635 s
->size
+= bed
->got_header_size
;
641 /* Retrieve a howto ptr using a BFD reloc_code. */
643 static reloc_howto_type
*
644 elf_cr16_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
645 bfd_reloc_code_real_type code
)
649 for (i
= 0; i
< R_CR16_MAX
; i
++)
650 if (code
== cr16_reloc_map
[i
].bfd_reloc_enum
)
651 return &cr16_elf_howto_table
[cr16_reloc_map
[i
].cr16_reloc_type
];
653 _bfd_error_handler (_("Unsupported CR16 relocation type: 0x%x\n"), code
);
657 static reloc_howto_type
*
658 elf_cr16_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
663 for (i
= 0; ARRAY_SIZE (cr16_elf_howto_table
); i
++)
664 if (cr16_elf_howto_table
[i
].name
!= NULL
665 && strcasecmp (cr16_elf_howto_table
[i
].name
, r_name
) == 0)
666 return cr16_elf_howto_table
+ i
;
671 /* Retrieve a howto ptr using an internal relocation entry. */
674 elf_cr16_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
675 Elf_Internal_Rela
*dst
)
677 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
679 if (r_type
>= R_CR16_MAX
)
681 /* xgettext:c-format */
682 _bfd_error_handler (_("%B: unrecognised CR16 reloc number: %d"),
684 bfd_set_error (bfd_error_bad_value
);
685 r_type
= R_CR16_NONE
;
687 cache_ptr
->howto
= cr16_elf_howto_table
+ r_type
;
690 /* Look through the relocs for a section during the first phase.
691 Since we don't do .gots or .plts, we just need to consider the
692 virtual table relocs for gc. */
695 cr16_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
696 const Elf_Internal_Rela
*relocs
)
698 Elf_Internal_Shdr
*symtab_hdr
;
699 Elf_Internal_Sym
* isymbuf
= NULL
;
700 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
701 const Elf_Internal_Rela
*rel
;
702 const Elf_Internal_Rela
*rel_end
;
704 bfd_vma
* local_got_offsets
;
710 bfd_boolean result
= FALSE
;
712 if (bfd_link_relocatable (info
))
715 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
716 sym_hashes
= elf_sym_hashes (abfd
);
717 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
718 if (!elf_bad_symtab (abfd
))
719 sym_hashes_end
-= symtab_hdr
->sh_info
;
721 dynobj
= elf_hash_table (info
)->dynobj
;
722 local_got_offsets
= elf_local_got_offsets (abfd
);
723 rel_end
= relocs
+ sec
->reloc_count
;
724 for (rel
= relocs
; rel
< rel_end
; rel
++)
726 struct elf_link_hash_entry
*h
;
727 unsigned long r_symndx
;
729 r_symndx
= ELF32_R_SYM (rel
->r_info
);
730 if (r_symndx
< symtab_hdr
->sh_info
)
734 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
735 while (h
->root
.type
== bfd_link_hash_indirect
736 || h
->root
.type
== bfd_link_hash_warning
)
737 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
739 /* PR15323, ref flags aren't set for references in the same
741 h
->root
.non_ir_ref_regular
= 1;
744 /* Some relocs require a global offset table. */
747 switch (ELF32_R_TYPE (rel
->r_info
))
749 case R_CR16_GOT_REGREL20
:
750 case R_CR16_GOTC_REGREL20
:
751 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
752 if (! _bfd_cr16_elf_create_got_section (dynobj
, info
))
761 switch (ELF32_R_TYPE (rel
->r_info
))
763 case R_CR16_GOT_REGREL20
:
764 case R_CR16_GOTC_REGREL20
:
765 /* This symbol requires a global offset table entry. */
767 sgot
= elf_hash_table (info
)->sgot
;
768 srelgot
= elf_hash_table (info
)->srelgot
;
769 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
773 if (h
->got
.offset
!= (bfd_vma
) -1)
774 /* We have already allocated space in the .got. */
777 h
->got
.offset
= sgot
->size
;
779 /* Make sure this symbol is output as a dynamic symbol. */
780 if (h
->dynindx
== -1)
782 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
786 srelgot
->size
+= sizeof (Elf32_External_Rela
);
790 /* This is a global offset table entry for a local
792 if (local_got_offsets
== NULL
)
797 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
798 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
800 if (local_got_offsets
== NULL
)
803 elf_local_got_offsets (abfd
) = local_got_offsets
;
805 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
806 local_got_offsets
[i
] = (bfd_vma
) -1;
809 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
810 /* We have already allocated space in the .got. */
813 local_got_offsets
[r_symndx
] = sgot
->size
;
815 if (bfd_link_executable (info
))
816 /* If we are generating a shared object, we need to
817 output a R_CR16_RELATIVE reloc so that the dynamic
818 linker can adjust this GOT entry. */
819 srelgot
->size
+= sizeof (Elf32_External_Rela
);
836 /* Perform a relocation as part of a final link. */
838 static bfd_reloc_status_type
839 cr16_elf_final_link_relocate (reloc_howto_type
*howto
,
841 bfd
*output_bfd ATTRIBUTE_UNUSED
,
842 asection
*input_section
,
847 struct elf_link_hash_entry
* h
,
848 unsigned long symndx ATTRIBUTE_UNUSED
,
849 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
850 asection
*sec ATTRIBUTE_UNUSED
,
851 int is_local ATTRIBUTE_UNUSED
)
853 unsigned short r_type
= howto
->type
;
854 bfd_byte
*hit_data
= contents
+ offset
;
855 bfd_vma reloc_bits
, check
, Rvalue1
;
869 case R_CR16_REGREL4a
:
870 case R_CR16_REGREL14
:
871 case R_CR16_REGREL14a
:
872 case R_CR16_REGREL16
:
873 case R_CR16_REGREL20
:
874 case R_CR16_REGREL20a
:
875 case R_CR16_GOT_REGREL20
:
876 case R_CR16_GOTC_REGREL20
:
880 /* 'hit_data' is relative to the start of the instruction, not the
881 relocation offset. Advance it to account for the exact offset. */
901 case R_CR16_SWITCH16
:
902 case R_CR16_SWITCH32
:
903 /* We only care about the addend, where the difference between
904 expressions is kept. */
911 if (howto
->pc_relative
)
913 /* Subtract the address of the section containing the location. */
914 Rvalue
-= (input_section
->output_section
->vma
915 + input_section
->output_offset
);
916 /* Subtract the position of the location within the section. */
920 /* Add in supplied addend. */
923 /* Complain if the bitfield overflows, whether it is considered
924 as signed or unsigned. */
925 check
= Rvalue
>> howto
->rightshift
;
927 /* Assumes two's complement. This expression avoids
928 overflow if howto->bitsize is the number of bits in
930 reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
932 /* For GOT and GOTC relocs no boundary checks applied. */
933 if (!((r_type
== R_CR16_GOT_REGREL20
)
934 || (r_type
== R_CR16_GOTC_REGREL20
)))
936 if (((bfd_vma
) check
& ~reloc_bits
) != 0
937 && (((bfd_vma
) check
& ~reloc_bits
)
938 != (-(bfd_vma
) 1 & ~reloc_bits
)))
940 /* The above right shift is incorrect for a signed
941 value. See if turning on the upper bits fixes the
943 if (howto
->rightshift
&& (bfd_signed_vma
) Rvalue
< 0)
945 check
|= ((bfd_vma
) - 1
947 >> howto
->rightshift
));
949 if (((bfd_vma
) check
& ~reloc_bits
)
950 != (-(bfd_vma
) 1 & ~reloc_bits
))
951 return bfd_reloc_overflow
;
954 return bfd_reloc_overflow
;
957 /* Drop unwanted bits from the value we are relocating to. */
958 Rvalue
>>= (bfd_vma
) howto
->rightshift
;
960 /* Apply dst_mask to select only relocatable part of the insn. */
961 Rvalue
&= howto
->dst_mask
;
967 if (r_type
== R_CR16_DISP8
)
969 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
970 Rvalue
= ((Rvalue1
& 0xf000) | ((Rvalue
<< 4) & 0xf00)
971 | (Rvalue1
& 0x00f0) | (Rvalue
& 0xf));
972 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
974 else if (r_type
== R_CR16_IMM4
)
976 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
977 Rvalue
= (((Rvalue1
& 0xff) << 8) | ((Rvalue
<< 4) & 0xf0)
978 | ((Rvalue1
& 0x0f00) >> 8));
979 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
981 else if (r_type
== R_CR16_DISP4
)
983 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
984 Rvalue
= (Rvalue1
| ((Rvalue
& 0xf) << 4));
985 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
989 bfd_put_8 (input_bfd
, (unsigned char) Rvalue
, hit_data
);
994 if (r_type
== R_CR16_DISP16
)
996 Rvalue
|= (bfd_get_16 (input_bfd
, hit_data
));
997 Rvalue
= ((Rvalue
& 0xfffe) | ((Rvalue
>> 16) & 0x1));
999 if (r_type
== R_CR16_IMM16
)
1001 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
1003 /* Add or subtract the offset value. */
1004 if (Rvalue1
& 0x8000)
1005 Rvalue
-= (~Rvalue1
+ 1) & 0xffff;
1009 /* Check for range. */
1010 if ((long) Rvalue
> 0xffff || (long) Rvalue
< 0x0)
1011 return bfd_reloc_overflow
;
1014 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1018 if ((r_type
== R_CR16_ABS20
) || (r_type
== R_CR16_IMM20
))
1020 Rvalue1
= (bfd_get_16 (input_bfd
, hit_data
+ 2)
1021 | (((bfd_get_16 (input_bfd
, hit_data
) & 0xf) <<16)));
1023 /* Add or subtract the offset value. */
1024 if (Rvalue1
& 0x80000)
1025 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1029 /* Check for range. */
1030 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1031 return bfd_reloc_overflow
;
1033 bfd_put_16 (input_bfd
, ((bfd_get_16 (input_bfd
, hit_data
) & 0xfff0)
1034 | ((Rvalue
>> 16) & 0xf)), hit_data
);
1035 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1037 else if (r_type
== R_CR16_GOT_REGREL20
)
1039 asection
*sgot
= elf_hash_table (info
)->sgot
;
1045 off
= h
->got
.offset
;
1046 BFD_ASSERT (off
!= (bfd_vma
) -1);
1048 if (! elf_hash_table (info
)->dynamic_sections_created
1049 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1050 /* This is actually a static link, or it is a
1051 -Bsymbolic link and the symbol is defined
1052 locally, or the symbol was forced to be local
1053 because of a version file. We must initialize
1054 this entry in the global offset table.
1055 When doing a dynamic link, we create a .rela.got
1056 relocation entry to initialize the value. This
1057 is done in the finish_dynamic_symbol routine. */
1058 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1060 Rvalue
= sgot
->output_offset
+ off
;
1066 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1067 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1069 Rvalue
= sgot
->output_offset
+ off
;
1074 /* REVISIT: if ((long) Rvalue > 0xffffff ||
1075 (long) Rvalue < -0x800000). */
1076 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1077 return bfd_reloc_overflow
;
1080 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1081 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1082 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1085 else if (r_type
== R_CR16_GOTC_REGREL20
)
1087 asection
*sgot
= elf_hash_table (info
)->sgot
;
1093 off
= h
->got
.offset
;
1094 BFD_ASSERT (off
!= (bfd_vma
) -1);
1096 Rvalue
>>=1; /* For code symbols. */
1098 if (! elf_hash_table (info
)->dynamic_sections_created
1099 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1100 /* This is actually a static link, or it is a
1101 -Bsymbolic link and the symbol is defined
1102 locally, or the symbol was forced to be local
1103 because of a version file. We must initialize
1104 this entry in the global offset table.
1105 When doing a dynamic link, we create a .rela.got
1106 relocation entry to initialize the value. This
1107 is done in the finish_dynamic_symbol routine. */
1108 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1110 Rvalue
= sgot
->output_offset
+ off
;
1116 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1118 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1119 Rvalue
= sgot
->output_offset
+ off
;
1124 /* Check if any value in DISP. */
1125 Rvalue1
=((bfd_get_32 (input_bfd
, hit_data
) >>16)
1126 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1128 /* Add or subtract the offset value. */
1129 if (Rvalue1
& 0x80000)
1130 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1134 /* Check for range. */
1135 /* REVISIT: if ((long) Rvalue > 0xffffff
1136 || (long) Rvalue < -0x800000). */
1137 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1138 return bfd_reloc_overflow
;
1140 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1141 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1142 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1146 if (r_type
== R_CR16_ABS24
)
1148 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1149 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16)
1150 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xf) <<20)));
1152 /* Add or subtract the offset value. */
1153 if (Rvalue1
& 0x800000)
1154 Rvalue
-= (~Rvalue1
+ 1) & 0xffffff;
1158 /* Check for Range. */
1159 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0x0)
1160 return bfd_reloc_overflow
;
1162 Rvalue
= ((((Rvalue
>> 20) & 0xf) | (((Rvalue
>> 16) & 0xf)<<8)
1163 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0f0))
1164 | ((Rvalue
& 0xffff) << 16));
1166 else if (r_type
== R_CR16_DISP24
)
1168 Rvalue
= ((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1169 | (bfd_get_16 (input_bfd
, hit_data
)))
1170 | (((Rvalue
& 0xfffe) | ((Rvalue
>> 24) & 0x1)) << 16));
1172 else if ((r_type
== R_CR16_IMM32
) || (r_type
== R_CR16_IMM32a
))
1174 Rvalue1
=((((bfd_get_32 (input_bfd
, hit_data
)) >> 16) &0xffff)
1175 | (((bfd_get_32 (input_bfd
, hit_data
)) &0xffff)) << 16);
1177 /* Add or subtract the offset value. */
1178 if (Rvalue1
& 0x80000000)
1179 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1183 /* Check for range. */
1184 if (Rvalue
> 0xffffffff || (long) Rvalue
< 0x0)
1185 return bfd_reloc_overflow
;
1187 Rvalue
= (((Rvalue
>> 16)& 0xffff) | (Rvalue
& 0xffff) << 16);
1189 else if (r_type
== R_CR16_DISP24a
)
1191 Rvalue
= (((Rvalue
& 0xfffffe) | (Rvalue
>> 23)));
1192 Rvalue
= ((Rvalue
>> 16) & 0xff) | ((Rvalue
& 0xffff) << 16)
1193 | (bfd_get_32 (input_bfd
, hit_data
));
1195 else if ((r_type
== R_CR16_REGREL20
)
1196 || (r_type
== R_CR16_REGREL20a
))
1198 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1199 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1200 /* Add or subtract the offset value. */
1201 if (Rvalue1
& 0x80000)
1202 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1206 /* Check for range. */
1207 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1208 return bfd_reloc_overflow
;
1210 Rvalue
= (((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1211 | ((Rvalue
& 0xffff) << 16)))
1212 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0ff));
1215 else if (r_type
== R_CR16_NUM32
)
1217 Rvalue1
= (bfd_get_32 (input_bfd
, hit_data
));
1219 /* Add or subtract the offset value */
1220 if (Rvalue1
& 0x80000000)
1221 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1225 /* Check for Ranga */
1226 if (Rvalue
> 0xffffffff)
1227 return bfd_reloc_overflow
;
1230 bfd_put_32 (input_bfd
, Rvalue
, hit_data
);
1235 return bfd_reloc_notsupported
;
1238 return bfd_reloc_ok
;
1241 /* Delete some bytes from a section while relaxing. */
1244 elf32_cr16_relax_delete_bytes (struct bfd_link_info
*link_info
, bfd
*abfd
,
1245 asection
*sec
, bfd_vma addr
, int count
)
1247 Elf_Internal_Shdr
*symtab_hdr
;
1248 unsigned int sec_shndx
;
1250 Elf_Internal_Rela
*irel
, *irelend
;
1252 Elf_Internal_Sym
*isym
;
1253 Elf_Internal_Sym
*isymend
;
1254 struct elf_link_hash_entry
**sym_hashes
;
1255 struct elf_link_hash_entry
**end_hashes
;
1256 struct elf_link_hash_entry
**start_hashes
;
1257 unsigned int symcount
;
1259 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1261 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1265 irel
= elf_section_data (sec
)->relocs
;
1266 irelend
= irel
+ sec
->reloc_count
;
1268 /* Actually delete the bytes. */
1269 memmove (contents
+ addr
, contents
+ addr
+ count
,
1270 (size_t) (toaddr
- addr
- count
));
1273 /* Adjust all the relocs. */
1274 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1275 /* Get the new reloc address. */
1276 if ((irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
))
1277 irel
->r_offset
-= count
;
1279 /* Adjust the local symbols defined in this section. */
1280 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1281 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1282 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1284 if (isym
->st_shndx
== sec_shndx
1285 && isym
->st_value
> addr
1286 && isym
->st_value
< toaddr
)
1288 /* Adjust the addend of SWITCH relocations in this section,
1289 which reference this local symbol. */
1291 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1293 unsigned long r_symndx
;
1294 Elf_Internal_Sym
*rsym
;
1295 bfd_vma addsym
, subsym
;
1297 /* Skip if not a SWITCH relocation. */
1298 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH8
1299 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH16
1300 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH32
)
1303 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1304 rsym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ r_symndx
;
1306 /* Skip if not the local adjusted symbol. */
1310 addsym
= isym
->st_value
;
1311 subsym
= addsym
- irel
->r_addend
;
1313 /* Fix the addend only when -->> (addsym > addr >= subsym). */
1315 irel
->r_addend
-= count
;
1321 isym
->st_value
-= count
;
1325 /* Now adjust the global symbols defined in this section. */
1326 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1327 - symtab_hdr
->sh_info
);
1328 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
1329 end_hashes
= sym_hashes
+ symcount
;
1331 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1333 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1335 /* The '--wrap SYMBOL' option is causing a pain when the object file,
1336 containing the definition of __wrap_SYMBOL, includes a direct
1337 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1338 the same symbol (which is __wrap_SYMBOL), but still exist as two
1339 different symbols in 'sym_hashes', we don't want to adjust
1340 the global symbol __wrap_SYMBOL twice.
1341 This check is only relevant when symbols are being wrapped. */
1342 if (link_info
->wrap_hash
!= NULL
)
1344 struct elf_link_hash_entry
**cur_sym_hashes
;
1346 /* Loop only over the symbols whom been already checked. */
1347 for (cur_sym_hashes
= start_hashes
; cur_sym_hashes
< sym_hashes
;
1349 /* If the current symbol is identical to 'sym_hash', that means
1350 the symbol was already adjusted (or at least checked). */
1351 if (*cur_sym_hashes
== sym_hash
)
1354 /* Don't adjust the symbol again. */
1355 if (cur_sym_hashes
< sym_hashes
)
1359 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1360 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1361 && sym_hash
->root
.u
.def
.section
== sec
1362 && sym_hash
->root
.u
.def
.value
> addr
1363 && sym_hash
->root
.u
.def
.value
< toaddr
)
1364 sym_hash
->root
.u
.def
.value
-= count
;
1370 /* Relocate a CR16 ELF section. */
1373 elf32_cr16_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1374 bfd
*input_bfd
, asection
*input_section
,
1375 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1376 Elf_Internal_Sym
*local_syms
,
1377 asection
**local_sections
)
1379 Elf_Internal_Shdr
*symtab_hdr
;
1380 struct elf_link_hash_entry
**sym_hashes
;
1381 Elf_Internal_Rela
*rel
, *relend
;
1383 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1384 sym_hashes
= elf_sym_hashes (input_bfd
);
1387 relend
= relocs
+ input_section
->reloc_count
;
1388 for (; rel
< relend
; rel
++)
1391 reloc_howto_type
*howto
;
1392 unsigned long r_symndx
;
1393 Elf_Internal_Sym
*sym
;
1395 struct elf_link_hash_entry
*h
;
1397 bfd_reloc_status_type r
;
1399 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1400 r_type
= ELF32_R_TYPE (rel
->r_info
);
1401 howto
= cr16_elf_howto_table
+ (r_type
);
1406 if (r_symndx
< symtab_hdr
->sh_info
)
1408 sym
= local_syms
+ r_symndx
;
1409 sec
= local_sections
[r_symndx
];
1410 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1414 bfd_boolean unresolved_reloc
, warned
, ignored
;
1416 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1417 r_symndx
, symtab_hdr
, sym_hashes
,
1419 unresolved_reloc
, warned
, ignored
);
1422 if (sec
!= NULL
&& discarded_section (sec
))
1423 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1424 rel
, 1, relend
, howto
, 0, contents
);
1426 if (bfd_link_relocatable (info
))
1429 r
= cr16_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
1431 contents
, rel
->r_offset
,
1432 relocation
, rel
->r_addend
,
1433 (struct elf_link_hash_entry
*) h
,
1435 info
, sec
, h
== NULL
);
1437 if (r
!= bfd_reloc_ok
)
1440 const char *msg
= NULL
;
1443 name
= h
->root
.root
.string
;
1446 name
= (bfd_elf_string_from_elf_section
1447 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1448 if (name
== NULL
|| *name
== '\0')
1449 name
= bfd_section_name (input_bfd
, sec
);
1454 case bfd_reloc_overflow
:
1455 (*info
->callbacks
->reloc_overflow
)
1456 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1457 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1460 case bfd_reloc_undefined
:
1461 (*info
->callbacks
->undefined_symbol
)
1462 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1465 case bfd_reloc_outofrange
:
1466 msg
= _("internal error: out of range error");
1469 case bfd_reloc_notsupported
:
1470 msg
= _("internal error: unsupported relocation error");
1473 case bfd_reloc_dangerous
:
1474 msg
= _("internal error: dangerous error");
1478 msg
= _("internal error: unknown error");
1482 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
1483 input_section
, rel
->r_offset
);
1492 /* This is a version of bfd_generic_get_relocated_section_contents
1493 which uses elf32_cr16_relocate_section. */
1496 elf32_cr16_get_relocated_section_contents (bfd
*output_bfd
,
1497 struct bfd_link_info
*link_info
,
1498 struct bfd_link_order
*link_order
,
1500 bfd_boolean relocatable
,
1503 Elf_Internal_Shdr
*symtab_hdr
;
1504 asection
*input_section
= link_order
->u
.indirect
.section
;
1505 bfd
*input_bfd
= input_section
->owner
;
1506 asection
**sections
= NULL
;
1507 Elf_Internal_Rela
*internal_relocs
= NULL
;
1508 Elf_Internal_Sym
*isymbuf
= NULL
;
1510 /* We only need to handle the case of relaxing, or of having a
1511 particular set of section contents, specially. */
1513 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1514 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1519 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1521 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1522 (size_t) input_section
->size
);
1524 if ((input_section
->flags
& SEC_RELOC
) != 0
1525 && input_section
->reloc_count
> 0)
1527 Elf_Internal_Sym
*isym
;
1528 Elf_Internal_Sym
*isymend
;
1532 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, input_section
,
1534 if (internal_relocs
== NULL
)
1537 if (symtab_hdr
->sh_info
!= 0)
1539 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1540 if (isymbuf
== NULL
)
1541 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1542 symtab_hdr
->sh_info
, 0,
1544 if (isymbuf
== NULL
)
1548 amt
= symtab_hdr
->sh_info
;
1549 amt
*= sizeof (asection
*);
1550 sections
= bfd_malloc (amt
);
1551 if (sections
== NULL
&& amt
!= 0)
1554 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1555 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1559 if (isym
->st_shndx
== SHN_UNDEF
)
1560 isec
= bfd_und_section_ptr
;
1561 else if (isym
->st_shndx
== SHN_ABS
)
1562 isec
= bfd_abs_section_ptr
;
1563 else if (isym
->st_shndx
== SHN_COMMON
)
1564 isec
= bfd_com_section_ptr
;
1566 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1571 if (! elf32_cr16_relocate_section (output_bfd
, link_info
, input_bfd
,
1572 input_section
, data
, internal_relocs
,
1576 if (sections
!= NULL
)
1579 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1581 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1582 free (internal_relocs
);
1588 if (sections
!= NULL
)
1591 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1593 if (internal_relocs
!= NULL
1594 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
1595 free (internal_relocs
);
1599 /* Assorted hash table functions. */
1601 /* Initialize an entry in the link hash table. */
1603 /* Create an entry in an CR16 ELF linker hash table. */
1605 static struct bfd_hash_entry
*
1606 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1607 struct bfd_hash_table
*table
,
1610 struct elf32_cr16_link_hash_entry
*ret
=
1611 (struct elf32_cr16_link_hash_entry
*) entry
;
1613 /* Allocate the structure if it has not already been allocated by a
1615 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1616 ret
= ((struct elf32_cr16_link_hash_entry
*)
1617 bfd_hash_allocate (table
,
1618 sizeof (struct elf32_cr16_link_hash_entry
)));
1619 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1620 return (struct bfd_hash_entry
*) ret
;
1622 /* Call the allocation method of the superclass. */
1623 ret
= ((struct elf32_cr16_link_hash_entry
*)
1624 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1626 if (ret
!= (struct elf32_cr16_link_hash_entry
*) NULL
)
1628 ret
->direct_calls
= 0;
1629 ret
->stack_size
= 0;
1631 ret
->movm_stack_size
= 0;
1636 return (struct bfd_hash_entry
*) ret
;
1639 /* Create an cr16 ELF linker hash table. */
1641 static struct bfd_link_hash_table
*
1642 elf32_cr16_link_hash_table_create (bfd
*abfd
)
1644 struct elf_link_hash_table
*ret
;
1645 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1647 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
1648 if (ret
== (struct elf_link_hash_table
*) NULL
)
1651 if (!_bfd_elf_link_hash_table_init (ret
, abfd
,
1652 elf32_cr16_link_hash_newfunc
,
1653 sizeof (struct elf32_cr16_link_hash_entry
),
1663 static unsigned long
1664 elf_cr16_mach (flagword flags
)
1670 return bfd_mach_cr16
;
1674 /* The final processing done just before writing out a CR16 ELF object
1675 file. This gets the CR16 architecture right based on the machine
1679 _bfd_cr16_elf_final_write_processing (bfd
*abfd
,
1680 bfd_boolean linker ATTRIBUTE_UNUSED
)
1683 switch (bfd_get_mach (abfd
))
1692 elf_elfheader (abfd
)->e_flags
|= val
;
1697 _bfd_cr16_elf_object_p (bfd
*abfd
)
1699 bfd_default_set_arch_mach (abfd
, bfd_arch_cr16
,
1700 elf_cr16_mach (elf_elfheader (abfd
)->e_flags
));
1704 /* Merge backend specific data from an object file to the output
1705 object file when linking. */
1708 _bfd_cr16_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
1710 bfd
*obfd
= info
->output_bfd
;
1712 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1713 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1716 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1717 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
1719 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1720 bfd_get_mach (ibfd
)))
1728 /* This function handles relaxing for the CR16.
1730 There's quite a few relaxing opportunites available on the CR16:
1732 * bcond:24 -> bcond:16 1 byte
1733 * bcond:16 -> bcond:8 1 byte
1734 * arithmetic imm32 -> arithmetic imm20 12 bits
1735 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits
1737 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
1740 elf32_cr16_relax_section (bfd
*abfd
, asection
*sec
,
1741 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
1743 Elf_Internal_Shdr
*symtab_hdr
;
1744 Elf_Internal_Rela
*internal_relocs
;
1745 Elf_Internal_Rela
*irel
, *irelend
;
1746 bfd_byte
*contents
= NULL
;
1747 Elf_Internal_Sym
*isymbuf
= NULL
;
1749 /* Assume nothing changes. */
1752 /* We don't have to do anything for a relocatable link, if
1753 this section does not have relocs, or if this is not a
1755 if (bfd_link_relocatable (link_info
)
1756 || (sec
->flags
& SEC_RELOC
) == 0
1757 || sec
->reloc_count
== 0
1758 || (sec
->flags
& SEC_CODE
) == 0)
1761 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1763 /* Get a copy of the native relocations. */
1764 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
1765 link_info
->keep_memory
);
1766 if (internal_relocs
== NULL
)
1769 /* Walk through them looking for relaxing opportunities. */
1770 irelend
= internal_relocs
+ sec
->reloc_count
;
1771 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1775 /* If this isn't something that can be relaxed, then ignore
1777 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP16
1778 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP24
1779 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM32
1780 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM20
1781 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM16
)
1784 /* Get the section contents if we haven't done so already. */
1785 if (contents
== NULL
)
1787 /* Get cached copy if it exists. */
1788 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1789 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1790 /* Go get them off disk. */
1791 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1795 /* Read this BFD's local symbols if we haven't done so already. */
1796 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1798 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1799 if (isymbuf
== NULL
)
1800 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1801 symtab_hdr
->sh_info
, 0,
1803 if (isymbuf
== NULL
)
1807 /* Get the value of the symbol referred to by the reloc. */
1808 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1810 /* A local symbol. */
1811 Elf_Internal_Sym
*isym
;
1814 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1815 if (isym
->st_shndx
== SHN_UNDEF
)
1816 sym_sec
= bfd_und_section_ptr
;
1817 else if (isym
->st_shndx
== SHN_ABS
)
1818 sym_sec
= bfd_abs_section_ptr
;
1819 else if (isym
->st_shndx
== SHN_COMMON
)
1820 sym_sec
= bfd_com_section_ptr
;
1822 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1823 symval
= (isym
->st_value
1824 + sym_sec
->output_section
->vma
1825 + sym_sec
->output_offset
);
1830 struct elf_link_hash_entry
*h
;
1832 /* An external symbol. */
1833 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1834 h
= elf_sym_hashes (abfd
)[indx
];
1835 BFD_ASSERT (h
!= NULL
);
1837 if (h
->root
.type
!= bfd_link_hash_defined
1838 && h
->root
.type
!= bfd_link_hash_defweak
)
1839 /* This appears to be a reference to an undefined
1840 symbol. Just ignore it--it will be caught by the
1841 regular reloc processing. */
1844 symval
= (h
->root
.u
.def
.value
1845 + h
->root
.u
.def
.section
->output_section
->vma
1846 + h
->root
.u
.def
.section
->output_offset
);
1849 /* For simplicity of coding, we are going to modify the section
1850 contents, the section relocs, and the BFD symbol table. We
1851 must tell the rest of the code not to free up this
1852 information. It would be possible to instead create a table
1853 of changes which have to be made, as is done in coff-mips.c;
1854 that would be more work, but would require less memory when
1855 the linker is run. */
1857 /* Try to turn a 24 branch/call into a 16bit relative
1859 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP24
)
1861 bfd_vma value
= symval
;
1863 /* Deal with pc-relative gunk. */
1864 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1865 value
-= irel
->r_offset
;
1866 value
+= irel
->r_addend
;
1868 /* See if the value will fit in 16 bits, note the high value is
1869 0xfffe + 2 as the target will be two bytes closer if we are
1871 if ((long) value
< 0x10000 && (long) value
> -0x10002)
1875 /* Get the opcode. */
1876 code
= (unsigned int) bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1878 /* Verify it's a 'bcond' and fix the opcode. */
1879 if ((code
& 0xffff) == 0x0010)
1880 bfd_put_16 (abfd
, 0x1800 | ((0xf & (code
>> 20)) << 4), contents
+ irel
->r_offset
);
1884 /* Note that we've changed the relocs, section contents, etc. */
1885 elf_section_data (sec
)->relocs
= internal_relocs
;
1886 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1887 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1889 /* Fix the relocation's type. */
1890 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1893 /* Delete two bytes of data. */
1894 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1895 irel
->r_offset
+ 2, 2))
1898 /* That will change things, so, we should relax again.
1899 Note that this is not required, and it may be slow. */
1904 /* Try to turn a 16bit pc-relative branch into an
1905 8bit pc-relative branch. */
1906 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP16
)
1908 bfd_vma value
= symval
;
1910 /* Deal with pc-relative gunk. */
1911 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1912 value
-= irel
->r_offset
;
1913 value
+= irel
->r_addend
;
1915 /* See if the value will fit in 8 bits, note the high value is
1916 0xfc + 2 as the target will be two bytes closer if we are
1918 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1919 if ((long) value
< 0xfa && (long) value
> -0x100)
1921 unsigned short code
;
1923 /* Get the opcode. */
1924 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1926 /* Verify it's a 'bcond' and fix the opcode. */
1927 if ((code
& 0xff0f) == 0x1800)
1928 bfd_put_16 (abfd
, (code
& 0xf0f0), contents
+ irel
->r_offset
);
1932 /* Note that we've changed the relocs, section contents, etc. */
1933 elf_section_data (sec
)->relocs
= internal_relocs
;
1934 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1935 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1937 /* Fix the relocation's type. */
1938 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1941 /* Delete two bytes of data. */
1942 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1943 irel
->r_offset
+ 2, 2))
1946 /* That will change things, so, we should relax again.
1947 Note that this is not required, and it may be slow. */
1952 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1953 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM32
)
1955 bfd_vma value
= symval
;
1956 unsigned short is_add_mov
= 0;
1959 /* Get the existing value from the mcode */
1960 value1
= ((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) >> 16)
1961 |(((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff) << 16)));
1963 /* See if the value will fit in 20 bits. */
1964 if ((long) (value
+ value1
) < 0xfffff && (long) (value
+ value1
) > 0)
1966 unsigned short code
;
1968 /* Get the opcode. */
1969 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1971 /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1972 For ADDD and MOVD only, convert to IMM32 -> IMM20. */
1974 if (((code
& 0xfff0) == 0x0070) || ((code
& 0xfff0) == 0x0020))
1979 /* Note that we've changed the relocs, section contents,
1981 elf_section_data (sec
)->relocs
= internal_relocs
;
1982 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1983 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1985 /* Fix the opcode. */
1986 if ((code
& 0xfff0) == 0x0070) /* For movd. */
1987 bfd_put_8 (abfd
, 0x05, contents
+ irel
->r_offset
+ 1);
1988 else /* code == 0x0020 for addd. */
1989 bfd_put_8 (abfd
, 0x04, contents
+ irel
->r_offset
+ 1);
1991 bfd_put_8 (abfd
, (code
& 0xf) << 4, contents
+ irel
->r_offset
);
1993 /* If existing value is nagavive adjust approriately
1994 place the 16-20bits (ie 4 bit) in new opcode,
1995 as the 0xffffxxxx, the higher 2 byte values removed. */
1996 if (value1
& 0x80000000)
1997 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
1999 bfd_put_8 (abfd
, (((value1
>> 16)&0xf) | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2001 /* Fix the relocation's type. */
2002 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2005 /* Delete two bytes of data. */
2006 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2007 irel
->r_offset
+ 2, 2))
2010 /* That will change things, so, we should relax again.
2011 Note that this is not required, and it may be slow. */
2016 /* See if the value will fit in 16 bits. */
2018 && ((long)(value
+ value1
) < 0x7fff && (long)(value
+ value1
) > 0))
2020 unsigned short code
;
2022 /* Get the opcode. */
2023 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2025 /* Note that we've changed the relocs, section contents, etc. */
2026 elf_section_data (sec
)->relocs
= internal_relocs
;
2027 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2028 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2030 /* Fix the opcode. */
2031 if ((code
& 0xf0) == 0x70) /* For movd. */
2032 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
+ 1);
2033 else if ((code
& 0xf0) == 0x20) /* For addd. */
2034 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
+ 1);
2035 else if ((code
& 0xf0) == 0x90) /* For cmpd. */
2036 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
+ 1);
2040 bfd_put_8 (abfd
, 0xb0 | (code
& 0xf), contents
+ irel
->r_offset
);
2042 /* If existing value is nagavive adjust approriately
2043 place the 12-16bits (ie 4 bit) in new opcode,
2044 as the 0xfffffxxx, the higher 2 byte values removed. */
2045 if (value1
& 0x80000000)
2046 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2048 bfd_put_16 (abfd
, value1
, contents
+ irel
->r_offset
+ 2);
2051 /* Fix the relocation's type. */
2052 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2055 /* Delete two bytes of data. */
2056 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2057 irel
->r_offset
+ 2, 2))
2060 /* That will change things, so, we should relax again.
2061 Note that this is not required, and it may be slow. */
2067 /* Try to turn a 16bit immediate address into a 4bit
2068 immediate address. */
2069 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2070 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM16
))
2072 bfd_vma value
= symval
;
2075 /* Get the existing value from the mcode */
2076 value1
= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff));
2078 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2080 value1
|= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 1) & 0xf000) << 0x4);
2083 /* See if the value will fit in 4 bits. */
2084 if ((((long) (value
+ value1
)) < 0xf)
2085 && (((long) (value
+ value1
)) > 0))
2087 unsigned short code
;
2089 /* Get the opcode. */
2090 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2092 /* Note that we've changed the relocs, section contents, etc. */
2093 elf_section_data (sec
)->relocs
= internal_relocs
;
2094 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2095 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2097 /* Fix the opcode. */
2098 if (((code
& 0x0f00) == 0x0400) || ((code
& 0x0f00) == 0x0500))
2100 if ((code
& 0x0f00) == 0x0400) /* For movd imm20. */
2101 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2102 else /* For addd imm20. */
2103 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2104 bfd_put_8 (abfd
, (code
& 0xf0) >> 4, contents
+ irel
->r_offset
+ 1);
2108 if ((code
& 0xfff0) == 0x56b0) /* For cmpd imm16. */
2109 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
);
2110 else if ((code
& 0xfff0) == 0x54b0) /* For movd imm16. */
2111 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2112 else if ((code
& 0xfff0) == 0x58b0) /* For movb imm16. */
2113 bfd_put_8 (abfd
, 0x58, contents
+ irel
->r_offset
);
2114 else if ((code
& 0xfff0) == 0x5Ab0) /* For movw imm16. */
2115 bfd_put_8 (abfd
, 0x5A, contents
+ irel
->r_offset
);
2116 else if ((code
& 0xfff0) == 0x60b0) /* For addd imm16. */
2117 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2118 else if ((code
& 0xfff0) == 0x30b0) /* For addb imm16. */
2119 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
);
2120 else if ((code
& 0xfff0) == 0x2Cb0) /* For addub imm16. */
2121 bfd_put_8 (abfd
, 0x2C, contents
+ irel
->r_offset
);
2122 else if ((code
& 0xfff0) == 0x32b0) /* For adduw imm16. */
2123 bfd_put_8 (abfd
, 0x32, contents
+ irel
->r_offset
);
2124 else if ((code
& 0xfff0) == 0x38b0) /* For subb imm16. */
2125 bfd_put_8 (abfd
, 0x38, contents
+ irel
->r_offset
);
2126 else if ((code
& 0xfff0) == 0x3Cb0) /* For subcb imm16. */
2127 bfd_put_8 (abfd
, 0x3C, contents
+ irel
->r_offset
);
2128 else if ((code
& 0xfff0) == 0x3Fb0) /* For subcw imm16. */
2129 bfd_put_8 (abfd
, 0x3F, contents
+ irel
->r_offset
);
2130 else if ((code
& 0xfff0) == 0x3Ab0) /* For subw imm16. */
2131 bfd_put_8 (abfd
, 0x3A, contents
+ irel
->r_offset
);
2132 else if ((code
& 0xfff0) == 0x50b0) /* For cmpb imm16. */
2133 bfd_put_8 (abfd
, 0x50, contents
+ irel
->r_offset
);
2134 else if ((code
& 0xfff0) == 0x52b0) /* For cmpw imm16. */
2135 bfd_put_8 (abfd
, 0x52, contents
+ irel
->r_offset
);
2139 bfd_put_8 (abfd
, (code
& 0xf), contents
+ irel
->r_offset
+ 1);
2142 /* Fix the relocation's type. */
2143 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2146 /* Delete two bytes of data. */
2147 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2148 irel
->r_offset
+ 2, 2))
2151 /* That will change things, so, we should relax again.
2152 Note that this is not required, and it may be slow. */
2160 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2162 if (! link_info
->keep_memory
)
2165 /* Cache the symbols for elf_link_input_bfd. */
2166 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2169 if (contents
!= NULL
2170 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2172 if (! link_info
->keep_memory
)
2175 /* Cache the section contents for elf_link_input_bfd. */
2176 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2180 if (internal_relocs
!= NULL
2181 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2182 free (internal_relocs
);
2188 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2190 if (contents
!= NULL
2191 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2193 if (internal_relocs
!= NULL
2194 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2195 free (internal_relocs
);
2201 elf32_cr16_gc_mark_hook (asection
*sec
,
2202 struct bfd_link_info
*info
,
2203 Elf_Internal_Rela
*rel
,
2204 struct elf_link_hash_entry
*h
,
2205 Elf_Internal_Sym
*sym
)
2207 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2210 /* Create dynamic sections when linking against a dynamic object. */
2213 _bfd_cr16_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2217 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
2218 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2221 switch (bed
->s
->arch_size
)
2232 bfd_set_error (bfd_error_bad_value
);
2236 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2237 .rel[a].bss sections. */
2239 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2240 | SEC_LINKER_CREATED
);
2242 s
= bfd_make_section_anyway_with_flags (abfd
,
2243 (bed
->default_use_rela_p
2244 ? ".rela.plt" : ".rel.plt"),
2245 flags
| SEC_READONLY
);
2248 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2251 if (! _bfd_cr16_elf_create_got_section (abfd
, info
))
2254 if (bed
->want_dynbss
)
2256 /* The .dynbss section is a place to put symbols which are defined
2257 by dynamic objects, are referenced by regular objects, and are
2258 not functions. We must allocate space for them in the process
2259 image and use a R_*_COPY reloc to tell the dynamic linker to
2260 initialize them at run time. The linker script puts the .dynbss
2261 section into the .bss section of the final image. */
2262 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2263 SEC_ALLOC
| SEC_LINKER_CREATED
);
2267 /* The .rel[a].bss section holds copy relocs. This section is not
2268 normally needed. We need to create it here, though, so that the
2269 linker will map it to an output section. We can't just create it
2270 only if we need it, because we will not know whether we need it
2271 until we have seen all the input files, and the first time the
2272 main linker code calls BFD after examining all the input files
2273 (size_dynamic_sections) the input sections have already been
2274 mapped to the output sections. If the section turns out not to
2275 be needed, we can discard it later. We will never need this
2276 section when generating a shared object, since they do not use
2278 if (! bfd_link_executable (info
))
2280 s
= bfd_make_section_anyway_with_flags (abfd
,
2281 (bed
->default_use_rela_p
2282 ? ".rela.bss" : ".rel.bss"),
2283 flags
| SEC_READONLY
);
2285 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2293 /* Adjust a symbol defined by a dynamic object and referenced by a
2294 regular object. The current definition is in some section of the
2295 dynamic object, but we're not including those sections. We have to
2296 change the definition to something the rest of the link can
2300 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info
* info
,
2301 struct elf_link_hash_entry
* h
)
2306 dynobj
= elf_hash_table (info
)->dynobj
;
2308 /* Make sure we know what is going on here. */
2309 BFD_ASSERT (dynobj
!= NULL
2311 || h
->u
.weakdef
!= NULL
2314 && !h
->def_regular
)));
2316 /* If this is a function, put it in the procedure linkage table. We
2317 will fill in the contents of the procedure linkage table later,
2318 when we know the address of the .got section. */
2319 if (h
->type
== STT_FUNC
2322 if (! bfd_link_executable (info
)
2326 /* This case can occur if we saw a PLT reloc in an input
2327 file, but the symbol was never referred to by a dynamic
2328 object. In such a case, we don't actually need to build
2329 a procedure linkage table, and we can just do a REL32
2331 BFD_ASSERT (h
->needs_plt
);
2335 /* Make sure this symbol is output as a dynamic symbol. */
2336 if (h
->dynindx
== -1)
2338 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2342 /* We also need to make an entry in the .got.plt section, which
2343 will be placed in the .got section by the linker script. */
2345 s
= elf_hash_table (info
)->sgotplt
;
2346 BFD_ASSERT (s
!= NULL
);
2349 /* We also need to make an entry in the .rela.plt section. */
2351 s
= elf_hash_table (info
)->srelplt
;
2352 BFD_ASSERT (s
!= NULL
);
2353 s
->size
+= sizeof (Elf32_External_Rela
);
2358 /* If this is a weak symbol, and there is a real definition, the
2359 processor independent code will have arranged for us to see the
2360 real definition first, and we can just use the same value. */
2361 if (h
->u
.weakdef
!= NULL
)
2363 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2364 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2365 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2366 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2370 /* This is a reference to a symbol defined by a dynamic object which
2371 is not a function. */
2373 /* If we are creating a shared library, we must presume that the
2374 only references to the symbol are via the global offset table.
2375 For such cases we need not do anything here; the relocations will
2376 be handled correctly by relocate_section. */
2377 if (bfd_link_executable (info
))
2380 /* If there are no references to this symbol that do not use the
2381 GOT, we don't need to generate a copy reloc. */
2382 if (!h
->non_got_ref
)
2385 /* We must allocate the symbol in our .dynbss section, which will
2386 become part of the .bss section of the executable. There will be
2387 an entry for this symbol in the .dynsym section. The dynamic
2388 object will contain position independent code, so all references
2389 from the dynamic object to this symbol will go through the global
2390 offset table. The dynamic linker will use the .dynsym entry to
2391 determine the address it must put in the global offset table, so
2392 both the dynamic object and the regular object will refer to the
2393 same memory location for the variable. */
2395 s
= bfd_get_linker_section (dynobj
, ".dynbss");
2396 BFD_ASSERT (s
!= NULL
);
2398 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2399 copy the initial value out of the dynamic object and into the
2400 runtime process image. We need to remember the offset into the
2401 .rela.bss section we are going to use. */
2402 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2406 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
2407 BFD_ASSERT (srel
!= NULL
);
2408 srel
->size
+= sizeof (Elf32_External_Rela
);
2412 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2415 /* Set the sizes of the dynamic sections. */
2418 _bfd_cr16_elf_size_dynamic_sections (bfd
* output_bfd
,
2419 struct bfd_link_info
* info
)
2425 bfd_boolean reltext
;
2427 dynobj
= elf_hash_table (info
)->dynobj
;
2428 BFD_ASSERT (dynobj
!= NULL
);
2430 if (elf_hash_table (info
)->dynamic_sections_created
)
2432 /* Set the contents of the .interp section to the interpreter. */
2433 if (bfd_link_executable (info
) && !info
->nointerp
)
2436 s
= bfd_get_linker_section (dynobj
, ".interp");
2437 BFD_ASSERT (s
!= NULL
);
2438 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2439 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2445 /* We may have created entries in the .rela.got section.
2446 However, if we are not creating the dynamic sections, we will
2447 not actually use these entries. Reset the size of .rela.got,
2448 which will cause it to get stripped from the output file
2450 s
= elf_hash_table (info
)->srelgot
;
2455 /* The check_relocs and adjust_dynamic_symbol entry points have
2456 determined the sizes of the various dynamic sections. Allocate
2461 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2465 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2468 /* It's OK to base decisions on the section name, because none
2469 of the dynobj section names depend upon the input files. */
2470 name
= bfd_get_section_name (dynobj
, s
);
2472 if (strcmp (name
, ".plt") == 0)
2474 /* Remember whether there is a PLT. */
2477 else if (CONST_STRNEQ (name
, ".rela"))
2483 /* Remember whether there are any reloc sections other
2485 if (strcmp (name
, ".rela.plt") != 0)
2487 const char * outname
;
2491 /* If this relocation section applies to a read only
2492 section, then we probably need a DT_TEXTREL
2493 entry. The entries in the .rela.plt section
2494 really apply to the .got section, which we
2495 created ourselves and so know is not readonly. */
2496 outname
= bfd_get_section_name (output_bfd
,
2498 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
2500 && (target
->flags
& SEC_READONLY
) != 0
2501 && (target
->flags
& SEC_ALLOC
) != 0)
2505 /* We use the reloc_count field as a counter if we need
2506 to copy relocs into the output file. */
2510 else if (! CONST_STRNEQ (name
, ".got")
2511 && strcmp (name
, ".dynbss") != 0)
2512 /* It's not one of our sections, so don't allocate space. */
2517 /* If we don't need this section, strip it from the
2518 output file. This is mostly to handle .rela.bss and
2519 .rela.plt. We must create both sections in
2520 create_dynamic_sections, because they must be created
2521 before the linker maps input sections to output
2522 sections. The linker does that before
2523 adjust_dynamic_symbol is called, and it is that
2524 function which decides whether anything needs to go
2525 into these sections. */
2526 s
->flags
|= SEC_EXCLUDE
;
2530 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2533 /* Allocate memory for the section contents. We use bfd_zalloc
2534 here in case unused entries are not reclaimed before the
2535 section's contents are written out. This should not happen,
2536 but this way if it does, we get a R_CR16_NONE reloc
2537 instead of garbage. */
2538 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2539 if (s
->contents
== NULL
)
2543 if (elf_hash_table (info
)->dynamic_sections_created
)
2545 /* Add some entries to the .dynamic section. We fill in the
2546 values later, in _bfd_cr16_elf_finish_dynamic_sections,
2547 but we must add the entries now so that we get the correct
2548 size for the .dynamic section. The DT_DEBUG entry is filled
2549 in by the dynamic linker and used by the debugger. */
2550 if (! bfd_link_executable (info
))
2552 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2558 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2559 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2560 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2561 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2567 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2568 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2569 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2570 sizeof (Elf32_External_Rela
)))
2576 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2584 /* Finish up dynamic symbol handling. We set the contents of various
2585 dynamic sections here. */
2588 _bfd_cr16_elf_finish_dynamic_symbol (bfd
* output_bfd
,
2589 struct bfd_link_info
* info
,
2590 struct elf_link_hash_entry
* h
,
2591 Elf_Internal_Sym
* sym
)
2595 dynobj
= elf_hash_table (info
)->dynobj
;
2597 if (h
->got
.offset
!= (bfd_vma
) -1)
2601 Elf_Internal_Rela rel
;
2603 /* This symbol has an entry in the global offset table. Set it up. */
2605 sgot
= elf_hash_table (info
)->sgot
;
2606 srel
= elf_hash_table (info
)->srelgot
;
2607 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2609 rel
.r_offset
= (sgot
->output_section
->vma
2610 + sgot
->output_offset
2611 + (h
->got
.offset
& ~1));
2613 /* If this is a -Bsymbolic link, and the symbol is defined
2614 locally, we just want to emit a RELATIVE reloc. Likewise if
2615 the symbol was forced to be local because of a version file.
2616 The entry in the global offset table will already have been
2617 initialized in the relocate_section function. */
2618 if (bfd_link_executable (info
)
2619 && (info
->symbolic
|| h
->dynindx
== -1)
2622 rel
.r_info
= ELF32_R_INFO (0, R_CR16_GOT_REGREL20
);
2623 rel
.r_addend
= (h
->root
.u
.def
.value
2624 + h
->root
.u
.def
.section
->output_section
->vma
2625 + h
->root
.u
.def
.section
->output_offset
);
2629 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2630 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2634 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2635 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
2636 + srel
->reloc_count
));
2637 ++ srel
->reloc_count
;
2643 Elf_Internal_Rela rel
;
2645 /* This symbol needs a copy reloc. Set it up. */
2646 BFD_ASSERT (h
->dynindx
!= -1
2647 && (h
->root
.type
== bfd_link_hash_defined
2648 || h
->root
.type
== bfd_link_hash_defweak
));
2650 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
2651 BFD_ASSERT (s
!= NULL
);
2653 rel
.r_offset
= (h
->root
.u
.def
.value
2654 + h
->root
.u
.def
.section
->output_section
->vma
2655 + h
->root
.u
.def
.section
->output_offset
);
2656 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2658 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2659 (bfd_byte
*) ((Elf32_External_Rela
*) s
->contents
2664 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2665 if (h
== elf_hash_table (info
)->hdynamic
2666 || h
== elf_hash_table (info
)->hgot
)
2667 sym
->st_shndx
= SHN_ABS
;
2672 /* Finish up the dynamic sections. */
2675 _bfd_cr16_elf_finish_dynamic_sections (bfd
* output_bfd
,
2676 struct bfd_link_info
* info
)
2682 dynobj
= elf_hash_table (info
)->dynobj
;
2684 sgot
= elf_hash_table (info
)->sgotplt
;
2685 BFD_ASSERT (sgot
!= NULL
);
2686 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2688 if (elf_hash_table (info
)->dynamic_sections_created
)
2690 Elf32_External_Dyn
* dyncon
;
2691 Elf32_External_Dyn
* dynconend
;
2693 BFD_ASSERT (sdyn
!= NULL
);
2695 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2696 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2698 for (; dyncon
< dynconend
; dyncon
++)
2700 Elf_Internal_Dyn dyn
;
2703 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2711 s
= elf_hash_table (info
)->sgotplt
;
2715 s
= elf_hash_table (info
)->srelplt
;
2717 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2718 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2722 s
= elf_hash_table (info
)->srelplt
;
2723 dyn
.d_un
.d_val
= s
->size
;
2724 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2731 /* Fill in the first three entries in the global offset table. */
2735 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2737 bfd_put_32 (output_bfd
,
2738 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2742 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2747 /* Given a .data.rel section and a .emreloc in-memory section, store
2748 relocation information into the .emreloc section which can be
2749 used at runtime to relocate the section. This is called by the
2750 linker when the --embedded-relocs switch is used. This is called
2751 after the add_symbols entry point has been called for all the
2752 objects, and before the final_link entry point is called. */
2755 bfd_cr16_elf32_create_embedded_relocs (bfd
*abfd
,
2756 struct bfd_link_info
*info
,
2761 Elf_Internal_Shdr
*symtab_hdr
;
2762 Elf_Internal_Sym
*isymbuf
= NULL
;
2763 Elf_Internal_Rela
*internal_relocs
= NULL
;
2764 Elf_Internal_Rela
*irel
, *irelend
;
2768 BFD_ASSERT (! bfd_link_relocatable (info
));
2772 if (datasec
->reloc_count
== 0)
2775 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2777 /* Get a copy of the native relocations. */
2778 internal_relocs
= (_bfd_elf_link_read_relocs
2779 (abfd
, datasec
, NULL
, NULL
, info
->keep_memory
));
2780 if (internal_relocs
== NULL
)
2783 amt
= (bfd_size_type
) datasec
->reloc_count
* 8;
2784 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2785 if (relsec
->contents
== NULL
)
2788 p
= relsec
->contents
;
2790 irelend
= internal_relocs
+ datasec
->reloc_count
;
2791 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 8)
2793 asection
*targetsec
;
2795 /* We are going to write a four byte longword into the runtime
2796 reloc section. The longword will be the address in the data
2797 section which must be relocated. It is followed by the name
2798 of the target section NUL-padded or truncated to 8
2801 /* We can only relocate absolute longword relocs at run time. */
2802 if (!((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2803 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32
)))
2805 *errmsg
= _("unsupported reloc type");
2806 bfd_set_error (bfd_error_bad_value
);
2810 /* Get the target section referred to by the reloc. */
2811 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2813 /* A local symbol. */
2814 Elf_Internal_Sym
*isym
;
2816 /* Read this BFD's local symbols if we haven't done so already. */
2817 if (isymbuf
== NULL
)
2819 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2820 if (isymbuf
== NULL
)
2821 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2822 symtab_hdr
->sh_info
, 0,
2824 if (isymbuf
== NULL
)
2828 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2829 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2834 struct elf_link_hash_entry
*h
;
2836 /* An external symbol. */
2837 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2838 h
= elf_sym_hashes (abfd
)[indx
];
2839 BFD_ASSERT (h
!= NULL
);
2840 if (h
->root
.type
== bfd_link_hash_defined
2841 || h
->root
.type
== bfd_link_hash_defweak
)
2842 targetsec
= h
->root
.u
.def
.section
;
2847 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2848 memset (p
+ 4, 0, 4);
2849 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2850 && (targetsec
!= NULL
) )
2851 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 4);
2854 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2856 if (internal_relocs
!= NULL
2857 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2858 free (internal_relocs
);
2862 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2864 if (internal_relocs
!= NULL
2865 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2866 free (internal_relocs
);
2871 /* Classify relocation types, such that combreloc can sort them
2874 static enum elf_reloc_type_class
2875 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2876 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2877 const Elf_Internal_Rela
*rela
)
2879 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2881 case R_CR16_GOT_REGREL20
:
2882 case R_CR16_GOTC_REGREL20
:
2883 return reloc_class_relative
;
2885 return reloc_class_normal
;
2889 /* Definitions for setting CR16 target vector. */
2890 #define TARGET_LITTLE_SYM cr16_elf32_vec
2891 #define TARGET_LITTLE_NAME "elf32-cr16"
2892 #define ELF_ARCH bfd_arch_cr16
2893 #define ELF_MACHINE_CODE EM_CR16
2894 #define ELF_MACHINE_ALT1 EM_CR16_OLD
2895 #define ELF_MAXPAGESIZE 0x1
2896 #define elf_symbol_leading_char '_'
2898 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup
2899 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup
2900 #define elf_info_to_howto elf_cr16_info_to_howto
2901 #define elf_info_to_howto_rel 0
2902 #define elf_backend_relocate_section elf32_cr16_relocate_section
2903 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section
2904 #define bfd_elf32_bfd_get_relocated_section_contents \
2905 elf32_cr16_get_relocated_section_contents
2906 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook
2907 #define elf_backend_can_gc_sections 1
2908 #define elf_backend_rela_normal 1
2909 #define elf_backend_check_relocs cr16_elf_check_relocs
2910 /* So we can set bits in e_flags. */
2911 #define elf_backend_final_write_processing \
2912 _bfd_cr16_elf_final_write_processing
2913 #define elf_backend_object_p _bfd_cr16_elf_object_p
2915 #define bfd_elf32_bfd_merge_private_bfd_data \
2916 _bfd_cr16_elf_merge_private_bfd_data
2919 #define bfd_elf32_bfd_link_hash_table_create \
2920 elf32_cr16_link_hash_table_create
2922 #define elf_backend_create_dynamic_sections \
2923 _bfd_cr16_elf_create_dynamic_sections
2924 #define elf_backend_adjust_dynamic_symbol \
2925 _bfd_cr16_elf_adjust_dynamic_symbol
2926 #define elf_backend_size_dynamic_sections \
2927 _bfd_cr16_elf_size_dynamic_sections
2928 #define elf_backend_omit_section_dynsym \
2929 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2930 #define elf_backend_finish_dynamic_symbol \
2931 _bfd_cr16_elf_finish_dynamic_symbol
2932 #define elf_backend_finish_dynamic_sections \
2933 _bfd_cr16_elf_finish_dynamic_sections
2935 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class
2938 #define elf_backend_want_got_plt 1
2939 #define elf_backend_plt_readonly 1
2940 #define elf_backend_want_plt_sym 0
2941 #define elf_backend_got_header_size 12
2942 #define elf_backend_dtrel_excludes_plt 1
2944 #include "elf32-target.h"