bfd/elf32-lm32.c

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