1 /* Matsushita 10200 specific support for 32-bit ELF
2    Copyright (C) 1996-2021 Free Software Foundation, Inc.
3 
4    This file is part of BFD, the Binary File Descriptor library.
5 
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10 
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15 
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20 
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 
26 static bool
27 mn10200_elf_relax_delete_bytes (bfd *, asection *, bfd_vma, int);
28 static bool
29 mn10200_elf_symbol_address_p (bfd *, asection *, Elf_Internal_Sym *, bfd_vma);
30 
31 enum reloc_type
32 {
33   R_MN10200_NONE = 0,
34   R_MN10200_32,
35   R_MN10200_16,
36   R_MN10200_8,
37   R_MN10200_24,
38   R_MN10200_PCREL8,
39   R_MN10200_PCREL16,
40   R_MN10200_PCREL24,
41   R_MN10200_MAX
42 };
43 
44 static reloc_howto_type elf_mn10200_howto_table[] =
45 {
46   /* Dummy relocation.  Does nothing.  */
47   HOWTO (R_MN10200_NONE,
48 	 0,
49 	 3,
50 	 0,
51 	 false,
52 	 0,
53 	 complain_overflow_dont,
54 	 bfd_elf_generic_reloc,
55 	 "R_MN10200_NONE",
56 	 false,
57 	 0,
58 	 0,
59 	 false),
60   /* Standard 32 bit reloc.  */
61   HOWTO (R_MN10200_32,
62 	 0,
63 	 2,
64 	 32,
65 	 false,
66 	 0,
67 	 complain_overflow_bitfield,
68 	 bfd_elf_generic_reloc,
69 	 "R_MN10200_32",
70 	 false,
71 	 0xffffffff,
72 	 0xffffffff,
73 	 false),
74   /* Standard 16 bit reloc.  */
75   HOWTO (R_MN10200_16,
76 	 0,
77 	 1,
78 	 16,
79 	 false,
80 	 0,
81 	 complain_overflow_bitfield,
82 	 bfd_elf_generic_reloc,
83 	 "R_MN10200_16",
84 	 false,
85 	 0xffff,
86 	 0xffff,
87 	 false),
88   /* Standard 8 bit reloc.  */
89   HOWTO (R_MN10200_8,
90 	 0,
91 	 0,
92 	 8,
93 	 false,
94 	 0,
95 	 complain_overflow_bitfield,
96 	 bfd_elf_generic_reloc,
97 	 "R_MN10200_8",
98 	 false,
99 	 0xff,
100 	 0xff,
101 	 false),
102   /* Standard 24 bit reloc.  */
103   HOWTO (R_MN10200_24,
104 	 0,
105 	 2,
106 	 24,
107 	 false,
108 	 0,
109 	 complain_overflow_bitfield,
110 	 bfd_elf_generic_reloc,
111 	 "R_MN10200_24",
112 	 false,
113 	 0xffffff,
114 	 0xffffff,
115 	 false),
116   /* Simple 8 pc-relative reloc.  */
117   HOWTO (R_MN10200_PCREL8,
118 	 0,
119 	 0,
120 	 8,
121 	 true,
122 	 0,
123 	 complain_overflow_bitfield,
124 	 bfd_elf_generic_reloc,
125 	 "R_MN10200_PCREL8",
126 	 false,
127 	 0xff,
128 	 0xff,
129 	 true),
130   /* Simple 16 pc-relative reloc.  */
131   HOWTO (R_MN10200_PCREL16,
132 	 0,
133 	 1,
134 	 16,
135 	 true,
136 	 0,
137 	 complain_overflow_bitfield,
138 	 bfd_elf_generic_reloc,
139 	 "R_MN10200_PCREL16",
140 	 false,
141 	 0xffff,
142 	 0xffff,
143 	 true),
144   /* Simple 32bit pc-relative reloc with a 1 byte adjustment
145      to get the pc-relative offset correct.  */
146   HOWTO (R_MN10200_PCREL24,
147 	 0,
148 	 2,
149 	 24,
150 	 true,
151 	 0,
152 	 complain_overflow_bitfield,
153 	 bfd_elf_generic_reloc,
154 	 "R_MN10200_PCREL24",
155 	 false,
156 	 0xffffff,
157 	 0xffffff,
158 	 true),
159 };
160 
161 struct mn10200_reloc_map
162 {
163   bfd_reloc_code_real_type bfd_reloc_val;
164   unsigned char elf_reloc_val;
165 };
166 
167 static const struct mn10200_reloc_map mn10200_reloc_map[] =
168 {
169   { BFD_RELOC_NONE    , R_MN10200_NONE   , },
170   { BFD_RELOC_32      , R_MN10200_32     , },
171   { BFD_RELOC_16      , R_MN10200_16     , },
172   { BFD_RELOC_8       , R_MN10200_8      , },
173   { BFD_RELOC_24      , R_MN10200_24     , },
174   { BFD_RELOC_8_PCREL , R_MN10200_PCREL8 , },
175   { BFD_RELOC_16_PCREL, R_MN10200_PCREL16, },
176   { BFD_RELOC_24_PCREL, R_MN10200_PCREL24, },
177 };
178 
179 static reloc_howto_type *
bfd_elf32_bfd_reloc_type_lookup(bfd * abfd ATTRIBUTE_UNUSED,bfd_reloc_code_real_type code)180 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
181 				 bfd_reloc_code_real_type code)
182 {
183   unsigned int i;
184 
185   for (i = 0;
186        i < sizeof (mn10200_reloc_map) / sizeof (struct mn10200_reloc_map);
187        i++)
188     {
189       if (mn10200_reloc_map[i].bfd_reloc_val == code)
190 	return &elf_mn10200_howto_table[mn10200_reloc_map[i].elf_reloc_val];
191     }
192 
193   return NULL;
194 }
195 
196 static reloc_howto_type *
bfd_elf32_bfd_reloc_name_lookup(bfd * abfd ATTRIBUTE_UNUSED,const char * r_name)197 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
198 				 const char *r_name)
199 {
200   unsigned int i;
201 
202   for (i = 0;
203        i < (sizeof (elf_mn10200_howto_table)
204 	    / sizeof (elf_mn10200_howto_table[0]));
205        i++)
206     if (elf_mn10200_howto_table[i].name != NULL
207 	&& strcasecmp (elf_mn10200_howto_table[i].name, r_name) == 0)
208       return &elf_mn10200_howto_table[i];
209 
210   return NULL;
211 }
212 
213 /* Set the howto pointer for an MN10200 ELF reloc.  */
214 
215 static bool
mn10200_info_to_howto(bfd * abfd,arelent * cache_ptr,Elf_Internal_Rela * dst)216 mn10200_info_to_howto (bfd *abfd,
217 		       arelent *cache_ptr,
218 		       Elf_Internal_Rela *dst)
219 {
220   unsigned int r_type;
221 
222   r_type = ELF32_R_TYPE (dst->r_info);
223   if (r_type >= (unsigned int) R_MN10200_MAX)
224     {
225       /* xgettext:c-format */
226       _bfd_error_handler (_("%pB: unsupported relocation type %#x"),
227 			  abfd, r_type);
228       bfd_set_error (bfd_error_bad_value);
229       return false;
230     }
231 
232   cache_ptr->howto = &elf_mn10200_howto_table[r_type];
233   return cache_ptr->howto != NULL;
234 }
235 
236 /* Perform a relocation as part of a final link.  */
237 
238 static bfd_reloc_status_type
mn10200_elf_final_link_relocate(reloc_howto_type * howto,bfd * input_bfd,bfd * output_bfd ATTRIBUTE_UNUSED,asection * input_section,bfd_byte * contents,bfd_vma offset,bfd_vma value,bfd_vma addend,struct bfd_link_info * info ATTRIBUTE_UNUSED,asection * sym_sec ATTRIBUTE_UNUSED,int is_local ATTRIBUTE_UNUSED)239 mn10200_elf_final_link_relocate (reloc_howto_type *howto,
240 				 bfd *input_bfd,
241 				 bfd *output_bfd ATTRIBUTE_UNUSED,
242 				 asection *input_section,
243 				 bfd_byte *contents,
244 				 bfd_vma offset,
245 				 bfd_vma value,
246 				 bfd_vma addend,
247 				 struct bfd_link_info *info ATTRIBUTE_UNUSED,
248 				 asection *sym_sec ATTRIBUTE_UNUSED,
249 				 int is_local ATTRIBUTE_UNUSED)
250 {
251   unsigned long r_type = howto->type;
252   bfd_byte *hit_data = contents + offset;
253 
254   switch (r_type)
255     {
256 
257     case R_MN10200_NONE:
258       return bfd_reloc_ok;
259 
260     case R_MN10200_32:
261       value += addend;
262       bfd_put_32 (input_bfd, value, hit_data);
263       return bfd_reloc_ok;
264 
265     case R_MN10200_16:
266       value += addend;
267 
268       if ((long) value > 0x7fff || (long) value < -0x8000)
269 	return bfd_reloc_overflow;
270 
271       bfd_put_16 (input_bfd, value, hit_data);
272       return bfd_reloc_ok;
273 
274     case R_MN10200_8:
275       value += addend;
276 
277       if ((long) value > 0x7f || (long) value < -0x80)
278 	return bfd_reloc_overflow;
279 
280       bfd_put_8 (input_bfd, value, hit_data);
281       return bfd_reloc_ok;
282 
283     case R_MN10200_24:
284       value += addend;
285 
286       if ((long) value > 0x7fffff || (long) value < -0x800000)
287 	return bfd_reloc_overflow;
288 
289       value &= 0xffffff;
290       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
291       bfd_put_32 (input_bfd, value, hit_data);
292       return bfd_reloc_ok;
293 
294     case R_MN10200_PCREL8:
295       value -= (input_section->output_section->vma
296 		+ input_section->output_offset);
297       value -= (offset + 1);
298       value += addend;
299 
300       if ((long) value > 0xff || (long) value < -0x100)
301 	return bfd_reloc_overflow;
302 
303       bfd_put_8 (input_bfd, value, hit_data);
304       return bfd_reloc_ok;
305 
306     case R_MN10200_PCREL16:
307       value -= (input_section->output_section->vma
308 		+ input_section->output_offset);
309       value -= (offset + 2);
310       value += addend;
311 
312       if ((long) value > 0xffff || (long) value < -0x10000)
313 	return bfd_reloc_overflow;
314 
315       bfd_put_16 (input_bfd, value, hit_data);
316       return bfd_reloc_ok;
317 
318     case R_MN10200_PCREL24:
319       value -= (input_section->output_section->vma
320 		+ input_section->output_offset);
321       value -= (offset + 3);
322       value += addend;
323 
324       if ((long) value > 0xffffff || (long) value < -0x1000000)
325 	return bfd_reloc_overflow;
326 
327       value &= 0xffffff;
328       value |= (bfd_get_32 (input_bfd, hit_data) & 0xff000000);
329       bfd_put_32 (input_bfd, value, hit_data);
330       return bfd_reloc_ok;
331 
332     default:
333       return bfd_reloc_notsupported;
334     }
335 }
336 
337 /* Relocate an MN10200 ELF section.  */
338 static int
mn10200_elf_relocate_section(bfd * output_bfd,struct bfd_link_info * info,bfd * input_bfd,asection * input_section,bfd_byte * contents,Elf_Internal_Rela * relocs,Elf_Internal_Sym * local_syms,asection ** local_sections)339 mn10200_elf_relocate_section (bfd *output_bfd,
340 			      struct bfd_link_info *info,
341 			      bfd *input_bfd,
342 			      asection *input_section,
343 			      bfd_byte *contents,
344 			      Elf_Internal_Rela *relocs,
345 			      Elf_Internal_Sym *local_syms,
346 			      asection **local_sections)
347 {
348   Elf_Internal_Shdr *symtab_hdr;
349   struct elf_link_hash_entry **sym_hashes;
350   Elf_Internal_Rela *rel, *relend;
351 
352   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
353   sym_hashes = elf_sym_hashes (input_bfd);
354 
355   rel = relocs;
356   relend = relocs + input_section->reloc_count;
357   for (; rel < relend; rel++)
358     {
359       int r_type;
360       reloc_howto_type *howto;
361       unsigned long r_symndx;
362       Elf_Internal_Sym *sym;
363       asection *sec;
364       struct elf_link_hash_entry *h;
365       bfd_vma relocation;
366       bfd_reloc_status_type r;
367 
368       r_symndx = ELF32_R_SYM (rel->r_info);
369       r_type = ELF32_R_TYPE (rel->r_info);
370       howto = elf_mn10200_howto_table + r_type;
371 
372       h = NULL;
373       sym = NULL;
374       sec = NULL;
375       if (r_symndx < symtab_hdr->sh_info)
376 	{
377 	  sym = local_syms + r_symndx;
378 	  sec = local_sections[r_symndx];
379 	  relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
380 	}
381       else
382 	{
383 	  bool unresolved_reloc, warned, ignored;
384 
385 	  RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
386 				   r_symndx, symtab_hdr, sym_hashes,
387 				   h, sec, relocation,
388 				   unresolved_reloc, warned, ignored);
389 	}
390 
391       if (sec != NULL && discarded_section (sec))
392 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
393 					 rel, 1, relend, howto, 0, contents);
394 
395       if (bfd_link_relocatable (info))
396 	continue;
397 
398       r = mn10200_elf_final_link_relocate (howto, input_bfd, output_bfd,
399 					   input_section,
400 					   contents, rel->r_offset,
401 					   relocation, rel->r_addend,
402 					   info, sec, h == NULL);
403 
404       if (r != bfd_reloc_ok)
405 	{
406 	  const char *name;
407 	  const char *msg = (const char *) 0;
408 
409 	  if (h != NULL)
410 	    name = h->root.root.string;
411 	  else
412 	    {
413 	      name = (bfd_elf_string_from_elf_section
414 		      (input_bfd, symtab_hdr->sh_link, sym->st_name));
415 	      if (name == NULL || *name == '\0')
416 		name = bfd_section_name (sec);
417 	    }
418 
419 	  switch (r)
420 	    {
421 	    case bfd_reloc_overflow:
422 	      (*info->callbacks->reloc_overflow)
423 		(info, (h ? &h->root : NULL), name, howto->name,
424 		 (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
425 	      break;
426 
427 	    case bfd_reloc_undefined:
428 	      (*info->callbacks->undefined_symbol) (info, name, input_bfd,
429 						    input_section,
430 						    rel->r_offset, true);
431 	      break;
432 
433 	    case bfd_reloc_outofrange:
434 	      msg = _("internal error: out of range error");
435 	      goto common_error;
436 
437 	    case bfd_reloc_notsupported:
438 	      msg = _("internal error: unsupported relocation error");
439 	      goto common_error;
440 
441 	    case bfd_reloc_dangerous:
442 	      msg = _("internal error: dangerous error");
443 	      goto common_error;
444 
445 	    default:
446 	      msg = _("internal error: unknown error");
447 	      /* fall through */
448 
449 	    common_error:
450 	      (*info->callbacks->warning) (info, msg, name, input_bfd,
451 					   input_section, rel->r_offset);
452 	      break;
453 	    }
454 	}
455     }
456 
457   return true;
458 }
459 
460 /* Delete some bytes from a section while relaxing.  */
461 
462 static bool
mn10200_elf_relax_delete_bytes(bfd * abfd,asection * sec,bfd_vma addr,int count)463 mn10200_elf_relax_delete_bytes (bfd *abfd, asection *sec,
464 				bfd_vma addr, int count)
465 {
466   Elf_Internal_Shdr *symtab_hdr;
467   unsigned int sec_shndx;
468   bfd_byte *contents;
469   Elf_Internal_Rela *irel, *irelend;
470   bfd_vma toaddr;
471   Elf_Internal_Sym *isym;
472   Elf_Internal_Sym *isymend;
473   struct elf_link_hash_entry **sym_hashes;
474   struct elf_link_hash_entry **end_hashes;
475   unsigned int symcount;
476 
477   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
478 
479   contents = elf_section_data (sec)->this_hdr.contents;
480 
481   toaddr = sec->size;
482 
483   irel = elf_section_data (sec)->relocs;
484   irelend = irel + sec->reloc_count;
485 
486   /* Actually delete the bytes.  */
487   memmove (contents + addr, contents + addr + count,
488 	   (size_t) (toaddr - addr - count));
489   sec->size -= count;
490 
491   /* Adjust all the relocs.  */
492   for (irel = elf_section_data (sec)->relocs; irel < irelend; irel++)
493     {
494       /* Get the new reloc address.  */
495       if ((irel->r_offset > addr
496 	   && irel->r_offset < toaddr))
497 	irel->r_offset -= count;
498     }
499 
500   /* Adjust the local symbols defined in this section.  */
501   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
502   isym = (Elf_Internal_Sym *) symtab_hdr->contents;
503   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
504     {
505       if (isym->st_shndx == sec_shndx
506 	  && isym->st_value > addr
507 	  && isym->st_value < toaddr)
508 	isym->st_value -= count;
509     }
510 
511   /* Now adjust the global symbols defined in this section.  */
512   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
513 	      - symtab_hdr->sh_info);
514   sym_hashes = elf_sym_hashes (abfd);
515   end_hashes = sym_hashes + symcount;
516   for (; sym_hashes < end_hashes; sym_hashes++)
517     {
518       struct elf_link_hash_entry *sym_hash = *sym_hashes;
519       if ((sym_hash->root.type == bfd_link_hash_defined
520 	   || sym_hash->root.type == bfd_link_hash_defweak)
521 	  && sym_hash->root.u.def.section == sec
522 	  && sym_hash->root.u.def.value > addr
523 	  && sym_hash->root.u.def.value < toaddr)
524 	{
525 	  sym_hash->root.u.def.value -= count;
526 	}
527     }
528 
529   return true;
530 }
531 
532 /* This function handles relaxing for the mn10200.
533 
534    There are quite a few relaxing opportunities available on the mn10200:
535 
536 	* jsr:24 -> jsr:16					   2 bytes
537 
538 	* jmp:24 -> jmp:16					   2 bytes
539 	* jmp:16 -> bra:8					   1 byte
540 
541 		* If the previous instruction is a conditional branch
542 		around the jump/bra, we may be able to reverse its condition
543 		and change its target to the jump's target.  The jump/bra
544 		can then be deleted.				   2 bytes
545 
546 	* mov abs24 -> mov abs16	2 byte savings
547 
548 	* Most instructions which accept imm24 can relax to imm16  2 bytes
549 	- Most instructions which accept imm16 can relax to imm8   1 byte
550 
551 	* Most instructions which accept d24 can relax to d16	   2 bytes
552 	- Most instructions which accept d16 can relax to d8	   1 byte
553 
554 	abs24, imm24, d24 all look the same at the reloc level.  It
555 	might make the code simpler if we had different relocs for
556 	the various relaxable operand types.
557 
558 	We don't handle imm16->imm8 or d16->d8 as they're very rare
559 	and somewhat more difficult to support.  */
560 
561 static bool
mn10200_elf_relax_section(bfd * abfd,asection * sec,struct bfd_link_info * link_info,bool * again)562 mn10200_elf_relax_section (bfd *abfd,
563 			   asection *sec,
564 			   struct bfd_link_info *link_info,
565 			   bool *again)
566 {
567   Elf_Internal_Shdr *symtab_hdr;
568   Elf_Internal_Rela *internal_relocs;
569   Elf_Internal_Rela *irel, *irelend;
570   bfd_byte *contents = NULL;
571   Elf_Internal_Sym *isymbuf = NULL;
572 
573   /* Assume nothing changes.  */
574   *again = false;
575 
576   /* We don't have to do anything for a relocatable link, if
577      this section does not have relocs, or if this is not a
578      code section.  */
579   if (bfd_link_relocatable (link_info)
580       || (sec->flags & SEC_RELOC) == 0
581       || sec->reloc_count == 0
582       || (sec->flags & SEC_CODE) == 0)
583     return true;
584 
585   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
586 
587   /* Get a copy of the native relocations.  */
588   internal_relocs = (_bfd_elf_link_read_relocs
589 		     (abfd, sec, NULL, (Elf_Internal_Rela *) NULL,
590 		      link_info->keep_memory));
591   if (internal_relocs == NULL)
592     goto error_return;
593 
594   /* Walk through them looking for relaxing opportunities.  */
595   irelend = internal_relocs + sec->reloc_count;
596   for (irel = internal_relocs; irel < irelend; irel++)
597     {
598       bfd_vma symval;
599 
600       /* If this isn't something that can be relaxed, then ignore
601 	 this reloc.  */
602       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_NONE
603 	  || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_8
604 	  || ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_MAX)
605 	continue;
606 
607       /* Get the section contents if we haven't done so already.  */
608       if (contents == NULL)
609 	{
610 	  /* Get cached copy if it exists.  */
611 	  if (elf_section_data (sec)->this_hdr.contents != NULL)
612 	    contents = elf_section_data (sec)->this_hdr.contents;
613 	  else
614 	    {
615 	      /* Go get them off disk.  */
616 	      if (!bfd_malloc_and_get_section (abfd, sec, &contents))
617 		goto error_return;
618 	    }
619 	}
620 
621       /* Read this BFD's local symbols if we haven't done so already.  */
622       if (isymbuf == NULL && symtab_hdr->sh_info != 0)
623 	{
624 	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
625 	  if (isymbuf == NULL)
626 	    isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
627 					    symtab_hdr->sh_info, 0,
628 					    NULL, NULL, NULL);
629 	  if (isymbuf == NULL)
630 	    goto error_return;
631 	}
632 
633       /* Get the value of the symbol referred to by the reloc.  */
634       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
635 	{
636 	  /* A local symbol.  */
637 	  Elf_Internal_Sym *isym;
638 	  asection *sym_sec;
639 
640 	  isym = isymbuf + ELF32_R_SYM (irel->r_info);
641 	  if (isym->st_shndx == SHN_UNDEF)
642 	    sym_sec = bfd_und_section_ptr;
643 	  else if (isym->st_shndx == SHN_ABS)
644 	    sym_sec = bfd_abs_section_ptr;
645 	  else if (isym->st_shndx == SHN_COMMON)
646 	    sym_sec = bfd_com_section_ptr;
647 	  else
648 	    sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
649 	  symval = (isym->st_value
650 		    + sym_sec->output_section->vma
651 		    + sym_sec->output_offset);
652 	}
653       else
654 	{
655 	  unsigned long indx;
656 	  struct elf_link_hash_entry *h;
657 
658 	  /* An external symbol.  */
659 	  indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
660 	  h = elf_sym_hashes (abfd)[indx];
661 	  BFD_ASSERT (h != NULL);
662 	  if (h->root.type != bfd_link_hash_defined
663 	      && h->root.type != bfd_link_hash_defweak)
664 	    {
665 	      /* This appears to be a reference to an undefined
666 		 symbol.  Just ignore it--it will be caught by the
667 		 regular reloc processing.  */
668 	      continue;
669 	    }
670 
671 	  symval = (h->root.u.def.value
672 		    + h->root.u.def.section->output_section->vma
673 		    + h->root.u.def.section->output_offset);
674 	}
675 
676       /* For simplicity of coding, we are going to modify the section
677 	 contents, the section relocs, and the BFD symbol table.  We
678 	 must tell the rest of the code not to free up this
679 	 information.  It would be possible to instead create a table
680 	 of changes which have to be made, as is done in coff-mips.c;
681 	 that would be more work, but would require less memory when
682 	 the linker is run.  */
683 
684       /* Try to turn a 24bit pc-relative branch/call into a 16bit pc-relative
685 	 branch/call.  */
686       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL24)
687 	{
688 	  bfd_vma value = symval;
689 
690 	  /* Deal with pc-relative gunk.  */
691 	  value -= (sec->output_section->vma + sec->output_offset);
692 	  value -= (irel->r_offset + 3);
693 	  value += irel->r_addend;
694 
695 	  /* See if the value will fit in 16 bits, note the high value is
696 	     0x7fff + 2 as the target will be two bytes closer if we are
697 	     able to relax.  */
698 	  if ((long) value < 0x8001 && (long) value > -0x8000)
699 	    {
700 	      unsigned char code;
701 
702 	      /* Get the opcode.  */
703 	      code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
704 
705 	      if (code != 0xe0 && code != 0xe1)
706 		continue;
707 
708 	      /* Note that we've changed the relocs, section contents, etc.  */
709 	      elf_section_data (sec)->relocs = internal_relocs;
710 	      elf_section_data (sec)->this_hdr.contents = contents;
711 	      symtab_hdr->contents = (unsigned char *) isymbuf;
712 
713 	      /* Fix the opcode.  */
714 	      if (code == 0xe0)
715 		bfd_put_8 (abfd, 0xfc, contents + irel->r_offset - 2);
716 	      else if (code == 0xe1)
717 		bfd_put_8 (abfd, 0xfd, contents + irel->r_offset - 2);
718 
719 	      /* Fix the relocation's type.  */
720 	      irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
721 					   R_MN10200_PCREL16);
722 
723 	      /* The opcode got shorter too, so we have to fix the offset.  */
724 	      irel->r_offset -= 1;
725 
726 	      /* Delete two bytes of data.  */
727 	      if (!mn10200_elf_relax_delete_bytes (abfd, sec,
728 						   irel->r_offset + 1, 2))
729 		goto error_return;
730 
731 	      /* That will change things, so, we should relax again.
732 		 Note that this is not required, and it may be slow.  */
733 	      *again = true;
734 	    }
735 	}
736 
737       /* Try to turn a 16bit pc-relative branch into a 8bit pc-relative
738 	 branch.  */
739       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL16)
740 	{
741 	  bfd_vma value = symval;
742 
743 	  /* Deal with pc-relative gunk.  */
744 	  value -= (sec->output_section->vma + sec->output_offset);
745 	  value -= (irel->r_offset + 2);
746 	  value += irel->r_addend;
747 
748 	  /* See if the value will fit in 8 bits, note the high value is
749 	     0x7f + 1 as the target will be one bytes closer if we are
750 	     able to relax.  */
751 	  if ((long) value < 0x80 && (long) value > -0x80)
752 	    {
753 	      unsigned char code;
754 
755 	      /* Get the opcode.  */
756 	      code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
757 
758 	      if (code != 0xfc)
759 		continue;
760 
761 	      /* Note that we've changed the relocs, section contents, etc.  */
762 	      elf_section_data (sec)->relocs = internal_relocs;
763 	      elf_section_data (sec)->this_hdr.contents = contents;
764 	      symtab_hdr->contents = (unsigned char *) isymbuf;
765 
766 	      /* Fix the opcode.  */
767 	      bfd_put_8 (abfd, 0xea, contents + irel->r_offset - 1);
768 
769 	      /* Fix the relocation's type.  */
770 	      irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
771 					   R_MN10200_PCREL8);
772 
773 	      /* Delete one byte of data.  */
774 	      if (!mn10200_elf_relax_delete_bytes (abfd, sec,
775 						   irel->r_offset + 1, 1))
776 		goto error_return;
777 
778 	      /* That will change things, so, we should relax again.
779 		 Note that this is not required, and it may be slow.  */
780 	      *again = true;
781 	    }
782 	}
783 
784       /* Try to eliminate an unconditional 8 bit pc-relative branch
785 	 which immediately follows a conditional 8 bit pc-relative
786 	 branch around the unconditional branch.
787 
788 	    original:		new:
789 	    bCC lab1		bCC' lab2
790 	    bra lab2
791 	   lab1:	       lab1:
792 
793 	 This happens when the bCC can't reach lab2 at assembly time,
794 	 but due to other relaxations it can reach at link time.  */
795       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_PCREL8)
796 	{
797 	  Elf_Internal_Rela *nrel;
798 	  bfd_vma value = symval;
799 	  unsigned char code;
800 
801 	  /* Deal with pc-relative gunk.  */
802 	  value -= (sec->output_section->vma + sec->output_offset);
803 	  value -= (irel->r_offset + 1);
804 	  value += irel->r_addend;
805 
806 	  /* Do nothing if this reloc is the last byte in the section.  */
807 	  if (irel->r_offset == sec->size)
808 	    continue;
809 
810 	  /* See if the next instruction is an unconditional pc-relative
811 	     branch, more often than not this test will fail, so we
812 	     test it first to speed things up.  */
813 	  code = bfd_get_8 (abfd, contents + irel->r_offset + 1);
814 	  if (code != 0xea)
815 	    continue;
816 
817 	  /* Also make sure the next relocation applies to the next
818 	     instruction and that it's a pc-relative 8 bit branch.  */
819 	  nrel = irel + 1;
820 	  if (nrel == irelend
821 	      || irel->r_offset + 2 != nrel->r_offset
822 	      || ELF32_R_TYPE (nrel->r_info) != (int) R_MN10200_PCREL8)
823 	    continue;
824 
825 	  /* Make sure our destination immediately follows the
826 	     unconditional branch.  */
827 	  if (symval != (sec->output_section->vma + sec->output_offset
828 			 + irel->r_offset + 3))
829 	    continue;
830 
831 	  /* Now make sure we are a conditional branch.  This may not
832 	     be necessary, but why take the chance.
833 
834 	     Note these checks assume that R_MN10200_PCREL8 relocs
835 	     only occur on bCC and bCCx insns.  If they occured
836 	     elsewhere, we'd need to know the start of this insn
837 	     for this check to be accurate.  */
838 	  code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
839 	  if (code != 0xe0 && code != 0xe1 && code != 0xe2
840 	      && code != 0xe3 && code != 0xe4 && code != 0xe5
841 	      && code != 0xe6 && code != 0xe7 && code != 0xe8
842 	      && code != 0xe9 && code != 0xec && code != 0xed
843 	      && code != 0xee && code != 0xef && code != 0xfc
844 	      && code != 0xfd && code != 0xfe && code != 0xff)
845 	    continue;
846 
847 	  /* We also have to be sure there is no symbol/label
848 	     at the unconditional branch.  */
849 	  if (mn10200_elf_symbol_address_p (abfd, sec, isymbuf,
850 					    irel->r_offset + 1))
851 	    continue;
852 
853 	  /* Note that we've changed the relocs, section contents, etc.  */
854 	  elf_section_data (sec)->relocs = internal_relocs;
855 	  elf_section_data (sec)->this_hdr.contents = contents;
856 	  symtab_hdr->contents = (unsigned char *) isymbuf;
857 
858 	  /* Reverse the condition of the first branch.  */
859 	  switch (code)
860 	    {
861 	    case 0xfc:
862 	      code = 0xfd;
863 	      break;
864 	    case 0xfd:
865 	      code = 0xfc;
866 	      break;
867 	    case 0xfe:
868 	      code = 0xff;
869 	      break;
870 	    case 0xff:
871 	      code = 0xfe;
872 	      break;
873 	    case 0xe8:
874 	      code = 0xe9;
875 	      break;
876 	    case 0xe9:
877 	      code = 0xe8;
878 	      break;
879 	    case 0xe0:
880 	      code = 0xe2;
881 	      break;
882 	    case 0xe2:
883 	      code = 0xe0;
884 	      break;
885 	    case 0xe3:
886 	      code = 0xe1;
887 	      break;
888 	    case 0xe1:
889 	      code = 0xe3;
890 	      break;
891 	    case 0xe4:
892 	      code = 0xe6;
893 	      break;
894 	    case 0xe6:
895 	      code = 0xe4;
896 	      break;
897 	    case 0xe7:
898 	      code = 0xe5;
899 	      break;
900 	    case 0xe5:
901 	      code = 0xe7;
902 	      break;
903 	    case 0xec:
904 	      code = 0xed;
905 	      break;
906 	    case 0xed:
907 	      code = 0xec;
908 	      break;
909 	    case 0xee:
910 	      code = 0xef;
911 	      break;
912 	    case 0xef:
913 	      code = 0xee;
914 	      break;
915 	    }
916 	  bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
917 
918 	  /* Set the reloc type and symbol for the first branch
919 	     from the second branch.  */
920 	  irel->r_info = nrel->r_info;
921 
922 	  /* Make the reloc for the second branch a null reloc.  */
923 	  nrel->r_info = ELF32_R_INFO (ELF32_R_SYM (nrel->r_info),
924 				       R_MN10200_NONE);
925 
926 	  /* Delete two bytes of data.  */
927 	  if (!mn10200_elf_relax_delete_bytes (abfd, sec,
928 					       irel->r_offset + 1, 2))
929 	    goto error_return;
930 
931 	  /* That will change things, so, we should relax again.
932 	     Note that this is not required, and it may be slow.  */
933 	  *again = true;
934 	}
935 
936       /* Try to turn a 24bit immediate, displacement or absolute address
937 	 into a 16bit immediate, displacement or absolute address.  */
938       if (ELF32_R_TYPE (irel->r_info) == (int) R_MN10200_24)
939 	{
940 	  bfd_vma value = symval;
941 
942 	  /* See if the value will fit in 16 bits.
943 	     We allow any 16bit match here.  We prune those we can't
944 	     handle below.  */
945 	  if ((long) value < 0x7fff && (long) value > -0x8000)
946 	    {
947 	      unsigned char code;
948 
949 	      /* All insns which have 24bit operands are 5 bytes long,
950 		 the first byte will always be 0xf4, but we double check
951 		 it just in case.  */
952 
953 	      /* Get the first opcode.  */
954 	      code = bfd_get_8 (abfd, contents + irel->r_offset - 2);
955 
956 	      if (code != 0xf4)
957 		continue;
958 
959 	      /* Get the second opcode.  */
960 	      code = bfd_get_8 (abfd, contents + irel->r_offset - 1);
961 
962 	      switch (code & 0xfc)
963 		{
964 		/* mov imm24,dn -> mov imm16,dn */
965 		case 0x70:
966 		  /* Not safe if the high bit is on as relaxing may
967 		     move the value out of high mem and thus not fit
968 		     in a signed 16bit value.  */
969 		  if (value & 0x8000)
970 		    continue;
971 
972 		  /* Note that we've changed the relocation contents, etc.  */
973 		  elf_section_data (sec)->relocs = internal_relocs;
974 		  elf_section_data (sec)->this_hdr.contents = contents;
975 		  symtab_hdr->contents = (unsigned char *) isymbuf;
976 
977 		  /* Fix the opcode.  */
978 		  bfd_put_8 (abfd, 0xf8 + (code & 0x03),
979 			     contents + irel->r_offset - 2);
980 
981 		  /* Fix the relocation's type.  */
982 		  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
983 					       R_MN10200_16);
984 
985 		  /* The opcode got shorter too, so we have to fix the
986 		     offset.  */
987 		  irel->r_offset -= 1;
988 
989 		  /* Delete two bytes of data.  */
990 		  if (!mn10200_elf_relax_delete_bytes (abfd, sec,
991 						       irel->r_offset + 1, 2))
992 		    goto error_return;
993 
994 		  /* That will change things, so, we should relax again.
995 		     Note that this is not required, and it may be slow.  */
996 		  *again = true;
997 		  break;
998 
999 		/* mov imm24,an -> mov imm16,an
1000 		   cmp imm24,an -> cmp imm16,an
1001 		   mov (abs24),dn -> mov (abs16),dn
1002 		   mov dn,(abs24) -> mov dn,(abs16)
1003 		   movb dn,(abs24) -> movb dn,(abs16)
1004 		   movbu (abs24),dn -> movbu (abs16),dn */
1005 		case 0x74:
1006 		case 0x7c:
1007 		case 0xc0:
1008 		case 0x40:
1009 		case 0x44:
1010 		case 0xc8:
1011 		  /* Note that we've changed the relocation contents, etc.  */
1012 		  elf_section_data (sec)->relocs = internal_relocs;
1013 		  elf_section_data (sec)->this_hdr.contents = contents;
1014 		  symtab_hdr->contents = (unsigned char *) isymbuf;
1015 
1016 		  if ((code & 0xfc) == 0x74)
1017 		    code = 0xdc + (code & 0x03);
1018 		  else if ((code & 0xfc) == 0x7c)
1019 		    code = 0xec + (code & 0x03);
1020 		  else if ((code & 0xfc) == 0xc0)
1021 		    code = 0xc8 + (code & 0x03);
1022 		  else if ((code & 0xfc) == 0x40)
1023 		    code = 0xc0 + (code & 0x03);
1024 		  else if ((code & 0xfc) == 0x44)
1025 		    code = 0xc4 + (code & 0x03);
1026 		  else if ((code & 0xfc) == 0xc8)
1027 		    code = 0xcc + (code & 0x03);
1028 
1029 		  /* Fix the opcode.  */
1030 		  bfd_put_8 (abfd, code, contents + irel->r_offset - 2);
1031 
1032 		  /* Fix the relocation's type.  */
1033 		  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1034 					       R_MN10200_16);
1035 
1036 		  /* The opcode got shorter too, so we have to fix the
1037 		     offset.  */
1038 		  irel->r_offset -= 1;
1039 
1040 		  /* Delete two bytes of data.  */
1041 		  if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1042 						       irel->r_offset + 1, 2))
1043 		    goto error_return;
1044 
1045 		  /* That will change things, so, we should relax again.
1046 		     Note that this is not required, and it may be slow.  */
1047 		  *again = true;
1048 		  break;
1049 
1050 		/* cmp imm24,dn -> cmp imm16,dn
1051 		   mov (abs24),an -> mov (abs16),an
1052 		   mov an,(abs24) -> mov an,(abs16)
1053 		   add imm24,dn -> add imm16,dn
1054 		   add imm24,an -> add imm16,an
1055 		   sub imm24,dn -> sub imm16,dn
1056 		   sub imm24,an -> sub imm16,an
1057 		   And all d24->d16 in memory ops.  */
1058 		case 0x78:
1059 		case 0xd0:
1060 		case 0x50:
1061 		case 0x60:
1062 		case 0x64:
1063 		case 0x68:
1064 		case 0x6c:
1065 		case 0x80:
1066 		case 0xf0:
1067 		case 0x00:
1068 		case 0x10:
1069 		case 0xb0:
1070 		case 0x30:
1071 		case 0xa0:
1072 		case 0x20:
1073 		case 0x90:
1074 		  /* Not safe if the high bit is on as relaxing may
1075 		     move the value out of high mem and thus not fit
1076 		     in a signed 16bit value.  */
1077 		  if (((code & 0xfc) == 0x78
1078 		       || (code & 0xfc) == 0x60
1079 		       || (code & 0xfc) == 0x64
1080 		       || (code & 0xfc) == 0x68
1081 		       || (code & 0xfc) == 0x6c
1082 		       || (code & 0xfc) == 0x80
1083 		       || (code & 0xfc) == 0xf0
1084 		       || (code & 0xfc) == 0x00
1085 		       || (code & 0xfc) == 0x10
1086 		       || (code & 0xfc) == 0xb0
1087 		       || (code & 0xfc) == 0x30
1088 		       || (code & 0xfc) == 0xa0
1089 		       || (code & 0xfc) == 0x20
1090 		       || (code & 0xfc) == 0x90)
1091 		      && (value & 0x8000) != 0)
1092 		    continue;
1093 
1094 		  /* Note that we've changed the relocation contents, etc.  */
1095 		  elf_section_data (sec)->relocs = internal_relocs;
1096 		  elf_section_data (sec)->this_hdr.contents = contents;
1097 		  symtab_hdr->contents = (unsigned char *) isymbuf;
1098 
1099 		  /* Fix the opcode.  */
1100 		  bfd_put_8 (abfd, 0xf7, contents + irel->r_offset - 2);
1101 
1102 		  if ((code & 0xfc) == 0x78)
1103 		    code = 0x48 + (code & 0x03);
1104 		  else if ((code & 0xfc) == 0xd0)
1105 		    code = 0x30 + (code & 0x03);
1106 		  else if ((code & 0xfc) == 0x50)
1107 		    code = 0x20 + (code & 0x03);
1108 		  else if ((code & 0xfc) == 0x60)
1109 		    code = 0x18 + (code & 0x03);
1110 		  else if ((code & 0xfc) == 0x64)
1111 		    code = 0x08 + (code & 0x03);
1112 		  else if ((code & 0xfc) == 0x68)
1113 		    code = 0x1c + (code & 0x03);
1114 		  else if ((code & 0xfc) == 0x6c)
1115 		    code = 0x0c + (code & 0x03);
1116 		  else if ((code & 0xfc) == 0x80)
1117 		    code = 0xc0 + (code & 0x07);
1118 		  else if ((code & 0xfc) == 0xf0)
1119 		    code = 0xb0 + (code & 0x07);
1120 		  else if ((code & 0xfc) == 0x00)
1121 		    code = 0x80 + (code & 0x07);
1122 		  else if ((code & 0xfc) == 0x10)
1123 		    code = 0xa0 + (code & 0x07);
1124 		  else if ((code & 0xfc) == 0xb0)
1125 		    code = 0x70 + (code & 0x07);
1126 		  else if ((code & 0xfc) == 0x30)
1127 		    code = 0x60 + (code & 0x07);
1128 		  else if ((code & 0xfc) == 0xa0)
1129 		    code = 0xd0 + (code & 0x07);
1130 		  else if ((code & 0xfc) == 0x20)
1131 		    code = 0x90 + (code & 0x07);
1132 		  else if ((code & 0xfc) == 0x90)
1133 		    code = 0x50 + (code & 0x07);
1134 
1135 		  bfd_put_8 (abfd, code, contents + irel->r_offset - 1);
1136 
1137 		  /* Fix the relocation's type.  */
1138 		  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1139 					       R_MN10200_16);
1140 
1141 		  /* Delete one bytes of data.  */
1142 		  if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1143 						       irel->r_offset + 2, 1))
1144 		    goto error_return;
1145 
1146 		  /* That will change things, so, we should relax again.
1147 		     Note that this is not required, and it may be slow.  */
1148 		  *again = true;
1149 		  break;
1150 
1151 		/* movb (abs24),dn ->movbu (abs16),dn extxb bn */
1152 		case 0xc4:
1153 		  /* Note that we've changed the reldection contents, etc.  */
1154 		  elf_section_data (sec)->relocs = internal_relocs;
1155 		  elf_section_data (sec)->this_hdr.contents = contents;
1156 		  symtab_hdr->contents = (unsigned char *) isymbuf;
1157 
1158 		  bfd_put_8 (abfd, 0xcc + (code & 0x03),
1159 			     contents + irel->r_offset - 2);
1160 
1161 		  bfd_put_8 (abfd, 0xb8 + (code & 0x03),
1162 			     contents + irel->r_offset - 1);
1163 
1164 		  /* Fix the relocation's type.  */
1165 		  irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
1166 					       R_MN10200_16);
1167 
1168 		  /* The reloc will be applied one byte in front of its
1169 		     current location.  */
1170 		  irel->r_offset -= 1;
1171 
1172 		  /* Delete one bytes of data.  */
1173 		  if (!mn10200_elf_relax_delete_bytes (abfd, sec,
1174 						       irel->r_offset + 2, 1))
1175 		    goto error_return;
1176 
1177 		  /* That will change things, so, we should relax again.
1178 		     Note that this is not required, and it may be slow.  */
1179 		  *again = true;
1180 		  break;
1181 		}
1182 	    }
1183 	}
1184     }
1185 
1186   if (isymbuf != NULL
1187       && symtab_hdr->contents != (unsigned char *) isymbuf)
1188     {
1189       if (! link_info->keep_memory)
1190 	free (isymbuf);
1191       else
1192 	{
1193 	  /* Cache the symbols for elf_link_input_bfd.  */
1194 	  symtab_hdr->contents = (unsigned char *) isymbuf;
1195 	}
1196     }
1197 
1198   if (contents != NULL
1199       && elf_section_data (sec)->this_hdr.contents != contents)
1200     {
1201       if (! link_info->keep_memory)
1202 	free (contents);
1203       else
1204 	{
1205 	  /* Cache the section contents for elf_link_input_bfd.  */
1206 	  elf_section_data (sec)->this_hdr.contents = contents;
1207 	}
1208     }
1209 
1210   if (elf_section_data (sec)->relocs != internal_relocs)
1211     free (internal_relocs);
1212 
1213   return true;
1214 
1215  error_return:
1216   if (symtab_hdr->contents != (unsigned char *) isymbuf)
1217     free (isymbuf);
1218   if (elf_section_data (sec)->this_hdr.contents != contents)
1219     free (contents);
1220   if (elf_section_data (sec)->relocs != internal_relocs)
1221     free (internal_relocs);
1222 
1223   return false;
1224 }
1225 
1226 /* Return TRUE if a symbol exists at the given address, else return
1227    FALSE.  */
1228 static bool
mn10200_elf_symbol_address_p(bfd * abfd,asection * sec,Elf_Internal_Sym * isym,bfd_vma addr)1229 mn10200_elf_symbol_address_p (bfd *abfd,
1230 			      asection *sec,
1231 			      Elf_Internal_Sym *isym,
1232 			      bfd_vma addr)
1233 {
1234   Elf_Internal_Shdr *symtab_hdr;
1235   unsigned int sec_shndx;
1236   Elf_Internal_Sym *isymend;
1237   struct elf_link_hash_entry **sym_hashes;
1238   struct elf_link_hash_entry **end_hashes;
1239   unsigned int symcount;
1240 
1241   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
1242 
1243   /* Examine all the local symbols.  */
1244   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1245   for (isymend = isym + symtab_hdr->sh_info; isym < isymend; isym++)
1246     {
1247       if (isym->st_shndx == sec_shndx
1248 	  && isym->st_value == addr)
1249 	return true;
1250     }
1251 
1252   symcount = (symtab_hdr->sh_size / sizeof (Elf32_External_Sym)
1253 	      - symtab_hdr->sh_info);
1254   sym_hashes = elf_sym_hashes (abfd);
1255   end_hashes = sym_hashes + symcount;
1256   for (; sym_hashes < end_hashes; sym_hashes++)
1257     {
1258       struct elf_link_hash_entry *sym_hash = *sym_hashes;
1259       if ((sym_hash->root.type == bfd_link_hash_defined
1260 	   || sym_hash->root.type == bfd_link_hash_defweak)
1261 	  && sym_hash->root.u.def.section == sec
1262 	  && sym_hash->root.u.def.value == addr)
1263 	return true;
1264     }
1265 
1266   return false;
1267 }
1268 
1269 /* This is a version of bfd_generic_get_relocated_section_contents
1270    which uses mn10200_elf_relocate_section.  */
1271 
1272 static bfd_byte *
mn10200_elf_get_relocated_section_contents(bfd * output_bfd,struct bfd_link_info * link_info,struct bfd_link_order * link_order,bfd_byte * data,bool relocatable,asymbol ** symbols)1273 mn10200_elf_get_relocated_section_contents (bfd *output_bfd,
1274 					    struct bfd_link_info *link_info,
1275 					    struct bfd_link_order *link_order,
1276 					    bfd_byte *data,
1277 					    bool relocatable,
1278 					    asymbol **symbols)
1279 {
1280   Elf_Internal_Shdr *symtab_hdr;
1281   asection *input_section = link_order->u.indirect.section;
1282   bfd *input_bfd = input_section->owner;
1283   asection **sections = NULL;
1284   Elf_Internal_Rela *internal_relocs = NULL;
1285   Elf_Internal_Sym *isymbuf = NULL;
1286 
1287   /* We only need to handle the case of relaxing, or of having a
1288      particular set of section contents, specially.  */
1289   if (relocatable
1290       || elf_section_data (input_section)->this_hdr.contents == NULL)
1291     return bfd_generic_get_relocated_section_contents (output_bfd, link_info,
1292 						       link_order, data,
1293 						       relocatable,
1294 						       symbols);
1295 
1296   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1297 
1298   memcpy (data, elf_section_data (input_section)->this_hdr.contents,
1299 	  (size_t) input_section->size);
1300 
1301   if ((input_section->flags & SEC_RELOC) != 0
1302       && input_section->reloc_count > 0)
1303     {
1304       Elf_Internal_Sym *isym;
1305       Elf_Internal_Sym *isymend;
1306       asection **secpp;
1307       bfd_size_type amt;
1308 
1309       internal_relocs = (_bfd_elf_link_read_relocs
1310 			 (input_bfd, input_section, NULL,
1311 			  (Elf_Internal_Rela *) NULL, false));
1312       if (internal_relocs == NULL)
1313 	goto error_return;
1314 
1315       if (symtab_hdr->sh_info != 0)
1316 	{
1317 	  isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
1318 	  if (isymbuf == NULL)
1319 	    isymbuf = bfd_elf_get_elf_syms (input_bfd, symtab_hdr,
1320 					    symtab_hdr->sh_info, 0,
1321 					    NULL, NULL, NULL);
1322 	  if (isymbuf == NULL)
1323 	    goto error_return;
1324 	}
1325 
1326       amt = symtab_hdr->sh_info;
1327       amt *= sizeof (asection *);
1328       sections = (asection **) bfd_malloc (amt);
1329       if (sections == NULL && amt != 0)
1330 	goto error_return;
1331 
1332       isymend = isymbuf + symtab_hdr->sh_info;
1333       for (isym = isymbuf, secpp = sections; isym < isymend; ++isym, ++secpp)
1334 	{
1335 	  asection *isec;
1336 
1337 	  if (isym->st_shndx == SHN_UNDEF)
1338 	    isec = bfd_und_section_ptr;
1339 	  else if (isym->st_shndx == SHN_ABS)
1340 	    isec = bfd_abs_section_ptr;
1341 	  else if (isym->st_shndx == SHN_COMMON)
1342 	    isec = bfd_com_section_ptr;
1343 	  else
1344 	    isec = bfd_section_from_elf_index (input_bfd, isym->st_shndx);
1345 
1346 	  *secpp = isec;
1347 	}
1348 
1349       if (! mn10200_elf_relocate_section (output_bfd, link_info, input_bfd,
1350 				     input_section, data, internal_relocs,
1351 				     isymbuf, sections))
1352 	goto error_return;
1353 
1354       free (sections);
1355       if (symtab_hdr->contents != (unsigned char *) isymbuf)
1356 	free (isymbuf);
1357       if (elf_section_data (input_section)->relocs != internal_relocs)
1358 	free (internal_relocs);
1359     }
1360 
1361   return data;
1362 
1363  error_return:
1364   free (sections);
1365   if (symtab_hdr->contents != (unsigned char *) isymbuf)
1366     free (isymbuf);
1367   if (elf_section_data (input_section)->relocs != internal_relocs)
1368     free (internal_relocs);
1369   return NULL;
1370 }
1371 
1372 #define TARGET_LITTLE_SYM	mn10200_elf32_vec
1373 #define TARGET_LITTLE_NAME	"elf32-mn10200"
1374 #define ELF_ARCH		bfd_arch_mn10200
1375 #define ELF_MACHINE_CODE	EM_MN10200
1376 #define ELF_MACHINE_ALT1	EM_CYGNUS_MN10200
1377 #define ELF_MAXPAGESIZE		0x1000
1378 
1379 #define elf_backend_rela_normal 1
1380 #define elf_info_to_howto	mn10200_info_to_howto
1381 #define elf_info_to_howto_rel	NULL
1382 #define elf_backend_relocate_section mn10200_elf_relocate_section
1383 #define bfd_elf32_bfd_relax_section	mn10200_elf_relax_section
1384 #define bfd_elf32_bfd_get_relocated_section_contents \
1385 				mn10200_elf_get_relocated_section_contents
1386 
1387 #define elf_symbol_leading_char '_'
1388 
1389 #include "elf32-target.h"
1390