+ /* A 12-bit signed operand with the offset from the module base
+ address to the thread-local symbol address. */
+ HOWTO (R_FRV_TLSMOFF12, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 12, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_signed, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSMOFF12", /* name */
+ FALSE, /* partial_inplace */
+ 0xfff, /* src_mask */
+ 0xfff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* The upper 16 bits of the offset from the module base address to
+ the thread-local symbol address. */
+ HOWTO (R_FRV_TLSMOFFHI, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 16, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSMOFFHI", /* name */
+ FALSE, /* partial_inplace */
+ 0xffff, /* src_mask */
+ 0xffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* The lower 16 bits of the offset from the module base address to
+ the thread-local symbol address. */
+ HOWTO (R_FRV_TLSMOFFLO, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 16, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSMOFFLO", /* name */
+ FALSE, /* partial_inplace */
+ 0xffff, /* src_mask */
+ 0xffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* A 12-bit signed operand with the GOT offset for the TLSOFF entry
+ for a symbol. */
+ HOWTO (R_FRV_GOTTLSOFF12, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 12, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_signed, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_GOTTLSOFF12", /* name */
+ FALSE, /* partial_inplace */
+ 0xfff, /* src_mask */
+ 0xfff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* The upper 16 bits of the GOT offset for the TLSOFF entry for a
+ symbol. */
+ HOWTO (R_FRV_GOTTLSOFFHI, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 16, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_GOTTLSOFFHI", /* name */
+ FALSE, /* partial_inplace */
+ 0xffff, /* src_mask */
+ 0xffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* The lower 16 bits of the GOT offset for the TLSOFF entry for a
+ symbol. */
+ HOWTO (R_FRV_GOTTLSOFFLO, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 16, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_GOTTLSOFFLO", /* name */
+ FALSE, /* partial_inplace */
+ 0xffff, /* src_mask */
+ 0xffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* The 32-bit offset from the thread pointer (not the module base
+ address) to a thread-local symbol. */
+ HOWTO (R_FRV_TLSOFF, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 32, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSOFF", /* name */
+ FALSE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* An annotation for linker relaxation, that denotes the
+ symbol+addend whose TLS descriptor is referenced by the sum of
+ the two input registers of an ldd instruction. */
+ HOWTO (R_FRV_TLSDESC_RELAX, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSDESC_RELAX", /* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* An annotation for linker relaxation, that denotes the
+ symbol+addend whose TLS resolver entry point is given by the sum
+ of the two register operands of an calll instruction. */
+ HOWTO (R_FRV_GETTLSOFF_RELAX, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_GETTLSOFF_RELAX", /* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* An annotation for linker relaxation, that denotes the
+ symbol+addend whose TLS offset GOT entry is given by the sum of
+ the two input registers of an ld instruction. */
+ HOWTO (R_FRV_TLSOFF_RELAX, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSOFF_RELAX", /* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ FALSE), /* pcrel_offset */
+
+ /* A 32-bit offset from the module base address to
+ the thread-local symbol address. */
+ HOWTO (R_FRV_TLSMOFF, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 32, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSMOFF", /* name */
+ FALSE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE), /* pcrel_offset */
+};
+
+/* GNU extension to record C++ vtable hierarchy. */
+static reloc_howto_type elf32_frv_vtinherit_howto =
+ HOWTO (R_FRV_GNU_VTINHERIT, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ NULL, /* special_function */
+ "R_FRV_GNU_VTINHERIT", /* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+ /* GNU extension to record C++ vtable member usage. */
+static reloc_howto_type elf32_frv_vtentry_howto =
+ HOWTO (R_FRV_GNU_VTENTRY, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 0, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_dont, /* complain_on_overflow */
+ _bfd_elf_rel_vtable_reloc_fn, /* special_function */
+ "R_FRV_GNU_VTENTRY", /* name */
+ FALSE, /* partial_inplace */
+ 0, /* src_mask */
+ 0, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+/* The following 3 relocations are REL. The only difference to the
+ entries in the table above are that partial_inplace is TRUE. */
+static reloc_howto_type elf32_frv_rel_32_howto =
+ HOWTO (R_FRV_32, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 32, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_32", /* name */
+ TRUE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+static reloc_howto_type elf32_frv_rel_funcdesc_howto =
+ HOWTO (R_FRV_FUNCDESC, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 32, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_FUNCDESC", /* name */
+ TRUE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+static reloc_howto_type elf32_frv_rel_funcdesc_value_howto =
+ HOWTO (R_FRV_FUNCDESC_VALUE, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 64, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_FUNCDESC_VALUE", /* name */
+ TRUE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+static reloc_howto_type elf32_frv_rel_tlsdesc_value_howto =
+ /* A 64-bit TLS descriptor for a symbol. The first word resolves to
+ an entry point, and the second resolves to a special argument.
+ If the symbol turns out to be in static TLS, the entry point is a
+ return instruction, and the special argument is the TLS offset
+ for the symbol. If it's in dynamic TLS, the entry point is a TLS
+ offset resolver, and the special argument is a pointer to a data
+ structure allocated by the dynamic loader, containing the GOT
+ address for the offset resolver, the module id, the offset within
+ the module, and anything else the TLS offset resolver might need
+ to determine the TLS offset for the symbol in the running
+ thread. */
+ HOWTO (R_FRV_TLSDESC_VALUE, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 64, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSDESC_VALUE", /* name */
+ TRUE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+static reloc_howto_type elf32_frv_rel_tlsoff_howto =
+ /* The 32-bit offset from the thread pointer (not the module base
+ address) to a thread-local symbol. */
+ HOWTO (R_FRV_TLSOFF, /* type */
+ 0, /* rightshift */
+ 2, /* size (0 = byte, 1 = short, 2 = long) */
+ 32, /* bitsize */
+ FALSE, /* pc_relative */
+ 0, /* bitpos */
+ complain_overflow_bitfield, /* complain_on_overflow */
+ bfd_elf_generic_reloc, /* special_function */
+ "R_FRV_TLSOFF", /* name */
+ TRUE, /* partial_inplace */
+ 0xffffffff, /* src_mask */
+ 0xffffffff, /* dst_mask */
+ FALSE); /* pcrel_offset */
+
+
+\f
+extern const bfd_target frv_elf32_fdpic_vec;
+#define IS_FDPIC(bfd) ((bfd)->xvec == &frv_elf32_fdpic_vec)
+
+/* An extension of the elf hash table data structure, containing some
+ additional FRV-specific data. */
+struct frvfdpic_elf_link_hash_table
+{
+ struct elf_link_hash_table elf;
+
+ /* A pointer to the .got section. */
+ asection *sgot;
+ /* A pointer to the .rel.got section. */
+ asection *sgotrel;
+ /* A pointer to the .rofixup section. */
+ asection *sgotfixup;
+ /* A pointer to the .plt section. */
+ asection *splt;
+ /* A pointer to the .rel.plt section. */
+ asection *spltrel;
+ /* GOT base offset. */
+ bfd_vma got0;
+ /* Location of the first non-lazy PLT entry, i.e., the number of
+ bytes taken by lazy PLT entries. If locally-bound TLS
+ descriptors require a ret instruction, it will be placed at this
+ offset. */
+ bfd_vma plt0;
+ /* A hash table holding information about which symbols were
+ referenced with which PIC-related relocations. */
+ struct htab *relocs_info;
+ /* Summary reloc information collected by
+ _frvfdpic_count_got_plt_entries. */
+ struct _frvfdpic_dynamic_got_info *g;
+};
+
+/* Get the FRV ELF linker hash table from a link_info structure. */
+
+#define frvfdpic_hash_table(p) \
+ (elf_hash_table_id ((struct elf_link_hash_table *) ((p)->hash)) \
+ == FRV_ELF_DATA ? ((struct frvfdpic_elf_link_hash_table *) ((p)->hash)) : NULL)
+
+#define frvfdpic_got_section(info) \
+ (frvfdpic_hash_table (info)->sgot)
+#define frvfdpic_gotrel_section(info) \
+ (frvfdpic_hash_table (info)->sgotrel)
+#define frvfdpic_gotfixup_section(info) \
+ (frvfdpic_hash_table (info)->sgotfixup)
+#define frvfdpic_plt_section(info) \
+ (frvfdpic_hash_table (info)->splt)
+#define frvfdpic_pltrel_section(info) \
+ (frvfdpic_hash_table (info)->spltrel)
+#define frvfdpic_relocs_info(info) \
+ (frvfdpic_hash_table (info)->relocs_info)
+#define frvfdpic_got_initial_offset(info) \
+ (frvfdpic_hash_table (info)->got0)
+#define frvfdpic_plt_initial_offset(info) \
+ (frvfdpic_hash_table (info)->plt0)
+#define frvfdpic_dynamic_got_plt_info(info) \
+ (frvfdpic_hash_table (info)->g)
+
+/* Currently it's the same, but if some day we have a reason to change
+ it, we'd better be using a different macro.
+
+ FIXME: if there's any TLS PLT entry that uses local-exec or
+ initial-exec models, we could use the ret at the end of any of them
+ instead of adding one more. */
+#define frvfdpic_plt_tls_ret_offset(info) \
+ (frvfdpic_plt_initial_offset (info))
+
+/* The name of the dynamic interpreter. This is put in the .interp
+ section. */
+
+#define ELF_DYNAMIC_INTERPRETER "/lib/ld.so.1"
+
+#define DEFAULT_STACK_SIZE 0x20000
+
+/* This structure is used to collect the number of entries present in
+ each addressable range of the got. */
+struct _frvfdpic_dynamic_got_info
+{
+ /* Several bits of information about the current link. */
+ struct bfd_link_info *info;
+ /* Total GOT size needed for GOT entries within the 12-, 16- or 32-bit
+ ranges. */
+ bfd_vma got12, gotlos, gothilo;
+ /* Total GOT size needed for function descriptor entries within the 12-,
+ 16- or 32-bit ranges. */
+ bfd_vma fd12, fdlos, fdhilo;
+ /* Total GOT size needed by function descriptor entries referenced
+ in PLT entries, that would be profitable to place in offsets
+ close to the PIC register. */
+ bfd_vma fdplt;
+ /* Total PLT size needed by lazy PLT entries. */
+ bfd_vma lzplt;
+ /* Total GOT size needed for TLS descriptor entries within the 12-,
+ 16- or 32-bit ranges. */
+ bfd_vma tlsd12, tlsdlos, tlsdhilo;
+ /* Total GOT size needed by TLS descriptors referenced in PLT
+ entries, that would be profitable to place in offers close to the
+ PIC register. */
+ bfd_vma tlsdplt;
+ /* Total PLT size needed by TLS lazy PLT entries. */
+ bfd_vma tlslzplt;
+ /* Number of relocations carried over from input object files. */
+ unsigned long relocs;
+ /* Number of fixups introduced by relocations in input object files. */
+ unsigned long fixups;
+ /* The number of fixups that reference the ret instruction added to
+ the PLT for locally-resolved TLS descriptors. */
+ unsigned long tls_ret_refs;
+};
+
+/* This structure is used to assign offsets to got entries, function
+ descriptors, plt entries and lazy plt entries. */
+
+struct _frvfdpic_dynamic_got_plt_info
+{
+ /* Summary information collected with _frvfdpic_count_got_plt_entries. */
+ struct _frvfdpic_dynamic_got_info g;
+
+ /* For each addressable range, we record a MAX (positive) and MIN
+ (negative) value. CUR is used to assign got entries, and it's
+ incremented from an initial positive value to MAX, then from MIN
+ to FDCUR (unless FDCUR wraps around first). FDCUR is used to
+ assign function descriptors, and it's decreased from an initial
+ non-positive value to MIN, then from MAX down to CUR (unless CUR
+ wraps around first). All of MIN, MAX, CUR and FDCUR always point
+ to even words. ODD, if non-zero, indicates an odd word to be
+ used for the next got entry, otherwise CUR is used and
+ incremented by a pair of words, wrapping around when it reaches
+ MAX. FDCUR is decremented (and wrapped) before the next function
+ descriptor is chosen. FDPLT indicates the number of remaining
+ slots that can be used for function descriptors used only by PLT
+ entries.
+
+ TMAX, TMIN and TCUR are used to assign TLS descriptors. TCUR
+ starts as MAX, and grows up to TMAX, then wraps around to TMIN
+ and grows up to MIN. TLSDPLT indicates the number of remaining
+ slots that can be used for TLS descriptors used only by TLS PLT
+ entries. */
+ struct _frvfdpic_dynamic_got_alloc_data
+ {
+ bfd_signed_vma max, cur, odd, fdcur, min;
+ bfd_signed_vma tmax, tcur, tmin;
+ bfd_vma fdplt, tlsdplt;
+ } got12, gotlos, gothilo;
+};
+
+/* Create an FRV ELF linker hash table. */
+
+static struct bfd_link_hash_table *
+frvfdpic_elf_link_hash_table_create (bfd *abfd)
+{
+ struct frvfdpic_elf_link_hash_table *ret;
+ bfd_size_type amt = sizeof (struct frvfdpic_elf_link_hash_table);
+
+ ret = bfd_zmalloc (amt);
+ if (ret == NULL)
+ return NULL;
+
+ if (!_bfd_elf_link_hash_table_init (&ret->elf, abfd,
+ _bfd_elf_link_hash_newfunc,
+ sizeof (struct elf_link_hash_entry),
+ FRV_ELF_DATA))
+ {
+ free (ret);
+ return NULL;
+ }
+
+ return &ret->elf.root;
+}
+
+/* Decide whether a reference to a symbol can be resolved locally or
+ not. If the symbol is protected, we want the local address, but
+ its function descriptor must be assigned by the dynamic linker. */
+#define FRVFDPIC_SYM_LOCAL(INFO, H) \
+ (_bfd_elf_symbol_refs_local_p ((H), (INFO), 1) \
+ || ! elf_hash_table (INFO)->dynamic_sections_created)
+#define FRVFDPIC_FUNCDESC_LOCAL(INFO, H) \
+ ((H)->dynindx == -1 || ! elf_hash_table (INFO)->dynamic_sections_created)
+
+/* This structure collects information on what kind of GOT, PLT or
+ function descriptors are required by relocations that reference a
+ certain symbol. */
+struct frvfdpic_relocs_info
+{
+ /* The index of the symbol, as stored in the relocation r_info, if
+ we have a local symbol; -1 otherwise. */
+ long symndx;
+ union
+ {
+ /* The input bfd in which the symbol is defined, if it's a local
+ symbol. */
+ bfd *abfd;
+ /* If symndx == -1, the hash table entry corresponding to a global
+ symbol (even if it turns out to bind locally, in which case it
+ should ideally be replaced with section's symndx + addend). */
+ struct elf_link_hash_entry *h;
+ } d;
+ /* The addend of the relocation that references the symbol. */
+ bfd_vma addend;
+
+ /* The fields above are used to identify an entry. The fields below
+ contain information on how an entry is used and, later on, which
+ locations it was assigned. */
+ /* The following 3 fields record whether the symbol+addend above was
+ ever referenced with a GOT relocation. The 12 suffix indicates a
+ GOT12 relocation; los is used for GOTLO relocations that are not
+ matched by a GOTHI relocation; hilo is used for GOTLO/GOTHI
+ pairs. */
+ unsigned got12:1;
+ unsigned gotlos:1;
+ unsigned gothilo:1;
+ /* Whether a FUNCDESC relocation references symbol+addend. */
+ unsigned fd:1;
+ /* Whether a FUNCDESC_GOT relocation references symbol+addend. */
+ unsigned fdgot12:1;
+ unsigned fdgotlos:1;
+ unsigned fdgothilo:1;
+ /* Whether a FUNCDESC_GOTOFF relocation references symbol+addend. */
+ unsigned fdgoff12:1;
+ unsigned fdgofflos:1;
+ unsigned fdgoffhilo:1;
+ /* Whether a GETTLSOFF relocation references symbol+addend. */
+ unsigned tlsplt:1;
+ /* FIXME: we should probably add tlspltdesc, tlspltoff and
+ tlspltimm, to tell what kind of TLS PLT entry we're generating.
+ We might instead just pre-compute flags telling whether the
+ object is suitable for local exec, initial exec or general
+ dynamic addressing, and use that all over the place. We could
+ also try to do a better job of merging TLSOFF and TLSDESC entries
+ in main executables, but perhaps we can get rid of TLSDESC
+ entirely in them instead. */
+ /* Whether a GOTTLSDESC relocation references symbol+addend. */
+ unsigned tlsdesc12:1;
+ unsigned tlsdesclos:1;
+ unsigned tlsdeschilo:1;
+ /* Whether a GOTTLSOFF relocation references symbol+addend. */
+ unsigned tlsoff12:1;
+ unsigned tlsofflos:1;
+ unsigned tlsoffhilo:1;
+ /* Whether symbol+addend is referenced with GOTOFF12, GOTOFFLO or
+ GOTOFFHI relocations. The addend doesn't really matter, since we
+ envision that this will only be used to check whether the symbol
+ is mapped to the same segment as the got. */
+ unsigned gotoff:1;
+ /* Whether symbol+addend is referenced by a LABEL24 relocation. */
+ unsigned call:1;
+ /* Whether symbol+addend is referenced by a 32 or FUNCDESC_VALUE
+ relocation. */
+ unsigned sym:1;
+ /* Whether we need a PLT entry for a symbol. Should be implied by
+ something like:
+ (call && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)) */
+ unsigned plt:1;
+ /* Whether a function descriptor should be created in this link unit
+ for symbol+addend. Should be implied by something like:
+ (plt || fdgotoff12 || fdgotofflos || fdgotofflohi
+ || ((fd || fdgot12 || fdgotlos || fdgothilo)
+ && (symndx != -1 || FRVFDPIC_FUNCDESC_LOCAL (info, d.h)))) */
+ unsigned privfd:1;
+ /* Whether a lazy PLT entry is needed for this symbol+addend.
+ Should be implied by something like:
+ (privfd && symndx == -1 && ! FRVFDPIC_SYM_LOCAL (info, d.h)
+ && ! (info->flags & DF_BIND_NOW)) */
+ unsigned lazyplt:1;
+ /* Whether we've already emitted GOT relocations and PLT entries as
+ needed for this symbol. */
+ unsigned done:1;
+
+ /* The number of R_FRV_32, R_FRV_FUNCDESC, R_FRV_FUNCDESC_VALUE and
+ R_FRV_TLSDESC_VALUE, R_FRV_TLSOFF relocations referencing
+ symbol+addend. */
+ unsigned relocs32, relocsfd, relocsfdv, relocstlsd, relocstlsoff;
+
+ /* The number of .rofixups entries and dynamic relocations allocated
+ for this symbol, minus any that might have already been used. */
+ unsigned fixups, dynrelocs;
+
+ /* The offsets of the GOT entries assigned to symbol+addend, to the
+ function descriptor's address, and to a function descriptor,
+ respectively. Should be zero if unassigned. The offsets are
+ counted from the value that will be assigned to the PIC register,
+ not from the beginning of the .got section. */
+ bfd_signed_vma got_entry, fdgot_entry, fd_entry;
+ /* The offsets of the PLT entries assigned to symbol+addend,
+ non-lazy and lazy, respectively. If unassigned, should be
+ (bfd_vma)-1. */
+ bfd_vma plt_entry, lzplt_entry;
+ /* The offsets of the GOT entries for TLS offset and TLS descriptor. */
+ bfd_signed_vma tlsoff_entry, tlsdesc_entry;
+ /* The offset of the TLS offset PLT entry. */
+ bfd_vma tlsplt_entry;
+};
+
+/* Compute a hash with the key fields of an frvfdpic_relocs_info entry. */
+static hashval_t
+frvfdpic_relocs_info_hash (const void *entry_)
+{
+ const struct frvfdpic_relocs_info *entry = entry_;
+
+ return (entry->symndx == -1
+ ? (long) entry->d.h->root.root.hash
+ : entry->symndx + (long) entry->d.abfd->id * 257) + entry->addend;
+}
+
+/* Test whether the key fields of two frvfdpic_relocs_info entries are
+ identical. */
+static int
+frvfdpic_relocs_info_eq (const void *entry1, const void *entry2)
+{
+ const struct frvfdpic_relocs_info *e1 = entry1;
+ const struct frvfdpic_relocs_info *e2 = entry2;
+
+ return e1->symndx == e2->symndx && e1->addend == e2->addend
+ && (e1->symndx == -1 ? e1->d.h == e2->d.h : e1->d.abfd == e2->d.abfd);
+}
+
+/* Find or create an entry in a hash table HT that matches the key
+ fields of the given ENTRY. If it's not found, memory for a new
+ entry is allocated in ABFD's obstack. */
+static struct frvfdpic_relocs_info *
+frvfdpic_relocs_info_find (struct htab *ht,
+ bfd *abfd,
+ const struct frvfdpic_relocs_info *entry,
+ enum insert_option insert)
+{
+ struct frvfdpic_relocs_info **loc =
+ (struct frvfdpic_relocs_info **) htab_find_slot (ht, entry, insert);
+
+ if (! loc)
+ return NULL;
+
+ if (*loc)
+ return *loc;
+
+ *loc = bfd_zalloc (abfd, sizeof (**loc));
+
+ if (! *loc)
+ return *loc;
+
+ (*loc)->symndx = entry->symndx;
+ (*loc)->d = entry->d;
+ (*loc)->addend = entry->addend;
+ (*loc)->plt_entry = (bfd_vma)-1;
+ (*loc)->lzplt_entry = (bfd_vma)-1;
+ (*loc)->tlsplt_entry = (bfd_vma)-1;
+
+ return *loc;
+}
+
+/* Obtain the address of the entry in HT associated with H's symbol +
+ addend, creating a new entry if none existed. ABFD is only used
+ for memory allocation purposes. */
+inline static struct frvfdpic_relocs_info *
+frvfdpic_relocs_info_for_global (struct htab *ht,
+ bfd *abfd,
+ struct elf_link_hash_entry *h,
+ bfd_vma addend,
+ enum insert_option insert)
+{
+ struct frvfdpic_relocs_info entry;
+
+ entry.symndx = -1;
+ entry.d.h = h;
+ entry.addend = addend;
+
+ return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
+}
+
+/* Obtain the address of the entry in HT associated with the SYMNDXth
+ local symbol of the input bfd ABFD, plus the addend, creating a new
+ entry if none existed. */
+inline static struct frvfdpic_relocs_info *
+frvfdpic_relocs_info_for_local (struct htab *ht,
+ bfd *abfd,
+ long symndx,
+ bfd_vma addend,
+ enum insert_option insert)
+{
+ struct frvfdpic_relocs_info entry;
+
+ entry.symndx = symndx;
+ entry.d.abfd = abfd;
+ entry.addend = addend;
+
+ return frvfdpic_relocs_info_find (ht, abfd, &entry, insert);
+}
+
+/* Merge fields set by check_relocs() of two entries that end up being
+ mapped to the same (presumably global) symbol. */
+
+inline static void
+frvfdpic_pic_merge_early_relocs_info (struct frvfdpic_relocs_info *e2,
+ struct frvfdpic_relocs_info const *e1)
+{
+ e2->got12 |= e1->got12;
+ e2->gotlos |= e1->gotlos;
+ e2->gothilo |= e1->gothilo;
+ e2->fd |= e1->fd;
+ e2->fdgot12 |= e1->fdgot12;
+ e2->fdgotlos |= e1->fdgotlos;
+ e2->fdgothilo |= e1->fdgothilo;
+ e2->fdgoff12 |= e1->fdgoff12;
+ e2->fdgofflos |= e1->fdgofflos;
+ e2->fdgoffhilo |= e1->fdgoffhilo;
+ e2->tlsplt |= e1->tlsplt;
+ e2->tlsdesc12 |= e1->tlsdesc12;
+ e2->tlsdesclos |= e1->tlsdesclos;
+ e2->tlsdeschilo |= e1->tlsdeschilo;
+ e2->tlsoff12 |= e1->tlsoff12;
+ e2->tlsofflos |= e1->tlsofflos;
+ e2->tlsoffhilo |= e1->tlsoffhilo;
+ e2->gotoff |= e1->gotoff;
+ e2->call |= e1->call;
+ e2->sym |= e1->sym;
+}
+
+/* Every block of 65535 lazy PLT entries shares a single call to the
+ resolver, inserted in the 32768th lazy PLT entry (i.e., entry #
+ 32767, counting from 0). All other lazy PLT entries branch to it
+ in a single instruction. */
+
+#define FRVFDPIC_LZPLT_BLOCK_SIZE ((bfd_vma) 8 * 65535 + 4)
+#define FRVFDPIC_LZPLT_RESOLV_LOC (8 * 32767)
+
+/* Add a dynamic relocation to the SRELOC section. */
+
+inline static bfd_vma
+_frvfdpic_add_dyn_reloc (bfd *output_bfd, asection *sreloc, bfd_vma offset,
+ int reloc_type, long dynindx, bfd_vma addend,
+ struct frvfdpic_relocs_info *entry)
+{
+ Elf_Internal_Rela outrel;
+ bfd_vma reloc_offset;
+
+ outrel.r_offset = offset;
+ outrel.r_info = ELF32_R_INFO (dynindx, reloc_type);
+ outrel.r_addend = addend;
+
+ reloc_offset = sreloc->reloc_count * sizeof (Elf32_External_Rel);
+ BFD_ASSERT (reloc_offset < sreloc->size);
+ bfd_elf32_swap_reloc_out (output_bfd, &outrel,
+ sreloc->contents + reloc_offset);
+ sreloc->reloc_count++;
+
+ /* If the entry's index is zero, this relocation was probably to a
+ linkonce section that got discarded. We reserved a dynamic
+ relocation, but it was for another entry than the one we got at
+ the time of emitting the relocation. Unfortunately there's no
+ simple way for us to catch this situation, since the relocation
+ is cleared right before calling relocate_section, at which point
+ we no longer know what the relocation used to point to. */
+ if (entry->symndx)
+ {
+ BFD_ASSERT (entry->dynrelocs > 0);
+ entry->dynrelocs--;
+ }
+
+ return reloc_offset;
+}
+
+/* Add a fixup to the ROFIXUP section. */
+
+static bfd_vma
+_frvfdpic_add_rofixup (bfd *output_bfd, asection *rofixup, bfd_vma offset,
+ struct frvfdpic_relocs_info *entry)
+{
+ bfd_vma fixup_offset;
+
+ if (rofixup->flags & SEC_EXCLUDE)
+ return -1;
+
+ fixup_offset = rofixup->reloc_count * 4;
+ if (rofixup->contents)
+ {
+ BFD_ASSERT (fixup_offset < rofixup->size);
+ bfd_put_32 (output_bfd, offset, rofixup->contents + fixup_offset);
+ }
+ rofixup->reloc_count++;
+
+ if (entry && entry->symndx)
+ {
+ /* See discussion about symndx == 0 in _frvfdpic_add_dyn_reloc
+ above. */
+ BFD_ASSERT (entry->fixups > 0);
+ entry->fixups--;
+ }
+
+ return fixup_offset;
+}
+
+/* Find the segment number in which OSEC, and output section, is
+ located. */
+
+static unsigned
+_frvfdpic_osec_to_segment (bfd *output_bfd, asection *osec)
+{
+ Elf_Internal_Phdr *p = _bfd_elf_find_segment_containing_section (output_bfd, osec);
+
+ return (p != NULL) ? p - elf_tdata (output_bfd)->phdr : -1;
+}
+
+inline static bfd_boolean
+_frvfdpic_osec_readonly_p (bfd *output_bfd, asection *osec)
+{
+ unsigned seg = _frvfdpic_osec_to_segment (output_bfd, osec);
+
+ return ! (elf_tdata (output_bfd)->phdr[seg].p_flags & PF_W);
+}
+
+#define FRVFDPIC_TLS_BIAS (2048 - 16)
+
+/* Return the base VMA address which should be subtracted from real addresses
+ when resolving TLSMOFF relocation.
+ This is PT_TLS segment p_vaddr, plus the 2048-16 bias. */
+
+static bfd_vma
+tls_biased_base (struct bfd_link_info *info)
+{
+ /* If tls_sec is NULL, we should have signalled an error already. */
+ if (elf_hash_table (info)->tls_sec == NULL)
+ return FRVFDPIC_TLS_BIAS;
+ return elf_hash_table (info)->tls_sec->vma + FRVFDPIC_TLS_BIAS;
+}
+
+/* Generate relocations for GOT entries, function descriptors, and
+ code for PLT and lazy PLT entries. */
+
+inline static bfd_boolean
+_frvfdpic_emit_got_relocs_plt_entries (struct frvfdpic_relocs_info *entry,
+ bfd *output_bfd,
+ struct bfd_link_info *info,
+ asection *sec,
+ Elf_Internal_Sym *sym,
+ bfd_vma addend)
+
+{
+ bfd_vma fd_lazy_rel_offset = (bfd_vma)-1;
+ int dynindx = -1;
+
+ if (entry->done)
+ return TRUE;
+ entry->done = 1;
+
+ if (entry->got_entry || entry->fdgot_entry || entry->fd_entry
+ || entry->tlsoff_entry || entry->tlsdesc_entry)
+ {
+ /* If the symbol is dynamic, consider it for dynamic
+ relocations, otherwise decay to section + offset. */
+ if (entry->symndx == -1 && entry->d.h->dynindx != -1)
+ dynindx = entry->d.h->dynindx;
+ else
+ {
+ if (sec
+ && sec->output_section
+ && ! bfd_is_abs_section (sec->output_section)
+ && ! bfd_is_und_section (sec->output_section))
+ dynindx = elf_section_data (sec->output_section)->dynindx;
+ else
+ dynindx = 0;
+ }
+ }
+
+ /* Generate relocation for GOT entry pointing to the symbol. */
+ if (entry->got_entry)
+ {
+ int idx = dynindx;
+ bfd_vma ad = addend;
+
+ /* If the symbol is dynamic but binds locally, use
+ section+offset. */
+ if (sec && (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ if (entry->symndx == -1)
+ ad += entry->d.h->root.u.def.value;
+ else
+ ad += sym->st_value;
+ ad += sec->output_offset;
+ if (sec->output_section && elf_section_data (sec->output_section))
+ idx = elf_section_data (sec->output_section)->dynindx;
+ else
+ idx = 0;
+ }
+
+ /* If we're linking an executable at a fixed address, we can
+ omit the dynamic relocation as long as the symbol is local to
+ this module. */
+ if (bfd_link_pde (info)
+ && (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ if (sec)
+ ad += sec->output_section->vma;
+ if (entry->symndx != -1
+ || entry->d.h->root.type != bfd_link_hash_undefweak)
+ _frvfdpic_add_rofixup (output_bfd,
+ frvfdpic_gotfixup_section (info),
+ frvfdpic_got_section (info)->output_section
+ ->vma
+ + frvfdpic_got_section (info)->output_offset
+ + frvfdpic_got_initial_offset (info)
+ + entry->got_entry, entry);
+ }
+ else
+ _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
+ _bfd_elf_section_offset
+ (output_bfd, info,
+ frvfdpic_got_section (info),
+ frvfdpic_got_initial_offset (info)
+ + entry->got_entry)
+ + frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)->output_offset,
+ R_FRV_32, idx, ad, entry);
+
+ bfd_put_32 (output_bfd, ad,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->got_entry);
+ }
+
+ /* Generate relocation for GOT entry pointing to a canonical
+ function descriptor. */
+ if (entry->fdgot_entry)
+ {
+ int reloc, idx;
+ bfd_vma ad = 0;
+
+ if (! (entry->symndx == -1
+ && entry->d.h->root.type == bfd_link_hash_undefweak
+ && FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ /* If the symbol is dynamic and there may be dynamic symbol
+ resolution because we are, or are linked with, a shared
+ library, emit a FUNCDESC relocation such that the dynamic
+ linker will allocate the function descriptor. If the
+ symbol needs a non-local function descriptor but binds
+ locally (e.g., its visibility is protected, emit a
+ dynamic relocation decayed to section+offset. */
+ if (entry->symndx == -1
+ && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)
+ && FRVFDPIC_SYM_LOCAL (info, entry->d.h)
+ && !bfd_link_pde (info))
+ {
+ reloc = R_FRV_FUNCDESC;
+ idx = elf_section_data (entry->d.h->root.u.def.section
+ ->output_section)->dynindx;
+ ad = entry->d.h->root.u.def.section->output_offset
+ + entry->d.h->root.u.def.value;
+ }
+ else if (entry->symndx == -1
+ && ! FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h))
+ {
+ reloc = R_FRV_FUNCDESC;
+ idx = dynindx;
+ ad = addend;
+ if (ad)
+ {
+ (*info->callbacks->reloc_dangerous)
+ (info, _("relocation requires zero addend"),
+ elf_hash_table (info)->dynobj,
+ frvfdpic_got_section (info),
+ entry->fdgot_entry);
+ return FALSE;
+ }
+ }
+ else
+ {
+ /* Otherwise, we know we have a private function descriptor,
+ so reference it directly. */
+ if (elf_hash_table (info)->dynamic_sections_created)
+ BFD_ASSERT (entry->privfd);
+ reloc = R_FRV_32;
+ idx = elf_section_data (frvfdpic_got_section (info)
+ ->output_section)->dynindx;
+ ad = frvfdpic_got_section (info)->output_offset
+ + frvfdpic_got_initial_offset (info) + entry->fd_entry;
+ }
+
+ /* If there is room for dynamic symbol resolution, emit the
+ dynamic relocation. However, if we're linking an
+ executable at a fixed location, we won't have emitted a
+ dynamic symbol entry for the got section, so idx will be
+ zero, which means we can and should compute the address
+ of the private descriptor ourselves. */
+ if (bfd_link_pde (info)
+ && (entry->symndx != -1
+ || FRVFDPIC_FUNCDESC_LOCAL (info, entry->d.h)))
+ {
+ ad += frvfdpic_got_section (info)->output_section->vma;
+ _frvfdpic_add_rofixup (output_bfd,
+ frvfdpic_gotfixup_section (info),
+ frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset
+ + frvfdpic_got_initial_offset (info)
+ + entry->fdgot_entry, entry);
+ }
+ else
+ _frvfdpic_add_dyn_reloc (output_bfd,
+ frvfdpic_gotrel_section (info),
+ _bfd_elf_section_offset
+ (output_bfd, info,
+ frvfdpic_got_section (info),
+ frvfdpic_got_initial_offset (info)
+ + entry->fdgot_entry)
+ + frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset,
+ reloc, idx, ad, entry);
+ }
+
+ bfd_put_32 (output_bfd, ad,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->fdgot_entry);
+ }
+
+ /* Generate relocation to fill in a private function descriptor in
+ the GOT. */
+ if (entry->fd_entry)
+ {
+ int idx = dynindx;
+ bfd_vma ad = addend;
+ bfd_vma ofst;
+ long lowword, highword;
+
+ /* If the symbol is dynamic but binds locally, use
+ section+offset. */
+ if (sec && (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ if (entry->symndx == -1)
+ ad += entry->d.h->root.u.def.value;
+ else
+ ad += sym->st_value;
+ ad += sec->output_offset;
+ if (sec->output_section && elf_section_data (sec->output_section))
+ idx = elf_section_data (sec->output_section)->dynindx;
+ else
+ idx = 0;
+ }
+
+ /* If we're linking an executable at a fixed address, we can
+ omit the dynamic relocation as long as the symbol is local to
+ this module. */
+ if (bfd_link_pde (info)
+ && (entry->symndx != -1 || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ if (sec)
+ ad += sec->output_section->vma;
+ ofst = 0;
+ if (entry->symndx != -1
+ || entry->d.h->root.type != bfd_link_hash_undefweak)
+ {
+ _frvfdpic_add_rofixup (output_bfd,
+ frvfdpic_gotfixup_section (info),
+ frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset
+ + frvfdpic_got_initial_offset (info)
+ + entry->fd_entry, entry);
+ _frvfdpic_add_rofixup (output_bfd,
+ frvfdpic_gotfixup_section (info),
+ frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset
+ + frvfdpic_got_initial_offset (info)
+ + entry->fd_entry + 4, entry);
+ }
+ }
+ else
+ {
+ ofst =
+ _frvfdpic_add_dyn_reloc (output_bfd,
+ entry->lazyplt
+ ? frvfdpic_pltrel_section (info)
+ : frvfdpic_gotrel_section (info),
+ _bfd_elf_section_offset
+ (output_bfd, info,
+ frvfdpic_got_section (info),
+ frvfdpic_got_initial_offset (info)
+ + entry->fd_entry)
+ + frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset,
+ R_FRV_FUNCDESC_VALUE, idx, ad, entry);
+ }
+
+ /* If we've omitted the dynamic relocation, just emit the fixed
+ addresses of the symbol and of the local GOT base offset. */
+ if (bfd_link_pde (info)
+ && sec
+ && sec->output_section)
+ {
+ lowword = ad;
+ highword = frvfdpic_got_section (info)->output_section->vma
+ + frvfdpic_got_section (info)->output_offset
+ + frvfdpic_got_initial_offset (info);
+ }
+ else if (entry->lazyplt)
+ {
+ if (ad)
+ {
+ (*info->callbacks->reloc_dangerous)
+ (info, _("relocation requires zero addend"),
+ elf_hash_table (info)->dynobj,
+ frvfdpic_got_section (info),
+ entry->fd_entry);
+ return FALSE;
+ }
+
+ fd_lazy_rel_offset = ofst;
+
+ /* A function descriptor used for lazy or local resolving is
+ initialized such that its high word contains the output
+ section index in which the PLT entries are located, and
+ the low word contains the address of the lazy PLT entry
+ entry point, that must be within the memory region
+ assigned to that section. */
+ lowword = entry->lzplt_entry + 4
+ + frvfdpic_plt_section (info)->output_offset
+ + frvfdpic_plt_section (info)->output_section->vma;
+ highword = _frvfdpic_osec_to_segment
+ (output_bfd, frvfdpic_plt_section (info)->output_section);
+ }
+ else
+ {
+ /* A function descriptor for a local function gets the index
+ of the section. For a non-local function, it's
+ disregarded. */
+ lowword = ad;
+ if (sec == NULL
+ || (entry->symndx == -1 && entry->d.h->dynindx != -1
+ && entry->d.h->dynindx == idx))
+ highword = 0;
+ else
+ highword = _frvfdpic_osec_to_segment
+ (output_bfd, sec->output_section);
+ }
+
+ bfd_put_32 (output_bfd, lowword,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->fd_entry);
+ bfd_put_32 (output_bfd, highword,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->fd_entry + 4);
+ }
+
+ /* Generate code for the PLT entry. */
+ if (entry->plt_entry != (bfd_vma) -1)
+ {
+ bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
+ + entry->plt_entry;
+
+ BFD_ASSERT (entry->fd_entry);
+
+ /* Figure out what kind of PLT entry we need, depending on the
+ location of the function descriptor within the GOT. */
+ if (entry->fd_entry >= -(1 << (12 - 1))
+ && entry->fd_entry < (1 << (12 - 1)))
+ {
+ /* lddi @(gr15, fd_entry), gr14 */
+ bfd_put_32 (output_bfd,
+ 0x9cccf000 | (entry->fd_entry & ((1 << 12) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ if (entry->fd_entry >= -(1 << (16 - 1))
+ && entry->fd_entry < (1 << (16 - 1)))
+ {
+ /* setlos lo(fd_entry), gr14 */
+ bfd_put_32 (output_bfd,
+ 0x9cfc0000
+ | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ /* sethi.p hi(fd_entry), gr14
+ setlo lo(fd_entry), gr14 */
+ bfd_put_32 (output_bfd,
+ 0x1cf80000
+ | ((entry->fd_entry >> 16)
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ bfd_put_32 (output_bfd,
+ 0x9cf40000
+ | (entry->fd_entry & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ /* ldd @(gr14,gr15),gr14 */
+ bfd_put_32 (output_bfd, 0x9c08e14f, plt_code);
+ plt_code += 4;
+ }
+ /* jmpl @(gr14,gr0) */
+ bfd_put_32 (output_bfd, 0x8030e000, plt_code);
+ }
+
+ /* Generate code for the lazy PLT entry. */
+ if (entry->lzplt_entry != (bfd_vma) -1)
+ {
+ bfd_byte *lzplt_code = frvfdpic_plt_section (info)->contents
+ + entry->lzplt_entry;
+ bfd_vma resolverStub_addr;
+
+ bfd_put_32 (output_bfd, fd_lazy_rel_offset, lzplt_code);
+ lzplt_code += 4;
+
+ resolverStub_addr = entry->lzplt_entry / FRVFDPIC_LZPLT_BLOCK_SIZE
+ * FRVFDPIC_LZPLT_BLOCK_SIZE + FRVFDPIC_LZPLT_RESOLV_LOC;
+ if (resolverStub_addr >= frvfdpic_plt_initial_offset (info))
+ resolverStub_addr = frvfdpic_plt_initial_offset (info) - 12;
+
+ if (entry->lzplt_entry == resolverStub_addr)
+ {
+ /* This is a lazy PLT entry that includes a resolver call. */
+ /* ldd @(gr15,gr0), gr4
+ jmpl @(gr4,gr0) */
+ bfd_put_32 (output_bfd, 0x8808f140, lzplt_code);
+ bfd_put_32 (output_bfd, 0x80304000, lzplt_code + 4);
+ }
+ else
+ {
+ /* bra resolverStub */
+ bfd_put_32 (output_bfd,
+ 0xc01a0000
+ | (((resolverStub_addr - entry->lzplt_entry)
+ / 4) & (((bfd_vma)1 << 16) - 1)),
+ lzplt_code);
+ }
+ }
+
+ /* Generate relocation for GOT entry holding the TLS offset. */
+ if (entry->tlsoff_entry)
+ {
+ int idx = dynindx;
+ bfd_vma ad = addend;
+
+ if (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h))
+ {
+ /* If the symbol is dynamic but binds locally, use
+ section+offset. */
+ if (sec)
+ {
+ if (entry->symndx == -1)
+ ad += entry->d.h->root.u.def.value;
+ else
+ ad += sym->st_value;
+ ad += sec->output_offset;
+ if (sec->output_section
+ && elf_section_data (sec->output_section))
+ idx = elf_section_data (sec->output_section)->dynindx;
+ else
+ idx = 0;
+ }
+ }
+
+ /* *ABS*+addend is special for TLS relocations, use only the
+ addend. */
+ if (bfd_link_executable (info)
+ && idx == 0
+ && (bfd_is_abs_section (sec)
+ || bfd_is_und_section (sec)))
+ ;
+ /* If we're linking an executable, we can entirely omit the
+ dynamic relocation if the symbol is local to this module. */
+ else if (bfd_link_executable (info)
+ && (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ if (sec)
+ ad += sec->output_section->vma - tls_biased_base (info);
+ }
+ else
+ {
+ if (idx == 0
+ && (bfd_is_abs_section (sec)
+ || bfd_is_und_section (sec)))
+ {
+ if (! elf_hash_table (info)->tls_sec)
+ {
+ (*info->callbacks->undefined_symbol)
+ (info, "TLS section", elf_hash_table (info)->dynobj,
+ frvfdpic_got_section (info), entry->tlsoff_entry, TRUE);
+ return FALSE;
+ }
+ idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
+ ad += FRVFDPIC_TLS_BIAS;
+ }
+ _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
+ _bfd_elf_section_offset
+ (output_bfd, info,
+ frvfdpic_got_section (info),
+ frvfdpic_got_initial_offset (info)
+ + entry->tlsoff_entry)
+ + frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset,
+ R_FRV_TLSOFF, idx, ad, entry);
+ }
+
+ bfd_put_32 (output_bfd, ad,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->tlsoff_entry);
+ }
+
+ if (entry->tlsdesc_entry)
+ {
+ int idx = dynindx;
+ bfd_vma ad = addend;
+
+ /* If the symbol is dynamic but binds locally, use
+ section+offset. */
+ if (sec && (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ if (entry->symndx == -1)
+ ad += entry->d.h->root.u.def.value;
+ else
+ ad += sym->st_value;
+ ad += sec->output_offset;
+ if (sec->output_section && elf_section_data (sec->output_section))
+ idx = elf_section_data (sec->output_section)->dynindx;
+ else
+ idx = 0;
+ }
+
+ /* If we didn't set up a TLS offset entry, but we're linking an
+ executable and the symbol binds locally, we can use the
+ module offset in the TLS descriptor in relaxations. */
+ if (bfd_link_executable (info) && ! entry->tlsoff_entry)
+ entry->tlsoff_entry = entry->tlsdesc_entry + 4;
+
+ if (bfd_link_pde (info)
+ && ((idx == 0
+ && (bfd_is_abs_section (sec)
+ || bfd_is_und_section (sec)))
+ || entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ /* *ABS*+addend is special for TLS relocations, use only the
+ addend for the TLS offset, and take the module id as
+ 0. */
+ if (idx == 0
+ && (bfd_is_abs_section (sec)
+ || bfd_is_und_section (sec)))
+ ;
+ /* For other TLS symbols that bind locally, add the section
+ TLS offset to the addend. */
+ else if (sec)
+ ad += sec->output_section->vma - tls_biased_base (info);
+
+ bfd_put_32 (output_bfd,
+ frvfdpic_plt_section (info)->output_section->vma
+ + frvfdpic_plt_section (info)->output_offset
+ + frvfdpic_plt_tls_ret_offset (info),
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->tlsdesc_entry);
+
+ _frvfdpic_add_rofixup (output_bfd,
+ frvfdpic_gotfixup_section (info),
+ frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset
+ + frvfdpic_got_initial_offset (info)
+ + entry->tlsdesc_entry, entry);
+
+ BFD_ASSERT (frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs);
+
+ /* We've used one of the reserved fixups, so discount it so
+ that we can check at the end that we've used them
+ all. */
+ frvfdpic_dynamic_got_plt_info (info)->tls_ret_refs--;
+
+ /* While at that, make sure the ret instruction makes to the
+ right location in the PLT. We could do it only when we
+ got to 0, but since the check at the end will only print
+ a warning, make sure we have the ret in place in case the
+ warning is missed. */
+ bfd_put_32 (output_bfd, 0xc03a4000,
+ frvfdpic_plt_section (info)->contents
+ + frvfdpic_plt_tls_ret_offset (info));
+ }
+ else
+ {
+ if (idx == 0
+ && (bfd_is_abs_section (sec)
+ || bfd_is_und_section (sec)))
+ {
+ if (! elf_hash_table (info)->tls_sec)
+ {
+ (*info->callbacks->undefined_symbol)
+ (info, "TLS section", elf_hash_table (info)->dynobj,
+ frvfdpic_got_section (info), entry->tlsdesc_entry, TRUE);
+ return FALSE;
+ }
+ idx = elf_section_data (elf_hash_table (info)->tls_sec)->dynindx;
+ ad += FRVFDPIC_TLS_BIAS;
+ }
+
+ _frvfdpic_add_dyn_reloc (output_bfd, frvfdpic_gotrel_section (info),
+ _bfd_elf_section_offset
+ (output_bfd, info,
+ frvfdpic_got_section (info),
+ frvfdpic_got_initial_offset (info)
+ + entry->tlsdesc_entry)
+ + frvfdpic_got_section (info)
+ ->output_section->vma
+ + frvfdpic_got_section (info)
+ ->output_offset,
+ R_FRV_TLSDESC_VALUE, idx, ad, entry);
+
+ bfd_put_32 (output_bfd, 0,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->tlsdesc_entry);
+ }
+
+ bfd_put_32 (output_bfd, ad,
+ frvfdpic_got_section (info)->contents
+ + frvfdpic_got_initial_offset (info)
+ + entry->tlsdesc_entry + 4);
+ }
+
+ /* Generate code for the get-TLS-offset PLT entry. */
+ if (entry->tlsplt_entry != (bfd_vma) -1)
+ {
+ bfd_byte *plt_code = frvfdpic_plt_section (info)->contents
+ + entry->tlsplt_entry;
+
+ if (bfd_link_executable (info)
+ && (entry->symndx != -1
+ || FRVFDPIC_SYM_LOCAL (info, entry->d.h)))
+ {
+ int idx = dynindx;
+ bfd_vma ad = addend;
+
+ /* sec may be NULL when referencing an undefweak symbol
+ while linking a static executable. */
+ if (!sec)
+ {
+ BFD_ASSERT (entry->symndx == -1
+ && entry->d.h->root.type == bfd_link_hash_undefweak);
+ }
+ else
+ {
+ if (entry->symndx == -1)
+ ad += entry->d.h->root.u.def.value;
+ else
+ ad += sym->st_value;
+ ad += sec->output_offset;
+ if (sec->output_section
+ && elf_section_data (sec->output_section))
+ idx = elf_section_data (sec->output_section)->dynindx;
+ else
+ idx = 0;
+ }
+
+ /* *ABS*+addend is special for TLS relocations, use only the
+ addend for the TLS offset, and take the module id as
+ 0. */
+ if (idx == 0
+ && (bfd_is_abs_section (sec)
+ || bfd_is_und_section (sec)))
+ ;
+ /* For other TLS symbols that bind locally, add the section
+ TLS offset to the addend. */
+ else if (sec)
+ ad += sec->output_section->vma - tls_biased_base (info);
+
+ if ((bfd_signed_vma)ad >= -(1 << (16 - 1))
+ && (bfd_signed_vma)ad < (1 << (16 - 1)))
+ {
+ /* setlos lo(ad), gr9 */
+ bfd_put_32 (output_bfd,
+ 0x92fc0000
+ | (ad
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ /* sethi.p hi(ad), gr9
+ setlo lo(ad), gr9 */
+ bfd_put_32 (output_bfd,
+ 0x12f80000
+ | ((ad >> 16)
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ bfd_put_32 (output_bfd,
+ 0x92f40000
+ | (ad
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ /* ret */
+ bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
+ }
+ else if (entry->tlsoff_entry)
+ {
+ /* Figure out what kind of PLT entry we need, depending on the
+ location of the TLS descriptor within the GOT. */
+ if (entry->tlsoff_entry >= -(1 << (12 - 1))
+ && entry->tlsoff_entry < (1 << (12 - 1)))
+ {
+ /* ldi @(gr15, tlsoff_entry), gr9 */
+ bfd_put_32 (output_bfd,
+ 0x92c8f000 | (entry->tlsoff_entry
+ & ((1 << 12) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ if (entry->tlsoff_entry >= -(1 << (16 - 1))
+ && entry->tlsoff_entry < (1 << (16 - 1)))
+ {
+ /* setlos lo(tlsoff_entry), gr8 */
+ bfd_put_32 (output_bfd,
+ 0x90fc0000
+ | (entry->tlsoff_entry
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ /* sethi.p hi(tlsoff_entry), gr8
+ setlo lo(tlsoff_entry), gr8 */
+ bfd_put_32 (output_bfd,
+ 0x10f80000
+ | ((entry->tlsoff_entry >> 16)
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ bfd_put_32 (output_bfd,
+ 0x90f40000
+ | (entry->tlsoff_entry
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ /* ld @(gr15,gr8),gr9 */
+ bfd_put_32 (output_bfd, 0x9008f108, plt_code);
+ plt_code += 4;
+ }
+ /* ret */
+ bfd_put_32 (output_bfd, 0xc03a4000, plt_code);
+ }
+ else
+ {
+ BFD_ASSERT (entry->tlsdesc_entry);
+
+ /* Figure out what kind of PLT entry we need, depending on the
+ location of the TLS descriptor within the GOT. */
+ if (entry->tlsdesc_entry >= -(1 << (12 - 1))
+ && entry->tlsdesc_entry < (1 << (12 - 1)))
+ {
+ /* lddi @(gr15, tlsdesc_entry), gr8 */
+ bfd_put_32 (output_bfd,
+ 0x90ccf000 | (entry->tlsdesc_entry
+ & ((1 << 12) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ if (entry->tlsdesc_entry >= -(1 << (16 - 1))
+ && entry->tlsdesc_entry < (1 << (16 - 1)))
+ {
+ /* setlos lo(tlsdesc_entry), gr8 */
+ bfd_put_32 (output_bfd,
+ 0x90fc0000
+ | (entry->tlsdesc_entry
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ else
+ {
+ /* sethi.p hi(tlsdesc_entry), gr8
+ setlo lo(tlsdesc_entry), gr8 */
+ bfd_put_32 (output_bfd,
+ 0x10f80000
+ | ((entry->tlsdesc_entry >> 16)
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ bfd_put_32 (output_bfd,
+ 0x90f40000
+ | (entry->tlsdesc_entry
+ & (((bfd_vma)1 << 16) - 1)),
+ plt_code);
+ plt_code += 4;
+ }
+ /* ldd @(gr15,gr8),gr8 */
+ bfd_put_32 (output_bfd, 0x9008f148, plt_code);
+ plt_code += 4;
+ }
+ /* jmpl @(gr8,gr0) */
+ bfd_put_32 (output_bfd, 0x80308000, plt_code);
+ }
+ }
+
+ return TRUE;
+}
+
+/* Handle an FRV small data reloc. */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprel12 (struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ Elf_Internal_Rela *relocation,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+ bfd_vma gp;
+ struct bfd_link_hash_entry *h;
+
+ h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
+
+ gp = (h->u.def.value
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
+
+ value -= input_section->output_section->vma;
+ value -= (gp - input_section->output_section->vma);
+
+ insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+
+ value += relocation->r_addend;
+
+ if ((long) value > 0x7ff || (long) value < -0x800)
+ return bfd_reloc_overflow;
+
+ bfd_put_32 (input_bfd,
+ (insn & 0xfffff000) | (value & 0xfff),
+ contents + relocation->r_offset);
+
+ return bfd_reloc_ok;
+}
+
+/* Handle an FRV small data reloc. for the u12 field. */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprelu12 (struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ Elf_Internal_Rela *relocation,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+ bfd_vma gp;
+ struct bfd_link_hash_entry *h;
+ bfd_vma mask;
+
+ h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
+
+ gp = (h->u.def.value
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
+
+ value -= input_section->output_section->vma;
+ value -= (gp - input_section->output_section->vma);
+
+ insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+
+ value += relocation->r_addend;
+
+ if ((long) value > 0x7ff || (long) value < -0x800)
+ return bfd_reloc_overflow;
+
+ /* The high 6 bits go into bits 17-12. The low 6 bits go into bits 5-0. */
+ mask = 0x3f03f;
+ insn = (insn & ~mask) | ((value & 0xfc0) << 12) | (value & 0x3f);
+
+ bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
+
+ return bfd_reloc_ok;
+}
+
+/* Handle an FRV ELF HI16 reloc. */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_hi16 (bfd *input_bfd,
+ Elf_Internal_Rela *relhi,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+
+ insn = bfd_get_32 (input_bfd, contents + relhi->r_offset);
+
+ value += relhi->r_addend;
+ value = ((value >> 16) & 0xffff);
+
+ insn = (insn & 0xffff0000) | value;
+
+ if ((long) value > 0xffff || (long) value < -0x10000)
+ return bfd_reloc_overflow;
+
+ bfd_put_32 (input_bfd, insn, contents + relhi->r_offset);
+ return bfd_reloc_ok;
+
+}
+static bfd_reloc_status_type
+elf32_frv_relocate_lo16 (bfd *input_bfd,
+ Elf_Internal_Rela *rello,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+
+ insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
+
+ value += rello->r_addend;
+ value = value & 0xffff;
+
+ insn = (insn & 0xffff0000) | value;
+
+ if ((long) value > 0xffff || (long) value < -0x10000)
+ return bfd_reloc_overflow;
+
+ bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
+ return bfd_reloc_ok;
+}
+
+/* Perform the relocation for the CALL label24 instruction. */
+
+static bfd_reloc_status_type
+elf32_frv_relocate_label24 (bfd *input_bfd,
+ asection *input_section,
+ Elf_Internal_Rela *rello,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+ bfd_vma label6;
+ bfd_vma label18;
+
+ /* The format for the call instruction is:
+
+ 0 000000 0001111 000000000000000000
+ label6 opcode label18
+
+ The branch calculation is: pc + (4*label24)
+ where label24 is the concatenation of label6 and label18. */
+
+ /* Grab the instruction. */
+ insn = bfd_get_32 (input_bfd, contents + rello->r_offset);
+
+ value -= input_section->output_section->vma + input_section->output_offset;
+ value -= rello->r_offset;
+ value += rello->r_addend;
+
+ value = value >> 2;
+
+ label6 = value & 0xfc0000;
+ label6 = label6 << 7;
+
+ label18 = value & 0x3ffff;
+
+ insn = insn & 0x803c0000;
+ insn = insn | label6;
+ insn = insn | label18;
+
+ bfd_put_32 (input_bfd, insn, contents + rello->r_offset);
+
+ return bfd_reloc_ok;
+}
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprelhi (struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ Elf_Internal_Rela *relocation,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+ bfd_vma gp;
+ struct bfd_link_hash_entry *h;
+
+ h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
+
+ gp = (h->u.def.value
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
+
+ value -= input_section->output_section->vma;
+ value -= (gp - input_section->output_section->vma);
+ value += relocation->r_addend;
+ value = ((value >> 16) & 0xffff);
+
+ if ((long) value > 0xffff || (long) value < -0x10000)
+ return bfd_reloc_overflow;
+
+ insn = bfd_get_32 (input_bfd, contents + relocation->r_offset);
+ insn = (insn & 0xffff0000) | value;
+
+ bfd_put_32 (input_bfd, insn, contents + relocation->r_offset);
+ return bfd_reloc_ok;
+}
+
+static bfd_reloc_status_type
+elf32_frv_relocate_gprello (struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ Elf_Internal_Rela *relocation,
+ bfd_byte *contents,
+ bfd_vma value)
+{
+ bfd_vma insn;
+ bfd_vma gp;
+ struct bfd_link_hash_entry *h;
+
+ h = bfd_link_hash_lookup (info->hash, "_gp", FALSE, FALSE, TRUE);
+
+ gp = (h->u.def.value
+ + h->u.def.section->output_section->vma
+ + h->u.def.section->output_offset);
+
+ value -= input_section->output_section->vma;
+ value -= (gp - input_section->output_section->vma);