bfd/elf32-lm32.c

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