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