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