bfd/elf32-frv.c

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