bfd/elf32-lm32.c

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