bfd/elf32-bfin.c

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