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