bfd/elf32-bfin.c

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