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