bfd/elf32-v850.c

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