bfd/elf32-bfin.c

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