bfd/elf32-cris.c

   1 /* CRIS-specific support for 32-bit ELF.
   2    Copyright 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
   3    Free Software Foundation, Inc.
   4    Contributed by Axis Communications AB.
   5    Written by Hans-Peter Nilsson, based on elf32-fr30.c
   6    PIC and shlib bits based primarily on elf32-m68k.c and elf32-i386.c.
   7
   8    This file is part of BFD, the Binary File Descriptor library.
   9
  10    This program is free software; you can redistribute it and/or modify
  11    it under the terms of the GNU General Public License as published by
  12    the Free Software Foundation; either version 3 of the License, or
  13    (at your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful,
  16    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18    GNU General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston,
  23    MA 02110-1301, USA.  */
  24
  25 #include "sysdep.h"
  26 #include "bfd.h"
  27 #include "libbfd.h"
  28 #include "elf-bfd.h"
  29 #include "elf/cris.h"
  30 #include <limits.h>
  31
  32 /* Forward declarations.  */
  33 static reloc_howto_type * cris_reloc_type_lookup
  34   PARAMS ((bfd *abfd, bfd_reloc_code_real_type code));
  35
  36 static void cris_info_to_howto_rela
  37   PARAMS ((bfd *, arelent *, Elf_Internal_Rela *));
  38
  39 static bfd_reloc_status_type cris_elf_pcrel_reloc
  40   PARAMS ((bfd *, arelent *, asymbol *, PTR, asection *, bfd *, char **));
  41
  42 static bfd_boolean cris_elf_grok_prstatus
  43   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
  44
  45 static bfd_boolean cris_elf_grok_psinfo
  46   PARAMS ((bfd *abfd, Elf_Internal_Note *note));
  47
  48 static bfd_boolean cris_elf_relocate_section
  49   PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *,
  50            Elf_Internal_Rela *, Elf_Internal_Sym *, asection **));
  51
  52 static bfd_reloc_status_type cris_final_link_relocate
  53   PARAMS ((reloc_howto_type *, bfd *, asection *, bfd_byte *,
  54            Elf_Internal_Rela *, bfd_vma));
  55
  56 static bfd_boolean cris_elf_object_p PARAMS ((bfd *));
  57
  58 static void cris_elf_final_write_processing PARAMS ((bfd *, bfd_boolean));
  59
  60 static bfd_boolean cris_elf_set_mach_from_flags
  61   PARAMS ((bfd *, unsigned long int));
  62
  63 static bfd_boolean cris_elf_print_private_bfd_data PARAMS ((bfd *, PTR));
  64
  65 static bfd_boolean cris_elf_merge_private_bfd_data PARAMS ((bfd *, bfd *));
  66 static bfd_boolean cris_elf_copy_private_bfd_data PARAMS ((bfd *, bfd *));
  67
  68 struct elf_cris_link_hash_entry;
  69 static bfd_boolean elf_cris_discard_excess_dso_dynamics
  70   PARAMS ((struct elf_cris_link_hash_entry *, PTR));
  71 static bfd_boolean elf_cris_discard_excess_program_dynamics
  72   PARAMS ((struct elf_cris_link_hash_entry *, PTR));
  73 static bfd_boolean elf_cris_adjust_gotplt_to_got
  74   PARAMS ((struct elf_cris_link_hash_entry *, PTR));
  75 static bfd_boolean elf_cris_try_fold_plt_to_got
  76   PARAMS ((struct elf_cris_link_hash_entry *, PTR));
  77 static struct bfd_hash_entry *elf_cris_link_hash_newfunc
  78   PARAMS ((struct bfd_hash_entry *, struct bfd_hash_table *, const char *));
  79 static struct bfd_link_hash_table *elf_cris_link_hash_table_create
  80   PARAMS ((bfd *));
  81 static bfd_boolean elf_cris_adjust_dynamic_symbol
  82   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *));
  83 static bfd_boolean cris_elf_check_relocs
  84   PARAMS ((bfd *, struct bfd_link_info *, asection *,
  85            const Elf_Internal_Rela *));
  86
  87 static bfd_boolean elf_cris_size_dynamic_sections
  88   PARAMS ((bfd *, struct bfd_link_info *));
  89 static bfd_boolean elf_cris_finish_dynamic_symbol
  90   PARAMS ((bfd *, struct bfd_link_info *, struct elf_link_hash_entry *,
  91            Elf_Internal_Sym *));
  92 static bfd_boolean elf_cris_finish_dynamic_sections
  93   PARAMS ((bfd *, struct bfd_link_info *));
  94 static void elf_cris_hide_symbol
  95   PARAMS ((struct bfd_link_info *, struct elf_link_hash_entry *, bfd_boolean));
  96 static enum elf_reloc_type_class elf_cris_reloc_type_class
  97   PARAMS ((const Elf_Internal_Rela *));
  98
  99 static reloc_howto_type cris_elf_howto_table [] =
 100 {
 101   /* This reloc does nothing.  */
 102   HOWTO (R_CRIS_NONE,           /* type */
 103          0,                     /* rightshift */
 104          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 105          32,                    /* bitsize */
 106          FALSE,                 /* pc_relative */
 107          0,                     /* bitpos */
 108          complain_overflow_bitfield, /* complain_on_overflow */
 109          bfd_elf_generic_reloc, /* special_function */
 110          "R_CRIS_NONE",         /* name */
 111          FALSE,                 /* partial_inplace */
 112          0,                     /* src_mask */
 113          0,                     /* dst_mask */
 114          FALSE),                /* pcrel_offset */
 115
 116   /* An 8 bit absolute relocation.  */
 117   HOWTO (R_CRIS_8,              /* type */
 118          0,                     /* rightshift */
 119          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 120          8,                     /* bitsize */
 121          FALSE,                 /* pc_relative */
 122          0,                     /* bitpos */
 123          complain_overflow_bitfield, /* complain_on_overflow */
 124          bfd_elf_generic_reloc, /* special_function */
 125          "R_CRIS_8",            /* name */
 126          FALSE,                 /* partial_inplace */
 127          0x0000,                /* src_mask */
 128          0x00ff,                /* dst_mask */
 129          FALSE),                /* pcrel_offset */
 130
 131   /* A 16 bit absolute relocation.  */
 132   HOWTO (R_CRIS_16,             /* type */
 133          0,                     /* rightshift */
 134          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 135          16,                    /* bitsize */
 136          FALSE,                 /* pc_relative */
 137          0,                     /* bitpos */
 138          complain_overflow_bitfield, /* complain_on_overflow */
 139          bfd_elf_generic_reloc, /* special_function */
 140          "R_CRIS_16",           /* name */
 141          FALSE,                 /* partial_inplace */
 142          0x00000000,            /* src_mask */
 143          0x0000ffff,            /* dst_mask */
 144          FALSE),                /* pcrel_offset */
 145
 146   /* A 32 bit absolute relocation.  */
 147   HOWTO (R_CRIS_32,             /* type */
 148          0,                     /* rightshift */
 149          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 150          32,                    /* bitsize */
 151          FALSE,                 /* pc_relative */
 152          0,                     /* bitpos */
 153          /* We don't want overflow complaints for 64-bit vma builds
 154             for e.g. sym+0x40000000 (or actually sym-0xc0000000 in
 155             32-bit ELF) where sym=0xc0001234.
 156             Don't do this for the PIC relocs, as we don't expect to
 157             see them with large offsets.  */
 158          complain_overflow_dont, /* complain_on_overflow */
 159          bfd_elf_generic_reloc, /* special_function */
 160          "R_CRIS_32",           /* name */
 161          FALSE,                 /* partial_inplace */
 162          0x00000000,            /* src_mask */
 163          0xffffffff,            /* dst_mask */
 164          FALSE),                /* pcrel_offset */
 165
 166   /* An 8 bit PC-relative relocation.  */
 167   HOWTO (R_CRIS_8_PCREL,        /* type */
 168          0,                     /* rightshift */
 169          0,                     /* size (0 = byte, 1 = short, 2 = long) */
 170          8,                     /* bitsize */
 171          TRUE,                  /* pc_relative */
 172          0,                     /* bitpos */
 173          complain_overflow_bitfield, /* complain_on_overflow */
 174          cris_elf_pcrel_reloc,  /* special_function */
 175          "R_CRIS_8_PCREL",      /* name */
 176          FALSE,                 /* partial_inplace */
 177          0x0000,                /* src_mask */
 178          0x00ff,                /* dst_mask */
 179          TRUE),                 /* pcrel_offset */
 180
 181   /* A 16 bit PC-relative relocation.  */
 182   HOWTO (R_CRIS_16_PCREL,       /* type */
 183          0,                     /* rightshift */
 184          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 185          16,                    /* bitsize */
 186          TRUE,                  /* pc_relative */
 187          0,                     /* bitpos */
 188          complain_overflow_bitfield, /* complain_on_overflow */
 189          cris_elf_pcrel_reloc,  /* special_function */
 190          "R_CRIS_16_PCREL",     /* name */
 191          FALSE,                 /* partial_inplace */
 192          0x00000000,            /* src_mask */
 193          0x0000ffff,            /* dst_mask */
 194          TRUE),                 /* pcrel_offset */
 195
 196   /* A 32 bit PC-relative relocation.  */
 197   HOWTO (R_CRIS_32_PCREL,       /* type */
 198          0,                     /* rightshift */
 199          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 200          32,                    /* bitsize */
 201          TRUE,                  /* pc_relative */
 202          0,                     /* bitpos */
 203          complain_overflow_bitfield, /* complain_on_overflow */
 204          cris_elf_pcrel_reloc,  /* special_function */
 205          "R_CRIS_32_PCREL",     /* name */
 206          FALSE,                 /* partial_inplace */
 207          0x00000000,            /* src_mask */
 208          0xffffffff,            /* dst_mask */
 209          TRUE),                 /* pcrel_offset */
 210
 211   /* GNU extension to record C++ vtable hierarchy.  */
 212   HOWTO (R_CRIS_GNU_VTINHERIT,  /* type */
 213          0,                     /* rightshift */
 214          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 215          0,                     /* bitsize */
 216          FALSE,                 /* pc_relative */
 217          0,                     /* bitpos */
 218          complain_overflow_dont, /* complain_on_overflow */
 219          NULL,                  /* special_function */
 220          "R_CRIS_GNU_VTINHERIT", /* name */
 221          FALSE,                 /* partial_inplace */
 222          0,                     /* src_mask */
 223          0,                     /* dst_mask */
 224          FALSE),                /* pcrel_offset */
 225
 226   /* GNU extension to record C++ vtable member usage.  */
 227   HOWTO (R_CRIS_GNU_VTENTRY,    /* type */
 228          0,                     /* rightshift */
 229          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 230          0,                     /* bitsize */
 231          FALSE,                 /* pc_relative */
 232          0,                     /* bitpos */
 233          complain_overflow_dont, /* complain_on_overflow */
 234          _bfd_elf_rel_vtable_reloc_fn,  /* special_function */
 235          "R_CRIS_GNU_VTENTRY",   /* name */
 236          FALSE,                 /* partial_inplace */
 237          0,                     /* src_mask */
 238          0,                     /* dst_mask */
 239          FALSE),                /* pcrel_offset */
 240
 241   /* This is used only by the dynamic linker.  The symbol should exist
 242      both in the object being run and in some shared library.  The
 243      dynamic linker copies the data addressed by the symbol from the
 244      shared library into the object, because the object being
 245      run has to have the data at some particular address.  */
 246   HOWTO (R_CRIS_COPY,           /* type */
 247          0,                     /* rightshift */
 248          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 249          32,                    /* bitsize */
 250          FALSE,                 /* pc_relative */
 251          0,                     /* bitpos */
 252          complain_overflow_bitfield, /* complain_on_overflow */
 253          bfd_elf_generic_reloc, /* special_function */
 254          "R_CRIS_COPY",         /* name */
 255          FALSE,                 /* partial_inplace */
 256          0,                     /* src_mask */
 257          0,                     /* dst_mask */
 258          FALSE),                /* pcrel_offset */
 259
 260   /* Like R_CRIS_32, but used when setting global offset table entries.  */
 261   HOWTO (R_CRIS_GLOB_DAT,       /* type */
 262          0,                     /* rightshift */
 263          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 264          32,                    /* bitsize */
 265          FALSE,                 /* pc_relative */
 266          0,                     /* bitpos */
 267          complain_overflow_bitfield, /* complain_on_overflow */
 268          bfd_elf_generic_reloc, /* special_function */
 269          "R_CRIS_GLOB_DAT",     /* name */
 270          FALSE,                 /* partial_inplace */
 271          0,                     /* src_mask */
 272          0xffffffff,            /* dst_mask */
 273          FALSE),                /* pcrel_offset */
 274
 275   /* Marks a procedure linkage table entry for a symbol.  */
 276   HOWTO (R_CRIS_JUMP_SLOT,      /* type */
 277          0,                     /* rightshift */
 278          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 279          32,                    /* bitsize */
 280          FALSE,                 /* pc_relative */
 281          0,                     /* bitpos */
 282          complain_overflow_bitfield, /* complain_on_overflow */
 283          bfd_elf_generic_reloc, /* special_function */
 284          "R_CRIS_JUMP_SLOT",    /* name */
 285          FALSE,                 /* partial_inplace */
 286          0,                     /* src_mask */
 287          0,                     /* dst_mask */
 288          FALSE),                /* pcrel_offset */
 289
 290   /* Used only by the dynamic linker.  When the object is run, this
 291      longword is set to the load address of the object, plus the
 292      addend.  */
 293   HOWTO (R_CRIS_RELATIVE,       /* type */
 294          0,                     /* rightshift */
 295          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 296          32,                    /* bitsize */
 297          FALSE,                 /* pc_relative */
 298          0,                     /* bitpos */
 299          complain_overflow_bitfield, /* complain_on_overflow */
 300          bfd_elf_generic_reloc, /* special_function */
 301          "R_CRIS_RELATIVE",     /* name */
 302          FALSE,                 /* partial_inplace */
 303          0,                     /* src_mask */
 304          0xffffffff,            /* dst_mask */
 305          FALSE),                /* pcrel_offset */
 306
 307   /* Like R_CRIS_32, but referring to the GOT table entry for the symbol.  */
 308   HOWTO (R_CRIS_16_GOT,         /* type */
 309          0,                     /* rightshift */
 310          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 311          16,                    /* bitsize */
 312          FALSE,                 /* pc_relative */
 313          0,                     /* bitpos */
 314          complain_overflow_bitfield, /* complain_on_overflow */
 315          bfd_elf_generic_reloc, /* special_function */
 316          "R_CRIS_16_GOT",       /* name */
 317          FALSE,                 /* partial_inplace */
 318          0,                     /* src_mask */
 319          0xffff,                /* dst_mask */
 320          FALSE),                /* pcrel_offset */
 321
 322   HOWTO (R_CRIS_32_GOT,         /* type */
 323          0,                     /* rightshift */
 324          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 325          32,                    /* bitsize */
 326          FALSE,                 /* pc_relative */
 327          0,                     /* bitpos */
 328          complain_overflow_bitfield, /* complain_on_overflow */
 329          bfd_elf_generic_reloc, /* special_function */
 330          "R_CRIS_32_GOT",       /* name */
 331          FALSE,                 /* partial_inplace */
 332          0,                     /* src_mask */
 333          0xffffffff,            /* dst_mask */
 334          FALSE),                /* pcrel_offset */
 335
 336   /* Like R_CRIS_32_GOT, but referring to (and requesting a) PLT part of
 337      the GOT table for the symbol.  */
 338   HOWTO (R_CRIS_16_GOTPLT,      /* type */
 339          0,                     /* rightshift */
 340          1,                     /* size (0 = byte, 1 = short, 2 = long) */
 341          16,                    /* bitsize */
 342          FALSE,                 /* pc_relative */
 343          0,                     /* bitpos */
 344          complain_overflow_bitfield, /* complain_on_overflow */
 345          bfd_elf_generic_reloc, /* special_function */
 346          "R_CRIS_16_GOTPLT",    /* name */
 347          FALSE,                 /* partial_inplace */
 348          0,                     /* src_mask */
 349          0xffff,                /* dst_mask */
 350          FALSE),                /* pcrel_offset */
 351
 352   HOWTO (R_CRIS_32_GOTPLT,      /* type */
 353          0,                     /* rightshift */
 354          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 355          32,                    /* bitsize */
 356          FALSE,                 /* pc_relative */
 357          0,                     /* bitpos */
 358          complain_overflow_bitfield, /* complain_on_overflow */
 359          bfd_elf_generic_reloc, /* special_function */
 360          "R_CRIS_32_GOTPLT",    /* name */
 361          FALSE,                 /* partial_inplace */
 362          0,                     /* src_mask */
 363          0xffffffff,            /* dst_mask */
 364          FALSE),                /* pcrel_offset */
 365
 366   /* A 32-bit offset from GOT to (local const) symbol: no GOT entry should
 367      be necessary.  */
 368   HOWTO (R_CRIS_32_GOTREL,      /* type */
 369          0,                     /* rightshift */
 370          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 371          32,                    /* bitsize */
 372          FALSE,                 /* pc_relative */
 373          0,                     /* bitpos */
 374          complain_overflow_bitfield, /* complain_on_overflow */
 375          bfd_elf_generic_reloc, /* special_function */
 376          "R_CRIS_32_GOTREL",    /* name */
 377          FALSE,                 /* partial_inplace */
 378          0,                     /* src_mask */
 379          0xffffffff,            /* dst_mask */
 380          FALSE),                /* pcrel_offset */
 381
 382   /* A 32-bit offset from GOT to entry for this symbol in PLT and request
 383      to create PLT entry for symbol.  */
 384   HOWTO (R_CRIS_32_PLT_GOTREL,  /* type */
 385          0,                     /* rightshift */
 386          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 387          32,                    /* bitsize */
 388          FALSE,                 /* pc_relative */
 389          0,                     /* bitpos */
 390          complain_overflow_bitfield, /* complain_on_overflow */
 391          bfd_elf_generic_reloc, /* special_function */
 392          "R_CRIS_32_PLT_GOTREL", /* name */
 393          FALSE,                 /* partial_inplace */
 394          0,                     /* src_mask */
 395          0xffffffff,            /* dst_mask */
 396          FALSE),                /* pcrel_offset */
 397
 398   /* A 32-bit offset from PC (location after the relocation) + addend to
 399      entry for this symbol in PLT and request to create PLT entry for
 400      symbol.  */
 401   HOWTO (R_CRIS_32_PLT_PCREL,   /* type */
 402          0,                     /* rightshift */
 403          2,                     /* size (0 = byte, 1 = short, 2 = long) */
 404          32,                    /* bitsize */
 405          TRUE,                  /* pc_relative */
 406          0,                     /* bitpos */
 407          complain_overflow_bitfield, /* complain_on_overflow */
 408          cris_elf_pcrel_reloc,  /* special_function */
 409          "R_CRIS_32_PLT_PCREL", /* name */
 410          FALSE,                 /* partial_inplace */
 411          0,                     /* src_mask */
 412          0xffffffff,            /* dst_mask */
 413          TRUE),                 /* pcrel_offset */
 414
 415   /* We don't handle these in any special manner and cross-format
 416      linking is not supported; just recognize them enough to pass them
 417      around.  FIXME: do the same for most PIC relocs and add sanity
 418      tests to actually refuse gracefully to handle these and PIC
 419      relocs for cross-format linking.  */
 420 #define TLSHOWTO32(name) \
 421  HOWTO (name, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, \
 422         bfd_elf_generic_reloc, #name, FALSE, 0, 0xffffffff, FALSE)
 423 #define TLSHOWTO16X(name, X)         \
 424  HOWTO (name, 0, 1, 16, FALSE, 0, complain_overflow_ ## X, \
 425         bfd_elf_generic_reloc, #name, FALSE, 0, 0xffff, FALSE)
 426 #define TLSHOWTO16(name) TLSHOWTO16X(name, unsigned)
 427 #define TLSHOWTO16S(name) TLSHOWTO16X(name, signed)
 428
 429   TLSHOWTO32 (R_CRIS_32_GOT_GD),
 430   TLSHOWTO16 (R_CRIS_16_GOT_GD),
 431   TLSHOWTO32 (R_CRIS_32_GD),
 432   TLSHOWTO32 (R_CRIS_DTP),
 433   TLSHOWTO32 (R_CRIS_32_DTPREL),
 434   TLSHOWTO16S (R_CRIS_16_DTPREL),
 435   TLSHOWTO32 (R_CRIS_32_GOT_TPREL),
 436   TLSHOWTO16S (R_CRIS_16_GOT_TPREL),
 437   TLSHOWTO32 (R_CRIS_32_TPREL),
 438   TLSHOWTO16S (R_CRIS_16_TPREL),
 439   TLSHOWTO32 (R_CRIS_DTPMOD)
 440 };
 441 \f
 442 /* Map BFD reloc types to CRIS ELF reloc types.  */
 443
 444 struct cris_reloc_map
 445 {
 446   bfd_reloc_code_real_type bfd_reloc_val;
 447   unsigned int cris_reloc_val;
 448 };
 449
 450 static const struct cris_reloc_map cris_reloc_map [] =
 451 {
 452   { BFD_RELOC_NONE,             R_CRIS_NONE },
 453   { BFD_RELOC_8,                R_CRIS_8 },
 454   { BFD_RELOC_16,               R_CRIS_16 },
 455   { BFD_RELOC_32,               R_CRIS_32 },
 456   { BFD_RELOC_8_PCREL,          R_CRIS_8_PCREL },
 457   { BFD_RELOC_16_PCREL,         R_CRIS_16_PCREL },
 458   { BFD_RELOC_32_PCREL,         R_CRIS_32_PCREL },
 459   { BFD_RELOC_VTABLE_INHERIT,   R_CRIS_GNU_VTINHERIT },
 460   { BFD_RELOC_VTABLE_ENTRY,     R_CRIS_GNU_VTENTRY },
 461   { BFD_RELOC_CRIS_COPY,        R_CRIS_COPY },
 462   { BFD_RELOC_CRIS_GLOB_DAT,    R_CRIS_GLOB_DAT },
 463   { BFD_RELOC_CRIS_JUMP_SLOT,   R_CRIS_JUMP_SLOT },
 464   { BFD_RELOC_CRIS_RELATIVE,    R_CRIS_RELATIVE },
 465   { BFD_RELOC_CRIS_16_GOT,      R_CRIS_16_GOT },
 466   { BFD_RELOC_CRIS_32_GOT,      R_CRIS_32_GOT },
 467   { BFD_RELOC_CRIS_16_GOTPLT,   R_CRIS_16_GOTPLT },
 468   { BFD_RELOC_CRIS_32_GOTPLT,   R_CRIS_32_GOTPLT },
 469   { BFD_RELOC_CRIS_32_GOTREL,   R_CRIS_32_GOTREL },
 470   { BFD_RELOC_CRIS_32_PLT_GOTREL, R_CRIS_32_PLT_GOTREL },
 471   { BFD_RELOC_CRIS_32_PLT_PCREL, R_CRIS_32_PLT_PCREL },
 472   { BFD_RELOC_CRIS_32_GOT_GD,   R_CRIS_32_GOT_GD },
 473   { BFD_RELOC_CRIS_16_GOT_GD,   R_CRIS_16_GOT_GD },
 474   { BFD_RELOC_CRIS_32_GD,       R_CRIS_32_GD },
 475   { BFD_RELOC_CRIS_DTP, R_CRIS_DTP },
 476   { BFD_RELOC_CRIS_32_DTPREL,   R_CRIS_32_DTPREL },
 477   { BFD_RELOC_CRIS_16_DTPREL,   R_CRIS_16_DTPREL },
 478   { BFD_RELOC_CRIS_32_GOT_TPREL, R_CRIS_32_GOT_TPREL },
 479   { BFD_RELOC_CRIS_16_GOT_TPREL, R_CRIS_16_GOT_TPREL },
 480   { BFD_RELOC_CRIS_32_TPREL,    R_CRIS_32_TPREL },
 481   { BFD_RELOC_CRIS_16_TPREL,    R_CRIS_16_TPREL },
 482   { BFD_RELOC_CRIS_DTPMOD,      R_CRIS_DTPMOD }
 483 };
 484
 485 static reloc_howto_type *
 486 cris_reloc_type_lookup (abfd, code)
 487      bfd * abfd ATTRIBUTE_UNUSED;
 488      bfd_reloc_code_real_type code;
 489 {
 490   unsigned int i;
 491
 492   for (i = 0; i < sizeof (cris_reloc_map) / sizeof (cris_reloc_map[0]); i++)
 493     if (cris_reloc_map [i].bfd_reloc_val == code)
 494       return & cris_elf_howto_table [cris_reloc_map[i].cris_reloc_val];
 495
 496   return NULL;
 497 }
 498
 499 static reloc_howto_type *
 500 cris_reloc_name_lookup (bfd *abfd ATTRIBUTE_UNUSED, const char *r_name)
 501 {
 502   unsigned int i;
 503
 504   for (i = 0;
 505        i < sizeof (cris_elf_howto_table) / sizeof (cris_elf_howto_table[0]);
 506        i++)
 507     if (cris_elf_howto_table[i].name != NULL
 508         && strcasecmp (cris_elf_howto_table[i].name, r_name) == 0)
 509       return &cris_elf_howto_table[i];
 510
 511   return NULL;
 512 }
 513
 514 /* Set the howto pointer for an CRIS ELF reloc.  */
 515
 516 static void
 517 cris_info_to_howto_rela (abfd, cache_ptr, dst)
 518      bfd * abfd ATTRIBUTE_UNUSED;
 519      arelent * cache_ptr;
 520      Elf_Internal_Rela * dst;
 521 {
 522   enum elf_cris_reloc_type r_type;
 523
 524   r_type = ELF32_R_TYPE (dst->r_info);
 525   BFD_ASSERT (r_type < (unsigned int) R_CRIS_max);
 526   cache_ptr->howto = & cris_elf_howto_table [r_type];
 527 }
 528
 529 bfd_reloc_status_type
 530 cris_elf_pcrel_reloc (abfd, reloc_entry, symbol, data, input_section,
 531                       output_bfd, error_message)
 532      bfd *abfd ATTRIBUTE_UNUSED;
 533      arelent *reloc_entry;
 534      asymbol *symbol;
 535      PTR data ATTRIBUTE_UNUSED;
 536      asection *input_section;
 537      bfd *output_bfd;
 538      char **error_message ATTRIBUTE_UNUSED;
 539 {
 540   /* By default (using only bfd_elf_generic_reloc when linking to
 541      non-ELF formats) PC-relative relocs are relative to the beginning
 542      of the reloc.  CRIS PC-relative relocs are relative to the position
 543      *after* the reloc because that's what pre-CRISv32 PC points to
 544      after reading an insn field with that reloc.  (For CRISv32, PC is
 545      actually relative to the start of the insn, but we keep the old
 546      definition.)  Still, we use as much generic machinery as we can.
 547
 548      Only adjust when doing a final link.  */
 549   if (output_bfd == (bfd *) NULL)
 550     reloc_entry->addend -= 1 << reloc_entry->howto->size;
 551
 552   return
 553     bfd_elf_generic_reloc (abfd, reloc_entry, symbol, data,
 554                            input_section, output_bfd, error_message);
 555 }
 556 \f
 557 /* Support for core dump NOTE sections.
 558    The slightly unintuitive code layout is an attempt to keep at least
 559    some similarities with other ports, hoping to simplify general
 560    changes, while still keeping Linux/CRIS and Linux/CRISv32 code apart.  */
 561
 562 static bfd_boolean
 563 cris_elf_grok_prstatus (abfd, note)
 564      bfd *abfd;
 565      Elf_Internal_Note *note;
 566 {
 567   int offset;
 568   size_t size;
 569
 570   if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
 571     switch (note->descsz)
 572       {
 573       default:
 574         return FALSE;
 575
 576       case 202:         /* Linux/CRISv32 */
 577         /* pr_cursig */
 578         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 579
 580         /* pr_pid */
 581         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
 582
 583         /* pr_reg */
 584         offset = 70;
 585         size = 128;
 586
 587         break;
 588       }
 589   else
 590     switch (note->descsz)
 591       {
 592       default:
 593         return FALSE;
 594
 595       case 214:         /* Linux/CRIS */
 596         /* pr_cursig */
 597         elf_tdata (abfd)->core_signal = bfd_get_16 (abfd, note->descdata + 12);
 598
 599         /* pr_pid */
 600         elf_tdata (abfd)->core_pid = bfd_get_32 (abfd, note->descdata + 22);
 601
 602         /* pr_reg */
 603         offset = 70;
 604         size = 140;
 605
 606         break;
 607       }
 608
 609   /* Make a ".reg/999" section.  */
 610   return _bfd_elfcore_make_pseudosection (abfd, ".reg",
 611                                           size, note->descpos + offset);
 612 }
 613
 614 static bfd_boolean
 615 cris_elf_grok_psinfo (abfd, note)
 616      bfd *abfd;
 617      Elf_Internal_Note *note;
 618 {
 619   if (bfd_get_mach (abfd) == bfd_mach_cris_v32)
 620     switch (note->descsz)
 621       {
 622       default:
 623         return FALSE;
 624
 625       case 124:         /* Linux/CRISv32 elf_prpsinfo */
 626         elf_tdata (abfd)->core_program
 627           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 628         elf_tdata (abfd)->core_command
 629           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 630       }
 631   else
 632     switch (note->descsz)
 633       {
 634       default:
 635         return FALSE;
 636
 637       case 124:         /* Linux/CRIS elf_prpsinfo */
 638         elf_tdata (abfd)->core_program
 639           = _bfd_elfcore_strndup (abfd, note->descdata + 28, 16);
 640         elf_tdata (abfd)->core_command
 641           = _bfd_elfcore_strndup (abfd, note->descdata + 44, 80);
 642       }
 643
 644   /* Note that for some reason, a spurious space is tacked
 645      onto the end of the args in some (at least one anyway)
 646      implementations, so strip it off if it exists.  */
 647
 648   {
 649     char *command = elf_tdata (abfd)->core_command;
 650     int n = strlen (command);
 651
 652     if (0 < n && command[n - 1] == ' ')
 653       command[n - 1] = '\0';
 654   }
 655
 656   return TRUE;
 657 }
 658 \f
 659 /* The name of the dynamic interpreter.  This is put in the .interp
 660    section.  */
 661
 662 #define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
 663
 664 /* The size in bytes of an entry in the procedure linkage table.  */
 665
 666 #define PLT_ENTRY_SIZE 20
 667 #define PLT_ENTRY_SIZE_V32 26
 668
 669 /* The first entry in an absolute procedure linkage table looks like this.  */
 670
 671 static const bfd_byte elf_cris_plt0_entry[PLT_ENTRY_SIZE] =
 672 {
 673   0xfc, 0xe1,
 674   0x7e, 0x7e,   /* push mof.  */
 675   0x7f, 0x0d,   /*  (dip [pc+]) */
 676   0, 0, 0, 0,   /*  Replaced with address of .got + 4.  */
 677   0x30, 0x7a,   /* move [...],mof */
 678   0x7f, 0x0d,   /*  (dip [pc+]) */
 679   0, 0, 0, 0,   /*  Replaced with address of .got + 8.  */
 680   0x30, 0x09    /* jump [...] */
 681 };
 682
 683 static const bfd_byte elf_cris_plt0_entry_v32[PLT_ENTRY_SIZE_V32] =
 684 {
 685   0x84, 0xe2,   /* subq 4,$sp */
 686   0x6f, 0xfe,   /* move.d 0,$acr */
 687   0, 0, 0, 0,   /*  Replaced by address of .got + 4.  */
 688   0x7e, 0x7a,   /* move $mof,[$sp] */
 689   0x3f, 0x7a,   /* move [$acr],$mof */
 690   0x04, 0xf2,   /* addq 4,acr */
 691   0x6f, 0xfa,   /* move.d [$acr],$acr */
 692   0xbf, 0x09,   /* jump $acr */
 693   0xb0, 0x05,   /* nop */
 694   0, 0          /*  Pad out to 26 bytes.  */
 695 };
 696
 697 /* Subsequent entries in an absolute procedure linkage table look like
 698    this.  */
 699
 700 static const bfd_byte elf_cris_plt_entry[PLT_ENTRY_SIZE] =
 701 {
 702   0x7f, 0x0d,   /*  (dip [pc+]) */
 703   0, 0, 0, 0,   /*  Replaced with address of this symbol in .got.  */
 704   0x30, 0x09,   /* jump [...] */
 705   0x3f,  0x7e,  /* move [pc+],mof */
 706   0, 0, 0, 0,   /*  Replaced with offset into relocation table.  */
 707   0x2f, 0xfe,   /* add.d [pc+],pc */
 708   0xec, 0xff,
 709   0xff, 0xff    /*  Replaced with offset to start of .plt.  */
 710 };
 711
 712 static const bfd_byte elf_cris_plt_entry_v32[PLT_ENTRY_SIZE_V32] =
 713 {
 714   0x6f, 0xfe,   /* move.d 0,$acr */
 715   0, 0, 0, 0,   /*  Replaced with address of this symbol in .got.  */
 716   0x6f, 0xfa,   /* move.d [$acr],$acr */
 717   0xbf, 0x09,   /* jump $acr */
 718   0xb0, 0x05,   /* nop */
 719   0x3f, 0x7e,   /* move 0,mof */
 720   0, 0, 0, 0,   /*  Replaced with offset into relocation table. */
 721   0xbf, 0x0e,   /* ba start_of_plt0_entry */
 722   0, 0, 0, 0,   /*  Replaced with offset to plt0 entry.  */
 723   0xb0, 0x05    /* nop */
 724 };
 725
 726 /* The first entry in a PIC procedure linkage table looks like this.  */
 727
 728 static const bfd_byte elf_cris_pic_plt0_entry[PLT_ENTRY_SIZE] =
 729 {
 730   0xfc, 0xe1, 0x7e, 0x7e,       /* push mof */
 731   0x04, 0x01, 0x30, 0x7a,       /* move [r0+4],mof */
 732   0x08, 0x01, 0x30, 0x09,       /* jump [r0+8] */
 733   0, 0, 0, 0, 0, 0, 0, 0,       /*  Pad out to 20 bytes.  */
 734 };
 735
 736 static const bfd_byte elf_cris_pic_plt0_entry_v32[PLT_ENTRY_SIZE_V32] =
 737 {
 738   0x84, 0xe2,   /* subq 4,$sp */
 739   0x04, 0x01,   /* addoq 4,$r0,$acr */
 740   0x7e, 0x7a,   /* move $mof,[$sp] */
 741   0x3f, 0x7a,   /* move [$acr],$mof */
 742   0x04, 0xf2,   /* addq 4,$acr */
 743   0x6f, 0xfa,   /* move.d [$acr],$acr */
 744   0xbf, 0x09,   /* jump $acr */
 745   0xb0, 0x05,   /* nop */
 746   0, 0,         /*  Pad out to 26 bytes.  */
 747   0, 0, 0, 0,
 748   0, 0, 0, 0
 749 };
 750
 751 /* Subsequent entries in a PIC procedure linkage table look like this.  */
 752
 753 static const bfd_byte elf_cris_pic_plt_entry[PLT_ENTRY_SIZE] =
 754 {
 755   0x6f, 0x0d,   /*  (bdap [pc+].d,r0) */
 756   0, 0, 0, 0,   /*  Replaced with offset of this symbol in .got.  */
 757   0x30, 0x09,   /* jump [...] */
 758   0x3f, 0x7e,   /* move [pc+],mof */
 759   0, 0, 0, 0,   /*  Replaced with offset into relocation table.  */
 760   0x2f, 0xfe,   /* add.d [pc+],pc */
 761   0xec, 0xff,   /*  Replaced with offset to start of .plt.  */
 762   0xff, 0xff
 763 };
 764
 765 static const bfd_byte elf_cris_pic_plt_entry_v32[PLT_ENTRY_SIZE_V32] =
 766 {
 767   0x6f, 0x0d,   /* addo.d 0,$r0,$acr */
 768   0, 0, 0, 0,   /*  Replaced with offset of this symbol in .got.  */
 769   0x6f, 0xfa,   /* move.d [$acr],$acr */
 770   0xbf, 0x09,   /* jump $acr */
 771   0xb0, 0x05,   /* nop */
 772   0x3f, 0x7e,   /* move relocoffs,$mof */
 773   0, 0, 0, 0,   /*  Replaced with offset into relocation table.  */
 774   0xbf, 0x0e,   /* ba start_of_plt */
 775   0, 0, 0, 0,   /*  Replaced with offset to start of .plt.  */
 776   0xb0, 0x05    /* nop */
 777 };
 778 \f
 779 /* We copy elf32-m68k.c and elf32-i386.c for the basic linker hash bits
 780    (and most other PIC/shlib stuff).  Check that we don't drift away
 781    without reason.
 782
 783    The CRIS linker, like the m68k and i386 linkers (and probably the rest
 784    too) needs to keep track of the number of relocs that it decides to
 785    copy in check_relocs for each symbol.  This is so that it can discard
 786    PC relative relocs if it doesn't need them when linking with
 787    -Bsymbolic.  We store the information in a field extending the regular
 788    ELF linker hash table.  */
 789
 790 /* This structure keeps track of the number of PC relative relocs we have
 791    copied for a given symbol.  */
 792
 793 struct elf_cris_pcrel_relocs_copied
 794 {
 795   /* Next section.  */
 796   struct elf_cris_pcrel_relocs_copied *next;
 797
 798   /* A section in dynobj.  */
 799   asection *section;
 800
 801   /* Number of relocs copied in this section.  */
 802   bfd_size_type count;
 803
 804   /* Example of reloc being copied, for message.  */
 805   enum elf_cris_reloc_type r_type;
 806 };
 807
 808 /* CRIS ELF linker hash entry.  */
 809
 810 struct elf_cris_link_hash_entry
 811 {
 812   struct elf_link_hash_entry root;
 813
 814   /* Number of PC relative relocs copied for this symbol.  */
 815   struct elf_cris_pcrel_relocs_copied *pcrel_relocs_copied;
 816
 817   /* The GOTPLT references are CRIS-specific; the goal is to avoid having
 818      both a general GOT and a PLT-specific GOT entry for the same symbol,
 819      when it is referenced both as a function and as a function pointer.
 820
 821      Number of GOTPLT references for a function.  */
 822   bfd_signed_vma gotplt_refcount;
 823
 824   /* Actual GOTPLT index for this symbol, if applicable, or zero if not
 825      (zero is never used as an index).  FIXME: We should be able to fold
 826      this with gotplt_refcount in a union, like the got and plt unions in
 827      elf_link_hash_entry.  */
 828   bfd_size_type gotplt_offset;
 829
 830   /* The root.got.refcount is the sum of the regular reference counts
 831      (this) and those members below.  We have to keep a separate count
 832      to track when we've found the first (or last) reference to a
 833      regular got entry.  The offset is in root.got.offset.  */
 834   bfd_signed_vma reg_got_refcount;
 835
 836   /* Similar to the above, the number of reloc references to this
 837      symbols that need a R_CRIS_32_TPREL slot.  The offset is in
 838      root.got.offset, because this and .dtp_refcount can't validly
 839      happen when there's also a regular GOT entry; that's invalid
 840      input for which an error is emitted.  */
 841   bfd_signed_vma tprel_refcount;
 842
 843   /* Similar to the above, the number of reloc references to this
 844      symbols that need a R_CRIS_DTP slot.  The offset is in
 845      root.got.offset; plus 4 if .tprel_refcount > 0.  */
 846   bfd_signed_vma dtp_refcount;
 847 };
 848
 849 /* The local_got_refcounts and local_got_offsets are a multiple of
 850    LSNUM in size, namely LGOT_ALLOC_NELTS_FOR(LSNUM) (plus one for the
 851    refcount for GOT itself, see code), with the summary / group offset
 852    for local symbols located at offset N, reference counts for
 853    ordinary (address) relocs at offset N + LSNUM, for R_CRIS_DTP
 854    relocs at offset N + 2*LSNUM, and for R_CRIS_32_TPREL relocs at N +
 855    3*LSNUM.  */
 856
 857 #define LGOT_REG_NDX(x) ((x) + symtab_hdr->sh_info)
 858 #define LGOT_DTP_NDX(x) ((x) + 2 * symtab_hdr->sh_info)
 859 #define LGOT_TPREL_NDX(x) ((x) + 3 * symtab_hdr->sh_info)
 860 #define LGOT_ALLOC_NELTS_FOR(x) ((x) * 4)
 861
 862 /* CRIS ELF linker hash table.  */
 863
 864 struct elf_cris_link_hash_table
 865 {
 866   struct elf_link_hash_table root;
 867
 868   /* We can't use the PLT offset and calculate to get the GOTPLT offset,
 869      since we try and avoid creating GOTPLT:s when there's already a GOT.
 870      Instead, we keep and update the next available index here.  */
 871   bfd_size_type next_gotplt_entry;
 872
 873   /* The number of R_CRIS_32_DTPREL and R_CRIS_16_DTPREL that have
 874      been seen for any input; if != 0, then the constant-offset
 875      R_CRIS_DTPMOD is needed for this DSO/executable.  This turns
 876      negative at relocation, so that we don't need an extra flag for
 877      when the reloc is output.  */
 878   bfd_signed_vma dtpmod_refcount;
 879 };
 880
 881 /* Traverse a CRIS ELF linker hash table.  */
 882
 883 #define elf_cris_link_hash_traverse(table, func, info)                  \
 884   (elf_link_hash_traverse                                               \
 885    (&(table)->root,                                                     \
 886     (bfd_boolean (*) PARAMS ((struct elf_link_hash_entry *, PTR))) (func), \
 887     (info)))
 888
 889 /* Get the CRIS ELF linker hash table from a link_info structure.  */
 890
 891 #define elf_cris_hash_table(p) \
 892   ((struct elf_cris_link_hash_table *) (p)->hash)
 893
 894 /* Get the CRIS ELF linker hash entry from a regular hash entry (the
 895    "parent class").  The .root reference is just a simple type
 896    check on the argument.  */
 897
 898 #define elf_cris_hash_entry(p) \
 899  ((struct elf_cris_link_hash_entry *) (&(p)->root))
 900
 901 /* Create an entry in a CRIS ELF linker hash table.  */
 902
 903 static struct bfd_hash_entry *
 904 elf_cris_link_hash_newfunc (entry, table, string)
 905      struct bfd_hash_entry *entry;
 906      struct bfd_hash_table *table;
 907      const char *string;
 908 {
 909   struct elf_cris_link_hash_entry *ret =
 910     (struct elf_cris_link_hash_entry *) entry;
 911
 912   /* Allocate the structure if it has not already been allocated by a
 913      subclass.  */
 914   if (ret == (struct elf_cris_link_hash_entry *) NULL)
 915     ret = ((struct elf_cris_link_hash_entry *)
 916            bfd_hash_allocate (table,
 917                               sizeof (struct elf_cris_link_hash_entry)));
 918   if (ret == (struct elf_cris_link_hash_entry *) NULL)
 919     return (struct bfd_hash_entry *) ret;
 920
 921   /* Call the allocation method of the superclass.  */
 922   ret = ((struct elf_cris_link_hash_entry *)
 923          _bfd_elf_link_hash_newfunc ((struct bfd_hash_entry *) ret,
 924                                      table, string));
 925   if (ret != (struct elf_cris_link_hash_entry *) NULL)
 926     {
 927       ret->pcrel_relocs_copied = NULL;
 928       ret->gotplt_refcount = 0;
 929       ret->gotplt_offset = 0;
 930       ret->dtp_refcount = 0;
 931       ret->tprel_refcount = 0;
 932       ret->reg_got_refcount = 0;
 933     }
 934
 935   return (struct bfd_hash_entry *) ret;
 936 }
 937
 938 /* Create a CRIS ELF linker hash table.  */
 939
 940 static struct bfd_link_hash_table *
 941 elf_cris_link_hash_table_create (abfd)
 942      bfd *abfd;
 943 {
 944   struct elf_cris_link_hash_table *ret;
 945   bfd_size_type amt = sizeof (struct elf_cris_link_hash_table);
 946
 947   ret = ((struct elf_cris_link_hash_table *) bfd_malloc (amt));
 948   if (ret == (struct elf_cris_link_hash_table *) NULL)
 949     return NULL;
 950
 951   if (!_bfd_elf_link_hash_table_init (&ret->root, abfd,
 952                                       elf_cris_link_hash_newfunc,
 953                                       sizeof (struct elf_cris_link_hash_entry)))
 954     {
 955       free (ret);
 956       return NULL;
 957     }
 958
 959   /* Initialize to skip over the first three entries in the gotplt; they
 960      are used for run-time symbol evaluation.  */
 961   ret->next_gotplt_entry = 12;
 962
 963   /* We haven't seen any R_CRIS_nn_GOT_TPREL initially.  */
 964   ret->dtpmod_refcount = 0;
 965
 966   return &ret->root.root;
 967 }
 968 \f
 969 /* Perform a single relocation.  By default we use the standard BFD
 970    routines, with a few tweaks.  */
 971
 972 static bfd_reloc_status_type
 973 cris_final_link_relocate (howto, input_bfd, input_section, contents, rel,
 974                           relocation)
 975      reloc_howto_type *  howto;
 976      bfd *               input_bfd;
 977      asection *          input_section;
 978      bfd_byte *          contents;
 979      Elf_Internal_Rela * rel;
 980      bfd_vma             relocation;
 981 {
 982   bfd_reloc_status_type r;
 983   enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
 984
 985   /* PC-relative relocations are relative to the position *after*
 986      the reloc.  Note that for R_CRIS_8_PCREL the adjustment is
 987      not a single byte, since PC must be 16-bit-aligned.  */
 988   switch (r_type)
 989     {
 990       /* Check that the 16-bit GOT relocs are positive.  */
 991     case R_CRIS_16_GOTPLT:
 992     case R_CRIS_16_GOT:
 993       if ((bfd_signed_vma) relocation < 0)
 994         return bfd_reloc_overflow;
 995       break;
 996
 997     case R_CRIS_32_PLT_PCREL:
 998     case R_CRIS_32_PCREL:
 999       relocation -= 2;
1000       /* Fall through.  */
1001     case R_CRIS_8_PCREL:
1002     case R_CRIS_16_PCREL:
1003       relocation -= 2;
1004       break;
1005
1006     default:
1007       break;
1008     }
1009
1010   r = _bfd_final_link_relocate (howto, input_bfd, input_section,
1011                                 contents, rel->r_offset,
1012                                 relocation, rel->r_addend);
1013   return r;
1014 }
1015 \f
1016
1017 /* The number of errors left before we stop outputting reloc-specific
1018    explanatory messages.  By coincidence, this works nicely together
1019    with the default number of messages you'll get from LD about
1020    "relocation truncated to fit" messages before you get an
1021    "additional relocation overflows omitted from the output".  */
1022 static int additional_relocation_error_msg_count = 10;
1023
1024 /* Relocate an CRIS ELF section.  See elf32-fr30.c, from where this was
1025    copied, for further comments.  */
1026
1027 static bfd_boolean
1028 cris_elf_relocate_section (output_bfd, info, input_bfd, input_section,
1029                            contents, relocs, local_syms, local_sections)
1030      bfd *output_bfd ATTRIBUTE_UNUSED;
1031      struct bfd_link_info *info;
1032      bfd *input_bfd;
1033      asection *input_section;
1034      bfd_byte *contents;
1035      Elf_Internal_Rela *relocs;
1036      Elf_Internal_Sym *local_syms;
1037      asection **local_sections;
1038 {
1039   bfd *dynobj;
1040   Elf_Internal_Shdr *symtab_hdr;
1041   struct elf_link_hash_entry **sym_hashes;
1042   bfd_vma *local_got_offsets;
1043   asection *sgot;
1044   asection *splt;
1045   asection *sreloc;
1046   Elf_Internal_Rela *rel;
1047   Elf_Internal_Rela *relend;
1048   asection *srelgot;
1049
1050   dynobj = elf_hash_table (info)->dynobj;
1051   local_got_offsets = elf_local_got_offsets (input_bfd);
1052   symtab_hdr = & elf_tdata (input_bfd)->symtab_hdr;
1053   sym_hashes = elf_sym_hashes (input_bfd);
1054   relend     = relocs + input_section->reloc_count;
1055
1056   sgot = NULL;
1057   splt = NULL;
1058   sreloc = NULL;
1059   srelgot = NULL;
1060
1061   if (dynobj != NULL)
1062     {
1063       splt = bfd_get_section_by_name (dynobj, ".plt");
1064       sgot = bfd_get_section_by_name (dynobj, ".got");
1065     }
1066
1067   for (rel = relocs; rel < relend; rel ++)
1068     {
1069       reloc_howto_type *howto;
1070       unsigned long r_symndx;
1071       Elf_Internal_Sym *sym;
1072       asection *sec;
1073       struct elf_link_hash_entry *h;
1074       bfd_vma relocation;
1075       bfd_reloc_status_type r;
1076       const char *symname = NULL;
1077       enum elf_cris_reloc_type r_type;
1078
1079       r_type = ELF32_R_TYPE (rel->r_info);
1080
1081       if (   r_type == R_CRIS_GNU_VTINHERIT
1082           || r_type == R_CRIS_GNU_VTENTRY)
1083         continue;
1084
1085       r_symndx = ELF32_R_SYM (rel->r_info);
1086       howto  = cris_elf_howto_table + r_type;
1087       h      = NULL;
1088       sym    = NULL;
1089       sec    = NULL;
1090
1091       if (r_symndx < symtab_hdr->sh_info)
1092         {
1093           sym = local_syms + r_symndx;
1094           sec = local_sections [r_symndx];
1095           relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sec, rel);
1096
1097           symname = (bfd_elf_string_from_elf_section
1098                      (input_bfd, symtab_hdr->sh_link, sym->st_name));
1099           if (symname == NULL)
1100             symname = bfd_section_name (input_bfd, sec);
1101         }
1102       else
1103         {
1104           bfd_boolean warned;
1105           bfd_boolean unresolved_reloc;
1106
1107           RELOC_FOR_GLOBAL_SYMBOL (info, input_bfd, input_section, rel,
1108                                    r_symndx, symtab_hdr, sym_hashes,
1109                                    h, sec, relocation,
1110                                    unresolved_reloc, warned);
1111
1112           symname = h->root.root.string;
1113
1114           if (unresolved_reloc
1115               /* Perhaps we should detect the cases that
1116                  sec->output_section is expected to be NULL like i386 and
1117                  m68k, but apparently (and according to elfxx-ia64.c) all
1118                  valid cases are where the symbol is defined in a shared
1119                  object which we link dynamically against.  This includes
1120                  PLT relocs for which we've created a PLT entry and other
1121                  relocs for which we're prepared to create dynamic
1122                  relocations.
1123
1124                  For now, new situations cause us to just err when
1125                  sec->output_offset is NULL but the object with the symbol
1126                  is *not* dynamically linked against.  Thus this will
1127                  automatically remind us so we can see if there are other
1128                  valid cases we need to revisit.  */
1129               && (sec->owner->flags & DYNAMIC) != 0)
1130             relocation = 0;
1131
1132           else if (h->root.type == bfd_link_hash_defined
1133                    || h->root.type == bfd_link_hash_defweak)
1134             {
1135               /* Here follow the cases where the relocation value must
1136                  be zero (or when further handling is simplified when
1137                  zero).  I can't claim to understand the various
1138                  conditions and they weren't described in the files
1139                  where I copied them from (elf32-m68k.c and
1140                  elf32-i386.c), but let's mention examples of where
1141                  they happen.  FIXME: Perhaps define and use a
1142                  dynamic_symbol_p function like ia64.
1143
1144                  - When creating a shared library, we can have an
1145                  ordinary relocation for a symbol defined in a shared
1146                  library (perhaps the one we create).  We then make
1147                  the relocation value zero, as the value seen now will
1148                  be added into the relocation addend in this shared
1149                  library, but must be handled only at dynamic-link
1150                  time.  FIXME: Not sure this example covers the
1151                  h->elf_link_hash_flags test, though it's there in
1152                  other targets.  */
1153               if (info->shared
1154                   && ((! info->symbolic && h->dynindx != -1)
1155                       || !h->def_regular)
1156                   && (input_section->flags & SEC_ALLOC) != 0
1157                   && (r_type == R_CRIS_8
1158                       || r_type == R_CRIS_16
1159                       || r_type == R_CRIS_32
1160                       || r_type == R_CRIS_8_PCREL
1161                       || r_type == R_CRIS_16_PCREL
1162                       || r_type == R_CRIS_32_PCREL))
1163                 relocation = 0;
1164               else if (!info->relocatable && unresolved_reloc)
1165                 {
1166                   _bfd_error_handler
1167                     (_("%B, section %A: unresolvable relocation %s against symbol `%s'"),
1168                      input_bfd,
1169                      input_section,
1170                      cris_elf_howto_table[r_type].name,
1171                      symname);
1172                   bfd_set_error (bfd_error_bad_value);
1173                   return FALSE;
1174                 }
1175             }
1176         }
1177
1178       if (sec != NULL && elf_discarded_section (sec))
1179         {
1180           /* For relocs against symbols from removed linkonce sections,
1181              or sections discarded by a linker script, we just want the
1182              section contents zeroed.  Avoid any special processing.  */
1183           _bfd_clear_contents (howto, input_bfd, contents + rel->r_offset);
1184           rel->r_info = 0;
1185           rel->r_addend = 0;
1186           continue;
1187         }
1188
1189       if (info->relocatable)
1190         continue;
1191
1192       switch (r_type)
1193         {
1194         case R_CRIS_16_GOTPLT:
1195         case R_CRIS_32_GOTPLT:
1196           /* This is like the case for R_CRIS_32_GOT and R_CRIS_16_GOT,
1197              but we require a PLT, and the PLT handling will take care of
1198              filling in the PLT-specific GOT entry.  For the GOT offset,
1199              calculate it as we do when filling it in for the .got.plt
1200              section.  If we don't have a PLT, punt to GOT handling.  */
1201           if (h != NULL
1202               && ((struct elf_cris_link_hash_entry *) h)->gotplt_offset != 0)
1203             {
1204               asection *sgotplt
1205                 = bfd_get_section_by_name (dynobj, ".got.plt");
1206               bfd_vma got_offset;
1207
1208               BFD_ASSERT (h->dynindx != -1);
1209               BFD_ASSERT (sgotplt != NULL);
1210
1211               got_offset
1212                 = ((struct elf_cris_link_hash_entry *) h)->gotplt_offset;
1213
1214               relocation = got_offset;
1215               break;
1216             }
1217
1218           /* We didn't make a PLT entry for this symbol.  Maybe everything is
1219              folded into the GOT.  Other than folding, this happens when
1220              statically linking PIC code, or when using -Bsymbolic.  Check
1221              that we instead have a GOT entry as done for us by
1222              elf_cris_adjust_dynamic_symbol, and drop through into the
1223              ordinary GOT cases.  This must not happen for the
1224              executable, because any reference it does to a function
1225              that is satisfied by a DSO must generate a PLT.  We assume
1226              these call-specific relocs don't address non-functions.  */
1227           if (h != NULL
1228               && (h->got.offset == (bfd_vma) -1
1229                   || (!info->shared
1230                       && !(h->def_regular
1231                            || (!h->def_dynamic
1232                                && h->root.type == bfd_link_hash_undefweak)))))
1233             {
1234               (*_bfd_error_handler)
1235                 ((h->got.offset == (bfd_vma) -1)
1236                  ? _("%B, section %A: No PLT nor GOT for relocation %s"
1237                      " against symbol `%s'")
1238                  : _("%B, section %A: No PLT for relocation %s"
1239                      " against symbol `%s'"),
1240                  input_bfd,
1241                  input_section,
1242                  cris_elf_howto_table[r_type].name,
1243                  (symname != NULL && symname[0] != '\0'
1244                   ? symname : _("[whose name is lost]")));
1245
1246               /* FIXME: Perhaps blaming input is not the right thing to
1247                  do; this is probably an internal error.  But it is true
1248                  that we didn't like that particular input.  */
1249               bfd_set_error (bfd_error_bad_value);
1250               return FALSE;
1251             }
1252           /* Fall through.  */
1253
1254           /* The size of the actual relocation is not used here; we only
1255              fill in the GOT table here.  */
1256         case R_CRIS_16_GOT:
1257         case R_CRIS_32_GOT:
1258           {
1259             bfd_vma off;
1260
1261             /* Note that despite using RELA relocations, the .got contents
1262                is always filled in with the link-relative relocation
1263                value; the addend.  */
1264
1265             if (h != NULL)
1266               {
1267                 off = h->got.offset;
1268                 BFD_ASSERT (off != (bfd_vma) -1);
1269
1270                 if (!elf_hash_table (info)->dynamic_sections_created
1271                     || (! info->shared
1272                         && (h->def_regular
1273                             || h->type == STT_FUNC
1274                             || h->needs_plt))
1275                     || (info->shared
1276                         && (info->symbolic || h->dynindx == -1)
1277                         && h->def_regular))
1278                   {
1279                     /* This wasn't checked above for ! info->shared, but
1280                        must hold there if we get here; the symbol must
1281                        be defined in the regular program or be undefweak
1282                        or be a function or otherwise need a PLT.  */
1283                     BFD_ASSERT (!elf_hash_table (info)->dynamic_sections_created
1284                                 || info->shared
1285                                 || h->def_regular
1286                                 || h->type == STT_FUNC
1287                                 || h->needs_plt
1288                                 || h->root.type == bfd_link_hash_undefweak);
1289
1290                     /* This is actually a static link, or it is a
1291                        -Bsymbolic link and the symbol is defined locally,
1292                        or is undefweak, or the symbol was forced to be
1293                        local because of a version file, or we're not
1294                        creating a dynamic object.  We must initialize this
1295                        entry in the global offset table.  Since the offset
1296                        must always be a multiple of 4, we use the least
1297                        significant bit to record whether we have
1298                        initialized it already.
1299
1300                        If this GOT entry should be runtime-initialized, we
1301                        will create a .rela.got relocation entry to
1302                        initialize the value.  This is done in the
1303                        finish_dynamic_symbol routine.  */
1304                     if ((off & 1) != 0)
1305                       off &= ~1;
1306                     else
1307                       {
1308                         bfd_put_32 (output_bfd, relocation,
1309                                     sgot->contents + off);
1310                         h->got.offset |= 1;
1311                       }
1312                   }
1313               }
1314             else
1315               {
1316                 BFD_ASSERT (local_got_offsets != NULL
1317                             && local_got_offsets[r_symndx] != (bfd_vma) -1);
1318
1319                 off = local_got_offsets[r_symndx];
1320
1321                 /* The offset must always be a multiple of 4.  We use
1322                    the least significant bit to record whether we have
1323                    already generated the necessary reloc.  */
1324                 if ((off & 1) != 0)
1325                   off &= ~1;
1326                 else
1327                   {
1328                     bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1329
1330                     if (info->shared)
1331                       {
1332                         Elf_Internal_Rela outrel;
1333                         bfd_byte *loc;
1334
1335                         if (srelgot == NULL)
1336                           srelgot
1337                             = bfd_get_section_by_name (dynobj, ".rela.got");
1338                         BFD_ASSERT (srelgot != NULL);
1339
1340                         outrel.r_offset = (sgot->output_section->vma
1341                                            + sgot->output_offset
1342                                            + off);
1343                         outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1344                         outrel.r_addend = relocation;
1345                         loc = srelgot->contents;
1346                         loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1347                         bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1348                       }
1349
1350                     local_got_offsets[r_symndx] |= 1;
1351                   }
1352               }
1353
1354             relocation = sgot->output_offset + off;
1355             if (rel->r_addend != 0)
1356               {
1357                 /* We can't do anything for a relocation which is against
1358                    a symbol *plus offset*.  GOT holds relocations for
1359                    symbols.  Make this an error; the compiler isn't
1360                    allowed to pass us these kinds of things.  */
1361                 if (h == NULL)
1362                   (*_bfd_error_handler)
1363                     (_("%B, section %A: relocation %s with non-zero addend %d"
1364                        " against local symbol"),
1365                      input_bfd,
1366                      input_section,
1367                      cris_elf_howto_table[r_type].name,
1368                      rel->r_addend);
1369                 else
1370                   (*_bfd_error_handler)
1371                     (_("%B, section %A: relocation %s with non-zero addend %d"
1372                        " against symbol `%s'"),
1373                      input_bfd,
1374                      input_section,
1375                      cris_elf_howto_table[r_type].name,
1376                      rel->r_addend,
1377                      symname[0] != '\0' ? symname : _("[whose name is lost]"));
1378
1379                 bfd_set_error (bfd_error_bad_value);
1380                 return FALSE;
1381               }
1382           }
1383           break;
1384
1385         case R_CRIS_32_GOTREL:
1386           /* This relocation must only be performed against local symbols.
1387              It's also ok when we link a program and the symbol is either
1388              defined in an ordinary (non-DSO) object or is undefined weak.  */
1389           if (h != NULL
1390               && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1391               && !(!info->shared
1392                    && (h->def_regular
1393                        || (!h->def_dynamic
1394                            && h->root.type == bfd_link_hash_undefweak))))
1395             {
1396               (*_bfd_error_handler)
1397                 (_("%B, section %A: relocation %s is"
1398                    " not allowed for global symbol: `%s'"),
1399                  input_bfd,
1400                  input_section,
1401                  cris_elf_howto_table[r_type].name,
1402                  symname);
1403               bfd_set_error (bfd_error_bad_value);
1404               return FALSE;
1405             }
1406
1407           /* This can happen if we get a link error with the input ELF
1408              variant mismatching the output variant.  Emit an error so
1409              it's noticed if it happens elsewhere.  */
1410           if (sgot == NULL)
1411             {
1412               (*_bfd_error_handler)
1413                 (_("%B, section %A: relocation %s with no GOT created"),
1414                  input_bfd,
1415                  input_section,
1416                  cris_elf_howto_table[r_type].name);
1417               bfd_set_error (bfd_error_bad_value);
1418               return FALSE;
1419             }
1420
1421           /* This relocation is like a PC-relative one, except the
1422              reference point is the location of GOT.  Note that
1423              sgot->output_offset is not involved in this calculation.  We
1424              always want the start of entire .got section, not the
1425              position after the reserved header.  */
1426           relocation -= sgot->output_section->vma;
1427           break;
1428
1429         case R_CRIS_32_PLT_PCREL:
1430           /* Relocation is to the entry for this symbol in the
1431              procedure linkage table.  */
1432
1433           /* Resolve a PLT_PCREL reloc against a local symbol directly,
1434              without using the procedure linkage table.  */
1435           if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1436             break;
1437
1438           if (h->plt.offset == (bfd_vma) -1
1439               || splt == NULL)
1440             {
1441               /* We didn't make a PLT entry for this symbol.  This
1442                  happens when statically linking PIC code, or when
1443                  using -Bsymbolic.  */
1444               break;
1445             }
1446
1447           relocation = (splt->output_section->vma
1448                         + splt->output_offset
1449                         + h->plt.offset);
1450           break;
1451
1452         case R_CRIS_32_PLT_GOTREL:
1453           /* Like R_CRIS_32_PLT_PCREL, but the reference point is the
1454              start of the .got section.  See also comment at
1455              R_CRIS_32_GOT.  */
1456           relocation -= sgot->output_section->vma;
1457
1458           /* Resolve a PLT_GOTREL reloc against a local symbol directly,
1459              without using the procedure linkage table.  */
1460           if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
1461             break;
1462
1463           if (h->plt.offset == (bfd_vma) -1
1464               || splt == NULL)
1465             {
1466               /* We didn't make a PLT entry for this symbol.  This
1467                  happens when statically linking PIC code, or when
1468                  using -Bsymbolic.  */
1469               break;
1470             }
1471
1472           relocation = (splt->output_section->vma
1473                         + splt->output_offset
1474                         + h->plt.offset
1475                         - sgot->output_section->vma);
1476           break;
1477
1478         case R_CRIS_8_PCREL:
1479         case R_CRIS_16_PCREL:
1480         case R_CRIS_32_PCREL:
1481           /* If the symbol was local, we need no shlib-specific handling.  */
1482           if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT
1483               || h->dynindx == -1)
1484             break;
1485
1486           /* Fall through.  */
1487         case R_CRIS_8:
1488         case R_CRIS_16:
1489         case R_CRIS_32:
1490           if (info->shared
1491               && r_symndx != 0
1492               && (input_section->flags & SEC_ALLOC) != 0
1493               && ((r_type != R_CRIS_8_PCREL
1494                    && r_type != R_CRIS_16_PCREL
1495                    && r_type != R_CRIS_32_PCREL)
1496                   || (!info->symbolic
1497                       || (h != NULL && !h->def_regular))))
1498             {
1499               Elf_Internal_Rela outrel;
1500               bfd_byte *loc;
1501               bfd_boolean skip, relocate;
1502
1503               /* When generating a shared object, these relocations
1504                  are copied into the output file to be resolved at run
1505                  time.  */
1506
1507               if (sreloc == NULL)
1508                 {
1509                   sreloc = _bfd_elf_get_dynamic_reloc_section
1510                     (input_bfd, input_section, /*rela?*/ TRUE);
1511                   /* The section should have been created in cris_elf_check_relocs,
1512                      but that function will not be called for objects which fail in
1513                      cris_elf_merge_private_bfd_data.  */
1514                   if (sreloc == NULL)
1515                     {
1516                       bfd_set_error (bfd_error_bad_value);
1517                       return FALSE;
1518                     }
1519                 }
1520
1521               skip = FALSE;
1522               relocate = FALSE;
1523
1524               outrel.r_offset =
1525                 _bfd_elf_section_offset (output_bfd, info, input_section,
1526                                          rel->r_offset);
1527               if (outrel.r_offset == (bfd_vma) -1)
1528                 skip = TRUE;
1529               else if (outrel.r_offset == (bfd_vma) -2)
1530                 skip = TRUE, relocate = TRUE;
1531               outrel.r_offset += (input_section->output_section->vma
1532                                   + input_section->output_offset);
1533
1534               if (skip)
1535                 memset (&outrel, 0, sizeof outrel);
1536               /* h->dynindx may be -1 if the symbol was marked to
1537                  become local.  */
1538               else if (h != NULL
1539                        && ((! info->symbolic && h->dynindx != -1)
1540                            || !h->def_regular))
1541                 {
1542                   BFD_ASSERT (h->dynindx != -1);
1543                   outrel.r_info = ELF32_R_INFO (h->dynindx, r_type);
1544                   outrel.r_addend = relocation + rel->r_addend;
1545                 }
1546               else
1547                 {
1548                   outrel.r_addend = relocation + rel->r_addend;
1549
1550                   if (r_type == R_CRIS_32)
1551                     {
1552                       relocate = TRUE;
1553                       outrel.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
1554                     }
1555                   else
1556                     {
1557                       long indx;
1558
1559                       if (bfd_is_abs_section (sec))
1560                         indx = 0;
1561                       else if (sec == NULL || sec->owner == NULL)
1562                         {
1563                           bfd_set_error (bfd_error_bad_value);
1564                           return FALSE;
1565                         }
1566                       else
1567                         {
1568                           asection *osec;
1569
1570                           /* We are turning this relocation into one
1571                              against a section symbol.  It would be
1572                              proper to subtract the symbol's value,
1573                              osec->vma, from the emitted reloc addend,
1574                              but ld.so expects buggy relocs.  */
1575                           osec = sec->output_section;
1576                           indx = elf_section_data (osec)->dynindx;
1577                           if (indx == 0)
1578                             {
1579                               struct elf_cris_link_hash_table *htab;
1580                               htab = elf_cris_hash_table (info);
1581                               osec = htab->root.text_index_section;
1582                               indx = elf_section_data (osec)->dynindx;
1583                             }
1584                           BFD_ASSERT (indx != 0);
1585                         }
1586
1587                       outrel.r_info = ELF32_R_INFO (indx, r_type);
1588                     }
1589                 }
1590
1591               loc = sreloc->contents;
1592               loc += sreloc->reloc_count++ * sizeof (Elf32_External_Rela);
1593               bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1594
1595               /* This reloc will be computed at runtime, so there's no
1596                  need to do anything now, except for R_CRIS_32 relocations
1597                  that have been turned into R_CRIS_RELATIVE.  */
1598               if (!relocate)
1599                 continue;
1600             }
1601
1602           break;
1603
1604         case R_CRIS_16_DTPREL:
1605         case R_CRIS_32_DTPREL:
1606           /* This relocation must only be performed against local
1607              symbols.  It's also ok when we link a program and the
1608              symbol is defined in an ordinary (non-DSO) object (if
1609              it's undefined there, we've already seen an error).  */
1610           if (h != NULL
1611               && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1612               && (info->shared
1613                   || (!h->def_regular
1614                       && h->root.type != bfd_link_hash_undefined)))
1615             {
1616               (*_bfd_error_handler)
1617                 ((h->root.type == bfd_link_hash_undefined)
1618                  /* We shouldn't get here for GCC-emitted code.  */
1619                  ? _("%B, section %A: relocation %s has an undefined"
1620                      " reference to `%s', perhaps a declaration mixup?")
1621                  : ("%B, section %A: relocation %s is"
1622                      " not allowed for `%s', a global symbol with default"
1623                      " visibility, perhaps a declaration mixup?"),
1624                  input_bfd,
1625                  input_section,
1626                  cris_elf_howto_table[r_type].name,
1627                  symname != NULL && symname[0] != '\0'
1628                  ? symname : _("[whose name is lost]"));
1629               bfd_set_error (bfd_error_bad_value);
1630               return FALSE;
1631             }
1632
1633           BFD_ASSERT (elf_cris_hash_table (info)->dtpmod_refcount != 0);
1634
1635           /* Fill in a R_CRIS_DTPMOD reloc at offset 3 if we haven't
1636              already done so.  Note that we do this in .got.plt, not
1637              in .got, as .got.plt contains the first part, still the
1638              reloc is against .got, because the linker script directs
1639              (is required to direct) them both into .got.  */
1640           if (elf_cris_hash_table (info)->dtpmod_refcount > 0)
1641             {
1642               asection *sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
1643               BFD_ASSERT (sgotplt != NULL);
1644
1645               if (info->shared)
1646                 {
1647                   Elf_Internal_Rela outrel;
1648                   bfd_byte *loc;
1649
1650                   if (srelgot == NULL)
1651                     srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1652                   BFD_ASSERT (srelgot != NULL);
1653                   loc = srelgot->contents;
1654                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1655
1656                   bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 12);
1657                   bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16);
1658                   outrel.r_offset = (sgotplt->output_section->vma
1659                                      + sgotplt->output_offset
1660                                      + 12);
1661                   outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTPMOD);
1662                   outrel.r_addend = 0;
1663                   bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1664                 }
1665               else
1666                 {
1667                   /* For an executable, the GOT entry contents is known.  */
1668                   bfd_put_32 (output_bfd, (bfd_vma) 1, sgotplt->contents + 12);
1669                   bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16);
1670                 }
1671
1672               /* Reverse the sign to mark that we've emitted the
1673                  required GOT entry.  */
1674               elf_cris_hash_table (info)->dtpmod_refcount
1675                 = -elf_cris_hash_table (info)->dtpmod_refcount;
1676             }
1677
1678           /* The thread-based offset to the local symbol is the
1679              relocation.  */
1680           relocation -= elf_hash_table (info)->tls_sec == NULL
1681             ? 0 : elf_hash_table (info)->tls_sec->vma;
1682           break;
1683
1684         case R_CRIS_32_GD:
1685           if (info->shared)
1686             {
1687               bfd_set_error (bfd_error_invalid_operation);
1688
1689               /* We've already informed in cris_elf_check_relocs that
1690                  this is an error.  */
1691               return FALSE;
1692             }
1693           /* Fall through.  */
1694
1695         case R_CRIS_16_GOT_GD:
1696         case R_CRIS_32_GOT_GD:
1697           if (rel->r_addend != 0)
1698             {
1699               /* We can't do anything for a relocation which is against a
1700                  symbol *plus offset*.  The GOT holds relocations for
1701                  symbols.  Make this an error; the compiler isn't allowed
1702                  to pass us these kinds of things.  */
1703               (*_bfd_error_handler)
1704                 (_("%B, section %A: relocation %s with non-zero addend %d"
1705                    " against symbol `%s'"),
1706                  input_bfd,
1707                  input_section,
1708                  cris_elf_howto_table[r_type].name,
1709                  rel->r_addend,
1710                  symname[0] != '\0' ? symname : _("[whose name is lost]"));
1711
1712               bfd_set_error (bfd_error_bad_value);
1713               return FALSE;
1714             }
1715
1716           if (!info->shared && (h == NULL || h->def_regular))
1717             {
1718               /* Known contents of the GOT.  */
1719               bfd_vma off;
1720
1721               /* The symbol is defined in the program, so just write
1722                  (1, known_tpoffset) into the GOT.  */
1723               relocation -= elf_hash_table (info)->tls_sec->vma;
1724
1725               if (h != NULL)
1726                 {
1727                   off = elf_cris_hash_entry (h)->tprel_refcount > 0
1728                     ? h->got.offset + 4 : h->got.offset;
1729                 }
1730               else
1731                 {
1732                   off = local_got_offsets[r_symndx];
1733                   if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)])
1734                     off += 4;
1735                 }
1736
1737               /* We use bit 1 of the offset as a flag for GOT entry with
1738                  the R_CRIS_DTP reloc, setting it when we've emitted the
1739                  GOT entry and reloc.  Bit 0 is used for R_CRIS_32_TPREL
1740                  relocs.  */
1741               if ((off & 2) == 0)
1742                 {
1743                   off &= ~3;
1744
1745                   if (h != NULL)
1746                     h->got.offset |= 2;
1747                   else
1748                     local_got_offsets[r_symndx] |= 2;
1749
1750                   bfd_put_32 (output_bfd, 1, sgot->contents + off);
1751                   bfd_put_32 (output_bfd, relocation, sgot->contents + off + 4);
1752                 }
1753               else
1754                 off &= ~3;
1755
1756               relocation = sgot->output_offset + off
1757                 + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0);
1758             }
1759           else
1760             {
1761               /* Not all parts of the GOT entry are known; emit a real
1762                  relocation.  */
1763               bfd_vma off;
1764
1765               if (h != NULL)
1766                 off = elf_cris_hash_entry (h)->tprel_refcount > 0
1767                   ? h->got.offset + 4 : h->got.offset;
1768               else
1769                 {
1770                   off = local_got_offsets[r_symndx];
1771                   if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)])
1772                     off += 4;
1773                 }
1774
1775               /* See above re bit 1 and bit 0 usage.  */
1776               if ((off & 2) == 0)
1777                 {
1778                   Elf_Internal_Rela outrel;
1779                   bfd_byte *loc;
1780
1781                   off &= ~3;
1782
1783                   if (h != NULL)
1784                     h->got.offset |= 2;
1785                   else
1786                     local_got_offsets[r_symndx] |= 2;
1787
1788                   /* Clear the target contents of the GOT (just as a
1789                      gesture; it's already cleared on allocation): this
1790                      relocation is not like the other dynrelocs.  */
1791                   bfd_put_32 (output_bfd, 0, sgot->contents + off);
1792                   bfd_put_32 (output_bfd, 0, sgot->contents + off + 4);
1793
1794                   if (srelgot == NULL)
1795                     srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1796                   BFD_ASSERT (srelgot != NULL);
1797
1798                   if (h != NULL && h->dynindx != -1)
1799                     {
1800                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_DTP);
1801                       relocation = 0;
1802                     }
1803                   else
1804                     {
1805                       outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTP);
1806
1807                       /* NULL if we had an error.  */
1808                       relocation -= elf_hash_table (info)->tls_sec == NULL
1809                         ? 0 : elf_hash_table (info)->tls_sec->vma;
1810                     }
1811
1812                   outrel.r_offset = (sgot->output_section->vma
1813                                      + sgot->output_offset
1814                                      + off);
1815                   outrel.r_addend = relocation;
1816                   loc = srelgot->contents;
1817                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1818
1819                   /* NULL if we had an error.  */
1820                   if (srelgot->contents != NULL)
1821                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1822                 }
1823               else
1824                 off &= ~3;
1825
1826               relocation = sgot->output_offset + off
1827                 + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0);
1828             }
1829
1830           /* The GOT-relative offset to the GOT entry is the
1831              relocation, or for R_CRIS_32_GD, the actual address of
1832              the GOT entry.  */
1833           break;
1834
1835         case R_CRIS_32_GOT_TPREL:
1836         case R_CRIS_16_GOT_TPREL:
1837           if (rel->r_addend != 0)
1838             {
1839               /* We can't do anything for a relocation which is
1840                  against a symbol *plus offset*.  GOT holds
1841                  relocations for symbols.  Make this an error; the
1842                  compiler isn't allowed to pass us these kinds of
1843                  things.  */
1844               (*_bfd_error_handler)
1845                 (_("%B, section %A: relocation %s with non-zero addend %d"
1846                    " against symbol `%s'"),
1847                  input_bfd,
1848                  input_section,
1849                  cris_elf_howto_table[r_type].name,
1850                  rel->r_addend,
1851                  symname[0] != '\0' ? symname : _("[whose name is lost]"));
1852               bfd_set_error (bfd_error_bad_value);
1853               return FALSE;
1854             }
1855
1856           if (!info->shared && (h == NULL || h->def_regular))
1857             {
1858               /* Known contents of the GOT.  */
1859               bfd_vma off;
1860
1861               /* The symbol is defined in the program, so just write
1862                  the known_tpoffset into the GOT.  */
1863               relocation -= elf_hash_table (info)->tls_sec->vma;
1864
1865               if (h != NULL)
1866                 off = h->got.offset;
1867               else
1868                 off = local_got_offsets[r_symndx];
1869
1870               /* Bit 0 is used to mark whether we've emitted the required
1871                  entry (and if needed R_CRIS_32_TPREL reloc).  Bit 1
1872                  is used similarly for R_CRIS_DTP, see above.  */
1873               if ((off & 1) == 0)
1874                 {
1875                   off &= ~3;
1876
1877                   if (h != NULL)
1878                     h->got.offset |= 1;
1879                   else
1880                     local_got_offsets[r_symndx] |= 1;
1881
1882                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1883                 }
1884               else
1885                 off &= ~3;
1886
1887               relocation = sgot->output_offset + off;
1888             }
1889           else
1890             {
1891               /* Emit a real relocation.  */
1892               bfd_vma off;
1893
1894               if (h != NULL)
1895                 off = h->got.offset;
1896               else
1897                 off = local_got_offsets[r_symndx];
1898
1899               /* See above re usage of bit 0 and 1.  */
1900               if ((off & 1) == 0)
1901                 {
1902                   Elf_Internal_Rela outrel;
1903                   bfd_byte *loc;
1904
1905                   off &= ~3;
1906
1907                   if (h != NULL)
1908                     h->got.offset |= 1;
1909                   else
1910                     local_got_offsets[r_symndx] |= 1;
1911
1912                   if (srelgot == NULL)
1913                     srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
1914                   BFD_ASSERT (srelgot != NULL);
1915
1916                   if (h != NULL && h->dynindx != -1)
1917                     {
1918                       outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_32_TPREL);
1919                       relocation = 0;
1920                     }
1921                   else
1922                     {
1923                       outrel.r_info = ELF32_R_INFO (0, R_CRIS_32_TPREL);
1924
1925                       /* NULL if we had an error.  */
1926                       relocation -= elf_hash_table (info)->tls_sec == NULL
1927                         ? 0 : elf_hash_table (info)->tls_sec->vma;
1928                     }
1929
1930                   /* Just "define" the initial contents in some
1931                      semi-logical way.  */
1932                   bfd_put_32 (output_bfd, relocation, sgot->contents + off);
1933
1934                   outrel.r_offset = (sgot->output_section->vma
1935                                      + sgot->output_offset
1936                                      + off);
1937                   outrel.r_addend = relocation;
1938                   loc = srelgot->contents;
1939                   loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);
1940                   /* NULL if we had an error.  */
1941                   if (srelgot->contents != NULL)
1942                     bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);
1943                 }
1944               else
1945                 off &= ~3;
1946
1947               relocation = sgot->output_offset + off;
1948             }
1949
1950           /* The GOT-relative offset to the GOT entry is the relocation.  */
1951           break;
1952
1953         case R_CRIS_16_TPREL:
1954         case R_CRIS_32_TPREL:
1955           /* This relocation must only be performed against symbols
1956              defined in an ordinary (non-DSO) object.  */
1957           if (info->shared)
1958             {
1959               bfd_set_error (bfd_error_invalid_operation);
1960
1961               /* We've already informed in cris_elf_check_relocs that
1962                  this is an error.  */
1963               return FALSE;
1964             }
1965
1966           if (h != NULL
1967               && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
1968               && !h->def_regular
1969               /* If it's undefined, then an error message has already
1970                  been emitted.  */
1971               && h->root.type != bfd_link_hash_undefined)
1972             {
1973               (*_bfd_error_handler)
1974                 (_("%B, section %A: relocation %s is"
1975                    " not allowed for symbol: `%s'"
1976                    " which is defined outside the program,"
1977                    " perhaps a declaration mixup?"),
1978                  input_bfd,
1979                  input_section,
1980                  cris_elf_howto_table[r_type].name,
1981                  symname);
1982               bfd_set_error (bfd_error_bad_value);
1983               return FALSE;
1984             }
1985
1986           /* NULL if we had an error.  */
1987           relocation -= elf_hash_table (info)->tls_sec == NULL
1988             ? 0 : elf_hash_table (info)->tls_sec->vma;
1989
1990           /* The TLS-relative offset is the relocation.  */
1991           break;
1992
1993         default:
1994           BFD_FAIL ();
1995           return FALSE;
1996         }
1997
1998       r = cris_final_link_relocate (howto, input_bfd, input_section,
1999                                      contents, rel, relocation);
2000
2001       if (r != bfd_reloc_ok)
2002         {
2003           const char * msg = (const char *) NULL;
2004
2005           switch (r)
2006             {
2007             case bfd_reloc_overflow:
2008               r = info->callbacks->reloc_overflow
2009                 (info, (h ? &h->root : NULL), symname, howto->name,
2010                  (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
2011               if (additional_relocation_error_msg_count > 0)
2012                 {
2013                   additional_relocation_error_msg_count--;
2014                   switch (r_type)
2015                     {
2016                     case R_CRIS_16_GOTPLT:
2017                     case R_CRIS_16_GOT:
2018
2019                       /* Not just TLS is involved here, so we make
2020                          generation and message depend on -fPIC/-fpic
2021                          only.  */
2022                     case R_CRIS_16_GOT_TPREL:
2023                     case R_CRIS_16_GOT_GD:
2024                       (*_bfd_error_handler)
2025                         (_("(too many global variables for -fpic:"
2026                            " recompile with -fPIC)"));
2027                       break;
2028
2029                     case R_CRIS_16_TPREL:
2030                     case R_CRIS_16_DTPREL:
2031                       (*_bfd_error_handler)
2032                         (_("(thread-local data too big for -fpic or"
2033                            " -msmall-tls: recompile with -fPIC or"
2034                            " -mno-small-tls)"));
2035                       break;
2036
2037                       /* No known cause for overflow for other relocs.  */
2038                     default:
2039                       break;
2040                     }
2041                 }
2042               break;
2043
2044             case bfd_reloc_undefined:
2045               r = info->callbacks->undefined_symbol
2046                 (info, symname, input_bfd, input_section, rel->r_offset,
2047                  TRUE);
2048               break;
2049
2050             case bfd_reloc_outofrange:
2051               msg = _("internal error: out of range error");
2052               break;
2053
2054             case bfd_reloc_notsupported:
2055               msg = _("internal error: unsupported relocation error");
2056               break;
2057
2058             case bfd_reloc_dangerous:
2059               msg = _("internal error: dangerous relocation");
2060               break;
2061
2062             default:
2063               msg = _("internal error: unknown error");
2064               break;
2065             }
2066
2067           if (msg)
2068             r = info->callbacks->warning
2069               (info, msg, symname, input_bfd, input_section, rel->r_offset);
2070
2071           if (! r)
2072             return FALSE;
2073         }
2074     }
2075
2076   return TRUE;
2077 }
2078 \f
2079 /* Finish up dynamic symbol handling.  We set the contents of various
2080    dynamic sections here.  */
2081
2082 static bfd_boolean
2083 elf_cris_finish_dynamic_symbol (output_bfd, info, h, sym)
2084      bfd *output_bfd;
2085      struct bfd_link_info *info;
2086      struct elf_link_hash_entry *h;
2087      Elf_Internal_Sym *sym;
2088 {
2089   bfd *dynobj;
2090
2091   /* Where in the plt entry to put values.  */
2092   int plt_off1 = 2, plt_off2 = 10, plt_off3 = 16;
2093
2094   /* What offset to add to the distance to the first PLT entry for the
2095      value at plt_off3.   */
2096   int plt_off3_value_bias = 4;
2097
2098   /* Where in the PLT entry the call-dynlink-stub is (happens to be same
2099      for PIC and non-PIC for v32 and pre-v32).  */
2100   int plt_stub_offset = 8;
2101   int plt_entry_size = PLT_ENTRY_SIZE;
2102   const bfd_byte *plt_entry = elf_cris_plt_entry;
2103   const bfd_byte *plt_pic_entry = elf_cris_pic_plt_entry;
2104
2105   /* Adjust the various PLT entry offsets.  */
2106   if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
2107     {
2108       plt_off2 = 14;
2109       plt_off3 = 20;
2110       plt_off3_value_bias = -2;
2111       plt_stub_offset = 12;
2112       plt_entry_size = PLT_ENTRY_SIZE_V32;
2113       plt_entry = elf_cris_plt_entry_v32;
2114       plt_pic_entry = elf_cris_pic_plt_entry_v32;
2115     }
2116
2117   dynobj = elf_hash_table (info)->dynobj;
2118
2119   if (h->plt.offset != (bfd_vma) -1)
2120     {
2121       asection *splt;
2122       asection *sgotplt;
2123       asection *sgot;
2124       asection *srela;
2125       bfd_vma got_base;
2126
2127       bfd_vma gotplt_offset
2128         = elf_cris_hash_entry (h)->gotplt_offset;
2129       Elf_Internal_Rela rela;
2130       bfd_byte *loc;
2131       bfd_boolean has_gotplt = gotplt_offset != 0;
2132
2133       /* Get the index in the procedure linkage table which
2134          corresponds to this symbol.  This is the index of this symbol
2135          in all the symbols for which we are making plt entries.  The
2136          first entry in the procedure linkage table is reserved.  */
2137       /* We have to count backwards here, and the result is only valid as
2138          an index into .got.plt and its relocations.  FIXME: Constants...  */
2139       bfd_vma gotplt_index = gotplt_offset/4 - 3;
2140
2141       /* Get the offset into the .got table of the entry that corresponds
2142          to this function.  Note that we embed knowledge that "incoming"
2143          .got goes after .got.plt in the output without padding (pointer
2144          aligned).  However, that knowledge is present in several other
2145          places too.  */
2146       bfd_vma got_offset
2147         = (has_gotplt
2148            ? gotplt_offset
2149            : h->got.offset + elf_cris_hash_table(info)->next_gotplt_entry);
2150
2151       /* This symbol has an entry in the procedure linkage table.  Set it
2152          up.  */
2153
2154       BFD_ASSERT (h->dynindx != -1);
2155
2156       splt = bfd_get_section_by_name (dynobj, ".plt");
2157       sgot = bfd_get_section_by_name (dynobj, ".got");
2158       sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");
2159       srela = bfd_get_section_by_name (dynobj, ".rela.plt");
2160       BFD_ASSERT (splt != NULL && sgotplt != NULL
2161                   && (! has_gotplt || srela != NULL));
2162
2163       got_base = sgotplt->output_section->vma + sgotplt->output_offset;
2164
2165       /* Fill in the entry in the procedure linkage table.  */
2166       if (! info->shared)
2167         {
2168           memcpy (splt->contents + h->plt.offset, plt_entry,
2169                   plt_entry_size);
2170
2171           /* We need to enter the absolute address of the GOT entry here.  */
2172           bfd_put_32 (output_bfd, got_base + got_offset,
2173                       splt->contents + h->plt.offset + plt_off1);
2174         }
2175       else
2176         {
2177           memcpy (splt->contents + h->plt.offset, plt_pic_entry,
2178                   plt_entry_size);
2179           bfd_put_32 (output_bfd, got_offset,
2180                       splt->contents + h->plt.offset + plt_off1);
2181         }
2182
2183       /* Fill in the plt entry and make a relocation, if this is a "real"
2184          PLT entry.  */
2185       if (has_gotplt)
2186         {
2187           /* Fill in the offset to the reloc table.  */
2188           bfd_put_32 (output_bfd,
2189                       gotplt_index * sizeof (Elf32_External_Rela),
2190                       splt->contents + h->plt.offset + plt_off2);
2191
2192           /* Fill in the offset to the first PLT entry, where to "jump".  */
2193           bfd_put_32 (output_bfd,
2194                       - (h->plt.offset + plt_off3 + plt_off3_value_bias),
2195                       splt->contents + h->plt.offset + plt_off3);
2196
2197           /* Fill in the entry in the global offset table with the address of
2198              the relocating stub.  */
2199           bfd_put_32 (output_bfd,
2200                       (splt->output_section->vma
2201                        + splt->output_offset
2202                        + h->plt.offset
2203                        + plt_stub_offset),
2204                       sgotplt->contents + got_offset);
2205
2206           /* Fill in the entry in the .rela.plt section.  */
2207           rela.r_offset = (sgotplt->output_section->vma
2208                            + sgotplt->output_offset
2209                            + got_offset);
2210           rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_JUMP_SLOT);
2211           rela.r_addend = 0;
2212           loc = srela->contents + gotplt_index * sizeof (Elf32_External_Rela);
2213           bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2214         }
2215
2216       if (!h->def_regular)
2217         {
2218           /* Mark the symbol as undefined, rather than as defined in
2219              the .plt section.  Leave the value alone.  */
2220           sym->st_shndx = SHN_UNDEF;
2221
2222           /* FIXME: From elf32-sparc.c 2001-02-19 (1.18).  I still don't
2223              know whether resetting the value is significant; if it really
2224              is, rather than a quirk or bug in the sparc port, then I
2225              believe we'd see this elsewhere.  */
2226           /* If the symbol is weak, we do need to clear the value.
2227              Otherwise, the PLT entry would provide a definition for
2228              the symbol even if the symbol wasn't defined anywhere,
2229              and so the symbol would never be NULL.  */
2230           if (!h->ref_regular_nonweak)
2231             sym->st_value = 0;
2232         }
2233     }
2234
2235   /* For an ordinary program, we emit .got relocs only for symbols that
2236      are in the dynamic-symbols table and are either defined by the
2237      program or are undefined weak symbols, or are function symbols
2238      where we do not output a PLT: the PLT reloc was output above and all
2239      references to the function symbol are redirected to the PLT.  */
2240   if (h->got.offset != (bfd_vma) -1
2241       && (elf_cris_hash_entry (h)->reg_got_refcount > 0)
2242       && (info->shared
2243           || (h->dynindx != -1
2244               && h->plt.offset == (bfd_vma) -1
2245               && !h->def_regular
2246               && h->root.type != bfd_link_hash_undefweak)))
2247     {
2248       asection *sgot;
2249       asection *srela;
2250       Elf_Internal_Rela rela;
2251       bfd_byte *loc;
2252       bfd_byte *where;
2253
2254       /* This symbol has an entry in the global offset table.  Set it up.  */
2255
2256       sgot = bfd_get_section_by_name (dynobj, ".got");
2257       srela = bfd_get_section_by_name (dynobj, ".rela.got");
2258       BFD_ASSERT (sgot != NULL && srela != NULL);
2259
2260       rela.r_offset = (sgot->output_section->vma
2261                        + sgot->output_offset
2262                        + (h->got.offset &~ (bfd_vma) 1));
2263
2264       /* If this is a static link, or it is a -Bsymbolic link and the
2265          symbol is defined locally or was forced to be local because
2266          of a version file, we just want to emit a RELATIVE reloc.
2267          The entry in the global offset table will already have been
2268          initialized in the relocate_section function.  */
2269       where = sgot->contents + (h->got.offset &~ (bfd_vma) 1);
2270       if (! elf_hash_table (info)->dynamic_sections_created
2271           || (info->shared
2272               && (info->symbolic || h->dynindx == -1)
2273               && h->def_regular))
2274         {
2275           rela.r_info = ELF32_R_INFO (0, R_CRIS_RELATIVE);
2276           rela.r_addend = bfd_get_signed_32 (output_bfd, where);
2277         }
2278       else
2279         {
2280           bfd_put_32 (output_bfd, (bfd_vma) 0, where);
2281           rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_GLOB_DAT);
2282           rela.r_addend = 0;
2283         }
2284
2285       loc = srela->contents;
2286       loc += srela->reloc_count++ * sizeof (Elf32_External_Rela);
2287       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2288     }
2289
2290   if (h->needs_copy)
2291     {
2292       asection *s;
2293       Elf_Internal_Rela rela;
2294       bfd_byte *loc;
2295
2296       /* This symbol needs a copy reloc.  Set it up.  */
2297
2298       BFD_ASSERT (h->dynindx != -1
2299                   && (h->root.type == bfd_link_hash_defined
2300                       || h->root.type == bfd_link_hash_defweak));
2301
2302       s = bfd_get_section_by_name (h->root.u.def.section->owner,
2303                                    ".rela.bss");
2304       BFD_ASSERT (s != NULL);
2305
2306       rela.r_offset = (h->root.u.def.value
2307                        + h->root.u.def.section->output_section->vma
2308                        + h->root.u.def.section->output_offset);
2309       rela.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_COPY);
2310       rela.r_addend = 0;
2311       loc = s->contents + s->reloc_count++ * sizeof (Elf32_External_Rela);
2312       bfd_elf32_swap_reloca_out (output_bfd, &rela, loc);
2313     }
2314
2315   /* Mark _DYNAMIC and _GLOBAL_OFFSET_TABLE_ as absolute.  */
2316   if (strcmp (h->root.root.string, "_DYNAMIC") == 0
2317       || h == elf_hash_table (info)->hgot)
2318     sym->st_shndx = SHN_ABS;
2319
2320   return TRUE;
2321 }
2322 \f
2323 /* Finish up the dynamic sections.  Do *not* emit relocs here, as their
2324    offsets were changed, as part of -z combreloc handling, from those we
2325    computed.  */
2326
2327 static bfd_boolean
2328 elf_cris_finish_dynamic_sections (output_bfd, info)
2329      bfd *output_bfd;
2330      struct bfd_link_info *info;
2331 {
2332   bfd *dynobj;
2333   asection *sgot;
2334   asection *sdyn;
2335
2336   dynobj = elf_hash_table (info)->dynobj;
2337
2338   sgot = bfd_get_section_by_name (dynobj, ".got.plt");
2339   BFD_ASSERT (sgot != NULL);
2340   sdyn = bfd_get_section_by_name (dynobj, ".dynamic");
2341
2342   if (elf_hash_table (info)->dynamic_sections_created)
2343     {
2344       asection *splt;
2345       Elf32_External_Dyn *dyncon, *dynconend;
2346
2347       splt = bfd_get_section_by_name (dynobj, ".plt");
2348       BFD_ASSERT (splt != NULL && sdyn != NULL);
2349
2350       dyncon = (Elf32_External_Dyn *) sdyn->contents;
2351       dynconend = (Elf32_External_Dyn *) (sdyn->contents + sdyn->size);
2352       for (; dyncon < dynconend; dyncon++)
2353         {
2354           Elf_Internal_Dyn dyn;
2355           asection *s;
2356
2357           bfd_elf32_swap_dyn_in (dynobj, dyncon, &dyn);
2358
2359           switch (dyn.d_tag)
2360             {
2361             default:
2362               break;
2363
2364             case DT_PLTGOT:
2365               s = bfd_get_section_by_name (output_bfd, ".got");
2366               BFD_ASSERT (s != NULL);
2367               dyn.d_un.d_ptr = s->vma;
2368               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2369               break;
2370
2371             case DT_JMPREL:
2372               /* Yes, we *can* have a .plt and no .plt.rela, for instance
2373                  if all symbols are found in the .got (not .got.plt).  */
2374               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2375               dyn.d_un.d_ptr = s != NULL ? s->vma : 0;
2376               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2377               break;
2378
2379             case DT_PLTRELSZ:
2380               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2381               if (s == NULL)
2382                 dyn.d_un.d_val = 0;
2383               else
2384                 dyn.d_un.d_val = s->size;
2385               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2386               break;
2387
2388             case DT_RELASZ:
2389               /* The procedure linkage table relocs (DT_JMPREL) should
2390                  not be included in the overall relocs (DT_RELA).
2391                  Therefore, we override the DT_RELASZ entry here to
2392                  make it not include the JMPREL relocs.  Since the
2393                  linker script arranges for .rela.plt to follow all
2394                  other relocation sections, we don't have to worry
2395                  about changing the DT_RELA entry.  */
2396               s = bfd_get_section_by_name (output_bfd, ".rela.plt");
2397               if (s != NULL)
2398                 dyn.d_un.d_val -= s->size;
2399               bfd_elf32_swap_dyn_out (output_bfd, &dyn, dyncon);
2400               break;
2401             }
2402         }
2403
2404       /* Fill in the first entry in the procedure linkage table.  */
2405       if (splt->size > 0)
2406         {
2407           if (bfd_get_mach (output_bfd) == bfd_mach_cris_v32)
2408             {
2409               if (info->shared)
2410                 memcpy (splt->contents, elf_cris_pic_plt0_entry_v32,
2411                         PLT_ENTRY_SIZE_V32);
2412               else
2413                 {
2414                   memcpy (splt->contents, elf_cris_plt0_entry_v32,
2415                           PLT_ENTRY_SIZE_V32);
2416                   bfd_put_32 (output_bfd,
2417                               sgot->output_section->vma
2418                               + sgot->output_offset + 4,
2419                               splt->contents + 4);
2420
2421                   elf_section_data (splt->output_section)->this_hdr.sh_entsize
2422                     = PLT_ENTRY_SIZE_V32;
2423                 }
2424             }
2425           else
2426             {
2427               if (info->shared)
2428                 memcpy (splt->contents, elf_cris_pic_plt0_entry,
2429                         PLT_ENTRY_SIZE);
2430               else
2431                 {
2432                   memcpy (splt->contents, elf_cris_plt0_entry,
2433                           PLT_ENTRY_SIZE);
2434                   bfd_put_32 (output_bfd,
2435                               sgot->output_section->vma
2436                               + sgot->output_offset + 4,
2437                               splt->contents + 6);
2438                   bfd_put_32 (output_bfd,
2439                               sgot->output_section->vma
2440                               + sgot->output_offset + 8,
2441                               splt->contents + 14);
2442
2443                   elf_section_data (splt->output_section)->this_hdr.sh_entsize
2444                     = PLT_ENTRY_SIZE;
2445                 }
2446             }
2447         }
2448     }
2449
2450   /* Fill in the first three entries in the global offset table.  */
2451   if (sgot->size > 0)
2452     {
2453       if (sdyn == NULL)
2454         bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents);
2455       else
2456         bfd_put_32 (output_bfd,
2457                     sdyn->output_section->vma + sdyn->output_offset,
2458                     sgot->contents);
2459       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 4);
2460       bfd_put_32 (output_bfd, (bfd_vma) 0, sgot->contents + 8);
2461     }
2462
2463   elf_section_data (sgot->output_section)->this_hdr.sh_entsize = 4;
2464
2465   return TRUE;
2466 }
2467 \f
2468 /* Return the section that should be marked against GC for a given
2469    relocation.  */
2470
2471 static asection *
2472 cris_elf_gc_mark_hook (asection *sec,
2473                        struct bfd_link_info *info,
2474                        Elf_Internal_Rela *rel,
2475                        struct elf_link_hash_entry *h,
2476                        Elf_Internal_Sym *sym)
2477 {
2478   enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info);
2479   if (h != NULL)
2480     switch (r_type)
2481       {
2482       case R_CRIS_GNU_VTINHERIT:
2483       case R_CRIS_GNU_VTENTRY:
2484         return NULL;
2485
2486       default:
2487         break;
2488       }
2489
2490   return _bfd_elf_gc_mark_hook (sec, info, rel, h, sym);
2491 }
2492
2493 /* Update the got entry reference counts for the section being removed.  */
2494
2495 static bfd_boolean
2496 cris_elf_gc_sweep_hook (bfd *abfd,
2497                         struct bfd_link_info *info,
2498                         asection *sec,
2499                         const Elf_Internal_Rela *relocs)
2500 {
2501   Elf_Internal_Shdr *symtab_hdr;
2502   struct elf_link_hash_entry **sym_hashes;
2503   bfd_signed_vma *local_got_refcounts;
2504   const Elf_Internal_Rela *rel, *relend;
2505   bfd *dynobj;
2506   asection *sgot;
2507   asection *srelgot;
2508
2509   if (info->relocatable)
2510     return TRUE;
2511
2512   dynobj = elf_hash_table (info)->dynobj;
2513   if (dynobj == NULL)
2514     return TRUE;
2515
2516   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
2517   sym_hashes = elf_sym_hashes (abfd);
2518   local_got_refcounts = elf_local_got_refcounts (abfd);
2519
2520   sgot = bfd_get_section_by_name (dynobj, ".got");
2521   srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2522
2523   relend = relocs + sec->reloc_count;
2524   for (rel = relocs; rel < relend; rel++)
2525     {
2526       unsigned long r_symndx;
2527       struct elf_link_hash_entry *h = NULL;
2528       bfd_signed_vma got_element_size = 4;
2529       bfd_signed_vma *specific_refcount = NULL;
2530       enum elf_cris_reloc_type r_type;
2531
2532       r_symndx = ELF32_R_SYM (rel->r_info);
2533       if (r_symndx >= symtab_hdr->sh_info)
2534         {
2535           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
2536           while (h->root.type == bfd_link_hash_indirect
2537                  || h->root.type == bfd_link_hash_warning)
2538             h = (struct elf_link_hash_entry *) h->root.u.i.link;
2539         }
2540
2541       r_type = ELF32_R_TYPE (rel->r_info);
2542       switch (r_type)
2543         {
2544         case R_CRIS_32_GOT:
2545         case R_CRIS_16_GOT:
2546         case R_CRIS_16_GOTPLT:
2547         case R_CRIS_32_GOTPLT:
2548           specific_refcount = h != NULL
2549             ? &((struct elf_cris_link_hash_entry *) h)->reg_got_refcount
2550             : &local_got_refcounts[LGOT_REG_NDX (r_symndx)];
2551           break;
2552
2553         case R_CRIS_32_GD:
2554         case R_CRIS_32_GOT_GD:
2555         case R_CRIS_16_GOT_GD:
2556           got_element_size = 8;
2557           specific_refcount = h != NULL
2558             ? &((struct elf_cris_link_hash_entry *) h)->dtp_refcount
2559             : &local_got_refcounts[LGOT_DTP_NDX (r_symndx)];
2560           break;
2561
2562         case R_CRIS_16_GOT_TPREL:
2563         case R_CRIS_32_GOT_TPREL:
2564           specific_refcount = h != NULL
2565             ? &((struct elf_cris_link_hash_entry *) h)->tprel_refcount
2566             : &local_got_refcounts[LGOT_TPREL_NDX (r_symndx)];
2567           break;
2568
2569         default:
2570           break;
2571         }
2572
2573       switch (r_type)
2574         {
2575         case R_CRIS_32_GD:
2576         case R_CRIS_16_GOT_TPREL:
2577         case R_CRIS_32_GOT_TPREL:
2578         case R_CRIS_32_GOT_GD:
2579         case R_CRIS_16_GOT_GD:
2580         case R_CRIS_16_GOT:
2581         case R_CRIS_32_GOT:
2582           if (h != NULL)
2583             {
2584               /* If the counters are 0 when we got here, we've
2585                  miscounted somehow somewhere, an internal error.  */
2586               BFD_ASSERT (h->got.refcount > 0);
2587               --h->got.refcount;
2588
2589               BFD_ASSERT (*specific_refcount > 0);
2590               --*specific_refcount;
2591               if (*specific_refcount == 0)
2592                 {
2593                   /* We don't need the .got entry any more.  */
2594                   sgot->size -= got_element_size;
2595                   srelgot->size -= sizeof (Elf32_External_Rela);
2596                 }
2597               break;
2598             }
2599
2600         local_got_reloc:
2601           if (local_got_refcounts != NULL)
2602             {
2603               /* If the counters are 0 when we got here, we've
2604                  miscounted somehow somewhere, an internal error.  */
2605               BFD_ASSERT (local_got_refcounts[r_symndx] > 0);
2606               --local_got_refcounts[r_symndx];
2607
2608               BFD_ASSERT (*specific_refcount > 0);
2609               --*specific_refcount;
2610               if (*specific_refcount == 0)
2611                 {
2612                   /* We don't need the .got entry any more.  */
2613                   sgot->size -= got_element_size;
2614                   if (info->shared)
2615                     srelgot->size -= sizeof (Elf32_External_Rela);
2616                 }
2617             }
2618           break;
2619
2620         case R_CRIS_16_GOTPLT:
2621         case R_CRIS_32_GOTPLT:
2622           /* For local symbols, treat these like GOT relocs.  */
2623           if (h == NULL)
2624             goto local_got_reloc;
2625           /* Fall through.  */
2626
2627         case R_CRIS_32_PLT_GOTREL:
2628           /* FIXME: We don't garbage-collect away the .got section.  */
2629           if (local_got_refcounts != NULL)
2630             local_got_refcounts[-1]--;
2631           /* Fall through.  */
2632
2633         case R_CRIS_8_PCREL:
2634         case R_CRIS_16_PCREL:
2635         case R_CRIS_32_PCREL:
2636         case R_CRIS_32_PLT_PCREL:
2637           if (h != NULL)
2638             {
2639               if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT
2640                   && h->plt.refcount > 0)
2641                 --h->plt.refcount;
2642             }
2643           break;
2644
2645         case R_CRIS_32_DTPREL:
2646         case R_CRIS_16_DTPREL:
2647           elf_cris_hash_table (info)->dtpmod_refcount--;
2648           if (elf_cris_hash_table (info)->dtpmod_refcount == 0)
2649             elf_cris_hash_table (info)->next_gotplt_entry -= 8;
2650           BFD_ASSERT (local_got_refcounts != NULL);
2651           local_got_refcounts[-1]--;
2652           break;
2653
2654         default:
2655           break;
2656         }
2657     }
2658
2659   return TRUE;
2660 }
2661
2662 /* Make sure we emit a GOT entry if the symbol was supposed to have a PLT
2663    entry but we found we will not create any.  Called when we find we will
2664    not have any PLT for this symbol, by for example
2665    elf_cris_adjust_dynamic_symbol when we're doing a proper dynamic link,
2666    or elf_cris_size_dynamic_sections if no dynamic sections will be
2667    created (we're only linking static objects).  */
2668
2669 static bfd_boolean
2670 elf_cris_adjust_gotplt_to_got (h, p)
2671      struct elf_cris_link_hash_entry *h;
2672      PTR p;
2673 {
2674   struct bfd_link_info *info = (struct bfd_link_info *) p;
2675
2676   if (h->root.root.type == bfd_link_hash_warning)
2677     h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
2678
2679   /* If nobody wanted a GOTPLT with this symbol, we're done.  */
2680   if (h->gotplt_refcount <= 0)
2681     return TRUE;
2682
2683   if (h->reg_got_refcount > 0)
2684     {
2685       /* There's a GOT entry for this symbol.  Just adjust the refcounts.
2686          Probably not necessary at this stage, but keeping them accurate
2687          helps avoiding surprises later.  */
2688       h->root.got.refcount += h->gotplt_refcount;
2689       h->reg_got_refcount += h->gotplt_refcount;
2690       h->gotplt_refcount = 0;
2691     }
2692   else
2693     {
2694       /* No GOT entry for this symbol.  We need to create one.  */
2695       bfd *dynobj = elf_hash_table (info)->dynobj;
2696       asection *sgot;
2697       asection *srelgot;
2698
2699       BFD_ASSERT (dynobj != NULL);
2700       sgot = bfd_get_section_by_name (dynobj, ".got");
2701       srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
2702
2703       /* Put accurate refcounts there.  */
2704       h->root.got.refcount += h->gotplt_refcount;
2705       h->reg_got_refcount = h->gotplt_refcount;
2706
2707       h->gotplt_refcount = 0;
2708
2709       /* We always have a .got and a .rela.got section if there were
2710          GOTPLT relocs in input.  */
2711       BFD_ASSERT (sgot != NULL && srelgot != NULL);
2712
2713       /* Allocate space in the .got section.  */
2714       sgot->size += 4;
2715
2716       /* Allocate relocation space.  */
2717       srelgot->size += sizeof (Elf32_External_Rela);
2718     }
2719
2720   return TRUE;
2721 }
2722
2723 /* Try to fold PLT entries with GOT entries.  There are two cases when we
2724    want to do this:
2725
2726    - When all PLT references are GOTPLT references, and there are GOT
2727      references, and this is not the executable.  We don't have to
2728      generate a PLT at all.
2729
2730    - When there are both (ordinary) PLT references and GOT references,
2731      and this isn't the executable.
2732      We want to make the PLT reference use the ordinary GOT entry rather
2733      than R_CRIS_JUMP_SLOT, a run-time dynamically resolved GOTPLT entry,
2734      since the GOT entry will have to be resolved at startup anyway.
2735
2736    Though the latter case is handled when room for the PLT is allocated,
2737    not here.
2738
2739    By folding into the GOT, we may need a round-trip to a PLT in the
2740    executable for calls, a loss in performance.  Still, losing a
2741    reloc is a win in size and at least in start-up time.
2742
2743    Note that this function is called before symbols are forced local by
2744    version scripts.  The differing cases are handled by
2745    elf_cris_hide_symbol.  */
2746
2747 static bfd_boolean
2748 elf_cris_try_fold_plt_to_got (h, p)
2749      struct elf_cris_link_hash_entry *h;
2750      PTR p;
2751 {
2752   struct bfd_link_info *info = (struct bfd_link_info *) p;
2753
2754   /* If there are no GOT references for this symbol, we can't fold any
2755      other reference so there's nothing to do.  Likewise if there are no
2756      PLT references; GOTPLT references included.  */
2757   if (h->root.got.refcount <= 0 || h->root.plt.refcount <= 0)
2758     return TRUE;
2759
2760   /* GOTPLT relocs are supposed to be included into the PLT refcount.  */
2761   BFD_ASSERT (h->gotplt_refcount <= h->root.plt.refcount);
2762
2763   if (h->gotplt_refcount == h->root.plt.refcount)
2764     {
2765       /* The only PLT references are GOTPLT references, and there are GOT
2766          references.  Convert PLT to GOT references.  */
2767       if (! elf_cris_adjust_gotplt_to_got (h, info))
2768         return FALSE;
2769
2770       /* Clear the PLT references, so no PLT will be created.  */
2771       h->root.plt.offset = (bfd_vma) -1;
2772     }
2773
2774   return TRUE;
2775 }
2776
2777 /* Our own version of hide_symbol, so that we can adjust a GOTPLT reloc
2778    to use a GOT entry (and create one) rather than requiring a GOTPLT
2779    entry.  */
2780
2781 static void
2782 elf_cris_hide_symbol (info, h, force_local)
2783      struct bfd_link_info *info;
2784      struct elf_link_hash_entry *h;
2785      bfd_boolean force_local;
2786 {
2787   elf_cris_adjust_gotplt_to_got ((struct elf_cris_link_hash_entry *) h, info);
2788
2789   _bfd_elf_link_hash_hide_symbol (info, h, force_local);
2790 }
2791
2792 /* Adjust a symbol defined by a dynamic object and referenced by a
2793    regular object.  The current definition is in some section of the
2794    dynamic object, but we're not including those sections.  We have to
2795    change the definition to something the rest of the link can
2796    understand.  */
2797
2798 static bfd_boolean
2799 elf_cris_adjust_dynamic_symbol (info, h)
2800      struct bfd_link_info *info;
2801      struct elf_link_hash_entry *h;
2802 {
2803   bfd *dynobj;
2804   asection *s;
2805   bfd_size_type plt_entry_size;
2806
2807   dynobj = elf_hash_table (info)->dynobj;
2808
2809   /* Make sure we know what is going on here.  */
2810   BFD_ASSERT (dynobj != NULL
2811               && (h->needs_plt
2812                   || h->u.weakdef != NULL
2813                   || (h->def_dynamic
2814                       && h->ref_regular
2815                       && !h->def_regular)));
2816
2817   plt_entry_size
2818     = (bfd_get_mach (dynobj) == bfd_mach_cris_v32
2819        ? PLT_ENTRY_SIZE_V32 : PLT_ENTRY_SIZE);
2820
2821   /* If this is a function, put it in the procedure linkage table.  We
2822      will fill in the contents of the procedure linkage table later,
2823      when we know the address of the .got section.  */
2824   if (h->type == STT_FUNC
2825       || h->needs_plt)
2826     {
2827       /* If we link a program (not a DSO), we'll get rid of unnecessary
2828          PLT entries; we point to the actual symbols -- even for pic
2829          relocs, because a program built with -fpic should have the same
2830          result as one built without -fpic, specifically considering weak
2831          symbols.
2832          FIXME: m68k and i386 differ here, for unclear reasons.  */
2833       if (! info->shared
2834           && !h->def_dynamic)
2835         {
2836           /* This case can occur if we saw a PLT reloc in an input file,
2837              but the symbol was not defined by a dynamic object.  In such
2838              a case, we don't actually need to build a procedure linkage
2839              table, and we can just do an absolute or PC reloc instead, or
2840              change a .got.plt index to a .got index for GOTPLT relocs.  */
2841           BFD_ASSERT (h->needs_plt);
2842           h->needs_plt = 0;
2843           h->plt.offset = (bfd_vma) -1;
2844           return
2845             elf_cris_adjust_gotplt_to_got ((struct
2846                                             elf_cris_link_hash_entry *) h,
2847                                            info);
2848         }
2849
2850       /* If we had a R_CRIS_GLOB_DAT that didn't have to point to a PLT;
2851          where a pointer-equivalent symbol was unimportant (i.e. more
2852          like R_CRIS_JUMP_SLOT after symbol evaluation) we could get rid
2853          of the PLT.  We can't for the executable, because the GOT
2854          entries will point to the PLT there (and be constant).  */
2855       if (info->shared
2856           && !elf_cris_try_fold_plt_to_got ((struct elf_cris_link_hash_entry*)
2857                                             h, info))
2858         return FALSE;
2859
2860       /* GC or folding may have rendered this entry unused.  */
2861       if (h->plt.refcount <= 0)
2862         {
2863           h->needs_plt = 0;
2864           h->plt.offset = (bfd_vma) -1;
2865           return TRUE;
2866         }
2867
2868       /* Make sure this symbol is output as a dynamic symbol.  */
2869       if (h->dynindx == -1)
2870         {
2871           if (! bfd_elf_link_record_dynamic_symbol (info, h))
2872             return FALSE;
2873         }
2874
2875       s = bfd_get_section_by_name (dynobj, ".plt");
2876       BFD_ASSERT (s != NULL);
2877
2878       /* If this is the first .plt entry, make room for the special
2879          first entry.  */
2880       if (s->size == 0)
2881         s->size += plt_entry_size;
2882
2883       /* If this symbol is not defined in a regular file, and we are
2884          not generating a shared library, then set the symbol to this
2885          location in the .plt.  */
2886       if (!info->shared
2887           && !h->def_regular)
2888         {
2889           h->root.u.def.section = s;
2890           h->root.u.def.value = s->size;
2891         }
2892
2893       /* If there's already a GOT entry, use that, not a .got.plt.  A
2894          GOT field still has a reference count when we get here; it's
2895          not yet changed to an offset.  We can't do this for an
2896          executable, because then the reloc associated with the PLT
2897          would get a non-PLT reloc pointing to the PLT.  FIXME: Move
2898          this to elf_cris_try_fold_plt_to_got.  */
2899       if (info->shared && h->got.refcount > 0)
2900         {
2901           h->got.refcount += h->plt.refcount;
2902
2903           /* Mark the PLT offset to use the GOT entry by setting the low
2904              bit in the plt offset; it is always a multiple of
2905              plt_entry_size (which is at least a multiple of 2).  */
2906           BFD_ASSERT ((s->size % plt_entry_size) == 0);
2907
2908           /* Change the PLT refcount to an offset.  */
2909           h->plt.offset = s->size;
2910
2911           /* By not setting gotplt_offset (i.e. it remains at 0), we signal
2912              that the got entry should be used instead.  */
2913           BFD_ASSERT (((struct elf_cris_link_hash_entry *)
2914                        h)->gotplt_offset == 0);
2915
2916           /* Make room for this entry.  */
2917           s->size += plt_entry_size;
2918
2919           return TRUE;
2920         }
2921
2922       /* No GOT reference for this symbol; prepare for an ordinary PLT.  */
2923       h->plt.offset = s->size;
2924
2925       /* Make room for this entry.  */
2926       s->size += plt_entry_size;
2927
2928       /* We also need to make an entry in the .got.plt section, which
2929          will be placed in the .got section by the linker script.  */
2930       ((struct elf_cris_link_hash_entry *) h)->gotplt_offset
2931         = elf_cris_hash_table (info)->next_gotplt_entry;
2932       elf_cris_hash_table (info)->next_gotplt_entry += 4;
2933
2934       s = bfd_get_section_by_name (dynobj, ".got.plt");
2935       BFD_ASSERT (s != NULL);
2936       s->size += 4;
2937
2938       /* We also need to make an entry in the .rela.plt section.  */
2939
2940       s = bfd_get_section_by_name (dynobj, ".rela.plt");
2941       BFD_ASSERT (s != NULL);
2942       s->size += sizeof (Elf32_External_Rela);
2943
2944       return TRUE;
2945     }
2946
2947   /* Reinitialize the plt offset now that it is not used as a reference
2948      count any more.  */
2949   h->plt.offset = (bfd_vma) -1;
2950
2951   /* If this is a weak symbol, and there is a real definition, the
2952      processor independent code will have arranged for us to see the
2953      real definition first, and we can just use the same value.  */
2954   if (h->u.weakdef != NULL)
2955     {
2956       BFD_ASSERT (h->u.weakdef->root.type == bfd_link_hash_defined
2957                   || h->u.weakdef->root.type == bfd_link_hash_defweak);
2958       h->root.u.def.section = h->u.weakdef->root.u.def.section;
2959       h->root.u.def.value = h->u.weakdef->root.u.def.value;
2960       return TRUE;
2961     }
2962
2963   /* This is a reference to a symbol defined by a dynamic object which
2964      is not a function.  */
2965
2966   /* If we are creating a shared library, we must presume that the
2967      only references to the symbol are via the global offset table.
2968      For such cases we need not do anything here; the relocations will
2969      be handled correctly by relocate_section.  */
2970   if (info->shared)
2971     return TRUE;
2972
2973   /* If there are no references to this symbol that do not use the
2974      GOT, we don't need to generate a copy reloc.  */
2975   if (!h->non_got_ref)
2976     return TRUE;
2977
2978   if (h->size == 0)
2979     {
2980       (*_bfd_error_handler) (_("dynamic variable `%s' is zero size"),
2981                              h->root.root.string);
2982       return TRUE;
2983     }
2984
2985   /* We must allocate the symbol in our .dynbss section, which will
2986      become part of the .bss section of the executable.  There will be
2987      an entry for this symbol in the .dynsym section.  The dynamic
2988      object will contain position independent code, so all references
2989      from the dynamic object to this symbol will go through the global
2990      offset table.  The dynamic linker will use the .dynsym entry to
2991      determine the address it must put in the global offset table, so
2992      both the dynamic object and the regular object will refer to the
2993      same memory location for the variable.  */
2994
2995   s = bfd_get_section_by_name (dynobj, ".dynbss");
2996   BFD_ASSERT (s != NULL);
2997
2998   /* We must generate a R_CRIS_COPY reloc to tell the dynamic linker to
2999      copy the initial value out of the dynamic object and into the
3000      runtime process image.  We need to remember the offset into the
3001      .rela.bss section we are going to use.  */
3002   if ((h->root.u.def.section->flags & SEC_ALLOC) != 0)
3003     {
3004       asection *srel;
3005
3006       srel = bfd_get_section_by_name (dynobj, ".rela.bss");
3007       BFD_ASSERT (srel != NULL);
3008       srel->size += sizeof (Elf32_External_Rela);
3009       h->needs_copy = 1;
3010     }
3011
3012   return _bfd_elf_adjust_dynamic_copy (h, s);
3013 }
3014
3015 /* Adjust our "subclass" elements for an indirect symbol.  */
3016
3017 static void
3018 elf_cris_copy_indirect_symbol (struct bfd_link_info *info,
3019                                struct elf_link_hash_entry *dir,
3020                                struct elf_link_hash_entry *ind)
3021 {
3022   struct elf_cris_link_hash_entry *edir, *eind;
3023
3024   edir = (struct elf_cris_link_hash_entry *) dir;
3025   eind = (struct elf_cris_link_hash_entry *) ind;
3026
3027   /* Only indirect symbols are replaced; we're not interested in
3028      updating any of EIND's fields for other symbols.  */
3029   if (eind->root.root.type != bfd_link_hash_indirect)
3030     return;
3031
3032   BFD_ASSERT (edir->pcrel_relocs_copied == NULL);
3033   BFD_ASSERT (edir->gotplt_offset == 0 || eind->gotplt_offset == 0);
3034
3035 #define XMOVOPZ(F, OP, Z) edir->F OP eind->F; eind->F = Z
3036 #define XMOVE(F) XMOVOPZ (F, +=, 0)
3037   XMOVOPZ (pcrel_relocs_copied, =, NULL);
3038   XMOVE (gotplt_refcount);
3039   XMOVE (gotplt_offset);
3040   XMOVE (reg_got_refcount);
3041   XMOVE (tprel_refcount);
3042   XMOVE (dtp_refcount);
3043 #undef XMOVE
3044 #undef XMOVOPZ
3045
3046   _bfd_elf_link_hash_copy_indirect (info, dir, ind);
3047 }
3048
3049 /* Look through the relocs for a section during the first phase.  */
3050
3051 static bfd_boolean
3052 cris_elf_check_relocs (abfd, info, sec, relocs)
3053      bfd *abfd;
3054      struct bfd_link_info *info;
3055      asection *sec;
3056      const Elf_Internal_Rela *relocs;
3057 {
3058   bfd *dynobj;
3059   Elf_Internal_Shdr *symtab_hdr;
3060   struct elf_link_hash_entry **sym_hashes;
3061   bfd_signed_vma *local_got_refcounts;
3062   const Elf_Internal_Rela *rel;
3063   const Elf_Internal_Rela *rel_end;
3064   asection *sgot;
3065   asection *srelgot;
3066   asection *sreloc;
3067
3068   if (info->relocatable)
3069     return TRUE;
3070
3071   dynobj = elf_hash_table (info)->dynobj;
3072   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3073   sym_hashes = elf_sym_hashes (abfd);
3074   local_got_refcounts = elf_local_got_refcounts (abfd);
3075
3076   sgot = NULL;
3077   srelgot = NULL;
3078   sreloc = NULL;
3079
3080   rel_end = relocs + sec->reloc_count;
3081   for (rel = relocs; rel < rel_end; rel++)
3082     {
3083       struct elf_link_hash_entry *h;
3084       unsigned long r_symndx;
3085       enum elf_cris_reloc_type r_type;
3086       bfd_signed_vma got_element_size = 4;
3087       unsigned long r_symndx_lgot = INT_MAX;
3088
3089       r_symndx = ELF32_R_SYM (rel->r_info);
3090       if (r_symndx < symtab_hdr->sh_info)
3091         {
3092           h = NULL;
3093           r_symndx_lgot = LGOT_REG_NDX (r_symndx);
3094         }
3095       else
3096         {
3097           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3098           while (h->root.type == bfd_link_hash_indirect
3099                  || h->root.type == bfd_link_hash_warning)
3100             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3101         }
3102
3103       r_type = ELF32_R_TYPE (rel->r_info);
3104
3105       /* Some relocs require linker-created sections; we need to hang them
3106          on the first input bfd we found that contained dynamic relocs.  */
3107       switch (r_type)
3108         {
3109         case R_CRIS_16_DTPREL:
3110         case R_CRIS_32_DTPREL:
3111           /* The first .got.plt entry is right after the R_CRIS_DTPMOD
3112              entry at index 3. */
3113           if (elf_cris_hash_table (info)->dtpmod_refcount == 0)
3114             elf_cris_hash_table (info)->next_gotplt_entry += 8;
3115           elf_cris_hash_table (info)->dtpmod_refcount++;
3116           /* Fall through.  */
3117
3118         case R_CRIS_32_GD:
3119         case R_CRIS_16_GOT_GD:
3120         case R_CRIS_32_GOT_GD:
3121         case R_CRIS_32_GOT_TPREL:
3122         case R_CRIS_16_GOT_TPREL:
3123         case R_CRIS_16_GOT:
3124         case R_CRIS_32_GOT:
3125         case R_CRIS_32_GOTREL:
3126         case R_CRIS_32_PLT_GOTREL:
3127         case R_CRIS_32_PLT_PCREL:
3128         case R_CRIS_16_GOTPLT:
3129         case R_CRIS_32_GOTPLT:
3130           if (dynobj == NULL)
3131             {
3132               elf_hash_table (info)->dynobj = dynobj = abfd;
3133
3134               /* We could handle this if we can get a handle on the
3135                  output bfd in elf_cris_adjust_dynamic_symbol.  Failing
3136                  that, we must insist on dynobj being a specific mach.  */
3137               if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32)
3138                 {
3139                   (*_bfd_error_handler)
3140                     (_("%B, section %A:\n  v10/v32 compatible object %s"
3141                        " must not contain a PIC relocation"),
3142                      abfd, sec);
3143                   return FALSE;
3144                 }
3145
3146               /* Create the .got section, so we can assume it's always
3147                  present whenever there's a dynobj.  */
3148               if (!_bfd_elf_create_got_section (dynobj, info))
3149                 return FALSE;
3150             }
3151
3152           if (sgot == NULL)
3153             sgot = bfd_get_section_by_name (dynobj, ".got");
3154
3155           if (local_got_refcounts == NULL)
3156             {
3157               bfd_size_type amt;
3158
3159               /* We use index local_got_refcounts[-1] to count all
3160                  GOT-relative relocations that do not have explicit
3161                  GOT entries.  */
3162               amt = LGOT_ALLOC_NELTS_FOR (symtab_hdr->sh_info) + 1;
3163               amt *= sizeof (bfd_signed_vma);
3164               local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
3165               if (local_got_refcounts == NULL)
3166                 return FALSE;
3167
3168               local_got_refcounts++;
3169               elf_local_got_refcounts (abfd) = local_got_refcounts;
3170             }
3171           break;
3172
3173         default:
3174           break;
3175         }
3176
3177       /* Some relocs require a global offset table (but perhaps not a
3178          specific GOT entry).  */
3179       switch (r_type)
3180         {
3181         case R_CRIS_16_DTPREL:
3182         case R_CRIS_32_DTPREL:
3183           /* Not requesting .got.rela for an executable: the contents
3184              of the first entry is constant there.  For a shared
3185              library, we need .got.rela for the R_CRIS_DTPMOD
3186              relocation at index 3.  */
3187           if (!info->shared)
3188             break;
3189           /* Fall through.  */
3190
3191         case R_CRIS_32_GD:
3192         case R_CRIS_16_GOT_GD:
3193         case R_CRIS_32_GOT_GD:
3194         case R_CRIS_32_GOT_TPREL:
3195         case R_CRIS_16_GOT_TPREL:
3196           /* Fall through.  */
3197
3198           /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
3199              entry only for local symbols.  Unfortunately, we don't know
3200              until later on if there's a version script that forces the
3201              symbol local.  We must have the .rela.got section in place
3202              before we know if the symbol looks global now, so we need
3203              to treat the reloc just like for R_CRIS_16_GOT and
3204              R_CRIS_32_GOT.  */
3205         case R_CRIS_16_GOTPLT:
3206         case R_CRIS_32_GOTPLT:
3207         case R_CRIS_16_GOT:
3208         case R_CRIS_32_GOT:
3209           if (srelgot == NULL
3210               && (h != NULL || info->shared))
3211             {
3212               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3213               if (srelgot == NULL)
3214                 {
3215                   srelgot = bfd_make_section_with_flags (dynobj,
3216                                                          ".rela.got",
3217                                                          (SEC_ALLOC
3218                                                           | SEC_LOAD
3219                                                           | SEC_HAS_CONTENTS
3220                                                           | SEC_IN_MEMORY
3221                                                           | SEC_LINKER_CREATED
3222                                                           | SEC_READONLY));
3223                   if (srelgot == NULL
3224                       || !bfd_set_section_alignment (dynobj, srelgot, 2))
3225                     return FALSE;
3226                 }
3227             }
3228           break;
3229
3230         default:
3231           break;
3232         }
3233
3234       /* Warn and error for invalid input.  */
3235       switch (r_type)
3236         {
3237         case R_CRIS_32_TPREL:
3238         case R_CRIS_16_TPREL:
3239         case R_CRIS_32_GD:
3240           if (info->shared)
3241             {
3242               (*_bfd_error_handler)
3243                 (_("%B, section %A:\n  relocation %s not valid"
3244                    " in a shared object;"
3245                    " typically an option mixup, recompile with -fPIC"),
3246                  abfd,
3247                  sec,
3248                  cris_elf_howto_table[r_type].name);
3249               /* Don't return FALSE here; we want messages for all of
3250                  these and the error behavior is ungraceful
3251                  anyway.  */
3252             }
3253         default:
3254           break;
3255         }
3256
3257       switch (r_type)
3258         {
3259         case R_CRIS_32_GD:
3260         case R_CRIS_16_GOT_GD:
3261         case R_CRIS_32_GOT_GD:
3262           /* These are requests for tls_index entries, run-time R_CRIS_DTP.  */
3263           got_element_size = 8;
3264           r_symndx_lgot = LGOT_DTP_NDX (r_symndx);
3265           break;
3266
3267         case R_CRIS_16_DTPREL:
3268         case R_CRIS_32_DTPREL:
3269           /* These two just request for the constant-index
3270              module-local tls_index-sized GOT entry, which we add
3271              elsewhere.  */
3272           break;
3273
3274         case R_CRIS_32_GOT_TPREL:
3275         case R_CRIS_16_GOT_TPREL:
3276           r_symndx_lgot = LGOT_TPREL_NDX (r_symndx);
3277
3278           /* Those two relocs also require that a DSO is of type
3279              Initial Exec.  Like other targets, we don't reset this
3280              flag even if the relocs are GC:ed away.  */
3281           if (info->shared)
3282             info->flags |= DF_STATIC_TLS;
3283           break;
3284
3285           /* Let's list the other assembler-generated TLS-relocs too,
3286              just to show that they're not forgotten. */
3287         case R_CRIS_16_TPREL:
3288         case R_CRIS_32_TPREL:
3289         default:
3290           break;
3291         }
3292
3293       switch (r_type)
3294         {
3295         case R_CRIS_16_GOTPLT:
3296         case R_CRIS_32_GOTPLT:
3297           /* Mark that we need a GOT entry if the PLT entry (and its GOT
3298              entry) is eliminated.  We can only do this for a non-local
3299              symbol.  */
3300           if (h != NULL)
3301             {
3302               elf_cris_hash_entry (h)->gotplt_refcount++;
3303               goto handle_gotplt_reloc;
3304             }
3305           /* If h is NULL then this is a local symbol, and we must make a
3306              GOT entry for it, so handle it like a GOT reloc.  */
3307           /* Fall through.  */
3308
3309         case R_CRIS_32_GD:
3310         case R_CRIS_16_GOT_GD:
3311         case R_CRIS_32_GOT_GD:
3312         case R_CRIS_32_GOT_TPREL:
3313         case R_CRIS_16_GOT_TPREL:
3314         case R_CRIS_16_GOT:
3315         case R_CRIS_32_GOT:
3316           /* This symbol requires a global offset table entry.  */
3317           if (h != NULL)
3318             {
3319               if (h->got.refcount == 0)
3320                 {
3321                   /* Make sure this symbol is output as a dynamic symbol.  */
3322                   if (h->dynindx == -1)
3323                     {
3324                       if (!bfd_elf_link_record_dynamic_symbol (info, h))
3325                         return FALSE;
3326                     }
3327                 }
3328
3329               /* Update the sum of reloc counts for this symbol.  */
3330               h->got.refcount++;
3331
3332               switch (r_type)
3333                 {
3334                 case R_CRIS_16_GOT:
3335                 case R_CRIS_32_GOT:
3336                   if (elf_cris_hash_entry (h)->reg_got_refcount == 0)
3337                     {
3338                       /* Allocate space in the .got section.  */
3339                       sgot->size += got_element_size;
3340                       /* Allocate relocation space.  */
3341                       srelgot->size += sizeof (Elf32_External_Rela);
3342                     }
3343                   elf_cris_hash_entry (h)->reg_got_refcount++;
3344                   break;
3345
3346                 case R_CRIS_32_GD:
3347                 case R_CRIS_16_GOT_GD:
3348                 case R_CRIS_32_GOT_GD:
3349                   if (elf_cris_hash_entry (h)->dtp_refcount == 0)
3350                     {
3351                       /* Allocate space in the .got section.  */
3352                       sgot->size += got_element_size;
3353                       /* Allocate relocation space.  */
3354                       srelgot->size += sizeof (Elf32_External_Rela);
3355                     }
3356                   elf_cris_hash_entry (h)->dtp_refcount++;
3357                   break;
3358
3359                 case R_CRIS_32_GOT_TPREL:
3360                 case R_CRIS_16_GOT_TPREL:
3361                   if (elf_cris_hash_entry (h)->tprel_refcount == 0)
3362                     {
3363                       /* Allocate space in the .got section.  */
3364                       sgot->size += got_element_size;
3365                       /* Allocate relocation space.  */
3366                       srelgot->size += sizeof (Elf32_External_Rela);
3367                     }
3368                   elf_cris_hash_entry (h)->tprel_refcount++;
3369                   break;
3370
3371                 default:
3372                   BFD_FAIL ();
3373                   break;
3374                 }
3375             }
3376           else
3377             {
3378               /* This is a global offset table entry for a local symbol.  */
3379               if (local_got_refcounts[r_symndx_lgot] == 0)
3380                 {
3381                   sgot->size += got_element_size;
3382                   if (info->shared)
3383                     {
3384                       /* If we are generating a shared object, we need
3385                          to output a R_CRIS_RELATIVE reloc so that the
3386                          dynamic linker can adjust this GOT entry.
3387                          Similarly for non-regular got entries.  */
3388                       srelgot->size += sizeof (Elf32_External_Rela);
3389                     }
3390                 }
3391               /* Update the reloc-specific count.  */
3392               local_got_refcounts[r_symndx_lgot]++;
3393
3394               /* This one is the sum of all the others.  */
3395               local_got_refcounts[r_symndx]++;
3396             }
3397           break;
3398
3399         case R_CRIS_16_DTPREL:
3400         case R_CRIS_32_DTPREL:
3401         case R_CRIS_32_GOTREL:
3402           /* This reference requires a global offset table.
3403              FIXME: The actual refcount isn't used currently; the .got
3404              section can't be removed if there were any references in the
3405              input.  */
3406           local_got_refcounts[-1]++;
3407           break;
3408
3409         handle_gotplt_reloc:
3410
3411         case R_CRIS_32_PLT_GOTREL:
3412           /* This reference requires a global offset table.  */
3413           local_got_refcounts[-1]++;
3414           /* Fall through.  */
3415
3416         case R_CRIS_32_PLT_PCREL:
3417           /* This symbol requires a procedure linkage table entry.  We
3418              actually build the entry in adjust_dynamic_symbol,
3419              because this might be a case of linking PIC code which is
3420              never referenced by a dynamic object, in which case we
3421              don't need to generate a procedure linkage table entry
3422              after all.  */
3423
3424           /* Beware: if we'd check for visibility of the symbol here
3425              (and not marking the need for a PLT when non-visible), we'd
3426              get into trouble with keeping handling consistent with
3427              regards to relocs found before definition and GOTPLT
3428              handling.  Eliminable PLT entries will be dealt with later
3429              anyway.  */
3430           if (h == NULL)
3431             continue;
3432
3433           h->needs_plt = 1;
3434           h->plt.refcount++;
3435           break;
3436
3437         case R_CRIS_8:
3438         case R_CRIS_16:
3439         case R_CRIS_32:
3440           /* Let's help debug shared library creation.  Any of these
3441              relocs *can* be used in shared libs, but pages containing
3442              them cannot be shared, so they're not appropriate for
3443              common use.  Don't warn for sections we don't care about,
3444              such as debug sections or non-constant sections.  We
3445              can't help tables of (global) function pointers, for
3446              example, though they must be emitted in a (writable) data
3447              section to avoid having impure text sections.  */
3448           if (info->shared
3449               && (sec->flags & SEC_ALLOC) != 0
3450               && (sec->flags & SEC_READONLY) != 0)
3451             {
3452               /* FIXME: How do we make this optionally a warning only?  */
3453               (*_bfd_error_handler)
3454                 (_("%B, section %A:\n  relocation %s should not"
3455                    " be used in a shared object; recompile with -fPIC"),
3456                  abfd,
3457                  sec,
3458                  cris_elf_howto_table[r_type].name);
3459             }
3460           if (h != NULL)
3461             {
3462               h->non_got_ref = 1;
3463
3464               /* Make sure a plt entry is created for this symbol if it
3465                  turns out to be a function defined by a dynamic object.  */
3466               if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3467                 h->plt.refcount++;
3468             }
3469
3470           /* If we are creating a shared library and this is not a local
3471              symbol, we need to copy the reloc into the shared library.
3472              However when linking with -Bsymbolic and this is a global
3473              symbol which is defined in an object we are including in the
3474              link (i.e., DEF_REGULAR is set), then we can resolve the
3475              reloc directly.  At this point we have not seen all the input
3476              files, so it is possible that DEF_REGULAR is not set now but
3477              will be set later (it is never cleared).  In case of a weak
3478              definition, DEF_REGULAR may be cleared later by a strong
3479              definition in a shared library.  We account for that
3480              possibility below by storing information in the relocs_copied
3481              field of the hash table entry.  A similar situation occurs
3482              when creating shared libraries and symbol visibility changes
3483              render the symbol local.  */
3484
3485           /* No need to do anything if we're not creating a shared object.  */
3486           if (! info->shared)
3487             break;
3488
3489           /* We don't need to handle relocs into sections not going into
3490              the "real" output.  */
3491           if ((sec->flags & SEC_ALLOC) == 0)
3492             break;
3493
3494           /* We may need to create a reloc section in the dynobj and made room
3495              for this reloc.  */
3496           if (sreloc == NULL)
3497             {
3498               sreloc = _bfd_elf_make_dynamic_reloc_section
3499                 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3500
3501               if (sreloc == NULL)
3502                 return FALSE;
3503             }
3504
3505           if (sec->flags & SEC_READONLY)
3506             info->flags |= DF_TEXTREL;
3507
3508           sreloc->size += sizeof (Elf32_External_Rela);
3509           break;
3510
3511         case R_CRIS_8_PCREL:
3512         case R_CRIS_16_PCREL:
3513         case R_CRIS_32_PCREL:
3514           if (h != NULL)
3515             {
3516               h->non_got_ref = 1;
3517
3518               /* Make sure a plt entry is created for this symbol if it
3519                  turns out to be a function defined by a dynamic object.  */
3520               if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3521                 h->plt.refcount++;
3522             }
3523
3524           /* If we are creating a shared library and this is not a local
3525              symbol, we need to copy the reloc into the shared library.
3526              However when linking with -Bsymbolic and this is a global
3527              symbol which is defined in an object we are including in the
3528              link (i.e., DEF_REGULAR is set), then we can resolve the
3529              reloc directly.  At this point we have not seen all the input
3530              files, so it is possible that DEF_REGULAR is not set now but
3531              will be set later (it is never cleared).  In case of a weak
3532              definition, DEF_REGULAR may be cleared later by a strong
3533              definition in a shared library.  We account for that
3534              possibility below by storing information in the relocs_copied
3535              field of the hash table entry.  A similar situation occurs
3536              when creating shared libraries and symbol visibility changes
3537              render the symbol local.  */
3538
3539           /* No need to do anything if we're not creating a shared object.  */
3540           if (! info->shared)
3541             break;
3542
3543           /* We don't need to handle relocs into sections not going into
3544              the "real" output.  */
3545           if ((sec->flags & SEC_ALLOC) == 0)
3546             break;
3547
3548           /* If the symbol is local, then we know already we can
3549              eliminate the reloc.  */
3550           if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3551             break;
3552
3553           /* If this is with -Bsymbolic and the symbol isn't weak, and
3554              is defined by an ordinary object (the ones we include in
3555              this shared library) then we can also eliminate the
3556              reloc.  See comment above for more eliminable cases which
3557              we can't identify at this time.  */
3558           if (info->symbolic
3559               && h->root.type != bfd_link_hash_defweak
3560               && h->def_regular)
3561             break;
3562
3563           /* We may need to create a reloc section in the dynobj and made room
3564              for this reloc.  */
3565           if (sreloc == NULL)
3566             {
3567               sreloc = _bfd_elf_make_dynamic_reloc_section
3568                 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3569
3570               if (sreloc == NULL)
3571                 return FALSE;
3572             }
3573
3574           sreloc->size += sizeof (Elf32_External_Rela);
3575
3576           /* We count the number of PC relative relocations we have
3577              entered for this symbol, so that we can discard them
3578              again if the symbol is later defined by a regular object.
3579              We know that h is really a pointer to an
3580              elf_cris_link_hash_entry.  */
3581           {
3582             struct elf_cris_link_hash_entry *eh;
3583             struct elf_cris_pcrel_relocs_copied *p;
3584
3585             eh = elf_cris_hash_entry (h);
3586
3587             for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
3588               if (p->section == sreloc)
3589                 break;
3590
3591             if (p == NULL)
3592               {
3593                 p = ((struct elf_cris_pcrel_relocs_copied *)
3594                      bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
3595                 if (p == NULL)
3596                   return FALSE;
3597                 p->next = eh->pcrel_relocs_copied;
3598                 eh->pcrel_relocs_copied = p;
3599                 p->section = sreloc;
3600                 p->count = 0;
3601                 p->r_type = r_type;
3602               }
3603
3604             ++p->count;
3605           }
3606           break;
3607
3608         /* This relocation describes the C++ object vtable hierarchy.
3609            Reconstruct it for later use during GC.  */
3610         case R_CRIS_GNU_VTINHERIT:
3611           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3612             return FALSE;
3613           break;
3614
3615         /* This relocation describes which C++ vtable entries are actually
3616            used.  Record for later use during GC.  */
3617         case R_CRIS_GNU_VTENTRY:
3618           BFD_ASSERT (h != NULL);
3619           if (h != NULL
3620               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3621             return FALSE;
3622           break;
3623
3624         case R_CRIS_16_TPREL:
3625         case R_CRIS_32_TPREL:
3626           /* Already warned above, when necessary.  */
3627           break;
3628
3629         default:
3630           /* Other relocs do not appear here.  */
3631           bfd_set_error (bfd_error_bad_value);
3632           return FALSE;
3633         }
3634     }
3635
3636   return TRUE;
3637 }
3638
3639 /* Set the sizes of the dynamic sections.  */
3640
3641 static bfd_boolean
3642 elf_cris_size_dynamic_sections (output_bfd, info)
3643      bfd *output_bfd ATTRIBUTE_UNUSED;
3644      struct bfd_link_info *info;
3645 {
3646   bfd *dynobj;
3647   asection *s;
3648   bfd_boolean plt;
3649   bfd_boolean relocs;
3650
3651   dynobj = elf_hash_table (info)->dynobj;
3652   BFD_ASSERT (dynobj != NULL);
3653
3654   if (elf_hash_table (info)->dynamic_sections_created)
3655     {
3656       /* Set the contents of the .interp section to the interpreter.  */
3657       if (info->executable)
3658         {
3659           s = bfd_get_section_by_name (dynobj, ".interp");
3660           BFD_ASSERT (s != NULL);
3661           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3662           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3663         }
3664     }
3665   else
3666     {
3667       /* Adjust all expected GOTPLT uses to use a GOT entry instead.  */
3668       elf_cris_link_hash_traverse (elf_cris_hash_table (info),
3669                                    elf_cris_adjust_gotplt_to_got,
3670                                    (PTR) info);
3671
3672       /* We may have created entries in the .rela.got section.
3673          However, if we are not creating the dynamic sections, we will
3674          not actually use these entries.  Reset the size of .rela.got,
3675          which will cause it to get stripped from the output file
3676          below.  */
3677       s = bfd_get_section_by_name (dynobj, ".rela.got");
3678       if (s != NULL)
3679         s->size = 0;
3680     }
3681
3682   /* If this is a -Bsymbolic shared link, then we need to discard all PC
3683      relative relocs against symbols defined in a regular object.  We
3684      allocated space for them in the check_relocs routine, but we will not
3685      fill them in in the relocate_section routine.  We also discard space
3686      for relocs that have become for local symbols due to symbol
3687      visibility changes.  For programs, we discard space for relocs for
3688      symbols not referenced by any dynamic object.  */
3689   if (info->shared)
3690     elf_cris_link_hash_traverse (elf_cris_hash_table (info),
3691                                  elf_cris_discard_excess_dso_dynamics,
3692                                  (PTR) info);
3693   else
3694     elf_cris_link_hash_traverse (elf_cris_hash_table (info),
3695                                  elf_cris_discard_excess_program_dynamics,
3696                                  (PTR) info);
3697
3698   /* The check_relocs and adjust_dynamic_symbol entry points have
3699      determined the sizes of the various dynamic sections.  Allocate
3700      memory for them.  */
3701   plt = FALSE;
3702   relocs = FALSE;
3703   for (s = dynobj->sections; s != NULL; s = s->next)
3704     {
3705       const char *name;
3706
3707       if ((s->flags & SEC_LINKER_CREATED) == 0)
3708         continue;
3709
3710       /* It's OK to base decisions on the section name, because none
3711          of the dynobj section names depend upon the input files.  */
3712       name = bfd_get_section_name (dynobj, s);
3713
3714       if (strcmp (name, ".plt") == 0)
3715         {
3716           /* Remember whether there is a PLT.  */
3717           plt = s->size != 0;
3718         }
3719       else if (strcmp (name, ".got.plt") == 0)
3720         {
3721           /* The .got.plt contains the .got header as well as the
3722              actual .got.plt contents.  The .got header may contain a
3723              R_CRIS_DTPMOD entry at index 3.  */
3724           s->size += elf_cris_hash_table (info)->dtpmod_refcount != 0
3725             ? 8 : 0;
3726         }
3727       else if (CONST_STRNEQ (name, ".rela"))
3728         {
3729           if (strcmp (name, ".rela.got") == 0
3730               && elf_cris_hash_table (info)->dtpmod_refcount != 0
3731               && info->shared)
3732             s->size += sizeof (Elf32_External_Rela);
3733
3734           if (s->size != 0)
3735             {
3736               /* Remember whether there are any reloc sections other
3737                  than .rela.plt.  */
3738               if (strcmp (name, ".rela.plt") != 0)
3739                   relocs = TRUE;
3740
3741               /* We use the reloc_count field as a counter if we need
3742                  to copy relocs into the output file.  */
3743               s->reloc_count = 0;
3744             }
3745         }
3746       else if (! CONST_STRNEQ (name, ".got")
3747                && strcmp (name, ".dynbss") != 0)
3748         {
3749           /* It's not one of our sections, so don't allocate space.  */
3750           continue;
3751         }
3752
3753       if (s->size == 0)
3754         {
3755           /* If we don't need this section, strip it from the
3756              output file.  This is mostly to handle .rela.bss and
3757              .rela.plt.  We must create both sections in
3758              create_dynamic_sections, because they must be created
3759              before the linker maps input sections to output
3760              sections.  The linker does that before
3761              adjust_dynamic_symbol is called, and it is that
3762              function which decides whether anything needs to go
3763              into these sections.  */
3764           s->flags |= SEC_EXCLUDE;
3765           continue;
3766         }
3767
3768       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3769         continue;
3770
3771       /* Allocate memory for the section contents. We use bfd_zalloc here
3772          in case unused entries are not reclaimed before the section's
3773          contents are written out.  This should not happen, but this way
3774          if it does, we will not write out garbage.  For reloc sections,
3775          this will make entries have the type R_CRIS_NONE.  */
3776       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3777       if (s->contents == NULL)
3778         return FALSE;
3779     }
3780
3781   if (elf_hash_table (info)->dynamic_sections_created)
3782     {
3783       /* Add some entries to the .dynamic section.  We fill in the
3784          values later, in elf_cris_finish_dynamic_sections, but we
3785          must add the entries now so that we get the correct size for
3786          the .dynamic section.  The DT_DEBUG entry is filled in by the
3787          dynamic linker and used by the debugger.  */
3788 #define add_dynamic_entry(TAG, VAL) \
3789   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3790
3791       if (!info->shared)
3792         {
3793           if (!add_dynamic_entry (DT_DEBUG, 0))
3794             return FALSE;
3795         }
3796
3797       if (plt)
3798         {
3799           if (!add_dynamic_entry (DT_PLTGOT, 0)
3800               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3801               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3802               || !add_dynamic_entry (DT_JMPREL, 0))
3803             return FALSE;
3804         }
3805
3806       if (relocs)
3807         {
3808           if (!add_dynamic_entry (DT_RELA, 0)
3809               || !add_dynamic_entry (DT_RELASZ, 0)
3810               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3811             return FALSE;
3812         }
3813
3814       if ((info->flags & DF_TEXTREL) != 0)
3815         {
3816           if (!add_dynamic_entry (DT_TEXTREL, 0))
3817             return FALSE;
3818           info->flags |= DF_TEXTREL;
3819         }
3820     }
3821 #undef add_dynamic_entry
3822
3823   return TRUE;
3824 }
3825
3826 /* This function is called via elf_cris_link_hash_traverse if we are
3827    creating a shared object.  In the -Bsymbolic case, it discards the
3828    space allocated to copy PC relative relocs against symbols which
3829    are defined in regular objects.  For the normal non-symbolic case,
3830    we also discard space for relocs that have become local due to
3831    symbol visibility changes.  We allocated space for them in the
3832    check_relocs routine, but we won't fill them in in the
3833    relocate_section routine.  */
3834
3835 static bfd_boolean
3836 elf_cris_discard_excess_dso_dynamics (h, inf)
3837      struct elf_cris_link_hash_entry *h;
3838      PTR inf;
3839 {
3840   struct elf_cris_pcrel_relocs_copied *s;
3841   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3842
3843   if (h->root.root.type == bfd_link_hash_warning)
3844     h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3845
3846   /* If a symbol has been forced local or we have found a regular
3847      definition for the symbolic link case, then we won't be needing
3848      any relocs.  */
3849   if (h->root.def_regular
3850       && (h->root.forced_local
3851           || info->symbolic))
3852     {
3853       for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3854         s->section->size -= s->count * sizeof (Elf32_External_Rela);
3855
3856       return TRUE;
3857     }
3858
3859   /* If we have accounted for PC-relative relocs for read-only
3860      sections, now is the time to warn for them.  We can't do it in
3861      cris_elf_check_relocs, because we don't know the status of all
3862      symbols at that time (and it's common to force symbols local
3863      late).  */
3864
3865   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3866     {
3867       BFD_ASSERT ((s->section->flags & SEC_READONLY) != 0);
3868
3869       /* FIXME: How do we make this optionally a warning only?  */
3870       (*_bfd_error_handler)
3871         (_("%B, section `%A', to symbol `%s':\n"
3872            "  relocation %s should not be used"
3873            " in a shared object; recompile with -fPIC"),
3874          s->section->owner,
3875          s->section,
3876          h->root.root.root.string,
3877          cris_elf_howto_table[s->r_type].name);
3878
3879       info->flags |= DF_TEXTREL;
3880     }
3881
3882   return TRUE;
3883 }
3884
3885 /* This function is called via elf_cris_link_hash_traverse if we are *not*
3886    creating a shared object.  We discard space for relocs for symbols put
3887    in the .got, but which we found we do not have to resolve at run-time.  */
3888
3889 static bfd_boolean
3890 elf_cris_discard_excess_program_dynamics (h, inf)
3891      struct elf_cris_link_hash_entry *h;
3892      PTR inf;
3893 {
3894   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3895
3896   if (h->root.root.type == bfd_link_hash_warning)
3897     h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3898
3899   /* If we're not creating a shared library and have a symbol which is
3900      referred to by .got references, but the symbol is defined locally,
3901      (or rather, not defined by a DSO) then lose the reloc for the .got
3902      (don't allocate room for it).  Likewise for relocs for something
3903      for which we create a PLT.  */
3904   if (!h->root.def_dynamic
3905       || h->root.plt.refcount > 0)
3906     {
3907       if (h->reg_got_refcount > 0
3908           /* The size of this section is only valid and in sync with the
3909              various reference counts if we do dynamic; don't decrement it
3910              otherwise.  */
3911           && elf_hash_table (info)->dynamic_sections_created)
3912         {
3913           bfd *dynobj = elf_hash_table (info)->dynobj;
3914           asection *srelgot;
3915
3916           BFD_ASSERT (dynobj != NULL);
3917
3918           srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3919
3920           BFD_ASSERT (srelgot != NULL);
3921
3922           srelgot->size -= sizeof (Elf32_External_Rela);
3923         }
3924
3925       /* If the locally-defined symbol isn't used by a DSO, then we don't
3926          have to export it as a dynamic symbol.  This was already done for
3927          functions; doing this for all symbols would presumably not
3928          introduce new problems.  Of course we don't do this if we're
3929          exporting all dynamic symbols.  */
3930       if (! info->export_dynamic
3931           && h->root.dynindx != -1
3932           && !h->root.def_dynamic
3933           && !h->root.ref_dynamic)
3934         {
3935           h->root.dynindx = -1;
3936           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3937                                   h->root.dynstr_index);
3938         }
3939     }
3940
3941   return TRUE;
3942 }
3943
3944 /* Reject a file depending on presence and expectation of prefixed
3945    underscores on symbols.  */
3946
3947 static bfd_boolean
3948 cris_elf_object_p (abfd)
3949      bfd *abfd;
3950 {
3951   if (! cris_elf_set_mach_from_flags (abfd, elf_elfheader (abfd)->e_flags))
3952     return FALSE;
3953
3954   if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
3955     return (bfd_get_symbol_leading_char (abfd) == '_');
3956   else
3957     return (bfd_get_symbol_leading_char (abfd) == 0);
3958 }
3959
3960 /* Mark presence or absence of leading underscore.  Set machine type
3961    flags from mach type.  */
3962
3963 static void
3964 cris_elf_final_write_processing (abfd, linker)
3965      bfd *abfd;
3966      bfd_boolean linker ATTRIBUTE_UNUSED;
3967 {
3968   unsigned long e_flags = elf_elfheader (abfd)->e_flags;
3969
3970   e_flags &= ~EF_CRIS_UNDERSCORE;
3971   if (bfd_get_symbol_leading_char (abfd) == '_')
3972     e_flags |= EF_CRIS_UNDERSCORE;
3973
3974   switch (bfd_get_mach (abfd))
3975     {
3976     case bfd_mach_cris_v0_v10:
3977       e_flags |= EF_CRIS_VARIANT_ANY_V0_V10;
3978       break;
3979
3980     case bfd_mach_cris_v10_v32:
3981       e_flags |= EF_CRIS_VARIANT_COMMON_V10_V32;
3982       break;
3983
3984     case bfd_mach_cris_v32:
3985       e_flags |= EF_CRIS_VARIANT_V32;
3986       break;
3987
3988     default:
3989       _bfd_abort (__FILE__, __LINE__,
3990                   _("Unexpected machine number"));
3991     }
3992
3993   elf_elfheader (abfd)->e_flags = e_flags;
3994 }
3995
3996 /* Set the mach type from e_flags value.  */
3997
3998 static bfd_boolean
3999 cris_elf_set_mach_from_flags (abfd, flags)
4000      bfd *abfd;
4001      unsigned long flags;
4002 {
4003   switch (flags & EF_CRIS_VARIANT_MASK)
4004     {
4005     case EF_CRIS_VARIANT_ANY_V0_V10:
4006       bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v0_v10);
4007       break;
4008
4009     case EF_CRIS_VARIANT_V32:
4010       bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v32);
4011       break;
4012
4013     case EF_CRIS_VARIANT_COMMON_V10_V32:
4014       bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v10_v32);
4015       break;
4016
4017     default:
4018       /* Since we don't recognize them, we obviously can't support them
4019          with this code; we'd have to require that all future handling
4020          would be optional.  */
4021       bfd_set_error (bfd_error_wrong_format);
4022       return FALSE;
4023     }
4024
4025   return TRUE;
4026 }
4027
4028 /* Display the flags field.  */
4029
4030 static bfd_boolean
4031 cris_elf_print_private_bfd_data (abfd, ptr)
4032      bfd *abfd;
4033      PTR ptr;
4034 {
4035   FILE *file = (FILE *) ptr;
4036
4037   BFD_ASSERT (abfd != NULL && ptr != NULL);
4038
4039   _bfd_elf_print_private_bfd_data (abfd, ptr);
4040
4041   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4042
4043   if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
4044     fprintf (file, _(" [symbols have a _ prefix]"));
4045   if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
4046       == EF_CRIS_VARIANT_COMMON_V10_V32)
4047     fprintf (file, _(" [v10 and v32]"));
4048   if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
4049       == EF_CRIS_VARIANT_V32)
4050     fprintf (file, _(" [v32]"));
4051
4052   fputc ('\n', file);
4053   return TRUE;
4054 }
4055
4056 /* Don't mix files with and without a leading underscore.  */
4057
4058 static bfd_boolean
4059 cris_elf_merge_private_bfd_data (ibfd, obfd)
4060      bfd *ibfd;
4061      bfd *obfd;
4062 {
4063   int imach, omach;
4064
4065   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4066     return FALSE;
4067
4068   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4069       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4070     return TRUE;
4071
4072   imach = bfd_get_mach (ibfd);
4073
4074   if (! elf_flags_init (obfd))
4075     {
4076       /* This happens when ld starts out with a 'blank' output file.  */
4077       elf_flags_init (obfd) = TRUE;
4078
4079       /* We ignore the linker-set mach, and instead set it according to
4080          the first input file.  This would also happen if we could
4081          somehow filter out the OUTPUT_ARCH () setting from elf.sc.
4082          This allows us to keep the same linker config across
4083          cris(v0..v10) and crisv32.  The drawback is that we can't force
4084          the output type, which might be a sane thing to do for a
4085          v10+v32 compatibility object.  */
4086       if (! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
4087         return FALSE;
4088     }
4089
4090   if (bfd_get_symbol_leading_char (ibfd)
4091       != bfd_get_symbol_leading_char (obfd))
4092     {
4093       (*_bfd_error_handler)
4094         (bfd_get_symbol_leading_char (ibfd) == '_'
4095          ? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols")
4096          : _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
4097          ibfd);
4098       bfd_set_error (bfd_error_bad_value);
4099       return FALSE;
4100     }
4101
4102   omach = bfd_get_mach (obfd);
4103
4104   if (imach != omach)
4105     {
4106       /* We can get an incompatible combination only if either is
4107          bfd_mach_cris_v32, and the other one isn't compatible.  */
4108       if ((imach == bfd_mach_cris_v32
4109            && omach != bfd_mach_cris_v10_v32)
4110           || (omach == bfd_mach_cris_v32
4111               && imach != bfd_mach_cris_v10_v32))
4112         {
4113           (*_bfd_error_handler)
4114             ((imach == bfd_mach_cris_v32)
4115              ? _("%B contains CRIS v32 code, incompatible"
4116                  " with previous objects")
4117              : _("%B contains non-CRIS-v32 code, incompatible"
4118                  " with previous objects"),
4119              ibfd);
4120           bfd_set_error (bfd_error_bad_value);
4121           return FALSE;
4122         }
4123
4124       /* We don't have to check the case where the input is compatible
4125          with v10 and v32, because the output is already known to be set
4126          to the other (compatible) mach.  */
4127       if (omach == bfd_mach_cris_v10_v32
4128           && ! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
4129         return FALSE;
4130     }
4131
4132   return TRUE;
4133 }
4134
4135 /* Do side-effects of e_flags copying to obfd.  */
4136
4137 static bfd_boolean
4138 cris_elf_copy_private_bfd_data (ibfd, obfd)
4139      bfd *ibfd;
4140      bfd *obfd;
4141 {
4142   /* Call the base function.  */
4143   if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd))
4144     return FALSE;
4145
4146   /* If output is big-endian for some obscure reason, stop here.  */
4147   if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
4148     return FALSE;
4149
4150   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4151       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4152     return TRUE;
4153
4154   /* Do what we really came here for.  */
4155   return bfd_set_arch_mach (obfd, bfd_arch_cris, bfd_get_mach (ibfd));
4156 }
4157
4158 static enum elf_reloc_type_class
4159 elf_cris_reloc_type_class (rela)
4160      const Elf_Internal_Rela *rela;
4161 {
4162   enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rela->r_info);
4163   switch (r_type)
4164     {
4165     case R_CRIS_RELATIVE:
4166       return reloc_class_relative;
4167     case R_CRIS_JUMP_SLOT:
4168       return reloc_class_plt;
4169     case R_CRIS_COPY:
4170       return reloc_class_copy;
4171     default:
4172       return reloc_class_normal;
4173     }
4174 }
4175
4176 /* The elf_backend_got_elt_size worker.  For one symbol, we can have up to
4177    two GOT entries from three types with two different sizes.  We handle
4178    it as a single entry, so we can use the regular offset-calculation
4179    machinery.  */
4180
4181 static bfd_vma
4182 elf_cris_got_elt_size (bfd *abfd ATTRIBUTE_UNUSED,
4183                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
4184                        struct elf_link_hash_entry *hr,
4185                        bfd *ibfd,
4186                        unsigned long symndx)
4187 {
4188   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) hr;
4189   bfd_vma eltsiz = 0;
4190
4191   /* We may have one regular GOT entry or up to two TLS GOT
4192      entries.  */
4193   if (h == NULL)
4194     {
4195       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4196       bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (ibfd);
4197
4198       BFD_ASSERT (local_got_refcounts != NULL);
4199
4200       if (local_got_refcounts[LGOT_REG_NDX (symndx)] > 0)
4201         {
4202           /* We can't have a variable referred to both as a regular
4203              variable and through TLS relocs.  */
4204           BFD_ASSERT (local_got_refcounts[LGOT_DTP_NDX (symndx)] == 0
4205                       && local_got_refcounts[LGOT_TPREL_NDX (symndx)] == 0);
4206           return 4;
4207         }
4208
4209       if (local_got_refcounts[LGOT_DTP_NDX (symndx)] > 0)
4210         eltsiz += 8;
4211
4212       if (local_got_refcounts[LGOT_TPREL_NDX (symndx)] > 0)
4213         eltsiz += 4;
4214     }
4215   else
4216     {
4217       struct elf_cris_link_hash_entry *hh = elf_cris_hash_entry (h);
4218       if (hh->reg_got_refcount > 0)
4219         {
4220           /* The actual error-on-input is emitted elsewhere.  */
4221           BFD_ASSERT (hh->dtp_refcount == 0 && hh->tprel_refcount == 0);
4222           return 4;
4223         }
4224
4225       if (hh->dtp_refcount > 0)
4226         eltsiz += 8;
4227
4228       if (hh->tprel_refcount > 0)
4229         eltsiz += 4;
4230     }
4231
4232   /* We're only called when h->got.refcount is non-zero, so we must
4233      have a non-zero size.  */
4234   BFD_ASSERT (eltsiz != 0);
4235   return eltsiz;
4236 }
4237 \f
4238 #define ELF_ARCH                bfd_arch_cris
4239 #define ELF_MACHINE_CODE        EM_CRIS
4240 #define ELF_MAXPAGESIZE         0x2000
4241
4242 #define TARGET_LITTLE_SYM       bfd_elf32_cris_vec
4243 #define TARGET_LITTLE_NAME      "elf32-cris"
4244 #define elf_symbol_leading_char 0
4245
4246 #define elf_info_to_howto_rel                   NULL
4247 #define elf_info_to_howto                       cris_info_to_howto_rela
4248 #define elf_backend_relocate_section            cris_elf_relocate_section
4249 #define elf_backend_gc_mark_hook                cris_elf_gc_mark_hook
4250 #define elf_backend_gc_sweep_hook               cris_elf_gc_sweep_hook
4251 #define elf_backend_check_relocs                cris_elf_check_relocs
4252 #define elf_backend_grok_prstatus               cris_elf_grok_prstatus
4253 #define elf_backend_grok_psinfo                 cris_elf_grok_psinfo
4254
4255 #define elf_backend_can_gc_sections             1
4256 #define elf_backend_can_refcount                1
4257
4258 #define elf_backend_object_p                    cris_elf_object_p
4259 #define elf_backend_final_write_processing \
4260         cris_elf_final_write_processing
4261 #define bfd_elf32_bfd_print_private_bfd_data \
4262         cris_elf_print_private_bfd_data
4263 #define bfd_elf32_bfd_merge_private_bfd_data \
4264         cris_elf_merge_private_bfd_data
4265 #define bfd_elf32_bfd_copy_private_bfd_data \
4266         cris_elf_copy_private_bfd_data
4267
4268 #define bfd_elf32_bfd_reloc_type_lookup         cris_reloc_type_lookup
4269 #define bfd_elf32_bfd_reloc_name_lookup cris_reloc_name_lookup
4270
4271 #define bfd_elf32_bfd_link_hash_table_create \
4272         elf_cris_link_hash_table_create
4273 #define elf_backend_adjust_dynamic_symbol \
4274         elf_cris_adjust_dynamic_symbol
4275 #define elf_backend_copy_indirect_symbol \
4276         elf_cris_copy_indirect_symbol
4277 #define elf_backend_size_dynamic_sections \
4278         elf_cris_size_dynamic_sections
4279 #define elf_backend_init_index_section          _bfd_elf_init_1_index_section
4280 #define elf_backend_finish_dynamic_symbol \
4281         elf_cris_finish_dynamic_symbol
4282 #define elf_backend_finish_dynamic_sections \
4283         elf_cris_finish_dynamic_sections
4284 #define elf_backend_create_dynamic_sections \
4285         _bfd_elf_create_dynamic_sections
4286 #define bfd_elf32_bfd_final_link \
4287         bfd_elf_gc_common_final_link
4288 #define elf_backend_hide_symbol                 elf_cris_hide_symbol
4289 #define elf_backend_reloc_type_class            elf_cris_reloc_type_class
4290
4291 #define elf_backend_want_got_plt        1
4292 #define elf_backend_plt_readonly        1
4293 #define elf_backend_want_plt_sym        0
4294 #define elf_backend_got_header_size     12
4295 #define elf_backend_got_elt_size elf_cris_got_elt_size
4296
4297 /* Later, we my want to optimize RELA entries into REL entries for dynamic
4298    linking and libraries (if it's a win of any significance).  Until then,
4299    take the easy route.  */
4300 #define elf_backend_may_use_rel_p 0
4301 #define elf_backend_may_use_rela_p 1
4302 #define elf_backend_rela_normal         1
4303
4304 #include "elf32-target.h"
4305
4306 #undef TARGET_LITTLE_SYM
4307 #undef TARGET_LITTLE_NAME
4308 #undef elf_symbol_leading_char
4309
4310 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
4311 #define TARGET_LITTLE_NAME "elf32-us-cris"
4312 #define elf_symbol_leading_char '_'
4313 #undef elf32_bed
4314 #define elf32_bed elf32_us_cris_bed
4315
4316 #include "elf32-target.h"