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,
3110                    Elf_Internal_Rela * rel,
3111                    struct elf_link_hash_entry *h,
3112                    Elf_Internal_Sym * sym)
3113 {
3114   if (h != NULL)
3115     switch (ELF32_R_TYPE (rel->r_info))
3116       {
3117       case R_BFIN_GNU_VTINHERIT:
3118       case R_BFIN_GNU_VTENTRY:
3119         return NULL;
3120       }
3121
3122   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
3123 }
3124
3125 /* Update the got entry reference counts for the section being removed.  */
3126
3127 static bfd_boolean
3128 bfin_gc_sweep_hook (bfd * abfd,
3129                     struct bfd_link_info *info,
3130                     asection * sec,
3131                     const Elf_Internal_Rela * relocs)
3132 {
3133   Elf_Internal_Shdr *symtab_hdr;
3134   struct elf_link_hash_entry **sym_hashes;
3135   bfd_signed_vma *local_got_refcounts;
3136   const Elf_Internal_Rela *rel, *relend;
3137   bfd *dynobj;
3138   asection *sgot;
3139   asection *srelgot;
3140
3141   dynobj = elf_hash_table (info)->dynobj;
3142   if (dynobj == NULL)
3143     return TRUE;
3144
3145   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3146   sym_hashes = elf_sym_hashes (abfd);
3147   local_got_refcounts = elf_local_got_refcounts (abfd);
3148
3149   sgot = bfd_get_section_by_name (dynobj, ".got");
3150   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3151
3152   relend = relocs + sec->reloc_count;
3153   for (rel = relocs; rel < relend; rel++)
3154     {
3155       unsigned long r_symndx;
3156       struct elf_link_hash_entry *h;
3157
3158       switch (ELF32_R_TYPE (rel->r_info))
3159         {
3160         case R_got:
3161           r_symndx = ELF32_R_SYM (rel->r_info);
3162           if (r_symndx >= symtab_hdr->sh_info)
3163             {
3164               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3165               if (h->got.refcount > 0)
3166                 {
3167                   --h->got.refcount;
3168                   if (h->got.refcount == 0)
3169                     {
3170                       /* We don't need the .got entry any more.  */
3171                       sgot->size -= 4;
3172                       srelgot->size -= sizeof (Elf32_External_Rela);
3173                     }
3174                 }
3175             }
3176           else if (local_got_refcounts != NULL)
3177             {
3178               if (local_got_refcounts[r_symndx] > 0)
3179                 {
3180                   --local_got_refcounts[r_symndx];
3181                   if (local_got_refcounts[r_symndx] == 0)
3182                     {
3183                       /* We don't need the .got entry any more.  */
3184                       sgot->size -= 4;
3185                       if (info->shared)
3186                         srelgot->size -= sizeof (Elf32_External_Rela);
3187                     }
3188                 }
3189             }
3190           break;
3191         default:
3192           break;
3193         }
3194     }
3195   return TRUE;
3196 }
3197
3198 /* We need dynamic symbols for every section, since segments can
3199    relocate independently.  */
3200 static bfd_boolean
3201 _bfinfdpic_link_omit_section_dynsym (bfd *output_bfd ATTRIBUTE_UNUSED,
3202                                     struct bfd_link_info *info
3203                                     ATTRIBUTE_UNUSED,
3204                                     asection *p ATTRIBUTE_UNUSED)
3205 {
3206   switch (elf_section_data (p)->this_hdr.sh_type)
3207     {
3208     case SHT_PROGBITS:
3209     case SHT_NOBITS:
3210       /* If sh_type is yet undecided, assume it could be
3211          SHT_PROGBITS/SHT_NOBITS.  */
3212     case SHT_NULL:
3213       return FALSE;
3214
3215       /* There shouldn't be section relative relocations
3216          against any other section.  */
3217     default:
3218       return TRUE;
3219     }
3220 }
3221
3222 /* Create  a .got section, as well as its additional info field.  This
3223    is almost entirely copied from
3224    elflink.c:_bfd_elf_create_got_section().  */
3225
3226 static bfd_boolean
3227 _bfin_create_got_section (bfd *abfd, struct bfd_link_info *info)
3228 {
3229   flagword flags, pltflags;
3230   asection *s;
3231   struct elf_link_hash_entry *h;
3232   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3233   int ptralign;
3234   int offset;
3235
3236   /* This function may be called more than once.  */
3237   s = bfd_get_section_by_name (abfd, ".got");
3238   if (s != NULL && (s->flags & SEC_LINKER_CREATED) != 0)
3239     return TRUE;
3240
3241   /* Machine specific: although pointers are 32-bits wide, we want the
3242      GOT to be aligned to a 64-bit boundary, such that function
3243      descriptors in it can be accessed with 64-bit loads and
3244      stores.  */
3245   ptralign = 3;
3246
3247   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3248            | SEC_LINKER_CREATED);
3249   pltflags = flags;
3250
3251   s = bfd_make_section_with_flags (abfd, ".got", flags);
3252   if (s == NULL
3253       || !bfd_set_section_alignment (abfd, s, ptralign))
3254     return FALSE;
3255
3256   if (bed->want_got_plt)
3257     {
3258       s = bfd_make_section_with_flags (abfd, ".got.plt", flags);
3259       if (s == NULL
3260           || !bfd_set_section_alignment (abfd, s, ptralign))
3261         return FALSE;
3262     }
3263
3264   if (bed->want_got_sym)
3265     {
3266       /* Define the symbol _GLOBAL_OFFSET_TABLE_ at the start of the .got
3267          (or .got.plt) section.  We don't do this in the linker script
3268          because we don't want to define the symbol if we are not creating
3269          a global offset table.  */
3270       h = _bfd_elf_define_linkage_sym (abfd, info, s, "__GLOBAL_OFFSET_TABLE_");
3271       elf_hash_table (info)->hgot = h;
3272       if (h == NULL)
3273         return FALSE;
3274
3275       /* Machine-specific: we want the symbol for executables as
3276          well.  */
3277       if (! bfd_elf_link_record_dynamic_symbol (info, h))
3278         return FALSE;
3279     }
3280
3281   /* The first bit of the global offset table is the header.  */
3282   s->size += bed->got_header_size;
3283
3284   /* This is the machine-specific part.  Create and initialize section
3285      data for the got.  */
3286   if (IS_FDPIC (abfd))
3287     {
3288       bfinfdpic_got_section (info) = s;
3289       bfinfdpic_relocs_info (info) = htab_try_create (1,
3290                                                       bfinfdpic_relocs_info_hash,
3291                                                       bfinfdpic_relocs_info_eq,
3292                                                       (htab_del) NULL);
3293       if (! bfinfdpic_relocs_info (info))
3294         return FALSE;
3295
3296       s = bfd_make_section_with_flags (abfd, ".rel.got",
3297                                        (flags | SEC_READONLY));
3298       if (s == NULL
3299           || ! bfd_set_section_alignment (abfd, s, 2))
3300         return FALSE;
3301
3302       bfinfdpic_gotrel_section (info) = s;
3303
3304       /* Machine-specific.  */
3305       s = bfd_make_section_with_flags (abfd, ".rofixup",
3306                                        (flags | SEC_READONLY));
3307       if (s == NULL
3308           || ! bfd_set_section_alignment (abfd, s, 2))
3309         return FALSE;
3310
3311       bfinfdpic_gotfixup_section (info) = s;
3312       offset = -2048;
3313       flags = BSF_GLOBAL;
3314     }
3315   else
3316     {
3317       offset = 2048;
3318       flags = BSF_GLOBAL | BSF_WEAK;
3319     }
3320
3321   return TRUE;
3322 }
3323
3324 /* Make sure the got and plt sections exist, and that our pointers in
3325    the link hash table point to them.  */
3326
3327 static bfd_boolean
3328 elf32_bfinfdpic_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
3329 {
3330   /* This is mostly copied from
3331      elflink.c:_bfd_elf_create_dynamic_sections().  */
3332   flagword flags, pltflags;
3333   asection *s;
3334   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
3335
3336   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
3337      .rel[a].bss sections.  */
3338
3339   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
3340            | SEC_LINKER_CREATED);
3341
3342   pltflags = flags;
3343   pltflags |= SEC_CODE;
3344   if (bed->plt_not_loaded)
3345     pltflags &= ~ (SEC_CODE | SEC_LOAD | SEC_HAS_CONTENTS);
3346   if (bed->plt_readonly)
3347     pltflags |= SEC_READONLY;
3348
3349   s = bfd_make_section_with_flags (abfd, ".plt", pltflags);
3350   if (s == NULL
3351       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
3352     return FALSE;
3353   /* Blackfin-specific: remember it.  */
3354   bfinfdpic_plt_section (info) = s;
3355
3356   if (bed->want_plt_sym)
3357     {
3358       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
3359          .plt section.  */
3360       struct elf_link_hash_entry *h;
3361       struct bfd_link_hash_entry *bh = NULL;
3362
3363       if (! (_bfd_generic_link_add_one_symbol
3364              (info, abfd, "__PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s, 0, NULL,
3365               FALSE, get_elf_backend_data (abfd)->collect, &bh)))
3366         return FALSE;
3367       h = (struct elf_link_hash_entry *) bh;
3368       h->def_regular = 1;
3369       h->type = STT_OBJECT;
3370
3371       if (! info->executable
3372           && ! bfd_elf_link_record_dynamic_symbol (info, h))
3373         return FALSE;
3374     }
3375
3376   /* Blackfin-specific: we want rel relocations for the plt.  */
3377   s = bfd_make_section_with_flags (abfd, ".rel.plt", flags | SEC_READONLY);
3378   if (s == NULL
3379       || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3380     return FALSE;
3381   /* Blackfin-specific: remember it.  */
3382   bfinfdpic_pltrel_section (info) = s;
3383
3384   /* Blackfin-specific: we want to create the GOT in the Blackfin way.  */
3385   if (! _bfin_create_got_section (abfd, info))
3386     return FALSE;
3387
3388   /* Blackfin-specific: make sure we created everything we wanted.  */
3389   BFD_ASSERT (bfinfdpic_got_section (info) && bfinfdpic_gotrel_section (info)
3390               /* && bfinfdpic_gotfixup_section (info) */
3391               && bfinfdpic_plt_section (info)
3392               && bfinfdpic_pltrel_section (info));
3393
3394   if (bed->want_dynbss)
3395     {
3396       /* The .dynbss section is a place to put symbols which are defined
3397          by dynamic objects, are referenced by regular objects, and are
3398          not functions.  We must allocate space for them in the process
3399          image and use a R_*_COPY reloc to tell the dynamic linker to
3400          initialize them at run time.  The linker script puts the .dynbss
3401          section into the .bss section of the final image.  */
3402       s = bfd_make_section_with_flags (abfd, ".dynbss",
3403                                        SEC_ALLOC | SEC_LINKER_CREATED);
3404       if (s == NULL)
3405         return FALSE;
3406
3407       /* The .rel[a].bss section holds copy relocs.  This section is not
3408      normally needed.  We need to create it here, though, so that the
3409      linker will map it to an output section.  We can't just create it
3410      only if we need it, because we will not know whether we need it
3411      until we have seen all the input files, and the first time the
3412      main linker code calls BFD after examining all the input files
3413      (size_dynamic_sections) the input sections have already been
3414      mapped to the output sections.  If the section turns out not to
3415      be needed, we can discard it later.  We will never need this
3416      section when generating a shared object, since they do not use
3417      copy relocs.  */
3418       if (! info->shared)
3419         {
3420           s = bfd_make_section_with_flags (abfd,
3421                                            (bed->default_use_rela_p
3422                                             ? ".rela.bss" : ".rel.bss"),
3423                                            flags | SEC_READONLY);
3424           if (s == NULL
3425               || ! bfd_set_section_alignment (abfd, s, bed->s->log_file_align))
3426             return FALSE;
3427         }
3428     }
3429
3430   return TRUE;
3431 }
3432
3433 /* The name of the dynamic interpreter.  This is put in the .interp
3434    section.  */
3435
3436 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
3437
3438 #define DEFAULT_STACK_SIZE 0x20000
3439
3440 /* This structure is used to collect the number of entries present in
3441    each addressable range of the got.  */
3442 struct _bfinfdpic_dynamic_got_info
3443 {
3444   /* Several bits of information about the current link.  */
3445   struct bfd_link_info *info;
3446   /* Total size needed for GOT entries within the 18- or 32-bit
3447      ranges.  */
3448   bfd_vma got17m4, gothilo;
3449   /* Total size needed for function descriptor entries within the 18-
3450      or 32-bit ranges.  */
3451   bfd_vma fd17m4, fdhilo;
3452   /* Total size needed function descriptor entries referenced in PLT
3453      entries, that would be profitable to place in offsets close to
3454      the PIC register.  */
3455   bfd_vma fdplt;
3456   /* Total size needed by lazy PLT entries.  */
3457   bfd_vma lzplt;
3458   /* Number of relocations carried over from input object files.  */
3459   unsigned long relocs;
3460   /* Number of fixups introduced by relocations in input object files.  */
3461   unsigned long fixups;
3462 };
3463
3464 /* Compute the total GOT size required by each symbol in each range.
3465    Symbols may require up to 4 words in the GOT: an entry pointing to
3466    the symbol, an entry pointing to its function descriptor, and a
3467    private function descriptors taking two words.  */
3468
3469 static int
3470 _bfinfdpic_count_got_plt_entries (void **entryp, void *dinfo_)
3471 {
3472   struct bfinfdpic_relocs_info *entry = *entryp;
3473   struct _bfinfdpic_dynamic_got_info *dinfo = dinfo_;
3474   unsigned relocs = 0, fixups = 0;
3475
3476   /* Allocate space for a GOT entry pointing to the symbol.  */
3477   if (entry->got17m4)
3478     dinfo->got17m4 += 4;
3479   else if (entry->gothilo)
3480     dinfo->gothilo += 4;
3481   else
3482     entry->relocs32--;
3483   entry->relocs32++;
3484
3485   /* Allocate space for a GOT entry pointing to the function
3486      descriptor.  */
3487   if (entry->fdgot17m4)
3488     dinfo->got17m4 += 4;
3489   else if (entry->fdgothilo)
3490     dinfo->gothilo += 4;
3491   else
3492     entry->relocsfd--;
3493   entry->relocsfd++;
3494
3495   /* Decide whether we need a PLT entry, a function descriptor in the
3496      GOT, and a lazy PLT entry for this symbol.  */
3497   entry->plt = entry->call
3498     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3499     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3500   entry->privfd = entry->plt
3501     || entry->fdgoff17m4 || entry->fdgoffhilo
3502     || ((entry->fd || entry->fdgot17m4 || entry->fdgothilo)
3503         && (entry->symndx != -1
3504             || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h)));
3505   entry->lazyplt = entry->privfd
3506     && entry->symndx == -1 && ! BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h)
3507     && ! (dinfo->info->flags & DF_BIND_NOW)
3508     && elf_hash_table (dinfo->info)->dynamic_sections_created;
3509
3510   /* Allocate space for a function descriptor.  */
3511   if (entry->fdgoff17m4)
3512     dinfo->fd17m4 += 8;
3513   else if (entry->privfd && entry->plt)
3514     dinfo->fdplt += 8;
3515   else if (entry->privfd)
3516     dinfo->fdhilo += 8;
3517   else
3518     entry->relocsfdv--;
3519   entry->relocsfdv++;
3520
3521   if (entry->lazyplt)
3522     dinfo->lzplt += LZPLT_NORMAL_SIZE;
3523
3524   if (!dinfo->info->executable || dinfo->info->pie)
3525     relocs = entry->relocs32 + entry->relocsfd + entry->relocsfdv;
3526   else
3527     {
3528       if (entry->symndx != -1 || BFINFDPIC_SYM_LOCAL (dinfo->info, entry->d.h))
3529         {
3530           if (entry->symndx != -1
3531               || entry->d.h->root.type != bfd_link_hash_undefweak)
3532             fixups += entry->relocs32 + 2 * entry->relocsfdv;
3533         }
3534       else
3535         relocs += entry->relocs32 + entry->relocsfdv;
3536
3537       if (entry->symndx != -1
3538           || BFINFDPIC_FUNCDESC_LOCAL (dinfo->info, entry->d.h))
3539         {
3540           if (entry->symndx != -1
3541               || entry->d.h->root.type != bfd_link_hash_undefweak)
3542             fixups += entry->relocsfd;
3543         }
3544       else
3545         relocs += entry->relocsfd;
3546     }
3547
3548   entry->dynrelocs += relocs;
3549   entry->fixups += fixups;
3550   dinfo->relocs += relocs;
3551   dinfo->fixups += fixups;
3552
3553   return 1;
3554 }
3555
3556 /* This structure is used to assign offsets to got entries, function
3557    descriptors, plt entries and lazy plt entries.  */
3558
3559 struct _bfinfdpic_dynamic_got_plt_info
3560 {
3561   /* Summary information collected with _bfinfdpic_count_got_plt_entries.  */
3562   struct _bfinfdpic_dynamic_got_info g;
3563
3564   /* For each addressable range, we record a MAX (positive) and MIN
3565      (negative) value.  CUR is used to assign got entries, and it's
3566      incremented from an initial positive value to MAX, then from MIN
3567      to FDCUR (unless FDCUR wraps around first).  FDCUR is used to
3568      assign function descriptors, and it's decreased from an initial
3569      non-positive value to MIN, then from MAX down to CUR (unless CUR
3570      wraps around first).  All of MIN, MAX, CUR and FDCUR always point
3571      to even words.  ODD, if non-zero, indicates an odd word to be
3572      used for the next got entry, otherwise CUR is used and
3573      incremented by a pair of words, wrapping around when it reaches
3574      MAX.  FDCUR is decremented (and wrapped) before the next function
3575      descriptor is chosen.  FDPLT indicates the number of remaining
3576      slots that can be used for function descriptors used only by PLT
3577      entries.  */
3578   struct _bfinfdpic_dynamic_got_alloc_data
3579   {
3580     bfd_signed_vma max, cur, odd, fdcur, min;
3581     bfd_vma fdplt;
3582   } got17m4, gothilo;
3583 };
3584
3585 /* Determine the positive and negative ranges to be used by each
3586    offset range in the GOT.  FDCUR and CUR, that must be aligned to a
3587    double-word boundary, are the minimum (negative) and maximum
3588    (positive) GOT offsets already used by previous ranges, except for
3589    an ODD entry that may have been left behind.  GOT and FD indicate
3590    the size of GOT entries and function descriptors that must be
3591    placed within the range from -WRAP to WRAP.  If there's room left,
3592    up to FDPLT bytes should be reserved for additional function
3593    descriptors.  */
3594
3595 inline static bfd_signed_vma
3596 _bfinfdpic_compute_got_alloc_data (struct _bfinfdpic_dynamic_got_alloc_data *gad,
3597                                    bfd_signed_vma fdcur,
3598                                    bfd_signed_vma odd,
3599                                    bfd_signed_vma cur,
3600                                    bfd_vma got,
3601                                    bfd_vma fd,
3602                                    bfd_vma fdplt,
3603                                    bfd_vma wrap)
3604 {
3605   bfd_signed_vma wrapmin = -wrap;
3606
3607   /* Start at the given initial points.  */
3608   gad->fdcur = fdcur;
3609   gad->cur = cur;
3610
3611   /* If we had an incoming odd word and we have any got entries that
3612      are going to use it, consume it, otherwise leave gad->odd at
3613      zero.  We might force gad->odd to zero and return the incoming
3614      odd such that it is used by the next range, but then GOT entries
3615      might appear to be out of order and we wouldn't be able to
3616      shorten the GOT by one word if it turns out to end with an
3617      unpaired GOT entry.  */
3618   if (odd && got)
3619     {
3620       gad->odd = odd;
3621       got -= 4;
3622       odd = 0;
3623     }
3624   else
3625     gad->odd = 0;
3626
3627   /* If we're left with an unpaired GOT entry, compute its location
3628      such that we can return it.  Otherwise, if got doesn't require an
3629      odd number of words here, either odd was already zero in the
3630      block above, or it was set to zero because got was non-zero, or
3631      got was already zero.  In the latter case, we want the value of
3632      odd to carry over to the return statement, so we don't want to
3633      reset odd unless the condition below is true.  */
3634   if (got & 4)
3635     {
3636       odd = cur + got;
3637       got += 4;
3638     }
3639
3640   /* Compute the tentative boundaries of this range.  */
3641   gad->max = cur + got;
3642   gad->min = fdcur - fd;
3643   gad->fdplt = 0;
3644
3645   /* If function descriptors took too much space, wrap some of them
3646      around.  */
3647   if (gad->min < wrapmin)
3648     {
3649       gad->max += wrapmin - gad->min;
3650       gad->min = wrapmin;
3651     }
3652   /* If there is space left and we have function descriptors
3653      referenced in PLT entries that could take advantage of shorter
3654      offsets, place them here.  */
3655   else if (fdplt && gad->min > wrapmin)
3656     {
3657       bfd_vma fds;
3658       if ((bfd_vma) (gad->min - wrapmin) < fdplt)
3659         fds = gad->min - wrapmin;
3660       else
3661         fds = fdplt;
3662
3663       fdplt -= fds;
3664       gad->min -= fds;
3665       gad->fdplt += fds;
3666     }
3667
3668   /* If GOT entries took too much space, wrap some of them around.
3669      This may well cause gad->min to become lower than wrapmin.  This
3670      will cause a relocation overflow later on, so we don't have to
3671      report it here . */
3672   if ((bfd_vma) gad->max > wrap)
3673     {
3674       gad->min -= gad->max - wrap;
3675       gad->max = wrap;
3676     }
3677   /* If there is more space left, try to place some more function
3678      descriptors for PLT entries.  */
3679   else if (fdplt && (bfd_vma) gad->max < wrap)
3680     {
3681       bfd_vma fds;
3682       if ((bfd_vma) (wrap - gad->max) < fdplt)
3683         fds = wrap - gad->max;
3684       else
3685         fds = fdplt;
3686
3687       fdplt -= fds;
3688       gad->max += fds;
3689       gad->fdplt += fds;
3690     }
3691
3692   /* If odd was initially computed as an offset past the wrap point,
3693      wrap it around.  */
3694   if (odd > gad->max)
3695     odd = gad->min + odd - gad->max;
3696
3697   /* _bfinfdpic_get_got_entry() below will always wrap gad->cur if needed
3698      before returning, so do it here too.  This guarantees that,
3699      should cur and fdcur meet at the wrap point, they'll both be
3700      equal to min.  */
3701   if (gad->cur == gad->max)
3702     gad->cur = gad->min;
3703
3704   return odd;
3705 }
3706
3707 /* Compute the location of the next GOT entry, given the allocation
3708    data for a range.  */
3709
3710 inline static bfd_signed_vma
3711 _bfinfdpic_get_got_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3712 {
3713   bfd_signed_vma ret;
3714
3715   if (gad->odd)
3716     {
3717       /* If there was an odd word left behind, use it.  */
3718       ret = gad->odd;
3719       gad->odd = 0;
3720     }
3721   else
3722     {
3723       /* Otherwise, use the word pointed to by cur, reserve the next
3724          as an odd word, and skip to the next pair of words, possibly
3725          wrapping around.  */
3726       ret = gad->cur;
3727       gad->odd = gad->cur + 4;
3728       gad->cur += 8;
3729       if (gad->cur == gad->max)
3730         gad->cur = gad->min;
3731     }
3732
3733   return ret;
3734 }
3735
3736 /* Compute the location of the next function descriptor entry in the
3737    GOT, given the allocation data for a range.  */
3738
3739 inline static bfd_signed_vma
3740 _bfinfdpic_get_fd_entry (struct _bfinfdpic_dynamic_got_alloc_data *gad)
3741 {
3742   /* If we're at the bottom, wrap around, and only then allocate the
3743      next pair of words.  */
3744   if (gad->fdcur == gad->min)
3745     gad->fdcur = gad->max;
3746   return gad->fdcur -= 8;
3747 }
3748
3749 /* Assign GOT offsets for every GOT entry and function descriptor.
3750    Doing everything in a single pass is tricky.  */
3751
3752 static int
3753 _bfinfdpic_assign_got_entries (void **entryp, void *info_)
3754 {
3755   struct bfinfdpic_relocs_info *entry = *entryp;
3756   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3757
3758   if (entry->got17m4)
3759     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3760   else if (entry->gothilo)
3761     entry->got_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3762
3763   if (entry->fdgot17m4)
3764     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->got17m4);
3765   else if (entry->fdgothilo)
3766     entry->fdgot_entry = _bfinfdpic_get_got_entry (&dinfo->gothilo);
3767
3768   if (entry->fdgoff17m4)
3769     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3770   else if (entry->plt && dinfo->got17m4.fdplt)
3771     {
3772       dinfo->got17m4.fdplt -= 8;
3773       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3774     }
3775   else if (entry->plt)
3776     {
3777       dinfo->gothilo.fdplt -= 8;
3778       entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3779     }
3780   else if (entry->privfd)
3781     entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3782
3783   return 1;
3784 }
3785
3786 /* Assign GOT offsets to private function descriptors used by PLT
3787    entries (or referenced by 32-bit offsets), as well as PLT entries
3788    and lazy PLT entries.  */
3789
3790 static int
3791 _bfinfdpic_assign_plt_entries (void **entryp, void *info_)
3792 {
3793   struct bfinfdpic_relocs_info *entry = *entryp;
3794   struct _bfinfdpic_dynamic_got_plt_info *dinfo = info_;
3795
3796   /* If this symbol requires a local function descriptor, allocate
3797      one.  */
3798   if (entry->privfd && entry->fd_entry == 0)
3799     {
3800       if (dinfo->got17m4.fdplt)
3801         {
3802           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->got17m4);
3803           dinfo->got17m4.fdplt -= 8;
3804         }
3805       else
3806         {
3807           BFD_ASSERT (dinfo->gothilo.fdplt);
3808           entry->fd_entry = _bfinfdpic_get_fd_entry (&dinfo->gothilo);
3809           dinfo->gothilo.fdplt -= 8;
3810         }
3811     }
3812
3813   if (entry->plt)
3814     {
3815       int size;
3816
3817       /* We use the section's raw size to mark the location of the
3818          next PLT entry.  */
3819       entry->plt_entry = bfinfdpic_plt_section (dinfo->g.info)->size;
3820
3821       /* Figure out the length of this PLT entry based on the
3822          addressing mode we need to reach the function descriptor.  */
3823       BFD_ASSERT (entry->fd_entry);
3824       if (entry->fd_entry >= -(1 << (18 - 1))
3825           && entry->fd_entry + 4 < (1 << (18 - 1)))
3826         size = 10;
3827       else
3828         size = 16;
3829
3830       bfinfdpic_plt_section (dinfo->g.info)->size += size;
3831     }
3832
3833   if (entry->lazyplt)
3834     {
3835       entry->lzplt_entry = dinfo->g.lzplt;
3836       dinfo->g.lzplt += LZPLT_NORMAL_SIZE;
3837       /* If this entry is the one that gets the resolver stub, account
3838          for the additional instruction.  */
3839       if (entry->lzplt_entry % BFINFDPIC_LZPLT_BLOCK_SIZE
3840           == BFINFDPIC_LZPLT_RESOLV_LOC)
3841         dinfo->g.lzplt += LZPLT_RESOLVER_EXTRA;
3842     }
3843
3844   return 1;
3845 }
3846
3847 /* Follow indirect and warning hash entries so that each got entry
3848    points to the final symbol definition.  P must point to a pointer
3849    to the hash table we're traversing.  Since this traversal may
3850    modify the hash table, we set this pointer to NULL to indicate
3851    we've made a potentially-destructive change to the hash table, so
3852    the traversal must be restarted.  */
3853 static int
3854 _bfinfdpic_resolve_final_relocs_info (void **entryp, void *p)
3855 {
3856   struct bfinfdpic_relocs_info *entry = *entryp;
3857   htab_t *htab = p;
3858
3859   if (entry->symndx == -1)
3860     {
3861       struct elf_link_hash_entry *h = entry->d.h;
3862       struct bfinfdpic_relocs_info *oentry;
3863
3864       while (h->root.type == bfd_link_hash_indirect
3865              || h->root.type == bfd_link_hash_warning)
3866         h = (struct elf_link_hash_entry *)h->root.u.i.link;
3867
3868       if (entry->d.h == h)
3869         return 1;
3870
3871       oentry = bfinfdpic_relocs_info_for_global (*htab, 0, h, entry->addend,
3872                                                 NO_INSERT);
3873
3874       if (oentry)
3875         {
3876           /* Merge the two entries.  */
3877           bfinfdpic_pic_merge_early_relocs_info (oentry, entry);
3878           htab_clear_slot (*htab, entryp);
3879           return 1;
3880         }
3881
3882       entry->d.h = h;
3883
3884       /* If we can't find this entry with the new bfd hash, re-insert
3885          it, and get the traversal restarted.  */
3886       if (! htab_find (*htab, entry))
3887         {
3888           htab_clear_slot (*htab, entryp);
3889           entryp = htab_find_slot (*htab, entry, INSERT);
3890           if (! *entryp)
3891             *entryp = entry;
3892           /* Abort the traversal, since the whole table may have
3893              moved, and leave it up to the parent to restart the
3894              process.  */
3895           *(htab_t *)p = NULL;
3896           return 0;
3897         }
3898     }
3899
3900   return 1;
3901 }
3902
3903 /* Set the sizes of the dynamic sections.  */
3904
3905 static bfd_boolean
3906 elf32_bfinfdpic_size_dynamic_sections (bfd *output_bfd,
3907                                       struct bfd_link_info *info)
3908 {
3909   bfd *dynobj;
3910   asection *s;
3911   struct _bfinfdpic_dynamic_got_plt_info gpinfo;
3912   bfd_signed_vma odd;
3913   bfd_vma limit;
3914
3915   dynobj = elf_hash_table (info)->dynobj;
3916   BFD_ASSERT (dynobj != NULL);
3917
3918   if (elf_hash_table (info)->dynamic_sections_created)
3919     {
3920       /* Set the contents of the .interp section to the interpreter.  */
3921       if (info->executable)
3922         {
3923           s = bfd_get_section_by_name (dynobj, ".interp");
3924           BFD_ASSERT (s != NULL);
3925           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3926           s->contents = (bfd_byte *) ELF_DYNAMIC_INTERPRETER;
3927         }
3928     }
3929
3930   memset (&gpinfo, 0, sizeof (gpinfo));
3931   gpinfo.g.info = info;
3932
3933   for (;;)
3934     {
3935       htab_t relocs = bfinfdpic_relocs_info (info);
3936
3937       htab_traverse (relocs, _bfinfdpic_resolve_final_relocs_info, &relocs);
3938
3939       if (relocs == bfinfdpic_relocs_info (info))
3940         break;
3941     }
3942
3943   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_count_got_plt_entries,
3944                  &gpinfo.g);
3945
3946   odd = 12;
3947   /* Compute the total size taken by entries in the 18-bit range,
3948      to tell how many PLT function descriptors we can bring into it
3949      without causing it to overflow.  */
3950   limit = odd + gpinfo.g.got17m4 + gpinfo.g.fd17m4;
3951   if (limit < (bfd_vma)1 << 18)
3952     limit = ((bfd_vma)1 << 18) - limit;
3953   else
3954     limit = 0;
3955   if (gpinfo.g.fdplt < limit)
3956     limit = gpinfo.g.fdplt;
3957
3958   /* Determine the ranges of GOT offsets that we can use for each
3959      range of addressing modes.  */
3960   odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.got17m4,
3961                                           0,
3962                                           odd,
3963                                           16,
3964                                           gpinfo.g.got17m4,
3965                                           gpinfo.g.fd17m4,
3966                                           limit,
3967                                           (bfd_vma)1 << (18-1));
3968   odd = _bfinfdpic_compute_got_alloc_data (&gpinfo.gothilo,
3969                                           gpinfo.got17m4.min,
3970                                           odd,
3971                                           gpinfo.got17m4.max,
3972                                           gpinfo.g.gothilo,
3973                                           gpinfo.g.fdhilo,
3974                                           gpinfo.g.fdplt - gpinfo.got17m4.fdplt,
3975                                           (bfd_vma)1 << (32-1));
3976
3977   /* Now assign (most) GOT offsets.  */
3978   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_got_entries,
3979                  &gpinfo);
3980
3981   bfinfdpic_got_section (info)->size = gpinfo.gothilo.max
3982     - gpinfo.gothilo.min
3983     /* If an odd word is the last word of the GOT, we don't need this
3984        word to be part of the GOT.  */
3985     - (odd + 4 == gpinfo.gothilo.max ? 4 : 0);
3986   if (bfinfdpic_got_section (info)->size == 0)
3987     bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
3988   else if (bfinfdpic_got_section (info)->size == 12
3989            && ! elf_hash_table (info)->dynamic_sections_created)
3990     {
3991       bfinfdpic_got_section (info)->flags |= SEC_EXCLUDE;
3992       bfinfdpic_got_section (info)->size = 0;
3993     }
3994   else
3995     {
3996       bfinfdpic_got_section (info)->contents =
3997         (bfd_byte *) bfd_zalloc (dynobj,
3998                                  bfinfdpic_got_section (info)->size);
3999       if (bfinfdpic_got_section (info)->contents == NULL)
4000         return FALSE;
4001     }
4002
4003   if (elf_hash_table (info)->dynamic_sections_created)
4004     /* Subtract the number of lzplt entries, since those will generate
4005        relocations in the pltrel section.  */
4006     bfinfdpic_gotrel_section (info)->size =
4007       (gpinfo.g.relocs - gpinfo.g.lzplt / LZPLT_NORMAL_SIZE)
4008       * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4009   else
4010     BFD_ASSERT (gpinfo.g.relocs == 0);
4011   if (bfinfdpic_gotrel_section (info)->size == 0)
4012     bfinfdpic_gotrel_section (info)->flags |= SEC_EXCLUDE;
4013   else
4014     {
4015       bfinfdpic_gotrel_section (info)->contents =
4016         (bfd_byte *) bfd_zalloc (dynobj,
4017                                  bfinfdpic_gotrel_section (info)->size);
4018       if (bfinfdpic_gotrel_section (info)->contents == NULL)
4019         return FALSE;
4020     }
4021
4022   bfinfdpic_gotfixup_section (info)->size = (gpinfo.g.fixups + 1) * 4;
4023   if (bfinfdpic_gotfixup_section (info)->size == 0)
4024     bfinfdpic_gotfixup_section (info)->flags |= SEC_EXCLUDE;
4025   else
4026     {
4027       bfinfdpic_gotfixup_section (info)->contents =
4028         (bfd_byte *) bfd_zalloc (dynobj,
4029                                  bfinfdpic_gotfixup_section (info)->size);
4030       if (bfinfdpic_gotfixup_section (info)->contents == NULL)
4031         return FALSE;
4032     }
4033
4034   if (elf_hash_table (info)->dynamic_sections_created)
4035     {
4036       bfinfdpic_pltrel_section (info)->size =
4037         gpinfo.g.lzplt / LZPLT_NORMAL_SIZE * get_elf_backend_data (output_bfd)->s->sizeof_rel;
4038       if (bfinfdpic_pltrel_section (info)->size == 0)
4039         bfinfdpic_pltrel_section (info)->flags |= SEC_EXCLUDE;
4040       else
4041         {
4042           bfinfdpic_pltrel_section (info)->contents =
4043             (bfd_byte *) bfd_zalloc (dynobj,
4044                                      bfinfdpic_pltrel_section (info)->size);
4045           if (bfinfdpic_pltrel_section (info)->contents == NULL)
4046             return FALSE;
4047         }
4048     }
4049
4050   /* Add 4 bytes for every block of at most 65535 lazy PLT entries,
4051      such that there's room for the additional instruction needed to
4052      call the resolver.  Since _bfinfdpic_assign_got_entries didn't
4053      account for them, our block size is 4 bytes smaller than the real
4054      block size.  */
4055   if (elf_hash_table (info)->dynamic_sections_created)
4056     {
4057       bfinfdpic_plt_section (info)->size = gpinfo.g.lzplt
4058         + ((gpinfo.g.lzplt + (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) - LZPLT_NORMAL_SIZE)
4059            / (BFINFDPIC_LZPLT_BLOCK_SIZE - 4) * LZPLT_RESOLVER_EXTRA);
4060     }
4061
4062   /* Reset it, such that _bfinfdpic_assign_plt_entries() can use it to
4063      actually assign lazy PLT entries addresses.  */
4064   gpinfo.g.lzplt = 0;
4065
4066   /* Save information that we're going to need to generate GOT and PLT
4067      entries.  */
4068   bfinfdpic_got_initial_offset (info) = -gpinfo.gothilo.min;
4069
4070   if (get_elf_backend_data (output_bfd)->want_got_sym)
4071     elf_hash_table (info)->hgot->root.u.def.value
4072       += bfinfdpic_got_initial_offset (info);
4073
4074   if (elf_hash_table (info)->dynamic_sections_created)
4075     bfinfdpic_plt_initial_offset (info) =
4076       bfinfdpic_plt_section (info)->size;
4077
4078   htab_traverse (bfinfdpic_relocs_info (info), _bfinfdpic_assign_plt_entries,
4079                  &gpinfo);
4080
4081   /* Allocate the PLT section contents only after
4082      _bfinfdpic_assign_plt_entries has a chance to add the size of the
4083      non-lazy PLT entries.  */
4084   if (elf_hash_table (info)->dynamic_sections_created)
4085     {
4086       if (bfinfdpic_plt_section (info)->size == 0)
4087         bfinfdpic_plt_section (info)->flags |= SEC_EXCLUDE;
4088       else
4089         {
4090           bfinfdpic_plt_section (info)->contents =
4091             (bfd_byte *) bfd_zalloc (dynobj,
4092                                      bfinfdpic_plt_section (info)->size);
4093           if (bfinfdpic_plt_section (info)->contents == NULL)
4094             return FALSE;
4095         }
4096     }
4097
4098   if (elf_hash_table (info)->dynamic_sections_created)
4099     {
4100       if (bfinfdpic_got_section (info)->size)
4101         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTGOT, 0))
4102           return FALSE;
4103
4104       if (bfinfdpic_pltrel_section (info)->size)
4105         if (!_bfd_elf_add_dynamic_entry (info, DT_PLTRELSZ, 0)
4106             || !_bfd_elf_add_dynamic_entry (info, DT_PLTREL, DT_REL)
4107             || !_bfd_elf_add_dynamic_entry (info, DT_JMPREL, 0))
4108           return FALSE;
4109
4110       if (bfinfdpic_gotrel_section (info)->size)
4111         if (!_bfd_elf_add_dynamic_entry (info, DT_REL, 0)
4112             || !_bfd_elf_add_dynamic_entry (info, DT_RELSZ, 0)
4113             || !_bfd_elf_add_dynamic_entry (info, DT_RELENT,
4114                                             sizeof (Elf32_External_Rel)))
4115           return FALSE;
4116     }
4117
4118   return TRUE;
4119 }
4120
4121 static bfd_boolean
4122 elf32_bfinfdpic_always_size_sections (bfd *output_bfd,
4123                                      struct bfd_link_info *info)
4124 {
4125   if (!info->relocatable)
4126     {
4127       struct elf_link_hash_entry *h;
4128
4129       /* Force a PT_GNU_STACK segment to be created.  */
4130       if (! elf_tdata (output_bfd)->stack_flags)
4131         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
4132
4133       /* Define __stacksize if it's not defined yet.  */
4134       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4135                                 FALSE, FALSE, FALSE);
4136       if (! h || h->root.type != bfd_link_hash_defined
4137           || h->type != STT_OBJECT
4138           || !h->def_regular)
4139         {
4140           struct bfd_link_hash_entry *bh = NULL;
4141
4142           if (!(_bfd_generic_link_add_one_symbol
4143                 (info, output_bfd, "__stacksize",
4144                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
4145                  (const char *) NULL, FALSE,
4146                  get_elf_backend_data (output_bfd)->collect, &bh)))
4147             return FALSE;
4148
4149           h = (struct elf_link_hash_entry *) bh;
4150           h->def_regular = 1;
4151           h->type = STT_OBJECT;
4152         }
4153     }
4154
4155   return TRUE;
4156 }
4157
4158 static bfd_boolean
4159 elf32_bfinfdpic_modify_program_headers (bfd *output_bfd,
4160                                         struct bfd_link_info *info)
4161 {
4162   struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
4163   struct elf_segment_map *m;
4164   Elf_Internal_Phdr *p;
4165
4166   /* objcopy and strip preserve what's already there using
4167      elf32_bfinfdpic_copy_private_bfd_data ().  */
4168   if (! info)
4169     return TRUE;
4170
4171   for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
4172     if (m->p_type == PT_GNU_STACK)
4173       break;
4174
4175   if (m)
4176     {
4177       struct elf_link_hash_entry *h;
4178
4179       /* Obtain the pointer to the __stacksize symbol.  */
4180       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
4181                                 FALSE, FALSE, FALSE);
4182       if (h)
4183         {
4184           while (h->root.type == bfd_link_hash_indirect
4185                  || h->root.type == bfd_link_hash_warning)
4186             h = (struct elf_link_hash_entry *) h->root.u.i.link;
4187           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
4188         }
4189
4190       /* Set the header p_memsz from the symbol value.  We
4191          intentionally ignore the symbol section.  */
4192       if (h && h->root.type == bfd_link_hash_defined)
4193         p->p_memsz = h->root.u.def.value;
4194       else
4195         p->p_memsz = DEFAULT_STACK_SIZE;
4196
4197       p->p_align = 8;
4198     }
4199
4200   return TRUE;
4201 }
4202
4203 static bfd_boolean
4204 elf32_bfinfdpic_finish_dynamic_sections (bfd *output_bfd,
4205                                         struct bfd_link_info *info)
4206 {
4207   bfd *dynobj;
4208   asection *sdyn;
4209
4210   dynobj = elf_hash_table (info)->dynobj;
4211
4212   if (bfinfdpic_got_section (info))
4213     {
4214       BFD_ASSERT (bfinfdpic_gotrel_section (info)->size
4215                   == (bfinfdpic_gotrel_section (info)->reloc_count
4216                       * sizeof (Elf32_External_Rel)));
4217
4218       if (bfinfdpic_gotfixup_section (info))
4219         {
4220           struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
4221           bfd_vma got_value = hgot->root.u.def.value
4222             + hgot->root.u.def.section->output_section->vma
4223             + hgot->root.u.def.section->output_offset;
4224
4225           _bfinfdpic_add_rofixup (output_bfd, bfinfdpic_gotfixup_section (info),
4226                                  got_value, 0);
4227
4228           if (bfinfdpic_gotfixup_section (info)->size
4229               != (bfinfdpic_gotfixup_section (info)->reloc_count * 4))
4230             {
4231               (*_bfd_error_handler)
4232                 ("LINKER BUG: .rofixup section size mismatch");
4233               return FALSE;
4234             }
4235         }
4236     }
4237   if (elf_hash_table (info)->dynamic_sections_created)
4238     {
4239       BFD_ASSERT (bfinfdpic_pltrel_section (info)->size
4240                   == (bfinfdpic_pltrel_section (info)->reloc_count
4241                       * sizeof (Elf32_External_Rel)));
4242     }
4243
4244   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4245
4246   if (elf_hash_table (info)->dynamic_sections_created)
4247     {
4248       Elf32_External_Dyn * dyncon;
4249       Elf32_External_Dyn * dynconend;
4250
4251       BFD_ASSERT (sdyn != NULL);
4252
4253       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4254       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4255
4256       for (; dyncon < dynconend; dyncon++)
4257         {
4258           Elf_Internal_Dyn dyn;
4259
4260           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4261
4262           switch (dyn.d_tag)
4263             {
4264             default:
4265               break;
4266
4267             case DT_PLTGOT:
4268               dyn.d_un.d_ptr = bfinfdpic_got_section (info)->output_section->vma
4269                 + bfinfdpic_got_section (info)->output_offset
4270                 + bfinfdpic_got_initial_offset (info);
4271               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4272               break;
4273
4274             case DT_JMPREL:
4275               dyn.d_un.d_ptr = bfinfdpic_pltrel_section (info)
4276                 ->output_section->vma
4277                 + bfinfdpic_pltrel_section (info)->output_offset;
4278               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4279               break;
4280
4281             case DT_PLTRELSZ:
4282               dyn.d_un.d_val = bfinfdpic_pltrel_section (info)->size;
4283               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
4284               break;
4285             }
4286         }
4287     }
4288
4289   return TRUE;
4290 }
4291
4292 /* Adjust a symbol defined by a dynamic object and referenced by a
4293    regular object.  */
4294
4295 static bfd_boolean
4296 elf32_bfinfdpic_adjust_dynamic_symbol
4297 (struct bfd_link_info *info ATTRIBUTE_UNUSED,
4298  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED)
4299 {
4300   bfd * dynobj;
4301
4302   dynobj = elf_hash_table (info)->dynobj;
4303
4304   /* Make sure we know what is going on here.  */
4305   BFD_ASSERT (dynobj != NULL
4306               && (h->u.weakdef != NULL
4307                   || (h->def_dynamic
4308                       && h->ref_regular
4309                       && !h->def_regular)));
4310
4311   /* If this is a weak symbol, and there is a real definition, the
4312      processor independent code will have arranged for us to see the
4313      real definition first, and we can just use the same value.  */
4314   if (h->u.weakdef != NULL)
4315     {
4316       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
4317                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
4318       h->root.u.def.section = h->u.weakdef->root.u.def.section;
4319       h->root.u.def.value = h->u.weakdef->root.u.def.value;
4320     }
4321
4322   return TRUE;
4323 }
4324
4325 /* Perform any actions needed for dynamic symbols.  */
4326
4327 static bfd_boolean
4328 elf32_bfinfdpic_finish_dynamic_symbol
4329 (bfd *output_bfd ATTRIBUTE_UNUSED,
4330  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4331  struct elf_link_hash_entry *h ATTRIBUTE_UNUSED,
4332  Elf_Internal_Sym *sym ATTRIBUTE_UNUSED)
4333 {
4334   return TRUE;
4335 }
4336
4337 /* Decide whether to attempt to turn absptr or lsda encodings in
4338    shared libraries into pcrel within the given input section.  */
4339
4340 static bfd_boolean
4341 bfinfdpic_elf_use_relative_eh_frame
4342 (bfd *input_bfd ATTRIBUTE_UNUSED,
4343  struct bfd_link_info *info ATTRIBUTE_UNUSED,
4344  asection *eh_frame_section ATTRIBUTE_UNUSED)
4345 {
4346   /* We can't use PC-relative encodings in FDPIC binaries, in general.  */
4347   return FALSE;
4348 }
4349
4350 /* Adjust the contents of an eh_frame_hdr section before they're output.  */
4351
4352 static bfd_byte
4353 bfinfdpic_elf_encode_eh_address (bfd *abfd,
4354                                 struct bfd_link_info *info,
4355                                 asection *osec, bfd_vma offset,
4356                                 asection *loc_sec, bfd_vma loc_offset,
4357                                 bfd_vma *encoded)
4358 {
4359   struct elf_link_hash_entry *h;
4360
4361   h = elf_hash_table (info)->hgot;
4362   BFD_ASSERT (h && h->root.type == bfd_link_hash_defined);
4363
4364   if (! h || (_bfinfdpic_osec_to_segment (abfd, osec)
4365               == _bfinfdpic_osec_to_segment (abfd, loc_sec->output_section)))
4366     return _bfd_elf_encode_eh_address (abfd, info, osec, offset,
4367                                        loc_sec, loc_offset, encoded);
4368
4369   BFD_ASSERT (_bfinfdpic_osec_to_segment (abfd, osec)
4370               == (_bfinfdpic_osec_to_segment
4371                   (abfd, h->root.u.def.section->output_section)));
4372
4373   *encoded = osec->vma + offset
4374     - (h->root.u.def.value
4375        + h->root.u.def.section->output_section->vma
4376        + h->root.u.def.section->output_offset);
4377
4378   return DW_EH_PE_datarel | DW_EH_PE_sdata4;
4379 }
4380
4381
4382
4383 /* Look through the relocs for a section during the first phase.
4384
4385    Besides handling virtual table relocs for gc, we have to deal with
4386    all sorts of PIC-related relocations.  We describe below the
4387    general plan on how to handle such relocations, even though we only
4388    collect information at this point, storing them in hash tables for
4389    perusal of later passes.
4390
4391    32 relocations are propagated to the linker output when creating
4392    position-independent output.  LO16 and HI16 relocations are not
4393    supposed to be encountered in this case.
4394
4395    LABEL16 should always be resolvable by the linker, since it's only
4396    used by branches.
4397
4398    LABEL24, on the other hand, is used by calls.  If it turns out that
4399    the target of a call is a dynamic symbol, a PLT entry must be
4400    created for it, which triggers the creation of a private function
4401    descriptor and, unless lazy binding is disabled, a lazy PLT entry.
4402
4403    GPREL relocations require the referenced symbol to be in the same
4404    segment as _gp, but this can only be checked later.
4405
4406    All GOT, GOTOFF and FUNCDESC relocations require a .got section to
4407    exist.  LABEL24 might as well, since it may require a PLT entry,
4408    that will require a got.
4409
4410    Non-FUNCDESC GOT relocations require a GOT entry to be created
4411    regardless of whether the symbol is dynamic.  However, since a
4412    global symbol that turns out to not be exported may have the same
4413    address of a non-dynamic symbol, we don't assign GOT entries at
4414    this point, such that we can share them in this case.  A relocation
4415    for the GOT entry always has to be created, be it to offset a
4416    private symbol by the section load address, be it to get the symbol
4417    resolved dynamically.
4418
4419    FUNCDESC GOT relocations require a GOT entry to be created, and
4420    handled as if a FUNCDESC relocation was applied to the GOT entry in
4421    an object file.
4422
4423    FUNCDESC relocations referencing a symbol that turns out to NOT be
4424    dynamic cause a private function descriptor to be created.  The
4425    FUNCDESC relocation then decays to a 32 relocation that points at
4426    the private descriptor.  If the symbol is dynamic, the FUNCDESC
4427    relocation is propagated to the linker output, such that the
4428    dynamic linker creates the canonical descriptor, pointing to the
4429    dynamically-resolved definition of the function.
4430
4431    Non-FUNCDESC GOTOFF relocations must always refer to non-dynamic
4432    symbols that are assigned to the same segment as the GOT, but we
4433    can only check this later, after we know the complete set of
4434    symbols defined and/or exported.
4435
4436    FUNCDESC GOTOFF relocations require a function descriptor to be
4437    created and, unless lazy binding is disabled or the symbol is not
4438    dynamic, a lazy PLT entry.  Since we can't tell at this point
4439    whether a symbol is going to be dynamic, we have to decide later
4440    whether to create a lazy PLT entry or bind the descriptor directly
4441    to the private function.
4442
4443    FUNCDESC_VALUE relocations are not supposed to be present in object
4444    files, but they may very well be simply propagated to the linker
4445    output, since they have no side effect.
4446
4447
4448    A function descriptor always requires a FUNCDESC_VALUE relocation.
4449    Whether it's in .plt.rel or not depends on whether lazy binding is
4450    enabled and on whether the referenced symbol is dynamic.
4451
4452    The existence of a lazy PLT requires the resolverStub lazy PLT
4453    entry to be present.
4454
4455
4456    As for assignment of GOT, PLT and lazy PLT entries, and private
4457    descriptors, we might do them all sequentially, but we can do
4458    better than that.  For example, we can place GOT entries and
4459    private function descriptors referenced using 12-bit operands
4460    closer to the PIC register value, such that these relocations don't
4461    overflow.  Those that are only referenced with LO16 relocations
4462    could come next, but we may as well place PLT-required function
4463    descriptors in the 12-bit range to make them shorter.  Symbols
4464    referenced with LO16/HI16 may come next, but we may place
4465    additional function descriptors in the 16-bit range if we can
4466    reliably tell that we've already placed entries that are ever
4467    referenced with only LO16.  PLT entries are therefore generated as
4468    small as possible, while not introducing relocation overflows in
4469    GOT or FUNCDESC_GOTOFF relocations.  Lazy PLT entries could be
4470    generated before or after PLT entries, but not intermingled with
4471    them, such that we can have more lazy PLT entries in range for a
4472    branch to the resolverStub.  The resolverStub should be emitted at
4473    the most distant location from the first lazy PLT entry such that
4474    it's still in range for a branch, or closer, if there isn't a need
4475    for so many lazy PLT entries.  Additional lazy PLT entries may be
4476    emitted after the resolverStub, as long as branches are still in
4477    range.  If the branch goes out of range, longer lazy PLT entries
4478    are emitted.
4479
4480    We could further optimize PLT and lazy PLT entries by giving them
4481    priority in assignment to closer-to-gr17 locations depending on the
4482    number of occurrences of references to them (assuming a function
4483    that's called more often is more important for performance, so its
4484    PLT entry should be faster), or taking hints from the compiler.
4485    Given infinite time and money... :-)  */
4486
4487 static bfd_boolean
4488 bfinfdpic_check_relocs (bfd *abfd, struct bfd_link_info *info,
4489                         asection *sec, const Elf_Internal_Rela *relocs)
4490 {
4491   Elf_Internal_Shdr *symtab_hdr;
4492   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
4493   const Elf_Internal_Rela *rel;
4494   const Elf_Internal_Rela *rel_end;
4495   bfd *dynobj;
4496   struct bfinfdpic_relocs_info *picrel;
4497
4498   if (info->relocatable)
4499     return TRUE;
4500
4501   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
4502   sym_hashes = elf_sym_hashes (abfd);
4503   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof(Elf32_External_Sym);
4504   if (!elf_bad_symtab (abfd))
4505     sym_hashes_end -= symtab_hdr->sh_info;
4506
4507   dynobj = elf_hash_table (info)->dynobj;
4508   rel_end = relocs + sec->reloc_count;
4509   for (rel = relocs; rel < rel_end; rel++)
4510     {
4511       struct elf_link_hash_entry *h;
4512       unsigned long r_symndx;
4513
4514       r_symndx = ELF32_R_SYM (rel->r_info);
4515       if (r_symndx < symtab_hdr->sh_info)
4516         h = NULL;
4517       else
4518         h = sym_hashes[r_symndx - symtab_hdr->sh_info];
4519
4520       switch (ELF32_R_TYPE (rel->r_info))
4521         {
4522         case R_BFIN_GOT17M4:
4523         case R_BFIN_GOTHI:
4524         case R_BFIN_GOTLO:
4525         case R_BFIN_FUNCDESC_GOT17M4:
4526         case R_BFIN_FUNCDESC_GOTHI:
4527         case R_BFIN_FUNCDESC_GOTLO:
4528         case R_BFIN_GOTOFF17M4:
4529         case R_BFIN_GOTOFFHI:
4530         case R_BFIN_GOTOFFLO:
4531         case R_BFIN_FUNCDESC_GOTOFF17M4:
4532         case R_BFIN_FUNCDESC_GOTOFFHI:
4533         case R_BFIN_FUNCDESC_GOTOFFLO:
4534         case R_BFIN_FUNCDESC:
4535         case R_BFIN_FUNCDESC_VALUE:
4536           if (! IS_FDPIC (abfd))
4537             goto bad_reloc;
4538           /* Fall through.  */
4539         case R_pcrel24:
4540         case R_pcrel24_jump_l:
4541         case R_byte4_data:
4542           if (IS_FDPIC (abfd) && ! dynobj)
4543             {
4544               elf_hash_table (info)->dynobj = dynobj = abfd;
4545               if (! _bfin_create_got_section (abfd, info))
4546                 return FALSE;
4547             }
4548           if (! IS_FDPIC (abfd))
4549             {
4550               picrel = NULL;
4551               break;
4552             }
4553           if (h != NULL)
4554             {
4555               if (h->dynindx == -1)
4556                 switch (ELF_ST_VISIBILITY (h->other))
4557                   {
4558                   case STV_INTERNAL:
4559                   case STV_HIDDEN:
4560                     break;
4561                   default:
4562                     bfd_elf_link_record_dynamic_symbol (info, h);
4563                     break;
4564                   }
4565               picrel
4566                 = bfinfdpic_relocs_info_for_global (bfinfdpic_relocs_info (info),
4567                                                    abfd, h,
4568                                                    rel->r_addend, INSERT);
4569             }
4570           else
4571             picrel = bfinfdpic_relocs_info_for_local (bfinfdpic_relocs_info
4572                                                      (info), abfd, r_symndx,
4573                                                      rel->r_addend, INSERT);
4574           if (! picrel)
4575             return FALSE;
4576           break;
4577
4578         default:
4579           picrel = NULL;
4580           break;
4581         }
4582
4583       switch (ELF32_R_TYPE (rel->r_info))
4584         {
4585         case R_pcrel24:
4586         case R_pcrel24_jump_l:
4587           if (IS_FDPIC (abfd))
4588             picrel->call = 1;
4589           break;
4590
4591         case R_BFIN_FUNCDESC_VALUE:
4592           picrel->relocsfdv++;
4593           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4594             picrel->relocs32--;
4595           /* Fall through.  */
4596
4597         case R_byte4_data:
4598           if (! IS_FDPIC (abfd))
4599             break;
4600
4601           picrel->sym = 1;
4602           if (bfd_get_section_flags (abfd, sec) & SEC_ALLOC)
4603             picrel->relocs32++;
4604           break;
4605
4606         case R_BFIN_GOT17M4:
4607           picrel->got17m4 = 1;
4608           break;
4609
4610         case R_BFIN_GOTHI:
4611         case R_BFIN_GOTLO:
4612           picrel->gothilo = 1;
4613           break;
4614
4615         case R_BFIN_FUNCDESC_GOT17M4:
4616           picrel->fdgot17m4 = 1;
4617           break;
4618
4619         case R_BFIN_FUNCDESC_GOTHI:
4620         case R_BFIN_FUNCDESC_GOTLO:
4621           picrel->fdgothilo = 1;
4622           break;
4623
4624         case R_BFIN_GOTOFF17M4:
4625         case R_BFIN_GOTOFFHI:
4626         case R_BFIN_GOTOFFLO:
4627           picrel->gotoff = 1;
4628           break;
4629
4630         case R_BFIN_FUNCDESC_GOTOFF17M4:
4631           picrel->fdgoff17m4 = 1;
4632           break;
4633
4634         case R_BFIN_FUNCDESC_GOTOFFHI:
4635         case R_BFIN_FUNCDESC_GOTOFFLO:
4636           picrel->fdgoffhilo = 1;
4637           break;
4638
4639         case R_BFIN_FUNCDESC:
4640           picrel->fd = 1;
4641           picrel->relocsfd++;
4642           break;
4643
4644         /* This relocation describes the C++ object vtable hierarchy.
4645            Reconstruct it for later use during GC.  */
4646         case R_BFIN_GNU_VTINHERIT:
4647           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
4648             return FALSE;
4649           break;
4650
4651         /* This relocation describes which C++ vtable entries are actually
4652            used.  Record for later use during GC.  */
4653         case R_BFIN_GNU_VTENTRY:
4654           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
4655             return FALSE;
4656           break;
4657
4658         case R_huimm16:
4659         case R_luimm16:
4660         case R_pcrel12_jump_s:
4661         case R_pcrel10:
4662           break;
4663
4664         default:
4665         bad_reloc:
4666           (*_bfd_error_handler)
4667             (_("%B: unsupported relocation type %i"),
4668              abfd, ELF32_R_TYPE (rel->r_info));
4669           return FALSE;
4670         }
4671     }
4672
4673   return TRUE;
4674 }
4675
4676 /* Set the right machine number for a Blackfin ELF file.  */
4677
4678 static bfd_boolean
4679 elf32_bfin_object_p (bfd *abfd)
4680 {
4681   bfd_default_set_arch_mach (abfd, bfd_arch_bfin, 0);
4682   return (((elf_elfheader (abfd)->e_flags & EF_BFIN_FDPIC) != 0)
4683           == (IS_FDPIC (abfd)));
4684 }
4685
4686 static bfd_boolean
4687 elf32_bfin_set_private_flags (bfd * abfd, flagword flags)
4688 {
4689   elf_elfheader (abfd)->e_flags = flags;
4690   elf_flags_init (abfd) = TRUE;
4691   return TRUE;
4692 }
4693
4694 /* Copy backend specific data from one object module to another.  */
4695
4696 static bfd_boolean
4697 bfin_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4698 {
4699   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4700       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4701     return TRUE;
4702
4703   BFD_ASSERT (!elf_flags_init (obfd)
4704               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
4705
4706   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
4707   elf_flags_init (obfd) = TRUE;
4708   return TRUE;
4709 }
4710
4711 static bfd_boolean
4712 elf32_bfinfdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
4713 {
4714   unsigned i;
4715
4716   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4717       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4718     return TRUE;
4719
4720   if (! bfin_elf_copy_private_bfd_data (ibfd, obfd))
4721     return FALSE;
4722
4723   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
4724       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
4725     return TRUE;
4726
4727   /* Copy the stack size.  */
4728   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
4729     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
4730       {
4731         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
4732
4733         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
4734           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
4735             {
4736               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
4737
4738               /* Rewrite the phdrs, since we're only called after they
4739                  were first written.  */
4740               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
4741                             ->s->sizeof_ehdr, SEEK_SET) != 0
4742                   || get_elf_backend_data (obfd)->s
4743                   ->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
4744                                      elf_elfheader (obfd)->e_phnum) != 0)
4745                 return FALSE;
4746               break;
4747             }
4748
4749         break;
4750       }
4751
4752   return TRUE;
4753 }
4754
4755
4756 /* Display the flags field.  */
4757 static bfd_boolean
4758 elf32_bfin_print_private_bfd_data (bfd * abfd, PTR ptr)
4759 {
4760   FILE *file = (FILE *) ptr;
4761   flagword flags;
4762
4763   BFD_ASSERT (abfd != NULL && ptr != NULL);
4764
4765   /* Print normal ELF private data.  */
4766   _bfd_elf_print_private_bfd_data (abfd, ptr);
4767
4768   flags = elf_elfheader (abfd)->e_flags;
4769
4770   /* xgettext:c-format */
4771   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4772
4773   if (flags & EF_BFIN_PIC)
4774     fprintf (file, " -fpic");
4775
4776   if (flags & EF_BFIN_FDPIC)
4777     fprintf (file, " -mfdpic");
4778
4779   fputc ('\n', file);
4780
4781   return TRUE;
4782 }
4783
4784 /* Merge backend specific data from an object file to the output
4785    object file when linking.  */
4786
4787 static bfd_boolean
4788 elf32_bfin_merge_private_bfd_data (bfd *ibfd, bfd *obfd)
4789 {
4790   flagword old_flags, old_partial;
4791   flagword new_flags, new_partial;
4792   bfd_boolean error = FALSE;
4793
4794   new_flags = elf_elfheader (ibfd)->e_flags;
4795   old_flags = elf_elfheader (obfd)->e_flags;
4796
4797   if (new_flags & EF_BFIN_FDPIC)
4798     new_flags &= ~EF_BFIN_PIC;
4799
4800 #ifdef DEBUG
4801   (*_bfd_error_handler) ("old_flags = 0x%.8lx, new_flags = 0x%.8lx, init = %s, filename = %s",
4802                          old_flags, new_flags, elf_flags_init (obfd) ? "yes" : "no",
4803                          bfd_get_filename (ibfd));
4804 #endif
4805
4806   if (!elf_flags_init (obfd))                   /* First call, no flags set.  */
4807     {
4808       elf_flags_init (obfd) = TRUE;
4809       old_flags = new_flags;
4810     }
4811
4812   else if (new_flags == old_flags)              /* Compatible flags are ok.  */
4813     ;
4814
4815   else                                          /* Possibly incompatible flags.  */
4816     {
4817       /* We don't have to do anything if the pic flags are the same, or the new
4818          module(s) were compiled with -mlibrary-pic.  */
4819       new_partial = (new_flags & EF_BFIN_PIC_FLAGS);
4820       old_partial = (old_flags & EF_BFIN_PIC_FLAGS);
4821       if (new_partial == old_partial)
4822         ;
4823
4824       /* If we have mixtures of -fpic and -fPIC, or in both bits.  */
4825       else if (new_partial != 0 && old_partial != 0)
4826         old_flags |= new_partial;
4827
4828       /* One module was compiled for pic and the other was not, see if we have
4829          had any relocations that are not pic-safe.  */
4830       else
4831         old_flags |= new_partial;
4832
4833     }
4834
4835   /* Update the old flags now with changes made above.  */
4836   elf_elfheader (obfd)->e_flags = old_flags;
4837
4838   if (((new_flags & EF_BFIN_FDPIC) == 0)
4839       != (! IS_FDPIC (ibfd)))
4840     {
4841       error = TRUE;
4842       if (IS_FDPIC (obfd))
4843         (*_bfd_error_handler)
4844           (_("%s: cannot link non-fdpic object file into fdpic executable"),
4845            bfd_get_filename (ibfd));
4846       else
4847         (*_bfd_error_handler)
4848           (_("%s: cannot link fdpic object file into non-fdpic executable"),
4849            bfd_get_filename (ibfd));
4850     }
4851
4852   if (error)
4853     bfd_set_error (bfd_error_bad_value);
4854
4855   return !error;
4856 }
4857 \f
4858 /* bfin ELF linker hash entry.  */
4859
4860 struct bfin_link_hash_entry
4861 {
4862   struct elf_link_hash_entry root;
4863
4864   /* Number of PC relative relocs copied for this symbol.  */
4865   struct bfin_pcrel_relocs_copied *pcrel_relocs_copied;
4866 };
4867
4868 /* bfin ELF linker hash table.  */
4869
4870 struct bfin_link_hash_table
4871 {
4872   struct elf_link_hash_table root;
4873
4874   /* Small local sym to section mapping cache.  */
4875   struct sym_sec_cache sym_sec;
4876 };
4877
4878 #define bfin_hash_entry(ent) ((struct bfin_link_hash_entry *) (ent))
4879
4880 static struct bfd_hash_entry *
4881 bfin_link_hash_newfunc (struct bfd_hash_entry *entry,
4882                         struct bfd_hash_table *table, const char *string)
4883 {
4884   struct bfd_hash_entry *ret = entry;
4885
4886   /* Allocate the structure if it has not already been allocated by a
4887      subclass.  */
4888   if (ret == NULL)
4889     ret = bfd_hash_allocate (table, sizeof (struct bfin_link_hash_entry));
4890   if (ret == NULL)
4891     return ret;
4892
4893   /* Call the allocation method of the superclass.  */
4894   ret = _bfd_elf_link_hash_newfunc (ret, table, string);
4895   if (ret != NULL)
4896     bfin_hash_entry (ret)->pcrel_relocs_copied = NULL;
4897
4898   return ret;
4899 }
4900
4901 /* Create an bfin ELF linker hash table.  */
4902
4903 static struct bfd_link_hash_table *
4904 bfin_link_hash_table_create (bfd * abfd)
4905 {
4906   struct bfin_link_hash_table *ret;
4907   bfd_size_type amt = sizeof (struct bfin_link_hash_table);
4908
4909   ret = bfd_zalloc (abfd, amt);
4910   if (ret == NULL)
4911     return NULL;
4912
4913   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
4914                                       bfin_link_hash_newfunc,
4915                                       sizeof (struct elf_link_hash_entry)))
4916     {
4917       free (ret);
4918       return NULL;
4919     }
4920
4921   ret->sym_sec.abfd = NULL;
4922
4923   return &ret->root.root;
4924 }
4925
4926 /* The size in bytes of an entry in the procedure linkage table.  */
4927
4928 /* Finish up the dynamic sections.  */
4929
4930 static bfd_boolean
4931 bfin_finish_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
4932                                   struct bfd_link_info *info)
4933 {
4934   bfd *dynobj;
4935   asection *sdyn;
4936
4937   dynobj = elf_hash_table (info)->dynobj;
4938
4939   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
4940
4941   if (elf_hash_table (info)->dynamic_sections_created)
4942     {
4943       Elf32_External_Dyn *dyncon, *dynconend;
4944
4945       BFD_ASSERT (sdyn != NULL);
4946
4947       dyncon = (Elf32_External_Dyn *) sdyn->contents;
4948       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
4949       for (; dyncon < dynconend; dyncon++)
4950         {
4951           Elf_Internal_Dyn dyn;
4952
4953           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
4954
4955         }
4956
4957     }
4958   return TRUE;
4959 }
4960
4961 /* Finish up dynamic symbol handling.  We set the contents of various
4962    dynamic sections here.  */
4963
4964 static bfd_boolean
4965 bfin_finish_dynamic_symbol (bfd * output_bfd,
4966                                 struct bfd_link_info *info,
4967                                 struct elf_link_hash_entry *h,
4968                                 Elf_Internal_Sym * sym)
4969 {
4970   bfd *dynobj;
4971
4972   dynobj = elf_hash_table (info)->dynobj;
4973
4974   if (h->got.offset != (bfd_vma) - 1)
4975     {
4976       asection *sgot;
4977       asection *srela;
4978       Elf_Internal_Rela rela;
4979       bfd_byte *loc;
4980
4981       /* This symbol has an entry in the global offset table.
4982          Set it up.  */
4983
4984       sgot = bfd_get_section_by_name (dynobj, ".got");
4985       srela = bfd_get_section_by_name (dynobj, ".rela.got");
4986       BFD_ASSERT (sgot != NULL && srela != NULL);
4987
4988       rela.r_offset = (sgot->output_section->vma
4989                        + sgot->output_offset
4990                        + (h->got.offset & ~(bfd_vma) 1));
4991
4992       /* If this is a -Bsymbolic link, and the symbol is defined
4993          locally, we just want to emit a RELATIVE reloc.  Likewise if
4994          the symbol was forced to be local because of a version file.
4995          The entry in the global offset table will already have been
4996          initialized in the relocate_section function.  */
4997       if (info->shared
4998           && (info->symbolic
4999               || h->dynindx == -1 || h->forced_local) && h->def_regular)
5000         {
5001           fprintf(stderr, "*** check this relocation %s\n", __FUNCTION__);
5002           rela.r_info = ELF32_R_INFO (0, R_pcrel24);
5003           rela.r_addend = bfd_get_signed_32 (output_bfd,
5004                                              (sgot->contents
5005                                               +
5006                                               (h->got.
5007                                                offset & ~(bfd_vma) 1)));
5008         }
5009       else
5010         {
5011           bfd_put_32 (output_bfd, (bfd_vma) 0,
5012                       sgot->contents + (h->got.offset & ~(bfd_vma) 1));
5013           rela.r_info = ELF32_R_INFO (h->dynindx, R_got);
5014           rela.r_addend = 0;
5015         }
5016
5017       loc = srela->contents;
5018       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
5019       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
5020     }
5021
5022   if (h->needs_copy)
5023     {
5024       BFD_ASSERT (0);
5025     }
5026   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
5027   if (strcmp (h->root.root.string, "__DYNAMIC") == 0
5028       || h == elf_hash_table (info)->hgot)
5029     sym->st_shndx = SHN_ABS;
5030
5031   return TRUE;
5032 }
5033
5034 /* Adjust a symbol defined by a dynamic object and referenced by a
5035    regular object.  The current definition is in some section of the
5036    dynamic object, but we're not including those sections.  We have to
5037    change the definition to something the rest of the link can
5038    understand.  */
5039
5040 static bfd_boolean
5041 bfin_adjust_dynamic_symbol (struct bfd_link_info *info,
5042                                 struct elf_link_hash_entry *h)
5043 {
5044   bfd *dynobj;
5045   asection *s;
5046   unsigned int power_of_two;
5047
5048   dynobj = elf_hash_table (info)->dynobj;
5049
5050   /* Make sure we know what is going on here.  */
5051   BFD_ASSERT (dynobj != NULL
5052               && (h->needs_plt
5053                   || h->u.weakdef != NULL
5054                   || (h->def_dynamic && h->ref_regular && !h->def_regular)));
5055
5056   /* If this is a function, put it in the procedure linkage table.  We
5057      will fill in the contents of the procedure linkage table later,
5058      when we know the address of the .got section.  */
5059   if (h->type == STT_FUNC || h->needs_plt)
5060     {
5061       BFD_ASSERT(0);
5062     }
5063
5064   /* If this is a weak symbol, and there is a real definition, the
5065      processor independent code will have arranged for us to see the
5066      real definition first, and we can just use the same value.  */
5067   if (h->u.weakdef != NULL)
5068     {
5069       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
5070                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
5071       h->root.u.def.section = h->u.weakdef->root.u.def.section;
5072       h->root.u.def.value = h->u.weakdef->root.u.def.value;
5073       return TRUE;
5074     }
5075
5076   /* This is a reference to a symbol defined by a dynamic object which
5077      is not a function.  */
5078
5079   /* If we are creating a shared library, we must presume that the
5080      only references to the symbol are via the global offset table.
5081      For such cases we need not do anything here; the relocations will
5082      be handled correctly by relocate_section.  */
5083   if (info->shared)
5084     return TRUE;
5085
5086   /* We must allocate the symbol in our .dynbss section, which will
5087      become part of the .bss section of the executable.  There will be
5088      an entry for this symbol in the .dynsym section.  The dynamic
5089      object will contain position independent code, so all references
5090      from the dynamic object to this symbol will go through the global
5091      offset table.  The dynamic linker will use the .dynsym entry to
5092      determine the address it must put in the global offset table, so
5093      both the dynamic object and the regular object will refer to the
5094      same memory location for the variable.  */
5095
5096   s = bfd_get_section_by_name (dynobj, ".dynbss");
5097   BFD_ASSERT (s != NULL);
5098
5099   /* We must generate a R_68K_COPY reloc to tell the dynamic linker to
5100      copy the initial value out of the dynamic object and into the
5101      runtime process image.  We need to remember the offset into the
5102      .rela.bss section we are going to use.  */
5103   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
5104     {
5105       asection *srel;
5106
5107       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
5108       BFD_ASSERT (srel != NULL);
5109       srel->size += sizeof (Elf32_External_Rela);
5110       h->needs_copy = 1;
5111     }
5112
5113   /* We need to figure out the alignment required for this symbol.  I
5114      have no idea how ELF linkers handle this.  */
5115   power_of_two = bfd_log2 (h->size);
5116   if (power_of_two > 3)
5117     power_of_two = 3;
5118
5119   /* Apply the required alignment.  */
5120   s->size = BFD_ALIGN (s->size, (bfd_size_type) (1 << power_of_two));
5121   if (power_of_two > bfd_get_section_alignment (dynobj, s))
5122     {
5123       if (!bfd_set_section_alignment (dynobj, s, power_of_two))
5124         return FALSE;
5125     }
5126
5127   /* Define the symbol as being at this point in the section.  */
5128   h->root.u.def.section = s;
5129   h->root.u.def.value = s->size;
5130
5131   /* Increment the section size to make room for the symbol.  */
5132   s->size += h->size;
5133
5134   return TRUE;
5135 }
5136
5137 /* The bfin linker needs to keep track of the number of relocs that it
5138    decides to copy in check_relocs for each symbol.  This is so that it
5139    can discard PC relative relocs if it doesn't need them when linking
5140    with -Bsymbolic.  We store the information in a field extending the
5141    regular ELF linker hash table.  */
5142
5143 /* This structure keeps track of the number of PC relative relocs we have
5144    copied for a given symbol.  */
5145
5146 struct bfin_pcrel_relocs_copied
5147 {
5148   /* Next section.  */
5149   struct bfin_pcrel_relocs_copied *next;
5150   /* A section in dynobj.  */
5151   asection *section;
5152   /* Number of relocs copied in this section.  */
5153   bfd_size_type count;
5154 };
5155
5156 /* This function is called via elf_link_hash_traverse if we are
5157    creating a shared object.  In the -Bsymbolic case it discards the
5158    space allocated to copy PC relative relocs against symbols which
5159    are defined in regular objects.  For the normal shared case, it
5160    discards space for pc-relative relocs that have become local due to
5161    symbol visibility changes.  We allocated space for them in the
5162    check_relocs routine, but we won't fill them in in the
5163    relocate_section routine.
5164
5165    We also check whether any of the remaining relocations apply
5166    against a readonly section, and set the DF_TEXTREL flag in this
5167    case.  */
5168
5169 static bfd_boolean
5170 bfin_discard_copies (struct elf_link_hash_entry *h, PTR inf)
5171 {
5172   struct bfd_link_info *info = (struct bfd_link_info *) inf;
5173   struct bfin_pcrel_relocs_copied *s;
5174
5175   if (h->root.type == bfd_link_hash_warning)
5176     h = (struct elf_link_hash_entry *) h->root.u.i.link;
5177
5178   if (!h->def_regular || (!info->symbolic && !h->forced_local))
5179     {
5180       if ((info->flags & DF_TEXTREL) == 0)
5181         {
5182           /* Look for relocations against read-only sections.  */
5183           for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5184                s != NULL; s = s->next)
5185             if ((s->section->flags & SEC_READONLY) != 0)
5186               {
5187                 info->flags |= DF_TEXTREL;
5188                 break;
5189               }
5190         }
5191
5192       return TRUE;
5193     }
5194
5195   for (s = bfin_hash_entry (h)->pcrel_relocs_copied;
5196        s != NULL; s = s->next)
5197     s->section->size -= s->count * sizeof (Elf32_External_Rela);
5198
5199   return TRUE;
5200 }
5201
5202 static bfd_boolean
5203 bfin_size_dynamic_sections (bfd * output_bfd ATTRIBUTE_UNUSED,
5204                                 struct bfd_link_info *info)
5205 {
5206   bfd *dynobj;
5207   asection *s;
5208   bfd_boolean relocs;
5209
5210   dynobj = elf_hash_table (info)->dynobj;
5211   BFD_ASSERT (dynobj != NULL);
5212
5213   if (elf_hash_table (info)->dynamic_sections_created)
5214     {
5215       /* Set the contents of the .interp section to the interpreter.  */
5216       if (info->executable)
5217         {
5218           s = bfd_get_section_by_name (dynobj, ".interp");
5219           BFD_ASSERT (s != NULL);
5220           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
5221           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
5222         }
5223     }
5224   else
5225     {
5226       /* We may have created entries in the .rela.got section.
5227          However, if we are not creating the dynamic sections, we will
5228          not actually use these entries.  Reset the size of .rela.got,
5229          which will cause it to get stripped from the output file
5230          below.  */
5231       s = bfd_get_section_by_name (dynobj, ".rela.got");
5232       if (s != NULL)
5233         s->size = 0;
5234     }
5235
5236   /* If this is a -Bsymbolic shared link, then we need to discard all
5237      PC relative relocs against symbols defined in a regular object.
5238      For the normal shared case we discard the PC relative relocs
5239      against symbols that have become local due to visibility changes.
5240      We allocated space for them in the check_relocs routine, but we
5241      will not fill them in in the relocate_section routine.  */
5242   if (info->shared)
5243     elf_link_hash_traverse (elf_hash_table (info),
5244                             bfin_discard_copies, (PTR) info);
5245
5246   /* The check_relocs and adjust_dynamic_symbol entry points have
5247      determined the sizes of the various dynamic sections.  Allocate
5248      memory for them.  */
5249   relocs = FALSE;
5250   for (s = dynobj->sections; s != NULL; s = s->next)
5251     {
5252       const char *name;
5253       bfd_boolean strip;
5254
5255       if ((s->flags & SEC_LINKER_CREATED) == 0)
5256         continue;
5257
5258       /* It's OK to base decisions on the section name, because none
5259          of the dynobj section names depend upon the input files.  */
5260       name = bfd_get_section_name (dynobj, s);
5261
5262       strip = FALSE;
5263
5264        if (CONST_STRNEQ (name, ".rela"))
5265         {
5266           if (s->size == 0)
5267             {
5268               /* If we don't need this section, strip it from the
5269                  output file.  This is mostly to handle .rela.bss and
5270                  .rela.plt.  We must create both sections in
5271                  create_dynamic_sections, because they must be created
5272                  before the linker maps input sections to output
5273                  sections.  The linker does that before
5274                  adjust_dynamic_symbol is called, and it is that
5275                  function which decides whether anything needs to go
5276                  into these sections.  */
5277               strip = TRUE;
5278             }
5279           else
5280             {
5281               relocs = TRUE;
5282
5283               /* We use the reloc_count field as a counter if we need
5284                  to copy relocs into the output file.  */
5285               s->reloc_count = 0;
5286             }
5287         }
5288       else if (! CONST_STRNEQ (name, ".got"))
5289         {
5290           /* It's not one of our sections, so don't allocate space.  */
5291           continue;
5292         }
5293
5294       if (strip)
5295         {
5296           s->flags |= SEC_EXCLUDE;
5297           continue;
5298         }
5299
5300       /* Allocate memory for the section contents.  */
5301       /* FIXME: This should be a call to bfd_alloc not bfd_zalloc.
5302          Unused entries should be reclaimed before the section's contents
5303          are written out, but at the moment this does not happen.  Thus in
5304          order to prevent writing out garbage, we initialise the section's
5305          contents to zero.  */
5306       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
5307       if (s->contents == NULL && s->size != 0)
5308         return FALSE;
5309     }
5310
5311   if (elf_hash_table (info)->dynamic_sections_created)
5312     {
5313       /* Add some entries to the .dynamic section.  We fill in the
5314          values later, in bfin_finish_dynamic_sections, but we
5315          must add the entries now so that we get the correct size for
5316          the .dynamic section.  The DT_DEBUG entry is filled in by the
5317          dynamic linker and used by the debugger.  */
5318 #define add_dynamic_entry(TAG, VAL) \
5319   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
5320
5321       if (!info->shared)
5322         {
5323           if (!add_dynamic_entry (DT_DEBUG, 0))
5324             return FALSE;
5325         }
5326
5327
5328       if (relocs)
5329         {
5330           if (!add_dynamic_entry (DT_RELA, 0)
5331               || !add_dynamic_entry (DT_RELASZ, 0)
5332               || !add_dynamic_entry (DT_RELAENT,
5333                                      sizeof (Elf32_External_Rela)))
5334             return FALSE;
5335         }
5336
5337       if ((info->flags & DF_TEXTREL) != 0)
5338         {
5339           if (!add_dynamic_entry (DT_TEXTREL, 0))
5340             return FALSE;
5341         }
5342     }
5343 #undef add_dynamic_entry
5344
5345   return TRUE;
5346 }
5347 \f
5348 /* Given a .data section and a .emreloc in-memory section, store
5349    relocation information into the .emreloc section which can be
5350    used at runtime to relocate the section.  This is called by the
5351    linker when the --embedded-relocs switch is used.  This is called
5352    after the add_symbols entry point has been called for all the
5353    objects, and before the final_link entry point is called.  */
5354
5355 bfd_boolean bfd_bfin_elf32_create_embedded_relocs
5356   PARAMS ((bfd *, struct bfd_link_info *, asection *, asection *, char **));
5357
5358 bfd_boolean
5359 bfd_bfin_elf32_create_embedded_relocs (
5360      bfd *abfd,
5361      struct bfd_link_info *info,
5362      asection *datasec,
5363      asection *relsec,
5364      char **errmsg)
5365 {
5366   Elf_Internal_Shdr *symtab_hdr;
5367   Elf_Internal_Sym *isymbuf = NULL;
5368   Elf_Internal_Rela *internal_relocs = NULL;
5369   Elf_Internal_Rela *irel, *irelend;
5370   bfd_byte *p;
5371   bfd_size_type amt;
5372
5373   BFD_ASSERT (! info->relocatable);
5374
5375   *errmsg = NULL;
5376
5377   if (datasec->reloc_count == 0)
5378     return TRUE;
5379
5380   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
5381
5382   /* Get a copy of the native relocations.  */
5383   internal_relocs = (_bfd_elf_link_read_relocs
5384                      (abfd, datasec, (PTR) NULL, (Elf_Internal_Rela *) NULL,
5385                       info->keep_memory));
5386   if (internal_relocs == NULL)
5387     goto error_return;
5388
5389   amt = (bfd_size_type) datasec->reloc_count * 12;
5390   relsec->contents = (bfd_byte *) bfd_alloc (abfd, amt);
5391   if (relsec->contents == NULL)
5392     goto error_return;
5393
5394   p = relsec->contents;
5395
5396   irelend = internal_relocs + datasec->reloc_count;
5397   for (irel = internal_relocs; irel < irelend; irel++, p += 12)
5398     {
5399       asection *targetsec;
5400
5401       /* We are going to write a four byte longword into the runtime
5402        reloc section.  The longword will be the address in the data
5403        section which must be relocated.  It is followed by the name
5404        of the target section NUL-padded or truncated to 8
5405        characters.  */
5406
5407       /* We can only relocate absolute longword relocs at run time.  */
5408       if (ELF32_R_TYPE (irel->r_info) != (int) R_byte4_data)
5409         {
5410           *errmsg = _("unsupported reloc type");
5411           bfd_set_error (bfd_error_bad_value);
5412           goto error_return;
5413         }
5414
5415       /* Get the target section referred to by the reloc.  */
5416       if (ELF32_R_SYM (irel->r_info) < symtab_hdr->sh_info)
5417         {
5418           /* A local symbol.  */
5419           Elf_Internal_Sym *isym;
5420
5421           /* Read this BFD's local symbols if we haven't done so already.  */
5422           if (isymbuf == NULL)
5423             {
5424               isymbuf = (Elf_Internal_Sym *) symtab_hdr->contents;
5425               if (isymbuf == NULL)
5426                 isymbuf = bfd_elf_get_elf_syms (abfd, symtab_hdr,
5427                                                 symtab_hdr->sh_info, 0,
5428                                                 NULL, NULL, NULL);
5429               if (isymbuf == NULL)
5430                 goto error_return;
5431             }
5432
5433           isym = isymbuf + ELF32_R_SYM (irel->r_info);
5434           targetsec = bfd_section_from_elf_index (abfd, isym->st_shndx);
5435         }
5436       else
5437         {
5438           unsigned long indx;
5439           struct elf_link_hash_entry *h;
5440
5441           /* An external symbol.  */
5442           indx = ELF32_R_SYM (irel->r_info) - symtab_hdr->sh_info;
5443           h = elf_sym_hashes (abfd)[indx];
5444           BFD_ASSERT (h != NULL);
5445           if (h->root.type == bfd_link_hash_defined
5446               || h->root.type == bfd_link_hash_defweak)
5447             targetsec = h->root.u.def.section;
5448           else
5449             targetsec = NULL;
5450         }
5451
5452       bfd_put_32 (abfd, irel->r_offset + datasec->output_offset, p);
5453       memset (p + 4, 0, 8);
5454       if (targetsec != NULL)
5455         strncpy ((char *) p + 4, targetsec->output_section->name, 8);
5456     }
5457
5458   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5459     free (isymbuf);
5460   if (internal_relocs != NULL
5461       && elf_section_data (datasec)->relocs != internal_relocs)
5462     free (internal_relocs);
5463   return TRUE;
5464
5465 error_return:
5466   if (isymbuf != NULL && symtab_hdr->contents != (unsigned char *) isymbuf)
5467     free (isymbuf);
5468   if (internal_relocs != NULL
5469       && elf_section_data (datasec)->relocs != internal_relocs)
5470     free (internal_relocs);
5471   return FALSE;
5472 }
5473 \f
5474 #define TARGET_LITTLE_SYM               bfd_elf32_bfin_vec
5475 #define TARGET_LITTLE_NAME              "elf32-bfin"
5476 #define ELF_ARCH                        bfd_arch_bfin
5477 #define ELF_MACHINE_CODE                EM_BLACKFIN
5478 #define ELF_MAXPAGESIZE                 0x1000
5479 #define elf_symbol_leading_char         '_'
5480
5481 #define bfd_elf32_bfd_reloc_type_lookup bfin_bfd_reloc_type_lookup
5482 #define elf_info_to_howto               bfin_info_to_howto
5483 #define elf_info_to_howto_rel           0
5484 #define elf_backend_object_p            elf32_bfin_object_p
5485
5486 #define bfd_elf32_bfd_is_local_label_name \
5487                                         bfin_is_local_label_name
5488 #define bfin_hash_table(p) \
5489   ((struct bfin_link_hash_table *) (p)->hash)
5490
5491
5492
5493 #define elf_backend_create_dynamic_sections \
5494                                         _bfd_elf_create_dynamic_sections
5495 #define bfd_elf32_bfd_link_hash_table_create \
5496                                         bfin_link_hash_table_create
5497 #define bfd_elf32_bfd_final_link        bfd_elf_gc_common_final_link
5498
5499 #define elf_backend_check_relocs        bfin_check_relocs
5500 #define elf_backend_adjust_dynamic_symbol \
5501                                         bfin_adjust_dynamic_symbol
5502 #define elf_backend_size_dynamic_sections \
5503                                         bfin_size_dynamic_sections
5504 #define elf_backend_relocate_section    bfin_relocate_section
5505 #define elf_backend_finish_dynamic_symbol \
5506                                         bfin_finish_dynamic_symbol
5507 #define elf_backend_finish_dynamic_sections \
5508                                         bfin_finish_dynamic_sections
5509 #define elf_backend_gc_mark_hook        bfin_gc_mark_hook
5510 #define elf_backend_gc_sweep_hook       bfin_gc_sweep_hook
5511 #define bfd_elf32_bfd_merge_private_bfd_data \
5512                                         elf32_bfin_merge_private_bfd_data
5513 #define bfd_elf32_bfd_set_private_flags \
5514                                         elf32_bfin_set_private_flags
5515 #define bfd_elf32_bfd_print_private_bfd_data \
5516                                         elf32_bfin_print_private_bfd_data
5517 #define elf_backend_reloc_type_class    elf32_bfin_reloc_type_class
5518 #define elf_backend_can_gc_sections 1
5519 #define elf_backend_can_refcount 1
5520 #define elf_backend_want_got_plt 0
5521 #define elf_backend_plt_readonly 1
5522 #define elf_backend_want_plt_sym 0
5523 #define elf_backend_got_header_size     12
5524 #define elf_backend_rela_normal         1
5525
5526 #include "elf32-target.h"
5527
5528 #undef TARGET_LITTLE_SYM
5529 #define TARGET_LITTLE_SYM          bfd_elf32_bfinfdpic_vec
5530 #undef TARGET_LITTLE_NAME
5531 #define TARGET_LITTLE_NAME              "elf32-bfinfdpic"
5532 #undef  elf32_bed
5533 #define elf32_bed               elf32_bfinfdpic_bed
5534
5535 #undef elf_backend_gc_sweep_hook
5536
5537 #undef elf_backend_got_header_size
5538 #define elf_backend_got_header_size     0
5539
5540 #undef elf_backend_relocate_section
5541 #define elf_backend_relocate_section    bfinfdpic_relocate_section
5542 #undef elf_backend_check_relocs
5543 #define elf_backend_check_relocs        bfinfdpic_check_relocs
5544
5545 #undef bfd_elf32_bfd_link_hash_table_create
5546 #define bfd_elf32_bfd_link_hash_table_create \
5547                 bfinfdpic_elf_link_hash_table_create
5548 #undef elf_backend_always_size_sections
5549 #define elf_backend_always_size_sections \
5550                 elf32_bfinfdpic_always_size_sections
5551 #undef elf_backend_modify_program_headers
5552 #define elf_backend_modify_program_headers \
5553                 elf32_bfinfdpic_modify_program_headers
5554 #undef bfd_elf32_bfd_copy_private_bfd_data
5555 #define bfd_elf32_bfd_copy_private_bfd_data \
5556                 elf32_bfinfdpic_copy_private_bfd_data
5557
5558 #undef elf_backend_create_dynamic_sections
5559 #define elf_backend_create_dynamic_sections \
5560                 elf32_bfinfdpic_create_dynamic_sections
5561 #undef elf_backend_adjust_dynamic_symbol
5562 #define elf_backend_adjust_dynamic_symbol \
5563                 elf32_bfinfdpic_adjust_dynamic_symbol
5564 #undef elf_backend_size_dynamic_sections
5565 #define elf_backend_size_dynamic_sections \
5566                 elf32_bfinfdpic_size_dynamic_sections
5567 #undef elf_backend_finish_dynamic_symbol
5568 #define elf_backend_finish_dynamic_symbol \
5569                 elf32_bfinfdpic_finish_dynamic_symbol
5570 #undef elf_backend_finish_dynamic_sections
5571 #define elf_backend_finish_dynamic_sections \
5572                 elf32_bfinfdpic_finish_dynamic_sections
5573
5574 #undef elf_backend_can_make_relative_eh_frame
5575 #define elf_backend_can_make_relative_eh_frame \
5576                 bfinfdpic_elf_use_relative_eh_frame
5577 #undef elf_backend_can_make_lsda_relative_eh_frame
5578 #define elf_backend_can_make_lsda_relative_eh_frame \
5579                 bfinfdpic_elf_use_relative_eh_frame
5580 #undef elf_backend_encode_eh_address
5581 #define elf_backend_encode_eh_address \
5582                 bfinfdpic_elf_encode_eh_address
5583
5584 #undef elf_backend_may_use_rel_p
5585 #define elf_backend_may_use_rel_p       1
5586 #undef elf_backend_may_use_rela_p
5587 #define elf_backend_may_use_rela_p      1
5588 /* We use REL for dynamic relocations only.  */
5589 #undef elf_backend_default_use_rela_p
5590 #define elf_backend_default_use_rela_p  1
5591
5592 #undef elf_backend_omit_section_dynsym
5593 #define elf_backend_omit_section_dynsym _bfinfdpic_link_omit_section_dynsym
5594
5595 #include "elf32-target.h"