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->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 /* Look through the relocs for a section during the first phase.  */
3016
3017 static bfd_boolean
3018 cris_elf_check_relocs (abfd, info, sec, relocs)
3019      bfd *abfd;
3020      struct bfd_link_info *info;
3021      asection *sec;
3022      const Elf_Internal_Rela *relocs;
3023 {
3024   bfd *dynobj;
3025   Elf_Internal_Shdr *symtab_hdr;
3026   struct elf_link_hash_entry **sym_hashes;
3027   bfd_signed_vma *local_got_refcounts;
3028   const Elf_Internal_Rela *rel;
3029   const Elf_Internal_Rela *rel_end;
3030   asection *sgot;
3031   asection *srelgot;
3032   asection *sreloc;
3033
3034   if (info->relocatable)
3035     return TRUE;
3036
3037   dynobj = elf_hash_table (info)->dynobj;
3038   symtab_hdr = &elf_tdata (abfd)->symtab_hdr;
3039   sym_hashes = elf_sym_hashes (abfd);
3040   local_got_refcounts = elf_local_got_refcounts (abfd);
3041
3042   sgot = NULL;
3043   srelgot = NULL;
3044   sreloc = NULL;
3045
3046   rel_end = relocs + sec->reloc_count;
3047   for (rel = relocs; rel < rel_end; rel++)
3048     {
3049       struct elf_link_hash_entry *h;
3050       unsigned long r_symndx;
3051       enum elf_cris_reloc_type r_type;
3052       bfd_signed_vma got_element_size = 4;
3053       unsigned long r_symndx_lgot = INT_MAX;
3054
3055       r_symndx = ELF32_R_SYM (rel->r_info);
3056       if (r_symndx < symtab_hdr->sh_info)
3057         {
3058           h = NULL;
3059           r_symndx_lgot = LGOT_REG_NDX (r_symndx);
3060         }
3061       else
3062         {
3063           h = sym_hashes[r_symndx - symtab_hdr->sh_info];
3064           while (h->root.type == bfd_link_hash_indirect
3065                  || h->root.type == bfd_link_hash_warning)
3066             h = (struct elf_link_hash_entry *) h->root.u.i.link;
3067         }
3068
3069       r_type = ELF32_R_TYPE (rel->r_info);
3070
3071       /* Some relocs require linker-created sections; we need to hang them
3072          on the first input bfd we found that contained dynamic relocs.  */
3073       switch (r_type)
3074         {
3075         case R_CRIS_16_DTPREL:
3076         case R_CRIS_32_DTPREL:
3077           /* The first .got.plt entry is right after the R_CRIS_DTPMOD
3078              entry at index 3. */
3079           if (elf_cris_hash_table (info)->dtpmod_refcount == 0)
3080             elf_cris_hash_table (info)->next_gotplt_entry += 8;
3081           elf_cris_hash_table (info)->dtpmod_refcount++;
3082           /* Fall through.  */
3083
3084         case R_CRIS_32_GD:
3085         case R_CRIS_16_GOT_GD:
3086         case R_CRIS_32_GOT_GD:
3087         case R_CRIS_32_GOT_TPREL:
3088         case R_CRIS_16_GOT_TPREL:
3089         case R_CRIS_16_GOT:
3090         case R_CRIS_32_GOT:
3091         case R_CRIS_32_GOTREL:
3092         case R_CRIS_32_PLT_GOTREL:
3093         case R_CRIS_32_PLT_PCREL:
3094         case R_CRIS_16_GOTPLT:
3095         case R_CRIS_32_GOTPLT:
3096           if (dynobj == NULL)
3097             {
3098               elf_hash_table (info)->dynobj = dynobj = abfd;
3099
3100               /* We could handle this if we can get a handle on the
3101                  output bfd in elf_cris_adjust_dynamic_symbol.  Failing
3102                  that, we must insist on dynobj being a specific mach.  */
3103               if (bfd_get_mach (dynobj) == bfd_mach_cris_v10_v32)
3104                 {
3105                   (*_bfd_error_handler)
3106                     (_("%B, section %A:\n  v10/v32 compatible object %s"
3107                        " must not contain a PIC relocation"),
3108                      abfd, sec);
3109                   return FALSE;
3110                 }
3111
3112               /* Create the .got section, so we can assume it's always
3113                  present whenever there's a dynobj.  */
3114               if (!_bfd_elf_create_got_section (dynobj, info))
3115                 return FALSE;
3116             }
3117
3118           if (sgot == NULL)
3119             sgot = bfd_get_section_by_name (dynobj, ".got");
3120
3121           if (local_got_refcounts == NULL)
3122             {
3123               bfd_size_type amt;
3124
3125               /* We use index local_got_refcounts[-1] to count all
3126                  GOT-relative relocations that do not have explicit
3127                  GOT entries.  */
3128               amt = LGOT_ALLOC_NELTS_FOR (symtab_hdr->sh_info) + 1;
3129               amt *= sizeof (bfd_signed_vma);
3130               local_got_refcounts = ((bfd_signed_vma *) bfd_zalloc (abfd, amt));
3131               if (local_got_refcounts == NULL)
3132                 return FALSE;
3133
3134               local_got_refcounts++;
3135               elf_local_got_refcounts (abfd) = local_got_refcounts;
3136             }
3137           break;
3138
3139         default:
3140           break;
3141         }
3142
3143       /* Some relocs require a global offset table (but perhaps not a
3144          specific GOT entry).  */
3145       switch (r_type)
3146         {
3147         case R_CRIS_16_DTPREL:
3148         case R_CRIS_32_DTPREL:
3149           /* Not requesting .got.rela for an executable: the contents
3150              of the first entry is constant there.  For a shared
3151              library, we need .got.rela for the R_CRIS_DTPMOD
3152              relocation at index 3.  */
3153           if (!info->shared)
3154             break;
3155           /* Fall through.  */
3156
3157         case R_CRIS_32_GD:
3158         case R_CRIS_16_GOT_GD:
3159         case R_CRIS_32_GOT_GD:
3160         case R_CRIS_32_GOT_TPREL:
3161         case R_CRIS_16_GOT_TPREL:
3162           /* Fall through.  */
3163
3164           /* For R_CRIS_16_GOTPLT and R_CRIS_32_GOTPLT, we need a GOT
3165              entry only for local symbols.  Unfortunately, we don't know
3166              until later on if there's a version script that forces the
3167              symbol local.  We must have the .rela.got section in place
3168              before we know if the symbol looks global now, so we need
3169              to treat the reloc just like for R_CRIS_16_GOT and
3170              R_CRIS_32_GOT.  */
3171         case R_CRIS_16_GOTPLT:
3172         case R_CRIS_32_GOTPLT:
3173         case R_CRIS_16_GOT:
3174         case R_CRIS_32_GOT:
3175           if (srelgot == NULL
3176               && (h != NULL || info->shared))
3177             {
3178               srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3179               if (srelgot == NULL)
3180                 {
3181                   srelgot = bfd_make_section_with_flags (dynobj,
3182                                                          ".rela.got",
3183                                                          (SEC_ALLOC
3184                                                           | SEC_LOAD
3185                                                           | SEC_HAS_CONTENTS
3186                                                           | SEC_IN_MEMORY
3187                                                           | SEC_LINKER_CREATED
3188                                                           | SEC_READONLY));
3189                   if (srelgot == NULL
3190                       || !bfd_set_section_alignment (dynobj, srelgot, 2))
3191                     return FALSE;
3192                 }
3193             }
3194           break;
3195
3196         default:
3197           break;
3198         }
3199
3200       /* Warn and error for invalid input.  */
3201       switch (r_type)
3202         {
3203         case R_CRIS_32_TPREL:
3204         case R_CRIS_16_TPREL:
3205         case R_CRIS_32_GD:
3206           if (info->shared)
3207             {
3208               (*_bfd_error_handler)
3209                 (_("%B, section %A:\n  relocation %s not valid"
3210                    " in a shared object;"
3211                    " typically an option mixup, recompile with -fPIC"),
3212                  abfd,
3213                  sec,
3214                  cris_elf_howto_table[r_type].name);
3215               /* Don't return FALSE here; we want messages for all of
3216                  these and the error behavior is ungraceful
3217                  anyway.  */
3218             }
3219         default:
3220           break;
3221         }
3222
3223       switch (r_type)
3224         {
3225         case R_CRIS_32_GD:
3226         case R_CRIS_16_GOT_GD:
3227         case R_CRIS_32_GOT_GD:
3228           /* These are requests for tls_index entries, run-time R_CRIS_DTP.  */
3229           got_element_size = 8;
3230           r_symndx_lgot = LGOT_DTP_NDX (r_symndx);
3231           break;
3232
3233         case R_CRIS_16_DTPREL:
3234         case R_CRIS_32_DTPREL:
3235           /* These two just request for the constant-index
3236              module-local tls_index-sized GOT entry, which we add
3237              elsewhere.  */
3238           break;
3239
3240         case R_CRIS_32_GOT_TPREL:
3241         case R_CRIS_16_GOT_TPREL:
3242           r_symndx_lgot = LGOT_TPREL_NDX (r_symndx);
3243
3244           /* Those two relocs also require that a DSO is of type
3245              Initial Exec.  Like other targets, we don't reset this
3246              flag even if the relocs are GC:ed away.  */
3247           if (info->shared)
3248             info->flags |= DF_STATIC_TLS;
3249           break;
3250
3251           /* Let's list the other assembler-generated TLS-relocs too,
3252              just to show that they're not forgotten. */
3253         case R_CRIS_16_TPREL:
3254         case R_CRIS_32_TPREL:
3255         default:
3256           break;
3257         }
3258
3259       switch (r_type)
3260         {
3261         case R_CRIS_16_GOTPLT:
3262         case R_CRIS_32_GOTPLT:
3263           /* Mark that we need a GOT entry if the PLT entry (and its GOT
3264              entry) is eliminated.  We can only do this for a non-local
3265              symbol.  */
3266           if (h != NULL)
3267             {
3268               elf_cris_hash_entry (h)->gotplt_refcount++;
3269               goto handle_gotplt_reloc;
3270             }
3271           /* If h is NULL then this is a local symbol, and we must make a
3272              GOT entry for it, so handle it like a GOT reloc.  */
3273           /* Fall through.  */
3274
3275         case R_CRIS_32_GD:
3276         case R_CRIS_16_GOT_GD:
3277         case R_CRIS_32_GOT_GD:
3278         case R_CRIS_32_GOT_TPREL:
3279         case R_CRIS_16_GOT_TPREL:
3280         case R_CRIS_16_GOT:
3281         case R_CRIS_32_GOT:
3282           /* This symbol requires a global offset table entry.  */
3283           if (h != NULL)
3284             {
3285               if (h->got.refcount == 0)
3286                 {
3287                   /* Make sure this symbol is output as a dynamic symbol.  */
3288                   if (h->dynindx == -1)
3289                     {
3290                       if (!bfd_elf_link_record_dynamic_symbol (info, h))
3291                         return FALSE;
3292                     }
3293                 }
3294
3295               /* Update the sum of reloc counts for this symbol.  */
3296               h->got.refcount++;
3297
3298               switch (r_type)
3299                 {
3300                 case R_CRIS_16_GOT:
3301                 case R_CRIS_32_GOT:
3302                   if (elf_cris_hash_entry (h)->reg_got_refcount == 0)
3303                     {
3304                       /* Allocate space in the .got section.  */
3305                       sgot->size += got_element_size;
3306                       /* Allocate relocation space.  */
3307                       srelgot->size += sizeof (Elf32_External_Rela);
3308                     }
3309                   elf_cris_hash_entry (h)->reg_got_refcount++;
3310                   break;
3311
3312                 case R_CRIS_32_GD:
3313                 case R_CRIS_16_GOT_GD:
3314                 case R_CRIS_32_GOT_GD:
3315                   if (elf_cris_hash_entry (h)->dtp_refcount == 0)
3316                     {
3317                       /* Allocate space in the .got section.  */
3318                       sgot->size += got_element_size;
3319                       /* Allocate relocation space.  */
3320                       srelgot->size += sizeof (Elf32_External_Rela);
3321                     }
3322                   elf_cris_hash_entry (h)->dtp_refcount++;
3323                   break;
3324
3325                 case R_CRIS_32_GOT_TPREL:
3326                 case R_CRIS_16_GOT_TPREL:
3327                   if (elf_cris_hash_entry (h)->tprel_refcount == 0)
3328                     {
3329                       /* Allocate space in the .got section.  */
3330                       sgot->size += got_element_size;
3331                       /* Allocate relocation space.  */
3332                       srelgot->size += sizeof (Elf32_External_Rela);
3333                     }
3334                   elf_cris_hash_entry (h)->tprel_refcount++;
3335                   break;
3336
3337                 default:
3338                   BFD_FAIL ();
3339                   break;
3340                 }
3341             }
3342           else
3343             {
3344               /* This is a global offset table entry for a local symbol.  */
3345               if (local_got_refcounts[r_symndx_lgot] == 0)
3346                 {
3347                   sgot->size += got_element_size;
3348                   if (info->shared)
3349                     {
3350                       /* If we are generating a shared object, we need
3351                          to output a R_CRIS_RELATIVE reloc so that the
3352                          dynamic linker can adjust this GOT entry.
3353                          Similarly for non-regular got entries.  */
3354                       srelgot->size += sizeof (Elf32_External_Rela);
3355                     }
3356                 }
3357               /* Update the reloc-specific count.  */
3358               local_got_refcounts[r_symndx_lgot]++;
3359
3360               /* This one is the sum of all the others.  */
3361               local_got_refcounts[r_symndx]++;
3362             }
3363           break;
3364
3365         case R_CRIS_16_DTPREL:
3366         case R_CRIS_32_DTPREL:
3367         case R_CRIS_32_GOTREL:
3368           /* This reference requires a global offset table.
3369              FIXME: The actual refcount isn't used currently; the .got
3370              section can't be removed if there were any references in the
3371              input.  */
3372           local_got_refcounts[-1]++;
3373           break;
3374
3375         handle_gotplt_reloc:
3376
3377         case R_CRIS_32_PLT_GOTREL:
3378           /* This reference requires a global offset table.  */
3379           local_got_refcounts[-1]++;
3380           /* Fall through.  */
3381
3382         case R_CRIS_32_PLT_PCREL:
3383           /* This symbol requires a procedure linkage table entry.  We
3384              actually build the entry in adjust_dynamic_symbol,
3385              because this might be a case of linking PIC code which is
3386              never referenced by a dynamic object, in which case we
3387              don't need to generate a procedure linkage table entry
3388              after all.  */
3389
3390           /* Beware: if we'd check for visibility of the symbol here
3391              (and not marking the need for a PLT when non-visible), we'd
3392              get into trouble with keeping handling consistent with
3393              regards to relocs found before definition and GOTPLT
3394              handling.  Eliminable PLT entries will be dealt with later
3395              anyway.  */
3396           if (h == NULL)
3397             continue;
3398
3399           h->needs_plt = 1;
3400           h->plt.refcount++;
3401           break;
3402
3403         case R_CRIS_8:
3404         case R_CRIS_16:
3405         case R_CRIS_32:
3406           /* Let's help debug shared library creation.  Any of these
3407              relocs *can* be used in shared libs, but pages containing
3408              them cannot be shared, so they're not appropriate for
3409              common use.  Don't warn for sections we don't care about,
3410              such as debug sections or non-constant sections.  We
3411              can't help tables of (global) function pointers, for
3412              example, though they must be emitted in a (writable) data
3413              section to avoid having impure text sections.  */
3414           if (info->shared
3415               && (sec->flags & SEC_ALLOC) != 0
3416               && (sec->flags & SEC_READONLY) != 0)
3417             {
3418               /* FIXME: How do we make this optionally a warning only?  */
3419               (*_bfd_error_handler)
3420                 (_("%B, section %A:\n  relocation %s should not"
3421                    " be used in a shared object; recompile with -fPIC"),
3422                  abfd,
3423                  sec,
3424                  cris_elf_howto_table[r_type].name);
3425             }
3426           if (h != NULL)
3427             {
3428               h->non_got_ref = 1;
3429
3430               /* Make sure a plt entry is created for this symbol if it
3431                  turns out to be a function defined by a dynamic object.  */
3432               if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3433                 h->plt.refcount++;
3434             }
3435
3436           /* If we are creating a shared library and this is not a local
3437              symbol, we need to copy the reloc into the shared library.
3438              However when linking with -Bsymbolic and this is a global
3439              symbol which is defined in an object we are including in the
3440              link (i.e., DEF_REGULAR is set), then we can resolve the
3441              reloc directly.  At this point we have not seen all the input
3442              files, so it is possible that DEF_REGULAR is not set now but
3443              will be set later (it is never cleared).  In case of a weak
3444              definition, DEF_REGULAR may be cleared later by a strong
3445              definition in a shared library.  We account for that
3446              possibility below by storing information in the relocs_copied
3447              field of the hash table entry.  A similar situation occurs
3448              when creating shared libraries and symbol visibility changes
3449              render the symbol local.  */
3450
3451           /* No need to do anything if we're not creating a shared object.  */
3452           if (! info->shared)
3453             break;
3454
3455           /* We don't need to handle relocs into sections not going into
3456              the "real" output.  */
3457           if ((sec->flags & SEC_ALLOC) == 0)
3458             break;
3459
3460           /* We may need to create a reloc section in the dynobj and made room
3461              for this reloc.  */
3462           if (sreloc == NULL)
3463             {
3464               sreloc = _bfd_elf_make_dynamic_reloc_section
3465                 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3466
3467               if (sreloc == NULL)
3468                 return FALSE;
3469             }
3470
3471           if (sec->flags & SEC_READONLY)
3472             info->flags |= DF_TEXTREL;
3473
3474           sreloc->size += sizeof (Elf32_External_Rela);
3475           break;
3476
3477         case R_CRIS_8_PCREL:
3478         case R_CRIS_16_PCREL:
3479         case R_CRIS_32_PCREL:
3480           if (h != NULL)
3481             {
3482               h->non_got_ref = 1;
3483
3484               /* Make sure a plt entry is created for this symbol if it
3485                  turns out to be a function defined by a dynamic object.  */
3486               if (ELF_ST_VISIBILITY (h->other) == STV_DEFAULT)
3487                 h->plt.refcount++;
3488             }
3489
3490           /* If we are creating a shared library and this is not a local
3491              symbol, we need to copy the reloc into the shared library.
3492              However when linking with -Bsymbolic and this is a global
3493              symbol which is defined in an object we are including in the
3494              link (i.e., DEF_REGULAR is set), then we can resolve the
3495              reloc directly.  At this point we have not seen all the input
3496              files, so it is possible that DEF_REGULAR is not set now but
3497              will be set later (it is never cleared).  In case of a weak
3498              definition, DEF_REGULAR may be cleared later by a strong
3499              definition in a shared library.  We account for that
3500              possibility below by storing information in the relocs_copied
3501              field of the hash table entry.  A similar situation occurs
3502              when creating shared libraries and symbol visibility changes
3503              render the symbol local.  */
3504
3505           /* No need to do anything if we're not creating a shared object.  */
3506           if (! info->shared)
3507             break;
3508
3509           /* We don't need to handle relocs into sections not going into
3510              the "real" output.  */
3511           if ((sec->flags & SEC_ALLOC) == 0)
3512             break;
3513
3514           /* If the symbol is local, then we know already we can
3515              eliminate the reloc.  */
3516           if (h == NULL || ELF_ST_VISIBILITY (h->other) != STV_DEFAULT)
3517             break;
3518
3519           /* If this is with -Bsymbolic and the symbol isn't weak, and
3520              is defined by an ordinary object (the ones we include in
3521              this shared library) then we can also eliminate the
3522              reloc.  See comment above for more eliminable cases which
3523              we can't identify at this time.  */
3524           if (info->symbolic
3525               && h->root.type != bfd_link_hash_defweak
3526               && h->def_regular)
3527             break;
3528
3529           /* We may need to create a reloc section in the dynobj and made room
3530              for this reloc.  */
3531           if (sreloc == NULL)
3532             {
3533               sreloc = _bfd_elf_make_dynamic_reloc_section
3534                 (sec, dynobj, 2, abfd, /*rela?*/ TRUE);
3535
3536               if (sreloc == NULL)
3537                 return FALSE;
3538             }
3539
3540           sreloc->size += sizeof (Elf32_External_Rela);
3541
3542           /* We count the number of PC relative relocations we have
3543              entered for this symbol, so that we can discard them
3544              again if the symbol is later defined by a regular object.
3545              We know that h is really a pointer to an
3546              elf_cris_link_hash_entry.  */
3547           {
3548             struct elf_cris_link_hash_entry *eh;
3549             struct elf_cris_pcrel_relocs_copied *p;
3550
3551             eh = elf_cris_hash_entry (h);
3552
3553             for (p = eh->pcrel_relocs_copied; p != NULL; p = p->next)
3554               if (p->section == sreloc)
3555                 break;
3556
3557             if (p == NULL)
3558               {
3559                 p = ((struct elf_cris_pcrel_relocs_copied *)
3560                      bfd_alloc (dynobj, (bfd_size_type) sizeof *p));
3561                 if (p == NULL)
3562                   return FALSE;
3563                 p->next = eh->pcrel_relocs_copied;
3564                 eh->pcrel_relocs_copied = p;
3565                 p->section = sreloc;
3566                 p->count = 0;
3567                 p->r_type = r_type;
3568               }
3569
3570             ++p->count;
3571           }
3572           break;
3573
3574         /* This relocation describes the C++ object vtable hierarchy.
3575            Reconstruct it for later use during GC.  */
3576         case R_CRIS_GNU_VTINHERIT:
3577           if (!bfd_elf_gc_record_vtinherit (abfd, sec, h, rel->r_offset))
3578             return FALSE;
3579           break;
3580
3581         /* This relocation describes which C++ vtable entries are actually
3582            used.  Record for later use during GC.  */
3583         case R_CRIS_GNU_VTENTRY:
3584           BFD_ASSERT (h != NULL);
3585           if (h != NULL
3586               && !bfd_elf_gc_record_vtentry (abfd, sec, h, rel->r_addend))
3587             return FALSE;
3588           break;
3589
3590         case R_CRIS_16_TPREL:
3591         case R_CRIS_32_TPREL:
3592           /* Already warned above, when necessary.  */
3593           break;
3594
3595         default:
3596           /* Other relocs do not appear here.  */
3597           bfd_set_error (bfd_error_bad_value);
3598           return FALSE;
3599         }
3600     }
3601
3602   return TRUE;
3603 }
3604
3605 /* Set the sizes of the dynamic sections.  */
3606
3607 static bfd_boolean
3608 elf_cris_size_dynamic_sections (output_bfd, info)
3609      bfd *output_bfd ATTRIBUTE_UNUSED;
3610      struct bfd_link_info *info;
3611 {
3612   bfd *dynobj;
3613   asection *s;
3614   bfd_boolean plt;
3615   bfd_boolean relocs;
3616
3617   dynobj = elf_hash_table (info)->dynobj;
3618   BFD_ASSERT (dynobj != NULL);
3619
3620   if (elf_hash_table (info)->dynamic_sections_created)
3621     {
3622       /* Set the contents of the .interp section to the interpreter.  */
3623       if (info->executable)
3624         {
3625           s = bfd_get_section_by_name (dynobj, ".interp");
3626           BFD_ASSERT (s != NULL);
3627           s->size = sizeof ELF_DYNAMIC_INTERPRETER;
3628           s->contents = (unsigned char *) ELF_DYNAMIC_INTERPRETER;
3629         }
3630     }
3631   else
3632     {
3633       /* Adjust all expected GOTPLT uses to use a GOT entry instead.  */
3634       elf_cris_link_hash_traverse (elf_cris_hash_table (info),
3635                                    elf_cris_adjust_gotplt_to_got,
3636                                    (PTR) info);
3637
3638       /* We may have created entries in the .rela.got section.
3639          However, if we are not creating the dynamic sections, we will
3640          not actually use these entries.  Reset the size of .rela.got,
3641          which will cause it to get stripped from the output file
3642          below.  */
3643       s = bfd_get_section_by_name (dynobj, ".rela.got");
3644       if (s != NULL)
3645         s->size = 0;
3646     }
3647
3648   /* If this is a -Bsymbolic shared link, then we need to discard all PC
3649      relative relocs against symbols defined in a regular object.  We
3650      allocated space for them in the check_relocs routine, but we will not
3651      fill them in in the relocate_section routine.  We also discard space
3652      for relocs that have become for local symbols due to symbol
3653      visibility changes.  For programs, we discard space for relocs for
3654      symbols not referenced by any dynamic object.  */
3655   if (info->shared)
3656     elf_cris_link_hash_traverse (elf_cris_hash_table (info),
3657                                  elf_cris_discard_excess_dso_dynamics,
3658                                  (PTR) info);
3659   else
3660     elf_cris_link_hash_traverse (elf_cris_hash_table (info),
3661                                  elf_cris_discard_excess_program_dynamics,
3662                                  (PTR) info);
3663
3664   /* The check_relocs and adjust_dynamic_symbol entry points have
3665      determined the sizes of the various dynamic sections.  Allocate
3666      memory for them.  */
3667   plt = FALSE;
3668   relocs = FALSE;
3669   for (s = dynobj->sections; s != NULL; s = s->next)
3670     {
3671       const char *name;
3672
3673       if ((s->flags & SEC_LINKER_CREATED) == 0)
3674         continue;
3675
3676       /* It's OK to base decisions on the section name, because none
3677          of the dynobj section names depend upon the input files.  */
3678       name = bfd_get_section_name (dynobj, s);
3679
3680       if (strcmp (name, ".plt") == 0)
3681         {
3682           /* Remember whether there is a PLT.  */
3683           plt = s->size != 0;
3684         }
3685       else if (strcmp (name, ".got.plt") == 0)
3686         {
3687           /* The .got.plt contains the .got header as well as the
3688              actual .got.plt contents.  The .got header may contain a
3689              R_CRIS_DTPMOD entry at index 3.  */
3690           s->size += elf_cris_hash_table (info)->dtpmod_refcount != 0
3691             ? 8 : 0;
3692         }
3693       else if (CONST_STRNEQ (name, ".rela"))
3694         {
3695           if (strcmp (name, ".rela.got") == 0
3696               && elf_cris_hash_table (info)->dtpmod_refcount != 0
3697               && info->shared)
3698             s->size += sizeof (Elf32_External_Rela);
3699
3700           if (s->size != 0)
3701             {
3702               /* Remember whether there are any reloc sections other
3703                  than .rela.plt.  */
3704               if (strcmp (name, ".rela.plt") != 0)
3705                   relocs = TRUE;
3706
3707               /* We use the reloc_count field as a counter if we need
3708                  to copy relocs into the output file.  */
3709               s->reloc_count = 0;
3710             }
3711         }
3712       else if (! CONST_STRNEQ (name, ".got")
3713                && strcmp (name, ".dynbss") != 0)
3714         {
3715           /* It's not one of our sections, so don't allocate space.  */
3716           continue;
3717         }
3718
3719       if (s->size == 0)
3720         {
3721           /* If we don't need this section, strip it from the
3722              output file.  This is mostly to handle .rela.bss and
3723              .rela.plt.  We must create both sections in
3724              create_dynamic_sections, because they must be created
3725              before the linker maps input sections to output
3726              sections.  The linker does that before
3727              adjust_dynamic_symbol is called, and it is that
3728              function which decides whether anything needs to go
3729              into these sections.  */
3730           s->flags |= SEC_EXCLUDE;
3731           continue;
3732         }
3733
3734       if ((s->flags & SEC_HAS_CONTENTS) == 0)
3735         continue;
3736
3737       /* Allocate memory for the section contents. We use bfd_zalloc here
3738          in case unused entries are not reclaimed before the section's
3739          contents are written out.  This should not happen, but this way
3740          if it does, we will not write out garbage.  For reloc sections,
3741          this will make entries have the type R_CRIS_NONE.  */
3742       s->contents = (bfd_byte *) bfd_zalloc (dynobj, s->size);
3743       if (s->contents == NULL)
3744         return FALSE;
3745     }
3746
3747   if (elf_hash_table (info)->dynamic_sections_created)
3748     {
3749       /* Add some entries to the .dynamic section.  We fill in the
3750          values later, in elf_cris_finish_dynamic_sections, but we
3751          must add the entries now so that we get the correct size for
3752          the .dynamic section.  The DT_DEBUG entry is filled in by the
3753          dynamic linker and used by the debugger.  */
3754 #define add_dynamic_entry(TAG, VAL) \
3755   _bfd_elf_add_dynamic_entry (info, TAG, VAL)
3756
3757       if (!info->shared)
3758         {
3759           if (!add_dynamic_entry (DT_DEBUG, 0))
3760             return FALSE;
3761         }
3762
3763       if (plt)
3764         {
3765           if (!add_dynamic_entry (DT_PLTGOT, 0)
3766               || !add_dynamic_entry (DT_PLTRELSZ, 0)
3767               || !add_dynamic_entry (DT_PLTREL, DT_RELA)
3768               || !add_dynamic_entry (DT_JMPREL, 0))
3769             return FALSE;
3770         }
3771
3772       if (relocs)
3773         {
3774           if (!add_dynamic_entry (DT_RELA, 0)
3775               || !add_dynamic_entry (DT_RELASZ, 0)
3776               || !add_dynamic_entry (DT_RELAENT, sizeof (Elf32_External_Rela)))
3777             return FALSE;
3778         }
3779
3780       if ((info->flags & DF_TEXTREL) != 0)
3781         {
3782           if (!add_dynamic_entry (DT_TEXTREL, 0))
3783             return FALSE;
3784           info->flags |= DF_TEXTREL;
3785         }
3786     }
3787 #undef add_dynamic_entry
3788
3789   return TRUE;
3790 }
3791
3792 /* This function is called via elf_cris_link_hash_traverse if we are
3793    creating a shared object.  In the -Bsymbolic case, it discards the
3794    space allocated to copy PC relative relocs against symbols which
3795    are defined in regular objects.  For the normal non-symbolic case,
3796    we also discard space for relocs that have become local due to
3797    symbol visibility changes.  We allocated space for them in the
3798    check_relocs routine, but we won't fill them in in the
3799    relocate_section routine.  */
3800
3801 static bfd_boolean
3802 elf_cris_discard_excess_dso_dynamics (h, inf)
3803      struct elf_cris_link_hash_entry *h;
3804      PTR inf;
3805 {
3806   struct elf_cris_pcrel_relocs_copied *s;
3807   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3808
3809   if (h->root.root.type == bfd_link_hash_warning)
3810     h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3811
3812   /* If a symbol has been forced local or we have found a regular
3813      definition for the symbolic link case, then we won't be needing
3814      any relocs.  */
3815   if (h->root.def_regular
3816       && (h->root.forced_local
3817           || info->symbolic))
3818     {
3819       for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3820         s->section->size -= s->count * sizeof (Elf32_External_Rela);
3821
3822       return TRUE;
3823     }
3824
3825   /* If we have accounted for PC-relative relocs for read-only
3826      sections, now is the time to warn for them.  We can't do it in
3827      cris_elf_check_relocs, because we don't know the status of all
3828      symbols at that time (and it's common to force symbols local
3829      late).  */
3830
3831   for (s = h->pcrel_relocs_copied; s != NULL; s = s->next)
3832     {
3833       BFD_ASSERT ((s->section->flags & SEC_READONLY) != 0);
3834
3835       /* FIXME: How do we make this optionally a warning only?  */
3836       (*_bfd_error_handler)
3837         (_("%B, section `%A', to symbol `%s':\n"
3838            "  relocation %s should not be used"
3839            " in a shared object; recompile with -fPIC"),
3840          s->section->owner,
3841          s->section,
3842          h->root.root.root.string,
3843          cris_elf_howto_table[s->r_type].name);
3844
3845       info->flags |= DF_TEXTREL;
3846     }
3847
3848   return TRUE;
3849 }
3850
3851 /* This function is called via elf_cris_link_hash_traverse if we are *not*
3852    creating a shared object.  We discard space for relocs for symbols put
3853    in the .got, but which we found we do not have to resolve at run-time.  */
3854
3855 static bfd_boolean
3856 elf_cris_discard_excess_program_dynamics (h, inf)
3857      struct elf_cris_link_hash_entry *h;
3858      PTR inf;
3859 {
3860   struct bfd_link_info *info = (struct bfd_link_info *) inf;
3861
3862   if (h->root.root.type == bfd_link_hash_warning)
3863     h = (struct elf_cris_link_hash_entry *) h->root.root.u.i.link;
3864
3865   /* If we're not creating a shared library and have a symbol which is
3866      referred to by .got references, but the symbol is defined locally,
3867      (or rather, not defined by a DSO) then lose the reloc for the .got
3868      (don't allocate room for it).  Likewise for relocs for something
3869      for which we create a PLT.  */
3870   if (!h->root.def_dynamic
3871       || h->root.plt.refcount > 0)
3872     {
3873       if (h->reg_got_refcount > 0
3874           /* The size of this section is only valid and in sync with the
3875              various reference counts if we do dynamic; don't decrement it
3876              otherwise.  */
3877           && elf_hash_table (info)->dynamic_sections_created)
3878         {
3879           bfd *dynobj = elf_hash_table (info)->dynobj;
3880           asection *srelgot;
3881
3882           BFD_ASSERT (dynobj != NULL);
3883
3884           srelgot = bfd_get_section_by_name (dynobj, ".rela.got");
3885
3886           BFD_ASSERT (srelgot != NULL);
3887
3888           srelgot->size -= sizeof (Elf32_External_Rela);
3889         }
3890
3891       /* If the locally-defined symbol isn't used by a DSO, then we don't
3892          have to export it as a dynamic symbol.  This was already done for
3893          functions; doing this for all symbols would presumably not
3894          introduce new problems.  Of course we don't do this if we're
3895          exporting all dynamic symbols.  */
3896       if (! info->export_dynamic
3897           && h->root.dynindx != -1
3898           && !h->root.def_dynamic
3899           && !h->root.ref_dynamic)
3900         {
3901           h->root.dynindx = -1;
3902           _bfd_elf_strtab_delref (elf_hash_table (info)->dynstr,
3903                                   h->root.dynstr_index);
3904         }
3905     }
3906
3907   return TRUE;
3908 }
3909
3910 /* Reject a file depending on presence and expectation of prefixed
3911    underscores on symbols.  */
3912
3913 static bfd_boolean
3914 cris_elf_object_p (abfd)
3915      bfd *abfd;
3916 {
3917   if (! cris_elf_set_mach_from_flags (abfd, elf_elfheader (abfd)->e_flags))
3918     return FALSE;
3919
3920   if ((elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE))
3921     return (bfd_get_symbol_leading_char (abfd) == '_');
3922   else
3923     return (bfd_get_symbol_leading_char (abfd) == 0);
3924 }
3925
3926 /* Mark presence or absence of leading underscore.  Set machine type
3927    flags from mach type.  */
3928
3929 static void
3930 cris_elf_final_write_processing (abfd, linker)
3931      bfd *abfd;
3932      bfd_boolean linker ATTRIBUTE_UNUSED;
3933 {
3934   unsigned long e_flags = elf_elfheader (abfd)->e_flags;
3935
3936   e_flags &= ~EF_CRIS_UNDERSCORE;
3937   if (bfd_get_symbol_leading_char (abfd) == '_')
3938     e_flags |= EF_CRIS_UNDERSCORE;
3939
3940   switch (bfd_get_mach (abfd))
3941     {
3942     case bfd_mach_cris_v0_v10:
3943       e_flags |= EF_CRIS_VARIANT_ANY_V0_V10;
3944       break;
3945
3946     case bfd_mach_cris_v10_v32:
3947       e_flags |= EF_CRIS_VARIANT_COMMON_V10_V32;
3948       break;
3949
3950     case bfd_mach_cris_v32:
3951       e_flags |= EF_CRIS_VARIANT_V32;
3952       break;
3953
3954     default:
3955       _bfd_abort (__FILE__, __LINE__,
3956                   _("Unexpected machine number"));
3957     }
3958
3959   elf_elfheader (abfd)->e_flags = e_flags;
3960 }
3961
3962 /* Set the mach type from e_flags value.  */
3963
3964 static bfd_boolean
3965 cris_elf_set_mach_from_flags (abfd, flags)
3966      bfd *abfd;
3967      unsigned long flags;
3968 {
3969   switch (flags & EF_CRIS_VARIANT_MASK)
3970     {
3971     case EF_CRIS_VARIANT_ANY_V0_V10:
3972       bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v0_v10);
3973       break;
3974
3975     case EF_CRIS_VARIANT_V32:
3976       bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v32);
3977       break;
3978
3979     case EF_CRIS_VARIANT_COMMON_V10_V32:
3980       bfd_default_set_arch_mach (abfd, bfd_arch_cris, bfd_mach_cris_v10_v32);
3981       break;
3982
3983     default:
3984       /* Since we don't recognize them, we obviously can't support them
3985          with this code; we'd have to require that all future handling
3986          would be optional.  */
3987       bfd_set_error (bfd_error_wrong_format);
3988       return FALSE;
3989     }
3990
3991   return TRUE;
3992 }
3993
3994 /* Display the flags field.  */
3995
3996 static bfd_boolean
3997 cris_elf_print_private_bfd_data (abfd, ptr)
3998      bfd *abfd;
3999      PTR ptr;
4000 {
4001   FILE *file = (FILE *) ptr;
4002
4003   BFD_ASSERT (abfd != NULL && ptr != NULL);
4004
4005   _bfd_elf_print_private_bfd_data (abfd, ptr);
4006
4007   fprintf (file, _("private flags = %lx:"), elf_elfheader (abfd)->e_flags);
4008
4009   if (elf_elfheader (abfd)->e_flags & EF_CRIS_UNDERSCORE)
4010     fprintf (file, _(" [symbols have a _ prefix]"));
4011   if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
4012       == EF_CRIS_VARIANT_COMMON_V10_V32)
4013     fprintf (file, _(" [v10 and v32]"));
4014   if ((elf_elfheader (abfd)->e_flags & EF_CRIS_VARIANT_MASK)
4015       == EF_CRIS_VARIANT_V32)
4016     fprintf (file, _(" [v32]"));
4017
4018   fputc ('\n', file);
4019   return TRUE;
4020 }
4021
4022 /* Don't mix files with and without a leading underscore.  */
4023
4024 static bfd_boolean
4025 cris_elf_merge_private_bfd_data (ibfd, obfd)
4026      bfd *ibfd;
4027      bfd *obfd;
4028 {
4029   int imach, omach;
4030
4031   if (! _bfd_generic_verify_endian_match (ibfd, obfd))
4032     return FALSE;
4033
4034   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4035       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4036     return TRUE;
4037
4038   imach = bfd_get_mach (ibfd);
4039
4040   if (! elf_flags_init (obfd))
4041     {
4042       /* This happens when ld starts out with a 'blank' output file.  */
4043       elf_flags_init (obfd) = TRUE;
4044
4045       /* We ignore the linker-set mach, and instead set it according to
4046          the first input file.  This would also happen if we could
4047          somehow filter out the OUTPUT_ARCH () setting from elf.sc.
4048          This allows us to keep the same linker config across
4049          cris(v0..v10) and crisv32.  The drawback is that we can't force
4050          the output type, which might be a sane thing to do for a
4051          v10+v32 compatibility object.  */
4052       if (! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
4053         return FALSE;
4054     }
4055
4056   if (bfd_get_symbol_leading_char (ibfd)
4057       != bfd_get_symbol_leading_char (obfd))
4058     {
4059       (*_bfd_error_handler)
4060         (bfd_get_symbol_leading_char (ibfd) == '_'
4061          ? _("%B: uses _-prefixed symbols, but writing file with non-prefixed symbols")
4062          : _("%B: uses non-prefixed symbols, but writing file with _-prefixed symbols"),
4063          ibfd);
4064       bfd_set_error (bfd_error_bad_value);
4065       return FALSE;
4066     }
4067
4068   omach = bfd_get_mach (obfd);
4069
4070   if (imach != omach)
4071     {
4072       /* We can get an incompatible combination only if either is
4073          bfd_mach_cris_v32, and the other one isn't compatible.  */
4074       if ((imach == bfd_mach_cris_v32
4075            && omach != bfd_mach_cris_v10_v32)
4076           || (omach == bfd_mach_cris_v32
4077               && imach != bfd_mach_cris_v10_v32))
4078         {
4079           (*_bfd_error_handler)
4080             ((imach == bfd_mach_cris_v32)
4081              ? _("%B contains CRIS v32 code, incompatible"
4082                  " with previous objects")
4083              : _("%B contains non-CRIS-v32 code, incompatible"
4084                  " with previous objects"),
4085              ibfd);
4086           bfd_set_error (bfd_error_bad_value);
4087           return FALSE;
4088         }
4089
4090       /* We don't have to check the case where the input is compatible
4091          with v10 and v32, because the output is already known to be set
4092          to the other (compatible) mach.  */
4093       if (omach == bfd_mach_cris_v10_v32
4094           && ! bfd_set_arch_mach (obfd, bfd_arch_cris, imach))
4095         return FALSE;
4096     }
4097
4098   return TRUE;
4099 }
4100
4101 /* Do side-effects of e_flags copying to obfd.  */
4102
4103 static bfd_boolean
4104 cris_elf_copy_private_bfd_data (ibfd, obfd)
4105      bfd *ibfd;
4106      bfd *obfd;
4107 {
4108   /* Call the base function.  */
4109   if (!_bfd_elf_copy_private_bfd_data (ibfd, obfd))
4110     return FALSE;
4111
4112   /* If output is big-endian for some obscure reason, stop here.  */
4113   if (_bfd_generic_verify_endian_match (ibfd, obfd) == FALSE)
4114     return FALSE;
4115
4116   if (bfd_get_flavour (ibfd) != bfd_target_elf_flavour
4117       || bfd_get_flavour (obfd) != bfd_target_elf_flavour)
4118     return TRUE;
4119
4120   /* Do what we really came here for.  */
4121   return bfd_set_arch_mach (obfd, bfd_arch_cris, bfd_get_mach (ibfd));
4122 }
4123
4124 static enum elf_reloc_type_class
4125 elf_cris_reloc_type_class (rela)
4126      const Elf_Internal_Rela *rela;
4127 {
4128   enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rela->r_info);
4129   switch (r_type)
4130     {
4131     case R_CRIS_RELATIVE:
4132       return reloc_class_relative;
4133     case R_CRIS_JUMP_SLOT:
4134       return reloc_class_plt;
4135     case R_CRIS_COPY:
4136       return reloc_class_copy;
4137     default:
4138       return reloc_class_normal;
4139     }
4140 }
4141
4142 /* The elf_backend_got_elt_size worker.  For one symbol, we can have up to
4143    two GOT entries from three types with two different sizes.  We handle
4144    it as a single entry, so we can use the regular offset-calculation
4145    machinery.  */
4146
4147 static bfd_vma
4148 elf_cris_got_elt_size (bfd *abfd ATTRIBUTE_UNUSED,
4149                        struct bfd_link_info *info ATTRIBUTE_UNUSED,
4150                        struct elf_link_hash_entry *hr,
4151                        bfd *ibfd,
4152                        unsigned long symndx)
4153 {
4154   struct elf_link_hash_entry *h = (struct elf_link_hash_entry *) hr;
4155   bfd_vma eltsiz = 0;
4156
4157   /* We may have one regular GOT entry or up to two TLS GOT
4158      entries.  */
4159   if (h == NULL)
4160     {
4161       Elf_Internal_Shdr *symtab_hdr = &elf_tdata (ibfd)->symtab_hdr;
4162       bfd_signed_vma *local_got_refcounts = elf_local_got_refcounts (ibfd);
4163
4164       BFD_ASSERT (local_got_refcounts != NULL);
4165
4166       if (local_got_refcounts[LGOT_REG_NDX (symndx)] > 0)
4167         {
4168           /* We can't have a variable referred to both as a regular
4169              variable and through TLS relocs.  */
4170           BFD_ASSERT (local_got_refcounts[LGOT_DTP_NDX (symndx)] == 0
4171                       && local_got_refcounts[LGOT_TPREL_NDX (symndx)] == 0);
4172           return 4;
4173         }
4174
4175       if (local_got_refcounts[LGOT_DTP_NDX (symndx)] > 0)
4176         eltsiz += 8;
4177
4178       if (local_got_refcounts[LGOT_TPREL_NDX (symndx)] > 0)
4179         eltsiz += 4;
4180     }
4181   else
4182     {
4183       struct elf_cris_link_hash_entry *hh = elf_cris_hash_entry (h);
4184       if (hh->reg_got_refcount > 0)
4185         {
4186           /* The actual error-on-input is emitted elsewhere.  */
4187           BFD_ASSERT (hh->dtp_refcount == 0 && hh->tprel_refcount == 0);
4188           return 4;
4189         }
4190
4191       if (hh->dtp_refcount > 0)
4192         eltsiz += 8;
4193
4194       if (hh->tprel_refcount > 0)
4195         eltsiz += 4;
4196     }
4197
4198   /* We're only called when h->got.refcount is non-zero, so we must
4199      have a non-zero size.  */
4200   BFD_ASSERT (eltsiz != 0);
4201   return eltsiz;
4202 }
4203 \f
4204 #define ELF_ARCH                bfd_arch_cris
4205 #define ELF_MACHINE_CODE        EM_CRIS
4206 #define ELF_MAXPAGESIZE         0x2000
4207
4208 #define TARGET_LITTLE_SYM       bfd_elf32_cris_vec
4209 #define TARGET_LITTLE_NAME      "elf32-cris"
4210 #define elf_symbol_leading_char 0
4211
4212 #define elf_info_to_howto_rel                   NULL
4213 #define elf_info_to_howto                       cris_info_to_howto_rela
4214 #define elf_backend_relocate_section            cris_elf_relocate_section
4215 #define elf_backend_gc_mark_hook                cris_elf_gc_mark_hook
4216 #define elf_backend_gc_sweep_hook               cris_elf_gc_sweep_hook
4217 #define elf_backend_check_relocs                cris_elf_check_relocs
4218 #define elf_backend_grok_prstatus               cris_elf_grok_prstatus
4219 #define elf_backend_grok_psinfo                 cris_elf_grok_psinfo
4220
4221 #define elf_backend_can_gc_sections             1
4222 #define elf_backend_can_refcount                1
4223
4224 #define elf_backend_object_p                    cris_elf_object_p
4225 #define elf_backend_final_write_processing \
4226         cris_elf_final_write_processing
4227 #define bfd_elf32_bfd_print_private_bfd_data \
4228         cris_elf_print_private_bfd_data
4229 #define bfd_elf32_bfd_merge_private_bfd_data \
4230         cris_elf_merge_private_bfd_data
4231 #define bfd_elf32_bfd_copy_private_bfd_data \
4232         cris_elf_copy_private_bfd_data
4233
4234 #define bfd_elf32_bfd_reloc_type_lookup         cris_reloc_type_lookup
4235 #define bfd_elf32_bfd_reloc_name_lookup cris_reloc_name_lookup
4236
4237 #define bfd_elf32_bfd_link_hash_table_create \
4238         elf_cris_link_hash_table_create
4239 #define elf_backend_adjust_dynamic_symbol \
4240         elf_cris_adjust_dynamic_symbol
4241 #define elf_backend_size_dynamic_sections \
4242         elf_cris_size_dynamic_sections
4243 #define elf_backend_init_index_section          _bfd_elf_init_1_index_section
4244 #define elf_backend_finish_dynamic_symbol \
4245         elf_cris_finish_dynamic_symbol
4246 #define elf_backend_finish_dynamic_sections \
4247         elf_cris_finish_dynamic_sections
4248 #define elf_backend_create_dynamic_sections \
4249         _bfd_elf_create_dynamic_sections
4250 #define bfd_elf32_bfd_final_link \
4251         bfd_elf_gc_common_final_link
4252 #define elf_backend_hide_symbol                 elf_cris_hide_symbol
4253 #define elf_backend_reloc_type_class            elf_cris_reloc_type_class
4254
4255 #define elf_backend_want_got_plt        1
4256 #define elf_backend_plt_readonly        1
4257 #define elf_backend_want_plt_sym        0
4258 #define elf_backend_got_header_size     12
4259 #define elf_backend_got_elt_size elf_cris_got_elt_size
4260
4261 /* Later, we my want to optimize RELA entries into REL entries for dynamic
4262    linking and libraries (if it's a win of any significance).  Until then,
4263    take the easy route.  */
4264 #define elf_backend_may_use_rel_p 0
4265 #define elf_backend_may_use_rela_p 1
4266 #define elf_backend_rela_normal         1
4267
4268 #include "elf32-target.h"
4269
4270 #undef TARGET_LITTLE_SYM
4271 #undef TARGET_LITTLE_NAME
4272 #undef elf_symbol_leading_char
4273
4274 #define TARGET_LITTLE_SYM bfd_elf32_us_cris_vec
4275 #define TARGET_LITTLE_NAME "elf32-us-cris"
4276 #define elf_symbol_leading_char '_'
4277 #undef elf32_bed
4278 #define elf32_bed elf32_us_cris_bed
4279
4280 #include "elf32-target.h"