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