bfd/elf32-bfin.c

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