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 (strcmp (h->root.root.string, "_DYNAMIC") == 0
1749       || h == htab->root.hgot)
1750     sym->st_shndx = SHN_ABS;
1751
1752   return TRUE;
1753 }
1754
1755 static enum elf_reloc_type_class
1756 lm32_elf_reloc_type_class (const Elf_Internal_Rela *rela)
1757 {
1758   switch ((int) ELF32_R_TYPE (rela->r_info))
1759     {
1760     case R_LM32_RELATIVE:  return reloc_class_relative;
1761     case R_LM32_JMP_SLOT:  return reloc_class_plt;
1762     case R_LM32_COPY:      return reloc_class_copy;
1763     default:               return reloc_class_normal;
1764     }
1765 }
1766
1767 /* Adjust a symbol defined by a dynamic object and referenced by a
1768    regular object.  The current definition is in some section of the
1769    dynamic object, but we're not including those sections.  We have to
1770    change the definition to something the rest of the link can
1771    understand.  */
1772
1773 static bfd_boolean
1774 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1775                                 struct elf_link_hash_entry *h)
1776 {
1777   struct elf_lm32_link_hash_table *htab;
1778   struct elf_lm32_link_hash_entry *eh;
1779   struct elf_lm32_dyn_relocs *p;
1780   bfd *dynobj;
1781   asection *s;
1782
1783   dynobj = elf_hash_table (info)->dynobj;
1784
1785   /* Make sure we know what is going on here.  */
1786   BFD_ASSERT (dynobj != NULL
1787               && (h->needs_plt
1788                   || h->u.weakdef != NULL
1789                   || (h->def_dynamic
1790                       && h->ref_regular
1791                       && !h->def_regular)));
1792
1793   /* If this is a function, put it in the procedure linkage table.  We
1794      will fill in the contents of the procedure linkage table later,
1795      when we know the address of the .got section.  */
1796   if (h->type == STT_FUNC
1797       || h->needs_plt)
1798     {
1799       if (! info->shared
1800           && !h->def_dynamic
1801           && !h->ref_dynamic
1802           && h->root.type != bfd_link_hash_undefweak
1803           && h->root.type != bfd_link_hash_undefined)
1804         {
1805           /* This case can occur if we saw a PLT reloc in an input
1806              file, but the symbol was never referred to by a dynamic
1807              object.  In such a case, we don't actually need to build
1808              a procedure linkage table, and we can just do a PCREL
1809              reloc instead.  */
1810           h->plt.offset = (bfd_vma) -1;
1811           h->needs_plt = 0;
1812         }
1813
1814       return TRUE;
1815     }
1816   else
1817     h->plt.offset = (bfd_vma) -1;
1818
1819   /* If this is a weak symbol, and there is a real definition, the
1820      processor independent code will have arranged for us to see the
1821      real definition first, and we can just use the same value.  */
1822   if (h->u.weakdef != NULL)
1823     {
1824       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
1825                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
1826       h->root.u.def.section = h->u.weakdef->root.u.def.section;
1827       h->root.u.def.value = h->u.weakdef->root.u.def.value;
1828       return TRUE;
1829     }
1830
1831   /* This is a reference to a symbol defined by a dynamic object which
1832      is not a function.  */
1833
1834   /* If we are creating a shared library, we must presume that the
1835      only references to the symbol are via the global offset table.
1836      For such cases we need not do anything here; the relocations will
1837      be handled correctly by relocate_section.  */
1838   if (info->shared)
1839     return TRUE;
1840
1841   /* If there are no references to this symbol that do not use the
1842      GOT, we don't need to generate a copy reloc.  */
1843   if (!h->non_got_ref)
1844     return TRUE;
1845
1846   /* If -z nocopyreloc was given, we won't generate them either.  */
1847   if (info->nocopyreloc)
1848     {
1849       h->non_got_ref = 0;
1850       return TRUE;
1851     }
1852
1853   eh = (struct elf_lm32_link_hash_entry *) h;
1854   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1855     {
1856       s = p->sec->output_section;
1857       if (s != NULL && (s->flags & (SEC_READONLY | SEC_HAS_CONTENTS)) != 0)
1858         break;
1859     }
1860
1861   /* If we didn't find any dynamic relocs in sections which needs the
1862      copy reloc, then we'll be keeping the dynamic relocs and avoiding
1863      the copy reloc.  */
1864   if (p == NULL)
1865     {
1866       h->non_got_ref = 0;
1867       return TRUE;
1868     }
1869
1870   /* We must allocate the symbol in our .dynbss section, which will
1871      become part of the .bss section of the executable.  There will be
1872      an entry for this symbol in the .dynsym section.  The dynamic
1873      object will contain position independent code, so all references
1874      from the dynamic object to this symbol will go through the global
1875      offset table.  The dynamic linker will use the .dynsym entry to
1876      determine the address it must put in the global offset table, so
1877      both the dynamic object and the regular object will refer to the
1878      same memory location for the variable.  */
1879
1880   htab = lm32_elf_hash_table (info);
1881   if (htab == NULL)
1882     return FALSE;
1883
1884   s = htab->sdynbss;
1885   BFD_ASSERT (s != NULL);
1886
1887   /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1888      to copy the initial value out of the dynamic object and into the
1889      runtime process image.  We need to remember the offset into the
1890      .rela.bss section we are going to use.  */
1891   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1892     {
1893       asection *srel;
1894
1895       srel = htab->srelbss;
1896       BFD_ASSERT (srel != NULL);
1897       srel->size += sizeof (Elf32_External_Rela);
1898       h->needs_copy = 1;
1899     }
1900
1901   return _bfd_elf_adjust_dynamic_copy (h, s);
1902 }
1903
1904 /* Allocate space in .plt, .got and associated reloc sections for
1905    dynamic relocs.  */
1906
1907 static bfd_boolean
1908 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1909 {
1910   struct bfd_link_info *info;
1911   struct elf_lm32_link_hash_table *htab;
1912   struct elf_lm32_link_hash_entry *eh;
1913   struct elf_lm32_dyn_relocs *p;
1914
1915   if (h->root.type == bfd_link_hash_indirect)
1916     return TRUE;
1917
1918   info = (struct bfd_link_info *) inf;
1919   htab = lm32_elf_hash_table (info);
1920   if (htab == NULL)
1921     return FALSE;
1922
1923   eh = (struct elf_lm32_link_hash_entry *) h;
1924
1925   if (htab->root.dynamic_sections_created
1926       && h->plt.refcount > 0)
1927     {
1928       /* Make sure this symbol is output as a dynamic symbol.
1929          Undefined weak syms won't yet be marked as dynamic.  */
1930       if (h->dynindx == -1
1931           && !h->forced_local)
1932         {
1933           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1934             return FALSE;
1935         }
1936
1937       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, info->shared, h))
1938         {
1939           asection *s = htab->splt;
1940
1941           /* If this is the first .plt entry, make room for the special
1942              first entry.  */
1943           if (s->size == 0)
1944             s->size += PLT_ENTRY_SIZE;
1945
1946           h->plt.offset = s->size;
1947
1948           /* If this symbol is not defined in a regular file, and we are
1949              not generating a shared library, then set the symbol to this
1950              location in the .plt.  This is required to make function
1951              pointers compare as equal between the normal executable and
1952              the shared library.  */
1953           if (! info->shared
1954               && !h->def_regular)
1955             {
1956               h->root.u.def.section = s;
1957               h->root.u.def.value = h->plt.offset;
1958             }
1959
1960           /* Make room for this entry.  */
1961           s->size += PLT_ENTRY_SIZE;
1962
1963           /* We also need to make an entry in the .got.plt section, which
1964              will be placed in the .got section by the linker script.  */
1965           htab->sgotplt->size += 4;
1966
1967           /* We also need to make an entry in the .rel.plt section.  */
1968           htab->srelplt->size += sizeof (Elf32_External_Rela);
1969         }
1970       else
1971         {
1972           h->plt.offset = (bfd_vma) -1;
1973           h->needs_plt = 0;
1974         }
1975     }
1976   else
1977     {
1978       h->plt.offset = (bfd_vma) -1;
1979       h->needs_plt = 0;
1980     }
1981
1982   if (h->got.refcount > 0)
1983     {
1984       asection *s;
1985       bfd_boolean dyn;
1986
1987       /* Make sure this symbol is output as a dynamic symbol.
1988          Undefined weak syms won't yet be marked as dynamic.  */
1989       if (h->dynindx == -1
1990           && !h->forced_local)
1991         {
1992           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1993             return FALSE;
1994         }
1995
1996       s = htab->sgot;
1997
1998       h->got.offset = s->size;
1999       s->size += 4;
2000       dyn = htab->root.dynamic_sections_created;
2001       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, info->shared, h))
2002         htab->srelgot->size += sizeof (Elf32_External_Rela);
2003     }
2004   else
2005     h->got.offset = (bfd_vma) -1;
2006
2007   if (eh->dyn_relocs == NULL)
2008     return TRUE;
2009
2010   /* In the shared -Bsymbolic case, discard space allocated for
2011      dynamic pc-relative relocs against symbols which turn out to be
2012      defined in regular objects.  For the normal shared case, discard
2013      space for pc-relative relocs that have become local due to symbol
2014      visibility changes.  */
2015
2016   if (info->shared)
2017     {
2018       if (h->def_regular
2019           && (h->forced_local
2020               || info->symbolic))
2021         {
2022           struct elf_lm32_dyn_relocs **pp;
2023
2024           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
2025             {
2026               p->count -= p->pc_count;
2027               p->pc_count = 0;
2028               if (p->count == 0)
2029                 *pp = p->next;
2030               else
2031                 pp = &p->next;
2032             }
2033         }
2034
2035       /* Also discard relocs on undefined weak syms with non-default
2036          visibility.  */
2037       if (eh->dyn_relocs != NULL
2038           && h->root.type == bfd_link_hash_undefweak)
2039         {
2040           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
2041             eh->dyn_relocs = NULL;
2042
2043           /* Make sure undefined weak symbols are output as a dynamic
2044              symbol in PIEs.  */
2045           else if (h->dynindx == -1
2046                    && !h->forced_local)
2047             {
2048               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2049                 return FALSE;
2050             }
2051         }
2052     }
2053   else
2054     {
2055       /* For the non-shared case, discard space for relocs against
2056          symbols which turn out to need copy relocs or are not
2057          dynamic.  */
2058
2059       if (!h->non_got_ref
2060           && ((h->def_dynamic
2061                && !h->def_regular)
2062               || (htab->root.dynamic_sections_created
2063                   && (h->root.type == bfd_link_hash_undefweak
2064                       || h->root.type == bfd_link_hash_undefined))))
2065         {
2066           /* Make sure this symbol is output as a dynamic symbol.
2067              Undefined weak syms won't yet be marked as dynamic.  */
2068           if (h->dynindx == -1
2069               && !h->forced_local)
2070             {
2071               if (! bfd_elf_link_record_dynamic_symbol (info, h))
2072                 return FALSE;
2073             }
2074
2075           /* If that succeeded, we know we'll be keeping all the
2076              relocs.  */
2077           if (h->dynindx != -1)
2078             goto keep;
2079         }
2080
2081       eh->dyn_relocs = NULL;
2082
2083     keep: ;
2084     }
2085
2086   /* Finally, allocate space.  */
2087   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2088     {
2089       asection *sreloc = elf_section_data (p->sec)->sreloc;
2090       sreloc->size += p->count * sizeof (Elf32_External_Rela);
2091     }
2092
2093   return TRUE;
2094 }
2095
2096 /* Find any dynamic relocs that apply to read-only sections.  */
2097
2098 static bfd_boolean
2099 readonly_dynrelocs (struct elf_link_hash_entry *h, void * inf)
2100 {
2101   struct elf_lm32_link_hash_entry *eh;
2102   struct elf_lm32_dyn_relocs *p;
2103
2104   eh = (struct elf_lm32_link_hash_entry *) h;
2105   for (p = eh->dyn_relocs; p != NULL; p = p->next)
2106     {
2107       asection *s = p->sec->output_section;
2108
2109       if (s != NULL && (s->flags & SEC_READONLY) != 0)
2110         {
2111           struct bfd_link_info *info = (struct bfd_link_info *) inf;
2112
2113           info->flags |= DF_TEXTREL;
2114
2115           /* Not an error, just cut short the traversal.  */
2116           return FALSE;
2117         }
2118     }
2119   return TRUE;
2120 }
2121
2122 /* Set the sizes of the dynamic sections.  */
2123
2124 static bfd_boolean
2125 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2126                                 struct bfd_link_info *info)
2127 {
2128   struct elf_lm32_link_hash_table *htab;
2129   bfd *dynobj;
2130   asection *s;
2131   bfd_boolean relocs;
2132   bfd *ibfd;
2133
2134   htab = lm32_elf_hash_table (info);
2135   if (htab == NULL)
2136     return FALSE;
2137
2138   dynobj = htab->root.dynobj;
2139   BFD_ASSERT (dynobj != NULL);
2140
2141   if (htab->root.dynamic_sections_created)
2142     {
2143       /* Set the contents of the .interp section to the interpreter.  */
2144       if (info->executable)
2145         {
2146           s = bfd_get_linker_section (dynobj, ".interp");
2147           BFD_ASSERT (s != NULL);
2148           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2149           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2150         }
2151     }
2152
2153   /* Set up .got offsets for local syms, and space for local dynamic
2154      relocs.  */
2155   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2156     {
2157       bfd_signed_vma *local_got;
2158       bfd_signed_vma *end_local_got;
2159       bfd_size_type locsymcount;
2160       Elf_Internal_Shdr *symtab_hdr;
2161       asection *srel;
2162
2163       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2164         continue;
2165
2166       for (s = ibfd->sections; s != NULL; s = s->next)
2167         {
2168           struct elf_lm32_dyn_relocs *p;
2169
2170           for (p = ((struct elf_lm32_dyn_relocs *)
2171                     elf_section_data (s)->local_dynrel);
2172                p != NULL;
2173                p = p->next)
2174             {
2175               if (! bfd_is_abs_section (p->sec)
2176                   && bfd_is_abs_section (p->sec->output_section))
2177                 {
2178                   /* Input section has been discarded, either because
2179                      it is a copy of a linkonce section or due to
2180                      linker script /DISCARD/, so we'll be discarding
2181                      the relocs too.  */
2182                 }
2183               else if (p->count != 0)
2184                 {
2185                   srel = elf_section_data (p->sec)->sreloc;
2186                   srel->size += p->count * sizeof (Elf32_External_Rela);
2187                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2188                     info->flags |= DF_TEXTREL;
2189                 }
2190             }
2191         }
2192
2193       local_got = elf_local_got_refcounts (ibfd);
2194       if (!local_got)
2195         continue;
2196
2197       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2198       locsymcount = symtab_hdr->sh_info;
2199       end_local_got = local_got + locsymcount;
2200       s = htab->sgot;
2201       srel = htab->srelgot;
2202       for (; local_got < end_local_got; ++local_got)
2203         {
2204           if (*local_got > 0)
2205             {
2206               *local_got = s->size;
2207               s->size += 4;
2208               if (info->shared)
2209                 srel->size += sizeof (Elf32_External_Rela);
2210             }
2211           else
2212             *local_got = (bfd_vma) -1;
2213         }
2214     }
2215
2216   /* Allocate global sym .plt and .got entries, and space for global
2217      sym dynamic relocs.  */
2218   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2219
2220   /* We now have determined the sizes of the various dynamic sections.
2221      Allocate memory for them.  */
2222   relocs = FALSE;
2223   for (s = dynobj->sections; s != NULL; s = s->next)
2224     {
2225       if ((s->flags & SEC_LINKER_CREATED) == 0)
2226         continue;
2227
2228       if (s == htab->splt
2229           || s == htab->sgot
2230           || s == htab->sgotplt
2231           || s == htab->sdynbss)
2232         {
2233           /* Strip this section if we don't need it; see the
2234              comment below.  */
2235         }
2236       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2237         {
2238           if (s->size != 0 && s != htab->srelplt)
2239             relocs = TRUE;
2240
2241           /* We use the reloc_count field as a counter if we need
2242              to copy relocs into the output file.  */
2243           s->reloc_count = 0;
2244         }
2245       else
2246         /* It's not one of our sections, so don't allocate space.  */
2247         continue;
2248
2249       if (s->size == 0)
2250         {
2251           /* If we don't need this section, strip it from the
2252              output file.  This is mostly to handle .rela.bss and
2253              .rela.plt.  We must create both sections in
2254              create_dynamic_sections, because they must be created
2255              before the linker maps input sections to output
2256              sections.  The linker does that before
2257              adjust_dynamic_symbol is called, and it is that
2258              function which decides whether anything needs to go
2259              into these sections.  */
2260           s->flags |= SEC_EXCLUDE;
2261           continue;
2262         }
2263
2264       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2265         continue;
2266
2267       /* Allocate memory for the section contents.  We use bfd_zalloc
2268          here in case unused entries are not reclaimed before the
2269          section's contents are written out.  This should not happen,
2270          but this way if it does, we get a R_LM32_NONE reloc instead
2271          of garbage.  */
2272       s->contents = bfd_zalloc (dynobj, s->size);
2273       if (s->contents == NULL)
2274         return FALSE;
2275     }
2276
2277   if (htab->root.dynamic_sections_created)
2278     {
2279       /* Add some entries to the .dynamic section.  We fill in the
2280          values later, in lm32_elf_finish_dynamic_sections, but we
2281          must add the entries now so that we get the correct size for
2282          the .dynamic section.  The DT_DEBUG entry is filled in by the
2283          dynamic linker and used by the debugger.  */
2284 #define add_dynamic_entry(TAG, VAL) \
2285   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2286
2287      if (info->executable)
2288         {
2289           if (! add_dynamic_entry (DT_DEBUG, 0))
2290             return FALSE;
2291         }
2292
2293       if (htab->splt->size != 0)
2294         {
2295           if (! add_dynamic_entry (DT_PLTGOT, 0)
2296               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2297               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2298               || ! add_dynamic_entry (DT_JMPREL, 0))
2299             return FALSE;
2300         }
2301
2302       if (relocs)
2303         {
2304           if (! add_dynamic_entry (DT_RELA, 0)
2305               || ! add_dynamic_entry (DT_RELASZ, 0)
2306               || ! add_dynamic_entry (DT_RELAENT,
2307                                       sizeof (Elf32_External_Rela)))
2308             return FALSE;
2309
2310           /* If any dynamic relocs apply to a read-only section,
2311              then we need a DT_TEXTREL entry.  */
2312           if ((info->flags & DF_TEXTREL) == 0)
2313             elf_link_hash_traverse (&htab->root, readonly_dynrelocs,
2314                                     info);
2315
2316           if ((info->flags & DF_TEXTREL) != 0)
2317             {
2318               if (! add_dynamic_entry (DT_TEXTREL, 0))
2319                 return FALSE;
2320             }
2321         }
2322     }
2323 #undef add_dynamic_entry
2324
2325   /* Allocate .rofixup section.  */
2326   if (IS_FDPIC (output_bfd))
2327     {
2328       struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2329       int rgot_weak_count = 0;
2330       int r32_count = 0;
2331       int rgot_count = 0;
2332       /* Look for deleted sections.  */
2333       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link_next)
2334         {
2335           for (s = ibfd->sections; s != NULL; s = s->next)
2336             {
2337               if (s->reloc_count)
2338                 {
2339                   /* Count relocs that need .rofixup entires.  */
2340                   Elf_Internal_Rela *internal_relocs, *end;
2341                   internal_relocs = elf_section_data (s)->relocs;
2342                   if (internal_relocs == NULL)
2343                     internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2344                   if (internal_relocs != NULL)
2345                     {
2346                       end = internal_relocs + s->reloc_count;
2347                       while (internal_relocs < end)
2348                         {
2349                           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2350                           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2351                           unsigned long r_symndx;
2352                           struct elf_link_hash_entry *h;
2353
2354                           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2355                           sym_hashes = elf_sym_hashes (ibfd);
2356                           r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2357                           h = NULL;
2358                           if (r_symndx < symtab_hdr->sh_info)
2359                             {
2360                             }
2361                           else
2362                             {
2363                               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2364                               while (h->root.type == bfd_link_hash_indirect
2365                                      || h->root.type == bfd_link_hash_warning)
2366                                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2367                               }
2368
2369                           /* Don't generate entries for weak symbols.  */
2370                           if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2371                             {
2372                               if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2373                                 {
2374                                   switch (ELF32_R_TYPE (internal_relocs->r_info))
2375                                     {
2376                                     case R_LM32_32:
2377                                       r32_count++;
2378                                       break;
2379                                     case R_LM32_16_GOT:
2380                                       rgot_count++;
2381                                       break;
2382                                     }
2383                                 }
2384                             }
2385                           else
2386                             {
2387                               struct weak_symbol_list *current, *new_entry;
2388                               /* Is this symbol already in the list?  */
2389                               for (current = list_start; current; current = current->next)
2390                                 {
2391                                   if (!strcmp (current->name, h->root.root.string))
2392                                     break;
2393                                 }
2394                               if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2395                                 {
2396                                   /* Will this have an entry in the GOT.  */
2397                                   if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2398                                     {
2399                                       /* Create a new entry.  */
2400                                       new_entry = malloc (sizeof (struct weak_symbol_list));
2401                                       if (!new_entry)
2402                                         return FALSE;
2403                                       new_entry->name = h->root.root.string;
2404                                       new_entry->next = NULL;
2405                                       /* Add to list */
2406                                       if (list_start == NULL)
2407                                         {
2408                                           list_start = new_entry;
2409                                           list_end = new_entry;
2410                                         }
2411                                       else
2412                                         {
2413                                           list_end->next = new_entry;
2414                                           list_end = new_entry;
2415                                         }
2416                                       /* Increase count of undefined weak symbols in the got.  */
2417                                       rgot_weak_count++;
2418                                     }
2419                                 }
2420                             }
2421                           internal_relocs++;
2422                         }
2423                     }
2424                   else
2425                     return FALSE;
2426                 }
2427             }
2428         }
2429       /* Free list.  */
2430       while (list_start)
2431         {
2432           list_end = list_start->next;
2433           free (list_start);
2434           list_start = list_end;
2435         }
2436
2437       /* Size sections.  */
2438       lm32fdpic_fixup32_section (info)->size = (r32_count + (htab->sgot->size / 4) - rgot_weak_count + 1) * 4;
2439       if (lm32fdpic_fixup32_section (info)->size == 0)
2440         lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2441       else
2442         {
2443           lm32fdpic_fixup32_section (info)->contents =
2444              bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2445           if (lm32fdpic_fixup32_section (info)->contents == NULL)
2446             return FALSE;
2447         }
2448     }
2449
2450   return TRUE;
2451 }
2452
2453 /* Create dynamic sections when linking against a dynamic object.  */
2454
2455 static bfd_boolean
2456 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2457 {
2458   struct elf_lm32_link_hash_table *htab;
2459   flagword flags, pltflags;
2460   asection *s;
2461   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2462   int ptralign = 2; /* 32bit */
2463
2464   htab = lm32_elf_hash_table (info);
2465   if (htab == NULL)
2466     return FALSE;
2467
2468   /* Make sure we have a GOT - For the case where we have a dynamic object
2469      but none of the relocs in check_relocs */
2470   if (! create_got_section (abfd, info))
2471     return FALSE;
2472   if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2473     {
2474       if (! create_rofixup_section (abfd, info))
2475         return FALSE;
2476     }
2477
2478   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2479      .rel[a].bss sections.  */
2480   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2481            | SEC_LINKER_CREATED);
2482
2483   pltflags = flags;
2484   pltflags |= SEC_CODE;
2485   if (bed->plt_not_loaded)
2486     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2487   if (bed->plt_readonly)
2488     pltflags |= SEC_READONLY;
2489
2490   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2491   htab->splt = s;
2492   if (s == NULL
2493       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2494     return FALSE;
2495
2496   if (bed->want_plt_sym)
2497     {
2498       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2499          .plt section.  */
2500       struct bfd_link_hash_entry *bh = NULL;
2501       struct elf_link_hash_entry *h;
2502
2503       if (! (_bfd_generic_link_add_one_symbol
2504              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2505               (bfd_vma) 0, NULL, FALSE,
2506               get_elf_backend_data (abfd)->collect, &bh)))
2507         return FALSE;
2508       h = (struct elf_link_hash_entry *) bh;
2509       h->def_regular = 1;
2510       h->type = STT_OBJECT;
2511       htab->root.hplt = h;
2512
2513       if (info->shared
2514           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2515         return FALSE;
2516     }
2517
2518   s = bfd_make_section_anyway_with_flags (abfd,
2519                                           bed->default_use_rela_p
2520                                           ? ".rela.plt" : ".rel.plt",
2521                                           flags | SEC_READONLY);
2522   htab->srelplt = s;
2523   if (s == NULL
2524       || ! bfd_set_section_alignment (abfd, s, ptralign))
2525     return FALSE;
2526
2527   if (htab->sgot == NULL
2528       && ! create_got_section (abfd, info))
2529     return FALSE;
2530
2531   if (bed->want_dynbss)
2532     {
2533       /* The .dynbss section is a place to put symbols which are defined
2534          by dynamic objects, are referenced by regular objects, and are
2535          not functions.  We must allocate space for them in the process
2536          image and use a R_*_COPY reloc to tell the dynamic linker to
2537          initialize them at run time.  The linker script puts the .dynbss
2538          section into the .bss section of the final image.  */
2539       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2540                                               SEC_ALLOC | SEC_LINKER_CREATED);
2541       htab->sdynbss = s;
2542       if (s == NULL)
2543         return FALSE;
2544       /* The .rel[a].bss section holds copy relocs.  This section is not
2545          normally needed.  We need to create it here, though, so that the
2546          linker will map it to an output section.  We can't just create it
2547          only if we need it, because we will not know whether we need it
2548          until we have seen all the input files, and the first time the
2549          main linker code calls BFD after examining all the input files
2550          (size_dynamic_sections) the input sections have already been
2551          mapped to the output sections.  If the section turns out not to
2552          be needed, we can discard it later.  We will never need this
2553          section when generating a shared object, since they do not use
2554          copy relocs.  */
2555       if (! info->shared)
2556         {
2557           s = bfd_make_section_anyway_with_flags (abfd,
2558                                                   (bed->default_use_rela_p
2559                                                    ? ".rela.bss" : ".rel.bss"),
2560                                                   flags | SEC_READONLY);
2561           htab->srelbss = s;
2562           if (s == NULL
2563               || ! bfd_set_section_alignment (abfd, s, ptralign))
2564             return FALSE;
2565         }
2566     }
2567
2568   return TRUE;
2569 }
2570
2571 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2572
2573 static void
2574 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2575                                struct elf_link_hash_entry *dir,
2576                                struct elf_link_hash_entry *ind)
2577 {
2578   struct elf_lm32_link_hash_entry * edir;
2579   struct elf_lm32_link_hash_entry * eind;
2580
2581   edir = (struct elf_lm32_link_hash_entry *) dir;
2582   eind = (struct elf_lm32_link_hash_entry *) ind;
2583
2584   if (eind->dyn_relocs != NULL)
2585     {
2586       if (edir->dyn_relocs != NULL)
2587         {
2588           struct elf_lm32_dyn_relocs **pp;
2589           struct elf_lm32_dyn_relocs *p;
2590
2591           /* Add reloc counts against the indirect sym to the direct sym
2592              list.  Merge any entries against the same section.  */
2593           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2594             {
2595               struct elf_lm32_dyn_relocs *q;
2596
2597               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2598                 if (q->sec == p->sec)
2599                   {
2600                     q->pc_count += p->pc_count;
2601                     q->count += p->count;
2602                     *pp = p->next;
2603                     break;
2604                   }
2605               if (q == NULL)
2606                 pp = &p->next;
2607             }
2608           *pp = edir->dyn_relocs;
2609         }
2610
2611       edir->dyn_relocs = eind->dyn_relocs;
2612       eind->dyn_relocs = NULL;
2613     }
2614
2615   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2616 }
2617
2618 static bfd_boolean
2619 lm32_elf_always_size_sections (bfd *output_bfd,
2620                                  struct bfd_link_info *info)
2621 {
2622   if (!info->relocatable)
2623     {
2624       struct elf_link_hash_entry *h;
2625
2626       /* Force a PT_GNU_STACK segment to be created.  */
2627       if (! elf_tdata (output_bfd)->stack_flags)
2628         elf_tdata (output_bfd)->stack_flags = PF_R | PF_W | PF_X;
2629
2630       /* Define __stacksize if it's not defined yet.  */
2631       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2632                                 FALSE, FALSE, FALSE);
2633       if (! h || h->root.type != bfd_link_hash_defined
2634           || h->type != STT_OBJECT
2635           || !h->def_regular)
2636         {
2637           struct bfd_link_hash_entry *bh = NULL;
2638
2639           if (!(_bfd_generic_link_add_one_symbol
2640                 (info, output_bfd, "__stacksize",
2641                  BSF_GLOBAL, bfd_abs_section_ptr, DEFAULT_STACK_SIZE,
2642                  (const char *) NULL, FALSE,
2643                  get_elf_backend_data (output_bfd)->collect, &bh)))
2644             return FALSE;
2645
2646           h = (struct elf_link_hash_entry *) bh;
2647           h->def_regular = 1;
2648           h->type = STT_OBJECT;
2649           /* This one must NOT be hidden.  */
2650         }
2651     }
2652
2653   return TRUE;
2654 }
2655
2656 static bfd_boolean
2657 lm32_elf_modify_segment_map (bfd *output_bfd,
2658                              struct bfd_link_info *info)
2659 {
2660   struct elf_segment_map *m;
2661
2662   /* objcopy and strip preserve what's already there using elf32_lm32fdpic_copy_
2663      private_bfd_data ().  */
2664   if (! info)
2665     return TRUE;
2666
2667   for (m = elf_tdata (output_bfd)->segment_map; m != NULL; m = m->next)
2668     if (m->p_type == PT_GNU_STACK)
2669       break;
2670
2671   if (m)
2672     {
2673       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2674       struct elf_link_hash_entry *h;
2675
2676       if (sec)
2677         {
2678           /* Obtain the pointer to the __stacksize symbol.  */
2679           h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2680                                     FALSE, FALSE, FALSE);
2681           while (h->root.type == bfd_link_hash_indirect
2682                  || h->root.type == bfd_link_hash_warning)
2683             h = (struct elf_link_hash_entry *)h->root.u.i.link;
2684           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2685
2686           /* Set the section size from the symbol value.  We
2687              intentionally ignore the symbol section.  */
2688           if (h->root.type == bfd_link_hash_defined)
2689             sec->size = h->root.u.def.value;
2690           else
2691             sec->size = DEFAULT_STACK_SIZE;
2692
2693           /* Add the stack section to the PT_GNU_STACK segment,
2694              such that its size and alignment requirements make it
2695              to the segment.  */
2696           m->sections[m->count] = sec;
2697           m->count++;
2698         }
2699     }
2700
2701   return TRUE;
2702 }
2703
2704 static bfd_boolean
2705 lm32_elf_modify_program_headers (bfd *output_bfd,
2706                                        struct bfd_link_info *info)
2707 {
2708   struct elf_obj_tdata *tdata = elf_tdata (output_bfd);
2709   struct elf_segment_map *m;
2710   Elf_Internal_Phdr *p;
2711
2712   if (! info)
2713     return TRUE;
2714
2715   for (p = tdata->phdr, m = tdata->segment_map; m != NULL; m = m->next, p++)
2716     if (m->p_type == PT_GNU_STACK)
2717       break;
2718
2719   if (m)
2720     {
2721       struct elf_link_hash_entry *h;
2722
2723       /* Obtain the pointer to the __stacksize symbol.  */
2724       h = elf_link_hash_lookup (elf_hash_table (info), "__stacksize",
2725                                 FALSE, FALSE, FALSE);
2726       if (h)
2727         {
2728           while (h->root.type == bfd_link_hash_indirect
2729                  || h->root.type == bfd_link_hash_warning)
2730             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2731           BFD_ASSERT (h->root.type == bfd_link_hash_defined);
2732         }
2733
2734       /* Set the header p_memsz from the symbol value.  We
2735          intentionally ignore the symbol section.  */
2736       if (h && h->root.type == bfd_link_hash_defined)
2737         p->p_memsz = h->root.u.def.value;
2738       else
2739         p->p_memsz = DEFAULT_STACK_SIZE;
2740
2741       p->p_align = 8;
2742     }
2743
2744   return TRUE;
2745 }
2746
2747
2748 static bfd_boolean
2749 lm32_elf_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2750 {
2751   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2752       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2753     return TRUE;
2754
2755   BFD_ASSERT (!elf_flags_init (obfd)
2756               || elf_elfheader (obfd)->e_flags == elf_elfheader (ibfd)->e_flags);
2757
2758   elf_elfheader (obfd)->e_flags = elf_elfheader (ibfd)->e_flags;
2759   elf_flags_init (obfd) = TRUE;
2760
2761   /* Copy object attributes.  */
2762   _bfd_elf_copy_obj_attributes (ibfd, obfd);
2763
2764   return TRUE;
2765 }
2766
2767
2768 static bfd_boolean
2769 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2770 {
2771   unsigned i;
2772
2773   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2774       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2775     return TRUE;
2776
2777   if (! lm32_elf_copy_private_bfd_data (ibfd, obfd))
2778     return FALSE;
2779
2780   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2781       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2782     return TRUE;
2783
2784   /* Copy the stack size.  */
2785   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2786     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2787       {
2788         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2789
2790         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2791           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2792             {
2793               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2794
2795               /* Rewrite the phdrs, since we're only called after they were first written.  */
2796               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2797                             ->s->sizeof_ehdr, SEEK_SET) != 0
2798                   || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2799                                      elf_elfheader (obfd)->e_phnum) != 0)
2800                 return FALSE;
2801               break;
2802             }
2803
2804         break;
2805       }
2806
2807   return TRUE;
2808 }
2809
2810
2811 #define ELF_ARCH                bfd_arch_lm32
2812 #define ELF_TARGET_ID           LM32_ELF_DATA
2813 #define ELF_MACHINE_CODE        EM_LATTICEMICO32
2814 #define ELF_MAXPAGESIZE         0x1000
2815
2816 #define TARGET_BIG_SYM          bfd_elf32_lm32_vec
2817 #define TARGET_BIG_NAME         "elf32-lm32"
2818
2819 #define bfd_elf32_bfd_reloc_type_lookup         lm32_reloc_type_lookup
2820 #define bfd_elf32_bfd_reloc_name_lookup         lm32_reloc_name_lookup
2821 #define elf_info_to_howto                       lm32_info_to_howto_rela
2822 #define elf_info_to_howto_rel                   0
2823 #define elf_backend_rela_normal                 1
2824 #define elf_backend_object_p                    lm32_elf_object_p
2825 #define elf_backend_final_write_processing      lm32_elf_final_write_processing
2826 #define elf_backend_can_gc_sections             1
2827 #define elf_backend_can_refcount                1
2828 #define elf_backend_gc_mark_hook                lm32_elf_gc_mark_hook
2829 #define elf_backend_gc_sweep_hook               lm32_elf_gc_sweep_hook
2830 #define elf_backend_plt_readonly                1
2831 #define elf_backend_want_got_plt                1
2832 #define elf_backend_want_plt_sym                0
2833 #define elf_backend_got_header_size             12
2834 #define bfd_elf32_bfd_link_hash_table_create    lm32_elf_link_hash_table_create
2835 #define elf_backend_check_relocs                lm32_elf_check_relocs
2836 #define elf_backend_reloc_type_class            lm32_elf_reloc_type_class
2837 #define elf_backend_copy_indirect_symbol        lm32_elf_copy_indirect_symbol
2838 #define elf_backend_size_dynamic_sections       lm32_elf_size_dynamic_sections
2839 #define elf_backend_omit_section_dynsym         ((bfd_boolean (*) (bfd *, struct bfd_link_info *, asection *)) bfd_true)
2840 #define elf_backend_create_dynamic_sections     lm32_elf_create_dynamic_sections
2841 #define elf_backend_finish_dynamic_sections     lm32_elf_finish_dynamic_sections
2842 #define elf_backend_adjust_dynamic_symbol       lm32_elf_adjust_dynamic_symbol
2843 #define elf_backend_finish_dynamic_symbol       lm32_elf_finish_dynamic_symbol
2844 #define elf_backend_relocate_section            lm32_elf_relocate_section
2845
2846 #include "elf32-target.h"
2847
2848 #undef  ELF_MAXPAGESIZE
2849 #define ELF_MAXPAGESIZE         0x4000
2850
2851
2852 #undef  TARGET_BIG_SYM
2853 #define TARGET_BIG_SYM          bfd_elf32_lm32fdpic_vec
2854 #undef  TARGET_BIG_NAME
2855 #define TARGET_BIG_NAME         "elf32-lm32fdpic"
2856 #undef  elf32_bed
2857 #define elf32_bed               elf32_lm32fdpic_bed
2858
2859 #undef  elf_backend_always_size_sections
2860 #define elf_backend_always_size_sections        lm32_elf_always_size_sections
2861 #undef  elf_backend_modify_segment_map
2862 #define elf_backend_modify_segment_map          lm32_elf_modify_segment_map
2863 #undef  elf_backend_modify_program_headers
2864 #define elf_backend_modify_program_headers      lm32_elf_modify_program_headers
2865 #undef  bfd_elf32_bfd_copy_private_bfd_data
2866 #define bfd_elf32_bfd_copy_private_bfd_data     lm32_elf_fdpic_copy_private_bfd_data
2867
2868 #include "elf32-target.h"