bfd/elf32-bfin.c

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