]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - bfd/elf32-m32c.c
projects / thirdparty / binutils-gdb.git / blob
? search:


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