1 /* BFD back-end for National Semiconductor's CR16 ELF
2 Copyright (C) 2007-2020 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"
28 #include "elf32-cr16.h"
30 /* The cr16 linker needs to keep track of the number of relocs that
31 it decides to copy in check_relocs for each symbol. This is so
32 that it can discard PC relative relocs if it doesn't need them when
33 linking with -Bsymbolic. We store the information in a field
34 extending the regular ELF linker hash table. */
36 struct elf32_cr16_link_hash_entry
38 /* The basic elf link hash table entry. */
39 struct elf_link_hash_entry root
;
41 /* For function symbols, the number of times this function is
42 called directly (ie by name). */
43 unsigned int direct_calls
;
45 /* For function symbols, the size of this function's stack
46 (if <= 255 bytes). We stuff this into "call" instructions
47 to this target when it's valid and profitable to do so.
49 This does not include stack allocated by movm! */
50 unsigned char stack_size
;
52 /* For function symbols, arguments (if any) for movm instruction
53 in the prologue. We stuff this value into "call" instructions
54 to the target when it's valid and profitable to do so. */
55 unsigned char movm_args
;
57 /* For function symbols, the amount of stack space that would be allocated
58 by the movm instruction. This is redundant with movm_args, but we
59 add it to the hash table to avoid computing it over and over. */
60 unsigned char movm_stack_size
;
62 /* Used to mark functions which have had redundant parts of their
64 #define CR16_DELETED_PROLOGUE_BYTES 0x1
67 /* Calculated value. */
71 /* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */
75 bfd_reloc_code_real_type bfd_reloc_enum
; /* BFD relocation enum. */
76 unsigned short cr16_reloc_type
; /* CR16 relocation type. */
79 static const struct cr16_reloc_map cr16_reloc_map
[R_CR16_MAX
] =
81 {BFD_RELOC_NONE
, R_CR16_NONE
},
82 {BFD_RELOC_CR16_NUM8
, R_CR16_NUM8
},
83 {BFD_RELOC_CR16_NUM16
, R_CR16_NUM16
},
84 {BFD_RELOC_CR16_NUM32
, R_CR16_NUM32
},
85 {BFD_RELOC_CR16_NUM32a
, R_CR16_NUM32a
},
86 {BFD_RELOC_CR16_REGREL4
, R_CR16_REGREL4
},
87 {BFD_RELOC_CR16_REGREL4a
, R_CR16_REGREL4a
},
88 {BFD_RELOC_CR16_REGREL14
, R_CR16_REGREL14
},
89 {BFD_RELOC_CR16_REGREL14a
, R_CR16_REGREL14a
},
90 {BFD_RELOC_CR16_REGREL16
, R_CR16_REGREL16
},
91 {BFD_RELOC_CR16_REGREL20
, R_CR16_REGREL20
},
92 {BFD_RELOC_CR16_REGREL20a
, R_CR16_REGREL20a
},
93 {BFD_RELOC_CR16_ABS20
, R_CR16_ABS20
},
94 {BFD_RELOC_CR16_ABS24
, R_CR16_ABS24
},
95 {BFD_RELOC_CR16_IMM4
, R_CR16_IMM4
},
96 {BFD_RELOC_CR16_IMM8
, R_CR16_IMM8
},
97 {BFD_RELOC_CR16_IMM16
, R_CR16_IMM16
},
98 {BFD_RELOC_CR16_IMM20
, R_CR16_IMM20
},
99 {BFD_RELOC_CR16_IMM24
, R_CR16_IMM24
},
100 {BFD_RELOC_CR16_IMM32
, R_CR16_IMM32
},
101 {BFD_RELOC_CR16_IMM32a
, R_CR16_IMM32a
},
102 {BFD_RELOC_CR16_DISP4
, R_CR16_DISP4
},
103 {BFD_RELOC_CR16_DISP8
, R_CR16_DISP8
},
104 {BFD_RELOC_CR16_DISP16
, R_CR16_DISP16
},
105 {BFD_RELOC_CR16_DISP24
, R_CR16_DISP24
},
106 {BFD_RELOC_CR16_DISP24a
, R_CR16_DISP24a
},
107 {BFD_RELOC_CR16_SWITCH8
, R_CR16_SWITCH8
},
108 {BFD_RELOC_CR16_SWITCH16
, R_CR16_SWITCH16
},
109 {BFD_RELOC_CR16_SWITCH32
, R_CR16_SWITCH32
},
110 {BFD_RELOC_CR16_GOT_REGREL20
, R_CR16_GOT_REGREL20
},
111 {BFD_RELOC_CR16_GOTC_REGREL20
, R_CR16_GOTC_REGREL20
},
112 {BFD_RELOC_CR16_GLOB_DAT
, R_CR16_GLOB_DAT
}
115 static reloc_howto_type cr16_elf_howto_table
[] =
117 HOWTO (R_CR16_NONE
, /* type */
121 FALSE
, /* pc_relative */
123 complain_overflow_dont
, /* complain_on_overflow */
124 bfd_elf_generic_reloc
, /* special_function */
125 "R_CR16_NONE", /* name */
126 FALSE
, /* partial_inplace */
129 FALSE
), /* pcrel_offset */
131 HOWTO (R_CR16_NUM8
, /* type */
135 FALSE
, /* pc_relative */
137 complain_overflow_bitfield
,/* complain_on_overflow */
138 bfd_elf_generic_reloc
, /* special_function */
139 "R_CR16_NUM8", /* name */
140 FALSE
, /* partial_inplace */
143 FALSE
), /* pcrel_offset */
145 HOWTO (R_CR16_NUM16
, /* type */
149 FALSE
, /* pc_relative */
151 complain_overflow_bitfield
,/* complain_on_overflow */
152 bfd_elf_generic_reloc
, /* special_function */
153 "R_CR16_NUM16", /* name */
154 FALSE
, /* partial_inplace */
156 0xffff, /* dst_mask */
157 FALSE
), /* pcrel_offset */
159 HOWTO (R_CR16_NUM32
, /* type */
163 FALSE
, /* pc_relative */
165 complain_overflow_bitfield
,/* complain_on_overflow */
166 bfd_elf_generic_reloc
, /* special_function */
167 "R_CR16_NUM32", /* name */
168 FALSE
, /* partial_inplace */
170 0xffffffff, /* dst_mask */
171 FALSE
), /* pcrel_offset */
173 HOWTO (R_CR16_NUM32a
, /* type */
177 FALSE
, /* pc_relative */
179 complain_overflow_bitfield
,/* complain_on_overflow */
180 bfd_elf_generic_reloc
, /* special_function */
181 "R_CR16_NUM32a", /* name */
182 FALSE
, /* partial_inplace */
184 0xffffffff, /* dst_mask */
185 FALSE
), /* pcrel_offset */
187 HOWTO (R_CR16_REGREL4
, /* type */
191 FALSE
, /* pc_relative */
193 complain_overflow_bitfield
,/* complain_on_overflow */
194 bfd_elf_generic_reloc
, /* special_function */
195 "R_CR16_REGREL4", /* name */
196 FALSE
, /* partial_inplace */
199 FALSE
), /* pcrel_offset */
201 HOWTO (R_CR16_REGREL4a
, /* type */
205 FALSE
, /* pc_relative */
207 complain_overflow_bitfield
,/* complain_on_overflow */
208 bfd_elf_generic_reloc
, /* special_function */
209 "R_CR16_REGREL4a", /* name */
210 FALSE
, /* partial_inplace */
213 FALSE
), /* pcrel_offset */
215 HOWTO (R_CR16_REGREL14
, /* type */
219 FALSE
, /* pc_relative */
221 complain_overflow_bitfield
,/* complain_on_overflow */
222 bfd_elf_generic_reloc
, /* special_function */
223 "R_CR16_REGREL14", /* name */
224 FALSE
, /* partial_inplace */
226 0x3fff, /* dst_mask */
227 FALSE
), /* pcrel_offset */
229 HOWTO (R_CR16_REGREL14a
, /* type */
233 FALSE
, /* pc_relative */
235 complain_overflow_bitfield
,/* complain_on_overflow */
236 bfd_elf_generic_reloc
, /* special_function */
237 "R_CR16_REGREL14a", /* name */
238 FALSE
, /* partial_inplace */
240 0x3fff, /* dst_mask */
241 FALSE
), /* pcrel_offset */
243 HOWTO (R_CR16_REGREL16
, /* type */
247 FALSE
, /* pc_relative */
249 complain_overflow_bitfield
,/* complain_on_overflow */
250 bfd_elf_generic_reloc
, /* special_function */
251 "R_CR16_REGREL16", /* name */
252 FALSE
, /* partial_inplace */
254 0xffff, /* dst_mask */
255 FALSE
), /* pcrel_offset */
257 HOWTO (R_CR16_REGREL20
, /* type */
261 FALSE
, /* pc_relative */
263 complain_overflow_bitfield
,/* complain_on_overflow */
264 bfd_elf_generic_reloc
, /* special_function */
265 "R_CR16_REGREL20", /* name */
266 FALSE
, /* partial_inplace */
268 0xfffff, /* dst_mask */
269 FALSE
), /* pcrel_offset */
271 HOWTO (R_CR16_REGREL20a
, /* type */
275 FALSE
, /* pc_relative */
277 complain_overflow_bitfield
,/* complain_on_overflow */
278 bfd_elf_generic_reloc
, /* special_function */
279 "R_CR16_REGREL20a", /* name */
280 FALSE
, /* partial_inplace */
282 0xfffff, /* dst_mask */
283 FALSE
), /* pcrel_offset */
285 HOWTO (R_CR16_ABS20
, /* type */
289 FALSE
, /* pc_relative */
291 complain_overflow_bitfield
,/* complain_on_overflow */
292 bfd_elf_generic_reloc
, /* special_function */
293 "R_CR16_ABS20", /* name */
294 FALSE
, /* partial_inplace */
296 0xfffff, /* dst_mask */
297 FALSE
), /* pcrel_offset */
299 HOWTO (R_CR16_ABS24
, /* type */
303 FALSE
, /* pc_relative */
305 complain_overflow_bitfield
,/* complain_on_overflow */
306 bfd_elf_generic_reloc
, /* special_function */
307 "R_CR16_ABS24", /* name */
308 FALSE
, /* partial_inplace */
310 0xffffff, /* dst_mask */
311 FALSE
), /* pcrel_offset */
313 HOWTO (R_CR16_IMM4
, /* type */
317 FALSE
, /* pc_relative */
319 complain_overflow_bitfield
,/* complain_on_overflow */
320 bfd_elf_generic_reloc
, /* special_function */
321 "R_CR16_IMM4", /* name */
322 FALSE
, /* partial_inplace */
325 FALSE
), /* pcrel_offset */
327 HOWTO (R_CR16_IMM8
, /* type */
331 FALSE
, /* pc_relative */
333 complain_overflow_bitfield
,/* complain_on_overflow */
334 bfd_elf_generic_reloc
, /* special_function */
335 "R_CR16_IMM8", /* name */
336 FALSE
, /* partial_inplace */
339 FALSE
), /* pcrel_offset */
341 HOWTO (R_CR16_IMM16
, /* type */
345 FALSE
, /* pc_relative */
347 complain_overflow_bitfield
,/* complain_on_overflow */
348 bfd_elf_generic_reloc
, /* special_function */
349 "R_CR16_IMM16", /* name */
350 FALSE
, /* partial_inplace */
352 0xffff, /* dst_mask */
353 FALSE
), /* pcrel_offset */
355 HOWTO (R_CR16_IMM20
, /* type */
359 FALSE
, /* pc_relative */
361 complain_overflow_bitfield
,/* complain_on_overflow */
362 bfd_elf_generic_reloc
, /* special_function */
363 "R_CR16_IMM20", /* name */
364 FALSE
, /* partial_inplace */
366 0xfffff, /* dst_mask */
367 FALSE
), /* pcrel_offset */
369 HOWTO (R_CR16_IMM24
, /* type */
373 FALSE
, /* pc_relative */
375 complain_overflow_bitfield
,/* complain_on_overflow */
376 bfd_elf_generic_reloc
, /* special_function */
377 "R_CR16_IMM24", /* name */
378 FALSE
, /* partial_inplace */
380 0xffffff, /* dst_mask */
381 FALSE
), /* pcrel_offset */
383 HOWTO (R_CR16_IMM32
, /* type */
387 FALSE
, /* pc_relative */
389 complain_overflow_bitfield
,/* complain_on_overflow */
390 bfd_elf_generic_reloc
, /* special_function */
391 "R_CR16_IMM32", /* name */
392 FALSE
, /* partial_inplace */
394 0xffffffff, /* dst_mask */
395 FALSE
), /* pcrel_offset */
397 HOWTO (R_CR16_IMM32a
, /* type */
401 FALSE
, /* pc_relative */
403 complain_overflow_bitfield
,/* complain_on_overflow */
404 bfd_elf_generic_reloc
, /* special_function */
405 "R_CR16_IMM32a", /* name */
406 FALSE
, /* partial_inplace */
408 0xffffffff, /* dst_mask */
409 FALSE
), /* pcrel_offset */
411 HOWTO (R_CR16_DISP4
, /* type */
413 0, /* size (0 = byte, 1 = short, 2 = long) */
415 TRUE
, /* pc_relative */
417 complain_overflow_unsigned
, /* complain_on_overflow */
418 bfd_elf_generic_reloc
, /* special_function */
419 "R_CR16_DISP4", /* name */
420 FALSE
, /* partial_inplace */
423 FALSE
), /* pcrel_offset */
425 HOWTO (R_CR16_DISP8
, /* type */
427 0, /* size (0 = byte, 1 = short, 2 = long) */
429 TRUE
, /* pc_relative */
431 complain_overflow_unsigned
, /* complain_on_overflow */
432 bfd_elf_generic_reloc
, /* special_function */
433 "R_CR16_DISP8", /* name */
434 FALSE
, /* partial_inplace */
436 0x1ff, /* dst_mask */
437 FALSE
), /* pcrel_offset */
439 HOWTO (R_CR16_DISP16
, /* type */
440 0, /* rightshift REVIITS: To sync with WinIDEA*/
441 1, /* size (0 = byte, 1 = short, 2 = long) */
443 TRUE
, /* pc_relative */
445 complain_overflow_unsigned
, /* complain_on_overflow */
446 bfd_elf_generic_reloc
, /* special_function */
447 "R_CR16_DISP16", /* name */
448 FALSE
, /* partial_inplace */
450 0x1ffff, /* dst_mask */
451 FALSE
), /* pcrel_offset */
452 /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc
453 but its not done, to sync with WinIDEA and CR16 4.1 tools */
454 HOWTO (R_CR16_DISP24
, /* type */
456 2, /* size (0 = byte, 1 = short, 2 = long) */
458 TRUE
, /* pc_relative */
460 complain_overflow_unsigned
, /* complain_on_overflow */
461 bfd_elf_generic_reloc
, /* special_function */
462 "R_CR16_DISP24", /* name */
463 FALSE
, /* partial_inplace */
465 0x1ffffff, /* dst_mask */
466 FALSE
), /* pcrel_offset */
468 HOWTO (R_CR16_DISP24a
, /* type */
470 2, /* size (0 = byte, 1 = short, 2 = long) */
472 TRUE
, /* pc_relative */
474 complain_overflow_unsigned
, /* complain_on_overflow */
475 bfd_elf_generic_reloc
, /* special_function */
476 "R_CR16_DISP24a", /* name */
477 FALSE
, /* partial_inplace */
479 0xffffff, /* dst_mask */
480 FALSE
), /* pcrel_offset */
482 /* An 8 bit switch table entry. This is generated for an expression
483 such as ``.byte L1 - L2''. The offset holds the difference
484 between the reloc address and L2. */
485 HOWTO (R_CR16_SWITCH8
, /* type */
487 0, /* size (0 = byte, 1 = short, 2 = long) */
489 FALSE
, /* pc_relative */
491 complain_overflow_unsigned
, /* complain_on_overflow */
492 bfd_elf_generic_reloc
, /* special_function */
493 "R_CR16_SWITCH8", /* name */
494 FALSE
, /* partial_inplace */
497 TRUE
), /* pcrel_offset */
499 /* A 16 bit switch table entry. This is generated for an expression
500 such as ``.word L1 - L2''. The offset holds the difference
501 between the reloc address and L2. */
502 HOWTO (R_CR16_SWITCH16
, /* type */
504 1, /* size (0 = byte, 1 = short, 2 = long) */
506 FALSE
, /* pc_relative */
508 complain_overflow_unsigned
, /* complain_on_overflow */
509 bfd_elf_generic_reloc
, /* special_function */
510 "R_CR16_SWITCH16", /* name */
511 FALSE
, /* partial_inplace */
513 0xffff, /* dst_mask */
514 TRUE
), /* pcrel_offset */
516 /* A 32 bit switch table entry. This is generated for an expression
517 such as ``.long L1 - L2''. The offset holds the difference
518 between the reloc address and L2. */
519 HOWTO (R_CR16_SWITCH32
, /* type */
521 2, /* size (0 = byte, 1 = short, 2 = long) */
523 FALSE
, /* pc_relative */
525 complain_overflow_unsigned
, /* complain_on_overflow */
526 bfd_elf_generic_reloc
, /* special_function */
527 "R_CR16_SWITCH32", /* name */
528 FALSE
, /* partial_inplace */
530 0xffffffff, /* dst_mask */
531 TRUE
), /* pcrel_offset */
533 HOWTO (R_CR16_GOT_REGREL20
, /* type */
537 FALSE
, /* pc_relative */
539 complain_overflow_bitfield
,/* complain_on_overflow */
540 bfd_elf_generic_reloc
, /* special_function */
541 "R_CR16_GOT_REGREL20", /* name */
542 TRUE
, /* partial_inplace */
544 0xfffff, /* dst_mask */
545 FALSE
), /* pcrel_offset */
547 HOWTO (R_CR16_GOTC_REGREL20
, /* type */
551 FALSE
, /* pc_relative */
553 complain_overflow_bitfield
,/* complain_on_overflow */
554 bfd_elf_generic_reloc
, /* special_function */
555 "R_CR16_GOTC_REGREL20", /* name */
556 TRUE
, /* partial_inplace */
558 0xfffff, /* dst_mask */
559 FALSE
), /* pcrel_offset */
561 HOWTO (R_CR16_GLOB_DAT
, /* type */
563 2, /* size (0 = byte, 1 = short, 2 = long) */
565 FALSE
, /* pc_relative */
567 complain_overflow_unsigned
, /* complain_on_overflow */
568 bfd_elf_generic_reloc
, /* special_function */
569 "R_CR16_GLOB_DAT", /* name */
570 FALSE
, /* partial_inplace */
572 0xffffffff, /* dst_mask */
573 TRUE
) /* pcrel_offset */
577 /* Create the GOT section. */
580 _bfd_cr16_elf_create_got_section (bfd
* abfd
, struct bfd_link_info
* info
)
584 struct elf_link_hash_entry
* h
;
585 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
586 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
589 /* This function may be called more than once. */
590 if (htab
->sgot
!= NULL
)
593 switch (bed
->s
->arch_size
)
604 bfd_set_error (bfd_error_bad_value
);
608 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
609 | SEC_LINKER_CREATED
);
611 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
614 || !bfd_set_section_alignment (s
, ptralign
))
617 if (bed
->want_got_plt
)
619 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
622 || !bfd_set_section_alignment (s
, ptralign
))
626 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
627 (or .got.plt) section. We don't do this in the linker script
628 because we don't want to define the symbol if we are not creating
629 a global offset table. */
630 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_GLOBAL_OFFSET_TABLE_");
635 /* The first bit of the global offset table is the header. */
636 s
->size
+= bed
->got_header_size
;
642 /* Retrieve a howto ptr using a BFD reloc_code. */
644 static reloc_howto_type
*
645 elf_cr16_reloc_type_lookup (bfd
*abfd
,
646 bfd_reloc_code_real_type code
)
650 for (i
= 0; i
< R_CR16_MAX
; i
++)
651 if (code
== cr16_reloc_map
[i
].bfd_reloc_enum
)
652 return &cr16_elf_howto_table
[cr16_reloc_map
[i
].cr16_reloc_type
];
654 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
659 static reloc_howto_type
*
660 elf_cr16_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
665 for (i
= 0; ARRAY_SIZE (cr16_elf_howto_table
); i
++)
666 if (cr16_elf_howto_table
[i
].name
!= NULL
667 && strcasecmp (cr16_elf_howto_table
[i
].name
, r_name
) == 0)
668 return cr16_elf_howto_table
+ i
;
673 /* Retrieve a howto ptr using an internal relocation entry. */
676 elf_cr16_info_to_howto (bfd
*abfd
, arelent
*cache_ptr
,
677 Elf_Internal_Rela
*dst
)
679 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
681 if (r_type
>= R_CR16_MAX
)
683 /* xgettext:c-format */
684 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
686 bfd_set_error (bfd_error_bad_value
);
689 cache_ptr
->howto
= cr16_elf_howto_table
+ r_type
;
693 /* Look through the relocs for a section during the first phase.
694 Since we don't do .gots or .plts, we just need to consider the
695 virtual table relocs for gc. */
698 cr16_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
699 const Elf_Internal_Rela
*relocs
)
701 Elf_Internal_Shdr
*symtab_hdr
;
702 Elf_Internal_Sym
* isymbuf
= NULL
;
703 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
704 const Elf_Internal_Rela
*rel
;
705 const Elf_Internal_Rela
*rel_end
;
707 bfd_vma
* local_got_offsets
;
713 bfd_boolean result
= FALSE
;
715 if (bfd_link_relocatable (info
))
718 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
719 sym_hashes
= elf_sym_hashes (abfd
);
720 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
721 if (!elf_bad_symtab (abfd
))
722 sym_hashes_end
-= symtab_hdr
->sh_info
;
724 dynobj
= elf_hash_table (info
)->dynobj
;
725 local_got_offsets
= elf_local_got_offsets (abfd
);
726 rel_end
= relocs
+ sec
->reloc_count
;
727 for (rel
= relocs
; rel
< rel_end
; rel
++)
729 struct elf_link_hash_entry
*h
;
730 unsigned long r_symndx
;
732 r_symndx
= ELF32_R_SYM (rel
->r_info
);
733 if (r_symndx
< symtab_hdr
->sh_info
)
737 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
738 while (h
->root
.type
== bfd_link_hash_indirect
739 || h
->root
.type
== bfd_link_hash_warning
)
740 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
743 /* Some relocs require a global offset table. */
746 switch (ELF32_R_TYPE (rel
->r_info
))
748 case R_CR16_GOT_REGREL20
:
749 case R_CR16_GOTC_REGREL20
:
750 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
751 if (! _bfd_cr16_elf_create_got_section (dynobj
, info
))
760 switch (ELF32_R_TYPE (rel
->r_info
))
762 case R_CR16_GOT_REGREL20
:
763 case R_CR16_GOTC_REGREL20
:
764 /* This symbol requires a global offset table entry. */
766 sgot
= elf_hash_table (info
)->sgot
;
767 srelgot
= elf_hash_table (info
)->srelgot
;
768 BFD_ASSERT (sgot
!= NULL
&& srelgot
!= NULL
);
772 if (h
->got
.offset
!= (bfd_vma
) -1)
773 /* We have already allocated space in the .got. */
776 h
->got
.offset
= sgot
->size
;
778 /* Make sure this symbol is output as a dynamic symbol. */
779 if (h
->dynindx
== -1)
781 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
785 srelgot
->size
+= sizeof (Elf32_External_Rela
);
789 /* This is a global offset table entry for a local
791 if (local_got_offsets
== NULL
)
796 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
797 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
799 if (local_got_offsets
== NULL
)
802 elf_local_got_offsets (abfd
) = local_got_offsets
;
804 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
805 local_got_offsets
[i
] = (bfd_vma
) -1;
808 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
809 /* We have already allocated space in the .got. */
812 local_got_offsets
[r_symndx
] = sgot
->size
;
814 if (bfd_link_executable (info
))
815 /* If we are generating a shared object, we need to
816 output a R_CR16_RELATIVE reloc so that the dynamic
817 linker can adjust this GOT entry. */
818 srelgot
->size
+= sizeof (Elf32_External_Rela
);
834 /* Perform a relocation as part of a final link. */
836 static bfd_reloc_status_type
837 cr16_elf_final_link_relocate (reloc_howto_type
*howto
,
839 bfd
*output_bfd ATTRIBUTE_UNUSED
,
840 asection
*input_section
,
845 struct elf_link_hash_entry
* h
,
846 unsigned long symndx ATTRIBUTE_UNUSED
,
847 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
848 asection
*sec ATTRIBUTE_UNUSED
,
849 int is_local ATTRIBUTE_UNUSED
)
851 unsigned short r_type
= howto
->type
;
852 bfd_byte
*hit_data
= contents
+ offset
;
853 bfd_vma reloc_bits
, check
, Rvalue1
;
867 case R_CR16_REGREL4a
:
868 case R_CR16_REGREL14
:
869 case R_CR16_REGREL14a
:
870 case R_CR16_REGREL16
:
871 case R_CR16_REGREL20
:
872 case R_CR16_REGREL20a
:
873 case R_CR16_GOT_REGREL20
:
874 case R_CR16_GOTC_REGREL20
:
878 /* 'hit_data' is relative to the start of the instruction, not the
879 relocation offset. Advance it to account for the exact offset. */
899 case R_CR16_SWITCH16
:
900 case R_CR16_SWITCH32
:
901 /* We only care about the addend, where the difference between
902 expressions is kept. */
909 if (howto
->pc_relative
)
911 /* Subtract the address of the section containing the location. */
912 Rvalue
-= (input_section
->output_section
->vma
913 + input_section
->output_offset
);
914 /* Subtract the position of the location within the section. */
918 /* Add in supplied addend. */
921 /* Complain if the bitfield overflows, whether it is considered
922 as signed or unsigned. */
923 check
= Rvalue
>> howto
->rightshift
;
925 reloc_bits
= ((bfd_vma
) 1 << (howto
->bitsize
- 1) << 1) - 1;
927 /* For GOT and GOTC relocs no boundary checks applied. */
928 if (!((r_type
== R_CR16_GOT_REGREL20
)
929 || (r_type
== R_CR16_GOTC_REGREL20
)))
931 if (((bfd_vma
) check
& ~reloc_bits
) != 0
932 && (((bfd_vma
) check
& ~reloc_bits
)
933 != (-(bfd_vma
) 1 & ~reloc_bits
)))
935 /* The above right shift is incorrect for a signed
936 value. See if turning on the upper bits fixes the
938 if (howto
->rightshift
&& (bfd_signed_vma
) Rvalue
< 0)
940 check
|= ((bfd_vma
) - 1
942 >> howto
->rightshift
));
944 if (((bfd_vma
) check
& ~reloc_bits
)
945 != (-(bfd_vma
) 1 & ~reloc_bits
))
946 return bfd_reloc_overflow
;
949 return bfd_reloc_overflow
;
952 /* Drop unwanted bits from the value we are relocating to. */
953 Rvalue
>>= (bfd_vma
) howto
->rightshift
;
955 /* Apply dst_mask to select only relocatable part of the insn. */
956 Rvalue
&= howto
->dst_mask
;
962 if (r_type
== R_CR16_DISP8
)
964 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
965 Rvalue
= ((Rvalue1
& 0xf000) | ((Rvalue
<< 4) & 0xf00)
966 | (Rvalue1
& 0x00f0) | (Rvalue
& 0xf));
967 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
969 else if (r_type
== R_CR16_IMM4
)
971 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
972 Rvalue
= (((Rvalue1
& 0xff) << 8) | ((Rvalue
<< 4) & 0xf0)
973 | ((Rvalue1
& 0x0f00) >> 8));
974 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
976 else if (r_type
== R_CR16_DISP4
)
978 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
979 Rvalue
= (Rvalue1
| ((Rvalue
& 0xf) << 4));
980 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
984 bfd_put_8 (input_bfd
, (unsigned char) Rvalue
, hit_data
);
989 if (r_type
== R_CR16_DISP16
)
991 Rvalue
|= (bfd_get_16 (input_bfd
, hit_data
));
992 Rvalue
= ((Rvalue
& 0xfffe) | ((Rvalue
>> 16) & 0x1));
994 if (r_type
== R_CR16_IMM16
)
996 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
998 /* Add or subtract the offset value. */
999 if (Rvalue1
& 0x8000)
1000 Rvalue
-= (~Rvalue1
+ 1) & 0xffff;
1004 /* Check for range. */
1005 if ((long) Rvalue
> 0xffff || (long) Rvalue
< 0x0)
1006 return bfd_reloc_overflow
;
1009 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1013 if ((r_type
== R_CR16_ABS20
) || (r_type
== R_CR16_IMM20
))
1015 Rvalue1
= (bfd_get_16 (input_bfd
, hit_data
+ 2)
1016 | (((bfd_get_16 (input_bfd
, hit_data
) & 0xf) <<16)));
1018 /* Add or subtract the offset value. */
1019 if (Rvalue1
& 0x80000)
1020 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1024 /* Check for range. */
1025 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1026 return bfd_reloc_overflow
;
1028 bfd_put_16 (input_bfd
, ((bfd_get_16 (input_bfd
, hit_data
) & 0xfff0)
1029 | ((Rvalue
>> 16) & 0xf)), hit_data
);
1030 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1032 else if (r_type
== R_CR16_GOT_REGREL20
)
1034 asection
*sgot
= elf_hash_table (info
)->sgot
;
1040 off
= h
->got
.offset
;
1041 BFD_ASSERT (off
!= (bfd_vma
) -1);
1043 if (! elf_hash_table (info
)->dynamic_sections_created
1044 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1045 /* This is actually a static link, or it is a
1046 -Bsymbolic link and the symbol is defined
1047 locally, or the symbol was forced to be local
1048 because of a version file. We must initialize
1049 this entry in the global offset table.
1050 When doing a dynamic link, we create a .rela.got
1051 relocation entry to initialize the value. This
1052 is done in the finish_dynamic_symbol routine. */
1053 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1055 Rvalue
= sgot
->output_offset
+ off
;
1061 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1062 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1064 Rvalue
= sgot
->output_offset
+ off
;
1069 /* REVISIT: if ((long) Rvalue > 0xffffff ||
1070 (long) Rvalue < -0x800000). */
1071 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1072 return bfd_reloc_overflow
;
1075 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1076 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1077 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1080 else if (r_type
== R_CR16_GOTC_REGREL20
)
1082 asection
*sgot
= elf_hash_table (info
)->sgot
;
1088 off
= h
->got
.offset
;
1089 BFD_ASSERT (off
!= (bfd_vma
) -1);
1091 Rvalue
>>=1; /* For code symbols. */
1093 if (! elf_hash_table (info
)->dynamic_sections_created
1094 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1095 /* This is actually a static link, or it is a
1096 -Bsymbolic link and the symbol is defined
1097 locally, or the symbol was forced to be local
1098 because of a version file. We must initialize
1099 this entry in the global offset table.
1100 When doing a dynamic link, we create a .rela.got
1101 relocation entry to initialize the value. This
1102 is done in the finish_dynamic_symbol routine. */
1103 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1105 Rvalue
= sgot
->output_offset
+ off
;
1111 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1113 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1114 Rvalue
= sgot
->output_offset
+ off
;
1119 /* Check if any value in DISP. */
1120 Rvalue1
=((bfd_get_32 (input_bfd
, hit_data
) >>16)
1121 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1123 /* Add or subtract the offset value. */
1124 if (Rvalue1
& 0x80000)
1125 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1129 /* Check for range. */
1130 /* REVISIT: if ((long) Rvalue > 0xffffff
1131 || (long) Rvalue < -0x800000). */
1132 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1133 return bfd_reloc_overflow
;
1135 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1136 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1137 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1141 if (r_type
== R_CR16_ABS24
)
1143 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1144 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16)
1145 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xf) <<20)));
1147 /* Add or subtract the offset value. */
1148 if (Rvalue1
& 0x800000)
1149 Rvalue
-= (~Rvalue1
+ 1) & 0xffffff;
1153 /* Check for Range. */
1154 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0x0)
1155 return bfd_reloc_overflow
;
1157 Rvalue
= ((((Rvalue
>> 20) & 0xf) | (((Rvalue
>> 16) & 0xf)<<8)
1158 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0f0))
1159 | ((Rvalue
& 0xffff) << 16));
1161 else if (r_type
== R_CR16_DISP24
)
1163 Rvalue
= ((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1164 | (bfd_get_16 (input_bfd
, hit_data
)))
1165 | (((Rvalue
& 0xfffe) | ((Rvalue
>> 24) & 0x1)) << 16));
1167 else if ((r_type
== R_CR16_IMM32
) || (r_type
== R_CR16_IMM32a
))
1169 Rvalue1
=((((bfd_get_32 (input_bfd
, hit_data
)) >> 16) &0xffff)
1170 | (((bfd_get_32 (input_bfd
, hit_data
)) &0xffff)) << 16);
1172 /* Add or subtract the offset value. */
1173 if (Rvalue1
& 0x80000000)
1174 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1178 /* Check for range. */
1179 if (Rvalue
> 0xffffffff || (long) Rvalue
< 0x0)
1180 return bfd_reloc_overflow
;
1182 Rvalue
= (((Rvalue
>> 16)& 0xffff) | (Rvalue
& 0xffff) << 16);
1184 else if (r_type
== R_CR16_DISP24a
)
1186 Rvalue
= (((Rvalue
& 0xfffffe) | (Rvalue
>> 23)));
1187 Rvalue
= ((Rvalue
>> 16) & 0xff) | ((Rvalue
& 0xffff) << 16)
1188 | (bfd_get_32 (input_bfd
, hit_data
));
1190 else if ((r_type
== R_CR16_REGREL20
)
1191 || (r_type
== R_CR16_REGREL20a
))
1193 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1194 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1195 /* Add or subtract the offset value. */
1196 if (Rvalue1
& 0x80000)
1197 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1201 /* Check for range. */
1202 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1203 return bfd_reloc_overflow
;
1205 Rvalue
= (((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1206 | ((Rvalue
& 0xffff) << 16)))
1207 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0ff));
1210 else if (r_type
== R_CR16_NUM32
)
1212 Rvalue1
= (bfd_get_32 (input_bfd
, hit_data
));
1214 /* Add or subtract the offset value */
1215 if (Rvalue1
& 0x80000000)
1216 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1220 /* Check for Ranga */
1221 if (Rvalue
> 0xffffffff)
1222 return bfd_reloc_overflow
;
1225 bfd_put_32 (input_bfd
, Rvalue
, hit_data
);
1230 return bfd_reloc_notsupported
;
1233 return bfd_reloc_ok
;
1236 /* Delete some bytes from a section while relaxing. */
1239 elf32_cr16_relax_delete_bytes (struct bfd_link_info
*link_info
, bfd
*abfd
,
1240 asection
*sec
, bfd_vma addr
, int count
)
1242 Elf_Internal_Shdr
*symtab_hdr
;
1243 unsigned int sec_shndx
;
1245 Elf_Internal_Rela
*irel
, *irelend
;
1247 Elf_Internal_Sym
*isym
;
1248 Elf_Internal_Sym
*isymend
;
1249 struct elf_link_hash_entry
**sym_hashes
;
1250 struct elf_link_hash_entry
**end_hashes
;
1251 struct elf_link_hash_entry
**start_hashes
;
1252 unsigned int symcount
;
1254 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1256 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1260 irel
= elf_section_data (sec
)->relocs
;
1261 irelend
= irel
+ sec
->reloc_count
;
1263 /* Actually delete the bytes. */
1264 memmove (contents
+ addr
, contents
+ addr
+ count
,
1265 (size_t) (toaddr
- addr
- count
));
1268 /* Adjust all the relocs. */
1269 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1270 /* Get the new reloc address. */
1271 if ((irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
))
1272 irel
->r_offset
-= count
;
1274 /* Adjust the local symbols defined in this section. */
1275 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1276 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1277 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1279 if (isym
->st_shndx
== sec_shndx
1280 && isym
->st_value
> addr
1281 && isym
->st_value
< toaddr
)
1283 /* Adjust the addend of SWITCH relocations in this section,
1284 which reference this local symbol. */
1286 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1288 unsigned long r_symndx
;
1289 Elf_Internal_Sym
*rsym
;
1290 bfd_vma addsym
, subsym
;
1292 /* Skip if not a SWITCH relocation. */
1293 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH8
1294 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH16
1295 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH32
)
1298 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1299 rsym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ r_symndx
;
1301 /* Skip if not the local adjusted symbol. */
1305 addsym
= isym
->st_value
;
1306 subsym
= addsym
- irel
->r_addend
;
1308 /* Fix the addend only when -->> (addsym > addr >= subsym). */
1310 irel
->r_addend
-= count
;
1316 isym
->st_value
-= count
;
1320 /* Now adjust the global symbols defined in this section. */
1321 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1322 - symtab_hdr
->sh_info
);
1323 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
1324 end_hashes
= sym_hashes
+ symcount
;
1326 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1328 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1330 /* The '--wrap SYMBOL' option is causing a pain when the object file,
1331 containing the definition of __wrap_SYMBOL, includes a direct
1332 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1333 the same symbol (which is __wrap_SYMBOL), but still exist as two
1334 different symbols in 'sym_hashes', we don't want to adjust
1335 the global symbol __wrap_SYMBOL twice.
1336 This check is only relevant when symbols are being wrapped. */
1337 if (link_info
->wrap_hash
!= NULL
)
1339 struct elf_link_hash_entry
**cur_sym_hashes
;
1341 /* Loop only over the symbols whom been already checked. */
1342 for (cur_sym_hashes
= start_hashes
; cur_sym_hashes
< sym_hashes
;
1344 /* If the current symbol is identical to 'sym_hash', that means
1345 the symbol was already adjusted (or at least checked). */
1346 if (*cur_sym_hashes
== sym_hash
)
1349 /* Don't adjust the symbol again. */
1350 if (cur_sym_hashes
< sym_hashes
)
1354 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1355 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1356 && sym_hash
->root
.u
.def
.section
== sec
1357 && sym_hash
->root
.u
.def
.value
> addr
1358 && sym_hash
->root
.u
.def
.value
< toaddr
)
1359 sym_hash
->root
.u
.def
.value
-= count
;
1365 /* Relocate a CR16 ELF section. */
1368 elf32_cr16_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1369 bfd
*input_bfd
, asection
*input_section
,
1370 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1371 Elf_Internal_Sym
*local_syms
,
1372 asection
**local_sections
)
1374 Elf_Internal_Shdr
*symtab_hdr
;
1375 struct elf_link_hash_entry
**sym_hashes
;
1376 Elf_Internal_Rela
*rel
, *relend
;
1378 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1379 sym_hashes
= elf_sym_hashes (input_bfd
);
1382 relend
= relocs
+ input_section
->reloc_count
;
1383 for (; rel
< relend
; rel
++)
1386 reloc_howto_type
*howto
;
1387 unsigned long r_symndx
;
1388 Elf_Internal_Sym
*sym
;
1390 struct elf_link_hash_entry
*h
;
1392 bfd_reloc_status_type r
;
1394 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1395 r_type
= ELF32_R_TYPE (rel
->r_info
);
1396 howto
= cr16_elf_howto_table
+ (r_type
);
1401 if (r_symndx
< symtab_hdr
->sh_info
)
1403 sym
= local_syms
+ r_symndx
;
1404 sec
= local_sections
[r_symndx
];
1405 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1409 bfd_boolean unresolved_reloc
, warned
, ignored
;
1411 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1412 r_symndx
, symtab_hdr
, sym_hashes
,
1414 unresolved_reloc
, warned
, ignored
);
1417 if (sec
!= NULL
&& discarded_section (sec
))
1418 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1419 rel
, 1, relend
, howto
, 0, contents
);
1421 if (bfd_link_relocatable (info
))
1424 r
= cr16_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
1426 contents
, rel
->r_offset
,
1427 relocation
, rel
->r_addend
,
1428 (struct elf_link_hash_entry
*) h
,
1430 info
, sec
, h
== NULL
);
1432 if (r
!= bfd_reloc_ok
)
1435 const char *msg
= NULL
;
1438 name
= h
->root
.root
.string
;
1441 name
= (bfd_elf_string_from_elf_section
1442 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1443 if (name
== NULL
|| *name
== '\0')
1444 name
= bfd_section_name (sec
);
1449 case bfd_reloc_overflow
:
1450 (*info
->callbacks
->reloc_overflow
)
1451 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1452 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1455 case bfd_reloc_undefined
:
1456 (*info
->callbacks
->undefined_symbol
)
1457 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1460 case bfd_reloc_outofrange
:
1461 msg
= _("internal error: out of range error");
1464 case bfd_reloc_notsupported
:
1465 msg
= _("internal error: unsupported relocation error");
1468 case bfd_reloc_dangerous
:
1469 msg
= _("internal error: dangerous error");
1473 msg
= _("internal error: unknown error");
1477 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
1478 input_section
, rel
->r_offset
);
1487 /* This is a version of bfd_generic_get_relocated_section_contents
1488 which uses elf32_cr16_relocate_section. */
1491 elf32_cr16_get_relocated_section_contents (bfd
*output_bfd
,
1492 struct bfd_link_info
*link_info
,
1493 struct bfd_link_order
*link_order
,
1495 bfd_boolean relocatable
,
1498 Elf_Internal_Shdr
*symtab_hdr
;
1499 asection
*input_section
= link_order
->u
.indirect
.section
;
1500 bfd
*input_bfd
= input_section
->owner
;
1501 asection
**sections
= NULL
;
1502 Elf_Internal_Rela
*internal_relocs
= NULL
;
1503 Elf_Internal_Sym
*isymbuf
= NULL
;
1505 /* We only need to handle the case of relaxing, or of having a
1506 particular set of section contents, specially. */
1508 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1509 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1514 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1516 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1517 (size_t) input_section
->size
);
1519 if ((input_section
->flags
& SEC_RELOC
) != 0
1520 && input_section
->reloc_count
> 0)
1522 Elf_Internal_Sym
*isym
;
1523 Elf_Internal_Sym
*isymend
;
1527 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, input_section
,
1529 if (internal_relocs
== NULL
)
1532 if (symtab_hdr
->sh_info
!= 0)
1534 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1535 if (isymbuf
== NULL
)
1536 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1537 symtab_hdr
->sh_info
, 0,
1539 if (isymbuf
== NULL
)
1543 amt
= symtab_hdr
->sh_info
;
1544 amt
*= sizeof (asection
*);
1545 sections
= bfd_malloc (amt
);
1546 if (sections
== NULL
&& amt
!= 0)
1549 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1550 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1554 if (isym
->st_shndx
== SHN_UNDEF
)
1555 isec
= bfd_und_section_ptr
;
1556 else if (isym
->st_shndx
== SHN_ABS
)
1557 isec
= bfd_abs_section_ptr
;
1558 else if (isym
->st_shndx
== SHN_COMMON
)
1559 isec
= bfd_com_section_ptr
;
1561 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1566 if (! elf32_cr16_relocate_section (output_bfd
, link_info
, input_bfd
,
1567 input_section
, data
, internal_relocs
,
1572 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1574 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1575 free (internal_relocs
);
1582 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1584 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1585 free (internal_relocs
);
1589 /* Assorted hash table functions. */
1591 /* Initialize an entry in the link hash table. */
1593 /* Create an entry in an CR16 ELF linker hash table. */
1595 static struct bfd_hash_entry
*
1596 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1597 struct bfd_hash_table
*table
,
1600 struct elf32_cr16_link_hash_entry
*ret
=
1601 (struct elf32_cr16_link_hash_entry
*) entry
;
1603 /* Allocate the structure if it has not already been allocated by a
1605 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1606 ret
= ((struct elf32_cr16_link_hash_entry
*)
1607 bfd_hash_allocate (table
,
1608 sizeof (struct elf32_cr16_link_hash_entry
)));
1609 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1610 return (struct bfd_hash_entry
*) ret
;
1612 /* Call the allocation method of the superclass. */
1613 ret
= ((struct elf32_cr16_link_hash_entry
*)
1614 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1616 if (ret
!= (struct elf32_cr16_link_hash_entry
*) NULL
)
1618 ret
->direct_calls
= 0;
1619 ret
->stack_size
= 0;
1621 ret
->movm_stack_size
= 0;
1626 return (struct bfd_hash_entry
*) ret
;
1629 /* Create an cr16 ELF linker hash table. */
1631 static struct bfd_link_hash_table
*
1632 elf32_cr16_link_hash_table_create (bfd
*abfd
)
1634 struct elf_link_hash_table
*ret
;
1635 size_t amt
= sizeof (struct elf_link_hash_table
);
1637 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
1638 if (ret
== (struct elf_link_hash_table
*) NULL
)
1641 if (!_bfd_elf_link_hash_table_init (ret
, abfd
,
1642 elf32_cr16_link_hash_newfunc
,
1643 sizeof (struct elf32_cr16_link_hash_entry
),
1653 static unsigned long
1654 elf_cr16_mach (flagword flags
)
1660 return bfd_mach_cr16
;
1664 /* The final processing done just before writing out a CR16 ELF object
1665 file. This gets the CR16 architecture right based on the machine
1669 _bfd_cr16_elf_final_write_processing (bfd
*abfd
)
1672 switch (bfd_get_mach (abfd
))
1679 elf_elfheader (abfd
)->e_flags
|= val
;
1680 return _bfd_elf_final_write_processing (abfd
);
1685 _bfd_cr16_elf_object_p (bfd
*abfd
)
1687 bfd_default_set_arch_mach (abfd
, bfd_arch_cr16
,
1688 elf_cr16_mach (elf_elfheader (abfd
)->e_flags
));
1692 /* Merge backend specific data from an object file to the output
1693 object file when linking. */
1696 _bfd_cr16_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
1698 bfd
*obfd
= info
->output_bfd
;
1700 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1701 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1704 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1705 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
1707 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1708 bfd_get_mach (ibfd
)))
1716 /* This function handles relaxing for the CR16.
1718 There's quite a few relaxing opportunites available on the CR16:
1720 * bcond:24 -> bcond:16 1 byte
1721 * bcond:16 -> bcond:8 1 byte
1722 * arithmetic imm32 -> arithmetic imm20 12 bits
1723 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits
1725 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
1728 elf32_cr16_relax_section (bfd
*abfd
, asection
*sec
,
1729 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
1731 Elf_Internal_Shdr
*symtab_hdr
;
1732 Elf_Internal_Rela
*internal_relocs
;
1733 Elf_Internal_Rela
*irel
, *irelend
;
1734 bfd_byte
*contents
= NULL
;
1735 Elf_Internal_Sym
*isymbuf
= NULL
;
1737 /* Assume nothing changes. */
1740 /* We don't have to do anything for a relocatable link, if
1741 this section does not have relocs, or if this is not a
1743 if (bfd_link_relocatable (link_info
)
1744 || (sec
->flags
& SEC_RELOC
) == 0
1745 || sec
->reloc_count
== 0
1746 || (sec
->flags
& SEC_CODE
) == 0)
1749 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1751 /* Get a copy of the native relocations. */
1752 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
1753 link_info
->keep_memory
);
1754 if (internal_relocs
== NULL
)
1757 /* Walk through them looking for relaxing opportunities. */
1758 irelend
= internal_relocs
+ sec
->reloc_count
;
1759 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1763 /* If this isn't something that can be relaxed, then ignore
1765 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP16
1766 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP24
1767 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM32
1768 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM20
1769 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM16
)
1772 /* Get the section contents if we haven't done so already. */
1773 if (contents
== NULL
)
1775 /* Get cached copy if it exists. */
1776 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1777 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1778 /* Go get them off disk. */
1779 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1783 /* Read this BFD's local symbols if we haven't done so already. */
1784 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1786 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1787 if (isymbuf
== NULL
)
1788 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1789 symtab_hdr
->sh_info
, 0,
1791 if (isymbuf
== NULL
)
1795 /* Get the value of the symbol referred to by the reloc. */
1796 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1798 /* A local symbol. */
1799 Elf_Internal_Sym
*isym
;
1802 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1803 if (isym
->st_shndx
== SHN_UNDEF
)
1804 sym_sec
= bfd_und_section_ptr
;
1805 else if (isym
->st_shndx
== SHN_ABS
)
1806 sym_sec
= bfd_abs_section_ptr
;
1807 else if (isym
->st_shndx
== SHN_COMMON
)
1808 sym_sec
= bfd_com_section_ptr
;
1810 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1811 symval
= (isym
->st_value
1812 + sym_sec
->output_section
->vma
1813 + sym_sec
->output_offset
);
1818 struct elf_link_hash_entry
*h
;
1820 /* An external symbol. */
1821 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1822 h
= elf_sym_hashes (abfd
)[indx
];
1823 BFD_ASSERT (h
!= NULL
);
1825 if (h
->root
.type
!= bfd_link_hash_defined
1826 && h
->root
.type
!= bfd_link_hash_defweak
)
1827 /* This appears to be a reference to an undefined
1828 symbol. Just ignore it--it will be caught by the
1829 regular reloc processing. */
1832 symval
= (h
->root
.u
.def
.value
1833 + h
->root
.u
.def
.section
->output_section
->vma
1834 + h
->root
.u
.def
.section
->output_offset
);
1837 /* For simplicity of coding, we are going to modify the section
1838 contents, the section relocs, and the BFD symbol table. We
1839 must tell the rest of the code not to free up this
1840 information. It would be possible to instead create a table
1841 of changes which have to be made, as is done in coff-mips.c;
1842 that would be more work, but would require less memory when
1843 the linker is run. */
1845 /* Try to turn a 24 branch/call into a 16bit relative
1847 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP24
)
1849 bfd_vma value
= symval
;
1851 /* Deal with pc-relative gunk. */
1852 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1853 value
-= irel
->r_offset
;
1854 value
+= irel
->r_addend
;
1856 /* See if the value will fit in 16 bits, note the high value is
1857 0xfffe + 2 as the target will be two bytes closer if we are
1859 if ((long) value
< 0x10000 && (long) value
> -0x10002)
1863 /* Get the opcode. */
1864 code
= (unsigned int) bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1866 /* Verify it's a 'bcond' and fix the opcode. */
1867 if ((code
& 0xffff) == 0x0010)
1868 bfd_put_16 (abfd
, 0x1800 | ((0xf & (code
>> 20)) << 4), contents
+ irel
->r_offset
);
1872 /* Note that we've changed the relocs, section contents, etc. */
1873 elf_section_data (sec
)->relocs
= internal_relocs
;
1874 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1875 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1877 /* Fix the relocation's type. */
1878 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1881 /* Delete two bytes of data. */
1882 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1883 irel
->r_offset
+ 2, 2))
1886 /* That will change things, so, we should relax again.
1887 Note that this is not required, and it may be slow. */
1892 /* Try to turn a 16bit pc-relative branch into an
1893 8bit pc-relative branch. */
1894 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP16
)
1896 bfd_vma value
= symval
;
1898 /* Deal with pc-relative gunk. */
1899 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1900 value
-= irel
->r_offset
;
1901 value
+= irel
->r_addend
;
1903 /* See if the value will fit in 8 bits, note the high value is
1904 0xfc + 2 as the target will be two bytes closer if we are
1906 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1907 if ((long) value
< 0xfa && (long) value
> -0x100)
1909 unsigned short code
;
1911 /* Get the opcode. */
1912 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1914 /* Verify it's a 'bcond' and fix the opcode. */
1915 if ((code
& 0xff0f) == 0x1800)
1916 bfd_put_16 (abfd
, (code
& 0xf0f0), contents
+ irel
->r_offset
);
1920 /* Note that we've changed the relocs, section contents, etc. */
1921 elf_section_data (sec
)->relocs
= internal_relocs
;
1922 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1923 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1925 /* Fix the relocation's type. */
1926 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1929 /* Delete two bytes of data. */
1930 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1931 irel
->r_offset
+ 2, 2))
1934 /* That will change things, so, we should relax again.
1935 Note that this is not required, and it may be slow. */
1940 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1941 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM32
)
1943 bfd_vma value
= symval
;
1944 unsigned short is_add_mov
= 0;
1947 /* Get the existing value from the mcode */
1948 value1
= ((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) >> 16)
1949 |(((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff) << 16)));
1951 /* See if the value will fit in 20 bits. */
1952 if ((long) (value
+ value1
) < 0xfffff && (long) (value
+ value1
) > 0)
1954 unsigned short code
;
1956 /* Get the opcode. */
1957 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1959 /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1960 For ADDD and MOVD only, convert to IMM32 -> IMM20. */
1962 if (((code
& 0xfff0) == 0x0070) || ((code
& 0xfff0) == 0x0020))
1967 /* Note that we've changed the relocs, section contents,
1969 elf_section_data (sec
)->relocs
= internal_relocs
;
1970 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1971 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1973 /* Fix the opcode. */
1974 if ((code
& 0xfff0) == 0x0070) /* For movd. */
1975 bfd_put_8 (abfd
, 0x05, contents
+ irel
->r_offset
+ 1);
1976 else /* code == 0x0020 for addd. */
1977 bfd_put_8 (abfd
, 0x04, contents
+ irel
->r_offset
+ 1);
1979 bfd_put_8 (abfd
, (code
& 0xf) << 4, contents
+ irel
->r_offset
);
1981 /* If existing value is nagavive adjust approriately
1982 place the 16-20bits (ie 4 bit) in new opcode,
1983 as the 0xffffxxxx, the higher 2 byte values removed. */
1984 if (value1
& 0x80000000)
1985 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
1987 bfd_put_8 (abfd
, (((value1
>> 16)&0xf) | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
1989 /* Fix the relocation's type. */
1990 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1993 /* Delete two bytes of data. */
1994 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1995 irel
->r_offset
+ 2, 2))
1998 /* That will change things, so, we should relax again.
1999 Note that this is not required, and it may be slow. */
2004 /* See if the value will fit in 16 bits. */
2006 && ((long)(value
+ value1
) < 0x7fff && (long)(value
+ value1
) > 0))
2008 unsigned short code
;
2010 /* Get the opcode. */
2011 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2013 /* Note that we've changed the relocs, section contents, etc. */
2014 elf_section_data (sec
)->relocs
= internal_relocs
;
2015 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2016 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2018 /* Fix the opcode. */
2019 if ((code
& 0xf0) == 0x70) /* For movd. */
2020 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
+ 1);
2021 else if ((code
& 0xf0) == 0x20) /* For addd. */
2022 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
+ 1);
2023 else if ((code
& 0xf0) == 0x90) /* For cmpd. */
2024 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
+ 1);
2028 bfd_put_8 (abfd
, 0xb0 | (code
& 0xf), contents
+ irel
->r_offset
);
2030 /* If existing value is nagavive adjust approriately
2031 place the 12-16bits (ie 4 bit) in new opcode,
2032 as the 0xfffffxxx, the higher 2 byte values removed. */
2033 if (value1
& 0x80000000)
2034 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2036 bfd_put_16 (abfd
, value1
, contents
+ irel
->r_offset
+ 2);
2039 /* Fix the relocation's type. */
2040 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2043 /* Delete two bytes of data. */
2044 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2045 irel
->r_offset
+ 2, 2))
2048 /* That will change things, so, we should relax again.
2049 Note that this is not required, and it may be slow. */
2055 /* Try to turn a 16bit immediate address into a 4bit
2056 immediate address. */
2057 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2058 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM16
))
2060 bfd_vma value
= symval
;
2063 /* Get the existing value from the mcode */
2064 value1
= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff));
2066 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2068 value1
|= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 1) & 0xf000) << 0x4);
2071 /* See if the value will fit in 4 bits. */
2072 if ((((long) (value
+ value1
)) < 0xf)
2073 && (((long) (value
+ value1
)) > 0))
2075 unsigned short code
;
2077 /* Get the opcode. */
2078 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2080 /* Note that we've changed the relocs, section contents, etc. */
2081 elf_section_data (sec
)->relocs
= internal_relocs
;
2082 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2083 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2085 /* Fix the opcode. */
2086 if (((code
& 0x0f00) == 0x0400) || ((code
& 0x0f00) == 0x0500))
2088 if ((code
& 0x0f00) == 0x0400) /* For movd imm20. */
2089 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2090 else /* For addd imm20. */
2091 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2092 bfd_put_8 (abfd
, (code
& 0xf0) >> 4, contents
+ irel
->r_offset
+ 1);
2096 if ((code
& 0xfff0) == 0x56b0) /* For cmpd imm16. */
2097 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
);
2098 else if ((code
& 0xfff0) == 0x54b0) /* For movd imm16. */
2099 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2100 else if ((code
& 0xfff0) == 0x58b0) /* For movb imm16. */
2101 bfd_put_8 (abfd
, 0x58, contents
+ irel
->r_offset
);
2102 else if ((code
& 0xfff0) == 0x5Ab0) /* For movw imm16. */
2103 bfd_put_8 (abfd
, 0x5A, contents
+ irel
->r_offset
);
2104 else if ((code
& 0xfff0) == 0x60b0) /* For addd imm16. */
2105 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2106 else if ((code
& 0xfff0) == 0x30b0) /* For addb imm16. */
2107 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
);
2108 else if ((code
& 0xfff0) == 0x2Cb0) /* For addub imm16. */
2109 bfd_put_8 (abfd
, 0x2C, contents
+ irel
->r_offset
);
2110 else if ((code
& 0xfff0) == 0x32b0) /* For adduw imm16. */
2111 bfd_put_8 (abfd
, 0x32, contents
+ irel
->r_offset
);
2112 else if ((code
& 0xfff0) == 0x38b0) /* For subb imm16. */
2113 bfd_put_8 (abfd
, 0x38, contents
+ irel
->r_offset
);
2114 else if ((code
& 0xfff0) == 0x3Cb0) /* For subcb imm16. */
2115 bfd_put_8 (abfd
, 0x3C, contents
+ irel
->r_offset
);
2116 else if ((code
& 0xfff0) == 0x3Fb0) /* For subcw imm16. */
2117 bfd_put_8 (abfd
, 0x3F, contents
+ irel
->r_offset
);
2118 else if ((code
& 0xfff0) == 0x3Ab0) /* For subw imm16. */
2119 bfd_put_8 (abfd
, 0x3A, contents
+ irel
->r_offset
);
2120 else if ((code
& 0xfff0) == 0x50b0) /* For cmpb imm16. */
2121 bfd_put_8 (abfd
, 0x50, contents
+ irel
->r_offset
);
2122 else if ((code
& 0xfff0) == 0x52b0) /* For cmpw imm16. */
2123 bfd_put_8 (abfd
, 0x52, contents
+ irel
->r_offset
);
2127 bfd_put_8 (abfd
, (code
& 0xf), contents
+ irel
->r_offset
+ 1);
2130 /* Fix the relocation's type. */
2131 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2134 /* Delete two bytes of data. */
2135 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2136 irel
->r_offset
+ 2, 2))
2139 /* That will change things, so, we should relax again.
2140 Note that this is not required, and it may be slow. */
2148 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2150 if (! link_info
->keep_memory
)
2153 /* Cache the symbols for elf_link_input_bfd. */
2154 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2157 if (contents
!= NULL
2158 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2160 if (! link_info
->keep_memory
)
2163 /* Cache the section contents for elf_link_input_bfd. */
2164 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2168 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2169 free (internal_relocs
);
2174 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2176 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2178 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2179 free (internal_relocs
);
2185 elf32_cr16_gc_mark_hook (asection
*sec
,
2186 struct bfd_link_info
*info
,
2187 Elf_Internal_Rela
*rel
,
2188 struct elf_link_hash_entry
*h
,
2189 Elf_Internal_Sym
*sym
)
2191 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2194 /* Create dynamic sections when linking against a dynamic object. */
2197 _bfd_cr16_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2201 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
2202 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2205 switch (bed
->s
->arch_size
)
2216 bfd_set_error (bfd_error_bad_value
);
2220 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2221 .rel[a].bss sections. */
2223 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2224 | SEC_LINKER_CREATED
);
2226 s
= bfd_make_section_anyway_with_flags (abfd
,
2227 (bed
->default_use_rela_p
2228 ? ".rela.plt" : ".rel.plt"),
2229 flags
| SEC_READONLY
);
2232 || !bfd_set_section_alignment (s
, ptralign
))
2235 if (! _bfd_cr16_elf_create_got_section (abfd
, info
))
2238 if (bed
->want_dynbss
)
2240 /* The .dynbss section is a place to put symbols which are defined
2241 by dynamic objects, are referenced by regular objects, and are
2242 not functions. We must allocate space for them in the process
2243 image and use a R_*_COPY reloc to tell the dynamic linker to
2244 initialize them at run time. The linker script puts the .dynbss
2245 section into the .bss section of the final image. */
2246 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2247 SEC_ALLOC
| SEC_LINKER_CREATED
);
2251 /* The .rel[a].bss section holds copy relocs. This section is not
2252 normally needed. We need to create it here, though, so that the
2253 linker will map it to an output section. We can't just create it
2254 only if we need it, because we will not know whether we need it
2255 until we have seen all the input files, and the first time the
2256 main linker code calls BFD after examining all the input files
2257 (size_dynamic_sections) the input sections have already been
2258 mapped to the output sections. If the section turns out not to
2259 be needed, we can discard it later. We will never need this
2260 section when generating a shared object, since they do not use
2262 if (! bfd_link_executable (info
))
2264 s
= bfd_make_section_anyway_with_flags (abfd
,
2265 (bed
->default_use_rela_p
2266 ? ".rela.bss" : ".rel.bss"),
2267 flags
| SEC_READONLY
);
2269 || !bfd_set_section_alignment (s
, ptralign
))
2277 /* Adjust a symbol defined by a dynamic object and referenced by a
2278 regular object. The current definition is in some section of the
2279 dynamic object, but we're not including those sections. We have to
2280 change the definition to something the rest of the link can
2284 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info
* info
,
2285 struct elf_link_hash_entry
* h
)
2290 dynobj
= elf_hash_table (info
)->dynobj
;
2292 /* Make sure we know what is going on here. */
2293 BFD_ASSERT (dynobj
!= NULL
2298 && !h
->def_regular
)));
2300 /* If this is a function, put it in the procedure linkage table. We
2301 will fill in the contents of the procedure linkage table later,
2302 when we know the address of the .got section. */
2303 if (h
->type
== STT_FUNC
2306 if (! bfd_link_executable (info
)
2310 /* This case can occur if we saw a PLT reloc in an input
2311 file, but the symbol was never referred to by a dynamic
2312 object. In such a case, we don't actually need to build
2313 a procedure linkage table, and we can just do a REL32
2315 BFD_ASSERT (h
->needs_plt
);
2319 /* Make sure this symbol is output as a dynamic symbol. */
2320 if (h
->dynindx
== -1)
2322 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2326 /* We also need to make an entry in the .got.plt section, which
2327 will be placed in the .got section by the linker script. */
2329 s
= elf_hash_table (info
)->sgotplt
;
2330 BFD_ASSERT (s
!= NULL
);
2333 /* We also need to make an entry in the .rela.plt section. */
2335 s
= elf_hash_table (info
)->srelplt
;
2336 BFD_ASSERT (s
!= NULL
);
2337 s
->size
+= sizeof (Elf32_External_Rela
);
2342 /* If this is a weak symbol, and there is a real definition, the
2343 processor independent code will have arranged for us to see the
2344 real definition first, and we can just use the same value. */
2345 if (h
->is_weakalias
)
2347 struct elf_link_hash_entry
*def
= weakdef (h
);
2348 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2349 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2350 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2354 /* This is a reference to a symbol defined by a dynamic object which
2355 is not a function. */
2357 /* If we are creating a shared library, we must presume that the
2358 only references to the symbol are via the global offset table.
2359 For such cases we need not do anything here; the relocations will
2360 be handled correctly by relocate_section. */
2361 if (bfd_link_executable (info
))
2364 /* If there are no references to this symbol that do not use the
2365 GOT, we don't need to generate a copy reloc. */
2366 if (!h
->non_got_ref
)
2369 /* We must allocate the symbol in our .dynbss section, which will
2370 become part of the .bss section of the executable. There will be
2371 an entry for this symbol in the .dynsym section. The dynamic
2372 object will contain position independent code, so all references
2373 from the dynamic object to this symbol will go through the global
2374 offset table. The dynamic linker will use the .dynsym entry to
2375 determine the address it must put in the global offset table, so
2376 both the dynamic object and the regular object will refer to the
2377 same memory location for the variable. */
2379 s
= bfd_get_linker_section (dynobj
, ".dynbss");
2380 BFD_ASSERT (s
!= NULL
);
2382 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2383 copy the initial value out of the dynamic object and into the
2384 runtime process image. We need to remember the offset into the
2385 .rela.bss section we are going to use. */
2386 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2390 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
2391 BFD_ASSERT (srel
!= NULL
);
2392 srel
->size
+= sizeof (Elf32_External_Rela
);
2396 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2399 /* Set the sizes of the dynamic sections. */
2402 _bfd_cr16_elf_size_dynamic_sections (bfd
* output_bfd
,
2403 struct bfd_link_info
* info
)
2409 dynobj
= elf_hash_table (info
)->dynobj
;
2410 BFD_ASSERT (dynobj
!= NULL
);
2412 if (elf_hash_table (info
)->dynamic_sections_created
)
2414 /* Set the contents of the .interp section to the interpreter. */
2415 if (bfd_link_executable (info
) && !info
->nointerp
)
2418 s
= bfd_get_linker_section (dynobj
, ".interp");
2419 BFD_ASSERT (s
!= NULL
);
2420 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2421 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2427 /* We may have created entries in the .rela.got section.
2428 However, if we are not creating the dynamic sections, we will
2429 not actually use these entries. Reset the size of .rela.got,
2430 which will cause it to get stripped from the output file
2432 s
= elf_hash_table (info
)->srelgot
;
2437 /* The check_relocs and adjust_dynamic_symbol entry points have
2438 determined the sizes of the various dynamic sections. Allocate
2441 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2445 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2448 /* It's OK to base decisions on the section name, because none
2449 of the dynobj section names depend upon the input files. */
2450 name
= bfd_section_name (s
);
2452 if (strcmp (name
, ".plt") == 0)
2454 /* Remember whether there is a PLT. */
2457 else if (CONST_STRNEQ (name
, ".rela"))
2461 /* Remember whether there are any reloc sections other
2463 if (strcmp (name
, ".rela.plt") != 0)
2466 /* We use the reloc_count field as a counter if we need
2467 to copy relocs into the output file. */
2471 else if (! CONST_STRNEQ (name
, ".got")
2472 && strcmp (name
, ".dynbss") != 0)
2473 /* It's not one of our sections, so don't allocate space. */
2478 /* If we don't need this section, strip it from the
2479 output file. This is mostly to handle .rela.bss and
2480 .rela.plt. We must create both sections in
2481 create_dynamic_sections, because they must be created
2482 before the linker maps input sections to output
2483 sections. The linker does that before
2484 adjust_dynamic_symbol is called, and it is that
2485 function which decides whether anything needs to go
2486 into these sections. */
2487 s
->flags
|= SEC_EXCLUDE
;
2491 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2494 /* Allocate memory for the section contents. We use bfd_zalloc
2495 here in case unused entries are not reclaimed before the
2496 section's contents are written out. This should not happen,
2497 but this way if it does, we get a R_CR16_NONE reloc
2498 instead of garbage. */
2499 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2500 if (s
->contents
== NULL
)
2504 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, relocs
);
2507 /* Finish up dynamic symbol handling. We set the contents of various
2508 dynamic sections here. */
2511 _bfd_cr16_elf_finish_dynamic_symbol (bfd
* output_bfd
,
2512 struct bfd_link_info
* info
,
2513 struct elf_link_hash_entry
* h
,
2514 Elf_Internal_Sym
* sym
)
2518 dynobj
= elf_hash_table (info
)->dynobj
;
2520 if (h
->got
.offset
!= (bfd_vma
) -1)
2524 Elf_Internal_Rela rel
;
2526 /* This symbol has an entry in the global offset table. Set it up. */
2528 sgot
= elf_hash_table (info
)->sgot
;
2529 srel
= elf_hash_table (info
)->srelgot
;
2530 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2532 rel
.r_offset
= (sgot
->output_section
->vma
2533 + sgot
->output_offset
2534 + (h
->got
.offset
& ~1));
2536 /* If this is a -Bsymbolic link, and the symbol is defined
2537 locally, we just want to emit a RELATIVE reloc. Likewise if
2538 the symbol was forced to be local because of a version file.
2539 The entry in the global offset table will already have been
2540 initialized in the relocate_section function. */
2541 if (bfd_link_executable (info
)
2542 && (info
->symbolic
|| h
->dynindx
== -1)
2545 rel
.r_info
= ELF32_R_INFO (0, R_CR16_GOT_REGREL20
);
2546 rel
.r_addend
= (h
->root
.u
.def
.value
2547 + h
->root
.u
.def
.section
->output_section
->vma
2548 + h
->root
.u
.def
.section
->output_offset
);
2552 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2553 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2557 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2558 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
2559 + srel
->reloc_count
));
2560 ++ srel
->reloc_count
;
2566 Elf_Internal_Rela rel
;
2568 /* This symbol needs a copy reloc. Set it up. */
2569 BFD_ASSERT (h
->dynindx
!= -1
2570 && (h
->root
.type
== bfd_link_hash_defined
2571 || h
->root
.type
== bfd_link_hash_defweak
));
2573 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
2574 BFD_ASSERT (s
!= NULL
);
2576 rel
.r_offset
= (h
->root
.u
.def
.value
2577 + h
->root
.u
.def
.section
->output_section
->vma
2578 + h
->root
.u
.def
.section
->output_offset
);
2579 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2581 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2582 (bfd_byte
*) ((Elf32_External_Rela
*) s
->contents
2587 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2588 if (h
== elf_hash_table (info
)->hdynamic
2589 || h
== elf_hash_table (info
)->hgot
)
2590 sym
->st_shndx
= SHN_ABS
;
2595 /* Finish up the dynamic sections. */
2598 _bfd_cr16_elf_finish_dynamic_sections (bfd
* output_bfd
,
2599 struct bfd_link_info
* info
)
2605 dynobj
= elf_hash_table (info
)->dynobj
;
2607 sgot
= elf_hash_table (info
)->sgotplt
;
2608 BFD_ASSERT (sgot
!= NULL
);
2609 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2611 if (elf_hash_table (info
)->dynamic_sections_created
)
2613 Elf32_External_Dyn
* dyncon
;
2614 Elf32_External_Dyn
* dynconend
;
2616 BFD_ASSERT (sdyn
!= NULL
);
2618 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2619 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2621 for (; dyncon
< dynconend
; dyncon
++)
2623 Elf_Internal_Dyn dyn
;
2626 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2634 s
= elf_hash_table (info
)->sgotplt
;
2638 s
= elf_hash_table (info
)->srelplt
;
2640 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2641 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2645 s
= elf_hash_table (info
)->srelplt
;
2646 dyn
.d_un
.d_val
= s
->size
;
2647 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2654 /* Fill in the first three entries in the global offset table. */
2658 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2660 bfd_put_32 (output_bfd
,
2661 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2665 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2670 /* Given a .data.rel section and a .emreloc in-memory section, store
2671 relocation information into the .emreloc section which can be
2672 used at runtime to relocate the section. This is called by the
2673 linker when the --embedded-relocs switch is used. This is called
2674 after the add_symbols entry point has been called for all the
2675 objects, and before the final_link entry point is called. */
2678 bfd_cr16_elf32_create_embedded_relocs (bfd
*abfd
,
2679 struct bfd_link_info
*info
,
2684 Elf_Internal_Shdr
*symtab_hdr
;
2685 Elf_Internal_Sym
*isymbuf
= NULL
;
2686 Elf_Internal_Rela
*internal_relocs
= NULL
;
2687 Elf_Internal_Rela
*irel
, *irelend
;
2691 BFD_ASSERT (! bfd_link_relocatable (info
));
2695 if (datasec
->reloc_count
== 0)
2698 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2700 /* Get a copy of the native relocations. */
2701 internal_relocs
= (_bfd_elf_link_read_relocs
2702 (abfd
, datasec
, NULL
, NULL
, info
->keep_memory
));
2703 if (internal_relocs
== NULL
)
2706 amt
= (bfd_size_type
) datasec
->reloc_count
* 8;
2707 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2708 if (relsec
->contents
== NULL
)
2711 p
= relsec
->contents
;
2713 irelend
= internal_relocs
+ datasec
->reloc_count
;
2714 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 8)
2716 asection
*targetsec
;
2718 /* We are going to write a four byte longword into the runtime
2719 reloc section. The longword will be the address in the data
2720 section which must be relocated. It is followed by the name
2721 of the target section NUL-padded or truncated to 8
2724 /* We can only relocate absolute longword relocs at run time. */
2725 if (!((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2726 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32
)))
2728 *errmsg
= _("unsupported relocation type");
2729 bfd_set_error (bfd_error_bad_value
);
2733 /* Get the target section referred to by the reloc. */
2734 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2736 /* A local symbol. */
2737 Elf_Internal_Sym
*isym
;
2739 /* Read this BFD's local symbols if we haven't done so already. */
2740 if (isymbuf
== NULL
)
2742 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2743 if (isymbuf
== NULL
)
2744 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2745 symtab_hdr
->sh_info
, 0,
2747 if (isymbuf
== NULL
)
2751 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2752 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2757 struct elf_link_hash_entry
*h
;
2759 /* An external symbol. */
2760 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2761 h
= elf_sym_hashes (abfd
)[indx
];
2762 BFD_ASSERT (h
!= NULL
);
2763 if (h
->root
.type
== bfd_link_hash_defined
2764 || h
->root
.type
== bfd_link_hash_defweak
)
2765 targetsec
= h
->root
.u
.def
.section
;
2770 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2771 memset (p
+ 4, 0, 4);
2772 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2773 && (targetsec
!= NULL
) )
2774 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 4);
2777 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2779 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
2780 free (internal_relocs
);
2784 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2786 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
2787 free (internal_relocs
);
2792 /* Classify relocation types, such that combreloc can sort them
2795 static enum elf_reloc_type_class
2796 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2797 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2798 const Elf_Internal_Rela
*rela
)
2800 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2802 case R_CR16_GOT_REGREL20
:
2803 case R_CR16_GOTC_REGREL20
:
2804 return reloc_class_relative
;
2806 return reloc_class_normal
;
2810 /* Definitions for setting CR16 target vector. */
2811 #define TARGET_LITTLE_SYM cr16_elf32_vec
2812 #define TARGET_LITTLE_NAME "elf32-cr16"
2813 #define ELF_ARCH bfd_arch_cr16
2814 #define ELF_MACHINE_CODE EM_CR16
2815 #define ELF_MACHINE_ALT1 EM_CR16_OLD
2816 #define ELF_MAXPAGESIZE 0x1
2817 #define elf_symbol_leading_char '_'
2819 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup
2820 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup
2821 #define elf_info_to_howto elf_cr16_info_to_howto
2822 #define elf_info_to_howto_rel NULL
2823 #define elf_backend_relocate_section elf32_cr16_relocate_section
2824 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section
2825 #define bfd_elf32_bfd_get_relocated_section_contents \
2826 elf32_cr16_get_relocated_section_contents
2827 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook
2828 #define elf_backend_can_gc_sections 1
2829 #define elf_backend_rela_normal 1
2830 #define elf_backend_check_relocs cr16_elf_check_relocs
2831 /* So we can set bits in e_flags. */
2832 #define elf_backend_final_write_processing \
2833 _bfd_cr16_elf_final_write_processing
2834 #define elf_backend_object_p _bfd_cr16_elf_object_p
2836 #define bfd_elf32_bfd_merge_private_bfd_data \
2837 _bfd_cr16_elf_merge_private_bfd_data
2840 #define bfd_elf32_bfd_link_hash_table_create \
2841 elf32_cr16_link_hash_table_create
2843 #define elf_backend_create_dynamic_sections \
2844 _bfd_cr16_elf_create_dynamic_sections
2845 #define elf_backend_adjust_dynamic_symbol \
2846 _bfd_cr16_elf_adjust_dynamic_symbol
2847 #define elf_backend_size_dynamic_sections \
2848 _bfd_cr16_elf_size_dynamic_sections
2849 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2850 #define elf_backend_finish_dynamic_symbol \
2851 _bfd_cr16_elf_finish_dynamic_symbol
2852 #define elf_backend_finish_dynamic_sections \
2853 _bfd_cr16_elf_finish_dynamic_sections
2855 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class
2858 #define elf_backend_want_got_plt 1
2859 #define elf_backend_plt_readonly 1
2860 #define elf_backend_want_plt_sym 0
2861 #define elf_backend_got_header_size 12
2862 #define elf_backend_dtrel_excludes_plt 1
2864 #include "elf32-target.h"