bfd/elf32-bfin.c

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