bfd/elf32-v850.c

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