bfd/elf32-frv.c

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