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 (_("internal error: addend should be zero for R_LM32_16_GOT"));
1000
1001               r = _bfd_final_link_relocate (howto,
1002                                             input_bfd,
1003                                             input_section,
1004                                             contents,
1005                                             rel->r_offset,
1006                                             relocation,
1007                                             rel->r_addend);
1008               break;
1009
1010             case R_LM32_GOTOFF_LO16:
1011             case R_LM32_GOTOFF_HI16:
1012               /* Relocation is offset from GOT.  */
1013               BFD_ASSERT (sgot != NULL);
1014               relocation -= sgot->output_section->vma;
1015               /* Account for sign-extension.  */
1016               if ((r_type == R_LM32_GOTOFF_HI16)
1017                   && ((relocation + rel->r_addend) & 0x8000))
1018                 rel->r_addend += 0x10000;
1019               r = _bfd_final_link_relocate (howto,
1020                                             input_bfd,
1021                                             input_section,
1022                                             contents,
1023                                             rel->r_offset,
1024                                             relocation,
1025                                             rel->r_addend);
1026               break;
1027
1028             case R_LM32_32:
1029               if (IS_FDPIC (output_bfd))
1030                 {
1031                   if ((!h) || (h && h->root.type != bfd_link_hash_undefweak))
1032                     {
1033                       /* Only create .rofixup entries for relocs in loadable sections.  */
1034                       if ((bfd_get_section_flags (output_bfd, input_section->output_section)
1035                           & (SEC_ALLOC | SEC_LOAD)) == (SEC_ALLOC | SEC_LOAD))
1036
1037                         {
1038                           /* Check address to be modified is writable.  */
1039                           if (_lm32fdpic_osec_readonly_p (output_bfd,
1040                                                           input_section
1041                                                            ->output_section))
1042                             {
1043                               info->callbacks->warning
1044                                 (info,
1045                                  _("cannot emit dynamic relocations in read-only section"),
1046                                  name, input_bfd, input_section, rel->r_offset);
1047                                return FALSE;
1048                             }
1049                           /* Create entry in .rofixup section.  */
1050                           _lm32fdpic_add_rofixup (output_bfd,
1051                                                   lm32fdpic_fixup32_section (info),
1052                                                   input_section->output_section->vma
1053                                                    + input_section->output_offset
1054                                                    + rel->r_offset);
1055                         }
1056                     }
1057                 }
1058               /* Fall through.  */
1059
1060             default:
1061               r = _bfd_final_link_relocate (howto,
1062                                             input_bfd,
1063                                             input_section,
1064                                             contents,
1065                                             rel->r_offset,
1066                                             relocation,
1067                                             rel->r_addend);
1068               break;
1069             }
1070         }
1071
1072       if (r != bfd_reloc_ok)
1073         {
1074           const char *msg = NULL;
1075           arelent bfd_reloc;
1076
1077           lm32_info_to_howto_rela (input_bfd, &bfd_reloc, rel);
1078           howto = bfd_reloc.howto;
1079
1080           if (h != NULL)
1081             name = h->root.root.string;
1082           else
1083             {
1084               name = (bfd_elf_string_from_elf_section
1085                       (input_bfd, symtab_hdr->sh_link, sym->st_name));
1086               if (name == NULL || *name == '\0')
1087                 name = bfd_section_name (input_bfd, sec);
1088             }
1089
1090           switch (r)
1091             {
1092             case bfd_reloc_overflow:
1093               if ((h != NULL)
1094                  && (h->root.type == bfd_link_hash_undefweak))
1095                 break;
1096               (*info->callbacks->reloc_overflow)
1097                 (info, (h ? &h->root : NULL), name, howto->name,
1098                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
1099               break;
1100
1101             case bfd_reloc_undefined:
1102               (*info->callbacks->undefined_symbol)
1103                 (info, name, input_bfd, input_section, rel->r_offset, TRUE);
1104               break;
1105
1106             case bfd_reloc_outofrange:
1107               msg = _("internal error: out of range error");
1108               goto common_error;
1109
1110             case bfd_reloc_notsupported:
1111               msg = _("internal error: unsupported relocation error");
1112               goto common_error;
1113
1114             case bfd_reloc_dangerous:
1115               msg = _("internal error: dangerous error");
1116               goto common_error;
1117
1118             default:
1119               msg = _("internal error: unknown error");
1120               /* fall through */
1121
1122             common_error:
1123               (*info->callbacks->warning) (info, msg, name, input_bfd,
1124                                            input_section, rel->r_offset);
1125               break;
1126             }
1127         }
1128     }
1129
1130   return TRUE;
1131 }
1132
1133 static asection *
1134 lm32_elf_gc_mark_hook (asection *sec,
1135                        struct bfd_link_info *info,
1136                        Elf_Internal_Rela *rel,
1137                        struct elf_link_hash_entry *h,
1138                        Elf_Internal_Sym *sym)
1139 {
1140   if (h != NULL)
1141     switch (ELF32_R_TYPE (rel->r_info))
1142       {
1143       case R_LM32_GNU_VTINHERIT:
1144       case R_LM32_GNU_VTENTRY:
1145         return NULL;
1146       }
1147
1148   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
1149 }
1150
1151 /* Look through the relocs for a section during the first phase.  */
1152
1153 static bfd_boolean
1154 lm32_elf_check_relocs (bfd *abfd,
1155                        struct bfd_link_info *info,
1156                        asection *sec,
1157                        const Elf_Internal_Rela *relocs)
1158 {
1159   Elf_Internal_Shdr *symtab_hdr;
1160   struct elf_link_hash_entry **sym_hashes, **sym_hashes_end;
1161   const Elf_Internal_Rela *rel;
1162   const Elf_Internal_Rela *rel_end;
1163   struct elf_lm32_link_hash_table *htab;
1164   bfd *dynobj;
1165
1166   if (bfd_link_relocatable (info))
1167     return TRUE;
1168
1169   /* Don't do anything special with non-loaded, non-alloced sections.
1170      In particular, any relocs in such sections should not affect GOT
1171      and PLT reference counting (ie. we don't allow them to create GOT
1172      or PLT entries), there's no possibility or desire to optimize TLS
1173      relocs, and there's not much point in propagating relocs to shared
1174      libs that the dynamic linker won't relocate.  */
1175   if ((sec->flags & SEC_ALLOC) == 0)
1176     return TRUE;
1177
1178   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
1179   sym_hashes = elf_sym_hashes (abfd);
1180   sym_hashes_end = sym_hashes + symtab_hdr->sh_size/sizeof (Elf32_External_Sym);
1181   if (!elf_bad_symtab (abfd))
1182     sym_hashes_end -= symtab_hdr->sh_info;
1183
1184   htab = lm32_elf_hash_table (info);
1185   if (htab == NULL)
1186     return FALSE;
1187
1188   dynobj = htab->root.dynobj;
1189
1190   rel_end = relocs + sec->reloc_count;
1191   for (rel = relocs; rel < rel_end; rel++)
1192     {
1193       int r_type;
1194       struct elf_link_hash_entry *h;
1195       unsigned long r_symndx;
1196
1197       r_symndx = ELF32_R_SYM (rel->r_info);
1198       r_type = ELF32_R_TYPE (rel->r_info);
1199       if (r_symndx < symtab_hdr->sh_info)
1200         h = NULL;
1201       else
1202         {
1203           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
1204           while (h->root.type == bfd_link_hash_indirect
1205                  || h->root.type == bfd_link_hash_warning)
1206             h = (struct elf_link_hash_entry *) h->root.u.i.link;
1207         }
1208
1209       /* Some relocs require a global offset table.  */
1210       if (htab->root.sgot == NULL)
1211         {
1212           switch (r_type)
1213             {
1214             case R_LM32_16_GOT:
1215             case R_LM32_GOTOFF_HI16:
1216             case R_LM32_GOTOFF_LO16:
1217               if (dynobj == NULL)
1218                 htab->root.dynobj = dynobj = abfd;
1219               if (!_bfd_elf_create_got_section (dynobj, info))
1220                 return FALSE;
1221               break;
1222             }
1223         }
1224
1225       /* Some relocs require a rofixup table. */
1226       if (IS_FDPIC (abfd))
1227         {
1228           switch (r_type)
1229             {
1230             case R_LM32_32:
1231               /* FDPIC requires a GOT if there is a .rofixup section
1232                  (Normal ELF doesn't). */
1233               if (dynobj == NULL)
1234                 htab->root.dynobj = dynobj = abfd;
1235               if (!_bfd_elf_create_got_section (dynobj, info))
1236                 return FALSE;
1237               /* Create .rofixup section */
1238               if (htab->sfixup32 == NULL)
1239                 {
1240                   if (! create_rofixup_section (dynobj, info))
1241                     return FALSE;
1242                 }
1243               break;
1244             case R_LM32_16_GOT:
1245             case R_LM32_GOTOFF_HI16:
1246             case R_LM32_GOTOFF_LO16:
1247               /* Create .rofixup section.  */
1248               if (htab->sfixup32 == NULL)
1249                 {
1250                   if (dynobj == NULL)
1251                     htab->root.dynobj = dynobj = abfd;
1252                   if (! create_rofixup_section (dynobj, info))
1253                     return FALSE;
1254                 }
1255               break;
1256             }
1257         }
1258
1259       switch (r_type)
1260         {
1261         case R_LM32_16_GOT:
1262           if (h != NULL)
1263             h->got.refcount += 1;
1264           else
1265             {
1266               bfd_signed_vma *local_got_refcounts;
1267
1268               /* This is a global offset table entry for a local symbol.  */
1269               local_got_refcounts = elf_local_got_refcounts (abfd);
1270               if (local_got_refcounts == NULL)
1271                 {
1272                   bfd_size_type size;
1273
1274                   size = symtab_hdr->sh_info;
1275                   size *= sizeof (bfd_signed_vma);
1276                   local_got_refcounts = bfd_zalloc (abfd, size);
1277                   if (local_got_refcounts == NULL)
1278                     return FALSE;
1279                   elf_local_got_refcounts (abfd) = local_got_refcounts;
1280                 }
1281               local_got_refcounts[r_symndx] += 1;
1282             }
1283           break;
1284
1285         /* This relocation describes the C++ object vtable hierarchy.
1286            Reconstruct it for later use during GC.  */
1287         case R_LM32_GNU_VTINHERIT:
1288           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
1289             return FALSE;
1290           break;
1291
1292         /* This relocation describes which C++ vtable entries are actually
1293            used.  Record for later use during GC.  */
1294         case R_LM32_GNU_VTENTRY:
1295           if (!bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
1296             return FALSE;
1297           break;
1298
1299         }
1300     }
1301
1302   return TRUE;
1303 }
1304
1305 /* Finish up the dynamic sections.  */
1306
1307 static bfd_boolean
1308 lm32_elf_finish_dynamic_sections (bfd *output_bfd,
1309                                   struct bfd_link_info *info)
1310 {
1311   struct elf_lm32_link_hash_table *htab;
1312   bfd *dynobj;
1313   asection *sdyn;
1314   asection *sgot;
1315
1316   htab = lm32_elf_hash_table (info);
1317   if (htab == NULL)
1318     return FALSE;
1319
1320   dynobj = htab->root.dynobj;
1321
1322   sgot = htab->root.sgotplt;
1323   sdyn = bfd_get_linker_section (dynobj, ".dynamic");
1324
1325   if (htab->root.dynamic_sections_created)
1326     {
1327       asection *splt;
1328       Elf32_External_Dyn *dyncon, *dynconend;
1329
1330       BFD_ASSERT (sgot != NULL && sdyn != NULL);
1331
1332       dyncon = (Elf32_External_Dyn *) sdyn->contents;
1333       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
1334
1335       for (; dyncon < dynconend; dyncon++)
1336         {
1337           Elf_Internal_Dyn dyn;
1338           asection *s;
1339
1340           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
1341
1342           switch (dyn.d_tag)
1343             {
1344             default:
1345               break;
1346
1347             case DT_PLTGOT:
1348               s = htab->root.sgotplt;
1349               goto get_vma;
1350             case DT_JMPREL:
1351               s = htab->root.srelplt;
1352             get_vma:
1353               dyn.d_un.d_ptr = s->output_section->vma + s->output_offset;
1354               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1355               break;
1356
1357             case DT_PLTRELSZ:
1358               s = htab->root.srelplt;
1359               dyn.d_un.d_val = s->size;
1360               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
1361               break;
1362             }
1363         }
1364
1365       /* Fill in the first entry in the procedure linkage table.  */
1366       splt = htab->root.splt;
1367       if (splt && splt->size > 0)
1368         {
1369           if (bfd_link_pic (info))
1370             {
1371               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD0, splt->contents);
1372               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD1, splt->contents + 4);
1373               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD2, splt->contents + 8);
1374               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD3, splt->contents + 12);
1375               bfd_put_32 (output_bfd, PLT0_PIC_ENTRY_WORD4, splt->contents + 16);
1376             }
1377           else
1378             {
1379               unsigned long addr;
1380               /* addr = .got + 4 */
1381               addr = sgot->output_section->vma + sgot->output_offset + 4;
1382               bfd_put_32 (output_bfd,
1383                           PLT0_ENTRY_WORD0 | ((addr >> 16) & 0xffff),
1384                           splt->contents);
1385               bfd_put_32 (output_bfd,
1386                           PLT0_ENTRY_WORD1 | (addr & 0xffff),
1387                           splt->contents + 4);
1388               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD2, splt->contents + 8);
1389               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD3, splt->contents + 12);
1390               bfd_put_32 (output_bfd, PLT0_ENTRY_WORD4, splt->contents + 16);
1391             }
1392
1393           elf_section_data (splt->output_section)->this_hdr.sh_entsize =
1394             PLT_ENTRY_SIZE;
1395         }
1396     }
1397
1398   /* Fill in the first three entries in the global offset table.  */
1399   if (sgot && sgot->size > 0)
1400     {
1401       if (sdyn == NULL)
1402         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
1403       else
1404         bfd_put_32 (output_bfd,
1405                     sdyn->output_section->vma + sdyn->output_offset,
1406                     sgot->contents);
1407       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
1408       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
1409
1410       /* FIXME:  This can be null if create_dynamic_sections wasn't called. */
1411       if (elf_section_data (sgot->output_section) != NULL)
1412         elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
1413     }
1414
1415   if (lm32fdpic_fixup32_section (info))
1416     {
1417       struct elf_link_hash_entry *hgot = elf_hash_table (info)->hgot;
1418       bfd_vma got_value = hgot->root.u.def.value
1419             + hgot->root.u.def.section->output_section->vma
1420             + hgot->root.u.def.section->output_offset;
1421       struct bfd_link_hash_entry *hend;
1422
1423       /* Last entry is pointer to GOT.  */
1424       _lm32fdpic_add_rofixup (output_bfd, lm32fdpic_fixup32_section (info), got_value);
1425
1426       /* Check we wrote enough entries.  */
1427       if (lm32fdpic_fixup32_section (info)->size
1428               != (lm32fdpic_fixup32_section (info)->reloc_count * 4))
1429         {
1430           _bfd_error_handler
1431             ("LINKER BUG: .rofixup section size mismatch: size/4 %" PRId64
1432              " != relocs %d",
1433             (int64_t) (lm32fdpic_fixup32_section (info)->size / 4),
1434             lm32fdpic_fixup32_section (info)->reloc_count);
1435           return FALSE;
1436         }
1437
1438       hend = bfd_link_hash_lookup (info->hash, "__ROFIXUP_END__",
1439               FALSE, FALSE, TRUE);
1440       if (hend
1441           && (hend->type == bfd_link_hash_defined
1442               || hend->type == bfd_link_hash_defweak))
1443         {
1444           bfd_vma value =
1445             lm32fdpic_fixup32_section (info)->output_section->vma
1446             + lm32fdpic_fixup32_section (info)->output_offset
1447             + lm32fdpic_fixup32_section (info)->size
1448             - hend->u.def.section->output_section->vma
1449             - hend->u.def.section->output_offset;
1450           BFD_ASSERT (hend->u.def.value == value);
1451           if (hend->u.def.value != value)
1452             {
1453               _bfd_error_handler
1454                 ("LINKER BUG: .rofixup section hend->u.def.value != value: %"
1455                  PRId64 " != %" PRId64,
1456                  (int64_t) hend->u.def.value, (int64_t) value);
1457               return FALSE;
1458             }
1459         }
1460     }
1461
1462   return TRUE;
1463 }
1464
1465 /* Finish up dynamic symbol handling.  We set the contents of various
1466    dynamic sections here.  */
1467
1468 static bfd_boolean
1469 lm32_elf_finish_dynamic_symbol (bfd *output_bfd,
1470                                 struct bfd_link_info *info,
1471                                 struct elf_link_hash_entry *h,
1472                                 Elf_Internal_Sym *sym)
1473 {
1474   struct elf_lm32_link_hash_table *htab;
1475   bfd_byte *loc;
1476
1477   htab = lm32_elf_hash_table (info);
1478   if (htab == NULL)
1479     return FALSE;
1480
1481   if (h->plt.offset != (bfd_vma) -1)
1482     {
1483       asection *splt;
1484       asection *sgot;
1485       asection *srela;
1486
1487       bfd_vma plt_index;
1488       bfd_vma got_offset;
1489       Elf_Internal_Rela rela;
1490
1491       /* This symbol has an entry in the procedure linkage table.  Set
1492          it up.  */
1493       BFD_ASSERT (h->dynindx != -1);
1494
1495       splt = htab->root.splt;
1496       sgot = htab->root.sgotplt;
1497       srela = htab->root.srelplt;
1498       BFD_ASSERT (splt != NULL && sgot != NULL && srela != NULL);
1499
1500       /* Get the index in the procedure linkage table which
1501          corresponds to this symbol.  This is the index of this symbol
1502          in all the symbols for which we are making plt entries.  The
1503          first entry in the procedure linkage table is reserved.  */
1504       plt_index = h->plt.offset / PLT_ENTRY_SIZE - 1;
1505
1506       /* Get the offset into the .got table of the entry that
1507         corresponds to this function.  Each .got entry is 4 bytes.
1508         The first three are reserved.  */
1509       got_offset = (plt_index + 3) * 4;
1510
1511       /* Fill in the entry in the procedure linkage table.  */
1512       if (! bfd_link_pic (info))
1513         {
1514           /* TODO */
1515         }
1516       else
1517         {
1518           /* TODO */
1519         }
1520
1521       /* Fill in the entry in the global offset table.  */
1522       bfd_put_32 (output_bfd,
1523                   (splt->output_section->vma
1524                    + splt->output_offset
1525                    + h->plt.offset
1526                    + 12), /* same offset */
1527                   sgot->contents + got_offset);
1528
1529       /* Fill in the entry in the .rela.plt section.  */
1530       rela.r_offset = (sgot->output_section->vma
1531                        + sgot->output_offset
1532                        + got_offset);
1533       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_JMP_SLOT);
1534       rela.r_addend = 0;
1535       loc = srela->contents;
1536       loc += plt_index * sizeof (Elf32_External_Rela);
1537       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1538
1539       if (!h->def_regular)
1540         {
1541           /* Mark the symbol as undefined, rather than as defined in
1542              the .plt section.  Leave the value alone.  */
1543           sym->st_shndx = SHN_UNDEF;
1544         }
1545
1546     }
1547
1548   if (h->got.offset != (bfd_vma) -1)
1549     {
1550       asection *sgot;
1551       asection *srela;
1552       Elf_Internal_Rela rela;
1553
1554       /* This symbol has an entry in the global offset table.  Set it
1555          up.  */
1556       sgot = htab->root.sgot;
1557       srela = htab->root.srelgot;
1558       BFD_ASSERT (sgot != NULL && srela != NULL);
1559
1560       rela.r_offset = (sgot->output_section->vma
1561                        + sgot->output_offset
1562                        + (h->got.offset &~ 1));
1563
1564       /* If this is a -Bsymbolic link, and the symbol is defined
1565          locally, we just want to emit a RELATIVE reloc.  Likewise if
1566          the symbol was forced to be local because of a version file.
1567          The entry in the global offset table will already have been
1568          initialized in the relocate_section function.  */
1569       if (bfd_link_pic (info)
1570           && (info->symbolic
1571               || h->dynindx == -1
1572               || h->forced_local)
1573           && h->def_regular)
1574         {
1575           rela.r_info = ELF32_R_INFO (0, R_LM32_RELATIVE);
1576           rela.r_addend = (h->root.u.def.value
1577                            + h->root.u.def.section->output_section->vma
1578                            + h->root.u.def.section->output_offset);
1579         }
1580       else
1581         {
1582           BFD_ASSERT ((h->got.offset & 1) == 0);
1583           bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + h->got.offset);
1584           rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_GLOB_DAT);
1585           rela.r_addend = 0;
1586         }
1587
1588       loc = srela->contents;
1589       loc += srela->reloc_count * sizeof (Elf32_External_Rela);
1590       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1591       ++srela->reloc_count;
1592     }
1593
1594   if (h->needs_copy)
1595     {
1596       asection *s;
1597       Elf_Internal_Rela rela;
1598
1599       /* This symbols needs a copy reloc.  Set it up.  */
1600       BFD_ASSERT (h->dynindx != -1
1601                   && (h->root.type == bfd_link_hash_defined
1602                       || h->root.type == bfd_link_hash_defweak));
1603
1604       s = bfd_get_linker_section (htab->root.dynobj, ".rela.bss");
1605       BFD_ASSERT (s != NULL);
1606
1607       rela.r_offset = (h->root.u.def.value
1608                        + h->root.u.def.section->output_section->vma
1609                        + h->root.u.def.section->output_offset);
1610       rela.r_info = ELF32_R_INFO (h->dynindx, R_LM32_COPY);
1611       rela.r_addend = 0;
1612       loc = s->contents;
1613       loc += s->reloc_count * sizeof (Elf32_External_Rela);
1614       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
1615       ++s->reloc_count;
1616     }
1617
1618   /* Mark some specially defined symbols as absolute.  */
1619   if (h == htab->root.hdynamic || h == htab->root.hgot)
1620     sym->st_shndx = SHN_ABS;
1621
1622   return TRUE;
1623 }
1624
1625 static enum elf_reloc_type_class
1626 lm32_elf_reloc_type_class (const struct bfd_link_info *info ATTRIBUTE_UNUSED,
1627                            const asection *rel_sec ATTRIBUTE_UNUSED,
1628                            const Elf_Internal_Rela *rela)
1629 {
1630   switch ((int) ELF32_R_TYPE (rela->r_info))
1631     {
1632     case R_LM32_RELATIVE:  return reloc_class_relative;
1633     case R_LM32_JMP_SLOT:  return reloc_class_plt;
1634     case R_LM32_COPY:      return reloc_class_copy;
1635     default:               return reloc_class_normal;
1636     }
1637 }
1638
1639 /* Find dynamic relocs for H that apply to read-only sections.  */
1640
1641 static asection *
1642 readonly_dynrelocs (struct elf_link_hash_entry *h)
1643 {
1644   struct elf_dyn_relocs *p;
1645   struct elf_lm32_link_hash_entry *eh = (struct elf_lm32_link_hash_entry *) h;
1646
1647   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1648     {
1649       asection *s = p->sec->output_section;
1650
1651       if (s != NULL && (s->flags & SEC_READONLY) != 0)
1652         return p->sec;
1653     }
1654   return NULL;
1655 }
1656
1657 /* Adjust a symbol defined by a dynamic object and referenced by a
1658    regular object.  The current definition is in some section of the
1659    dynamic object, but we're not including those sections.  We have to
1660    change the definition to something the rest of the link can
1661    understand.  */
1662
1663 static bfd_boolean
1664 lm32_elf_adjust_dynamic_symbol (struct bfd_link_info *info,
1665                                 struct elf_link_hash_entry *h)
1666 {
1667   struct elf_lm32_link_hash_table *htab;
1668   bfd *dynobj;
1669   asection *s;
1670
1671   dynobj = elf_hash_table (info)->dynobj;
1672
1673   /* Make sure we know what is going on here.  */
1674   BFD_ASSERT (dynobj != NULL
1675               && (h->needs_plt
1676                   || h->is_weakalias
1677                   || (h->def_dynamic
1678                       && h->ref_regular
1679                       && !h->def_regular)));
1680
1681   /* If this is a function, put it in the procedure linkage table.  We
1682      will fill in the contents of the procedure linkage table later,
1683      when we know the address of the .got section.  */
1684   if (h->type == STT_FUNC
1685       || h->needs_plt)
1686     {
1687       if (! bfd_link_pic (info)
1688           && !h->def_dynamic
1689           && !h->ref_dynamic
1690           && h->root.type != bfd_link_hash_undefweak
1691           && h->root.type != bfd_link_hash_undefined)
1692         {
1693           /* This case can occur if we saw a PLT reloc in an input
1694              file, but the symbol was never referred to by a dynamic
1695              object.  In such a case, we don't actually need to build
1696              a procedure linkage table, and we can just do a PCREL
1697              reloc instead.  */
1698           h->plt.offset = (bfd_vma) -1;
1699           h->needs_plt = 0;
1700         }
1701
1702       return TRUE;
1703     }
1704   else
1705     h->plt.offset = (bfd_vma) -1;
1706
1707   /* If this is a weak symbol, and there is a real definition, the
1708      processor independent code will have arranged for us to see the
1709      real definition first, and we can just use the same value.  */
1710   if (h->is_weakalias)
1711     {
1712       struct elf_link_hash_entry *def = weakdef (h);
1713       BFD_ASSERT (def->root.type == bfd_link_hash_defined);
1714       h->root.u.def.section = def->root.u.def.section;
1715       h->root.u.def.value = def->root.u.def.value;
1716       return TRUE;
1717     }
1718
1719   /* This is a reference to a symbol defined by a dynamic object which
1720      is not a function.  */
1721
1722   /* If we are creating a shared library, we must presume that the
1723      only references to the symbol are via the global offset table.
1724      For such cases we need not do anything here; the relocations will
1725      be handled correctly by relocate_section.  */
1726   if (bfd_link_pic (info))
1727     return TRUE;
1728
1729   /* If there are no references to this symbol that do not use the
1730      GOT, we don't need to generate a copy reloc.  */
1731   if (!h->non_got_ref)
1732     return TRUE;
1733
1734   /* If -z nocopyreloc was given, we won't generate them either.  */
1735   if (0 && info->nocopyreloc)
1736     {
1737       h->non_got_ref = 0;
1738       return TRUE;
1739     }
1740
1741   /* If we don't find any dynamic relocs in read-only sections, then
1742      we'll be keeping the dynamic relocs and avoiding the copy reloc.  */
1743   if (0 && !readonly_dynrelocs (h))
1744     {
1745       h->non_got_ref = 0;
1746       return TRUE;
1747     }
1748
1749   /* We must allocate the symbol in our .dynbss section, which will
1750      become part of the .bss section of the executable.  There will be
1751      an entry for this symbol in the .dynsym section.  The dynamic
1752      object will contain position independent code, so all references
1753      from the dynamic object to this symbol will go through the global
1754      offset table.  The dynamic linker will use the .dynsym entry to
1755      determine the address it must put in the global offset table, so
1756      both the dynamic object and the regular object will refer to the
1757      same memory location for the variable.  */
1758
1759   htab = lm32_elf_hash_table (info);
1760   if (htab == NULL)
1761     return FALSE;
1762
1763   s = htab->sdynbss;
1764   BFD_ASSERT (s != NULL);
1765
1766   /* We must generate a R_LM32_COPY reloc to tell the dynamic linker
1767      to copy the initial value out of the dynamic object and into the
1768      runtime process image.  We need to remember the offset into the
1769      .rela.bss section we are going to use.  */
1770   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0 && h->size != 0)
1771     {
1772       asection *srel;
1773
1774       srel = htab->srelbss;
1775       BFD_ASSERT (srel != NULL);
1776       srel->size += sizeof (Elf32_External_Rela);
1777       h->needs_copy = 1;
1778     }
1779
1780   return _bfd_elf_adjust_dynamic_copy (info, h, s);
1781 }
1782
1783 /* Allocate space in .plt, .got and associated reloc sections for
1784    dynamic relocs.  */
1785
1786 static bfd_boolean
1787 allocate_dynrelocs (struct elf_link_hash_entry *h, void * inf)
1788 {
1789   struct bfd_link_info *info;
1790   struct elf_lm32_link_hash_table *htab;
1791   struct elf_lm32_link_hash_entry *eh;
1792   struct elf_dyn_relocs *p;
1793
1794   if (h->root.type == bfd_link_hash_indirect)
1795     return TRUE;
1796
1797   info = (struct bfd_link_info *) inf;
1798   htab = lm32_elf_hash_table (info);
1799   if (htab == NULL)
1800     return FALSE;
1801
1802   eh = (struct elf_lm32_link_hash_entry *) h;
1803
1804   if (htab->root.dynamic_sections_created
1805       && h->plt.refcount > 0)
1806     {
1807       /* Make sure this symbol is output as a dynamic symbol.
1808          Undefined weak syms won't yet be marked as dynamic.  */
1809       if (h->dynindx == -1
1810           && !h->forced_local)
1811         {
1812           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1813             return FALSE;
1814         }
1815
1816       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (1, bfd_link_pic (info), h))
1817         {
1818           asection *s = htab->root.splt;
1819
1820           /* If this is the first .plt entry, make room for the special
1821              first entry.  */
1822           if (s->size == 0)
1823             s->size += PLT_ENTRY_SIZE;
1824
1825           h->plt.offset = s->size;
1826
1827           /* If this symbol is not defined in a regular file, and we are
1828              not generating a shared library, then set the symbol to this
1829              location in the .plt.  This is required to make function
1830              pointers compare as equal between the normal executable and
1831              the shared library.  */
1832           if (! bfd_link_pic (info)
1833               && !h->def_regular)
1834             {
1835               h->root.u.def.section = s;
1836               h->root.u.def.value = h->plt.offset;
1837             }
1838
1839           /* Make room for this entry.  */
1840           s->size += PLT_ENTRY_SIZE;
1841
1842           /* We also need to make an entry in the .got.plt section, which
1843              will be placed in the .got section by the linker script.  */
1844           htab->root.sgotplt->size += 4;
1845
1846           /* We also need to make an entry in the .rel.plt section.  */
1847           htab->root.srelplt->size += sizeof (Elf32_External_Rela);
1848         }
1849       else
1850         {
1851           h->plt.offset = (bfd_vma) -1;
1852           h->needs_plt = 0;
1853         }
1854     }
1855   else
1856     {
1857       h->plt.offset = (bfd_vma) -1;
1858       h->needs_plt = 0;
1859     }
1860
1861   if (h->got.refcount > 0)
1862     {
1863       asection *s;
1864       bfd_boolean dyn;
1865
1866       /* Make sure this symbol is output as a dynamic symbol.
1867          Undefined weak syms won't yet be marked as dynamic.  */
1868       if (h->dynindx == -1
1869           && !h->forced_local)
1870         {
1871           if (! bfd_elf_link_record_dynamic_symbol (info, h))
1872             return FALSE;
1873         }
1874
1875       s = htab->root.sgot;
1876
1877       h->got.offset = s->size;
1878       s->size += 4;
1879       dyn = htab->root.dynamic_sections_created;
1880       if (WILL_CALL_FINISH_DYNAMIC_SYMBOL (dyn, bfd_link_pic (info), h))
1881         htab->root.srelgot->size += sizeof (Elf32_External_Rela);
1882     }
1883   else
1884     h->got.offset = (bfd_vma) -1;
1885
1886   if (eh->dyn_relocs == NULL)
1887     return TRUE;
1888
1889   /* In the shared -Bsymbolic case, discard space allocated for
1890      dynamic pc-relative relocs against symbols which turn out to be
1891      defined in regular objects.  For the normal shared case, discard
1892      space for pc-relative relocs that have become local due to symbol
1893      visibility changes.  */
1894
1895   if (bfd_link_pic (info))
1896     {
1897       if (h->def_regular
1898           && (h->forced_local
1899               || info->symbolic))
1900         {
1901           struct elf_dyn_relocs **pp;
1902
1903           for (pp = &eh->dyn_relocs; (p = *pp) != NULL;)
1904             {
1905               p->count -= p->pc_count;
1906               p->pc_count = 0;
1907               if (p->count == 0)
1908                 *pp = p->next;
1909               else
1910                 pp = &p->next;
1911             }
1912         }
1913
1914       /* Also discard relocs on undefined weak syms with non-default
1915          visibility.  */
1916       if (eh->dyn_relocs != NULL
1917           && h->root.type == bfd_link_hash_undefweak)
1918         {
1919           if (ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1920             eh->dyn_relocs = NULL;
1921
1922           /* Make sure undefined weak symbols are output as a dynamic
1923              symbol in PIEs.  */
1924           else if (h->dynindx == -1
1925                    && !h->forced_local)
1926             {
1927               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1928                 return FALSE;
1929             }
1930         }
1931     }
1932   else
1933     {
1934       /* For the non-shared case, discard space for relocs against
1935          symbols which turn out to need copy relocs or are not
1936          dynamic.  */
1937
1938       if (!h->non_got_ref
1939           && ((h->def_dynamic
1940                && !h->def_regular)
1941               || (htab->root.dynamic_sections_created
1942                   && (h->root.type == bfd_link_hash_undefweak
1943                       || h->root.type == bfd_link_hash_undefined))))
1944         {
1945           /* Make sure this symbol is output as a dynamic symbol.
1946              Undefined weak syms won't yet be marked as dynamic.  */
1947           if (h->dynindx == -1
1948               && !h->forced_local)
1949             {
1950               if (! bfd_elf_link_record_dynamic_symbol (info, h))
1951                 return FALSE;
1952             }
1953
1954           /* If that succeeded, we know we'll be keeping all the
1955              relocs.  */
1956           if (h->dynindx != -1)
1957             goto keep;
1958         }
1959
1960       eh->dyn_relocs = NULL;
1961
1962     keep: ;
1963     }
1964
1965   /* Finally, allocate space.  */
1966   for (p = eh->dyn_relocs; p != NULL; p = p->next)
1967     {
1968       asection *sreloc = elf_section_data (p->sec)->sreloc;
1969       sreloc->size += p->count * sizeof (Elf32_External_Rela);
1970     }
1971
1972   return TRUE;
1973 }
1974
1975 /* Set DF_TEXTREL if we find any dynamic relocs that apply to
1976    read-only sections.  */
1977
1978 static bfd_boolean
1979 maybe_set_textrel (struct elf_link_hash_entry *h, void *info_p)
1980 {
1981   asection *sec;
1982
1983   if (h->root.type == bfd_link_hash_indirect)
1984     return TRUE;
1985
1986   sec = readonly_dynrelocs (h);
1987   if (sec != NULL)
1988     {
1989       struct bfd_link_info *info = (struct bfd_link_info *) info_p;
1990
1991       info->flags |= DF_TEXTREL;
1992       info->callbacks->minfo
1993         (_("%pB: dynamic relocation against `%pT' in read-only section `%pA'\n"),
1994          sec->owner, h->root.root.string, sec);
1995
1996       /* Not an error, just cut short the traversal.  */
1997       return FALSE;
1998     }
1999   return TRUE;
2000 }
2001
2002 /* Set the sizes of the dynamic sections.  */
2003
2004 static bfd_boolean
2005 lm32_elf_size_dynamic_sections (bfd *output_bfd,
2006                                 struct bfd_link_info *info)
2007 {
2008   struct elf_lm32_link_hash_table *htab;
2009   bfd *dynobj;
2010   asection *s;
2011   bfd_boolean relocs;
2012   bfd *ibfd;
2013
2014   htab = lm32_elf_hash_table (info);
2015   if (htab == NULL)
2016     return FALSE;
2017
2018   dynobj = htab->root.dynobj;
2019   BFD_ASSERT (dynobj != NULL);
2020
2021   if (htab->root.dynamic_sections_created)
2022     {
2023       /* Set the contents of the .interp section to the interpreter.  */
2024       if (bfd_link_executable (info) && !info->nointerp)
2025         {
2026           s = bfd_get_linker_section (dynobj, ".interp");
2027           BFD_ASSERT (s != NULL);
2028           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
2029           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
2030         }
2031     }
2032
2033   /* Set up .got offsets for local syms, and space for local dynamic
2034      relocs.  */
2035   for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2036     {
2037       bfd_signed_vma *local_got;
2038       bfd_signed_vma *end_local_got;
2039       bfd_size_type locsymcount;
2040       Elf_Internal_Shdr *symtab_hdr;
2041       asection *srel;
2042
2043       if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour)
2044         continue;
2045
2046       for (s = ibfd->sections; s != NULL; s = s->next)
2047         {
2048           struct elf_dyn_relocs *p;
2049
2050           for (p = ((struct elf_dyn_relocs *)
2051                     elf_section_data (s)->local_dynrel);
2052                p != NULL;
2053                p = p->next)
2054             {
2055               if (! bfd_is_abs_section (p->sec)
2056                   && bfd_is_abs_section (p->sec->output_section))
2057                 {
2058                   /* Input section has been discarded, either because
2059                      it is a copy of a linkonce section or due to
2060                      linker script /DISCARD/, so we'll be discarding
2061                      the relocs too.  */
2062                 }
2063               else if (p->count != 0)
2064                 {
2065                   srel = elf_section_data (p->sec)->sreloc;
2066                   srel->size += p->count * sizeof (Elf32_External_Rela);
2067                   if ((p->sec->output_section->flags & SEC_READONLY) != 0)
2068                     info->flags |= DF_TEXTREL;
2069                 }
2070             }
2071         }
2072
2073       local_got = elf_local_got_refcounts (ibfd);
2074       if (!local_got)
2075         continue;
2076
2077       symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2078       locsymcount = symtab_hdr->sh_info;
2079       end_local_got = local_got + locsymcount;
2080       s = htab->root.sgot;
2081       srel = htab->root.srelgot;
2082       for (; local_got < end_local_got; ++local_got)
2083         {
2084           if (*local_got > 0)
2085             {
2086               *local_got = s->size;
2087               s->size += 4;
2088               if (bfd_link_pic (info))
2089                 srel->size += sizeof (Elf32_External_Rela);
2090             }
2091           else
2092             *local_got = (bfd_vma) -1;
2093         }
2094     }
2095
2096   /* Allocate global sym .plt and .got entries, and space for global
2097      sym dynamic relocs.  */
2098   elf_link_hash_traverse (&htab->root, allocate_dynrelocs, info);
2099
2100   /* We now have determined the sizes of the various dynamic sections.
2101      Allocate memory for them.  */
2102   relocs = FALSE;
2103   for (s = dynobj->sections; s != NULL; s = s->next)
2104     {
2105       if ((s->flags & SEC_LINKER_CREATED) == 0)
2106         continue;
2107
2108       if (s == htab->root.splt
2109           || s == htab->root.sgot
2110           || s == htab->root.sgotplt
2111           || s == htab->sdynbss)
2112         {
2113           /* Strip this section if we don't need it; see the
2114              comment below.  */
2115         }
2116       else if (CONST_STRNEQ (bfd_get_section_name (dynobj, s), ".rela"))
2117         {
2118           if (s->size != 0 && s != htab->root.srelplt)
2119             relocs = TRUE;
2120
2121           /* We use the reloc_count field as a counter if we need
2122              to copy relocs into the output file.  */
2123           s->reloc_count = 0;
2124         }
2125       else
2126         /* It's not one of our sections, so don't allocate space.  */
2127         continue;
2128
2129       if (s->size == 0)
2130         {
2131           /* If we don't need this section, strip it from the
2132              output file.  This is mostly to handle .rela.bss and
2133              .rela.plt.  We must create both sections in
2134              create_dynamic_sections, because they must be created
2135              before the linker maps input sections to output
2136              sections.  The linker does that before
2137              adjust_dynamic_symbol is called, and it is that
2138              function which decides whether anything needs to go
2139              into these sections.  */
2140           s->flags |= SEC_EXCLUDE;
2141           continue;
2142         }
2143
2144       if ((s->flags & SEC_HAS_CONTENTS) == 0)
2145         continue;
2146
2147       /* Allocate memory for the section contents.  We use bfd_zalloc
2148          here in case unused entries are not reclaimed before the
2149          section's contents are written out.  This should not happen,
2150          but this way if it does, we get a R_LM32_NONE reloc instead
2151          of garbage.  */
2152       s->contents = bfd_zalloc (dynobj, s->size);
2153       if (s->contents == NULL)
2154         return FALSE;
2155     }
2156
2157   if (htab->root.dynamic_sections_created)
2158     {
2159       /* Add some entries to the .dynamic section.  We fill in the
2160          values later, in lm32_elf_finish_dynamic_sections, but we
2161          must add the entries now so that we get the correct size for
2162          the .dynamic section.  The DT_DEBUG entry is filled in by the
2163          dynamic linker and used by the debugger.  */
2164 #define add_dynamic_entry(TAG, VAL) \
2165   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
2166
2167      if (bfd_link_executable (info))
2168         {
2169           if (! add_dynamic_entry (DT_DEBUG, 0))
2170             return FALSE;
2171         }
2172
2173       if (htab->root.splt->size != 0)
2174         {
2175           if (! add_dynamic_entry (DT_PLTGOT, 0)
2176               || ! add_dynamic_entry (DT_PLTRELSZ, 0)
2177               || ! add_dynamic_entry (DT_PLTREL, DT_RELA)
2178               || ! add_dynamic_entry (DT_JMPREL, 0))
2179             return FALSE;
2180         }
2181
2182       if (relocs)
2183         {
2184           if (! add_dynamic_entry (DT_RELA, 0)
2185               || ! add_dynamic_entry (DT_RELASZ, 0)
2186               || ! add_dynamic_entry (DT_RELAENT,
2187                                       sizeof (Elf32_External_Rela)))
2188             return FALSE;
2189
2190           /* If any dynamic relocs apply to a read-only section,
2191              then we need a DT_TEXTREL entry.  */
2192           if ((info->flags & DF_TEXTREL) == 0)
2193             elf_link_hash_traverse (&htab->root, maybe_set_textrel, info);
2194
2195           if ((info->flags & DF_TEXTREL) != 0)
2196             {
2197               if (! add_dynamic_entry (DT_TEXTREL, 0))
2198                 return FALSE;
2199             }
2200         }
2201     }
2202 #undef add_dynamic_entry
2203
2204   /* Allocate .rofixup section.  */
2205   if (IS_FDPIC (output_bfd))
2206     {
2207       struct weak_symbol_list *list_start = NULL, *list_end = NULL;
2208       int rgot_weak_count = 0;
2209       int r32_count = 0;
2210       int rgot_count = 0;
2211       /* Look for deleted sections.  */
2212       for (ibfd = info->input_bfds; ibfd != NULL; ibfd = ibfd->link.next)
2213         {
2214           for (s = ibfd->sections; s != NULL; s = s->next)
2215             {
2216               if (s->reloc_count)
2217                 {
2218                   /* Count relocs that need .rofixup entires.  */
2219                   Elf_Internal_Rela *internal_relocs, *end;
2220                   internal_relocs = elf_section_data (s)->relocs;
2221                   if (internal_relocs == NULL)
2222                     internal_relocs = (_bfd_elf_link_read_relocs (ibfd, s, NULL, NULL, FALSE));
2223                   if (internal_relocs != NULL)
2224                     {
2225                       end = internal_relocs + s->reloc_count;
2226                       while (internal_relocs < end)
2227                         {
2228                           Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2229                           struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (ibfd);
2230                           unsigned long r_symndx;
2231                           struct elf_link_hash_entry *h;
2232
2233                           symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
2234                           sym_hashes = elf_sym_hashes (ibfd);
2235                           r_symndx = ELF32_R_SYM (internal_relocs->r_info);
2236                           h = NULL;
2237                           if (r_symndx < symtab_hdr->sh_info)
2238                             {
2239                             }
2240                           else
2241                             {
2242                               h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2243                               while (h->root.type == bfd_link_hash_indirect
2244                                      || h->root.type == bfd_link_hash_warning)
2245                                 h = (struct elf_link_hash_entry *) h->root.u.i.link;
2246                               }
2247
2248                           /* Don't generate entries for weak symbols.  */
2249                           if (!h || (h && h->root.type != bfd_link_hash_undefweak))
2250                             {
2251                               if (!discarded_section (s) && !((bfd_get_section_flags (ibfd, s) & SEC_ALLOC) == 0))
2252                                 {
2253                                   switch (ELF32_R_TYPE (internal_relocs->r_info))
2254                                     {
2255                                     case R_LM32_32:
2256                                       r32_count++;
2257                                       break;
2258                                     case R_LM32_16_GOT:
2259                                       rgot_count++;
2260                                       break;
2261                                     }
2262                                 }
2263                             }
2264                           else
2265                             {
2266                               struct weak_symbol_list *current, *new_entry;
2267                               /* Is this symbol already in the list?  */
2268                               for (current = list_start; current; current = current->next)
2269                                 {
2270                                   if (!strcmp (current->name, h->root.root.string))
2271                                     break;
2272                                 }
2273                               if (!current && !discarded_section (s) && (bfd_get_section_flags (ibfd, s) & SEC_ALLOC))
2274                                 {
2275                                   /* Will this have an entry in the GOT.  */
2276                                   if (ELF32_R_TYPE (internal_relocs->r_info) == R_LM32_16_GOT)
2277                                     {
2278                                       /* Create a new entry.  */
2279                                       new_entry = malloc (sizeof (struct weak_symbol_list));
2280                                       if (!new_entry)
2281                                         return FALSE;
2282                                       new_entry->name = h->root.root.string;
2283                                       new_entry->next = NULL;
2284                                       /* Add to list */
2285                                       if (list_start == NULL)
2286                                         {
2287                                           list_start = new_entry;
2288                                           list_end = new_entry;
2289                                         }
2290                                       else
2291                                         {
2292                                           list_end->next = new_entry;
2293                                           list_end = new_entry;
2294                                         }
2295                                       /* Increase count of undefined weak symbols in the got.  */
2296                                       rgot_weak_count++;
2297                                     }
2298                                 }
2299                             }
2300                           internal_relocs++;
2301                         }
2302                     }
2303                   else
2304                     return FALSE;
2305                 }
2306             }
2307         }
2308       /* Free list.  */
2309       while (list_start)
2310         {
2311           list_end = list_start->next;
2312           free (list_start);
2313           list_start = list_end;
2314         }
2315
2316       /* Size sections.  */
2317       lm32fdpic_fixup32_section (info)->size
2318         = (r32_count + (htab->root.sgot->size / 4) - rgot_weak_count + 1) * 4;
2319       if (lm32fdpic_fixup32_section (info)->size == 0)
2320         lm32fdpic_fixup32_section (info)->flags |= SEC_EXCLUDE;
2321       else
2322         {
2323           lm32fdpic_fixup32_section (info)->contents =
2324              bfd_zalloc (dynobj, lm32fdpic_fixup32_section (info)->size);
2325           if (lm32fdpic_fixup32_section (info)->contents == NULL)
2326             return FALSE;
2327         }
2328     }
2329
2330   return TRUE;
2331 }
2332
2333 /* Create dynamic sections when linking against a dynamic object.  */
2334
2335 static bfd_boolean
2336 lm32_elf_create_dynamic_sections (bfd *abfd, struct bfd_link_info *info)
2337 {
2338   struct elf_lm32_link_hash_table *htab;
2339   flagword flags, pltflags;
2340   asection *s;
2341   const struct elf_backend_data *bed = get_elf_backend_data (abfd);
2342   int ptralign = 2; /* 32bit */
2343
2344   htab = lm32_elf_hash_table (info);
2345   if (htab == NULL)
2346     return FALSE;
2347
2348   /* Make sure we have a GOT - For the case where we have a dynamic object
2349      but none of the relocs in check_relocs */
2350   if (!_bfd_elf_create_got_section (abfd, info))
2351     return FALSE;
2352   if (IS_FDPIC (abfd) && (htab->sfixup32 == NULL))
2353     {
2354       if (! create_rofixup_section (abfd, info))
2355         return FALSE;
2356     }
2357
2358   /* We need to create .plt, .rel[a].plt, .got, .got.plt, .dynbss, and
2359      .rel[a].bss sections.  */
2360   flags = (SEC_ALLOC | SEC_LOAD | SEC_HAS_CONTENTS | SEC_IN_MEMORY
2361            | SEC_LINKER_CREATED);
2362
2363   pltflags = flags;
2364   pltflags |= SEC_CODE;
2365   if (bed->plt_not_loaded)
2366     pltflags &= ~ (SEC_LOAD | SEC_HAS_CONTENTS);
2367   if (bed->plt_readonly)
2368     pltflags |= SEC_READONLY;
2369
2370   s = bfd_make_section_anyway_with_flags (abfd, ".plt", pltflags);
2371   htab->root.splt = s;
2372   if (s == NULL
2373       || ! bfd_set_section_alignment (abfd, s, bed->plt_alignment))
2374     return FALSE;
2375
2376   if (bed->want_plt_sym)
2377     {
2378       /* Define the symbol _PROCEDURE_LINKAGE_TABLE_ at the start of the
2379          .plt section.  */
2380       struct bfd_link_hash_entry *bh = NULL;
2381       struct elf_link_hash_entry *h;
2382
2383       if (! (_bfd_generic_link_add_one_symbol
2384              (info, abfd, "_PROCEDURE_LINKAGE_TABLE_", BSF_GLOBAL, s,
2385               (bfd_vma) 0, NULL, FALSE,
2386               get_elf_backend_data (abfd)->collect, &bh)))
2387         return FALSE;
2388       h = (struct elf_link_hash_entry *) bh;
2389       h->def_regular = 1;
2390       h->type = STT_OBJECT;
2391       htab->root.hplt = h;
2392
2393       if (bfd_link_pic (info)
2394           && ! bfd_elf_link_record_dynamic_symbol (info, h))
2395         return FALSE;
2396     }
2397
2398   s = bfd_make_section_anyway_with_flags (abfd,
2399                                           bed->default_use_rela_p
2400                                           ? ".rela.plt" : ".rel.plt",
2401                                           flags | SEC_READONLY);
2402   htab->root.srelplt = s;
2403   if (s == NULL
2404       || ! bfd_set_section_alignment (abfd, s, ptralign))
2405     return FALSE;
2406
2407   if (htab->root.sgot == NULL
2408       && !_bfd_elf_create_got_section (abfd, info))
2409     return FALSE;
2410
2411   if (bed->want_dynbss)
2412     {
2413       /* The .dynbss section is a place to put symbols which are defined
2414          by dynamic objects, are referenced by regular objects, and are
2415          not functions.  We must allocate space for them in the process
2416          image and use a R_*_COPY reloc to tell the dynamic linker to
2417          initialize them at run time.  The linker script puts the .dynbss
2418          section into the .bss section of the final image.  */
2419       s = bfd_make_section_anyway_with_flags (abfd, ".dynbss",
2420                                               SEC_ALLOC | SEC_LINKER_CREATED);
2421       htab->sdynbss = s;
2422       if (s == NULL)
2423         return FALSE;
2424       /* The .rel[a].bss section holds copy relocs.  This section is not
2425          normally needed.  We need to create it here, though, so that the
2426          linker will map it to an output section.  We can't just create it
2427          only if we need it, because we will not know whether we need it
2428          until we have seen all the input files, and the first time the
2429          main linker code calls BFD after examining all the input files
2430          (size_dynamic_sections) the input sections have already been
2431          mapped to the output sections.  If the section turns out not to
2432          be needed, we can discard it later.  We will never need this
2433          section when generating a shared object, since they do not use
2434          copy relocs.  */
2435       if (! bfd_link_pic (info))
2436         {
2437           s = bfd_make_section_anyway_with_flags (abfd,
2438                                                   (bed->default_use_rela_p
2439                                                    ? ".rela.bss" : ".rel.bss"),
2440                                                   flags | SEC_READONLY);
2441           htab->srelbss = s;
2442           if (s == NULL
2443               || ! bfd_set_section_alignment (abfd, s, ptralign))
2444             return FALSE;
2445         }
2446     }
2447
2448   return TRUE;
2449 }
2450
2451 /* Copy the extra info we tack onto an elf_link_hash_entry.  */
2452
2453 static void
2454 lm32_elf_copy_indirect_symbol (struct bfd_link_info *info,
2455                                struct elf_link_hash_entry *dir,
2456                                struct elf_link_hash_entry *ind)
2457 {
2458   struct elf_lm32_link_hash_entry * edir;
2459   struct elf_lm32_link_hash_entry * eind;
2460
2461   edir = (struct elf_lm32_link_hash_entry *) dir;
2462   eind = (struct elf_lm32_link_hash_entry *) ind;
2463
2464   if (eind->dyn_relocs != NULL)
2465     {
2466       if (edir->dyn_relocs != NULL)
2467         {
2468           struct elf_dyn_relocs **pp;
2469           struct elf_dyn_relocs *p;
2470
2471           /* Add reloc counts against the indirect sym to the direct sym
2472              list.  Merge any entries against the same section.  */
2473           for (pp = &eind->dyn_relocs; (p = *pp) != NULL;)
2474             {
2475               struct elf_dyn_relocs *q;
2476
2477               for (q = edir->dyn_relocs; q != NULL; q = q->next)
2478                 if (q->sec == p->sec)
2479                   {
2480                     q->pc_count += p->pc_count;
2481                     q->count += p->count;
2482                     *pp = p->next;
2483                     break;
2484                   }
2485               if (q == NULL)
2486                 pp = &p->next;
2487             }
2488           *pp = edir->dyn_relocs;
2489         }
2490
2491       edir->dyn_relocs = eind->dyn_relocs;
2492       eind->dyn_relocs = NULL;
2493     }
2494
2495   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
2496 }
2497
2498 static bfd_boolean
2499 lm32_elf_always_size_sections (bfd *output_bfd, struct bfd_link_info *info)
2500 {
2501   if (!bfd_link_relocatable (info))
2502     {
2503       if (!bfd_elf_stack_segment_size (output_bfd, info,
2504                                        "__stacksize", DEFAULT_STACK_SIZE))
2505         return FALSE;
2506
2507       asection *sec = bfd_get_section_by_name (output_bfd, ".stack");
2508       if (sec)
2509         sec->size = info->stacksize >= 0 ? info->stacksize : 0;
2510     }
2511
2512   return TRUE;
2513 }
2514
2515 static bfd_boolean
2516 lm32_elf_fdpic_copy_private_bfd_data (bfd *ibfd, bfd *obfd)
2517 {
2518   unsigned i;
2519
2520   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
2521       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
2522     return TRUE;
2523
2524   if (! _bfd_elf_copy_private_bfd_data (ibfd, obfd))
2525     return FALSE;
2526
2527   if (! elf_tdata (ibfd) || ! elf_tdata (ibfd)->phdr
2528       || ! elf_tdata (obfd) || ! elf_tdata (obfd)->phdr)
2529     return TRUE;
2530
2531   /* Copy the stack size.  */
2532   for (i = 0; i < elf_elfheader (ibfd)->e_phnum; i++)
2533     if (elf_tdata (ibfd)->phdr[i].p_type == PT_GNU_STACK)
2534       {
2535         Elf_Internal_Phdr *iphdr = &elf_tdata (ibfd)->phdr[i];
2536
2537         for (i = 0; i < elf_elfheader (obfd)->e_phnum; i++)
2538           if (elf_tdata (obfd)->phdr[i].p_type == PT_GNU_STACK)
2539             {
2540               memcpy (&elf_tdata (obfd)->phdr[i], iphdr, sizeof (*iphdr));
2541
2542               /* Rewrite the phdrs, since we're only called after they were first written.  */
2543               if (bfd_seek (obfd, (bfd_signed_vma) get_elf_backend_data (obfd)
2544                             ->s->sizeof_ehdr, SEEK_SET) != 0
2545                   || get_elf_backend_data (obfd)->s->write_out_phdrs (obfd, elf_tdata (obfd)->phdr,
2546                                      elf_elfheader (obfd)->e_phnum) != 0)
2547                 return FALSE;
2548               break;
2549             }
2550
2551         break;
2552       }
2553
2554   return TRUE;
2555 }
2556
2557
2558 #define ELF_ARCH                bfd_arch_lm32
2559 #define ELF_TARGET_ID           LM32_ELF_DATA
2560 #define ELF_MACHINE_CODE        EM_LATTICEMICO32
2561 #define ELF_MAXPAGESIZE         0x1000
2562
2563 #define TARGET_BIG_SYM          lm32_elf32_vec
2564 #define TARGET_BIG_NAME         "elf32-lm32"
2565
2566 #define bfd_elf32_bfd_reloc_type_lookup         lm32_reloc_type_lookup
2567 #define bfd_elf32_bfd_reloc_name_lookup         lm32_reloc_name_lookup
2568 #define elf_info_to_howto                       lm32_info_to_howto_rela
2569 #define elf_info_to_howto_rel                   0
2570 #define elf_backend_rela_normal                 1
2571 #define elf_backend_object_p                    lm32_elf_object_p
2572 #define elf_backend_final_write_processing      lm32_elf_final_write_processing
2573 #define elf_backend_stack_align                 8
2574 #define elf_backend_can_gc_sections             1
2575 #define elf_backend_can_refcount                1
2576 #define elf_backend_gc_mark_hook                lm32_elf_gc_mark_hook
2577 #define elf_backend_plt_readonly                1
2578 #define elf_backend_want_got_plt                1
2579 #define elf_backend_want_plt_sym                0
2580 #define elf_backend_got_header_size             12
2581 #define elf_backend_dtrel_excludes_plt          1
2582 #define bfd_elf32_bfd_link_hash_table_create    lm32_elf_link_hash_table_create
2583 #define elf_backend_check_relocs                lm32_elf_check_relocs
2584 #define elf_backend_reloc_type_class            lm32_elf_reloc_type_class
2585 #define elf_backend_copy_indirect_symbol        lm32_elf_copy_indirect_symbol
2586 #define elf_backend_size_dynamic_sections       lm32_elf_size_dynamic_sections
2587 #define elf_backend_omit_section_dynsym         _bfd_elf_omit_section_dynsym_all
2588 #define elf_backend_create_dynamic_sections     lm32_elf_create_dynamic_sections
2589 #define elf_backend_finish_dynamic_sections     lm32_elf_finish_dynamic_sections
2590 #define elf_backend_adjust_dynamic_symbol       lm32_elf_adjust_dynamic_symbol
2591 #define elf_backend_finish_dynamic_symbol       lm32_elf_finish_dynamic_symbol
2592 #define elf_backend_relocate_section            lm32_elf_relocate_section
2593
2594 #include "elf32-target.h"
2595
2596 #undef  ELF_MAXPAGESIZE
2597 #define ELF_MAXPAGESIZE         0x4000
2598
2599
2600 #undef  TARGET_BIG_SYM
2601 #define TARGET_BIG_SYM          lm32_elf32_fdpic_vec
2602 #undef  TARGET_BIG_NAME
2603 #define TARGET_BIG_NAME         "elf32-lm32fdpic"
2604 #undef  elf32_bed
2605 #define elf32_bed               elf32_lm32fdpic_bed
2606
2607 #undef  elf_backend_always_size_sections
2608 #define elf_backend_always_size_sections        lm32_elf_always_size_sections
2609 #undef  bfd_elf32_bfd_copy_private_bfd_data
2610 #define bfd_elf32_bfd_copy_private_bfd_data     lm32_elf_fdpic_copy_private_bfd_data
2611
2612 #include "elf32-target.h"