+ switch (r_type)
+ {
+ /* This is any 22 bit branch. In PA2.0 syntax it corresponds to
+ the "B" instruction. */
+ case R_PARISC_PCREL22F:
+ case R_PARISC_PCREL22C:
+ return (insn & ~0x3ff1ffd) | re_assemble_22 (sym_value);
+
+ /* This is any 12 bit branch. */
+ case R_PARISC_PCREL12F:
+ return (insn & ~0x1ffd) | re_assemble_12 (sym_value);
+
+ /* This is any 17 bit branch. In PA2.0 syntax it also corresponds
+ to the "B" instruction as well as BE. */
+ case R_PARISC_PCREL17F:
+ case R_PARISC_DIR17F:
+ case R_PARISC_DIR17R:
+ case R_PARISC_PCREL17C:
+ case R_PARISC_PCREL17R:
+ return (insn & ~0x1f1ffd) | re_assemble_17 (sym_value);
+
+ /* ADDIL or LDIL instructions. */
+ case R_PARISC_DLTREL21L:
+ case R_PARISC_DLTIND21L:
+ case R_PARISC_LTOFF_FPTR21L:
+ case R_PARISC_PCREL21L:
+ case R_PARISC_LTOFF_TP21L:
+ case R_PARISC_DPREL21L:
+ case R_PARISC_PLTOFF21L:
+ case R_PARISC_DIR21L:
+ return (insn & ~0x1fffff) | re_assemble_21 (sym_value);
+
+ /* LDO and integer loads/stores with 14 bit displacements. */
+ case R_PARISC_DLTREL14R:
+ case R_PARISC_DLTREL14F:
+ case R_PARISC_DLTIND14R:
+ case R_PARISC_DLTIND14F:
+ case R_PARISC_LTOFF_FPTR14R:
+ case R_PARISC_PCREL14R:
+ case R_PARISC_PCREL14F:
+ case R_PARISC_LTOFF_TP14R:
+ case R_PARISC_LTOFF_TP14F:
+ case R_PARISC_DPREL14R:
+ case R_PARISC_DPREL14F:
+ case R_PARISC_PLTOFF14R:
+ case R_PARISC_PLTOFF14F:
+ case R_PARISC_DIR14R:
+ case R_PARISC_DIR14F:
+ return (insn & ~0x3fff) | low_sign_unext (sym_value, 14);
+
+ /* PA2.0W LDO and integer loads/stores with 16 bit displacements. */
+ case R_PARISC_LTOFF_FPTR16F:
+ case R_PARISC_PCREL16F:
+ case R_PARISC_LTOFF_TP16F:
+ case R_PARISC_GPREL16F:
+ case R_PARISC_PLTOFF16F:
+ case R_PARISC_DIR16F:
+ case R_PARISC_LTOFF16F:
+ return (insn & ~0xffff) | re_assemble_16 (sym_value);
+
+ /* Doubleword loads and stores with a 14 bit displacement. */
+ case R_PARISC_DLTREL14DR:
+ case R_PARISC_DLTIND14DR:
+ case R_PARISC_LTOFF_FPTR14DR:
+ case R_PARISC_LTOFF_FPTR16DF:
+ case R_PARISC_PCREL14DR:
+ case R_PARISC_PCREL16DF:
+ case R_PARISC_LTOFF_TP14DR:
+ case R_PARISC_LTOFF_TP16DF:
+ case R_PARISC_DPREL14DR:
+ case R_PARISC_GPREL16DF:
+ case R_PARISC_PLTOFF14DR:
+ case R_PARISC_PLTOFF16DF:
+ case R_PARISC_DIR14DR:
+ case R_PARISC_DIR16DF:
+ case R_PARISC_LTOFF16DF:
+ return (insn & ~0x3ff1) | (((sym_value & 0x2000) >> 13)
+ | ((sym_value & 0x1ff8) << 1));
+
+ /* Floating point single word load/store instructions. */
+ case R_PARISC_DLTREL14WR:
+ case R_PARISC_DLTIND14WR:
+ case R_PARISC_LTOFF_FPTR14WR:
+ case R_PARISC_LTOFF_FPTR16WF:
+ case R_PARISC_PCREL14WR:
+ case R_PARISC_PCREL16WF:
+ case R_PARISC_LTOFF_TP14WR:
+ case R_PARISC_LTOFF_TP16WF:
+ case R_PARISC_DPREL14WR:
+ case R_PARISC_GPREL16WF:
+ case R_PARISC_PLTOFF14WR:
+ case R_PARISC_PLTOFF16WF:
+ case R_PARISC_DIR16WF:
+ case R_PARISC_DIR14WR:
+ case R_PARISC_LTOFF16WF:
+ return (insn & ~0x3ff9) | (((sym_value & 0x2000) >> 13)
+ | ((sym_value & 0x1ffc) << 1));
+
+ default:
+ return insn;
+ }
+}
+
+/* Compute the value for a relocation (REL) during a final link stage,
+ then insert the value into the proper location in CONTENTS.
+
+ VALUE is a tentative value for the relocation and may be overridden
+ and modified here based on the specific relocation to be performed.
+
+ For example we do conversions for PC-relative branches in this routine
+ or redirection of calls to external routines to stubs.
+
+ The work of actually applying the relocation is left to a helper
+ routine in an attempt to reduce the complexity and size of this
+ function. */
+
+static bfd_reloc_status_type
+elf_hppa_final_link_relocate (Elf_Internal_Rela *rel,
+ bfd *input_bfd,
+ bfd *output_bfd,
+ asection *input_section,
+ bfd_byte *contents,
+ bfd_vma value,
+ struct bfd_link_info *info,
+ asection *sym_sec,
+ struct elf_link_hash_entry *eh)
+{
+ struct elf64_hppa_link_hash_table *hppa_info = hppa_link_hash_table (info);
+ struct elf64_hppa_link_hash_entry *hh = hppa_elf_hash_entry (eh);
+ bfd_vma *local_offsets;
+ Elf_Internal_Shdr *symtab_hdr;
+ int insn;
+ bfd_vma max_branch_offset = 0;
+ bfd_vma offset = rel->r_offset;
+ bfd_signed_vma addend = rel->r_addend;
+ reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
+ unsigned int r_symndx = ELF_R_SYM (rel->r_info);
+ unsigned int r_type = howto->type;
+ bfd_byte *hit_data = contents + offset;
+
+ if (hppa_info == NULL)
+ return bfd_reloc_notsupported;
+
+ symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+ local_offsets = elf_local_got_offsets (input_bfd);
+ insn = bfd_get_32 (input_bfd, hit_data);
+
+ switch (r_type)
+ {
+ case R_PARISC_NONE:
+ break;
+
+ /* Basic function call support.
+
+ Note for a call to a function defined in another dynamic library
+ we want to redirect the call to a stub. */
+
+ /* PC relative relocs without an implicit offset. */
+ case R_PARISC_PCREL21L:
+ case R_PARISC_PCREL14R:
+ case R_PARISC_PCREL14F:
+ case R_PARISC_PCREL14WR:
+ case R_PARISC_PCREL14DR:
+ case R_PARISC_PCREL16F:
+ case R_PARISC_PCREL16WF:
+ case R_PARISC_PCREL16DF:
+ {
+ /* If this is a call to a function defined in another dynamic
+ library, then redirect the call to the local stub for this
+ function. */
+ if (sym_sec == NULL || sym_sec->output_section == NULL)
+ value = (hh->stub_offset + hppa_info->stub_sec->output_offset
+ + hppa_info->stub_sec->output_section->vma);
+
+ /* Turn VALUE into a proper PC relative address. */
+ value -= (offset + input_section->output_offset
+ + input_section->output_section->vma);
+
+ /* Adjust for any field selectors. */
+ if (r_type == R_PARISC_PCREL21L)
+ value = hppa_field_adjust (value, -8 + addend, e_lsel);
+ else if (r_type == R_PARISC_PCREL14F
+ || r_type == R_PARISC_PCREL16F
+ || r_type == R_PARISC_PCREL16WF
+ || r_type == R_PARISC_PCREL16DF)
+ value = hppa_field_adjust (value, -8 + addend, e_fsel);
+ else
+ value = hppa_field_adjust (value, -8 + addend, e_rsel);
+
+ /* Apply the relocation to the given instruction. */
+ insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
+ break;
+ }
+
+ case R_PARISC_PCREL12F:
+ case R_PARISC_PCREL22F:
+ case R_PARISC_PCREL17F:
+ case R_PARISC_PCREL22C:
+ case R_PARISC_PCREL17C:
+ case R_PARISC_PCREL17R:
+ {
+ /* If this is a call to a function defined in another dynamic
+ library, then redirect the call to the local stub for this
+ function. */
+ if (sym_sec == NULL || sym_sec->output_section == NULL)
+ value = (hh->stub_offset + hppa_info->stub_sec->output_offset
+ + hppa_info->stub_sec->output_section->vma);
+
+ /* Turn VALUE into a proper PC relative address. */
+ value -= (offset + input_section->output_offset
+ + input_section->output_section->vma);
+ addend -= 8;
+
+ if (r_type == (unsigned int) R_PARISC_PCREL22F)
+ max_branch_offset = (1 << (22-1)) << 2;
+ else if (r_type == (unsigned int) R_PARISC_PCREL17F)
+ max_branch_offset = (1 << (17-1)) << 2;
+ else if (r_type == (unsigned int) R_PARISC_PCREL12F)
+ max_branch_offset = (1 << (12-1)) << 2;
+
+ /* Make sure we can reach the branch target. */
+ if (max_branch_offset != 0
+ && value + addend + max_branch_offset >= 2*max_branch_offset)
+ {
+ _bfd_error_handler
+ /* xgettext:c-format */
+ (_("%B(%A+0x%" BFD_VMA_FMT "x): cannot reach %s"),
+ input_bfd,
+ input_section,
+ offset,
+ eh ? eh->root.root.string : "unknown");
+ bfd_set_error (bfd_error_bad_value);
+ return bfd_reloc_overflow;
+ }
+
+ /* Adjust for any field selectors. */
+ if (r_type == R_PARISC_PCREL17R)
+ value = hppa_field_adjust (value, addend, e_rsel);
+ else
+ value = hppa_field_adjust (value, addend, e_fsel);
+
+ /* All branches are implicitly shifted by 2 places. */
+ value >>= 2;
+
+ /* Apply the relocation to the given instruction. */
+ insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
+ break;
+ }
+
+ /* Indirect references to data through the DLT. */
+ case R_PARISC_DLTIND14R:
+ case R_PARISC_DLTIND14F:
+ case R_PARISC_DLTIND14DR:
+ case R_PARISC_DLTIND14WR:
+ case R_PARISC_DLTIND21L:
+ case R_PARISC_LTOFF_FPTR14R:
+ case R_PARISC_LTOFF_FPTR14DR:
+ case R_PARISC_LTOFF_FPTR14WR:
+ case R_PARISC_LTOFF_FPTR21L:
+ case R_PARISC_LTOFF_FPTR16F:
+ case R_PARISC_LTOFF_FPTR16WF:
+ case R_PARISC_LTOFF_FPTR16DF:
+ case R_PARISC_LTOFF_TP21L:
+ case R_PARISC_LTOFF_TP14R:
+ case R_PARISC_LTOFF_TP14F:
+ case R_PARISC_LTOFF_TP14WR:
+ case R_PARISC_LTOFF_TP14DR:
+ case R_PARISC_LTOFF_TP16F:
+ case R_PARISC_LTOFF_TP16WF:
+ case R_PARISC_LTOFF_TP16DF:
+ case R_PARISC_LTOFF16F:
+ case R_PARISC_LTOFF16WF:
+ case R_PARISC_LTOFF16DF:
+ {
+ bfd_vma off;
+
+ /* If this relocation was against a local symbol, then we still
+ have not set up the DLT entry (it's not convenient to do so
+ in the "finalize_dlt" routine because it is difficult to get
+ to the local symbol's value).
+
+ So, if this is a local symbol (h == NULL), then we need to
+ fill in its DLT entry.
+
+ Similarly we may still need to set up an entry in .opd for
+ a local function which had its address taken. */
+ if (hh == NULL)
+ {
+ bfd_vma *local_opd_offsets, *local_dlt_offsets;
+
+ if (local_offsets == NULL)
+ abort ();
+
+ /* Now do .opd creation if needed. */
+ if (r_type == R_PARISC_LTOFF_FPTR14R
+ || r_type == R_PARISC_LTOFF_FPTR14DR
+ || r_type == R_PARISC_LTOFF_FPTR14WR
+ || r_type == R_PARISC_LTOFF_FPTR21L
+ || r_type == R_PARISC_LTOFF_FPTR16F
+ || r_type == R_PARISC_LTOFF_FPTR16WF
+ || r_type == R_PARISC_LTOFF_FPTR16DF)
+ {
+ local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
+ off = local_opd_offsets[r_symndx];
+
+ /* The last bit records whether we've already initialised
+ this local .opd entry. */
+ if ((off & 1) != 0)
+ {
+ BFD_ASSERT (off != (bfd_vma) -1);
+ off &= ~1;
+ }
+ else
+ {
+ local_opd_offsets[r_symndx] |= 1;
+
+ /* The first two words of an .opd entry are zero. */
+ memset (hppa_info->opd_sec->contents + off, 0, 16);
+
+ /* The next word is the address of the function. */
+ bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
+ (hppa_info->opd_sec->contents + off + 16));
+
+ /* The last word is our local __gp value. */
+ value = _bfd_get_gp_value
+ (hppa_info->opd_sec->output_section->owner);
+ bfd_put_64 (hppa_info->opd_sec->owner, value,
+ (hppa_info->opd_sec->contents + off + 24));
+ }
+
+ /* The DLT value is the address of the .opd entry. */
+ value = (off
+ + hppa_info->opd_sec->output_offset
+ + hppa_info->opd_sec->output_section->vma);
+ addend = 0;
+ }
+
+ local_dlt_offsets = local_offsets;
+ off = local_dlt_offsets[r_symndx];
+
+ if ((off & 1) != 0)
+ {
+ BFD_ASSERT (off != (bfd_vma) -1);
+ off &= ~1;
+ }
+ else
+ {
+ local_dlt_offsets[r_symndx] |= 1;
+ bfd_put_64 (hppa_info->dlt_sec->owner,
+ value + addend,
+ hppa_info->dlt_sec->contents + off);
+ }
+ }
+ else
+ off = hh->dlt_offset;
+
+ /* We want the value of the DLT offset for this symbol, not
+ the symbol's actual address. Note that __gp may not point
+ to the start of the DLT, so we have to compute the absolute
+ address, then subtract out the value of __gp. */
+ value = (off
+ + hppa_info->dlt_sec->output_offset
+ + hppa_info->dlt_sec->output_section->vma);
+ value -= _bfd_get_gp_value (output_bfd);
+
+ /* All DLTIND relocations are basically the same at this point,
+ except that we need different field selectors for the 21bit
+ version vs the 14bit versions. */
+ if (r_type == R_PARISC_DLTIND21L
+ || r_type == R_PARISC_LTOFF_FPTR21L
+ || r_type == R_PARISC_LTOFF_TP21L)
+ value = hppa_field_adjust (value, 0, e_lsel);
+ else if (r_type == R_PARISC_DLTIND14F
+ || r_type == R_PARISC_LTOFF_FPTR16F
+ || r_type == R_PARISC_LTOFF_FPTR16WF
+ || r_type == R_PARISC_LTOFF_FPTR16DF
+ || r_type == R_PARISC_LTOFF16F
+ || r_type == R_PARISC_LTOFF16DF
+ || r_type == R_PARISC_LTOFF16WF
+ || r_type == R_PARISC_LTOFF_TP16F
+ || r_type == R_PARISC_LTOFF_TP16WF
+ || r_type == R_PARISC_LTOFF_TP16DF)
+ value = hppa_field_adjust (value, 0, e_fsel);
+ else
+ value = hppa_field_adjust (value, 0, e_rsel);
+
+ insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
+ break;
+ }
+
+ case R_PARISC_DLTREL14R:
+ case R_PARISC_DLTREL14F:
+ case R_PARISC_DLTREL14DR:
+ case R_PARISC_DLTREL14WR:
+ case R_PARISC_DLTREL21L:
+ case R_PARISC_DPREL21L:
+ case R_PARISC_DPREL14WR:
+ case R_PARISC_DPREL14DR:
+ case R_PARISC_DPREL14R:
+ case R_PARISC_DPREL14F:
+ case R_PARISC_GPREL16F:
+ case R_PARISC_GPREL16WF:
+ case R_PARISC_GPREL16DF:
+ {
+ /* Subtract out the global pointer value to make value a DLT
+ relative address. */
+ value -= _bfd_get_gp_value (output_bfd);
+
+ /* All DLTREL relocations are basically the same at this point,
+ except that we need different field selectors for the 21bit
+ version vs the 14bit versions. */
+ if (r_type == R_PARISC_DLTREL21L
+ || r_type == R_PARISC_DPREL21L)
+ value = hppa_field_adjust (value, addend, e_lrsel);
+ else if (r_type == R_PARISC_DLTREL14F
+ || r_type == R_PARISC_DPREL14F
+ || r_type == R_PARISC_GPREL16F
+ || r_type == R_PARISC_GPREL16WF
+ || r_type == R_PARISC_GPREL16DF)
+ value = hppa_field_adjust (value, addend, e_fsel);
+ else
+ value = hppa_field_adjust (value, addend, e_rrsel);
+
+ insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
+ break;
+ }
+
+ case R_PARISC_DIR21L:
+ case R_PARISC_DIR17R:
+ case R_PARISC_DIR17F:
+ case R_PARISC_DIR14R:
+ case R_PARISC_DIR14F:
+ case R_PARISC_DIR14WR:
+ case R_PARISC_DIR14DR:
+ case R_PARISC_DIR16F:
+ case R_PARISC_DIR16WF:
+ case R_PARISC_DIR16DF:
+ {
+ /* All DIR relocations are basically the same at this point,
+ except that branch offsets need to be divided by four, and
+ we need different field selectors. Note that we don't
+ redirect absolute calls to local stubs. */
+
+ if (r_type == R_PARISC_DIR21L)
+ value = hppa_field_adjust (value, addend, e_lrsel);
+ else if (r_type == R_PARISC_DIR17F
+ || r_type == R_PARISC_DIR16F
+ || r_type == R_PARISC_DIR16WF
+ || r_type == R_PARISC_DIR16DF
+ || r_type == R_PARISC_DIR14F)
+ value = hppa_field_adjust (value, addend, e_fsel);
+ else
+ value = hppa_field_adjust (value, addend, e_rrsel);
+
+ if (r_type == R_PARISC_DIR17R || r_type == R_PARISC_DIR17F)
+ /* All branches are implicitly shifted by 2 places. */
+ value >>= 2;
+
+ insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
+ break;
+ }
+
+ case R_PARISC_PLTOFF21L:
+ case R_PARISC_PLTOFF14R:
+ case R_PARISC_PLTOFF14F:
+ case R_PARISC_PLTOFF14WR:
+ case R_PARISC_PLTOFF14DR:
+ case R_PARISC_PLTOFF16F:
+ case R_PARISC_PLTOFF16WF:
+ case R_PARISC_PLTOFF16DF:
+ {
+ /* We want the value of the PLT offset for this symbol, not
+ the symbol's actual address. Note that __gp may not point
+ to the start of the DLT, so we have to compute the absolute
+ address, then subtract out the value of __gp. */
+ value = (hh->plt_offset
+ + hppa_info->plt_sec->output_offset
+ + hppa_info->plt_sec->output_section->vma);
+ value -= _bfd_get_gp_value (output_bfd);
+
+ /* All PLTOFF relocations are basically the same at this point,
+ except that we need different field selectors for the 21bit
+ version vs the 14bit versions. */
+ if (r_type == R_PARISC_PLTOFF21L)
+ value = hppa_field_adjust (value, addend, e_lrsel);
+ else if (r_type == R_PARISC_PLTOFF14F
+ || r_type == R_PARISC_PLTOFF16F
+ || r_type == R_PARISC_PLTOFF16WF
+ || r_type == R_PARISC_PLTOFF16DF)
+ value = hppa_field_adjust (value, addend, e_fsel);
+ else
+ value = hppa_field_adjust (value, addend, e_rrsel);
+
+ insn = elf_hppa_relocate_insn (insn, (int) value, r_type);
+ break;
+ }
+
+ case R_PARISC_LTOFF_FPTR32:
+ {
+ /* We may still need to create the FPTR itself if it was for
+ a local symbol. */
+ if (hh == NULL)
+ {
+ /* The first two words of an .opd entry are zero. */
+ memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
+
+ /* The next word is the address of the function. */
+ bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
+ (hppa_info->opd_sec->contents
+ + hh->opd_offset + 16));
+
+ /* The last word is our local __gp value. */
+ value = _bfd_get_gp_value
+ (hppa_info->opd_sec->output_section->owner);
+ bfd_put_64 (hppa_info->opd_sec->owner, value,
+ hppa_info->opd_sec->contents + hh->opd_offset + 24);
+
+ /* The DLT value is the address of the .opd entry. */
+ value = (hh->opd_offset
+ + hppa_info->opd_sec->output_offset
+ + hppa_info->opd_sec->output_section->vma);
+
+ bfd_put_64 (hppa_info->dlt_sec->owner,
+ value,
+ hppa_info->dlt_sec->contents + hh->dlt_offset);
+ }
+
+ /* We want the value of the DLT offset for this symbol, not
+ the symbol's actual address. Note that __gp may not point
+ to the start of the DLT, so we have to compute the absolute
+ address, then subtract out the value of __gp. */
+ value = (hh->dlt_offset
+ + hppa_info->dlt_sec->output_offset
+ + hppa_info->dlt_sec->output_section->vma);
+ value -= _bfd_get_gp_value (output_bfd);
+ bfd_put_32 (input_bfd, value, hit_data);
+ return bfd_reloc_ok;
+ }
+
+ case R_PARISC_LTOFF_FPTR64:
+ case R_PARISC_LTOFF_TP64:
+ {
+ /* We may still need to create the FPTR itself if it was for
+ a local symbol. */
+ if (eh == NULL && r_type == R_PARISC_LTOFF_FPTR64)
+ {
+ /* The first two words of an .opd entry are zero. */
+ memset (hppa_info->opd_sec->contents + hh->opd_offset, 0, 16);
+
+ /* The next word is the address of the function. */
+ bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
+ (hppa_info->opd_sec->contents
+ + hh->opd_offset + 16));
+
+ /* The last word is our local __gp value. */
+ value = _bfd_get_gp_value
+ (hppa_info->opd_sec->output_section->owner);
+ bfd_put_64 (hppa_info->opd_sec->owner, value,
+ hppa_info->opd_sec->contents + hh->opd_offset + 24);
+
+ /* The DLT value is the address of the .opd entry. */
+ value = (hh->opd_offset
+ + hppa_info->opd_sec->output_offset
+ + hppa_info->opd_sec->output_section->vma);
+
+ bfd_put_64 (hppa_info->dlt_sec->owner,
+ value,
+ hppa_info->dlt_sec->contents + hh->dlt_offset);
+ }
+
+ /* We want the value of the DLT offset for this symbol, not
+ the symbol's actual address. Note that __gp may not point
+ to the start of the DLT, so we have to compute the absolute
+ address, then subtract out the value of __gp. */
+ value = (hh->dlt_offset
+ + hppa_info->dlt_sec->output_offset
+ + hppa_info->dlt_sec->output_section->vma);
+ value -= _bfd_get_gp_value (output_bfd);
+ bfd_put_64 (input_bfd, value, hit_data);
+ return bfd_reloc_ok;
+ }
+
+ case R_PARISC_DIR32:
+ bfd_put_32 (input_bfd, value + addend, hit_data);
+ return bfd_reloc_ok;
+
+ case R_PARISC_DIR64:
+ bfd_put_64 (input_bfd, value + addend, hit_data);
+ return bfd_reloc_ok;
+
+ case R_PARISC_GPREL64:
+ /* Subtract out the global pointer value to make value a DLT
+ relative address. */
+ value -= _bfd_get_gp_value (output_bfd);
+
+ bfd_put_64 (input_bfd, value + addend, hit_data);
+ return bfd_reloc_ok;
+
+ case R_PARISC_LTOFF64:
+ /* We want the value of the DLT offset for this symbol, not
+ the symbol's actual address. Note that __gp may not point
+ to the start of the DLT, so we have to compute the absolute
+ address, then subtract out the value of __gp. */
+ value = (hh->dlt_offset
+ + hppa_info->dlt_sec->output_offset
+ + hppa_info->dlt_sec->output_section->vma);
+ value -= _bfd_get_gp_value (output_bfd);
+
+ bfd_put_64 (input_bfd, value + addend, hit_data);
+ return bfd_reloc_ok;
+
+ case R_PARISC_PCREL32:
+ {
+ /* If this is a call to a function defined in another dynamic
+ library, then redirect the call to the local stub for this
+ function. */
+ if (sym_sec == NULL || sym_sec->output_section == NULL)
+ value = (hh->stub_offset + hppa_info->stub_sec->output_offset
+ + hppa_info->stub_sec->output_section->vma);
+
+ /* Turn VALUE into a proper PC relative address. */
+ value -= (offset + input_section->output_offset
+ + input_section->output_section->vma);
+
+ value += addend;
+ value -= 8;
+ bfd_put_32 (input_bfd, value, hit_data);
+ return bfd_reloc_ok;
+ }
+
+ case R_PARISC_PCREL64:
+ {
+ /* If this is a call to a function defined in another dynamic
+ library, then redirect the call to the local stub for this
+ function. */
+ if (sym_sec == NULL || sym_sec->output_section == NULL)
+ value = (hh->stub_offset + hppa_info->stub_sec->output_offset
+ + hppa_info->stub_sec->output_section->vma);
+
+ /* Turn VALUE into a proper PC relative address. */
+ value -= (offset + input_section->output_offset
+ + input_section->output_section->vma);
+
+ value += addend;
+ value -= 8;
+ bfd_put_64 (input_bfd, value, hit_data);
+ return bfd_reloc_ok;
+ }
+
+ case R_PARISC_FPTR64:
+ {
+ bfd_vma off;
+
+ /* We may still need to create the FPTR itself if it was for
+ a local symbol. */
+ if (hh == NULL)
+ {
+ bfd_vma *local_opd_offsets;
+
+ if (local_offsets == NULL)
+ abort ();
+
+ local_opd_offsets = local_offsets + 2 * symtab_hdr->sh_info;
+ off = local_opd_offsets[r_symndx];
+
+ /* The last bit records whether we've already initialised
+ this local .opd entry. */
+ if ((off & 1) != 0)
+ {
+ BFD_ASSERT (off != (bfd_vma) -1);
+ off &= ~1;
+ }
+ else
+ {
+ /* The first two words of an .opd entry are zero. */
+ memset (hppa_info->opd_sec->contents + off, 0, 16);
+
+ /* The next word is the address of the function. */
+ bfd_put_64 (hppa_info->opd_sec->owner, value + addend,
+ (hppa_info->opd_sec->contents + off + 16));
+
+ /* The last word is our local __gp value. */
+ value = _bfd_get_gp_value
+ (hppa_info->opd_sec->output_section->owner);
+ bfd_put_64 (hppa_info->opd_sec->owner, value,
+ hppa_info->opd_sec->contents + off + 24);
+ }
+ }
+ else
+ off = hh->opd_offset;
+
+ if (hh == NULL || hh->want_opd)
+ /* We want the value of the OPD offset for this symbol. */
+ value = (off
+ + hppa_info->opd_sec->output_offset
+ + hppa_info->opd_sec->output_section->vma);
+ else
+ /* We want the address of the symbol. */
+ value += addend;
+
+ bfd_put_64 (input_bfd, value, hit_data);
+ return bfd_reloc_ok;
+ }
+
+ case R_PARISC_SECREL32:
+ if (sym_sec)
+ value -= sym_sec->output_section->vma;
+ bfd_put_32 (input_bfd, value + addend, hit_data);
+ return bfd_reloc_ok;
+
+ case R_PARISC_SEGREL32:
+ case R_PARISC_SEGREL64:
+ {
+ /* If this is the first SEGREL relocation, then initialize
+ the segment base values. */
+ if (hppa_info->text_segment_base == (bfd_vma) -1)
+ bfd_map_over_sections (output_bfd, elf_hppa_record_segment_addrs,
+ hppa_info);
+
+ /* VALUE holds the absolute address. We want to include the
+ addend, then turn it into a segment relative address.
+
+ The segment is derived from SYM_SEC. We assume that there are
+ only two segments of note in the resulting executable/shlib.
+ A readonly segment (.text) and a readwrite segment (.data). */
+ value += addend;
+
+ if (sym_sec->flags & SEC_CODE)
+ value -= hppa_info->text_segment_base;
+ else
+ value -= hppa_info->data_segment_base;
+
+ if (r_type == R_PARISC_SEGREL32)
+ bfd_put_32 (input_bfd, value, hit_data);
+ else
+ bfd_put_64 (input_bfd, value, hit_data);
+ return bfd_reloc_ok;
+ }
+
+ /* Something we don't know how to handle. */
+ default:
+ return bfd_reloc_notsupported;
+ }
+
+ /* Update the instruction word. */
+ bfd_put_32 (input_bfd, (bfd_vma) insn, hit_data);
+ return bfd_reloc_ok;
+}
+
+/* Relocate an HPPA ELF section. */
+
+static bfd_boolean
+elf64_hppa_relocate_section (bfd *output_bfd,
+ struct bfd_link_info *info,
+ bfd *input_bfd,
+ asection *input_section,
+ bfd_byte *contents,
+ Elf_Internal_Rela *relocs,
+ Elf_Internal_Sym *local_syms,
+ asection **local_sections)
+{
+ Elf_Internal_Shdr *symtab_hdr;
+ Elf_Internal_Rela *rel;
+ Elf_Internal_Rela *relend;
+ struct elf64_hppa_link_hash_table *hppa_info;
+
+ hppa_info = hppa_link_hash_table (info);
+ if (hppa_info == NULL)
+ return FALSE;
+
+ symtab_hdr = &elf_tdata (input_bfd)->symtab_hdr;
+
+ rel = relocs;
+ relend = relocs + input_section->reloc_count;
+ for (; rel < relend; rel++)
+ {
+ int r_type;
+ reloc_howto_type *howto = elf_hppa_howto_table + ELF_R_TYPE (rel->r_info);
+ unsigned long r_symndx;
+ struct elf_link_hash_entry *eh;
+ Elf_Internal_Sym *sym;
+ asection *sym_sec;
+ bfd_vma relocation;
+ bfd_reloc_status_type r;
+
+ r_type = ELF_R_TYPE (rel->r_info);
+ if (r_type < 0 || r_type >= (int) R_PARISC_UNIMPLEMENTED)
+ {
+ bfd_set_error (bfd_error_bad_value);
+ return FALSE;
+ }
+ if (r_type == (unsigned int) R_PARISC_GNU_VTENTRY
+ || r_type == (unsigned int) R_PARISC_GNU_VTINHERIT)
+ continue;
+
+ /* This is a final link. */
+ r_symndx = ELF_R_SYM (rel->r_info);
+ eh = NULL;
+ sym = NULL;
+ sym_sec = NULL;
+ if (r_symndx < symtab_hdr->sh_info)
+ {
+ /* This is a local symbol, hh defaults to NULL. */
+ sym = local_syms + r_symndx;
+ sym_sec = local_sections[r_symndx];
+ relocation = _bfd_elf_rela_local_sym (output_bfd, sym, &sym_sec, rel);
+ }
+ else
+ {
+ /* This is not a local symbol. */
+ struct elf_link_hash_entry **sym_hashes = elf_sym_hashes (input_bfd);
+
+ /* It seems this can happen with erroneous or unsupported
+ input (mixing a.out and elf in an archive, for example.) */
+ if (sym_hashes == NULL)
+ return FALSE;
+
+ eh = sym_hashes[r_symndx - symtab_hdr->sh_info];
+
+ if (info->wrap_hash != NULL
+ && (input_section->flags & SEC_DEBUGGING) != 0)
+ eh = ((struct elf_link_hash_entry *)
+ unwrap_hash_lookup (info, input_bfd, &eh->root));
+
+ while (eh->root.type == bfd_link_hash_indirect
+ || eh->root.type == bfd_link_hash_warning)
+ eh = (struct elf_link_hash_entry *) eh->root.u.i.link;
+
+ relocation = 0;
+ if (eh->root.type == bfd_link_hash_defined
+ || eh->root.type == bfd_link_hash_defweak)
+ {
+ sym_sec = eh->root.u.def.section;
+ if (sym_sec != NULL
+ && sym_sec->output_section != NULL)
+ relocation = (eh->root.u.def.value
+ + sym_sec->output_section->vma
+ + sym_sec->output_offset);
+ }
+ else if (eh->root.type == bfd_link_hash_undefweak)
+ ;
+ else if (info->unresolved_syms_in_objects == RM_IGNORE
+ && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT)
+ ;
+ else if (!bfd_link_relocatable (info)
+ && elf_hppa_is_dynamic_loader_symbol (eh->root.root.string))
+ continue;
+ else if (!bfd_link_relocatable (info))
+ {
+ bfd_boolean err;
+ err = (info->unresolved_syms_in_objects == RM_GENERATE_ERROR
+ || ELF_ST_VISIBILITY (eh->other) != STV_DEFAULT);
+ (*info->callbacks->undefined_symbol) (info,
+ eh->root.root.string,
+ input_bfd,
+ input_section,
+ rel->r_offset, err);
+ }
+
+ if (!bfd_link_relocatable (info)
+ && relocation == 0
+ && eh->root.type != bfd_link_hash_defined
+ && eh->root.type != bfd_link_hash_defweak
+ && eh->root.type != bfd_link_hash_undefweak)
+ {
+ if (info->unresolved_syms_in_objects == RM_IGNORE
+ && ELF_ST_VISIBILITY (eh->other) == STV_DEFAULT
+ && eh->type == STT_PARISC_MILLI)
+ (*info->callbacks->undefined_symbol)
+ (info, eh_name (eh), input_bfd,
+ input_section, rel->r_offset, FALSE);
+ }
+ }
+
+ if (sym_sec != NULL && discarded_section (sym_sec))
+ RELOC_AGAINST_DISCARDED_SECTION (info, input_bfd, input_section,
+ rel, 1, relend, howto, 0, contents);
+
+ if (bfd_link_relocatable (info))
+ continue;
+
+ r = elf_hppa_final_link_relocate (rel, input_bfd, output_bfd,
+ input_section, contents,
+ relocation, info, sym_sec,
+ eh);
+
+ if (r != bfd_reloc_ok)
+ {
+ switch (r)
+ {
+ default:
+ abort ();
+ case bfd_reloc_overflow:
+ {
+ const char *sym_name;
+
+ if (eh != NULL)
+ sym_name = NULL;
+ else
+ {
+ sym_name = bfd_elf_string_from_elf_section (input_bfd,
+ symtab_hdr->sh_link,
+ sym->st_name);
+ if (sym_name == NULL)
+ return FALSE;
+ if (*sym_name == '\0')
+ sym_name = bfd_section_name (input_bfd, sym_sec);
+ }
+
+ (*info->callbacks->reloc_overflow)
+ (info, (eh ? &eh->root : NULL), sym_name, howto->name,
+ (bfd_vma) 0, input_bfd, input_section, rel->r_offset);
+ }
+ break;
+ }
+ }
+ }
+ return TRUE;
+}
+
+static const struct bfd_elf_special_section elf64_hppa_special_sections[] =
+{
+ { STRING_COMMA_LEN (".fini"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
+ { STRING_COMMA_LEN (".init"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE },
+ { STRING_COMMA_LEN (".plt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
+ { STRING_COMMA_LEN (".dlt"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
+ { STRING_COMMA_LEN (".sdata"), 0, SHT_PROGBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
+ { STRING_COMMA_LEN (".sbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_PARISC_SHORT },
+ { STRING_COMMA_LEN (".tbss"), 0, SHT_NOBITS, SHF_ALLOC + SHF_WRITE + SHF_HP_TLS },
+ { NULL, 0, 0, 0, 0 }