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