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