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