bfd/elf32-frv.c

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