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