From mboxrd@z Thu Jan 1 00:00:00 1970 From: Jakub Jelinek To: ian@cygnus.com, rth@cygnus.com Cc: binutils@sourceware.cygnus.com, "David S. Miller" Subject: [PATCH] Support for R_SPARC_OLO10 relocations Date: Mon, 05 Jul 1999 08:47:00 -0000 Message-id: <19990705174729.B1736@mff.cuni.cz> X-SW-Source: 1999-q3/msg00034.html Hi! This patch adds support for R_SPARC_OLO10 relocation. It is in fact a compound relocation equal to R_SPARC_LO10 and R_SPARC_13 with no symbol applied on top of it, so I have modelled the support from elf64-mips.c which already supports compound relocations. The syntax in the assembler is obvious: ld [%o1 + %lo(ab+12)], %o1 will generate normal R_SPARC_LO10 relocation with addend 12, while ld [%o1 + %lo(ab+12) + 24], %o1 will generate R_SPARC_OLO10 relocation with addend 12 and secondary addend (stored in upper 24 bits of ELF64_R_TYPE) 24. slurp_reloc_table will read all OLO10 relocations as LO10 and 13, because there is no place to store secondary addend in arelent. OLO10 is IMHO very useful, because gcc can now add constants to symbols without having to worry about the symbol alignment. It should speed up access to array members at constant offsets if a routine accesses more than two different ones. 1999-07-05 Jakub Jelinek * bfd/elf64-sparc.c (sparc64_elf_info_to_howto): Use ELF64_R_TYPE_ID. (sparc64_elf_get_reloc_upper_bound, sparc64_elf_get_dynamic_reloc_upper_bound, sparc64_elf_slurp_one_reloc_table, sparc64_elf_slurp_reloc_table, sparc64_elf_canonicalize_dynamic_reloc, sparc64_elf_write_relocs): New functions. (sparc64_elf_check_relocs, sparc64_elf_relocate_section): Use ELF64_R_TYPE_ID/DATA where appropriate. * binutils/readelf.c (guess_is_rela): Sparcv9 and v8plus use rela. (dump_relocations): Use ELF64_R_TYPE_ID for Sparc, for R_SPARC_OLO10 print the secondary addend. (get_machine_flags): Print Sparc machine flags. (get_symbol_type): Print STT_REGISTER. * include/elf/sparc.h (ELF64_R_TYPE_DATA): Sign extend the value. (ELF64_R_TYPE_INFO): Mask out all but low 24 bits of data. * opcodes/sparc-dis.c (print_insn_sparc): Differentiate between addition and oring when guessing symbol for comment. * gas/config/tc-sparc.c (sparc_ip): Allow OLO10 relocations on -64 and not pic. (output_insn): Put OLO10's secondary addend into tc_fix_data. (md_apply_fix3): Handle BFD_RELOC_SPARC_OLO10. (tc_gen_reloc): Return two relocs for OLO10, LO10 and SPARC13. * gas/config/tc-sparc.h (RELOC_EXPANSION_POSSIBLE, MAX_RELOC_EXPANSION): Define. (TC_FIX_TYPE, TC_INIT_FIX_DATA, TC_FIX_DATA_PRINT): Likewise. --- ./bfd/elf64-sparc.c.jj Tue Jun 29 10:47:08 1999 +++ ./bfd/elf64-sparc.c Mon Jul 5 17:11:20 1999 @@ -61,6 +61,15 @@ static boolean sparc64_elf_relocate_sect PARAMS ((bfd *, struct bfd_link_info *, bfd *, asection *, bfd_byte *, Elf_Internal_Rela *, Elf_Internal_Sym *, asection **)); static boolean sparc64_elf_object_p PARAMS ((bfd *)); +static long sparc64_elf_get_reloc_upper_bound PARAMS ((bfd *, asection *)); +static long sparc64_elf_get_dynamic_reloc_upper_bound PARAMS ((bfd *)); +static boolean sparc64_elf_slurp_one_reloc_table + PARAMS ((bfd *, asection *, Elf_Internal_Shdr *, asymbol **, boolean)); +static boolean sparc64_elf_slurp_reloc_table + PARAMS ((bfd *, asection *, asymbol **, boolean)); +static long sparc64_elf_canonicalize_dynamic_reloc + PARAMS ((bfd *, arelent **, asymbol **)); +static void sparc64_elf_write_relocs PARAMS ((bfd *, asection *, PTR)); /* The relocation "howto" table. */ @@ -213,8 +222,380 @@ sparc64_elf_info_to_howto (abfd, cache_p arelent *cache_ptr; Elf64_Internal_Rela *dst; { - BFD_ASSERT (ELF64_R_TYPE (dst->r_info) < (unsigned int) R_SPARC_max_std); - cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE (dst->r_info)]; + BFD_ASSERT (ELF64_R_TYPE_ID (dst->r_info) < (unsigned int) R_SPARC_max_std); + cache_ptr->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (dst->r_info)]; +} + +/* Due to the way how we handle R_SPARC_OLO10, each entry in a SHT_RELA + section can represent up to two relocs, we must tell the user to allocate + more space. */ + +static long +sparc64_elf_get_reloc_upper_bound (abfd, sec) + bfd *abfd; + asection *sec; +{ + return (sec->reloc_count * 2 + 1) * sizeof (arelent *); +} + +static long +sparc64_elf_get_dynamic_reloc_upper_bound (abfd) + bfd *abfd; +{ + return _bfd_elf_get_dynamic_reloc_upper_bound (abfd) * 2; +} + +/* Read relocations for ASECT from REL_HDR. There are RELOC_COUNT of + them. We cannot use generic elf routines for this, because R_SPARC_OLO10 + has secondary addend in ELF64_R_TYPE_DATA. We handle it as two relocations + for the same location, R_SPARC_LO10 and R_SPARC_13. */ + +static boolean +sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, dynamic) + bfd *abfd; + asection *asect; + Elf_Internal_Shdr *rel_hdr; + asymbol **symbols; + boolean dynamic; +{ + struct elf_backend_data * const ebd = get_elf_backend_data (abfd); + PTR allocated = NULL; + bfd_byte *native_relocs; + arelent *relent; + unsigned int i; + int entsize; + bfd_size_type count; + arelent *relents; + + allocated = (PTR) bfd_malloc ((size_t) rel_hdr->sh_size); + if (allocated == NULL) + goto error_return; + + if (bfd_seek (abfd, rel_hdr->sh_offset, SEEK_SET) != 0 + || (bfd_read (allocated, 1, rel_hdr->sh_size, abfd) + != rel_hdr->sh_size)) + goto error_return; + + native_relocs = (bfd_byte *) allocated; + + relents = asect->relocation + asect->reloc_count; + + entsize = rel_hdr->sh_entsize; + BFD_ASSERT (entsize == sizeof (Elf64_External_Rela)); + + count = rel_hdr->sh_size / entsize; + + for (i = 0, relent = relents; i < count; + i++, relent++, native_relocs += entsize) + { + Elf_Internal_Rela rela; + + bfd_elf64_swap_reloca_in (abfd, (Elf64_External_Rela *) native_relocs, &rela); + + /* The address of an ELF reloc is section relative for an object + file, and absolute for an executable file or shared library. + The address of a normal BFD reloc is always section relative, + and the address of a dynamic reloc is absolute.. */ + if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0 || dynamic) + relent->address = rela.r_offset; + else + relent->address = rela.r_offset - asect->vma; + + if (ELF64_R_SYM (rela.r_info) == 0) + relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; + else + { + asymbol **ps, *s; + + ps = symbols + ELF64_R_SYM (rela.r_info) - 1; + s = *ps; + + /* Canonicalize ELF section symbols. FIXME: Why? */ + if ((s->flags & BSF_SECTION_SYM) == 0) + relent->sym_ptr_ptr = ps; + else + relent->sym_ptr_ptr = s->section->symbol_ptr_ptr; + } + + relent->addend = rela.r_addend; + + BFD_ASSERT (ELF64_R_TYPE_ID (rela.r_info) < (unsigned int) R_SPARC_max_std); + if (ELF64_R_TYPE_ID (rela.r_info) == R_SPARC_OLO10) + { + relent->howto = &sparc64_elf_howto_table[R_SPARC_LO10]; + relent[1].address = relent->address; + relent++; + relent->sym_ptr_ptr = bfd_abs_section_ptr->symbol_ptr_ptr; + relent->addend = ELF64_R_TYPE_DATA (rela.r_info); + relent->howto = &sparc64_elf_howto_table[R_SPARC_13]; + } + else + relent->howto = &sparc64_elf_howto_table[ELF64_R_TYPE_ID (rela.r_info)]; + } + + asect->reloc_count += relent - relents; + + if (allocated != NULL) + free (allocated); + + return true; + + error_return: + if (allocated != NULL) + free (allocated); + return false; +} + +/* Read in and swap the external relocs. */ + +static boolean +sparc64_elf_slurp_reloc_table (abfd, asect, symbols, dynamic) + bfd *abfd; + asection *asect; + asymbol **symbols; + boolean dynamic; +{ + struct bfd_elf_section_data * const d = elf_section_data (asect); + Elf_Internal_Shdr *rel_hdr; + Elf_Internal_Shdr *rel_hdr2; + + if (asect->relocation != NULL) + return true; + + if (! dynamic) + { + if ((asect->flags & SEC_RELOC) == 0 + || asect->reloc_count == 0) + return true; + + rel_hdr = &d->rel_hdr; + rel_hdr2 = d->rel_hdr2; + + BFD_ASSERT (asect->rel_filepos == rel_hdr->sh_offset + || (rel_hdr2 && asect->rel_filepos == rel_hdr2->sh_offset)); + } + else + { + /* Note that ASECT->RELOC_COUNT tends not to be accurate in this + case because relocations against this section may use the + dynamic symbol table, and in that case bfd_section_from_shdr + in elf.c does not update the RELOC_COUNT. */ + if (asect->_raw_size == 0) + return true; + + rel_hdr = &d->this_hdr; + asect->reloc_count = rel_hdr->sh_size / rel_hdr->sh_entsize; + rel_hdr2 = NULL; + } + + asect->relocation = ((arelent *) + bfd_alloc (abfd, + asect->reloc_count * 2 * sizeof (arelent))); + if (asect->relocation == NULL) + return false; + + /* The sparc64_elf_slurp_one_reloc_table routine increments reloc_count. */ + asect->reloc_count = 0; + + if (!sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr, symbols, + dynamic)) + return false; + + if (rel_hdr2 + && !sparc64_elf_slurp_one_reloc_table (abfd, asect, rel_hdr2, symbols, + dynamic)) + return false; + + return true; +} + +/* Canonicalize the dynamic relocation entries. Note that we return + the dynamic relocations as a single block, although they are + actually associated with particular sections; the interface, which + was designed for SunOS style shared libraries, expects that there + is only one set of dynamic relocs. Any section that was actually + installed in the BFD, and has type SHT_REL or SHT_RELA, and uses + the dynamic symbol table, is considered to be a dynamic reloc + section. */ + +static long +sparc64_elf_canonicalize_dynamic_reloc (abfd, storage, syms) + bfd *abfd; + arelent **storage; + asymbol **syms; +{ + asection *s; + long ret; + + if (elf_dynsymtab (abfd) == 0) + { + bfd_set_error (bfd_error_invalid_operation); + return -1; + } + + ret = 0; + for (s = abfd->sections; s != NULL; s = s->next) + { + if (elf_section_data (s)->this_hdr.sh_link == elf_dynsymtab (abfd) + && (elf_section_data (s)->this_hdr.sh_type == SHT_RELA)) + { + arelent *p; + long count, i; + + if (! sparc64_elf_slurp_reloc_table (abfd, s, syms, true)) + return -1; + count = s->reloc_count; + p = s->relocation; + for (i = 0; i < count; i++) + *storage++ = p++; + ret += count; + } + } + + *storage = NULL; + + return ret; +} + +/* Write out the relocs. */ + +static void +sparc64_elf_write_relocs (abfd, sec, data) + bfd *abfd; + asection *sec; + PTR data; +{ + boolean *failedp = (boolean *) data; + Elf_Internal_Shdr *rela_hdr; + Elf64_External_Rela *outbound_relocas; + unsigned int idx, count; + asymbol *last_sym = 0; + int last_sym_idx = 0; + + /* If we have already failed, don't do anything. */ + if (*failedp) + return; + + if ((sec->flags & SEC_RELOC) == 0) + return; + + /* The linker backend writes the relocs out itself, and sets the + reloc_count field to zero to inhibit writing them here. Also, + sometimes the SEC_RELOC flag gets set even when there aren't any + relocs. */ + if (sec->reloc_count == 0) + return; + + /* We can combine two relocs that refer to the same address + into R_SPARC_OLO10 if first one is R_SPARC_LO10 and the + latter is R_SPARC_13 with no associated symbol. */ + count = 0; + for (idx = 0; idx < sec->reloc_count; idx++) + { + bfd_vma addr; + unsigned int i; + + ++count; + + addr = sec->orelocation[idx]->address; + if (sec->orelocation[idx]->howto->type == R_SPARC_LO10 + && idx < sec->reloc_count + 1) + { + arelent *r = sec->orelocation[idx + 1]; + + if (r->howto->type == R_SPARC_13 + && r->address == addr + && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) + && (*r->sym_ptr_ptr)->value == 0) + ++idx; + } + } + + rela_hdr = &elf_section_data (sec)->rel_hdr; + + rela_hdr->sh_size = rela_hdr->sh_entsize * count; + rela_hdr->contents = (PTR) bfd_alloc (abfd, rela_hdr->sh_size); + if (rela_hdr->contents == NULL) + { + *failedp = true; + return; + } + + /* Figure out whether the relocations are RELA or REL relocations. */ + if (rela_hdr->sh_type != SHT_RELA) + abort (); + + /* orelocation has the data, reloc_count has the count... */ + outbound_relocas = (Elf64_External_Rela *) rela_hdr->contents; + + for (idx = 0; idx < sec->reloc_count; idx++) + { + Elf_Internal_Rela dst_rela; + Elf64_External_Rela *src_rela; + arelent *ptr; + asymbol *sym; + int n; + + ptr = sec->orelocation[idx]; + src_rela = outbound_relocas + idx; + + /* The address of an ELF reloc is section relative for an object + file, and absolute for an executable file or shared library. + The address of a BFD reloc is always section relative. */ + if ((abfd->flags & (EXEC_P | DYNAMIC)) == 0) + dst_rela.r_offset = ptr->address; + else + dst_rela.r_offset = ptr->address + sec->vma; + + sym = *ptr->sym_ptr_ptr; + if (sym == last_sym) + n = last_sym_idx; + else if (bfd_is_abs_section (sym->section) && sym->value == 0) + n = STN_UNDEF; + else + { + last_sym = sym; + n = _bfd_elf_symbol_from_bfd_symbol (abfd, &sym); + if (n < 0) + { + *failedp = true; + return; + } + last_sym_idx = n; + } + + if ((*ptr->sym_ptr_ptr)->the_bfd != NULL + && (*ptr->sym_ptr_ptr)->the_bfd->xvec != abfd->xvec + && ! _bfd_elf_validate_reloc (abfd, ptr)) + { + *failedp = true; + return; + } + + if (ptr->howto->type == R_SPARC_LO10 + && idx < sec->reloc_count - 1) + { + arelent *r = sec->orelocation[idx + 1]; + + if (r->howto->type == R_SPARC_13 + && r->address == ptr->address + && bfd_is_abs_section ((*r->sym_ptr_ptr)->section) + && (*r->sym_ptr_ptr)->value == 0) + { + idx++; + dst_rela.r_info + = ELF64_R_INFO (n, ELF64_R_TYPE_INFO (r->addend, + R_SPARC_OLO10)); + } + else + dst_rela.r_info = ELF64_R_INFO (n, R_SPARC_LO10); + } + else + dst_rela.r_info = ELF64_R_INFO (n, ptr->howto->type); + + dst_rela.r_addend = ptr->addend; + bfd_elf64_swap_reloca_out (abfd, &dst_rela, src_rela); + } } /* Utility for performing the standard initial work of an instruction @@ -570,7 +951,7 @@ sparc64_elf_check_relocs (abfd, info, se else h = sym_hashes[r_symndx - symtab_hdr->sh_info]; - switch (ELF64_R_TYPE (rel->r_info)) + switch (ELF64_R_TYPE_ID (rel->r_info)) { case R_SPARC_GOT10: case R_SPARC_GOT13: @@ -809,7 +1190,7 @@ sparc64_elf_check_relocs (abfd, info, se default: (*_bfd_error_handler)(_("%s: check_relocs: unhandled reloc type %d"), bfd_get_filename(abfd), - ELF64_R_TYPE (rel->r_info)); + ELF64_R_TYPE_ID (rel->r_info)); return false; } } @@ -1245,7 +1626,7 @@ sparc64_elf_relocate_section (output_bfd bfd_vma relocation; bfd_reloc_status_type r; - r_type = ELF64_R_TYPE (rel->r_info); + r_type = ELF64_R_TYPE_ID (rel->r_info); if (r_type < 0 || r_type >= (int) R_SPARC_max_std) { bfd_set_error (bfd_error_bad_value); @@ -1531,7 +1912,11 @@ sparc64_elf_relocate_section (output_bfd & ELF_LINK_HASH_DEF_REGULAR) == 0)) { BFD_ASSERT (h->dynindx != -1); - outrel.r_info = ELF64_R_INFO (h->dynindx, r_type); + outrel.r_info + = ELF64_R_INFO (h->dynindx, + ELF64_R_TYPE_INFO ( + ELF64_R_TYPE_DATA (rel->r_info), + r_type)); outrel.r_addend = rel->r_addend; } else @@ -1581,7 +1966,11 @@ sparc64_elf_relocate_section (output_bfd } } - outrel.r_info = ELF64_R_INFO (indx, r_type); + outrel.r_info + = ELF64_R_INFO (indx, + ELF64_R_TYPE_INFO ( + ELF64_R_TYPE_DATA (rel->r_info), + r_type)); /* For non-RELATIVE dynamic relocations, we keep the same symbol, and so generally the same addend. But @@ -1605,7 +1994,7 @@ sparc64_elf_relocate_section (output_bfd reloc in an unallocated section. */ if (skip || (input_section->flags & SEC_ALLOC) != 0 - || ELF64_R_TYPE (outrel.r_info) != R_SPARC_RELATIVE) + || ELF64_R_TYPE_ID (outrel.r_info) != R_SPARC_RELATIVE) continue; } break; @@ -2225,6 +2614,34 @@ sparc64_elf_object_p (abfd) return bfd_default_set_arch_mach (abfd, bfd_arch_sparc, mach); } +/* Relocations in the 64 bit SPARC ELF ABI are more complex than in + standard ELF, because R_SPARC_OLO10 has secondary addend in + ELF64_R_TYPE_DATA field. This structure is used to redirect the + relocation handling routines. */ + +const struct elf_size_info sparc64_elf_size_info = +{ + sizeof (Elf64_External_Ehdr), + sizeof (Elf64_External_Phdr), + sizeof (Elf64_External_Shdr), + sizeof (Elf64_External_Rel), + sizeof (Elf64_External_Rela), + sizeof (Elf64_External_Sym), + sizeof (Elf64_External_Dyn), + sizeof (Elf_External_Note), + 64, /* arch_size */ + 8, /* file_align */ + ELFCLASS64, + EV_CURRENT, + bfd_elf64_write_out_phdrs, + bfd_elf64_write_shdrs_and_ehdr, + sparc64_elf_write_relocs, + bfd_elf64_swap_symbol_out, + sparc64_elf_slurp_reloc_table, + bfd_elf64_slurp_symbol_table, + bfd_elf64_swap_dyn_in +}; + #define TARGET_BIG_SYM bfd_elf64_sparc_vec #define TARGET_BIG_NAME "elf64-sparc" #define ELF_ARCH bfd_arch_sparc @@ -2238,6 +2655,12 @@ sparc64_elf_object_p (abfd) #define elf_info_to_howto \ sparc64_elf_info_to_howto +#define bfd_elf64_get_reloc_upper_bound \ + sparc64_elf_get_reloc_upper_bound +#define bfd_elf64_get_dynamic_reloc_upper_bound \ + sparc64_elf_get_dynamic_reloc_upper_bound +#define bfd_elf64_canonicalize_dynamic_reloc \ + sparc64_elf_canonicalize_dynamic_reloc #define bfd_elf64_bfd_reloc_type_lookup \ sparc64_elf_reloc_type_lookup @@ -2259,6 +2682,8 @@ sparc64_elf_object_p (abfd) #define bfd_elf64_bfd_merge_private_bfd_data \ sparc64_elf_merge_private_bfd_data +#define elf_backend_size_info \ + sparc64_elf_size_info #define elf_backend_object_p \ sparc64_elf_object_p --- ./binutils/readelf.c.jj Tue Jun 29 10:48:20 1999 +++ ./binutils/readelf.c Mon Jul 5 14:55:30 1999 @@ -414,6 +414,8 @@ guess_is_rela (e_machine) /* Targets that use RELA relocations. */ case EM_68K: + case EM_SPARC32PLUS: + case EM_SPARCV9: case EM_SPARC: case EM_PPC: case EM_CYGNUS_V850: @@ -605,7 +607,10 @@ dump_relocations (file, rel_offset, rel_ } else { - type = ELF64_R_TYPE (info); + if (elf_header.e_machine == EM_SPARCV9) + type = ELF64_R_TYPE_ID (info); + else + type = ELF64_R_TYPE (info); symtab_index = ELF64_R_SYM (info); } @@ -742,6 +747,10 @@ dump_relocations (file, rel_offset, rel_ else if (is_rela) printf ("%34c%lx", ' ', (unsigned long) relas[i].r_addend); + if (elf_header.e_machine == EM_SPARCV9 + && !strcmp (rtype, "R_SPARC_OLO10")) + printf (" + %lx", (unsigned long) ELF64_R_TYPE_DATA (info)); + putchar ('\n'); } @@ -1062,6 +1071,29 @@ get_machine_flags (e_flags, e_machine) if ((e_flags & EF_MIPS_ARCH) == E_MIPS_ARCH_4) strcat (buf, ", mips4"); break; + + case EM_SPARCV9: + if (e_flags & EF_SPARC_32PLUS) + strcat (buf, ", v8+"); + + if (e_flags & EF_SPARC_SUN_US1) + strcat (buf, ", ultrasparc"); + + if (e_flags & EF_SPARC_HAL_R1) + strcat (buf, ", halr1"); + + if (e_flags & EF_SPARC_LEDATA) + strcat (buf, ", ledata"); + + if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_TSO) + strcat (buf, ", tso"); + + if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_PSO) + strcat (buf, ", pso"); + + if ((e_flags & EF_SPARCV9_MM) == EF_SPARCV9_RMO) + strcat (buf, ", rmo"); + break; } } @@ -3393,6 +3425,9 @@ get_symbol_type (type) { if (elf_header.e_machine == EM_ARM && type == STT_ARM_TFUNC) return _("THUMB_FUNC"); + + if (elf_header.e_machine == EM_SPARCV9 && type == STT_REGISTER) + return _("REGISTER"); sprintf (buff, _(": %d"), type); } --- ./include/elf/sparc.h.jj Tue Jun 29 10:51:49 1999 +++ ./include/elf/sparc.h Mon Jul 5 14:44:35 1999 @@ -138,9 +138,9 @@ END_RELOC_NUMBERS /* Relocation macros. */ -#define ELF64_R_TYPE_DATA(info) (((bfd_vma) (info) << 32) >> 40) +#define ELF64_R_TYPE_DATA(info) (((bfd_signed_vma) (info) << 32) >> 40) #define ELF64_R_TYPE_ID(info) (((bfd_vma) (info) << 56) >> 56) -#define ELF64_R_TYPE_INFO(data, type) (((bfd_vma) (data) << 8) \ +#define ELF64_R_TYPE_INFO(data, type) (((((bfd_vma) (data)) & 0xffffff) << 8) \ + (bfd_vma) (type)) #define DT_SPARC_REGISTER 0x70000001 --- ./opcodes/sparc-dis.c.jj Mon May 3 09:29:00 1999 +++ ./opcodes/sparc-dis.c Mon Jul 5 17:17:50 1999 @@ -283,6 +283,7 @@ print_insn_sparc (memaddr, info) /* Nonzero means that we have found an instruction which has the effect of adding or or'ing the imm13 field to rs1. */ int imm_added_to_rs1 = 0; + int imm_ored_to_rs1 = 0; /* Nonzero means that we have found a plus sign in the args field of the opcode table. */ @@ -293,8 +294,9 @@ print_insn_sparc (memaddr, info) /* Do we have an `add' or `or' instruction combining an immediate with rs1? */ - if (opcode->match == 0x80102000 || opcode->match == 0x80002000) - /* (or) (add) */ + if (opcode->match == 0x80102000) /* or */ + imm_ored_to_rs1 = 1; + if (opcode->match == 0x80002000) /* add */ imm_added_to_rs1 = 1; if (X_RS1 (insn) != X_RD (insn) @@ -670,7 +672,7 @@ print_insn_sparc (memaddr, info) If so, attempt to print the result of the add or or (in this context add and or do the same thing) and its symbolic value. */ - if (imm_added_to_rs1) + if (imm_ored_to_rs1 || imm_added_to_rs1) { unsigned long prev_insn; int errcode; @@ -709,8 +711,11 @@ print_insn_sparc (memaddr, info) { (*info->fprintf_func) (stream, "\t! "); info->target = - (0xFFFFFFFF & (int) X_IMM22 (prev_insn) << 10) - | X_SIMM (insn, 13); + (0xFFFFFFFF & (int) X_IMM22 (prev_insn) << 10); + if (imm_added_to_rs1) + info->target += X_SIMM (insn, 13); + else + info->target |= X_SIMM (insn, 13); (*info->print_address_func) (info->target, info); info->insn_type = dis_dref; info->data_size = 4; /* FIXME!!! */ --- ./gas/config/tc-sparc.c.jj Sat Jul 3 18:31:35 1999 +++ ./gas/config/tc-sparc.c Mon Jul 5 14:31:44 1999 @@ -2248,7 +2248,7 @@ sparc_ip (str, pinsn) } else { - if (1 || old_reloc != BFD_RELOC_SPARC13 + if (old_reloc != BFD_RELOC_SPARC13 || the_insn.reloc != BFD_RELOC_LO10 || sparc_arch_size != 64 || sparc_pic_code) @@ -2667,6 +2667,8 @@ output_insn (insn, the_insn) the insn size is 4 and fixup_segment will signal an overflow for large 8 byte quantities. */ fixP->fx_no_overflow = 1; + if (the_insn->reloc == BFD_RELOC_SPARC_OLO10) + fixP->tc_fix_data = the_insn->exp2.X_add_number; } last_insn = insn; @@ -3001,6 +3003,11 @@ md_apply_fix3 (fixP, value, segment) } break; + case BFD_RELOC_SPARC_OLO10: + val &= 0x3ff; + val += fixP->tc_fix_data; + /* intentional fallthrough */ + case BFD_RELOC_SPARC13: if (! in_signed_range (val, 0x1fff)) as_bad_where (fixP->fx_file, fixP->fx_line, @@ -3070,15 +3077,17 @@ md_apply_fix3 (fixP, value, segment) /* Translate internal representation of relocation info to BFD target format. */ -arelent * +arelent ** tc_gen_reloc (section, fixp) asection *section; fixS *fixp; { + static arelent *relocs[3]; arelent *reloc; bfd_reloc_code_real_type code; - reloc = (arelent *) xmalloc (sizeof (arelent)); + relocs[0] = reloc = (arelent *) xmalloc (sizeof (arelent)); + relocs[1] = NULL; reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy); @@ -3115,6 +3124,7 @@ tc_gen_reloc (section, fixp) case BFD_RELOC_SPARC_HIX22: case BFD_RELOC_SPARC_LOX10: case BFD_RELOC_SPARC_REV32: + case BFD_RELOC_SPARC_OLO10: case BFD_RELOC_VTABLE_ENTRY: case BFD_RELOC_VTABLE_INHERIT: code = fixp->fx_r_type; @@ -3168,13 +3178,18 @@ tc_gen_reloc (section, fixp) } #endif /* defined (OBJ_ELF) || defined (OBJ_AOUT) */ - reloc->howto = bfd_reloc_type_lookup (stdoutput, code); + if (code == BFD_RELOC_SPARC_OLO10) + reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_LO10); + else + reloc->howto = bfd_reloc_type_lookup (stdoutput, code); if (reloc->howto == 0) { as_bad_where (fixp->fx_file, fixp->fx_line, _("internal error: can't export reloc type %d (`%s')"), fixp->fx_r_type, bfd_get_reloc_code_name (code)); - return 0; + xfree (reloc); + relocs[0] = NULL; + return relocs; } /* @@ Why fx_addnumber sometimes and fx_offset other times? */ @@ -3209,7 +3224,21 @@ tc_gen_reloc (section, fixp) reloc->addend = fixp->fx_offset; #endif - return reloc; + /* We expand R_SPARC_OLO10 to R_SPARC_LO10 and R_SPARC_13 + on the same location. */ + if (code == BFD_RELOC_SPARC_OLO10) + { + relocs[1] = reloc = (arelent *) xmalloc (sizeof (arelent)); + relocs[2] = NULL; + + reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *)); + *reloc->sym_ptr_ptr = symbol_get_bfdsym (section_symbol (absolute_section)); + reloc->address = fixp->fx_frag->fr_address + fixp->fx_where; + reloc->howto = bfd_reloc_type_lookup (stdoutput, BFD_RELOC_SPARC13); + reloc->addend = fixp->tc_fix_data; + } + + return relocs; } /* We have no need to default values of symbols. */ --- ./gas/config/tc-sparc.h.jj Tue Jun 29 10:49:38 1999 +++ ./gas/config/tc-sparc.h Mon Jul 5 14:15:17 1999 @@ -35,6 +35,9 @@ struct frag; extern const char *sparc_target_format PARAMS ((void)); #define TARGET_FORMAT sparc_target_format () +#define RELOC_EXPANSION_POSSIBLE +#define MAX_RELOC_EXPANSION 2 + #if 0 #ifdef TE_SPARCAOUT /* Bi-endian support may eventually be unconditional, but until things are @@ -160,5 +163,22 @@ extern void sparc_md_end PARAMS ((void)) #define TC_CONS_FIX_NEW cons_fix_new_sparc extern void cons_fix_new_sparc PARAMS ((struct frag *, int, unsigned int, struct expressionS *)); + +#define TC_FIX_TYPE valueT + +#define TC_INIT_FIX_DATA(X) \ + do \ + { \ + (X)->tc_fix_data = 0; \ + } \ + while(0) + +#define TC_FIX_DATA_PRINT(FILE, FIXP) \ + do \ + { \ + fprintf((FILE), "addend2=%ld\n", \ + (unsigned long) (FIXP)->tc_fix_data); \ + } \ + while(0) /* end of tc-sparc.h */ Cheers, Jakub ___________________________________________________________________ Jakub Jelinek | jj@sunsite.mff.cuni.cz | http://sunsite.mff.cuni.cz Administrator of SunSITE Czech Republic, MFF, Charles University ___________________________________________________________________ UltraLinux | http://ultra.linux.cz/ | http://ultra.penguin.cz/ Linux version 2.2.10 on a sparc64 machine (1343.49 BogoMips) ___________________________________________________________________