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 64-bit 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   /* A 24-bit pc-relative relocation referencing the TLS PLT entry for
 465      a thread-local symbol.  If the symbol number is 0, it refers to
 466      the module.  */
 467   HOWTO (R_FRV_GETTLSOFF,       /* type */
 468          2,                     /* rightshift */
 469          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 470          26,                    /* bitsize */
 471          TRUE,                  /* pc_relative */
 472          0,                     /* bitpos */
 473          complain_overflow_bitfield, /* complain_on_overflow */
 474          bfd_elf_generic_reloc, /* special_function */
 475          "R_FRV_GETTLSOFF",     /* name */
 476          FALSE,                 /* partial_inplace */
 477          0x7e03ffff,            /* src_mask */
 478          0x7e03ffff,            /* dst_mask */
 479          TRUE),                 /* pcrel_offset */
 480
 481   /* A 64-bit TLS descriptor for a symbol.  This relocation is only
 482      valid as a REL, dynamic relocation.  */
 483   HOWTO (R_FRV_TLSDESC_VALUE,   /* type */
 484          0,                     /* rightshift */
 485          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 486          64,                    /* bitsize */
 487          FALSE,                 /* pc_relative */
 488          0,                     /* bitpos */
 489          complain_overflow_bitfield, /* complain_on_overflow */
 490          bfd_elf_generic_reloc, /* special_function */
 491          "R_FRV_TLSDESC_VALUE", /* name */
 492          FALSE,                 /* partial_inplace */
 493          0xffffffff,            /* src_mask */
 494          0xffffffff,            /* dst_mask */
 495          FALSE),                /* pcrel_offset */
 496
 497   /* A 12-bit signed operand with the GOT offset for the TLS
 498      descriptor of the symbol.  */
 499   HOWTO (R_FRV_GOTTLSDESC12,    /* type */
 500          0,                     /* rightshift */
 501          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 502          12,                    /* bitsize */
 503          FALSE,                 /* pc_relative */
 504          0,                     /* bitpos */
 505          complain_overflow_signed, /* complain_on_overflow */
 506          bfd_elf_generic_reloc, /* special_function */
 507          "R_FRV_GOTTLSDESC12",  /* name */
 508          FALSE,                 /* partial_inplace */
 509          0xfff,                 /* src_mask */
 510          0xfff,                 /* dst_mask */
 511          FALSE),                /* pcrel_offset */
 512
 513   /* The upper 16 bits of the GOT offset for the TLS descriptor of the
 514      symbol.  */
 515   HOWTO (R_FRV_GOTTLSDESCHI,    /* type */
 516          0,                     /* rightshift */
 517          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 518          16,                    /* bitsize */
 519          FALSE,                 /* pc_relative */
 520          0,                     /* bitpos */
 521          complain_overflow_dont, /* complain_on_overflow */
 522          bfd_elf_generic_reloc, /* special_function */
 523          "R_FRV_GOTTLSDESCHI",  /* name */
 524          FALSE,                 /* partial_inplace */
 525          0xffff,                /* src_mask */
 526          0xffff,                /* dst_mask */
 527          FALSE),                /* pcrel_offset */
 528
 529   /* The lower 16 bits of the GOT offset for the TLS descriptor of the
 530      symbol.  */
 531   HOWTO (R_FRV_GOTTLSDESCLO,    /* type */
 532          0,                     /* rightshift */
 533          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 534          16,                    /* bitsize */
 535          FALSE,                 /* pc_relative */
 536          0,                     /* bitpos */
 537          complain_overflow_dont, /* complain_on_overflow */
 538          bfd_elf_generic_reloc, /* special_function */
 539          "R_FRV_GOTTLSDESCLO",  /* name */
 540          FALSE,                 /* partial_inplace */
 541          0xffff,                /* src_mask */
 542          0xffff,                /* dst_mask */
 543          FALSE),                /* pcrel_offset */
 544
 545   /* A 12-bit signed operand with the offset from the module base
 546      address to the thread-local symbol address.  */
 547   HOWTO (R_FRV_TLSMOFF12,        /* type */
 548          0,                     /* rightshift */
 549          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 550          12,                    /* bitsize */
 551          FALSE,                 /* pc_relative */
 552          0,                     /* bitpos */
 553          complain_overflow_signed, /* complain_on_overflow */
 554          bfd_elf_generic_reloc, /* special_function */
 555          "R_FRV_TLSMOFF12",     /* name */
 556          FALSE,                 /* partial_inplace */
 557          0xfff,                 /* src_mask */
 558          0xfff,                 /* dst_mask */
 559          FALSE),                /* pcrel_offset */
 560
 561   /* The upper 16 bits of the offset from the module base address to
 562      the thread-local symbol address.  */
 563   HOWTO (R_FRV_TLSMOFFHI,        /* type */
 564          0,                     /* rightshift */
 565          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 566          16,                    /* bitsize */
 567          FALSE,                 /* pc_relative */
 568          0,                     /* bitpos */
 569          complain_overflow_dont, /* complain_on_overflow */
 570          bfd_elf_generic_reloc, /* special_function */
 571          "R_FRV_TLSMOFFHI",     /* name */
 572          FALSE,                 /* partial_inplace */
 573          0xffff,                /* src_mask */
 574          0xffff,                /* dst_mask */
 575          FALSE),                /* pcrel_offset */
 576
 577   /* The lower 16 bits of the offset from the module base address to
 578      the thread-local symbol address.  */
 579   HOWTO (R_FRV_TLSMOFFLO,       /* type */
 580          0,                     /* rightshift */
 581          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 582          16,                    /* bitsize */
 583          FALSE,                 /* pc_relative */
 584          0,                     /* bitpos */
 585          complain_overflow_dont, /* complain_on_overflow */
 586          bfd_elf_generic_reloc, /* special_function */
 587          "R_FRV_TLSMOFFLO",     /* name */
 588          FALSE,                 /* partial_inplace */
 589          0xffff,                /* src_mask */
 590          0xffff,                /* dst_mask */
 591          FALSE),                /* pcrel_offset */
 592
 593   /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
 594      for a symbol.  */
 595   HOWTO (R_FRV_GOTTLSOFF12,        /* type */
 596          0,                     /* rightshift */
 597          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 598          12,                    /* bitsize */
 599          FALSE,                 /* pc_relative */
 600          0,                     /* bitpos */
 601          complain_overflow_signed, /* complain_on_overflow */
 602          bfd_elf_generic_reloc, /* special_function */
 603          "R_FRV_GOTTLSOFF12",   /* name */
 604          FALSE,                 /* partial_inplace */
 605          0xfff,                 /* src_mask */
 606          0xfff,                 /* dst_mask */
 607          FALSE),                /* pcrel_offset */
 608
 609   /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
 610      symbol.  */
 611   HOWTO (R_FRV_GOTTLSOFFHI,        /* type */
 612          0,                     /* rightshift */
 613          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 614          16,                    /* bitsize */
 615          FALSE,                 /* pc_relative */
 616          0,                     /* bitpos */
 617          complain_overflow_dont, /* complain_on_overflow */
 618          bfd_elf_generic_reloc, /* special_function */
 619          "R_FRV_GOTTLSOFFHI",   /* name */
 620          FALSE,                 /* partial_inplace */
 621          0xffff,                /* src_mask */
 622          0xffff,                /* dst_mask */
 623          FALSE),                /* pcrel_offset */
 624
 625   /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
 626      symbol.  */
 627   HOWTO (R_FRV_GOTTLSOFFLO,     /* type */
 628          0,                     /* rightshift */
 629          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 630          16,                    /* bitsize */
 631          FALSE,                 /* pc_relative */
 632          0,                     /* bitpos */
 633          complain_overflow_dont, /* complain_on_overflow */
 634          bfd_elf_generic_reloc, /* special_function */
 635          "R_FRV_GOTTLSOFFLO",   /* name */
 636          FALSE,                 /* partial_inplace */
 637          0xffff,                /* src_mask */
 638          0xffff,                /* dst_mask */
 639          FALSE),                /* pcrel_offset */
 640
 641   /* The 32-bit offset from the thread pointer (not the module base
 642      address) to a thread-local symbol.  */
 643   HOWTO (R_FRV_TLSOFF,          /* type */
 644          0,                     /* rightshift */
 645          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 646          32,                    /* bitsize */
 647          FALSE,                 /* pc_relative */
 648          0,                     /* bitpos */
 649          complain_overflow_dont, /* complain_on_overflow */
 650          bfd_elf_generic_reloc, /* special_function */
 651          "R_FRV_TLSOFF",        /* name */
 652          FALSE,                 /* partial_inplace */
 653          0xffffffff,            /* src_mask */
 654          0xffffffff,            /* dst_mask */
 655          FALSE),                /* pcrel_offset */
 656
 657   /* An annotation for linker relaxation, that denotes the
 658      symbol+addend whose TLS descriptor is referenced by the sum of
 659      the two input registers of an ldd instruction.  */
 660   HOWTO (R_FRV_TLSDESC_RELAX,   /* type */
 661          0,                     /* rightshift */
 662          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 663          0,                     /* bitsize */
 664          FALSE,                 /* pc_relative */
 665          0,                     /* bitpos */
 666          complain_overflow_dont, /* complain_on_overflow */
 667          bfd_elf_generic_reloc, /* special_function */
 668          "R_FRV_TLSDESC_RELAX", /* name */
 669          FALSE,                 /* partial_inplace */
 670          0,                     /* src_mask */
 671          0,                     /* dst_mask */
 672          FALSE),                /* pcrel_offset */
 673
 674   /* An annotation for linker relaxation, that denotes the
 675      symbol+addend whose TLS resolver entry point is given by the sum
 676      of the two register operands of an calll instruction.  */
 677   HOWTO (R_FRV_GETTLSOFF_RELAX, /* type */
 678          0,                     /* rightshift */
 679          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 680          0,                     /* bitsize */
 681          FALSE,                 /* pc_relative */
 682          0,                     /* bitpos */
 683          complain_overflow_dont, /* complain_on_overflow */
 684          bfd_elf_generic_reloc, /* special_function */
 685          "R_FRV_GETTLSOFF_RELAX", /* name */
 686          FALSE,                 /* partial_inplace */
 687          0,                     /* src_mask */
 688          0,                     /* dst_mask */
 689          FALSE),                /* pcrel_offset */
 690
 691   /* An annotation for linker relaxation, that denotes the
 692      symbol+addend whose TLS offset GOT entry is given by the sum of
 693      the two input registers of an ld instruction.  */
 694   HOWTO (R_FRV_TLSOFF_RELAX,    /* type */
 695          0,                     /* rightshift */
 696          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 697          0,                     /* bitsize */
 698          FALSE,                 /* pc_relative */
 699          0,                     /* bitpos */
 700          complain_overflow_bitfield, /* complain_on_overflow */
 701          bfd_elf_generic_reloc, /* special_function */
 702          "R_FRV_TLSOFF_RELAX",  /* name */
 703          FALSE,                 /* partial_inplace */
 704          0,                     /* src_mask */
 705          0,                     /* dst_mask */
 706          FALSE),                /* pcrel_offset */
 707
 708   /* A 32-bit offset from the module base address to
 709      the thread-local symbol address.  */
 710   HOWTO (R_FRV_TLSMOFF, /* type */
 711          0,                     /* rightshift */
 712          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 713          32,                    /* bitsize */
 714          FALSE,                 /* pc_relative */
 715          0,                     /* bitpos */
 716          complain_overflow_dont, /* complain_on_overflow */
 717          bfd_elf_generic_reloc, /* special_function */
 718          "R_FRV_TLSMOFF",       /* name */
 719          FALSE,                 /* partial_inplace */
 720          0xffffffff,            /* src_mask */
 721          0xffffffff,            /* dst_mask */
 722          FALSE),                /* pcrel_offset */
 723 };
 724
 725 /* GNU extension to record C++ vtable hierarchy.  */
 726 static reloc_howto_type elf32_frv_vtinherit_howto =
 727   HOWTO (R_FRV_GNU_VTINHERIT,   /* type */
 728          0,                     /* rightshift */
 729          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          0,                     /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_dont, /* complain_on_overflow */
 734          NULL,                  /* special_function */
 735          "R_FRV_GNU_VTINHERIT", /* name */
 736          FALSE,                 /* partial_inplace */
 737          0,                     /* src_mask */
 738          0,                     /* dst_mask */
 739          FALSE);                /* pcrel_offset */
 740
 741   /* GNU extension to record C++ vtable member usage.  */
 742 static reloc_howto_type elf32_frv_vtentry_howto =
 743   HOWTO (R_FRV_GNU_VTENTRY,     /* type */
 744          0,                     /* rightshift */
 745          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          0,                     /* bitsize */
 747          FALSE,                 /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_dont, /* complain_on_overflow */
 750          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 751          "R_FRV_GNU_VTENTRY",   /* name */
 752          FALSE,                 /* partial_inplace */
 753          0,                     /* src_mask */
 754          0,                     /* dst_mask */
 755          FALSE);                /* pcrel_offset */
 756
 757 /* The following 3 relocations are REL.  The only difference to the
 758    entries in the table above are that partial_inplace is TRUE.  */
 759 static reloc_howto_type elf32_frv_rel_32_howto =
 760   HOWTO (R_FRV_32,              /* type */
 761          0,                     /* rightshift */
 762          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 763          32,                    /* bitsize */
 764          FALSE,                 /* pc_relative */
 765          0,                     /* bitpos */
 766          complain_overflow_bitfield, /* complain_on_overflow */
 767          bfd_elf_generic_reloc, /* special_function */
 768          "R_FRV_32",            /* name */
 769          TRUE,                  /* partial_inplace */
 770          0xffffffff,            /* src_mask */
 771          0xffffffff,            /* dst_mask */
 772          FALSE);                /* pcrel_offset */
 773
 774 static reloc_howto_type elf32_frv_rel_funcdesc_howto =
 775   HOWTO (R_FRV_FUNCDESC,        /* type */
 776          0,                     /* rightshift */
 777          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 778          32,                    /* bitsize */
 779          FALSE,                 /* pc_relative */
 780          0,                     /* bitpos */
 781          complain_overflow_bitfield, /* complain_on_overflow */
 782          bfd_elf_generic_reloc, /* special_function */
 783          "R_FRV_FUNCDESC",      /* name */
 784          TRUE,                  /* partial_inplace */
 785          0xffffffff,            /* src_mask */
 786          0xffffffff,            /* dst_mask */
 787          FALSE);                /* pcrel_offset */
 788
 789 static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
 790   HOWTO (R_FRV_FUNCDESC_VALUE,  /* type */
 791          0,                     /* rightshift */
 792          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 793          64,                    /* bitsize */
 794          FALSE,                 /* pc_relative */
 795          0,                     /* bitpos */
 796          complain_overflow_bitfield, /* complain_on_overflow */
 797          bfd_elf_generic_reloc, /* special_function */
 798          "R_FRV_FUNCDESC_VALUE", /* name */
 799          TRUE,                  /* partial_inplace */
 800          0xffffffff,            /* src_mask */
 801          0xffffffff,            /* dst_mask */
 802          FALSE);                /* pcrel_offset */
 803
 804 static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto =
 805   /* A 64-bit TLS descriptor for a symbol.  The first word resolves to
 806      an entry point, and the second resolves to a special argument.
 807      If the symbol turns out to be in static TLS, the entry point is a
 808      return instruction, and the special argument is the TLS offset
 809      for the symbol.  If it's in dynamic TLS, the entry point is a TLS
 810      offset resolver, and the special argument is a pointer to a data
 811      structure allocated by the dynamic loader, containing the GOT
 812      address for the offset resolver, the module id, the offset within
 813      the module, and anything else the TLS offset resolver might need
 814      to determine the TLS offset for the symbol in the running
 815      thread.  */
 816   HOWTO (R_FRV_TLSDESC_VALUE,   /* type */
 817          0,                     /* rightshift */
 818          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 819          64,                    /* bitsize */
 820          FALSE,                 /* pc_relative */
 821          0,                     /* bitpos */
 822          complain_overflow_bitfield, /* complain_on_overflow */
 823          bfd_elf_generic_reloc, /* special_function */
 824          "R_FRV_TLSDESC_VALUE", /* name */
 825          TRUE,                  /* partial_inplace */
 826          0xffffffff,            /* src_mask */
 827          0xffffffff,            /* dst_mask */
 828          FALSE);                /* pcrel_offset */
 829
 830 static reloc_howto_type elf32_frv_rel_tlsoff_howto =
 831   /* The 32-bit offset from the thread pointer (not the module base
 832      address) to a thread-local symbol.  */
 833   HOWTO (R_FRV_TLSOFF,          /* type */
 834          0,                     /* rightshift */
 835          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 836          32,                    /* bitsize */
 837          FALSE,                 /* pc_relative */
 838          0,                     /* bitpos */
 839          complain_overflow_bitfield, /* complain_on_overflow */
 840          bfd_elf_generic_reloc, /* special_function */
 841          "R_FRV_TLSOFF",        /* name */
 842          TRUE,                  /* partial_inplace */
 843          0xffffffff,            /* src_mask */
 844          0xffffffff,            /* dst_mask */
 845          FALSE);                /* pcrel_offset */
 846
 847
 848 \f
 849 extern const bfd_target bfd_elf32_frvfdpic_vec;
 850 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfd_elf32_frvfdpic_vec)
 851
 852 /* An extension of the elf hash table data structure, containing some
 853    additional FRV-specific data.  */
 854 struct frvfdpic_elf_link_hash_table
 855 {
 856   struct elf_link_hash_table elf;
 857
 858   /* A pointer to the .got section.  */
 859   asection *sgot;
 860   /* A pointer to the .rel.got section.  */
 861   asection *sgotrel;
 862   /* A pointer to the .rofixup section.  */
 863   asection *sgotfixup;
 864   /* A pointer to the .plt section.  */
 865   asection *splt;
 866   /* A pointer to the .rel.plt section.  */
 867   asection *spltrel;
 868   /* GOT base offset.  */
 869   bfd_vma got0;
 870   /* Location of the first non-lazy PLT entry, i.e., the number of
 871      bytes taken by lazy PLT entries.  If locally-bound TLS
 872      descriptors require a ret instruction, it will be placed at this
 873      offset.  */
 874   bfd_vma plt0;
 875   /* A hash table holding information about which symbols were
 876      referenced with which PIC-related relocations.  */
 877   struct htab *relocs_info;
 878   /* Summary reloc information collected by
 879      _frvfdpic_count_got_plt_entries.  */
 880   struct _frvfdpic_dynamic_got_info *g;
 881 };
 882
 883 /* Get the FRV ELF linker hash table from a link_info structure.  */
 884
 885 #define frvfdpic_hash_table(info) \
 886   ((struct frvfdpic_elf_link_hash_table *) ((info)->hash))
 887
 888 #define frvfdpic_got_section(info) \
 889   (frvfdpic_hash_table (info)->sgot)
 890 #define frvfdpic_gotrel_section(info) \
 891   (frvfdpic_hash_table (info)->sgotrel)
 892 #define frvfdpic_gotfixup_section(info) \
 893   (frvfdpic_hash_table (info)->sgotfixup)
 894 #define frvfdpic_plt_section(info) \
 895   (frvfdpic_hash_table (info)->splt)
 896 #define frvfdpic_pltrel_section(info) \
 897   (frvfdpic_hash_table (info)->spltrel)
 898 #define frvfdpic_relocs_info(info) \
 899   (frvfdpic_hash_table (info)->relocs_info)
 900 #define frvfdpic_got_initial_offset(info) \
 901   (frvfdpic_hash_table (info)->got0)
 902 #define frvfdpic_plt_initial_offset(info) \
 903   (frvfdpic_hash_table (info)->plt0)
 904 #define frvfdpic_dynamic_got_plt_info(info) \
 905   (frvfdpic_hash_table (info)->g)
 906
 907 /* Currently it's the same, but if some day we have a reason to change
 908    it, we'd better be using a different macro.
 909
 910    FIXME: if there's any TLS PLT entry that uses local-exec or
 911    initial-exec models, we could use the ret at the end of any of them
 912    instead of adding one more.  */
 913 #define frvfdpic_plt_tls_ret_offset(info) \
 914   (frvfdpic_plt_initial_offset (info))
 915
 916 /* The name of the dynamic interpreter.  This is put in the .interp
 917    section.  */
 918
 919 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
 920
 921 #define DEFAULT_STACK_SIZE 0x20000
 922
 923 /* This structure is used to collect the number of entries present in
 924    each addressable range of the got.  */
 925 struct _frvfdpic_dynamic_got_info
 926 {
 927   /* Several bits of information about the current link.  */
 928   struct bfd_link_info *info;
 929   /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit
 930      ranges.  */
 931   bfd_vma got12, gotlos, gothilo;
 932   /* Total GOT size needed for function descriptor entries within the 12-,
 933      16- or 32-bit ranges.  */
 934   bfd_vma fd12, fdlos, fdhilo;
 935   /* Total GOT size needed by function descriptor entries referenced
 936      in PLT entries, that would be profitable to place in offsets
 937      close to the PIC register.  */
 938   bfd_vma fdplt;
 939   /* Total PLT size needed by lazy PLT entries.  */
 940   bfd_vma lzplt;
 941   /* Total GOT size needed for TLS descriptor entries within the 12-,
 942      16- or 32-bit ranges.  */
 943   bfd_vma tlsd12, tlsdlos, tlsdhilo;
 944   /* Total GOT size needed by TLS descriptors referenced in PLT
 945      entries, that would be profitable to place in offers close to the
 946      PIC register.  */
 947   bfd_vma tlsdplt;
 948   /* Total PLT size needed by TLS lazy PLT entries.  */
 949   bfd_vma tlslzplt;
 950   /* Number of relocations carried over from input object files.  */
 951   unsigned long relocs;
 952   /* Number of fixups introduced by relocations in input object files.  */
 953   unsigned long fixups;
 954   /* The number of fixups that reference the ret instruction added to
 955      the PLT for locally-resolved TLS descriptors.  */
 956   unsigned long tls_ret_refs;
 957 };
 958
 959 /* This structure is used to assign offsets to got entries, function
 960    descriptors, plt entries and lazy plt entries.  */
 961
 962 struct _frvfdpic_dynamic_got_plt_info
 963 {
 964   /* Summary information collected with _frvfdpic_count_got_plt_entries.  */
 965   struct _frvfdpic_dynamic_got_info g;
 966
 967   /* For each addressable range, we record a MAX (positive) and MIN
 968      (negative) value.  CUR is used to assign got entries, and it's
 969      incremented from an initial positive value to MAX, then from MIN
 970      to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
 971      assign function descriptors, and it's decreased from an initial
 972      non-positive value to MIN, then from MAX down to CUR (unless CUR
 973      wraps around first).  All of MIN, MAX, CUR and FDCUR always point
 974      to even words.  ODD, if non-zero, indicates an odd word to be
 975      used for the next got entry, otherwise CUR is used and
 976      incremented by a pair of words, wrapping around when it reaches
 977      MAX.  FDCUR is decremented (and wrapped) before the next function
 978      descriptor is chosen.  FDPLT indicates the number of remaining
 979      slots that can be used for function descriptors used only by PLT
 980      entries.
 981
 982      TMAX, TMIN and TCUR are used to assign TLS descriptors.  TCUR
 983      starts as MAX, and grows up to TMAX, then wraps around to TMIN
 984      and grows up to MIN.  TLSDPLT indicates the number of remaining
 985      slots that can be used for TLS descriptors used only by TLS PLT
 986      entries.  */
 987   struct _frvfdpic_dynamic_got_alloc_data
 988   {
 989     bfd_signed_vma max, cur, odd, fdcur, min;
 990     bfd_signed_vma tmax, tcur, tmin;
 991     bfd_vma fdplt, tlsdplt;
 992   } got12, gotlos, gothilo;
 993 };
 994
 995 /* Create an FRV ELF linker hash table.  */
 996
 997 static struct bfd_link_hash_table *
 998 frvfdpic_elf_link_hash_table_create (bfd *abfd)
 999 {
1000   struct frvfdpic_elf_link_hash_table *ret;
1001   bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
1002
1003   ret = bfd_zalloc (abfd, amt);
1004   if (ret == NULL)
1005     return NULL;
1006
1007   if (! _bfd_elf_link_hash_table_init (&ret->elf, abfd,
1008                                        _bfd_elf_link_hash_newfunc))
1009     {
1010       free (ret);
1011       return NULL;
1012     }
1013
1014   return &ret->elf.root;
1015 }
1016
1017 /* Decide whether a reference to a symbol can be resolved locally or
1018    not.  If the symbol is protected, we want the local address, but
1019    its function descriptor must be assigned by the dynamic linker.  */
1020 #define FRVFDPIC_SYM_LOCAL(INFO, H) \
1021   (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1022    || ! elf_hash_table (INFO)->dynamic_sections_created \
1023    /* These two additional alternatives are needed for TLS
1024       relocations, that use *ABS*+offset relocations to refer to the
1025       TLS section of the local module.  FIXME: At some point during
1026       linking, the definition section ceases to be regarded as the
1027       absolute section, and starts being regarded as the undefined
1028       section.  */ \
1029    || bfd_is_abs_section ((H)->root.u.def.section) \
1030    || bfd_is_und_section ((H)->root.u.def.section))
1031 #define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
1032   ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1033
1034 /* This structure collects information on what kind of GOT, PLT or
1035    function descriptors are required by relocations that reference a
1036    certain symbol.  */
1037 struct frvfdpic_relocs_info
1038 {
1039   /* The index of the symbol, as stored in the relocation r_info, if
1040      we have a local symbol; -1 otherwise.  */
1041   long symndx;
1042   union
1043   {
1044     /* The input bfd in which the symbol is defined, if it's a local
1045        symbol.  */
1046     bfd *abfd;
1047     /* If symndx == -1, the hash table entry corresponding to a global
1048        symbol (even if it turns out to bind locally, in which case it
1049        should ideally be replaced with section's symndx + addend).  */
1050     struct elf_link_hash_entry *h;
1051   } d;
1052   /* The addend of the relocation that references the symbol.  */
1053   bfd_vma addend;
1054
1055   /* The fields above are used to identify an entry.  The fields below
1056      contain information on how an entry is used and, later on, which
1057      locations it was assigned.  */
1058   /* The following 3 fields record whether the symbol+addend above was
1059      ever referenced with a GOT relocation.  The 12 suffix indicates a
1060      GOT12 relocation; los is used for GOTLO relocations that are not
1061      matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
1062      pairs.  */
1063   unsigned got12:1;
1064   unsigned gotlos:1;
1065   unsigned gothilo:1;
1066   /* Whether a FUNCDESC relocation references symbol+addend.  */
1067   unsigned fd:1;
1068   /* Whether a FUNCDESC_GOT relocation references symbol+addend.  */
1069   unsigned fdgot12:1;
1070   unsigned fdgotlos:1;
1071   unsigned fdgothilo:1;
1072   /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend.  */
1073   unsigned fdgoff12:1;
1074   unsigned fdgofflos:1;
1075   unsigned fdgoffhilo:1;
1076   /* Whether a GETTLSOFF relocation references symbol+addend.  */
1077   unsigned tlsplt:1;
1078   /* FIXME: we should probably add tlspltdesc, tlspltoff and
1079      tlspltimm, to tell what kind of TLS PLT entry we're generating.
1080      We might instead just pre-compute flags telling whether the
1081      object is suitable for local exec, initial exec or general
1082      dynamic addressing, and use that all over the place.  We could
1083      also try to do a better job of merging TLSOFF and TLSDESC entries
1084      in main executables, but perhaps we can get rid of TLSDESC
1085      entirely in them instead.  */
1086   /* Whether a GOTTLSDESC relocation references symbol+addend.  */
1087   unsigned tlsdesc12:1;
1088   unsigned tlsdesclos:1;
1089   unsigned tlsdeschilo:1;
1090   /* Whether a GOTTLSOFF relocation references symbol+addend.  */
1091   unsigned tlsoff12:1;
1092   unsigned tlsofflos:1;
1093   unsigned tlsoffhilo:1;
1094   /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
1095      GOTOFFHI relocations.  The addend doesn't really matter, since we
1096      envision that this will only be used to check whether the symbol
1097      is mapped to the same segment as the got.  */
1098   unsigned gotoff:1;
1099   /* Whether symbol+addend is referenced by a LABEL24 relocation.  */
1100   unsigned call:1;
1101   /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1102      relocation.  */
1103   unsigned sym:1;
1104   /* Whether we need a PLT entry for a symbol.  Should be implied by
1105      something like:
1106      (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h))  */
1107   unsigned plt:1;
1108   /* Whether a function descriptor should be created in this link unit
1109      for symbol+addend.  Should be implied by something like:
1110      (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
1111       || ((fd || fdgot12 || fdgotlos || fdgothilo)
1112           && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h))))  */
1113   unsigned privfd:1;
1114   /* Whether a lazy PLT entry is needed for this symbol+addend.
1115      Should be implied by something like:
1116      (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
1117       && ! (info->flags & DF_BIND_NOW))  */
1118   unsigned lazyplt:1;
1119   /* Whether we've already emitted GOT relocations and PLT entries as
1120      needed for this symbol.  */
1121   unsigned done:1;
1122
1123   /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and
1124      R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing
1125      symbol+addend.  */
1126   unsigned relocs32, relocsfd, relocsfdv, relocstlsd, relocstlsoff;
1127
1128   /* The number of .rofixups entries and dynamic relocations allocated
1129      for this symbol, minus any that might have already been used.  */
1130   unsigned fixups, dynrelocs;
1131
1132   /* The offsets of the GOT entries assigned to symbol+addend, to the
1133      function descriptor's address, and to a function descriptor,
1134      respectively.  Should be zero if unassigned.  The offsets are
1135      counted from the value that will be assigned to the PIC register,
1136      not from the beginning of the .got section.  */
1137   bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1138   /* The offsets of the PLT entries assigned to symbol+addend,
1139      non-lazy and lazy, respectively.  If unassigned, should be
1140      (bfd_vma)-1.  */
1141   bfd_vma plt_entry, lzplt_entry;
1142   /* The offsets of the GOT entries for TLS offset and TLS descriptor.  */
1143   bfd_signed_vma tlsoff_entry, tlsdesc_entry;
1144   /* The offset of the TLS offset PLT entry.  */
1145   bfd_vma tlsplt_entry;
1146 };
1147
1148 /* Compute a hash with the key fields of an frvfdpic_relocs_info entry.  */
1149 static hashval_t
1150 frvfdpic_relocs_info_hash (const void *entry_)
1151 {
1152   const struct frvfdpic_relocs_info *entry = entry_;
1153
1154   return (entry->symndx == -1
1155           ? (long)entry->d.h->root.root.hash
1156           : entry->symndx + entry->d.abfd->id * 257) + entry->addend;
1157 }
1158
1159 /* Test whether the key fields of two frvfdpic_relocs_info entries are
1160    identical.  */
1161 static int
1162 frvfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1163 {
1164   const struct frvfdpic_relocs_info *e1 = entry1;
1165   const struct frvfdpic_relocs_info *e2 = entry2;
1166
1167   return e1->symndx == e2->symndx && e1->addend == e2->addend
1168     && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1169 }
1170
1171 /* Find or create an entry in a hash table HT that matches the key
1172    fields of the given ENTRY.  If it's not found, memory for a new
1173    entry is allocated in ABFD's obstack.  */
1174 static struct frvfdpic_relocs_info *
1175 frvfdpic_relocs_info_find (struct htab *ht,
1176                            bfd *abfd,
1177                            const struct frvfdpic_relocs_info *entry,
1178                            enum insert_option insert)
1179 {
1180   struct frvfdpic_relocs_info **loc =
1181     (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1182
1183   if (! loc)
1184     return NULL;
1185
1186   if (*loc)
1187     return *loc;
1188
1189   *loc = bfd_zalloc (abfd, sizeof (**loc));
1190
1191   if (! *loc)
1192     return *loc;
1193
1194   (*loc)->symndx = entry->symndx;
1195   (*loc)->d = entry->d;
1196   (*loc)->addend = entry->addend;
1197   (*loc)->plt_entry = (bfd_vma)-1;
1198   (*loc)->lzplt_entry = (bfd_vma)-1;
1199   (*loc)->tlsplt_entry = (bfd_vma)-1;
1200
1201   return *loc;
1202 }
1203
1204 /* Obtain the address of the entry in HT associated with H's symbol +
1205    addend, creating a new entry if none existed.  ABFD is only used
1206    for memory allocation purposes.  */
1207 inline static struct frvfdpic_relocs_info *
1208 frvfdpic_relocs_info_for_global (struct htab *ht,
1209                                  bfd *abfd,
1210                                  struct elf_link_hash_entry *h,
1211                                  bfd_vma addend,
1212                                  enum insert_option insert)
1213 {
1214   struct frvfdpic_relocs_info entry;
1215
1216   entry.symndx = -1;
1217   entry.d.h = h;
1218   entry.addend = addend;
1219
1220   return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1221 }
1222
1223 /* Obtain the address of the entry in HT associated with the SYMNDXth
1224    local symbol of the input bfd ABFD, plus the addend, creating a new
1225    entry if none existed.  */
1226 inline static struct frvfdpic_relocs_info *
1227 frvfdpic_relocs_info_for_local (struct htab *ht,
1228                                 bfd *abfd,
1229                                 long symndx,
1230                                 bfd_vma addend,
1231                                 enum insert_option insert)
1232 {
1233   struct frvfdpic_relocs_info entry;
1234
1235   entry.symndx = symndx;
1236   entry.d.abfd = abfd;
1237   entry.addend = addend;
1238
1239   return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
1240 }
1241
1242 /* Merge fields set by check_relocs() of two entries that end up being
1243    mapped to the same (presumably global) symbol.  */
1244
1245 inline static void
1246 frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2,
1247                                       struct frvfdpic_relocs_info const *e1)
1248 {
1249   e2->got12 |= e1->got12;
1250   e2->gotlos |= e1->gotlos;
1251   e2->gothilo |= e1->gothilo;
1252   e2->fd |= e1->fd;
1253   e2->fdgot12 |= e1->fdgot12;
1254   e2->fdgotlos |= e1->fdgotlos;
1255   e2->fdgothilo |= e1->fdgothilo;
1256   e2->fdgoff12 |= e1->fdgoff12;
1257   e2->fdgofflos |= e1->fdgofflos;
1258   e2->fdgoffhilo |= e1->fdgoffhilo;
1259   e2->tlsplt |= e1->tlsplt;
1260   e2->tlsdesc12 |= e1->tlsdesc12;
1261   e2->tlsdesclos |= e1->tlsdesclos;
1262   e2->tlsdeschilo |= e1->tlsdeschilo;
1263   e2->tlsoff12 |= e1->tlsoff12;
1264   e2->tlsofflos |= e1->tlsofflos;
1265   e2->tlsoffhilo |= e1->tlsoffhilo;
1266   e2->gotoff |= e1->gotoff;
1267   e2->call |= e1->call;
1268   e2->sym |= e1->sym;
1269 }
1270
1271 /* Every block of 65535 lazy PLT entries shares a single call to the
1272    resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
1273    32767, counting from 0).  All other lazy PLT entries branch to it
1274    in a single instruction.  */
1275
1276 #define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
1277 #define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
1278
1279 /* Add a dynamic relocation to the SRELOC section.  */
1280
1281 inline static bfd_vma
1282 _frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
1283                          int reloc_type, long dynindx, bfd_vma addend,
1284                          struct frvfdpic_relocs_info *entry)
1285 {
1286   Elf_Internal_Rela outrel;
1287   bfd_vma reloc_offset;
1288
1289   outrel.r_offset = offset;
1290   outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
1291   outrel.r_addend = addend;
1292
1293   reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
1294   BFD_ASSERT (reloc_offset < sreloc->size);
1295   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
1296                             sreloc->contents + reloc_offset);
1297   sreloc->reloc_count++;
1298
1299   /* If the entry's index is zero, this relocation was probably to a
1300      linkonce section that got discarded.  We reserved a dynamic
1301      relocation, but it was for another entry than the one we got at
1302      the time of emitting the relocation.  Unfortunately there's no
1303      simple way for us to catch this situation, since the relocation
1304      is cleared right before calling relocate_section, at which point
1305      we no longer know what the relocation used to point to.  */
1306   if (entry->symndx)
1307     {
1308       BFD_ASSERT (entry->dynrelocs > 0);
1309       entry->dynrelocs--;
1310     }
1311
1312   return reloc_offset;
1313 }
1314
1315 /* Add a fixup to the ROFIXUP section.  */
1316
1317 static bfd_vma
1318 _frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
1319                        struct frvfdpic_relocs_info *entry)
1320 {
1321   bfd_vma fixup_offset;
1322
1323   if (rofixup->flags & SEC_EXCLUDE)
1324     return -1;
1325
1326   fixup_offset = rofixup->reloc_count * 4;
1327   if (rofixup->contents)
1328     {
1329       BFD_ASSERT (fixup_offset < rofixup->size);
1330       bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
1331     }
1332   rofixup->reloc_count++;
1333
1334   if (entry && entry->symndx)
1335     {
1336       /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
1337          above.  */
1338       BFD_ASSERT (entry->fixups > 0);
1339       entry->fixups--;
1340     }
1341
1342   return fixup_offset;
1343 }
1344
1345 /* Find the segment number in which OSEC, and output section, is
1346    located.  */
1347
1348 static unsigned
1349 _frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
1350 {
1351   struct elf_segment_map *m;
1352   Elf_Internal_Phdr *p;
1353
1354   /* Find the segment that contains the output_section.  */
1355   for (m = elf_tdata (output_bfd)->segment_map,
1356          p = elf_tdata (output_bfd)->phdr;
1357        m != NULL;
1358        m = m->next, p++)
1359     {
1360       int i;
1361
1362       for (i = m->count - 1; i >= 0; i--)
1363         if (m->sections[i] == osec)
1364           break;
1365
1366       if (i >= 0)
1367         break;
1368     }
1369
1370   return p - elf_tdata (output_bfd)->phdr;
1371 }
1372
1373 inline static bfd_boolean
1374 _frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
1375 {
1376   unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec);
1377
1378   return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
1379 }
1380
1381 #define FRVFDPIC_TLS_BIAS (2048 - 16)
1382
1383 /* Return the base VMA address which should be subtracted from real addresses
1384    when resolving TLSMOFF relocation.
1385    This is PT_TLS segment p_vaddr, plus the 2048-16 bias.  */
1386
1387 static bfd_vma
1388 tls_biased_base (struct bfd_link_info *info)
1389 {
1390   /* If tls_sec is NULL, we should have signalled an error already.  */
1391   if (elf_hash_table (info)->tls_sec == NULL)
1392     return FRVFDPIC_TLS_BIAS;
1393   return elf_hash_table (info)->tls_sec->vma + FRVFDPIC_TLS_BIAS;
1394 }
1395
1396 /* Generate relocations for GOT entries, function descriptors, and
1397    code for PLT and lazy PLT entries.  */
1398
1399 inline static bfd_boolean
1400 _frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
1401                                        bfd *output_bfd,
1402                                        struct bfd_link_info *info,
1403                                        asection *sec,
1404                                        Elf_Internal_Sym *sym,
1405                                        bfd_vma addend)
1406
1407 {
1408   bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
1409   int dynindx = -1;
1410
1411   if (entry->done)
1412     return TRUE;
1413   entry->done = 1;
1414
1415   if (entry->got_entry || entry->fdgot_entry || entry->fd_entry
1416       || entry->tlsoff_entry || entry->tlsdesc_entry)
1417     {
1418       /* If the symbol is dynamic, consider it for dynamic
1419          relocations, otherwise decay to section + offset.  */
1420       if (entry->symndx == -1 && entry->d.h->dynindx != -1)
1421         dynindx = entry->d.h->dynindx;
1422       else
1423         {
1424           if (sec->output_section
1425               && ! bfd_is_abs_section (sec->output_section)
1426               && ! bfd_is_und_section (sec->output_section))
1427             dynindx = elf_section_data (sec->output_section)->dynindx;
1428           else
1429             dynindx = 0;
1430         }
1431     }
1432
1433   /* Generate relocation for GOT entry pointing to the symbol.  */
1434   if (entry->got_entry)
1435     {
1436       int idx = dynindx;
1437       bfd_vma ad = addend;
1438
1439       /* If the symbol is dynamic but binds locally, use
1440          section+offset.  */
1441       if (sec && (entry->symndx != -1
1442                   || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1443         {
1444           if (entry->symndx == -1)
1445             ad += entry->d.h->root.u.def.value;
1446           else
1447             ad += sym->st_value;
1448           ad += sec->output_offset;
1449           if (sec->output_section && elf_section_data (sec->output_section))
1450             idx = elf_section_data (sec->output_section)->dynindx;
1451           else
1452             idx = 0;
1453         }
1454
1455       /* If we're linking an executable at a fixed address, we can
1456          omit the dynamic relocation as long as the symbol is local to
1457          this module.  */
1458       if (info->executable && !info->pie
1459           && (entry->symndx != -1
1460               || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1461         {
1462           if (sec)
1463             ad += sec->output_section->vma;
1464           if (entry->symndx != -1
1465               || entry->d.h->root.type != bfd_link_hash_undefweak)
1466             _frvfdpic_add_rofixup (output_bfd,
1467                                    frvfdpic_gotfixup_section (info),
1468                                    frvfdpic_got_section (info)->output_section
1469                                    ->vma
1470                                    + frvfdpic_got_section (info)->output_offset
1471                                    + frvfdpic_got_initial_offset (info)
1472                                    + entry->got_entry, entry);
1473         }
1474       else
1475         _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1476                                  _bfd_elf_section_offset
1477                                  (output_bfd, info,
1478                                   frvfdpic_got_section (info),
1479                                   frvfdpic_got_initial_offset (info)
1480                                   + entry->got_entry)
1481                                  + frvfdpic_got_section (info)
1482                                  ->output_section->vma
1483                                  + frvfdpic_got_section (info)->output_offset,
1484                                  R_FRV_32, idx, ad, entry);
1485
1486       bfd_put_32 (output_bfd, ad,
1487                   frvfdpic_got_section (info)->contents
1488                   + frvfdpic_got_initial_offset (info)
1489                   + entry->got_entry);
1490     }
1491
1492   /* Generate relocation for GOT entry pointing to a canonical
1493      function descriptor.  */
1494   if (entry->fdgot_entry)
1495     {
1496       int reloc, idx;
1497       bfd_vma ad = 0;
1498
1499       if (! (entry->symndx == -1
1500              && entry->d.h->root.type == bfd_link_hash_undefweak
1501              && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1502         {
1503           /* If the symbol is dynamic and there may be dynamic symbol
1504              resolution because we are, or are linked with, a shared
1505              library, emit a FUNCDESC relocation such that the dynamic
1506              linker will allocate the function descriptor.  If the
1507              symbol needs a non-local function descriptor but binds
1508              locally (e.g., its visibility is protected, emit a
1509              dynamic relocation decayed to section+offset.  */
1510           if (entry->symndx == -1
1511               && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
1512               && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
1513               && !(info->executable && !info->pie))
1514             {
1515               reloc = R_FRV_FUNCDESC;
1516               idx = elf_section_data (entry->d.h->root.u.def.section
1517                                       ->output_section)->dynindx;
1518               ad = entry->d.h->root.u.def.section->output_offset
1519                 + entry->d.h->root.u.def.value;
1520             }
1521           else if (entry->symndx == -1
1522                    && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
1523             {
1524               reloc = R_FRV_FUNCDESC;
1525               idx = dynindx;
1526               ad = addend;
1527               if (ad)
1528                 return FALSE;
1529             }
1530           else
1531             {
1532               /* Otherwise, we know we have a private function descriptor,
1533                  so reference it directly.  */
1534               if (elf_hash_table (info)->dynamic_sections_created)
1535                 BFD_ASSERT (entry->privfd);
1536               reloc = R_FRV_32;
1537               idx = elf_section_data (frvfdpic_got_section (info)
1538                                       ->output_section)->dynindx;
1539               ad = frvfdpic_got_section (info)->output_offset
1540                 + frvfdpic_got_initial_offset (info) + entry->fd_entry;
1541             }
1542
1543           /* If there is room for dynamic symbol resolution, emit the
1544              dynamic relocation.  However, if we're linking an
1545              executable at a fixed location, we won't have emitted a
1546              dynamic symbol entry for the got section, so idx will be
1547              zero, which means we can and should compute the address
1548              of the private descriptor ourselves.  */
1549           if (info->executable && !info->pie
1550               && (entry->symndx != -1
1551                   || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
1552             {
1553               ad += frvfdpic_got_section (info)->output_section->vma;
1554               _frvfdpic_add_rofixup (output_bfd,
1555                                      frvfdpic_gotfixup_section (info),
1556                                      frvfdpic_got_section (info)
1557                                      ->output_section->vma
1558                                      + frvfdpic_got_section (info)
1559                                      ->output_offset
1560                                      + frvfdpic_got_initial_offset (info)
1561                                      + entry->fdgot_entry, entry);
1562             }
1563           else
1564             _frvfdpic_add_dyn_reloc (output_bfd,
1565                                      frvfdpic_gotrel_section (info),
1566                                      _bfd_elf_section_offset
1567                                      (output_bfd, info,
1568                                       frvfdpic_got_section (info),
1569                                       frvfdpic_got_initial_offset (info)
1570                                       + entry->fdgot_entry)
1571                                      + frvfdpic_got_section (info)
1572                                      ->output_section->vma
1573                                      + frvfdpic_got_section (info)
1574                                      ->output_offset,
1575                                      reloc, idx, ad, entry);
1576         }
1577
1578       bfd_put_32 (output_bfd, ad,
1579                   frvfdpic_got_section (info)->contents
1580                   + frvfdpic_got_initial_offset (info)
1581                   + entry->fdgot_entry);
1582     }
1583
1584   /* Generate relocation to fill in a private function descriptor in
1585      the GOT.  */
1586   if (entry->fd_entry)
1587     {
1588       int idx = dynindx;
1589       bfd_vma ad = addend;
1590       bfd_vma ofst;
1591       long lowword, highword;
1592
1593       /* If the symbol is dynamic but binds locally, use
1594          section+offset.  */
1595       if (sec && (entry->symndx != -1
1596                   || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1597         {
1598           if (entry->symndx == -1)
1599             ad += entry->d.h->root.u.def.value;
1600           else
1601             ad += sym->st_value;
1602           ad += sec->output_offset;
1603           if (sec->output_section && elf_section_data (sec->output_section))
1604             idx = elf_section_data (sec->output_section)->dynindx;
1605           else
1606             idx = 0;
1607         }
1608
1609       /* If we're linking an executable at a fixed address, we can
1610          omit the dynamic relocation as long as the symbol is local to
1611          this module.  */
1612       if (info->executable && !info->pie
1613           && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1614         {
1615           if (sec)
1616             ad += sec->output_section->vma;
1617           ofst = 0;
1618           if (entry->symndx != -1
1619               || entry->d.h->root.type != bfd_link_hash_undefweak)
1620             {
1621               _frvfdpic_add_rofixup (output_bfd,
1622                                      frvfdpic_gotfixup_section (info),
1623                                      frvfdpic_got_section (info)
1624                                      ->output_section->vma
1625                                      + frvfdpic_got_section (info)
1626                                      ->output_offset
1627                                      + frvfdpic_got_initial_offset (info)
1628                                      + entry->fd_entry, entry);
1629               _frvfdpic_add_rofixup (output_bfd,
1630                                      frvfdpic_gotfixup_section (info),
1631                                      frvfdpic_got_section (info)
1632                                      ->output_section->vma
1633                                      + frvfdpic_got_section (info)
1634                                      ->output_offset
1635                                      + frvfdpic_got_initial_offset (info)
1636                                      + entry->fd_entry + 4, entry);
1637             }
1638         }
1639       else
1640         {
1641           ofst =
1642             _frvfdpic_add_dyn_reloc (output_bfd,
1643                                      entry->lazyplt
1644                                      ? frvfdpic_pltrel_section (info)
1645                                      : frvfdpic_gotrel_section (info),
1646                                      _bfd_elf_section_offset
1647                                      (output_bfd, info,
1648                                       frvfdpic_got_section (info),
1649                                       frvfdpic_got_initial_offset (info)
1650                                       + entry->fd_entry)
1651                                      + frvfdpic_got_section (info)
1652                                      ->output_section->vma
1653                                      + frvfdpic_got_section (info)
1654                                      ->output_offset,
1655                                      R_FRV_FUNCDESC_VALUE, idx, ad, entry);
1656         }
1657
1658       /* If we've omitted the dynamic relocation, just emit the fixed
1659          addresses of the symbol and of the local GOT base offset.  */
1660       if (info->executable && !info->pie && sec && sec->output_section)
1661         {
1662           lowword = ad;
1663           highword = frvfdpic_got_section (info)->output_section->vma
1664             + frvfdpic_got_section (info)->output_offset
1665             + frvfdpic_got_initial_offset (info);
1666         }
1667       else if (entry->lazyplt)
1668         {
1669           if (ad)
1670             return FALSE;
1671
1672           fd_lazy_rel_offset = ofst;
1673
1674           /* A function descriptor used for lazy or local resolving is
1675              initialized such that its high word contains the output
1676              section index in which the PLT entries are located, and
1677              the low word contains the address of the lazy PLT entry
1678              entry point, that must be within the memory region
1679              assigned to that section.  */
1680           lowword = entry->lzplt_entry + 4
1681             + frvfdpic_plt_section (info)->output_offset
1682             + frvfdpic_plt_section (info)->output_section->vma;
1683           highword = _frvfdpic_osec_to_segment
1684             (output_bfd, frvfdpic_plt_section (info)->output_section);
1685         }
1686       else
1687         {
1688           /* A function descriptor for a local function gets the index
1689              of the section.  For a non-local function, it's
1690              disregarded.  */
1691           lowword = ad;
1692           if (entry->symndx == -1 && entry->d.h->dynindx != -1
1693               && entry->d.h->dynindx == idx)
1694             highword = 0;
1695           else
1696             highword = _frvfdpic_osec_to_segment
1697               (output_bfd, sec->output_section);
1698         }
1699
1700       bfd_put_32 (output_bfd, lowword,
1701                   frvfdpic_got_section (info)->contents
1702                   + frvfdpic_got_initial_offset (info)
1703                   + entry->fd_entry);
1704       bfd_put_32 (output_bfd, highword,
1705                   frvfdpic_got_section (info)->contents
1706                   + frvfdpic_got_initial_offset (info)
1707                   + entry->fd_entry + 4);
1708     }
1709
1710   /* Generate code for the PLT entry.  */
1711   if (entry->plt_entry != (bfd_vma) -1)
1712     {
1713       bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1714         + entry->plt_entry;
1715
1716       BFD_ASSERT (entry->fd_entry);
1717
1718       /* Figure out what kind of PLT entry we need, depending on the
1719          location of the function descriptor within the GOT.  */
1720       if (entry->fd_entry >= -(1 << (12 - 1))
1721           && entry->fd_entry < (1 << (12 - 1)))
1722         {
1723           /* lddi @(gr15, fd_entry), gr14 */
1724           bfd_put_32 (output_bfd,
1725                       0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
1726                       plt_code);
1727           plt_code += 4;
1728         }
1729       else
1730         {
1731           if (entry->fd_entry >= -(1 << (16 - 1))
1732               && entry->fd_entry < (1 << (16 - 1)))
1733             {
1734               /* setlos lo(fd_entry), gr14 */
1735               bfd_put_32 (output_bfd,
1736                           0x9cfc0000
1737                           | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1738                           plt_code);
1739               plt_code += 4;
1740             }
1741           else
1742             {
1743               /* sethi.p hi(fd_entry), gr14
1744                  setlo lo(fd_entry), gr14 */
1745               bfd_put_32 (output_bfd,
1746                           0x1cf80000
1747                           | ((entry->fd_entry >> 16)
1748                              & (((bfd_vma)1 << 16) - 1)),
1749                           plt_code);
1750               plt_code += 4;
1751               bfd_put_32 (output_bfd,
1752                           0x9cf40000
1753                           | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
1754                           plt_code);
1755               plt_code += 4;
1756             }
1757           /* ldd @(gr14,gr15),gr14 */
1758           bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
1759           plt_code += 4;
1760         }
1761       /* jmpl @(gr14,gr0) */
1762       bfd_put_32 (output_bfd, 0x8030e000, plt_code);
1763     }
1764
1765   /* Generate code for the lazy PLT entry.  */
1766   if (entry->lzplt_entry != (bfd_vma) -1)
1767     {
1768       bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents
1769         + entry->lzplt_entry;
1770       bfd_vma resolverStub_addr;
1771
1772       bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
1773       lzplt_code += 4;
1774
1775       resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
1776         * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC;
1777       if (resolverStub_addr >= frvfdpic_plt_initial_offset (info))
1778         resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12;
1779
1780       if (entry->lzplt_entry == resolverStub_addr)
1781         {
1782           /* This is a lazy PLT entry that includes a resolver call.  */
1783           /* ldd @(gr15,gr0), gr4
1784              jmpl @(gr4,gr0)  */
1785           bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
1786           bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
1787         }
1788       else
1789         {
1790           /* bra  resolverStub */
1791           bfd_put_32 (output_bfd,
1792                       0xc01a0000
1793                       | (((resolverStub_addr - entry->lzplt_entry)
1794                           / 4) & (((bfd_vma)1 << 16) - 1)),
1795                       lzplt_code);
1796         }
1797     }
1798
1799   /* Generate relocation for GOT entry holding the TLS offset.  */
1800   if (entry->tlsoff_entry)
1801     {
1802       int idx = dynindx;
1803       bfd_vma ad = addend;
1804
1805       if (entry->symndx != -1
1806           || FRVFDPIC_SYM_LOCAL (info, entry->d.h))
1807         {
1808           /* If the symbol is dynamic but binds locally, use
1809              section+offset.  */
1810           if (sec)
1811             {
1812               if (entry->symndx == -1)
1813                 ad += entry->d.h->root.u.def.value;
1814               else
1815                 ad += sym->st_value;
1816               ad += sec->output_offset;
1817               if (sec->output_section
1818                   && elf_section_data (sec->output_section))
1819                 idx = elf_section_data (sec->output_section)->dynindx;
1820               else
1821                 idx = 0;
1822             }
1823         }
1824
1825       /* *ABS*+addend is special for TLS relocations, use only the
1826          addend.  */
1827       if (info->executable
1828           && idx == 0
1829           && (bfd_is_abs_section (sec)
1830               || bfd_is_und_section (sec)))
1831         ;
1832       /* If we're linking an executable, we can entirely omit the
1833          dynamic relocation if the symbol is local to this module.  */
1834       else if (info->executable
1835                && (entry->symndx != -1
1836                    || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1837         {
1838           if (sec)
1839             ad += sec->output_section->vma - tls_biased_base (info);
1840         }
1841       else
1842         {
1843           if (idx == 0
1844               && (bfd_is_abs_section (sec)
1845                   || bfd_is_und_section (sec)))
1846             {
1847               idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1848               ad += FRVFDPIC_TLS_BIAS;
1849             }
1850           _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1851                                    _bfd_elf_section_offset
1852                                    (output_bfd, info,
1853                                     frvfdpic_got_section (info),
1854                                     frvfdpic_got_initial_offset (info)
1855                                     + entry->tlsoff_entry)
1856                                    + frvfdpic_got_section (info)
1857                                    ->output_section->vma
1858                                    + frvfdpic_got_section (info)
1859                                    ->output_offset,
1860                                    R_FRV_TLSOFF, idx, ad, entry);
1861         }
1862
1863       bfd_put_32 (output_bfd, ad,
1864                   frvfdpic_got_section (info)->contents
1865                   + frvfdpic_got_initial_offset (info)
1866                   + entry->tlsoff_entry);
1867     }
1868
1869   if (entry->tlsdesc_entry)
1870     {
1871       int idx = dynindx;
1872       bfd_vma ad = addend;
1873
1874       /* If the symbol is dynamic but binds locally, use
1875          section+offset.  */
1876       if (sec && (entry->symndx != -1
1877                   || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1878         {
1879           if (entry->symndx == -1)
1880             ad += entry->d.h->root.u.def.value;
1881           else
1882             ad += sym->st_value;
1883           ad += sec->output_offset;
1884           if (sec->output_section && elf_section_data (sec->output_section))
1885             idx = elf_section_data (sec->output_section)->dynindx;
1886           else
1887             idx = 0;
1888         }
1889
1890       /* If we didn't set up a TLS offset entry, but we're linking an
1891          executable and the symbol binds locally, we can use the
1892          module offset in the TLS descriptor in relaxations.  */
1893       if (info->executable && ! entry->tlsoff_entry)
1894         entry->tlsoff_entry = entry->tlsdesc_entry + 4;
1895
1896       if (info->executable && !info->pie
1897           && ((idx == 0
1898                && (bfd_is_abs_section (sec)
1899                    || bfd_is_und_section (sec)))
1900               || entry->symndx != -1
1901               || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1902         {
1903           /* *ABS*+addend is special for TLS relocations, use only the
1904              addend for the TLS offset, and take the module id as
1905              0.  */
1906           if (idx == 0
1907               && (bfd_is_abs_section (sec)
1908                   || bfd_is_und_section (sec)))
1909             ;
1910           /* For other TLS symbols that bind locally, add the section
1911              TLS offset to the addend.  */
1912           else if (sec)
1913             ad += sec->output_section->vma - tls_biased_base (info);
1914
1915           bfd_put_32 (output_bfd,
1916                       frvfdpic_plt_section (info)->output_section->vma
1917                       + frvfdpic_plt_section (info)->output_offset
1918                       + frvfdpic_plt_tls_ret_offset (info),
1919                       frvfdpic_got_section (info)->contents
1920                       + frvfdpic_got_initial_offset (info)
1921                       + entry->tlsdesc_entry);
1922
1923           _frvfdpic_add_rofixup (output_bfd,
1924                                  frvfdpic_gotfixup_section (info),
1925                                  frvfdpic_got_section (info)
1926                                  ->output_section->vma
1927                                  + frvfdpic_got_section (info)
1928                                  ->output_offset
1929                                  + frvfdpic_got_initial_offset (info)
1930                                  + entry->tlsdesc_entry, entry);
1931
1932           BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs);
1933
1934           /* We've used one of the reserved fixups, so discount it so
1935              that we can check at the end that we've used them
1936              all.  */
1937           frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs--;
1938
1939           /* While at that, make sure the ret instruction makes to the
1940              right location in the PLT.  We could do it only when we
1941              got to 0, but since the check at the end will only print
1942              a warning, make sure we have the ret in place in case the
1943              warning is missed.  */
1944           bfd_put_32 (output_bfd, 0xc03a4000,
1945                       frvfdpic_plt_section (info)->contents
1946                       + frvfdpic_plt_tls_ret_offset (info));
1947         }
1948       else
1949         {
1950           if (idx == 0
1951               && (bfd_is_abs_section (sec)
1952                   || bfd_is_und_section (sec)))
1953             {
1954               idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
1955               ad += FRVFDPIC_TLS_BIAS;
1956             }
1957
1958           _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
1959                                    _bfd_elf_section_offset
1960                                    (output_bfd, info,
1961                                     frvfdpic_got_section (info),
1962                                     frvfdpic_got_initial_offset (info)
1963                                     + entry->tlsdesc_entry)
1964                                    + frvfdpic_got_section (info)
1965                                    ->output_section->vma
1966                                    + frvfdpic_got_section (info)
1967                                    ->output_offset,
1968                                    R_FRV_TLSDESC_VALUE, idx, ad, entry);
1969
1970           bfd_put_32 (output_bfd, 0,
1971                       frvfdpic_got_section (info)->contents
1972                       + frvfdpic_got_initial_offset (info)
1973                       + entry->tlsdesc_entry);
1974         }
1975
1976       bfd_put_32 (output_bfd, ad,
1977                   frvfdpic_got_section (info)->contents
1978                   + frvfdpic_got_initial_offset (info)
1979                   + entry->tlsdesc_entry + 4);
1980     }
1981
1982   /* Generate code for the get-TLS-offset PLT entry.  */
1983   if (entry->tlsplt_entry != (bfd_vma) -1)
1984     {
1985       bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
1986         + entry->tlsplt_entry;
1987
1988       if (info->executable
1989           && (entry->symndx != -1
1990               || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
1991         {
1992           int idx = dynindx;
1993           bfd_vma ad = addend;
1994
1995           /* sec may be NULL when referencing an undefweak symbol
1996              while linking a static executable.  */
1997           if (!sec)
1998             {
1999               BFD_ASSERT (entry->symndx == -1
2000                           && entry->d.h->root.type == bfd_link_hash_undefweak);
2001             }
2002           else
2003             {
2004               if (entry->symndx == -1)
2005                 ad += entry->d.h->root.u.def.value;
2006               else
2007                 ad += sym->st_value;
2008               ad += sec->output_offset;
2009               if (sec->output_section
2010                   && elf_section_data (sec->output_section))
2011                 idx = elf_section_data (sec->output_section)->dynindx;
2012               else
2013                 idx = 0;
2014             }
2015
2016           /* *ABS*+addend is special for TLS relocations, use only the
2017              addend for the TLS offset, and take the module id as
2018              0.  */
2019           if (idx == 0
2020               && (bfd_is_abs_section (sec)
2021                   || bfd_is_und_section (sec)))
2022             ;
2023           /* For other TLS symbols that bind locally, add the section
2024              TLS offset to the addend.  */
2025           else if (sec)
2026             ad += sec->output_section->vma - tls_biased_base (info);
2027
2028           if ((bfd_signed_vma)ad >= -(1 << (16 - 1))
2029               && (bfd_signed_vma)ad < (1 << (16 - 1)))
2030             {
2031               /* setlos lo(ad), gr9 */
2032               bfd_put_32 (output_bfd,
2033                           0x92fc0000
2034                           | (ad
2035                              & (((bfd_vma)1 << 16) - 1)),
2036                           plt_code);
2037               plt_code += 4;
2038             }
2039           else
2040             {
2041               /* sethi.p hi(ad), gr9
2042                  setlo lo(ad), gr9 */
2043               bfd_put_32 (output_bfd,
2044                           0x12f80000
2045                           | ((ad >> 16)
2046                              & (((bfd_vma)1 << 16) - 1)),
2047                           plt_code);
2048               plt_code += 4;
2049               bfd_put_32 (output_bfd,
2050                           0x92f40000
2051                           | (ad
2052                              & (((bfd_vma)1 << 16) - 1)),
2053                           plt_code);
2054               plt_code += 4;
2055             }
2056           /* ret */
2057           bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2058         }
2059       else if (entry->tlsoff_entry)
2060         {
2061           /* Figure out what kind of PLT entry we need, depending on the
2062              location of the TLS descriptor within the GOT.  */
2063           if (entry->tlsoff_entry >= -(1 << (12 - 1))
2064               && entry->tlsoff_entry < (1 << (12 - 1)))
2065             {
2066               /* ldi @(gr15, tlsoff_entry), gr9 */
2067               bfd_put_32 (output_bfd,
2068                           0x92c8f000 | (entry->tlsoff_entry
2069                                         & ((1 << 12) - 1)),
2070                           plt_code);
2071               plt_code += 4;
2072             }
2073           else
2074             {
2075               if (entry->tlsoff_entry >= -(1 << (16 - 1))
2076                   && entry->tlsoff_entry < (1 << (16 - 1)))
2077                 {
2078                   /* setlos lo(tlsoff_entry), gr8 */
2079                   bfd_put_32 (output_bfd,
2080                               0x90fc0000
2081                               | (entry->tlsoff_entry
2082                                  & (((bfd_vma)1 << 16) - 1)),
2083                               plt_code);
2084                   plt_code += 4;
2085                 }
2086               else
2087                 {
2088                   /* sethi.p hi(tlsoff_entry), gr8
2089                      setlo lo(tlsoff_entry), gr8 */
2090                   bfd_put_32 (output_bfd,
2091                               0x10f80000
2092                               | ((entry->tlsoff_entry >> 16)
2093                                  & (((bfd_vma)1 << 16) - 1)),
2094                               plt_code);
2095                   plt_code += 4;
2096                   bfd_put_32 (output_bfd,
2097                               0x90f40000
2098                               | (entry->tlsoff_entry
2099                                  & (((bfd_vma)1 << 16) - 1)),
2100                               plt_code);
2101                   plt_code += 4;
2102                 }
2103               /* ld @(gr15,gr8),gr9 */
2104               bfd_put_32 (output_bfd, 0x9008f108, plt_code);
2105               plt_code += 4;
2106             }
2107           /* ret */
2108           bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
2109         }
2110       else
2111         {
2112           BFD_ASSERT (entry->tlsdesc_entry);
2113
2114           /* Figure out what kind of PLT entry we need, depending on the
2115              location of the TLS descriptor within the GOT.  */
2116           if (entry->tlsdesc_entry >= -(1 << (12 - 1))
2117               && entry->tlsdesc_entry < (1 << (12 - 1)))
2118             {
2119               /* lddi @(gr15, tlsdesc_entry), gr8 */
2120               bfd_put_32 (output_bfd,
2121                           0x90ccf000 | (entry->tlsdesc_entry
2122                                         & ((1 << 12) - 1)),
2123                           plt_code);
2124               plt_code += 4;
2125             }
2126           else
2127             {
2128               if (entry->tlsdesc_entry >= -(1 << (16 - 1))
2129                   && entry->tlsdesc_entry < (1 << (16 - 1)))
2130                 {
2131                   /* setlos lo(tlsdesc_entry), gr8 */
2132                   bfd_put_32 (output_bfd,
2133                               0x90fc0000
2134                               | (entry->tlsdesc_entry
2135                                  & (((bfd_vma)1 << 16) - 1)),
2136                               plt_code);
2137                   plt_code += 4;
2138                 }
2139               else
2140                 {
2141                   /* sethi.p hi(tlsdesc_entry), gr8
2142                      setlo lo(tlsdesc_entry), gr8 */
2143                   bfd_put_32 (output_bfd,
2144                               0x10f80000
2145                               | ((entry->tlsdesc_entry >> 16)
2146                                  & (((bfd_vma)1 << 16) - 1)),
2147                               plt_code);
2148                   plt_code += 4;
2149                   bfd_put_32 (output_bfd,
2150                               0x90f40000
2151                               | (entry->tlsdesc_entry
2152                                  & (((bfd_vma)1 << 16) - 1)),
2153                               plt_code);
2154                   plt_code += 4;
2155                 }
2156               /* ldd @(gr15,gr8),gr8 */
2157               bfd_put_32 (output_bfd, 0x9008f148, plt_code);
2158               plt_code += 4;
2159             }
2160           /* jmpl @(gr8,gr0) */
2161           bfd_put_32 (output_bfd, 0x80308000, plt_code);
2162         }
2163     }
2164
2165   return TRUE;
2166 }
2167
2168 /* Handle an FRV small data reloc.  */
2169
2170 static bfd_reloc_status_type
2171 elf32_frv_relocate_gprel12 (info, input_bfd, input_section, relocation,
2172                             contents, value)
2173      struct bfd_link_info *info;
2174      bfd *input_bfd;
2175      asection *input_section;
2176      Elf_Internal_Rela *relocation;
2177      bfd_byte *contents;
2178      bfd_vma value;
2179 {
2180   bfd_vma insn;
2181   bfd_vma gp;
2182   struct bfd_link_hash_entry *h;
2183
2184   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2185
2186   gp = (h->u.def.value
2187         + h->u.def.section->output_section->vma
2188         + h->u.def.section->output_offset);
2189
2190   value -= input_section->output_section->vma;
2191   value -= (gp - input_section->output_section->vma);
2192
2193   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2194
2195   value += relocation->r_addend;
2196
2197   if ((long) value > 0x7ff || (long) value < -0x800)
2198     return bfd_reloc_overflow;
2199
2200   bfd_put_32 (input_bfd,
2201               (insn & 0xfffff000) | (value & 0xfff),
2202               contents + relocation->r_offset);
2203
2204   return bfd_reloc_ok;
2205 }
2206
2207 /* Handle an FRV small data reloc. for the u12 field.  */
2208
2209 static bfd_reloc_status_type
2210 elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, relocation,
2211                              contents, value)
2212      struct bfd_link_info *info;
2213      bfd *input_bfd;
2214      asection *input_section;
2215      Elf_Internal_Rela *relocation;
2216      bfd_byte *contents;
2217      bfd_vma value;
2218 {
2219   bfd_vma insn;
2220   bfd_vma gp;
2221   struct bfd_link_hash_entry *h;
2222   bfd_vma mask;
2223
2224   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2225
2226   gp = (h->u.def.value
2227         + h->u.def.section->output_section->vma
2228         + h->u.def.section->output_offset);
2229
2230   value -= input_section->output_section->vma;
2231   value -= (gp - input_section->output_section->vma);
2232
2233   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2234
2235   value += relocation->r_addend;
2236
2237   if ((long) value > 0x7ff || (long) value < -0x800)
2238     return bfd_reloc_overflow;
2239
2240   /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0.  */
2241   mask = 0x3f03f;
2242   insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
2243
2244   bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2245
2246   return bfd_reloc_ok;
2247 }
2248
2249 /* Handle an FRV ELF HI16 reloc.  */
2250
2251 static bfd_reloc_status_type
2252 elf32_frv_relocate_hi16 (input_bfd, relhi, contents, value)
2253      bfd *input_bfd;
2254      Elf_Internal_Rela *relhi;
2255      bfd_byte *contents;
2256      bfd_vma value;
2257 {
2258   bfd_vma insn;
2259
2260   insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
2261
2262   value += relhi->r_addend;
2263   value = ((value >> 16) & 0xffff);
2264
2265   insn = (insn & 0xffff0000) | value;
2266
2267   if ((long) value > 0xffff || (long) value < -0x10000)
2268     return bfd_reloc_overflow;
2269
2270   bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
2271   return bfd_reloc_ok;
2272
2273 }
2274 static bfd_reloc_status_type
2275 elf32_frv_relocate_lo16 (input_bfd, rello, contents, value)
2276      bfd *input_bfd;
2277      Elf_Internal_Rela *rello;
2278      bfd_byte *contents;
2279      bfd_vma value;
2280 {
2281   bfd_vma insn;
2282
2283   insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
2284
2285   value += rello->r_addend;
2286   value = value & 0xffff;
2287
2288   insn = (insn & 0xffff0000) | value;
2289
2290   if ((long) value > 0xffff || (long) value < -0x10000)
2291     return bfd_reloc_overflow;
2292
2293   bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
2294   return bfd_reloc_ok;
2295 }
2296
2297 /* Perform the relocation for the CALL label24 instruction.  */
2298
2299 static bfd_reloc_status_type
2300 elf32_frv_relocate_label24 (input_bfd, input_section, rello, contents, value)
2301      bfd *input_bfd;
2302      asection *input_section;
2303      Elf_Internal_Rela *rello;
2304      bfd_byte *contents;
2305      bfd_vma value;
2306 {
2307   bfd_vma insn;
2308   bfd_vma label6;
2309   bfd_vma label18;
2310
2311   /* The format for the call instruction is:
2312
2313     0 000000 0001111 000000000000000000
2314       label6 opcode  label18
2315
2316     The branch calculation is: pc + (4*label24)
2317     where label24 is the concatenation of label6 and label18.  */
2318
2319   /* Grab the instruction.  */
2320   insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
2321
2322   value -= input_section->output_section->vma + input_section->output_offset;
2323   value -= rello->r_offset;
2324   value += rello->r_addend;
2325
2326   value = value >> 2;
2327
2328   label6  = value & 0xfc0000;
2329   label6  = label6 << 7;
2330
2331   label18 = value & 0x3ffff;
2332
2333   insn = insn & 0x803c0000;
2334   insn = insn | label6;
2335   insn = insn | label18;
2336
2337   bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
2338
2339   return bfd_reloc_ok;
2340 }
2341
2342 static bfd_reloc_status_type
2343 elf32_frv_relocate_gprelhi (info, input_bfd, input_section, relocation,
2344                             contents, value)
2345      struct bfd_link_info *info;
2346      bfd *input_bfd;
2347      asection *input_section;
2348      Elf_Internal_Rela *relocation;
2349      bfd_byte *contents;
2350      bfd_vma value;
2351 {
2352   bfd_vma insn;
2353   bfd_vma gp;
2354   struct bfd_link_hash_entry *h;
2355
2356   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2357
2358   gp = (h->u.def.value
2359         + h->u.def.section->output_section->vma
2360         + h->u.def.section->output_offset);
2361
2362   value -= input_section->output_section->vma;
2363   value -= (gp - input_section->output_section->vma);
2364   value += relocation->r_addend;
2365   value = ((value >> 16) & 0xffff);
2366
2367   if ((long) value > 0xffff || (long) value < -0x10000)
2368     return bfd_reloc_overflow;
2369
2370   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2371   insn = (insn & 0xffff0000) | value;
2372
2373   bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2374   return bfd_reloc_ok;
2375 }
2376
2377 static bfd_reloc_status_type
2378 elf32_frv_relocate_gprello (info, input_bfd, input_section, relocation,
2379                             contents, value)
2380      struct bfd_link_info *info;
2381      bfd *input_bfd;
2382      asection *input_section;
2383      Elf_Internal_Rela *relocation;
2384      bfd_byte *contents;
2385      bfd_vma value;
2386 {
2387   bfd_vma insn;
2388   bfd_vma gp;
2389   struct bfd_link_hash_entry *h;
2390
2391   h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
2392
2393   gp = (h->u.def.value
2394         + h->u.def.section->output_section->vma
2395         + h->u.def.section->output_offset);
2396
2397   value -= input_section->output_section->vma;
2398   value -= (gp - input_section->output_section->vma);
2399   value += relocation->r_addend;
2400   value = value & 0xffff;
2401
2402   if ((long) value > 0xffff || (long) value < -0x10000)
2403     return bfd_reloc_overflow;
2404
2405   insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
2406   insn = (insn & 0xffff0000) | value;
2407
2408   bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
2409
2410  return bfd_reloc_ok;
2411 }
2412
2413 static reloc_howto_type *
2414 frv_reloc_type_lookup (abfd, code)
2415      bfd *abfd ATTRIBUTE_UNUSED;
2416      bfd_reloc_code_real_type code;
2417 {
2418   switch (code)
2419     {
2420     default:
2421       break;
2422
2423     case BFD_RELOC_NONE:
2424       return &elf32_frv_howto_table[ (int) R_FRV_NONE];
2425
2426     case BFD_RELOC_32:
2427       if (elf_elfheader (abfd)->e_type == ET_EXEC
2428           || elf_elfheader (abfd)->e_type == ET_DYN)
2429         return &elf32_frv_rel_32_howto;
2430       /* Fall through.  */
2431     case BFD_RELOC_CTOR:
2432       return &elf32_frv_howto_table[ (int) R_FRV_32];
2433
2434     case BFD_RELOC_FRV_LABEL16:
2435       return &elf32_frv_howto_table[ (int) R_FRV_LABEL16];
2436
2437     case BFD_RELOC_FRV_LABEL24:
2438       return &elf32_frv_howto_table[ (int) R_FRV_LABEL24];
2439
2440     case BFD_RELOC_FRV_LO16:
2441       return &elf32_frv_howto_table[ (int) R_FRV_LO16];
2442
2443     case BFD_RELOC_FRV_HI16:
2444       return &elf32_frv_howto_table[ (int) R_FRV_HI16];
2445
2446     case BFD_RELOC_FRV_GPREL12:
2447       return &elf32_frv_howto_table[ (int) R_FRV_GPREL12];
2448
2449     case BFD_RELOC_FRV_GPRELU12:
2450       return &elf32_frv_howto_table[ (int) R_FRV_GPRELU12];
2451
2452     case BFD_RELOC_FRV_GPREL32:
2453       return &elf32_frv_howto_table[ (int) R_FRV_GPREL32];
2454
2455     case BFD_RELOC_FRV_GPRELHI:
2456       return &elf32_frv_howto_table[ (int) R_FRV_GPRELHI];
2457
2458     case BFD_RELOC_FRV_GPRELLO:
2459       return &elf32_frv_howto_table[ (int) R_FRV_GPRELLO];
2460
2461     case BFD_RELOC_FRV_GOT12:
2462       return &elf32_frv_howto_table[ (int) R_FRV_GOT12];
2463
2464     case BFD_RELOC_FRV_GOTHI:
2465       return &elf32_frv_howto_table[ (int) R_FRV_GOTHI];
2466
2467     case BFD_RELOC_FRV_GOTLO:
2468       return &elf32_frv_howto_table[ (int) R_FRV_GOTLO];
2469
2470     case BFD_RELOC_FRV_FUNCDESC:
2471       if (elf_elfheader (abfd)->e_type == ET_EXEC
2472           || elf_elfheader (abfd)->e_type == ET_DYN)
2473         return &elf32_frv_rel_funcdesc_howto;
2474       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC];
2475
2476     case BFD_RELOC_FRV_FUNCDESC_GOT12:
2477       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOT12];
2478
2479     case BFD_RELOC_FRV_FUNCDESC_GOTHI:
2480       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTHI];
2481
2482     case BFD_RELOC_FRV_FUNCDESC_GOTLO:
2483       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTLO];
2484
2485     case BFD_RELOC_FRV_FUNCDESC_VALUE:
2486       if (elf_elfheader (abfd)->e_type == ET_EXEC
2487           || elf_elfheader (abfd)->e_type == ET_DYN)
2488         return &elf32_frv_rel_funcdesc_value_howto;
2489       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_VALUE];
2490
2491     case BFD_RELOC_FRV_FUNCDESC_GOTOFF12:
2492       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFF12];
2493
2494     case BFD_RELOC_FRV_FUNCDESC_GOTOFFHI:
2495       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFHI];
2496
2497     case BFD_RELOC_FRV_FUNCDESC_GOTOFFLO:
2498       return &elf32_frv_howto_table[ (int) R_FRV_FUNCDESC_GOTOFFLO];
2499
2500     case BFD_RELOC_FRV_GOTOFF12:
2501       return &elf32_frv_howto_table[ (int) R_FRV_GOTOFF12];
2502
2503     case BFD_RELOC_FRV_GOTOFFHI:
2504       return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFHI];
2505
2506     case BFD_RELOC_FRV_GOTOFFLO:
2507       return &elf32_frv_howto_table[ (int) R_FRV_GOTOFFLO];
2508
2509     case BFD_RELOC_FRV_GETTLSOFF:
2510       return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF];
2511
2512     case BFD_RELOC_FRV_TLSDESC_VALUE:
2513       if (elf_elfheader (abfd)->e_type == ET_EXEC
2514           || elf_elfheader (abfd)->e_type == ET_DYN)
2515         return &elf32_frv_rel_tlsdesc_value_howto;
2516       return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_VALUE];
2517
2518     case BFD_RELOC_FRV_GOTTLSDESC12:
2519       return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESC12];
2520
2521     case BFD_RELOC_FRV_GOTTLSDESCHI:
2522       return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCHI];
2523
2524     case BFD_RELOC_FRV_GOTTLSDESCLO:
2525       return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSDESCLO];
2526
2527     case BFD_RELOC_FRV_TLSMOFF12:
2528       return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF12];
2529
2530     case BFD_RELOC_FRV_TLSMOFFHI:
2531       return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFHI];
2532
2533     case BFD_RELOC_FRV_TLSMOFFLO:
2534       return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFFLO];
2535
2536     case BFD_RELOC_FRV_GOTTLSOFF12:
2537       return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFF12];
2538
2539     case BFD_RELOC_FRV_GOTTLSOFFHI:
2540       return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFHI];
2541
2542     case BFD_RELOC_FRV_GOTTLSOFFLO:
2543       return &elf32_frv_howto_table[ (int) R_FRV_GOTTLSOFFLO];
2544
2545     case BFD_RELOC_FRV_TLSOFF:
2546       if (elf_elfheader (abfd)->e_type == ET_EXEC
2547           || elf_elfheader (abfd)->e_type == ET_DYN)
2548         return &elf32_frv_rel_tlsoff_howto;
2549       return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF];
2550
2551     case BFD_RELOC_FRV_TLSDESC_RELAX:
2552       return &elf32_frv_howto_table[ (int) R_FRV_TLSDESC_RELAX];
2553
2554     case BFD_RELOC_FRV_GETTLSOFF_RELAX:
2555       return &elf32_frv_howto_table[ (int) R_FRV_GETTLSOFF_RELAX];
2556
2557     case BFD_RELOC_FRV_TLSOFF_RELAX:
2558       return &elf32_frv_howto_table[ (int) R_FRV_TLSOFF_RELAX];
2559
2560     case BFD_RELOC_FRV_TLSMOFF:
2561       return &elf32_frv_howto_table[ (int) R_FRV_TLSMOFF];
2562
2563     case BFD_RELOC_VTABLE_INHERIT:
2564       return &elf32_frv_vtinherit_howto;
2565
2566     case BFD_RELOC_VTABLE_ENTRY:
2567       return &elf32_frv_vtentry_howto;
2568     }
2569
2570   return NULL;
2571 }
2572
2573 /* Set the howto pointer for an FRV ELF reloc.  */
2574
2575 static void
2576 frv_info_to_howto_rela (abfd, cache_ptr, dst)
2577      bfd *abfd ATTRIBUTE_UNUSED;
2578      arelent *cache_ptr;
2579      Elf_Internal_Rela *dst;
2580 {
2581   unsigned int r_type;
2582
2583   r_type = ELF32_R_TYPE (dst->r_info);
2584   switch (r_type)
2585     {
2586     case R_FRV_GNU_VTINHERIT:
2587       cache_ptr->howto = &elf32_frv_vtinherit_howto;
2588       break;
2589
2590     case R_FRV_GNU_VTENTRY:
2591       cache_ptr->howto = &elf32_frv_vtentry_howto;
2592       break;
2593
2594     default:
2595       cache_ptr->howto = & elf32_frv_howto_table [r_type];
2596       break;
2597     }
2598 }
2599
2600 /* Set the howto pointer for an FRV ELF REL reloc.  */
2601 static void
2602 frvfdpic_info_to_howto_rel (bfd *abfd ATTRIBUTE_UNUSED,
2603                             arelent *cache_ptr, Elf_Internal_Rela *dst)
2604 {
2605   unsigned int r_type;
2606
2607   r_type = ELF32_R_TYPE (dst->r_info);
2608   switch (r_type)
2609     {
2610     case R_FRV_32:
2611       cache_ptr->howto = &elf32_frv_rel_32_howto;
2612       break;
2613
2614     case R_FRV_FUNCDESC:
2615       cache_ptr->howto = &elf32_frv_rel_funcdesc_howto;
2616       break;
2617
2618     case R_FRV_FUNCDESC_VALUE:
2619       cache_ptr->howto = &elf32_frv_rel_funcdesc_value_howto;
2620       break;
2621
2622     case R_FRV_TLSDESC_VALUE:
2623       cache_ptr->howto = &elf32_frv_rel_tlsdesc_value_howto;
2624       break;
2625
2626     case R_FRV_TLSOFF:
2627       cache_ptr->howto = &elf32_frv_rel_tlsoff_howto;
2628       break;
2629
2630     default:
2631       cache_ptr->howto = NULL;
2632       break;
2633     }
2634 }
2635 \f
2636 /* Perform a single relocation.  By default we use the standard BFD
2637    routines, but a few relocs, we have to do them ourselves.  */
2638
2639 static bfd_reloc_status_type
2640 frv_final_link_relocate (howto, input_bfd, input_section, contents, rel,
2641                          relocation)
2642      reloc_howto_type *howto;
2643      bfd *input_bfd;
2644      asection *input_section;
2645      bfd_byte *contents;
2646      Elf_Internal_Rela *rel;
2647      bfd_vma relocation;
2648 {
2649   return _bfd_final_link_relocate (howto, input_bfd, input_section,
2650                                    contents, rel->r_offset, relocation,
2651                                    rel->r_addend);
2652 }
2653
2654 \f
2655 /* Relocate an FRV ELF section.
2656
2657    The RELOCATE_SECTION function is called by the new ELF backend linker
2658    to handle the relocations for a section.
2659
2660    The relocs are always passed as Rela structures; if the section
2661    actually uses Rel structures, the r_addend field will always be
2662    zero.
2663
2664    This function is responsible for adjusting the section contents as
2665    necessary, and (if using Rela relocs and generating a relocatable
2666    output file) adjusting the reloc addend as necessary.
2667
2668    This function does not have to worry about setting the reloc
2669    address or the reloc symbol index.
2670
2671    LOCAL_SYMS is a pointer to the swapped in local symbols.
2672
2673    LOCAL_SECTIONS is an array giving the section in the input file
2674    corresponding to the st_shndx field of each local symbol.
2675
2676    The global hash table entry for the global symbols can be found
2677    via elf_sym_hashes (input_bfd).
2678
2679    When generating relocatable output, this function must handle
2680    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2681    going to be the section symbol corresponding to the output
2682    section, which means that the addend must be adjusted
2683    accordingly.  */
2684
2685 static bfd_boolean
2686 elf32_frv_relocate_section (output_bfd, info, input_bfd, input_section,
2687                             contents, relocs, local_syms, local_sections)
2688      bfd *output_bfd ATTRIBUTE_UNUSED;
2689      struct bfd_link_info *info;
2690      bfd *input_bfd;
2691      asection *input_section;
2692      bfd_byte *contents;
2693      Elf_Internal_Rela *relocs;
2694      Elf_Internal_Sym *local_syms;
2695      asection **local_sections;
2696 {
2697   Elf_Internal_Shdr *symtab_hdr;
2698   struct elf_link_hash_entry **sym_hashes;
2699   Elf_Internal_Rela *rel;
2700   Elf_Internal_Rela *relend;
2701   unsigned isec_segment, got_segment, plt_segment, gprel_segment, tls_segment,
2702     check_segment[2];
2703   int silence_segment_error = !(info->shared || info->pie);
2704   unsigned long insn;
2705
2706   if (info->relocatable)
2707     return TRUE;
2708
2709   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2710   sym_hashes = elf_sym_hashes (input_bfd);
2711   relend     = relocs + input_section->reloc_count;
2712
2713   isec_segment = _frvfdpic_osec_to_segment (output_bfd,
2714                                             input_section->output_section);
2715   if (IS_FDPIC (output_bfd) && frvfdpic_got_section (info))
2716     got_segment = _frvfdpic_osec_to_segment (output_bfd,
2717                                              frvfdpic_got_section (info)
2718                                              ->output_section);
2719   else
2720     got_segment = -1;
2721   if (IS_FDPIC (output_bfd) && frvfdpic_gotfixup_section (info))
2722     gprel_segment = _frvfdpic_osec_to_segment (output_bfd,
2723                                                frvfdpic_gotfixup_section (info)
2724                                                ->output_section);
2725   else
2726     gprel_segment = -1;
2727   if (IS_FDPIC (output_bfd) && frvfdpic_plt_section (info))
2728     plt_segment = _frvfdpic_osec_to_segment (output_bfd,
2729                                              frvfdpic_plt_section (info)
2730                                              ->output_section);
2731   else
2732     plt_segment = -1;
2733   if (elf_hash_table (info)->tls_sec)
2734     tls_segment = _frvfdpic_osec_to_segment (output_bfd,
2735                                              elf_hash_table (info)->tls_sec);
2736   else
2737     tls_segment = -1;
2738
2739   for (rel = relocs; rel < relend; rel ++)
2740     {
2741       reloc_howto_type *howto;
2742       unsigned long r_symndx;
2743       Elf_Internal_Sym *sym;
2744       asection *sec;
2745       struct elf_link_hash_entry *h;
2746       bfd_vma relocation;
2747       bfd_reloc_status_type r;
2748       const char * name = NULL;
2749       int r_type;
2750       asection *osec;
2751       struct frvfdpic_relocs_info *picrel;
2752       bfd_vma orig_addend = rel->r_addend;
2753
2754       r_type = ELF32_R_TYPE (rel->r_info);
2755
2756       if (   r_type == R_FRV_GNU_VTINHERIT
2757           || r_type == R_FRV_GNU_VTENTRY)
2758         continue;
2759
2760       /* This is a final link.  */
2761       r_symndx = ELF32_R_SYM (rel->r_info);
2762       howto  = elf32_frv_howto_table + ELF32_R_TYPE (rel->r_info);
2763       h      = NULL;
2764       sym    = NULL;
2765       sec    = NULL;
2766
2767       if (r_symndx < symtab_hdr->sh_info)
2768         {
2769           sym = local_syms + r_symndx;
2770           osec = sec = local_sections [r_symndx];
2771           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2772
2773           name = bfd_elf_string_from_elf_section
2774             (input_bfd, symtab_hdr->sh_link, sym->st_name);
2775           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
2776         }
2777       else
2778         {
2779           h = sym_hashes [r_symndx - symtab_hdr->sh_info];
2780
2781           while (h->root.type == bfd_link_hash_indirect
2782                  || h->root.type == bfd_link_hash_warning)
2783             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2784
2785           name = h->root.root.string;
2786
2787           if ((h->root.type == bfd_link_hash_defined
2788                || h->root.type == bfd_link_hash_defweak))
2789             {
2790               if (/* TLSMOFF forces local binding.  */
2791                   r_type != R_FRV_TLSMOFF
2792                   && ! FRVFDPIC_SYM_LOCAL (info, h))
2793                 {
2794                   sec = NULL;
2795                   relocation = 0;
2796                 }
2797               else
2798                 {
2799                   sec = h->root.u.def.section;
2800                   relocation = (h->root.u.def.value
2801                                 + sec->output_section->vma
2802                                 + sec->output_offset);
2803                 }
2804             }
2805           else if (h->root.type == bfd_link_hash_undefweak)
2806             {
2807               relocation = 0;
2808             }
2809           else if (info->unresolved_syms_in_objects == RM_IGNORE
2810                    && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
2811             relocation = 0;
2812           else
2813             {
2814               if (! ((*info->callbacks->undefined_symbol)
2815                      (info, h->root.root.string, input_bfd,
2816                       input_section, rel->r_offset,
2817                       (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
2818                        || ELF_ST_VISIBILITY (h->other)))))
2819                 return FALSE;
2820               relocation = 0;
2821             }
2822           osec = sec;
2823         }
2824
2825       switch (r_type)
2826         {
2827         case R_FRV_LABEL24:
2828         case R_FRV_32:
2829           if (! IS_FDPIC (output_bfd))
2830             goto non_fdpic;
2831
2832         case R_FRV_GOT12:
2833         case R_FRV_GOTHI:
2834         case R_FRV_GOTLO:
2835         case R_FRV_FUNCDESC_GOT12:
2836         case R_FRV_FUNCDESC_GOTHI:
2837         case R_FRV_FUNCDESC_GOTLO:
2838         case R_FRV_GOTOFF12:
2839         case R_FRV_GOTOFFHI:
2840         case R_FRV_GOTOFFLO:
2841         case R_FRV_FUNCDESC_GOTOFF12:
2842         case R_FRV_FUNCDESC_GOTOFFHI:
2843         case R_FRV_FUNCDESC_GOTOFFLO:
2844         case R_FRV_FUNCDESC:
2845         case R_FRV_FUNCDESC_VALUE:
2846         case R_FRV_GETTLSOFF:
2847         case R_FRV_TLSDESC_VALUE:
2848         case R_FRV_GOTTLSDESC12:
2849         case R_FRV_GOTTLSDESCHI:
2850         case R_FRV_GOTTLSDESCLO:
2851         case R_FRV_TLSMOFF12:
2852         case R_FRV_TLSMOFFHI:
2853         case R_FRV_TLSMOFFLO:
2854         case R_FRV_GOTTLSOFF12:
2855         case R_FRV_GOTTLSOFFHI:
2856         case R_FRV_GOTTLSOFFLO:
2857         case R_FRV_TLSOFF:
2858         case R_FRV_TLSDESC_RELAX:
2859         case R_FRV_GETTLSOFF_RELAX:
2860         case R_FRV_TLSOFF_RELAX:
2861         case R_FRV_TLSMOFF:
2862           if (h != NULL)
2863             picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2864                                                       (info), input_bfd, h,
2865                                                       orig_addend, INSERT);
2866           else
2867             /* In order to find the entry we created before, we must
2868                use the original addend, not the one that may have been
2869                modified by _bfd_elf_rela_local_sym().  */
2870             picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2871                                                      (info), input_bfd, r_symndx,
2872                                                      orig_addend, INSERT);
2873           if (! picrel)
2874             return FALSE;
2875
2876           if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2877                                                       osec, sym,
2878                                                       rel->r_addend))
2879             {
2880               (*_bfd_error_handler)
2881                 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2882                  input_bfd, input_section, rel->r_offset, name);
2883               return FALSE;
2884
2885             }
2886
2887           break;
2888
2889         default:
2890         non_fdpic:
2891           picrel = NULL;
2892           if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2893             {
2894               info->callbacks->warning
2895                 (info, _("relocation references symbol not defined in the module"),
2896                  name, input_bfd, input_section, rel->r_offset);
2897               return FALSE;
2898             }
2899           break;
2900         }
2901
2902       switch (r_type)
2903         {
2904         case R_FRV_GETTLSOFF:
2905         case R_FRV_TLSDESC_VALUE:
2906         case R_FRV_GOTTLSDESC12:
2907         case R_FRV_GOTTLSDESCHI:
2908         case R_FRV_GOTTLSDESCLO:
2909         case R_FRV_TLSMOFF12:
2910         case R_FRV_TLSMOFFHI:
2911         case R_FRV_TLSMOFFLO:
2912         case R_FRV_GOTTLSOFF12:
2913         case R_FRV_GOTTLSOFFHI:
2914         case R_FRV_GOTTLSOFFLO:
2915         case R_FRV_TLSOFF:
2916         case R_FRV_TLSDESC_RELAX:
2917         case R_FRV_GETTLSOFF_RELAX:
2918         case R_FRV_TLSOFF_RELAX:
2919         case R_FRV_TLSMOFF:
2920           if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec)))
2921             relocation += tls_biased_base (info);
2922           break;
2923
2924         default:
2925           break;
2926         }
2927
2928       /* Try to apply TLS relaxations.  */
2929       if (1)
2930         switch (r_type)
2931           {
2932
2933 #define LOCAL_EXEC_P(info, picrel) \
2934   ((info)->executable \
2935    && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2936 #define INITIAL_EXEC_P(info, picrel) \
2937   (((info)->executable || (info)->flags & DF_STATIC_TLS) \
2938    && (picrel)->tlsoff_entry)
2939
2940 #define IN_RANGE_FOR_OFST12_P(value) \
2941   ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2942 #define IN_RANGE_FOR_SETLOS_P(value) \
2943   ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2944 #define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2945   (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2946
2947 #define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2948   (LOCAL_EXEC_P ((info), (picrel)) \
2949    && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2950 #define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2951   (INITIAL_EXEC_P ((info), (picrel)) \
2952    && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2953
2954 #define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2955   (LOCAL_EXEC_P ((info), (picrel)))
2956 #define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2957   (INITIAL_EXEC_P ((info), (picrel)))
2958
2959 #define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2960   (LOCAL_EXEC_P ((info), (picrel)) \
2961    && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2962
2963           case R_FRV_GETTLSOFF:
2964             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2965
2966             /* Is this a call instruction?  */
2967             if ((insn & (unsigned long)0x01fc0000) != 0x003c0000)
2968               {
2969                 r = info->callbacks->warning
2970                   (info,
2971                    _("R_FRV_GETTLSOFF not applied to a call instruction"),
2972                    name, input_bfd, input_section, rel->r_offset);
2973                 return FALSE;
2974               }
2975
2976             if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel,
2977                                               relocation + rel->r_addend))
2978               {
2979                 /* Replace the call instruction (except the packing bit)
2980                    with setlos #tlsmofflo(symbol+offset), gr9.  */
2981                 insn &= (unsigned long)0x80000000;
2982                 insn |= (unsigned long)0x12fc0000;
2983                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2984
2985                 r_type = R_FRV_TLSMOFFLO;
2986                 howto  = elf32_frv_howto_table + r_type;
2987                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
2988               }
2989
2990             else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel))
2991               {
2992                 /* Replace the call instruction (except the packing bit)
2993                    with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9.  */
2994                 insn &= (unsigned long)0x80000000;
2995                 insn |= (unsigned long)0x12c8f000;
2996                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2997
2998                 r_type = R_FRV_GOTTLSOFF12;
2999                 howto  = elf32_frv_howto_table + r_type;
3000                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3001               }
3002
3003             break;
3004
3005           case R_FRV_GOTTLSDESC12:
3006             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3007
3008             /* Is this an lddi instruction?  */
3009             if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000)
3010               {
3011                 r = info->callbacks->warning
3012                   (info,
3013                    _("R_FRV_GOTTLSDESC12 not applied to an lddi instruction"),
3014                    name, input_bfd, input_section, rel->r_offset);
3015                 return FALSE;
3016               }
3017
3018             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3019                                             relocation + rel->r_addend)
3020                 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3021                                                   info))
3022               {
3023                 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3024                    with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3025                    Preserve the packing bit.  */
3026                 insn = (insn & (unsigned long)0x80000000)
3027                   | ((insn + (unsigned long)0x02000000)
3028                      & (unsigned long)0x7e000000);
3029                 insn |= (unsigned long)0x00fc0000;
3030                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3031
3032                 r_type = R_FRV_TLSMOFFLO;
3033                 howto  = elf32_frv_howto_table + r_type;
3034                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3035               }
3036
3037             else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3038                                                  relocation + rel->r_addend))
3039               {
3040                 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3041                    with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3042                    Preserve the packing bit.  */
3043                 insn = (insn & (unsigned long)0x80000000)
3044                   | ((insn + (unsigned long)0x02000000)
3045                      & (unsigned long)0x7e000000);
3046                 insn |= (unsigned long)0x00f80000;
3047                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3048
3049                 r_type = R_FRV_TLSMOFFHI;
3050                 howto  = elf32_frv_howto_table + r_type;
3051                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3052               }
3053
3054             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3055               {
3056                 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3057                    with ldi @(grB, #gottlsoff12(symbol+offset),
3058                    gr<C+1>.  Preserve the packing bit.  If gottlsoff12
3059                    overflows, we'll error out, but that's sort-of ok,
3060                    since we'd started with gottlsdesc12, that's actually
3061                    more demanding.  Compiling with -fPIE instead of
3062                    -fpie would fix it; linking with --relax should fix
3063                    it as well.  */
3064                 insn = (insn & (unsigned long)0x80cbf000)
3065                   | ((insn + (unsigned long)0x02000000)
3066                      & (unsigned long)0x7e000000);
3067                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3068
3069                 r_type = R_FRV_GOTTLSOFF12;
3070                 howto  = elf32_frv_howto_table + r_type;
3071                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3072               }
3073
3074             break;
3075
3076           case R_FRV_GOTTLSDESCHI:
3077             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3078
3079             /* Is this a sethi instruction?  */
3080             if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3081               {
3082                 r = info->callbacks->warning
3083                   (info,
3084                    _("R_FRV_GOTTLSDESCHI not applied to a sethi instruction"),
3085                    name, input_bfd, input_section, rel->r_offset);
3086                 return FALSE;
3087               }
3088
3089             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3090                                             relocation + rel->r_addend)
3091                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3092                     && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)))
3093               {
3094                 /* Replace sethi with a nop.  Preserve the packing bit.  */
3095                 insn &= (unsigned long)0x80000000;
3096                 insn |= (unsigned long)0x00880000;
3097                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3098
3099                 /* Nothing to relocate.  */
3100                 continue;
3101               }
3102
3103             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3104               {
3105                 /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3106                 r_type = R_FRV_GOTTLSOFFHI;
3107                 howto  = elf32_frv_howto_table + r_type;
3108                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3109               }
3110
3111             break;
3112
3113           case R_FRV_GOTTLSDESCLO:
3114             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3115
3116             /* Is this a setlo or setlos instruction?  */
3117             if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3118               {
3119                 r = info->callbacks->warning
3120                   (info,
3121                    _("R_FRV_GOTTLSDESCLO"
3122                      " not applied to a setlo or setlos instruction"),
3123                    name, input_bfd, input_section, rel->r_offset);
3124                 return FALSE;
3125               }
3126
3127             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3128                                             relocation + rel->r_addend)
3129                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3130                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3131               {
3132                 /* Replace setlo/setlos with a nop.  Preserve the
3133                    packing bit.  */
3134                 insn &= (unsigned long)0x80000000;
3135                 insn |= (unsigned long)0x00880000;
3136                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3137
3138                 /* Nothing to relocate.  */
3139                 continue;
3140               }
3141
3142             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3143               {
3144                 /* If the corresponding sethi (if it exists) decayed
3145                    to a nop, make sure this becomes (or already is) a
3146                    setlos, not setlo.  */
3147                 if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))
3148                   {
3149                     insn |= (unsigned long)0x00080000;
3150                     bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3151                   }
3152
3153                 /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3154                 r_type = R_FRV_GOTTLSOFFLO;
3155                 howto  = elf32_frv_howto_table + r_type;
3156                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3157               }
3158
3159             break;
3160
3161           case R_FRV_TLSDESC_RELAX:
3162             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3163
3164             /* Is this an ldd instruction?  */
3165             if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140)
3166               {
3167                 r = info->callbacks->warning
3168                   (info,
3169                    _("R_FRV_TLSDESC_RELAX not applied to an ldd instruction"),
3170                    name, input_bfd, input_section, rel->r_offset);
3171                 return FALSE;
3172               }
3173
3174             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3175                                             relocation + rel->r_addend)
3176                 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3177                                                   info))
3178               {
3179                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3180                    with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3181                    Preserve the packing bit.  */
3182                 insn = (insn & (unsigned long)0x80000000)
3183                   | ((insn + (unsigned long)0x02000000)
3184                      & (unsigned long)0x7e000000);
3185                 insn |= (unsigned long)0x00fc0000;
3186                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3187
3188                 r_type = R_FRV_TLSMOFFLO;
3189                 howto  = elf32_frv_howto_table + r_type;
3190                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3191               }
3192
3193             else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3194                                                  relocation + rel->r_addend))
3195               {
3196                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3197                    with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3198                    Preserve the packing bit.  */
3199                 insn = (insn & (unsigned long)0x80000000)
3200                   | ((insn + (unsigned long)0x02000000)
3201                      & (unsigned long)0x7e000000);
3202                 insn |= (unsigned long)0x00f80000;
3203                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3204
3205                 r_type = R_FRV_TLSMOFFHI;
3206                 howto  = elf32_frv_howto_table + r_type;
3207                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3208               }
3209
3210             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3211                      && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3212               {
3213                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3214                    with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3215                    Preserve the packing bit.  */
3216                 insn = (insn & (unsigned long)0x8003f000)
3217                   | (unsigned long)0x00c80000
3218                   | ((insn + (unsigned long)0x02000000)
3219                      & (unsigned long)0x7e000000);
3220                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3221
3222                 r_type = R_FRV_GOTTLSOFF12;
3223                 howto  = elf32_frv_howto_table + r_type;
3224                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3225               }
3226
3227             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3228               {
3229                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3230                    with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3231                    Preserve the packing bit.  */
3232                 insn = (insn & (unsigned long)0x81ffffbf)
3233                   | ((insn + (unsigned long)0x02000000)
3234                      & (unsigned long)0x7e000000);
3235                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3236
3237                 /* #tlsoff(symbol+offset) is just a relaxation
3238                     annotation, so there's nothing left to
3239                     relocate.  */
3240                 continue;
3241               }
3242
3243             break;
3244
3245           case R_FRV_GETTLSOFF_RELAX:
3246             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3247
3248             /* Is this a calll or callil instruction?  */
3249             if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000)
3250               {
3251                 r = info->callbacks->warning
3252                   (info,
3253                    _("R_FRV_GETTLSOFF_RELAX"
3254                      " not applied to a calll instruction"),
3255                    name, input_bfd, input_section, rel->r_offset);
3256                 return FALSE;
3257               }
3258
3259             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3260                                             relocation + rel->r_addend)
3261                 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3262                                                   info))
3263               {
3264                 /* Replace calll with a nop.  Preserve the packing bit.  */
3265                 insn &= (unsigned long)0x80000000;
3266                 insn |= (unsigned long)0x00880000;
3267                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3268
3269                 /* Nothing to relocate.  */
3270                 continue;
3271               }
3272
3273             else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3274                                                  relocation + rel->r_addend))
3275               {
3276                 /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3277                    Preserve the packing bit.  */
3278                 insn &= (unsigned long)0x80000000;
3279                 insn |= (unsigned long)0x12f40000;
3280                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3281
3282                 r_type = R_FRV_TLSMOFFLO;
3283                 howto  = elf32_frv_howto_table + r_type;
3284                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3285               }
3286
3287             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3288               {
3289                 /* Replace calll with a nop.  Preserve the packing bit.  */
3290                 insn &= (unsigned long)0x80000000;
3291                 insn |= (unsigned long)0x00880000;
3292                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3293
3294                 /* Nothing to relocate.  */
3295                 continue;
3296               }
3297
3298             break;
3299
3300           case R_FRV_GOTTLSOFF12:
3301             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3302
3303             /* Is this an ldi instruction?  */
3304             if ((insn & (unsigned long)0x01fc0000) != 0x00c80000)
3305               {
3306                 r = info->callbacks->warning
3307                   (info,
3308                    _("R_FRV_GOTTLSOFF12 not applied to an ldi instruction"),
3309                    name, input_bfd, input_section, rel->r_offset);
3310                 return FALSE;
3311               }
3312
3313             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3314                                               relocation + rel->r_addend))
3315               {
3316                 /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3317                    with setlos #tlsmofflo(symbol+offset), grC.
3318                    Preserve the packing bit.  */
3319                 insn &= (unsigned long)0xfe000000;
3320                 insn |= (unsigned long)0x00fc0000;
3321                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3322
3323                 r_type = R_FRV_TLSMOFFLO;
3324                 howto  = elf32_frv_howto_table + r_type;
3325                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3326               }
3327
3328             break;
3329
3330           case R_FRV_GOTTLSOFFHI:
3331             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3332
3333             /* Is this a sethi instruction?  */
3334             if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3335               {
3336                 r = info->callbacks->warning
3337                   (info,
3338                    _("R_FRV_GOTTLSOFFHI not applied to a sethi instruction"),
3339                    name, input_bfd, input_section, rel->r_offset);
3340                 return FALSE;
3341               }
3342
3343             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3344                                               relocation + rel->r_addend)
3345                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3346                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3347               {
3348                 /* Replace sethi with a nop.  Preserve the packing bit.  */
3349                 insn &= (unsigned long)0x80000000;
3350                 insn |= (unsigned long)0x00880000;
3351                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3352
3353                 /* Nothing to relocate.  */
3354                 continue;
3355               }
3356
3357             break;
3358
3359           case R_FRV_GOTTLSOFFLO:
3360             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3361
3362             /* Is this a setlo or setlos instruction?  */
3363             if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3364               {
3365                 r = info->callbacks->warning
3366                   (info,
3367                    _("R_FRV_GOTTLSOFFLO"
3368                      " not applied to a setlo or setlos instruction"),
3369                    name, input_bfd, input_section, rel->r_offset);
3370                 return FALSE;
3371               }
3372
3373             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3374                                               relocation + rel->r_addend)
3375                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3376                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3377               {
3378                 /* Replace setlo/setlos with a nop.  Preserve the
3379                    packing bit.  */
3380                 insn &= (unsigned long)0x80000000;
3381                 insn |= (unsigned long)0x00880000;
3382                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3383
3384                 /* Nothing to relocate.  */
3385                 continue;
3386               }
3387
3388             break;
3389
3390           case R_FRV_TLSOFF_RELAX:
3391             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3392
3393             /* Is this an ld instruction?  */
3394             if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100)
3395               {
3396                 r = info->callbacks->warning
3397                   (info,
3398                    _("R_FRV_TLSOFF_RELAX not applied to an ld instruction"),
3399                    name, input_bfd, input_section, rel->r_offset);
3400                 return FALSE;
3401               }
3402
3403             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3404                                               relocation + rel->r_addend))
3405               {
3406                 /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3407                    with setlos #tlsmofflo(symbol+offset), grC.
3408                    Preserve the packing bit.  */
3409                 insn &= (unsigned long)0xfe000000;
3410                 insn |= (unsigned long)0x00fc0000;
3411                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3412
3413                 r_type = R_FRV_TLSMOFFLO;
3414                 howto  = elf32_frv_howto_table + r_type;
3415                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3416               }
3417
3418             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3419                      && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3420               {
3421                 /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3422                    with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3423                    Preserve the packing bit.  */
3424                 insn = (insn & (unsigned long)0xfe03f000)
3425                   | (unsigned long)0x00c80000;;
3426                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3427
3428                 r_type = R_FRV_GOTTLSOFF12;
3429                 howto  = elf32_frv_howto_table + r_type;
3430                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3431               }
3432
3433             break;
3434
3435           case R_FRV_TLSMOFFHI:
3436             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3437
3438             /* Is this a sethi instruction?  */
3439             if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3440               {
3441                 r = info->callbacks->warning
3442                   (info,
3443                    _("R_FRV_TLSMOFFHI not applied to a sethi instruction"),
3444                    name, input_bfd, input_section, rel->r_offset);
3445                 return FALSE;
3446               }
3447
3448             if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3449                                                info))
3450               {
3451                 /* Replace sethi with a nop.  Preserve the packing bit.  */
3452                 insn &= (unsigned long)0x80000000;
3453                 insn |= (unsigned long)0x00880000;
3454                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3455
3456                 /* Nothing to relocate.  */
3457                 continue;
3458               }
3459
3460             break;
3461
3462           case R_FRV_TLSMOFFLO:
3463             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3464
3465             /* Is this a setlo or setlos instruction?  */
3466             if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3467               {
3468                 r = info->callbacks->warning
3469                   (info,
3470                    _("R_FRV_TLSMOFFLO"
3471                      " not applied to a setlo or setlos instruction"),
3472                    name, input_bfd, input_section, rel->r_offset);
3473                 return FALSE;
3474               }
3475
3476             if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3477                                                info))
3478               /* If the corresponding sethi (if it exists) decayed
3479                  to a nop, make sure this becomes (or already is) a
3480                  setlos, not setlo.  */
3481               {
3482                 insn |= (unsigned long)0x00080000;
3483                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3484               }
3485
3486             break;
3487
3488             /*
3489               There's nothing to relax in these:
3490                 R_FRV_TLSDESC_VALUE
3491                 R_FRV_TLSOFF
3492                 R_FRV_TLSMOFF12
3493                 R_FRV_TLSMOFFHI
3494                 R_FRV_TLSMOFFLO
3495                 R_FRV_TLSMOFF
3496             */
3497
3498           default:
3499             break;
3500           }
3501
3502       switch (r_type)
3503         {
3504         case R_FRV_LABEL24:
3505           check_segment[0] = isec_segment;
3506           if (! IS_FDPIC (output_bfd))
3507             check_segment[1] = isec_segment;
3508           else if (picrel->plt)
3509             {
3510               relocation = frvfdpic_plt_section (info)->output_section->vma
3511                 + frvfdpic_plt_section (info)->output_offset
3512                 + picrel->plt_entry;
3513               check_segment[1] = plt_segment;
3514             }
3515           /* We don't want to warn on calls to undefined weak symbols,
3516              as calls to them must be protected by non-NULL tests
3517              anyway, and unprotected calls would invoke undefined
3518              behavior.  */
3519           else if (picrel->symndx == -1
3520                    && picrel->d.h->root.type == bfd_link_hash_undefweak)
3521             check_segment[1] = check_segment[0];
3522           else
3523             check_segment[1] = sec
3524               ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3525               : (unsigned)-1;
3526           break;
3527
3528         case R_FRV_GOT12:
3529         case R_FRV_GOTHI:
3530         case R_FRV_GOTLO:
3531           relocation = picrel->got_entry;
3532           check_segment[0] = check_segment[1] = got_segment;
3533           break;
3534
3535         case R_FRV_FUNCDESC_GOT12:
3536         case R_FRV_FUNCDESC_GOTHI:
3537         case R_FRV_FUNCDESC_GOTLO:
3538           relocation = picrel->fdgot_entry;
3539           check_segment[0] = check_segment[1] = got_segment;
3540           break;
3541
3542         case R_FRV_GOTOFFHI:
3543         case R_FRV_GOTOFF12:
3544         case R_FRV_GOTOFFLO:
3545           relocation -= frvfdpic_got_section (info)->output_section->vma
3546             + frvfdpic_got_section (info)->output_offset
3547             + frvfdpic_got_initial_offset (info);
3548           check_segment[0] = got_segment;
3549           check_segment[1] = sec
3550             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3551             : (unsigned)-1;
3552           break;
3553
3554         case R_FRV_FUNCDESC_GOTOFF12:
3555         case R_FRV_FUNCDESC_GOTOFFHI:
3556         case R_FRV_FUNCDESC_GOTOFFLO:
3557           relocation = picrel->fd_entry;
3558           check_segment[0] = check_segment[1] = got_segment;
3559           break;
3560
3561         case R_FRV_FUNCDESC:
3562           {
3563             int dynindx;
3564             bfd_vma addend = rel->r_addend;
3565
3566             if (! (h && h->root.type == bfd_link_hash_undefweak
3567                    && FRVFDPIC_SYM_LOCAL (info, h)))
3568               {
3569                 /* If the symbol is dynamic and there may be dynamic
3570                    symbol resolution because we are or are linked with a
3571                    shared library, emit a FUNCDESC relocation such that
3572                    the dynamic linker will allocate the function
3573                    descriptor.  If the symbol needs a non-local function
3574                    descriptor but binds locally (e.g., its visibility is
3575                    protected, emit a dynamic relocation decayed to
3576                    section+offset.  */
3577                 if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
3578                     && FRVFDPIC_SYM_LOCAL (info, h)
3579                     && !(info->executable && !info->pie))
3580                   {
3581                     dynindx = elf_section_data (h->root.u.def.section
3582                                                 ->output_section)->dynindx;
3583                     addend += h->root.u.def.section->output_offset
3584                       + h->root.u.def.value;
3585                   }
3586                 else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
3587                   {
3588                     if (addend)
3589                       {
3590                         info->callbacks->warning
3591                           (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
3592                            name, input_bfd, input_section, rel->r_offset);
3593                         return FALSE;
3594                       }
3595                     dynindx = h->dynindx;
3596                   }
3597                 else
3598                   {
3599                     /* Otherwise, we know we have a private function
3600                        descriptor, so reference it directly.  */
3601                     BFD_ASSERT (picrel->privfd);
3602                     r_type = R_FRV_32;
3603                     dynindx = elf_section_data (frvfdpic_got_section (info)
3604                                                 ->output_section)->dynindx;
3605                     addend = frvfdpic_got_section (info)->output_offset
3606                       + frvfdpic_got_initial_offset (info)
3607                       + picrel->fd_entry;
3608                   }
3609
3610                 /* If there is room for dynamic symbol resolution, emit
3611                    the dynamic relocation.  However, if we're linking an
3612                    executable at a fixed location, we won't have emitted a
3613                    dynamic symbol entry for the got section, so idx will
3614                    be zero, which means we can and should compute the
3615                    address of the private descriptor ourselves.  */
3616                 if (info->executable && !info->pie
3617                     && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
3618                   {
3619                     addend += frvfdpic_got_section (info)->output_section->vma;
3620                     if ((bfd_get_section_flags (output_bfd,
3621                                                 input_section->output_section)
3622                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3623                       {
3624                         if (_frvfdpic_osec_readonly_p (output_bfd,
3625                                                        input_section
3626                                                        ->output_section))
3627                           {
3628                             info->callbacks->warning
3629                               (info,
3630                                _("cannot emit fixups in read-only section"),
3631                                name, input_bfd, input_section, rel->r_offset);
3632                             return FALSE;
3633                           }
3634                         _frvfdpic_add_rofixup (output_bfd,
3635                                                frvfdpic_gotfixup_section
3636                                                (info),
3637                                                _bfd_elf_section_offset
3638                                                (output_bfd, info,
3639                                                 input_section, rel->r_offset)
3640                                                + input_section
3641                                                ->output_section->vma
3642                                                + input_section->output_offset,
3643                                                picrel);
3644                       }
3645                   }
3646                 else if ((bfd_get_section_flags (output_bfd,
3647                                                  input_section->output_section)
3648                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3649                   {
3650                     if (_frvfdpic_osec_readonly_p (output_bfd,
3651                                                    input_section
3652                                                    ->output_section))
3653                       {
3654                         info->callbacks->warning
3655                           (info,
3656                            _("cannot emit dynamic relocations in read-only section"),
3657                            name, input_bfd, input_section, rel->r_offset);
3658                         return FALSE;
3659                       }
3660                     _frvfdpic_add_dyn_reloc (output_bfd,
3661                                              frvfdpic_gotrel_section (info),
3662                                              _bfd_elf_section_offset
3663                                              (output_bfd, info,
3664                                               input_section, rel->r_offset)
3665                                              + input_section
3666                                              ->output_section->vma
3667                                              + input_section->output_offset,
3668                                              r_type, dynindx, addend, picrel);
3669                   }
3670                 else
3671                   addend += frvfdpic_got_section (info)->output_section->vma;
3672               }
3673
3674             /* We want the addend in-place because dynamic
3675                relocations are REL.  Setting relocation to it should
3676                arrange for it to be installed.  */
3677             relocation = addend - rel->r_addend;
3678           }
3679           check_segment[0] = check_segment[1] = got_segment;
3680           break;
3681
3682         case R_FRV_32:
3683           if (! IS_FDPIC (output_bfd))
3684             {
3685               check_segment[0] = check_segment[1] = -1;
3686               break;
3687             }
3688           /* Fall through.  */
3689         case R_FRV_FUNCDESC_VALUE:
3690           {
3691             int dynindx;
3692             bfd_vma addend = rel->r_addend;
3693
3694             /* If the symbol is dynamic but binds locally, use
3695                section+offset.  */
3696             if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
3697               {
3698                 if (addend && r_type == R_FRV_FUNCDESC_VALUE)
3699                   {
3700                     info->callbacks->warning
3701                       (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
3702                        name, input_bfd, input_section, rel->r_offset);
3703                     return FALSE;
3704                   }
3705                 dynindx = h->dynindx;
3706               }
3707             else
3708               {
3709                 if (h)
3710                   addend += h->root.u.def.value;
3711                 else
3712                   addend += sym->st_value;
3713                 if (osec)
3714                   addend += osec->output_offset;
3715                 if (osec && osec->output_section
3716                     && ! bfd_is_abs_section (osec->output_section)
3717                     && ! bfd_is_und_section (osec->output_section))
3718                   dynindx = elf_section_data (osec->output_section)->dynindx;
3719                 else
3720                   dynindx = 0;
3721               }
3722
3723             /* If we're linking an executable at a fixed address, we
3724                can omit the dynamic relocation as long as the symbol
3725                is defined in the current link unit (which is implied
3726                by its output section not being NULL).  */
3727             if (info->executable && !info->pie
3728                 && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3729               {
3730                 if (osec)
3731                   addend += osec->output_section->vma;
3732                 if (IS_FDPIC (input_bfd)
3733                     && (bfd_get_section_flags (output_bfd,
3734                                                input_section->output_section)
3735                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3736                   {
3737                     if (_frvfdpic_osec_readonly_p (output_bfd,
3738                                                    input_section
3739                                                    ->output_section))
3740                       {
3741                         info->callbacks->warning
3742                           (info,
3743                            _("cannot emit fixups in read-only section"),
3744                            name, input_bfd, input_section, rel->r_offset);
3745                         return FALSE;
3746                       }
3747                     if (!h || h->root.type != bfd_link_hash_undefweak)
3748                       {
3749                         _frvfdpic_add_rofixup (output_bfd,
3750                                                frvfdpic_gotfixup_section
3751                                                (info),
3752                                                _bfd_elf_section_offset
3753                                                (output_bfd, info,
3754                                                 input_section, rel->r_offset)
3755                                                + input_section
3756                                                ->output_section->vma
3757                                                + input_section->output_offset,
3758                                                picrel);
3759                         if (r_type == R_FRV_FUNCDESC_VALUE)
3760                           _frvfdpic_add_rofixup
3761                             (output_bfd,
3762                              frvfdpic_gotfixup_section (info),
3763                              _bfd_elf_section_offset
3764                              (output_bfd, info,
3765                               input_section, rel->r_offset)
3766                              + input_section->output_section->vma
3767                              + input_section->output_offset + 4, picrel);
3768                       }
3769                   }
3770               }
3771             else
3772               {
3773                 if ((bfd_get_section_flags (output_bfd,
3774                                             input_section->output_section)
3775                      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3776                   {
3777                     if (_frvfdpic_osec_readonly_p (output_bfd,
3778                                                    input_section
3779                                                    ->output_section))
3780                       {
3781                         info->callbacks->warning
3782                           (info,
3783                            _("cannot emit dynamic relocations in read-only section"),
3784                            name, input_bfd, input_section, rel->r_offset);
3785                         return FALSE;
3786                       }
3787                     _frvfdpic_add_dyn_reloc (output_bfd,
3788                                              frvfdpic_gotrel_section (info),
3789                                              _bfd_elf_section_offset
3790                                              (output_bfd, info,
3791                                               input_section, rel->r_offset)
3792                                              + input_section
3793                                              ->output_section->vma
3794                                              + input_section->output_offset,
3795                                              r_type, dynindx, addend, picrel);
3796                   }
3797                 else if (osec)
3798                   addend += osec->output_section->vma;
3799                 /* We want the addend in-place because dynamic
3800                    relocations are REL.  Setting relocation to it
3801                    should arrange for it to be installed.  */
3802                 relocation = addend - rel->r_addend;
3803               }
3804
3805             if (r_type == R_FRV_FUNCDESC_VALUE)
3806               {
3807                 /* If we've omitted the dynamic relocation, just emit
3808                    the fixed addresses of the symbol and of the local
3809                    GOT base offset.  */
3810                 if (info->executable && !info->pie
3811                     && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3812                   bfd_put_32 (output_bfd,
3813                               frvfdpic_got_section (info)->output_section->vma
3814                               + frvfdpic_got_section (info)->output_offset
3815                               + frvfdpic_got_initial_offset (info),
3816                               contents + rel->r_offset + 4);
3817                 else
3818                   /* A function descriptor used for lazy or local
3819                      resolving is initialized such that its high word
3820                      contains the output section index in which the
3821                      PLT entries are located, and the low word
3822                      contains the offset of the lazy PLT entry entry
3823                      point into that section.  */
3824                   bfd_put_32 (output_bfd,
3825                               h && ! FRVFDPIC_SYM_LOCAL (info, h)
3826                               ? 0
3827                               : _frvfdpic_osec_to_segment (output_bfd,
3828                                                            sec
3829                                                            ->output_section),
3830                               contents + rel->r_offset + 4);
3831               }
3832           }
3833           check_segment[0] = check_segment[1] = got_segment;
3834           break;
3835
3836         case R_FRV_GPREL12:
3837         case R_FRV_GPRELU12:
3838         case R_FRV_GPREL32:
3839         case R_FRV_GPRELHI:
3840         case R_FRV_GPRELLO:
3841           check_segment[0] = gprel_segment;
3842           check_segment[1] = sec
3843             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3844             : (unsigned)-1;
3845           break;
3846
3847         case R_FRV_GETTLSOFF:
3848           relocation = frvfdpic_plt_section (info)->output_section->vma
3849             + frvfdpic_plt_section (info)->output_offset
3850             + picrel->tlsplt_entry;
3851           BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1
3852                       && picrel->tlsdesc_entry);
3853           check_segment[0] = isec_segment;
3854           check_segment[1] = plt_segment;
3855           break;
3856
3857         case R_FRV_GOTTLSDESC12:
3858         case R_FRV_GOTTLSDESCHI:
3859         case R_FRV_GOTTLSDESCLO:
3860           BFD_ASSERT (picrel->tlsdesc_entry);
3861           relocation = picrel->tlsdesc_entry;
3862           check_segment[0] = tls_segment;
3863           check_segment[1] = sec
3864             && ! bfd_is_abs_section (sec)
3865             && ! bfd_is_und_section (sec)
3866             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3867             : tls_segment;
3868           break;
3869
3870         case R_FRV_TLSMOFF12:
3871         case R_FRV_TLSMOFFHI:
3872         case R_FRV_TLSMOFFLO:
3873         case R_FRV_TLSMOFF:
3874           check_segment[0] = tls_segment;
3875           if (! sec)
3876             check_segment[1] = -1;
3877           else if (bfd_is_abs_section (sec)
3878                    || bfd_is_und_section (sec))
3879             {
3880               relocation = 0;
3881               check_segment[1] = tls_segment;
3882             }
3883           else if (sec->output_section)
3884             {
3885               relocation -= tls_biased_base (info);
3886               check_segment[1] =
3887                 _frvfdpic_osec_to_segment (output_bfd, sec->output_section);
3888             }
3889           break;
3890
3891         case R_FRV_GOTTLSOFF12:
3892         case R_FRV_GOTTLSOFFHI:
3893         case R_FRV_GOTTLSOFFLO:
3894           BFD_ASSERT (picrel->tlsoff_entry);
3895           relocation = picrel->tlsoff_entry;
3896           check_segment[0] = tls_segment;
3897           check_segment[1] = sec
3898             && ! bfd_is_abs_section (sec)
3899             && ! bfd_is_und_section (sec)
3900             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3901             : tls_segment;
3902           break;
3903
3904         case R_FRV_TLSDESC_VALUE:
3905         case R_FRV_TLSOFF:
3906           /* These shouldn't be present in input object files.  */
3907           check_segment[0] = check_segment[1] = isec_segment;
3908           break;
3909
3910         case R_FRV_TLSDESC_RELAX:
3911         case R_FRV_GETTLSOFF_RELAX:
3912         case R_FRV_TLSOFF_RELAX:
3913           /* These are just annotations for relaxation, nothing to do
3914              here.  */
3915           continue;
3916
3917         default:
3918           check_segment[0] = isec_segment;
3919           check_segment[1] = sec
3920             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3921             : (unsigned)-1;
3922           break;
3923         }
3924
3925       if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3926         {
3927           /* If you take this out, remove the #error from fdpic-static-6.d
3928              in the ld testsuite.  */
3929           /* This helps catch problems in GCC while we can't do more
3930              than static linking.  The idea is to test whether the
3931              input file basename is crt0.o only once.  */
3932           if (silence_segment_error == 1)
3933             silence_segment_error =
3934               (strlen (input_bfd->filename) == 6
3935                && strcmp (input_bfd->filename, "crt0.o") == 0)
3936               || (strlen (input_bfd->filename) > 6
3937                   && strcmp (input_bfd->filename
3938                              + strlen (input_bfd->filename) - 7,
3939                              "/crt0.o") == 0)
3940               ? -1 : 0;
3941           if (!silence_segment_error
3942               /* We don't want duplicate errors for undefined
3943                  symbols.  */
3944               && !(picrel && picrel->symndx == -1
3945                    && picrel->d.h->root.type == bfd_link_hash_undefined))
3946             info->callbacks->warning
3947               (info,
3948                (info->shared || info->pie)
3949                ? _("relocations between different segments are not supported")
3950                : _("warning: relocation references a different segment"),
3951                name, input_bfd, input_section, rel->r_offset);
3952           if (!silence_segment_error && (info->shared || info->pie))
3953             return FALSE;
3954           elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
3955         }
3956
3957       switch (r_type)
3958         {
3959         case R_FRV_GOTOFFHI:
3960         case R_FRV_TLSMOFFHI:
3961           /* We need the addend to be applied before we shift the
3962              value right.  */
3963           relocation += rel->r_addend;
3964           /* Fall through.  */
3965         case R_FRV_GOTHI:
3966         case R_FRV_FUNCDESC_GOTHI:
3967         case R_FRV_FUNCDESC_GOTOFFHI:
3968         case R_FRV_GOTTLSOFFHI:
3969         case R_FRV_GOTTLSDESCHI:
3970           relocation >>= 16;
3971           /* Fall through.  */
3972
3973         case R_FRV_GOTLO:
3974         case R_FRV_FUNCDESC_GOTLO:
3975         case R_FRV_GOTOFFLO:
3976         case R_FRV_FUNCDESC_GOTOFFLO:
3977         case R_FRV_GOTTLSOFFLO:
3978         case R_FRV_GOTTLSDESCLO:
3979         case R_FRV_TLSMOFFLO:
3980           relocation &= 0xffff;
3981           break;
3982
3983         default:
3984           break;
3985         }
3986
3987       switch (r_type)
3988         {
3989         case R_FRV_LABEL24:
3990           if (! IS_FDPIC (output_bfd) || ! picrel->plt)
3991             break;
3992           /* Fall through.  */
3993
3994           /* When referencing a GOT entry, a function descriptor or a
3995              PLT, we don't want the addend to apply to the reference,
3996              but rather to the referenced symbol.  The actual entry
3997              will have already been created taking the addend into
3998              account, so cancel it out here.  */
3999         case R_FRV_GOT12:
4000         case R_FRV_GOTHI:
4001         case R_FRV_GOTLO:
4002         case R_FRV_FUNCDESC_GOT12:
4003         case R_FRV_FUNCDESC_GOTHI:
4004         case R_FRV_FUNCDESC_GOTLO:
4005         case R_FRV_FUNCDESC_GOTOFF12:
4006         case R_FRV_FUNCDESC_GOTOFFHI:
4007         case R_FRV_FUNCDESC_GOTOFFLO:
4008         case R_FRV_GETTLSOFF:
4009         case R_FRV_GOTTLSDESC12:
4010         case R_FRV_GOTTLSDESCHI:
4011         case R_FRV_GOTTLSDESCLO:
4012         case R_FRV_GOTTLSOFF12:
4013         case R_FRV_GOTTLSOFFHI:
4014         case R_FRV_GOTTLSOFFLO:
4015           /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
4016              here, since we do want to apply the addend to the others.
4017              Note that we've applied the addend to GOTOFFHI before we
4018              shifted it right.  */
4019         case R_FRV_GOTOFFHI:
4020         case R_FRV_TLSMOFFHI:
4021           relocation -= rel->r_addend;
4022           break;
4023
4024         default:
4025           break;
4026         }
4027
4028      if (r_type == R_FRV_HI16)
4029        r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
4030
4031      else if (r_type == R_FRV_LO16)
4032        r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
4033
4034      else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF)
4035        r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
4036                                        contents, relocation);
4037
4038      else if (r_type == R_FRV_GPREL12)
4039        r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
4040                                        contents, relocation);
4041
4042      else if (r_type == R_FRV_GPRELU12)
4043        r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
4044                                         contents, relocation);
4045
4046      else if (r_type == R_FRV_GPRELLO)
4047        r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
4048                                        contents, relocation);
4049
4050      else if (r_type == R_FRV_GPRELHI)
4051        r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
4052                                        contents, relocation);
4053
4054      else if (r_type == R_FRV_TLSOFF
4055               || r_type == R_FRV_TLSDESC_VALUE)
4056        r = bfd_reloc_notsupported;
4057
4058      else
4059        r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
4060                                     rel, relocation);
4061
4062       if (r != bfd_reloc_ok)
4063         {
4064           const char * msg = (const char *) NULL;
4065
4066           switch (r)
4067             {
4068             case bfd_reloc_overflow:
4069               r = info->callbacks->reloc_overflow
4070                 (info, (h ? &h->root : NULL), name, howto->name,
4071                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4072               break;
4073
4074             case bfd_reloc_undefined:
4075               r = info->callbacks->undefined_symbol
4076                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
4077               break;
4078
4079             case bfd_reloc_outofrange:
4080               msg = _("internal error: out of range error");
4081               break;
4082
4083             case bfd_reloc_notsupported:
4084               msg = _("internal error: unsupported relocation error");
4085               break;
4086
4087             case bfd_reloc_dangerous:
4088               msg = _("internal error: dangerous relocation");
4089               break;
4090
4091             default:
4092               msg = _("internal error: unknown error");
4093               break;
4094             }
4095
4096           if (msg)
4097             r = info->callbacks->warning
4098               (info, msg, name, input_bfd, input_section, rel->r_offset);
4099
4100           if (! r)
4101             return FALSE;
4102         }
4103     }
4104
4105   return TRUE;
4106 }
4107 \f
4108 /* Return the section that should be marked against GC for a given
4109    relocation.  */
4110
4111 static asection *
4112 elf32_frv_gc_mark_hook (sec, info, rel, h, sym)
4113      asection *sec;
4114      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4115      Elf_Internal_Rela *rel;
4116      struct elf_link_hash_entry *h;
4117      Elf_Internal_Sym *sym;
4118 {
4119   if (h != NULL)
4120     {
4121       switch (ELF32_R_TYPE (rel->r_info))
4122         {
4123         case R_FRV_GNU_VTINHERIT:
4124         case R_FRV_GNU_VTENTRY:
4125           break;
4126
4127         default:
4128           switch (h->root.type)
4129             {
4130             default:
4131               break;
4132
4133             case bfd_link_hash_defined:
4134             case bfd_link_hash_defweak:
4135               return h->root.u.def.section;
4136
4137             case bfd_link_hash_common:
4138               return h->root.u.c.p->section;
4139             }
4140         }
4141     }
4142   else
4143     return bfd_section_from_elf_index (sec->owner, sym->st_shndx);
4144
4145   return NULL;
4146 }
4147
4148 /* Update the got entry reference counts for the section being removed.  */
4149
4150 static bfd_boolean
4151 elf32_frv_gc_sweep_hook (abfd, info, sec, relocs)
4152      bfd *abfd ATTRIBUTE_UNUSED;
4153      struct bfd_link_info *info ATTRIBUTE_UNUSED;
4154      asection *sec ATTRIBUTE_UNUSED;
4155      const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED;
4156 {
4157   return TRUE;
4158 }
4159
4160 \f
4161 /* Hook called by the linker routine which adds symbols from an object
4162    file.  We use it to put .comm items in .scomm, and not .comm.  */
4163
4164 static bfd_boolean
4165 elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4166      bfd *abfd;
4167      struct bfd_link_info *info;
4168      Elf_Internal_Sym *sym;
4169      const char **namep ATTRIBUTE_UNUSED;
4170      flagword *flagsp ATTRIBUTE_UNUSED;
4171      asection **secp;
4172      bfd_vma *valp;
4173 {
4174   if (sym->st_shndx == SHN_COMMON
4175       && !info->relocatable
4176       && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
4177     {
4178       /* Common symbols less than or equal to -G nn bytes are
4179          automatically put into .sbss.  */
4180
4181       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
4182
4183       if (scomm == NULL)
4184         {
4185           scomm = bfd_make_section (abfd, ".scommon");
4186           if (scomm == NULL
4187               || !bfd_set_section_flags (abfd, scomm, (SEC_ALLOC
4188                                                        | SEC_IS_COMMON
4189                                                        | SEC_LINKER_CREATED)))
4190             return FALSE;
4191         }
4192
4193       *secp = scomm;
4194       *valp = sym->st_size;
4195     }
4196
4197   return TRUE;
4198 }
4199
4200 /* We need dynamic symbols for every section, since segments can
4201    relocate independently.  */
4202 static bfd_boolean
4203 _frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
4204                                     struct bfd_link_info *info
4205                                     ATTRIBUTE_UNUSED,
4206                                     asection *p ATTRIBUTE_UNUSED)
4207 {
4208   switch (elf_section_data (p)->this_hdr.sh_type)
4209     {
4210     case SHT_PROGBITS:
4211     case SHT_NOBITS:
4212       /* If sh_type is yet undecided, assume it could be
4213          SHT_PROGBITS/SHT_NOBITS.  */
4214     case SHT_NULL:
4215       return FALSE;
4216
4217       /* There shouldn't be section relative relocations
4218          against any other section.  */
4219     default:
4220       return TRUE;
4221     }
4222 }
4223
4224 /* Create  a .got section, as well as its additional info field.  This
4225    is almost entirely copied from
4226    elflink.c:_bfd_elf_create_got_section().  */
4227
4228 static bfd_boolean
4229 _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
4230 {
4231   flagword flags, pltflags;
4232   asection *s;
4233   struct elf_link_hash_entry *h;
4234   struct bfd_link_hash_entry *bh;
4235   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4236   int ptralign;
4237   int offset;
4238
4239   /* This function may be called more than once.  */
4240   s = bfd_get_section_by_name (abfd, ".got");
4241   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
4242     return TRUE;
4243
4244   /* Machine specific: although pointers are 32-bits wide, we want the
4245      GOT to be aligned to a 64-bit boundary, such that function
4246      descriptors in it can be accessed with 64-bit loads and
4247      stores.  */
4248   ptralign = 3;
4249
4250   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4251            | SEC_LINKER_CREATED);
4252   pltflags = flags;
4253
4254   s = bfd_make_section (abfd, ".got");
4255   if (s == NULL
4256       || !bfd_set_section_flags (abfd, s, flags)
4257       || !bfd_set_section_alignment (abfd, s, ptralign))
4258     return FALSE;
4259
4260   if (bed->want_got_plt)
4261     {
4262       s = bfd_make_section (abfd, ".got.plt");
4263       if (s == NULL
4264           || !bfd_set_section_flags (abfd, s, flags)
4265           || !bfd_set_section_alignment (abfd, s, ptralign))
4266         return FALSE;
4267     }
4268
4269   if (bed->want_got_sym)
4270     {
4271       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4272          (or .got.plt) section.  We don't do this in the linker script
4273          because we don't want to define the symbol if we are not creating
4274          a global offset table.  */
4275       bh = NULL;
4276       if (!(_bfd_generic_link_add_one_symbol
4277             (info, abfd, "_GLOBAL_OFFSET_TABLE_", BSF_GLOBAL, s,
4278              bed->got_symbol_offset, (const char *) NULL, FALSE,
4279              bed->collect, &bh)))
4280         return FALSE;
4281       h = (struct elf_link_hash_entry *) bh;
4282       h->def_regular = 1;
4283       h->type = STT_OBJECT;
4284       /* h->other = STV_HIDDEN; */ /* Should we?  */
4285
4286       /* Machine-specific: we want the symbol for executables as
4287          well.  */
4288       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4289         return FALSE;
4290
4291       elf_hash_table (info)->hgot = h;
4292     }
4293
4294   /* The first bit of the global offset table is the header.  */
4295   s->size += bed->got_header_size + bed->got_symbol_offset;
4296
4297   /* This is the machine-specific part.  Create and initialize section
4298      data for the got.  */
4299   if (IS_FDPIC (abfd))
4300     {
4301       frvfdpic_got_section (info) = s;
4302       frvfdpic_relocs_info (info) = htab_try_create (1,
4303                                                      frvfdpic_relocs_info_hash,
4304                                                      frvfdpic_relocs_info_eq,
4305                                                      (htab_del) NULL);
4306       if (! frvfdpic_relocs_info (info))
4307         return FALSE;
4308
4309       s = bfd_make_section (abfd, ".rel.got");
4310       if (s == NULL
4311           || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
4312           || ! bfd_set_section_alignment (abfd, s, 2))
4313         return FALSE;
4314
4315       frvfdpic_gotrel_section (info) = s;
4316
4317       /* Machine-specific.  */
4318       s = bfd_make_section (abfd, ".rofixup");
4319       if (s == NULL
4320           || ! bfd_set_section_flags (abfd, s, (flags | SEC_READONLY))
4321           || ! bfd_set_section_alignment (abfd, s, 2))
4322         return FALSE;
4323
4324       frvfdpic_gotfixup_section (info) = s;
4325       offset = -2048;
4326       flags = BSF_GLOBAL;
4327     }
4328   else
4329     {
4330       offset = 2048;
4331       flags = BSF_GLOBAL | BSF_WEAK;
4332     }
4333
4334   /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
4335      turns out that we're linking with a different linker script, the
4336      linker script will override it.  */
4337   bh = NULL;
4338   if (!(_bfd_generic_link_add_one_symbol
4339         (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
4340          bed->collect, &bh)))
4341     return FALSE;
4342   h = (struct elf_link_hash_entry *) bh;
4343   h->def_regular = 1;
4344   h->type = STT_OBJECT;
4345   /* h->other = STV_HIDDEN; */ /* Should we?  */
4346
4347   /* Machine-specific: we want the symbol for executables as well.  */
4348   if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
4349     return FALSE;
4350
4351   if (!IS_FDPIC (abfd))
4352     return TRUE;
4353
4354   /* FDPIC supports Thread Local Storage, and this may require a
4355      procedure linkage table for TLS PLT entries.  */
4356
4357   /* This is mostly copied from
4358      elflink.c:_bfd_elf_create_dynamic_sections().  */
4359
4360   flags = pltflags;
4361   pltflags |= SEC_CODE;
4362   if (bed->plt_not_loaded)
4363     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
4364   if (bed->plt_readonly)
4365     pltflags |= SEC_READONLY;
4366
4367   s = bfd_make_section (abfd, ".plt");
4368   if (s == NULL
4369       || ! bfd_set_section_flags (abfd, s, pltflags)
4370       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
4371     return FALSE;
4372   /* FRV-specific: remember it.  */
4373   frvfdpic_plt_section (info) = s;
4374
4375   if (bed->want_plt_sym)
4376     {
4377       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4378          .plt section.  */
4379       struct elf_link_hash_entry *h;
4380       struct bfd_link_hash_entry *bh = NULL;
4381
4382       if (! (_bfd_generic_link_add_one_symbol
4383              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
4384               FALSE, get_elf_backend_data (abfd)->collect, &bh)))
4385         return FALSE;
4386       h = (struct elf_link_hash_entry *) bh;
4387       h->def_regular = 1;
4388       h->type = STT_OBJECT;
4389       /* h->other = STV_HIDDEN; */ /* Should we?  */
4390
4391       if (! info->executable
4392           && ! bfd_elf_link_record_dynamic_symbol (info, h))
4393         return FALSE;
4394     }
4395
4396   /* FRV-specific: we want rel relocations for the plt.  */
4397   s = bfd_make_section (abfd, ".rel.plt");
4398   if (s == NULL
4399       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4400       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4401     return FALSE;
4402   /* FRV-specific: remember it.  */
4403   frvfdpic_pltrel_section (info) = s;
4404
4405   return TRUE;
4406 }
4407
4408 /* Make sure the got and plt sections exist, and that our pointers in
4409    the link hash table point to them.  */
4410
4411 static bfd_boolean
4412 elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4413 {
4414   /* This is mostly copied from
4415      elflink.c:_bfd_elf_create_dynamic_sections().  */
4416   flagword flags;
4417   asection *s;
4418   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4419
4420   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4421            | SEC_LINKER_CREATED);
4422
4423   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4424      .rel[a].bss sections.  */
4425
4426   /* FRV-specific: we want to create the GOT and the PLT in the FRV
4427      way.  */
4428   if (! _frv_create_got_section (abfd, info))
4429     return FALSE;
4430
4431   /* FRV-specific: make sure we created everything we wanted.  */
4432   BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
4433               && frvfdpic_gotfixup_section (info)
4434               && frvfdpic_plt_section (info)
4435               && frvfdpic_pltrel_section (info));
4436
4437   if (bed->want_dynbss)
4438     {
4439       /* The .dynbss section is a place to put symbols which are defined
4440          by dynamic objects, are referenced by regular objects, and are
4441          not functions.  We must allocate space for them in the process
4442          image and use a R_*_COPY reloc to tell the dynamic linker to
4443          initialize them at run time.  The linker script puts the .dynbss
4444          section into the .bss section of the final image.  */
4445       s = bfd_make_section (abfd, ".dynbss");
4446       if (s == NULL
4447           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
4448         return FALSE;
4449
4450       /* The .rel[a].bss section holds copy relocs.  This section is not
4451      normally needed.  We need to create it here, though, so that the
4452      linker will map it to an output section.  We can't just create it
4453      only if we need it, because we will not know whether we need it
4454      until we have seen all the input files, and the first time the
4455      main linker code calls BFD after examining all the input files
4456      (size_dynamic_sections) the input sections have already been
4457      mapped to the output sections.  If the section turns out not to
4458      be needed, we can discard it later.  We will never need this
4459      section when generating a shared object, since they do not use
4460      copy relocs.  */
4461       if (! info->shared)
4462         {
4463           s = bfd_make_section (abfd,
4464                                 (bed->default_use_rela_p
4465                                  ? ".rela.bss" : ".rel.bss"));
4466           if (s == NULL
4467               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
4468               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4469             return FALSE;
4470         }
4471     }
4472
4473   return TRUE;
4474 }
4475
4476 /* Compute the total GOT and PLT size required by each symbol in each
4477    range.  Symbols may require up to 4 words in the GOT: an entry
4478    pointing to the symbol, an entry pointing to its function
4479    descriptor, and a private function descriptors taking two
4480    words.  */
4481
4482 static void
4483 _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4484                                 struct _frvfdpic_dynamic_got_info *dinfo)
4485 {
4486   /* Allocate space for a GOT entry pointing to the symbol.  */
4487   if (entry->got12)
4488     dinfo->got12 += 4;
4489   else if (entry->gotlos)
4490     dinfo->gotlos += 4;
4491   else if (entry->gothilo)
4492     dinfo->gothilo += 4;
4493   else
4494     entry->relocs32--;
4495   entry->relocs32++;
4496
4497   /* Allocate space for a GOT entry pointing to the function
4498      descriptor.  */
4499   if (entry->fdgot12)
4500     dinfo->got12 += 4;
4501   else if (entry->fdgotlos)
4502     dinfo->gotlos += 4;
4503   else if (entry->fdgothilo)
4504     dinfo->gothilo += 4;
4505   else
4506     entry->relocsfd--;
4507   entry->relocsfd++;
4508
4509   /* Decide whether we need a PLT entry, a function descriptor in the
4510      GOT, and a lazy PLT entry for this symbol.  */
4511   entry->plt = entry->call
4512     && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4513     && elf_hash_table (dinfo->info)->dynamic_sections_created;
4514   entry->privfd = entry->plt
4515     || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4516     || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4517         && (entry->symndx != -1
4518             || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4519   entry->lazyplt = entry->privfd
4520     && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4521     && ! (dinfo->info->flags & DF_BIND_NOW)
4522     && elf_hash_table (dinfo->info)->dynamic_sections_created;
4523
4524   /* Allocate space for a function descriptor.  */
4525   if (entry->fdgoff12)
4526     dinfo->fd12 += 8;
4527   else if (entry->fdgofflos)
4528     dinfo->fdlos += 8;
4529   else if (entry->privfd && entry->plt)
4530     dinfo->fdplt += 8;
4531   else if (entry->privfd)
4532     dinfo->fdhilo += 8;
4533   else
4534     entry->relocsfdv--;
4535   entry->relocsfdv++;
4536
4537   if (entry->lazyplt)
4538     dinfo->lzplt += 8;
4539 }
4540
4541 /* Compute the total GOT size required by each TLS symbol in each
4542    range.  Symbols may require up to 5 words in the GOT: an entry
4543    holding the TLS offset for the symbol, and an entry with a full TLS
4544    descriptor taking 4 words.  */
4545
4546 static void
4547 _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4548                              struct _frvfdpic_dynamic_got_info *dinfo,
4549                              bfd_boolean subtract)
4550 {
4551   const int l = subtract ? -1 : 1;
4552
4553   /* Allocate space for a GOT entry with the TLS offset of the
4554      symbol.  */
4555   if (entry->tlsoff12)
4556     dinfo->got12 += 4 * l;
4557   else if (entry->tlsofflos)
4558     dinfo->gotlos += 4 * l;
4559   else if (entry->tlsoffhilo)
4560     dinfo->gothilo += 4 * l;
4561   else
4562     entry->relocstlsoff -= l;
4563   entry->relocstlsoff += l;
4564
4565   /* If there's any TLSOFF relocation, mark the output file as not
4566      suitable for dlopening.  This mark will remain even if we relax
4567      all such relocations, but this is not a problem, since we'll only
4568      do so for executables, and we definitely don't want anyone
4569      dlopening executables.  */
4570   if (entry->relocstlsoff)
4571     dinfo->info->flags |= DF_STATIC_TLS;
4572
4573   /* Allocate space for a TLS descriptor.  */
4574   if (entry->tlsdesc12)
4575     dinfo->tlsd12 += 8 * l;
4576   else if (entry->tlsdesclos)
4577     dinfo->tlsdlos += 8 * l;
4578   else if (entry->tlsplt)
4579     dinfo->tlsdplt += 8 * l;
4580   else if (entry->tlsdeschilo)
4581     dinfo->tlsdhilo += 8 * l;
4582   else
4583     entry->relocstlsd -= l;
4584   entry->relocstlsd += l;
4585 }
4586
4587 /* Compute the number of dynamic relocations and fixups that a symbol
4588    requires, and add (or subtract) from the grand and per-symbol
4589    totals.  */
4590
4591 static void
4592 _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4593                                struct _frvfdpic_dynamic_got_info *dinfo,
4594                                bfd_boolean subtract)
4595 {
4596   bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
4597
4598   if (!dinfo->info->executable || dinfo->info->pie)
4599     {
4600       relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4601         + entry->relocstlsd;
4602
4603       /* In the executable, TLS relocations to symbols that bind
4604          locally (including those that resolve to global TLS offsets)
4605          are resolved immediately, without any need for fixups or
4606          dynamic relocations.  In shared libraries, however, we must
4607          emit dynamic relocations even for local symbols, because we
4608          don't know the module id the library is going to get at
4609          run-time, nor its TLS base offset.  */
4610       if (!dinfo->info->executable
4611           || (entry->symndx == -1
4612               && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4613         relocs += entry->relocstlsoff;
4614     }
4615   else
4616     {
4617       if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4618         {
4619           if (entry->symndx != -1
4620               || entry->d.h->root.type != bfd_link_hash_undefweak)
4621             fixups += entry->relocs32 + 2 * entry->relocsfdv;
4622           fixups += entry->relocstlsd;
4623           tlsrets += entry->relocstlsd;
4624         }
4625       else
4626         {
4627           relocs += entry->relocs32 + entry->relocsfdv
4628             + entry->relocstlsoff + entry->relocstlsd;
4629         }
4630
4631       if (entry->symndx != -1
4632           || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4633         {
4634           if (entry->symndx != -1
4635               || entry->d.h->root.type != bfd_link_hash_undefweak)
4636             fixups += entry->relocsfd;
4637         }
4638       else
4639         relocs += entry->relocsfd;
4640     }
4641
4642   if (subtract)
4643     {
4644       relocs = - relocs;
4645       fixups = - fixups;
4646       tlsrets = - tlsrets;
4647     }
4648
4649   entry->dynrelocs += relocs;
4650   entry->fixups += fixups;
4651   dinfo->relocs += relocs;
4652   dinfo->fixups += fixups;
4653   dinfo->tls_ret_refs += tlsrets;
4654 }
4655
4656 /* Look for opportunities to relax TLS relocations.  We can assume
4657    we're linking the main executable or a static-tls library, since
4658    otherwise we wouldn't have got here.  When relaxing, we have to
4659    first undo any previous accounting of TLS uses of fixups, dynamic
4660    relocations, GOT and PLT entries.  */
4661
4662 static void
4663 _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4664                              struct _frvfdpic_dynamic_got_info *dinfo,
4665                              bfd_boolean relaxing)
4666 {
4667   bfd_boolean changed = ! relaxing;
4668
4669   BFD_ASSERT (dinfo->info->executable
4670               || (dinfo->info->flags & DF_STATIC_TLS));
4671
4672   if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4673     {
4674       if (! changed)
4675         {
4676           _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4677           _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4678           changed = TRUE;
4679         }
4680
4681       /* When linking an executable, we can always decay GOTTLSDESC to
4682          TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4683          When linking a static-tls shared library, using TLSMOFF is
4684          not an option, but we can still use GOTTLSOFF.  When decaying
4685          to GOTTLSOFF, we must keep the GOT entry in range.  We know
4686          it has to fit because we'll be trading the 4 words of hte TLS
4687          descriptor for a single word in the same range.  */
4688       if (! dinfo->info->executable
4689           || (entry->symndx == -1
4690               && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4691         {
4692           entry->tlsoff12 |= entry->tlsdesc12;
4693           entry->tlsofflos |= entry->tlsdesclos;
4694           entry->tlsoffhilo |= entry->tlsdeschilo;
4695         }
4696
4697       entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4698     }
4699
4700   /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4701      main executable.  We have to check whether the symbol's TLSOFF is
4702      in range for a setlos.  For symbols with a hash entry, we can
4703      determine exactly what to do; for others locals, we don't have
4704      addresses handy, so we use the size of the TLS section as an
4705      approximation.  If we get it wrong, we'll retain a GOT entry
4706      holding the TLS offset (without dynamic relocations or fixups),
4707      but we'll still optimize away the loads from it.  Since TLS sizes
4708      are generally very small, it's probably not worth attempting to
4709      do better than this.  */
4710   if ((entry->tlsplt
4711        || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4712       && dinfo->info->executable && relaxing
4713       && ((entry->symndx == -1
4714            && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4715            /* The above may hold for an undefweak TLS symbol, so make
4716               sure we don't have this case before accessing def.value
4717               and def.section.  */
4718            && (entry->d.h->root.type == bfd_link_hash_undefweak
4719                || (bfd_vma)(entry->d.h->root.u.def.value
4720                             + (entry->d.h->root.u.def.section
4721                                ->output_section->vma)
4722                             + entry->d.h->root.u.def.section->output_offset
4723                             + entry->addend
4724                             - tls_biased_base (dinfo->info)
4725                             + 32768) < (bfd_vma)65536))
4726           || (entry->symndx != -1
4727               && (elf_hash_table (dinfo->info)->tls_sec->size
4728                   + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
4729     {
4730       if (! changed)
4731         {
4732           _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4733           _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4734           changed = TRUE;
4735         }
4736
4737       entry->tlsplt =
4738         entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4739     }
4740
4741   /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4742      have a #gottlsoff12 relocation for this entry, or if we can fit
4743      one more in the 12-bit (and 16-bit) ranges.  */
4744   if (entry->tlsplt
4745       && (entry->tlsoff12
4746           || (relaxing
4747               && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4
4748               && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12
4749                   + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos
4750                   <= 65536 - 12 - 4))))
4751     {
4752       if (! changed)
4753         {
4754           _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4755           _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4756           changed = TRUE;
4757         }
4758
4759       entry->tlsoff12 = 1;
4760       entry->tlsplt = 0;
4761     }
4762
4763   if (changed)
4764     {
4765       _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4766       _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4767     }
4768
4769   return;
4770 }
4771
4772 /* Compute the total GOT and PLT size required by each symbol in each range. *
4773    Symbols may require up to 4 words in the GOT: an entry pointing to
4774    the symbol, an entry pointing to its function descriptor, and a
4775    private function descriptors taking two words.  */
4776
4777 static int
4778 _frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
4779 {
4780   struct frvfdpic_relocs_info *entry = *entryp;
4781   struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
4782
4783   _frvfdpic_count_nontls_entries (entry, dinfo);
4784
4785   if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
4786     _frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
4787   else
4788     {
4789       _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4790       _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4791     }
4792
4793   return 1;
4794 }
4795
4796 /* Determine the positive and negative ranges to be used by each
4797    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
4798    double-word boundary, are the minimum (negative) and maximum
4799    (positive) GOT offsets already used by previous ranges, except for
4800    an ODD entry that may have been left behind.  GOT and FD indicate
4801    the size of GOT entries and function descriptors that must be
4802    placed within the range from -WRAP to WRAP.  If there's room left,
4803    up to FDPLT bytes should be reserved for additional function
4804    descriptors.  */
4805
4806 inline static bfd_signed_vma
4807 _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
4808                                   bfd_signed_vma fdcur,
4809                                   bfd_signed_vma odd,
4810                                   bfd_signed_vma cur,
4811                                   bfd_vma got,
4812                                   bfd_vma fd,
4813                                   bfd_vma fdplt,
4814                                   bfd_vma tlsd,
4815                                   bfd_vma tlsdplt,
4816                                   bfd_vma wrap)
4817 {
4818   bfd_signed_vma wrapmin = -wrap;
4819   const bfd_vma tdescsz = 8;
4820
4821   /* Start at the given initial points.  */
4822   gad->fdcur = fdcur;
4823   gad->cur = cur;
4824
4825   /* If we had an incoming odd word and we have any got entries that
4826      are going to use it, consume it, otherwise leave gad->odd at
4827      zero.  We might force gad->odd to zero and return the incoming
4828      odd such that it is used by the next range, but then GOT entries
4829      might appear to be out of order and we wouldn't be able to
4830      shorten the GOT by one word if it turns out to end with an
4831      unpaired GOT entry.  */
4832   if (odd && got)
4833     {
4834       gad->odd = odd;
4835       got -= 4;
4836       odd = 0;
4837     }
4838   else
4839     gad->odd = 0;
4840
4841   /* If we're left with an unpaired GOT entry, compute its location
4842      such that we can return it.  Otherwise, if got doesn't require an
4843      odd number of words here, either odd was already zero in the
4844      block above, or it was set to zero because got was non-zero, or
4845      got was already zero.  In the latter case, we want the value of
4846      odd to carry over to the return statement, so we don't want to
4847      reset odd unless the condition below is true.  */
4848   if (got & 4)
4849     {
4850       odd = cur + got;
4851       got += 4;
4852     }
4853
4854   /* Compute the tentative boundaries of this range.  */
4855   gad->max = cur + got;
4856   gad->min = fdcur - fd;
4857   gad->fdplt = 0;
4858
4859   /* If function descriptors took too much space, wrap some of them
4860      around.  */
4861   if (gad->min < wrapmin)
4862     {
4863       gad->max += wrapmin - gad->min;
4864       gad->tmin = gad->min = wrapmin;
4865     }
4866
4867   /* If GOT entries took too much space, wrap some of them around.
4868      This may well cause gad->min to become lower than wrapmin.  This
4869      will cause a relocation overflow later on, so we don't have to
4870      report it here . */
4871   if ((bfd_vma) gad->max > wrap)
4872     {
4873       gad->min -= gad->max - wrap;
4874       gad->max = wrap;
4875     }
4876
4877   /* Add TLS descriptors.  */
4878   gad->tmax = gad->max + tlsd;
4879   gad->tmin = gad->min;
4880   gad->tlsdplt = 0;
4881
4882   /* If TLS descriptors took too much space, wrap an integral number
4883      of them around.  */
4884   if ((bfd_vma) gad->tmax > wrap)
4885     {
4886       bfd_vma wrapsize = gad->tmax - wrap;
4887
4888       wrapsize += tdescsz / 2;
4889       wrapsize &= ~ tdescsz / 2;
4890
4891       gad->tmin -= wrapsize;
4892       gad->tmax -= wrapsize;
4893     }
4894
4895   /* If there is space left and we have function descriptors
4896      referenced in PLT entries that could take advantage of shorter
4897      offsets, place them now.  */
4898   if (fdplt && gad->tmin > wrapmin)
4899     {
4900       bfd_vma fds;
4901
4902       if ((bfd_vma) (gad->tmin - wrapmin) < fdplt)
4903         fds = gad->tmin - wrapmin;
4904       else
4905         fds = fdplt;
4906
4907       fdplt -= fds;
4908       gad->min -= fds;
4909       gad->tmin -= fds;
4910       gad->fdplt += fds;
4911     }
4912
4913   /* If there is more space left, try to place some more function
4914      descriptors for PLT entries.  */
4915   if (fdplt && (bfd_vma) gad->tmax < wrap)
4916     {
4917       bfd_vma fds;
4918
4919       if ((bfd_vma) (wrap - gad->tmax) < fdplt)
4920         fds = wrap - gad->tmax;
4921       else
4922         fds = fdplt;
4923
4924       fdplt -= fds;
4925       gad->max += fds;
4926       gad->tmax += fds;
4927       gad->fdplt += fds;
4928     }
4929
4930   /* If there is space left and we have TLS descriptors referenced in
4931      PLT entries that could take advantage of shorter offsets, place
4932      them now.  */
4933   if (tlsdplt && gad->tmin > wrapmin)
4934     {
4935       bfd_vma tlsds;
4936
4937       if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt)
4938         tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2);
4939       else
4940         tlsds = tlsdplt;
4941
4942       tlsdplt -= tlsds;
4943       gad->tmin -= tlsds;
4944       gad->tlsdplt += tlsds;
4945     }
4946
4947   /* If there is more space left, try to place some more TLS
4948      descriptors for PLT entries.  Although we could try to fit an
4949      additional TLS descriptor with half of it just before before the
4950      wrap point and another right past the wrap point, this might
4951      cause us to run out of space for the next region, so don't do
4952      it.  */
4953   if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2)
4954     {
4955       bfd_vma tlsds;
4956
4957       if ((bfd_vma) (wrap - gad->tmax) < tlsdplt)
4958         tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2);
4959       else
4960         tlsds = tlsdplt;
4961
4962       tlsdplt -= tlsds;
4963       gad->tmax += tlsds;
4964       gad->tlsdplt += tlsds;
4965     }
4966
4967   /* If odd was initially computed as an offset past the wrap point,
4968      wrap it around.  */
4969   if (odd > gad->max)
4970     odd = gad->min + odd - gad->max;
4971
4972   /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
4973      before returning, so do it here too.  This guarantees that,
4974      should cur and fdcur meet at the wrap point, they'll both be
4975      equal to min.  */
4976   if (gad->cur == gad->max)
4977     gad->cur = gad->min;
4978
4979   /* Ditto for _frvfdpic_get_tlsdesc_entry().  */
4980   gad->tcur = gad->max;
4981   if (gad->tcur == gad->tmax)
4982     gad->tcur = gad->tmin;
4983
4984   return odd;
4985 }
4986
4987 /* Compute the location of the next GOT entry, given the allocation
4988    data for a range.  */
4989
4990 inline static bfd_signed_vma
4991 _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4992 {
4993   bfd_signed_vma ret;
4994
4995   if (gad->odd)
4996     {
4997       /* If there was an odd word left behind, use it.  */
4998       ret = gad->odd;
4999       gad->odd = 0;
5000     }
5001   else
5002     {
5003       /* Otherwise, use the word pointed to by cur, reserve the next
5004          as an odd word, and skip to the next pair of words, possibly
5005          wrapping around.  */
5006       ret = gad->cur;
5007       gad->odd = gad->cur + 4;
5008       gad->cur += 8;
5009       if (gad->cur == gad->max)
5010         gad->cur = gad->min;
5011     }
5012
5013   return ret;
5014 }
5015
5016 /* Compute the location of the next function descriptor entry in the
5017    GOT, given the allocation data for a range.  */
5018
5019 inline static bfd_signed_vma
5020 _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5021 {
5022   /* If we're at the bottom, wrap around, and only then allocate the
5023      next pair of words.  */
5024   if (gad->fdcur == gad->min)
5025     gad->fdcur = gad->max;
5026   return gad->fdcur -= 8;
5027 }
5028
5029 /* Compute the location of the next TLS descriptor entry in the GOT,
5030    given the allocation data for a range.  */
5031 inline static bfd_signed_vma
5032 _frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5033 {
5034   bfd_signed_vma ret;
5035
5036   ret = gad->tcur;
5037
5038   gad->tcur += 8;
5039
5040   /* If we're at the top of the region, wrap around to the bottom.  */
5041   if (gad->tcur == gad->tmax)
5042     gad->tcur = gad->tmin;
5043
5044   return ret;
5045 }
5046
5047 /* Assign GOT offsets for every GOT entry and function descriptor.
5048    Doing everything in a single pass is tricky.  */
5049
5050 static int
5051 _frvfdpic_assign_got_entries (void **entryp, void *info_)
5052 {
5053   struct frvfdpic_relocs_info *entry = *entryp;
5054   struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5055
5056   if (entry->got12)
5057     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5058   else if (entry->gotlos)
5059     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5060   else if (entry->gothilo)
5061     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5062
5063   if (entry->fdgot12)
5064     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5065   else if (entry->fdgotlos)
5066     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5067   else if (entry->fdgothilo)
5068     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5069
5070   if (entry->fdgoff12)
5071     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5072   else if (entry->plt && dinfo->got12.fdplt)
5073     {
5074       dinfo->got12.fdplt -= 8;
5075       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5076     }
5077   else if (entry->fdgofflos)
5078     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5079   else if (entry->plt && dinfo->gotlos.fdplt)
5080     {
5081       dinfo->gotlos.fdplt -= 8;
5082       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5083     }
5084   else if (entry->plt)
5085     {
5086       dinfo->gothilo.fdplt -= 8;
5087       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5088     }
5089   else if (entry->privfd)
5090     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5091
5092   if (entry->tlsoff12)
5093     entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5094   else if (entry->tlsofflos)
5095     entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5096   else if (entry->tlsoffhilo)
5097     entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5098
5099   if (entry->tlsdesc12)
5100     entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5101   else if (entry->tlsplt && dinfo->got12.tlsdplt)
5102     {
5103       dinfo->got12.tlsdplt -= 8;
5104       entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5105     }
5106   else if (entry->tlsdesclos)
5107     entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5108   else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5109     {
5110       dinfo->gotlos.tlsdplt -= 8;
5111       entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5112     }
5113   else if (entry->tlsplt)
5114     {
5115       dinfo->gothilo.tlsdplt -= 8;
5116       entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5117     }
5118   else if (entry->tlsdeschilo)
5119     entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5120
5121   return 1;
5122 }
5123
5124 /* Assign GOT offsets to private function descriptors used by PLT
5125    entries (or referenced by 32-bit offsets), as well as PLT entries
5126    and lazy PLT entries.  */
5127
5128 static int
5129 _frvfdpic_assign_plt_entries (void **entryp, void *info_)
5130 {
5131   struct frvfdpic_relocs_info *entry = *entryp;
5132   struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5133
5134   if (entry->privfd)
5135     BFD_ASSERT (entry->fd_entry);
5136
5137   if (entry->plt)
5138     {
5139       int size;
5140
5141       /* We use the section's raw size to mark the location of the
5142          next PLT entry.  */
5143       entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5144
5145       /* Figure out the length of this PLT entry based on the
5146          addressing mode we need to reach the function descriptor.  */
5147       BFD_ASSERT (entry->fd_entry);
5148       if (entry->fd_entry >= -(1 << (12 - 1))
5149           && entry->fd_entry < (1 << (12 - 1)))
5150         size = 8;
5151       else if (entry->fd_entry >= -(1 << (16 - 1))
5152                && entry->fd_entry < (1 << (16 - 1)))
5153         size = 12;
5154       else
5155         size = 16;
5156
5157       frvfdpic_plt_section (dinfo->g.info)->size += size;
5158     }
5159
5160   if (entry->lazyplt)
5161     {
5162       entry->lzplt_entry = dinfo->g.lzplt;
5163       dinfo->g.lzplt += 8;
5164       /* If this entry is the one that gets the resolver stub, account
5165          for the additional instruction.  */
5166       if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5167           == FRVFDPIC_LZPLT_RESOLV_LOC)
5168         dinfo->g.lzplt += 4;
5169     }
5170
5171   if (entry->tlsplt)
5172     {
5173       int size;
5174
5175       entry->tlsplt_entry
5176         = frvfdpic_plt_section (dinfo->g.info)->size;
5177
5178       if (dinfo->g.info->executable
5179           && (entry->symndx != -1
5180               || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5181         {
5182           if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5183               /* FIXME: here we use the size of the TLS section
5184                  as an upper bound for the value of the TLS
5185                  symbol, because we may not know the exact value
5186                  yet.  If we get it wrong, we'll just waste a
5187                  word in the PLT, and we should never get even
5188                  close to 32 KiB of TLS anyway.  */
5189               && elf_hash_table (dinfo->g.info)->tls_sec
5190               && (elf_hash_table (dinfo->g.info)->tls_sec->size
5191                   + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5192             size = 8;
5193           else
5194             size = 12;
5195         }
5196       else if (entry->tlsoff_entry)
5197         {
5198           if (entry->tlsoff_entry >= -(1 << (12 - 1))
5199               && entry->tlsoff_entry < (1 << (12 - 1)))
5200             size = 8;
5201           else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5202                    && entry->tlsoff_entry < (1 << (16 - 1)))
5203             size = 12;
5204           else
5205             size = 16;
5206         }
5207       else
5208         {
5209           BFD_ASSERT (entry->tlsdesc_entry);
5210
5211           if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5212               && entry->tlsdesc_entry < (1 << (12 - 1)))
5213             size = 8;
5214           else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5215                    && entry->tlsdesc_entry < (1 << (16 - 1)))
5216             size = 12;
5217           else
5218             size = 16;
5219         }
5220
5221       frvfdpic_plt_section (dinfo->g.info)->size += size;
5222     }
5223
5224   return 1;
5225 }
5226
5227 /* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5228    _frvfdpic_assign_plt_entries.  */
5229
5230 static int
5231 _frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
5232 {
5233   struct frvfdpic_relocs_info *entry = *entryp;
5234
5235   entry->got_entry = 0;
5236   entry->fdgot_entry = 0;
5237   entry->fd_entry = 0;
5238   entry->plt_entry = (bfd_vma)-1;
5239   entry->lzplt_entry = (bfd_vma)-1;
5240   entry->tlsoff_entry = 0;
5241   entry->tlsdesc_entry = 0;
5242   entry->tlsplt_entry = (bfd_vma)-1;
5243
5244   return 1;
5245 }
5246
5247 /* Follow indirect and warning hash entries so that each got entry
5248    points to the final symbol definition.  P must point to a pointer
5249    to the hash table we're traversing.  Since this traversal may
5250    modify the hash table, we set this pointer to NULL to indicate
5251    we've made a potentially-destructive change to the hash table, so
5252    the traversal must be restarted.  */
5253 static int
5254 _frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
5255 {
5256   struct frvfdpic_relocs_info *entry = *entryp;
5257   htab_t *htab = p;
5258
5259   if (entry->symndx == -1)
5260     {
5261       struct elf_link_hash_entry *h = entry->d.h;
5262       struct frvfdpic_relocs_info *oentry;
5263
5264       while (h->root.type == bfd_link_hash_indirect
5265              || h->root.type == bfd_link_hash_warning)
5266         h = (struct elf_link_hash_entry *)h->root.u.i.link;
5267
5268       if (entry->d.h == h)
5269         return 1;
5270
5271       oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5272                                                 NO_INSERT);
5273
5274       if (oentry)
5275         {
5276           /* Merge the two entries.  */
5277           frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5278           htab_clear_slot (*htab, entryp);
5279           return 1;
5280         }
5281
5282       entry->d.h = h;
5283
5284       /* If we can't find this entry with the new bfd hash, re-insert
5285          it, and get the traversal restarted.  */
5286       if (! htab_find (*htab, entry))
5287         {
5288           htab_clear_slot (*htab, entryp);
5289           entryp = htab_find_slot (*htab, entry, INSERT);
5290           if (! *entryp)
5291             *entryp = entry;
5292           /* Abort the traversal, since the whole table may have
5293              moved, and leave it up to the parent to restart the
5294              process.  */
5295           *(htab_t *)p = NULL;
5296           return 0;
5297         }
5298     }
5299
5300   return 1;
5301 }
5302
5303 /* Compute the total size of the GOT, the PLT, the dynamic relocations
5304    section and the rofixup section.  Assign locations for GOT and PLT
5305    entries.  */
5306
5307 static bfd_boolean
5308 _frvfdpic_size_got_plt (bfd *output_bfd,
5309                         struct _frvfdpic_dynamic_got_plt_info *gpinfop)
5310 {
5311   bfd_signed_vma odd;
5312   bfd_vma limit, tlslimit;
5313   struct bfd_link_info *info = gpinfop->g.info;
5314   bfd *dynobj = elf_hash_table (info)->dynobj;
5315
5316   memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g,
5317           sizeof (gpinfop->g));
5318
5319   odd = 12;
5320   /* Compute the total size taken by entries in the 12-bit and 16-bit
5321      ranges, to tell how many PLT function descriptors we can bring
5322      into the 12-bit range without causing the 16-bit range to
5323      overflow.  */
5324   limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos
5325     + gpinfop->g.fd12 + gpinfop->g.fdlos
5326     + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos;
5327   if (limit < (bfd_vma)1 << 16)
5328     limit = ((bfd_vma)1 << 16) - limit;
5329   else
5330     limit = 0;
5331   if (gpinfop->g.fdplt < limit)
5332     {
5333       tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8;
5334       limit = gpinfop->g.fdplt;
5335     }
5336   else
5337     tlslimit = 0;
5338   if (gpinfop->g.tlsdplt < tlslimit)
5339     tlslimit = gpinfop->g.tlsdplt;
5340
5341   /* Determine the ranges of GOT offsets that we can use for each
5342      range of addressing modes.  */
5343   odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12,
5344                                           0,
5345                                           odd,
5346                                           16,
5347                                           gpinfop->g.got12,
5348                                           gpinfop->g.fd12,
5349                                           limit,
5350                                           gpinfop->g.tlsd12,
5351                                           tlslimit,
5352                                           (bfd_vma)1 << (12-1));
5353   odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos,
5354                                           gpinfop->got12.tmin,
5355                                           odd,
5356                                           gpinfop->got12.tmax,
5357                                           gpinfop->g.gotlos,
5358                                           gpinfop->g.fdlos,
5359                                           gpinfop->g.fdplt
5360                                           - gpinfop->got12.fdplt,
5361                                           gpinfop->g.tlsdlos,
5362                                           gpinfop->g.tlsdplt
5363                                           - gpinfop->got12.tlsdplt,
5364                                           (bfd_vma)1 << (16-1));
5365   odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo,
5366                                           gpinfop->gotlos.tmin,
5367                                           odd,
5368                                           gpinfop->gotlos.tmax,
5369                                           gpinfop->g.gothilo,
5370                                           gpinfop->g.fdhilo,
5371                                           gpinfop->g.fdplt
5372                                           - gpinfop->got12.fdplt
5373                                           - gpinfop->gotlos.fdplt,
5374                                           gpinfop->g.tlsdhilo,
5375                                           gpinfop->g.tlsdplt
5376                                           - gpinfop->got12.tlsdplt
5377                                           - gpinfop->gotlos.tlsdplt,
5378                                           (bfd_vma)1 << (32-1));
5379
5380   /* Now assign (most) GOT offsets.  */
5381   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
5382                  gpinfop);
5383
5384   frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax
5385     - gpinfop->gothilo.tmin
5386     /* If an odd word is the last word of the GOT, we don't need this
5387        word to be part of the GOT.  */
5388     - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0);
5389   if (frvfdpic_got_section (info)->size == 0)
5390     frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5391   else if (frvfdpic_got_section (info)->size == 12
5392            && ! elf_hash_table (info)->dynamic_sections_created)
5393     {
5394       frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5395       frvfdpic_got_section (info)->size = 0;
5396     }
5397   /* This will be non-NULL during relaxation.  The assumption is that
5398      the size of one of these sections will never grow, only shrink,
5399      so we can use the larger buffer we allocated before.  */
5400   else if (frvfdpic_got_section (info)->contents == NULL)
5401     {
5402       frvfdpic_got_section (info)->contents =
5403         (bfd_byte *) bfd_zalloc (dynobj,
5404                                  frvfdpic_got_section (info)->size);
5405       if (frvfdpic_got_section (info)->contents == NULL)
5406         return FALSE;
5407     }
5408
5409   if (frvfdpic_gotrel_section (info))
5410     /* Subtract the number of lzplt entries, since those will generate
5411        relocations in the pltrel section.  */
5412     frvfdpic_gotrel_section (info)->size =
5413       (gpinfop->g.relocs - gpinfop->g.lzplt / 8)
5414       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5415   else
5416     BFD_ASSERT (gpinfop->g.relocs == 0);
5417   if (frvfdpic_gotrel_section (info)->size == 0)
5418     frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
5419   else if (frvfdpic_gotrel_section (info)->contents == NULL)
5420     {
5421       frvfdpic_gotrel_section (info)->contents =
5422         (bfd_byte *) bfd_zalloc (dynobj,
5423                                  frvfdpic_gotrel_section (info)->size);
5424       if (frvfdpic_gotrel_section (info)->contents == NULL)
5425         return FALSE;
5426     }
5427
5428   frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
5429   if (frvfdpic_gotfixup_section (info)->size == 0)
5430     frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
5431   else if (frvfdpic_gotfixup_section (info)->contents == NULL)
5432     {
5433       frvfdpic_gotfixup_section (info)->contents =
5434         (bfd_byte *) bfd_zalloc (dynobj,
5435                                  frvfdpic_gotfixup_section (info)->size);
5436       if (frvfdpic_gotfixup_section (info)->contents == NULL)
5437         return FALSE;
5438     }
5439
5440   if (frvfdpic_pltrel_section (info))
5441     {
5442       frvfdpic_pltrel_section (info)->size =
5443         gpinfop->g.lzplt / 8
5444         * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5445       if (frvfdpic_pltrel_section (info)->size == 0)
5446         frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
5447       else if (frvfdpic_pltrel_section (info)->contents == NULL)
5448         {
5449           frvfdpic_pltrel_section (info)->contents =
5450             (bfd_byte *) bfd_zalloc (dynobj,
5451                                      frvfdpic_pltrel_section (info)->size);
5452           if (frvfdpic_pltrel_section (info)->contents == NULL)
5453             return FALSE;
5454         }
5455     }
5456
5457   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5458      such that there's room for the additional instruction needed to
5459      call the resolver.  Since _frvfdpic_assign_got_entries didn't
5460      account for them, our block size is 4 bytes smaller than the real
5461      block size.  */
5462   if (frvfdpic_plt_section (info))
5463     {
5464       frvfdpic_plt_section (info)->size = gpinfop->g.lzplt
5465         + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
5466            / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
5467     }
5468
5469   /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5470      actually assign lazy PLT entries addresses.  */
5471   gpinfop->g.lzplt = 0;
5472
5473   /* Save information that we're going to need to generate GOT and PLT
5474      entries.  */
5475   frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin;
5476
5477   if (get_elf_backend_data (output_bfd)->want_got_sym)
5478     elf_hash_table (info)->hgot->root.u.def.value
5479       = frvfdpic_got_initial_offset (info);
5480
5481   if (frvfdpic_plt_section (info))
5482     frvfdpic_plt_initial_offset (info) =
5483       frvfdpic_plt_section (info)->size;
5484
5485   /* Allocate a ret statement at plt_initial_offset, to be used by
5486      locally-resolved TLS descriptors.  */
5487   if (gpinfop->g.tls_ret_refs)
5488     frvfdpic_plt_section (info)->size += 4;
5489
5490   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
5491                  gpinfop);
5492
5493   /* Allocate the PLT section contents only after
5494      _frvfdpic_assign_plt_entries has a chance to add the size of the
5495      non-lazy PLT entries.  */
5496   if (frvfdpic_plt_section (info))
5497     {
5498       if (frvfdpic_plt_section (info)->size == 0)
5499         frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
5500       else if (frvfdpic_plt_section (info)->contents == NULL)
5501         {
5502           frvfdpic_plt_section (info)->contents =
5503             (bfd_byte *) bfd_zalloc (dynobj,
5504                                      frvfdpic_plt_section (info)->size);
5505           if (frvfdpic_plt_section (info)->contents == NULL)
5506             return FALSE;
5507         }
5508     }
5509
5510   return TRUE;
5511 }
5512
5513 /* Set the sizes of the dynamic sections.  */
5514
5515 static bfd_boolean
5516 elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
5517                                       struct bfd_link_info *info)
5518 {
5519   bfd *dynobj;
5520   asection *s;
5521   struct _frvfdpic_dynamic_got_plt_info gpinfo;
5522
5523   dynobj = elf_hash_table (info)->dynobj;
5524   BFD_ASSERT (dynobj != NULL);
5525
5526   if (elf_hash_table (info)->dynamic_sections_created)
5527     {
5528       /* Set the contents of the .interp section to the interpreter.  */
5529       if (info->executable)
5530         {
5531           s = bfd_get_section_by_name (dynobj, ".interp");
5532           BFD_ASSERT (s != NULL);
5533           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5534           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
5535         }
5536     }
5537
5538   memset (&gpinfo, 0, sizeof (gpinfo));
5539   gpinfo.g.info = info;
5540
5541   for (;;)
5542     {
5543       htab_t relocs = frvfdpic_relocs_info (info);
5544
5545       htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
5546
5547       if (relocs == frvfdpic_relocs_info (info))
5548         break;
5549     }
5550
5551   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
5552                  &gpinfo.g);
5553
5554   /* Allocate space to save the summary information, we're going to
5555      use it if we're doing relaxations.  */
5556   frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
5557
5558   if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo))
5559     return FALSE;
5560
5561   if (elf_hash_table (info)->dynamic_sections_created)
5562     {
5563       if (frvfdpic_got_section (info)->size)
5564         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
5565           return FALSE;
5566
5567       if (frvfdpic_pltrel_section (info)->size)
5568         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5569             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
5570             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5571           return FALSE;
5572
5573       if (frvfdpic_gotrel_section (info)->size)
5574         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
5575             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
5576             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
5577                                             sizeof (Elf32_External_Rel)))
5578           return FALSE;
5579     }
5580
5581   return TRUE;
5582 }
5583
5584 static bfd_boolean
5585 elf32_frvfdpic_always_size_sections (bfd *output_bfd,
5586                                      struct bfd_link_info *info)
5587 {
5588   if (!info->relocatable)
5589     {
5590       struct elf_link_hash_entry *h;
5591       asection *sec;
5592
5593       /* Force a PT_GNU_STACK segment to be created.  */
5594       if (! elf_tdata (output_bfd)->stack_flags)
5595         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5596
5597       /* Define __stacksize if it's not defined yet.  */
5598       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5599                                 FALSE, FALSE, FALSE);
5600       if (! h || h->root.type != bfd_link_hash_defined
5601           || h->type != STT_OBJECT
5602           || !h->def_regular)
5603         {
5604           struct bfd_link_hash_entry *bh = NULL;
5605
5606           if (!(_bfd_generic_link_add_one_symbol
5607                 (info, output_bfd, "__stacksize",
5608                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
5609                  (const char *) NULL, FALSE,
5610                  get_elf_backend_data (output_bfd)->collect, &bh)))
5611             return FALSE;
5612
5613           h = (struct elf_link_hash_entry *) bh;
5614           h->def_regular = 1;
5615           h->type = STT_OBJECT;
5616           /* This one must NOT be hidden.  */
5617         }
5618
5619       /* Create a stack section, and set its alignment.  */
5620       sec = bfd_make_section (output_bfd, ".stack");
5621
5622       if (sec == NULL
5623           || ! bfd_set_section_alignment (output_bfd, sec, 3))
5624         return FALSE;
5625     }
5626
5627   return TRUE;
5628 }
5629
5630 /* Look for opportunities to relax TLS relocations.  We can assume
5631    we're linking the main executable or a static-tls library, since
5632    otherwise we wouldn't have got here.  */
5633
5634 static int
5635 _frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_)
5636 {
5637   struct frvfdpic_relocs_info *entry = *entryp;
5638   struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
5639
5640   _frvfdpic_relax_tls_entries (entry, dinfo, TRUE);
5641
5642   return 1;
5643 }
5644
5645 static bfd_boolean
5646 elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
5647                               struct bfd_link_info *info, bfd_boolean *again)
5648 {
5649   struct _frvfdpic_dynamic_got_plt_info gpinfo;
5650
5651   /* If we return early, we didn't change anything.  */
5652   *again = FALSE;
5653
5654   /* We'll do our thing when requested to relax the GOT section.  */
5655   if (sec != frvfdpic_got_section (info))
5656     return TRUE;
5657
5658   /* We can only relax when linking the main executable or a library
5659      that can't be dlopened.  */
5660   if (! info->executable && ! (info->flags & DF_STATIC_TLS))
5661     return TRUE;
5662
5663   /* If there isn't a TLS section for this binary, we can't do
5664      anything about its TLS relocations (it probably doesn't have
5665      any.  */
5666   if (elf_hash_table (info)->tls_sec == NULL)
5667     return TRUE;
5668
5669   memset (&gpinfo, 0, sizeof (gpinfo));
5670   memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g));
5671
5672   /* Now look for opportunities to relax, adjusting the GOT usage
5673      as needed.  */
5674   htab_traverse (frvfdpic_relocs_info (info),
5675                  _frvfdpic_relax_got_plt_entries,
5676                  &gpinfo.g);
5677
5678   /* If we changed anything, reset and re-assign GOT and PLT entries.  */
5679   if (memcmp (frvfdpic_dynamic_got_plt_info (info),
5680               &gpinfo.g, sizeof (gpinfo.g)) != 0)
5681     {
5682       /* Clear GOT and PLT assignments.  */
5683       htab_traverse (frvfdpic_relocs_info (info),
5684                      _frvfdpic_reset_got_plt_entries,
5685                      NULL);
5686
5687       /* The owner of the TLS section is the output bfd.  There should
5688          be a better way to get to it.  */
5689       if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner,
5690                                    &gpinfo))
5691         return FALSE;
5692
5693       /* Repeat until we don't make any further changes.  We could fail to
5694          introduce changes in a round if, for example, the 12-bit range is
5695          full, but we later release some space by getting rid of TLS
5696          descriptors in it.  We have to repeat the whole process because
5697          we might have changed the size of a section processed before this
5698          one.  */
5699       *again = TRUE;
5700     }
5701
5702   return TRUE;
5703 }
5704
5705 static bfd_boolean
5706 elf32_frvfdpic_modify_segment_map (bfd *output_bfd,
5707                                    struct bfd_link_info *info)
5708 {
5709   struct elf_segment_map *m;
5710
5711   /* objcopy and strip preserve what's already there using
5712      elf32_frvfdpic_copy_private_bfd_data ().  */
5713   if (! info)
5714     return TRUE;
5715
5716   for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
5717     if (m->p_type == PT_GNU_STACK)
5718       break;
5719
5720   if (m)
5721     {
5722       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
5723       struct elf_link_hash_entry *h;
5724
5725       if (sec)
5726         {
5727           /* Obtain the pointer to the __stacksize symbol.  */
5728           h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5729                                     FALSE, FALSE, FALSE);
5730           while (h->root.type == bfd_link_hash_indirect
5731                  || h->root.type == bfd_link_hash_warning)
5732             h = (struct elf_link_hash_entry *)h->root.u.i.link;
5733           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5734
5735           /* Set the section size from the symbol value.  We
5736              intentionally ignore the symbol section.  */
5737           if (h->root.type == bfd_link_hash_defined)
5738             sec->size = h->root.u.def.value;
5739           else
5740             sec->size = DEFAULT_STACK_SIZE;
5741
5742           /* Add the stack section to the PT_GNU_STACK segment,
5743              such that its size and alignment requirements make it
5744              to the segment.  */
5745           m->sections[m->count] = sec;
5746           m->count++;
5747         }
5748     }
5749
5750   return TRUE;
5751 }
5752
5753 /* Fill in code and data in dynamic sections.  */
5754
5755 static bfd_boolean
5756 elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5757                                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
5758 {
5759   /* Nothing to be done for non-FDPIC.  */
5760   return TRUE;
5761 }
5762
5763 static bfd_boolean
5764 elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
5765                                         struct bfd_link_info *info)
5766 {
5767   bfd *dynobj;
5768   asection *sdyn;
5769
5770   dynobj = elf_hash_table (info)->dynobj;
5771
5772   if (frvfdpic_dynamic_got_plt_info (info))
5773     {
5774       BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0);
5775     }
5776   if (frvfdpic_got_section (info))
5777     {
5778       BFD_ASSERT (frvfdpic_gotrel_section (info)->size
5779                   == (frvfdpic_gotrel_section (info)->reloc_count
5780                       * sizeof (Elf32_External_Rel)));
5781
5782       if (frvfdpic_gotfixup_section (info))
5783         {
5784           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
5785           bfd_vma got_value = hgot->root.u.def.value
5786             + hgot->root.u.def.section->output_section->vma
5787             + hgot->root.u.def.section->output_offset;
5788           struct bfd_link_hash_entry *hend;
5789
5790           _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
5791                                  got_value, 0);
5792
5793           if (frvfdpic_gotfixup_section (info)->size
5794               != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
5795             {
5796             error:
5797               (*_bfd_error_handler)
5798                 ("LINKER BUG: .rofixup section size mismatch");
5799               return FALSE;
5800             }
5801
5802           hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
5803                                        FALSE, FALSE, TRUE);
5804           if (hend
5805               && (hend->type == bfd_link_hash_defined
5806                   || hend->type == bfd_link_hash_defweak))
5807             {
5808               bfd_vma value =
5809                 frvfdpic_gotfixup_section (info)->output_section->vma
5810                 + frvfdpic_gotfixup_section (info)->output_offset
5811                 + frvfdpic_gotfixup_section (info)->size
5812                 - hend->u.def.section->output_section->vma
5813                 - hend->u.def.section->output_offset;
5814               BFD_ASSERT (hend->u.def.value == value);
5815               if (hend->u.def.value != value)
5816                 goto error;
5817             }
5818         }
5819     }
5820   if (frvfdpic_pltrel_section (info))
5821     {
5822       BFD_ASSERT (frvfdpic_pltrel_section (info)->size
5823                   == (frvfdpic_pltrel_section (info)->reloc_count
5824                       * sizeof (Elf32_External_Rel)));
5825     }
5826
5827
5828   if (elf_hash_table (info)->dynamic_sections_created)
5829     {
5830       Elf32_External_Dyn * dyncon;
5831       Elf32_External_Dyn * dynconend;
5832
5833       sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5834
5835       BFD_ASSERT (sdyn != NULL);
5836
5837       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5838       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5839
5840       for (; dyncon < dynconend; dyncon++)
5841         {
5842           Elf_Internal_Dyn dyn;
5843
5844           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5845
5846           switch (dyn.d_tag)
5847             {
5848             default:
5849               break;
5850
5851             case DT_PLTGOT:
5852               dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
5853                 + frvfdpic_got_section (info)->output_offset
5854                 + frvfdpic_got_initial_offset (info);
5855               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5856               break;
5857
5858             case DT_JMPREL:
5859               dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
5860                 ->output_section->vma
5861                 + frvfdpic_pltrel_section (info)->output_offset;
5862               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5863               break;
5864
5865             case DT_PLTRELSZ:
5866               dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
5867               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5868               break;
5869             }
5870         }
5871     }
5872
5873   return TRUE;
5874 }
5875
5876 /* Adjust a symbol defined by a dynamic object and referenced by a
5877    regular object.  */
5878
5879 static bfd_boolean
5880 elf32_frvfdpic_adjust_dynamic_symbol
5881 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5882  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5883 {
5884   bfd * dynobj;
5885
5886   dynobj = elf_hash_table (info)->dynobj;
5887
5888   /* Make sure we know what is going on here.  */
5889   BFD_ASSERT (dynobj != NULL
5890               && (h->u.weakdef != NULL
5891                   || (h->def_dynamic
5892                       && h->ref_regular
5893                       && !h->def_regular)));
5894
5895   /* If this is a weak symbol, and there is a real definition, the
5896      processor independent code will have arranged for us to see the
5897      real definition first, and we can just use the same value.  */
5898   if (h->u.weakdef != NULL)
5899     {
5900       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5901                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5902       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5903       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5904     }
5905
5906   return TRUE;
5907 }
5908
5909 /* Perform any actions needed for dynamic symbols.  */
5910
5911 static bfd_boolean
5912 elf32_frvfdpic_finish_dynamic_symbol
5913 (bfd *output_bfd ATTRIBUTE_UNUSED,
5914  struct bfd_link_info *info ATTRIBUTE_UNUSED,
5915  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
5916  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
5917 {
5918   return TRUE;
5919 }
5920
5921 /* Decide whether to attempt to turn absptr or lsda encodings in
5922    shared libraries into pcrel within the given input section.  */
5923
5924 static bfd_boolean
5925 frvfdpic_elf_use_relative_eh_frame
5926 (bfd *input_bfd ATTRIBUTE_UNUSED,
5927  struct bfd_link_info *info ATTRIBUTE_UNUSED,
5928  asection *eh_frame_section ATTRIBUTE_UNUSED)
5929 {
5930   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
5931   return FALSE;
5932 }
5933
5934 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
5935
5936 static bfd_byte
5937 frvfdpic_elf_encode_eh_address (bfd *abfd,
5938                                 struct bfd_link_info *info,
5939                                 asection *osec, bfd_vma offset,
5940                                 asection *loc_sec, bfd_vma loc_offset,
5941                                 bfd_vma *encoded)
5942 {
5943   struct elf_link_hash_entry *h;
5944
5945   h = elf_hash_table (info)->hgot;
5946   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
5947
5948   if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
5949               == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
5950     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
5951                                        loc_sec, loc_offset, encoded);
5952
5953   BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
5954               == (_frvfdpic_osec_to_segment
5955                   (abfd, h->root.u.def.section->output_section)));
5956
5957   *encoded = osec->vma + offset
5958     - (h->root.u.def.value
5959        + h->root.u.def.section->output_section->vma
5960        + h->root.u.def.section->output_offset);
5961
5962   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
5963 }
5964
5965 /* Look through the relocs for a section during the first phase.
5966
5967    Besides handling virtual table relocs for gc, we have to deal with
5968    all sorts of PIC-related relocations.  We describe below the
5969    general plan on how to handle such relocations, even though we only
5970    collect information at this point, storing them in hash tables for
5971    perusal of later passes.
5972
5973    32 relocations are propagated to the linker output when creating
5974    position-independent output.  LO16 and HI16 relocations are not
5975    supposed to be encountered in this case.
5976
5977    LABEL16 should always be resolvable by the linker, since it's only
5978    used by branches.
5979
5980    LABEL24, on the other hand, is used by calls.  If it turns out that
5981    the target of a call is a dynamic symbol, a PLT entry must be
5982    created for it, which triggers the creation of a private function
5983    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
5984
5985    GPREL relocations require the referenced symbol to be in the same
5986    segment as _gp, but this can only be checked later.
5987
5988    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
5989    exist.  LABEL24 might as well, since it may require a PLT entry,
5990    that will require a got.
5991
5992    Non-FUNCDESC GOT relocations require a GOT entry to be created
5993    regardless of whether the symbol is dynamic.  However, since a
5994    global symbol that turns out to not be exported may have the same
5995    address of a non-dynamic symbol, we don't assign GOT entries at
5996    this point, such that we can share them in this case.  A relocation
5997    for the GOT entry always has to be created, be it to offset a
5998    private symbol by the section load address, be it to get the symbol
5999    resolved dynamically.
6000
6001    FUNCDESC GOT relocations require a GOT entry to be created, and
6002    handled as if a FUNCDESC relocation was applied to the GOT entry in
6003    an object file.
6004
6005    FUNCDESC relocations referencing a symbol that turns out to NOT be
6006    dynamic cause a private function descriptor to be created.  The
6007    FUNCDESC relocation then decays to a 32 relocation that points at
6008    the private descriptor.  If the symbol is dynamic, the FUNCDESC
6009    relocation is propagated to the linker output, such that the
6010    dynamic linker creates the canonical descriptor, pointing to the
6011    dynamically-resolved definition of the function.
6012
6013    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
6014    symbols that are assigned to the same segment as the GOT, but we
6015    can only check this later, after we know the complete set of
6016    symbols defined and/or exported.
6017
6018    FUNCDESC GOTOFF relocations require a function descriptor to be
6019    created and, unless lazy binding is disabled or the symbol is not
6020    dynamic, a lazy PLT entry.  Since we can't tell at this point
6021    whether a symbol is going to be dynamic, we have to decide later
6022    whether to create a lazy PLT entry or bind the descriptor directly
6023    to the private function.
6024
6025    FUNCDESC_VALUE relocations are not supposed to be present in object
6026    files, but they may very well be simply propagated to the linker
6027    output, since they have no side effect.
6028
6029
6030    A function descriptor always requires a FUNCDESC_VALUE relocation.
6031    Whether it's in .plt.rel or not depends on whether lazy binding is
6032    enabled and on whether the referenced symbol is dynamic.
6033
6034    The existence of a lazy PLT requires the resolverStub lazy PLT
6035    entry to be present.
6036
6037
6038    As for assignment of GOT, PLT and lazy PLT entries, and private
6039    descriptors, we might do them all sequentially, but we can do
6040    better than that.  For example, we can place GOT entries and
6041    private function descriptors referenced using 12-bit operands
6042    closer to the PIC register value, such that these relocations don't
6043    overflow.  Those that are only referenced with LO16 relocations
6044    could come next, but we may as well place PLT-required function
6045    descriptors in the 12-bit range to make them shorter.  Symbols
6046    referenced with LO16/HI16 may come next, but we may place
6047    additional function descriptors in the 16-bit range if we can
6048    reliably tell that we've already placed entries that are ever
6049    referenced with only LO16.  PLT entries are therefore generated as
6050    small as possible, while not introducing relocation overflows in
6051    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
6052    generated before or after PLT entries, but not intermingled with
6053    them, such that we can have more lazy PLT entries in range for a
6054    branch to the resolverStub.  The resolverStub should be emitted at
6055    the most distant location from the first lazy PLT entry such that
6056    it's still in range for a branch, or closer, if there isn't a need
6057    for so many lazy PLT entries.  Additional lazy PLT entries may be
6058    emitted after the resolverStub, as long as branches are still in
6059    range.  If the branch goes out of range, longer lazy PLT entries
6060    are emitted.
6061
6062    We could further optimize PLT and lazy PLT entries by giving them
6063    priority in assignment to closer-to-gr17 locations depending on the
6064    number of occurrences of references to them (assuming a function
6065    that's called more often is more important for performance, so its
6066    PLT entry should be faster), or taking hints from the compiler.
6067    Given infinite time and money... :-)  */
6068
6069 static bfd_boolean
6070 elf32_frv_check_relocs (abfd, info, sec, relocs)
6071      bfd *abfd;
6072      struct bfd_link_info *info;
6073      asection *sec;
6074      const Elf_Internal_Rela *relocs;
6075 {
6076   Elf_Internal_Shdr *symtab_hdr;
6077   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
6078   const Elf_Internal_Rela *rel;
6079   const Elf_Internal_Rela *rel_end;
6080   bfd *dynobj;
6081   struct frvfdpic_relocs_info *picrel;
6082
6083   if (info->relocatable)
6084     return TRUE;
6085
6086   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6087   sym_hashes = elf_sym_hashes (abfd);
6088   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
6089   if (!elf_bad_symtab (abfd))
6090     sym_hashes_end -= symtab_hdr->sh_info;
6091
6092   dynobj = elf_hash_table (info)->dynobj;
6093   rel_end = relocs + sec->reloc_count;
6094   for (rel = relocs; rel < rel_end; rel++)
6095     {
6096       struct elf_link_hash_entry *h;
6097       unsigned long r_symndx;
6098
6099       r_symndx = ELF32_R_SYM (rel->r_info);
6100       if (r_symndx < symtab_hdr->sh_info)
6101         h = NULL;
6102       else
6103         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6104
6105       switch (ELF32_R_TYPE (rel->r_info))
6106         {
6107         case R_FRV_GETTLSOFF:
6108         case R_FRV_TLSDESC_VALUE:
6109         case R_FRV_GOTTLSDESC12:
6110         case R_FRV_GOTTLSDESCHI:
6111         case R_FRV_GOTTLSDESCLO:
6112         case R_FRV_GOTTLSOFF12:
6113         case R_FRV_GOTTLSOFFHI:
6114         case R_FRV_GOTTLSOFFLO:
6115         case R_FRV_TLSOFF:
6116         case R_FRV_GOT12:
6117         case R_FRV_GOTHI:
6118         case R_FRV_GOTLO:
6119         case R_FRV_FUNCDESC_GOT12:
6120         case R_FRV_FUNCDESC_GOTHI:
6121         case R_FRV_FUNCDESC_GOTLO:
6122         case R_FRV_GOTOFF12:
6123         case R_FRV_GOTOFFHI:
6124         case R_FRV_GOTOFFLO:
6125         case R_FRV_FUNCDESC_GOTOFF12:
6126         case R_FRV_FUNCDESC_GOTOFFHI:
6127         case R_FRV_FUNCDESC_GOTOFFLO:
6128         case R_FRV_FUNCDESC:
6129         case R_FRV_FUNCDESC_VALUE:
6130         case R_FRV_TLSMOFF12:
6131         case R_FRV_TLSMOFFHI:
6132         case R_FRV_TLSMOFFLO:
6133         case R_FRV_TLSMOFF:
6134           if (! IS_FDPIC (abfd))
6135             goto bad_reloc;
6136           /* Fall through.  */
6137         case R_FRV_GPREL12:
6138         case R_FRV_GPRELU12:
6139         case R_FRV_GPRELHI:
6140         case R_FRV_GPRELLO:
6141         case R_FRV_LABEL24:
6142         case R_FRV_32:
6143           if (! dynobj)
6144             {
6145               elf_hash_table (info)->dynobj = dynobj = abfd;
6146               if (! _frv_create_got_section (abfd, info))
6147                 return FALSE;
6148             }
6149           if (! IS_FDPIC (abfd))
6150             {
6151               picrel = NULL;
6152               break;
6153             }
6154           if (h != NULL)
6155             {
6156               if (h->dynindx == -1)
6157                 switch (ELF_ST_VISIBILITY (h->other))
6158                   {
6159                   case STV_INTERNAL:
6160                   case STV_HIDDEN:
6161                     break;
6162                   default:
6163                     bfd_elf_link_record_dynamic_symbol (info, h);
6164                     break;
6165                   }
6166               picrel
6167                 = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
6168                                                    abfd, h,
6169                                                    rel->r_addend, INSERT);
6170             }
6171           else
6172             picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6173                                                      (info), abfd, r_symndx,
6174                                                      rel->r_addend, INSERT);
6175           if (! picrel)
6176             return FALSE;
6177           break;
6178
6179         default:
6180           picrel = NULL;
6181           break;
6182         }
6183
6184       switch (ELF32_R_TYPE (rel->r_info))
6185         {
6186         case R_FRV_LABEL24:
6187           if (IS_FDPIC (abfd))
6188             picrel->call = 1;
6189           break;
6190
6191         case R_FRV_FUNCDESC_VALUE:
6192           picrel->relocsfdv++;
6193           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6194             picrel->relocs32--;
6195           /* Fall through.  */
6196
6197         case R_FRV_32:
6198           if (! IS_FDPIC (abfd))
6199             break;
6200
6201           picrel->sym = 1;
6202           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6203             picrel->relocs32++;
6204           break;
6205
6206         case R_FRV_GOT12:
6207           picrel->got12 = 1;
6208           break;
6209
6210         case R_FRV_GOTHI:
6211         case R_FRV_GOTLO:
6212           picrel->gothilo = 1;
6213           break;
6214
6215         case R_FRV_FUNCDESC_GOT12:
6216           picrel->fdgot12 = 1;
6217           break;
6218
6219         case R_FRV_FUNCDESC_GOTHI:
6220         case R_FRV_FUNCDESC_GOTLO:
6221           picrel->fdgothilo = 1;
6222           break;
6223
6224         case R_FRV_GOTOFF12:
6225         case R_FRV_GOTOFFHI:
6226         case R_FRV_GOTOFFLO:
6227           picrel->gotoff = 1;
6228           break;
6229
6230         case R_FRV_FUNCDESC_GOTOFF12:
6231           picrel->fdgoff12 = 1;
6232           break;
6233
6234         case R_FRV_FUNCDESC_GOTOFFHI:
6235         case R_FRV_FUNCDESC_GOTOFFLO:
6236           picrel->fdgoffhilo = 1;
6237           break;
6238
6239         case R_FRV_FUNCDESC:
6240           picrel->fd = 1;
6241           picrel->relocsfd++;
6242           break;
6243
6244         case R_FRV_GETTLSOFF:
6245           picrel->tlsplt = 1;
6246           break;
6247
6248         case R_FRV_TLSDESC_VALUE:
6249           picrel->relocstlsd++;
6250           goto bad_reloc;
6251
6252         case R_FRV_GOTTLSDESC12:
6253           picrel->tlsdesc12 = 1;
6254           break;
6255
6256         case R_FRV_GOTTLSDESCHI:
6257         case R_FRV_GOTTLSDESCLO:
6258           picrel->tlsdeschilo = 1;
6259           break;
6260
6261         case R_FRV_TLSMOFF12:
6262         case R_FRV_TLSMOFFHI:
6263         case R_FRV_TLSMOFFLO:
6264         case R_FRV_TLSMOFF:
6265           break;
6266
6267         case R_FRV_GOTTLSOFF12:
6268           picrel->tlsoff12 = 1;
6269           info->flags |= DF_STATIC_TLS;
6270           break;
6271
6272         case R_FRV_GOTTLSOFFHI:
6273         case R_FRV_GOTTLSOFFLO:
6274           picrel->tlsoffhilo = 1;
6275           info->flags |= DF_STATIC_TLS;
6276           break;
6277
6278         case R_FRV_TLSOFF:
6279           picrel->relocstlsoff++;
6280           info->flags |= DF_STATIC_TLS;
6281           goto bad_reloc;
6282
6283         /* This relocation describes the C++ object vtable hierarchy.
6284            Reconstruct it for later use during GC.  */
6285         case R_FRV_GNU_VTINHERIT:
6286           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6287             return FALSE;
6288           break;
6289
6290         /* This relocation describes which C++ vtable entries are actually
6291            used.  Record for later use during GC.  */
6292         case R_FRV_GNU_VTENTRY:
6293           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6294             return FALSE;
6295           break;
6296
6297         case R_FRV_LABEL16:
6298         case R_FRV_LO16:
6299         case R_FRV_HI16:
6300         case R_FRV_GPREL12:
6301         case R_FRV_GPRELU12:
6302         case R_FRV_GPREL32:
6303         case R_FRV_GPRELHI:
6304         case R_FRV_GPRELLO:
6305         case R_FRV_TLSDESC_RELAX:
6306         case R_FRV_GETTLSOFF_RELAX:
6307         case R_FRV_TLSOFF_RELAX:
6308           break;
6309
6310         default:
6311         bad_reloc:
6312           (*_bfd_error_handler)
6313             (_("%B: unsupported relocation type %i"),
6314              abfd, ELF32_R_TYPE (rel->r_info));
6315           return FALSE;
6316         }
6317     }
6318
6319   return TRUE;
6320 }
6321
6322 \f
6323 /* Return the machine subcode from the ELF e_flags header.  */
6324
6325 static int
6326 elf32_frv_machine (abfd)
6327      bfd *abfd;
6328 {
6329   switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
6330     {
6331     default:                break;
6332     case EF_FRV_CPU_FR550:  return bfd_mach_fr550;
6333     case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
6334     case EF_FRV_CPU_FR450:  return bfd_mach_fr450;
6335     case EF_FRV_CPU_FR405:  return bfd_mach_fr400;
6336     case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
6337     case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
6338     case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
6339     case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
6340     }
6341
6342   return bfd_mach_frv;
6343 }
6344
6345 /* Set the right machine number for a FRV ELF file.  */
6346
6347 static bfd_boolean
6348 elf32_frv_object_p (abfd)
6349      bfd *abfd;
6350 {
6351   bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
6352   return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
6353           == (IS_FDPIC (abfd)));
6354 }
6355 \f
6356 /* Function to set the ELF flag bits.  */
6357
6358 static bfd_boolean
6359 frv_elf_set_private_flags (abfd, flags)
6360      bfd *abfd;
6361      flagword flags;
6362 {
6363   elf_elfheader (abfd)->e_flags = flags;
6364   elf_flags_init (abfd) = TRUE;
6365   return TRUE;
6366 }
6367
6368 /* Copy backend specific data from one object module to another.  */
6369
6370 static bfd_boolean
6371 frv_elf_copy_private_bfd_data (ibfd, obfd)
6372      bfd *ibfd;
6373      bfd *obfd;
6374 {
6375   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6376       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6377     return TRUE;
6378
6379   BFD_ASSERT (!elf_flags_init (obfd)
6380               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
6381
6382   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6383   elf_flags_init (obfd) = TRUE;
6384   return TRUE;
6385 }
6386
6387 /* Return true if the architecture described by elf header flag
6388    EXTENSION is an extension of the architecture described by BASE.  */
6389
6390 static bfd_boolean
6391 frv_elf_arch_extension_p (flagword base, flagword extension)
6392 {
6393   if (base == extension)
6394     return TRUE;
6395
6396   /* CPU_GENERIC code can be merged with code for a specific
6397      architecture, in which case the result is marked as being
6398      for the specific architecture.  Everything is therefore
6399      an extension of CPU_GENERIC.  */
6400   if (base == EF_FRV_CPU_GENERIC)
6401     return TRUE;
6402
6403   if (extension == EF_FRV_CPU_FR450)
6404     if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
6405       return TRUE;
6406
6407   if (extension == EF_FRV_CPU_FR405)
6408     if (base == EF_FRV_CPU_FR400)
6409       return TRUE;
6410
6411   return FALSE;
6412 }
6413
6414 static bfd_boolean
6415 elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6416 {
6417   unsigned i;
6418
6419   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6420       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6421     return TRUE;
6422
6423   if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
6424     return FALSE;
6425
6426   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
6427       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
6428     return TRUE;
6429
6430   /* Copy the stack size.  */
6431   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6432     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6433       {
6434         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6435
6436         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6437           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6438             {
6439               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6440
6441               /* Rewrite the phdrs, since we're only called after they
6442                  were first written.  */
6443               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
6444                             ->s->sizeof_ehdr, SEEK_SET) != 0
6445                   || get_elf_backend_data (obfd)->s
6446                   ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6447                                      elf_elfheader (obfd)->e_phnum) != 0)
6448                 return FALSE;
6449               break;
6450             }
6451
6452         break;
6453       }
6454
6455   return TRUE;
6456 }
6457
6458 /* Merge backend specific data from an object file to the output
6459    object file when linking.  */
6460
6461 static bfd_boolean
6462 frv_elf_merge_private_bfd_data (ibfd, obfd)
6463      bfd *ibfd;
6464      bfd *obfd;
6465 {
6466   flagword old_flags, old_partial;
6467   flagword new_flags, new_partial;
6468   bfd_boolean error = FALSE;
6469   char new_opt[80];
6470   char old_opt[80];
6471
6472   new_opt[0] = old_opt[0] = '\0';
6473   new_flags = elf_elfheader (ibfd)->e_flags;
6474   old_flags = elf_elfheader (obfd)->e_flags;
6475
6476   if (new_flags & EF_FRV_FDPIC)
6477     new_flags &= ~EF_FRV_PIC;
6478
6479 #ifdef DEBUG
6480   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
6481                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
6482                          bfd_get_filename (ibfd));
6483 #endif
6484
6485   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
6486     {
6487       elf_flags_init (obfd) = TRUE;
6488       old_flags = new_flags;
6489     }
6490
6491   else if (new_flags == old_flags)              /* Compatible flags are ok.  */
6492     ;
6493
6494   else                                          /* Possibly incompatible flags.  */
6495     {
6496       /* Warn if different # of gprs are used.  Note, 0 means nothing is
6497          said about the size of gprs.  */
6498       new_partial = (new_flags & EF_FRV_GPR_MASK);
6499       old_partial = (old_flags & EF_FRV_GPR_MASK);
6500       if (new_partial == old_partial)
6501         ;
6502
6503       else if (new_partial == 0)
6504         ;
6505
6506       else if (old_partial == 0)
6507         old_flags |= new_partial;
6508
6509       else
6510         {
6511           switch (new_partial)
6512             {
6513             default:            strcat (new_opt, " -mgpr-??"); break;
6514             case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
6515             case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
6516             }
6517
6518           switch (old_partial)
6519             {
6520             default:            strcat (old_opt, " -mgpr-??"); break;
6521             case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
6522             case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
6523             }
6524         }
6525
6526       /* Warn if different # of fprs are used.  Note, 0 means nothing is
6527          said about the size of fprs.  */
6528       new_partial = (new_flags & EF_FRV_FPR_MASK);
6529       old_partial = (old_flags & EF_FRV_FPR_MASK);
6530       if (new_partial == old_partial)
6531         ;
6532
6533       else if (new_partial == 0)
6534         ;
6535
6536       else if (old_partial == 0)
6537         old_flags |= new_partial;
6538
6539       else
6540         {
6541           switch (new_partial)
6542             {
6543             default:              strcat (new_opt, " -mfpr-?");      break;
6544             case EF_FRV_FPR_32:   strcat (new_opt, " -mfpr-32");     break;
6545             case EF_FRV_FPR_64:   strcat (new_opt, " -mfpr-64");     break;
6546             case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
6547             }
6548
6549           switch (old_partial)
6550             {
6551             default:              strcat (old_opt, " -mfpr-?");      break;
6552             case EF_FRV_FPR_32:   strcat (old_opt, " -mfpr-32");     break;
6553             case EF_FRV_FPR_64:   strcat (old_opt, " -mfpr-64");     break;
6554             case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
6555             }
6556         }
6557
6558       /* Warn if different dword support was used.  Note, 0 means nothing is
6559          said about the dword support.  */
6560       new_partial = (new_flags & EF_FRV_DWORD_MASK);
6561       old_partial = (old_flags & EF_FRV_DWORD_MASK);
6562       if (new_partial == old_partial)
6563         ;
6564
6565       else if (new_partial == 0)
6566         ;
6567
6568       else if (old_partial == 0)
6569         old_flags |= new_partial;
6570
6571       else
6572         {
6573           switch (new_partial)
6574             {
6575             default:               strcat (new_opt, " -mdword-?");  break;
6576             case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword");    break;
6577             case EF_FRV_DWORD_NO:  strcat (new_opt, " -mno-dword"); break;
6578             }
6579
6580           switch (old_partial)
6581             {
6582             default:               strcat (old_opt, " -mdword-?");  break;
6583             case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword");    break;
6584             case EF_FRV_DWORD_NO:  strcat (old_opt, " -mno-dword"); break;
6585             }
6586         }
6587
6588       /* Or in flags that accumulate (ie, if one module uses it, mark that the
6589          feature is used.  */
6590       old_flags |= new_flags & (EF_FRV_DOUBLE
6591                                 | EF_FRV_MEDIA
6592                                 | EF_FRV_MULADD
6593                                 | EF_FRV_NON_PIC_RELOCS);
6594
6595       /* If any module was compiled without -G0, clear the G0 bit.  */
6596       old_flags = ((old_flags & ~ EF_FRV_G0)
6597                    | (old_flags & new_flags & EF_FRV_G0));
6598
6599       /* If any module was compiled without -mnopack, clear the mnopack bit.  */
6600       old_flags = ((old_flags & ~ EF_FRV_NOPACK)
6601                    | (old_flags & new_flags & EF_FRV_NOPACK));
6602
6603       /* We don't have to do anything if the pic flags are the same, or the new
6604          module(s) were compiled with -mlibrary-pic.  */
6605       new_partial = (new_flags & EF_FRV_PIC_FLAGS);
6606       old_partial = (old_flags & EF_FRV_PIC_FLAGS);
6607       if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
6608         ;
6609
6610       /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
6611          flags if any from the new module.  */
6612       else if ((old_partial & EF_FRV_LIBPIC) != 0)
6613         old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
6614
6615       /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
6616       else if (new_partial != 0 && old_partial != 0)
6617         old_flags |= new_partial;
6618
6619       /* One module was compiled for pic and the other was not, see if we have
6620          had any relocations that are not pic-safe.  */
6621       else
6622         {
6623           if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
6624             old_flags |= new_partial;
6625           else
6626             {
6627               old_flags &= ~ EF_FRV_PIC_FLAGS;
6628 #ifndef FRV_NO_PIC_ERROR
6629               error = TRUE;
6630               (*_bfd_error_handler)
6631                 (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
6632                  bfd_get_filename (ibfd),
6633                  (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
6634 #endif
6635             }
6636         }
6637
6638       /* Warn if different cpu is used (allow a specific cpu to override
6639          the generic cpu).  */
6640       new_partial = (new_flags & EF_FRV_CPU_MASK);
6641       old_partial = (old_flags & EF_FRV_CPU_MASK);
6642       if (frv_elf_arch_extension_p (new_partial, old_partial))
6643         ;
6644
6645       else if (frv_elf_arch_extension_p (old_partial, new_partial))
6646         old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
6647
6648       else
6649         {
6650           switch (new_partial)
6651             {
6652             default:                 strcat (new_opt, " -mcpu=?");      break;
6653             case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
6654             case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
6655             case EF_FRV_CPU_FR550:   strcat (new_opt, " -mcpu=fr550");  break;
6656             case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
6657             case EF_FRV_CPU_FR450:   strcat (new_opt, " -mcpu=fr450");  break;
6658             case EF_FRV_CPU_FR405:   strcat (new_opt, " -mcpu=fr405");  break;
6659             case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
6660             case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
6661             case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
6662             }
6663
6664           switch (old_partial)
6665             {
6666             default:                 strcat (old_opt, " -mcpu=?");      break;
6667             case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
6668             case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
6669             case EF_FRV_CPU_FR550:   strcat (old_opt, " -mcpu=fr550");  break;
6670             case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
6671             case EF_FRV_CPU_FR450:   strcat (old_opt, " -mcpu=fr450");  break;
6672             case EF_FRV_CPU_FR405:   strcat (old_opt, " -mcpu=fr405");  break;
6673             case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
6674             case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
6675             case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
6676             }
6677         }
6678
6679       /* Print out any mismatches from above.  */
6680       if (new_opt[0])
6681         {
6682           error = TRUE;
6683           (*_bfd_error_handler)
6684             (_("%s: compiled with %s and linked with modules compiled with %s"),
6685              bfd_get_filename (ibfd), new_opt, old_opt);
6686         }
6687
6688       /* Warn about any other mismatches */
6689       new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
6690       old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
6691       if (new_partial != old_partial)
6692         {
6693           old_flags |= new_partial;
6694           error = TRUE;
6695           (*_bfd_error_handler)
6696             (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
6697              bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
6698         }
6699     }
6700
6701   /* If the cpu is -mcpu=simple, then set the -mnopack bit.  */
6702   if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
6703     old_flags |= EF_FRV_NOPACK;
6704
6705   /* Update the old flags now with changes made above.  */
6706   old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
6707   elf_elfheader (obfd)->e_flags = old_flags;
6708   if (old_partial != (old_flags & EF_FRV_CPU_MASK))
6709     bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
6710
6711   if (((new_flags & EF_FRV_FDPIC) == 0)
6712       != (! IS_FDPIC (ibfd)))
6713     {
6714       error = TRUE;
6715       if (IS_FDPIC (obfd))
6716         (*_bfd_error_handler)
6717           (_("%s: cannot link non-fdpic object file into fdpic executable"),
6718            bfd_get_filename (ibfd));
6719       else
6720         (*_bfd_error_handler)
6721           (_("%s: cannot link fdpic object file into non-fdpic executable"),
6722            bfd_get_filename (ibfd));
6723     }
6724
6725   if (error)
6726     bfd_set_error (bfd_error_bad_value);
6727
6728   return !error;
6729 }
6730
6731 \f
6732 bfd_boolean
6733 frv_elf_print_private_bfd_data (abfd, ptr)
6734      bfd *abfd;
6735      PTR ptr;
6736 {
6737   FILE *file = (FILE *) ptr;
6738   flagword flags;
6739
6740   BFD_ASSERT (abfd != NULL && ptr != NULL);
6741
6742   /* Print normal ELF private data.  */
6743   _bfd_elf_print_private_bfd_data (abfd, ptr);
6744
6745   flags = elf_elfheader (abfd)->e_flags;
6746   fprintf (file, _("private flags = 0x%lx:"), (long)flags);
6747
6748   switch (flags & EF_FRV_CPU_MASK)
6749     {
6750     default:                                                    break;
6751     case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;
6752     case EF_FRV_CPU_FR550:  fprintf (file, " -mcpu=fr550");     break;
6753     case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;
6754     case EF_FRV_CPU_FR450:  fprintf (file, " -mcpu=fr450");     break;
6755     case EF_FRV_CPU_FR405:  fprintf (file, " -mcpu=fr405");     break;
6756     case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;
6757     case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;
6758     case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;
6759     }
6760
6761   switch (flags & EF_FRV_GPR_MASK)
6762     {
6763     default:                                                    break;
6764     case EF_FRV_GPR_32: fprintf (file, " -mgpr-32");            break;
6765     case EF_FRV_GPR_64: fprintf (file, " -mgpr-64");            break;
6766     }
6767
6768   switch (flags & EF_FRV_FPR_MASK)
6769     {
6770     default:                                                    break;
6771     case EF_FRV_FPR_32:   fprintf (file, " -mfpr-32");          break;
6772     case EF_FRV_FPR_64:   fprintf (file, " -mfpr-64");          break;
6773     case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float");      break;
6774     }
6775
6776   switch (flags & EF_FRV_DWORD_MASK)
6777     {
6778     default:                                                    break;
6779     case EF_FRV_DWORD_YES: fprintf (file, " -mdword");          break;
6780     case EF_FRV_DWORD_NO:  fprintf (file, " -mno-dword");       break;
6781     }
6782
6783   if (flags & EF_FRV_DOUBLE)
6784     fprintf (file, " -mdouble");
6785
6786   if (flags & EF_FRV_MEDIA)
6787     fprintf (file, " -mmedia");
6788
6789   if (flags & EF_FRV_MULADD)
6790     fprintf (file, " -mmuladd");
6791
6792   if (flags & EF_FRV_PIC)
6793     fprintf (file, " -fpic");
6794
6795   if (flags & EF_FRV_BIGPIC)
6796     fprintf (file, " -fPIC");
6797
6798   if (flags & EF_FRV_LIBPIC)
6799     fprintf (file, " -mlibrary-pic");
6800
6801   if (flags & EF_FRV_FDPIC)
6802     fprintf (file, " -mfdpic");
6803
6804   if (flags & EF_FRV_NON_PIC_RELOCS)
6805     fprintf (file, " non-pic relocations");
6806
6807   if (flags & EF_FRV_G0)
6808     fprintf (file, " -G0");
6809
6810   fputc ('\n', file);
6811   return TRUE;
6812 }
6813
6814 \f
6815 #define ELF_ARCH                bfd_arch_frv
6816 #define ELF_MACHINE_CODE        EM_CYGNUS_FRV
6817 #define ELF_MAXPAGESIZE         0x1000
6818
6819 #define TARGET_BIG_SYM          bfd_elf32_frv_vec
6820 #define TARGET_BIG_NAME         "elf32-frv"
6821
6822 #define elf_info_to_howto                       frv_info_to_howto_rela
6823 #define elf_backend_relocate_section            elf32_frv_relocate_section
6824 #define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook
6825 #define elf_backend_gc_sweep_hook               elf32_frv_gc_sweep_hook
6826 #define elf_backend_check_relocs                elf32_frv_check_relocs
6827 #define elf_backend_object_p                    elf32_frv_object_p
6828 #define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
6829
6830 #define elf_backend_can_gc_sections             1
6831 #define elf_backend_rela_normal                 1
6832
6833 #define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup
6834 #define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags
6835 #define bfd_elf32_bfd_copy_private_bfd_data     frv_elf_copy_private_bfd_data
6836 #define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data
6837 #define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data
6838
6839 #define elf_backend_want_got_sym        1
6840 #define elf_backend_got_header_size     0
6841 #define elf_backend_want_got_plt        0
6842 #define elf_backend_plt_readonly        1
6843 #define elf_backend_want_plt_sym        0
6844 #define elf_backend_plt_header_size     0
6845
6846 #define elf_backend_finish_dynamic_sections \
6847                 elf32_frv_finish_dynamic_sections
6848
6849 #include "elf32-target.h"
6850
6851 #undef ELF_MAXPAGESIZE
6852 #define ELF_MAXPAGESIZE         0x4000
6853
6854 #undef TARGET_BIG_SYM
6855 #define TARGET_BIG_SYM          bfd_elf32_frvfdpic_vec
6856 #undef TARGET_BIG_NAME
6857 #define TARGET_BIG_NAME         "elf32-frvfdpic"
6858 #undef  elf32_bed
6859 #define elf32_bed               elf32_frvfdpic_bed
6860
6861 #undef elf_info_to_howto_rel
6862 #define elf_info_to_howto_rel   frvfdpic_info_to_howto_rel
6863
6864 #undef bfd_elf32_bfd_link_hash_table_create
6865 #define bfd_elf32_bfd_link_hash_table_create \
6866                 frvfdpic_elf_link_hash_table_create
6867 #undef elf_backend_always_size_sections
6868 #define elf_backend_always_size_sections \
6869                 elf32_frvfdpic_always_size_sections
6870 #undef elf_backend_modify_segment_map
6871 #define elf_backend_modify_segment_map \
6872                 elf32_frvfdpic_modify_segment_map
6873 #undef bfd_elf32_bfd_copy_private_bfd_data
6874 #define bfd_elf32_bfd_copy_private_bfd_data \
6875                 elf32_frvfdpic_copy_private_bfd_data
6876
6877 #undef elf_backend_create_dynamic_sections
6878 #define elf_backend_create_dynamic_sections \
6879                 elf32_frvfdpic_create_dynamic_sections
6880 #undef elf_backend_adjust_dynamic_symbol
6881 #define elf_backend_adjust_dynamic_symbol \
6882                 elf32_frvfdpic_adjust_dynamic_symbol
6883 #undef elf_backend_size_dynamic_sections
6884 #define elf_backend_size_dynamic_sections \
6885                 elf32_frvfdpic_size_dynamic_sections
6886 #undef bfd_elf32_bfd_relax_section
6887 #define bfd_elf32_bfd_relax_section \
6888   elf32_frvfdpic_relax_section
6889 #undef elf_backend_finish_dynamic_symbol
6890 #define elf_backend_finish_dynamic_symbol \
6891                 elf32_frvfdpic_finish_dynamic_symbol
6892 #undef elf_backend_finish_dynamic_sections
6893 #define elf_backend_finish_dynamic_sections \
6894                 elf32_frvfdpic_finish_dynamic_sections
6895
6896 #undef elf_backend_can_make_relative_eh_frame
6897 #define elf_backend_can_make_relative_eh_frame \
6898                 frvfdpic_elf_use_relative_eh_frame
6899 #undef elf_backend_can_make_lsda_relative_eh_frame
6900 #define elf_backend_can_make_lsda_relative_eh_frame \
6901                 frvfdpic_elf_use_relative_eh_frame
6902 #undef elf_backend_encode_eh_address
6903 #define elf_backend_encode_eh_address \
6904                 frvfdpic_elf_encode_eh_address
6905
6906 #undef elf_backend_may_use_rel_p
6907 #define elf_backend_may_use_rel_p       1
6908 #undef elf_backend_may_use_rela_p
6909 #define elf_backend_may_use_rela_p      1
6910 /* We use REL for dynamic relocations only.  */
6911 #undef elf_backend_default_use_rela_p
6912 #define elf_backend_default_use_rela_p  1
6913
6914 #undef elf_backend_omit_section_dynsym
6915 #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
6916
6917 #include "elf32-target.h"