bfd/elf32-lm32.c

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