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