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