bfd/elf32-frv.c

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