aboutsummaryrefslogtreecommitdiff
path: root/gold/object.cc
diff options
context:
space:
mode:
authorIan Lance Taylor <iant@google.com>2006-09-21 22:13:18 +0000
committerIan Lance Taylor <iant@google.com>2006-09-21 22:13:18 +0000
commita2fb1b05e4af3fac54faac6c07a4717f2cb34aae (patch)
treecab19eb8c3abe76aee65d684dcceee884ed59c61 /gold/object.cc
parent5ffff7c1d1d2db595e4c23a8c388d3a51d5bb357 (diff)
downloadgdb-a2fb1b05e4af3fac54faac6c07a4717f2cb34aae.zip
gdb-a2fb1b05e4af3fac54faac6c07a4717f2cb34aae.tar.gz
gdb-a2fb1b05e4af3fac54faac6c07a4717f2cb34aae.tar.bz2
New drop, with first cut of section layout code.
Diffstat (limited to 'gold/object.cc')
-rw-r--r--gold/object.cc262
1 files changed, 240 insertions, 22 deletions
diff --git a/gold/object.cc b/gold/object.cc
index bad7f47..0e00c43 100644
--- a/gold/object.cc
+++ b/gold/object.cc
@@ -8,6 +8,7 @@
#include "object.h"
#include "target-select.h"
+#include "layout.h"
namespace gold
{
@@ -42,28 +43,24 @@ Sized_object<size, big_endian>::Sized_object(
off_t offset,
const elfcpp::Ehdr<size, big_endian>& ehdr)
: Object(name, input_file, false, offset),
- osabi_(ehdr.get_e_ident()[elfcpp::EI_OSABI]),
- abiversion_(ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]),
- machine_(ehdr.get_e_machine()),
flags_(ehdr.get_e_flags()),
shoff_(ehdr.get_e_shoff()),
- shnum_(0),
shstrndx_(0),
symtab_shnum_(0),
symbols_(NULL)
{
- if (ehdr.get_e_ehsize() != elfcpp::Elf_sizes<size>::ehdr_size)
+ if (ehdr.get_e_ehsize() != This::ehdr_size)
{
fprintf(stderr, _("%s: %s: bad e_ehsize field (%d != %d)\n"),
program_name, this->name().c_str(), ehdr.get_e_ehsize(),
- elfcpp::Elf_sizes<size>::ehdr_size);
+ This::ehdr_size);
gold_exit(false);
}
- if (ehdr.get_e_shentsize() != elfcpp::Elf_sizes<size>::shdr_size)
+ if (ehdr.get_e_shentsize() != This::shdr_size)
{
fprintf(stderr, _("%s: %s: bad e_shentsize field (%d != %d)\n"),
program_name, this->name().c_str(), ehdr.get_e_shentsize(),
- elfcpp::Elf_sizes<size>::shdr_size);
+ This::shdr_size);
gold_exit(false);
}
}
@@ -81,12 +78,14 @@ void
Sized_object<size, big_endian>::setup(
const elfcpp::Ehdr<size, big_endian>& ehdr)
{
- Target* target = select_target(this->machine_, size, big_endian,
- this->osabi_, this->abiversion_);
+ int machine = ehdr.get_e_machine();
+ Target* target = select_target(machine, size, big_endian,
+ ehdr.get_e_ident()[elfcpp::EI_OSABI],
+ ehdr.get_e_ident()[elfcpp::EI_ABIVERSION]);
if (target == NULL)
{
fprintf(stderr, _("%s: %s: unsupported ELF machine number %d\n"),
- program_name, this->name().c_str(), this->machine_);
+ program_name, this->name().c_str(), machine);
gold_exit(false);
}
this->set_target(target);
@@ -95,25 +94,24 @@ Sized_object<size, big_endian>::setup(
if ((shnum == 0 || shstrndx == elfcpp::SHN_XINDEX)
&& this->shoff_ != 0)
{
- const unsigned char* p = this->get_view
- (this->shoff_, elfcpp::Elf_sizes<size>::shdr_size);
+ const unsigned char* p = this->get_view (this->shoff_, This::shdr_size);
elfcpp::Shdr<size, big_endian> shdr(p);
if (shnum == 0)
shnum = shdr.get_sh_size();
if (shstrndx == elfcpp::SHN_XINDEX)
shstrndx = shdr.get_sh_link();
}
- this->shnum_ = shnum;
+ this->set_shnum(shnum);
this->shstrndx_ = shstrndx;
if (shnum == 0)
return;
// Find the SHT_SYMTAB section.
- const unsigned char* p = this->get_view
- (this->shoff_, shnum * elfcpp::Elf_sizes<size>::shdr_size);
+ const unsigned char* p = this->get_view (this->shoff_,
+ shnum * This::shdr_size);
// Skip the first section, which is always empty.
- p += elfcpp::Elf_sizes<size>::shdr_size;
+ p += This::shdr_size;
for (unsigned int i = 1; i < shnum; ++i)
{
elfcpp::Shdr<size, big_endian> shdr(p);
@@ -122,7 +120,7 @@ Sized_object<size, big_endian>::setup(
this->symtab_shnum_ = i;
break;
}
- p += elfcpp::Elf_sizes<size>::shdr_size;
+ p += This::shdr_size;
}
}
@@ -143,7 +141,7 @@ Sized_object<size, big_endian>::do_read_symbols()
return ret;
}
- int shdr_size = elfcpp::Elf_sizes<size>::shdr_size;
+ const int shdr_size = This::shdr_size;
// Read the symbol table section header.
off_t symtabshdroff = this->shoff_ + (this->symtab_shnum_ * shdr_size);
@@ -152,7 +150,7 @@ Sized_object<size, big_endian>::do_read_symbols()
assert(symtabshdr.get_sh_type() == elfcpp::SHT_SYMTAB);
// We only need the external symbols.
- int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+ const int sym_size = This::sym_size;
off_t locsize = symtabshdr.get_sh_info() * sym_size;
off_t extoff = symtabshdr.get_sh_offset() + locsize;
off_t extsize = symtabshdr.get_sh_size() - locsize;
@@ -162,7 +160,7 @@ Sized_object<size, big_endian>::do_read_symbols()
// Read the section header for the symbol names.
unsigned int strtab_shnum = symtabshdr.get_sh_link();
- if (strtab_shnum == 0 || strtab_shnum >= this->shnum_)
+ if (strtab_shnum == 0 || strtab_shnum >= this->shnum())
{
fprintf(stderr, _("%s: %s: invalid symbol table name index: %u\n"),
program_name, this->name().c_str(), strtab_shnum);
@@ -206,7 +204,7 @@ Sized_object<size, big_endian>::do_add_symbols(Symbol_table* symtab,
return;
}
- unsigned int sym_size = elfcpp::Elf_sizes<size>::sym_size;
+ const int sym_size = This::sym_size;
size_t symcount = sd.symbols_size / sym_size;
if (symcount * sym_size != sd.symbols_size)
{
@@ -224,6 +222,226 @@ Sized_object<size, big_endian>::do_add_symbols(Symbol_table* symtab,
reinterpret_cast<const char*>(sd.symbol_names->data());
symtab->add_from_object(this, syms, symcount, sym_names,
sd.symbol_names_size, this->symbols_);
+
+ delete sd.symbols;
+ delete sd.symbol_names;
+}
+
+// Return whether to include a section group in the link. LAYOUT is
+// used to keep track of which section groups we have already seen.
+// INDEX is the index of the section group and SHDR is the section
+// header. If we do not want to include this group, we set bits in
+// OMIT for each section which should be discarded.
+
+template<int size, bool big_endian>
+bool
+Sized_object<size, big_endian>::include_section_group(
+ Layout* layout,
+ unsigned int index,
+ const elfcpp::Shdr<size, big_endian>& shdr,
+ std::vector<bool>* omit)
+{
+ // Read the section contents.
+ const unsigned char* pcon = this->get_view(shdr.get_sh_offset(),
+ shdr.get_sh_size());
+ const elfcpp::Elf_Word* pword =
+ reinterpret_cast<const elfcpp::Elf_Word*>(pcon);
+
+ // The first word contains flags. We only care about COMDAT section
+ // groups. Other section groups are always included in the link
+ // just like ordinary sections.
+ elfcpp::Elf_Word flags = elfcpp::read_elf_word<big_endian>(pword);
+ if ((flags & elfcpp::GRP_COMDAT) == 0)
+ return true;
+
+ // Look up the group signature, which is the name of a symbol. This
+ // is a lot of effort to go to to read a string. Why didn't they
+ // just use the name of the SHT_GROUP section as the group
+ // signature?
+
+ // Get the appropriate symbol table header (this will normally be
+ // the single SHT_SYMTAB section, but in principle it need not be).
+ if (shdr.get_sh_link() >= this->shnum())
+ {
+ fprintf(stderr, _("%s: %s: section group %u link %u out of range\n"),
+ program_name, this->name().c_str(), index, shdr.get_sh_link());
+ gold_exit(false);
+ }
+ off_t off = this->shoff_ + shdr.get_sh_link() * This::shdr_size;
+ const unsigned char* psymshdr = this->get_view(off, This::shdr_size);
+ elfcpp::Shdr<size, big_endian> symshdr(psymshdr);
+
+ // Read the symbol table entry.
+ if (shdr.get_sh_info() >= symshdr.get_sh_size() / This::sym_size)
+ {
+ fprintf(stderr, _("%s: %s: section group %u info %u out of range\n"),
+ program_name, this->name().c_str(), index, shdr.get_sh_info());
+ gold_exit(false);
+ }
+ off_t symoff = symshdr.get_sh_offset() + shdr.get_sh_info() * This::sym_size;
+ const unsigned char* psym = this->get_view(symoff, This::sym_size);
+ elfcpp::Sym<size, big_endian> sym(psym);
+
+ // Read the section header for the symbol table names.
+ if (symshdr.get_sh_link() >= this->shnum())
+ {
+ fprintf(stderr, _("%s; %s: symtab section %u link %u out of range\n"),
+ program_name, this->name().c_str(), shdr.get_sh_link(),
+ symshdr.get_sh_link());
+ gold_exit(false);
+ }
+ off_t symnameoff = this->shoff_ + symshdr.get_sh_link() * This::shdr_size;
+ const unsigned char* psymnamehdr = this->get_view(symnameoff,
+ This::shdr_size);
+ elfcpp::Shdr<size, big_endian> symnamehdr(psymnamehdr);
+
+ // Read the symbol table names.
+ const unsigned char *psymnamesu = this->get_view(symnamehdr.get_sh_offset(),
+ symnamehdr.get_sh_size());
+ const char* psymnames = reinterpret_cast<const char*>(psymnamesu);
+
+ // Get the section group signature.
+ if (sym.get_st_name() >= symnamehdr.get_sh_size())
+ {
+ fprintf(stderr, _("%s: %s: symbol %u name offset %u out of range\n"),
+ program_name, this->name().c_str(), shdr.get_sh_info(),
+ sym.get_st_name());
+ gold_exit(false);
+ }
+
+ const char* signature = psymnames + sym.get_st_name();
+
+ // Record this section group, and see whether we've already seen one
+ // with the same signature.
+ if (layout->add_comdat(signature, true))
+ return true;
+
+ // This is a duplicate. We want to discard the sections in this
+ // group.
+ size_t count = shdr.get_sh_size() / sizeof(elfcpp::Elf_Word);
+ for (size_t i = 1; i < count; ++i)
+ {
+ elfcpp::Elf_Word secnum = elfcpp::read_elf_word<big_endian>(pword + i);
+ if (secnum >= this->shnum())
+ {
+ fprintf(stderr,
+ _("%s: %s: section %u in section group %u out of range"),
+ program_name, this->name().c_str(), secnum,
+ index);
+ gold_exit(false);
+ }
+ (*omit)[secnum] = true;
+ }
+
+ return false;
+}
+
+// Whether to include a linkonce section in the link. NAME is the
+// name of the section and SHDR is the section header.
+
+// Linkonce sections are a GNU extension implemented in the original
+// GNU linker before section groups were defined. The semantics are
+// that we only include one linkonce section with a given name. The
+// name of a linkonce section is normally .gnu.linkonce.T.SYMNAME,
+// where T is the type of section and SYMNAME is the name of a symbol.
+// In an attempt to make linkonce sections interact well with section
+// groups, we try to identify SYMNAME and use it like a section group
+// signature. We want to block section groups with that signature,
+// but not other linkonce sections with that signature. We also use
+// the full name of the linkonce section as a normal section group
+// signature.
+
+template<int size, bool big_endian>
+bool
+Sized_object<size, big_endian>::include_linkonce_section(
+ Layout* layout,
+ const char* name,
+ const elfcpp::Shdr<size, big_endian>&)
+{
+ const char* symname = strrchr(name, '.') + 1;
+ bool omit1 = layout->add_comdat(symname, false);
+ bool omit2 = layout->add_comdat(name, true);
+ return omit1 || omit2;
+}
+
+// Lay out the input sections. We walk through the sections and check
+// whether they should be included in the link. If they should, we
+// pass them to the Layout object, which will return an output section
+// and an offset.
+
+template<int size, bool big_endian>
+void
+Sized_object<size, big_endian>::do_layout(Layout* layout)
+{
+ // This is always called from the main thread. Lock the file to
+ // keep the error checks happy.
+ Task_locker_obj<File_read> frl(this->input_file()->file());
+
+ // Get the section headers.
+ unsigned int shnum = this->shnum();
+ const unsigned char* pshdrs = this->get_view(this->shoff_,
+ shnum * This::shdr_size);
+
+ // Get the section names.
+ const unsigned char* pshdrnames = pshdrs + this->shstrndx_ * This::shdr_size;
+ elfcpp::Shdr<size, big_endian> shdrnames(pshdrnames);
+ typename elfcpp::Elf_types<size>::Elf_WXword names_size =
+ shdrnames.get_sh_size();
+ const unsigned char* pnamesu = this->get_view(shdrnames.get_sh_offset(),
+ shdrnames.get_sh_size());
+ const char* pnames = reinterpret_cast<const char*>(pnamesu);
+
+ std::vector<Map_to_output>& map_sections(this->map_to_output());
+ map_sections.reserve(shnum);
+
+ // Keep track of which sections to omit.
+ std::vector<bool> omit(shnum, false);
+
+ for (unsigned int i = 0; i < shnum; ++i)
+ {
+ elfcpp::Shdr<size, big_endian> shdr(pshdrs);
+
+ if (shdr.get_sh_name() >= names_size)
+ {
+ fprintf(stderr,
+ _("%s: %s: bad section name offset for section %u: %lu\n"),
+ program_name, this->name().c_str(), i,
+ static_cast<unsigned long>(shdr.get_sh_name()));
+ gold_exit(false);
+ }
+
+ const char* name = pnames + shdr.get_sh_name();
+
+ bool discard = omit[i];
+ if (!discard)
+ {
+ if (shdr.get_sh_type() == elfcpp::SHT_GROUP)
+ {
+ if (!this->include_section_group(layout, i, shdr, &omit))
+ discard = true;
+ }
+ else if (Layout::is_linkonce(name))
+ {
+ if (!this->include_linkonce_section(layout, name, shdr))
+ discard = true;
+ }
+ }
+
+ if (discard)
+ {
+ // Do not include this section in the link.
+ map_sections[i].output_section = NULL;
+ continue;
+ }
+
+ off_t offset;
+ Output_section* os = layout->layout(this, name, shdr, &offset);
+
+ map_sections[i].output_section = os;
+ map_sections[i].offset = offset;
+
+ pshdrs += This::shdr_size;
+ }
}
} // End namespace gold.