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