xref: /netbsd-src/external/gpl3/gdb/dist/bfd/elf32-m32r.c (revision b7b7574d3bf8eeb51a1fa3977b59142ec6434a55)
1 /* M32R-specific support for 32-bit ELF.
2    Copyright 1996-2013 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 #include "elf/m32r.h"
26 
27 #define NOP_INSN		0x7000
28 #define MAKE_PARALLEL(insn)	((insn) | 0x8000)
29 
30 /* Use REL instead of RELA to save space.
31    This only saves space in libraries and object files, but perhaps
32    relocs will be put in ROM?  All in all though, REL relocs are a pain
33    to work with.  */
34 /* #define USE_REL	1
35 
36 #ifndef USE_REL
37 #define USE_REL	0
38 #endif */
39 /* Use RELA. But use REL to link old objects for backwords compatibility.  */
40 
41 /* Functions for the M32R ELF linker.  */
42 
43 /* The name of the dynamic interpreter.  This is put in the .interp
44    section.  */
45 
46 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
47 
48 /* The nop opcode we use.  */
49 
50 #define M32R_NOP 0x7000f000
51 
52 #define PLT_EMPTY   0x10101010  /* RIE  -> RIE */
53 
54 /* The size in bytes of an entry in the procedure linkage table.  */
55 
56 #define PLT_ENTRY_SIZE 20
57 #define PLT_HEADER_SIZE 20
58 
59 /* The first one entries in a procedure linkage table are reserved,
60    and the initial contents are unimportant (we zero them out).
61    Subsequent entries look like this. */
62 
63 #define PLT0_ENTRY_WORD0  0xd6c00000    /* seth r6, #high(.got+4)          */
64 #define PLT0_ENTRY_WORD1  0x86e60000    /* or3  r6, r6, #low(.got)+4)      */
65 #define PLT0_ENTRY_WORD2  0x24e626c6    /* ld   r4, @r6+    -> ld r6, @r6  */
66 #define PLT0_ENTRY_WORD3  0x1fc6f000    /* jmp  r6          || pnop        */
67 #define PLT0_ENTRY_WORD4  PLT_EMPTY     /* RIE             -> RIE          */
68 
69 #define PLT0_PIC_ENTRY_WORD0  0xa4cc0004 /* ld   r4, @(4,r12)              */
70 #define PLT0_PIC_ENTRY_WORD1  0xa6cc0008 /* ld   r6, @(8,r12)              */
71 #define PLT0_PIC_ENTRY_WORD2  0x1fc6f000 /* jmp  r6         || nop         */
72 #define PLT0_PIC_ENTRY_WORD3  PLT_EMPTY  /* RIE             -> RIE         */
73 #define PLT0_PIC_ENTRY_WORD4  PLT_EMPTY  /* RIE             -> RIE         */
74 
75 #define PLT_ENTRY_WORD0  0xe6000000 /* ld24 r6, .name_in_GOT                */
76 #define PLT_ENTRY_WORD1  0x06acf000 /* add  r6, r12          || nop         */
77 #define PLT_ENTRY_WORD0b 0xd6c00000 /* seth r6, #high(.name_in_GOT)         */
78 #define PLT_ENTRY_WORD1b 0x86e60000 /* or3  r6, r6, #low(.name_in_GOT)      */
79 #define PLT_ENTRY_WORD2  0x26c61fc6 /* ld  r6, @r6           -> jmp r6      */
80 #define PLT_ENTRY_WORD3  0xe5000000 /* ld24 r5, $offset                     */
81 #define PLT_ENTRY_WORD4  0xff000000 /* bra  .plt0.                          */
82 
83 
84 /* Utility to actually perform an R_M32R_10_PCREL reloc.  */
85 
86 static bfd_reloc_status_type
87 m32r_elf_do_10_pcrel_reloc (bfd *abfd,
88 			    reloc_howto_type *howto,
89 			    asection *input_section,
90 			    bfd_byte *data,
91 			    bfd_vma offset,
92 			    asection *symbol_section ATTRIBUTE_UNUSED,
93 			    bfd_vma symbol_value,
94 			    bfd_vma addend)
95 {
96   bfd_signed_vma relocation;
97   unsigned long x;
98   bfd_reloc_status_type status;
99 
100   /* Sanity check the address (offset in section).  */
101   if (offset > bfd_get_section_limit (abfd, input_section))
102     return bfd_reloc_outofrange;
103 
104   relocation = symbol_value + addend;
105   /* Make it pc relative.  */
106   relocation -=	(input_section->output_section->vma
107 		 + input_section->output_offset);
108   /* These jumps mask off the lower two bits of the current address
109      before doing pcrel calculations.  */
110   relocation -= (offset & -(bfd_vma) 4);
111 
112   if (relocation < -0x200 || relocation > 0x1ff)
113     status = bfd_reloc_overflow;
114   else
115     status = bfd_reloc_ok;
116 
117   x = bfd_get_16 (abfd, data + offset);
118   relocation >>= howto->rightshift;
119   relocation <<= howto->bitpos;
120   x = (x & ~howto->dst_mask) | (((x & howto->src_mask) + relocation) & howto->dst_mask);
121   bfd_put_16 (abfd, (bfd_vma) x, data + offset);
122 
123   return status;
124 }
125 
126 /* Handle the R_M32R_10_PCREL reloc.  */
127 
128 static bfd_reloc_status_type
129 m32r_elf_10_pcrel_reloc (bfd * abfd,
130 			 arelent * reloc_entry,
131 			 asymbol * symbol,
132 			 void * data,
133 			 asection * input_section,
134 			 bfd * output_bfd,
135 			 char ** error_message ATTRIBUTE_UNUSED)
136 {
137   /* This part is from bfd_elf_generic_reloc.  */
138   if (output_bfd != NULL
139       && (symbol->flags & BSF_SECTION_SYM) == 0
140       && (! reloc_entry->howto->partial_inplace
141 	  || reloc_entry->addend == 0))
142     {
143       reloc_entry->address += input_section->output_offset;
144       return bfd_reloc_ok;
145     }
146 
147   if (output_bfd != NULL)
148     /* FIXME: See bfd_perform_relocation.  Is this right?  */
149     return bfd_reloc_continue;
150 
151   return m32r_elf_do_10_pcrel_reloc (abfd, reloc_entry->howto,
152 				     input_section,
153 				     data, reloc_entry->address,
154 				     symbol->section,
155 				     (symbol->value
156 				      + symbol->section->output_section->vma
157 				      + symbol->section->output_offset),
158 				     reloc_entry->addend);
159 }
160 
161 /* Do generic partial_inplace relocation.
162    This is a local replacement for bfd_elf_generic_reloc.  */
163 
164 static bfd_reloc_status_type
165 m32r_elf_generic_reloc (bfd *input_bfd,
166 			arelent *reloc_entry,
167 			asymbol *symbol,
168 			void * data,
169 			asection *input_section,
170 			bfd *output_bfd,
171 			char **error_message ATTRIBUTE_UNUSED)
172 {
173   bfd_reloc_status_type ret;
174   bfd_vma relocation;
175   bfd_byte *inplace_address;
176 
177   /* This part is from bfd_elf_generic_reloc.
178      If we're relocating, and this an external symbol, we don't want
179      to change anything.  */
180   if (output_bfd != NULL
181       && (symbol->flags & BSF_SECTION_SYM) == 0
182       && reloc_entry->addend == 0)
183     {
184       reloc_entry->address += input_section->output_offset;
185       return bfd_reloc_ok;
186     }
187 
188   /* Now do the reloc in the usual way.
189      ??? It would be nice to call bfd_elf_generic_reloc here,
190      but we have partial_inplace set.  bfd_elf_generic_reloc will
191      pass the handling back to bfd_install_relocation which will install
192      a section relative addend which is wrong.  */
193 
194   /* Sanity check the address (offset in section).  */
195   if (reloc_entry->address > bfd_get_section_limit (input_bfd, input_section))
196     return bfd_reloc_outofrange;
197 
198   ret = bfd_reloc_ok;
199   if (bfd_is_und_section (symbol->section)
200       && output_bfd == NULL)
201     ret = bfd_reloc_undefined;
202 
203   if (bfd_is_com_section (symbol->section)
204       || output_bfd != NULL)
205     relocation = 0;
206   else
207     relocation = symbol->value;
208 
209   /* Only do this for a final link.  */
210   if (output_bfd == NULL)
211     {
212       relocation += symbol->section->output_section->vma;
213       relocation += symbol->section->output_offset;
214     }
215 
216   relocation += reloc_entry->addend;
217   inplace_address = (bfd_byte *) data + reloc_entry->address;
218 
219 #define DOIT(x) 					\
220   x = ( (x & ~reloc_entry->howto->dst_mask) | 		\
221   (((x & reloc_entry->howto->src_mask) +  relocation) &	\
222   reloc_entry->howto->dst_mask))
223 
224   switch (reloc_entry->howto->size)
225     {
226     case 1:
227       {
228 	short x = bfd_get_16 (input_bfd, inplace_address);
229 	DOIT (x);
230       	bfd_put_16 (input_bfd, (bfd_vma) x, inplace_address);
231       }
232       break;
233     case 2:
234       {
235 	unsigned long x = bfd_get_32 (input_bfd, inplace_address);
236 	DOIT (x);
237       	bfd_put_32 (input_bfd, (bfd_vma)x , inplace_address);
238       }
239       break;
240     default:
241       BFD_ASSERT (0);
242     }
243 
244   if (output_bfd != NULL)
245     reloc_entry->address += input_section->output_offset;
246 
247   return ret;
248 }
249 
250 /* Handle the R_M32R_SDA16 reloc.
251    This reloc is used to compute the address of objects in the small data area
252    and to perform loads and stores from that area.
253    The lower 16 bits are sign extended and added to the register specified
254    in the instruction, which is assumed to point to _SDA_BASE_.  */
255 
256 static bfd_reloc_status_type
257 m32r_elf_sda16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
258 		      arelent *reloc_entry,
259 		      asymbol *symbol,
260 		      void * data ATTRIBUTE_UNUSED,
261 		      asection *input_section,
262 		      bfd *output_bfd,
263 		      char **error_message ATTRIBUTE_UNUSED)
264 {
265   /* This part is from bfd_elf_generic_reloc.  */
266   if (output_bfd != NULL
267       && (symbol->flags & BSF_SECTION_SYM) == 0
268       && (! reloc_entry->howto->partial_inplace
269 	  || reloc_entry->addend == 0))
270     {
271       reloc_entry->address += input_section->output_offset;
272       return bfd_reloc_ok;
273     }
274 
275   if (output_bfd != NULL)
276     /* FIXME: See bfd_perform_relocation.  Is this right?  */
277     return bfd_reloc_continue;
278 
279   /* FIXME: not sure what to do here yet.  But then again, the linker
280      may never call us.  */
281   abort ();
282 }
283 
284 
285 /* Handle the R_M32R_HI16_[SU]LO relocs.
286    HI16_SLO is for the add3 and load/store with displacement instructions.
287    HI16_ULO is for the or3 instruction.
288    For R_M32R_HI16_SLO, the lower 16 bits are sign extended when added to
289    the high 16 bytes so if the lower 16 bits are negative (bit 15 == 1) then
290    we must add one to the high 16 bytes (which will get subtracted off when
291    the low 16 bits are added).
292    These relocs have to be done in combination with an R_M32R_LO16 reloc
293    because there is a carry from the LO16 to the HI16.  Here we just save
294    the information we need; we do the actual relocation when we see the LO16.
295    This code is copied from the elf32-mips.c.  We also support an arbitrary
296    number of HI16 relocs to be associated with a single LO16 reloc.  The
297    assembler sorts the relocs to ensure each HI16 immediately precedes its
298    LO16.  However if there are multiple copies, the assembler may not find
299    the real LO16 so it picks the first one it finds.  */
300 
301 struct m32r_hi16
302 {
303   struct m32r_hi16 *next;
304   bfd_byte *addr;
305   bfd_vma addend;
306 };
307 
308 /* FIXME: This should not be a static variable.  */
309 
310 static struct m32r_hi16 *m32r_hi16_list;
311 
312 static bfd_reloc_status_type
313 m32r_elf_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
314 		     arelent *reloc_entry,
315 		     asymbol *symbol,
316 		     void * data,
317 		     asection *input_section,
318 		     bfd *output_bfd,
319 		     char **error_message ATTRIBUTE_UNUSED)
320 {
321   bfd_reloc_status_type ret;
322   bfd_vma relocation;
323   struct m32r_hi16 *n;
324 
325   /* This part is from bfd_elf_generic_reloc.
326      If we're relocating, and this an external symbol, we don't want
327      to change anything.  */
328   if (output_bfd != NULL
329       && (symbol->flags & BSF_SECTION_SYM) == 0
330       && reloc_entry->addend == 0)
331     {
332       reloc_entry->address += input_section->output_offset;
333       return bfd_reloc_ok;
334     }
335 
336   /* Sanity check the address (offset in section).  */
337   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
338     return bfd_reloc_outofrange;
339 
340   ret = bfd_reloc_ok;
341   if (bfd_is_und_section (symbol->section)
342       && output_bfd == NULL)
343     ret = bfd_reloc_undefined;
344 
345   if (bfd_is_com_section (symbol->section))
346     relocation = 0;
347   else
348     relocation = symbol->value;
349 
350   relocation += symbol->section->output_section->vma;
351   relocation += symbol->section->output_offset;
352   relocation += reloc_entry->addend;
353 
354   /* Save the information, and let LO16 do the actual relocation.  */
355   n = bfd_malloc ((bfd_size_type) sizeof *n);
356   if (n == NULL)
357     return bfd_reloc_outofrange;
358   n->addr = (bfd_byte *) data + reloc_entry->address;
359   n->addend = relocation;
360   n->next = m32r_hi16_list;
361   m32r_hi16_list = n;
362 
363   if (output_bfd != NULL)
364     reloc_entry->address += input_section->output_offset;
365 
366   return ret;
367 }
368 
369 /* Handle an M32R ELF HI16 reloc.  */
370 
371 static void
372 m32r_elf_relocate_hi16 (bfd *input_bfd,
373 			int type,
374 			Elf_Internal_Rela *relhi,
375 			Elf_Internal_Rela *rello,
376 			bfd_byte *contents,
377 			bfd_vma addend)
378 {
379   unsigned long insn;
380   bfd_vma addlo;
381 
382   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
383 
384   addlo = bfd_get_32 (input_bfd, contents + rello->r_offset);
385   if (type == R_M32R_HI16_SLO)
386     addlo = ((addlo & 0xffff) ^ 0x8000) - 0x8000;
387   else
388     addlo &= 0xffff;
389 
390   addend += ((insn & 0xffff) << 16) + addlo;
391 
392   /* Reaccount for sign extension of low part.  */
393   if (type == R_M32R_HI16_SLO
394       && (addend & 0x8000) != 0)
395     addend += 0x10000;
396 
397   bfd_put_32 (input_bfd,
398 	      (insn & 0xffff0000) | ((addend >> 16) & 0xffff),
399 	      contents + relhi->r_offset);
400 }
401 
402 /* Do an R_M32R_LO16 relocation.  This is a straightforward 16 bit
403    inplace relocation; this function exists in order to do the
404    R_M32R_HI16_[SU]LO relocation described above.  */
405 
406 static bfd_reloc_status_type
407 m32r_elf_lo16_reloc (bfd *input_bfd,
408 		     arelent *reloc_entry,
409 		     asymbol *symbol,
410 		     void * data,
411 		     asection *input_section,
412 		     bfd *output_bfd,
413 		     char **error_message)
414 {
415   /* This part is from bfd_elf_generic_reloc.
416      If we're relocating, and this an external symbol, we don't want
417      to change anything.  */
418   if (output_bfd != NULL
419       && (symbol->flags & BSF_SECTION_SYM) == 0
420       && reloc_entry->addend == 0)
421     {
422       reloc_entry->address += input_section->output_offset;
423       return bfd_reloc_ok;
424     }
425 
426   if (m32r_hi16_list != NULL)
427     {
428       struct m32r_hi16 *l;
429 
430       l = m32r_hi16_list;
431       while (l != NULL)
432 	{
433 	  unsigned long insn;
434 	  unsigned long val;
435 	  unsigned long vallo;
436 	  struct m32r_hi16 *next;
437 
438 	  /* Do the HI16 relocation.  Note that we actually don't need
439 	     to know anything about the LO16 itself, except where to
440 	     find the low 16 bits of the addend needed by the LO16.  */
441 	  insn = bfd_get_32 (input_bfd, l->addr);
442 	  vallo = ((bfd_get_32 (input_bfd, (bfd_byte *) data + reloc_entry->address)
443 		   & 0xffff) ^ 0x8000) - 0x8000;
444 	  val = ((insn & 0xffff) << 16) + vallo;
445 	  val += l->addend;
446 
447 	  /* Reaccount for sign extension of low part.  */
448 	  if ((val & 0x8000) != 0)
449 	    val += 0x10000;
450 
451 	  insn = (insn &~ (bfd_vma) 0xffff) | ((val >> 16) & 0xffff);
452 	  bfd_put_32 (input_bfd, (bfd_vma) insn, l->addr);
453 
454 	  next = l->next;
455 	  free (l);
456 	  l = next;
457 	}
458 
459       m32r_hi16_list = NULL;
460     }
461 
462   /* Now do the LO16 reloc in the usual way.
463      ??? It would be nice to call bfd_elf_generic_reloc here,
464      but we have partial_inplace set.  bfd_elf_generic_reloc will
465      pass the handling back to bfd_install_relocation which will install
466      a section relative addend which is wrong.  */
467   return m32r_elf_generic_reloc (input_bfd, reloc_entry, symbol, data,
468 				input_section, output_bfd, error_message);
469 }
470 
471 
472 static reloc_howto_type m32r_elf_howto_table[] =
473 {
474   /* This reloc does nothing.  */
475   HOWTO (R_M32R_NONE,		/* type */
476 	 0,			/* rightshift */
477 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
478 	 32,			/* bitsize */
479 	 FALSE,			/* pc_relative */
480 	 0,			/* bitpos */
481 	 complain_overflow_bitfield, /* complain_on_overflow */
482 	 bfd_elf_generic_reloc,	/* special_function */
483 	 "R_M32R_NONE",		/* name */
484 	 FALSE,			/* partial_inplace */
485 	 0,			/* src_mask */
486 	 0,			/* dst_mask */
487 	 FALSE),		/* pcrel_offset */
488 
489   /* A 16 bit absolute relocation.  */
490   HOWTO (R_M32R_16,		/* type */
491 	 0,			/* rightshift */
492 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
493 	 16,			/* bitsize */
494 	 FALSE,			/* pc_relative */
495 	 0,			/* bitpos */
496 	 complain_overflow_bitfield, /* complain_on_overflow */
497 	 m32r_elf_generic_reloc,/* special_function */
498 	 "R_M32R_16",		/* name */
499 	 TRUE,			/* partial_inplace */
500 	 0xffff,		/* src_mask */
501 	 0xffff,		/* dst_mask */
502 	 FALSE),		/* pcrel_offset */
503 
504   /* A 32 bit absolute relocation.  */
505   HOWTO (R_M32R_32,		/* type */
506 	 0,			/* rightshift */
507 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
508 	 32,			/* bitsize */
509 	 FALSE,			/* pc_relative */
510 	 0,			/* bitpos */
511 	 complain_overflow_bitfield, /* complain_on_overflow */
512 	 m32r_elf_generic_reloc,/* special_function */
513 	 "R_M32R_32",		/* name */
514 	 TRUE,			/* partial_inplace */
515 	 0xffffffff,		/* src_mask */
516 	 0xffffffff,		/* dst_mask */
517 	 FALSE),		/* pcrel_offset */
518 
519   /* A 24 bit address.  */
520   HOWTO (R_M32R_24,		/* type */
521 	 0,			/* rightshift */
522 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
523 	 24,			/* bitsize */
524 	 FALSE,			/* pc_relative */
525 	 0,			/* bitpos */
526 	 complain_overflow_unsigned, /* complain_on_overflow */
527 	 m32r_elf_generic_reloc,/* special_function */
528 	 "R_M32R_24",		/* name */
529 	 TRUE,			/* partial_inplace */
530 	 0xffffff,		/* src_mask */
531 	 0xffffff,		/* dst_mask */
532 	 FALSE),		/* pcrel_offset */
533 
534   /* An PC Relative 10-bit relocation, shifted by 2.
535      This reloc is complicated because relocations are relative to pc & -4.
536      i.e. branches in the right insn slot use the address of the left insn
537      slot for pc.  */
538   /* ??? It's not clear whether this should have partial_inplace set or not.
539      Branch relaxing in the assembler can store the addend in the insn,
540      and if bfd_install_relocation gets called the addend may get added
541      again.  */
542   HOWTO (R_M32R_10_PCREL,	/* type */
543 	 2,	                /* rightshift */
544 	 1,	                /* size (0 = byte, 1 = short, 2 = long) */
545 	 10,	                /* bitsize */
546 	 TRUE,	                /* pc_relative */
547 	 0,	                /* bitpos */
548 	 complain_overflow_signed, /* complain_on_overflow */
549 	 m32r_elf_10_pcrel_reloc, /* special_function */
550 	 "R_M32R_10_PCREL",	/* name */
551 	 FALSE,	                /* partial_inplace */
552 	 0xff,		        /* src_mask */
553 	 0xff,   		/* dst_mask */
554 	 TRUE),			/* pcrel_offset */
555 
556   /* A relative 18 bit relocation, right shifted by 2.  */
557   HOWTO (R_M32R_18_PCREL,	/* type */
558 	 2,			/* rightshift */
559 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
560 	 16,			/* bitsize */
561 	 TRUE,			/* pc_relative */
562 	 0,			/* bitpos */
563 	 complain_overflow_signed, /* complain_on_overflow */
564 	 bfd_elf_generic_reloc,	/* special_function */
565 	 "R_M32R_18_PCREL",	/* name */
566 	 FALSE,			/* partial_inplace */
567 	 0xffff,		/* src_mask */
568 	 0xffff,		/* dst_mask */
569 	 TRUE),			/* pcrel_offset */
570 
571   /* A relative 26 bit relocation, right shifted by 2.  */
572   /* ??? It's not clear whether this should have partial_inplace set or not.
573      Branch relaxing in the assembler can store the addend in the insn,
574      and if bfd_install_relocation gets called the addend may get added
575      again.  */
576   HOWTO (R_M32R_26_PCREL,	/* type */
577 	 2,			/* rightshift */
578 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
579 	 26,			/* bitsize */
580 	 TRUE,			/* pc_relative */
581 	 0,			/* bitpos */
582 	 complain_overflow_signed, /* complain_on_overflow */
583 	 bfd_elf_generic_reloc,	/* special_function */
584 	 "R_M32R_26_PCREL",	/* name */
585 	 FALSE,			/* partial_inplace */
586 	 0xffffff,		/* src_mask */
587 	 0xffffff,		/* dst_mask */
588 	 TRUE),			/* pcrel_offset */
589 
590   /* High 16 bits of address when lower 16 is or'd in.  */
591   HOWTO (R_M32R_HI16_ULO,	/* type */
592 	 16,			/* rightshift */
593 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
594 	 16,			/* bitsize */
595 	 FALSE,			/* pc_relative */
596 	 0,			/* bitpos */
597 	 complain_overflow_dont, /* complain_on_overflow */
598 	 m32r_elf_hi16_reloc,	/* special_function */
599 	 "R_M32R_HI16_ULO",	/* name */
600 	 TRUE,			/* partial_inplace */
601 	 0x0000ffff,		/* src_mask */
602 	 0x0000ffff,		/* dst_mask */
603 	 FALSE),		/* pcrel_offset */
604 
605   /* High 16 bits of address when lower 16 is added in.  */
606   HOWTO (R_M32R_HI16_SLO,	/* type */
607 	 16,			/* rightshift */
608 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
609 	 16,			/* bitsize */
610 	 FALSE,			/* pc_relative */
611 	 0,			/* bitpos */
612 	 complain_overflow_dont, /* complain_on_overflow */
613 	 m32r_elf_hi16_reloc,	/* special_function */
614 	 "R_M32R_HI16_SLO",	/* name */
615 	 TRUE,			/* partial_inplace */
616 	 0x0000ffff,		/* src_mask */
617 	 0x0000ffff,		/* dst_mask */
618 	 FALSE),		/* pcrel_offset */
619 
620   /* Lower 16 bits of address.  */
621   HOWTO (R_M32R_LO16,		/* type */
622 	 0,			/* rightshift */
623 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
624 	 16,			/* bitsize */
625 	 FALSE,			/* pc_relative */
626 	 0,			/* bitpos */
627 	 complain_overflow_dont, /* complain_on_overflow */
628 	 m32r_elf_lo16_reloc,	/* special_function */
629 	 "R_M32R_LO16",		/* name */
630 	 TRUE,			/* partial_inplace */
631 	 0x0000ffff,		/* src_mask */
632 	 0x0000ffff,		/* dst_mask */
633 	 FALSE),		/* pcrel_offset */
634 
635   /* Small data area 16 bits offset.  */
636   HOWTO (R_M32R_SDA16,		/* type */
637 	 0,			/* rightshift */
638 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
639 	 16,			/* bitsize */
640 	 FALSE,			/* pc_relative */
641 	 0,			/* bitpos */
642 	 complain_overflow_signed, /* complain_on_overflow */
643 	 m32r_elf_sda16_reloc,	/* special_function */
644 	 "R_M32R_SDA16",	/* name */
645 	 TRUE,			/* partial_inplace */  /* FIXME: correct? */
646 	 0x0000ffff,		/* src_mask */
647 	 0x0000ffff,		/* dst_mask */
648 	 FALSE),		/* pcrel_offset */
649 
650   /* GNU extension to record C++ vtable hierarchy.  */
651   HOWTO (R_M32R_GNU_VTINHERIT, /* type */
652          0,                     /* rightshift */
653          2,                     /* size (0 = byte, 1 = short, 2 = long) */
654          0,                     /* bitsize */
655          FALSE,                 /* pc_relative */
656          0,                     /* bitpos */
657          complain_overflow_dont, /* complain_on_overflow */
658          NULL,                  /* special_function */
659          "R_M32R_GNU_VTINHERIT", /* name */
660          FALSE,                 /* partial_inplace */
661          0,                     /* src_mask */
662          0,                     /* dst_mask */
663          FALSE),                /* pcrel_offset */
664 
665   /* GNU extension to record C++ vtable member usage.  */
666   HOWTO (R_M32R_GNU_VTENTRY,     /* type */
667          0,                     /* rightshift */
668          2,                     /* size (0 = byte, 1 = short, 2 = long) */
669          0,                     /* bitsize */
670          FALSE,                 /* pc_relative */
671          0,                     /* bitpos */
672          complain_overflow_dont, /* complain_on_overflow */
673          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
674          "R_M32R_GNU_VTENTRY",   /* name */
675          FALSE,                 /* partial_inplace */
676          0,                     /* src_mask */
677          0,                     /* dst_mask */
678          FALSE),                /* pcrel_offset */
679 
680   EMPTY_HOWTO (13),
681   EMPTY_HOWTO (14),
682   EMPTY_HOWTO (15),
683   EMPTY_HOWTO (16),
684   EMPTY_HOWTO (17),
685   EMPTY_HOWTO (18),
686   EMPTY_HOWTO (19),
687   EMPTY_HOWTO (20),
688   EMPTY_HOWTO (21),
689   EMPTY_HOWTO (22),
690   EMPTY_HOWTO (23),
691   EMPTY_HOWTO (24),
692   EMPTY_HOWTO (25),
693   EMPTY_HOWTO (26),
694   EMPTY_HOWTO (27),
695   EMPTY_HOWTO (28),
696   EMPTY_HOWTO (29),
697   EMPTY_HOWTO (30),
698   EMPTY_HOWTO (31),
699   EMPTY_HOWTO (32),
700 
701   /* A 16 bit absolute relocation.  */
702   HOWTO (R_M32R_16_RELA,	/* type */
703 	 0,			/* rightshift */
704 	 1,			/* size (0 = byte, 1 = short, 2 = long) */
705 	 16,			/* bitsize */
706 	 FALSE,			/* pc_relative */
707 	 0,			/* bitpos */
708 	 complain_overflow_bitfield, /* complain_on_overflow */
709 	 bfd_elf_generic_reloc,	/* special_function */
710 	 "R_M32R_16_RELA",	/* name */
711 	 FALSE,			/* partial_inplace */
712 	 0xffff,		/* src_mask */
713 	 0xffff,		/* dst_mask */
714 	 FALSE),		/* pcrel_offset */
715 
716   /* A 32 bit absolute relocation.  */
717   HOWTO (R_M32R_32_RELA,	/* type */
718 	 0,			/* rightshift */
719 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
720 	 32,			/* bitsize */
721 	 FALSE,			/* pc_relative */
722 	 0,			/* bitpos */
723 	 complain_overflow_bitfield, /* complain_on_overflow */
724 	 bfd_elf_generic_reloc,/* special_function */
725 	 "R_M32R_32_RELA",		/* name */
726 	 FALSE,			/* partial_inplace */
727 	 0xffffffff,		/* src_mask */
728 	 0xffffffff,		/* dst_mask */
729 	 FALSE),		/* pcrel_offset */
730 
731   /* A 24 bit address.  */
732   HOWTO (R_M32R_24_RELA,	/* type */
733 	 0,			/* rightshift */
734 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
735 	 24,			/* bitsize */
736 	 FALSE,			/* pc_relative */
737 	 0,			/* bitpos */
738 	 complain_overflow_unsigned, /* complain_on_overflow */
739 	 bfd_elf_generic_reloc,/* special_function */
740 	 "R_M32R_24_RELA",	/* name */
741 	 FALSE,			/* partial_inplace */
742 	 0xffffff,		/* src_mask */
743 	 0xffffff,		/* dst_mask */
744 	 FALSE),		/* pcrel_offset */
745 
746   HOWTO (R_M32R_10_PCREL_RELA,	/* type */
747 	 2,	                /* rightshift */
748 	 1,	                /* size (0 = byte, 1 = short, 2 = long) */
749 	 10,	                /* bitsize */
750 	 TRUE,	                /* pc_relative */
751 	 0,	                /* bitpos */
752 	 complain_overflow_signed, /* complain_on_overflow */
753 	 m32r_elf_10_pcrel_reloc, /* special_function */
754 	 "R_M32R_10_PCREL_RELA",/* name */
755 	 FALSE,	                /* partial_inplace */
756 	 0xff,		        /* src_mask */
757 	 0xff,   		/* dst_mask */
758 	 TRUE),			/* pcrel_offset */
759 
760   /* A relative 18 bit relocation, right shifted by 2.  */
761   HOWTO (R_M32R_18_PCREL_RELA,	/* type */
762 	 2,			/* rightshift */
763 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
764 	 16,			/* bitsize */
765 	 TRUE,			/* pc_relative */
766 	 0,			/* bitpos */
767 	 complain_overflow_signed, /* complain_on_overflow */
768 	 bfd_elf_generic_reloc,	/* special_function */
769 	 "R_M32R_18_PCREL_RELA",/* name */
770 	 FALSE,			/* partial_inplace */
771 	 0xffff,		/* src_mask */
772 	 0xffff,		/* dst_mask */
773 	 TRUE),			/* pcrel_offset */
774 
775   /* A relative 26 bit relocation, right shifted by 2.  */
776   HOWTO (R_M32R_26_PCREL_RELA,	/* type */
777 	 2,			/* rightshift */
778 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
779 	 26,			/* bitsize */
780 	 TRUE,			/* pc_relative */
781 	 0,			/* bitpos */
782 	 complain_overflow_signed, /* complain_on_overflow */
783 	 bfd_elf_generic_reloc,	/* special_function */
784 	 "R_M32R_26_PCREL_RELA",/* name */
785 	 FALSE,			/* partial_inplace */
786 	 0xffffff,		/* src_mask */
787 	 0xffffff,		/* dst_mask */
788 	 TRUE),			/* pcrel_offset */
789 
790   /* High 16 bits of address when lower 16 is or'd in.  */
791   HOWTO (R_M32R_HI16_ULO_RELA,	/* type */
792 	 16,			/* rightshift */
793 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
794 	 16,			/* bitsize */
795 	 FALSE,			/* pc_relative */
796 	 0,			/* bitpos */
797 	 complain_overflow_dont, /* complain_on_overflow */
798 	 bfd_elf_generic_reloc,	/* special_function */
799 	 "R_M32R_HI16_ULO_RELA",/* name */
800 	 FALSE,			/* partial_inplace */
801 	 0x0000ffff,		/* src_mask */
802 	 0x0000ffff,		/* dst_mask */
803 	 FALSE),		/* pcrel_offset */
804 
805   /* High 16 bits of address when lower 16 is added in.  */
806   HOWTO (R_M32R_HI16_SLO_RELA,	/* type */
807 	 16,			/* rightshift */
808 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
809 	 16,			/* bitsize */
810 	 FALSE,			/* pc_relative */
811 	 0,			/* bitpos */
812 	 complain_overflow_dont, /* complain_on_overflow */
813 	 bfd_elf_generic_reloc,	/* special_function */
814 	 "R_M32R_HI16_SLO_RELA",/* name */
815 	 FALSE,			/* partial_inplace */
816 	 0x0000ffff,		/* src_mask */
817 	 0x0000ffff,		/* dst_mask */
818 	 FALSE),		/* pcrel_offset */
819 
820   /* Lower 16 bits of address.  */
821   HOWTO (R_M32R_LO16_RELA,	/* type */
822 	 0,			/* rightshift */
823 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
824 	 16,			/* bitsize */
825 	 FALSE,			/* pc_relative */
826 	 0,			/* bitpos */
827 	 complain_overflow_dont, /* complain_on_overflow */
828 	 bfd_elf_generic_reloc,	/* special_function */
829 	 "R_M32R_LO16_RELA",	/* name */
830 	 FALSE,			/* partial_inplace */
831 	 0x0000ffff,		/* src_mask */
832 	 0x0000ffff,		/* dst_mask */
833 	 FALSE),		/* pcrel_offset */
834 
835   /* Small data area 16 bits offset.  */
836   HOWTO (R_M32R_SDA16_RELA,	/* type */
837 	 0,			/* rightshift */
838 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
839 	 16,			/* bitsize */
840 	 FALSE,			/* pc_relative */
841 	 0,			/* bitpos */
842 	 complain_overflow_signed, /* complain_on_overflow */
843 	 bfd_elf_generic_reloc,	/* special_function */
844 	 "R_M32R_SDA16_RELA",	/* name */
845 	 TRUE,			/* partial_inplace */  /* FIXME: correct? */
846 	 0x0000ffff,		/* src_mask */
847 	 0x0000ffff,		/* dst_mask */
848 	 FALSE),		/* pcrel_offset */
849 
850   /* GNU extension to record C++ vtable hierarchy.  */
851   HOWTO (R_M32R_RELA_GNU_VTINHERIT, /* type */
852          0,                     /* rightshift */
853          2,                     /* size (0 = byte, 1 = short, 2 = long) */
854          0,                     /* bitsize */
855          FALSE,                 /* pc_relative */
856          0,                     /* bitpos */
857          complain_overflow_dont, /* complain_on_overflow */
858          NULL,                  /* special_function */
859          "R_M32R_RELA_GNU_VTINHERIT", /* name */
860          FALSE,                 /* partial_inplace */
861          0,                     /* src_mask */
862          0,                     /* dst_mask */
863          FALSE),                /* pcrel_offset */
864 
865   /* GNU extension to record C++ vtable member usage.  */
866   HOWTO (R_M32R_RELA_GNU_VTENTRY,     /* type */
867          0,                     /* rightshift */
868          2,                     /* size (0 = byte, 1 = short, 2 = long) */
869          0,                     /* bitsize */
870          FALSE,                 /* pc_relative */
871          0,                     /* bitpos */
872          complain_overflow_dont, /* complain_on_overflow */
873          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
874          "R_M32R_RELA_GNU_VTENTRY",   /* name */
875          FALSE,                 /* partial_inplace */
876          0,                     /* src_mask */
877          0,                     /* dst_mask */
878          FALSE),                /* pcrel_offset */
879 
880   /* A 32 bit PC relative relocation.  */
881   HOWTO (R_M32R_REL32,		/* type */
882 	 0,			/* rightshift */
883 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
884 	 32,			/* bitsize */
885 	 TRUE,			/* pc_relative */
886 	 0,			/* bitpos */
887 	 complain_overflow_bitfield, /* complain_on_overflow */
888 	 bfd_elf_generic_reloc,/* special_function */
889 	 "R_M32R_REL32",		/* name */
890 	 FALSE,			/* partial_inplace */
891 	 0xffffffff,		/* src_mask */
892 	 0xffffffff,		/* dst_mask */
893 	 TRUE),			/* pcrel_offset */
894 
895   EMPTY_HOWTO (46),
896   EMPTY_HOWTO (47),
897 
898   /* Like R_M32R_24, but referring to the GOT table entry for
899      the symbol.  */
900   HOWTO (R_M32R_GOT24,		/* type */
901 	 0,			/* rightshift */
902 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
903 	 24,			/* bitsize */
904 	 FALSE,			/* pc_relative */
905 	 0,			/* bitpos */
906 	 complain_overflow_unsigned, /* complain_on_overflow */
907 	 bfd_elf_generic_reloc, /* special_function */
908 	 "R_M32R_GOT24",	/* name */
909 	 FALSE,			/* partial_inplace */
910 	 0xffffff,		/* src_mask */
911 	 0xffffff,		/* dst_mask */
912 	 FALSE),		/* pcrel_offset */
913 
914   /* Like R_M32R_PCREL, but referring to the procedure linkage table
915      entry for the symbol.  */
916   HOWTO (R_M32R_26_PLTREL,	/* type */
917 	 2,			/* rightshift */
918 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
919 	 24,			/* bitsize */
920 	 TRUE,			/* pc_relative */
921 	 0,			/* bitpos */
922 	 complain_overflow_signed, /* complain_on_overflow */
923 	 bfd_elf_generic_reloc,	/* special_function */
924 	 "R_M32R_26_PLTREL",	/* name */
925 	 FALSE,			/* partial_inplace */
926 	 0xffffff,		/* src_mask */
927 	 0xffffff,		/* dst_mask */
928 	 TRUE),			/* pcrel_offset */
929 
930   /* This is used only by the dynamic linker.  The symbol should exist
931      both in the object being run and in some shared library.  The
932      dynamic linker copies the data addressed by the symbol from the
933      shared library into the object, because the object being
934      run has to have the data at some particular address.  */
935   HOWTO (R_M32R_COPY,		/* type */
936 	 0,			/* rightshift */
937 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
938 	 32,			/* bitsize */
939 	 FALSE,			/* pc_relative */
940 	 0,			/* bitpos */
941 	 complain_overflow_bitfield, /* complain_on_overflow */
942 	 bfd_elf_generic_reloc, /* special_function */
943 	 "R_M32R_COPY",		/* name */
944 	 FALSE,			/* partial_inplace */
945 	 0xffffffff,		/* src_mask */
946 	 0xffffffff,		/* dst_mask */
947 	 FALSE),		/* pcrel_offset */
948 
949   /* Like R_M32R_24, but used when setting global offset table
950      entries.  */
951   HOWTO (R_M32R_GLOB_DAT,	/* type */
952 	 0,			/* rightshift */
953 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
954 	 32,			/* bitsize */
955 	 FALSE,			/* pc_relative */
956 	 0,			/* bitpos */
957 	 complain_overflow_bitfield, /* complain_on_overflow */
958 	 bfd_elf_generic_reloc, /* special_function */
959 	 "R_M32R_GLOB_DAT",	/* name */
960 	 FALSE,			/* partial_inplace */
961 	 0xffffffff,		/* src_mask */
962 	 0xffffffff,		/* dst_mask */
963 	 FALSE),		/* pcrel_offset */
964 
965   /* Marks a procedure linkage table entry for a symbol.  */
966   HOWTO (R_M32R_JMP_SLOT,	/* type */
967 	 0,			/* rightshift */
968 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
969 	 32,			/* bitsize */
970 	 FALSE,			/* pc_relative */
971 	 0,			/* bitpos */
972 	 complain_overflow_bitfield, /* complain_on_overflow */
973 	 bfd_elf_generic_reloc, /* special_function */
974 	 "R_M32R_JMP_SLOT",	/* name */
975 	 FALSE,			/* partial_inplace */
976 	 0xffffffff,		/* src_mask */
977 	 0xffffffff,		/* dst_mask */
978 	 FALSE),		/* pcrel_offset */
979 
980   /* Used only by the dynamic linker.  When the object is run, this
981      longword is set to the load address of the object, plus the
982      addend.  */
983   HOWTO (R_M32R_RELATIVE,	/* type */
984 	 0,			/* rightshift */
985 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
986 	 32,			/* bitsize */
987 	 FALSE,			/* pc_relative */
988 	 0,			/* bitpos */
989 	 complain_overflow_bitfield, /* complain_on_overflow */
990 	 bfd_elf_generic_reloc, /* special_function */
991 	 "R_M32R_RELATIVE",	/* name */
992 	 FALSE,			/* partial_inplace */
993 	 0xffffffff,		/* src_mask */
994 	 0xffffffff,		/* dst_mask */
995 	 FALSE),		/* pcrel_offset */
996 
997   HOWTO (R_M32R_GOTOFF,		/* type */
998 	 0,			/* rightshift */
999 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1000 	 24,			/* bitsize */
1001 	 FALSE,			/* pc_relative */
1002 	 0,			/* bitpos */
1003 	 complain_overflow_bitfield, /* complain_on_overflow */
1004 	 bfd_elf_generic_reloc, /* special_function */
1005 	 "R_M32R_GOTOFF",	/* name */
1006 	 FALSE,			/* partial_inplace */
1007 	 0xffffff,		/* src_mask */
1008 	 0xffffff,		/* dst_mask */
1009 	 FALSE),		/* pcrel_offset */
1010 
1011   /* An PC Relative 24-bit relocation used when setting PIC offset
1012      table register. */
1013   HOWTO (R_M32R_GOTPC24,	/* type */
1014 	 0,			/* rightshift */
1015 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1016 	 24,			/* bitsize */
1017 	 TRUE,			/* pc_relative */
1018 	 0,			/* bitpos */
1019 	 complain_overflow_unsigned, /* complain_on_overflow */
1020 	 bfd_elf_generic_reloc, /* special_function */
1021 	 "R_M32R_GOTPC24",	/* name */
1022 	 FALSE,			/* partial_inplace */
1023 	 0xffffff,		/* src_mask */
1024 	 0xffffff,		/* dst_mask */
1025 	 TRUE),			/* pcrel_offset */
1026 
1027   /* Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1028      the symbol.  */
1029   HOWTO (R_M32R_GOT16_HI_ULO,	/* type */
1030 	 16,			/* rightshift */
1031 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1032 	 16,			/* bitsize */
1033 	 FALSE,			/* pc_relative */
1034 	 0,			/* bitpos */
1035 	 complain_overflow_dont, /* complain_on_overflow */
1036 	 bfd_elf_generic_reloc,	/* special_function */
1037 	 "R_M32R_GOT16_HI_ULO",	/* name */
1038 	 FALSE,			/* partial_inplace */
1039 	 0x0000ffff,		/* src_mask */
1040 	 0x0000ffff,		/* dst_mask */
1041 	 FALSE),		/* pcrel_offset */
1042 
1043   /* Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1044      the symbol.  */
1045   HOWTO (R_M32R_GOT16_HI_SLO,	/* type */
1046 	 16,			/* rightshift */
1047 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1048 	 16,			/* bitsize */
1049 	 FALSE,			/* pc_relative */
1050 	 0,			/* bitpos */
1051 	 complain_overflow_dont, /* complain_on_overflow */
1052 	 bfd_elf_generic_reloc,	/* special_function */
1053 	 "R_M32R_GOT16_HI_SLO",	/* name */
1054 	 FALSE,			/* partial_inplace */
1055 	 0x0000ffff,		/* src_mask */
1056 	 0x0000ffff,		/* dst_mask */
1057 	 FALSE),		/* pcrel_offset */
1058 
1059   /* Like R_M32R_LO16, but referring to the GOT table entry for
1060      the symbol.  */
1061   HOWTO (R_M32R_GOT16_LO,	/* type */
1062 	 0,			/* rightshift */
1063 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1064 	 16,			/* bitsize */
1065 	 FALSE,			/* pc_relative */
1066 	 0,			/* bitpos */
1067 	 complain_overflow_dont, /* complain_on_overflow */
1068 	 bfd_elf_generic_reloc,	/* special_function */
1069 	 "R_M32R_GOT16_LO",	/* name */
1070 	 FALSE,			/* partial_inplace */
1071 	 0x0000ffff,		/* src_mask */
1072 	 0x0000ffff,		/* dst_mask */
1073 	 FALSE),		/* pcrel_offset */
1074 
1075   /* An PC Relative relocation used when setting PIC offset table register.
1076      Like R_M32R_HI16_ULO, but referring to the GOT table entry for
1077      the symbol.  */
1078   HOWTO (R_M32R_GOTPC_HI_ULO,	/* type */
1079 	 16,			/* rightshift */
1080 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1081 	 16,			/* bitsize */
1082 	 FALSE,			/* pc_relative */
1083 	 0,			/* bitpos */
1084 	 complain_overflow_dont, /* complain_on_overflow */
1085 	 bfd_elf_generic_reloc,	/* special_function */
1086 	 "R_M32R_GOTPC_HI_ULO",	/* name */
1087 	 FALSE,			/* partial_inplace */
1088 	 0x0000ffff,		/* src_mask */
1089 	 0x0000ffff,		/* dst_mask */
1090 	 TRUE),			/* pcrel_offset */
1091 
1092   /* An PC Relative relocation used when setting PIC offset table register.
1093      Like R_M32R_HI16_SLO, but referring to the GOT table entry for
1094      the symbol.  */
1095   HOWTO (R_M32R_GOTPC_HI_SLO,	/* type */
1096 	 16,			/* rightshift */
1097 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1098 	 16,			/* bitsize */
1099 	 FALSE,			/* pc_relative */
1100 	 0,			/* bitpos */
1101 	 complain_overflow_dont, /* complain_on_overflow */
1102 	 bfd_elf_generic_reloc,	/* special_function */
1103 	 "R_M32R_GOTPC_HI_SLO",	/* name */
1104 	 FALSE,			/* partial_inplace */
1105 	 0x0000ffff,		/* src_mask */
1106 	 0x0000ffff,		/* dst_mask */
1107 	 TRUE),			/* pcrel_offset */
1108 
1109   /* An PC Relative relocation used when setting PIC offset table register.
1110      Like R_M32R_LO16, but referring to the GOT table entry for
1111      the symbol.  */
1112   HOWTO (R_M32R_GOTPC_LO,	/* type */
1113 	 0,			/* rightshift */
1114 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1115 	 16,			/* bitsize */
1116 	 FALSE,			/* pc_relative */
1117 	 0,			/* bitpos */
1118 	 complain_overflow_dont, /* complain_on_overflow */
1119 	 bfd_elf_generic_reloc,	/* special_function */
1120 	 "R_M32R_GOTPC_LO",	/* name */
1121 	 FALSE,			/* partial_inplace */
1122 	 0x0000ffff,		/* src_mask */
1123 	 0x0000ffff,		/* dst_mask */
1124 	 TRUE),			/* pcrel_offset */
1125 
1126   HOWTO (R_M32R_GOTOFF_HI_ULO,	/* type */
1127 	 16,			/* rightshift */
1128 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1129 	 16,			/* bitsize */
1130 	 FALSE,			/* pc_relative */
1131 	 0,			/* bitpos */
1132 	 complain_overflow_dont, /* complain_on_overflow */
1133 	 bfd_elf_generic_reloc,	/* special_function */
1134 	 "R_M32R_GOTOFF_HI_ULO",/* name */
1135 	 FALSE,			/* partial_inplace */
1136 	 0x0000ffff,		/* src_mask */
1137 	 0x0000ffff,		/* dst_mask */
1138 	 FALSE),		/* pcrel_offset */
1139 
1140   HOWTO (R_M32R_GOTOFF_HI_SLO,	/* type */
1141 	 16,			/* rightshift */
1142 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1143 	 16,			/* bitsize */
1144 	 FALSE,			/* pc_relative */
1145 	 0,			/* bitpos */
1146 	 complain_overflow_dont, /* complain_on_overflow */
1147 	 bfd_elf_generic_reloc,	/* special_function */
1148 	 "R_M32R_GOTOFF_HI_SLO",/* name */
1149 	 FALSE,			/* partial_inplace */
1150 	 0x0000ffff,		/* src_mask */
1151 	 0x0000ffff,		/* dst_mask */
1152 	 FALSE),		/* pcrel_offset */
1153 
1154   HOWTO (R_M32R_GOTOFF_LO,	/* type */
1155 	 0,			/* rightshift */
1156 	 2,			/* size (0 = byte, 1 = short, 2 = long) */
1157 	 16,			/* bitsize */
1158 	 FALSE,			/* pc_relative */
1159 	 0,			/* bitpos */
1160 	 complain_overflow_dont, /* complain_on_overflow */
1161 	 bfd_elf_generic_reloc,	/* special_function */
1162 	 "R_M32R_GOTOFF_LO",	/* name */
1163 	 FALSE,			/* partial_inplace */
1164 	 0x0000ffff,		/* src_mask */
1165 	 0x0000ffff,		/* dst_mask */
1166 	 FALSE),		/* pcrel_offset */
1167 };
1168 
1169 /* Map BFD reloc types to M32R ELF reloc types.  */
1170 
1171 struct m32r_reloc_map
1172 {
1173   bfd_reloc_code_real_type bfd_reloc_val;
1174   unsigned char elf_reloc_val;
1175 };
1176 
1177 #ifdef USE_M32R_OLD_RELOC
1178 static const struct m32r_reloc_map m32r_reloc_map_old[] =
1179 {
1180   { BFD_RELOC_NONE, R_M32R_NONE },
1181   { BFD_RELOC_16, R_M32R_16 },
1182   { BFD_RELOC_32, R_M32R_32 },
1183   { BFD_RELOC_M32R_24, R_M32R_24 },
1184   { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL },
1185   { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL },
1186   { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL },
1187   { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO },
1188   { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO },
1189   { BFD_RELOC_M32R_LO16, R_M32R_LO16 },
1190   { BFD_RELOC_M32R_SDA16, R_M32R_SDA16 },
1191   { BFD_RELOC_VTABLE_INHERIT, R_M32R_GNU_VTINHERIT },
1192   { BFD_RELOC_VTABLE_ENTRY, R_M32R_GNU_VTENTRY },
1193 };
1194 #else
1195 static const struct m32r_reloc_map m32r_reloc_map[] =
1196 {
1197   { BFD_RELOC_NONE, R_M32R_NONE },
1198   { BFD_RELOC_16, R_M32R_16_RELA },
1199   { BFD_RELOC_32, R_M32R_32_RELA },
1200   { BFD_RELOC_M32R_24, R_M32R_24_RELA },
1201   { BFD_RELOC_M32R_10_PCREL, R_M32R_10_PCREL_RELA },
1202   { BFD_RELOC_M32R_18_PCREL, R_M32R_18_PCREL_RELA },
1203   { BFD_RELOC_M32R_26_PCREL, R_M32R_26_PCREL_RELA },
1204   { BFD_RELOC_M32R_HI16_ULO, R_M32R_HI16_ULO_RELA },
1205   { BFD_RELOC_M32R_HI16_SLO, R_M32R_HI16_SLO_RELA },
1206   { BFD_RELOC_M32R_LO16, R_M32R_LO16_RELA },
1207   { BFD_RELOC_M32R_SDA16, R_M32R_SDA16_RELA },
1208   { BFD_RELOC_VTABLE_INHERIT, R_M32R_RELA_GNU_VTINHERIT },
1209   { BFD_RELOC_VTABLE_ENTRY, R_M32R_RELA_GNU_VTENTRY },
1210   { BFD_RELOC_32_PCREL, R_M32R_REL32 },
1211 
1212   { BFD_RELOC_M32R_GOT24, R_M32R_GOT24 },
1213   { BFD_RELOC_M32R_26_PLTREL, R_M32R_26_PLTREL },
1214   { BFD_RELOC_M32R_COPY, R_M32R_COPY },
1215   { BFD_RELOC_M32R_GLOB_DAT, R_M32R_GLOB_DAT },
1216   { BFD_RELOC_M32R_JMP_SLOT, R_M32R_JMP_SLOT },
1217   { BFD_RELOC_M32R_RELATIVE, R_M32R_RELATIVE },
1218   { BFD_RELOC_M32R_GOTOFF, R_M32R_GOTOFF },
1219   { BFD_RELOC_M32R_GOTPC24, R_M32R_GOTPC24 },
1220   { BFD_RELOC_M32R_GOT16_HI_ULO, R_M32R_GOT16_HI_ULO },
1221   { BFD_RELOC_M32R_GOT16_HI_SLO, R_M32R_GOT16_HI_SLO },
1222   { BFD_RELOC_M32R_GOT16_LO, R_M32R_GOT16_LO },
1223   { BFD_RELOC_M32R_GOTPC_HI_ULO, R_M32R_GOTPC_HI_ULO },
1224   { BFD_RELOC_M32R_GOTPC_HI_SLO, R_M32R_GOTPC_HI_SLO },
1225   { BFD_RELOC_M32R_GOTPC_LO, R_M32R_GOTPC_LO },
1226   { BFD_RELOC_M32R_GOTOFF_HI_ULO, R_M32R_GOTOFF_HI_ULO },
1227   { BFD_RELOC_M32R_GOTOFF_HI_SLO, R_M32R_GOTOFF_HI_SLO },
1228   { BFD_RELOC_M32R_GOTOFF_LO, R_M32R_GOTOFF_LO },
1229 };
1230 #endif
1231 
1232 static reloc_howto_type *
1233 bfd_elf32_bfd_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1234 				 bfd_reloc_code_real_type code)
1235 {
1236   unsigned int i;
1237 
1238 #ifdef USE_M32R_OLD_RELOC
1239   for (i = 0;
1240        i < sizeof (m32r_reloc_map_old) / sizeof (struct m32r_reloc_map);
1241        i++)
1242     if (m32r_reloc_map_old[i].bfd_reloc_val == code)
1243       return &m32r_elf_howto_table[m32r_reloc_map_old[i].elf_reloc_val];
1244 
1245 #else /* ! USE_M32R_OLD_RELOC */
1246 
1247   for (i = 0;
1248        i < sizeof (m32r_reloc_map) / sizeof (struct m32r_reloc_map);
1249        i++)
1250     if (m32r_reloc_map[i].bfd_reloc_val == code)
1251       return &m32r_elf_howto_table[m32r_reloc_map[i].elf_reloc_val];
1252 #endif
1253 
1254   return NULL;
1255 }
1256 
1257 static reloc_howto_type *
1258 bfd_elf32_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1259 				 const char *r_name)
1260 {
1261   unsigned int i;
1262 
1263   for (i = 0;
1264        i < sizeof (m32r_elf_howto_table) / sizeof (m32r_elf_howto_table[0]);
1265        i++)
1266     if (m32r_elf_howto_table[i].name != NULL
1267 	&& strcasecmp (m32r_elf_howto_table[i].name, r_name) == 0)
1268       return &m32r_elf_howto_table[i];
1269 
1270   return NULL;
1271 }
1272 
1273 /* Set the howto pointer for an M32R ELF reloc.  */
1274 
1275 static void
1276 m32r_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1277 			arelent *cache_ptr,
1278 			Elf_Internal_Rela *dst)
1279 {
1280   unsigned int r_type;
1281 
1282   r_type = ELF32_R_TYPE (dst->r_info);
1283   BFD_ASSERT (ELF32_R_TYPE(dst->r_info) <= (unsigned int) R_M32R_GNU_VTENTRY);
1284   cache_ptr->howto = &m32r_elf_howto_table[r_type];
1285 }
1286 
1287 static void
1288 m32r_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1289 		    arelent *cache_ptr,
1290 		    Elf_Internal_Rela *dst)
1291 {
1292   BFD_ASSERT ((ELF32_R_TYPE(dst->r_info) == (unsigned int) R_M32R_NONE)
1293               || ((ELF32_R_TYPE(dst->r_info) > (unsigned int) R_M32R_GNU_VTENTRY)
1294                   && (ELF32_R_TYPE(dst->r_info) < (unsigned int) R_M32R_max)));
1295   cache_ptr->howto = &m32r_elf_howto_table[ELF32_R_TYPE(dst->r_info)];
1296 }
1297 
1298 
1299 /* Given a BFD section, try to locate the corresponding ELF section
1300    index.  */
1301 
1302 static bfd_boolean
1303 _bfd_m32r_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
1304 					asection *sec,
1305 					int *retval)
1306 {
1307   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1308     {
1309       *retval = SHN_M32R_SCOMMON;
1310       return TRUE;
1311     }
1312   return FALSE;
1313 }
1314 
1315 /* M32R ELF uses two common sections.  One is the usual one, and the other
1316    is for small objects.  All the small objects are kept together, and then
1317    referenced via one register, which yields faster assembler code.  It is
1318    up to the compiler to emit an instruction to load the register with
1319    _SDA_BASE.  This is what we use for the small common section.  This
1320    approach is copied from elf32-mips.c.  */
1321 static asection m32r_elf_scom_section;
1322 static asymbol m32r_elf_scom_symbol;
1323 static asymbol *m32r_elf_scom_symbol_ptr;
1324 
1325 /* Handle the special M32R section numbers that a symbol may use.  */
1326 
1327 static void
1328 _bfd_m32r_elf_symbol_processing (bfd *abfd ATTRIBUTE_UNUSED, asymbol *asym)
1329 {
1330   elf_symbol_type *elfsym = (elf_symbol_type *) asym;
1331 
1332   switch (elfsym->internal_elf_sym.st_shndx)
1333     {
1334     case SHN_M32R_SCOMMON:
1335       if (m32r_elf_scom_section.name == NULL)
1336 	{
1337 	  /* Initialize the small common section.  */
1338 	  m32r_elf_scom_section.name = ".scommon";
1339 	  m32r_elf_scom_section.flags = SEC_IS_COMMON;
1340 	  m32r_elf_scom_section.output_section = &m32r_elf_scom_section;
1341 	  m32r_elf_scom_section.symbol = &m32r_elf_scom_symbol;
1342 	  m32r_elf_scom_section.symbol_ptr_ptr = &m32r_elf_scom_symbol_ptr;
1343 	  m32r_elf_scom_symbol.name = ".scommon";
1344 	  m32r_elf_scom_symbol.flags = BSF_SECTION_SYM;
1345 	  m32r_elf_scom_symbol.section = &m32r_elf_scom_section;
1346 	  m32r_elf_scom_symbol_ptr = &m32r_elf_scom_symbol;
1347 	}
1348       asym->section = &m32r_elf_scom_section;
1349       asym->value = elfsym->internal_elf_sym.st_size;
1350       break;
1351     }
1352 }
1353 
1354 /* Hook called by the linker routine which adds symbols from an object
1355    file.  We must handle the special M32R section numbers here.
1356    We also keep watching for whether we need to create the sdata special
1357    linker sections.  */
1358 
1359 static bfd_boolean
1360 m32r_elf_add_symbol_hook (bfd *abfd,
1361 			  struct bfd_link_info *info,
1362 			  Elf_Internal_Sym *sym,
1363 			  const char **namep,
1364 			  flagword *flagsp ATTRIBUTE_UNUSED,
1365 			  asection **secp,
1366 			  bfd_vma *valp)
1367 {
1368   if (! info->relocatable
1369       && (*namep)[0] == '_' && (*namep)[1] == 'S'
1370       && strcmp (*namep, "_SDA_BASE_") == 0
1371       && is_elf_hash_table (info->hash))
1372     {
1373       /* This is simpler than using _bfd_elf_create_linker_section
1374 	 (our needs are simpler than ppc's needs).  Also
1375 	 _bfd_elf_create_linker_section currently has a bug where if a .sdata
1376 	 section already exists a new one is created that follows it which
1377 	 screws of _SDA_BASE_ address calcs because output_offset != 0.  */
1378       struct elf_link_hash_entry *h;
1379       struct bfd_link_hash_entry *bh;
1380       asection *s = bfd_get_section_by_name (abfd, ".sdata");
1381 
1382       /* The following code was cobbled from elf32-ppc.c and elflink.c.  */
1383       if (s == NULL)
1384 	{
1385 	  flagword flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS
1386 			    | SEC_IN_MEMORY | SEC_LINKER_CREATED);
1387 
1388 	  s = bfd_make_section_anyway_with_flags (abfd, ".sdata",
1389 						  flags);
1390 	  if (s == NULL)
1391 	    return FALSE;
1392 	  if (! bfd_set_section_alignment (abfd, s, 2))
1393 	    return FALSE;
1394 	}
1395 
1396       bh = bfd_link_hash_lookup (info->hash, "_SDA_BASE_",
1397 				 FALSE, FALSE, FALSE);
1398 
1399       if ((bh == NULL || bh->type == bfd_link_hash_undefined)
1400 	  && !(_bfd_generic_link_add_one_symbol (info,
1401 						 abfd,
1402 						 "_SDA_BASE_",
1403 						 BSF_GLOBAL,
1404 						 s,
1405 						 (bfd_vma) 32768,
1406 						 NULL,
1407 						 FALSE,
1408 						 get_elf_backend_data (abfd)->collect,
1409 						 &bh)))
1410 	return FALSE;
1411       h = (struct elf_link_hash_entry *) bh;
1412       h->type = STT_OBJECT;
1413     }
1414 
1415   switch (sym->st_shndx)
1416     {
1417     case SHN_M32R_SCOMMON:
1418       *secp = bfd_make_section_old_way (abfd, ".scommon");
1419       (*secp)->flags |= SEC_IS_COMMON;
1420       *valp = sym->st_size;
1421       break;
1422     }
1423 
1424   return TRUE;
1425 }
1426 
1427 /* We have to figure out the SDA_BASE value, so that we can adjust the
1428    symbol value correctly.  We look up the symbol _SDA_BASE_ in the output
1429    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
1430    target data.  We don't need to adjust the symbol value for an
1431    external symbol if we are producing relocatable output.  */
1432 
1433 static bfd_reloc_status_type
1434 m32r_elf_final_sda_base (bfd *output_bfd,
1435 			 struct bfd_link_info *info,
1436 			 const char **error_message,
1437 			 bfd_vma *psb)
1438 {
1439   if (elf_gp (output_bfd) == 0)
1440     {
1441       struct bfd_link_hash_entry *h;
1442 
1443       h = bfd_link_hash_lookup (info->hash, "_SDA_BASE_", FALSE, FALSE, TRUE);
1444       if (h != NULL && h->type == bfd_link_hash_defined)
1445 	elf_gp (output_bfd) = (h->u.def.value
1446 			       + h->u.def.section->output_section->vma
1447 			       + h->u.def.section->output_offset);
1448       else
1449 	{
1450 	  /* Only get the error once.  */
1451 	  *psb = elf_gp (output_bfd) = 4;
1452 	  *error_message =
1453 	    (const char *) _("SDA relocation when _SDA_BASE_ not defined");
1454 	  return bfd_reloc_dangerous;
1455 	}
1456     }
1457   *psb = elf_gp (output_bfd);
1458   return bfd_reloc_ok;
1459 }
1460 
1461 /* Return size of a PLT entry.  */
1462 #define elf_m32r_sizeof_plt(info) PLT_ENTRY_SIZE
1463 
1464 /* The m32r linker needs to keep track of the number of relocs that it
1465    decides to copy in check_relocs for each symbol.  This is so that
1466    it can discard PC relative relocs if it doesn't need them when
1467    linking with -Bsymbolic.  We store the information in a field
1468    extending the regular ELF linker hash table.  */
1469 
1470 /* This structure keeps track of the number of PC relative relocs we
1471    have copied for a given symbol.  */
1472 
1473 struct elf_m32r_pcrel_relocs_copied
1474 {
1475   /* Next section.  */
1476   struct elf_m32r_pcrel_relocs_copied *next;
1477   /* A section in dynobj.  */
1478   asection *section;
1479   /* Number of relocs copied in this section.  */
1480   bfd_size_type count;
1481 };
1482 
1483 /* The sh linker needs to keep track of the number of relocs that it
1484    decides to copy as dynamic relocs in check_relocs for each symbol.
1485    This is so that it can later discard them if they are found to be
1486    unnecessary.  We store the information in a field extending the
1487    regular ELF linker hash table.  */
1488 
1489 struct elf_m32r_dyn_relocs
1490 {
1491   struct elf_m32r_dyn_relocs *next;
1492 
1493   /* The input section of the reloc.  */
1494   asection *sec;
1495 
1496   /* Total number of relocs copied for the input section.  */
1497   bfd_size_type count;
1498 
1499   /* Number of pc-relative relocs copied for the input section.  */
1500   bfd_size_type pc_count;
1501 };
1502 
1503 
1504 /* m32r ELF linker hash entry.  */
1505 
1506 struct elf_m32r_link_hash_entry
1507 {
1508   struct elf_link_hash_entry root;
1509 
1510   /* Track dynamic relocs copied for this symbol.  */
1511   struct elf_m32r_dyn_relocs *dyn_relocs;
1512 };
1513 
1514 /* m32r ELF linker hash table.  */
1515 
1516 struct elf_m32r_link_hash_table
1517 {
1518   struct elf_link_hash_table root;
1519 
1520   /* Short-cuts to get to dynamic linker sections.  */
1521   asection *sgot;
1522   asection *sgotplt;
1523   asection *srelgot;
1524   asection *splt;
1525   asection *srelplt;
1526   asection *sdynbss;
1527   asection *srelbss;
1528 
1529   /* Small local sym cache.  */
1530   struct sym_cache sym_cache;
1531 };
1532 
1533 /* Traverse an m32r ELF linker hash table.  */
1534 
1535 #define m32r_elf_link_hash_traverse(table, func, info)			\
1536   (elf_link_hash_traverse						\
1537    (&(table)->root,							\
1538     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),	\
1539     (info)))
1540 
1541 /* Get the m32r ELF linker hash table from a link_info structure.  */
1542 
1543 #define m32r_elf_hash_table(p) \
1544   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1545   == M32R_ELF_DATA ? ((struct elf_m32r_link_hash_table *) ((p)->hash)) : NULL)
1546 
1547 /* Create an entry in an m32r ELF linker hash table.  */
1548 
1549 static struct bfd_hash_entry *
1550 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1551 			    struct bfd_hash_table *table,
1552 			    const char *string)
1553 {
1554   struct elf_m32r_link_hash_entry *ret =
1555     (struct elf_m32r_link_hash_entry *) entry;
1556 
1557   /* Allocate the structure if it has not already been allocated by a
1558      subclass.  */
1559   if (ret == NULL)
1560     ret = bfd_hash_allocate (table,
1561 			     sizeof (struct elf_m32r_link_hash_entry));
1562   if (ret == NULL)
1563     return NULL;
1564 
1565   /* Call the allocation method of the superclass.  */
1566   ret = ((struct elf_m32r_link_hash_entry *)
1567          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1568                                      table, string));
1569   if (ret != NULL)
1570     {
1571       struct elf_m32r_link_hash_entry *eh;
1572 
1573       eh = (struct elf_m32r_link_hash_entry *) ret;
1574       eh->dyn_relocs = NULL;
1575     }
1576 
1577   return (struct bfd_hash_entry *) ret;
1578 }
1579 
1580 /* Create an m32r ELF linker hash table.  */
1581 
1582 static struct bfd_link_hash_table *
1583 m32r_elf_link_hash_table_create (bfd *abfd)
1584 {
1585   struct elf_m32r_link_hash_table *ret;
1586   bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1587 
1588   ret = bfd_zmalloc (amt);
1589   if (ret == NULL)
1590     return NULL;
1591 
1592   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
1593 				      m32r_elf_link_hash_newfunc,
1594 				      sizeof (struct elf_m32r_link_hash_entry),
1595 				      M32R_ELF_DATA))
1596     {
1597       free (ret);
1598       return NULL;
1599     }
1600 
1601   return &ret->root.root;
1602 }
1603 
1604 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1605    shortcuts to them in our hash table.  */
1606 
1607 static bfd_boolean
1608 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1609 {
1610   struct elf_m32r_link_hash_table *htab;
1611 
1612   if (! _bfd_elf_create_got_section (dynobj, info))
1613     return FALSE;
1614 
1615   htab = m32r_elf_hash_table (info);
1616   if (htab == NULL)
1617     return FALSE;
1618 
1619   htab->sgot = bfd_get_linker_section (dynobj, ".got");
1620   htab->sgotplt = bfd_get_linker_section (dynobj, ".got.plt");
1621   htab->srelgot = bfd_get_linker_section (dynobj, ".rela.got");
1622   if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
1623     abort ();
1624 
1625   return TRUE;
1626 }
1627 
1628 /* Create dynamic sections when linking against a dynamic object.  */
1629 
1630 static bfd_boolean
1631 m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1632 {
1633   struct elf_m32r_link_hash_table *htab;
1634   flagword flags, pltflags;
1635   asection *s;
1636   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1637   int ptralign = 2; /* 32bit */
1638 
1639   htab = m32r_elf_hash_table (info);
1640   if (htab == NULL)
1641     return FALSE;
1642 
1643   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1644      .rel[a].bss sections.  */
1645   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1646            | SEC_LINKER_CREATED);
1647 
1648   pltflags = flags;
1649   pltflags |= SEC_CODE;
1650   if (bed->plt_not_loaded)
1651     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1652   if (bed->plt_readonly)
1653     pltflags |= SEC_READONLY;
1654 
1655   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
1656   htab->splt = s;
1657   if (s == NULL
1658       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1659     return FALSE;
1660 
1661   if (bed->want_plt_sym)
1662     {
1663       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1664          .plt section.  */
1665       struct bfd_link_hash_entry *bh = NULL;
1666       struct elf_link_hash_entry *h;
1667 
1668       if (! (_bfd_generic_link_add_one_symbol
1669              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1670               (bfd_vma) 0, NULL, FALSE,
1671               get_elf_backend_data (abfd)->collect, &bh)))
1672         return FALSE;
1673       h = (struct elf_link_hash_entry *) bh;
1674       h->def_regular = 1;
1675       h->type = STT_OBJECT;
1676       htab->root.hplt = h;
1677 
1678       if (info->shared
1679           && ! bfd_elf_link_record_dynamic_symbol (info, h))
1680         return FALSE;
1681     }
1682 
1683   s = bfd_make_section_anyway_with_flags (abfd,
1684 					  bed->default_use_rela_p
1685 					  ? ".rela.plt" : ".rel.plt",
1686 					  flags | SEC_READONLY);
1687   htab->srelplt = s;
1688   if (s == NULL
1689       || ! bfd_set_section_alignment (abfd, s, ptralign))
1690     return FALSE;
1691 
1692   if (htab->sgot == NULL
1693       && ! create_got_section (abfd, info))
1694     return FALSE;
1695 
1696   if (bed->want_dynbss)
1697     {
1698       /* The .dynbss section is a place to put symbols which are defined
1699          by dynamic objects, are referenced by regular objects, and are
1700          not functions.  We must allocate space for them in the process
1701          image and use a R_*_COPY reloc to tell the dynamic linker to
1702          initialize them at run time.  The linker script puts the .dynbss
1703          section into the .bss section of the final image.  */
1704       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
1705 					      SEC_ALLOC | SEC_LINKER_CREATED);
1706       htab->sdynbss = s;
1707       if (s == NULL)
1708         return FALSE;
1709       /* The .rel[a].bss section holds copy relocs.  This section is not
1710          normally needed.  We need to create it here, though, so that the
1711          linker will map it to an output section.  We can't just create it
1712          only if we need it, because we will not know whether we need it
1713          until we have seen all the input files, and the first time the
1714          main linker code calls BFD after examining all the input files
1715          (size_dynamic_sections) the input sections have already been
1716          mapped to the output sections.  If the section turns out not to
1717          be needed, we can discard it later.  We will never need this
1718          section when generating a shared object, since they do not use
1719          copy relocs.  */
1720       if (! info->shared)
1721         {
1722           s = bfd_make_section_anyway_with_flags (abfd,
1723 						  (bed->default_use_rela_p
1724 						   ? ".rela.bss" : ".rel.bss"),
1725 						  flags | SEC_READONLY);
1726           htab->srelbss = s;
1727           if (s == NULL
1728               || ! bfd_set_section_alignment (abfd, s, ptralign))
1729             return FALSE;
1730         }
1731     }
1732 
1733   return TRUE;
1734 }
1735 
1736 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1737 
1738 static void
1739 m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1740                                struct elf_link_hash_entry *dir,
1741                                struct elf_link_hash_entry *ind)
1742 {
1743   struct elf_m32r_link_hash_entry * edir;
1744   struct elf_m32r_link_hash_entry * eind;
1745 
1746   edir = (struct elf_m32r_link_hash_entry *) dir;
1747   eind = (struct elf_m32r_link_hash_entry *) ind;
1748 
1749   if (eind->dyn_relocs != NULL)
1750     {
1751       if (edir->dyn_relocs != NULL)
1752         {
1753           struct elf_m32r_dyn_relocs **pp;
1754           struct elf_m32r_dyn_relocs *p;
1755 
1756           /* Add reloc counts against the indirect sym to the direct sym
1757              list.  Merge any entries against the same section.  */
1758           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1759             {
1760               struct elf_m32r_dyn_relocs *q;
1761 
1762               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1763                 if (q->sec == p->sec)
1764                   {
1765                     q->pc_count += p->pc_count;
1766                     q->count += p->count;
1767                     *pp = p->next;
1768                     break;
1769                   }
1770               if (q == NULL)
1771                 pp = &p->next;
1772             }
1773           *pp = edir->dyn_relocs;
1774         }
1775 
1776       edir->dyn_relocs = eind->dyn_relocs;
1777       eind->dyn_relocs = NULL;
1778     }
1779 
1780   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1781 }
1782 
1783 
1784 /* Adjust a symbol defined by a dynamic object and referenced by a
1785    regular object.  The current definition is in some section of the
1786    dynamic object, but we're not including those sections.  We have to
1787    change the definition to something the rest of the link can
1788    understand.  */
1789 
1790 static bfd_boolean
1791 m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1792 				struct elf_link_hash_entry *h)
1793 {
1794   struct elf_m32r_link_hash_table *htab;
1795   struct elf_m32r_link_hash_entry *eh;
1796   struct elf_m32r_dyn_relocs *p;
1797   bfd *dynobj;
1798   asection *s;
1799 
1800 #ifdef DEBUG_PIC
1801   printf ("m32r_elf_adjust_dynamic_symbol()\n");
1802 #endif
1803 
1804   dynobj = elf_hash_table (info)->dynobj;
1805 
1806   /* Make sure we know what is going on here.  */
1807   BFD_ASSERT (dynobj != NULL
1808               && (h->needs_plt
1809                   || h->u.weakdef != NULL
1810                   || (h->def_dynamic
1811                       && h->ref_regular
1812                       && !h->def_regular)));
1813 
1814   /* If this is a function, put it in the procedure linkage table.  We
1815      will fill in the contents of the procedure linkage table later,
1816      when we know the address of the .got section.  */
1817   if (h->type == STT_FUNC
1818       || h->needs_plt)
1819     {
1820       if (! info->shared
1821           && !h->def_dynamic
1822           && !h->ref_dynamic
1823 	  && h->root.type != bfd_link_hash_undefweak
1824 	  && h->root.type != bfd_link_hash_undefined)
1825         {
1826           /* This case can occur if we saw a PLT reloc in an input
1827              file, but the symbol was never referred to by a dynamic
1828              object.  In such a case, we don't actually need to build
1829              a procedure linkage table, and we can just do a PCREL
1830              reloc instead.  */
1831           h->plt.offset = (bfd_vma) -1;
1832           h->needs_plt = 0;
1833         }
1834 
1835       return TRUE;
1836     }
1837   else
1838     h->plt.offset = (bfd_vma) -1;
1839 
1840   /* If this is a weak symbol, and there is a real definition, the
1841      processor independent code will have arranged for us to see the
1842      real definition first, and we can just use the same value.  */
1843   if (h->u.weakdef != NULL)
1844     {
1845       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1846                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1847       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1848       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1849       return TRUE;
1850     }
1851 
1852   /* This is a reference to a symbol defined by a dynamic object which
1853      is not a function.  */
1854 
1855   /* If we are creating a shared library, we must presume that the
1856      only references to the symbol are via the global offset table.
1857      For such cases we need not do anything here; the relocations will
1858      be handled correctly by relocate_section.  */
1859   if (info->shared)
1860     return TRUE;
1861 
1862   /* If there are no references to this symbol that do not use the
1863      GOT, we don't need to generate a copy reloc.  */
1864   if (!h->non_got_ref)
1865     return TRUE;
1866 
1867   /* If -z nocopyreloc was given, we won't generate them either.  */
1868   if (info->nocopyreloc)
1869     {
1870       h->non_got_ref = 0;
1871       return TRUE;
1872     }
1873 
1874   eh = (struct elf_m32r_link_hash_entry *) h;
1875   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1876     {
1877       s = p->sec->output_section;
1878       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1879         break;
1880     }
1881 
1882   /* If we didn't find any dynamic relocs in sections which needs the
1883      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1884      the copy reloc.  */
1885   if (p == NULL)
1886     {
1887       h->non_got_ref = 0;
1888       return TRUE;
1889     }
1890 
1891   /* We must allocate the symbol in our .dynbss section, which will
1892      become part of the .bss section of the executable.  There will be
1893      an entry for this symbol in the .dynsym section.  The dynamic
1894      object will contain position independent code, so all references
1895      from the dynamic object to this symbol will go through the global
1896      offset table.  The dynamic linker will use the .dynsym entry to
1897      determine the address it must put in the global offset table, so
1898      both the dynamic object and the regular object will refer to the
1899      same memory location for the variable.  */
1900 
1901   htab = m32r_elf_hash_table (info);
1902   if (htab == NULL)
1903     return FALSE;
1904 
1905   s = htab->sdynbss;
1906   BFD_ASSERT (s != NULL);
1907 
1908   /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1909      to copy the initial value out of the dynamic object and into the
1910      runtime process image.  We need to remember the offset into the
1911      .rela.bss section we are going to use.  */
1912   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1913     {
1914       asection *srel;
1915 
1916       srel = htab->srelbss;
1917       BFD_ASSERT (srel != NULL);
1918       srel->size += sizeof (Elf32_External_Rela);
1919       h->needs_copy = 1;
1920     }
1921 
1922   return _bfd_elf_adjust_dynamic_copy (h, s);
1923 }
1924 
1925 /* Allocate space in .plt, .got and associated reloc sections for
1926    dynamic relocs.  */
1927 
1928 static bfd_boolean
1929 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1930 {
1931   struct bfd_link_info *info;
1932   struct elf_m32r_link_hash_table *htab;
1933   struct elf_m32r_link_hash_entry *eh;
1934   struct elf_m32r_dyn_relocs *p;
1935 
1936   if (h->root.type == bfd_link_hash_indirect)
1937     return TRUE;
1938 
1939   info = (struct bfd_link_info *) inf;
1940   htab = m32r_elf_hash_table (info);
1941   if (htab == NULL)
1942     return FALSE;
1943 
1944   eh = (struct elf_m32r_link_hash_entry *) h;
1945 
1946   if (htab->root.dynamic_sections_created
1947       && h->plt.refcount > 0)
1948     {
1949       /* Make sure this symbol is output as a dynamic symbol.
1950          Undefined weak syms won't yet be marked as dynamic.  */
1951       if (h->dynindx == -1
1952           && !h->forced_local)
1953         {
1954           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1955             return FALSE;
1956         }
1957 
1958       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1959         {
1960           asection *s = htab->splt;
1961 
1962           /* If this is the first .plt entry, make room for the special
1963              first entry.  */
1964           if (s->size == 0)
1965             s->size += PLT_ENTRY_SIZE;
1966 
1967           h->plt.offset = s->size;
1968 
1969           /* If this symbol is not defined in a regular file, and we are
1970              not generating a shared library, then set the symbol to this
1971              location in the .plt.  This is required to make function
1972              pointers compare as equal between the normal executable and
1973              the shared library.  */
1974           if (! info->shared
1975               && !h->def_regular)
1976             {
1977               h->root.u.def.section = s;
1978               h->root.u.def.value = h->plt.offset;
1979             }
1980 
1981           /* Make room for this entry.  */
1982           s->size += PLT_ENTRY_SIZE;
1983 
1984           /* We also need to make an entry in the .got.plt section, which
1985              will be placed in the .got section by the linker script.  */
1986           htab->sgotplt->size += 4;
1987 
1988           /* We also need to make an entry in the .rel.plt section.  */
1989           htab->srelplt->size += sizeof (Elf32_External_Rela);
1990         }
1991       else
1992         {
1993           h->plt.offset = (bfd_vma) -1;
1994           h->needs_plt = 0;
1995         }
1996     }
1997   else
1998     {
1999       h->plt.offset = (bfd_vma) -1;
2000       h->needs_plt = 0;
2001     }
2002 
2003   if (h->got.refcount > 0)
2004     {
2005       asection *s;
2006       bfd_boolean dyn;
2007 
2008       /* Make sure this symbol is output as a dynamic symbol.
2009          Undefined weak syms won't yet be marked as dynamic.  */
2010       if (h->dynindx == -1
2011           && !h->forced_local)
2012         {
2013           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2014             return FALSE;
2015         }
2016 
2017       s = htab->sgot;
2018 
2019       h->got.offset = s->size;
2020       s->size += 4;
2021       dyn = htab->root.dynamic_sections_created;
2022       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2023         htab->srelgot->size += sizeof (Elf32_External_Rela);
2024     }
2025   else
2026     h->got.offset = (bfd_vma) -1;
2027 
2028   if (eh->dyn_relocs == NULL)
2029     return TRUE;
2030 
2031   /* In the shared -Bsymbolic case, discard space allocated for
2032      dynamic pc-relative relocs against symbols which turn out to be
2033      defined in regular objects.  For the normal shared case, discard
2034      space for pc-relative relocs that have become local due to symbol
2035      visibility changes.  */
2036 
2037   if (info->shared)
2038     {
2039       if (h->def_regular
2040           && (h->forced_local
2041               || info->symbolic))
2042         {
2043           struct elf_m32r_dyn_relocs **pp;
2044 
2045           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2046             {
2047               p->count -= p->pc_count;
2048               p->pc_count = 0;
2049               if (p->count == 0)
2050                 *pp = p->next;
2051               else
2052                 pp = &p->next;
2053             }
2054         }
2055 
2056       /* Also discard relocs on undefined weak syms with non-default
2057 	 visibility.  */
2058       if (eh->dyn_relocs != NULL
2059 	  && h->root.type == bfd_link_hash_undefweak)
2060 	{
2061 	  if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2062 	    eh->dyn_relocs = NULL;
2063 
2064 	  /* Make sure undefined weak symbols are output as a dynamic
2065 	     symbol in PIEs.  */
2066 	  else if (h->dynindx == -1
2067 		   && !h->forced_local)
2068 	    {
2069 	      if (! bfd_elf_link_record_dynamic_symbol (info, h))
2070 		return FALSE;
2071 	    }
2072 	}
2073     }
2074   else
2075     {
2076       /* For the non-shared case, discard space for relocs against
2077          symbols which turn out to need copy relocs or are not
2078          dynamic.  */
2079 
2080       if (!h->non_got_ref
2081           && ((h->def_dynamic
2082                && !h->def_regular)
2083               || (htab->root.dynamic_sections_created
2084                   && (h->root.type == bfd_link_hash_undefweak
2085                       || h->root.type == bfd_link_hash_undefined))))
2086         {
2087           /* Make sure this symbol is output as a dynamic symbol.
2088              Undefined weak syms won't yet be marked as dynamic.  */
2089           if (h->dynindx == -1
2090               && !h->forced_local)
2091             {
2092               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2093                 return FALSE;
2094             }
2095 
2096           /* If that succeeded, we know we'll be keeping all the
2097              relocs.  */
2098           if (h->dynindx != -1)
2099             goto keep;
2100         }
2101 
2102       eh->dyn_relocs = NULL;
2103 
2104     keep: ;
2105     }
2106 
2107   /* Finally, allocate space.  */
2108   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2109     {
2110       asection *sreloc = elf_section_data (p->sec)->sreloc;
2111       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2112     }
2113 
2114   return TRUE;
2115 }
2116 
2117 /* Find any dynamic relocs that apply to read-only sections.  */
2118 
2119 static bfd_boolean
2120 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2121 {
2122   struct elf_m32r_link_hash_entry *eh;
2123   struct elf_m32r_dyn_relocs *p;
2124 
2125   eh = (struct elf_m32r_link_hash_entry *) h;
2126   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2127     {
2128       asection *s = p->sec->output_section;
2129 
2130       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2131         {
2132           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2133 
2134           info->flags |= DF_TEXTREL;
2135 
2136           /* Not an error, just cut short the traversal.  */
2137           return FALSE;
2138         }
2139     }
2140   return TRUE;
2141 }
2142 
2143 /* Set the sizes of the dynamic sections.  */
2144 
2145 static bfd_boolean
2146 m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2147 				struct bfd_link_info *info)
2148 {
2149   struct elf_m32r_link_hash_table *htab;
2150   bfd *dynobj;
2151   asection *s;
2152   bfd_boolean relocs;
2153   bfd *ibfd;
2154 
2155 #ifdef DEBUG_PIC
2156   printf ("m32r_elf_size_dynamic_sections()\n");
2157 #endif
2158 
2159   htab = m32r_elf_hash_table (info);
2160   if (htab == NULL)
2161     return FALSE;
2162 
2163   dynobj = htab->root.dynobj;
2164   BFD_ASSERT (dynobj != NULL);
2165 
2166   if (htab->root.dynamic_sections_created)
2167     {
2168       /* Set the contents of the .interp section to the interpreter.  */
2169       if (info->executable)
2170 	{
2171 	  s = bfd_get_linker_section (dynobj, ".interp");
2172 	  BFD_ASSERT (s != NULL);
2173 	  s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2174 	  s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2175 	}
2176     }
2177 
2178   /* Set up .got offsets for local syms, and space for local dynamic
2179      relocs.  */
2180   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2181     {
2182       bfd_signed_vma *local_got;
2183       bfd_signed_vma *end_local_got;
2184       bfd_size_type locsymcount;
2185       Elf_Internal_Shdr *symtab_hdr;
2186       asection *srel;
2187 
2188       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2189         continue;
2190 
2191       for (s = ibfd->sections; s != NULL; s = s->next)
2192         {
2193           struct elf_m32r_dyn_relocs *p;
2194 
2195           for (p = ((struct elf_m32r_dyn_relocs *)
2196                     elf_section_data (s)->local_dynrel);
2197                p != NULL;
2198                p = p->next)
2199             {
2200               if (! bfd_is_abs_section (p->sec)
2201                   && bfd_is_abs_section (p->sec->output_section))
2202                 {
2203                   /* Input section has been discarded, either because
2204                      it is a copy of a linkonce section or due to
2205                      linker script /DISCARD/, so we'll be discarding
2206                      the relocs too.  */
2207                 }
2208               else if (p->count != 0)
2209                 {
2210                   srel = elf_section_data (p->sec)->sreloc;
2211                   srel->size += p->count * sizeof (Elf32_External_Rela);
2212                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2213                     info->flags |= DF_TEXTREL;
2214                 }
2215             }
2216         }
2217 
2218       local_got = elf_local_got_refcounts (ibfd);
2219       if (!local_got)
2220         continue;
2221 
2222       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2223       locsymcount = symtab_hdr->sh_info;
2224       end_local_got = local_got + locsymcount;
2225       s = htab->sgot;
2226       srel = htab->srelgot;
2227       for (; local_got < end_local_got; ++local_got)
2228         {
2229           if (*local_got > 0)
2230             {
2231               *local_got = s->size;
2232               s->size += 4;
2233               if (info->shared)
2234                 srel->size += sizeof (Elf32_External_Rela);
2235             }
2236           else
2237             *local_got = (bfd_vma) -1;
2238         }
2239     }
2240 
2241   /* Allocate global sym .plt and .got entries, and space for global
2242      sym dynamic relocs.  */
2243   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2244 
2245   /* We now have determined the sizes of the various dynamic sections.
2246      Allocate memory for them.  */
2247   relocs = FALSE;
2248   for (s = dynobj->sections; s != NULL; s = s->next)
2249     {
2250       if ((s->flags & SEC_LINKER_CREATED) == 0)
2251         continue;
2252 
2253       if (s == htab->splt
2254           || s == htab->sgot
2255           || s == htab->sgotplt
2256 	  || s == htab->sdynbss)
2257         {
2258           /* Strip this section if we don't need it; see the
2259              comment below.  */
2260         }
2261       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2262         {
2263           if (s->size != 0 && s != htab->srelplt)
2264             relocs = TRUE;
2265 
2266           /* We use the reloc_count field as a counter if we need
2267              to copy relocs into the output file.  */
2268           s->reloc_count = 0;
2269         }
2270       else
2271 	/* It's not one of our sections, so don't allocate space.  */
2272 	continue;
2273 
2274       if (s->size == 0)
2275         {
2276           /* If we don't need this section, strip it from the
2277              output file.  This is mostly to handle .rela.bss and
2278              .rela.plt.  We must create both sections in
2279              create_dynamic_sections, because they must be created
2280              before the linker maps input sections to output
2281              sections.  The linker does that before
2282              adjust_dynamic_symbol is called, and it is that
2283              function which decides whether anything needs to go
2284              into these sections.  */
2285           s->flags |= SEC_EXCLUDE;
2286           continue;
2287         }
2288 
2289       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2290 	continue;
2291 
2292       /* Allocate memory for the section contents.  We use bfd_zalloc
2293          here in case unused entries are not reclaimed before the
2294          section's contents are written out.  This should not happen,
2295          but this way if it does, we get a R_M32R_NONE reloc instead
2296          of garbage.  */
2297       s->contents = bfd_zalloc (dynobj, s->size);
2298       if (s->contents == NULL)
2299         return FALSE;
2300     }
2301 
2302   if (htab->root.dynamic_sections_created)
2303     {
2304       /* Add some entries to the .dynamic section.  We fill in the
2305 	 values later, in m32r_elf_finish_dynamic_sections, but we
2306 	 must add the entries now so that we get the correct size for
2307 	 the .dynamic section.  The DT_DEBUG entry is filled in by the
2308 	 dynamic linker and used by the debugger.  */
2309 #define add_dynamic_entry(TAG, VAL) \
2310   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2311 
2312      if (info->executable)
2313 	{
2314 	  if (! add_dynamic_entry (DT_DEBUG, 0))
2315 	    return FALSE;
2316 	}
2317 
2318       if (htab->splt->size != 0)
2319         {
2320           if (! add_dynamic_entry (DT_PLTGOT, 0)
2321               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2322               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2323               || ! add_dynamic_entry (DT_JMPREL, 0))
2324             return FALSE;
2325         }
2326 
2327       if (relocs)
2328         {
2329           if (! add_dynamic_entry (DT_RELA, 0)
2330               || ! add_dynamic_entry (DT_RELASZ, 0)
2331               || ! add_dynamic_entry (DT_RELAENT,
2332                                       sizeof (Elf32_External_Rela)))
2333             return FALSE;
2334 
2335           /* If any dynamic relocs apply to a read-only section,
2336              then we need a DT_TEXTREL entry.  */
2337           if ((info->flags & DF_TEXTREL) == 0)
2338             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2339                                     info);
2340 
2341           if ((info->flags & DF_TEXTREL) != 0)
2342             {
2343               if (! add_dynamic_entry (DT_TEXTREL, 0))
2344                 return FALSE;
2345             }
2346         }
2347     }
2348 #undef add_dynamic_entry
2349 
2350   return TRUE;
2351 }
2352 
2353 /* Relocate an M32R/D ELF section.
2354    There is some attempt to make this function usable for many architectures,
2355    both for RELA and REL type relocs, if only to serve as a learning tool.
2356 
2357    The RELOCATE_SECTION function is called by the new ELF backend linker
2358    to handle the relocations for a section.
2359 
2360    The relocs are always passed as Rela structures; if the section
2361    actually uses Rel structures, the r_addend field will always be
2362    zero.
2363 
2364    This function is responsible for adjust the section contents as
2365    necessary, and (if using Rela relocs and generating a
2366    relocatable output file) adjusting the reloc addend as
2367    necessary.
2368 
2369    This function does not have to worry about setting the reloc
2370    address or the reloc symbol index.
2371 
2372    LOCAL_SYMS is a pointer to the swapped in local symbols.
2373 
2374    LOCAL_SECTIONS is an array giving the section in the input file
2375    corresponding to the st_shndx field of each local symbol.
2376 
2377    The global hash table entry for the global symbols can be found
2378    via elf_sym_hashes (input_bfd).
2379 
2380    When generating relocatable output, this function must handle
2381    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2382    going to be the section symbol corresponding to the output
2383    section, which means that the addend must be adjusted
2384    accordingly.  */
2385 
2386 static bfd_boolean
2387 m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2388 			   struct bfd_link_info *info,
2389 			   bfd *input_bfd,
2390 			   asection *input_section,
2391 			   bfd_byte *contents,
2392 			   Elf_Internal_Rela *relocs,
2393 			   Elf_Internal_Sym *local_syms,
2394 			   asection **local_sections)
2395 {
2396   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2397   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2398   Elf_Internal_Rela *rel, *relend;
2399   /* Assume success.  */
2400   bfd_boolean ret = TRUE;
2401   struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2402   bfd *dynobj;
2403   bfd_vma *local_got_offsets;
2404   asection *sgot, *splt, *sreloc;
2405   bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2406 
2407   if (htab == NULL)
2408     return FALSE;
2409 
2410   dynobj = htab->root.dynobj;
2411   local_got_offsets = elf_local_got_offsets (input_bfd);
2412 
2413   sgot = htab->sgot;
2414   splt = htab->splt;
2415   sreloc = NULL;
2416 
2417   rel = relocs;
2418   relend = relocs + input_section->reloc_count;
2419   for (; rel < relend; rel++)
2420     {
2421       int r_type;
2422       reloc_howto_type *howto;
2423       unsigned long r_symndx;
2424       struct elf_link_hash_entry *h;
2425       /* We can't modify r_addend here as elf_link_input_bfd has an assert to
2426          ensure it's zero (we use REL relocs, not RELA).  Therefore this
2427          should be assigning zero to `addend', but for clarity we use
2428          `r_addend'.  */
2429       bfd_vma addend = rel->r_addend;
2430       bfd_vma offset = rel->r_offset;
2431       bfd_vma relocation;
2432       Elf_Internal_Sym *sym;
2433       asection *sec;
2434       const char *sym_name;
2435       bfd_reloc_status_type r;
2436       const char *errmsg = NULL;
2437       bfd_boolean use_rel = FALSE;
2438 
2439       h = NULL;
2440       r_type = ELF32_R_TYPE (rel->r_info);
2441       if (r_type < 0 || r_type >= (int) R_M32R_max)
2442 	{
2443 	  (*_bfd_error_handler) (_("%B: unknown relocation type %d"),
2444 				 input_bfd,
2445 				 (int) r_type);
2446 	  bfd_set_error (bfd_error_bad_value);
2447 	  ret = FALSE;
2448 	  continue;
2449 	}
2450 
2451       if (   r_type == R_M32R_GNU_VTENTRY
2452           || r_type == R_M32R_GNU_VTINHERIT
2453           || r_type == R_M32R_NONE
2454           || r_type == R_M32R_RELA_GNU_VTENTRY
2455           || r_type == R_M32R_RELA_GNU_VTINHERIT)
2456         continue;
2457 
2458       if (r_type <= R_M32R_GNU_VTENTRY)
2459         use_rel = TRUE;
2460 
2461       howto = m32r_elf_howto_table + r_type;
2462       r_symndx = ELF32_R_SYM (rel->r_info);
2463 
2464       sym = NULL;
2465       sec = NULL;
2466       h = NULL;
2467 
2468       if (r_symndx < symtab_hdr->sh_info)
2469 	{
2470 	  /* Local symbol.  */
2471 	  sym = local_syms + r_symndx;
2472 	  sec = local_sections[r_symndx];
2473 	  sym_name = "<local symbol>";
2474 
2475 	  if (!use_rel)
2476 	    {
2477 	      relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2478 	      addend = rel->r_addend;
2479 	    }
2480 	  else
2481 	    {
2482 	      relocation = (sec->output_section->vma
2483 			    + sec->output_offset
2484 			    + sym->st_value);
2485 	    }
2486 	}
2487       else
2488 	{
2489 	  /* External symbol.  */
2490 	  relocation = 0;
2491 
2492 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2493 	  while (h->root.type == bfd_link_hash_indirect
2494 		 || h->root.type == bfd_link_hash_warning)
2495 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
2496 	  sym_name = h->root.root.string;
2497 
2498 	  if (h->root.type == bfd_link_hash_defined
2499 	      || h->root.type == bfd_link_hash_defweak)
2500 	    {
2501 	      bfd_boolean dyn;
2502 	      sec = h->root.u.def.section;
2503 
2504 	      dyn = htab->root.dynamic_sections_created;
2505 	      sec = h->root.u.def.section;
2506 	      if (r_type == R_M32R_GOTPC24
2507 		  || (r_type == R_M32R_GOTPC_HI_ULO
2508 		      || r_type == R_M32R_GOTPC_HI_SLO
2509 		      || r_type == R_M32R_GOTPC_LO)
2510 		  || (r_type == R_M32R_26_PLTREL
2511 		      && h->plt.offset != (bfd_vma) -1)
2512 		  || ((r_type == R_M32R_GOT24
2513 		       || r_type == R_M32R_GOT16_HI_ULO
2514 		       || r_type == R_M32R_GOT16_HI_SLO
2515 		       || r_type == R_M32R_GOT16_LO)
2516 		      && WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
2517 							  info->shared, h)
2518 		      && (! info->shared
2519 			  || (! info->symbolic && h->dynindx != -1)
2520 			  || !h->def_regular))
2521 		  || (info->shared
2522 		      && ((! info->symbolic && h->dynindx != -1)
2523 			  || !h->def_regular)
2524 		      && (((r_type == R_M32R_16_RELA
2525 			    || r_type == R_M32R_32_RELA
2526 			    || r_type == R_M32R_24_RELA
2527 			    || r_type == R_M32R_HI16_ULO_RELA
2528 			    || r_type == R_M32R_HI16_SLO_RELA
2529 			    || r_type == R_M32R_LO16_RELA)
2530 			   && !h->forced_local)
2531 			  || r_type == R_M32R_REL32
2532 			  || r_type == R_M32R_10_PCREL_RELA
2533 			  || r_type == R_M32R_18_PCREL_RELA
2534 			  || r_type == R_M32R_26_PCREL_RELA)
2535 		      && ((input_section->flags & SEC_ALLOC) != 0
2536 			  /* DWARF will emit R_M32R_16(24,32) relocations
2537 			     in its sections against symbols defined
2538 			     externally in shared libraries.  We can't do
2539 			     anything with them here.  */
2540 			  || ((input_section->flags & SEC_DEBUGGING) != 0
2541 			      && h->def_dynamic))))
2542 		{
2543 		  /* In these cases, we don't need the relocation
2544 		     value.  We check specially because in some
2545 		     obscure cases sec->output_section will be NULL.  */
2546 		}
2547 	      else if (sec->output_section != NULL)
2548 		relocation = (h->root.u.def.value
2549 			      + sec->output_section->vma
2550 			      + sec->output_offset);
2551 	      else if (!info->relocatable
2552 		       && (_bfd_elf_section_offset (output_bfd, info,
2553 						    input_section,
2554 						    rel->r_offset)
2555 			   != (bfd_vma) -1))
2556 		{
2557 		  (*_bfd_error_handler)
2558 		    (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2559 		     input_bfd,
2560 		     input_section,
2561 		     (long) rel->r_offset,
2562 		     howto->name,
2563 		     h->root.root.string);
2564 		}
2565 	    }
2566 	  else if (h->root.type == bfd_link_hash_undefweak)
2567 	    ;
2568 	  else if (info->unresolved_syms_in_objects == RM_IGNORE
2569 		   && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2570 	    ;
2571 	  else if (!info->relocatable)
2572 	    {
2573 	      if (! ((*info->callbacks->undefined_symbol)
2574 		     (info, h->root.root.string, input_bfd,
2575 		      input_section, offset,
2576 		      (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2577 		       || ELF_ST_VISIBILITY (h->other)))))
2578 		return FALSE;
2579 	    }
2580 	}
2581 
2582       if (sec != NULL && discarded_section (sec))
2583 	RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2584 					 rel, 1, relend, howto, 0, contents);
2585 
2586       if (info->relocatable && !use_rel)
2587 	{
2588 	  /* This is a relocatable link.  We don't have to change
2589 	     anything, unless the reloc is against a section symbol,
2590 	     in which case we have to adjust according to where the
2591 	     section symbol winds up in the output section.  */
2592 	  if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2593 	    rel->r_addend += sec->output_offset;
2594 	  continue;
2595 	}
2596 
2597       if (info->relocatable && use_rel)
2598 	{
2599 	  /* This is a relocatable link.  We don't have to change
2600 	     anything, unless the reloc is against a section symbol,
2601 	     in which case we have to adjust according to where the
2602 	     section symbol winds up in the output section.  */
2603 	  if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2604 	    continue;
2605 
2606 	  addend += sec->output_offset;
2607 
2608 	  /* If partial_inplace, we need to store any additional addend
2609 	     back in the section.  */
2610 	  if (! howto->partial_inplace)
2611 	    continue;
2612 	  /* ??? Here is a nice place to call a special_function
2613 	     like handler.  */
2614 	  if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2615 	    r = _bfd_relocate_contents (howto, input_bfd,
2616 					addend, contents + offset);
2617 	  else
2618 	    {
2619 	      Elf_Internal_Rela *lorel;
2620 
2621 	      /* We allow an arbitrary number of HI16 relocs before the
2622 		 LO16 reloc.  This permits gcc to emit the HI and LO relocs
2623 		 itself.  */
2624 	      for (lorel = rel + 1;
2625 		   (lorel < relend
2626 		    && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2627 			|| ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2628 		   lorel++)
2629 		continue;
2630 	      if (lorel < relend
2631 		  && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2632 		{
2633 		  m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2634 					  contents, addend);
2635 		  r = bfd_reloc_ok;
2636 		}
2637 	      else
2638 		r = _bfd_relocate_contents (howto, input_bfd,
2639 					    addend, contents + offset);
2640 	    }
2641 	}
2642       else
2643 	{
2644 	  /* Sanity check the address.  */
2645 	  if (offset > high_address)
2646 	    {
2647 	      r = bfd_reloc_outofrange;
2648 	      goto check_reloc;
2649 	    }
2650 
2651 	  switch ((int) r_type)
2652 	    {
2653             case R_M32R_GOTOFF:
2654               /* Relocation is relative to the start of the global offset
2655                  table (for ld24 rx, #uimm24). eg access at label+addend
2656 
2657                  ld24 rx. #label@GOTOFF + addend
2658                  sub  rx, r12.  */
2659 
2660               BFD_ASSERT (sgot != NULL);
2661 
2662               relocation = -(relocation - sgot->output_section->vma);
2663               rel->r_addend = -rel->r_addend;
2664               break;
2665 
2666             case R_M32R_GOTOFF_HI_ULO:
2667             case R_M32R_GOTOFF_HI_SLO:
2668             case R_M32R_GOTOFF_LO:
2669 	      BFD_ASSERT (sgot != NULL);
2670 
2671 	      relocation -= sgot->output_section->vma;
2672 
2673 	      if ((r_type == R_M32R_GOTOFF_HI_SLO)
2674 		  && ((relocation + rel->r_addend) & 0x8000))
2675 		rel->r_addend += 0x10000;
2676 	      break;
2677 
2678             case R_M32R_GOTPC24:
2679               /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2680                  ld24 rx,#_GLOBAL_OFFSET_TABLE_
2681                */
2682              relocation = sgot->output_section->vma;
2683              break;
2684 
2685             case R_M32R_GOTPC_HI_ULO:
2686             case R_M32R_GOTPC_HI_SLO:
2687             case R_M32R_GOTPC_LO:
2688               {
2689                 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2690                    bl .+4
2691                    seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2692                    or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2693                    or
2694                    bl .+4
2695                    seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2696                    add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2697                  */
2698                 relocation = sgot->output_section->vma;
2699                 relocation -= (input_section->output_section->vma
2700                                + input_section->output_offset
2701                                + rel->r_offset);
2702                 if ((r_type == R_M32R_GOTPC_HI_SLO)
2703                      && ((relocation + rel->r_addend) & 0x8000))
2704                   rel->r_addend += 0x10000;
2705 
2706                 break;
2707               }
2708             case R_M32R_GOT16_HI_ULO:
2709             case R_M32R_GOT16_HI_SLO:
2710             case R_M32R_GOT16_LO:
2711               /* Fall through.  */
2712             case R_M32R_GOT24:
2713               /* Relocation is to the entry for this symbol in the global
2714                  offset table.  */
2715               BFD_ASSERT (sgot != NULL);
2716 
2717               if (h != NULL)
2718                 {
2719                   bfd_boolean dyn;
2720                   bfd_vma off;
2721 
2722                   off = h->got.offset;
2723                   BFD_ASSERT (off != (bfd_vma) -1);
2724 
2725                   dyn = htab->root.dynamic_sections_created;
2726                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2727                       || (info->shared
2728                           && (info->symbolic
2729                               || h->dynindx == -1
2730                               || h->forced_local)
2731                           && h->def_regular))
2732                     {
2733                       /* This is actually a static link, or it is a
2734                          -Bsymbolic link and the symbol is defined
2735                          locally, or the symbol was forced to be local
2736                          because of a version file.  We must initialize
2737                          this entry in the global offset table.  Since the
2738                          offset must always be a multiple of 4, we use the
2739                          least significant bit to record whether we have
2740                          initialized it already.
2741 
2742                          When doing a dynamic link, we create a .rela.got
2743                          relocation entry to initialize the value.  This
2744                          is done in the finish_dynamic_symbol routine.  */
2745                       if ((off & 1) != 0)
2746                         off &= ~1;
2747                       else
2748                         {
2749                           bfd_put_32 (output_bfd, relocation,
2750                                       sgot->contents + off);
2751                           h->got.offset |= 1;
2752                         }
2753                     }
2754 
2755                   relocation = sgot->output_offset + off;
2756                 }
2757               else
2758                 {
2759                   bfd_vma off;
2760                   bfd_byte *loc;
2761 
2762                   BFD_ASSERT (local_got_offsets != NULL
2763                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
2764 
2765                   off = local_got_offsets[r_symndx];
2766 
2767                   /* The offset must always be a multiple of 4.  We use
2768                      the least significant bit to record whether we have
2769                      already processed this entry.  */
2770                   if ((off & 1) != 0)
2771                     off &= ~1;
2772                   else
2773                     {
2774                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2775 
2776                       if (info->shared)
2777                         {
2778                           asection *srelgot;
2779                           Elf_Internal_Rela outrel;
2780 
2781                           /* We need to generate a R_M32R_RELATIVE reloc
2782                              for the dynamic linker.  */
2783                           srelgot = bfd_get_linker_section (dynobj,
2784 							    ".rela.got");
2785                           BFD_ASSERT (srelgot != NULL);
2786 
2787                           outrel.r_offset = (sgot->output_section->vma
2788                                              + sgot->output_offset
2789                                              + off);
2790                           outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2791                           outrel.r_addend = relocation;
2792                           loc = srelgot->contents;
2793                           loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2794                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2795                           ++srelgot->reloc_count;
2796                         }
2797 
2798                       local_got_offsets[r_symndx] |= 1;
2799                     }
2800 
2801                   relocation = sgot->output_offset + off;
2802                 }
2803               if ((r_type == R_M32R_GOT16_HI_SLO)
2804                   && ((relocation + rel->r_addend) & 0x8000))
2805                 rel->r_addend += 0x10000;
2806 
2807               break;
2808 
2809             case R_M32R_26_PLTREL:
2810               /* Relocation is to the entry for this symbol in the
2811                  procedure linkage table.  */
2812 
2813               /* The native assembler will generate a 26_PLTREL reloc
2814                  for a local symbol if you assemble a call from one
2815                  section to another when using -K pic. */
2816               if (h == NULL)
2817                 break;
2818 
2819               if (h->forced_local)
2820                 break;
2821 
2822               if (h->plt.offset == (bfd_vma) -1)
2823 		/* We didn't make a PLT entry for this symbol.  This
2824 		   happens when statically linking PIC code, or when
2825 		   using -Bsymbolic.  */
2826 		break;
2827 
2828               relocation = (splt->output_section->vma
2829                             + splt->output_offset
2830                             + h->plt.offset);
2831               break;
2832 
2833             case R_M32R_HI16_SLO_RELA:
2834 	      if ((relocation + rel->r_addend) & 0x8000)
2835 		rel->r_addend += 0x10000;
2836               /* Fall through.  */
2837 
2838             case R_M32R_16_RELA:
2839             case R_M32R_24_RELA:
2840             case R_M32R_32_RELA:
2841             case R_M32R_REL32:
2842 	    case R_M32R_10_PCREL_RELA:
2843             case R_M32R_18_PCREL_RELA:
2844             case R_M32R_26_PCREL_RELA:
2845             case R_M32R_HI16_ULO_RELA:
2846             case R_M32R_LO16_RELA:
2847               if (info->shared
2848                   && r_symndx != STN_UNDEF
2849                   && (input_section->flags & SEC_ALLOC) != 0
2850                   && ((   r_type != R_M32R_10_PCREL_RELA
2851                        && r_type != R_M32R_18_PCREL_RELA
2852                        && r_type != R_M32R_26_PCREL_RELA
2853                        && r_type != R_M32R_REL32)
2854                       || (h != NULL
2855                           && h->dynindx != -1
2856                           && (! info->symbolic
2857                               || !h->def_regular))))
2858                 {
2859                   Elf_Internal_Rela outrel;
2860                   bfd_boolean skip, relocate;
2861                   bfd_byte *loc;
2862 
2863                   /* When generating a shared object, these relocations
2864                      are copied into the output file to be resolved at run
2865                      time.  */
2866                   if (sreloc == NULL)
2867                     {
2868 		      sreloc = _bfd_elf_get_dynamic_reloc_section
2869 			(input_bfd, input_section, /*rela?*/ TRUE);
2870 		      if (sreloc == NULL)
2871 			return FALSE;
2872                     }
2873 
2874                   skip = FALSE;
2875                   relocate = FALSE;
2876 
2877                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2878                                                              info,
2879                                                              input_section,
2880                                                              rel->r_offset);
2881                   if (outrel.r_offset == (bfd_vma) -1)
2882                     skip = TRUE;
2883                   else if (outrel.r_offset == (bfd_vma) -2)
2884                     skip = relocate = TRUE;
2885                   outrel.r_offset += (input_section->output_section->vma
2886                                       + input_section->output_offset);
2887 
2888                   if (skip)
2889                     memset (&outrel, 0, sizeof outrel);
2890                   else if (   r_type == R_M32R_10_PCREL_RELA
2891                            || r_type == R_M32R_18_PCREL_RELA
2892                            || r_type == R_M32R_26_PCREL_RELA
2893                            || r_type == R_M32R_REL32)
2894                     {
2895                       BFD_ASSERT (h != NULL && h->dynindx != -1);
2896                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2897                       outrel.r_addend = rel->r_addend;
2898                     }
2899                   else
2900                     {
2901                     /* h->dynindx may be -1 if this symbol was marked to
2902                        become local.  */
2903                     if (h == NULL
2904                         || ((info->symbolic || h->dynindx == -1)
2905                              && h->def_regular))
2906                       {
2907                         relocate = TRUE;
2908                         outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2909                         outrel.r_addend = relocation + rel->r_addend;
2910                       }
2911                     else
2912                       {
2913                         BFD_ASSERT (h->dynindx != -1);
2914                         outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2915                         outrel.r_addend = relocation + rel->r_addend;
2916                       }
2917                     }
2918 
2919                   loc = sreloc->contents;
2920                   loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2921                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2922                   ++sreloc->reloc_count;
2923 
2924                   /* If this reloc is against an external symbol, we do
2925                      not want to fiddle with the addend.  Otherwise, we
2926                      need to include the symbol value so that it becomes
2927                      an addend for the dynamic reloc.  */
2928                   if (! relocate)
2929                     continue;
2930 		  break;
2931                 }
2932 	      else if (r_type != R_M32R_10_PCREL_RELA)
2933 		break;
2934 	      /* Fall through.  */
2935 
2936 	    case (int) R_M32R_10_PCREL :
2937 	      r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2938 					      contents, offset,
2939 					      sec, relocation, addend);
2940               goto check_reloc;
2941 
2942 	    case (int) R_M32R_HI16_SLO :
2943 	    case (int) R_M32R_HI16_ULO :
2944 	      {
2945 		Elf_Internal_Rela *lorel;
2946 
2947 		/* We allow an arbitrary number of HI16 relocs before the
2948 		   LO16 reloc.  This permits gcc to emit the HI and LO relocs
2949 		   itself.  */
2950 		for (lorel = rel + 1;
2951 		     (lorel < relend
2952 		      && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2953 			  || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2954 		     lorel++)
2955 		  continue;
2956 		if (lorel < relend
2957 		    && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2958 		  {
2959 		    m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2960 					    contents, relocation + addend);
2961 		    r = bfd_reloc_ok;
2962 		  }
2963 		else
2964 		  r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2965 						contents, offset,
2966 						relocation, addend);
2967 	      }
2968 
2969               goto check_reloc;
2970 
2971             case (int) R_M32R_SDA16_RELA:
2972 	    case (int) R_M32R_SDA16 :
2973 	      {
2974 		const char *name;
2975 
2976 		BFD_ASSERT (sec != NULL);
2977 		name = bfd_get_section_name (sec->owner, sec);
2978 
2979 		if (   strcmp (name, ".sdata") == 0
2980 		    || strcmp (name, ".sbss") == 0
2981 		    || strcmp (name, ".scommon") == 0)
2982 		  {
2983 		    bfd_vma sda_base;
2984 		    bfd *out_bfd = sec->output_section->owner;
2985 
2986 		    r = m32r_elf_final_sda_base (out_bfd, info,
2987 						 &errmsg,
2988 						 &sda_base);
2989 		    if (r != bfd_reloc_ok)
2990 		      {
2991 			ret = FALSE;
2992 			goto check_reloc;
2993 		      }
2994 
2995 		    /* At this point `relocation' contains the object's
2996 		       address.  */
2997 		    relocation -= sda_base;
2998 		    /* Now it contains the offset from _SDA_BASE_.  */
2999 		  }
3000 		else
3001 		  {
3002 		    (*_bfd_error_handler)
3003 		      (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3004 		       input_bfd,
3005 		       sec,
3006 		       sym_name,
3007 		       m32r_elf_howto_table[(int) r_type].name);
3008 		    /*bfd_set_error (bfd_error_bad_value); ??? why? */
3009 		    ret = FALSE;
3010 		    continue;
3011 		  }
3012 	      }
3013               /* Fall through.  */
3014 
3015 	    default : /* OLD_M32R_RELOC */
3016 
3017 	      r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3018 					    contents, offset,
3019 					    relocation, addend);
3020 	      goto check_reloc;
3021 	    }
3022 
3023           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3024                                         contents, rel->r_offset,
3025                                         relocation, rel->r_addend);
3026 
3027 	}
3028 
3029     check_reloc:
3030 
3031       if (r != bfd_reloc_ok)
3032 	{
3033 	  /* FIXME: This should be generic enough to go in a utility.  */
3034 	  const char *name;
3035 
3036 	  if (h != NULL)
3037 	    name = h->root.root.string;
3038 	  else
3039 	    {
3040 	      name = (bfd_elf_string_from_elf_section
3041 		      (input_bfd, symtab_hdr->sh_link, sym->st_name));
3042 	      if (name == NULL || *name == '\0')
3043 		name = bfd_section_name (input_bfd, sec);
3044 	    }
3045 
3046 	  if (errmsg != NULL)
3047 	    goto common_error;
3048 
3049 	  switch (r)
3050 	    {
3051 	    case bfd_reloc_overflow:
3052 	      if (! ((*info->callbacks->reloc_overflow)
3053 		     (info, (h ? &h->root : NULL), name, howto->name,
3054 		      (bfd_vma) 0, input_bfd, input_section, offset)))
3055 		return FALSE;
3056 	      break;
3057 
3058 	    case bfd_reloc_undefined:
3059 	      if (! ((*info->callbacks->undefined_symbol)
3060 		     (info, name, input_bfd, input_section,
3061 		      offset, TRUE)))
3062 		return FALSE;
3063 	      break;
3064 
3065 	    case bfd_reloc_outofrange:
3066 	      errmsg = _("internal error: out of range error");
3067 	      goto common_error;
3068 
3069 	    case bfd_reloc_notsupported:
3070 	      errmsg = _("internal error: unsupported relocation error");
3071 	      goto common_error;
3072 
3073 	    case bfd_reloc_dangerous:
3074 	      errmsg = _("internal error: dangerous error");
3075 	      goto common_error;
3076 
3077 	    default:
3078 	      errmsg = _("internal error: unknown error");
3079 	      /* fall through */
3080 
3081 	    common_error:
3082 	      if (!((*info->callbacks->warning)
3083 		    (info, errmsg, name, input_bfd, input_section,
3084 		     offset)))
3085 		return FALSE;
3086 	      break;
3087 	    }
3088 	}
3089     }
3090 
3091   return ret;
3092 }
3093 
3094 /* Finish up dynamic symbol handling.  We set the contents of various
3095    dynamic sections here.  */
3096 
3097 static bfd_boolean
3098 m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3099 				struct bfd_link_info *info,
3100 				struct elf_link_hash_entry *h,
3101 				Elf_Internal_Sym *sym)
3102 {
3103   struct elf_m32r_link_hash_table *htab;
3104   bfd_byte *loc;
3105 
3106 #ifdef DEBUG_PIC
3107   printf ("m32r_elf_finish_dynamic_symbol()\n");
3108 #endif
3109 
3110   htab = m32r_elf_hash_table (info);
3111   if (htab == NULL)
3112     return FALSE;
3113 
3114   if (h->plt.offset != (bfd_vma) -1)
3115     {
3116       asection *splt;
3117       asection *sgot;
3118       asection *srela;
3119 
3120       bfd_vma plt_index;
3121       bfd_vma got_offset;
3122       Elf_Internal_Rela rela;
3123 
3124       /* This symbol has an entry in the procedure linkage table.  Set
3125          it up.  */
3126 
3127       BFD_ASSERT (h->dynindx != -1);
3128 
3129       splt = htab->splt;
3130       sgot = htab->sgotplt;
3131       srela = htab->srelplt;
3132       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3133 
3134       /* Get the index in the procedure linkage table which
3135          corresponds to this symbol.  This is the index of this symbol
3136          in all the symbols for which we are making plt entries.  The
3137          first entry in the procedure linkage table is reserved.  */
3138       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3139 
3140       /* Get the offset into the .got table of the entry that
3141         corresponds to this function.  Each .got entry is 4 bytes.
3142         The first three are reserved.  */
3143       got_offset = (plt_index + 3) * 4;
3144 
3145       /* Fill in the entry in the procedure linkage table.  */
3146       if (! info->shared)
3147         {
3148           bfd_put_32 (output_bfd,
3149               (PLT_ENTRY_WORD0b
3150                + (((sgot->output_section->vma
3151                     + sgot->output_offset
3152                     + got_offset) >> 16) & 0xffff)),
3153               splt->contents + h->plt.offset);
3154           bfd_put_32 (output_bfd,
3155               (PLT_ENTRY_WORD1b
3156                + ((sgot->output_section->vma
3157                    + sgot->output_offset
3158                    + got_offset) & 0xffff)),
3159               splt->contents + h->plt.offset + 4);
3160           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3161               splt->contents + h->plt.offset + 8);
3162           bfd_put_32 (output_bfd,
3163               (PLT_ENTRY_WORD3
3164                + plt_index * sizeof (Elf32_External_Rela)),
3165               splt->contents + h->plt.offset + 12);
3166           bfd_put_32 (output_bfd,
3167               (PLT_ENTRY_WORD4
3168                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3169               splt->contents + h->plt.offset + 16);
3170         }
3171       else
3172         {
3173           bfd_put_32 (output_bfd,
3174               PLT_ENTRY_WORD0 + got_offset,
3175               splt->contents + h->plt.offset);
3176           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3177               splt->contents + h->plt.offset + 4);
3178           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3179               splt->contents + h->plt.offset + 8);
3180           bfd_put_32 (output_bfd,
3181               (PLT_ENTRY_WORD3
3182                + plt_index * sizeof (Elf32_External_Rela)),
3183               splt->contents + h->plt.offset + 12);
3184           bfd_put_32 (output_bfd,
3185               (PLT_ENTRY_WORD4
3186                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3187               splt->contents + h->plt.offset + 16);
3188         }
3189 
3190       /* Fill in the entry in the global offset table.  */
3191       bfd_put_32 (output_bfd,
3192                   (splt->output_section->vma
3193                    + splt->output_offset
3194                    + h->plt.offset
3195                    + 12), /* same offset */
3196                   sgot->contents + got_offset);
3197 
3198       /* Fill in the entry in the .rela.plt section.  */
3199       rela.r_offset = (sgot->output_section->vma
3200                        + sgot->output_offset
3201                        + got_offset);
3202       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3203       rela.r_addend = 0;
3204       loc = srela->contents;
3205       loc += plt_index * sizeof (Elf32_External_Rela);
3206       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3207 
3208       if (!h->def_regular)
3209         {
3210           /* Mark the symbol as undefined, rather than as defined in
3211              the .plt section.  Leave the value alone.  */
3212           sym->st_shndx = SHN_UNDEF;
3213         }
3214     }
3215 
3216   if (h->got.offset != (bfd_vma) -1)
3217     {
3218       asection *sgot;
3219       asection *srela;
3220       Elf_Internal_Rela rela;
3221 
3222       /* This symbol has an entry in the global offset table.  Set it
3223          up.  */
3224 
3225       sgot = htab->sgot;
3226       srela = htab->srelgot;
3227       BFD_ASSERT (sgot != NULL && srela != NULL);
3228 
3229       rela.r_offset = (sgot->output_section->vma
3230                        + sgot->output_offset
3231                        + (h->got.offset &~ 1));
3232 
3233       /* If this is a -Bsymbolic link, and the symbol is defined
3234          locally, we just want to emit a RELATIVE reloc.  Likewise if
3235          the symbol was forced to be local because of a version file.
3236          The entry in the global offset table will already have been
3237          initialized in the relocate_section function.  */
3238       if (info->shared
3239           && (info->symbolic
3240 	      || h->dynindx == -1
3241 	      || h->forced_local)
3242           && h->def_regular)
3243         {
3244           rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3245           rela.r_addend = (h->root.u.def.value
3246                            + h->root.u.def.section->output_section->vma
3247                            + h->root.u.def.section->output_offset);
3248         }
3249       else
3250         {
3251 	  BFD_ASSERT ((h->got.offset & 1) == 0);
3252           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3253           rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3254           rela.r_addend = 0;
3255         }
3256 
3257       loc = srela->contents;
3258       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3259       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3260       ++srela->reloc_count;
3261     }
3262 
3263   if (h->needs_copy)
3264     {
3265       asection *s;
3266       Elf_Internal_Rela rela;
3267 
3268       /* This symbols needs a copy reloc.  Set it up.  */
3269 
3270       BFD_ASSERT (h->dynindx != -1
3271                   && (h->root.type == bfd_link_hash_defined
3272                       || h->root.type == bfd_link_hash_defweak));
3273 
3274       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
3275       BFD_ASSERT (s != NULL);
3276 
3277       rela.r_offset = (h->root.u.def.value
3278                        + h->root.u.def.section->output_section->vma
3279                        + h->root.u.def.section->output_offset);
3280       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3281       rela.r_addend = 0;
3282       loc = s->contents;
3283       loc += s->reloc_count * sizeof (Elf32_External_Rela);
3284       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3285       ++s->reloc_count;
3286     }
3287 
3288   /* Mark some specially defined symbols as absolute.  */
3289   if (h == htab->root.hdynamic || h == htab->root.hgot)
3290     sym->st_shndx = SHN_ABS;
3291 
3292   return TRUE;
3293 }
3294 
3295 
3296 /* Finish up the dynamic sections.  */
3297 
3298 static bfd_boolean
3299 m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3300 				  struct bfd_link_info *info)
3301 {
3302   struct elf_m32r_link_hash_table *htab;
3303   bfd *dynobj;
3304   asection *sdyn;
3305   asection *sgot;
3306 
3307 #ifdef DEBUG_PIC
3308   printf ("m32r_elf_finish_dynamic_sections()\n");
3309 #endif
3310 
3311   htab = m32r_elf_hash_table (info);
3312   if (htab == NULL)
3313     return FALSE;
3314 
3315   dynobj = htab->root.dynobj;
3316 
3317   sgot = htab->sgotplt;
3318   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
3319 
3320   if (htab->root.dynamic_sections_created)
3321     {
3322       asection *splt;
3323       Elf32_External_Dyn *dyncon, *dynconend;
3324 
3325       BFD_ASSERT (sgot != NULL && sdyn != NULL);
3326 
3327       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3328       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3329 
3330       for (; dyncon < dynconend; dyncon++)
3331         {
3332           Elf_Internal_Dyn dyn;
3333           asection *s;
3334 
3335           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3336 
3337           switch (dyn.d_tag)
3338             {
3339             default:
3340               break;
3341 
3342             case DT_PLTGOT:
3343               s = htab->sgot->output_section;
3344               goto get_vma;
3345             case DT_JMPREL:
3346               s = htab->srelplt->output_section;
3347             get_vma:
3348               BFD_ASSERT (s != NULL);
3349               dyn.d_un.d_ptr = s->vma;
3350               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3351               break;
3352 
3353             case DT_PLTRELSZ:
3354               s = htab->srelplt->output_section;
3355               BFD_ASSERT (s != NULL);
3356 	      dyn.d_un.d_val = s->size;
3357               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3358               break;
3359 
3360             case DT_RELASZ:
3361               /* My reading of the SVR4 ABI indicates that the
3362                  procedure linkage table relocs (DT_JMPREL) should be
3363                  included in the overall relocs (DT_RELA).  This is
3364                  what Solaris does.  However, UnixWare can not handle
3365                  that case.  Therefore, we override the DT_RELASZ entry
3366                  here to make it not include the JMPREL relocs.  Since
3367                  the linker script arranges for .rela.plt to follow all
3368                  other relocation sections, we don't have to worry
3369                  about changing the DT_RELA entry.  */
3370               if (htab->srelplt != NULL)
3371                 {
3372                   s = htab->srelplt->output_section;
3373 		  dyn.d_un.d_val -= s->size;
3374                 }
3375               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3376               break;
3377             }
3378         }
3379 
3380       /* Fill in the first entry in the procedure linkage table.  */
3381       splt = htab->splt;
3382       if (splt && splt->size > 0)
3383         {
3384           if (info->shared)
3385             {
3386               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3387               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3388               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3389               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3390               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3391             }
3392           else
3393             {
3394               unsigned long addr;
3395               /* addr = .got + 4 */
3396               addr = sgot->output_section->vma + sgot->output_offset + 4;
3397               bfd_put_32 (output_bfd,
3398 			  PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3399 			  splt->contents);
3400               bfd_put_32 (output_bfd,
3401 			  PLT0_ENTRY_WORD1 | (addr & 0xffff),
3402 			  splt->contents + 4);
3403               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3404               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3405               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3406             }
3407 
3408           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3409             PLT_ENTRY_SIZE;
3410         }
3411     }
3412 
3413   /* Fill in the first three entries in the global offset table.  */
3414   if (sgot && sgot->size > 0)
3415     {
3416       if (sdyn == NULL)
3417         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3418       else
3419         bfd_put_32 (output_bfd,
3420                     sdyn->output_section->vma + sdyn->output_offset,
3421                     sgot->contents);
3422       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3423       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3424 
3425       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3426     }
3427 
3428   return TRUE;
3429 }
3430 
3431 
3432 /* Set the right machine number.  */
3433 
3434 static bfd_boolean
3435 m32r_elf_object_p (bfd *abfd)
3436 {
3437   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3438     {
3439     default:
3440     case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3441     case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3442     case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3443     }
3444   return TRUE;
3445 }
3446 
3447 /* Store the machine number in the flags field.  */
3448 
3449 static void
3450 m32r_elf_final_write_processing (bfd *abfd,
3451 				 bfd_boolean linker ATTRIBUTE_UNUSED)
3452 {
3453   unsigned long val;
3454 
3455   switch (bfd_get_mach (abfd))
3456     {
3457     default:
3458     case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3459     case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3460     case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3461     }
3462 
3463   elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3464   elf_elfheader (abfd)->e_flags |= val;
3465 }
3466 
3467 /* Function to keep M32R specific file flags.  */
3468 
3469 static bfd_boolean
3470 m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3471 {
3472   BFD_ASSERT (!elf_flags_init (abfd)
3473 	      || elf_elfheader (abfd)->e_flags == flags);
3474 
3475   elf_elfheader (abfd)->e_flags = flags;
3476   elf_flags_init (abfd) = TRUE;
3477   return TRUE;
3478 }
3479 
3480 /* Merge backend specific data from an object file to the output
3481    object file when linking.  */
3482 
3483 static bfd_boolean
3484 m32r_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3485 {
3486   flagword out_flags;
3487   flagword in_flags;
3488 
3489   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3490       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3491     return TRUE;
3492 
3493   in_flags  = elf_elfheader (ibfd)->e_flags;
3494   out_flags = elf_elfheader (obfd)->e_flags;
3495 
3496   if (! elf_flags_init (obfd))
3497     {
3498       /* If the input is the default architecture then do not
3499 	 bother setting the flags for the output architecture,
3500 	 instead allow future merges to do this.  If no future
3501 	 merges ever set these flags then they will retain their
3502 	 unitialised values, which surprise surprise, correspond
3503 	 to the default values.  */
3504       if (bfd_get_arch_info (ibfd)->the_default)
3505 	return TRUE;
3506 
3507       elf_flags_init (obfd) = TRUE;
3508       elf_elfheader (obfd)->e_flags = in_flags;
3509 
3510       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3511 	  && bfd_get_arch_info (obfd)->the_default)
3512 	return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3513 				  bfd_get_mach (ibfd));
3514 
3515       return TRUE;
3516     }
3517 
3518   /* Check flag compatibility.  */
3519   if (in_flags == out_flags)
3520     return TRUE;
3521 
3522   if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3523     {
3524       if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3525           || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3526           || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3527 	{
3528 	  (*_bfd_error_handler)
3529 	    (_("%B: Instruction set mismatch with previous modules"), ibfd);
3530 
3531 	  bfd_set_error (bfd_error_bad_value);
3532 	  return FALSE;
3533 	}
3534     }
3535 
3536   return TRUE;
3537 }
3538 
3539 /* Display the flags field.  */
3540 
3541 static bfd_boolean
3542 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3543 {
3544   FILE * file = (FILE *) ptr;
3545 
3546   BFD_ASSERT (abfd != NULL && ptr != NULL);
3547 
3548   _bfd_elf_print_private_bfd_data (abfd, ptr);
3549 
3550   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3551 
3552   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3553     {
3554     default:
3555     case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3556     case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3557     case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3558     }
3559 
3560   fputc ('\n', file);
3561 
3562   return TRUE;
3563 }
3564 
3565 static asection *
3566 m32r_elf_gc_mark_hook (asection *sec,
3567 		       struct bfd_link_info *info,
3568 		       Elf_Internal_Rela *rel,
3569 		       struct elf_link_hash_entry *h,
3570 		       Elf_Internal_Sym *sym)
3571 {
3572   if (h != NULL)
3573     switch (ELF32_R_TYPE (rel->r_info))
3574       {
3575       case R_M32R_GNU_VTINHERIT:
3576       case R_M32R_GNU_VTENTRY:
3577       case R_M32R_RELA_GNU_VTINHERIT:
3578       case R_M32R_RELA_GNU_VTENTRY:
3579 	return NULL;
3580       }
3581 
3582   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3583 }
3584 
3585 static bfd_boolean
3586 m32r_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3587 			struct bfd_link_info *info ATTRIBUTE_UNUSED,
3588 			asection *sec ATTRIBUTE_UNUSED,
3589 			const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3590 {
3591   /* Update the got entry reference counts for the section being removed.  */
3592   Elf_Internal_Shdr *symtab_hdr;
3593   struct elf_link_hash_entry **sym_hashes;
3594   bfd_signed_vma *local_got_refcounts;
3595   const Elf_Internal_Rela *rel, *relend;
3596 
3597   if (info->relocatable)
3598     return TRUE;
3599 
3600   elf_section_data (sec)->local_dynrel = NULL;
3601 
3602   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3603   sym_hashes = elf_sym_hashes (abfd);
3604   local_got_refcounts = elf_local_got_refcounts (abfd);
3605 
3606   relend = relocs + sec->reloc_count;
3607   for (rel = relocs; rel < relend; rel++)
3608     {
3609       unsigned long r_symndx;
3610       struct elf_link_hash_entry *h = NULL;
3611 
3612       r_symndx = ELF32_R_SYM (rel->r_info);
3613       if (r_symndx >= symtab_hdr->sh_info)
3614 	{
3615 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3616 	  while (h->root.type == bfd_link_hash_indirect
3617 		 || h->root.type == bfd_link_hash_warning)
3618 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
3619 	}
3620 
3621       switch (ELF32_R_TYPE (rel->r_info))
3622 	{
3623 	case R_M32R_GOT16_HI_ULO:
3624 	case R_M32R_GOT16_HI_SLO:
3625 	case R_M32R_GOT16_LO:
3626 	case R_M32R_GOTOFF:
3627 	case R_M32R_GOTOFF_HI_ULO:
3628 	case R_M32R_GOTOFF_HI_SLO:
3629 	case R_M32R_GOTOFF_LO:
3630 	case R_M32R_GOT24:
3631 	case R_M32R_GOTPC_HI_ULO:
3632 	case R_M32R_GOTPC_HI_SLO:
3633 	case R_M32R_GOTPC_LO:
3634 	case R_M32R_GOTPC24:
3635 	  if (h != NULL)
3636 	    {
3637 	      if (h->got.refcount > 0)
3638 		h->got.refcount--;
3639 	    }
3640 	  else
3641 	    {
3642 	      if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3643 		local_got_refcounts[r_symndx]--;
3644 	    }
3645 	  break;
3646 
3647 	case R_M32R_16_RELA:
3648 	case R_M32R_24_RELA:
3649 	case R_M32R_32_RELA:
3650 	case R_M32R_REL32:
3651 	case R_M32R_HI16_ULO_RELA:
3652 	case R_M32R_HI16_SLO_RELA:
3653 	case R_M32R_LO16_RELA:
3654 	case R_M32R_SDA16_RELA:
3655 	case R_M32R_10_PCREL_RELA:
3656 	case R_M32R_18_PCREL_RELA:
3657 	case R_M32R_26_PCREL_RELA:
3658 	  if (h != NULL)
3659 	    {
3660 	      struct elf_m32r_link_hash_entry *eh;
3661 	      struct elf_m32r_dyn_relocs **pp;
3662 	      struct elf_m32r_dyn_relocs *p;
3663 
3664 	      if (!info->shared && h->plt.refcount > 0)
3665 		h->plt.refcount -= 1;
3666 
3667 	      eh = (struct elf_m32r_link_hash_entry *) h;
3668 
3669 	      for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3670 		if (p->sec == sec)
3671 		  {
3672 		    if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3673 			|| ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3674 			|| ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3675 			|| ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3676 		      p->pc_count -= 1;
3677 		    p->count -= 1;
3678 		    if (p->count == 0)
3679 		      *pp = p->next;
3680 		    break;
3681 		  }
3682 	    }
3683 	  break;
3684 
3685 	case R_M32R_26_PLTREL:
3686 	  if (h != NULL)
3687 	    {
3688 	      if (h->plt.refcount > 0)
3689 		h->plt.refcount--;
3690 	    }
3691 	  break;
3692 
3693 	default:
3694 	  break;
3695 	}
3696     }
3697 
3698   return TRUE;
3699 }
3700 
3701 /* Look through the relocs for a section during the first phase.
3702    Since we don't do .gots or .plts, we just need to consider the
3703    virtual table relocs for gc.  */
3704 
3705 static bfd_boolean
3706 m32r_elf_check_relocs (bfd *abfd,
3707 		       struct bfd_link_info *info,
3708 		       asection *sec,
3709 		       const Elf_Internal_Rela *relocs)
3710 {
3711   Elf_Internal_Shdr *symtab_hdr;
3712   struct elf_link_hash_entry **sym_hashes;
3713   const Elf_Internal_Rela *rel;
3714   const Elf_Internal_Rela *rel_end;
3715   struct elf_m32r_link_hash_table *htab;
3716   bfd *dynobj;
3717   asection *sreloc;
3718 
3719   if (info->relocatable)
3720     return TRUE;
3721 
3722   sreloc = NULL;
3723   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3724   sym_hashes = elf_sym_hashes (abfd);
3725 
3726   htab = m32r_elf_hash_table (info);
3727   if (htab == NULL)
3728     return FALSE;
3729 
3730   dynobj = htab->root.dynobj;
3731 
3732   rel_end = relocs + sec->reloc_count;
3733   for (rel = relocs; rel < rel_end; rel++)
3734     {
3735       int r_type;
3736       struct elf_link_hash_entry *h;
3737       unsigned long r_symndx;
3738 
3739       r_symndx = ELF32_R_SYM (rel->r_info);
3740       r_type = ELF32_R_TYPE (rel->r_info);
3741       if (r_symndx < symtab_hdr->sh_info)
3742         h = NULL;
3743       else
3744 	{
3745 	  h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3746 	  while (h->root.type == bfd_link_hash_indirect
3747 		 || h->root.type == bfd_link_hash_warning)
3748 	    h = (struct elf_link_hash_entry *) h->root.u.i.link;
3749 
3750 	  /* PR15323, ref flags aren't set for references in the same
3751 	     object.  */
3752 	  h->root.non_ir_ref = 1;
3753 	}
3754 
3755       /* Some relocs require a global offset table.  */
3756       if (htab->sgot == NULL)
3757         {
3758           switch (r_type)
3759             {
3760             case R_M32R_GOT16_HI_ULO:
3761             case R_M32R_GOT16_HI_SLO:
3762             case R_M32R_GOTOFF:
3763             case R_M32R_GOTOFF_HI_ULO:
3764             case R_M32R_GOTOFF_HI_SLO:
3765             case R_M32R_GOTOFF_LO:
3766             case R_M32R_GOT16_LO:
3767             case R_M32R_GOTPC24:
3768             case R_M32R_GOTPC_HI_ULO:
3769             case R_M32R_GOTPC_HI_SLO:
3770             case R_M32R_GOTPC_LO:
3771             case R_M32R_GOT24:
3772               if (dynobj == NULL)
3773                 htab->root.dynobj = dynobj = abfd;
3774               if (! create_got_section (dynobj, info))
3775                 return FALSE;
3776               break;
3777 
3778             default:
3779               break;
3780           }
3781         }
3782 
3783       switch (r_type)
3784         {
3785 	case R_M32R_GOT16_HI_ULO:
3786 	case R_M32R_GOT16_HI_SLO:
3787 	case R_M32R_GOT16_LO:
3788         case R_M32R_GOT24:
3789 
3790           if (h != NULL)
3791             h->got.refcount += 1;
3792           else
3793             {
3794               bfd_signed_vma *local_got_refcounts;
3795 
3796               /* This is a global offset table entry for a local
3797                  symbol.  */
3798               local_got_refcounts = elf_local_got_refcounts (abfd);
3799               if (local_got_refcounts == NULL)
3800                 {
3801                   bfd_size_type size;
3802 
3803                   size = symtab_hdr->sh_info;
3804                   size *= sizeof (bfd_signed_vma);
3805                   local_got_refcounts = bfd_zalloc (abfd, size);
3806                   if (local_got_refcounts == NULL)
3807                     return FALSE;
3808                   elf_local_got_refcounts (abfd) = local_got_refcounts;
3809                 }
3810               local_got_refcounts[r_symndx] += 1;
3811             }
3812           break;
3813 
3814         case R_M32R_26_PLTREL:
3815           /* This symbol requires a procedure linkage table entry.  We
3816              actually build the entry in adjust_dynamic_symbol,
3817              because this might be a case of linking PIC code without
3818              linking in any dynamic objects, in which case we don't
3819              need to generate a procedure linkage table after all.  */
3820 
3821 	  /* If this is a local symbol, we resolve it directly without
3822 	     creating a procedure linkage table entry.  */
3823           if (h == NULL)
3824             continue;
3825 
3826           if (h->forced_local)
3827             break;
3828 
3829           h->needs_plt = 1;
3830 	  h->plt.refcount += 1;
3831           break;
3832 
3833         case R_M32R_16_RELA:
3834         case R_M32R_24_RELA:
3835         case R_M32R_32_RELA:
3836         case R_M32R_REL32:
3837         case R_M32R_HI16_ULO_RELA:
3838         case R_M32R_HI16_SLO_RELA:
3839         case R_M32R_LO16_RELA:
3840         case R_M32R_SDA16_RELA:
3841 	case R_M32R_10_PCREL_RELA:
3842         case R_M32R_18_PCREL_RELA:
3843         case R_M32R_26_PCREL_RELA:
3844 
3845           if (h != NULL && !info->shared)
3846             {
3847               h->non_got_ref = 1;
3848               h->plt.refcount += 1;
3849             }
3850 
3851           /* If we are creating a shared library, and this is a reloc
3852              against a global symbol, or a non PC relative reloc
3853              against a local symbol, then we need to copy the reloc
3854              into the shared library.  However, if we are linking with
3855              -Bsymbolic, we do not need to copy a reloc against a
3856              global symbol which is defined in an object we are
3857              including in the link (i.e., DEF_REGULAR is set).  At
3858              this point we have not seen all the input files, so it is
3859              possible that DEF_REGULAR is not set now but will be set
3860              later (it is never cleared).  We account for that
3861              possibility below by storing information in the
3862              dyn_relocs field of the hash table entry. A similar
3863              situation occurs when creating shared libraries and symbol
3864              visibility changes render the symbol local.
3865 
3866              If on the other hand, we are creating an executable, we
3867              may need to keep relocations for symbols satisfied by a
3868              dynamic library if we manage to avoid copy relocs for the
3869              symbol.  */
3870           if ((info->shared
3871                && (sec->flags & SEC_ALLOC) != 0
3872 	       && ((   r_type != R_M32R_26_PCREL_RELA
3873                     && r_type != R_M32R_18_PCREL_RELA
3874                     && r_type != R_M32R_10_PCREL_RELA
3875                     && r_type != R_M32R_REL32)
3876 	           || (h != NULL
3877 		       && (! info->symbolic
3878 		           || h->root.type == bfd_link_hash_defweak
3879 		           || !h->def_regular))))
3880               || (!info->shared
3881                   && (sec->flags & SEC_ALLOC) != 0
3882                   && h != NULL
3883                   && (h->root.type == bfd_link_hash_defweak
3884                       || !h->def_regular)))
3885             {
3886               struct elf_m32r_dyn_relocs *p;
3887               struct elf_m32r_dyn_relocs **head;
3888 
3889               if (dynobj == NULL)
3890                 htab->root.dynobj = dynobj = abfd;
3891 
3892               /* When creating a shared object, we must copy these
3893                  relocs into the output file.  We create a reloc
3894                  section in dynobj and make room for the reloc.  */
3895               if (sreloc == NULL)
3896                 {
3897 		  sreloc = _bfd_elf_make_dynamic_reloc_section
3898 		    (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3899 
3900 		  if (sreloc == NULL)
3901 		    return FALSE;
3902                 }
3903 
3904               /* If this is a global symbol, we count the number of
3905                  relocations we need for this symbol.  */
3906               if (h != NULL)
3907                 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3908               else
3909                 {
3910                   /* Track dynamic relocs needed for local syms too.  */
3911                   asection *s;
3912                   void *vpp;
3913 		  Elf_Internal_Sym *isym;
3914 
3915 		  isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3916 						abfd, r_symndx);
3917 		  if (isym == NULL)
3918 		    return FALSE;
3919 
3920 		  s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3921 		  if (s == NULL)
3922 		    s = sec;
3923 
3924 		  vpp = &elf_section_data (s)->local_dynrel;
3925                   head = (struct elf_m32r_dyn_relocs **) vpp;
3926                 }
3927 
3928               p = *head;
3929               if (p == NULL || p->sec != sec)
3930                 {
3931                   bfd_size_type amt = sizeof (*p);
3932 
3933                   p = bfd_alloc (dynobj, amt);
3934                   if (p == NULL)
3935                     return FALSE;
3936                   p->next = *head;
3937                   *head = p;
3938                   p->sec = sec;
3939                   p->count = 0;
3940                   p->pc_count = 0;
3941                 }
3942 
3943               p->count += 1;
3944               if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3945                   || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3946 		  || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3947 		  || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3948                 p->pc_count += 1;
3949             }
3950           break;
3951 
3952         /* This relocation describes the C++ object vtable hierarchy.
3953            Reconstruct it for later use during GC.  */
3954         case R_M32R_RELA_GNU_VTINHERIT:
3955         case R_M32R_GNU_VTINHERIT:
3956           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3957             return FALSE;
3958           break;
3959 
3960         /* This relocation describes which C++ vtable entries are actually
3961            used.  Record for later use during GC.  */
3962         case R_M32R_GNU_VTENTRY:
3963           BFD_ASSERT (h != NULL);
3964           if (h != NULL
3965               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
3966             return FALSE;
3967           break;
3968         case R_M32R_RELA_GNU_VTENTRY:
3969           BFD_ASSERT (h != NULL);
3970           if (h != NULL
3971               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3972             return FALSE;
3973           break;
3974         }
3975     }
3976 
3977   return TRUE;
3978 }
3979 
3980 static const struct bfd_elf_special_section m32r_elf_special_sections[] =
3981 {
3982   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
3983   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
3984   { NULL,                     0,  0, 0,            0 }
3985 };
3986 
3987 static enum elf_reloc_type_class
3988 m32r_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
3989 			   const asection *rel_sec ATTRIBUTE_UNUSED,
3990 			   const Elf_Internal_Rela *rela)
3991 {
3992   switch ((int) ELF32_R_TYPE (rela->r_info))
3993     {
3994     case R_M32R_RELATIVE:  return reloc_class_relative;
3995     case R_M32R_JMP_SLOT:  return reloc_class_plt;
3996     case R_M32R_COPY:      return reloc_class_copy;
3997     default:      	   return reloc_class_normal;
3998     }
3999 }
4000 
4001 #define ELF_ARCH		bfd_arch_m32r
4002 #define ELF_TARGET_ID		M32R_ELF_DATA
4003 #define ELF_MACHINE_CODE	EM_M32R
4004 #define ELF_MACHINE_ALT1	EM_CYGNUS_M32R
4005 #define ELF_MAXPAGESIZE		0x1 /* Explicitly requested by Mitsubishi.  */
4006 
4007 #define TARGET_BIG_SYM          bfd_elf32_m32r_vec
4008 #define TARGET_BIG_NAME		"elf32-m32r"
4009 #define TARGET_LITTLE_SYM       bfd_elf32_m32rle_vec
4010 #define TARGET_LITTLE_NAME      "elf32-m32rle"
4011 
4012 #define elf_info_to_howto			m32r_info_to_howto
4013 #define elf_info_to_howto_rel			m32r_info_to_howto_rel
4014 #define elf_backend_section_from_bfd_section	_bfd_m32r_elf_section_from_bfd_section
4015 #define elf_backend_symbol_processing		_bfd_m32r_elf_symbol_processing
4016 #define elf_backend_add_symbol_hook		m32r_elf_add_symbol_hook
4017 #define elf_backend_relocate_section		m32r_elf_relocate_section
4018 #define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
4019 #define elf_backend_gc_sweep_hook               m32r_elf_gc_sweep_hook
4020 #define elf_backend_check_relocs                m32r_elf_check_relocs
4021 
4022 #define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
4023 #define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
4024 #define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
4025 #define elf_backend_omit_section_dynsym \
4026   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4027 #define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
4028 #define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
4029 #define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
4030 #define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
4031 #define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
4032 
4033 #define elf_backend_can_gc_sections             1
4034 /*#if !USE_REL
4035 #define elf_backend_rela_normal			1
4036 #endif*/
4037 #define elf_backend_can_refcount 1
4038 #define elf_backend_want_got_plt 1
4039 #define elf_backend_plt_readonly 1
4040 #define elf_backend_want_plt_sym 0
4041 #define elf_backend_got_header_size 12
4042 
4043 #define elf_backend_may_use_rel_p       1
4044 #ifdef USE_M32R_OLD_RELOC
4045 #define elf_backend_default_use_rela_p  0
4046 #define elf_backend_may_use_rela_p      0
4047 #else
4048 #define elf_backend_default_use_rela_p  1
4049 #define elf_backend_may_use_rela_p      1
4050 #endif
4051 
4052 #define elf_backend_object_p			m32r_elf_object_p
4053 #define elf_backend_final_write_processing 	m32r_elf_final_write_processing
4054 #define bfd_elf32_bfd_merge_private_bfd_data 	m32r_elf_merge_private_bfd_data
4055 #define bfd_elf32_bfd_set_private_flags		m32r_elf_set_private_flags
4056 #define bfd_elf32_bfd_print_private_bfd_data	m32r_elf_print_private_bfd_data
4057 #define elf_backend_special_sections		m32r_elf_special_sections
4058 
4059 #include "elf32-target.h"
4060 
4061 #undef  ELF_MAXPAGESIZE
4062 #define ELF_MAXPAGESIZE         0x1000
4063 
4064 #undef  TARGET_BIG_SYM
4065 #define TARGET_BIG_SYM          bfd_elf32_m32rlin_vec
4066 #undef  TARGET_BIG_NAME
4067 #define TARGET_BIG_NAME         "elf32-m32r-linux"
4068 #undef  TARGET_LITTLE_SYM
4069 #define TARGET_LITTLE_SYM       bfd_elf32_m32rlelin_vec
4070 #undef  TARGET_LITTLE_NAME
4071 #define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
4072 #undef  elf32_bed
4073 #define elf32_bed               elf32_m32r_lin_bed
4074 
4075 #include "elf32-target.h"
4076 
4077