bfd/elf32-cris.c

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