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