bfd/elf32-bfin.c

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