bfd/elf32-bfin.c

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