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           /* Fall through.  */
2699
2700         case R_BFIN_GOT17M4:
2701         case R_BFIN_GOTHI:
2702         case R_BFIN_GOTLO:
2703         case R_BFIN_FUNCDESC_GOT17M4:
2704         case R_BFIN_FUNCDESC_GOTHI:
2705         case R_BFIN_FUNCDESC_GOTLO:
2706         case R_BFIN_GOTOFF17M4:
2707         case R_BFIN_GOTOFFHI:
2708         case R_BFIN_GOTOFFLO:
2709         case R_BFIN_FUNCDESC_GOTOFF17M4:
2710         case R_BFIN_FUNCDESC_GOTOFFHI:
2711         case R_BFIN_FUNCDESC_GOTOFFLO:
2712         case R_BFIN_FUNCDESC:
2713         case R_BFIN_FUNCDESC_VALUE:
2714           if (h != NULL)
2715             picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info
2716                                                        (info), input_bfd, h,
2717                                                        orig_addend, INSERT);
2718           else
2719             /* In order to find the entry we created before, we must
2720                use the original addend, not the one that may have been
2721                modified by _bfd_elf_rela_local_sym().  */
2722             picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
2723                                                       (info), input_bfd, r_symndx,
2724                                                       orig_addend, INSERT);
2725           if (! picrel)
2726             return FALSE;
2727
2728           if (!_bfinfdpic_emit_got_relocs_plt_entries (picrel, output_bfd, info,
2729                                                        osec, sym,
2730                                                        rel->r_addend))
2731             {
2732               _bfd_error_handler
2733                 (_("%B: relocation at `%A+0x%x' references symbol `%s' with nonzero addend"),
2734                  input_bfd, input_section, rel->r_offset, name);
2735               return FALSE;
2736
2737             }
2738
2739           break;
2740
2741         default:
2742         non_fdpic:
2743           picrel = NULL;
2744           if (h && ! BFINFDPIC_SYM_LOCAL (info, h)
2745               && _bfd_elf_section_offset (output_bfd, info, input_section,
2746                                           rel->r_offset) != (bfd_vma) -1)
2747             {
2748               info->callbacks->warning
2749                 (info, _("relocation references symbol not defined in the module"),
2750                  name, input_bfd, input_section, rel->r_offset);
2751               return FALSE;
2752             }
2753           break;
2754         }
2755
2756       switch (r_type)
2757         {
2758         case R_BFIN_PCREL24:
2759         case R_BFIN_PCREL24_JUMP_L:
2760           check_segment[0] = isec_segment;
2761           if (! IS_FDPIC (output_bfd))
2762             check_segment[1] = isec_segment;
2763           else if (picrel->plt)
2764             {
2765               relocation = bfinfdpic_plt_section (info)->output_section->vma
2766                 + bfinfdpic_plt_section (info)->output_offset
2767                 + picrel->plt_entry;
2768               check_segment[1] = plt_segment;
2769             }
2770           /* We don't want to warn on calls to undefined weak symbols,
2771              as calls to them must be protected by non-NULL tests
2772              anyway, and unprotected calls would invoke undefined
2773              behavior.  */
2774           else if (picrel->symndx == -1
2775                    && picrel->d.h->root.type == bfd_link_hash_undefweak)
2776             check_segment[1] = check_segment[0];
2777           else
2778             check_segment[1] = sec
2779               ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2780               : (unsigned)-1;
2781           break;
2782
2783         case R_BFIN_GOT17M4:
2784         case R_BFIN_GOTHI:
2785         case R_BFIN_GOTLO:
2786           relocation = picrel->got_entry;
2787           check_segment[0] = check_segment[1] = got_segment;
2788           break;
2789
2790         case R_BFIN_FUNCDESC_GOT17M4:
2791         case R_BFIN_FUNCDESC_GOTHI:
2792         case R_BFIN_FUNCDESC_GOTLO:
2793           relocation = picrel->fdgot_entry;
2794           check_segment[0] = check_segment[1] = got_segment;
2795           break;
2796
2797         case R_BFIN_GOTOFFHI:
2798         case R_BFIN_GOTOFF17M4:
2799         case R_BFIN_GOTOFFLO:
2800           relocation -= bfinfdpic_got_section (info)->output_section->vma
2801             + bfinfdpic_got_section (info)->output_offset
2802             + bfinfdpic_got_initial_offset (info);
2803           check_segment[0] = got_segment;
2804           check_segment[1] = sec
2805             ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
2806             : (unsigned)-1;
2807           break;
2808
2809         case R_BFIN_FUNCDESC_GOTOFF17M4:
2810         case R_BFIN_FUNCDESC_GOTOFFHI:
2811         case R_BFIN_FUNCDESC_GOTOFFLO:
2812           relocation = picrel->fd_entry;
2813           check_segment[0] = check_segment[1] = got_segment;
2814           break;
2815
2816         case R_BFIN_FUNCDESC:
2817           {
2818             int dynindx;
2819             bfd_vma addend = rel->r_addend;
2820
2821             if (! (h && h->root.type == bfd_link_hash_undefweak
2822                    && BFINFDPIC_SYM_LOCAL (info, h)))
2823               {
2824                 /* If the symbol is dynamic and there may be dynamic
2825                    symbol resolution because we are or are linked with a
2826                    shared library, emit a FUNCDESC relocation such that
2827                    the dynamic linker will allocate the function
2828                    descriptor.  If the symbol needs a non-local function
2829                    descriptor but binds locally (e.g., its visibility is
2830                    protected, emit a dynamic relocation decayed to
2831                    section+offset.  */
2832                 if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h)
2833                     && BFINFDPIC_SYM_LOCAL (info, h)
2834                     && !bfd_link_pde (info))
2835                   {
2836                     dynindx = elf_section_data (h->root.u.def.section
2837                                                 ->output_section)->dynindx;
2838                     addend += h->root.u.def.section->output_offset
2839                       + h->root.u.def.value;
2840                   }
2841                 else if (h && ! BFINFDPIC_FUNCDESC_LOCAL (info, h))
2842                   {
2843                     if (addend)
2844                       {
2845                         info->callbacks->warning
2846                           (info, _("R_BFIN_FUNCDESC references dynamic symbol with nonzero addend"),
2847                            name, input_bfd, input_section, rel->r_offset);
2848                         return FALSE;
2849                       }
2850                     dynindx = h->dynindx;
2851                   }
2852                 else
2853                   {
2854                     /* Otherwise, we know we have a private function
2855                        descriptor, so reference it directly.  */
2856                     BFD_ASSERT (picrel->privfd);
2857                     r_type = R_BFIN_BYTE4_DATA;
2858                     dynindx = elf_section_data (bfinfdpic_got_section (info)
2859                                                 ->output_section)->dynindx;
2860                     addend = bfinfdpic_got_section (info)->output_offset
2861                       + bfinfdpic_got_initial_offset (info)
2862                       + picrel->fd_entry;
2863                   }
2864
2865                 /* If there is room for dynamic symbol resolution, emit
2866                    the dynamic relocation.  However, if we're linking an
2867                    executable at a fixed location, we won't have emitted a
2868                    dynamic symbol entry for the got section, so idx will
2869                    be zero, which means we can and should compute the
2870                    address of the private descriptor ourselves.  */
2871                 if (bfd_link_pde (info)
2872                     && (!h || BFINFDPIC_FUNCDESC_LOCAL (info, h)))
2873                   {
2874                     bfd_vma offset;
2875
2876                     addend += bfinfdpic_got_section (info)->output_section->vma;
2877                     if ((bfd_get_section_flags (output_bfd,
2878                                                 input_section->output_section)
2879                          & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2880                       {
2881                         if (_bfinfdpic_osec_readonly_p (output_bfd,
2882                                                        input_section
2883                                                        ->output_section))
2884                           {
2885                             info->callbacks->warning
2886                               (info,
2887                                _("cannot emit fixups in read-only section"),
2888                                name, input_bfd, input_section, rel->r_offset);
2889                             return FALSE;
2890                           }
2891
2892                         offset = _bfd_elf_section_offset
2893                           (output_bfd, info,
2894                            input_section, rel->r_offset);
2895
2896                         if (offset != (bfd_vma)-1)
2897                           _bfinfdpic_add_rofixup (output_bfd,
2898                                                   bfinfdpic_gotfixup_section
2899                                                   (info),
2900                                                   offset + input_section
2901                                                   ->output_section->vma
2902                                                   + input_section->output_offset,
2903                                                   picrel);
2904                       }
2905                   }
2906                 else if ((bfd_get_section_flags (output_bfd,
2907                                                  input_section->output_section)
2908                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
2909                   {
2910                     bfd_vma offset;
2911
2912                     if (_bfinfdpic_osec_readonly_p (output_bfd,
2913                                                    input_section
2914                                                    ->output_section))
2915                       {
2916                         info->callbacks->warning
2917                           (info,
2918                            _("cannot emit dynamic relocations in read-only section"),
2919                            name, input_bfd, input_section, rel->r_offset);
2920                         return FALSE;
2921                       }
2922                     offset = _bfd_elf_section_offset (output_bfd, info,
2923                                                       input_section, rel->r_offset);
2924
2925                     if (offset != (bfd_vma)-1)
2926                       _bfinfdpic_add_dyn_reloc (output_bfd,
2927                                                 bfinfdpic_gotrel_section (info),
2928                                                 offset + input_section
2929                                                 ->output_section->vma
2930                                                 + input_section->output_offset,
2931                                                 r_type,
2932                                                 dynindx, addend, picrel);
2933                   }
2934                 else
2935                   addend += bfinfdpic_got_section (info)->output_section->vma;
2936               }
2937
2938             /* We want the addend in-place because dynamic
2939                relocations are REL.  Setting relocation to it should
2940                arrange for it to be installed.  */
2941             relocation = addend - rel->r_addend;
2942           }
2943           check_segment[0] = check_segment[1] = got_segment;
2944           break;
2945
2946         case R_BFIN_BYTE4_DATA:
2947           if (! IS_FDPIC (output_bfd))
2948             {
2949               check_segment[0] = check_segment[1] = -1;
2950               break;
2951             }
2952           /* Fall through.  */
2953         case R_BFIN_FUNCDESC_VALUE:
2954           {
2955             int dynindx;
2956             bfd_vma addend = rel->r_addend;
2957             bfd_vma offset;
2958             offset = _bfd_elf_section_offset (output_bfd, info,
2959                                               input_section, rel->r_offset);
2960
2961             /* If the symbol is dynamic but binds locally, use
2962                section+offset.  */
2963             if (h && ! BFINFDPIC_SYM_LOCAL (info, h))
2964               {
2965                 if (addend && r_type == R_BFIN_FUNCDESC_VALUE)
2966                   {
2967                     info->callbacks->warning
2968                       (info, _("R_BFIN_FUNCDESC_VALUE references dynamic symbol with nonzero addend"),
2969                        name, input_bfd, input_section, rel->r_offset);
2970                     return FALSE;
2971                   }
2972                 dynindx = h->dynindx;
2973               }
2974             else
2975               {
2976                 if (h)
2977                   addend += h->root.u.def.value;
2978                 else
2979                   addend += sym->st_value;
2980                 if (osec)
2981                   addend += osec->output_offset;
2982                 if (osec && osec->output_section
2983                     && ! bfd_is_abs_section (osec->output_section)
2984                     && ! bfd_is_und_section (osec->output_section))
2985                   dynindx = elf_section_data (osec->output_section)->dynindx;
2986                 else
2987                   dynindx = 0;
2988               }
2989
2990             /* If we're linking an executable at a fixed address, we
2991                can omit the dynamic relocation as long as the symbol
2992                is defined in the current link unit (which is implied
2993                by its output section not being NULL).  */
2994             if (bfd_link_pde (info)
2995                 && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
2996               {
2997                 if (osec)
2998                   addend += osec->output_section->vma;
2999                 if (IS_FDPIC (input_bfd)
3000                     && (bfd_get_section_flags (output_bfd,
3001                                                input_section->output_section)
3002                         & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3003                   {
3004                     if (_bfinfdpic_osec_readonly_p (output_bfd,
3005                                                    input_section
3006                                                    ->output_section))
3007                       {
3008                         info->callbacks->warning
3009                           (info,
3010                            _("cannot emit fixups in read-only section"),
3011                            name, input_bfd, input_section, rel->r_offset);
3012                         return FALSE;
3013                       }
3014                     if (!h || h->root.type != bfd_link_hash_undefweak)
3015                       {
3016                         if (offset != (bfd_vma)-1)
3017                           {
3018                             _bfinfdpic_add_rofixup (output_bfd,
3019                                                     bfinfdpic_gotfixup_section
3020                                                     (info),
3021                                                     offset + input_section
3022                                                     ->output_section->vma
3023                                                     + input_section->output_offset,
3024                                                     picrel);
3025
3026                             if (r_type == R_BFIN_FUNCDESC_VALUE)
3027                               _bfinfdpic_add_rofixup
3028                                 (output_bfd,
3029                                  bfinfdpic_gotfixup_section (info),
3030                                  offset + input_section->output_section->vma
3031                                  + input_section->output_offset + 4, picrel);
3032                           }
3033                       }
3034                   }
3035               }
3036             else
3037               {
3038                 if ((bfd_get_section_flags (output_bfd,
3039                                             input_section->output_section)
3040                      & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
3041                   {
3042                     if (_bfinfdpic_osec_readonly_p (output_bfd,
3043                                                    input_section
3044                                                    ->output_section))
3045                       {
3046                         info->callbacks->warning
3047                           (info,
3048                            _("cannot emit dynamic relocations in read-only section"),
3049                            name, input_bfd, input_section, rel->r_offset);
3050                         return FALSE;
3051                       }
3052
3053                     if (offset != (bfd_vma)-1)
3054                       _bfinfdpic_add_dyn_reloc (output_bfd,
3055                                                 bfinfdpic_gotrel_section (info),
3056                                                 offset
3057                                                 + input_section->output_section->vma
3058                                                 + input_section->output_offset,
3059                                                 r_type, dynindx, addend, picrel);
3060                   }
3061                 else if (osec)
3062                   addend += osec->output_section->vma;
3063                 /* We want the addend in-place because dynamic
3064                    relocations are REL.  Setting relocation to it
3065                    should arrange for it to be installed.  */
3066                 relocation = addend - rel->r_addend;
3067               }
3068
3069             if (r_type == R_BFIN_FUNCDESC_VALUE)
3070               {
3071                 /* If we've omitted the dynamic relocation, just emit
3072                    the fixed addresses of the symbol and of the local
3073                    GOT base offset.  */
3074                 if (bfd_link_pde (info)
3075                     && (!h || BFINFDPIC_SYM_LOCAL (info, h)))
3076                   bfd_put_32 (output_bfd,
3077                               bfinfdpic_got_section (info)->output_section->vma
3078                               + bfinfdpic_got_section (info)->output_offset
3079                               + bfinfdpic_got_initial_offset (info),
3080                               contents + rel->r_offset + 4);
3081                 else
3082                   /* A function descriptor used for lazy or local
3083                      resolving is initialized such that its high word
3084                      contains the output section index in which the
3085                      PLT entries are located, and the low word
3086                      contains the offset of the lazy PLT entry entry
3087                      point into that section.  */
3088                   bfd_put_32 (output_bfd,
3089                               h && ! BFINFDPIC_SYM_LOCAL (info, h)
3090                               ? 0
3091                               : _bfinfdpic_osec_to_segment (output_bfd,
3092                                                             sec
3093                                                             ->output_section),
3094                               contents + rel->r_offset + 4);
3095               }
3096           }
3097           check_segment[0] = check_segment[1] = got_segment;
3098           break;
3099
3100         default:
3101           check_segment[0] = isec_segment;
3102           check_segment[1] = sec
3103             ? _bfinfdpic_osec_to_segment (output_bfd, sec->output_section)
3104             : (unsigned)-1;
3105           break;
3106         }
3107
3108       if (check_segment[0] != check_segment[1] && IS_FDPIC (output_bfd))
3109         {
3110 #if 1 /* If you take this out, remove the #error from fdpic-static-6.d
3111          in the ld testsuite.  */
3112           /* This helps catch problems in GCC while we can't do more
3113              than static linking.  The idea is to test whether the
3114              input file basename is crt0.o only once.  */
3115           if (silence_segment_error == 1)
3116             silence_segment_error =
3117               (strlen (input_bfd->filename) == 6
3118                && filename_cmp (input_bfd->filename, "crt0.o") == 0)
3119               || (strlen (input_bfd->filename) > 6
3120                   && filename_cmp (input_bfd->filename
3121                                    + strlen (input_bfd->filename) - 7,
3122                              "/crt0.o") == 0)
3123               ? -1 : 0;
3124 #endif
3125           if (!silence_segment_error
3126               /* We don't want duplicate errors for undefined
3127                  symbols.  */
3128               && !(picrel && picrel->symndx == -1
3129                    && picrel->d.h->root.type == bfd_link_hash_undefined))
3130             info->callbacks->warning
3131               (info,
3132                bfd_link_pic (info)
3133                ? _("relocations between different segments are not supported")
3134                : _("warning: relocation references a different segment"),
3135                name, input_bfd, input_section, rel->r_offset);
3136           if (!silence_segment_error && bfd_link_pic (info))
3137             return FALSE;
3138           elf_elfheader (output_bfd)->e_flags |= EF_BFIN_PIC;
3139         }
3140
3141       switch (r_type)
3142         {
3143         case R_BFIN_GOTOFFHI:
3144           /* We need the addend to be applied before we shift the
3145              value right.  */
3146           relocation += rel->r_addend;
3147           /* Fall through.  */
3148         case R_BFIN_GOTHI:
3149         case R_BFIN_FUNCDESC_GOTHI:
3150         case R_BFIN_FUNCDESC_GOTOFFHI:
3151           relocation >>= 16;
3152           /* Fall through.  */
3153
3154         case R_BFIN_GOTLO:
3155         case R_BFIN_FUNCDESC_GOTLO:
3156         case R_BFIN_GOTOFFLO:
3157         case R_BFIN_FUNCDESC_GOTOFFLO:
3158           relocation &= 0xffff;
3159           break;
3160
3161         default:
3162           break;
3163         }
3164
3165       switch (r_type)
3166         {
3167         case R_BFIN_PCREL24:
3168         case R_BFIN_PCREL24_JUMP_L:
3169           if (! IS_FDPIC (output_bfd) || ! picrel->plt)
3170             break;
3171           /* Fall through.  */
3172
3173           /* When referencing a GOT entry, a function descriptor or a
3174              PLT, we don't want the addend to apply to the reference,
3175              but rather to the referenced symbol.  The actual entry
3176              will have already been created taking the addend into
3177              account, so cancel it out here.  */
3178         case R_BFIN_GOT17M4:
3179         case R_BFIN_GOTHI:
3180         case R_BFIN_GOTLO:
3181         case R_BFIN_FUNCDESC_GOT17M4:
3182         case R_BFIN_FUNCDESC_GOTHI:
3183         case R_BFIN_FUNCDESC_GOTLO:
3184         case R_BFIN_FUNCDESC_GOTOFF17M4:
3185         case R_BFIN_FUNCDESC_GOTOFFHI:
3186         case R_BFIN_FUNCDESC_GOTOFFLO:
3187           /* Note that we only want GOTOFFHI, not GOTOFFLO or GOTOFF17M4
3188              here, since we do want to apply the addend to the others.
3189              Note that we've applied the addend to GOTOFFHI before we
3190              shifted it right.  */
3191         case R_BFIN_GOTOFFHI:
3192           relocation -= rel->r_addend;
3193           break;
3194
3195         default:
3196           break;
3197         }
3198
3199       r = bfin_final_link_relocate (rel, howto, input_bfd, input_section,
3200                                     contents, rel->r_offset,
3201                                     relocation, rel->r_addend);
3202
3203       if (r != bfd_reloc_ok)
3204         {
3205           const char * msg = (const char *) NULL;
3206
3207           switch (r)
3208             {
3209             case bfd_reloc_overflow:
3210               (*info->callbacks->reloc_overflow)
3211                 (info, (h ? &h->root : NULL), name, howto->name,
3212                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
3213               break;
3214
3215             case bfd_reloc_undefined:
3216               (*info->callbacks->undefined_symbol)
3217                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
3218               break;
3219
3220             case bfd_reloc_outofrange:
3221               msg = _("internal error: out of range error");
3222               break;
3223
3224             case bfd_reloc_notsupported:
3225               msg = _("internal error: unsupported relocation error");
3226               break;
3227
3228             case bfd_reloc_dangerous:
3229               msg = _("internal error: dangerous relocation");
3230               break;
3231
3232             default:
3233               msg = _("internal error: unknown error");
3234               break;
3235             }
3236
3237           if (msg)
3238             (*info->callbacks->warning) (info, msg, name, input_bfd,
3239                                          input_section, rel->r_offset);
3240         }
3241     }
3242
3243   return TRUE;
3244 }
3245
3246 /* Update the relocation information for the relocations of the section
3247    being removed.  */
3248
3249 static bfd_boolean
3250 bfinfdpic_gc_sweep_hook (bfd *abfd,
3251                          struct bfd_link_info *info,
3252                          asection *sec,
3253                          const Elf_Internal_Rela *relocs)
3254 {
3255   Elf_Internal_Shdr *symtab_hdr;
3256   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
3257   const Elf_Internal_Rela *rel;
3258   const Elf_Internal_Rela *rel_end;
3259   struct bfinfdpic_relocs_info *picrel;
3260
3261   BFD_ASSERT (IS_FDPIC (abfd));
3262
3263   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3264   sym_hashes = elf_sym_hashes (abfd);
3265   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
3266   if (!elf_bad_symtab (abfd))
3267     sym_hashes_end -= symtab_hdr->sh_info;
3268
3269   rel_end = relocs + sec->reloc_count;
3270   for (rel = relocs; rel < rel_end; rel++)
3271     {
3272       struct elf_link_hash_entry *h;
3273       unsigned long r_symndx;
3274
3275       r_symndx = ELF32_R_SYM (rel->r_info);
3276       if (r_symndx < symtab_hdr->sh_info)
3277         h = NULL;
3278       else
3279         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3280
3281       if (h != NULL)
3282         picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
3283                                                    abfd, h,
3284                                                    rel->r_addend, NO_INSERT);
3285       else
3286         picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
3287                                                   (info), abfd, r_symndx,
3288                                                   rel->r_addend, NO_INSERT);
3289
3290       if (!picrel)
3291         return TRUE;
3292
3293       switch (ELF32_R_TYPE (rel->r_info))
3294         {
3295         case R_BFIN_PCREL24:
3296         case R_BFIN_PCREL24_JUMP_L:
3297           picrel->call--;
3298           break;
3299
3300         case R_BFIN_FUNCDESC_VALUE:
3301           picrel->relocsfdv--;
3302           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
3303             picrel->relocs32++;
3304           /* Fall through.  */
3305
3306         case R_BFIN_BYTE4_DATA:
3307           picrel->sym--;
3308           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
3309             picrel->relocs32--;
3310           break;
3311
3312         case R_BFIN_GOT17M4:
3313           picrel->got17m4--;
3314           break;
3315
3316         case R_BFIN_GOTHI:
3317         case R_BFIN_GOTLO:
3318           picrel->gothilo--;
3319           break;
3320
3321         case R_BFIN_FUNCDESC_GOT17M4:
3322           picrel->fdgot17m4--;
3323           break;
3324
3325         case R_BFIN_FUNCDESC_GOTHI:
3326         case R_BFIN_FUNCDESC_GOTLO:
3327           picrel->fdgothilo--;
3328           break;
3329
3330         case R_BFIN_GOTOFF17M4:
3331         case R_BFIN_GOTOFFHI:
3332         case R_BFIN_GOTOFFLO:
3333           picrel->gotoff--;
3334           break;
3335
3336         case R_BFIN_FUNCDESC_GOTOFF17M4:
3337           picrel->fdgoff17m4--;
3338           break;
3339
3340         case R_BFIN_FUNCDESC_GOTOFFHI:
3341         case R_BFIN_FUNCDESC_GOTOFFLO:
3342           picrel->fdgoffhilo--;
3343           break;
3344
3345         case R_BFIN_FUNCDESC:
3346           picrel->fd--;
3347           picrel->relocsfd--;
3348           break;
3349
3350         default:
3351           break;
3352         }
3353     }
3354
3355   return TRUE;
3356 }
3357
3358 /* We need dynamic symbols for every section, since segments can
3359    relocate independently.  */
3360 static bfd_boolean
3361 _bfinfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
3362                                     struct bfd_link_info *info ATTRIBUTE_UNUSED,
3363                                     asection *p)
3364 {
3365   switch (elf_section_data (p)->this_hdr.sh_type)
3366     {
3367     case SHT_PROGBITS:
3368     case SHT_NOBITS:
3369       /* If sh_type is yet undecided, assume it could be
3370          SHT_PROGBITS/SHT_NOBITS.  */
3371     case SHT_NULL:
3372       return FALSE;
3373
3374       /* There shouldn't be section relative relocations
3375          against any other section.  */
3376     default:
3377       return TRUE;
3378     }
3379 }
3380
3381 /* Create  a .got section, as well as its additional info field.  This
3382    is almost entirely copied from
3383    elflink.c:_bfd_elf_create_got_section().  */
3384
3385 static bfd_boolean
3386 _bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
3387 {
3388   flagword flags, pltflags;
3389   asection *s;
3390   struct elf_link_hash_entry *h;
3391   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3392   int ptralign;
3393
3394   /* This function may be called more than once.  */
3395   s = bfd_get_linker_section (abfd, ".got");
3396   if (s != NULL)
3397     return TRUE;
3398
3399   /* Machine specific: although pointers are 32-bits wide, we want the
3400      GOT to be aligned to a 64-bit boundary, such that function
3401      descriptors in it can be accessed with 64-bit loads and
3402      stores.  */
3403   ptralign = 3;
3404
3405   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3406            | SEC_LINKER_CREATED);
3407   pltflags = flags;
3408
3409   s = bfd_make_section_anyway_with_flags (abfd, ".got", flags);
3410   if (s == NULL
3411       || !bfd_set_section_alignment (abfd, s, ptralign))
3412     return FALSE;
3413
3414   if (bed->want_got_plt)
3415     {
3416       s = bfd_make_section_anyway_with_flags (abfd, ".got.plt", flags);
3417       if (s == NULL
3418           || !bfd_set_section_alignment (abfd, s, ptralign))
3419         return FALSE;
3420     }
3421
3422   if (bed->want_got_sym)
3423     {
3424       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3425          (or .got.plt) section.  We don't do this in the linker script
3426          because we don't want to define the symbol if we are not creating
3427          a global offset table.  */
3428       h = _bfd_elf_define_linkage_sym (abfd, info, s, "__GLOBAL_OFFSET_TABLE_");
3429       elf_hash_table (info)->hgot = h;
3430       if (h == NULL)
3431         return FALSE;
3432
3433       /* Machine-specific: we want the symbol for executables as
3434          well.  */
3435       if (! bfd_elf_link_record_dynamic_symbol (info, h))
3436         return FALSE;
3437     }
3438
3439   /* The first bit of the global offset table is the header.  */
3440   s->size += bed->got_header_size;
3441
3442   /* This is the machine-specific part.  Create and initialize section
3443      data for the got.  */
3444   if (IS_FDPIC (abfd))
3445     {
3446       bfinfdpic_got_section (info) = s;
3447       bfinfdpic_relocs_info (info) = htab_try_create (1,
3448                                                       bfinfdpic_relocs_info_hash,
3449                                                       bfinfdpic_relocs_info_eq,
3450                                                       (htab_del) NULL);
3451       if (! bfinfdpic_relocs_info (info))
3452         return FALSE;
3453
3454       s = bfd_make_section_anyway_with_flags (abfd, ".rel.got",
3455                                               (flags | SEC_READONLY));
3456       if (s == NULL
3457           || ! bfd_set_section_alignment (abfd, s, 2))
3458         return FALSE;
3459
3460       bfinfdpic_gotrel_section (info) = s;
3461
3462       /* Machine-specific.  */
3463       s = bfd_make_section_anyway_with_flags (abfd, ".rofixup",
3464                                               (flags | SEC_READONLY));
3465       if (s == NULL
3466           || ! bfd_set_section_alignment (abfd, s, 2))
3467         return FALSE;
3468
3469       bfinfdpic_gotfixup_section (info) = s;
3470     }
3471
3472   pltflags |= SEC_CODE;
3473   if (bed->plt_not_loaded)
3474     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3475   if (bed->plt_readonly)
3476     pltflags |= SEC_READONLY;
3477
3478   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
3479   if (s == NULL
3480       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3481     return FALSE;
3482   /* Blackfin-specific: remember it.  */
3483   bfinfdpic_plt_section (info) = s;
3484
3485   if (bed->want_plt_sym)
3486     {
3487       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3488          .plt section.  */
3489       struct bfd_link_hash_entry *bh = NULL;
3490
3491       if (! (_bfd_generic_link_add_one_symbol
3492              (info, abfd, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3493               FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3494         return FALSE;
3495       h = (struct elf_link_hash_entry *) bh;
3496       h->def_regular = 1;
3497       h->type = STT_OBJECT;
3498
3499       if (! bfd_link_executable (info)
3500           && ! bfd_elf_link_record_dynamic_symbol (info, h))
3501         return FALSE;
3502     }
3503
3504   /* Blackfin-specific: we want rel relocations for the plt.  */
3505   s = bfd_make_section_anyway_with_flags (abfd, ".rel.plt",
3506                                           flags | SEC_READONLY);
3507   if (s == NULL
3508       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3509     return FALSE;
3510   /* Blackfin-specific: remember it.  */
3511   bfinfdpic_pltrel_section (info) = s;
3512
3513   return TRUE;
3514 }
3515
3516 /* Make sure the got and plt sections exist, and that our pointers in
3517    the link hash table point to them.  */
3518
3519 static bfd_boolean
3520 elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3521 {
3522   /* This is mostly copied from
3523      elflink.c:_bfd_elf_create_dynamic_sections().  */
3524   flagword flags;
3525   asection *s;
3526   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3527
3528   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3529            | SEC_LINKER_CREATED);
3530
3531   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3532      .rel[a].bss sections.  */
3533
3534   /* Blackfin-specific: we want to create the GOT in the Blackfin way.  */
3535   if (! _bfin_create_got_section (abfd, info))
3536     return FALSE;
3537
3538   /* Blackfin-specific: make sure we created everything we wanted.  */
3539   BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3540               /* && bfinfdpic_gotfixup_section (info) */
3541               && bfinfdpic_plt_section (info)
3542               && bfinfdpic_pltrel_section (info));
3543
3544   if (bed->want_dynbss)
3545     {
3546       /* The .dynbss section is a place to put symbols which are defined
3547          by dynamic objects, are referenced by regular objects, and are
3548          not functions.  We must allocate space for them in the process
3549          image and use a R_*_COPY reloc to tell the dynamic linker to
3550          initialize them at run time.  The linker script puts the .dynbss
3551          section into the .bss section of the final image.  */
3552       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
3553                                               SEC_ALLOC | SEC_LINKER_CREATED);
3554       if (s == NULL)
3555         return FALSE;
3556
3557       /* The .rel[a].bss section holds copy relocs.  This section is not
3558          normally needed.  We need to create it here, though, so that the
3559          linker will map it to an output section.  We can't just create it
3560          only if we need it, because we will not know whether we need it
3561          until we have seen all the input files, and the first time the
3562          main linker code calls BFD after examining all the input files
3563          (size_dynamic_sections) the input sections have already been
3564          mapped to the output sections.  If the section turns out not to
3565          be needed, we can discard it later.  We will never need this
3566          section when generating a shared object, since they do not use
3567          copy relocs.  */
3568       if (! bfd_link_pic (info))
3569         {
3570           s = bfd_make_section_anyway_with_flags (abfd,
3571                                                   ".rela.bss",
3572                                                   flags | SEC_READONLY);
3573           if (s == NULL
3574               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3575             return FALSE;
3576         }
3577     }
3578
3579   return TRUE;
3580 }
3581
3582 /* Compute the total GOT size required by each symbol in each range.
3583    Symbols may require up to 4 words in the GOT: an entry pointing to
3584    the symbol, an entry pointing to its function descriptor, and a
3585    private function descriptors taking two words.  */
3586
3587 static void
3588 _bfinfdpic_count_nontls_entries (struct bfinfdpic_relocs_info *entry,
3589                                  struct _bfinfdpic_dynamic_got_info *dinfo)
3590 {
3591   /* Allocate space for a GOT entry pointing to the symbol.  */
3592   if (entry->got17m4)
3593     dinfo->got17m4 += 4;
3594   else if (entry->gothilo)
3595     dinfo->gothilo += 4;
3596   else
3597     entry->relocs32--;
3598   entry->relocs32++;
3599
3600   /* Allocate space for a GOT entry pointing to the function
3601      descriptor.  */
3602   if (entry->fdgot17m4)
3603     dinfo->got17m4 += 4;
3604   else if (entry->fdgothilo)
3605     dinfo->gothilo += 4;
3606   else
3607     entry->relocsfd--;
3608   entry->relocsfd++;
3609
3610   /* Decide whether we need a PLT entry, a function descriptor in the
3611      GOT, and a lazy PLT entry for this symbol.  */
3612   entry->plt = entry->call
3613     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3614     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3615   entry->privfd = entry->plt
3616     || entry->fdgoff17m4 || entry->fdgoffhilo
3617     || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3618         && (entry->symndx != -1
3619             || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3620   entry->lazyplt = entry->privfd
3621     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3622     && ! (dinfo->info->flags & DF_BIND_NOW)
3623     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3624
3625   /* Allocate space for a function descriptor.  */
3626   if (entry->fdgoff17m4)
3627     dinfo->fd17m4 += 8;
3628   else if (entry->privfd && entry->plt)
3629     dinfo->fdplt += 8;
3630   else if (entry->privfd)
3631     dinfo->fdhilo += 8;
3632   else
3633     entry->relocsfdv--;
3634   entry->relocsfdv++;
3635
3636   if (entry->lazyplt)
3637     dinfo->lzplt += LZPLT_NORMAL_SIZE;
3638 }
3639
3640 /* Compute the number of dynamic relocations and fixups that a symbol
3641    requires, and add (or subtract) from the grand and per-symbol
3642    totals.  */
3643
3644 static void
3645 _bfinfdpic_count_relocs_fixups (struct bfinfdpic_relocs_info *entry,
3646                                 struct _bfinfdpic_dynamic_got_info *dinfo,
3647                                 bfd_boolean subtract)
3648 {
3649   bfd_vma relocs = 0, fixups = 0;
3650
3651   if (!bfd_link_pde (dinfo->info))
3652     relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3653   else
3654     {
3655       if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3656         {
3657           if (entry->symndx != -1
3658               || entry->d.h->root.type != bfd_link_hash_undefweak)
3659             fixups += entry->relocs32 + 2 * entry->relocsfdv;
3660         }
3661       else
3662         relocs += entry->relocs32 + entry->relocsfdv;
3663
3664       if (entry->symndx != -1
3665           || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3666         {
3667           if (entry->symndx != -1
3668               || entry->d.h->root.type != bfd_link_hash_undefweak)
3669             fixups += entry->relocsfd;
3670         }
3671       else
3672         relocs += entry->relocsfd;
3673     }
3674
3675   if (subtract)
3676     {
3677       relocs = - relocs;
3678       fixups = - fixups;
3679     }
3680
3681   entry->dynrelocs += relocs;
3682   entry->fixups += fixups;
3683   dinfo->relocs += relocs;
3684   dinfo->fixups += fixups;
3685 }
3686
3687 /* Compute the total GOT and PLT size required by each symbol in each range. *
3688    Symbols may require up to 4 words in the GOT: an entry pointing to
3689    the symbol, an entry pointing to its function descriptor, and a
3690    private function descriptors taking two words.  */
3691
3692 static int
3693 _bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3694 {
3695   struct bfinfdpic_relocs_info *entry = *entryp;
3696   struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3697
3698   _bfinfdpic_count_nontls_entries (entry, dinfo);
3699
3700   _bfinfdpic_count_relocs_fixups (entry, dinfo, FALSE);
3701
3702   return 1;
3703 }
3704
3705 /* This structure is used to assign offsets to got entries, function
3706    descriptors, plt entries and lazy plt entries.  */
3707
3708 struct _bfinfdpic_dynamic_got_plt_info
3709 {
3710   /* Summary information collected with _bfinfdpic_count_got_plt_entries.  */
3711   struct _bfinfdpic_dynamic_got_info g;
3712
3713   /* For each addressable range, we record a MAX (positive) and MIN
3714      (negative) value.  CUR is used to assign got entries, and it's
3715      incremented from an initial positive value to MAX, then from MIN
3716      to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
3717      assign function descriptors, and it's decreased from an initial
3718      non-positive value to MIN, then from MAX down to CUR (unless CUR
3719      wraps around first).  All of MIN, MAX, CUR and FDCUR always point
3720      to even words.  ODD, if non-zero, indicates an odd word to be
3721      used for the next got entry, otherwise CUR is used and
3722      incremented by a pair of words, wrapping around when it reaches
3723      MAX.  FDCUR is decremented (and wrapped) before the next function
3724      descriptor is chosen.  FDPLT indicates the number of remaining
3725      slots that can be used for function descriptors used only by PLT
3726      entries.  */
3727   struct _bfinfdpic_dynamic_got_alloc_data
3728   {
3729     bfd_signed_vma max, cur, odd, fdcur, min;
3730     bfd_vma fdplt;
3731   } got17m4, gothilo;
3732 };
3733
3734 /* Determine the positive and negative ranges to be used by each
3735    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
3736    double-word boundary, are the minimum (negative) and maximum
3737    (positive) GOT offsets already used by previous ranges, except for
3738    an ODD entry that may have been left behind.  GOT and FD indicate
3739    the size of GOT entries and function descriptors that must be
3740    placed within the range from -WRAP to WRAP.  If there's room left,
3741    up to FDPLT bytes should be reserved for additional function
3742    descriptors.  */
3743
3744 inline static bfd_signed_vma
3745 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3746                                    bfd_signed_vma fdcur,
3747                                    bfd_signed_vma odd,
3748                                    bfd_signed_vma cur,
3749                                    bfd_vma got,
3750                                    bfd_vma fd,
3751                                    bfd_vma fdplt,
3752                                    bfd_vma wrap)
3753 {
3754   bfd_signed_vma wrapmin = -wrap;
3755
3756   /* Start at the given initial points.  */
3757   gad->fdcur = fdcur;
3758   gad->cur = cur;
3759
3760   /* If we had an incoming odd word and we have any got entries that
3761      are going to use it, consume it, otherwise leave gad->odd at
3762      zero.  We might force gad->odd to zero and return the incoming
3763      odd such that it is used by the next range, but then GOT entries
3764      might appear to be out of order and we wouldn't be able to
3765      shorten the GOT by one word if it turns out to end with an
3766      unpaired GOT entry.  */
3767   if (odd && got)
3768     {
3769       gad->odd = odd;
3770       got -= 4;
3771       odd = 0;
3772     }
3773   else
3774     gad->odd = 0;
3775
3776   /* If we're left with an unpaired GOT entry, compute its location
3777      such that we can return it.  Otherwise, if got doesn't require an
3778      odd number of words here, either odd was already zero in the
3779      block above, or it was set to zero because got was non-zero, or
3780      got was already zero.  In the latter case, we want the value of
3781      odd to carry over to the return statement, so we don't want to
3782      reset odd unless the condition below is true.  */
3783   if (got & 4)
3784     {
3785       odd = cur + got;
3786       got += 4;
3787     }
3788
3789   /* Compute the tentative boundaries of this range.  */
3790   gad->max = cur + got;
3791   gad->min = fdcur - fd;
3792   gad->fdplt = 0;
3793
3794   /* If function descriptors took too much space, wrap some of them
3795      around.  */
3796   if (gad->min < wrapmin)
3797     {
3798       gad->max += wrapmin - gad->min;
3799       gad->min = wrapmin;
3800     }
3801   /* If there is space left and we have function descriptors
3802      referenced in PLT entries that could take advantage of shorter
3803      offsets, place them here.  */
3804   else if (fdplt && gad->min > wrapmin)
3805     {
3806       bfd_vma fds;
3807       if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3808         fds = gad->min - wrapmin;
3809       else
3810         fds = fdplt;
3811
3812       fdplt -= fds;
3813       gad->min -= fds;
3814       gad->fdplt += fds;
3815     }
3816
3817   /* If GOT entries took too much space, wrap some of them around.
3818      This may well cause gad->min to become lower than wrapmin.  This
3819      will cause a relocation overflow later on, so we don't have to
3820      report it here . */
3821   if ((bfd_vma) gad->max > wrap)
3822     {
3823       gad->min -= gad->max - wrap;
3824       gad->max = wrap;
3825     }
3826   /* If there is more space left, try to place some more function
3827      descriptors for PLT entries.  */
3828   else if (fdplt && (bfd_vma) gad->max < wrap)
3829     {
3830       bfd_vma fds;
3831       if ((bfd_vma) (wrap - gad->max) < fdplt)
3832         fds = wrap - gad->max;
3833       else
3834         fds = fdplt;
3835
3836       fdplt -= fds;
3837       gad->max += fds;
3838       gad->fdplt += fds;
3839     }
3840
3841   /* If odd was initially computed as an offset past the wrap point,
3842      wrap it around.  */
3843   if (odd > gad->max)
3844     odd = gad->min + odd - gad->max;
3845
3846   /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3847      before returning, so do it here too.  This guarantees that,
3848      should cur and fdcur meet at the wrap point, they'll both be
3849      equal to min.  */
3850   if (gad->cur == gad->max)
3851     gad->cur = gad->min;
3852
3853   return odd;
3854 }
3855
3856 /* Compute the location of the next GOT entry, given the allocation
3857    data for a range.  */
3858
3859 inline static bfd_signed_vma
3860 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3861 {
3862   bfd_signed_vma ret;
3863
3864   if (gad->odd)
3865     {
3866       /* If there was an odd word left behind, use it.  */
3867       ret = gad->odd;
3868       gad->odd = 0;
3869     }
3870   else
3871     {
3872       /* Otherwise, use the word pointed to by cur, reserve the next
3873          as an odd word, and skip to the next pair of words, possibly
3874          wrapping around.  */
3875       ret = gad->cur;
3876       gad->odd = gad->cur + 4;
3877       gad->cur += 8;
3878       if (gad->cur == gad->max)
3879         gad->cur = gad->min;
3880     }
3881
3882   return ret;
3883 }
3884
3885 /* Compute the location of the next function descriptor entry in the
3886    GOT, given the allocation data for a range.  */
3887
3888 inline static bfd_signed_vma
3889 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3890 {
3891   /* If we're at the bottom, wrap around, and only then allocate the
3892      next pair of words.  */
3893   if (gad->fdcur == gad->min)
3894     gad->fdcur = gad->max;
3895   return gad->fdcur -= 8;
3896 }
3897
3898 /* Assign GOT offsets for every GOT entry and function descriptor.
3899    Doing everything in a single pass is tricky.  */
3900
3901 static int
3902 _bfinfdpic_assign_got_entries (void **entryp, void *info_)
3903 {
3904   struct bfinfdpic_relocs_info *entry = *entryp;
3905   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3906
3907   if (entry->got17m4)
3908     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3909   else if (entry->gothilo)
3910     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3911
3912   if (entry->fdgot17m4)
3913     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3914   else if (entry->fdgothilo)
3915     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3916
3917   if (entry->fdgoff17m4)
3918     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3919   else if (entry->plt && dinfo->got17m4.fdplt)
3920     {
3921       dinfo->got17m4.fdplt -= 8;
3922       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3923     }
3924   else if (entry->plt)
3925     {
3926       dinfo->gothilo.fdplt -= 8;
3927       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3928     }
3929   else if (entry->privfd)
3930     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3931
3932   return 1;
3933 }
3934
3935 /* Assign GOT offsets to private function descriptors used by PLT
3936    entries (or referenced by 32-bit offsets), as well as PLT entries
3937    and lazy PLT entries.  */
3938
3939 static int
3940 _bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3941 {
3942   struct bfinfdpic_relocs_info *entry = *entryp;
3943   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3944
3945   /* If this symbol requires a local function descriptor, allocate
3946      one.  */
3947   if (entry->privfd && entry->fd_entry == 0)
3948     {
3949       if (dinfo->got17m4.fdplt)
3950         {
3951           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3952           dinfo->got17m4.fdplt -= 8;
3953         }
3954       else
3955         {
3956           BFD_ASSERT (dinfo->gothilo.fdplt);
3957           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3958           dinfo->gothilo.fdplt -= 8;
3959         }
3960     }
3961
3962   if (entry->plt)
3963     {
3964       int size;
3965
3966       /* We use the section's raw size to mark the location of the
3967          next PLT entry.  */
3968       entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3969
3970       /* Figure out the length of this PLT entry based on the
3971          addressing mode we need to reach the function descriptor.  */
3972       BFD_ASSERT (entry->fd_entry);
3973       if (entry->fd_entry >= -(1 << (18 - 1))
3974           && entry->fd_entry + 4 < (1 << (18 - 1)))
3975         size = 10;
3976       else
3977         size = 16;
3978
3979       bfinfdpic_plt_section (dinfo->g.info)->size += size;
3980     }
3981
3982   if (entry->lazyplt)
3983     {
3984       entry->lzplt_entry = dinfo->g.lzplt;
3985       dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3986       /* If this entry is the one that gets the resolver stub, account
3987          for the additional instruction.  */
3988       if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3989           == BFINFDPIC_LZPLT_RESOLV_LOC)
3990         dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3991     }
3992
3993   return 1;
3994 }
3995
3996 /* Cancel out any effects of calling _bfinfdpic_assign_got_entries and
3997    _bfinfdpic_assign_plt_entries.  */
3998
3999 static int
4000 _bfinfdpic_reset_got_plt_entries (void **entryp, void *ignore ATTRIBUTE_UNUSED)
4001 {
4002   struct bfinfdpic_relocs_info *entry = *entryp;
4003
4004   entry->got_entry = 0;
4005   entry->fdgot_entry = 0;
4006   entry->fd_entry = 0;
4007   entry->plt_entry = (bfd_vma)-1;
4008   entry->lzplt_entry = (bfd_vma)-1;
4009
4010   return 1;
4011 }
4012
4013 /* Follow indirect and warning hash entries so that each got entry
4014    points to the final symbol definition.  P must point to a pointer
4015    to the hash table we're traversing.  Since this traversal may
4016    modify the hash table, we set this pointer to NULL to indicate
4017    we've made a potentially-destructive change to the hash table, so
4018    the traversal must be restarted.  */
4019 static int
4020 _bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
4021 {
4022   struct bfinfdpic_relocs_info *entry = *entryp;
4023   htab_t *htab = p;
4024
4025   if (entry->symndx == -1)
4026     {
4027       struct elf_link_hash_entry *h = entry->d.h;
4028       struct bfinfdpic_relocs_info *oentry;
4029
4030       while (h->root.type == bfd_link_hash_indirect
4031              || h->root.type == bfd_link_hash_warning)
4032         h = (struct elf_link_hash_entry *)h->root.u.i.link;
4033
4034       if (entry->d.h == h)
4035         return 1;
4036
4037       oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
4038                                                 NO_INSERT);
4039
4040       if (oentry)
4041         {
4042           /* Merge the two entries.  */
4043           bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
4044           htab_clear_slot (*htab, entryp);
4045           return 1;
4046         }
4047
4048       entry->d.h = h;
4049
4050       /* If we can't find this entry with the new bfd hash, re-insert
4051          it, and get the traversal restarted.  */
4052       if (! htab_find (*htab, entry))
4053         {
4054           htab_clear_slot (*htab, entryp);
4055           entryp = htab_find_slot (*htab, entry, INSERT);
4056           if (! *entryp)
4057             *entryp = entry;
4058           /* Abort the traversal, since the whole table may have
4059              moved, and leave it up to the parent to restart the
4060              process.  */
4061           *(htab_t *)p = NULL;
4062           return 0;
4063         }
4064     }
4065
4066   return 1;
4067 }
4068
4069 /* Compute the total size of the GOT, the PLT, the dynamic relocations
4070    section and the rofixup section.  Assign locations for GOT and PLT
4071    entries.  */
4072
4073 static bfd_boolean
4074 _bfinfdpic_size_got_plt (bfd *output_bfd,
4075                          struct _bfinfdpic_dynamic_got_plt_info *gpinfop)
4076 {
4077   bfd_signed_vma odd;
4078   bfd_vma limit;
4079   struct bfd_link_info *info = gpinfop->g.info;
4080   bfd *dynobj = elf_hash_table (info)->dynobj;
4081
4082   memcpy (bfinfdpic_dynamic_got_plt_info (info), &gpinfop->g,
4083           sizeof (gpinfop->g));
4084
4085   odd = 12;
4086   /* Compute the total size taken by entries in the 18-bit range,
4087      to tell how many PLT function descriptors we can bring into it
4088      without causing it to overflow.  */
4089   limit = odd + gpinfop->g.got17m4 + gpinfop->g.fd17m4;
4090   if (limit < (bfd_vma)1 << 18)
4091     limit = ((bfd_vma)1 << 18) - limit;
4092   else
4093     limit = 0;
4094   if (gpinfop->g.fdplt < limit)
4095     limit = gpinfop->g.fdplt;
4096
4097   /* Determine the ranges of GOT offsets that we can use for each
4098      range of addressing modes.  */
4099   odd = _bfinfdpic_compute_got_alloc_data (&gpinfop->got17m4,
4100                                           0,
4101                                           odd,
4102                                           16,
4103                                           gpinfop->g.got17m4,
4104                                           gpinfop->g.fd17m4,
4105                                           limit,
4106                                           (bfd_vma)1 << (18-1));
4107   odd = _bfinfdpic_compute_got_alloc_data (&gpinfop->gothilo,
4108                                           gpinfop->got17m4.min,
4109                                           odd,
4110                                           gpinfop->got17m4.max,
4111                                           gpinfop->g.gothilo,
4112                                           gpinfop->g.fdhilo,
4113                                           gpinfop->g.fdplt - gpinfop->got17m4.fdplt,
4114                                           (bfd_vma)1 << (32-1));
4115
4116   /* Now assign (most) GOT offsets.  */
4117   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
4118                  gpinfop);
4119
4120   bfinfdpic_got_section (info)->size = gpinfop->gothilo.max
4121     - gpinfop->gothilo.min
4122     /* If an odd word is the last word of the GOT, we don't need this
4123        word to be part of the GOT.  */
4124     - (odd + 4 == gpinfop->gothilo.max ? 4 : 0);
4125   if (bfinfdpic_got_section (info)->size == 0)
4126     bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4127   else if (bfinfdpic_got_section (info)->size == 12
4128            && ! elf_hash_table (info)->dynamic_sections_created)
4129     {
4130       bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4131       bfinfdpic_got_section (info)->size = 0;
4132     }
4133   else
4134     {
4135       bfinfdpic_got_section (info)->contents =
4136         (bfd_byte *) bfd_zalloc (dynobj,
4137                                  bfinfdpic_got_section (info)->size);
4138       if (bfinfdpic_got_section (info)->contents == NULL)
4139         return FALSE;
4140     }
4141
4142   if (elf_hash_table (info)->dynamic_sections_created)
4143     /* Subtract the number of lzplt entries, since those will generate
4144        relocations in the pltrel section.  */
4145     bfinfdpic_gotrel_section (info)->size =
4146       (gpinfop->g.relocs - gpinfop->g.lzplt / LZPLT_NORMAL_SIZE)
4147       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4148   else
4149     BFD_ASSERT (gpinfop->g.relocs == 0);
4150   if (bfinfdpic_gotrel_section (info)->size == 0)
4151     bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
4152   else
4153     {
4154       bfinfdpic_gotrel_section (info)->contents =
4155         (bfd_byte *) bfd_zalloc (dynobj,
4156                                  bfinfdpic_gotrel_section (info)->size);
4157       if (bfinfdpic_gotrel_section (info)->contents == NULL)
4158         return FALSE;
4159     }
4160
4161   bfinfdpic_gotfixup_section (info)->size = (gpinfop->g.fixups + 1) * 4;
4162   if (bfinfdpic_gotfixup_section (info)->size == 0)
4163     bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
4164   else
4165     {
4166       bfinfdpic_gotfixup_section (info)->contents =
4167         (bfd_byte *) bfd_zalloc (dynobj,
4168                                  bfinfdpic_gotfixup_section (info)->size);
4169       if (bfinfdpic_gotfixup_section (info)->contents == NULL)
4170         return FALSE;
4171     }
4172
4173   if (elf_hash_table (info)->dynamic_sections_created)
4174     bfinfdpic_pltrel_section (info)->size =
4175       gpinfop->g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4176   if (bfinfdpic_pltrel_section (info)->size == 0)
4177     bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
4178   else
4179     {
4180       bfinfdpic_pltrel_section (info)->contents =
4181         (bfd_byte *) bfd_zalloc (dynobj,
4182                                  bfinfdpic_pltrel_section (info)->size);
4183       if (bfinfdpic_pltrel_section (info)->contents == NULL)
4184         return FALSE;
4185     }
4186
4187   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4188      such that there's room for the additional instruction needed to
4189      call the resolver.  Since _bfinfdpic_assign_got_entries didn't
4190      account for them, our block size is 4 bytes smaller than the real
4191      block size.  */
4192   if (elf_hash_table (info)->dynamic_sections_created)
4193     {
4194       bfinfdpic_plt_section (info)->size = gpinfop->g.lzplt
4195         + ((gpinfop->g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
4196            / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
4197     }
4198
4199   /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4200      actually assign lazy PLT entries addresses.  */
4201   gpinfop->g.lzplt = 0;
4202
4203   /* Save information that we're going to need to generate GOT and PLT
4204      entries.  */
4205   bfinfdpic_got_initial_offset (info) = -gpinfop->gothilo.min;
4206
4207   if (get_elf_backend_data (output_bfd)->want_got_sym)
4208     elf_hash_table (info)->hgot->root.u.def.value
4209       = bfinfdpic_got_initial_offset (info);
4210
4211   if (elf_hash_table (info)->dynamic_sections_created)
4212     bfinfdpic_plt_initial_offset (info) =
4213       bfinfdpic_plt_section (info)->size;
4214
4215   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4216                  gpinfop);
4217
4218   /* Allocate the PLT section contents only after
4219      _bfinfdpic_assign_plt_entries has a chance to add the size of the
4220      non-lazy PLT entries.  */
4221   if (bfinfdpic_plt_section (info)->size == 0)
4222     bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4223   else
4224     {
4225       bfinfdpic_plt_section (info)->contents =
4226         (bfd_byte *) bfd_zalloc (dynobj,
4227                                  bfinfdpic_plt_section (info)->size);
4228       if (bfinfdpic_plt_section (info)->contents == NULL)
4229         return FALSE;
4230     }
4231
4232   return TRUE;
4233 }
4234
4235 /* Set the sizes of the dynamic sections.  */
4236
4237 static bfd_boolean
4238 elf32_bfinfdpic_size_dynamic_sections (bfd *output_bfd,
4239                                       struct bfd_link_info *info)
4240 {
4241   struct elf_link_hash_table *htab;
4242   bfd *dynobj;
4243   asection *s;
4244   struct _bfinfdpic_dynamic_got_plt_info gpinfo;
4245
4246   htab = elf_hash_table (info);
4247   dynobj = htab->dynobj;
4248   BFD_ASSERT (dynobj != NULL);
4249
4250   if (htab->dynamic_sections_created)
4251     {
4252       /* Set the contents of the .interp section to the interpreter.  */
4253       if (bfd_link_executable (info) && !info->nointerp)
4254         {
4255           s = bfd_get_linker_section (dynobj, ".interp");
4256           BFD_ASSERT (s != NULL);
4257           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
4258           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
4259         }
4260     }
4261
4262   memset (&gpinfo, 0, sizeof (gpinfo));
4263   gpinfo.g.info = info;
4264
4265   for (;;)
4266     {
4267       htab_t relocs = bfinfdpic_relocs_info (info);
4268
4269       htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
4270
4271       if (relocs == bfinfdpic_relocs_info (info))
4272         break;
4273     }
4274
4275   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
4276                  &gpinfo.g);
4277
4278   /* Allocate space to save the summary information, we're going to
4279      use it if we're doing relaxations.  */
4280   bfinfdpic_dynamic_got_plt_info (info) = bfd_alloc (dynobj, sizeof (gpinfo.g));
4281
4282   if (!_bfinfdpic_size_got_plt (output_bfd, &gpinfo))
4283       return FALSE;
4284
4285   if (elf_hash_table (info)->dynamic_sections_created)
4286     {
4287       if (bfinfdpic_got_section (info)->size)
4288         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
4289           return FALSE;
4290
4291       if (bfinfdpic_pltrel_section (info)->size)
4292         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4293             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
4294             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4295           return FALSE;
4296
4297       if (bfinfdpic_gotrel_section (info)->size)
4298         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
4299             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
4300             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
4301                                             sizeof (Elf32_External_Rel)))
4302           return FALSE;
4303     }
4304
4305   s = bfd_get_linker_section (dynobj, ".dynbss");
4306   if (s && s->size == 0)
4307     s->flags |= SEC_EXCLUDE;
4308
4309   s = bfd_get_linker_section (dynobj, ".rela.bss");
4310   if (s && s->size == 0)
4311     s->flags |= SEC_EXCLUDE;
4312
4313   return TRUE;
4314 }
4315
4316 static bfd_boolean
4317 elf32_bfinfdpic_always_size_sections (bfd *output_bfd,
4318                                      struct bfd_link_info *info)
4319 {
4320   if (!bfd_link_relocatable (info)
4321       && !bfd_elf_stack_segment_size (output_bfd, info,
4322                                       "__stacksize", DEFAULT_STACK_SIZE))
4323     return FALSE;
4324
4325   return TRUE;
4326 }
4327
4328 /* Check whether any of the relocations was optimized away, and
4329    subtract it from the relocation or fixup count.  */
4330 static bfd_boolean
4331 _bfinfdpic_check_discarded_relocs (bfd *abfd, asection *sec,
4332                                    struct bfd_link_info *info,
4333                                    bfd_boolean *changed)
4334 {
4335   Elf_Internal_Shdr *symtab_hdr;
4336   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4337   Elf_Internal_Rela *rel, *erel;
4338
4339   if ((sec->flags & SEC_RELOC) == 0
4340       || sec->reloc_count == 0)
4341     return TRUE;
4342
4343   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4344   sym_hashes = elf_sym_hashes (abfd);
4345   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4346   if (!elf_bad_symtab (abfd))
4347     sym_hashes_end -= symtab_hdr->sh_info;
4348
4349   rel = elf_section_data (sec)->relocs;
4350
4351   /* Now examine each relocation.  */
4352   for (erel = rel + sec->reloc_count; rel < erel; rel++)
4353     {
4354       struct elf_link_hash_entry *h;
4355       unsigned long r_symndx;
4356       struct bfinfdpic_relocs_info *picrel;
4357       struct _bfinfdpic_dynamic_got_info *dinfo;
4358
4359       if (ELF32_R_TYPE (rel->r_info) != R_BFIN_BYTE4_DATA
4360           && ELF32_R_TYPE (rel->r_info) != R_BFIN_FUNCDESC)
4361         continue;
4362
4363       if (_bfd_elf_section_offset (sec->output_section->owner,
4364                                    info, sec, rel->r_offset)
4365           != (bfd_vma)-1)
4366         continue;
4367
4368       r_symndx = ELF32_R_SYM (rel->r_info);
4369       if (r_symndx < symtab_hdr->sh_info)
4370         h = NULL;
4371       else
4372         {
4373           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4374           while (h->root.type == bfd_link_hash_indirect
4375                  || h->root.type == bfd_link_hash_warning)
4376             h = (struct elf_link_hash_entry *)h->root.u.i.link;
4377         }
4378
4379       if (h != NULL)
4380         picrel = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4381                                                   abfd, h,
4382                                                   rel->r_addend, NO_INSERT);
4383       else
4384         picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info (info),
4385                                                  abfd, r_symndx,
4386                                                  rel->r_addend, NO_INSERT);
4387
4388       if (! picrel)
4389         return FALSE;
4390
4391       *changed = TRUE;
4392       dinfo = bfinfdpic_dynamic_got_plt_info (info);
4393
4394       _bfinfdpic_count_relocs_fixups (picrel, dinfo, TRUE);
4395       if (ELF32_R_TYPE (rel->r_info) == R_BFIN_BYTE4_DATA)
4396         picrel->relocs32--;
4397       else /* we know (ELF32_R_TYPE (rel->r_info) == R_BFIN_FUNCDESC) */
4398         picrel->relocsfd--;
4399       _bfinfdpic_count_relocs_fixups (picrel, dinfo, FALSE);
4400     }
4401
4402   return TRUE;
4403 }
4404
4405 static bfd_boolean
4406 bfinfdpic_elf_discard_info (bfd *ibfd,
4407                            struct elf_reloc_cookie *cookie ATTRIBUTE_UNUSED,
4408                            struct bfd_link_info *info)
4409 {
4410   bfd_boolean changed = FALSE;
4411   asection *s;
4412   bfd *obfd = NULL;
4413
4414   /* Account for relaxation of .eh_frame section.  */
4415   for (s = ibfd->sections; s; s = s->next)
4416     if (s->sec_info_type == SEC_INFO_TYPE_EH_FRAME)
4417       {
4418         if (!_bfinfdpic_check_discarded_relocs (ibfd, s, info, &changed))
4419           return FALSE;
4420         obfd = s->output_section->owner;
4421       }
4422
4423   if (changed)
4424     {
4425       struct _bfinfdpic_dynamic_got_plt_info gpinfo;
4426
4427       memset (&gpinfo, 0, sizeof (gpinfo));
4428       memcpy (&gpinfo.g, bfinfdpic_dynamic_got_plt_info (info),
4429               sizeof (gpinfo.g));
4430
4431       /* Clear GOT and PLT assignments.  */
4432       htab_traverse (bfinfdpic_relocs_info (info),
4433                      _bfinfdpic_reset_got_plt_entries,
4434                      NULL);
4435
4436       if (!_bfinfdpic_size_got_plt (obfd, &gpinfo))
4437         return FALSE;
4438     }
4439
4440   return TRUE;
4441 }
4442
4443 static bfd_boolean
4444 elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4445                                         struct bfd_link_info *info)
4446 {
4447   bfd *dynobj;
4448   asection *sdyn;
4449
4450   dynobj = elf_hash_table (info)->dynobj;
4451
4452   if (bfinfdpic_got_section (info))
4453     {
4454       BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4455                   /* PR 17334: It appears that the GOT section can end up
4456                      being bigger than the number of relocs.  Presumably
4457                      because some relocs have been deleted.  A test case has
4458                      yet to be generated for verify this, but in the meantime
4459                      the test below has been changed from == to >= so that
4460                      applications can continue to be built.  */
4461                   >= (bfinfdpic_gotrel_section (info)->reloc_count
4462                       * sizeof (Elf32_External_Rel)));
4463
4464       if (bfinfdpic_gotfixup_section (info))
4465         {
4466           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4467           bfd_vma got_value = hgot->root.u.def.value
4468             + hgot->root.u.def.section->output_section->vma
4469             + hgot->root.u.def.section->output_offset;
4470
4471           _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4472                                  got_value, 0);
4473
4474           if (bfinfdpic_gotfixup_section (info)->size
4475               != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4476             {
4477               _bfd_error_handler
4478                 ("LINKER BUG: .rofixup section size mismatch");
4479               return FALSE;
4480             }
4481         }
4482     }
4483   if (elf_hash_table (info)->dynamic_sections_created)
4484     {
4485       BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4486                   == (bfinfdpic_pltrel_section (info)->reloc_count
4487                       * sizeof (Elf32_External_Rel)));
4488     }
4489
4490   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
4491
4492   if (elf_hash_table (info)->dynamic_sections_created)
4493     {
4494       Elf32_External_Dyn * dyncon;
4495       Elf32_External_Dyn * dynconend;
4496
4497       BFD_ASSERT (sdyn != NULL);
4498
4499       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4500       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4501
4502       for (; dyncon < dynconend; dyncon++)
4503         {
4504           Elf_Internal_Dyn dyn;
4505
4506           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4507
4508           switch (dyn.d_tag)
4509             {
4510             default:
4511               break;
4512
4513             case DT_PLTGOT:
4514               dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4515                 + bfinfdpic_got_section (info)->output_offset
4516                 + bfinfdpic_got_initial_offset (info);
4517               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4518               break;
4519
4520             case DT_JMPREL:
4521               dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4522                 ->output_section->vma
4523                 + bfinfdpic_pltrel_section (info)->output_offset;
4524               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4525               break;
4526
4527             case DT_PLTRELSZ:
4528               dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4529               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4530               break;
4531             }
4532         }
4533     }
4534
4535   return TRUE;
4536 }
4537
4538 /* Adjust a symbol defined by a dynamic object and referenced by a
4539    regular object.  */
4540
4541 static bfd_boolean
4542 elf32_bfinfdpic_adjust_dynamic_symbol (struct bfd_link_info *info,
4543                                        struct elf_link_hash_entry *h)
4544 {
4545   bfd * dynobj;
4546
4547   dynobj = elf_hash_table (info)->dynobj;
4548
4549   /* Make sure we know what is going on here.  */
4550   BFD_ASSERT (dynobj != NULL
4551               && (h->u.weakdef != NULL
4552                   || (h->def_dynamic
4553                       && h->ref_regular
4554                       && !h->def_regular)));
4555
4556   /* If this is a weak symbol, and there is a real definition, the
4557      processor independent code will have arranged for us to see the
4558      real definition first, and we can just use the same value.  */
4559   if (h->u.weakdef != NULL)
4560     {
4561       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4562                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4563       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4564       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4565     }
4566
4567   return TRUE;
4568 }
4569
4570 /* Perform any actions needed for dynamic symbols.  */
4571
4572 static bfd_boolean
4573 elf32_bfinfdpic_finish_dynamic_symbol
4574 (bfd *output_bfd ATTRIBUTE_UNUSED,
4575  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4576  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4577  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4578 {
4579   return TRUE;
4580 }
4581
4582 /* Decide whether to attempt to turn absptr or lsda encodings in
4583    shared libraries into pcrel within the given input section.  */
4584
4585 static bfd_boolean
4586 bfinfdpic_elf_use_relative_eh_frame
4587 (bfd *input_bfd ATTRIBUTE_UNUSED,
4588  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4589  asection *eh_frame_section ATTRIBUTE_UNUSED)
4590 {
4591   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
4592   return FALSE;
4593 }
4594
4595 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
4596
4597 static bfd_byte
4598 bfinfdpic_elf_encode_eh_address (bfd *abfd,
4599                                 struct bfd_link_info *info,
4600                                 asection *osec, bfd_vma offset,
4601                                 asection *loc_sec, bfd_vma loc_offset,
4602                                 bfd_vma *encoded)
4603 {
4604   struct elf_link_hash_entry *h;
4605
4606   h = elf_hash_table (info)->hgot;
4607   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4608
4609   if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4610               == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4611     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4612                                        loc_sec, loc_offset, encoded);
4613
4614   BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4615               == (_bfinfdpic_osec_to_segment
4616                   (abfd, h->root.u.def.section->output_section)));
4617
4618   *encoded = osec->vma + offset
4619     - (h->root.u.def.value
4620        + h->root.u.def.section->output_section->vma
4621        + h->root.u.def.section->output_offset);
4622
4623   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4624 }
4625
4626
4627
4628 /* Look through the relocs for a section during the first phase.
4629
4630    Besides handling virtual table relocs for gc, we have to deal with
4631    all sorts of PIC-related relocations.  We describe below the
4632    general plan on how to handle such relocations, even though we only
4633    collect information at this point, storing them in hash tables for
4634    perusal of later passes.
4635
4636    32 relocations are propagated to the linker output when creating
4637    position-independent output.  LO16 and HI16 relocations are not
4638    supposed to be encountered in this case.
4639
4640    LABEL16 should always be resolvable by the linker, since it's only
4641    used by branches.
4642
4643    LABEL24, on the other hand, is used by calls.  If it turns out that
4644    the target of a call is a dynamic symbol, a PLT entry must be
4645    created for it, which triggers the creation of a private function
4646    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4647
4648    GPREL relocations require the referenced symbol to be in the same
4649    segment as _gp, but this can only be checked later.
4650
4651    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4652    exist.  LABEL24 might as well, since it may require a PLT entry,
4653    that will require a got.
4654
4655    Non-FUNCDESC GOT relocations require a GOT entry to be created
4656    regardless of whether the symbol is dynamic.  However, since a
4657    global symbol that turns out to not be exported may have the same
4658    address of a non-dynamic symbol, we don't assign GOT entries at
4659    this point, such that we can share them in this case.  A relocation
4660    for the GOT entry always has to be created, be it to offset a
4661    private symbol by the section load address, be it to get the symbol
4662    resolved dynamically.
4663
4664    FUNCDESC GOT relocations require a GOT entry to be created, and
4665    handled as if a FUNCDESC relocation was applied to the GOT entry in
4666    an object file.
4667
4668    FUNCDESC relocations referencing a symbol that turns out to NOT be
4669    dynamic cause a private function descriptor to be created.  The
4670    FUNCDESC relocation then decays to a 32 relocation that points at
4671    the private descriptor.  If the symbol is dynamic, the FUNCDESC
4672    relocation is propagated to the linker output, such that the
4673    dynamic linker creates the canonical descriptor, pointing to the
4674    dynamically-resolved definition of the function.
4675
4676    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4677    symbols that are assigned to the same segment as the GOT, but we
4678    can only check this later, after we know the complete set of
4679    symbols defined and/or exported.
4680
4681    FUNCDESC GOTOFF relocations require a function descriptor to be
4682    created and, unless lazy binding is disabled or the symbol is not
4683    dynamic, a lazy PLT entry.  Since we can't tell at this point
4684    whether a symbol is going to be dynamic, we have to decide later
4685    whether to create a lazy PLT entry or bind the descriptor directly
4686    to the private function.
4687
4688    FUNCDESC_VALUE relocations are not supposed to be present in object
4689    files, but they may very well be simply propagated to the linker
4690    output, since they have no side effect.
4691
4692
4693    A function descriptor always requires a FUNCDESC_VALUE relocation.
4694    Whether it's in .plt.rel or not depends on whether lazy binding is
4695    enabled and on whether the referenced symbol is dynamic.
4696
4697    The existence of a lazy PLT requires the resolverStub lazy PLT
4698    entry to be present.
4699
4700
4701    As for assignment of GOT, PLT and lazy PLT entries, and private
4702    descriptors, we might do them all sequentially, but we can do
4703    better than that.  For example, we can place GOT entries and
4704    private function descriptors referenced using 12-bit operands
4705    closer to the PIC register value, such that these relocations don't
4706    overflow.  Those that are only referenced with LO16 relocations
4707    could come next, but we may as well place PLT-required function
4708    descriptors in the 12-bit range to make them shorter.  Symbols
4709    referenced with LO16/HI16 may come next, but we may place
4710    additional function descriptors in the 16-bit range if we can
4711    reliably tell that we've already placed entries that are ever
4712    referenced with only LO16.  PLT entries are therefore generated as
4713    small as possible, while not introducing relocation overflows in
4714    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
4715    generated before or after PLT entries, but not intermingled with
4716    them, such that we can have more lazy PLT entries in range for a
4717    branch to the resolverStub.  The resolverStub should be emitted at
4718    the most distant location from the first lazy PLT entry such that
4719    it's still in range for a branch, or closer, if there isn't a need
4720    for so many lazy PLT entries.  Additional lazy PLT entries may be
4721    emitted after the resolverStub, as long as branches are still in
4722    range.  If the branch goes out of range, longer lazy PLT entries
4723    are emitted.
4724
4725    We could further optimize PLT and lazy PLT entries by giving them
4726    priority in assignment to closer-to-gr17 locations depending on the
4727    number of occurrences of references to them (assuming a function
4728    that's called more often is more important for performance, so its
4729    PLT entry should be faster), or taking hints from the compiler.
4730    Given infinite time and money... :-)  */
4731
4732 static bfd_boolean
4733 bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4734                         asection *sec, const Elf_Internal_Rela *relocs)
4735 {
4736   Elf_Internal_Shdr *symtab_hdr;
4737   struct elf_link_hash_entry **sym_hashes;
4738   const Elf_Internal_Rela *rel;
4739   const Elf_Internal_Rela *rel_end;
4740   bfd *dynobj;
4741   struct bfinfdpic_relocs_info *picrel;
4742
4743   if (bfd_link_relocatable (info))
4744     return TRUE;
4745
4746   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4747   sym_hashes = elf_sym_hashes (abfd);
4748
4749   dynobj = elf_hash_table (info)->dynobj;
4750   rel_end = relocs + sec->reloc_count;
4751   for (rel = relocs; rel < rel_end; rel++)
4752     {
4753       struct elf_link_hash_entry *h;
4754       unsigned long r_symndx;
4755
4756       r_symndx = ELF32_R_SYM (rel->r_info);
4757       if (r_symndx < symtab_hdr->sh_info)
4758         h = NULL;
4759       else
4760         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4761
4762       switch (ELF32_R_TYPE (rel->r_info))
4763         {
4764         case R_BFIN_GOT17M4:
4765         case R_BFIN_GOTHI:
4766         case R_BFIN_GOTLO:
4767         case R_BFIN_FUNCDESC_GOT17M4:
4768         case R_BFIN_FUNCDESC_GOTHI:
4769         case R_BFIN_FUNCDESC_GOTLO:
4770         case R_BFIN_GOTOFF17M4:
4771         case R_BFIN_GOTOFFHI:
4772         case R_BFIN_GOTOFFLO:
4773         case R_BFIN_FUNCDESC_GOTOFF17M4:
4774         case R_BFIN_FUNCDESC_GOTOFFHI:
4775         case R_BFIN_FUNCDESC_GOTOFFLO:
4776         case R_BFIN_FUNCDESC:
4777         case R_BFIN_FUNCDESC_VALUE:
4778           if (! IS_FDPIC (abfd))
4779             goto bad_reloc;
4780           /* Fall through.  */
4781         case R_BFIN_PCREL24:
4782         case R_BFIN_PCREL24_JUMP_L:
4783         case R_BFIN_BYTE4_DATA:
4784           if (IS_FDPIC (abfd) && ! dynobj)
4785             {
4786               elf_hash_table (info)->dynobj = dynobj = abfd;
4787               if (! _bfin_create_got_section (abfd, info))
4788                 return FALSE;
4789             }
4790           if (! IS_FDPIC (abfd))
4791             {
4792               picrel = NULL;
4793               break;
4794             }
4795           if (h != NULL)
4796             {
4797               if (h->dynindx == -1)
4798                 switch (ELF_ST_VISIBILITY (h->other))
4799                   {
4800                   case STV_INTERNAL:
4801                   case STV_HIDDEN:
4802                     break;
4803                   default:
4804                     bfd_elf_link_record_dynamic_symbol (info, h);
4805                     break;
4806                   }
4807               picrel
4808                 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4809                                                    abfd, h,
4810                                                    rel->r_addend, INSERT);
4811             }
4812           else
4813             picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4814                                                      (info), abfd, r_symndx,
4815                                                      rel->r_addend, INSERT);
4816           if (! picrel)
4817             return FALSE;
4818           break;
4819
4820         default:
4821           picrel = NULL;
4822           break;
4823         }
4824
4825       switch (ELF32_R_TYPE (rel->r_info))
4826         {
4827         case R_BFIN_PCREL24:
4828         case R_BFIN_PCREL24_JUMP_L:
4829           if (IS_FDPIC (abfd))
4830             picrel->call++;
4831           break;
4832
4833         case R_BFIN_FUNCDESC_VALUE:
4834           picrel->relocsfdv++;
4835           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4836             picrel->relocs32--;
4837           /* Fall through.  */
4838
4839         case R_BFIN_BYTE4_DATA:
4840           if (! IS_FDPIC (abfd))
4841             break;
4842
4843           picrel->sym++;
4844           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4845             picrel->relocs32++;
4846           break;
4847
4848         case R_BFIN_GOT17M4:
4849           picrel->got17m4++;
4850           break;
4851
4852         case R_BFIN_GOTHI:
4853         case R_BFIN_GOTLO:
4854           picrel->gothilo++;
4855           break;
4856
4857         case R_BFIN_FUNCDESC_GOT17M4:
4858           picrel->fdgot17m4++;
4859           break;
4860
4861         case R_BFIN_FUNCDESC_GOTHI:
4862         case R_BFIN_FUNCDESC_GOTLO:
4863           picrel->fdgothilo++;
4864           break;
4865
4866         case R_BFIN_GOTOFF17M4:
4867         case R_BFIN_GOTOFFHI:
4868         case R_BFIN_GOTOFFLO:
4869           picrel->gotoff++;
4870           break;
4871
4872         case R_BFIN_FUNCDESC_GOTOFF17M4:
4873           picrel->fdgoff17m4++;
4874           break;
4875
4876         case R_BFIN_FUNCDESC_GOTOFFHI:
4877         case R_BFIN_FUNCDESC_GOTOFFLO:
4878           picrel->fdgoffhilo++;
4879           break;
4880
4881         case R_BFIN_FUNCDESC:
4882           picrel->fd++;
4883           picrel->relocsfd++;
4884           break;
4885
4886         /* This relocation describes the C++ object vtable hierarchy.
4887            Reconstruct it for later use during GC.  */
4888         case R_BFIN_GNU_VTINHERIT:
4889           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4890             return FALSE;
4891           break;
4892
4893         /* This relocation describes which C++ vtable entries are actually
4894            used.  Record for later use during GC.  */
4895         case R_BFIN_GNU_VTENTRY:
4896           BFD_ASSERT (h != NULL);
4897           if (h != NULL
4898               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4899             return FALSE;
4900           break;
4901
4902         case R_BFIN_HUIMM16:
4903         case R_BFIN_LUIMM16:
4904         case R_BFIN_PCREL12_JUMP_S:
4905         case R_BFIN_PCREL10:
4906           break;
4907
4908         default:
4909         bad_reloc:
4910           _bfd_error_handler
4911             (_("%B: unsupported relocation type %i"),
4912              abfd, ELF32_R_TYPE (rel->r_info));
4913           return FALSE;
4914         }
4915     }
4916
4917   return TRUE;
4918 }
4919
4920 /* Set the right machine number for a Blackfin ELF file.  */
4921
4922 static bfd_boolean
4923 elf32_bfin_object_p (bfd *abfd)
4924 {
4925   bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4926   return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4927           == (IS_FDPIC (abfd)));
4928 }
4929
4930 static bfd_boolean
4931 elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4932 {
4933   elf_elfheader (abfd)->e_flags = flags;
4934   elf_flags_init (abfd) = TRUE;
4935   return TRUE;
4936 }
4937
4938 /* Display the flags field.  */
4939 static bfd_boolean
4940 elf32_bfin_print_private_bfd_data (bfd * abfd, void * ptr)
4941 {
4942   FILE *file = (FILE *) ptr;
4943   flagword flags;
4944
4945   BFD_ASSERT (abfd != NULL && ptr != NULL);
4946
4947   /* Print normal ELF private data.  */
4948   _bfd_elf_print_private_bfd_data (abfd, ptr);
4949
4950   flags = elf_elfheader (abfd)->e_flags;
4951
4952   /* xgettext:c-format */
4953   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4954
4955   if (flags & EF_BFIN_PIC)
4956     fprintf (file, " -fpic");
4957
4958   if (flags & EF_BFIN_FDPIC)
4959     fprintf (file, " -mfdpic");
4960
4961   fputc ('\n', file);
4962
4963   return TRUE;
4964 }
4965
4966 /* Merge backend specific data from an object file to the output
4967    object file when linking.  */
4968
4969 static bfd_boolean
4970 elf32_bfin_merge_private_bfd_data (bfd *ibfd, struct bfd_link_info *info)
4971 {
4972   bfd *obfd = info->output_bfd;
4973   flagword old_flags, new_flags;
4974   bfd_boolean error = FALSE;
4975
4976   new_flags = elf_elfheader (ibfd)->e_flags;
4977   old_flags = elf_elfheader (obfd)->e_flags;
4978
4979   if (new_flags & EF_BFIN_FDPIC)
4980     new_flags &= ~EF_BFIN_PIC;
4981
4982 #ifndef DEBUG
4983   if (0)
4984 #endif
4985   _bfd_error_handler
4986     ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4987      old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4988      bfd_get_filename (ibfd));
4989
4990   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
4991     {
4992       elf_flags_init (obfd) = TRUE;
4993       elf_elfheader (obfd)->e_flags = new_flags;
4994     }
4995
4996   if (((new_flags & EF_BFIN_FDPIC) == 0) != (! IS_FDPIC (obfd)))
4997     {
4998       error = TRUE;
4999       if (IS_FDPIC (obfd))
5000         _bfd_error_handler
5001           (_("%s: cannot link non-fdpic object file into fdpic executable"),
5002            bfd_get_filename (ibfd));
5003       else
5004         _bfd_error_handler
5005           (_("%s: cannot link fdpic object file into non-fdpic executable"),
5006            bfd_get_filename (ibfd));
5007     }
5008
5009   if (error)
5010     bfd_set_error (bfd_error_bad_value);
5011
5012   return !error;
5013 }
5014 \f
5015 /* bfin ELF linker hash entry.  */
5016
5017 struct bfin_link_hash_entry
5018 {
5019   struct elf_link_hash_entry root;
5020
5021   /* Number of PC relative relocs copied for this symbol.  */
5022   struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
5023 };
5024
5025 /* bfin ELF linker hash table.  */
5026
5027 struct bfin_link_hash_table
5028 {
5029   struct elf_link_hash_table root;
5030
5031   /* Small local sym cache.  */
5032   struct sym_cache sym_cache;
5033 };
5034
5035 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
5036
5037 static struct bfd_hash_entry *
5038 bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
5039                         struct bfd_hash_table *table, const char *string)
5040 {
5041   struct bfd_hash_entry *ret = entry;
5042
5043   /* Allocate the structure if it has not already been allocated by a
5044      subclass.  */
5045   if (ret == NULL)
5046     ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
5047   if (ret == NULL)
5048     return ret;
5049
5050   /* Call the allocation method of the superclass.  */
5051   ret = _bfd_elf_link_hash_newfunc (ret, table, string);
5052   if (ret != NULL)
5053     bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
5054
5055   return ret;
5056 }
5057
5058 /* Create an bfin ELF linker hash table.  */
5059
5060 static struct bfd_link_hash_table *
5061 bfin_link_hash_table_create (bfd * abfd)
5062 {
5063   struct bfin_link_hash_table *ret;
5064   bfd_size_type amt = sizeof (struct bfin_link_hash_table);
5065
5066   ret = bfd_zmalloc (amt);
5067   if (ret == NULL)
5068     return NULL;
5069
5070   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
5071                                       bfin_link_hash_newfunc,
5072                                       sizeof (struct elf_link_hash_entry),
5073                                       BFIN_ELF_DATA))
5074     {
5075       free (ret);
5076       return NULL;
5077     }
5078
5079   ret->sym_cache.abfd = NULL;
5080
5081   return &ret->root.root;
5082 }
5083
5084 /* The size in bytes of an entry in the procedure linkage table.  */
5085
5086 /* Finish up the dynamic sections.  */
5087
5088 static bfd_boolean
5089 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5090                               struct bfd_link_info *info)
5091 {
5092   bfd *dynobj;
5093   asection *sdyn;
5094
5095   dynobj = elf_hash_table (info)->dynobj;
5096
5097   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
5098
5099   if (elf_hash_table (info)->dynamic_sections_created)
5100     {
5101       Elf32_External_Dyn *dyncon, *dynconend;
5102
5103       BFD_ASSERT (sdyn != NULL);
5104
5105       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5106       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5107       for (; dyncon < dynconend; dyncon++)
5108         {
5109           Elf_Internal_Dyn dyn;
5110
5111           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5112
5113         }
5114
5115     }
5116   return TRUE;
5117 }
5118
5119 /* Finish up dynamic symbol handling.  We set the contents of various
5120    dynamic sections here.  */
5121
5122 static bfd_boolean
5123 bfin_finish_dynamic_symbol (bfd * output_bfd,
5124                             struct bfd_link_info *info,
5125                             struct elf_link_hash_entry *h,
5126                             Elf_Internal_Sym * sym)
5127 {
5128   bfd *dynobj;
5129
5130   dynobj = elf_hash_table (info)->dynobj;
5131
5132   if (h->got.offset != (bfd_vma) - 1)
5133     {
5134       asection *sgot;
5135       asection *srela;
5136       Elf_Internal_Rela rela;
5137       bfd_byte *loc;
5138
5139       /* This symbol has an entry in the global offset table.
5140          Set it up.  */
5141
5142       sgot = bfd_get_linker_section (dynobj, ".got");
5143       srela = bfd_get_linker_section (dynobj, ".rela.got");
5144       BFD_ASSERT (sgot != NULL && srela != NULL);
5145
5146       rela.r_offset = (sgot->output_section->vma
5147                        + sgot->output_offset
5148                        + (h->got.offset & ~(bfd_vma) 1));
5149
5150       /* If this is a -Bsymbolic link, and the symbol is defined
5151          locally, we just want to emit a RELATIVE reloc.  Likewise if
5152          the symbol was forced to be local because of a version file.
5153          The entry in the global offset table will already have been
5154          initialized in the relocate_section function.  */
5155       if (bfd_link_pic (info)
5156           && (info->symbolic
5157               || h->dynindx == -1 || h->forced_local) && h->def_regular)
5158         {
5159           _bfd_error_handler (_("*** check this relocation %s"),
5160                               __FUNCTION__);
5161           rela.r_info = ELF32_R_INFO (0, R_BFIN_PCREL24);
5162           rela.r_addend = bfd_get_signed_32 (output_bfd,
5163                                              (sgot->contents
5164                                               +
5165                                               (h->got.
5166                                                offset & ~(bfd_vma) 1)));
5167         }
5168       else
5169         {
5170           bfd_put_32 (output_bfd, (bfd_vma) 0,
5171                       sgot->contents + (h->got.offset & ~(bfd_vma) 1));
5172           rela.r_info = ELF32_R_INFO (h->dynindx, R_BFIN_GOT);
5173           rela.r_addend = 0;
5174         }
5175
5176       loc = srela->contents;
5177       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5178       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5179     }
5180
5181   if (h->needs_copy)
5182     {
5183       BFD_ASSERT (0);
5184     }
5185   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5186   if (strcmp (h->root.root.string, "__DYNAMIC") == 0
5187       || h == elf_hash_table (info)->hgot)
5188     sym->st_shndx = SHN_ABS;
5189
5190   return TRUE;
5191 }
5192
5193 /* Adjust a symbol defined by a dynamic object and referenced by a
5194    regular object.  The current definition is in some section of the
5195    dynamic object, but we're not including those sections.  We have to
5196    change the definition to something the rest of the link can
5197    understand.  */
5198
5199 static bfd_boolean
5200 bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
5201                             struct elf_link_hash_entry *h)
5202 {
5203   bfd *dynobj;
5204   asection *s;
5205   unsigned int power_of_two;
5206
5207   dynobj = elf_hash_table (info)->dynobj;
5208
5209   /* Make sure we know what is going on here.  */
5210   BFD_ASSERT (dynobj != NULL
5211               && (h->needs_plt
5212                   || h->u.weakdef != NULL
5213                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
5214
5215   /* If this is a function, put it in the procedure linkage table.  We
5216      will fill in the contents of the procedure linkage table later,
5217      when we know the address of the .got section.  */
5218   if (h->type == STT_FUNC || h->needs_plt)
5219     {
5220       BFD_ASSERT(0);
5221     }
5222
5223   /* If this is a weak symbol, and there is a real definition, the
5224      processor independent code will have arranged for us to see the
5225      real definition first, and we can just use the same value.  */
5226   if (h->u.weakdef != NULL)
5227     {
5228       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5229                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5230       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5231       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5232       return TRUE;
5233     }
5234
5235   /* This is a reference to a symbol defined by a dynamic object which
5236      is not a function.  */
5237
5238   /* If we are creating a shared library, we must presume that the
5239      only references to the symbol are via the global offset table.
5240      For such cases we need not do anything here; the relocations will
5241      be handled correctly by relocate_section.  */
5242   if (bfd_link_pic (info))
5243     return TRUE;
5244
5245   /* We must allocate the symbol in our .dynbss section, which will
5246      become part of the .bss section of the executable.  There will be
5247      an entry for this symbol in the .dynsym section.  The dynamic
5248      object will contain position independent code, so all references
5249      from the dynamic object to this symbol will go through the global
5250      offset table.  The dynamic linker will use the .dynsym entry to
5251      determine the address it must put in the global offset table, so
5252      both the dynamic object and the regular object will refer to the
5253      same memory location for the variable.  */
5254
5255   s = bfd_get_linker_section (dynobj, ".dynbss");
5256   BFD_ASSERT (s != NULL);
5257
5258 #if 0 /* Bfin does not currently have a COPY reloc.  */
5259   /* We must generate a R_BFIN_COPY reloc to tell the dynamic linker to
5260      copy the initial value out of the dynamic object and into the
5261      runtime process image.  We need to remember the offset into the
5262      .rela.bss section we are going to use.  */
5263   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5264     {
5265       asection *srel;
5266
5267       srel = bfd_get_linker_section (dynobj, ".rela.bss");
5268       BFD_ASSERT (srel != NULL);
5269       srel->size += sizeof (Elf32_External_Rela);
5270       h->needs_copy = 1;
5271     }
5272 #else
5273   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5274     {
5275       _bfd_error_handler (_("the bfin target does not currently support the generation of copy relocations"));
5276       return FALSE;
5277     }
5278 #endif
5279   /* We need to figure out the alignment required for this symbol.  I
5280      have no idea how ELF linkers handle this.  */
5281   power_of_two = bfd_log2 (h->size);
5282   if (power_of_two > 3)
5283     power_of_two = 3;
5284
5285   /* Apply the required alignment.  */
5286   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5287   if (power_of_two > bfd_get_section_alignment (dynobj, s))
5288     {
5289       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
5290         return FALSE;
5291     }
5292
5293   /* Define the symbol as being at this point in the section.  */
5294   h->root.u.def.section = s;
5295   h->root.u.def.value = s->size;
5296
5297   /* Increment the section size to make room for the symbol.  */
5298   s->size += h->size;
5299
5300   return TRUE;
5301 }
5302
5303 /* The bfin linker needs to keep track of the number of relocs that it
5304    decides to copy in check_relocs for each symbol.  This is so that it
5305    can discard PC relative relocs if it doesn't need them when linking
5306    with -Bsymbolic.  We store the information in a field extending the
5307    regular ELF linker hash table.  */
5308
5309 /* This structure keeps track of the number of PC relative relocs we have
5310    copied for a given symbol.  */
5311
5312 struct bfin_pcrel_relocs_copied
5313 {
5314   /* Next section.  */
5315   struct bfin_pcrel_relocs_copied *next;
5316   /* A section in dynobj.  */
5317   asection *section;
5318   /* Number of relocs copied in this section.  */
5319   bfd_size_type count;
5320 };
5321
5322 /* This function is called via elf_link_hash_traverse if we are
5323    creating a shared object.  In the -Bsymbolic case it discards the
5324    space allocated to copy PC relative relocs against symbols which
5325    are defined in regular objects.  For the normal shared case, it
5326    discards space for pc-relative relocs that have become local due to
5327    symbol visibility changes.  We allocated space for them in the
5328    check_relocs routine, but we won't fill them in in the
5329    relocate_section routine.
5330
5331    We also check whether any of the remaining relocations apply
5332    against a readonly section, and set the DF_TEXTREL flag in this
5333    case.  */
5334
5335 static bfd_boolean
5336 bfin_discard_copies (struct elf_link_hash_entry *h, void * inf)
5337 {
5338   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5339   struct bfin_pcrel_relocs_copied *s;
5340
5341   if (!h->def_regular || (!info->symbolic && !h->forced_local))
5342     {
5343       if ((info->flags & DF_TEXTREL) == 0)
5344         {
5345           /* Look for relocations against read-only sections.  */
5346           for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5347                s != NULL; s = s->next)
5348             if ((s->section->flags & SEC_READONLY) != 0)
5349               {
5350                 info->flags |= DF_TEXTREL;
5351                 break;
5352               }
5353         }
5354
5355       return TRUE;
5356     }
5357
5358   for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5359        s != NULL; s = s->next)
5360     s->section->size -= s->count * sizeof (Elf32_External_Rela);
5361
5362   return TRUE;
5363 }
5364
5365 static bfd_boolean
5366 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5367                             struct bfd_link_info *info)
5368 {
5369   bfd *dynobj;
5370   asection *s;
5371   bfd_boolean relocs;
5372
5373   dynobj = elf_hash_table (info)->dynobj;
5374   BFD_ASSERT (dynobj != NULL);
5375
5376   if (elf_hash_table (info)->dynamic_sections_created)
5377     {
5378       /* Set the contents of the .interp section to the interpreter.  */
5379       if (bfd_link_executable (info))
5380         {
5381           s = bfd_get_linker_section (dynobj, ".interp");
5382           BFD_ASSERT (s != NULL);
5383           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5384           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5385         }
5386     }
5387   else
5388     {
5389       /* We may have created entries in the .rela.got section.
5390          However, if we are not creating the dynamic sections, we will
5391          not actually use these entries.  Reset the size of .rela.got,
5392          which will cause it to get stripped from the output file
5393          below.  */
5394       s = bfd_get_linker_section (dynobj, ".rela.got");
5395       if (s != NULL)
5396         s->size = 0;
5397     }
5398
5399   /* If this is a -Bsymbolic shared link, then we need to discard all
5400      PC relative relocs against symbols defined in a regular object.
5401      For the normal shared case we discard the PC relative relocs
5402      against symbols that have become local due to visibility changes.
5403      We allocated space for them in the check_relocs routine, but we
5404      will not fill them in in the relocate_section routine.  */
5405   if (bfd_link_pic (info))
5406     elf_link_hash_traverse (elf_hash_table (info),
5407                             bfin_discard_copies, info);
5408
5409   /* The check_relocs and adjust_dynamic_symbol entry points have
5410      determined the sizes of the various dynamic sections.  Allocate
5411      memory for them.  */
5412   relocs = FALSE;
5413   for (s = dynobj->sections; s != NULL; s = s->next)
5414     {
5415       const char *name;
5416       bfd_boolean strip;
5417
5418       if ((s->flags & SEC_LINKER_CREATED) == 0)
5419         continue;
5420
5421       /* It's OK to base decisions on the section name, because none
5422          of the dynobj section names depend upon the input files.  */
5423       name = bfd_get_section_name (dynobj, s);
5424
5425       strip = FALSE;
5426
5427        if (CONST_STRNEQ (name, ".rela"))
5428         {
5429           if (s->size == 0)
5430             {
5431               /* If we don't need this section, strip it from the
5432                  output file.  This is mostly to handle .rela.bss and
5433                  .rela.plt.  We must create both sections in
5434                  create_dynamic_sections, because they must be created
5435                  before the linker maps input sections to output
5436                  sections.  The linker does that before
5437                  adjust_dynamic_symbol is called, and it is that
5438                  function which decides whether anything needs to go
5439                  into these sections.  */
5440               strip = TRUE;
5441             }
5442           else
5443             {
5444               relocs = TRUE;
5445
5446               /* We use the reloc_count field as a counter if we need
5447                  to copy relocs into the output file.  */
5448               s->reloc_count = 0;
5449             }
5450         }
5451       else if (! CONST_STRNEQ (name, ".got"))
5452         {
5453           /* It's not one of our sections, so don't allocate space.  */
5454           continue;
5455         }
5456
5457       if (strip)
5458         {
5459           s->flags |= SEC_EXCLUDE;
5460           continue;
5461         }
5462
5463       /* Allocate memory for the section contents.  */
5464       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5465          Unused entries should be reclaimed before the section's contents
5466          are written out, but at the moment this does not happen.  Thus in
5467          order to prevent writing out garbage, we initialise the section's
5468          contents to zero.  */
5469       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5470       if (s->contents == NULL && s->size != 0)
5471         return FALSE;
5472     }
5473
5474   if (elf_hash_table (info)->dynamic_sections_created)
5475     {
5476       /* Add some entries to the .dynamic section.  We fill in the
5477          values later, in bfin_finish_dynamic_sections, but we
5478          must add the entries now so that we get the correct size for
5479          the .dynamic section.  The DT_DEBUG entry is filled in by the
5480          dynamic linker and used by the debugger.  */
5481 #define add_dynamic_entry(TAG, VAL) \
5482   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5483
5484       if (!bfd_link_pic (info))
5485         {
5486           if (!add_dynamic_entry (DT_DEBUG, 0))
5487             return FALSE;
5488         }
5489
5490
5491       if (relocs)
5492         {
5493           if (!add_dynamic_entry (DT_RELA, 0)
5494               || !add_dynamic_entry (DT_RELASZ, 0)
5495               || !add_dynamic_entry (DT_RELAENT,
5496                                      sizeof (Elf32_External_Rela)))
5497             return FALSE;
5498         }
5499
5500       if ((info->flags & DF_TEXTREL) != 0)
5501         {
5502           if (!add_dynamic_entry (DT_TEXTREL, 0))
5503             return FALSE;
5504         }
5505     }
5506 #undef add_dynamic_entry
5507
5508   return TRUE;
5509 }
5510 \f
5511 /* Given a .data section and a .emreloc in-memory section, store
5512    relocation information into the .emreloc section which can be
5513    used at runtime to relocate the section.  This is called by the
5514    linker when the --embedded-relocs switch is used.  This is called
5515    after the add_symbols entry point has been called for all the
5516    objects, and before the final_link entry point is called.  */
5517
5518 bfd_boolean
5519 bfd_bfin_elf32_create_embedded_relocs (bfd *abfd,
5520                                        struct bfd_link_info *info,
5521                                        asection *datasec,
5522                                        asection *relsec,
5523                                        char **errmsg)
5524 {
5525   Elf_Internal_Shdr *symtab_hdr;
5526   Elf_Internal_Sym *isymbuf = NULL;
5527   Elf_Internal_Rela *internal_relocs = NULL;
5528   Elf_Internal_Rela *irel, *irelend;
5529   bfd_byte *p;
5530   bfd_size_type amt;
5531
5532   BFD_ASSERT (! bfd_link_relocatable (info));
5533
5534   *errmsg = NULL;
5535
5536   if (datasec->reloc_count == 0)
5537     return TRUE;
5538
5539   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5540
5541   /* Get a copy of the native relocations.  */
5542   internal_relocs = (_bfd_elf_link_read_relocs
5543                      (abfd, datasec, NULL, (Elf_Internal_Rela *) NULL,
5544                       info->keep_memory));
5545   if (internal_relocs == NULL)
5546     goto error_return;
5547
5548   amt = (bfd_size_type) datasec->reloc_count * 12;
5549   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5550   if (relsec->contents == NULL)
5551     goto error_return;
5552
5553   p = relsec->contents;
5554
5555   irelend = internal_relocs + datasec->reloc_count;
5556   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5557     {
5558       asection *targetsec;
5559
5560       /* We are going to write a four byte longword into the runtime
5561        reloc section.  The longword will be the address in the data
5562        section which must be relocated.  It is followed by the name
5563        of the target section NUL-padded or truncated to 8
5564        characters.  */
5565
5566       /* We can only relocate absolute longword relocs at run time.  */
5567       if (ELF32_R_TYPE (irel->r_info) != (int) R_BFIN_BYTE4_DATA)
5568         {
5569           *errmsg = _("unsupported reloc type");
5570           bfd_set_error (bfd_error_bad_value);
5571           goto error_return;
5572         }
5573
5574       /* Get the target section referred to by the reloc.  */
5575       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5576         {
5577           /* A local symbol.  */
5578           Elf_Internal_Sym *isym;
5579
5580           /* Read this BFD's local symbols if we haven't done so already.  */
5581           if (isymbuf == NULL)
5582             {
5583               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5584               if (isymbuf == NULL)
5585                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5586                                                 symtab_hdr->sh_info, 0,
5587                                                 NULL, NULL, NULL);
5588               if (isymbuf == NULL)
5589                 goto error_return;
5590             }
5591
5592           isym = isymbuf + ELF32_R_SYM (irel->r_info);
5593           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5594         }
5595       else
5596         {
5597           unsigned long indx;
5598           struct elf_link_hash_entry *h;
5599
5600           /* An external symbol.  */
5601           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5602           h = elf_sym_hashes (abfd)[indx];
5603           BFD_ASSERT (h != NULL);
5604           if (h->root.type == bfd_link_hash_defined
5605               || h->root.type == bfd_link_hash_defweak)
5606             targetsec = h->root.u.def.section;
5607           else
5608             targetsec = NULL;
5609         }
5610
5611       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5612       memset (p + 4, 0, 8);
5613       if (targetsec != NULL)
5614         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5615     }
5616
5617   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5618     free (isymbuf);
5619   if (internal_relocs != NULL
5620       && elf_section_data (datasec)->relocs != internal_relocs)
5621     free (internal_relocs);
5622   return TRUE;
5623
5624 error_return:
5625   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5626     free (isymbuf);
5627   if (internal_relocs != NULL
5628       && elf_section_data (datasec)->relocs != internal_relocs)
5629     free (internal_relocs);
5630   return FALSE;
5631 }
5632
5633 struct bfd_elf_special_section const elf32_bfin_special_sections[] =
5634 {
5635   { ".l1.text",         8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_EXECINSTR },
5636   { ".l1.data",         8, -2, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
5637   { NULL,               0,  0, 0,            0 }
5638 };
5639
5640 \f
5641 #define TARGET_LITTLE_SYM               bfin_elf32_vec
5642 #define TARGET_LITTLE_NAME              "elf32-bfin"
5643 #define ELF_ARCH                        bfd_arch_bfin
5644 #define ELF_TARGET_ID                   BFIN_ELF_DATA
5645 #define ELF_MACHINE_CODE                EM_BLACKFIN
5646 #define ELF_MAXPAGESIZE                 0x1000
5647 #define elf_symbol_leading_char         '_'
5648
5649 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5650 #define bfd_elf32_bfd_reloc_name_lookup \
5651                                         bfin_bfd_reloc_name_lookup
5652 #define elf_info_to_howto               bfin_info_to_howto
5653 #define elf_info_to_howto_rel           0
5654 #define elf_backend_object_p            elf32_bfin_object_p
5655
5656 #define bfd_elf32_bfd_is_local_label_name \
5657                                         bfin_is_local_label_name
5658 #define bfin_hash_table(p) \
5659   ((struct bfin_link_hash_table *) (p)->hash)
5660
5661
5662
5663 #define elf_backend_create_dynamic_sections \
5664                                         _bfd_elf_create_dynamic_sections
5665 #define bfd_elf32_bfd_link_hash_table_create \
5666                                         bfin_link_hash_table_create
5667 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
5668
5669 #define elf_backend_check_relocs        bfin_check_relocs
5670 #define elf_backend_adjust_dynamic_symbol \
5671                                         bfin_adjust_dynamic_symbol
5672 #define elf_backend_size_dynamic_sections \
5673                                         bfin_size_dynamic_sections
5674 #define elf_backend_relocate_section    bfin_relocate_section
5675 #define elf_backend_finish_dynamic_symbol \
5676                                         bfin_finish_dynamic_symbol
5677 #define elf_backend_finish_dynamic_sections \
5678                                         bfin_finish_dynamic_sections
5679 #define elf_backend_gc_mark_hook        bfin_gc_mark_hook
5680 #define elf_backend_gc_sweep_hook       bfin_gc_sweep_hook
5681 #define bfd_elf32_bfd_merge_private_bfd_data \
5682                                         elf32_bfin_merge_private_bfd_data
5683 #define bfd_elf32_bfd_set_private_flags \
5684                                         elf32_bfin_set_private_flags
5685 #define bfd_elf32_bfd_print_private_bfd_data \
5686                                         elf32_bfin_print_private_bfd_data
5687 #define elf_backend_final_write_processing \
5688                                         elf32_bfin_final_write_processing
5689 #define elf_backend_reloc_type_class    elf32_bfin_reloc_type_class
5690 #define elf_backend_stack_align         8
5691 #define elf_backend_can_gc_sections 1
5692 #define elf_backend_special_sections    elf32_bfin_special_sections
5693 #define elf_backend_can_refcount 1
5694 #define elf_backend_want_got_plt 0
5695 #define elf_backend_plt_readonly 1
5696 #define elf_backend_want_plt_sym 0
5697 #define elf_backend_got_header_size     12
5698 #define elf_backend_rela_normal         1
5699
5700 #include "elf32-target.h"
5701
5702 #undef TARGET_LITTLE_SYM
5703 #define TARGET_LITTLE_SYM          bfin_elf32_fdpic_vec
5704 #undef TARGET_LITTLE_NAME
5705 #define TARGET_LITTLE_NAME              "elf32-bfinfdpic"
5706 #undef  elf32_bed
5707 #define elf32_bed               elf32_bfinfdpic_bed
5708
5709 #undef elf_backend_gc_sweep_hook
5710 #define elf_backend_gc_sweep_hook       bfinfdpic_gc_sweep_hook
5711
5712 #undef elf_backend_got_header_size
5713 #define elf_backend_got_header_size     0
5714
5715 #undef elf_backend_relocate_section
5716 #define elf_backend_relocate_section    bfinfdpic_relocate_section
5717 #undef elf_backend_check_relocs
5718 #define elf_backend_check_relocs        bfinfdpic_check_relocs
5719
5720 #undef bfd_elf32_bfd_link_hash_table_create
5721 #define bfd_elf32_bfd_link_hash_table_create \
5722                 bfinfdpic_elf_link_hash_table_create
5723 #undef elf_backend_always_size_sections
5724 #define elf_backend_always_size_sections \
5725                 elf32_bfinfdpic_always_size_sections
5726
5727 #undef elf_backend_create_dynamic_sections
5728 #define elf_backend_create_dynamic_sections \
5729                 elf32_bfinfdpic_create_dynamic_sections
5730 #undef elf_backend_adjust_dynamic_symbol
5731 #define elf_backend_adjust_dynamic_symbol \
5732                 elf32_bfinfdpic_adjust_dynamic_symbol
5733 #undef elf_backend_size_dynamic_sections
5734 #define elf_backend_size_dynamic_sections \
5735                 elf32_bfinfdpic_size_dynamic_sections
5736 #undef elf_backend_finish_dynamic_symbol
5737 #define elf_backend_finish_dynamic_symbol \
5738                 elf32_bfinfdpic_finish_dynamic_symbol
5739 #undef elf_backend_finish_dynamic_sections
5740 #define elf_backend_finish_dynamic_sections \
5741                 elf32_bfinfdpic_finish_dynamic_sections
5742
5743 #undef elf_backend_discard_info
5744 #define elf_backend_discard_info \
5745                 bfinfdpic_elf_discard_info
5746 #undef elf_backend_can_make_relative_eh_frame
5747 #define elf_backend_can_make_relative_eh_frame \
5748                 bfinfdpic_elf_use_relative_eh_frame
5749 #undef elf_backend_can_make_lsda_relative_eh_frame
5750 #define elf_backend_can_make_lsda_relative_eh_frame \
5751                 bfinfdpic_elf_use_relative_eh_frame
5752 #undef elf_backend_encode_eh_address
5753 #define elf_backend_encode_eh_address \
5754                 bfinfdpic_elf_encode_eh_address
5755
5756 #undef elf_backend_may_use_rel_p
5757 #define elf_backend_may_use_rel_p       1
5758 #undef elf_backend_may_use_rela_p
5759 #define elf_backend_may_use_rela_p      1
5760 /* We use REL for dynamic relocations only.  */
5761 #undef elf_backend_default_use_rela_p
5762 #define elf_backend_default_use_rela_p  1
5763
5764 #undef elf_backend_omit_section_dynsym
5765 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5766
5767 #include "elf32-target.h"