* bfd-in.h (bfd_get_section_name, bfd_get_section_vma,
[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, 2009, 2010, 2011, 2012 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 cache.  */
1530   struct sym_cache sym_cache;
1531 };
1532
1533 /* Traverse an m32r ELF linker hash table.  */
1534
1535 #define m32r_elf_link_hash_traverse(table, func, info)                  \
1536   (elf_link_hash_traverse                                               \
1537    (&(table)->root,                                                     \
1538     (bfd_boolean (*) (struct elf_link_hash_entry *, void *)) (func),    \
1539     (info)))
1540
1541 /* Get the m32r ELF linker hash table from a link_info structure.  */
1542
1543 #define m32r_elf_hash_table(p) \
1544   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
1545   == M32R_ELF_DATA ? ((struct elf_m32r_link_hash_table *) ((p)->hash)) : NULL)
1546
1547 /* Create an entry in an m32r ELF linker hash table.  */
1548
1549 static struct bfd_hash_entry *
1550 m32r_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
1551                             struct bfd_hash_table *table,
1552                             const char *string)
1553 {
1554   struct elf_m32r_link_hash_entry *ret =
1555     (struct elf_m32r_link_hash_entry *) entry;
1556
1557   /* Allocate the structure if it has not already been allocated by a
1558      subclass.  */
1559   if (ret == NULL)
1560     ret = bfd_hash_allocate (table,
1561                              sizeof (struct elf_m32r_link_hash_entry));
1562   if (ret == NULL)
1563     return NULL;
1564
1565   /* Call the allocation method of the superclass.  */
1566   ret = ((struct elf_m32r_link_hash_entry *)
1567          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
1568                                      table, string));
1569   if (ret != NULL)
1570     {
1571       struct elf_m32r_link_hash_entry *eh;
1572
1573       eh = (struct elf_m32r_link_hash_entry *) ret;
1574       eh->dyn_relocs = NULL;
1575     }
1576
1577   return (struct bfd_hash_entry *) ret;
1578 }
1579
1580 /* Create an m32r ELF linker hash table.  */
1581
1582 static struct bfd_link_hash_table *
1583 m32r_elf_link_hash_table_create (bfd *abfd)
1584 {
1585   struct elf_m32r_link_hash_table *ret;
1586   bfd_size_type amt = sizeof (struct elf_m32r_link_hash_table);
1587
1588   ret = bfd_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                                       M32R_ELF_DATA))
1596     {
1597       free (ret);
1598       return NULL;
1599     }
1600
1601   ret->sgot = NULL;
1602   ret->sgotplt = NULL;
1603   ret->srelgot = NULL;
1604   ret->splt = NULL;
1605   ret->srelplt = NULL;
1606   ret->sdynbss = NULL;
1607   ret->srelbss = NULL;
1608   ret->sym_cache.abfd = NULL;
1609
1610   return &ret->root.root;
1611 }
1612
1613 /* Create .got, .gotplt, and .rela.got sections in DYNOBJ, and set up
1614    shortcuts to them in our hash table.  */
1615
1616 static bfd_boolean
1617 create_got_section (bfd *dynobj, struct bfd_link_info *info)
1618 {
1619   struct elf_m32r_link_hash_table *htab;
1620
1621   if (! _bfd_elf_create_got_section (dynobj, info))
1622     return FALSE;
1623
1624   htab = m32r_elf_hash_table (info);
1625   if (htab == NULL)
1626     return FALSE;
1627
1628   htab->sgot = bfd_get_section_by_name (dynobj, ".got");
1629   htab->sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1630   htab->srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1631   if (! htab->sgot || ! htab->sgotplt || ! htab->srelgot)
1632     abort ();
1633
1634   return TRUE;
1635 }
1636
1637 /* Create dynamic sections when linking against a dynamic object.  */
1638
1639 static bfd_boolean
1640 m32r_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
1641 {
1642   struct elf_m32r_link_hash_table *htab;
1643   flagword flags, pltflags;
1644   asection *s;
1645   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
1646   int ptralign = 2; /* 32bit */
1647
1648   htab = m32r_elf_hash_table (info);
1649   if (htab == NULL)
1650     return FALSE;
1651
1652   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
1653      .rel[a].bss sections.  */
1654   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
1655            | SEC_LINKER_CREATED);
1656
1657   pltflags = flags;
1658   pltflags |= SEC_CODE;
1659   if (bed->plt_not_loaded)
1660     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
1661   if (bed->plt_readonly)
1662     pltflags |= SEC_READONLY;
1663
1664   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
1665   htab->splt = s;
1666   if (s == NULL
1667       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
1668     return FALSE;
1669
1670   if (bed->want_plt_sym)
1671     {
1672       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
1673          .plt section.  */
1674       struct bfd_link_hash_entry *bh = NULL;
1675       struct elf_link_hash_entry *h;
1676
1677       if (! (_bfd_generic_link_add_one_symbol
1678              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
1679               (bfd_vma) 0, NULL, FALSE,
1680               get_elf_backend_data (abfd)->collect, &bh)))
1681         return FALSE;
1682       h = (struct elf_link_hash_entry *) bh;
1683       h->def_regular = 1;
1684       h->type = STT_OBJECT;
1685       htab->root.hplt = h;
1686
1687       if (info->shared
1688           && ! bfd_elf_link_record_dynamic_symbol (info, h))
1689         return FALSE;
1690     }
1691
1692   s = bfd_make_section_with_flags (abfd,
1693                                    bed->default_use_rela_p ? ".rela.plt" : ".rel.plt",
1694                                    flags | SEC_READONLY);
1695   htab->srelplt = s;
1696   if (s == NULL
1697       || ! bfd_set_section_alignment (abfd, s, ptralign))
1698     return FALSE;
1699
1700   if (htab->sgot == NULL
1701       && ! create_got_section (abfd, info))
1702     return FALSE;
1703
1704   {
1705     const char *secname;
1706     char *relname;
1707     flagword secflags;
1708     asection *sec;
1709
1710     for (sec = abfd->sections; sec; sec = sec->next)
1711       {
1712         secflags = bfd_get_section_flags (abfd, sec);
1713         if ((secflags & (SEC_DATA | SEC_LINKER_CREATED))
1714             || ((secflags & SEC_HAS_CONTENTS) != SEC_HAS_CONTENTS))
1715           continue;
1716         secname = bfd_get_section_name (abfd, sec);
1717         relname = bfd_malloc ((bfd_size_type) strlen (secname) + 6);
1718         strcpy (relname, ".rela");
1719         strcat (relname, secname);
1720         if (bfd_get_section_by_name (abfd, secname))
1721           continue;
1722         s = bfd_make_section_with_flags (abfd, relname,
1723                                          flags | SEC_READONLY);
1724         if (s == NULL
1725             || ! bfd_set_section_alignment (abfd, s, ptralign))
1726           return FALSE;
1727       }
1728   }
1729
1730   if (bed->want_dynbss)
1731     {
1732       /* The .dynbss section is a place to put symbols which are defined
1733          by dynamic objects, are referenced by regular objects, and are
1734          not functions.  We must allocate space for them in the process
1735          image and use a R_*_COPY reloc to tell the dynamic linker to
1736          initialize them at run time.  The linker script puts the .dynbss
1737          section into the .bss section of the final image.  */
1738       s = bfd_make_section_with_flags (abfd, ".dynbss",
1739                                        SEC_ALLOC | SEC_LINKER_CREATED);
1740       htab->sdynbss = s;
1741       if (s == NULL)
1742         return FALSE;
1743       /* The .rel[a].bss section holds copy relocs.  This section is not
1744          normally needed.  We need to create it here, though, so that the
1745          linker will map it to an output section.  We can't just create it
1746          only if we need it, because we will not know whether we need it
1747          until we have seen all the input files, and the first time the
1748          main linker code calls BFD after examining all the input files
1749          (size_dynamic_sections) the input sections have already been
1750          mapped to the output sections.  If the section turns out not to
1751          be needed, we can discard it later.  We will never need this
1752          section when generating a shared object, since they do not use
1753          copy relocs.  */
1754       if (! info->shared)
1755         {
1756           s = bfd_make_section_with_flags (abfd,
1757                                            (bed->default_use_rela_p
1758                                             ? ".rela.bss" : ".rel.bss"),
1759                                            flags | SEC_READONLY);
1760           htab->srelbss = s;
1761           if (s == NULL
1762               || ! bfd_set_section_alignment (abfd, s, ptralign))
1763             return FALSE;
1764         }
1765     }
1766
1767   return TRUE;
1768 }
1769
1770 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
1771
1772 static void
1773 m32r_elf_copy_indirect_symbol (struct bfd_link_info *info,
1774                                struct elf_link_hash_entry *dir,
1775                                struct elf_link_hash_entry *ind)
1776 {
1777   struct elf_m32r_link_hash_entry * edir;
1778   struct elf_m32r_link_hash_entry * eind;
1779
1780   edir = (struct elf_m32r_link_hash_entry *) dir;
1781   eind = (struct elf_m32r_link_hash_entry *) ind;
1782
1783   if (eind->dyn_relocs != NULL)
1784     {
1785       if (edir->dyn_relocs != NULL)
1786         {
1787           struct elf_m32r_dyn_relocs **pp;
1788           struct elf_m32r_dyn_relocs *p;
1789
1790           /* Add reloc counts against the indirect sym to the direct sym
1791              list.  Merge any entries against the same section.  */
1792           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
1793             {
1794               struct elf_m32r_dyn_relocs *q;
1795
1796               for (q = edir->dyn_relocs; q != NULL; q = q->next)
1797                 if (q->sec == p->sec)
1798                   {
1799                     q->pc_count += p->pc_count;
1800                     q->count += p->count;
1801                     *pp = p->next;
1802                     break;
1803                   }
1804               if (q == NULL)
1805                 pp = &p->next;
1806             }
1807           *pp = edir->dyn_relocs;
1808         }
1809
1810       edir->dyn_relocs = eind->dyn_relocs;
1811       eind->dyn_relocs = NULL;
1812     }
1813
1814   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
1815 }
1816
1817 \f
1818 /* Adjust a symbol defined by a dynamic object and referenced by a
1819    regular object.  The current definition is in some section of the
1820    dynamic object, but we're not including those sections.  We have to
1821    change the definition to something the rest of the link can
1822    understand.  */
1823
1824 static bfd_boolean
1825 m32r_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1826                                 struct elf_link_hash_entry *h)
1827 {
1828   struct elf_m32r_link_hash_table *htab;
1829   struct elf_m32r_link_hash_entry *eh;
1830   struct elf_m32r_dyn_relocs *p;
1831   bfd *dynobj;
1832   asection *s;
1833
1834 #ifdef DEBUG_PIC
1835   printf ("m32r_elf_adjust_dynamic_symbol()\n");
1836 #endif
1837
1838   dynobj = elf_hash_table (info)->dynobj;
1839
1840   /* Make sure we know what is going on here.  */
1841   BFD_ASSERT (dynobj != NULL
1842               && (h->needs_plt
1843                   || h->u.weakdef != NULL
1844                   || (h->def_dynamic
1845                       && h->ref_regular
1846                       && !h->def_regular)));
1847
1848   /* If this is a function, put it in the procedure linkage table.  We
1849      will fill in the contents of the procedure linkage table later,
1850      when we know the address of the .got section.  */
1851   if (h->type == STT_FUNC
1852       || h->needs_plt)
1853     {
1854       if (! info->shared
1855           && !h->def_dynamic
1856           && !h->ref_dynamic
1857           && h->root.type != bfd_link_hash_undefweak
1858           && h->root.type != bfd_link_hash_undefined)
1859         {
1860           /* This case can occur if we saw a PLT reloc in an input
1861              file, but the symbol was never referred to by a dynamic
1862              object.  In such a case, we don't actually need to build
1863              a procedure linkage table, and we can just do a PCREL
1864              reloc instead.  */
1865           h->plt.offset = (bfd_vma) -1;
1866           h->needs_plt = 0;
1867         }
1868
1869       return TRUE;
1870     }
1871   else
1872     h->plt.offset = (bfd_vma) -1;
1873
1874   /* If this is a weak symbol, and there is a real definition, the
1875      processor independent code will have arranged for us to see the
1876      real definition first, and we can just use the same value.  */
1877   if (h->u.weakdef != NULL)
1878     {
1879       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1880                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1881       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1882       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1883       return TRUE;
1884     }
1885
1886   /* This is a reference to a symbol defined by a dynamic object which
1887      is not a function.  */
1888
1889   /* If we are creating a shared library, we must presume that the
1890      only references to the symbol are via the global offset table.
1891      For such cases we need not do anything here; the relocations will
1892      be handled correctly by relocate_section.  */
1893   if (info->shared)
1894     return TRUE;
1895
1896   /* If there are no references to this symbol that do not use the
1897      GOT, we don't need to generate a copy reloc.  */
1898   if (!h->non_got_ref)
1899     return TRUE;
1900
1901   /* If -z nocopyreloc was given, we won't generate them either.  */
1902   if (info->nocopyreloc)
1903     {
1904       h->non_got_ref = 0;
1905       return TRUE;
1906     }
1907
1908   eh = (struct elf_m32r_link_hash_entry *) h;
1909   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1910     {
1911       s = p->sec->output_section;
1912       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1913         break;
1914     }
1915
1916   /* If we didn't find any dynamic relocs in sections which needs the
1917      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1918      the copy reloc.  */
1919   if (p == NULL)
1920     {
1921       h->non_got_ref = 0;
1922       return TRUE;
1923     }
1924
1925   /* We must allocate the symbol in our .dynbss section, which will
1926      become part of the .bss section of the executable.  There will be
1927      an entry for this symbol in the .dynsym section.  The dynamic
1928      object will contain position independent code, so all references
1929      from the dynamic object to this symbol will go through the global
1930      offset table.  The dynamic linker will use the .dynsym entry to
1931      determine the address it must put in the global offset table, so
1932      both the dynamic object and the regular object will refer to the
1933      same memory location for the variable.  */
1934
1935   htab = m32r_elf_hash_table (info);
1936   if (htab == NULL)
1937     return FALSE;
1938
1939   s = htab->sdynbss;
1940   BFD_ASSERT (s != NULL);
1941
1942   /* We must generate a R_M32R_COPY reloc to tell the dynamic linker
1943      to copy the initial value out of the dynamic object and into the
1944      runtime process image.  We need to remember the offset into the
1945      .rela.bss section we are going to use.  */
1946   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1947     {
1948       asection *srel;
1949
1950       srel = htab->srelbss;
1951       BFD_ASSERT (srel != NULL);
1952       srel->size += sizeof (Elf32_External_Rela);
1953       h->needs_copy = 1;
1954     }
1955
1956   return _bfd_elf_adjust_dynamic_copy (h, s);
1957 }
1958
1959 /* Allocate space in .plt, .got and associated reloc sections for
1960    dynamic relocs.  */
1961
1962 static bfd_boolean
1963 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1964 {
1965   struct bfd_link_info *info;
1966   struct elf_m32r_link_hash_table *htab;
1967   struct elf_m32r_link_hash_entry *eh;
1968   struct elf_m32r_dyn_relocs *p;
1969
1970   if (h->root.type == bfd_link_hash_indirect)
1971     return TRUE;
1972
1973   info = (struct bfd_link_info *) inf;
1974   htab = m32r_elf_hash_table (info);
1975   if (htab == NULL)
1976     return FALSE;
1977
1978   eh = (struct elf_m32r_link_hash_entry *) h;
1979
1980   if (htab->root.dynamic_sections_created
1981       && h->plt.refcount > 0)
1982     {
1983       /* Make sure this symbol is output as a dynamic symbol.
1984          Undefined weak syms won't yet be marked as dynamic.  */
1985       if (h->dynindx == -1
1986           && !h->forced_local)
1987         {
1988           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1989             return FALSE;
1990         }
1991
1992       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1993         {
1994           asection *s = htab->splt;
1995
1996           /* If this is the first .plt entry, make room for the special
1997              first entry.  */
1998           if (s->size == 0)
1999             s->size += PLT_ENTRY_SIZE;
2000
2001           h->plt.offset = s->size;
2002
2003           /* If this symbol is not defined in a regular file, and we are
2004              not generating a shared library, then set the symbol to this
2005              location in the .plt.  This is required to make function
2006              pointers compare as equal between the normal executable and
2007              the shared library.  */
2008           if (! info->shared
2009               && !h->def_regular)
2010             {
2011               h->root.u.def.section = s;
2012               h->root.u.def.value = h->plt.offset;
2013             }
2014
2015           /* Make room for this entry.  */
2016           s->size += PLT_ENTRY_SIZE;
2017
2018           /* We also need to make an entry in the .got.plt section, which
2019              will be placed in the .got section by the linker script.  */
2020           htab->sgotplt->size += 4;
2021
2022           /* We also need to make an entry in the .rel.plt section.  */
2023           htab->srelplt->size += sizeof (Elf32_External_Rela);
2024         }
2025       else
2026         {
2027           h->plt.offset = (bfd_vma) -1;
2028           h->needs_plt = 0;
2029         }
2030     }
2031   else
2032     {
2033       h->plt.offset = (bfd_vma) -1;
2034       h->needs_plt = 0;
2035     }
2036
2037   if (h->got.refcount > 0)
2038     {
2039       asection *s;
2040       bfd_boolean dyn;
2041
2042       /* Make sure this symbol is output as a dynamic symbol.
2043          Undefined weak syms won't yet be marked as dynamic.  */
2044       if (h->dynindx == -1
2045           && !h->forced_local)
2046         {
2047           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2048             return FALSE;
2049         }
2050
2051       s = htab->sgot;
2052
2053       h->got.offset = s->size;
2054       s->size += 4;
2055       dyn = htab->root.dynamic_sections_created;
2056       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2057         htab->srelgot->size += sizeof (Elf32_External_Rela);
2058     }
2059   else
2060     h->got.offset = (bfd_vma) -1;
2061
2062   if (eh->dyn_relocs == NULL)
2063     return TRUE;
2064
2065   /* In the shared -Bsymbolic case, discard space allocated for
2066      dynamic pc-relative relocs against symbols which turn out to be
2067      defined in regular objects.  For the normal shared case, discard
2068      space for pc-relative relocs that have become local due to symbol
2069      visibility changes.  */
2070
2071   if (info->shared)
2072     {
2073       if (h->def_regular
2074           && (h->forced_local
2075               || info->symbolic))
2076         {
2077           struct elf_m32r_dyn_relocs **pp;
2078
2079           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2080             {
2081               p->count -= p->pc_count;
2082               p->pc_count = 0;
2083               if (p->count == 0)
2084                 *pp = p->next;
2085               else
2086                 pp = &p->next;
2087             }
2088         }
2089
2090       /* Also discard relocs on undefined weak syms with non-default
2091          visibility.  */
2092       if (eh->dyn_relocs != NULL
2093           && h->root.type == bfd_link_hash_undefweak)
2094         {
2095           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2096             eh->dyn_relocs = NULL;
2097
2098           /* Make sure undefined weak symbols are output as a dynamic
2099              symbol in PIEs.  */
2100           else if (h->dynindx == -1
2101                    && !h->forced_local)
2102             {
2103               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2104                 return FALSE;
2105             }
2106         }
2107     }
2108   else
2109     {
2110       /* For the non-shared case, discard space for relocs against
2111          symbols which turn out to need copy relocs or are not
2112          dynamic.  */
2113
2114       if (!h->non_got_ref
2115           && ((h->def_dynamic
2116                && !h->def_regular)
2117               || (htab->root.dynamic_sections_created
2118                   && (h->root.type == bfd_link_hash_undefweak
2119                       || h->root.type == bfd_link_hash_undefined))))
2120         {
2121           /* Make sure this symbol is output as a dynamic symbol.
2122              Undefined weak syms won't yet be marked as dynamic.  */
2123           if (h->dynindx == -1
2124               && !h->forced_local)
2125             {
2126               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2127                 return FALSE;
2128             }
2129
2130           /* If that succeeded, we know we'll be keeping all the
2131              relocs.  */
2132           if (h->dynindx != -1)
2133             goto keep;
2134         }
2135
2136       eh->dyn_relocs = NULL;
2137
2138     keep: ;
2139     }
2140
2141   /* Finally, allocate space.  */
2142   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2143     {
2144       asection *sreloc = elf_section_data (p->sec)->sreloc;
2145       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2146     }
2147
2148   return TRUE;
2149 }
2150
2151 /* Find any dynamic relocs that apply to read-only sections.  */
2152
2153 static bfd_boolean
2154 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2155 {
2156   struct elf_m32r_link_hash_entry *eh;
2157   struct elf_m32r_dyn_relocs *p;
2158
2159   eh = (struct elf_m32r_link_hash_entry *) h;
2160   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2161     {
2162       asection *s = p->sec->output_section;
2163
2164       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2165         {
2166           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2167
2168           info->flags |= DF_TEXTREL;
2169
2170           /* Not an error, just cut short the traversal.  */
2171           return FALSE;
2172         }
2173     }
2174   return TRUE;
2175 }
2176
2177 /* Set the sizes of the dynamic sections.  */
2178
2179 static bfd_boolean
2180 m32r_elf_size_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
2181                                 struct bfd_link_info *info)
2182 {
2183   struct elf_m32r_link_hash_table *htab;
2184   bfd *dynobj;
2185   asection *s;
2186   bfd_boolean relocs;
2187   bfd *ibfd;
2188
2189 #ifdef DEBUG_PIC
2190   printf ("m32r_elf_size_dynamic_sections()\n");
2191 #endif
2192
2193   htab = m32r_elf_hash_table (info);
2194   if (htab == NULL)
2195     return FALSE;
2196
2197   dynobj = htab->root.dynobj;
2198   BFD_ASSERT (dynobj != NULL);
2199
2200   if (htab->root.dynamic_sections_created)
2201     {
2202       /* Set the contents of the .interp section to the interpreter.  */
2203       if (info->executable)
2204         {
2205           s = bfd_get_section_by_name (dynobj, ".interp");
2206           BFD_ASSERT (s != NULL);
2207           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2208           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2209         }
2210     }
2211
2212   /* Set up .got offsets for local syms, and space for local dynamic
2213      relocs.  */
2214   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2215     {
2216       bfd_signed_vma *local_got;
2217       bfd_signed_vma *end_local_got;
2218       bfd_size_type locsymcount;
2219       Elf_Internal_Shdr *symtab_hdr;
2220       asection *srel;
2221
2222       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2223         continue;
2224
2225       for (s = ibfd->sections; s != NULL; s = s->next)
2226         {
2227           struct elf_m32r_dyn_relocs *p;
2228
2229           for (p = ((struct elf_m32r_dyn_relocs *)
2230                     elf_section_data (s)->local_dynrel);
2231                p != NULL;
2232                p = p->next)
2233             {
2234               if (! bfd_is_abs_section (p->sec)
2235                   && bfd_is_abs_section (p->sec->output_section))
2236                 {
2237                   /* Input section has been discarded, either because
2238                      it is a copy of a linkonce section or due to
2239                      linker script /DISCARD/, so we'll be discarding
2240                      the relocs too.  */
2241                 }
2242               else if (p->count != 0)
2243                 {
2244                   srel = elf_section_data (p->sec)->sreloc;
2245                   srel->size += p->count * sizeof (Elf32_External_Rela);
2246                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2247                     info->flags |= DF_TEXTREL;
2248                 }
2249             }
2250         }
2251
2252       local_got = elf_local_got_refcounts (ibfd);
2253       if (!local_got)
2254         continue;
2255
2256       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2257       locsymcount = symtab_hdr->sh_info;
2258       end_local_got = local_got + locsymcount;
2259       s = htab->sgot;
2260       srel = htab->srelgot;
2261       for (; local_got < end_local_got; ++local_got)
2262         {
2263           if (*local_got > 0)
2264             {
2265               *local_got = s->size;
2266               s->size += 4;
2267               if (info->shared)
2268                 srel->size += sizeof (Elf32_External_Rela);
2269             }
2270           else
2271             *local_got = (bfd_vma) -1;
2272         }
2273     }
2274
2275   /* Allocate global sym .plt and .got entries, and space for global
2276      sym dynamic relocs.  */
2277   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2278
2279   /* We now have determined the sizes of the various dynamic sections.
2280      Allocate memory for them.  */
2281   relocs = FALSE;
2282   for (s = dynobj->sections; s != NULL; s = s->next)
2283     {
2284       if ((s->flags & SEC_LINKER_CREATED) == 0)
2285         continue;
2286
2287       if (s == htab->splt
2288           || s == htab->sgot
2289           || s == htab->sgotplt
2290           || s == htab->sdynbss)
2291         {
2292           /* Strip this section if we don't need it; see the
2293              comment below.  */
2294         }
2295       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2296         {
2297           if (s->size != 0 && s != htab->srelplt)
2298             relocs = TRUE;
2299
2300           /* We use the reloc_count field as a counter if we need
2301              to copy relocs into the output file.  */
2302           s->reloc_count = 0;
2303         }
2304       else
2305         /* It's not one of our sections, so don't allocate space.  */
2306         continue;
2307
2308       if (s->size == 0)
2309         {
2310           /* If we don't need this section, strip it from the
2311              output file.  This is mostly to handle .rela.bss and
2312              .rela.plt.  We must create both sections in
2313              create_dynamic_sections, because they must be created
2314              before the linker maps input sections to output
2315              sections.  The linker does that before
2316              adjust_dynamic_symbol is called, and it is that
2317              function which decides whether anything needs to go
2318              into these sections.  */
2319           s->flags |= SEC_EXCLUDE;
2320           continue;
2321         }
2322
2323       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2324         continue;
2325
2326       /* Allocate memory for the section contents.  We use bfd_zalloc
2327          here in case unused entries are not reclaimed before the
2328          section's contents are written out.  This should not happen,
2329          but this way if it does, we get a R_M32R_NONE reloc instead
2330          of garbage.  */
2331       s->contents = bfd_zalloc (dynobj, s->size);
2332       if (s->contents == NULL)
2333         return FALSE;
2334     }
2335
2336   if (htab->root.dynamic_sections_created)
2337     {
2338       /* Add some entries to the .dynamic section.  We fill in the
2339          values later, in m32r_elf_finish_dynamic_sections, but we
2340          must add the entries now so that we get the correct size for
2341          the .dynamic section.  The DT_DEBUG entry is filled in by the
2342          dynamic linker and used by the debugger.  */
2343 #define add_dynamic_entry(TAG, VAL) \
2344   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2345
2346      if (info->executable)
2347         {
2348           if (! add_dynamic_entry (DT_DEBUG, 0))
2349             return FALSE;
2350         }
2351
2352       if (htab->splt->size != 0)
2353         {
2354           if (! add_dynamic_entry (DT_PLTGOT, 0)
2355               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2356               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2357               || ! add_dynamic_entry (DT_JMPREL, 0))
2358             return FALSE;
2359         }
2360
2361       if (relocs)
2362         {
2363           if (! add_dynamic_entry (DT_RELA, 0)
2364               || ! add_dynamic_entry (DT_RELASZ, 0)
2365               || ! add_dynamic_entry (DT_RELAENT,
2366                                       sizeof (Elf32_External_Rela)))
2367             return FALSE;
2368
2369           /* If any dynamic relocs apply to a read-only section,
2370              then we need a DT_TEXTREL entry.  */
2371           if ((info->flags & DF_TEXTREL) == 0)
2372             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2373                                     info);
2374
2375           if ((info->flags & DF_TEXTREL) != 0)
2376             {
2377               if (! add_dynamic_entry (DT_TEXTREL, 0))
2378                 return FALSE;
2379             }
2380         }
2381     }
2382 #undef add_dynamic_entry
2383
2384   return TRUE;
2385 }
2386
2387 /* Relocate an M32R/D ELF section.
2388    There is some attempt to make this function usable for many architectures,
2389    both for RELA and REL type relocs, if only to serve as a learning tool.
2390
2391    The RELOCATE_SECTION function is called by the new ELF backend linker
2392    to handle the relocations for a section.
2393
2394    The relocs are always passed as Rela structures; if the section
2395    actually uses Rel structures, the r_addend field will always be
2396    zero.
2397
2398    This function is responsible for adjust the section contents as
2399    necessary, and (if using Rela relocs and generating a
2400    relocatable output file) adjusting the reloc addend as
2401    necessary.
2402
2403    This function does not have to worry about setting the reloc
2404    address or the reloc symbol index.
2405
2406    LOCAL_SYMS is a pointer to the swapped in local symbols.
2407
2408    LOCAL_SECTIONS is an array giving the section in the input file
2409    corresponding to the st_shndx field of each local symbol.
2410
2411    The global hash table entry for the global symbols can be found
2412    via elf_sym_hashes (input_bfd).
2413
2414    When generating relocatable output, this function must handle
2415    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2416    going to be the section symbol corresponding to the output
2417    section, which means that the addend must be adjusted
2418    accordingly.  */
2419
2420 static bfd_boolean
2421 m32r_elf_relocate_section (bfd *output_bfd ATTRIBUTE_UNUSED,
2422                            struct bfd_link_info *info,
2423                            bfd *input_bfd,
2424                            asection *input_section,
2425                            bfd_byte *contents,
2426                            Elf_Internal_Rela *relocs,
2427                            Elf_Internal_Sym *local_syms,
2428                            asection **local_sections)
2429 {
2430   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
2431   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
2432   Elf_Internal_Rela *rel, *relend;
2433   /* Assume success.  */
2434   bfd_boolean ret = TRUE;
2435   struct elf_m32r_link_hash_table *htab = m32r_elf_hash_table (info);
2436   bfd *dynobj;
2437   bfd_vma *local_got_offsets;
2438   asection *sgot, *splt, *sreloc;
2439   bfd_vma high_address = bfd_get_section_limit (input_bfd, input_section);
2440
2441   if (htab == NULL)
2442     return FALSE;
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                        && (_bfd_elf_section_offset (output_bfd, info,
2587                                                     input_section,
2588                                                     rel->r_offset)
2589                            != (bfd_vma) -1))
2590                 {
2591                   (*_bfd_error_handler)
2592                     (_("%B(%A+0x%lx): unresolvable %s relocation against symbol `%s'"),
2593                      input_bfd,
2594                      input_section,
2595                      (long) rel->r_offset,
2596                      howto->name,
2597                      h->root.root.string);
2598                 }
2599             }
2600           else if (h->root.type == bfd_link_hash_undefweak)
2601             ;
2602           else if (info->unresolved_syms_in_objects == RM_IGNORE
2603                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2604             ;
2605           else if (!info->relocatable)
2606             {
2607               if (! ((*info->callbacks->undefined_symbol)
2608                      (info, h->root.root.string, input_bfd,
2609                       input_section, offset,
2610                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2611                        || ELF_ST_VISIBILITY (h->other)))))
2612                 return FALSE;
2613             }
2614         }
2615
2616       if (sec != NULL && discarded_section (sec))
2617         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2618                                          rel, 1, relend, howto, 0, contents);
2619
2620       if (info->relocatable && !use_rel)
2621         {
2622           /* This is a relocatable link.  We don't have to change
2623              anything, unless the reloc is against a section symbol,
2624              in which case we have to adjust according to where the
2625              section symbol winds up in the output section.  */
2626           if (sym != NULL && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
2627             rel->r_addend += sec->output_offset;
2628           continue;
2629         }
2630
2631       if (info->relocatable && use_rel)
2632         {
2633           /* This is a relocatable link.  We don't have to change
2634              anything, unless the reloc is against a section symbol,
2635              in which case we have to adjust according to where the
2636              section symbol winds up in the output section.  */
2637           if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
2638             continue;
2639
2640           addend += sec->output_offset;
2641
2642           /* If partial_inplace, we need to store any additional addend
2643              back in the section.  */
2644           if (! howto->partial_inplace)
2645             continue;
2646           /* ??? Here is a nice place to call a special_function
2647              like handler.  */
2648           if (r_type != R_M32R_HI16_SLO && r_type != R_M32R_HI16_ULO)
2649             r = _bfd_relocate_contents (howto, input_bfd,
2650                                         addend, contents + offset);
2651           else
2652             {
2653               Elf_Internal_Rela *lorel;
2654
2655               /* We allow an arbitrary number of HI16 relocs before the
2656                  LO16 reloc.  This permits gcc to emit the HI and LO relocs
2657                  itself.  */
2658               for (lorel = rel + 1;
2659                    (lorel < relend
2660                     && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2661                         || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2662                    lorel++)
2663                 continue;
2664               if (lorel < relend
2665                   && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2666                 {
2667                   m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2668                                           contents, addend);
2669                   r = bfd_reloc_ok;
2670                 }
2671               else
2672                 r = _bfd_relocate_contents (howto, input_bfd,
2673                                             addend, contents + offset);
2674             }
2675         }
2676       else
2677         {
2678           /* Sanity check the address.  */
2679           if (offset > high_address)
2680             {
2681               r = bfd_reloc_outofrange;
2682               goto check_reloc;
2683             }
2684
2685           switch ((int) r_type)
2686             {
2687             case R_M32R_GOTOFF:
2688               /* Relocation is relative to the start of the global offset
2689                  table (for ld24 rx, #uimm24). eg access at label+addend
2690
2691                  ld24 rx. #label@GOTOFF + addend
2692                  sub  rx, r12.  */
2693
2694               BFD_ASSERT (sgot != NULL);
2695
2696               relocation = -(relocation - sgot->output_section->vma);
2697               rel->r_addend = -rel->r_addend;
2698               break;
2699
2700             case R_M32R_GOTOFF_HI_ULO:
2701             case R_M32R_GOTOFF_HI_SLO:
2702             case R_M32R_GOTOFF_LO:
2703               BFD_ASSERT (sgot != NULL);
2704
2705               relocation -= sgot->output_section->vma;
2706
2707               if ((r_type == R_M32R_GOTOFF_HI_SLO)
2708                   && ((relocation + rel->r_addend) & 0x8000))
2709                 rel->r_addend += 0x10000;
2710               break;
2711
2712             case R_M32R_GOTPC24:
2713               /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2714                  ld24 rx,#_GLOBAL_OFFSET_TABLE_
2715                */
2716              relocation = sgot->output_section->vma;
2717              break;
2718
2719             case R_M32R_GOTPC_HI_ULO:
2720             case R_M32R_GOTPC_HI_SLO:
2721             case R_M32R_GOTPC_LO:
2722               {
2723                 /* .got(_GLOBAL_OFFSET_TABLE_) - pc relocation
2724                    bl .+4
2725                    seth rx,#high(_GLOBAL_OFFSET_TABLE_)
2726                    or3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2727                    or
2728                    bl .+4
2729                    seth rx,#shigh(_GLOBAL_OFFSET_TABLE_)
2730                    add3 rx,rx,#low(_GLOBAL_OFFSET_TABLE_ +4)
2731                  */
2732                 relocation = sgot->output_section->vma;
2733                 relocation -= (input_section->output_section->vma
2734                                + input_section->output_offset
2735                                + rel->r_offset);
2736                 if ((r_type == R_M32R_GOTPC_HI_SLO)
2737                      && ((relocation + rel->r_addend) & 0x8000))
2738                   rel->r_addend += 0x10000;
2739
2740                 break;
2741               }
2742             case R_M32R_GOT16_HI_ULO:
2743             case R_M32R_GOT16_HI_SLO:
2744             case R_M32R_GOT16_LO:
2745               /* Fall through.  */
2746             case R_M32R_GOT24:
2747               /* Relocation is to the entry for this symbol in the global
2748                  offset table.  */
2749               BFD_ASSERT (sgot != NULL);
2750
2751               if (h != NULL)
2752                 {
2753                   bfd_boolean dyn;
2754                   bfd_vma off;
2755
2756                   off = h->got.offset;
2757                   BFD_ASSERT (off != (bfd_vma) -1);
2758
2759                   dyn = htab->root.dynamic_sections_created;
2760                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h)
2761                       || (info->shared
2762                           && (info->symbolic
2763                               || h->dynindx == -1
2764                               || h->forced_local)
2765                           && h->def_regular))
2766                     {
2767                       /* This is actually a static link, or it is a
2768                          -Bsymbolic link and the symbol is defined
2769                          locally, or the symbol was forced to be local
2770                          because of a version file.  We must initialize
2771                          this entry in the global offset table.  Since the
2772                          offset must always be a multiple of 4, we use the
2773                          least significant bit to record whether we have
2774                          initialized it already.
2775
2776                          When doing a dynamic link, we create a .rela.got
2777                          relocation entry to initialize the value.  This
2778                          is done in the finish_dynamic_symbol routine.  */
2779                       if ((off & 1) != 0)
2780                         off &= ~1;
2781                       else
2782                         {
2783                           bfd_put_32 (output_bfd, relocation,
2784                                       sgot->contents + off);
2785                           h->got.offset |= 1;
2786                         }
2787                     }
2788
2789                   relocation = sgot->output_offset + off;
2790                 }
2791               else
2792                 {
2793                   bfd_vma off;
2794                   bfd_byte *loc;
2795
2796                   BFD_ASSERT (local_got_offsets != NULL
2797                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
2798
2799                   off = local_got_offsets[r_symndx];
2800
2801                   /* The offset must always be a multiple of 4.  We use
2802                      the least significant bit to record whether we have
2803                      already processed this entry.  */
2804                   if ((off & 1) != 0)
2805                     off &= ~1;
2806                   else
2807                     {
2808                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
2809
2810                       if (info->shared)
2811                         {
2812                           asection *srelgot;
2813                           Elf_Internal_Rela outrel;
2814
2815                           /* We need to generate a R_M32R_RELATIVE reloc
2816                              for the dynamic linker.  */
2817                           srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2818                           BFD_ASSERT (srelgot != NULL);
2819
2820                           outrel.r_offset = (sgot->output_section->vma
2821                                              + sgot->output_offset
2822                                              + off);
2823                           outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2824                           outrel.r_addend = relocation;
2825                           loc = srelgot->contents;
2826                           loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
2827                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2828                           ++srelgot->reloc_count;
2829                         }
2830
2831                       local_got_offsets[r_symndx] |= 1;
2832                     }
2833
2834                   relocation = sgot->output_offset + off;
2835                 }
2836               if ((r_type == R_M32R_GOT16_HI_SLO)
2837                   && ((relocation + rel->r_addend) & 0x8000))
2838                 rel->r_addend += 0x10000;
2839
2840               break;
2841
2842             case R_M32R_26_PLTREL:
2843               /* Relocation is to the entry for this symbol in the
2844                  procedure linkage table.  */
2845
2846               /* The native assembler will generate a 26_PLTREL reloc
2847                  for a local symbol if you assemble a call from one
2848                  section to another when using -K pic. */
2849               if (h == NULL)
2850                 break;
2851
2852               if (h->forced_local)
2853                 break;
2854
2855               if (h->plt.offset == (bfd_vma) -1)
2856                 /* We didn't make a PLT entry for this symbol.  This
2857                    happens when statically linking PIC code, or when
2858                    using -Bsymbolic.  */
2859                 break;
2860
2861               relocation = (splt->output_section->vma
2862                             + splt->output_offset
2863                             + h->plt.offset);
2864               break;
2865
2866             case R_M32R_HI16_SLO_RELA:
2867               if ((relocation + rel->r_addend) & 0x8000)
2868                 rel->r_addend += 0x10000;
2869               /* Fall through.  */
2870
2871             case R_M32R_16_RELA:
2872             case R_M32R_24_RELA:
2873             case R_M32R_32_RELA:
2874             case R_M32R_REL32:
2875             case R_M32R_10_PCREL_RELA:
2876             case R_M32R_18_PCREL_RELA:
2877             case R_M32R_26_PCREL_RELA:
2878             case R_M32R_HI16_ULO_RELA:
2879             case R_M32R_LO16_RELA:
2880               if (info->shared
2881                   && r_symndx != STN_UNDEF
2882                   && (input_section->flags & SEC_ALLOC) != 0
2883                   && ((   r_type != R_M32R_10_PCREL_RELA
2884                        && r_type != R_M32R_18_PCREL_RELA
2885                        && r_type != R_M32R_26_PCREL_RELA
2886                        && r_type != R_M32R_REL32)
2887                       || (h != NULL
2888                           && h->dynindx != -1
2889                           && (! info->symbolic
2890                               || !h->def_regular))))
2891                 {
2892                   Elf_Internal_Rela outrel;
2893                   bfd_boolean skip, relocate;
2894                   bfd_byte *loc;
2895
2896                   /* When generating a shared object, these relocations
2897                      are copied into the output file to be resolved at run
2898                      time.  */
2899                   if (sreloc == NULL)
2900                     {
2901                       sreloc = _bfd_elf_get_dynamic_reloc_section
2902                         (input_bfd, input_section, /*rela?*/ TRUE);
2903                       if (sreloc == NULL)
2904                         return FALSE;
2905                     }
2906
2907                   skip = FALSE;
2908                   relocate = FALSE;
2909
2910                   outrel.r_offset = _bfd_elf_section_offset (output_bfd,
2911                                                              info,
2912                                                              input_section,
2913                                                              rel->r_offset);
2914                   if (outrel.r_offset == (bfd_vma) -1)
2915                     skip = TRUE;
2916                   else if (outrel.r_offset == (bfd_vma) -2)
2917                     skip = relocate = TRUE;
2918                   outrel.r_offset += (input_section->output_section->vma
2919                                       + input_section->output_offset);
2920
2921                   if (skip)
2922                     memset (&outrel, 0, sizeof outrel);
2923                   else if (   r_type == R_M32R_10_PCREL_RELA
2924                            || r_type == R_M32R_18_PCREL_RELA
2925                            || r_type == R_M32R_26_PCREL_RELA
2926                            || r_type == R_M32R_REL32)
2927                     {
2928                       BFD_ASSERT (h != NULL && h->dynindx != -1);
2929                       outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2930                       outrel.r_addend = rel->r_addend;
2931                     }
2932                   else
2933                     {
2934                     /* h->dynindx may be -1 if this symbol was marked to
2935                        become local.  */
2936                     if (h == NULL
2937                         || ((info->symbolic || h->dynindx == -1)
2938                              && h->def_regular))
2939                       {
2940                         relocate = TRUE;
2941                         outrel.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
2942                         outrel.r_addend = relocation + rel->r_addend;
2943                       }
2944                     else
2945                       {
2946                         BFD_ASSERT (h->dynindx != -1);
2947                         outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
2948                         outrel.r_addend = relocation + rel->r_addend;
2949                       }
2950                     }
2951
2952                   loc = sreloc->contents;
2953                   loc += sreloc->reloc_count * sizeof (Elf32_External_Rela);
2954                   bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
2955                   ++sreloc->reloc_count;
2956
2957                   /* If this reloc is against an external symbol, we do
2958                      not want to fiddle with the addend.  Otherwise, we
2959                      need to include the symbol value so that it becomes
2960                      an addend for the dynamic reloc.  */
2961                   if (! relocate)
2962                     continue;
2963                   break;
2964                 }
2965               else if (r_type != R_M32R_10_PCREL_RELA)
2966                 break;
2967               /* Fall through.  */
2968
2969             case (int) R_M32R_10_PCREL :
2970               r = m32r_elf_do_10_pcrel_reloc (input_bfd, howto, input_section,
2971                                               contents, offset,
2972                                               sec, relocation, addend);
2973               goto check_reloc;
2974
2975             case (int) R_M32R_HI16_SLO :
2976             case (int) R_M32R_HI16_ULO :
2977               {
2978                 Elf_Internal_Rela *lorel;
2979
2980                 /* We allow an arbitrary number of HI16 relocs before the
2981                    LO16 reloc.  This permits gcc to emit the HI and LO relocs
2982                    itself.  */
2983                 for (lorel = rel + 1;
2984                      (lorel < relend
2985                       && (ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_SLO
2986                           || ELF32_R_TYPE (lorel->r_info) == R_M32R_HI16_ULO));
2987                      lorel++)
2988                   continue;
2989                 if (lorel < relend
2990                     && ELF32_R_TYPE (lorel->r_info) == R_M32R_LO16)
2991                   {
2992                     m32r_elf_relocate_hi16 (input_bfd, r_type, rel, lorel,
2993                                             contents, relocation + addend);
2994                     r = bfd_reloc_ok;
2995                   }
2996                 else
2997                   r = _bfd_final_link_relocate (howto, input_bfd, input_section,
2998                                                 contents, offset,
2999                                                 relocation, addend);
3000               }
3001
3002               goto check_reloc;
3003
3004             case (int) R_M32R_SDA16_RELA:
3005             case (int) R_M32R_SDA16 :
3006               {
3007                 const char *name;
3008
3009                 BFD_ASSERT (sec != NULL);
3010                 name = bfd_get_section_name (sec->owner, sec);
3011
3012                 if (   strcmp (name, ".sdata") == 0
3013                     || strcmp (name, ".sbss") == 0
3014                     || strcmp (name, ".scommon") == 0)
3015                   {
3016                     bfd_vma sda_base;
3017                     bfd *out_bfd = sec->output_section->owner;
3018
3019                     r = m32r_elf_final_sda_base (out_bfd, info,
3020                                                  &errmsg,
3021                                                  &sda_base);
3022                     if (r != bfd_reloc_ok)
3023                       {
3024                         ret = FALSE;
3025                         goto check_reloc;
3026                       }
3027
3028                     /* At this point `relocation' contains the object's
3029                        address.  */
3030                     relocation -= sda_base;
3031                     /* Now it contains the offset from _SDA_BASE_.  */
3032                   }
3033                 else
3034                   {
3035                     (*_bfd_error_handler)
3036                       (_("%B: The target (%s) of an %s relocation is in the wrong section (%A)"),
3037                        input_bfd,
3038                        sec,
3039                        sym_name,
3040                        m32r_elf_howto_table[(int) r_type].name);
3041                     /*bfd_set_error (bfd_error_bad_value); ??? why? */
3042                     ret = FALSE;
3043                     continue;
3044                   }
3045               }
3046               /* Fall through.  */
3047
3048             default : /* OLD_M32R_RELOC */
3049
3050               r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3051                                             contents, offset,
3052                                             relocation, addend);
3053               goto check_reloc;
3054             }
3055
3056           r = _bfd_final_link_relocate (howto, input_bfd, input_section,
3057                                         contents, rel->r_offset,
3058                                         relocation, rel->r_addend);
3059
3060         }
3061
3062     check_reloc:
3063
3064       if (r != bfd_reloc_ok)
3065         {
3066           /* FIXME: This should be generic enough to go in a utility.  */
3067           const char *name;
3068
3069           if (h != NULL)
3070             name = h->root.root.string;
3071           else
3072             {
3073               name = (bfd_elf_string_from_elf_section
3074                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
3075               if (name == NULL || *name == '\0')
3076                 name = bfd_section_name (input_bfd, sec);
3077             }
3078
3079           if (errmsg != NULL)
3080             goto common_error;
3081
3082           switch (r)
3083             {
3084             case bfd_reloc_overflow:
3085               if (! ((*info->callbacks->reloc_overflow)
3086                      (info, (h ? &h->root : NULL), name, howto->name,
3087                       (bfd_vma) 0, input_bfd, input_section, offset)))
3088                 return FALSE;
3089               break;
3090
3091             case bfd_reloc_undefined:
3092               if (! ((*info->callbacks->undefined_symbol)
3093                      (info, name, input_bfd, input_section,
3094                       offset, TRUE)))
3095                 return FALSE;
3096               break;
3097
3098             case bfd_reloc_outofrange:
3099               errmsg = _("internal error: out of range error");
3100               goto common_error;
3101
3102             case bfd_reloc_notsupported:
3103               errmsg = _("internal error: unsupported relocation error");
3104               goto common_error;
3105
3106             case bfd_reloc_dangerous:
3107               errmsg = _("internal error: dangerous error");
3108               goto common_error;
3109
3110             default:
3111               errmsg = _("internal error: unknown error");
3112               /* fall through */
3113
3114             common_error:
3115               if (!((*info->callbacks->warning)
3116                     (info, errmsg, name, input_bfd, input_section,
3117                      offset)))
3118                 return FALSE;
3119               break;
3120             }
3121         }
3122     }
3123
3124   return ret;
3125 }
3126
3127 /* Finish up dynamic symbol handling.  We set the contents of various
3128    dynamic sections here.  */
3129
3130 static bfd_boolean
3131 m32r_elf_finish_dynamic_symbol (bfd *output_bfd,
3132                                 struct bfd_link_info *info,
3133                                 struct elf_link_hash_entry *h,
3134                                 Elf_Internal_Sym *sym)
3135 {
3136   struct elf_m32r_link_hash_table *htab;
3137   bfd_byte *loc;
3138
3139 #ifdef DEBUG_PIC
3140   printf ("m32r_elf_finish_dynamic_symbol()\n");
3141 #endif
3142
3143   htab = m32r_elf_hash_table (info);
3144   if (htab == NULL)
3145     return FALSE;
3146
3147   if (h->plt.offset != (bfd_vma) -1)
3148     {
3149       asection *splt;
3150       asection *sgot;
3151       asection *srela;
3152
3153       bfd_vma plt_index;
3154       bfd_vma got_offset;
3155       Elf_Internal_Rela rela;
3156
3157       /* This symbol has an entry in the procedure linkage table.  Set
3158          it up.  */
3159
3160       BFD_ASSERT (h->dynindx != -1);
3161
3162       splt = htab->splt;
3163       sgot = htab->sgotplt;
3164       srela = htab->srelplt;
3165       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
3166
3167       /* Get the index in the procedure linkage table which
3168          corresponds to this symbol.  This is the index of this symbol
3169          in all the symbols for which we are making plt entries.  The
3170          first entry in the procedure linkage table is reserved.  */
3171       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
3172
3173       /* Get the offset into the .got table of the entry that
3174         corresponds to this function.  Each .got entry is 4 bytes.
3175         The first three are reserved.  */
3176       got_offset = (plt_index + 3) * 4;
3177
3178       /* Fill in the entry in the procedure linkage table.  */
3179       if (! info->shared)
3180         {
3181           bfd_put_32 (output_bfd,
3182               (PLT_ENTRY_WORD0b
3183                + (((sgot->output_section->vma
3184                     + sgot->output_offset
3185                     + got_offset) >> 16) & 0xffff)),
3186               splt->contents + h->plt.offset);
3187           bfd_put_32 (output_bfd,
3188               (PLT_ENTRY_WORD1b
3189                + ((sgot->output_section->vma
3190                    + sgot->output_offset
3191                    + got_offset) & 0xffff)),
3192               splt->contents + h->plt.offset + 4);
3193           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3194               splt->contents + h->plt.offset + 8);
3195           bfd_put_32 (output_bfd,
3196               (PLT_ENTRY_WORD3
3197                + plt_index * sizeof (Elf32_External_Rela)),
3198               splt->contents + h->plt.offset + 12);
3199           bfd_put_32 (output_bfd,
3200               (PLT_ENTRY_WORD4
3201                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3202               splt->contents + h->plt.offset + 16);
3203         }
3204       else
3205         {
3206           bfd_put_32 (output_bfd,
3207               PLT_ENTRY_WORD0 + got_offset,
3208               splt->contents + h->plt.offset);
3209           bfd_put_32 (output_bfd, PLT_ENTRY_WORD1,
3210               splt->contents + h->plt.offset + 4);
3211           bfd_put_32 (output_bfd, PLT_ENTRY_WORD2,
3212               splt->contents + h->plt.offset + 8);
3213           bfd_put_32 (output_bfd,
3214               (PLT_ENTRY_WORD3
3215                + plt_index * sizeof (Elf32_External_Rela)),
3216               splt->contents + h->plt.offset + 12);
3217           bfd_put_32 (output_bfd,
3218               (PLT_ENTRY_WORD4
3219                + (((unsigned int) ((- (h->plt.offset + 16)) >> 2)) & 0xffffff)),
3220               splt->contents + h->plt.offset + 16);
3221         }
3222
3223       /* Fill in the entry in the global offset table.  */
3224       bfd_put_32 (output_bfd,
3225                   (splt->output_section->vma
3226                    + splt->output_offset
3227                    + h->plt.offset
3228                    + 12), /* same offset */
3229                   sgot->contents + got_offset);
3230
3231       /* Fill in the entry in the .rela.plt section.  */
3232       rela.r_offset = (sgot->output_section->vma
3233                        + sgot->output_offset
3234                        + got_offset);
3235       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_JMP_SLOT);
3236       rela.r_addend = 0;
3237       loc = srela->contents;
3238       loc += plt_index * sizeof (Elf32_External_Rela);
3239       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3240
3241       if (!h->def_regular)
3242         {
3243           /* Mark the symbol as undefined, rather than as defined in
3244              the .plt section.  Leave the value alone.  */
3245           sym->st_shndx = SHN_UNDEF;
3246         }
3247     }
3248
3249   if (h->got.offset != (bfd_vma) -1)
3250     {
3251       asection *sgot;
3252       asection *srela;
3253       Elf_Internal_Rela rela;
3254
3255       /* This symbol has an entry in the global offset table.  Set it
3256          up.  */
3257
3258       sgot = htab->sgot;
3259       srela = htab->srelgot;
3260       BFD_ASSERT (sgot != NULL && srela != NULL);
3261
3262       rela.r_offset = (sgot->output_section->vma
3263                        + sgot->output_offset
3264                        + (h->got.offset &~ 1));
3265
3266       /* If this is a -Bsymbolic link, and the symbol is defined
3267          locally, we just want to emit a RELATIVE reloc.  Likewise if
3268          the symbol was forced to be local because of a version file.
3269          The entry in the global offset table will already have been
3270          initialized in the relocate_section function.  */
3271       if (info->shared
3272           && (info->symbolic
3273               || h->dynindx == -1
3274               || h->forced_local)
3275           && h->def_regular)
3276         {
3277           rela.r_info = ELF32_R_INFO (0, R_M32R_RELATIVE);
3278           rela.r_addend = (h->root.u.def.value
3279                            + h->root.u.def.section->output_section->vma
3280                            + h->root.u.def.section->output_offset);
3281         }
3282       else
3283         {
3284           BFD_ASSERT ((h->got.offset & 1) == 0);
3285           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
3286           rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_GLOB_DAT);
3287           rela.r_addend = 0;
3288         }
3289
3290       loc = srela->contents;
3291       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
3292       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3293       ++srela->reloc_count;
3294     }
3295
3296   if (h->needs_copy)
3297     {
3298       asection *s;
3299       Elf_Internal_Rela rela;
3300
3301       /* This symbols needs a copy reloc.  Set it up.  */
3302
3303       BFD_ASSERT (h->dynindx != -1
3304                   && (h->root.type == bfd_link_hash_defined
3305                       || h->root.type == bfd_link_hash_defweak));
3306
3307       s = bfd_get_section_by_name (h->root.u.def.section->owner,
3308                                    ".rela.bss");
3309       BFD_ASSERT (s != NULL);
3310
3311       rela.r_offset = (h->root.u.def.value
3312                        + h->root.u.def.section->output_section->vma
3313                        + h->root.u.def.section->output_offset);
3314       rela.r_info = ELF32_R_INFO (h->dynindx, R_M32R_COPY);
3315       rela.r_addend = 0;
3316       loc = s->contents;
3317       loc += s->reloc_count * sizeof (Elf32_External_Rela);
3318       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
3319       ++s->reloc_count;
3320     }
3321
3322   /* Mark some specially defined symbols as absolute.  */
3323   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
3324       || h == htab->root.hgot)
3325     sym->st_shndx = SHN_ABS;
3326
3327   return TRUE;
3328 }
3329
3330
3331 /* Finish up the dynamic sections.  */
3332
3333 static bfd_boolean
3334 m32r_elf_finish_dynamic_sections (bfd *output_bfd,
3335                                   struct bfd_link_info *info)
3336 {
3337   struct elf_m32r_link_hash_table *htab;
3338   bfd *dynobj;
3339   asection *sdyn;
3340   asection *sgot;
3341
3342 #ifdef DEBUG_PIC
3343   printf ("m32r_elf_finish_dynamic_sections()\n");
3344 #endif
3345
3346   htab = m32r_elf_hash_table (info);
3347   if (htab == NULL)
3348     return FALSE;
3349
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           asection *s;
3369
3370           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3371
3372           switch (dyn.d_tag)
3373             {
3374             default:
3375               break;
3376
3377             case DT_PLTGOT:
3378               s = htab->sgot->output_section;
3379               goto get_vma;
3380             case DT_JMPREL:
3381               s = htab->srelplt->output_section;
3382             get_vma:
3383               BFD_ASSERT (s != NULL);
3384               dyn.d_un.d_ptr = s->vma;
3385               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3386               break;
3387
3388             case DT_PLTRELSZ:
3389               s = htab->srelplt->output_section;
3390               BFD_ASSERT (s != NULL);
3391               dyn.d_un.d_val = s->size;
3392               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3393               break;
3394
3395             case DT_RELASZ:
3396               /* My reading of the SVR4 ABI indicates that the
3397                  procedure linkage table relocs (DT_JMPREL) should be
3398                  included in the overall relocs (DT_RELA).  This is
3399                  what Solaris does.  However, UnixWare can not handle
3400                  that case.  Therefore, we override the DT_RELASZ entry
3401                  here to make it not include the JMPREL relocs.  Since
3402                  the linker script arranges for .rela.plt to follow all
3403                  other relocation sections, we don't have to worry
3404                  about changing the DT_RELA entry.  */
3405               if (htab->srelplt != NULL)
3406                 {
3407                   s = htab->srelplt->output_section;
3408                   dyn.d_un.d_val -= s->size;
3409                 }
3410               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3411               break;
3412             }
3413         }
3414
3415       /* Fill in the first entry in the procedure linkage table.  */
3416       splt = htab->splt;
3417       if (splt && splt->size > 0)
3418         {
3419           if (info->shared)
3420             {
3421               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
3422               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
3423               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
3424               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
3425               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
3426             }
3427           else
3428             {
3429               unsigned long addr;
3430               /* addr = .got + 4 */
3431               addr = sgot->output_section->vma + sgot->output_offset + 4;
3432               bfd_put_32 (output_bfd,
3433                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
3434                           splt->contents);
3435               bfd_put_32 (output_bfd,
3436                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
3437                           splt->contents + 4);
3438               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
3439               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
3440               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
3441             }
3442
3443           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
3444             PLT_ENTRY_SIZE;
3445         }
3446     }
3447
3448   /* Fill in the first three entries in the global offset table.  */
3449   if (sgot && sgot->size > 0)
3450     {
3451       if (sdyn == NULL)
3452         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
3453       else
3454         bfd_put_32 (output_bfd,
3455                     sdyn->output_section->vma + sdyn->output_offset,
3456                     sgot->contents);
3457       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
3458       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
3459
3460       elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
3461     }
3462
3463   return TRUE;
3464 }
3465
3466 \f
3467 /* Set the right machine number.  */
3468
3469 static bfd_boolean
3470 m32r_elf_object_p (bfd *abfd)
3471 {
3472   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3473     {
3474     default:
3475     case E_M32R_ARCH:   (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r);  break;
3476     case E_M32RX_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32rx); break;
3477     case E_M32R2_ARCH:  (void) bfd_default_set_arch_mach (abfd, bfd_arch_m32r, bfd_mach_m32r2); break;
3478     }
3479   return TRUE;
3480 }
3481
3482 /* Store the machine number in the flags field.  */
3483
3484 static void
3485 m32r_elf_final_write_processing (bfd *abfd,
3486                                  bfd_boolean linker ATTRIBUTE_UNUSED)
3487 {
3488   unsigned long val;
3489
3490   switch (bfd_get_mach (abfd))
3491     {
3492     default:
3493     case bfd_mach_m32r:  val = E_M32R_ARCH; break;
3494     case bfd_mach_m32rx: val = E_M32RX_ARCH; break;
3495     case bfd_mach_m32r2: val = E_M32R2_ARCH; break;
3496     }
3497
3498   elf_elfheader (abfd)->e_flags &=~ EF_M32R_ARCH;
3499   elf_elfheader (abfd)->e_flags |= val;
3500 }
3501
3502 /* Function to keep M32R specific file flags.  */
3503
3504 static bfd_boolean
3505 m32r_elf_set_private_flags (bfd *abfd, flagword flags)
3506 {
3507   BFD_ASSERT (!elf_flags_init (abfd)
3508               || elf_elfheader (abfd)->e_flags == flags);
3509
3510   elf_elfheader (abfd)->e_flags = flags;
3511   elf_flags_init (abfd) = TRUE;
3512   return TRUE;
3513 }
3514
3515 /* Merge backend specific data from an object file to the output
3516    object file when linking.  */
3517
3518 static bfd_boolean
3519 m32r_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
3520 {
3521   flagword out_flags;
3522   flagword in_flags;
3523
3524   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
3525       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
3526     return TRUE;
3527
3528   in_flags  = elf_elfheader (ibfd)->e_flags;
3529   out_flags = elf_elfheader (obfd)->e_flags;
3530
3531   if (! elf_flags_init (obfd))
3532     {
3533       /* If the input is the default architecture then do not
3534          bother setting the flags for the output architecture,
3535          instead allow future merges to do this.  If no future
3536          merges ever set these flags then they will retain their
3537          unitialised values, which surprise surprise, correspond
3538          to the default values.  */
3539       if (bfd_get_arch_info (ibfd)->the_default)
3540         return TRUE;
3541
3542       elf_flags_init (obfd) = TRUE;
3543       elf_elfheader (obfd)->e_flags = in_flags;
3544
3545       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
3546           && bfd_get_arch_info (obfd)->the_default)
3547         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd),
3548                                   bfd_get_mach (ibfd));
3549
3550       return TRUE;
3551     }
3552
3553   /* Check flag compatibility.  */
3554   if (in_flags == out_flags)
3555     return TRUE;
3556
3557   if ((in_flags & EF_M32R_ARCH) != (out_flags & EF_M32R_ARCH))
3558     {
3559       if (   ((in_flags  & EF_M32R_ARCH) != E_M32R_ARCH)
3560           || ((out_flags & EF_M32R_ARCH) == E_M32R_ARCH)
3561           || ((in_flags  & EF_M32R_ARCH) == E_M32R2_ARCH))
3562         {
3563           (*_bfd_error_handler)
3564             (_("%B: Instruction set mismatch with previous modules"), ibfd);
3565
3566           bfd_set_error (bfd_error_bad_value);
3567           return FALSE;
3568         }
3569     }
3570
3571   return TRUE;
3572 }
3573
3574 /* Display the flags field.  */
3575
3576 static bfd_boolean
3577 m32r_elf_print_private_bfd_data (bfd *abfd, void * ptr)
3578 {
3579   FILE * file = (FILE *) ptr;
3580
3581   BFD_ASSERT (abfd != NULL && ptr != NULL);
3582
3583   _bfd_elf_print_private_bfd_data (abfd, ptr);
3584
3585   fprintf (file, _("private flags = %lx"), elf_elfheader (abfd)->e_flags);
3586
3587   switch (elf_elfheader (abfd)->e_flags & EF_M32R_ARCH)
3588     {
3589     default:
3590     case E_M32R_ARCH:  fprintf (file, _(": m32r instructions"));  break;
3591     case E_M32RX_ARCH: fprintf (file, _(": m32rx instructions")); break;
3592     case E_M32R2_ARCH: fprintf (file, _(": m32r2 instructions")); break;
3593     }
3594
3595   fputc ('\n', file);
3596
3597   return TRUE;
3598 }
3599
3600 static asection *
3601 m32r_elf_gc_mark_hook (asection *sec,
3602                        struct bfd_link_info *info,
3603                        Elf_Internal_Rela *rel,
3604                        struct elf_link_hash_entry *h,
3605                        Elf_Internal_Sym *sym)
3606 {
3607   if (h != NULL)
3608     switch (ELF32_R_TYPE (rel->r_info))
3609       {
3610       case R_M32R_GNU_VTINHERIT:
3611       case R_M32R_GNU_VTENTRY:
3612       case R_M32R_RELA_GNU_VTINHERIT:
3613       case R_M32R_RELA_GNU_VTENTRY:
3614         return NULL;
3615       }
3616
3617   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3618 }
3619
3620 static bfd_boolean
3621 m32r_elf_gc_sweep_hook (bfd *abfd ATTRIBUTE_UNUSED,
3622                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
3623                         asection *sec ATTRIBUTE_UNUSED,
3624                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
3625 {
3626   /* Update the got entry reference counts for the section being removed.  */
3627   Elf_Internal_Shdr *symtab_hdr;
3628   struct elf_link_hash_entry **sym_hashes;
3629   bfd_signed_vma *local_got_refcounts;
3630   const Elf_Internal_Rela *rel, *relend;
3631
3632   if (info->relocatable)
3633     return TRUE;
3634
3635   elf_section_data (sec)->local_dynrel = NULL;
3636
3637   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3638   sym_hashes = elf_sym_hashes (abfd);
3639   local_got_refcounts = elf_local_got_refcounts (abfd);
3640
3641   relend = relocs + sec->reloc_count;
3642   for (rel = relocs; rel < relend; rel++)
3643     {
3644       unsigned long r_symndx;
3645       struct elf_link_hash_entry *h = NULL;
3646
3647       r_symndx = ELF32_R_SYM (rel->r_info);
3648       if (r_symndx >= symtab_hdr->sh_info)
3649         {
3650           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3651           while (h->root.type == bfd_link_hash_indirect
3652                  || h->root.type == bfd_link_hash_warning)
3653             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3654         }
3655
3656       switch (ELF32_R_TYPE (rel->r_info))
3657         {
3658         case R_M32R_GOT16_HI_ULO:
3659         case R_M32R_GOT16_HI_SLO:
3660         case R_M32R_GOT16_LO:
3661         case R_M32R_GOTOFF:
3662         case R_M32R_GOTOFF_HI_ULO:
3663         case R_M32R_GOTOFF_HI_SLO:
3664         case R_M32R_GOTOFF_LO:
3665         case R_M32R_GOT24:
3666         case R_M32R_GOTPC_HI_ULO:
3667         case R_M32R_GOTPC_HI_SLO:
3668         case R_M32R_GOTPC_LO:
3669         case R_M32R_GOTPC24:
3670           if (h != NULL)
3671             {
3672               if (h->got.refcount > 0)
3673                 h->got.refcount--;
3674             }
3675           else
3676             {
3677               if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
3678                 local_got_refcounts[r_symndx]--;
3679             }
3680           break;
3681
3682         case R_M32R_16_RELA:
3683         case R_M32R_24_RELA:
3684         case R_M32R_32_RELA:
3685         case R_M32R_REL32:
3686         case R_M32R_HI16_ULO_RELA:
3687         case R_M32R_HI16_SLO_RELA:
3688         case R_M32R_LO16_RELA:
3689         case R_M32R_SDA16_RELA:
3690         case R_M32R_10_PCREL_RELA:
3691         case R_M32R_18_PCREL_RELA:
3692         case R_M32R_26_PCREL_RELA:
3693           if (h != NULL)
3694             {
3695               struct elf_m32r_link_hash_entry *eh;
3696               struct elf_m32r_dyn_relocs **pp;
3697               struct elf_m32r_dyn_relocs *p;
3698
3699               if (!info->shared && h->plt.refcount > 0)
3700                 h->plt.refcount -= 1;
3701
3702               eh = (struct elf_m32r_link_hash_entry *) h;
3703
3704               for (pp = &eh->dyn_relocs; (p = *pp) != NULL; pp = &p->next)
3705                 if (p->sec == sec)
3706                   {
3707                     if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3708                         || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3709                         || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3710                         || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3711                       p->pc_count -= 1;
3712                     p->count -= 1;
3713                     if (p->count == 0)
3714                       *pp = p->next;
3715                     break;
3716                   }
3717             }
3718           break;
3719
3720         case R_M32R_26_PLTREL:
3721           if (h != NULL)
3722             {
3723               if (h->plt.refcount > 0)
3724                 h->plt.refcount--;
3725             }
3726           break;
3727
3728         default:
3729           break;
3730         }
3731     }
3732
3733   return TRUE;
3734 }
3735
3736 /* Look through the relocs for a section during the first phase.
3737    Since we don't do .gots or .plts, we just need to consider the
3738    virtual table relocs for gc.  */
3739
3740 static bfd_boolean
3741 m32r_elf_check_relocs (bfd *abfd,
3742                        struct bfd_link_info *info,
3743                        asection *sec,
3744                        const Elf_Internal_Rela *relocs)
3745 {
3746   Elf_Internal_Shdr *symtab_hdr;
3747   struct elf_link_hash_entry **sym_hashes;
3748   const Elf_Internal_Rela *rel;
3749   const Elf_Internal_Rela *rel_end;
3750   struct elf_m32r_link_hash_table *htab;
3751   bfd *dynobj;
3752   asection *sreloc;
3753
3754   if (info->relocatable)
3755     return TRUE;
3756
3757   sreloc = NULL;
3758   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3759   sym_hashes = elf_sym_hashes (abfd);
3760
3761   htab = m32r_elf_hash_table (info);
3762   if (htab == NULL)
3763     return FALSE;
3764
3765   dynobj = htab->root.dynobj;
3766
3767   rel_end = relocs + sec->reloc_count;
3768   for (rel = relocs; rel < rel_end; rel++)
3769     {
3770       int r_type;
3771       struct elf_link_hash_entry *h;
3772       unsigned long r_symndx;
3773
3774       r_symndx = ELF32_R_SYM (rel->r_info);
3775       r_type = ELF32_R_TYPE (rel->r_info);
3776       if (r_symndx < symtab_hdr->sh_info)
3777         h = NULL;
3778       else
3779         {
3780           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3781           while (h->root.type == bfd_link_hash_indirect
3782                  || h->root.type == bfd_link_hash_warning)
3783             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3784         }
3785
3786       /* Some relocs require a global offset table.  */
3787       if (htab->sgot == NULL)
3788         {
3789           switch (r_type)
3790             {
3791             case R_M32R_GOT16_HI_ULO:
3792             case R_M32R_GOT16_HI_SLO:
3793             case R_M32R_GOTOFF:
3794             case R_M32R_GOTOFF_HI_ULO:
3795             case R_M32R_GOTOFF_HI_SLO:
3796             case R_M32R_GOTOFF_LO:
3797             case R_M32R_GOT16_LO:
3798             case R_M32R_GOTPC24:
3799             case R_M32R_GOTPC_HI_ULO:
3800             case R_M32R_GOTPC_HI_SLO:
3801             case R_M32R_GOTPC_LO:
3802             case R_M32R_GOT24:
3803               if (dynobj == NULL)
3804                 htab->root.dynobj = dynobj = abfd;
3805               if (! create_got_section (dynobj, info))
3806                 return FALSE;
3807               break;
3808
3809             default:
3810               break;
3811           }
3812         }
3813
3814       switch (r_type)
3815         {
3816         case R_M32R_GOT16_HI_ULO:
3817         case R_M32R_GOT16_HI_SLO:
3818         case R_M32R_GOT16_LO:
3819         case R_M32R_GOT24:
3820
3821           if (h != NULL)
3822             h->got.refcount += 1;
3823           else
3824             {
3825               bfd_signed_vma *local_got_refcounts;
3826
3827               /* This is a global offset table entry for a local
3828                  symbol.  */
3829               local_got_refcounts = elf_local_got_refcounts (abfd);
3830               if (local_got_refcounts == NULL)
3831                 {
3832                   bfd_size_type size;
3833
3834                   size = symtab_hdr->sh_info;
3835                   size *= sizeof (bfd_signed_vma);
3836                   local_got_refcounts = bfd_zalloc (abfd, size);
3837                   if (local_got_refcounts == NULL)
3838                     return FALSE;
3839                   elf_local_got_refcounts (abfd) = local_got_refcounts;
3840                 }
3841               local_got_refcounts[r_symndx] += 1;
3842             }
3843           break;
3844
3845         case R_M32R_26_PLTREL:
3846           /* This symbol requires a procedure linkage table entry.  We
3847              actually build the entry in adjust_dynamic_symbol,
3848              because this might be a case of linking PIC code without
3849              linking in any dynamic objects, in which case we don't
3850              need to generate a procedure linkage table after all.  */
3851
3852           /* If this is a local symbol, we resolve it directly without
3853              creating a procedure linkage table entry.  */
3854           if (h == NULL)
3855             continue;
3856
3857           if (h->forced_local)
3858             break;
3859
3860           h->needs_plt = 1;
3861           h->plt.refcount += 1;
3862           break;
3863
3864         case R_M32R_16_RELA:
3865         case R_M32R_24_RELA:
3866         case R_M32R_32_RELA:
3867         case R_M32R_REL32:
3868         case R_M32R_HI16_ULO_RELA:
3869         case R_M32R_HI16_SLO_RELA:
3870         case R_M32R_LO16_RELA:
3871         case R_M32R_SDA16_RELA:
3872         case R_M32R_10_PCREL_RELA:
3873         case R_M32R_18_PCREL_RELA:
3874         case R_M32R_26_PCREL_RELA:
3875
3876           if (h != NULL && !info->shared)
3877             {
3878               h->non_got_ref = 1;
3879               h->plt.refcount += 1;
3880             }
3881
3882           /* If we are creating a shared library, and this is a reloc
3883              against a global symbol, or a non PC relative reloc
3884              against a local symbol, then we need to copy the reloc
3885              into the shared library.  However, if we are linking with
3886              -Bsymbolic, we do not need to copy a reloc against a
3887              global symbol which is defined in an object we are
3888              including in the link (i.e., DEF_REGULAR is set).  At
3889              this point we have not seen all the input files, so it is
3890              possible that DEF_REGULAR is not set now but will be set
3891              later (it is never cleared).  We account for that
3892              possibility below by storing information in the
3893              dyn_relocs field of the hash table entry. A similar
3894              situation occurs when creating shared libraries and symbol
3895              visibility changes render the symbol local.
3896
3897              If on the other hand, we are creating an executable, we
3898              may need to keep relocations for symbols satisfied by a
3899              dynamic library if we manage to avoid copy relocs for the
3900              symbol.  */
3901           if ((info->shared
3902                && (sec->flags & SEC_ALLOC) != 0
3903                && ((   r_type != R_M32R_26_PCREL_RELA
3904                     && r_type != R_M32R_18_PCREL_RELA
3905                     && r_type != R_M32R_10_PCREL_RELA
3906                     && r_type != R_M32R_REL32)
3907                    || (h != NULL
3908                        && (! info->symbolic
3909                            || h->root.type == bfd_link_hash_defweak
3910                            || !h->def_regular))))
3911               || (!info->shared
3912                   && (sec->flags & SEC_ALLOC) != 0
3913                   && h != NULL
3914                   && (h->root.type == bfd_link_hash_defweak
3915                       || !h->def_regular)))
3916             {
3917               struct elf_m32r_dyn_relocs *p;
3918               struct elf_m32r_dyn_relocs **head;
3919
3920               if (dynobj == NULL)
3921                 htab->root.dynobj = dynobj = abfd;
3922
3923               /* When creating a shared object, we must copy these
3924                  relocs into the output file.  We create a reloc
3925                  section in dynobj and make room for the reloc.  */
3926               if (sreloc == NULL)
3927                 {
3928                   sreloc = _bfd_elf_make_dynamic_reloc_section
3929                     (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3930
3931                   if (sreloc == NULL)
3932                     return FALSE;
3933                 }
3934
3935               /* If this is a global symbol, we count the number of
3936                  relocations we need for this symbol.  */
3937               if (h != NULL)
3938                 head = &((struct elf_m32r_link_hash_entry *) h)->dyn_relocs;
3939               else
3940                 {
3941                   /* Track dynamic relocs needed for local syms too.  */
3942                   asection *s;
3943                   void *vpp;
3944                   Elf_Internal_Sym *isym;
3945
3946                   isym = bfd_sym_from_r_symndx (&htab->sym_cache,
3947                                                 abfd, r_symndx);
3948                   if (isym == NULL)
3949                     return FALSE;
3950
3951                   s = bfd_section_from_elf_index (abfd, isym->st_shndx);
3952                   if (s == NULL)
3953                     s = sec;
3954
3955                   vpp = &elf_section_data (s)->local_dynrel;
3956                   head = (struct elf_m32r_dyn_relocs **) vpp;
3957                 }
3958
3959               p = *head;
3960               if (p == NULL || p->sec != sec)
3961                 {
3962                   bfd_size_type amt = sizeof (*p);
3963
3964                   p = bfd_alloc (dynobj, amt);
3965                   if (p == NULL)
3966                     return FALSE;
3967                   p->next = *head;
3968                   *head = p;
3969                   p->sec = sec;
3970                   p->count = 0;
3971                   p->pc_count = 0;
3972                 }
3973
3974               p->count += 1;
3975               if (   ELF32_R_TYPE (rel->r_info) == R_M32R_26_PCREL_RELA
3976                   || ELF32_R_TYPE (rel->r_info) == R_M32R_18_PCREL_RELA
3977                   || ELF32_R_TYPE (rel->r_info) == R_M32R_10_PCREL_RELA
3978                   || ELF32_R_TYPE (rel->r_info) == R_M32R_REL32)
3979                 p->pc_count += 1;
3980             }
3981           break;
3982
3983         /* This relocation describes the C++ object vtable hierarchy.
3984            Reconstruct it for later use during GC.  */
3985         case R_M32R_RELA_GNU_VTINHERIT:
3986         case R_M32R_GNU_VTINHERIT:
3987           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3988             return FALSE;
3989           break;
3990
3991         /* This relocation describes which C++ vtable entries are actually
3992            used.  Record for later use during GC.  */
3993         case R_M32R_GNU_VTENTRY:
3994           BFD_ASSERT (h != NULL);
3995           if (h != NULL
3996               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_offset))
3997             return FALSE;
3998           break;
3999         case R_M32R_RELA_GNU_VTENTRY:
4000           BFD_ASSERT (h != NULL);
4001           if (h != NULL
4002               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4003             return FALSE;
4004           break;
4005         }
4006     }
4007
4008   return TRUE;
4009 }
4010
4011 static const struct bfd_elf_special_section m32r_elf_special_sections[] =
4012 {
4013   { STRING_COMMA_LEN (".sbss"),  -2, SHT_NOBITS,   SHF_ALLOC + SHF_WRITE },
4014   { STRING_COMMA_LEN (".sdata"), -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
4015   { NULL,                     0,  0, 0,            0 }
4016 };
4017
4018 static enum elf_reloc_type_class
4019 m32r_elf_reloc_type_class (const Elf_Internal_Rela *rela)
4020 {
4021   switch ((int) ELF32_R_TYPE (rela->r_info))
4022     {
4023     case R_M32R_RELATIVE:  return reloc_class_relative;
4024     case R_M32R_JMP_SLOT:  return reloc_class_plt;
4025     case R_M32R_COPY:      return reloc_class_copy;
4026     default:               return reloc_class_normal;
4027     }
4028 }
4029 \f
4030 #define ELF_ARCH                bfd_arch_m32r
4031 #define ELF_TARGET_ID           M32R_ELF_DATA
4032 #define ELF_MACHINE_CODE        EM_M32R
4033 #define ELF_MACHINE_ALT1        EM_CYGNUS_M32R
4034 #define ELF_MAXPAGESIZE         0x1 /* Explicitly requested by Mitsubishi.  */
4035
4036 #define TARGET_BIG_SYM          bfd_elf32_m32r_vec
4037 #define TARGET_BIG_NAME         "elf32-m32r"
4038 #define TARGET_LITTLE_SYM       bfd_elf32_m32rle_vec
4039 #define TARGET_LITTLE_NAME      "elf32-m32rle"
4040
4041 #define elf_info_to_howto                       m32r_info_to_howto
4042 #define elf_info_to_howto_rel                   m32r_info_to_howto_rel
4043 #define elf_backend_section_from_bfd_section    _bfd_m32r_elf_section_from_bfd_section
4044 #define elf_backend_symbol_processing           _bfd_m32r_elf_symbol_processing
4045 #define elf_backend_add_symbol_hook             m32r_elf_add_symbol_hook
4046 #define elf_backend_relocate_section            m32r_elf_relocate_section
4047 #define elf_backend_gc_mark_hook                m32r_elf_gc_mark_hook
4048 #define elf_backend_gc_sweep_hook               m32r_elf_gc_sweep_hook
4049 #define elf_backend_check_relocs                m32r_elf_check_relocs
4050
4051 #define elf_backend_create_dynamic_sections     m32r_elf_create_dynamic_sections
4052 #define bfd_elf32_bfd_link_hash_table_create    m32r_elf_link_hash_table_create
4053 #define elf_backend_size_dynamic_sections       m32r_elf_size_dynamic_sections
4054 #define elf_backend_omit_section_dynsym \
4055   ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
4056 #define elf_backend_finish_dynamic_sections     m32r_elf_finish_dynamic_sections
4057 #define elf_backend_adjust_dynamic_symbol       m32r_elf_adjust_dynamic_symbol
4058 #define elf_backend_finish_dynamic_symbol       m32r_elf_finish_dynamic_symbol
4059 #define elf_backend_reloc_type_class            m32r_elf_reloc_type_class
4060 #define elf_backend_copy_indirect_symbol        m32r_elf_copy_indirect_symbol
4061
4062 #define elf_backend_can_gc_sections             1
4063 /*#if !USE_REL
4064 #define elf_backend_rela_normal                 1
4065 #endif*/
4066 #define elf_backend_can_refcount 1
4067 #define elf_backend_want_got_plt 1
4068 #define elf_backend_plt_readonly 1
4069 #define elf_backend_want_plt_sym 0
4070 #define elf_backend_got_header_size 12
4071
4072 #define elf_backend_may_use_rel_p       1
4073 #ifdef USE_M32R_OLD_RELOC
4074 #define elf_backend_default_use_rela_p  0
4075 #define elf_backend_may_use_rela_p      0
4076 #else
4077 #define elf_backend_default_use_rela_p  1
4078 #define elf_backend_may_use_rela_p      1
4079 #endif
4080
4081 #define elf_backend_object_p                    m32r_elf_object_p
4082 #define elf_backend_final_write_processing      m32r_elf_final_write_processing
4083 #define bfd_elf32_bfd_merge_private_bfd_data    m32r_elf_merge_private_bfd_data
4084 #define bfd_elf32_bfd_set_private_flags         m32r_elf_set_private_flags
4085 #define bfd_elf32_bfd_print_private_bfd_data    m32r_elf_print_private_bfd_data
4086 #define elf_backend_special_sections            m32r_elf_special_sections
4087
4088 #include "elf32-target.h"
4089
4090 #undef  ELF_MAXPAGESIZE
4091 #define ELF_MAXPAGESIZE         0x1000
4092
4093 #undef  TARGET_BIG_SYM
4094 #define TARGET_BIG_SYM          bfd_elf32_m32rlin_vec
4095 #undef  TARGET_BIG_NAME
4096 #define TARGET_BIG_NAME         "elf32-m32r-linux"
4097 #undef  TARGET_LITTLE_SYM
4098 #define TARGET_LITTLE_SYM       bfd_elf32_m32rlelin_vec
4099 #undef  TARGET_LITTLE_NAME
4100 #define TARGET_LITTLE_NAME      "elf32-m32rle-linux"
4101 #undef  elf32_bed
4102 #define elf32_bed               elf32_m32r_lin_bed
4103
4104 #include "elf32-target.h"
4105