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