bfd/elf32-bfin.c

   1 /* ADI Blackfin BFD support for 32-bit ELF.
   2    Copyright (C) 2005-2017 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/bfin.h"
  26 #include "dwarf2.h"
  27 #include "hashtab.h"
  28
  29 /* FUNCTION : bfin_pltpc_reloc
  30    ABSTRACT : TODO : figure out how to handle pltpc relocs.  */
  31 static bfd_reloc_status_type
  32 bfin_pltpc_reloc (
  33      bfd *abfd ATTRIBUTE_UNUSED,
  34      arelent *reloc_entry ATTRIBUTE_UNUSED,
  35      asymbol *symbol ATTRIBUTE_UNUSED,
  36      void * data ATTRIBUTE_UNUSED,
  37      asection *input_section ATTRIBUTE_UNUSED,
  38      bfd *output_bfd ATTRIBUTE_UNUSED,
  39      char **error_message ATTRIBUTE_UNUSED)
  40 {
  41   bfd_reloc_status_type flag = bfd_reloc_ok;
  42   return flag;
  43 }
  44 \f
  45
  46 static bfd_reloc_status_type
  47 bfin_pcrel24_reloc (bfd *abfd,
  48                     arelent *reloc_entry,
  49                     asymbol *symbol,
  50                     void * data,
  51                     asection *input_section,
  52                     bfd *output_bfd,
  53                     char **error_message ATTRIBUTE_UNUSED)
  54 {
  55   bfd_vma relocation;
  56   bfd_size_type addr = reloc_entry->address;
  57   bfd_vma output_base = 0;
  58   reloc_howto_type *howto = reloc_entry->howto;
  59   asection *output_section;
  60   bfd_boolean relocatable = (output_bfd != NULL);
  61
  62   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
  63     return bfd_reloc_outofrange;
  64
  65   if (bfd_is_und_section (symbol->section)
  66       && (symbol->flags & BSF_WEAK) == 0
  67       && !relocatable)
  68     return bfd_reloc_undefined;
  69
  70   if (bfd_is_com_section (symbol->section))
  71     relocation = 0;
  72   else
  73     relocation = symbol->value;
  74
  75   output_section = symbol->section->output_section;
  76
  77   if (relocatable)
  78     output_base = 0;
  79   else
  80     output_base = output_section->vma;
  81
  82   if (!relocatable || !strcmp (symbol->name, symbol->section->name))
  83     relocation += output_base + symbol->section->output_offset;
  84
  85   if (!relocatable && !strcmp (symbol->name, symbol->section->name))
  86     relocation += reloc_entry->addend;
  87
  88   relocation -= input_section->output_section->vma + input_section->output_offset;
  89   relocation -= reloc_entry->address;
  90
  91   if (howto->complain_on_overflow != complain_overflow_dont)
  92     {
  93       bfd_reloc_status_type status;
  94       status = bfd_check_overflow (howto->complain_on_overflow,
  95                                    howto->bitsize,
  96                                    howto->rightshift,
  97                                    bfd_arch_bits_per_address(abfd),
  98                                    relocation);
  99       if (status != bfd_reloc_ok)
 100         return status;
 101     }
 102
 103   /* if rightshift is 1 and the number odd, return error.  */
 104   if (howto->rightshift && (relocation & 0x01))
 105     {
 106       _bfd_error_handler (_("relocation should be even number"));
 107       return bfd_reloc_overflow;
 108     }
 109
 110   relocation >>= (bfd_vma) howto->rightshift;
 111   /* Shift everything up to where it's going to be used.  */
 112
 113   relocation <<= (bfd_vma) howto->bitpos;
 114
 115   if (relocatable)
 116     {
 117       reloc_entry->address += input_section->output_offset;
 118       reloc_entry->addend += symbol->section->output_offset;
 119     }
 120
 121   {
 122     short x;
 123
 124     /* We are getting reloc_entry->address 2 byte off from
 125        the start of instruction. Assuming absolute postion
 126        of the reloc data. But, following code had been written assuming
 127        reloc address is starting at begining of instruction.
 128        To compensate that I have increased the value of
 129        relocation by 1 (effectively 2) and used the addr -2 instead of addr.  */
 130
 131     relocation += 1;
 132     x = bfd_get_16 (abfd, (bfd_byte *) data + addr - 2);
 133     x = (x & 0xff00) | ((relocation >> 16) & 0xff);
 134     bfd_put_16 (abfd, x, (unsigned char *) data + addr - 2);
 135
 136     x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 137     x = relocation & 0xFFFF;
 138     bfd_put_16 (abfd, x, (unsigned char *) data + addr );
 139   }
 140   return bfd_reloc_ok;
 141 }
 142
 143 static bfd_reloc_status_type
 144 bfin_imm16_reloc (bfd *abfd,
 145                   arelent *reloc_entry,
 146                   asymbol *symbol,
 147                   void * data,
 148                   asection *input_section,
 149                   bfd *output_bfd,
 150                   char **error_message ATTRIBUTE_UNUSED)
 151 {
 152   bfd_vma relocation, x;
 153   bfd_size_type reloc_addr = reloc_entry->address;
 154   bfd_vma output_base = 0;
 155   reloc_howto_type *howto = reloc_entry->howto;
 156   asection *output_section;
 157   bfd_boolean relocatable = (output_bfd != NULL);
 158
 159   /* Is the address of the relocation really within the section?  */
 160   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 161     return bfd_reloc_outofrange;
 162
 163   if (bfd_is_und_section (symbol->section)
 164       && (symbol->flags & BSF_WEAK) == 0
 165       && !relocatable)
 166     return bfd_reloc_undefined;
 167
 168   output_section = symbol->section->output_section;
 169   relocation = symbol->value;
 170
 171   /* Convert input-section-relative symbol value to absolute.  */
 172   if (relocatable)
 173     output_base = 0;
 174   else
 175     output_base = output_section->vma;
 176
 177   if (!relocatable || !strcmp (symbol->name, symbol->section->name))
 178     relocation += output_base + symbol->section->output_offset;
 179
 180   /* Add in supplied addend.  */
 181   relocation += reloc_entry->addend;
 182
 183   if (relocatable)
 184     {
 185       reloc_entry->address += input_section->output_offset;
 186       reloc_entry->addend += symbol->section->output_offset;
 187     }
 188   else
 189     {
 190       reloc_entry->addend = 0;
 191     }
 192
 193   if (howto->complain_on_overflow != complain_overflow_dont)
 194     {
 195       bfd_reloc_status_type flag;
 196       flag = bfd_check_overflow (howto->complain_on_overflow,
 197                                  howto->bitsize,
 198                                  howto->rightshift,
 199                                  bfd_arch_bits_per_address(abfd),
 200                                  relocation);
 201       if (flag != bfd_reloc_ok)
 202         return flag;
 203     }
 204
 205   /* Here the variable relocation holds the final address of the
 206      symbol we are relocating against, plus any addend.  */
 207
 208   relocation >>= (bfd_vma) howto->rightshift;
 209   x = relocation;
 210   bfd_put_16 (abfd, x, (unsigned char *) data + reloc_addr);
 211   return bfd_reloc_ok;
 212 }
 213
 214
 215 static bfd_reloc_status_type
 216 bfin_byte4_reloc (bfd *abfd,
 217                   arelent *reloc_entry,
 218                   asymbol *symbol,
 219                   void * data,
 220                   asection *input_section,
 221                   bfd *output_bfd,
 222                   char **error_message ATTRIBUTE_UNUSED)
 223 {
 224   bfd_vma relocation, x;
 225   bfd_size_type addr = reloc_entry->address;
 226   bfd_vma output_base = 0;
 227   asection *output_section;
 228   bfd_boolean relocatable = (output_bfd != NULL);
 229
 230   /* Is the address of the relocation really within the section?  */
 231   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 232     return bfd_reloc_outofrange;
 233
 234   if (bfd_is_und_section (symbol->section)
 235       && (symbol->flags & BSF_WEAK) == 0
 236       && !relocatable)
 237     return bfd_reloc_undefined;
 238
 239   output_section = symbol->section->output_section;
 240   relocation = symbol->value;
 241   /* Convert input-section-relative symbol value to absolute.  */
 242   if (relocatable)
 243     output_base = 0;
 244   else
 245     output_base = output_section->vma;
 246
 247   if ((symbol->name
 248        && symbol->section->name
 249        && !strcmp (symbol->name, symbol->section->name))
 250       || !relocatable)
 251     {
 252       relocation += output_base + symbol->section->output_offset;
 253     }
 254
 255   relocation += reloc_entry->addend;
 256
 257   if (relocatable)
 258     {
 259       /* This output will be relocatable ... like ld -r. */
 260       reloc_entry->address += input_section->output_offset;
 261       reloc_entry->addend += symbol->section->output_offset;
 262     }
 263   else
 264     {
 265       reloc_entry->addend = 0;
 266     }
 267
 268   /* Here the variable relocation holds the final address of the
 269      symbol we are relocating against, plus any addend.  */
 270   x = relocation & 0xFFFF0000;
 271   x >>=16;
 272   bfd_put_16 (abfd, x, (unsigned char *) data + addr + 2);
 273
 274   x = relocation & 0x0000FFFF;
 275   bfd_put_16 (abfd, x, (unsigned char *) data + addr);
 276   return bfd_reloc_ok;
 277 }
 278
 279 /* bfin_bfd_reloc handles the blackfin arithmetic relocations.
 280    Use this instead of bfd_perform_relocation.  */
 281 static bfd_reloc_status_type
 282 bfin_bfd_reloc (bfd *abfd,
 283                 arelent *reloc_entry,
 284                 asymbol *symbol,
 285                 void * data,
 286                 asection *input_section,
 287                 bfd *output_bfd,
 288                 char **error_message ATTRIBUTE_UNUSED)
 289 {
 290   bfd_vma relocation;
 291   bfd_size_type addr = reloc_entry->address;
 292   bfd_vma output_base = 0;
 293   reloc_howto_type *howto = reloc_entry->howto;
 294   asection *output_section;
 295   bfd_boolean relocatable = (output_bfd != NULL);
 296
 297   /* Is the address of the relocation really within the section?  */
 298   if (reloc_entry->address > bfd_get_section_limit (abfd, input_section))
 299     return bfd_reloc_outofrange;
 300
 301   if (bfd_is_und_section (symbol->section)
 302       && (symbol->flags & BSF_WEAK) == 0
 303       && !relocatable)
 304     return bfd_reloc_undefined;
 305
 306   /* Get symbol value.  (Common symbols are special.)  */
 307   if (bfd_is_com_section (symbol->section))
 308     relocation = 0;
 309   else
 310     relocation = symbol->value;
 311
 312   output_section = symbol->section->output_section;
 313
 314   /* Convert input-section-relative symbol value to absolute.  */
 315   if (relocatable)
 316     output_base = 0;
 317   else
 318     output_base = output_section->vma;
 319
 320   if (!relocatable || !strcmp (symbol->name, symbol->section->name))
 321     relocation += output_base + symbol->section->output_offset;
 322
 323   if (!relocatable && !strcmp (symbol->name, symbol->section->name))
 324     {
 325       /* Add in supplied addend.  */
 326       relocation += reloc_entry->addend;
 327     }
 328
 329   /* Here the variable relocation holds the final address of the
 330      symbol we are relocating against, plus any addend.  */
 331
 332   if (howto->pc_relative == TRUE)
 333     {
 334       relocation -= input_section->output_section->vma + input_section->output_offset;
 335
 336       if (howto->pcrel_offset == TRUE)
 337         relocation -= reloc_entry->address;
 338     }
 339
 340   if (relocatable)
 341     {
 342       reloc_entry->address += input_section->output_offset;
 343       reloc_entry->addend += symbol->section->output_offset;
 344     }
 345
 346   if (howto->complain_on_overflow != complain_overflow_dont)
 347     {
 348       bfd_reloc_status_type status;
 349
 350       status = bfd_check_overflow (howto->complain_on_overflow,
 351                                   howto->bitsize,
 352                                   howto->rightshift,
 353                                   bfd_arch_bits_per_address(abfd),
 354                                   relocation);
 355       if (status != bfd_reloc_ok)
 356         return status;
 357     }
 358
 359   /* If rightshift is 1 and the number odd, return error.  */
 360   if (howto->rightshift && (relocation & 0x01))
 361     {
 362       _bfd_error_handler (_("relocation should be even number"));
 363       return bfd_reloc_overflow;
 364     }
 365
 366   relocation >>= (bfd_vma) howto->rightshift;
 367
 368   /* Shift everything up to where it's going to be used.  */
 369
 370   relocation <<= (bfd_vma) howto->bitpos;
 371
 372 #define DOIT(x)                                                         \
 373   x = ( (x & ~howto->dst_mask) | (relocation & howto->dst_mask))
 374
 375   /* handle 8 and 16 bit relocations here. */
 376   switch (howto->size)
 377     {
 378     case 0:
 379       {
 380         char x = bfd_get_8 (abfd, (char *) data + addr);
 381         DOIT (x);
 382         bfd_put_8 (abfd, x, (unsigned char *) data + addr);
 383       }
 384       break;
 385
 386     case 1:
 387       {
 388         unsigned short x = bfd_get_16 (abfd, (bfd_byte *) data + addr);
 389         DOIT (x);
 390         bfd_put_16 (abfd, (bfd_vma) x, (unsigned char *) data + addr);
 391       }
 392       break;
 393
 394     default:
 395       return bfd_reloc_other;
 396     }
 397
 398   return bfd_reloc_ok;
 399 }
 400
 401 /* HOWTO Table for blackfin.
 402    Blackfin relocations are fairly complicated.
 403    Some of the salient features are
 404    a. Even numbered offsets. A number of (not all) relocations are
 405       even numbered. This means that the rightmost bit is not stored.
 406       Needs to right shift by 1 and check to see if value is not odd
 407    b. A relocation can be an expression. An expression takes on
 408       a variety of relocations arranged in a stack.
 409    As a result, we cannot use the standard generic function as special
 410    function. We will have our own, which is very similar to the standard
 411    generic function except that it understands how to get the value from
 412    the relocation stack. .  */
 413
 414 #define BFIN_RELOC_MIN 0
 415 #define BFIN_RELOC_MAX 0x21
 416 #define BFIN_GNUEXT_RELOC_MIN 0x40
 417 #define BFIN_GNUEXT_RELOC_MAX 0x43
 418 #define BFIN_ARELOC_MIN 0xE0
 419 #define BFIN_ARELOC_MAX 0xF3
 420
 421 static reloc_howto_type bfin_howto_table [] =
 422 {
 423   /* This reloc does nothing. .  */
 424   HOWTO (R_BFIN_UNUSED0,        /* type.  */
 425          0,                     /* rightshift.  */
 426          3,                     /* size (0 = byte, 1 = short, 2 = long).  */
 427          0,                     /* bitsize.  */
 428          FALSE,                 /* pc_relative.  */
 429          0,                     /* bitpos.  */
 430          complain_overflow_dont, /* complain_on_overflow.  */
 431          bfd_elf_generic_reloc, /* special_function.  */
 432          "R_BFIN_UNUSED0",      /* name.  */
 433          FALSE,                 /* partial_inplace.  */
 434          0,                     /* src_mask.  */
 435          0,                     /* dst_mask.  */
 436          FALSE),                /* pcrel_offset.  */
 437
 438   HOWTO (R_BFIN_PCREL5M2,       /* type.  */
 439          1,                     /* rightshift.  */
 440          1,                     /* size (0 = byte, 1 = short, 2 = long)..  */
 441          4,                     /* bitsize.  */
 442          TRUE,                  /* pc_relative.  */
 443          0,                     /* bitpos.  */
 444          complain_overflow_unsigned, /* complain_on_overflow.  */
 445          bfin_bfd_reloc,        /* special_function.  */
 446          "R_BFIN_PCREL5M2",     /* name.  */
 447          FALSE,                 /* partial_inplace.  */
 448          0,                     /* src_mask.  */
 449          0x0000000F,            /* dst_mask.  */
 450          FALSE),                /* pcrel_offset.  */
 451
 452   HOWTO (R_BFIN_UNUSED1,        /* type.  */
 453          0,                     /* rightshift.  */
 454          3,                     /* size (0 = byte, 1 = short, 2 = long).  */
 455          0,                     /* bitsize.  */
 456          FALSE,                 /* pc_relative.  */
 457          0,                     /* bitpos.  */
 458          complain_overflow_dont, /* complain_on_overflow.  */
 459          bfd_elf_generic_reloc, /* special_function.  */
 460          "R_BFIN_UNUSED1",      /* name.  */
 461          FALSE,                 /* partial_inplace.  */
 462          0,                     /* src_mask.  */
 463          0,                     /* dst_mask.  */
 464          FALSE),                /* pcrel_offset.  */
 465
 466   HOWTO (R_BFIN_PCREL10,        /* type.  */
 467          1,                     /* rightshift.  */
 468          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 469          10,                    /* bitsize.  */
 470          TRUE,                  /* pc_relative.  */
 471          0,                     /* bitpos.  */
 472          complain_overflow_signed, /* complain_on_overflow.  */
 473          bfin_bfd_reloc,        /* special_function.  */
 474          "R_BFIN_PCREL10",      /* name.  */
 475          FALSE,                 /* partial_inplace.  */
 476          0,                     /* src_mask.  */
 477          0x000003FF,            /* dst_mask.  */
 478          TRUE),                 /* pcrel_offset.  */
 479
 480   HOWTO (R_BFIN_PCREL12_JUMP,   /* type.  */
 481          1,                     /* rightshift.  */
 482                                 /* the offset is actually 13 bit
 483                                    aligned on a word boundary so
 484                                    only 12 bits have to be used.
 485                                    Right shift the rightmost bit..  */
 486          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 487          12,                    /* bitsize.  */
 488          TRUE,                  /* pc_relative.  */
 489          0,                     /* bitpos.  */
 490          complain_overflow_signed, /* complain_on_overflow.  */
 491          bfin_bfd_reloc,        /* special_function.  */
 492          "R_BFIN_PCREL12_JUMP", /* name.  */
 493          FALSE,                 /* partial_inplace.  */
 494          0,                     /* src_mask.  */
 495          0x0FFF,                /* dst_mask.  */
 496          TRUE),                 /* pcrel_offset.  */
 497
 498   HOWTO (R_BFIN_RIMM16,         /* type.  */
 499          0,                     /* rightshift.  */
 500          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 501          16,                    /* bitsize.  */
 502          FALSE,                 /* pc_relative.  */
 503          0,                     /* bitpos.  */
 504          complain_overflow_signed, /* complain_on_overflow.  */
 505          bfin_imm16_reloc,      /* special_function.  */
 506          "R_BFIN_RIMM16",       /* name.  */
 507          FALSE,                 /* partial_inplace.  */
 508          0,                     /* src_mask.  */
 509          0x0000FFFF,            /* dst_mask.  */
 510          TRUE),                 /* pcrel_offset.  */
 511
 512   HOWTO (R_BFIN_LUIMM16,        /* type.  */
 513          0,                     /* rightshift.  */
 514          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 515          16,                    /* bitsize.  */
 516          FALSE,                 /* pc_relative.  */
 517          0,                     /* bitpos.  */
 518          complain_overflow_dont, /* complain_on_overflow.  */
 519          bfin_imm16_reloc,      /* special_function.  */
 520          "R_BFIN_LUIMM16",      /* name.  */
 521          FALSE,                 /* partial_inplace.  */
 522          0,                     /* src_mask.  */
 523          0x0000FFFF,            /* dst_mask.  */
 524          TRUE),                 /* pcrel_offset.  */
 525
 526   HOWTO (R_BFIN_HUIMM16,        /* type.  */
 527          16,                    /* rightshift.  */
 528          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 529          16,                    /* bitsize.  */
 530          FALSE,                 /* pc_relative.  */
 531          0,                     /* bitpos.  */
 532          complain_overflow_unsigned, /* complain_on_overflow.  */
 533          bfin_imm16_reloc,      /* special_function.  */
 534          "R_BFIN_HUIMM16",      /* name.  */
 535          FALSE,                 /* partial_inplace.  */
 536          0,                     /* src_mask.  */
 537          0x0000FFFF,            /* dst_mask.  */
 538          TRUE),                 /* pcrel_offset.  */
 539
 540   HOWTO (R_BFIN_PCREL12_JUMP_S, /* type.  */
 541          1,                     /* rightshift.  */
 542          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 543          12,                    /* bitsize.  */
 544          TRUE,                  /* pc_relative.  */
 545          0,                     /* bitpos.  */
 546          complain_overflow_signed, /* complain_on_overflow.  */
 547          bfin_bfd_reloc,        /* special_function.  */
 548          "R_BFIN_PCREL12_JUMP_S", /* name.  */
 549          FALSE,                 /* partial_inplace.  */
 550          0,                     /* src_mask.  */
 551          0x00000FFF,            /* dst_mask.  */
 552          TRUE),                 /* pcrel_offset.  */
 553
 554   HOWTO (R_BFIN_PCREL24_JUMP_X, /* type.  */
 555          1,                     /* rightshift.  */
 556          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 557          24,                    /* bitsize.  */
 558          TRUE,                  /* pc_relative.  */
 559          0,                     /* bitpos.  */
 560          complain_overflow_signed, /* complain_on_overflow.  */
 561          bfin_pcrel24_reloc,    /* special_function.  */
 562         "R_BFIN_PCREL24_JUMP_X", /* name.  */
 563          FALSE,                 /* partial_inplace.  */
 564          0,                     /* src_mask.  */
 565          0x00FFFFFF,            /* dst_mask.  */
 566          TRUE),                 /* pcrel_offset.  */
 567
 568   HOWTO (R_BFIN_PCREL24,        /* type.  */
 569          1,                     /* rightshift.  */
 570          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 571          24,                    /* bitsize.  */
 572          TRUE,                  /* pc_relative.  */
 573          0,                     /* bitpos.  */
 574          complain_overflow_signed, /* complain_on_overflow.  */
 575          bfin_pcrel24_reloc,    /* special_function.  */
 576          "R_BFIN_PCREL24",      /* name.  */
 577          FALSE,                 /* partial_inplace.  */
 578          0,                     /* src_mask.  */
 579          0x00FFFFFF,            /* dst_mask.  */
 580          TRUE),                 /* pcrel_offset.  */
 581
 582   HOWTO (R_BFIN_UNUSEDB,        /* type.  */
 583          0,                     /* rightshift.  */
 584          3,                     /* size (0 = byte, 1 = short, 2 = long).  */
 585          0,                     /* bitsize.  */
 586          FALSE,                 /* pc_relative.  */
 587          0,                     /* bitpos.  */
 588          complain_overflow_dont, /* complain_on_overflow.  */
 589          bfd_elf_generic_reloc, /* special_function.  */
 590          "R_BFIN_UNUSEDB",      /* name.  */
 591          FALSE,                 /* partial_inplace.  */
 592          0,                     /* src_mask.  */
 593          0,                     /* dst_mask.  */
 594          FALSE),                /* pcrel_offset.  */
 595
 596   HOWTO (R_BFIN_UNUSEDC,        /* type.  */
 597          0,                     /* rightshift.  */
 598          3,                     /* size (0 = byte, 1 = short, 2 = long).  */
 599          0,                     /* bitsize.  */
 600          FALSE,                 /* pc_relative.  */
 601          0,                     /* bitpos.  */
 602          complain_overflow_dont, /* complain_on_overflow.  */
 603          bfd_elf_generic_reloc, /* special_function.  */
 604          "R_BFIN_UNUSEDC",      /* name.  */
 605          FALSE,                 /* partial_inplace.  */
 606          0,                     /* src_mask.  */
 607          0,                     /* dst_mask.  */
 608          FALSE),                /* pcrel_offset.  */
 609
 610   HOWTO (R_BFIN_PCREL24_JUMP_L, /* type.  */
 611          1,                     /* rightshift.  */
 612          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 613          24,                    /* bitsize.  */
 614          TRUE,                  /* pc_relative.  */
 615          0,                     /* bitpos.  */
 616          complain_overflow_signed, /* complain_on_overflow.  */
 617          bfin_pcrel24_reloc,    /* special_function.  */
 618          "R_BFIN_PCREL24_JUMP_L", /* name.  */
 619          FALSE,                 /* partial_inplace.  */
 620          0,                     /* src_mask.  */
 621          0x00FFFFFF,            /* dst_mask.  */
 622          TRUE),                 /* pcrel_offset.  */
 623
 624   HOWTO (R_BFIN_PCREL24_CALL_X, /* type.  */
 625          1,                     /* rightshift.  */
 626          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 627          24,                    /* bitsize.  */
 628          TRUE,                  /* pc_relative.  */
 629          0,                     /* bitpos.  */
 630          complain_overflow_signed, /* complain_on_overflow.  */
 631          bfin_pcrel24_reloc,    /* special_function.  */
 632          "R_BFIN_PCREL24_CALL_X", /* name.  */
 633          FALSE,                 /* partial_inplace.  */
 634          0,                     /* src_mask.  */
 635          0x00FFFFFF,            /* dst_mask.  */
 636          TRUE),                 /* pcrel_offset.  */
 637
 638   HOWTO (R_BFIN_VAR_EQ_SYMB,    /* type.  */
 639          0,                     /* rightshift.  */
 640          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 641          32,                    /* bitsize.  */
 642          FALSE,                 /* pc_relative.  */
 643          0,                     /* bitpos.  */
 644          complain_overflow_bitfield, /* complain_on_overflow.  */
 645          bfin_bfd_reloc,        /* special_function.  */
 646          "R_BFIN_VAR_EQ_SYMB",  /* name.  */
 647          FALSE,                 /* partial_inplace.  */
 648          0,                     /* src_mask.  */
 649          0,                     /* dst_mask.  */
 650          FALSE),                /* pcrel_offset.  */
 651
 652   HOWTO (R_BFIN_BYTE_DATA,      /* type.  */
 653          0,                     /* rightshift.  */
 654          0,                     /* size (0 = byte, 1 = short, 2 = long).  */
 655          8,                     /* bitsize.  */
 656          FALSE,                 /* pc_relative.  */
 657          0,                     /* bitpos.  */
 658          complain_overflow_unsigned, /* complain_on_overflow.  */
 659          bfin_bfd_reloc,        /* special_function.  */
 660          "R_BFIN_BYTE_DATA",    /* name.  */
 661          FALSE,                 /* partial_inplace.  */
 662          0,                     /* src_mask.  */
 663          0xFF,                  /* dst_mask.  */
 664          TRUE),                 /* pcrel_offset.  */
 665
 666   HOWTO (R_BFIN_BYTE2_DATA,     /* type.  */
 667          0,                     /* rightshift.  */
 668          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 669          16,                    /* bitsize.  */
 670          FALSE,                 /* pc_relative.  */
 671          0,                     /* bitpos.  */
 672          complain_overflow_signed, /* complain_on_overflow.  */
 673          bfin_bfd_reloc,        /* special_function.  */
 674          "R_BFIN_BYTE2_DATA",   /* name.  */
 675          FALSE,                 /* partial_inplace.  */
 676          0,                     /* src_mask.  */
 677          0xFFFF,                /* dst_mask.  */
 678          TRUE),                 /* pcrel_offset.  */
 679
 680   HOWTO (R_BFIN_BYTE4_DATA,     /* type.  */
 681          0,                     /* rightshift.  */
 682          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 683          32,                    /* bitsize.  */
 684          FALSE,                 /* pc_relative.  */
 685          0,                     /* bitpos.  */
 686          complain_overflow_unsigned, /* complain_on_overflow.  */
 687          bfin_byte4_reloc,      /* special_function.  */
 688          "R_BFIN_BYTE4_DATA",   /* name.  */
 689          FALSE,                 /* partial_inplace.  */
 690          0,                     /* src_mask.  */
 691          0xFFFFFFFF,            /* dst_mask.  */
 692          TRUE),                 /* pcrel_offset.  */
 693
 694   HOWTO (R_BFIN_PCREL11,        /* type.  */
 695          1,                     /* rightshift.  */
 696          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 697          10,                    /* bitsize.  */
 698          TRUE,                  /* pc_relative.  */
 699          0,                     /* bitpos.  */
 700          complain_overflow_unsigned, /* complain_on_overflow.  */
 701          bfin_bfd_reloc,        /* special_function.  */
 702          "R_BFIN_PCREL11",      /* name.  */
 703          FALSE,                 /* partial_inplace.  */
 704          0,                     /* src_mask.  */
 705          0x000003FF,            /* dst_mask.  */
 706          FALSE),                /* pcrel_offset.  */
 707
 708
 709   /* A 18-bit signed operand with the GOT offset for the address of
 710      the symbol.  */
 711   HOWTO (R_BFIN_GOT17M4,        /* type */
 712          2,                     /* rightshift */
 713          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 714          16,                    /* bitsize */
 715          FALSE,                 /* pc_relative */
 716          0,                     /* bitpos */
 717          complain_overflow_signed, /* complain_on_overflow */
 718          bfd_elf_generic_reloc, /* special_function */
 719          "R_BFIN_GOT17M4",      /* name */
 720          FALSE,                 /* partial_inplace */
 721          0xffff,                /* src_mask */
 722          0xffff,                /* dst_mask */
 723          FALSE),                /* pcrel_offset */
 724
 725   /* The upper 16 bits of the GOT offset for the address of the
 726      symbol.  */
 727   HOWTO (R_BFIN_GOTHI,          /* type */
 728          0,                     /* rightshift */
 729          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 730          16,                    /* bitsize */
 731          FALSE,                 /* pc_relative */
 732          0,                     /* bitpos */
 733          complain_overflow_dont, /* complain_on_overflow */
 734          bfd_elf_generic_reloc, /* special_function */
 735          "R_BFIN_GOTHI",                /* name */
 736          FALSE,                 /* partial_inplace */
 737          0xffff,                        /* src_mask */
 738          0xffff,                /* dst_mask */
 739          FALSE),                /* pcrel_offset */
 740
 741   /* The lower 16 bits of the GOT offset for the address of the
 742      symbol.  */
 743   HOWTO (R_BFIN_GOTLO,          /* type */
 744          0,                     /* rightshift */
 745          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 746          16,                    /* bitsize */
 747          FALSE,                 /* pc_relative */
 748          0,                     /* bitpos */
 749          complain_overflow_dont, /* complain_on_overflow */
 750          bfd_elf_generic_reloc, /* special_function */
 751          "R_BFIN_GOTLO",                /* name */
 752          FALSE,                 /* partial_inplace */
 753          0xffff,                /* src_mask */
 754          0xffff,                /* dst_mask */
 755          FALSE),                /* pcrel_offset */
 756
 757   /* The 32-bit address of the canonical descriptor of a function.  */
 758   HOWTO (R_BFIN_FUNCDESC,       /* type */
 759          0,                     /* rightshift */
 760          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 761          32,                    /* bitsize */
 762          FALSE,                 /* pc_relative */
 763          0,                     /* bitpos */
 764          complain_overflow_bitfield, /* complain_on_overflow */
 765          bfd_elf_generic_reloc, /* special_function */
 766          "R_BFIN_FUNCDESC",     /* name */
 767          FALSE,                 /* partial_inplace */
 768          0xffffffff,            /* src_mask */
 769          0xffffffff,            /* dst_mask */
 770          FALSE),                /* pcrel_offset */
 771
 772   /* A 12-bit signed operand with the GOT offset for the address of
 773      canonical descriptor of a function.  */
 774   HOWTO (R_BFIN_FUNCDESC_GOT17M4,       /* type */
 775          2,                     /* rightshift */
 776          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 777          16,                    /* bitsize */
 778          FALSE,                 /* pc_relative */
 779          0,                     /* bitpos */
 780          complain_overflow_signed, /* complain_on_overflow */
 781          bfd_elf_generic_reloc, /* special_function */
 782          "R_BFIN_FUNCDESC_GOT17M4", /* name */
 783          FALSE,                 /* partial_inplace */
 784          0xffff,                /* src_mask */
 785          0xffff,                /* dst_mask */
 786          FALSE),                /* pcrel_offset */
 787
 788   /* The upper 16 bits of the GOT offset for the address of the
 789      canonical descriptor of a function.  */
 790   HOWTO (R_BFIN_FUNCDESC_GOTHI, /* type */
 791          0,                     /* rightshift */
 792          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 793          16,                    /* bitsize */
 794          FALSE,                 /* pc_relative */
 795          0,                     /* bitpos */
 796          complain_overflow_dont, /* complain_on_overflow */
 797          bfd_elf_generic_reloc, /* special_function */
 798          "R_BFIN_FUNCDESC_GOTHI", /* name */
 799          FALSE,                 /* partial_inplace */
 800          0xffff,                /* src_mask */
 801          0xffff,                /* dst_mask */
 802          FALSE),                /* pcrel_offset */
 803
 804   /* The lower 16 bits of the GOT offset for the address of the
 805      canonical descriptor of a function.  */
 806   HOWTO (R_BFIN_FUNCDESC_GOTLO, /* type */
 807          0,                     /* rightshift */
 808          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 809          16,                    /* bitsize */
 810          FALSE,                 /* pc_relative */
 811          0,                     /* bitpos */
 812          complain_overflow_dont, /* complain_on_overflow */
 813          bfd_elf_generic_reloc, /* special_function */
 814          "R_BFIN_FUNCDESC_GOTLO", /* name */
 815          FALSE,                 /* partial_inplace */
 816          0xffff,                /* src_mask */
 817          0xffff,                /* dst_mask */
 818          FALSE),                /* pcrel_offset */
 819
 820   /* The 32-bit address of the canonical descriptor of a function.  */
 821   HOWTO (R_BFIN_FUNCDESC_VALUE, /* type */
 822          0,                     /* rightshift */
 823          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 824          64,                    /* bitsize */
 825          FALSE,                 /* pc_relative */
 826          0,                     /* bitpos */
 827          complain_overflow_bitfield, /* complain_on_overflow */
 828          bfd_elf_generic_reloc, /* special_function */
 829          "R_BFIN_FUNCDESC_VALUE", /* name */
 830          FALSE,                 /* partial_inplace */
 831          0xffffffff,            /* src_mask */
 832          0xffffffff,            /* dst_mask */
 833          FALSE),                /* pcrel_offset */
 834
 835   /* A 12-bit signed operand with the GOT offset for the address of
 836      canonical descriptor of a function.  */
 837   HOWTO (R_BFIN_FUNCDESC_GOTOFF17M4, /* type */
 838          2,                     /* rightshift */
 839          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 840          16,                    /* bitsize */
 841          FALSE,                 /* pc_relative */
 842          0,                     /* bitpos */
 843          complain_overflow_signed, /* complain_on_overflow */
 844          bfd_elf_generic_reloc, /* special_function */
 845          "R_BFIN_FUNCDESC_GOTOFF17M4", /* name */
 846          FALSE,                 /* partial_inplace */
 847          0xffff,                /* src_mask */
 848          0xffff,                /* dst_mask */
 849          FALSE),                /* pcrel_offset */
 850
 851   /* The upper 16 bits of the GOT offset for the address of the
 852      canonical descriptor of a function.  */
 853   HOWTO (R_BFIN_FUNCDESC_GOTOFFHI, /* type */
 854          0,                     /* rightshift */
 855          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 856          16,                    /* bitsize */
 857          FALSE,                 /* pc_relative */
 858          0,                     /* bitpos */
 859          complain_overflow_dont, /* complain_on_overflow */
 860          bfd_elf_generic_reloc, /* special_function */
 861          "R_BFIN_FUNCDESC_GOTOFFHI", /* name */
 862          FALSE,                 /* partial_inplace */
 863          0xffff,                /* src_mask */
 864          0xffff,                /* dst_mask */
 865          FALSE),                /* pcrel_offset */
 866
 867   /* The lower 16 bits of the GOT offset for the address of the
 868      canonical descriptor of a function.  */
 869   HOWTO (R_BFIN_FUNCDESC_GOTOFFLO, /* type */
 870          0,                     /* rightshift */
 871          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 872          16,                    /* bitsize */
 873          FALSE,                 /* pc_relative */
 874          0,                     /* bitpos */
 875          complain_overflow_dont, /* complain_on_overflow */
 876          bfd_elf_generic_reloc, /* special_function */
 877          "R_BFIN_FUNCDESC_GOTOFFLO", /* name */
 878          FALSE,                 /* partial_inplace */
 879          0xffff,                /* src_mask */
 880          0xffff,                /* dst_mask */
 881          FALSE),                /* pcrel_offset */
 882
 883   /* A 12-bit signed operand with the GOT offset for the address of
 884      the symbol.  */
 885   HOWTO (R_BFIN_GOTOFF17M4,     /* type */
 886          2,                     /* rightshift */
 887          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 888          16,                    /* bitsize */
 889          FALSE,                 /* pc_relative */
 890          0,                     /* bitpos */
 891          complain_overflow_signed, /* complain_on_overflow */
 892          bfd_elf_generic_reloc, /* special_function */
 893          "R_BFIN_GOTOFF17M4",   /* name */
 894          FALSE,                 /* partial_inplace */
 895          0xffff,                /* src_mask */
 896          0xffff,                /* dst_mask */
 897          FALSE),                /* pcrel_offset */
 898
 899   /* The upper 16 bits of the GOT offset for the address of the
 900      symbol.  */
 901   HOWTO (R_BFIN_GOTOFFHI,        /* type */
 902          0,                     /* rightshift */
 903          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 904          16,                    /* bitsize */
 905          FALSE,                 /* pc_relative */
 906          0,                     /* bitpos */
 907          complain_overflow_dont, /* complain_on_overflow */
 908          bfd_elf_generic_reloc, /* special_function */
 909          "R_BFIN_GOTOFFHI",     /* name */
 910          FALSE,                 /* partial_inplace */
 911          0xffff,                /* src_mask */
 912          0xffff,                /* dst_mask */
 913          FALSE),                /* pcrel_offset */
 914
 915   /* The lower 16 bits of the GOT offset for the address of the
 916      symbol.  */
 917   HOWTO (R_BFIN_GOTOFFLO,       /* type */
 918          0,                     /* rightshift */
 919          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 920          16,                    /* bitsize */
 921          FALSE,                 /* pc_relative */
 922          0,                     /* bitpos */
 923          complain_overflow_dont, /* complain_on_overflow */
 924          bfd_elf_generic_reloc, /* special_function */
 925          "R_BFIN_GOTOFFLO",     /* name */
 926          FALSE,                 /* partial_inplace */
 927          0xffff,                /* src_mask */
 928          0xffff,                /* dst_mask */
 929          FALSE),                /* pcrel_offset */
 930 };
 931
 932 static reloc_howto_type bfin_gnuext_howto_table [] =
 933 {
 934   HOWTO (R_BFIN_PLTPC,          /* type.  */
 935          0,                     /* rightshift.  */
 936          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 937          16,                    /* bitsize.  */
 938          FALSE,                 /* pc_relative.  */
 939          0,                     /* bitpos.  */
 940          complain_overflow_bitfield, /* complain_on_overflow.  */
 941          bfin_pltpc_reloc,      /* special_function.  */
 942          "R_BFIN_PLTPC",        /* name.  */
 943          FALSE,                 /* partial_inplace.  */
 944          0xffff,                /* src_mask.  */
 945          0xffff,                /* dst_mask.  */
 946          FALSE),                /* pcrel_offset.  */
 947
 948   HOWTO (R_BFIN_GOT,            /* type.  */
 949          0,                     /* rightshift.  */
 950          1,                     /* size (0 = byte, 1 = short, 2 = long).  */
 951          16,                    /* bitsize.  */
 952          FALSE,                 /* pc_relative.  */
 953          0,                     /* bitpos.  */
 954          complain_overflow_bitfield, /* complain_on_overflow.  */
 955          bfd_elf_generic_reloc, /* special_function.  */
 956          "R_BFIN_GOT",          /* name.  */
 957          FALSE,                 /* partial_inplace.  */
 958          0x7fff,                /* src_mask.  */
 959          0x7fff,                /* dst_mask.  */
 960          FALSE),                /* pcrel_offset.  */
 961
 962 /* GNU extension to record C++ vtable hierarchy.  */
 963   HOWTO (R_BFIN_GNU_VTINHERIT, /* type.  */
 964          0,                     /* rightshift.  */
 965          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 966          0,                     /* bitsize.  */
 967          FALSE,                 /* pc_relative.  */
 968          0,                     /* bitpos.  */
 969          complain_overflow_dont, /* complain_on_overflow.  */
 970          NULL,                  /* special_function.  */
 971          "R_BFIN_GNU_VTINHERIT", /* name.  */
 972          FALSE,                 /* partial_inplace.  */
 973          0,                     /* src_mask.  */
 974          0,                     /* dst_mask.  */
 975          FALSE),                /* pcrel_offset.  */
 976
 977 /* GNU extension to record C++ vtable member usage.  */
 978   HOWTO (R_BFIN_GNU_VTENTRY,    /* type.  */
 979          0,                     /* rightshift.  */
 980          2,                     /* size (0 = byte, 1 = short, 2 = long).  */
 981          0,                     /* bitsize.  */
 982          FALSE,                 /* pc_relative.  */
 983          0,                     /* bitpos.  */
 984          complain_overflow_dont, /* complain_on_overflow.  */
 985          _bfd_elf_rel_vtable_reloc_fn, /* special_function.  */
 986          "R_BFIN_GNU_VTENTRY",  /* name.  */
 987          FALSE,                 /* partial_inplace.  */
 988          0,                     /* src_mask.  */
 989          0,                     /* dst_mask.  */
 990          FALSE)                 /* pcrel_offset.  */
 991 };
 992
 993 struct bfin_reloc_map
 994 {
 995   bfd_reloc_code_real_type      bfd_reloc_val;
 996   unsigned int                  bfin_reloc_val;
 997 };
 998
 999 static const struct bfin_reloc_map bfin_reloc_map [] =
1000 {
1001   { BFD_RELOC_NONE,                     R_BFIN_UNUSED0 },
1002   { BFD_RELOC_BFIN_5_PCREL,             R_BFIN_PCREL5M2 },
1003   { BFD_RELOC_NONE,                     R_BFIN_UNUSED1 },
1004   { BFD_RELOC_BFIN_10_PCREL,            R_BFIN_PCREL10 },
1005   { BFD_RELOC_BFIN_12_PCREL_JUMP,       R_BFIN_PCREL12_JUMP },
1006   { BFD_RELOC_BFIN_16_IMM,              R_BFIN_RIMM16 },
1007   { BFD_RELOC_BFIN_16_LOW,              R_BFIN_LUIMM16 },
1008   { BFD_RELOC_BFIN_16_HIGH,             R_BFIN_HUIMM16 },
1009   { BFD_RELOC_BFIN_12_PCREL_JUMP_S,     R_BFIN_PCREL12_JUMP_S },
1010   { BFD_RELOC_24_PCREL,                 R_BFIN_PCREL24 },
1011   { BFD_RELOC_24_PCREL,                 R_BFIN_PCREL24 },
1012   { BFD_RELOC_BFIN_24_PCREL_JUMP_L,     R_BFIN_PCREL24_JUMP_L },
1013   { BFD_RELOC_NONE,                     R_BFIN_UNUSEDB },
1014   { BFD_RELOC_NONE,                     R_BFIN_UNUSEDC },
1015   { BFD_RELOC_BFIN_24_PCREL_CALL_X,     R_BFIN_PCREL24_CALL_X },
1016   { BFD_RELOC_8,                        R_BFIN_BYTE_DATA },
1017   { BFD_RELOC_16,                       R_BFIN_BYTE2_DATA },
1018   { BFD_RELOC_32,                       R_BFIN_BYTE4_DATA },
1019   { BFD_RELOC_BFIN_11_PCREL,            R_BFIN_PCREL11 },
1020   { BFD_RELOC_BFIN_GOT,                 R_BFIN_GOT },
1021   { BFD_RELOC_BFIN_PLTPC,               R_BFIN_PLTPC },
1022
1023   { BFD_RELOC_BFIN_GOT17M4,      R_BFIN_GOT17M4 },
1024   { BFD_RELOC_BFIN_GOTHI,      R_BFIN_GOTHI },
1025   { BFD_RELOC_BFIN_GOTLO,      R_BFIN_GOTLO },
1026   { BFD_RELOC_BFIN_FUNCDESC,   R_BFIN_FUNCDESC },
1027   { BFD_RELOC_BFIN_FUNCDESC_GOT17M4, R_BFIN_FUNCDESC_GOT17M4 },
1028   { BFD_RELOC_BFIN_FUNCDESC_GOTHI, R_BFIN_FUNCDESC_GOTHI },
1029   { BFD_RELOC_BFIN_FUNCDESC_GOTLO, R_BFIN_FUNCDESC_GOTLO },
1030   { BFD_RELOC_BFIN_FUNCDESC_VALUE, R_BFIN_FUNCDESC_VALUE },
1031   { BFD_RELOC_BFIN_FUNCDESC_GOTOFF17M4, R_BFIN_FUNCDESC_GOTOFF17M4 },
1032   { BFD_RELOC_BFIN_FUNCDESC_GOTOFFHI, R_BFIN_FUNCDESC_GOTOFFHI },
1033   { BFD_RELOC_BFIN_FUNCDESC_GOTOFFLO, R_BFIN_FUNCDESC_GOTOFFLO },
1034   { BFD_RELOC_BFIN_GOTOFF17M4,   R_BFIN_GOTOFF17M4 },
1035   { BFD_RELOC_BFIN_GOTOFFHI,   R_BFIN_GOTOFFHI },
1036   { BFD_RELOC_BFIN_GOTOFFLO,   R_BFIN_GOTOFFLO },
1037
1038   { BFD_RELOC_VTABLE_INHERIT,           R_BFIN_GNU_VTINHERIT },
1039   { BFD_RELOC_VTABLE_ENTRY,             R_BFIN_GNU_VTENTRY },
1040 };
1041
1042
1043 static void
1044 bfin_info_to_howto (bfd *abfd ATTRIBUTE_UNUSED,
1045                     arelent *cache_ptr,
1046                     Elf_Internal_Rela *dst)
1047 {
1048   unsigned int r_type;
1049
1050   r_type = ELF32_R_TYPE (dst->r_info);
1051
1052   if (r_type <= BFIN_RELOC_MAX)
1053     cache_ptr->howto = &bfin_howto_table [r_type];
1054
1055   else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1056     cache_ptr->howto = &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1057
1058   else
1059     cache_ptr->howto = (reloc_howto_type *) NULL;
1060 }
1061
1062 /* Given a BFD reloc type, return the howto.  */
1063 static reloc_howto_type *
1064 bfin_bfd_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1065                             bfd_reloc_code_real_type code)
1066 {
1067   unsigned int i;
1068   unsigned int r_type = (unsigned int) -1;
1069
1070   for (i = sizeof (bfin_reloc_map) / sizeof (bfin_reloc_map[0]); i--;)
1071     if (bfin_reloc_map[i].bfd_reloc_val == code)
1072       r_type = bfin_reloc_map[i].bfin_reloc_val;
1073
1074   if (r_type <= BFIN_RELOC_MAX)
1075     return &bfin_howto_table [r_type];
1076
1077   else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1078    return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1079
1080   return (reloc_howto_type *) NULL;
1081 }
1082
1083 static reloc_howto_type *
1084 bfin_bfd_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
1085                             const char *r_name)
1086 {
1087   unsigned int i;
1088
1089   for (i = 0;
1090        i < (sizeof (bfin_howto_table)
1091             / sizeof (bfin_howto_table[0]));
1092        i++)
1093     if (bfin_howto_table[i].name != NULL
1094         && strcasecmp (bfin_howto_table[i].name, r_name) == 0)
1095       return &bfin_howto_table[i];
1096
1097   for (i = 0;
1098        i < (sizeof (bfin_gnuext_howto_table)
1099             / sizeof (bfin_gnuext_howto_table[0]));
1100        i++)
1101     if (bfin_gnuext_howto_table[i].name != NULL
1102         && strcasecmp (bfin_gnuext_howto_table[i].name, r_name) == 0)
1103       return &bfin_gnuext_howto_table[i];
1104
1105   return NULL;
1106 }
1107
1108 /* Given a bfin relocation type, return the howto.  */
1109 static reloc_howto_type *
1110 bfin_reloc_type_lookup (bfd * abfd ATTRIBUTE_UNUSED,
1111                         unsigned int r_type)
1112 {
1113   if (r_type <= BFIN_RELOC_MAX)
1114     return &bfin_howto_table [r_type];
1115
1116   else if (r_type >= BFIN_GNUEXT_RELOC_MIN && r_type <= BFIN_GNUEXT_RELOC_MAX)
1117    return &bfin_gnuext_howto_table [r_type - BFIN_GNUEXT_RELOC_MIN];
1118
1119   return (reloc_howto_type *) NULL;
1120 }
1121
1122 /* Set by ld emulation if --code-in-l1.  */
1123 bfd_boolean elf32_bfin_code_in_l1 = 0;
1124
1125 /* Set by ld emulation if --data-in-l1.  */
1126 bfd_boolean elf32_bfin_data_in_l1 = 0;
1127
1128 static void
1129 elf32_bfin_final_write_processing (bfd *abfd,
1130                                    bfd_boolean linker ATTRIBUTE_UNUSED)
1131 {
1132   if (elf32_bfin_code_in_l1)
1133     elf_elfheader (abfd)->e_flags |= EF_BFIN_CODE_IN_L1;
1134   if (elf32_bfin_data_in_l1)
1135     elf_elfheader (abfd)->e_flags |= EF_BFIN_DATA_IN_L1;
1136 }
1137
1138 /* Return TRUE if the name is a local label.
1139    bfin local labels begin with L$.  */
1140 static bfd_boolean
1141 bfin_is_local_label_name (bfd *abfd, const char *label)
1142 {
1143   if (label[0] == 'L' && label[1] == '$' )
1144     return TRUE;
1145
1146   return _bfd_elf_is_local_label_name (abfd, label);
1147 }
1148 \f
1149 /* Look through the relocs for a section during the first phase, and
1150    allocate space in the global offset table or procedure linkage
1151    table.  */
1152
1153 static bfd_boolean
1154 bfin_check_relocs (bfd * abfd,
1155                    struct bfd_link_info *info,
1156                    asection *sec,
1157                    const Elf_Internal_Rela *relocs)
1158 {
1159   bfd *dynobj;
1160   Elf_Internal_Shdr *symtab_hdr;
1161   struct elf_link_hash_entry **sym_hashes;
1162   bfd_signed_vma *local_got_refcounts;
1163   const Elf_Internal_Rela *rel;
1164   const Elf_Internal_Rela *rel_end;
1165   asection *sgot;
1166   asection *srelgot;
1167
1168   if (bfd_link_relocatable (info))
1169     return TRUE;
1170
1171   dynobj = elf_hash_table (info)->dynobj;
1172   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1173   sym_hashes = elf_sym_hashes (abfd);
1174   local_got_refcounts = elf_local_got_refcounts (abfd);
1175
1176   sgot = NULL;
1177   srelgot = NULL;
1178
1179   rel_end = relocs + sec->reloc_count;
1180   for (rel = relocs; rel < rel_end; rel++)
1181     {
1182       unsigned long r_symndx;
1183       struct elf_link_hash_entry *h;
1184
1185       r_symndx = ELF32_R_SYM (rel->r_info);
1186       if (r_symndx < symtab_hdr->sh_info)
1187         h = NULL;
1188       else
1189         {
1190           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1191
1192           /* PR15323, ref flags aren't set for references in the same
1193              object.  */
1194           h->root.non_ir_ref_regular = 1;
1195         }
1196
1197       switch (ELF32_R_TYPE (rel->r_info))
1198         {
1199        /* This relocation describes the C++ object vtable hierarchy.
1200            Reconstruct it for later use during GC.  */
1201         case R_BFIN_GNU_VTINHERIT:
1202           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1203             return FALSE;
1204           break;
1205
1206         /* This relocation describes which C++ vtable entries
1207            are actually used.  Record for later use during GC.  */
1208         case R_BFIN_GNU_VTENTRY:
1209           BFD_ASSERT (h != NULL);
1210           if (h != NULL
1211               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1212             return FALSE;
1213           break;
1214
1215         case R_BFIN_GOT:
1216           if (h != NULL
1217               && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1218             break;
1219           /* Fall through.  */
1220
1221           if (dynobj == NULL)
1222             {
1223               /* Create the .got section.  */
1224               elf_hash_table (info)->dynobj = dynobj = abfd;
1225               if (!_bfd_elf_create_got_section (dynobj, info))
1226                 return FALSE;
1227             }
1228
1229           sgot = elf_hash_table (info)->sgot;
1230           srelgot = elf_hash_table (info)->srelgot;
1231           BFD_ASSERT (sgot != NULL);
1232
1233           if (h != NULL)
1234             {
1235               if (h->got.refcount == 0)
1236                 {
1237                   /* Make sure this symbol is output as a dynamic symbol.  */
1238                   if (h->dynindx == -1 && !h->forced_local)
1239                     {
1240                       if (!bfd_elf_link_record_dynamic_symbol (info, h))
1241                         return FALSE;
1242                     }
1243
1244                   /* Allocate space in the .got section.  */
1245                   sgot->size += 4;
1246                   /* Allocate relocation space.  */
1247                   srelgot->size += sizeof (Elf32_External_Rela);
1248                 }
1249               h->got.refcount++;
1250             }
1251           else
1252             {
1253               /* This is a global offset table entry for a local symbol.  */
1254               if (local_got_refcounts == NULL)
1255                 {
1256                   bfd_size_type size;
1257
1258                   size = symtab_hdr->sh_info;
1259                   size *= sizeof (bfd_signed_vma);
1260                   local_got_refcounts = ((bfd_signed_vma *)
1261                                          bfd_zalloc (abfd, size));
1262                   if (local_got_refcounts == NULL)
1263                     return FALSE;
1264                   elf_local_got_refcounts (abfd) = local_got_refcounts;
1265                 }
1266               if (local_got_refcounts[r_symndx] == 0)
1267                 {
1268                   sgot->size += 4;
1269                   if (bfd_link_pic (info))
1270                     {
1271                       /* If we are generating a shared object, we need to
1272                          output a R_68K_RELATIVE reloc so that the dynamic
1273                          linker can adjust this GOT entry.  */
1274                       srelgot->size += sizeof (Elf32_External_Rela);
1275                     }
1276                 }
1277               local_got_refcounts[r_symndx]++;
1278             }
1279           break;
1280
1281         default:
1282           break;
1283         }
1284     }
1285
1286   return TRUE;
1287 }
1288
1289 static enum elf_reloc_type_class
1290 elf32_bfin_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1291                              const asection *rel_sec ATTRIBUTE_UNUSED,
1292                              const Elf_Internal_Rela * rela)
1293 {
1294   switch ((int) ELF32_R_TYPE (rela->r_info))
1295     {
1296     default:
1297       return reloc_class_normal;
1298     }
1299 }
1300 \f
1301 static bfd_reloc_status_type
1302 bfin_final_link_relocate (Elf_Internal_Rela *rel, reloc_howto_type *howto,
1303                           bfd *input_bfd, asection *input_section,
1304                           bfd_byte *contents, bfd_vma address,
1305                           bfd_vma value, bfd_vma addend)
1306 {
1307   int r_type = ELF32_R_TYPE (rel->r_info);
1308
1309   if (r_type == R_BFIN_PCREL24 || r_type == R_BFIN_PCREL24_JUMP_L)
1310     {
1311       bfd_reloc_status_type r = bfd_reloc_ok;
1312       bfd_vma x;
1313
1314       if (address > bfd_get_section_limit (input_bfd, input_section))
1315         return bfd_reloc_outofrange;
1316
1317       value += addend;
1318
1319       /* Perform usual pc-relative correction.  */
1320       value -= input_section->output_section->vma + input_section->output_offset;
1321       value -= address;
1322
1323       /* We are getting reloc_entry->address 2 byte off from
1324          the start of instruction. Assuming absolute postion
1325          of the reloc data. But, following code had been written assuming
1326          reloc address is starting at begining of instruction.
1327          To compensate that I have increased the value of
1328          relocation by 1 (effectively 2) and used the addr -2 instead of addr.  */
1329
1330       value += 2;
1331       address -= 2;
1332
1333       if ((value & 0xFF000000) != 0
1334           && (value & 0xFF000000) != 0xFF000000)
1335         r = bfd_reloc_overflow;
1336
1337       value >>= 1;
1338
1339       x = bfd_get_16 (input_bfd, contents + address);
1340       x = (x & 0xff00) | ((value >> 16) & 0xff);
1341       bfd_put_16 (input_bfd, x, contents + address);
1342
1343       x = bfd_get_16 (input_bfd, contents + address + 2);
1344       x = value & 0xFFFF;
1345       bfd_put_16 (input_bfd, x, contents + address + 2);
1346       return r;
1347     }
1348
1349   return _bfd_final_link_relocate (howto, input_bfd, input_section, contents,
1350                                    rel->r_offset, value, addend);
1351
1352 }
1353
1354 static bfd_boolean
1355 bfin_relocate_section (bfd * output_bfd,
1356                        struct bfd_link_info *info,
1357                        bfd * input_bfd,
1358                        asection * input_section,
1359                        bfd_byte * contents,
1360                        Elf_Internal_Rela * relocs,
1361                        Elf_Internal_Sym * local_syms,
1362                        asection ** local_sections)
1363 {
1364   bfd *dynobj;
1365   Elf_Internal_Shdr *symtab_hdr;
1366   struct elf_link_hash_entry **sym_hashes;
1367   bfd_vma *local_got_offsets;
1368   asection *sgot;
1369   Elf_Internal_Rela *rel;
1370   Elf_Internal_Rela *relend;
1371   int i = 0;
1372
1373   dynobj = elf_hash_table (info)->dynobj;
1374   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
1375   sym_hashes = elf_sym_hashes (input_bfd);
1376   local_got_offsets = elf_local_got_offsets (input_bfd);
1377
1378   sgot = NULL;
1379
1380   rel = relocs;
1381   relend = relocs + input_section->reloc_count;
1382   for (; rel < relend; rel++, i++)
1383     {
1384       int r_type;
1385       reloc_howto_type *howto;
1386       unsigned long r_symndx;
1387       struct elf_link_hash_entry *h;
1388       Elf_Internal_Sym *sym;
1389       asection *sec;
1390       bfd_vma relocation = 0;
1391       bfd_boolean unresolved_reloc;
1392       bfd_reloc_status_type r;
1393       bfd_vma address;
1394
1395       r_type = ELF32_R_TYPE (rel->r_info);
1396       if (r_type < 0 || r_type >= 243)
1397         {
1398           bfd_set_error (bfd_error_bad_value);
1399           return FALSE;
1400         }
1401
1402       if (r_type == R_BFIN_GNU_VTENTRY
1403           || r_type == R_BFIN_GNU_VTINHERIT)
1404         continue;
1405
1406       howto = bfin_reloc_type_lookup (input_bfd, r_type);
1407       if (howto == NULL)
1408         {
1409           bfd_set_error (bfd_error_bad_value);
1410           return FALSE;
1411         }
1412       r_symndx = ELF32_R_SYM (rel->r_info);
1413
1414       h = NULL;
1415       sym = NULL;
1416       sec = NULL;
1417       unresolved_reloc = FALSE;
1418
1419       if (r_symndx < symtab_hdr->sh_info)
1420         {
1421           sym = local_syms + r_symndx;
1422           sec = local_sections[r_symndx];
1423           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1424         }
1425       else
1426         {
1427           bfd_boolean warned, ignored;
1428
1429           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1430                                    r_symndx, symtab_hdr, sym_hashes,
1431                                    h, sec, relocation,
1432                                    unresolved_reloc, warned, ignored);
1433         }
1434
1435       if (sec != NULL && discarded_section (sec))
1436         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
1437                                          rel, 1, relend, howto, 0, contents);
1438
1439       if (bfd_link_relocatable (info))
1440         continue;
1441
1442       address = rel->r_offset;
1443
1444       /* Then, process normally.  */
1445       switch (r_type)
1446         {
1447         case R_BFIN_GNU_VTINHERIT:
1448         case R_BFIN_GNU_VTENTRY:
1449           return bfd_reloc_ok;
1450
1451         case R_BFIN_GOT:
1452           /* Relocation is to the address of the entry for this symbol
1453              in the global offset table.  */
1454           if (h != NULL
1455               && strcmp (h->root.root.string, "__GLOBAL_OFFSET_TABLE_") == 0)
1456             goto do_default;
1457           /* Fall through.  */
1458           /* Relocation is the offset of the entry for this symbol in
1459              the global offset table.  */
1460
1461           {
1462             bfd_vma off;
1463
1464             if (dynobj == NULL)
1465               {
1466                 /* Create the .got section.  */
1467                 elf_hash_table (info)->dynobj = dynobj = output_bfd;
1468                 if (!_bfd_elf_create_got_section (dynobj, info))
1469                   return FALSE;
1470               }
1471
1472             sgot = elf_hash_table (info)->sgot;
1473             BFD_ASSERT (sgot != NULL);
1474
1475             if (h != NULL)
1476               {
1477                 bfd_boolean dyn;
1478
1479                 off = h->got.offset;
1480                 BFD_ASSERT (off != (bfd_vma) - 1);
1481                 dyn = elf_hash_table (info)->dynamic_sections_created;
1482
1483                 if (!WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
1484                                                       bfd_link_pic (info),
1485                                                       h)
1486                     || (bfd_link_pic (info)
1487                         && (info->symbolic
1488                             || h->dynindx == -1
1489                             || h->forced_local)
1490                         && h->def_regular))
1491                   {
1492                     /* This is actually a static link, or it is a
1493                        -Bsymbolic link and the symbol is defined
1494                        locally, or the symbol was forced to be local
1495                        because of a version file..  We must initialize
1496                        this entry in the global offset table.  Since
1497                        the offset must always be a multiple of 4, we
1498                        use the least significant bit to record whether
1499                        we have initialized it already.
1500
1501                        When doing a dynamic link, we create a .rela.got
1502                        relocation entry to initialize the value.  This
1503                        is done in the finish_dynamic_symbol routine.  */
1504                     if ((off & 1) != 0)
1505                       off &= ~1;
1506                     else
1507                       {
1508                         bfd_put_32 (output_bfd, relocation,
1509                                     sgot->contents + off);
1510                         h->got.offset |= 1;
1511                       }
1512                   }
1513                 else
1514                   unresolved_reloc = FALSE;
1515               }
1516             else
1517               {
1518                 BFD_ASSERT (local_got_offsets != NULL);
1519                 off = local_got_offsets[r_symndx];
1520                 BFD_ASSERT (off != (bfd_vma) - 1);
1521
1522                 /* The offset must always be a multiple of 4.  We use
1523                    the least significant bit to record whether we have
1524                    already generated the necessary reloc.  */
1525                 if ((off & 1) != 0)
1526                   off &= ~1;
1527                 else
1528                   {
1529                     bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1530
1531                     if (bfd_link_pic (info))
1532                       {
1533                         asection *s;
1534                         Elf_Internal_Rela outrel;
1535                         bfd_byte *loc;
1536
1537                         s = elf_hash_table (info)->srelgot;
1538                         BFD_ASSERT (s != NULL);
1539
1540                         outrel.r_offset = (sgot->output_section->vma
1541                                            + sgot->output_offset + off);
1542                         outrel.r_info =
1543                           ELF32_R_INFO (0, R_BFIN_PCREL24);
1544                         outrel.r_addend = relocation;
1545                         loc = s->contents;
1546                         loc +=
1547                           s->reloc_count++ * sizeof (Elf32_External_Rela);
1548                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1549                       }
1550
1551                     local_got_offsets[r_symndx] |= 1;
1552                   }
1553               }
1554
1555             relocation = sgot->output_offset + off;
1556             rel->r_addend = 0;
1557             /* bfin : preg = [preg + 17bitdiv4offset] relocation is div by 4.  */
1558             relocation /= 4;
1559           }
1560           goto do_default;
1561
1562         default:
1563         do_default:
1564           r = bfin_final_link_relocate (rel, howto, input_bfd, input_section,
1565                                         contents, address,
1566                                         relocation, rel->r_addend);
1567
1568           break;
1569         }
1570
1571       /* Dynamic relocs are not propagated for SEC_DEBUGGING sections
1572          because such sections are not SEC_ALLOC and thus ld.so will
1573          not process them.  */
1574       if (unresolved_reloc
1575           && !((input_section->flags & SEC_DEBUGGING) != 0 && h->def_dynamic)
1576           && _bfd_elf_section_offset (output_bfd, info, input_section,
1577                                       rel->r_offset) != (bfd_vma) -1)
1578         {
1579           _bfd_error_handler
1580             /* xgettext:c-format */
1581             (_("%B(%A+0x%lx): unresolvable relocation against symbol `%s'"),
1582              input_bfd,
1583              input_section, (long) rel->r_offset, h->root.root.string);
1584           return FALSE;
1585         }
1586
1587       if (r != bfd_reloc_ok)
1588         {
1589           const char *name;
1590
1591           if (h != NULL)
1592             name = h->root.root.string;
1593           else
1594             {
1595               name = bfd_elf_string_from_elf_section (input_bfd,
1596                                                       symtab_hdr->sh_link,
1597                                                       sym->st_name);
1598               if (name == NULL)
1599                 return FALSE;
1600               if (*name == '\0')
1601                 name = bfd_section_name (input_bfd, sec);
1602             }
1603
1604           if (r == bfd_reloc_overflow)
1605             (*info->callbacks->reloc_overflow)
1606               (info, (h ? &h->root : NULL), name, howto->name,
1607                (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1608           else
1609             {
1610               _bfd_error_handler
1611                 /* xgettext:c-format */
1612                 (_("%B(%A+0x%lx): reloc against `%s': error %d"),
1613                  input_bfd, input_section,
1614                  (long) rel->r_offset, name, (int) r);
1615               return FALSE;
1616             }
1617         }
1618     }
1619
1620   return TRUE;
1621 }
1622
1623 static asection *
1624 bfin_gc_mark_hook (asection * sec,
1625                    struct bfd_link_info *info,
1626                    Elf_Internal_Rela * rel,
1627                    struct elf_link_hash_entry *h,
1628                    Elf_Internal_Sym * sym)
1629 {
1630   if (h != NULL)
1631     switch (ELF32_R_TYPE (rel->r_info))
1632       {
1633       case R_BFIN_GNU_VTINHERIT:
1634       case R_BFIN_GNU_VTENTRY:
1635         return NULL;
1636       }
1637
1638   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1639 }
1640
1641 /* Update the got entry reference counts for the section being removed.  */
1642
1643 static bfd_boolean
1644 bfin_gc_sweep_hook (bfd * abfd,
1645                     struct bfd_link_info *info,
1646                     asection * sec,
1647                     const Elf_Internal_Rela * relocs)
1648 {
1649   Elf_Internal_Shdr *symtab_hdr;
1650   struct elf_link_hash_entry **sym_hashes;
1651   bfd_signed_vma *local_got_refcounts;
1652   const Elf_Internal_Rela *rel, *relend;
1653   bfd *dynobj;
1654   asection *sgot;
1655   asection *srelgot;
1656
1657   dynobj = elf_hash_table (info)->dynobj;
1658   if (dynobj == NULL)
1659     return TRUE;
1660
1661   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1662   sym_hashes = elf_sym_hashes (abfd);
1663   local_got_refcounts = elf_local_got_refcounts (abfd);
1664
1665   sgot = elf_hash_table (info)->sgot;
1666   srelgot = elf_hash_table (info)->srelgot;
1667
1668   relend = relocs + sec->reloc_count;
1669   for (rel = relocs; rel < relend; rel++)
1670     {
1671       unsigned long r_symndx;
1672       struct elf_link_hash_entry *h;
1673
1674       switch (ELF32_R_TYPE (rel->r_info))
1675         {
1676         case R_BFIN_GOT:
1677           r_symndx = ELF32_R_SYM (rel->r_info);
1678           if (r_symndx >= symtab_hdr->sh_info)
1679             {
1680               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1681               if (h->got.refcount > 0)
1682                 {
1683                   --h->got.refcount;
1684                   if (h->got.refcount == 0)
1685                     {
1686                       /* We don't need the .got entry any more.  */
1687                       sgot->size -= 4;
1688                       srelgot->size -= sizeof (Elf32_External_Rela);
1689                     }
1690                 }
1691             }
1692           else if (local_got_refcounts != NULL)
1693             {
1694               if (local_got_refcounts[r_symndx] > 0)
1695                 {
1696                   --local_got_refcounts[r_symndx];
1697                   if (local_got_refcounts[r_symndx] == 0)
1698                     {
1699                       /* We don't need the .got entry any more.  */
1700                       sgot->size -= 4;
1701                       if (bfd_link_pic (info))
1702                         srelgot->size -= sizeof (Elf32_External_Rela);
1703                     }
1704                 }
1705             }
1706           break;
1707         default:
1708           break;
1709         }
1710     }
1711   return TRUE;
1712 }
1713 \f
1714 extern const bfd_target bfin_elf32_fdpic_vec;
1715 #define IS_FDPIC(bfd) ((bfd)->xvec == &bfin_elf32_fdpic_vec)
1716
1717 /* An extension of the elf hash table data structure,
1718    containing some additional Blackfin-specific data.  */
1719 struct bfinfdpic_elf_link_hash_table
1720 {
1721   struct elf_link_hash_table elf;
1722
1723   /* A pointer to the .rofixup section.  */
1724   asection *sgotfixup;
1725   /* GOT base offset.  */
1726   bfd_vma got0;
1727   /* Location of the first non-lazy PLT entry, i.e., the number of
1728      bytes taken by lazy PLT entries.  */
1729   bfd_vma plt0;
1730   /* A hash table holding information about which symbols were
1731      referenced with which PIC-related relocations.  */
1732   struct htab *relocs_info;
1733   /* Summary reloc information collected by
1734      _bfinfdpic_count_got_plt_entries.  */
1735   struct _bfinfdpic_dynamic_got_info *g;
1736 };
1737
1738 /* Get the Blackfin ELF linker hash table from a link_info structure.  */
1739
1740 #define bfinfdpic_hash_table(info) \
1741   (elf_hash_table_id ((struct elf_link_hash_table *) ((info)->hash)) \
1742   == BFIN_ELF_DATA ? ((struct bfinfdpic_elf_link_hash_table *) ((info)->hash)) : NULL)
1743
1744 #define bfinfdpic_got_section(info) \
1745   (bfinfdpic_hash_table (info)->elf.sgot)
1746 #define bfinfdpic_gotrel_section(info) \
1747   (bfinfdpic_hash_table (info)->elf.srelgot)
1748 #define bfinfdpic_gotfixup_section(info) \
1749   (bfinfdpic_hash_table (info)->sgotfixup)
1750 #define bfinfdpic_plt_section(info) \
1751   (bfinfdpic_hash_table (info)->elf.splt)
1752 #define bfinfdpic_pltrel_section(info) \
1753   (bfinfdpic_hash_table (info)->elf.srelplt)
1754 #define bfinfdpic_relocs_info(info) \
1755   (bfinfdpic_hash_table (info)->relocs_info)
1756 #define bfinfdpic_got_initial_offset(info) \
1757   (bfinfdpic_hash_table (info)->got0)
1758 #define bfinfdpic_plt_initial_offset(info) \
1759   (bfinfdpic_hash_table (info)->plt0)
1760 #define bfinfdpic_dynamic_got_plt_info(info) \
1761   (bfinfdpic_hash_table (info)->g)
1762
1763 /* The name of the dynamic interpreter.  This is put in the .interp
1764    section.  */
1765
1766 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
1767
1768 #define DEFAULT_STACK_SIZE 0x20000
1769
1770 /* This structure is used to collect the number of entries present in
1771    each addressable range of the got.  */
1772 struct _bfinfdpic_dynamic_got_info
1773 {
1774   /* Several bits of information about the current link.  */
1775   struct bfd_link_info *info;
1776   /* Total size needed for GOT entries within the 18- or 32-bit
1777      ranges.  */
1778   bfd_vma got17m4, gothilo;
1779   /* Total size needed for function descriptor entries within the 18-
1780      or 32-bit ranges.  */
1781   bfd_vma fd17m4, fdhilo;
1782   /* Total size needed function descriptor entries referenced in PLT
1783      entries, that would be profitable to place in offsets close to
1784      the PIC register.  */
1785   bfd_vma fdplt;
1786   /* Total size needed by lazy PLT entries.  */
1787   bfd_vma lzplt;
1788   /* Number of relocations carried over from input object files.  */
1789   unsigned long relocs;
1790   /* Number of fixups introduced by relocations in input object files.  */
1791   unsigned long fixups;
1792 };
1793
1794 /* Create a Blackfin ELF linker hash table.  */
1795
1796 static struct bfd_link_hash_table *
1797 bfinfdpic_elf_link_hash_table_create (bfd *abfd)
1798 {
1799   struct bfinfdpic_elf_link_hash_table *ret;
1800   bfd_size_type amt = sizeof (struct bfinfdpic_elf_link_hash_table);
1801
1802   ret = bfd_zmalloc (amt);
1803   if (ret == NULL)
1804     return NULL;
1805
1806   if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
1807                                       _bfd_elf_link_hash_newfunc,
1808                                       sizeof (struct elf_link_hash_entry),
1809                                       BFIN_ELF_DATA))
1810     {
1811       free (ret);
1812       return NULL;
1813     }
1814
1815   return &ret->elf.root;
1816 }
1817
1818 /* Decide whether a reference to a symbol can be resolved locally or
1819    not.  If the symbol is protected, we want the local address, but
1820    its function descriptor must be assigned by the dynamic linker.  */
1821 #define BFINFDPIC_SYM_LOCAL(INFO, H) \
1822   (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
1823    || ! elf_hash_table (INFO)->dynamic_sections_created)
1824 #define BFINFDPIC_FUNCDESC_LOCAL(INFO, H) \
1825   ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
1826
1827 /* This structure collects information on what kind of GOT, PLT or
1828    function descriptors are required by relocations that reference a
1829    certain symbol.  */
1830 struct bfinfdpic_relocs_info
1831 {
1832   /* The index of the symbol, as stored in the relocation r_info, if
1833      we have a local symbol; -1 otherwise.  */
1834   long symndx;
1835   union
1836   {
1837     /* The input bfd in which the symbol is defined, if it's a local
1838        symbol.  */
1839     bfd *abfd;
1840     /* If symndx == -1, the hash table entry corresponding to a global
1841        symbol (even if it turns out to bind locally, in which case it
1842        should ideally be replaced with section's symndx + addend).  */
1843     struct elf_link_hash_entry *h;
1844   } d;
1845   /* The addend of the relocation that references the symbol.  */
1846   bfd_vma addend;
1847
1848   /* The fields above are used to identify an entry.  The fields below
1849      contain information on how an entry is used and, later on, which
1850      locations it was assigned.  */
1851   /* The following 2 fields record whether the symbol+addend above was
1852      ever referenced with a GOT relocation.  The 17M4 suffix indicates a
1853      GOT17M4 relocation; hilo is used for GOTLO/GOTHI pairs.  */
1854   unsigned got17m4;
1855   unsigned gothilo;
1856   /* Whether a FUNCDESC relocation references symbol+addend.  */
1857   unsigned fd;
1858   /* Whether a FUNCDESC_GOT relocation references symbol+addend.  */
1859   unsigned fdgot17m4;
1860   unsigned fdgothilo;
1861   /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend.  */
1862   unsigned fdgoff17m4;
1863   unsigned fdgoffhilo;
1864   /* Whether symbol+addend is referenced with GOTOFF17M4, GOTOFFLO or
1865      GOTOFFHI relocations.  The addend doesn't really matter, since we
1866      envision that this will only be used to check whether the symbol
1867      is mapped to the same segment as the got.  */
1868   unsigned gotoff;
1869   /* Whether symbol+addend is referenced by a LABEL24 relocation.  */
1870   unsigned call;
1871   /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
1872      relocation.  */
1873   unsigned sym;
1874   /* Whether we need a PLT entry for a symbol.  Should be implied by
1875      something like:
1876      (call && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h))  */
1877   unsigned plt:1;
1878   /* Whether a function descriptor should be created in this link unit
1879      for symbol+addend.  Should be implied by something like:
1880      (plt || fdgotoff17m4 || fdgotofflohi
1881       || ((fd || fdgot17m4 || fdgothilo)
1882           && (symndx != -1 || BFINFDPIC_FUNCDESC_LOCAL (info, d.h))))  */
1883   unsigned privfd:1;
1884   /* Whether a lazy PLT entry is needed for this symbol+addend.
1885      Should be implied by something like:
1886      (privfd && symndx == -1 && ! BFINFDPIC_SYM_LOCAL (info, d.h)
1887       && ! (info->flags & DF_BIND_NOW))  */
1888   unsigned lazyplt:1;
1889   /* Whether we've already emitted GOT relocations and PLT entries as
1890      needed for this symbol.  */
1891   unsigned done:1;
1892
1893   /* The number of R_BFIN_BYTE4_DATA, R_BFIN_FUNCDESC and R_BFIN_FUNCDESC_VALUE
1894      relocations referencing the symbol.  */
1895   unsigned relocs32, relocsfd, relocsfdv;
1896
1897   /* The number of .rofixups entries and dynamic relocations allocated
1898      for this symbol, minus any that might have already been used.  */
1899   unsigned fixups, dynrelocs;
1900
1901   /* The offsets of the GOT entries assigned to symbol+addend, to the
1902      function descriptor's address, and to a function descriptor,
1903      respectively.  Should be zero if unassigned.  The offsets are
1904      counted from the value that will be assigned to the PIC register,
1905      not from the beginning of the .got section.  */
1906   bfd_signed_vma got_entry, fdgot_entry, fd_entry;
1907   /* The offsets of the PLT entries assigned to symbol+addend,
1908      non-lazy and lazy, respectively.  If unassigned, should be
1909      (bfd_vma)-1.  */
1910   bfd_vma plt_entry, lzplt_entry;
1911 };
1912
1913 /* Compute a hash with the key fields of an bfinfdpic_relocs_info entry.  */
1914 static hashval_t
1915 bfinfdpic_relocs_info_hash (const void *entry_)
1916 {
1917   const struct bfinfdpic_relocs_info *entry = entry_;
1918
1919   return (entry->symndx == -1
1920           ? (long) entry->d.h->root.root.hash
1921           : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
1922 }
1923
1924 /* Test whether the key fields of two bfinfdpic_relocs_info entries are
1925    identical.  */
1926 static int
1927 bfinfdpic_relocs_info_eq (const void *entry1, const void *entry2)
1928 {
1929   const struct bfinfdpic_relocs_info *e1 = entry1;
1930   const struct bfinfdpic_relocs_info *e2 = entry2;
1931
1932   return e1->symndx == e2->symndx && e1->addend == e2->addend
1933     && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
1934 }
1935
1936 /* Find or create an entry in a hash table HT that matches the key
1937    fields of the given ENTRY.  If it's not found, memory for a new
1938    entry is allocated in ABFD's obstack.  */
1939 static struct bfinfdpic_relocs_info *
1940 bfinfdpic_relocs_info_find (struct htab *ht,
1941                            bfd *abfd,
1942                            const struct bfinfdpic_relocs_info *entry,
1943                            enum insert_option insert)
1944 {
1945   struct bfinfdpic_relocs_info **loc;
1946
1947   if (!ht)
1948     return NULL;
1949
1950   loc = (struct bfinfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
1951
1952   if (! loc)
1953     return NULL;
1954
1955   if (*loc)
1956     return *loc;
1957
1958   *loc = bfd_zalloc (abfd, sizeof (**loc));
1959
1960   if (! *loc)
1961     return *loc;
1962
1963   (*loc)->symndx = entry->symndx;
1964   (*loc)->d = entry->d;
1965   (*loc)->addend = entry->addend;
1966   (*loc)->plt_entry = (bfd_vma)-1;
1967   (*loc)->lzplt_entry = (bfd_vma)-1;
1968
1969   return *loc;
1970 }
1971
1972 /* Obtain the address of the entry in HT associated with H's symbol +
1973    addend, creating a new entry if none existed.  ABFD is only used
1974    for memory allocation purposes.  */
1975 inline static struct bfinfdpic_relocs_info *
1976 bfinfdpic_relocs_info_for_global (struct htab *ht,
1977                                   bfd *abfd,
1978                                   struct elf_link_hash_entry *h,
1979                                   bfd_vma addend,
1980                                   enum insert_option insert)
1981 {
1982   struct bfinfdpic_relocs_info entry;
1983
1984   entry.symndx = -1;
1985   entry.d.h = h;
1986   entry.addend = addend;
1987
1988   return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert);
1989 }
1990
1991 /* Obtain the address of the entry in HT associated with the SYMNDXth
1992    local symbol of the input bfd ABFD, plus the addend, creating a new
1993    entry if none existed.  */
1994 inline static struct bfinfdpic_relocs_info *
1995 bfinfdpic_relocs_info_for_local (struct htab *ht,
1996                                 bfd *abfd,
1997                                 long symndx,
1998                                 bfd_vma addend,
1999                                 enum insert_option insert)
2000 {
2001   struct bfinfdpic_relocs_info entry;
2002
2003   entry.symndx = symndx;
2004   entry.d.abfd = abfd;
2005   entry.addend = addend;
2006
2007   return bfinfdpic_relocs_info_find (ht, abfd, &entry, insert);
2008 }
2009
2010 /* Merge fields set by check_relocs() of two entries that end up being
2011    mapped to the same (presumably global) symbol.  */
2012
2013 inline static void
2014 bfinfdpic_pic_merge_early_relocs_info (struct bfinfdpic_relocs_info *e2,
2015                                        struct bfinfdpic_relocs_info const *e1)
2016 {
2017   e2->got17m4 |= e1->got17m4;
2018   e2->gothilo |= e1->gothilo;
2019   e2->fd |= e1->fd;
2020   e2->fdgot17m4 |= e1->fdgot17m4;
2021   e2->fdgothilo |= e1->fdgothilo;
2022   e2->fdgoff17m4 |= e1->fdgoff17m4;
2023   e2->fdgoffhilo |= e1->fdgoffhilo;
2024   e2->gotoff |= e1->gotoff;
2025   e2->call |= e1->call;
2026   e2->sym |= e1->sym;
2027 }
2028
2029 /* Every block of 65535 lazy PLT entries shares a single call to the
2030    resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
2031    32767, counting from 0).  All other lazy PLT entries branch to it
2032    in a single instruction.  */
2033
2034 #define LZPLT_RESOLVER_EXTRA 10
2035 #define LZPLT_NORMAL_SIZE 6
2036 #define LZPLT_ENTRIES 1362
2037
2038 #define BFINFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) LZPLT_NORMAL_SIZE * LZPLT_ENTRIES + LZPLT_RESOLVER_EXTRA)
2039 #define BFINFDPIC_LZPLT_RESOLV_LOC (LZPLT_NORMAL_SIZE * LZPLT_ENTRIES / 2)
2040
2041 /* Add a dynamic relocation to the SRELOC section.  */
2042
2043 inline static bfd_vma
2044 _bfinfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
2045                          int reloc_type, long dynindx, bfd_vma addend,
2046                          struct bfinfdpic_relocs_info *entry)
2047 {
2048   Elf_Internal_Rela outrel;
2049   bfd_vma reloc_offset;
2050
2051   outrel.r_offset = offset;
2052   outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
2053   outrel.r_addend = addend;
2054
2055   reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
2056   BFD_ASSERT (reloc_offset < sreloc->size);
2057   bfd_elf32_swap_reloc_out (output_bfd, &outrel,
2058                             sreloc->contents + reloc_offset);
2059   sreloc->reloc_count++;
2060
2061   /* If the entry's index is zero, this relocation was probably to a
2062      linkonce section that got discarded.  We reserved a dynamic
2063      relocation, but it was for another entry than the one we got at
2064      the time of emitting the relocation.  Unfortunately there's no
2065      simple way for us to catch this situation, since the relocation
2066      is cleared right before calling relocate_section, at which point
2067      we no longer know what the relocation used to point to.  */
2068   if (entry->symndx)
2069     {
2070       BFD_ASSERT (entry->dynrelocs > 0);
2071       entry->dynrelocs--;
2072     }
2073
2074   return reloc_offset;
2075 }
2076
2077 /* Add a fixup to the ROFIXUP section.  */
2078
2079 static bfd_vma
2080 _bfinfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
2081                         struct bfinfdpic_relocs_info *entry)
2082 {
2083   bfd_vma fixup_offset;
2084
2085   if (rofixup->flags & SEC_EXCLUDE)
2086     return -1;
2087
2088   fixup_offset = rofixup->reloc_count * 4;
2089   if (rofixup->contents)
2090     {
2091       BFD_ASSERT (fixup_offset < rofixup->size);
2092       bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
2093     }
2094   rofixup->reloc_count++;
2095
2096   if (entry && entry->symndx)
2097     {
2098       /* See discussion about symndx == 0 in _bfinfdpic_add_dyn_reloc
2099          above.  */
2100       BFD_ASSERT (entry->fixups > 0);
2101       entry->fixups--;
2102     }
2103
2104   return fixup_offset;
2105 }
2106
2107 /* Find the segment number in which OSEC, and output section, is
2108    located.  */
2109
2110 static unsigned
2111 _bfinfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
2112 {
2113   Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
2114
2115   return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
2116 }
2117
2118 inline static bfd_boolean
2119 _bfinfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
2120 {
2121   unsigned seg = _bfinfdpic_osec_to_segment (output_bfd, osec);
2122
2123   return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
2124 }
2125
2126 /* Generate relocations for GOT entries, function descriptors, and
2127    code for PLT and lazy PLT entries.  */
2128
2129 inline static bfd_boolean
2130 _bfinfdpic_emit_got_relocs_plt_entries (struct bfinfdpic_relocs_info *entry,
2131                                         bfd *output_bfd,
2132                                         struct bfd_link_info *info,
2133                                         asection *sec,
2134                                         Elf_Internal_Sym *sym,
2135                                         bfd_vma addend)
2136 {
2137   bfd_vma fd_lazy_rel_offset = (bfd_vma) -1;
2138   int dynindx = -1;
2139
2140   if (entry->done)
2141     return TRUE;
2142   entry->done = 1;
2143
2144   if (entry->got_entry || entry->fdgot_entry || entry->fd_entry)
2145     {
2146       /* If the symbol is dynamic, consider it for dynamic
2147          relocations, otherwise decay to section + offset.  */
2148       if (entry->symndx == -1 && entry->d.h->dynindx != -1)
2149         dynindx = entry->d.h->dynindx;
2150       else
2151         {
2152           if (sec
2153               && sec->output_section
2154               && ! bfd_is_abs_section (sec->output_section)
2155               && ! bfd_is_und_section (sec->output_section))
2156             dynindx = elf_section_data (sec->output_section)->dynindx;
2157           else
2158             dynindx = 0;
2159         }
2160     }
2161
2162   /* Generate relocation for GOT entry pointing to the symbol.  */
2163   if (entry->got_entry)
2164     {
2165       int idx = dynindx;
2166       bfd_vma ad = addend;
2167
2168       /* If the symbol is dynamic but binds locally, use
2169          section+offset.  */
2170       if (sec && (entry->symndx != -1
2171                   || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2172         {
2173           if (entry->symndx == -1)
2174             ad += entry->d.h->root.u.def.value;
2175           else
2176             ad += sym->st_value;
2177           ad += sec->output_offset;
2178           if (sec->output_section && elf_section_data (sec->output_section))
2179             idx = elf_section_data (sec->output_section)->dynindx;
2180           else
2181             idx = 0;
2182         }
2183
2184       /* If we're linking an executable at a fixed address, we can
2185          omit the dynamic relocation as long as the symbol is local to
2186          this module.  */
2187       if (bfd_link_pde (info)
2188           && (entry->symndx != -1
2189               || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2190         {
2191           if (sec)
2192             ad += sec->output_section->vma;
2193           if (entry->symndx != -1
2194               || entry->d.h->root.type != bfd_link_hash_undefweak)
2195             _bfinfdpic_add_rofixup (output_bfd,
2196                                    bfinfdpic_gotfixup_section (info),
2197                                    bfinfdpic_got_section (info)->output_section
2198                                    ->vma
2199                                    + bfinfdpic_got_section (info)->output_offset
2200                                    + bfinfdpic_got_initial_offset (info)
2201                                    + entry->got_entry, entry);
2202         }
2203       else
2204         _bfinfdpic_add_dyn_reloc (output_bfd, bfinfdpic_gotrel_section (info),
2205                                  _bfd_elf_section_offset
2206                                  (output_bfd, info,
2207                                   bfinfdpic_got_section (info),
2208                                   bfinfdpic_got_initial_offset (info)
2209                                   + entry->got_entry)
2210                                  + bfinfdpic_got_section (info)
2211                                  ->output_section->vma
2212                                  + bfinfdpic_got_section (info)->output_offset,
2213                                  R_BFIN_BYTE4_DATA, idx, ad, entry);
2214
2215       bfd_put_32 (output_bfd, ad,
2216                   bfinfdpic_got_section (info)->contents
2217                   + bfinfdpic_got_initial_offset (info)
2218                   + entry->got_entry);
2219     }
2220
2221   /* Generate relocation for GOT entry pointing to a canonical
2222      function descriptor.  */
2223   if (entry->fdgot_entry)
2224     {
2225       int reloc, idx;
2226       bfd_vma ad = 0;
2227
2228       if (! (entry->symndx == -1
2229              && entry->d.h->root.type == bfd_link_hash_undefweak
2230              && BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2231         {
2232           /* If the symbol is dynamic and there may be dynamic symbol
2233              resolution because we are, or are linked with, a shared
2234              library, emit a FUNCDESC relocation such that the dynamic
2235              linker will allocate the function descriptor.  If the
2236              symbol needs a non-local function descriptor but binds
2237              locally (e.g., its visibility is protected, emit a
2238              dynamic relocation decayed to section+offset.  */
2239           if (entry->symndx == -1
2240               && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
2241               && BFINFDPIC_SYM_LOCAL (info, entry->d.h)
2242               && !bfd_link_pde (info))
2243             {
2244               reloc = R_BFIN_FUNCDESC;
2245               idx = elf_section_data (entry->d.h->root.u.def.section
2246                                       ->output_section)->dynindx;
2247               ad = entry->d.h->root.u.def.section->output_offset
2248                 + entry->d.h->root.u.def.value;
2249             }
2250           else if (entry->symndx == -1
2251                    && ! BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
2252             {
2253               reloc = R_BFIN_FUNCDESC;
2254               idx = dynindx;
2255               ad = addend;
2256               if (ad)
2257                 return FALSE;
2258             }
2259           else
2260             {
2261               /* Otherwise, we know we have a private function descriptor,
2262                  so reference it directly.  */
2263               if (elf_hash_table (info)->dynamic_sections_created)
2264                 BFD_ASSERT (entry->privfd);
2265               reloc = R_BFIN_BYTE4_DATA;
2266               idx = elf_section_data (bfinfdpic_got_section (info)
2267                                       ->output_section)->dynindx;
2268               ad = bfinfdpic_got_section (info)->output_offset
2269                 + bfinfdpic_got_initial_offset (info) + entry->fd_entry;
2270             }
2271
2272           /* If there is room for dynamic symbol resolution, emit the
2273              dynamic relocation.  However, if we're linking an
2274              executable at a fixed location, we won't have emitted a
2275              dynamic symbol entry for the got section, so idx will be
2276              zero, which means we can and should compute the address
2277              of the private descriptor ourselves.  */
2278           if (bfd_link_pde (info)
2279               && (entry->symndx != -1
2280                   || BFINFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
2281             {
2282               ad += bfinfdpic_got_section (info)->output_section->vma;
2283               _bfinfdpic_add_rofixup (output_bfd,
2284                                      bfinfdpic_gotfixup_section (info),
2285                                      bfinfdpic_got_section (info)
2286                                      ->output_section->vma
2287                                      + bfinfdpic_got_section (info)
2288                                      ->output_offset
2289                                      + bfinfdpic_got_initial_offset (info)
2290                                      + entry->fdgot_entry, entry);
2291             }
2292           else
2293             _bfinfdpic_add_dyn_reloc (output_bfd,
2294                                      bfinfdpic_gotrel_section (info),
2295                                      _bfd_elf_section_offset
2296                                      (output_bfd, info,
2297                                       bfinfdpic_got_section (info),
2298                                       bfinfdpic_got_initial_offset (info)
2299                                       + entry->fdgot_entry)
2300                                      + bfinfdpic_got_section (info)
2301                                      ->output_section->vma
2302                                      + bfinfdpic_got_section (info)
2303                                      ->output_offset,
2304                                      reloc, idx, ad, entry);
2305         }
2306
2307       bfd_put_32 (output_bfd, ad,
2308                   bfinfdpic_got_section (info)->contents
2309                   + bfinfdpic_got_initial_offset (info)
2310                   + entry->fdgot_entry);
2311     }
2312
2313   /* Generate relocation to fill in a private function descriptor in
2314      the GOT.  */
2315   if (entry->fd_entry)
2316     {
2317       int idx = dynindx;
2318       bfd_vma ad = addend;
2319       bfd_vma ofst;
2320       long lowword, highword;
2321
2322       /* If the symbol is dynamic but binds locally, use
2323          section+offset.  */
2324       if (sec && (entry->symndx != -1
2325                   || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2326         {
2327           if (entry->symndx == -1)
2328             ad += entry->d.h->root.u.def.value;
2329           else
2330             ad += sym->st_value;
2331           ad += sec->output_offset;
2332           if (sec->output_section && elf_section_data (sec->output_section))
2333             idx = elf_section_data (sec->output_section)->dynindx;
2334           else
2335             idx = 0;
2336         }
2337
2338       /* If we're linking an executable at a fixed address, we can
2339          omit the dynamic relocation as long as the symbol is local to
2340          this module.  */
2341       if (bfd_link_pde (info)
2342           && (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (info, entry->d.h)))
2343         {
2344           if (sec)
2345             ad += sec->output_section->vma;
2346           ofst = 0;
2347           if (entry->symndx != -1
2348               || entry->d.h->root.type != bfd_link_hash_undefweak)
2349             {
2350               _bfinfdpic_add_rofixup (output_bfd,
2351                                      bfinfdpic_gotfixup_section (info),
2352                                      bfinfdpic_got_section (info)
2353                                      ->output_section->vma
2354                                      + bfinfdpic_got_section (info)
2355                                      ->output_offset
2356                                      + bfinfdpic_got_initial_offset (info)
2357                                      + entry->fd_entry, entry);
2358               _bfinfdpic_add_rofixup (output_bfd,
2359                                      bfinfdpic_gotfixup_section (info),
2360                                      bfinfdpic_got_section (info)
2361                                      ->output_section->vma
2362                                      + bfinfdpic_got_section (info)
2363                                      ->output_offset
2364                                      + bfinfdpic_got_initial_offset (info)
2365                                      + entry->fd_entry + 4, entry);
2366             }
2367         }
2368       else
2369         {
2370           ofst
2371             = _bfinfdpic_add_dyn_reloc (output_bfd,
2372                                         entry->lazyplt
2373                                         ? bfinfdpic_pltrel_section (info)
2374                                         : bfinfdpic_gotrel_section (info),
2375                                         _bfd_elf_section_offset
2376                                         (output_bfd, info,
2377                                          bfinfdpic_got_section (info),
2378                                          bfinfdpic_got_initial_offset (info)
2379                                          + entry->fd_entry)
2380                                         + bfinfdpic_got_section (info)
2381                                         ->output_section->vma
2382                                         + bfinfdpic_got_section (info)
2383                                         ->output_offset,
2384                                         R_BFIN_FUNCDESC_VALUE, idx, ad, entry);
2385         }
2386
2387       /* If we've omitted the dynamic relocation, just emit the fixed
2388          addresses of the symbol and of the local GOT base offset.  */
2389       if (bfd_link_pde (info)
2390           && sec
2391           && sec->output_section)
2392         {
2393           lowword = ad;
2394           highword = bfinfdpic_got_section (info)->output_section->vma
2395             + bfinfdpic_got_section (info)->output_offset
2396             + bfinfdpic_got_initial_offset (info);
2397         }
2398       else if (entry->lazyplt)
2399         {
2400           if (ad)
2401             return FALSE;
2402
2403           fd_lazy_rel_offset = ofst;
2404
2405           /* A function descriptor used for lazy or local resolving is
2406              initialized such that its high word contains the output
2407              section index in which the PLT entries are located, and
2408              the low word contains the address of the lazy PLT entry
2409              entry point, that must be within the memory region
2410              assigned to that section.  */
2411           lowword = entry->lzplt_entry + 4
2412             + bfinfdpic_plt_section (info)->output_offset
2413             + bfinfdpic_plt_section (info)->output_section->vma;
2414           highword = _bfinfdpic_osec_to_segment
2415             (output_bfd, bfinfdpic_plt_section (info)->output_section);
2416         }
2417       else
2418         {
2419           /* A function descriptor for a local function gets the index
2420              of the section.  For a non-local function, it's
2421              disregarded.  */
2422           lowword = ad;
2423           if (sec == NULL
2424               || (entry->symndx == -1 && entry->d.h->dynindx != -1
2425                   && entry->d.h->dynindx == idx))
2426             highword = 0;
2427           else
2428             highword = _bfinfdpic_osec_to_segment
2429               (output_bfd, sec->output_section);
2430         }
2431
2432       bfd_put_32 (output_bfd, lowword,
2433                   bfinfdpic_got_section (info)->contents
2434                   + bfinfdpic_got_initial_offset (info)
2435                   + entry->fd_entry);
2436       bfd_put_32 (output_bfd, highword,
2437                   bfinfdpic_got_section (info)->contents
2438                   + bfinfdpic_got_initial_offset (info)
2439                   + entry->fd_entry + 4);
2440     }
2441
2442   /* Generate code for the PLT entry.  */
2443   if (entry->plt_entry != (bfd_vma) -1)
2444     {
2445       bfd_byte *plt_code = bfinfdpic_plt_section (info)->contents
2446         + entry->plt_entry;
2447
2448       BFD_ASSERT (entry->fd_entry);
2449
2450       /* Figure out what kind of PLT entry we need, depending on the
2451          location of the function descriptor within the GOT.  */
2452       if (entry->fd_entry >= -(1 << (18 - 1))
2453           && entry->fd_entry + 4 < (1 << (18 - 1)))
2454         {
2455           /* P1 = [P3 + fd_entry]; P3 = [P3 + fd_entry + 4] */
2456           bfd_put_32 (output_bfd,
2457                       0xe519 | ((entry->fd_entry << 14) & 0xFFFF0000),
2458                       plt_code);
2459           bfd_put_32 (output_bfd,
2460                       0xe51b | (((entry->fd_entry + 4) << 14) & 0xFFFF0000),
2461                       plt_code + 4);
2462           plt_code += 8;
2463         }
2464       else
2465         {
2466           /* P1.L = fd_entry; P1.H = fd_entry;
2467              P3 = P3 + P1;
2468              P1 = [P3];
2469              P3 = [P3 + 4];  */
2470           bfd_put_32 (output_bfd,
2471                       0xe109 | (entry->fd_entry << 16),
2472                       plt_code);
2473           bfd_put_32 (output_bfd,
2474                       0xe149 | (entry->fd_entry & 0xFFFF0000),
2475                       plt_code + 4);
2476           bfd_put_16 (output_bfd, 0x5ad9, plt_code + 8);
2477           bfd_put_16 (output_bfd, 0x9159, plt_code + 10);
2478           bfd_put_16 (output_bfd, 0xac5b, plt_code + 12);
2479           plt_code += 14;
2480         }
2481       /* JUMP (P1) */
2482       bfd_put_16 (output_bfd, 0x0051, plt_code);
2483     }
2484
2485   /* Generate code for the lazy PLT entry.  */
2486   if (entry->lzplt_entry != (bfd_vma) -1)
2487     {
2488       bfd_byte *lzplt_code = bfinfdpic_plt_section (info)->contents
2489         + entry->lzplt_entry;
2490       bfd_vma resolverStub_addr;
2491
2492       bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
2493       lzplt_code += 4;
2494
2495       resolverStub_addr = entry->lzplt_entry / BFINFDPIC_LZPLT_BLOCK_SIZE
2496         * BFINFDPIC_LZPLT_BLOCK_SIZE + BFINFDPIC_LZPLT_RESOLV_LOC;
2497       if (resolverStub_addr >= bfinfdpic_plt_initial_offset (info))
2498         resolverStub_addr = bfinfdpic_plt_initial_offset (info) - LZPLT_NORMAL_SIZE - LZPLT_RESOLVER_EXTRA;
2499
2500       if (entry->lzplt_entry == resolverStub_addr)
2501         {
2502           /* This is a lazy PLT entry that includes a resolver call.
2503              P2 = [P3];
2504              R3 = [P3 + 4];
2505              JUMP (P2);  */
2506           bfd_put_32 (output_bfd,
2507                       0xa05b915a,
2508                       lzplt_code);
2509           bfd_put_16 (output_bfd, 0x0052, lzplt_code + 4);
2510         }
2511       else
2512         {
2513           /* JUMP.S  resolverStub */
2514           bfd_put_16 (output_bfd,
2515                       0x2000
2516                       | (((resolverStub_addr - entry->lzplt_entry)
2517                           / 2) & (((bfd_vma)1 << 12) - 1)),
2518                       lzplt_code);
2519         }
2520     }
2521
2522   return TRUE;
2523 }
2524 \f
2525 /* Relocate an Blackfin ELF section.
2526
2527    The RELOCATE_SECTION function is called by the new ELF backend linker
2528    to handle the relocations for a section.
2529
2530    The relocs are always passed as Rela structures; if the section
2531    actually uses Rel structures, the r_addend field will always be
2532    zero.
2533
2534    This function is responsible for adjusting the section contents as
2535    necessary, and (if using Rela relocs and generating a relocatable
2536    output file) adjusting the reloc addend as necessary.
2537
2538    This function does not have to worry about setting the reloc
2539    address or the reloc symbol index.
2540
2541    LOCAL_SYMS is a pointer to the swapped in local symbols.
2542
2543    LOCAL_SECTIONS is an array giving the section in the input file
2544    corresponding to the st_shndx field of each local symbol.
2545
2546    The global hash table entry for the global symbols can be found
2547    via elf_sym_hashes (input_bfd).
2548
2549    When generating relocatable output, this function must handle
2550    STB_LOCAL/STT_SECTION symbols specially.  The output symbol is
2551    going to be the section symbol corresponding to the output
2552    section, which means that the addend must be adjusted
2553    accordingly.  */
2554
2555 static bfd_boolean
2556 bfinfdpic_relocate_section (bfd * output_bfd,
2557                             struct bfd_link_info *info,
2558                             bfd * input_bfd,
2559                             asection * input_section,
2560                             bfd_byte * contents,
2561                             Elf_Internal_Rela * relocs,
2562                             Elf_Internal_Sym * local_syms,
2563                             asection ** local_sections)
2564 {
2565   Elf_Internal_Shdr *symtab_hdr;
2566   struct elf_link_hash_entry **sym_hashes;
2567   Elf_Internal_Rela *rel;
2568   Elf_Internal_Rela *relend;
2569   unsigned isec_segment, got_segment, plt_segment,
2570     check_segment[2];
2571   int silence_segment_error = !bfd_link_pic (info);
2572
2573   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
2574   sym_hashes = elf_sym_hashes (input_bfd);
2575   relend     = relocs + input_section->reloc_count;
2576
2577   isec_segment = _bfinfdpic_osec_to_segment (output_bfd,
2578                                              input_section->output_section);
2579   if (IS_FDPIC (output_bfd) && bfinfdpic_got_section (info))
2580     got_segment = _bfinfdpic_osec_to_segment (output_bfd,
2581                                               bfinfdpic_got_section (info)
2582                                               ->output_section);
2583   else
2584     got_segment = -1;
2585   if (IS_FDPIC (output_bfd) && elf_hash_table (info)->dynamic_sections_created)
2586     plt_segment = _bfinfdpic_osec_to_segment (output_bfd,
2587                                               bfinfdpic_plt_section (info)
2588                                               ->output_section);
2589   else
2590     plt_segment = -1;
2591
2592   for (rel = relocs; rel < relend; rel ++)
2593     {
2594       reloc_howto_type *howto;
2595       unsigned long r_symndx;
2596       Elf_Internal_Sym *sym;
2597       asection *sec;
2598       struct elf_link_hash_entry *h;
2599       bfd_vma relocation;
2600       bfd_reloc_status_type r;
2601       const char * name = NULL;
2602       int r_type;
2603       asection *osec;
2604       struct bfinfdpic_relocs_info *picrel;
2605       bfd_vma orig_addend = rel->r_addend;
2606
2607       r_type = ELF32_R_TYPE (rel->r_info);
2608
2609       if (r_type == R_BFIN_GNU_VTINHERIT
2610           || r_type == R_BFIN_GNU_VTENTRY)
2611         continue;
2612
2613       r_symndx = ELF32_R_SYM (rel->r_info);
2614       howto = bfin_reloc_type_lookup (input_bfd, r_type);
2615       if (howto == NULL)
2616         {
2617           bfd_set_error (bfd_error_bad_value);
2618           return FALSE;
2619         }
2620
2621       h      = NULL;
2622       sym    = NULL;
2623       sec    = NULL;
2624
2625       if (r_symndx < symtab_hdr->sh_info)
2626         {
2627           sym = local_syms + r_symndx;
2628           osec = sec = local_sections [r_symndx];
2629           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
2630
2631           name = bfd_elf_string_from_elf_section
2632             (input_bfd, symtab_hdr->sh_link, sym->st_name);
2633           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
2634         }
2635       else
2636         {
2637           bfd_boolean warned, ignored;
2638           bfd_boolean unresolved_reloc;
2639
2640           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
2641                                    r_symndx, symtab_hdr, sym_hashes,
2642                                    h, sec, relocation,
2643                                    unresolved_reloc, warned, ignored);
2644           osec = sec;
2645         }
2646
2647       if (sec != NULL && discarded_section (sec))
2648         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
2649                                          rel, 1, relend, howto, 0, contents);
2650
2651       if (bfd_link_relocatable (info))
2652         continue;
2653
2654       if (h != NULL
2655           && (h->root.type == bfd_link_hash_defined
2656               || h->root.type == bfd_link_hash_defweak)
2657           && !BFINFDPIC_SYM_LOCAL (info, h))
2658         {
2659           osec = sec = NULL;
2660           relocation = 0;
2661         }
2662
2663       switch (r_type)
2664         {
2665         case R_BFIN_PCREL24:
2666         case R_BFIN_PCREL24_JUMP_L:
2667         case R_BFIN_BYTE4_DATA:
2668           if (! IS_FDPIC (output_bfd))
2669             goto non_fdpic;
2670           /* Fall through.  */
2671
2672         case R_BFIN_GOT17M4:
2673         case R_BFIN_GOTHI:
2674         case R_BFIN_GOTLO:
2675         case R_BFIN_FUNCDESC_GOT17M4:
2676         case R_BFIN_FUNCDESC_GOTHI:
2677         case R_BFIN_FUNCDESC_GOTLO:
2678         case R_BFIN_GOTOFF17M4:
2679         case R_BFIN_GOTOFFHI:
2680         case R_BFIN_GOTOFFLO:
2681         case R_BFIN_FUNCDESC_GOTOFF17M4:
2682         case R_BFIN_FUNCDESC_GOTOFFHI:
2683         case R_BFIN_FUNCDESC_GOTOFFLO:
2684         case R_BFIN_FUNCDESC:
2685         case R_BFIN_FUNCDESC_VALUE:
2686           if (h != NULL)
2687             picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2688                                                        (info), input_bfd, h,
2689                                                        orig_addend, INSERT);
2690           else
2691             /* In order to find the entry we created before, we must
2692                use the original addend, not the one that may have been
2693                modified by _bfd_elf_rela_local_sym().  */
2694             picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2695                                                       (info), input_bfd, r_symndx,
2696                                                       orig_addend, INSERT);
2697           if (! picrel)
2698             return FALSE;
2699
2700           if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2701                                                        osec, sym,
2702                                                        rel->r_addend))
2703             {
2704               _bfd_error_handler
2705                 /* xgettext:c-format */
2706                 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2707                  input_bfd, input_section, rel->r_offset, name);
2708               return FALSE;
2709
2710             }
2711
2712           break;
2713
2714         default:
2715         non_fdpic:
2716           picrel = NULL;
2717           if (h && ! BFINFDPIC_SYM_LOCAL (info, h)
2718               && _bfd_elf_section_offset (output_bfd, info, input_section,
2719                                           rel->r_offset) != (bfd_vma) -1)
2720             {
2721               info->callbacks->warning
2722                 (info, _("relocation references symbol not defined in the module"),
2723                  name, input_bfd, input_section, rel->r_offset);
2724               return FALSE;
2725             }
2726           break;
2727         }
2728
2729       switch (r_type)
2730         {
2731         case R_BFIN_PCREL24:
2732         case R_BFIN_PCREL24_JUMP_L:
2733           check_segment[0] = isec_segment;
2734           if (! IS_FDPIC (output_bfd))
2735             check_segment[1] = isec_segment;
2736           else if (picrel->plt)
2737             {
2738               relocation = bfinfdpic_plt_section (info)->output_section->vma
2739                 + bfinfdpic_plt_section (info)->output_offset
2740                 + picrel->plt_entry;
2741               check_segment[1] = plt_segment;
2742             }
2743           /* We don't want to warn on calls to undefined weak symbols,
2744              as calls to them must be protected by non-NULL tests
2745              anyway, and unprotected calls would invoke undefined
2746              behavior.  */
2747           else if (picrel->symndx == -1
2748                    && picrel->d.h->root.type == bfd_link_hash_undefweak)
2749             check_segment[1] = check_segment[0];
2750           else
2751             check_segment[1] = sec
2752               ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2753               : (unsigned)-1;
2754           break;
2755
2756         case R_BFIN_GOT17M4:
2757         case R_BFIN_GOTHI:
2758         case R_BFIN_GOTLO:
2759           relocation = picrel->got_entry;
2760           check_segment[0] = check_segment[1] = got_segment;
2761           break;
2762
2763         case R_BFIN_FUNCDESC_GOT17M4:
2764         case R_BFIN_FUNCDESC_GOTHI:
2765         case R_BFIN_FUNCDESC_GOTLO:
2766           relocation = picrel->fdgot_entry;
2767           check_segment[0] = check_segment[1] = got_segment;
2768           break;
2769
2770         case R_BFIN_GOTOFFHI:
2771         case R_BFIN_GOTOFF17M4:
2772         case R_BFIN_GOTOFFLO:
2773           relocation -= bfinfdpic_got_section (info)->output_section->vma
2774             + bfinfdpic_got_section (info)->output_offset
2775             + bfinfdpic_got_initial_offset (info);
2776           check_segment[0] = got_segment;
2777           check_segment[1] = sec
2778             ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2779             : (unsigned)-1;
2780           break;
2781
2782         case R_BFIN_FUNCDESC_GOTOFF17M4:
2783         case R_BFIN_FUNCDESC_GOTOFFHI:
2784         case R_BFIN_FUNCDESC_GOTOFFLO:
2785           relocation = picrel->fd_entry;
2786           check_segment[0] = check_segment[1] = got_segment;
2787           break;
2788
2789         case R_BFIN_FUNCDESC:
2790           {
2791             int dynindx;
2792             bfd_vma addend = rel->r_addend;
2793
2794             if (! (h && h->root.type == bfd_link_hash_undefweak
2795                    && BFINFDPIC_SYM_LOCAL (info, h)))
2796               {
2797                 /* If the symbol is dynamic and there may be dynamic
2798                    symbol resolution because we are or are linked with a
2799                    shared library, emit a FUNCDESC relocation such that
2800                    the dynamic linker will allocate the function
2801                    descriptor.  If the symbol needs a non-local function
2802                    descriptor but binds locally (e.g., its visibility is
2803                    protected, emit a dynamic relocation decayed to
2804                    section+offset.  */
2805                 if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h)
2806                     && BFINFDPIC_SYM_LOCAL (info, h)
2807                     && !bfd_link_pde (info))
2808                   {
2809                     dynindx = elf_section_data (h->root.u.def.section
2810                                                 ->output_section)->dynindx;
2811                     addend += h->root.u.def.section->output_offset
2812                       + h->root.u.def.value;
2813                   }
2814                 else if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h))
2815                   {
2816                     if (addend)
2817                       {
2818                         info->callbacks->warning
2819                           (info, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2820                            name, input_bfd, input_section, rel->r_offset);
2821                         return FALSE;
2822                       }
2823                     dynindx = h->dynindx;
2824                   }
2825                 else
2826                   {
2827                     /* Otherwise, we know we have a private function
2828                        descriptor, so reference it directly.  */
2829                     BFD_ASSERT (picrel->privfd);
2830                     r_type = R_BFIN_BYTE4_DATA;
2831                     dynindx = elf_section_data (bfinfdpic_got_section (info)
2832                                                 ->output_section)->dynindx;
2833                     addend = bfinfdpic_got_section (info)->output_offset
2834                       + bfinfdpic_got_initial_offset (info)
2835                       + picrel->fd_entry;
2836                   }
2837
2838                 /* If there is room for dynamic symbol resolution, emit
2839                    the dynamic relocation.  However, if we're linking an
2840                    executable at a fixed location, we won't have emitted a
2841                    dynamic symbol entry for the got section, so idx will
2842                    be zero, which means we can and should compute the
2843                    address of the private descriptor ourselves.  */
2844                 if (bfd_link_pde (info)
2845                     && (!h || BFINFDPIC_FUNCDESC_LOCAL (info, h)))
2846                   {
2847                     bfd_vma offset;
2848
2849                     addend += bfinfdpic_got_section (info)->output_section->vma;
2850                     if ((bfd_get_section_flags (output_bfd,
2851                                                 input_section->output_section)
2852                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2853                       {
2854                         if (_bfinfdpic_osec_readonly_p (output_bfd,
2855                                                        input_section
2856                                                        ->output_section))
2857                           {
2858                             info->callbacks->warning
2859                               (info,
2860                                _("cannot emit fixups in read-only section"),
2861                                name, input_bfd, input_section, rel->r_offset);
2862                             return FALSE;
2863                           }
2864
2865                         offset = _bfd_elf_section_offset
2866                           (output_bfd, info,
2867                            input_section, rel->r_offset);
2868
2869                         if (offset != (bfd_vma)-1)
2870                           _bfinfdpic_add_rofixup (output_bfd,
2871                                                   bfinfdpic_gotfixup_section
2872                                                   (info),
2873                                                   offset + input_section
2874                                                   ->output_section->vma
2875                                                   + input_section->output_offset,
2876                                                   picrel);
2877                       }
2878                   }
2879                 else if ((bfd_get_section_flags (output_bfd,
2880                                                  input_section->output_section)
2881                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2882                   {
2883                     bfd_vma offset;
2884
2885                     if (_bfinfdpic_osec_readonly_p (output_bfd,
2886                                                    input_section
2887                                                    ->output_section))
2888                       {
2889                         info->callbacks->warning
2890                           (info,
2891                            _("cannot emit dynamic relocations in read-only section"),
2892                            name, input_bfd, input_section, rel->r_offset);
2893                         return FALSE;
2894                       }
2895                     offset = _bfd_elf_section_offset (output_bfd, info,
2896                                                       input_section, rel->r_offset);
2897
2898                     if (offset != (bfd_vma)-1)
2899                       _bfinfdpic_add_dyn_reloc (output_bfd,
2900                                                 bfinfdpic_gotrel_section (info),
2901                                                 offset + input_section
2902                                                 ->output_section->vma
2903                                                 + input_section->output_offset,
2904                                                 r_type,
2905                                                 dynindx, addend, picrel);
2906                   }
2907                 else
2908                   addend += bfinfdpic_got_section (info)->output_section->vma;
2909               }
2910
2911             /* We want the addend in-place because dynamic
2912                relocations are REL.  Setting relocation to it should
2913                arrange for it to be installed.  */
2914             relocation = addend - rel->r_addend;
2915           }
2916           check_segment[0] = check_segment[1] = got_segment;
2917           break;
2918
2919         case R_BFIN_BYTE4_DATA:
2920           if (! IS_FDPIC (output_bfd))
2921             {
2922               check_segment[0] = check_segment[1] = -1;
2923               break;
2924             }
2925           /* Fall through.  */
2926         case R_BFIN_FUNCDESC_VALUE:
2927           {
2928             int dynindx;
2929             bfd_vma addend = rel->r_addend;
2930             bfd_vma offset;
2931             offset = _bfd_elf_section_offset (output_bfd, info,
2932                                               input_section, rel->r_offset);
2933
2934             /* If the symbol is dynamic but binds locally, use
2935                section+offset.  */
2936             if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2937               {
2938                 if (addend && r_type == R_BFIN_FUNCDESC_VALUE)
2939                   {
2940                     info->callbacks->warning
2941                       (info, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2942                        name, input_bfd, input_section, rel->r_offset);
2943                     return FALSE;
2944                   }
2945                 dynindx = h->dynindx;
2946               }
2947             else
2948               {
2949                 if (h)
2950                   addend += h->root.u.def.value;
2951                 else
2952                   addend += sym->st_value;
2953                 if (osec)
2954                   addend += osec->output_offset;
2955                 if (osec && osec->output_section
2956                     && ! bfd_is_abs_section (osec->output_section)
2957                     && ! bfd_is_und_section (osec->output_section))
2958                   dynindx = elf_section_data (osec->output_section)->dynindx;
2959                 else
2960                   dynindx = 0;
2961               }
2962
2963             /* If we're linking an executable at a fixed address, we
2964                can omit the dynamic relocation as long as the symbol
2965                is defined in the current link unit (which is implied
2966                by its output section not being NULL).  */
2967             if (bfd_link_pde (info)
2968                 && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2969               {
2970                 if (osec)
2971                   addend += osec->output_section->vma;
2972                 if (IS_FDPIC (input_bfd)
2973                     && (bfd_get_section_flags (output_bfd,
2974                                                input_section->output_section)
2975                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2976                   {
2977                     if (_bfinfdpic_osec_readonly_p (output_bfd,
2978                                                    input_section
2979                                                    ->output_section))
2980                       {
2981                         info->callbacks->warning
2982                           (info,
2983                            _("cannot emit fixups in read-only section"),
2984                            name, input_bfd, input_section, rel->r_offset);
2985                         return FALSE;
2986                       }
2987                     if (!h || h->root.type != bfd_link_hash_undefweak)
2988                       {
2989                         if (offset != (bfd_vma)-1)
2990                           {
2991                             _bfinfdpic_add_rofixup (output_bfd,
2992                                                     bfinfdpic_gotfixup_section
2993                                                     (info),
2994                                                     offset + input_section
2995                                                     ->output_section->vma
2996                                                     + input_section->output_offset,
2997                                                     picrel);
2998
2999                             if (r_type == R_BFIN_FUNCDESC_VALUE)
3000                               _bfinfdpic_add_rofixup
3001                                 (output_bfd,
3002                                  bfinfdpic_gotfixup_section (info),
3003                                  offset + input_section->output_section->vma
3004                                  + input_section->output_offset + 4, picrel);
3005                           }
3006                       }
3007                   }
3008               }
3009             else
3010               {
3011                 if ((bfd_get_section_flags (output_bfd,
3012                                             input_section->output_section)
3013                      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3014                   {
3015                     if (_bfinfdpic_osec_readonly_p (output_bfd,
3016                                                    input_section
3017                                                    ->output_section))
3018                       {
3019                         info->callbacks->warning
3020                           (info,
3021                            _("cannot emit dynamic relocations in read-only section"),
3022                            name, input_bfd, input_section, rel->r_offset);
3023                         return FALSE;
3024                       }
3025
3026                     if (offset != (bfd_vma)-1)
3027                       _bfinfdpic_add_dyn_reloc (output_bfd,
3028                                                 bfinfdpic_gotrel_section (info),
3029                                                 offset
3030                                                 + input_section->output_section->vma
3031                                                 + input_section->output_offset,
3032                                                 r_type, dynindx, addend, picrel);
3033                   }
3034                 else if (osec)
3035                   addend += osec->output_section->vma;
3036                 /* We want the addend in-place because dynamic
3037                    relocations are REL.  Setting relocation to it
3038                    should arrange for it to be installed.  */
3039                 relocation = addend - rel->r_addend;
3040               }
3041
3042             if (r_type == R_BFIN_FUNCDESC_VALUE)
3043               {
3044                 /* If we've omitted the dynamic relocation, just emit
3045                    the fixed addresses of the symbol and of the local
3046                    GOT base offset.  */
3047                 if (bfd_link_pde (info)
3048                     && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
3049                   bfd_put_32 (output_bfd,
3050                               bfinfdpic_got_section (info)->output_section->vma
3051                               + bfinfdpic_got_section (info)->output_offset
3052                               + bfinfdpic_got_initial_offset (info),
3053                               contents + rel->r_offset + 4);
3054                 else
3055                   /* A function descriptor used for lazy or local
3056                      resolving is initialized such that its high word
3057                      contains the output section index in which the
3058                      PLT entries are located, and the low word
3059                      contains the offset of the lazy PLT entry entry
3060                      point into that section.  */
3061                   bfd_put_32 (output_bfd,
3062                               h && ! BFINFDPIC_SYM_LOCAL (info, h)
3063                               ? 0
3064                               : _bfinfdpic_osec_to_segment (output_bfd,
3065                                                             sec
3066                                                             ->output_section),
3067                               contents + rel->r_offset + 4);
3068               }
3069           }
3070           check_segment[0] = check_segment[1] = got_segment;
3071           break;
3072
3073         default:
3074           check_segment[0] = isec_segment;
3075           check_segment[1] = sec
3076             ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
3077             : (unsigned)-1;
3078           break;
3079         }
3080
3081       if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3082         {
3083 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
3084          in the ld testsuite.  */
3085           /* This helps catch problems in GCC while we can't do more
3086              than static linking.  The idea is to test whether the
3087              input file basename is crt0.o only once.  */
3088           if (silence_segment_error == 1)
3089             silence_segment_error =
3090               (strlen (input_bfd->filename) == 6
3091                && filename_cmp (input_bfd->filename, "crt0.o") == 0)
3092               || (strlen (input_bfd->filename) > 6
3093                   && filename_cmp (input_bfd->filename
3094                                    + strlen (input_bfd->filename) - 7,
3095                              "/crt0.o") == 0)
3096               ? -1 : 0;
3097 #endif
3098           if (!silence_segment_error
3099               /* We don't want duplicate errors for undefined
3100                  symbols.  */
3101               && !(picrel && picrel->symndx == -1
3102                    && picrel->d.h->root.type == bfd_link_hash_undefined))
3103             info->callbacks->warning
3104               (info,
3105                bfd_link_pic (info)
3106                ? _("relocations between different segments are not supported")
3107                : _("warning: relocation references a different segment"),
3108                name, input_bfd, input_section, rel->r_offset);
3109           if (!silence_segment_error && bfd_link_pic (info))
3110             return FALSE;
3111           elf_elfheader (output_bfd)->e_flags |= EF_BFIN_PIC;
3112         }
3113
3114       switch (r_type)
3115         {
3116         case R_BFIN_GOTOFFHI:
3117           /* We need the addend to be applied before we shift the
3118              value right.  */
3119           relocation += rel->r_addend;
3120           /* Fall through.  */
3121         case R_BFIN_GOTHI:
3122         case R_BFIN_FUNCDESC_GOTHI:
3123         case R_BFIN_FUNCDESC_GOTOFFHI:
3124           relocation >>= 16;
3125           /* Fall through.  */
3126
3127         case R_BFIN_GOTLO:
3128         case R_BFIN_FUNCDESC_GOTLO:
3129         case R_BFIN_GOTOFFLO:
3130         case R_BFIN_FUNCDESC_GOTOFFLO:
3131           relocation &= 0xffff;
3132           break;
3133
3134         default:
3135           break;
3136         }
3137
3138       switch (r_type)
3139         {
3140         case R_BFIN_PCREL24:
3141         case R_BFIN_PCREL24_JUMP_L:
3142           if (! IS_FDPIC (output_bfd) || ! picrel->plt)
3143             break;
3144           /* Fall through.  */
3145
3146           /* When referencing a GOT entry, a function descriptor or a
3147              PLT, we don't want the addend to apply to the reference,
3148              but rather to the referenced symbol.  The actual entry
3149              will have already been created taking the addend into
3150              account, so cancel it out here.  */
3151         case R_BFIN_GOT17M4:
3152         case R_BFIN_GOTHI:
3153         case R_BFIN_GOTLO:
3154         case R_BFIN_FUNCDESC_GOT17M4:
3155         case R_BFIN_FUNCDESC_GOTHI:
3156         case R_BFIN_FUNCDESC_GOTLO:
3157         case R_BFIN_FUNCDESC_GOTOFF17M4:
3158         case R_BFIN_FUNCDESC_GOTOFFHI:
3159         case R_BFIN_FUNCDESC_GOTOFFLO:
3160           /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
3161              here, since we do want to apply the addend to the others.
3162              Note that we've applied the addend to GOTOFFHI before we
3163              shifted it right.  */
3164         case R_BFIN_GOTOFFHI:
3165           relocation -= rel->r_addend;
3166           break;
3167
3168         default:
3169           break;
3170         }
3171
3172       r = bfin_final_link_relocate (rel, howto, input_bfd, input_section,
3173                                     contents, rel->r_offset,
3174                                     relocation, rel->r_addend);
3175
3176       if (r != bfd_reloc_ok)
3177         {
3178           const char * msg = (const char *) NULL;
3179
3180           switch (r)
3181             {
3182             case bfd_reloc_overflow:
3183               (*info->callbacks->reloc_overflow)
3184                 (info, (h ? &h->root : NULL), name, howto->name,
3185                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3186               break;
3187
3188             case bfd_reloc_undefined:
3189               (*info->callbacks->undefined_symbol)
3190                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
3191               break;
3192
3193             case bfd_reloc_outofrange:
3194               msg = _("internal error: out of range error");
3195               break;
3196
3197             case bfd_reloc_notsupported:
3198               msg = _("internal error: unsupported relocation error");
3199               break;
3200
3201             case bfd_reloc_dangerous:
3202               msg = _("internal error: dangerous relocation");
3203               break;
3204
3205             default:
3206               msg = _("internal error: unknown error");
3207               break;
3208             }
3209
3210           if (msg)
3211             (*info->callbacks->warning) (info, msg, name, input_bfd,
3212                                          input_section, rel->r_offset);
3213         }
3214     }
3215
3216   return TRUE;
3217 }
3218
3219 /* Update the relocation information for the relocations of the section
3220    being removed.  */
3221
3222 static bfd_boolean
3223 bfinfdpic_gc_sweep_hook (bfd *abfd,
3224                          struct bfd_link_info *info,
3225                          asection *sec,
3226                          const Elf_Internal_Rela *relocs)
3227 {
3228   Elf_Internal_Shdr *symtab_hdr;
3229   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3230   const Elf_Internal_Rela *rel;
3231   const Elf_Internal_Rela *rel_end;
3232   struct bfinfdpic_relocs_info *picrel;
3233
3234   BFD_ASSERT (IS_FDPIC (abfd));
3235
3236   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3237   sym_hashes = elf_sym_hashes (abfd);
3238   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
3239   if (!elf_bad_symtab (abfd))
3240     sym_hashes_end -= symtab_hdr->sh_info;
3241
3242   rel_end = relocs + sec->reloc_count;
3243   for (rel = relocs; rel < rel_end; rel++)
3244     {
3245       struct elf_link_hash_entry *h;
3246       unsigned long r_symndx;
3247
3248       r_symndx = ELF32_R_SYM (rel->r_info);
3249       if (r_symndx < symtab_hdr->sh_info)
3250         h = NULL;
3251       else
3252         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3253
3254       if (h != NULL)
3255         picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
3256                                                    abfd, h,
3257                                                    rel->r_addend, NO_INSERT);
3258       else
3259         picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
3260                                                   (info), abfd, r_symndx,
3261                                                   rel->r_addend, NO_INSERT);
3262
3263       if (!picrel)
3264         return TRUE;
3265
3266       switch (ELF32_R_TYPE (rel->r_info))
3267         {
3268         case R_BFIN_PCREL24:
3269         case R_BFIN_PCREL24_JUMP_L:
3270           picrel->call--;
3271           break;
3272
3273         case R_BFIN_FUNCDESC_VALUE:
3274           picrel->relocsfdv--;
3275           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
3276             picrel->relocs32++;
3277           /* Fall through.  */
3278
3279         case R_BFIN_BYTE4_DATA:
3280           picrel->sym--;
3281           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
3282             picrel->relocs32--;
3283           break;
3284
3285         case R_BFIN_GOT17M4:
3286           picrel->got17m4--;
3287           break;
3288
3289         case R_BFIN_GOTHI:
3290         case R_BFIN_GOTLO:
3291           picrel->gothilo--;
3292           break;
3293
3294         case R_BFIN_FUNCDESC_GOT17M4:
3295           picrel->fdgot17m4--;
3296           break;
3297
3298         case R_BFIN_FUNCDESC_GOTHI:
3299         case R_BFIN_FUNCDESC_GOTLO:
3300           picrel->fdgothilo--;
3301           break;
3302
3303         case R_BFIN_GOTOFF17M4:
3304         case R_BFIN_GOTOFFHI:
3305         case R_BFIN_GOTOFFLO:
3306           picrel->gotoff--;
3307           break;
3308
3309         case R_BFIN_FUNCDESC_GOTOFF17M4:
3310           picrel->fdgoff17m4--;
3311           break;
3312
3313         case R_BFIN_FUNCDESC_GOTOFFHI:
3314         case R_BFIN_FUNCDESC_GOTOFFLO:
3315           picrel->fdgoffhilo--;
3316           break;
3317
3318         case R_BFIN_FUNCDESC:
3319           picrel->fd--;
3320           picrel->relocsfd--;
3321           break;
3322
3323         default:
3324           break;
3325         }
3326     }
3327
3328   return TRUE;
3329 }
3330
3331 /* We need dynamic symbols for every section, since segments can
3332    relocate independently.  */
3333 static bfd_boolean
3334 _bfinfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
3335                                     struct bfd_link_info *info ATTRIBUTE_UNUSED,
3336                                     asection *p)
3337 {
3338   switch (elf_section_data (p)->this_hdr.sh_type)
3339     {
3340     case SHT_PROGBITS:
3341     case SHT_NOBITS:
3342       /* If sh_type is yet undecided, assume it could be
3343          SHT_PROGBITS/SHT_NOBITS.  */
3344     case SHT_NULL:
3345       return FALSE;
3346
3347       /* There shouldn't be section relative relocations
3348          against any other section.  */
3349     default:
3350       return TRUE;
3351     }
3352 }
3353
3354 /* Create  a .got section, as well as its additional info field.  This
3355    is almost entirely copied from
3356    elflink.c:_bfd_elf_create_got_section().  */
3357
3358 static bfd_boolean
3359 _bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
3360 {
3361   flagword flags, pltflags;
3362   asection *s;
3363   struct elf_link_hash_entry *h;
3364   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3365   int ptralign;
3366
3367   /* This function may be called more than once.  */
3368   s = elf_hash_table (info)->sgot;
3369   if (s != NULL)
3370     return TRUE;
3371
3372   /* Machine specific: although pointers are 32-bits wide, we want the
3373      GOT to be aligned to a 64-bit boundary, such that function
3374      descriptors in it can be accessed with 64-bit loads and
3375      stores.  */
3376   ptralign = 3;
3377
3378   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3379            | SEC_LINKER_CREATED);
3380   pltflags = flags;
3381
3382   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3383   elf_hash_table (info)->sgot = s;
3384   if (s == NULL
3385       || !bfd_set_section_alignment (abfd, s, ptralign))
3386     return FALSE;
3387
3388   if (bed->want_got_sym)
3389     {
3390       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3391          (or .got.plt) section.  We don't do this in the linker script
3392          because we don't want to define the symbol if we are not creating
3393          a global offset table.  */
3394       h = _bfd_elf_define_linkage_sym (abfd, info, s, "__GLOBAL_OFFSET_TABLE_");
3395       elf_hash_table (info)->hgot = h;
3396       if (h == NULL)
3397         return FALSE;
3398
3399       /* Machine-specific: we want the symbol for executables as
3400          well.  */
3401       if (! bfd_elf_link_record_dynamic_symbol (info, h))
3402         return FALSE;
3403     }
3404
3405   /* The first bit of the global offset table is the header.  */
3406   s->size += bed->got_header_size;
3407
3408   /* This is the machine-specific part.  Create and initialize section
3409      data for the got.  */
3410   if (IS_FDPIC (abfd))
3411     {
3412       bfinfdpic_relocs_info (info) = htab_try_create (1,
3413                                                       bfinfdpic_relocs_info_hash,
3414                                                       bfinfdpic_relocs_info_eq,
3415                                                       (htab_del) NULL);
3416       if (! bfinfdpic_relocs_info (info))
3417         return FALSE;
3418
3419       s = bfd_make_section_anyway_with_flags (abfd, ".rel.got",
3420                                               (flags | SEC_READONLY));
3421       if (s == NULL
3422           || ! bfd_set_section_alignment (abfd, s, 2))
3423         return FALSE;
3424
3425       bfinfdpic_gotrel_section (info) = s;
3426
3427       /* Machine-specific.  */
3428       s = bfd_make_section_anyway_with_flags (abfd, ".rofixup",
3429                                               (flags | SEC_READONLY));
3430       if (s == NULL
3431           || ! bfd_set_section_alignment (abfd, s, 2))
3432         return FALSE;
3433
3434       bfinfdpic_gotfixup_section (info) = s;
3435     }
3436
3437   pltflags |= SEC_CODE;
3438   if (bed->plt_not_loaded)
3439     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3440   if (bed->plt_readonly)
3441     pltflags |= SEC_READONLY;
3442
3443   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
3444   if (s == NULL
3445       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3446     return FALSE;
3447   /* Blackfin-specific: remember it.  */
3448   bfinfdpic_plt_section (info) = s;
3449
3450   if (bed->want_plt_sym)
3451     {
3452       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3453          .plt section.  */
3454       struct bfd_link_hash_entry *bh = NULL;
3455
3456       if (! (_bfd_generic_link_add_one_symbol
3457              (info, abfd, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3458               FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3459         return FALSE;
3460       h = (struct elf_link_hash_entry *) bh;
3461       h->def_regular = 1;
3462       h->type = STT_OBJECT;
3463
3464       if (! bfd_link_executable (info)
3465           && ! bfd_elf_link_record_dynamic_symbol (info, h))
3466         return FALSE;
3467     }
3468
3469   /* Blackfin-specific: we want rel relocations for the plt.  */
3470   s = bfd_make_section_anyway_with_flags (abfd, ".rel.plt",
3471                                           flags | SEC_READONLY);
3472   if (s == NULL
3473       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3474     return FALSE;
3475   /* Blackfin-specific: remember it.  */
3476   bfinfdpic_pltrel_section (info) = s;
3477
3478   return TRUE;
3479 }
3480
3481 /* Make sure the got and plt sections exist, and that our pointers in
3482    the link hash table point to them.  */
3483
3484 static bfd_boolean
3485 elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3486 {
3487   /* This is mostly copied from
3488      elflink.c:_bfd_elf_create_dynamic_sections().  */
3489   flagword flags;
3490   asection *s;
3491   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3492
3493   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3494            | SEC_LINKER_CREATED);
3495
3496   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3497      .rel[a].bss sections.  */
3498
3499   /* Blackfin-specific: we want to create the GOT in the Blackfin way.  */
3500   if (! _bfin_create_got_section (abfd, info))
3501     return FALSE;
3502
3503   /* Blackfin-specific: make sure we created everything we wanted.  */
3504   BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3505               /* && bfinfdpic_gotfixup_section (info) */
3506               && bfinfdpic_plt_section (info)
3507               && bfinfdpic_pltrel_section (info));
3508
3509   if (bed->want_dynbss)
3510     {
3511       /* The .dynbss section is a place to put symbols which are defined
3512          by dynamic objects, are referenced by regular objects, and are
3513          not functions.  We must allocate space for them in the process
3514          image and use a R_*_COPY reloc to tell the dynamic linker to
3515          initialize them at run time.  The linker script puts the .dynbss
3516          section into the .bss section of the final image.  */
3517       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
3518                                               SEC_ALLOC | SEC_LINKER_CREATED);
3519       if (s == NULL)
3520         return FALSE;
3521
3522       /* The .rel[a].bss section holds copy relocs.  This section is not
3523          normally needed.  We need to create it here, though, so that the
3524          linker will map it to an output section.  We can't just create it
3525          only if we need it, because we will not know whether we need it
3526          until we have seen all the input files, and the first time the
3527          main linker code calls BFD after examining all the input files
3528          (size_dynamic_sections) the input sections have already been
3529          mapped to the output sections.  If the section turns out not to
3530          be needed, we can discard it later.  We will never need this
3531          section when generating a shared object, since they do not use
3532          copy relocs.  */
3533       if (! bfd_link_pic (info))
3534         {
3535           s = bfd_make_section_anyway_with_flags (abfd,
3536                                                   ".rela.bss",
3537                                                   flags | SEC_READONLY);
3538           if (s == NULL
3539               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3540             return FALSE;
3541         }
3542     }
3543
3544   return TRUE;
3545 }
3546
3547 /* Compute the total GOT size required by each symbol in each range.
3548    Symbols may require up to 4 words in the GOT: an entry pointing to
3549    the symbol, an entry pointing to its function descriptor, and a
3550    private function descriptors taking two words.  */
3551
3552 static void
3553 _bfinfdpic_count_nontls_entries (struct bfinfdpic_relocs_info *entry,
3554                                  struct _bfinfdpic_dynamic_got_info *dinfo)
3555 {
3556   /* Allocate space for a GOT entry pointing to the symbol.  */
3557   if (entry->got17m4)
3558     dinfo->got17m4 += 4;
3559   else if (entry->gothilo)
3560     dinfo->gothilo += 4;
3561   else
3562     entry->relocs32--;
3563   entry->relocs32++;
3564
3565   /* Allocate space for a GOT entry pointing to the function
3566      descriptor.  */
3567   if (entry->fdgot17m4)
3568     dinfo->got17m4 += 4;
3569   else if (entry->fdgothilo)
3570     dinfo->gothilo += 4;
3571   else
3572     entry->relocsfd--;
3573   entry->relocsfd++;
3574
3575   /* Decide whether we need a PLT entry, a function descriptor in the
3576      GOT, and a lazy PLT entry for this symbol.  */
3577   entry->plt = entry->call
3578     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3579     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3580   entry->privfd = entry->plt
3581     || entry->fdgoff17m4 || entry->fdgoffhilo
3582     || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3583         && (entry->symndx != -1
3584             || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3585   entry->lazyplt = entry->privfd
3586     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3587     && ! (dinfo->info->flags & DF_BIND_NOW)
3588     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3589
3590   /* Allocate space for a function descriptor.  */
3591   if (entry->fdgoff17m4)
3592     dinfo->fd17m4 += 8;
3593   else if (entry->privfd && entry->plt)
3594     dinfo->fdplt += 8;
3595   else if (entry->privfd)
3596     dinfo->fdhilo += 8;
3597   else
3598     entry->relocsfdv--;
3599   entry->relocsfdv++;
3600
3601   if (entry->lazyplt)
3602     dinfo->lzplt += LZPLT_NORMAL_SIZE;
3603 }
3604
3605 /* Compute the number of dynamic relocations and fixups that a symbol
3606    requires, and add (or subtract) from the grand and per-symbol
3607    totals.  */
3608
3609 static void
3610 _bfinfdpic_count_relocs_fixups (struct bfinfdpic_relocs_info *entry,
3611                                 struct _bfinfdpic_dynamic_got_info *dinfo,
3612                                 bfd_boolean subtract)
3613 {
3614   bfd_vma relocs = 0, fixups = 0;
3615
3616   if (!bfd_link_pde (dinfo->info))
3617     relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3618   else
3619     {
3620       if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3621         {
3622           if (entry->symndx != -1
3623               || entry->d.h->root.type != bfd_link_hash_undefweak)
3624             fixups += entry->relocs32 + 2 * entry->relocsfdv;
3625         }
3626       else
3627         relocs += entry->relocs32 + entry->relocsfdv;
3628
3629       if (entry->symndx != -1
3630           || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3631         {
3632           if (entry->symndx != -1
3633               || entry->d.h->root.type != bfd_link_hash_undefweak)
3634             fixups += entry->relocsfd;
3635         }
3636       else
3637         relocs += entry->relocsfd;
3638     }
3639
3640   if (subtract)
3641     {
3642       relocs = - relocs;
3643       fixups = - fixups;
3644     }
3645
3646   entry->dynrelocs += relocs;
3647   entry->fixups += fixups;
3648   dinfo->relocs += relocs;
3649   dinfo->fixups += fixups;
3650 }
3651
3652 /* Compute the total GOT and PLT size required by each symbol in each range. *
3653    Symbols may require up to 4 words in the GOT: an entry pointing to
3654    the symbol, an entry pointing to its function descriptor, and a
3655    private function descriptors taking two words.  */
3656
3657 static int
3658 _bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3659 {
3660   struct bfinfdpic_relocs_info *entry = *entryp;
3661   struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3662
3663   _bfinfdpic_count_nontls_entries (entry, dinfo);
3664
3665   _bfinfdpic_count_relocs_fixups (entry, dinfo, FALSE);
3666
3667   return 1;
3668 }
3669
3670 /* This structure is used to assign offsets to got entries, function
3671    descriptors, plt entries and lazy plt entries.  */
3672
3673 struct _bfinfdpic_dynamic_got_plt_info
3674 {
3675   /* Summary information collected with _bfinfdpic_count_got_plt_entries.  */
3676   struct _bfinfdpic_dynamic_got_info g;
3677
3678   /* For each addressable range, we record a MAX (positive) and MIN
3679      (negative) value.  CUR is used to assign got entries, and it's
3680      incremented from an initial positive value to MAX, then from MIN
3681      to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
3682      assign function descriptors, and it's decreased from an initial
3683      non-positive value to MIN, then from MAX down to CUR (unless CUR
3684      wraps around first).  All of MIN, MAX, CUR and FDCUR always point
3685      to even words.  ODD, if non-zero, indicates an odd word to be
3686      used for the next got entry, otherwise CUR is used and
3687      incremented by a pair of words, wrapping around when it reaches
3688      MAX.  FDCUR is decremented (and wrapped) before the next function
3689      descriptor is chosen.  FDPLT indicates the number of remaining
3690      slots that can be used for function descriptors used only by PLT
3691      entries.  */
3692   struct _bfinfdpic_dynamic_got_alloc_data
3693   {
3694     bfd_signed_vma max, cur, odd, fdcur, min;
3695     bfd_vma fdplt;
3696   } got17m4, gothilo;
3697 };
3698
3699 /* Determine the positive and negative ranges to be used by each
3700    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
3701    double-word boundary, are the minimum (negative) and maximum
3702    (positive) GOT offsets already used by previous ranges, except for
3703    an ODD entry that may have been left behind.  GOT and FD indicate
3704    the size of GOT entries and function descriptors that must be
3705    placed within the range from -WRAP to WRAP.  If there's room left,
3706    up to FDPLT bytes should be reserved for additional function
3707    descriptors.  */
3708
3709 inline static bfd_signed_vma
3710 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3711                                    bfd_signed_vma fdcur,
3712                                    bfd_signed_vma odd,
3713                                    bfd_signed_vma cur,
3714                                    bfd_vma got,
3715                                    bfd_vma fd,
3716                                    bfd_vma fdplt,
3717                                    bfd_vma wrap)
3718 {
3719   bfd_signed_vma wrapmin = -wrap;
3720
3721   /* Start at the given initial points.  */
3722   gad->fdcur = fdcur;
3723   gad->cur = cur;
3724
3725   /* If we had an incoming odd word and we have any got entries that
3726      are going to use it, consume it, otherwise leave gad->odd at
3727      zero.  We might force gad->odd to zero and return the incoming
3728      odd such that it is used by the next range, but then GOT entries
3729      might appear to be out of order and we wouldn't be able to
3730      shorten the GOT by one word if it turns out to end with an
3731      unpaired GOT entry.  */
3732   if (odd && got)
3733     {
3734       gad->odd = odd;
3735       got -= 4;
3736       odd = 0;
3737     }
3738   else
3739     gad->odd = 0;
3740
3741   /* If we're left with an unpaired GOT entry, compute its location
3742      such that we can return it.  Otherwise, if got doesn't require an
3743      odd number of words here, either odd was already zero in the
3744      block above, or it was set to zero because got was non-zero, or
3745      got was already zero.  In the latter case, we want the value of
3746      odd to carry over to the return statement, so we don't want to
3747      reset odd unless the condition below is true.  */
3748   if (got & 4)
3749     {
3750       odd = cur + got;
3751       got += 4;
3752     }
3753
3754   /* Compute the tentative boundaries of this range.  */
3755   gad->max = cur + got;
3756   gad->min = fdcur - fd;
3757   gad->fdplt = 0;
3758
3759   /* If function descriptors took too much space, wrap some of them
3760      around.  */
3761   if (gad->min < wrapmin)
3762     {
3763       gad->max += wrapmin - gad->min;
3764       gad->min = wrapmin;
3765     }
3766   /* If there is space left and we have function descriptors
3767      referenced in PLT entries that could take advantage of shorter
3768      offsets, place them here.  */
3769   else if (fdplt && gad->min > wrapmin)
3770     {
3771       bfd_vma fds;
3772       if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3773         fds = gad->min - wrapmin;
3774       else
3775         fds = fdplt;
3776
3777       fdplt -= fds;
3778       gad->min -= fds;
3779       gad->fdplt += fds;
3780     }
3781
3782   /* If GOT entries took too much space, wrap some of them around.
3783      This may well cause gad->min to become lower than wrapmin.  This
3784      will cause a relocation overflow later on, so we don't have to
3785      report it here . */
3786   if ((bfd_vma) gad->max > wrap)
3787     {
3788       gad->min -= gad->max - wrap;
3789       gad->max = wrap;
3790     }
3791   /* If there is more space left, try to place some more function
3792      descriptors for PLT entries.  */
3793   else if (fdplt && (bfd_vma) gad->max < wrap)
3794     {
3795       bfd_vma fds;
3796       if ((bfd_vma) (wrap - gad->max) < fdplt)
3797         fds = wrap - gad->max;
3798       else
3799         fds = fdplt;
3800
3801       fdplt -= fds;
3802       gad->max += fds;
3803       gad->fdplt += fds;
3804     }
3805
3806   /* If odd was initially computed as an offset past the wrap point,
3807      wrap it around.  */
3808   if (odd > gad->max)
3809     odd = gad->min + odd - gad->max;
3810
3811   /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3812      before returning, so do it here too.  This guarantees that,
3813      should cur and fdcur meet at the wrap point, they'll both be
3814      equal to min.  */
3815   if (gad->cur == gad->max)
3816     gad->cur = gad->min;
3817
3818   return odd;
3819 }
3820
3821 /* Compute the location of the next GOT entry, given the allocation
3822    data for a range.  */
3823
3824 inline static bfd_signed_vma
3825 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3826 {
3827   bfd_signed_vma ret;
3828
3829   if (gad->odd)
3830     {
3831       /* If there was an odd word left behind, use it.  */
3832       ret = gad->odd;
3833       gad->odd = 0;
3834     }
3835   else
3836     {
3837       /* Otherwise, use the word pointed to by cur, reserve the next
3838          as an odd word, and skip to the next pair of words, possibly
3839          wrapping around.  */
3840       ret = gad->cur;
3841       gad->odd = gad->cur + 4;
3842       gad->cur += 8;
3843       if (gad->cur == gad->max)
3844         gad->cur = gad->min;
3845     }
3846
3847   return ret;
3848 }
3849
3850 /* Compute the location of the next function descriptor entry in the
3851    GOT, given the allocation data for a range.  */
3852
3853 inline static bfd_signed_vma
3854 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3855 {
3856   /* If we're at the bottom, wrap around, and only then allocate the
3857      next pair of words.  */
3858   if (gad->fdcur == gad->min)
3859     gad->fdcur = gad->max;
3860   return gad->fdcur -= 8;
3861 }
3862
3863 /* Assign GOT offsets for every GOT entry and function descriptor.
3864    Doing everything in a single pass is tricky.  */
3865
3866 static int
3867 _bfinfdpic_assign_got_entries (void **entryp, void *info_)
3868 {
3869   struct bfinfdpic_relocs_info *entry = *entryp;
3870   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3871
3872   if (entry->got17m4)
3873     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3874   else if (entry->gothilo)
3875     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3876
3877   if (entry->fdgot17m4)
3878     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3879   else if (entry->fdgothilo)
3880     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3881
3882   if (entry->fdgoff17m4)
3883     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3884   else if (entry->plt && dinfo->got17m4.fdplt)
3885     {
3886       dinfo->got17m4.fdplt -= 8;
3887       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3888     }
3889   else if (entry->plt)
3890     {
3891       dinfo->gothilo.fdplt -= 8;
3892       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3893     }
3894   else if (entry->privfd)
3895     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3896
3897   return 1;
3898 }
3899
3900 /* Assign GOT offsets to private function descriptors used by PLT
3901    entries (or referenced by 32-bit offsets), as well as PLT entries
3902    and lazy PLT entries.  */
3903
3904 static int
3905 _bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3906 {
3907   struct bfinfdpic_relocs_info *entry = *entryp;
3908   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3909
3910   /* If this symbol requires a local function descriptor, allocate
3911      one.  */
3912   if (entry->privfd && entry->fd_entry == 0)
3913     {
3914       if (dinfo->got17m4.fdplt)
3915         {
3916           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3917           dinfo->got17m4.fdplt -= 8;
3918         }
3919       else
3920         {
3921           BFD_ASSERT (dinfo->gothilo.fdplt);
3922           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3923           dinfo->gothilo.fdplt -= 8;
3924         }
3925     }
3926
3927   if (entry->plt)
3928     {
3929       int size;
3930
3931       /* We use the section's raw size to mark the location of the
3932          next PLT entry.  */
3933       entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3934
3935       /* Figure out the length of this PLT entry based on the
3936          addressing mode we need to reach the function descriptor.  */
3937       BFD_ASSERT (entry->fd_entry);
3938       if (entry->fd_entry >= -(1 << (18 - 1))
3939           && entry->fd_entry + 4 < (1 << (18 - 1)))
3940         size = 10;
3941       else
3942         size = 16;
3943
3944       bfinfdpic_plt_section (dinfo->g.info)->size += size;
3945     }
3946
3947   if (entry->lazyplt)
3948     {
3949       entry->lzplt_entry = dinfo->g.lzplt;
3950       dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3951       /* If this entry is the one that gets the resolver stub, account
3952          for the additional instruction.  */
3953       if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3954           == BFINFDPIC_LZPLT_RESOLV_LOC)
3955         dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3956     }
3957
3958   return 1;
3959 }
3960
3961 /* Cancel out any effects of calling _bfinfdpic_assign_got_entries and
3962    _bfinfdpic_assign_plt_entries.  */
3963
3964 static int
3965 _bfinfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
3966 {
3967   struct bfinfdpic_relocs_info *entry = *entryp;
3968
3969   entry->got_entry = 0;
3970   entry->fdgot_entry = 0;
3971   entry->fd_entry = 0;
3972   entry->plt_entry = (bfd_vma)-1;
3973   entry->lzplt_entry = (bfd_vma)-1;
3974
3975   return 1;
3976 }
3977
3978 /* Follow indirect and warning hash entries so that each got entry
3979    points to the final symbol definition.  P must point to a pointer
3980    to the hash table we're traversing.  Since this traversal may
3981    modify the hash table, we set this pointer to NULL to indicate
3982    we've made a potentially-destructive change to the hash table, so
3983    the traversal must be restarted.  */
3984 static int
3985 _bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
3986 {
3987   struct bfinfdpic_relocs_info *entry = *entryp;
3988   htab_t *htab = p;
3989
3990   if (entry->symndx == -1)
3991     {
3992       struct elf_link_hash_entry *h = entry->d.h;
3993       struct bfinfdpic_relocs_info *oentry;
3994
3995       while (h->root.type == bfd_link_hash_indirect
3996              || h->root.type == bfd_link_hash_warning)
3997         h = (struct elf_link_hash_entry *)h->root.u.i.link;
3998
3999       if (entry->d.h == h)
4000         return 1;
4001
4002       oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
4003                                                 NO_INSERT);
4004
4005       if (oentry)
4006         {
4007           /* Merge the two entries.  */
4008           bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
4009           htab_clear_slot (*htab, entryp);
4010           return 1;
4011         }
4012
4013       entry->d.h = h;
4014
4015       /* If we can't find this entry with the new bfd hash, re-insert
4016          it, and get the traversal restarted.  */
4017       if (! htab_find (*htab, entry))
4018         {
4019           htab_clear_slot (*htab, entryp);
4020           entryp = htab_find_slot (*htab, entry, INSERT);
4021           if (! *entryp)
4022             *entryp = entry;
4023           /* Abort the traversal, since the whole table may have
4024              moved, and leave it up to the parent to restart the
4025              process.  */
4026           *(htab_t *)p = NULL;
4027           return 0;
4028         }
4029     }
4030
4031   return 1;
4032 }
4033
4034 /* Compute the total size of the GOT, the PLT, the dynamic relocations
4035    section and the rofixup section.  Assign locations for GOT and PLT
4036    entries.  */
4037
4038 static bfd_boolean
4039 _bfinfdpic_size_got_plt (bfd *output_bfd,
4040                          struct _bfinfdpic_dynamic_got_plt_info *gpinfop)
4041 {
4042   bfd_signed_vma odd;
4043   bfd_vma limit;
4044   struct bfd_link_info *info = gpinfop->g.info;
4045   bfd *dynobj = elf_hash_table (info)->dynobj;
4046
4047   memcpy (bfinfdpic_dynamic_got_plt_info (info), &gpinfop->g,
4048           sizeof (gpinfop->g));
4049
4050   odd = 12;
4051   /* Compute the total size taken by entries in the 18-bit range,
4052      to tell how many PLT function descriptors we can bring into it
4053      without causing it to overflow.  */
4054   limit = odd + gpinfop->g.got17m4 + gpinfop->g.fd17m4;
4055   if (limit < (bfd_vma)1 << 18)
4056     limit = ((bfd_vma)1 << 18) - limit;
4057   else
4058     limit = 0;
4059   if (gpinfop->g.fdplt < limit)
4060     limit = gpinfop->g.fdplt;
4061
4062   /* Determine the ranges of GOT offsets that we can use for each
4063      range of addressing modes.  */
4064   odd = _bfinfdpic_compute_got_alloc_data (&gpinfop->got17m4,
4065                                           0,
4066                                           odd,
4067                                           16,
4068                                           gpinfop->g.got17m4,
4069                                           gpinfop->g.fd17m4,
4070                                           limit,
4071                                           (bfd_vma)1 << (18-1));
4072   odd = _bfinfdpic_compute_got_alloc_data (&gpinfop->gothilo,
4073                                           gpinfop->got17m4.min,
4074                                           odd,
4075                                           gpinfop->got17m4.max,
4076                                           gpinfop->g.gothilo,
4077                                           gpinfop->g.fdhilo,
4078                                           gpinfop->g.fdplt - gpinfop->got17m4.fdplt,
4079                                           (bfd_vma)1 << (32-1));
4080
4081   /* Now assign (most) GOT offsets.  */
4082   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
4083                  gpinfop);
4084
4085   bfinfdpic_got_section (info)->size = gpinfop->gothilo.max
4086     - gpinfop->gothilo.min
4087     /* If an odd word is the last word of the GOT, we don't need this
4088        word to be part of the GOT.  */
4089     - (odd + 4 == gpinfop->gothilo.max ? 4 : 0);
4090   if (bfinfdpic_got_section (info)->size == 0)
4091     bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4092   else if (bfinfdpic_got_section (info)->size == 12
4093            && ! elf_hash_table (info)->dynamic_sections_created)
4094     {
4095       bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4096       bfinfdpic_got_section (info)->size = 0;
4097     }
4098   else
4099     {
4100       bfinfdpic_got_section (info)->contents =
4101         (bfd_byte *) bfd_zalloc (dynobj,
4102                                  bfinfdpic_got_section (info)->size);
4103       if (bfinfdpic_got_section (info)->contents == NULL)
4104         return FALSE;
4105     }
4106
4107   if (elf_hash_table (info)->dynamic_sections_created)
4108     /* Subtract the number of lzplt entries, since those will generate
4109        relocations in the pltrel section.  */
4110     bfinfdpic_gotrel_section (info)->size =
4111       (gpinfop->g.relocs - gpinfop->g.lzplt / LZPLT_NORMAL_SIZE)
4112       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4113   else
4114     BFD_ASSERT (gpinfop->g.relocs == 0);
4115   if (bfinfdpic_gotrel_section (info)->size == 0)
4116     bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
4117   else
4118     {
4119       bfinfdpic_gotrel_section (info)->contents =
4120         (bfd_byte *) bfd_zalloc (dynobj,
4121                                  bfinfdpic_gotrel_section (info)->size);
4122       if (bfinfdpic_gotrel_section (info)->contents == NULL)
4123         return FALSE;
4124     }
4125
4126   bfinfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
4127   if (bfinfdpic_gotfixup_section (info)->size == 0)
4128     bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
4129   else
4130     {
4131       bfinfdpic_gotfixup_section (info)->contents =
4132         (bfd_byte *) bfd_zalloc (dynobj,
4133                                  bfinfdpic_gotfixup_section (info)->size);
4134       if (bfinfdpic_gotfixup_section (info)->contents == NULL)
4135         return FALSE;
4136     }
4137
4138   if (elf_hash_table (info)->dynamic_sections_created)
4139     bfinfdpic_pltrel_section (info)->size =
4140       gpinfop->g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4141   if (bfinfdpic_pltrel_section (info)->size == 0)
4142     bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
4143   else
4144     {
4145       bfinfdpic_pltrel_section (info)->contents =
4146         (bfd_byte *) bfd_zalloc (dynobj,
4147                                  bfinfdpic_pltrel_section (info)->size);
4148       if (bfinfdpic_pltrel_section (info)->contents == NULL)
4149         return FALSE;
4150     }
4151
4152   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4153      such that there's room for the additional instruction needed to
4154      call the resolver.  Since _bfinfdpic_assign_got_entries didn't
4155      account for them, our block size is 4 bytes smaller than the real
4156      block size.  */
4157   if (elf_hash_table (info)->dynamic_sections_created)
4158     {
4159       bfinfdpic_plt_section (info)->size = gpinfop->g.lzplt
4160         + ((gpinfop->g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
4161            / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
4162     }
4163
4164   /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4165      actually assign lazy PLT entries addresses.  */
4166   gpinfop->g.lzplt = 0;
4167
4168   /* Save information that we're going to need to generate GOT and PLT
4169      entries.  */
4170   bfinfdpic_got_initial_offset (info) = -gpinfop->gothilo.min;
4171
4172   if (get_elf_backend_data (output_bfd)->want_got_sym)
4173     elf_hash_table (info)->hgot->root.u.def.value
4174       = bfinfdpic_got_initial_offset (info);
4175
4176   if (elf_hash_table (info)->dynamic_sections_created)
4177     bfinfdpic_plt_initial_offset (info) =
4178       bfinfdpic_plt_section (info)->size;
4179
4180   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4181                  gpinfop);
4182
4183   /* Allocate the PLT section contents only after
4184      _bfinfdpic_assign_plt_entries has a chance to add the size of the
4185      non-lazy PLT entries.  */
4186   if (bfinfdpic_plt_section (info)->size == 0)
4187     bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4188   else
4189     {
4190       bfinfdpic_plt_section (info)->contents =
4191         (bfd_byte *) bfd_zalloc (dynobj,
4192                                  bfinfdpic_plt_section (info)->size);
4193       if (bfinfdpic_plt_section (info)->contents == NULL)
4194         return FALSE;
4195     }
4196
4197   return TRUE;
4198 }
4199
4200 /* Set the sizes of the dynamic sections.  */
4201
4202 static bfd_boolean
4203 elf32_bfinfdpic_size_dynamic_sections (bfd *output_bfd,
4204                                       struct bfd_link_info *info)
4205 {
4206   struct elf_link_hash_table *htab;
4207   bfd *dynobj;
4208   asection *s;
4209   struct _bfinfdpic_dynamic_got_plt_info gpinfo;
4210
4211   htab = elf_hash_table (info);
4212   dynobj = htab->dynobj;
4213   BFD_ASSERT (dynobj != NULL);
4214
4215   if (htab->dynamic_sections_created)
4216     {
4217       /* Set the contents of the .interp section to the interpreter.  */
4218       if (bfd_link_executable (info) && !info->nointerp)
4219         {
4220           s = bfd_get_linker_section (dynobj, ".interp");
4221           BFD_ASSERT (s != NULL);
4222           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4223           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
4224         }
4225     }
4226
4227   memset (&gpinfo, 0, sizeof (gpinfo));
4228   gpinfo.g.info = info;
4229
4230   for (;;)
4231     {
4232       htab_t relocs = bfinfdpic_relocs_info (info);
4233
4234       htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
4235
4236       if (relocs == bfinfdpic_relocs_info (info))
4237         break;
4238     }
4239
4240   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
4241                  &gpinfo.g);
4242
4243   /* Allocate space to save the summary information, we're going to
4244      use it if we're doing relaxations.  */
4245   bfinfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
4246
4247   if (!_bfinfdpic_size_got_plt (output_bfd, &gpinfo))
4248       return FALSE;
4249
4250   if (elf_hash_table (info)->dynamic_sections_created)
4251     {
4252       if (bfinfdpic_got_section (info)->size)
4253         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
4254           return FALSE;
4255
4256       if (bfinfdpic_pltrel_section (info)->size)
4257         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4258             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
4259             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4260           return FALSE;
4261
4262       if (bfinfdpic_gotrel_section (info)->size)
4263         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
4264             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
4265             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
4266                                             sizeof (Elf32_External_Rel)))
4267           return FALSE;
4268     }
4269
4270   s = bfd_get_linker_section (dynobj, ".dynbss");
4271   if (s && s->size == 0)
4272     s->flags |= SEC_EXCLUDE;
4273
4274   s = bfd_get_linker_section (dynobj, ".rela.bss");
4275   if (s && s->size == 0)
4276     s->flags |= SEC_EXCLUDE;
4277
4278   return TRUE;
4279 }
4280
4281 static bfd_boolean
4282 elf32_bfinfdpic_always_size_sections (bfd *output_bfd,
4283                                      struct bfd_link_info *info)
4284 {
4285   if (!bfd_link_relocatable (info)
4286       && !bfd_elf_stack_segment_size (output_bfd, info,
4287                                       "__stacksize", DEFAULT_STACK_SIZE))
4288     return FALSE;
4289
4290   return TRUE;
4291 }
4292
4293 /* Check whether any of the relocations was optimized away, and
4294    subtract it from the relocation or fixup count.  */
4295 static bfd_boolean
4296 _bfinfdpic_check_discarded_relocs (bfd *abfd, asection *sec,
4297                                    struct bfd_link_info *info,
4298                                    bfd_boolean *changed)
4299 {
4300   Elf_Internal_Shdr *symtab_hdr;
4301   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4302   Elf_Internal_Rela *rel, *erel;
4303
4304   if ((sec->flags & SEC_RELOC) == 0
4305       || sec->reloc_count == 0)
4306     return TRUE;
4307
4308   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4309   sym_hashes = elf_sym_hashes (abfd);
4310   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4311   if (!elf_bad_symtab (abfd))
4312     sym_hashes_end -= symtab_hdr->sh_info;
4313
4314   rel = elf_section_data (sec)->relocs;
4315
4316   /* Now examine each relocation.  */
4317   for (erel = rel + sec->reloc_count; rel < erel; rel++)
4318     {
4319       struct elf_link_hash_entry *h;
4320       unsigned long r_symndx;
4321       struct bfinfdpic_relocs_info *picrel;
4322       struct _bfinfdpic_dynamic_got_info *dinfo;
4323
4324       if (ELF32_R_TYPE (rel->r_info) != R_BFIN_BYTE4_DATA
4325           && ELF32_R_TYPE (rel->r_info) != R_BFIN_FUNCDESC)
4326         continue;
4327
4328       if (_bfd_elf_section_offset (sec->output_section->owner,
4329                                    info, sec, rel->r_offset)
4330           != (bfd_vma)-1)
4331         continue;
4332
4333       r_symndx = ELF32_R_SYM (rel->r_info);
4334       if (r_symndx < symtab_hdr->sh_info)
4335         h = NULL;
4336       else
4337         {
4338           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4339           while (h->root.type == bfd_link_hash_indirect
4340                  || h->root.type == bfd_link_hash_warning)
4341             h = (struct elf_link_hash_entry *)h->root.u.i.link;
4342         }
4343
4344       if (h != NULL)
4345         picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4346                                                   abfd, h,
4347                                                   rel->r_addend, NO_INSERT);
4348       else
4349         picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info),
4350                                                  abfd, r_symndx,
4351                                                  rel->r_addend, NO_INSERT);
4352
4353       if (! picrel)
4354         return FALSE;
4355
4356       *changed = TRUE;
4357       dinfo = bfinfdpic_dynamic_got_plt_info (info);
4358
4359       _bfinfdpic_count_relocs_fixups (picrel, dinfo, TRUE);
4360       if (ELF32_R_TYPE (rel->r_info) == R_BFIN_BYTE4_DATA)
4361         picrel->relocs32--;
4362       else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4363         picrel->relocsfd--;
4364       _bfinfdpic_count_relocs_fixups (picrel, dinfo, FALSE);
4365     }
4366
4367   return TRUE;
4368 }
4369
4370 static bfd_boolean
4371 bfinfdpic_elf_discard_info (bfd *ibfd,
4372                            struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED,
4373                            struct bfd_link_info *info)
4374 {
4375   bfd_boolean changed = FALSE;
4376   asection *s;
4377   bfd *obfd = NULL;
4378
4379   /* Account for relaxation of .eh_frame section.  */
4380   for (s = ibfd->sections; s; s = s->next)
4381     if (s->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4382       {
4383         if (!_bfinfdpic_check_discarded_relocs (ibfd, s, info, &changed))
4384           return FALSE;
4385         obfd = s->output_section->owner;
4386       }
4387
4388   if (changed)
4389     {
4390       struct _bfinfdpic_dynamic_got_plt_info gpinfo;
4391
4392       memset (&gpinfo, 0, sizeof (gpinfo));
4393       memcpy (&gpinfo.g, bfinfdpic_dynamic_got_plt_info (info),
4394               sizeof (gpinfo.g));
4395
4396       /* Clear GOT and PLT assignments.  */
4397       htab_traverse (bfinfdpic_relocs_info (info),
4398                      _bfinfdpic_reset_got_plt_entries,
4399                      NULL);
4400
4401       if (!_bfinfdpic_size_got_plt (obfd, &gpinfo))
4402         return FALSE;
4403     }
4404
4405   return TRUE;
4406 }
4407
4408 static bfd_boolean
4409 elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4410                                         struct bfd_link_info *info)
4411 {
4412   bfd *dynobj;
4413   asection *sdyn;
4414
4415   dynobj = elf_hash_table (info)->dynobj;
4416
4417   if (bfinfdpic_got_section (info))
4418     {
4419       BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4420                   /* PR 17334: It appears that the GOT section can end up
4421                      being bigger than the number of relocs.  Presumably
4422                      because some relocs have been deleted.  A test case has
4423                      yet to be generated for verify this, but in the meantime
4424                      the test below has been changed from == to >= so that
4425                      applications can continue to be built.  */
4426                   >= (bfinfdpic_gotrel_section (info)->reloc_count
4427                       * sizeof (Elf32_External_Rel)));
4428
4429       if (bfinfdpic_gotfixup_section (info))
4430         {
4431           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4432           bfd_vma got_value = hgot->root.u.def.value
4433             + hgot->root.u.def.section->output_section->vma
4434             + hgot->root.u.def.section->output_offset;
4435
4436           _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4437                                  got_value, 0);
4438
4439           if (bfinfdpic_gotfixup_section (info)->size
4440               != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4441             {
4442               _bfd_error_handler
4443                 ("LINKER BUG: .rofixup section size mismatch");
4444               return FALSE;
4445             }
4446         }
4447     }
4448   if (elf_hash_table (info)->dynamic_sections_created)
4449     {
4450       BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4451                   == (bfinfdpic_pltrel_section (info)->reloc_count
4452                       * sizeof (Elf32_External_Rel)));
4453     }
4454
4455   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4456
4457   if (elf_hash_table (info)->dynamic_sections_created)
4458     {
4459       Elf32_External_Dyn * dyncon;
4460       Elf32_External_Dyn * dynconend;
4461
4462       BFD_ASSERT (sdyn != NULL);
4463
4464       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4465       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4466
4467       for (; dyncon < dynconend; dyncon++)
4468         {
4469           Elf_Internal_Dyn dyn;
4470
4471           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4472
4473           switch (dyn.d_tag)
4474             {
4475             default:
4476               break;
4477
4478             case DT_PLTGOT:
4479               dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4480                 + bfinfdpic_got_section (info)->output_offset
4481                 + bfinfdpic_got_initial_offset (info);
4482               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4483               break;
4484
4485             case DT_JMPREL:
4486               dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4487                 ->output_section->vma
4488                 + bfinfdpic_pltrel_section (info)->output_offset;
4489               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4490               break;
4491
4492             case DT_PLTRELSZ:
4493               dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4494               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4495               break;
4496             }
4497         }
4498     }
4499
4500   return TRUE;
4501 }
4502
4503 /* Adjust a symbol defined by a dynamic object and referenced by a
4504    regular object.  */
4505
4506 static bfd_boolean
4507 elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info *info,
4508                                        struct elf_link_hash_entry *h)
4509 {
4510   bfd * dynobj;
4511
4512   dynobj = elf_hash_table (info)->dynobj;
4513
4514   /* Make sure we know what is going on here.  */
4515   BFD_ASSERT (dynobj != NULL
4516               && (h->u.weakdef != NULL
4517                   || (h->def_dynamic
4518                       && h->ref_regular
4519                       && !h->def_regular)));
4520
4521   /* If this is a weak symbol, and there is a real definition, the
4522      processor independent code will have arranged for us to see the
4523      real definition first, and we can just use the same value.  */
4524   if (h->u.weakdef != NULL)
4525     {
4526       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4527                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4528       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4529       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4530     }
4531
4532   return TRUE;
4533 }
4534
4535 /* Perform any actions needed for dynamic symbols.  */
4536
4537 static bfd_boolean
4538 elf32_bfinfdpic_finish_dynamic_symbol
4539 (bfd *output_bfd ATTRIBUTE_UNUSED,
4540  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4541  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4542  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4543 {
4544   return TRUE;
4545 }
4546
4547 /* Decide whether to attempt to turn absptr or lsda encodings in
4548    shared libraries into pcrel within the given input section.  */
4549
4550 static bfd_boolean
4551 bfinfdpic_elf_use_relative_eh_frame
4552 (bfd *input_bfd ATTRIBUTE_UNUSED,
4553  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4554  asection *eh_frame_section ATTRIBUTE_UNUSED)
4555 {
4556   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
4557   return FALSE;
4558 }
4559
4560 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
4561
4562 static bfd_byte
4563 bfinfdpic_elf_encode_eh_address (bfd *abfd,
4564                                 struct bfd_link_info *info,
4565                                 asection *osec, bfd_vma offset,
4566                                 asection *loc_sec, bfd_vma loc_offset,
4567                                 bfd_vma *encoded)
4568 {
4569   struct elf_link_hash_entry *h;
4570
4571   h = elf_hash_table (info)->hgot;
4572   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4573
4574   if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4575               == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4576     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4577                                        loc_sec, loc_offset, encoded);
4578
4579   BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4580               == (_bfinfdpic_osec_to_segment
4581                   (abfd, h->root.u.def.section->output_section)));
4582
4583   *encoded = osec->vma + offset
4584     - (h->root.u.def.value
4585        + h->root.u.def.section->output_section->vma
4586        + h->root.u.def.section->output_offset);
4587
4588   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4589 }
4590
4591
4592
4593 /* Look through the relocs for a section during the first phase.
4594
4595    Besides handling virtual table relocs for gc, we have to deal with
4596    all sorts of PIC-related relocations.  We describe below the
4597    general plan on how to handle such relocations, even though we only
4598    collect information at this point, storing them in hash tables for
4599    perusal of later passes.
4600
4601    32 relocations are propagated to the linker output when creating
4602    position-independent output.  LO16 and HI16 relocations are not
4603    supposed to be encountered in this case.
4604
4605    LABEL16 should always be resolvable by the linker, since it's only
4606    used by branches.
4607
4608    LABEL24, on the other hand, is used by calls.  If it turns out that
4609    the target of a call is a dynamic symbol, a PLT entry must be
4610    created for it, which triggers the creation of a private function
4611    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4612
4613    GPREL relocations require the referenced symbol to be in the same
4614    segment as _gp, but this can only be checked later.
4615
4616    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4617    exist.  LABEL24 might as well, since it may require a PLT entry,
4618    that will require a got.
4619
4620    Non-FUNCDESC GOT relocations require a GOT entry to be created
4621    regardless of whether the symbol is dynamic.  However, since a
4622    global symbol that turns out to not be exported may have the same
4623    address of a non-dynamic symbol, we don't assign GOT entries at
4624    this point, such that we can share them in this case.  A relocation
4625    for the GOT entry always has to be created, be it to offset a
4626    private symbol by the section load address, be it to get the symbol
4627    resolved dynamically.
4628
4629    FUNCDESC GOT relocations require a GOT entry to be created, and
4630    handled as if a FUNCDESC relocation was applied to the GOT entry in
4631    an object file.
4632
4633    FUNCDESC relocations referencing a symbol that turns out to NOT be
4634    dynamic cause a private function descriptor to be created.  The
4635    FUNCDESC relocation then decays to a 32 relocation that points at
4636    the private descriptor.  If the symbol is dynamic, the FUNCDESC
4637    relocation is propagated to the linker output, such that the
4638    dynamic linker creates the canonical descriptor, pointing to the
4639    dynamically-resolved definition of the function.
4640
4641    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4642    symbols that are assigned to the same segment as the GOT, but we
4643    can only check this later, after we know the complete set of
4644    symbols defined and/or exported.
4645
4646    FUNCDESC GOTOFF relocations require a function descriptor to be
4647    created and, unless lazy binding is disabled or the symbol is not
4648    dynamic, a lazy PLT entry.  Since we can't tell at this point
4649    whether a symbol is going to be dynamic, we have to decide later
4650    whether to create a lazy PLT entry or bind the descriptor directly
4651    to the private function.
4652
4653    FUNCDESC_VALUE relocations are not supposed to be present in object
4654    files, but they may very well be simply propagated to the linker
4655    output, since they have no side effect.
4656
4657
4658    A function descriptor always requires a FUNCDESC_VALUE relocation.
4659    Whether it's in .plt.rel or not depends on whether lazy binding is
4660    enabled and on whether the referenced symbol is dynamic.
4661
4662    The existence of a lazy PLT requires the resolverStub lazy PLT
4663    entry to be present.
4664
4665
4666    As for assignment of GOT, PLT and lazy PLT entries, and private
4667    descriptors, we might do them all sequentially, but we can do
4668    better than that.  For example, we can place GOT entries and
4669    private function descriptors referenced using 12-bit operands
4670    closer to the PIC register value, such that these relocations don't
4671    overflow.  Those that are only referenced with LO16 relocations
4672    could come next, but we may as well place PLT-required function
4673    descriptors in the 12-bit range to make them shorter.  Symbols
4674    referenced with LO16/HI16 may come next, but we may place
4675    additional function descriptors in the 16-bit range if we can
4676    reliably tell that we've already placed entries that are ever
4677    referenced with only LO16.  PLT entries are therefore generated as
4678    small as possible, while not introducing relocation overflows in
4679    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
4680    generated before or after PLT entries, but not intermingled with
4681    them, such that we can have more lazy PLT entries in range for a
4682    branch to the resolverStub.  The resolverStub should be emitted at
4683    the most distant location from the first lazy PLT entry such that
4684    it's still in range for a branch, or closer, if there isn't a need
4685    for so many lazy PLT entries.  Additional lazy PLT entries may be
4686    emitted after the resolverStub, as long as branches are still in
4687    range.  If the branch goes out of range, longer lazy PLT entries
4688    are emitted.
4689
4690    We could further optimize PLT and lazy PLT entries by giving them
4691    priority in assignment to closer-to-gr17 locations depending on the
4692    number of occurrences of references to them (assuming a function
4693    that's called more often is more important for performance, so its
4694    PLT entry should be faster), or taking hints from the compiler.
4695    Given infinite time and money... :-)  */
4696
4697 static bfd_boolean
4698 bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4699                         asection *sec, const Elf_Internal_Rela *relocs)
4700 {
4701   Elf_Internal_Shdr *symtab_hdr;
4702   struct elf_link_hash_entry **sym_hashes;
4703   const Elf_Internal_Rela *rel;
4704   const Elf_Internal_Rela *rel_end;
4705   bfd *dynobj;
4706   struct bfinfdpic_relocs_info *picrel;
4707
4708   if (bfd_link_relocatable (info))
4709     return TRUE;
4710
4711   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4712   sym_hashes = elf_sym_hashes (abfd);
4713
4714   dynobj = elf_hash_table (info)->dynobj;
4715   rel_end = relocs + sec->reloc_count;
4716   for (rel = relocs; rel < rel_end; rel++)
4717     {
4718       struct elf_link_hash_entry *h;
4719       unsigned long r_symndx;
4720
4721       r_symndx = ELF32_R_SYM (rel->r_info);
4722       if (r_symndx < symtab_hdr->sh_info)
4723         h = NULL;
4724       else
4725         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4726
4727       switch (ELF32_R_TYPE (rel->r_info))
4728         {
4729         case R_BFIN_GOT17M4:
4730         case R_BFIN_GOTHI:
4731         case R_BFIN_GOTLO:
4732         case R_BFIN_FUNCDESC_GOT17M4:
4733         case R_BFIN_FUNCDESC_GOTHI:
4734         case R_BFIN_FUNCDESC_GOTLO:
4735         case R_BFIN_GOTOFF17M4:
4736         case R_BFIN_GOTOFFHI:
4737         case R_BFIN_GOTOFFLO:
4738         case R_BFIN_FUNCDESC_GOTOFF17M4:
4739         case R_BFIN_FUNCDESC_GOTOFFHI:
4740         case R_BFIN_FUNCDESC_GOTOFFLO:
4741         case R_BFIN_FUNCDESC:
4742         case R_BFIN_FUNCDESC_VALUE:
4743           if (! IS_FDPIC (abfd))
4744             goto bad_reloc;
4745           /* Fall through.  */
4746         case R_BFIN_PCREL24:
4747         case R_BFIN_PCREL24_JUMP_L:
4748         case R_BFIN_BYTE4_DATA:
4749           if (IS_FDPIC (abfd) && ! dynobj)
4750             {
4751               elf_hash_table (info)->dynobj = dynobj = abfd;
4752               if (! _bfin_create_got_section (abfd, info))
4753                 return FALSE;
4754             }
4755           if (! IS_FDPIC (abfd))
4756             {
4757               picrel = NULL;
4758               break;
4759             }
4760           if (h != NULL)
4761             {
4762               if (h->dynindx == -1)
4763                 switch (ELF_ST_VISIBILITY (h->other))
4764                   {
4765                   case STV_INTERNAL:
4766                   case STV_HIDDEN:
4767                     break;
4768                   default:
4769                     bfd_elf_link_record_dynamic_symbol (info, h);
4770                     break;
4771                   }
4772               picrel
4773                 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4774                                                    abfd, h,
4775                                                    rel->r_addend, INSERT);
4776             }
4777           else
4778             picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4779                                                      (info), abfd, r_symndx,
4780                                                      rel->r_addend, INSERT);
4781           if (! picrel)
4782             return FALSE;
4783           break;
4784
4785         default:
4786           picrel = NULL;
4787           break;
4788         }
4789
4790       switch (ELF32_R_TYPE (rel->r_info))
4791         {
4792         case R_BFIN_PCREL24:
4793         case R_BFIN_PCREL24_JUMP_L:
4794           if (IS_FDPIC (abfd))
4795             picrel->call++;
4796           break;
4797
4798         case R_BFIN_FUNCDESC_VALUE:
4799           picrel->relocsfdv++;
4800           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4801             picrel->relocs32--;
4802           /* Fall through.  */
4803
4804         case R_BFIN_BYTE4_DATA:
4805           if (! IS_FDPIC (abfd))
4806             break;
4807
4808           picrel->sym++;
4809           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4810             picrel->relocs32++;
4811           break;
4812
4813         case R_BFIN_GOT17M4:
4814           picrel->got17m4++;
4815           break;
4816
4817         case R_BFIN_GOTHI:
4818         case R_BFIN_GOTLO:
4819           picrel->gothilo++;
4820           break;
4821
4822         case R_BFIN_FUNCDESC_GOT17M4:
4823           picrel->fdgot17m4++;
4824           break;
4825
4826         case R_BFIN_FUNCDESC_GOTHI:
4827         case R_BFIN_FUNCDESC_GOTLO:
4828           picrel->fdgothilo++;
4829           break;
4830
4831         case R_BFIN_GOTOFF17M4:
4832         case R_BFIN_GOTOFFHI:
4833         case R_BFIN_GOTOFFLO:
4834           picrel->gotoff++;
4835           break;
4836
4837         case R_BFIN_FUNCDESC_GOTOFF17M4:
4838           picrel->fdgoff17m4++;
4839           break;
4840
4841         case R_BFIN_FUNCDESC_GOTOFFHI:
4842         case R_BFIN_FUNCDESC_GOTOFFLO:
4843           picrel->fdgoffhilo++;
4844           break;
4845
4846         case R_BFIN_FUNCDESC:
4847           picrel->fd++;
4848           picrel->relocsfd++;
4849           break;
4850
4851         /* This relocation describes the C++ object vtable hierarchy.
4852            Reconstruct it for later use during GC.  */
4853         case R_BFIN_GNU_VTINHERIT:
4854           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4855             return FALSE;
4856           break;
4857
4858         /* This relocation describes which C++ vtable entries are actually
4859            used.  Record for later use during GC.  */
4860         case R_BFIN_GNU_VTENTRY:
4861           BFD_ASSERT (h != NULL);
4862           if (h != NULL
4863               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4864             return FALSE;
4865           break;
4866
4867         case R_BFIN_HUIMM16:
4868         case R_BFIN_LUIMM16:
4869         case R_BFIN_PCREL12_JUMP_S:
4870         case R_BFIN_PCREL10:
4871           break;
4872
4873         default:
4874         bad_reloc:
4875           _bfd_error_handler
4876             /* xgettext:c-format */
4877             (_("%B: unsupported relocation type %i"),
4878              abfd, ELF32_R_TYPE (rel->r_info));
4879           return FALSE;
4880         }
4881     }
4882
4883   return TRUE;
4884 }
4885
4886 /* Set the right machine number for a Blackfin ELF file.  */
4887
4888 static bfd_boolean
4889 elf32_bfin_object_p (bfd *abfd)
4890 {
4891   bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4892   return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4893           == (IS_FDPIC (abfd)));
4894 }
4895
4896 static bfd_boolean
4897 elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4898 {
4899   elf_elfheader (abfd)->e_flags = flags;
4900   elf_flags_init (abfd) = TRUE;
4901   return TRUE;
4902 }
4903
4904 /* Display the flags field.  */
4905 static bfd_boolean
4906 elf32_bfin_print_private_bfd_data (bfd * abfd, void * ptr)
4907 {
4908   FILE *file = (FILE *) ptr;
4909   flagword flags;
4910
4911   BFD_ASSERT (abfd != NULL && ptr != NULL);
4912
4913   /* Print normal ELF private data.  */
4914   _bfd_elf_print_private_bfd_data (abfd, ptr);
4915
4916   flags = elf_elfheader (abfd)->e_flags;
4917
4918   /* xgettext:c-format */
4919   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4920
4921   if (flags & EF_BFIN_PIC)
4922     fprintf (file, " -fpic");
4923
4924   if (flags & EF_BFIN_FDPIC)
4925     fprintf (file, " -mfdpic");
4926
4927   fputc ('\n', file);
4928
4929   return TRUE;
4930 }
4931
4932 /* Merge backend specific data from an object file to the output
4933    object file when linking.  */
4934
4935 static bfd_boolean
4936 elf32_bfin_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4937 {
4938   bfd *obfd = info->output_bfd;
4939   flagword old_flags, new_flags;
4940   bfd_boolean error = FALSE;
4941
4942   new_flags = elf_elfheader (ibfd)->e_flags;
4943   old_flags = elf_elfheader (obfd)->e_flags;
4944
4945   if (new_flags & EF_BFIN_FDPIC)
4946     new_flags &= ~EF_BFIN_PIC;
4947
4948 #ifndef DEBUG
4949   if (0)
4950 #endif
4951   _bfd_error_handler
4952     ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %B",
4953      old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no", ibfd);
4954
4955   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
4956     {
4957       elf_flags_init (obfd) = TRUE;
4958       elf_elfheader (obfd)->e_flags = new_flags;
4959     }
4960
4961   if (((new_flags & EF_BFIN_FDPIC) == 0) != (! IS_FDPIC (obfd)))
4962     {
4963       error = TRUE;
4964       if (IS_FDPIC (obfd))
4965         _bfd_error_handler
4966           (_("%B: cannot link non-fdpic object file into fdpic executable"),
4967            ibfd);
4968       else
4969         _bfd_error_handler
4970           (_("%B: cannot link fdpic object file into non-fdpic executable"),
4971            ibfd);
4972     }
4973
4974   if (error)
4975     bfd_set_error (bfd_error_bad_value);
4976
4977   return !error;
4978 }
4979 \f
4980 /* bfin ELF linker hash entry.  */
4981
4982 struct bfin_link_hash_entry
4983 {
4984   struct elf_link_hash_entry root;
4985
4986   /* Number of PC relative relocs copied for this symbol.  */
4987   struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
4988 };
4989
4990 /* bfin ELF linker hash table.  */
4991
4992 struct bfin_link_hash_table
4993 {
4994   struct elf_link_hash_table root;
4995
4996   /* Small local sym cache.  */
4997   struct sym_cache sym_cache;
4998 };
4999
5000 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
5001
5002 static struct bfd_hash_entry *
5003 bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
5004                         struct bfd_hash_table *table, const char *string)
5005 {
5006   struct bfd_hash_entry *ret = entry;
5007
5008   /* Allocate the structure if it has not already been allocated by a
5009      subclass.  */
5010   if (ret == NULL)
5011     ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
5012   if (ret == NULL)
5013     return ret;
5014
5015   /* Call the allocation method of the superclass.  */
5016   ret = _bfd_elf_link_hash_newfunc (ret, table, string);
5017   if (ret != NULL)
5018     bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
5019
5020   return ret;
5021 }
5022
5023 /* Create an bfin ELF linker hash table.  */
5024
5025 static struct bfd_link_hash_table *
5026 bfin_link_hash_table_create (bfd * abfd)
5027 {
5028   struct bfin_link_hash_table *ret;
5029   bfd_size_type amt = sizeof (struct bfin_link_hash_table);
5030
5031   ret = bfd_zmalloc (amt);
5032   if (ret == NULL)
5033     return NULL;
5034
5035   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5036                                       bfin_link_hash_newfunc,
5037                                       sizeof (struct elf_link_hash_entry),
5038                                       BFIN_ELF_DATA))
5039     {
5040       free (ret);
5041       return NULL;
5042     }
5043
5044   ret->sym_cache.abfd = NULL;
5045
5046   return &ret->root.root;
5047 }
5048
5049 /* The size in bytes of an entry in the procedure linkage table.  */
5050
5051 /* Finish up the dynamic sections.  */
5052
5053 static bfd_boolean
5054 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5055                               struct bfd_link_info *info)
5056 {
5057   bfd *dynobj;
5058   asection *sdyn;
5059
5060   dynobj = elf_hash_table (info)->dynobj;
5061
5062   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5063
5064   if (elf_hash_table (info)->dynamic_sections_created)
5065     {
5066       Elf32_External_Dyn *dyncon, *dynconend;
5067
5068       BFD_ASSERT (sdyn != NULL);
5069
5070       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5071       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5072       for (; dyncon < dynconend; dyncon++)
5073         {
5074           Elf_Internal_Dyn dyn;
5075
5076           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5077
5078         }
5079
5080     }
5081   return TRUE;
5082 }
5083
5084 /* Finish up dynamic symbol handling.  We set the contents of various
5085    dynamic sections here.  */
5086
5087 static bfd_boolean
5088 bfin_finish_dynamic_symbol (bfd * output_bfd,
5089                             struct bfd_link_info *info,
5090                             struct elf_link_hash_entry *h,
5091                             Elf_Internal_Sym * sym)
5092 {
5093   if (h->got.offset != (bfd_vma) - 1)
5094     {
5095       asection *sgot;
5096       asection *srela;
5097       Elf_Internal_Rela rela;
5098       bfd_byte *loc;
5099
5100       /* This symbol has an entry in the global offset table.
5101          Set it up.  */
5102
5103       sgot = elf_hash_table (info)->sgot;
5104       srela = elf_hash_table (info)->srelgot;
5105       BFD_ASSERT (sgot != NULL && srela != NULL);
5106
5107       rela.r_offset = (sgot->output_section->vma
5108                        + sgot->output_offset
5109                        + (h->got.offset & ~(bfd_vma) 1));
5110
5111       /* If this is a -Bsymbolic link, and the symbol is defined
5112          locally, we just want to emit a RELATIVE reloc.  Likewise if
5113          the symbol was forced to be local because of a version file.
5114          The entry in the global offset table will already have been
5115          initialized in the relocate_section function.  */
5116       if (bfd_link_pic (info)
5117           && (info->symbolic
5118               || h->dynindx == -1 || h->forced_local) && h->def_regular)
5119         {
5120           _bfd_error_handler (_("*** check this relocation %s"),
5121                               __FUNCTION__);
5122           rela.r_info = ELF32_R_INFO (0, R_BFIN_PCREL24);
5123           rela.r_addend = bfd_get_signed_32 (output_bfd,
5124                                              (sgot->contents
5125                                               +
5126                                               (h->got.
5127                                                offset & ~(bfd_vma) 1)));
5128         }
5129       else
5130         {
5131           bfd_put_32 (output_bfd, (bfd_vma) 0,
5132                       sgot->contents + (h->got.offset & ~(bfd_vma) 1));
5133           rela.r_info = ELF32_R_INFO (h->dynindx, R_BFIN_GOT);
5134           rela.r_addend = 0;
5135         }
5136
5137       loc = srela->contents;
5138       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5139       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5140     }
5141
5142   if (h->needs_copy)
5143     {
5144       BFD_ASSERT (0);
5145     }
5146   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5147   if (strcmp (h->root.root.string, "__DYNAMIC") == 0
5148       || h == elf_hash_table (info)->hgot)
5149     sym->st_shndx = SHN_ABS;
5150
5151   return TRUE;
5152 }
5153
5154 /* Adjust a symbol defined by a dynamic object and referenced by a
5155    regular object.  The current definition is in some section of the
5156    dynamic object, but we're not including those sections.  We have to
5157    change the definition to something the rest of the link can
5158    understand.  */
5159
5160 static bfd_boolean
5161 bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
5162                             struct elf_link_hash_entry *h)
5163 {
5164   bfd *dynobj;
5165   asection *s;
5166   unsigned int power_of_two;
5167
5168   dynobj = elf_hash_table (info)->dynobj;
5169
5170   /* Make sure we know what is going on here.  */
5171   BFD_ASSERT (dynobj != NULL
5172               && (h->needs_plt
5173                   || h->u.weakdef != NULL
5174                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
5175
5176   /* If this is a function, put it in the procedure linkage table.  We
5177      will fill in the contents of the procedure linkage table later,
5178      when we know the address of the .got section.  */
5179   if (h->type == STT_FUNC || h->needs_plt)
5180     {
5181       BFD_ASSERT(0);
5182     }
5183
5184   /* If this is a weak symbol, and there is a real definition, the
5185      processor independent code will have arranged for us to see the
5186      real definition first, and we can just use the same value.  */
5187   if (h->u.weakdef != NULL)
5188     {
5189       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5190                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5191       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5192       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5193       return TRUE;
5194     }
5195
5196   /* This is a reference to a symbol defined by a dynamic object which
5197      is not a function.  */
5198
5199   /* If we are creating a shared library, we must presume that the
5200      only references to the symbol are via the global offset table.
5201      For such cases we need not do anything here; the relocations will
5202      be handled correctly by relocate_section.  */
5203   if (bfd_link_pic (info))
5204     return TRUE;
5205
5206   /* We must allocate the symbol in our .dynbss section, which will
5207      become part of the .bss section of the executable.  There will be
5208      an entry for this symbol in the .dynsym section.  The dynamic
5209      object will contain position independent code, so all references
5210      from the dynamic object to this symbol will go through the global
5211      offset table.  The dynamic linker will use the .dynsym entry to
5212      determine the address it must put in the global offset table, so
5213      both the dynamic object and the regular object will refer to the
5214      same memory location for the variable.  */
5215
5216   s = bfd_get_linker_section (dynobj, ".dynbss");
5217   BFD_ASSERT (s != NULL);
5218
5219 #if 0 /* Bfin does not currently have a COPY reloc.  */
5220   /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5221      copy the initial value out of the dynamic object and into the
5222      runtime process image.  We need to remember the offset into the
5223      .rela.bss section we are going to use.  */
5224   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5225     {
5226       asection *srel;
5227
5228       srel = bfd_get_linker_section (dynobj, ".rela.bss");
5229       BFD_ASSERT (srel != NULL);
5230       srel->size += sizeof (Elf32_External_Rela);
5231       h->needs_copy = 1;
5232     }
5233 #else
5234   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5235     {
5236       _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5237       return FALSE;
5238     }
5239 #endif
5240   /* We need to figure out the alignment required for this symbol.  I
5241      have no idea how ELF linkers handle this.  */
5242   power_of_two = bfd_log2 (h->size);
5243   if (power_of_two > 3)
5244     power_of_two = 3;
5245
5246   /* Apply the required alignment.  */
5247   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5248   if (power_of_two > bfd_get_section_alignment (dynobj, s))
5249     {
5250       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
5251         return FALSE;
5252     }
5253
5254   /* Define the symbol as being at this point in the section.  */
5255   h->root.u.def.section = s;
5256   h->root.u.def.value = s->size;
5257
5258   /* Increment the section size to make room for the symbol.  */
5259   s->size += h->size;
5260
5261   return TRUE;
5262 }
5263
5264 /* The bfin linker needs to keep track of the number of relocs that it
5265    decides to copy in check_relocs for each symbol.  This is so that it
5266    can discard PC relative relocs if it doesn't need them when linking
5267    with -Bsymbolic.  We store the information in a field extending the
5268    regular ELF linker hash table.  */
5269
5270 /* This structure keeps track of the number of PC relative relocs we have
5271    copied for a given symbol.  */
5272
5273 struct bfin_pcrel_relocs_copied
5274 {
5275   /* Next section.  */
5276   struct bfin_pcrel_relocs_copied *next;
5277   /* A section in dynobj.  */
5278   asection *section;
5279   /* Number of relocs copied in this section.  */
5280   bfd_size_type count;
5281 };
5282
5283 /* This function is called via elf_link_hash_traverse if we are
5284    creating a shared object.  In the -Bsymbolic case it discards the
5285    space allocated to copy PC relative relocs against symbols which
5286    are defined in regular objects.  For the normal shared case, it
5287    discards space for pc-relative relocs that have become local due to
5288    symbol visibility changes.  We allocated space for them in the
5289    check_relocs routine, but we won't fill them in in the
5290    relocate_section routine.
5291
5292    We also check whether any of the remaining relocations apply
5293    against a readonly section, and set the DF_TEXTREL flag in this
5294    case.  */
5295
5296 static bfd_boolean
5297 bfin_discard_copies (struct elf_link_hash_entry *h, void * inf)
5298 {
5299   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5300   struct bfin_pcrel_relocs_copied *s;
5301
5302   if (!h->def_regular || (!info->symbolic && !h->forced_local))
5303     {
5304       if ((info->flags & DF_TEXTREL) == 0)
5305         {
5306           /* Look for relocations against read-only sections.  */
5307           for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5308                s != NULL; s = s->next)
5309             if ((s->section->flags & SEC_READONLY) != 0)
5310               {
5311                 info->flags |= DF_TEXTREL;
5312                 break;
5313               }
5314         }
5315
5316       return TRUE;
5317     }
5318
5319   for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5320        s != NULL; s = s->next)
5321     s->section->size -= s->count * sizeof (Elf32_External_Rela);
5322
5323   return TRUE;
5324 }
5325
5326 static bfd_boolean
5327 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5328                             struct bfd_link_info *info)
5329 {
5330   bfd *dynobj;
5331   asection *s;
5332   bfd_boolean relocs;
5333
5334   dynobj = elf_hash_table (info)->dynobj;
5335   BFD_ASSERT (dynobj != NULL);
5336
5337   if (elf_hash_table (info)->dynamic_sections_created)
5338     {
5339       /* Set the contents of the .interp section to the interpreter.  */
5340       if (bfd_link_executable (info))
5341         {
5342           s = bfd_get_linker_section (dynobj, ".interp");
5343           BFD_ASSERT (s != NULL);
5344           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5345           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5346         }
5347     }
5348   else
5349     {
5350       /* We may have created entries in the .rela.got section.
5351          However, if we are not creating the dynamic sections, we will
5352          not actually use these entries.  Reset the size of .rela.got,
5353          which will cause it to get stripped from the output file
5354          below.  */
5355       s = elf_hash_table (info)->srelgot;
5356       if (s != NULL)
5357         s->size = 0;
5358     }
5359
5360   /* If this is a -Bsymbolic shared link, then we need to discard all
5361      PC relative relocs against symbols defined in a regular object.
5362      For the normal shared case we discard the PC relative relocs
5363      against symbols that have become local due to visibility changes.
5364      We allocated space for them in the check_relocs routine, but we
5365      will not fill them in in the relocate_section routine.  */
5366   if (bfd_link_pic (info))
5367     elf_link_hash_traverse (elf_hash_table (info),
5368                             bfin_discard_copies, info);
5369
5370   /* The check_relocs and adjust_dynamic_symbol entry points have
5371      determined the sizes of the various dynamic sections.  Allocate
5372      memory for them.  */
5373   relocs = FALSE;
5374   for (s = dynobj->sections; s != NULL; s = s->next)
5375     {
5376       const char *name;
5377       bfd_boolean strip;
5378
5379       if ((s->flags & SEC_LINKER_CREATED) == 0)
5380         continue;
5381
5382       /* It's OK to base decisions on the section name, because none
5383          of the dynobj section names depend upon the input files.  */
5384       name = bfd_get_section_name (dynobj, s);
5385
5386       strip = FALSE;
5387
5388        if (CONST_STRNEQ (name, ".rela"))
5389         {
5390           if (s->size == 0)
5391             {
5392               /* If we don't need this section, strip it from the
5393                  output file.  This is mostly to handle .rela.bss and
5394                  .rela.plt.  We must create both sections in
5395                  create_dynamic_sections, because they must be created
5396                  before the linker maps input sections to output
5397                  sections.  The linker does that before
5398                  adjust_dynamic_symbol is called, and it is that
5399                  function which decides whether anything needs to go
5400                  into these sections.  */
5401               strip = TRUE;
5402             }
5403           else
5404             {
5405               relocs = TRUE;
5406
5407               /* We use the reloc_count field as a counter if we need
5408                  to copy relocs into the output file.  */
5409               s->reloc_count = 0;
5410             }
5411         }
5412       else if (! CONST_STRNEQ (name, ".got"))
5413         {
5414           /* It's not one of our sections, so don't allocate space.  */
5415           continue;
5416         }
5417
5418       if (strip)
5419         {
5420           s->flags |= SEC_EXCLUDE;
5421           continue;
5422         }
5423
5424       /* Allocate memory for the section contents.  */
5425       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5426          Unused entries should be reclaimed before the section's contents
5427          are written out, but at the moment this does not happen.  Thus in
5428          order to prevent writing out garbage, we initialise the section's
5429          contents to zero.  */
5430       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5431       if (s->contents == NULL && s->size != 0)
5432         return FALSE;
5433     }
5434
5435   if (elf_hash_table (info)->dynamic_sections_created)
5436     {
5437       /* Add some entries to the .dynamic section.  We fill in the
5438          values later, in bfin_finish_dynamic_sections, but we
5439          must add the entries now so that we get the correct size for
5440          the .dynamic section.  The DT_DEBUG entry is filled in by the
5441          dynamic linker and used by the debugger.  */
5442 #define add_dynamic_entry(TAG, VAL) \
5443   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5444
5445       if (!bfd_link_pic (info))
5446         {
5447           if (!add_dynamic_entry (DT_DEBUG, 0))
5448             return FALSE;
5449         }
5450
5451
5452       if (relocs)
5453         {
5454           if (!add_dynamic_entry (DT_RELA, 0)
5455               || !add_dynamic_entry (DT_RELASZ, 0)
5456               || !add_dynamic_entry (DT_RELAENT,
5457                                      sizeof (Elf32_External_Rela)))
5458             return FALSE;
5459         }
5460
5461       if ((info->flags & DF_TEXTREL) != 0)
5462         {
5463           if (!add_dynamic_entry (DT_TEXTREL, 0))
5464             return FALSE;
5465         }
5466     }
5467 #undef add_dynamic_entry
5468
5469   return TRUE;
5470 }
5471 \f
5472 /* Given a .data section and a .emreloc in-memory section, store
5473    relocation information into the .emreloc section which can be
5474    used at runtime to relocate the section.  This is called by the
5475    linker when the --embedded-relocs switch is used.  This is called
5476    after the add_symbols entry point has been called for all the
5477    objects, and before the final_link entry point is called.  */
5478
5479 bfd_boolean
5480 bfd_bfin_elf32_create_embedded_relocs (bfd *abfd,
5481                                        struct bfd_link_info *info,
5482                                        asection *datasec,
5483                                        asection *relsec,
5484                                        char **errmsg)
5485 {
5486   Elf_Internal_Shdr *symtab_hdr;
5487   Elf_Internal_Sym *isymbuf = NULL;
5488   Elf_Internal_Rela *internal_relocs = NULL;
5489   Elf_Internal_Rela *irel, *irelend;
5490   bfd_byte *p;
5491   bfd_size_type amt;
5492
5493   BFD_ASSERT (! bfd_link_relocatable (info));
5494
5495   *errmsg = NULL;
5496
5497   if (datasec->reloc_count == 0)
5498     return TRUE;
5499
5500   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5501
5502   /* Get a copy of the native relocations.  */
5503   internal_relocs = (_bfd_elf_link_read_relocs
5504                      (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
5505                       info->keep_memory));
5506   if (internal_relocs == NULL)
5507     goto error_return;
5508
5509   amt = (bfd_size_type) datasec->reloc_count * 12;
5510   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5511   if (relsec->contents == NULL)
5512     goto error_return;
5513
5514   p = relsec->contents;
5515
5516   irelend = internal_relocs + datasec->reloc_count;
5517   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5518     {
5519       asection *targetsec;
5520
5521       /* We are going to write a four byte longword into the runtime
5522        reloc section.  The longword will be the address in the data
5523        section which must be relocated.  It is followed by the name
5524        of the target section NUL-padded or truncated to 8
5525        characters.  */
5526
5527       /* We can only relocate absolute longword relocs at run time.  */
5528       if (ELF32_R_TYPE (irel->r_info) != (int) R_BFIN_BYTE4_DATA)
5529         {
5530           *errmsg = _("unsupported reloc type");
5531           bfd_set_error (bfd_error_bad_value);
5532           goto error_return;
5533         }
5534
5535       /* Get the target section referred to by the reloc.  */
5536       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5537         {
5538           /* A local symbol.  */
5539           Elf_Internal_Sym *isym;
5540
5541           /* Read this BFD's local symbols if we haven't done so already.  */
5542           if (isymbuf == NULL)
5543             {
5544               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5545               if (isymbuf == NULL)
5546                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5547                                                 symtab_hdr->sh_info, 0,
5548                                                 NULL, NULL, NULL);
5549               if (isymbuf == NULL)
5550                 goto error_return;
5551             }
5552
5553           isym = isymbuf + ELF32_R_SYM (irel->r_info);
5554           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5555         }
5556       else
5557         {
5558           unsigned long indx;
5559           struct elf_link_hash_entry *h;
5560
5561           /* An external symbol.  */
5562           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5563           h = elf_sym_hashes (abfd)[indx];
5564           BFD_ASSERT (h != NULL);
5565           if (h->root.type == bfd_link_hash_defined
5566               || h->root.type == bfd_link_hash_defweak)
5567             targetsec = h->root.u.def.section;
5568           else
5569             targetsec = NULL;
5570         }
5571
5572       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5573       memset (p + 4, 0, 8);
5574       if (targetsec != NULL)
5575         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5576     }
5577
5578   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5579     free (isymbuf);
5580   if (internal_relocs != NULL
5581       && elf_section_data (datasec)->relocs != internal_relocs)
5582     free (internal_relocs);
5583   return TRUE;
5584
5585 error_return:
5586   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5587     free (isymbuf);
5588   if (internal_relocs != NULL
5589       && elf_section_data (datasec)->relocs != internal_relocs)
5590     free (internal_relocs);
5591   return FALSE;
5592 }
5593
5594 struct bfd_elf_special_section const elf32_bfin_special_sections[] =
5595 {
5596   { ".l1.text",         8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5597   { ".l1.data",         8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
5598   { NULL,               0,  0, 0,            0 }
5599 };
5600
5601 \f
5602 #define TARGET_LITTLE_SYM               bfin_elf32_vec
5603 #define TARGET_LITTLE_NAME              "elf32-bfin"
5604 #define ELF_ARCH                        bfd_arch_bfin
5605 #define ELF_TARGET_ID                   BFIN_ELF_DATA
5606 #define ELF_MACHINE_CODE                EM_BLACKFIN
5607 #define ELF_MAXPAGESIZE                 0x1000
5608 #define elf_symbol_leading_char         '_'
5609
5610 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5611 #define bfd_elf32_bfd_reloc_name_lookup \
5612                                         bfin_bfd_reloc_name_lookup
5613 #define elf_info_to_howto               bfin_info_to_howto
5614 #define elf_info_to_howto_rel           0
5615 #define elf_backend_object_p            elf32_bfin_object_p
5616
5617 #define bfd_elf32_bfd_is_local_label_name \
5618                                         bfin_is_local_label_name
5619 #define bfin_hash_table(p) \
5620   ((struct bfin_link_hash_table *) (p)->hash)
5621
5622
5623
5624 #define elf_backend_create_dynamic_sections \
5625                                         _bfd_elf_create_dynamic_sections
5626 #define bfd_elf32_bfd_link_hash_table_create \
5627                                         bfin_link_hash_table_create
5628 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
5629
5630 #define elf_backend_check_relocs        bfin_check_relocs
5631 #define elf_backend_adjust_dynamic_symbol \
5632                                         bfin_adjust_dynamic_symbol
5633 #define elf_backend_size_dynamic_sections \
5634                                         bfin_size_dynamic_sections
5635 #define elf_backend_relocate_section    bfin_relocate_section
5636 #define elf_backend_finish_dynamic_symbol \
5637                                         bfin_finish_dynamic_symbol
5638 #define elf_backend_finish_dynamic_sections \
5639                                         bfin_finish_dynamic_sections
5640 #define elf_backend_gc_mark_hook        bfin_gc_mark_hook
5641 #define elf_backend_gc_sweep_hook       bfin_gc_sweep_hook
5642 #define bfd_elf32_bfd_merge_private_bfd_data \
5643                                         elf32_bfin_merge_private_bfd_data
5644 #define bfd_elf32_bfd_set_private_flags \
5645                                         elf32_bfin_set_private_flags
5646 #define bfd_elf32_bfd_print_private_bfd_data \
5647                                         elf32_bfin_print_private_bfd_data
5648 #define elf_backend_final_write_processing \
5649                                         elf32_bfin_final_write_processing
5650 #define elf_backend_reloc_type_class    elf32_bfin_reloc_type_class
5651 #define elf_backend_stack_align         8
5652 #define elf_backend_can_gc_sections 1
5653 #define elf_backend_special_sections    elf32_bfin_special_sections
5654 #define elf_backend_can_refcount 1
5655 #define elf_backend_want_got_plt 0
5656 #define elf_backend_plt_readonly 1
5657 #define elf_backend_want_plt_sym 0
5658 #define elf_backend_got_header_size     12
5659 #define elf_backend_rela_normal         1
5660
5661 #include "elf32-target.h"
5662
5663 #undef TARGET_LITTLE_SYM
5664 #define TARGET_LITTLE_SYM          bfin_elf32_fdpic_vec
5665 #undef TARGET_LITTLE_NAME
5666 #define TARGET_LITTLE_NAME              "elf32-bfinfdpic"
5667 #undef  elf32_bed
5668 #define elf32_bed               elf32_bfinfdpic_bed
5669
5670 #undef elf_backend_gc_sweep_hook
5671 #define elf_backend_gc_sweep_hook       bfinfdpic_gc_sweep_hook
5672
5673 #undef elf_backend_got_header_size
5674 #define elf_backend_got_header_size     0
5675
5676 #undef elf_backend_relocate_section
5677 #define elf_backend_relocate_section    bfinfdpic_relocate_section
5678 #undef elf_backend_check_relocs
5679 #define elf_backend_check_relocs        bfinfdpic_check_relocs
5680
5681 #undef bfd_elf32_bfd_link_hash_table_create
5682 #define bfd_elf32_bfd_link_hash_table_create \
5683                 bfinfdpic_elf_link_hash_table_create
5684 #undef elf_backend_always_size_sections
5685 #define elf_backend_always_size_sections \
5686                 elf32_bfinfdpic_always_size_sections
5687
5688 #undef elf_backend_create_dynamic_sections
5689 #define elf_backend_create_dynamic_sections \
5690                 elf32_bfinfdpic_create_dynamic_sections
5691 #undef elf_backend_adjust_dynamic_symbol
5692 #define elf_backend_adjust_dynamic_symbol \
5693                 elf32_bfinfdpic_adjust_dynamic_symbol
5694 #undef elf_backend_size_dynamic_sections
5695 #define elf_backend_size_dynamic_sections \
5696                 elf32_bfinfdpic_size_dynamic_sections
5697 #undef elf_backend_finish_dynamic_symbol
5698 #define elf_backend_finish_dynamic_symbol \
5699                 elf32_bfinfdpic_finish_dynamic_symbol
5700 #undef elf_backend_finish_dynamic_sections
5701 #define elf_backend_finish_dynamic_sections \
5702                 elf32_bfinfdpic_finish_dynamic_sections
5703
5704 #undef elf_backend_discard_info
5705 #define elf_backend_discard_info \
5706                 bfinfdpic_elf_discard_info
5707 #undef elf_backend_can_make_relative_eh_frame
5708 #define elf_backend_can_make_relative_eh_frame \
5709                 bfinfdpic_elf_use_relative_eh_frame
5710 #undef elf_backend_can_make_lsda_relative_eh_frame
5711 #define elf_backend_can_make_lsda_relative_eh_frame \
5712                 bfinfdpic_elf_use_relative_eh_frame
5713 #undef elf_backend_encode_eh_address
5714 #define elf_backend_encode_eh_address \
5715                 bfinfdpic_elf_encode_eh_address
5716
5717 #undef elf_backend_may_use_rel_p
5718 #define elf_backend_may_use_rel_p       1
5719 #undef elf_backend_may_use_rela_p
5720 #define elf_backend_may_use_rela_p      1
5721 /* We use REL for dynamic relocations only.  */
5722 #undef elf_backend_default_use_rela_p
5723 #define elf_backend_default_use_rela_p  1
5724
5725 #undef elf_backend_omit_section_dynsym
5726 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5727
5728 #include "elf32-target.h"