bfd/elf32-lm32.c

   1 /* Lattice Mico32-specific support for 32-bit ELF
   2    Copyright (C) 2008-2016 Free Software Foundation, Inc.
   3    Contributed by Jon Beniston <jon@beniston.com>
   4
   5    This file is part of BFD, the Binary File Descriptor library.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  20    MA 02110-1301, USA.  */
  21
  22 #include "sysdep.h"
  23 #include "bfd.h"
  24 #include "libbfd.h"
  25 #include "elf-bfd.h"
  26 #include "elf/lm32.h"
  27
  28 #define DEFAULT_STACK_SIZE 0x20000
  29
  30 #define PLT_ENTRY_SIZE 20
  31
  32 #define PLT0_ENTRY_WORD0  0
  33 #define PLT0_ENTRY_WORD1  0
  34 #define PLT0_ENTRY_WORD2  0
  35 #define PLT0_ENTRY_WORD3  0
  36 #define PLT0_ENTRY_WORD4  0
  37
  38 #define PLT0_PIC_ENTRY_WORD0  0
  39 #define PLT0_PIC_ENTRY_WORD1  0
  40 #define PLT0_PIC_ENTRY_WORD2  0
  41 #define PLT0_PIC_ENTRY_WORD3  0
  42 #define PLT0_PIC_ENTRY_WORD4  0
  43
  44 #define ELF_DYNAMIC_INTERPRETER "/usr/lib/libc.so.1"
  45
  46 extern const bfd_target lm32_elf32_fdpic_vec;
  47
  48 #define IS_FDPIC(bfd) ((bfd)->xvec == &lm32_elf32_fdpic_vec)
  49
  50 static bfd_reloc_status_type lm32_elf_gprel_reloc
  51   (bfd *, arelent *, asymbol *, void *, asection *, bfd *, char **);
  52
  53 /* The linker needs to keep track of the number of relocs that it
  54    decides to copy as dynamic relocs in check_relocs for each symbol.
  55    This is so that it can later discard them if they are found to be
  56    unnecessary.  We store the information in a field extending the
  57    regular ELF linker hash table.  */
  58
  59 struct elf_lm32_dyn_relocs
  60 {
  61   struct elf_lm32_dyn_relocs *next;
  62
  63   /* The input section of the reloc.  */
  64   asection *sec;
  65
  66   /* Total number of relocs copied for the input section.  */
  67   bfd_size_type count;
  68
  69   /* Number of pc-relative relocs copied for the input section.  */
  70   bfd_size_type pc_count;
  71 };
  72
  73 /* lm32 ELF linker hash entry.  */
  74
  75 struct elf_lm32_link_hash_entry
  76 {
  77   struct elf_link_hash_entry root;
  78
  79   /* Track dynamic relocs copied for this symbol.  */
  80   struct elf_lm32_dyn_relocs *dyn_relocs;
  81 };
  82
  83 /* lm32 ELF linker hash table.  */
  84
  85 struct elf_lm32_link_hash_table
  86 {
  87   struct elf_link_hash_table root;
  88
  89   /* Short-cuts to get to dynamic linker sections.  */
  90   asection *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          3,                         /* size (0 = byte, 1 = short, 2 = long) */
 266          0,                         /* bitsize */
 267          FALSE,                     /* pc_relative */
 268          0,                         /* bitpos */
 269          complain_overflow_dont,    /* 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 (_("%B: 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 (bfd_link_relocatable (info))
 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,
 949                                                          bfd_link_pic (info),
 950                                                          h)
 951                       || (bfd_link_pic (info)
 952                           && (info->symbolic
 953                               || h->dynindx == -1
 954                               || h->forced_local)
 955                           && h->def_regular))
 956                     {
 957                       /* This is actually a static link, or it is a
 958                          -Bsymbolic link and the symbol is defined
 959                          locally, or the symbol was forced to be local
 960                          because of a version file.  We must initialize
 961                          this entry in the global offset table.  Since the
 962                          offset must always be a multiple of 4, we use the
 963                          least significant bit to record whether we have
 964                          initialized it already.
 965
 966                          When doing a dynamic link, we create a .rela.got
 967                          relocation entry to initialize the value.  This
 968                          is done in the finish_dynamic_symbol routine.  */
 969                       if ((off & 1) != 0)
 970                         off &= ~1;
 971                       else
 972                         {
 973                           /* Write entry in GOT */
 974                           bfd_put_32 (output_bfd, relocation,
 975                                       sgot->contents + off);
 976                           /* Create entry in .rofixup pointing to GOT entry.  */
 977                            if (IS_FDPIC (output_bfd) && h->root.type != bfd_link_hash_undefweak)
 978                              {
 979                                _lm32fdpic_add_rofixup (output_bfd,
 980                                                        lm32fdpic_fixup32_section
 981                                                         (info),
 982                                                        sgot->output_section->vma
 983                                                         + sgot->output_offset
 984                                                         + off);
 985                              }
 986                           /* Mark GOT entry as having been written.  */
 987                           h->got.offset |= 1;
 988                         }
 989                     }
 990
 991                   relocation = sgot->output_offset + off;
 992                 }
 993               else
 994                 {
 995                   bfd_vma off;
 996                   bfd_byte *loc;
 997
 998                   BFD_ASSERT (local_got_offsets != NULL
 999                               && local_got_offsets[r_symndx] != (bfd_vma) -1);
1000
1001                   /* Get offset into GOT table.  */
1002                   off = local_got_offsets[r_symndx];
1003
1004                   /* The offset must always be a multiple of 4.  We use
1005                      the least significant bit to record whether we have
1006                      already processed this entry.  */
1007                   if ((off & 1) != 0)
1008                     off &= ~1;
1009                   else
1010                     {
1011                       /* Write entry in GOT.  */
1012                       bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1013                       /* Create entry in .rofixup pointing to GOT entry.  */
1014                       if (IS_FDPIC (output_bfd))
1015                         {
1016                           _lm32fdpic_add_rofixup (output_bfd,
1017                                                   lm32fdpic_fixup32_section
1018                                                    (info),
1019                                                   sgot->output_section->vma
1020                                                    + sgot->output_offset
1021                                                    + off);
1022                         }
1023
1024                       if (bfd_link_pic (info))
1025                         {
1026                           asection *srelgot;
1027                           Elf_Internal_Rela outrel;
1028
1029                           /* We need to generate a R_LM32_RELATIVE reloc
1030                              for the dynamic linker.  */
1031                           srelgot = bfd_get_linker_section (dynobj,
1032                                                             ".rela.got");
1033                           BFD_ASSERT (srelgot != NULL);
1034
1035                           outrel.r_offset = (sgot->output_section->vma
1036                                              + sgot->output_offset
1037                                              + off);
1038                           outrel.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1039                           outrel.r_addend = relocation;
1040                           loc = srelgot->contents;
1041                           loc += srelgot->reloc_count * sizeof (Elf32_External_Rela);
1042                           bfd_elf32_swap_reloca_out (output_bfd, &outrel,loc);
1043                           ++srelgot->reloc_count;
1044                         }
1045
1046                       local_got_offsets[r_symndx] |= 1;
1047                     }
1048
1049
1050                   relocation = sgot->output_offset + off;
1051                 }
1052
1053               /* Addend should be zero.  */
1054               if (rel->r_addend != 0)
1055                 (*_bfd_error_handler) (_("internal error: addend should be zero for R_LM32_16_GOT"));
1056
1057               r = _bfd_final_link_relocate (howto,
1058                                             input_bfd,
1059                                             input_section,
1060                                             contents,
1061                                             rel->r_offset,
1062                                             relocation,
1063                                             rel->r_addend);
1064               break;
1065
1066             case R_LM32_GOTOFF_LO16:
1067             case R_LM32_GOTOFF_HI16:
1068               /* Relocation is offset from GOT.  */
1069               BFD_ASSERT (sgot != NULL);
1070               relocation -= sgot->output_section->vma;
1071               /* Account for sign-extension.  */
1072               if ((r_type == R_LM32_GOTOFF_HI16)
1073                   && ((relocation + rel->r_addend) & 0x8000))
1074                 rel->r_addend += 0x10000;
1075               r = _bfd_final_link_relocate (howto,
1076                                             input_bfd,
1077                                             input_section,
1078                                             contents,
1079                                             rel->r_offset,
1080                                             relocation,
1081                                             rel->r_addend);
1082               break;
1083
1084             case R_LM32_32:
1085               if (IS_FDPIC (output_bfd))
1086                 {
1087                   if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1088                     {
1089                       /* Only create .rofixup entries for relocs in loadable sections.  */
1090                       if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1091                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1092
1093                         {
1094                           /* Check address to be modified is writable.  */
1095                           if (_lm32fdpic_osec_readonly_p (output_bfd,
1096                                                           input_section
1097                                                            ->output_section))
1098                             {
1099                               info->callbacks->warning
1100                                 (info,
1101                                  _("cannot emit dynamic relocations in read-only section"),
1102                                  name, input_bfd, input_section, rel->r_offset);
1103                                return FALSE;
1104                             }
1105                           /* Create entry in .rofixup section.  */
1106                           _lm32fdpic_add_rofixup (output_bfd,
1107                                                   lm32fdpic_fixup32_section (info),
1108                                                   input_section->output_section->vma
1109                                                    + input_section->output_offset
1110                                                    + rel->r_offset);
1111                         }
1112                     }
1113                 }
1114               /* Fall through.  */
1115
1116             default:
1117               r = _bfd_final_link_relocate (howto,
1118                                             input_bfd,
1119                                             input_section,
1120                                             contents,
1121                                             rel->r_offset,
1122                                             relocation,
1123                                             rel->r_addend);
1124               break;
1125             }
1126         }
1127
1128       if (r != bfd_reloc_ok)
1129         {
1130           const char *msg = NULL;
1131           arelent bfd_reloc;
1132
1133           lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1134           howto = bfd_reloc.howto;
1135
1136           if (h != NULL)
1137             name = h->root.root.string;
1138           else
1139             {
1140               name = (bfd_elf_string_from_elf_section
1141                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1142               if (name == NULL || *name == '\0')
1143                 name = bfd_section_name (input_bfd, sec);
1144             }
1145
1146           switch (r)
1147             {
1148             case bfd_reloc_overflow:
1149               if ((h != NULL)
1150                  && (h->root.type == bfd_link_hash_undefweak))
1151                 break;
1152               if (! ((*info->callbacks->reloc_overflow)
1153                      (info, (h ? &h->root : NULL), name, howto->name,
1154                       (bfd_vma) 0, input_bfd, input_section, rel->r_offset)))
1155                 return FALSE;
1156               break;
1157
1158             case bfd_reloc_undefined:
1159               if (! ((*info->callbacks->undefined_symbol)
1160                      (info, name, input_bfd, input_section,
1161                       rel->r_offset, TRUE)))
1162                 return FALSE;
1163               break;
1164
1165             case bfd_reloc_outofrange:
1166               msg = _("internal error: out of range error");
1167               goto common_error;
1168
1169             case bfd_reloc_notsupported:
1170               msg = _("internal error: unsupported relocation error");
1171               goto common_error;
1172
1173             case bfd_reloc_dangerous:
1174               msg = _("internal error: dangerous error");
1175               goto common_error;
1176
1177             default:
1178               msg = _("internal error: unknown error");
1179               /* fall through */
1180
1181             common_error:
1182               if (!((*info->callbacks->warning)
1183                     (info, msg, name, input_bfd, input_section,
1184                      rel->r_offset)))
1185                 return FALSE;
1186               break;
1187             }
1188         }
1189     }
1190
1191   return TRUE;
1192 }
1193
1194 static asection *
1195 lm32_elf_gc_mark_hook (asection *sec,
1196                        struct bfd_link_info *info,
1197                        Elf_Internal_Rela *rel,
1198                        struct elf_link_hash_entry *h,
1199                        Elf_Internal_Sym *sym)
1200 {
1201   if (h != NULL)
1202     switch (ELF32_R_TYPE (rel->r_info))
1203       {
1204       case R_LM32_GNU_VTINHERIT:
1205       case R_LM32_GNU_VTENTRY:
1206         return NULL;
1207       }
1208
1209   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1210 }
1211
1212 static bfd_boolean
1213 lm32_elf_gc_sweep_hook (bfd *abfd,
1214                         struct bfd_link_info *info ATTRIBUTE_UNUSED,
1215                         asection *sec,
1216                         const Elf_Internal_Rela *relocs ATTRIBUTE_UNUSED)
1217 {
1218   /* Update the got entry reference counts for the section being removed.  */
1219   Elf_Internal_Shdr *symtab_hdr;
1220   struct elf_link_hash_entry **sym_hashes;
1221   bfd_signed_vma *local_got_refcounts;
1222   const Elf_Internal_Rela *rel, *relend;
1223
1224   elf_section_data (sec)->local_dynrel = NULL;
1225
1226   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1227   sym_hashes = elf_sym_hashes (abfd);
1228   local_got_refcounts = elf_local_got_refcounts (abfd);
1229
1230   relend = relocs + sec->reloc_count;
1231   for (rel = relocs; rel < relend; rel++)
1232     {
1233       unsigned long r_symndx;
1234       struct elf_link_hash_entry *h = NULL;
1235
1236       r_symndx = ELF32_R_SYM (rel->r_info);
1237       if (r_symndx >= symtab_hdr->sh_info)
1238         {
1239           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1240           while (h->root.type == bfd_link_hash_indirect
1241                  || h->root.type == bfd_link_hash_warning)
1242             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1243         }
1244
1245       switch (ELF32_R_TYPE (rel->r_info))
1246         {
1247         case R_LM32_16_GOT:
1248           if (h != NULL)
1249             {
1250               if (h->got.refcount > 0)
1251                 h->got.refcount--;
1252             }
1253           else
1254             {
1255               if (local_got_refcounts && local_got_refcounts[r_symndx] > 0)
1256                 local_got_refcounts[r_symndx]--;
1257             }
1258           break;
1259
1260         default:
1261           break;
1262         }
1263     }
1264   return TRUE;
1265 }
1266
1267 /* Look through the relocs for a section during the first phase.  */
1268
1269 static bfd_boolean
1270 lm32_elf_check_relocs (bfd *abfd,
1271                        struct bfd_link_info *info,
1272                        asection *sec,
1273                        const Elf_Internal_Rela *relocs)
1274 {
1275   Elf_Internal_Shdr *symtab_hdr;
1276   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1277   const Elf_Internal_Rela *rel;
1278   const Elf_Internal_Rela *rel_end;
1279   struct elf_lm32_link_hash_table *htab;
1280   bfd *dynobj;
1281
1282   if (bfd_link_relocatable (info))
1283     return TRUE;
1284
1285   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1286   sym_hashes = elf_sym_hashes (abfd);
1287   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1288   if (!elf_bad_symtab (abfd))
1289     sym_hashes_end -= symtab_hdr->sh_info;
1290
1291   htab = lm32_elf_hash_table (info);
1292   if (htab == NULL)
1293     return FALSE;
1294
1295   dynobj = htab->root.dynobj;
1296
1297   rel_end = relocs + sec->reloc_count;
1298   for (rel = relocs; rel < rel_end; rel++)
1299     {
1300       int r_type;
1301       struct elf_link_hash_entry *h;
1302       unsigned long r_symndx;
1303
1304       r_symndx = ELF32_R_SYM (rel->r_info);
1305       r_type = ELF32_R_TYPE (rel->r_info);
1306       if (r_symndx < symtab_hdr->sh_info)
1307         h = NULL;
1308       else
1309         {
1310           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1311           while (h->root.type == bfd_link_hash_indirect
1312                  || h->root.type == bfd_link_hash_warning)
1313             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1314
1315           /* PR15323, ref flags aren't set for references in the same
1316              object.  */
1317           h->root.non_ir_ref = 1;
1318         }
1319
1320       /* Some relocs require a global offset table.  */
1321       if (htab->sgot == NULL)
1322         {
1323           switch (r_type)
1324             {
1325             case R_LM32_16_GOT:
1326             case R_LM32_GOTOFF_HI16:
1327             case R_LM32_GOTOFF_LO16:
1328               if (dynobj == NULL)
1329                 htab->root.dynobj = dynobj = abfd;
1330               if (! create_got_section (dynobj, info))
1331                 return FALSE;
1332               break;
1333             }
1334         }
1335
1336       /* Some relocs require a rofixup table. */
1337       if (IS_FDPIC (abfd))
1338         {
1339           switch (r_type)
1340             {
1341             case R_LM32_32:
1342               /* FDPIC requires a GOT if there is a .rofixup section
1343                  (Normal ELF doesn't). */
1344               if (dynobj == NULL)
1345                 htab->root.dynobj = dynobj = abfd;
1346               if (! create_got_section (dynobj, info))
1347                 return FALSE;
1348               /* Create .rofixup section */
1349               if (htab->sfixup32 == NULL)
1350                 {
1351                   if (! create_rofixup_section (dynobj, info))
1352                     return FALSE;
1353                 }
1354               break;
1355             case R_LM32_16_GOT:
1356             case R_LM32_GOTOFF_HI16:
1357             case R_LM32_GOTOFF_LO16:
1358               /* Create .rofixup section.  */
1359               if (htab->sfixup32 == NULL)
1360                 {
1361                   if (dynobj == NULL)
1362                     htab->root.dynobj = dynobj = abfd;
1363                   if (! create_rofixup_section (dynobj, info))
1364                     return FALSE;
1365                 }
1366               break;
1367             }
1368         }
1369
1370       switch (r_type)
1371         {
1372         case R_LM32_16_GOT:
1373           if (h != NULL)
1374             h->got.refcount += 1;
1375           else
1376             {
1377               bfd_signed_vma *local_got_refcounts;
1378
1379               /* This is a global offset table entry for a local symbol.  */
1380               local_got_refcounts = elf_local_got_refcounts (abfd);
1381               if (local_got_refcounts == NULL)
1382                 {
1383                   bfd_size_type size;
1384
1385                   size = symtab_hdr->sh_info;
1386                   size *= sizeof (bfd_signed_vma);
1387                   local_got_refcounts = bfd_zalloc (abfd, size);
1388                   if (local_got_refcounts == NULL)
1389                     return FALSE;
1390                   elf_local_got_refcounts (abfd) = local_got_refcounts;
1391                 }
1392               local_got_refcounts[r_symndx] += 1;
1393             }
1394           break;
1395
1396         /* This relocation describes the C++ object vtable hierarchy.
1397            Reconstruct it for later use during GC.  */
1398         case R_LM32_GNU_VTINHERIT:
1399           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1400             return FALSE;
1401           break;
1402
1403         /* This relocation describes which C++ vtable entries are actually
1404            used.  Record for later use during GC.  */
1405         case R_LM32_GNU_VTENTRY:
1406           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1407             return FALSE;
1408           break;
1409
1410         }
1411     }
1412
1413   return TRUE;
1414 }
1415
1416 /* Finish up the dynamic sections.  */
1417
1418 static bfd_boolean
1419 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1420                                   struct bfd_link_info *info)
1421 {
1422   struct elf_lm32_link_hash_table *htab;
1423   bfd *dynobj;
1424   asection *sdyn;
1425   asection *sgot;
1426
1427   htab = lm32_elf_hash_table (info);
1428   if (htab == NULL)
1429     return FALSE;
1430
1431   dynobj = htab->root.dynobj;
1432
1433   sgot = htab->sgotplt;
1434   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1435
1436   if (htab->root.dynamic_sections_created)
1437     {
1438       asection *splt;
1439       Elf32_External_Dyn *dyncon, *dynconend;
1440
1441       BFD_ASSERT (sgot != NULL && sdyn != NULL);
1442
1443       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1444       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1445
1446       for (; dyncon < dynconend; dyncon++)
1447         {
1448           Elf_Internal_Dyn dyn;
1449           asection *s;
1450
1451           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1452
1453           switch (dyn.d_tag)
1454             {
1455             default:
1456               break;
1457
1458             case DT_PLTGOT:
1459               s = htab->sgot->output_section;
1460               goto get_vma;
1461             case DT_JMPREL:
1462               s = htab->srelplt->output_section;
1463             get_vma:
1464               BFD_ASSERT (s != NULL);
1465               dyn.d_un.d_ptr = s->vma;
1466               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1467               break;
1468
1469             case DT_PLTRELSZ:
1470               s = htab->srelplt->output_section;
1471               BFD_ASSERT (s != NULL);
1472               dyn.d_un.d_val = s->size;
1473               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1474               break;
1475
1476             case DT_RELASZ:
1477               /* My reading of the SVR4 ABI indicates that the
1478                  procedure linkage table relocs (DT_JMPREL) should be
1479                  included in the overall relocs (DT_RELA).  This is
1480                  what Solaris does.  However, UnixWare can not handle
1481                  that case.  Therefore, we override the DT_RELASZ entry
1482                  here to make it not include the JMPREL relocs.  Since
1483                  the linker script arranges for .rela.plt to follow all
1484                  other relocation sections, we don't have to worry
1485                  about changing the DT_RELA entry.  */
1486               if (htab->srelplt != NULL)
1487                 {
1488                   s = htab->srelplt->output_section;
1489                   dyn.d_un.d_val -= s->size;
1490                 }
1491               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1492               break;
1493             }
1494         }
1495
1496       /* Fill in the first entry in the procedure linkage table.  */
1497       splt = htab->splt;
1498       if (splt && splt->size > 0)
1499         {
1500           if (bfd_link_pic (info))
1501             {
1502               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1503               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1504               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1505               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1506               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1507             }
1508           else
1509             {
1510               unsigned long addr;
1511               /* addr = .got + 4 */
1512               addr = sgot->output_section->vma + sgot->output_offset + 4;
1513               bfd_put_32 (output_bfd,
1514                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1515                           splt->contents);
1516               bfd_put_32 (output_bfd,
1517                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
1518                           splt->contents + 4);
1519               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1520               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1521               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1522             }
1523
1524           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1525             PLT_ENTRY_SIZE;
1526         }
1527     }
1528
1529   /* Fill in the first three entries in the global offset table.  */
1530   if (sgot && sgot->size > 0)
1531     {
1532       if (sdyn == NULL)
1533         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1534       else
1535         bfd_put_32 (output_bfd,
1536                     sdyn->output_section->vma + sdyn->output_offset,
1537                     sgot->contents);
1538       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1539       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1540
1541       /* FIXME:  This can be null if create_dynamic_sections wasn't called. */
1542       if (elf_section_data (sgot->output_section) != NULL)
1543         elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1544     }
1545
1546   if (lm32fdpic_fixup32_section (info))
1547     {
1548       struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1549       bfd_vma got_value = hgot->root.u.def.value
1550             + hgot->root.u.def.section->output_section->vma
1551             + hgot->root.u.def.section->output_offset;
1552       struct bfd_link_hash_entry *hend;
1553
1554       /* Last entry is pointer to GOT.  */
1555       _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1556
1557       /* Check we wrote enough entries.  */
1558       if (lm32fdpic_fixup32_section (info)->size
1559               != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1560         {
1561           (*_bfd_error_handler)
1562             ("LINKER BUG: .rofixup section size mismatch: size/4 %d != relocs %d",
1563             lm32fdpic_fixup32_section (info)->size/4,
1564             lm32fdpic_fixup32_section (info)->reloc_count);
1565           return FALSE;
1566         }
1567
1568       hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1569               FALSE, FALSE, TRUE);
1570       if (hend
1571           && (hend->type == bfd_link_hash_defined
1572               || hend->type == bfd_link_hash_defweak))
1573         {
1574           bfd_vma value =
1575             lm32fdpic_fixup32_section (info)->output_section->vma
1576             + lm32fdpic_fixup32_section (info)->output_offset
1577             + lm32fdpic_fixup32_section (info)->size
1578             - hend->u.def.section->output_section->vma
1579             - hend->u.def.section->output_offset;
1580           BFD_ASSERT (hend->u.def.value == value);
1581           if (hend->u.def.value != value)
1582             {
1583               (*_bfd_error_handler)
1584                 ("LINKER BUG: .rofixup section hend->u.def.value != value: %ld != %ld", hend->u.def.value, value);
1585               return FALSE;
1586             }
1587         }
1588     }
1589
1590   return TRUE;
1591 }
1592
1593 /* Finish up dynamic symbol handling.  We set the contents of various
1594    dynamic sections here.  */
1595
1596 static bfd_boolean
1597 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1598                                 struct bfd_link_info *info,
1599                                 struct elf_link_hash_entry *h,
1600                                 Elf_Internal_Sym *sym)
1601 {
1602   struct elf_lm32_link_hash_table *htab;
1603   bfd_byte *loc;
1604
1605   htab = lm32_elf_hash_table (info);
1606   if (htab == NULL)
1607     return FALSE;
1608
1609   if (h->plt.offset != (bfd_vma) -1)
1610     {
1611       asection *splt;
1612       asection *sgot;
1613       asection *srela;
1614
1615       bfd_vma plt_index;
1616       bfd_vma got_offset;
1617       Elf_Internal_Rela rela;
1618
1619       /* This symbol has an entry in the procedure linkage table.  Set
1620          it up.  */
1621       BFD_ASSERT (h->dynindx != -1);
1622
1623       splt = htab->splt;
1624       sgot = htab->sgotplt;
1625       srela = htab->srelplt;
1626       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1627
1628       /* Get the index in the procedure linkage table which
1629          corresponds to this symbol.  This is the index of this symbol
1630          in all the symbols for which we are making plt entries.  The
1631          first entry in the procedure linkage table is reserved.  */
1632       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1633
1634       /* Get the offset into the .got table of the entry that
1635         corresponds to this function.  Each .got entry is 4 bytes.
1636         The first three are reserved.  */
1637       got_offset = (plt_index + 3) * 4;
1638
1639       /* Fill in the entry in the procedure linkage table.  */
1640       if (! bfd_link_pic (info))
1641         {
1642           /* TODO */
1643         }
1644       else
1645         {
1646           /* TODO */
1647         }
1648
1649       /* Fill in the entry in the global offset table.  */
1650       bfd_put_32 (output_bfd,
1651                   (splt->output_section->vma
1652                    + splt->output_offset
1653                    + h->plt.offset
1654                    + 12), /* same offset */
1655                   sgot->contents + got_offset);
1656
1657       /* Fill in the entry in the .rela.plt section.  */
1658       rela.r_offset = (sgot->output_section->vma
1659                        + sgot->output_offset
1660                        + got_offset);
1661       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1662       rela.r_addend = 0;
1663       loc = srela->contents;
1664       loc += plt_index * sizeof (Elf32_External_Rela);
1665       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1666
1667       if (!h->def_regular)
1668         {
1669           /* Mark the symbol as undefined, rather than as defined in
1670              the .plt section.  Leave the value alone.  */
1671           sym->st_shndx = SHN_UNDEF;
1672         }
1673
1674     }
1675
1676   if (h->got.offset != (bfd_vma) -1)
1677     {
1678       asection *sgot;
1679       asection *srela;
1680       Elf_Internal_Rela rela;
1681
1682       /* This symbol has an entry in the global offset table.  Set it
1683          up.  */
1684       sgot = htab->sgot;
1685       srela = htab->srelgot;
1686       BFD_ASSERT (sgot != NULL && srela != NULL);
1687
1688       rela.r_offset = (sgot->output_section->vma
1689                        + sgot->output_offset
1690                        + (h->got.offset &~ 1));
1691
1692       /* If this is a -Bsymbolic link, and the symbol is defined
1693          locally, we just want to emit a RELATIVE reloc.  Likewise if
1694          the symbol was forced to be local because of a version file.
1695          The entry in the global offset table will already have been
1696          initialized in the relocate_section function.  */
1697       if (bfd_link_pic (info)
1698           && (info->symbolic
1699               || h->dynindx == -1
1700               || h->forced_local)
1701           && h->def_regular)
1702         {
1703           rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1704           rela.r_addend = (h->root.u.def.value
1705                            + h->root.u.def.section->output_section->vma
1706                            + h->root.u.def.section->output_offset);
1707         }
1708       else
1709         {
1710           BFD_ASSERT ((h->got.offset & 1) == 0);
1711           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1712           rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1713           rela.r_addend = 0;
1714         }
1715
1716       loc = srela->contents;
1717       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1718       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1719       ++srela->reloc_count;
1720     }
1721
1722   if (h->needs_copy)
1723     {
1724       asection *s;
1725       Elf_Internal_Rela rela;
1726
1727       /* This symbols needs a copy reloc.  Set it up.  */
1728       BFD_ASSERT (h->dynindx != -1
1729                   && (h->root.type == bfd_link_hash_defined
1730                       || h->root.type == bfd_link_hash_defweak));
1731
1732       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1733       BFD_ASSERT (s != NULL);
1734
1735       rela.r_offset = (h->root.u.def.value
1736                        + h->root.u.def.section->output_section->vma
1737                        + h->root.u.def.section->output_offset);
1738       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1739       rela.r_addend = 0;
1740       loc = s->contents;
1741       loc += s->reloc_count * sizeof (Elf32_External_Rela);
1742       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1743       ++s->reloc_count;
1744     }
1745
1746   /* Mark some specially defined symbols as absolute.  */
1747   if (h == htab->root.hdynamic || h == htab->root.hgot)
1748     sym->st_shndx = SHN_ABS;
1749
1750   return TRUE;
1751 }
1752
1753 static enum elf_reloc_type_class
1754 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1755                            const asection *rel_sec ATTRIBUTE_UNUSED,
1756                            const Elf_Internal_Rela *rela)
1757 {
1758   switch ((int) ELF32_R_TYPE (rela->r_info))
1759     {
1760     case R_LM32_RELATIVE:  return reloc_class_relative;
1761     case R_LM32_JMP_SLOT:  return reloc_class_plt;
1762     case R_LM32_COPY:      return reloc_class_copy;
1763     default:               return reloc_class_normal;
1764     }
1765 }
1766
1767 /* Adjust a symbol defined by a dynamic object and referenced by a
1768    regular object.  The current definition is in some section of the
1769    dynamic object, but we're not including those sections.  We have to
1770    change the definition to something the rest of the link can
1771    understand.  */
1772
1773 static bfd_boolean
1774 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1775                                 struct elf_link_hash_entry *h)
1776 {
1777   struct elf_lm32_link_hash_table *htab;
1778   struct elf_lm32_link_hash_entry *eh;
1779   struct elf_lm32_dyn_relocs *p;
1780   bfd *dynobj;
1781   asection *s;
1782
1783   dynobj = elf_hash_table (info)->dynobj;
1784
1785   /* Make sure we know what is going on here.  */
1786   BFD_ASSERT (dynobj != NULL
1787               && (h->needs_plt
1788                   || h->u.weakdef != NULL
1789                   || (h->def_dynamic
1790                       && h->ref_regular
1791                       && !h->def_regular)));
1792
1793   /* If this is a function, put it in the procedure linkage table.  We
1794      will fill in the contents of the procedure linkage table later,
1795      when we know the address of the .got section.  */
1796   if (h->type == STT_FUNC
1797       || h->needs_plt)
1798     {
1799       if (! bfd_link_pic (info)
1800           && !h->def_dynamic
1801           && !h->ref_dynamic
1802           && h->root.type != bfd_link_hash_undefweak
1803           && h->root.type != bfd_link_hash_undefined)
1804         {
1805           /* This case can occur if we saw a PLT reloc in an input
1806              file, but the symbol was never referred to by a dynamic
1807              object.  In such a case, we don't actually need to build
1808              a procedure linkage table, and we can just do a PCREL
1809              reloc instead.  */
1810           h->plt.offset = (bfd_vma) -1;
1811           h->needs_plt = 0;
1812         }
1813
1814       return TRUE;
1815     }
1816   else
1817     h->plt.offset = (bfd_vma) -1;
1818
1819   /* If this is a weak symbol, and there is a real definition, the
1820      processor independent code will have arranged for us to see the
1821      real definition first, and we can just use the same value.  */
1822   if (h->u.weakdef != NULL)
1823     {
1824       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1825                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1826       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1827       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1828       return TRUE;
1829     }
1830
1831   /* This is a reference to a symbol defined by a dynamic object which
1832      is not a function.  */
1833
1834   /* If we are creating a shared library, we must presume that the
1835      only references to the symbol are via the global offset table.
1836      For such cases we need not do anything here; the relocations will
1837      be handled correctly by relocate_section.  */
1838   if (bfd_link_pic (info))
1839     return TRUE;
1840
1841   /* If there are no references to this symbol that do not use the
1842      GOT, we don't need to generate a copy reloc.  */
1843   if (!h->non_got_ref)
1844     return TRUE;
1845
1846   /* If -z nocopyreloc was given, we won't generate them either.  */
1847   if (info->nocopyreloc)
1848     {
1849       h->non_got_ref = 0;
1850       return TRUE;
1851     }
1852
1853   eh = (struct elf_lm32_link_hash_entry *) h;
1854   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1855     {
1856       s = p->sec->output_section;
1857       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1858         break;
1859     }
1860
1861   /* If we didn't find any dynamic relocs in sections which needs the
1862      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1863      the copy reloc.  */
1864   if (p == NULL)
1865     {
1866       h->non_got_ref = 0;
1867       return TRUE;
1868     }
1869
1870   /* We must allocate the symbol in our .dynbss section, which will
1871      become part of the .bss section of the executable.  There will be
1872      an entry for this symbol in the .dynsym section.  The dynamic
1873      object will contain position independent code, so all references
1874      from the dynamic object to this symbol will go through the global
1875      offset table.  The dynamic linker will use the .dynsym entry to
1876      determine the address it must put in the global offset table, so
1877      both the dynamic object and the regular object will refer to the
1878      same memory location for the variable.  */
1879
1880   htab = lm32_elf_hash_table (info);
1881   if (htab == NULL)
1882     return FALSE;
1883
1884   s = htab->sdynbss;
1885   BFD_ASSERT (s != NULL);
1886
1887   /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1888      to copy the initial value out of the dynamic object and into the
1889      runtime process image.  We need to remember the offset into the
1890      .rela.bss section we are going to use.  */
1891   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1892     {
1893       asection *srel;
1894
1895       srel = htab->srelbss;
1896       BFD_ASSERT (srel != NULL);
1897       srel->size += sizeof (Elf32_External_Rela);
1898       h->needs_copy = 1;
1899     }
1900
1901   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1902 }
1903
1904 /* Allocate space in .plt, .got and associated reloc sections for
1905    dynamic relocs.  */
1906
1907 static bfd_boolean
1908 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1909 {
1910   struct bfd_link_info *info;
1911   struct elf_lm32_link_hash_table *htab;
1912   struct elf_lm32_link_hash_entry *eh;
1913   struct elf_lm32_dyn_relocs *p;
1914
1915   if (h->root.type == bfd_link_hash_indirect)
1916     return TRUE;
1917
1918   info = (struct bfd_link_info *) inf;
1919   htab = lm32_elf_hash_table (info);
1920   if (htab == NULL)
1921     return FALSE;
1922
1923   eh = (struct elf_lm32_link_hash_entry *) h;
1924
1925   if (htab->root.dynamic_sections_created
1926       && h->plt.refcount > 0)
1927     {
1928       /* Make sure this symbol is output as a dynamic symbol.
1929          Undefined weak syms won't yet be marked as dynamic.  */
1930       if (h->dynindx == -1
1931           && !h->forced_local)
1932         {
1933           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1934             return FALSE;
1935         }
1936
1937       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1938         {
1939           asection *s = htab->splt;
1940
1941           /* If this is the first .plt entry, make room for the special
1942              first entry.  */
1943           if (s->size == 0)
1944             s->size += PLT_ENTRY_SIZE;
1945
1946           h->plt.offset = s->size;
1947
1948           /* If this symbol is not defined in a regular file, and we are
1949              not generating a shared library, then set the symbol to this
1950              location in the .plt.  This is required to make function
1951              pointers compare as equal between the normal executable and
1952              the shared library.  */
1953           if (! bfd_link_pic (info)
1954               && !h->def_regular)
1955             {
1956               h->root.u.def.section = s;
1957               h->root.u.def.value = h->plt.offset;
1958             }
1959
1960           /* Make room for this entry.  */
1961           s->size += PLT_ENTRY_SIZE;
1962
1963           /* We also need to make an entry in the .got.plt section, which
1964              will be placed in the .got section by the linker script.  */
1965           htab->sgotplt->size += 4;
1966
1967           /* We also need to make an entry in the .rel.plt section.  */
1968           htab->srelplt->size += sizeof (Elf32_External_Rela);
1969         }
1970       else
1971         {
1972           h->plt.offset = (bfd_vma) -1;
1973           h->needs_plt = 0;
1974         }
1975     }
1976   else
1977     {
1978       h->plt.offset = (bfd_vma) -1;
1979       h->needs_plt = 0;
1980     }
1981
1982   if (h->got.refcount > 0)
1983     {
1984       asection *s;
1985       bfd_boolean dyn;
1986
1987       /* Make sure this symbol is output as a dynamic symbol.
1988          Undefined weak syms won't yet be marked as dynamic.  */
1989       if (h->dynindx == -1
1990           && !h->forced_local)
1991         {
1992           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1993             return FALSE;
1994         }
1995
1996       s = htab->sgot;
1997
1998       h->got.offset = s->size;
1999       s->size += 4;
2000       dyn = htab->root.dynamic_sections_created;
2001       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
2002         htab->srelgot->size += sizeof (Elf32_External_Rela);
2003     }
2004   else
2005     h->got.offset = (bfd_vma) -1;
2006
2007   if (eh->dyn_relocs == NULL)
2008     return TRUE;
2009
2010   /* In the shared -Bsymbolic case, discard space allocated for
2011      dynamic pc-relative relocs against symbols which turn out to be
2012      defined in regular objects.  For the normal shared case, discard
2013      space for pc-relative relocs that have become local due to symbol
2014      visibility changes.  */
2015
2016   if (bfd_link_pic (info))
2017     {
2018       if (h->def_regular
2019           && (h->forced_local
2020               || info->symbolic))
2021         {
2022           struct elf_lm32_dyn_relocs **pp;
2023
2024           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2025             {
2026               p->count -= p->pc_count;
2027               p->pc_count = 0;
2028               if (p->count == 0)
2029                 *pp = p->next;
2030               else
2031                 pp = &p->next;
2032             }
2033         }
2034
2035       /* Also discard relocs on undefined weak syms with non-default
2036          visibility.  */
2037       if (eh->dyn_relocs != NULL
2038           && h->root.type == bfd_link_hash_undefweak)
2039         {
2040           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2041             eh->dyn_relocs = NULL;
2042
2043           /* Make sure undefined weak symbols are output as a dynamic
2044              symbol in PIEs.  */
2045           else if (h->dynindx == -1
2046                    && !h->forced_local)
2047             {
2048               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2049                 return FALSE;
2050             }
2051         }
2052     }
2053   else
2054     {
2055       /* For the non-shared case, discard space for relocs against
2056          symbols which turn out to need copy relocs or are not
2057          dynamic.  */
2058
2059       if (!h->non_got_ref
2060           && ((h->def_dynamic
2061                && !h->def_regular)
2062               || (htab->root.dynamic_sections_created
2063                   && (h->root.type == bfd_link_hash_undefweak
2064                       || h->root.type == bfd_link_hash_undefined))))
2065         {
2066           /* Make sure this symbol is output as a dynamic symbol.
2067              Undefined weak syms won't yet be marked as dynamic.  */
2068           if (h->dynindx == -1
2069               && !h->forced_local)
2070             {
2071               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2072                 return FALSE;
2073             }
2074
2075           /* If that succeeded, we know we'll be keeping all the
2076              relocs.  */
2077           if (h->dynindx != -1)
2078             goto keep;
2079         }
2080
2081       eh->dyn_relocs = NULL;
2082
2083     keep: ;
2084     }
2085
2086   /* Finally, allocate space.  */
2087   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2088     {
2089       asection *sreloc = elf_section_data (p->sec)->sreloc;
2090       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2091     }
2092
2093   return TRUE;
2094 }
2095
2096 /* Find any dynamic relocs that apply to read-only sections.  */
2097
2098 static bfd_boolean
2099 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2100 {
2101   struct elf_lm32_link_hash_entry *eh;
2102   struct elf_lm32_dyn_relocs *p;
2103
2104   eh = (struct elf_lm32_link_hash_entry *) h;
2105   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2106     {
2107       asection *s = p->sec->output_section;
2108
2109       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2110         {
2111           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2112
2113           info->flags |= DF_TEXTREL;
2114
2115           /* Not an error, just cut short the traversal.  */
2116           return FALSE;
2117         }
2118     }
2119   return TRUE;
2120 }
2121
2122 /* Set the sizes of the dynamic sections.  */
2123
2124 static bfd_boolean
2125 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2126                                 struct bfd_link_info *info)
2127 {
2128   struct elf_lm32_link_hash_table *htab;
2129   bfd *dynobj;
2130   asection *s;
2131   bfd_boolean relocs;
2132   bfd *ibfd;
2133
2134   htab = lm32_elf_hash_table (info);
2135   if (htab == NULL)
2136     return FALSE;
2137
2138   dynobj = htab->root.dynobj;
2139   BFD_ASSERT (dynobj != NULL);
2140
2141   if (htab->root.dynamic_sections_created)
2142     {
2143       /* Set the contents of the .interp section to the interpreter.  */
2144       if (bfd_link_executable (info) && !info->nointerp)
2145         {
2146           s = bfd_get_linker_section (dynobj, ".interp");
2147           BFD_ASSERT (s != NULL);
2148           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2149           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2150         }
2151     }
2152
2153   /* Set up .got offsets for local syms, and space for local dynamic
2154      relocs.  */
2155   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2156     {
2157       bfd_signed_vma *local_got;
2158       bfd_signed_vma *end_local_got;
2159       bfd_size_type locsymcount;
2160       Elf_Internal_Shdr *symtab_hdr;
2161       asection *srel;
2162
2163       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2164         continue;
2165
2166       for (s = ibfd->sections; s != NULL; s = s->next)
2167         {
2168           struct elf_lm32_dyn_relocs *p;
2169
2170           for (p = ((struct elf_lm32_dyn_relocs *)
2171                     elf_section_data (s)->local_dynrel);
2172                p != NULL;
2173                p = p->next)
2174             {
2175               if (! bfd_is_abs_section (p->sec)
2176                   && bfd_is_abs_section (p->sec->output_section))
2177                 {
2178                   /* Input section has been discarded, either because
2179                      it is a copy of a linkonce section or due to
2180                      linker script /DISCARD/, so we'll be discarding
2181                      the relocs too.  */
2182                 }
2183               else if (p->count != 0)
2184                 {
2185                   srel = elf_section_data (p->sec)->sreloc;
2186                   srel->size += p->count * sizeof (Elf32_External_Rela);
2187                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2188                     info->flags |= DF_TEXTREL;
2189                 }
2190             }
2191         }
2192
2193       local_got = elf_local_got_refcounts (ibfd);
2194       if (!local_got)
2195         continue;
2196
2197       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2198       locsymcount = symtab_hdr->sh_info;
2199       end_local_got = local_got + locsymcount;
2200       s = htab->sgot;
2201       srel = htab->srelgot;
2202       for (; local_got < end_local_got; ++local_got)
2203         {
2204           if (*local_got > 0)
2205             {
2206               *local_got = s->size;
2207               s->size += 4;
2208               if (bfd_link_pic (info))
2209                 srel->size += sizeof (Elf32_External_Rela);
2210             }
2211           else
2212             *local_got = (bfd_vma) -1;
2213         }
2214     }
2215
2216   /* Allocate global sym .plt and .got entries, and space for global
2217      sym dynamic relocs.  */
2218   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2219
2220   /* We now have determined the sizes of the various dynamic sections.
2221      Allocate memory for them.  */
2222   relocs = FALSE;
2223   for (s = dynobj->sections; s != NULL; s = s->next)
2224     {
2225       if ((s->flags & SEC_LINKER_CREATED) == 0)
2226         continue;
2227
2228       if (s == htab->splt
2229           || s == htab->sgot
2230           || s == htab->sgotplt
2231           || s == htab->sdynbss)
2232         {
2233           /* Strip this section if we don't need it; see the
2234              comment below.  */
2235         }
2236       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2237         {
2238           if (s->size != 0 && s != htab->srelplt)
2239             relocs = TRUE;
2240
2241           /* We use the reloc_count field as a counter if we need
2242              to copy relocs into the output file.  */
2243           s->reloc_count = 0;
2244         }
2245       else
2246         /* It's not one of our sections, so don't allocate space.  */
2247         continue;
2248
2249       if (s->size == 0)
2250         {
2251           /* If we don't need this section, strip it from the
2252              output file.  This is mostly to handle .rela.bss and
2253              .rela.plt.  We must create both sections in
2254              create_dynamic_sections, because they must be created
2255              before the linker maps input sections to output
2256              sections.  The linker does that before
2257              adjust_dynamic_symbol is called, and it is that
2258              function which decides whether anything needs to go
2259              into these sections.  */
2260           s->flags |= SEC_EXCLUDE;
2261           continue;
2262         }
2263
2264       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2265         continue;
2266
2267       /* Allocate memory for the section contents.  We use bfd_zalloc
2268          here in case unused entries are not reclaimed before the
2269          section's contents are written out.  This should not happen,
2270          but this way if it does, we get a R_LM32_NONE reloc instead
2271          of garbage.  */
2272       s->contents = bfd_zalloc (dynobj, s->size);
2273       if (s->contents == NULL)
2274         return FALSE;
2275     }
2276
2277   if (htab->root.dynamic_sections_created)
2278     {
2279       /* Add some entries to the .dynamic section.  We fill in the
2280          values later, in lm32_elf_finish_dynamic_sections, but we
2281          must add the entries now so that we get the correct size for
2282          the .dynamic section.  The DT_DEBUG entry is filled in by the
2283          dynamic linker and used by the debugger.  */
2284 #define add_dynamic_entry(TAG, VAL) \
2285   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2286
2287      if (bfd_link_executable (info))
2288         {
2289           if (! add_dynamic_entry (DT_DEBUG, 0))
2290             return FALSE;
2291         }
2292
2293       if (htab->splt->size != 0)
2294         {
2295           if (! add_dynamic_entry (DT_PLTGOT, 0)
2296               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2297               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2298               || ! add_dynamic_entry (DT_JMPREL, 0))
2299             return FALSE;
2300         }
2301
2302       if (relocs)
2303         {
2304           if (! add_dynamic_entry (DT_RELA, 0)
2305               || ! add_dynamic_entry (DT_RELASZ, 0)
2306               || ! add_dynamic_entry (DT_RELAENT,
2307                                       sizeof (Elf32_External_Rela)))
2308             return FALSE;
2309
2310           /* If any dynamic relocs apply to a read-only section,
2311              then we need a DT_TEXTREL entry.  */
2312           if ((info->flags & DF_TEXTREL) == 0)
2313             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2314                                     info);
2315
2316           if ((info->flags & DF_TEXTREL) != 0)
2317             {
2318               if (! add_dynamic_entry (DT_TEXTREL, 0))
2319                 return FALSE;
2320             }
2321         }
2322     }
2323 #undef add_dynamic_entry
2324
2325   /* Allocate .rofixup section.  */
2326   if (IS_FDPIC (output_bfd))
2327     {
2328       struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2329       int rgot_weak_count = 0;
2330       int r32_count = 0;
2331       int rgot_count = 0;
2332       /* Look for deleted sections.  */
2333       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2334         {
2335           for (s = ibfd->sections; s != NULL; s = s->next)
2336             {
2337               if (s->reloc_count)
2338                 {
2339                   /* Count relocs that need .rofixup entires.  */
2340                   Elf_Internal_Rela *internal_relocs, *end;
2341                   internal_relocs = elf_section_data (s)->relocs;
2342                   if (internal_relocs == NULL)
2343                     internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2344                   if (internal_relocs != NULL)
2345                     {
2346                       end = internal_relocs + s->reloc_count;
2347                       while (internal_relocs < end)
2348                         {
2349                           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2350                           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2351                           unsigned long r_symndx;
2352                           struct elf_link_hash_entry *h;
2353
2354                           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2355                           sym_hashes = elf_sym_hashes (ibfd);
2356                           r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2357                           h = NULL;
2358                           if (r_symndx < symtab_hdr->sh_info)
2359                             {
2360                             }
2361                           else
2362                             {
2363                               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2364                               while (h->root.type == bfd_link_hash_indirect
2365                                      || h->root.type == bfd_link_hash_warning)
2366                                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2367                               }
2368
2369                           /* Don't generate entries for weak symbols.  */
2370                           if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2371                             {
2372                               if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2373                                 {
2374                                   switch (ELF32_R_TYPE (internal_relocs->r_info))
2375                                     {
2376                                     case R_LM32_32:
2377                                       r32_count++;
2378                                       break;
2379                                     case R_LM32_16_GOT:
2380                                       rgot_count++;
2381                                       break;
2382                                     }
2383                                 }
2384                             }
2385                           else
2386                             {
2387                               struct weak_symbol_list *current, *new_entry;
2388                               /* Is this symbol already in the list?  */
2389                               for (current = list_start; current; current = current->next)
2390                                 {
2391                                   if (!strcmp (current->name, h->root.root.string))
2392                                     break;
2393                                 }
2394                               if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2395                                 {
2396                                   /* Will this have an entry in the GOT.  */
2397                                   if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2398                                     {
2399                                       /* Create a new entry.  */
2400                                       new_entry = malloc (sizeof (struct weak_symbol_list));
2401                                       if (!new_entry)
2402                                         return FALSE;
2403                                       new_entry->name = h->root.root.string;
2404                                       new_entry->next = NULL;
2405                                       /* Add to list */
2406                                       if (list_start == NULL)
2407                                         {
2408                                           list_start = new_entry;
2409                                           list_end = new_entry;
2410                                         }
2411                                       else
2412                                         {
2413                                           list_end->next = new_entry;
2414                                           list_end = new_entry;
2415                                         }
2416                                       /* Increase count of undefined weak symbols in the got.  */
2417                                       rgot_weak_count++;
2418                                     }
2419                                 }
2420                             }
2421                           internal_relocs++;
2422                         }
2423                     }
2424                   else
2425                     return FALSE;
2426                 }
2427             }
2428         }
2429       /* Free list.  */
2430       while (list_start)
2431         {
2432           list_end = list_start->next;
2433           free (list_start);
2434           list_start = list_end;
2435         }
2436
2437       /* Size sections.  */
2438       lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2439       if (lm32fdpic_fixup32_section (info)->size == 0)
2440         lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2441       else
2442         {
2443           lm32fdpic_fixup32_section (info)->contents =
2444              bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2445           if (lm32fdpic_fixup32_section (info)->contents == NULL)
2446             return FALSE;
2447         }
2448     }
2449
2450   return TRUE;
2451 }
2452
2453 /* Create dynamic sections when linking against a dynamic object.  */
2454
2455 static bfd_boolean
2456 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2457 {
2458   struct elf_lm32_link_hash_table *htab;
2459   flagword flags, pltflags;
2460   asection *s;
2461   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2462   int ptralign = 2; /* 32bit */
2463
2464   htab = lm32_elf_hash_table (info);
2465   if (htab == NULL)
2466     return FALSE;
2467
2468   /* Make sure we have a GOT - For the case where we have a dynamic object
2469      but none of the relocs in check_relocs */
2470   if (! create_got_section (abfd, info))
2471     return FALSE;
2472   if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2473     {
2474       if (! create_rofixup_section (abfd, info))
2475         return FALSE;
2476     }
2477
2478   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2479      .rel[a].bss sections.  */
2480   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2481            | SEC_LINKER_CREATED);
2482
2483   pltflags = flags;
2484   pltflags |= SEC_CODE;
2485   if (bed->plt_not_loaded)
2486     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2487   if (bed->plt_readonly)
2488     pltflags |= SEC_READONLY;
2489
2490   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2491   htab->splt = s;
2492   if (s == NULL
2493       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2494     return FALSE;
2495
2496   if (bed->want_plt_sym)
2497     {
2498       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2499          .plt section.  */
2500       struct bfd_link_hash_entry *bh = NULL;
2501       struct elf_link_hash_entry *h;
2502
2503       if (! (_bfd_generic_link_add_one_symbol
2504              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2505               (bfd_vma) 0, NULL, FALSE,
2506               get_elf_backend_data (abfd)->collect, &bh)))
2507         return FALSE;
2508       h = (struct elf_link_hash_entry *) bh;
2509       h->def_regular = 1;
2510       h->type = STT_OBJECT;
2511       htab->root.hplt = h;
2512
2513       if (bfd_link_pic (info)
2514           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2515         return FALSE;
2516     }
2517
2518   s = bfd_make_section_anyway_with_flags (abfd,
2519                                           bed->default_use_rela_p
2520                                           ? ".rela.plt" : ".rel.plt",
2521                                           flags | SEC_READONLY);
2522   htab->srelplt = s;
2523   if (s == NULL
2524       || ! bfd_set_section_alignment (abfd, s, ptralign))
2525     return FALSE;
2526
2527   if (htab->sgot == NULL
2528       && ! create_got_section (abfd, info))
2529     return FALSE;
2530
2531   if (bed->want_dynbss)
2532     {
2533       /* The .dynbss section is a place to put symbols which are defined
2534          by dynamic objects, are referenced by regular objects, and are
2535          not functions.  We must allocate space for them in the process
2536          image and use a R_*_COPY reloc to tell the dynamic linker to
2537          initialize them at run time.  The linker script puts the .dynbss
2538          section into the .bss section of the final image.  */
2539       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2540                                               SEC_ALLOC | SEC_LINKER_CREATED);
2541       htab->sdynbss = s;
2542       if (s == NULL)
2543         return FALSE;
2544       /* The .rel[a].bss section holds copy relocs.  This section is not
2545          normally needed.  We need to create it here, though, so that the
2546          linker will map it to an output section.  We can't just create it
2547          only if we need it, because we will not know whether we need it
2548          until we have seen all the input files, and the first time the
2549          main linker code calls BFD after examining all the input files
2550          (size_dynamic_sections) the input sections have already been
2551          mapped to the output sections.  If the section turns out not to
2552          be needed, we can discard it later.  We will never need this
2553          section when generating a shared object, since they do not use
2554          copy relocs.  */
2555       if (! bfd_link_pic (info))
2556         {
2557           s = bfd_make_section_anyway_with_flags (abfd,
2558                                                   (bed->default_use_rela_p
2559                                                    ? ".rela.bss" : ".rel.bss"),
2560                                                   flags | SEC_READONLY);
2561           htab->srelbss = s;
2562           if (s == NULL
2563               || ! bfd_set_section_alignment (abfd, s, ptralign))
2564             return FALSE;
2565         }
2566     }
2567
2568   return TRUE;
2569 }
2570
2571 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2572
2573 static void
2574 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2575                                struct elf_link_hash_entry *dir,
2576                                struct elf_link_hash_entry *ind)
2577 {
2578   struct elf_lm32_link_hash_entry * edir;
2579   struct elf_lm32_link_hash_entry * eind;
2580
2581   edir = (struct elf_lm32_link_hash_entry *) dir;
2582   eind = (struct elf_lm32_link_hash_entry *) ind;
2583
2584   if (eind->dyn_relocs != NULL)
2585     {
2586       if (edir->dyn_relocs != NULL)
2587         {
2588           struct elf_lm32_dyn_relocs **pp;
2589           struct elf_lm32_dyn_relocs *p;
2590
2591           /* Add reloc counts against the indirect sym to the direct sym
2592              list.  Merge any entries against the same section.  */
2593           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2594             {
2595               struct elf_lm32_dyn_relocs *q;
2596
2597               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2598                 if (q->sec == p->sec)
2599                   {
2600                     q->pc_count += p->pc_count;
2601                     q->count += p->count;
2602                     *pp = p->next;
2603                     break;
2604                   }
2605               if (q == NULL)
2606                 pp = &p->next;
2607             }
2608           *pp = edir->dyn_relocs;
2609         }
2610
2611       edir->dyn_relocs = eind->dyn_relocs;
2612       eind->dyn_relocs = NULL;
2613     }
2614
2615   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2616 }
2617
2618 static bfd_boolean
2619 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2620 {
2621   if (!bfd_link_relocatable (info))
2622     {
2623       if (!bfd_elf_stack_segment_size (output_bfd, info,
2624                                        "__stacksize", DEFAULT_STACK_SIZE))
2625         return FALSE;
2626
2627       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2628       if (sec)
2629         sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2630     }
2631
2632   return TRUE;
2633 }
2634
2635 static bfd_boolean
2636 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2637 {
2638   unsigned i;
2639
2640   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2641       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2642     return TRUE;
2643
2644   if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2645     return FALSE;
2646
2647   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2648       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2649     return TRUE;
2650
2651   /* Copy the stack size.  */
2652   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2653     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2654       {
2655         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2656
2657         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2658           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2659             {
2660               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2661
2662               /* Rewrite the phdrs, since we're only called after they were first written.  */
2663               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2664                             ->s->sizeof_ehdr, SEEK_SET) != 0
2665                   || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2666                                      elf_elfheader (obfd)->e_phnum) != 0)
2667                 return FALSE;
2668               break;
2669             }
2670
2671         break;
2672       }
2673
2674   return TRUE;
2675 }
2676
2677
2678 #define ELF_ARCH                bfd_arch_lm32
2679 #define ELF_TARGET_ID           LM32_ELF_DATA
2680 #define ELF_MACHINE_CODE        EM_LATTICEMICO32
2681 #define ELF_MAXPAGESIZE         0x1000
2682
2683 #define TARGET_BIG_SYM          lm32_elf32_vec
2684 #define TARGET_BIG_NAME         "elf32-lm32"
2685
2686 #define bfd_elf32_bfd_reloc_type_lookup         lm32_reloc_type_lookup
2687 #define bfd_elf32_bfd_reloc_name_lookup         lm32_reloc_name_lookup
2688 #define elf_info_to_howto                       lm32_info_to_howto_rela
2689 #define elf_info_to_howto_rel                   0
2690 #define elf_backend_rela_normal                 1
2691 #define elf_backend_object_p                    lm32_elf_object_p
2692 #define elf_backend_final_write_processing      lm32_elf_final_write_processing
2693 #define elf_backend_stack_align                 8
2694 #define elf_backend_can_gc_sections             1
2695 #define elf_backend_can_refcount                1
2696 #define elf_backend_gc_mark_hook                lm32_elf_gc_mark_hook
2697 #define elf_backend_gc_sweep_hook               lm32_elf_gc_sweep_hook
2698 #define elf_backend_plt_readonly                1
2699 #define elf_backend_want_got_plt                1
2700 #define elf_backend_want_plt_sym                0
2701 #define elf_backend_got_header_size             12
2702 #define bfd_elf32_bfd_link_hash_table_create    lm32_elf_link_hash_table_create
2703 #define elf_backend_check_relocs                lm32_elf_check_relocs
2704 #define elf_backend_reloc_type_class            lm32_elf_reloc_type_class
2705 #define elf_backend_copy_indirect_symbol        lm32_elf_copy_indirect_symbol
2706 #define elf_backend_size_dynamic_sections       lm32_elf_size_dynamic_sections
2707 #define elf_backend_omit_section_dynsym         ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2708 #define elf_backend_create_dynamic_sections     lm32_elf_create_dynamic_sections
2709 #define elf_backend_finish_dynamic_sections     lm32_elf_finish_dynamic_sections
2710 #define elf_backend_adjust_dynamic_symbol       lm32_elf_adjust_dynamic_symbol
2711 #define elf_backend_finish_dynamic_symbol       lm32_elf_finish_dynamic_symbol
2712 #define elf_backend_relocate_section            lm32_elf_relocate_section
2713
2714 #include "elf32-target.h"
2715
2716 #undef  ELF_MAXPAGESIZE
2717 #define ELF_MAXPAGESIZE         0x4000
2718
2719
2720 #undef  TARGET_BIG_SYM
2721 #define TARGET_BIG_SYM          lm32_elf32_fdpic_vec
2722 #undef  TARGET_BIG_NAME
2723 #define TARGET_BIG_NAME         "elf32-lm32fdpic"
2724 #undef  elf32_bed
2725 #define elf32_bed               elf32_lm32fdpic_bed
2726
2727 #undef  elf_backend_always_size_sections
2728 #define elf_backend_always_size_sections        lm32_elf_always_size_sections
2729 #undef  bfd_elf32_bfd_copy_private_bfd_data
2730 #define bfd_elf32_bfd_copy_private_bfd_data     lm32_elf_fdpic_copy_private_bfd_data
2731
2732 #include "elf32-target.h"