bfd/elf32-lm32.c

   1 /* Lattice Mico32-specific support for 32-bit ELF
   2    Copyright (C) 2008-2017 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_regular = 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         }
1433
1434       /* Fill in the first entry in the procedure linkage table.  */
1435       splt = htab->root.splt;
1436       if (splt && splt->size > 0)
1437         {
1438           if (bfd_link_pic (info))
1439             {
1440               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1441               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1442               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1443               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1444               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1445             }
1446           else
1447             {
1448               unsigned long addr;
1449               /* addr = .got + 4 */
1450               addr = sgot->output_section->vma + sgot->output_offset + 4;
1451               bfd_put_32 (output_bfd,
1452                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1453                           splt->contents);
1454               bfd_put_32 (output_bfd,
1455                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
1456                           splt->contents + 4);
1457               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1458               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1459               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1460             }
1461
1462           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1463             PLT_ENTRY_SIZE;
1464         }
1465     }
1466
1467   /* Fill in the first three entries in the global offset table.  */
1468   if (sgot && sgot->size > 0)
1469     {
1470       if (sdyn == NULL)
1471         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1472       else
1473         bfd_put_32 (output_bfd,
1474                     sdyn->output_section->vma + sdyn->output_offset,
1475                     sgot->contents);
1476       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1477       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1478
1479       /* FIXME:  This can be null if create_dynamic_sections wasn't called. */
1480       if (elf_section_data (sgot->output_section) != NULL)
1481         elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1482     }
1483
1484   if (lm32fdpic_fixup32_section (info))
1485     {
1486       struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1487       bfd_vma got_value = hgot->root.u.def.value
1488             + hgot->root.u.def.section->output_section->vma
1489             + hgot->root.u.def.section->output_offset;
1490       struct bfd_link_hash_entry *hend;
1491
1492       /* Last entry is pointer to GOT.  */
1493       _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1494
1495       /* Check we wrote enough entries.  */
1496       if (lm32fdpic_fixup32_section (info)->size
1497               != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1498         {
1499           _bfd_error_handler
1500             ("LINKER BUG: .rofixup section size mismatch: size/4 %Ld != relocs %d",
1501             lm32fdpic_fixup32_section (info)->size/4,
1502             lm32fdpic_fixup32_section (info)->reloc_count);
1503           return FALSE;
1504         }
1505
1506       hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1507               FALSE, FALSE, TRUE);
1508       if (hend
1509           && (hend->type == bfd_link_hash_defined
1510               || hend->type == bfd_link_hash_defweak))
1511         {
1512           bfd_vma value =
1513             lm32fdpic_fixup32_section (info)->output_section->vma
1514             + lm32fdpic_fixup32_section (info)->output_offset
1515             + lm32fdpic_fixup32_section (info)->size
1516             - hend->u.def.section->output_section->vma
1517             - hend->u.def.section->output_offset;
1518           BFD_ASSERT (hend->u.def.value == value);
1519           if (hend->u.def.value != value)
1520             {
1521               _bfd_error_handler
1522                 ("LINKER BUG: .rofixup section hend->u.def.value != value: %Ld != %Ld", hend->u.def.value, value);
1523               return FALSE;
1524             }
1525         }
1526     }
1527
1528   return TRUE;
1529 }
1530
1531 /* Finish up dynamic symbol handling.  We set the contents of various
1532    dynamic sections here.  */
1533
1534 static bfd_boolean
1535 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1536                                 struct bfd_link_info *info,
1537                                 struct elf_link_hash_entry *h,
1538                                 Elf_Internal_Sym *sym)
1539 {
1540   struct elf_lm32_link_hash_table *htab;
1541   bfd_byte *loc;
1542
1543   htab = lm32_elf_hash_table (info);
1544   if (htab == NULL)
1545     return FALSE;
1546
1547   if (h->plt.offset != (bfd_vma) -1)
1548     {
1549       asection *splt;
1550       asection *sgot;
1551       asection *srela;
1552
1553       bfd_vma plt_index;
1554       bfd_vma got_offset;
1555       Elf_Internal_Rela rela;
1556
1557       /* This symbol has an entry in the procedure linkage table.  Set
1558          it up.  */
1559       BFD_ASSERT (h->dynindx != -1);
1560
1561       splt = htab->root.splt;
1562       sgot = htab->root.sgotplt;
1563       srela = htab->root.srelplt;
1564       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1565
1566       /* Get the index in the procedure linkage table which
1567          corresponds to this symbol.  This is the index of this symbol
1568          in all the symbols for which we are making plt entries.  The
1569          first entry in the procedure linkage table is reserved.  */
1570       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1571
1572       /* Get the offset into the .got table of the entry that
1573         corresponds to this function.  Each .got entry is 4 bytes.
1574         The first three are reserved.  */
1575       got_offset = (plt_index + 3) * 4;
1576
1577       /* Fill in the entry in the procedure linkage table.  */
1578       if (! bfd_link_pic (info))
1579         {
1580           /* TODO */
1581         }
1582       else
1583         {
1584           /* TODO */
1585         }
1586
1587       /* Fill in the entry in the global offset table.  */
1588       bfd_put_32 (output_bfd,
1589                   (splt->output_section->vma
1590                    + splt->output_offset
1591                    + h->plt.offset
1592                    + 12), /* same offset */
1593                   sgot->contents + got_offset);
1594
1595       /* Fill in the entry in the .rela.plt section.  */
1596       rela.r_offset = (sgot->output_section->vma
1597                        + sgot->output_offset
1598                        + got_offset);
1599       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1600       rela.r_addend = 0;
1601       loc = srela->contents;
1602       loc += plt_index * sizeof (Elf32_External_Rela);
1603       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1604
1605       if (!h->def_regular)
1606         {
1607           /* Mark the symbol as undefined, rather than as defined in
1608              the .plt section.  Leave the value alone.  */
1609           sym->st_shndx = SHN_UNDEF;
1610         }
1611
1612     }
1613
1614   if (h->got.offset != (bfd_vma) -1)
1615     {
1616       asection *sgot;
1617       asection *srela;
1618       Elf_Internal_Rela rela;
1619
1620       /* This symbol has an entry in the global offset table.  Set it
1621          up.  */
1622       sgot = htab->root.sgot;
1623       srela = htab->root.srelgot;
1624       BFD_ASSERT (sgot != NULL && srela != NULL);
1625
1626       rela.r_offset = (sgot->output_section->vma
1627                        + sgot->output_offset
1628                        + (h->got.offset &~ 1));
1629
1630       /* If this is a -Bsymbolic link, and the symbol is defined
1631          locally, we just want to emit a RELATIVE reloc.  Likewise if
1632          the symbol was forced to be local because of a version file.
1633          The entry in the global offset table will already have been
1634          initialized in the relocate_section function.  */
1635       if (bfd_link_pic (info)
1636           && (info->symbolic
1637               || h->dynindx == -1
1638               || h->forced_local)
1639           && h->def_regular)
1640         {
1641           rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1642           rela.r_addend = (h->root.u.def.value
1643                            + h->root.u.def.section->output_section->vma
1644                            + h->root.u.def.section->output_offset);
1645         }
1646       else
1647         {
1648           BFD_ASSERT ((h->got.offset & 1) == 0);
1649           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1650           rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1651           rela.r_addend = 0;
1652         }
1653
1654       loc = srela->contents;
1655       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1656       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1657       ++srela->reloc_count;
1658     }
1659
1660   if (h->needs_copy)
1661     {
1662       asection *s;
1663       Elf_Internal_Rela rela;
1664
1665       /* This symbols needs a copy reloc.  Set it up.  */
1666       BFD_ASSERT (h->dynindx != -1
1667                   && (h->root.type == bfd_link_hash_defined
1668                       || h->root.type == bfd_link_hash_defweak));
1669
1670       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1671       BFD_ASSERT (s != NULL);
1672
1673       rela.r_offset = (h->root.u.def.value
1674                        + h->root.u.def.section->output_section->vma
1675                        + h->root.u.def.section->output_offset);
1676       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1677       rela.r_addend = 0;
1678       loc = s->contents;
1679       loc += s->reloc_count * sizeof (Elf32_External_Rela);
1680       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1681       ++s->reloc_count;
1682     }
1683
1684   /* Mark some specially defined symbols as absolute.  */
1685   if (h == htab->root.hdynamic || h == htab->root.hgot)
1686     sym->st_shndx = SHN_ABS;
1687
1688   return TRUE;
1689 }
1690
1691 static enum elf_reloc_type_class
1692 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1693                            const asection *rel_sec ATTRIBUTE_UNUSED,
1694                            const Elf_Internal_Rela *rela)
1695 {
1696   switch ((int) ELF32_R_TYPE (rela->r_info))
1697     {
1698     case R_LM32_RELATIVE:  return reloc_class_relative;
1699     case R_LM32_JMP_SLOT:  return reloc_class_plt;
1700     case R_LM32_COPY:      return reloc_class_copy;
1701     default:               return reloc_class_normal;
1702     }
1703 }
1704
1705 /* Adjust a symbol defined by a dynamic object and referenced by a
1706    regular object.  The current definition is in some section of the
1707    dynamic object, but we're not including those sections.  We have to
1708    change the definition to something the rest of the link can
1709    understand.  */
1710
1711 static bfd_boolean
1712 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1713                                 struct elf_link_hash_entry *h)
1714 {
1715   struct elf_lm32_link_hash_table *htab;
1716   struct elf_lm32_link_hash_entry *eh;
1717   struct elf_lm32_dyn_relocs *p;
1718   bfd *dynobj;
1719   asection *s;
1720
1721   dynobj = elf_hash_table (info)->dynobj;
1722
1723   /* Make sure we know what is going on here.  */
1724   BFD_ASSERT (dynobj != NULL
1725               && (h->needs_plt
1726                   || h->u.weakdef != NULL
1727                   || (h->def_dynamic
1728                       && h->ref_regular
1729                       && !h->def_regular)));
1730
1731   /* If this is a function, put it in the procedure linkage table.  We
1732      will fill in the contents of the procedure linkage table later,
1733      when we know the address of the .got section.  */
1734   if (h->type == STT_FUNC
1735       || h->needs_plt)
1736     {
1737       if (! bfd_link_pic (info)
1738           && !h->def_dynamic
1739           && !h->ref_dynamic
1740           && h->root.type != bfd_link_hash_undefweak
1741           && h->root.type != bfd_link_hash_undefined)
1742         {
1743           /* This case can occur if we saw a PLT reloc in an input
1744              file, but the symbol was never referred to by a dynamic
1745              object.  In such a case, we don't actually need to build
1746              a procedure linkage table, and we can just do a PCREL
1747              reloc instead.  */
1748           h->plt.offset = (bfd_vma) -1;
1749           h->needs_plt = 0;
1750         }
1751
1752       return TRUE;
1753     }
1754   else
1755     h->plt.offset = (bfd_vma) -1;
1756
1757   /* If this is a weak symbol, and there is a real definition, the
1758      processor independent code will have arranged for us to see the
1759      real definition first, and we can just use the same value.  */
1760   if (h->u.weakdef != NULL)
1761     {
1762       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1763                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1764       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1765       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1766       return TRUE;
1767     }
1768
1769   /* This is a reference to a symbol defined by a dynamic object which
1770      is not a function.  */
1771
1772   /* If we are creating a shared library, we must presume that the
1773      only references to the symbol are via the global offset table.
1774      For such cases we need not do anything here; the relocations will
1775      be handled correctly by relocate_section.  */
1776   if (bfd_link_pic (info))
1777     return TRUE;
1778
1779   /* If there are no references to this symbol that do not use the
1780      GOT, we don't need to generate a copy reloc.  */
1781   if (!h->non_got_ref)
1782     return TRUE;
1783
1784   /* If -z nocopyreloc was given, we won't generate them either.  */
1785   if (info->nocopyreloc)
1786     {
1787       h->non_got_ref = 0;
1788       return TRUE;
1789     }
1790
1791   eh = (struct elf_lm32_link_hash_entry *) h;
1792   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1793     {
1794       s = p->sec->output_section;
1795       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1796         break;
1797     }
1798
1799   /* If we didn't find any dynamic relocs in sections which needs the
1800      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1801      the copy reloc.  */
1802   if (p == NULL)
1803     {
1804       h->non_got_ref = 0;
1805       return TRUE;
1806     }
1807
1808   /* We must allocate the symbol in our .dynbss section, which will
1809      become part of the .bss section of the executable.  There will be
1810      an entry for this symbol in the .dynsym section.  The dynamic
1811      object will contain position independent code, so all references
1812      from the dynamic object to this symbol will go through the global
1813      offset table.  The dynamic linker will use the .dynsym entry to
1814      determine the address it must put in the global offset table, so
1815      both the dynamic object and the regular object will refer to the
1816      same memory location for the variable.  */
1817
1818   htab = lm32_elf_hash_table (info);
1819   if (htab == NULL)
1820     return FALSE;
1821
1822   s = htab->sdynbss;
1823   BFD_ASSERT (s != NULL);
1824
1825   /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1826      to copy the initial value out of the dynamic object and into the
1827      runtime process image.  We need to remember the offset into the
1828      .rela.bss section we are going to use.  */
1829   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1830     {
1831       asection *srel;
1832
1833       srel = htab->srelbss;
1834       BFD_ASSERT (srel != NULL);
1835       srel->size += sizeof (Elf32_External_Rela);
1836       h->needs_copy = 1;
1837     }
1838
1839   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1840 }
1841
1842 /* Allocate space in .plt, .got and associated reloc sections for
1843    dynamic relocs.  */
1844
1845 static bfd_boolean
1846 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1847 {
1848   struct bfd_link_info *info;
1849   struct elf_lm32_link_hash_table *htab;
1850   struct elf_lm32_link_hash_entry *eh;
1851   struct elf_lm32_dyn_relocs *p;
1852
1853   if (h->root.type == bfd_link_hash_indirect)
1854     return TRUE;
1855
1856   info = (struct bfd_link_info *) inf;
1857   htab = lm32_elf_hash_table (info);
1858   if (htab == NULL)
1859     return FALSE;
1860
1861   eh = (struct elf_lm32_link_hash_entry *) h;
1862
1863   if (htab->root.dynamic_sections_created
1864       && h->plt.refcount > 0)
1865     {
1866       /* Make sure this symbol is output as a dynamic symbol.
1867          Undefined weak syms won't yet be marked as dynamic.  */
1868       if (h->dynindx == -1
1869           && !h->forced_local)
1870         {
1871           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1872             return FALSE;
1873         }
1874
1875       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1876         {
1877           asection *s = htab->root.splt;
1878
1879           /* If this is the first .plt entry, make room for the special
1880              first entry.  */
1881           if (s->size == 0)
1882             s->size += PLT_ENTRY_SIZE;
1883
1884           h->plt.offset = s->size;
1885
1886           /* If this symbol is not defined in a regular file, and we are
1887              not generating a shared library, then set the symbol to this
1888              location in the .plt.  This is required to make function
1889              pointers compare as equal between the normal executable and
1890              the shared library.  */
1891           if (! bfd_link_pic (info)
1892               && !h->def_regular)
1893             {
1894               h->root.u.def.section = s;
1895               h->root.u.def.value = h->plt.offset;
1896             }
1897
1898           /* Make room for this entry.  */
1899           s->size += PLT_ENTRY_SIZE;
1900
1901           /* We also need to make an entry in the .got.plt section, which
1902              will be placed in the .got section by the linker script.  */
1903           htab->root.sgotplt->size += 4;
1904
1905           /* We also need to make an entry in the .rel.plt section.  */
1906           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1907         }
1908       else
1909         {
1910           h->plt.offset = (bfd_vma) -1;
1911           h->needs_plt = 0;
1912         }
1913     }
1914   else
1915     {
1916       h->plt.offset = (bfd_vma) -1;
1917       h->needs_plt = 0;
1918     }
1919
1920   if (h->got.refcount > 0)
1921     {
1922       asection *s;
1923       bfd_boolean dyn;
1924
1925       /* Make sure this symbol is output as a dynamic symbol.
1926          Undefined weak syms won't yet be marked as dynamic.  */
1927       if (h->dynindx == -1
1928           && !h->forced_local)
1929         {
1930           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1931             return FALSE;
1932         }
1933
1934       s = htab->root.sgot;
1935
1936       h->got.offset = s->size;
1937       s->size += 4;
1938       dyn = htab->root.dynamic_sections_created;
1939       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1940         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1941     }
1942   else
1943     h->got.offset = (bfd_vma) -1;
1944
1945   if (eh->dyn_relocs == NULL)
1946     return TRUE;
1947
1948   /* In the shared -Bsymbolic case, discard space allocated for
1949      dynamic pc-relative relocs against symbols which turn out to be
1950      defined in regular objects.  For the normal shared case, discard
1951      space for pc-relative relocs that have become local due to symbol
1952      visibility changes.  */
1953
1954   if (bfd_link_pic (info))
1955     {
1956       if (h->def_regular
1957           && (h->forced_local
1958               || info->symbolic))
1959         {
1960           struct elf_lm32_dyn_relocs **pp;
1961
1962           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1963             {
1964               p->count -= p->pc_count;
1965               p->pc_count = 0;
1966               if (p->count == 0)
1967                 *pp = p->next;
1968               else
1969                 pp = &p->next;
1970             }
1971         }
1972
1973       /* Also discard relocs on undefined weak syms with non-default
1974          visibility.  */
1975       if (eh->dyn_relocs != NULL
1976           && h->root.type == bfd_link_hash_undefweak)
1977         {
1978           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1979             eh->dyn_relocs = NULL;
1980
1981           /* Make sure undefined weak symbols are output as a dynamic
1982              symbol in PIEs.  */
1983           else if (h->dynindx == -1
1984                    && !h->forced_local)
1985             {
1986               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1987                 return FALSE;
1988             }
1989         }
1990     }
1991   else
1992     {
1993       /* For the non-shared case, discard space for relocs against
1994          symbols which turn out to need copy relocs or are not
1995          dynamic.  */
1996
1997       if (!h->non_got_ref
1998           && ((h->def_dynamic
1999                && !h->def_regular)
2000               || (htab->root.dynamic_sections_created
2001                   && (h->root.type == bfd_link_hash_undefweak
2002                       || h->root.type == bfd_link_hash_undefined))))
2003         {
2004           /* Make sure this symbol is output as a dynamic symbol.
2005              Undefined weak syms won't yet be marked as dynamic.  */
2006           if (h->dynindx == -1
2007               && !h->forced_local)
2008             {
2009               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2010                 return FALSE;
2011             }
2012
2013           /* If that succeeded, we know we'll be keeping all the
2014              relocs.  */
2015           if (h->dynindx != -1)
2016             goto keep;
2017         }
2018
2019       eh->dyn_relocs = NULL;
2020
2021     keep: ;
2022     }
2023
2024   /* Finally, allocate space.  */
2025   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2026     {
2027       asection *sreloc = elf_section_data (p->sec)->sreloc;
2028       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2029     }
2030
2031   return TRUE;
2032 }
2033
2034 /* Find any dynamic relocs that apply to read-only sections.  */
2035
2036 static bfd_boolean
2037 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2038 {
2039   struct elf_lm32_link_hash_entry *eh;
2040   struct elf_lm32_dyn_relocs *p;
2041
2042   eh = (struct elf_lm32_link_hash_entry *) h;
2043   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2044     {
2045       asection *s = p->sec->output_section;
2046
2047       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2048         {
2049           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2050
2051           info->flags |= DF_TEXTREL;
2052
2053           /* Not an error, just cut short the traversal.  */
2054           return FALSE;
2055         }
2056     }
2057   return TRUE;
2058 }
2059
2060 /* Set the sizes of the dynamic sections.  */
2061
2062 static bfd_boolean
2063 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2064                                 struct bfd_link_info *info)
2065 {
2066   struct elf_lm32_link_hash_table *htab;
2067   bfd *dynobj;
2068   asection *s;
2069   bfd_boolean relocs;
2070   bfd *ibfd;
2071
2072   htab = lm32_elf_hash_table (info);
2073   if (htab == NULL)
2074     return FALSE;
2075
2076   dynobj = htab->root.dynobj;
2077   BFD_ASSERT (dynobj != NULL);
2078
2079   if (htab->root.dynamic_sections_created)
2080     {
2081       /* Set the contents of the .interp section to the interpreter.  */
2082       if (bfd_link_executable (info) && !info->nointerp)
2083         {
2084           s = bfd_get_linker_section (dynobj, ".interp");
2085           BFD_ASSERT (s != NULL);
2086           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2087           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2088         }
2089     }
2090
2091   /* Set up .got offsets for local syms, and space for local dynamic
2092      relocs.  */
2093   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2094     {
2095       bfd_signed_vma *local_got;
2096       bfd_signed_vma *end_local_got;
2097       bfd_size_type locsymcount;
2098       Elf_Internal_Shdr *symtab_hdr;
2099       asection *srel;
2100
2101       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2102         continue;
2103
2104       for (s = ibfd->sections; s != NULL; s = s->next)
2105         {
2106           struct elf_lm32_dyn_relocs *p;
2107
2108           for (p = ((struct elf_lm32_dyn_relocs *)
2109                     elf_section_data (s)->local_dynrel);
2110                p != NULL;
2111                p = p->next)
2112             {
2113               if (! bfd_is_abs_section (p->sec)
2114                   && bfd_is_abs_section (p->sec->output_section))
2115                 {
2116                   /* Input section has been discarded, either because
2117                      it is a copy of a linkonce section or due to
2118                      linker script /DISCARD/, so we'll be discarding
2119                      the relocs too.  */
2120                 }
2121               else if (p->count != 0)
2122                 {
2123                   srel = elf_section_data (p->sec)->sreloc;
2124                   srel->size += p->count * sizeof (Elf32_External_Rela);
2125                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2126                     info->flags |= DF_TEXTREL;
2127                 }
2128             }
2129         }
2130
2131       local_got = elf_local_got_refcounts (ibfd);
2132       if (!local_got)
2133         continue;
2134
2135       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2136       locsymcount = symtab_hdr->sh_info;
2137       end_local_got = local_got + locsymcount;
2138       s = htab->root.sgot;
2139       srel = htab->root.srelgot;
2140       for (; local_got < end_local_got; ++local_got)
2141         {
2142           if (*local_got > 0)
2143             {
2144               *local_got = s->size;
2145               s->size += 4;
2146               if (bfd_link_pic (info))
2147                 srel->size += sizeof (Elf32_External_Rela);
2148             }
2149           else
2150             *local_got = (bfd_vma) -1;
2151         }
2152     }
2153
2154   /* Allocate global sym .plt and .got entries, and space for global
2155      sym dynamic relocs.  */
2156   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2157
2158   /* We now have determined the sizes of the various dynamic sections.
2159      Allocate memory for them.  */
2160   relocs = FALSE;
2161   for (s = dynobj->sections; s != NULL; s = s->next)
2162     {
2163       if ((s->flags & SEC_LINKER_CREATED) == 0)
2164         continue;
2165
2166       if (s == htab->root.splt
2167           || s == htab->root.sgot
2168           || s == htab->root.sgotplt
2169           || s == htab->sdynbss)
2170         {
2171           /* Strip this section if we don't need it; see the
2172              comment below.  */
2173         }
2174       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2175         {
2176           if (s->size != 0 && s != htab->root.srelplt)
2177             relocs = TRUE;
2178
2179           /* We use the reloc_count field as a counter if we need
2180              to copy relocs into the output file.  */
2181           s->reloc_count = 0;
2182         }
2183       else
2184         /* It's not one of our sections, so don't allocate space.  */
2185         continue;
2186
2187       if (s->size == 0)
2188         {
2189           /* If we don't need this section, strip it from the
2190              output file.  This is mostly to handle .rela.bss and
2191              .rela.plt.  We must create both sections in
2192              create_dynamic_sections, because they must be created
2193              before the linker maps input sections to output
2194              sections.  The linker does that before
2195              adjust_dynamic_symbol is called, and it is that
2196              function which decides whether anything needs to go
2197              into these sections.  */
2198           s->flags |= SEC_EXCLUDE;
2199           continue;
2200         }
2201
2202       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2203         continue;
2204
2205       /* Allocate memory for the section contents.  We use bfd_zalloc
2206          here in case unused entries are not reclaimed before the
2207          section's contents are written out.  This should not happen,
2208          but this way if it does, we get a R_LM32_NONE reloc instead
2209          of garbage.  */
2210       s->contents = bfd_zalloc (dynobj, s->size);
2211       if (s->contents == NULL)
2212         return FALSE;
2213     }
2214
2215   if (htab->root.dynamic_sections_created)
2216     {
2217       /* Add some entries to the .dynamic section.  We fill in the
2218          values later, in lm32_elf_finish_dynamic_sections, but we
2219          must add the entries now so that we get the correct size for
2220          the .dynamic section.  The DT_DEBUG entry is filled in by the
2221          dynamic linker and used by the debugger.  */
2222 #define add_dynamic_entry(TAG, VAL) \
2223   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2224
2225      if (bfd_link_executable (info))
2226         {
2227           if (! add_dynamic_entry (DT_DEBUG, 0))
2228             return FALSE;
2229         }
2230
2231       if (htab->root.splt->size != 0)
2232         {
2233           if (! add_dynamic_entry (DT_PLTGOT, 0)
2234               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2235               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2236               || ! add_dynamic_entry (DT_JMPREL, 0))
2237             return FALSE;
2238         }
2239
2240       if (relocs)
2241         {
2242           if (! add_dynamic_entry (DT_RELA, 0)
2243               || ! add_dynamic_entry (DT_RELASZ, 0)
2244               || ! add_dynamic_entry (DT_RELAENT,
2245                                       sizeof (Elf32_External_Rela)))
2246             return FALSE;
2247
2248           /* If any dynamic relocs apply to a read-only section,
2249              then we need a DT_TEXTREL entry.  */
2250           if ((info->flags & DF_TEXTREL) == 0)
2251             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2252                                     info);
2253
2254           if ((info->flags & DF_TEXTREL) != 0)
2255             {
2256               if (! add_dynamic_entry (DT_TEXTREL, 0))
2257                 return FALSE;
2258             }
2259         }
2260     }
2261 #undef add_dynamic_entry
2262
2263   /* Allocate .rofixup section.  */
2264   if (IS_FDPIC (output_bfd))
2265     {
2266       struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2267       int rgot_weak_count = 0;
2268       int r32_count = 0;
2269       int rgot_count = 0;
2270       /* Look for deleted sections.  */
2271       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2272         {
2273           for (s = ibfd->sections; s != NULL; s = s->next)
2274             {
2275               if (s->reloc_count)
2276                 {
2277                   /* Count relocs that need .rofixup entires.  */
2278                   Elf_Internal_Rela *internal_relocs, *end;
2279                   internal_relocs = elf_section_data (s)->relocs;
2280                   if (internal_relocs == NULL)
2281                     internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2282                   if (internal_relocs != NULL)
2283                     {
2284                       end = internal_relocs + s->reloc_count;
2285                       while (internal_relocs < end)
2286                         {
2287                           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2288                           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2289                           unsigned long r_symndx;
2290                           struct elf_link_hash_entry *h;
2291
2292                           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2293                           sym_hashes = elf_sym_hashes (ibfd);
2294                           r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2295                           h = NULL;
2296                           if (r_symndx < symtab_hdr->sh_info)
2297                             {
2298                             }
2299                           else
2300                             {
2301                               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2302                               while (h->root.type == bfd_link_hash_indirect
2303                                      || h->root.type == bfd_link_hash_warning)
2304                                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2305                               }
2306
2307                           /* Don't generate entries for weak symbols.  */
2308                           if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2309                             {
2310                               if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2311                                 {
2312                                   switch (ELF32_R_TYPE (internal_relocs->r_info))
2313                                     {
2314                                     case R_LM32_32:
2315                                       r32_count++;
2316                                       break;
2317                                     case R_LM32_16_GOT:
2318                                       rgot_count++;
2319                                       break;
2320                                     }
2321                                 }
2322                             }
2323                           else
2324                             {
2325                               struct weak_symbol_list *current, *new_entry;
2326                               /* Is this symbol already in the list?  */
2327                               for (current = list_start; current; current = current->next)
2328                                 {
2329                                   if (!strcmp (current->name, h->root.root.string))
2330                                     break;
2331                                 }
2332                               if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2333                                 {
2334                                   /* Will this have an entry in the GOT.  */
2335                                   if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2336                                     {
2337                                       /* Create a new entry.  */
2338                                       new_entry = malloc (sizeof (struct weak_symbol_list));
2339                                       if (!new_entry)
2340                                         return FALSE;
2341                                       new_entry->name = h->root.root.string;
2342                                       new_entry->next = NULL;
2343                                       /* Add to list */
2344                                       if (list_start == NULL)
2345                                         {
2346                                           list_start = new_entry;
2347                                           list_end = new_entry;
2348                                         }
2349                                       else
2350                                         {
2351                                           list_end->next = new_entry;
2352                                           list_end = new_entry;
2353                                         }
2354                                       /* Increase count of undefined weak symbols in the got.  */
2355                                       rgot_weak_count++;
2356                                     }
2357                                 }
2358                             }
2359                           internal_relocs++;
2360                         }
2361                     }
2362                   else
2363                     return FALSE;
2364                 }
2365             }
2366         }
2367       /* Free list.  */
2368       while (list_start)
2369         {
2370           list_end = list_start->next;
2371           free (list_start);
2372           list_start = list_end;
2373         }
2374
2375       /* Size sections.  */
2376       lm32fdpic_fixup32_section (info)->size
2377         = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2378       if (lm32fdpic_fixup32_section (info)->size == 0)
2379         lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2380       else
2381         {
2382           lm32fdpic_fixup32_section (info)->contents =
2383              bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2384           if (lm32fdpic_fixup32_section (info)->contents == NULL)
2385             return FALSE;
2386         }
2387     }
2388
2389   return TRUE;
2390 }
2391
2392 /* Create dynamic sections when linking against a dynamic object.  */
2393
2394 static bfd_boolean
2395 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2396 {
2397   struct elf_lm32_link_hash_table *htab;
2398   flagword flags, pltflags;
2399   asection *s;
2400   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2401   int ptralign = 2; /* 32bit */
2402
2403   htab = lm32_elf_hash_table (info);
2404   if (htab == NULL)
2405     return FALSE;
2406
2407   /* Make sure we have a GOT - For the case where we have a dynamic object
2408      but none of the relocs in check_relocs */
2409   if (!_bfd_elf_create_got_section (abfd, info))
2410     return FALSE;
2411   if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2412     {
2413       if (! create_rofixup_section (abfd, info))
2414         return FALSE;
2415     }
2416
2417   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2418      .rel[a].bss sections.  */
2419   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2420            | SEC_LINKER_CREATED);
2421
2422   pltflags = flags;
2423   pltflags |= SEC_CODE;
2424   if (bed->plt_not_loaded)
2425     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2426   if (bed->plt_readonly)
2427     pltflags |= SEC_READONLY;
2428
2429   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2430   htab->root.splt = s;
2431   if (s == NULL
2432       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2433     return FALSE;
2434
2435   if (bed->want_plt_sym)
2436     {
2437       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2438          .plt section.  */
2439       struct bfd_link_hash_entry *bh = NULL;
2440       struct elf_link_hash_entry *h;
2441
2442       if (! (_bfd_generic_link_add_one_symbol
2443              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2444               (bfd_vma) 0, NULL, FALSE,
2445               get_elf_backend_data (abfd)->collect, &bh)))
2446         return FALSE;
2447       h = (struct elf_link_hash_entry *) bh;
2448       h->def_regular = 1;
2449       h->type = STT_OBJECT;
2450       htab->root.hplt = h;
2451
2452       if (bfd_link_pic (info)
2453           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2454         return FALSE;
2455     }
2456
2457   s = bfd_make_section_anyway_with_flags (abfd,
2458                                           bed->default_use_rela_p
2459                                           ? ".rela.plt" : ".rel.plt",
2460                                           flags | SEC_READONLY);
2461   htab->root.srelplt = s;
2462   if (s == NULL
2463       || ! bfd_set_section_alignment (abfd, s, ptralign))
2464     return FALSE;
2465
2466   if (htab->root.sgot == NULL
2467       && !_bfd_elf_create_got_section (abfd, info))
2468     return FALSE;
2469
2470   if (bed->want_dynbss)
2471     {
2472       /* The .dynbss section is a place to put symbols which are defined
2473          by dynamic objects, are referenced by regular objects, and are
2474          not functions.  We must allocate space for them in the process
2475          image and use a R_*_COPY reloc to tell the dynamic linker to
2476          initialize them at run time.  The linker script puts the .dynbss
2477          section into the .bss section of the final image.  */
2478       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2479                                               SEC_ALLOC | SEC_LINKER_CREATED);
2480       htab->sdynbss = s;
2481       if (s == NULL)
2482         return FALSE;
2483       /* The .rel[a].bss section holds copy relocs.  This section is not
2484          normally needed.  We need to create it here, though, so that the
2485          linker will map it to an output section.  We can't just create it
2486          only if we need it, because we will not know whether we need it
2487          until we have seen all the input files, and the first time the
2488          main linker code calls BFD after examining all the input files
2489          (size_dynamic_sections) the input sections have already been
2490          mapped to the output sections.  If the section turns out not to
2491          be needed, we can discard it later.  We will never need this
2492          section when generating a shared object, since they do not use
2493          copy relocs.  */
2494       if (! bfd_link_pic (info))
2495         {
2496           s = bfd_make_section_anyway_with_flags (abfd,
2497                                                   (bed->default_use_rela_p
2498                                                    ? ".rela.bss" : ".rel.bss"),
2499                                                   flags | SEC_READONLY);
2500           htab->srelbss = s;
2501           if (s == NULL
2502               || ! bfd_set_section_alignment (abfd, s, ptralign))
2503             return FALSE;
2504         }
2505     }
2506
2507   return TRUE;
2508 }
2509
2510 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2511
2512 static void
2513 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2514                                struct elf_link_hash_entry *dir,
2515                                struct elf_link_hash_entry *ind)
2516 {
2517   struct elf_lm32_link_hash_entry * edir;
2518   struct elf_lm32_link_hash_entry * eind;
2519
2520   edir = (struct elf_lm32_link_hash_entry *) dir;
2521   eind = (struct elf_lm32_link_hash_entry *) ind;
2522
2523   if (eind->dyn_relocs != NULL)
2524     {
2525       if (edir->dyn_relocs != NULL)
2526         {
2527           struct elf_lm32_dyn_relocs **pp;
2528           struct elf_lm32_dyn_relocs *p;
2529
2530           /* Add reloc counts against the indirect sym to the direct sym
2531              list.  Merge any entries against the same section.  */
2532           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2533             {
2534               struct elf_lm32_dyn_relocs *q;
2535
2536               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2537                 if (q->sec == p->sec)
2538                   {
2539                     q->pc_count += p->pc_count;
2540                     q->count += p->count;
2541                     *pp = p->next;
2542                     break;
2543                   }
2544               if (q == NULL)
2545                 pp = &p->next;
2546             }
2547           *pp = edir->dyn_relocs;
2548         }
2549
2550       edir->dyn_relocs = eind->dyn_relocs;
2551       eind->dyn_relocs = NULL;
2552     }
2553
2554   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2555 }
2556
2557 static bfd_boolean
2558 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2559 {
2560   if (!bfd_link_relocatable (info))
2561     {
2562       if (!bfd_elf_stack_segment_size (output_bfd, info,
2563                                        "__stacksize", DEFAULT_STACK_SIZE))
2564         return FALSE;
2565
2566       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2567       if (sec)
2568         sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2569     }
2570
2571   return TRUE;
2572 }
2573
2574 static bfd_boolean
2575 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2576 {
2577   unsigned i;
2578
2579   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2580       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2581     return TRUE;
2582
2583   if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2584     return FALSE;
2585
2586   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2587       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2588     return TRUE;
2589
2590   /* Copy the stack size.  */
2591   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2592     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2593       {
2594         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2595
2596         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2597           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2598             {
2599               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2600
2601               /* Rewrite the phdrs, since we're only called after they were first written.  */
2602               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2603                             ->s->sizeof_ehdr, SEEK_SET) != 0
2604                   || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2605                                      elf_elfheader (obfd)->e_phnum) != 0)
2606                 return FALSE;
2607               break;
2608             }
2609
2610         break;
2611       }
2612
2613   return TRUE;
2614 }
2615
2616
2617 #define ELF_ARCH                bfd_arch_lm32
2618 #define ELF_TARGET_ID           LM32_ELF_DATA
2619 #define ELF_MACHINE_CODE        EM_LATTICEMICO32
2620 #define ELF_MAXPAGESIZE         0x1000
2621
2622 #define TARGET_BIG_SYM          lm32_elf32_vec
2623 #define TARGET_BIG_NAME         "elf32-lm32"
2624
2625 #define bfd_elf32_bfd_reloc_type_lookup         lm32_reloc_type_lookup
2626 #define bfd_elf32_bfd_reloc_name_lookup         lm32_reloc_name_lookup
2627 #define elf_info_to_howto                       lm32_info_to_howto_rela
2628 #define elf_info_to_howto_rel                   0
2629 #define elf_backend_rela_normal                 1
2630 #define elf_backend_object_p                    lm32_elf_object_p
2631 #define elf_backend_final_write_processing      lm32_elf_final_write_processing
2632 #define elf_backend_stack_align                 8
2633 #define elf_backend_can_gc_sections             1
2634 #define elf_backend_can_refcount                1
2635 #define elf_backend_gc_mark_hook                lm32_elf_gc_mark_hook
2636 #define elf_backend_gc_sweep_hook               lm32_elf_gc_sweep_hook
2637 #define elf_backend_plt_readonly                1
2638 #define elf_backend_want_got_plt                1
2639 #define elf_backend_want_plt_sym                0
2640 #define elf_backend_got_header_size             12
2641 #define elf_backend_dtrel_excludes_plt          1
2642 #define bfd_elf32_bfd_link_hash_table_create    lm32_elf_link_hash_table_create
2643 #define elf_backend_check_relocs                lm32_elf_check_relocs
2644 #define elf_backend_reloc_type_class            lm32_elf_reloc_type_class
2645 #define elf_backend_copy_indirect_symbol        lm32_elf_copy_indirect_symbol
2646 #define elf_backend_size_dynamic_sections       lm32_elf_size_dynamic_sections
2647 #define elf_backend_omit_section_dynsym         ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2648 #define elf_backend_create_dynamic_sections     lm32_elf_create_dynamic_sections
2649 #define elf_backend_finish_dynamic_sections     lm32_elf_finish_dynamic_sections
2650 #define elf_backend_adjust_dynamic_symbol       lm32_elf_adjust_dynamic_symbol
2651 #define elf_backend_finish_dynamic_symbol       lm32_elf_finish_dynamic_symbol
2652 #define elf_backend_relocate_section            lm32_elf_relocate_section
2653
2654 #include "elf32-target.h"
2655
2656 #undef  ELF_MAXPAGESIZE
2657 #define ELF_MAXPAGESIZE         0x4000
2658
2659
2660 #undef  TARGET_BIG_SYM
2661 #define TARGET_BIG_SYM          lm32_elf32_fdpic_vec
2662 #undef  TARGET_BIG_NAME
2663 #define TARGET_BIG_NAME         "elf32-lm32fdpic"
2664 #undef  elf32_bed
2665 #define elf32_bed               elf32_lm32fdpic_bed
2666
2667 #undef  elf_backend_always_size_sections
2668 #define elf_backend_always_size_sections        lm32_elf_always_size_sections
2669 #undef  bfd_elf32_bfd_copy_private_bfd_data
2670 #define bfd_elf32_bfd_copy_private_bfd_data     lm32_elf_fdpic_copy_private_bfd_data
2671
2672 #include "elf32-target.h"