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   struct bfd_link_hash_entry *bh;
3257   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3258   int ptralign;
3259   int offset;
3260
3261   /* This function may be called more than once.  */
3262   s = bfd_get_section_by_name (abfd, ".got");
3263   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
3264     return TRUE;
3265
3266   /* Machine specific: although pointers are 32-bits wide, we want the
3267      GOT to be aligned to a 64-bit boundary, such that function
3268      descriptors in it can be accessed with 64-bit loads and
3269      stores.  */
3270   ptralign = 3;
3271
3272   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3273            | SEC_LINKER_CREATED);
3274   pltflags = flags;
3275
3276   s = bfd_make_section_with_flags (abfd, ".got", flags);
3277   if (s == NULL
3278       || !bfd_set_section_alignment (abfd, s, ptralign))
3279     return FALSE;
3280
3281   if (bed->want_got_plt)
3282     {
3283       s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
3284       if (s == NULL
3285           || !bfd_set_section_alignment (abfd, s, ptralign))
3286         return FALSE;
3287     }
3288
3289   if (bed->want_got_sym)
3290     {
3291       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3292          (or .got.plt) section.  We don't do this in the linker script
3293          because we don't want to define the symbol if we are not creating
3294          a global offset table.  */
3295       h = _bfd_elf_define_linkage_sym (abfd, info, s, "_GLOBAL_OFFSET_TABLE_");
3296       elf_hash_table (info)->hgot = h;
3297       if (h == NULL)
3298         return FALSE;
3299
3300       /* Machine-specific: we want the symbol for executables as
3301          well.  */
3302       if (! bfd_elf_link_record_dynamic_symbol (info, h))
3303         return FALSE;
3304     }
3305
3306   /* The first bit of the global offset table is the header.  */
3307   s->size += bed->got_header_size;
3308
3309   /* This is the machine-specific part.  Create and initialize section
3310      data for the got.  */
3311   if (IS_FDPIC (abfd))
3312     {
3313       bfinfdpic_got_section (info) = s;
3314       bfinfdpic_relocs_info (info) = htab_try_create (1,
3315                                                       bfinfdpic_relocs_info_hash,
3316                                                       bfinfdpic_relocs_info_eq,
3317                                                       (htab_del) NULL);
3318       if (! bfinfdpic_relocs_info (info))
3319         return FALSE;
3320
3321       s = bfd_make_section_with_flags (abfd, ".rel.got",
3322                                        (flags | SEC_READONLY));
3323       if (s == NULL
3324           || ! bfd_set_section_alignment (abfd, s, 2))
3325         return FALSE;
3326
3327       bfinfdpic_gotrel_section (info) = s;
3328
3329       /* Machine-specific.  */
3330       s = bfd_make_section_with_flags (abfd, ".rofixup",
3331                                        (flags | SEC_READONLY));
3332       if (s == NULL
3333           || ! bfd_set_section_alignment (abfd, s, 2))
3334         return FALSE;
3335
3336       bfinfdpic_gotfixup_section (info) = s;
3337       offset = -2048;
3338       flags = BSF_GLOBAL;
3339     }
3340   else
3341     {
3342       offset = 2048;
3343       flags = BSF_GLOBAL | BSF_WEAK;
3344     }
3345
3346   /* Define _gp in .rofixup, for FDPIC, or .got otherwise.  If it
3347      turns out that we're linking with a different linker script, the
3348      linker script will override it.  */
3349   bh = NULL;
3350   if (!(_bfd_generic_link_add_one_symbol
3351         (info, abfd, "_gp", flags, s, offset, (const char *) NULL, FALSE,
3352          bed->collect, &bh)))
3353     return FALSE;
3354   h = (struct elf_link_hash_entry *) bh;
3355   h->def_regular = 1;
3356   h->type = STT_OBJECT;
3357   /* h->other = STV_HIDDEN; */ /* Should we?  */
3358
3359   /* Machine-specific: we want the symbol for executables as well.  */
3360   if (IS_FDPIC (abfd) && ! bfd_elf_link_record_dynamic_symbol (info, h))
3361     return FALSE;
3362
3363   return TRUE;
3364 }
3365
3366 /* Make sure the got and plt sections exist, and that our pointers in
3367    the link hash table point to them.  */
3368
3369 static bfd_boolean
3370 elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3371 {
3372   /* This is mostly copied from
3373      elflink.c:_bfd_elf_create_dynamic_sections().  */
3374   flagword flags, pltflags;
3375   asection *s;
3376   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3377
3378   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3379      .rel[a].bss sections.  */
3380
3381   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3382            | SEC_LINKER_CREATED);
3383
3384   pltflags = flags;
3385   pltflags |= SEC_CODE;
3386   if (bed->plt_not_loaded)
3387     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3388   if (bed->plt_readonly)
3389     pltflags |= SEC_READONLY;
3390
3391   s = bfd_make_section (abfd, ".plt");
3392   if (s == NULL
3393       || ! bfd_set_section_flags (abfd, s, pltflags)
3394       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3395     return FALSE;
3396   /* Blackfin-specific: remember it.  */
3397   bfinfdpic_plt_section (info) = s;
3398
3399   if (bed->want_plt_sym)
3400     {
3401       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3402          .plt section.  */
3403       struct elf_link_hash_entry *h;
3404       struct bfd_link_hash_entry *bh = NULL;
3405
3406       if (! (_bfd_generic_link_add_one_symbol
3407              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3408               FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3409         return FALSE;
3410       h = (struct elf_link_hash_entry *) bh;
3411       h->def_regular = 1;
3412       h->type = STT_OBJECT;
3413
3414       if (! info->executable
3415           && ! bfd_elf_link_record_dynamic_symbol (info, h))
3416         return FALSE;
3417     }
3418
3419   /* Blackfin-specific: we want rel relocations for the plt.  */
3420   s = bfd_make_section (abfd, ".rel.plt");
3421   if (s == NULL
3422       || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3423       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3424     return FALSE;
3425   /* Blackfin-specific: remember it.  */
3426   bfinfdpic_pltrel_section (info) = s;
3427
3428   /* Blackfin-specific: we want to create the GOT in the Blackfin way.  */
3429   if (! _bfin_create_got_section (abfd, info))
3430     return FALSE;
3431
3432   /* Blackfin-specific: make sure we created everything we wanted.  */
3433   BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3434               /* && bfinfdpic_gotfixup_section (info) */
3435               && bfinfdpic_plt_section (info)
3436               && bfinfdpic_pltrel_section (info));
3437
3438   if (bed->want_dynbss)
3439     {
3440       /* The .dynbss section is a place to put symbols which are defined
3441          by dynamic objects, are referenced by regular objects, and are
3442          not functions.  We must allocate space for them in the process
3443          image and use a R_*_COPY reloc to tell the dynamic linker to
3444          initialize them at run time.  The linker script puts the .dynbss
3445          section into the .bss section of the final image.  */
3446       s = bfd_make_section (abfd, ".dynbss");
3447       if (s == NULL
3448           || ! bfd_set_section_flags (abfd, s, SEC_ALLOC | SEC_LINKER_CREATED))
3449         return FALSE;
3450
3451       /* The .rel[a].bss section holds copy relocs.  This section is not
3452      normally needed.  We need to create it here, though, so that the
3453      linker will map it to an output section.  We can't just create it
3454      only if we need it, because we will not know whether we need it
3455      until we have seen all the input files, and the first time the
3456      main linker code calls BFD after examining all the input files
3457      (size_dynamic_sections) the input sections have already been
3458      mapped to the output sections.  If the section turns out not to
3459      be needed, we can discard it later.  We will never need this
3460      section when generating a shared object, since they do not use
3461      copy relocs.  */
3462       if (! info->shared)
3463         {
3464           s = bfd_make_section (abfd,
3465                                 (bed->default_use_rela_p
3466                                  ? ".rela.bss" : ".rel.bss"));
3467           if (s == NULL
3468               || ! bfd_set_section_flags (abfd, s, flags | SEC_READONLY)
3469               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3470             return FALSE;
3471         }
3472     }
3473
3474   return TRUE;
3475 }
3476
3477 /* The name of the dynamic interpreter.  This is put in the .interp
3478    section.  */
3479
3480 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
3481
3482 #define DEFAULT_STACK_SIZE 0x20000
3483
3484 /* This structure is used to collect the number of entries present in
3485    each addressable range of the got.  */
3486 struct _bfinfdpic_dynamic_got_info
3487 {
3488   /* Several bits of information about the current link.  */
3489   struct bfd_link_info *info;
3490   /* Total size needed for GOT entries within the 18- or 32-bit
3491      ranges.  */
3492   bfd_vma got17m4, gothilo;
3493   /* Total size needed for function descriptor entries within the 18-
3494      or 32-bit ranges.  */
3495   bfd_vma fd17m4, fdhilo;
3496   /* Total size needed function descriptor entries referenced in PLT
3497      entries, that would be profitable to place in offsets close to
3498      the PIC register.  */
3499   bfd_vma fdplt;
3500   /* Total size needed by lazy PLT entries.  */
3501   bfd_vma lzplt;
3502   /* Number of relocations carried over from input object files.  */
3503   unsigned long relocs;
3504   /* Number of fixups introduced by relocations in input object files.  */
3505   unsigned long fixups;
3506 };
3507
3508 /* Compute the total GOT size required by each symbol in each range.
3509    Symbols may require up to 4 words in the GOT: an entry pointing to
3510    the symbol, an entry pointing to its function descriptor, and a
3511    private function descriptors taking two words.  */
3512
3513 static int
3514 _bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3515 {
3516   struct bfinfdpic_relocs_info *entry = *entryp;
3517   struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3518   unsigned relocs = 0, fixups = 0;
3519
3520   /* Allocate space for a GOT entry pointing to the symbol.  */
3521   if (entry->got17m4)
3522     dinfo->got17m4 += 4;
3523   else if (entry->gothilo)
3524     dinfo->gothilo += 4;
3525   else
3526     entry->relocs32--;
3527   entry->relocs32++;
3528
3529   /* Allocate space for a GOT entry pointing to the function
3530      descriptor.  */
3531   if (entry->fdgot17m4)
3532     dinfo->got17m4 += 4;
3533   else if (entry->fdgothilo)
3534     dinfo->gothilo += 4;
3535   else
3536     entry->relocsfd--;
3537   entry->relocsfd++;
3538
3539   /* Decide whether we need a PLT entry, a function descriptor in the
3540      GOT, and a lazy PLT entry for this symbol.  */
3541   entry->plt = entry->call
3542     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3543     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3544   entry->privfd = entry->plt
3545     || entry->fdgoff17m4 || entry->fdgoffhilo
3546     || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3547         && (entry->symndx != -1
3548             || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3549   entry->lazyplt = entry->privfd
3550     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3551     && ! (dinfo->info->flags & DF_BIND_NOW)
3552     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3553
3554   /* Allocate space for a function descriptor.  */
3555   if (entry->fdgoff17m4)
3556     dinfo->fd17m4 += 8;
3557   else if (entry->privfd && entry->plt)
3558     dinfo->fdplt += 8;
3559   else if (entry->privfd)
3560     dinfo->fdhilo += 8;
3561   else
3562     entry->relocsfdv--;
3563   entry->relocsfdv++;
3564
3565   if (entry->lazyplt)
3566     dinfo->lzplt += LZPLT_NORMAL_SIZE;
3567
3568   if (!dinfo->info->executable || dinfo->info->pie)
3569     relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3570   else
3571     {
3572       if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3573         {
3574           if (entry->symndx != -1
3575               || entry->d.h->root.type != bfd_link_hash_undefweak)
3576             fixups += entry->relocs32 + 2 * entry->relocsfdv;
3577         }
3578       else
3579         relocs += entry->relocs32 + entry->relocsfdv;
3580
3581       if (entry->symndx != -1
3582           || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3583         {
3584           if (entry->symndx != -1
3585               || entry->d.h->root.type != bfd_link_hash_undefweak)
3586             fixups += entry->relocsfd;
3587         }
3588       else
3589         relocs += entry->relocsfd;
3590     }
3591
3592   entry->dynrelocs += relocs;
3593   entry->fixups += fixups;
3594   dinfo->relocs += relocs;
3595   dinfo->fixups += fixups;
3596
3597   return 1;
3598 }
3599
3600 /* This structure is used to assign offsets to got entries, function
3601    descriptors, plt entries and lazy plt entries.  */
3602
3603 struct _bfinfdpic_dynamic_got_plt_info
3604 {
3605   /* Summary information collected with _bfinfdpic_count_got_plt_entries.  */
3606   struct _bfinfdpic_dynamic_got_info g;
3607
3608   /* For each addressable range, we record a MAX (positive) and MIN
3609      (negative) value.  CUR is used to assign got entries, and it's
3610      incremented from an initial positive value to MAX, then from MIN
3611      to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
3612      assign function descriptors, and it's decreased from an initial
3613      non-positive value to MIN, then from MAX down to CUR (unless CUR
3614      wraps around first).  All of MIN, MAX, CUR and FDCUR always point
3615      to even words.  ODD, if non-zero, indicates an odd word to be
3616      used for the next got entry, otherwise CUR is used and
3617      incremented by a pair of words, wrapping around when it reaches
3618      MAX.  FDCUR is decremented (and wrapped) before the next function
3619      descriptor is chosen.  FDPLT indicates the number of remaining
3620      slots that can be used for function descriptors used only by PLT
3621      entries.  */
3622   struct _bfinfdpic_dynamic_got_alloc_data
3623   {
3624     bfd_signed_vma max, cur, odd, fdcur, min;
3625     bfd_vma fdplt;
3626   } got17m4, gothilo;
3627 };
3628
3629 /* Determine the positive and negative ranges to be used by each
3630    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
3631    double-word boundary, are the minimum (negative) and maximum
3632    (positive) GOT offsets already used by previous ranges, except for
3633    an ODD entry that may have been left behind.  GOT and FD indicate
3634    the size of GOT entries and function descriptors that must be
3635    placed within the range from -WRAP to WRAP.  If there's room left,
3636    up to FDPLT bytes should be reserved for additional function
3637    descriptors.  */
3638
3639 inline static bfd_signed_vma
3640 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3641                                    bfd_signed_vma fdcur,
3642                                    bfd_signed_vma odd,
3643                                    bfd_signed_vma cur,
3644                                    bfd_vma got,
3645                                    bfd_vma fd,
3646                                    bfd_vma fdplt,
3647                                    bfd_vma wrap)
3648 {
3649   bfd_signed_vma wrapmin = -wrap;
3650
3651   /* Start at the given initial points.  */
3652   gad->fdcur = fdcur;
3653   gad->cur = cur;
3654
3655   /* If we had an incoming odd word and we have any got entries that
3656      are going to use it, consume it, otherwise leave gad->odd at
3657      zero.  We might force gad->odd to zero and return the incoming
3658      odd such that it is used by the next range, but then GOT entries
3659      might appear to be out of order and we wouldn't be able to
3660      shorten the GOT by one word if it turns out to end with an
3661      unpaired GOT entry.  */
3662   if (odd && got)
3663     {
3664       gad->odd = odd;
3665       got -= 4;
3666       odd = 0;
3667     }
3668   else
3669     gad->odd = 0;
3670
3671   /* If we're left with an unpaired GOT entry, compute its location
3672      such that we can return it.  Otherwise, if got doesn't require an
3673      odd number of words here, either odd was already zero in the
3674      block above, or it was set to zero because got was non-zero, or
3675      got was already zero.  In the latter case, we want the value of
3676      odd to carry over to the return statement, so we don't want to
3677      reset odd unless the condition below is true.  */
3678   if (got & 4)
3679     {
3680       odd = cur + got;
3681       got += 4;
3682     }
3683
3684   /* Compute the tentative boundaries of this range.  */
3685   gad->max = cur + got;
3686   gad->min = fdcur - fd;
3687   gad->fdplt = 0;
3688
3689   /* If function descriptors took too much space, wrap some of them
3690      around.  */
3691   if (gad->min < wrapmin)
3692     {
3693       gad->max += wrapmin - gad->min;
3694       gad->min = wrapmin;
3695     }
3696   /* If there is space left and we have function descriptors
3697      referenced in PLT entries that could take advantage of shorter
3698      offsets, place them here.  */
3699   else if (fdplt && gad->min > wrapmin)
3700     {
3701       bfd_vma fds;
3702       if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3703         fds = gad->min - wrapmin;
3704       else
3705         fds = fdplt;
3706
3707       fdplt -= fds;
3708       gad->min -= fds;
3709       gad->fdplt += fds;
3710     }
3711
3712   /* If GOT entries took too much space, wrap some of them around.
3713      This may well cause gad->min to become lower than wrapmin.  This
3714      will cause a relocation overflow later on, so we don't have to
3715      report it here . */
3716   if ((bfd_vma) gad->max > wrap)
3717     {
3718       gad->min -= gad->max - wrap;
3719       gad->max = wrap;
3720     }
3721   /* If there is more space left, try to place some more function
3722      descriptors for PLT entries.  */
3723   else if (fdplt && (bfd_vma) gad->max < wrap)
3724     {
3725       bfd_vma fds;
3726       if ((bfd_vma) (wrap - gad->max) < fdplt)
3727         fds = wrap - gad->max;
3728       else
3729         fds = fdplt;
3730
3731       fdplt -= fds;
3732       gad->max += fds;
3733       gad->fdplt += fds;
3734     }
3735
3736   /* If odd was initially computed as an offset past the wrap point,
3737      wrap it around.  */
3738   if (odd > gad->max)
3739     odd = gad->min + odd - gad->max;
3740
3741   /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3742      before returning, so do it here too.  This guarantees that,
3743      should cur and fdcur meet at the wrap point, they'll both be
3744      equal to min.  */
3745   if (gad->cur == gad->max)
3746     gad->cur = gad->min;
3747
3748   return odd;
3749 }
3750
3751 /* Compute the location of the next GOT entry, given the allocation
3752    data for a range.  */
3753
3754 inline static bfd_signed_vma
3755 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3756 {
3757   bfd_signed_vma ret;
3758
3759   if (gad->odd)
3760     {
3761       /* If there was an odd word left behind, use it.  */
3762       ret = gad->odd;
3763       gad->odd = 0;
3764     }
3765   else
3766     {
3767       /* Otherwise, use the word pointed to by cur, reserve the next
3768          as an odd word, and skip to the next pair of words, possibly
3769          wrapping around.  */
3770       ret = gad->cur;
3771       gad->odd = gad->cur + 4;
3772       gad->cur += 8;
3773       if (gad->cur == gad->max)
3774         gad->cur = gad->min;
3775     }
3776
3777   return ret;
3778 }
3779
3780 /* Compute the location of the next function descriptor entry in the
3781    GOT, given the allocation data for a range.  */
3782
3783 inline static bfd_signed_vma
3784 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3785 {
3786   /* If we're at the bottom, wrap around, and only then allocate the
3787      next pair of words.  */
3788   if (gad->fdcur == gad->min)
3789     gad->fdcur = gad->max;
3790   return gad->fdcur -= 8;
3791 }
3792
3793 /* Assign GOT offsets for every GOT entry and function descriptor.
3794    Doing everything in a single pass is tricky.  */
3795
3796 static int
3797 _bfinfdpic_assign_got_entries (void **entryp, void *info_)
3798 {
3799   struct bfinfdpic_relocs_info *entry = *entryp;
3800   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3801
3802   if (entry->got17m4)
3803     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3804   else if (entry->gothilo)
3805     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3806
3807   if (entry->fdgot17m4)
3808     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3809   else if (entry->fdgothilo)
3810     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3811
3812   if (entry->fdgoff17m4)
3813     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3814   else if (entry->plt && dinfo->got17m4.fdplt)
3815     {
3816       dinfo->got17m4.fdplt -= 8;
3817       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3818     }
3819   else if (entry->plt)
3820     {
3821       dinfo->gothilo.fdplt -= 8;
3822       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3823     }
3824   else if (entry->privfd)
3825     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3826
3827   return 1;
3828 }
3829
3830 /* Assign GOT offsets to private function descriptors used by PLT
3831    entries (or referenced by 32-bit offsets), as well as PLT entries
3832    and lazy PLT entries.  */
3833
3834 static int
3835 _bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3836 {
3837   struct bfinfdpic_relocs_info *entry = *entryp;
3838   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3839
3840   /* If this symbol requires a local function descriptor, allocate
3841      one.  */
3842   if (entry->privfd && entry->fd_entry == 0)
3843     {
3844       if (dinfo->got17m4.fdplt)
3845         {
3846           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3847           dinfo->got17m4.fdplt -= 8;
3848         }
3849       else
3850         {
3851           BFD_ASSERT (dinfo->gothilo.fdplt);
3852           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3853           dinfo->gothilo.fdplt -= 8;
3854         }
3855     }
3856
3857   if (entry->plt)
3858     {
3859       int size;
3860
3861       /* We use the section's raw size to mark the location of the
3862          next PLT entry.  */
3863       entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3864
3865       /* Figure out the length of this PLT entry based on the
3866          addressing mode we need to reach the function descriptor.  */
3867       BFD_ASSERT (entry->fd_entry);
3868       if (entry->fd_entry >= -(1 << (18 - 1))
3869           && entry->fd_entry + 4 < (1 << (18 - 1)))
3870         size = 10;
3871       else
3872         size = 16;
3873
3874       bfinfdpic_plt_section (dinfo->g.info)->size += size;
3875     }
3876
3877   if (entry->lazyplt)
3878     {
3879       entry->lzplt_entry = dinfo->g.lzplt;
3880       dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3881       /* If this entry is the one that gets the resolver stub, account
3882          for the additional instruction.  */
3883       if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3884           == BFINFDPIC_LZPLT_RESOLV_LOC)
3885         dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3886     }
3887
3888   return 1;
3889 }
3890
3891 /* Follow indirect and warning hash entries so that each got entry
3892    points to the final symbol definition.  P must point to a pointer
3893    to the hash table we're traversing.  Since this traversal may
3894    modify the hash table, we set this pointer to NULL to indicate
3895    we've made a potentially-destructive change to the hash table, so
3896    the traversal must be restarted.  */
3897 static int
3898 _bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
3899 {
3900   struct bfinfdpic_relocs_info *entry = *entryp;
3901   htab_t *htab = p;
3902
3903   if (entry->symndx == -1)
3904     {
3905       struct elf_link_hash_entry *h = entry->d.h;
3906       struct bfinfdpic_relocs_info *oentry;
3907
3908       while (h->root.type == bfd_link_hash_indirect
3909              || h->root.type == bfd_link_hash_warning)
3910         h = (struct elf_link_hash_entry *)h->root.u.i.link;
3911
3912       if (entry->d.h == h)
3913         return 1;
3914
3915       oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
3916                                                 NO_INSERT);
3917
3918       if (oentry)
3919         {
3920           /* Merge the two entries.  */
3921           bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
3922           htab_clear_slot (*htab, entryp);
3923           return 1;
3924         }
3925
3926       entry->d.h = h;
3927
3928       /* If we can't find this entry with the new bfd hash, re-insert
3929          it, and get the traversal restarted.  */
3930       if (! htab_find (*htab, entry))
3931         {
3932           htab_clear_slot (*htab, entryp);
3933           entryp = htab_find_slot (*htab, entry, INSERT);
3934           if (! *entryp)
3935             *entryp = entry;
3936           /* Abort the traversal, since the whole table may have
3937              moved, and leave it up to the parent to restart the
3938              process.  */
3939           *(htab_t *)p = NULL;
3940           return 0;
3941         }
3942     }
3943
3944   return 1;
3945 }
3946
3947 /* Set the sizes of the dynamic sections.  */
3948
3949 static bfd_boolean
3950 elf32_bfinfdpic_size_dynamic_sections (bfd *output_bfd,
3951                                       struct bfd_link_info *info)
3952 {
3953   bfd *dynobj;
3954   asection *s;
3955   struct _bfinfdpic_dynamic_got_plt_info gpinfo;
3956   bfd_signed_vma odd;
3957   bfd_vma limit;
3958
3959   dynobj = elf_hash_table (info)->dynobj;
3960   BFD_ASSERT (dynobj != NULL);
3961
3962   if (elf_hash_table (info)->dynamic_sections_created)
3963     {
3964       /* Set the contents of the .interp section to the interpreter.  */
3965       if (info->executable)
3966         {
3967           s = bfd_get_section_by_name (dynobj, ".interp");
3968           BFD_ASSERT (s != NULL);
3969           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3970           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3971         }
3972     }
3973
3974   memset (&gpinfo, 0, sizeof (gpinfo));
3975   gpinfo.g.info = info;
3976
3977   for (;;)
3978     {
3979       htab_t relocs = bfinfdpic_relocs_info (info);
3980
3981       htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
3982
3983       if (relocs == bfinfdpic_relocs_info (info))
3984         break;
3985     }
3986
3987   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
3988                  &gpinfo.g);
3989
3990   odd = 12;
3991   /* Compute the total size taken by entries in the 18-bit range,
3992      to tell how many PLT function descriptors we can bring into it
3993      without causing it to overflow.  */
3994   limit = odd + gpinfo.g.got17m4 + gpinfo.g.fd17m4;
3995   if (limit < (bfd_vma)1 << 18)
3996     limit = ((bfd_vma)1 << 18) - limit;
3997   else
3998     limit = 0;
3999   if (gpinfo.g.fdplt < limit)
4000     limit = gpinfo.g.fdplt;
4001
4002   /* Determine the ranges of GOT offsets that we can use for each
4003      range of addressing modes.  */
4004   odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.got17m4,
4005                                           0,
4006                                           odd,
4007                                           16,
4008                                           gpinfo.g.got17m4,
4009                                           gpinfo.g.fd17m4,
4010                                           limit,
4011                                           (bfd_vma)1 << (18-1));
4012   odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.gothilo,
4013                                           gpinfo.got17m4.min,
4014                                           odd,
4015                                           gpinfo.got17m4.max,
4016                                           gpinfo.g.gothilo,
4017                                           gpinfo.g.fdhilo,
4018                                           gpinfo.g.fdplt - gpinfo.got17m4.fdplt,
4019                                           (bfd_vma)1 << (32-1));
4020
4021   /* Now assign (most) GOT offsets.  */
4022   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
4023                  &gpinfo);
4024
4025   bfinfdpic_got_section (info)->size = gpinfo.gothilo.max
4026     - gpinfo.gothilo.min
4027     /* If an odd word is the last word of the GOT, we don't need this
4028        word to be part of the GOT.  */
4029     - (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
4030   if (bfinfdpic_got_section (info)->size == 0)
4031     bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4032   else if (bfinfdpic_got_section (info)->size == 12
4033            && ! elf_hash_table (info)->dynamic_sections_created)
4034     {
4035       bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
4036       bfinfdpic_got_section (info)->size = 0;
4037     }
4038   else
4039     {
4040       bfinfdpic_got_section (info)->contents =
4041         (bfd_byte *) bfd_zalloc (dynobj,
4042                                  bfinfdpic_got_section (info)->size);
4043       if (bfinfdpic_got_section (info)->contents == NULL)
4044         return FALSE;
4045     }
4046
4047   if (elf_hash_table (info)->dynamic_sections_created)
4048     /* Subtract the number of lzplt entries, since those will generate
4049        relocations in the pltrel section.  */
4050     bfinfdpic_gotrel_section (info)->size =
4051       (gpinfo.g.relocs - gpinfo.g.lzplt / LZPLT_NORMAL_SIZE)
4052       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4053   else
4054     BFD_ASSERT (gpinfo.g.relocs == 0);
4055   if (bfinfdpic_gotrel_section (info)->size == 0)
4056     bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
4057   else
4058     {
4059       bfinfdpic_gotrel_section (info)->contents =
4060         (bfd_byte *) bfd_zalloc (dynobj,
4061                                  bfinfdpic_gotrel_section (info)->size);
4062       if (bfinfdpic_gotrel_section (info)->contents == NULL)
4063         return FALSE;
4064     }
4065
4066   bfinfdpic_gotfixup_section (info)->size = (gpinfo.g.fixups + 1) * 4;
4067   if (bfinfdpic_gotfixup_section (info)->size == 0)
4068     bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
4069   else
4070     {
4071       bfinfdpic_gotfixup_section (info)->contents =
4072         (bfd_byte *) bfd_zalloc (dynobj,
4073                                  bfinfdpic_gotfixup_section (info)->size);
4074       if (bfinfdpic_gotfixup_section (info)->contents == NULL)
4075         return FALSE;
4076     }
4077
4078   if (elf_hash_table (info)->dynamic_sections_created)
4079     {
4080       bfinfdpic_pltrel_section (info)->size =
4081         gpinfo.g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4082       if (bfinfdpic_pltrel_section (info)->size == 0)
4083         bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
4084       else
4085         {
4086           bfinfdpic_pltrel_section (info)->contents =
4087             (bfd_byte *) bfd_zalloc (dynobj,
4088                                      bfinfdpic_pltrel_section (info)->size);
4089           if (bfinfdpic_pltrel_section (info)->contents == NULL)
4090             return FALSE;
4091         }
4092     }
4093
4094   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4095      such that there's room for the additional instruction needed to
4096      call the resolver.  Since _bfinfdpic_assign_got_entries didn't
4097      account for them, our block size is 4 bytes smaller than the real
4098      block size.  */
4099   if (elf_hash_table (info)->dynamic_sections_created)
4100     {
4101       bfinfdpic_plt_section (info)->size = gpinfo.g.lzplt
4102         + ((gpinfo.g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
4103            / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
4104     }
4105
4106   /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4107      actually assign lazy PLT entries addresses.  */
4108   gpinfo.g.lzplt = 0;
4109
4110   /* Save information that we're going to need to generate GOT and PLT
4111      entries.  */
4112   bfinfdpic_got_initial_offset (info) = -gpinfo.gothilo.min;
4113
4114   if (get_elf_backend_data (output_bfd)->want_got_sym)
4115     elf_hash_table (info)->hgot->root.u.def.value
4116       += bfinfdpic_got_initial_offset (info);
4117
4118   if (elf_hash_table (info)->dynamic_sections_created)
4119     bfinfdpic_plt_initial_offset (info) =
4120       bfinfdpic_plt_section (info)->size;
4121
4122   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4123                  &gpinfo);
4124
4125   /* Allocate the PLT section contents only after
4126      _bfinfdpic_assign_plt_entries has a chance to add the size of the
4127      non-lazy PLT entries.  */
4128   if (elf_hash_table (info)->dynamic_sections_created)
4129     {
4130       if (bfinfdpic_plt_section (info)->size == 0)
4131         bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4132       else
4133         {
4134           bfinfdpic_plt_section (info)->contents =
4135             (bfd_byte *) bfd_zalloc (dynobj,
4136                                      bfinfdpic_plt_section (info)->size);
4137           if (bfinfdpic_plt_section (info)->contents == NULL)
4138             return FALSE;
4139         }
4140     }
4141
4142   if (elf_hash_table (info)->dynamic_sections_created)
4143     {
4144       if (bfinfdpic_got_section (info)->size)
4145         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
4146           return FALSE;
4147
4148       if (bfinfdpic_pltrel_section (info)->size)
4149         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4150             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
4151             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4152           return FALSE;
4153
4154       if (bfinfdpic_gotrel_section (info)->size)
4155         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
4156             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
4157             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
4158                                             sizeof (Elf32_External_Rel)))
4159           return FALSE;
4160     }
4161
4162   return TRUE;
4163 }
4164
4165 static bfd_boolean
4166 elf32_bfinfdpic_always_size_sections (bfd *output_bfd,
4167                                      struct bfd_link_info *info)
4168 {
4169   if (!info->relocatable)
4170     {
4171       struct elf_link_hash_entry *h;
4172       asection *sec;
4173
4174       /* Force a PT_GNU_STACK segment to be created.  */
4175       if (! elf_tdata (output_bfd)->stack_flags)
4176         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
4177
4178       /* Define __stacksize if it's not defined yet.  */
4179       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4180                                 FALSE, FALSE, FALSE);
4181       if (! h || h->root.type != bfd_link_hash_defined
4182           || h->type != STT_OBJECT
4183           || !h->def_regular)
4184         {
4185           struct bfd_link_hash_entry *bh = NULL;
4186
4187           if (!(_bfd_generic_link_add_one_symbol
4188                 (info, output_bfd, "__stacksize",
4189                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
4190                  (const char *) NULL, FALSE,
4191                  get_elf_backend_data (output_bfd)->collect, &bh)))
4192             return FALSE;
4193
4194           h = (struct elf_link_hash_entry *) bh;
4195           h->def_regular = 1;
4196           h->type = STT_OBJECT;
4197         }
4198
4199       /* Create a stack section, and set its alignment.  */
4200       sec = bfd_make_section (output_bfd, ".stack");
4201
4202       if (sec == NULL
4203           || ! bfd_set_section_alignment (output_bfd, sec, 3))
4204         return FALSE;
4205     }
4206
4207   return TRUE;
4208 }
4209
4210 static bfd_boolean
4211 elf32_bfinfdpic_modify_segment_map (bfd *output_bfd,
4212                                    struct bfd_link_info *info)
4213 {
4214   struct elf_segment_map *m;
4215
4216   /* objcopy and strip preserve what's already there using
4217      elf32_bfinfdpic_copy_private_bfd_data ().  */
4218   if (! info)
4219     return TRUE;
4220
4221   for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
4222     if (m->p_type == PT_GNU_STACK)
4223       break;
4224
4225   if (m)
4226     {
4227       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
4228       struct elf_link_hash_entry *h;
4229
4230       if (sec)
4231         {
4232           /* Obtain the pointer to the __stacksize symbol.  */
4233           h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4234                                     FALSE, FALSE, FALSE);
4235           while (h->root.type == bfd_link_hash_indirect
4236                  || h->root.type == bfd_link_hash_warning)
4237             h = (struct elf_link_hash_entry *)h->root.u.i.link;
4238           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
4239
4240           /* Set the section size from the symbol value.  We
4241              intentionally ignore the symbol section.  */
4242           if (h->root.type == bfd_link_hash_defined)
4243             sec->size = h->root.u.def.value;
4244           else
4245             sec->size = DEFAULT_STACK_SIZE;
4246
4247           /* Add the stack section to the PT_GNU_STACK segment,
4248              such that its size and alignment requirements make it
4249              to the segment.  */
4250           m->sections[m->count] = sec;
4251           m->count++;
4252         }
4253     }
4254
4255   return TRUE;
4256 }
4257
4258 static bfd_boolean
4259 elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4260                                         struct bfd_link_info *info)
4261 {
4262   bfd *dynobj;
4263   asection *sdyn;
4264
4265   dynobj = elf_hash_table (info)->dynobj;
4266
4267   if (bfinfdpic_got_section (info))
4268     {
4269       BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4270                   == (bfinfdpic_gotrel_section (info)->reloc_count
4271                       * sizeof (Elf32_External_Rel)));
4272
4273       if (bfinfdpic_gotfixup_section (info))
4274         {
4275           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4276           bfd_vma got_value = hgot->root.u.def.value
4277             + hgot->root.u.def.section->output_section->vma
4278             + hgot->root.u.def.section->output_offset;
4279
4280           _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4281                                  got_value, 0);
4282
4283           if (bfinfdpic_gotfixup_section (info)->size
4284               != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4285             {
4286               (*_bfd_error_handler)
4287                 ("LINKER BUG: .rofixup section size mismatch");
4288               return FALSE;
4289             }
4290         }
4291     }
4292   if (elf_hash_table (info)->dynamic_sections_created)
4293     {
4294       BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4295                   == (bfinfdpic_pltrel_section (info)->reloc_count
4296                       * sizeof (Elf32_External_Rel)));
4297     }
4298
4299   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4300
4301   if (elf_hash_table (info)->dynamic_sections_created)
4302     {
4303       Elf32_External_Dyn * dyncon;
4304       Elf32_External_Dyn * dynconend;
4305
4306       BFD_ASSERT (sdyn != NULL);
4307
4308       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4309       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4310
4311       for (; dyncon < dynconend; dyncon++)
4312         {
4313           Elf_Internal_Dyn dyn;
4314
4315           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4316
4317           switch (dyn.d_tag)
4318             {
4319             default:
4320               break;
4321
4322             case DT_PLTGOT:
4323               dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4324                 + bfinfdpic_got_section (info)->output_offset
4325                 + bfinfdpic_got_initial_offset (info);
4326               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4327               break;
4328
4329             case DT_JMPREL:
4330               dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4331                 ->output_section->vma
4332                 + bfinfdpic_pltrel_section (info)->output_offset;
4333               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4334               break;
4335
4336             case DT_PLTRELSZ:
4337               dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4338               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4339               break;
4340             }
4341         }
4342     }
4343
4344   return TRUE;
4345 }
4346
4347 /* Adjust a symbol defined by a dynamic object and referenced by a
4348    regular object.  */
4349
4350 static bfd_boolean
4351 elf32_bfinfdpic_adjust_dynamic_symbol
4352 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4353  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4354 {
4355   bfd * dynobj;
4356
4357   dynobj = elf_hash_table (info)->dynobj;
4358
4359   /* Make sure we know what is going on here.  */
4360   BFD_ASSERT (dynobj != NULL
4361               && (h->u.weakdef != NULL
4362                   || (h->def_dynamic
4363                       && h->ref_regular
4364                       && !h->def_regular)));
4365
4366   /* If this is a weak symbol, and there is a real definition, the
4367      processor independent code will have arranged for us to see the
4368      real definition first, and we can just use the same value.  */
4369   if (h->u.weakdef != NULL)
4370     {
4371       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4372                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4373       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4374       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4375     }
4376
4377   return TRUE;
4378 }
4379
4380 /* Perform any actions needed for dynamic symbols.  */
4381
4382 static bfd_boolean
4383 elf32_bfinfdpic_finish_dynamic_symbol
4384 (bfd *output_bfd ATTRIBUTE_UNUSED,
4385  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4386  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4387  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4388 {
4389   return TRUE;
4390 }
4391
4392 /* Decide whether to attempt to turn absptr or lsda encodings in
4393    shared libraries into pcrel within the given input section.  */
4394
4395 static bfd_boolean
4396 bfinfdpic_elf_use_relative_eh_frame
4397 (bfd *input_bfd ATTRIBUTE_UNUSED,
4398  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4399  asection *eh_frame_section ATTRIBUTE_UNUSED)
4400 {
4401   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
4402   return FALSE;
4403 }
4404
4405 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
4406
4407 static bfd_byte
4408 bfinfdpic_elf_encode_eh_address (bfd *abfd,
4409                                 struct bfd_link_info *info,
4410                                 asection *osec, bfd_vma offset,
4411                                 asection *loc_sec, bfd_vma loc_offset,
4412                                 bfd_vma *encoded)
4413 {
4414   struct elf_link_hash_entry *h;
4415
4416   h = elf_hash_table (info)->hgot;
4417   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4418
4419   if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4420               == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4421     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4422                                        loc_sec, loc_offset, encoded);
4423
4424   BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4425               == (_bfinfdpic_osec_to_segment
4426                   (abfd, h->root.u.def.section->output_section)));
4427
4428   *encoded = osec->vma + offset
4429     - (h->root.u.def.value
4430        + h->root.u.def.section->output_section->vma
4431        + h->root.u.def.section->output_offset);
4432
4433   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4434 }
4435
4436
4437
4438 /* Look through the relocs for a section during the first phase.
4439
4440    Besides handling virtual table relocs for gc, we have to deal with
4441    all sorts of PIC-related relocations.  We describe below the
4442    general plan on how to handle such relocations, even though we only
4443    collect information at this point, storing them in hash tables for
4444    perusal of later passes.
4445
4446    32 relocations are propagated to the linker output when creating
4447    position-independent output.  LO16 and HI16 relocations are not
4448    supposed to be encountered in this case.
4449
4450    LABEL16 should always be resolvable by the linker, since it's only
4451    used by branches.
4452
4453    LABEL24, on the other hand, is used by calls.  If it turns out that
4454    the target of a call is a dynamic symbol, a PLT entry must be
4455    created for it, which triggers the creation of a private function
4456    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4457
4458    GPREL relocations require the referenced symbol to be in the same
4459    segment as _gp, but this can only be checked later.
4460
4461    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4462    exist.  LABEL24 might as well, since it may require a PLT entry,
4463    that will require a got.
4464
4465    Non-FUNCDESC GOT relocations require a GOT entry to be created
4466    regardless of whether the symbol is dynamic.  However, since a
4467    global symbol that turns out to not be exported may have the same
4468    address of a non-dynamic symbol, we don't assign GOT entries at
4469    this point, such that we can share them in this case.  A relocation
4470    for the GOT entry always has to be created, be it to offset a
4471    private symbol by the section load address, be it to get the symbol
4472    resolved dynamically.
4473
4474    FUNCDESC GOT relocations require a GOT entry to be created, and
4475    handled as if a FUNCDESC relocation was applied to the GOT entry in
4476    an object file.
4477
4478    FUNCDESC relocations referencing a symbol that turns out to NOT be
4479    dynamic cause a private function descriptor to be created.  The
4480    FUNCDESC relocation then decays to a 32 relocation that points at
4481    the private descriptor.  If the symbol is dynamic, the FUNCDESC
4482    relocation is propagated to the linker output, such that the
4483    dynamic linker creates the canonical descriptor, pointing to the
4484    dynamically-resolved definition of the function.
4485
4486    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4487    symbols that are assigned to the same segment as the GOT, but we
4488    can only check this later, after we know the complete set of
4489    symbols defined and/or exported.
4490
4491    FUNCDESC GOTOFF relocations require a function descriptor to be
4492    created and, unless lazy binding is disabled or the symbol is not
4493    dynamic, a lazy PLT entry.  Since we can't tell at this point
4494    whether a symbol is going to be dynamic, we have to decide later
4495    whether to create a lazy PLT entry or bind the descriptor directly
4496    to the private function.
4497
4498    FUNCDESC_VALUE relocations are not supposed to be present in object
4499    files, but they may very well be simply propagated to the linker
4500    output, since they have no side effect.
4501
4502
4503    A function descriptor always requires a FUNCDESC_VALUE relocation.
4504    Whether it's in .plt.rel or not depends on whether lazy binding is
4505    enabled and on whether the referenced symbol is dynamic.
4506
4507    The existence of a lazy PLT requires the resolverStub lazy PLT
4508    entry to be present.
4509
4510
4511    As for assignment of GOT, PLT and lazy PLT entries, and private
4512    descriptors, we might do them all sequentially, but we can do
4513    better than that.  For example, we can place GOT entries and
4514    private function descriptors referenced using 12-bit operands
4515    closer to the PIC register value, such that these relocations don't
4516    overflow.  Those that are only referenced with LO16 relocations
4517    could come next, but we may as well place PLT-required function
4518    descriptors in the 12-bit range to make them shorter.  Symbols
4519    referenced with LO16/HI16 may come next, but we may place
4520    additional function descriptors in the 16-bit range if we can
4521    reliably tell that we've already placed entries that are ever
4522    referenced with only LO16.  PLT entries are therefore generated as
4523    small as possible, while not introducing relocation overflows in
4524    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
4525    generated before or after PLT entries, but not intermingled with
4526    them, such that we can have more lazy PLT entries in range for a
4527    branch to the resolverStub.  The resolverStub should be emitted at
4528    the most distant location from the first lazy PLT entry such that
4529    it's still in range for a branch, or closer, if there isn't a need
4530    for so many lazy PLT entries.  Additional lazy PLT entries may be
4531    emitted after the resolverStub, as long as branches are still in
4532    range.  If the branch goes out of range, longer lazy PLT entries
4533    are emitted.
4534
4535    We could further optimize PLT and lazy PLT entries by giving them
4536    priority in assignment to closer-to-gr17 locations depending on the
4537    number of occurrences of references to them (assuming a function
4538    that's called more often is more important for performance, so its
4539    PLT entry should be faster), or taking hints from the compiler.
4540    Given infinite time and money... :-)  */
4541
4542 static bfd_boolean
4543 bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4544                         asection *sec, const Elf_Internal_Rela *relocs)
4545 {
4546   Elf_Internal_Shdr *symtab_hdr;
4547   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4548   const Elf_Internal_Rela *rel;
4549   const Elf_Internal_Rela *rel_end;
4550   bfd *dynobj;
4551   struct bfinfdpic_relocs_info *picrel;
4552
4553   if (info->relocatable)
4554     return TRUE;
4555
4556   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4557   sym_hashes = elf_sym_hashes (abfd);
4558   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4559   if (!elf_bad_symtab (abfd))
4560     sym_hashes_end -= symtab_hdr->sh_info;
4561
4562   dynobj = elf_hash_table (info)->dynobj;
4563   rel_end = relocs + sec->reloc_count;
4564   for (rel = relocs; rel < rel_end; rel++)
4565     {
4566       struct elf_link_hash_entry *h;
4567       unsigned long r_symndx;
4568
4569       r_symndx = ELF32_R_SYM (rel->r_info);
4570       if (r_symndx < symtab_hdr->sh_info)
4571         h = NULL;
4572       else
4573         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4574
4575       switch (ELF32_R_TYPE (rel->r_info))
4576         {
4577         case R_BFIN_GOT17M4:
4578         case R_BFIN_GOTHI:
4579         case R_BFIN_GOTLO:
4580         case R_BFIN_FUNCDESC_GOT17M4:
4581         case R_BFIN_FUNCDESC_GOTHI:
4582         case R_BFIN_FUNCDESC_GOTLO:
4583         case R_BFIN_GOTOFF17M4:
4584         case R_BFIN_GOTOFFHI:
4585         case R_BFIN_GOTOFFLO:
4586         case R_BFIN_FUNCDESC_GOTOFF17M4:
4587         case R_BFIN_FUNCDESC_GOTOFFHI:
4588         case R_BFIN_FUNCDESC_GOTOFFLO:
4589         case R_BFIN_FUNCDESC:
4590         case R_BFIN_FUNCDESC_VALUE:
4591           if (! IS_FDPIC (abfd))
4592             goto bad_reloc;
4593           /* Fall through.  */
4594         case R_pcrel24:
4595         case R_pcrel24_jump_l:
4596         case R_byte4_data:
4597           if (IS_FDPIC (abfd) && ! dynobj)
4598             {
4599               elf_hash_table (info)->dynobj = dynobj = abfd;
4600               if (! _bfin_create_got_section (abfd, info))
4601                 return FALSE;
4602             }
4603           if (! IS_FDPIC (abfd))
4604             {
4605               picrel = NULL;
4606               break;
4607             }
4608           if (h != NULL)
4609             {
4610               if (h->dynindx == -1)
4611                 switch (ELF_ST_VISIBILITY (h->other))
4612                   {
4613                   case STV_INTERNAL:
4614                   case STV_HIDDEN:
4615                     break;
4616                   default:
4617                     bfd_elf_link_record_dynamic_symbol (info, h);
4618                     break;
4619                   }
4620               picrel
4621                 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4622                                                    abfd, h,
4623                                                    rel->r_addend, INSERT);
4624             }
4625           else
4626             picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4627                                                      (info), abfd, r_symndx,
4628                                                      rel->r_addend, INSERT);
4629           if (! picrel)
4630             return FALSE;
4631           break;
4632
4633         default:
4634           picrel = NULL;
4635           break;
4636         }
4637
4638       switch (ELF32_R_TYPE (rel->r_info))
4639         {
4640         case R_pcrel24:
4641         case R_pcrel24_jump_l:
4642           if (IS_FDPIC (abfd))
4643             picrel->call = 1;
4644           break;
4645
4646         case R_BFIN_FUNCDESC_VALUE:
4647           picrel->relocsfdv++;
4648           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4649             picrel->relocs32--;
4650           /* Fall through.  */
4651
4652         case R_byte4_data:
4653           if (! IS_FDPIC (abfd))
4654             break;
4655
4656           picrel->sym = 1;
4657           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4658             picrel->relocs32++;
4659           break;
4660
4661         case R_BFIN_GOT17M4:
4662           picrel->got17m4 = 1;
4663           break;
4664
4665         case R_BFIN_GOTHI:
4666         case R_BFIN_GOTLO:
4667           picrel->gothilo = 1;
4668           break;
4669
4670         case R_BFIN_FUNCDESC_GOT17M4:
4671           picrel->fdgot17m4 = 1;
4672           break;
4673
4674         case R_BFIN_FUNCDESC_GOTHI:
4675         case R_BFIN_FUNCDESC_GOTLO:
4676           picrel->fdgothilo = 1;
4677           break;
4678
4679         case R_BFIN_GOTOFF17M4:
4680         case R_BFIN_GOTOFFHI:
4681         case R_BFIN_GOTOFFLO:
4682           picrel->gotoff = 1;
4683           break;
4684
4685         case R_BFIN_FUNCDESC_GOTOFF17M4:
4686           picrel->fdgoff17m4 = 1;
4687           break;
4688
4689         case R_BFIN_FUNCDESC_GOTOFFHI:
4690         case R_BFIN_FUNCDESC_GOTOFFLO:
4691           picrel->fdgoffhilo = 1;
4692           break;
4693
4694         case R_BFIN_FUNCDESC:
4695           picrel->fd = 1;
4696           picrel->relocsfd++;
4697           break;
4698
4699         /* This relocation describes the C++ object vtable hierarchy.
4700            Reconstruct it for later use during GC.  */
4701         case R_BFIN_GNU_VTINHERIT:
4702           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4703             return FALSE;
4704           break;
4705
4706         /* This relocation describes which C++ vtable entries are actually
4707            used.  Record for later use during GC.  */
4708         case R_BFIN_GNU_VTENTRY:
4709           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4710             return FALSE;
4711           break;
4712
4713         case R_huimm16:
4714         case R_luimm16:
4715         case R_pcrel12_jump_s:
4716         case R_pcrel10:
4717           break;
4718
4719         default:
4720         bad_reloc:
4721           (*_bfd_error_handler)
4722             (_("%B: unsupported relocation type %i"),
4723              abfd, ELF32_R_TYPE (rel->r_info));
4724           return FALSE;
4725         }
4726     }
4727
4728   return TRUE;
4729 }
4730
4731 /* Set the right machine number for a Blackfin ELF file.  */
4732
4733 static bfd_boolean
4734 elf32_bfin_object_p (bfd *abfd)
4735 {
4736   bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4737   return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4738           == (IS_FDPIC (abfd)));
4739 }
4740
4741 static bfd_boolean
4742 elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4743 {
4744   elf_elfheader (abfd)->e_flags = flags;
4745   elf_flags_init (abfd) = TRUE;
4746   return TRUE;
4747 }
4748
4749 /* Copy backend specific data from one object module to another.  */
4750
4751 static bfd_boolean
4752 bfin_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4753 {
4754   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4755       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4756     return TRUE;
4757
4758   BFD_ASSERT (!elf_flags_init (obfd)
4759               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
4760
4761   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4762   elf_flags_init (obfd) = TRUE;
4763   return TRUE;
4764 }
4765
4766 static bfd_boolean
4767 elf32_bfinfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4768 {
4769   unsigned i;
4770
4771   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4772       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4773     return TRUE;
4774
4775   if (! bfin_elf_copy_private_bfd_data (ibfd, obfd))
4776     return FALSE;
4777
4778   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
4779       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
4780     return TRUE;
4781
4782   /* Copy the stack size.  */
4783   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
4784     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
4785       {
4786         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
4787
4788         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
4789           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
4790             {
4791               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
4792
4793               /* Rewrite the phdrs, since we're only called after they
4794                  were first written.  */
4795               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
4796                             ->s->sizeof_ehdr, SEEK_SET) != 0
4797                   || get_elf_backend_data (obfd)->s
4798                   ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
4799                                      elf_elfheader (obfd)->e_phnum) != 0)
4800                 return FALSE;
4801               break;
4802             }
4803
4804         break;
4805       }
4806
4807   return TRUE;
4808 }
4809
4810
4811 /* Display the flags field.  */
4812 static bfd_boolean
4813 elf32_bfin_print_private_bfd_data (bfd * abfd, PTR ptr)
4814 {
4815   FILE *file = (FILE *) ptr;
4816   flagword flags;
4817
4818   BFD_ASSERT (abfd != NULL && ptr != NULL);
4819
4820   /* Print normal ELF private data.  */
4821   _bfd_elf_print_private_bfd_data (abfd, ptr);
4822
4823   flags = elf_elfheader (abfd)->e_flags;
4824
4825   /* xgettext:c-format */
4826   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4827
4828   if (flags & EF_BFIN_PIC)
4829     fprintf (file, " -fpic");
4830
4831   if (flags & EF_BFIN_FDPIC)
4832     fprintf (file, " -mfdpic");
4833
4834   fputc ('\n', file);
4835
4836   return TRUE;
4837 }
4838
4839 /* Merge backend specific data from an object file to the output
4840    object file when linking.  */
4841
4842 static bfd_boolean
4843 elf32_bfin_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4844 {
4845   flagword old_flags, old_partial;
4846   flagword new_flags, new_partial;
4847   bfd_boolean error = FALSE;
4848
4849   new_flags = elf_elfheader (ibfd)->e_flags;
4850   old_flags = elf_elfheader (obfd)->e_flags;
4851
4852   if (new_flags & EF_BFIN_FDPIC)
4853     new_flags &= ~EF_BFIN_PIC;
4854
4855 #ifdef DEBUG
4856   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4857                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4858                          bfd_get_filename (ibfd));
4859 #endif
4860
4861   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
4862     {
4863       elf_flags_init (obfd) = TRUE;
4864       old_flags = new_flags;
4865     }
4866
4867   else if (new_flags == old_flags)              /* Compatible flags are ok.  */
4868     ;
4869
4870   else                                          /* Possibly incompatible flags.  */
4871     {
4872       /* We don't have to do anything if the pic flags are the same, or the new
4873          module(s) were compiled with -mlibrary-pic.  */
4874       new_partial = (new_flags & EF_BFIN_PIC_FLAGS);
4875       old_partial = (old_flags & EF_BFIN_PIC_FLAGS);
4876       if (new_partial == old_partial)
4877         ;
4878
4879       /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
4880       else if (new_partial != 0 && old_partial != 0)
4881         old_flags |= new_partial;
4882
4883       /* One module was compiled for pic and the other was not, see if we have
4884          had any relocations that are not pic-safe.  */
4885       else
4886         old_flags |= new_partial;
4887
4888     }
4889
4890   /* Update the old flags now with changes made above.  */
4891   elf_elfheader (obfd)->e_flags = old_flags;
4892
4893   if (((new_flags & EF_BFIN_FDPIC) == 0)
4894       != (! IS_FDPIC (ibfd)))
4895     {
4896       error = TRUE;
4897       if (IS_FDPIC (obfd))
4898         (*_bfd_error_handler)
4899           (_("%s: cannot link non-fdpic object file into fdpic executable"),
4900            bfd_get_filename (ibfd));
4901       else
4902         (*_bfd_error_handler)
4903           (_("%s: cannot link fdpic object file into non-fdpic executable"),
4904            bfd_get_filename (ibfd));
4905     }
4906
4907   if (error)
4908     bfd_set_error (bfd_error_bad_value);
4909
4910   return !error;
4911 }
4912 \f
4913 /* bfin ELF linker hash entry.  */
4914
4915 struct bfin_link_hash_entry
4916 {
4917   struct elf_link_hash_entry root;
4918
4919   /* Number of PC relative relocs copied for this symbol.  */
4920   struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
4921 };
4922
4923 /* bfin ELF linker hash table.  */
4924
4925 struct bfin_link_hash_table
4926 {
4927   struct elf_link_hash_table root;
4928
4929   /* Small local sym to section mapping cache.  */
4930   struct sym_sec_cache sym_sec;
4931 };
4932
4933 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4934
4935 static struct bfd_hash_entry *
4936 bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
4937                         struct bfd_hash_table *table, const char *string)
4938 {
4939   struct bfd_hash_entry *ret = entry;
4940
4941   /* Allocate the structure if it has not already been allocated by a
4942      subclass.  */
4943   if (ret == NULL)
4944     ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
4945   if (ret == NULL)
4946     return ret;
4947
4948   /* Call the allocation method of the superclass.  */
4949   ret = _bfd_elf_link_hash_newfunc (ret, table, string);
4950   if (ret != NULL)
4951     bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
4952
4953   return ret;
4954 }
4955
4956 /* Create an bfin ELF linker hash table.  */
4957
4958 static struct bfd_link_hash_table *
4959 bfin_link_hash_table_create (bfd * abfd)
4960 {
4961   struct bfin_link_hash_table *ret;
4962   bfd_size_type amt = sizeof (struct bfin_link_hash_table);
4963
4964   ret = bfd_zalloc (abfd, amt);
4965   if (ret == NULL)
4966     return NULL;
4967
4968   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4969                                       bfin_link_hash_newfunc,
4970                                       sizeof (struct elf_link_hash_entry)))
4971     {
4972       free (ret);
4973       return NULL;
4974     }
4975
4976   ret->sym_sec.abfd = NULL;
4977
4978   return &ret->root.root;
4979 }
4980
4981 /* The size in bytes of an entry in the procedure linkage table.  */
4982
4983 /* Finish up the dynamic sections.  */
4984
4985 static bfd_boolean
4986 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4987                                   struct bfd_link_info *info)
4988 {
4989   bfd *dynobj;
4990   asection *sdyn;
4991
4992   dynobj = elf_hash_table (info)->dynobj;
4993
4994   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4995
4996   if (elf_hash_table (info)->dynamic_sections_created)
4997     {
4998       Elf32_External_Dyn *dyncon, *dynconend;
4999
5000       BFD_ASSERT (sdyn != NULL);
5001
5002       dyncon = (Elf32_External_Dyn *) sdyn->contents;
5003       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
5004       for (; dyncon < dynconend; dyncon++)
5005         {
5006           Elf_Internal_Dyn dyn;
5007
5008           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
5009
5010         }
5011
5012     }
5013   return TRUE;
5014 }
5015
5016 /* Finish up dynamic symbol handling.  We set the contents of various
5017    dynamic sections here.  */
5018
5019 static bfd_boolean
5020 bfin_finish_dynamic_symbol (bfd * output_bfd,
5021                                 struct bfd_link_info *info,
5022                                 struct elf_link_hash_entry *h,
5023                                 Elf_Internal_Sym * sym)
5024 {
5025   bfd *dynobj;
5026
5027   dynobj = elf_hash_table (info)->dynobj;
5028
5029   if (h->got.offset != (bfd_vma) - 1)
5030     {
5031       asection *sgot;
5032       asection *srela;
5033       Elf_Internal_Rela rela;
5034       bfd_byte *loc;
5035
5036       /* This symbol has an entry in the global offset table.
5037          Set it up.  */
5038
5039       sgot = bfd_get_section_by_name (dynobj, ".got");
5040       srela = bfd_get_section_by_name (dynobj, ".rela.got");
5041       BFD_ASSERT (sgot != NULL && srela != NULL);
5042
5043       rela.r_offset = (sgot->output_section->vma
5044                        + sgot->output_offset
5045                        + (h->got.offset & ~(bfd_vma) 1));
5046
5047       /* If this is a -Bsymbolic link, and the symbol is defined
5048          locally, we just want to emit a RELATIVE reloc.  Likewise if
5049          the symbol was forced to be local because of a version file.
5050          The entry in the global offset table will already have been
5051          initialized in the relocate_section function.  */
5052       if (info->shared
5053           && (info->symbolic
5054               || h->dynindx == -1 || h->forced_local) && h->def_regular)
5055         {
5056 fprintf(stderr, "*** check this relocation %s\n", __FUNCTION__);
5057           rela.r_info = ELF32_R_INFO (0, R_pcrel24);
5058           rela.r_addend = bfd_get_signed_32 (output_bfd,
5059                                              (sgot->contents
5060                                               +
5061                                               (h->got.
5062                                                offset & ~(bfd_vma) 1)));
5063         }
5064       else
5065         {
5066           bfd_put_32 (output_bfd, (bfd_vma) 0,
5067                       sgot->contents + (h->got.offset & ~(bfd_vma) 1));
5068           rela.r_info = ELF32_R_INFO (h->dynindx, R_got);
5069           rela.r_addend = 0;
5070         }
5071
5072       loc = srela->contents;
5073       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5074       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5075     }
5076
5077   if (h->needs_copy)
5078     {
5079       BFD_ASSERT (0);
5080     }
5081   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5082   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
5083       || h == elf_hash_table (info)->hgot)
5084     sym->st_shndx = SHN_ABS;
5085
5086   return TRUE;
5087 }
5088
5089 /* Adjust a symbol defined by a dynamic object and referenced by a
5090    regular object.  The current definition is in some section of the
5091    dynamic object, but we're not including those sections.  We have to
5092    change the definition to something the rest of the link can
5093    understand.  */
5094
5095 static bfd_boolean
5096 bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
5097                                 struct elf_link_hash_entry *h)
5098 {
5099   bfd *dynobj;
5100   asection *s;
5101   unsigned int power_of_two;
5102
5103   dynobj = elf_hash_table (info)->dynobj;
5104
5105   /* Make sure we know what is going on here.  */
5106   BFD_ASSERT (dynobj != NULL
5107               && (h->needs_plt
5108                   || h->u.weakdef != NULL
5109                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
5110
5111   /* If this is a function, put it in the procedure linkage table.  We
5112      will fill in the contents of the procedure linkage table later,
5113      when we know the address of the .got section.  */
5114   if (h->type == STT_FUNC || h->needs_plt)
5115     {
5116       BFD_ASSERT(0);
5117     }
5118
5119   /* If this is a weak symbol, and there is a real definition, the
5120      processor independent code will have arranged for us to see the
5121      real definition first, and we can just use the same value.  */
5122   if (h->u.weakdef != NULL)
5123     {
5124       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5125                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5126       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5127       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5128       return TRUE;
5129     }
5130
5131   /* This is a reference to a symbol defined by a dynamic object which
5132      is not a function.  */
5133
5134   /* If we are creating a shared library, we must presume that the
5135      only references to the symbol are via the global offset table.
5136      For such cases we need not do anything here; the relocations will
5137      be handled correctly by relocate_section.  */
5138   if (info->shared)
5139     return TRUE;
5140
5141   /* We must allocate the symbol in our .dynbss section, which will
5142      become part of the .bss section of the executable.  There will be
5143      an entry for this symbol in the .dynsym section.  The dynamic
5144      object will contain position independent code, so all references
5145      from the dynamic object to this symbol will go through the global
5146      offset table.  The dynamic linker will use the .dynsym entry to
5147      determine the address it must put in the global offset table, so
5148      both the dynamic object and the regular object will refer to the
5149      same memory location for the variable.  */
5150
5151   s = bfd_get_section_by_name (dynobj, ".dynbss");
5152   BFD_ASSERT (s != NULL);
5153
5154   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
5155      copy the initial value out of the dynamic object and into the
5156      runtime process image.  We need to remember the offset into the
5157      .rela.bss section we are going to use.  */
5158   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5159     {
5160       asection *srel;
5161
5162       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
5163       BFD_ASSERT (srel != NULL);
5164       srel->size += sizeof (Elf32_External_Rela);
5165       h->needs_copy = 1;
5166     }
5167
5168   /* We need to figure out the alignment required for this symbol.  I
5169      have no idea how ELF linkers handle this.  */
5170   power_of_two = bfd_log2 (h->size);
5171   if (power_of_two > 3)
5172     power_of_two = 3;
5173
5174   /* Apply the required alignment.  */
5175   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5176   if (power_of_two > bfd_get_section_alignment (dynobj, s))
5177     {
5178       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
5179         return FALSE;
5180     }
5181
5182   /* Define the symbol as being at this point in the section.  */
5183   h->root.u.def.section = s;
5184   h->root.u.def.value = s->size;
5185
5186   /* Increment the section size to make room for the symbol.  */
5187   s->size += h->size;
5188
5189   return TRUE;
5190 }
5191
5192 /* The bfin linker needs to keep track of the number of relocs that it
5193    decides to copy in check_relocs for each symbol.  This is so that it
5194    can discard PC relative relocs if it doesn't need them when linking
5195    with -Bsymbolic.  We store the information in a field extending the
5196    regular ELF linker hash table.  */
5197
5198 /* This structure keeps track of the number of PC relative relocs we have
5199    copied for a given symbol.  */
5200
5201 struct bfin_pcrel_relocs_copied
5202 {
5203   /* Next section.  */
5204   struct bfin_pcrel_relocs_copied *next;
5205   /* A section in dynobj.  */
5206   asection *section;
5207   /* Number of relocs copied in this section.  */
5208   bfd_size_type count;
5209 };
5210
5211 /* This function is called via elf_link_hash_traverse if we are
5212    creating a shared object.  In the -Bsymbolic case it discards the
5213    space allocated to copy PC relative relocs against symbols which
5214    are defined in regular objects.  For the normal shared case, it
5215    discards space for pc-relative relocs that have become local due to
5216    symbol visibility changes.  We allocated space for them in the
5217    check_relocs routine, but we won't fill them in in the
5218    relocate_section routine.
5219
5220    We also check whether any of the remaining relocations apply
5221    against a readonly section, and set the DF_TEXTREL flag in this
5222    case.  */
5223
5224 static bfd_boolean
5225 bfin_discard_copies (struct elf_link_hash_entry *h, PTR inf)
5226 {
5227   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5228   struct bfin_pcrel_relocs_copied *s;
5229
5230   if (h->root.type == bfd_link_hash_warning)
5231     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5232
5233   if (!h->def_regular || (!info->symbolic && !h->forced_local))
5234     {
5235       if ((info->flags & DF_TEXTREL) == 0)
5236         {
5237           /* Look for relocations against read-only sections.  */
5238           for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5239                s != NULL; s = s->next)
5240             if ((s->section->flags & SEC_READONLY) != 0)
5241               {
5242                 info->flags |= DF_TEXTREL;
5243                 break;
5244               }
5245         }
5246
5247       return TRUE;
5248     }
5249
5250   for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5251        s != NULL; s = s->next)
5252     s->section->size -= s->count * sizeof (Elf32_External_Rela);
5253
5254   return TRUE;
5255 }
5256
5257 static bfd_boolean
5258 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5259                                 struct bfd_link_info *info)
5260 {
5261   bfd *dynobj;
5262   asection *s;
5263   bfd_boolean relocs;
5264
5265   dynobj = elf_hash_table (info)->dynobj;
5266   BFD_ASSERT (dynobj != NULL);
5267
5268   if (elf_hash_table (info)->dynamic_sections_created)
5269     {
5270       /* Set the contents of the .interp section to the interpreter.  */
5271       if (info->executable)
5272         {
5273           s = bfd_get_section_by_name (dynobj, ".interp");
5274           BFD_ASSERT (s != NULL);
5275           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5276           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5277         }
5278     }
5279   else
5280     {
5281       /* We may have created entries in the .rela.got section.
5282          However, if we are not creating the dynamic sections, we will
5283          not actually use these entries.  Reset the size of .rela.got,
5284          which will cause it to get stripped from the output file
5285          below.  */
5286       s = bfd_get_section_by_name (dynobj, ".rela.got");
5287       if (s != NULL)
5288         s->size = 0;
5289     }
5290
5291   /* If this is a -Bsymbolic shared link, then we need to discard all
5292      PC relative relocs against symbols defined in a regular object.
5293      For the normal shared case we discard the PC relative relocs
5294      against symbols that have become local due to visibility changes.
5295      We allocated space for them in the check_relocs routine, but we
5296      will not fill them in in the relocate_section routine.  */
5297   if (info->shared)
5298     elf_link_hash_traverse (elf_hash_table (info),
5299                             bfin_discard_copies, (PTR) info);
5300
5301   /* The check_relocs and adjust_dynamic_symbol entry points have
5302      determined the sizes of the various dynamic sections.  Allocate
5303      memory for them.  */
5304   relocs = FALSE;
5305   for (s = dynobj->sections; s != NULL; s = s->next)
5306     {
5307       const char *name;
5308       bfd_boolean strip;
5309
5310       if ((s->flags & SEC_LINKER_CREATED) == 0)
5311         continue;
5312
5313       /* It's OK to base decisions on the section name, because none
5314          of the dynobj section names depend upon the input files.  */
5315       name = bfd_get_section_name (dynobj, s);
5316
5317       strip = FALSE;
5318
5319        if (strncmp (name, ".rela", 5) == 0)
5320         {
5321           if (s->size == 0)
5322             {
5323               /* If we don't need this section, strip it from the
5324                  output file.  This is mostly to handle .rela.bss and
5325                  .rela.plt.  We must create both sections in
5326                  create_dynamic_sections, because they must be created
5327                  before the linker maps input sections to output
5328                  sections.  The linker does that before
5329                  adjust_dynamic_symbol is called, and it is that
5330                  function which decides whether anything needs to go
5331                  into these sections.  */
5332               strip = TRUE;
5333             }
5334           else
5335             {
5336               relocs = TRUE;
5337
5338               /* We use the reloc_count field as a counter if we need
5339                  to copy relocs into the output file.  */
5340               s->reloc_count = 0;
5341             }
5342         }
5343       else if (strncmp (name, ".got", 4) != 0)
5344         {
5345           /* It's not one of our sections, so don't allocate space.  */
5346           continue;
5347         }
5348
5349       if (strip)
5350         {
5351           s->flags |= SEC_EXCLUDE;
5352           continue;
5353         }
5354
5355       /* Allocate memory for the section contents.  */
5356       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5357          Unused entries should be reclaimed before the section's contents
5358          are written out, but at the moment this does not happen.  Thus in
5359          order to prevent writing out garbage, we initialise the section's
5360          contents to zero.  */
5361       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5362       if (s->contents == NULL && s->size != 0)
5363         return FALSE;
5364     }
5365
5366   if (elf_hash_table (info)->dynamic_sections_created)
5367     {
5368       /* Add some entries to the .dynamic section.  We fill in the
5369          values later, in bfin_finish_dynamic_sections, but we
5370          must add the entries now so that we get the correct size for
5371          the .dynamic section.  The DT_DEBUG entry is filled in by the
5372          dynamic linker and used by the debugger.  */
5373 #define add_dynamic_entry(TAG, VAL) \
5374   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5375
5376       if (!info->shared)
5377         {
5378           if (!add_dynamic_entry (DT_DEBUG, 0))
5379             return FALSE;
5380         }
5381
5382
5383       if (relocs)
5384         {
5385           if (!add_dynamic_entry (DT_RELA, 0)
5386               || !add_dynamic_entry (DT_RELASZ, 0)
5387               || !add_dynamic_entry (DT_RELAENT,
5388                                      sizeof (Elf32_External_Rela)))
5389             return FALSE;
5390         }
5391
5392       if ((info->flags & DF_TEXTREL) != 0)
5393         {
5394           if (!add_dynamic_entry (DT_TEXTREL, 0))
5395             return FALSE;
5396         }
5397     }
5398 #undef add_dynamic_entry
5399
5400   return TRUE;
5401 }
5402 \f
5403 /* Given a .data section and a .emreloc in-memory section, store
5404    relocation information into the .emreloc section which can be
5405    used at runtime to relocate the section.  This is called by the
5406    linker when the --embedded-relocs switch is used.  This is called
5407    after the add_symbols entry point has been called for all the
5408    objects, and before the final_link entry point is called.  */
5409
5410 bfd_boolean bfd_bfin_elf32_create_embedded_relocs
5411   PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *, char **));
5412
5413 bfd_boolean
5414 bfd_bfin_elf32_create_embedded_relocs (
5415      bfd *abfd,
5416      struct bfd_link_info *info,
5417      asection *datasec,
5418      asection *relsec,
5419      char **errmsg)
5420 {
5421   Elf_Internal_Shdr *symtab_hdr;
5422   Elf_Internal_Sym *isymbuf = NULL;
5423   Elf_Internal_Rela *internal_relocs = NULL;
5424   Elf_Internal_Rela *irel, *irelend;
5425   bfd_byte *p;
5426   bfd_size_type amt;
5427
5428   BFD_ASSERT (! info->relocatable);
5429
5430   *errmsg = NULL;
5431
5432   if (datasec->reloc_count == 0)
5433     return TRUE;
5434
5435   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5436
5437   /* Get a copy of the native relocations.  */
5438   internal_relocs = (_bfd_elf_link_read_relocs
5439                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
5440                       info->keep_memory));
5441   if (internal_relocs == NULL)
5442     goto error_return;
5443
5444   amt = (bfd_size_type) datasec->reloc_count * 12;
5445   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5446   if (relsec->contents == NULL)
5447     goto error_return;
5448
5449   p = relsec->contents;
5450
5451   irelend = internal_relocs + datasec->reloc_count;
5452   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5453     {
5454       asection *targetsec;
5455
5456       /* We are going to write a four byte longword into the runtime
5457        reloc section.  The longword will be the address in the data
5458        section which must be relocated.  It is followed by the name
5459        of the target section NUL-padded or truncated to 8
5460        characters.  */
5461
5462       /* We can only relocate absolute longword relocs at run time.  */
5463       if (ELF32_R_TYPE (irel->r_info) != (int) R_byte4_data)
5464         {
5465           *errmsg = _("unsupported reloc type");
5466           bfd_set_error (bfd_error_bad_value);
5467           goto error_return;
5468         }
5469
5470       /* Get the target section referred to by the reloc.  */
5471       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5472         {
5473           /* A local symbol.  */
5474           Elf_Internal_Sym *isym;
5475
5476           /* Read this BFD's local symbols if we haven't done so already.  */
5477           if (isymbuf == NULL)
5478             {
5479               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5480               if (isymbuf == NULL)
5481                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5482                                                 symtab_hdr->sh_info, 0,
5483                                                 NULL, NULL, NULL);
5484               if (isymbuf == NULL)
5485                 goto error_return;
5486             }
5487
5488           isym = isymbuf + ELF32_R_SYM (irel->r_info);
5489           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5490         }
5491       else
5492         {
5493           unsigned long indx;
5494           struct elf_link_hash_entry *h;
5495
5496           /* An external symbol.  */
5497           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5498           h = elf_sym_hashes (abfd)[indx];
5499           BFD_ASSERT (h != NULL);
5500           if (h->root.type == bfd_link_hash_defined
5501               || h->root.type == bfd_link_hash_defweak)
5502             targetsec = h->root.u.def.section;
5503           else
5504             targetsec = NULL;
5505         }
5506
5507       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5508       memset (p + 4, 0, 8);
5509       if (targetsec != NULL)
5510         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5511     }
5512
5513   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5514     free (isymbuf);
5515   if (internal_relocs != NULL
5516       && elf_section_data (datasec)->relocs != internal_relocs)
5517     free (internal_relocs);
5518   return TRUE;
5519
5520 error_return:
5521   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5522     free (isymbuf);
5523   if (internal_relocs != NULL
5524       && elf_section_data (datasec)->relocs != internal_relocs)
5525     free (internal_relocs);
5526   return FALSE;
5527 }
5528 \f
5529 #define TARGET_LITTLE_SYM               bfd_elf32_bfin_vec
5530 #define TARGET_LITTLE_NAME              "elf32-bfin"
5531 #define ELF_ARCH                        bfd_arch_bfin
5532 #define ELF_MACHINE_CODE                EM_BLACKFIN
5533 #define ELF_MAXPAGESIZE                 0x1000
5534 #define elf_symbol_leading_char         '_'
5535
5536 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5537 #define elf_info_to_howto               bfin_info_to_howto
5538 #define elf_info_to_howto_rel           0
5539 #define elf_backend_object_p            elf32_bfin_object_p
5540
5541 #define bfd_elf32_bfd_is_local_label_name \
5542                                         bfin_is_local_label_name
5543 #define bfin_hash_table(p) \
5544   ((struct bfin_link_hash_table *) (p)->hash)
5545
5546
5547
5548 #define elf_backend_create_dynamic_sections \
5549                                         _bfd_elf_create_dynamic_sections
5550 #define bfd_elf32_bfd_link_hash_table_create \
5551                                         bfin_link_hash_table_create
5552 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
5553
5554 #define elf_backend_check_relocs        bfin_check_relocs
5555 #define elf_backend_adjust_dynamic_symbol \
5556                                         bfin_adjust_dynamic_symbol
5557 #define elf_backend_size_dynamic_sections \
5558                                         bfin_size_dynamic_sections
5559 #define elf_backend_relocate_section    bfin_relocate_section
5560 #define elf_backend_finish_dynamic_symbol \
5561                                         bfin_finish_dynamic_symbol
5562 #define elf_backend_finish_dynamic_sections \
5563                                         bfin_finish_dynamic_sections
5564 #define elf_backend_gc_mark_hook        bfin_gc_mark_hook
5565 #define elf_backend_gc_sweep_hook       bfin_gc_sweep_hook
5566 #define bfd_elf32_bfd_merge_private_bfd_data \
5567                                         elf32_bfin_merge_private_bfd_data
5568 #define bfd_elf32_bfd_set_private_flags \
5569                                         elf32_bfin_set_private_flags
5570 #define bfd_elf32_bfd_print_private_bfd_data \
5571                                         elf32_bfin_print_private_bfd_data
5572 #define elf_backend_reloc_type_class    elf32_bfin_reloc_type_class
5573 #define elf_backend_can_gc_sections 1
5574 #define elf_backend_can_refcount 1
5575 #define elf_backend_want_got_plt 0
5576 #define elf_backend_plt_readonly 1
5577 #define elf_backend_want_plt_sym 0
5578 #define elf_backend_got_header_size     12
5579 #define elf_backend_rela_normal         1
5580
5581 #include "elf32-target.h"
5582
5583 #undef TARGET_LITTLE_SYM
5584 #define TARGET_LITTLE_SYM          bfd_elf32_bfinfdpic_vec
5585 #undef TARGET_LITTLE_NAME
5586 #define TARGET_LITTLE_NAME              "elf32-bfinfdpic"
5587 #undef  elf32_bed
5588 #define elf32_bed               elf32_bfinfdpic_bed
5589
5590 #undef elf_backend_gc_sweep_hook
5591 #define elf_backend_gc_sweep_hook       bfinfdpic_gc_sweep_hook
5592
5593 #undef elf_backend_got_header_size
5594 #define elf_backend_got_header_size     0
5595
5596 #undef elf_backend_relocate_section
5597 #define elf_backend_relocate_section    bfinfdpic_relocate_section
5598 #undef elf_backend_check_relocs
5599 #define elf_backend_check_relocs        bfinfdpic_check_relocs
5600
5601 #undef bfd_elf32_bfd_link_hash_table_create
5602 #define bfd_elf32_bfd_link_hash_table_create \
5603                 bfinfdpic_elf_link_hash_table_create
5604 #undef elf_backend_always_size_sections
5605 #define elf_backend_always_size_sections \
5606                 elf32_bfinfdpic_always_size_sections
5607 #undef elf_backend_modify_segment_map
5608 #define elf_backend_modify_segment_map \
5609                 elf32_bfinfdpic_modify_segment_map
5610 #undef bfd_elf32_bfd_copy_private_bfd_data
5611 #define bfd_elf32_bfd_copy_private_bfd_data \
5612                 elf32_bfinfdpic_copy_private_bfd_data
5613
5614 #undef elf_backend_create_dynamic_sections
5615 #define elf_backend_create_dynamic_sections \
5616                 elf32_bfinfdpic_create_dynamic_sections
5617 #undef elf_backend_adjust_dynamic_symbol
5618 #define elf_backend_adjust_dynamic_symbol \
5619                 elf32_bfinfdpic_adjust_dynamic_symbol
5620 #undef elf_backend_size_dynamic_sections
5621 #define elf_backend_size_dynamic_sections \
5622                 elf32_bfinfdpic_size_dynamic_sections
5623 #undef elf_backend_finish_dynamic_symbol
5624 #define elf_backend_finish_dynamic_symbol \
5625                 elf32_bfinfdpic_finish_dynamic_symbol
5626 #undef elf_backend_finish_dynamic_sections
5627 #define elf_backend_finish_dynamic_sections \
5628                 elf32_bfinfdpic_finish_dynamic_sections
5629
5630 #undef elf_backend_can_make_relative_eh_frame
5631 #define elf_backend_can_make_relative_eh_frame \
5632                 bfinfdpic_elf_use_relative_eh_frame
5633 #undef elf_backend_can_make_lsda_relative_eh_frame
5634 #define elf_backend_can_make_lsda_relative_eh_frame \
5635                 bfinfdpic_elf_use_relative_eh_frame
5636 #undef elf_backend_encode_eh_address
5637 #define elf_backend_encode_eh_address \
5638                 bfinfdpic_elf_encode_eh_address
5639
5640 #undef elf_backend_may_use_rel_p
5641 #define elf_backend_may_use_rel_p       1
5642 #undef elf_backend_may_use_rela_p
5643 #define elf_backend_may_use_rela_p      1
5644 /* We use REL for dynamic relocations only.  */
5645 #undef elf_backend_default_use_rela_p
5646 #define elf_backend_default_use_rela_p  1
5647
5648 #undef elf_backend_omit_section_dynsym
5649 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5650
5651 #include "elf32-target.h"