bfd/elf32-lm32.c

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