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