bfd/elf32-frv.c

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