bfd/elf32-lm32.c

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