bfd/elf32-lm32.c

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