projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Pass link_info to _bfd_merge_private_bfd_data
[deliverable/binutils-gdb.git] / bfd / elf32-m32c.c
CommitLineData
49f58d10 1/* M16C/M32C specific support for 32-bit ELF.
6f2750fe 2 Copyright (C) 2005-2016 Free Software Foundation, Inc.
49f58d10
JB		 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
cd123cb7 8 the Free Software Foundation; either version 3 of the License, or
49f58d10
JB		 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
49f58d10 20#include "sysdep.h"
3db64b00 21#include "bfd.h"
49f58d10
JB		 22#include "libbfd.h"
23#include "elf-bfd.h"
24#include "elf/m32c.h"
25#include "libiberty.h"
26
27/* Forward declarations. */
28static reloc_howto_type * m32c_reloc_type_lookup
29 (bfd *, bfd_reloc_code_real_type);
68ffbac6 30static void m32c_info_to_howto_rela
49f58d10 31 (bfd *, arelent *, Elf_Internal_Rela *);
68ffbac6 32static bfd_boolean m32c_elf_relocate_section
49f58d10 33 (bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **);
49f58d10
JB		 34static bfd_boolean m32c_elf_check_relocs
35 (bfd *, struct bfd_link_info *, asection *, const Elf_Internal_Rela *);
36static bfd_boolean m32c_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
37#ifdef DEBUG
e460dd0d
AM		 38char * m32c_get_reloc (long reloc);
39void dump_symtab (bfd *, void *, void *);
49f58d10
JB		 40#endif
41static bfd_boolean m32c_elf_relax_section
42(bfd *abfd, asection *sec, struct bfd_link_info *link_info, bfd_boolean *again);
055173ca
DD		 43static bfd_reloc_status_type m32c_apply_reloc_24
44 (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
49f58d10
JB		 45
46
47static reloc_howto_type m32c_elf_howto_table [] =
48{
49 /* This reloc does nothing. */
50 HOWTO (R_M32C_NONE, /* type */
51 0, /* rightshift */
6346d5ca
AM		 52 3, /* size (0 = byte, 1 = short, 2 = long) */
53 0, /* bitsize */
49f58d10
JB		 54 FALSE, /* pc_relative */
55 0, /* bitpos */
6346d5ca 56 complain_overflow_dont, /* complain_on_overflow */
49f58d10
JB		 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
78eba9b6
DD		 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. */
49f58d10
JB		 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 */
78eba9b6 73 complain_overflow_dont, /* complain_on_overflow */
49f58d10
JB		 74 bfd_elf_generic_reloc, /* special_function */
75 "R_M32C_16", /* name */
76 FALSE, /* partial_inplace */
77 0, /* src_mask */
6772dd07 78 0xffff, /* dst_mask */
49f58d10
JB		 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 */
78eba9b6 87 complain_overflow_dont, /* complain_on_overflow */
055173ca 88 m32c_apply_reloc_24, /* special_function */
49f58d10
JB		 89 "R_M32C_24", /* name */
90 FALSE, /* partial_inplace */
91 0, /* src_mask */
6772dd07 92 0xffffff, /* dst_mask */
49f58d10
JB		 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 */
6772dd07 120 0xff, /* dst_mask */
49f58d10
JB		 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 */
6772dd07 134 0xffff, /* dst_mask */
49f58d10 135 TRUE), /* pcrel_offset */
fd54057a
DD		 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 */
6772dd07 148 0xff, /* dst_mask */
fd54057a
DD		 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 */
6772dd07 162 0xffff, /* dst_mask */
fd54057a
DD		 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 */
6772dd07 176 0xff, /* dst_mask */
fd54057a
DD		 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 */
6772dd07 190 0xffff, /* dst_mask */
fd54057a 191 FALSE), /* pcrel_offset */
6772dd07
DD		 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
49f58d10
JB		 235};
236\f
237/* Map BFD reloc types to M32C ELF reloc types. */
238
239struct m32c_reloc_map
240{
241 bfd_reloc_code_real_type bfd_reloc_val;
242 unsigned int m32c_reloc_val;
243};
244
245static 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 },
fd54057a
DD		 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 },
6772dd07
DD		 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 }
49f58d10
JB		 260};
261
262static reloc_howto_type *
263m32c_reloc_type_lookup
264 (bfd * abfd ATTRIBUTE_UNUSED,
265 bfd_reloc_code_real_type code)
266{
267 unsigned int i;
268
0ba38529 269 for (i = ARRAY_SIZE (m32c_reloc_map); i--;)
49f58d10
JB		 270 if (m32c_reloc_map [i].bfd_reloc_val == code)
271 return & m32c_elf_howto_table [m32c_reloc_map[i].m32c_reloc_val];
68ffbac6 272
49f58d10
JB		 273 return NULL;
274}
275
157090f7
AM		 276static reloc_howto_type *
277m32c_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
49f58d10
JB		 291/* Set the howto pointer for an M32C ELF reloc. */
292
293static void
294m32c_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);
5860e3f8
NC		 302 if (r_type >= (unsigned int) R_M32C_max)
303 {
64d29018 304 _bfd_error_handler (_("%B: invalid M32C reloc number: %d"), abfd, r_type);
5860e3f8
NC		 305 r_type = 0;
306 }
49f58d10
JB		 307 cache_ptr->howto = & m32c_elf_howto_table [r_type];
308}
309
310\f
311
055173ca
DD		 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
321static 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
49f58d10
JB		 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
387static bfd_boolean
388m32c_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)
3d4d4302 412 splt = bfd_get_linker_section (dynobj, ".plt");
49f58d10
JB		 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;
68ffbac6 425
49f58d10 426 r_type = ELF32_R_TYPE (rel->r_info);
6772dd07
DD		 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;
68ffbac6 434
49f58d10
JB		 435 r_symndx = ELF32_R_SYM (rel->r_info);
436
49f58d10
JB		 437 howto = m32c_elf_howto_table + ELF32_R_TYPE (rel->r_info);
438 h = NULL;
439 sym = NULL;
440 sec = NULL;
ab96bf03 441 relocation = 0;
6772dd07 442
49f58d10
JB		 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);
68ffbac6 450
49f58d10
JB		 451 name = bfd_elf_string_from_elf_section
452 (input_bfd, symtab_hdr->sh_link, sym->st_name);
6772dd07 453 name = (sym->st_name == 0) ? bfd_section_name (input_bfd, sec) : name;
49f58d10
JB		 454 }
455 else
456 {
457 h = sym_hashes [r_symndx - symtab_hdr->sh_info];
68ffbac6 458
8a5da09b
AM		 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
49f58d10
JB		 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;
68ffbac6 469
49f58d10
JB		 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)
ab96bf03 479 ;
0e1862bb 480 else if (!bfd_link_relocatable (info))
1a72702b
AM		 481 (*info->callbacks->undefined_symbol) (info, h->root.root.string,
482 input_bfd, input_section,
483 rel->r_offset, TRUE);
49f58d10
JB		 484 }
485
dbaa2011 486 if (sec != NULL && discarded_section (sec))
e4067dbb 487 RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
545fd46b 488 rel, 1, relend, howto, 0, contents);
ab96bf03 489
0e1862bb 490 if (bfd_link_relocatable (info))
ab96bf03
AM		 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
49f58d10
JB		 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));
35520cb7
DD		 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 }
49f58d10
JB		 557 }
558 }
559 break;
fd54057a
DD		 560
561 case R_M32C_HI8:
562 case R_M32C_HI16:
563 relocation >>= 16;
564 break;
49f58d10
JB		 565 }
566
6772dd07 567#if 0
a1013894
DD		 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);
6772dd07
DD		 572 {
573 int i;
574 for (i=0; i<4; i++)
a1013894
DD		 575 printf (" %02x", contents[rel->r_offset+i]);
576 printf ("\n");
6772dd07
DD		 577 }
578#endif
055173ca
DD		 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 }
49f58d10
JB		 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:
1a72702b 613 (*info->callbacks->reloc_overflow)
49f58d10
JB		 614 (info, (h ? &h->root : NULL), name, howto->name, (bfd_vma) 0,
615 input_bfd, input_section, rel->r_offset);
616 break;
68ffbac6 617
49f58d10 618 case bfd_reloc_undefined:
1a72702b
AM		 619 (*info->callbacks->undefined_symbol)
620 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
49f58d10 621 break;
68ffbac6 622
49f58d10
JB		 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)
1a72702b
AM		 641 (*info->callbacks->warning) (info, msg, name, input_bfd,
642 input_section, rel->r_offset);
49f58d10
JB		 643 }
644 }
645
646 return TRUE;
647}
648\f
49f58d10
JB		 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. */
68ffbac6 651
49f58d10
JB		 652static bfd_boolean
653m32c_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;
49f58d10
JB		 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;
68ffbac6 666
0e1862bb 667 if (bfd_link_relocatable (info))
49f58d10 668 return TRUE;
68ffbac6 669
49f58d10
JB		 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
49f58d10
JB		 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;
68ffbac6 682
49f58d10
JB		 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;
81fbe831
AM		 692
693 /* PR15323, ref flags aren't set for references in the same
694 object. */
695 h->root.non_ir_ref = 1;
49f58d10 696 }
68ffbac6 697
49f58d10
JB		 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 {
3d4d4302 708 splt = bfd_get_linker_section (dynobj, ".plt");
49f58d10
JB		 709 if (splt == NULL)
710 {
117ed4f8
AM		 711 flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
712 | SEC_IN_MEMORY | SEC_LINKER_CREATED
713 | SEC_READONLY | SEC_CODE);
87e0a731
AM		 714 splt = bfd_make_section_anyway_with_flags (dynobj, ".plt",
715 flags);
49f58d10 716 if (splt == NULL
49f58d10
JB		 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 }
68ffbac6 751
49f58d10
JB		 752 return TRUE;
753}
754
755/* This must exist if dynobj is ever set. */
756
757static bfd_boolean
758m32c_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
3d4d4302 768 && (splt = bfd_get_linker_section (dynobj, ".plt")) != NULL)
49f58d10
JB		 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
782static bfd_boolean
783m32c_elf_always_size_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
784 struct bfd_link_info *info)
785{
786 bfd *dynobj;
787 asection *splt;
788
0e1862bb 789 if (bfd_link_relocatable (info))
49f58d10
JB		 790 return TRUE;
791
792 dynobj = elf_hash_table (info)->dynobj;
793 if (dynobj == NULL)
794 return TRUE;
795
3d4d4302 796 splt = bfd_get_linker_section (dynobj, ".plt");
49f58d10
JB		 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
808static bfd_boolean
809m32c_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
819static bfd_boolean
50e03d47 820m32c_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
49f58d10 821{
50e03d47 822 bfd *obfd = info->output_bfd;
49f58d10
JB		 823 flagword old_flags, old_partial;
824 flagword new_flags, new_partial;
825 bfd_boolean error = FALSE;
826 char new_opt[80];
827 char old_opt[80];
828
829 new_opt[0] = old_opt[0] = '\0';
830 new_flags = elf_elfheader (ibfd)->e_flags;
831 old_flags = elf_elfheader (obfd)->e_flags;
832
833#ifdef DEBUG
4eca0228
AM		 834 _bfd_error_handler
835 ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
836 old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
837 bfd_get_filename (ibfd));
49f58d10
JB		 838#endif
839
840 if (!elf_flags_init (obfd))
841 {
842 /* First call, no flags set. */
843 elf_flags_init (obfd) = TRUE;
844 elf_elfheader (obfd)->e_flags = new_flags;
845 }
846
847 else if (new_flags == old_flags)
848 /* Compatible flags are ok. */
849 ;
850
851 else /* Possibly incompatible flags. */
852 {
853 /* Warn if different cpu is used (allow a specific cpu to override
854 the generic cpu). */
855 new_partial = (new_flags & EF_M32C_CPU_MASK);
856 old_partial = (old_flags & EF_M32C_CPU_MASK);
857 if (new_partial == old_partial)
858 ;
859
860 else
861 {
862 switch (new_partial)
863 {
864 default: strcat (new_opt, " -m16c"); break;
865 case EF_M32C_CPU_M16C: strcat (new_opt, " -m16c"); break;
866 case EF_M32C_CPU_M32C: strcat (new_opt, " -m32c"); break;
867 }
868
869 switch (old_partial)
870 {
871 default: strcat (old_opt, " -m16c"); break;
872 case EF_M32C_CPU_M16C: strcat (old_opt, " -m16c"); break;
873 case EF_M32C_CPU_M32C: strcat (old_opt, " -m32c"); break;
874 }
875 }
68ffbac6 876
49f58d10
JB		 877 /* Print out any mismatches from above. */
878 if (new_opt[0])
879 {
880 error = TRUE;
4eca0228 881 _bfd_error_handler
49f58d10
JB		 882 (_("%s: compiled with %s and linked with modules compiled with %s"),
883 bfd_get_filename (ibfd), new_opt, old_opt);
884 }
885
886 new_flags &= ~ EF_M32C_ALL_FLAGS;
887 old_flags &= ~ EF_M32C_ALL_FLAGS;
888
889 /* Warn about any other mismatches. */
890 if (new_flags != old_flags)
891 {
892 error = TRUE;
4eca0228 893 _bfd_error_handler
49f58d10
JB		 894 (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
895 bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
896 }
897 }
898
899 if (error)
900 bfd_set_error (bfd_error_bad_value);
901
902 return !error;
903}
904
905\f
906static bfd_boolean
2c3fc389 907m32c_elf_print_private_bfd_data (bfd *abfd, void *ptr)
49f58d10
JB		 908{
909 FILE *file = (FILE *) ptr;
910 flagword flags;
911
912 BFD_ASSERT (abfd != NULL && ptr != NULL);
913
914 /* Print normal ELF private data. */
915 _bfd_elf_print_private_bfd_data (abfd, ptr);
916
917 flags = elf_elfheader (abfd)->e_flags;
0af1713e 918 fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
49f58d10
JB		 919
920 switch (flags & EF_M32C_CPU_MASK)
921 {
922 default: break;
923 case EF_M32C_CPU_M16C: fprintf (file, " -m16c"); break;
924 case EF_M32C_CPU_M32C: fprintf (file, " -m32c"); break;
925 }
926
927 fputc ('\n', file);
928 return TRUE;
929}
930
931/* Return the MACH for an e_flags value. */
932
933static int
934elf32_m32c_machine (bfd *abfd)
935{
936 switch (elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK)
937 {
938 case EF_M32C_CPU_M16C: return bfd_mach_m16c;
939 case EF_M32C_CPU_M32C: return bfd_mach_m32c;
940 }
941
942 return bfd_mach_m16c;
943}
944
945static bfd_boolean
946m32c_elf_object_p (bfd *abfd)
947{
948 bfd_default_set_arch_mach (abfd, bfd_arch_m32c,
949 elf32_m32c_machine (abfd));
950 return TRUE;
951}
952 \f
953
954#ifdef DEBUG
e460dd0d 955void
49f58d10
JB		 956dump_symtab (bfd * abfd, void *internal_syms, void *external_syms)
957{
958 size_t locsymcount;
959 Elf_Internal_Sym *isymbuf;
960 Elf_Internal_Sym *isymend;
961 Elf_Internal_Sym *isym;
962 Elf_Internal_Shdr *symtab_hdr;
963 bfd_boolean free_internal = 0, free_external = 0;
964 char * st_info_str;
965 char * st_info_stb_str;
966 char * st_other_str;
967 char * st_shndx_str;
968
969 if (! internal_syms)
970 {
971 internal_syms = bfd_malloc (1000);
972 free_internal = 1;
973 }
974 if (! external_syms)
975 {
976 external_syms = bfd_malloc (1000);
977 free_external = 1;
978 }
68ffbac6 979
49f58d10
JB		 980 symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
981 locsymcount = symtab_hdr->sh_size / get_elf_backend_data(abfd)->s->sizeof_sym;
982 if (free_internal)
983 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
984 symtab_hdr->sh_info, 0,
985 internal_syms, external_syms, NULL);
986 else
987 isymbuf = internal_syms;
988 isymend = isymbuf + locsymcount;
989
990 for (isym = isymbuf ; isym < isymend ; isym++)
991 {
992 switch (ELF_ST_TYPE (isym->st_info))
993 {
86879d88
SDJ		 994 case STT_FUNC:
995 st_info_str = "STT_FUNC";
996 break;
997
998 case STT_SECTION:
999 st_info_str = "STT_SECTION";
1000 break;
1001
1002 case STT_FILE:
1003 st_info_str = "STT_FILE";
1004 break;
1005
1006 case STT_OBJECT:
1007 st_info_str = "STT_OBJECT";
1008 break;
1009
1010 case STT_TLS:
1011 st_info_str = "STT_TLS";
1012 break;
1013
1014 default:
1015 st_info_str = "";
49f58d10 1016 }
86879d88 1017
49f58d10
JB		 1018 switch (ELF_ST_BIND (isym->st_info))
1019 {
86879d88
SDJ		 1020 case STB_LOCAL:
1021 st_info_stb_str = "STB_LOCAL";
1022 break;
1023
1024 case STB_GLOBAL:
1025 st_info_stb_str = "STB_GLOBAL";
1026 break;
1027
1028 default:
1029 st_info_stb_str = "";
49f58d10 1030 }
86879d88 1031
49f58d10
JB		 1032 switch (ELF_ST_VISIBILITY (isym->st_other))
1033 {
86879d88
SDJ		 1034 case STV_DEFAULT:
1035 st_other_str = "STV_DEFAULT";
1036 break;
1037
1038 case STV_INTERNAL:
1039 st_other_str = "STV_INTERNAL";
1040 break;
1041
1042 case STV_PROTECTED:
1043 st_other_str = "STV_PROTECTED";
1044 break;
1045
1046 default:
1047 st_other_str = "";
49f58d10 1048 }
86879d88 1049
49f58d10
JB		 1050 switch (isym->st_shndx)
1051 {
86879d88
SDJ		 1052 case SHN_ABS:
1053 st_shndx_str = "SHN_ABS";
1054 break;
1055
1056 case SHN_COMMON:
1057 st_shndx_str = "SHN_COMMON";
1058 break;
1059
1060 case SHN_UNDEF:
1061 st_shndx_str = "SHN_UNDEF";
1062 break;
1063
1064 default:
1065 st_shndx_str = "";
49f58d10 1066 }
68ffbac6 1067
49f58d10
JB		 1068 printf ("isym = %p st_value = %lx st_size = %lx st_name = (%lu) %s "
1069 "st_info = (%d) %s %s st_other = (%d) %s st_shndx = (%d) %s\n",
68ffbac6 1070 isym,
49f58d10
JB		 1071 (unsigned long) isym->st_value,
1072 (unsigned long) isym->st_size,
1073 isym->st_name,
1074 bfd_elf_string_from_elf_section (abfd, symtab_hdr->sh_link,
1075 isym->st_name),
1076 isym->st_info, st_info_str, st_info_stb_str,
1077 isym->st_other, st_other_str,
1078 isym->st_shndx, st_shndx_str);
1079 }
1080 if (free_internal)
1081 free (internal_syms);
1082 if (free_external)
1083 free (external_syms);
1084}
1085
e460dd0d 1086char *
49f58d10
JB		 1087m32c_get_reloc (long reloc)
1088{
1089 if (0 <= reloc && reloc < R_M32C_max)
1090 return m32c_elf_howto_table[reloc].name;
1091 else
1092 return "";
1093}
1094#endif /* DEBUG */
1095
1096/* Handle relaxing. */
1097
1098/* A subroutine of m32c_elf_relax_section. If the global symbol H
1099 is within the low 64k, remove any entry for it in the plt. */
1100
1101struct relax_plt_data
1102{
1103 asection *splt;
1104 bfd_boolean *again;
1105};
1106
1107static bfd_boolean
2c3fc389 1108m32c_relax_plt_check (struct elf_link_hash_entry *h, void * xdata)
49f58d10
JB		 1109{
1110 struct relax_plt_data *data = (struct relax_plt_data *) xdata;
1111
49f58d10
JB		 1112 if (h->plt.offset != (bfd_vma) -1)
1113 {
1114 bfd_vma address;
1115
1116 if (h->root.type == bfd_link_hash_undefined
1117 || h->root.type == bfd_link_hash_undefweak)
1118 address = 0;
1119 else
1120 address = (h->root.u.def.section->output_section->vma
1121 + h->root.u.def.section->output_offset
1122 + h->root.u.def.value);
1123
1124 if (address <= 0xffff)
1125 {
1126 h->plt.offset = -1;
1127 data->splt->size -= 4;
1128 *data->again = TRUE;
1129 }
1130 }
1131
1132 return TRUE;
1133}
1134
1135/* A subroutine of m32c_elf_relax_section. If the global symbol H
1136 previously had a plt entry, give it a new entry offset. */
1137
1138static bfd_boolean
2c3fc389 1139m32c_relax_plt_realloc (struct elf_link_hash_entry *h, void * xdata)
49f58d10
JB		 1140{
1141 bfd_vma *entry = (bfd_vma *) xdata;
1142
49f58d10
JB		 1143 if (h->plt.offset != (bfd_vma) -1)
1144 {
1145 h->plt.offset = *entry;
1146 *entry += 4;
1147 }
1148
1149 return TRUE;
1150}
1151
1152static bfd_boolean
87e0a731 1153m32c_elf_relax_plt_section (asection *splt,
49f58d10
JB		 1154 struct bfd_link_info *info,
1155 bfd_boolean *again)
1156{
1157 struct relax_plt_data relax_plt_data;
1158 bfd *ibfd;
1159
1160 /* Assume nothing changes. */
1161 *again = FALSE;
1162
0e1862bb 1163 if (bfd_link_relocatable (info))
49f58d10
JB		 1164 return TRUE;
1165
49f58d10
JB		 1166 /* Quick check for an empty plt. */
1167 if (splt->size == 0)
1168 return TRUE;
1169
1170 /* Map across all global symbols; see which ones happen to
1171 fall in the low 64k. */
1172 relax_plt_data.splt = splt;
1173 relax_plt_data.again = again;
1174 elf_link_hash_traverse (elf_hash_table (info), m32c_relax_plt_check,
1175 &relax_plt_data);
1176
1177 /* Likewise for local symbols, though that's somewhat less convenient
1178 as we have to walk the list of input bfds and swap in symbol data. */
c72f2fb2 1179 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
49f58d10
JB		 1180 {
1181 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1182 Elf_Internal_Shdr *symtab_hdr;
1183 Elf_Internal_Sym *isymbuf = NULL;
1184 unsigned int idx;
1185
1186 if (! local_plt_offsets)
1187 continue;
1188
1189 symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
1190 if (symtab_hdr->sh_info != 0)
1191 {
1192 isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1193 if (isymbuf == NULL)
1194 isymbuf = bfd_elf_get_elf_syms (ibfd, symtab_hdr,
1195 symtab_hdr->sh_info, 0,
1196 NULL, NULL, NULL);
1197 if (isymbuf == NULL)
1198 return FALSE;
1199 }
1200
1201 for (idx = 0; idx < symtab_hdr->sh_info; ++idx)
1202 {
1203 Elf_Internal_Sym *isym;
1204 asection *tsec;
1205 bfd_vma address;
1206
1207 if (local_plt_offsets[idx] == (bfd_vma) -1)
1208 continue;
1209
1210 isym = &isymbuf[idx];
1211 if (isym->st_shndx == SHN_UNDEF)
1212 continue;
1213 else if (isym->st_shndx == SHN_ABS)
1214 tsec = bfd_abs_section_ptr;
1215 else if (isym->st_shndx == SHN_COMMON)
1216 tsec = bfd_com_section_ptr;
1217 else
1218 tsec = bfd_section_from_elf_index (ibfd, isym->st_shndx);
1219
1220 address = (tsec->output_section->vma
1221 + tsec->output_offset
1222 + isym->st_value);
1223 if (address <= 0xffff)
1224 {
1225 local_plt_offsets[idx] = -1;
1226 splt->size -= 4;
1227 *again = TRUE;
1228 }
1229 }
1230
1231 if (isymbuf != NULL
1232 && symtab_hdr->contents != (unsigned char *) isymbuf)
1233 {
1234 if (! info->keep_memory)
1235 free (isymbuf);
1236 else
1237 {
1238 /* Cache the symbols for elf_link_input_bfd. */
1239 symtab_hdr->contents = (unsigned char *) isymbuf;
1240 }
1241 }
1242 }
1243
1244 /* If we changed anything, walk the symbols again to reallocate
1245 .plt entry addresses. */
1246 if (*again && splt->size > 0)
1247 {
1248 bfd_vma entry = 0;
1249
1250 elf_link_hash_traverse (elf_hash_table (info),
1251 m32c_relax_plt_realloc, &entry);
1252
c72f2fb2 1253 for (ibfd = info->input_bfds; ibfd ; ibfd = ibfd->link.next)
49f58d10
JB		 1254 {
1255 bfd_vma *local_plt_offsets = elf_local_got_offsets (ibfd);
1256 unsigned int nlocals = elf_tdata (ibfd)->symtab_hdr.sh_info;
1257 unsigned int idx;
1258
1259 if (! local_plt_offsets)
1260 continue;
1261
1262 for (idx = 0; idx < nlocals; ++idx)
1263 if (local_plt_offsets[idx] != (bfd_vma) -1)
1264 {
1265 local_plt_offsets[idx] = entry;
1266 entry += 4;
1267 }
1268 }
1269 }
1270
1271 return TRUE;
1272}
1273
6772dd07
DD		 1274static int
1275compare_reloc (const void *e1, const void *e2)
49f58d10 1276{
6772dd07
DD		 1277 const Elf_Internal_Rela *i1 = (const Elf_Internal_Rela *) e1;
1278 const Elf_Internal_Rela *i2 = (const Elf_Internal_Rela *) e2;
1279
1280 if (i1->r_offset == i2->r_offset)
1281 return 0;
1282 else
1283 return i1->r_offset < i2->r_offset ? -1 : 1;
1284}
1285
a1013894 1286#define OFFSET_FOR_RELOC(rel) m32c_offset_for_reloc (abfd, rel, symtab_hdr, shndx_buf, intsyms)
6772dd07
DD		 1287static bfd_vma
1288m32c_offset_for_reloc (bfd *abfd,
6772dd07
DD		 1289 Elf_Internal_Rela *rel,
1290 Elf_Internal_Shdr *symtab_hdr,
c7e2358a 1291 Elf_External_Sym_Shndx *shndx_buf ATTRIBUTE_UNUSED,
6772dd07
DD		 1292 Elf_Internal_Sym *intsyms)
1293{
1294 bfd_vma symval;
1295
1296 /* Get the value of the symbol referred to by the reloc. */
1297 if (ELF32_R_SYM (rel->r_info) < symtab_hdr->sh_info)
49f58d10 1298 {
6772dd07
DD		 1299 /* A local symbol. */
1300 Elf_Internal_Sym *isym;
a1013894
DD		 1301 asection *ssec;
1302
6772dd07 1303 isym = intsyms + ELF32_R_SYM (rel->r_info);
a1013894 1304 ssec = bfd_section_from_elf_index (abfd, isym->st_shndx);
a1013894
DD		 1305 symval = isym->st_value;
1306 if (ssec)
1307 symval += ssec->output_section->vma
1308 + ssec->output_offset;
6772dd07
DD		 1309 }
1310 else
49f58d10 1311 {
6772dd07
DD		 1312 unsigned long indx;
1313 struct elf_link_hash_entry *h;
1314
1315 /* An external symbol. */
1316 indx = ELF32_R_SYM (rel->r_info) - symtab_hdr->sh_info;
1317 h = elf_sym_hashes (abfd)[indx];
1318 BFD_ASSERT (h != NULL);
1319
1320 if (h->root.type != bfd_link_hash_defined
1321 && h->root.type != bfd_link_hash_defweak)
1322 /* This appears to be a reference to an undefined
1323 symbol. Just ignore it--it will be caught by the
1324 regular reloc processing. */
1325 return 0;
1326
1327 symval = (h->root.u.def.value
1328 + h->root.u.def.section->output_section->vma
1329 + h->root.u.def.section->output_offset);
49f58d10 1330 }
6772dd07
DD		 1331 return symval;
1332}
1333
1334static int bytes_saved = 0;
1335
1336static int bytes_to_reloc[] = {
1337 R_M32C_NONE,
1338 R_M32C_8,
1339 R_M32C_16,
1340 R_M32C_24,
1341 R_M32C_32
1342};
1343
1344/* What we use the bits in a relax reloc addend (R_M32C_RL_*) for. */
1345
1346/* Mask for the number of relocs associated with this insn. */
1347#define RLA_RELOCS 0x0000000f
1348/* Number of bytes gas emitted (before gas's relaxing) */
1349#define RLA_NBYTES 0x00000ff0
1350
1351/* If the displacement is within the given range and the new encoding
1352 differs from the old encoding (the index), then the insn can be
1353 relaxed to the new encoding. */
1354typedef struct {
1355 int bytes;
1356 unsigned int max_disp;
1357 unsigned char new_encoding;
1358} EncodingTable;
1359
1360static EncodingTable m16c_addr_encodings[] = {
1361 { 0, 0, 0 }, /* R0 */
1362 { 0, 0, 1 }, /* R1 */
1363 { 0, 0, 2 }, /* R2 */
1364 { 0, 0, 3 }, /* R3 */
1365 { 0, 0, 4 }, /* A0 */
1366 { 0, 0, 5 }, /* A1 */
1367 { 0, 0, 6 }, /* [A0] */
1368 { 0, 0, 7 }, /* [A1] */
1369 { 1, 0, 6 }, /* udsp:8[A0] */
1370 { 1, 0, 7 }, /* udsp:8[A1] */
1371 { 1, 0, 10 }, /* udsp:8[SB] */
1372 { 1, 0, 11 }, /* sdsp:8[FB] */
1373 { 2, 255, 8 }, /* udsp:16[A0] */
1374 { 2, 255, 9 }, /* udsp:16[A1] */
1375 { 2, 255, 10 }, /* udsp:16[SB] */
1376 { 2, 0, 15 }, /* abs:16 */
1377};
1378
1379static EncodingTable m16c_jmpaddr_encodings[] = {
1380 { 0, 0, 0 }, /* R0 */
1381 { 0, 0, 1 }, /* R1 */
1382 { 0, 0, 2 }, /* R2 */
1383 { 0, 0, 3 }, /* R3 */
1384 { 0, 0, 4 }, /* A0 */
1385 { 0, 0, 5 }, /* A1 */
1386 { 0, 0, 6 }, /* [A0] */
1387 { 0, 0, 7 }, /* [A1] */
1388 { 1, 0, 6 }, /* udsp:8[A0] */
1389 { 1, 0, 7 }, /* udsp:8[A1] */
1390 { 1, 0, 10 }, /* udsp:8[SB] */
1391 { 1, 0, 11 }, /* sdsp:8[FB] */
1392 { 3, 255, 8 }, /* udsp:20[A0] */
1393 { 3, 255, 9 }, /* udsp:20[A1] */
1394 { 2, 255, 10 }, /* udsp:16[SB] */
1395 { 2, 0, 15 }, /* abs:16 */
1396};
1397
1398static EncodingTable m32c_addr_encodings[] = {
1399 { 0, 0, 0 }, /* [A0] */
1400 { 0, 0, 1 }, /* [A1] */
1401 { 0, 0, 2 }, /* A0 */
1402 { 0, 0, 3 }, /* A1 */
1403 { 1, 0, 0 }, /* udsp:8[A0] */
1404 { 1, 0, 1 }, /* udsp:8[A1] */
1405 { 1, 0, 6 }, /* udsp:8[SB] */
1406 { 1, 0, 7 }, /* sdsp:8[FB] */
1407 { 2, 255, 4 }, /* udsp:16[A0] */
1408 { 2, 255, 5 }, /* udsp:16[A1] */
1409 { 2, 255, 6 }, /* udsp:16[SB] */
1410 { 2, 127, 7 }, /* sdsp:16[FB] */
1411 { 3, 65535, 8 }, /* udsp:24[A0] */
1412 { 3, 65535, 9 }, /* udsp:24[A1] */
1413 { 3, 65535, 15 }, /* abs24 */
1414 { 2, 0, 15 }, /* abs16 */
1415 { 0, 0, 16 }, /* R2 */
1416 { 0, 0, 17 }, /* R3 */
1417 { 0, 0, 18 }, /* R0 */
1418 { 0, 0, 19 }, /* R1 */
1419 { 0, 0, 20 }, /* */
1420 { 0, 0, 21 }, /* */
1421 { 0, 0, 22 }, /* */
1422 { 0, 0, 23 }, /* */
1423 { 0, 0, 24 }, /* */
1424 { 0, 0, 25 }, /* */
1425 { 0, 0, 26 }, /* */
1426 { 0, 0, 27 }, /* */
1427 { 0, 0, 28 }, /* */
1428 { 0, 0, 29 }, /* */
1429 { 0, 0, 30 }, /* */
1430 { 0, 0, 31 }, /* */
1431};
1432
49f58d10
JB		 1433static bfd_boolean
1434m32c_elf_relax_section
1435 (bfd * abfd,
1436 asection * sec,
1437 struct bfd_link_info * link_info,
1438 bfd_boolean * again)
1439{
1440 Elf_Internal_Shdr *symtab_hdr;
1441 Elf_Internal_Shdr *shndx_hdr;
1442 Elf_Internal_Rela *internal_relocs;
1443 Elf_Internal_Rela *free_relocs = NULL;
6772dd07 1444 Elf_Internal_Rela *irel, *irelend, *srel;
49f58d10
JB		 1445 bfd_byte * contents = NULL;
1446 bfd_byte * free_contents = NULL;
6772dd07
DD		 1447 Elf_Internal_Sym *intsyms = NULL;
1448 Elf_Internal_Sym *free_intsyms = NULL;
49f58d10
JB		 1449 Elf_External_Sym_Shndx *shndx_buf = NULL;
1450 int machine;
1451
1452 if (abfd == elf_hash_table (link_info)->dynobj
87e0a731 1453 && (sec->flags & SEC_LINKER_CREATED) != 0
49f58d10 1454 && strcmp (sec->name, ".plt") == 0)
87e0a731 1455 return m32c_elf_relax_plt_section (sec, link_info, again);
49f58d10
JB		 1456
1457 /* Assume nothing changes. */
1458 *again = FALSE;
1459
1460 machine = elf32_m32c_machine (abfd);
1461
1462 /* We don't have to do anything for a relocatable link, if
1463 this section does not have relocs, or if this is not a
1464 code section. */
0e1862bb 1465 if (bfd_link_relocatable (link_info)
49f58d10
JB		 1466 || (sec->flags & SEC_RELOC) == 0
1467 || sec->reloc_count == 0
1468 || (sec->flags & SEC_CODE) == 0)
1469 return TRUE;
1470
6a40cf0c
NC		 1471 symtab_hdr = & elf_symtab_hdr (abfd);
1472 if (elf_symtab_shndx_list (abfd))
1473 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
1474 else
1475 shndx_hdr = NULL;
49f58d10 1476
6772dd07
DD		 1477 /* Get the section contents. */
1478 if (elf_section_data (sec)->this_hdr.contents != NULL)
1479 contents = elf_section_data (sec)->this_hdr.contents;
1480 /* Go get them off disk. */
1481 else if (!bfd_malloc_and_get_section (abfd, sec, &contents))
1482 goto error_return;
1483
1484 /* Read this BFD's symbols. */
1485 /* Get cached copy if it exists. */
1486 if (symtab_hdr->contents != NULL)
1487 {
1488 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
1489 }
1490 else
1491 {
1492 intsyms = bfd_elf_get_elf_syms (abfd, symtab_hdr, symtab_hdr->sh_info, 0, NULL, NULL, NULL);
1493 symtab_hdr->contents = (bfd_byte *) intsyms;
1494 }
1495
6a40cf0c 1496 if (shndx_hdr && shndx_hdr->sh_size != 0)
6772dd07
DD		 1497 {
1498 bfd_size_type amt;
1499
1500 amt = symtab_hdr->sh_info;
1501 amt *= sizeof (Elf_External_Sym_Shndx);
1502 shndx_buf = (Elf_External_Sym_Shndx *) bfd_malloc (amt);
1503 if (shndx_buf == NULL)
1504 goto error_return;
1505 if (bfd_seek (abfd, shndx_hdr->sh_offset, SEEK_SET) != 0
2c3fc389 1506 || bfd_bread (shndx_buf, amt, abfd) != amt)
6772dd07
DD		 1507 goto error_return;
1508 shndx_hdr->contents = (bfd_byte *) shndx_buf;
1509 }
1510
49f58d10
JB		 1511 /* Get a copy of the native relocations. */
1512 internal_relocs = (_bfd_elf_link_read_relocs
2c3fc389 1513 (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
49f58d10
JB		 1514 link_info->keep_memory));
1515 if (internal_relocs == NULL)
1516 goto error_return;
1517 if (! link_info->keep_memory)
1518 free_relocs = internal_relocs;
1519
6772dd07
DD		 1520 /* The RL_ relocs must be just before the operand relocs they go
1521 with, so we must sort them to guarantee this. */
1522 qsort (internal_relocs, sec->reloc_count, sizeof (Elf_Internal_Rela),
1523 compare_reloc);
1524
49f58d10
JB		 1525 /* Walk through them looking for relaxing opportunities. */
1526 irelend = internal_relocs + sec->reloc_count;
1527
1528 for (irel = internal_relocs; irel < irelend; irel++)
1529 {
1530 bfd_vma symval;
6772dd07 1531 unsigned char *insn, *gap, *einsn;
49f58d10 1532 bfd_vma pc;
6772dd07
DD		 1533 bfd_signed_vma pcrel;
1534 int relax_relocs;
1535 int gap_size;
1536 int new_type;
1537 int posn;
1538 int enc;
1539 EncodingTable *enctbl;
1540 EncodingTable *e;
1541
1542 if (ELF32_R_TYPE(irel->r_info) != R_M32C_RL_JUMP
1543 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_1ADDR
1544 && ELF32_R_TYPE(irel->r_info) != R_M32C_RL_2ADDR)
1545 continue;
49f58d10 1546
6772dd07 1547 srel = irel;
49f58d10 1548
6772dd07
DD		 1549 /* There will always be room for the relaxed insn, since it is smaller
1550 than the one it would replace. */
1551 BFD_ASSERT (irel->r_offset < sec->size);
1552
1553 insn = contents + irel->r_offset;
1554 relax_relocs = irel->r_addend % 16;
1555
1556 /* Ok, we only have three relocs we care about, and they're all
1557 fake. The lower four bits of the addend is always the number
1558 of following relocs (hence the qsort above) that are assigned
1559 to this opcode. The next 8 bits of the addend indicates the
1560 number of bytes in the insn. We use the rest of them
1561 ourselves as flags for the more expensive operations (defines
1562 above). The three relocs are:
1563
1564 RL_JUMP: This marks all direct jump insns. We check the
1565 displacement and replace them with shorter jumps if
1566 they're in range. We also use this to find JMP.S
1567 insns and manually shorten them when we delete bytes.
1568 We have to decode these insns to figure out what to
1569 do.
1570
1571 RL_1ADDR: This is a :G or :Q insn, which has a single
1572 "standard" operand. We have to extract the type
1573 field, see if it's a wide displacement, then figure
1574 out if we can replace it with a narrow displacement.
1575 We don't have to decode these insns.
1576
1577 RL_2ADDR: Similarly, but two "standard" operands. Note that
1578 r_addend may still be 1, as standard operands don't
1579 always have displacements. Gas shouldn't give us one
1580 with zero operands, but since we don't know which one
1581 has the displacement, we check them both anyway.
1582
1583 These all point to the beginning of the insn itself, not the
1584 operands.
1585
1586 Note that we only relax one step at a time, relying on the
1587 linker to call us repeatedly. Thus, there is no code for
1588 JMP.A->JMP.B although that will happen in two steps.
1589 Likewise, for 2ADDR relaxes, we do one operand per cycle.
1590 */
1591
1592 /* Get the value of the symbol referred to by the reloc. Just
1593 in case this is the last reloc in the list, use the RL's
1594 addend to choose between this reloc (no addend) or the next
1595 (yes addend, which means at least one following reloc). */
1596 srel = irel + (relax_relocs ? 1 : 0);
1597 symval = OFFSET_FOR_RELOC (srel);
1598
1599 /* Setting gap_size nonzero is the flag which means "something
1600 shrunk". */
1601 gap_size = 0;
e970df31 1602 gap = NULL;
6772dd07
DD		 1603 new_type = ELF32_R_TYPE(srel->r_info);
1604
1605 pc = sec->output_section->vma + sec->output_offset
1606 + srel->r_offset;
1607 pcrel = symval - pc + srel->r_addend;
1608
1609 if (machine == bfd_mach_m16c)
49f58d10 1610 {
6772dd07 1611 /* R8C / M16C */
49f58d10 1612
6772dd07 1613 switch (ELF32_R_TYPE(irel->r_info))
49f58d10 1614 {
49f58d10 1615
6772dd07
DD		 1616 case R_M32C_RL_JUMP:
1617 switch (insn[0])
1618 {
1619 case 0xfe: /* jmp.b */
1620 if (pcrel >= 2 && pcrel <= 9)
1621 {
1622 /* Relax JMP.B -> JMP.S. We need to get rid of
1623 the following reloc though. */
1624 insn[0] = 0x60 | (pcrel - 2);
1625 new_type = R_M32C_NONE;
1626 irel->r_addend = 0x10;
1627 gap_size = 1;
1628 gap = insn + 1;
1629 }
1630 break;
1631
1632 case 0xf4: /* jmp.w */
1633 /* 128 is allowed because it will be one byte closer
1634 after relaxing. Likewise for all other pc-rel
1635 jumps. */
1636 if (pcrel <= 128 && pcrel >= -128)
1637 {
1638 /* Relax JMP.W -> JMP.B */
1639 insn[0] = 0xfe;
1640 insn[1] = 0;
1641 new_type = R_M32C_8_PCREL;
1642 gap_size = 1;
1643 gap = insn + 2;
1644 }
1645 break;
1646
1647 case 0xfc: /* jmp.a */
1648 if (pcrel <= 32768 && pcrel >= -32768)
1649 {
1650 /* Relax JMP.A -> JMP.W */
1651 insn[0] = 0xf4;
1652 insn[1] = 0;
1653 insn[2] = 0;
1654 new_type = R_M32C_16_PCREL;
1655 gap_size = 1;
1656 gap = insn + 3;
1657 }
1658 break;
1659
1660 case 0xfd: /* jsr.a */
1661 if (pcrel <= 32768 && pcrel >= -32768)
1662 {
1663 /* Relax JSR.A -> JSR.W */
1664 insn[0] = 0xf5;
1665 insn[1] = 0;
1666 insn[2] = 0;
1667 new_type = R_M32C_16_PCREL;
1668 gap_size = 1;
1669 gap = insn + 3;
1670 }
1671 break;
1672 }
1673 break;
49f58d10 1674
6772dd07
DD		 1675 case R_M32C_RL_2ADDR:
1676 /* xxxx xxxx srce dest [src-disp] [dest-disp]*/
49f58d10 1677
6772dd07
DD		 1678 enctbl = m16c_addr_encodings;
1679 posn = 2;
1680 enc = (insn[1] >> 4) & 0x0f;
1681 e = & enctbl[enc];
1682
1683 if (srel->r_offset == irel->r_offset + posn
1684 && e->new_encoding != enc
1685 && symval <= e->max_disp)
1686 {
1687 insn[1] &= 0x0f;
1688 insn[1] |= e->new_encoding << 4;
1689 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1690 gap = insn + posn + enctbl[e->new_encoding].bytes;
1691 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1692 break;
1693 }
1694 if (relax_relocs == 2)
1695 srel ++;
1696 posn += e->bytes;
1697
1698 goto try_1addr_16;
49f58d10 1699
6772dd07
DD		 1700 case R_M32C_RL_1ADDR:
1701 /* xxxx xxxx xxxx dest [disp] */
49f58d10 1702
6772dd07
DD		 1703 enctbl = m16c_addr_encodings;
1704 posn = 2;
68ffbac6 1705
6772dd07
DD		 1706 /* Check the opcode for jumps. We know it's safe to
1707 do this because all 2ADDR insns are at least two
1708 bytes long. */
1709 enc = insn[0] * 256 + insn[1];
1710 enc &= 0xfff0;
1711 if (enc == 0x7d20
1712 || enc == 0x7d00
1713 || enc == 0x7d30
1714 || enc == 0x7d10)
1715 {
1716 enctbl = m16c_jmpaddr_encodings;
1717 }
1718
1719 try_1addr_16:
1720 /* srel, posn, and enc must be set here. */
1721
1722 symval = OFFSET_FOR_RELOC (srel);
1723 enc = insn[1] & 0x0f;
1724 e = & enctbl[enc];
1725
1726 if (srel->r_offset == irel->r_offset + posn
1727 && e->new_encoding != enc
1728 && symval <= e->max_disp)
1729 {
1730 insn[1] &= 0xf0;
1731 insn[1] |= e->new_encoding;
1732 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1733 gap = insn + posn + enctbl[e->new_encoding].bytes;
1734 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1735 break;
1736 }
1737
1738 break;
1739
1740 } /* Ends switch (reloc type) for m16c. */
1741 }
1742 else /* machine == bfd_mach_m32c */
49f58d10 1743 {
6772dd07 1744 /* M32CM / M32C */
49f58d10 1745
6772dd07 1746 switch (ELF32_R_TYPE(irel->r_info))
49f58d10 1747 {
49f58d10 1748
6772dd07
DD		 1749 case R_M32C_RL_JUMP:
1750 switch (insn[0])
1751 {
1752 case 0xbb: /* jmp.b */
1753 if (pcrel >= 2 && pcrel <= 9)
1754 {
1755 int p = pcrel - 2;
1756 /* Relax JMP.B -> JMP.S. We need to get rid of
1757 the following reloc though. */
1758 insn[0] = 0x4a | ((p << 3) & 0x30) | (p & 1);
1759 new_type = R_M32C_NONE;
1760 irel->r_addend = 0x10;
1761 gap_size = 1;
1762 gap = insn + 1;
1763 }
1764 break;
1765
1766 case 0xce: /* jmp.w */
1767 if (pcrel <= 128 && pcrel >= -128)
1768 {
1769 /* Relax JMP.W -> JMP.B */
1770 insn[0] = 0xbb;
1771 insn[1] = 0;
1772 new_type = R_M32C_8_PCREL;
1773 gap_size = 1;
1774 gap = insn + 2;
1775 }
1776 break;
1777
1778 case 0xcc: /* jmp.a */
1779 if (pcrel <= 32768 && pcrel >= -32768)
1780 {
1781 /* Relax JMP.A -> JMP.W */
1782 insn[0] = 0xce;
1783 insn[1] = 0;
1784 insn[2] = 0;
1785 new_type = R_M32C_16_PCREL;
1786 gap_size = 1;
1787 gap = insn + 3;
1788 }
1789 break;
1790
1791 case 0xcd: /* jsr.a */
1792 if (pcrel <= 32768 && pcrel >= -32768)
1793 {
1794 /* Relax JSR.A -> JSR.W */
1795 insn[0] = 0xcf;
1796 insn[1] = 0;
1797 insn[2] = 0;
1798 new_type = R_M32C_16_PCREL;
1799 gap_size = 1;
1800 gap = insn + 3;
1801 }
1802 break;
1803 }
1804 break;
49f58d10 1805
6772dd07
DD		 1806 case R_M32C_RL_2ADDR:
1807 /* xSSS DDDx DDSS xxxx [src-disp] [dest-disp]*/
49f58d10 1808
6772dd07
DD		 1809 einsn = insn;
1810 posn = 2;
1811 if (einsn[0] == 1)
1812 {
1813 /* prefix; remove it as far as the RL reloc is concerned. */
1814 einsn ++;
1815 posn ++;
1816 }
49f58d10 1817
6772dd07
DD		 1818 enctbl = m32c_addr_encodings;
1819 enc = ((einsn[0] & 0x70) >> 2) | ((einsn[1] & 0x30) >> 4);
1820 e = & enctbl[enc];
49f58d10 1821
6772dd07
DD		 1822 if (srel->r_offset == irel->r_offset + posn
1823 && e->new_encoding != enc
1824 && symval <= e->max_disp)
1825 {
1826 einsn[0] &= 0x8f;
1827 einsn[0] |= (e->new_encoding & 0x1c) << 2;
1828 einsn[1] &= 0xcf;
1829 einsn[1] |= (e->new_encoding & 0x03) << 4;
1830 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1831 gap = insn + posn + enctbl[e->new_encoding].bytes;
1832 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1833 break;
1834 }
1835 if (relax_relocs == 2)
1836 srel ++;
1837 posn += e->bytes;
1838
1839 goto try_1addr_32;
1840
1841 case R_M32C_RL_1ADDR:
1842 /* xxxx DDDx DDxx xxxx [disp] */
1843
1844 einsn = insn;
1845 posn = 2;
1846 if (einsn[0] == 1)
1847 {
1848 /* prefix; remove it as far as the RL reloc is concerned. */
1849 einsn ++;
1850 posn ++;
1851 }
1852
1853 enctbl = m32c_addr_encodings;
49f58d10 1854
6772dd07
DD		 1855 try_1addr_32:
1856 /* srel, posn, and enc must be set here. */
49f58d10 1857
6772dd07
DD		 1858 symval = OFFSET_FOR_RELOC (srel);
1859 enc = ((einsn[0] & 0x0e) << 1) | ((einsn[1] & 0xc0) >> 6);
1860 e = & enctbl[enc];
49f58d10 1861
6772dd07
DD		 1862 if (srel->r_offset == irel->r_offset + posn
1863 && e->new_encoding != enc
1864 && symval <= e->max_disp)
1865 {
1866 einsn[0] &= 0xf1;
1867 einsn[0] |= (e->new_encoding & 0x1c) >> 1;
1868 einsn[1] &= 0x3f;
1869 einsn[1] |= (e->new_encoding & 0x03) << 6;
1870 gap_size = e->bytes - enctbl[e->new_encoding].bytes;
1871 gap = insn + posn + enctbl[e->new_encoding].bytes;
1872 new_type = bytes_to_reloc[enctbl[e->new_encoding].bytes];
1873 break;
1874 }
1875
1876 break;
1877
1878 } /* Ends switch (reloc type) for m32c. */
1879 }
1880
1881 if (gap_size == 0)
1882 continue;
1883
1884 *again = TRUE;
1885
1886 srel->r_info = ELF32_R_INFO (ELF32_R_SYM (srel->r_info), new_type);
1887
1888 /* Note that we've changed the relocs, section contents, etc. */
1889 elf_section_data (sec)->relocs = internal_relocs;
1890 free_relocs = NULL;
68ffbac6 1891
6772dd07
DD		 1892 elf_section_data (sec)->this_hdr.contents = contents;
1893 free_contents = NULL;
1894
1895 symtab_hdr->contents = (bfd_byte *) intsyms;
1896 free_intsyms = NULL;
1897
1898 bytes_saved += gap_size;
1899
1900 if (! m32c_elf_relax_delete_bytes(abfd, sec, gap - contents, gap_size))
1901 goto error_return;
49f58d10 1902
49f58d10
JB		 1903 } /* next relocation */
1904
1905 if (free_relocs != NULL)
1906 {
1907 free (free_relocs);
1908 free_relocs = NULL;
1909 }
1910
1911 if (free_contents != NULL)
1912 {
1913 if (! link_info->keep_memory)
1914 free (free_contents);
1915 /* Cache the section contents for elf_link_input_bfd. */
1916 else
1917 elf_section_data (sec)->this_hdr.contents = contents;
1918
1919 free_contents = NULL;
1920 }
1921
1922 if (shndx_buf != NULL)
1923 {
1924 shndx_hdr->contents = NULL;
1925 free (shndx_buf);
1926 }
1927
6772dd07 1928 if (free_intsyms != NULL)
49f58d10
JB		 1929 {
1930 if (! link_info->keep_memory)
6772dd07 1931 free (free_intsyms);
49f58d10
JB		 1932 /* Cache the symbols for elf_link_input_bfd. */
1933 else
6772dd07
DD		 1934 {
1935 symtab_hdr->contents = NULL /* (unsigned char *) intsyms*/;
1936 }
49f58d10 1937
6772dd07 1938 free_intsyms = NULL;
49f58d10 1939 }
49f58d10
JB		 1940
1941 return TRUE;
1942
1943 error_return:
1944 if (free_relocs != NULL)
1945 free (free_relocs);
1946 if (free_contents != NULL)
1947 free (free_contents);
1948 if (shndx_buf != NULL)
1949 {
1950 shndx_hdr->contents = NULL;
1951 free (shndx_buf);
1952 }
6772dd07
DD		 1953 if (free_intsyms != NULL)
1954 free (free_intsyms);
49f58d10
JB		 1955 return FALSE;
1956}
1957
1958/* Delete some bytes from a section while relaxing. */
1959
1960static bfd_boolean
1961m32c_elf_relax_delete_bytes
1962 (bfd * abfd,
1963 asection * sec,
1964 bfd_vma addr,
1965 int count)
1966{
1967 Elf_Internal_Shdr *symtab_hdr;
1968 Elf_Internal_Shdr *shndx_hdr;
1969 int sec_shndx;
1970 bfd_byte *contents;
1971 Elf_Internal_Rela *irel;
1972 Elf_Internal_Rela *irelend;
49f58d10 1973 bfd_vma toaddr;
6772dd07
DD		 1974 Elf_Internal_Sym *isym;
1975 Elf_Internal_Sym *isymend;
1976 Elf_Internal_Sym *intsyms;
49f58d10
JB		 1977 Elf_External_Sym_Shndx *shndx_buf;
1978 Elf_External_Sym_Shndx *shndx;
1979 struct elf_link_hash_entry ** sym_hashes;
1980 struct elf_link_hash_entry ** end_hashes;
1981 unsigned int symcount;
6772dd07 1982
49f58d10
JB		 1983 contents = elf_section_data (sec)->this_hdr.contents;
1984
49f58d10
JB		 1985 toaddr = sec->size;
1986
1987 irel = elf_section_data (sec)->relocs;
1988 irelend = irel + sec->reloc_count;
1989
1990 /* Actually delete the bytes. */
1991 memmove (contents + addr, contents + addr + count, (size_t) (toaddr - addr - count));
1992 sec->size -= count;
1993
1994 /* Adjust all the relocs. */
1995 for (irel = elf_section_data (sec)->relocs; irel < irelend; irel ++)
1996 {
1997 /* Get the new reloc address. */
1998 if (irel->r_offset > addr && irel->r_offset < toaddr)
1999 irel->r_offset -= count;
6772dd07
DD		 2000
2001 if (ELF32_R_TYPE(irel->r_info) == R_M32C_RL_JUMP
2002 && irel->r_addend == 0x10 /* one byte insn, no relocs */
2003 && irel->r_offset + 1 < addr
2004 && irel->r_offset + 7 > addr)
2005 {
2006 bfd_vma disp;
2007 unsigned char *insn = &contents[irel->r_offset];
2008 disp = *insn;
2009 /* This is a JMP.S, which we have to manually update. */
2010 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
2011 {
2012 if ((*insn & 0xf8) != 0x60)
2013 continue;
2014 disp = (disp & 7);
2015 }
2016 else
2017 {
2018 if ((*insn & 0xce) != 0x4a)
2019 continue;
2020 disp = ((disp & 0x30) >> 3) | (disp & 1);
2021 }
2022 if (irel->r_offset + disp + 2 >= addr+count)
2023 {
2024 disp -= count;
2025 if (elf32_m32c_machine (abfd) == bfd_mach_m16c)
2026 {
2027 *insn = (*insn & 0xf8) | disp;
2028 }
2029 else
2030 {
2031 *insn = (*insn & 0xce) | ((disp & 6) << 3) | (disp & 1);
2032 }
2033 }
2034 }
49f58d10
JB		 2035 }
2036
2037 /* Adjust the local symbols defined in this section. */
6772dd07
DD		 2038 symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2039 intsyms = (Elf_Internal_Sym *) symtab_hdr->contents;
2040 isym = intsyms;
2041 isymend = isym + symtab_hdr->sh_info;
2042
2043 sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
6a40cf0c
NC		 2044 if (elf_symtab_shndx_list (abfd))
2045 {
2046 shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
2047 shndx_buf = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
2048 }
2049 else
2050 {
2051 shndx_hdr = NULL;
2052 shndx_buf = NULL;
2053 }
49f58d10 2054 shndx = shndx_buf;
49f58d10 2055
6772dd07
DD		 2056 for (; isym < isymend; isym++, shndx = (shndx ? shndx + 1 : NULL))
2057 {
a109e2f5
DD		 2058 /* If the symbol is in the range of memory we just moved, we
2059 have to adjust its value. */
6772dd07
DD		 2060 if ((int) isym->st_shndx == sec_shndx
2061 && isym->st_value > addr
2062 && isym->st_value < toaddr)
49f58d10 2063 {
6772dd07 2064 isym->st_value -= count;
49f58d10 2065 }
a109e2f5
DD		 2066 /* If the symbol *spans* the bytes we just deleted (i.e. it's
2067 *end* is in the moved bytes but it's *start* isn't), then we
2068 must adjust its size. */
2069 if ((int) isym->st_shndx == sec_shndx
2070 && isym->st_value < addr
2071 && isym->st_value + isym->st_size > addr
2072 && isym->st_value + isym->st_size < toaddr)
2073 {
2074 isym->st_size -= count;
2075 }
49f58d10
JB		 2076 }
2077
2078 /* Now adjust the global symbols defined in this section. */
2079 symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
2080 - symtab_hdr->sh_info);
2081 sym_hashes = elf_sym_hashes (abfd);
2082 // sym_hashes += symtab_hdr->sh_info;
2083 end_hashes = sym_hashes + symcount;
2084
2085 for (; sym_hashes < end_hashes; sym_hashes ++)
2086 {
2087 struct elf_link_hash_entry * sym_hash = * sym_hashes;
2088
2089 if (sym_hash &&
a109e2f5 2090 (sym_hash->root.type == bfd_link_hash_defined
49f58d10 2091 || sym_hash->root.type == bfd_link_hash_defweak)
a109e2f5 2092 && sym_hash->root.u.def.section == sec)
6772dd07 2093 {
a109e2f5
DD		 2094 if (sym_hash->root.u.def.value > addr
2095 && sym_hash->root.u.def.value < toaddr)
2096 {
2097 sym_hash->root.u.def.value -= count;
2098 }
2099 if (sym_hash->root.u.def.value < addr
2100 && sym_hash->root.u.def.value + sym_hash->size > addr
2101 && sym_hash->root.u.def.value + sym_hash->size < toaddr)
2102 {
2103 sym_hash->size -= count;
2104 }
6772dd07 2105 }
49f58d10
JB		 2106 }
2107
2108 return TRUE;
2109}
c006d697
DD		 2110\f
2111/* This is for versions of gcc prior to 4.3. */
2112static unsigned int
2113_bfd_m32c_elf_eh_frame_address_size (bfd *abfd, asection *sec ATTRIBUTE_UNUSED)
2114{
2115 if ((elf_elfheader (abfd)->e_flags & EF_M32C_CPU_MASK) == EF_M32C_CPU_M16C)
2116 return 2;
2117 return 4;
2118}
2119
49f58d10
JB		 2120\f
2121
2122#define ELF_ARCH bfd_arch_m32c
2123#define ELF_MACHINE_CODE EM_M32C
ff7eeb89 2124#define ELF_MACHINE_ALT1 EM_M32C_OLD
e1be4b13 2125#define ELF_MAXPAGESIZE 0x100
49f58d10
JB		 2126
2127#if 0
6d00b590 2128#define TARGET_BIG_SYM m32c_elf32_vec
49f58d10
JB		 2129#define TARGET_BIG_NAME "elf32-m32c"
2130#else
6d00b590 2131#define TARGET_LITTLE_SYM m32c_elf32_vec
49f58d10
JB		 2132#define TARGET_LITTLE_NAME "elf32-m32c"
2133#endif
2134
2135#define elf_info_to_howto_rel NULL
2136#define elf_info_to_howto m32c_info_to_howto_rela
2137#define elf_backend_object_p m32c_elf_object_p
2138#define elf_backend_relocate_section m32c_elf_relocate_section
49f58d10
JB		 2139#define elf_backend_check_relocs m32c_elf_check_relocs
2140#define elf_backend_object_p m32c_elf_object_p
2141#define elf_symbol_leading_char ('_')
2142#define elf_backend_always_size_sections \
2143 m32c_elf_always_size_sections
2144#define elf_backend_finish_dynamic_sections \
2145 m32c_elf_finish_dynamic_sections
2146
2147#define elf_backend_can_gc_sections 1
c006d697 2148#define elf_backend_eh_frame_address_size _bfd_m32c_elf_eh_frame_address_size
49f58d10
JB		 2149
2150#define bfd_elf32_bfd_reloc_type_lookup m32c_reloc_type_lookup
157090f7 2151#define bfd_elf32_bfd_reloc_name_lookup m32c_reloc_name_lookup
49f58d10
JB		 2152#define bfd_elf32_bfd_relax_section m32c_elf_relax_section
2153#define bfd_elf32_bfd_set_private_flags m32c_elf_set_private_flags
2154#define bfd_elf32_bfd_merge_private_bfd_data m32c_elf_merge_private_bfd_data
2155#define bfd_elf32_bfd_print_private_bfd_data m32c_elf_print_private_bfd_data
2156
2157#include "elf32-target.h"
GDB Binutils - Deliverables
This page took 0.658962 seconds and 4 git commands to generate.