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