bfd/elf32-lm32.c

   1 /* Lattice Mico32-specific support for 32-bit ELF
   2    Copyright (C) 2008-2016 Free Software Foundation, Inc.
   3    Contributed by Jon Beniston <jon@beniston.com>
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/lm32.h"
  27
  28 #define DEFAULT_STACK_SIZE 0x20000
  29
  30 #define PLT_ENTRY_SIZE 20
  31
  32 #define PLT0_ENTRY_WORD0  0
  33 #define PLT0_ENTRY_WORD1  0
  34 #define PLT0_ENTRY_WORD2  0
  35 #define PLT0_ENTRY_WORD3  0
  36 #define PLT0_ENTRY_WORD4  0
  37
  38 #define PLT0_PIC_ENTRY_WORD0  0
  39 #define PLT0_PIC_ENTRY_WORD1  0
  40 #define PLT0_PIC_ENTRY_WORD2  0
  41 #define PLT0_PIC_ENTRY_WORD3  0
  42 #define PLT0_PIC_ENTRY_WORD4  0
  43
  44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
  45
  46 extern const bfd_target lm32_elf32_fdpic_vec;
  47
  48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec)
  49
  50 static bfd_reloc_status_type lm32_elf_gprel_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52
  53 /* The linker needs to keep track of the number of relocs that it
  54    decides to copy as dynamic relocs in check_relocs for each symbol.
  55    This is so that it can later discard them if they are found to be
  56    unnecessary.  We store the information in a field extending the
  57    regular ELF linker hash table.  */
  58
  59 struct elf_lm32_dyn_relocs
  60 {
  61   struct elf_lm32_dyn_relocs *next;
  62
  63   /* The input section of the reloc.  */
  64   asection *sec;
  65
  66   /* Total number of relocs copied for the input section.  */
  67   bfd_size_type count;
  68
  69   /* Number of pc-relative relocs copied for the input section.  */
  70   bfd_size_type pc_count;
  71 };
  72
  73 /* lm32 ELF linker hash entry.  */
  74
  75 struct elf_lm32_link_hash_entry
  76 {
  77   struct elf_link_hash_entry root;
  78
  79   /* Track dynamic relocs copied for this symbol.  */
  80   struct elf_lm32_dyn_relocs *dyn_relocs;
  81 };
  82
  83 /* lm32 ELF linker hash table.  */
  84
  85 struct elf_lm32_link_hash_table
  86 {
  87   struct elf_link_hash_table root;
  88
  89   /* Short-cuts to get to dynamic linker sections.  */
  90   asection *sfixup32;
  91   asection *sdynbss;
  92   asection *srelbss;
  93
  94   int relocs32;
  95 };
  96
  97 /* Get the lm32 ELF linker hash table from a link_info structure.  */
  98
  99 #define lm32_elf_hash_table(p) \
 100   (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
 101   == LM32_ELF_DATA ? ((struct elf_lm32_link_hash_table *) ((p)->hash)) : NULL)
 102
 103 #define lm32fdpic_got_section(info) \
 104   (lm32_elf_hash_table (info)->root.sgot)
 105 #define lm32fdpic_gotrel_section(info) \
 106   (lm32_elf_hash_table (info)->root.srelgot)
 107 #define lm32fdpic_fixup32_section(info) \
 108   (lm32_elf_hash_table (info)->sfixup32)
 109
 110 struct weak_symbol_list
 111 {
 112   const char *name;
 113   struct weak_symbol_list *next;
 114 };
 115
 116 /* Create an entry in an lm32 ELF linker hash table.  */
 117
 118 static struct bfd_hash_entry *
 119 lm32_elf_link_hash_newfunc (struct bfd_hash_entry *entry,
 120                             struct bfd_hash_table *table,
 121                             const char *string)
 122 {
 123   struct elf_lm32_link_hash_entry *ret =
 124     (struct elf_lm32_link_hash_entry *) entry;
 125
 126   /* Allocate the structure if it has not already been allocated by a
 127      subclass.  */
 128   if (ret == NULL)
 129     ret = bfd_hash_allocate (table,
 130                              sizeof (struct elf_lm32_link_hash_entry));
 131   if (ret == NULL)
 132     return NULL;
 133
 134   /* Call the allocation method of the superclass.  */
 135   ret = ((struct elf_lm32_link_hash_entry *)
 136          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 137                                      table, string));
 138   if (ret != NULL)
 139     {
 140       struct elf_lm32_link_hash_entry *eh;
 141
 142       eh = (struct elf_lm32_link_hash_entry *) ret;
 143       eh->dyn_relocs = NULL;
 144     }
 145
 146   return (struct bfd_hash_entry *) ret;
 147 }
 148
 149 /* Create an lm32 ELF linker hash table.  */
 150
 151 static struct bfd_link_hash_table *
 152 lm32_elf_link_hash_table_create (bfd *abfd)
 153 {
 154   struct elf_lm32_link_hash_table *ret;
 155   bfd_size_type amt = sizeof (struct elf_lm32_link_hash_table);
 156
 157   ret = bfd_zmalloc (amt);
 158   if (ret == NULL)
 159     return NULL;
 160
 161   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 162                                       lm32_elf_link_hash_newfunc,
 163                                       sizeof (struct elf_lm32_link_hash_entry),
 164                                       LM32_ELF_DATA))
 165     {
 166       free (ret);
 167       return NULL;
 168     }
 169
 170   return &ret->root.root;
 171 }
 172
 173 /* Add a fixup to the ROFIXUP section.  */
 174
 175 static bfd_vma
 176 _lm32fdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma relocation)
 177 {
 178   bfd_vma fixup_offset;
 179
 180   if (rofixup->flags & SEC_EXCLUDE)
 181     return -1;
 182
 183   fixup_offset = rofixup->reloc_count * 4;
 184   if (rofixup->contents)
 185     {
 186       BFD_ASSERT (fixup_offset < rofixup->size);
 187       if (fixup_offset < rofixup->size)
 188       bfd_put_32 (output_bfd, relocation, rofixup->contents + fixup_offset);
 189     }
 190   rofixup->reloc_count++;
 191
 192   return fixup_offset;
 193 }
 194
 195 /* Create .rofixup sections in DYNOBJ, and set up
 196    shortcuts to them in our hash table.  */
 197
 198 static bfd_boolean
 199 create_rofixup_section (bfd *dynobj, struct bfd_link_info *info)
 200 {
 201   struct elf_lm32_link_hash_table *htab;
 202   htab = lm32_elf_hash_table (info);
 203
 204   if (htab == NULL)
 205     return FALSE;
 206
 207   /* Fixup section for R_LM32_32 relocs.  */
 208   lm32fdpic_fixup32_section (info)
 209     = bfd_make_section_anyway_with_flags (dynobj,
 210                                           ".rofixup",
 211                                           (SEC_ALLOC
 212                                            | SEC_LOAD
 213                                            | SEC_HAS_CONTENTS
 214                                            | SEC_IN_MEMORY
 215                                            | SEC_LINKER_CREATED
 216                                            | SEC_READONLY));
 217   if (lm32fdpic_fixup32_section (info) == NULL
 218       || ! bfd_set_section_alignment (dynobj,
 219                                       lm32fdpic_fixup32_section (info), 2))
 220     return FALSE;
 221
 222   return TRUE;
 223 }
 224
 225 static reloc_howto_type lm32_elf_howto_table [] =
 226 {
 227   /* This reloc does nothing.  */
 228   HOWTO (R_LM32_NONE,               /* type */
 229          0,                         /* rightshift */
 230          3,                         /* size (0 = byte, 1 = short, 2 = long) */
 231          0,                         /* bitsize */
 232          FALSE,                     /* pc_relative */
 233          0,                         /* bitpos */
 234          complain_overflow_dont,    /* complain_on_overflow */
 235          bfd_elf_generic_reloc,     /* special_function */
 236          "R_LM32_NONE",             /* name */
 237          FALSE,                     /* partial_inplace */
 238          0,                         /* src_mask */
 239          0,                         /* dst_mask */
 240          FALSE),                    /* pcrel_offset */
 241
 242   /* An 8 bit absolute relocation.  */
 243   HOWTO (R_LM32_8,                  /* type */
 244          0,                         /* rightshift */
 245          0,                         /* size (0 = byte, 1 = short, 2 = long) */
 246          8,                         /* bitsize */
 247          FALSE,                     /* pc_relative */
 248          0,                         /* bitpos */
 249          complain_overflow_bitfield,/* complain_on_overflow */
 250          bfd_elf_generic_reloc,     /* special_function */
 251          "R_LM32_8",                /* name */
 252          FALSE,                     /* partial_inplace */
 253          0,                         /* src_mask */
 254          0xff,                      /* dst_mask */
 255          FALSE),                    /* pcrel_offset */
 256
 257   /* A 16 bit absolute relocation.  */
 258   HOWTO (R_LM32_16,                 /* type */
 259          0,                         /* rightshift */
 260          1,                         /* size (0 = byte, 1 = short, 2 = long) */
 261          16,                        /* bitsize */
 262          FALSE,                     /* pc_relative */
 263          0,                         /* bitpos */
 264          complain_overflow_bitfield,/* complain_on_overflow */
 265          bfd_elf_generic_reloc,     /* special_function */
 266          "R_LM32_16",               /* name */
 267          FALSE,                     /* partial_inplace */
 268          0,                         /* src_mask */
 269          0xffff,                    /* dst_mask */
 270          FALSE),                    /* pcrel_offset */
 271
 272   /* A 32 bit absolute relocation.  */
 273   HOWTO (R_LM32_32,                 /* type */
 274          0,                         /* rightshift */
 275          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 276          32,                        /* bitsize */
 277          FALSE,                     /* pc_relative */
 278          0,                         /* bitpos */
 279          complain_overflow_bitfield,/* complain_on_overflow */
 280          bfd_elf_generic_reloc,     /* special_function */
 281          "R_LM32_32",               /* name */
 282          FALSE,                     /* partial_inplace */
 283          0,                         /* src_mask */
 284          0xffffffff,                /* dst_mask */
 285          FALSE),                    /* pcrel_offset */
 286
 287   HOWTO (R_LM32_HI16,               /* type */
 288          16,                        /* rightshift */
 289          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 290          16,                        /* bitsize */
 291          FALSE,                     /* pc_relative */
 292          0,                         /* bitpos */
 293          complain_overflow_bitfield,/* complain_on_overflow */
 294          bfd_elf_generic_reloc,     /* special_function */
 295          "R_LM32_HI16",             /* name */
 296          FALSE,                     /* partial_inplace */
 297          0,                         /* src_mask */
 298          0xffff,                    /* dst_mask */
 299          FALSE),                    /* pcrel_offset */
 300
 301   HOWTO (R_LM32_LO16,               /* type */
 302          0,                         /* rightshift */
 303          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 304          16,                        /* bitsize */
 305          FALSE,                     /* pc_relative */
 306          0,                         /* bitpos */
 307          complain_overflow_dont,    /* complain_on_overflow */
 308          bfd_elf_generic_reloc,     /* special_function */
 309          "R_LM32_LO16",             /* name */
 310          FALSE,                     /* partial_inplace */
 311          0,                         /* src_mask */
 312          0xffff,                    /* dst_mask */
 313          FALSE),                    /* pcrel_offset */
 314
 315   HOWTO (R_LM32_GPREL16,            /* type */
 316          0,                         /* rightshift */
 317          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 318          16,                        /* bitsize */
 319          FALSE,                     /* pc_relative */
 320          0,                         /* bitpos */
 321          complain_overflow_dont,    /* complain_on_overflow */
 322          lm32_elf_gprel_reloc,      /* special_function */
 323          "R_LM32_GPREL16",          /* name */
 324          FALSE,                     /* partial_inplace */
 325          0,                         /* src_mask */
 326          0xffff,                    /* dst_mask */
 327          FALSE),                    /* pcrel_offset */
 328
 329   HOWTO (R_LM32_CALL,               /* type */
 330          2,                         /* rightshift */
 331          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 332          26,                        /* bitsize */
 333          TRUE,                      /* pc_relative */
 334          0,                         /* bitpos */
 335          complain_overflow_signed,  /* complain_on_overflow */
 336          bfd_elf_generic_reloc,     /* special_function */
 337          "R_LM32_CALL",             /* name */
 338          FALSE,                     /* partial_inplace */
 339          0,                         /* src_mask */
 340          0x3ffffff,                 /* dst_mask */
 341          TRUE),                     /* pcrel_offset */
 342
 343   HOWTO (R_LM32_BRANCH,             /* type */
 344          2,                         /* rightshift */
 345          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 346          16,                        /* bitsize */
 347          TRUE,                      /* pc_relative */
 348          0,                         /* bitpos */
 349          complain_overflow_signed,  /* complain_on_overflow */
 350          bfd_elf_generic_reloc,     /* special_function */
 351          "R_LM32_BRANCH",           /* name */
 352          FALSE,                     /* partial_inplace */
 353          0,                         /* src_mask */
 354          0xffff,                    /* dst_mask */
 355          TRUE),                     /* pcrel_offset */
 356
 357   /* GNU extension to record C++ vtable hierarchy.  */
 358   HOWTO (R_LM32_GNU_VTINHERIT,      /* type */
 359          0,                         /* rightshift */
 360          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 361          0,                         /* bitsize */
 362          FALSE,                     /* pc_relative */
 363          0,                         /* bitpos */
 364          complain_overflow_dont,    /* complain_on_overflow */
 365          NULL,                      /* special_function */
 366          "R_LM32_GNU_VTINHERIT",    /* name */
 367          FALSE,                     /* partial_inplace */
 368          0,                         /* src_mask */
 369          0,                         /* dst_mask */
 370          FALSE),                    /* pcrel_offset */
 371
 372   /* GNU extension to record C++ vtable member usage.  */
 373   HOWTO (R_LM32_GNU_VTENTRY,        /* type */
 374          0,                         /* rightshift */
 375          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 376          0,                         /* bitsize */
 377          FALSE,                     /* pc_relative */
 378          0,                         /* bitpos */
 379          complain_overflow_dont,    /* complain_on_overflow */
 380          _bfd_elf_rel_vtable_reloc_fn,/* special_function */
 381          "R_LM32_GNU_VTENTRY",      /* name */
 382          FALSE,                     /* partial_inplace */
 383          0,                         /* src_mask */
 384          0,                         /* dst_mask */
 385          FALSE),                    /* pcrel_offset */
 386
 387   HOWTO (R_LM32_16_GOT,             /* type */
 388          0,                         /* rightshift */
 389          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 390          16,                        /* bitsize */
 391          FALSE,                     /* pc_relative */
 392          0,                         /* bitpos */
 393          complain_overflow_signed,  /* complain_on_overflow */
 394          bfd_elf_generic_reloc,     /* special_function */
 395          "R_LM32_16_GOT",           /* name */
 396          FALSE,                     /* partial_inplace */
 397          0,                         /* src_mask */
 398          0xffff,                    /* dst_mask */
 399          FALSE),                    /* pcrel_offset */
 400
 401   HOWTO (R_LM32_GOTOFF_HI16,        /* type */
 402          16,                        /* rightshift */
 403          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 404          16,                        /* bitsize */
 405          FALSE,                     /* pc_relative */
 406          0,                         /* bitpos */
 407          complain_overflow_dont,    /* complain_on_overflow */
 408          bfd_elf_generic_reloc,     /* special_function */
 409          "R_LM32_GOTOFF_HI16",      /* name */
 410          FALSE,                     /* partial_inplace */
 411          0xffff,                    /* src_mask */
 412          0xffff,                    /* dst_mask */
 413          FALSE),                    /* pcrel_offset */
 414
 415   HOWTO (R_LM32_GOTOFF_LO16,        /* type */
 416          0,                         /* rightshift */
 417          2,                         /* size (0 = byte, 1 = short, 2 = long) */
 418          16,                        /* bitsize */
 419          FALSE,                     /* pc_relative */
 420          0,                         /* bitpos */
 421          complain_overflow_dont,    /* complain_on_overflow */
 422          bfd_elf_generic_reloc,     /* special_function */
 423          "R_LM32_GOTOFF_LO16",      /* name */
 424          FALSE,                     /* partial_inplace */
 425          0xffff,                    /* src_mask */
 426          0xffff,                    /* dst_mask */
 427          FALSE),                    /* pcrel_offset */
 428
 429   HOWTO (R_LM32_COPY,           /* type */
 430          0,                     /* rightshift */
 431          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 432          32,                    /* bitsize */
 433          FALSE,                 /* pc_relative */
 434          0,                     /* bitpos */
 435          complain_overflow_bitfield, /* complain_on_overflow */
 436          bfd_elf_generic_reloc, /* special_function */
 437          "R_LM32_COPY",         /* name */
 438          FALSE,                 /* partial_inplace */
 439          0xffffffff,            /* src_mask */
 440          0xffffffff,            /* dst_mask */
 441          FALSE),                /* pcrel_offset */
 442
 443   HOWTO (R_LM32_GLOB_DAT,       /* type */
 444          0,                     /* rightshift */
 445          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 446          32,                    /* bitsize */
 447          FALSE,                 /* pc_relative */
 448          0,                     /* bitpos */
 449          complain_overflow_bitfield, /* complain_on_overflow */
 450          bfd_elf_generic_reloc, /* special_function */
 451          "R_LM32_GLOB_DAT",     /* name */
 452          FALSE,                 /* partial_inplace */
 453          0xffffffff,            /* src_mask */
 454          0xffffffff,            /* dst_mask */
 455          FALSE),                /* pcrel_offset */
 456
 457   HOWTO (R_LM32_JMP_SLOT,       /* type */
 458          0,                     /* rightshift */
 459          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 460          32,                    /* bitsize */
 461          FALSE,                 /* pc_relative */
 462          0,                     /* bitpos */
 463          complain_overflow_bitfield, /* complain_on_overflow */
 464          bfd_elf_generic_reloc, /* special_function */
 465          "R_LM32_JMP_SLOT",     /* name */
 466          FALSE,                 /* partial_inplace */
 467          0xffffffff,            /* src_mask */
 468          0xffffffff,            /* dst_mask */
 469          FALSE),                /* pcrel_offset */
 470
 471   HOWTO (R_LM32_RELATIVE,       /* type */
 472          0,                     /* rightshift */
 473          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 474          32,                    /* bitsize */
 475          FALSE,                 /* pc_relative */
 476          0,                     /* bitpos */
 477          complain_overflow_bitfield, /* complain_on_overflow */
 478          bfd_elf_generic_reloc, /* special_function */
 479          "R_LM32_RELATIVE",     /* name */
 480          FALSE,                 /* partial_inplace */
 481          0xffffffff,            /* src_mask */
 482          0xffffffff,            /* dst_mask */
 483          FALSE),                /* pcrel_offset */
 484
 485 };
 486
 487 /* Map BFD reloc types to lm32 ELF reloc types. */
 488
 489 struct lm32_reloc_map
 490 {
 491     bfd_reloc_code_real_type bfd_reloc_val;
 492     unsigned char elf_reloc_val;
 493 };
 494
 495 static const struct lm32_reloc_map lm32_reloc_map[] =
 496 {
 497   { BFD_RELOC_NONE,             R_LM32_NONE },
 498   { BFD_RELOC_8,                R_LM32_8 },
 499   { BFD_RELOC_16,               R_LM32_16 },
 500   { BFD_RELOC_32,               R_LM32_32 },
 501   { BFD_RELOC_HI16,             R_LM32_HI16 },
 502   { BFD_RELOC_LO16,             R_LM32_LO16 },
 503   { BFD_RELOC_GPREL16,          R_LM32_GPREL16 },
 504   { BFD_RELOC_LM32_CALL,        R_LM32_CALL },
 505   { BFD_RELOC_LM32_BRANCH,      R_LM32_BRANCH },
 506   { BFD_RELOC_VTABLE_INHERIT,   R_LM32_GNU_VTINHERIT },
 507   { BFD_RELOC_VTABLE_ENTRY,     R_LM32_GNU_VTENTRY },
 508   { BFD_RELOC_LM32_16_GOT,      R_LM32_16_GOT },
 509   { BFD_RELOC_LM32_GOTOFF_HI16, R_LM32_GOTOFF_HI16 },
 510   { BFD_RELOC_LM32_GOTOFF_LO16, R_LM32_GOTOFF_LO16 },
 511   { BFD_RELOC_LM32_COPY,        R_LM32_COPY },
 512   { BFD_RELOC_LM32_GLOB_DAT,    R_LM32_GLOB_DAT },
 513   { BFD_RELOC_LM32_JMP_SLOT,    R_LM32_JMP_SLOT },
 514   { BFD_RELOC_LM32_RELATIVE,    R_LM32_RELATIVE },
 515 };
 516
 517 static reloc_howto_type *
 518 lm32_reloc_type_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 519                         bfd_reloc_code_real_type code)
 520 {
 521   unsigned int i;
 522
 523   for (i = 0; i < sizeof (lm32_reloc_map) / sizeof (lm32_reloc_map[0]); i++)
 524     if (lm32_reloc_map[i].bfd_reloc_val == code)
 525       return &lm32_elf_howto_table[lm32_reloc_map[i].elf_reloc_val];
 526   return NULL;
 527 }
 528
 529 static reloc_howto_type *
 530 lm32_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED,
 531                         const char *r_name)
 532 {
 533   unsigned int i;
 534
 535   for (i = 0;
 536        i < sizeof (lm32_elf_howto_table) / sizeof (lm32_elf_howto_table[0]);
 537        i++)
 538     if (lm32_elf_howto_table[i].name != NULL
 539         && strcasecmp (lm32_elf_howto_table[i].name, r_name) == 0)
 540       return &lm32_elf_howto_table[i];
 541
 542   return NULL;
 543 }
 544
 545
 546 /* Set the howto pointer for an Lattice Mico32 ELF reloc.  */
 547
 548 static void
 549 lm32_info_to_howto_rela (bfd *abfd ATTRIBUTE_UNUSED,
 550                          arelent *cache_ptr,
 551                          Elf_Internal_Rela *dst)
 552 {
 553   unsigned int r_type;
 554
 555   r_type = ELF32_R_TYPE (dst->r_info);
 556   if (r_type >= (unsigned int) R_LM32_max)
 557     {
 558       /* xgettext:c-format */
 559       _bfd_error_handler (_("%B: invalid LM32 reloc number: %d"), abfd, r_type);
 560       r_type = 0;
 561     }
 562   cache_ptr->howto = &lm32_elf_howto_table[r_type];
 563 }
 564
 565 /* Set the right machine number for an Lattice Mico32 ELF file. */
 566
 567 static bfd_boolean
 568 lm32_elf_object_p (bfd *abfd)
 569 {
 570   return bfd_default_set_arch_mach (abfd, bfd_arch_lm32, bfd_mach_lm32);
 571 }
 572
 573 /* Set machine type flags just before file is written out. */
 574
 575 static void
 576 lm32_elf_final_write_processing (bfd *abfd, bfd_boolean linker ATTRIBUTE_UNUSED)
 577 {
 578   elf_elfheader (abfd)->e_machine = EM_LATTICEMICO32;
 579   elf_elfheader (abfd)->e_flags &=~ EF_LM32_MACH;
 580   switch (bfd_get_mach (abfd))
 581     {
 582       case bfd_mach_lm32:
 583         elf_elfheader (abfd)->e_flags |= E_LM32_MACH;
 584         break;
 585       default:
 586         abort ();
 587     }
 588 }
 589
 590 /* Set the GP value for OUTPUT_BFD.  Returns FALSE if this is a
 591    dangerous relocation.  */
 592
 593 static bfd_boolean
 594 lm32_elf_assign_gp (bfd *output_bfd, bfd_vma *pgp)
 595 {
 596   unsigned int count;
 597   asymbol **sym;
 598   unsigned int i;
 599
 600   /* If we've already figured out what GP will be, just return it. */
 601   *pgp = _bfd_get_gp_value (output_bfd);
 602   if (*pgp)
 603     return TRUE;
 604
 605   count = bfd_get_symcount (output_bfd);
 606   sym = bfd_get_outsymbols (output_bfd);
 607
 608   /* The linker script will have created a symbol named `_gp' with the
 609      appropriate value.  */
 610   if (sym == NULL)
 611     i = count;
 612   else
 613     {
 614       for (i = 0; i < count; i++, sym++)
 615         {
 616           const char *name;
 617
 618           name = bfd_asymbol_name (*sym);
 619           if (*name == '_' && strcmp (name, "_gp") == 0)
 620             {
 621               *pgp = bfd_asymbol_value (*sym);
 622               _bfd_set_gp_value (output_bfd, *pgp);
 623               break;
 624             }
 625         }
 626     }
 627
 628   if (i >= count)
 629     {
 630       /* Only get the error once.  */
 631       *pgp = 4;
 632       _bfd_set_gp_value (output_bfd, *pgp);
 633       return FALSE;
 634     }
 635
 636   return TRUE;
 637 }
 638
 639 /* We have to figure out the gp value, so that we can adjust the
 640    symbol value correctly.  We look up the symbol _gp in the output
 641    BFD.  If we can't find it, we're stuck.  We cache it in the ELF
 642    target data.  We don't need to adjust the symbol value for an
 643    external symbol if we are producing relocatable output.  */
 644
 645 static bfd_reloc_status_type
 646 lm32_elf_final_gp (bfd *output_bfd, asymbol *symbol, bfd_boolean relocatable,
 647                     char **error_message, bfd_vma *pgp)
 648 {
 649   if (bfd_is_und_section (symbol->section) && !relocatable)
 650     {
 651       *pgp = 0;
 652       return bfd_reloc_undefined;
 653     }
 654
 655   *pgp = _bfd_get_gp_value (output_bfd);
 656   if (*pgp == 0 && (!relocatable || (symbol->flags & BSF_SECTION_SYM) != 0))
 657     {
 658       if (relocatable)
 659         {
 660           /* Make up a value.  */
 661           *pgp = symbol->section->output_section->vma + 0x4000;
 662           _bfd_set_gp_value (output_bfd, *pgp);
 663         }
 664       else if (!lm32_elf_assign_gp (output_bfd, pgp))
 665         {
 666           *error_message =
 667             (char *)
 668             _("global pointer relative relocation when _gp not defined");
 669           return bfd_reloc_dangerous;
 670         }
 671     }
 672
 673   return bfd_reloc_ok;
 674 }
 675
 676 static bfd_reloc_status_type
 677 lm32_elf_do_gprel_relocate (bfd *abfd,
 678                             reloc_howto_type *howto,
 679                             asection *input_section ATTRIBUTE_UNUSED,
 680                             bfd_byte *data,
 681                             bfd_vma offset,
 682                             bfd_vma symbol_value,
 683                             bfd_vma addend)
 684 {
 685   return _bfd_final_link_relocate (howto, abfd, input_section,
 686                                    data, offset, symbol_value, addend);
 687 }
 688
 689 static bfd_reloc_status_type
 690 lm32_elf_gprel_reloc (bfd *abfd,
 691                       arelent *reloc_entry,
 692                       asymbol *symbol,
 693                       void *data,
 694                       asection *input_section,
 695                       bfd *output_bfd,
 696                       char **msg)
 697 {
 698   bfd_vma relocation;
 699   bfd_vma gp;
 700   bfd_reloc_status_type r;
 701
 702   if (output_bfd != (bfd *) NULL
 703       && (symbol->flags & BSF_SECTION_SYM) == 0
 704       && (!reloc_entry->howto->partial_inplace || reloc_entry->addend == 0))
 705     {
 706       reloc_entry->address += input_section->output_offset;
 707       return bfd_reloc_ok;
 708     }
 709
 710   if (output_bfd != NULL)
 711     return bfd_reloc_ok;
 712
 713   relocation = symbol->value
 714     + symbol->section->output_section->vma + symbol->section->output_offset;
 715
 716   if ((r =
 717        lm32_elf_final_gp (abfd, symbol, FALSE, msg, &gp)) == bfd_reloc_ok)
 718     {
 719       relocation = relocation + reloc_entry->addend - gp;
 720       reloc_entry->addend = 0;
 721       if ((signed) relocation < -32768 || (signed) relocation > 32767)
 722         {
 723           *msg = _("global pointer relative address out of range");
 724           r = bfd_reloc_outofrange;
 725         }
 726       else
 727         {
 728           r = lm32_elf_do_gprel_relocate (abfd, reloc_entry->howto,
 729                                              input_section,
 730                                              data, reloc_entry->address,
 731                                              relocation, reloc_entry->addend);
 732         }
 733     }
 734
 735   return r;
 736 }
 737
 738 /* Find the segment number in which OSEC, and output section, is
 739    located.  */
 740
 741 static unsigned
 742 _lm32fdpic_osec_to_segment (bfd *output_bfd, asection *osec)
 743 {
 744   struct elf_segment_map *m;
 745   Elf_Internal_Phdr *p;
 746
 747   /* Find the segment that contains the output_section.  */
 748   for (m = elf_seg_map (output_bfd), p = elf_tdata (output_bfd)->phdr;
 749        m != NULL;
 750        m = m->next, p++)
 751     {
 752       int i;
 753
 754       for (i = m->count - 1; i >= 0; i--)
 755         if (m->sections[i] == osec)
 756           break;
 757
 758       if (i >= 0)
 759         break;
 760     }
 761
 762   return p - elf_tdata (output_bfd)->phdr;
 763 }
 764
 765 /* Determine if an output section is read-only.  */
 766
 767 inline static bfd_boolean
 768 _lm32fdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
 769 {
 770   unsigned seg = _lm32fdpic_osec_to_segment (output_bfd, osec);
 771
 772   return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
 773 }
 774
 775 /* Relocate a section */
 776
 777 static bfd_boolean
 778 lm32_elf_relocate_section (bfd *output_bfd,
 779                            struct bfd_link_info *info,
 780                            bfd *input_bfd,
 781                            asection *input_section,
 782                            bfd_byte *contents,
 783                            Elf_Internal_Rela *relocs,
 784                            Elf_Internal_Sym *local_syms,
 785                            asection **local_sections)
 786 {
 787   Elf_Internal_Shdr *symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 788   struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
 789   Elf_Internal_Rela *rel, *relend;
 790   struct elf_lm32_link_hash_table *htab = lm32_elf_hash_table (info);
 791   bfd_vma *local_got_offsets;
 792   asection *sgot;
 793
 794   if (htab == NULL)
 795     return FALSE;
 796
 797   local_got_offsets = elf_local_got_offsets (input_bfd);
 798
 799   sgot = htab->root.sgot;
 800
 801   symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
 802   sym_hashes = elf_sym_hashes (input_bfd);
 803
 804   rel = relocs;
 805   relend = relocs + input_section->reloc_count;
 806   for (; rel < relend; rel++)
 807     {
 808       reloc_howto_type *howto;
 809       unsigned int r_type;
 810       unsigned long r_symndx;
 811       Elf_Internal_Sym *sym;
 812       asection *sec;
 813       struct elf_link_hash_entry *h;
 814       bfd_vma relocation;
 815       bfd_vma gp;
 816       bfd_reloc_status_type r;
 817       const char *name = NULL;
 818
 819       r_symndx = ELF32_R_SYM (rel->r_info);
 820       r_type = ELF32_R_TYPE (rel->r_info);
 821
 822       if (r_type == R_LM32_GNU_VTENTRY
 823           || r_type == R_LM32_GNU_VTINHERIT )
 824         continue;
 825
 826       h = NULL;
 827       sym = NULL;
 828       sec = NULL;
 829
 830       howto = lm32_elf_howto_table + r_type;
 831
 832       if (r_symndx < symtab_hdr->sh_info)
 833         {
 834           /* It's a local symbol.  */
 835           sym = local_syms + r_symndx;
 836           sec = local_sections[r_symndx];
 837           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
 838           name = bfd_elf_string_from_elf_section
 839             (input_bfd, symtab_hdr->sh_link, sym->st_name);
 840           name = (name == NULL) ? bfd_section_name (input_bfd, sec) : name;
 841         }
 842       else
 843         {
 844           /* It's a global symbol.  */
 845           bfd_boolean unresolved_reloc;
 846           bfd_boolean warned, ignored;
 847
 848           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
 849                                    r_symndx, symtab_hdr, sym_hashes,
 850                                    h, sec, relocation,
 851                                    unresolved_reloc, warned, ignored);
 852           name = h->root.root.string;
 853         }
 854
 855       if (sec != NULL && discarded_section (sec))
 856         RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
 857                                          rel, 1, relend, howto, 0, contents);
 858
 859       if (bfd_link_relocatable (info))
 860         {
 861           /* This is a relocatable link.  We don't have to change
 862              anything, unless the reloc is against a section symbol,
 863              in which case we have to adjust according to where the
 864              section symbol winds up in the output section.  */
 865           if (sym == NULL || ELF_ST_TYPE (sym->st_info) != STT_SECTION)
 866             continue;
 867
 868           /* If partial_inplace, we need to store any additional addend
 869              back in the section.  */
 870           if (! howto->partial_inplace)
 871             continue;
 872
 873           /* Shouldn't reach here.  */
 874           abort ();
 875           r = bfd_reloc_ok;
 876         }
 877       else
 878         {
 879           switch (howto->type)
 880             {
 881             case R_LM32_GPREL16:
 882               if (!lm32_elf_assign_gp (output_bfd, &gp))
 883                 r = bfd_reloc_dangerous;
 884               else
 885                 {
 886                   relocation = relocation + rel->r_addend - gp;
 887                   rel->r_addend = 0;
 888                   if ((signed)relocation < -32768 || (signed)relocation > 32767)
 889                     r = bfd_reloc_outofrange;
 890                   else
 891                     {
 892                       r = _bfd_final_link_relocate (howto, input_bfd,
 893                                                   input_section, contents,
 894                                           rel->r_offset, relocation,
 895                                           rel->r_addend);
 896                    }
 897                 }
 898               break;
 899             case R_LM32_16_GOT:
 900               /* Relocation is to the entry for this symbol in the global
 901                  offset table.  */
 902               BFD_ASSERT (sgot != NULL);
 903               if (h != NULL)
 904                 {
 905                   bfd_boolean dyn;
 906                   bfd_vma off;
 907
 908                   off = h->got.offset;
 909                   BFD_ASSERT (off != (bfd_vma) -1);
 910
 911                   dyn = htab->root.dynamic_sections_created;
 912                   if (! WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn,
 913                                                          bfd_link_pic (info),
 914                                                          h)
 915                       || (bfd_link_pic (info)
 916                           && (info->symbolic
 917                               || h->dynindx == -1
 918                               || h->forced_local)
 919                           && h->def_regular))
 920                     {
 921                       /* This is actually a static link, or it is a
 922                          -Bsymbolic link and the symbol is defined
 923                          locally, or the symbol was forced to be local
 924                          because of a version file.  We must initialize
 925                          this entry in the global offset table.  Since the
 926                          offset must always be a multiple of 4, we use the
 927                          least significant bit to record whether we have
 928                          initialized it already.
 929
 930                          When doing a dynamic link, we create a .rela.got
 931                          relocation entry to initialize the value.  This
 932                          is done in the finish_dynamic_symbol routine.  */
 933                       if ((off & 1) != 0)
 934                         off &= ~1;
 935                       else
 936                         {
 937                           /* Write entry in GOT */
 938                           bfd_put_32 (output_bfd, relocation,
 939                                       sgot->contents + off);
 940                           /* Create entry in .rofixup pointing to GOT entry.  */
 941                            if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
 942                              {
 943                                _lm32fdpic_add_rofixup (output_bfd,
 944                                                        lm32fdpic_fixup32_section
 945                                                         (info),
 946                                                        sgot->output_section->vma
 947                                                         + sgot->output_offset
 948                                                         + off);
 949                              }
 950                           /* Mark GOT entry as having been written.  */
 951                           h->got.offset |= 1;
 952                         }
 953                     }
 954
 955                   relocation = sgot->output_offset + off;
 956                 }
 957               else
 958                 {
 959                   bfd_vma off;
 960                   bfd_byte *loc;
 961
 962                   BFD_ASSERT (local_got_offsets != NULL
 963                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
 964
 965                   /* Get offset into GOT table.  */
 966                   off = local_got_offsets[r_symndx];
 967
 968                   /* The offset must always be a multiple of 4.  We use
 969                      the least significant bit to record whether we have
 970                      already processed this entry.  */
 971                   if ((off & 1) != 0)
 972                     off &= ~1;
 973                   else
 974                     {
 975                       /* Write entry in GOT.  */
 976                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
 977                       /* Create entry in .rofixup pointing to GOT entry.  */
 978                       if (IS_FDPIC (output_bfd))
 979                         {
 980                           _lm32fdpic_add_rofixup (output_bfd,
 981                                                   lm32fdpic_fixup32_section
 982                                                    (info),
 983                                                   sgot->output_section->vma
 984                                                    + sgot->output_offset
 985                                                    + off);
 986                         }
 987
 988                       if (bfd_link_pic (info))
 989                         {
 990                           asection *srelgot;
 991                           Elf_Internal_Rela outrel;
 992
 993                           /* We need to generate a R_LM32_RELATIVE reloc
 994                              for the dynamic linker.  */
 995                           srelgot = htab->root.srelgot;
 996                           BFD_ASSERT (srelgot != NULL);
 997
 998                           outrel.r_offset = (sgot->output_section->vma
 999                                              + sgot->output_offset
1000                                              + off);
1001                           outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1002                           outrel.r_addend = relocation;
1003                           loc = srelgot->contents;
1004                           loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1005                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1006                           ++srelgot->reloc_count;
1007                         }
1008
1009                       local_got_offsets[r_symndx] |= 1;
1010                     }
1011
1012
1013                   relocation = sgot->output_offset + off;
1014                 }
1015
1016               /* Addend should be zero.  */
1017               if (rel->r_addend != 0)
1018                 _bfd_error_handler (_("internal error: addend should be zero for R_LM32_16_GOT"));
1019
1020               r = _bfd_final_link_relocate (howto,
1021                                             input_bfd,
1022                                             input_section,
1023                                             contents,
1024                                             rel->r_offset,
1025                                             relocation,
1026                                             rel->r_addend);
1027               break;
1028
1029             case R_LM32_GOTOFF_LO16:
1030             case R_LM32_GOTOFF_HI16:
1031               /* Relocation is offset from GOT.  */
1032               BFD_ASSERT (sgot != NULL);
1033               relocation -= sgot->output_section->vma;
1034               /* Account for sign-extension.  */
1035               if ((r_type == R_LM32_GOTOFF_HI16)
1036                   && ((relocation + rel->r_addend) & 0x8000))
1037                 rel->r_addend += 0x10000;
1038               r = _bfd_final_link_relocate (howto,
1039                                             input_bfd,
1040                                             input_section,
1041                                             contents,
1042                                             rel->r_offset,
1043                                             relocation,
1044                                             rel->r_addend);
1045               break;
1046
1047             case R_LM32_32:
1048               if (IS_FDPIC (output_bfd))
1049                 {
1050                   if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1051                     {
1052                       /* Only create .rofixup entries for relocs in loadable sections.  */
1053                       if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1054                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1055
1056                         {
1057                           /* Check address to be modified is writable.  */
1058                           if (_lm32fdpic_osec_readonly_p (output_bfd,
1059                                                           input_section
1060                                                            ->output_section))
1061                             {
1062                               info->callbacks->warning
1063                                 (info,
1064                                  _("cannot emit dynamic relocations in read-only section"),
1065                                  name, input_bfd, input_section, rel->r_offset);
1066                                return FALSE;
1067                             }
1068                           /* Create entry in .rofixup section.  */
1069                           _lm32fdpic_add_rofixup (output_bfd,
1070                                                   lm32fdpic_fixup32_section (info),
1071                                                   input_section->output_section->vma
1072                                                    + input_section->output_offset
1073                                                    + rel->r_offset);
1074                         }
1075                     }
1076                 }
1077               /* Fall through.  */
1078
1079             default:
1080               r = _bfd_final_link_relocate (howto,
1081                                             input_bfd,
1082                                             input_section,
1083                                             contents,
1084                                             rel->r_offset,
1085                                             relocation,
1086                                             rel->r_addend);
1087               break;
1088             }
1089         }
1090
1091       if (r != bfd_reloc_ok)
1092         {
1093           const char *msg = NULL;
1094           arelent bfd_reloc;
1095
1096           lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1097           howto = bfd_reloc.howto;
1098
1099           if (h != NULL)
1100             name = h->root.root.string;
1101           else
1102             {
1103               name = (bfd_elf_string_from_elf_section
1104                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1105               if (name == NULL || *name == '\0')
1106                 name = bfd_section_name (input_bfd, sec);
1107             }
1108
1109           switch (r)
1110             {
1111             case bfd_reloc_overflow:
1112               if ((h != NULL)
1113                  && (h->root.type == bfd_link_hash_undefweak))
1114                 break;
1115               (*info->callbacks->reloc_overflow)
1116                 (info, (h ? &h->root : NULL), name, howto->name,
1117                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1118               break;
1119
1120             case bfd_reloc_undefined:
1121               (*info->callbacks->undefined_symbol)
1122                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1123               break;
1124
1125             case bfd_reloc_outofrange:
1126               msg = _("internal error: out of range error");
1127               goto common_error;
1128
1129             case bfd_reloc_notsupported:
1130               msg = _("internal error: unsupported relocation error");
1131               goto common_error;
1132
1133             case bfd_reloc_dangerous:
1134               msg = _("internal error: dangerous error");
1135               goto common_error;
1136
1137             default:
1138               msg = _("internal error: unknown error");
1139               /* fall through */
1140
1141             common_error:
1142               (*info->callbacks->warning) (info, msg, name, input_bfd,
1143                                            input_section, rel->r_offset);
1144               break;
1145             }
1146         }
1147     }
1148
1149   return TRUE;
1150 }
1151
1152 static asection *
1153 lm32_elf_gc_mark_hook (asection *sec,
1154                        struct bfd_link_info *info,
1155                        Elf_Internal_Rela *rel,
1156                        struct elf_link_hash_entry *h,
1157                        Elf_Internal_Sym *sym)
1158 {
1159   if (h != NULL)
1160     switch (ELF32_R_TYPE (rel->r_info))
1161       {
1162       case R_LM32_GNU_VTINHERIT:
1163       case R_LM32_GNU_VTENTRY:
1164         return NULL;
1165       }
1166
1167   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1168 }
1169
1170 static bfd_boolean
1171 lm32_elf_gc_sweep_hook (bfd *abfd,
1172                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
1173                         asection *sec,
1174                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1175 {
1176   /* Update the got entry reference counts for the section being removed.  */
1177   Elf_Internal_Shdr *symtab_hdr;
1178   struct elf_link_hash_entry **sym_hashes;
1179   bfd_signed_vma *local_got_refcounts;
1180   const Elf_Internal_Rela *rel, *relend;
1181
1182   elf_section_data (sec)->local_dynrel = NULL;
1183
1184   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1185   sym_hashes = elf_sym_hashes (abfd);
1186   local_got_refcounts = elf_local_got_refcounts (abfd);
1187
1188   relend = relocs + sec->reloc_count;
1189   for (rel = relocs; rel < relend; rel++)
1190     {
1191       unsigned long r_symndx;
1192       struct elf_link_hash_entry *h = NULL;
1193
1194       r_symndx = ELF32_R_SYM (rel->r_info);
1195       if (r_symndx >= symtab_hdr->sh_info)
1196         {
1197           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1198           while (h->root.type == bfd_link_hash_indirect
1199                  || h->root.type == bfd_link_hash_warning)
1200             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1201         }
1202
1203       switch (ELF32_R_TYPE (rel->r_info))
1204         {
1205         case R_LM32_16_GOT:
1206           if (h != NULL)
1207             {
1208               if (h->got.refcount > 0)
1209                 h->got.refcount--;
1210             }
1211           else
1212             {
1213               if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1214                 local_got_refcounts[r_symndx]--;
1215             }
1216           break;
1217
1218         default:
1219           break;
1220         }
1221     }
1222   return TRUE;
1223 }
1224
1225 /* Look through the relocs for a section during the first phase.  */
1226
1227 static bfd_boolean
1228 lm32_elf_check_relocs (bfd *abfd,
1229                        struct bfd_link_info *info,
1230                        asection *sec,
1231                        const Elf_Internal_Rela *relocs)
1232 {
1233   Elf_Internal_Shdr *symtab_hdr;
1234   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1235   const Elf_Internal_Rela *rel;
1236   const Elf_Internal_Rela *rel_end;
1237   struct elf_lm32_link_hash_table *htab;
1238   bfd *dynobj;
1239
1240   if (bfd_link_relocatable (info))
1241     return TRUE;
1242
1243   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1244   sym_hashes = elf_sym_hashes (abfd);
1245   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1246   if (!elf_bad_symtab (abfd))
1247     sym_hashes_end -= symtab_hdr->sh_info;
1248
1249   htab = lm32_elf_hash_table (info);
1250   if (htab == NULL)
1251     return FALSE;
1252
1253   dynobj = htab->root.dynobj;
1254
1255   rel_end = relocs + sec->reloc_count;
1256   for (rel = relocs; rel < rel_end; rel++)
1257     {
1258       int r_type;
1259       struct elf_link_hash_entry *h;
1260       unsigned long r_symndx;
1261
1262       r_symndx = ELF32_R_SYM (rel->r_info);
1263       r_type = ELF32_R_TYPE (rel->r_info);
1264       if (r_symndx < symtab_hdr->sh_info)
1265         h = NULL;
1266       else
1267         {
1268           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1269           while (h->root.type == bfd_link_hash_indirect
1270                  || h->root.type == bfd_link_hash_warning)
1271             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1272
1273           /* PR15323, ref flags aren't set for references in the same
1274              object.  */
1275           h->root.non_ir_ref = 1;
1276         }
1277
1278       /* Some relocs require a global offset table.  */
1279       if (htab->root.sgot == NULL)
1280         {
1281           switch (r_type)
1282             {
1283             case R_LM32_16_GOT:
1284             case R_LM32_GOTOFF_HI16:
1285             case R_LM32_GOTOFF_LO16:
1286               if (dynobj == NULL)
1287                 htab->root.dynobj = dynobj = abfd;
1288               if (!_bfd_elf_create_got_section (dynobj, info))
1289                 return FALSE;
1290               break;
1291             }
1292         }
1293
1294       /* Some relocs require a rofixup table. */
1295       if (IS_FDPIC (abfd))
1296         {
1297           switch (r_type)
1298             {
1299             case R_LM32_32:
1300               /* FDPIC requires a GOT if there is a .rofixup section
1301                  (Normal ELF doesn't). */
1302               if (dynobj == NULL)
1303                 htab->root.dynobj = dynobj = abfd;
1304               if (!_bfd_elf_create_got_section (dynobj, info))
1305                 return FALSE;
1306               /* Create .rofixup section */
1307               if (htab->sfixup32 == NULL)
1308                 {
1309                   if (! create_rofixup_section (dynobj, info))
1310                     return FALSE;
1311                 }
1312               break;
1313             case R_LM32_16_GOT:
1314             case R_LM32_GOTOFF_HI16:
1315             case R_LM32_GOTOFF_LO16:
1316               /* Create .rofixup section.  */
1317               if (htab->sfixup32 == NULL)
1318                 {
1319                   if (dynobj == NULL)
1320                     htab->root.dynobj = dynobj = abfd;
1321                   if (! create_rofixup_section (dynobj, info))
1322                     return FALSE;
1323                 }
1324               break;
1325             }
1326         }
1327
1328       switch (r_type)
1329         {
1330         case R_LM32_16_GOT:
1331           if (h != NULL)
1332             h->got.refcount += 1;
1333           else
1334             {
1335               bfd_signed_vma *local_got_refcounts;
1336
1337               /* This is a global offset table entry for a local symbol.  */
1338               local_got_refcounts = elf_local_got_refcounts (abfd);
1339               if (local_got_refcounts == NULL)
1340                 {
1341                   bfd_size_type size;
1342
1343                   size = symtab_hdr->sh_info;
1344                   size *= sizeof (bfd_signed_vma);
1345                   local_got_refcounts = bfd_zalloc (abfd, size);
1346                   if (local_got_refcounts == NULL)
1347                     return FALSE;
1348                   elf_local_got_refcounts (abfd) = local_got_refcounts;
1349                 }
1350               local_got_refcounts[r_symndx] += 1;
1351             }
1352           break;
1353
1354         /* This relocation describes the C++ object vtable hierarchy.
1355            Reconstruct it for later use during GC.  */
1356         case R_LM32_GNU_VTINHERIT:
1357           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1358             return FALSE;
1359           break;
1360
1361         /* This relocation describes which C++ vtable entries are actually
1362            used.  Record for later use during GC.  */
1363         case R_LM32_GNU_VTENTRY:
1364           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1365             return FALSE;
1366           break;
1367
1368         }
1369     }
1370
1371   return TRUE;
1372 }
1373
1374 /* Finish up the dynamic sections.  */
1375
1376 static bfd_boolean
1377 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1378                                   struct bfd_link_info *info)
1379 {
1380   struct elf_lm32_link_hash_table *htab;
1381   bfd *dynobj;
1382   asection *sdyn;
1383   asection *sgot;
1384
1385   htab = lm32_elf_hash_table (info);
1386   if (htab == NULL)
1387     return FALSE;
1388
1389   dynobj = htab->root.dynobj;
1390
1391   sgot = htab->root.sgotplt;
1392   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1393
1394   if (htab->root.dynamic_sections_created)
1395     {
1396       asection *splt;
1397       Elf32_External_Dyn *dyncon, *dynconend;
1398
1399       BFD_ASSERT (sgot != NULL && sdyn != NULL);
1400
1401       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1402       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1403
1404       for (; dyncon < dynconend; dyncon++)
1405         {
1406           Elf_Internal_Dyn dyn;
1407           asection *s;
1408
1409           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1410
1411           switch (dyn.d_tag)
1412             {
1413             default:
1414               break;
1415
1416             case DT_PLTGOT:
1417               s = htab->root.sgotplt;
1418               goto get_vma;
1419             case DT_JMPREL:
1420               s = htab->root.srelplt;
1421             get_vma:
1422               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1423               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1424               break;
1425
1426             case DT_PLTRELSZ:
1427               s = htab->root.srelplt;
1428               dyn.d_un.d_val = s->size;
1429               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1430               break;
1431
1432             case DT_RELASZ:
1433               /* My reading of the SVR4 ABI indicates that the
1434                  procedure linkage table relocs (DT_JMPREL) should be
1435                  included in the overall relocs (DT_RELA).  This is
1436                  what Solaris does.  However, UnixWare can not handle
1437                  that case.  Therefore, we override the DT_RELASZ entry
1438                  here to make it not include the JMPREL relocs.  Since
1439                  the linker script arranges for .rela.plt to follow all
1440                  other relocation sections, we don't have to worry
1441                  about changing the DT_RELA entry.  */
1442               if (htab->root.srelplt != NULL)
1443                 {
1444                   s = htab->root.srelplt;
1445                   dyn.d_un.d_val -= s->size;
1446                 }
1447               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1448               break;
1449             }
1450         }
1451
1452       /* Fill in the first entry in the procedure linkage table.  */
1453       splt = htab->root.splt;
1454       if (splt && splt->size > 0)
1455         {
1456           if (bfd_link_pic (info))
1457             {
1458               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1459               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1460               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1461               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1462               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1463             }
1464           else
1465             {
1466               unsigned long addr;
1467               /* addr = .got + 4 */
1468               addr = sgot->output_section->vma + sgot->output_offset + 4;
1469               bfd_put_32 (output_bfd,
1470                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1471                           splt->contents);
1472               bfd_put_32 (output_bfd,
1473                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
1474                           splt->contents + 4);
1475               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1476               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1477               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1478             }
1479
1480           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1481             PLT_ENTRY_SIZE;
1482         }
1483     }
1484
1485   /* Fill in the first three entries in the global offset table.  */
1486   if (sgot && sgot->size > 0)
1487     {
1488       if (sdyn == NULL)
1489         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1490       else
1491         bfd_put_32 (output_bfd,
1492                     sdyn->output_section->vma + sdyn->output_offset,
1493                     sgot->contents);
1494       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1495       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1496
1497       /* FIXME:  This can be null if create_dynamic_sections wasn't called. */
1498       if (elf_section_data (sgot->output_section) != NULL)
1499         elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1500     }
1501
1502   if (lm32fdpic_fixup32_section (info))
1503     {
1504       struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1505       bfd_vma got_value = hgot->root.u.def.value
1506             + hgot->root.u.def.section->output_section->vma
1507             + hgot->root.u.def.section->output_offset;
1508       struct bfd_link_hash_entry *hend;
1509
1510       /* Last entry is pointer to GOT.  */
1511       _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1512
1513       /* Check we wrote enough entries.  */
1514       if (lm32fdpic_fixup32_section (info)->size
1515               != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1516         {
1517           _bfd_error_handler
1518             ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1519             lm32fdpic_fixup32_section (info)->size/4,
1520             lm32fdpic_fixup32_section (info)->reloc_count);
1521           return FALSE;
1522         }
1523
1524       hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1525               FALSE, FALSE, TRUE);
1526       if (hend
1527           && (hend->type == bfd_link_hash_defined
1528               || hend->type == bfd_link_hash_defweak))
1529         {
1530           bfd_vma value =
1531             lm32fdpic_fixup32_section (info)->output_section->vma
1532             + lm32fdpic_fixup32_section (info)->output_offset
1533             + lm32fdpic_fixup32_section (info)->size
1534             - hend->u.def.section->output_section->vma
1535             - hend->u.def.section->output_offset;
1536           BFD_ASSERT (hend->u.def.value == value);
1537           if (hend->u.def.value != value)
1538             {
1539               _bfd_error_handler
1540                 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1541               return FALSE;
1542             }
1543         }
1544     }
1545
1546   return TRUE;
1547 }
1548
1549 /* Finish up dynamic symbol handling.  We set the contents of various
1550    dynamic sections here.  */
1551
1552 static bfd_boolean
1553 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1554                                 struct bfd_link_info *info,
1555                                 struct elf_link_hash_entry *h,
1556                                 Elf_Internal_Sym *sym)
1557 {
1558   struct elf_lm32_link_hash_table *htab;
1559   bfd_byte *loc;
1560
1561   htab = lm32_elf_hash_table (info);
1562   if (htab == NULL)
1563     return FALSE;
1564
1565   if (h->plt.offset != (bfd_vma) -1)
1566     {
1567       asection *splt;
1568       asection *sgot;
1569       asection *srela;
1570
1571       bfd_vma plt_index;
1572       bfd_vma got_offset;
1573       Elf_Internal_Rela rela;
1574
1575       /* This symbol has an entry in the procedure linkage table.  Set
1576          it up.  */
1577       BFD_ASSERT (h->dynindx != -1);
1578
1579       splt = htab->root.splt;
1580       sgot = htab->root.sgotplt;
1581       srela = htab->root.srelplt;
1582       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1583
1584       /* Get the index in the procedure linkage table which
1585          corresponds to this symbol.  This is the index of this symbol
1586          in all the symbols for which we are making plt entries.  The
1587          first entry in the procedure linkage table is reserved.  */
1588       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1589
1590       /* Get the offset into the .got table of the entry that
1591         corresponds to this function.  Each .got entry is 4 bytes.
1592         The first three are reserved.  */
1593       got_offset = (plt_index + 3) * 4;
1594
1595       /* Fill in the entry in the procedure linkage table.  */
1596       if (! bfd_link_pic (info))
1597         {
1598           /* TODO */
1599         }
1600       else
1601         {
1602           /* TODO */
1603         }
1604
1605       /* Fill in the entry in the global offset table.  */
1606       bfd_put_32 (output_bfd,
1607                   (splt->output_section->vma
1608                    + splt->output_offset
1609                    + h->plt.offset
1610                    + 12), /* same offset */
1611                   sgot->contents + got_offset);
1612
1613       /* Fill in the entry in the .rela.plt section.  */
1614       rela.r_offset = (sgot->output_section->vma
1615                        + sgot->output_offset
1616                        + got_offset);
1617       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1618       rela.r_addend = 0;
1619       loc = srela->contents;
1620       loc += plt_index * sizeof (Elf32_External_Rela);
1621       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1622
1623       if (!h->def_regular)
1624         {
1625           /* Mark the symbol as undefined, rather than as defined in
1626              the .plt section.  Leave the value alone.  */
1627           sym->st_shndx = SHN_UNDEF;
1628         }
1629
1630     }
1631
1632   if (h->got.offset != (bfd_vma) -1)
1633     {
1634       asection *sgot;
1635       asection *srela;
1636       Elf_Internal_Rela rela;
1637
1638       /* This symbol has an entry in the global offset table.  Set it
1639          up.  */
1640       sgot = htab->root.sgot;
1641       srela = htab->root.srelgot;
1642       BFD_ASSERT (sgot != NULL && srela != NULL);
1643
1644       rela.r_offset = (sgot->output_section->vma
1645                        + sgot->output_offset
1646                        + (h->got.offset &~ 1));
1647
1648       /* If this is a -Bsymbolic link, and the symbol is defined
1649          locally, we just want to emit a RELATIVE reloc.  Likewise if
1650          the symbol was forced to be local because of a version file.
1651          The entry in the global offset table will already have been
1652          initialized in the relocate_section function.  */
1653       if (bfd_link_pic (info)
1654           && (info->symbolic
1655               || h->dynindx == -1
1656               || h->forced_local)
1657           && h->def_regular)
1658         {
1659           rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1660           rela.r_addend = (h->root.u.def.value
1661                            + h->root.u.def.section->output_section->vma
1662                            + h->root.u.def.section->output_offset);
1663         }
1664       else
1665         {
1666           BFD_ASSERT ((h->got.offset & 1) == 0);
1667           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1668           rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1669           rela.r_addend = 0;
1670         }
1671
1672       loc = srela->contents;
1673       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1674       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1675       ++srela->reloc_count;
1676     }
1677
1678   if (h->needs_copy)
1679     {
1680       asection *s;
1681       Elf_Internal_Rela rela;
1682
1683       /* This symbols needs a copy reloc.  Set it up.  */
1684       BFD_ASSERT (h->dynindx != -1
1685                   && (h->root.type == bfd_link_hash_defined
1686                       || h->root.type == bfd_link_hash_defweak));
1687
1688       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1689       BFD_ASSERT (s != NULL);
1690
1691       rela.r_offset = (h->root.u.def.value
1692                        + h->root.u.def.section->output_section->vma
1693                        + h->root.u.def.section->output_offset);
1694       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1695       rela.r_addend = 0;
1696       loc = s->contents;
1697       loc += s->reloc_count * sizeof (Elf32_External_Rela);
1698       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1699       ++s->reloc_count;
1700     }
1701
1702   /* Mark some specially defined symbols as absolute.  */
1703   if (h == htab->root.hdynamic || h == htab->root.hgot)
1704     sym->st_shndx = SHN_ABS;
1705
1706   return TRUE;
1707 }
1708
1709 static enum elf_reloc_type_class
1710 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1711                            const asection *rel_sec ATTRIBUTE_UNUSED,
1712                            const Elf_Internal_Rela *rela)
1713 {
1714   switch ((int) ELF32_R_TYPE (rela->r_info))
1715     {
1716     case R_LM32_RELATIVE:  return reloc_class_relative;
1717     case R_LM32_JMP_SLOT:  return reloc_class_plt;
1718     case R_LM32_COPY:      return reloc_class_copy;
1719     default:               return reloc_class_normal;
1720     }
1721 }
1722
1723 /* Adjust a symbol defined by a dynamic object and referenced by a
1724    regular object.  The current definition is in some section of the
1725    dynamic object, but we're not including those sections.  We have to
1726    change the definition to something the rest of the link can
1727    understand.  */
1728
1729 static bfd_boolean
1730 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1731                                 struct elf_link_hash_entry *h)
1732 {
1733   struct elf_lm32_link_hash_table *htab;
1734   struct elf_lm32_link_hash_entry *eh;
1735   struct elf_lm32_dyn_relocs *p;
1736   bfd *dynobj;
1737   asection *s;
1738
1739   dynobj = elf_hash_table (info)->dynobj;
1740
1741   /* Make sure we know what is going on here.  */
1742   BFD_ASSERT (dynobj != NULL
1743               && (h->needs_plt
1744                   || h->u.weakdef != NULL
1745                   || (h->def_dynamic
1746                       && h->ref_regular
1747                       && !h->def_regular)));
1748
1749   /* If this is a function, put it in the procedure linkage table.  We
1750      will fill in the contents of the procedure linkage table later,
1751      when we know the address of the .got section.  */
1752   if (h->type == STT_FUNC
1753       || h->needs_plt)
1754     {
1755       if (! bfd_link_pic (info)
1756           && !h->def_dynamic
1757           && !h->ref_dynamic
1758           && h->root.type != bfd_link_hash_undefweak
1759           && h->root.type != bfd_link_hash_undefined)
1760         {
1761           /* This case can occur if we saw a PLT reloc in an input
1762              file, but the symbol was never referred to by a dynamic
1763              object.  In such a case, we don't actually need to build
1764              a procedure linkage table, and we can just do a PCREL
1765              reloc instead.  */
1766           h->plt.offset = (bfd_vma) -1;
1767           h->needs_plt = 0;
1768         }
1769
1770       return TRUE;
1771     }
1772   else
1773     h->plt.offset = (bfd_vma) -1;
1774
1775   /* If this is a weak symbol, and there is a real definition, the
1776      processor independent code will have arranged for us to see the
1777      real definition first, and we can just use the same value.  */
1778   if (h->u.weakdef != NULL)
1779     {
1780       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1781                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1782       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1783       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1784       return TRUE;
1785     }
1786
1787   /* This is a reference to a symbol defined by a dynamic object which
1788      is not a function.  */
1789
1790   /* If we are creating a shared library, we must presume that the
1791      only references to the symbol are via the global offset table.
1792      For such cases we need not do anything here; the relocations will
1793      be handled correctly by relocate_section.  */
1794   if (bfd_link_pic (info))
1795     return TRUE;
1796
1797   /* If there are no references to this symbol that do not use the
1798      GOT, we don't need to generate a copy reloc.  */
1799   if (!h->non_got_ref)
1800     return TRUE;
1801
1802   /* If -z nocopyreloc was given, we won't generate them either.  */
1803   if (info->nocopyreloc)
1804     {
1805       h->non_got_ref = 0;
1806       return TRUE;
1807     }
1808
1809   eh = (struct elf_lm32_link_hash_entry *) h;
1810   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1811     {
1812       s = p->sec->output_section;
1813       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1814         break;
1815     }
1816
1817   /* If we didn't find any dynamic relocs in sections which needs the
1818      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1819      the copy reloc.  */
1820   if (p == NULL)
1821     {
1822       h->non_got_ref = 0;
1823       return TRUE;
1824     }
1825
1826   /* We must allocate the symbol in our .dynbss section, which will
1827      become part of the .bss section of the executable.  There will be
1828      an entry for this symbol in the .dynsym section.  The dynamic
1829      object will contain position independent code, so all references
1830      from the dynamic object to this symbol will go through the global
1831      offset table.  The dynamic linker will use the .dynsym entry to
1832      determine the address it must put in the global offset table, so
1833      both the dynamic object and the regular object will refer to the
1834      same memory location for the variable.  */
1835
1836   htab = lm32_elf_hash_table (info);
1837   if (htab == NULL)
1838     return FALSE;
1839
1840   s = htab->sdynbss;
1841   BFD_ASSERT (s != NULL);
1842
1843   /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1844      to copy the initial value out of the dynamic object and into the
1845      runtime process image.  We need to remember the offset into the
1846      .rela.bss section we are going to use.  */
1847   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1848     {
1849       asection *srel;
1850
1851       srel = htab->srelbss;
1852       BFD_ASSERT (srel != NULL);
1853       srel->size += sizeof (Elf32_External_Rela);
1854       h->needs_copy = 1;
1855     }
1856
1857   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1858 }
1859
1860 /* Allocate space in .plt, .got and associated reloc sections for
1861    dynamic relocs.  */
1862
1863 static bfd_boolean
1864 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1865 {
1866   struct bfd_link_info *info;
1867   struct elf_lm32_link_hash_table *htab;
1868   struct elf_lm32_link_hash_entry *eh;
1869   struct elf_lm32_dyn_relocs *p;
1870
1871   if (h->root.type == bfd_link_hash_indirect)
1872     return TRUE;
1873
1874   info = (struct bfd_link_info *) inf;
1875   htab = lm32_elf_hash_table (info);
1876   if (htab == NULL)
1877     return FALSE;
1878
1879   eh = (struct elf_lm32_link_hash_entry *) h;
1880
1881   if (htab->root.dynamic_sections_created
1882       && h->plt.refcount > 0)
1883     {
1884       /* Make sure this symbol is output as a dynamic symbol.
1885          Undefined weak syms won't yet be marked as dynamic.  */
1886       if (h->dynindx == -1
1887           && !h->forced_local)
1888         {
1889           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1890             return FALSE;
1891         }
1892
1893       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1894         {
1895           asection *s = htab->root.splt;
1896
1897           /* If this is the first .plt entry, make room for the special
1898              first entry.  */
1899           if (s->size == 0)
1900             s->size += PLT_ENTRY_SIZE;
1901
1902           h->plt.offset = s->size;
1903
1904           /* If this symbol is not defined in a regular file, and we are
1905              not generating a shared library, then set the symbol to this
1906              location in the .plt.  This is required to make function
1907              pointers compare as equal between the normal executable and
1908              the shared library.  */
1909           if (! bfd_link_pic (info)
1910               && !h->def_regular)
1911             {
1912               h->root.u.def.section = s;
1913               h->root.u.def.value = h->plt.offset;
1914             }
1915
1916           /* Make room for this entry.  */
1917           s->size += PLT_ENTRY_SIZE;
1918
1919           /* We also need to make an entry in the .got.plt section, which
1920              will be placed in the .got section by the linker script.  */
1921           htab->root.sgotplt->size += 4;
1922
1923           /* We also need to make an entry in the .rel.plt section.  */
1924           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1925         }
1926       else
1927         {
1928           h->plt.offset = (bfd_vma) -1;
1929           h->needs_plt = 0;
1930         }
1931     }
1932   else
1933     {
1934       h->plt.offset = (bfd_vma) -1;
1935       h->needs_plt = 0;
1936     }
1937
1938   if (h->got.refcount > 0)
1939     {
1940       asection *s;
1941       bfd_boolean dyn;
1942
1943       /* Make sure this symbol is output as a dynamic symbol.
1944          Undefined weak syms won't yet be marked as dynamic.  */
1945       if (h->dynindx == -1
1946           && !h->forced_local)
1947         {
1948           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1949             return FALSE;
1950         }
1951
1952       s = htab->root.sgot;
1953
1954       h->got.offset = s->size;
1955       s->size += 4;
1956       dyn = htab->root.dynamic_sections_created;
1957       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1958         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1959     }
1960   else
1961     h->got.offset = (bfd_vma) -1;
1962
1963   if (eh->dyn_relocs == NULL)
1964     return TRUE;
1965
1966   /* In the shared -Bsymbolic case, discard space allocated for
1967      dynamic pc-relative relocs against symbols which turn out to be
1968      defined in regular objects.  For the normal shared case, discard
1969      space for pc-relative relocs that have become local due to symbol
1970      visibility changes.  */
1971
1972   if (bfd_link_pic (info))
1973     {
1974       if (h->def_regular
1975           && (h->forced_local
1976               || info->symbolic))
1977         {
1978           struct elf_lm32_dyn_relocs **pp;
1979
1980           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1981             {
1982               p->count -= p->pc_count;
1983               p->pc_count = 0;
1984               if (p->count == 0)
1985                 *pp = p->next;
1986               else
1987                 pp = &p->next;
1988             }
1989         }
1990
1991       /* Also discard relocs on undefined weak syms with non-default
1992          visibility.  */
1993       if (eh->dyn_relocs != NULL
1994           && h->root.type == bfd_link_hash_undefweak)
1995         {
1996           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1997             eh->dyn_relocs = NULL;
1998
1999           /* Make sure undefined weak symbols are output as a dynamic
2000              symbol in PIEs.  */
2001           else if (h->dynindx == -1
2002                    && !h->forced_local)
2003             {
2004               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2005                 return FALSE;
2006             }
2007         }
2008     }
2009   else
2010     {
2011       /* For the non-shared case, discard space for relocs against
2012          symbols which turn out to need copy relocs or are not
2013          dynamic.  */
2014
2015       if (!h->non_got_ref
2016           && ((h->def_dynamic
2017                && !h->def_regular)
2018               || (htab->root.dynamic_sections_created
2019                   && (h->root.type == bfd_link_hash_undefweak
2020                       || h->root.type == bfd_link_hash_undefined))))
2021         {
2022           /* Make sure this symbol is output as a dynamic symbol.
2023              Undefined weak syms won't yet be marked as dynamic.  */
2024           if (h->dynindx == -1
2025               && !h->forced_local)
2026             {
2027               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2028                 return FALSE;
2029             }
2030
2031           /* If that succeeded, we know we'll be keeping all the
2032              relocs.  */
2033           if (h->dynindx != -1)
2034             goto keep;
2035         }
2036
2037       eh->dyn_relocs = NULL;
2038
2039     keep: ;
2040     }
2041
2042   /* Finally, allocate space.  */
2043   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2044     {
2045       asection *sreloc = elf_section_data (p->sec)->sreloc;
2046       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2047     }
2048
2049   return TRUE;
2050 }
2051
2052 /* Find any dynamic relocs that apply to read-only sections.  */
2053
2054 static bfd_boolean
2055 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2056 {
2057   struct elf_lm32_link_hash_entry *eh;
2058   struct elf_lm32_dyn_relocs *p;
2059
2060   eh = (struct elf_lm32_link_hash_entry *) h;
2061   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2062     {
2063       asection *s = p->sec->output_section;
2064
2065       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2066         {
2067           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2068
2069           info->flags |= DF_TEXTREL;
2070
2071           /* Not an error, just cut short the traversal.  */
2072           return FALSE;
2073         }
2074     }
2075   return TRUE;
2076 }
2077
2078 /* Set the sizes of the dynamic sections.  */
2079
2080 static bfd_boolean
2081 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2082                                 struct bfd_link_info *info)
2083 {
2084   struct elf_lm32_link_hash_table *htab;
2085   bfd *dynobj;
2086   asection *s;
2087   bfd_boolean relocs;
2088   bfd *ibfd;
2089
2090   htab = lm32_elf_hash_table (info);
2091   if (htab == NULL)
2092     return FALSE;
2093
2094   dynobj = htab->root.dynobj;
2095   BFD_ASSERT (dynobj != NULL);
2096
2097   if (htab->root.dynamic_sections_created)
2098     {
2099       /* Set the contents of the .interp section to the interpreter.  */
2100       if (bfd_link_executable (info) && !info->nointerp)
2101         {
2102           s = bfd_get_linker_section (dynobj, ".interp");
2103           BFD_ASSERT (s != NULL);
2104           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2105           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2106         }
2107     }
2108
2109   /* Set up .got offsets for local syms, and space for local dynamic
2110      relocs.  */
2111   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2112     {
2113       bfd_signed_vma *local_got;
2114       bfd_signed_vma *end_local_got;
2115       bfd_size_type locsymcount;
2116       Elf_Internal_Shdr *symtab_hdr;
2117       asection *srel;
2118
2119       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2120         continue;
2121
2122       for (s = ibfd->sections; s != NULL; s = s->next)
2123         {
2124           struct elf_lm32_dyn_relocs *p;
2125
2126           for (p = ((struct elf_lm32_dyn_relocs *)
2127                     elf_section_data (s)->local_dynrel);
2128                p != NULL;
2129                p = p->next)
2130             {
2131               if (! bfd_is_abs_section (p->sec)
2132                   && bfd_is_abs_section (p->sec->output_section))
2133                 {
2134                   /* Input section has been discarded, either because
2135                      it is a copy of a linkonce section or due to
2136                      linker script /DISCARD/, so we'll be discarding
2137                      the relocs too.  */
2138                 }
2139               else if (p->count != 0)
2140                 {
2141                   srel = elf_section_data (p->sec)->sreloc;
2142                   srel->size += p->count * sizeof (Elf32_External_Rela);
2143                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2144                     info->flags |= DF_TEXTREL;
2145                 }
2146             }
2147         }
2148
2149       local_got = elf_local_got_refcounts (ibfd);
2150       if (!local_got)
2151         continue;
2152
2153       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2154       locsymcount = symtab_hdr->sh_info;
2155       end_local_got = local_got + locsymcount;
2156       s = htab->root.sgot;
2157       srel = htab->root.srelgot;
2158       for (; local_got < end_local_got; ++local_got)
2159         {
2160           if (*local_got > 0)
2161             {
2162               *local_got = s->size;
2163               s->size += 4;
2164               if (bfd_link_pic (info))
2165                 srel->size += sizeof (Elf32_External_Rela);
2166             }
2167           else
2168             *local_got = (bfd_vma) -1;
2169         }
2170     }
2171
2172   /* Allocate global sym .plt and .got entries, and space for global
2173      sym dynamic relocs.  */
2174   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2175
2176   /* We now have determined the sizes of the various dynamic sections.
2177      Allocate memory for them.  */
2178   relocs = FALSE;
2179   for (s = dynobj->sections; s != NULL; s = s->next)
2180     {
2181       if ((s->flags & SEC_LINKER_CREATED) == 0)
2182         continue;
2183
2184       if (s == htab->root.splt
2185           || s == htab->root.sgot
2186           || s == htab->root.sgotplt
2187           || s == htab->sdynbss)
2188         {
2189           /* Strip this section if we don't need it; see the
2190              comment below.  */
2191         }
2192       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2193         {
2194           if (s->size != 0 && s != htab->root.srelplt)
2195             relocs = TRUE;
2196
2197           /* We use the reloc_count field as a counter if we need
2198              to copy relocs into the output file.  */
2199           s->reloc_count = 0;
2200         }
2201       else
2202         /* It's not one of our sections, so don't allocate space.  */
2203         continue;
2204
2205       if (s->size == 0)
2206         {
2207           /* If we don't need this section, strip it from the
2208              output file.  This is mostly to handle .rela.bss and
2209              .rela.plt.  We must create both sections in
2210              create_dynamic_sections, because they must be created
2211              before the linker maps input sections to output
2212              sections.  The linker does that before
2213              adjust_dynamic_symbol is called, and it is that
2214              function which decides whether anything needs to go
2215              into these sections.  */
2216           s->flags |= SEC_EXCLUDE;
2217           continue;
2218         }
2219
2220       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2221         continue;
2222
2223       /* Allocate memory for the section contents.  We use bfd_zalloc
2224          here in case unused entries are not reclaimed before the
2225          section's contents are written out.  This should not happen,
2226          but this way if it does, we get a R_LM32_NONE reloc instead
2227          of garbage.  */
2228       s->contents = bfd_zalloc (dynobj, s->size);
2229       if (s->contents == NULL)
2230         return FALSE;
2231     }
2232
2233   if (htab->root.dynamic_sections_created)
2234     {
2235       /* Add some entries to the .dynamic section.  We fill in the
2236          values later, in lm32_elf_finish_dynamic_sections, but we
2237          must add the entries now so that we get the correct size for
2238          the .dynamic section.  The DT_DEBUG entry is filled in by the
2239          dynamic linker and used by the debugger.  */
2240 #define add_dynamic_entry(TAG, VAL) \
2241   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2242
2243      if (bfd_link_executable (info))
2244         {
2245           if (! add_dynamic_entry (DT_DEBUG, 0))
2246             return FALSE;
2247         }
2248
2249       if (htab->root.splt->size != 0)
2250         {
2251           if (! add_dynamic_entry (DT_PLTGOT, 0)
2252               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2253               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2254               || ! add_dynamic_entry (DT_JMPREL, 0))
2255             return FALSE;
2256         }
2257
2258       if (relocs)
2259         {
2260           if (! add_dynamic_entry (DT_RELA, 0)
2261               || ! add_dynamic_entry (DT_RELASZ, 0)
2262               || ! add_dynamic_entry (DT_RELAENT,
2263                                       sizeof (Elf32_External_Rela)))
2264             return FALSE;
2265
2266           /* If any dynamic relocs apply to a read-only section,
2267              then we need a DT_TEXTREL entry.  */
2268           if ((info->flags & DF_TEXTREL) == 0)
2269             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2270                                     info);
2271
2272           if ((info->flags & DF_TEXTREL) != 0)
2273             {
2274               if (! add_dynamic_entry (DT_TEXTREL, 0))
2275                 return FALSE;
2276             }
2277         }
2278     }
2279 #undef add_dynamic_entry
2280
2281   /* Allocate .rofixup section.  */
2282   if (IS_FDPIC (output_bfd))
2283     {
2284       struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2285       int rgot_weak_count = 0;
2286       int r32_count = 0;
2287       int rgot_count = 0;
2288       /* Look for deleted sections.  */
2289       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2290         {
2291           for (s = ibfd->sections; s != NULL; s = s->next)
2292             {
2293               if (s->reloc_count)
2294                 {
2295                   /* Count relocs that need .rofixup entires.  */
2296                   Elf_Internal_Rela *internal_relocs, *end;
2297                   internal_relocs = elf_section_data (s)->relocs;
2298                   if (internal_relocs == NULL)
2299                     internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2300                   if (internal_relocs != NULL)
2301                     {
2302                       end = internal_relocs + s->reloc_count;
2303                       while (internal_relocs < end)
2304                         {
2305                           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2306                           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2307                           unsigned long r_symndx;
2308                           struct elf_link_hash_entry *h;
2309
2310                           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2311                           sym_hashes = elf_sym_hashes (ibfd);
2312                           r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2313                           h = NULL;
2314                           if (r_symndx < symtab_hdr->sh_info)
2315                             {
2316                             }
2317                           else
2318                             {
2319                               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2320                               while (h->root.type == bfd_link_hash_indirect
2321                                      || h->root.type == bfd_link_hash_warning)
2322                                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2323                               }
2324
2325                           /* Don't generate entries for weak symbols.  */
2326                           if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2327                             {
2328                               if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2329                                 {
2330                                   switch (ELF32_R_TYPE (internal_relocs->r_info))
2331                                     {
2332                                     case R_LM32_32:
2333                                       r32_count++;
2334                                       break;
2335                                     case R_LM32_16_GOT:
2336                                       rgot_count++;
2337                                       break;
2338                                     }
2339                                 }
2340                             }
2341                           else
2342                             {
2343                               struct weak_symbol_list *current, *new_entry;
2344                               /* Is this symbol already in the list?  */
2345                               for (current = list_start; current; current = current->next)
2346                                 {
2347                                   if (!strcmp (current->name, h->root.root.string))
2348                                     break;
2349                                 }
2350                               if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2351                                 {
2352                                   /* Will this have an entry in the GOT.  */
2353                                   if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2354                                     {
2355                                       /* Create a new entry.  */
2356                                       new_entry = malloc (sizeof (struct weak_symbol_list));
2357                                       if (!new_entry)
2358                                         return FALSE;
2359                                       new_entry->name = h->root.root.string;
2360                                       new_entry->next = NULL;
2361                                       /* Add to list */
2362                                       if (list_start == NULL)
2363                                         {
2364                                           list_start = new_entry;
2365                                           list_end = new_entry;
2366                                         }
2367                                       else
2368                                         {
2369                                           list_end->next = new_entry;
2370                                           list_end = new_entry;
2371                                         }
2372                                       /* Increase count of undefined weak symbols in the got.  */
2373                                       rgot_weak_count++;
2374                                     }
2375                                 }
2376                             }
2377                           internal_relocs++;
2378                         }
2379                     }
2380                   else
2381                     return FALSE;
2382                 }
2383             }
2384         }
2385       /* Free list.  */
2386       while (list_start)
2387         {
2388           list_end = list_start->next;
2389           free (list_start);
2390           list_start = list_end;
2391         }
2392
2393       /* Size sections.  */
2394       lm32fdpic_fixup32_section (info)->size
2395         = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2396       if (lm32fdpic_fixup32_section (info)->size == 0)
2397         lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2398       else
2399         {
2400           lm32fdpic_fixup32_section (info)->contents =
2401              bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2402           if (lm32fdpic_fixup32_section (info)->contents == NULL)
2403             return FALSE;
2404         }
2405     }
2406
2407   return TRUE;
2408 }
2409
2410 /* Create dynamic sections when linking against a dynamic object.  */
2411
2412 static bfd_boolean
2413 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2414 {
2415   struct elf_lm32_link_hash_table *htab;
2416   flagword flags, pltflags;
2417   asection *s;
2418   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2419   int ptralign = 2; /* 32bit */
2420
2421   htab = lm32_elf_hash_table (info);
2422   if (htab == NULL)
2423     return FALSE;
2424
2425   /* Make sure we have a GOT - For the case where we have a dynamic object
2426      but none of the relocs in check_relocs */
2427   if (!_bfd_elf_create_got_section (abfd, info))
2428     return FALSE;
2429   if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2430     {
2431       if (! create_rofixup_section (abfd, info))
2432         return FALSE;
2433     }
2434
2435   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2436      .rel[a].bss sections.  */
2437   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2438            | SEC_LINKER_CREATED);
2439
2440   pltflags = flags;
2441   pltflags |= SEC_CODE;
2442   if (bed->plt_not_loaded)
2443     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2444   if (bed->plt_readonly)
2445     pltflags |= SEC_READONLY;
2446
2447   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2448   htab->root.splt = s;
2449   if (s == NULL
2450       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2451     return FALSE;
2452
2453   if (bed->want_plt_sym)
2454     {
2455       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2456          .plt section.  */
2457       struct bfd_link_hash_entry *bh = NULL;
2458       struct elf_link_hash_entry *h;
2459
2460       if (! (_bfd_generic_link_add_one_symbol
2461              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2462               (bfd_vma) 0, NULL, FALSE,
2463               get_elf_backend_data (abfd)->collect, &bh)))
2464         return FALSE;
2465       h = (struct elf_link_hash_entry *) bh;
2466       h->def_regular = 1;
2467       h->type = STT_OBJECT;
2468       htab->root.hplt = h;
2469
2470       if (bfd_link_pic (info)
2471           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2472         return FALSE;
2473     }
2474
2475   s = bfd_make_section_anyway_with_flags (abfd,
2476                                           bed->default_use_rela_p
2477                                           ? ".rela.plt" : ".rel.plt",
2478                                           flags | SEC_READONLY);
2479   htab->root.srelplt = s;
2480   if (s == NULL
2481       || ! bfd_set_section_alignment (abfd, s, ptralign))
2482     return FALSE;
2483
2484   if (htab->root.sgot == NULL
2485       && !_bfd_elf_create_got_section (abfd, info))
2486     return FALSE;
2487
2488   if (bed->want_dynbss)
2489     {
2490       /* The .dynbss section is a place to put symbols which are defined
2491          by dynamic objects, are referenced by regular objects, and are
2492          not functions.  We must allocate space for them in the process
2493          image and use a R_*_COPY reloc to tell the dynamic linker to
2494          initialize them at run time.  The linker script puts the .dynbss
2495          section into the .bss section of the final image.  */
2496       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2497                                               SEC_ALLOC | SEC_LINKER_CREATED);
2498       htab->sdynbss = s;
2499       if (s == NULL)
2500         return FALSE;
2501       /* The .rel[a].bss section holds copy relocs.  This section is not
2502          normally needed.  We need to create it here, though, so that the
2503          linker will map it to an output section.  We can't just create it
2504          only if we need it, because we will not know whether we need it
2505          until we have seen all the input files, and the first time the
2506          main linker code calls BFD after examining all the input files
2507          (size_dynamic_sections) the input sections have already been
2508          mapped to the output sections.  If the section turns out not to
2509          be needed, we can discard it later.  We will never need this
2510          section when generating a shared object, since they do not use
2511          copy relocs.  */
2512       if (! bfd_link_pic (info))
2513         {
2514           s = bfd_make_section_anyway_with_flags (abfd,
2515                                                   (bed->default_use_rela_p
2516                                                    ? ".rela.bss" : ".rel.bss"),
2517                                                   flags | SEC_READONLY);
2518           htab->srelbss = s;
2519           if (s == NULL
2520               || ! bfd_set_section_alignment (abfd, s, ptralign))
2521             return FALSE;
2522         }
2523     }
2524
2525   return TRUE;
2526 }
2527
2528 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2529
2530 static void
2531 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2532                                struct elf_link_hash_entry *dir,
2533                                struct elf_link_hash_entry *ind)
2534 {
2535   struct elf_lm32_link_hash_entry * edir;
2536   struct elf_lm32_link_hash_entry * eind;
2537
2538   edir = (struct elf_lm32_link_hash_entry *) dir;
2539   eind = (struct elf_lm32_link_hash_entry *) ind;
2540
2541   if (eind->dyn_relocs != NULL)
2542     {
2543       if (edir->dyn_relocs != NULL)
2544         {
2545           struct elf_lm32_dyn_relocs **pp;
2546           struct elf_lm32_dyn_relocs *p;
2547
2548           /* Add reloc counts against the indirect sym to the direct sym
2549              list.  Merge any entries against the same section.  */
2550           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2551             {
2552               struct elf_lm32_dyn_relocs *q;
2553
2554               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2555                 if (q->sec == p->sec)
2556                   {
2557                     q->pc_count += p->pc_count;
2558                     q->count += p->count;
2559                     *pp = p->next;
2560                     break;
2561                   }
2562               if (q == NULL)
2563                 pp = &p->next;
2564             }
2565           *pp = edir->dyn_relocs;
2566         }
2567
2568       edir->dyn_relocs = eind->dyn_relocs;
2569       eind->dyn_relocs = NULL;
2570     }
2571
2572   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2573 }
2574
2575 static bfd_boolean
2576 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2577 {
2578   if (!bfd_link_relocatable (info))
2579     {
2580       if (!bfd_elf_stack_segment_size (output_bfd, info,
2581                                        "__stacksize", DEFAULT_STACK_SIZE))
2582         return FALSE;
2583
2584       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2585       if (sec)
2586         sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2587     }
2588
2589   return TRUE;
2590 }
2591
2592 static bfd_boolean
2593 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2594 {
2595   unsigned i;
2596
2597   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2598       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2599     return TRUE;
2600
2601   if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2602     return FALSE;
2603
2604   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2605       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2606     return TRUE;
2607
2608   /* Copy the stack size.  */
2609   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2610     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2611       {
2612         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2613
2614         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2615           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2616             {
2617               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2618
2619               /* Rewrite the phdrs, since we're only called after they were first written.  */
2620               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2621                             ->s->sizeof_ehdr, SEEK_SET) != 0
2622                   || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2623                                      elf_elfheader (obfd)->e_phnum) != 0)
2624                 return FALSE;
2625               break;
2626             }
2627
2628         break;
2629       }
2630
2631   return TRUE;
2632 }
2633
2634
2635 #define ELF_ARCH                bfd_arch_lm32
2636 #define ELF_TARGET_ID           LM32_ELF_DATA
2637 #define ELF_MACHINE_CODE        EM_LATTICEMICO32
2638 #define ELF_MAXPAGESIZE         0x1000
2639
2640 #define TARGET_BIG_SYM          lm32_elf32_vec
2641 #define TARGET_BIG_NAME         "elf32-lm32"
2642
2643 #define bfd_elf32_bfd_reloc_type_lookup         lm32_reloc_type_lookup
2644 #define bfd_elf32_bfd_reloc_name_lookup         lm32_reloc_name_lookup
2645 #define elf_info_to_howto                       lm32_info_to_howto_rela
2646 #define elf_info_to_howto_rel                   0
2647 #define elf_backend_rela_normal                 1
2648 #define elf_backend_object_p                    lm32_elf_object_p
2649 #define elf_backend_final_write_processing      lm32_elf_final_write_processing
2650 #define elf_backend_stack_align                 8
2651 #define elf_backend_can_gc_sections             1
2652 #define elf_backend_can_refcount                1
2653 #define elf_backend_gc_mark_hook                lm32_elf_gc_mark_hook
2654 #define elf_backend_gc_sweep_hook               lm32_elf_gc_sweep_hook
2655 #define elf_backend_plt_readonly                1
2656 #define elf_backend_want_got_plt                1
2657 #define elf_backend_want_plt_sym                0
2658 #define elf_backend_got_header_size             12
2659 #define bfd_elf32_bfd_link_hash_table_create    lm32_elf_link_hash_table_create
2660 #define elf_backend_check_relocs                lm32_elf_check_relocs
2661 #define elf_backend_reloc_type_class            lm32_elf_reloc_type_class
2662 #define elf_backend_copy_indirect_symbol        lm32_elf_copy_indirect_symbol
2663 #define elf_backend_size_dynamic_sections       lm32_elf_size_dynamic_sections
2664 #define elf_backend_omit_section_dynsym         ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2665 #define elf_backend_create_dynamic_sections     lm32_elf_create_dynamic_sections
2666 #define elf_backend_finish_dynamic_sections     lm32_elf_finish_dynamic_sections
2667 #define elf_backend_adjust_dynamic_symbol       lm32_elf_adjust_dynamic_symbol
2668 #define elf_backend_finish_dynamic_symbol       lm32_elf_finish_dynamic_symbol
2669 #define elf_backend_relocate_section            lm32_elf_relocate_section
2670
2671 #include "elf32-target.h"
2672
2673 #undef  ELF_MAXPAGESIZE
2674 #define ELF_MAXPAGESIZE         0x4000
2675
2676
2677 #undef  TARGET_BIG_SYM
2678 #define TARGET_BIG_SYM          lm32_elf32_fdpic_vec
2679 #undef  TARGET_BIG_NAME
2680 #define TARGET_BIG_NAME         "elf32-lm32fdpic"
2681 #undef  elf32_bed
2682 #define elf32_bed               elf32_lm32fdpic_bed
2683
2684 #undef  elf_backend_always_size_sections
2685 #define elf_backend_always_size_sections        lm32_elf_always_size_sections
2686 #undef  bfd_elf32_bfd_copy_private_bfd_data
2687 #define bfd_elf32_bfd_copy_private_bfd_data     lm32_elf_fdpic_copy_private_bfd_data
2688
2689 #include "elf32-target.h"