bfd/elf32-bfin.c

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