Fix spelling typos.
[external/binutils.git] / bfd / elf32-v850.c
1 /* V850-specific support for 32-bit ELF
2    Copyright (C) 1996-2017 Free Software Foundation, Inc.
3
4    This file is part of BFD, the Binary File Descriptor library.
5
6    This program is free software; you can redistribute it and/or modify
7    it under the terms of the GNU General Public License as published by
8    the Free Software Foundation; either version 3 of the License, or
9    (at your option) any later version.
10
11    This program is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14    GNU General Public License for more details.
15
16    You should have received a copy of the GNU General Public License
17    along with this program; if not, write to the Free Software
18    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
19    MA 02110-1301, USA.  */
20
21
22 /* XXX FIXME: This code is littered with 32bit int, 16bit short, 8bit char
23    dependencies.  As is the gas & simulator code for the v850.  */
24
25 #include "sysdep.h"
26 #include "bfd.h"
27 #include "bfdlink.h"
28 #include "libbfd.h"
29 #include "elf-bfd.h"
30 #include "elf/v850.h"
31 #include "libiberty.h"
32
33 /* Sign-extend a 17-bit number.  */
34 #define SEXT17(x)       ((((x) & 0x1ffff) ^ 0x10000) - 0x10000)
35
36 /* Sign-extend a 22-bit number.  */
37 #define SEXT22(x)       ((((x) & 0x3fffff) ^ 0x200000) - 0x200000)
38
39 static reloc_howto_type v850_elf_howto_table[];
40
41 /* Look through the relocs for a section during the first phase, and
42    allocate space in the global offset table or procedure linkage
43    table.  */
44
45 static bfd_boolean
46 v850_elf_check_relocs (bfd *abfd,
47                        struct bfd_link_info *info,
48                        asection *sec,
49                        const Elf_Internal_Rela *relocs)
50 {
51   bfd_boolean ret = TRUE;
52   Elf_Internal_Shdr *symtab_hdr;
53   struct elf_link_hash_entry **sym_hashes;
54   const Elf_Internal_Rela *rel;
55   const Elf_Internal_Rela *rel_end;
56   unsigned int r_type;
57   int other = 0;
58   const char *common = NULL;
59
60   if (bfd_link_relocatable (info))
61     return TRUE;
62
63 #ifdef DEBUG
64   _bfd_error_handler ("v850_elf_check_relocs called for section %A in %B",
65                       sec, abfd);
66 #endif
67
68   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
69   sym_hashes = elf_sym_hashes (abfd);
70
71   rel_end = relocs + sec->reloc_count;
72   for (rel = relocs; rel < rel_end; rel++)
73     {
74       unsigned long r_symndx;
75       struct elf_link_hash_entry *h;
76
77       r_symndx = ELF32_R_SYM (rel->r_info);
78       if (r_symndx < symtab_hdr->sh_info)
79         h = NULL;
80       else
81         {
82           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
83           while (h->root.type == bfd_link_hash_indirect
84                  || h->root.type == bfd_link_hash_warning)
85             h = (struct elf_link_hash_entry *) h->root.u.i.link;
86
87           /* PR15323, ref flags aren't set for references in the same
88              object.  */
89           h->root.non_ir_ref_regular = 1;
90         }
91
92       r_type = ELF32_R_TYPE (rel->r_info);
93       switch (r_type)
94         {
95         default:
96           break;
97
98         /* This relocation describes the C++ object vtable hierarchy.
99            Reconstruct it for later use during GC.  */
100         case R_V850_GNU_VTINHERIT:
101           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
102             return FALSE;
103           break;
104
105         /* This relocation describes which C++ vtable entries
106            are actually used.  Record for later use during GC.  */
107         case R_V850_GNU_VTENTRY:
108           BFD_ASSERT (h != NULL);
109           if (h != NULL
110               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
111             return FALSE;
112           break;
113
114         case R_V850_SDA_16_16_SPLIT_OFFSET:
115         case R_V850_SDA_16_16_OFFSET:
116         case R_V850_SDA_15_16_OFFSET:
117         case R_V810_GPWLO_1:
118         case R_V850_HWLO:
119         case R_V850_HWLO_1:
120           other = V850_OTHER_SDA;
121           common = ".scommon";
122           goto small_data_common;
123
124         case R_V850_ZDA_16_16_SPLIT_OFFSET:
125         case R_V850_ZDA_16_16_OFFSET:
126         case R_V850_ZDA_15_16_OFFSET:
127           other = V850_OTHER_ZDA;
128           common = ".zcommon";
129           goto small_data_common;
130
131         case R_V850_TDA_4_4_OFFSET:
132         case R_V850_TDA_4_5_OFFSET:
133         case R_V850_TDA_7_7_OFFSET:
134         case R_V850_TDA_6_8_OFFSET:
135         case R_V850_TDA_7_8_OFFSET:
136         case R_V850_TDA_16_16_OFFSET:
137           other = V850_OTHER_TDA;
138           common = ".tcommon";
139           /* fall through */
140
141 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
142
143         small_data_common:
144           if (h)
145             {
146               /* Flag which type of relocation was used.  */
147               h->other |= other;
148               if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
149                   && (h->other & V850_OTHER_ERROR) == 0)
150                 {
151                   const char * msg;
152                   static char  buff[200]; /* XXX */
153
154                   switch (h->other & V850_OTHER_MASK)
155                     {
156                     default:
157                       msg = _("Variable `%s' cannot occupy in multiple small data regions");
158                       break;
159                     case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
160                       msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions");
161                       break;
162                     case V850_OTHER_SDA | V850_OTHER_ZDA:
163                       msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously");
164                       break;
165                     case V850_OTHER_SDA | V850_OTHER_TDA:
166                       msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously");
167                       break;
168                     case V850_OTHER_ZDA | V850_OTHER_TDA:
169                       msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously");
170                       break;
171                     }
172
173                   sprintf (buff, msg, h->root.root.string);
174                   info->callbacks->warning (info, buff, h->root.root.string,
175                                             abfd, h->root.u.def.section,
176                                             (bfd_vma) 0);
177
178                   bfd_set_error (bfd_error_bad_value);
179                   h->other |= V850_OTHER_ERROR;
180                   ret = FALSE;
181                 }
182             }
183
184           if (h && h->root.type == bfd_link_hash_common
185               && h->root.u.c.p
186               && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
187             {
188               asection * section;
189
190               section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
191               section->flags |= SEC_IS_COMMON;
192             }
193
194 #ifdef DEBUG
195           fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
196                    v850_elf_howto_table[ (int)r_type ].name,
197                    (h && h->root.root.string) ? h->root.root.string : "<unknown>",
198                    (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
199 #endif
200           break;
201         }
202     }
203
204   return ret;
205 }
206
207 /* In the old version, when an entry was checked out from the table,
208    it was deleted.  This produced an error if the entry was needed
209    more than once, as the second attempted retry failed.
210
211    In the current version, the entry is not deleted, instead we set
212    the field 'found' to TRUE.  If a second lookup matches the same
213    entry, then we know that the hi16s reloc has already been updated
214    and does not need to be updated a second time.
215
216    TODO - TOFIX: If it is possible that we need to restore 2 different
217    addresses from the same table entry, where the first generates an
218    overflow, whilst the second do not, then this code will fail.  */
219
220 typedef struct hi16s_location
221 {
222   bfd_vma                 addend;
223   bfd_byte *              address;
224   unsigned long           counter;
225   bfd_boolean             found;
226   struct hi16s_location * next;
227 }
228 hi16s_location;
229
230 static hi16s_location * previous_hi16s;
231 static hi16s_location * free_hi16s;
232 static unsigned long    hi16s_counter;
233
234 static void
235 remember_hi16s_reloc (bfd *abfd, bfd_vma addend, bfd_byte *address)
236 {
237   hi16s_location * entry = NULL;
238   bfd_size_type amt = sizeof (* free_hi16s);
239
240   /* Find a free structure.  */
241   if (free_hi16s == NULL)
242     free_hi16s = bfd_zalloc (abfd, amt);
243
244   entry      = free_hi16s;
245   free_hi16s = free_hi16s->next;
246
247   entry->addend  = addend;
248   entry->address = address;
249   entry->counter = hi16s_counter ++;
250   entry->found   = FALSE;
251   entry->next    = previous_hi16s;
252   previous_hi16s = entry;
253
254   /* Cope with wrap around of our counter.  */
255   if (hi16s_counter == 0)
256     {
257       /* XXX: Assume that all counter entries differ only in their low 16 bits.  */
258       for (entry = previous_hi16s; entry != NULL; entry = entry->next)
259         entry->counter &= 0xffff;
260
261       hi16s_counter = 0x10000;
262     }
263 }
264
265 static bfd_byte *
266 find_remembered_hi16s_reloc (bfd_vma addend, bfd_boolean *already_found)
267 {
268   hi16s_location *match = NULL;
269   hi16s_location *entry;
270   bfd_byte *addr;
271
272   /* Search the table.  Record the most recent entry that matches.  */
273   for (entry = previous_hi16s; entry; entry = entry->next)
274     {
275       if (entry->addend == addend
276           && (match == NULL || match->counter < entry->counter))
277         {
278           match    = entry;
279         }
280     }
281
282   if (match == NULL)
283     return NULL;
284
285   /* Extract the address.  */
286   addr = match->address;
287
288   /* Remember if this entry has already been used before.  */
289   if (already_found)
290     * already_found = match->found;
291
292   /* Note that this entry has now been used.  */
293   match->found = TRUE;
294
295   return addr;
296 }
297
298 /* Calculate the final operand value for a R_V850_LO16 or
299    R_V850_LO16_SPLIT_OFFSET.  *INSN is the current operand value and
300    ADDEND is the sum of the relocation symbol and offset.  Store the
301    operand value in *INSN and return true on success.
302
303    The assembler has already done some of this: If the value stored in
304    the instruction has its 15th bit set, (counting from zero) then the
305    assembler will have added 1 to the value stored in the associated
306    HI16S reloc.  So for example, these relocations:
307
308        movhi hi( fred ), r0, r1
309        movea lo( fred ), r1, r1
310
311    will store 0 in the value fields for the MOVHI and MOVEA instructions
312    and addend will be the address of fred, but for these instructions:
313
314        movhi hi( fred + 0x123456 ), r0, r1
315        movea lo( fred + 0x123456 ), r1, r1
316
317    the value stored in the MOVHI instruction will be 0x12 and the value
318    stored in the MOVEA instruction will be 0x3456.  If however the
319    instructions were:
320
321        movhi hi( fred + 0x10ffff ), r0, r1
322        movea lo( fred + 0x10ffff ), r1, r1
323
324    then the value stored in the MOVHI instruction would be 0x11 (not
325    0x10) and the value stored in the MOVEA instruction would be 0xffff.
326    Thus (assuming for the moment that the addend is 0), at run time the
327    MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
328    adds 0xffffffff (sign extension!) producing 0x10ffff.  Similarly if
329    the instructions were:
330
331        movhi hi( fred - 1 ), r0, r1
332        movea lo( fred - 1 ), r1, r1
333
334    then 0 is stored in the MOVHI instruction and -1 is stored in the
335    MOVEA instruction.
336
337    Overflow can occur if the addition of the value stored in the
338    instruction plus the addend sets the 15th bit when before it was clear.
339    This is because the 15th bit will be sign extended into the high part,
340    thus reducing its value by one, but since the 15th bit was originally
341    clear, the assembler will not have added 1 to the previous HI16S reloc
342    to compensate for this effect.  For example:
343
344       movhi hi( fred + 0x123456 ), r0, r1
345       movea lo( fred + 0x123456 ), r1, r1
346
347    The value stored in HI16S reloc is 0x12, the value stored in the LO16
348    reloc is 0x3456.  If we assume that the address of fred is 0x00007000
349    then the relocations become:
350
351      HI16S: 0x0012 + (0x00007000 >> 16)    = 0x12
352      LO16:  0x3456 + (0x00007000 & 0xffff) = 0xa456
353
354    but when the instructions are executed, the MOVEA instruction's value
355    is signed extended, so the sum becomes:
356
357         0x00120000
358       + 0xffffa456
359       ------------
360         0x0011a456    but 'fred + 0x123456' = 0x0012a456
361
362    Note that if the 15th bit was set in the value stored in the LO16
363    reloc, then we do not have to do anything:
364
365       movhi hi( fred + 0x10ffff ), r0, r1
366       movea lo( fred + 0x10ffff ), r1, r1
367
368       HI16S:  0x0011 + (0x00007000 >> 16)    = 0x11
369       LO16:   0xffff + (0x00007000 & 0xffff) = 0x6fff
370
371         0x00110000
372       + 0x00006fff
373       ------------
374         0x00116fff  = fred + 0x10ffff = 0x7000 + 0x10ffff
375
376    Overflow can also occur if the computation carries into the 16th bit
377    and it also results in the 15th bit having the same value as the 15th
378    bit of the original value.   What happens is that the HI16S reloc
379    will have already examined the 15th bit of the original value and
380    added 1 to the high part if the bit is set.  This compensates for the
381    sign extension of 15th bit of the result of the computation.  But now
382    there is a carry into the 16th bit, and this has not been allowed for.
383
384    So, for example if fred is at address 0xf000:
385
386      movhi hi( fred + 0xffff ), r0, r1    [bit 15 of the offset is set]
387      movea lo( fred + 0xffff ), r1, r1
388
389      HI16S: 0x0001 + (0x0000f000 >> 16)    = 0x0001
390      LO16:  0xffff + (0x0000f000 & 0xffff) = 0xefff   (carry into bit 16 is lost)
391
392        0x00010000
393      + 0xffffefff
394      ------------
395        0x0000efff   but 'fred + 0xffff' = 0x0001efff
396
397    Similarly, if the 15th bit remains clear, but overflow occurs into
398    the 16th bit then (assuming the address of fred is 0xf000):
399
400      movhi hi( fred + 0x7000 ), r0, r1    [bit 15 of the offset is clear]
401      movea lo( fred + 0x7000 ), r1, r1
402
403      HI16S: 0x0000 + (0x0000f000 >> 16)    = 0x0000
404      LO16:  0x7000 + (0x0000f000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
405
406        0x00000000
407      + 0x00006fff
408      ------------
409        0x00006fff   but 'fred + 0x7000' = 0x00016fff
410
411    Note - there is no need to change anything if a carry occurs, and the
412    15th bit changes its value from being set to being clear, as the HI16S
413    reloc will have already added in 1 to the high part for us:
414
415      movhi hi( fred + 0xffff ), r0, r1     [bit 15 of the offset is set]
416      movea lo( fred + 0xffff ), r1, r1
417
418      HI16S: 0x0001 + (0x00007000 >> 16)
419      LO16:  0xffff + (0x00007000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
420
421        0x00010000
422      + 0x00006fff   (bit 15 not set, so the top half is zero)
423      ------------
424        0x00016fff   which is right (assuming that fred is at 0x7000)
425
426    but if the 15th bit goes from being clear to being set, then we must
427    once again handle overflow:
428
429      movhi hi( fred + 0x7000 ), r0, r1     [bit 15 of the offset is clear]
430      movea lo( fred + 0x7000 ), r1, r1
431
432      HI16S: 0x0000 + (0x0000ffff >> 16)
433      LO16:  0x7000 + (0x0000ffff & 0xffff) = 0x6fff  (carry into bit 16)
434
435        0x00000000
436      + 0x00006fff   (bit 15 not set, so the top half is zero)
437      ------------
438        0x00006fff   which is wrong (assuming that fred is at 0xffff).  */
439
440 static bfd_boolean
441 v850_elf_perform_lo16_relocation (bfd *abfd, unsigned long *insn,
442                                   unsigned long addend)
443 {
444 #define BIT15_SET(x) ((x) & 0x8000)
445 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
446
447   if ((BIT15_SET (*insn + addend) && ! BIT15_SET (addend))
448       || (OVERFLOWS (addend, *insn)
449           && ((! BIT15_SET (*insn)) || (BIT15_SET (addend)))))
450     {
451       bfd_boolean already_updated;
452       bfd_byte *hi16s_address = find_remembered_hi16s_reloc
453         (addend, & already_updated);
454
455       /* Amend the matching HI16_S relocation.  */
456       if (hi16s_address != NULL)
457         {
458           if (! already_updated)
459             {
460               unsigned long hi_insn = bfd_get_16 (abfd, hi16s_address);
461               hi_insn += 1;
462               bfd_put_16 (abfd, hi_insn, hi16s_address);
463             }
464         }
465       else
466         {
467           _bfd_error_handler (_("FAILED to find previous HI16 reloc"));
468           return FALSE;
469         }
470     }
471 #undef OVERFLOWS
472 #undef BIT15_SET
473
474   /* Do not complain if value has top bit set, as this has been
475      anticipated.  */
476   *insn = (*insn + addend) & 0xffff;
477   return TRUE;
478 }
479
480 /* FIXME:  The code here probably ought to be removed and the code in reloc.c
481    allowed to do its stuff instead.  At least for most of the relocs, anyway.  */
482
483 static bfd_reloc_status_type
484 v850_elf_perform_relocation (bfd *abfd,
485                              unsigned int r_type,
486                              bfd_vma addend,
487                              bfd_byte *address)
488 {
489   unsigned long insn;
490   unsigned long result;
491   bfd_signed_vma saddend = (bfd_signed_vma) addend;
492
493   switch (r_type)
494     {
495     default:
496 #ifdef DEBUG
497       fprintf (stderr, "%B: reloc number %d not recognised\n", abfd, r_type);
498 #endif
499       return bfd_reloc_notsupported;
500
501     case R_V850_REL32:
502     case R_V850_ABS32:
503     case R_V810_WORD:
504     case R_V850_PC32:
505       bfd_put_32 (abfd, addend, address);
506       return bfd_reloc_ok;
507
508     case R_V850_WLO23:
509     case R_V850_23:
510       insn  = bfd_get_32 (abfd, address);
511       insn &= ~((0x7f << 4) | (0x7fff80 << (16-7)));
512       insn |= ((addend & 0x7f) << 4) | ((addend & 0x7fff80) << (16-7));
513       bfd_put_32 (abfd, (bfd_vma) insn, address);
514       return bfd_reloc_ok;
515
516     case R_V850_PCR22:
517     case R_V850_22_PCREL:
518       if (saddend > 0x1fffff || saddend < -0x200000)
519         return bfd_reloc_overflow;
520
521       if ((addend % 2) != 0)
522         return bfd_reloc_dangerous;
523
524       insn  = bfd_get_32 (abfd, address);
525       insn &= ~0xfffe003f;
526       insn |= (((addend & 0xfffe) << 16) | ((addend & 0x3f0000) >> 16));
527       bfd_put_32 (abfd, (bfd_vma) insn, address);
528       return bfd_reloc_ok;
529
530     case R_V850_PC17:
531     case R_V850_17_PCREL:
532       if (saddend > 0xffff || saddend < -0x10000)
533         return bfd_reloc_overflow;
534
535       if ((addend % 2) != 0)
536         return bfd_reloc_dangerous;
537
538       insn  = bfd_get_32 (abfd, address);
539       insn &= ~ 0xfffe0010;
540       insn |= ((addend & 0xfffe) << 16) | ((addend & 0x10000) >> (16-4));
541       break;
542
543     case R_V850_PC16U:
544     case R_V850_16_PCREL:
545       if ((saddend < -0xffff) || (saddend > 0))
546         return bfd_reloc_overflow;
547
548       if ((addend % 2) != 0)
549         return bfd_reloc_dangerous;
550
551       insn  = bfd_get_16 (abfd, address);
552       insn &= ~0xfffe;
553       insn |= (-addend & 0xfffe);
554       break;
555
556     case R_V850_PC9:
557     case R_V850_9_PCREL:
558       if (saddend > 0xff || saddend < -0x100)
559         return bfd_reloc_overflow;
560
561       if ((addend % 2) != 0)
562         return bfd_reloc_dangerous;
563
564       insn  = bfd_get_16 (abfd, address);
565       insn &= ~ 0xf870;
566       insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
567       break;
568
569     case R_V810_WHI:
570     case R_V850_HI16:
571       addend += (bfd_get_16 (abfd, address) << 16);
572       addend = (addend >> 16);
573       insn = addend;
574       break;
575
576     case R_V810_WHI1:
577     case R_V850_HI16_S:
578       /* Remember where this relocation took place.  */
579       remember_hi16s_reloc (abfd, addend, address);
580
581       addend += (bfd_get_16 (abfd, address) << 16);
582       addend = (addend >> 16) + ((addend & 0x8000) != 0);
583
584       /* This relocation cannot overflow.  */
585       if (addend > 0xffff)
586         addend = 0;
587
588       insn = addend;
589       break;
590
591     case R_V810_WLO:
592     case R_V850_LO16:
593       insn = bfd_get_16 (abfd, address);
594       if (! v850_elf_perform_lo16_relocation (abfd, &insn, addend))
595         return bfd_reloc_overflow;
596       break;
597
598     case R_V810_BYTE:
599     case R_V850_8:
600       addend += (char) bfd_get_8 (abfd, address);
601
602       saddend = (bfd_signed_vma) addend;
603
604       if (saddend > 0x7f || saddend < -0x80)
605         return bfd_reloc_overflow;
606
607       bfd_put_8 (abfd, addend, address);
608       return bfd_reloc_ok;
609
610     case R_V850_CALLT_16_16_OFFSET:
611       addend += bfd_get_16 (abfd, address);
612
613       saddend = (bfd_signed_vma) addend;
614
615       if (saddend > 0xffff || saddend < 0)
616         return bfd_reloc_overflow;
617
618       insn = addend;
619       break;
620
621     case R_V850_CALLT_15_16_OFFSET:
622       insn = bfd_get_16 (abfd, address);
623
624       addend += insn & 0xfffe;
625
626       saddend = (bfd_signed_vma) addend;
627
628       if (saddend > 0xffff || saddend < 0)
629         return bfd_reloc_overflow;
630
631       insn = (0xfffe & addend)
632         | (insn & ~0xfffe);
633       break;
634
635     case R_V850_CALLT_6_7_OFFSET:
636       insn = bfd_get_16 (abfd, address);
637       addend += ((insn & 0x3f) << 1);
638
639       saddend = (bfd_signed_vma) addend;
640
641       if (saddend > 0x7e || saddend < 0)
642         return bfd_reloc_overflow;
643
644       if (addend & 1)
645         return bfd_reloc_dangerous;
646
647       insn &= 0xff80;
648       insn |= (addend >> 1);
649       break;
650
651     case R_V850_16:
652     case R_V810_HWORD:
653     case R_V850_SDA_16_16_OFFSET:
654     case R_V850_ZDA_16_16_OFFSET:
655     case R_V850_TDA_16_16_OFFSET:
656       addend += bfd_get_16 (abfd, address);
657
658       saddend = (bfd_signed_vma) addend;
659
660       if (saddend > 0x7fff || saddend < -0x8000)
661         return bfd_reloc_overflow;
662
663       insn = addend;
664       break;
665
666     case R_V850_16_S1:
667     case R_V850_SDA_15_16_OFFSET:
668     case R_V850_ZDA_15_16_OFFSET:
669     case R_V810_GPWLO_1:
670       insn = bfd_get_16 (abfd, address);
671       addend += (insn & 0xfffe);
672
673       saddend = (bfd_signed_vma) addend;
674
675       if (saddend > 0x7ffe || saddend < -0x8000)
676         return bfd_reloc_overflow;
677
678       if (addend & 1)
679         return bfd_reloc_dangerous;
680
681       insn = (addend &~ (bfd_vma) 1) | (insn & 1);
682       break;
683
684     case R_V850_TDA_6_8_OFFSET:
685       insn = bfd_get_16 (abfd, address);
686       addend += ((insn & 0x7e) << 1);
687
688       saddend = (bfd_signed_vma) addend;
689
690       if (saddend > 0xfc || saddend < 0)
691         return bfd_reloc_overflow;
692
693       if (addend & 3)
694         return bfd_reloc_dangerous;
695
696       insn &= 0xff81;
697       insn |= (addend >> 1);
698       break;
699
700     case R_V850_TDA_7_8_OFFSET:
701       insn = bfd_get_16 (abfd, address);
702       addend += ((insn & 0x7f) << 1);
703
704       saddend = (bfd_signed_vma) addend;
705
706       if (saddend > 0xfe || saddend < 0)
707         return bfd_reloc_overflow;
708
709       if (addend & 1)
710         return bfd_reloc_dangerous;
711
712       insn &= 0xff80;
713       insn |= (addend >> 1);
714       break;
715
716     case R_V850_TDA_7_7_OFFSET:
717       insn = bfd_get_16 (abfd, address);
718       addend += insn & 0x7f;
719
720       saddend = (bfd_signed_vma) addend;
721
722       if (saddend > 0x7f || saddend < 0)
723         return bfd_reloc_overflow;
724
725       insn &= 0xff80;
726       insn |= addend;
727       break;
728
729     case R_V850_TDA_4_5_OFFSET:
730       insn = bfd_get_16 (abfd, address);
731       addend += ((insn & 0xf) << 1);
732
733       saddend = (bfd_signed_vma) addend;
734
735       if (saddend > 0x1e || saddend < 0)
736         return bfd_reloc_overflow;
737
738       if (addend & 1)
739         return bfd_reloc_dangerous;
740
741       insn &= 0xfff0;
742       insn |= (addend >> 1);
743       break;
744
745     case R_V850_TDA_4_4_OFFSET:
746       insn = bfd_get_16 (abfd, address);
747       addend += insn & 0xf;
748
749       saddend = (bfd_signed_vma) addend;
750
751       if (saddend > 0xf || saddend < 0)
752         return bfd_reloc_overflow;
753
754       insn &= 0xfff0;
755       insn |= addend;
756       break;
757
758     case R_V810_WLO_1:
759     case R_V850_HWLO:
760     case R_V850_HWLO_1:
761     case R_V850_LO16_S1:
762       insn = bfd_get_16 (abfd, address);
763       result = insn & 0xfffe;
764       if (! v850_elf_perform_lo16_relocation (abfd, &result, addend))
765         return bfd_reloc_overflow;
766       if (result & 1)
767         return bfd_reloc_overflow;
768       insn = (result & 0xfffe)
769         | (insn & ~0xfffe);
770         bfd_put_16 (abfd, insn, address);
771       return bfd_reloc_ok;
772
773     case R_V850_BLO:
774     case R_V850_LO16_SPLIT_OFFSET:
775       insn = bfd_get_32 (abfd, address);
776       result = ((insn & 0xfffe0000) >> 16) | ((insn & 0x20) >> 5);
777       if (! v850_elf_perform_lo16_relocation (abfd, &result, addend))
778         return bfd_reloc_overflow;
779       insn = (((result << 16) & 0xfffe0000)
780               | ((result << 5) & 0x20)
781               | (insn & ~0xfffe0020));
782       bfd_put_32 (abfd, insn, address);
783       return bfd_reloc_ok;
784
785     case R_V850_16_SPLIT_OFFSET:
786     case R_V850_SDA_16_16_SPLIT_OFFSET:
787     case R_V850_ZDA_16_16_SPLIT_OFFSET:
788       insn = bfd_get_32 (abfd, address);
789       addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
790
791       saddend = (bfd_signed_vma) addend;
792
793       if (saddend > 0x7fff || saddend < -0x8000)
794         return bfd_reloc_overflow;
795
796       insn &= 0x0001ffdf;
797       insn |= (addend & 1) << 5;
798       insn |= (addend &~ (bfd_vma) 1) << 16;
799
800       bfd_put_32 (abfd, (bfd_vma) insn, address);
801       return bfd_reloc_ok;
802
803     case R_V850_GNU_VTINHERIT:
804     case R_V850_GNU_VTENTRY:
805       return bfd_reloc_ok;
806
807     }
808
809   bfd_put_16 (abfd, (bfd_vma) insn, address);
810   return bfd_reloc_ok;
811 }
812 \f
813 /* Insert the addend into the instruction.  */
814
815 static bfd_reloc_status_type
816 v850_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED,
817                 arelent *reloc,
818                 asymbol *symbol,
819                 void * data ATTRIBUTE_UNUSED,
820                 asection *isection,
821                 bfd *obfd,
822                 char **err ATTRIBUTE_UNUSED)
823 {
824   long relocation;
825
826   /* If there is an output BFD,
827      and the symbol is not a section name (which is only defined at final link time),
828      and either we are not putting the addend into the instruction
829       or the addend is zero, so there is nothing to add into the instruction
830      then just fixup the address and return.  */
831   if (obfd != NULL
832       && (symbol->flags & BSF_SECTION_SYM) == 0
833       && (! reloc->howto->partial_inplace
834           || reloc->addend == 0))
835     {
836       reloc->address += isection->output_offset;
837       return bfd_reloc_ok;
838     }
839
840   /* Catch relocs involving undefined symbols.  */
841   if (bfd_is_und_section (symbol->section)
842       && (symbol->flags & BSF_WEAK) == 0
843       && obfd == NULL)
844     return bfd_reloc_undefined;
845
846   /* We handle final linking of some relocs ourselves.  */
847
848   /* Is the address of the relocation really within the section?  */
849   if (reloc->address > bfd_get_section_limit (abfd, isection))
850     return bfd_reloc_outofrange;
851
852   /* Work out which section the relocation is targeted at and the
853      initial relocation command value.  */
854
855   if (reloc->howto->pc_relative)
856     return bfd_reloc_ok;
857
858   /* Get symbol value.  (Common symbols are special.)  */
859   if (bfd_is_com_section (symbol->section))
860     relocation = 0;
861   else
862     relocation = symbol->value;
863
864   /* Convert input-section-relative symbol value to absolute + addend.  */
865   relocation += symbol->section->output_section->vma;
866   relocation += symbol->section->output_offset;
867   relocation += reloc->addend;
868
869   reloc->addend = relocation;
870   return bfd_reloc_ok;
871 }
872
873 /* This function is used for relocs which are only used
874    for relaxing, which the linker should otherwise ignore.  */
875
876 static bfd_reloc_status_type
877 v850_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
878                        arelent *reloc_entry,
879                        asymbol *symbol ATTRIBUTE_UNUSED,
880                        void * data ATTRIBUTE_UNUSED,
881                        asection *input_section,
882                        bfd *output_bfd,
883                        char **error_message ATTRIBUTE_UNUSED)
884 {
885   if (output_bfd != NULL)
886     reloc_entry->address += input_section->output_offset;
887
888   return bfd_reloc_ok;
889 }
890 /* Note: It is REQUIRED that the 'type' value of each entry
891    in this array match the index of the entry in the array.
892    SeeAlso: RELOC_NUBMER in include/elf/v850.h.  */
893 static reloc_howto_type v850_elf_howto_table[] =
894 {
895   /* This reloc does nothing.  */
896   HOWTO (R_V850_NONE,                   /* Type.  */
897          0,                             /* Rightshift.  */
898          3,                             /* Size (0 = byte, 1 = short, 2 = long).  */
899          0,                             /* Bitsize.  */
900          FALSE,                         /* PC_relative.  */
901          0,                             /* Bitpos.  */
902          complain_overflow_dont,        /* Complain_on_overflow.  */
903          bfd_elf_generic_reloc,         /* Special_function.  */
904          "R_V850_NONE",                 /* Name.  */
905          FALSE,                         /* Partial_inplace.  */
906          0,                             /* Src_mask.  */
907          0,                             /* Dst_mask.  */
908          FALSE),                        /* PCrel_offset.  */
909
910   /* A PC relative 9 bit branch.  */
911   HOWTO (R_V850_9_PCREL,                /* Type.  */
912          0,                             /* Rightshift.  */
913          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
914          9,                             /* Bitsize.  */
915          TRUE,                          /* PC_relative.  */
916          0,                             /* Bitpos.  */
917          complain_overflow_bitfield,    /* Complain_on_overflow.  */
918          v850_elf_reloc,                /* Special_function.  */
919          "R_V850_9_PCREL",              /* Name.  */
920          FALSE,                         /* Partial_inplace.  */
921          0x00ffffff,                    /* Src_mask.  */
922          0x00ffffff,                    /* Dst_mask.  */
923          TRUE),                         /* PCrel_offset.  */
924
925   /* A PC relative 22 bit branch.  */
926   HOWTO (R_V850_22_PCREL,               /* Type.  */
927          0,                             /* Rightshift.  */
928          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
929          22,                            /* Bitsize.  */
930          TRUE,                          /* PC_relative.  */
931          0,                             /* Bitpos.  */
932          complain_overflow_signed,      /* Complain_on_overflow.  */
933          v850_elf_reloc,                /* Special_function.  */
934          "R_V850_22_PCREL",             /* Name.  */
935          FALSE,                         /* Partial_inplace.  */
936          0x07ffff80,                    /* Src_mask.  */
937          0x07ffff80,                    /* Dst_mask.  */
938          TRUE),                         /* PCrel_offset.  */
939
940   /* High 16 bits of symbol value.  */
941   HOWTO (R_V850_HI16_S,                 /* Type.  */
942          0,                             /* Rightshift.  */
943          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
944          16,                            /* Bitsize.  */
945          FALSE,                         /* PC_relative.  */
946          0,                             /* Bitpos.  */
947          complain_overflow_dont,        /* Complain_on_overflow.  */
948          v850_elf_reloc,                /* Special_function.  */
949          "R_V850_HI16_S",               /* Name.  */
950          FALSE,                         /* Partial_inplace.  */
951          0xffff,                        /* Src_mask.  */
952          0xffff,                        /* Dst_mask.  */
953          FALSE),                        /* PCrel_offset.  */
954
955   /* High 16 bits of symbol value.  */
956   HOWTO (R_V850_HI16,                   /* Type.  */
957          0,                             /* Rightshift.  */
958          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
959          16,                            /* Bitsize.  */
960          FALSE,                         /* PC_relative.  */
961          0,                             /* Bitpos.  */
962          complain_overflow_dont,        /* Complain_on_overflow.  */
963          v850_elf_reloc,                /* Special_function.  */
964          "R_V850_HI16",                 /* Name.  */
965          FALSE,                         /* Partial_inplace.  */
966          0xffff,                        /* Src_mask.  */
967          0xffff,                        /* Dst_mask.  */
968          FALSE),                        /* PCrel_offset.  */
969
970   /* Low 16 bits of symbol value.  */
971   HOWTO (R_V850_LO16,                   /* Type.  */
972          0,                             /* Rightshift.  */
973          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
974          16,                            /* Bitsize.  */
975          FALSE,                         /* PC_relative.  */
976          0,                             /* Bitpos.  */
977          complain_overflow_dont,        /* Complain_on_overflow.  */
978          v850_elf_reloc,                /* Special_function.  */
979          "R_V850_LO16",                 /* Name.  */
980          FALSE,                         /* Partial_inplace.  */
981          0xffff,                        /* Src_mask.  */
982          0xffff,                        /* Dst_mask.  */
983          FALSE),                        /* PCrel_offset.  */
984
985   /* Simple 32bit reloc.  */
986   HOWTO (R_V850_ABS32,                  /* Type.  */
987          0,                             /* Rightshift.  */
988          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
989          32,                            /* Bitsize.  */
990          FALSE,                         /* PC_relative.  */
991          0,                             /* Bitpos.  */
992          complain_overflow_dont,        /* Complain_on_overflow.  */
993          v850_elf_reloc,                /* Special_function.  */
994          "R_V850_ABS32",                /* Name.  */
995          FALSE,                         /* Partial_inplace.  */
996          0xffffffff,                    /* Src_mask.  */
997          0xffffffff,                    /* Dst_mask.  */
998          FALSE),                        /* PCrel_offset.  */
999
1000   /* Simple 16bit reloc.  */
1001   HOWTO (R_V850_16,                     /* Type.  */
1002          0,                             /* Rightshift.  */
1003          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1004          16,                            /* Bitsize.  */
1005          FALSE,                         /* PC_relative.  */
1006          0,                             /* Bitpos.  */
1007          complain_overflow_dont,        /* Complain_on_overflow.  */
1008          bfd_elf_generic_reloc,         /* Special_function.  */
1009          "R_V850_16",                   /* Name.  */
1010          FALSE,                         /* Partial_inplace.  */
1011          0xffff,                        /* Src_mask.  */
1012          0xffff,                        /* Dst_mask.  */
1013          FALSE),                        /* PCrel_offset.  */
1014
1015   /* Simple 8bit reloc.  */
1016   HOWTO (R_V850_8,                      /* Type.  */
1017          0,                             /* Rightshift.  */
1018          0,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1019          8,                             /* Bitsize.  */
1020          FALSE,                         /* PC_relative.  */
1021          0,                             /* Bitpos.  */
1022          complain_overflow_dont,        /* Complain_on_overflow.  */
1023          bfd_elf_generic_reloc,         /* Special_function.  */
1024          "R_V850_8",                    /* Name.  */
1025          FALSE,                         /* Partial_inplace.  */
1026          0xff,                          /* Src_mask.  */
1027          0xff,                          /* Dst_mask.  */
1028          FALSE),                        /* PCrel_offset.  */
1029
1030   /* 16 bit offset from the short data area pointer.  */
1031   HOWTO (R_V850_SDA_16_16_OFFSET,       /* Type.  */
1032          0,                             /* Rightshift.  */
1033          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1034          16,                            /* Bitsize.  */
1035          FALSE,                         /* PC_relative.  */
1036          0,                             /* Bitpos.  */
1037          complain_overflow_dont,        /* Complain_on_overflow.  */
1038          v850_elf_reloc,                /* Special_function.  */
1039          "R_V850_SDA_16_16_OFFSET",     /* Name.  */
1040          FALSE,                         /* Partial_inplace.  */
1041          0xffff,                        /* Src_mask.  */
1042          0xffff,                        /* Dst_mask.  */
1043          FALSE),                        /* PCrel_offset.  */
1044
1045   /* 15 bit offset from the short data area pointer.  */
1046   HOWTO (R_V850_SDA_15_16_OFFSET,       /* Type.  */
1047          1,                             /* Rightshift.  */
1048          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1049          16,                            /* Bitsize.  */
1050          FALSE,                         /* PC_relative.  */
1051          1,                             /* Bitpos.  */
1052          complain_overflow_dont,        /* Complain_on_overflow.  */
1053          v850_elf_reloc,                /* Special_function.  */
1054          "R_V850_SDA_15_16_OFFSET",     /* Name.  */
1055          FALSE,                         /* Partial_inplace.  */
1056          0xfffe,                        /* Src_mask.  */
1057          0xfffe,                        /* Dst_mask.  */
1058          FALSE),                        /* PCrel_offset.  */
1059
1060   /* 16 bit offset from the zero data area pointer.  */
1061   HOWTO (R_V850_ZDA_16_16_OFFSET,       /* Type.  */
1062          0,                             /* Rightshift.  */
1063          1,                             /* 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          v850_elf_reloc,                /* Special_function.  */
1069          "R_V850_ZDA_16_16_OFFSET",     /* Name.  */
1070          FALSE,                         /* Partial_inplace.  */
1071          0xffff,                        /* Src_mask.  */
1072          0xffff,                        /* Dst_mask.  */
1073          FALSE),                        /* PCrel_offset.  */
1074
1075   /* 15 bit offset from the zero data area pointer.  */
1076   HOWTO (R_V850_ZDA_15_16_OFFSET,       /* Type.  */
1077          1,                             /* Rightshift.  */
1078          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1079          16,                            /* Bitsize.  */
1080          FALSE,                         /* PC_relative.  */
1081          1,                             /* Bitpos.  */
1082          complain_overflow_dont,        /* Complain_on_overflow.  */
1083          v850_elf_reloc,                /* Special_function.  */
1084          "R_V850_ZDA_15_16_OFFSET",     /* Name.  */
1085          FALSE,                         /* Partial_inplace.  */
1086          0xfffe,                        /* Src_mask.  */
1087          0xfffe,                        /* Dst_mask.  */
1088          FALSE),                        /* PCrel_offset.  */
1089
1090   /* 6 bit offset from the tiny data area pointer.  */
1091   HOWTO (R_V850_TDA_6_8_OFFSET,         /* Type.  */
1092          2,                             /* Rightshift.  */
1093          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1094          8,                             /* Bitsize.  */
1095          FALSE,                         /* PC_relative.  */
1096          1,                             /* Bitpos.  */
1097          complain_overflow_dont,        /* Complain_on_overflow.  */
1098          v850_elf_reloc,                /* Special_function.  */
1099          "R_V850_TDA_6_8_OFFSET",       /* Name.  */
1100          FALSE,                         /* Partial_inplace.  */
1101          0x7e,                          /* Src_mask.  */
1102          0x7e,                          /* Dst_mask.  */
1103          FALSE),                        /* PCrel_offset.  */
1104
1105   /* 8 bit offset from the tiny data area pointer.  */
1106   HOWTO (R_V850_TDA_7_8_OFFSET,         /* Type.  */
1107          1,                             /* Rightshift.  */
1108          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1109          8,                             /* Bitsize.  */
1110          FALSE,                         /* PC_relative.  */
1111          0,                             /* Bitpos.  */
1112          complain_overflow_dont,        /* Complain_on_overflow.  */
1113          v850_elf_reloc,                /* Special_function.  */
1114          "R_V850_TDA_7_8_OFFSET",       /* Name.  */
1115          FALSE,                         /* Partial_inplace.  */
1116          0x7f,                          /* Src_mask.  */
1117          0x7f,                          /* Dst_mask.  */
1118          FALSE),                        /* PCrel_offset.  */
1119
1120   /* 7 bit offset from the tiny data area pointer.  */
1121   HOWTO (R_V850_TDA_7_7_OFFSET,         /* Type.  */
1122          0,                             /* Rightshift.  */
1123          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1124          7,                             /* Bitsize.  */
1125          FALSE,                         /* PC_relative.  */
1126          0,                             /* Bitpos.  */
1127          complain_overflow_dont,        /* Complain_on_overflow.  */
1128          v850_elf_reloc,                /* Special_function.  */
1129          "R_V850_TDA_7_7_OFFSET",       /* Name.  */
1130          FALSE,                         /* Partial_inplace.  */
1131          0x7f,                          /* Src_mask.  */
1132          0x7f,                          /* Dst_mask.  */
1133          FALSE),                        /* PCrel_offset.  */
1134
1135   /* 16 bit offset from the tiny data area pointer!  */
1136   HOWTO (R_V850_TDA_16_16_OFFSET,       /* Type.  */
1137          0,                             /* Rightshift.  */
1138          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1139          16,                            /* Bitsize.  */
1140          FALSE,                         /* PC_relative.  */
1141          0,                             /* Bitpos.  */
1142          complain_overflow_dont,        /* Complain_on_overflow.  */
1143          v850_elf_reloc,                /* Special_function.  */
1144          "R_V850_TDA_16_16_OFFSET",     /* Name.  */
1145          FALSE,                         /* Partial_inplace.  */
1146          0xffff,                        /* Src_mask.  */
1147          0xfff,                         /* Dst_mask.  */
1148          FALSE),                        /* PCrel_offset.  */
1149
1150   /* 5 bit offset from the tiny data area pointer.  */
1151   HOWTO (R_V850_TDA_4_5_OFFSET,         /* Type.  */
1152          1,                             /* Rightshift.  */
1153          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1154          5,                             /* Bitsize.  */
1155          FALSE,                         /* PC_relative.  */
1156          0,                             /* Bitpos.  */
1157          complain_overflow_dont,        /* Complain_on_overflow.  */
1158          v850_elf_reloc,                /* Special_function.  */
1159          "R_V850_TDA_4_5_OFFSET",       /* Name.  */
1160          FALSE,                         /* Partial_inplace.  */
1161          0x0f,                          /* Src_mask.  */
1162          0x0f,                          /* Dst_mask.  */
1163          FALSE),                        /* PCrel_offset.  */
1164
1165   /* 4 bit offset from the tiny data area pointer.  */
1166   HOWTO (R_V850_TDA_4_4_OFFSET,         /* Type.  */
1167          0,                             /* Rightshift.  */
1168          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1169          4,                             /* Bitsize.  */
1170          FALSE,                         /* PC_relative.  */
1171          0,                             /* Bitpos.  */
1172          complain_overflow_dont,        /* Complain_on_overflow.  */
1173          v850_elf_reloc,                /* Special_function.  */
1174          "R_V850_TDA_4_4_OFFSET",       /* Name.  */
1175          FALSE,                         /* Partial_inplace.  */
1176          0x0f,                          /* Src_mask.  */
1177          0x0f,                          /* Dst_mask.  */
1178          FALSE),                        /* PCrel_offset.  */
1179
1180   /* 16 bit offset from the short data area pointer.  */
1181   HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* Type.  */
1182          0,                             /* Rightshift.  */
1183          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1184          16,                            /* Bitsize.  */
1185          FALSE,                         /* PC_relative.  */
1186          0,                             /* Bitpos.  */
1187          complain_overflow_dont,        /* Complain_on_overflow.  */
1188          v850_elf_reloc,                /* Special_function.  */
1189          "R_V850_SDA_16_16_SPLIT_OFFSET",/* Name.  */
1190          FALSE,                         /* Partial_inplace.  */
1191          0xfffe0020,                    /* Src_mask.  */
1192          0xfffe0020,                    /* Dst_mask.  */
1193          FALSE),                        /* PCrel_offset.  */
1194
1195   /* 16 bit offset from the zero data area pointer.  */
1196   HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* Type.  */
1197          0,                             /* Rightshift.  */
1198          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1199          16,                            /* Bitsize.  */
1200          FALSE,                         /* PC_relative.  */
1201          0,                             /* Bitpos.  */
1202          complain_overflow_dont,        /* Complain_on_overflow.  */
1203          v850_elf_reloc,                /* Special_function.  */
1204          "R_V850_ZDA_16_16_SPLIT_OFFSET",/* Name.  */
1205          FALSE,                         /* Partial_inplace.  */
1206          0xfffe0020,                    /* Src_mask.  */
1207          0xfffe0020,                    /* Dst_mask.  */
1208          FALSE),                        /* PCrel_offset.  */
1209
1210   /* 6 bit offset from the call table base pointer.  */
1211   HOWTO (R_V850_CALLT_6_7_OFFSET,       /* Type.  */
1212          0,                             /* Rightshift.  */
1213          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1214          7,                             /* Bitsize.  */
1215          FALSE,                         /* PC_relative.  */
1216          0,                             /* Bitpos.  */
1217          complain_overflow_dont,        /* Complain_on_overflow.  */
1218          v850_elf_reloc,                /* Special_function.  */
1219          "R_V850_CALLT_6_7_OFFSET",     /* Name.  */
1220          FALSE,                         /* Partial_inplace.  */
1221          0x3f,                          /* Src_mask.  */
1222          0x3f,                          /* Dst_mask.  */
1223          FALSE),                        /* PCrel_offset.  */
1224
1225   /* 16 bit offset from the call table base pointer.  */
1226   HOWTO (R_V850_CALLT_16_16_OFFSET,     /* Type.  */
1227          0,                             /* Rightshift.  */
1228          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1229          16,                            /* Bitsize.  */
1230          FALSE,                         /* PC_relative.  */
1231          0,                             /* Bitpos.  */
1232          complain_overflow_dont,        /* Complain_on_overflow.  */
1233          v850_elf_reloc,                /* Special_function.  */
1234          "R_V850_CALLT_16_16_OFFSET",   /* Name.  */
1235          FALSE,                         /* Partial_inplace.  */
1236          0xffff,                        /* Src_mask.  */
1237          0xffff,                        /* Dst_mask.  */
1238          FALSE),                        /* PCrel_offset.  */
1239
1240
1241   /* GNU extension to record C++ vtable hierarchy */
1242   HOWTO (R_V850_GNU_VTINHERIT, /* Type.  */
1243          0,                     /* Rightshift.  */
1244          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1245          0,                     /* Bitsize.  */
1246          FALSE,                 /* PC_relative.  */
1247          0,                     /* Bitpos.  */
1248          complain_overflow_dont, /* Complain_on_overflow.  */
1249          NULL,                  /* Special_function.  */
1250          "R_V850_GNU_VTINHERIT", /* Name.  */
1251          FALSE,                 /* Partial_inplace.  */
1252          0,                     /* Src_mask.  */
1253          0,                     /* Dst_mask.  */
1254          FALSE),                /* PCrel_offset.  */
1255
1256   /* GNU extension to record C++ vtable member usage.  */
1257   HOWTO (R_V850_GNU_VTENTRY,     /* Type.  */
1258          0,                     /* Rightshift.  */
1259          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1260          0,                     /* Bitsize.  */
1261          FALSE,                 /* PC_relative.  */
1262          0,                     /* Bitpos.  */
1263          complain_overflow_dont, /* Complain_on_overflow.  */
1264          _bfd_elf_rel_vtable_reloc_fn,  /* Special_function.  */
1265          "R_V850_GNU_VTENTRY",   /* Name.  */
1266          FALSE,                 /* Partial_inplace.  */
1267          0,                     /* Src_mask.  */
1268          0,                     /* Dst_mask.  */
1269          FALSE),                /* PCrel_offset.  */
1270
1271   /* Indicates a .longcall pseudo-op.  The compiler will generate a .longcall
1272      pseudo-op when it finds a function call which can be relaxed.  */
1273   HOWTO (R_V850_LONGCALL,     /* Type.  */
1274          0,                     /* Rightshift.  */
1275          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1276          32,                    /* Bitsize.  */
1277          TRUE,                  /* PC_relative.  */
1278          0,                     /* Bitpos.  */
1279          complain_overflow_signed, /* Complain_on_overflow.  */
1280          v850_elf_ignore_reloc, /* Special_function.  */
1281          "R_V850_LONGCALL",     /* Name.  */
1282          FALSE,                 /* Partial_inplace.  */
1283          0,                     /* Src_mask.  */
1284          0,                     /* Dst_mask.  */
1285          TRUE),                 /* PCrel_offset.  */
1286
1287   /* Indicates a .longjump pseudo-op.  The compiler will generate a
1288      .longjump pseudo-op when it finds a branch which can be relaxed.  */
1289   HOWTO (R_V850_LONGJUMP,     /* Type.  */
1290          0,                     /* Rightshift.  */
1291          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1292          32,                    /* Bitsize.  */
1293          TRUE,                  /* PC_relative.  */
1294          0,                     /* Bitpos.  */
1295          complain_overflow_signed, /* Complain_on_overflow.  */
1296          v850_elf_ignore_reloc, /* Special_function.  */
1297          "R_V850_LONGJUMP",     /* Name.  */
1298          FALSE,                 /* Partial_inplace.  */
1299          0,                     /* Src_mask.  */
1300          0,                     /* Dst_mask.  */
1301          TRUE),                 /* PCrel_offset.  */
1302
1303   HOWTO (R_V850_ALIGN,        /* Type.  */
1304          0,                     /* Rightshift.  */
1305          1,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1306          0,                     /* Bitsize.  */
1307          FALSE,                 /* PC_relative.  */
1308          0,                     /* Bitpos.  */
1309          complain_overflow_unsigned, /* Complain_on_overflow.  */
1310          v850_elf_ignore_reloc, /* Special_function.  */
1311          "R_V850_ALIGN",        /* Name.  */
1312          FALSE,                 /* Partial_inplace.  */
1313          0,                     /* Src_mask.  */
1314          0,                     /* Dst_mask.  */
1315          TRUE),                 /* PCrel_offset.  */
1316
1317   /* Simple pc-relative 32bit reloc.  */
1318   HOWTO (R_V850_REL32,                  /* Type.  */
1319          0,                             /* Rightshift.  */
1320          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1321          32,                            /* Bitsize.  */
1322          TRUE,                          /* PC_relative.  */
1323          0,                             /* Bitpos.  */
1324          complain_overflow_dont,        /* Complain_on_overflow.  */
1325          v850_elf_reloc,                /* Special_function.  */
1326          "R_V850_REL32",                /* Name.  */
1327          FALSE,                         /* Partial_inplace.  */
1328          0xffffffff,                    /* Src_mask.  */
1329          0xffffffff,                    /* Dst_mask.  */
1330          FALSE),                        /* PCrel_offset.  */
1331
1332   /* An ld.bu version of R_V850_LO16.  */
1333   HOWTO (R_V850_LO16_SPLIT_OFFSET,      /* Type.  */
1334          0,                             /* Rightshift.  */
1335          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1336          16,                            /* Bitsize.  */
1337          FALSE,                         /* PC_relative.  */
1338          0,                             /* Bitpos.  */
1339          complain_overflow_dont,        /* Complain_on_overflow.  */
1340          v850_elf_reloc,                /* Special_function.  */
1341          "R_V850_LO16_SPLIT_OFFSET",    /* Name.  */
1342          FALSE,                         /* Partial_inplace.  */
1343          0xfffe0020,                    /* Src_mask.  */
1344          0xfffe0020,                    /* Dst_mask.  */
1345          FALSE),                        /* PCrel_offset.  */
1346
1347   /* A unsigned PC relative 16 bit loop.  */
1348   HOWTO (R_V850_16_PCREL,               /* Type.  */
1349          0,                             /* Rightshift.  */
1350          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1351          16,                            /* Bitsize.  */
1352          TRUE,                          /* PC_relative.  */
1353          0,                             /* Bitpos.  */
1354          complain_overflow_bitfield,    /* Complain_on_overflow.  */
1355          v850_elf_reloc,                /* Special_function.  */
1356          "R_V850_16_PCREL",             /* Name.  */
1357          FALSE,                         /* Partial_inplace.  */
1358          0xfffe,                        /* Src_mask.  */
1359          0xfffe,                        /* Dst_mask.  */
1360          TRUE),                         /* PCrel_offset.  */
1361
1362   /* A PC relative 17 bit branch.  */
1363   HOWTO (R_V850_17_PCREL,               /* Type.  */
1364          0,                             /* Rightshift.  */
1365          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1366          17,                            /* Bitsize.  */
1367          TRUE,                          /* PC_relative.  */
1368          0,                             /* Bitpos.  */
1369          complain_overflow_bitfield,    /* Complain_on_overflow.  */
1370          v850_elf_reloc,                /* Special_function.  */
1371          "R_V850_17_PCREL",             /* Name.  */
1372          FALSE,                         /* Partial_inplace.  */
1373          0x0010fffe,                    /* Src_mask.  */
1374          0x0010fffe,                    /* Dst_mask.  */
1375          TRUE),                         /* PCrel_offset.  */
1376
1377   /* A 23bit offset ld/st.  */
1378   HOWTO (R_V850_23,                     /* type.  */
1379          0,                             /* rightshift.  */
1380          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1381          23,                            /* bitsize.  */
1382          FALSE,                         /* pc_relative.  */
1383          0,                             /* bitpos.  */
1384          complain_overflow_dont,        /* complain_on_overflow.  */
1385          v850_elf_reloc,                /* special_function.  */
1386          "R_V850_23",                   /* name.  */
1387          FALSE,                         /* partial_inplace.  */
1388          0xffff07f0,                    /* src_mask.  */
1389          0xffff07f0,                    /* dst_mask.  */
1390          FALSE),                        /* pcrel_offset.  */
1391
1392   /* A PC relative 32 bit branch.  */
1393   HOWTO (R_V850_32_PCREL,               /* type.  */
1394          1,                             /* rightshift.  */
1395          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1396          32,                            /* bitsize.  */
1397          TRUE,                          /* pc_relative.  */
1398          1,                             /* bitpos.  */
1399          complain_overflow_signed,      /* complain_on_overflow.  */
1400          v850_elf_reloc,                /* special_function.  */
1401          "R_V850_32_PCREL",             /* name.  */
1402          FALSE,                         /* partial_inplace.  */
1403          0xfffffffe,                    /* src_mask.  */
1404          0xfffffffe,                    /* dst_mask.  */
1405          TRUE),                         /* pcrel_offset.  */
1406
1407   /* A absolute 32 bit branch.  */
1408   HOWTO (R_V850_32_ABS,                 /* type.  */
1409          1,                             /* rightshift.  */
1410          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1411          32,                            /* bitsize.  */
1412          TRUE,                          /* pc_relative.  */
1413          1,                             /* bitpos.  */
1414          complain_overflow_signed,      /* complain_on_overflow.  */
1415          v850_elf_reloc,                /* special_function.  */
1416          "R_V850_32_ABS",               /* name.  */
1417          FALSE,                         /* partial_inplace.  */
1418          0xfffffffe,                    /* src_mask.  */
1419          0xfffffffe,                    /* dst_mask.  */
1420          FALSE),                        /* pcrel_offset.  */
1421
1422   /* High 16 bits of symbol value.  */
1423   HOWTO (R_V850_HI16,                   /* Type.  */
1424          0,                             /* Rightshift.  */
1425          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1426          16,                            /* Bitsize.  */
1427          FALSE,                         /* PC_relative.  */
1428          0,                             /* Bitpos.  */
1429          complain_overflow_dont,        /* Complain_on_overflow.  */
1430          v850_elf_reloc,                /* Special_function.  */
1431          "R_V850_HI16",                 /* Name.  */
1432          FALSE,                         /* Partial_inplace.  */
1433          0xffff,                        /* Src_mask.  */
1434          0xffff,                        /* Dst_mask.  */
1435          FALSE),                        /* PCrel_offset.  */
1436
1437   /* Low 16 bits of symbol value.  */
1438   HOWTO (R_V850_16_S1,                  /* type.  */
1439          1,                             /* rightshift.  */
1440          1,                             /* size (0 = byte, 1 = short, 2 = long).  */
1441          16,                            /* bitsize.  */
1442          FALSE,                         /* pc_relative.  */
1443          1,                             /* bitpos.  */
1444          complain_overflow_dont,        /* complain_on_overflow.  */
1445          v850_elf_reloc,                /* special_function.  */
1446          "R_V850_16_S1",                /* name.  */
1447          FALSE,                         /* partial_inplace.  */
1448          0xfffe,                        /* src_mask.  */
1449          0xfffe,                        /* dst_mask.  */
1450          FALSE),                        /* pcrel_offset.  */
1451
1452   /* Low 16 bits of symbol value.  */
1453   HOWTO (R_V850_LO16_S1,                /* type.  */
1454          1,                             /* rightshift.  */
1455          1,                             /* size (0 = byte, 1 = short, 2 = long).  */
1456          16,                            /* bitsize.  */
1457          FALSE,                         /* pc_relative.  */
1458          1,                             /* bitpos.  */
1459          complain_overflow_dont,        /* complain_on_overflow.  */
1460          v850_elf_reloc,                /* special_function.  */
1461          "R_V850_LO16_S1",              /* name.  */
1462          FALSE,                         /* partial_inplace.  */
1463          0xfffe,                        /* src_mask.  */
1464          0xfffe,                        /* dst_mask.  */
1465          FALSE),                        /* pcrel_offset.  */
1466
1467   /* 16 bit offset from the call table base pointer.  */
1468   HOWTO (R_V850_CALLT_15_16_OFFSET,     /* type.  */
1469          1,                             /* rightshift.  */
1470          1,                             /* size (0 = byte, 1 = short, 2 = long).  */
1471          16,                            /* bitsize.  */
1472          FALSE,                         /* pc_relative.  */
1473          1,                             /* bitpos.  */
1474          complain_overflow_dont,        /* complain_on_overflow.  */
1475          v850_elf_reloc,                /* special_function.  */
1476          "R_V850_CALLT_15_16_OFFSET",   /* name.  */
1477          FALSE,                         /* partial_inplace.  */
1478          0xfffe,                        /* src_mask.  */
1479          0xfffe,                        /* dst_mask.  */
1480          FALSE),                        /* pcrel_offset.  */
1481
1482   /* Like R_V850_32 PCREL, but referring to the GOT table entry for
1483      the symbol.  */
1484   HOWTO (R_V850_32_GOTPCREL,            /* type.  */
1485          0,                             /* rightshift.  */
1486          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1487          32,                            /* bitsize.  */
1488          TRUE,                          /* pc_relative.  */
1489          0,                             /* bitpos.  */
1490          complain_overflow_unsigned,    /* complain_on_overflow.  */
1491          v850_elf_reloc,                /* special_function.  */
1492          "R_V850_32_GOTPCREL",          /* name.  */
1493          FALSE,                         /* partial_inplace.  */
1494          0xffffffff,                    /* src_mask.  */
1495          0xffffffff,                    /* dst_mask.  */
1496          TRUE),                         /* pcrel_offset.  */
1497
1498   /* Like R_V850_SDA_, but referring to the GOT table entry for
1499      the symbol.  */
1500   HOWTO (R_V850_16_GOT,                 /* type.  */
1501          0,                             /* rightshift.  */
1502          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1503          16,                            /* bitsize.  */
1504          FALSE,                         /* pc_relative.  */
1505          0,                             /* bitpos.  */
1506          complain_overflow_unsigned,    /* complain_on_overflow.  */
1507          bfd_elf_generic_reloc,         /* special_function.  */
1508          "R_V850_16_GOT",               /* name.  */
1509          FALSE,                         /* partial_inplace.  */
1510          0xffff,                        /* src_mask.  */
1511          0xffff,                        /* dst_mask.  */
1512          FALSE),                        /* pcrel_offset.  */
1513
1514   HOWTO (R_V850_32_GOT,                 /* type.  */
1515          0,                             /* rightshift.  */
1516          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1517          32,                            /* bitsize.  */
1518          FALSE,                         /* pc_relative.  */
1519          0,                             /* bitpos.  */
1520          complain_overflow_unsigned,    /* complain_on_overflow.  */
1521          bfd_elf_generic_reloc,         /* special_function.  */
1522          "R_V850_32_GOT",               /* name.  */
1523          FALSE,                         /* partial_inplace.  */
1524          0xffffffff,                    /* src_mask.  */
1525          0xffffffff,                    /* dst_mask.  */
1526          FALSE),                        /* pcrel_offset.  */
1527
1528   /* Like R_V850_22_PCREL, but referring to the procedure linkage table
1529      entry for the symbol.  */
1530   HOWTO (R_V850_22_PLT,                 /* type.  */
1531          1,                             /* rightshift.  */
1532          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1533          22,                            /* bitsize.  */
1534          TRUE,                          /* pc_relative.  */
1535          7,                             /* bitpos.  */
1536          complain_overflow_signed,      /* complain_on_overflow.  */
1537          bfd_elf_generic_reloc,         /* special_function.  */
1538          "R_V850_22_PLT",               /* name.  */
1539          FALSE,                         /* partial_inplace.  */
1540          0x07ffff80,                    /* src_mask.  */
1541          0x07ffff80,                    /* dst_mask.  */
1542          TRUE),                         /* pcrel_offset.  */
1543
1544   HOWTO (R_V850_32_PLT,                 /* type.  */
1545          1,                             /* rightshift.  */
1546          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1547          32,                            /* bitsize.  */
1548          TRUE,                          /* pc_relative.  */
1549          1,                             /* bitpos.  */
1550          complain_overflow_signed,      /* complain_on_overflow.  */
1551          bfd_elf_generic_reloc,         /* special_function.  */
1552          "R_V850_32_PLT",               /* name.  */
1553          FALSE,                         /* partial_inplace.  */
1554          0xffffffff,                    /* src_mask.  */
1555          0xffffffff,                    /* dst_mask.  */
1556          TRUE),                         /* pcrel_offset.  */
1557
1558   /* This is used only by the dynamic linker.  The symbol should exist
1559      both in the object being run and in some shared library.  The
1560      dynamic linker copies the data addressed by the symbol from the
1561      shared library into the object, because the object being
1562      run has to have the data at some particular address.  */
1563   HOWTO (R_V850_COPY,                   /* type.  */
1564          0,                             /* rightshift.  */
1565          2,                             /* size (0 = byte, 1 = short, 2 = long).  */
1566          32,                            /* bitsize.  */
1567          FALSE,                         /* pc_relative.  */
1568          0,                             /* bitpos.  */
1569          complain_overflow_bitfield,    /* complain_on_overflow.  */
1570          bfd_elf_generic_reloc,         /* special_function.  */
1571          "R_V850_COPY",                 /* name.  */
1572          FALSE,                         /* partial_inplace.  */
1573          0xffffffff,                    /* src_mask.  */
1574          0xffffffff,                    /* dst_mask.  */
1575          FALSE),                        /* pcrel_offset.  */
1576
1577   /* Like R_M32R_24, but used when setting global offset table
1578      entries.  */
1579   HOWTO (R_V850_GLOB_DAT,               /* type.  */
1580          0,                             /* rightshift.  */
1581          2,                             /* size (0 = byte, 1 = short, 2 = long) */
1582          32,                            /* bitsize.  */
1583          FALSE,                         /* pc_relative.  */
1584          0,                             /* bitpos.  */
1585          complain_overflow_bitfield,    /* complain_on_overflow.  */
1586          bfd_elf_generic_reloc,         /* special_function.  */
1587          "R_V850_GLOB_DAT",             /* name.  */
1588          FALSE,                         /* partial_inplace.  */
1589          0xffffffff,                    /* src_mask.  */
1590          0xffffffff,                    /* dst_mask.  */
1591          FALSE),                        /* pcrel_offset.  */
1592
1593   /* Marks a procedure linkage table entry for a symbol.  */
1594   HOWTO (R_V850_JMP_SLOT,               /* type.  */
1595          0,                             /* rightshift.  */
1596          2,                             /* size (0 = byte, 1 = short, 2 = long) */
1597          32,                            /* bitsize.  */
1598          FALSE,                         /* pc_relative.  */
1599          0,                             /* bitpos.  */
1600          complain_overflow_bitfield,    /* complain_on_overflow.  */
1601          bfd_elf_generic_reloc,         /* special_function.  */
1602          "R_V850_JMP_SLOT",             /* name.  */
1603          FALSE,                         /* partial_inplace.  */
1604          0xffffffff,                    /* src_mask.  */
1605          0xffffffff,                    /* dst_mask.  */
1606          FALSE),                        /* pcrel_offset.  */
1607
1608   /* Used only by the dynamic linker.  When the object is run, this
1609      longword is set to the load address of the object, plus the
1610      addend.  */
1611   HOWTO (R_V850_RELATIVE,               /* type.  */
1612          0,                             /* rightshift.  */
1613          2,                             /* size (0 = byte, 1 = short, 2 = long) */
1614          32,                            /* bitsize.  */
1615          FALSE,                         /* pc_relative.  */
1616          0,                             /* bitpos.  */
1617          complain_overflow_bitfield,    /* complain_on_overflow.  */
1618          bfd_elf_generic_reloc,         /* special_function.  */
1619          "R_V850_RELATIVE",             /* name.  */
1620          FALSE,                         /* partial_inplace.  */
1621          0xffffffff,                    /* src_mask.  */
1622          0xffffffff,                    /* dst_mask.  */
1623          FALSE),                        /* pcrel_offset.  */
1624
1625   HOWTO (R_V850_16_GOTOFF,              /* type.  */
1626          0,                             /* rightshift.  */
1627          2,                             /* size (0 = byte, 1 = short, 2 = long) */
1628          16,                            /* bitsize.  */
1629          FALSE,                         /* pc_relative.  */
1630          0,                             /* bitpos.  */
1631          complain_overflow_bitfield,    /* complain_on_overflow.  */
1632          bfd_elf_generic_reloc,         /* special_function.  */
1633          "R_V850_16_GOTOFF",            /* name.  */
1634          FALSE,                         /* partial_inplace.  */
1635          0xffff,                        /* src_mask.  */
1636          0xffff,                        /* dst_mask.  */
1637          FALSE),                        /* pcrel_offset.  */
1638
1639   HOWTO (R_V850_32_GOTOFF,              /* type.  */
1640          0,                             /* rightshift.  */
1641          2,                             /* size (0 = byte, 1 = short, 2 = long) */
1642          32,                            /* bitsize.  */
1643          FALSE,                         /* pc_relative.  */
1644          0,                             /* bitpos.  */
1645          complain_overflow_bitfield,    /* complain_on_overflow.  */
1646          bfd_elf_generic_reloc,         /* special_function.  */
1647          "R_V850_32_GOTOFF",            /* name.  */
1648          FALSE,                         /* partial_inplace.  */
1649          0xffffffff,                    /* src_mask.  */
1650          0xffffffff,                    /* dst_mask.  */
1651          FALSE),                        /* pcrel_offset.  */
1652
1653   HOWTO (R_V850_CODE,                   /* type.  */
1654          0,                             /* rightshift.  */
1655          1,                             /* size (0 = byte, 1 = short, 2 = long) */
1656          0,                             /* bitsize.  */
1657          FALSE,                         /* pc_relative.  */
1658          0,                             /* bitpos.  */
1659          complain_overflow_unsigned,    /* complain_on_overflow.  */
1660          v850_elf_ignore_reloc,         /* special_function.  */
1661          "R_V850_CODE",                 /* name.  */
1662          FALSE,                         /* partial_inplace.  */
1663          0,                             /* src_mask.  */
1664          0,                             /* dst_mask.  */
1665          TRUE),                         /* pcrel_offset.  */
1666
1667   HOWTO (R_V850_DATA,                   /* type.  */
1668          0,                             /* rightshift.  */
1669          1,                             /* size (0 = byte, 1 = short, 2 = long) */
1670          0,                             /* bitsize.  */
1671          FALSE,                         /* pc_relative.  */
1672          0,                             /* bitpos.  */
1673          complain_overflow_unsigned,    /* complain_on_overflow.  */
1674          v850_elf_ignore_reloc,         /* special_function.  */
1675          "R_V850_DATA",                 /* name.  */
1676          FALSE,                         /* partial_inplace.  */
1677          0,                             /* src_mask.  */
1678          0,                             /* dst_mask.  */
1679          TRUE),                         /* pcrel_offset.  */
1680
1681 };
1682
1683 /* Map BFD reloc types to V850 ELF reloc types.  */
1684
1685 struct v850_elf_reloc_map
1686 {
1687   /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an
1688      unsigned char.  */
1689   bfd_reloc_code_real_type bfd_reloc_val;
1690   unsigned int elf_reloc_val;
1691 };
1692
1693 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
1694 {
1695   { BFD_RELOC_NONE,                        R_V850_NONE                   },
1696   { BFD_RELOC_V850_9_PCREL,                R_V850_9_PCREL                },
1697   { BFD_RELOC_V850_22_PCREL,               R_V850_22_PCREL               },
1698   { BFD_RELOC_HI16_S,                      R_V850_HI16_S                 },
1699   { BFD_RELOC_HI16,                        R_V850_HI16                   },
1700   { BFD_RELOC_LO16,                        R_V850_LO16                   },
1701   { BFD_RELOC_32,                          R_V850_ABS32                  },
1702   { BFD_RELOC_32_PCREL,                    R_V850_REL32                  },
1703   { BFD_RELOC_16,                          R_V850_16                     },
1704   { BFD_RELOC_8,                           R_V850_8                      },
1705   { BFD_RELOC_V850_SDA_16_16_OFFSET,       R_V850_SDA_16_16_OFFSET       },
1706   { BFD_RELOC_V850_SDA_15_16_OFFSET,       R_V850_SDA_15_16_OFFSET       },
1707   { BFD_RELOC_V850_ZDA_16_16_OFFSET,       R_V850_ZDA_16_16_OFFSET       },
1708   { BFD_RELOC_V850_ZDA_15_16_OFFSET,       R_V850_ZDA_15_16_OFFSET       },
1709   { BFD_RELOC_V850_TDA_6_8_OFFSET,         R_V850_TDA_6_8_OFFSET         },
1710   { BFD_RELOC_V850_TDA_7_8_OFFSET,         R_V850_TDA_7_8_OFFSET         },
1711   { BFD_RELOC_V850_TDA_7_7_OFFSET,         R_V850_TDA_7_7_OFFSET         },
1712   { BFD_RELOC_V850_TDA_16_16_OFFSET,       R_V850_TDA_16_16_OFFSET       },
1713   { BFD_RELOC_V850_TDA_4_5_OFFSET,         R_V850_TDA_4_5_OFFSET         },
1714   { BFD_RELOC_V850_TDA_4_4_OFFSET,         R_V850_TDA_4_4_OFFSET         },
1715   { BFD_RELOC_V850_LO16_SPLIT_OFFSET,      R_V850_LO16_SPLIT_OFFSET      },
1716   { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
1717   { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
1718   { BFD_RELOC_V850_CALLT_6_7_OFFSET,       R_V850_CALLT_6_7_OFFSET       },
1719   { BFD_RELOC_V850_CALLT_16_16_OFFSET,     R_V850_CALLT_16_16_OFFSET     },
1720   { BFD_RELOC_VTABLE_INHERIT,              R_V850_GNU_VTINHERIT          },
1721   { BFD_RELOC_VTABLE_ENTRY,                R_V850_GNU_VTENTRY            },
1722   { BFD_RELOC_V850_LONGCALL,               R_V850_LONGCALL               },
1723   { BFD_RELOC_V850_LONGJUMP,               R_V850_LONGJUMP               },
1724   { BFD_RELOC_V850_ALIGN,                  R_V850_ALIGN                  },
1725   { BFD_RELOC_V850_16_PCREL,               R_V850_16_PCREL               },
1726   { BFD_RELOC_V850_17_PCREL,               R_V850_17_PCREL               },
1727   { BFD_RELOC_V850_23,                     R_V850_23                     },
1728   { BFD_RELOC_V850_32_PCREL,               R_V850_32_PCREL               },
1729   { BFD_RELOC_V850_32_ABS,                 R_V850_32_ABS                 },
1730   { BFD_RELOC_V850_16_SPLIT_OFFSET,        R_V850_HI16                   },
1731   { BFD_RELOC_V850_16_S1,                  R_V850_16_S1                  },
1732   { BFD_RELOC_V850_LO16_S1,                R_V850_LO16_S1                },
1733   { BFD_RELOC_V850_CALLT_15_16_OFFSET,     R_V850_CALLT_15_16_OFFSET     },
1734   { BFD_RELOC_V850_32_GOTPCREL,            R_V850_32_GOTPCREL            },
1735   { BFD_RELOC_V850_16_GOT,                 R_V850_16_GOT                 },
1736   { BFD_RELOC_V850_32_GOT,                 R_V850_32_GOT                 },
1737   { BFD_RELOC_V850_22_PLT_PCREL,           R_V850_22_PLT                 },
1738   { BFD_RELOC_V850_32_PLT_PCREL,           R_V850_32_PLT                 },
1739   { BFD_RELOC_V850_COPY,                   R_V850_COPY                   },
1740   { BFD_RELOC_V850_GLOB_DAT,               R_V850_GLOB_DAT               },
1741   { BFD_RELOC_V850_JMP_SLOT,               R_V850_JMP_SLOT               },
1742   { BFD_RELOC_V850_RELATIVE,               R_V850_RELATIVE               },
1743   { BFD_RELOC_V850_16_GOTOFF,              R_V850_16_GOTOFF              },
1744   { BFD_RELOC_V850_32_GOTOFF,              R_V850_32_GOTOFF              },
1745   { BFD_RELOC_V850_CODE,                   R_V850_CODE                   },
1746   { BFD_RELOC_V850_DATA,                   R_V850_DATA                   },
1747 };
1748
1749 #define V800_RELOC(name,sz,bit,shift,complain,pcrel,resolver)            \
1750   HOWTO (name, shift, sz, bit, pcrel, 0, complain_overflow_ ## complain, \
1751          bfd_elf_ ## resolver ## _reloc, #name, FALSE, 0, ~0, FALSE)
1752
1753 #define V800_EMPTY(name) EMPTY_HOWTO (name - R_V810_NONE)
1754
1755 #define bfd_elf_v850_reloc v850_elf_reloc
1756
1757 /* Note: It is REQUIRED that the 'type' value (R_V810_...) of each entry
1758    in this array match the index of the entry in the array minus 0x30.
1759    See: bfd_elf_v850_relocate_section(), v800_elf_reloc_type_lookup()
1760    and v800_elf_info_to_howto().  */
1761
1762 static reloc_howto_type v800_elf_howto_table[] =
1763 {
1764   V800_RELOC (R_V810_NONE,      0,  0, 0, dont,     FALSE, generic),    /* Type = 0x30 */
1765   V800_RELOC (R_V810_BYTE,      0,  8, 0, dont,     FALSE, generic),
1766   V800_RELOC (R_V810_HWORD,     1, 16, 0, dont,     FALSE, generic),
1767   V800_RELOC (R_V810_WORD,      2, 32, 0, dont,     FALSE, generic),
1768   V800_RELOC (R_V810_WLO,       1, 16, 0, dont,     FALSE, generic),
1769   V800_RELOC (R_V810_WHI,       1, 16, 0, dont,     FALSE, generic),
1770   V800_RELOC (R_V810_WHI1,      1, 16, 0, dont,     FALSE, generic),
1771   V800_RELOC (R_V810_GPBYTE,    0,  8, 0, dont,     FALSE, v850),
1772   V800_RELOC (R_V810_GPHWORD,   1, 16, 0, dont,     FALSE, v850),
1773   V800_RELOC (R_V810_GPWORD,    2, 32, 0, dont,     FALSE, v850),
1774   V800_RELOC (R_V810_GPWLO,     1, 16, 0, dont,     FALSE, v850),
1775   V800_RELOC (R_V810_GPWHI,     1, 16, 0, dont,     FALSE, v850),
1776   V800_RELOC (R_V810_GPWHI1,    1, 16, 0, dont,     FALSE, v850),
1777   V800_RELOC (R_V850_HWLO,      1, 16, 0, dont,     FALSE, generic),
1778   V800_EMPTY (R_V810_reserved1),
1779   V800_RELOC (R_V850_EP7BIT,    0,  7, 0, unsigned, FALSE, v850),
1780   V800_RELOC (R_V850_EPHBYTE,   0,  8, 1, unsigned, FALSE, v850),
1781   V800_RELOC (R_V850_EPWBYTE,   0,  8, 2, unsigned, FALSE, v850),
1782   V800_RELOC (R_V850_REGHWLO,   1, 16, 0, dont,     FALSE, v850),
1783   V800_EMPTY (R_V810_reserved2),
1784   V800_RELOC (R_V850_GPHWLO,    1, 16, 0, dont,     FALSE, v850),
1785   V800_EMPTY (R_V810_reserved3),
1786   V800_RELOC (R_V850_PCR22,     2, 22, 0, signed,   TRUE,  generic),
1787   V800_RELOC (R_V850_BLO,       2, 24, 0, dont,     FALSE, v850),
1788   V800_RELOC (R_V850_EP4BIT,    0,  4, 0, unsigned, FALSE, v850),
1789   V800_RELOC (R_V850_EP5BIT,    0,  5, 0, unsigned, FALSE, v850),
1790   V800_RELOC (R_V850_REGBLO,    2, 24, 0, dont,     FALSE, v850),
1791   V800_RELOC (R_V850_GPBLO,     2, 24, 0, dont,     FALSE, v850),
1792   V800_RELOC (R_V810_WLO_1,     1, 16, 0, dont,     FALSE, v850),
1793   V800_RELOC (R_V810_GPWLO_1,   1, 16, 0, signed,   FALSE, v850),
1794   V800_RELOC (R_V850_BLO_1,     2, 16, 0, signed,   FALSE, v850),
1795   V800_RELOC (R_V850_HWLO_1,    1, 16, 0, signed,   FALSE, v850),
1796   V800_EMPTY  (R_V810_reserved4),
1797   V800_RELOC (R_V850_GPBLO_1,   2, 16, 1, signed,   FALSE, v850),
1798   V800_RELOC (R_V850_GPHWLO_1,  1, 16, 1, signed,   FALSE, v850),
1799   V800_EMPTY (R_V810_reserved5),
1800   V800_RELOC (R_V850_EPBLO,     2, 16, 1, signed,   FALSE, v850),
1801   V800_RELOC (R_V850_EPHWLO,    1, 16, 1, signed,   FALSE, v850),
1802   V800_EMPTY (R_V810_reserved6),
1803   V800_RELOC (R_V850_EPWLO_N,   1, 16, 1, signed,   FALSE, v850),
1804   V800_RELOC (R_V850_PC32,      2, 32, 1, signed,   TRUE,  v850),
1805   V800_RELOC (R_V850_W23BIT,    2, 23, 1, signed,   FALSE, v850),
1806   V800_RELOC (R_V850_GPW23BIT,  2, 23, 1, signed,   FALSE, v850),
1807   V800_RELOC (R_V850_EPW23BIT,  2, 23, 1, signed,   FALSE, v850),
1808   V800_RELOC (R_V850_B23BIT,    2, 23, 1, signed,   FALSE, v850),
1809   V800_RELOC (R_V850_GPB23BIT,  2, 23, 1, signed,   FALSE, v850),
1810   V800_RELOC (R_V850_EPB23BIT,  2, 23, 1, signed,   FALSE, v850),
1811   V800_RELOC (R_V850_PC16U,     1, 16, 1, unsigned, TRUE,  generic),
1812   V800_RELOC (R_V850_PC17,      2, 17, 1, signed,   TRUE,  generic),
1813   V800_RELOC (R_V850_DW8,       2,  8, 2, signed,   FALSE, v850),
1814   V800_RELOC (R_V850_GPDW8,     2,  8, 2, signed,   FALSE, v850),
1815   V800_RELOC (R_V850_EPDW8,     2,  8, 2, signed,   FALSE, v850),
1816   V800_RELOC (R_V850_PC9,       1,  9, 3, signed,   TRUE,  v850),
1817   V800_RELOC (R_V810_REGBYTE,   0,  8, 0, dont,     FALSE, v850),
1818   V800_RELOC (R_V810_REGHWORD,  1, 16, 0, dont,     FALSE, v850),
1819   V800_RELOC (R_V810_REGWORD,   2, 32, 0, dont,     FALSE, v850),
1820   V800_RELOC (R_V810_REGWLO,    1, 16, 0, dont,     FALSE, v850),
1821   V800_RELOC (R_V810_REGWHI,    1, 16, 0, dont,     FALSE, v850),
1822   V800_RELOC (R_V810_REGWHI1,   1, 16, 0, dont,     FALSE, v850),
1823   V800_RELOC (R_V850_REGW23BIT, 2, 23, 1, signed,   FALSE, v850),
1824   V800_RELOC (R_V850_REGB23BIT, 2, 23, 1, signed,   FALSE, v850),
1825   V800_RELOC (R_V850_REGDW8,    2,  8, 2, signed,   FALSE, v850),
1826   V800_RELOC (R_V810_EPBYTE,    0,  8, 0, dont,     FALSE, v850),
1827   V800_RELOC (R_V810_EPHWORD,   1, 16, 0, dont,     FALSE, v850),
1828   V800_RELOC (R_V810_EPWORD,    2, 32, 0, dont,     FALSE, v850),
1829   V800_RELOC (R_V850_WLO23,     2, 32, 1, dont,     FALSE, v850),
1830   V800_RELOC (R_V850_WORD_E,    2, 32, 1, dont,     FALSE, v850),
1831   V800_RELOC (R_V850_REGWORD_E, 2, 32, 1, dont,     FALSE, v850),
1832   V800_RELOC (R_V850_WORD,      2, 32, 0, dont,     FALSE, v850),
1833   V800_RELOC (R_V850_GPWORD,    2, 32, 0, dont,     FALSE, v850),
1834   V800_RELOC (R_V850_REGWORD,   2, 32, 0, dont,     FALSE, v850),
1835   V800_RELOC (R_V850_EPWORD,    2, 32, 0, dont,     FALSE, v850),
1836   V800_RELOC (R_V810_TPBYTE,    0,  8, 0, dont,     FALSE, v850),
1837   V800_RELOC (R_V810_TPHWORD,   1, 16, 0, dont,     FALSE, v850),
1838   V800_RELOC (R_V810_TPWORD,    2, 32, 0, dont,     FALSE, v850),
1839   V800_RELOC (R_V810_TPWLO,     1, 16, 0, dont,     FALSE, v850),
1840   V800_RELOC (R_V810_TPWHI,     1, 16, 0, dont,     FALSE, v850),
1841   V800_RELOC (R_V810_TPWHI1,    1, 16, 0, dont,     FALSE, v850),
1842   V800_RELOC (R_V850_TPHWLO,    1, 16, 1, dont,     FALSE, v850),
1843   V800_RELOC (R_V850_TPBLO,     2, 24, 0, dont,     FALSE, v850),
1844   V800_RELOC (R_V810_TPWLO_1,   1, 16, 0, signed,   FALSE, v850),
1845   V800_RELOC (R_V850_TPBLO_1,   2, 16, 0, signed,   FALSE, v850),
1846   V800_RELOC (R_V850_TPHWLO_1,  1, 16, 0, signed,   FALSE, v850),
1847   V800_RELOC (R_V850_TP23BIT,   2, 23, 0, signed,   FALSE, v850),
1848   V800_RELOC (R_V850_TPW23BIT,  2, 23, 0, signed,   FALSE, v850),
1849   V800_RELOC (R_V850_TPDW8,     2,  8, 0, signed,   FALSE, v850)
1850 };
1851 \f
1852 /* Map a bfd relocation into the appropriate howto structure.  */
1853
1854 static reloc_howto_type *
1855 v850_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1856                             bfd_reloc_code_real_type code)
1857 {
1858   unsigned int i;
1859
1860   for (i = ARRAY_SIZE (v850_elf_reloc_map); i --;)
1861     if (v850_elf_reloc_map[i].bfd_reloc_val == code)
1862       {
1863         unsigned int elf_reloc_val = v850_elf_reloc_map[i].elf_reloc_val;
1864
1865         BFD_ASSERT (v850_elf_howto_table[elf_reloc_val].type == elf_reloc_val);
1866
1867         return v850_elf_howto_table + elf_reloc_val;
1868       }
1869
1870   return NULL;
1871 }
1872
1873 static reloc_howto_type *
1874 v850_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1875                             const char *r_name)
1876 {
1877   unsigned int i;
1878
1879   for (i = 0;
1880        i < sizeof (v850_elf_howto_table) / sizeof (v850_elf_howto_table[0]);
1881        i++)
1882     if (v850_elf_howto_table[i].name != NULL
1883         && strcasecmp (v850_elf_howto_table[i].name, r_name) == 0)
1884       return &v850_elf_howto_table[i];
1885
1886   return NULL;
1887 }
1888 \f
1889 /* Set the howto pointer for an V850 ELF reloc.  */
1890
1891 static void
1892 v850_elf_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1893                             arelent *cache_ptr,
1894                             Elf_Internal_Rela *dst)
1895 {
1896   unsigned int r_type;
1897
1898   r_type = ELF32_R_TYPE (dst->r_info);
1899   if (r_type >= (unsigned int) R_V850_max)
1900     {
1901       /* xgettext:c-format */
1902       _bfd_error_handler (_("%B: invalid V850 reloc number: %d"), abfd, r_type);
1903       r_type = 0;
1904     }
1905   cache_ptr->howto = &v850_elf_howto_table[r_type];
1906 }
1907
1908 /* Set the howto pointer for a V850 ELF reloc (type RELA).  */
1909
1910 static void
1911 v850_elf_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
1912                              arelent * cache_ptr,
1913                              Elf_Internal_Rela *dst)
1914 {
1915   unsigned int r_type;
1916
1917   r_type = ELF32_R_TYPE (dst->r_info);
1918   if (r_type >= (unsigned int) R_V850_max)
1919     {
1920       /* xgettext:c-format */
1921       _bfd_error_handler (_("%B: invalid V850 reloc number: %d"), abfd, r_type);
1922       r_type = 0;
1923     }
1924   cache_ptr->howto = &v850_elf_howto_table[r_type];
1925 }
1926 \f
1927 static bfd_boolean
1928 v850_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1929 {
1930   return (   (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1931           || (name[0] == '_' &&  name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1932 }
1933
1934 static bfd_boolean
1935 v850_elf_is_target_special_symbol (bfd *abfd, asymbol *sym)
1936 {
1937   return v850_elf_is_local_label_name (abfd, sym->name);
1938 }
1939 \f
1940 /* We overload some of the bfd_reloc error codes for own purposes.  */
1941 #define bfd_reloc_gp_not_found          bfd_reloc_other
1942 #define bfd_reloc_ep_not_found          bfd_reloc_continue
1943 #define bfd_reloc_ctbp_not_found        (bfd_reloc_dangerous + 1)
1944
1945 /* Perform a relocation as part of a final link.  */
1946
1947 static bfd_reloc_status_type
1948 v850_elf_final_link_relocate (reloc_howto_type *howto,
1949                               bfd *input_bfd,
1950                               bfd *output_bfd ATTRIBUTE_UNUSED,
1951                               asection *input_section,
1952                               bfd_byte *contents,
1953                               bfd_vma offset,
1954                               bfd_vma value,
1955                               bfd_vma addend,
1956                               struct bfd_link_info *info,
1957                               asection *sym_sec,
1958                               int is_local ATTRIBUTE_UNUSED)
1959 {
1960   unsigned int r_type = howto->type;
1961   bfd_byte *hit_data = contents + offset;
1962
1963   /* Adjust the value according to the relocation.  */
1964   switch (r_type)
1965     {
1966     case R_V850_PC9:
1967     case R_V850_9_PCREL:
1968       value -= (input_section->output_section->vma
1969                 + input_section->output_offset);
1970       value -= offset;
1971       break;
1972
1973     case R_V850_PC16U:
1974     case R_V850_16_PCREL:
1975       value -= (input_section->output_section->vma
1976                 + input_section->output_offset
1977                 + offset);
1978
1979       /* If the sign extension will corrupt the value then we have overflowed.  */
1980       if ((value & 0xffff0000) != 0xffff0000)
1981         return bfd_reloc_overflow;
1982
1983       break;
1984
1985     case R_V850_PC17:
1986     case R_V850_17_PCREL:
1987       value -= (input_section->output_section->vma
1988                 + input_section->output_offset
1989                 + offset);
1990
1991       /* If the sign extension will corrupt the value then we have overflowed.  */
1992       if (((value & 0xffff0000) != 0x0) && ((value & 0xffff0000) != 0xffff0000))
1993         return bfd_reloc_overflow;
1994
1995       value = SEXT17 (value);
1996       break;
1997
1998     case R_V850_PCR22:
1999     case R_V850_22_PCREL:
2000       value -= (input_section->output_section->vma
2001                 + input_section->output_offset
2002                 + offset);
2003
2004       /* If the sign extension will corrupt the value then we have overflowed.  */
2005       if (((value & 0xffe00000) != 0x0) && ((value & 0xffe00000) != 0xffe00000))
2006         return bfd_reloc_overflow;
2007
2008       /* Only the bottom 22 bits of the PC are valid.  */
2009       value = SEXT22 (value);
2010       break;
2011
2012     case R_V850_PC32:
2013     case R_V850_32_PCREL:
2014       value -= (input_section->output_section->vma
2015                 + input_section->output_offset
2016                 + offset);
2017       break;
2018
2019     case R_V850_32_ABS:
2020     case R_V850_23:
2021     case R_V850_HI16_S:
2022     case R_V850_HI16:
2023     case R_V850_LO16:
2024     case R_V850_LO16_S1:
2025     case R_V850_LO16_SPLIT_OFFSET:
2026     case R_V850_16:
2027     case R_V850_ABS32:
2028     case R_V850_8:
2029     case R_V810_BYTE:
2030     case R_V810_HWORD:
2031     case R_V810_WORD:
2032     case R_V810_WLO:
2033     case R_V810_WHI:
2034     case R_V810_WHI1:
2035     case R_V810_WLO_1:
2036     case R_V850_WLO23:
2037     case R_V850_BLO:
2038       break;
2039
2040     case R_V850_ZDA_15_16_OFFSET:
2041     case R_V850_ZDA_16_16_OFFSET:
2042     case R_V850_ZDA_16_16_SPLIT_OFFSET:
2043       if (sym_sec == NULL)
2044         return bfd_reloc_undefined;
2045
2046       value -= sym_sec->output_section->vma;
2047       break;
2048
2049     case R_V850_SDA_15_16_OFFSET:
2050     case R_V850_SDA_16_16_OFFSET:
2051     case R_V850_SDA_16_16_SPLIT_OFFSET:
2052     case R_V810_GPWLO_1:
2053       {
2054         unsigned long                gp;
2055         struct bfd_link_hash_entry * h;
2056
2057         if (sym_sec == NULL)
2058           return bfd_reloc_undefined;
2059
2060         /* Get the value of __gp.  */
2061         h = bfd_link_hash_lookup (info->hash, "__gp", FALSE, FALSE, TRUE);
2062         if (h == NULL
2063             || h->type != bfd_link_hash_defined)
2064           return bfd_reloc_gp_not_found;
2065
2066         gp = (h->u.def.value
2067               + h->u.def.section->output_section->vma
2068               + h->u.def.section->output_offset);
2069
2070         value -= sym_sec->output_section->vma;
2071         value -= (gp - sym_sec->output_section->vma);
2072       }
2073     break;
2074
2075     case R_V850_TDA_4_4_OFFSET:
2076     case R_V850_TDA_4_5_OFFSET:
2077     case R_V850_TDA_7_7_OFFSET:
2078     case R_V850_TDA_7_8_OFFSET:
2079     case R_V850_TDA_6_8_OFFSET:
2080     case R_V850_TDA_16_16_OFFSET:
2081       {
2082         unsigned long                ep;
2083         struct bfd_link_hash_entry * h;
2084
2085         /* Get the value of __ep.  */
2086         h = bfd_link_hash_lookup (info->hash, "__ep", FALSE, FALSE, TRUE);
2087         if (h == NULL
2088             || h->type != bfd_link_hash_defined)
2089           return bfd_reloc_ep_not_found;
2090
2091         ep = (h->u.def.value
2092               + h->u.def.section->output_section->vma
2093               + h->u.def.section->output_offset);
2094
2095         value -= ep;
2096       }
2097     break;
2098
2099     case R_V850_CALLT_6_7_OFFSET:
2100       {
2101         unsigned long                ctbp;
2102         struct bfd_link_hash_entry * h;
2103
2104         /* Get the value of __ctbp.  */
2105         h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE);
2106         if (h == NULL
2107             || h->type != bfd_link_hash_defined)
2108           return bfd_reloc_ctbp_not_found;
2109
2110         ctbp = (h->u.def.value
2111               + h->u.def.section->output_section->vma
2112               + h->u.def.section->output_offset);
2113         value -= ctbp;
2114       }
2115     break;
2116
2117     case R_V850_CALLT_15_16_OFFSET:
2118     case R_V850_CALLT_16_16_OFFSET:
2119       {
2120         unsigned long                ctbp;
2121         struct bfd_link_hash_entry * h;
2122
2123         if (sym_sec == NULL)
2124           return bfd_reloc_undefined;
2125
2126         /* Get the value of __ctbp.  */
2127         h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE);
2128         if (h == NULL
2129             || h->type != bfd_link_hash_defined)
2130           return bfd_reloc_ctbp_not_found;
2131
2132         ctbp = (h->u.def.value
2133               + h->u.def.section->output_section->vma
2134               + h->u.def.section->output_offset);
2135
2136         value -= sym_sec->output_section->vma;
2137         value -= (ctbp - sym_sec->output_section->vma);
2138       }
2139     break;
2140
2141     case R_V850_NONE:
2142     case R_V810_NONE:
2143     case R_V850_GNU_VTINHERIT:
2144     case R_V850_GNU_VTENTRY:
2145     case R_V850_LONGCALL:
2146     case R_V850_LONGJUMP:
2147     case R_V850_ALIGN:
2148       return bfd_reloc_ok;
2149
2150     default:
2151 #ifdef DEBUG
2152       fprintf (stderr, "%B: reloc number %d not recognised\n", input_bfd, r_type);
2153 #endif
2154       return bfd_reloc_notsupported;
2155     }
2156
2157   /* Perform the relocation.  */
2158   return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
2159 }
2160 \f
2161 /* Relocate an V850 ELF section.  */
2162
2163 static bfd_boolean
2164 v850_elf_relocate_section (bfd *output_bfd,
2165                            struct bfd_link_info *info,
2166                            bfd *input_bfd,
2167                            asection *input_section,
2168                            bfd_byte *contents,
2169                            Elf_Internal_Rela *relocs,
2170                            Elf_Internal_Sym *local_syms,
2171                            asection **local_sections)
2172 {
2173   Elf_Internal_Shdr *symtab_hdr;
2174   struct elf_link_hash_entry **sym_hashes;
2175   Elf_Internal_Rela *rel;
2176   Elf_Internal_Rela *relend;
2177
2178   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2179   sym_hashes = elf_sym_hashes (input_bfd);
2180
2181   /* Reset the list of remembered HI16S relocs to empty.  */
2182   free_hi16s     = previous_hi16s;
2183   previous_hi16s = NULL;
2184   hi16s_counter  = 0;
2185
2186   rel    = relocs;
2187   relend = relocs + input_section->reloc_count;
2188   for (; rel < relend; rel++)
2189     {
2190       unsigned int r_type;
2191       reloc_howto_type *howto;
2192       unsigned long r_symndx;
2193       Elf_Internal_Sym *sym;
2194       asection *sec;
2195       struct elf_link_hash_entry *h;
2196       bfd_vma relocation;
2197       bfd_reloc_status_type r;
2198
2199       r_symndx = ELF32_R_SYM (rel->r_info);
2200       r_type   = ELF32_R_TYPE (rel->r_info);
2201
2202       if (r_type == R_V850_GNU_VTENTRY
2203           || r_type == R_V850_GNU_VTINHERIT)
2204         continue;
2205
2206       if (bfd_get_arch (input_bfd) == bfd_arch_v850_rh850)
2207         howto = v800_elf_howto_table + (r_type - R_V810_NONE);
2208       else
2209         howto = v850_elf_howto_table + r_type;
2210
2211       BFD_ASSERT (r_type == howto->type);
2212
2213       h = NULL;
2214       sym = NULL;
2215       sec = NULL;
2216       if (r_symndx < symtab_hdr->sh_info)
2217         {
2218           sym = local_syms + r_symndx;
2219           sec = local_sections[r_symndx];
2220           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2221         }
2222       else
2223         {
2224           bfd_boolean unresolved_reloc, warned, ignored;
2225
2226           /* Note - this check is delayed until now as it is possible and
2227              valid to have a file without any symbols but with relocs that
2228              can be processed.  */
2229           if (sym_hashes == NULL)
2230             {
2231               info->callbacks->warning
2232                 (info, "no hash table available",
2233                  NULL, input_bfd, input_section, (bfd_vma) 0);
2234
2235               return FALSE;
2236             }
2237
2238           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2239                                    r_symndx, symtab_hdr, sym_hashes,
2240                                    h, sec, relocation,
2241                                    unresolved_reloc, warned, ignored);
2242         }
2243
2244       if (sec != NULL && discarded_section (sec))
2245         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2246                                          rel, 1, relend, howto, 0, contents);
2247
2248       if (bfd_link_relocatable (info))
2249         continue;
2250
2251       /* FIXME: We should use the addend, but the COFF relocations don't.  */
2252       r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
2253                                         input_section,
2254                                         contents, rel->r_offset,
2255                                         relocation, rel->r_addend,
2256                                         info, sec, h == NULL);
2257
2258       if (r != bfd_reloc_ok)
2259         {
2260           const char * name;
2261           const char * msg = NULL;
2262
2263           if (h != NULL)
2264             name = h->root.root.string;
2265           else
2266             {
2267               name = (bfd_elf_string_from_elf_section
2268                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
2269               if (name == NULL || *name == '\0')
2270                 name = bfd_section_name (input_bfd, sec);
2271             }
2272
2273           switch ((int) r)
2274             {
2275             case bfd_reloc_overflow:
2276               (*info->callbacks->reloc_overflow)
2277                 (info, (h ? &h->root : NULL), name, howto->name,
2278                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2279               break;
2280
2281             case bfd_reloc_undefined:
2282               (*info->callbacks->undefined_symbol)
2283                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2284               break;
2285
2286             case bfd_reloc_outofrange:
2287               msg = _("internal error: out of range error");
2288               goto common_error;
2289
2290             case bfd_reloc_notsupported:
2291               msg = _("internal error: unsupported relocation error");
2292               goto common_error;
2293
2294             case bfd_reloc_dangerous:
2295               msg = _("internal error: dangerous relocation");
2296               goto common_error;
2297
2298             case bfd_reloc_gp_not_found:
2299               msg = _("could not locate special linker symbol __gp");
2300               goto common_error;
2301
2302             case bfd_reloc_ep_not_found:
2303               msg = _("could not locate special linker symbol __ep");
2304               goto common_error;
2305
2306             case bfd_reloc_ctbp_not_found:
2307               msg = _("could not locate special linker symbol __ctbp");
2308               goto common_error;
2309
2310             default:
2311               msg = _("internal error: unknown error");
2312               /* fall through */
2313
2314             common_error:
2315               (*info->callbacks->warning) (info, msg, name, input_bfd,
2316                                            input_section, rel->r_offset);
2317               break;
2318             }
2319         }
2320     }
2321
2322   return TRUE;
2323 }
2324
2325 static asection *
2326 v850_elf_gc_mark_hook (asection *sec,
2327                        struct bfd_link_info *info,
2328                        Elf_Internal_Rela *rel,
2329                        struct elf_link_hash_entry *h,
2330                        Elf_Internal_Sym *sym)
2331 {
2332   if (h != NULL)
2333     switch (ELF32_R_TYPE (rel->r_info))
2334       {
2335       case R_V850_GNU_VTINHERIT:
2336       case R_V850_GNU_VTENTRY:
2337         return NULL;
2338       }
2339
2340   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2341 }
2342
2343 static void
2344 v850_set_note (bfd * abfd, asection * s, enum v850_notes note, unsigned int val)
2345 {
2346   bfd_byte * data = s->contents + ((note - 1) * SIZEOF_V850_NOTE);
2347
2348   bfd_put_32 (abfd, 4, data + 0);
2349   bfd_put_32 (abfd, 4, data + 4);
2350   bfd_put_32 (abfd, note, data + 8);
2351   memcpy (data + 12, V850_NOTE_NAME, 4);
2352   bfd_put_32 (abfd, val, data + 16);
2353 }
2354
2355 /* Create the note section if not already present.  This is done early so
2356    that the linker maps the sections to the right place in the output.  */
2357
2358 static asection *
2359 v850_elf_make_note_section (bfd * abfd)
2360 {
2361   asection *s;
2362   bfd_byte *data;
2363   flagword flags;
2364   enum v850_notes id;
2365
2366   /* Make the note section.  */
2367   flags = SEC_READONLY | SEC_HAS_CONTENTS | SEC_IN_MEMORY | SEC_MERGE;
2368
2369   s = bfd_make_section_anyway_with_flags (abfd, V850_NOTE_SECNAME, flags);
2370   if (s == NULL)
2371     return NULL;
2372
2373   if (!bfd_set_section_alignment (abfd, s, 2))
2374     return NULL;
2375
2376   /* Allocate space for all known notes.  */
2377   if (!bfd_set_section_size (abfd, s, NUM_V850_NOTES * SIZEOF_V850_NOTE))
2378     return NULL;
2379
2380   data = bfd_zalloc (abfd, NUM_V850_NOTES * SIZEOF_V850_NOTE);
2381   if (data == NULL)
2382     return NULL;
2383
2384   s->contents = data;
2385
2386   /* Provide default (= uninitilaised) values for all of the notes.  */
2387   for (id = V850_NOTE_ALIGNMENT; id <= NUM_V850_NOTES; id++)
2388     v850_set_note (abfd, s, id,  0);
2389
2390   return s;
2391 }
2392
2393 /* Create the note section if not already present.  This is done early so
2394    that the linker maps the sections to the right place in the output.  */
2395
2396 bfd_boolean
2397 v850_elf_create_sections (struct bfd_link_info * info)
2398 {
2399   bfd * ibfd;
2400
2401   /* If we already have a note section, do not make another.  */
2402   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2403     if (bfd_get_section_by_name (ibfd, V850_NOTE_SECNAME) != NULL)
2404       return TRUE;
2405
2406   return v850_elf_make_note_section (info->input_bfds) != NULL;
2407 }
2408
2409 bfd_boolean
2410 v850_elf_set_note (bfd * abfd, enum v850_notes note, unsigned int val)
2411 {
2412   asection * notes = bfd_get_section_by_name (abfd, V850_NOTE_SECNAME);
2413
2414   if (val > 2)
2415     /* At the moment, no known note has a value over 2.  */
2416     return FALSE;
2417
2418   if (notes == NULL)
2419     notes = v850_elf_make_note_section (abfd);
2420   if (notes == NULL)
2421     return FALSE;
2422
2423   v850_set_note (abfd, notes, note, val);
2424   return TRUE;
2425 }
2426
2427 /* Copy a v850 note section from one object module to another.  */
2428
2429 static void
2430 v850_elf_copy_notes (bfd *ibfd, bfd *obfd)
2431 {
2432   asection * onotes;
2433   asection * inotes;
2434
2435   /* If the output bfd does not have a note section, then
2436      skip the merge.  The normal input to output section
2437      copying will take care of everythng for us.  */
2438   if ((onotes = bfd_get_section_by_name (obfd, V850_NOTE_SECNAME)) == NULL)
2439     return;
2440
2441   if ((inotes = bfd_get_section_by_name (ibfd, V850_NOTE_SECNAME)) == NULL)
2442     return;
2443
2444   if (bfd_section_size (ibfd, inotes) == bfd_section_size (obfd, onotes))
2445     {
2446       bfd_byte * icont;
2447       bfd_byte * ocont;
2448
2449       if ((icont = elf_section_data (inotes)->this_hdr.contents) == NULL)
2450         BFD_ASSERT (bfd_malloc_and_get_section (ibfd, inotes, & icont));
2451
2452       if ((ocont = elf_section_data (onotes)->this_hdr.contents) == NULL)
2453         /* If the output is being stripped then it is possible for
2454            the notes section to disappear.  In this case do nothing.  */
2455         return;
2456
2457       /* Copy/overwrite notes from the input to the output.  */
2458       memcpy (ocont, icont, bfd_section_size (obfd, onotes));
2459     }
2460 }
2461
2462 /* Copy backend specific data from one object module to another.  */
2463
2464 static bfd_boolean
2465 v850_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2466 {
2467   v850_elf_copy_notes (ibfd, obfd);
2468   return _bfd_elf_copy_private_bfd_data (ibfd, obfd);
2469 }
2470 #define bfd_elf32_bfd_copy_private_bfd_data     v850_elf_copy_private_bfd_data
2471
2472 static bfd_boolean
2473 v850_elf_merge_notes (bfd * ibfd, bfd *obfd)
2474 {
2475   asection * onotes;
2476   asection * inotes;
2477   bfd_boolean result = TRUE;
2478
2479   /* If the output bfd does not have a note section, then
2480      skip the merge.  The normal input to output section
2481      copying will take care of everythng for us.  */
2482   if ((onotes = bfd_get_section_by_name (obfd, V850_NOTE_SECNAME)) == NULL)
2483     return TRUE;
2484
2485   if ((inotes = bfd_get_section_by_name (ibfd, V850_NOTE_SECNAME)) != NULL)
2486     {
2487       enum v850_notes id;
2488       bfd_byte * icont;
2489       bfd_byte * ocont;
2490
2491       BFD_ASSERT (bfd_section_size (ibfd, inotes) == bfd_section_size (obfd, onotes));
2492
2493       if ((icont = elf_section_data (inotes)->this_hdr.contents) == NULL)
2494         BFD_ASSERT (bfd_malloc_and_get_section (ibfd, inotes, & icont));
2495
2496       if ((ocont = elf_section_data (onotes)->this_hdr.contents) == NULL)
2497         BFD_ASSERT (bfd_malloc_and_get_section (obfd, onotes, & ocont));
2498
2499       for (id = V850_NOTE_ALIGNMENT; id <= NUM_V850_NOTES; id++)
2500         {
2501           unsigned int ival;
2502           unsigned int oval;
2503           bfd_byte * idata = icont + ((id - 1) * SIZEOF_V850_NOTE) + 16;
2504           bfd_byte * odata = ocont + ((id - 1) * SIZEOF_V850_NOTE) + 16;
2505
2506           ival = bfd_get_32 (ibfd, idata);
2507           oval = bfd_get_32 (obfd, odata);
2508
2509           if (ival == 0 || ival == oval)
2510             continue;
2511
2512           if (oval == 0)
2513             {
2514               bfd_put_32 (obfd, ival, odata);
2515               v850_set_note (obfd, onotes, id, ival);
2516               continue;
2517             }
2518
2519           /* We have a mismatch.  The ABI defines how to handle
2520              this siutation on a per note type basis.  */
2521           switch (id)
2522             {
2523             case V850_NOTE_ALIGNMENT:
2524               if (oval == EF_RH850_DATA_ALIGN4)
2525                 {
2526                   _bfd_error_handler
2527                     /* xgettext:c-format */
2528                     (_("error: %B needs 8-byte alignment but %B is set for 4-byte alignment"),
2529                                       ibfd, obfd);
2530                   result = FALSE;
2531                 }
2532               else
2533                 /* ibfd uses 4-byte alignment, obfd uses 8-byte alignment.
2534                    Leave the obfd alignment as it is.  */
2535                 BFD_ASSERT (oval == EF_RH850_DATA_ALIGN8);
2536
2537               break;
2538
2539             case V850_NOTE_DATA_SIZE:
2540               if (oval == EF_RH850_DOUBLE32)
2541                 {
2542                   _bfd_error_handler
2543                     /* xgettext:c-format */
2544                     (_("error: %B uses 64-bit doubles but "
2545                        "%B uses 32-bit doubles"), ibfd, obfd);
2546                   result = FALSE;
2547                 }
2548               else
2549                 /* ibfd uses 32-bit doubles, obfd uses 64-bit doubles.
2550                    This is acceptable.  Honest, that is what the ABI says.  */
2551                 BFD_ASSERT (oval == EF_RH850_DOUBLE64);
2552               break;
2553
2554             case V850_NOTE_FPU_INFO:
2555               if (oval == EF_RH850_FPU20)
2556                 {
2557                   _bfd_error_handler
2558                     /* xgettext:c-format */
2559                     (_("error: %B uses FPU-3.0 but %B only supports FPU-2.0"),
2560                      ibfd, obfd);
2561                   result = FALSE;
2562                 }
2563               else
2564                 /* ibfd uses FPU-2.0, obfd uses FPU-3.0.  Leave obfd as it is.  */
2565                 BFD_ASSERT (oval == EF_RH850_FPU30);
2566
2567               break;
2568
2569             default:
2570               /* None of the other conflicts matter.
2571                  Stick with the current output values.  */
2572               break;
2573             }
2574         }
2575
2576       /* FIXME:  We should also check for conflicts between the notes
2577          and the EF flags in the ELF header.  */
2578     }
2579
2580   return result;
2581 }
2582
2583 static void
2584 print_v850_note (bfd * abfd, FILE * file, bfd_byte * data, enum v850_notes id)
2585 {
2586   unsigned int value = bfd_get_32 (abfd, data + ((id - 1) * SIZEOF_V850_NOTE) + 16);
2587
2588   switch (id)
2589     {
2590     case V850_NOTE_ALIGNMENT:
2591       fprintf (file, _(" alignment of 8-byte entities: "));
2592       switch (value)
2593         {
2594         case EF_RH850_DATA_ALIGN4: fprintf (file, _("4-byte")); break;
2595         case EF_RH850_DATA_ALIGN8: fprintf (file, _("8-byte")); break;
2596         case 0:  fprintf (file, _("not set")); break;
2597         default: fprintf (file, _("unknown: %x"), value); break;
2598         }
2599       fputc ('\n', file);
2600       break;
2601
2602     case V850_NOTE_DATA_SIZE:
2603       fprintf (file, _(" size of doubles: "));
2604       switch (value)
2605         {
2606         case EF_RH850_DOUBLE32: fprintf (file, _("4-bytes")); break;
2607         case EF_RH850_DOUBLE64: fprintf (file, _("8-bytes")); break;
2608         case 0:  fprintf (file, _("not set")); break;
2609         default: fprintf (file, _("unknown: %x"), value); break;
2610         }
2611       fputc ('\n', file);
2612       break;
2613
2614     case V850_NOTE_FPU_INFO:
2615       fprintf (file, _(" FPU support required: "));
2616       switch (value)
2617         {
2618         case EF_RH850_FPU20: fprintf (file, _("FPU-2.0")); break;
2619         case EF_RH850_FPU30: fprintf (file, _("FPU-3.0")); break;
2620         case 0:  fprintf (file, _("none")); break;
2621         default: fprintf (file, _("unknown: %x"), value); break;
2622         }
2623       fputc ('\n', file);
2624       break;
2625
2626     case V850_NOTE_SIMD_INFO:
2627       fprintf (file, _("SIMD use: "));
2628       switch (value)
2629         {
2630         case EF_RH850_SIMD: fprintf (file, _("yes")); break;
2631         case 0:  fprintf (file, _("no")); break;
2632         default: fprintf (file, _("unknown: %x"), value); break;
2633         }
2634       fputc ('\n', file);
2635       break;
2636
2637     case V850_NOTE_CACHE_INFO:
2638       fprintf (file, _("CACHE use: "));
2639       switch (value)
2640         {
2641         case EF_RH850_CACHE: fprintf (file, _("yes")); break;
2642         case 0:  fprintf (file, _("no")); break;
2643         default: fprintf (file, _("unknown: %x"), value); break;
2644         }
2645       fputc ('\n', file);
2646       break;
2647
2648     case V850_NOTE_MMU_INFO:
2649       fprintf (file, _("MMU use: "));
2650       switch (value)
2651         {
2652         case EF_RH850_MMU: fprintf (file, _("yes")); break;
2653         case 0:  fprintf (file, _("no")); break;
2654         default: fprintf (file, _("unknown: %x"), value); break;
2655         }
2656       fputc ('\n', file);
2657       break;
2658
2659     default:
2660       BFD_ASSERT (0);
2661     }
2662 }
2663
2664 static void
2665 v850_elf_print_notes (bfd * abfd, FILE * file)
2666 {
2667   asection * notes = bfd_get_section_by_name (abfd, V850_NOTE_SECNAME);
2668   enum v850_notes id;
2669
2670   if (notes == NULL || notes->contents == NULL)
2671     return;
2672
2673   BFD_ASSERT (bfd_section_size (abfd, notes) == NUM_V850_NOTES * SIZEOF_V850_NOTE);
2674
2675   for (id = V850_NOTE_ALIGNMENT; id <= NUM_V850_NOTES; id++)
2676     print_v850_note (abfd, file, notes->contents, id);
2677 }
2678
2679 /* Set the right machine number and architecture.  */
2680
2681 static bfd_boolean
2682 v850_elf_object_p (bfd *abfd)
2683 {
2684   enum bfd_architecture arch;
2685   unsigned long mach;
2686
2687   switch (elf_elfheader (abfd)->e_machine)
2688     {
2689     case EM_V800:
2690       arch = bfd_arch_v850_rh850;
2691       mach = (elf_elfheader (abfd)->e_flags & EF_V800_850E3)
2692         ? bfd_mach_v850e3v5 : bfd_mach_v850e2v3;
2693       break;
2694
2695     case EM_CYGNUS_V850:
2696     case EM_V850:
2697       arch = bfd_arch_v850;
2698       switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
2699         {
2700         default:
2701         case E_V850_ARCH:     mach = bfd_mach_v850; break;
2702         case E_V850E_ARCH:    mach = bfd_mach_v850e; break;
2703         case E_V850E1_ARCH:   mach = bfd_mach_v850e1; break;
2704         case E_V850E2_ARCH:   mach = bfd_mach_v850e2; break;
2705         case E_V850E2V3_ARCH: mach = bfd_mach_v850e2v3; break;
2706         case E_V850E3V5_ARCH: mach = bfd_mach_v850e3v5; break;
2707         }
2708       break;
2709
2710     default:
2711       return FALSE;
2712     }
2713
2714   return bfd_default_set_arch_mach (abfd, arch, mach);
2715 }
2716
2717 /* Store the machine number in the flags field.  */
2718
2719 static void
2720 v850_elf_final_write_processing (bfd *abfd,
2721                                  bfd_boolean linker ATTRIBUTE_UNUSED)
2722 {
2723   unsigned long val;
2724
2725   switch (bfd_get_arch (abfd))
2726     {
2727     case bfd_arch_v850_rh850:
2728       val = EF_RH850_ABI;
2729       if (bfd_get_mach (abfd) == bfd_mach_v850e3v5)
2730         val |= EF_V800_850E3;
2731       elf_elfheader (abfd)->e_flags |= val;
2732       break;
2733
2734     case bfd_arch_v850:
2735       switch (bfd_get_mach (abfd))
2736         {
2737         default:
2738         case bfd_mach_v850:     val = E_V850_ARCH; break;
2739         case bfd_mach_v850e:    val = E_V850E_ARCH; break;
2740         case bfd_mach_v850e1:   val = E_V850E1_ARCH; break;
2741         case bfd_mach_v850e2:   val = E_V850E2_ARCH; break;
2742         case bfd_mach_v850e2v3: val = E_V850E2V3_ARCH; break;
2743         case bfd_mach_v850e3v5: val = E_V850E3V5_ARCH; break;
2744         }
2745       elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
2746       elf_elfheader (abfd)->e_flags |= val;
2747       break;
2748     default:
2749       break;
2750     }
2751 }
2752
2753 /* Function to keep V850 specific file flags.  */
2754
2755 static bfd_boolean
2756 v850_elf_set_private_flags (bfd *abfd, flagword flags)
2757 {
2758   BFD_ASSERT (!elf_flags_init (abfd)
2759               || elf_elfheader (abfd)->e_flags == flags);
2760
2761   elf_elfheader (abfd)->e_flags = flags;
2762   elf_flags_init (abfd) = TRUE;
2763   return TRUE;
2764 }
2765
2766 /* Merge backend specific data from an object file
2767    to the output object file when linking.  */
2768
2769 static bfd_boolean
2770 v850_elf_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
2771 {
2772   bfd *obfd = info->output_bfd;
2773   flagword out_flags;
2774   flagword in_flags;
2775   bfd_boolean result = TRUE;
2776
2777   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2778       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2779     return TRUE;
2780
2781   result &= v850_elf_merge_notes (ibfd, obfd);
2782
2783   in_flags = elf_elfheader (ibfd)->e_flags;
2784   out_flags = elf_elfheader (obfd)->e_flags;
2785
2786   if (! elf_flags_init (obfd))
2787     {
2788       /* If the input is the default architecture then do not
2789          bother setting the flags for the output architecture,
2790          instead allow future merges to do this.  If no future
2791          merges ever set these flags then they will retain their
2792          unitialised values, which surprise surprise, correspond
2793          to the default values.  */
2794       if (bfd_get_arch_info (ibfd)->the_default)
2795         return TRUE;
2796
2797       elf_flags_init (obfd) = TRUE;
2798       elf_elfheader (obfd)->e_flags = in_flags;
2799
2800       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
2801           && bfd_get_arch_info (obfd)->the_default)
2802         result &= bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
2803
2804       return result;
2805     }
2806
2807   /* Check flag compatibility.  */
2808   if (in_flags == out_flags)
2809     return result;
2810
2811   if (bfd_get_arch (obfd) == bfd_arch_v850_rh850)
2812     {
2813       if ((in_flags & EF_V800_850E3) != (out_flags & EF_V800_850E3))
2814         {
2815           _bfd_error_handler
2816             (_("%B: Architecture mismatch with previous modules"), ibfd);
2817           elf_elfheader (obfd)->e_flags |= EF_V800_850E3;
2818         }
2819
2820       return result;
2821     }
2822
2823   if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
2824       && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
2825     {
2826       /* Allow earlier architecture binaries to be linked with later binaries.
2827          Set the output binary to the later architecture, except for v850e1,
2828          which we set to v850e.  */
2829       if (   (in_flags  & EF_V850_ARCH) == E_V850E1_ARCH
2830           && (out_flags & EF_V850_ARCH) == E_V850E_ARCH)
2831         return result;
2832
2833       if (   (in_flags  & EF_V850_ARCH) == E_V850_ARCH
2834           && (out_flags & EF_V850_ARCH) == E_V850E_ARCH)
2835         {
2836           elf_elfheader (obfd)->e_flags =
2837             ((out_flags & ~ EF_V850_ARCH) | E_V850E_ARCH);
2838           return result;
2839         }
2840
2841       if ((   (in_flags & EF_V850_ARCH) == E_V850_ARCH
2842            || (in_flags & EF_V850_ARCH) == E_V850E_ARCH)
2843           && (out_flags & EF_V850_ARCH) == E_V850E2_ARCH)
2844         {
2845           elf_elfheader (obfd)->e_flags =
2846             ((out_flags & ~ EF_V850_ARCH) | E_V850E2_ARCH);
2847           return result;
2848         }
2849
2850       if ((   (in_flags & EF_V850_ARCH) == E_V850_ARCH
2851            || (in_flags & EF_V850_ARCH) == E_V850E_ARCH
2852            || (in_flags & EF_V850_ARCH) == E_V850E2_ARCH)
2853           && (out_flags & EF_V850_ARCH) == E_V850E2V3_ARCH)
2854         {
2855           elf_elfheader (obfd)->e_flags =
2856             ((out_flags & ~ EF_V850_ARCH) | E_V850E2V3_ARCH);
2857           return result;
2858         }
2859
2860       if ((   (in_flags & EF_V850_ARCH) == E_V850_ARCH
2861            || (in_flags & EF_V850_ARCH) == E_V850E_ARCH
2862            || (in_flags & EF_V850_ARCH) == E_V850E2_ARCH
2863            || (in_flags & EF_V850_ARCH) == E_V850E2V3_ARCH)
2864           && (out_flags & EF_V850_ARCH) == E_V850E3V5_ARCH)
2865         {
2866           elf_elfheader (obfd)->e_flags =
2867             ((out_flags & ~ EF_V850_ARCH) | E_V850E3V5_ARCH);
2868           return result;
2869         }
2870
2871       _bfd_error_handler
2872         (_("%B: Architecture mismatch with previous modules"), ibfd);
2873     }
2874
2875   return result;
2876 }
2877
2878 /* Display the flags field.  */
2879
2880 static bfd_boolean
2881 v850_elf_print_private_bfd_data (bfd *abfd, void * ptr)
2882 {
2883   FILE * file = (FILE *) ptr;
2884
2885   BFD_ASSERT (abfd != NULL && ptr != NULL);
2886
2887   _bfd_elf_print_private_bfd_data (abfd, ptr);
2888
2889   /* xgettext:c-format.  */
2890   fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
2891
2892   if (bfd_get_arch (abfd) == bfd_arch_v850_rh850)
2893     {
2894       if ((elf_elfheader (abfd)->e_flags & EF_RH850_ABI) != EF_RH850_ABI)
2895         fprintf (file, _("unknown v850 architecture"));
2896       else if (elf_elfheader (abfd)->e_flags & EF_V800_850E3)
2897         fprintf (file, _("v850 E3 architecture"));
2898       else
2899         fprintf (file, _("v850 architecture"));
2900     }
2901   else
2902     {
2903       switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
2904         {
2905         default:
2906         case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
2907         case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break;
2908         case E_V850E1_ARCH: fprintf (file, _("v850e1 architecture")); break;
2909         case E_V850E2_ARCH: fprintf (file, _("v850e2 architecture")); break;
2910         case E_V850E2V3_ARCH: fprintf (file, _("v850e2v3 architecture")); break;
2911         case E_V850E3V5_ARCH: fprintf (file, _("v850e3v5 architecture")); break;
2912         }
2913     }
2914
2915   fputc ('\n', file);
2916
2917   v850_elf_print_notes (abfd, file);
2918
2919   return TRUE;
2920 }
2921
2922 /* V850 ELF uses four common sections.  One is the usual one, and the
2923    others are for (small) objects in one of the special data areas:
2924    small, tiny and zero.  All the objects are kept together, and then
2925    referenced via the gp register, the ep register or the r0 register
2926    respectively, which yields smaller, faster assembler code.  This
2927    approach is copied from elf32-mips.c.  */
2928
2929 static asection  v850_elf_scom_section;
2930 static asymbol   v850_elf_scom_symbol;
2931 static asymbol * v850_elf_scom_symbol_ptr;
2932 static asection  v850_elf_tcom_section;
2933 static asymbol   v850_elf_tcom_symbol;
2934 static asymbol * v850_elf_tcom_symbol_ptr;
2935 static asection  v850_elf_zcom_section;
2936 static asymbol   v850_elf_zcom_symbol;
2937 static asymbol * v850_elf_zcom_symbol_ptr;
2938
2939 /* Given a BFD section, try to locate the
2940    corresponding ELF section index.  */
2941
2942 static bfd_boolean
2943 v850_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
2944                                    asection *sec,
2945                                    int *retval)
2946 {
2947   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
2948     *retval = SHN_V850_SCOMMON;
2949   else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
2950     *retval = SHN_V850_TCOMMON;
2951   else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
2952     *retval = SHN_V850_ZCOMMON;
2953   else
2954     return FALSE;
2955
2956   return TRUE;
2957 }
2958
2959 /* Handle the special V850 section numbers that a symbol may use.  */
2960
2961 static void
2962 v850_elf_symbol_processing (bfd *abfd, asymbol *asym)
2963 {
2964   elf_symbol_type * elfsym = (elf_symbol_type *) asym;
2965   unsigned int indx;
2966
2967   indx = elfsym->internal_elf_sym.st_shndx;
2968
2969   /* If the section index is an "ordinary" index, then it may
2970      refer to a v850 specific section created by the assembler.
2971      Check the section's type and change the index it matches.
2972
2973      FIXME: Should we alter the st_shndx field as well ?  */
2974
2975   if (indx < elf_numsections (abfd))
2976     switch (elf_elfsections (abfd)[indx]->sh_type)
2977       {
2978       case SHT_V850_SCOMMON:
2979         indx = SHN_V850_SCOMMON;
2980         break;
2981
2982       case SHT_V850_TCOMMON:
2983         indx = SHN_V850_TCOMMON;
2984         break;
2985
2986       case SHT_V850_ZCOMMON:
2987         indx = SHN_V850_ZCOMMON;
2988         break;
2989
2990       default:
2991         break;
2992       }
2993
2994   switch (indx)
2995     {
2996     case SHN_V850_SCOMMON:
2997       if (v850_elf_scom_section.name == NULL)
2998         {
2999           /* Initialize the small common section.  */
3000           v850_elf_scom_section.name           = ".scommon";
3001           v850_elf_scom_section.flags          = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
3002           v850_elf_scom_section.output_section = & v850_elf_scom_section;
3003           v850_elf_scom_section.symbol         = & v850_elf_scom_symbol;
3004           v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
3005           v850_elf_scom_symbol.name            = ".scommon";
3006           v850_elf_scom_symbol.flags           = BSF_SECTION_SYM;
3007           v850_elf_scom_symbol.section         = & v850_elf_scom_section;
3008           v850_elf_scom_symbol_ptr             = & v850_elf_scom_symbol;
3009         }
3010       asym->section = & v850_elf_scom_section;
3011       asym->value = elfsym->internal_elf_sym.st_size;
3012       break;
3013
3014     case SHN_V850_TCOMMON:
3015       if (v850_elf_tcom_section.name == NULL)
3016         {
3017           /* Initialize the tcommon section.  */
3018           v850_elf_tcom_section.name           = ".tcommon";
3019           v850_elf_tcom_section.flags          = SEC_IS_COMMON;
3020           v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
3021           v850_elf_tcom_section.symbol         = & v850_elf_tcom_symbol;
3022           v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
3023           v850_elf_tcom_symbol.name            = ".tcommon";
3024           v850_elf_tcom_symbol.flags           = BSF_SECTION_SYM;
3025           v850_elf_tcom_symbol.section         = & v850_elf_tcom_section;
3026           v850_elf_tcom_symbol_ptr             = & v850_elf_tcom_symbol;
3027         }
3028       asym->section = & v850_elf_tcom_section;
3029       asym->value = elfsym->internal_elf_sym.st_size;
3030       break;
3031
3032     case SHN_V850_ZCOMMON:
3033       if (v850_elf_zcom_section.name == NULL)
3034         {
3035           /* Initialize the zcommon section.  */
3036           v850_elf_zcom_section.name           = ".zcommon";
3037           v850_elf_zcom_section.flags          = SEC_IS_COMMON;
3038           v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
3039           v850_elf_zcom_section.symbol         = & v850_elf_zcom_symbol;
3040           v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
3041           v850_elf_zcom_symbol.name            = ".zcommon";
3042           v850_elf_zcom_symbol.flags           = BSF_SECTION_SYM;
3043           v850_elf_zcom_symbol.section         = & v850_elf_zcom_section;
3044           v850_elf_zcom_symbol_ptr             = & v850_elf_zcom_symbol;
3045         }
3046       asym->section = & v850_elf_zcom_section;
3047       asym->value = elfsym->internal_elf_sym.st_size;
3048       break;
3049     }
3050 }
3051
3052 /* Hook called by the linker routine which adds symbols from an object
3053    file.  We must handle the special v850 section numbers here.  */
3054
3055 static bfd_boolean
3056 v850_elf_add_symbol_hook (bfd *abfd,
3057                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
3058                           Elf_Internal_Sym *sym,
3059                           const char **namep ATTRIBUTE_UNUSED,
3060                           flagword *flagsp ATTRIBUTE_UNUSED,
3061                           asection **secp,
3062                           bfd_vma *valp)
3063 {
3064   unsigned int indx = sym->st_shndx;
3065
3066   /* If the section index is an "ordinary" index, then it may
3067      refer to a v850 specific section created by the assembler.
3068      Check the section's type and change the index it matches.
3069
3070      FIXME: Should we alter the st_shndx field as well ?  */
3071
3072   if (indx < elf_numsections (abfd))
3073     switch (elf_elfsections (abfd)[indx]->sh_type)
3074       {
3075       case SHT_V850_SCOMMON:
3076         indx = SHN_V850_SCOMMON;
3077         break;
3078
3079       case SHT_V850_TCOMMON:
3080         indx = SHN_V850_TCOMMON;
3081         break;
3082
3083       case SHT_V850_ZCOMMON:
3084         indx = SHN_V850_ZCOMMON;
3085         break;
3086
3087       default:
3088         break;
3089       }
3090
3091   switch (indx)
3092     {
3093     case SHN_V850_SCOMMON:
3094       *secp = bfd_make_section_old_way (abfd, ".scommon");
3095       (*secp)->flags |= SEC_IS_COMMON;
3096       *valp = sym->st_size;
3097       break;
3098
3099     case SHN_V850_TCOMMON:
3100       *secp = bfd_make_section_old_way (abfd, ".tcommon");
3101       (*secp)->flags |= SEC_IS_COMMON;
3102       *valp = sym->st_size;
3103       break;
3104
3105     case SHN_V850_ZCOMMON:
3106       *secp = bfd_make_section_old_way (abfd, ".zcommon");
3107       (*secp)->flags |= SEC_IS_COMMON;
3108       *valp = sym->st_size;
3109       break;
3110     }
3111
3112   return TRUE;
3113 }
3114
3115 static int
3116 v850_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3117                                   const char *name ATTRIBUTE_UNUSED,
3118                                   Elf_Internal_Sym *sym,
3119                                   asection *input_sec,
3120                                   struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
3121 {
3122   /* If we see a common symbol, which implies a relocatable link, then
3123      if a symbol was in a special common section in an input file, mark
3124      it as a special common in the output file.  */
3125
3126   if (sym->st_shndx == SHN_COMMON)
3127     {
3128       if (strcmp (input_sec->name, ".scommon") == 0)
3129         sym->st_shndx = SHN_V850_SCOMMON;
3130       else if (strcmp (input_sec->name, ".tcommon") == 0)
3131         sym->st_shndx = SHN_V850_TCOMMON;
3132       else if (strcmp (input_sec->name, ".zcommon") == 0)
3133         sym->st_shndx = SHN_V850_ZCOMMON;
3134     }
3135
3136   /* The price we pay for using h->other unused bits as flags in the
3137      linker is cleaning up after ourselves.  */
3138
3139   sym->st_other &= ~(V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA
3140                      | V850_OTHER_ERROR);
3141
3142   return 1;
3143 }
3144
3145 static bfd_boolean
3146 v850_elf_section_from_shdr (bfd *abfd,
3147                             Elf_Internal_Shdr *hdr,
3148                             const char *name,
3149                             int shindex)
3150 {
3151   /* There ought to be a place to keep ELF backend specific flags, but
3152      at the moment there isn't one.  We just keep track of the
3153      sections by their name, instead.  */
3154
3155   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
3156     return FALSE;
3157
3158   switch (hdr->sh_type)
3159     {
3160     case SHT_V850_SCOMMON:
3161     case SHT_V850_TCOMMON:
3162     case SHT_V850_ZCOMMON:
3163       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
3164                                    (bfd_get_section_flags (abfd,
3165                                                            hdr->bfd_section)
3166                                     | SEC_IS_COMMON)))
3167         return FALSE;
3168     }
3169
3170   return TRUE;
3171 }
3172
3173 /* Set the correct type for a V850 ELF section.  We do this
3174    by the section name, which is a hack, but ought to work.  */
3175
3176 static bfd_boolean
3177 v850_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
3178                         Elf_Internal_Shdr *hdr,
3179                         asection *sec)
3180 {
3181   const char * name;
3182
3183   name = bfd_get_section_name (abfd, sec);
3184
3185   if (strcmp (name, ".scommon") == 0)
3186     hdr->sh_type = SHT_V850_SCOMMON;
3187   else if (strcmp (name, ".tcommon") == 0)
3188     hdr->sh_type = SHT_V850_TCOMMON;
3189   else if (strcmp (name, ".zcommon") == 0)
3190     hdr->sh_type = SHT_V850_ZCOMMON;
3191   /* Tweak the section type of .note.renesas.  */
3192   else if (strcmp (name, V850_NOTE_SECNAME) == 0)
3193     {
3194       hdr->sh_type = SHT_RENESAS_INFO;
3195       hdr->sh_entsize = SIZEOF_V850_NOTE;
3196     }
3197
3198   return TRUE;
3199 }
3200
3201 /* Delete some bytes from a section while relaxing.  */
3202
3203 static bfd_boolean
3204 v850_elf_relax_delete_bytes (bfd *abfd,
3205                              asection *sec,
3206                              bfd_vma addr,
3207                              bfd_vma toaddr,
3208                              int count)
3209 {
3210   Elf_Internal_Shdr *symtab_hdr;
3211   Elf32_External_Sym *extsyms;
3212   Elf32_External_Sym *esym;
3213   Elf32_External_Sym *esymend;
3214   int sym_index;
3215   unsigned int sec_shndx;
3216   bfd_byte *contents;
3217   Elf_Internal_Rela *irel;
3218   Elf_Internal_Rela *irelend;
3219   struct elf_link_hash_entry *sym_hash;
3220   Elf_External_Sym_Shndx *shndx;
3221
3222   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3223   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
3224
3225   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
3226
3227   contents = elf_section_data (sec)->this_hdr.contents;
3228
3229   /* The deletion must stop at the next ALIGN reloc for an alignment
3230      power larger than the number of bytes we are deleting.  */
3231
3232   /* Actually delete the bytes.  */
3233 #if (DEBUG_RELAX & 2)
3234   fprintf (stderr, "relax_delete: contents: sec: %s  %p .. %p %x\n",
3235            sec->name, addr, toaddr, count );
3236 #endif
3237   memmove (contents + addr, contents + addr + count,
3238            toaddr - addr - count);
3239   memset (contents + toaddr-count, 0, count);
3240
3241   /* Adjust all the relocs.  */
3242   irel = elf_section_data (sec)->relocs;
3243   irelend = irel + sec->reloc_count;
3244   if (elf_symtab_shndx_list (abfd))
3245     {
3246       Elf_Internal_Shdr *shndx_hdr;
3247
3248       shndx_hdr = & elf_symtab_shndx_list (abfd)->hdr;
3249       shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
3250     }
3251   else
3252     {
3253       shndx = NULL;
3254     }
3255
3256   for (; irel < irelend; irel++)
3257     {
3258       bfd_vma raddr, paddr, symval;
3259       Elf_Internal_Sym isym;
3260
3261       /* Get the new reloc address.  */
3262       raddr = irel->r_offset;
3263       if ((raddr >= (addr + count) && raddr < toaddr))
3264         irel->r_offset -= count;
3265
3266       if (raddr >= addr && raddr < addr + count)
3267         {
3268           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
3269                                        (int) R_V850_NONE);
3270           continue;
3271         }
3272
3273       if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN)
3274         continue;
3275
3276       bfd_elf32_swap_symbol_in (abfd,
3277                                 extsyms + ELF32_R_SYM (irel->r_info),
3278                                 shndx ? shndx + ELF32_R_SYM (irel->r_info) : NULL,
3279                                 & isym);
3280
3281       if (isym.st_shndx != sec_shndx)
3282         continue;
3283
3284       /* Get the value of the symbol referred to by the reloc.  */
3285       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
3286         {
3287           symval = isym.st_value;
3288 #if (DEBUG_RELAX & 2)
3289           {
3290             char * name = bfd_elf_string_from_elf_section
3291                            (abfd, symtab_hdr->sh_link, isym.st_name);
3292             fprintf (stderr,
3293                "relax_delete: local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
3294                sec->name, name, isym.st_name,
3295                sec->output_section->vma, sec->output_offset,
3296                isym.st_value, irel->r_addend);
3297           }
3298 #endif
3299         }
3300       else
3301         {
3302           unsigned long indx;
3303           struct elf_link_hash_entry * h;
3304
3305           /* An external symbol.  */
3306           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
3307
3308           h = elf_sym_hashes (abfd) [indx];
3309           BFD_ASSERT (h != NULL);
3310
3311           symval = h->root.u.def.value;
3312 #if (DEBUG_RELAX & 2)
3313           fprintf (stderr,
3314                    "relax_delete: defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
3315                    sec->name, h->root.root.string, h->root.u.def.value,
3316                    sec->output_section->vma, sec->output_offset, irel->r_addend);
3317 #endif
3318         }
3319
3320       paddr = symval + irel->r_addend;
3321
3322       if ( (symval >= addr + count && symval < toaddr)
3323           && (paddr < addr + count || paddr >= toaddr))
3324         irel->r_addend += count;
3325       else if (    (symval < addr + count || symval >= toaddr)
3326                 && (paddr >= addr + count && paddr < toaddr))
3327         irel->r_addend -= count;
3328     }
3329
3330   /* Adjust the local symbols defined in this section.  */
3331   esym = extsyms;
3332   esymend = esym + symtab_hdr->sh_info;
3333
3334   for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
3335     {
3336       Elf_Internal_Sym isym;
3337
3338       bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
3339
3340       if (isym.st_shndx == sec_shndx
3341           && isym.st_value >= addr + count
3342           && isym.st_value < toaddr)
3343         {
3344           isym.st_value -= count;
3345
3346           if (isym.st_value + isym.st_size >= toaddr)
3347             isym.st_size += count;
3348
3349           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
3350         }
3351       else if (isym.st_shndx == sec_shndx
3352                && isym.st_value < addr + count)
3353         {
3354           if (isym.st_value+isym.st_size >= addr + count
3355               && isym.st_value+isym.st_size < toaddr)
3356             isym.st_size -= count;
3357
3358           if (isym.st_value >= addr
3359               && isym.st_value <  addr + count)
3360             isym.st_value = addr;
3361
3362           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
3363         }
3364     }
3365
3366   /* Now adjust the global symbols defined in this section.  */
3367   esym = extsyms + symtab_hdr->sh_info;
3368   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
3369
3370   for (sym_index = 0; esym < esymend; esym ++, sym_index ++)
3371     {
3372       Elf_Internal_Sym isym;
3373
3374       bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
3375       sym_hash = elf_sym_hashes (abfd) [sym_index];
3376
3377       if (isym.st_shndx == sec_shndx
3378           && ((sym_hash)->root.type == bfd_link_hash_defined
3379               || (sym_hash)->root.type == bfd_link_hash_defweak)
3380           && (sym_hash)->root.u.def.section == sec
3381           && (sym_hash)->root.u.def.value >= addr + count
3382           && (sym_hash)->root.u.def.value < toaddr)
3383         {
3384           if ((sym_hash)->root.u.def.value + isym.st_size >= toaddr)
3385             {
3386               isym.st_size += count;
3387               bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
3388             }
3389
3390           (sym_hash)->root.u.def.value -= count;
3391         }
3392       else if (isym.st_shndx == sec_shndx
3393                && ((sym_hash)->root.type == bfd_link_hash_defined
3394                    || (sym_hash)->root.type == bfd_link_hash_defweak)
3395                && (sym_hash)->root.u.def.section == sec
3396                && (sym_hash)->root.u.def.value < addr + count)
3397         {
3398           if ((sym_hash)->root.u.def.value+isym.st_size >= addr + count
3399               && (sym_hash)->root.u.def.value+isym.st_size < toaddr)
3400             isym.st_size -= count;
3401
3402           if ((sym_hash)->root.u.def.value >= addr
3403               && (sym_hash)->root.u.def.value < addr + count)
3404             (sym_hash)->root.u.def.value = addr;
3405
3406           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
3407         }
3408
3409       if (shndx)
3410         ++ shndx;
3411     }
3412
3413   return TRUE;
3414 }
3415
3416 #define NOP_OPCODE      (0x0000)
3417 #define MOVHI           0x0640                          /* 4byte.  */
3418 #define MOVHI_MASK      0x07e0
3419 #define MOVHI_R1(insn)  ((insn) & 0x1f)                 /* 4byte.  */
3420 #define MOVHI_R2(insn)  ((insn) >> 11)
3421 #define MOVEA           0x0620                          /* 2byte.  */
3422 #define MOVEA_MASK      0x07e0
3423 #define MOVEA_R1(insn)  ((insn) & 0x1f)
3424 #define MOVEA_R2(insn)  ((insn) >> 11)
3425 #define JARL_4          0x00040780                              /* 4byte.  */
3426 #define JARL_4_MASK     0xFFFF07FF
3427 #define JARL_R2(insn)   (int)(((insn) & (~JARL_4_MASK)) >> 11)
3428 #define ADD_I           0x0240                                  /* 2byte.  */
3429 #define ADD_I_MASK      0x07e0
3430 #define ADD_I5(insn)    ((((insn) & 0x001f) << 11) >> 11)       /* 2byte.  */
3431 #define ADD_R2(insn)    ((insn) >> 11)
3432 #define JMP_R           0x0060                                  /* 2byte.  */
3433 #define JMP_R_MASK      0xFFE0
3434 #define JMP_R1(insn)    ((insn) & 0x1f)
3435
3436 static bfd_boolean
3437 v850_elf_relax_section (bfd *abfd,
3438                         asection *sec,
3439                         struct bfd_link_info *link_info,
3440                         bfd_boolean *again)
3441 {
3442   Elf_Internal_Shdr *symtab_hdr;
3443   Elf_Internal_Rela *internal_relocs;
3444   Elf_Internal_Rela *irel;
3445   Elf_Internal_Rela *irelend;
3446   Elf_Internal_Rela *irelalign = NULL;
3447   Elf_Internal_Sym *isymbuf = NULL;
3448   bfd_byte *contents = NULL;
3449   bfd_vma addr = 0;
3450   bfd_vma toaddr;
3451   int align_pad_size = 0;
3452   bfd_boolean result = TRUE;
3453
3454   *again = FALSE;
3455
3456   if (bfd_link_relocatable (link_info)
3457       || (sec->flags & SEC_RELOC) == 0
3458       || sec->reloc_count == 0)
3459     return TRUE;
3460
3461   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
3462
3463   internal_relocs = (_bfd_elf_link_read_relocs
3464                      (abfd, sec, NULL, NULL, link_info->keep_memory));
3465   if (internal_relocs == NULL)
3466     goto error_return;
3467
3468   irelend = internal_relocs + sec->reloc_count;
3469
3470   while (addr < sec->size)
3471     {
3472       toaddr = sec->size;
3473
3474       for (irel = internal_relocs; irel < irelend; irel ++)
3475         if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
3476             && irel->r_offset > addr
3477             && irel->r_offset < toaddr)
3478           toaddr = irel->r_offset;
3479
3480 #ifdef DEBUG_RELAX
3481       fprintf (stderr, "relax region 0x%x to 0x%x align pad %d\n",
3482                addr, toaddr, align_pad_size);
3483 #endif
3484       if (irelalign)
3485         {
3486           bfd_vma alignto;
3487           bfd_vma alignmoveto;
3488
3489           alignmoveto = BFD_ALIGN (addr - align_pad_size, 1 << irelalign->r_addend);
3490           alignto = BFD_ALIGN (addr, 1 << irelalign->r_addend);
3491
3492           if (alignmoveto < alignto)
3493             {
3494               bfd_vma i;
3495
3496               align_pad_size = alignto - alignmoveto;
3497 #ifdef DEBUG_RELAX
3498               fprintf (stderr, "relax move region 0x%x to 0x%x delete size 0x%x\n",
3499                        alignmoveto, toaddr, align_pad_size);
3500 #endif
3501               if (!v850_elf_relax_delete_bytes (abfd, sec, alignmoveto,
3502                                                 toaddr, align_pad_size))
3503                 goto error_return;
3504
3505               for (i  = BFD_ALIGN (toaddr - align_pad_size, 1);
3506                    (i + 1) < toaddr; i += 2)
3507                 bfd_put_16 (abfd, NOP_OPCODE, contents + i);
3508
3509               addr = alignmoveto;
3510             }
3511           else
3512             align_pad_size = 0;
3513         }
3514
3515       for (irel = internal_relocs; irel < irelend; irel++)
3516         {
3517           bfd_vma laddr;
3518           bfd_vma addend;
3519           bfd_vma symval;
3520           int insn[5];
3521           int no_match = -1;
3522           Elf_Internal_Rela *hi_irelfn;
3523           Elf_Internal_Rela *lo_irelfn;
3524           Elf_Internal_Rela *irelcall;
3525           bfd_signed_vma foff;
3526           unsigned int r_type;
3527
3528           if (! (irel->r_offset >= addr && irel->r_offset < toaddr
3529                  && (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL
3530                      || ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)))
3531             continue;
3532
3533 #ifdef DEBUG_RELAX
3534           fprintf (stderr, "relax check r_info 0x%x r_offset 0x%x r_addend 0x%x\n",
3535                    irel->r_info,
3536                    irel->r_offset,
3537                    irel->r_addend );
3538 #endif
3539
3540           /* Get the section contents.  */
3541           if (contents == NULL)
3542             {
3543               if (elf_section_data (sec)->this_hdr.contents != NULL)
3544                 contents = elf_section_data (sec)->this_hdr.contents;
3545               else
3546                 {
3547                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
3548                     goto error_return;
3549                 }
3550             }
3551
3552           /* Read this BFD's local symbols if we haven't done so already.  */
3553           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
3554             {
3555               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
3556               if (isymbuf == NULL)
3557                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
3558                                                 symtab_hdr->sh_info, 0,
3559                                                 NULL, NULL, NULL);
3560               if (isymbuf == NULL)
3561                 goto error_return;
3562             }
3563
3564           laddr = irel->r_offset;
3565
3566           if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL)
3567             {
3568               /* Check code for -mlong-calls output. */
3569               if (laddr + 16 <= (bfd_vma) sec->size)
3570                 {
3571                   insn[0] = bfd_get_16 (abfd, contents + laddr);
3572                   insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
3573                   insn[2] = bfd_get_32 (abfd, contents + laddr + 8);
3574                   insn[3] = bfd_get_16 (abfd, contents + laddr + 12);
3575                   insn[4] = bfd_get_16 (abfd, contents + laddr + 14);
3576
3577                   if ((insn[0] & MOVHI_MASK) != MOVHI
3578                        || MOVHI_R1 (insn[0]) != 0)
3579                     no_match = 0;
3580
3581                   if (no_match < 0
3582                       && ((insn[1] & MOVEA_MASK) != MOVEA
3583                            || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
3584                     no_match = 1;
3585
3586                   if (no_match < 0
3587                       && (insn[2] & JARL_4_MASK) != JARL_4)
3588                     no_match = 2;
3589
3590                   if (no_match < 0
3591                       && ((insn[3] & ADD_I_MASK) != ADD_I
3592                            || ADD_I5 (insn[3]) != 4
3593                            || JARL_R2 (insn[2]) != ADD_R2 (insn[3])))
3594                     no_match = 3;
3595
3596                   if (no_match < 0
3597                       && ((insn[4] & JMP_R_MASK) != JMP_R
3598                            || MOVEA_R2 (insn[1]) != JMP_R1 (insn[4])))
3599                     no_match = 4;
3600                 }
3601               else
3602                 {
3603                   _bfd_error_handler
3604                     /* xgettext:c-format */
3605                     (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
3606                        "unrecognized insns"),
3607                      abfd, irel->r_offset);
3608                   continue;
3609                 }
3610
3611               if (no_match >= 0)
3612                 {
3613                   _bfd_error_handler
3614                     /* xgettext:c-format */
3615                     (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
3616                        "unrecognized insn %#x"),
3617                      abfd,
3618                      irel->r_offset + no_match,
3619                      insn[no_match]);
3620                   continue;
3621                 }
3622
3623               /* Get the reloc for the address from which the register is
3624                  being loaded.  This reloc will tell us which function is
3625                  actually being called.  */
3626
3627               for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
3628                 {
3629                   r_type = ELF32_R_TYPE (hi_irelfn->r_info);
3630
3631                   if (hi_irelfn->r_offset == laddr + 2
3632                       && (r_type == (int) R_V850_HI16_S || r_type == (int) R_V810_WHI1))
3633                     break;
3634                 }
3635
3636               for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
3637                 {
3638                   r_type = ELF32_R_TYPE (lo_irelfn->r_info);
3639
3640                   if (lo_irelfn->r_offset == laddr + 6
3641                       && (r_type == (int) R_V850_LO16 || r_type == (int) R_V810_WLO))
3642                     break;
3643                 }
3644
3645               for (irelcall = internal_relocs; irelcall < irelend; irelcall ++)
3646                 {
3647                   r_type = ELF32_R_TYPE (irelcall->r_info);
3648
3649                   if (irelcall->r_offset == laddr + 8
3650                       && (r_type == (int) R_V850_22_PCREL || r_type == (int) R_V850_PCR22))
3651                     break;
3652                 }
3653
3654               if (   hi_irelfn == irelend
3655                   || lo_irelfn == irelend
3656                   || irelcall  == irelend)
3657                 {
3658                   _bfd_error_handler
3659                     /* xgettext:c-format */
3660                     (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
3661                        "unrecognized reloc"),
3662                      abfd, irel->r_offset);
3663
3664                   continue;
3665                 }
3666
3667               if (ELF32_R_SYM (irelcall->r_info) < symtab_hdr->sh_info)
3668                 {
3669                   Elf_Internal_Sym *  isym;
3670
3671                   /* A local symbol.  */
3672                   isym = isymbuf + ELF32_R_SYM (irelcall->r_info);
3673
3674                   symval = isym->st_value;
3675                 }
3676               else
3677                 {
3678                   unsigned long indx;
3679                   struct elf_link_hash_entry * h;
3680
3681                   /* An external symbol.  */
3682                   indx = ELF32_R_SYM (irelcall->r_info) - symtab_hdr->sh_info;
3683                   h = elf_sym_hashes (abfd)[indx];
3684                   BFD_ASSERT (h != NULL);
3685
3686                   if (   h->root.type != bfd_link_hash_defined
3687                       && h->root.type != bfd_link_hash_defweak)
3688                     /* This appears to be a reference to an undefined
3689                        symbol.  Just ignore it--it will be caught by the
3690                        regular reloc processing.  */
3691                     continue;
3692
3693                   symval = h->root.u.def.value;
3694                 }
3695
3696               if (symval + irelcall->r_addend != irelcall->r_offset + 4)
3697                 {
3698                   _bfd_error_handler
3699                     /* xgettext:c-format */
3700                     (_("%B: %#Lx: warning: R_V850_LONGCALL points to "
3701                        "unrecognized reloc %#Lx"),
3702                      abfd, irel->r_offset,
3703                      irelcall->r_offset);
3704                   continue;
3705                 }
3706
3707               /* Get the value of the symbol referred to by the reloc.  */
3708               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3709                 {
3710                   Elf_Internal_Sym *isym;
3711                   asection *sym_sec;
3712
3713                   /* A local symbol.  */
3714                   isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
3715
3716                   if (isym->st_shndx == SHN_UNDEF)
3717                     sym_sec = bfd_und_section_ptr;
3718                   else if (isym->st_shndx == SHN_ABS)
3719                     sym_sec = bfd_abs_section_ptr;
3720                   else if (isym->st_shndx == SHN_COMMON)
3721                     sym_sec = bfd_com_section_ptr;
3722                   else
3723                     sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3724                   symval = (isym->st_value
3725                             + sym_sec->output_section->vma
3726                             + sym_sec->output_offset);
3727                 }
3728               else
3729                 {
3730                   unsigned long indx;
3731                   struct elf_link_hash_entry *h;
3732
3733                   /* An external symbol.  */
3734                   indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
3735                   h = elf_sym_hashes (abfd)[indx];
3736                   BFD_ASSERT (h != NULL);
3737
3738                   if (   h->root.type != bfd_link_hash_defined
3739                       && h->root.type != bfd_link_hash_defweak)
3740                     /* This appears to be a reference to an undefined
3741                        symbol.  Just ignore it--it will be caught by the
3742                        regular reloc processing.  */
3743                     continue;
3744
3745                   symval = (h->root.u.def.value
3746                             + h->root.u.def.section->output_section->vma
3747                             + h->root.u.def.section->output_offset);
3748                 }
3749
3750               addend = irel->r_addend;
3751
3752               foff = (symval + addend
3753                       - (irel->r_offset
3754                          + sec->output_section->vma
3755                          + sec->output_offset
3756                          + 4));
3757 #ifdef DEBUG_RELAX
3758               fprintf (stderr, "relax longcall r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
3759                        irel->r_offset,
3760                        (irel->r_offset
3761                         + sec->output_section->vma
3762                         + sec->output_offset),
3763                        symval, addend, foff);
3764 #endif
3765
3766               if (foff < -0x100000 || foff >= 0x100000)
3767                 /* After all that work, we can't shorten this function call.  */
3768                 continue;
3769
3770               /* For simplicity of coding, we are going to modify the section
3771                  contents, the section relocs, and the BFD symbol table.  We
3772                  must tell the rest of the code not to free up this
3773                  information.  It would be possible to instead create a table
3774                  of changes which have to be made, as is done in coff-mips.c;
3775                  that would be more work, but would require less memory when
3776                  the linker is run.  */
3777               elf_section_data (sec)->relocs = internal_relocs;
3778               elf_section_data (sec)->this_hdr.contents = contents;
3779               symtab_hdr->contents = (bfd_byte *) isymbuf;
3780
3781               /* Replace the long call with a jarl.  */
3782               if (bfd_get_arch (abfd) == bfd_arch_v850_rh850)
3783                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_PCR22);
3784               else
3785                 irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_22_PCREL);
3786
3787               addend = 0;
3788
3789               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3790                 /* If this needs to be changed because of future relaxing,
3791                    it will be handled here like other internal IND12W
3792                    relocs.  */
3793                 bfd_put_32 (abfd,
3794                             0x00000780 | (JARL_R2 (insn[2])<<11) | ((addend << 16) & 0xffff) | ((addend >> 16) & 0xf),
3795                             contents + irel->r_offset);
3796               else
3797                 /* We can't fully resolve this yet, because the external
3798                    symbol value may be changed by future relaxing.
3799                    We let the final link phase handle it.  */
3800                 bfd_put_32 (abfd, 0x00000780 | (JARL_R2 (insn[2])<<11),
3801                             contents + irel->r_offset);
3802
3803               hi_irelfn->r_info =
3804                 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
3805               lo_irelfn->r_info =
3806                 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
3807               irelcall->r_info =
3808                 ELF32_R_INFO (ELF32_R_SYM (irelcall->r_info), R_V850_NONE);
3809
3810               if (! v850_elf_relax_delete_bytes (abfd, sec,
3811                                                  irel->r_offset + 4, toaddr, 12))
3812                 goto error_return;
3813
3814               align_pad_size += 12;
3815             }
3816           else if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)
3817             {
3818               /* Check code for -mlong-jumps output.  */
3819               if (laddr + 10 <= (bfd_vma) sec->size)
3820                 {
3821                   insn[0] = bfd_get_16 (abfd, contents + laddr);
3822                   insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
3823                   insn[2] = bfd_get_16 (abfd, contents + laddr + 8);
3824
3825                   if ((insn[0] & MOVHI_MASK) != MOVHI
3826                        || MOVHI_R1 (insn[0]) != 0)
3827                     no_match = 0;
3828
3829                   if (no_match < 0
3830                       && ((insn[1] & MOVEA_MASK) != MOVEA
3831                            || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
3832                     no_match = 1;
3833
3834                   if (no_match < 0
3835                       && ((insn[2] & JMP_R_MASK) != JMP_R
3836                            || MOVEA_R2 (insn[1]) != JMP_R1 (insn[2])))
3837                     no_match = 4;
3838                 }
3839               else
3840                 {
3841                   _bfd_error_handler
3842                     /* xgettext:c-format */
3843                     (_("%B: %#Lx: warning: R_V850_LONGJUMP points to "
3844                        "unrecognized insns"),
3845                      abfd, irel->r_offset);
3846                   continue;
3847                 }
3848
3849               if (no_match >= 0)
3850                 {
3851                   _bfd_error_handler
3852                     /* xgettext:c-format */
3853                     (_("%B: %#Lx: warning: R_V850_LONGJUMP points to "
3854                        "unrecognized insn %#x"),
3855                      abfd,
3856                      irel->r_offset + no_match,
3857                      insn[no_match]);
3858                   continue;
3859                 }
3860
3861               /* Get the reloc for the address from which the register is
3862                  being loaded.  This reloc will tell us which function is
3863                  actually being called.  */
3864               for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
3865                 {
3866                   r_type = ELF32_R_TYPE (hi_irelfn->r_info);
3867
3868                   if (hi_irelfn->r_offset == laddr + 2
3869                       && ((r_type == (int) R_V850_HI16_S) || r_type == (int) R_V810_WHI1))
3870                     break;
3871                 }
3872
3873               for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
3874                 {
3875                   r_type = ELF32_R_TYPE (lo_irelfn->r_info);
3876
3877                   if (lo_irelfn->r_offset == laddr + 6
3878                       && (r_type == (int) R_V850_LO16 || r_type == (int) R_V810_WLO))
3879                     break;
3880                 }
3881
3882               if (   hi_irelfn == irelend
3883                   || lo_irelfn == irelend)
3884                 {
3885                   _bfd_error_handler
3886                     /* xgettext:c-format */
3887                     (_("%B: %#Lx: warning: R_V850_LONGJUMP points to "
3888                        "unrecognized reloc"),
3889                      abfd, irel->r_offset);
3890                   continue;
3891                 }
3892
3893               /* Get the value of the symbol referred to by the reloc.  */
3894               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3895                 {
3896                   Elf_Internal_Sym *  isym;
3897                   asection *          sym_sec;
3898
3899                   /* A local symbol.  */
3900                   isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
3901
3902                   if (isym->st_shndx == SHN_UNDEF)
3903                     sym_sec = bfd_und_section_ptr;
3904                   else if (isym->st_shndx == SHN_ABS)
3905                     sym_sec = bfd_abs_section_ptr;
3906                   else if (isym->st_shndx == SHN_COMMON)
3907                     sym_sec = bfd_com_section_ptr;
3908                   else
3909                     sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
3910                   symval = (isym->st_value
3911                             + sym_sec->output_section->vma
3912                             + sym_sec->output_offset);
3913 #ifdef DEBUG_RELAX
3914                   {
3915                     char * name = bfd_elf_string_from_elf_section
3916                       (abfd, symtab_hdr->sh_link, isym->st_name);
3917
3918                     fprintf (stderr, "relax long jump local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
3919                              sym_sec->name, name, isym->st_name,
3920                              sym_sec->output_section->vma,
3921                              sym_sec->output_offset,
3922                              isym->st_value, irel->r_addend);
3923                   }
3924 #endif
3925                 }
3926               else
3927                 {
3928                   unsigned long indx;
3929                   struct elf_link_hash_entry * h;
3930
3931                   /* An external symbol.  */
3932                   indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
3933                   h = elf_sym_hashes (abfd)[indx];
3934                   BFD_ASSERT (h != NULL);
3935
3936                   if (   h->root.type != bfd_link_hash_defined
3937                       && h->root.type != bfd_link_hash_defweak)
3938                     /* This appears to be a reference to an undefined
3939                        symbol.  Just ignore it--it will be caught by the
3940                        regular reloc processing.  */
3941                     continue;
3942
3943                   symval = (h->root.u.def.value
3944                             + h->root.u.def.section->output_section->vma
3945                             + h->root.u.def.section->output_offset);
3946 #ifdef DEBUG_RELAX
3947                   fprintf (stderr,
3948                            "relax longjump defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
3949                            sec->name, h->root.root.string, h->root.u.def.value,
3950                            sec->output_section->vma, sec->output_offset, irel->r_addend);
3951 #endif
3952                 }
3953
3954               addend = irel->r_addend;
3955
3956               foff = (symval + addend
3957                       - (irel->r_offset
3958                          + sec->output_section->vma
3959                          + sec->output_offset
3960                          + 4));
3961 #ifdef DEBUG_RELAX
3962               fprintf (stderr, "relax longjump r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
3963                        irel->r_offset,
3964                        (irel->r_offset
3965                         + sec->output_section->vma
3966                         + sec->output_offset),
3967                        symval, addend, foff);
3968 #endif
3969               if (foff < -0x100000 || foff >= 0x100000)
3970                 /* After all that work, we can't shorten this function call.  */
3971                 continue;
3972
3973               /* For simplicity of coding, we are going to modify the section
3974                  contents, the section relocs, and the BFD symbol table.  We
3975                  must tell the rest of the code not to free up this
3976                  information.  It would be possible to instead create a table
3977                  of changes which have to be made, as is done in coff-mips.c;
3978                  that would be more work, but would require less memory when
3979                  the linker is run.  */
3980               elf_section_data (sec)->relocs = internal_relocs;
3981               elf_section_data (sec)->this_hdr.contents = contents;
3982               symtab_hdr->contents = (bfd_byte *) isymbuf;
3983
3984               if (foff < -0x100 || foff >= 0x100)
3985                 {
3986                   /* Replace the long jump with a jr.  */
3987
3988                   if (bfd_get_arch (abfd) == bfd_arch_v850_rh850)
3989                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_PCR22);
3990                   else
3991                     irel->r_info =
3992                       ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_22_PCREL);
3993
3994                   irel->r_addend = addend;
3995                   addend = 0;
3996
3997                   if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
3998                     /* If this needs to be changed because of future relaxing,
3999                        it will be handled here like other internal IND12W
4000                        relocs.  */
4001                     bfd_put_32 (abfd,
4002                                 0x00000780 | ((addend << 15) & 0xffff0000) | ((addend >> 17) & 0xf),
4003                                 contents + irel->r_offset);
4004                   else
4005                     /* We can't fully resolve this yet, because the external
4006                        symbol value may be changed by future relaxing.
4007                        We let the final link phase handle it.  */
4008                     bfd_put_32 (abfd, 0x00000780, contents + irel->r_offset);
4009
4010                   hi_irelfn->r_info =
4011                         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
4012                   lo_irelfn->r_info =
4013                         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
4014                   if (!v850_elf_relax_delete_bytes (abfd, sec,
4015                                                     irel->r_offset + 4, toaddr, 6))
4016                     goto error_return;
4017
4018                   align_pad_size += 6;
4019                 }
4020               else
4021                 {
4022                   /* Replace the long jump with a br.  */
4023
4024                   if (bfd_get_arch (abfd) == bfd_arch_v850_rh850)
4025                     irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_PC9);
4026                   else
4027                     irel->r_info =
4028                       ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_9_PCREL);
4029
4030                   irel->r_addend = addend;
4031                   addend = 0;
4032
4033                   if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
4034                     /* If this needs to be changed because of future relaxing,
4035                        it will be handled here like other internal IND12W
4036                        relocs.  */
4037                     bfd_put_16 (abfd,
4038                                 0x0585 | ((addend << 10) & 0xf800) | ((addend << 3) & 0x0070),
4039                                 contents + irel->r_offset);
4040                   else
4041                     /* We can't fully resolve this yet, because the external
4042                        symbol value may be changed by future relaxing.
4043                        We let the final link phase handle it.  */
4044                     bfd_put_16 (abfd, 0x0585, contents + irel->r_offset);
4045
4046                   hi_irelfn->r_info =
4047                         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
4048                   lo_irelfn->r_info =
4049                         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
4050                   if (!v850_elf_relax_delete_bytes (abfd, sec,
4051                                                     irel->r_offset + 2, toaddr, 8))
4052                     goto error_return;
4053
4054                   align_pad_size += 8;
4055                 }
4056             }
4057         }
4058
4059       irelalign = NULL;
4060       for (irel = internal_relocs; irel < irelend; irel++)
4061         {
4062           if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
4063               && irel->r_offset == toaddr)
4064             {
4065               irel->r_offset -= align_pad_size;
4066
4067               if (irelalign == NULL || irelalign->r_addend > irel->r_addend)
4068                 irelalign = irel;
4069             }
4070         }
4071
4072       addr = toaddr;
4073     }
4074
4075   if (!irelalign)
4076     {
4077 #ifdef DEBUG_RELAX
4078       fprintf (stderr, "relax pad %d shorten %d -> %d\n",
4079                align_pad_size,
4080                sec->size,
4081                sec->size - align_pad_size);
4082 #endif
4083       sec->size -= align_pad_size;
4084     }
4085
4086  finish:
4087   if (internal_relocs != NULL
4088       && elf_section_data (sec)->relocs != internal_relocs)
4089     free (internal_relocs);
4090
4091   if (contents != NULL
4092       && elf_section_data (sec)->this_hdr.contents != (unsigned char *) contents)
4093     free (contents);
4094
4095   if (isymbuf != NULL
4096       && symtab_hdr->contents != (bfd_byte *) isymbuf)
4097     free (isymbuf);
4098
4099   return result;
4100
4101  error_return:
4102   result = FALSE;
4103   goto finish;
4104 }
4105
4106 static const struct bfd_elf_special_section v850_elf_special_sections[] =
4107 {
4108   { STRING_COMMA_LEN (".call_table_data"), 0, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE) },
4109   { STRING_COMMA_LEN (".call_table_text"), 0, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
4110                                                                  + SHF_EXECINSTR) },
4111   { STRING_COMMA_LEN (".rosdata"),        -2, SHT_PROGBITS,     (SHF_ALLOC
4112                                                                  + SHF_V850_GPREL) },
4113   { STRING_COMMA_LEN (".rozdata"),        -2, SHT_PROGBITS,     (SHF_ALLOC
4114                                                                  + SHF_V850_R0REL) },
4115   { STRING_COMMA_LEN (".sbss"),           -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
4116                                                                  + SHF_V850_GPREL) },
4117   { STRING_COMMA_LEN (".scommon"),        -2, SHT_V850_SCOMMON, (SHF_ALLOC + SHF_WRITE
4118                                                                  + SHF_V850_GPREL) },
4119   { STRING_COMMA_LEN (".sdata"),          -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
4120                                                                  + SHF_V850_GPREL) },
4121   { STRING_COMMA_LEN (".tbss"),           -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
4122                                                                  + SHF_V850_EPREL) },
4123   { STRING_COMMA_LEN (".tcommon"),        -2, SHT_V850_TCOMMON, (SHF_ALLOC + SHF_WRITE
4124                                                                  + SHF_V850_R0REL) },
4125   { STRING_COMMA_LEN (".tdata"),          -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
4126                                                                  + SHF_V850_EPREL) },
4127   { STRING_COMMA_LEN (".zbss"),           -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
4128                                                                  + SHF_V850_R0REL) },
4129   { STRING_COMMA_LEN (".zcommon"),        -2, SHT_V850_ZCOMMON, (SHF_ALLOC + SHF_WRITE
4130                                                                  + SHF_V850_R0REL) },
4131   { STRING_COMMA_LEN (".zdata"),          -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
4132                                                                  + SHF_V850_R0REL) },
4133   { NULL,                     0,           0, 0,                0 }
4134 };
4135 \f
4136 #define TARGET_LITTLE_SYM                       v850_elf32_vec
4137 #define TARGET_LITTLE_NAME                      "elf32-v850"
4138 #define ELF_ARCH                                bfd_arch_v850
4139 #define ELF_MACHINE_CODE                        EM_V850
4140 #define ELF_MACHINE_ALT1                        EM_CYGNUS_V850
4141 #define ELF_MAXPAGESIZE                         0x1000
4142
4143 #define elf_info_to_howto                       v850_elf_info_to_howto_rela
4144 #define elf_info_to_howto_rel                   v850_elf_info_to_howto_rel
4145
4146 #define elf_backend_check_relocs                v850_elf_check_relocs
4147 #define elf_backend_relocate_section            v850_elf_relocate_section
4148 #define elf_backend_object_p                    v850_elf_object_p
4149 #define elf_backend_final_write_processing      v850_elf_final_write_processing
4150 #define elf_backend_section_from_bfd_section    v850_elf_section_from_bfd_section
4151 #define elf_backend_symbol_processing           v850_elf_symbol_processing
4152 #define elf_backend_add_symbol_hook             v850_elf_add_symbol_hook
4153 #define elf_backend_link_output_symbol_hook     v850_elf_link_output_symbol_hook
4154 #define elf_backend_section_from_shdr           v850_elf_section_from_shdr
4155 #define elf_backend_fake_sections               v850_elf_fake_sections
4156 #define elf_backend_gc_mark_hook                v850_elf_gc_mark_hook
4157 #define elf_backend_special_sections            v850_elf_special_sections
4158
4159 #define elf_backend_can_gc_sections             1
4160 #define elf_backend_rela_normal                 1
4161
4162 #define bfd_elf32_bfd_is_local_label_name       v850_elf_is_local_label_name
4163 #define bfd_elf32_bfd_is_target_special_symbol  v850_elf_is_target_special_symbol
4164
4165 #define bfd_elf32_bfd_reloc_type_lookup         v850_elf_reloc_type_lookup
4166 #define bfd_elf32_bfd_reloc_name_lookup         v850_elf_reloc_name_lookup
4167 #define bfd_elf32_bfd_merge_private_bfd_data    v850_elf_merge_private_bfd_data
4168 #define bfd_elf32_bfd_set_private_flags         v850_elf_set_private_flags
4169 #define bfd_elf32_bfd_print_private_bfd_data    v850_elf_print_private_bfd_data
4170 #define bfd_elf32_bfd_relax_section             v850_elf_relax_section
4171
4172 #define elf_symbol_leading_char                 '_'
4173
4174 #undef  elf32_bed
4175 #define elf32_bed elf32_v850_bed
4176
4177 #include "elf32-target.h"
4178
4179 /* Map BFD reloc types to V800 ELF reloc types.  */
4180
4181 static const struct v850_elf_reloc_map v800_elf_reloc_map[] =
4182 {
4183   { BFD_RELOC_NONE,                   R_V810_NONE    },
4184   { BFD_RELOC_8,                      R_V810_BYTE    },
4185   { BFD_RELOC_16,                     R_V810_HWORD   },
4186   { BFD_RELOC_32,                     R_V810_WORD    },
4187   { BFD_RELOC_LO16,                   R_V810_WLO     },
4188   { BFD_RELOC_HI16,                   R_V810_WHI     },
4189   { BFD_RELOC_HI16_S,                 R_V810_WHI1    },
4190   { BFD_RELOC_V850_32_PCREL,          R_V850_PC32    },
4191   { BFD_RELOC_V850_22_PCREL,          R_V850_PCR22   },
4192   { BFD_RELOC_V850_17_PCREL,          R_V850_PC17    },
4193   { BFD_RELOC_V850_16_PCREL,          R_V850_PC16U   },
4194   { BFD_RELOC_V850_9_PCREL,           R_V850_PC9     },
4195   { BFD_RELOC_V850_LO16_S1,           R_V810_WLO_1   }, /* Or R_V850_HWLO or R_V850_HWLO_1.  */
4196   { BFD_RELOC_V850_23,                R_V850_WLO23   },
4197   { BFD_RELOC_V850_LO16_SPLIT_OFFSET, R_V850_BLO     },
4198   { BFD_RELOC_V850_ZDA_16_16_OFFSET,  R_V810_HWORD   },
4199   { BFD_RELOC_V850_TDA_16_16_OFFSET,  R_V810_HWORD   },
4200   { BFD_RELOC_V850_SDA_16_16_OFFSET,  R_V810_HWORD   },
4201   { BFD_RELOC_V850_SDA_15_16_OFFSET,  R_V810_GPWLO_1 }
4202 };
4203
4204 /* Map a bfd relocation into the appropriate howto structure.  */
4205
4206 static reloc_howto_type *
4207 v800_elf_reloc_type_lookup (bfd * abfd, bfd_reloc_code_real_type code)
4208 {
4209   unsigned int i;
4210
4211   BFD_ASSERT (bfd_get_arch (abfd) == bfd_arch_v850_rh850);
4212
4213   for (i = ARRAY_SIZE (v800_elf_reloc_map); i --;)
4214     if (v800_elf_reloc_map[i].bfd_reloc_val == code)
4215       {
4216         unsigned int elf_reloc_val = v800_elf_reloc_map[i].elf_reloc_val;
4217         unsigned int idx = elf_reloc_val - R_V810_NONE;
4218
4219         BFD_ASSERT (v800_elf_howto_table[idx].type == elf_reloc_val);
4220
4221         return v800_elf_howto_table + idx;
4222       }
4223
4224 #ifdef DEBUG
4225   fprintf (stderr, "failed to find v800 equiv of bfd reloc code %d\n", code);
4226 #endif
4227   return NULL;
4228 }
4229
4230 static reloc_howto_type *
4231 v800_elf_reloc_name_lookup (bfd * abfd, const char * r_name)
4232 {
4233   unsigned int i;
4234
4235   BFD_ASSERT (bfd_get_arch (abfd) == bfd_arch_v850_rh850);
4236
4237   for (i = ARRAY_SIZE (v800_elf_howto_table); i--;)
4238     if (v800_elf_howto_table[i].name != NULL
4239         && strcasecmp (v800_elf_howto_table[i].name, r_name) == 0)
4240       return v800_elf_howto_table + i;
4241
4242   return NULL;
4243 }
4244
4245
4246 /* Set the howto pointer in CACHE_PTR for a V800 ELF reloc.  */
4247
4248 static void
4249 v800_elf_info_to_howto (bfd *               abfd,
4250                         arelent *           cache_ptr,
4251                         Elf_Internal_Rela * dst)
4252 {
4253   unsigned int r_type = ELF32_R_TYPE (dst->r_info);
4254
4255   BFD_ASSERT (bfd_get_arch (abfd) == bfd_arch_v850_rh850);
4256
4257   BFD_ASSERT (r_type < (unsigned int) R_V800_max);
4258
4259   if (r_type == R_V800_NONE)
4260     r_type = R_V810_NONE;
4261
4262   BFD_ASSERT (r_type >= (unsigned int) R_V810_NONE);
4263   r_type -= R_V810_NONE;
4264   BFD_ASSERT (r_type < ARRAY_SIZE (v800_elf_howto_table));
4265
4266   cache_ptr->howto = v800_elf_howto_table + r_type;
4267 }
4268 \f
4269 #undef  TARGET_LITTLE_SYM
4270 #define TARGET_LITTLE_SYM                       v800_elf32_vec
4271 #undef  TARGET_LITTLE_NAME
4272 #define TARGET_LITTLE_NAME                      "elf32-v850-rh850"
4273 #undef  ELF_ARCH
4274 #define ELF_ARCH                                bfd_arch_v850_rh850
4275 #undef  ELF_MACHINE_CODE
4276 #define ELF_MACHINE_CODE                        EM_V800
4277 #undef  ELF_MACHINE_ALT1
4278
4279 #undef  elf32_bed
4280 #define elf32_bed elf32_v850_rh850_bed
4281
4282 #undef  elf_info_to_howto
4283 #define elf_info_to_howto                       v800_elf_info_to_howto
4284 #undef  elf_info_to_howto_rel
4285 #define elf_info_to_howto_rel                   NULL
4286 #undef  bfd_elf32_bfd_reloc_type_lookup
4287 #define bfd_elf32_bfd_reloc_type_lookup         v800_elf_reloc_type_lookup
4288 #undef  bfd_elf32_bfd_reloc_name_lookup
4289 #define bfd_elf32_bfd_reloc_name_lookup         v800_elf_reloc_name_lookup
4290
4291 #include "elf32-target.h"