bfd/elf32-lm32.c

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