bfd/elf32-frv.c

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