bfd/elf32-frv.c

   1 /* FRV-specific support for 32-bit ELF.
   2    Copyright 2002, 2003, 2004 Free Software Foundation, Inc.
   3
   4 This file is part of BFD, the Binary File Descriptor library.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "bfd.h"
  21 #include "sysdep.h"
  22 #include "libbfd.h"
  23 #include "elf-bfd.h"
  24 #include "elf/frv.h"
  25 #include "elf/dwarf2.h"
  26 #include "hashtab.h"
  27
  28 /* Forward declarations.  */
  29 static bfd_reloc_status_type elf32_frv_relocate_lo16
  30   PARAMS ((bfd *,  Elf_Internal_Rela *, bfd_byte *, bfd_vma));
  31 static bfd_reloc_status_type elf32_frv_relocate_hi16
  32   PARAMS ((bfd *,  Elf_Internal_Rela *, bfd_byte *, bfd_vma));
  33 static bfd_reloc_status_type elf32_frv_relocate_label24
  34   PARAMS ((bfd *, asection *, Elf_Internal_Rela *, bfd_byte *, bfd_vma));
  35 static bfd_reloc_status_type elf32_frv_relocate_gprel12
  36   PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
  37            bfd_byte *, bfd_vma));
  38 static bfd_reloc_status_type elf32_frv_relocate_gprelu12
  39   PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
  40            bfd_byte *, bfd_vma));
  41 static bfd_reloc_status_type elf32_frv_relocate_gprello
  42   PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
  43            bfd_byte *, bfd_vma));
  44 static bfd_reloc_status_type elf32_frv_relocate_gprelhi
  45   PARAMS ((struct bfd_link_info *, bfd *, asection *, Elf_Internal_Rela *,
  46            bfd_byte *, bfd_vma));
  47 static reloc_howto_type *frv_reloc_type_lookup
  48   PARAMS ((bfd *, bfd_reloc_code_real_type));
  49 static void frv_info_to_howto_rela
  50   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  51 static bfd_boolean elf32_frv_relocate_section
  52   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  53            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  54 static bfd_boolean elf32_frv_add_symbol_hook
  55   PARAMS (( bfd *, struct bfd_link_info *, Elf_Internal_Sym *,
  56             const char **, flagword *, asection **, bfd_vma *));
  57 static bfd_reloc_status_type frv_final_link_relocate
  58   PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
  59            Elf_Internal_Rela *, bfd_vma));
  60 static bfd_boolean elf32_frv_gc_sweep_hook
  61   PARAMS ((bfd *, struct bfd_link_info *, asection *, const
  62            Elf_Internal_Rela *));
  63 static asection * elf32_frv_gc_mark_hook
  64   PARAMS ((asection *, struct bfd_link_info *, Elf_Internal_Rela *,
  65            struct elf_link_hash_entry *, Elf_Internal_Sym *));
  66 static bfd_boolean elf32_frv_check_relocs
  67   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  68            const Elf_Internal_Rela *));
  69 static int elf32_frv_machine
  70   PARAMS ((bfd *));
  71 static bfd_boolean elf32_frv_object_p
  72   PARAMS ((bfd *));
  73 static bfd_boolean frv_elf_set_private_flags
  74   PARAMS ((bfd *, flagword));
  75 static bfd_boolean frv_elf_copy_private_bfd_data
  76   PARAMS ((bfd *, bfd *));
  77 static bfd_boolean frv_elf_merge_private_bfd_data
  78   PARAMS ((bfd *, bfd *));
  79 static bfd_boolean frv_elf_print_private_bfd_data
  80   PARAMS ((bfd *, PTR));
  81
  82 static reloc_howto_type elf32_frv_howto_table [] =
  83 {
  84   /* This reloc does nothing.  */
  85   HOWTO (R_FRV_NONE,            /* type */
  86          0,                     /* rightshift */
  87          2,                     /* size (0 = byte, 1 = short, 2 = long) */
  88          32,                    /* bitsize */
  89          FALSE,                 /* pc_relative */
  90          0,                     /* bitpos */
  91          complain_overflow_bitfield, /* complain_on_overflow */
  92          bfd_elf_generic_reloc, /* special_function */
  93          "R_FRV_NONE",          /* name */
  94          FALSE,                 /* partial_inplace */
  95          0,                     /* src_mask */
  96          0,                     /* dst_mask */
  97          FALSE),                /* pcrel_offset */
  98
  99   /* A 32 bit absolute relocation.  */
 100   HOWTO (R_FRV_32,              /* type */
 101          0,                     /* rightshift */
 102          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 103          32,                    /* bitsize */
 104          FALSE,                 /* pc_relative */
 105          0,                     /* bitpos */
 106          complain_overflow_bitfield, /* complain_on_overflow */
 107          bfd_elf_generic_reloc, /* special_function */
 108          "R_FRV_32",            /* name */
 109          FALSE,                 /* partial_inplace */
 110          0xffffffff,            /* src_mask */
 111          0xffffffff,            /* dst_mask */
 112          FALSE),                /* pcrel_offset */
 113
 114   /* A 16 bit pc-relative relocation.  */
 115   HOWTO (R_FRV_LABEL16,         /* type */
 116          2,                     /* rightshift */
 117          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 118          16,                    /* bitsize */
 119          TRUE,                  /* pc_relative */
 120          0,                     /* bitpos */
 121          complain_overflow_signed, /* complain_on_overflow */
 122          bfd_elf_generic_reloc, /* special_function */
 123          "R_FRV_LABEL16",       /* name */
 124          FALSE,                 /* partial_inplace */
 125          0xffff,                /* src_mask */
 126          0xffff,                /* dst_mask */
 127          TRUE),                 /* pcrel_offset */
 128
 129   /* A 24-bit pc-relative relocation.  */
 130   HOWTO (R_FRV_LABEL24, /* type */
 131          2,                     /* rightshift */
 132          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 133          26,                    /* bitsize */
 134          TRUE,                  /* pc_relative */
 135          0,                     /* bitpos */
 136          complain_overflow_bitfield, /* complain_on_overflow */
 137          bfd_elf_generic_reloc, /* special_function */
 138          "R_FRV_LABEL24",       /* name */
 139          FALSE,                 /* partial_inplace */
 140          0x7e03ffff,            /* src_mask */
 141          0x7e03ffff,            /* dst_mask */
 142          TRUE),                 /* pcrel_offset */
 143
 144   HOWTO (R_FRV_LO16,            /* type */
 145          0,                     /* rightshift */
 146          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 147          16,                    /* bitsize */
 148          FALSE,                 /* pc_relative */
 149          0,                     /* bitpos */
 150          complain_overflow_dont, /* complain_on_overflow */
 151          bfd_elf_generic_reloc, /* special_function */
 152          "R_FRV_LO16",          /* name */
 153          FALSE,                 /* partial_inplace */
 154          0xffff,                /* src_mask */
 155          0xffff,                /* dst_mask */
 156          FALSE),                /* pcrel_offset */
 157
 158   HOWTO (R_FRV_HI16,            /* type */
 159          0,                     /* rightshift */
 160          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 161          16,                    /* bitsize */
 162          FALSE,                 /* pc_relative */
 163          0,                     /* bitpos */
 164          complain_overflow_dont, /* complain_on_overflow */
 165          bfd_elf_generic_reloc, /* special_function */
 166          "R_FRV_HI16",          /* name */
 167          FALSE,                 /* partial_inplace */
 168          0xffff,                /* src_mask */
 169          0xffff,                /* dst_mask */
 170          FALSE),                /* pcrel_offset */
 171
 172   HOWTO (R_FRV_GPREL12,         /* type */
 173          0,                     /* rightshift */
 174          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 175          12,                    /* bitsize */
 176          FALSE,                 /* pc_relative */
 177          0,                     /* bitpos */
 178          complain_overflow_dont, /* complain_on_overflow */
 179          bfd_elf_generic_reloc, /* special_function */
 180          "R_FRV_GPREL12",       /* name */
 181          FALSE,                 /* partial_inplace */
 182          0xfff,                 /* src_mask */
 183          0xfff,                 /* dst_mask */
 184          FALSE),                /* pcrel_offset */
 185
 186   HOWTO (R_FRV_GPRELU12,        /* type */
 187          0,                     /* rightshift */
 188          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 189          12,                    /* bitsize */
 190          FALSE,                 /* pc_relative */
 191          0,                     /* bitpos */
 192          complain_overflow_dont, /* complain_on_overflow */
 193          bfd_elf_generic_reloc, /* special_function */
 194          "R_FRV_GPRELU12",      /* name */
 195          FALSE,                 /* partial_inplace */
 196          0xfff,                 /* src_mask */
 197          0x3f03f,               /* dst_mask */
 198          FALSE),                /* pcrel_offset */
 199
 200   HOWTO (R_FRV_GPREL32,         /* type */
 201          0,                     /* rightshift */
 202          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 203          32,                    /* bitsize */
 204          FALSE,                 /* pc_relative */
 205          0,                     /* bitpos */
 206          complain_overflow_dont, /* complain_on_overflow */
 207          bfd_elf_generic_reloc, /* special_function */
 208          "R_FRV_GPREL32",       /* name */
 209          FALSE,                 /* partial_inplace */
 210          0xffffffff,            /* src_mask */
 211          0xffffffff,            /* dst_mask */
 212          FALSE),                /* pcrel_offset */
 213
 214   HOWTO (R_FRV_GPRELHI,         /* type */
 215          0,                     /* rightshift */
 216          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 217          16,                    /* bitsize */
 218          FALSE,                 /* pc_relative */
 219          0,                     /* bitpos */
 220          complain_overflow_dont, /* complain_on_overflow */
 221          bfd_elf_generic_reloc, /* special_function */
 222          "R_FRV_GPRELHI",       /* name */
 223          FALSE,                 /* partial_inplace */
 224          0xffff,                        /* src_mask */
 225          0xffff,                /* dst_mask */
 226          FALSE),                /* pcrel_offset */
 227
 228   HOWTO (R_FRV_GPRELLO,         /* type */
 229          0,                     /* rightshift */
 230          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 231          16,                    /* bitsize */
 232          FALSE,                 /* pc_relative */
 233          0,                     /* bitpos */
 234          complain_overflow_dont, /* complain_on_overflow */
 235          bfd_elf_generic_reloc, /* special_function */
 236          "R_FRV_GPRELLO",       /* name */
 237          FALSE,                 /* partial_inplace */
 238          0xffff,                        /* src_mask */
 239          0xffff,                /* dst_mask */
 240          FALSE),                /* pcrel_offset */
 241
 242   /* A 12-bit signed operand with the GOT offset for the address of
 243      the symbol.  */
 244   HOWTO (R_FRV_GOT12,           /* type */
 245          0,                     /* rightshift */
 246          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 247          12,                    /* bitsize */
 248          FALSE,                 /* pc_relative */
 249          0,                     /* bitpos */
 250          complain_overflow_signed, /* complain_on_overflow */
 251          bfd_elf_generic_reloc, /* special_function */
 252          "R_FRV_GOT12",         /* name */
 253          FALSE,                 /* partial_inplace */
 254          0xfff,                 /* src_mask */
 255          0xfff,                 /* dst_mask */
 256          FALSE),                /* pcrel_offset */
 257
 258   /* The upper 16 bits of the GOT offset for the address of the
 259      symbol.  */
 260   HOWTO (R_FRV_GOTHI,           /* type */
 261          0,                     /* rightshift */
 262          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 263          16,                    /* bitsize */
 264          FALSE,                 /* pc_relative */
 265          0,                     /* bitpos */
 266          complain_overflow_dont, /* complain_on_overflow */
 267          bfd_elf_generic_reloc, /* special_function */
 268          "R_FRV_GOTHI",         /* name */
 269          FALSE,                 /* partial_inplace */
 270          0xffff,                        /* src_mask */
 271          0xffff,                /* dst_mask */
 272          FALSE),                /* pcrel_offset */
 273
 274   /* The lower 16 bits of the GOT offset for the address of the
 275      symbol.  */
 276   HOWTO (R_FRV_GOTLO,           /* type */
 277          0,                     /* rightshift */
 278          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          16,                    /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_dont, /* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_FRV_GOTLO",         /* name */
 285          FALSE,                 /* partial_inplace */
 286          0xffff,                /* src_mask */
 287          0xffff,                /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290   /* The 32-bit address of the canonical descriptor of a function.  */
 291   HOWTO (R_FRV_FUNCDESC,        /* type */
 292          0,                     /* rightshift */
 293          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 294          32,                    /* bitsize */
 295          FALSE,                 /* pc_relative */
 296          0,                     /* bitpos */
 297          complain_overflow_bitfield, /* complain_on_overflow */
 298          bfd_elf_generic_reloc, /* special_function */
 299          "R_FRV_FUNCDESC",      /* name */
 300          FALSE,                 /* partial_inplace */
 301          0xffffffff,            /* src_mask */
 302          0xffffffff,            /* dst_mask */
 303          FALSE),                /* pcrel_offset */
 304
 305   /* A 12-bit signed operand with the GOT offset for the address of
 306      canonical descriptor of a function.  */
 307   HOWTO (R_FRV_FUNCDESC_GOT12,  /* type */
 308          0,                     /* rightshift */
 309          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 310          12,                    /* bitsize */
 311          FALSE,                 /* pc_relative */
 312          0,                     /* bitpos */
 313          complain_overflow_signed, /* complain_on_overflow */
 314          bfd_elf_generic_reloc, /* special_function */
 315          "R_FRV_FUNCDESC_GOT12", /* name */
 316          FALSE,                 /* partial_inplace */
 317          0xfff,                 /* src_mask */
 318          0xfff,                 /* dst_mask */
 319          FALSE),                /* pcrel_offset */
 320
 321   /* The upper 16 bits of the GOT offset for the address of the
 322      canonical descriptor of a function.  */
 323   HOWTO (R_FRV_FUNCDESC_GOTHI,  /* type */
 324          0,                     /* rightshift */
 325          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 326          16,                    /* bitsize */
 327          FALSE,                 /* pc_relative */
 328          0,                     /* bitpos */
 329          complain_overflow_dont, /* complain_on_overflow */
 330          bfd_elf_generic_reloc, /* special_function */
 331          "R_FRV_FUNCDESC_GOTHI", /* name */
 332          FALSE,                 /* partial_inplace */
 333          0xffff,                /* src_mask */
 334          0xffff,                /* dst_mask */
 335          FALSE),                /* pcrel_offset */
 336
 337   /* The lower 16 bits of the GOT offset for the address of the
 338      canonical descriptor of a function.  */
 339   HOWTO (R_FRV_FUNCDESC_GOTLO,  /* type */
 340          0,                     /* rightshift */
 341          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 342          16,                    /* bitsize */
 343          FALSE,                 /* pc_relative */
 344          0,                     /* bitpos */
 345          complain_overflow_dont, /* complain_on_overflow */
 346          bfd_elf_generic_reloc, /* special_function */
 347          "R_FRV_FUNCDESC_GOTLO", /* name */
 348          FALSE,                 /* partial_inplace */
 349          0xffff,                /* src_mask */
 350          0xffff,                /* dst_mask */
 351          FALSE),                /* pcrel_offset */
 352
 353   /* The 32-bit address of the canonical descriptor of a function.  */
 354   HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
 355          0,                     /* rightshift */
 356          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 357          64,                    /* bitsize */
 358          FALSE,                 /* pc_relative */
 359          0,                     /* bitpos */
 360          complain_overflow_bitfield, /* complain_on_overflow */
 361          bfd_elf_generic_reloc, /* special_function */
 362          "R_FRV_FUNCDESC_VALUE", /* name */
 363          FALSE,                 /* partial_inplace */
 364          0xffffffff,            /* src_mask */
 365          0xffffffff,            /* dst_mask */
 366          FALSE),                /* pcrel_offset */
 367
 368   /* A 12-bit signed operand with the GOT offset for the address of
 369      canonical descriptor of a function.  */
 370   HOWTO (R_FRV_FUNCDESC_GOTOFF12, /* type */
 371          0,                     /* rightshift */
 372          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 373          12,                    /* bitsize */
 374          FALSE,                 /* pc_relative */
 375          0,                     /* bitpos */
 376          complain_overflow_signed, /* complain_on_overflow */
 377          bfd_elf_generic_reloc, /* special_function */
 378          "R_FRV_FUNCDESC_GOTOFF12", /* name */
 379          FALSE,                 /* partial_inplace */
 380          0xfff,                 /* src_mask */
 381          0xfff,                 /* dst_mask */
 382          FALSE),                /* pcrel_offset */
 383
 384   /* The upper 16 bits of the GOT offset for the address of the
 385      canonical descriptor of a function.  */
 386   HOWTO (R_FRV_FUNCDESC_GOTOFFHI, /* type */
 387          0,                     /* rightshift */
 388          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 389          16,                    /* bitsize */
 390          FALSE,                 /* pc_relative */
 391          0,                     /* bitpos */
 392          complain_overflow_dont, /* complain_on_overflow */
 393          bfd_elf_generic_reloc, /* special_function */
 394          "R_FRV_FUNCDESC_GOTOFFHI", /* name */
 395          FALSE,                 /* partial_inplace */
 396          0xffff,                /* src_mask */
 397          0xffff,                /* dst_mask */
 398          FALSE),                /* pcrel_offset */
 399
 400   /* The lower 16 bits of the GOT offset for the address of the
 401      canonical descriptor of a function.  */
 402   HOWTO (R_FRV_FUNCDESC_GOTOFFLO, /* 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          bfd_elf_generic_reloc, /* special_function */
 410          "R_FRV_FUNCDESC_GOTOFFLO", /* name */
 411          FALSE,                 /* partial_inplace */
 412          0xffff,                /* src_mask */
 413          0xffff,                /* dst_mask */
 414          FALSE),                /* pcrel_offset */
 415
 416   /* A 12-bit signed operand with the GOT offset for the address of
 417      the symbol.  */
 418   HOWTO (R_FRV_GOTOFF12,        /* type */
 419          0,                     /* rightshift */
 420          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 421          12,                    /* bitsize */
 422          FALSE,                 /* pc_relative */
 423          0,                     /* bitpos */
 424          complain_overflow_signed, /* complain_on_overflow */
 425          bfd_elf_generic_reloc, /* special_function */
 426          "R_FRV_GOTOFF12",      /* name */
 427          FALSE,                 /* partial_inplace */
 428          0xfff,                 /* src_mask */
 429          0xfff,                 /* dst_mask */
 430          FALSE),                /* pcrel_offset */
 431
 432   /* The upper 16 bits of the GOT offset for the address of the
 433      symbol.  */
 434   HOWTO (R_FRV_GOTOFFHI,        /* type */
 435          0,                     /* rightshift */
 436          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 437          16,                    /* bitsize */
 438          FALSE,                 /* pc_relative */
 439          0,                     /* bitpos */
 440          complain_overflow_dont, /* complain_on_overflow */
 441          bfd_elf_generic_reloc, /* special_function */
 442          "R_FRV_GOTOFFHI",      /* name */
 443          FALSE,                 /* partial_inplace */
 444          0xffff,                /* src_mask */
 445          0xffff,                /* dst_mask */
 446          FALSE),                /* pcrel_offset */
 447
 448   /* The lower 16 bits of the GOT offset for the address of the
 449      symbol.  */
 450   HOWTO (R_FRV_GOTOFFLO,        /* type */
 451          0,                     /* rightshift */
 452          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 453          16,                    /* bitsize */
 454          FALSE,                 /* pc_relative */
 455          0,                     /* bitpos */
 456          complain_overflow_dont, /* complain_on_overflow */
 457          bfd_elf_generic_reloc, /* special_function */
 458          "R_FRV_GOTOFFLO",      /* name */
 459          FALSE,                 /* partial_inplace */
 460          0xffff,                /* src_mask */
 461          0xffff,                /* dst_mask */
 462          FALSE),                /* pcrel_offset */
 463
 464 };
 465
 466 /* GNU extension to record C++ vtable hierarchy.  */
 467 static reloc_howto_type elf32_frv_vtinherit_howto =
 468   HOWTO (R_FRV_GNU_VTINHERIT,   /* type */
 469          0,                     /* rightshift */
 470          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 471          0,                     /* bitsize */
 472          FALSE,                 /* pc_relative */
 473          0,                     /* bitpos */
 474          complain_overflow_dont, /* complain_on_overflow */
 475          NULL,                  /* special_function */
 476          "R_FRV_GNU_VTINHERIT", /* name */
 477          FALSE,                 /* partial_inplace */
 478          0,                     /* src_mask */
 479          0,                     /* dst_mask */
 480          FALSE);                /* pcrel_offset */
 481
 482   /* GNU extension to record C++ vtable member usage.  */
 483 static reloc_howto_type elf32_frv_vtentry_howto =
 484   HOWTO (R_FRV_GNU_VTENTRY,     /* type */
 485          0,                     /* rightshift */
 486          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 487          0,                     /* bitsize */
 488          FALSE,                 /* pc_relative */
 489          0,                     /* bitpos */
 490          complain_overflow_dont, /* complain_on_overflow */
 491          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 492          "R_FRV_GNU_VTENTRY",   /* name */
 493          FALSE,                 /* partial_inplace */
 494          0,                     /* src_mask */
 495          0,                     /* dst_mask */
 496          FALSE);                /* pcrel_offset */
 497
 498 /* The following 3 relocations are REL.  The only difference to the
 499    entries in the table above are that partial_inplace is TRUE.  */
 500 static reloc_howto_type elf32_frv_rel_32_howto =
 501   HOWTO (R_FRV_32,              /* type */
 502          0,                     /* rightshift */
 503          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 504          32,                    /* bitsize */
 505          FALSE,                 /* pc_relative */
 506          0,                     /* bitpos */
 507          complain_overflow_bitfield, /* complain_on_overflow */
 508          bfd_elf_generic_reloc, /* special_function */
 509          "R_FRV_32",            /* name */
 510          TRUE,                  /* partial_inplace */
 511          0xffffffff,            /* src_mask */
 512          0xffffffff,            /* dst_mask */
 513          FALSE);                /* pcrel_offset */
 514
 515 static reloc_howto_type elf32_frv_rel_funcdesc_howto =
 516   HOWTO (R_FRV_FUNCDESC,        /* type */
 517          0,                     /* rightshift */
 518          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 519          32,                    /* bitsize */
 520          FALSE,                 /* pc_relative */
 521          0,                     /* bitpos */
 522          complain_overflow_bitfield, /* complain_on_overflow */
 523          bfd_elf_generic_reloc, /* special_function */
 524          "R_FRV_FUNCDESC",      /* name */
 525          TRUE,                  /* partial_inplace */
 526          0xffffffff,            /* src_mask */
 527          0xffffffff,            /* dst_mask */
 528          FALSE);                /* pcrel_offset */
 529
 530 static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
 531   HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
 532          0,                     /* rightshift */
 533          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 534          64,                    /* bitsize */
 535          FALSE,                 /* pc_relative */
 536          0,                     /* bitpos */
 537          complain_overflow_bitfield, /* complain_on_overflow */
 538          bfd_elf_generic_reloc, /* special_function */
 539          "R_FRV_FUNCDESC_VALUE", /* name */
 540          TRUE,                  /* partial_inplace */
 541          0xffffffff,            /* src_mask */
 542          0xffffffff,            /* dst_mask */
 543          FALSE);                /* pcrel_offset */
 544
 545 \f
 546 /* Map BFD reloc types to FRV ELF reloc types.  */
 547 #if 0
 548 struct frv_reloc_map
 549 {
 550   unsigned int bfd_reloc_val;
 551   unsigned int frv_reloc_val;
 552 };
 553
 554 static const struct frv_reloc_map frv_reloc_map [] =
 555 {
 556   { BFD_RELOC_NONE,           R_FRV_NONE },
 557   { BFD_RELOC_32,             R_FRV_32 },
 558   { BFD_RELOC_FRV_LABEL16,    R_FRV_LABEL16 },
 559   { BFD_RELOC_FRV_LABEL24,    R_FRV_LABEL24 },
 560   { BFD_RELOC_FRV_LO16,       R_FRV_LO16 },
 561   { BFD_RELOC_FRV_HI16,       R_FRV_HI16 },
 562   { BFD_RELOC_FRV_GPREL12,    R_FRV_GPREL12 },
 563   { BFD_RELOC_FRV_GPRELU12,   R_FRV_GPRELU12 },
 564   { BFD_RELOC_FRV_GPREL32,    R_FRV_GPREL32 },
 565   { BFD_RELOC_FRV_GPRELHI,    R_FRV_GPRELHI },
 566   { BFD_RELOC_FRV_GPRELLO,    R_FRV_GPRELLO },
 567   { BFD_RELOC_FRV_GOT12,      R_FRV_GOT12 },
 568   { BFD_RELOC_FRV_GOTHI,      R_FRV_GOTHI },
 569   { BFD_RELOC_FRV_GOTLO,      R_FRV_GOTLO },
 570   { BFD_RELOC_FRV_FUNCDESC,   R_FRV_FUNCDESC },
 571   { BFD_RELOC_FRV_FUNCDESC_GOT12, R_FRV_FUNCDESC_GOT12 },
 572   { BFD_RELOC_FRV_FUNCDESC_GOTHI, R_FRV_FUNCDESC_GOTHI },
 573   { BFD_RELOC_FRV_FUNCDESC_GOTLO, R_FRV_FUNCDESC_GOTLO },
 574   { BFD_RELOC_FRV_FUNCDESC_VALUE, R_FRV_FUNCDESC_VALUE },
 575   { BFD_RELOC_FRV_FUNCDESC_GOTOFF12, R_FRV_FUNCDESC_GOTOFF12 },
 576   { BFD_RELOC_FRV_FUNCDESC_GOTOFFHI, R_FRV_FUNCDESC_GOTOFFHI },
 577   { BFD_RELOC_FRV_FUNCDESC_GOTOFFLO, R_FRV_FUNCDESC_GOTOFFLO },
 578   { BFD_RELOC_FRV_GOTOFF12,   R_FRV_GOTOFF12 },
 579   { BFD_RELOC_FRV_GOTOFFHI,   R_FRV_GOTOFFHI },
 580   { BFD_RELOC_FRV_GOTOFFLO,   R_FRV_GOTOFFLO },
 581   { BFD_RELOC_VTABLE_INHERIT, R_FRV_GNU_VTINHERIT },
 582   { BFD_RELOC_VTABLE_ENTRY,   R_FRV_GNU_VTENTRY },
 583 };
 584 #endif
 585
 586 extern const bfd_target bfd_elf32_frvfdpic_vec;
 587 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_frvfdpic_vec)
 588
 589 /* An extension of the elf hash table data structure, containing some
 590    additional FRV-specific data.  */
 591 struct frvfdpic_elf_link_hash_table
 592 {
 593   struct elf_link_hash_table elf;
 594
 595   /* A pointer to the .got section.  */
 596   asection *sgot;
 597   /* A pointer to the .rel.got section.  */
 598   asection *sgotrel;
 599   /* A pointer to the .rofixup section.  */
 600   asection *sgotfixup;
 601   /* A pointer to the .plt section.  */
 602   asection *splt;
 603   /* A pointer to the .rel.plt section.  */
 604   asection *spltrel;
 605   /* GOT base offset.  */
 606   bfd_vma got0;
 607   /* Location of the first non-lazy PLT entry, i.e., the number of
 608      bytes taken by lazy PLT entries.  */
 609   bfd_vma plt0;
 610   /* A hash table holding information about which symbols were
 611      referenced with which PIC-related relocations.  */
 612   struct htab *relocs_info;
 613 };
 614
 615 /* Get the FRV ELF linker hash table from a link_info structure.  */
 616
 617 #define frvfdpic_hash_table(info) \
 618   ((struct frvfdpic_elf_link_hash_table *) ((info)->hash))
 619
 620 #define frvfdpic_got_section(info) \
 621   (frvfdpic_hash_table (info)->sgot)
 622 #define frvfdpic_gotrel_section(info) \
 623   (frvfdpic_hash_table (info)->sgotrel)
 624 #define frvfdpic_gotfixup_section(info) \
 625   (frvfdpic_hash_table (info)->sgotfixup)
 626 #define frvfdpic_plt_section(info) \
 627   (frvfdpic_hash_table (info)->splt)
 628 #define frvfdpic_pltrel_section(info) \
 629   (frvfdpic_hash_table (info)->spltrel)
 630 #define frvfdpic_relocs_info(info) \
 631   (frvfdpic_hash_table (info)->relocs_info)
 632 #define frvfdpic_got_initial_offset(info) \
 633   (frvfdpic_hash_table (info)->got0)
 634 #define frvfdpic_plt_initial_offset(info) \
 635   (frvfdpic_hash_table (info)->plt0)
 636
 637 /* Create an FRV ELF linker hash table.  */
 638
 639 static struct bfd_link_hash_table *
 640 frvfdpic_elf_link_hash_table_create (bfd *abfd)
 641 {
 642   struct frvfdpic_elf_link_hash_table *ret;
 643   bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
 644
 645   ret = bfd_zalloc (abfd, amt);
 646   if (ret == NULL)
 647     return NULL;
 648
 649   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
 650                                        _bfd_elf_link_hash_newfunc))
 651     {
 652       free (ret);
 653       return NULL;
 654     }
 655
 656   return &ret->elf.root;
 657 }
 658
 659 /* Decide whether a reference to a symbol can be resolved locally or
 660    not.  If the symbol is protected, we want the local address, but
 661    its function descriptor must be assigned by the dynamic linker.  */
 662 #define FRVFDPIC_SYM_LOCAL(INFO, H) \
 663   (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
 664    || ! elf_hash_table (INFO)->dynamic_sections_created)
 665 #define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
 666   ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
 667
 668 /* This structure collects information on what kind of GOT, PLT or
 669    function descriptors are required by relocations that reference a
 670    certain symbol.  */
 671 struct frvfdpic_relocs_info
 672 {
 673   /* The index of the symbol, as stored in the relocation r_info, if
 674      we have a local symbol; -1 otherwise.  */
 675   long symndx;
 676   union
 677   {
 678     /* The input bfd in which the symbol is defined, if it's a local
 679        symbol.  */
 680     bfd *abfd;
 681     /* If symndx == -1, the hash table entry corresponding to a global
 682        symbol (even if it turns out to bind locally, in which case it
 683        should ideally be replaced with section's symndx + addend).  */
 684     struct elf_link_hash_entry *h;
 685   } d;
 686   /* The addend of the relocation that references the symbol.  */
 687   bfd_vma addend;
 688
 689   /* The fields above are used to identify an entry.  The fields below
 690      contain information on how an entry is used and, later on, which
 691      locations it was assigned.  */
 692   /* The following 3 fields record whether the symbol+addend above was
 693      ever referenced with a GOT relocation.  The 12 suffix indicates a
 694      GOT12 relocation; los is used for GOTLO relocations that are not
 695      matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
 696      pairs.  */
 697   unsigned got12:1;
 698   unsigned gotlos:1;
 699   unsigned gothilo:1;
 700   /* Whether a FUNCDESC relocation references symbol+addend.  */
 701   unsigned fd:1;
 702   /* Whether a FUNCDESC_GOT relocation references symbol+addend.  */
 703   unsigned fdgot12:1;
 704   unsigned fdgotlos:1;
 705   unsigned fdgothilo:1;
 706   /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend.  */
 707   unsigned fdgoff12:1;
 708   unsigned fdgofflos:1;
 709   unsigned fdgoffhilo:1;
 710   /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
 711      GOTOFFHI relocations.  The addend doesn't really matter, since we
 712      envision that this will only be used to check whether the symbol
 713      is mapped to the same segment as the got.  */
 714   unsigned gotoff:1;
 715   /* Whether symbol+addend is referenced by a LABEL24 relocation.  */
 716   unsigned call:1;
 717   /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
 718      relocation.  */
 719   unsigned sym:1;
 720   /* Whether we need a PLT entry for a symbol.  Should be implied by
 721      something like:
 722      (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h))  */
 723   unsigned plt:1;
 724   /* Whether a function descriptor should be created in this link unit
 725      for symbol+addend.  Should be implied by something like:
 726      (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
 727       || ((fd || fdgot12 || fdgotlos || fdgothilo)
 728           && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h))))  */
 729   unsigned privfd:1;
 730   /* Whether a lazy PLT entry is needed for this symbol+addend.
 731      Should be implied by something like:
 732      (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
 733       && ! (info->flags & DF_BIND_NOW))  */
 734   unsigned lazyplt:1;
 735   /* Whether we've already emitted GOT relocations and PLT entries as
 736      needed for this symbol.  */
 737   unsigned done:1;
 738
 739   /* The number of R_FRV_32, R_FRV_FUNCDESC and R_FRV_FUNCDESC_VALUE
 740      relocations referencing the symbol.  */
 741   unsigned relocs32, relocsfd, relocsfdv;
 742
 743   /* The number of .rofixups entries and dynamic relocations allocated
 744      for this symbol, minus any that might have already been used.  */
 745   unsigned fixups, dynrelocs;
 746
 747   /* The offsets of the GOT entries assigned to symbol+addend, to the
 748      function descriptor's address, and to a function descriptor,
 749      respectively.  Should be zero if unassigned.  The offsets are
 750      counted from the value that will be assigned to the PIC register,
 751      not from the beginning of the .got section.  */
 752   bfd_signed_vma got_entry, fdgot_entry, fd_entry;
 753   /* The offsets of the PLT entries assigned to symbol+addend,
 754      non-lazy and lazy, respectively.  If unassigned, should be
 755      (bfd_vma)-1.  */
 756   bfd_vma plt_entry, lzplt_entry;
 757 };
 758
 759 /* Compute a hash with the key fields of an frvfdpic_relocs_info entry.  */
 760 static hashval_t
 761 frvfdpic_relocs_info_hash (const void *entry_)
 762 {
 763   const struct frvfdpic_relocs_info *entry = entry_;
 764
 765   return (entry->symndx == -1
 766           ? entry->d.h->root.root.hash
 767           : entry->symndx + entry->d.abfd->id * 257) + entry->addend;
 768 }
 769
 770 /* Test whether the key fields of two frvfdpic_relocs_info entries are
 771    identical.  */
 772 static int
 773 frvfdpic_relocs_info_eq (const void *entry1, const void *entry2)
 774 {
 775   const struct frvfdpic_relocs_info *e1 = entry1;
 776   const struct frvfdpic_relocs_info *e2 = entry2;
 777
 778   return e1->symndx == e2->symndx && e1->addend == e2->addend
 779     && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
 780 }
 781
 782 /* Find or create an entry in a hash table HT that matches the key
 783    fields of the given ENTRY.  If it's not found, memory for a new
 784    entry is allocated in ABFD's obstack.  */
 785 static struct frvfdpic_relocs_info *
 786 frvfdpic_relocs_info_find (struct htab *ht,
 787                            bfd *abfd,
 788                            const struct frvfdpic_relocs_info *entry,
 789                            enum insert_option insert)
 790 {
 791   struct frvfdpic_relocs_info **loc =
 792     (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
 793
 794   if (! loc)
 795     return NULL;
 796
 797   if (*loc)
 798     return *loc;
 799
 800   *loc = bfd_zalloc (abfd, sizeof (**loc));
 801
 802   if (! *loc)
 803     return *loc;
 804
 805   (*loc)->symndx = entry->symndx;
 806   (*loc)->d = entry->d;
 807   (*loc)->addend = entry->addend;
 808   (*loc)->plt_entry = (bfd_vma)-1;
 809   (*loc)->lzplt_entry = (bfd_vma)-1;
 810
 811   return *loc;
 812 }
 813
 814 /* Obtain the address of the entry in HT associated with H's symbol +
 815    addend, creating a new entry if none existed.  ABFD is only used
 816    for memory allocation purposes.  */
 817 inline static struct frvfdpic_relocs_info *
 818 frvfdpic_relocs_info_for_global (struct htab *ht,
 819                                  bfd *abfd,
 820                                  struct elf_link_hash_entry *h,
 821                                  bfd_vma addend,
 822                                  enum insert_option insert)
 823 {
 824   struct frvfdpic_relocs_info entry;
 825
 826   entry.symndx = -1;
 827   entry.d.h = h;
 828   entry.addend = addend;
 829
 830   return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
 831 }
 832
 833 /* Obtain the address of the entry in HT associated with the SYMNDXth
 834    local symbol of the input bfd ABFD, plus the addend, creating a new
 835    entry if none existed.  */
 836 inline static struct frvfdpic_relocs_info *
 837 frvfdpic_relocs_info_for_local (struct htab *ht,
 838                                 bfd *abfd,
 839                                 long symndx,
 840                                 bfd_vma addend,
 841                                 enum insert_option insert)
 842 {
 843   struct frvfdpic_relocs_info entry;
 844
 845   entry.symndx = symndx;
 846   entry.d.abfd = abfd;
 847   entry.addend = addend;
 848
 849   return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
 850 }
 851
 852 /* Merge fields set by check_relocs() of two entries that end up being
 853    mapped to the same (presumably global) symbol.  */
 854
 855 inline static void
 856 frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2,
 857                                       struct frvfdpic_relocs_info const *e1)
 858 {
 859   e2->got12 |= e1->got12;
 860   e2->gotlos |= e1->gotlos;
 861   e2->gothilo |= e1->gothilo;
 862   e2->fd |= e1->fd;
 863   e2->fdgot12 |= e1->fdgot12;
 864   e2->fdgotlos |= e1->fdgotlos;
 865   e2->fdgothilo |= e1->fdgothilo;
 866   e2->fdgoff12 |= e1->fdgoff12;
 867   e2->fdgofflos |= e1->fdgofflos;
 868   e2->fdgoffhilo |= e1->fdgoffhilo;
 869   e2->gotoff |= e1->gotoff;
 870   e2->call |= e1->call;
 871   e2->sym |= e1->sym;
 872
 873 #if 0
 874   /* These are set in _frvfdpic_count_got_plt_entries() or later, and this
 875      function is only called in _frvfdpic_resolve_final_relocs_info(), that
 876      runs just before it, so we don't have to worry about the fields
 877      below.  */
 878
 879   e2->plt |= e1->plt;
 880   e2->privfd |= e1->privfd;
 881   e2->lazyplt |= e1->lazyplt;
 882   e2->done |= e1->done;
 883
 884   e2->relocs32 += e1->relocs32;
 885   e2->relocsfd += e1->relocsfd;
 886   e2->relocsfdv += e1->relocsfdv;
 887   e2->fixups += e1->fixups;
 888   e2->dynrelocs += e1->dynrelocs;
 889
 890   if (abs (e1->got_entry) < abs (e2->got_entry))
 891     e2->got_entry = e1->got_entry;
 892   if (abs (e1->fdgot_entry) < abs (e2->fdgot_entry))
 893     e2->fdgot_entry = e1->fdgot_entry;
 894   if (abs (e1->fd_entry) < abs (e2->fd_entry))
 895     e2->fd_entry = e1->fd_entry;
 896
 897   if (e1->plt_entry < e2->plt_entry)
 898     e2->plt_entry = e1->plt_entry;
 899   if (e1->lzplt_entry < e2->lzplt_entry)
 900     e2->lzplt_entry = e1->lzplt_entry;
 901 #endif
 902 }
 903
 904 /* Every block of 65535 lazy PLT entries shares a single call to the
 905    resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
 906    32767, counting from 0).  All other lazy PLT entries branch to it
 907    in a single instruction.  */
 908
 909 #define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
 910 #define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
 911
 912 /* Add a dynamic relocation to the SRELOC section.  */
 913
 914 inline static bfd_vma
 915 _frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
 916                          int reloc_type, long dynindx, bfd_vma addend,
 917                          struct frvfdpic_relocs_info *entry)
 918 {
 919   Elf_Internal_Rela outrel;
 920   bfd_vma reloc_offset;
 921
 922   outrel.r_offset = offset;
 923   outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
 924   outrel.r_addend = addend;
 925
 926   reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
 927   BFD_ASSERT (reloc_offset < sreloc->size);
 928   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
 929                             sreloc->contents + reloc_offset);
 930   sreloc->reloc_count++;
 931
 932   /* If the entry's index is zero, this relocation was probably to a
 933      linkonce section that got discarded.  We reserved a dynamic
 934      relocation, but it was for another entry than the one we got at
 935      the time of emitting the relocation.  Unfortunately there's no
 936      simple way for us to catch this situation, since the relocation
 937      is cleared right before calling relocate_section, at which point
 938      we no longer know what the relocation used to point to.  */
 939   if (entry->symndx)
 940     {
 941       BFD_ASSERT (entry->dynrelocs > 0);
 942       entry->dynrelocs--;
 943     }
 944
 945   return reloc_offset;
 946 }
 947
 948 /* Add a fixup to the ROFIXUP section.  */
 949
 950 static bfd_vma
 951 _frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
 952                        struct frvfdpic_relocs_info *entry)
 953 {
 954   bfd_vma fixup_offset;
 955
 956   if (rofixup->flags & SEC_EXCLUDE)
 957     return -1;
 958
 959   fixup_offset = rofixup->reloc_count * 4;
 960   if (rofixup->contents)
 961     {
 962       BFD_ASSERT (fixup_offset < rofixup->size);
 963       bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
 964     }
 965   rofixup->reloc_count++;
 966
 967   if (entry && entry->symndx)
 968     {
 969       /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
 970          above.  */
 971       BFD_ASSERT (entry->fixups > 0);
 972       entry->fixups--;
 973     }
 974
 975   return fixup_offset;
 976 }
 977
 978 /* Find the segment number in which OSEC, and output section, is
 979    located.  */
 980
 981 static unsigned
 982 _frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
 983 {
 984   struct elf_segment_map *m;
 985   Elf_Internal_Phdr *p;
 986
 987   /* Find the segment that contains the output_section.  */
 988   for (m = elf_tdata (output_bfd)->segment_map,
 989          p = elf_tdata (output_bfd)->phdr;
 990        m != NULL;
 991        m = m->next, p++)
 992     {
 993       int i;
 994
 995       for (i = m->count - 1; i >= 0; i--)
 996         if (m->sections[i] == osec)
 997           break;
 998
 999       if (i >= 0)
1000         break;
1001     }
1002
1003   return p - elf_tdata (output_bfd)->phdr;
1004 }
1005
1006 inline static bfd_boolean
1007 _frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
1008 {
1009   unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec);
1010
1011   return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
1012 }
1013
1014 /* Generate relocations for GOT entries, function descriptors, and
1015    code for PLT and lazy PLT entries.  */
1016
1017 inline static bfd_boolean
1018 _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
1019                                        bfd *output_bfd,
1020                                        struct bfd_link_info *info,
1021                                        asection *sec,
1022                                        Elf_Internal_Sym *sym,
1023                                        bfd_vma addend)
1024
1025 {
1026   bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
1027   int dynindx = -1;
1028
1029   if (entry->done)
1030     return TRUE;
1031   entry->done = 1;
1032
1033   if (entry->got_entry || entry->fdgot_entry || entry->fd_entry)
1034     {
1035       /* If the symbol is dynamic, consider it for dynamic
1036          relocations, otherwise decay to section + offset.  */
1037       if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1038         dynindx = entry->d.h->dynindx;
1039       else
1040         {
1041           if (sec->output_section
1042               && ! bfd_is_abs_section (sec->output_section)
1043               && ! bfd_is_und_section (sec->output_section))
1044             dynindx = elf_section_data (sec->output_section)->dynindx;
1045           else
1046             dynindx = 0;
1047         }
1048     }
1049
1050   /* Generate relocation for GOT entry pointing to the symbol.  */
1051   if (entry->got_entry)
1052     {
1053       int idx = dynindx;
1054       bfd_vma ad = addend;
1055
1056       /* If the symbol is dynamic but binds locally, use
1057          section+offset.  */
1058       if (sec && (entry->symndx != -1
1059                   || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1060         {
1061           if (entry->symndx == -1)
1062             ad += entry->d.h->root.u.def.value;
1063           else
1064             ad += sym->st_value;
1065           ad += sec->output_offset;
1066           if (sec->output_section && elf_section_data (sec->output_section))
1067             idx = elf_section_data (sec->output_section)->dynindx;
1068           else
1069             idx = 0;
1070         }
1071
1072       /* If we're linking an executable at a fixed address, we can
1073          omit the dynamic relocation as long as the symbol is local to
1074          this module.  */
1075       if (info->executable && !info->pie
1076           && (entry->symndx != -1
1077               || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1078         {
1079           if (sec)
1080             ad += sec->output_section->vma;
1081           if (entry->symndx != -1
1082               || entry->d.h->root.type != bfd_link_hash_undefweak)
1083             _frvfdpic_add_rofixup (output_bfd,
1084                                    frvfdpic_gotfixup_section (info),
1085                                    frvfdpic_got_section (info)->output_section
1086                                    ->vma
1087                                    + frvfdpic_got_section (info)->output_offset
1088                                    + frvfdpic_got_initial_offset (info)
1089                                    + entry->got_entry, entry);
1090         }
1091       else
1092         _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1093                                  _bfd_elf_section_offset
1094                                  (output_bfd, info,
1095                                   frvfdpic_got_section (info),
1096                                   frvfdpic_got_initial_offset (info)
1097                                   + entry->got_entry)
1098                                  + frvfdpic_got_section (info)
1099                                  ->output_section->vma
1100                                  + frvfdpic_got_section (info)->output_offset,
1101                                  R_FRV_32, idx, ad, entry);
1102
1103       bfd_put_32 (output_bfd, ad,
1104                   frvfdpic_got_section (info)->contents
1105                   + frvfdpic_got_initial_offset (info)
1106                   + entry->got_entry);
1107     }
1108
1109   /* Generate relocation for GOT entry pointing to a canonical
1110      function descriptor.  */
1111   if (entry->fdgot_entry)
1112     {
1113       int reloc, idx;
1114       bfd_vma ad = 0;
1115
1116       if (! (entry->symndx == -1
1117              && entry->d.h->root.type == bfd_link_hash_undefweak
1118              && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1119         {
1120           /* If the symbol is dynamic and there may be dynamic symbol
1121              resolution because we are, or are linked with, a shared
1122              library, emit a FUNCDESC relocation such that the dynamic
1123              linker will allocate the function descriptor.  If the
1124              symbol needs a non-local function descriptor but binds
1125              locally (e.g., its visibility is protected, emit a
1126              dynamic relocation decayed to section+offset.  */
1127           if (entry->symndx == -1
1128               && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1129               && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
1130               && !(info->executable && !info->pie))
1131             {
1132               reloc = R_FRV_FUNCDESC;
1133               idx = elf_section_data (entry->d.h->root.u.def.section
1134                                       ->output_section)->dynindx;
1135               ad = entry->d.h->root.u.def.section->output_offset
1136                 + entry->d.h->root.u.def.value;
1137             }
1138           else if (entry->symndx == -1
1139                    && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1140             {
1141               reloc = R_FRV_FUNCDESC;
1142               idx = dynindx;
1143               ad = addend;
1144               if (ad)
1145                 return FALSE;
1146             }
1147           else
1148             {
1149               /* Otherwise, we know we have a private function descriptor,
1150                  so reference it directly.  */
1151               if (elf_hash_table (info)->dynamic_sections_created)
1152                 BFD_ASSERT (entry->privfd);
1153               reloc = R_FRV_32;
1154               idx = elf_section_data (frvfdpic_got_section (info)
1155                                       ->output_section)->dynindx;
1156               ad = frvfdpic_got_section (info)->output_offset
1157                 + frvfdpic_got_initial_offset (info) + entry->fd_entry;
1158             }
1159
1160           /* If there is room for dynamic symbol resolution, emit the
1161              dynamic relocation.  However, if we're linking an
1162              executable at a fixed location, we won't have emitted a
1163              dynamic symbol entry for the got section, so idx will be
1164              zero, which means we can and should compute the address
1165              of the private descriptor ourselves.  */
1166           if (info->executable && !info->pie
1167               && (entry->symndx != -1
1168                   || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1169             {
1170               ad += frvfdpic_got_section (info)->output_section->vma;
1171               _frvfdpic_add_rofixup (output_bfd,
1172                                      frvfdpic_gotfixup_section (info),
1173                                      frvfdpic_got_section (info)
1174                                      ->output_section->vma
1175                                      + frvfdpic_got_section (info)
1176                                      ->output_offset
1177                                      + frvfdpic_got_initial_offset (info)
1178                                      + entry->fdgot_entry, entry);
1179             }
1180           else
1181             _frvfdpic_add_dyn_reloc (output_bfd,
1182                                      frvfdpic_gotrel_section (info),
1183                                      _bfd_elf_section_offset
1184                                      (output_bfd, info,
1185                                       frvfdpic_got_section (info),
1186                                       frvfdpic_got_initial_offset (info)
1187                                       + entry->fdgot_entry)
1188                                      + frvfdpic_got_section (info)
1189                                      ->output_section->vma
1190                                      + frvfdpic_got_section (info)
1191                                      ->output_offset,
1192                                      reloc, idx, ad, entry);
1193         }
1194
1195       bfd_put_32 (output_bfd, ad,
1196                   frvfdpic_got_section (info)->contents
1197                   + frvfdpic_got_initial_offset (info)
1198                   + entry->fdgot_entry);
1199     }
1200
1201   /* Generate relocation to fill in a private function descriptor in
1202      the GOT.  */
1203   if (entry->fd_entry)
1204     {
1205       int idx = dynindx;
1206       bfd_vma ad = addend;
1207       bfd_vma ofst;
1208       long lowword, highword;
1209
1210       /* If the symbol is dynamic but binds locally, use
1211          section+offset.  */
1212       if (sec && (entry->symndx != -1
1213                   || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1214         {
1215           if (entry->symndx == -1)
1216             ad += entry->d.h->root.u.def.value;
1217           else
1218             ad += sym->st_value;
1219           ad += sec->output_offset;
1220           if (sec->output_section && elf_section_data (sec->output_section))
1221             idx = elf_section_data (sec->output_section)->dynindx;
1222           else
1223             idx = 0;
1224         }
1225
1226       /* If we're linking an executable at a fixed address, we can
1227          omit the dynamic relocation as long as the symbol is local to
1228          this module.  */
1229       if (info->executable && !info->pie
1230           && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1231         {
1232           if (sec)
1233             ad += sec->output_section->vma;
1234           ofst = 0;
1235           if (entry->symndx != -1
1236               || entry->d.h->root.type != bfd_link_hash_undefweak)
1237             {
1238               _frvfdpic_add_rofixup (output_bfd,
1239                                      frvfdpic_gotfixup_section (info),
1240                                      frvfdpic_got_section (info)
1241                                      ->output_section->vma
1242                                      + frvfdpic_got_section (info)
1243                                      ->output_offset
1244                                      + frvfdpic_got_initial_offset (info)
1245                                      + entry->fd_entry, entry);
1246               _frvfdpic_add_rofixup (output_bfd,
1247                                      frvfdpic_gotfixup_section (info),
1248                                      frvfdpic_got_section (info)
1249                                      ->output_section->vma
1250                                      + frvfdpic_got_section (info)
1251                                      ->output_offset
1252                                      + frvfdpic_got_initial_offset (info)
1253                                      + entry->fd_entry + 4, entry);
1254             }
1255         }
1256       else
1257         {
1258           ofst =
1259             _frvfdpic_add_dyn_reloc (output_bfd,
1260                                      entry->lazyplt
1261                                      ? frvfdpic_pltrel_section (info)
1262                                      : frvfdpic_gotrel_section (info),
1263                                      _bfd_elf_section_offset
1264                                      (output_bfd, info,
1265                                       frvfdpic_got_section (info),
1266                                       frvfdpic_got_initial_offset (info)
1267                                       + entry->fd_entry)
1268                                      + frvfdpic_got_section (info)
1269                                      ->output_section->vma
1270                                      + frvfdpic_got_section (info)
1271                                      ->output_offset,
1272                                      R_FRV_FUNCDESC_VALUE, idx, ad, entry);
1273         }
1274
1275       /* If we've omitted the dynamic relocation, just emit the fixed
1276          addresses of the symbol and of the local GOT base offset.  */
1277       if (info->executable && !info->pie && sec && sec->output_section)
1278         {
1279           lowword = ad;
1280           highword = frvfdpic_got_section (info)->output_section->vma
1281             + frvfdpic_got_section (info)->output_offset
1282             + frvfdpic_got_initial_offset (info);
1283         }
1284       else if (entry->lazyplt)
1285         {
1286           if (ad)
1287             return FALSE;
1288
1289           fd_lazy_rel_offset = ofst;
1290
1291           /* A function descriptor used for lazy or local resolving is
1292              initialized such that its high word contains the output
1293              section index in which the PLT entries are located, and
1294              the low word contains the address of the lazy PLT entry
1295              entry point, that must be within the memory region
1296              assigned to that section.  */
1297           lowword = entry->lzplt_entry + 4
1298             + frvfdpic_plt_section (info)->output_offset
1299             + frvfdpic_plt_section (info)->output_section->vma;
1300           highword = _frvfdpic_osec_to_segment
1301             (output_bfd, frvfdpic_plt_section (info)->output_section);
1302         }
1303       else
1304         {
1305           /* A function descriptor for a local function gets the index
1306              of the section.  For a non-local function, it's
1307              disregarded.  */
1308           lowword = ad;
1309           if (entry->symndx == -1 && entry->d.h->dynindx != -1
1310               && entry->d.h->dynindx == idx)
1311             highword = 0;
1312           else
1313             highword = _frvfdpic_osec_to_segment
1314               (output_bfd, sec->output_section);
1315         }
1316
1317       bfd_put_32 (output_bfd, lowword,
1318                   frvfdpic_got_section (info)->contents
1319                   + frvfdpic_got_initial_offset (info)
1320                   + entry->fd_entry);
1321       bfd_put_32 (output_bfd, highword,
1322                   frvfdpic_got_section (info)->contents
1323                   + frvfdpic_got_initial_offset (info)
1324                   + entry->fd_entry + 4);
1325     }
1326
1327   /* Generate code for the PLT entry.  */
1328   if (entry->plt_entry != (bfd_vma) -1)
1329     {
1330       bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1331         + entry->plt_entry;
1332
1333       BFD_ASSERT (entry->fd_entry);
1334
1335       /* Figure out what kind of PLT entry we need, depending on the
1336          location of the function descriptor within the GOT.  */
1337       if (entry->fd_entry >= -(1 << (12 - 1))
1338           && entry->fd_entry < (1 << (12 - 1)))
1339         {
1340           /* lddi @(gr15, fd_entry), gr14 */
1341           bfd_put_32 (output_bfd,
1342                       0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1343                       plt_code);
1344           plt_code += 4;
1345         }
1346       else
1347         {
1348           if (entry->fd_entry >= -(1 << (16 - 1))
1349               && entry->fd_entry < (1 << (16 - 1)))
1350             {
1351               /* setlos lo(fd_entry), gr14 */
1352               bfd_put_32 (output_bfd,
1353                           0x9cfc0000
1354                           | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1355                           plt_code);
1356               plt_code += 4;
1357             }
1358           else
1359             {
1360               /* sethi.p hi(fd_entry), gr14
1361                  setlo lo(fd_entry), gr14 */
1362               bfd_put_32 (output_bfd,
1363                           0x1cf80000
1364                           | ((entry->fd_entry >> 16)
1365                              & (((bfd_vma)1 << 16) - 1)),
1366                           plt_code);
1367               bfd_put_32 (output_bfd,
1368                           0x9cf40000
1369                           | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1370                           plt_code);
1371               plt_code += 8;
1372             }
1373           /* ldd @(gr14,gr15),gr14 */
1374           bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
1375           plt_code += 4;
1376         }
1377       /* jmpl @(gr14,gr0) */
1378       bfd_put_32 (output_bfd, 0x8030e000, plt_code);
1379     }
1380
1381   /* Generate code for the lazy PLT entry.  */
1382   if (entry->lzplt_entry != (bfd_vma) -1)
1383     {
1384       bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents
1385         + entry->lzplt_entry;
1386       bfd_vma resolverStub_addr;
1387
1388       bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1389       lzplt_code += 4;
1390
1391       resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
1392         * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC;
1393       if (resolverStub_addr >= frvfdpic_plt_initial_offset (info))
1394         resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12;
1395
1396       if (entry->lzplt_entry == resolverStub_addr)
1397         {
1398           /* This is a lazy PLT entry that includes a resolver call.  */
1399           /* ldd @(gr15,gr0), gr4
1400              jmpl @(gr4,gr0)  */
1401           bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
1402           bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
1403         }
1404       else
1405         {
1406           /* bra  resolverStub */
1407           bfd_put_32 (output_bfd,
1408                       0xc01a0000
1409                       | (((resolverStub_addr - entry->lzplt_entry)
1410                           / 4) & (((bfd_vma)1 << 16) - 1)),
1411                       lzplt_code);
1412         }
1413     }
1414
1415   return TRUE;
1416 }
1417
1418 /* Handle an FRV small data reloc.  */
1419
1420 static bfd_reloc_status_type
1421 elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
1422                             contents, value)
1423      struct bfd_link_info *info;
1424      bfd *input_bfd;
1425      asection *input_section;
1426      Elf_Internal_Rela *relocation;
1427      bfd_byte *contents;
1428      bfd_vma value;
1429 {
1430   bfd_vma insn;
1431   bfd_vma gp;
1432   struct bfd_link_hash_entry *h;
1433
1434   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1435
1436   gp = (h->u.def.value
1437         + h->u.def.section->output_section->vma
1438         + h->u.def.section->output_offset);
1439
1440   value -= input_section->output_section->vma;
1441   value -= (gp - input_section->output_section->vma);
1442
1443   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1444
1445   value += relocation->r_addend;
1446
1447   if ((long) value > 0x7ff || (long) value < -0x800)
1448     return bfd_reloc_overflow;
1449
1450   bfd_put_32 (input_bfd,
1451               (insn & 0xfffff000) | (value & 0xfff),
1452               contents + relocation->r_offset);
1453
1454   return bfd_reloc_ok;
1455 }
1456
1457 /* Handle an FRV small data reloc. for the u12 field.  */
1458
1459 static bfd_reloc_status_type
1460 elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
1461                              contents, value)
1462      struct bfd_link_info *info;
1463      bfd *input_bfd;
1464      asection *input_section;
1465      Elf_Internal_Rela *relocation;
1466      bfd_byte *contents;
1467      bfd_vma value;
1468 {
1469   bfd_vma insn;
1470   bfd_vma gp;
1471   struct bfd_link_hash_entry *h;
1472   bfd_vma mask;
1473
1474   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1475
1476   gp = (h->u.def.value
1477         + h->u.def.section->output_section->vma
1478         + h->u.def.section->output_offset);
1479
1480   value -= input_section->output_section->vma;
1481   value -= (gp - input_section->output_section->vma);
1482
1483   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1484
1485   value += relocation->r_addend;
1486
1487   if ((long) value > 0x7ff || (long) value < -0x800)
1488     return bfd_reloc_overflow;
1489
1490   /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0.  */
1491   mask = 0x3f03f;
1492   insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
1493
1494   bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
1495
1496   return bfd_reloc_ok;
1497 }
1498
1499 /* Handle an FRV ELF HI16 reloc.  */
1500
1501 static bfd_reloc_status_type
1502 elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
1503      bfd *input_bfd;
1504      Elf_Internal_Rela *relhi;
1505      bfd_byte *contents;
1506      bfd_vma value;
1507 {
1508   bfd_vma insn;
1509
1510   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
1511
1512   value += relhi->r_addend;
1513   value = ((value >> 16) & 0xffff);
1514
1515   insn = (insn & 0xffff0000) | value;
1516
1517   if ((long) value > 0xffff || (long) value < -0x10000)
1518     return bfd_reloc_overflow;
1519
1520   bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
1521   return bfd_reloc_ok;
1522
1523 }
1524 static bfd_reloc_status_type
1525 elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
1526      bfd *input_bfd;
1527      Elf_Internal_Rela *rello;
1528      bfd_byte *contents;
1529      bfd_vma value;
1530 {
1531   bfd_vma insn;
1532
1533   insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
1534
1535   value += rello->r_addend;
1536   value = value & 0xffff;
1537
1538   insn = (insn & 0xffff0000) | value;
1539
1540   if ((long) value > 0xffff || (long) value < -0x10000)
1541     return bfd_reloc_overflow;
1542
1543   bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
1544   return bfd_reloc_ok;
1545 }
1546
1547 /* Perform the relocation for the CALL label24 instruction.  */
1548
1549 static bfd_reloc_status_type
1550 elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
1551      bfd *input_bfd;
1552      asection *input_section;
1553      Elf_Internal_Rela *rello;
1554      bfd_byte *contents;
1555      bfd_vma value;
1556 {
1557   bfd_vma insn;
1558   bfd_vma label6;
1559   bfd_vma label18;
1560
1561   /* The format for the call instruction is:
1562
1563     0 000000 0001111 000000000000000000
1564       label6 opcode  label18
1565
1566     The branch calculation is: pc + (4*label24)
1567     where label24 is the concatenation of label6 and label18.  */
1568
1569   /* Grab the instruction.  */
1570   insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
1571
1572   value -= input_section->output_section->vma + input_section->output_offset;
1573   value -= rello->r_offset;
1574   value += rello->r_addend;
1575
1576   value = value >> 2;
1577
1578   label6  = value & 0xfc0000;
1579   label6  = label6 << 7;
1580
1581   label18 = value & 0x3ffff;
1582
1583   insn = insn & 0x803c0000;
1584   insn = insn | label6;
1585   insn = insn | label18;
1586
1587   bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
1588
1589   return bfd_reloc_ok;
1590 }
1591
1592 static bfd_reloc_status_type
1593 elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
1594                             contents, value)
1595      struct bfd_link_info *info;
1596      bfd *input_bfd;
1597      asection *input_section;
1598      Elf_Internal_Rela *relocation;
1599      bfd_byte *contents;
1600      bfd_vma value;
1601 {
1602   bfd_vma insn;
1603   bfd_vma gp;
1604   struct bfd_link_hash_entry *h;
1605
1606   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1607
1608   gp = (h->u.def.value
1609         + h->u.def.section->output_section->vma
1610         + h->u.def.section->output_offset);
1611
1612   value -= input_section->output_section->vma;
1613   value -= (gp - input_section->output_section->vma);
1614   value += relocation->r_addend;
1615   value = ((value >> 16) & 0xffff);
1616
1617   if ((long) value > 0xffff || (long) value < -0x10000)
1618     return bfd_reloc_overflow;
1619
1620   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1621   insn = (insn & 0xffff0000) | value;
1622
1623   bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
1624   return bfd_reloc_ok;
1625 }
1626
1627 static bfd_reloc_status_type
1628 elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
1629                             contents, value)
1630      struct bfd_link_info *info;
1631      bfd *input_bfd;
1632      asection *input_section;
1633      Elf_Internal_Rela *relocation;
1634      bfd_byte *contents;
1635      bfd_vma value;
1636 {
1637   bfd_vma insn;
1638   bfd_vma gp;
1639   struct bfd_link_hash_entry *h;
1640
1641   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
1642
1643   gp = (h->u.def.value
1644         + h->u.def.section->output_section->vma
1645         + h->u.def.section->output_offset);
1646
1647   value -= input_section->output_section->vma;
1648   value -= (gp - input_section->output_section->vma);
1649   value += relocation->r_addend;
1650   value = value & 0xffff;
1651
1652   if ((long) value > 0xffff || (long) value < -0x10000)
1653     return bfd_reloc_overflow;
1654
1655   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
1656   insn = (insn & 0xffff0000) | value;
1657
1658   bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
1659
1660  return bfd_reloc_ok;
1661 }
1662
1663 static reloc_howto_type *
1664 frv_reloc_type_lookup (abfd, code)
1665      bfd *abfd ATTRIBUTE_UNUSED;
1666      bfd_reloc_code_real_type code;
1667 {
1668   switch (code)
1669     {
1670     default:
1671       break;
1672
1673     case BFD_RELOC_NONE:
1674       return &elf32_frv_howto_table[ (int) R_FRV_NONE];
1675
1676     case BFD_RELOC_32:
1677       if (elf_elfheader (abfd)->e_type == ET_EXEC
1678           || elf_elfheader (abfd)->e_type == ET_DYN)
1679         return &elf32_frv_rel_32_howto;
1680       /* Fall through.  */
1681     case BFD_RELOC_CTOR:
1682       return &elf32_frv_howto_table[ (int) R_FRV_32];
1683
1684     case BFD_RELOC_FRV_LABEL16:
1685       return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
1686
1687     case BFD_RELOC_FRV_LABEL24:
1688       return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
1689
1690     case BFD_RELOC_FRV_LO16:
1691       return &elf32_frv_howto_table[ (int) R_FRV_LO16];
1692
1693     case BFD_RELOC_FRV_HI16:
1694       return &elf32_frv_howto_table[ (int) R_FRV_HI16];
1695
1696     case BFD_RELOC_FRV_GPREL12:
1697       return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
1698
1699     case BFD_RELOC_FRV_GPRELU12:
1700       return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
1701
1702     case BFD_RELOC_FRV_GPREL32:
1703       return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
1704
1705     case BFD_RELOC_FRV_GPRELHI:
1706       return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
1707
1708     case BFD_RELOC_FRV_GPRELLO:
1709       return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
1710
1711     case BFD_RELOC_FRV_GOT12:
1712       return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
1713
1714     case BFD_RELOC_FRV_GOTHI:
1715       return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
1716
1717     case BFD_RELOC_FRV_GOTLO:
1718       return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
1719
1720     case BFD_RELOC_FRV_FUNCDESC:
1721       if (elf_elfheader (abfd)->e_type == ET_EXEC
1722           || elf_elfheader (abfd)->e_type == ET_DYN)
1723         return &elf32_frv_rel_funcdesc_howto;
1724       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
1725
1726     case BFD_RELOC_FRV_FUNCDESC_GOT12:
1727       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
1728
1729     case BFD_RELOC_FRV_FUNCDESC_GOTHI:
1730       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
1731
1732     case BFD_RELOC_FRV_FUNCDESC_GOTLO:
1733       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
1734
1735     case BFD_RELOC_FRV_FUNCDESC_VALUE:
1736       if (elf_elfheader (abfd)->e_type == ET_EXEC
1737           || elf_elfheader (abfd)->e_type == ET_DYN)
1738         return &elf32_frv_rel_funcdesc_value_howto;
1739       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
1740
1741     case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
1742       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
1743
1744     case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
1745       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
1746
1747     case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
1748       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
1749
1750     case BFD_RELOC_FRV_GOTOFF12:
1751       return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
1752
1753     case BFD_RELOC_FRV_GOTOFFHI:
1754       return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
1755
1756     case BFD_RELOC_FRV_GOTOFFLO:
1757       return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
1758
1759     case BFD_RELOC_VTABLE_INHERIT:
1760       return &elf32_frv_vtinherit_howto;
1761
1762     case BFD_RELOC_VTABLE_ENTRY:
1763       return &elf32_frv_vtentry_howto;
1764     }
1765
1766   return NULL;
1767 }
1768
1769 /* Set the howto pointer for an FRV ELF reloc.  */
1770
1771 static void
1772 frv_info_to_howto_rela (abfd, cache_ptr, dst)
1773      bfd *abfd ATTRIBUTE_UNUSED;
1774      arelent *cache_ptr;
1775      Elf_Internal_Rela *dst;
1776 {
1777   unsigned int r_type;
1778
1779   r_type = ELF32_R_TYPE (dst->r_info);
1780   switch (r_type)
1781     {
1782     case R_FRV_GNU_VTINHERIT:
1783       cache_ptr->howto = &elf32_frv_vtinherit_howto;
1784       break;
1785
1786     case R_FRV_GNU_VTENTRY:
1787       cache_ptr->howto = &elf32_frv_vtentry_howto;
1788       break;
1789
1790     default:
1791       cache_ptr->howto = & elf32_frv_howto_table [r_type];
1792       break;
1793     }
1794 }
1795
1796 /* Set the howto pointer for an FRV ELF REL reloc.  */
1797 static void
1798 frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
1799                             arelent *cache_ptr, Elf_Internal_Rela *dst)
1800 {
1801   unsigned int r_type;
1802
1803   r_type = ELF32_R_TYPE (dst->r_info);
1804   switch (r_type)
1805     {
1806     case R_FRV_32:
1807       cache_ptr->howto = &elf32_frv_rel_32_howto;
1808       break;
1809
1810     case R_FRV_FUNCDESC:
1811       cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
1812       break;
1813
1814     case R_FRV_FUNCDESC_VALUE:
1815       cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
1816       break;
1817
1818     default:
1819       cache_ptr->howto = NULL;
1820       break;
1821     }
1822 }
1823 \f
1824 /* Perform a single relocation.  By default we use the standard BFD
1825    routines, but a few relocs, we have to do them ourselves.  */
1826
1827 static bfd_reloc_status_type
1828 frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
1829                          relocation)
1830      reloc_howto_type *howto;
1831      bfd *input_bfd;
1832      asection *input_section;
1833      bfd_byte *contents;
1834      Elf_Internal_Rela *rel;
1835      bfd_vma relocation;
1836 {
1837   return _bfd_final_link_relocate (howto, input_bfd, input_section,
1838                                    contents, rel->r_offset, relocation,
1839                                    rel->r_addend);
1840 }
1841
1842 \f
1843 /* Relocate an FRV ELF section.
1844
1845    The RELOCATE_SECTION function is called by the new ELF backend linker
1846    to handle the relocations for a section.
1847
1848    The relocs are always passed as Rela structures; if the section
1849    actually uses Rel structures, the r_addend field will always be
1850    zero.
1851
1852    This function is responsible for adjusting the section contents as
1853    necessary, and (if using Rela relocs and generating a relocatable
1854    output file) adjusting the reloc addend as necessary.
1855
1856    This function does not have to worry about setting the reloc
1857    address or the reloc symbol index.
1858
1859    LOCAL_SYMS is a pointer to the swapped in local symbols.
1860
1861    LOCAL_SECTIONS is an array giving the section in the input file
1862    corresponding to the st_shndx field of each local symbol.
1863
1864    The global hash table entry for the global symbols can be found
1865    via elf_sym_hashes (input_bfd).
1866
1867    When generating relocatable output, this function must handle
1868    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
1869    going to be the section symbol corresponding to the output
1870    section, which means that the addend must be adjusted
1871    accordingly.  */
1872
1873 static bfd_boolean
1874 elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
1875                             contents, relocs, local_syms, local_sections)
1876      bfd *output_bfd ATTRIBUTE_UNUSED;
1877      struct bfd_link_info *info;
1878      bfd *input_bfd;
1879      asection *input_section;
1880      bfd_byte *contents;
1881      Elf_Internal_Rela *relocs;
1882      Elf_Internal_Sym *local_syms;
1883      asection **local_sections;
1884 {
1885   Elf_Internal_Shdr *symtab_hdr;
1886   struct elf_link_hash_entry **sym_hashes;
1887   Elf_Internal_Rela *rel;
1888   Elf_Internal_Rela *relend;
1889   unsigned isec_segment, got_segment, plt_segment, gprel_segment,
1890     check_segment[2];
1891   int silence_segment_error = !(info->shared || info->pie);
1892
1893   if (info->relocatable)
1894     return TRUE;
1895
1896   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1897   sym_hashes = elf_sym_hashes (input_bfd);
1898   relend     = relocs + input_section->reloc_count;
1899
1900   isec_segment = _frvfdpic_osec_to_segment (output_bfd,
1901                                             input_section->output_section);
1902   if (IS_FDPIC (output_bfd) && frvfdpic_got_section (info))
1903     got_segment = _frvfdpic_osec_to_segment (output_bfd,
1904                                              frvfdpic_got_section (info)
1905                                              ->output_section);
1906   else
1907     got_segment = -1;
1908   if (IS_FDPIC (output_bfd) && frvfdpic_gotfixup_section (info))
1909     gprel_segment = _frvfdpic_osec_to_segment (output_bfd,
1910                                                frvfdpic_gotfixup_section (info)
1911                                                ->output_section);
1912   else
1913     gprel_segment = -1;
1914   if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created)
1915     plt_segment = _frvfdpic_osec_to_segment (output_bfd,
1916                                              frvfdpic_plt_section (info)
1917                                              ->output_section);
1918   else
1919     plt_segment = -1;
1920
1921   for (rel = relocs; rel < relend; rel ++)
1922     {
1923       reloc_howto_type *howto;
1924       unsigned long r_symndx;
1925       Elf_Internal_Sym *sym;
1926       asection *sec;
1927       struct elf_link_hash_entry *h;
1928       bfd_vma relocation;
1929       bfd_reloc_status_type r;
1930       const char * name = NULL;
1931       int r_type;
1932       asection *osec;
1933       struct frvfdpic_relocs_info *picrel;
1934       bfd_vma orig_addend = rel->r_addend;
1935
1936       r_type = ELF32_R_TYPE (rel->r_info);
1937
1938       if (   r_type == R_FRV_GNU_VTINHERIT
1939           || r_type == R_FRV_GNU_VTENTRY)
1940         continue;
1941
1942       /* This is a final link.  */
1943       r_symndx = ELF32_R_SYM (rel->r_info);
1944       howto  = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
1945       h      = NULL;
1946       sym    = NULL;
1947       sec    = NULL;
1948
1949       if (r_symndx < symtab_hdr->sh_info)
1950         {
1951           sym = local_syms + r_symndx;
1952           osec = sec = local_sections [r_symndx];
1953           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1954
1955           name = bfd_elf_string_from_elf_section
1956             (input_bfd, symtab_hdr->sh_link, sym->st_name);
1957           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
1958         }
1959       else
1960         {
1961           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
1962
1963           while (h->root.type == bfd_link_hash_indirect
1964                  || h->root.type == bfd_link_hash_warning)
1965             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1966
1967           name = h->root.root.string;
1968
1969           if ((h->root.type == bfd_link_hash_defined
1970                || h->root.type == bfd_link_hash_defweak)
1971               && ! FRVFDPIC_SYM_LOCAL (info, h))
1972             {
1973               sec = NULL;
1974               relocation = 0;
1975             }
1976           else
1977           if (h->root.type == bfd_link_hash_defined
1978               || h->root.type == bfd_link_hash_defweak)
1979             {
1980               sec = h->root.u.def.section;
1981               relocation = (h->root.u.def.value
1982                             + sec->output_section->vma
1983                             + sec->output_offset);
1984             }
1985           else if (h->root.type == bfd_link_hash_undefweak)
1986             {
1987               relocation = 0;
1988             }
1989           else if (info->unresolved_syms_in_objects == RM_IGNORE
1990                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
1991             relocation = 0;
1992           else
1993             {
1994               if (! ((*info->callbacks->undefined_symbol)
1995                      (info, h->root.root.string, input_bfd,
1996                       input_section, rel->r_offset,
1997                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
1998                        || ELF_ST_VISIBILITY (h->other)))))
1999                 return FALSE;
2000               relocation = 0;
2001             }
2002           osec = sec;
2003         }
2004
2005       switch (r_type)
2006         {
2007         case R_FRV_LABEL24:
2008         case R_FRV_32:
2009           if (! IS_FDPIC (output_bfd))
2010             goto non_fdpic;
2011
2012         case R_FRV_GOT12:
2013         case R_FRV_GOTHI:
2014         case R_FRV_GOTLO:
2015         case R_FRV_FUNCDESC_GOT12:
2016         case R_FRV_FUNCDESC_GOTHI:
2017         case R_FRV_FUNCDESC_GOTLO:
2018         case R_FRV_GOTOFF12:
2019         case R_FRV_GOTOFFHI:
2020         case R_FRV_GOTOFFLO:
2021         case R_FRV_FUNCDESC_GOTOFF12:
2022         case R_FRV_FUNCDESC_GOTOFFHI:
2023         case R_FRV_FUNCDESC_GOTOFFLO:
2024         case R_FRV_FUNCDESC:
2025         case R_FRV_FUNCDESC_VALUE:
2026           if (h != NULL)
2027             picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2028                                                       (info), input_bfd, h,
2029                                                       orig_addend, INSERT);
2030           else
2031             /* In order to find the entry we created before, we must
2032                use the original addend, not the one that may have been
2033                modified by _bfd_elf_rela_local_sym().  */
2034             picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2035                                                      (info), input_bfd, r_symndx,
2036                                                      orig_addend, INSERT);
2037           if (! picrel)
2038             return FALSE;
2039
2040           if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2041                                                       osec, sym,
2042                                                       rel->r_addend))
2043             {
2044               (*_bfd_error_handler)
2045                 (_("%s: relocation at `%s+0x%x' references symbol `%s' with nonzero addend"),
2046                  bfd_archive_filename (input_bfd), input_section->name,
2047                  rel->r_offset, name);
2048               return FALSE;
2049
2050             }
2051
2052           break;
2053
2054         default:
2055         non_fdpic:
2056           picrel = NULL;
2057           if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2058             {
2059               info->callbacks->warning
2060                 (info, _("relocation references symbol not defined in the module"),
2061                  name, input_bfd, input_section, rel->r_offset);
2062               return FALSE;
2063             }
2064           break;
2065         }
2066
2067       switch (r_type)
2068         {
2069         case R_FRV_LABEL24:
2070           check_segment[0] = isec_segment;
2071           if (! IS_FDPIC (output_bfd))
2072             check_segment[1] = isec_segment;
2073           else if (picrel->plt)
2074             {
2075               relocation = frvfdpic_plt_section (info)->output_section->vma
2076                 + frvfdpic_plt_section (info)->output_offset
2077                 + picrel->plt_entry;
2078               check_segment[1] = plt_segment;
2079             }
2080           /* We don't want to warn on calls to undefined weak symbols,
2081              as calls to them must be protected by non-NULL tests
2082              anyway, and unprotected calls would invoke undefined
2083              behavior.  */
2084           else if (picrel->symndx == -1
2085                    && picrel->d.h->root.type == bfd_link_hash_undefweak)
2086             check_segment[1] = check_segment[0];
2087           else
2088             check_segment[1] = sec
2089               ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
2090               : (unsigned)-1;
2091           break;
2092
2093         case R_FRV_GOT12:
2094         case R_FRV_GOTHI:
2095         case R_FRV_GOTLO:
2096           relocation = picrel->got_entry;
2097           check_segment[0] = check_segment[1] = got_segment;
2098           break;
2099
2100         case R_FRV_FUNCDESC_GOT12:
2101         case R_FRV_FUNCDESC_GOTHI:
2102         case R_FRV_FUNCDESC_GOTLO:
2103           relocation = picrel->fdgot_entry;
2104           check_segment[0] = check_segment[1] = got_segment;
2105           break;
2106
2107         case R_FRV_GOTOFFHI:
2108         case R_FRV_GOTOFF12:
2109         case R_FRV_GOTOFFLO:
2110           relocation -= frvfdpic_got_section (info)->output_section->vma
2111             + frvfdpic_got_section (info)->output_offset
2112             + frvfdpic_got_initial_offset (info);
2113           check_segment[0] = got_segment;
2114           check_segment[1] = sec
2115             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
2116             : (unsigned)-1;
2117           break;
2118
2119         case R_FRV_FUNCDESC_GOTOFF12:
2120         case R_FRV_FUNCDESC_GOTOFFHI:
2121         case R_FRV_FUNCDESC_GOTOFFLO:
2122           relocation = picrel->fd_entry;
2123           check_segment[0] = check_segment[1] = got_segment;
2124           break;
2125
2126         case R_FRV_FUNCDESC:
2127           {
2128             int dynindx;
2129             bfd_vma addend = rel->r_addend;
2130
2131             if (! (h && h->root.type == bfd_link_hash_undefweak
2132                    && FRVFDPIC_SYM_LOCAL (info, h)))
2133               {
2134                 /* If the symbol is dynamic and there may be dynamic
2135                    symbol resolution because we are or are linked with a
2136                    shared library, emit a FUNCDESC relocation such that
2137                    the dynamic linker will allocate the function
2138                    descriptor.  If the symbol needs a non-local function
2139                    descriptor but binds locally (e.g., its visibility is
2140                    protected, emit a dynamic relocation decayed to
2141                    section+offset.  */
2142                 if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
2143                     && FRVFDPIC_SYM_LOCAL (info, h)
2144                     && !(info->executable && !info->pie))
2145                   {
2146                     dynindx = elf_section_data (h->root.u.def.section
2147                                                 ->output_section)->dynindx;
2148                     addend += h->root.u.def.section->output_offset
2149                       + h->root.u.def.value;
2150                   }
2151                 else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
2152                   {
2153                     if (addend)
2154                       {
2155                         info->callbacks->warning
2156                           (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
2157                            name, input_bfd, input_section, rel->r_offset);
2158                         return FALSE;
2159                       }
2160                     dynindx = h->dynindx;
2161                   }
2162                 else
2163                   {
2164                     /* Otherwise, we know we have a private function
2165                        descriptor, so reference it directly.  */
2166                     BFD_ASSERT (picrel->privfd);
2167                     r_type = R_FRV_32;
2168                     dynindx = elf_section_data (frvfdpic_got_section (info)
2169                                                 ->output_section)->dynindx;
2170                     addend = frvfdpic_got_section (info)->output_offset
2171                       + frvfdpic_got_initial_offset (info)
2172                       + picrel->fd_entry;
2173                   }
2174
2175                 /* If there is room for dynamic symbol resolution, emit
2176                    the dynamic relocation.  However, if we're linking an
2177                    executable at a fixed location, we won't have emitted a
2178                    dynamic symbol entry for the got section, so idx will
2179                    be zero, which means we can and should compute the
2180                    address of the private descriptor ourselves.  */
2181                 if (info->executable && !info->pie
2182                     && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
2183                   {
2184                     addend += frvfdpic_got_section (info)->output_section->vma;
2185                     if ((bfd_get_section_flags (output_bfd,
2186                                                 input_section->output_section)
2187                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2188                       {
2189                         if (_frvfdpic_osec_readonly_p (output_bfd,
2190                                                        input_section
2191                                                        ->output_section))
2192                           {
2193                             info->callbacks->warning
2194                               (info,
2195                                _("cannot emit fixups in read-only section"),
2196                                name, input_bfd, input_section, rel->r_offset);
2197                             return FALSE;
2198                           }
2199                         _frvfdpic_add_rofixup (output_bfd,
2200                                                frvfdpic_gotfixup_section
2201                                                (info),
2202                                                _bfd_elf_section_offset
2203                                                (output_bfd, info,
2204                                                 input_section, rel->r_offset)
2205                                                + input_section
2206                                                ->output_section->vma
2207                                                + input_section->output_offset,
2208                                                picrel);
2209                       }
2210                   }
2211                 else if ((bfd_get_section_flags (output_bfd,
2212                                                  input_section->output_section)
2213                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2214                   {
2215                     if (_frvfdpic_osec_readonly_p (output_bfd,
2216                                                    input_section
2217                                                    ->output_section))
2218                       {
2219                         info->callbacks->warning
2220                           (info,
2221                            _("cannot emit dynamic relocations in read-only section"),
2222                            name, input_bfd, input_section, rel->r_offset);
2223                         return FALSE;
2224                       }
2225                     _frvfdpic_add_dyn_reloc (output_bfd,
2226                                              frvfdpic_gotrel_section (info),
2227                                              _bfd_elf_section_offset
2228                                              (output_bfd, info,
2229                                               input_section, rel->r_offset)
2230                                              + input_section
2231                                              ->output_section->vma
2232                                              + input_section->output_offset,
2233                                              r_type, dynindx, addend, picrel);
2234                   }
2235                 else
2236                   addend += frvfdpic_got_section (info)->output_section->vma;
2237               }
2238
2239             /* We want the addend in-place because dynamic
2240                relocations are REL.  Setting relocation to it should
2241                arrange for it to be installed.  */
2242             relocation = addend - rel->r_addend;
2243           }
2244           check_segment[0] = check_segment[1] = got_segment;
2245           break;
2246
2247         case R_FRV_32:
2248           if (! IS_FDPIC (output_bfd))
2249             {
2250               check_segment[0] = check_segment[1] = -1;
2251               break;
2252             }
2253           /* Fall through.  */
2254         case R_FRV_FUNCDESC_VALUE:
2255           {
2256             int dynindx;
2257             bfd_vma addend = rel->r_addend;
2258
2259             /* If the symbol is dynamic but binds locally, use
2260                section+offset.  */
2261             if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2262               {
2263                 if (addend && r_type == R_FRV_FUNCDESC_VALUE)
2264                   {
2265                     info->callbacks->warning
2266                       (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2267                        name, input_bfd, input_section, rel->r_offset);
2268                     return FALSE;
2269                   }
2270                 dynindx = h->dynindx;
2271               }
2272             else
2273               {
2274                 if (h)
2275                   addend += h->root.u.def.value;
2276                 else
2277                   addend += sym->st_value;
2278                 if (osec)
2279                   addend += osec->output_offset;
2280                 if (osec && osec->output_section
2281                     && ! bfd_is_abs_section (osec->output_section)
2282                     && ! bfd_is_und_section (osec->output_section))
2283                   dynindx = elf_section_data (osec->output_section)->dynindx;
2284                 else
2285                   dynindx = 0;
2286               }
2287
2288             /* If we're linking an executable at a fixed address, we
2289                can omit the dynamic relocation as long as the symbol
2290                is defined in the current link unit (which is implied
2291                by its output section not being NULL).  */
2292             if (info->executable && !info->pie
2293                 && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
2294               {
2295                 if (osec)
2296                   addend += osec->output_section->vma;
2297                 if (IS_FDPIC (input_bfd)
2298                     && (bfd_get_section_flags (output_bfd,
2299                                                input_section->output_section)
2300                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2301                   {
2302                     if (_frvfdpic_osec_readonly_p (output_bfd,
2303                                                    input_section
2304                                                    ->output_section))
2305                       {
2306                         info->callbacks->warning
2307                           (info,
2308                            _("cannot emit fixups in read-only section"),
2309                            name, input_bfd, input_section, rel->r_offset);
2310                         return FALSE;
2311                       }
2312                     if (!h || h->root.type != bfd_link_hash_undefweak)
2313                       {
2314                         _frvfdpic_add_rofixup (output_bfd,
2315                                                frvfdpic_gotfixup_section
2316                                                (info),
2317                                                _bfd_elf_section_offset
2318                                                (output_bfd, info,
2319                                                 input_section, rel->r_offset)
2320                                                + input_section
2321                                                ->output_section->vma
2322                                                + input_section->output_offset,
2323                                                picrel);
2324                         if (r_type == R_FRV_FUNCDESC_VALUE)
2325                           _frvfdpic_add_rofixup
2326                             (output_bfd,
2327                              frvfdpic_gotfixup_section (info),
2328                              _bfd_elf_section_offset
2329                              (output_bfd, info,
2330                               input_section, rel->r_offset)
2331                              + input_section->output_section->vma
2332                              + input_section->output_offset + 4, picrel);
2333                       }
2334                   }
2335               }
2336             else
2337               {
2338                 if ((bfd_get_section_flags (output_bfd,
2339                                             input_section->output_section)
2340                      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2341                   {
2342                     if (_frvfdpic_osec_readonly_p (output_bfd,
2343                                                    input_section
2344                                                    ->output_section))
2345                       {
2346                         info->callbacks->warning
2347                           (info,
2348                            _("cannot emit dynamic relocations in read-only section"),
2349                            name, input_bfd, input_section, rel->r_offset);
2350                         return FALSE;
2351                       }
2352                     _frvfdpic_add_dyn_reloc (output_bfd,
2353                                              frvfdpic_gotrel_section (info),
2354                                              _bfd_elf_section_offset
2355                                              (output_bfd, info,
2356                                               input_section, rel->r_offset)
2357                                              + input_section
2358                                              ->output_section->vma
2359                                              + input_section->output_offset,
2360                                              r_type, dynindx, addend, picrel);
2361                   }
2362                 else if (osec)
2363                   addend += osec->output_section->vma;
2364                 /* We want the addend in-place because dynamic
2365                    relocations are REL.  Setting relocation to it
2366                    should arrange for it to be installed.  */
2367                 relocation = addend - rel->r_addend;
2368               }
2369
2370             if (r_type == R_FRV_FUNCDESC_VALUE)
2371               {
2372                 /* If we've omitted the dynamic relocation, just emit
2373                    the fixed addresses of the symbol and of the local
2374                    GOT base offset.  */
2375                 if (info->executable && !info->pie
2376                     && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
2377                   bfd_put_32 (output_bfd,
2378                               frvfdpic_got_section (info)->output_section->vma
2379                               + frvfdpic_got_section (info)->output_offset
2380                               + frvfdpic_got_initial_offset (info),
2381                               contents + rel->r_offset + 4);
2382                 else
2383                   /* A function descriptor used for lazy or local
2384                      resolving is initialized such that its high word
2385                      contains the output section index in which the
2386                      PLT entries are located, and the low word
2387                      contains the offset of the lazy PLT entry entry
2388                      point into that section.  */
2389                   bfd_put_32 (output_bfd,
2390                               h && ! FRVFDPIC_SYM_LOCAL (info, h)
2391                               ? 0
2392                               : _frvfdpic_osec_to_segment (output_bfd,
2393                                                            sec
2394                                                            ->output_section),
2395                               contents + rel->r_offset + 4);
2396               }
2397           }
2398           check_segment[0] = check_segment[1] = got_segment;
2399           break;
2400
2401         case R_FRV_GPREL12:
2402         case R_FRV_GPRELU12:
2403         case R_FRV_GPREL32:
2404         case R_FRV_GPRELHI:
2405         case R_FRV_GPRELLO:
2406           check_segment[0] = gprel_segment;
2407           check_segment[1] = sec
2408             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
2409             : (unsigned)-1;
2410           break;
2411
2412         default:
2413           check_segment[0] = isec_segment;
2414           check_segment[1] = sec
2415             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
2416             : (unsigned)-1;
2417           break;
2418         }
2419
2420       if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
2421         {
2422 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
2423          in the ld testsuite.  */
2424           /* This helps catch problems in GCC while we can't do more
2425              than static linking.  The idea is to test whether the
2426              input file basename is crt0.o only once.  */
2427           if (silence_segment_error == 1)
2428             silence_segment_error =
2429               (strlen (input_bfd->filename) == 6
2430                && strcmp (input_bfd->filename, "crt0.o") == 0)
2431               || (strlen (input_bfd->filename) > 6
2432                   && strcmp (input_bfd->filename
2433                              + strlen (input_bfd->filename) - 7,
2434                              "/crt0.o") == 0)
2435               ? -1 : 0;
2436 #endif
2437           if (!silence_segment_error
2438               /* We don't want duplicate errors for undefined
2439                  symbols.  */
2440               && !(picrel && picrel->symndx == -1
2441                    && picrel->d.h->root.type == bfd_link_hash_undefined))
2442             info->callbacks->warning
2443               (info,
2444                (info->shared || info->pie)
2445                ? _("relocations between different segments are not supported")
2446                : _("warning: relocation references a different segment"),
2447                name, input_bfd, input_section, rel->r_offset);
2448           if (!silence_segment_error && (info->shared || info->pie))
2449             return FALSE;
2450           elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
2451         }
2452
2453       switch (r_type)
2454         {
2455         case R_FRV_GOTOFFHI:
2456           /* We need the addend to be applied before we shift the
2457              value right.  */
2458           relocation += rel->r_addend;
2459           /* Fall through.  */
2460         case R_FRV_GOTHI:
2461         case R_FRV_FUNCDESC_GOTHI:
2462         case R_FRV_FUNCDESC_GOTOFFHI:
2463           relocation >>= 16;
2464           /* Fall through.  */
2465
2466         case R_FRV_GOTLO:
2467         case R_FRV_FUNCDESC_GOTLO:
2468         case R_FRV_GOTOFFLO:
2469         case R_FRV_FUNCDESC_GOTOFFLO:
2470           relocation &= 0xffff;
2471           break;
2472
2473         default:
2474           break;
2475         }
2476
2477       switch (r_type)
2478         {
2479         case R_FRV_LABEL24:
2480           if (! IS_FDPIC (output_bfd) || ! picrel->plt)
2481             break;
2482           /* Fall through.  */
2483
2484           /* When referencing a GOT entry, a function descriptor or a
2485              PLT, we don't want the addend to apply to the reference,
2486              but rather to the referenced symbol.  The actual entry
2487              will have already been created taking the addend into
2488              account, so cancel it out here.  */
2489         case R_FRV_GOT12:
2490         case R_FRV_GOTHI:
2491         case R_FRV_GOTLO:
2492         case R_FRV_FUNCDESC_GOT12:
2493         case R_FRV_FUNCDESC_GOTHI:
2494         case R_FRV_FUNCDESC_GOTLO:
2495         case R_FRV_FUNCDESC_GOTOFF12:
2496         case R_FRV_FUNCDESC_GOTOFFHI:
2497         case R_FRV_FUNCDESC_GOTOFFLO:
2498           /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
2499              here, since we do want to apply the addend to the others.
2500              Note that we've applied the addend to GOTOFFHI before we
2501              shifted it right.  */
2502         case R_FRV_GOTOFFHI:
2503           relocation -= rel->r_addend;
2504           break;
2505
2506         default:
2507           break;
2508         }
2509
2510      if (r_type == R_FRV_HI16)
2511        r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
2512
2513      else if (r_type == R_FRV_LO16)
2514        r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
2515
2516      else if (r_type == R_FRV_LABEL24)
2517        r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
2518                                        contents, relocation);
2519
2520      else if (r_type == R_FRV_GPREL12)
2521        r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
2522                                        contents, relocation);
2523
2524      else if (r_type == R_FRV_GPRELU12)
2525        r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
2526                                         contents, relocation);
2527
2528      else if (r_type == R_FRV_GPRELLO)
2529        r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
2530                                        contents, relocation);
2531
2532      else if (r_type == R_FRV_GPRELHI)
2533        r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
2534                                        contents, relocation);
2535
2536      else
2537        r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
2538                                     rel, relocation);
2539
2540       if (r != bfd_reloc_ok)
2541         {
2542           const char * msg = (const char *) NULL;
2543
2544           switch (r)
2545             {
2546             case bfd_reloc_overflow:
2547               r = info->callbacks->reloc_overflow
2548                 (info, name, howto->name, (bfd_vma) 0,
2549                  input_bfd, input_section, rel->r_offset);
2550               break;
2551
2552             case bfd_reloc_undefined:
2553               r = info->callbacks->undefined_symbol
2554                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
2555               break;
2556
2557             case bfd_reloc_outofrange:
2558               msg = _("internal error: out of range error");
2559               break;
2560
2561             case bfd_reloc_notsupported:
2562               msg = _("internal error: unsupported relocation error");
2563               break;
2564
2565             case bfd_reloc_dangerous:
2566               msg = _("internal error: dangerous relocation");
2567               break;
2568
2569             default:
2570               msg = _("internal error: unknown error");
2571               break;
2572             }
2573
2574           if (msg)
2575             r = info->callbacks->warning
2576               (info, msg, name, input_bfd, input_section, rel->r_offset);
2577
2578           if (! r)
2579             return FALSE;
2580         }
2581     }
2582
2583   return TRUE;
2584 }
2585 \f
2586 /* Return the section that should be marked against GC for a given
2587    relocation.  */
2588
2589 static asection *
2590 elf32_frv_gc_mark_hook (sec, info, rel, h, sym)
2591      asection *sec;
2592      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2593      Elf_Internal_Rela *rel;
2594      struct elf_link_hash_entry *h;
2595      Elf_Internal_Sym *sym;
2596 {
2597   if (h != NULL)
2598     {
2599       switch (ELF32_R_TYPE (rel->r_info))
2600         {
2601         case R_FRV_GNU_VTINHERIT:
2602         case R_FRV_GNU_VTENTRY:
2603           break;
2604
2605         default:
2606           switch (h->root.type)
2607             {
2608             default:
2609               break;
2610
2611             case bfd_link_hash_defined:
2612             case bfd_link_hash_defweak:
2613               return h->root.u.def.section;
2614
2615             case bfd_link_hash_common:
2616               return h->root.u.c.p->section;
2617             }
2618         }
2619     }
2620   else
2621     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
2622
2623   return NULL;
2624 }
2625
2626 /* Update the got entry reference counts for the section being removed.  */
2627
2628 static bfd_boolean
2629 elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)
2630      bfd *abfd ATTRIBUTE_UNUSED;
2631      struct bfd_link_info *info ATTRIBUTE_UNUSED;
2632      asection *sec ATTRIBUTE_UNUSED;
2633      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
2634 {
2635   return TRUE;
2636 }
2637
2638 \f
2639 /* Hook called by the linker routine which adds symbols from an object
2640    file.  We use it to put .comm items in .scomm, and not .comm.  */
2641
2642 static bfd_boolean
2643 elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
2644      bfd *abfd;
2645      struct bfd_link_info *info;
2646      Elf_Internal_Sym *sym;
2647      const char **namep ATTRIBUTE_UNUSED;
2648      flagword *flagsp ATTRIBUTE_UNUSED;
2649      asection **secp;
2650      bfd_vma *valp;
2651 {
2652   if (sym->st_shndx == SHN_COMMON
2653       && !info->relocatable
2654       && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
2655     {
2656       /* Common symbols less than or equal to -G nn bytes are
2657          automatically put into .sbss.  */
2658
2659       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
2660
2661       if (scomm == NULL)
2662         {
2663           scomm = bfd_make_section (abfd, ".scommon");
2664           if (scomm == NULL
2665               || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
2666                                                        | SEC_IS_COMMON
2667                                                        | SEC_LINKER_CREATED)))
2668             return FALSE;
2669         }
2670
2671       *secp = scomm;
2672       *valp = sym->st_size;
2673     }
2674
2675   return TRUE;
2676 }
2677
2678 /* We need dynamic symbols for every section, since segments can
2679    relocate independently.  */
2680 static bfd_boolean
2681 _frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
2682                                     struct bfd_link_info *info
2683                                     ATTRIBUTE_UNUSED,
2684                                     asection *p ATTRIBUTE_UNUSED)
2685 {
2686   switch (elf_section_data (p)->this_hdr.sh_type)
2687     {
2688     case SHT_PROGBITS:
2689     case SHT_NOBITS:
2690       /* If sh_type is yet undecided, assume it could be
2691          SHT_PROGBITS/SHT_NOBITS.  */
2692     case SHT_NULL:
2693       return FALSE;
2694
2695       /* There shouldn't be section relative relocations
2696          against any other section.  */
2697     default:
2698       return TRUE;
2699     }
2700 }
2701
2702 /* Create  a .got section, as well as its additional info field.  This
2703    is almost entirely copied from
2704    elflink.c:_bfd_elf_create_got_section().  */
2705
2706 static bfd_boolean
2707 _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
2708 {
2709   flagword flags;
2710   asection *s;
2711   struct elf_link_hash_entry *h;
2712   struct bfd_link_hash_entry *bh;
2713   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2714   int ptralign;
2715   int offset;
2716
2717   /* This function may be called more than once.  */
2718   s = bfd_get_section_by_name (abfd, ".got");
2719   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
2720     return TRUE;
2721
2722   /* Machine specific: although pointers are 32-bits wide, we want the
2723      GOT to be aligned to a 64-bit boundary, such that function
2724      descriptors in it can be accessed with 64-bit loads and
2725      stores.  */
2726   ptralign = 3;
2727
2728   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2729            | SEC_LINKER_CREATED);
2730
2731   s = bfd_make_section (abfd, ".got");
2732   if (s == NULL
2733       || !bfd_set_section_flags (abfd, s, flags)
2734       || !bfd_set_section_alignment (abfd, s, ptralign))
2735     return FALSE;
2736
2737   if (bed->want_got_plt)
2738     {
2739       s = bfd_make_section (abfd, ".got.plt");
2740       if (s == NULL
2741           || !bfd_set_section_flags (abfd, s, flags)
2742           || !bfd_set_section_alignment (abfd, s, ptralign))
2743         return FALSE;
2744     }
2745
2746   if (bed->want_got_sym)
2747     {
2748       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
2749          (or .got.plt) section.  We don't do this in the linker script
2750          because we don't want to define the symbol if we are not creating
2751          a global offset table.  */
2752       bh = NULL;
2753       if (!(_bfd_generic_link_add_one_symbol
2754             (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
2755              bed->got_symbol_offset, (const char *) NULL, FALSE,
2756              bed->collect, &bh)))
2757         return FALSE;
2758       h = (struct elf_link_hash_entry *) bh;
2759       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2760       h->type = STT_OBJECT;
2761
2762       /* Machine-specific: we want the symbol for executables as
2763          well.  */
2764       if (! bfd_elf_link_record_dynamic_symbol (info, h))
2765         return FALSE;
2766
2767       elf_hash_table (info)->hgot = h;
2768     }
2769
2770   /* The first bit of the global offset table is the header.  */
2771   s->size += bed->got_header_size + bed->got_symbol_offset;
2772
2773   /* This is the machine-specific part.  Create and initialize section
2774      data for the got.  */
2775   if (IS_FDPIC (abfd))
2776     {
2777       frvfdpic_got_section (info) = s;
2778       frvfdpic_relocs_info (info) = htab_try_create (1, frvfdpic_relocs_info_hash,
2779                                                      frvfdpic_relocs_info_eq,
2780                                                      (htab_del) NULL);
2781       if (! frvfdpic_relocs_info (info))
2782         return FALSE;
2783
2784       s = bfd_make_section (abfd, ".rel.got");
2785       if (s == NULL
2786           || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
2787           || ! bfd_set_section_alignment (abfd, s, 2))
2788         return FALSE;
2789
2790       frvfdpic_gotrel_section (info) = s;
2791
2792       /* Machine-specific.  */
2793       s = bfd_make_section (abfd, ".rofixup");
2794       if (s == NULL
2795           || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
2796           || ! bfd_set_section_alignment (abfd, s, 2))
2797         return FALSE;
2798
2799       frvfdpic_gotfixup_section (info) = s;
2800       offset = -2048;
2801       flags = BSF_GLOBAL;
2802     }
2803   else
2804     {
2805       offset = 2048;
2806       flags = BSF_GLOBAL | BSF_WEAK;
2807     }
2808
2809   /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
2810      turns out that we're linking with a different linker script, the
2811      linker script will override it.  */
2812   bh = NULL;
2813   if (!(_bfd_generic_link_add_one_symbol
2814         (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
2815          bed->collect, &bh)))
2816     return FALSE;
2817   h = (struct elf_link_hash_entry *) bh;
2818   h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2819   h->type = STT_OBJECT;
2820
2821   /* Machine-specific: we want the symbol for executables as well.  */
2822   if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
2823     return FALSE;
2824
2825   return TRUE;
2826 }
2827
2828 /* Make sure the got and plt sections exist, and that our pointers in
2829    the link hash table point to them.  */
2830
2831 static bfd_boolean
2832 elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2833 {
2834   /* This is mostly copied from
2835      elflink.c:_bfd_elf_create_dynamic_sections().  */
2836   flagword flags, pltflags;
2837   asection *s;
2838   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2839
2840   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2841      .rel[a].bss sections.  */
2842
2843   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2844            | SEC_LINKER_CREATED);
2845
2846   pltflags = flags;
2847   pltflags |= SEC_CODE;
2848   if (bed->plt_not_loaded)
2849     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
2850   if (bed->plt_readonly)
2851     pltflags |= SEC_READONLY;
2852
2853   s = bfd_make_section (abfd, ".plt");
2854   if (s == NULL
2855       || ! bfd_set_section_flags (abfd, s, pltflags)
2856       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2857     return FALSE;
2858   /* FRV-specific: remember it.  */
2859   frvfdpic_plt_section (info) = s;
2860
2861   if (bed->want_plt_sym)
2862     {
2863       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2864          .plt section.  */
2865       struct elf_link_hash_entry *h;
2866       struct bfd_link_hash_entry *bh = NULL;
2867
2868       if (! (_bfd_generic_link_add_one_symbol
2869              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
2870               FALSE, get_elf_backend_data (abfd)->collect, &bh)))
2871         return FALSE;
2872       h = (struct elf_link_hash_entry *) bh;
2873       h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
2874       h->type = STT_OBJECT;
2875
2876       if (! info->executable
2877           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2878         return FALSE;
2879     }
2880
2881   /* FRV-specific: we want rel relocations for the plt.  */
2882   s = bfd_make_section (abfd, ".rel.plt");
2883   if (s == NULL
2884       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2885       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
2886     return FALSE;
2887   /* FRV-specific: remember it.  */
2888   frvfdpic_pltrel_section (info) = s;
2889
2890   /* FRV-specific: we want to create the GOT in the FRV way.  */
2891   if (! _frv_create_got_section (abfd, info))
2892     return FALSE;
2893
2894   /* FRV-specific: make sure we created everything we wanted.  */
2895   BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
2896               && frvfdpic_gotfixup_section (info)
2897               && frvfdpic_plt_section (info)
2898               && frvfdpic_pltrel_section (info));
2899
2900   if (bed->want_dynbss)
2901     {
2902       /* The .dynbss section is a place to put symbols which are defined
2903          by dynamic objects, are referenced by regular objects, and are
2904          not functions.  We must allocate space for them in the process
2905          image and use a R_*_COPY reloc to tell the dynamic linker to
2906          initialize them at run time.  The linker script puts the .dynbss
2907          section into the .bss section of the final image.  */
2908       s = bfd_make_section (abfd, ".dynbss");
2909       if (s == NULL
2910           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
2911         return FALSE;
2912
2913       /* The .rel[a].bss section holds copy relocs.  This section is not
2914      normally needed.  We need to create it here, though, so that the
2915      linker will map it to an output section.  We can't just create it
2916      only if we need it, because we will not know whether we need it
2917      until we have seen all the input files, and the first time the
2918      main linker code calls BFD after examining all the input files
2919      (size_dynamic_sections) the input sections have already been
2920      mapped to the output sections.  If the section turns out not to
2921      be needed, we can discard it later.  We will never need this
2922      section when generating a shared object, since they do not use
2923      copy relocs.  */
2924       if (! info->shared)
2925         {
2926           s = bfd_make_section (abfd,
2927                                 (bed->default_use_rela_p
2928                                  ? ".rela.bss" : ".rel.bss"));
2929           if (s == NULL
2930               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
2931               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
2932             return FALSE;
2933         }
2934     }
2935
2936   return TRUE;
2937 }
2938
2939 /* The name of the dynamic interpreter.  This is put in the .interp
2940    section.  */
2941
2942 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
2943
2944 #define DEFAULT_STACK_SIZE 0x20000
2945
2946 /* This structure is used to collect the number of entries present in
2947    each addressable range of the got.  */
2948 struct _frvfdpic_dynamic_got_info
2949 {
2950   /* Several bits of information about the current link.  */
2951   struct bfd_link_info *info;
2952   /* Total size needed for GOT entries within the 12-, 16- or 32-bit
2953      ranges.  */
2954   bfd_vma got12, gotlos, gothilo;
2955   /* Total size needed for function descriptor entries within the 12-,
2956      16- or 32-bit ranges.  */
2957   bfd_vma fd12, fdlos, fdhilo;
2958   /* Total size needed function descriptor entries referenced in PLT
2959      entries, that would be profitable to place in offsets close to
2960      the PIC register.  */
2961   bfd_vma fdplt;
2962   /* Total size needed by lazy PLT entries.  */
2963   bfd_vma lzplt;
2964   /* Number of relocations carried over from input object files.  */
2965   unsigned long relocs;
2966   /* Number of fixups introduced by relocations in input object files.  */
2967   unsigned long fixups;
2968 };
2969
2970 /* Compute the total GOT size required by each symbol in each range.
2971    Symbols may require up to 4 words in the GOT: an entry pointing to
2972    the symbol, an entry pointing to its function descriptor, and a
2973    private function descriptors taking two words.  */
2974
2975 static int
2976 _frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
2977 {
2978   struct frvfdpic_relocs_info *entry = *entryp;
2979   struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
2980   unsigned relocs = 0, fixups = 0;
2981
2982   /* Allocate space for a GOT entry pointing to the symbol.  */
2983   if (entry->got12)
2984     dinfo->got12 += 4;
2985   else if (entry->gotlos)
2986     dinfo->gotlos += 4;
2987   else if (entry->gothilo)
2988     dinfo->gothilo += 4;
2989   else
2990     entry->relocs32--;
2991   entry->relocs32++;
2992
2993   /* Allocate space for a GOT entry pointing to the function
2994      descriptor.  */
2995   if (entry->fdgot12)
2996     dinfo->got12 += 4;
2997   else if (entry->fdgotlos)
2998     dinfo->gotlos += 4;
2999   else if (entry->fdgothilo)
3000     dinfo->gothilo += 4;
3001   else
3002     entry->relocsfd--;
3003   entry->relocsfd++;
3004
3005   /* Decide whether we need a PLT entry, a function descriptor in the
3006      GOT, and a lazy PLT entry for this symbol.  */
3007   entry->plt = entry->call
3008     && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3009     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3010   entry->privfd = entry->plt
3011     || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
3012     || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
3013         && (entry->symndx != -1
3014             || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3015   entry->lazyplt = entry->privfd
3016     && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3017     && ! (dinfo->info->flags & DF_BIND_NOW)
3018     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3019
3020   /* Allocate space for a function descriptor.  */
3021   if (entry->fdgoff12)
3022     dinfo->fd12 += 8;
3023   else if (entry->fdgofflos)
3024     dinfo->fdlos += 8;
3025   else if (entry->privfd && entry->plt)
3026     dinfo->fdplt += 8;
3027   else if (entry->privfd)
3028     dinfo->fdhilo += 8;
3029   else
3030     entry->relocsfdv--;
3031   entry->relocsfdv++;
3032
3033   if (entry->lazyplt)
3034     dinfo->lzplt += 8;
3035
3036   if (!dinfo->info->executable || dinfo->info->pie)
3037     relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3038   else
3039     {
3040       if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3041         {
3042           if (entry->symndx != -1
3043               || entry->d.h->root.type != bfd_link_hash_undefweak)
3044             fixups += entry->relocs32 + 2 * entry->relocsfdv;
3045         }
3046       else
3047         relocs += entry->relocs32 + entry->relocsfdv;
3048
3049       if (entry->symndx != -1
3050           || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3051         {
3052           if (entry->symndx != -1
3053               || entry->d.h->root.type != bfd_link_hash_undefweak)
3054             fixups += entry->relocsfd;
3055         }
3056       else
3057         relocs += entry->relocsfd;
3058     }
3059
3060   entry->dynrelocs += relocs;
3061   entry->fixups += fixups;
3062   dinfo->relocs += relocs;
3063   dinfo->fixups += fixups;
3064
3065   return 1;
3066 }
3067
3068 /* This structure is used to assign offsets to got entries, function
3069    descriptors, plt entries and lazy plt entries.  */
3070
3071 struct _frvfdpic_dynamic_got_plt_info
3072 {
3073   /* Summary information collected with _frvfdpic_count_got_plt_entries.  */
3074   struct _frvfdpic_dynamic_got_info g;
3075
3076   /* For each addressable range, we record a MAX (positive) and MIN
3077      (negative) value.  CUR is used to assign got entries, and it's
3078      incremented from an initial positive value to MAX, then from MIN
3079      to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
3080      assign function descriptors, and it's decreased from an initial
3081      non-positive value to MIN, then from MAX down to CUR (unless CUR
3082      wraps around first).  All of MIN, MAX, CUR and FDCUR always point
3083      to even words.  ODD, if non-zero, indicates an odd word to be
3084      used for the next got entry, otherwise CUR is used and
3085      incremented by a pair of words, wrapping around when it reaches
3086      MAX.  FDCUR is decremented (and wrapped) before the next function
3087      descriptor is chosen.  FDPLT indicates the number of remaining
3088      slots that can be used for function descriptors used only by PLT
3089      entries.  */
3090   struct _frvfdpic_dynamic_got_alloc_data
3091   {
3092     bfd_signed_vma max, cur, odd, fdcur, min;
3093     bfd_vma fdplt;
3094   } got12, gotlos, gothilo;
3095 };
3096
3097 /* Determine the positive and negative ranges to be used by each
3098    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
3099    double-word boundary, are the minimum (negative) and maximum
3100    (positive) GOT offsets already used by previous ranges, except for
3101    an ODD entry that may have been left behind.  GOT and FD indicate
3102    the size of GOT entries and function descriptors that must be
3103    placed within the range from -WRAP to WRAP.  If there's room left,
3104    up to FDPLT bytes should be reserved for additional function
3105    descriptors.  */
3106
3107 inline static bfd_signed_vma
3108 _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
3109                                   bfd_signed_vma fdcur,
3110                                   bfd_signed_vma odd,
3111                                   bfd_signed_vma cur,
3112                                   bfd_vma got,
3113                                   bfd_vma fd,
3114                                   bfd_vma fdplt,
3115                                   bfd_vma wrap)
3116 {
3117   bfd_signed_vma wrapmin = -wrap;
3118
3119   /* Start at the given initial points.  */
3120   gad->fdcur = fdcur;
3121   gad->cur = cur;
3122
3123   /* If we had an incoming odd word and we have any got entries that
3124      are going to use it, consume it, otherwise leave gad->odd at
3125      zero.  We might force gad->odd to zero and return the incoming
3126      odd such that it is used by the next range, but then GOT entries
3127      might appear to be out of order and we wouldn't be able to
3128      shorten the GOT by one word if it turns out to end with an
3129      unpaired GOT entry.  */
3130   if (odd && got)
3131     {
3132       gad->odd = odd;
3133       got -= 4;
3134       odd = 0;
3135     }
3136   else
3137     gad->odd = 0;
3138
3139   /* If we're left with an unpaired GOT entry, compute its location
3140      such that we can return it.  Otherwise, if got doesn't require an
3141      odd number of words here, either odd was already zero in the
3142      block above, or it was set to zero because got was non-zero, or
3143      got was already zero.  In the latter case, we want the value of
3144      odd to carry over to the return statement, so we don't want to
3145      reset odd unless the condition below is true.  */
3146   if (got & 4)
3147     {
3148       odd = cur + got;
3149       got += 4;
3150     }
3151
3152   /* Compute the tentative boundaries of this range.  */
3153   gad->max = cur + got;
3154   gad->min = fdcur - fd;
3155   gad->fdplt = 0;
3156
3157   /* If function descriptors took too much space, wrap some of them
3158      around.  */
3159   if (gad->min < wrapmin)
3160     {
3161       gad->max += wrapmin - gad->min;
3162       gad->min = wrapmin;
3163     }
3164   /* If there is space left and we have function descriptors
3165      referenced in PLT entries that could take advantage of shorter
3166      offsets, place them here.  */
3167   else if (fdplt && gad->min > wrapmin)
3168     {
3169       bfd_vma fds;
3170       if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3171         fds = gad->min - wrapmin;
3172       else
3173         fds = fdplt;
3174
3175       fdplt -= fds;
3176       gad->min -= fds;
3177       gad->fdplt += fds;
3178     }
3179
3180   /* If GOT entries took too much space, wrap some of them around.
3181      This may well cause gad->min to become lower than wrapmin.  This
3182      will cause a relocation overflow later on, so we don't have to
3183      report it here . */
3184   if ((bfd_vma) gad->max > wrap)
3185     {
3186       gad->min -= gad->max - wrap;
3187       gad->max = wrap;
3188     }
3189   /* If there is more space left, try to place some more function
3190      descriptors for PLT entries.  */
3191   else if (fdplt && (bfd_vma) gad->max < wrap)
3192     {
3193       bfd_vma fds;
3194       if ((bfd_vma) (wrap - gad->max) < fdplt)
3195         fds = wrap - gad->max;
3196       else
3197         fds = fdplt;
3198
3199       fdplt -= fds;
3200       gad->max += fds;
3201       gad->fdplt += fds;
3202     }
3203
3204   /* If odd was initially computed as an offset past the wrap point,
3205      wrap it around.  */
3206   if (odd > gad->max)
3207     odd = gad->min + odd - gad->max;
3208
3209   /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
3210      before returning, so do it here too.  This guarantees that,
3211      should cur and fdcur meet at the wrap point, they'll both be
3212      equal to min.  */
3213   if (gad->cur == gad->max)
3214     gad->cur = gad->min;
3215
3216   return odd;
3217 }
3218
3219 /* Compute the location of the next GOT entry, given the allocation
3220    data for a range.  */
3221
3222 inline static bfd_signed_vma
3223 _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
3224 {
3225   bfd_signed_vma ret;
3226
3227   if (gad->odd)
3228     {
3229       /* If there was an odd word left behind, use it.  */
3230       ret = gad->odd;
3231       gad->odd = 0;
3232     }
3233   else
3234     {
3235       /* Otherwise, use the word pointed to by cur, reserve the next
3236          as an odd word, and skip to the next pair of words, possibly
3237          wrapping around.  */
3238       ret = gad->cur;
3239       gad->odd = gad->cur + 4;
3240       gad->cur += 8;
3241       if (gad->cur == gad->max)
3242         gad->cur = gad->min;
3243     }
3244
3245   return ret;
3246 }
3247
3248 /* Compute the location of the next function descriptor entry in the
3249    GOT, given the allocation data for a range.  */
3250
3251 inline static bfd_signed_vma
3252 _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
3253 {
3254   /* If we're at the bottom, wrap around, and only then allocate the
3255      next pair of words.  */
3256   if (gad->fdcur == gad->min)
3257     gad->fdcur = gad->max;
3258   return gad->fdcur -= 8;
3259 }
3260
3261 /* Assign GOT offsets for every GOT entry and function descriptor.
3262    Doing everything in a single pass is tricky.  */
3263
3264 static int
3265 _frvfdpic_assign_got_entries (void **entryp, void *info_)
3266 {
3267   struct frvfdpic_relocs_info *entry = *entryp;
3268   struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
3269
3270   if (entry->got12)
3271     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
3272   else if (entry->gotlos)
3273     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
3274   else if (entry->gothilo)
3275     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
3276
3277   if (entry->fdgot12)
3278     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
3279   else if (entry->fdgotlos)
3280     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
3281   else if (entry->fdgothilo)
3282     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
3283
3284   if (entry->fdgoff12)
3285     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
3286   else if (entry->plt && dinfo->got12.fdplt)
3287     {
3288       dinfo->got12.fdplt -= 8;
3289       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
3290     }
3291   else if (entry->fdgofflos)
3292     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
3293   else if (entry->plt && dinfo->gotlos.fdplt)
3294     {
3295       dinfo->gotlos.fdplt -= 8;
3296       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
3297     }
3298   else if (entry->plt)
3299     {
3300       dinfo->gothilo.fdplt -= 8;
3301       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
3302     }
3303   else if (entry->privfd)
3304     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
3305
3306   return 1;
3307 }
3308
3309 /* Assign GOT offsets to private function descriptors used by PLT
3310    entries (or referenced by 32-bit offsets), as well as PLT entries
3311    and lazy PLT entries.  */
3312
3313 static int
3314 _frvfdpic_assign_plt_entries (void **entryp, void *info_)
3315 {
3316   struct frvfdpic_relocs_info *entry = *entryp;
3317   struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
3318
3319   /* If this symbol requires a local function descriptor, allocate
3320      one.  */
3321   if (entry->privfd && entry->fd_entry == 0)
3322     {
3323       if (dinfo->got12.fdplt)
3324         {
3325           entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
3326           dinfo->got12.fdplt -= 8;
3327         }
3328       else if (dinfo->gotlos.fdplt)
3329         {
3330           entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
3331           dinfo->gotlos.fdplt -= 8;
3332         }
3333       else
3334         {
3335           BFD_ASSERT (dinfo->gothilo.fdplt)
3336           entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
3337           dinfo->gothilo.fdplt -= 8;
3338         }
3339     }
3340
3341   if (entry->plt)
3342     {
3343       int size;
3344
3345       /* We use the section's raw size to mark the location of the
3346          next PLT entry.  */
3347       entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
3348
3349       /* Figure out the length of this PLT entry based on the
3350          addressing mode we need to reach the function descriptor.  */
3351       BFD_ASSERT (entry->fd_entry);
3352       if (entry->fd_entry >= -(1 << (12 - 1))
3353           && entry->fd_entry < (1 << (12 - 1)))
3354         size = 8;
3355       else if (entry->fd_entry >= -(1 << (16 - 1))
3356                && entry->fd_entry < (1 << (16 - 1)))
3357         size = 12;
3358       else
3359         size = 16;
3360
3361       frvfdpic_plt_section (dinfo->g.info)->size += size;
3362     }
3363
3364   if (entry->lazyplt)
3365     {
3366       entry->lzplt_entry = dinfo->g.lzplt;
3367       dinfo->g.lzplt += 8;
3368       /* If this entry is the one that gets the resolver stub, account
3369          for the additional instruction.  */
3370       if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
3371           == FRVFDPIC_LZPLT_RESOLV_LOC)
3372         dinfo->g.lzplt += 4;
3373     }
3374
3375   return 1;
3376 }
3377
3378 /* Follow indirect and warning hash entries so that each got entry
3379    points to the final symbol definition.  P must point to a pointer
3380    to the hash table we're traversing.  Since this traversal may
3381    modify the hash table, we set this pointer to NULL to indicate
3382    we've made a potentially-destructive change to the hash table, so
3383    the traversal must be restarted.  */
3384 static int
3385 _frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
3386 {
3387   struct frvfdpic_relocs_info *entry = *entryp;
3388   htab_t *htab = p;
3389
3390   if (entry->symndx == -1)
3391     {
3392       struct elf_link_hash_entry *h = entry->d.h;
3393       struct frvfdpic_relocs_info *oentry;
3394
3395       while (h->root.type == bfd_link_hash_indirect
3396              || h->root.type == bfd_link_hash_warning)
3397         h = (struct elf_link_hash_entry *)h->root.u.i.link;
3398
3399       if (entry->d.h == h)
3400         return 1;
3401
3402       oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
3403                                                 NO_INSERT);
3404
3405       if (oentry)
3406         {
3407           /* Merge the two entries.  */
3408           frvfdpic_pic_merge_early_relocs_info (oentry, entry);
3409           htab_clear_slot (*htab, entryp);
3410           return 1;
3411         }
3412
3413       entry->d.h = h;
3414
3415       /* If we can't find this entry with the new bfd hash, re-insert
3416          it, and get the traversal restarted.  */
3417       if (! htab_find (*htab, entry))
3418         {
3419           htab_clear_slot (*htab, entryp);
3420           entryp = htab_find_slot (*htab, entry, INSERT);
3421           if (! *entryp)
3422             *entryp = entry;
3423           /* Abort the traversal, since the whole table may have
3424              moved, and leave it up to the parent to restart the
3425              process.  */
3426           *(htab_t *)p = NULL;
3427           return 0;
3428         }
3429     }
3430
3431   return 1;
3432 }
3433
3434 /* Set the sizes of the dynamic sections.  */
3435
3436 static bfd_boolean
3437 elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
3438                                       struct bfd_link_info *info)
3439 {
3440   bfd *dynobj;
3441   asection *s;
3442   struct _frvfdpic_dynamic_got_plt_info gpinfo;
3443   bfd_signed_vma odd;
3444   bfd_vma limit;
3445
3446   dynobj = elf_hash_table (info)->dynobj;
3447   BFD_ASSERT (dynobj != NULL);
3448
3449   if (elf_hash_table (info)->dynamic_sections_created)
3450     {
3451       /* Set the contents of the .interp section to the interpreter.  */
3452       if (info->executable)
3453         {
3454           s = bfd_get_section_by_name (dynobj, ".interp");
3455           BFD_ASSERT (s != NULL);
3456           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3457           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3458         }
3459     }
3460
3461   memset (&gpinfo, 0, sizeof (gpinfo));
3462   gpinfo.g.info = info;
3463
3464   for (;;)
3465     {
3466       htab_t relocs = frvfdpic_relocs_info (info);
3467
3468       htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
3469
3470       if (relocs == frvfdpic_relocs_info (info))
3471         break;
3472     }
3473
3474   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
3475                  &gpinfo.g);
3476
3477   odd = 12;
3478   /* Compute the total size taken by entries in the 12-bit and 16-bit
3479      ranges, to tell how many PLT function descriptors we can bring
3480      into the 12-bit range without causing the 16-bit range to
3481      overflow.  */
3482   limit = odd + gpinfo.g.got12 + gpinfo.g.gotlos
3483     + gpinfo.g.fd12 + gpinfo.g.fdlos;
3484   if (limit < (bfd_vma)1 << 16)
3485     limit = ((bfd_vma)1 << 16) - limit;
3486   else
3487     limit = 0;
3488   if (gpinfo.g.fdplt < limit)
3489     limit = gpinfo.g.fdplt;
3490
3491   /* Determine the ranges of GOT offsets that we can use for each
3492      range of addressing modes.  */
3493   odd = _frvfdpic_compute_got_alloc_data (&gpinfo.got12,
3494                                           0,
3495                                           odd,
3496                                           16,
3497                                           gpinfo.g.got12,
3498                                           gpinfo.g.fd12,
3499                                           limit,
3500                                           (bfd_vma)1 << (12-1));
3501   odd = _frvfdpic_compute_got_alloc_data (&gpinfo.gotlos,
3502                                           gpinfo.got12.min,
3503                                           odd,
3504                                           gpinfo.got12.max,
3505                                           gpinfo.g.gotlos,
3506                                           gpinfo.g.fdlos,
3507                                           gpinfo.g.fdplt - gpinfo.got12.fdplt,
3508                                           (bfd_vma)1 << (16-1));
3509   odd = _frvfdpic_compute_got_alloc_data (&gpinfo.gothilo,
3510                                           gpinfo.gotlos.min,
3511                                           odd,
3512                                           gpinfo.gotlos.max,
3513                                           gpinfo.g.gothilo,
3514                                           gpinfo.g.fdhilo,
3515                                           gpinfo.g.fdplt - gpinfo.got12.fdplt
3516                                           - gpinfo.gotlos.fdplt,
3517                                           (bfd_vma)1 << (32-1));
3518
3519   /* Now assign (most) GOT offsets.  */
3520   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
3521                  &gpinfo);
3522
3523   frvfdpic_got_section (info)->size = gpinfo.gothilo.max
3524     - gpinfo.gothilo.min
3525     /* If an odd word is the last word of the GOT, we don't need this
3526        word to be part of the GOT.  */
3527     - (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
3528   if (frvfdpic_got_section (info)->size == 0)
3529     frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
3530   else if (frvfdpic_got_section (info)->size == 12
3531            && ! elf_hash_table (info)->dynamic_sections_created)
3532     {
3533       frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
3534       frvfdpic_got_section (info)->size = 0;
3535     }
3536   else
3537     {
3538       frvfdpic_got_section (info)->contents =
3539         (bfd_byte *) bfd_zalloc (dynobj,
3540                                  frvfdpic_got_section (info)->size);
3541       if (frvfdpic_got_section (info)->contents == NULL)
3542         return FALSE;
3543     }
3544
3545   if (elf_hash_table (info)->dynamic_sections_created)
3546     /* Subtract the number of lzplt entries, since those will generate
3547        relocations in the pltrel section.  */
3548     frvfdpic_gotrel_section (info)->size =
3549       (gpinfo.g.relocs - gpinfo.g.lzplt / 8)
3550       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
3551   else
3552     BFD_ASSERT (gpinfo.g.relocs == 0);
3553   if (frvfdpic_gotrel_section (info)->size == 0)
3554     frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
3555   else
3556     {
3557       frvfdpic_gotrel_section (info)->contents =
3558         (bfd_byte *) bfd_zalloc (dynobj,
3559                                  frvfdpic_gotrel_section (info)->size);
3560       if (frvfdpic_gotrel_section (info)->contents == NULL)
3561         return FALSE;
3562     }
3563
3564   frvfdpic_gotfixup_section (info)->size = (gpinfo.g.fixups + 1) * 4;
3565   if (frvfdpic_gotfixup_section (info)->size == 0)
3566     frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
3567   else
3568     {
3569       frvfdpic_gotfixup_section (info)->contents =
3570         (bfd_byte *) bfd_zalloc (dynobj,
3571                                  frvfdpic_gotfixup_section (info)->size);
3572       if (frvfdpic_gotfixup_section (info)->contents == NULL)
3573         return FALSE;
3574     }
3575
3576   if (elf_hash_table (info)->dynamic_sections_created)
3577     {
3578       frvfdpic_pltrel_section (info)->size =
3579         gpinfo.g.lzplt / 8 * get_elf_backend_data (output_bfd)->s->sizeof_rel;
3580       if (frvfdpic_pltrel_section (info)->size == 0)
3581         frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
3582       else
3583         {
3584           frvfdpic_pltrel_section (info)->contents =
3585             (bfd_byte *) bfd_zalloc (dynobj,
3586                                      frvfdpic_pltrel_section (info)->size);
3587           if (frvfdpic_pltrel_section (info)->contents == NULL)
3588             return FALSE;
3589         }
3590     }
3591
3592   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
3593      such that there's room for the additional instruction needed to
3594      call the resolver.  Since _frvfdpic_assign_got_entries didn't
3595      account for them, our block size is 4 bytes smaller than the real
3596      block size.  */
3597   if (elf_hash_table (info)->dynamic_sections_created)
3598     {
3599       frvfdpic_plt_section (info)->size = gpinfo.g.lzplt
3600         + ((gpinfo.g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
3601            / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
3602     }
3603
3604   /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
3605      actually assign lazy PLT entries addresses.  */
3606   gpinfo.g.lzplt = 0;
3607
3608   /* Save information that we're going to need to generate GOT and PLT
3609      entries.  */
3610   frvfdpic_got_initial_offset (info) = -gpinfo.gothilo.min;
3611
3612   if (get_elf_backend_data (output_bfd)->want_got_sym)
3613     elf_hash_table (info)->hgot->root.u.def.value
3614       += frvfdpic_got_initial_offset (info);
3615
3616   if (elf_hash_table (info)->dynamic_sections_created)
3617     frvfdpic_plt_initial_offset (info) =
3618       frvfdpic_plt_section (info)->size;
3619
3620   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
3621                  &gpinfo);
3622
3623   /* Allocate the PLT section contents only after
3624      _frvfdpic_assign_plt_entries has a chance to add the size of the
3625      non-lazy PLT entries.  */
3626   if (elf_hash_table (info)->dynamic_sections_created)
3627     {
3628       if (frvfdpic_plt_section (info)->size == 0)
3629         frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
3630       else
3631         {
3632           frvfdpic_plt_section (info)->contents =
3633             (bfd_byte *) bfd_zalloc (dynobj,
3634                                      frvfdpic_plt_section (info)->size);
3635           if (frvfdpic_plt_section (info)->contents == NULL)
3636             return FALSE;
3637         }
3638     }
3639
3640   if (elf_hash_table (info)->dynamic_sections_created)
3641     {
3642       if (frvfdpic_got_section (info)->size)
3643         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
3644           return FALSE;
3645
3646       if (frvfdpic_pltrel_section (info)->size)
3647         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
3648             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
3649             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
3650           return FALSE;
3651
3652       if (frvfdpic_gotrel_section (info)->size)
3653         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
3654             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
3655             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
3656                                             sizeof (Elf32_External_Rel)))
3657           return FALSE;
3658     }
3659
3660   return TRUE;
3661 }
3662
3663 static bfd_boolean
3664 elf32_frvfdpic_always_size_sections (bfd *output_bfd,
3665                                      struct bfd_link_info *info)
3666 {
3667   if (!info->relocatable)
3668     {
3669       struct elf_link_hash_entry *h;
3670       asection *sec;
3671
3672       /* Force a PT_GNU_STACK segment to be created.  */
3673       if (! elf_tdata (output_bfd)->stack_flags)
3674         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
3675
3676       /* Define __stacksize if it's not defined yet.  */
3677       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3678                                 FALSE, FALSE, FALSE);
3679       if (! h || h->root.type != bfd_link_hash_defined
3680           || h->type != STT_OBJECT
3681           || !(h->elf_link_hash_flags & ELF_LINK_HASH_DEF_REGULAR))
3682         {
3683           struct bfd_link_hash_entry *bh = NULL;
3684
3685           if (!(_bfd_generic_link_add_one_symbol
3686                 (info, output_bfd, "__stacksize",
3687                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
3688                  (const char *) NULL, FALSE,
3689                  get_elf_backend_data (output_bfd)->collect, &bh)))
3690             return FALSE;
3691
3692           h = (struct elf_link_hash_entry *) bh;
3693           h->elf_link_hash_flags |= ELF_LINK_HASH_DEF_REGULAR;
3694           h->type = STT_OBJECT;
3695         }
3696
3697       /* Create a stack section, and set its alignment.  */
3698       sec = bfd_make_section (output_bfd, ".stack");
3699
3700       if (sec == NULL
3701           || ! bfd_set_section_alignment (output_bfd, sec, 3))
3702         return FALSE;
3703     }
3704
3705   return TRUE;
3706 }
3707
3708 static bfd_boolean
3709 elf32_frvfdpic_modify_segment_map (bfd *output_bfd,
3710                                    struct bfd_link_info *info)
3711 {
3712   struct elf_segment_map *m;
3713
3714   /* objcopy and strip preserve what's already there using
3715      elf32_frvfdpic_copy_private_bfd_data ().  */
3716   if (! info)
3717     return TRUE;
3718
3719   for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
3720     if (m->p_type == PT_GNU_STACK)
3721       break;
3722
3723   if (m)
3724     {
3725       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
3726       struct elf_link_hash_entry *h;
3727
3728       if (sec)
3729         {
3730           /* Obtain the pointer to the __stacksize symbol.  */
3731           h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
3732                                     FALSE, FALSE, FALSE);
3733           while (h->root.type == bfd_link_hash_indirect
3734                  || h->root.type == bfd_link_hash_warning)
3735             h = (struct elf_link_hash_entry *)h->root.u.i.link;
3736           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
3737
3738           /* Set the section size from the symbol value.  We
3739              intentionally ignore the symbol section.  */
3740           if (h->root.type == bfd_link_hash_defined)
3741             sec->size = h->root.u.def.value;
3742           else
3743             sec->size = DEFAULT_STACK_SIZE;
3744
3745           /* Add the stack section to the PT_GNU_STACK segment,
3746              such that its size and alignment requirements make it
3747              to the segment.  */
3748           m->sections[m->count] = sec;
3749           m->count++;
3750         }
3751     }
3752
3753   return TRUE;
3754 }
3755
3756 /* Fill in code and data in dynamic sections.  */
3757
3758 static bfd_boolean
3759 elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
3760                                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
3761 {
3762   /* Nothing to be done for non-FDPIC.  */
3763   return TRUE;
3764 }
3765
3766 static bfd_boolean
3767 elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
3768                                         struct bfd_link_info *info)
3769 {
3770   bfd *dynobj;
3771   asection *sdyn;
3772
3773   dynobj = elf_hash_table (info)->dynobj;
3774
3775   if (frvfdpic_got_section (info))
3776     {
3777       BFD_ASSERT (frvfdpic_gotrel_section (info)->size
3778                   == (frvfdpic_gotrel_section (info)->reloc_count
3779                       * sizeof (Elf32_External_Rel)));
3780
3781       if (frvfdpic_gotfixup_section (info))
3782         {
3783           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
3784           bfd_vma got_value = hgot->root.u.def.value
3785             + hgot->root.u.def.section->output_section->vma
3786             + hgot->root.u.def.section->output_offset;
3787
3788           _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
3789                                  got_value, 0);
3790
3791           if (frvfdpic_gotfixup_section (info)->size
3792               != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
3793             {
3794               (*_bfd_error_handler)
3795                 ("LINKER BUG: .rofixup section size mismatch");
3796               return FALSE;
3797             }
3798         }
3799     }
3800   if (elf_hash_table (info)->dynamic_sections_created)
3801     {
3802       BFD_ASSERT (frvfdpic_pltrel_section (info)->size
3803                   == (frvfdpic_pltrel_section (info)->reloc_count
3804                       * sizeof (Elf32_External_Rel)));
3805     }
3806
3807   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
3808
3809   if (elf_hash_table (info)->dynamic_sections_created)
3810     {
3811       Elf32_External_Dyn * dyncon;
3812       Elf32_External_Dyn * dynconend;
3813
3814       BFD_ASSERT (sdyn != NULL);
3815
3816       dyncon = (Elf32_External_Dyn *) sdyn->contents;
3817       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
3818
3819       for (; dyncon < dynconend; dyncon++)
3820         {
3821           Elf_Internal_Dyn dyn;
3822
3823           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
3824
3825           switch (dyn.d_tag)
3826             {
3827             default:
3828               break;
3829
3830             case DT_PLTGOT:
3831               dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
3832                 + frvfdpic_got_section (info)->output_offset
3833                 + frvfdpic_got_initial_offset (info);
3834               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3835               break;
3836
3837             case DT_JMPREL:
3838               dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
3839                 ->output_section->vma
3840                 + frvfdpic_pltrel_section (info)->output_offset;
3841               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3842               break;
3843
3844             case DT_PLTRELSZ:
3845               dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
3846               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
3847               break;
3848             }
3849         }
3850     }
3851
3852   return TRUE;
3853 }
3854
3855 /* Adjust a symbol defined by a dynamic object and referenced by a
3856    regular object.  */
3857
3858 static bfd_boolean
3859 elf32_frvfdpic_adjust_dynamic_symbol
3860 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
3861  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
3862 {
3863   bfd * dynobj;
3864
3865   dynobj = elf_hash_table (info)->dynobj;
3866
3867   /* Make sure we know what is going on here.  */
3868   BFD_ASSERT (dynobj != NULL
3869               && (h->weakdef != NULL
3870                   || ((h->elf_link_hash_flags
3871                        & ELF_LINK_HASH_DEF_DYNAMIC) != 0
3872                       && (h->elf_link_hash_flags
3873                           & ELF_LINK_HASH_REF_REGULAR) != 0
3874                       && (h->elf_link_hash_flags
3875                           & ELF_LINK_HASH_DEF_REGULAR) == 0)));
3876
3877   /* If this is a weak symbol, and there is a real definition, the
3878      processor independent code will have arranged for us to see the
3879      real definition first, and we can just use the same value.  */
3880   if (h->weakdef != NULL)
3881     {
3882       BFD_ASSERT (h->weakdef->root.type == bfd_link_hash_defined
3883                   || h->weakdef->root.type == bfd_link_hash_defweak);
3884       h->root.u.def.section = h->weakdef->root.u.def.section;
3885       h->root.u.def.value = h->weakdef->root.u.def.value;
3886     }
3887
3888   return TRUE;
3889 }
3890
3891 /* Perform any actions needed for dynamic symbols.  */
3892
3893 static bfd_boolean
3894 elf32_frvfdpic_finish_dynamic_symbol
3895 (bfd *output_bfd ATTRIBUTE_UNUSED,
3896  struct bfd_link_info *info ATTRIBUTE_UNUSED,
3897  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
3898  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
3899 {
3900   return TRUE;
3901 }
3902
3903 /* Decide whether to attempt to turn absptr or lsda encodings in
3904    shared libraries into pcrel within the given input section.  */
3905
3906 static bfd_boolean
3907 frvfdpic_elf_use_relative_eh_frame
3908 (bfd *input_bfd ATTRIBUTE_UNUSED,
3909  struct bfd_link_info *info ATTRIBUTE_UNUSED,
3910  asection *eh_frame_section ATTRIBUTE_UNUSED)
3911 {
3912   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
3913   return FALSE;
3914 }
3915
3916 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
3917
3918 static bfd_byte
3919 frvfdpic_elf_encode_eh_address (bfd *abfd,
3920                                 struct bfd_link_info *info,
3921                                 asection *osec, bfd_vma offset,
3922                                 asection *loc_sec, bfd_vma loc_offset,
3923                                 bfd_vma *encoded)
3924 {
3925   struct elf_link_hash_entry *h;
3926
3927   h = elf_hash_table (info)->hgot;
3928   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
3929
3930   if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
3931               == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
3932     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
3933                                        loc_sec, loc_offset, encoded);
3934
3935   BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
3936               == (_frvfdpic_osec_to_segment
3937                   (abfd, h->root.u.def.section->output_section)));
3938
3939   *encoded = osec->vma + offset
3940     - (h->root.u.def.value
3941        + h->root.u.def.section->output_section->vma
3942        + h->root.u.def.section->output_offset);
3943
3944   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
3945 }
3946
3947 /* Look through the relocs for a section during the first phase.
3948
3949    Besides handling virtual table relocs for gc, we have to deal with
3950    all sorts of PIC-related relocations.  We describe below the
3951    general plan on how to handle such relocations, even though we only
3952    collect information at this point, storing them in hash tables for
3953    perusal of later passes.
3954
3955    32 relocations are propagated to the linker output when creating
3956    position-independent output.  LO16 and HI16 relocations are not
3957    supposed to be encountered in this case.
3958
3959    LABEL16 should always be resolvable by the linker, since it's only
3960    used by branches.
3961
3962    LABEL24, on the other hand, is used by calls.  If it turns out that
3963    the target of a call is a dynamic symbol, a PLT entry must be
3964    created for it, which triggers the creation of a private function
3965    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
3966
3967    GPREL relocations require the referenced symbol to be in the same
3968    segment as _gp, but this can only be checked later.
3969
3970    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
3971    exist.  LABEL24 might as well, since it may require a PLT entry,
3972    that will require a got.
3973
3974    Non-FUNCDESC GOT relocations require a GOT entry to be created
3975    regardless of whether the symbol is dynamic.  However, since a
3976    global symbol that turns out to not be exported may have the same
3977    address of a non-dynamic symbol, we don't assign GOT entries at
3978    this point, such that we can share them in this case.  A relocation
3979    for the GOT entry always has to be created, be it to offset a
3980    private symbol by the section load address, be it to get the symbol
3981    resolved dynamically.
3982
3983    FUNCDESC GOT relocations require a GOT entry to be created, and
3984    handled as if a FUNCDESC relocation was applied to the GOT entry in
3985    an object file.
3986
3987    FUNCDESC relocations referencing a symbol that turns out to NOT be
3988    dynamic cause a private function descriptor to be created.  The
3989    FUNCDESC relocation then decays to a 32 relocation that points at
3990    the private descriptor.  If the symbol is dynamic, the FUNCDESC
3991    relocation is propagated to the linker output, such that the
3992    dynamic linker creates the canonical descriptor, pointing to the
3993    dynamically-resolved definition of the function.
3994
3995    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
3996    symbols that are assigned to the same segment as the GOT, but we
3997    can only check this later, after we know the complete set of
3998    symbols defined and/or exported.
3999
4000    FUNCDESC GOTOFF relocations require a function descriptor to be
4001    created and, unless lazy binding is disabled or the symbol is not
4002    dynamic, a lazy PLT entry.  Since we can't tell at this point
4003    whether a symbol is going to be dynamic, we have to decide later
4004    whether to create a lazy PLT entry or bind the descriptor directly
4005    to the private function.
4006
4007    FUNCDESC_VALUE relocations are not supposed to be present in object
4008    files, but they may very well be simply propagated to the linker
4009    output, since they have no side effect.
4010
4011
4012    A function descriptor always requires a FUNCDESC_VALUE relocation.
4013    Whether it's in .plt.rel or not depends on whether lazy binding is
4014    enabled and on whether the referenced symbol is dynamic.
4015
4016    The existence of a lazy PLT requires the resolverStub lazy PLT
4017    entry to be present.
4018
4019
4020    As for assignment of GOT, PLT and lazy PLT entries, and private
4021    descriptors, we might do them all sequentially, but we can do
4022    better than that.  For example, we can place GOT entries and
4023    private function descriptors referenced using 12-bit operands
4024    closer to the PIC register value, such that these relocations don't
4025    overflow.  Those that are only referenced with LO16 relocations
4026    could come next, but we may as well place PLT-required function
4027    descriptors in the 12-bit range to make them shorter.  Symbols
4028    referenced with LO16/HI16 may come next, but we may place
4029    additional function descriptors in the 16-bit range if we can
4030    reliably tell that we've already placed entries that are ever
4031    referenced with only LO16.  PLT entries are therefore generated as
4032    small as possible, while not introducing relocation overflows in
4033    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
4034    generated before or after PLT entries, but not intermingled with
4035    them, such that we can have more lazy PLT entries in range for a
4036    branch to the resolverStub.  The resolverStub should be emitted at
4037    the most distant location from the first lazy PLT entry such that
4038    it's still in range for a branch, or closer, if there isn't a need
4039    for so many lazy PLT entries.  Additional lazy PLT entries may be
4040    emitted after the resolverStub, as long as branches are still in
4041    range.  If the branch goes out of range, longer lazy PLT entries
4042    are emitted.
4043
4044    We could further optimize PLT and lazy PLT entries by giving them
4045    priority in assignment to closer-to-gr17 locations depending on the
4046    number of occurrences of references to them (assuming a function
4047    that's called more often is more important for performance, so its
4048    PLT entry should be faster), or taking hints from the compiler.
4049    Given infinite time and money... :-)  */
4050
4051 static bfd_boolean
4052 elf32_frv_check_relocs (abfd, info, sec, relocs)
4053      bfd *abfd;
4054      struct bfd_link_info *info;
4055      asection *sec;
4056      const Elf_Internal_Rela *relocs;
4057 {
4058   Elf_Internal_Shdr *symtab_hdr;
4059   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4060   const Elf_Internal_Rela *rel;
4061   const Elf_Internal_Rela *rel_end;
4062   bfd *dynobj;
4063   struct frvfdpic_relocs_info *picrel;
4064
4065   if (info->relocatable)
4066     return TRUE;
4067
4068   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4069   sym_hashes = elf_sym_hashes (abfd);
4070   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4071   if (!elf_bad_symtab (abfd))
4072     sym_hashes_end -= symtab_hdr->sh_info;
4073
4074   dynobj = elf_hash_table (info)->dynobj;
4075   rel_end = relocs + sec->reloc_count;
4076   for (rel = relocs; rel < rel_end; rel++)
4077     {
4078       struct elf_link_hash_entry *h;
4079       unsigned long r_symndx;
4080
4081       r_symndx = ELF32_R_SYM (rel->r_info);
4082       if (r_symndx < symtab_hdr->sh_info)
4083         h = NULL;
4084       else
4085         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4086
4087       switch (ELF32_R_TYPE (rel->r_info))
4088         {
4089         case R_FRV_GOT12:
4090         case R_FRV_GOTHI:
4091         case R_FRV_GOTLO:
4092         case R_FRV_FUNCDESC_GOT12:
4093         case R_FRV_FUNCDESC_GOTHI:
4094         case R_FRV_FUNCDESC_GOTLO:
4095         case R_FRV_GOTOFF12:
4096         case R_FRV_GOTOFFHI:
4097         case R_FRV_GOTOFFLO:
4098         case R_FRV_FUNCDESC_GOTOFF12:
4099         case R_FRV_FUNCDESC_GOTOFFHI:
4100         case R_FRV_FUNCDESC_GOTOFFLO:
4101         case R_FRV_FUNCDESC:
4102         case R_FRV_FUNCDESC_VALUE:
4103           if (! IS_FDPIC (abfd))
4104             goto bad_reloc;
4105           /* Fall through.  */
4106         case R_FRV_GPREL12:
4107         case R_FRV_GPRELU12:
4108         case R_FRV_GPRELHI:
4109         case R_FRV_GPRELLO:
4110         case R_FRV_LABEL24:
4111         case R_FRV_32:
4112           if (! dynobj)
4113             {
4114               elf_hash_table (info)->dynobj = dynobj = abfd;
4115               if (! _frv_create_got_section (abfd, info))
4116                 return FALSE;
4117             }
4118           if (! IS_FDPIC (abfd))
4119             {
4120               picrel = NULL;
4121               break;
4122             }
4123           if (h != NULL)
4124             {
4125               if (h->dynindx == -1)
4126                 switch (ELF_ST_VISIBILITY (h->other))
4127                   {
4128                   case STV_INTERNAL:
4129                   case STV_HIDDEN:
4130                     break;
4131                   default:
4132                     bfd_elf_link_record_dynamic_symbol (info, h);
4133                     break;
4134                   }
4135               picrel
4136                 = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
4137                                                    abfd, h,
4138                                                    rel->r_addend, INSERT);
4139             }
4140           else
4141             picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
4142                                                      (info), abfd, r_symndx,
4143                                                      rel->r_addend, INSERT);
4144           if (! picrel)
4145             return FALSE;
4146           break;
4147
4148         default:
4149           picrel = NULL;
4150           break;
4151         }
4152
4153       switch (ELF32_R_TYPE (rel->r_info))
4154         {
4155         case R_FRV_LABEL24:
4156           if (IS_FDPIC (abfd))
4157             picrel->call = 1;
4158           break;
4159
4160         case R_FRV_FUNCDESC_VALUE:
4161           picrel->relocsfdv++;
4162           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4163             picrel->relocs32--;
4164           /* Fall through.  */
4165
4166         case R_FRV_32:
4167           if (! IS_FDPIC (abfd))
4168             break;
4169
4170           picrel->sym = 1;
4171           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4172             picrel->relocs32++;
4173           break;
4174
4175         case R_FRV_GOT12:
4176           picrel->got12 = 1;
4177           break;
4178
4179         case R_FRV_GOTHI:
4180         case R_FRV_GOTLO:
4181           picrel->gothilo = 1;
4182           break;
4183
4184         case R_FRV_FUNCDESC_GOT12:
4185           picrel->fdgot12 = 1;
4186           break;
4187
4188         case R_FRV_FUNCDESC_GOTHI:
4189         case R_FRV_FUNCDESC_GOTLO:
4190           picrel->fdgothilo = 1;
4191           break;
4192
4193         case R_FRV_GOTOFF12:
4194         case R_FRV_GOTOFFHI:
4195         case R_FRV_GOTOFFLO:
4196           picrel->gotoff = 1;
4197           break;
4198
4199         case R_FRV_FUNCDESC_GOTOFF12:
4200           picrel->fdgoff12 = 1;
4201           break;
4202
4203         case R_FRV_FUNCDESC_GOTOFFHI:
4204         case R_FRV_FUNCDESC_GOTOFFLO:
4205           picrel->fdgoffhilo = 1;
4206           break;
4207
4208         case R_FRV_FUNCDESC:
4209           picrel->fd = 1;
4210           picrel->relocsfd++;
4211           break;
4212
4213         /* This relocation describes the C++ object vtable hierarchy.
4214            Reconstruct it for later use during GC.  */
4215         case R_FRV_GNU_VTINHERIT:
4216           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4217             return FALSE;
4218           break;
4219
4220         /* This relocation describes which C++ vtable entries are actually
4221            used.  Record for later use during GC.  */
4222         case R_FRV_GNU_VTENTRY:
4223           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4224             return FALSE;
4225           break;
4226
4227         case R_FRV_LABEL16:
4228         case R_FRV_LO16:
4229         case R_FRV_HI16:
4230         case R_FRV_GPREL12:
4231         case R_FRV_GPRELU12:
4232         case R_FRV_GPREL32:
4233         case R_FRV_GPRELHI:
4234         case R_FRV_GPRELLO:
4235           break;
4236
4237         default:
4238         bad_reloc:
4239           (*_bfd_error_handler)
4240             (_("%s: unsupported relocation type %i"),
4241              bfd_archive_filename (abfd), ELF32_R_TYPE (rel->r_info));
4242           return FALSE;
4243         }
4244     }
4245
4246   return TRUE;
4247 }
4248
4249 \f
4250 /* Return the machine subcode from the ELF e_flags header.  */
4251
4252 static int
4253 elf32_frv_machine (abfd)
4254      bfd *abfd;
4255 {
4256   switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
4257     {
4258     default:                break;
4259     case EF_FRV_CPU_FR550:  return bfd_mach_fr550;
4260     case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
4261     case EF_FRV_CPU_FR450:  return bfd_mach_fr450;
4262     case EF_FRV_CPU_FR405:  return bfd_mach_fr400;
4263     case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
4264     case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
4265     case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
4266     case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
4267     }
4268
4269   return bfd_mach_frv;
4270 }
4271
4272 /* Set the right machine number for a FRV ELF file.  */
4273
4274 static bfd_boolean
4275 elf32_frv_object_p (abfd)
4276      bfd *abfd;
4277 {
4278   bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
4279   return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
4280           == (IS_FDPIC (abfd)));
4281 }
4282 \f
4283 /* Function to set the ELF flag bits.  */
4284
4285 static bfd_boolean
4286 frv_elf_set_private_flags (abfd, flags)
4287      bfd *abfd;
4288      flagword flags;
4289 {
4290   elf_elfheader (abfd)->e_flags = flags;
4291   elf_flags_init (abfd) = TRUE;
4292   return TRUE;
4293 }
4294
4295 /* Copy backend specific data from one object module to another.  */
4296
4297 static bfd_boolean
4298 frv_elf_copy_private_bfd_data (ibfd, obfd)
4299      bfd *ibfd;
4300      bfd *obfd;
4301 {
4302   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4303       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4304     return TRUE;
4305
4306   BFD_ASSERT (!elf_flags_init (obfd)
4307               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
4308
4309   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4310   elf_flags_init (obfd) = TRUE;
4311   return TRUE;
4312 }
4313
4314 /* Return true if the architecture described by elf header flag
4315    EXTENSION is an extension of the architecture described by BASE.  */
4316
4317 static bfd_boolean
4318 frv_elf_arch_extension_p (flagword base, flagword extension)
4319 {
4320   if (base == extension)
4321     return TRUE;
4322
4323   /* CPU_GENERIC code can be merged with code for a specific
4324      architecture, in which case the result is marked as being
4325      for the specific architecture.  Everything is therefore
4326      an extension of CPU_GENERIC.  */
4327   if (base == EF_FRV_CPU_GENERIC)
4328     return TRUE;
4329
4330   if (extension == EF_FRV_CPU_FR450)
4331     if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
4332       return TRUE;
4333
4334   if (extension == EF_FRV_CPU_FR405)
4335     if (base == EF_FRV_CPU_FR400)
4336       return TRUE;
4337
4338   return FALSE;
4339 }
4340
4341 static bfd_boolean
4342 elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4343 {
4344   unsigned i;
4345
4346   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4347       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4348     return TRUE;
4349
4350   if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
4351     return FALSE;
4352
4353   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
4354       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
4355     return TRUE;
4356
4357   /* Copy the stack size.  */
4358   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
4359     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
4360       {
4361         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
4362
4363         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
4364           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
4365             {
4366               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
4367
4368               /* Rewrite the phdrs, since we're only called after they
4369                  were first written.  */
4370               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
4371                             ->s->sizeof_ehdr, SEEK_SET) != 0
4372                   || get_elf_backend_data (obfd)->s
4373                   ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
4374                                      elf_elfheader (obfd)->e_phnum) != 0)
4375                 return FALSE;
4376               break;
4377             }
4378
4379         break;
4380       }
4381
4382   return TRUE;
4383 }
4384
4385 /* Merge backend specific data from an object file to the output
4386    object file when linking.  */
4387
4388 static bfd_boolean
4389 frv_elf_merge_private_bfd_data (ibfd, obfd)
4390      bfd *ibfd;
4391      bfd *obfd;
4392 {
4393   flagword old_flags, old_partial;
4394   flagword new_flags, new_partial;
4395   bfd_boolean error = FALSE;
4396   char new_opt[80];
4397   char old_opt[80];
4398
4399   new_opt[0] = old_opt[0] = '\0';
4400   new_flags = elf_elfheader (ibfd)->e_flags;
4401   old_flags = elf_elfheader (obfd)->e_flags;
4402
4403   if (new_flags & EF_FRV_FDPIC)
4404     new_flags &= ~EF_FRV_PIC;
4405
4406 #ifdef DEBUG
4407   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4408                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4409                          bfd_get_filename (ibfd));
4410 #endif
4411
4412   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
4413     {
4414       elf_flags_init (obfd) = TRUE;
4415       old_flags = new_flags;
4416     }
4417
4418   else if (new_flags == old_flags)              /* Compatible flags are ok.  */
4419     ;
4420
4421   else                                          /* Possibly incompatible flags.  */
4422     {
4423       /* Warn if different # of gprs are used.  Note, 0 means nothing is
4424          said about the size of gprs.  */
4425       new_partial = (new_flags & EF_FRV_GPR_MASK);
4426       old_partial = (old_flags & EF_FRV_GPR_MASK);
4427       if (new_partial == old_partial)
4428         ;
4429
4430       else if (new_partial == 0)
4431         ;
4432
4433       else if (old_partial == 0)
4434         old_flags |= new_partial;
4435
4436       else
4437         {
4438           switch (new_partial)
4439             {
4440             default:            strcat (new_opt, " -mgpr-??"); break;
4441             case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
4442             case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
4443             }
4444
4445           switch (old_partial)
4446             {
4447             default:            strcat (old_opt, " -mgpr-??"); break;
4448             case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
4449             case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
4450             }
4451         }
4452
4453       /* Warn if different # of fprs are used.  Note, 0 means nothing is
4454          said about the size of fprs.  */
4455       new_partial = (new_flags & EF_FRV_FPR_MASK);
4456       old_partial = (old_flags & EF_FRV_FPR_MASK);
4457       if (new_partial == old_partial)
4458         ;
4459
4460       else if (new_partial == 0)
4461         ;
4462
4463       else if (old_partial == 0)
4464         old_flags |= new_partial;
4465
4466       else
4467         {
4468           switch (new_partial)
4469             {
4470             default:              strcat (new_opt, " -mfpr-?");      break;
4471             case EF_FRV_FPR_32:   strcat (new_opt, " -mfpr-32");     break;
4472             case EF_FRV_FPR_64:   strcat (new_opt, " -mfpr-64");     break;
4473             case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
4474             }
4475
4476           switch (old_partial)
4477             {
4478             default:              strcat (old_opt, " -mfpr-?");      break;
4479             case EF_FRV_FPR_32:   strcat (old_opt, " -mfpr-32");     break;
4480             case EF_FRV_FPR_64:   strcat (old_opt, " -mfpr-64");     break;
4481             case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
4482             }
4483         }
4484
4485       /* Warn if different dword support was used.  Note, 0 means nothing is
4486          said about the dword support.  */
4487       new_partial = (new_flags & EF_FRV_DWORD_MASK);
4488       old_partial = (old_flags & EF_FRV_DWORD_MASK);
4489       if (new_partial == old_partial)
4490         ;
4491
4492       else if (new_partial == 0)
4493         ;
4494
4495       else if (old_partial == 0)
4496         old_flags |= new_partial;
4497
4498       else
4499         {
4500           switch (new_partial)
4501             {
4502             default:               strcat (new_opt, " -mdword-?");  break;
4503             case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword");    break;
4504             case EF_FRV_DWORD_NO:  strcat (new_opt, " -mno-dword"); break;
4505             }
4506
4507           switch (old_partial)
4508             {
4509             default:               strcat (old_opt, " -mdword-?");  break;
4510             case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword");    break;
4511             case EF_FRV_DWORD_NO:  strcat (old_opt, " -mno-dword"); break;
4512             }
4513         }
4514
4515       /* Or in flags that accumulate (ie, if one module uses it, mark that the
4516          feature is used.  */
4517       old_flags |= new_flags & (EF_FRV_DOUBLE
4518                                 | EF_FRV_MEDIA
4519                                 | EF_FRV_MULADD
4520                                 | EF_FRV_NON_PIC_RELOCS);
4521
4522       /* If any module was compiled without -G0, clear the G0 bit.  */
4523       old_flags = ((old_flags & ~ EF_FRV_G0)
4524                    | (old_flags & new_flags & EF_FRV_G0));
4525
4526       /* If any module was compiled without -mnopack, clear the mnopack bit.  */
4527       old_flags = ((old_flags & ~ EF_FRV_NOPACK)
4528                    | (old_flags & new_flags & EF_FRV_NOPACK));
4529
4530       /* We don't have to do anything if the pic flags are the same, or the new
4531          module(s) were compiled with -mlibrary-pic.  */
4532       new_partial = (new_flags & EF_FRV_PIC_FLAGS);
4533       old_partial = (old_flags & EF_FRV_PIC_FLAGS);
4534       if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
4535         ;
4536
4537       /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
4538          flags if any from the new module.  */
4539       else if ((old_partial & EF_FRV_LIBPIC) != 0)
4540         old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
4541
4542       /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
4543       else if (new_partial != 0 && old_partial != 0)
4544         old_flags |= new_partial;
4545
4546       /* One module was compiled for pic and the other was not, see if we have
4547          had any relocations that are not pic-safe.  */
4548       else
4549         {
4550           if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
4551             old_flags |= new_partial;
4552           else
4553             {
4554               old_flags &= ~ EF_FRV_PIC_FLAGS;
4555 #ifndef FRV_NO_PIC_ERROR
4556               error = TRUE;
4557               (*_bfd_error_handler)
4558                 (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
4559                  bfd_get_filename (ibfd),
4560                  (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
4561 #endif
4562             }
4563         }
4564
4565       /* Warn if different cpu is used (allow a specific cpu to override
4566          the generic cpu).  */
4567       new_partial = (new_flags & EF_FRV_CPU_MASK);
4568       old_partial = (old_flags & EF_FRV_CPU_MASK);
4569       if (frv_elf_arch_extension_p (new_partial, old_partial))
4570         ;
4571
4572       else if (frv_elf_arch_extension_p (old_partial, new_partial))
4573         old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
4574
4575       else
4576         {
4577           switch (new_partial)
4578             {
4579             default:                 strcat (new_opt, " -mcpu=?");      break;
4580             case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
4581             case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
4582             case EF_FRV_CPU_FR550:   strcat (new_opt, " -mcpu=fr550");  break;
4583             case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
4584             case EF_FRV_CPU_FR450:   strcat (new_opt, " -mcpu=fr450");  break;
4585             case EF_FRV_CPU_FR405:   strcat (new_opt, " -mcpu=fr405");  break;
4586             case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
4587             case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
4588             case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
4589             }
4590
4591           switch (old_partial)
4592             {
4593             default:                 strcat (old_opt, " -mcpu=?");      break;
4594             case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
4595             case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
4596             case EF_FRV_CPU_FR550:   strcat (old_opt, " -mcpu=fr550");  break;
4597             case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
4598             case EF_FRV_CPU_FR450:   strcat (old_opt, " -mcpu=fr450");  break;
4599             case EF_FRV_CPU_FR405:   strcat (old_opt, " -mcpu=fr405");  break;
4600             case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
4601             case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
4602             case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
4603             }
4604         }
4605
4606       /* Print out any mismatches from above.  */
4607       if (new_opt[0])
4608         {
4609           error = TRUE;
4610           (*_bfd_error_handler)
4611             (_("%s: compiled with %s and linked with modules compiled with %s"),
4612              bfd_get_filename (ibfd), new_opt, old_opt);
4613         }
4614
4615       /* Warn about any other mismatches */
4616       new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
4617       old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
4618       if (new_partial != old_partial)
4619         {
4620           old_flags |= new_partial;
4621           error = TRUE;
4622           (*_bfd_error_handler)
4623             (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
4624              bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
4625         }
4626     }
4627
4628   /* If the cpu is -mcpu=simple, then set the -mnopack bit.  */
4629   if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
4630     old_flags |= EF_FRV_NOPACK;
4631
4632   /* Update the old flags now with changes made above.  */
4633   old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
4634   elf_elfheader (obfd)->e_flags = old_flags;
4635   if (old_partial != (old_flags & EF_FRV_CPU_MASK))
4636     bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
4637
4638   if (((new_flags & EF_FRV_FDPIC) == 0)
4639       != (! IS_FDPIC (ibfd)))
4640     {
4641       error = TRUE;
4642       if (IS_FDPIC (obfd))
4643         (*_bfd_error_handler)
4644           (_("%s: cannot link non-fdpic object file into fdpic executable"),
4645            bfd_get_filename (ibfd));
4646       else
4647         (*_bfd_error_handler)
4648           (_("%s: cannot link fdpic object file into non-fdpic executable"),
4649            bfd_get_filename (ibfd));
4650     }
4651
4652   if (error)
4653     bfd_set_error (bfd_error_bad_value);
4654
4655   return !error;
4656 }
4657
4658 \f
4659 bfd_boolean
4660 frv_elf_print_private_bfd_data (abfd, ptr)
4661      bfd *abfd;
4662      PTR ptr;
4663 {
4664   FILE *file = (FILE *) ptr;
4665   flagword flags;
4666
4667   BFD_ASSERT (abfd != NULL && ptr != NULL);
4668
4669   /* Print normal ELF private data.  */
4670   _bfd_elf_print_private_bfd_data (abfd, ptr);
4671
4672   flags = elf_elfheader (abfd)->e_flags;
4673   fprintf (file, _("private flags = 0x%lx:"), (long)flags);
4674
4675   switch (flags & EF_FRV_CPU_MASK)
4676     {
4677     default:                                                    break;
4678     case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;
4679     case EF_FRV_CPU_FR550:  fprintf (file, " -mcpu=fr550");     break;
4680     case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;
4681     case EF_FRV_CPU_FR450:  fprintf (file, " -mcpu=fr450");     break;
4682     case EF_FRV_CPU_FR405:  fprintf (file, " -mcpu=fr405");     break;
4683     case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;
4684     case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;
4685     case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;
4686     }
4687
4688   switch (flags & EF_FRV_GPR_MASK)
4689     {
4690     default:                                                    break;
4691     case EF_FRV_GPR_32: fprintf (file, " -mgpr-32");            break;
4692     case EF_FRV_GPR_64: fprintf (file, " -mgpr-64");            break;
4693     }
4694
4695   switch (flags & EF_FRV_FPR_MASK)
4696     {
4697     default:                                                    break;
4698     case EF_FRV_FPR_32:   fprintf (file, " -mfpr-32");          break;
4699     case EF_FRV_FPR_64:   fprintf (file, " -mfpr-64");          break;
4700     case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float");      break;
4701     }
4702
4703   switch (flags & EF_FRV_DWORD_MASK)
4704     {
4705     default:                                                    break;
4706     case EF_FRV_DWORD_YES: fprintf (file, " -mdword");          break;
4707     case EF_FRV_DWORD_NO:  fprintf (file, " -mno-dword");       break;
4708     }
4709
4710   if (flags & EF_FRV_DOUBLE)
4711     fprintf (file, " -mdouble");
4712
4713   if (flags & EF_FRV_MEDIA)
4714     fprintf (file, " -mmedia");
4715
4716   if (flags & EF_FRV_MULADD)
4717     fprintf (file, " -mmuladd");
4718
4719   if (flags & EF_FRV_PIC)
4720     fprintf (file, " -fpic");
4721
4722   if (flags & EF_FRV_BIGPIC)
4723     fprintf (file, " -fPIC");
4724
4725   if (flags & EF_FRV_LIBPIC)
4726     fprintf (file, " -mlibrary-pic");
4727
4728   if (flags & EF_FRV_FDPIC)
4729     fprintf (file, " -mfdpic");
4730
4731   if (flags & EF_FRV_NON_PIC_RELOCS)
4732     fprintf (file, " non-pic relocations");
4733
4734   if (flags & EF_FRV_G0)
4735     fprintf (file, " -G0");
4736
4737   fputc ('\n', file);
4738   return TRUE;
4739 }
4740
4741 \f
4742 #define ELF_ARCH                bfd_arch_frv
4743 #define ELF_MACHINE_CODE        EM_CYGNUS_FRV
4744 #define ELF_MAXPAGESIZE         0x1000
4745
4746 #define TARGET_BIG_SYM          bfd_elf32_frv_vec
4747 #define TARGET_BIG_NAME         "elf32-frv"
4748
4749 #define elf_info_to_howto                       frv_info_to_howto_rela
4750 #define elf_backend_relocate_section            elf32_frv_relocate_section
4751 #define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook
4752 #define elf_backend_gc_sweep_hook               elf32_frv_gc_sweep_hook
4753 #define elf_backend_check_relocs                elf32_frv_check_relocs
4754 #define elf_backend_object_p                    elf32_frv_object_p
4755 #define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
4756
4757 #define elf_backend_can_gc_sections             1
4758 #define elf_backend_rela_normal                 1
4759
4760 #define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup
4761 #define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags
4762 #define bfd_elf32_bfd_copy_private_bfd_data     frv_elf_copy_private_bfd_data
4763 #define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data
4764 #define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data
4765
4766 #define elf_backend_want_got_sym        1
4767 #define elf_backend_got_header_size     0
4768 #define elf_backend_want_got_plt        0
4769 #define elf_backend_plt_readonly        1
4770 #define elf_backend_want_plt_sym        0
4771 #define elf_backend_plt_header_size     0
4772
4773 #define elf_backend_finish_dynamic_sections \
4774                 elf32_frv_finish_dynamic_sections
4775
4776 #include "elf32-target.h"
4777
4778 #undef ELF_MAXPAGESIZE
4779 #define ELF_MAXPAGESIZE         0x4000
4780
4781 #undef TARGET_BIG_SYM
4782 #define TARGET_BIG_SYM          bfd_elf32_frvfdpic_vec
4783 #undef TARGET_BIG_NAME
4784 #define TARGET_BIG_NAME         "elf32-frvfdpic"
4785 #undef  elf32_bed
4786 #define elf32_bed               elf32_frvfdpic_bed
4787
4788 #undef elf_info_to_howto_rel
4789 #define elf_info_to_howto_rel   frvfdpic_info_to_howto_rel
4790
4791 #undef bfd_elf32_bfd_link_hash_table_create
4792 #define bfd_elf32_bfd_link_hash_table_create \
4793                 frvfdpic_elf_link_hash_table_create
4794 #undef elf_backend_always_size_sections
4795 #define elf_backend_always_size_sections \
4796                 elf32_frvfdpic_always_size_sections
4797 #undef elf_backend_modify_segment_map
4798 #define elf_backend_modify_segment_map \
4799                 elf32_frvfdpic_modify_segment_map
4800 #undef bfd_elf32_bfd_copy_private_bfd_data
4801 #define bfd_elf32_bfd_copy_private_bfd_data \
4802                 elf32_frvfdpic_copy_private_bfd_data
4803
4804 #undef elf_backend_create_dynamic_sections
4805 #define elf_backend_create_dynamic_sections \
4806                 elf32_frvfdpic_create_dynamic_sections
4807 #undef elf_backend_adjust_dynamic_symbol
4808 #define elf_backend_adjust_dynamic_symbol \
4809                 elf32_frvfdpic_adjust_dynamic_symbol
4810 #undef elf_backend_size_dynamic_sections
4811 #define elf_backend_size_dynamic_sections \
4812                 elf32_frvfdpic_size_dynamic_sections
4813 #undef elf_backend_finish_dynamic_symbol
4814 #define elf_backend_finish_dynamic_symbol \
4815                 elf32_frvfdpic_finish_dynamic_symbol
4816 #undef elf_backend_finish_dynamic_sections
4817 #define elf_backend_finish_dynamic_sections \
4818                 elf32_frvfdpic_finish_dynamic_sections
4819
4820 #undef elf_backend_can_make_relative_eh_frame
4821 #define elf_backend_can_make_relative_eh_frame \
4822                 frvfdpic_elf_use_relative_eh_frame
4823 #undef elf_backend_can_make_lsda_relative_eh_frame
4824 #define elf_backend_can_make_lsda_relative_eh_frame \
4825                 frvfdpic_elf_use_relative_eh_frame
4826 #undef elf_backend_encode_eh_address
4827 #define elf_backend_encode_eh_address \
4828                 frvfdpic_elf_encode_eh_address
4829
4830 #undef elf_backend_may_use_rel_p
4831 #define elf_backend_may_use_rel_p       1
4832 #undef elf_backend_may_use_rela_p
4833 #define elf_backend_may_use_rela_p      1
4834 /* We use REL for dynamic relocations only.  */
4835 #undef elf_backend_default_use_rela_p
4836 #define elf_backend_default_use_rela_p  1
4837
4838 #undef elf_backend_omit_section_dynsym
4839 #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
4840
4841 #include "elf32-target.h"