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