1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005-2021 Free Software Foundation, Inc.
3
4 This file is part of BFD, the Binary File Descriptor library.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19 MA 02110-1301, USA. */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/m32c.h"
26 #include "libiberty.h"
27
28 /* Forward declarations. */
29 static reloc_howto_type * m32c_reloc_type_lookup
30 (bfd *, bfd_reloc_code_real_type);
31 static bool m32c_info_to_howto_rela
32 (bfd *, arelent *, Elf_Internal_Rela *);
33 static int m32c_elf_relocate_section
34 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
35 static bool m32c_elf_check_relocs
36 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
37 static bool m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
38 #ifdef DEBUG
39 char * m32c_get_reloc (long reloc);
40 void dump_symtab (bfd *, void *, void *);
41 #endif
42 static bool m32c_elf_relax_section
43 (bfd *abfd, asection *sec, struct bfd_link_info *link_info, bool *again);
44 static bfd_reloc_status_type m32c_apply_reloc_24
45 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
46
47
48 static reloc_howto_type m32c_elf_howto_table [] =
49 {
50 /* This reloc does nothing. */
51 HOWTO (R_M32C_NONE, /* type */
52 0, /* rightshift */
53 3, /* size (0 = byte, 1 = short, 2 = long) */
54 0, /* bitsize */
55 false, /* pc_relative */
56 0, /* bitpos */
57 complain_overflow_dont, /* complain_on_overflow */
58 bfd_elf_generic_reloc, /* special_function */
59 "R_M32C_NONE", /* name */
60 false, /* partial_inplace */
61 0, /* src_mask */
62 0, /* dst_mask */
63 false), /* pcrel_offset */
64
65 /* GCC intentionally overflows these next two in order to work
66 around limitations in the addressing modes, so don't complain
67 about overflow. */
68 HOWTO (R_M32C_16, /* type */
69 0, /* rightshift */
70 1, /* size (0 = byte, 1 = short, 2 = long) */
71 16, /* bitsize */
72 false, /* pc_relative */
73 0, /* bitpos */
74 complain_overflow_dont, /* complain_on_overflow */
75 bfd_elf_generic_reloc, /* special_function */
76 "R_M32C_16", /* name */
77 false, /* partial_inplace */
78 0, /* src_mask */
79 0xffff, /* dst_mask */
80 false), /* pcrel_offset */
81
82 HOWTO (R_M32C_24, /* type */
83 0, /* rightshift */
84 2, /* size (0 = byte, 1 = short, 2 = long) */
85 24, /* bitsize */
86 false, /* pc_relative */
87 0, /* bitpos */
88 complain_overflow_dont, /* complain_on_overflow */
89 m32c_apply_reloc_24, /* special_function */
90 "R_M32C_24", /* name */
91 false, /* partial_inplace */
92 0, /* src_mask */
93 0xffffff, /* dst_mask */
94 false), /* pcrel_offset */
95
96 HOWTO (R_M32C_32, /* type */
97 0, /* rightshift */
98 2, /* size (0 = byte, 1 = short, 2 = long) */
99 32, /* bitsize */
100 false, /* pc_relative */
101 0, /* bitpos */
102 complain_overflow_bitfield, /* complain_on_overflow */
103 bfd_elf_generic_reloc, /* special_function */
104 "R_M32C_32", /* name */
105 false, /* partial_inplace */
106 0, /* src_mask */
107 0xffffffff, /* dst_mask */
108 false), /* pcrel_offset */
109
110 HOWTO (R_M32C_8_PCREL, /* type */
111 0, /* rightshift */
112 0, /* size (0 = byte, 1 = short, 2 = long) */
113 8, /* bitsize */
114 true, /* pc_relative */
115 0, /* bitpos */
116 complain_overflow_signed, /* complain_on_overflow */
117 bfd_elf_generic_reloc, /* special_function */
118 "R_M32C_8_PCREL", /* name */
119 false, /* partial_inplace */
120 0, /* src_mask */
121 0xff, /* dst_mask */
122 true), /* pcrel_offset */
123
124 HOWTO (R_M32C_16_PCREL, /* type */
125 0, /* rightshift */
126 1, /* size (0 = byte, 1 = short, 2 = long) */
127 16, /* bitsize */
128 true, /* pc_relative */
129 0, /* bitpos */
130 complain_overflow_signed, /* complain_on_overflow */
131 bfd_elf_generic_reloc, /* special_function */
132 "R_M32C_16_PCREL", /* name */
133 false, /* partial_inplace */
134 0, /* src_mask */
135 0xffff, /* dst_mask */
136 true), /* pcrel_offset */
137
138 HOWTO (R_M32C_8, /* type */
139 0, /* rightshift */
140 0, /* size (0 = byte, 1 = short, 2 = long) */
141 8, /* bitsize */
142 false, /* pc_relative */
143 0, /* bitpos */
144 complain_overflow_unsigned, /* complain_on_overflow */
145 bfd_elf_generic_reloc, /* special_function */
146 "R_M32C_8", /* name */
147 false, /* partial_inplace */
148 0, /* src_mask */
149 0xff, /* dst_mask */
150 false), /* pcrel_offset */
151
152 HOWTO (R_M32C_LO16, /* type */
153 0, /* rightshift */
154 1, /* size (0 = byte, 1 = short, 2 = long) */
155 16, /* bitsize */
156 false, /* pc_relative */
157 0, /* bitpos */
158 complain_overflow_dont, /* complain_on_overflow */
159 bfd_elf_generic_reloc, /* special_function */
160 "R_M32C_LO16", /* name */
161 false, /* partial_inplace */
162 0, /* src_mask */
163 0xffff, /* dst_mask */
164 false), /* pcrel_offset */
165
166 HOWTO (R_M32C_HI8, /* type */
167 0, /* rightshift */
168 0, /* size (0 = byte, 1 = short, 2 = long) */
169 8, /* bitsize */
170 false, /* pc_relative */
171 0, /* bitpos */
172 complain_overflow_dont, /* complain_on_overflow */
173 bfd_elf_generic_reloc, /* special_function */
174 "R_M32C_HI8", /* name */
175 false, /* partial_inplace */
176 0, /* src_mask */
177 0xff, /* dst_mask */
178 false), /* pcrel_offset */
179
180 HOWTO (R_M32C_HI16, /* type */
181 0, /* rightshift */
182 1, /* size (0 = byte, 1 = short, 2 = long) */
183 16, /* bitsize */
184 false, /* pc_relative */
185 0, /* bitpos */
186 complain_overflow_dont, /* complain_on_overflow */
187 bfd_elf_generic_reloc, /* special_function */
188 "R_M32C_HI16", /* name */
189 false, /* partial_inplace */
190 0, /* src_mask */
191 0xffff, /* dst_mask */
192 false), /* pcrel_offset */
193
194 HOWTO (R_M32C_RL_JUMP, /* type */
195 0, /* rightshift */
196 0, /* size (0 = byte, 1 = short, 2 = long) */
197 0, /* bitsize */
198 false, /* pc_relative */
199 0, /* bitpos */
200 complain_overflow_signed, /* complain_on_overflow */
201 bfd_elf_generic_reloc, /* special_function */
202 "R_M32C_RL_JUMP", /* name */
203 false, /* partial_inplace */
204 0, /* src_mask */
205 0, /* dst_mask */
206 false), /* pcrel_offset */
207
208 HOWTO (R_M32C_RL_1ADDR, /* type */
209 0, /* rightshift */
210 0, /* size (0 = byte, 1 = short, 2 = long) */
211 0, /* bitsize */
212 false, /* pc_relative */
213 0, /* bitpos */
214 complain_overflow_signed, /* complain_on_overflow */
215 bfd_elf_generic_reloc, /* special_function */
216 "R_M32C_RL_1ADDR", /* name */
217 false, /* partial_inplace */
218 0, /* src_mask */
219 0, /* dst_mask */
220 false), /* pcrel_offset */
221
222 HOWTO (R_M32C_RL_2ADDR, /* type */
223 0, /* rightshift */
224 0, /* size (0 = byte, 1 = short, 2 = long) */
225 0, /* bitsize */
226 false, /* pc_relative */
227 0, /* bitpos */
228 complain_overflow_signed, /* complain_on_overflow */
229 bfd_elf_generic_reloc, /* special_function */
230 "R_M32C_RL_2ADDR", /* name */
231 false, /* partial_inplace */
232 0, /* src_mask */
233 0, /* dst_mask */
234 false), /* pcrel_offset */
235
236 };
237
238 /* Map BFD reloc types to M32C ELF reloc types. */
239
240 struct m32c_reloc_map
241 {
242 bfd_reloc_code_real_type bfd_reloc_val;
243 unsigned int m32c_reloc_val;
244 };
245
246 static const struct m32c_reloc_map m32c_reloc_map [] =
247 {
248 { BFD_RELOC_NONE, R_M32C_NONE },
249 { BFD_RELOC_16, R_M32C_16 },
250 { BFD_RELOC_24, R_M32C_24 },
251 { BFD_RELOC_32, R_M32C_32 },
252 { BFD_RELOC_8_PCREL, R_M32C_8_PCREL },
253 { BFD_RELOC_16_PCREL, R_M32C_16_PCREL },
254 { BFD_RELOC_8, R_M32C_8 },
255 { BFD_RELOC_LO16, R_M32C_LO16 },
256 { BFD_RELOC_HI16, R_M32C_HI16 },
257 { BFD_RELOC_M32C_HI8, R_M32C_HI8 },
258 { BFD_RELOC_M32C_RL_JUMP, R_M32C_RL_JUMP },
259 { BFD_RELOC_M32C_RL_1ADDR, R_M32C_RL_1ADDR },
260 { BFD_RELOC_M32C_RL_2ADDR, R_M32C_RL_2ADDR }
261 };
262
263 static reloc_howto_type *
m32c_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)264 m32c_reloc_type_lookup
265 (bfd * abfd ATTRIBUTE_UNUSED,
266 bfd_reloc_code_real_type code)
267 {
268 unsigned int i;
269
270 for (i = ARRAY_SIZE (m32c_reloc_map); i--;)
271 if (m32c_reloc_map [i].bfd_reloc_val == code)
272 return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
273
274 return NULL;
275 }
276
277 static reloc_howto_type *
m32c_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)278 m32c_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
279 {
280 unsigned int i;
281
282 for (i = 0;
283 i < sizeof (m32c_elf_howto_table) / sizeof (m32c_elf_howto_table[0]);
284 i++)
285 if (m32c_elf_howto_table[i].name != NULL
286 && strcasecmp (m32c_elf_howto_table[i].name, r_name) == 0)
287 return &m32c_elf_howto_table[i];
288
289 return NULL;
290 }
291
292 /* Set the howto pointer for an M32C ELF reloc. */
293
294 static bool
m32c_info_to_howto_rela(bfd * abfd,arelent * cache_ptr,Elf_Internal_Rela * dst)295 m32c_info_to_howto_rela (bfd * abfd,
296 arelent * cache_ptr,
297 Elf_Internal_Rela * dst)
298 {
299 unsigned int r_type;
300
301 r_type = ELF32_R_TYPE (dst->r_info);
302 if (r_type >= (unsigned int) R_M32C_max)
303 {
304 /* xgettext:c-format */
305 _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
306 abfd, r_type);
307 bfd_set_error (bfd_error_bad_value);
308 return false;
309 }
310 cache_ptr->howto = & m32c_elf_howto_table [r_type];
311 return true;
312 }
313
314
315
316 /* Apply R_M32C_24 relocations. We have to do this because it's not a
317 power-of-two size, and the generic code may think it overruns the
318 section if it's right at the end.
319
320 Must return something other than bfd_reloc_continue to avoid the
321 above problem. Typical return values include bfd_reloc_ok or
322 bfd_reloc_overflow.
323 */
324
m32c_apply_reloc_24(bfd * abfd ATTRIBUTE_UNUSED,arelent * reloc_entry,asymbol * symbol,void * vdata_start ATTRIBUTE_UNUSED,asection * input_section,bfd * ibfd ATTRIBUTE_UNUSED,char ** error_msg ATTRIBUTE_UNUSED)325 static bfd_reloc_status_type m32c_apply_reloc_24 (bfd *abfd ATTRIBUTE_UNUSED,
326 arelent *reloc_entry,
327 asymbol *symbol,
328 void *vdata_start ATTRIBUTE_UNUSED,
329 asection *input_section,
330 bfd *ibfd ATTRIBUTE_UNUSED,
331 char **error_msg ATTRIBUTE_UNUSED)
332 {
333 bfd_vma relocation;
334 bfd_reloc_status_type s;
335
336 s = bfd_elf_generic_reloc (abfd, reloc_entry, symbol,
337 vdata_start,
338 input_section, ibfd, error_msg);
339 if (s != bfd_reloc_continue)
340 return s;
341
342 /* Get symbol value. (Common symbols are special.) */
343 if (bfd_is_com_section (symbol->section))
344 relocation = 0;
345 else
346 relocation = symbol->value;
347
348 relocation += symbol->section->output_offset;
349
350 /* Add in supplied addend. */
351 relocation += reloc_entry->addend;
352
353 reloc_entry->addend = relocation;
354 reloc_entry->address += input_section->output_offset;
355 return bfd_reloc_ok;
356 }
357
358 /* Relocate an M32C ELF section.
359 There is some attempt to make this function usable for many architectures,
360 both USE_REL and USE_RELA ['twould be nice if such a critter existed],
361 if only to serve as a learning tool.
362
363 The RELOCATE_SECTION function is called by the new ELF backend linker
364 to handle the relocations for a section.
365
366 The relocs are always passed as Rela structures; if the section
367 actually uses Rel structures, the r_addend field will always be
368 zero.
369
370 This function is responsible for adjusting the section contents as
371 necessary, and (if using Rela relocs and generating a relocatable
372 output file) adjusting the reloc addend as necessary.
373
374 This function does not have to worry about setting the reloc
375 address or the reloc symbol index.
376
377 LOCAL_SYMS is a pointer to the swapped in local symbols.
378
379 LOCAL_SECTIONS is an array giving the section in the input file
380 corresponding to the st_shndx field of each local symbol.
381
382 The global hash table entry for the global symbols can be found
383 via elf_sym_hashes (input_bfd).
384
385 When generating relocatable output, this function must handle
386 STB_LOCAL/STT_SECTION symbols specially. The output symbol is
387 going to be the section symbol corresponding to the output
388 section, which means that the addend must be adjusted
389 accordingly. */
390
391 static int
m32c_elf_relocate_section(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)392 m32c_elf_relocate_section
393 (bfd * output_bfd ATTRIBUTE_UNUSED,
394 struct bfd_link_info * info,
395 bfd * input_bfd,
396 asection * input_section,
397 bfd_byte * contents,
398 Elf_Internal_Rela * relocs,
399 Elf_Internal_Sym * local_syms,
400 asection ** local_sections)
401 {
402 Elf_Internal_Shdr * symtab_hdr;
403 struct elf_link_hash_entry ** sym_hashes;
404 Elf_Internal_Rela * rel;
405 Elf_Internal_Rela * relend;
406 asection *splt;
407
408 symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
409 sym_hashes = elf_sym_hashes (input_bfd);
410 relend = relocs + input_section->reloc_count;
411
412 splt = elf_hash_table (info)->splt;
413
414 for (rel = relocs; rel < relend; rel ++)
415 {
416 reloc_howto_type * howto;
417 unsigned long r_symndx;
418 Elf_Internal_Sym * sym;
419 asection * sec;
420 struct elf_link_hash_entry * h;
421 bfd_vma relocation;
422 bfd_reloc_status_type r;
423 const char * name = NULL;
424 int r_type;
425
426 r_type = ELF32_R_TYPE (rel->r_info);
427
428 /* These are only used for relaxing; we don't actually relocate
429 anything with them, so skip them. */
430 if (r_type == R_M32C_RL_JUMP
431 || r_type == R_M32C_RL_1ADDR
432 || r_type == R_M32C_RL_2ADDR)
433 continue;
434
435 r_symndx = ELF32_R_SYM (rel->r_info);
436
437 howto = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
438 h = NULL;
439 sym = NULL;
440 sec = NULL;
441 relocation = 0;
442
443 if (r_symndx < symtab_hdr->sh_info)
444 {
445 sym = local_syms + r_symndx;
446 sec = local_sections [r_symndx];
447 relocation = (sec->output_section->vma
448 + sec->output_offset
449 + sym->st_value);
450
451 name = bfd_elf_string_from_elf_section
452 (input_bfd, symtab_hdr->sh_link, sym->st_name);
453 name = sym->st_name == 0 ? bfd_section_name (sec) : name;
454 }
455 else
456 {
457 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
458
459 if (info->wrap_hash != NULL
460 && (input_section->flags & SEC_DEBUGGING) != 0)
461 h = ((struct elf_link_hash_entry *)
462 unwrap_hash_lookup (info, input_bfd, &h->root));
463
464 while (h->root.type == bfd_link_hash_indirect
465 || h->root.type == bfd_link_hash_warning)
466 h = (struct elf_link_hash_entry *) h->root.u.i.link;
467
468 name = h->root.root.string;
469
470 if (h->root.type == bfd_link_hash_defined
471 || h->root.type == bfd_link_hash_defweak)
472 {
473 sec = h->root.u.def.section;
474 relocation = (h->root.u.def.value
475 + sec->output_section->vma
476 + sec->output_offset);
477 }
478 else if (h->root.type == bfd_link_hash_undefweak)
479 ;
480 else if (!bfd_link_relocatable (info))
481 (*info->callbacks->undefined_symbol) (info, h->root.root.string,
482 input_bfd, input_section,
483 rel->r_offset, true);
484 }
485
486 if (sec != NULL && discarded_section (sec))
487 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
488 rel, 1, relend, howto, 0, contents);
489
490 if (bfd_link_relocatable (info))
491 {
492 /* This is a relocatable link. We don't have to change
493 anything, unless the reloc is against a section symbol,
494 in which case we have to adjust according to where the
495 section symbol winds up in the output section. */
496 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
497 rel->r_addend += sec->output_offset;
498 continue;
499 }
500
501 switch (ELF32_R_TYPE (rel->r_info))
502 {
503 case R_M32C_16:
504 {
505 bfd_vma *plt_offset;
506
507 if (h != NULL)
508 plt_offset = &h->plt.offset;
509 else
510 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
511
512 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
513 relocation, *plt_offset);*/
514 if (relocation <= 0xffff)
515 {
516 /* If the symbol is in range for a 16-bit address, we should
517 have deallocated the plt entry in relax_section. */
518 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
519 }
520 else
521 {
522 /* If the symbol is out of range for a 16-bit address,
523 we must have allocated a plt entry. */
524 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
525
526 /* If this is the first time we've processed this symbol,
527 fill in the plt entry with the correct symbol address. */
528 if ((*plt_offset & 1) == 0)
529 {
530 unsigned int x;
531
532 x = 0x000000fc; /* jmpf */
533 x |= (relocation << 8) & 0xffffff00;
534 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
535 *plt_offset |= 1;
536 }
537
538 relocation = (splt->output_section->vma
539 + splt->output_offset
540 + (*plt_offset & -2));
541 if (name)
542 {
543 char *newname = bfd_malloc (strlen(name)+5);
544 strcpy (newname, name);
545 strcat(newname, ".plt");
546 _bfd_generic_link_add_one_symbol (info,
547 input_bfd,
548 newname,
549 BSF_FUNCTION | BSF_WEAK,
550 splt,
551 (*plt_offset & -2),
552 0,
553 1,
554 0,
555 0);
556 }
557 }
558 }
559 break;
560
561 case R_M32C_HI8:
562 case R_M32C_HI16:
563 relocation >>= 16;
564 break;
565 }
566
567 #if 0
568 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
569 m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name,
570 rel->r_offset + input_section->output_section->vma + input_section->output_offset,
571 relocation, rel->r_addend);
572 {
573 int i;
574 for (i=0; i<4; i++)
575 printf (" %02x", contents[rel->r_offset+i]);
576 printf ("\n");
577 }
578 #endif
579 switch (ELF32_R_TYPE(rel->r_info))
580 {
581 case R_M32C_24:
582 /* Like m32c_apply_reloc_24, we must handle this one separately. */
583 relocation += rel->r_addend;
584
585 /* Sanity check the address. */
586 if (rel->r_offset + 3
587 > bfd_get_section_limit_octets (input_bfd, input_section))
588 r = bfd_reloc_outofrange;
589 else
590 {
591 bfd_put_8 (input_bfd, relocation & 0xff, contents + rel->r_offset);
592 bfd_put_8 (input_bfd, (relocation >> 8) & 0xff, contents + rel->r_offset + 1);
593 bfd_put_8 (input_bfd, (relocation >> 16) & 0xff, contents + rel->r_offset + 2);
594 r = bfd_reloc_ok;
595 }
596
597 break;
598
599 default:
600 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
601 contents, rel->r_offset, relocation,
602 rel->r_addend);
603 break;
604 }
605
606 if (r != bfd_reloc_ok)
607 {
608 const char * msg = (const char *) NULL;
609
610 switch (r)
611 {
612 case bfd_reloc_overflow:
613 (*info->callbacks->reloc_overflow)
614 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
615 input_bfd, input_section, rel->r_offset);
616 break;
617
618 case bfd_reloc_undefined:
619 (*info->callbacks->undefined_symbol)
620 (info, name, input_bfd, input_section, rel->r_offset, true);
621 break;
622
623 case bfd_reloc_outofrange:
624 msg = _("internal error: out of range error");
625 break;
626
627 case bfd_reloc_notsupported:
628 msg = _("internal error: unsupported relocation error");
629 break;
630
631 case bfd_reloc_dangerous:
632 msg = _("internal error: dangerous relocation");
633 break;
634
635 default:
636 msg = _("internal error: unknown error");
637 break;
638 }
639
640 if (msg)
641 (*info->callbacks->warning) (info, msg, name, input_bfd,
642 input_section, rel->r_offset);
643 }
644 }
645
646 return true;
647 }
648
649 /* We support 16-bit pointers to code above 64k by generating a thunk
650 below 64k containing a JMP instruction to the final address. */
651
652 static bool
m32c_elf_check_relocs(bfd * abfd,struct bfd_link_info * info,asection * sec,const Elf_Internal_Rela * relocs)653 m32c_elf_check_relocs
654 (bfd * abfd,
655 struct bfd_link_info * info,
656 asection * sec,
657 const Elf_Internal_Rela * relocs)
658 {
659 Elf_Internal_Shdr * symtab_hdr;
660 struct elf_link_hash_entry ** sym_hashes;
661 const Elf_Internal_Rela * rel;
662 const Elf_Internal_Rela * rel_end;
663 bfd_vma *local_plt_offsets;
664 asection *splt;
665 bfd *dynobj;
666
667 if (bfd_link_relocatable (info))
668 return true;
669
670 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
671 sym_hashes = elf_sym_hashes (abfd);
672 local_plt_offsets = elf_local_got_offsets (abfd);
673 splt = NULL;
674 dynobj = elf_hash_table(info)->dynobj;
675
676 rel_end = relocs + sec->reloc_count;
677 for (rel = relocs; rel < rel_end; rel++)
678 {
679 struct elf_link_hash_entry *h;
680 unsigned long r_symndx;
681 bfd_vma *offset;
682
683 r_symndx = ELF32_R_SYM (rel->r_info);
684 if (r_symndx < symtab_hdr->sh_info)
685 h = NULL;
686 else
687 {
688 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
689 while (h->root.type == bfd_link_hash_indirect
690 || h->root.type == bfd_link_hash_warning)
691 h = (struct elf_link_hash_entry *) h->root.u.i.link;
692 }
693
694 switch (ELF32_R_TYPE (rel->r_info))
695 {
696 /* This relocation describes a 16-bit pointer to a function.
697 We may need to allocate a thunk in low memory; reserve memory
698 for it now. */
699 case R_M32C_16:
700 if (dynobj == NULL)
701 elf_hash_table (info)->dynobj = dynobj = abfd;
702 splt = elf_hash_table (info)->splt;
703 if (splt == NULL)
704 {
705 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
706 | SEC_IN_MEMORY | SEC_LINKER_CREATED
707 | SEC_READONLY | SEC_CODE);
708 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
709 flags);
710 elf_hash_table (info)->splt = splt;
711 if (splt == NULL
712 || !bfd_set_section_alignment (splt, 1))
713 return false;
714 }
715
716 if (h != NULL)
717 offset = &h->plt.offset;
718 else
719 {
720 if (local_plt_offsets == NULL)
721 {
722 size_t size;
723 unsigned int i;
724
725 size = symtab_hdr->sh_info * sizeof (bfd_vma);
726 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
727 if (local_plt_offsets == NULL)
728 return false;
729 elf_local_got_offsets (abfd) = local_plt_offsets;
730
731 for (i = 0; i < symtab_hdr->sh_info; i++)
732 local_plt_offsets[i] = (bfd_vma) -1;
733 }
734 offset = &local_plt_offsets[r_symndx];
735 }
736
737 if (*offset == (bfd_vma) -1)
738 {
739 *offset = splt->size;
740 splt->size += 4;
741 }
742 break;
743 }
744 }
745
746 return true;
747 }
748
749 /* This must exist if dynobj is ever set. */
750
751 static bool
m32c_elf_finish_dynamic_sections(bfd * abfd ATTRIBUTE_UNUSED,struct bfd_link_info * info)752 m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
753 struct bfd_link_info *info)
754 {
755 bfd *dynobj = elf_hash_table (info)->dynobj;
756 asection *splt = elf_hash_table (info)->splt;
757
758 /* As an extra sanity check, verify that all plt entries have
759 been filled in. */
760
761 if (dynobj != NULL && splt != NULL)
762 {
763 bfd_byte *contents = splt->contents;
764 unsigned int i, size = splt->size;
765 for (i = 0; i < size; i += 4)
766 {
767 unsigned int x = bfd_get_32 (dynobj, contents + i);
768 BFD_ASSERT (x != 0);
769 }
770 }
771
772 return true;
773 }
774
775 static bool
m32c_elf_always_size_sections(bfd * output_bfd ATTRIBUTE_UNUSED,struct bfd_link_info * info)776 m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
777 struct bfd_link_info *info)
778 {
779 bfd *dynobj;
780 asection *splt;
781
782 if (bfd_link_relocatable (info))
783 return true;
784
785 dynobj = elf_hash_table (info)->dynobj;
786 if (dynobj == NULL)
787 return true;
788
789 splt = elf_hash_table (info)->splt;
790 BFD_ASSERT (splt != NULL);
791
792 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
793 if (splt->contents == NULL)
794 return false;
795
796 return true;
797 }
798
799 /* Function to set the ELF flag bits. */
800
801 static bool
m32c_elf_set_private_flags(bfd * abfd,flagword flags)802 m32c_elf_set_private_flags (bfd *abfd, flagword flags)
803 {
804 elf_elfheader (abfd)->e_flags = flags;
805 elf_flags_init (abfd) = true;
806 return true;
807 }
808
809 /* Merge backend specific data from an object file to the output
810 object file when linking. */
811
812 static bool
m32c_elf_merge_private_bfd_data(bfd * ibfd,struct bfd_link_info * info)813 m32c_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
814 {
815 bfd *obfd = info->output_bfd;
816 flagword old_flags, old_partial;
817 flagword new_flags, new_partial;
818 bool error = false;
819 char new_opt[80];
820 char old_opt[80];
821
822 new_opt[0] = old_opt[0] = '\0';
823 new_flags = elf_elfheader (ibfd)->e_flags;
824 old_flags = elf_elfheader (obfd)->e_flags;
825
826 #ifdef DEBUG
827 _bfd_error_handler
828 ("old_flags = 0x%.8x, new_flags = 0x%.8x, init = %s, filename = %s",
829 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
830 bfd_get_filename (ibfd));
831 #endif
832
833 if (!elf_flags_init (obfd))
834 {
835 /* First call, no flags set. */
836 elf_flags_init (obfd) = true;
837 elf_elfheader (obfd)->e_flags = new_flags;
838 }
839
840 else if (new_flags == old_flags)
841 /* Compatible flags are ok. */
842 ;
843
844 else /* Possibly incompatible flags. */
845 {
846 /* Warn if different cpu is used (allow a specific cpu to override
847 the generic cpu). */
848 new_partial = (new_flags & EF_M32C_CPU_MASK);
849 old_partial = (old_flags & EF_M32C_CPU_MASK);
850 if (new_partial == old_partial)
851 ;
852
853 else
854 {
855 switch (new_partial)
856 {
857 default: strcat (new_opt, " -m16c"); break;
858 case EF_M32C_CPU_M16C: strcat (new_opt, " -m16c"); break;
859 case EF_M32C_CPU_M32C: strcat (new_opt, " -m32c"); break;
860 }
861
862 switch (old_partial)
863 {
864 default: strcat (old_opt, " -m16c"); break;
865 case EF_M32C_CPU_M16C: strcat (old_opt, " -m16c"); break;
866 case EF_M32C_CPU_M32C: strcat (old_opt, " -m32c"); break;
867 }
868 }
869
870 /* Print out any mismatches from above. */
871 if (new_opt[0])
872 {
873 error = true;
874 _bfd_error_handler
875 /* xgettext:c-format */
876 (_("%pB: compiled with %s and linked with modules compiled with %s"),
877 ibfd, new_opt, old_opt);
878 }
879
880 new_flags &= ~ EF_M32C_ALL_FLAGS;
881 old_flags &= ~ EF_M32C_ALL_FLAGS;
882
883 /* Warn about any other mismatches. */
884 if (new_flags != old_flags)
885 {
886 error = true;
887 _bfd_error_handler
888 /* xgettext:c-format */
889 (_("%pB: uses different e_flags (%#x) fields"
890 " than previous modules (%#x)"),
891 ibfd, new_flags, old_flags);
892 }
893 }
894
895 if (error)
896 bfd_set_error (bfd_error_bad_value);
897
898 return !error;
899 }
900
901
902 static bool
m32c_elf_print_private_bfd_data(bfd * abfd,void * ptr)903 m32c_elf_print_private_bfd_data (bfd *abfd, void *ptr)
904 {
905 FILE *file = (FILE *) ptr;
906 flagword flags;
907
908 BFD_ASSERT (abfd != NULL && ptr != NULL);
909
910 /* Print normal ELF private data. */
911 _bfd_elf_print_private_bfd_data (abfd, ptr);
912
913 flags = elf_elfheader (abfd)->e_flags;
914 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
915
916 switch (flags & EF_M32C_CPU_MASK)
917 {
918 default: break;
919 case EF_M32C_CPU_M16C: fprintf (file, " -m16c"); break;
920 case EF_M32C_CPU_M32C: fprintf (file, " -m32c"); break;
921 }
922
923 fputc ('\n', file);
924 return true;
925 }
926
927 /* Return the MACH for an e_flags value. */
928
929 static int
elf32_m32c_machine(bfd * abfd)930 elf32_m32c_machine (bfd *abfd)
931 {
932 switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
933 {
934 case EF_M32C_CPU_M16C: return bfd_mach_m16c;
935 case EF_M32C_CPU_M32C: return bfd_mach_m32c;
936 }
937
938 return bfd_mach_m16c;
939 }
940
941 static bool
m32c_elf_object_p(bfd * abfd)942 m32c_elf_object_p (bfd *abfd)
943 {
944 bfd_default_set_arch_mach (abfd, bfd_arch_m32c,
945 elf32_m32c_machine (abfd));
946 return true;
947 }
948
949
950 #ifdef DEBUG
951 void
dump_symtab(bfd * abfd,void * internal_syms,void * external_syms)952 dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
953 {
954 size_t locsymcount;
955 Elf_Internal_Sym *isymbuf;
956 Elf_Internal_Sym *isymend;
957 Elf_Internal_Sym *isym;
958 Elf_Internal_Shdr *symtab_hdr;
959 bool free_internal = 0, free_external = 0;
960 char * st_info_str;
961 char * st_info_stb_str;
962 char * st_other_str;
963 char * st_shndx_str;
964
965 if (! internal_syms)
966 {
967 internal_syms = bfd_malloc (1000);
968 free_internal = 1;
969 }
970 if (! external_syms)
971 {
972 external_syms = bfd_malloc (1000);
973 free_external = 1;
974 }
975
976 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
977 locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
978 if (free_internal)
979 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
980 symtab_hdr->sh_info, 0,
981 internal_syms, external_syms, NULL);
982 else
983 isymbuf = internal_syms;
984 isymend = isymbuf + locsymcount;
985
986 for (isym = isymbuf ; isym < isymend ; isym++)
987 {
988 switch (ELF_ST_TYPE (isym->st_info))
989 {
990 case STT_FUNC:
991 st_info_str = "STT_FUNC";
992 break;
993
994 case STT_SECTION:
995 st_info_str = "STT_SECTION";
996 break;
997
998 case STT_FILE:
999 st_info_str = "STT_FILE";
1000 break;
1001
1002 case STT_OBJECT:
1003 st_info_str = "STT_OBJECT";
1004 break;
1005
1006 case STT_TLS:
1007 st_info_str = "STT_TLS";
1008 break;
1009
1010 default:
1011 st_info_str = "";
1012 }
1013
1014 switch (ELF_ST_BIND (isym->st_info))
1015 {
1016 case STB_LOCAL:
1017 st_info_stb_str = "STB_LOCAL";
1018 break;
1019
1020 case STB_GLOBAL:
1021 st_info_stb_str = "STB_GLOBAL";
1022 break;
1023
1024 default:
1025 st_info_stb_str = "";
1026 }
1027
1028 switch (ELF_ST_VISIBILITY (isym->st_other))
1029 {
1030 case STV_DEFAULT:
1031 st_other_str = "STV_DEFAULT";
1032 break;
1033
1034 case STV_INTERNAL:
1035 st_other_str = "STV_INTERNAL";
1036 break;
1037
1038 case STV_PROTECTED:
1039 st_other_str = "STV_PROTECTED";
1040 break;
1041
1042 default:
1043 st_other_str = "";
1044 }
1045
1046 switch (isym->st_shndx)
1047 {
1048 case SHN_ABS:
1049 st_shndx_str = "SHN_ABS";
1050 break;
1051
1052 case SHN_COMMON:
1053 st_shndx_str = "SHN_COMMON";
1054 break;
1055
1056 case SHN_UNDEF:
1057 st_shndx_str = "SHN_UNDEF";
1058 break;
1059
1060 default:
1061 st_shndx_str = "";
1062 }
1063
1064 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1065 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
1066 isym,
1067 (unsigned long) isym->st_value,
1068 (unsigned long) isym->st_size,
1069 isym->st_name,
1070 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
1071 isym->st_name),
1072 isym->st_info, st_info_str, st_info_stb_str,
1073 isym->st_other, st_other_str,
1074 isym->st_shndx, st_shndx_str);
1075 }
1076 if (free_internal)
1077 free (internal_syms);
1078 if (free_external)
1079 free (external_syms);
1080 }
1081
1082 char *
m32c_get_reloc(long reloc)1083 m32c_get_reloc (long reloc)
1084 {
1085 if (0 <= reloc && reloc < R_M32C_max)
1086 return m32c_elf_howto_table[reloc].name;
1087 else
1088 return "";
1089 }
1090 #endif /* DEBUG */
1091
1092 /* Handle relaxing. */
1093
1094 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1095 is within the low 64k, remove any entry for it in the plt. */
1096
1097 struct relax_plt_data
1098 {
1099 asection *splt;
1100 bool *again;
1101 };
1102
1103 static bool
m32c_relax_plt_check(struct elf_link_hash_entry * h,void * xdata)1104 m32c_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
1105 {
1106 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1107
1108 if (h->plt.offset != (bfd_vma) -1)
1109 {
1110 bfd_vma address;
1111
1112 if (h->root.type == bfd_link_hash_undefined
1113 || h->root.type == bfd_link_hash_undefweak)
1114 address = 0;
1115 else
1116 address = (h->root.u.def.section->output_section->vma
1117 + h->root.u.def.section->output_offset
1118 + h->root.u.def.value);
1119
1120 if (address <= 0xffff)
1121 {
1122 h->plt.offset = -1;
1123 data->splt->size -= 4;
1124 *data->again = true;
1125 }
1126 }
1127
1128 return true;
1129 }
1130
1131 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1132 previously had a plt entry, give it a new entry offset. */
1133
1134 static bool
m32c_relax_plt_realloc(struct elf_link_hash_entry * h,void * xdata)1135 m32c_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
1136 {
1137 bfd_vma *entry = (bfd_vma *) xdata;
1138
1139 if (h->plt.offset != (bfd_vma) -1)
1140 {
1141 h->plt.offset = *entry;
1142 *entry += 4;
1143 }
1144
1145 return true;
1146 }
1147
1148 static bool
m32c_elf_relax_plt_section(asection * splt,struct bfd_link_info * info,bool * again)1149 m32c_elf_relax_plt_section (asection *splt,
1150 struct bfd_link_info *info,
1151 bool *again)
1152 {
1153 struct relax_plt_data relax_plt_data;
1154 bfd *ibfd;
1155
1156 /* Assume nothing changes. */
1157 *again = false;
1158
1159 if (bfd_link_relocatable (info))
1160 return true;
1161
1162 /* Quick check for an empty plt. */
1163 if (splt->size == 0)
1164 return true;
1165
1166 /* Map across all global symbols; see which ones happen to
1167 fall in the low 64k. */
1168 relax_plt_data.splt = splt;
1169 relax_plt_data.again = again;
1170 elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check,
1171 &relax_plt_data);
1172
1173 /* Likewise for local symbols, though that's somewhat less convenient
1174 as we have to walk the list of input bfds and swap in symbol data. */
1175 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
1176 {
1177 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1178 Elf_Internal_Shdr *symtab_hdr;
1179 Elf_Internal_Sym *isymbuf = NULL;
1180 unsigned int idx;
1181
1182 if (! local_plt_offsets)
1183 continue;
1184
1185 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1186 if (symtab_hdr->sh_info != 0)
1187 {
1188 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1189 if (isymbuf == NULL)
1190 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1191 symtab_hdr->sh_info, 0,
1192 NULL, NULL, NULL);
1193 if (isymbuf == NULL)
1194 return false;
1195 }
1196
1197 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1198 {
1199 Elf_Internal_Sym *isym;
1200 asection *tsec;
1201 bfd_vma address;
1202
1203 if (local_plt_offsets[idx] == (bfd_vma) -1)
1204 continue;
1205
1206 isym = &isymbuf[idx];
1207 if (isym->st_shndx == SHN_UNDEF)
1208 continue;
1209 else if (isym->st_shndx == SHN_ABS)
1210 tsec = bfd_abs_section_ptr;
1211 else if (isym->st_shndx == SHN_COMMON)
1212 tsec = bfd_com_section_ptr;
1213 else
1214 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1215
1216 address = (tsec->output_section->vma
1217 + tsec->output_offset
1218 + isym->st_value);
1219 if (address <= 0xffff)
1220 {
1221 local_plt_offsets[idx] = -1;
1222 splt->size -= 4;
1223 *again = true;
1224 }
1225 }
1226
1227 if (isymbuf != NULL
1228 && symtab_hdr->contents != (unsigned char *) isymbuf)
1229 {
1230 if (! info->keep_memory)
1231 free (isymbuf);
1232 else
1233 {
1234 /* Cache the symbols for elf_link_input_bfd. */
1235 symtab_hdr->contents = (unsigned char *) isymbuf;
1236 }
1237 }
1238 }
1239
1240 /* If we changed anything, walk the symbols again to reallocate
1241 .plt entry addresses. */
1242 if (*again && splt->size > 0)
1243 {
1244 bfd_vma entry = 0;
1245
1246 elf_link_hash_traverse (elf_hash_table (info),
1247 m32c_relax_plt_realloc, &entry);
1248
1249 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
1250 {
1251 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1252 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1253 unsigned int idx;
1254
1255 if (! local_plt_offsets)
1256 continue;
1257
1258 for (idx = 0; idx < nlocals; ++idx)
1259 if (local_plt_offsets[idx] != (bfd_vma) -1)
1260 {
1261 local_plt_offsets[idx] = entry;
1262 entry += 4;
1263 }
1264 }
1265 }
1266
1267 return true;
1268 }
1269
1270 static int
compare_reloc(const void * e1,const void * e2)1271 compare_reloc (const void *e1, const void *e2)
1272 {
1273 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
1274 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
1275
1276 if (i1->r_offset == i2->r_offset)
1277 return 0;
1278 else
1279 return i1->r_offset < i2->r_offset ? -1 : 1;
1280 }
1281
1282 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1283 static bfd_vma
m32c_offset_for_reloc(bfd * abfd,Elf_Internal_Rela * rel,Elf_Internal_Shdr * symtab_hdr,bfd_byte * shndx_buf ATTRIBUTE_UNUSED,Elf_Internal_Sym * intsyms)1284 m32c_offset_for_reloc (bfd *abfd,
1285 Elf_Internal_Rela *rel,
1286 Elf_Internal_Shdr *symtab_hdr,
1287 bfd_byte *shndx_buf ATTRIBUTE_UNUSED,
1288 Elf_Internal_Sym *intsyms)
1289 {
1290 bfd_vma symval;
1291
1292 /* Get the value of the symbol referred to by the reloc. */
1293 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1294 {
1295 /* A local symbol. */
1296 Elf_Internal_Sym *isym;
1297 asection *ssec;
1298
1299 isym = intsyms + ELF32_R_SYM (rel->r_info);
1300 ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1301 symval = isym->st_value;
1302 if (ssec)
1303 symval += ssec->output_section->vma
1304 + ssec->output_offset;
1305 }
1306 else
1307 {
1308 unsigned long indx;
1309 struct elf_link_hash_entry *h;
1310
1311 /* An external symbol. */
1312 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1313 h = elf_sym_hashes (abfd)[indx];
1314 BFD_ASSERT (h != NULL);
1315
1316 if (h->root.type != bfd_link_hash_defined
1317 && h->root.type != bfd_link_hash_defweak)
1318 /* This appears to be a reference to an undefined
1319 symbol. Just ignore it--it will be caught by the
1320 regular reloc processing. */
1321 return 0;
1322
1323 symval = (h->root.u.def.value
1324 + h->root.u.def.section->output_section->vma
1325 + h->root.u.def.section->output_offset);
1326 }
1327 return symval;
1328 }
1329
1330 static int bytes_saved = 0;
1331
1332 static int bytes_to_reloc[] = {
1333 R_M32C_NONE,
1334 R_M32C_8,
1335 R_M32C_16,
1336 R_M32C_24,
1337 R_M32C_32
1338 };
1339
1340 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1341
1342 /* Mask for the number of relocs associated with this insn. */
1343 #define RLA_RELOCS 0x0000000f
1344 /* Number of bytes gas emitted (before gas's relaxing) */
1345 #define RLA_NBYTES 0x00000ff0
1346
1347 /* If the displacement is within the given range and the new encoding
1348 differs from the old encoding (the index), then the insn can be
1349 relaxed to the new encoding. */
1350 typedef const struct {
1351 int bytes;
1352 unsigned int max_disp;
1353 unsigned char new_encoding;
1354 } EncodingTable;
1355
1356 static EncodingTable m16c_addr_encodings[] = {
1357 { 0, 0, 0 }, /* R0 */
1358 { 0, 0, 1 }, /* R1 */
1359 { 0, 0, 2 }, /* R2 */
1360 { 0, 0, 3 }, /* R3 */
1361 { 0, 0, 4 }, /* A0 */
1362 { 0, 0, 5 }, /* A1 */
1363 { 0, 0, 6 }, /* [A0] */
1364 { 0, 0, 7 }, /* [A1] */
1365 { 1, 0, 6 }, /* udsp:8[A0] */
1366 { 1, 0, 7 }, /* udsp:8[A1] */
1367 { 1, 0, 10 }, /* udsp:8[SB] */
1368 { 1, 0, 11 }, /* sdsp:8[FB] */
1369 { 2, 255, 8 }, /* udsp:16[A0] */
1370 { 2, 255, 9 }, /* udsp:16[A1] */
1371 { 2, 255, 10 }, /* udsp:16[SB] */
1372 { 2, 0, 15 }, /* abs:16 */
1373 };
1374
1375 static EncodingTable m16c_jmpaddr_encodings[] = {
1376 { 0, 0, 0 }, /* R0 */
1377 { 0, 0, 1 }, /* R1 */
1378 { 0, 0, 2 }, /* R2 */
1379 { 0, 0, 3 }, /* R3 */
1380 { 0, 0, 4 }, /* A0 */
1381 { 0, 0, 5 }, /* A1 */
1382 { 0, 0, 6 }, /* [A0] */
1383 { 0, 0, 7 }, /* [A1] */
1384 { 1, 0, 6 }, /* udsp:8[A0] */
1385 { 1, 0, 7 }, /* udsp:8[A1] */
1386 { 1, 0, 10 }, /* udsp:8[SB] */
1387 { 1, 0, 11 }, /* sdsp:8[FB] */
1388 { 3, 255, 8 }, /* udsp:20[A0] */
1389 { 3, 255, 9 }, /* udsp:20[A1] */
1390 { 2, 255, 10 }, /* udsp:16[SB] */
1391 { 2, 0, 15 }, /* abs:16 */
1392 };
1393
1394 static EncodingTable m32c_addr_encodings[] = {
1395 { 0, 0, 0 }, /* [A0] */
1396 { 0, 0, 1 }, /* [A1] */
1397 { 0, 0, 2 }, /* A0 */
1398 { 0, 0, 3 }, /* A1 */
1399 { 1, 0, 0 }, /* udsp:8[A0] */
1400 { 1, 0, 1 }, /* udsp:8[A1] */
1401 { 1, 0, 6 }, /* udsp:8[SB] */
1402 { 1, 0, 7 }, /* sdsp:8[FB] */
1403 { 2, 255, 4 }, /* udsp:16[A0] */
1404 { 2, 255, 5 }, /* udsp:16[A1] */
1405 { 2, 255, 6 }, /* udsp:16[SB] */
1406 { 2, 127, 7 }, /* sdsp:16[FB] */
1407 { 3, 65535, 8 }, /* udsp:24[A0] */
1408 { 3, 65535, 9 }, /* udsp:24[A1] */
1409 { 3, 65535, 15 }, /* abs24 */
1410 { 2, 0, 15 }, /* abs16 */
1411 { 0, 0, 16 }, /* R2 */
1412 { 0, 0, 17 }, /* R3 */
1413 { 0, 0, 18 }, /* R0 */
1414 { 0, 0, 19 }, /* R1 */
1415 { 0, 0, 20 }, /* */
1416 { 0, 0, 21 }, /* */
1417 { 0, 0, 22 }, /* */
1418 { 0, 0, 23 }, /* */
1419 { 0, 0, 24 }, /* */
1420 { 0, 0, 25 }, /* */
1421 { 0, 0, 26 }, /* */
1422 { 0, 0, 27 }, /* */
1423 { 0, 0, 28 }, /* */
1424 { 0, 0, 29 }, /* */
1425 { 0, 0, 30 }, /* */
1426 { 0, 0, 31 }, /* */
1427 };
1428
1429 static bool
m32c_elf_relax_section(bfd * abfd,asection * sec,struct bfd_link_info * link_info,bool * again)1430 m32c_elf_relax_section (bfd *abfd,
1431 asection *sec,
1432 struct bfd_link_info *link_info,
1433 bool *again)
1434 {
1435 Elf_Internal_Shdr *symtab_hdr;
1436 Elf_Internal_Shdr *shndx_hdr;
1437 Elf_Internal_Rela *internal_relocs;
1438 Elf_Internal_Rela *free_relocs = NULL;
1439 Elf_Internal_Rela *irel, *irelend, *srel;
1440 bfd_byte * contents = NULL;
1441 bfd_byte * free_contents = NULL;
1442 Elf_Internal_Sym *intsyms = NULL;
1443 Elf_Internal_Sym *free_intsyms = NULL;
1444 bfd_byte *shndx_buf = NULL;
1445 int machine;
1446
1447 if (is_elf_hash_table (link_info->hash)
1448 && abfd == elf_hash_table (link_info)->dynobj
1449 && (sec->flags & SEC_LINKER_CREATED) != 0
1450 && strcmp (sec->name, ".plt") == 0)
1451 return m32c_elf_relax_plt_section (sec, link_info, again);
1452
1453 /* Assume nothing changes. */
1454 *again = false;
1455
1456 machine = elf32_m32c_machine (abfd);
1457
1458 /* We don't have to do anything for a relocatable link, if
1459 this section does not have relocs, or if this is not a
1460 code section. */
1461 if (bfd_link_relocatable (link_info)
1462 || (sec->flags & SEC_RELOC) == 0
1463 || sec->reloc_count == 0
1464 || (sec->flags & SEC_CODE) == 0)
1465 return true;
1466
1467 symtab_hdr = & elf_symtab_hdr (abfd);
1468 if (elf_symtab_shndx_list (abfd))
1469 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
1470 else
1471 shndx_hdr = NULL;
1472
1473 /* Get the section contents. */
1474 if (elf_section_data (sec)->this_hdr.contents != NULL)
1475 contents = elf_section_data (sec)->this_hdr.contents;
1476 /* Go get them off disk. */
1477 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1478 goto error_return;
1479
1480 /* Read this BFD's symbols. */
1481 /* Get cached copy if it exists. */
1482 if (symtab_hdr->contents != NULL)
1483 {
1484 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1485 }
1486 else
1487 {
1488 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1489 symtab_hdr->contents = (bfd_byte *) intsyms;
1490 }
1491
1492 if (shndx_hdr && shndx_hdr->sh_size != 0)
1493 {
1494 size_t amt;
1495
1496 if (_bfd_mul_overflow (symtab_hdr->sh_info,
1497 sizeof (Elf_External_Sym_Shndx), &amt))
1498 {
1499 bfd_set_error (bfd_error_file_too_big);
1500 goto error_return;
1501 }
1502 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0)
1503 goto error_return;
1504 shndx_buf = _bfd_malloc_and_read (abfd, amt, amt);
1505 if (shndx_buf == NULL)
1506 goto error_return;
1507 shndx_hdr->contents = shndx_buf;
1508 }
1509
1510 /* Get a copy of the native relocations. */
1511 internal_relocs = (_bfd_elf_link_read_relocs
1512 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
1513 link_info->keep_memory));
1514 if (internal_relocs == NULL)
1515 goto error_return;
1516 if (! link_info->keep_memory)
1517 free_relocs = internal_relocs;
1518
1519 /* The RL_ relocs must be just before the operand relocs they go
1520 with, so we must sort them to guarantee this. */
1521 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
1522 compare_reloc);
1523
1524 /* Walk through them looking for relaxing opportunities. */
1525 irelend = internal_relocs + sec->reloc_count;
1526
1527 for (irel = internal_relocs; irel < irelend; irel++)
1528 {
1529 bfd_vma symval;
1530 unsigned char *insn, *gap, *einsn;
1531 bfd_vma pc;
1532 bfd_signed_vma pcrel;
1533 int relax_relocs;
1534 int gap_size;
1535 int new_type;
1536 int posn;
1537 int enc;
1538 EncodingTable *enctbl;
1539 EncodingTable *e;
1540
1541 if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
1542 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
1543 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
1544 continue;
1545
1546 srel = irel;
1547
1548 /* There will always be room for the relaxed insn, since it is smaller
1549 than the one it would replace. */
1550 BFD_ASSERT (irel->r_offset < sec->size);
1551
1552 insn = contents + irel->r_offset;
1553 relax_relocs = irel->r_addend % 16;
1554
1555 /* Ok, we only have three relocs we care about, and they're all
1556 fake. The lower four bits of the addend is always the number
1557 of following relocs (hence the qsort above) that are assigned
1558 to this opcode. The next 8 bits of the addend indicates the
1559 number of bytes in the insn. We use the rest of them
1560 ourselves as flags for the more expensive operations (defines
1561 above). The three relocs are:
1562
1563 RL_JUMP: This marks all direct jump insns. We check the
1564 displacement and replace them with shorter jumps if
1565 they're in range. We also use this to find JMP.S
1566 insns and manually shorten them when we delete bytes.
1567 We have to decode these insns to figure out what to
1568 do.
1569
1570 RL_1ADDR: This is a :G or :Q insn, which has a single
1571 "standard" operand. We have to extract the type
1572 field, see if it's a wide displacement, then figure
1573 out if we can replace it with a narrow displacement.
1574 We don't have to decode these insns.
1575
1576 RL_2ADDR: Similarly, but two "standard" operands. Note that
1577 r_addend may still be 1, as standard operands don't
1578 always have displacements. Gas shouldn't give us one
1579 with zero operands, but since we don't know which one
1580 has the displacement, we check them both anyway.
1581
1582 These all point to the beginning of the insn itself, not the
1583 operands.
1584
1585 Note that we only relax one step at a time, relying on the
1586 linker to call us repeatedly. Thus, there is no code for
1587 JMP.A->JMP.B although that will happen in two steps.
1588 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1589 */
1590
1591 /* Get the value of the symbol referred to by the reloc. Just
1592 in case this is the last reloc in the list, use the RL's
1593 addend to choose between this reloc (no addend) or the next
1594 (yes addend, which means at least one following reloc). */
1595 srel = irel + (relax_relocs ? 1 : 0);
1596 symval = OFFSET_FOR_RELOC (srel);
1597
1598 /* Setting gap_size nonzero is the flag which means "something
1599 shrunk". */
1600 gap_size = 0;
1601 gap = NULL;
1602 new_type = ELF32_R_TYPE(srel->r_info);
1603
1604 pc = sec->output_section->vma + sec->output_offset
1605 + srel->r_offset;
1606 pcrel = symval - pc + srel->r_addend;
1607
1608 if (machine == bfd_mach_m16c)
1609 {
1610 /* R8C / M16C */
1611
1612 switch (ELF32_R_TYPE(irel->r_info))
1613 {
1614
1615 case R_M32C_RL_JUMP:
1616 switch (insn[0])
1617 {
1618 case 0xfe: /* jmp.b */
1619 if (pcrel >= 2 && pcrel <= 9)
1620 {
1621 /* Relax JMP.B -> JMP.S. We need to get rid of
1622 the following reloc though. */
1623 insn[0] = 0x60 | (pcrel - 2);
1624 new_type = R_M32C_NONE;
1625 irel->r_addend = 0x10;
1626 gap_size = 1;
1627 gap = insn + 1;
1628 }
1629 break;
1630
1631 case 0xf4: /* jmp.w */
1632 /* 128 is allowed because it will be one byte closer
1633 after relaxing. Likewise for all other pc-rel
1634 jumps. */
1635 if (pcrel <= 128 && pcrel >= -128)
1636 {
1637 /* Relax JMP.W -> JMP.B */
1638 insn[0] = 0xfe;
1639 insn[1] = 0;
1640 new_type = R_M32C_8_PCREL;
1641 gap_size = 1;
1642 gap = insn + 2;
1643 }
1644 break;
1645
1646 case 0xfc: /* jmp.a */
1647 if (pcrel <= 32768 && pcrel >= -32768)
1648 {
1649 /* Relax JMP.A -> JMP.W */
1650 insn[0] = 0xf4;
1651 insn[1] = 0;
1652 insn[2] = 0;
1653 new_type = R_M32C_16_PCREL;
1654 gap_size = 1;
1655 gap = insn + 3;
1656 }
1657 break;
1658
1659 case 0xfd: /* jsr.a */
1660 if (pcrel <= 32768 && pcrel >= -32768)
1661 {
1662 /* Relax JSR.A -> JSR.W */
1663 insn[0] = 0xf5;
1664 insn[1] = 0;
1665 insn[2] = 0;
1666 new_type = R_M32C_16_PCREL;
1667 gap_size = 1;
1668 gap = insn + 3;
1669 }
1670 break;
1671 }
1672 break;
1673
1674 case R_M32C_RL_2ADDR:
1675 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1676
1677 enctbl = m16c_addr_encodings;
1678 posn = 2;
1679 enc = (insn[1] >> 4) & 0x0f;
1680 e = & enctbl[enc];
1681
1682 if (srel->r_offset == irel->r_offset + posn
1683 && e->new_encoding != enc
1684 && symval <= e->max_disp)
1685 {
1686 insn[1] &= 0x0f;
1687 insn[1] |= e->new_encoding << 4;
1688 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1689 gap = insn + posn + enctbl[e->new_encoding].bytes;
1690 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1691 break;
1692 }
1693 if (relax_relocs == 2)
1694 srel ++;
1695 posn += e->bytes;
1696
1697 goto try_1addr_16;
1698
1699 case R_M32C_RL_1ADDR:
1700 /* xxxx xxxx xxxx dest [disp] */
1701
1702 enctbl = m16c_addr_encodings;
1703 posn = 2;
1704
1705 /* Check the opcode for jumps. We know it's safe to
1706 do this because all 2ADDR insns are at least two
1707 bytes long. */
1708 enc = insn[0] * 256 + insn[1];
1709 enc &= 0xfff0;
1710 if (enc == 0x7d20
1711 || enc == 0x7d00
1712 || enc == 0x7d30
1713 || enc == 0x7d10)
1714 {
1715 enctbl = m16c_jmpaddr_encodings;
1716 }
1717
1718 try_1addr_16:
1719 /* srel, posn, and enc must be set here. */
1720
1721 symval = OFFSET_FOR_RELOC (srel);
1722 enc = insn[1] & 0x0f;
1723 e = & enctbl[enc];
1724
1725 if (srel->r_offset == irel->r_offset + posn
1726 && e->new_encoding != enc
1727 && symval <= e->max_disp)
1728 {
1729 insn[1] &= 0xf0;
1730 insn[1] |= e->new_encoding;
1731 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1732 gap = insn + posn + enctbl[e->new_encoding].bytes;
1733 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1734 break;
1735 }
1736
1737 break;
1738
1739 } /* Ends switch (reloc type) for m16c. */
1740 }
1741 else /* machine == bfd_mach_m32c */
1742 {
1743 /* M32CM / M32C */
1744
1745 switch (ELF32_R_TYPE(irel->r_info))
1746 {
1747
1748 case R_M32C_RL_JUMP:
1749 switch (insn[0])
1750 {
1751 case 0xbb: /* jmp.b */
1752 if (pcrel >= 2 && pcrel <= 9)
1753 {
1754 int p = pcrel - 2;
1755 /* Relax JMP.B -> JMP.S. We need to get rid of
1756 the following reloc though. */
1757 insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
1758 new_type = R_M32C_NONE;
1759 irel->r_addend = 0x10;
1760 gap_size = 1;
1761 gap = insn + 1;
1762 }
1763 break;
1764
1765 case 0xce: /* jmp.w */
1766 if (pcrel <= 128 && pcrel >= -128)
1767 {
1768 /* Relax JMP.W -> JMP.B */
1769 insn[0] = 0xbb;
1770 insn[1] = 0;
1771 new_type = R_M32C_8_PCREL;
1772 gap_size = 1;
1773 gap = insn + 2;
1774 }
1775 break;
1776
1777 case 0xcc: /* jmp.a */
1778 if (pcrel <= 32768 && pcrel >= -32768)
1779 {
1780 /* Relax JMP.A -> JMP.W */
1781 insn[0] = 0xce;
1782 insn[1] = 0;
1783 insn[2] = 0;
1784 new_type = R_M32C_16_PCREL;
1785 gap_size = 1;
1786 gap = insn + 3;
1787 }
1788 break;
1789
1790 case 0xcd: /* jsr.a */
1791 if (pcrel <= 32768 && pcrel >= -32768)
1792 {
1793 /* Relax JSR.A -> JSR.W */
1794 insn[0] = 0xcf;
1795 insn[1] = 0;
1796 insn[2] = 0;
1797 new_type = R_M32C_16_PCREL;
1798 gap_size = 1;
1799 gap = insn + 3;
1800 }
1801 break;
1802 }
1803 break;
1804
1805 case R_M32C_RL_2ADDR:
1806 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1807
1808 einsn = insn;
1809 posn = 2;
1810 if (einsn[0] == 1)
1811 {
1812 /* prefix; remove it as far as the RL reloc is concerned. */
1813 einsn ++;
1814 posn ++;
1815 }
1816
1817 enctbl = m32c_addr_encodings;
1818 enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
1819 e = & enctbl[enc];
1820
1821 if (srel->r_offset == irel->r_offset + posn
1822 && e->new_encoding != enc
1823 && symval <= e->max_disp)
1824 {
1825 einsn[0] &= 0x8f;
1826 einsn[0] |= (e->new_encoding & 0x1c) << 2;
1827 einsn[1] &= 0xcf;
1828 einsn[1] |= (e->new_encoding & 0x03) << 4;
1829 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1830 gap = insn + posn + enctbl[e->new_encoding].bytes;
1831 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1832 break;
1833 }
1834 if (relax_relocs == 2)
1835 srel ++;
1836 posn += e->bytes;
1837
1838 goto try_1addr_32;
1839
1840 case R_M32C_RL_1ADDR:
1841 /* xxxx DDDx DDxx xxxx [disp] */
1842
1843 einsn = insn;
1844 posn = 2;
1845 if (einsn[0] == 1)
1846 {
1847 /* prefix; remove it as far as the RL reloc is concerned. */
1848 einsn ++;
1849 posn ++;
1850 }
1851
1852 enctbl = m32c_addr_encodings;
1853
1854 try_1addr_32:
1855 /* srel, posn, and enc must be set here. */
1856
1857 symval = OFFSET_FOR_RELOC (srel);
1858 enc = ((einsn[0] & 0x0e) << 1) | ((einsn[1] & 0xc0) >> 6);
1859 e = & enctbl[enc];
1860
1861 if (srel->r_offset == irel->r_offset + posn
1862 && e->new_encoding != enc
1863 && symval <= e->max_disp)
1864 {
1865 einsn[0] &= 0xf1;
1866 einsn[0] |= (e->new_encoding & 0x1c) >> 1;
1867 einsn[1] &= 0x3f;
1868 einsn[1] |= (e->new_encoding & 0x03) << 6;
1869 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1870 gap = insn + posn + enctbl[e->new_encoding].bytes;
1871 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1872 break;
1873 }
1874
1875 break;
1876
1877 } /* Ends switch (reloc type) for m32c. */
1878 }
1879
1880 if (gap_size == 0)
1881 continue;
1882
1883 *again = true;
1884
1885 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
1886
1887 /* Note that we've changed the relocs, section contents, etc. */
1888 elf_section_data (sec)->relocs = internal_relocs;
1889 free_relocs = NULL;
1890
1891 elf_section_data (sec)->this_hdr.contents = contents;
1892 free_contents = NULL;
1893
1894 symtab_hdr->contents = (bfd_byte *) intsyms;
1895 free_intsyms = NULL;
1896
1897 bytes_saved += gap_size;
1898
1899 if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
1900 goto error_return;
1901
1902 } /* next relocation */
1903
1904 free (free_relocs);
1905 free_relocs = NULL;
1906
1907 if (free_contents != NULL)
1908 {
1909 if (! link_info->keep_memory)
1910 free (free_contents);
1911 /* Cache the section contents for elf_link_input_bfd. */
1912 else
1913 elf_section_data (sec)->this_hdr.contents = contents;
1914
1915 free_contents = NULL;
1916 }
1917
1918 if (shndx_buf != NULL)
1919 {
1920 shndx_hdr->contents = NULL;
1921 free (shndx_buf);
1922 }
1923
1924 if (free_intsyms != NULL)
1925 {
1926 if (! link_info->keep_memory)
1927 free (free_intsyms);
1928 /* Cache the symbols for elf_link_input_bfd. */
1929 else
1930 {
1931 symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
1932 }
1933
1934 free_intsyms = NULL;
1935 }
1936
1937 return true;
1938
1939 error_return:
1940 free (free_relocs);
1941 free (free_contents);
1942 if (shndx_buf != NULL)
1943 {
1944 shndx_hdr->contents = NULL;
1945 free (shndx_buf);
1946 }
1947 free (free_intsyms);
1948 return false;
1949 }
1950
1951 /* Delete some bytes from a section while relaxing. */
1952
1953 static bool
m32c_elf_relax_delete_bytes(bfd * abfd,asection * sec,bfd_vma addr,int count)1954 m32c_elf_relax_delete_bytes (bfd *abfd,
1955 asection *sec,
1956 bfd_vma addr,
1957 int count)
1958 {
1959 Elf_Internal_Shdr *symtab_hdr;
1960 Elf_Internal_Shdr *shndx_hdr;
1961 int sec_shndx;
1962 bfd_byte *contents;
1963 Elf_Internal_Rela *irel;
1964 Elf_Internal_Rela *irelend;
1965 bfd_vma toaddr;
1966 Elf_Internal_Sym *isym;
1967 Elf_Internal_Sym *isymend;
1968 Elf_Internal_Sym *intsyms;
1969 Elf_External_Sym_Shndx *shndx_buf;
1970 Elf_External_Sym_Shndx *shndx;
1971 struct elf_link_hash_entry ** sym_hashes;
1972 struct elf_link_hash_entry ** end_hashes;
1973 unsigned int symcount;
1974
1975 contents = elf_section_data (sec)->this_hdr.contents;
1976
1977 toaddr = sec->size;
1978
1979 irel = elf_section_data (sec)->relocs;
1980 irelend = irel + sec->reloc_count;
1981
1982 /* Actually delete the bytes. */
1983 memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count));
1984 sec->size -= count;
1985
1986 /* Adjust all the relocs. */
1987 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++)
1988 {
1989 /* Get the new reloc address. */
1990 if (irel->r_offset > addr && irel->r_offset < toaddr)
1991 irel->r_offset -= count;
1992
1993 if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
1994 && irel->r_addend == 0x10 /* one byte insn, no relocs */
1995 && irel->r_offset + 1 < addr
1996 && irel->r_offset + 7 > addr)
1997 {
1998 bfd_vma disp;
1999 unsigned char *insn = &contents[irel->r_offset];
2000 disp = *insn;
2001 /* This is a JMP.S, which we have to manually update. */
2002 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
2003 {
2004 if ((*insn & 0xf8) != 0x60)
2005 continue;
2006 disp = (disp & 7);
2007 }
2008 else
2009 {
2010 if ((*insn & 0xce) != 0x4a)
2011 continue;
2012 disp = ((disp & 0x30) >> 3) | (disp & 1);
2013 }
2014 if (irel->r_offset + disp + 2 >= addr+count)
2015 {
2016 disp -= count;
2017 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
2018 {
2019 *insn = (*insn & 0xf8) | disp;
2020 }
2021 else
2022 {
2023 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
2024 }
2025 }
2026 }
2027 }
2028
2029 /* Adjust the local symbols defined in this section. */
2030 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2031 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2032 isym = intsyms;
2033 isymend = isym + symtab_hdr->sh_info;
2034
2035 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2036 if (elf_symtab_shndx_list (abfd))
2037 {
2038 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2039 shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
2040 }
2041 else
2042 {
2043 shndx_hdr = NULL;
2044 shndx_buf = NULL;
2045 }
2046 shndx = shndx_buf;
2047
2048 for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
2049 {
2050 /* If the symbol is in the range of memory we just moved, we
2051 have to adjust its value. */
2052 if ((int) isym->st_shndx == sec_shndx
2053 && isym->st_value > addr
2054 && isym->st_value < toaddr)
2055 {
2056 isym->st_value -= count;
2057 }
2058 /* If the symbol *spans* the bytes we just deleted (i.e. it's
2059 *end* is in the moved bytes but it's *start* isn't), then we
2060 must adjust its size. */
2061 if ((int) isym->st_shndx == sec_shndx
2062 && isym->st_value < addr
2063 && isym->st_value + isym->st_size > addr
2064 && isym->st_value + isym->st_size < toaddr)
2065 {
2066 isym->st_size -= count;
2067 }
2068 }
2069
2070 /* Now adjust the global symbols defined in this section. */
2071 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2072 - symtab_hdr->sh_info);
2073 sym_hashes = elf_sym_hashes (abfd);
2074 end_hashes = sym_hashes + symcount;
2075
2076 for (; sym_hashes < end_hashes; sym_hashes ++)
2077 {
2078 struct elf_link_hash_entry * sym_hash = * sym_hashes;
2079
2080 if (sym_hash &&
2081 (sym_hash->root.type == bfd_link_hash_defined
2082 || sym_hash->root.type == bfd_link_hash_defweak)
2083 && sym_hash->root.u.def.section == sec)
2084 {
2085 if (sym_hash->root.u.def.value > addr
2086 && sym_hash->root.u.def.value < toaddr)
2087 {
2088 sym_hash->root.u.def.value -= count;
2089 }
2090 if (sym_hash->root.u.def.value < addr
2091 && sym_hash->root.u.def.value + sym_hash->size > addr
2092 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
2093 {
2094 sym_hash->size -= count;
2095 }
2096 }
2097 }
2098
2099 return true;
2100 }
2101
2102 /* This is for versions of gcc prior to 4.3. */
2103 static unsigned int
_bfd_m32c_elf_eh_frame_address_size(bfd * abfd,const asection * sec ATTRIBUTE_UNUSED)2104 _bfd_m32c_elf_eh_frame_address_size (bfd *abfd,
2105 const asection *sec ATTRIBUTE_UNUSED)
2106 {
2107 if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C)
2108 return 2;
2109 return 4;
2110 }
2111
2112
2113
2114 #define ELF_ARCH bfd_arch_m32c
2115 #define ELF_MACHINE_CODE EM_M32C
2116 #define ELF_MACHINE_ALT1 EM_M32C_OLD
2117 #define ELF_MAXPAGESIZE 0x100
2118
2119 #if 0
2120 #define TARGET_BIG_SYM m32c_elf32_vec
2121 #define TARGET_BIG_NAME "elf32-m32c"
2122 #else
2123 #define TARGET_LITTLE_SYM m32c_elf32_vec
2124 #define TARGET_LITTLE_NAME "elf32-m32c"
2125 #endif
2126
2127 #define elf_info_to_howto_rel NULL
2128 #define elf_info_to_howto m32c_info_to_howto_rela
2129 #define elf_backend_object_p m32c_elf_object_p
2130 #define elf_backend_relocate_section m32c_elf_relocate_section
2131 #define elf_backend_check_relocs m32c_elf_check_relocs
2132 #define elf_backend_object_p m32c_elf_object_p
2133 #define elf_symbol_leading_char ('_')
2134 #define elf_backend_always_size_sections \
2135 m32c_elf_always_size_sections
2136 #define elf_backend_finish_dynamic_sections \
2137 m32c_elf_finish_dynamic_sections
2138
2139 #define elf_backend_can_gc_sections 1
2140 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2141
2142 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2143 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2144 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2145 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2146 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2147 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2148
2149 #include "elf32-target.h"
2150