bfd/elf32-bfin.c

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