From 92e059d8dc78c3f65e29e48e368f6e47ea0ab671 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 20 Oct 2006 20:40:49 +0000 Subject: Framework for relocation scanning. Implement simple static TLS relocations. --- gold/target-reloc.h | 114 ++++++++++++++++++++++++++++++++++++++++++---------- 1 file changed, 92 insertions(+), 22 deletions(-) (limited to 'gold/target-reloc.h') diff --git a/gold/target-reloc.h b/gold/target-reloc.h index f972b11..2d1fe30 100644 --- a/gold/target-reloc.h +++ b/gold/target-reloc.h @@ -4,6 +4,7 @@ #define GOLD_TARGET_RELOC_H #include "elfcpp.h" +#include "object.h" #include "symtab.h" namespace gold @@ -29,7 +30,79 @@ struct Reloc_types static const int reloc_size = elfcpp::Elf_sizes::rela_size; }; -// This function implements the generic part of relocation handling. +// This function implements the generic part of reloc scanning. This +// is an inline function which takes a class whose operator() +// implements the machine specific part of scanning. We do it this +// way to avoidmaking a function call for each relocation, and to +// avoid repeating the generic code for each target. + +template +inline void +scan_relocs( + const General_options& options, + Symbol_table* symtab, + Sized_object* object, + const unsigned char* prelocs, + size_t reloc_count, + size_t local_count, + const unsigned char* plocal_syms, + Symbol** global_syms) +{ + typedef typename Reloc_types::Reloc Reltype; + const int reloc_size = Reloc_types::reloc_size; + const int sym_size = elfcpp::Elf_sizes::sym_size; + Scan scan; + + for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) + { + Reltype reloc(prelocs); + + typename elfcpp::Elf_types::Elf_WXword r_info = reloc.get_r_info(); + unsigned int r_sym = elfcpp::elf_r_sym(r_info); + unsigned int r_type = elfcpp::elf_r_type(r_info); + + if (r_sym < local_count) + { + assert(plocal_syms != NULL); + typename elfcpp::Sym lsym(plocal_syms + + r_sym * sym_size); + const unsigned int shndx = lsym.get_st_shndx(); + if (shndx < elfcpp::SHN_LORESERVE + && !object->is_section_included(lsym.get_st_shndx())) + { + // RELOC is a relocation against a local symbol in a + // section we are discarding. We can ignore this + // relocation. It will eventually become a reloc + // against the value zero. + // + // FIXME: We should issue a warning if this is an + // allocated section; is this the best place to do it? + // + // FIXME: The old GNU linker would in some cases look + // for the linkonce section which caused this section to + // be discarded, and, if the other section was the same + // size, change the reloc to refer to the other section. + // That seems risky and weird to me, and I don't know of + // any case where it is actually required. + + continue; + } + + scan.local(options, object, reloc, r_type, lsym); + } + else + { + Symbol* gsym = global_syms[r_sym - local_count]; + assert(gsym != NULL); + if (gsym->is_forwarder()) + gsym = symtab->resolve_forwards(gsym); + + scan.global(options, object, reloc, r_type, gsym); + } + } +} + +// This function implements the generic part of relocation processing. // This is an inline function which take a class whose operator() // implements the machine specific part of relocation. We do it this // way to avoid making a function call for each relocation, and to @@ -37,27 +110,19 @@ struct Reloc_types // target. // SIZE is the ELF size: 32 or 64. BIG_ENDIAN is the endianness of -// the data. SH_TYPE is the section type: SHT_REL or SHT_RELA. RELOC -// implements operator() to do a relocation. +// the data. SH_TYPE is the section type: SHT_REL or SHT_RELA. +// RELOCATE implements operator() to do a relocation. -// OBJECT is the object for we are processing relocs. SH_TYPE is the -// type of relocation: SHT_REL or SHT_RELA. PRELOCS points to the -// relocation data. RELOC_COUNT is the number of relocs. LOCAL_COUNT -// is the number of local symbols. LOCAL_VALUES holds the values of -// the local symbols. GLOBAL_SYMS points to the global symbols. VIEW -// is the section data, VIEW_ADDRESS is its memory address, and -// VIEW_SIZE is the size. +// PRELOCS points to the relocation data. RELOC_COUNT is the number +// of relocs. VIEW is the section data, VIEW_ADDRESS is its memory +// address, and VIEW_SIZE is the size. template inline void relocate_section( - const Symbol_table* symtab, - Sized_object* object, + const Relocate_info* relinfo, const unsigned char* prelocs, size_t reloc_count, - size_t local_count, - const typename elfcpp::Elf_types::Elf_Addr* local_values, - Symbol** global_syms, unsigned char* view, typename elfcpp::Elf_types::Elf_Addr view_address, off_t view_size) @@ -66,6 +131,10 @@ relocate_section( const int reloc_size = Reloc_types::reloc_size; Relocate relocate; + unsigned int local_count = relinfo->local_symbol_count; + typename elfcpp::Elf_types::Elf_Addr *local_values = relinfo->values; + Symbol** global_syms = relinfo->symbols; + for (size_t i = 0; i < reloc_count; ++i, prelocs += reloc_size) { Reltype reloc(prelocs); @@ -73,9 +142,9 @@ relocate_section( off_t offset = reloc.get_r_offset(); if (offset < 0 || offset >= view_size) { - fprintf(stderr, _("%s: %s: reloc %zu has bad offset %lu\n"), - program_name, object->name().c_str(), i, - static_cast(offset)); + fprintf(stderr, _("%s: %s: reloc has bad offset %zu\n"), + program_name, relinfo->location(i, offset).c_str(), + static_cast(offset)); gold_exit(false); } @@ -96,7 +165,7 @@ relocate_section( Symbol* gsym = global_syms[r_sym - local_count]; assert(gsym != NULL); if (gsym->is_forwarder()) - gsym = symtab->resolve_forwards(gsym); + gsym = relinfo->symtab->resolve_forwards(gsym); sym = static_cast*>(gsym); value = sym->value(); @@ -105,13 +174,14 @@ relocate_section( && sym->binding() != elfcpp::STB_WEAK) { fprintf(stderr, _("%s: %s: undefined reference to '%s'\n"), - program_name, object->name().c_str(), sym->name()); + program_name, relinfo->location(i, offset).c_str(), + sym->name()); // gold_exit(false); } } - relocate(object, reloc, r_type, sym, value, view + offset, - view_address + offset); + relocate.relocate(relinfo, i, reloc, r_type, sym, value, view + offset, + view_address + offset, view_size); } } -- cgit v1.1