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;
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           if (name == NULL || name[0] == 0)
2800             name = bfd_section_name (input_bfd, sec);
2801         }
2802       else
2803         {
2804           bfd_boolean warned;
2805           bfd_boolean unresolved_reloc;
2806
2807           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2808                                    r_symndx, symtab_hdr, sym_hashes,
2809                                    h, sec, relocation,
2810                                    unresolved_reloc, warned);
2811           osec = sec;
2812           name = h->root.root.string;
2813         }
2814
2815       if (sec != NULL && elf_discarded_section (sec))
2816         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2817                                          rel, relend, howto, contents);
2818
2819       if (info->relocatable)
2820         continue;
2821
2822       if (r_type != R_FRV_TLSMOFF
2823           && h != NULL
2824           && (h->root.type == bfd_link_hash_defined
2825               || h->root.type == bfd_link_hash_defweak)
2826           && !FRVFDPIC_SYM_LOCAL (info, h))
2827         {
2828           osec = sec = NULL;
2829           relocation = 0;
2830         }
2831
2832       switch (r_type)
2833         {
2834         case R_FRV_LABEL24:
2835         case R_FRV_32:
2836           if (! IS_FDPIC (output_bfd))
2837             goto non_fdpic;
2838
2839         case R_FRV_GOT12:
2840         case R_FRV_GOTHI:
2841         case R_FRV_GOTLO:
2842         case R_FRV_FUNCDESC_GOT12:
2843         case R_FRV_FUNCDESC_GOTHI:
2844         case R_FRV_FUNCDESC_GOTLO:
2845         case R_FRV_GOTOFF12:
2846         case R_FRV_GOTOFFHI:
2847         case R_FRV_GOTOFFLO:
2848         case R_FRV_FUNCDESC_GOTOFF12:
2849         case R_FRV_FUNCDESC_GOTOFFHI:
2850         case R_FRV_FUNCDESC_GOTOFFLO:
2851         case R_FRV_FUNCDESC:
2852         case R_FRV_FUNCDESC_VALUE:
2853         case R_FRV_GETTLSOFF:
2854         case R_FRV_TLSDESC_VALUE:
2855         case R_FRV_GOTTLSDESC12:
2856         case R_FRV_GOTTLSDESCHI:
2857         case R_FRV_GOTTLSDESCLO:
2858         case R_FRV_TLSMOFF12:
2859         case R_FRV_TLSMOFFHI:
2860         case R_FRV_TLSMOFFLO:
2861         case R_FRV_GOTTLSOFF12:
2862         case R_FRV_GOTTLSOFFHI:
2863         case R_FRV_GOTTLSOFFLO:
2864         case R_FRV_TLSOFF:
2865         case R_FRV_TLSDESC_RELAX:
2866         case R_FRV_GETTLSOFF_RELAX:
2867         case R_FRV_TLSOFF_RELAX:
2868         case R_FRV_TLSMOFF:
2869           if (h != NULL)
2870             picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info
2871                                                       (info), input_bfd, h,
2872                                                       orig_addend, INSERT);
2873           else
2874             /* In order to find the entry we created before, we must
2875                use the original addend, not the one that may have been
2876                modified by _bfd_elf_rela_local_sym().  */
2877             picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
2878                                                      (info), input_bfd, r_symndx,
2879                                                      orig_addend, INSERT);
2880           if (! picrel)
2881             return FALSE;
2882
2883           if (!_frvfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2884                                                       osec, sym,
2885                                                       rel->r_addend))
2886             {
2887               (*_bfd_error_handler)
2888                 (_("%B(%A+0x%x): relocation to `%s+%x' may have caused the error above"),
2889                  input_bfd, input_section, rel->r_offset, name, rel->r_addend);
2890               return FALSE;
2891             }
2892
2893           break;
2894
2895         default:
2896         non_fdpic:
2897           picrel = NULL;
2898           if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
2899             {
2900               info->callbacks->warning
2901                 (info, _("relocation references symbol not defined in the module"),
2902                  name, input_bfd, input_section, rel->r_offset);
2903               return FALSE;
2904             }
2905           break;
2906         }
2907
2908       switch (r_type)
2909         {
2910         case R_FRV_GETTLSOFF:
2911         case R_FRV_TLSDESC_VALUE:
2912         case R_FRV_GOTTLSDESC12:
2913         case R_FRV_GOTTLSDESCHI:
2914         case R_FRV_GOTTLSDESCLO:
2915         case R_FRV_TLSMOFF12:
2916         case R_FRV_TLSMOFFHI:
2917         case R_FRV_TLSMOFFLO:
2918         case R_FRV_GOTTLSOFF12:
2919         case R_FRV_GOTTLSOFFHI:
2920         case R_FRV_GOTTLSOFFLO:
2921         case R_FRV_TLSOFF:
2922         case R_FRV_TLSDESC_RELAX:
2923         case R_FRV_GETTLSOFF_RELAX:
2924         case R_FRV_TLSOFF_RELAX:
2925         case R_FRV_TLSMOFF:
2926           if (sec && (bfd_is_abs_section (sec) || bfd_is_und_section (sec)))
2927             relocation += tls_biased_base (info);
2928           break;
2929
2930         default:
2931           break;
2932         }
2933
2934       /* Try to apply TLS relaxations.  */
2935       if (1)
2936         switch (r_type)
2937           {
2938
2939 #define LOCAL_EXEC_P(info, picrel) \
2940   ((info)->executable \
2941    && (picrel->symndx != -1 || FRVFDPIC_SYM_LOCAL ((info), (picrel)->d.h)))
2942 #define INITIAL_EXEC_P(info, picrel) \
2943   (((info)->executable || (info)->flags & DF_STATIC_TLS) \
2944    && (picrel)->tlsoff_entry)
2945
2946 #define IN_RANGE_FOR_OFST12_P(value) \
2947   ((bfd_vma)((value) + 2048) < (bfd_vma)4096)
2948 #define IN_RANGE_FOR_SETLOS_P(value) \
2949   ((bfd_vma)((value) + 32768) < (bfd_vma)65536)
2950 #define TLSMOFF_IN_RANGE_FOR_SETLOS_P(value, info) \
2951   (IN_RANGE_FOR_SETLOS_P ((value) - tls_biased_base (info)))
2952
2953 #define RELAX_GETTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2954   (LOCAL_EXEC_P ((info), (picrel)) \
2955    && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2956 #define RELAX_GETTLSOFF_INITIAL_EXEC_P(info, picrel) \
2957   (INITIAL_EXEC_P ((info), (picrel)) \
2958    && IN_RANGE_FOR_OFST12_P ((picrel)->tlsoff_entry))
2959
2960 #define RELAX_TLSDESC_LOCAL_EXEC_P(info, picrel, value) \
2961   (LOCAL_EXEC_P ((info), (picrel)))
2962 #define RELAX_TLSDESC_INITIAL_EXEC_P(info, picrel) \
2963   (INITIAL_EXEC_P ((info), (picrel)))
2964
2965 #define RELAX_GOTTLSOFF_LOCAL_EXEC_P(info, picrel, value) \
2966   (LOCAL_EXEC_P ((info), (picrel)) \
2967    && TLSMOFF_IN_RANGE_FOR_SETLOS_P((value), (info)))
2968
2969           case R_FRV_GETTLSOFF:
2970             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
2971
2972             /* Is this a call instruction?  */
2973             if ((insn & (unsigned long)0x01fc0000) != 0x003c0000)
2974               {
2975                 r = info->callbacks->warning
2976                   (info,
2977                    _("R_FRV_GETTLSOFF not applied to a call instruction"),
2978                    name, input_bfd, input_section, rel->r_offset);
2979                 return FALSE;
2980               }
2981
2982             if (RELAX_GETTLSOFF_LOCAL_EXEC_P (info, picrel,
2983                                               relocation + rel->r_addend))
2984               {
2985                 /* Replace the call instruction (except the packing bit)
2986                    with setlos #tlsmofflo(symbol+offset), gr9.  */
2987                 insn &= (unsigned long)0x80000000;
2988                 insn |= (unsigned long)0x12fc0000;
2989                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
2990
2991                 r_type = R_FRV_TLSMOFFLO;
2992                 howto  = elf32_frv_howto_table + r_type;
2993                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
2994               }
2995
2996             else if (RELAX_GETTLSOFF_INITIAL_EXEC_P (info, picrel))
2997               {
2998                 /* Replace the call instruction (except the packing bit)
2999                    with ldi @(gr15, #gottlsoff12(symbol+addend)), gr9.  */
3000                 insn &= (unsigned long)0x80000000;
3001                 insn |= (unsigned long)0x12c8f000;
3002                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3003
3004                 r_type = R_FRV_GOTTLSOFF12;
3005                 howto  = elf32_frv_howto_table + r_type;
3006                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3007               }
3008
3009             break;
3010
3011           case R_FRV_GOTTLSDESC12:
3012             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3013
3014             /* Is this an lddi instruction?  */
3015             if ((insn & (unsigned long)0x01fc0000) != 0x00cc0000)
3016               {
3017                 r = info->callbacks->warning
3018                   (info,
3019                    _("R_FRV_GOTTLSDESC12 not applied to an lddi instruction"),
3020                    name, input_bfd, input_section, rel->r_offset);
3021                 return FALSE;
3022               }
3023
3024             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3025                                             relocation + rel->r_addend)
3026                 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3027                                                   info))
3028               {
3029                 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3030                    with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3031                    Preserve the packing bit.  */
3032                 insn = (insn & (unsigned long)0x80000000)
3033                   | ((insn + (unsigned long)0x02000000)
3034                      & (unsigned long)0x7e000000);
3035                 insn |= (unsigned long)0x00fc0000;
3036                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3037
3038                 r_type = R_FRV_TLSMOFFLO;
3039                 howto  = elf32_frv_howto_table + r_type;
3040                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3041               }
3042
3043             else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3044                                                  relocation + rel->r_addend))
3045               {
3046                 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3047                    with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3048                    Preserve the packing bit.  */
3049                 insn = (insn & (unsigned long)0x80000000)
3050                   | ((insn + (unsigned long)0x02000000)
3051                      & (unsigned long)0x7e000000);
3052                 insn |= (unsigned long)0x00f80000;
3053                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3054
3055                 r_type = R_FRV_TLSMOFFHI;
3056                 howto  = elf32_frv_howto_table + r_type;
3057                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3058               }
3059
3060             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3061               {
3062                 /* Replace lddi @(grB, #gottlsdesc12(symbol+offset), grC
3063                    with ldi @(grB, #gottlsoff12(symbol+offset),
3064                    gr<C+1>.  Preserve the packing bit.  If gottlsoff12
3065                    overflows, we'll error out, but that's sort-of ok,
3066                    since we'd started with gottlsdesc12, that's actually
3067                    more demanding.  Compiling with -fPIE instead of
3068                    -fpie would fix it; linking with --relax should fix
3069                    it as well.  */
3070                 insn = (insn & (unsigned long)0x80cbf000)
3071                   | ((insn + (unsigned long)0x02000000)
3072                      & (unsigned long)0x7e000000);
3073                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3074
3075                 r_type = R_FRV_GOTTLSOFF12;
3076                 howto  = elf32_frv_howto_table + r_type;
3077                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3078               }
3079
3080             break;
3081
3082           case R_FRV_GOTTLSDESCHI:
3083             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3084
3085             /* Is this a sethi instruction?  */
3086             if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3087               {
3088                 r = info->callbacks->warning
3089                   (info,
3090                    _("R_FRV_GOTTLSDESCHI not applied to a sethi instruction"),
3091                    name, input_bfd, input_section, rel->r_offset);
3092                 return FALSE;
3093               }
3094
3095             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3096                                             relocation + rel->r_addend)
3097                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3098                     && IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry)))
3099               {
3100                 /* Replace sethi with a nop.  Preserve the packing bit.  */
3101                 insn &= (unsigned long)0x80000000;
3102                 insn |= (unsigned long)0x00880000;
3103                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3104
3105                 /* Nothing to relocate.  */
3106                 continue;
3107               }
3108
3109             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3110               {
3111                 /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3112                 r_type = R_FRV_GOTTLSOFFHI;
3113                 howto  = elf32_frv_howto_table + r_type;
3114                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3115               }
3116
3117             break;
3118
3119           case R_FRV_GOTTLSDESCLO:
3120             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3121
3122             /* Is this a setlo or setlos instruction?  */
3123             if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3124               {
3125                 r = info->callbacks->warning
3126                   (info,
3127                    _("R_FRV_GOTTLSDESCLO"
3128                      " not applied to a setlo or setlos instruction"),
3129                    name, input_bfd, input_section, rel->r_offset);
3130                 return FALSE;
3131               }
3132
3133             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3134                                             relocation + rel->r_addend)
3135                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3136                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3137               {
3138                 /* Replace setlo/setlos with a nop.  Preserve the
3139                    packing bit.  */
3140                 insn &= (unsigned long)0x80000000;
3141                 insn |= (unsigned long)0x00880000;
3142                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3143
3144                 /* Nothing to relocate.  */
3145                 continue;
3146               }
3147
3148             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3149               {
3150                 /* If the corresponding sethi (if it exists) decayed
3151                    to a nop, make sure this becomes (or already is) a
3152                    setlos, not setlo.  */
3153                 if (IN_RANGE_FOR_SETLOS_P (picrel->tlsoff_entry))
3154                   {
3155                     insn |= (unsigned long)0x00080000;
3156                     bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3157                   }
3158
3159                 /* Simply decay GOTTLSDESC to GOTTLSOFF.  */
3160                 r_type = R_FRV_GOTTLSOFFLO;
3161                 howto  = elf32_frv_howto_table + r_type;
3162                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3163               }
3164
3165             break;
3166
3167           case R_FRV_TLSDESC_RELAX:
3168             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3169
3170             /* Is this an ldd instruction?  */
3171             if ((insn & (unsigned long)0x01fc0fc0) != 0x00080140)
3172               {
3173                 r = info->callbacks->warning
3174                   (info,
3175                    _("R_FRV_TLSDESC_RELAX not applied to an ldd instruction"),
3176                    name, input_bfd, input_section, rel->r_offset);
3177                 return FALSE;
3178               }
3179
3180             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3181                                             relocation + rel->r_addend)
3182                 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3183                                                   info))
3184               {
3185                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3186                    with setlos #tlsmofflo(symbol+offset), gr<C+1>.
3187                    Preserve the packing bit.  */
3188                 insn = (insn & (unsigned long)0x80000000)
3189                   | ((insn + (unsigned long)0x02000000)
3190                      & (unsigned long)0x7e000000);
3191                 insn |= (unsigned long)0x00fc0000;
3192                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3193
3194                 r_type = R_FRV_TLSMOFFLO;
3195                 howto  = elf32_frv_howto_table + r_type;
3196                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3197               }
3198
3199             else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3200                                                  relocation + rel->r_addend))
3201               {
3202                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3203                    with sethi #tlsmoffhi(symbol+offset), gr<C+1>.
3204                    Preserve the packing bit.  */
3205                 insn = (insn & (unsigned long)0x80000000)
3206                   | ((insn + (unsigned long)0x02000000)
3207                      & (unsigned long)0x7e000000);
3208                 insn |= (unsigned long)0x00f80000;
3209                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3210
3211                 r_type = R_FRV_TLSMOFFHI;
3212                 howto  = elf32_frv_howto_table + r_type;
3213                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3214               }
3215
3216             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3217                      && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3218               {
3219                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3220                    with ldi @(grB, #gottlsoff12(symbol+offset), gr<C+1>.
3221                    Preserve the packing bit.  */
3222                 insn = (insn & (unsigned long)0x8003f000)
3223                   | (unsigned long)0x00c80000
3224                   | ((insn + (unsigned long)0x02000000)
3225                      & (unsigned long)0x7e000000);
3226                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3227
3228                 r_type = R_FRV_GOTTLSOFF12;
3229                 howto  = elf32_frv_howto_table + r_type;
3230                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3231               }
3232
3233             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3234               {
3235                 /* Replace ldd #tlsdesc(symbol+offset)@(grB, grA), grC
3236                    with ld #tlsoff(symbol+offset)@(grB, grA), gr<C+1>.
3237                    Preserve the packing bit.  */
3238                 insn = (insn & (unsigned long)0x81ffffbf)
3239                   | ((insn + (unsigned long)0x02000000)
3240                      & (unsigned long)0x7e000000);
3241                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3242
3243                 /* #tlsoff(symbol+offset) is just a relaxation
3244                     annotation, so there's nothing left to
3245                     relocate.  */
3246                 continue;
3247               }
3248
3249             break;
3250
3251           case R_FRV_GETTLSOFF_RELAX:
3252             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3253
3254             /* Is this a calll or callil instruction?  */
3255             if ((insn & (unsigned long)0x7ff80fc0) != 0x02300000)
3256               {
3257                 r = info->callbacks->warning
3258                   (info,
3259                    _("R_FRV_GETTLSOFF_RELAX"
3260                      " not applied to a calll instruction"),
3261                    name, input_bfd, input_section, rel->r_offset);
3262                 return FALSE;
3263               }
3264
3265             if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3266                                             relocation + rel->r_addend)
3267                 && TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3268                                                   info))
3269               {
3270                 /* Replace calll with a nop.  Preserve the packing bit.  */
3271                 insn &= (unsigned long)0x80000000;
3272                 insn |= (unsigned long)0x00880000;
3273                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3274
3275                 /* Nothing to relocate.  */
3276                 continue;
3277               }
3278
3279             else if (RELAX_TLSDESC_LOCAL_EXEC_P (info, picrel,
3280                                                  relocation + rel->r_addend))
3281               {
3282                 /* Replace calll with setlo #tlsmofflo(symbol+offset), gr9.
3283                    Preserve the packing bit.  */
3284                 insn &= (unsigned long)0x80000000;
3285                 insn |= (unsigned long)0x12f40000;
3286                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3287
3288                 r_type = R_FRV_TLSMOFFLO;
3289                 howto  = elf32_frv_howto_table + r_type;
3290                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3291               }
3292
3293             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel))
3294               {
3295                 /* Replace calll with a nop.  Preserve the packing bit.  */
3296                 insn &= (unsigned long)0x80000000;
3297                 insn |= (unsigned long)0x00880000;
3298                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3299
3300                 /* Nothing to relocate.  */
3301                 continue;
3302               }
3303
3304             break;
3305
3306           case R_FRV_GOTTLSOFF12:
3307             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3308
3309             /* Is this an ldi instruction?  */
3310             if ((insn & (unsigned long)0x01fc0000) != 0x00c80000)
3311               {
3312                 r = info->callbacks->warning
3313                   (info,
3314                    _("R_FRV_GOTTLSOFF12 not applied to an ldi instruction"),
3315                    name, input_bfd, input_section, rel->r_offset);
3316                 return FALSE;
3317               }
3318
3319             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3320                                               relocation + rel->r_addend))
3321               {
3322                 /* Replace ldi @(grB, #gottlsoff12(symbol+offset), grC
3323                    with setlos #tlsmofflo(symbol+offset), grC.
3324                    Preserve the packing bit.  */
3325                 insn &= (unsigned long)0xfe000000;
3326                 insn |= (unsigned long)0x00fc0000;
3327                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3328
3329                 r_type = R_FRV_TLSMOFFLO;
3330                 howto  = elf32_frv_howto_table + r_type;
3331                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3332               }
3333
3334             break;
3335
3336           case R_FRV_GOTTLSOFFHI:
3337             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3338
3339             /* Is this a sethi instruction?  */
3340             if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3341               {
3342                 r = info->callbacks->warning
3343                   (info,
3344                    _("R_FRV_GOTTLSOFFHI not applied to a sethi instruction"),
3345                    name, input_bfd, input_section, rel->r_offset);
3346                 return FALSE;
3347               }
3348
3349             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3350                                               relocation + rel->r_addend)
3351                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3352                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3353               {
3354                 /* Replace sethi with a nop.  Preserve the packing bit.  */
3355                 insn &= (unsigned long)0x80000000;
3356                 insn |= (unsigned long)0x00880000;
3357                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3358
3359                 /* Nothing to relocate.  */
3360                 continue;
3361               }
3362
3363             break;
3364
3365           case R_FRV_GOTTLSOFFLO:
3366             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3367
3368             /* Is this a setlo or setlos instruction?  */
3369             if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3370               {
3371                 r = info->callbacks->warning
3372                   (info,
3373                    _("R_FRV_GOTTLSOFFLO"
3374                      " not applied to a setlo or setlos instruction"),
3375                    name, input_bfd, input_section, rel->r_offset);
3376                 return FALSE;
3377               }
3378
3379             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3380                                               relocation + rel->r_addend)
3381                 || (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3382                     && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry)))
3383               {
3384                 /* Replace setlo/setlos with a nop.  Preserve the
3385                    packing bit.  */
3386                 insn &= (unsigned long)0x80000000;
3387                 insn |= (unsigned long)0x00880000;
3388                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3389
3390                 /* Nothing to relocate.  */
3391                 continue;
3392               }
3393
3394             break;
3395
3396           case R_FRV_TLSOFF_RELAX:
3397             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3398
3399             /* Is this an ld instruction?  */
3400             if ((insn & (unsigned long)0x01fc0fc0) != 0x00080100)
3401               {
3402                 r = info->callbacks->warning
3403                   (info,
3404                    _("R_FRV_TLSOFF_RELAX not applied to an ld instruction"),
3405                    name, input_bfd, input_section, rel->r_offset);
3406                 return FALSE;
3407               }
3408
3409             if (RELAX_GOTTLSOFF_LOCAL_EXEC_P (info, picrel,
3410                                               relocation + rel->r_addend))
3411               {
3412                 /* Replace ld #gottlsoff(symbol+offset)@(grB, grA), grC
3413                    with setlos #tlsmofflo(symbol+offset), grC.
3414                    Preserve the packing bit.  */
3415                 insn &= (unsigned long)0xfe000000;
3416                 insn |= (unsigned long)0x00fc0000;
3417                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3418
3419                 r_type = R_FRV_TLSMOFFLO;
3420                 howto  = elf32_frv_howto_table + r_type;
3421                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3422               }
3423
3424             else if (RELAX_TLSDESC_INITIAL_EXEC_P (info, picrel)
3425                      && IN_RANGE_FOR_OFST12_P (picrel->tlsoff_entry))
3426               {
3427                 /* Replace ld #tlsoff(symbol+offset)@(grB, grA), grC
3428                    with ldi @(grB, #gottlsoff12(symbol+offset), grC.
3429                    Preserve the packing bit.  */
3430                 insn = (insn & (unsigned long)0xfe03f000)
3431                   | (unsigned long)0x00c80000;;
3432                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3433
3434                 r_type = R_FRV_GOTTLSOFF12;
3435                 howto  = elf32_frv_howto_table + r_type;
3436                 rel->r_info = ELF32_R_INFO (r_symndx, r_type);
3437               }
3438
3439             break;
3440
3441           case R_FRV_TLSMOFFHI:
3442             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3443
3444             /* Is this a sethi instruction?  */
3445             if ((insn & (unsigned long)0x01ff0000) != 0x00f80000)
3446               {
3447                 r = info->callbacks->warning
3448                   (info,
3449                    _("R_FRV_TLSMOFFHI not applied to a sethi instruction"),
3450                    name, input_bfd, input_section, rel->r_offset);
3451                 return FALSE;
3452               }
3453
3454             if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3455                                                info))
3456               {
3457                 /* Replace sethi with a nop.  Preserve the packing bit.  */
3458                 insn &= (unsigned long)0x80000000;
3459                 insn |= (unsigned long)0x00880000;
3460                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3461
3462                 /* Nothing to relocate.  */
3463                 continue;
3464               }
3465
3466             break;
3467
3468           case R_FRV_TLSMOFFLO:
3469             insn = bfd_get_32 (input_bfd, contents + rel->r_offset);
3470
3471             /* Is this a setlo or setlos instruction?  */
3472             if ((insn & (unsigned long)0x01f70000) != 0x00f40000)
3473               {
3474                 r = info->callbacks->warning
3475                   (info,
3476                    _("R_FRV_TLSMOFFLO"
3477                      " not applied to a setlo or setlos instruction"),
3478                    name, input_bfd, input_section, rel->r_offset);
3479                 return FALSE;
3480               }
3481
3482             if (TLSMOFF_IN_RANGE_FOR_SETLOS_P (relocation + rel->r_addend,
3483                                                info))
3484               /* If the corresponding sethi (if it exists) decayed
3485                  to a nop, make sure this becomes (or already is) a
3486                  setlos, not setlo.  */
3487               {
3488                 insn |= (unsigned long)0x00080000;
3489                 bfd_put_32 (input_bfd, insn, contents + rel->r_offset);
3490               }
3491
3492             break;
3493
3494             /*
3495               There's nothing to relax in these:
3496                 R_FRV_TLSDESC_VALUE
3497                 R_FRV_TLSOFF
3498                 R_FRV_TLSMOFF12
3499                 R_FRV_TLSMOFFHI
3500                 R_FRV_TLSMOFFLO
3501                 R_FRV_TLSMOFF
3502             */
3503
3504           default:
3505             break;
3506           }
3507
3508       switch (r_type)
3509         {
3510         case R_FRV_LABEL24:
3511           check_segment[0] = isec_segment;
3512           if (! IS_FDPIC (output_bfd))
3513             check_segment[1] = isec_segment;
3514           else if (picrel->plt)
3515             {
3516               relocation = frvfdpic_plt_section (info)->output_section->vma
3517                 + frvfdpic_plt_section (info)->output_offset
3518                 + picrel->plt_entry;
3519               check_segment[1] = plt_segment;
3520             }
3521           /* We don't want to warn on calls to undefined weak symbols,
3522              as calls to them must be protected by non-NULL tests
3523              anyway, and unprotected calls would invoke undefined
3524              behavior.  */
3525           else if (picrel->symndx == -1
3526                    && picrel->d.h->root.type == bfd_link_hash_undefweak)
3527             check_segment[1] = check_segment[0];
3528           else
3529             check_segment[1] = sec
3530               ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3531               : (unsigned)-1;
3532           break;
3533
3534         case R_FRV_GOT12:
3535         case R_FRV_GOTHI:
3536         case R_FRV_GOTLO:
3537           relocation = picrel->got_entry;
3538           check_segment[0] = check_segment[1] = got_segment;
3539           break;
3540
3541         case R_FRV_FUNCDESC_GOT12:
3542         case R_FRV_FUNCDESC_GOTHI:
3543         case R_FRV_FUNCDESC_GOTLO:
3544           relocation = picrel->fdgot_entry;
3545           check_segment[0] = check_segment[1] = got_segment;
3546           break;
3547
3548         case R_FRV_GOTOFFHI:
3549         case R_FRV_GOTOFF12:
3550         case R_FRV_GOTOFFLO:
3551           relocation -= frvfdpic_got_section (info)->output_section->vma
3552             + frvfdpic_got_section (info)->output_offset
3553             + frvfdpic_got_initial_offset (info);
3554           check_segment[0] = got_segment;
3555           check_segment[1] = sec
3556             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3557             : (unsigned)-1;
3558           break;
3559
3560         case R_FRV_FUNCDESC_GOTOFF12:
3561         case R_FRV_FUNCDESC_GOTOFFHI:
3562         case R_FRV_FUNCDESC_GOTOFFLO:
3563           relocation = picrel->fd_entry;
3564           check_segment[0] = check_segment[1] = got_segment;
3565           break;
3566
3567         case R_FRV_FUNCDESC:
3568           {
3569             int dynindx;
3570             bfd_vma addend = rel->r_addend;
3571
3572             if (! (h && h->root.type == bfd_link_hash_undefweak
3573                    && FRVFDPIC_SYM_LOCAL (info, h)))
3574               {
3575                 /* If the symbol is dynamic and there may be dynamic
3576                    symbol resolution because we are or are linked with a
3577                    shared library, emit a FUNCDESC relocation such that
3578                    the dynamic linker will allocate the function
3579                    descriptor.  If the symbol needs a non-local function
3580                    descriptor but binds locally (e.g., its visibility is
3581                    protected, emit a dynamic relocation decayed to
3582                    section+offset.  */
3583                 if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h)
3584                     && FRVFDPIC_SYM_LOCAL (info, h)
3585                     && !(info->executable && !info->pie))
3586                   {
3587                     dynindx = elf_section_data (h->root.u.def.section
3588                                                 ->output_section)->dynindx;
3589                     addend += h->root.u.def.section->output_offset
3590                       + h->root.u.def.value;
3591                   }
3592                 else if (h && ! FRVFDPIC_FUNCDESC_LOCAL (info, h))
3593                   {
3594                     if (addend)
3595                       {
3596                         info->callbacks->warning
3597                           (info, _("R_FRV_FUNCDESC references dynamic symbol with nonzero addend"),
3598                            name, input_bfd, input_section, rel->r_offset);
3599                         return FALSE;
3600                       }
3601                     dynindx = h->dynindx;
3602                   }
3603                 else
3604                   {
3605                     /* Otherwise, we know we have a private function
3606                        descriptor, so reference it directly.  */
3607                     BFD_ASSERT (picrel->privfd);
3608                     r_type = R_FRV_32;
3609                     dynindx = elf_section_data (frvfdpic_got_section (info)
3610                                                 ->output_section)->dynindx;
3611                     addend = frvfdpic_got_section (info)->output_offset
3612                       + frvfdpic_got_initial_offset (info)
3613                       + picrel->fd_entry;
3614                   }
3615
3616                 /* If there is room for dynamic symbol resolution, emit
3617                    the dynamic relocation.  However, if we're linking an
3618                    executable at a fixed location, we won't have emitted a
3619                    dynamic symbol entry for the got section, so idx will
3620                    be zero, which means we can and should compute the
3621                    address of the private descriptor ourselves.  */
3622                 if (info->executable && !info->pie
3623                     && (!h || FRVFDPIC_FUNCDESC_LOCAL (info, h)))
3624                   {
3625                     addend += frvfdpic_got_section (info)->output_section->vma;
3626                     if ((bfd_get_section_flags (output_bfd,
3627                                                 input_section->output_section)
3628                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3629                       {
3630                         bfd_vma offset;
3631
3632                         if (_frvfdpic_osec_readonly_p (output_bfd,
3633                                                        input_section
3634                                                        ->output_section))
3635                           {
3636                             info->callbacks->warning
3637                               (info,
3638                                _("cannot emit fixups in read-only section"),
3639                                name, input_bfd, input_section, rel->r_offset);
3640                             return FALSE;
3641                           }
3642
3643                         offset = _bfd_elf_section_offset
3644                           (output_bfd, info,
3645                            input_section, rel->r_offset);
3646
3647                         if (offset != (bfd_vma)-1)
3648                           _frvfdpic_add_rofixup (output_bfd,
3649                                                  frvfdpic_gotfixup_section
3650                                                  (info),
3651                                                  offset + input_section
3652                                                  ->output_section->vma
3653                                                  + input_section->output_offset,
3654                                                  picrel);
3655                       }
3656                   }
3657                 else if ((bfd_get_section_flags (output_bfd,
3658                                                  input_section->output_section)
3659                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3660                   {
3661                     bfd_vma offset;
3662
3663                     if (_frvfdpic_osec_readonly_p (output_bfd,
3664                                                    input_section
3665                                                    ->output_section))
3666                       {
3667                         info->callbacks->warning
3668                           (info,
3669                            _("cannot emit dynamic relocations in read-only section"),
3670                            name, input_bfd, input_section, rel->r_offset);
3671                         return FALSE;
3672                       }
3673
3674                     offset = _bfd_elf_section_offset
3675                       (output_bfd, info,
3676                        input_section, rel->r_offset);
3677
3678                     if (offset != (bfd_vma)-1)
3679                       _frvfdpic_add_dyn_reloc (output_bfd,
3680                                                frvfdpic_gotrel_section (info),
3681                                                offset + input_section
3682                                                ->output_section->vma
3683                                                + input_section->output_offset,
3684                                                r_type, dynindx, addend, picrel);
3685                   }
3686                 else
3687                   addend += frvfdpic_got_section (info)->output_section->vma;
3688               }
3689
3690             /* We want the addend in-place because dynamic
3691                relocations are REL.  Setting relocation to it should
3692                arrange for it to be installed.  */
3693             relocation = addend - rel->r_addend;
3694           }
3695           check_segment[0] = check_segment[1] = got_segment;
3696           break;
3697
3698         case R_FRV_32:
3699           if (! IS_FDPIC (output_bfd))
3700             {
3701               check_segment[0] = check_segment[1] = -1;
3702               break;
3703             }
3704           /* Fall through.  */
3705         case R_FRV_FUNCDESC_VALUE:
3706           {
3707             int dynindx;
3708             bfd_vma addend = rel->r_addend;
3709
3710             /* If the symbol is dynamic but binds locally, use
3711                section+offset.  */
3712             if (h && ! FRVFDPIC_SYM_LOCAL (info, h))
3713               {
3714                 if (addend && r_type == R_FRV_FUNCDESC_VALUE)
3715                   {
3716                     info->callbacks->warning
3717                       (info, _("R_FRV_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
3718                        name, input_bfd, input_section, rel->r_offset);
3719                     return FALSE;
3720                   }
3721                 dynindx = h->dynindx;
3722               }
3723             else
3724               {
3725                 if (h)
3726                   addend += h->root.u.def.value;
3727                 else
3728                   addend += sym->st_value;
3729                 if (osec)
3730                   addend += osec->output_offset;
3731                 if (osec && osec->output_section
3732                     && ! bfd_is_abs_section (osec->output_section)
3733                     && ! bfd_is_und_section (osec->output_section))
3734                   dynindx = elf_section_data (osec->output_section)->dynindx;
3735                 else
3736                   dynindx = 0;
3737               }
3738
3739             /* If we're linking an executable at a fixed address, we
3740                can omit the dynamic relocation as long as the symbol
3741                is defined in the current link unit (which is implied
3742                by its output section not being NULL).  */
3743             if (info->executable && !info->pie
3744                 && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3745               {
3746                 if (osec)
3747                   addend += osec->output_section->vma;
3748                 if (IS_FDPIC (input_bfd)
3749                     && (bfd_get_section_flags (output_bfd,
3750                                                input_section->output_section)
3751                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3752                   {
3753                     if (_frvfdpic_osec_readonly_p (output_bfd,
3754                                                    input_section
3755                                                    ->output_section))
3756                       {
3757                         info->callbacks->warning
3758                           (info,
3759                            _("cannot emit fixups in read-only section"),
3760                            name, input_bfd, input_section, rel->r_offset);
3761                         return FALSE;
3762                       }
3763                     if (!h || h->root.type != bfd_link_hash_undefweak)
3764                       {
3765                         bfd_vma offset = _bfd_elf_section_offset
3766                           (output_bfd, info,
3767                            input_section, rel->r_offset);
3768
3769                         if (offset != (bfd_vma)-1)
3770                           {
3771                             _frvfdpic_add_rofixup (output_bfd,
3772                                                    frvfdpic_gotfixup_section
3773                                                    (info),
3774                                                    offset + input_section
3775                                                    ->output_section->vma
3776                                                    + input_section->output_offset,
3777                                                    picrel);
3778                             if (r_type == R_FRV_FUNCDESC_VALUE)
3779                               _frvfdpic_add_rofixup
3780                                 (output_bfd,
3781                                  frvfdpic_gotfixup_section (info),
3782                                  offset
3783                                  + input_section->output_section->vma
3784                                  + input_section->output_offset + 4, picrel);
3785                           }
3786                       }
3787                   }
3788               }
3789             else
3790               {
3791                 if ((bfd_get_section_flags (output_bfd,
3792                                             input_section->output_section)
3793                      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3794                   {
3795                     bfd_vma offset;
3796
3797                     if (_frvfdpic_osec_readonly_p (output_bfd,
3798                                                    input_section
3799                                                    ->output_section))
3800                       {
3801                         info->callbacks->warning
3802                           (info,
3803                            _("cannot emit dynamic relocations in read-only section"),
3804                            name, input_bfd, input_section, rel->r_offset);
3805                         return FALSE;
3806                       }
3807
3808                     offset = _bfd_elf_section_offset
3809                       (output_bfd, info,
3810                        input_section, rel->r_offset);
3811
3812                     if (offset != (bfd_vma)-1)
3813                       _frvfdpic_add_dyn_reloc (output_bfd,
3814                                                frvfdpic_gotrel_section (info),
3815                                                offset + input_section
3816                                                ->output_section->vma
3817                                                + input_section->output_offset,
3818                                                r_type, dynindx, addend, picrel);
3819                   }
3820                 else if (osec)
3821                   addend += osec->output_section->vma;
3822                 /* We want the addend in-place because dynamic
3823                    relocations are REL.  Setting relocation to it
3824                    should arrange for it to be installed.  */
3825                 relocation = addend - rel->r_addend;
3826               }
3827
3828             if (r_type == R_FRV_FUNCDESC_VALUE)
3829               {
3830                 /* If we've omitted the dynamic relocation, just emit
3831                    the fixed addresses of the symbol and of the local
3832                    GOT base offset.  */
3833                 if (info->executable && !info->pie
3834                     && (!h || FRVFDPIC_SYM_LOCAL (info, h)))
3835                   bfd_put_32 (output_bfd,
3836                               frvfdpic_got_section (info)->output_section->vma
3837                               + frvfdpic_got_section (info)->output_offset
3838                               + frvfdpic_got_initial_offset (info),
3839                               contents + rel->r_offset + 4);
3840                 else
3841                   /* A function descriptor used for lazy or local
3842                      resolving is initialized such that its high word
3843                      contains the output section index in which the
3844                      PLT entries are located, and the low word
3845                      contains the offset of the lazy PLT entry entry
3846                      point into that section.  */
3847                   bfd_put_32 (output_bfd,
3848                               h && ! FRVFDPIC_SYM_LOCAL (info, h)
3849                               ? 0
3850                               : _frvfdpic_osec_to_segment (output_bfd,
3851                                                            sec
3852                                                            ->output_section),
3853                               contents + rel->r_offset + 4);
3854               }
3855           }
3856           check_segment[0] = check_segment[1] = got_segment;
3857           break;
3858
3859         case R_FRV_GPREL12:
3860         case R_FRV_GPRELU12:
3861         case R_FRV_GPREL32:
3862         case R_FRV_GPRELHI:
3863         case R_FRV_GPRELLO:
3864           check_segment[0] = gprel_segment;
3865           check_segment[1] = sec
3866             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3867             : (unsigned)-1;
3868           break;
3869
3870         case R_FRV_GETTLSOFF:
3871           relocation = frvfdpic_plt_section (info)->output_section->vma
3872             + frvfdpic_plt_section (info)->output_offset
3873             + picrel->tlsplt_entry;
3874           BFD_ASSERT (picrel->tlsplt_entry != (bfd_vma)-1
3875                       && picrel->tlsdesc_entry);
3876           check_segment[0] = isec_segment;
3877           check_segment[1] = plt_segment;
3878           break;
3879
3880         case R_FRV_GOTTLSDESC12:
3881         case R_FRV_GOTTLSDESCHI:
3882         case R_FRV_GOTTLSDESCLO:
3883           BFD_ASSERT (picrel->tlsdesc_entry);
3884           relocation = picrel->tlsdesc_entry;
3885           check_segment[0] = tls_segment;
3886           check_segment[1] = sec
3887             && ! bfd_is_abs_section (sec)
3888             && ! bfd_is_und_section (sec)
3889             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3890             : tls_segment;
3891           break;
3892
3893         case R_FRV_TLSMOFF12:
3894         case R_FRV_TLSMOFFHI:
3895         case R_FRV_TLSMOFFLO:
3896         case R_FRV_TLSMOFF:
3897           check_segment[0] = tls_segment;
3898           if (! sec)
3899             check_segment[1] = -1;
3900           else if (bfd_is_abs_section (sec)
3901                    || bfd_is_und_section (sec))
3902             {
3903               relocation = 0;
3904               check_segment[1] = tls_segment;
3905             }
3906           else if (sec->output_section)
3907             {
3908               relocation -= tls_biased_base (info);
3909               check_segment[1] =
3910                 _frvfdpic_osec_to_segment (output_bfd, sec->output_section);
3911             }
3912           else
3913             check_segment[1] = -1;
3914           break;
3915
3916         case R_FRV_GOTTLSOFF12:
3917         case R_FRV_GOTTLSOFFHI:
3918         case R_FRV_GOTTLSOFFLO:
3919           BFD_ASSERT (picrel->tlsoff_entry);
3920           relocation = picrel->tlsoff_entry;
3921           check_segment[0] = tls_segment;
3922           check_segment[1] = sec
3923             && ! bfd_is_abs_section (sec)
3924             && ! bfd_is_und_section (sec)
3925             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3926             : tls_segment;
3927           break;
3928
3929         case R_FRV_TLSDESC_VALUE:
3930         case R_FRV_TLSOFF:
3931           /* These shouldn't be present in input object files.  */
3932           check_segment[0] = check_segment[1] = isec_segment;
3933           break;
3934
3935         case R_FRV_TLSDESC_RELAX:
3936         case R_FRV_GETTLSOFF_RELAX:
3937         case R_FRV_TLSOFF_RELAX:
3938           /* These are just annotations for relaxation, nothing to do
3939              here.  */
3940           continue;
3941
3942         default:
3943           check_segment[0] = isec_segment;
3944           check_segment[1] = sec
3945             ? _frvfdpic_osec_to_segment (output_bfd, sec->output_section)
3946             : (unsigned)-1;
3947           break;
3948         }
3949
3950       if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3951         {
3952           /* If you take this out, remove the #error from fdpic-static-6.d
3953              in the ld testsuite.  */
3954           /* This helps catch problems in GCC while we can't do more
3955              than static linking.  The idea is to test whether the
3956              input file basename is crt0.o only once.  */
3957           if (silence_segment_error == 1)
3958             silence_segment_error =
3959               (strlen (input_bfd->filename) == 6
3960                && filename_cmp (input_bfd->filename, "crt0.o") == 0)
3961               || (strlen (input_bfd->filename) > 6
3962                   && filename_cmp (input_bfd->filename
3963                                    + strlen (input_bfd->filename) - 7,
3964                              "/crt0.o") == 0)
3965               ? -1 : 0;
3966           if (!silence_segment_error
3967               /* We don't want duplicate errors for undefined
3968                  symbols.  */
3969               && !(picrel && picrel->symndx == -1
3970                    && picrel->d.h->root.type == bfd_link_hash_undefined))
3971             {
3972               if (info->shared || info->pie)
3973                 (*_bfd_error_handler)
3974                   (_("%B(%A+0x%lx): reloc against `%s': %s"),
3975                    input_bfd, input_section, (long)rel->r_offset, name,
3976                    _("relocation references a different segment"));
3977               else
3978                 info->callbacks->warning
3979                   (info,
3980                    _("relocation references a different segment"),
3981                    name, input_bfd, input_section, rel->r_offset);
3982             }
3983           if (!silence_segment_error && (info->shared || info->pie))
3984             return FALSE;
3985           elf_elfheader (output_bfd)->e_flags |= EF_FRV_PIC;
3986         }
3987
3988       switch (r_type)
3989         {
3990         case R_FRV_GOTOFFHI:
3991         case R_FRV_TLSMOFFHI:
3992           /* We need the addend to be applied before we shift the
3993              value right.  */
3994           relocation += rel->r_addend;
3995           /* Fall through.  */
3996         case R_FRV_GOTHI:
3997         case R_FRV_FUNCDESC_GOTHI:
3998         case R_FRV_FUNCDESC_GOTOFFHI:
3999         case R_FRV_GOTTLSOFFHI:
4000         case R_FRV_GOTTLSDESCHI:
4001           relocation >>= 16;
4002           /* Fall through.  */
4003
4004         case R_FRV_GOTLO:
4005         case R_FRV_FUNCDESC_GOTLO:
4006         case R_FRV_GOTOFFLO:
4007         case R_FRV_FUNCDESC_GOTOFFLO:
4008         case R_FRV_GOTTLSOFFLO:
4009         case R_FRV_GOTTLSDESCLO:
4010         case R_FRV_TLSMOFFLO:
4011           relocation &= 0xffff;
4012           break;
4013
4014         default:
4015           break;
4016         }
4017
4018       switch (r_type)
4019         {
4020         case R_FRV_LABEL24:
4021           if (! IS_FDPIC (output_bfd) || ! picrel->plt)
4022             break;
4023           /* Fall through.  */
4024
4025           /* When referencing a GOT entry, a function descriptor or a
4026              PLT, we don't want the addend to apply to the reference,
4027              but rather to the referenced symbol.  The actual entry
4028              will have already been created taking the addend into
4029              account, so cancel it out here.  */
4030         case R_FRV_GOT12:
4031         case R_FRV_GOTHI:
4032         case R_FRV_GOTLO:
4033         case R_FRV_FUNCDESC_GOT12:
4034         case R_FRV_FUNCDESC_GOTHI:
4035         case R_FRV_FUNCDESC_GOTLO:
4036         case R_FRV_FUNCDESC_GOTOFF12:
4037         case R_FRV_FUNCDESC_GOTOFFHI:
4038         case R_FRV_FUNCDESC_GOTOFFLO:
4039         case R_FRV_GETTLSOFF:
4040         case R_FRV_GOTTLSDESC12:
4041         case R_FRV_GOTTLSDESCHI:
4042         case R_FRV_GOTTLSDESCLO:
4043         case R_FRV_GOTTLSOFF12:
4044         case R_FRV_GOTTLSOFFHI:
4045         case R_FRV_GOTTLSOFFLO:
4046           /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF12
4047              here, since we do want to apply the addend to the others.
4048              Note that we've applied the addend to GOTOFFHI before we
4049              shifted it right.  */
4050         case R_FRV_GOTOFFHI:
4051         case R_FRV_TLSMOFFHI:
4052           relocation -= rel->r_addend;
4053           break;
4054
4055         default:
4056           break;
4057         }
4058
4059      if (r_type == R_FRV_HI16)
4060        r = elf32_frv_relocate_hi16 (input_bfd, rel, contents, relocation);
4061
4062      else if (r_type == R_FRV_LO16)
4063        r = elf32_frv_relocate_lo16 (input_bfd, rel, contents, relocation);
4064
4065      else if (r_type == R_FRV_LABEL24 || r_type == R_FRV_GETTLSOFF)
4066        r = elf32_frv_relocate_label24 (input_bfd, input_section, rel,
4067                                        contents, relocation);
4068
4069      else if (r_type == R_FRV_GPREL12)
4070        r = elf32_frv_relocate_gprel12 (info, input_bfd, input_section, rel,
4071                                        contents, relocation);
4072
4073      else if (r_type == R_FRV_GPRELU12)
4074        r = elf32_frv_relocate_gprelu12 (info, input_bfd, input_section, rel,
4075                                         contents, relocation);
4076
4077      else if (r_type == R_FRV_GPRELLO)
4078        r = elf32_frv_relocate_gprello (info, input_bfd, input_section, rel,
4079                                        contents, relocation);
4080
4081      else if (r_type == R_FRV_GPRELHI)
4082        r = elf32_frv_relocate_gprelhi (info, input_bfd, input_section, rel,
4083                                        contents, relocation);
4084
4085      else if (r_type == R_FRV_TLSOFF
4086               || r_type == R_FRV_TLSDESC_VALUE)
4087        r = bfd_reloc_notsupported;
4088
4089      else
4090        r = frv_final_link_relocate (howto, input_bfd, input_section, contents,
4091                                     rel, relocation);
4092
4093       if (r != bfd_reloc_ok)
4094         {
4095           const char * msg = (const char *) NULL;
4096
4097           switch (r)
4098             {
4099             case bfd_reloc_overflow:
4100               r = info->callbacks->reloc_overflow
4101                 (info, (h ? &h->root : NULL), name, howto->name,
4102                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
4103               break;
4104
4105             case bfd_reloc_undefined:
4106               r = info->callbacks->undefined_symbol
4107                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
4108               break;
4109
4110             case bfd_reloc_outofrange:
4111               msg = _("internal error: out of range error");
4112               break;
4113
4114             case bfd_reloc_notsupported:
4115               msg = _("internal error: unsupported relocation error");
4116               break;
4117
4118             case bfd_reloc_dangerous:
4119               msg = _("internal error: dangerous relocation");
4120               break;
4121
4122             default:
4123               msg = _("internal error: unknown error");
4124               break;
4125             }
4126
4127           if (msg)
4128             {
4129               (*_bfd_error_handler)
4130                 (_("%B(%A+0x%lx): reloc against `%s': %s"),
4131                  input_bfd, input_section, (long)rel->r_offset, name, msg);
4132               return FALSE;
4133             }
4134
4135           if (! r)
4136             return FALSE;
4137         }
4138     }
4139
4140   return TRUE;
4141 }
4142 \f
4143 /* Return the section that should be marked against GC for a given
4144    relocation.  */
4145
4146 static asection *
4147 elf32_frv_gc_mark_hook (asection *sec,
4148                         struct bfd_link_info *info,
4149                         Elf_Internal_Rela *rel,
4150                         struct elf_link_hash_entry *h,
4151                         Elf_Internal_Sym *sym)
4152 {
4153   if (h != NULL)
4154     switch (ELF32_R_TYPE (rel->r_info))
4155       {
4156       case R_FRV_GNU_VTINHERIT:
4157       case R_FRV_GNU_VTENTRY:
4158         return NULL;
4159       }
4160
4161   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
4162 }
4163 \f
4164 /* Hook called by the linker routine which adds symbols from an object
4165    file.  We use it to put .comm items in .scomm, and not .comm.  */
4166
4167 static bfd_boolean
4168 elf32_frv_add_symbol_hook (abfd, info, sym, namep, flagsp, secp, valp)
4169      bfd *abfd;
4170      struct bfd_link_info *info;
4171      Elf_Internal_Sym *sym;
4172      const char **namep ATTRIBUTE_UNUSED;
4173      flagword *flagsp ATTRIBUTE_UNUSED;
4174      asection **secp;
4175      bfd_vma *valp;
4176 {
4177   if (sym->st_shndx == SHN_COMMON
4178       && !info->relocatable
4179       && (int)sym->st_size <= (int)bfd_get_gp_size (abfd))
4180     {
4181       /* Common symbols less than or equal to -G nn bytes are
4182          automatically put into .sbss.  */
4183
4184       asection *scomm = bfd_get_section_by_name (abfd, ".scommon");
4185
4186       if (scomm == NULL)
4187         {
4188           scomm = bfd_make_section_with_flags (abfd, ".scommon",
4189                                                (SEC_ALLOC
4190                                                 | SEC_IS_COMMON
4191                                                 | SEC_LINKER_CREATED));
4192           if (scomm == NULL)
4193             return FALSE;
4194         }
4195
4196       *secp = scomm;
4197       *valp = sym->st_size;
4198     }
4199
4200   return TRUE;
4201 }
4202
4203 /* We need dynamic symbols for every section, since segments can
4204    relocate independently.  */
4205 static bfd_boolean
4206 _frvfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
4207                                     struct bfd_link_info *info
4208                                     ATTRIBUTE_UNUSED,
4209                                     asection *p ATTRIBUTE_UNUSED)
4210 {
4211   switch (elf_section_data (p)->this_hdr.sh_type)
4212     {
4213     case SHT_PROGBITS:
4214     case SHT_NOBITS:
4215       /* If sh_type is yet undecided, assume it could be
4216          SHT_PROGBITS/SHT_NOBITS.  */
4217     case SHT_NULL:
4218       return FALSE;
4219
4220       /* There shouldn't be section relative relocations
4221          against any other section.  */
4222     default:
4223       return TRUE;
4224     }
4225 }
4226
4227 /* Create  a .got section, as well as its additional info field.  This
4228    is almost entirely copied from
4229    elflink.c:_bfd_elf_create_got_section().  */
4230
4231 static bfd_boolean
4232 _frv_create_got_section (bfd *abfd, struct bfd_link_info *info)
4233 {
4234   flagword flags, pltflags;
4235   asection *s;
4236   struct elf_link_hash_entry *h;
4237   struct bfd_link_hash_entry *bh;
4238   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4239   int ptralign;
4240   int offset;
4241
4242   /* This function may be called more than once.  */
4243   s = bfd_get_section_by_name (abfd, ".got");
4244   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
4245     return TRUE;
4246
4247   /* Machine specific: although pointers are 32-bits wide, we want the
4248      GOT to be aligned to a 64-bit boundary, such that function
4249      descriptors in it can be accessed with 64-bit loads and
4250      stores.  */
4251   ptralign = 3;
4252
4253   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4254            | SEC_LINKER_CREATED);
4255   pltflags = flags;
4256
4257   s = bfd_make_section_with_flags (abfd, ".got", flags);
4258   if (s == NULL
4259       || !bfd_set_section_alignment (abfd, s, ptralign))
4260     return FALSE;
4261
4262   if (bed->want_got_plt)
4263     {
4264       s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
4265       if (s == NULL
4266           || !bfd_set_section_alignment (abfd, s, ptralign))
4267         return FALSE;
4268     }
4269
4270   if (bed->want_got_sym)
4271     {
4272       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
4273          (or .got.plt) section.  We don't do this in the linker script
4274          because we don't want to define the symbol if we are not creating
4275          a global offset table.  */
4276       h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
4277       elf_hash_table (info)->hgot = h;
4278       if (h == NULL)
4279         return FALSE;
4280
4281       /* Machine-specific: we want the symbol for executables as
4282          well.  */
4283       if (! bfd_elf_link_record_dynamic_symbol (info, h))
4284         return FALSE;
4285     }
4286
4287   /* The first bit of the global offset table is the header.  */
4288   s->size += bed->got_header_size;
4289
4290   /* This is the machine-specific part.  Create and initialize section
4291      data for the got.  */
4292   if (IS_FDPIC (abfd))
4293     {
4294       frvfdpic_got_section (info) = s;
4295       frvfdpic_relocs_info (info) = htab_try_create (1,
4296                                                      frvfdpic_relocs_info_hash,
4297                                                      frvfdpic_relocs_info_eq,
4298                                                      (htab_del) NULL);
4299       if (! frvfdpic_relocs_info (info))
4300         return FALSE;
4301
4302       s = bfd_make_section_with_flags (abfd, ".rel.got",
4303                                        (flags | SEC_READONLY));
4304       if (s == NULL
4305           || ! bfd_set_section_alignment (abfd, s, 2))
4306         return FALSE;
4307
4308       frvfdpic_gotrel_section (info) = s;
4309
4310       /* Machine-specific.  */
4311       s = bfd_make_section_with_flags (abfd, ".rofixup",
4312                                        (flags | SEC_READONLY));
4313       if (s == NULL
4314           || ! bfd_set_section_alignment (abfd, s, 2))
4315         return FALSE;
4316
4317       frvfdpic_gotfixup_section (info) = s;
4318       offset = -2048;
4319       flags = BSF_GLOBAL;
4320     }
4321   else
4322     {
4323       offset = 2048;
4324       flags = BSF_GLOBAL | BSF_WEAK;
4325     }
4326
4327   /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
4328      turns out that we're linking with a different linker script, the
4329      linker script will override it.  */
4330   bh = NULL;
4331   if (!(_bfd_generic_link_add_one_symbol
4332         (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
4333          bed->collect, &bh)))
4334     return FALSE;
4335   h = (struct elf_link_hash_entry *) bh;
4336   h->def_regular = 1;
4337   h->type = STT_OBJECT;
4338   /* h->other = STV_HIDDEN; */ /* Should we?  */
4339
4340   /* Machine-specific: we want the symbol for executables as well.  */
4341   if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
4342     return FALSE;
4343
4344   if (!IS_FDPIC (abfd))
4345     return TRUE;
4346
4347   /* FDPIC supports Thread Local Storage, and this may require a
4348      procedure linkage table for TLS PLT entries.  */
4349
4350   /* This is mostly copied from
4351      elflink.c:_bfd_elf_create_dynamic_sections().  */
4352
4353   flags = pltflags;
4354   pltflags |= SEC_CODE;
4355   if (bed->plt_not_loaded)
4356     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
4357   if (bed->plt_readonly)
4358     pltflags |= SEC_READONLY;
4359
4360   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
4361   if (s == NULL
4362       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
4363     return FALSE;
4364   /* FRV-specific: remember it.  */
4365   frvfdpic_plt_section (info) = s;
4366
4367   /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
4368      .plt section.  */
4369   if (bed->want_plt_sym)
4370     {
4371       h = _bfd_elf_define_linkage_sym (abfd, info, s,
4372                                        "_PROCEDURE_LINKAGE_TABLE_");
4373       elf_hash_table (info)->hplt = h;
4374       if (h == NULL)
4375         return FALSE;
4376     }
4377
4378   /* FRV-specific: we want rel relocations for the plt.  */
4379   s = bfd_make_section_with_flags (abfd, ".rel.plt",
4380                                    flags | SEC_READONLY);
4381   if (s == NULL
4382       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4383     return FALSE;
4384   /* FRV-specific: remember it.  */
4385   frvfdpic_pltrel_section (info) = s;
4386
4387   return TRUE;
4388 }
4389
4390 /* Make sure the got and plt sections exist, and that our pointers in
4391    the link hash table point to them.  */
4392
4393 static bfd_boolean
4394 elf32_frvfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
4395 {
4396   /* This is mostly copied from
4397      elflink.c:_bfd_elf_create_dynamic_sections().  */
4398   flagword flags;
4399   asection *s;
4400   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
4401
4402   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
4403            | SEC_LINKER_CREATED);
4404
4405   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
4406      .rel[a].bss sections.  */
4407
4408   /* FRV-specific: we want to create the GOT and the PLT in the FRV
4409      way.  */
4410   if (! _frv_create_got_section (abfd, info))
4411     return FALSE;
4412
4413   /* FRV-specific: make sure we created everything we wanted.  */
4414   BFD_ASSERT (frvfdpic_got_section (info) && frvfdpic_gotrel_section (info)
4415               && frvfdpic_gotfixup_section (info)
4416               && frvfdpic_plt_section (info)
4417               && frvfdpic_pltrel_section (info));
4418
4419   if (bed->want_dynbss)
4420     {
4421       /* The .dynbss section is a place to put symbols which are defined
4422          by dynamic objects, are referenced by regular objects, and are
4423          not functions.  We must allocate space for them in the process
4424          image and use a R_*_COPY reloc to tell the dynamic linker to
4425          initialize them at run time.  The linker script puts the .dynbss
4426          section into the .bss section of the final image.  */
4427       s = bfd_make_section_with_flags (abfd, ".dynbss",
4428                                        SEC_ALLOC | SEC_LINKER_CREATED);
4429       if (s == NULL)
4430         return FALSE;
4431
4432       /* The .rel[a].bss section holds copy relocs.  This section is not
4433      normally needed.  We need to create it here, though, so that the
4434      linker will map it to an output section.  We can't just create it
4435      only if we need it, because we will not know whether we need it
4436      until we have seen all the input files, and the first time the
4437      main linker code calls BFD after examining all the input files
4438      (size_dynamic_sections) the input sections have already been
4439      mapped to the output sections.  If the section turns out not to
4440      be needed, we can discard it later.  We will never need this
4441      section when generating a shared object, since they do not use
4442      copy relocs.  */
4443       if (! info->shared)
4444         {
4445           s = bfd_make_section_with_flags (abfd,
4446                                            (bed->default_use_rela_p
4447                                             ? ".rela.bss" : ".rel.bss"),
4448                                            flags | SEC_READONLY);
4449           if (s == NULL
4450               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
4451             return FALSE;
4452         }
4453     }
4454
4455   return TRUE;
4456 }
4457
4458 /* Compute the total GOT and PLT size required by each symbol in each
4459    range.  Symbols may require up to 4 words in the GOT: an entry
4460    pointing to the symbol, an entry pointing to its function
4461    descriptor, and a private function descriptors taking two
4462    words.  */
4463
4464 static void
4465 _frvfdpic_count_nontls_entries (struct frvfdpic_relocs_info *entry,
4466                                 struct _frvfdpic_dynamic_got_info *dinfo)
4467 {
4468   /* Allocate space for a GOT entry pointing to the symbol.  */
4469   if (entry->got12)
4470     dinfo->got12 += 4;
4471   else if (entry->gotlos)
4472     dinfo->gotlos += 4;
4473   else if (entry->gothilo)
4474     dinfo->gothilo += 4;
4475   else
4476     entry->relocs32--;
4477   entry->relocs32++;
4478
4479   /* Allocate space for a GOT entry pointing to the function
4480      descriptor.  */
4481   if (entry->fdgot12)
4482     dinfo->got12 += 4;
4483   else if (entry->fdgotlos)
4484     dinfo->gotlos += 4;
4485   else if (entry->fdgothilo)
4486     dinfo->gothilo += 4;
4487   else
4488     entry->relocsfd--;
4489   entry->relocsfd++;
4490
4491   /* Decide whether we need a PLT entry, a function descriptor in the
4492      GOT, and a lazy PLT entry for this symbol.  */
4493   entry->plt = entry->call
4494     && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4495     && elf_hash_table (dinfo->info)->dynamic_sections_created;
4496   entry->privfd = entry->plt
4497     || entry->fdgoff12 || entry->fdgofflos || entry->fdgoffhilo
4498     || ((entry->fd || entry->fdgot12 || entry->fdgotlos || entry->fdgothilo)
4499         && (entry->symndx != -1
4500             || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
4501   entry->lazyplt = entry->privfd
4502     && entry->symndx == -1 && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4503     && ! (dinfo->info->flags & DF_BIND_NOW)
4504     && elf_hash_table (dinfo->info)->dynamic_sections_created;
4505
4506   /* Allocate space for a function descriptor.  */
4507   if (entry->fdgoff12)
4508     dinfo->fd12 += 8;
4509   else if (entry->fdgofflos)
4510     dinfo->fdlos += 8;
4511   else if (entry->privfd && entry->plt)
4512     dinfo->fdplt += 8;
4513   else if (entry->privfd)
4514     dinfo->fdhilo += 8;
4515   else
4516     entry->relocsfdv--;
4517   entry->relocsfdv++;
4518
4519   if (entry->lazyplt)
4520     dinfo->lzplt += 8;
4521 }
4522
4523 /* Compute the total GOT size required by each TLS symbol in each
4524    range.  Symbols may require up to 5 words in the GOT: an entry
4525    holding the TLS offset for the symbol, and an entry with a full TLS
4526    descriptor taking 4 words.  */
4527
4528 static void
4529 _frvfdpic_count_tls_entries (struct frvfdpic_relocs_info *entry,
4530                              struct _frvfdpic_dynamic_got_info *dinfo,
4531                              bfd_boolean subtract)
4532 {
4533   const int l = subtract ? -1 : 1;
4534
4535   /* Allocate space for a GOT entry with the TLS offset of the
4536      symbol.  */
4537   if (entry->tlsoff12)
4538     dinfo->got12 += 4 * l;
4539   else if (entry->tlsofflos)
4540     dinfo->gotlos += 4 * l;
4541   else if (entry->tlsoffhilo)
4542     dinfo->gothilo += 4 * l;
4543   else
4544     entry->relocstlsoff -= l;
4545   entry->relocstlsoff += l;
4546
4547   /* If there's any TLSOFF relocation, mark the output file as not
4548      suitable for dlopening.  This mark will remain even if we relax
4549      all such relocations, but this is not a problem, since we'll only
4550      do so for executables, and we definitely don't want anyone
4551      dlopening executables.  */
4552   if (entry->relocstlsoff)
4553     dinfo->info->flags |= DF_STATIC_TLS;
4554
4555   /* Allocate space for a TLS descriptor.  */
4556   if (entry->tlsdesc12)
4557     dinfo->tlsd12 += 8 * l;
4558   else if (entry->tlsdesclos)
4559     dinfo->tlsdlos += 8 * l;
4560   else if (entry->tlsplt)
4561     dinfo->tlsdplt += 8 * l;
4562   else if (entry->tlsdeschilo)
4563     dinfo->tlsdhilo += 8 * l;
4564   else
4565     entry->relocstlsd -= l;
4566   entry->relocstlsd += l;
4567 }
4568
4569 /* Compute the number of dynamic relocations and fixups that a symbol
4570    requires, and add (or subtract) from the grand and per-symbol
4571    totals.  */
4572
4573 static void
4574 _frvfdpic_count_relocs_fixups (struct frvfdpic_relocs_info *entry,
4575                                struct _frvfdpic_dynamic_got_info *dinfo,
4576                                bfd_boolean subtract)
4577 {
4578   bfd_vma relocs = 0, fixups = 0, tlsrets = 0;
4579
4580   if (!dinfo->info->executable || dinfo->info->pie)
4581     {
4582       relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv
4583         + entry->relocstlsd;
4584
4585       /* In the executable, TLS relocations to symbols that bind
4586          locally (including those that resolve to global TLS offsets)
4587          are resolved immediately, without any need for fixups or
4588          dynamic relocations.  In shared libraries, however, we must
4589          emit dynamic relocations even for local symbols, because we
4590          don't know the module id the library is going to get at
4591          run-time, nor its TLS base offset.  */
4592       if (!dinfo->info->executable
4593           || (entry->symndx == -1
4594               && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4595         relocs += entry->relocstlsoff;
4596     }
4597   else
4598     {
4599       if (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
4600         {
4601           if (entry->symndx != -1
4602               || entry->d.h->root.type != bfd_link_hash_undefweak)
4603             fixups += entry->relocs32 + 2 * entry->relocsfdv;
4604           fixups += entry->relocstlsd;
4605           tlsrets += entry->relocstlsd;
4606         }
4607       else
4608         {
4609           relocs += entry->relocs32 + entry->relocsfdv
4610             + entry->relocstlsoff + entry->relocstlsd;
4611         }
4612
4613       if (entry->symndx != -1
4614           || FRVFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
4615         {
4616           if (entry->symndx != -1
4617               || entry->d.h->root.type != bfd_link_hash_undefweak)
4618             fixups += entry->relocsfd;
4619         }
4620       else
4621         relocs += entry->relocsfd;
4622     }
4623
4624   if (subtract)
4625     {
4626       relocs = - relocs;
4627       fixups = - fixups;
4628       tlsrets = - tlsrets;
4629     }
4630
4631   entry->dynrelocs += relocs;
4632   entry->fixups += fixups;
4633   dinfo->relocs += relocs;
4634   dinfo->fixups += fixups;
4635   dinfo->tls_ret_refs += tlsrets;
4636 }
4637
4638 /* Look for opportunities to relax TLS relocations.  We can assume
4639    we're linking the main executable or a static-tls library, since
4640    otherwise we wouldn't have got here.  When relaxing, we have to
4641    first undo any previous accounting of TLS uses of fixups, dynamic
4642    relocations, GOT and PLT entries.  */
4643
4644 static void
4645 _frvfdpic_relax_tls_entries (struct frvfdpic_relocs_info *entry,
4646                              struct _frvfdpic_dynamic_got_info *dinfo,
4647                              bfd_boolean relaxing)
4648 {
4649   bfd_boolean changed = ! relaxing;
4650
4651   BFD_ASSERT (dinfo->info->executable
4652               || (dinfo->info->flags & DF_STATIC_TLS));
4653
4654   if (entry->tlsdesc12 || entry->tlsdesclos || entry->tlsdeschilo)
4655     {
4656       if (! changed)
4657         {
4658           _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4659           _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4660           changed = TRUE;
4661         }
4662
4663       /* When linking an executable, we can always decay GOTTLSDESC to
4664          TLSMOFF, if the symbol is local, or GOTTLSOFF, otherwise.
4665          When linking a static-tls shared library, using TLSMOFF is
4666          not an option, but we can still use GOTTLSOFF.  When decaying
4667          to GOTTLSOFF, we must keep the GOT entry in range.  We know
4668          it has to fit because we'll be trading the 4 words of hte TLS
4669          descriptor for a single word in the same range.  */
4670       if (! dinfo->info->executable
4671           || (entry->symndx == -1
4672               && ! FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)))
4673         {
4674           entry->tlsoff12 |= entry->tlsdesc12;
4675           entry->tlsofflos |= entry->tlsdesclos;
4676           entry->tlsoffhilo |= entry->tlsdeschilo;
4677         }
4678
4679       entry->tlsdesc12 = entry->tlsdesclos = entry->tlsdeschilo = 0;
4680     }
4681
4682   /* We can only decay TLSOFFs or call #gettlsoff to TLSMOFF in the
4683      main executable.  We have to check whether the symbol's TLSOFF is
4684      in range for a setlos.  For symbols with a hash entry, we can
4685      determine exactly what to do; for others locals, we don't have
4686      addresses handy, so we use the size of the TLS section as an
4687      approximation.  If we get it wrong, we'll retain a GOT entry
4688      holding the TLS offset (without dynamic relocations or fixups),
4689      but we'll still optimize away the loads from it.  Since TLS sizes
4690      are generally very small, it's probably not worth attempting to
4691      do better than this.  */
4692   if ((entry->tlsplt
4693        || entry->tlsoff12 || entry->tlsofflos || entry->tlsoffhilo)
4694       && dinfo->info->executable && relaxing
4695       && ((entry->symndx == -1
4696            && FRVFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
4697            /* The above may hold for an undefweak TLS symbol, so make
4698               sure we don't have this case before accessing def.value
4699               and def.section.  */
4700            && (entry->d.h->root.type == bfd_link_hash_undefweak
4701                || (bfd_vma)(entry->d.h->root.u.def.value
4702                             + (entry->d.h->root.u.def.section
4703                                ->output_section->vma)
4704                             + entry->d.h->root.u.def.section->output_offset
4705                             + entry->addend
4706                             - tls_biased_base (dinfo->info)
4707                             + 32768) < (bfd_vma)65536))
4708           || (entry->symndx != -1
4709               && (elf_hash_table (dinfo->info)->tls_sec->size
4710                   + abs (entry->addend) < 32768 + FRVFDPIC_TLS_BIAS))))
4711     {
4712       if (! changed)
4713         {
4714           _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4715           _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4716           changed = TRUE;
4717         }
4718
4719       entry->tlsplt =
4720         entry->tlsoff12 = entry->tlsofflos = entry->tlsoffhilo = 0;
4721     }
4722
4723   /* We can decay `call #gettlsoff' to a ldi #tlsoff if we already
4724      have a #gottlsoff12 relocation for this entry, or if we can fit
4725      one more in the 12-bit (and 16-bit) ranges.  */
4726   if (entry->tlsplt
4727       && (entry->tlsoff12
4728           || (relaxing
4729               && dinfo->got12 + dinfo->fd12 + dinfo->tlsd12 <= 4096 - 12 - 4
4730               && (dinfo->got12 + dinfo->fd12 + dinfo->tlsd12
4731                   + dinfo->gotlos + dinfo->fdlos + dinfo->tlsdlos
4732                   <= 65536 - 12 - 4))))
4733     {
4734       if (! changed)
4735         {
4736           _frvfdpic_count_relocs_fixups (entry, dinfo, TRUE);
4737           _frvfdpic_count_tls_entries (entry, dinfo, TRUE);
4738           changed = TRUE;
4739         }
4740
4741       entry->tlsoff12 = 1;
4742       entry->tlsplt = 0;
4743     }
4744
4745   if (changed)
4746     {
4747       _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4748       _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4749     }
4750
4751   return;
4752 }
4753
4754 /* Compute the total GOT and PLT size required by each symbol in each range. *
4755    Symbols may require up to 4 words in the GOT: an entry pointing to
4756    the symbol, an entry pointing to its function descriptor, and a
4757    private function descriptors taking two words.  */
4758
4759 static int
4760 _frvfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
4761 {
4762   struct frvfdpic_relocs_info *entry = *entryp;
4763   struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
4764
4765   _frvfdpic_count_nontls_entries (entry, dinfo);
4766
4767   if (dinfo->info->executable || (dinfo->info->flags & DF_STATIC_TLS))
4768     _frvfdpic_relax_tls_entries (entry, dinfo, FALSE);
4769   else
4770     {
4771       _frvfdpic_count_tls_entries (entry, dinfo, FALSE);
4772       _frvfdpic_count_relocs_fixups (entry, dinfo, FALSE);
4773     }
4774
4775   return 1;
4776 }
4777
4778 /* Determine the positive and negative ranges to be used by each
4779    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
4780    double-word boundary, are the minimum (negative) and maximum
4781    (positive) GOT offsets already used by previous ranges, except for
4782    an ODD entry that may have been left behind.  GOT and FD indicate
4783    the size of GOT entries and function descriptors that must be
4784    placed within the range from -WRAP to WRAP.  If there's room left,
4785    up to FDPLT bytes should be reserved for additional function
4786    descriptors.  */
4787
4788 inline static bfd_signed_vma
4789 _frvfdpic_compute_got_alloc_data (struct _frvfdpic_dynamic_got_alloc_data *gad,
4790                                   bfd_signed_vma fdcur,
4791                                   bfd_signed_vma odd,
4792                                   bfd_signed_vma cur,
4793                                   bfd_vma got,
4794                                   bfd_vma fd,
4795                                   bfd_vma fdplt,
4796                                   bfd_vma tlsd,
4797                                   bfd_vma tlsdplt,
4798                                   bfd_vma wrap)
4799 {
4800   bfd_signed_vma wrapmin = -wrap;
4801   const bfd_vma tdescsz = 8;
4802
4803   /* Start at the given initial points.  */
4804   gad->fdcur = fdcur;
4805   gad->cur = cur;
4806
4807   /* If we had an incoming odd word and we have any got entries that
4808      are going to use it, consume it, otherwise leave gad->odd at
4809      zero.  We might force gad->odd to zero and return the incoming
4810      odd such that it is used by the next range, but then GOT entries
4811      might appear to be out of order and we wouldn't be able to
4812      shorten the GOT by one word if it turns out to end with an
4813      unpaired GOT entry.  */
4814   if (odd && got)
4815     {
4816       gad->odd = odd;
4817       got -= 4;
4818       odd = 0;
4819     }
4820   else
4821     gad->odd = 0;
4822
4823   /* If we're left with an unpaired GOT entry, compute its location
4824      such that we can return it.  Otherwise, if got doesn't require an
4825      odd number of words here, either odd was already zero in the
4826      block above, or it was set to zero because got was non-zero, or
4827      got was already zero.  In the latter case, we want the value of
4828      odd to carry over to the return statement, so we don't want to
4829      reset odd unless the condition below is true.  */
4830   if (got & 4)
4831     {
4832       odd = cur + got;
4833       got += 4;
4834     }
4835
4836   /* Compute the tentative boundaries of this range.  */
4837   gad->max = cur + got;
4838   gad->min = fdcur - fd;
4839   gad->fdplt = 0;
4840
4841   /* If function descriptors took too much space, wrap some of them
4842      around.  */
4843   if (gad->min < wrapmin)
4844     {
4845       gad->max += wrapmin - gad->min;
4846       gad->tmin = gad->min = wrapmin;
4847     }
4848
4849   /* If GOT entries took too much space, wrap some of them around.
4850      This may well cause gad->min to become lower than wrapmin.  This
4851      will cause a relocation overflow later on, so we don't have to
4852      report it here . */
4853   if ((bfd_vma) gad->max > wrap)
4854     {
4855       gad->min -= gad->max - wrap;
4856       gad->max = wrap;
4857     }
4858
4859   /* Add TLS descriptors.  */
4860   gad->tmax = gad->max + tlsd;
4861   gad->tmin = gad->min;
4862   gad->tlsdplt = 0;
4863
4864   /* If TLS descriptors took too much space, wrap an integral number
4865      of them around.  */
4866   if ((bfd_vma) gad->tmax > wrap)
4867     {
4868       bfd_vma wrapsize = gad->tmax - wrap;
4869
4870       wrapsize += tdescsz / 2;
4871       wrapsize &= ~ tdescsz / 2;
4872
4873       gad->tmin -= wrapsize;
4874       gad->tmax -= wrapsize;
4875     }
4876
4877   /* If there is space left and we have function descriptors
4878      referenced in PLT entries that could take advantage of shorter
4879      offsets, place them now.  */
4880   if (fdplt && gad->tmin > wrapmin)
4881     {
4882       bfd_vma fds;
4883
4884       if ((bfd_vma) (gad->tmin - wrapmin) < fdplt)
4885         fds = gad->tmin - wrapmin;
4886       else
4887         fds = fdplt;
4888
4889       fdplt -= fds;
4890       gad->min -= fds;
4891       gad->tmin -= fds;
4892       gad->fdplt += fds;
4893     }
4894
4895   /* If there is more space left, try to place some more function
4896      descriptors for PLT entries.  */
4897   if (fdplt && (bfd_vma) gad->tmax < wrap)
4898     {
4899       bfd_vma fds;
4900
4901       if ((bfd_vma) (wrap - gad->tmax) < fdplt)
4902         fds = wrap - gad->tmax;
4903       else
4904         fds = fdplt;
4905
4906       fdplt -= fds;
4907       gad->max += fds;
4908       gad->tmax += fds;
4909       gad->fdplt += fds;
4910     }
4911
4912   /* If there is space left and we have TLS descriptors referenced in
4913      PLT entries that could take advantage of shorter offsets, place
4914      them now.  */
4915   if (tlsdplt && gad->tmin > wrapmin)
4916     {
4917       bfd_vma tlsds;
4918
4919       if ((bfd_vma) (gad->tmin - wrapmin) < tlsdplt)
4920         tlsds = (gad->tmin - wrapmin) & ~ (tdescsz / 2);
4921       else
4922         tlsds = tlsdplt;
4923
4924       tlsdplt -= tlsds;
4925       gad->tmin -= tlsds;
4926       gad->tlsdplt += tlsds;
4927     }
4928
4929   /* If there is more space left, try to place some more TLS
4930      descriptors for PLT entries.  Although we could try to fit an
4931      additional TLS descriptor with half of it just before before the
4932      wrap point and another right past the wrap point, this might
4933      cause us to run out of space for the next region, so don't do
4934      it.  */
4935   if (tlsdplt && (bfd_vma) gad->tmax < wrap - tdescsz / 2)
4936     {
4937       bfd_vma tlsds;
4938
4939       if ((bfd_vma) (wrap - gad->tmax) < tlsdplt)
4940         tlsds = (wrap - gad->tmax) & ~ (tdescsz / 2);
4941       else
4942         tlsds = tlsdplt;
4943
4944       tlsdplt -= tlsds;
4945       gad->tmax += tlsds;
4946       gad->tlsdplt += tlsds;
4947     }
4948
4949   /* If odd was initially computed as an offset past the wrap point,
4950      wrap it around.  */
4951   if (odd > gad->max)
4952     odd = gad->min + odd - gad->max;
4953
4954   /* _frvfdpic_get_got_entry() below will always wrap gad->cur if needed
4955      before returning, so do it here too.  This guarantees that,
4956      should cur and fdcur meet at the wrap point, they'll both be
4957      equal to min.  */
4958   if (gad->cur == gad->max)
4959     gad->cur = gad->min;
4960
4961   /* Ditto for _frvfdpic_get_tlsdesc_entry().  */
4962   gad->tcur = gad->max;
4963   if (gad->tcur == gad->tmax)
4964     gad->tcur = gad->tmin;
4965
4966   return odd;
4967 }
4968
4969 /* Compute the location of the next GOT entry, given the allocation
4970    data for a range.  */
4971
4972 inline static bfd_signed_vma
4973 _frvfdpic_get_got_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
4974 {
4975   bfd_signed_vma ret;
4976
4977   if (gad->odd)
4978     {
4979       /* If there was an odd word left behind, use it.  */
4980       ret = gad->odd;
4981       gad->odd = 0;
4982     }
4983   else
4984     {
4985       /* Otherwise, use the word pointed to by cur, reserve the next
4986          as an odd word, and skip to the next pair of words, possibly
4987          wrapping around.  */
4988       ret = gad->cur;
4989       gad->odd = gad->cur + 4;
4990       gad->cur += 8;
4991       if (gad->cur == gad->max)
4992         gad->cur = gad->min;
4993     }
4994
4995   return ret;
4996 }
4997
4998 /* Compute the location of the next function descriptor entry in the
4999    GOT, given the allocation data for a range.  */
5000
5001 inline static bfd_signed_vma
5002 _frvfdpic_get_fd_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5003 {
5004   /* If we're at the bottom, wrap around, and only then allocate the
5005      next pair of words.  */
5006   if (gad->fdcur == gad->min)
5007     gad->fdcur = gad->max;
5008   return gad->fdcur -= 8;
5009 }
5010
5011 /* Compute the location of the next TLS descriptor entry in the GOT,
5012    given the allocation data for a range.  */
5013 inline static bfd_signed_vma
5014 _frvfdpic_get_tlsdesc_entry (struct _frvfdpic_dynamic_got_alloc_data *gad)
5015 {
5016   bfd_signed_vma ret;
5017
5018   ret = gad->tcur;
5019
5020   gad->tcur += 8;
5021
5022   /* If we're at the top of the region, wrap around to the bottom.  */
5023   if (gad->tcur == gad->tmax)
5024     gad->tcur = gad->tmin;
5025
5026   return ret;
5027 }
5028
5029 /* Assign GOT offsets for every GOT entry and function descriptor.
5030    Doing everything in a single pass is tricky.  */
5031
5032 static int
5033 _frvfdpic_assign_got_entries (void **entryp, void *info_)
5034 {
5035   struct frvfdpic_relocs_info *entry = *entryp;
5036   struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5037
5038   if (entry->got12)
5039     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5040   else if (entry->gotlos)
5041     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5042   else if (entry->gothilo)
5043     entry->got_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5044
5045   if (entry->fdgot12)
5046     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5047   else if (entry->fdgotlos)
5048     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5049   else if (entry->fdgothilo)
5050     entry->fdgot_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5051
5052   if (entry->fdgoff12)
5053     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5054   else if (entry->plt && dinfo->got12.fdplt)
5055     {
5056       dinfo->got12.fdplt -= 8;
5057       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->got12);
5058     }
5059   else if (entry->fdgofflos)
5060     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5061   else if (entry->plt && dinfo->gotlos.fdplt)
5062     {
5063       dinfo->gotlos.fdplt -= 8;
5064       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gotlos);
5065     }
5066   else if (entry->plt)
5067     {
5068       dinfo->gothilo.fdplt -= 8;
5069       entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5070     }
5071   else if (entry->privfd)
5072     entry->fd_entry = _frvfdpic_get_fd_entry (&dinfo->gothilo);
5073
5074   if (entry->tlsoff12)
5075     entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->got12);
5076   else if (entry->tlsofflos)
5077     entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gotlos);
5078   else if (entry->tlsoffhilo)
5079     entry->tlsoff_entry = _frvfdpic_get_got_entry (&dinfo->gothilo);
5080
5081   if (entry->tlsdesc12)
5082     entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5083   else if (entry->tlsplt && dinfo->got12.tlsdplt)
5084     {
5085       dinfo->got12.tlsdplt -= 8;
5086       entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->got12);
5087     }
5088   else if (entry->tlsdesclos)
5089     entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5090   else if (entry->tlsplt && dinfo->gotlos.tlsdplt)
5091     {
5092       dinfo->gotlos.tlsdplt -= 8;
5093       entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gotlos);
5094     }
5095   else if (entry->tlsplt)
5096     {
5097       dinfo->gothilo.tlsdplt -= 8;
5098       entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5099     }
5100   else if (entry->tlsdeschilo)
5101     entry->tlsdesc_entry = _frvfdpic_get_tlsdesc_entry (&dinfo->gothilo);
5102
5103   return 1;
5104 }
5105
5106 /* Assign GOT offsets to private function descriptors used by PLT
5107    entries (or referenced by 32-bit offsets), as well as PLT entries
5108    and lazy PLT entries.  */
5109
5110 static int
5111 _frvfdpic_assign_plt_entries (void **entryp, void *info_)
5112 {
5113   struct frvfdpic_relocs_info *entry = *entryp;
5114   struct _frvfdpic_dynamic_got_plt_info *dinfo = info_;
5115
5116   if (entry->privfd)
5117     BFD_ASSERT (entry->fd_entry);
5118
5119   if (entry->plt)
5120     {
5121       int size;
5122
5123       /* We use the section's raw size to mark the location of the
5124          next PLT entry.  */
5125       entry->plt_entry = frvfdpic_plt_section (dinfo->g.info)->size;
5126
5127       /* Figure out the length of this PLT entry based on the
5128          addressing mode we need to reach the function descriptor.  */
5129       BFD_ASSERT (entry->fd_entry);
5130       if (entry->fd_entry >= -(1 << (12 - 1))
5131           && entry->fd_entry < (1 << (12 - 1)))
5132         size = 8;
5133       else if (entry->fd_entry >= -(1 << (16 - 1))
5134                && entry->fd_entry < (1 << (16 - 1)))
5135         size = 12;
5136       else
5137         size = 16;
5138
5139       frvfdpic_plt_section (dinfo->g.info)->size += size;
5140     }
5141
5142   if (entry->lazyplt)
5143     {
5144       entry->lzplt_entry = dinfo->g.lzplt;
5145       dinfo->g.lzplt += 8;
5146       /* If this entry is the one that gets the resolver stub, account
5147          for the additional instruction.  */
5148       if (entry->lzplt_entry % FRVFDPIC_LZPLT_BLOCK_SIZE
5149           == FRVFDPIC_LZPLT_RESOLV_LOC)
5150         dinfo->g.lzplt += 4;
5151     }
5152
5153   if (entry->tlsplt)
5154     {
5155       int size;
5156
5157       entry->tlsplt_entry
5158         = frvfdpic_plt_section (dinfo->g.info)->size;
5159
5160       if (dinfo->g.info->executable
5161           && (entry->symndx != -1
5162               || FRVFDPIC_SYM_LOCAL (dinfo->g.info, entry->d.h)))
5163         {
5164           if ((bfd_signed_vma)entry->addend >= -(1 << (16 - 1))
5165               /* FIXME: here we use the size of the TLS section
5166                  as an upper bound for the value of the TLS
5167                  symbol, because we may not know the exact value
5168                  yet.  If we get it wrong, we'll just waste a
5169                  word in the PLT, and we should never get even
5170                  close to 32 KiB of TLS anyway.  */
5171               && elf_hash_table (dinfo->g.info)->tls_sec
5172               && (elf_hash_table (dinfo->g.info)->tls_sec->size
5173                   + (bfd_signed_vma)(entry->addend) <= (1 << (16 - 1))))
5174             size = 8;
5175           else
5176             size = 12;
5177         }
5178       else if (entry->tlsoff_entry)
5179         {
5180           if (entry->tlsoff_entry >= -(1 << (12 - 1))
5181               && entry->tlsoff_entry < (1 << (12 - 1)))
5182             size = 8;
5183           else if (entry->tlsoff_entry >= -(1 << (16 - 1))
5184                    && entry->tlsoff_entry < (1 << (16 - 1)))
5185             size = 12;
5186           else
5187             size = 16;
5188         }
5189       else
5190         {
5191           BFD_ASSERT (entry->tlsdesc_entry);
5192
5193           if (entry->tlsdesc_entry >= -(1 << (12 - 1))
5194               && entry->tlsdesc_entry < (1 << (12 - 1)))
5195             size = 8;
5196           else if (entry->tlsdesc_entry >= -(1 << (16 - 1))
5197                    && entry->tlsdesc_entry < (1 << (16 - 1)))
5198             size = 12;
5199           else
5200             size = 16;
5201         }
5202
5203       frvfdpic_plt_section (dinfo->g.info)->size += size;
5204     }
5205
5206   return 1;
5207 }
5208
5209 /* Cancel out any effects of calling _frvfdpic_assign_got_entries and
5210    _frvfdpic_assign_plt_entries.  */
5211
5212 static int
5213 _frvfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
5214 {
5215   struct frvfdpic_relocs_info *entry = *entryp;
5216
5217   entry->got_entry = 0;
5218   entry->fdgot_entry = 0;
5219   entry->fd_entry = 0;
5220   entry->plt_entry = (bfd_vma)-1;
5221   entry->lzplt_entry = (bfd_vma)-1;
5222   entry->tlsoff_entry = 0;
5223   entry->tlsdesc_entry = 0;
5224   entry->tlsplt_entry = (bfd_vma)-1;
5225
5226   return 1;
5227 }
5228
5229 /* Follow indirect and warning hash entries so that each got entry
5230    points to the final symbol definition.  P must point to a pointer
5231    to the hash table we're traversing.  Since this traversal may
5232    modify the hash table, we set this pointer to NULL to indicate
5233    we've made a potentially-destructive change to the hash table, so
5234    the traversal must be restarted.  */
5235 static int
5236 _frvfdpic_resolve_final_relocs_info (void **entryp, void *p)
5237 {
5238   struct frvfdpic_relocs_info *entry = *entryp;
5239   htab_t *htab = p;
5240
5241   if (entry->symndx == -1)
5242     {
5243       struct elf_link_hash_entry *h = entry->d.h;
5244       struct frvfdpic_relocs_info *oentry;
5245
5246       while (h->root.type == bfd_link_hash_indirect
5247              || h->root.type == bfd_link_hash_warning)
5248         h = (struct elf_link_hash_entry *)h->root.u.i.link;
5249
5250       if (entry->d.h == h)
5251         return 1;
5252
5253       oentry = frvfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
5254                                                 NO_INSERT);
5255
5256       if (oentry)
5257         {
5258           /* Merge the two entries.  */
5259           frvfdpic_pic_merge_early_relocs_info (oentry, entry);
5260           htab_clear_slot (*htab, entryp);
5261           return 1;
5262         }
5263
5264       entry->d.h = h;
5265
5266       /* If we can't find this entry with the new bfd hash, re-insert
5267          it, and get the traversal restarted.  */
5268       if (! htab_find (*htab, entry))
5269         {
5270           htab_clear_slot (*htab, entryp);
5271           entryp = htab_find_slot (*htab, entry, INSERT);
5272           if (! *entryp)
5273             *entryp = entry;
5274           /* Abort the traversal, since the whole table may have
5275              moved, and leave it up to the parent to restart the
5276              process.  */
5277           *(htab_t *)p = NULL;
5278           return 0;
5279         }
5280     }
5281
5282   return 1;
5283 }
5284
5285 /* Compute the total size of the GOT, the PLT, the dynamic relocations
5286    section and the rofixup section.  Assign locations for GOT and PLT
5287    entries.  */
5288
5289 static bfd_boolean
5290 _frvfdpic_size_got_plt (bfd *output_bfd,
5291                         struct _frvfdpic_dynamic_got_plt_info *gpinfop)
5292 {
5293   bfd_signed_vma odd;
5294   bfd_vma limit, tlslimit;
5295   struct bfd_link_info *info = gpinfop->g.info;
5296   bfd *dynobj = elf_hash_table (info)->dynobj;
5297
5298   memcpy (frvfdpic_dynamic_got_plt_info (info), &gpinfop->g,
5299           sizeof (gpinfop->g));
5300
5301   odd = 12;
5302   /* Compute the total size taken by entries in the 12-bit and 16-bit
5303      ranges, to tell how many PLT function descriptors we can bring
5304      into the 12-bit range without causing the 16-bit range to
5305      overflow.  */
5306   limit = odd + gpinfop->g.got12 + gpinfop->g.gotlos
5307     + gpinfop->g.fd12 + gpinfop->g.fdlos
5308     + gpinfop->g.tlsd12 + gpinfop->g.tlsdlos;
5309   if (limit < (bfd_vma)1 << 16)
5310     limit = ((bfd_vma)1 << 16) - limit;
5311   else
5312     limit = 0;
5313   if (gpinfop->g.fdplt < limit)
5314     {
5315       tlslimit = (limit - gpinfop->g.fdplt) & ~ (bfd_vma) 8;
5316       limit = gpinfop->g.fdplt;
5317     }
5318   else
5319     tlslimit = 0;
5320   if (gpinfop->g.tlsdplt < tlslimit)
5321     tlslimit = gpinfop->g.tlsdplt;
5322
5323   /* Determine the ranges of GOT offsets that we can use for each
5324      range of addressing modes.  */
5325   odd = _frvfdpic_compute_got_alloc_data (&gpinfop->got12,
5326                                           0,
5327                                           odd,
5328                                           16,
5329                                           gpinfop->g.got12,
5330                                           gpinfop->g.fd12,
5331                                           limit,
5332                                           gpinfop->g.tlsd12,
5333                                           tlslimit,
5334                                           (bfd_vma)1 << (12-1));
5335   odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gotlos,
5336                                           gpinfop->got12.tmin,
5337                                           odd,
5338                                           gpinfop->got12.tmax,
5339                                           gpinfop->g.gotlos,
5340                                           gpinfop->g.fdlos,
5341                                           gpinfop->g.fdplt
5342                                           - gpinfop->got12.fdplt,
5343                                           gpinfop->g.tlsdlos,
5344                                           gpinfop->g.tlsdplt
5345                                           - gpinfop->got12.tlsdplt,
5346                                           (bfd_vma)1 << (16-1));
5347   odd = _frvfdpic_compute_got_alloc_data (&gpinfop->gothilo,
5348                                           gpinfop->gotlos.tmin,
5349                                           odd,
5350                                           gpinfop->gotlos.tmax,
5351                                           gpinfop->g.gothilo,
5352                                           gpinfop->g.fdhilo,
5353                                           gpinfop->g.fdplt
5354                                           - gpinfop->got12.fdplt
5355                                           - gpinfop->gotlos.fdplt,
5356                                           gpinfop->g.tlsdhilo,
5357                                           gpinfop->g.tlsdplt
5358                                           - gpinfop->got12.tlsdplt
5359                                           - gpinfop->gotlos.tlsdplt,
5360                                           (bfd_vma)1 << (32-1));
5361
5362   /* Now assign (most) GOT offsets.  */
5363   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_got_entries,
5364                  gpinfop);
5365
5366   frvfdpic_got_section (info)->size = gpinfop->gothilo.tmax
5367     - gpinfop->gothilo.tmin
5368     /* If an odd word is the last word of the GOT, we don't need this
5369        word to be part of the GOT.  */
5370     - (odd + 4 == gpinfop->gothilo.tmax ? 4 : 0);
5371   if (frvfdpic_got_section (info)->size == 0)
5372     frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5373   else if (frvfdpic_got_section (info)->size == 12
5374            && ! elf_hash_table (info)->dynamic_sections_created)
5375     {
5376       frvfdpic_got_section (info)->flags |= SEC_EXCLUDE;
5377       frvfdpic_got_section (info)->size = 0;
5378     }
5379   /* This will be non-NULL during relaxation.  The assumption is that
5380      the size of one of these sections will never grow, only shrink,
5381      so we can use the larger buffer we allocated before.  */
5382   else if (frvfdpic_got_section (info)->contents == NULL)
5383     {
5384       frvfdpic_got_section (info)->contents =
5385         (bfd_byte *) bfd_zalloc (dynobj,
5386                                  frvfdpic_got_section (info)->size);
5387       if (frvfdpic_got_section (info)->contents == NULL)
5388         return FALSE;
5389     }
5390
5391   if (frvfdpic_gotrel_section (info))
5392     /* Subtract the number of lzplt entries, since those will generate
5393        relocations in the pltrel section.  */
5394     frvfdpic_gotrel_section (info)->size =
5395       (gpinfop->g.relocs - gpinfop->g.lzplt / 8)
5396       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5397   else
5398     BFD_ASSERT (gpinfop->g.relocs == 0);
5399   if (frvfdpic_gotrel_section (info)->size == 0)
5400     frvfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
5401   else if (frvfdpic_gotrel_section (info)->contents == NULL)
5402     {
5403       frvfdpic_gotrel_section (info)->contents =
5404         (bfd_byte *) bfd_zalloc (dynobj,
5405                                  frvfdpic_gotrel_section (info)->size);
5406       if (frvfdpic_gotrel_section (info)->contents == NULL)
5407         return FALSE;
5408     }
5409
5410   frvfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
5411   if (frvfdpic_gotfixup_section (info)->size == 0)
5412     frvfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
5413   else if (frvfdpic_gotfixup_section (info)->contents == NULL)
5414     {
5415       frvfdpic_gotfixup_section (info)->contents =
5416         (bfd_byte *) bfd_zalloc (dynobj,
5417                                  frvfdpic_gotfixup_section (info)->size);
5418       if (frvfdpic_gotfixup_section (info)->contents == NULL)
5419         return FALSE;
5420     }
5421
5422   if (frvfdpic_pltrel_section (info))
5423     {
5424       frvfdpic_pltrel_section (info)->size =
5425         gpinfop->g.lzplt / 8
5426         * get_elf_backend_data (output_bfd)->s->sizeof_rel;
5427       if (frvfdpic_pltrel_section (info)->size == 0)
5428         frvfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
5429       else if (frvfdpic_pltrel_section (info)->contents == NULL)
5430         {
5431           frvfdpic_pltrel_section (info)->contents =
5432             (bfd_byte *) bfd_zalloc (dynobj,
5433                                      frvfdpic_pltrel_section (info)->size);
5434           if (frvfdpic_pltrel_section (info)->contents == NULL)
5435             return FALSE;
5436         }
5437     }
5438
5439   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
5440      such that there's room for the additional instruction needed to
5441      call the resolver.  Since _frvfdpic_assign_got_entries didn't
5442      account for them, our block size is 4 bytes smaller than the real
5443      block size.  */
5444   if (frvfdpic_plt_section (info))
5445     {
5446       frvfdpic_plt_section (info)->size = gpinfop->g.lzplt
5447         + ((gpinfop->g.lzplt + (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) - 8)
5448            / (FRVFDPIC_LZPLT_BLOCK_SIZE - 4) * 4);
5449     }
5450
5451   /* Reset it, such that _frvfdpic_assign_plt_entries() can use it to
5452      actually assign lazy PLT entries addresses.  */
5453   gpinfop->g.lzplt = 0;
5454
5455   /* Save information that we're going to need to generate GOT and PLT
5456      entries.  */
5457   frvfdpic_got_initial_offset (info) = -gpinfop->gothilo.tmin;
5458
5459   if (get_elf_backend_data (output_bfd)->want_got_sym)
5460     elf_hash_table (info)->hgot->root.u.def.value
5461       = frvfdpic_got_initial_offset (info);
5462
5463   if (frvfdpic_plt_section (info))
5464     frvfdpic_plt_initial_offset (info) =
5465       frvfdpic_plt_section (info)->size;
5466
5467   /* Allocate a ret statement at plt_initial_offset, to be used by
5468      locally-resolved TLS descriptors.  */
5469   if (gpinfop->g.tls_ret_refs)
5470     frvfdpic_plt_section (info)->size += 4;
5471
5472   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_assign_plt_entries,
5473                  gpinfop);
5474
5475   /* Allocate the PLT section contents only after
5476      _frvfdpic_assign_plt_entries has a chance to add the size of the
5477      non-lazy PLT entries.  */
5478   if (frvfdpic_plt_section (info))
5479     {
5480       if (frvfdpic_plt_section (info)->size == 0)
5481         frvfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
5482       else if (frvfdpic_plt_section (info)->contents == NULL)
5483         {
5484           frvfdpic_plt_section (info)->contents =
5485             (bfd_byte *) bfd_zalloc (dynobj,
5486                                      frvfdpic_plt_section (info)->size);
5487           if (frvfdpic_plt_section (info)->contents == NULL)
5488             return FALSE;
5489         }
5490     }
5491
5492   return TRUE;
5493 }
5494
5495 /* Set the sizes of the dynamic sections.  */
5496
5497 static bfd_boolean
5498 elf32_frvfdpic_size_dynamic_sections (bfd *output_bfd,
5499                                       struct bfd_link_info *info)
5500 {
5501   bfd *dynobj;
5502   asection *s;
5503   struct _frvfdpic_dynamic_got_plt_info gpinfo;
5504
5505   dynobj = elf_hash_table (info)->dynobj;
5506   BFD_ASSERT (dynobj != NULL);
5507
5508   if (elf_hash_table (info)->dynamic_sections_created)
5509     {
5510       /* Set the contents of the .interp section to the interpreter.  */
5511       if (info->executable)
5512         {
5513           s = bfd_get_section_by_name (dynobj, ".interp");
5514           BFD_ASSERT (s != NULL);
5515           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5516           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
5517         }
5518     }
5519
5520   memset (&gpinfo, 0, sizeof (gpinfo));
5521   gpinfo.g.info = info;
5522
5523   for (;;)
5524     {
5525       htab_t relocs = frvfdpic_relocs_info (info);
5526
5527       htab_traverse (relocs, _frvfdpic_resolve_final_relocs_info, &relocs);
5528
5529       if (relocs == frvfdpic_relocs_info (info))
5530         break;
5531     }
5532
5533   htab_traverse (frvfdpic_relocs_info (info), _frvfdpic_count_got_plt_entries,
5534                  &gpinfo.g);
5535
5536   /* Allocate space to save the summary information, we're going to
5537      use it if we're doing relaxations.  */
5538   frvfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
5539
5540   if (!_frvfdpic_size_got_plt (output_bfd, &gpinfo))
5541     return FALSE;
5542
5543   if (elf_hash_table (info)->dynamic_sections_created)
5544     {
5545       if (frvfdpic_got_section (info)->size)
5546         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
5547           return FALSE;
5548
5549       if (frvfdpic_pltrel_section (info)->size)
5550         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
5551             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
5552             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
5553           return FALSE;
5554
5555       if (frvfdpic_gotrel_section (info)->size)
5556         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
5557             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
5558             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
5559                                             sizeof (Elf32_External_Rel)))
5560           return FALSE;
5561     }
5562
5563   return TRUE;
5564 }
5565
5566 static bfd_boolean
5567 elf32_frvfdpic_always_size_sections (bfd *output_bfd,
5568                                      struct bfd_link_info *info)
5569 {
5570   if (!info->relocatable)
5571     {
5572       struct elf_link_hash_entry *h;
5573
5574       /* Force a PT_GNU_STACK segment to be created.  */
5575       if (! elf_tdata (output_bfd)->stack_flags)
5576         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
5577
5578       /* Define __stacksize if it's not defined yet.  */
5579       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5580                                 FALSE, FALSE, FALSE);
5581       if (! h || h->root.type != bfd_link_hash_defined
5582           || h->type != STT_OBJECT
5583           || !h->def_regular)
5584         {
5585           struct bfd_link_hash_entry *bh = NULL;
5586
5587           if (!(_bfd_generic_link_add_one_symbol
5588                 (info, output_bfd, "__stacksize",
5589                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
5590                  (const char *) NULL, FALSE,
5591                  get_elf_backend_data (output_bfd)->collect, &bh)))
5592             return FALSE;
5593
5594           h = (struct elf_link_hash_entry *) bh;
5595           h->def_regular = 1;
5596           h->type = STT_OBJECT;
5597           /* This one must NOT be hidden.  */
5598         }
5599     }
5600
5601   return TRUE;
5602 }
5603
5604 /* Check whether any of the relocations was optimized away, and
5605    subtract it from the relocation or fixup count.  */
5606 static bfd_boolean
5607 _frvfdpic_check_discarded_relocs (bfd *abfd, asection *sec,
5608                                   struct bfd_link_info *info,
5609
5610                                   bfd_boolean *changed)
5611 {
5612   Elf_Internal_Shdr *symtab_hdr;
5613   struct elf_link_hash_entry **sym_hashes;
5614   Elf_Internal_Rela *rel, *erel;
5615
5616   if ((sec->flags & SEC_RELOC) == 0
5617       || sec->reloc_count == 0)
5618     return TRUE;
5619
5620   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5621   sym_hashes = elf_sym_hashes (abfd);
5622
5623   rel = elf_section_data (sec)->relocs;
5624
5625   /* Now examine each relocation.  */
5626   for (erel = rel + sec->reloc_count; rel < erel; rel++)
5627     {
5628       struct elf_link_hash_entry *h;
5629       unsigned long r_symndx;
5630       struct frvfdpic_relocs_info *picrel;
5631       struct _frvfdpic_dynamic_got_info *dinfo;
5632
5633       if (ELF32_R_TYPE (rel->r_info) != R_FRV_32
5634           && ELF32_R_TYPE (rel->r_info) != R_FRV_FUNCDESC)
5635         continue;
5636
5637       if (_bfd_elf_section_offset (sec->output_section->owner,
5638                                    info, sec, rel->r_offset)
5639           != (bfd_vma)-1)
5640         continue;
5641
5642       r_symndx = ELF32_R_SYM (rel->r_info);
5643       if (r_symndx < symtab_hdr->sh_info)
5644         h = NULL;
5645       else
5646         {
5647           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
5648           while (h->root.type == bfd_link_hash_indirect
5649                  || h->root.type == bfd_link_hash_warning)
5650             h = (struct elf_link_hash_entry *)h->root.u.i.link;
5651         }
5652
5653       if (h != NULL)
5654         picrel = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
5655                                                   abfd, h,
5656                                                   rel->r_addend, NO_INSERT);
5657       else
5658         picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info (info),
5659                                                  abfd, r_symndx,
5660                                                  rel->r_addend, NO_INSERT);
5661
5662       if (! picrel)
5663         return FALSE;
5664
5665       *changed = TRUE;
5666       dinfo = frvfdpic_dynamic_got_plt_info (info);
5667
5668       _frvfdpic_count_relocs_fixups (picrel, dinfo, TRUE);
5669       if (ELF32_R_TYPE (rel->r_info) == R_FRV_32)
5670         picrel->relocs32--;
5671       else /* we know (ELF32_R_TYPE (rel->r_info) == R_FRV_FUNCDESC) */
5672         picrel->relocsfd--;
5673       _frvfdpic_count_relocs_fixups (picrel, dinfo, FALSE);
5674     }
5675
5676   return TRUE;
5677 }
5678
5679 static bfd_boolean
5680 frvfdpic_elf_discard_info (bfd *ibfd,
5681                            struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED,
5682                            struct bfd_link_info *info)
5683 {
5684   bfd_boolean changed = FALSE;
5685   asection *s;
5686   bfd *obfd = NULL;
5687
5688   /* Account for relaxation of .eh_frame section.  */
5689   for (s = ibfd->sections; s; s = s->next)
5690     if (s->sec_info_type == ELF_INFO_TYPE_EH_FRAME)
5691       {
5692         if (!_frvfdpic_check_discarded_relocs (ibfd, s, info, &changed))
5693           return FALSE;
5694         obfd = s->output_section->owner;
5695       }
5696
5697   if (changed)
5698     {
5699       struct _frvfdpic_dynamic_got_plt_info gpinfo;
5700
5701       memset (&gpinfo, 0, sizeof (gpinfo));
5702       memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info),
5703               sizeof (gpinfo.g));
5704
5705       /* Clear GOT and PLT assignments.  */
5706       htab_traverse (frvfdpic_relocs_info (info),
5707                      _frvfdpic_reset_got_plt_entries,
5708                      NULL);
5709
5710       if (!_frvfdpic_size_got_plt (obfd, &gpinfo))
5711         return FALSE;
5712     }
5713
5714   return TRUE;
5715 }
5716
5717 /* Look for opportunities to relax TLS relocations.  We can assume
5718    we're linking the main executable or a static-tls library, since
5719    otherwise we wouldn't have got here.  */
5720
5721 static int
5722 _frvfdpic_relax_got_plt_entries (void **entryp, void *dinfo_)
5723 {
5724   struct frvfdpic_relocs_info *entry = *entryp;
5725   struct _frvfdpic_dynamic_got_info *dinfo = dinfo_;
5726
5727   _frvfdpic_relax_tls_entries (entry, dinfo, TRUE);
5728
5729   return 1;
5730 }
5731
5732 static bfd_boolean
5733 elf32_frvfdpic_relax_section (bfd *abfd ATTRIBUTE_UNUSED, asection *sec,
5734                               struct bfd_link_info *info, bfd_boolean *again)
5735 {
5736   struct _frvfdpic_dynamic_got_plt_info gpinfo;
5737
5738   if (info->relocatable)
5739     (*info->callbacks->einfo)
5740       (_("%P%F: --relax and -r may not be used together\n"));
5741
5742   /* If we return early, we didn't change anything.  */
5743   *again = FALSE;
5744
5745   /* We'll do our thing when requested to relax the GOT section.  */
5746   if (sec != frvfdpic_got_section (info))
5747     return TRUE;
5748
5749   /* We can only relax when linking the main executable or a library
5750      that can't be dlopened.  */
5751   if (! info->executable && ! (info->flags & DF_STATIC_TLS))
5752     return TRUE;
5753
5754   /* If there isn't a TLS section for this binary, we can't do
5755      anything about its TLS relocations (it probably doesn't have
5756      any.  */
5757   if (elf_hash_table (info)->tls_sec == NULL)
5758     return TRUE;
5759
5760   memset (&gpinfo, 0, sizeof (gpinfo));
5761   memcpy (&gpinfo.g, frvfdpic_dynamic_got_plt_info (info), sizeof (gpinfo.g));
5762
5763   /* Now look for opportunities to relax, adjusting the GOT usage
5764      as needed.  */
5765   htab_traverse (frvfdpic_relocs_info (info),
5766                  _frvfdpic_relax_got_plt_entries,
5767                  &gpinfo.g);
5768
5769   /* If we changed anything, reset and re-assign GOT and PLT entries.  */
5770   if (memcmp (frvfdpic_dynamic_got_plt_info (info),
5771               &gpinfo.g, sizeof (gpinfo.g)) != 0)
5772     {
5773       /* Clear GOT and PLT assignments.  */
5774       htab_traverse (frvfdpic_relocs_info (info),
5775                      _frvfdpic_reset_got_plt_entries,
5776                      NULL);
5777
5778       /* The owner of the TLS section is the output bfd.  There should
5779          be a better way to get to it.  */
5780       if (!_frvfdpic_size_got_plt (elf_hash_table (info)->tls_sec->owner,
5781                                    &gpinfo))
5782         return FALSE;
5783
5784       /* Repeat until we don't make any further changes.  We could fail to
5785          introduce changes in a round if, for example, the 12-bit range is
5786          full, but we later release some space by getting rid of TLS
5787          descriptors in it.  We have to repeat the whole process because
5788          we might have changed the size of a section processed before this
5789          one.  */
5790       *again = TRUE;
5791     }
5792
5793   return TRUE;
5794 }
5795
5796 static bfd_boolean
5797 elf32_frvfdpic_modify_program_headers (bfd *output_bfd,
5798                                        struct bfd_link_info *info)
5799 {
5800   struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
5801   struct elf_segment_map *m;
5802   Elf_Internal_Phdr *p;
5803
5804   /* objcopy and strip preserve what's already there using
5805      elf32_frvfdpic_copy_private_bfd_data ().  */
5806   if (! info)
5807     return TRUE;
5808
5809   for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
5810     if (m->p_type == PT_GNU_STACK)
5811       break;
5812
5813   if (m)
5814     {
5815       struct elf_link_hash_entry *h;
5816
5817       /* Obtain the pointer to the __stacksize symbol.  */
5818       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
5819                                 FALSE, FALSE, FALSE);
5820       if (h)
5821         {
5822           while (h->root.type == bfd_link_hash_indirect
5823                  || h->root.type == bfd_link_hash_warning)
5824             h = (struct elf_link_hash_entry *) h->root.u.i.link;
5825           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
5826         }
5827
5828       /* Set the header p_memsz from the symbol value.  We
5829          intentionally ignore the symbol section.  */
5830       if (h && h->root.type == bfd_link_hash_defined)
5831         p->p_memsz = h->root.u.def.value;
5832       else
5833         p->p_memsz = DEFAULT_STACK_SIZE;
5834
5835       p->p_align = 8;
5836     }
5837
5838   return TRUE;
5839 }
5840
5841 /* Fill in code and data in dynamic sections.  */
5842
5843 static bfd_boolean
5844 elf32_frv_finish_dynamic_sections (bfd *output_bfd ATTRIBUTE_UNUSED,
5845                                    struct bfd_link_info *info ATTRIBUTE_UNUSED)
5846 {
5847   /* Nothing to be done for non-FDPIC.  */
5848   return TRUE;
5849 }
5850
5851 static bfd_boolean
5852 elf32_frvfdpic_finish_dynamic_sections (bfd *output_bfd,
5853                                         struct bfd_link_info *info)
5854 {
5855   bfd *dynobj;
5856   asection *sdyn;
5857
5858   dynobj = elf_hash_table (info)->dynobj;
5859
5860   if (frvfdpic_dynamic_got_plt_info (info))
5861     {
5862       BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs == 0);
5863     }
5864   if (frvfdpic_got_section (info))
5865     {
5866       BFD_ASSERT (frvfdpic_gotrel_section (info)->size
5867                   == (frvfdpic_gotrel_section (info)->reloc_count
5868                       * sizeof (Elf32_External_Rel)));
5869
5870       if (frvfdpic_gotfixup_section (info))
5871         {
5872           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
5873           bfd_vma got_value = hgot->root.u.def.value
5874             + hgot->root.u.def.section->output_section->vma
5875             + hgot->root.u.def.section->output_offset;
5876           struct bfd_link_hash_entry *hend;
5877
5878           _frvfdpic_add_rofixup (output_bfd, frvfdpic_gotfixup_section (info),
5879                                  got_value, 0);
5880
5881           if (frvfdpic_gotfixup_section (info)->size
5882               != (frvfdpic_gotfixup_section (info)->reloc_count * 4))
5883             {
5884             error:
5885               (*_bfd_error_handler)
5886                 ("LINKER BUG: .rofixup section size mismatch");
5887               return FALSE;
5888             }
5889
5890           hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
5891                                        FALSE, FALSE, TRUE);
5892           if (hend
5893               && (hend->type == bfd_link_hash_defined
5894                   || hend->type == bfd_link_hash_defweak)
5895               && hend->u.def.section->output_section != NULL)
5896             {
5897               bfd_vma value =
5898                 frvfdpic_gotfixup_section (info)->output_section->vma
5899                 + frvfdpic_gotfixup_section (info)->output_offset
5900                 + frvfdpic_gotfixup_section (info)->size
5901                 - hend->u.def.section->output_section->vma
5902                 - hend->u.def.section->output_offset;
5903               BFD_ASSERT (hend->u.def.value == value);
5904               if (hend->u.def.value != value)
5905                 goto error;
5906             }
5907         }
5908     }
5909   if (frvfdpic_pltrel_section (info))
5910     {
5911       BFD_ASSERT (frvfdpic_pltrel_section (info)->size
5912                   == (frvfdpic_pltrel_section (info)->reloc_count
5913                       * sizeof (Elf32_External_Rel)));
5914     }
5915
5916
5917   if (elf_hash_table (info)->dynamic_sections_created)
5918     {
5919       Elf32_External_Dyn * dyncon;
5920       Elf32_External_Dyn * dynconend;
5921
5922       sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
5923
5924       BFD_ASSERT (sdyn != NULL);
5925
5926       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5927       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5928
5929       for (; dyncon < dynconend; dyncon++)
5930         {
5931           Elf_Internal_Dyn dyn;
5932
5933           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5934
5935           switch (dyn.d_tag)
5936             {
5937             default:
5938               break;
5939
5940             case DT_PLTGOT:
5941               dyn.d_un.d_ptr = frvfdpic_got_section (info)->output_section->vma
5942                 + frvfdpic_got_section (info)->output_offset
5943                 + frvfdpic_got_initial_offset (info);
5944               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5945               break;
5946
5947             case DT_JMPREL:
5948               dyn.d_un.d_ptr = frvfdpic_pltrel_section (info)
5949                 ->output_section->vma
5950                 + frvfdpic_pltrel_section (info)->output_offset;
5951               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5952               break;
5953
5954             case DT_PLTRELSZ:
5955               dyn.d_un.d_val = frvfdpic_pltrel_section (info)->size;
5956               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
5957               break;
5958             }
5959         }
5960     }
5961
5962   return TRUE;
5963 }
5964
5965 /* Adjust a symbol defined by a dynamic object and referenced by a
5966    regular object.  */
5967
5968 static bfd_boolean
5969 elf32_frvfdpic_adjust_dynamic_symbol
5970 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
5971  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
5972 {
5973   bfd * dynobj;
5974
5975   dynobj = elf_hash_table (info)->dynobj;
5976
5977   /* Make sure we know what is going on here.  */
5978   BFD_ASSERT (dynobj != NULL
5979               && (h->u.weakdef != NULL
5980                   || (h->def_dynamic
5981                       && h->ref_regular
5982                       && !h->def_regular)));
5983
5984   /* If this is a weak symbol, and there is a real definition, the
5985      processor independent code will have arranged for us to see the
5986      real definition first, and we can just use the same value.  */
5987   if (h->u.weakdef != NULL)
5988     {
5989       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5990                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5991       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5992       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5993     }
5994
5995   return TRUE;
5996 }
5997
5998 /* Perform any actions needed for dynamic symbols.  */
5999
6000 static bfd_boolean
6001 elf32_frvfdpic_finish_dynamic_symbol
6002 (bfd *output_bfd ATTRIBUTE_UNUSED,
6003  struct bfd_link_info *info ATTRIBUTE_UNUSED,
6004  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
6005  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
6006 {
6007   return TRUE;
6008 }
6009
6010 /* Decide whether to attempt to turn absptr or lsda encodings in
6011    shared libraries into pcrel within the given input section.  */
6012
6013 static bfd_boolean
6014 frvfdpic_elf_use_relative_eh_frame
6015 (bfd *input_bfd ATTRIBUTE_UNUSED,
6016  struct bfd_link_info *info ATTRIBUTE_UNUSED,
6017  asection *eh_frame_section ATTRIBUTE_UNUSED)
6018 {
6019   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
6020   return FALSE;
6021 }
6022
6023 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
6024
6025 static bfd_byte
6026 frvfdpic_elf_encode_eh_address (bfd *abfd,
6027                                 struct bfd_link_info *info,
6028                                 asection *osec, bfd_vma offset,
6029                                 asection *loc_sec, bfd_vma loc_offset,
6030                                 bfd_vma *encoded)
6031 {
6032   struct elf_link_hash_entry *h;
6033
6034   h = elf_hash_table (info)->hgot;
6035   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
6036
6037   if (! h || (_frvfdpic_osec_to_segment (abfd, osec)
6038               == _frvfdpic_osec_to_segment (abfd, loc_sec->output_section)))
6039     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
6040                                        loc_sec, loc_offset, encoded);
6041
6042   BFD_ASSERT (_frvfdpic_osec_to_segment (abfd, osec)
6043               == (_frvfdpic_osec_to_segment
6044                   (abfd, h->root.u.def.section->output_section)));
6045
6046   *encoded = osec->vma + offset
6047     - (h->root.u.def.value
6048        + h->root.u.def.section->output_section->vma
6049        + h->root.u.def.section->output_offset);
6050
6051   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
6052 }
6053
6054 /* Look through the relocs for a section during the first phase.
6055
6056    Besides handling virtual table relocs for gc, we have to deal with
6057    all sorts of PIC-related relocations.  We describe below the
6058    general plan on how to handle such relocations, even though we only
6059    collect information at this point, storing them in hash tables for
6060    perusal of later passes.
6061
6062    32 relocations are propagated to the linker output when creating
6063    position-independent output.  LO16 and HI16 relocations are not
6064    supposed to be encountered in this case.
6065
6066    LABEL16 should always be resolvable by the linker, since it's only
6067    used by branches.
6068
6069    LABEL24, on the other hand, is used by calls.  If it turns out that
6070    the target of a call is a dynamic symbol, a PLT entry must be
6071    created for it, which triggers the creation of a private function
6072    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
6073
6074    GPREL relocations require the referenced symbol to be in the same
6075    segment as _gp, but this can only be checked later.
6076
6077    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
6078    exist.  LABEL24 might as well, since it may require a PLT entry,
6079    that will require a got.
6080
6081    Non-FUNCDESC GOT relocations require a GOT entry to be created
6082    regardless of whether the symbol is dynamic.  However, since a
6083    global symbol that turns out to not be exported may have the same
6084    address of a non-dynamic symbol, we don't assign GOT entries at
6085    this point, such that we can share them in this case.  A relocation
6086    for the GOT entry always has to be created, be it to offset a
6087    private symbol by the section load address, be it to get the symbol
6088    resolved dynamically.
6089
6090    FUNCDESC GOT relocations require a GOT entry to be created, and
6091    handled as if a FUNCDESC relocation was applied to the GOT entry in
6092    an object file.
6093
6094    FUNCDESC relocations referencing a symbol that turns out to NOT be
6095    dynamic cause a private function descriptor to be created.  The
6096    FUNCDESC relocation then decays to a 32 relocation that points at
6097    the private descriptor.  If the symbol is dynamic, the FUNCDESC
6098    relocation is propagated to the linker output, such that the
6099    dynamic linker creates the canonical descriptor, pointing to the
6100    dynamically-resolved definition of the function.
6101
6102    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
6103    symbols that are assigned to the same segment as the GOT, but we
6104    can only check this later, after we know the complete set of
6105    symbols defined and/or exported.
6106
6107    FUNCDESC GOTOFF relocations require a function descriptor to be
6108    created and, unless lazy binding is disabled or the symbol is not
6109    dynamic, a lazy PLT entry.  Since we can't tell at this point
6110    whether a symbol is going to be dynamic, we have to decide later
6111    whether to create a lazy PLT entry or bind the descriptor directly
6112    to the private function.
6113
6114    FUNCDESC_VALUE relocations are not supposed to be present in object
6115    files, but they may very well be simply propagated to the linker
6116    output, since they have no side effect.
6117
6118
6119    A function descriptor always requires a FUNCDESC_VALUE relocation.
6120    Whether it's in .plt.rel or not depends on whether lazy binding is
6121    enabled and on whether the referenced symbol is dynamic.
6122
6123    The existence of a lazy PLT requires the resolverStub lazy PLT
6124    entry to be present.
6125
6126
6127    As for assignment of GOT, PLT and lazy PLT entries, and private
6128    descriptors, we might do them all sequentially, but we can do
6129    better than that.  For example, we can place GOT entries and
6130    private function descriptors referenced using 12-bit operands
6131    closer to the PIC register value, such that these relocations don't
6132    overflow.  Those that are only referenced with LO16 relocations
6133    could come next, but we may as well place PLT-required function
6134    descriptors in the 12-bit range to make them shorter.  Symbols
6135    referenced with LO16/HI16 may come next, but we may place
6136    additional function descriptors in the 16-bit range if we can
6137    reliably tell that we've already placed entries that are ever
6138    referenced with only LO16.  PLT entries are therefore generated as
6139    small as possible, while not introducing relocation overflows in
6140    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
6141    generated before or after PLT entries, but not intermingled with
6142    them, such that we can have more lazy PLT entries in range for a
6143    branch to the resolverStub.  The resolverStub should be emitted at
6144    the most distant location from the first lazy PLT entry such that
6145    it's still in range for a branch, or closer, if there isn't a need
6146    for so many lazy PLT entries.  Additional lazy PLT entries may be
6147    emitted after the resolverStub, as long as branches are still in
6148    range.  If the branch goes out of range, longer lazy PLT entries
6149    are emitted.
6150
6151    We could further optimize PLT and lazy PLT entries by giving them
6152    priority in assignment to closer-to-gr17 locations depending on the
6153    number of occurrences of references to them (assuming a function
6154    that's called more often is more important for performance, so its
6155    PLT entry should be faster), or taking hints from the compiler.
6156    Given infinite time and money... :-)  */
6157
6158 static bfd_boolean
6159 elf32_frv_check_relocs (abfd, info, sec, relocs)
6160      bfd *abfd;
6161      struct bfd_link_info *info;
6162      asection *sec;
6163      const Elf_Internal_Rela *relocs;
6164 {
6165   Elf_Internal_Shdr *symtab_hdr;
6166   struct elf_link_hash_entry **sym_hashes;
6167   const Elf_Internal_Rela *rel;
6168   const Elf_Internal_Rela *rel_end;
6169   bfd *dynobj;
6170   struct frvfdpic_relocs_info *picrel;
6171
6172   if (info->relocatable)
6173     return TRUE;
6174
6175   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
6176   sym_hashes = elf_sym_hashes (abfd);
6177
6178   dynobj = elf_hash_table (info)->dynobj;
6179   rel_end = relocs + sec->reloc_count;
6180   for (rel = relocs; rel < rel_end; rel++)
6181     {
6182       struct elf_link_hash_entry *h;
6183       unsigned long r_symndx;
6184
6185       r_symndx = ELF32_R_SYM (rel->r_info);
6186       if (r_symndx < symtab_hdr->sh_info)
6187         h = NULL;
6188       else
6189         {
6190           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
6191           while (h->root.type == bfd_link_hash_indirect
6192                  || h->root.type == bfd_link_hash_warning)
6193             h = (struct elf_link_hash_entry *) h->root.u.i.link;
6194         }
6195
6196       switch (ELF32_R_TYPE (rel->r_info))
6197         {
6198         case R_FRV_GETTLSOFF:
6199         case R_FRV_TLSDESC_VALUE:
6200         case R_FRV_GOTTLSDESC12:
6201         case R_FRV_GOTTLSDESCHI:
6202         case R_FRV_GOTTLSDESCLO:
6203         case R_FRV_GOTTLSOFF12:
6204         case R_FRV_GOTTLSOFFHI:
6205         case R_FRV_GOTTLSOFFLO:
6206         case R_FRV_TLSOFF:
6207         case R_FRV_GOT12:
6208         case R_FRV_GOTHI:
6209         case R_FRV_GOTLO:
6210         case R_FRV_FUNCDESC_GOT12:
6211         case R_FRV_FUNCDESC_GOTHI:
6212         case R_FRV_FUNCDESC_GOTLO:
6213         case R_FRV_GOTOFF12:
6214         case R_FRV_GOTOFFHI:
6215         case R_FRV_GOTOFFLO:
6216         case R_FRV_FUNCDESC_GOTOFF12:
6217         case R_FRV_FUNCDESC_GOTOFFHI:
6218         case R_FRV_FUNCDESC_GOTOFFLO:
6219         case R_FRV_FUNCDESC:
6220         case R_FRV_FUNCDESC_VALUE:
6221         case R_FRV_TLSMOFF12:
6222         case R_FRV_TLSMOFFHI:
6223         case R_FRV_TLSMOFFLO:
6224         case R_FRV_TLSMOFF:
6225           if (! IS_FDPIC (abfd))
6226             goto bad_reloc;
6227           /* Fall through.  */
6228         case R_FRV_GPREL12:
6229         case R_FRV_GPRELU12:
6230         case R_FRV_GPRELHI:
6231         case R_FRV_GPRELLO:
6232         case R_FRV_LABEL24:
6233         case R_FRV_32:
6234           if (! dynobj)
6235             {
6236               elf_hash_table (info)->dynobj = dynobj = abfd;
6237               if (! _frv_create_got_section (abfd, info))
6238                 return FALSE;
6239             }
6240           if (! IS_FDPIC (abfd))
6241             {
6242               picrel = NULL;
6243               break;
6244             }
6245           if (h != NULL)
6246             {
6247               if (h->dynindx == -1)
6248                 switch (ELF_ST_VISIBILITY (h->other))
6249                   {
6250                   case STV_INTERNAL:
6251                   case STV_HIDDEN:
6252                     break;
6253                   default:
6254                     bfd_elf_link_record_dynamic_symbol (info, h);
6255                     break;
6256                   }
6257               picrel
6258                 = frvfdpic_relocs_info_for_global (frvfdpic_relocs_info (info),
6259                                                    abfd, h,
6260                                                    rel->r_addend, INSERT);
6261             }
6262           else
6263             picrel = frvfdpic_relocs_info_for_local (frvfdpic_relocs_info
6264                                                      (info), abfd, r_symndx,
6265                                                      rel->r_addend, INSERT);
6266           if (! picrel)
6267             return FALSE;
6268           break;
6269
6270         default:
6271           picrel = NULL;
6272           break;
6273         }
6274
6275       switch (ELF32_R_TYPE (rel->r_info))
6276         {
6277         case R_FRV_LABEL24:
6278           if (IS_FDPIC (abfd))
6279             picrel->call = 1;
6280           break;
6281
6282         case R_FRV_FUNCDESC_VALUE:
6283           picrel->relocsfdv++;
6284           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6285             picrel->relocs32--;
6286           /* Fall through.  */
6287
6288         case R_FRV_32:
6289           if (! IS_FDPIC (abfd))
6290             break;
6291
6292           picrel->sym = 1;
6293           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
6294             picrel->relocs32++;
6295           break;
6296
6297         case R_FRV_GOT12:
6298           picrel->got12 = 1;
6299           break;
6300
6301         case R_FRV_GOTHI:
6302         case R_FRV_GOTLO:
6303           picrel->gothilo = 1;
6304           break;
6305
6306         case R_FRV_FUNCDESC_GOT12:
6307           picrel->fdgot12 = 1;
6308           break;
6309
6310         case R_FRV_FUNCDESC_GOTHI:
6311         case R_FRV_FUNCDESC_GOTLO:
6312           picrel->fdgothilo = 1;
6313           break;
6314
6315         case R_FRV_GOTOFF12:
6316         case R_FRV_GOTOFFHI:
6317         case R_FRV_GOTOFFLO:
6318           picrel->gotoff = 1;
6319           break;
6320
6321         case R_FRV_FUNCDESC_GOTOFF12:
6322           picrel->fdgoff12 = 1;
6323           break;
6324
6325         case R_FRV_FUNCDESC_GOTOFFHI:
6326         case R_FRV_FUNCDESC_GOTOFFLO:
6327           picrel->fdgoffhilo = 1;
6328           break;
6329
6330         case R_FRV_FUNCDESC:
6331           picrel->fd = 1;
6332           picrel->relocsfd++;
6333           break;
6334
6335         case R_FRV_GETTLSOFF:
6336           picrel->tlsplt = 1;
6337           break;
6338
6339         case R_FRV_TLSDESC_VALUE:
6340           picrel->relocstlsd++;
6341           goto bad_reloc;
6342
6343         case R_FRV_GOTTLSDESC12:
6344           picrel->tlsdesc12 = 1;
6345           break;
6346
6347         case R_FRV_GOTTLSDESCHI:
6348         case R_FRV_GOTTLSDESCLO:
6349           picrel->tlsdeschilo = 1;
6350           break;
6351
6352         case R_FRV_TLSMOFF12:
6353         case R_FRV_TLSMOFFHI:
6354         case R_FRV_TLSMOFFLO:
6355         case R_FRV_TLSMOFF:
6356           break;
6357
6358         case R_FRV_GOTTLSOFF12:
6359           picrel->tlsoff12 = 1;
6360           info->flags |= DF_STATIC_TLS;
6361           break;
6362
6363         case R_FRV_GOTTLSOFFHI:
6364         case R_FRV_GOTTLSOFFLO:
6365           picrel->tlsoffhilo = 1;
6366           info->flags |= DF_STATIC_TLS;
6367           break;
6368
6369         case R_FRV_TLSOFF:
6370           picrel->relocstlsoff++;
6371           info->flags |= DF_STATIC_TLS;
6372           goto bad_reloc;
6373
6374         /* This relocation describes the C++ object vtable hierarchy.
6375            Reconstruct it for later use during GC.  */
6376         case R_FRV_GNU_VTINHERIT:
6377           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
6378             return FALSE;
6379           break;
6380
6381         /* This relocation describes which C++ vtable entries are actually
6382            used.  Record for later use during GC.  */
6383         case R_FRV_GNU_VTENTRY:
6384           BFD_ASSERT (h != NULL);
6385           if (h != NULL
6386               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
6387             return FALSE;
6388           break;
6389
6390         case R_FRV_LABEL16:
6391         case R_FRV_LO16:
6392         case R_FRV_HI16:
6393         case R_FRV_GPREL12:
6394         case R_FRV_GPRELU12:
6395         case R_FRV_GPREL32:
6396         case R_FRV_GPRELHI:
6397         case R_FRV_GPRELLO:
6398         case R_FRV_TLSDESC_RELAX:
6399         case R_FRV_GETTLSOFF_RELAX:
6400         case R_FRV_TLSOFF_RELAX:
6401           break;
6402
6403         default:
6404         bad_reloc:
6405           (*_bfd_error_handler)
6406             (_("%B: unsupported relocation type %i"),
6407              abfd, ELF32_R_TYPE (rel->r_info));
6408           return FALSE;
6409         }
6410     }
6411
6412   return TRUE;
6413 }
6414
6415 \f
6416 /* Return the machine subcode from the ELF e_flags header.  */
6417
6418 static int
6419 elf32_frv_machine (abfd)
6420      bfd *abfd;
6421 {
6422   switch (elf_elfheader (abfd)->e_flags & EF_FRV_CPU_MASK)
6423     {
6424     default:                break;
6425     case EF_FRV_CPU_FR550:  return bfd_mach_fr550;
6426     case EF_FRV_CPU_FR500:  return bfd_mach_fr500;
6427     case EF_FRV_CPU_FR450:  return bfd_mach_fr450;
6428     case EF_FRV_CPU_FR405:  return bfd_mach_fr400;
6429     case EF_FRV_CPU_FR400:  return bfd_mach_fr400;
6430     case EF_FRV_CPU_FR300:  return bfd_mach_fr300;
6431     case EF_FRV_CPU_SIMPLE: return bfd_mach_frvsimple;
6432     case EF_FRV_CPU_TOMCAT: return bfd_mach_frvtomcat;
6433     }
6434
6435   return bfd_mach_frv;
6436 }
6437
6438 /* Set the right machine number for a FRV ELF file.  */
6439
6440 static bfd_boolean
6441 elf32_frv_object_p (abfd)
6442      bfd *abfd;
6443 {
6444   bfd_default_set_arch_mach (abfd, bfd_arch_frv, elf32_frv_machine (abfd));
6445   return (((elf_elfheader (abfd)->e_flags & EF_FRV_FDPIC) != 0)
6446           == (IS_FDPIC (abfd)));
6447 }
6448 \f
6449 /* Function to set the ELF flag bits.  */
6450
6451 static bfd_boolean
6452 frv_elf_set_private_flags (abfd, flags)
6453      bfd *abfd;
6454      flagword flags;
6455 {
6456   elf_elfheader (abfd)->e_flags = flags;
6457   elf_flags_init (abfd) = TRUE;
6458   return TRUE;
6459 }
6460
6461 /* Copy backend specific data from one object module to another.  */
6462
6463 static bfd_boolean
6464 frv_elf_copy_private_bfd_data (ibfd, obfd)
6465      bfd *ibfd;
6466      bfd *obfd;
6467 {
6468   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6469       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6470     return TRUE;
6471
6472   BFD_ASSERT (!elf_flags_init (obfd)
6473               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
6474
6475   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
6476   elf_flags_init (obfd) = TRUE;
6477
6478   /* Copy object attributes.  */
6479   _bfd_elf_copy_obj_attributes (ibfd, obfd);
6480
6481   return TRUE;
6482 }
6483
6484 /* Return true if the architecture described by elf header flag
6485    EXTENSION is an extension of the architecture described by BASE.  */
6486
6487 static bfd_boolean
6488 frv_elf_arch_extension_p (flagword base, flagword extension)
6489 {
6490   if (base == extension)
6491     return TRUE;
6492
6493   /* CPU_GENERIC code can be merged with code for a specific
6494      architecture, in which case the result is marked as being
6495      for the specific architecture.  Everything is therefore
6496      an extension of CPU_GENERIC.  */
6497   if (base == EF_FRV_CPU_GENERIC)
6498     return TRUE;
6499
6500   if (extension == EF_FRV_CPU_FR450)
6501     if (base == EF_FRV_CPU_FR400 || base == EF_FRV_CPU_FR405)
6502       return TRUE;
6503
6504   if (extension == EF_FRV_CPU_FR405)
6505     if (base == EF_FRV_CPU_FR400)
6506       return TRUE;
6507
6508   return FALSE;
6509 }
6510
6511 static bfd_boolean
6512 elf32_frvfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
6513 {
6514   unsigned i;
6515
6516   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
6517       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
6518     return TRUE;
6519
6520   if (! frv_elf_copy_private_bfd_data (ibfd, obfd))
6521     return FALSE;
6522
6523   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
6524       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
6525     return TRUE;
6526
6527   /* Copy the stack size.  */
6528   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
6529     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
6530       {
6531         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
6532
6533         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
6534           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
6535             {
6536               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
6537
6538               /* Rewrite the phdrs, since we're only called after they
6539                  were first written.  */
6540               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
6541                             ->s->sizeof_ehdr, SEEK_SET) != 0
6542                   || get_elf_backend_data (obfd)->s
6543                   ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
6544                                      elf_elfheader (obfd)->e_phnum) != 0)
6545                 return FALSE;
6546               break;
6547             }
6548
6549         break;
6550       }
6551
6552   return TRUE;
6553 }
6554
6555 /* Merge backend specific data from an object file to the output
6556    object file when linking.  */
6557
6558 static bfd_boolean
6559 frv_elf_merge_private_bfd_data (ibfd, obfd)
6560      bfd *ibfd;
6561      bfd *obfd;
6562 {
6563   flagword old_flags, old_partial;
6564   flagword new_flags, new_partial;
6565   bfd_boolean error = FALSE;
6566   char new_opt[80];
6567   char old_opt[80];
6568
6569   new_opt[0] = old_opt[0] = '\0';
6570   new_flags = elf_elfheader (ibfd)->e_flags;
6571   old_flags = elf_elfheader (obfd)->e_flags;
6572
6573   if (new_flags & EF_FRV_FDPIC)
6574     new_flags &= ~EF_FRV_PIC;
6575
6576 #ifdef DEBUG
6577   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
6578                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
6579                          bfd_get_filename (ibfd));
6580 #endif
6581
6582   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
6583     {
6584       elf_flags_init (obfd) = TRUE;
6585       old_flags = new_flags;
6586     }
6587
6588   else if (new_flags == old_flags)              /* Compatible flags are ok.  */
6589     ;
6590
6591   else                                          /* Possibly incompatible flags.  */
6592     {
6593       /* Warn if different # of gprs are used.  Note, 0 means nothing is
6594          said about the size of gprs.  */
6595       new_partial = (new_flags & EF_FRV_GPR_MASK);
6596       old_partial = (old_flags & EF_FRV_GPR_MASK);
6597       if (new_partial == old_partial)
6598         ;
6599
6600       else if (new_partial == 0)
6601         ;
6602
6603       else if (old_partial == 0)
6604         old_flags |= new_partial;
6605
6606       else
6607         {
6608           switch (new_partial)
6609             {
6610             default:            strcat (new_opt, " -mgpr-??"); break;
6611             case EF_FRV_GPR_32: strcat (new_opt, " -mgpr-32"); break;
6612             case EF_FRV_GPR_64: strcat (new_opt, " -mgpr-64"); break;
6613             }
6614
6615           switch (old_partial)
6616             {
6617             default:            strcat (old_opt, " -mgpr-??"); break;
6618             case EF_FRV_GPR_32: strcat (old_opt, " -mgpr-32"); break;
6619             case EF_FRV_GPR_64: strcat (old_opt, " -mgpr-64"); break;
6620             }
6621         }
6622
6623       /* Warn if different # of fprs are used.  Note, 0 means nothing is
6624          said about the size of fprs.  */
6625       new_partial = (new_flags & EF_FRV_FPR_MASK);
6626       old_partial = (old_flags & EF_FRV_FPR_MASK);
6627       if (new_partial == old_partial)
6628         ;
6629
6630       else if (new_partial == 0)
6631         ;
6632
6633       else if (old_partial == 0)
6634         old_flags |= new_partial;
6635
6636       else
6637         {
6638           switch (new_partial)
6639             {
6640             default:              strcat (new_opt, " -mfpr-?");      break;
6641             case EF_FRV_FPR_32:   strcat (new_opt, " -mfpr-32");     break;
6642             case EF_FRV_FPR_64:   strcat (new_opt, " -mfpr-64");     break;
6643             case EF_FRV_FPR_NONE: strcat (new_opt, " -msoft-float"); break;
6644             }
6645
6646           switch (old_partial)
6647             {
6648             default:              strcat (old_opt, " -mfpr-?");      break;
6649             case EF_FRV_FPR_32:   strcat (old_opt, " -mfpr-32");     break;
6650             case EF_FRV_FPR_64:   strcat (old_opt, " -mfpr-64");     break;
6651             case EF_FRV_FPR_NONE: strcat (old_opt, " -msoft-float"); break;
6652             }
6653         }
6654
6655       /* Warn if different dword support was used.  Note, 0 means nothing is
6656          said about the dword support.  */
6657       new_partial = (new_flags & EF_FRV_DWORD_MASK);
6658       old_partial = (old_flags & EF_FRV_DWORD_MASK);
6659       if (new_partial == old_partial)
6660         ;
6661
6662       else if (new_partial == 0)
6663         ;
6664
6665       else if (old_partial == 0)
6666         old_flags |= new_partial;
6667
6668       else
6669         {
6670           switch (new_partial)
6671             {
6672             default:               strcat (new_opt, " -mdword-?");  break;
6673             case EF_FRV_DWORD_YES: strcat (new_opt, " -mdword");    break;
6674             case EF_FRV_DWORD_NO:  strcat (new_opt, " -mno-dword"); break;
6675             }
6676
6677           switch (old_partial)
6678             {
6679             default:               strcat (old_opt, " -mdword-?");  break;
6680             case EF_FRV_DWORD_YES: strcat (old_opt, " -mdword");    break;
6681             case EF_FRV_DWORD_NO:  strcat (old_opt, " -mno-dword"); break;
6682             }
6683         }
6684
6685       /* Or in flags that accumulate (ie, if one module uses it, mark that the
6686          feature is used.  */
6687       old_flags |= new_flags & (EF_FRV_DOUBLE
6688                                 | EF_FRV_MEDIA
6689                                 | EF_FRV_MULADD
6690                                 | EF_FRV_NON_PIC_RELOCS);
6691
6692       /* If any module was compiled without -G0, clear the G0 bit.  */
6693       old_flags = ((old_flags & ~ EF_FRV_G0)
6694                    | (old_flags & new_flags & EF_FRV_G0));
6695
6696       /* If any module was compiled without -mnopack, clear the mnopack bit.  */
6697       old_flags = ((old_flags & ~ EF_FRV_NOPACK)
6698                    | (old_flags & new_flags & EF_FRV_NOPACK));
6699
6700       /* We don't have to do anything if the pic flags are the same, or the new
6701          module(s) were compiled with -mlibrary-pic.  */
6702       new_partial = (new_flags & EF_FRV_PIC_FLAGS);
6703       old_partial = (old_flags & EF_FRV_PIC_FLAGS);
6704       if ((new_partial == old_partial) || ((new_partial & EF_FRV_LIBPIC) != 0))
6705         ;
6706
6707       /* If the old module(s) were compiled with -mlibrary-pic, copy in the pic
6708          flags if any from the new module.  */
6709       else if ((old_partial & EF_FRV_LIBPIC) != 0)
6710         old_flags = (old_flags & ~ EF_FRV_PIC_FLAGS) | new_partial;
6711
6712       /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
6713       else if (new_partial != 0 && old_partial != 0)
6714         old_flags |= new_partial;
6715
6716       /* One module was compiled for pic and the other was not, see if we have
6717          had any relocations that are not pic-safe.  */
6718       else
6719         {
6720           if ((old_flags & EF_FRV_NON_PIC_RELOCS) == 0)
6721             old_flags |= new_partial;
6722           else
6723             {
6724               old_flags &= ~ EF_FRV_PIC_FLAGS;
6725 #ifndef FRV_NO_PIC_ERROR
6726               error = TRUE;
6727               (*_bfd_error_handler)
6728                 (_("%s: compiled with %s and linked with modules that use non-pic relocations"),
6729                  bfd_get_filename (ibfd),
6730                  (new_flags & EF_FRV_BIGPIC) ? "-fPIC" : "-fpic");
6731 #endif
6732             }
6733         }
6734
6735       /* Warn if different cpu is used (allow a specific cpu to override
6736          the generic cpu).  */
6737       new_partial = (new_flags & EF_FRV_CPU_MASK);
6738       old_partial = (old_flags & EF_FRV_CPU_MASK);
6739       if (frv_elf_arch_extension_p (new_partial, old_partial))
6740         ;
6741
6742       else if (frv_elf_arch_extension_p (old_partial, new_partial))
6743         old_flags = (old_flags & ~EF_FRV_CPU_MASK) | new_partial;
6744
6745       else
6746         {
6747           switch (new_partial)
6748             {
6749             default:                 strcat (new_opt, " -mcpu=?");      break;
6750             case EF_FRV_CPU_GENERIC: strcat (new_opt, " -mcpu=frv");    break;
6751             case EF_FRV_CPU_SIMPLE:  strcat (new_opt, " -mcpu=simple"); break;
6752             case EF_FRV_CPU_FR550:   strcat (new_opt, " -mcpu=fr550");  break;
6753             case EF_FRV_CPU_FR500:   strcat (new_opt, " -mcpu=fr500");  break;
6754             case EF_FRV_CPU_FR450:   strcat (new_opt, " -mcpu=fr450");  break;
6755             case EF_FRV_CPU_FR405:   strcat (new_opt, " -mcpu=fr405");  break;
6756             case EF_FRV_CPU_FR400:   strcat (new_opt, " -mcpu=fr400");  break;
6757             case EF_FRV_CPU_FR300:   strcat (new_opt, " -mcpu=fr300");  break;
6758             case EF_FRV_CPU_TOMCAT:  strcat (new_opt, " -mcpu=tomcat"); break;
6759             }
6760
6761           switch (old_partial)
6762             {
6763             default:                 strcat (old_opt, " -mcpu=?");      break;
6764             case EF_FRV_CPU_GENERIC: strcat (old_opt, " -mcpu=frv");    break;
6765             case EF_FRV_CPU_SIMPLE:  strcat (old_opt, " -mcpu=simple"); break;
6766             case EF_FRV_CPU_FR550:   strcat (old_opt, " -mcpu=fr550");  break;
6767             case EF_FRV_CPU_FR500:   strcat (old_opt, " -mcpu=fr500");  break;
6768             case EF_FRV_CPU_FR450:   strcat (old_opt, " -mcpu=fr450");  break;
6769             case EF_FRV_CPU_FR405:   strcat (old_opt, " -mcpu=fr405");  break;
6770             case EF_FRV_CPU_FR400:   strcat (old_opt, " -mcpu=fr400");  break;
6771             case EF_FRV_CPU_FR300:   strcat (old_opt, " -mcpu=fr300");  break;
6772             case EF_FRV_CPU_TOMCAT:  strcat (old_opt, " -mcpu=tomcat"); break;
6773             }
6774         }
6775
6776       /* Print out any mismatches from above.  */
6777       if (new_opt[0])
6778         {
6779           error = TRUE;
6780           (*_bfd_error_handler)
6781             (_("%s: compiled with %s and linked with modules compiled with %s"),
6782              bfd_get_filename (ibfd), new_opt, old_opt);
6783         }
6784
6785       /* Warn about any other mismatches */
6786       new_partial = (new_flags & ~ EF_FRV_ALL_FLAGS);
6787       old_partial = (old_flags & ~ EF_FRV_ALL_FLAGS);
6788       if (new_partial != old_partial)
6789         {
6790           old_flags |= new_partial;
6791           error = TRUE;
6792           (*_bfd_error_handler)
6793             (_("%s: uses different unknown e_flags (0x%lx) fields than previous modules (0x%lx)"),
6794              bfd_get_filename (ibfd), (long)new_partial, (long)old_partial);
6795         }
6796     }
6797
6798   /* If the cpu is -mcpu=simple, then set the -mnopack bit.  */
6799   if ((old_flags & EF_FRV_CPU_MASK) == EF_FRV_CPU_SIMPLE)
6800     old_flags |= EF_FRV_NOPACK;
6801
6802   /* Update the old flags now with changes made above.  */
6803   old_partial = elf_elfheader (obfd)->e_flags & EF_FRV_CPU_MASK;
6804   elf_elfheader (obfd)->e_flags = old_flags;
6805   if (old_partial != (old_flags & EF_FRV_CPU_MASK))
6806     bfd_default_set_arch_mach (obfd, bfd_arch_frv, elf32_frv_machine (obfd));
6807
6808   if (((new_flags & EF_FRV_FDPIC) == 0)
6809       != (! IS_FDPIC (ibfd)))
6810     {
6811       error = TRUE;
6812       if (IS_FDPIC (obfd))
6813         (*_bfd_error_handler)
6814           (_("%s: cannot link non-fdpic object file into fdpic executable"),
6815            bfd_get_filename (ibfd));
6816       else
6817         (*_bfd_error_handler)
6818           (_("%s: cannot link fdpic object file into non-fdpic executable"),
6819            bfd_get_filename (ibfd));
6820     }
6821
6822   if (error)
6823     bfd_set_error (bfd_error_bad_value);
6824
6825   return !error;
6826 }
6827
6828 \f
6829 bfd_boolean
6830 frv_elf_print_private_bfd_data (abfd, ptr)
6831      bfd *abfd;
6832      PTR ptr;
6833 {
6834   FILE *file = (FILE *) ptr;
6835   flagword flags;
6836
6837   BFD_ASSERT (abfd != NULL && ptr != NULL);
6838
6839   /* Print normal ELF private data.  */
6840   _bfd_elf_print_private_bfd_data (abfd, ptr);
6841
6842   flags = elf_elfheader (abfd)->e_flags;
6843   fprintf (file, _("private flags = 0x%lx:"), (unsigned long) flags);
6844
6845   switch (flags & EF_FRV_CPU_MASK)
6846     {
6847     default:                                                    break;
6848     case EF_FRV_CPU_SIMPLE: fprintf (file, " -mcpu=simple");    break;
6849     case EF_FRV_CPU_FR550:  fprintf (file, " -mcpu=fr550");     break;
6850     case EF_FRV_CPU_FR500:  fprintf (file, " -mcpu=fr500");     break;
6851     case EF_FRV_CPU_FR450:  fprintf (file, " -mcpu=fr450");     break;
6852     case EF_FRV_CPU_FR405:  fprintf (file, " -mcpu=fr405");     break;
6853     case EF_FRV_CPU_FR400:  fprintf (file, " -mcpu=fr400");     break;
6854     case EF_FRV_CPU_FR300:  fprintf (file, " -mcpu=fr300");     break;
6855     case EF_FRV_CPU_TOMCAT: fprintf (file, " -mcpu=tomcat");    break;
6856     }
6857
6858   switch (flags & EF_FRV_GPR_MASK)
6859     {
6860     default:                                                    break;
6861     case EF_FRV_GPR_32: fprintf (file, " -mgpr-32");            break;
6862     case EF_FRV_GPR_64: fprintf (file, " -mgpr-64");            break;
6863     }
6864
6865   switch (flags & EF_FRV_FPR_MASK)
6866     {
6867     default:                                                    break;
6868     case EF_FRV_FPR_32:   fprintf (file, " -mfpr-32");          break;
6869     case EF_FRV_FPR_64:   fprintf (file, " -mfpr-64");          break;
6870     case EF_FRV_FPR_NONE: fprintf (file, " -msoft-float");      break;
6871     }
6872
6873   switch (flags & EF_FRV_DWORD_MASK)
6874     {
6875     default:                                                    break;
6876     case EF_FRV_DWORD_YES: fprintf (file, " -mdword");          break;
6877     case EF_FRV_DWORD_NO:  fprintf (file, " -mno-dword");       break;
6878     }
6879
6880   if (flags & EF_FRV_DOUBLE)
6881     fprintf (file, " -mdouble");
6882
6883   if (flags & EF_FRV_MEDIA)
6884     fprintf (file, " -mmedia");
6885
6886   if (flags & EF_FRV_MULADD)
6887     fprintf (file, " -mmuladd");
6888
6889   if (flags & EF_FRV_PIC)
6890     fprintf (file, " -fpic");
6891
6892   if (flags & EF_FRV_BIGPIC)
6893     fprintf (file, " -fPIC");
6894
6895   if (flags & EF_FRV_LIBPIC)
6896     fprintf (file, " -mlibrary-pic");
6897
6898   if (flags & EF_FRV_FDPIC)
6899     fprintf (file, " -mfdpic");
6900
6901   if (flags & EF_FRV_NON_PIC_RELOCS)
6902     fprintf (file, " non-pic relocations");
6903
6904   if (flags & EF_FRV_G0)
6905     fprintf (file, " -G0");
6906
6907   fputc ('\n', file);
6908   return TRUE;
6909 }
6910
6911 \f
6912 /* Support for core dump NOTE sections.  */
6913
6914 static bfd_boolean
6915 elf32_frv_grok_prstatus (bfd *abfd, Elf_Internal_Note *note)
6916 {
6917   int offset;
6918   unsigned int raw_size;
6919
6920   switch (note->descsz)
6921     {
6922       default:
6923         return FALSE;
6924
6925       /* The Linux/FRV elf_prstatus struct is 268 bytes long.  The other
6926          hardcoded offsets and sizes listed below (and contained within
6927          this lexical block) refer to fields in the target's elf_prstatus
6928          struct.  */
6929       case 268:
6930         /* `pr_cursig' is at offset 12.  */
6931         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
6932
6933         /* `pr_pid' is at offset 24.  */
6934         elf_tdata (abfd)->core_lwpid = bfd_get_32 (abfd, note->descdata + 24);
6935
6936         /* `pr_reg' is at offset 72.  */
6937         offset = 72;
6938
6939         /* Most grok_prstatus implementations set `raw_size' to the size
6940            of the pr_reg field.  For Linux/FRV, we set `raw_size' to be
6941            the size of `pr_reg' plus the size of `pr_exec_fdpic_loadmap'
6942            and `pr_interp_fdpic_loadmap', both of which (by design)
6943            immediately follow `pr_reg'.  This will allow these fields to
6944            be viewed by GDB as registers.
6945
6946            `pr_reg' is 184 bytes long.  `pr_exec_fdpic_loadmap' and
6947            `pr_interp_fdpic_loadmap' are 4 bytes each.  */
6948         raw_size = 184 + 4 + 4;
6949
6950         break;
6951     }
6952
6953   /* Make a ".reg/999" section.  */
6954   return _bfd_elfcore_make_pseudosection (abfd, ".reg", raw_size,
6955                                           note->descpos + offset);
6956 }
6957
6958 static bfd_boolean
6959 elf32_frv_grok_psinfo (bfd *abfd, Elf_Internal_Note *note)
6960 {
6961   switch (note->descsz)
6962     {
6963       default:
6964         return FALSE;
6965
6966       /* The Linux/FRV elf_prpsinfo struct is 124 bytes long.  */
6967       case 124:
6968
6969         /* `pr_fname' is found at offset 28 and is 16 bytes long.  */
6970         elf_tdata (abfd)->core_program
6971           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
6972
6973         /* `pr_psargs' is found at offset 44 and is 80 bytes long.  */
6974         elf_tdata (abfd)->core_command
6975           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
6976     }
6977
6978   /* Note that for some reason, a spurious space is tacked
6979      onto the end of the args in some (at least one anyway)
6980      implementations, so strip it off if it exists.  */
6981
6982   {
6983     char *command = elf_tdata (abfd)->core_command;
6984     int n = strlen (command);
6985
6986     if (0 < n && command[n - 1] == ' ')
6987       command[n - 1] = '\0';
6988   }
6989
6990   return TRUE;
6991 }
6992 #define ELF_ARCH                bfd_arch_frv
6993 #define ELF_TARGET_ID           FRV_ELF_DATA
6994 #define ELF_MACHINE_CODE        EM_CYGNUS_FRV
6995 #define ELF_MAXPAGESIZE         0x1000
6996
6997 #define TARGET_BIG_SYM          bfd_elf32_frv_vec
6998 #define TARGET_BIG_NAME         "elf32-frv"
6999
7000 #define elf_info_to_howto                       frv_info_to_howto_rela
7001 #define elf_backend_relocate_section            elf32_frv_relocate_section
7002 #define elf_backend_gc_mark_hook                elf32_frv_gc_mark_hook
7003 #define elf_backend_check_relocs                elf32_frv_check_relocs
7004 #define elf_backend_object_p                    elf32_frv_object_p
7005 #define elf_backend_add_symbol_hook             elf32_frv_add_symbol_hook
7006
7007 #define elf_backend_can_gc_sections             1
7008 #define elf_backend_rela_normal                 1
7009
7010 #define bfd_elf32_bfd_reloc_type_lookup         frv_reloc_type_lookup
7011 #define bfd_elf32_bfd_reloc_name_lookup frv_reloc_name_lookup
7012 #define bfd_elf32_bfd_set_private_flags         frv_elf_set_private_flags
7013 #define bfd_elf32_bfd_copy_private_bfd_data     frv_elf_copy_private_bfd_data
7014 #define bfd_elf32_bfd_merge_private_bfd_data    frv_elf_merge_private_bfd_data
7015 #define bfd_elf32_bfd_print_private_bfd_data    frv_elf_print_private_bfd_data
7016
7017 #define elf_backend_want_got_sym        1
7018 #define elf_backend_got_header_size     0
7019 #define elf_backend_want_got_plt        0
7020 #define elf_backend_plt_readonly        1
7021 #define elf_backend_want_plt_sym        0
7022 #define elf_backend_plt_header_size     0
7023
7024 #define elf_backend_finish_dynamic_sections \
7025                 elf32_frv_finish_dynamic_sections
7026
7027 #define elf_backend_grok_prstatus       elf32_frv_grok_prstatus
7028 #define elf_backend_grok_psinfo         elf32_frv_grok_psinfo
7029
7030 #include "elf32-target.h"
7031
7032 #undef ELF_MAXPAGESIZE
7033 #define ELF_MAXPAGESIZE         0x4000
7034
7035 #undef TARGET_BIG_SYM
7036 #define TARGET_BIG_SYM          bfd_elf32_frvfdpic_vec
7037 #undef TARGET_BIG_NAME
7038 #define TARGET_BIG_NAME         "elf32-frvfdpic"
7039 #undef  elf32_bed
7040 #define elf32_bed               elf32_frvfdpic_bed
7041
7042 #undef elf_info_to_howto_rel
7043 #define elf_info_to_howto_rel   frvfdpic_info_to_howto_rel
7044
7045 #undef bfd_elf32_bfd_link_hash_table_create
7046 #define bfd_elf32_bfd_link_hash_table_create \
7047                 frvfdpic_elf_link_hash_table_create
7048 #undef elf_backend_always_size_sections
7049 #define elf_backend_always_size_sections \
7050                 elf32_frvfdpic_always_size_sections
7051 #undef elf_backend_modify_program_headers
7052 #define elf_backend_modify_program_headers \
7053                 elf32_frvfdpic_modify_program_headers
7054 #undef bfd_elf32_bfd_copy_private_bfd_data
7055 #define bfd_elf32_bfd_copy_private_bfd_data \
7056                 elf32_frvfdpic_copy_private_bfd_data
7057
7058 #undef elf_backend_create_dynamic_sections
7059 #define elf_backend_create_dynamic_sections \
7060                 elf32_frvfdpic_create_dynamic_sections
7061 #undef elf_backend_adjust_dynamic_symbol
7062 #define elf_backend_adjust_dynamic_symbol \
7063                 elf32_frvfdpic_adjust_dynamic_symbol
7064 #undef elf_backend_size_dynamic_sections
7065 #define elf_backend_size_dynamic_sections \
7066                 elf32_frvfdpic_size_dynamic_sections
7067 #undef bfd_elf32_bfd_relax_section
7068 #define bfd_elf32_bfd_relax_section \
7069   elf32_frvfdpic_relax_section
7070 #undef elf_backend_finish_dynamic_symbol
7071 #define elf_backend_finish_dynamic_symbol \
7072                 elf32_frvfdpic_finish_dynamic_symbol
7073 #undef elf_backend_finish_dynamic_sections
7074 #define elf_backend_finish_dynamic_sections \
7075                 elf32_frvfdpic_finish_dynamic_sections
7076
7077 #undef elf_backend_discard_info
7078 #define elf_backend_discard_info \
7079                 frvfdpic_elf_discard_info
7080 #undef elf_backend_can_make_relative_eh_frame
7081 #define elf_backend_can_make_relative_eh_frame \
7082                 frvfdpic_elf_use_relative_eh_frame
7083 #undef elf_backend_can_make_lsda_relative_eh_frame
7084 #define elf_backend_can_make_lsda_relative_eh_frame \
7085                 frvfdpic_elf_use_relative_eh_frame
7086 #undef elf_backend_encode_eh_address
7087 #define elf_backend_encode_eh_address \
7088                 frvfdpic_elf_encode_eh_address
7089
7090 #undef elf_backend_may_use_rel_p
7091 #define elf_backend_may_use_rel_p       1
7092 #undef elf_backend_may_use_rela_p
7093 #define elf_backend_may_use_rela_p      1
7094 /* We use REL for dynamic relocations only.  */
7095 #undef elf_backend_default_use_rela_p
7096 #define elf_backend_default_use_rela_p  1
7097
7098 #undef elf_backend_omit_section_dynsym
7099 #define elf_backend_omit_section_dynsym _frvfdpic_link_omit_section_dynsym
7100
7101 #include "elf32-target.h"