bfd/elf32-bfin.c

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