bfd/elf32-bfin.c

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