bfd/elf32-frv.c

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