Use _bfd_elf_copy_private_bfd_data
[external/binutils.git] / bfd / elf32-iq2000.c
1 /* IQ2000-specific support for 32-bit ELF.
2    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2010, 2012
3    Free Software Foundation, Inc.
4
5    This file is part of BFD, the Binary File Descriptor library.
6
7    This program is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 3 of the License, or
10    (at your option) any later version.
11
12    This program is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with this program; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
20
21 #include "sysdep.h"
22 #include "bfd.h"
23 #include "libbfd.h"
24 #include "elf-bfd.h"
25 #include "elf/iq2000.h"
26
27 /* Forward declarations.  */
28
29 static bfd_reloc_status_type iq2000_elf_howto_hi16_reloc (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
30
31 \f
32 static reloc_howto_type iq2000_elf_howto_table [] =
33 {
34   /* This reloc does nothing.  */
35
36   HOWTO (R_IQ2000_NONE,              /* type */
37          0,                          /* rightshift */
38          2,                          /* size (0 = byte, 1 = short, 2 = long) */
39          32,                         /* bitsize */
40          FALSE,                      /* pc_relative */
41          0,                          /* bitpos */
42          complain_overflow_bitfield, /* complain_on_overflow */
43          bfd_elf_generic_reloc,      /* special_function */
44          "R_IQ2000_NONE",            /* name */
45          FALSE,                      /* partial_inplace */
46          0,                          /* src_mask */
47          0,                          /* dst_mask */
48          FALSE),                     /* pcrel_offset */
49
50   /* A 16 bit absolute relocation.  */
51   HOWTO (R_IQ2000_16,                /* type */
52          0,                          /* rightshift */
53          1,                          /* size (0 = byte, 1 = short, 2 = long) */
54          16,                         /* bitsize */
55          FALSE,                      /* pc_relative */
56          0,                          /* bitpos */
57          complain_overflow_bitfield, /* complain_on_overflow */
58          bfd_elf_generic_reloc,      /* special_function */
59          "R_IQ2000_16",              /* name */
60          FALSE,                      /* partial_inplace */
61          0x0000,                     /* src_mask */
62          0xffff,                     /* dst_mask */
63          FALSE),                     /* pcrel_offset */
64
65   /* A 32 bit absolute relocation.  */
66   HOWTO (R_IQ2000_32,                /* type */
67          0,                          /* rightshift */
68          2,                          /* size (0 = byte, 1 = short, 2 = long) */
69          31,                         /* bitsize */
70          FALSE,                      /* pc_relative */
71          0,                          /* bitpos */
72          complain_overflow_bitfield, /* complain_on_overflow */
73          bfd_elf_generic_reloc,      /* special_function */
74          "R_IQ2000_32",              /* name */
75          FALSE,                      /* partial_inplace */
76          0x00000000,                 /* src_mask */
77          0x7fffffff,                 /* dst_mask */
78          FALSE),                     /* pcrel_offset */
79
80   /* 26 bit branch address.  */
81   HOWTO (R_IQ2000_26,           /* type */
82          2,                     /* rightshift */
83          2,                     /* size (0 = byte, 1 = short, 2 = long) */
84          26,                    /* bitsize */
85          FALSE,                 /* pc_relative */
86          0,                     /* bitpos */
87          complain_overflow_dont, /* complain_on_overflow */
88                                 /* This needs complex overflow
89                                    detection, because the upper four
90                                    bits must match the PC.  */
91          bfd_elf_generic_reloc, /* special_function */
92          "R_IQ2000_26",         /* name */
93          FALSE,                 /* partial_inplace */
94          0x00000000,            /* src_mask */
95          0x03ffffff,            /* dst_mask */
96          FALSE),                /* pcrel_offset */
97
98   /* 16 bit PC relative reference.  */
99   HOWTO (R_IQ2000_PC16,         /* type */
100          2,                     /* rightshift */
101          2,                     /* size (0 = byte, 1 = short, 2 = long) */
102          16,                    /* bitsize */
103          TRUE,                  /* pc_relative */
104          0,                     /* bitpos */
105          complain_overflow_signed, /* complain_on_overflow */
106          bfd_elf_generic_reloc, /* special_function */
107          "R_IQ2000_PC16",       /* name */
108          FALSE,                 /* partial_inplace */
109          0x0000,                /* src_mask */
110          0xffff,                /* dst_mask */
111          TRUE),                 /* pcrel_offset */
112
113   /* high 16 bits of symbol value.  */
114   HOWTO (R_IQ2000_HI16,         /* type */
115          16,                    /* rightshift */
116          2,                     /* size (0 = byte, 1 = short, 2 = long) */
117          15,                    /* bitsize */
118          FALSE,                 /* pc_relative */
119          0,                     /* bitpos */
120          complain_overflow_dont, /* complain_on_overflow */
121          iq2000_elf_howto_hi16_reloc,   /* special_function */
122          "R_IQ2000_HI16",       /* name */
123          FALSE,                 /* partial_inplace */
124          0x0000,                /* src_mask */
125          0x7fff,                /* dst_mask */
126          FALSE),                /* pcrel_offset */
127
128   /* Low 16 bits of symbol value.  */
129   HOWTO (R_IQ2000_LO16,         /* type */
130          0,                     /* rightshift */
131          2,                     /* size (0 = byte, 1 = short, 2 = long) */
132          16,                    /* bitsize */
133          FALSE,                 /* pc_relative */
134          0,                     /* bitpos */
135          complain_overflow_dont, /* complain_on_overflow */
136          bfd_elf_generic_reloc, /* special_function */
137          "R_IQ2000_LO16",       /* name */
138          FALSE,                 /* partial_inplace */
139          0x0000,                /* src_mask */
140          0xffff,                /* dst_mask */
141          FALSE),                /* pcrel_offset */
142
143   /* 16-bit jump offset.  */
144   HOWTO (R_IQ2000_OFFSET_16,    /* type */
145          2,                     /* rightshift */
146          2,                     /* size (0 = byte, 1 = short, 2 = long) */
147          16,                    /* bitsize */
148          FALSE,                 /* pc_relative */
149          0,                     /* bitpos */
150          complain_overflow_dont, /* complain_on_overflow */
151          bfd_elf_generic_reloc, /* special_function */
152          "R_IQ2000_OFFSET_16",  /* name */
153          FALSE,                 /* partial_inplace */
154          0x0000,                /* src_mask */
155          0xffff,                /* dst_mask */
156          FALSE),                /* pcrel_offset */
157
158   /* 21-bit jump offset.  */
159   HOWTO (R_IQ2000_OFFSET_21,    /* type */
160          2,                     /* rightshift */
161          2,                     /* size (0 = byte, 1 = short, 2 = long) */
162          21,                    /* bitsize */
163          FALSE,                 /* pc_relative */
164          0,                     /* bitpos */
165          complain_overflow_dont, /* complain_on_overflow */
166          bfd_elf_generic_reloc, /* special_function */
167          "R_IQ2000_OFFSET_21",  /* name */
168          FALSE,                 /* partial_inplace */
169          0x000000,              /* src_mask */
170          0x1fffff,              /* dst_mask */
171          FALSE),                /* pcrel_offset */
172
173   /* unsigned high 16 bits of value.  */
174   HOWTO (R_IQ2000_OFFSET_21,    /* type */
175          16,                    /* rightshift */
176          2,                     /* size (0 = byte, 1 = short, 2 = long) */
177          16,                    /* bitsize */
178          FALSE,                 /* pc_relative */
179          0,                     /* bitpos */
180          complain_overflow_dont, /* complain_on_overflow */
181          bfd_elf_generic_reloc, /* special_function */
182          "R_IQ2000_UHI16",      /* name */
183          FALSE,                 /* partial_inplace */
184          0x0000,                /* src_mask */
185          0x7fff,                /* dst_mask */
186          FALSE),                /* pcrel_offset */
187
188   /* A 32 bit absolute debug relocation.  */
189   HOWTO (R_IQ2000_32_DEBUG,          /* type */
190          0,                          /* rightshift */
191          2,                          /* size (0 = byte, 1 = short, 2 = long) */
192          32,                         /* bitsize */
193          FALSE,                      /* pc_relative */
194          0,                          /* bitpos */
195          complain_overflow_bitfield, /* complain_on_overflow */
196          bfd_elf_generic_reloc,      /* special_function */
197          "R_IQ2000_32",              /* name */
198          FALSE,                      /* partial_inplace */
199          0x00000000,                 /* src_mask */
200          0xffffffff,                 /* dst_mask */
201          FALSE),                     /* pcrel_offset */
202
203 };
204
205 /* GNU extension to record C++ vtable hierarchy.  */
206 static reloc_howto_type iq2000_elf_vtinherit_howto =
207   HOWTO (R_IQ2000_GNU_VTINHERIT,    /* type */
208          0,                        /* rightshift */
209          2,                        /* size (0 = byte, 1 = short, 2 = long) */
210          0,                        /* bitsize */
211          FALSE,                    /* pc_relative */
212          0,                        /* bitpos */
213          complain_overflow_dont,   /* complain_on_overflow */
214          NULL,                     /* special_function */
215          "R_IQ2000_GNU_VTINHERIT",  /* name */
216          FALSE,                    /* partial_inplace */
217          0,                        /* src_mask */
218          0,                        /* dst_mask */
219          FALSE);                   /* pcrel_offset */
220
221 /* GNU extension to record C++ vtable member usage.  */
222 static reloc_howto_type iq2000_elf_vtentry_howto =
223   HOWTO (R_IQ2000_GNU_VTENTRY,     /* type */
224          0,                        /* rightshift */
225          2,                        /* size (0 = byte, 1 = short, 2 = long) */
226          0,                        /* bitsize */
227          FALSE,                    /* pc_relative */
228          0,                        /* bitpos */
229          complain_overflow_dont,   /* complain_on_overflow */
230          NULL,                     /* special_function */
231          "R_IQ2000_GNU_VTENTRY",    /* name */
232          FALSE,                    /* partial_inplace */
233          0,                        /* src_mask */
234          0,                        /* dst_mask */
235          FALSE);                   /* pcrel_offset */
236
237 \f
238 static bfd_reloc_status_type
239 iq2000_elf_howto_hi16_reloc (bfd *abfd ATTRIBUTE_UNUSED,
240                              arelent *reloc_entry,
241                              asymbol *symbol,
242                              void * data,
243                              asection *input_section,
244                              bfd *output_bfd,
245                              char **error_message ATTRIBUTE_UNUSED)
246 {
247   bfd_reloc_status_type ret;
248   bfd_vma relocation;
249
250   /* If we're relocating and this an external symbol,
251      we don't want to change anything.  */
252   if (output_bfd != (bfd *) NULL
253       && (symbol->flags & BSF_SECTION_SYM) == 0
254       && reloc_entry->addend == 0)
255     {
256       reloc_entry->address += input_section->output_offset;
257       return bfd_reloc_ok;
258     }
259
260   if (bfd_is_com_section (symbol->section))
261     relocation = 0;
262   else
263     relocation = symbol->value;
264
265   relocation += symbol->section->output_section->vma;
266   relocation += symbol->section->output_offset;
267   relocation += reloc_entry->addend;
268
269   /* If %lo will have sign-extension, compensate by add 0x10000 to hi portion.  */
270   if (relocation & 0x8000)
271     reloc_entry->addend += 0x10000;
272
273   /* Now do the reloc in the usual way.  */
274   ret = bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
275                                 input_section, output_bfd, error_message);
276
277   /* Put it back the way it was.  */
278   if (relocation & 0x8000)
279     reloc_entry->addend -= 0x10000;
280
281   return ret;
282 }
283
284 static bfd_reloc_status_type
285 iq2000_elf_relocate_hi16 (bfd *input_bfd,
286                           Elf_Internal_Rela *relhi,
287                           bfd_byte *contents,
288                           bfd_vma value)
289 {
290   bfd_vma insn;
291
292   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
293
294   value += relhi->r_addend;
295   value &= 0x7fffffff; /* Mask off top-bit which is Harvard mask bit.  */
296
297   /* If top-bit of %lo value is on, this means that %lo will
298      sign-propagate and so we compensate by adding 1 to %hi value.  */
299   if (value & 0x8000)
300     value += 0x10000;
301
302   value >>= 16;
303   insn = ((insn & ~0xFFFF) | value);
304
305   bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
306   return bfd_reloc_ok;
307 }
308
309 static bfd_reloc_status_type
310 iq2000_elf_relocate_offset16 (bfd *input_bfd,
311                               Elf_Internal_Rela *rel,
312                               bfd_byte *contents,
313                               bfd_vma value,
314                               bfd_vma location)
315 {
316   bfd_vma insn;
317   bfd_vma jtarget;
318
319   insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
320
321   value += rel->r_addend;
322
323   if (value & 3)
324     return bfd_reloc_dangerous;
325
326   jtarget = (value & 0x3fffc) | (location & 0xf0000000L);
327
328   if (jtarget != value)
329     return bfd_reloc_overflow;
330
331   insn = (insn & ~0xFFFF) | ((value >> 2) & 0xFFFF);
332
333   bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
334   return bfd_reloc_ok;
335 }
336
337 /* Map BFD reloc types to IQ2000 ELF reloc types.  */
338
339 static reloc_howto_type *
340 iq2000_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
341                           bfd_reloc_code_real_type code)
342 {
343   /* Note that the iq2000_elf_howto_table is indxed by the R_
344      constants.  Thus, the order that the howto records appear in the
345      table *must* match the order of the relocation types defined in
346      include/elf/iq2000.h.  */
347
348   switch (code)
349     {
350     case BFD_RELOC_NONE:
351       return &iq2000_elf_howto_table[ (int) R_IQ2000_NONE];
352     case BFD_RELOC_16:
353       return &iq2000_elf_howto_table[ (int) R_IQ2000_16];
354     case BFD_RELOC_32:
355       return &iq2000_elf_howto_table[ (int) R_IQ2000_32];
356     case BFD_RELOC_MIPS_JMP:
357       return &iq2000_elf_howto_table[ (int) R_IQ2000_26];
358     case BFD_RELOC_IQ2000_OFFSET_16:
359       return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_16];
360     case BFD_RELOC_IQ2000_OFFSET_21:
361       return &iq2000_elf_howto_table[ (int) R_IQ2000_OFFSET_21];
362     case BFD_RELOC_16_PCREL_S2:
363       return &iq2000_elf_howto_table[ (int) R_IQ2000_PC16];
364     case BFD_RELOC_HI16:
365       return &iq2000_elf_howto_table[ (int) R_IQ2000_HI16];
366     case BFD_RELOC_IQ2000_UHI16:
367       return &iq2000_elf_howto_table[ (int) R_IQ2000_UHI16];
368     case BFD_RELOC_LO16:
369       return &iq2000_elf_howto_table[ (int) R_IQ2000_LO16];
370     case BFD_RELOC_VTABLE_INHERIT:
371       return &iq2000_elf_vtinherit_howto;
372     case BFD_RELOC_VTABLE_ENTRY:
373       return &iq2000_elf_vtentry_howto;
374     default:
375       /* Pacify gcc -Wall.  */
376       return NULL;
377     }
378   return NULL;
379 }
380
381 static reloc_howto_type *
382 iq2000_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
383 {
384   unsigned int i;
385
386   for (i = 0;
387        i < (sizeof (iq2000_elf_howto_table)
388             / sizeof (iq2000_elf_howto_table[0]));
389        i++)
390     if (iq2000_elf_howto_table[i].name != NULL
391         && strcasecmp (iq2000_elf_howto_table[i].name, r_name) == 0)
392       return &iq2000_elf_howto_table[i];
393
394   if (strcasecmp (iq2000_elf_vtinherit_howto.name, r_name) == 0)
395     return &iq2000_elf_vtinherit_howto;
396   if (strcasecmp (iq2000_elf_vtentry_howto.name, r_name) == 0)
397     return &iq2000_elf_vtentry_howto;
398
399   return NULL;
400 }
401 \f
402 /* Perform a single relocation.  By default we use the standard BFD
403    routines.  */
404
405 static bfd_reloc_status_type
406 iq2000_final_link_relocate (reloc_howto_type *  howto,
407                             bfd *               input_bfd,
408                             asection *          input_section,
409                             bfd_byte *          contents,
410                             Elf_Internal_Rela * rel,
411                             bfd_vma             relocation)
412 {
413   return _bfd_final_link_relocate (howto, input_bfd, input_section,
414                                    contents, rel->r_offset,
415                                    relocation, rel->r_addend);
416 }
417 \f
418 /* Set the howto pointer for a IQ2000 ELF reloc.  */
419
420 static void
421 iq2000_info_to_howto_rela (bfd * abfd ATTRIBUTE_UNUSED,
422                            arelent * cache_ptr,
423                            Elf_Internal_Rela * dst)
424 {
425   unsigned int r_type;
426
427   r_type = ELF32_R_TYPE (dst->r_info);
428   switch (r_type)
429     {
430     case R_IQ2000_GNU_VTINHERIT:
431       cache_ptr->howto = & iq2000_elf_vtinherit_howto;
432       break;
433
434     case R_IQ2000_GNU_VTENTRY:
435       cache_ptr->howto = & iq2000_elf_vtentry_howto;
436       break;
437
438     default:
439       cache_ptr->howto = & iq2000_elf_howto_table [r_type];
440       break;
441     }
442 }
443
444 /* Look through the relocs for a section during the first phase.
445    Since we don't do .gots or .plts, we just need to consider the
446    virtual table relocs for gc.  */
447
448 static bfd_boolean
449 iq2000_elf_check_relocs (bfd *abfd,
450                          struct bfd_link_info *info,
451                          asection *sec,
452                          const Elf_Internal_Rela *relocs)
453 {
454   Elf_Internal_Shdr *symtab_hdr;
455   struct elf_link_hash_entry **sym_hashes;
456   const Elf_Internal_Rela *rel;
457   const Elf_Internal_Rela *rel_end;
458   bfd_boolean changed = FALSE;
459
460   if (info->relocatable)
461     return TRUE;
462
463   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
464   sym_hashes = elf_sym_hashes (abfd);
465
466   rel_end = relocs + sec->reloc_count;
467   for (rel = relocs; rel < rel_end; rel++)
468     {
469       struct elf_link_hash_entry *h;
470       unsigned long r_symndx;
471
472       r_symndx = ELF32_R_SYM (rel->r_info);
473       if (r_symndx < symtab_hdr->sh_info)
474         h = NULL;
475       else
476         {
477           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
478           while (h->root.type == bfd_link_hash_indirect
479                  || h->root.type == bfd_link_hash_warning)
480             h = (struct elf_link_hash_entry *) h->root.u.i.link;
481
482           /* PR15323, ref flags aren't set for references in the same
483              object.  */
484           h->root.non_ir_ref = 1;
485         }
486
487       switch (ELF32_R_TYPE (rel->r_info))
488         {
489           /* This relocation describes the C++ object vtable
490              hierarchy.  Reconstruct it for later use during GC.  */
491         case R_IQ2000_GNU_VTINHERIT:
492           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
493             return FALSE;
494           break;
495
496           /* This relocation describes which C++ vtable entries
497              are actually used.  Record for later use during GC.  */
498         case R_IQ2000_GNU_VTENTRY:
499           BFD_ASSERT (h != NULL);
500           if (h != NULL
501               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
502             return FALSE;
503           break;
504
505         case R_IQ2000_32:
506           /* For debug section, change to special harvard-aware relocations.  */
507           if (CONST_STRNEQ (sec->name, ".debug")
508               || CONST_STRNEQ (sec->name, ".stab")
509               || CONST_STRNEQ (sec->name, ".eh_frame"))
510             {
511               ((Elf_Internal_Rela *) rel)->r_info
512                 = ELF32_R_INFO (ELF32_R_SYM (rel->r_info), R_IQ2000_32_DEBUG);
513               changed = TRUE;
514             }
515           break;
516         }
517     }
518
519   if (changed)
520     /* Note that we've changed relocs, otherwise if !info->keep_memory
521        we'll free the relocs and lose our changes.  */
522     elf_section_data (sec)->relocs = (Elf_Internal_Rela *) relocs;
523
524   return TRUE;
525 }
526
527 \f
528 /* Relocate a IQ2000 ELF section.
529    There is some attempt to make this function usable for many architectures,
530    both USE_REL and USE_RELA ['twould be nice if such a critter existed],
531    if only to serve as a learning tool.
532
533    The RELOCATE_SECTION function is called by the new ELF backend linker
534    to handle the relocations for a section.
535
536    The relocs are always passed as Rela structures; if the section
537    actually uses Rel structures, the r_addend field will always be
538    zero.
539
540    This function is responsible for adjusting the section contents as
541    necessary, and (if using Rela relocs and generating a relocatable
542    output file) adjusting the reloc addend as necessary.
543
544    This function does not have to worry about setting the reloc
545    address or the reloc symbol index.
546
547    LOCAL_SYMS is a pointer to the swapped in local symbols.
548
549    LOCAL_SECTIONS is an array giving the section in the input file
550    corresponding to the st_shndx field of each local symbol.
551
552    The global hash table entry for the global symbols can be found
553    via elf_sym_hashes (input_bfd).
554
555    When generating relocatable output, this function must handle
556    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
557    going to be the section symbol corresponding to the output
558    section, which means that the addend must be adjusted
559    accordingly.  */
560
561 static bfd_boolean
562 iq2000_elf_relocate_section (bfd *                   output_bfd ATTRIBUTE_UNUSED,
563                              struct bfd_link_info *  info,
564                              bfd *                   input_bfd,
565                              asection *              input_section,
566                              bfd_byte *              contents,
567                              Elf_Internal_Rela *     relocs,
568                              Elf_Internal_Sym *      local_syms,
569                              asection **             local_sections)
570 {
571   Elf_Internal_Shdr *           symtab_hdr;
572   struct elf_link_hash_entry ** sym_hashes;
573   Elf_Internal_Rela *           rel;
574   Elf_Internal_Rela *           relend;
575
576   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
577   sym_hashes = elf_sym_hashes (input_bfd);
578   relend     = relocs + input_section->reloc_count;
579
580   for (rel = relocs; rel < relend; rel ++)
581     {
582       reloc_howto_type *           howto;
583       unsigned long                r_symndx;
584       Elf_Internal_Sym *           sym;
585       asection *                   sec;
586       struct elf_link_hash_entry * h;
587       bfd_vma                      relocation;
588       bfd_reloc_status_type        r;
589       const char *                 name = NULL;
590       int                          r_type;
591
592       r_type = ELF32_R_TYPE (rel->r_info);
593
594       if (   r_type == R_IQ2000_GNU_VTINHERIT
595           || r_type == R_IQ2000_GNU_VTENTRY)
596         continue;
597
598       r_symndx = ELF32_R_SYM (rel->r_info);
599
600       howto  = iq2000_elf_howto_table + ELF32_R_TYPE (rel->r_info);
601       h      = NULL;
602       sym    = NULL;
603       sec    = NULL;
604
605       if (r_symndx < symtab_hdr->sh_info)
606         {
607           asection *osec;
608
609           sym = local_syms + r_symndx;
610           osec = sec = local_sections [r_symndx];
611           if ((sec->flags & SEC_MERGE)
612               && ELF_ST_TYPE (sym->st_info) == STT_SECTION)
613             /* This relocation is relative to a section symbol that is
614                going to be merged.  Change it so that it is relative
615                to the merged section symbol.  */
616             rel->r_addend = _bfd_elf_rel_local_sym (output_bfd, sym, &sec,
617                                                     rel->r_addend);
618
619           relocation = (sec->output_section->vma
620                         + sec->output_offset
621                         + sym->st_value);
622
623           name = bfd_elf_string_from_elf_section
624             (input_bfd, symtab_hdr->sh_link, sym->st_name);
625           name = (name == NULL) ? bfd_section_name (input_bfd, osec) : name;
626         }
627       else
628         {
629           bfd_boolean unresolved_reloc;
630           bfd_boolean warned, ignored;
631
632           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
633                                    r_symndx, symtab_hdr, sym_hashes,
634                                    h, sec, relocation,
635                                    unresolved_reloc, warned, ignored);
636
637           name = h->root.root.string;
638         }
639
640       if (sec != NULL && discarded_section (sec))
641         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
642                                          rel, 1, relend, howto, 0, contents);
643
644       if (info->relocatable)
645         continue;
646
647       switch (r_type)
648         {
649         case R_IQ2000_HI16:
650           r = iq2000_elf_relocate_hi16 (input_bfd, rel, contents, relocation);
651           break;
652
653         case R_IQ2000_OFFSET_16:
654           r = iq2000_elf_relocate_offset16 (input_bfd, rel, contents, relocation,
655                                             input_section->output_section->vma
656                                             + input_section->output_offset
657                                             + rel->r_offset);
658           break;
659
660         case R_IQ2000_PC16:
661           rel->r_addend -= 4;
662           /* Fall through.  */
663
664         default:
665           r = iq2000_final_link_relocate (howto, input_bfd, input_section,
666                                          contents, rel, relocation);
667           break;
668         }
669
670       if (r != bfd_reloc_ok)
671         {
672           const char * msg = (const char *) NULL;
673
674           switch (r)
675             {
676             case bfd_reloc_overflow:
677               r = info->callbacks->reloc_overflow
678                 (info, (h ? &h->root : NULL), name, howto->name,
679                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
680               break;
681
682             case bfd_reloc_undefined:
683               r = info->callbacks->undefined_symbol
684                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
685               break;
686
687             case bfd_reloc_outofrange:
688               msg = _("internal error: out of range error");
689               break;
690
691             case bfd_reloc_notsupported:
692               msg = _("internal error: unsupported relocation error");
693               break;
694
695             case bfd_reloc_dangerous:
696               msg = _("internal error: dangerous relocation");
697               break;
698
699             default:
700               msg = _("internal error: unknown error");
701               break;
702             }
703
704           if (msg)
705             r = info->callbacks->warning
706               (info, msg, name, input_bfd, input_section, rel->r_offset);
707
708           if (! r)
709             return FALSE;
710         }
711     }
712
713   return TRUE;
714 }
715 \f
716
717 /* Return the section that should be marked against GC for a given
718    relocation.  */
719
720 static asection *
721 iq2000_elf_gc_mark_hook (asection *sec,
722                          struct bfd_link_info *info,
723                          Elf_Internal_Rela *rel,
724                          struct elf_link_hash_entry *h,
725                          Elf_Internal_Sym *sym)
726 {
727   if (h != NULL)
728     switch (ELF32_R_TYPE (rel->r_info))
729       {
730       case R_IQ2000_GNU_VTINHERIT:
731       case R_IQ2000_GNU_VTENTRY:
732         return NULL;
733       }
734
735   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
736 }
737
738 \f
739 /* Return the MACH for an e_flags value.  */
740
741 static int
742 elf32_iq2000_machine (bfd *abfd)
743 {
744   switch (elf_elfheader (abfd)->e_flags & EF_IQ2000_CPU_MASK)
745     {
746     case EF_IQ2000_CPU_IQ10:
747       return bfd_mach_iq10;
748
749     case EF_IQ2000_CPU_IQ2000:
750     default:
751       return bfd_mach_iq2000;
752     }
753 }
754
755 \f
756 /* Function to set the ELF flag bits.  */
757
758 static bfd_boolean
759 iq2000_elf_set_private_flags (bfd *abfd, flagword flags)
760 {
761   elf_elfheader (abfd)->e_flags = flags;
762   elf_flags_init (abfd) = TRUE;
763   return TRUE;
764 }
765
766 /* Merge backend specific data from an object
767    file to the output object file when linking.  */
768
769 static bfd_boolean
770 iq2000_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
771 {
772   flagword old_flags, old_partial;
773   flagword new_flags, new_partial;
774   bfd_boolean error = FALSE;
775   char new_opt[80];
776   char old_opt[80];
777
778   new_opt[0] = old_opt[0] = '\0';
779   new_flags = elf_elfheader (ibfd)->e_flags;
780   old_flags = elf_elfheader (obfd)->e_flags;
781
782   if (!elf_flags_init (obfd))
783     {
784       /* First call, no flags set.  */
785       elf_flags_init (obfd) = TRUE;
786       elf_elfheader (obfd)->e_flags = new_flags;
787     }
788
789   else if (new_flags != old_flags)
790     {
791       /* Warn if different cpu is used, but allow a
792          specific cpu to override the generic cpu.  */
793       new_partial = (new_flags & EF_IQ2000_CPU_MASK);
794       old_partial = (old_flags & EF_IQ2000_CPU_MASK);
795
796       if (new_partial != old_partial)
797         {
798           switch (new_partial)
799             {
800             case EF_IQ2000_CPU_IQ10:
801               strcat (new_opt, " -m10");
802               break;
803
804             default:
805             case EF_IQ2000_CPU_IQ2000:
806               strcat (new_opt, " -m2000");
807               break;
808             }
809
810           switch (old_partial)
811             {
812             case EF_IQ2000_CPU_IQ10:
813               strcat (old_opt, " -m10");
814               break;
815
816             default:
817             case EF_IQ2000_CPU_IQ2000:
818               strcat (old_opt, " -m2000");
819               break;
820             }
821         }
822
823       /* Print out any mismatches from above.  */
824       if (new_opt[0])
825         {
826           error = TRUE;
827           _bfd_error_handler
828             (_("%s: compiled with %s and linked with modules compiled with %s"),
829              bfd_get_filename (ibfd), new_opt, old_opt);
830         }
831
832       new_flags &= ~ EF_IQ2000_ALL_FLAGS;
833       old_flags &= ~ EF_IQ2000_ALL_FLAGS;
834
835       /* Warn about any other mismatches.  */
836       if (new_flags != old_flags)
837         {
838           error = TRUE;
839
840           _bfd_error_handler
841             (_("%s: uses different e_flags (0x%lx) fields than previous modules (0x%lx)"),
842              bfd_get_filename (ibfd), (long)new_flags, (long)old_flags);
843         }
844     }
845
846   if (error)
847     bfd_set_error (bfd_error_bad_value);
848
849   return !error;
850 }
851
852 \f
853 static bfd_boolean
854 iq2000_elf_print_private_bfd_data (bfd *abfd, void * ptr)
855 {
856   FILE *file = (FILE *) ptr;
857   flagword flags;
858
859   BFD_ASSERT (abfd != NULL && ptr != NULL);
860
861   /* Print normal ELF private data.  */
862   _bfd_elf_print_private_bfd_data (abfd, ptr);
863
864   flags = elf_elfheader (abfd)->e_flags;
865   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
866
867   switch (flags & EF_IQ2000_CPU_MASK)
868     {
869     case EF_IQ2000_CPU_IQ10:
870       fprintf (file, " -m10");
871       break;
872     case EF_IQ2000_CPU_IQ2000:
873       fprintf (file, " -m2000");
874       break;
875     default:
876       break;
877     }
878
879   fputc ('\n', file);
880   return TRUE;
881 }
882
883 static
884 bfd_boolean
885 iq2000_elf_object_p (bfd *abfd)
886 {
887   bfd_default_set_arch_mach (abfd, bfd_arch_iq2000,
888                              elf32_iq2000_machine (abfd));
889   return TRUE;
890 }
891
892 \f
893 #define ELF_ARCH                bfd_arch_iq2000
894 #define ELF_MACHINE_CODE        EM_IQ2000
895 #define ELF_MAXPAGESIZE         0x1000
896
897 #define TARGET_BIG_SYM          bfd_elf32_iq2000_vec
898 #define TARGET_BIG_NAME         "elf32-iq2000"
899
900 #define elf_info_to_howto_rel                   NULL
901 #define elf_info_to_howto                       iq2000_info_to_howto_rela
902 #define elf_backend_relocate_section            iq2000_elf_relocate_section
903 #define elf_backend_gc_mark_hook                iq2000_elf_gc_mark_hook
904 #define elf_backend_check_relocs                iq2000_elf_check_relocs
905 #define elf_backend_object_p                    iq2000_elf_object_p
906 #define elf_backend_rela_normal                 1
907
908 #define elf_backend_can_gc_sections             1
909
910 #define bfd_elf32_bfd_reloc_type_lookup         iq2000_reloc_type_lookup
911 #define bfd_elf32_bfd_reloc_name_lookup iq2000_reloc_name_lookup
912 #define bfd_elf32_bfd_set_private_flags         iq2000_elf_set_private_flags
913 #define bfd_elf32_bfd_merge_private_bfd_data    iq2000_elf_merge_private_bfd_data
914 #define bfd_elf32_bfd_print_private_bfd_data    iq2000_elf_print_private_bfd_data
915
916 #include "elf32-target.h"