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 /* Assumes two's complement. This expression avoids
926 overflow if howto->bitsize is the number of bits in
928 reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
930 /* For GOT and GOTC relocs no boundary checks applied. */
931 if (!((r_type
== R_CR16_GOT_REGREL20
)
932 || (r_type
== R_CR16_GOTC_REGREL20
)))
934 if (((bfd_vma
) check
& ~reloc_bits
) != 0
935 && (((bfd_vma
) check
& ~reloc_bits
)
936 != (-(bfd_vma
) 1 & ~reloc_bits
)))
938 /* The above right shift is incorrect for a signed
939 value. See if turning on the upper bits fixes the
941 if (howto
->rightshift
&& (bfd_signed_vma
) Rvalue
< 0)
943 check
|= ((bfd_vma
) - 1
945 >> howto
->rightshift
));
947 if (((bfd_vma
) check
& ~reloc_bits
)
948 != (-(bfd_vma
) 1 & ~reloc_bits
))
949 return bfd_reloc_overflow
;
952 return bfd_reloc_overflow
;
955 /* Drop unwanted bits from the value we are relocating to. */
956 Rvalue
>>= (bfd_vma
) howto
->rightshift
;
958 /* Apply dst_mask to select only relocatable part of the insn. */
959 Rvalue
&= howto
->dst_mask
;
965 if (r_type
== R_CR16_DISP8
)
967 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
968 Rvalue
= ((Rvalue1
& 0xf000) | ((Rvalue
<< 4) & 0xf00)
969 | (Rvalue1
& 0x00f0) | (Rvalue
& 0xf));
970 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
972 else if (r_type
== R_CR16_IMM4
)
974 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
975 Rvalue
= (((Rvalue1
& 0xff) << 8) | ((Rvalue
<< 4) & 0xf0)
976 | ((Rvalue1
& 0x0f00) >> 8));
977 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
979 else if (r_type
== R_CR16_DISP4
)
981 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
982 Rvalue
= (Rvalue1
| ((Rvalue
& 0xf) << 4));
983 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
987 bfd_put_8 (input_bfd
, (unsigned char) Rvalue
, hit_data
);
992 if (r_type
== R_CR16_DISP16
)
994 Rvalue
|= (bfd_get_16 (input_bfd
, hit_data
));
995 Rvalue
= ((Rvalue
& 0xfffe) | ((Rvalue
>> 16) & 0x1));
997 if (r_type
== R_CR16_IMM16
)
999 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
1001 /* Add or subtract the offset value. */
1002 if (Rvalue1
& 0x8000)
1003 Rvalue
-= (~Rvalue1
+ 1) & 0xffff;
1007 /* Check for range. */
1008 if ((long) Rvalue
> 0xffff || (long) Rvalue
< 0x0)
1009 return bfd_reloc_overflow
;
1012 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1016 if ((r_type
== R_CR16_ABS20
) || (r_type
== R_CR16_IMM20
))
1018 Rvalue1
= (bfd_get_16 (input_bfd
, hit_data
+ 2)
1019 | (((bfd_get_16 (input_bfd
, hit_data
) & 0xf) <<16)));
1021 /* Add or subtract the offset value. */
1022 if (Rvalue1
& 0x80000)
1023 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1027 /* Check for range. */
1028 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1029 return bfd_reloc_overflow
;
1031 bfd_put_16 (input_bfd
, ((bfd_get_16 (input_bfd
, hit_data
) & 0xfff0)
1032 | ((Rvalue
>> 16) & 0xf)), hit_data
);
1033 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1035 else if (r_type
== R_CR16_GOT_REGREL20
)
1037 asection
*sgot
= elf_hash_table (info
)->sgot
;
1043 off
= h
->got
.offset
;
1044 BFD_ASSERT (off
!= (bfd_vma
) -1);
1046 if (! elf_hash_table (info
)->dynamic_sections_created
1047 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1048 /* This is actually a static link, or it is a
1049 -Bsymbolic link and the symbol is defined
1050 locally, or the symbol was forced to be local
1051 because of a version file. We must initialize
1052 this entry in the global offset table.
1053 When doing a dynamic link, we create a .rela.got
1054 relocation entry to initialize the value. This
1055 is done in the finish_dynamic_symbol routine. */
1056 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1058 Rvalue
= sgot
->output_offset
+ off
;
1064 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1065 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1067 Rvalue
= sgot
->output_offset
+ off
;
1072 /* REVISIT: if ((long) Rvalue > 0xffffff ||
1073 (long) Rvalue < -0x800000). */
1074 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1075 return bfd_reloc_overflow
;
1078 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1079 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1080 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1083 else if (r_type
== R_CR16_GOTC_REGREL20
)
1085 asection
*sgot
= elf_hash_table (info
)->sgot
;
1091 off
= h
->got
.offset
;
1092 BFD_ASSERT (off
!= (bfd_vma
) -1);
1094 Rvalue
>>=1; /* For code symbols. */
1096 if (! elf_hash_table (info
)->dynamic_sections_created
1097 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1098 /* This is actually a static link, or it is a
1099 -Bsymbolic link and the symbol is defined
1100 locally, or the symbol was forced to be local
1101 because of a version file. We must initialize
1102 this entry in the global offset table.
1103 When doing a dynamic link, we create a .rela.got
1104 relocation entry to initialize the value. This
1105 is done in the finish_dynamic_symbol routine. */
1106 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1108 Rvalue
= sgot
->output_offset
+ off
;
1114 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1116 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1117 Rvalue
= sgot
->output_offset
+ off
;
1122 /* Check if any value in DISP. */
1123 Rvalue1
=((bfd_get_32 (input_bfd
, hit_data
) >>16)
1124 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1126 /* Add or subtract the offset value. */
1127 if (Rvalue1
& 0x80000)
1128 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1132 /* Check for range. */
1133 /* REVISIT: if ((long) Rvalue > 0xffffff
1134 || (long) Rvalue < -0x800000). */
1135 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1136 return bfd_reloc_overflow
;
1138 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1139 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1140 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1144 if (r_type
== R_CR16_ABS24
)
1146 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1147 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16)
1148 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xf) <<20)));
1150 /* Add or subtract the offset value. */
1151 if (Rvalue1
& 0x800000)
1152 Rvalue
-= (~Rvalue1
+ 1) & 0xffffff;
1156 /* Check for Range. */
1157 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0x0)
1158 return bfd_reloc_overflow
;
1160 Rvalue
= ((((Rvalue
>> 20) & 0xf) | (((Rvalue
>> 16) & 0xf)<<8)
1161 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0f0))
1162 | ((Rvalue
& 0xffff) << 16));
1164 else if (r_type
== R_CR16_DISP24
)
1166 Rvalue
= ((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1167 | (bfd_get_16 (input_bfd
, hit_data
)))
1168 | (((Rvalue
& 0xfffe) | ((Rvalue
>> 24) & 0x1)) << 16));
1170 else if ((r_type
== R_CR16_IMM32
) || (r_type
== R_CR16_IMM32a
))
1172 Rvalue1
=((((bfd_get_32 (input_bfd
, hit_data
)) >> 16) &0xffff)
1173 | (((bfd_get_32 (input_bfd
, hit_data
)) &0xffff)) << 16);
1175 /* Add or subtract the offset value. */
1176 if (Rvalue1
& 0x80000000)
1177 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1181 /* Check for range. */
1182 if (Rvalue
> 0xffffffff || (long) Rvalue
< 0x0)
1183 return bfd_reloc_overflow
;
1185 Rvalue
= (((Rvalue
>> 16)& 0xffff) | (Rvalue
& 0xffff) << 16);
1187 else if (r_type
== R_CR16_DISP24a
)
1189 Rvalue
= (((Rvalue
& 0xfffffe) | (Rvalue
>> 23)));
1190 Rvalue
= ((Rvalue
>> 16) & 0xff) | ((Rvalue
& 0xffff) << 16)
1191 | (bfd_get_32 (input_bfd
, hit_data
));
1193 else if ((r_type
== R_CR16_REGREL20
)
1194 || (r_type
== R_CR16_REGREL20a
))
1196 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1197 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1198 /* Add or subtract the offset value. */
1199 if (Rvalue1
& 0x80000)
1200 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1204 /* Check for range. */
1205 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1206 return bfd_reloc_overflow
;
1208 Rvalue
= (((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1209 | ((Rvalue
& 0xffff) << 16)))
1210 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0ff));
1213 else if (r_type
== R_CR16_NUM32
)
1215 Rvalue1
= (bfd_get_32 (input_bfd
, hit_data
));
1217 /* Add or subtract the offset value */
1218 if (Rvalue1
& 0x80000000)
1219 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1223 /* Check for Ranga */
1224 if (Rvalue
> 0xffffffff)
1225 return bfd_reloc_overflow
;
1228 bfd_put_32 (input_bfd
, Rvalue
, hit_data
);
1233 return bfd_reloc_notsupported
;
1236 return bfd_reloc_ok
;
1239 /* Delete some bytes from a section while relaxing. */
1242 elf32_cr16_relax_delete_bytes (struct bfd_link_info
*link_info
, bfd
*abfd
,
1243 asection
*sec
, bfd_vma addr
, int count
)
1245 Elf_Internal_Shdr
*symtab_hdr
;
1246 unsigned int sec_shndx
;
1248 Elf_Internal_Rela
*irel
, *irelend
;
1250 Elf_Internal_Sym
*isym
;
1251 Elf_Internal_Sym
*isymend
;
1252 struct elf_link_hash_entry
**sym_hashes
;
1253 struct elf_link_hash_entry
**end_hashes
;
1254 struct elf_link_hash_entry
**start_hashes
;
1255 unsigned int symcount
;
1257 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1259 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1263 irel
= elf_section_data (sec
)->relocs
;
1264 irelend
= irel
+ sec
->reloc_count
;
1266 /* Actually delete the bytes. */
1267 memmove (contents
+ addr
, contents
+ addr
+ count
,
1268 (size_t) (toaddr
- addr
- count
));
1271 /* Adjust all the relocs. */
1272 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1273 /* Get the new reloc address. */
1274 if ((irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
))
1275 irel
->r_offset
-= count
;
1277 /* Adjust the local symbols defined in this section. */
1278 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1279 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1280 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1282 if (isym
->st_shndx
== sec_shndx
1283 && isym
->st_value
> addr
1284 && isym
->st_value
< toaddr
)
1286 /* Adjust the addend of SWITCH relocations in this section,
1287 which reference this local symbol. */
1289 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1291 unsigned long r_symndx
;
1292 Elf_Internal_Sym
*rsym
;
1293 bfd_vma addsym
, subsym
;
1295 /* Skip if not a SWITCH relocation. */
1296 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH8
1297 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH16
1298 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH32
)
1301 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1302 rsym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ r_symndx
;
1304 /* Skip if not the local adjusted symbol. */
1308 addsym
= isym
->st_value
;
1309 subsym
= addsym
- irel
->r_addend
;
1311 /* Fix the addend only when -->> (addsym > addr >= subsym). */
1313 irel
->r_addend
-= count
;
1319 isym
->st_value
-= count
;
1323 /* Now adjust the global symbols defined in this section. */
1324 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1325 - symtab_hdr
->sh_info
);
1326 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
1327 end_hashes
= sym_hashes
+ symcount
;
1329 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1331 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1333 /* The '--wrap SYMBOL' option is causing a pain when the object file,
1334 containing the definition of __wrap_SYMBOL, includes a direct
1335 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1336 the same symbol (which is __wrap_SYMBOL), but still exist as two
1337 different symbols in 'sym_hashes', we don't want to adjust
1338 the global symbol __wrap_SYMBOL twice.
1339 This check is only relevant when symbols are being wrapped. */
1340 if (link_info
->wrap_hash
!= NULL
)
1342 struct elf_link_hash_entry
**cur_sym_hashes
;
1344 /* Loop only over the symbols whom been already checked. */
1345 for (cur_sym_hashes
= start_hashes
; cur_sym_hashes
< sym_hashes
;
1347 /* If the current symbol is identical to 'sym_hash', that means
1348 the symbol was already adjusted (or at least checked). */
1349 if (*cur_sym_hashes
== sym_hash
)
1352 /* Don't adjust the symbol again. */
1353 if (cur_sym_hashes
< sym_hashes
)
1357 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1358 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1359 && sym_hash
->root
.u
.def
.section
== sec
1360 && sym_hash
->root
.u
.def
.value
> addr
1361 && sym_hash
->root
.u
.def
.value
< toaddr
)
1362 sym_hash
->root
.u
.def
.value
-= count
;
1368 /* Relocate a CR16 ELF section. */
1371 elf32_cr16_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1372 bfd
*input_bfd
, asection
*input_section
,
1373 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1374 Elf_Internal_Sym
*local_syms
,
1375 asection
**local_sections
)
1377 Elf_Internal_Shdr
*symtab_hdr
;
1378 struct elf_link_hash_entry
**sym_hashes
;
1379 Elf_Internal_Rela
*rel
, *relend
;
1381 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1382 sym_hashes
= elf_sym_hashes (input_bfd
);
1385 relend
= relocs
+ input_section
->reloc_count
;
1386 for (; rel
< relend
; rel
++)
1389 reloc_howto_type
*howto
;
1390 unsigned long r_symndx
;
1391 Elf_Internal_Sym
*sym
;
1393 struct elf_link_hash_entry
*h
;
1395 bfd_reloc_status_type r
;
1397 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1398 r_type
= ELF32_R_TYPE (rel
->r_info
);
1399 howto
= cr16_elf_howto_table
+ (r_type
);
1404 if (r_symndx
< symtab_hdr
->sh_info
)
1406 sym
= local_syms
+ r_symndx
;
1407 sec
= local_sections
[r_symndx
];
1408 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1412 bfd_boolean unresolved_reloc
, warned
, ignored
;
1414 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1415 r_symndx
, symtab_hdr
, sym_hashes
,
1417 unresolved_reloc
, warned
, ignored
);
1420 if (sec
!= NULL
&& discarded_section (sec
))
1421 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1422 rel
, 1, relend
, howto
, 0, contents
);
1424 if (bfd_link_relocatable (info
))
1427 r
= cr16_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
1429 contents
, rel
->r_offset
,
1430 relocation
, rel
->r_addend
,
1431 (struct elf_link_hash_entry
*) h
,
1433 info
, sec
, h
== NULL
);
1435 if (r
!= bfd_reloc_ok
)
1438 const char *msg
= NULL
;
1441 name
= h
->root
.root
.string
;
1444 name
= (bfd_elf_string_from_elf_section
1445 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1446 if (name
== NULL
|| *name
== '\0')
1447 name
= bfd_section_name (sec
);
1452 case bfd_reloc_overflow
:
1453 (*info
->callbacks
->reloc_overflow
)
1454 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1455 (bfd_vma
) 0, input_bfd
, input_section
, rel
->r_offset
);
1458 case bfd_reloc_undefined
:
1459 (*info
->callbacks
->undefined_symbol
)
1460 (info
, name
, input_bfd
, input_section
, rel
->r_offset
, TRUE
);
1463 case bfd_reloc_outofrange
:
1464 msg
= _("internal error: out of range error");
1467 case bfd_reloc_notsupported
:
1468 msg
= _("internal error: unsupported relocation error");
1471 case bfd_reloc_dangerous
:
1472 msg
= _("internal error: dangerous error");
1476 msg
= _("internal error: unknown error");
1480 (*info
->callbacks
->warning
) (info
, msg
, name
, input_bfd
,
1481 input_section
, rel
->r_offset
);
1490 /* This is a version of bfd_generic_get_relocated_section_contents
1491 which uses elf32_cr16_relocate_section. */
1494 elf32_cr16_get_relocated_section_contents (bfd
*output_bfd
,
1495 struct bfd_link_info
*link_info
,
1496 struct bfd_link_order
*link_order
,
1498 bfd_boolean relocatable
,
1501 Elf_Internal_Shdr
*symtab_hdr
;
1502 asection
*input_section
= link_order
->u
.indirect
.section
;
1503 bfd
*input_bfd
= input_section
->owner
;
1504 asection
**sections
= NULL
;
1505 Elf_Internal_Rela
*internal_relocs
= NULL
;
1506 Elf_Internal_Sym
*isymbuf
= NULL
;
1508 /* We only need to handle the case of relaxing, or of having a
1509 particular set of section contents, specially. */
1511 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1512 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1517 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1519 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1520 (size_t) input_section
->size
);
1522 if ((input_section
->flags
& SEC_RELOC
) != 0
1523 && input_section
->reloc_count
> 0)
1525 Elf_Internal_Sym
*isym
;
1526 Elf_Internal_Sym
*isymend
;
1530 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, input_section
,
1532 if (internal_relocs
== NULL
)
1535 if (symtab_hdr
->sh_info
!= 0)
1537 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1538 if (isymbuf
== NULL
)
1539 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1540 symtab_hdr
->sh_info
, 0,
1542 if (isymbuf
== NULL
)
1546 amt
= symtab_hdr
->sh_info
;
1547 amt
*= sizeof (asection
*);
1548 sections
= bfd_malloc (amt
);
1549 if (sections
== NULL
&& amt
!= 0)
1552 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1553 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1557 if (isym
->st_shndx
== SHN_UNDEF
)
1558 isec
= bfd_und_section_ptr
;
1559 else if (isym
->st_shndx
== SHN_ABS
)
1560 isec
= bfd_abs_section_ptr
;
1561 else if (isym
->st_shndx
== SHN_COMMON
)
1562 isec
= bfd_com_section_ptr
;
1564 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1569 if (! elf32_cr16_relocate_section (output_bfd
, link_info
, input_bfd
,
1570 input_section
, data
, internal_relocs
,
1575 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1577 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1578 free (internal_relocs
);
1585 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1587 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1588 free (internal_relocs
);
1592 /* Assorted hash table functions. */
1594 /* Initialize an entry in the link hash table. */
1596 /* Create an entry in an CR16 ELF linker hash table. */
1598 static struct bfd_hash_entry
*
1599 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1600 struct bfd_hash_table
*table
,
1603 struct elf32_cr16_link_hash_entry
*ret
=
1604 (struct elf32_cr16_link_hash_entry
*) entry
;
1606 /* Allocate the structure if it has not already been allocated by a
1608 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1609 ret
= ((struct elf32_cr16_link_hash_entry
*)
1610 bfd_hash_allocate (table
,
1611 sizeof (struct elf32_cr16_link_hash_entry
)));
1612 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1613 return (struct bfd_hash_entry
*) ret
;
1615 /* Call the allocation method of the superclass. */
1616 ret
= ((struct elf32_cr16_link_hash_entry
*)
1617 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1619 if (ret
!= (struct elf32_cr16_link_hash_entry
*) NULL
)
1621 ret
->direct_calls
= 0;
1622 ret
->stack_size
= 0;
1624 ret
->movm_stack_size
= 0;
1629 return (struct bfd_hash_entry
*) ret
;
1632 /* Create an cr16 ELF linker hash table. */
1634 static struct bfd_link_hash_table
*
1635 elf32_cr16_link_hash_table_create (bfd
*abfd
)
1637 struct elf_link_hash_table
*ret
;
1638 size_t amt
= sizeof (struct elf_link_hash_table
);
1640 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
1641 if (ret
== (struct elf_link_hash_table
*) NULL
)
1644 if (!_bfd_elf_link_hash_table_init (ret
, abfd
,
1645 elf32_cr16_link_hash_newfunc
,
1646 sizeof (struct elf32_cr16_link_hash_entry
),
1656 static unsigned long
1657 elf_cr16_mach (flagword flags
)
1663 return bfd_mach_cr16
;
1667 /* The final processing done just before writing out a CR16 ELF object
1668 file. This gets the CR16 architecture right based on the machine
1672 _bfd_cr16_elf_final_write_processing (bfd
*abfd
)
1675 switch (bfd_get_mach (abfd
))
1682 elf_elfheader (abfd
)->e_flags
|= val
;
1683 return _bfd_elf_final_write_processing (abfd
);
1688 _bfd_cr16_elf_object_p (bfd
*abfd
)
1690 bfd_default_set_arch_mach (abfd
, bfd_arch_cr16
,
1691 elf_cr16_mach (elf_elfheader (abfd
)->e_flags
));
1695 /* Merge backend specific data from an object file to the output
1696 object file when linking. */
1699 _bfd_cr16_elf_merge_private_bfd_data (bfd
*ibfd
, struct bfd_link_info
*info
)
1701 bfd
*obfd
= info
->output_bfd
;
1703 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1704 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1707 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1708 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
1710 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1711 bfd_get_mach (ibfd
)))
1719 /* This function handles relaxing for the CR16.
1721 There's quite a few relaxing opportunites available on the CR16:
1723 * bcond:24 -> bcond:16 1 byte
1724 * bcond:16 -> bcond:8 1 byte
1725 * arithmetic imm32 -> arithmetic imm20 12 bits
1726 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits
1728 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
1731 elf32_cr16_relax_section (bfd
*abfd
, asection
*sec
,
1732 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
1734 Elf_Internal_Shdr
*symtab_hdr
;
1735 Elf_Internal_Rela
*internal_relocs
;
1736 Elf_Internal_Rela
*irel
, *irelend
;
1737 bfd_byte
*contents
= NULL
;
1738 Elf_Internal_Sym
*isymbuf
= NULL
;
1740 /* Assume nothing changes. */
1743 /* We don't have to do anything for a relocatable link, if
1744 this section does not have relocs, or if this is not a
1746 if (bfd_link_relocatable (link_info
)
1747 || (sec
->flags
& SEC_RELOC
) == 0
1748 || sec
->reloc_count
== 0
1749 || (sec
->flags
& SEC_CODE
) == 0)
1752 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1754 /* Get a copy of the native relocations. */
1755 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
1756 link_info
->keep_memory
);
1757 if (internal_relocs
== NULL
)
1760 /* Walk through them looking for relaxing opportunities. */
1761 irelend
= internal_relocs
+ sec
->reloc_count
;
1762 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1766 /* If this isn't something that can be relaxed, then ignore
1768 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP16
1769 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP24
1770 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM32
1771 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM20
1772 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM16
)
1775 /* Get the section contents if we haven't done so already. */
1776 if (contents
== NULL
)
1778 /* Get cached copy if it exists. */
1779 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1780 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1781 /* Go get them off disk. */
1782 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1786 /* Read this BFD's local symbols if we haven't done so already. */
1787 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1789 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1790 if (isymbuf
== NULL
)
1791 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1792 symtab_hdr
->sh_info
, 0,
1794 if (isymbuf
== NULL
)
1798 /* Get the value of the symbol referred to by the reloc. */
1799 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1801 /* A local symbol. */
1802 Elf_Internal_Sym
*isym
;
1805 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1806 if (isym
->st_shndx
== SHN_UNDEF
)
1807 sym_sec
= bfd_und_section_ptr
;
1808 else if (isym
->st_shndx
== SHN_ABS
)
1809 sym_sec
= bfd_abs_section_ptr
;
1810 else if (isym
->st_shndx
== SHN_COMMON
)
1811 sym_sec
= bfd_com_section_ptr
;
1813 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1814 symval
= (isym
->st_value
1815 + sym_sec
->output_section
->vma
1816 + sym_sec
->output_offset
);
1821 struct elf_link_hash_entry
*h
;
1823 /* An external symbol. */
1824 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1825 h
= elf_sym_hashes (abfd
)[indx
];
1826 BFD_ASSERT (h
!= NULL
);
1828 if (h
->root
.type
!= bfd_link_hash_defined
1829 && h
->root
.type
!= bfd_link_hash_defweak
)
1830 /* This appears to be a reference to an undefined
1831 symbol. Just ignore it--it will be caught by the
1832 regular reloc processing. */
1835 symval
= (h
->root
.u
.def
.value
1836 + h
->root
.u
.def
.section
->output_section
->vma
1837 + h
->root
.u
.def
.section
->output_offset
);
1840 /* For simplicity of coding, we are going to modify the section
1841 contents, the section relocs, and the BFD symbol table. We
1842 must tell the rest of the code not to free up this
1843 information. It would be possible to instead create a table
1844 of changes which have to be made, as is done in coff-mips.c;
1845 that would be more work, but would require less memory when
1846 the linker is run. */
1848 /* Try to turn a 24 branch/call into a 16bit relative
1850 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP24
)
1852 bfd_vma value
= symval
;
1854 /* Deal with pc-relative gunk. */
1855 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1856 value
-= irel
->r_offset
;
1857 value
+= irel
->r_addend
;
1859 /* See if the value will fit in 16 bits, note the high value is
1860 0xfffe + 2 as the target will be two bytes closer if we are
1862 if ((long) value
< 0x10000 && (long) value
> -0x10002)
1866 /* Get the opcode. */
1867 code
= (unsigned int) bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1869 /* Verify it's a 'bcond' and fix the opcode. */
1870 if ((code
& 0xffff) == 0x0010)
1871 bfd_put_16 (abfd
, 0x1800 | ((0xf & (code
>> 20)) << 4), contents
+ irel
->r_offset
);
1875 /* Note that we've changed the relocs, section contents, etc. */
1876 elf_section_data (sec
)->relocs
= internal_relocs
;
1877 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1878 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1880 /* Fix the relocation's type. */
1881 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1884 /* Delete two bytes of data. */
1885 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1886 irel
->r_offset
+ 2, 2))
1889 /* That will change things, so, we should relax again.
1890 Note that this is not required, and it may be slow. */
1895 /* Try to turn a 16bit pc-relative branch into an
1896 8bit pc-relative branch. */
1897 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP16
)
1899 bfd_vma value
= symval
;
1901 /* Deal with pc-relative gunk. */
1902 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1903 value
-= irel
->r_offset
;
1904 value
+= irel
->r_addend
;
1906 /* See if the value will fit in 8 bits, note the high value is
1907 0xfc + 2 as the target will be two bytes closer if we are
1909 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1910 if ((long) value
< 0xfa && (long) value
> -0x100)
1912 unsigned short code
;
1914 /* Get the opcode. */
1915 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1917 /* Verify it's a 'bcond' and fix the opcode. */
1918 if ((code
& 0xff0f) == 0x1800)
1919 bfd_put_16 (abfd
, (code
& 0xf0f0), contents
+ irel
->r_offset
);
1923 /* Note that we've changed the relocs, section contents, etc. */
1924 elf_section_data (sec
)->relocs
= internal_relocs
;
1925 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1926 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1928 /* Fix the relocation's type. */
1929 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1932 /* Delete two bytes of data. */
1933 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1934 irel
->r_offset
+ 2, 2))
1937 /* That will change things, so, we should relax again.
1938 Note that this is not required, and it may be slow. */
1943 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1944 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM32
)
1946 bfd_vma value
= symval
;
1947 unsigned short is_add_mov
= 0;
1950 /* Get the existing value from the mcode */
1951 value1
= ((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) >> 16)
1952 |(((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff) << 16)));
1954 /* See if the value will fit in 20 bits. */
1955 if ((long) (value
+ value1
) < 0xfffff && (long) (value
+ value1
) > 0)
1957 unsigned short code
;
1959 /* Get the opcode. */
1960 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1962 /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1963 For ADDD and MOVD only, convert to IMM32 -> IMM20. */
1965 if (((code
& 0xfff0) == 0x0070) || ((code
& 0xfff0) == 0x0020))
1970 /* Note that we've changed the relocs, section contents,
1972 elf_section_data (sec
)->relocs
= internal_relocs
;
1973 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1974 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1976 /* Fix the opcode. */
1977 if ((code
& 0xfff0) == 0x0070) /* For movd. */
1978 bfd_put_8 (abfd
, 0x05, contents
+ irel
->r_offset
+ 1);
1979 else /* code == 0x0020 for addd. */
1980 bfd_put_8 (abfd
, 0x04, contents
+ irel
->r_offset
+ 1);
1982 bfd_put_8 (abfd
, (code
& 0xf) << 4, contents
+ irel
->r_offset
);
1984 /* If existing value is nagavive adjust approriately
1985 place the 16-20bits (ie 4 bit) in new opcode,
1986 as the 0xffffxxxx, the higher 2 byte values removed. */
1987 if (value1
& 0x80000000)
1988 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
1990 bfd_put_8 (abfd
, (((value1
>> 16)&0xf) | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
1992 /* Fix the relocation's type. */
1993 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1996 /* Delete two bytes of data. */
1997 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1998 irel
->r_offset
+ 2, 2))
2001 /* That will change things, so, we should relax again.
2002 Note that this is not required, and it may be slow. */
2007 /* See if the value will fit in 16 bits. */
2009 && ((long)(value
+ value1
) < 0x7fff && (long)(value
+ value1
) > 0))
2011 unsigned short code
;
2013 /* Get the opcode. */
2014 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2016 /* Note that we've changed the relocs, section contents, etc. */
2017 elf_section_data (sec
)->relocs
= internal_relocs
;
2018 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2019 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2021 /* Fix the opcode. */
2022 if ((code
& 0xf0) == 0x70) /* For movd. */
2023 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
+ 1);
2024 else if ((code
& 0xf0) == 0x20) /* For addd. */
2025 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
+ 1);
2026 else if ((code
& 0xf0) == 0x90) /* For cmpd. */
2027 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
+ 1);
2031 bfd_put_8 (abfd
, 0xb0 | (code
& 0xf), contents
+ irel
->r_offset
);
2033 /* If existing value is nagavive adjust approriately
2034 place the 12-16bits (ie 4 bit) in new opcode,
2035 as the 0xfffffxxx, the higher 2 byte values removed. */
2036 if (value1
& 0x80000000)
2037 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2039 bfd_put_16 (abfd
, value1
, contents
+ irel
->r_offset
+ 2);
2042 /* Fix the relocation's type. */
2043 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2046 /* Delete two bytes of data. */
2047 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2048 irel
->r_offset
+ 2, 2))
2051 /* That will change things, so, we should relax again.
2052 Note that this is not required, and it may be slow. */
2058 /* Try to turn a 16bit immediate address into a 4bit
2059 immediate address. */
2060 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2061 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM16
))
2063 bfd_vma value
= symval
;
2066 /* Get the existing value from the mcode */
2067 value1
= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff));
2069 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2071 value1
|= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 1) & 0xf000) << 0x4);
2074 /* See if the value will fit in 4 bits. */
2075 if ((((long) (value
+ value1
)) < 0xf)
2076 && (((long) (value
+ value1
)) > 0))
2078 unsigned short code
;
2080 /* Get the opcode. */
2081 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2083 /* Note that we've changed the relocs, section contents, etc. */
2084 elf_section_data (sec
)->relocs
= internal_relocs
;
2085 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2086 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2088 /* Fix the opcode. */
2089 if (((code
& 0x0f00) == 0x0400) || ((code
& 0x0f00) == 0x0500))
2091 if ((code
& 0x0f00) == 0x0400) /* For movd imm20. */
2092 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2093 else /* For addd imm20. */
2094 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2095 bfd_put_8 (abfd
, (code
& 0xf0) >> 4, contents
+ irel
->r_offset
+ 1);
2099 if ((code
& 0xfff0) == 0x56b0) /* For cmpd imm16. */
2100 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
);
2101 else if ((code
& 0xfff0) == 0x54b0) /* For movd imm16. */
2102 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2103 else if ((code
& 0xfff0) == 0x58b0) /* For movb imm16. */
2104 bfd_put_8 (abfd
, 0x58, contents
+ irel
->r_offset
);
2105 else if ((code
& 0xfff0) == 0x5Ab0) /* For movw imm16. */
2106 bfd_put_8 (abfd
, 0x5A, contents
+ irel
->r_offset
);
2107 else if ((code
& 0xfff0) == 0x60b0) /* For addd imm16. */
2108 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2109 else if ((code
& 0xfff0) == 0x30b0) /* For addb imm16. */
2110 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
);
2111 else if ((code
& 0xfff0) == 0x2Cb0) /* For addub imm16. */
2112 bfd_put_8 (abfd
, 0x2C, contents
+ irel
->r_offset
);
2113 else if ((code
& 0xfff0) == 0x32b0) /* For adduw imm16. */
2114 bfd_put_8 (abfd
, 0x32, contents
+ irel
->r_offset
);
2115 else if ((code
& 0xfff0) == 0x38b0) /* For subb imm16. */
2116 bfd_put_8 (abfd
, 0x38, contents
+ irel
->r_offset
);
2117 else if ((code
& 0xfff0) == 0x3Cb0) /* For subcb imm16. */
2118 bfd_put_8 (abfd
, 0x3C, contents
+ irel
->r_offset
);
2119 else if ((code
& 0xfff0) == 0x3Fb0) /* For subcw imm16. */
2120 bfd_put_8 (abfd
, 0x3F, contents
+ irel
->r_offset
);
2121 else if ((code
& 0xfff0) == 0x3Ab0) /* For subw imm16. */
2122 bfd_put_8 (abfd
, 0x3A, contents
+ irel
->r_offset
);
2123 else if ((code
& 0xfff0) == 0x50b0) /* For cmpb imm16. */
2124 bfd_put_8 (abfd
, 0x50, contents
+ irel
->r_offset
);
2125 else if ((code
& 0xfff0) == 0x52b0) /* For cmpw imm16. */
2126 bfd_put_8 (abfd
, 0x52, contents
+ irel
->r_offset
);
2130 bfd_put_8 (abfd
, (code
& 0xf), contents
+ irel
->r_offset
+ 1);
2133 /* Fix the relocation's type. */
2134 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2137 /* Delete two bytes of data. */
2138 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2139 irel
->r_offset
+ 2, 2))
2142 /* That will change things, so, we should relax again.
2143 Note that this is not required, and it may be slow. */
2151 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2153 if (! link_info
->keep_memory
)
2156 /* Cache the symbols for elf_link_input_bfd. */
2157 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2160 if (contents
!= NULL
2161 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2163 if (! link_info
->keep_memory
)
2166 /* Cache the section contents for elf_link_input_bfd. */
2167 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2171 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2172 free (internal_relocs
);
2177 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2179 if (elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2181 if (elf_section_data (sec
)->relocs
!= internal_relocs
)
2182 free (internal_relocs
);
2188 elf32_cr16_gc_mark_hook (asection
*sec
,
2189 struct bfd_link_info
*info
,
2190 Elf_Internal_Rela
*rel
,
2191 struct elf_link_hash_entry
*h
,
2192 Elf_Internal_Sym
*sym
)
2194 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2197 /* Create dynamic sections when linking against a dynamic object. */
2200 _bfd_cr16_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2204 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
2205 struct elf_link_hash_table
*htab
= elf_hash_table (info
);
2208 switch (bed
->s
->arch_size
)
2219 bfd_set_error (bfd_error_bad_value
);
2223 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2224 .rel[a].bss sections. */
2226 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2227 | SEC_LINKER_CREATED
);
2229 s
= bfd_make_section_anyway_with_flags (abfd
,
2230 (bed
->default_use_rela_p
2231 ? ".rela.plt" : ".rel.plt"),
2232 flags
| SEC_READONLY
);
2235 || !bfd_set_section_alignment (s
, ptralign
))
2238 if (! _bfd_cr16_elf_create_got_section (abfd
, info
))
2241 if (bed
->want_dynbss
)
2243 /* The .dynbss section is a place to put symbols which are defined
2244 by dynamic objects, are referenced by regular objects, and are
2245 not functions. We must allocate space for them in the process
2246 image and use a R_*_COPY reloc to tell the dynamic linker to
2247 initialize them at run time. The linker script puts the .dynbss
2248 section into the .bss section of the final image. */
2249 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2250 SEC_ALLOC
| SEC_LINKER_CREATED
);
2254 /* The .rel[a].bss section holds copy relocs. This section is not
2255 normally needed. We need to create it here, though, so that the
2256 linker will map it to an output section. We can't just create it
2257 only if we need it, because we will not know whether we need it
2258 until we have seen all the input files, and the first time the
2259 main linker code calls BFD after examining all the input files
2260 (size_dynamic_sections) the input sections have already been
2261 mapped to the output sections. If the section turns out not to
2262 be needed, we can discard it later. We will never need this
2263 section when generating a shared object, since they do not use
2265 if (! bfd_link_executable (info
))
2267 s
= bfd_make_section_anyway_with_flags (abfd
,
2268 (bed
->default_use_rela_p
2269 ? ".rela.bss" : ".rel.bss"),
2270 flags
| SEC_READONLY
);
2272 || !bfd_set_section_alignment (s
, ptralign
))
2280 /* Adjust a symbol defined by a dynamic object and referenced by a
2281 regular object. The current definition is in some section of the
2282 dynamic object, but we're not including those sections. We have to
2283 change the definition to something the rest of the link can
2287 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info
* info
,
2288 struct elf_link_hash_entry
* h
)
2293 dynobj
= elf_hash_table (info
)->dynobj
;
2295 /* Make sure we know what is going on here. */
2296 BFD_ASSERT (dynobj
!= NULL
2301 && !h
->def_regular
)));
2303 /* If this is a function, put it in the procedure linkage table. We
2304 will fill in the contents of the procedure linkage table later,
2305 when we know the address of the .got section. */
2306 if (h
->type
== STT_FUNC
2309 if (! bfd_link_executable (info
)
2313 /* This case can occur if we saw a PLT reloc in an input
2314 file, but the symbol was never referred to by a dynamic
2315 object. In such a case, we don't actually need to build
2316 a procedure linkage table, and we can just do a REL32
2318 BFD_ASSERT (h
->needs_plt
);
2322 /* Make sure this symbol is output as a dynamic symbol. */
2323 if (h
->dynindx
== -1)
2325 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2329 /* We also need to make an entry in the .got.plt section, which
2330 will be placed in the .got section by the linker script. */
2332 s
= elf_hash_table (info
)->sgotplt
;
2333 BFD_ASSERT (s
!= NULL
);
2336 /* We also need to make an entry in the .rela.plt section. */
2338 s
= elf_hash_table (info
)->srelplt
;
2339 BFD_ASSERT (s
!= NULL
);
2340 s
->size
+= sizeof (Elf32_External_Rela
);
2345 /* If this is a weak symbol, and there is a real definition, the
2346 processor independent code will have arranged for us to see the
2347 real definition first, and we can just use the same value. */
2348 if (h
->is_weakalias
)
2350 struct elf_link_hash_entry
*def
= weakdef (h
);
2351 BFD_ASSERT (def
->root
.type
== bfd_link_hash_defined
);
2352 h
->root
.u
.def
.section
= def
->root
.u
.def
.section
;
2353 h
->root
.u
.def
.value
= def
->root
.u
.def
.value
;
2357 /* This is a reference to a symbol defined by a dynamic object which
2358 is not a function. */
2360 /* If we are creating a shared library, we must presume that the
2361 only references to the symbol are via the global offset table.
2362 For such cases we need not do anything here; the relocations will
2363 be handled correctly by relocate_section. */
2364 if (bfd_link_executable (info
))
2367 /* If there are no references to this symbol that do not use the
2368 GOT, we don't need to generate a copy reloc. */
2369 if (!h
->non_got_ref
)
2372 /* We must allocate the symbol in our .dynbss section, which will
2373 become part of the .bss section of the executable. There will be
2374 an entry for this symbol in the .dynsym section. The dynamic
2375 object will contain position independent code, so all references
2376 from the dynamic object to this symbol will go through the global
2377 offset table. The dynamic linker will use the .dynsym entry to
2378 determine the address it must put in the global offset table, so
2379 both the dynamic object and the regular object will refer to the
2380 same memory location for the variable. */
2382 s
= bfd_get_linker_section (dynobj
, ".dynbss");
2383 BFD_ASSERT (s
!= NULL
);
2385 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2386 copy the initial value out of the dynamic object and into the
2387 runtime process image. We need to remember the offset into the
2388 .rela.bss section we are going to use. */
2389 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2393 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
2394 BFD_ASSERT (srel
!= NULL
);
2395 srel
->size
+= sizeof (Elf32_External_Rela
);
2399 return _bfd_elf_adjust_dynamic_copy (info
, h
, s
);
2402 /* Set the sizes of the dynamic sections. */
2405 _bfd_cr16_elf_size_dynamic_sections (bfd
* output_bfd
,
2406 struct bfd_link_info
* info
)
2412 dynobj
= elf_hash_table (info
)->dynobj
;
2413 BFD_ASSERT (dynobj
!= NULL
);
2415 if (elf_hash_table (info
)->dynamic_sections_created
)
2417 /* Set the contents of the .interp section to the interpreter. */
2418 if (bfd_link_executable (info
) && !info
->nointerp
)
2421 s
= bfd_get_linker_section (dynobj
, ".interp");
2422 BFD_ASSERT (s
!= NULL
);
2423 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2424 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2430 /* We may have created entries in the .rela.got section.
2431 However, if we are not creating the dynamic sections, we will
2432 not actually use these entries. Reset the size of .rela.got,
2433 which will cause it to get stripped from the output file
2435 s
= elf_hash_table (info
)->srelgot
;
2440 /* The check_relocs and adjust_dynamic_symbol entry points have
2441 determined the sizes of the various dynamic sections. Allocate
2444 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2448 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2451 /* It's OK to base decisions on the section name, because none
2452 of the dynobj section names depend upon the input files. */
2453 name
= bfd_section_name (s
);
2455 if (strcmp (name
, ".plt") == 0)
2457 /* Remember whether there is a PLT. */
2460 else if (CONST_STRNEQ (name
, ".rela"))
2464 /* Remember whether there are any reloc sections other
2466 if (strcmp (name
, ".rela.plt") != 0)
2469 /* We use the reloc_count field as a counter if we need
2470 to copy relocs into the output file. */
2474 else if (! CONST_STRNEQ (name
, ".got")
2475 && strcmp (name
, ".dynbss") != 0)
2476 /* It's not one of our sections, so don't allocate space. */
2481 /* If we don't need this section, strip it from the
2482 output file. This is mostly to handle .rela.bss and
2483 .rela.plt. We must create both sections in
2484 create_dynamic_sections, because they must be created
2485 before the linker maps input sections to output
2486 sections. The linker does that before
2487 adjust_dynamic_symbol is called, and it is that
2488 function which decides whether anything needs to go
2489 into these sections. */
2490 s
->flags
|= SEC_EXCLUDE
;
2494 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2497 /* Allocate memory for the section contents. We use bfd_zalloc
2498 here in case unused entries are not reclaimed before the
2499 section's contents are written out. This should not happen,
2500 but this way if it does, we get a R_CR16_NONE reloc
2501 instead of garbage. */
2502 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2503 if (s
->contents
== NULL
)
2507 return _bfd_elf_add_dynamic_tags (output_bfd
, info
, relocs
);
2510 /* Finish up dynamic symbol handling. We set the contents of various
2511 dynamic sections here. */
2514 _bfd_cr16_elf_finish_dynamic_symbol (bfd
* output_bfd
,
2515 struct bfd_link_info
* info
,
2516 struct elf_link_hash_entry
* h
,
2517 Elf_Internal_Sym
* sym
)
2521 dynobj
= elf_hash_table (info
)->dynobj
;
2523 if (h
->got
.offset
!= (bfd_vma
) -1)
2527 Elf_Internal_Rela rel
;
2529 /* This symbol has an entry in the global offset table. Set it up. */
2531 sgot
= elf_hash_table (info
)->sgot
;
2532 srel
= elf_hash_table (info
)->srelgot
;
2533 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2535 rel
.r_offset
= (sgot
->output_section
->vma
2536 + sgot
->output_offset
2537 + (h
->got
.offset
& ~1));
2539 /* If this is a -Bsymbolic link, and the symbol is defined
2540 locally, we just want to emit a RELATIVE reloc. Likewise if
2541 the symbol was forced to be local because of a version file.
2542 The entry in the global offset table will already have been
2543 initialized in the relocate_section function. */
2544 if (bfd_link_executable (info
)
2545 && (info
->symbolic
|| h
->dynindx
== -1)
2548 rel
.r_info
= ELF32_R_INFO (0, R_CR16_GOT_REGREL20
);
2549 rel
.r_addend
= (h
->root
.u
.def
.value
2550 + h
->root
.u
.def
.section
->output_section
->vma
2551 + h
->root
.u
.def
.section
->output_offset
);
2555 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2556 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2560 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2561 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
2562 + srel
->reloc_count
));
2563 ++ srel
->reloc_count
;
2569 Elf_Internal_Rela rel
;
2571 /* This symbol needs a copy reloc. Set it up. */
2572 BFD_ASSERT (h
->dynindx
!= -1
2573 && (h
->root
.type
== bfd_link_hash_defined
2574 || h
->root
.type
== bfd_link_hash_defweak
));
2576 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
2577 BFD_ASSERT (s
!= NULL
);
2579 rel
.r_offset
= (h
->root
.u
.def
.value
2580 + h
->root
.u
.def
.section
->output_section
->vma
2581 + h
->root
.u
.def
.section
->output_offset
);
2582 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2584 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2585 (bfd_byte
*) ((Elf32_External_Rela
*) s
->contents
2590 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2591 if (h
== elf_hash_table (info
)->hdynamic
2592 || h
== elf_hash_table (info
)->hgot
)
2593 sym
->st_shndx
= SHN_ABS
;
2598 /* Finish up the dynamic sections. */
2601 _bfd_cr16_elf_finish_dynamic_sections (bfd
* output_bfd
,
2602 struct bfd_link_info
* info
)
2608 dynobj
= elf_hash_table (info
)->dynobj
;
2610 sgot
= elf_hash_table (info
)->sgotplt
;
2611 BFD_ASSERT (sgot
!= NULL
);
2612 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2614 if (elf_hash_table (info
)->dynamic_sections_created
)
2616 Elf32_External_Dyn
* dyncon
;
2617 Elf32_External_Dyn
* dynconend
;
2619 BFD_ASSERT (sdyn
!= NULL
);
2621 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2622 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2624 for (; dyncon
< dynconend
; dyncon
++)
2626 Elf_Internal_Dyn dyn
;
2629 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2637 s
= elf_hash_table (info
)->sgotplt
;
2641 s
= elf_hash_table (info
)->srelplt
;
2643 dyn
.d_un
.d_ptr
= s
->output_section
->vma
+ s
->output_offset
;
2644 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2648 s
= elf_hash_table (info
)->srelplt
;
2649 dyn
.d_un
.d_val
= s
->size
;
2650 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2657 /* Fill in the first three entries in the global offset table. */
2661 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2663 bfd_put_32 (output_bfd
,
2664 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2668 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2673 /* Given a .data.rel section and a .emreloc in-memory section, store
2674 relocation information into the .emreloc section which can be
2675 used at runtime to relocate the section. This is called by the
2676 linker when the --embedded-relocs switch is used. This is called
2677 after the add_symbols entry point has been called for all the
2678 objects, and before the final_link entry point is called. */
2681 bfd_cr16_elf32_create_embedded_relocs (bfd
*abfd
,
2682 struct bfd_link_info
*info
,
2687 Elf_Internal_Shdr
*symtab_hdr
;
2688 Elf_Internal_Sym
*isymbuf
= NULL
;
2689 Elf_Internal_Rela
*internal_relocs
= NULL
;
2690 Elf_Internal_Rela
*irel
, *irelend
;
2694 BFD_ASSERT (! bfd_link_relocatable (info
));
2698 if (datasec
->reloc_count
== 0)
2701 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2703 /* Get a copy of the native relocations. */
2704 internal_relocs
= (_bfd_elf_link_read_relocs
2705 (abfd
, datasec
, NULL
, NULL
, info
->keep_memory
));
2706 if (internal_relocs
== NULL
)
2709 amt
= (bfd_size_type
) datasec
->reloc_count
* 8;
2710 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2711 if (relsec
->contents
== NULL
)
2714 p
= relsec
->contents
;
2716 irelend
= internal_relocs
+ datasec
->reloc_count
;
2717 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 8)
2719 asection
*targetsec
;
2721 /* We are going to write a four byte longword into the runtime
2722 reloc section. The longword will be the address in the data
2723 section which must be relocated. It is followed by the name
2724 of the target section NUL-padded or truncated to 8
2727 /* We can only relocate absolute longword relocs at run time. */
2728 if (!((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2729 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32
)))
2731 *errmsg
= _("unsupported relocation type");
2732 bfd_set_error (bfd_error_bad_value
);
2736 /* Get the target section referred to by the reloc. */
2737 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2739 /* A local symbol. */
2740 Elf_Internal_Sym
*isym
;
2742 /* Read this BFD's local symbols if we haven't done so already. */
2743 if (isymbuf
== NULL
)
2745 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2746 if (isymbuf
== NULL
)
2747 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2748 symtab_hdr
->sh_info
, 0,
2750 if (isymbuf
== NULL
)
2754 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2755 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2760 struct elf_link_hash_entry
*h
;
2762 /* An external symbol. */
2763 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2764 h
= elf_sym_hashes (abfd
)[indx
];
2765 BFD_ASSERT (h
!= NULL
);
2766 if (h
->root
.type
== bfd_link_hash_defined
2767 || h
->root
.type
== bfd_link_hash_defweak
)
2768 targetsec
= h
->root
.u
.def
.section
;
2773 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2774 memset (p
+ 4, 0, 4);
2775 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2776 && (targetsec
!= NULL
) )
2777 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 4);
2780 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2782 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
2783 free (internal_relocs
);
2787 if (symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2789 if (elf_section_data (datasec
)->relocs
!= internal_relocs
)
2790 free (internal_relocs
);
2795 /* Classify relocation types, such that combreloc can sort them
2798 static enum elf_reloc_type_class
2799 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2800 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2801 const Elf_Internal_Rela
*rela
)
2803 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2805 case R_CR16_GOT_REGREL20
:
2806 case R_CR16_GOTC_REGREL20
:
2807 return reloc_class_relative
;
2809 return reloc_class_normal
;
2813 /* Definitions for setting CR16 target vector. */
2814 #define TARGET_LITTLE_SYM cr16_elf32_vec
2815 #define TARGET_LITTLE_NAME "elf32-cr16"
2816 #define ELF_ARCH bfd_arch_cr16
2817 #define ELF_MACHINE_CODE EM_CR16
2818 #define ELF_MACHINE_ALT1 EM_CR16_OLD
2819 #define ELF_MAXPAGESIZE 0x1
2820 #define elf_symbol_leading_char '_'
2822 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup
2823 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup
2824 #define elf_info_to_howto elf_cr16_info_to_howto
2825 #define elf_info_to_howto_rel NULL
2826 #define elf_backend_relocate_section elf32_cr16_relocate_section
2827 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section
2828 #define bfd_elf32_bfd_get_relocated_section_contents \
2829 elf32_cr16_get_relocated_section_contents
2830 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook
2831 #define elf_backend_can_gc_sections 1
2832 #define elf_backend_rela_normal 1
2833 #define elf_backend_check_relocs cr16_elf_check_relocs
2834 /* So we can set bits in e_flags. */
2835 #define elf_backend_final_write_processing \
2836 _bfd_cr16_elf_final_write_processing
2837 #define elf_backend_object_p _bfd_cr16_elf_object_p
2839 #define bfd_elf32_bfd_merge_private_bfd_data \
2840 _bfd_cr16_elf_merge_private_bfd_data
2843 #define bfd_elf32_bfd_link_hash_table_create \
2844 elf32_cr16_link_hash_table_create
2846 #define elf_backend_create_dynamic_sections \
2847 _bfd_cr16_elf_create_dynamic_sections
2848 #define elf_backend_adjust_dynamic_symbol \
2849 _bfd_cr16_elf_adjust_dynamic_symbol
2850 #define elf_backend_size_dynamic_sections \
2851 _bfd_cr16_elf_size_dynamic_sections
2852 #define elf_backend_omit_section_dynsym _bfd_elf_omit_section_dynsym_all
2853 #define elf_backend_finish_dynamic_symbol \
2854 _bfd_cr16_elf_finish_dynamic_symbol
2855 #define elf_backend_finish_dynamic_sections \
2856 _bfd_cr16_elf_finish_dynamic_sections
2858 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class
2861 #define elf_backend_want_got_plt 1
2862 #define elf_backend_plt_readonly 1
2863 #define elf_backend_want_plt_sym 0
2864 #define elf_backend_got_header_size 12
2865 #define elf_backend_dtrel_excludes_plt 1
2867 #include "elf32-target.h"