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