bfd/elf32-bfin.c

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