bfd/elf32-v850.c

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