1 /* BFD back-end for National Semiconductor's CR16 ELF
2 Copyright 2007, 2008, 2009, 2010, 2012 Free Software Foundation, Inc.
3 Written by M R Swami Reddy.
5 This file is part of BFD, the Binary File Descriptor library.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software Foundation,
19 Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
25 #include "libiberty.h"
29 /* The cr16 linker needs to keep track of the number of relocs that
30 it decides to copy in check_relocs for each symbol. This is so
31 that it can discard PC relative relocs if it doesn't need them when
32 linking with -Bsymbolic. We store the information in a field
33 extending the regular ELF linker hash table. */
35 struct elf32_cr16_link_hash_entry
37 /* The basic elf link hash table entry. */
38 struct elf_link_hash_entry root
;
40 /* For function symbols, the number of times this function is
41 called directly (ie by name). */
42 unsigned int direct_calls
;
44 /* For function symbols, the size of this function's stack
45 (if <= 255 bytes). We stuff this into "call" instructions
46 to this target when it's valid and profitable to do so.
48 This does not include stack allocated by movm! */
49 unsigned char stack_size
;
51 /* For function symbols, arguments (if any) for movm instruction
52 in the prologue. We stuff this value into "call" instructions
53 to the target when it's valid and profitable to do so. */
54 unsigned char movm_args
;
56 /* For function symbols, the amount of stack space that would be allocated
57 by the movm instruction. This is redundant with movm_args, but we
58 add it to the hash table to avoid computing it over and over. */
59 unsigned char movm_stack_size
;
61 /* Used to mark functions which have had redundant parts of their
63 #define CR16_DELETED_PROLOGUE_BYTES 0x1
66 /* Calculated value. */
70 /* cr16_reloc_map array maps BFD relocation enum into a CRGAS relocation type. */
74 bfd_reloc_code_real_type bfd_reloc_enum
; /* BFD relocation enum. */
75 unsigned short cr16_reloc_type
; /* CR16 relocation type. */
78 static const struct cr16_reloc_map cr16_reloc_map
[R_CR16_MAX
] =
80 {BFD_RELOC_NONE
, R_CR16_NONE
},
81 {BFD_RELOC_CR16_NUM8
, R_CR16_NUM8
},
82 {BFD_RELOC_CR16_NUM16
, R_CR16_NUM16
},
83 {BFD_RELOC_CR16_NUM32
, R_CR16_NUM32
},
84 {BFD_RELOC_CR16_NUM32a
, R_CR16_NUM32a
},
85 {BFD_RELOC_CR16_REGREL4
, R_CR16_REGREL4
},
86 {BFD_RELOC_CR16_REGREL4a
, R_CR16_REGREL4a
},
87 {BFD_RELOC_CR16_REGREL14
, R_CR16_REGREL14
},
88 {BFD_RELOC_CR16_REGREL14a
, R_CR16_REGREL14a
},
89 {BFD_RELOC_CR16_REGREL16
, R_CR16_REGREL16
},
90 {BFD_RELOC_CR16_REGREL20
, R_CR16_REGREL20
},
91 {BFD_RELOC_CR16_REGREL20a
, R_CR16_REGREL20a
},
92 {BFD_RELOC_CR16_ABS20
, R_CR16_ABS20
},
93 {BFD_RELOC_CR16_ABS24
, R_CR16_ABS24
},
94 {BFD_RELOC_CR16_IMM4
, R_CR16_IMM4
},
95 {BFD_RELOC_CR16_IMM8
, R_CR16_IMM8
},
96 {BFD_RELOC_CR16_IMM16
, R_CR16_IMM16
},
97 {BFD_RELOC_CR16_IMM20
, R_CR16_IMM20
},
98 {BFD_RELOC_CR16_IMM24
, R_CR16_IMM24
},
99 {BFD_RELOC_CR16_IMM32
, R_CR16_IMM32
},
100 {BFD_RELOC_CR16_IMM32a
, R_CR16_IMM32a
},
101 {BFD_RELOC_CR16_DISP4
, R_CR16_DISP4
},
102 {BFD_RELOC_CR16_DISP8
, R_CR16_DISP8
},
103 {BFD_RELOC_CR16_DISP16
, R_CR16_DISP16
},
104 {BFD_RELOC_CR16_DISP24
, R_CR16_DISP24
},
105 {BFD_RELOC_CR16_DISP24a
, R_CR16_DISP24a
},
106 {BFD_RELOC_CR16_SWITCH8
, R_CR16_SWITCH8
},
107 {BFD_RELOC_CR16_SWITCH16
, R_CR16_SWITCH16
},
108 {BFD_RELOC_CR16_SWITCH32
, R_CR16_SWITCH32
},
109 {BFD_RELOC_CR16_GOT_REGREL20
, R_CR16_GOT_REGREL20
},
110 {BFD_RELOC_CR16_GOTC_REGREL20
, R_CR16_GOTC_REGREL20
},
111 {BFD_RELOC_CR16_GLOB_DAT
, R_CR16_GLOB_DAT
}
114 static reloc_howto_type cr16_elf_howto_table
[] =
116 HOWTO (R_CR16_NONE
, /* type */
120 FALSE
, /* pc_relative */
122 complain_overflow_dont
, /* complain_on_overflow */
123 bfd_elf_generic_reloc
, /* special_function */
124 "R_CR16_NONE", /* name */
125 FALSE
, /* partial_inplace */
128 FALSE
), /* pcrel_offset */
130 HOWTO (R_CR16_NUM8
, /* type */
134 FALSE
, /* pc_relative */
136 complain_overflow_bitfield
,/* complain_on_overflow */
137 bfd_elf_generic_reloc
, /* special_function */
138 "R_CR16_NUM8", /* name */
139 FALSE
, /* partial_inplace */
142 FALSE
), /* pcrel_offset */
144 HOWTO (R_CR16_NUM16
, /* type */
148 FALSE
, /* pc_relative */
150 complain_overflow_bitfield
,/* complain_on_overflow */
151 bfd_elf_generic_reloc
, /* special_function */
152 "R_CR16_NUM16", /* name */
153 FALSE
, /* partial_inplace */
155 0xffff, /* dst_mask */
156 FALSE
), /* pcrel_offset */
158 HOWTO (R_CR16_NUM32
, /* type */
162 FALSE
, /* pc_relative */
164 complain_overflow_bitfield
,/* complain_on_overflow */
165 bfd_elf_generic_reloc
, /* special_function */
166 "R_CR16_NUM32", /* name */
167 FALSE
, /* partial_inplace */
169 0xffffffff, /* dst_mask */
170 FALSE
), /* pcrel_offset */
172 HOWTO (R_CR16_NUM32a
, /* type */
176 FALSE
, /* pc_relative */
178 complain_overflow_bitfield
,/* complain_on_overflow */
179 bfd_elf_generic_reloc
, /* special_function */
180 "R_CR16_NUM32a", /* name */
181 FALSE
, /* partial_inplace */
183 0xffffffff, /* dst_mask */
184 FALSE
), /* pcrel_offset */
186 HOWTO (R_CR16_REGREL4
, /* type */
190 FALSE
, /* pc_relative */
192 complain_overflow_bitfield
,/* complain_on_overflow */
193 bfd_elf_generic_reloc
, /* special_function */
194 "R_CR16_REGREL4", /* name */
195 FALSE
, /* partial_inplace */
198 FALSE
), /* pcrel_offset */
200 HOWTO (R_CR16_REGREL4a
, /* type */
204 FALSE
, /* pc_relative */
206 complain_overflow_bitfield
,/* complain_on_overflow */
207 bfd_elf_generic_reloc
, /* special_function */
208 "R_CR16_REGREL4a", /* name */
209 FALSE
, /* partial_inplace */
212 FALSE
), /* pcrel_offset */
214 HOWTO (R_CR16_REGREL14
, /* type */
218 FALSE
, /* pc_relative */
220 complain_overflow_bitfield
,/* complain_on_overflow */
221 bfd_elf_generic_reloc
, /* special_function */
222 "R_CR16_REGREL14", /* name */
223 FALSE
, /* partial_inplace */
225 0x3fff, /* dst_mask */
226 FALSE
), /* pcrel_offset */
228 HOWTO (R_CR16_REGREL14a
, /* type */
232 FALSE
, /* pc_relative */
234 complain_overflow_bitfield
,/* complain_on_overflow */
235 bfd_elf_generic_reloc
, /* special_function */
236 "R_CR16_REGREL14a", /* name */
237 FALSE
, /* partial_inplace */
239 0x3fff, /* dst_mask */
240 FALSE
), /* pcrel_offset */
242 HOWTO (R_CR16_REGREL16
, /* type */
246 FALSE
, /* pc_relative */
248 complain_overflow_bitfield
,/* complain_on_overflow */
249 bfd_elf_generic_reloc
, /* special_function */
250 "R_CR16_REGREL16", /* name */
251 FALSE
, /* partial_inplace */
253 0xffff, /* dst_mask */
254 FALSE
), /* pcrel_offset */
256 HOWTO (R_CR16_REGREL20
, /* type */
260 FALSE
, /* pc_relative */
262 complain_overflow_bitfield
,/* complain_on_overflow */
263 bfd_elf_generic_reloc
, /* special_function */
264 "R_CR16_REGREL20", /* name */
265 FALSE
, /* partial_inplace */
267 0xfffff, /* dst_mask */
268 FALSE
), /* pcrel_offset */
270 HOWTO (R_CR16_REGREL20a
, /* type */
274 FALSE
, /* pc_relative */
276 complain_overflow_bitfield
,/* complain_on_overflow */
277 bfd_elf_generic_reloc
, /* special_function */
278 "R_CR16_REGREL20a", /* name */
279 FALSE
, /* partial_inplace */
281 0xfffff, /* dst_mask */
282 FALSE
), /* pcrel_offset */
284 HOWTO (R_CR16_ABS20
, /* type */
288 FALSE
, /* pc_relative */
290 complain_overflow_bitfield
,/* complain_on_overflow */
291 bfd_elf_generic_reloc
, /* special_function */
292 "R_CR16_ABS20", /* name */
293 FALSE
, /* partial_inplace */
295 0xfffff, /* dst_mask */
296 FALSE
), /* pcrel_offset */
298 HOWTO (R_CR16_ABS24
, /* type */
302 FALSE
, /* pc_relative */
304 complain_overflow_bitfield
,/* complain_on_overflow */
305 bfd_elf_generic_reloc
, /* special_function */
306 "R_CR16_ABS24", /* name */
307 FALSE
, /* partial_inplace */
309 0xffffff, /* dst_mask */
310 FALSE
), /* pcrel_offset */
312 HOWTO (R_CR16_IMM4
, /* type */
316 FALSE
, /* pc_relative */
318 complain_overflow_bitfield
,/* complain_on_overflow */
319 bfd_elf_generic_reloc
, /* special_function */
320 "R_CR16_IMM4", /* name */
321 FALSE
, /* partial_inplace */
324 FALSE
), /* pcrel_offset */
326 HOWTO (R_CR16_IMM8
, /* type */
330 FALSE
, /* pc_relative */
332 complain_overflow_bitfield
,/* complain_on_overflow */
333 bfd_elf_generic_reloc
, /* special_function */
334 "R_CR16_IMM8", /* name */
335 FALSE
, /* partial_inplace */
338 FALSE
), /* pcrel_offset */
340 HOWTO (R_CR16_IMM16
, /* type */
344 FALSE
, /* pc_relative */
346 complain_overflow_bitfield
,/* complain_on_overflow */
347 bfd_elf_generic_reloc
, /* special_function */
348 "R_CR16_IMM16", /* name */
349 FALSE
, /* partial_inplace */
351 0xffff, /* dst_mask */
352 FALSE
), /* pcrel_offset */
354 HOWTO (R_CR16_IMM20
, /* type */
358 FALSE
, /* pc_relative */
360 complain_overflow_bitfield
,/* complain_on_overflow */
361 bfd_elf_generic_reloc
, /* special_function */
362 "R_CR16_IMM20", /* name */
363 FALSE
, /* partial_inplace */
365 0xfffff, /* dst_mask */
366 FALSE
), /* pcrel_offset */
368 HOWTO (R_CR16_IMM24
, /* type */
372 FALSE
, /* pc_relative */
374 complain_overflow_bitfield
,/* complain_on_overflow */
375 bfd_elf_generic_reloc
, /* special_function */
376 "R_CR16_IMM24", /* name */
377 FALSE
, /* partial_inplace */
379 0xffffff, /* dst_mask */
380 FALSE
), /* pcrel_offset */
382 HOWTO (R_CR16_IMM32
, /* type */
386 FALSE
, /* pc_relative */
388 complain_overflow_bitfield
,/* complain_on_overflow */
389 bfd_elf_generic_reloc
, /* special_function */
390 "R_CR16_IMM32", /* name */
391 FALSE
, /* partial_inplace */
393 0xffffffff, /* dst_mask */
394 FALSE
), /* pcrel_offset */
396 HOWTO (R_CR16_IMM32a
, /* type */
400 FALSE
, /* pc_relative */
402 complain_overflow_bitfield
,/* complain_on_overflow */
403 bfd_elf_generic_reloc
, /* special_function */
404 "R_CR16_IMM32a", /* name */
405 FALSE
, /* partial_inplace */
407 0xffffffff, /* dst_mask */
408 FALSE
), /* pcrel_offset */
410 HOWTO (R_CR16_DISP4
, /* type */
412 0, /* size (0 = byte, 1 = short, 2 = long) */
414 TRUE
, /* pc_relative */
416 complain_overflow_unsigned
, /* complain_on_overflow */
417 bfd_elf_generic_reloc
, /* special_function */
418 "R_CR16_DISP4", /* name */
419 FALSE
, /* partial_inplace */
422 FALSE
), /* pcrel_offset */
424 HOWTO (R_CR16_DISP8
, /* type */
426 0, /* size (0 = byte, 1 = short, 2 = long) */
428 TRUE
, /* pc_relative */
430 complain_overflow_unsigned
, /* complain_on_overflow */
431 bfd_elf_generic_reloc
, /* special_function */
432 "R_CR16_DISP8", /* name */
433 FALSE
, /* partial_inplace */
435 0x1ff, /* dst_mask */
436 FALSE
), /* pcrel_offset */
438 HOWTO (R_CR16_DISP16
, /* type */
439 0, /* rightshift REVIITS: To sync with WinIDEA*/
440 1, /* size (0 = byte, 1 = short, 2 = long) */
442 TRUE
, /* pc_relative */
444 complain_overflow_unsigned
, /* complain_on_overflow */
445 bfd_elf_generic_reloc
, /* special_function */
446 "R_CR16_DISP16", /* name */
447 FALSE
, /* partial_inplace */
449 0x1ffff, /* dst_mask */
450 FALSE
), /* pcrel_offset */
451 /* REVISIT: DISP24 should be left-shift by 2 as per ISA doc
452 but its not done, to sync with WinIDEA and CR16 4.1 tools */
453 HOWTO (R_CR16_DISP24
, /* type */
455 2, /* size (0 = byte, 1 = short, 2 = long) */
457 TRUE
, /* pc_relative */
459 complain_overflow_unsigned
, /* complain_on_overflow */
460 bfd_elf_generic_reloc
, /* special_function */
461 "R_CR16_DISP24", /* name */
462 FALSE
, /* partial_inplace */
464 0x1ffffff, /* dst_mask */
465 FALSE
), /* pcrel_offset */
467 HOWTO (R_CR16_DISP24a
, /* type */
469 2, /* size (0 = byte, 1 = short, 2 = long) */
471 TRUE
, /* pc_relative */
473 complain_overflow_unsigned
, /* complain_on_overflow */
474 bfd_elf_generic_reloc
, /* special_function */
475 "R_CR16_DISP24a", /* name */
476 FALSE
, /* partial_inplace */
478 0xffffff, /* dst_mask */
479 FALSE
), /* pcrel_offset */
481 /* An 8 bit switch table entry. This is generated for an expression
482 such as ``.byte L1 - L2''. The offset holds the difference
483 between the reloc address and L2. */
484 HOWTO (R_CR16_SWITCH8
, /* type */
486 0, /* size (0 = byte, 1 = short, 2 = long) */
488 FALSE
, /* pc_relative */
490 complain_overflow_unsigned
, /* complain_on_overflow */
491 bfd_elf_generic_reloc
, /* special_function */
492 "R_CR16_SWITCH8", /* name */
493 FALSE
, /* partial_inplace */
496 TRUE
), /* pcrel_offset */
498 /* A 16 bit switch table entry. This is generated for an expression
499 such as ``.word L1 - L2''. The offset holds the difference
500 between the reloc address and L2. */
501 HOWTO (R_CR16_SWITCH16
, /* type */
503 1, /* size (0 = byte, 1 = short, 2 = long) */
505 FALSE
, /* pc_relative */
507 complain_overflow_unsigned
, /* complain_on_overflow */
508 bfd_elf_generic_reloc
, /* special_function */
509 "R_CR16_SWITCH16", /* name */
510 FALSE
, /* partial_inplace */
512 0xffff, /* dst_mask */
513 TRUE
), /* pcrel_offset */
515 /* A 32 bit switch table entry. This is generated for an expression
516 such as ``.long L1 - L2''. The offset holds the difference
517 between the reloc address and L2. */
518 HOWTO (R_CR16_SWITCH32
, /* type */
520 2, /* size (0 = byte, 1 = short, 2 = long) */
522 FALSE
, /* pc_relative */
524 complain_overflow_unsigned
, /* complain_on_overflow */
525 bfd_elf_generic_reloc
, /* special_function */
526 "R_CR16_SWITCH32", /* name */
527 FALSE
, /* partial_inplace */
529 0xffffffff, /* dst_mask */
530 TRUE
), /* pcrel_offset */
532 HOWTO (R_CR16_GOT_REGREL20
, /* type */
536 FALSE
, /* pc_relative */
538 complain_overflow_bitfield
,/* complain_on_overflow */
539 bfd_elf_generic_reloc
, /* special_function */
540 "R_CR16_GOT_REGREL20", /* name */
541 TRUE
, /* partial_inplace */
543 0xfffff, /* dst_mask */
544 FALSE
), /* pcrel_offset */
546 HOWTO (R_CR16_GOTC_REGREL20
, /* type */
550 FALSE
, /* pc_relative */
552 complain_overflow_bitfield
,/* complain_on_overflow */
553 bfd_elf_generic_reloc
, /* special_function */
554 "R_CR16_GOTC_REGREL20", /* name */
555 TRUE
, /* partial_inplace */
557 0xfffff, /* dst_mask */
558 FALSE
), /* pcrel_offset */
560 HOWTO (R_CR16_GLOB_DAT
, /* type */
562 2, /* size (0 = byte, 1 = short, 2 = long) */
564 FALSE
, /* pc_relative */
566 complain_overflow_unsigned
, /* complain_on_overflow */
567 bfd_elf_generic_reloc
, /* special_function */
568 "R_CR16_GLOB_DAT", /* name */
569 FALSE
, /* partial_inplace */
571 0xffffffff, /* dst_mask */
572 TRUE
) /* pcrel_offset */
576 /* Create the GOT section. */
579 _bfd_cr16_elf_create_got_section (bfd
* abfd
, struct bfd_link_info
* info
)
583 struct elf_link_hash_entry
* h
;
584 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
587 /* This function may be called more than once. */
588 if (bfd_get_linker_section (abfd
, ".got") != NULL
)
591 switch (bed
->s
->arch_size
)
602 bfd_set_error (bfd_error_bad_value
);
606 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
607 | SEC_LINKER_CREATED
);
609 s
= bfd_make_section_anyway_with_flags (abfd
, ".got", flags
);
611 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
614 if (bed
->want_got_plt
)
616 s
= bfd_make_section_anyway_with_flags (abfd
, ".got.plt", flags
);
618 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
622 /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
623 (or .got.plt) section. We don't do this in the linker script
624 because we don't want to define the symbol if we are not creating
625 a global offset table. */
626 h
= _bfd_elf_define_linkage_sym (abfd
, info
, s
, "_GLOBAL_OFFSET_TABLE_");
627 elf_hash_table (info
)->hgot
= h
;
631 /* The first bit of the global offset table is the header. */
632 s
->size
+= bed
->got_header_size
;
638 /* Retrieve a howto ptr using a BFD reloc_code. */
640 static reloc_howto_type
*
641 elf_cr16_reloc_type_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
642 bfd_reloc_code_real_type code
)
646 for (i
= 0; i
< R_CR16_MAX
; i
++)
647 if (code
== cr16_reloc_map
[i
].bfd_reloc_enum
)
648 return &cr16_elf_howto_table
[cr16_reloc_map
[i
].cr16_reloc_type
];
650 _bfd_error_handler ("Unsupported CR16 relocation type: 0x%x\n", code
);
654 static reloc_howto_type
*
655 elf_cr16_reloc_name_lookup (bfd
*abfd ATTRIBUTE_UNUSED
,
660 for (i
= 0; ARRAY_SIZE (cr16_elf_howto_table
); i
++)
661 if (cr16_elf_howto_table
[i
].name
!= NULL
662 && strcasecmp (cr16_elf_howto_table
[i
].name
, r_name
) == 0)
663 return cr16_elf_howto_table
+ i
;
668 /* Retrieve a howto ptr using an internal relocation entry. */
671 elf_cr16_info_to_howto (bfd
*abfd ATTRIBUTE_UNUSED
, arelent
*cache_ptr
,
672 Elf_Internal_Rela
*dst
)
674 unsigned int r_type
= ELF32_R_TYPE (dst
->r_info
);
676 BFD_ASSERT (r_type
< (unsigned int) R_CR16_MAX
);
677 cache_ptr
->howto
= cr16_elf_howto_table
+ r_type
;
680 /* Look through the relocs for a section during the first phase.
681 Since we don't do .gots or .plts, we just need to consider the
682 virtual table relocs for gc. */
685 cr16_elf_check_relocs (bfd
*abfd
, struct bfd_link_info
*info
, asection
*sec
,
686 const Elf_Internal_Rela
*relocs
)
688 Elf_Internal_Shdr
*symtab_hdr
;
689 Elf_Internal_Sym
* isymbuf
= NULL
;
690 struct elf_link_hash_entry
**sym_hashes
, **sym_hashes_end
;
691 const Elf_Internal_Rela
*rel
;
692 const Elf_Internal_Rela
*rel_end
;
694 bfd_vma
* local_got_offsets
;
700 bfd_boolean result
= FALSE
;
702 if (info
->relocatable
)
705 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
706 sym_hashes
= elf_sym_hashes (abfd
);
707 sym_hashes_end
= sym_hashes
+ symtab_hdr
->sh_size
/sizeof (Elf32_External_Sym
);
708 if (!elf_bad_symtab (abfd
))
709 sym_hashes_end
-= symtab_hdr
->sh_info
;
711 dynobj
= elf_hash_table (info
)->dynobj
;
712 local_got_offsets
= elf_local_got_offsets (abfd
);
713 rel_end
= relocs
+ sec
->reloc_count
;
714 for (rel
= relocs
; rel
< rel_end
; rel
++)
716 struct elf_link_hash_entry
*h
;
717 unsigned long r_symndx
;
719 r_symndx
= ELF32_R_SYM (rel
->r_info
);
720 if (r_symndx
< symtab_hdr
->sh_info
)
724 h
= sym_hashes
[r_symndx
- symtab_hdr
->sh_info
];
725 while (h
->root
.type
== bfd_link_hash_indirect
726 || h
->root
.type
== bfd_link_hash_warning
)
727 h
= (struct elf_link_hash_entry
*) h
->root
.u
.i
.link
;
730 /* Some relocs require a global offset table. */
733 switch (ELF32_R_TYPE (rel
->r_info
))
735 case R_CR16_GOT_REGREL20
:
736 case R_CR16_GOTC_REGREL20
:
737 elf_hash_table (info
)->dynobj
= dynobj
= abfd
;
738 if (! _bfd_cr16_elf_create_got_section (dynobj
, info
))
747 switch (ELF32_R_TYPE (rel
->r_info
))
749 case R_CR16_GOT_REGREL20
:
750 case R_CR16_GOTC_REGREL20
:
751 /* This symbol requires a global offset table entry. */
755 sgot
= bfd_get_linker_section (dynobj
, ".got");
756 BFD_ASSERT (sgot
!= NULL
);
760 && (h
!= NULL
|| info
->executable
))
762 srelgot
= bfd_get_linker_section (dynobj
, ".rela.got");
765 flagword flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
766 | SEC_IN_MEMORY
| SEC_LINKER_CREATED
768 srelgot
= bfd_make_section_anyway_with_flags (dynobj
,
772 || ! bfd_set_section_alignment (dynobj
, srelgot
, 2))
779 if (h
->got
.offset
!= (bfd_vma
) -1)
780 /* We have already allocated space in the .got. */
783 h
->got
.offset
= sgot
->size
;
785 /* Make sure this symbol is output as a dynamic symbol. */
786 if (h
->dynindx
== -1)
788 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
792 srelgot
->size
+= sizeof (Elf32_External_Rela
);
796 /* This is a global offset table entry for a local
798 if (local_got_offsets
== NULL
)
803 size
= symtab_hdr
->sh_info
* sizeof (bfd_vma
);
804 local_got_offsets
= (bfd_vma
*) bfd_alloc (abfd
, size
);
806 if (local_got_offsets
== NULL
)
809 elf_local_got_offsets (abfd
) = local_got_offsets
;
811 for (i
= 0; i
< symtab_hdr
->sh_info
; i
++)
812 local_got_offsets
[i
] = (bfd_vma
) -1;
815 if (local_got_offsets
[r_symndx
] != (bfd_vma
) -1)
816 /* We have already allocated space in the .got. */
819 local_got_offsets
[r_symndx
] = sgot
->size
;
821 if (info
->executable
)
822 /* If we are generating a shared object, we need to
823 output a R_CR16_RELATIVE reloc so that the dynamic
824 linker can adjust this GOT entry. */
825 srelgot
->size
+= sizeof (Elf32_External_Rela
);
842 /* Perform a relocation as part of a final link. */
844 static bfd_reloc_status_type
845 cr16_elf_final_link_relocate (reloc_howto_type
*howto
,
847 bfd
*output_bfd ATTRIBUTE_UNUSED
,
848 asection
*input_section
,
853 struct elf_link_hash_entry
* h
,
854 unsigned long symndx ATTRIBUTE_UNUSED
,
855 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
856 asection
*sec ATTRIBUTE_UNUSED
,
857 int is_local ATTRIBUTE_UNUSED
)
859 unsigned short r_type
= howto
->type
;
860 bfd_byte
*hit_data
= contents
+ offset
;
861 bfd_vma reloc_bits
, check
, Rvalue1
;
864 dynobj
= elf_hash_table (info
)->dynobj
;
878 case R_CR16_REGREL4a
:
879 case R_CR16_REGREL14
:
880 case R_CR16_REGREL14a
:
881 case R_CR16_REGREL16
:
882 case R_CR16_REGREL20
:
883 case R_CR16_REGREL20a
:
884 case R_CR16_GOT_REGREL20
:
885 case R_CR16_GOTC_REGREL20
:
889 /* 'hit_data' is relative to the start of the instruction, not the
890 relocation offset. Advance it to account for the exact offset. */
910 case R_CR16_SWITCH16
:
911 case R_CR16_SWITCH32
:
912 /* We only care about the addend, where the difference between
913 expressions is kept. */
920 if (howto
->pc_relative
)
922 /* Subtract the address of the section containing the location. */
923 Rvalue
-= (input_section
->output_section
->vma
924 + input_section
->output_offset
);
925 /* Subtract the position of the location within the section. */
929 /* Add in supplied addend. */
932 /* Complain if the bitfield overflows, whether it is considered
933 as signed or unsigned. */
934 check
= Rvalue
>> howto
->rightshift
;
936 /* Assumes two's complement. This expression avoids
937 overflow if howto->bitsize is the number of bits in
939 reloc_bits
= (((1 << (howto
->bitsize
- 1)) - 1) << 1) | 1;
941 /* For GOT and GOTC relocs no boundary checks applied. */
942 if (!((r_type
== R_CR16_GOT_REGREL20
)
943 || (r_type
== R_CR16_GOTC_REGREL20
)))
945 if (((bfd_vma
) check
& ~reloc_bits
) != 0
946 && (((bfd_vma
) check
& ~reloc_bits
)
947 != (-(bfd_vma
) 1 & ~reloc_bits
)))
949 /* The above right shift is incorrect for a signed
950 value. See if turning on the upper bits fixes the
952 if (howto
->rightshift
&& (bfd_signed_vma
) Rvalue
< 0)
954 check
|= ((bfd_vma
) - 1
956 >> howto
->rightshift
));
958 if (((bfd_vma
) check
& ~reloc_bits
)
959 != (-(bfd_vma
) 1 & ~reloc_bits
))
960 return bfd_reloc_overflow
;
963 return bfd_reloc_overflow
;
966 /* Drop unwanted bits from the value we are relocating to. */
967 Rvalue
>>= (bfd_vma
) howto
->rightshift
;
969 /* Apply dst_mask to select only relocatable part of the insn. */
970 Rvalue
&= howto
->dst_mask
;
976 if (r_type
== R_CR16_DISP8
)
978 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
979 Rvalue
= ((Rvalue1
& 0xf000) | ((Rvalue
<< 4) & 0xf00)
980 | (Rvalue1
& 0x00f0) | (Rvalue
& 0xf));
981 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
983 else if (r_type
== R_CR16_IMM4
)
985 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
986 Rvalue
= (((Rvalue1
& 0xff) << 8) | ((Rvalue
<< 4) & 0xf0)
987 | ((Rvalue1
& 0x0f00) >> 8));
988 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
990 else if (r_type
== R_CR16_DISP4
)
992 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
993 Rvalue
= (Rvalue1
| ((Rvalue
& 0xf) << 4));
994 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
998 bfd_put_8 (input_bfd
, (unsigned char) Rvalue
, hit_data
);
1003 if (r_type
== R_CR16_DISP16
)
1005 Rvalue
|= (bfd_get_16 (input_bfd
, hit_data
));
1006 Rvalue
= ((Rvalue
& 0xfffe) | ((Rvalue
>> 16) & 0x1));
1008 if (r_type
== R_CR16_IMM16
)
1010 Rvalue1
= bfd_get_16 (input_bfd
, hit_data
);
1012 /* Add or subtract the offset value. */
1013 if (Rvalue1
& 0x8000)
1014 Rvalue
-= (~Rvalue1
+ 1) & 0xffff;
1018 /* Check for range. */
1019 if ((long) Rvalue
> 0xffff || (long) Rvalue
< 0x0)
1020 return bfd_reloc_overflow
;
1023 bfd_put_16 (input_bfd
, Rvalue
, hit_data
);
1027 if ((r_type
== R_CR16_ABS20
) || (r_type
== R_CR16_IMM20
))
1029 Rvalue1
= (bfd_get_16 (input_bfd
, hit_data
+ 2)
1030 | (((bfd_get_16 (input_bfd
, hit_data
) & 0xf) <<16)));
1032 /* Add or subtract the offset value. */
1033 if (Rvalue1
& 0x80000)
1034 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1038 /* Check for range. */
1039 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1040 return bfd_reloc_overflow
;
1042 bfd_put_16 (input_bfd
, ((bfd_get_16 (input_bfd
, hit_data
) & 0xfff0)
1043 | ((Rvalue
>> 16) & 0xf)), hit_data
);
1044 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1046 else if (r_type
== R_CR16_GOT_REGREL20
)
1048 asection
* sgot
= bfd_get_linker_section (dynobj
, ".got");
1054 off
= h
->got
.offset
;
1055 BFD_ASSERT (off
!= (bfd_vma
) -1);
1057 if (! elf_hash_table (info
)->dynamic_sections_created
1058 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1059 /* This is actually a static link, or it is a
1060 -Bsymbolic link and the symbol is defined
1061 locally, or the symbol was forced to be local
1062 because of a version file. We must initialize
1063 this entry in the global offset table.
1064 When doing a dynamic link, we create a .rela.got
1065 relocation entry to initialize the value. This
1066 is done in the finish_dynamic_symbol routine. */
1067 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1069 Rvalue
= sgot
->output_offset
+ off
;
1075 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1076 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1078 Rvalue
= sgot
->output_offset
+ off
;
1083 /* REVISIT: if ((long) Rvalue > 0xffffff ||
1084 (long) Rvalue < -0x800000). */
1085 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1086 return bfd_reloc_overflow
;
1089 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1090 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1091 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1094 else if (r_type
== R_CR16_GOTC_REGREL20
)
1097 sgot
= bfd_get_linker_section (dynobj
, ".got");
1103 off
= h
->got
.offset
;
1104 BFD_ASSERT (off
!= (bfd_vma
) -1);
1106 Rvalue
>>=1; /* For code symbols. */
1108 if (! elf_hash_table (info
)->dynamic_sections_created
1109 || SYMBOL_REFERENCES_LOCAL (info
, h
))
1110 /* This is actually a static link, or it is a
1111 -Bsymbolic link and the symbol is defined
1112 locally, or the symbol was forced to be local
1113 because of a version file. We must initialize
1114 this entry in the global offset table.
1115 When doing a dynamic link, we create a .rela.got
1116 relocation entry to initialize the value. This
1117 is done in the finish_dynamic_symbol routine. */
1118 bfd_put_32 (output_bfd
, Rvalue
, sgot
->contents
+ off
);
1120 Rvalue
= sgot
->output_offset
+ off
;
1126 off
= elf_local_got_offsets (input_bfd
)[symndx
];
1128 bfd_put_32 (output_bfd
,Rvalue
, sgot
->contents
+ off
);
1129 Rvalue
= sgot
->output_offset
+ off
;
1134 /* Check if any value in DISP. */
1135 Rvalue1
=((bfd_get_32 (input_bfd
, hit_data
) >>16)
1136 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1138 /* Add or subtract the offset value. */
1139 if (Rvalue1
& 0x80000)
1140 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1144 /* Check for range. */
1145 /* REVISIT: if ((long) Rvalue > 0xffffff
1146 || (long) Rvalue < -0x800000). */
1147 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0)
1148 return bfd_reloc_overflow
;
1150 bfd_put_16 (input_bfd
, (bfd_get_16 (input_bfd
, hit_data
))
1151 | (((Rvalue
>> 16) & 0xf) << 8), hit_data
);
1152 bfd_put_16 (input_bfd
, (Rvalue
) & 0xffff, hit_data
+ 2);
1156 if (r_type
== R_CR16_ABS24
)
1158 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1159 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16)
1160 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xf) <<20)));
1162 /* Add or subtract the offset value. */
1163 if (Rvalue1
& 0x800000)
1164 Rvalue
-= (~Rvalue1
+ 1) & 0xffffff;
1168 /* Check for Range. */
1169 if ((long) Rvalue
> 0xffffff || (long) Rvalue
< 0x0)
1170 return bfd_reloc_overflow
;
1172 Rvalue
= ((((Rvalue
>> 20) & 0xf) | (((Rvalue
>> 16) & 0xf)<<8)
1173 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0f0))
1174 | ((Rvalue
& 0xffff) << 16));
1176 else if (r_type
== R_CR16_DISP24
)
1178 Rvalue
= ((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1179 | (bfd_get_16 (input_bfd
, hit_data
)))
1180 | (((Rvalue
& 0xfffe) | ((Rvalue
>> 24) & 0x1)) << 16));
1182 else if ((r_type
== R_CR16_IMM32
) || (r_type
== R_CR16_IMM32a
))
1184 Rvalue1
=((((bfd_get_32 (input_bfd
, hit_data
)) >> 16) &0xffff)
1185 | (((bfd_get_32 (input_bfd
, hit_data
)) &0xffff)) << 16);
1187 /* Add or subtract the offset value. */
1188 if (Rvalue1
& 0x80000000)
1189 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1193 /* Check for range. */
1194 if (Rvalue
> 0xffffffff || (long) Rvalue
< 0x0)
1195 return bfd_reloc_overflow
;
1197 Rvalue
= (((Rvalue
>> 16)& 0xffff) | (Rvalue
& 0xffff) << 16);
1199 else if (r_type
== R_CR16_DISP24a
)
1201 Rvalue
= (((Rvalue
& 0xfffffe) | (Rvalue
>> 23)));
1202 Rvalue
= ((Rvalue
>> 16) & 0xff) | ((Rvalue
& 0xffff) << 16)
1203 | (bfd_get_32 (input_bfd
, hit_data
));
1205 else if ((r_type
== R_CR16_REGREL20
)
1206 || (r_type
== R_CR16_REGREL20a
))
1208 Rvalue1
= ((bfd_get_32 (input_bfd
, hit_data
) >> 16)
1209 | (((bfd_get_32 (input_bfd
, hit_data
) & 0xfff) >> 8) <<16));
1210 /* Add or subtract the offset value. */
1211 if (Rvalue1
& 0x80000)
1212 Rvalue
-= (~Rvalue1
+ 1) & 0xfffff;
1216 /* Check for range. */
1217 if ((long) Rvalue
> 0xfffff || (long) Rvalue
< 0x0)
1218 return bfd_reloc_overflow
;
1220 Rvalue
= (((((Rvalue
>> 20)& 0xf) | (((Rvalue
>>16) & 0xf)<<8)
1221 | ((Rvalue
& 0xffff) << 16)))
1222 | (bfd_get_32 (input_bfd
, hit_data
) & 0xf0ff));
1225 else if (r_type
== R_CR16_NUM32
)
1227 Rvalue1
= (bfd_get_32 (input_bfd
, hit_data
));
1229 /* Add or subtract the offset value */
1230 if (Rvalue1
& 0x80000000)
1231 Rvalue
-= (~Rvalue1
+ 1) & 0xffffffff;
1235 /* Check for Ranga */
1236 if (Rvalue
> 0xffffffff)
1237 return bfd_reloc_overflow
;
1240 bfd_put_32 (input_bfd
, Rvalue
, hit_data
);
1245 return bfd_reloc_notsupported
;
1248 return bfd_reloc_ok
;
1251 /* Delete some bytes from a section while relaxing. */
1254 elf32_cr16_relax_delete_bytes (struct bfd_link_info
*link_info
, bfd
*abfd
,
1255 asection
*sec
, bfd_vma addr
, int count
)
1257 Elf_Internal_Shdr
*symtab_hdr
;
1258 unsigned int sec_shndx
;
1260 Elf_Internal_Rela
*irel
, *irelend
;
1262 Elf_Internal_Sym
*isym
;
1263 Elf_Internal_Sym
*isymend
;
1264 struct elf_link_hash_entry
**sym_hashes
;
1265 struct elf_link_hash_entry
**end_hashes
;
1266 struct elf_link_hash_entry
**start_hashes
;
1267 unsigned int symcount
;
1269 sec_shndx
= _bfd_elf_section_from_bfd_section (abfd
, sec
);
1271 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1275 irel
= elf_section_data (sec
)->relocs
;
1276 irelend
= irel
+ sec
->reloc_count
;
1278 /* Actually delete the bytes. */
1279 memmove (contents
+ addr
, contents
+ addr
+ count
,
1280 (size_t) (toaddr
- addr
- count
));
1283 /* Adjust all the relocs. */
1284 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1285 /* Get the new reloc address. */
1286 if ((irel
->r_offset
> addr
&& irel
->r_offset
< toaddr
))
1287 irel
->r_offset
-= count
;
1289 /* Adjust the local symbols defined in this section. */
1290 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1291 isym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1292 for (isymend
= isym
+ symtab_hdr
->sh_info
; isym
< isymend
; isym
++)
1294 if (isym
->st_shndx
== sec_shndx
1295 && isym
->st_value
> addr
1296 && isym
->st_value
< toaddr
)
1298 /* Adjust the addend of SWITCH relocations in this section,
1299 which reference this local symbol. */
1301 for (irel
= elf_section_data (sec
)->relocs
; irel
< irelend
; irel
++)
1303 unsigned long r_symndx
;
1304 Elf_Internal_Sym
*rsym
;
1305 bfd_vma addsym
, subsym
;
1307 /* Skip if not a SWITCH relocation. */
1308 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH8
1309 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH16
1310 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_SWITCH32
)
1313 r_symndx
= ELF32_R_SYM (irel
->r_info
);
1314 rsym
= (Elf_Internal_Sym
*) symtab_hdr
->contents
+ r_symndx
;
1316 /* Skip if not the local adjusted symbol. */
1320 addsym
= isym
->st_value
;
1321 subsym
= addsym
- irel
->r_addend
;
1323 /* Fix the addend only when -->> (addsym > addr >= subsym). */
1325 irel
->r_addend
-= count
;
1331 isym
->st_value
-= count
;
1335 /* Now adjust the global symbols defined in this section. */
1336 symcount
= (symtab_hdr
->sh_size
/ sizeof (Elf32_External_Sym
)
1337 - symtab_hdr
->sh_info
);
1338 sym_hashes
= start_hashes
= elf_sym_hashes (abfd
);
1339 end_hashes
= sym_hashes
+ symcount
;
1341 for (; sym_hashes
< end_hashes
; sym_hashes
++)
1343 struct elf_link_hash_entry
*sym_hash
= *sym_hashes
;
1345 /* The '--wrap SYMBOL' option is causing a pain when the object file,
1346 containing the definition of __wrap_SYMBOL, includes a direct
1347 call to SYMBOL as well. Since both __wrap_SYMBOL and SYMBOL reference
1348 the same symbol (which is __wrap_SYMBOL), but still exist as two
1349 different symbols in 'sym_hashes', we don't want to adjust
1350 the global symbol __wrap_SYMBOL twice.
1351 This check is only relevant when symbols are being wrapped. */
1352 if (link_info
->wrap_hash
!= NULL
)
1354 struct elf_link_hash_entry
**cur_sym_hashes
;
1356 /* Loop only over the symbols whom been already checked. */
1357 for (cur_sym_hashes
= start_hashes
; cur_sym_hashes
< sym_hashes
;
1359 /* If the current symbol is identical to 'sym_hash', that means
1360 the symbol was already adjusted (or at least checked). */
1361 if (*cur_sym_hashes
== sym_hash
)
1364 /* Don't adjust the symbol again. */
1365 if (cur_sym_hashes
< sym_hashes
)
1369 if ((sym_hash
->root
.type
== bfd_link_hash_defined
1370 || sym_hash
->root
.type
== bfd_link_hash_defweak
)
1371 && sym_hash
->root
.u
.def
.section
== sec
1372 && sym_hash
->root
.u
.def
.value
> addr
1373 && sym_hash
->root
.u
.def
.value
< toaddr
)
1374 sym_hash
->root
.u
.def
.value
-= count
;
1380 /* Relocate a CR16 ELF section. */
1383 elf32_cr16_relocate_section (bfd
*output_bfd
, struct bfd_link_info
*info
,
1384 bfd
*input_bfd
, asection
*input_section
,
1385 bfd_byte
*contents
, Elf_Internal_Rela
*relocs
,
1386 Elf_Internal_Sym
*local_syms
,
1387 asection
**local_sections
)
1389 Elf_Internal_Shdr
*symtab_hdr
;
1390 struct elf_link_hash_entry
**sym_hashes
;
1391 Elf_Internal_Rela
*rel
, *relend
;
1393 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1394 sym_hashes
= elf_sym_hashes (input_bfd
);
1397 relend
= relocs
+ input_section
->reloc_count
;
1398 for (; rel
< relend
; rel
++)
1401 reloc_howto_type
*howto
;
1402 unsigned long r_symndx
;
1403 Elf_Internal_Sym
*sym
;
1405 struct elf_link_hash_entry
*h
;
1407 bfd_reloc_status_type r
;
1409 r_symndx
= ELF32_R_SYM (rel
->r_info
);
1410 r_type
= ELF32_R_TYPE (rel
->r_info
);
1411 howto
= cr16_elf_howto_table
+ (r_type
);
1416 if (r_symndx
< symtab_hdr
->sh_info
)
1418 sym
= local_syms
+ r_symndx
;
1419 sec
= local_sections
[r_symndx
];
1420 relocation
= _bfd_elf_rela_local_sym (output_bfd
, sym
, &sec
, rel
);
1424 bfd_boolean unresolved_reloc
, warned
;
1426 RELOC_FOR_GLOBAL_SYMBOL (info
, input_bfd
, input_section
, rel
,
1427 r_symndx
, symtab_hdr
, sym_hashes
,
1429 unresolved_reloc
, warned
);
1432 if (sec
!= NULL
&& discarded_section (sec
))
1433 RELOC_AGAINST_DISCARDED_SECTION (info
, input_bfd
, input_section
,
1434 rel
, 1, relend
, howto
, 0, contents
);
1436 if (info
->relocatable
)
1439 r
= cr16_elf_final_link_relocate (howto
, input_bfd
, output_bfd
,
1441 contents
, rel
->r_offset
,
1442 relocation
, rel
->r_addend
,
1443 (struct elf_link_hash_entry
*) h
,
1445 info
, sec
, h
== NULL
);
1447 if (r
!= bfd_reloc_ok
)
1450 const char *msg
= NULL
;
1453 name
= h
->root
.root
.string
;
1456 name
= (bfd_elf_string_from_elf_section
1457 (input_bfd
, symtab_hdr
->sh_link
, sym
->st_name
));
1458 if (name
== NULL
|| *name
== '\0')
1459 name
= bfd_section_name (input_bfd
, sec
);
1464 case bfd_reloc_overflow
:
1465 if (!((*info
->callbacks
->reloc_overflow
)
1466 (info
, (h
? &h
->root
: NULL
), name
, howto
->name
,
1467 (bfd_vma
) 0, input_bfd
, input_section
,
1472 case bfd_reloc_undefined
:
1473 if (!((*info
->callbacks
->undefined_symbol
)
1474 (info
, name
, input_bfd
, input_section
,
1475 rel
->r_offset
, TRUE
)))
1479 case bfd_reloc_outofrange
:
1480 msg
= _("internal error: out of range error");
1483 case bfd_reloc_notsupported
:
1484 msg
= _("internal error: unsupported relocation error");
1487 case bfd_reloc_dangerous
:
1488 msg
= _("internal error: dangerous error");
1492 msg
= _("internal error: unknown error");
1496 if (!((*info
->callbacks
->warning
)
1497 (info
, msg
, name
, input_bfd
, input_section
,
1508 /* This is a version of bfd_generic_get_relocated_section_contents
1509 which uses elf32_cr16_relocate_section. */
1512 elf32_cr16_get_relocated_section_contents (bfd
*output_bfd
,
1513 struct bfd_link_info
*link_info
,
1514 struct bfd_link_order
*link_order
,
1516 bfd_boolean relocatable
,
1519 Elf_Internal_Shdr
*symtab_hdr
;
1520 asection
*input_section
= link_order
->u
.indirect
.section
;
1521 bfd
*input_bfd
= input_section
->owner
;
1522 asection
**sections
= NULL
;
1523 Elf_Internal_Rela
*internal_relocs
= NULL
;
1524 Elf_Internal_Sym
*isymbuf
= NULL
;
1526 /* We only need to handle the case of relaxing, or of having a
1527 particular set of section contents, specially. */
1529 || elf_section_data (input_section
)->this_hdr
.contents
== NULL
)
1530 return bfd_generic_get_relocated_section_contents (output_bfd
, link_info
,
1535 symtab_hdr
= &elf_tdata (input_bfd
)->symtab_hdr
;
1537 memcpy (data
, elf_section_data (input_section
)->this_hdr
.contents
,
1538 (size_t) input_section
->size
);
1540 if ((input_section
->flags
& SEC_RELOC
) != 0
1541 && input_section
->reloc_count
> 0)
1543 Elf_Internal_Sym
*isym
;
1544 Elf_Internal_Sym
*isymend
;
1548 internal_relocs
= _bfd_elf_link_read_relocs (input_bfd
, input_section
,
1550 if (internal_relocs
== NULL
)
1553 if (symtab_hdr
->sh_info
!= 0)
1555 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1556 if (isymbuf
== NULL
)
1557 isymbuf
= bfd_elf_get_elf_syms (input_bfd
, symtab_hdr
,
1558 symtab_hdr
->sh_info
, 0,
1560 if (isymbuf
== NULL
)
1564 amt
= symtab_hdr
->sh_info
;
1565 amt
*= sizeof (asection
*);
1566 sections
= bfd_malloc (amt
);
1567 if (sections
== NULL
&& amt
!= 0)
1570 isymend
= isymbuf
+ symtab_hdr
->sh_info
;
1571 for (isym
= isymbuf
, secpp
= sections
; isym
< isymend
; ++isym
, ++secpp
)
1575 if (isym
->st_shndx
== SHN_UNDEF
)
1576 isec
= bfd_und_section_ptr
;
1577 else if (isym
->st_shndx
== SHN_ABS
)
1578 isec
= bfd_abs_section_ptr
;
1579 else if (isym
->st_shndx
== SHN_COMMON
)
1580 isec
= bfd_com_section_ptr
;
1582 isec
= bfd_section_from_elf_index (input_bfd
, isym
->st_shndx
);
1587 if (! elf32_cr16_relocate_section (output_bfd
, link_info
, input_bfd
,
1588 input_section
, data
, internal_relocs
,
1592 if (sections
!= NULL
)
1595 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1597 if (elf_section_data (input_section
)->relocs
!= internal_relocs
)
1598 free (internal_relocs
);
1604 if (sections
!= NULL
)
1607 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
1609 if (internal_relocs
!= NULL
1610 && elf_section_data (input_section
)->relocs
!= internal_relocs
)
1611 free (internal_relocs
);
1615 /* Assorted hash table functions. */
1617 /* Initialize an entry in the link hash table. */
1619 /* Create an entry in an CR16 ELF linker hash table. */
1621 static struct bfd_hash_entry
*
1622 elf32_cr16_link_hash_newfunc (struct bfd_hash_entry
*entry
,
1623 struct bfd_hash_table
*table
,
1626 struct elf32_cr16_link_hash_entry
*ret
=
1627 (struct elf32_cr16_link_hash_entry
*) entry
;
1629 /* Allocate the structure if it has not already been allocated by a
1631 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1632 ret
= ((struct elf32_cr16_link_hash_entry
*)
1633 bfd_hash_allocate (table
,
1634 sizeof (struct elf32_cr16_link_hash_entry
)));
1635 if (ret
== (struct elf32_cr16_link_hash_entry
*) NULL
)
1636 return (struct bfd_hash_entry
*) ret
;
1638 /* Call the allocation method of the superclass. */
1639 ret
= ((struct elf32_cr16_link_hash_entry
*)
1640 _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry
*) ret
,
1642 if (ret
!= (struct elf32_cr16_link_hash_entry
*) NULL
)
1644 ret
->direct_calls
= 0;
1645 ret
->stack_size
= 0;
1647 ret
->movm_stack_size
= 0;
1652 return (struct bfd_hash_entry
*) ret
;
1655 /* Create an cr16 ELF linker hash table. */
1657 static struct bfd_link_hash_table
*
1658 elf32_cr16_link_hash_table_create (bfd
*abfd
)
1660 struct elf_link_hash_table
*ret
;
1661 bfd_size_type amt
= sizeof (struct elf_link_hash_table
);
1663 ret
= (struct elf_link_hash_table
*) bfd_zmalloc (amt
);
1664 if (ret
== (struct elf_link_hash_table
*) NULL
)
1667 if (!_bfd_elf_link_hash_table_init (ret
, abfd
,
1668 elf32_cr16_link_hash_newfunc
,
1669 sizeof (struct elf32_cr16_link_hash_entry
),
1679 static unsigned long
1680 elf_cr16_mach (flagword flags
)
1686 return bfd_mach_cr16
;
1690 /* The final processing done just before writing out a CR16 ELF object
1691 file. This gets the CR16 architecture right based on the machine
1695 _bfd_cr16_elf_final_write_processing (bfd
*abfd
,
1696 bfd_boolean linker ATTRIBUTE_UNUSED
)
1699 switch (bfd_get_mach (abfd
))
1708 elf_elfheader (abfd
)->e_flags
|= val
;
1713 _bfd_cr16_elf_object_p (bfd
*abfd
)
1715 bfd_default_set_arch_mach (abfd
, bfd_arch_cr16
,
1716 elf_cr16_mach (elf_elfheader (abfd
)->e_flags
));
1720 /* Merge backend specific data from an object file to the output
1721 object file when linking. */
1724 _bfd_cr16_elf_merge_private_bfd_data (bfd
*ibfd
, bfd
*obfd
)
1726 if (bfd_get_flavour (ibfd
) != bfd_target_elf_flavour
1727 || bfd_get_flavour (obfd
) != bfd_target_elf_flavour
)
1730 if (bfd_get_arch (obfd
) == bfd_get_arch (ibfd
)
1731 && bfd_get_mach (obfd
) < bfd_get_mach (ibfd
))
1733 if (! bfd_set_arch_mach (obfd
, bfd_get_arch (ibfd
),
1734 bfd_get_mach (ibfd
)))
1742 /* This function handles relaxing for the CR16.
1744 There's quite a few relaxing opportunites available on the CR16:
1746 * bcond:24 -> bcond:16 1 byte
1747 * bcond:16 -> bcond:8 1 byte
1748 * arithmetic imm32 -> arithmetic imm20 12 bits
1749 * arithmetic imm20/imm16 -> arithmetic imm4 12/16 bits
1751 Symbol- and reloc-reading infrastructure copied from elf-m10200.c. */
1754 elf32_cr16_relax_section (bfd
*abfd
, asection
*sec
,
1755 struct bfd_link_info
*link_info
, bfd_boolean
*again
)
1757 Elf_Internal_Shdr
*symtab_hdr
;
1758 Elf_Internal_Rela
*internal_relocs
;
1759 Elf_Internal_Rela
*irel
, *irelend
;
1760 bfd_byte
*contents
= NULL
;
1761 Elf_Internal_Sym
*isymbuf
= NULL
;
1763 /* Assume nothing changes. */
1766 /* We don't have to do anything for a relocatable link, if
1767 this section does not have relocs, or if this is not a
1769 if (link_info
->relocatable
1770 || (sec
->flags
& SEC_RELOC
) == 0
1771 || sec
->reloc_count
== 0
1772 || (sec
->flags
& SEC_CODE
) == 0)
1775 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
1777 /* Get a copy of the native relocations. */
1778 internal_relocs
= _bfd_elf_link_read_relocs (abfd
, sec
, NULL
, NULL
,
1779 link_info
->keep_memory
);
1780 if (internal_relocs
== NULL
)
1783 /* Walk through them looking for relaxing opportunities. */
1784 irelend
= internal_relocs
+ sec
->reloc_count
;
1785 for (irel
= internal_relocs
; irel
< irelend
; irel
++)
1789 /* If this isn't something that can be relaxed, then ignore
1791 if (ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP16
1792 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_DISP24
1793 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM32
1794 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM20
1795 && ELF32_R_TYPE (irel
->r_info
) != (int) R_CR16_IMM16
)
1798 /* Get the section contents if we haven't done so already. */
1799 if (contents
== NULL
)
1801 /* Get cached copy if it exists. */
1802 if (elf_section_data (sec
)->this_hdr
.contents
!= NULL
)
1803 contents
= elf_section_data (sec
)->this_hdr
.contents
;
1804 /* Go get them off disk. */
1805 else if (!bfd_malloc_and_get_section (abfd
, sec
, &contents
))
1809 /* Read this BFD's local symbols if we haven't done so already. */
1810 if (isymbuf
== NULL
&& symtab_hdr
->sh_info
!= 0)
1812 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
1813 if (isymbuf
== NULL
)
1814 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
1815 symtab_hdr
->sh_info
, 0,
1817 if (isymbuf
== NULL
)
1821 /* Get the value of the symbol referred to by the reloc. */
1822 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
1824 /* A local symbol. */
1825 Elf_Internal_Sym
*isym
;
1828 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
1829 if (isym
->st_shndx
== SHN_UNDEF
)
1830 sym_sec
= bfd_und_section_ptr
;
1831 else if (isym
->st_shndx
== SHN_ABS
)
1832 sym_sec
= bfd_abs_section_ptr
;
1833 else if (isym
->st_shndx
== SHN_COMMON
)
1834 sym_sec
= bfd_com_section_ptr
;
1836 sym_sec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
1837 symval
= (isym
->st_value
1838 + sym_sec
->output_section
->vma
1839 + sym_sec
->output_offset
);
1844 struct elf_link_hash_entry
*h
;
1846 /* An external symbol. */
1847 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
1848 h
= elf_sym_hashes (abfd
)[indx
];
1849 BFD_ASSERT (h
!= NULL
);
1851 if (h
->root
.type
!= bfd_link_hash_defined
1852 && h
->root
.type
!= bfd_link_hash_defweak
)
1853 /* This appears to be a reference to an undefined
1854 symbol. Just ignore it--it will be caught by the
1855 regular reloc processing. */
1858 symval
= (h
->root
.u
.def
.value
1859 + h
->root
.u
.def
.section
->output_section
->vma
1860 + h
->root
.u
.def
.section
->output_offset
);
1863 /* For simplicity of coding, we are going to modify the section
1864 contents, the section relocs, and the BFD symbol table. We
1865 must tell the rest of the code not to free up this
1866 information. It would be possible to instead create a table
1867 of changes which have to be made, as is done in coff-mips.c;
1868 that would be more work, but would require less memory when
1869 the linker is run. */
1871 /* Try to turn a 24 branch/call into a 16bit relative
1873 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP24
)
1875 bfd_vma value
= symval
;
1877 /* Deal with pc-relative gunk. */
1878 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1879 value
-= irel
->r_offset
;
1880 value
+= irel
->r_addend
;
1882 /* See if the value will fit in 16 bits, note the high value is
1883 0xfffe + 2 as the target will be two bytes closer if we are
1885 if ((long) value
< 0x10000 && (long) value
> -0x10002)
1889 /* Get the opcode. */
1890 code
= (unsigned int) bfd_get_32 (abfd
, contents
+ irel
->r_offset
);
1892 /* Verify it's a 'bcond' and fix the opcode. */
1893 if ((code
& 0xffff) == 0x0010)
1894 bfd_put_16 (abfd
, 0x1800 | ((0xf & (code
>> 20)) << 4), contents
+ irel
->r_offset
);
1898 /* Note that we've changed the relocs, section contents, etc. */
1899 elf_section_data (sec
)->relocs
= internal_relocs
;
1900 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1901 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1903 /* Fix the relocation's type. */
1904 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1907 /* Delete two bytes of data. */
1908 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1909 irel
->r_offset
+ 2, 2))
1912 /* That will change things, so, we should relax again.
1913 Note that this is not required, and it may be slow. */
1918 /* Try to turn a 16bit pc-relative branch into an
1919 8bit pc-relative branch. */
1920 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_DISP16
)
1922 bfd_vma value
= symval
;
1924 /* Deal with pc-relative gunk. */
1925 value
-= (sec
->output_section
->vma
+ sec
->output_offset
);
1926 value
-= irel
->r_offset
;
1927 value
+= irel
->r_addend
;
1929 /* See if the value will fit in 8 bits, note the high value is
1930 0xfc + 2 as the target will be two bytes closer if we are
1932 /*if ((long) value < 0x1fa && (long) value > -0x100) REVISIT:range */
1933 if ((long) value
< 0xfa && (long) value
> -0x100)
1935 unsigned short code
;
1937 /* Get the opcode. */
1938 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1940 /* Verify it's a 'bcond' and fix the opcode. */
1941 if ((code
& 0xff0f) == 0x1800)
1942 bfd_put_16 (abfd
, (code
& 0xf0f0), contents
+ irel
->r_offset
);
1946 /* Note that we've changed the relocs, section contents, etc. */
1947 elf_section_data (sec
)->relocs
= internal_relocs
;
1948 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1949 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1951 /* Fix the relocation's type. */
1952 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
1955 /* Delete two bytes of data. */
1956 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
1957 irel
->r_offset
+ 2, 2))
1960 /* That will change things, so, we should relax again.
1961 Note that this is not required, and it may be slow. */
1966 /* Try to turn a 32-bit IMM address into a 20/16-bit IMM address */
1967 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM32
)
1969 bfd_vma value
= symval
;
1970 unsigned short is_add_mov
= 0;
1973 /* Get the existing value from the mcode */
1974 value1
= ((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) >> 16)
1975 |(((bfd_get_32 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff) << 16)));
1977 /* See if the value will fit in 20 bits. */
1978 if ((long) (value
+ value1
) < 0xfffff && (long) (value
+ value1
) > 0)
1980 unsigned short code
;
1982 /* Get the opcode. */
1983 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
1985 /* Verify it's a 'arithmetic ADDD or MOVD instruction'.
1986 For ADDD and MOVD only, convert to IMM32 -> IMM20. */
1988 if (((code
& 0xfff0) == 0x0070) || ((code
& 0xfff0) == 0x0020))
1993 /* Note that we've changed the relocs, section contents,
1995 elf_section_data (sec
)->relocs
= internal_relocs
;
1996 elf_section_data (sec
)->this_hdr
.contents
= contents
;
1997 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
1999 /* Fix the opcode. */
2000 if ((code
& 0xfff0) == 0x0070) /* For movd. */
2001 bfd_put_8 (abfd
, 0x05, contents
+ irel
->r_offset
+ 1);
2002 else /* code == 0x0020 for addd. */
2003 bfd_put_8 (abfd
, 0x04, contents
+ irel
->r_offset
+ 1);
2005 bfd_put_8 (abfd
, (code
& 0xf) << 4, contents
+ irel
->r_offset
);
2007 /* If existing value is nagavive adjust approriately
2008 place the 16-20bits (ie 4 bit) in new opcode,
2009 as the 0xffffxxxx, the higher 2 byte values removed. */
2010 if (value1
& 0x80000000)
2011 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2013 bfd_put_8 (abfd
, (((value1
>> 16)&0xf) | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2015 /* Fix the relocation's type. */
2016 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2019 /* Delete two bytes of data. */
2020 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2021 irel
->r_offset
+ 2, 2))
2024 /* That will change things, so, we should relax again.
2025 Note that this is not required, and it may be slow. */
2030 /* See if the value will fit in 16 bits. */
2032 && ((long)(value
+ value1
) < 0x7fff && (long)(value
+ value1
) > 0))
2034 unsigned short code
;
2036 /* Get the opcode. */
2037 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2039 /* Note that we've changed the relocs, section contents, etc. */
2040 elf_section_data (sec
)->relocs
= internal_relocs
;
2041 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2042 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2044 /* Fix the opcode. */
2045 if ((code
& 0xf0) == 0x70) /* For movd. */
2046 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
+ 1);
2047 else if ((code
& 0xf0) == 0x20) /* For addd. */
2048 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
+ 1);
2049 else if ((code
& 0xf0) == 0x90) /* For cmpd. */
2050 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
+ 1);
2054 bfd_put_8 (abfd
, 0xb0 | (code
& 0xf), contents
+ irel
->r_offset
);
2056 /* If existing value is nagavive adjust approriately
2057 place the 12-16bits (ie 4 bit) in new opcode,
2058 as the 0xfffffxxx, the higher 2 byte values removed. */
2059 if (value1
& 0x80000000)
2060 bfd_put_8 (abfd
, (0x0f | (bfd_get_8(abfd
, contents
+ irel
->r_offset
))), contents
+ irel
->r_offset
);
2062 bfd_put_16 (abfd
, value1
, contents
+ irel
->r_offset
+ 2);
2065 /* Fix the relocation's type. */
2066 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2069 /* Delete two bytes of data. */
2070 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2071 irel
->r_offset
+ 2, 2))
2074 /* That will change things, so, we should relax again.
2075 Note that this is not required, and it may be slow. */
2081 /* Try to turn a 16bit immediate address into a 4bit
2082 immediate address. */
2083 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2084 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM16
))
2086 bfd_vma value
= symval
;
2089 /* Get the existing value from the mcode */
2090 value1
= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 2) & 0xffff));
2092 if (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_IMM20
)
2094 value1
|= ((bfd_get_16 (abfd
, contents
+ irel
->r_offset
+ 1) & 0xf000) << 0x4);
2097 /* See if the value will fit in 4 bits. */
2098 if ((((long) (value
+ value1
)) < 0xf)
2099 && (((long) (value
+ value1
)) > 0))
2101 unsigned short code
;
2103 /* Get the opcode. */
2104 code
= (unsigned short) bfd_get_16 (abfd
, contents
+ irel
->r_offset
);
2106 /* Note that we've changed the relocs, section contents, etc. */
2107 elf_section_data (sec
)->relocs
= internal_relocs
;
2108 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2109 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2111 /* Fix the opcode. */
2112 if (((code
& 0x0f00) == 0x0400) || ((code
& 0x0f00) == 0x0500))
2114 if ((code
& 0x0f00) == 0x0400) /* For movd imm20. */
2115 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2116 else /* For addd imm20. */
2117 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2118 bfd_put_8 (abfd
, (code
& 0xf0) >> 4, contents
+ irel
->r_offset
+ 1);
2122 if ((code
& 0xfff0) == 0x56b0) /* For cmpd imm16. */
2123 bfd_put_8 (abfd
, 0x56, contents
+ irel
->r_offset
);
2124 else if ((code
& 0xfff0) == 0x54b0) /* For movd imm16. */
2125 bfd_put_8 (abfd
, 0x54, contents
+ irel
->r_offset
);
2126 else if ((code
& 0xfff0) == 0x58b0) /* For movb imm16. */
2127 bfd_put_8 (abfd
, 0x58, contents
+ irel
->r_offset
);
2128 else if ((code
& 0xfff0) == 0x5Ab0) /* For movw imm16. */
2129 bfd_put_8 (abfd
, 0x5A, contents
+ irel
->r_offset
);
2130 else if ((code
& 0xfff0) == 0x60b0) /* For addd imm16. */
2131 bfd_put_8 (abfd
, 0x60, contents
+ irel
->r_offset
);
2132 else if ((code
& 0xfff0) == 0x30b0) /* For addb imm16. */
2133 bfd_put_8 (abfd
, 0x30, contents
+ irel
->r_offset
);
2134 else if ((code
& 0xfff0) == 0x2Cb0) /* For addub imm16. */
2135 bfd_put_8 (abfd
, 0x2C, contents
+ irel
->r_offset
);
2136 else if ((code
& 0xfff0) == 0x32b0) /* For adduw imm16. */
2137 bfd_put_8 (abfd
, 0x32, contents
+ irel
->r_offset
);
2138 else if ((code
& 0xfff0) == 0x38b0) /* For subb imm16. */
2139 bfd_put_8 (abfd
, 0x38, contents
+ irel
->r_offset
);
2140 else if ((code
& 0xfff0) == 0x3Cb0) /* For subcb imm16. */
2141 bfd_put_8 (abfd
, 0x3C, contents
+ irel
->r_offset
);
2142 else if ((code
& 0xfff0) == 0x3Fb0) /* For subcw imm16. */
2143 bfd_put_8 (abfd
, 0x3F, contents
+ irel
->r_offset
);
2144 else if ((code
& 0xfff0) == 0x3Ab0) /* For subw imm16. */
2145 bfd_put_8 (abfd
, 0x3A, contents
+ irel
->r_offset
);
2146 else if ((code
& 0xfff0) == 0x50b0) /* For cmpb imm16. */
2147 bfd_put_8 (abfd
, 0x50, contents
+ irel
->r_offset
);
2148 else if ((code
& 0xfff0) == 0x52b0) /* For cmpw imm16. */
2149 bfd_put_8 (abfd
, 0x52, contents
+ irel
->r_offset
);
2153 bfd_put_8 (abfd
, (code
& 0xf), contents
+ irel
->r_offset
+ 1);
2156 /* Fix the relocation's type. */
2157 irel
->r_info
= ELF32_R_INFO (ELF32_R_SYM (irel
->r_info
),
2160 /* Delete two bytes of data. */
2161 if (!elf32_cr16_relax_delete_bytes (link_info
, abfd
, sec
,
2162 irel
->r_offset
+ 2, 2))
2165 /* That will change things, so, we should relax again.
2166 Note that this is not required, and it may be slow. */
2174 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2176 if (! link_info
->keep_memory
)
2179 /* Cache the symbols for elf_link_input_bfd. */
2180 symtab_hdr
->contents
= (unsigned char *) isymbuf
;
2183 if (contents
!= NULL
2184 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2186 if (! link_info
->keep_memory
)
2189 /* Cache the section contents for elf_link_input_bfd. */
2190 elf_section_data (sec
)->this_hdr
.contents
= contents
;
2194 if (internal_relocs
!= NULL
2195 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2196 free (internal_relocs
);
2202 && symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2204 if (contents
!= NULL
2205 && elf_section_data (sec
)->this_hdr
.contents
!= contents
)
2207 if (internal_relocs
!= NULL
2208 && elf_section_data (sec
)->relocs
!= internal_relocs
)
2209 free (internal_relocs
);
2215 elf32_cr16_gc_mark_hook (asection
*sec
,
2216 struct bfd_link_info
*info
,
2217 Elf_Internal_Rela
*rel
,
2218 struct elf_link_hash_entry
*h
,
2219 Elf_Internal_Sym
*sym
)
2221 return _bfd_elf_gc_mark_hook (sec
, info
, rel
, h
, sym
);
2224 /* Update the got entry reference counts for the section being removed. */
2227 elf32_cr16_gc_sweep_hook (bfd
*abfd ATTRIBUTE_UNUSED
,
2228 struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2229 asection
*sec ATTRIBUTE_UNUSED
,
2230 const Elf_Internal_Rela
*relocs ATTRIBUTE_UNUSED
)
2232 /* We don't support garbage collection of GOT and PLT relocs yet. */
2236 /* Create dynamic sections when linking against a dynamic object. */
2239 _bfd_cr16_elf_create_dynamic_sections (bfd
*abfd
, struct bfd_link_info
*info
)
2243 const struct elf_backend_data
* bed
= get_elf_backend_data (abfd
);
2246 switch (bed
->s
->arch_size
)
2257 bfd_set_error (bfd_error_bad_value
);
2261 /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2262 .rel[a].bss sections. */
2264 flags
= (SEC_ALLOC
| SEC_LOAD
| SEC_HAS_CONTENTS
| SEC_IN_MEMORY
2265 | SEC_LINKER_CREATED
);
2267 s
= bfd_make_section_anyway_with_flags (abfd
,
2268 (bed
->default_use_rela_p
2269 ? ".rela.plt" : ".rel.plt"),
2270 flags
| SEC_READONLY
);
2272 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2275 if (! _bfd_cr16_elf_create_got_section (abfd
, info
))
2278 if (bed
->want_dynbss
)
2280 /* The .dynbss section is a place to put symbols which are defined
2281 by dynamic objects, are referenced by regular objects, and are
2282 not functions. We must allocate space for them in the process
2283 image and use a R_*_COPY reloc to tell the dynamic linker to
2284 initialize them at run time. The linker script puts the .dynbss
2285 section into the .bss section of the final image. */
2286 s
= bfd_make_section_anyway_with_flags (abfd
, ".dynbss",
2287 SEC_ALLOC
| SEC_LINKER_CREATED
);
2291 /* The .rel[a].bss section holds copy relocs. This section is not
2292 normally needed. We need to create it here, though, so that the
2293 linker will map it to an output section. We can't just create it
2294 only if we need it, because we will not know whether we need it
2295 until we have seen all the input files, and the first time the
2296 main linker code calls BFD after examining all the input files
2297 (size_dynamic_sections) the input sections have already been
2298 mapped to the output sections. If the section turns out not to
2299 be needed, we can discard it later. We will never need this
2300 section when generating a shared object, since they do not use
2302 if (! info
->executable
)
2304 s
= bfd_make_section_anyway_with_flags (abfd
,
2305 (bed
->default_use_rela_p
2306 ? ".rela.bss" : ".rel.bss"),
2307 flags
| SEC_READONLY
);
2309 || ! bfd_set_section_alignment (abfd
, s
, ptralign
))
2317 /* Adjust a symbol defined by a dynamic object and referenced by a
2318 regular object. The current definition is in some section of the
2319 dynamic object, but we're not including those sections. We have to
2320 change the definition to something the rest of the link can
2324 _bfd_cr16_elf_adjust_dynamic_symbol (struct bfd_link_info
* info
,
2325 struct elf_link_hash_entry
* h
)
2330 dynobj
= elf_hash_table (info
)->dynobj
;
2332 /* Make sure we know what is going on here. */
2333 BFD_ASSERT (dynobj
!= NULL
2335 || h
->u
.weakdef
!= NULL
2338 && !h
->def_regular
)));
2340 /* If this is a function, put it in the procedure linkage table. We
2341 will fill in the contents of the procedure linkage table later,
2342 when we know the address of the .got section. */
2343 if (h
->type
== STT_FUNC
2346 if (! info
->executable
2350 /* This case can occur if we saw a PLT reloc in an input
2351 file, but the symbol was never referred to by a dynamic
2352 object. In such a case, we don't actually need to build
2353 a procedure linkage table, and we can just do a REL32
2355 BFD_ASSERT (h
->needs_plt
);
2359 /* Make sure this symbol is output as a dynamic symbol. */
2360 if (h
->dynindx
== -1)
2362 if (! bfd_elf_link_record_dynamic_symbol (info
, h
))
2366 /* We also need to make an entry in the .got.plt section, which
2367 will be placed in the .got section by the linker script. */
2369 s
= bfd_get_linker_section (dynobj
, ".got.plt");
2370 BFD_ASSERT (s
!= NULL
);
2373 /* We also need to make an entry in the .rela.plt section. */
2375 s
= bfd_get_linker_section (dynobj
, ".rela.plt");
2376 BFD_ASSERT (s
!= NULL
);
2377 s
->size
+= sizeof (Elf32_External_Rela
);
2382 /* If this is a weak symbol, and there is a real definition, the
2383 processor independent code will have arranged for us to see the
2384 real definition first, and we can just use the same value. */
2385 if (h
->u
.weakdef
!= NULL
)
2387 BFD_ASSERT (h
->u
.weakdef
->root
.type
== bfd_link_hash_defined
2388 || h
->u
.weakdef
->root
.type
== bfd_link_hash_defweak
);
2389 h
->root
.u
.def
.section
= h
->u
.weakdef
->root
.u
.def
.section
;
2390 h
->root
.u
.def
.value
= h
->u
.weakdef
->root
.u
.def
.value
;
2394 /* This is a reference to a symbol defined by a dynamic object which
2395 is not a function. */
2397 /* If we are creating a shared library, we must presume that the
2398 only references to the symbol are via the global offset table.
2399 For such cases we need not do anything here; the relocations will
2400 be handled correctly by relocate_section. */
2401 if (info
->executable
)
2404 /* If there are no references to this symbol that do not use the
2405 GOT, we don't need to generate a copy reloc. */
2406 if (!h
->non_got_ref
)
2409 /* We must allocate the symbol in our .dynbss section, which will
2410 become part of the .bss section of the executable. There will be
2411 an entry for this symbol in the .dynsym section. The dynamic
2412 object will contain position independent code, so all references
2413 from the dynamic object to this symbol will go through the global
2414 offset table. The dynamic linker will use the .dynsym entry to
2415 determine the address it must put in the global offset table, so
2416 both the dynamic object and the regular object will refer to the
2417 same memory location for the variable. */
2419 s
= bfd_get_linker_section (dynobj
, ".dynbss");
2420 BFD_ASSERT (s
!= NULL
);
2422 /* We must generate a R_CR16_COPY reloc to tell the dynamic linker to
2423 copy the initial value out of the dynamic object and into the
2424 runtime process image. We need to remember the offset into the
2425 .rela.bss section we are going to use. */
2426 if ((h
->root
.u
.def
.section
->flags
& SEC_ALLOC
) != 0 && h
->size
!= 0)
2430 srel
= bfd_get_linker_section (dynobj
, ".rela.bss");
2431 BFD_ASSERT (srel
!= NULL
);
2432 srel
->size
+= sizeof (Elf32_External_Rela
);
2436 return _bfd_elf_adjust_dynamic_copy (h
, s
);
2439 /* Set the sizes of the dynamic sections. */
2442 _bfd_cr16_elf_size_dynamic_sections (bfd
* output_bfd
,
2443 struct bfd_link_info
* info
)
2449 bfd_boolean reltext
;
2451 dynobj
= elf_hash_table (info
)->dynobj
;
2452 BFD_ASSERT (dynobj
!= NULL
);
2454 if (elf_hash_table (info
)->dynamic_sections_created
)
2456 /* Set the contents of the .interp section to the interpreter. */
2457 if (info
->executable
)
2460 s
= bfd_get_linker_section (dynobj
, ".interp");
2461 BFD_ASSERT (s
!= NULL
);
2462 s
->size
= sizeof ELF_DYNAMIC_INTERPRETER
;
2463 s
->contents
= (unsigned char *) ELF_DYNAMIC_INTERPRETER
;
2469 /* We may have created entries in the .rela.got section.
2470 However, if we are not creating the dynamic sections, we will
2471 not actually use these entries. Reset the size of .rela.got,
2472 which will cause it to get stripped from the output file
2474 s
= bfd_get_linker_section (dynobj
, ".rela.got");
2479 /* The check_relocs and adjust_dynamic_symbol entry points have
2480 determined the sizes of the various dynamic sections. Allocate
2485 for (s
= dynobj
->sections
; s
!= NULL
; s
= s
->next
)
2489 if ((s
->flags
& SEC_LINKER_CREATED
) == 0)
2492 /* It's OK to base decisions on the section name, because none
2493 of the dynobj section names depend upon the input files. */
2494 name
= bfd_get_section_name (dynobj
, s
);
2496 if (strcmp (name
, ".plt") == 0)
2498 /* Remember whether there is a PLT. */
2501 else if (CONST_STRNEQ (name
, ".rela"))
2507 /* Remember whether there are any reloc sections other
2509 if (strcmp (name
, ".rela.plt") != 0)
2511 const char * outname
;
2515 /* If this relocation section applies to a read only
2516 section, then we probably need a DT_TEXTREL
2517 entry. The entries in the .rela.plt section
2518 really apply to the .got section, which we
2519 created ourselves and so know is not readonly. */
2520 outname
= bfd_get_section_name (output_bfd
,
2522 target
= bfd_get_section_by_name (output_bfd
, outname
+ 5);
2524 && (target
->flags
& SEC_READONLY
) != 0
2525 && (target
->flags
& SEC_ALLOC
) != 0)
2529 /* We use the reloc_count field as a counter if we need
2530 to copy relocs into the output file. */
2534 else if (! CONST_STRNEQ (name
, ".got")
2535 && strcmp (name
, ".dynbss") != 0)
2536 /* It's not one of our sections, so don't allocate space. */
2541 /* If we don't need this section, strip it from the
2542 output file. This is mostly to handle .rela.bss and
2543 .rela.plt. We must create both sections in
2544 create_dynamic_sections, because they must be created
2545 before the linker maps input sections to output
2546 sections. The linker does that before
2547 adjust_dynamic_symbol is called, and it is that
2548 function which decides whether anything needs to go
2549 into these sections. */
2550 s
->flags
|= SEC_EXCLUDE
;
2554 if ((s
->flags
& SEC_HAS_CONTENTS
) == 0)
2557 /* Allocate memory for the section contents. We use bfd_zalloc
2558 here in case unused entries are not reclaimed before the
2559 section's contents are written out. This should not happen,
2560 but this way if it does, we get a R_CR16_NONE reloc
2561 instead of garbage. */
2562 s
->contents
= (bfd_byte
*) bfd_zalloc (dynobj
, s
->size
);
2563 if (s
->contents
== NULL
)
2567 if (elf_hash_table (info
)->dynamic_sections_created
)
2569 /* Add some entries to the .dynamic section. We fill in the
2570 values later, in _bfd_cr16_elf_finish_dynamic_sections,
2571 but we must add the entries now so that we get the correct
2572 size for the .dynamic section. The DT_DEBUG entry is filled
2573 in by the dynamic linker and used by the debugger. */
2574 if (! info
->executable
)
2576 if (!_bfd_elf_add_dynamic_entry (info
, DT_DEBUG
, 0))
2582 if (!_bfd_elf_add_dynamic_entry (info
, DT_PLTGOT
, 0)
2583 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTRELSZ
, 0)
2584 || !_bfd_elf_add_dynamic_entry (info
, DT_PLTREL
, DT_RELA
)
2585 || !_bfd_elf_add_dynamic_entry (info
, DT_JMPREL
, 0))
2591 if (!_bfd_elf_add_dynamic_entry (info
, DT_RELA
, 0)
2592 || !_bfd_elf_add_dynamic_entry (info
, DT_RELASZ
, 0)
2593 || !_bfd_elf_add_dynamic_entry (info
, DT_RELAENT
,
2594 sizeof (Elf32_External_Rela
)))
2600 if (!_bfd_elf_add_dynamic_entry (info
, DT_TEXTREL
, 0))
2608 /* Finish up dynamic symbol handling. We set the contents of various
2609 dynamic sections here. */
2612 _bfd_cr16_elf_finish_dynamic_symbol (bfd
* output_bfd
,
2613 struct bfd_link_info
* info
,
2614 struct elf_link_hash_entry
* h
,
2615 Elf_Internal_Sym
* sym
)
2619 dynobj
= elf_hash_table (info
)->dynobj
;
2621 if (h
->got
.offset
!= (bfd_vma
) -1)
2625 Elf_Internal_Rela rel
;
2627 /* This symbol has an entry in the global offset table. Set it up. */
2629 sgot
= bfd_get_linker_section (dynobj
, ".got");
2630 srel
= bfd_get_linker_section (dynobj
, ".rela.got");
2631 BFD_ASSERT (sgot
!= NULL
&& srel
!= NULL
);
2633 rel
.r_offset
= (sgot
->output_section
->vma
2634 + sgot
->output_offset
2635 + (h
->got
.offset
& ~1));
2637 /* If this is a -Bsymbolic link, and the symbol is defined
2638 locally, we just want to emit a RELATIVE reloc. Likewise if
2639 the symbol was forced to be local because of a version file.
2640 The entry in the global offset table will already have been
2641 initialized in the relocate_section function. */
2642 if (info
->executable
2643 && (info
->symbolic
|| h
->dynindx
== -1)
2646 rel
.r_info
= ELF32_R_INFO (0, R_CR16_GOT_REGREL20
);
2647 rel
.r_addend
= (h
->root
.u
.def
.value
2648 + h
->root
.u
.def
.section
->output_section
->vma
2649 + h
->root
.u
.def
.section
->output_offset
);
2653 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
+ h
->got
.offset
);
2654 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2658 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2659 (bfd_byte
*) ((Elf32_External_Rela
*) srel
->contents
2660 + srel
->reloc_count
));
2661 ++ srel
->reloc_count
;
2667 Elf_Internal_Rela rel
;
2669 /* This symbol needs a copy reloc. Set it up. */
2670 BFD_ASSERT (h
->dynindx
!= -1
2671 && (h
->root
.type
== bfd_link_hash_defined
2672 || h
->root
.type
== bfd_link_hash_defweak
));
2674 s
= bfd_get_linker_section (dynobj
, ".rela.bss");
2675 BFD_ASSERT (s
!= NULL
);
2677 rel
.r_offset
= (h
->root
.u
.def
.value
2678 + h
->root
.u
.def
.section
->output_section
->vma
2679 + h
->root
.u
.def
.section
->output_offset
);
2680 rel
.r_info
= ELF32_R_INFO (h
->dynindx
, R_CR16_GOT_REGREL20
);
2682 bfd_elf32_swap_reloca_out (output_bfd
, &rel
,
2683 (bfd_byte
*) ((Elf32_External_Rela
*) s
->contents
2688 /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute. */
2689 if (h
== elf_hash_table (info
)->hdynamic
2690 || h
== elf_hash_table (info
)->hgot
)
2691 sym
->st_shndx
= SHN_ABS
;
2696 /* Finish up the dynamic sections. */
2699 _bfd_cr16_elf_finish_dynamic_sections (bfd
* output_bfd
,
2700 struct bfd_link_info
* info
)
2706 dynobj
= elf_hash_table (info
)->dynobj
;
2708 sgot
= bfd_get_linker_section (dynobj
, ".got.plt");
2709 BFD_ASSERT (sgot
!= NULL
);
2710 sdyn
= bfd_get_linker_section (dynobj
, ".dynamic");
2712 if (elf_hash_table (info
)->dynamic_sections_created
)
2714 Elf32_External_Dyn
* dyncon
;
2715 Elf32_External_Dyn
* dynconend
;
2717 BFD_ASSERT (sdyn
!= NULL
);
2719 dyncon
= (Elf32_External_Dyn
*) sdyn
->contents
;
2720 dynconend
= (Elf32_External_Dyn
*) (sdyn
->contents
+ sdyn
->size
);
2722 for (; dyncon
< dynconend
; dyncon
++)
2724 Elf_Internal_Dyn dyn
;
2728 bfd_elf32_swap_dyn_in (dynobj
, dyncon
, &dyn
);
2742 s
= bfd_get_section_by_name (output_bfd
, name
);
2743 BFD_ASSERT (s
!= NULL
);
2744 dyn
.d_un
.d_ptr
= s
->vma
;
2745 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2749 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2750 BFD_ASSERT (s
!= NULL
);
2751 dyn
.d_un
.d_val
= s
->size
;
2752 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2756 /* My reading of the SVR4 ABI indicates that the
2757 procedure linkage table relocs (DT_JMPREL) should be
2758 included in the overall relocs (DT_RELA). This is
2759 what Solaris does. However, UnixWare can not handle
2760 that case. Therefore, we override the DT_RELASZ entry
2761 here to make it not include the JMPREL relocs. Since
2762 the linker script arranges for .rela.plt to follow all
2763 other relocation sections, we don't have to worry
2764 about changing the DT_RELA entry. */
2765 s
= bfd_get_section_by_name (output_bfd
, ".rela.plt");
2767 dyn
.d_un
.d_val
-= s
->size
;
2768 bfd_elf32_swap_dyn_out (output_bfd
, &dyn
, dyncon
);
2775 /* Fill in the first three entries in the global offset table. */
2779 bfd_put_32 (output_bfd
, (bfd_vma
) 0, sgot
->contents
);
2781 bfd_put_32 (output_bfd
,
2782 sdyn
->output_section
->vma
+ sdyn
->output_offset
,
2786 elf_section_data (sgot
->output_section
)->this_hdr
.sh_entsize
= 4;
2791 /* Given a .data.rel section and a .emreloc in-memory section, store
2792 relocation information into the .emreloc section which can be
2793 used at runtime to relocate the section. This is called by the
2794 linker when the --embedded-relocs switch is used. This is called
2795 after the add_symbols entry point has been called for all the
2796 objects, and before the final_link entry point is called. */
2799 bfd_cr16_elf32_create_embedded_relocs (bfd
*abfd
,
2800 struct bfd_link_info
*info
,
2805 Elf_Internal_Shdr
*symtab_hdr
;
2806 Elf_Internal_Sym
*isymbuf
= NULL
;
2807 Elf_Internal_Rela
*internal_relocs
= NULL
;
2808 Elf_Internal_Rela
*irel
, *irelend
;
2812 BFD_ASSERT (! info
->relocatable
);
2816 if (datasec
->reloc_count
== 0)
2819 symtab_hdr
= &elf_tdata (abfd
)->symtab_hdr
;
2821 /* Get a copy of the native relocations. */
2822 internal_relocs
= (_bfd_elf_link_read_relocs
2823 (abfd
, datasec
, NULL
, NULL
, info
->keep_memory
));
2824 if (internal_relocs
== NULL
)
2827 amt
= (bfd_size_type
) datasec
->reloc_count
* 8;
2828 relsec
->contents
= (bfd_byte
*) bfd_alloc (abfd
, amt
);
2829 if (relsec
->contents
== NULL
)
2832 p
= relsec
->contents
;
2834 irelend
= internal_relocs
+ datasec
->reloc_count
;
2835 for (irel
= internal_relocs
; irel
< irelend
; irel
++, p
+= 8)
2837 asection
*targetsec
;
2839 /* We are going to write a four byte longword into the runtime
2840 reloc section. The longword will be the address in the data
2841 section which must be relocated. It is followed by the name
2842 of the target section NUL-padded or truncated to 8
2845 /* We can only relocate absolute longword relocs at run time. */
2846 if (!((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2847 || (ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32
)))
2849 *errmsg
= _("unsupported reloc type");
2850 bfd_set_error (bfd_error_bad_value
);
2854 /* Get the target section referred to by the reloc. */
2855 if (ELF32_R_SYM (irel
->r_info
) < symtab_hdr
->sh_info
)
2857 /* A local symbol. */
2858 Elf_Internal_Sym
*isym
;
2860 /* Read this BFD's local symbols if we haven't done so already. */
2861 if (isymbuf
== NULL
)
2863 isymbuf
= (Elf_Internal_Sym
*) symtab_hdr
->contents
;
2864 if (isymbuf
== NULL
)
2865 isymbuf
= bfd_elf_get_elf_syms (abfd
, symtab_hdr
,
2866 symtab_hdr
->sh_info
, 0,
2868 if (isymbuf
== NULL
)
2872 isym
= isymbuf
+ ELF32_R_SYM (irel
->r_info
);
2873 targetsec
= bfd_section_from_elf_index (abfd
, isym
->st_shndx
);
2878 struct elf_link_hash_entry
*h
;
2880 /* An external symbol. */
2881 indx
= ELF32_R_SYM (irel
->r_info
) - symtab_hdr
->sh_info
;
2882 h
= elf_sym_hashes (abfd
)[indx
];
2883 BFD_ASSERT (h
!= NULL
);
2884 if (h
->root
.type
== bfd_link_hash_defined
2885 || h
->root
.type
== bfd_link_hash_defweak
)
2886 targetsec
= h
->root
.u
.def
.section
;
2891 bfd_put_32 (abfd
, irel
->r_offset
+ datasec
->output_offset
, p
);
2892 memset (p
+ 4, 0, 4);
2893 if ((ELF32_R_TYPE (irel
->r_info
) == (int) R_CR16_NUM32a
)
2894 && (targetsec
!= NULL
) )
2895 strncpy ((char *) p
+ 4, targetsec
->output_section
->name
, 4);
2898 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2900 if (internal_relocs
!= NULL
2901 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2902 free (internal_relocs
);
2906 if (isymbuf
!= NULL
&& symtab_hdr
->contents
!= (unsigned char *) isymbuf
)
2908 if (internal_relocs
!= NULL
2909 && elf_section_data (datasec
)->relocs
!= internal_relocs
)
2910 free (internal_relocs
);
2915 /* Classify relocation types, such that combreloc can sort them
2918 static enum elf_reloc_type_class
2919 _bfd_cr16_elf_reloc_type_class (const struct bfd_link_info
*info ATTRIBUTE_UNUSED
,
2920 const asection
*rel_sec ATTRIBUTE_UNUSED
,
2921 const Elf_Internal_Rela
*rela
)
2923 switch ((int) ELF32_R_TYPE (rela
->r_info
))
2925 case R_CR16_GOT_REGREL20
:
2926 case R_CR16_GOTC_REGREL20
:
2927 return reloc_class_relative
;
2929 return reloc_class_normal
;
2933 /* Definitions for setting CR16 target vector. */
2934 #define TARGET_LITTLE_SYM bfd_elf32_cr16_vec
2935 #define TARGET_LITTLE_NAME "elf32-cr16"
2936 #define ELF_ARCH bfd_arch_cr16
2937 #define ELF_MACHINE_CODE EM_CR16
2938 #define ELF_MACHINE_ALT1 EM_CR16_OLD
2939 #define ELF_MAXPAGESIZE 0x1
2940 #define elf_symbol_leading_char '_'
2942 #define bfd_elf32_bfd_reloc_type_lookup elf_cr16_reloc_type_lookup
2943 #define bfd_elf32_bfd_reloc_name_lookup elf_cr16_reloc_name_lookup
2944 #define elf_info_to_howto elf_cr16_info_to_howto
2945 #define elf_info_to_howto_rel 0
2946 #define elf_backend_relocate_section elf32_cr16_relocate_section
2947 #define bfd_elf32_bfd_relax_section elf32_cr16_relax_section
2948 #define bfd_elf32_bfd_get_relocated_section_contents \
2949 elf32_cr16_get_relocated_section_contents
2950 #define elf_backend_gc_mark_hook elf32_cr16_gc_mark_hook
2951 #define elf_backend_gc_sweep_hook elf32_cr16_gc_sweep_hook
2952 #define elf_backend_can_gc_sections 1
2953 #define elf_backend_rela_normal 1
2954 #define elf_backend_check_relocs cr16_elf_check_relocs
2955 /* So we can set bits in e_flags. */
2956 #define elf_backend_final_write_processing \
2957 _bfd_cr16_elf_final_write_processing
2958 #define elf_backend_object_p _bfd_cr16_elf_object_p
2960 #define bfd_elf32_bfd_merge_private_bfd_data \
2961 _bfd_cr16_elf_merge_private_bfd_data
2964 #define bfd_elf32_bfd_link_hash_table_create \
2965 elf32_cr16_link_hash_table_create
2967 #define elf_backend_create_dynamic_sections \
2968 _bfd_cr16_elf_create_dynamic_sections
2969 #define elf_backend_adjust_dynamic_symbol \
2970 _bfd_cr16_elf_adjust_dynamic_symbol
2971 #define elf_backend_size_dynamic_sections \
2972 _bfd_cr16_elf_size_dynamic_sections
2973 #define elf_backend_omit_section_dynsym \
2974 ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2975 #define elf_backend_finish_dynamic_symbol \
2976 _bfd_cr16_elf_finish_dynamic_symbol
2977 #define elf_backend_finish_dynamic_sections \
2978 _bfd_cr16_elf_finish_dynamic_sections
2980 #define elf_backend_reloc_type_class _bfd_cr16_elf_reloc_type_class
2983 #define elf_backend_want_got_plt 1
2984 #define elf_backend_plt_readonly 1
2985 #define elf_backend_want_plt_sym 0
2986 #define elf_backend_got_header_size 12
2988 #include "elf32-target.h"