bfd/elf32-bfin.c

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