bfd/elf32-v850.c

   1 /* V850-specific support for 32-bit ELF
   2    Copyright 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005,
   3    2006, 2007 Free Software Foundation, Inc.
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  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 24-bit number.  */
  34 #define SEXT24(x)       ((((x) & 0xffffff) ^ 0x800000) - 0x800000)
  35
  36 static reloc_howto_type v850_elf_howto_table[];
  37
  38 /* Look through the relocs for a section during the first phase, and
  39    allocate space in the global offset table or procedure linkage
  40    table.  */
  41
  42 static bfd_boolean
  43 v850_elf_check_relocs (bfd *abfd,
  44                        struct bfd_link_info *info,
  45                        asection *sec,
  46                        const Elf_Internal_Rela *relocs)
  47 {
  48   bfd_boolean ret = TRUE;
  49   bfd *dynobj;
  50   Elf_Internal_Shdr *symtab_hdr;
  51   struct elf_link_hash_entry **sym_hashes;
  52   const Elf_Internal_Rela *rel;
  53   const Elf_Internal_Rela *rel_end;
  54   asection *sreloc;
  55   enum v850_reloc_type r_type;
  56   int other = 0;
  57   const char *common = NULL;
  58
  59   if (info->relocatable)
  60     return TRUE;
  61
  62 #ifdef DEBUG
  63   _bfd_error_handler ("v850_elf_check_relocs called for section %A in %B",
  64                       sec, abfd);
  65 #endif
  66
  67   dynobj = elf_hash_table (info)->dynobj;
  68   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
  69   sym_hashes = elf_sym_hashes (abfd);
  70   sreloc = NULL;
  71
  72   rel_end = relocs + sec->reloc_count;
  73   for (rel = relocs; rel < rel_end; rel++)
  74     {
  75       unsigned long r_symndx;
  76       struct elf_link_hash_entry *h;
  77
  78       r_symndx = ELF32_R_SYM (rel->r_info);
  79       if (r_symndx < symtab_hdr->sh_info)
  80         h = NULL;
  81       else
  82         {
  83           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
  84           while (h->root.type == bfd_link_hash_indirect
  85                  || h->root.type == bfd_link_hash_warning)
  86             h = (struct elf_link_hash_entry *) h->root.u.i.link;
  87         }
  88
  89       r_type = (enum v850_reloc_type) ELF32_R_TYPE (rel->r_info);
  90       switch (r_type)
  91         {
  92         default:
  93         case R_V850_NONE:
  94         case R_V850_9_PCREL:
  95         case R_V850_22_PCREL:
  96         case R_V850_HI16_S:
  97         case R_V850_HI16:
  98         case R_V850_LO16:
  99         case R_V850_LO16_SPLIT_OFFSET:
 100         case R_V850_ABS32:
 101         case R_V850_REL32:
 102         case R_V850_16:
 103         case R_V850_8:
 104         case R_V850_CALLT_6_7_OFFSET:
 105         case R_V850_CALLT_16_16_OFFSET:
 106           break;
 107
 108         /* This relocation describes the C++ object vtable hierarchy.
 109            Reconstruct it for later use during GC.  */
 110         case R_V850_GNU_VTINHERIT:
 111           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
 112             return FALSE;
 113           break;
 114
 115         /* This relocation describes which C++ vtable entries
 116            are actually used.  Record for later use during GC.  */
 117         case R_V850_GNU_VTENTRY:
 118           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
 119             return FALSE;
 120           break;
 121
 122         case R_V850_SDA_16_16_SPLIT_OFFSET:
 123         case R_V850_SDA_16_16_OFFSET:
 124         case R_V850_SDA_15_16_OFFSET:
 125           other = V850_OTHER_SDA;
 126           common = ".scommon";
 127           goto small_data_common;
 128
 129         case R_V850_ZDA_16_16_SPLIT_OFFSET:
 130         case R_V850_ZDA_16_16_OFFSET:
 131         case R_V850_ZDA_15_16_OFFSET:
 132           other = V850_OTHER_ZDA;
 133           common = ".zcommon";
 134           goto small_data_common;
 135
 136         case R_V850_TDA_4_5_OFFSET:
 137         case R_V850_TDA_4_4_OFFSET:
 138         case R_V850_TDA_6_8_OFFSET:
 139         case R_V850_TDA_7_8_OFFSET:
 140         case R_V850_TDA_7_7_OFFSET:
 141         case R_V850_TDA_16_16_OFFSET:
 142           other = V850_OTHER_TDA;
 143           common = ".tcommon";
 144           /* fall through */
 145
 146 #define V850_OTHER_MASK (V850_OTHER_TDA | V850_OTHER_SDA | V850_OTHER_ZDA)
 147
 148         small_data_common:
 149           if (h)
 150             {
 151               /* Flag which type of relocation was used.  */
 152               h->other |= other;
 153               if ((h->other & V850_OTHER_MASK) != (other & V850_OTHER_MASK)
 154                   && (h->other & V850_OTHER_ERROR) == 0)
 155                 {
 156                   const char * msg;
 157                   static char  buff[200]; /* XXX */
 158
 159                   switch (h->other & V850_OTHER_MASK)
 160                     {
 161                     default:
 162                       msg = _("Variable `%s' cannot occupy in multiple small data regions");
 163                       break;
 164                     case V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA:
 165                       msg = _("Variable `%s' can only be in one of the small, zero, and tiny data regions");
 166                       break;
 167                     case V850_OTHER_SDA | V850_OTHER_ZDA:
 168                       msg = _("Variable `%s' cannot be in both small and zero data regions simultaneously");
 169                       break;
 170                     case V850_OTHER_SDA | V850_OTHER_TDA:
 171                       msg = _("Variable `%s' cannot be in both small and tiny data regions simultaneously");
 172                       break;
 173                     case V850_OTHER_ZDA | V850_OTHER_TDA:
 174                       msg = _("Variable `%s' cannot be in both zero and tiny data regions simultaneously");
 175                       break;
 176                     }
 177
 178                   sprintf (buff, msg, h->root.root.string);
 179                   info->callbacks->warning (info, buff, h->root.root.string,
 180                                             abfd, h->root.u.def.section,
 181                                             (bfd_vma) 0);
 182
 183                   bfd_set_error (bfd_error_bad_value);
 184                   h->other |= V850_OTHER_ERROR;
 185                   ret = FALSE;
 186                 }
 187             }
 188
 189           if (h && h->root.type == bfd_link_hash_common
 190               && h->root.u.c.p
 191               && !strcmp (bfd_get_section_name (abfd, h->root.u.c.p->section), "COMMON"))
 192             {
 193               asection * section;
 194
 195               section = h->root.u.c.p->section = bfd_make_section_old_way (abfd, common);
 196               section->flags |= SEC_IS_COMMON;
 197             }
 198
 199 #ifdef DEBUG
 200           fprintf (stderr, "v850_elf_check_relocs, found %s relocation for %s%s\n",
 201                    v850_elf_howto_table[ (int)r_type ].name,
 202                    (h && h->root.root.string) ? h->root.root.string : "<unknown>",
 203                    (h->root.type == bfd_link_hash_common) ? ", symbol is common" : "");
 204 #endif
 205           break;
 206         }
 207     }
 208
 209   return ret;
 210 }
 211
 212 /* In the old version, when an entry was checked out from the table,
 213    it was deleted.  This produced an error if the entry was needed
 214    more than once, as the second attempted retry failed.
 215
 216    In the current version, the entry is not deleted, instead we set
 217    the field 'found' to TRUE.  If a second lookup matches the same
 218    entry, then we know that the hi16s reloc has already been updated
 219    and does not need to be updated a second time.
 220
 221    TODO - TOFIX: If it is possible that we need to restore 2 different
 222    addresses from the same table entry, where the first generates an
 223    overflow, whilst the second do not, then this code will fail.  */
 224
 225 typedef struct hi16s_location
 226 {
 227   bfd_vma                 addend;
 228   bfd_byte *              address;
 229   unsigned long           counter;
 230   bfd_boolean             found;
 231   struct hi16s_location * next;
 232 }
 233 hi16s_location;
 234
 235 static hi16s_location * previous_hi16s;
 236 static hi16s_location * free_hi16s;
 237 static unsigned long    hi16s_counter;
 238
 239 static void
 240 remember_hi16s_reloc (bfd *abfd, bfd_vma addend, bfd_byte *address)
 241 {
 242   hi16s_location * entry = NULL;
 243   bfd_size_type amt = sizeof (* free_hi16s);
 244
 245   /* Find a free structure.  */
 246   if (free_hi16s == NULL)
 247     free_hi16s = bfd_zalloc (abfd, amt);
 248
 249   entry      = free_hi16s;
 250   free_hi16s = free_hi16s->next;
 251
 252   entry->addend  = addend;
 253   entry->address = address;
 254   entry->counter = hi16s_counter ++;
 255   entry->found   = FALSE;
 256   entry->next    = previous_hi16s;
 257   previous_hi16s = entry;
 258
 259   /* Cope with wrap around of our counter.  */
 260   if (hi16s_counter == 0)
 261     {
 262       /* XXX: Assume that all counter entries differ only in their low 16 bits.  */
 263       for (entry = previous_hi16s; entry != NULL; entry = entry->next)
 264         entry->counter &= 0xffff;
 265
 266       hi16s_counter = 0x10000;
 267     }
 268 }
 269
 270 static bfd_byte *
 271 find_remembered_hi16s_reloc (bfd_vma addend, bfd_boolean *already_found)
 272 {
 273   hi16s_location *match = NULL;
 274   hi16s_location *entry;
 275   hi16s_location *previous = NULL;
 276   hi16s_location *prev;
 277   bfd_byte *addr;
 278
 279   /* Search the table.  Record the most recent entry that matches.  */
 280   for (entry = previous_hi16s; entry; entry = entry->next)
 281     {
 282       if (entry->addend == addend
 283           && (match == NULL || match->counter < entry->counter))
 284         {
 285           previous = prev;
 286           match    = entry;
 287         }
 288
 289       prev = entry;
 290     }
 291
 292   if (match == NULL)
 293     return NULL;
 294
 295   /* Extract the address.  */
 296   addr = match->address;
 297
 298   /* Remember if this entry has already been used before.  */
 299   if (already_found)
 300     * already_found = match->found;
 301
 302   /* Note that this entry has now been used.  */
 303   match->found = TRUE;
 304
 305   return addr;
 306 }
 307
 308 /* Calculate the final operand value for a R_V850_LO16 or
 309    R_V850_LO16_SPLIT_OFFSET.  *INSN is the current operand value and
 310    ADDEND is the sum of the relocation symbol and offset.  Store the
 311    operand value in *INSN and return true on success.
 312
 313    The assembler has already done some of this: If the value stored in
 314    the instruction has its 15th bit set, (counting from zero) then the
 315    assembler will have added 1 to the value stored in the associated
 316    HI16S reloc.  So for example, these relocations:
 317
 318        movhi hi( fred ), r0, r1
 319        movea lo( fred ), r1, r1
 320
 321    will store 0 in the value fields for the MOVHI and MOVEA instructions
 322    and addend will be the address of fred, but for these instructions:
 323
 324        movhi hi( fred + 0x123456), r0, r1
 325        movea lo( fred + 0x123456), r1, r1
 326
 327    the value stored in the MOVHI instruction will be 0x12 and the value
 328    stored in the MOVEA instruction will be 0x3456.  If however the
 329    instructions were:
 330
 331        movhi hi( fred + 0x10ffff), r0, r1
 332        movea lo( fred + 0x10ffff), r1, r1
 333
 334    then the value stored in the MOVHI instruction would be 0x11 (not
 335    0x10) and the value stored in the MOVEA instruction would be 0xffff.
 336    Thus (assuming for the moment that the addend is 0), at run time the
 337    MOVHI instruction loads 0x110000 into r1, then the MOVEA instruction
 338    adds 0xffffffff (sign extension!) producing 0x10ffff.  Similarly if
 339    the instructions were:
 340
 341        movhi hi( fred - 1), r0, r1
 342        movea lo( fred - 1), r1, r1
 343
 344    then 0 is stored in the MOVHI instruction and -1 is stored in the
 345    MOVEA instruction.
 346
 347    Overflow can occur if the addition of the value stored in the
 348    instruction plus the addend sets the 15th bit when before it was clear.
 349    This is because the 15th bit will be sign extended into the high part,
 350    thus reducing its value by one, but since the 15th bit was originally
 351    clear, the assembler will not have added 1 to the previous HI16S reloc
 352    to compensate for this effect.  For example:
 353
 354       movhi hi( fred + 0x123456), r0, r1
 355       movea lo( fred + 0x123456), r1, r1
 356
 357    The value stored in HI16S reloc is 0x12, the value stored in the LO16
 358    reloc is 0x3456.  If we assume that the address of fred is 0x00007000
 359    then the relocations become:
 360
 361      HI16S: 0x0012 + (0x00007000 >> 16)    = 0x12
 362      LO16:  0x3456 + (0x00007000 & 0xffff) = 0xa456
 363
 364    but when the instructions are executed, the MOVEA instruction's value
 365    is signed extended, so the sum becomes:
 366
 367         0x00120000
 368       + 0xffffa456
 369       ------------
 370         0x0011a456    but 'fred + 0x123456' = 0x0012a456
 371
 372    Note that if the 15th bit was set in the value stored in the LO16
 373    reloc, then we do not have to do anything:
 374
 375       movhi hi( fred + 0x10ffff), r0, r1
 376       movea lo( fred + 0x10ffff), r1, r1
 377
 378       HI16S:  0x0011 + (0x00007000 >> 16)    = 0x11
 379       LO16:   0xffff + (0x00007000 & 0xffff) = 0x6fff
 380
 381         0x00110000
 382       + 0x00006fff
 383       ------------
 384         0x00116fff  = fred + 0x10ffff = 0x7000 + 0x10ffff
 385
 386    Overflow can also occur if the computation carries into the 16th bit
 387    and it also results in the 15th bit having the same value as the 15th
 388    bit of the original value.   What happens is that the HI16S reloc
 389    will have already examined the 15th bit of the original value and
 390    added 1 to the high part if the bit is set.  This compensates for the
 391    sign extension of 15th bit of the result of the computation.  But now
 392    there is a carry into the 16th bit, and this has not been allowed for.
 393
 394    So, for example if fred is at address 0xf000:
 395
 396      movhi hi( fred + 0xffff), r0, r1    [bit 15 of the offset is set]
 397      movea lo( fred + 0xffff), r1, r1
 398
 399      HI16S: 0x0001 + (0x0000f000 >> 16)    = 0x0001
 400      LO16:  0xffff + (0x0000f000 & 0xffff) = 0xefff   (carry into bit 16 is lost)
 401
 402        0x00010000
 403      + 0xffffefff
 404      ------------
 405        0x0000efff   but 'fred + 0xffff' = 0x0001efff
 406
 407    Similarly, if the 15th bit remains clear, but overflow occurs into
 408    the 16th bit then (assuming the address of fred is 0xf000):
 409
 410      movhi hi( fred + 0x7000), r0, r1    [bit 15 of the offset is clear]
 411      movea lo( fred + 0x7000), r1, r1
 412
 413      HI16S: 0x0000 + (0x0000f000 >> 16)    = 0x0000
 414      LO16:  0x7000 + (0x0000f000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
 415
 416        0x00000000
 417      + 0x00006fff
 418      ------------
 419        0x00006fff   but 'fred + 0x7000' = 0x00016fff
 420
 421    Note - there is no need to change anything if a carry occurs, and the
 422    15th bit changes its value from being set to being clear, as the HI16S
 423    reloc will have already added in 1 to the high part for us:
 424
 425      movhi hi( fred + 0xffff), r0, r1     [bit 15 of the offset is set]
 426      movea lo( fred + 0xffff), r1, r1
 427
 428      HI16S: 0x0001 + (0x00007000 >> 16)
 429      LO16:  0xffff + (0x00007000 & 0xffff) = 0x6fff  (carry into bit 16 is lost)
 430
 431        0x00010000
 432      + 0x00006fff   (bit 15 not set, so the top half is zero)
 433      ------------
 434        0x00016fff   which is right (assuming that fred is at 0x7000)
 435
 436    but if the 15th bit goes from being clear to being set, then we must
 437    once again handle overflow:
 438
 439      movhi hi( fred + 0x7000), r0, r1     [bit 15 of the offset is clear]
 440      movea lo( fred + 0x7000), r1, r1
 441
 442      HI16S: 0x0000 + (0x0000ffff >> 16)
 443      LO16:  0x7000 + (0x0000ffff & 0xffff) = 0x6fff  (carry into bit 16)
 444
 445        0x00000000
 446      + 0x00006fff   (bit 15 not set, so the top half is zero)
 447      ------------
 448        0x00006fff   which is wrong (assuming that fred is at 0xffff).  */
 449
 450 static bfd_boolean
 451 v850_elf_perform_lo16_relocation (bfd *abfd, unsigned long *insn,
 452                                   unsigned long addend)
 453 {
 454 #define BIT15_SET(x) ((x) & 0x8000)
 455 #define OVERFLOWS(a,i) ((((a) & 0xffff) + (i)) > 0xffff)
 456
 457   if ((BIT15_SET (*insn + addend) && ! BIT15_SET (addend))
 458       || (OVERFLOWS (addend, *insn)
 459           && ((! BIT15_SET (*insn)) || (BIT15_SET (addend)))))
 460     {
 461       bfd_boolean already_updated;
 462       bfd_byte *hi16s_address = find_remembered_hi16s_reloc
 463         (addend, & already_updated);
 464
 465       /* Amend the matching HI16_S relocation.  */
 466       if (hi16s_address != NULL)
 467         {
 468           if (! already_updated)
 469             {
 470               unsigned long hi_insn = bfd_get_16 (abfd, hi16s_address);
 471               hi_insn += 1;
 472               bfd_put_16 (abfd, hi_insn, hi16s_address);
 473             }
 474         }
 475       else
 476         {
 477           fprintf (stderr, _("FAILED to find previous HI16 reloc\n"));
 478           return FALSE;
 479         }
 480     }
 481 #undef OVERFLOWS
 482 #undef BIT15_SET
 483
 484   /* Do not complain if value has top bit set, as this has been
 485      anticipated.  */
 486   *insn = (*insn + addend) & 0xffff;
 487   return TRUE;
 488 }
 489
 490 /* FIXME:  The code here probably ought to be removed and the code in reloc.c
 491    allowed to do its stuff instead.  At least for most of the relocs, anyway.  */
 492
 493 static bfd_reloc_status_type
 494 v850_elf_perform_relocation (bfd *abfd,
 495                              unsigned int r_type,
 496                              bfd_vma addend,
 497                              bfd_byte *address)
 498 {
 499   unsigned long insn;
 500   unsigned long result;
 501   bfd_signed_vma saddend = (bfd_signed_vma) addend;
 502
 503   switch (r_type)
 504     {
 505     default:
 506       return bfd_reloc_notsupported;
 507
 508     case R_V850_REL32:
 509     case R_V850_ABS32:
 510       bfd_put_32 (abfd, addend, address);
 511       return bfd_reloc_ok;
 512
 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_9_PCREL:
 527       if (saddend > 0xff || saddend < -0x100)
 528         return bfd_reloc_overflow;
 529
 530       if ((addend % 2) != 0)
 531         return bfd_reloc_dangerous;
 532
 533       insn  = bfd_get_16 (abfd, address);
 534       insn &= ~ 0xf870;
 535       insn |= ((addend & 0x1f0) << 7) | ((addend & 0x0e) << 3);
 536       break;
 537
 538     case R_V850_HI16:
 539       addend += (bfd_get_16 (abfd, address) << 16);
 540       addend = (addend >> 16);
 541       insn = addend;
 542       break;
 543
 544     case R_V850_HI16_S:
 545       /* Remember where this relocation took place.  */
 546       remember_hi16s_reloc (abfd, addend, address);
 547
 548       addend += (bfd_get_16 (abfd, address) << 16);
 549       addend = (addend >> 16) + ((addend & 0x8000) != 0);
 550
 551       /* This relocation cannot overflow.  */
 552       if (addend > 0x7fff)
 553         addend = 0;
 554
 555       insn = addend;
 556       break;
 557
 558     case R_V850_LO16:
 559       insn = bfd_get_16 (abfd, address);
 560       if (! v850_elf_perform_lo16_relocation (abfd, &insn, addend))
 561         return bfd_reloc_overflow;
 562       break;
 563
 564     case R_V850_8:
 565       addend += (char) bfd_get_8 (abfd, address);
 566
 567       saddend = (bfd_signed_vma) addend;
 568
 569       if (saddend > 0x7f || saddend < -0x80)
 570         return bfd_reloc_overflow;
 571
 572       bfd_put_8 (abfd, addend, address);
 573       return bfd_reloc_ok;
 574
 575     case R_V850_CALLT_16_16_OFFSET:
 576       addend += bfd_get_16 (abfd, address);
 577
 578       saddend = (bfd_signed_vma) addend;
 579
 580       if (saddend > 0xffff || saddend < 0)
 581         return bfd_reloc_overflow;
 582
 583       insn = addend;
 584       break;
 585
 586     case R_V850_16:
 587     case R_V850_SDA_16_16_OFFSET:
 588     case R_V850_ZDA_16_16_OFFSET:
 589     case R_V850_TDA_16_16_OFFSET:
 590       addend += bfd_get_16 (abfd, address);
 591
 592       saddend = (bfd_signed_vma) addend;
 593
 594       if (saddend > 0x7fff || saddend < -0x8000)
 595         return bfd_reloc_overflow;
 596
 597       insn = addend;
 598       break;
 599
 600     case R_V850_SDA_15_16_OFFSET:
 601     case R_V850_ZDA_15_16_OFFSET:
 602       insn = bfd_get_16 (abfd, address);
 603       addend += (insn & 0xfffe);
 604
 605       saddend = (bfd_signed_vma) addend;
 606
 607       if (saddend > 0x7ffe || saddend < -0x8000)
 608         return bfd_reloc_overflow;
 609
 610       if (addend & 1)
 611         return bfd_reloc_dangerous;
 612
 613       insn = (addend &~ (bfd_vma) 1) | (insn & 1);
 614       break;
 615
 616     case R_V850_TDA_6_8_OFFSET:
 617       insn = bfd_get_16 (abfd, address);
 618       addend += ((insn & 0x7e) << 1);
 619
 620       saddend = (bfd_signed_vma) addend;
 621
 622       if (saddend > 0xfc || saddend < 0)
 623         return bfd_reloc_overflow;
 624
 625       if (addend & 3)
 626         return bfd_reloc_dangerous;
 627
 628       insn &= 0xff81;
 629       insn |= (addend >> 1);
 630       break;
 631
 632     case R_V850_TDA_7_8_OFFSET:
 633       insn = bfd_get_16 (abfd, address);
 634       addend += ((insn & 0x7f) << 1);
 635
 636       saddend = (bfd_signed_vma) addend;
 637
 638       if (saddend > 0xfe || saddend < 0)
 639         return bfd_reloc_overflow;
 640
 641       if (addend & 1)
 642         return bfd_reloc_dangerous;
 643
 644       insn &= 0xff80;
 645       insn |= (addend >> 1);
 646       break;
 647
 648     case R_V850_TDA_7_7_OFFSET:
 649       insn = bfd_get_16 (abfd, address);
 650       addend += insn & 0x7f;
 651
 652       saddend = (bfd_signed_vma) addend;
 653
 654       if (saddend > 0x7f || saddend < 0)
 655         return bfd_reloc_overflow;
 656
 657       insn &= 0xff80;
 658       insn |= addend;
 659       break;
 660
 661     case R_V850_TDA_4_5_OFFSET:
 662       insn = bfd_get_16 (abfd, address);
 663       addend += ((insn & 0xf) << 1);
 664
 665       saddend = (bfd_signed_vma) addend;
 666
 667       if (saddend > 0x1e || saddend < 0)
 668         return bfd_reloc_overflow;
 669
 670       if (addend & 1)
 671         return bfd_reloc_dangerous;
 672
 673       insn &= 0xfff0;
 674       insn |= (addend >> 1);
 675       break;
 676
 677     case R_V850_TDA_4_4_OFFSET:
 678       insn = bfd_get_16 (abfd, address);
 679       addend += insn & 0xf;
 680
 681       saddend = (bfd_signed_vma) addend;
 682
 683       if (saddend > 0xf || saddend < 0)
 684         return bfd_reloc_overflow;
 685
 686       insn &= 0xfff0;
 687       insn |= addend;
 688       break;
 689
 690     case R_V850_LO16_SPLIT_OFFSET:
 691       insn = bfd_get_32 (abfd, address);
 692       result = ((insn & 0xfffe0000) >> 16) | ((insn & 0x20) >> 5);
 693       if (! v850_elf_perform_lo16_relocation (abfd, &result, addend))
 694         return bfd_reloc_overflow;
 695       insn = (((result << 16) & 0xfffe0000)
 696               | ((result << 5) & 0x20)
 697               | (insn & ~0xfffe0020));
 698       bfd_put_32 (abfd, insn, address);
 699       return bfd_reloc_ok;
 700
 701     case R_V850_ZDA_16_16_SPLIT_OFFSET:
 702     case R_V850_SDA_16_16_SPLIT_OFFSET:
 703       insn = bfd_get_32 (abfd, address);
 704       addend += ((insn & 0xfffe0000) >> 16) + ((insn & 0x20) >> 5);
 705
 706       saddend = (bfd_signed_vma) addend;
 707
 708       if (saddend > 0x7fff || saddend < -0x8000)
 709         return bfd_reloc_overflow;
 710
 711       insn &= 0x0001ffdf;
 712       insn |= (addend & 1) << 5;
 713       insn |= (addend &~ (bfd_vma) 1) << 16;
 714
 715       bfd_put_32 (abfd, (bfd_vma) insn, address);
 716       return bfd_reloc_ok;
 717
 718     case R_V850_CALLT_6_7_OFFSET:
 719       insn = bfd_get_16 (abfd, address);
 720       addend += ((insn & 0x3f) << 1);
 721
 722       saddend = (bfd_signed_vma) addend;
 723
 724       if (saddend > 0x7e || saddend < 0)
 725         return bfd_reloc_overflow;
 726
 727       if (addend & 1)
 728         return bfd_reloc_dangerous;
 729
 730       insn &= 0xff80;
 731       insn |= (addend >> 1);
 732       break;
 733
 734     case R_V850_GNU_VTINHERIT:
 735     case R_V850_GNU_VTENTRY:
 736       return bfd_reloc_ok;
 737
 738     }
 739
 740   bfd_put_16 (abfd, (bfd_vma) insn, address);
 741   return bfd_reloc_ok;
 742 }
 743 \f
 744 /* Insert the addend into the instruction.  */
 745
 746 static bfd_reloc_status_type
 747 v850_elf_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 748                 arelent *reloc,
 749                 asymbol *symbol,
 750                 void * data ATTRIBUTE_UNUSED,
 751                 asection *isection,
 752                 bfd *obfd,
 753                 char **err ATTRIBUTE_UNUSED)
 754 {
 755   long relocation;
 756
 757   /* If there is an output BFD,
 758      and the symbol is not a section name (which is only defined at final link time),
 759      and either we are not putting the addend into the instruction
 760       or the addend is zero, so there is nothing to add into the instruction
 761      then just fixup the address and return.  */
 762   if (obfd != NULL
 763       && (symbol->flags & BSF_SECTION_SYM) == 0
 764       && (! reloc->howto->partial_inplace
 765           || reloc->addend == 0))
 766     {
 767       reloc->address += isection->output_offset;
 768       return bfd_reloc_ok;
 769     }
 770
 771   /* Catch relocs involving undefined symbols.  */
 772   if (bfd_is_und_section (symbol->section)
 773       && (symbol->flags & BSF_WEAK) == 0
 774       && obfd == NULL)
 775     return bfd_reloc_undefined;
 776
 777   /* We handle final linking of some relocs ourselves.  */
 778
 779   /* Is the address of the relocation really within the section?  */
 780   if (reloc->address > bfd_get_section_limit (abfd, isection))
 781     return bfd_reloc_outofrange;
 782
 783   /* Work out which section the relocation is targeted at and the
 784      initial relocation command value.  */
 785
 786   if (reloc->howto->pc_relative)
 787     return bfd_reloc_ok;
 788
 789   /* Get symbol value.  (Common symbols are special.)  */
 790   if (bfd_is_com_section (symbol->section))
 791     relocation = 0;
 792   else
 793     relocation = symbol->value;
 794
 795   /* Convert input-section-relative symbol value to absolute + addend.  */
 796   relocation += symbol->section->output_section->vma;
 797   relocation += symbol->section->output_offset;
 798   relocation += reloc->addend;
 799
 800   reloc->addend = relocation;
 801   return bfd_reloc_ok;
 802 }
 803
 804 /* This function is used for relocs which are only used
 805    for relaxing, which the linker should otherwise ignore.  */
 806
 807 static bfd_reloc_status_type
 808 v850_elf_ignore_reloc (bfd *abfd ATTRIBUTE_UNUSED,
 809                        arelent *reloc_entry,
 810                        asymbol *symbol ATTRIBUTE_UNUSED,
 811                        void * data ATTRIBUTE_UNUSED,
 812                        asection *input_section,
 813                        bfd *output_bfd,
 814                        char **error_message ATTRIBUTE_UNUSED)
 815 {
 816   if (output_bfd != NULL)
 817     reloc_entry->address += input_section->output_offset;
 818
 819   return bfd_reloc_ok;
 820 }
 821 /* Note: It is REQUIRED that the 'type' value of each entry
 822    in this array match the index of the entry in the array.  */
 823 static reloc_howto_type v850_elf_howto_table[] =
 824 {
 825   /* This reloc does nothing.  */
 826   HOWTO (R_V850_NONE,                   /* Type.  */
 827          0,                             /* Rightshift.  */
 828          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 829          32,                            /* Bitsize.  */
 830          FALSE,                         /* PC_relative.  */
 831          0,                             /* Bitpos.  */
 832          complain_overflow_bitfield,    /* Complain_on_overflow.  */
 833          bfd_elf_generic_reloc,         /* Special_function.  */
 834          "R_V850_NONE",                 /* Name.  */
 835          FALSE,                         /* Partial_inplace.  */
 836          0,                             /* Src_mask.  */
 837          0,                             /* Dst_mask.  */
 838          FALSE),                        /* PCrel_offset.  */
 839
 840   /* A PC relative 9 bit branch.  */
 841   HOWTO (R_V850_9_PCREL,                /* Type.  */
 842          2,                             /* Rightshift.  */
 843          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 844          26,                            /* Bitsize.  */
 845          TRUE,                          /* PC_relative.  */
 846          0,                             /* Bitpos.  */
 847          complain_overflow_bitfield,    /* Complain_on_overflow.  */
 848          v850_elf_reloc,                /* Special_function.  */
 849          "R_V850_9_PCREL",              /* Name.  */
 850          FALSE,                         /* Partial_inplace.  */
 851          0x00ffffff,                    /* Src_mask.  */
 852          0x00ffffff,                    /* Dst_mask.  */
 853          TRUE),                         /* PCrel_offset.  */
 854
 855   /* A PC relative 22 bit branch.  */
 856   HOWTO (R_V850_22_PCREL,               /* Type.  */
 857          2,                             /* Rightshift.  */
 858          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 859          22,                            /* Bitsize.  */
 860          TRUE,                          /* PC_relative.  */
 861          7,                             /* Bitpos.  */
 862          complain_overflow_signed,      /* Complain_on_overflow.  */
 863          v850_elf_reloc,                /* Special_function.  */
 864          "R_V850_22_PCREL",             /* Name.  */
 865          FALSE,                         /* Partial_inplace.  */
 866          0x07ffff80,                    /* Src_mask.  */
 867          0x07ffff80,                    /* Dst_mask.  */
 868          TRUE),                         /* PCrel_offset.  */
 869
 870   /* High 16 bits of symbol value.  */
 871   HOWTO (R_V850_HI16_S,                 /* Type.  */
 872          0,                             /* Rightshift.  */
 873          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 874          16,                            /* Bitsize.  */
 875          FALSE,                         /* PC_relative.  */
 876          0,                             /* Bitpos.  */
 877          complain_overflow_dont,        /* Complain_on_overflow.  */
 878          v850_elf_reloc,                /* Special_function.  */
 879          "R_V850_HI16_S",               /* Name.  */
 880          FALSE,                         /* Partial_inplace.  */
 881          0xffff,                        /* Src_mask.  */
 882          0xffff,                        /* Dst_mask.  */
 883          FALSE),                        /* PCrel_offset.  */
 884
 885   /* High 16 bits of symbol value.  */
 886   HOWTO (R_V850_HI16,                   /* Type.  */
 887          0,                             /* Rightshift.  */
 888          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 889          16,                            /* Bitsize.  */
 890          FALSE,                         /* PC_relative.  */
 891          0,                             /* Bitpos.  */
 892          complain_overflow_dont,        /* Complain_on_overflow.  */
 893          v850_elf_reloc,                /* Special_function.  */
 894          "R_V850_HI16",                 /* Name.  */
 895          FALSE,                         /* Partial_inplace.  */
 896          0xffff,                        /* Src_mask.  */
 897          0xffff,                        /* Dst_mask.  */
 898          FALSE),                        /* PCrel_offset.  */
 899
 900   /* Low 16 bits of symbol value.  */
 901   HOWTO (R_V850_LO16,                   /* Type.  */
 902          0,                             /* Rightshift.  */
 903          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 904          16,                            /* Bitsize.  */
 905          FALSE,                         /* PC_relative.  */
 906          0,                             /* Bitpos.  */
 907          complain_overflow_dont,        /* Complain_on_overflow.  */
 908          v850_elf_reloc,                /* Special_function.  */
 909          "R_V850_LO16",                 /* Name.  */
 910          FALSE,                         /* Partial_inplace.  */
 911          0xffff,                        /* Src_mask.  */
 912          0xffff,                        /* Dst_mask.  */
 913          FALSE),                        /* PCrel_offset.  */
 914
 915   /* Simple 32bit reloc.  */
 916   HOWTO (R_V850_ABS32,                  /* Type.  */
 917          0,                             /* Rightshift.  */
 918          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 919          32,                            /* Bitsize.  */
 920          FALSE,                         /* PC_relative.  */
 921          0,                             /* Bitpos.  */
 922          complain_overflow_dont,        /* Complain_on_overflow.  */
 923          v850_elf_reloc,                /* Special_function.  */
 924          "R_V850_ABS32",                /* Name.  */
 925          FALSE,                         /* Partial_inplace.  */
 926          0xffffffff,                    /* Src_mask.  */
 927          0xffffffff,                    /* Dst_mask.  */
 928          FALSE),                        /* PCrel_offset.  */
 929
 930   /* Simple 16bit reloc.  */
 931   HOWTO (R_V850_16,                     /* Type.  */
 932          0,                             /* Rightshift.  */
 933          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 934          16,                            /* Bitsize.  */
 935          FALSE,                         /* PC_relative.  */
 936          0,                             /* Bitpos.  */
 937          complain_overflow_dont,        /* Complain_on_overflow.  */
 938          bfd_elf_generic_reloc,         /* Special_function.  */
 939          "R_V850_16",                   /* Name.  */
 940          FALSE,                         /* Partial_inplace.  */
 941          0xffff,                        /* Src_mask.  */
 942          0xffff,                        /* Dst_mask.  */
 943          FALSE),                        /* PCrel_offset.  */
 944
 945   /* Simple 8bit reloc.  */
 946   HOWTO (R_V850_8,                      /* Type.  */
 947          0,                             /* Rightshift.  */
 948          0,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 949          8,                             /* Bitsize.  */
 950          FALSE,                         /* PC_relative.  */
 951          0,                             /* Bitpos.  */
 952          complain_overflow_dont,        /* Complain_on_overflow.  */
 953          bfd_elf_generic_reloc,         /* Special_function.  */
 954          "R_V850_8",                    /* Name.  */
 955          FALSE,                         /* Partial_inplace.  */
 956          0xff,                          /* Src_mask.  */
 957          0xff,                          /* Dst_mask.  */
 958          FALSE),                        /* PCrel_offset.  */
 959
 960   /* 16 bit offset from the short data area pointer.  */
 961   HOWTO (R_V850_SDA_16_16_OFFSET,       /* Type.  */
 962          0,                             /* Rightshift.  */
 963          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 964          16,                            /* Bitsize.  */
 965          FALSE,                         /* PC_relative.  */
 966          0,                             /* Bitpos.  */
 967          complain_overflow_dont,        /* Complain_on_overflow.  */
 968          v850_elf_reloc,                /* Special_function.  */
 969          "R_V850_SDA_16_16_OFFSET",     /* Name.  */
 970          FALSE,                         /* Partial_inplace.  */
 971          0xffff,                        /* Src_mask.  */
 972          0xffff,                        /* Dst_mask.  */
 973          FALSE),                        /* PCrel_offset.  */
 974
 975   /* 15 bit offset from the short data area pointer.  */
 976   HOWTO (R_V850_SDA_15_16_OFFSET,       /* Type.  */
 977          1,                             /* Rightshift.  */
 978          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 979          16,                            /* Bitsize.  */
 980          FALSE,                         /* PC_relative.  */
 981          1,                             /* Bitpos.  */
 982          complain_overflow_dont,        /* Complain_on_overflow.  */
 983          v850_elf_reloc,                /* Special_function.  */
 984          "R_V850_SDA_15_16_OFFSET",     /* Name.  */
 985          FALSE,                         /* Partial_inplace.  */
 986          0xfffe,                        /* Src_mask.  */
 987          0xfffe,                        /* Dst_mask.  */
 988          FALSE),                        /* PCrel_offset.  */
 989
 990   /* 16 bit offset from the zero data area pointer.  */
 991   HOWTO (R_V850_ZDA_16_16_OFFSET,       /* Type.  */
 992          0,                             /* Rightshift.  */
 993          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
 994          16,                            /* Bitsize.  */
 995          FALSE,                         /* PC_relative.  */
 996          0,                             /* Bitpos.  */
 997          complain_overflow_dont,        /* Complain_on_overflow.  */
 998          v850_elf_reloc,                /* Special_function.  */
 999          "R_V850_ZDA_16_16_OFFSET",     /* Name.  */
1000          FALSE,                         /* Partial_inplace.  */
1001          0xffff,                        /* Src_mask.  */
1002          0xffff,                        /* Dst_mask.  */
1003          FALSE),                        /* PCrel_offset.  */
1004
1005   /* 15 bit offset from the zero data area pointer.  */
1006   HOWTO (R_V850_ZDA_15_16_OFFSET,       /* Type.  */
1007          1,                             /* Rightshift.  */
1008          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1009          16,                            /* Bitsize.  */
1010          FALSE,                         /* PC_relative.  */
1011          1,                             /* Bitpos.  */
1012          complain_overflow_dont,        /* Complain_on_overflow.  */
1013          v850_elf_reloc,                /* Special_function.  */
1014          "R_V850_ZDA_15_16_OFFSET",     /* Name.  */
1015          FALSE,                         /* Partial_inplace.  */
1016          0xfffe,                        /* Src_mask.  */
1017          0xfffe,                        /* Dst_mask.  */
1018          FALSE),                        /* PCrel_offset.  */
1019
1020   /* 6 bit offset from the tiny data area pointer.  */
1021   HOWTO (R_V850_TDA_6_8_OFFSET,         /* Type.  */
1022          2,                             /* Rightshift.  */
1023          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1024          8,                             /* Bitsize.  */
1025          FALSE,                         /* PC_relative.  */
1026          1,                             /* Bitpos.  */
1027          complain_overflow_dont,        /* Complain_on_overflow.  */
1028          v850_elf_reloc,                /* Special_function.  */
1029          "R_V850_TDA_6_8_OFFSET",       /* Name.  */
1030          FALSE,                         /* Partial_inplace.  */
1031          0x7e,                          /* Src_mask.  */
1032          0x7e,                          /* Dst_mask.  */
1033          FALSE),                        /* PCrel_offset.  */
1034
1035   /* 8 bit offset from the tiny data area pointer.  */
1036   HOWTO (R_V850_TDA_7_8_OFFSET,         /* Type.  */
1037          1,                             /* Rightshift.  */
1038          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1039          8,                             /* Bitsize.  */
1040          FALSE,                         /* PC_relative.  */
1041          0,                             /* Bitpos.  */
1042          complain_overflow_dont,        /* Complain_on_overflow.  */
1043          v850_elf_reloc,                /* Special_function.  */
1044          "R_V850_TDA_7_8_OFFSET",       /* Name.  */
1045          FALSE,                         /* Partial_inplace.  */
1046          0x7f,                          /* Src_mask.  */
1047          0x7f,                          /* Dst_mask.  */
1048          FALSE),                        /* PCrel_offset.  */
1049
1050   /* 7 bit offset from the tiny data area pointer.  */
1051   HOWTO (R_V850_TDA_7_7_OFFSET,         /* Type.  */
1052          0,                             /* Rightshift.  */
1053          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1054          7,                             /* Bitsize.  */
1055          FALSE,                         /* PC_relative.  */
1056          0,                             /* Bitpos.  */
1057          complain_overflow_dont,        /* Complain_on_overflow.  */
1058          v850_elf_reloc,                /* Special_function.  */
1059          "R_V850_TDA_7_7_OFFSET",       /* Name.  */
1060          FALSE,                         /* Partial_inplace.  */
1061          0x7f,                          /* Src_mask.  */
1062          0x7f,                          /* Dst_mask.  */
1063          FALSE),                        /* PCrel_offset.  */
1064
1065   /* 16 bit offset from the tiny data area pointer!  */
1066   HOWTO (R_V850_TDA_16_16_OFFSET,       /* Type.  */
1067          0,                             /* Rightshift.  */
1068          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1069          16,                            /* Bitsize.  */
1070          FALSE,                         /* PC_relative.  */
1071          0,                             /* Bitpos.  */
1072          complain_overflow_dont,        /* Complain_on_overflow.  */
1073          v850_elf_reloc,                /* Special_function.  */
1074          "R_V850_TDA_16_16_OFFSET",     /* Name.  */
1075          FALSE,                         /* Partial_inplace.  */
1076          0xffff,                        /* Src_mask.  */
1077          0xfff,                         /* Dst_mask.  */
1078          FALSE),                        /* PCrel_offset.  */
1079
1080   /* 5 bit offset from the tiny data area pointer.  */
1081   HOWTO (R_V850_TDA_4_5_OFFSET,         /* Type.  */
1082          1,                             /* Rightshift.  */
1083          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1084          5,                             /* Bitsize.  */
1085          FALSE,                         /* PC_relative.  */
1086          0,                             /* Bitpos.  */
1087          complain_overflow_dont,        /* Complain_on_overflow.  */
1088          v850_elf_reloc,                /* Special_function.  */
1089          "R_V850_TDA_4_5_OFFSET",       /* Name.  */
1090          FALSE,                         /* Partial_inplace.  */
1091          0x0f,                          /* Src_mask.  */
1092          0x0f,                          /* Dst_mask.  */
1093          FALSE),                        /* PCrel_offset.  */
1094
1095   /* 4 bit offset from the tiny data area pointer.  */
1096   HOWTO (R_V850_TDA_4_4_OFFSET,         /* Type.  */
1097          0,                             /* Rightshift.  */
1098          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1099          4,                             /* Bitsize.  */
1100          FALSE,                         /* PC_relative.  */
1101          0,                             /* Bitpos.  */
1102          complain_overflow_dont,        /* Complain_on_overflow.  */
1103          v850_elf_reloc,                /* Special_function.  */
1104          "R_V850_TDA_4_4_OFFSET",       /* Name.  */
1105          FALSE,                         /* Partial_inplace.  */
1106          0x0f,                          /* Src_mask.  */
1107          0x0f,                          /* Dst_mask.  */
1108          FALSE),                        /* PCrel_offset.  */
1109
1110   /* 16 bit offset from the short data area pointer.  */
1111   HOWTO (R_V850_SDA_16_16_SPLIT_OFFSET, /* Type.  */
1112          0,                             /* Rightshift.  */
1113          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1114          16,                            /* Bitsize.  */
1115          FALSE,                         /* PC_relative.  */
1116          0,                             /* Bitpos.  */
1117          complain_overflow_dont,        /* Complain_on_overflow.  */
1118          v850_elf_reloc,                /* Special_function.  */
1119          "R_V850_SDA_16_16_SPLIT_OFFSET",/* Name.  */
1120          FALSE,                         /* Partial_inplace.  */
1121          0xfffe0020,                    /* Src_mask.  */
1122          0xfffe0020,                    /* Dst_mask.  */
1123          FALSE),                        /* PCrel_offset.  */
1124
1125   /* 16 bit offset from the zero data area pointer.  */
1126   HOWTO (R_V850_ZDA_16_16_SPLIT_OFFSET, /* Type.  */
1127          0,                             /* Rightshift.  */
1128          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1129          16,                            /* Bitsize.  */
1130          FALSE,                         /* PC_relative.  */
1131          0,                             /* Bitpos.  */
1132          complain_overflow_dont,        /* Complain_on_overflow.  */
1133          v850_elf_reloc,                /* Special_function.  */
1134          "R_V850_ZDA_16_16_SPLIT_OFFSET",/* Name.  */
1135          FALSE,                         /* Partial_inplace.  */
1136          0xfffe0020,                    /* Src_mask.  */
1137          0xfffe0020,                    /* Dst_mask.  */
1138          FALSE),                        /* PCrel_offset.  */
1139
1140   /* 6 bit offset from the call table base pointer.  */
1141   HOWTO (R_V850_CALLT_6_7_OFFSET,       /* Type.  */
1142          0,                             /* Rightshift.  */
1143          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1144          7,                             /* Bitsize.  */
1145          FALSE,                         /* PC_relative.  */
1146          0,                             /* Bitpos.  */
1147          complain_overflow_dont,        /* Complain_on_overflow.  */
1148          v850_elf_reloc,                /* Special_function.  */
1149          "R_V850_CALLT_6_7_OFFSET",     /* Name.  */
1150          FALSE,                         /* Partial_inplace.  */
1151          0x3f,                          /* Src_mask.  */
1152          0x3f,                          /* Dst_mask.  */
1153          FALSE),                        /* PCrel_offset.  */
1154
1155   /* 16 bit offset from the call table base pointer.  */
1156   HOWTO (R_V850_CALLT_16_16_OFFSET,     /* Type.  */
1157          0,                             /* Rightshift.  */
1158          1,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1159          16,                            /* Bitsize.  */
1160          FALSE,                         /* PC_relative.  */
1161          0,                             /* Bitpos.  */
1162          complain_overflow_dont,        /* Complain_on_overflow.  */
1163          v850_elf_reloc,                /* Special_function.  */
1164          "R_V850_CALLT_16_16_OFFSET",   /* Name.  */
1165          FALSE,                         /* Partial_inplace.  */
1166          0xffff,                        /* Src_mask.  */
1167          0xffff,                        /* Dst_mask.  */
1168          FALSE),                        /* PCrel_offset.  */
1169
1170   /* GNU extension to record C++ vtable hierarchy */
1171   HOWTO (R_V850_GNU_VTINHERIT, /* Type.  */
1172          0,                     /* Rightshift.  */
1173          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1174          0,                     /* Bitsize.  */
1175          FALSE,                 /* PC_relative.  */
1176          0,                     /* Bitpos.  */
1177          complain_overflow_dont, /* Complain_on_overflow.  */
1178          NULL,                  /* Special_function.  */
1179          "R_V850_GNU_VTINHERIT", /* Name.  */
1180          FALSE,                 /* Partial_inplace.  */
1181          0,                     /* Src_mask.  */
1182          0,                     /* Dst_mask.  */
1183          FALSE),                /* PCrel_offset.  */
1184
1185   /* GNU extension to record C++ vtable member usage */
1186   HOWTO (R_V850_GNU_VTENTRY,     /* Type.  */
1187          0,                     /* Rightshift.  */
1188          2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1189          0,                     /* Bitsize.  */
1190          FALSE,                 /* PC_relative.  */
1191          0,                     /* Bitpos.  */
1192          complain_overflow_dont, /* Complain_on_overflow.  */
1193          _bfd_elf_rel_vtable_reloc_fn,  /* Special_function.  */
1194          "R_V850_GNU_VTENTRY",   /* Name.  */
1195          FALSE,                 /* Partial_inplace.  */
1196          0,                     /* Src_mask.  */
1197          0,                     /* Dst_mask.  */
1198          FALSE),                /* PCrel_offset.  */
1199
1200   /* Indicates a .longcall pseudo-op.  The compiler will generate a .longcall
1201      pseudo-op when it finds a function call which can be relaxed.  */
1202   HOWTO (R_V850_LONGCALL,     /* Type.  */
1203        0,                     /* Rightshift.  */
1204        2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1205        32,                    /* Bitsize.  */
1206        TRUE,                  /* PC_relative.  */
1207        0,                     /* Bitpos.  */
1208        complain_overflow_signed, /* Complain_on_overflow.  */
1209        v850_elf_ignore_reloc, /* Special_function.  */
1210        "R_V850_LONGCALL",     /* Name.  */
1211        FALSE,                 /* Partial_inplace.  */
1212        0,                     /* Src_mask.  */
1213        0,                     /* Dst_mask.  */
1214        TRUE),                 /* PCrel_offset.  */
1215
1216   /* Indicates a .longjump pseudo-op.  The compiler will generate a
1217      .longjump pseudo-op when it finds a branch which can be relaxed.  */
1218   HOWTO (R_V850_LONGJUMP,     /* Type.  */
1219        0,                     /* Rightshift.  */
1220        2,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1221        32,                    /* Bitsize.  */
1222        TRUE,                  /* PC_relative.  */
1223        0,                     /* Bitpos.  */
1224        complain_overflow_signed, /* Complain_on_overflow.  */
1225        v850_elf_ignore_reloc, /* Special_function.  */
1226        "R_V850_LONGJUMP",     /* Name.  */
1227        FALSE,                 /* Partial_inplace.  */
1228        0,                     /* Src_mask.  */
1229        0,                     /* Dst_mask.  */
1230        TRUE),                 /* PCrel_offset.  */
1231
1232   HOWTO (R_V850_ALIGN,        /* Type.  */
1233        0,                     /* Rightshift.  */
1234        1,                     /* Size (0 = byte, 1 = short, 2 = long).  */
1235        0,                     /* Bitsize.  */
1236        FALSE,                 /* PC_relative.  */
1237        0,                     /* Bitpos.  */
1238        complain_overflow_unsigned, /* Complain_on_overflow.  */
1239        v850_elf_ignore_reloc, /* Special_function.  */
1240        "R_V850_ALIGN",        /* Name.  */
1241        FALSE,                 /* Partial_inplace.  */
1242        0,                     /* Src_mask.  */
1243        0,                     /* Dst_mask.  */
1244        TRUE),                 /* PCrel_offset.  */
1245
1246   /* Simple pc-relative 32bit reloc.  */
1247   HOWTO (R_V850_REL32,                  /* Type.  */
1248          0,                             /* Rightshift.  */
1249          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1250          32,                            /* Bitsize.  */
1251          TRUE,                          /* PC_relative.  */
1252          0,                             /* Bitpos.  */
1253          complain_overflow_dont,        /* Complain_on_overflow.  */
1254          v850_elf_reloc,                /* Special_function.  */
1255          "R_V850_REL32",                /* Name.  */
1256          FALSE,                         /* Partial_inplace.  */
1257          0xffffffff,                    /* Src_mask.  */
1258          0xffffffff,                    /* Dst_mask.  */
1259          FALSE),                        /* PCrel_offset.  */
1260
1261   /* An ld.bu version of R_V850_LO16.  */
1262   HOWTO (R_V850_LO16_SPLIT_OFFSET,      /* Type.  */
1263          0,                             /* Rightshift.  */
1264          2,                             /* Size (0 = byte, 1 = short, 2 = long).  */
1265          16,                            /* Bitsize.  */
1266          FALSE,                         /* PC_relative.  */
1267          0,                             /* Bitpos.  */
1268          complain_overflow_dont,        /* Complain_on_overflow.  */
1269          v850_elf_reloc,                /* Special_function.  */
1270          "R_V850_LO16_SPLIT_OFFSET",    /* Name.  */
1271          FALSE,                         /* Partial_inplace.  */
1272          0xfffe0020,                    /* Src_mask.  */
1273          0xfffe0020,                    /* Dst_mask.  */
1274          FALSE),                        /* PCrel_offset.  */
1275 };
1276
1277 /* Map BFD reloc types to V850 ELF reloc types.  */
1278
1279 struct v850_elf_reloc_map
1280 {
1281   /* BFD_RELOC_V850_CALLT_16_16_OFFSET is 258, which will not fix in an
1282      unsigned char.  */
1283   bfd_reloc_code_real_type bfd_reloc_val;
1284   unsigned int elf_reloc_val;
1285 };
1286
1287 static const struct v850_elf_reloc_map v850_elf_reloc_map[] =
1288 {
1289   { BFD_RELOC_NONE,                        R_V850_NONE                   },
1290   { BFD_RELOC_V850_9_PCREL,                R_V850_9_PCREL                },
1291   { BFD_RELOC_V850_22_PCREL,               R_V850_22_PCREL               },
1292   { BFD_RELOC_HI16_S,                      R_V850_HI16_S                 },
1293   { BFD_RELOC_HI16,                        R_V850_HI16                   },
1294   { BFD_RELOC_LO16,                        R_V850_LO16                   },
1295   { BFD_RELOC_32,                          R_V850_ABS32                  },
1296   { BFD_RELOC_32_PCREL,                    R_V850_REL32                  },
1297   { BFD_RELOC_16,                          R_V850_16                     },
1298   { BFD_RELOC_8,                           R_V850_8                      },
1299   { BFD_RELOC_V850_SDA_16_16_OFFSET,       R_V850_SDA_16_16_OFFSET       },
1300   { BFD_RELOC_V850_SDA_15_16_OFFSET,       R_V850_SDA_15_16_OFFSET       },
1301   { BFD_RELOC_V850_ZDA_16_16_OFFSET,       R_V850_ZDA_16_16_OFFSET       },
1302   { BFD_RELOC_V850_ZDA_15_16_OFFSET,       R_V850_ZDA_15_16_OFFSET       },
1303   { BFD_RELOC_V850_TDA_6_8_OFFSET,         R_V850_TDA_6_8_OFFSET         },
1304   { BFD_RELOC_V850_TDA_7_8_OFFSET,         R_V850_TDA_7_8_OFFSET         },
1305   { BFD_RELOC_V850_TDA_7_7_OFFSET,         R_V850_TDA_7_7_OFFSET         },
1306   { BFD_RELOC_V850_TDA_16_16_OFFSET,       R_V850_TDA_16_16_OFFSET       },
1307   { BFD_RELOC_V850_TDA_4_5_OFFSET,         R_V850_TDA_4_5_OFFSET         },
1308   { BFD_RELOC_V850_TDA_4_4_OFFSET,         R_V850_TDA_4_4_OFFSET         },
1309   { BFD_RELOC_V850_LO16_SPLIT_OFFSET,      R_V850_LO16_SPLIT_OFFSET      },
1310   { BFD_RELOC_V850_SDA_16_16_SPLIT_OFFSET, R_V850_SDA_16_16_SPLIT_OFFSET },
1311   { BFD_RELOC_V850_ZDA_16_16_SPLIT_OFFSET, R_V850_ZDA_16_16_SPLIT_OFFSET },
1312   { BFD_RELOC_V850_CALLT_6_7_OFFSET,       R_V850_CALLT_6_7_OFFSET       },
1313   { BFD_RELOC_V850_CALLT_16_16_OFFSET,     R_V850_CALLT_16_16_OFFSET     },
1314   { BFD_RELOC_VTABLE_INHERIT,              R_V850_GNU_VTINHERIT          },
1315   { BFD_RELOC_VTABLE_ENTRY,                R_V850_GNU_VTENTRY            },
1316   { BFD_RELOC_V850_LONGCALL,               R_V850_LONGCALL               },
1317   { BFD_RELOC_V850_LONGJUMP,               R_V850_LONGJUMP               },
1318   { BFD_RELOC_V850_ALIGN,                  R_V850_ALIGN                  },
1319
1320 };
1321 \f
1322 /* Map a bfd relocation into the appropriate howto structure.  */
1323
1324 static reloc_howto_type *
1325 v850_elf_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1326                             bfd_reloc_code_real_type code)
1327 {
1328   unsigned int i;
1329
1330   for (i = ARRAY_SIZE (v850_elf_reloc_map); i --;)
1331     if (v850_elf_reloc_map[i].bfd_reloc_val == code)
1332       {
1333         unsigned int elf_reloc_val = v850_elf_reloc_map[i].elf_reloc_val;
1334
1335         BFD_ASSERT (v850_elf_howto_table[elf_reloc_val].type == elf_reloc_val);
1336
1337         return v850_elf_howto_table + elf_reloc_val;
1338       }
1339
1340   return NULL;
1341 }
1342
1343 static reloc_howto_type *
1344 v850_elf_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1345                             const char *r_name)
1346 {
1347   unsigned int i;
1348
1349   for (i = 0;
1350        i < sizeof (v850_elf_howto_table) / sizeof (v850_elf_howto_table[0]);
1351        i++)
1352     if (v850_elf_howto_table[i].name != NULL
1353         && strcasecmp (v850_elf_howto_table[i].name, r_name) == 0)
1354       return &v850_elf_howto_table[i];
1355
1356   return NULL;
1357 }
1358 \f
1359 /* Set the howto pointer for an V850 ELF reloc.  */
1360
1361 static void
1362 v850_elf_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1363                             arelent *cache_ptr,
1364                             Elf_Internal_Rela *dst)
1365 {
1366   unsigned int r_type;
1367
1368   r_type = ELF32_R_TYPE (dst->r_info);
1369   BFD_ASSERT (r_type < (unsigned int) R_V850_max);
1370   cache_ptr->howto = &v850_elf_howto_table[r_type];
1371 }
1372
1373 /* Set the howto pointer for a V850 ELF reloc (type RELA).  */
1374
1375 static void
1376 v850_elf_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
1377                              arelent * cache_ptr,
1378                              Elf_Internal_Rela *dst)
1379 {
1380   unsigned int r_type;
1381
1382   r_type = ELF32_R_TYPE (dst->r_info);
1383   BFD_ASSERT (r_type < (unsigned int) R_V850_max);
1384   cache_ptr->howto = &v850_elf_howto_table[r_type];
1385 }
1386 \f
1387 static bfd_boolean
1388 v850_elf_is_local_label_name (bfd *abfd ATTRIBUTE_UNUSED, const char *name)
1389 {
1390   return (   (name[0] == '.' && (name[1] == 'L' || name[1] == '.'))
1391           || (name[0] == '_' &&  name[1] == '.' && name[2] == 'L' && name[3] == '_'));
1392 }
1393 \f
1394 /* We overload some of the bfd_reloc error codes for own purposes.  */
1395 #define bfd_reloc_gp_not_found          bfd_reloc_other
1396 #define bfd_reloc_ep_not_found          bfd_reloc_continue
1397 #define bfd_reloc_ctbp_not_found        (bfd_reloc_dangerous + 1)
1398
1399 /* Perform a relocation as part of a final link.  */
1400
1401 static bfd_reloc_status_type
1402 v850_elf_final_link_relocate (reloc_howto_type *howto,
1403                               bfd *input_bfd,
1404                               bfd *output_bfd ATTRIBUTE_UNUSED,
1405                               asection *input_section,
1406                               bfd_byte *contents,
1407                               bfd_vma offset,
1408                               bfd_vma value,
1409                               bfd_vma addend,
1410                               struct bfd_link_info *info,
1411                               asection *sym_sec,
1412                               int is_local ATTRIBUTE_UNUSED)
1413 {
1414   unsigned int r_type = howto->type;
1415   bfd_byte *hit_data = contents + offset;
1416
1417   /* Adjust the value according to the relocation.  */
1418   switch (r_type)
1419     {
1420     case R_V850_9_PCREL:
1421       value -= (input_section->output_section->vma
1422                 + input_section->output_offset);
1423       value -= offset;
1424       break;
1425
1426     case R_V850_22_PCREL:
1427       value -= (input_section->output_section->vma
1428                 + input_section->output_offset
1429                 + offset);
1430
1431       /* If the sign extension will corrupt the value then we have overflowed.  */
1432       if (((value & 0xff000000) != 0x0) && ((value & 0xff000000) != 0xff000000))
1433         return bfd_reloc_overflow;
1434
1435       /* Only the bottom 24 bits of the PC are valid.  */
1436       value = SEXT24 (value);
1437       break;
1438
1439     case R_V850_REL32:
1440       value -= (input_section->output_section->vma
1441                 + input_section->output_offset
1442                 + offset);
1443       break;
1444
1445     case R_V850_HI16_S:
1446     case R_V850_HI16:
1447     case R_V850_LO16:
1448     case R_V850_LO16_SPLIT_OFFSET:
1449     case R_V850_16:
1450     case R_V850_ABS32:
1451     case R_V850_8:
1452       break;
1453
1454     case R_V850_ZDA_15_16_OFFSET:
1455     case R_V850_ZDA_16_16_OFFSET:
1456     case R_V850_ZDA_16_16_SPLIT_OFFSET:
1457       if (sym_sec == NULL)
1458         return bfd_reloc_undefined;
1459
1460       value -= sym_sec->output_section->vma;
1461       break;
1462
1463     case R_V850_SDA_15_16_OFFSET:
1464     case R_V850_SDA_16_16_OFFSET:
1465     case R_V850_SDA_16_16_SPLIT_OFFSET:
1466       {
1467         unsigned long                gp;
1468         struct bfd_link_hash_entry * h;
1469
1470         if (sym_sec == NULL)
1471           return bfd_reloc_undefined;
1472
1473         /* Get the value of __gp.  */
1474         h = bfd_link_hash_lookup (info->hash, "__gp", FALSE, FALSE, TRUE);
1475         if (h == NULL
1476             || h->type != bfd_link_hash_defined)
1477           return bfd_reloc_gp_not_found;
1478
1479         gp = (h->u.def.value
1480               + h->u.def.section->output_section->vma
1481               + h->u.def.section->output_offset);
1482
1483         value -= sym_sec->output_section->vma;
1484         value -= (gp - sym_sec->output_section->vma);
1485       }
1486     break;
1487
1488     case R_V850_TDA_4_4_OFFSET:
1489     case R_V850_TDA_4_5_OFFSET:
1490     case R_V850_TDA_16_16_OFFSET:
1491     case R_V850_TDA_7_7_OFFSET:
1492     case R_V850_TDA_7_8_OFFSET:
1493     case R_V850_TDA_6_8_OFFSET:
1494       {
1495         unsigned long                ep;
1496         struct bfd_link_hash_entry * h;
1497
1498         /* Get the value of __ep.  */
1499         h = bfd_link_hash_lookup (info->hash, "__ep", FALSE, FALSE, TRUE);
1500         if (h == NULL
1501             || h->type != bfd_link_hash_defined)
1502           return bfd_reloc_ep_not_found;
1503
1504         ep = (h->u.def.value
1505               + h->u.def.section->output_section->vma
1506               + h->u.def.section->output_offset);
1507
1508         value -= ep;
1509       }
1510     break;
1511
1512     case R_V850_CALLT_6_7_OFFSET:
1513       {
1514         unsigned long                ctbp;
1515         struct bfd_link_hash_entry * h;
1516
1517         /* Get the value of __ctbp.  */
1518         h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE);
1519         if (h == NULL
1520             || h->type != bfd_link_hash_defined)
1521           return bfd_reloc_ctbp_not_found;
1522
1523         ctbp = (h->u.def.value
1524               + h->u.def.section->output_section->vma
1525               + h->u.def.section->output_offset);
1526         value -= ctbp;
1527       }
1528     break;
1529
1530     case R_V850_CALLT_16_16_OFFSET:
1531       {
1532         unsigned long                ctbp;
1533         struct bfd_link_hash_entry * h;
1534
1535         if (sym_sec == NULL)
1536           return bfd_reloc_undefined;
1537
1538         /* Get the value of __ctbp.  */
1539         h = bfd_link_hash_lookup (info->hash, "__ctbp", FALSE, FALSE, TRUE);
1540         if (h == NULL
1541             || h->type != bfd_link_hash_defined)
1542           return bfd_reloc_ctbp_not_found;
1543
1544         ctbp = (h->u.def.value
1545               + h->u.def.section->output_section->vma
1546               + h->u.def.section->output_offset);
1547
1548         value -= sym_sec->output_section->vma;
1549         value -= (ctbp - sym_sec->output_section->vma);
1550       }
1551     break;
1552
1553     case R_V850_NONE:
1554     case R_V850_GNU_VTINHERIT:
1555     case R_V850_GNU_VTENTRY:
1556     case R_V850_LONGCALL:
1557     case R_V850_LONGJUMP:
1558     case R_V850_ALIGN:
1559       return bfd_reloc_ok;
1560
1561     default:
1562       return bfd_reloc_notsupported;
1563     }
1564
1565   /* Perform the relocation.  */
1566   return v850_elf_perform_relocation (input_bfd, r_type, value + addend, hit_data);
1567 }
1568 \f
1569 /* Relocate an V850 ELF section.  */
1570
1571 static bfd_boolean
1572 v850_elf_relocate_section (bfd *output_bfd,
1573                            struct bfd_link_info *info,
1574                            bfd *input_bfd,
1575                            asection *input_section,
1576                            bfd_byte *contents,
1577                            Elf_Internal_Rela *relocs,
1578                            Elf_Internal_Sym *local_syms,
1579                            asection **local_sections)
1580 {
1581   Elf_Internal_Shdr *symtab_hdr;
1582   struct elf_link_hash_entry **sym_hashes;
1583   Elf_Internal_Rela *rel;
1584   Elf_Internal_Rela *relend;
1585
1586   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1587   sym_hashes = elf_sym_hashes (input_bfd);
1588
1589   /* Reset the list of remembered HI16S relocs to empty.  */
1590   free_hi16s     = previous_hi16s;
1591   previous_hi16s = NULL;
1592   hi16s_counter  = 0;
1593
1594   rel    = relocs;
1595   relend = relocs + input_section->reloc_count;
1596   for (; rel < relend; rel++)
1597     {
1598       int r_type;
1599       reloc_howto_type *howto;
1600       unsigned long r_symndx;
1601       Elf_Internal_Sym *sym;
1602       asection *sec;
1603       struct elf_link_hash_entry *h;
1604       bfd_vma relocation;
1605       bfd_reloc_status_type r;
1606
1607       r_symndx = ELF32_R_SYM (rel->r_info);
1608       r_type   = ELF32_R_TYPE (rel->r_info);
1609
1610       if (r_type == R_V850_GNU_VTENTRY
1611           || r_type == R_V850_GNU_VTINHERIT)
1612         continue;
1613
1614       howto = v850_elf_howto_table + r_type;
1615       h = NULL;
1616       sym = NULL;
1617       sec = NULL;
1618       if (r_symndx < symtab_hdr->sh_info)
1619         {
1620           sym = local_syms + r_symndx;
1621           sec = local_sections[r_symndx];
1622           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1623         }
1624       else
1625         {
1626           bfd_boolean unresolved_reloc, warned;
1627
1628           /* Note - this check is delayed until now as it is possible and
1629              valid to have a file without any symbols but with relocs that
1630              can be processed.  */
1631           if (sym_hashes == NULL)
1632             {
1633               info->callbacks->warning
1634                 (info, "no hash table available",
1635                  NULL, input_bfd, input_section, (bfd_vma) 0);
1636
1637               return FALSE;
1638             }
1639
1640           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1641                                    r_symndx, symtab_hdr, sym_hashes,
1642                                    h, sec, relocation,
1643                                    unresolved_reloc, warned);
1644         }
1645
1646       if (sec != NULL && elf_discarded_section (sec))
1647         {
1648           /* For relocs against symbols from removed linkonce sections,
1649              or sections discarded by a linker script, we just want the
1650              section contents zeroed.  Avoid any special processing.  */
1651           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1652           rel->r_info = 0;
1653           rel->r_addend = 0;
1654           continue;
1655         }
1656
1657       if (info->relocatable)
1658         continue;
1659
1660       /* FIXME: We should use the addend, but the COFF relocations don't.  */
1661       r = v850_elf_final_link_relocate (howto, input_bfd, output_bfd,
1662                                         input_section,
1663                                         contents, rel->r_offset,
1664                                         relocation, rel->r_addend,
1665                                         info, sec, h == NULL);
1666
1667       if (r != bfd_reloc_ok)
1668         {
1669           const char * name;
1670           const char * msg = NULL;
1671
1672           if (h != NULL)
1673             name = h->root.root.string;
1674           else
1675             {
1676               name = (bfd_elf_string_from_elf_section
1677                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1678               if (name == NULL || *name == '\0')
1679                 name = bfd_section_name (input_bfd, sec);
1680             }
1681
1682           switch (r)
1683             {
1684             case bfd_reloc_overflow:
1685               if (! ((*info->callbacks->reloc_overflow)
1686                      (info, (h ? &h->root : NULL), name, howto->name,
1687                       (bfd_vma) 0, input_bfd, input_section,
1688                       rel->r_offset)))
1689                 return FALSE;
1690               break;
1691
1692             case bfd_reloc_undefined:
1693               if (! ((*info->callbacks->undefined_symbol)
1694                      (info, name, input_bfd, input_section,
1695                       rel->r_offset, TRUE)))
1696                 return FALSE;
1697               break;
1698
1699             case bfd_reloc_outofrange:
1700               msg = _("internal error: out of range error");
1701               goto common_error;
1702
1703             case bfd_reloc_notsupported:
1704               msg = _("internal error: unsupported relocation error");
1705               goto common_error;
1706
1707             case bfd_reloc_dangerous:
1708               msg = _("internal error: dangerous relocation");
1709               goto common_error;
1710
1711             case bfd_reloc_gp_not_found:
1712               msg = _("could not locate special linker symbol __gp");
1713               goto common_error;
1714
1715             case bfd_reloc_ep_not_found:
1716               msg = _("could not locate special linker symbol __ep");
1717               goto common_error;
1718
1719             case bfd_reloc_ctbp_not_found:
1720               msg = _("could not locate special linker symbol __ctbp");
1721               goto common_error;
1722
1723             default:
1724               msg = _("internal error: unknown error");
1725               /* fall through */
1726
1727             common_error:
1728               if (!((*info->callbacks->warning)
1729                     (info, msg, name, input_bfd, input_section,
1730                      rel->r_offset)))
1731                 return FALSE;
1732               break;
1733             }
1734         }
1735     }
1736
1737   return TRUE;
1738 }
1739
1740 static asection *
1741 v850_elf_gc_mark_hook (asection *sec,
1742                        struct bfd_link_info *info,
1743                        Elf_Internal_Rela *rel,
1744                        struct elf_link_hash_entry *h,
1745                        Elf_Internal_Sym *sym)
1746 {
1747   if (h != NULL)
1748     switch (ELF32_R_TYPE (rel->r_info))
1749       {
1750       case R_V850_GNU_VTINHERIT:
1751       case R_V850_GNU_VTENTRY:
1752         return NULL;
1753       }
1754
1755   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1756 }
1757
1758 /* Set the right machine number.  */
1759
1760 static bfd_boolean
1761 v850_elf_object_p (bfd *abfd)
1762 {
1763   switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1764     {
1765     default:
1766     case E_V850_ARCH:
1767       bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850);
1768       break;
1769     case E_V850E_ARCH:
1770       bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e);
1771       break;
1772     case E_V850E1_ARCH:
1773       bfd_default_set_arch_mach (abfd, bfd_arch_v850, bfd_mach_v850e1);
1774       break;
1775     }
1776   return TRUE;
1777 }
1778
1779 /* Store the machine number in the flags field.  */
1780
1781 static void
1782 v850_elf_final_write_processing (bfd *abfd,
1783                                  bfd_boolean linker ATTRIBUTE_UNUSED)
1784 {
1785   unsigned long val;
1786
1787   switch (bfd_get_mach (abfd))
1788     {
1789     default:
1790     case bfd_mach_v850:   val = E_V850_ARCH; break;
1791     case bfd_mach_v850e:  val = E_V850E_ARCH; break;
1792     case bfd_mach_v850e1: val = E_V850E1_ARCH; break;
1793     }
1794
1795   elf_elfheader (abfd)->e_flags &=~ EF_V850_ARCH;
1796   elf_elfheader (abfd)->e_flags |= val;
1797 }
1798
1799 /* Function to keep V850 specific file flags.  */
1800
1801 static bfd_boolean
1802 v850_elf_set_private_flags (bfd *abfd, flagword flags)
1803 {
1804   BFD_ASSERT (!elf_flags_init (abfd)
1805               || elf_elfheader (abfd)->e_flags == flags);
1806
1807   elf_elfheader (abfd)->e_flags = flags;
1808   elf_flags_init (abfd) = TRUE;
1809   return TRUE;
1810 }
1811
1812 /* Merge backend specific data from an object file
1813    to the output object file when linking.  */
1814
1815 static bfd_boolean
1816 v850_elf_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
1817 {
1818   flagword out_flags;
1819   flagword in_flags;
1820
1821   if (   bfd_get_flavour (ibfd) != bfd_target_elf_flavour
1822       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
1823     return TRUE;
1824
1825   in_flags = elf_elfheader (ibfd)->e_flags;
1826   out_flags = elf_elfheader (obfd)->e_flags;
1827
1828   if (! elf_flags_init (obfd))
1829     {
1830       /* If the input is the default architecture then do not
1831          bother setting the flags for the output architecture,
1832          instead allow future merges to do this.  If no future
1833          merges ever set these flags then they will retain their
1834          unitialised values, which surprise surprise, correspond
1835          to the default values.  */
1836       if (bfd_get_arch_info (ibfd)->the_default)
1837         return TRUE;
1838
1839       elf_flags_init (obfd) = TRUE;
1840       elf_elfheader (obfd)->e_flags = in_flags;
1841
1842       if (bfd_get_arch (obfd) == bfd_get_arch (ibfd)
1843           && bfd_get_arch_info (obfd)->the_default)
1844         return bfd_set_arch_mach (obfd, bfd_get_arch (ibfd), bfd_get_mach (ibfd));
1845
1846       return TRUE;
1847     }
1848
1849   /* Check flag compatibility.  */
1850   if (in_flags == out_flags)
1851     return TRUE;
1852
1853   if ((in_flags & EF_V850_ARCH) != (out_flags & EF_V850_ARCH)
1854       && (in_flags & EF_V850_ARCH) != E_V850_ARCH)
1855     {
1856       /* Allow v850e1 binaries to be linked with v850e binaries.
1857          Set the output binary to v850e.  */
1858       if ((in_flags & EF_V850_ARCH) == E_V850E1_ARCH
1859           && (out_flags & EF_V850_ARCH) == E_V850E_ARCH)
1860         return TRUE;
1861
1862       if ((in_flags & EF_V850_ARCH) == E_V850E_ARCH
1863           && (out_flags & EF_V850_ARCH) == E_V850E1_ARCH)
1864         {
1865           elf_elfheader (obfd)->e_flags =
1866             ((out_flags & ~ EF_V850_ARCH) | E_V850E_ARCH);
1867           return TRUE;
1868         }
1869
1870       _bfd_error_handler (_("%B: Architecture mismatch with previous modules"),
1871                           ibfd);
1872     }
1873
1874   return TRUE;
1875 }
1876
1877 /* Display the flags field.  */
1878
1879 static bfd_boolean
1880 v850_elf_print_private_bfd_data (bfd *abfd, void * ptr)
1881 {
1882   FILE * file = (FILE *) ptr;
1883
1884   BFD_ASSERT (abfd != NULL && ptr != NULL);
1885
1886   _bfd_elf_print_private_bfd_data (abfd, ptr);
1887
1888   /* xgettext:c-format */
1889   fprintf (file, _("private flags = %lx: "), elf_elfheader (abfd)->e_flags);
1890
1891   switch (elf_elfheader (abfd)->e_flags & EF_V850_ARCH)
1892     {
1893     default:
1894     case E_V850_ARCH: fprintf (file, _("v850 architecture")); break;
1895     case E_V850E_ARCH: fprintf (file, _("v850e architecture")); break;
1896     case E_V850E1_ARCH: fprintf (file, _("v850e1 architecture")); break;
1897     }
1898
1899   fputc ('\n', file);
1900
1901   return TRUE;
1902 }
1903
1904 /* V850 ELF uses four common sections.  One is the usual one, and the
1905    others are for (small) objects in one of the special data areas:
1906    small, tiny and zero.  All the objects are kept together, and then
1907    referenced via the gp register, the ep register or the r0 register
1908    respectively, which yields smaller, faster assembler code.  This
1909    approach is copied from elf32-mips.c.  */
1910
1911 static asection  v850_elf_scom_section;
1912 static asymbol   v850_elf_scom_symbol;
1913 static asymbol * v850_elf_scom_symbol_ptr;
1914 static asection  v850_elf_tcom_section;
1915 static asymbol   v850_elf_tcom_symbol;
1916 static asymbol * v850_elf_tcom_symbol_ptr;
1917 static asection  v850_elf_zcom_section;
1918 static asymbol   v850_elf_zcom_symbol;
1919 static asymbol * v850_elf_zcom_symbol_ptr;
1920
1921 /* Given a BFD section, try to locate the
1922    corresponding ELF section index.  */
1923
1924 static bfd_boolean
1925 v850_elf_section_from_bfd_section (bfd *abfd ATTRIBUTE_UNUSED,
1926                                    asection *sec,
1927                                    int *retval)
1928 {
1929   if (strcmp (bfd_get_section_name (abfd, sec), ".scommon") == 0)
1930     *retval = SHN_V850_SCOMMON;
1931   else if (strcmp (bfd_get_section_name (abfd, sec), ".tcommon") == 0)
1932     *retval = SHN_V850_TCOMMON;
1933   else if (strcmp (bfd_get_section_name (abfd, sec), ".zcommon") == 0)
1934     *retval = SHN_V850_ZCOMMON;
1935   else
1936     return FALSE;
1937
1938   return TRUE;
1939 }
1940
1941 /* Handle the special V850 section numbers that a symbol may use.  */
1942
1943 static void
1944 v850_elf_symbol_processing (bfd *abfd, asymbol *asym)
1945 {
1946   elf_symbol_type * elfsym = (elf_symbol_type *) asym;
1947   unsigned int indx;
1948
1949   indx = elfsym->internal_elf_sym.st_shndx;
1950
1951   /* If the section index is an "ordinary" index, then it may
1952      refer to a v850 specific section created by the assembler.
1953      Check the section's type and change the index it matches.
1954
1955      FIXME: Should we alter the st_shndx field as well ?  */
1956
1957   if (indx < elf_numsections (abfd))
1958     switch (elf_elfsections(abfd)[indx]->sh_type)
1959       {
1960       case SHT_V850_SCOMMON:
1961         indx = SHN_V850_SCOMMON;
1962         break;
1963
1964       case SHT_V850_TCOMMON:
1965         indx = SHN_V850_TCOMMON;
1966         break;
1967
1968       case SHT_V850_ZCOMMON:
1969         indx = SHN_V850_ZCOMMON;
1970         break;
1971
1972       default:
1973         break;
1974       }
1975
1976   switch (indx)
1977     {
1978     case SHN_V850_SCOMMON:
1979       if (v850_elf_scom_section.name == NULL)
1980         {
1981           /* Initialize the small common section.  */
1982           v850_elf_scom_section.name           = ".scommon";
1983           v850_elf_scom_section.flags          = SEC_IS_COMMON | SEC_ALLOC | SEC_DATA;
1984           v850_elf_scom_section.output_section = & v850_elf_scom_section;
1985           v850_elf_scom_section.symbol         = & v850_elf_scom_symbol;
1986           v850_elf_scom_section.symbol_ptr_ptr = & v850_elf_scom_symbol_ptr;
1987           v850_elf_scom_symbol.name            = ".scommon";
1988           v850_elf_scom_symbol.flags           = BSF_SECTION_SYM;
1989           v850_elf_scom_symbol.section         = & v850_elf_scom_section;
1990           v850_elf_scom_symbol_ptr             = & v850_elf_scom_symbol;
1991         }
1992       asym->section = & v850_elf_scom_section;
1993       asym->value = elfsym->internal_elf_sym.st_size;
1994       break;
1995
1996     case SHN_V850_TCOMMON:
1997       if (v850_elf_tcom_section.name == NULL)
1998         {
1999           /* Initialize the tcommon section.  */
2000           v850_elf_tcom_section.name           = ".tcommon";
2001           v850_elf_tcom_section.flags          = SEC_IS_COMMON;
2002           v850_elf_tcom_section.output_section = & v850_elf_tcom_section;
2003           v850_elf_tcom_section.symbol         = & v850_elf_tcom_symbol;
2004           v850_elf_tcom_section.symbol_ptr_ptr = & v850_elf_tcom_symbol_ptr;
2005           v850_elf_tcom_symbol.name            = ".tcommon";
2006           v850_elf_tcom_symbol.flags           = BSF_SECTION_SYM;
2007           v850_elf_tcom_symbol.section         = & v850_elf_tcom_section;
2008           v850_elf_tcom_symbol_ptr             = & v850_elf_tcom_symbol;
2009         }
2010       asym->section = & v850_elf_tcom_section;
2011       asym->value = elfsym->internal_elf_sym.st_size;
2012       break;
2013
2014     case SHN_V850_ZCOMMON:
2015       if (v850_elf_zcom_section.name == NULL)
2016         {
2017           /* Initialize the zcommon section.  */
2018           v850_elf_zcom_section.name           = ".zcommon";
2019           v850_elf_zcom_section.flags          = SEC_IS_COMMON;
2020           v850_elf_zcom_section.output_section = & v850_elf_zcom_section;
2021           v850_elf_zcom_section.symbol         = & v850_elf_zcom_symbol;
2022           v850_elf_zcom_section.symbol_ptr_ptr = & v850_elf_zcom_symbol_ptr;
2023           v850_elf_zcom_symbol.name            = ".zcommon";
2024           v850_elf_zcom_symbol.flags           = BSF_SECTION_SYM;
2025           v850_elf_zcom_symbol.section         = & v850_elf_zcom_section;
2026           v850_elf_zcom_symbol_ptr             = & v850_elf_zcom_symbol;
2027         }
2028       asym->section = & v850_elf_zcom_section;
2029       asym->value = elfsym->internal_elf_sym.st_size;
2030       break;
2031     }
2032 }
2033
2034 /* Hook called by the linker routine which adds symbols from an object
2035    file.  We must handle the special v850 section numbers here.  */
2036
2037 static bfd_boolean
2038 v850_elf_add_symbol_hook (bfd *abfd,
2039                           struct bfd_link_info *info ATTRIBUTE_UNUSED,
2040                           Elf_Internal_Sym *sym,
2041                           const char **namep ATTRIBUTE_UNUSED,
2042                           flagword *flagsp ATTRIBUTE_UNUSED,
2043                           asection **secp,
2044                           bfd_vma *valp)
2045 {
2046   unsigned int indx = sym->st_shndx;
2047
2048   /* If the section index is an "ordinary" index, then it may
2049      refer to a v850 specific section created by the assembler.
2050      Check the section's type and change the index it matches.
2051
2052      FIXME: Should we alter the st_shndx field as well ?  */
2053
2054   if (indx < elf_numsections (abfd))
2055     switch (elf_elfsections(abfd)[indx]->sh_type)
2056       {
2057       case SHT_V850_SCOMMON:
2058         indx = SHN_V850_SCOMMON;
2059         break;
2060
2061       case SHT_V850_TCOMMON:
2062         indx = SHN_V850_TCOMMON;
2063         break;
2064
2065       case SHT_V850_ZCOMMON:
2066         indx = SHN_V850_ZCOMMON;
2067         break;
2068
2069       default:
2070         break;
2071       }
2072
2073   switch (indx)
2074     {
2075     case SHN_V850_SCOMMON:
2076       *secp = bfd_make_section_old_way (abfd, ".scommon");
2077       (*secp)->flags |= SEC_IS_COMMON;
2078       *valp = sym->st_size;
2079       break;
2080
2081     case SHN_V850_TCOMMON:
2082       *secp = bfd_make_section_old_way (abfd, ".tcommon");
2083       (*secp)->flags |= SEC_IS_COMMON;
2084       *valp = sym->st_size;
2085       break;
2086
2087     case SHN_V850_ZCOMMON:
2088       *secp = bfd_make_section_old_way (abfd, ".zcommon");
2089       (*secp)->flags |= SEC_IS_COMMON;
2090       *valp = sym->st_size;
2091       break;
2092     }
2093
2094   return TRUE;
2095 }
2096
2097 static bfd_boolean
2098 v850_elf_link_output_symbol_hook (struct bfd_link_info *info ATTRIBUTE_UNUSED,
2099                                   const char *name ATTRIBUTE_UNUSED,
2100                                   Elf_Internal_Sym *sym,
2101                                   asection *input_sec,
2102                                   struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
2103 {
2104   /* If we see a common symbol, which implies a relocatable link, then
2105      if a symbol was in a special common section in an input file, mark
2106      it as a special common in the output file.  */
2107
2108   if (sym->st_shndx == SHN_COMMON)
2109     {
2110       if (strcmp (input_sec->name, ".scommon") == 0)
2111         sym->st_shndx = SHN_V850_SCOMMON;
2112       else if (strcmp (input_sec->name, ".tcommon") == 0)
2113         sym->st_shndx = SHN_V850_TCOMMON;
2114       else if (strcmp (input_sec->name, ".zcommon") == 0)
2115         sym->st_shndx = SHN_V850_ZCOMMON;
2116     }
2117
2118   /* The price we pay for using h->other unused bits as flags in the
2119      linker is cleaning up after ourselves.  */
2120
2121   sym->st_other &= ~(V850_OTHER_SDA | V850_OTHER_ZDA | V850_OTHER_TDA
2122                      | V850_OTHER_ERROR);
2123
2124   return TRUE;
2125 }
2126
2127 static bfd_boolean
2128 v850_elf_section_from_shdr (bfd *abfd,
2129                             Elf_Internal_Shdr *hdr,
2130                             const char *name,
2131                             int shindex)
2132 {
2133   /* There ought to be a place to keep ELF backend specific flags, but
2134      at the moment there isn't one.  We just keep track of the
2135      sections by their name, instead.  */
2136
2137   if (! _bfd_elf_make_section_from_shdr (abfd, hdr, name, shindex))
2138     return FALSE;
2139
2140   switch (hdr->sh_type)
2141     {
2142     case SHT_V850_SCOMMON:
2143     case SHT_V850_TCOMMON:
2144     case SHT_V850_ZCOMMON:
2145       if (! bfd_set_section_flags (abfd, hdr->bfd_section,
2146                                    (bfd_get_section_flags (abfd,
2147                                                            hdr->bfd_section)
2148                                     | SEC_IS_COMMON)))
2149         return FALSE;
2150     }
2151
2152   return TRUE;
2153 }
2154
2155 /* Set the correct type for a V850 ELF section.  We do this
2156    by the section name, which is a hack, but ought to work.  */
2157
2158 static bfd_boolean
2159 v850_elf_fake_sections (bfd *abfd ATTRIBUTE_UNUSED,
2160                         Elf_Internal_Shdr *hdr,
2161                         asection *sec)
2162 {
2163   const char * name;
2164
2165   name = bfd_get_section_name (abfd, sec);
2166
2167   if (strcmp (name, ".scommon") == 0)
2168     hdr->sh_type = SHT_V850_SCOMMON;
2169   else if (strcmp (name, ".tcommon") == 0)
2170     hdr->sh_type = SHT_V850_TCOMMON;
2171   else if (strcmp (name, ".zcommon") == 0)
2172     hdr->sh_type = SHT_V850_ZCOMMON;
2173
2174   return TRUE;
2175 }
2176
2177 /* Delete some bytes from a section while relaxing.  */
2178
2179 static bfd_boolean
2180 v850_elf_relax_delete_bytes (bfd *abfd,
2181                              asection *sec,
2182                              bfd_vma addr,
2183                              bfd_vma toaddr,
2184                              int count)
2185 {
2186   Elf_Internal_Shdr *symtab_hdr;
2187   Elf32_External_Sym *extsyms;
2188   Elf32_External_Sym *esym;
2189   Elf32_External_Sym *esymend;
2190   int index;
2191   unsigned int sec_shndx;
2192   bfd_byte *contents;
2193   Elf_Internal_Rela *irel;
2194   Elf_Internal_Rela *irelend;
2195   struct elf_link_hash_entry *sym_hash;
2196   Elf_Internal_Shdr *shndx_hdr;
2197   Elf_External_Sym_Shndx *shndx;
2198
2199   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2200   extsyms = (Elf32_External_Sym *) symtab_hdr->contents;
2201
2202   sec_shndx = _bfd_elf_section_from_bfd_section (abfd, sec);
2203
2204   contents = elf_section_data (sec)->this_hdr.contents;
2205
2206   /* The deletion must stop at the next ALIGN reloc for an alignment
2207      power larger than the number of bytes we are deleting.  */
2208
2209   /* Actually delete the bytes.  */
2210 #if (DEBUG_RELAX & 2)
2211   fprintf (stderr, "relax_delete: contents: sec: %s  %p .. %p %x\n",
2212            sec->name, addr, toaddr, count );
2213 #endif
2214   memmove (contents + addr, contents + addr + count,
2215            toaddr - addr - count);
2216   memset (contents + toaddr-count, 0, count);
2217
2218   /* Adjust all the relocs.  */
2219   irel = elf_section_data (sec)->relocs;
2220   irelend = irel + sec->reloc_count;
2221   shndx_hdr = &elf_tdata (abfd)->symtab_shndx_hdr;
2222   shndx = (Elf_External_Sym_Shndx *) shndx_hdr->contents;
2223
2224   for (; irel < irelend; irel++)
2225     {
2226       bfd_vma raddr, paddr, symval;
2227       Elf_Internal_Sym isym;
2228
2229       /* Get the new reloc address.  */
2230       raddr = irel->r_offset;
2231       if ((raddr >= (addr + count) && raddr < toaddr))
2232         irel->r_offset -= count;
2233
2234       if (raddr >= addr && raddr < addr + count)
2235         {
2236           irel->r_info = ELF32_R_INFO (ELF32_R_SYM (irel->r_info),
2237                                        (int) R_V850_NONE);
2238           continue;
2239         }
2240
2241       if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN)
2242         continue;
2243
2244       bfd_elf32_swap_symbol_in (abfd,
2245                                 extsyms + ELF32_R_SYM (irel->r_info),
2246                                 shndx ? shndx + ELF32_R_SYM (irel->r_info) : NULL,
2247                                 & isym);
2248
2249       if (isym.st_shndx != sec_shndx)
2250         continue;
2251
2252       /* Get the value of the symbol referred to by the reloc.  */
2253       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
2254         {
2255           symval = isym.st_value;
2256 #if (DEBUG_RELAX & 2)
2257           {
2258             char * name = bfd_elf_string_from_elf_section
2259                            (abfd, symtab_hdr->sh_link, isym.st_name);
2260             fprintf (stderr,
2261                "relax_delete: local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
2262                sec->name, name, isym.st_name,
2263                sec->output_section->vma, sec->output_offset,
2264                isym.st_value, irel->r_addend);
2265           }
2266 #endif
2267         }
2268       else
2269         {
2270           unsigned long indx;
2271           struct elf_link_hash_entry * h;
2272
2273           /* An external symbol.  */
2274           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2275
2276           h = elf_sym_hashes (abfd) [indx];
2277           BFD_ASSERT (h != NULL);
2278
2279           symval = h->root.u.def.value;
2280 #if (DEBUG_RELAX & 2)
2281           fprintf (stderr,
2282                    "relax_delete: defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
2283                    sec->name, h->root.root.string, h->root.u.def.value,
2284                    sec->output_section->vma, sec->output_offset, irel->r_addend);
2285 #endif
2286         }
2287
2288       paddr = symval + irel->r_addend;
2289
2290       if ( (symval >= addr + count && symval < toaddr)
2291           && (paddr < addr + count || paddr >= toaddr))
2292         irel->r_addend += count;
2293       else if (    (symval < addr + count || symval >= toaddr)
2294                 && (paddr >= addr + count && paddr < toaddr))
2295         irel->r_addend -= count;
2296     }
2297
2298   /* Adjust the local symbols defined in this section.  */
2299   esym = extsyms;
2300   esymend = esym + symtab_hdr->sh_info;
2301
2302   for (; esym < esymend; esym++, shndx = (shndx ? shndx + 1 : NULL))
2303     {
2304       Elf_Internal_Sym isym;
2305
2306       bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
2307
2308       if (isym.st_shndx == sec_shndx
2309           && isym.st_value >= addr + count
2310           && isym.st_value < toaddr)
2311         {
2312           isym.st_value -= count;
2313
2314           if (isym.st_value + isym.st_size >= toaddr)
2315             isym.st_size += count;
2316
2317           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2318         }
2319       else if (isym.st_shndx == sec_shndx
2320                && isym.st_value < addr + count)
2321         {
2322           if (isym.st_value+isym.st_size >= addr + count
2323               && isym.st_value+isym.st_size < toaddr)
2324             isym.st_size -= count;
2325
2326           if (isym.st_value >= addr
2327               && isym.st_value <  addr + count)
2328             isym.st_value = addr;
2329
2330           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2331         }
2332     }
2333
2334   /* Now adjust the global symbols defined in this section.  */
2335   esym = extsyms + symtab_hdr->sh_info;
2336   esymend = extsyms + (symtab_hdr->sh_size / sizeof (Elf32_External_Sym));
2337
2338   for (index = 0; esym < esymend; esym ++, index ++)
2339     {
2340       Elf_Internal_Sym isym;
2341
2342       bfd_elf32_swap_symbol_in (abfd, esym, shndx, & isym);
2343       sym_hash = elf_sym_hashes (abfd) [index];
2344
2345       if (isym.st_shndx == sec_shndx
2346           && ((sym_hash)->root.type == bfd_link_hash_defined
2347               || (sym_hash)->root.type == bfd_link_hash_defweak)
2348           && (sym_hash)->root.u.def.section == sec
2349           && (sym_hash)->root.u.def.value >= addr + count
2350           && (sym_hash)->root.u.def.value < toaddr)
2351         {
2352           if ((sym_hash)->root.u.def.value + isym.st_size >= toaddr)
2353             {
2354               isym.st_size += count;
2355               bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2356             }
2357
2358           (sym_hash)->root.u.def.value -= count;
2359         }
2360       else if (isym.st_shndx == sec_shndx
2361                && ((sym_hash)->root.type == bfd_link_hash_defined
2362                    || (sym_hash)->root.type == bfd_link_hash_defweak)
2363                && (sym_hash)->root.u.def.section == sec
2364                && (sym_hash)->root.u.def.value < addr + count)
2365         {
2366           if ((sym_hash)->root.u.def.value+isym.st_size >= addr + count
2367               && (sym_hash)->root.u.def.value+isym.st_size < toaddr)
2368             isym.st_size -= count;
2369
2370           if ((sym_hash)->root.u.def.value >= addr
2371               && (sym_hash)->root.u.def.value < addr + count)
2372             (sym_hash)->root.u.def.value = addr;
2373
2374           bfd_elf32_swap_symbol_out (abfd, & isym, esym, shndx);
2375         }
2376
2377       if (shndx)
2378         ++ shndx;
2379     }
2380
2381   return TRUE;
2382 }
2383
2384 #define NOP_OPCODE      (0x0000)
2385 #define MOVHI           0x0640                          /* 4byte */
2386 #define MOVHI_MASK      0x07e0
2387 #define MOVHI_R1(insn)  ((insn) & 0x1f)                 /* 4byte */
2388 #define MOVHI_R2(insn)  ((insn) >> 11)
2389 #define MOVEA           0x0620                          /* 2byte */
2390 #define MOVEA_MASK      0x07e0
2391 #define MOVEA_R1(insn)  ((insn) & 0x1f)
2392 #define MOVEA_R2(insn)  ((insn) >> 11)
2393 #define JARL_4          0x00040780                              /* 4byte */
2394 #define JARL_4_MASK     0xFFFF07FF
2395 #define JARL_R2(insn)   (int)(((insn) & (~JARL_4_MASK)) >> 11)
2396 #define ADD_I           0x0240                                  /* 2byte */
2397 #define ADD_I_MASK      0x07e0
2398 #define ADD_I5(insn)    ((((insn) & 0x001f) << 11) >> 11)       /* 2byte */
2399 #define ADD_R2(insn)    ((insn) >> 11)
2400 #define JMP_R           0x0060                                  /* 2byte */
2401 #define JMP_R_MASK      0xFFE0
2402 #define JMP_R1(insn)    ((insn) & 0x1f)
2403
2404 static bfd_boolean
2405 v850_elf_relax_section (bfd *abfd,
2406                         asection *sec,
2407                         struct bfd_link_info *link_info,
2408                         bfd_boolean *again)
2409 {
2410   Elf_Internal_Shdr *symtab_hdr;
2411   Elf_Internal_Rela *internal_relocs;
2412   Elf_Internal_Rela *irel;
2413   Elf_Internal_Rela *irelend;
2414   Elf_Internal_Rela *irelalign = NULL;
2415   Elf_Internal_Sym *isymbuf = NULL;
2416   bfd_byte *contents = NULL;
2417   bfd_vma addr = 0;
2418   bfd_vma toaddr;
2419   int align_pad_size = 0;
2420   bfd_boolean result = TRUE;
2421
2422   *again = FALSE;
2423
2424   if (link_info->relocatable
2425       || (sec->flags & SEC_RELOC) == 0
2426       || sec->reloc_count == 0)
2427     return TRUE;
2428
2429   symtab_hdr = & elf_tdata (abfd)->symtab_hdr;
2430
2431   internal_relocs = (_bfd_elf_link_read_relocs
2432                      (abfd, sec, NULL, NULL, link_info->keep_memory));
2433   if (internal_relocs == NULL)
2434     goto error_return;
2435
2436   irelend = internal_relocs + sec->reloc_count;
2437
2438   while (addr < sec->size)
2439     {
2440       toaddr = sec->size;
2441
2442       for (irel = internal_relocs; irel < irelend; irel ++)
2443         if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
2444             && irel->r_offset > addr
2445             && irel->r_offset < toaddr)
2446           toaddr = irel->r_offset;
2447
2448 #ifdef DEBUG_RELAX
2449       fprintf (stderr, "relax region 0x%x to 0x%x align pad %d\n",
2450                addr, toaddr, align_pad_size);
2451 #endif
2452       if (irelalign)
2453         {
2454           bfd_vma alignto;
2455           bfd_vma alignmoveto;
2456
2457           alignmoveto = BFD_ALIGN (addr - align_pad_size, 1 << irelalign->r_addend);
2458           alignto = BFD_ALIGN (addr, 1 << irelalign->r_addend);
2459
2460           if (alignmoveto < alignto)
2461             {
2462               unsigned int i;
2463
2464               align_pad_size = alignto - alignmoveto;
2465 #ifdef DEBUG_RELAX
2466               fprintf (stderr, "relax move region 0x%x to 0x%x delete size 0x%x\n",
2467                        alignmoveto, toaddr, align_pad_size);
2468 #endif
2469               if (!v850_elf_relax_delete_bytes (abfd, sec, alignmoveto,
2470                                                 toaddr, align_pad_size))
2471                 goto error_return;
2472
2473               for (i  = BFD_ALIGN (toaddr - align_pad_size, 1);
2474                    (i + 1) < toaddr; i += 2)
2475                 bfd_put_16 (abfd, NOP_OPCODE, contents + i);
2476
2477               addr = alignmoveto;
2478             }
2479           else
2480             align_pad_size = 0;
2481         }
2482
2483       for (irel = internal_relocs; irel < irelend; irel++)
2484         {
2485           bfd_vma laddr;
2486           bfd_vma addend;
2487           bfd_vma symval;
2488           int insn[5];
2489           int no_match = -1;
2490           Elf_Internal_Rela *hi_irelfn;
2491           Elf_Internal_Rela *lo_irelfn;
2492           Elf_Internal_Rela *irelcall;
2493           bfd_signed_vma foff;
2494
2495           if (! (irel->r_offset >= addr && irel->r_offset < toaddr
2496                  && (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL
2497                      || ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)))
2498             continue;
2499
2500 #ifdef DEBUG_RELAX
2501           fprintf (stderr, "relax check r_info 0x%x r_offset 0x%x r_addend 0x%x\n",
2502                    irel->r_info,
2503                    irel->r_offset,
2504                    irel->r_addend );
2505 #endif
2506
2507           /* Get the section contents.  */
2508           if (contents == NULL)
2509             {
2510               if (elf_section_data (sec)->this_hdr.contents != NULL)
2511                 contents = elf_section_data (sec)->this_hdr.contents;
2512               else
2513                 {
2514                   if (! bfd_malloc_and_get_section (abfd, sec, &contents))
2515                     goto error_return;
2516                 }
2517             }
2518
2519           /* Read this BFD's local symbols if we haven't done so already.  */
2520           if (isymbuf == NULL && symtab_hdr->sh_info != 0)
2521             {
2522               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
2523               if (isymbuf == NULL)
2524                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
2525                                                 symtab_hdr->sh_info, 0,
2526                                                 NULL, NULL, NULL);
2527               if (isymbuf == NULL)
2528                 goto error_return;
2529             }
2530
2531           laddr = irel->r_offset;
2532
2533           if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGCALL)
2534             {
2535               /* Check code for -mlong-calls output. */
2536               if (laddr + 16 <= (bfd_vma) sec->size)
2537                 {
2538                   insn[0] = bfd_get_16 (abfd, contents + laddr);
2539                   insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
2540                   insn[2] = bfd_get_32 (abfd, contents + laddr + 8);
2541                   insn[3] = bfd_get_16 (abfd, contents + laddr + 12);
2542                   insn[4] = bfd_get_16 (abfd, contents + laddr + 14);
2543
2544                   if ((insn[0] & MOVHI_MASK) != MOVHI
2545                        || MOVHI_R1 (insn[0]) != 0)
2546                     no_match = 0;
2547
2548                   if (no_match < 0
2549                       && ((insn[1] & MOVEA_MASK) != MOVEA
2550                            || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
2551                     no_match = 1;
2552
2553                   if (no_match < 0
2554                       && (insn[2] & JARL_4_MASK) != JARL_4)
2555                     no_match = 2;
2556
2557                   if (no_match < 0
2558                       && ((insn[3] & ADD_I_MASK) != ADD_I
2559                            || ADD_I5 (insn[3]) != 4
2560                            || JARL_R2 (insn[2]) != ADD_R2 (insn[3])))
2561                     no_match = 3;
2562
2563                   if (no_match < 0
2564                       && ((insn[4] & JMP_R_MASK) != JMP_R
2565                            || MOVEA_R2 (insn[1]) != JMP_R1 (insn[4])))
2566                     no_match = 4;
2567                 }
2568               else
2569                 {
2570                   ((*_bfd_error_handler)
2571                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insns",
2572                     bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2573
2574                   continue;
2575                 }
2576
2577               if (no_match >= 0)
2578                 {
2579                   ((*_bfd_error_handler)
2580                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized insn 0x%x",
2581                     bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
2582
2583                   continue;
2584                 }
2585
2586               /* Get the reloc for the address from which the register is
2587                  being loaded.  This reloc will tell us which function is
2588                  actually being called.  */
2589               for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
2590                 if (hi_irelfn->r_offset == laddr + 2
2591                     && ELF32_R_TYPE (hi_irelfn->r_info)
2592                         == (int) R_V850_HI16_S)
2593                   break;
2594
2595               for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
2596                 if (lo_irelfn->r_offset == laddr + 6
2597                     && ELF32_R_TYPE (lo_irelfn->r_info)
2598                         == (int) R_V850_LO16)
2599                   break;
2600
2601               for (irelcall = internal_relocs; irelcall < irelend; irelcall ++)
2602                 if (irelcall->r_offset == laddr + 8
2603                     && ELF32_R_TYPE (irelcall->r_info)
2604                         == (int) R_V850_22_PCREL)
2605                   break;
2606
2607               if (   hi_irelfn == irelend
2608                   || lo_irelfn == irelend
2609                   || irelcall  == irelend)
2610                 {
2611                   ((*_bfd_error_handler)
2612                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc",
2613                     bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
2614
2615                   continue;
2616                 }
2617
2618               if (ELF32_R_SYM (irelcall->r_info) < symtab_hdr->sh_info)
2619                 {
2620                   Elf_Internal_Sym *  isym;
2621
2622                   /* A local symbol.  */
2623                   isym = isymbuf + ELF32_R_SYM (irelcall->r_info);
2624
2625                   symval = isym->st_value;
2626                 }
2627               else
2628                 {
2629                   unsigned long indx;
2630                   struct elf_link_hash_entry * h;
2631
2632                   /* An external symbol.  */
2633                   indx = ELF32_R_SYM (irelcall->r_info) - symtab_hdr->sh_info;
2634                   h = elf_sym_hashes (abfd)[indx];
2635                   BFD_ASSERT (h != NULL);
2636
2637                   if (   h->root.type != bfd_link_hash_defined
2638                       && h->root.type != bfd_link_hash_defweak)
2639                     /* This appears to be a reference to an undefined
2640                        symbol.  Just ignore it--it will be caught by the
2641                        regular reloc processing.  */
2642                     continue;
2643
2644                   symval = h->root.u.def.value;
2645                 }
2646
2647               if (symval + irelcall->r_addend != irelcall->r_offset + 4)
2648                 {
2649                   ((*_bfd_error_handler)
2650                    ("%s: 0x%lx: warning: R_V850_LONGCALL points to unrecognized reloc 0x%lx",
2651                     bfd_get_filename (abfd), (unsigned long) irel->r_offset, irelcall->r_offset ));
2652
2653                   continue;
2654                 }
2655
2656               /* Get the value of the symbol referred to by the reloc.  */
2657               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2658                 {
2659                   Elf_Internal_Sym *isym;
2660                   asection *sym_sec;
2661
2662                   /* A local symbol.  */
2663                   isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
2664
2665                   if (isym->st_shndx == SHN_UNDEF)
2666                     sym_sec = bfd_und_section_ptr;
2667                   else if (isym->st_shndx == SHN_ABS)
2668                     sym_sec = bfd_abs_section_ptr;
2669                   else if (isym->st_shndx == SHN_COMMON)
2670                     sym_sec = bfd_com_section_ptr;
2671                   else
2672                     sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2673                   symval = (isym->st_value
2674                             + sym_sec->output_section->vma
2675                             + sym_sec->output_offset);
2676                 }
2677               else
2678                 {
2679                   unsigned long indx;
2680                   struct elf_link_hash_entry *h;
2681
2682                   /* An external symbol.  */
2683                   indx = ELF32_R_SYM (hi_irelfn->r_info) - symtab_hdr->sh_info;
2684                   h = elf_sym_hashes (abfd)[indx];
2685                   BFD_ASSERT (h != NULL);
2686
2687                   if (   h->root.type != bfd_link_hash_defined
2688                       && h->root.type != bfd_link_hash_defweak)
2689                     /* This appears to be a reference to an undefined
2690                        symbol.  Just ignore it--it will be caught by the
2691                        regular reloc processing.  */
2692                     continue;
2693
2694                   symval = (h->root.u.def.value
2695                             + h->root.u.def.section->output_section->vma
2696                             + h->root.u.def.section->output_offset);
2697                 }
2698
2699               addend = irel->r_addend;
2700
2701               foff = (symval + addend
2702                       - (irel->r_offset
2703                          + sec->output_section->vma
2704                          + sec->output_offset
2705                          + 4));
2706 #ifdef DEBUG_RELAX
2707               fprintf (stderr, "relax longcall r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
2708                        irel->r_offset,
2709                        (irel->r_offset
2710                         + sec->output_section->vma
2711                         + sec->output_offset),
2712                        symval, addend, foff);
2713 #endif
2714
2715               if (foff < -0x100000 || foff >= 0x100000)
2716                 /* After all that work, we can't shorten this function call.  */
2717                 continue;
2718
2719               /* For simplicity of coding, we are going to modify the section
2720                  contents, the section relocs, and the BFD symbol table.  We
2721                  must tell the rest of the code not to free up this
2722                  information.  It would be possible to instead create a table
2723                  of changes which have to be made, as is done in coff-mips.c;
2724                  that would be more work, but would require less memory when
2725                  the linker is run.  */
2726               elf_section_data (sec)->relocs = internal_relocs;
2727               elf_section_data (sec)->this_hdr.contents = contents;
2728               symtab_hdr->contents = (bfd_byte *) isymbuf;
2729
2730               /* Replace the long call with a jarl.  */
2731               irel->r_info = ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_22_PCREL);
2732
2733               addend = 0;
2734
2735               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2736                 /* If this needs to be changed because of future relaxing,
2737                    it will be handled here like other internal IND12W
2738                    relocs.  */
2739                 bfd_put_32 (abfd,
2740                             0x00000780 | (JARL_R2 (insn[2])<<11) | ((addend << 16) & 0xffff) | ((addend >> 16) & 0xf),
2741                             contents + irel->r_offset);
2742               else
2743                 /* We can't fully resolve this yet, because the external
2744                    symbol value may be changed by future relaxing.
2745                    We let the final link phase handle it.  */
2746                 bfd_put_32 (abfd, 0x00000780 | (JARL_R2 (insn[2])<<11),
2747                             contents + irel->r_offset);
2748
2749               hi_irelfn->r_info =
2750                 ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
2751               lo_irelfn->r_info =
2752                 ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
2753               irelcall->r_info =
2754                 ELF32_R_INFO (ELF32_R_SYM (irelcall->r_info), R_V850_NONE);
2755
2756               if (! v850_elf_relax_delete_bytes (abfd, sec,
2757                                                  irel->r_offset + 4, toaddr, 12))
2758                 goto error_return;
2759
2760               align_pad_size += 12;
2761             }
2762           else if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_LONGJUMP)
2763             {
2764               /* Check code for -mlong-jumps output.  */
2765               if (laddr + 10 <= (bfd_vma) sec->size)
2766                 {
2767                   insn[0] = bfd_get_16 (abfd, contents + laddr);
2768                   insn[1] = bfd_get_16 (abfd, contents + laddr + 4);
2769                   insn[2] = bfd_get_16 (abfd, contents + laddr + 8);
2770
2771                   if ((insn[0] & MOVHI_MASK) != MOVHI
2772                        || MOVHI_R1 (insn[0]) != 0)
2773                     no_match = 0;
2774
2775                   if (no_match < 0
2776                       && ((insn[1] & MOVEA_MASK) != MOVEA
2777                            || MOVHI_R2 (insn[0]) != MOVEA_R1 (insn[1])))
2778                     no_match = 1;
2779
2780                   if (no_match < 0
2781                       && ((insn[2] & JMP_R_MASK) != JMP_R
2782                            || MOVEA_R2 (insn[1]) != JMP_R1 (insn[2])))
2783                     no_match = 4;
2784                 }
2785               else
2786                 {
2787                   ((*_bfd_error_handler)
2788                    ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insns",
2789                     bfd_get_filename (abfd), (unsigned long) irel->r_offset));
2790
2791                   continue;
2792                 }
2793
2794               if (no_match >= 0)
2795                 {
2796                   ((*_bfd_error_handler)
2797                    ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized insn 0x%x",
2798                     bfd_get_filename (abfd), (unsigned long) irel->r_offset+no_match, insn[no_match]));
2799
2800                   continue;
2801                 }
2802
2803               /* Get the reloc for the address from which the register is
2804                  being loaded.  This reloc will tell us which function is
2805                  actually being called.  */
2806               for (hi_irelfn = internal_relocs; hi_irelfn < irelend; hi_irelfn ++)
2807                 if (hi_irelfn->r_offset == laddr + 2
2808                     && ELF32_R_TYPE (hi_irelfn->r_info) == (int) R_V850_HI16_S)
2809                   break;
2810
2811               for (lo_irelfn = internal_relocs; lo_irelfn < irelend; lo_irelfn ++)
2812                 if (lo_irelfn->r_offset == laddr + 6
2813                     && ELF32_R_TYPE (lo_irelfn->r_info) == (int) R_V850_LO16)
2814                   break;
2815
2816               if (   hi_irelfn == irelend
2817                   || lo_irelfn == irelend)
2818                 {
2819                   ((*_bfd_error_handler)
2820                    ("%s: 0x%lx: warning: R_V850_LONGJUMP points to unrecognized reloc",
2821                     bfd_get_filename (abfd), (unsigned long) irel->r_offset ));
2822
2823                   continue;
2824                 }
2825
2826               /* Get the value of the symbol referred to by the reloc.  */
2827               if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2828                 {
2829                   Elf_Internal_Sym *  isym;
2830                   asection *          sym_sec;
2831
2832                   /* A local symbol.  */
2833                   isym = isymbuf + ELF32_R_SYM (hi_irelfn->r_info);
2834
2835                   if (isym->st_shndx == SHN_UNDEF)
2836                     sym_sec = bfd_und_section_ptr;
2837                   else if (isym->st_shndx == SHN_ABS)
2838                     sym_sec = bfd_abs_section_ptr;
2839                   else if (isym->st_shndx == SHN_COMMON)
2840                     sym_sec = bfd_com_section_ptr;
2841                   else
2842                     sym_sec = bfd_section_from_elf_index (abfd, isym->st_shndx);
2843                   symval = (isym->st_value
2844                             + sym_sec->output_section->vma
2845                             + sym_sec->output_offset);
2846 #ifdef DEBUG_RELAX
2847                   {
2848                     char * name = bfd_elf_string_from_elf_section
2849                       (abfd, symtab_hdr->sh_link, isym->st_name);
2850
2851                     fprintf (stderr, "relax long jump local: sec: %s, sym: %s (%d), value: %x + %x + %x addend %x\n",
2852                              sym_sec->name, name, isym->st_name,
2853                              sym_sec->output_section->vma,
2854                              sym_sec->output_offset,
2855                              isym->st_value, irel->r_addend);
2856                   }
2857 #endif
2858                 }
2859               else
2860                 {
2861                   unsigned long indx;
2862                   struct elf_link_hash_entry * h;
2863
2864                   /* An external symbol.  */
2865                   indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
2866                   h = elf_sym_hashes (abfd)[indx];
2867                   BFD_ASSERT (h != NULL);
2868
2869                   if (   h->root.type != bfd_link_hash_defined
2870                       && h->root.type != bfd_link_hash_defweak)
2871                     /* This appears to be a reference to an undefined
2872                        symbol.  Just ignore it--it will be caught by the
2873                        regular reloc processing.  */
2874                     continue;
2875
2876                   symval = (h->root.u.def.value
2877                             + h->root.u.def.section->output_section->vma
2878                             + h->root.u.def.section->output_offset);
2879 #ifdef DEBUG_RELAX
2880                   fprintf (stderr,
2881                            "relax longjump defined: sec: %s, name: %s, value: %x + %x + %x addend %x\n",
2882                            sec->name, h->root.root.string, h->root.u.def.value,
2883                            sec->output_section->vma, sec->output_offset, irel->r_addend);
2884 #endif
2885                 }
2886
2887               addend = irel->r_addend;
2888
2889               foff = (symval + addend
2890                       - (irel->r_offset
2891                          + sec->output_section->vma
2892                          + sec->output_offset
2893                          + 4));
2894 #ifdef DEBUG_RELAX
2895               fprintf (stderr, "relax longjump r_offset 0x%x ptr 0x%x symbol 0x%x addend 0x%x distance 0x%x\n",
2896                        irel->r_offset,
2897                        (irel->r_offset
2898                         + sec->output_section->vma
2899                         + sec->output_offset),
2900                        symval, addend, foff);
2901 #endif
2902               if (foff < -0x100000 || foff >= 0x100000)
2903                 /* After all that work, we can't shorten this function call.  */
2904                 continue;
2905
2906               /* For simplicity of coding, we are going to modify the section
2907                  contents, the section relocs, and the BFD symbol table.  We
2908                  must tell the rest of the code not to free up this
2909                  information.  It would be possible to instead create a table
2910                  of changes which have to be made, as is done in coff-mips.c;
2911                  that would be more work, but would require less memory when
2912                  the linker is run.  */
2913               elf_section_data (sec)->relocs = internal_relocs;
2914               elf_section_data (sec)->this_hdr.contents = contents;
2915               symtab_hdr->contents = (bfd_byte *) isymbuf;
2916
2917               if (foff < -0x100 || foff >= 0x100)
2918                 {
2919                   /* Replace the long jump with a jr.  */
2920
2921                   irel->r_info =
2922                     ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_22_PCREL);
2923
2924                   irel->r_addend = addend;
2925                   addend = 0;
2926
2927                   if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2928                     /* If this needs to be changed because of future relaxing,
2929                        it will be handled here like other internal IND12W
2930                        relocs.  */
2931                     bfd_put_32 (abfd,
2932                                 0x00000780 | ((addend << 15) & 0xffff0000) | ((addend >> 17) & 0xf),
2933                                 contents + irel->r_offset);
2934                   else
2935                     /* We can't fully resolve this yet, because the external
2936                        symbol value may be changed by future relaxing.
2937                        We let the final link phase handle it.  */
2938                     bfd_put_32 (abfd, 0x00000780, contents + irel->r_offset);
2939
2940                   hi_irelfn->r_info =
2941                         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
2942                   lo_irelfn->r_info =
2943                         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
2944                   if (!v850_elf_relax_delete_bytes (abfd, sec,
2945                                                     irel->r_offset + 4, toaddr, 6))
2946                     goto error_return;
2947
2948                   align_pad_size += 6;
2949                 }
2950               else
2951                 {
2952                   /* Replace the long jump with a br.  */
2953
2954                   irel->r_info =
2955                         ELF32_R_INFO (ELF32_R_SYM (irel->r_info), R_V850_9_PCREL);
2956
2957                   irel->r_addend = addend;
2958                   addend = 0;
2959
2960                   if (ELF32_R_SYM (hi_irelfn->r_info) < symtab_hdr->sh_info)
2961                     /* If this needs to be changed because of future relaxing,
2962                        it will be handled here like other internal IND12W
2963                        relocs.  */
2964                     bfd_put_16 (abfd,
2965                                 0x0585 | ((addend << 10) & 0xf800) | ((addend << 3) & 0x0070),
2966                                 contents + irel->r_offset);
2967                   else
2968                     /* We can't fully resolve this yet, because the external
2969                        symbol value may be changed by future relaxing.
2970                        We let the final link phase handle it.  */
2971                     bfd_put_16 (abfd, 0x0585, contents + irel->r_offset);
2972
2973                   hi_irelfn->r_info =
2974                         ELF32_R_INFO (ELF32_R_SYM (hi_irelfn->r_info), R_V850_NONE);
2975                   lo_irelfn->r_info =
2976                         ELF32_R_INFO (ELF32_R_SYM (lo_irelfn->r_info), R_V850_NONE);
2977                   if (!v850_elf_relax_delete_bytes (abfd, sec,
2978                                                     irel->r_offset + 2, toaddr, 8))
2979                     goto error_return;
2980
2981                   align_pad_size += 8;
2982                 }
2983             }
2984         }
2985
2986       irelalign = NULL;
2987       for (irel = internal_relocs; irel < irelend; irel++)
2988         {
2989           if (ELF32_R_TYPE (irel->r_info) == (int) R_V850_ALIGN
2990               && irel->r_offset == toaddr)
2991             {
2992               irel->r_offset -= align_pad_size;
2993
2994               if (irelalign == NULL || irelalign->r_addend > irel->r_addend)
2995                 irelalign = irel;
2996             }
2997         }
2998
2999       addr = toaddr;
3000     }
3001
3002   if (!irelalign)
3003     {
3004 #ifdef DEBUG_RELAX
3005       fprintf (stderr, "relax pad %d shorten %d -> %d\n",
3006                align_pad_size,
3007                sec->size,
3008                sec->size - align_pad_size);
3009 #endif
3010       sec->size -= align_pad_size;
3011     }
3012
3013  finish:
3014   if (internal_relocs != NULL
3015       && elf_section_data (sec)->relocs != internal_relocs)
3016     free (internal_relocs);
3017
3018   if (contents != NULL
3019       && elf_section_data (sec)->this_hdr.contents != (unsigned char *) contents)
3020     free (contents);
3021
3022   if (isymbuf != NULL
3023       && symtab_hdr->contents != (bfd_byte *) isymbuf)
3024     free (isymbuf);
3025
3026   return result;
3027
3028  error_return:
3029   result = FALSE;
3030   goto finish;
3031 }
3032
3033 static const struct bfd_elf_special_section v850_elf_special_sections[] =
3034 {
3035   { STRING_COMMA_LEN (".call_table_data"), 0, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE) },
3036   { STRING_COMMA_LEN (".call_table_text"), 0, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3037                                                                  + SHF_EXECINSTR) },
3038   { STRING_COMMA_LEN (".rosdata"),        -2, SHT_PROGBITS,     (SHF_ALLOC
3039                                                                  + SHF_V850_GPREL) },
3040   { STRING_COMMA_LEN (".rozdata"),        -2, SHT_PROGBITS,     (SHF_ALLOC
3041                                                                  + SHF_V850_R0REL) },
3042   { STRING_COMMA_LEN (".sbss"),           -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
3043                                                                  + SHF_V850_GPREL) },
3044   { STRING_COMMA_LEN (".scommon"),        -2, SHT_V850_SCOMMON, (SHF_ALLOC + SHF_WRITE
3045                                                                  + SHF_V850_GPREL) },
3046   { STRING_COMMA_LEN (".sdata"),          -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3047                                                                  + SHF_V850_GPREL) },
3048   { STRING_COMMA_LEN (".tbss"),           -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
3049                                                                  + SHF_V850_EPREL) },
3050   { STRING_COMMA_LEN (".tcommon"),        -2, SHT_V850_TCOMMON, (SHF_ALLOC + SHF_WRITE
3051                                                                  + SHF_V850_R0REL) },
3052   { STRING_COMMA_LEN (".tdata"),          -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3053                                                                  + SHF_V850_EPREL) },
3054   { STRING_COMMA_LEN (".zbss"),           -2, SHT_NOBITS,       (SHF_ALLOC + SHF_WRITE
3055                                                                  + SHF_V850_R0REL) },
3056   { STRING_COMMA_LEN (".zcommon"),        -2, SHT_V850_ZCOMMON, (SHF_ALLOC + SHF_WRITE
3057                                                                  + SHF_V850_R0REL) },
3058   { STRING_COMMA_LEN (".zdata"),          -2, SHT_PROGBITS,     (SHF_ALLOC + SHF_WRITE
3059                                                                  + SHF_V850_R0REL) },
3060   { NULL,                     0,           0, 0,                0 }
3061 };
3062 \f
3063 #define TARGET_LITTLE_SYM                       bfd_elf32_v850_vec
3064 #define TARGET_LITTLE_NAME                      "elf32-v850"
3065 #define ELF_ARCH                                bfd_arch_v850
3066 #define ELF_MACHINE_CODE                        EM_V850
3067 #define ELF_MACHINE_ALT1                        EM_CYGNUS_V850
3068 #define ELF_MACHINE_ALT2                        EM_V800 /* This is the value used by the GreenHills toolchain.  */
3069 #define ELF_MAXPAGESIZE                         0x1000
3070
3071 #define elf_info_to_howto                       v850_elf_info_to_howto_rela
3072 #define elf_info_to_howto_rel                   v850_elf_info_to_howto_rel
3073
3074 #define elf_backend_check_relocs                v850_elf_check_relocs
3075 #define elf_backend_relocate_section            v850_elf_relocate_section
3076 #define elf_backend_object_p                    v850_elf_object_p
3077 #define elf_backend_final_write_processing      v850_elf_final_write_processing
3078 #define elf_backend_section_from_bfd_section    v850_elf_section_from_bfd_section
3079 #define elf_backend_symbol_processing           v850_elf_symbol_processing
3080 #define elf_backend_add_symbol_hook             v850_elf_add_symbol_hook
3081 #define elf_backend_link_output_symbol_hook     v850_elf_link_output_symbol_hook
3082 #define elf_backend_section_from_shdr           v850_elf_section_from_shdr
3083 #define elf_backend_fake_sections               v850_elf_fake_sections
3084 #define elf_backend_gc_mark_hook                v850_elf_gc_mark_hook
3085 #define elf_backend_special_sections            v850_elf_special_sections
3086
3087 #define elf_backend_can_gc_sections 1
3088 #define elf_backend_rela_normal 1
3089
3090 #define bfd_elf32_bfd_is_local_label_name       v850_elf_is_local_label_name
3091 #define bfd_elf32_bfd_reloc_type_lookup         v850_elf_reloc_type_lookup
3092 #define bfd_elf32_bfd_reloc_name_lookup v850_elf_reloc_name_lookup
3093 #define bfd_elf32_bfd_merge_private_bfd_data    v850_elf_merge_private_bfd_data
3094 #define bfd_elf32_bfd_set_private_flags         v850_elf_set_private_flags
3095 #define bfd_elf32_bfd_print_private_bfd_data    v850_elf_print_private_bfd_data
3096 #define bfd_elf32_bfd_relax_section             v850_elf_relax_section
3097
3098 #define elf_symbol_leading_char                 '_'
3099
3100 #include "elf32-target.h"