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