Subversion Repositories openrisc_2011-10-31

#include <limits.h>

  /* We don't handle these in any special manner and cross-format

     linking is not supported; just recognize them enough to pass them

     around.  FIXME: do the same for most PIC relocs and add sanity

     tests to actually refuse gracefully to handle these and PIC

     relocs for cross-format linking.  */

#define TLSHOWTO32(name) \

 HOWTO (name, 0, 2, 32, FALSE, 0, complain_overflow_bitfield, \

        bfd_elf_generic_reloc, #name, FALSE, 0, 0xffffffff, FALSE)

#define TLSHOWTO16X(name, X)         \

 HOWTO (name, 0, 1, 16, FALSE, 0, complain_overflow_ ## X, \

        bfd_elf_generic_reloc, #name, FALSE, 0, 0xffff, FALSE)

#define TLSHOWTO16(name) TLSHOWTO16X(name, unsigned)

#define TLSHOWTO16S(name) TLSHOWTO16X(name, signed)

  TLSHOWTO32 (R_CRIS_32_GOT_GD),

  TLSHOWTO16 (R_CRIS_16_GOT_GD),

  TLSHOWTO32 (R_CRIS_32_GD),

  TLSHOWTO32 (R_CRIS_DTP),

  TLSHOWTO32 (R_CRIS_32_DTPREL),

  TLSHOWTO16S (R_CRIS_16_DTPREL),

  TLSHOWTO32 (R_CRIS_32_GOT_TPREL),

  TLSHOWTO16S (R_CRIS_16_GOT_TPREL),

  TLSHOWTO32 (R_CRIS_32_TPREL),

  TLSHOWTO16S (R_CRIS_16_TPREL),

  TLSHOWTO32 (R_CRIS_DTPMOD),

  TLSHOWTO32 (R_CRIS_32_IE)

  { BFD_RELOC_CRIS_32_GOT_GD,   R_CRIS_32_GOT_GD },

  { BFD_RELOC_CRIS_16_GOT_GD,   R_CRIS_16_GOT_GD },

  { BFD_RELOC_CRIS_32_GD,       R_CRIS_32_GD },

  { BFD_RELOC_CRIS_DTP, R_CRIS_DTP },

  { BFD_RELOC_CRIS_32_DTPREL,   R_CRIS_32_DTPREL },

  { BFD_RELOC_CRIS_16_DTPREL,   R_CRIS_16_DTPREL },

  { BFD_RELOC_CRIS_32_GOT_TPREL, R_CRIS_32_GOT_TPREL },

  { BFD_RELOC_CRIS_16_GOT_TPREL, R_CRIS_16_GOT_TPREL },

  { BFD_RELOC_CRIS_32_TPREL,    R_CRIS_32_TPREL },

  { BFD_RELOC_CRIS_16_TPREL,    R_CRIS_16_TPREL },

  { BFD_RELOC_CRIS_DTPMOD,      R_CRIS_DTPMOD },

  { BFD_RELOC_CRIS_32_IE,       R_CRIS_32_IE }

  /* Example of reloc being copied, for message.  */

  enum elf_cris_reloc_type r_type;

  /* The root.got.refcount is the sum of the regular reference counts

     (this) and those members below.  We have to keep a separate count

     to track when we've found the first (or last) reference to a

     regular got entry.  The offset is in root.got.offset.  */

  bfd_signed_vma reg_got_refcount;

  /* Similar to the above, the number of reloc references to this

     symbols that need a R_CRIS_32_TPREL slot.  The offset is in

     root.got.offset, because this and .dtp_refcount can't validly

     happen when there's also a regular GOT entry; that's invalid

     input for which an error is emitted.  */

  bfd_signed_vma tprel_refcount;

  /* Similar to the above, the number of reloc references to this

     symbols that need a R_CRIS_DTP slot.  The offset is in

     root.got.offset; plus 4 if .tprel_refcount > 0.  */

  bfd_signed_vma dtp_refcount;

/* The local_got_refcounts and local_got_offsets are a multiple of

   LSNUM in size, namely LGOT_ALLOC_NELTS_FOR(LSNUM) (plus one for the

   refcount for GOT itself, see code), with the summary / group offset

   for local symbols located at offset N, reference counts for

   ordinary (address) relocs at offset N + LSNUM, for R_CRIS_DTP

   relocs at offset N + 2*LSNUM, and for R_CRIS_32_TPREL relocs at N +

   3*LSNUM.  */

#define LGOT_REG_NDX(x) ((x) + symtab_hdr->sh_info)

#define LGOT_DTP_NDX(x) ((x) + 2 * symtab_hdr->sh_info)

#define LGOT_TPREL_NDX(x) ((x) + 3 * symtab_hdr->sh_info)

#define LGOT_ALLOC_NELTS_FOR(x) ((x) * 4)

  /* The number of R_CRIS_32_DTPREL and R_CRIS_16_DTPREL that have

     been seen for any input; if != 0, then the constant-offset

     R_CRIS_DTPMOD is needed for this DSO/executable.  This turns

     negative at relocation, so that we don't need an extra flag for

     when the reloc is output.  */

  bfd_signed_vma dtpmod_refcount;

/* Get the CRIS ELF linker hash entry from a regular hash entry (the

   "parent class").  The .root reference is just a simple type

   check on the argument.  */

#define elf_cris_hash_entry(p) \

 ((struct elf_cris_link_hash_entry *) (&(p)->root))

      ret->dtp_refcount = 0;

      ret->tprel_refcount = 0;

      ret->reg_got_refcount = 0;

  /* We haven't seen any R_CRIS_nn_GOT_TPREL initially.  */

  ret->dtpmod_refcount = 0;

  enum elf_cris_reloc_type r_type = ELF32_R_TYPE (rel->r_info);

/* The number of errors left before we stop outputting reloc-specific

   explanatory messages.  By coincidence, this works nicely together

   with the default number of messages you'll get from LD about

   "relocation truncated to fit" messages before you get an

   "additional relocation overflows omitted from the output".  */

static int additional_relocation_error_msg_count = 10;

  asection *srelgot;

  srelgot = NULL;

          symname = h->root.root.string;

                            = bfd_get_section_by_name (dynobj, ".rela.got");

                        BFD_ASSERT (srelgot != NULL);

              || h->dynindx == -1)

                       /* For now, undefined weak symbols with non-default

                          visibility (yielding 0), like exception info for

                          discarded sections, will get a R_CRIS_NONE

                          relocation rather than no relocation, because we

                          notice too late that the symbol doesn't need a

                          relocation.  */

                       || (h != NULL

                           && h->root.type == bfd_link_hash_undefweak

                           && ELF_ST_VISIBILITY (h->other) != STV_DEFAULT))

        case R_CRIS_16_DTPREL:

        case R_CRIS_32_DTPREL:

          /* This relocation must only be performed against local

             symbols, or to sections that are not loadable.  It's also

             ok when we link a program and the symbol is defined in an

             ordinary (non-DSO) object (if it's undefined there, we've

             already seen an error).  */

          if (h != NULL

              && (input_section->flags & SEC_ALLOC) != 0

              && ELF_ST_VISIBILITY (h->other) == STV_DEFAULT

              && (info->shared

                  || (!h->def_regular

                      && h->root.type != bfd_link_hash_undefined)))

            {

              (*_bfd_error_handler)

                ((h->root.type == bfd_link_hash_undefined)

                 /* We shouldn't get here for GCC-emitted code.  */

                 ? _("%B, section %A: relocation %s has an undefined"

                     " reference to `%s', perhaps a declaration mixup?")

                 : ("%B, section %A: relocation %s is"

                     " not allowed for `%s', a global symbol with default"

                     " visibility, perhaps a declaration mixup?"),

                 input_bfd,

                 input_section,

                 cris_elf_howto_table[r_type].name,

                 symname != NULL && symname[0] != '\0'

                 ? symname : _("[whose name is lost]"));

              bfd_set_error (bfd_error_bad_value);

              return FALSE;

            }

          BFD_ASSERT ((input_section->flags & SEC_ALLOC) == 0

                      || elf_cris_hash_table (info)->dtpmod_refcount != 0);

          /* Fill in a R_CRIS_DTPMOD reloc at offset 3 if we haven't

             already done so.  Note that we do this in .got.plt, not

             in .got, as .got.plt contains the first part, still the

             reloc is against .got, because the linker script directs

             (is required to direct) them both into .got.  */

          if (elf_cris_hash_table (info)->dtpmod_refcount > 0

              && (input_section->flags & SEC_ALLOC) != 0)

            {

              asection *sgotplt = bfd_get_section_by_name (dynobj, ".got.plt");

              BFD_ASSERT (sgotplt != NULL);

              if (info->shared)

                {

                  Elf_Internal_Rela outrel;

                  bfd_byte *loc;

                  if (srelgot == NULL)

                    srelgot = bfd_get_section_by_name (dynobj, ".rela.got");

                  BFD_ASSERT (srelgot != NULL);

                  loc = srelgot->contents;

                  loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);

                  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 12);

                  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16);

                  outrel.r_offset = (sgotplt->output_section->vma

                                     + sgotplt->output_offset

                                     + 12);

                  outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTPMOD);

                  outrel.r_addend = 0;

                  bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);

                }

              else

                {

                  /* For an executable, the GOT entry contents is known.  */

                  bfd_put_32 (output_bfd, (bfd_vma) 1, sgotplt->contents + 12);

                  bfd_put_32 (output_bfd, (bfd_vma) 0, sgotplt->contents + 16);

                }

              /* Reverse the sign to mark that we've emitted the

                 required GOT entry.  */

              elf_cris_hash_table (info)->dtpmod_refcount

                = -elf_cris_hash_table (info)->dtpmod_refcount;

            }

          /* The relocation is the offset from the start of the module

             TLS block to the (local) symbol.  */

          relocation -= elf_hash_table (info)->tls_sec == NULL

            ? 0 : elf_hash_table (info)->tls_sec->vma;

          break;

        case R_CRIS_32_GD:

          if (info->shared)

            {

              bfd_set_error (bfd_error_invalid_operation);

              /* We've already informed in cris_elf_check_relocs that

                 this is an error.  */

              return FALSE;

            }

          /* Fall through.  */

        case R_CRIS_16_GOT_GD:

        case R_CRIS_32_GOT_GD:

          if (rel->r_addend != 0)

            {

              /* We can't do anything for a relocation which is against a

                 symbol *plus offset*.  The GOT holds relocations for

                 symbols.  Make this an error; the compiler isn't allowed

                 to pass us these kinds of things.  */

              (*_bfd_error_handler)

                (_("%B, section %A: relocation %s with non-zero addend %d"

                   " against symbol `%s'"),

                 input_bfd,

                 input_section,

                 cris_elf_howto_table[r_type].name,

                 rel->r_addend,

                 symname[0] != '\0' ? symname : _("[whose name is lost]"));

              bfd_set_error (bfd_error_bad_value);

              return FALSE;

            }

          if (!info->shared

              && (h == NULL || h->def_regular || ELF_COMMON_DEF_P (h)))

            {

              /* Known contents of the GOT.  */

              bfd_vma off;

              /* The symbol is defined in the program, so just write

                 (1, known_tpoffset) into the GOT.  */

              relocation -= elf_hash_table (info)->tls_sec->vma;

              if (h != NULL)

                {

                  off = elf_cris_hash_entry (h)->tprel_refcount > 0

                    ? h->got.offset + 4 : h->got.offset;

                }

              else

                {

                  off = local_got_offsets[r_symndx];

                  if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)])

                    off += 4;

                }

              /* We use bit 1 of the offset as a flag for GOT entry with

                 the R_CRIS_DTP reloc, setting it when we've emitted the

                 GOT entry and reloc.  Bit 0 is used for R_CRIS_32_TPREL

                 relocs.  */

              if ((off & 2) == 0)

                {

                  off &= ~3;

                  if (h != NULL)

                    h->got.offset |= 2;

                  else

                    local_got_offsets[r_symndx] |= 2;

                  bfd_put_32 (output_bfd, 1, sgot->contents + off);

                  bfd_put_32 (output_bfd, relocation, sgot->contents + off + 4);

                }

              else

                off &= ~3;

              relocation = sgot->output_offset + off

                + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0);

            }

          else

            {

              /* Not all parts of the GOT entry are known; emit a real

                 relocation.  */

              bfd_vma off;

              if (h != NULL)

                off = elf_cris_hash_entry (h)->tprel_refcount > 0

                  ? h->got.offset + 4 : h->got.offset;

              else

                {

                  off = local_got_offsets[r_symndx];

                  if (local_got_offsets[LGOT_TPREL_NDX (r_symndx)])

                    off += 4;

                }

              /* See above re bit 1 and bit 0 usage.  */

              if ((off & 2) == 0)

                {

                  Elf_Internal_Rela outrel;

                  bfd_byte *loc;

                  off &= ~3;

                  if (h != NULL)

                    h->got.offset |= 2;

                  else

                    local_got_offsets[r_symndx] |= 2;

                  /* Clear the target contents of the GOT (just as a

                     gesture; it's already cleared on allocation): this

                     relocation is not like the other dynrelocs.  */

                  bfd_put_32 (output_bfd, 0, sgot->contents + off);

                  bfd_put_32 (output_bfd, 0, sgot->contents + off + 4);

                  if (srelgot == NULL)

                    srelgot = bfd_get_section_by_name (dynobj, ".rela.got");

                  BFD_ASSERT (srelgot != NULL);

                  if (h != NULL && h->dynindx != -1)

                    {

                      outrel.r_info = ELF32_R_INFO (h->dynindx, R_CRIS_DTP);

                      relocation = 0;

                    }

                  else

                    {

                      outrel.r_info = ELF32_R_INFO (0, R_CRIS_DTP);

                      /* NULL if we had an error.  */

                      relocation -= elf_hash_table (info)->tls_sec == NULL

                        ? 0 : elf_hash_table (info)->tls_sec->vma;

                    }

                  outrel.r_offset = (sgot->output_section->vma

                                     + sgot->output_offset

                                     + off);

                  outrel.r_addend = relocation;

                  loc = srelgot->contents;

                  loc += srelgot->reloc_count++ * sizeof (Elf32_External_Rela);

                  /* NULL if we had an error.  */

                  if (srelgot->contents != NULL)

                    bfd_elf32_swap_reloca_out (output_bfd, &outrel, loc);

                }

              else

                off &= ~3;

              relocation = sgot->output_offset + off

                + (r_type == R_CRIS_32_GD ? sgot->output_section->vma : 0);

            }

          /* The GOT-relative offset to the GOT entry is the

             relocation, or for R_CRIS_32_GD, the actual address of

             the GOT entry.  */

          break;

        case R_CRIS_32_IE:

          if (info->shared)

            {

              bfd_set_error (bfd_error_invalid_operation);

              /* We've already informed in cris_elf_check_relocs that

                 this is an error.  */

              return FALSE;

            }

          /* Fall through.  */

        case R_CRIS_32_GOT_TPREL:

        case R_CRIS_16_GOT_TPREL:

          if (rel->r_addend != 0)

            {

              /* We can't do anything for a relocation which is

                 against a symbol *plus offset*.  GOT holds

                 relocations for symbols.  Make this an error; the

                 compiler isn't allowed to pass us these kinds of

                 things.  */

              (*_bfd_error_handler)

                (_("%B, section %A: relocation %s with non-zero addend %d"

                   " against symbol `%s'"),

                 input_bfd,

                 input_section,

                 cris_elf_howto_table[r_type].name,

                 rel->r_addend,

                 symname[0] != '\0' ? symname : _("[whose name is lost]"));

              bfd_set_error (bfd_error_bad_value);

              return FALSE;

            }

          if (!info->shared && (h == NULL || h->def_regular))

            {

              /* Known contents of the GOT.  */

              bfd_vma off;

              /* The symbol is defined in the program, so just write