bfd/elf32-v850.c

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