projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
* elf32-m32c.c (m32c_elf_check_relocs): Use bfd_make_section
[binutils-gdb.git] / bfd / elf32-m32c.c
1 /* M16C/M32C specific support for 32-bit ELF.
2 Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
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_linker_section (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 && discarded_section (sec))
438 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
439 rel, 1, relend, howto, 0, contents);
440
441 if (info->relocatable)
442 {
443 /* This is a relocatable link. We don't have to change
444 anything, unless the reloc is against a section symbol,
445 in which case we have to adjust according to where the
446 section symbol winds up in the output section. */
447 if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
448 rel->r_addend += sec->output_offset;
449 continue;
450 }
451
452 switch (ELF32_R_TYPE (rel->r_info))
453 {
454 case R_M32C_16:
455 {
456 bfd_vma *plt_offset;
457
458 if (h != NULL)
459 plt_offset = &h->plt.offset;
460 else
461 plt_offset = elf_local_got_offsets (input_bfd) + r_symndx;
462
463 /* printf("%s: rel %x plt %d\n", h ? h->root.root.string : "(none)",
464 relocation, *plt_offset);*/
465 if (relocation <= 0xffff)
466 {
467 /* If the symbol is in range for a 16-bit address, we should
468 have deallocated the plt entry in relax_section. */
469 BFD_ASSERT (*plt_offset == (bfd_vma) -1);
470 }
471 else
472 {
473 /* If the symbol is out of range for a 16-bit address,
474 we must have allocated a plt entry. */
475 BFD_ASSERT (*plt_offset != (bfd_vma) -1);
476
477 /* If this is the first time we've processed this symbol,
478 fill in the plt entry with the correct symbol address. */
479 if ((*plt_offset & 1) == 0)
480 {
481 unsigned int x;
482
483 x = 0x000000fc; /* jmpf */
484 x |= (relocation << 8) & 0xffffff00;
485 bfd_put_32 (input_bfd, x, splt->contents + *plt_offset);
486 *plt_offset |= 1;
487 }
488
489 relocation = (splt->output_section->vma
490 + splt->output_offset
491 + (*plt_offset & -2));
492 if (name)
493 {
494 char *newname = bfd_malloc (strlen(name)+5);
495 strcpy (newname, name);
496 strcat(newname, ".plt");
497 _bfd_generic_link_add_one_symbol (info,
498 input_bfd,
499 newname,
500 BSF_FUNCTION | BSF_WEAK,
501 splt,
502 (*plt_offset & -2),
503 0,
504 1,
505 0,
506 0);
507 }
508 }
509 }
510 break;
511
512 case R_M32C_HI8:
513 case R_M32C_HI16:
514 relocation >>= 16;
515 break;
516 }
517
518 #if 0
519 printf ("relocate %s at %06lx relocation %06lx addend %ld ",
520 m32c_elf_howto_table[ELF32_R_TYPE(rel->r_info)].name,
521 rel->r_offset + input_section->output_section->vma + input_section->output_offset,
522 relocation, rel->r_addend);
523 {
524 int i;
525 for (i=0; i<4; i++)
526 printf (" %02x", contents[rel->r_offset+i]);
527 printf ("\n");
528 }
529 #endif
530 r = _bfd_final_link_relocate (howto, input_bfd, input_section,
531 contents, rel->r_offset, relocation,
532 rel->r_addend);
533
534 if (r != bfd_reloc_ok)
535 {
536 const char * msg = (const char *) NULL;
537
538 switch (r)
539 {
540 case bfd_reloc_overflow:
541 r = info->callbacks->reloc_overflow
542 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
543 input_bfd, input_section, rel->r_offset);
544 break;
545
546 case bfd_reloc_undefined:
547 r = info->callbacks->undefined_symbol
548 (info, name, input_bfd, input_section, rel->r_offset,
549 TRUE);
550 break;
551
552 case bfd_reloc_outofrange:
553 msg = _("internal error: out of range error");
554 break;
555
556 case bfd_reloc_notsupported:
557 msg = _("internal error: unsupported relocation error");
558 break;
559
560 case bfd_reloc_dangerous:
561 msg = _("internal error: dangerous relocation");
562 break;
563
564 default:
565 msg = _("internal error: unknown error");
566 break;
567 }
568
569 if (msg)
570 r = info->callbacks->warning
571 (info, msg, name, input_bfd, input_section, rel->r_offset);
572
573 if (! r)
574 return FALSE;
575 }
576 }
577
578 return TRUE;
579 }
580 \f
581 /* We support 16-bit pointers to code above 64k by generating a thunk
582 below 64k containing a JMP instruction to the final address. */
583
584 static bfd_boolean
585 m32c_elf_check_relocs
586 (bfd * abfd,
587 struct bfd_link_info * info,
588 asection * sec,
589 const Elf_Internal_Rela * relocs)
590 {
591 Elf_Internal_Shdr * symtab_hdr;
592 struct elf_link_hash_entry ** sym_hashes;
593 const Elf_Internal_Rela * rel;
594 const Elf_Internal_Rela * rel_end;
595 bfd_vma *local_plt_offsets;
596 asection *splt;
597 bfd *dynobj;
598
599 if (info->relocatable)
600 return TRUE;
601
602 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
603 sym_hashes = elf_sym_hashes (abfd);
604 local_plt_offsets = elf_local_got_offsets (abfd);
605 splt = NULL;
606 dynobj = elf_hash_table(info)->dynobj;
607
608 rel_end = relocs + sec->reloc_count;
609 for (rel = relocs; rel < rel_end; rel++)
610 {
611 struct elf_link_hash_entry *h;
612 unsigned long r_symndx;
613 bfd_vma *offset;
614
615 r_symndx = ELF32_R_SYM (rel->r_info);
616 if (r_symndx < symtab_hdr->sh_info)
617 h = NULL;
618 else
619 {
620 h = sym_hashes[r_symndx - symtab_hdr->sh_info];
621 while (h->root.type == bfd_link_hash_indirect
622 || h->root.type == bfd_link_hash_warning)
623 h = (struct elf_link_hash_entry *) h->root.u.i.link;
624 }
625
626 switch (ELF32_R_TYPE (rel->r_info))
627 {
628 /* This relocation describes a 16-bit pointer to a function.
629 We may need to allocate a thunk in low memory; reserve memory
630 for it now. */
631 case R_M32C_16:
632 if (dynobj == NULL)
633 elf_hash_table (info)->dynobj = dynobj = abfd;
634 if (splt == NULL)
635 {
636 splt = bfd_get_linker_section (dynobj, ".plt");
637 if (splt == NULL)
638 {
639 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
640 | SEC_IN_MEMORY | SEC_LINKER_CREATED
641 | SEC_READONLY | SEC_CODE);
642 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
643 flags);
644 if (splt == NULL
645 || ! bfd_set_section_alignment (dynobj, splt, 1))
646 return FALSE;
647 }
648 }
649
650 if (h != NULL)
651 offset = &h->plt.offset;
652 else
653 {
654 if (local_plt_offsets == NULL)
655 {
656 size_t size;
657 unsigned int i;
658
659 size = symtab_hdr->sh_info * sizeof (bfd_vma);
660 local_plt_offsets = (bfd_vma *) bfd_alloc (abfd, size);
661 if (local_plt_offsets == NULL)
662 return FALSE;
663 elf_local_got_offsets (abfd) = local_plt_offsets;
664
665 for (i = 0; i < symtab_hdr->sh_info; i++)
666 local_plt_offsets[i] = (bfd_vma) -1;
667 }
668 offset = &local_plt_offsets[r_symndx];
669 }
670
671 if (*offset == (bfd_vma) -1)
672 {
673 *offset = splt->size;
674 splt->size += 4;
675 }
676 break;
677 }
678 }
679
680 return TRUE;
681 }
682
683 /* This must exist if dynobj is ever set. */
684
685 static bfd_boolean
686 m32c_elf_finish_dynamic_sections (bfd *abfd ATTRIBUTE_UNUSED,
687 struct bfd_link_info *info)
688 {
689 bfd *dynobj;
690 asection *splt;
691
692 /* As an extra sanity check, verify that all plt entries have
693 been filled in. */
694
695 if ((dynobj = elf_hash_table (info)->dynobj) != NULL
696 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
697 {
698 bfd_byte *contents = splt->contents;
699 unsigned int i, size = splt->size;
700 for (i = 0; i < size; i += 4)
701 {
702 unsigned int x = bfd_get_32 (dynobj, contents + i);
703 BFD_ASSERT (x != 0);
704 }
705 }
706
707 return TRUE;
708 }
709
710 static bfd_boolean
711 m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
712 struct bfd_link_info *info)
713 {
714 bfd *dynobj;
715 asection *splt;
716
717 if (info->relocatable)
718 return TRUE;
719
720 dynobj = elf_hash_table (info)->dynobj;
721 if (dynobj == NULL)
722 return TRUE;
723
724 splt = bfd_get_linker_section (dynobj, ".plt");
725 BFD_ASSERT (splt != NULL);
726
727 splt->contents = (bfd_byte *) bfd_zalloc (dynobj, splt->size);
728 if (splt->contents == NULL)
729 return FALSE;
730
731 return TRUE;
732 }
733 \f
734 /* Function to set the ELF flag bits. */
735
736 static bfd_boolean
737 m32c_elf_set_private_flags (bfd *abfd, flagword flags)
738 {
739 elf_elfheader (abfd)->e_flags = flags;
740 elf_flags_init (abfd) = TRUE;
741 return TRUE;
742 }
743
744 /* Merge backend specific data from an object file to the output
745 object file when linking. */
746
747 static bfd_boolean
748 m32c_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
749 {
750 flagword old_flags, old_partial;
751 flagword new_flags, new_partial;
752 bfd_boolean error = FALSE;
753 char new_opt[80];
754 char old_opt[80];
755
756 new_opt[0] = old_opt[0] = '\0';
757 new_flags = elf_elfheader (ibfd)->e_flags;
758 old_flags = elf_elfheader (obfd)->e_flags;
759
760 #ifdef DEBUG
761 (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
762 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
763 bfd_get_filename (ibfd));
764 #endif
765
766 if (!elf_flags_init (obfd))
767 {
768 /* First call, no flags set. */
769 elf_flags_init (obfd) = TRUE;
770 elf_elfheader (obfd)->e_flags = new_flags;
771 }
772
773 else if (new_flags == old_flags)
774 /* Compatible flags are ok. */
775 ;
776
777 else /* Possibly incompatible flags. */
778 {
779 /* Warn if different cpu is used (allow a specific cpu to override
780 the generic cpu). */
781 new_partial = (new_flags & EF_M32C_CPU_MASK);
782 old_partial = (old_flags & EF_M32C_CPU_MASK);
783 if (new_partial == old_partial)
784 ;
785
786 else
787 {
788 switch (new_partial)
789 {
790 default: strcat (new_opt, " -m16c"); break;
791 case EF_M32C_CPU_M16C: strcat (new_opt, " -m16c"); break;
792 case EF_M32C_CPU_M32C: strcat (new_opt, " -m32c"); break;
793 }
794
795 switch (old_partial)
796 {
797 default: strcat (old_opt, " -m16c"); break;
798 case EF_M32C_CPU_M16C: strcat (old_opt, " -m16c"); break;
799 case EF_M32C_CPU_M32C: strcat (old_opt, " -m32c"); break;
800 }
801 }
802
803 /* Print out any mismatches from above. */
804 if (new_opt[0])
805 {
806 error = TRUE;
807 (*_bfd_error_handler)
808 (_("%s: compiled with %s and linked with modules compiled with %s"),
809 bfd_get_filename (ibfd), new_opt, old_opt);
810 }
811
812 new_flags &= ~ EF_M32C_ALL_FLAGS;
813 old_flags &= ~ EF_M32C_ALL_FLAGS;
814
815 /* Warn about any other mismatches. */
816 if (new_flags != old_flags)
817 {
818 error = TRUE;
819 (*_bfd_error_handler)
820 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
821 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
822 }
823 }
824
825 if (error)
826 bfd_set_error (bfd_error_bad_value);
827
828 return !error;
829 }
830
831 \f
832 static bfd_boolean
833 m32c_elf_print_private_bfd_data (bfd *abfd, PTR ptr)
834 {
835 FILE *file = (FILE *) ptr;
836 flagword flags;
837
838 BFD_ASSERT (abfd != NULL && ptr != NULL);
839
840 /* Print normal ELF private data. */
841 _bfd_elf_print_private_bfd_data (abfd, ptr);
842
843 flags = elf_elfheader (abfd)->e_flags;
844 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
845
846 switch (flags & EF_M32C_CPU_MASK)
847 {
848 default: break;
849 case EF_M32C_CPU_M16C: fprintf (file, " -m16c"); break;
850 case EF_M32C_CPU_M32C: fprintf (file, " -m32c"); break;
851 }
852
853 fputc ('\n', file);
854 return TRUE;
855 }
856
857 /* Return the MACH for an e_flags value. */
858
859 static int
860 elf32_m32c_machine (bfd *abfd)
861 {
862 switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
863 {
864 case EF_M32C_CPU_M16C: return bfd_mach_m16c;
865 case EF_M32C_CPU_M32C: return bfd_mach_m32c;
866 }
867
868 return bfd_mach_m16c;
869 }
870
871 static bfd_boolean
872 m32c_elf_object_p (bfd *abfd)
873 {
874 bfd_default_set_arch_mach (abfd, bfd_arch_m32c,
875 elf32_m32c_machine (abfd));
876 return TRUE;
877 }
878 \f
879
880 #ifdef DEBUG
881 void
882 dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
883 {
884 size_t locsymcount;
885 Elf_Internal_Sym *isymbuf;
886 Elf_Internal_Sym *isymend;
887 Elf_Internal_Sym *isym;
888 Elf_Internal_Shdr *symtab_hdr;
889 bfd_boolean free_internal = 0, free_external = 0;
890 char * st_info_str;
891 char * st_info_stb_str;
892 char * st_other_str;
893 char * st_shndx_str;
894
895 if (! internal_syms)
896 {
897 internal_syms = bfd_malloc (1000);
898 free_internal = 1;
899 }
900 if (! external_syms)
901 {
902 external_syms = bfd_malloc (1000);
903 free_external = 1;
904 }
905
906 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
907 locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
908 if (free_internal)
909 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
910 symtab_hdr->sh_info, 0,
911 internal_syms, external_syms, NULL);
912 else
913 isymbuf = internal_syms;
914 isymend = isymbuf + locsymcount;
915
916 for (isym = isymbuf ; isym < isymend ; isym++)
917 {
918 switch (ELF_ST_TYPE (isym->st_info))
919 {
920 case STT_FUNC: st_info_str = "STT_FUNC";
921 case STT_SECTION: st_info_str = "STT_SECTION";
922 case STT_FILE: st_info_str = "STT_FILE";
923 case STT_OBJECT: st_info_str = "STT_OBJECT";
924 case STT_TLS: st_info_str = "STT_TLS";
925 default: st_info_str = "";
926 }
927 switch (ELF_ST_BIND (isym->st_info))
928 {
929 case STB_LOCAL: st_info_stb_str = "STB_LOCAL";
930 case STB_GLOBAL: st_info_stb_str = "STB_GLOBAL";
931 default: st_info_stb_str = "";
932 }
933 switch (ELF_ST_VISIBILITY (isym->st_other))
934 {
935 case STV_DEFAULT: st_other_str = "STV_DEFAULT";
936 case STV_INTERNAL: st_other_str = "STV_INTERNAL";
937 case STV_PROTECTED: st_other_str = "STV_PROTECTED";
938 default: st_other_str = "";
939 }
940 switch (isym->st_shndx)
941 {
942 case SHN_ABS: st_shndx_str = "SHN_ABS";
943 case SHN_COMMON: st_shndx_str = "SHN_COMMON";
944 case SHN_UNDEF: st_shndx_str = "SHN_UNDEF";
945 default: st_shndx_str = "";
946 }
947
948 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
949 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
950 isym,
951 (unsigned long) isym->st_value,
952 (unsigned long) isym->st_size,
953 isym->st_name,
954 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
955 isym->st_name),
956 isym->st_info, st_info_str, st_info_stb_str,
957 isym->st_other, st_other_str,
958 isym->st_shndx, st_shndx_str);
959 }
960 if (free_internal)
961 free (internal_syms);
962 if (free_external)
963 free (external_syms);
964 }
965
966 char *
967 m32c_get_reloc (long reloc)
968 {
969 if (0 <= reloc && reloc < R_M32C_max)
970 return m32c_elf_howto_table[reloc].name;
971 else
972 return "";
973 }
974 #endif /* DEBUG */
975
976 /* Handle relaxing. */
977
978 /* A subroutine of m32c_elf_relax_section. If the global symbol H
979 is within the low 64k, remove any entry for it in the plt. */
980
981 struct relax_plt_data
982 {
983 asection *splt;
984 bfd_boolean *again;
985 };
986
987 static bfd_boolean
988 m32c_relax_plt_check (struct elf_link_hash_entry *h,
989 PTR xdata)
990 {
991 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
992
993 if (h->plt.offset != (bfd_vma) -1)
994 {
995 bfd_vma address;
996
997 if (h->root.type == bfd_link_hash_undefined
998 || h->root.type == bfd_link_hash_undefweak)
999 address = 0;
1000 else
1001 address = (h->root.u.def.section->output_section->vma
1002 + h->root.u.def.section->output_offset
1003 + h->root.u.def.value);
1004
1005 if (address <= 0xffff)
1006 {
1007 h->plt.offset = -1;
1008 data->splt->size -= 4;
1009 *data->again = TRUE;
1010 }
1011 }
1012
1013 return TRUE;
1014 }
1015
1016 /* A subroutine of m32c_elf_relax_section. If the global symbol H
1017 previously had a plt entry, give it a new entry offset. */
1018
1019 static bfd_boolean
1020 m32c_relax_plt_realloc (struct elf_link_hash_entry *h,
1021 PTR xdata)
1022 {
1023 bfd_vma *entry = (bfd_vma *) xdata;
1024
1025 if (h->plt.offset != (bfd_vma) -1)
1026 {
1027 h->plt.offset = *entry;
1028 *entry += 4;
1029 }
1030
1031 return TRUE;
1032 }
1033
1034 static bfd_boolean
1035 m32c_elf_relax_plt_section (asection *splt,
1036 struct bfd_link_info *info,
1037 bfd_boolean *again)
1038 {
1039 struct relax_plt_data relax_plt_data;
1040 bfd *ibfd;
1041
1042 /* Assume nothing changes. */
1043 *again = FALSE;
1044
1045 if (info->relocatable)
1046 return TRUE;
1047
1048 /* Quick check for an empty plt. */
1049 if (splt->size == 0)
1050 return TRUE;
1051
1052 /* Map across all global symbols; see which ones happen to
1053 fall in the low 64k. */
1054 relax_plt_data.splt = splt;
1055 relax_plt_data.again = again;
1056 elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check,
1057 &relax_plt_data);
1058
1059 /* Likewise for local symbols, though that's somewhat less convenient
1060 as we have to walk the list of input bfds and swap in symbol data. */
1061 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1062 {
1063 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1064 Elf_Internal_Shdr *symtab_hdr;
1065 Elf_Internal_Sym *isymbuf = NULL;
1066 unsigned int idx;
1067
1068 if (! local_plt_offsets)
1069 continue;
1070
1071 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1072 if (symtab_hdr->sh_info != 0)
1073 {
1074 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1075 if (isymbuf == NULL)
1076 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1077 symtab_hdr->sh_info, 0,
1078 NULL, NULL, NULL);
1079 if (isymbuf == NULL)
1080 return FALSE;
1081 }
1082
1083 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1084 {
1085 Elf_Internal_Sym *isym;
1086 asection *tsec;
1087 bfd_vma address;
1088
1089 if (local_plt_offsets[idx] == (bfd_vma) -1)
1090 continue;
1091
1092 isym = &isymbuf[idx];
1093 if (isym->st_shndx == SHN_UNDEF)
1094 continue;
1095 else if (isym->st_shndx == SHN_ABS)
1096 tsec = bfd_abs_section_ptr;
1097 else if (isym->st_shndx == SHN_COMMON)
1098 tsec = bfd_com_section_ptr;
1099 else
1100 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1101
1102 address = (tsec->output_section->vma
1103 + tsec->output_offset
1104 + isym->st_value);
1105 if (address <= 0xffff)
1106 {
1107 local_plt_offsets[idx] = -1;
1108 splt->size -= 4;
1109 *again = TRUE;
1110 }
1111 }
1112
1113 if (isymbuf != NULL
1114 && symtab_hdr->contents != (unsigned char *) isymbuf)
1115 {
1116 if (! info->keep_memory)
1117 free (isymbuf);
1118 else
1119 {
1120 /* Cache the symbols for elf_link_input_bfd. */
1121 symtab_hdr->contents = (unsigned char *) isymbuf;
1122 }
1123 }
1124 }
1125
1126 /* If we changed anything, walk the symbols again to reallocate
1127 .plt entry addresses. */
1128 if (*again && splt->size > 0)
1129 {
1130 bfd_vma entry = 0;
1131
1132 elf_link_hash_traverse (elf_hash_table (info),
1133 m32c_relax_plt_realloc, &entry);
1134
1135 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link_next)
1136 {
1137 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1138 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1139 unsigned int idx;
1140
1141 if (! local_plt_offsets)
1142 continue;
1143
1144 for (idx = 0; idx < nlocals; ++idx)
1145 if (local_plt_offsets[idx] != (bfd_vma) -1)
1146 {
1147 local_plt_offsets[idx] = entry;
1148 entry += 4;
1149 }
1150 }
1151 }
1152
1153 return TRUE;
1154 }
1155
1156 static int
1157 compare_reloc (const void *e1, const void *e2)
1158 {
1159 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
1160 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
1161
1162 if (i1->r_offset == i2->r_offset)
1163 return 0;
1164 else
1165 return i1->r_offset < i2->r_offset ? -1 : 1;
1166 }
1167
1168 #define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
1169 static bfd_vma
1170 m32c_offset_for_reloc (bfd *abfd,
1171 Elf_Internal_Rela *rel,
1172 Elf_Internal_Shdr *symtab_hdr,
1173 Elf_External_Sym_Shndx *shndx_buf ATTRIBUTE_UNUSED,
1174 Elf_Internal_Sym *intsyms)
1175 {
1176 bfd_vma symval;
1177
1178 /* Get the value of the symbol referred to by the reloc. */
1179 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
1180 {
1181 /* A local symbol. */
1182 Elf_Internal_Sym *isym;
1183 asection *ssec;
1184
1185 isym = intsyms + ELF32_R_SYM (rel->r_info);
1186 ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
1187 symval = isym->st_value;
1188 if (ssec)
1189 symval += ssec->output_section->vma
1190 + ssec->output_offset;
1191 }
1192 else
1193 {
1194 unsigned long indx;
1195 struct elf_link_hash_entry *h;
1196
1197 /* An external symbol. */
1198 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1199 h = elf_sym_hashes (abfd)[indx];
1200 BFD_ASSERT (h != NULL);
1201
1202 if (h->root.type != bfd_link_hash_defined
1203 && h->root.type != bfd_link_hash_defweak)
1204 /* This appears to be a reference to an undefined
1205 symbol. Just ignore it--it will be caught by the
1206 regular reloc processing. */
1207 return 0;
1208
1209 symval = (h->root.u.def.value
1210 + h->root.u.def.section->output_section->vma
1211 + h->root.u.def.section->output_offset);
1212 }
1213 return symval;
1214 }
1215
1216 static int bytes_saved = 0;
1217
1218 static int bytes_to_reloc[] = {
1219 R_M32C_NONE,
1220 R_M32C_8,
1221 R_M32C_16,
1222 R_M32C_24,
1223 R_M32C_32
1224 };
1225
1226 /* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1227
1228 /* Mask for the number of relocs associated with this insn. */
1229 #define RLA_RELOCS 0x0000000f
1230 /* Number of bytes gas emitted (before gas's relaxing) */
1231 #define RLA_NBYTES 0x00000ff0
1232
1233 /* If the displacement is within the given range and the new encoding
1234 differs from the old encoding (the index), then the insn can be
1235 relaxed to the new encoding. */
1236 typedef struct {
1237 int bytes;
1238 unsigned int max_disp;
1239 unsigned char new_encoding;
1240 } EncodingTable;
1241
1242 static EncodingTable m16c_addr_encodings[] = {
1243 { 0, 0, 0 }, /* R0 */
1244 { 0, 0, 1 }, /* R1 */
1245 { 0, 0, 2 }, /* R2 */
1246 { 0, 0, 3 }, /* R3 */
1247 { 0, 0, 4 }, /* A0 */
1248 { 0, 0, 5 }, /* A1 */
1249 { 0, 0, 6 }, /* [A0] */
1250 { 0, 0, 7 }, /* [A1] */
1251 { 1, 0, 6 }, /* udsp:8[A0] */
1252 { 1, 0, 7 }, /* udsp:8[A1] */
1253 { 1, 0, 10 }, /* udsp:8[SB] */
1254 { 1, 0, 11 }, /* sdsp:8[FB] */
1255 { 2, 255, 8 }, /* udsp:16[A0] */
1256 { 2, 255, 9 }, /* udsp:16[A1] */
1257 { 2, 255, 10 }, /* udsp:16[SB] */
1258 { 2, 0, 15 }, /* abs:16 */
1259 };
1260
1261 static EncodingTable m16c_jmpaddr_encodings[] = {
1262 { 0, 0, 0 }, /* R0 */
1263 { 0, 0, 1 }, /* R1 */
1264 { 0, 0, 2 }, /* R2 */
1265 { 0, 0, 3 }, /* R3 */
1266 { 0, 0, 4 }, /* A0 */
1267 { 0, 0, 5 }, /* A1 */
1268 { 0, 0, 6 }, /* [A0] */
1269 { 0, 0, 7 }, /* [A1] */
1270 { 1, 0, 6 }, /* udsp:8[A0] */
1271 { 1, 0, 7 }, /* udsp:8[A1] */
1272 { 1, 0, 10 }, /* udsp:8[SB] */
1273 { 1, 0, 11 }, /* sdsp:8[FB] */
1274 { 3, 255, 8 }, /* udsp:20[A0] */
1275 { 3, 255, 9 }, /* udsp:20[A1] */
1276 { 2, 255, 10 }, /* udsp:16[SB] */
1277 { 2, 0, 15 }, /* abs:16 */
1278 };
1279
1280 static EncodingTable m32c_addr_encodings[] = {
1281 { 0, 0, 0 }, /* [A0] */
1282 { 0, 0, 1 }, /* [A1] */
1283 { 0, 0, 2 }, /* A0 */
1284 { 0, 0, 3 }, /* A1 */
1285 { 1, 0, 0 }, /* udsp:8[A0] */
1286 { 1, 0, 1 }, /* udsp:8[A1] */
1287 { 1, 0, 6 }, /* udsp:8[SB] */
1288 { 1, 0, 7 }, /* sdsp:8[FB] */
1289 { 2, 255, 4 }, /* udsp:16[A0] */
1290 { 2, 255, 5 }, /* udsp:16[A1] */
1291 { 2, 255, 6 }, /* udsp:16[SB] */
1292 { 2, 127, 7 }, /* sdsp:16[FB] */
1293 { 3, 65535, 8 }, /* udsp:24[A0] */
1294 { 3, 65535, 9 }, /* udsp:24[A1] */
1295 { 3, 65535, 15 }, /* abs24 */
1296 { 2, 0, 15 }, /* abs16 */
1297 { 0, 0, 16 }, /* R2 */
1298 { 0, 0, 17 }, /* R3 */
1299 { 0, 0, 18 }, /* R0 */
1300 { 0, 0, 19 }, /* R1 */
1301 { 0, 0, 20 }, /* */
1302 { 0, 0, 21 }, /* */
1303 { 0, 0, 22 }, /* */
1304 { 0, 0, 23 }, /* */
1305 { 0, 0, 24 }, /* */
1306 { 0, 0, 25 }, /* */
1307 { 0, 0, 26 }, /* */
1308 { 0, 0, 27 }, /* */
1309 { 0, 0, 28 }, /* */
1310 { 0, 0, 29 }, /* */
1311 { 0, 0, 30 }, /* */
1312 { 0, 0, 31 }, /* */
1313 };
1314
1315 static bfd_boolean
1316 m32c_elf_relax_section
1317 (bfd * abfd,
1318 asection * sec,
1319 struct bfd_link_info * link_info,
1320 bfd_boolean * again)
1321 {
1322 Elf_Internal_Shdr *symtab_hdr;
1323 Elf_Internal_Shdr *shndx_hdr;
1324 Elf_Internal_Rela *internal_relocs;
1325 Elf_Internal_Rela *free_relocs = NULL;
1326 Elf_Internal_Rela *irel, *irelend, *srel;
1327 bfd_byte * contents = NULL;
1328 bfd_byte * free_contents = NULL;
1329 Elf_Internal_Sym *intsyms = NULL;
1330 Elf_Internal_Sym *free_intsyms = NULL;
1331 Elf_External_Sym_Shndx *shndx_buf = NULL;
1332 int machine;
1333
1334 if (abfd == elf_hash_table (link_info)->dynobj
1335 && (sec->flags & SEC_LINKER_CREATED) != 0
1336 && strcmp (sec->name, ".plt") == 0)
1337 return m32c_elf_relax_plt_section (sec, link_info, again);
1338
1339 /* Assume nothing changes. */
1340 *again = FALSE;
1341
1342 machine = elf32_m32c_machine (abfd);
1343
1344 /* We don't have to do anything for a relocatable link, if
1345 this section does not have relocs, or if this is not a
1346 code section. */
1347 if (link_info->relocatable
1348 || (sec->flags & SEC_RELOC) == 0
1349 || sec->reloc_count == 0
1350 || (sec->flags & SEC_CODE) == 0)
1351 return TRUE;
1352
1353 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1354 shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
1355
1356 /* Get the section contents. */
1357 if (elf_section_data (sec)->this_hdr.contents != NULL)
1358 contents = elf_section_data (sec)->this_hdr.contents;
1359 /* Go get them off disk. */
1360 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1361 goto error_return;
1362
1363 /* Read this BFD's symbols. */
1364 /* Get cached copy if it exists. */
1365 if (symtab_hdr->contents != NULL)
1366 {
1367 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1368 }
1369 else
1370 {
1371 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1372 symtab_hdr->contents = (bfd_byte *) intsyms;
1373 }
1374
1375 if (shndx_hdr->sh_size != 0)
1376 {
1377 bfd_size_type amt;
1378
1379 amt = symtab_hdr->sh_info;
1380 amt *= sizeof (Elf_External_Sym_Shndx);
1381 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1382 if (shndx_buf == NULL)
1383 goto error_return;
1384 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
1385 || bfd_bread ((PTR) shndx_buf, amt, abfd) != amt)
1386 goto error_return;
1387 shndx_hdr->contents = (bfd_byte *) shndx_buf;
1388 }
1389
1390 /* Get a copy of the native relocations. */
1391 internal_relocs = (_bfd_elf_link_read_relocs
1392 (abfd, sec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
1393 link_info->keep_memory));
1394 if (internal_relocs == NULL)
1395 goto error_return;
1396 if (! link_info->keep_memory)
1397 free_relocs = internal_relocs;
1398
1399 /* The RL_ relocs must be just before the operand relocs they go
1400 with, so we must sort them to guarantee this. */
1401 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
1402 compare_reloc);
1403
1404 /* Walk through them looking for relaxing opportunities. */
1405 irelend = internal_relocs + sec->reloc_count;
1406
1407 for (irel = internal_relocs; irel < irelend; irel++)
1408 {
1409 bfd_vma symval;
1410 unsigned char *insn, *gap, *einsn;
1411 bfd_vma pc;
1412 bfd_signed_vma pcrel;
1413 int relax_relocs;
1414 int gap_size;
1415 int new_type;
1416 int posn;
1417 int enc;
1418 EncodingTable *enctbl;
1419 EncodingTable *e;
1420
1421 if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
1422 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
1423 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
1424 continue;
1425
1426 srel = irel;
1427
1428 /* There will always be room for the relaxed insn, since it is smaller
1429 than the one it would replace. */
1430 BFD_ASSERT (irel->r_offset < sec->size);
1431
1432 insn = contents + irel->r_offset;
1433 relax_relocs = irel->r_addend % 16;
1434
1435 /* Ok, we only have three relocs we care about, and they're all
1436 fake. The lower four bits of the addend is always the number
1437 of following relocs (hence the qsort above) that are assigned
1438 to this opcode. The next 8 bits of the addend indicates the
1439 number of bytes in the insn. We use the rest of them
1440 ourselves as flags for the more expensive operations (defines
1441 above). The three relocs are:
1442
1443 RL_JUMP: This marks all direct jump insns. We check the
1444 displacement and replace them with shorter jumps if
1445 they're in range. We also use this to find JMP.S
1446 insns and manually shorten them when we delete bytes.
1447 We have to decode these insns to figure out what to
1448 do.
1449
1450 RL_1ADDR: This is a :G or :Q insn, which has a single
1451 "standard" operand. We have to extract the type
1452 field, see if it's a wide displacement, then figure
1453 out if we can replace it with a narrow displacement.
1454 We don't have to decode these insns.
1455
1456 RL_2ADDR: Similarly, but two "standard" operands. Note that
1457 r_addend may still be 1, as standard operands don't
1458 always have displacements. Gas shouldn't give us one
1459 with zero operands, but since we don't know which one
1460 has the displacement, we check them both anyway.
1461
1462 These all point to the beginning of the insn itself, not the
1463 operands.
1464
1465 Note that we only relax one step at a time, relying on the
1466 linker to call us repeatedly. Thus, there is no code for
1467 JMP.A->JMP.B although that will happen in two steps.
1468 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1469 */
1470
1471 /* Get the value of the symbol referred to by the reloc. Just
1472 in case this is the last reloc in the list, use the RL's
1473 addend to choose between this reloc (no addend) or the next
1474 (yes addend, which means at least one following reloc). */
1475 srel = irel + (relax_relocs ? 1 : 0);
1476 symval = OFFSET_FOR_RELOC (srel);
1477
1478 /* Setting gap_size nonzero is the flag which means "something
1479 shrunk". */
1480 gap_size = 0;
1481 gap = NULL;
1482 new_type = ELF32_R_TYPE(srel->r_info);
1483
1484 pc = sec->output_section->vma + sec->output_offset
1485 + srel->r_offset;
1486 pcrel = symval - pc + srel->r_addend;
1487
1488 if (machine == bfd_mach_m16c)
1489 {
1490 /* R8C / M16C */
1491
1492 switch (ELF32_R_TYPE(irel->r_info))
1493 {
1494
1495 case R_M32C_RL_JUMP:
1496 switch (insn[0])
1497 {
1498 case 0xfe: /* jmp.b */
1499 if (pcrel >= 2 && pcrel <= 9)
1500 {
1501 /* Relax JMP.B -> JMP.S. We need to get rid of
1502 the following reloc though. */
1503 insn[0] = 0x60 | (pcrel - 2);
1504 new_type = R_M32C_NONE;
1505 irel->r_addend = 0x10;
1506 gap_size = 1;
1507 gap = insn + 1;
1508 }
1509 break;
1510
1511 case 0xf4: /* jmp.w */
1512 /* 128 is allowed because it will be one byte closer
1513 after relaxing. Likewise for all other pc-rel
1514 jumps. */
1515 if (pcrel <= 128 && pcrel >= -128)
1516 {
1517 /* Relax JMP.W -> JMP.B */
1518 insn[0] = 0xfe;
1519 insn[1] = 0;
1520 new_type = R_M32C_8_PCREL;
1521 gap_size = 1;
1522 gap = insn + 2;
1523 }
1524 break;
1525
1526 case 0xfc: /* jmp.a */
1527 if (pcrel <= 32768 && pcrel >= -32768)
1528 {
1529 /* Relax JMP.A -> JMP.W */
1530 insn[0] = 0xf4;
1531 insn[1] = 0;
1532 insn[2] = 0;
1533 new_type = R_M32C_16_PCREL;
1534 gap_size = 1;
1535 gap = insn + 3;
1536 }
1537 break;
1538
1539 case 0xfd: /* jsr.a */
1540 if (pcrel <= 32768 && pcrel >= -32768)
1541 {
1542 /* Relax JSR.A -> JSR.W */
1543 insn[0] = 0xf5;
1544 insn[1] = 0;
1545 insn[2] = 0;
1546 new_type = R_M32C_16_PCREL;
1547 gap_size = 1;
1548 gap = insn + 3;
1549 }
1550 break;
1551 }
1552 break;
1553
1554 case R_M32C_RL_2ADDR:
1555 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
1556
1557 enctbl = m16c_addr_encodings;
1558 posn = 2;
1559 enc = (insn[1] >> 4) & 0x0f;
1560 e = & enctbl[enc];
1561
1562 if (srel->r_offset == irel->r_offset + posn
1563 && e->new_encoding != enc
1564 && symval <= e->max_disp)
1565 {
1566 insn[1] &= 0x0f;
1567 insn[1] |= e->new_encoding << 4;
1568 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1569 gap = insn + posn + enctbl[e->new_encoding].bytes;
1570 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1571 break;
1572 }
1573 if (relax_relocs == 2)
1574 srel ++;
1575 posn += e->bytes;
1576
1577 goto try_1addr_16;
1578
1579 case R_M32C_RL_1ADDR:
1580 /* xxxx xxxx xxxx dest [disp] */
1581
1582 enctbl = m16c_addr_encodings;
1583 posn = 2;
1584
1585 /* Check the opcode for jumps. We know it's safe to
1586 do this because all 2ADDR insns are at least two
1587 bytes long. */
1588 enc = insn[0] * 256 + insn[1];
1589 enc &= 0xfff0;
1590 if (enc == 0x7d20
1591 || enc == 0x7d00
1592 || enc == 0x7d30
1593 || enc == 0x7d10)
1594 {
1595 enctbl = m16c_jmpaddr_encodings;
1596 }
1597
1598 try_1addr_16:
1599 /* srel, posn, and enc must be set here. */
1600
1601 symval = OFFSET_FOR_RELOC (srel);
1602 enc = insn[1] & 0x0f;
1603 e = & enctbl[enc];
1604
1605 if (srel->r_offset == irel->r_offset + posn
1606 && e->new_encoding != enc
1607 && symval <= e->max_disp)
1608 {
1609 insn[1] &= 0xf0;
1610 insn[1] |= e->new_encoding;
1611 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1612 gap = insn + posn + enctbl[e->new_encoding].bytes;
1613 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1614 break;
1615 }
1616
1617 break;
1618
1619 } /* Ends switch (reloc type) for m16c. */
1620 }
1621 else /* machine == bfd_mach_m32c */
1622 {
1623 /* M32CM / M32C */
1624
1625 switch (ELF32_R_TYPE(irel->r_info))
1626 {
1627
1628 case R_M32C_RL_JUMP:
1629 switch (insn[0])
1630 {
1631 case 0xbb: /* jmp.b */
1632 if (pcrel >= 2 && pcrel <= 9)
1633 {
1634 int p = pcrel - 2;
1635 /* Relax JMP.B -> JMP.S. We need to get rid of
1636 the following reloc though. */
1637 insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
1638 new_type = R_M32C_NONE;
1639 irel->r_addend = 0x10;
1640 gap_size = 1;
1641 gap = insn + 1;
1642 }
1643 break;
1644
1645 case 0xce: /* jmp.w */
1646 if (pcrel <= 128 && pcrel >= -128)
1647 {
1648 /* Relax JMP.W -> JMP.B */
1649 insn[0] = 0xbb;
1650 insn[1] = 0;
1651 new_type = R_M32C_8_PCREL;
1652 gap_size = 1;
1653 gap = insn + 2;
1654 }
1655 break;
1656
1657 case 0xcc: /* jmp.a */
1658 if (pcrel <= 32768 && pcrel >= -32768)
1659 {
1660 /* Relax JMP.A -> JMP.W */
1661 insn[0] = 0xce;
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 case 0xcd: /* jsr.a */
1671 if (pcrel <= 32768 && pcrel >= -32768)
1672 {
1673 /* Relax JSR.A -> JSR.W */
1674 insn[0] = 0xcf;
1675 insn[1] = 0;
1676 insn[2] = 0;
1677 new_type = R_M32C_16_PCREL;
1678 gap_size = 1;
1679 gap = insn + 3;
1680 }
1681 break;
1682 }
1683 break;
1684
1685 case R_M32C_RL_2ADDR:
1686 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
1687
1688 einsn = insn;
1689 posn = 2;
1690 if (einsn[0] == 1)
1691 {
1692 /* prefix; remove it as far as the RL reloc is concerned. */
1693 einsn ++;
1694 posn ++;
1695 }
1696
1697 enctbl = m32c_addr_encodings;
1698 enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
1699 e = & enctbl[enc];
1700
1701 if (srel->r_offset == irel->r_offset + posn
1702 && e->new_encoding != enc
1703 && symval <= e->max_disp)
1704 {
1705 einsn[0] &= 0x8f;
1706 einsn[0] |= (e->new_encoding & 0x1c) << 2;
1707 einsn[1] &= 0xcf;
1708 einsn[1] |= (e->new_encoding & 0x03) << 4;
1709 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1710 gap = insn + posn + enctbl[e->new_encoding].bytes;
1711 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1712 break;
1713 }
1714 if (relax_relocs == 2)
1715 srel ++;
1716 posn += e->bytes;
1717
1718 goto try_1addr_32;
1719
1720 case R_M32C_RL_1ADDR:
1721 /* xxxx DDDx DDxx xxxx [disp] */
1722
1723 einsn = insn;
1724 posn = 2;
1725 if (einsn[0] == 1)
1726 {
1727 /* prefix; remove it as far as the RL reloc is concerned. */
1728 einsn ++;
1729 posn ++;
1730 }
1731
1732 enctbl = m32c_addr_encodings;
1733
1734 try_1addr_32:
1735 /* srel, posn, and enc must be set here. */
1736
1737 symval = OFFSET_FOR_RELOC (srel);
1738 enc = ((einsn[0] & 0x0e) << 1) | ((einsn[1] & 0xc0) >> 6);
1739 e = & enctbl[enc];
1740
1741 if (srel->r_offset == irel->r_offset + posn
1742 && e->new_encoding != enc
1743 && symval <= e->max_disp)
1744 {
1745 einsn[0] &= 0xf1;
1746 einsn[0] |= (e->new_encoding & 0x1c) >> 1;
1747 einsn[1] &= 0x3f;
1748 einsn[1] |= (e->new_encoding & 0x03) << 6;
1749 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1750 gap = insn + posn + enctbl[e->new_encoding].bytes;
1751 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1752 break;
1753 }
1754
1755 break;
1756
1757 } /* Ends switch (reloc type) for m32c. */
1758 }
1759
1760 if (gap_size == 0)
1761 continue;
1762
1763 *again = TRUE;
1764
1765 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
1766
1767 /* Note that we've changed the relocs, section contents, etc. */
1768 elf_section_data (sec)->relocs = internal_relocs;
1769 free_relocs = NULL;
1770
1771 elf_section_data (sec)->this_hdr.contents = contents;
1772 free_contents = NULL;
1773
1774 symtab_hdr->contents = (bfd_byte *) intsyms;
1775 free_intsyms = NULL;
1776
1777 bytes_saved += gap_size;
1778
1779 if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
1780 goto error_return;
1781
1782 } /* next relocation */
1783
1784 if (free_relocs != NULL)
1785 {
1786 free (free_relocs);
1787 free_relocs = NULL;
1788 }
1789
1790 if (free_contents != NULL)
1791 {
1792 if (! link_info->keep_memory)
1793 free (free_contents);
1794 /* Cache the section contents for elf_link_input_bfd. */
1795 else
1796 elf_section_data (sec)->this_hdr.contents = contents;
1797
1798 free_contents = NULL;
1799 }
1800
1801 if (shndx_buf != NULL)
1802 {
1803 shndx_hdr->contents = NULL;
1804 free (shndx_buf);
1805 }
1806
1807 if (free_intsyms != NULL)
1808 {
1809 if (! link_info->keep_memory)
1810 free (free_intsyms);
1811 /* Cache the symbols for elf_link_input_bfd. */
1812 else
1813 {
1814 symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
1815 }
1816
1817 free_intsyms = NULL;
1818 }
1819
1820 return TRUE;
1821
1822 error_return:
1823 if (free_relocs != NULL)
1824 free (free_relocs);
1825 if (free_contents != NULL)
1826 free (free_contents);
1827 if (shndx_buf != NULL)
1828 {
1829 shndx_hdr->contents = NULL;
1830 free (shndx_buf);
1831 }
1832 if (free_intsyms != NULL)
1833 free (free_intsyms);
1834 return FALSE;
1835 }
1836
1837 /* Delete some bytes from a section while relaxing. */
1838
1839 static bfd_boolean
1840 m32c_elf_relax_delete_bytes
1841 (bfd * abfd,
1842 asection * sec,
1843 bfd_vma addr,
1844 int count)
1845 {
1846 Elf_Internal_Shdr *symtab_hdr;
1847 Elf_Internal_Shdr *shndx_hdr;
1848 int sec_shndx;
1849 bfd_byte *contents;
1850 Elf_Internal_Rela *irel;
1851 Elf_Internal_Rela *irelend;
1852 bfd_vma toaddr;
1853 Elf_Internal_Sym *isym;
1854 Elf_Internal_Sym *isymend;
1855 Elf_Internal_Sym *intsyms;
1856 Elf_External_Sym_Shndx *shndx_buf;
1857 Elf_External_Sym_Shndx *shndx;
1858 struct elf_link_hash_entry ** sym_hashes;
1859 struct elf_link_hash_entry ** end_hashes;
1860 unsigned int symcount;
1861
1862 contents = elf_section_data (sec)->this_hdr.contents;
1863
1864 toaddr = sec->size;
1865
1866 irel = elf_section_data (sec)->relocs;
1867 irelend = irel + sec->reloc_count;
1868
1869 /* Actually delete the bytes. */
1870 memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count));
1871 sec->size -= count;
1872
1873 /* Adjust all the relocs. */
1874 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++)
1875 {
1876 /* Get the new reloc address. */
1877 if (irel->r_offset > addr && irel->r_offset < toaddr)
1878 irel->r_offset -= count;
1879
1880 if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
1881 && irel->r_addend == 0x10 /* one byte insn, no relocs */
1882 && irel->r_offset + 1 < addr
1883 && irel->r_offset + 7 > addr)
1884 {
1885 bfd_vma disp;
1886 unsigned char *insn = &contents[irel->r_offset];
1887 disp = *insn;
1888 /* This is a JMP.S, which we have to manually update. */
1889 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1890 {
1891 if ((*insn & 0xf8) != 0x60)
1892 continue;
1893 disp = (disp & 7);
1894 }
1895 else
1896 {
1897 if ((*insn & 0xce) != 0x4a)
1898 continue;
1899 disp = ((disp & 0x30) >> 3) | (disp & 1);
1900 }
1901 if (irel->r_offset + disp + 2 >= addr+count)
1902 {
1903 disp -= count;
1904 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
1905 {
1906 *insn = (*insn & 0xf8) | disp;
1907 }
1908 else
1909 {
1910 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
1911 }
1912 }
1913 }
1914 }
1915
1916 /* Adjust the local symbols defined in this section. */
1917 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
1918 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1919 isym = intsyms;
1920 isymend = isym + symtab_hdr->sh_info;
1921
1922 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1923 shndx_hdr = & elf_tdata (abfd)->symtab_shndx_hdr;
1924 shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
1925 shndx = shndx_buf;
1926
1927 for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
1928 {
1929 /* If the symbol is in the range of memory we just moved, we
1930 have to adjust its value. */
1931 if ((int) isym->st_shndx == sec_shndx
1932 && isym->st_value > addr
1933 && isym->st_value < toaddr)
1934 {
1935 isym->st_value -= count;
1936 }
1937 /* If the symbol *spans* the bytes we just deleted (i.e. it's
1938 *end* is in the moved bytes but it's *start* isn't), then we
1939 must adjust its size. */
1940 if ((int) isym->st_shndx == sec_shndx
1941 && isym->st_value < addr
1942 && isym->st_value + isym->st_size > addr
1943 && isym->st_value + isym->st_size < toaddr)
1944 {
1945 isym->st_size -= count;
1946 }
1947 }
1948
1949 /* Now adjust the global symbols defined in this section. */
1950 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1951 - symtab_hdr->sh_info);
1952 sym_hashes = elf_sym_hashes (abfd);
1953 // sym_hashes += symtab_hdr->sh_info;
1954 end_hashes = sym_hashes + symcount;
1955
1956 for (; sym_hashes < end_hashes; sym_hashes ++)
1957 {
1958 struct elf_link_hash_entry * sym_hash = * sym_hashes;
1959
1960 if (sym_hash &&
1961 (sym_hash->root.type == bfd_link_hash_defined
1962 || sym_hash->root.type == bfd_link_hash_defweak)
1963 && sym_hash->root.u.def.section == sec)
1964 {
1965 if (sym_hash->root.u.def.value > addr
1966 && sym_hash->root.u.def.value < toaddr)
1967 {
1968 sym_hash->root.u.def.value -= count;
1969 }
1970 if (sym_hash->root.u.def.value < addr
1971 && sym_hash->root.u.def.value + sym_hash->size > addr
1972 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
1973 {
1974 sym_hash->size -= count;
1975 }
1976 }
1977 }
1978
1979 return TRUE;
1980 }
1981 \f
1982 /* This is for versions of gcc prior to 4.3. */
1983 static unsigned int
1984 _bfd_m32c_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
1985 {
1986 if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C)
1987 return 2;
1988 return 4;
1989 }
1990
1991 \f
1992
1993 #define ELF_ARCH bfd_arch_m32c
1994 #define ELF_MACHINE_CODE EM_M32C
1995 #define ELF_MACHINE_ALT1 EM_M32C_OLD
1996 #define ELF_MAXPAGESIZE 0x100
1997
1998 #if 0
1999 #define TARGET_BIG_SYM bfd_elf32_m32c_vec
2000 #define TARGET_BIG_NAME "elf32-m32c"
2001 #else
2002 #define TARGET_LITTLE_SYM bfd_elf32_m32c_vec
2003 #define TARGET_LITTLE_NAME "elf32-m32c"
2004 #endif
2005
2006 #define elf_info_to_howto_rel NULL
2007 #define elf_info_to_howto m32c_info_to_howto_rela
2008 #define elf_backend_object_p m32c_elf_object_p
2009 #define elf_backend_relocate_section m32c_elf_relocate_section
2010 #define elf_backend_check_relocs m32c_elf_check_relocs
2011 #define elf_backend_object_p m32c_elf_object_p
2012 #define elf_symbol_leading_char ('_')
2013 #define elf_backend_always_size_sections \
2014 m32c_elf_always_size_sections
2015 #define elf_backend_finish_dynamic_sections \
2016 m32c_elf_finish_dynamic_sections
2017
2018 #define elf_backend_can_gc_sections 1
2019 #define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
2020
2021 #define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
2022 #define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
2023 #define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2024 #define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2025 #define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2026 #define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2027
2028 #include "elf32-target.h"