bfd/elf32-v850.c

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