bfd/elf32-bfin.c

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