diff options
36 files changed, 3545 insertions, 572 deletions
diff --git a/gold/Makefile.am b/gold/Makefile.am index 8545a77..13aae26 100644 --- a/gold/Makefile.am +++ b/gold/Makefile.am @@ -19,6 +19,8 @@ noinst_PROGRAMS = ld-new CCFILES = \ archive.cc \ + common.cc \ + defstd.cc \ dirsearch.cc \ fileread.cc \ gold.cc \ @@ -37,6 +39,8 @@ CCFILES = \ HFILES = \ archive.h \ + common.h \ + defstd.h \ dirsearch.h \ fileread.h \ gold.h \ diff --git a/gold/Makefile.in b/gold/Makefile.in index a9d6073..d4c0c67 100644 --- a/gold/Makefile.in +++ b/gold/Makefile.in @@ -1,4 +1,4 @@ -# Makefile.in generated by automake 1.9.5 from Makefile.am. +# Makefile.in generated by automake 1.9.6 from Makefile.am. # @configure_input@ # Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, @@ -16,8 +16,6 @@ # Process this file with automake to generate Makefile.in -SOURCES = $(ld_new_SOURCES) - srcdir = @srcdir@ top_srcdir = @top_srcdir@ VPATH = @srcdir@ @@ -52,10 +50,9 @@ subdir = . ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 am__aclocal_m4_deps = $(top_srcdir)/../config/depstand.m4 \ $(top_srcdir)/../config/lead-dot.m4 \ - $(top_srcdir)/../bfd/../config/progtest.m4 \ - $(top_srcdir)/../bfd/../config/po.m4 \ - $(top_srcdir)/../bfd/../config/nls.m4 \ - $(top_srcdir)/../bfd/../config/gettext-sister.m4 \ + $(top_srcdir)/../config/progtest.m4 \ + $(top_srcdir)/../config/po.m4 $(top_srcdir)/../config/nls.m4 \ + $(top_srcdir)/../config/gettext-sister.m4 \ $(top_srcdir)/../bfd/warning.m4 $(top_srcdir)/configure.ac am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ $(ACLOCAL_M4) @@ -65,12 +62,13 @@ mkinstalldirs = $(SHELL) $(top_srcdir)/../mkinstalldirs CONFIG_HEADER = config.h CONFIG_CLEAN_FILES = po/Makefile.in PROGRAMS = $(noinst_PROGRAMS) -am__objects_1 = archive.$(OBJEXT) dirsearch.$(OBJEXT) \ - fileread.$(OBJEXT) gold.$(OBJEXT) gold-threads.$(OBJEXT) \ - layout.$(OBJEXT) object.$(OBJEXT) options.$(OBJEXT) \ - output.$(OBJEXT) readsyms.$(OBJEXT) reloc.$(OBJEXT) \ - resolve.$(OBJEXT) symtab.$(OBJEXT) stringpool.$(OBJEXT) \ - target-select.$(OBJEXT) workqueue.$(OBJEXT) +am__objects_1 = archive.$(OBJEXT) common.$(OBJEXT) defstd.$(OBJEXT) \ + dirsearch.$(OBJEXT) fileread.$(OBJEXT) gold.$(OBJEXT) \ + gold-threads.$(OBJEXT) layout.$(OBJEXT) object.$(OBJEXT) \ + options.$(OBJEXT) output.$(OBJEXT) readsyms.$(OBJEXT) \ + reloc.$(OBJEXT) resolve.$(OBJEXT) symtab.$(OBJEXT) \ + stringpool.$(OBJEXT) target-select.$(OBJEXT) \ + workqueue.$(OBJEXT) am__objects_2 = am__objects_3 = i386.$(OBJEXT) am_ld_new_OBJECTS = $(am__objects_1) $(am__objects_2) $(am__objects_3) @@ -233,6 +231,8 @@ INCLUDES = -D_GNU_SOURCE \ CCFILES = \ archive.cc \ + common.cc \ + defstd.cc \ dirsearch.cc \ fileread.cc \ gold.cc \ @@ -251,6 +251,8 @@ CCFILES = \ HFILES = \ archive.h \ + common.h \ + defstd.h \ dirsearch.h \ fileread.h \ gold.h \ @@ -347,6 +349,8 @@ distclean-compile: -rm -f *.tab.c @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/archive.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/common.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/defstd.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dirsearch.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fileread.Po@am__quote@ @AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/gold-threads.Po@am__quote@ @@ -514,7 +518,7 @@ distclean-tags: distdir: $(DISTFILES) $(am__remove_distdir) mkdir $(distdir) - $(mkdir_p) $(distdir)/.. $(distdir)/../bfd $(distdir)/../bfd/../config $(distdir)/../config $(distdir)/po + $(mkdir_p) $(distdir)/.. $(distdir)/../bfd $(distdir)/../config $(distdir)/po @srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \ list='$(DISTFILES)'; for file in $$list; do \ diff --git a/gold/aclocal.m4 b/gold/aclocal.m4 index 1385aed..4438a34 100644 --- a/gold/aclocal.m4 +++ b/gold/aclocal.m4 @@ -1,4 +1,4 @@ -# generated automatically by aclocal 1.9.5 -*- Autoconf -*- +# generated automatically by aclocal 1.9.6 -*- Autoconf -*- # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, # 2005 Free Software Foundation, Inc. @@ -28,7 +28,7 @@ AC_DEFUN([AM_AUTOMAKE_VERSION], [am__api_version="1.9"]) # Call AM_AUTOMAKE_VERSION so it can be traced. # This function is AC_REQUIREd by AC_INIT_AUTOMAKE. AC_DEFUN([AM_SET_CURRENT_AUTOMAKE_VERSION], - [AM_AUTOMAKE_VERSION([1.9.5])]) + [AM_AUTOMAKE_VERSION([1.9.6])]) # AM_AUX_DIR_EXPAND -*- Autoconf -*- @@ -870,8 +870,8 @@ AC_SUBST([am__untar]) m4_include([../config/depstand.m4]) m4_include([../config/lead-dot.m4]) -m4_include([../bfd/../config/progtest.m4]) -m4_include([../bfd/../config/po.m4]) -m4_include([../bfd/../config/nls.m4]) -m4_include([../bfd/../config/gettext-sister.m4]) +m4_include([../config/progtest.m4]) +m4_include([../config/po.m4]) +m4_include([../config/nls.m4]) +m4_include([../config/gettext-sister.m4]) m4_include([../bfd/warning.m4]) diff --git a/gold/archive.cc b/gold/archive.cc index a64109a..031ead0 100644 --- a/gold/archive.cc +++ b/gold/archive.cc @@ -9,6 +9,7 @@ #include "elfcpp.h" #include "fileread.h" +#include "readsyms.h" #include "symtab.h" #include "object.h" #include "archive.h" @@ -47,14 +48,6 @@ const char Archive::armag[sarmag] = const char Archive::arfmag[2] = { '`', '\n' }; -// Get a view into the underlying file. - -const unsigned char* -Archive::get_view(off_t start, off_t size) -{ - return this->input_file_->file().get_view(start, size); -} - // Set up the archive: read the symbol map and the extended name // table. @@ -113,6 +106,10 @@ Archive::setup() this->extended_names_.assign(px, extended_size); } + // This array keeps track of which symbols are for archive elements + // which we have already included in the link. + this->seen_.resize(nsyms); + // Opening the file locked it. Unlock it now. this->input_file_->file().unlock(); } @@ -221,10 +218,7 @@ void Archive::add_symbols(Symbol_table* symtab, Layout* layout, Input_objects* input_objects) { - size_t armap_size = this->armap_.size(); - std::vector<bool> seen; - seen.resize(this->armap_.size()); - seen.clear(); + const size_t armap_size = this->armap_.size(); bool added_new_object; do @@ -233,20 +227,20 @@ Archive::add_symbols(Symbol_table* symtab, Layout* layout, off_t last = -1; for (size_t i = 0; i < armap_size; ++i) { - if (seen[i]) + if (this->seen_[i]) continue; if (this->armap_[i].offset == last) { - seen[i] = true; + this->seen_[i] = true; continue; } Symbol* sym = symtab->lookup(this->armap_[i].name); if (sym == NULL) continue; - else if (sym->shnum() != elfcpp::SHN_UNDEF) + else if (!sym->is_undefined()) { - seen[i] = true; + this->seen_[i] = true; continue; } else if (sym->binding() == elfcpp::STB_WEAK) @@ -255,6 +249,7 @@ Archive::add_symbols(Symbol_table* symtab, Layout* layout, // We want to include this object in the link. last = this->armap_[i].offset; this->include_member(symtab, layout, input_objects, last); + this->seen_[i] = true; added_new_object = true; } } @@ -337,13 +332,13 @@ class Add_archive_symbols::Add_archive_symbols_locker : public Task_locker { public: Add_archive_symbols_locker(Task_token& token, Workqueue* workqueue, - Archive* archive) - : blocker_(token, workqueue), archlock_(*archive) + File_read& file) + : blocker_(token, workqueue), filelock_(file) { } private: Task_locker_block blocker_; - Task_locker_obj<Archive> archlock_; + Task_locker_obj<File_read> filelock_; }; Task_locker* @@ -351,7 +346,7 @@ Add_archive_symbols::locks(Workqueue* workqueue) { return new Add_archive_symbols_locker(*this->next_blocker_, workqueue, - this->archive_); + this->archive_->file()); } void @@ -359,6 +354,14 @@ Add_archive_symbols::run(Workqueue*) { this->archive_->add_symbols(this->symtab_, this->layout_, this->input_objects_); + + if (this->input_group_ != NULL) + this->input_group_->add_archive(this->archive_); + else + { + // We no longer need to know about this archive. + delete this->archive_; + } } } // End namespace gold. diff --git a/gold/archive.h b/gold/archive.h index b2d4c46..f0edfcb 100644 --- a/gold/archive.h +++ b/gold/archive.h @@ -13,6 +13,7 @@ namespace gold class Input_file; class Input_objects; +class Input_group; class Layout; class Symbol_table; @@ -44,6 +45,11 @@ class Archive void setup(); + // Get a reference to the underlying file. + File_read& + file() + { return this->input_file_->file(); } + // Lock the underlying file. void lock() @@ -73,7 +79,8 @@ class Archive // Get a view into the underlying file. const unsigned char* - get_view(off_t start, off_t size); + get_view(off_t start, off_t size) + { return this->input_file_->file().get_view(start, size); } // Read an archive member header at OFF. Return the size of the // member, and set *PNAME to the name. @@ -101,6 +108,9 @@ class Archive std::vector<Armap_entry> armap_; // The extended name table. std::string extended_names_; + // Track which symbols in the archive map are for elements which + // have already been included in the link. + std::vector<bool> seen_; }; // This class is used to read an archive and pick out the desired @@ -111,11 +121,12 @@ class Add_archive_symbols : public Task public: Add_archive_symbols(Symbol_table* symtab, Layout* layout, Input_objects* input_objects, - Archive* archive, Task_token* this_blocker, + Archive* archive, Input_group* input_group, + Task_token* this_blocker, Task_token* next_blocker) : symtab_(symtab), layout_(layout), input_objects_(input_objects), - archive_(archive), this_blocker_(this_blocker), - next_blocker_(next_blocker) + archive_(archive), input_group_(input_group), + this_blocker_(this_blocker), next_blocker_(next_blocker) { } ~Add_archive_symbols(); @@ -138,6 +149,7 @@ class Add_archive_symbols : public Task Layout* layout_; Input_objects* input_objects_; Archive* archive_; + Input_group* input_group_; Task_token* this_blocker_; Task_token* next_blocker_; }; diff --git a/gold/common.cc b/gold/common.cc new file mode 100644 index 0000000..9738f98 --- /dev/null +++ b/gold/common.cc @@ -0,0 +1,208 @@ +// common.cc -- handle common symbols for gold + +#include "gold.h" + +#include <algorithm> + +#include "workqueue.h" +#include "layout.h" +#include "output.h" +#include "common.h" + +namespace gold +{ + +// Allocate_commons_task methods. + +// This task allocates the common symbols. We need a lock on the +// symbol table. + +Task::Is_runnable_type +Allocate_commons_task::is_runnable(Workqueue*) +{ + if (!this->symtab_lock_->is_writable()) + return IS_LOCKED; + return IS_RUNNABLE; +} + +// Return the locks we hold: one on the symbol table, and one blocker. + +class Allocate_commons_task::Allocate_commons_locker : public Task_locker +{ + public: + Allocate_commons_locker(Task_token& symtab_lock, Task* task, + Task_token& blocker, Workqueue* workqueue) + : symtab_locker_(symtab_lock, task), + blocker_(blocker, workqueue) + { } + + private: + Task_locker_write symtab_locker_; + Task_locker_block blocker_; +}; + +Task_locker* +Allocate_commons_task::locks(Workqueue* workqueue) +{ + return new Allocate_commons_locker(*this->symtab_lock_, this, + *this->blocker_, workqueue); +} + +// Allocate the common symbols. + +void +Allocate_commons_task::run(Workqueue*) +{ + this->symtab_->allocate_commons(this->options_, this->layout_); +} + +// This class is used to sort the common symbol by size. We put the +// larger common symbols first. + +template<int size> +class Sort_commons +{ + public: + Sort_commons(const Symbol_table* symtab) + : symtab_(symtab) + { } + + bool operator()(const Symbol* a, const Symbol* b) const; + + private: + const Symbol_table* symtab_; +}; + +template<int size> +bool +Sort_commons<size>::operator()(const Symbol* pa, const Symbol* pb) const +{ + if (pa == NULL) + return false; + if (pb == NULL) + return true; + + const Symbol_table* symtab = this->symtab_; + const Sized_symbol<size>* psa; + psa = symtab->get_sized_symbol SELECT_SIZE_NAME (pa + SELECT_SIZE(size)); + const Sized_symbol<size>* psb; + psb = symtab->get_sized_symbol SELECT_SIZE_NAME (pb + SELECT_SIZE(size)); + + typename Sized_symbol<size>::Size_type sa = psa->symsize(); + typename Sized_symbol<size>::Size_type sb = psb->symsize(); + if (sa < sb) + return false; + else if (sb > sa) + return true; + + // When the symbols are the same size, we sort them by alignment. + typename Sized_symbol<size>::Value_type va = psa->value(); + typename Sized_symbol<size>::Value_type vb = psb->value(); + if (va < vb) + return false; + else if (vb > va) + return true; + + // Otherwise we stabilize the sort by sorting by name. + return strcmp(psa->name(), psb->name()) < 0; +} + +// Allocate the common symbols. + +void +Symbol_table::allocate_commons(const General_options& options, Layout* layout) +{ + if (this->get_size() == 32) + this->do_allocate_commons<32>(options, layout); + else if (this->get_size() == 64) + this->do_allocate_commons<64>(options, layout); + else + abort(); +} + +// Allocated the common symbols, sized version. + +template<int size> +void +Symbol_table::do_allocate_commons(const General_options&, + Layout* layout) +{ + typedef typename Sized_symbol<size>::Value_type Value_type; + typedef typename Sized_symbol<size>::Size_type Size_type; + + // We've kept a list of all the common symbols. But the symbol may + // have been resolved to a defined symbol by now. And it may be a + // forwarder. First remove all non-common symbols. + bool any = false; + uint64_t addralign = 0; + for (Commons_type::iterator p = this->commons_.begin(); + p != this->commons_.end(); + ++p) + { + Symbol* sym = *p; + if (sym->is_forwarder()) + { + sym = this->resolve_forwards(sym); + *p = sym; + } + if (!sym->is_common()) + *p = NULL; + else + { + any = true; + Sized_symbol<size>* ssym; + ssym = this->get_sized_symbol SELECT_SIZE_NAME (sym + SELECT_SIZE(size)); + if (ssym->value() > addralign) + addralign = ssym->value(); + } + } + if (!any) + return; + + // Sort the common symbols by size, so that they pack better into + // memory. + std::sort(this->commons_.begin(), this->commons_.end(), + Sort_commons<size>(this)); + + // Place them in a newly allocated .bss section. + + Output_section_common *poc = new Output_section_common(addralign); + + layout->add_output_section_data(".bss", elfcpp::SHT_NOBITS, + elfcpp::SHF_WRITE | elfcpp::SHF_ALLOC, + poc); + + // Allocate them all. + + off_t off = 0; + for (Commons_type::iterator p = this->commons_.begin(); + p != this->commons_.end(); + ++p) + { + Symbol* sym = *p; + if (sym == NULL) + break; + + Sized_symbol<size>* ssym; + ssym = this->get_sized_symbol SELECT_SIZE_NAME (sym + SELECT_SIZE(size)); + + off = align_address(off, ssym->value()); + + Size_type symsize = ssym->symsize(); + ssym->init(ssym->name(), poc, off, symsize, ssym->type(), + ssym->binding(), ssym->visibility(), ssym->nonvis(), + false); + + off += symsize; + } + + poc->set_common_size(off); + + this->commons_.clear(); +} + +} // End namespace gold. diff --git a/gold/common.h b/gold/common.h new file mode 100644 index 0000000..75237a6 --- /dev/null +++ b/gold/common.h @@ -0,0 +1,49 @@ +// common.h -- handle common symbols for gold -*- C++ -*- + +#ifndef GOLD_COMMON_H +#define GOLD_COMMON_H + +#include "workqueue.h" + +namespace gold +{ + +class General_options; +class Symbol_table; + +// This task is used to allocate the common symbols. + +class Allocate_commons_task : public Task +{ + public: + Allocate_commons_task(const General_options& options, Symbol_table* symtab, + Layout* layout, Task_token* symtab_lock, + Task_token* blocker) + : options_(options), symtab_(symtab), layout_(layout), + symtab_lock_(symtab_lock), blocker_(blocker) + { } + + // The standard Task methods. + + Is_runnable_type + is_runnable(Workqueue*); + + Task_locker* + locks(Workqueue*); + + void + run(Workqueue*); + + private: + class Allocate_commons_locker; + + const General_options& options_; + Symbol_table* symtab_; + Layout* layout_; + Task_token* symtab_lock_; + Task_token* blocker_; +}; + +} // End namespace gold. + +#endif // !defined(GOLD_COMMON_H) diff --git a/gold/defstd.cc b/gold/defstd.cc new file mode 100644 index 0000000..29fd2cd --- /dev/null +++ b/gold/defstd.cc @@ -0,0 +1,127 @@ +// defstd.cc -- define standard symbols for gold. + +#include "gold.h" + +#include "symtab.h" +#include "defstd.h" + +// This is a simple file which defines the standard symbols like +// "_end". + +namespace +{ + +using namespace gold; + +const Define_symbol_in_section in_section[] = +{ + { + "__preinit_array_start", // name + ".preinit_array", // output_section + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + false, // offset_is_from_end + true // only_if_ref + }, + { + "__preinit_array_end", // name + ".preinit_array", // output_section + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + true, // offset_is_from_end + true // only_if_ref + }, + { + "__init_array_start", // name + ".init_array", // output_section + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + false, // offset_is_from_end + true // only_if_ref + }, + { + "__init_array_end", // name + ".init_array", // output_section + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + true, // offset_is_from_end + true // only_if_ref + }, + { + "__fini_array_start", // name + ".fini_array", // output_section + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + false, // offset_is_from_end + true // only_if_ref + }, + { + "__fini_array_end", // name + ".fini_array", // output_section + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_HIDDEN, // visibility + 0, // nonvis + true, // offset_is_from_end + true // only_if_ref + } +}; + +const int in_section_count = sizeof in_section / sizeof in_section[0]; + +const Define_symbol_in_segment in_segment[] = +{ + { + "_end", // name + elfcpp::PT_LOAD, // segment_type + elfcpp::PF_W, // segment_flags_set + elfcpp::PF(0), // segment_flags_clear + 0, // value + 0, // size + elfcpp::STT_NOTYPE, // type + elfcpp::STB_GLOBAL, // binding + elfcpp::STV_DEFAULT, // visibility + 0, // nonvis + Symbol::SEGMENT_START, // offset_from_bas + false // only_if_ref + } +}; + +const int in_segment_count = sizeof in_segment / sizeof in_segment[0]; + +} // End anonymous namespace. + +namespace gold +{ + +void +define_standard_symbols(Symbol_table* symtab, const Layout* layout, + Target* target) +{ + symtab->define_symbols(layout, target, in_section_count, in_section); + symtab->define_symbols(layout, target, in_segment_count, in_segment); +} + +} // End namespace gold. diff --git a/gold/defstd.h b/gold/defstd.h new file mode 100644 index 0000000..f578b49 --- /dev/null +++ b/gold/defstd.h @@ -0,0 +1,16 @@ +// defstd.h -- define standard symbols for gold -*- C++ -*- + +#ifndef GOLD_DEFSTD_H +#define GOLD_DEFSTD_H + +#include "symtab.h" + +namespace gold +{ + +extern void +define_standard_symbols(Symbol_table*, const Layout*, Target*); + +} // End namespace gold. + +#endif // !defined(GOLD_DEFSTD_H) diff --git a/gold/dirsearch.h b/gold/dirsearch.h index 3beb143..8b6ba59 100644 --- a/gold/dirsearch.h +++ b/gold/dirsearch.h @@ -6,12 +6,13 @@ #include <string> #include <list> -#include "options.h" #include "workqueue.h" namespace gold { +class General_options; + // A simple interface to manage directories to be searched for // libraries. diff --git a/gold/fileread.cc b/gold/fileread.cc index 987408e..00971a7 100644 --- a/gold/fileread.cc +++ b/gold/fileread.cc @@ -102,18 +102,16 @@ File_read::is_locked() // See if we have a view which covers the file starting at START for // SIZE bytes. Return a pointer to the View if found, NULL if not. -File_read::View* +inline File_read::View* File_read::find_view(off_t start, off_t size) { - for (std::list<File_read::View*>::iterator p = this->view_list_.begin(); - p != this->view_list_.end(); - ++p) - { - if ((*p)->start() <= start - && (*p)->start() + (*p)->size() >= start + size) - return *p; - } - return NULL; + off_t page = File_read::page_offset(start); + Views::iterator p = this->views_.find(page); + if (p == this->views_.end()) + return NULL; + if (p->second->size() - (start - page) < size) + return NULL; + return p->second; } // Read data from the file. Return the number of bytes read. If @@ -184,15 +182,59 @@ File_read::find_or_make_view(off_t start, off_t size, off_t* pbytes) { assert(this->lock_count_ > 0); - File_read::View* pv = this->find_view(start, size); - if (pv != NULL) - return pv; + off_t poff = File_read::page_offset(start); + + File_read::View* const vnull = NULL; + std::pair<Views::iterator, bool> ins = + this->views_.insert(std::make_pair(poff, vnull)); + + if (!ins.second) + { + // There was an existing view at this offset. + File_read::View* v = ins.first->second; + if (v->size() - (start - v->start()) >= size) + { + if (pbytes != NULL) + *pbytes = size; + return v; + } + + // This view is not large enough. + this->saved_views_.push_back(v); + } + + // We need to read data from the file. + + off_t psize = File_read::pages(size + (start - poff)); + unsigned char* p = new unsigned char[psize]; - unsigned char* p = new unsigned char[size]; - off_t bytes = this->do_read(start, size, p, pbytes); - pv = new File_read::View(start, bytes, p); - this->view_list_.push_back(pv); - return pv; + off_t got_bytes; + off_t bytes = this->do_read(poff, psize, p, &got_bytes); + + File_read::View* v = new File_read::View(poff, bytes, p); + + ins.first->second = v; + + if (bytes - (start - poff) >= size) + { + if (pbytes != NULL) + *pbytes = size; + return v; + } + + if (pbytes != NULL) + { + *pbytes = bytes - (start - poff); + return v; + } + + fprintf(stderr, + _("%s: %s: file too short: read only %lld of %lld bytes at %lld\n"), + program_name, this->filename().c_str(), + static_cast<long long>(bytes - (start - poff)), + static_cast<long long>(size), + static_cast<long long>(start)); + gold_exit(false); } // This implementation of get_view just reads into a memory buffer, @@ -221,18 +263,32 @@ File_read::get_lasting_view(off_t start, off_t size, off_t* pbytes) void File_read::clear_views(bool destroying) { - std::list<File_read::View*>::iterator p = this->view_list_.begin(); - while (p != this->view_list_.end()) + for (Views::iterator p = this->views_.begin(); + p != this->views_.end(); + ++p) { - if ((*p)->is_locked()) + if (!p->second->is_locked()) + delete p->second; + else { assert(!destroying); - ++p; + this->saved_views_.push_back(p->second); } - else + } + this->views_.clear(); + + Saved_views::iterator p = this->saved_views_.begin(); + while (p != this->saved_views_.end()) + { + if (!(*p)->is_locked()) { delete *p; - p = this->view_list_.erase(p); + p = this->saved_views_.erase(p); + } + else + { + assert(!destroying); + ++p; } } } diff --git a/gold/fileread.h b/gold/fileread.h index b65a86b..6e49324 100644 --- a/gold/fileread.h +++ b/gold/fileread.h @@ -5,8 +5,9 @@ #ifndef GOLD_FILEREAD_H #define GOLD_FILEREAD_H -#include <string> #include <list> +#include <map> +#include <string> #include "options.h" @@ -14,7 +15,6 @@ namespace gold { class Dirsearch; - class File_view; // File_read manages a file descriptor for a file we are reading. We @@ -123,22 +123,52 @@ class File_read friend class File_view; + // Find a view into the file. View* find_view(off_t start, off_t size); + // Read data from the file into a buffer. off_t do_read(off_t start, off_t size, void* p, off_t* pbytes); + // Find or make a view into the file. View* find_or_make_view(off_t start, off_t size, off_t* pbytes); + // Clear the file views. void clear_views(bool); + // The size of a file page for buffering data. + static const off_t page_size = 8192; + + // Given a file offset, return the page offset. + static off_t + page_offset(off_t file_offset) + { return file_offset & ~ (page_size - 1); } + + // Given a file size, return the size to read integral pages. + static off_t + pages(off_t file_size) + { return (file_size + (page_size - 1)) & ~ (page_size - 1); } + + // The type of a mapping from page start to views. + typedef std::map<off_t, View*> Views; + + // A simple list of Views. + typedef std::list<View*> Saved_views; + + // File name. std::string name_; + // File descriptor. int descriptor_; + // Number of locks on the file. int lock_count_; - std::list<View*> view_list_; + // Buffered views into the file. + Views views_; + // List of views which were locked but had to be removed from views_ + // because they were not large enough. + Saved_views saved_views_; }; // A view of file data that persists even when the file is unlocked. @@ -179,7 +209,7 @@ class File_view class Input_file { public: - Input_file(const Input_argument& input_argument) + Input_file(const Input_file_argument& input_argument) : input_argument_(input_argument) { } @@ -201,7 +231,10 @@ class Input_file { return this->file_; } private: - const Input_argument& input_argument_; + Input_file(const Input_file&); + Input_file& operator=(const Input_file&); + + const Input_file_argument& input_argument_; File_read file_; }; diff --git a/gold/gold.cc b/gold/gold.cc index c39f999..31598dc 100644 --- a/gold/gold.cc +++ b/gold/gold.cc @@ -12,9 +12,11 @@ #include "dirsearch.h" #include "readsyms.h" #include "symtab.h" +#include "common.h" #include "object.h" #include "layout.h" #include "reloc.h" +#include "defstd.h" namespace gold { @@ -92,11 +94,11 @@ Middle_runner::run(Workqueue* workqueue) void queue_initial_tasks(const General_options& options, const Dirsearch& search_path, - const Input_argument_list& inputs, + const Command_line& cmdline, Workqueue* workqueue, Input_objects* input_objects, Symbol_table* symtab, Layout* layout) { - if (inputs.empty()) + if (cmdline.begin() == cmdline.end()) gold_fatal(_("no input files"), false); // Read the input files. We have to add the symbols to the symbol @@ -104,14 +106,14 @@ queue_initial_tasks(const General_options& options, // each input file. We associate the blocker with the following // input file, to give us a convenient place to delete it. Task_token* this_blocker = NULL; - for (Input_argument_list::const_iterator p = inputs.begin(); - p != inputs.end(); + for (Command_line::const_iterator p = cmdline.begin(); + p != cmdline.end(); ++p) { Task_token* next_blocker = new Task_token(); next_blocker->add_blocker(); workqueue->queue(new Read_symbols(options, input_objects, symtab, layout, - search_path, *p, this_blocker, + search_path, *p, NULL, this_blocker, next_blocker)); this_blocker = next_blocker; } @@ -134,6 +136,10 @@ queue_middle_tasks(const General_options& options, Layout* layout, Workqueue* workqueue) { + // Predefine standard symbols. This should be fast, so we don't + // bother to create a task for it. + define_standard_symbols(symtab, layout, input_objects->target()); + // Read the relocations of the input files. We do this to find // which symbols are used by relocations which require a GOT and/or // a PLT entry, or a COPY reloc. When we implement garbage @@ -157,15 +163,15 @@ queue_middle_tasks(const General_options& options, // relocations. That task will in turn queue a task to wait // until it can write to the symbol table. blocker->add_blocker(); - workqueue->queue(new Read_relocs(options, symtab, *p, symtab_lock, - blocker)); + workqueue->queue(new Read_relocs(options, symtab, layout, *p, + symtab_lock, blocker)); } // Allocate common symbols. This requires write access to the // symbol table, but is independent of the relocation processing. - // blocker->add_blocker(); - // workqueue->queue(new Allocate_commons_task(options, symtab, layout, - // symtab_lock, blocker)); + blocker->add_blocker(); + workqueue->queue(new Allocate_commons_task(options, symtab, layout, + symtab_lock, blocker)); // When all those tasks are complete, we can start laying out the // output file. @@ -257,7 +263,7 @@ main(int argc, char** argv) // Queue up the first set of tasks. queue_initial_tasks(command_line.options(), search_path, - command_line.inputs(), &workqueue, &input_objects, + command_line, &workqueue, &input_objects, &symtab, &layout); // Run the main task processing loop. diff --git a/gold/i386.cc b/gold/i386.cc index 468cb90..53af5ee 100644 --- a/gold/i386.cc +++ b/gold/i386.cc @@ -1,10 +1,14 @@ // i386.cc -- i386 target support for gold. #include "gold.h" + +#include <cstring> + #include "elfcpp.h" #include "reloc.h" #include "i386.h" #include "object.h" +#include "symtab.h" #include "layout.h" #include "output.h" #include "target.h" @@ -22,13 +26,15 @@ class Target_i386 : public Sized_target<32, false> { public: Target_i386() - : Sized_target<32, false>(&i386_info) + : Sized_target<32, false>(&i386_info), + got_(NULL) { } // Scan the relocations to look for symbol adjustments. void scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Sized_object<32, false>* object, unsigned int sh_type, const unsigned char* prelocs, @@ -52,12 +58,16 @@ class Target_i386 : public Sized_target<32, false> struct Scan { inline void - local(const General_options& options, Sized_object<32, false>* object, + local(const General_options& options, Symbol_table* symtab, + Layout* layout, Target_i386* target, + Sized_object<32, false>* object, const elfcpp::Rel<32, false>& reloc, unsigned int r_type, const elfcpp::Sym<32, false>& lsym); inline void - global(const General_options& options, Sized_object<32, false>* object, + global(const General_options& options, Symbol_table* symtab, + Layout* layout, Target_i386* target, + Sized_object<32, false>* object, const elfcpp::Rel<32, false>& reloc, unsigned int r_type, Symbol* gsym); }; @@ -66,9 +76,25 @@ class Target_i386 : public Sized_target<32, false> class Relocate { public: - // Do a relocation. - static inline void - relocate(const Relocate_info<32, false>*, size_t relnum, + Relocate() + : skip_call_tls_get_addr_(false) + { } + + ~Relocate() + { + if (this->skip_call_tls_get_addr_) + { + // FIXME: This needs to specify the location somehow. + fprintf(stderr, _("%s: missing expected TLS relocation\n"), + program_name); + gold_exit(false); + } + } + + // Do a relocation. Return false if the caller should not issue + // any warnings about this relocation. + inline bool + relocate(const Relocate_info<32, false>*, Target_i386*, size_t relnum, const elfcpp::Rel<32, false>&, unsigned int r_type, Sized_symbol<32>*, elfcpp::Elf_types<32>::Elf_Addr, @@ -77,7 +103,7 @@ class Target_i386 : public Sized_target<32, false> private: // Do a TLS relocation. - static inline void + inline void relocate_tls(const Relocate_info<32, false>*, size_t relnum, const elfcpp::Rel<32, false>&, unsigned int r_type, Sized_symbol<32>*, @@ -93,6 +119,15 @@ class Target_i386 : public Sized_target<32, false> unsigned char* view, off_t view_size); + // Do a TLS Global-Dynamic to Local-Exec transition. + inline void + tls_gd_to_le(const Relocate_info<32, false>*, size_t relnum, + Output_segment* tls_segment, + const elfcpp::Rel<32, false>&, unsigned int r_type, + elfcpp::Elf_types<32>::Elf_Addr value, + unsigned char* view, + off_t view_size); + // Check the range for a TLS relocation. static inline void check_range(const Relocate_info<32, false>*, size_t relnum, @@ -102,6 +137,10 @@ class Target_i386 : public Sized_target<32, false> static inline void check_tls(const Relocate_info<32, false>*, size_t relnum, const elfcpp::Rel<32, false>&, bool); + + // This is set if we should skip the next reloc, which should be a + // PLT32 reloc against ___tls_get_addr. + bool skip_call_tls_get_addr_; }; // Adjust TLS relocation type based on the options and whether this @@ -109,9 +148,16 @@ class Target_i386 : public Sized_target<32, false> static unsigned int optimize_tls_reloc(const General_options*, bool is_local, int r_type); + // Get the GOT section, creating it if necessary. + Output_section_got<32, false>* + got_section(Symbol_table*, Layout*); + // Information about this specific target which we pass to the // general Target structure. static const Target::Target_info i386_info; + + // The GOT section. + Output_section_got<32, false>* got_; }; const Target::Target_info Target_i386::i386_info = @@ -126,6 +172,34 @@ const Target::Target_info Target_i386::i386_info = 0x1000 // common_pagesize }; +// Get the GOT section, creating it if necessary. + +Output_section_got<32, false>* +Target_i386::got_section(Symbol_table* symtab, Layout* layout) +{ + if (this->got_ == NULL) + { + this->got_ = new Output_section_got<32, false>(); + + assert(symtab != NULL && layout != NULL); + layout->add_output_section_data(".got", elfcpp::SHT_PROGBITS, + elfcpp::SHF_ALLOC, this->got_); + + // The first three entries are reserved. + this->got_->add_constant(0); + this->got_->add_constant(0); + this->got_->add_constant(0); + + // Define _GLOBAL_OFFSET_TABLE_ at the start of the section. + symtab->define_in_output_data(this, "_GLOBAL_OFFSET_TABLE_", this->got_, + 0, 0, elfcpp::STT_OBJECT, + elfcpp::STB_GLOBAL, + elfcpp::STV_HIDDEN, 0, + false, false); + } + return this->got_; +} + // Optimize the TLS relocation type based on what we know about the // symbol. IS_LOCAL is true if this symbol can be resolved entirely // locally--i.e., does not have to be in the dynamic symbol table. @@ -188,6 +262,9 @@ Target_i386::optimize_tls_reloc(const General_options* options, bool is_local, inline void Target_i386::Scan::local(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Target_i386* target, Sized_object<32, false>* object, const elfcpp::Rel<32, false>&, unsigned int r_type, const elfcpp::Sym<32, false>&) @@ -211,6 +288,12 @@ Target_i386::Scan::local(const General_options& options, case elfcpp::R_386_PC8: break; + case elfcpp::R_386_GOTOFF: + case elfcpp::R_386_GOTPC: + // We need a GOT section. + target->got_section(symtab, layout); + break; + case elfcpp::R_386_COPY: case elfcpp::R_386_GLOB_DAT: case elfcpp::R_386_JUMP_SLOT: @@ -261,8 +344,6 @@ Target_i386::Scan::local(const General_options& options, case elfcpp::R_386_GOT32: case elfcpp::R_386_PLT32: - case elfcpp::R_386_GOTOFF: - case elfcpp::R_386_GOTPC: case elfcpp::R_386_32PLT: case elfcpp::R_386_TLS_GD_32: case elfcpp::R_386_TLS_GD_PUSH: @@ -284,6 +365,9 @@ Target_i386::Scan::local(const General_options& options, inline void Target_i386::Scan::global(const General_options& options, + Symbol_table* symtab, + Layout* layout, + Target_i386* target, Sized_object<32, false>* object, const elfcpp::Rel<32, false>&, unsigned int r_type, Symbol* gsym) @@ -307,6 +391,37 @@ Target_i386::Scan::global(const General_options& options, // relocation in order to avoid a COPY relocation. break; + case elfcpp::R_386_GOT32: + // The symbol requires a GOT entry. + if (!gsym->has_got_offset()) + { + Output_section_got<32, false>* got = target->got_section(symtab, + layout); + const unsigned int got_offset = got->add_global(gsym); + gsym->set_got_offset(got_offset); + + // If this symbol is not resolved locally, we need to add a + // dynamic relocation for it. + if (!gsym->is_resolved_locally()) + abort(); + } + break; + + case elfcpp::R_386_PLT32: + // If the symbol is resolved locally, this is just a PC32 reloc. + if (gsym->is_resolved_locally()) + break; + fprintf(stderr, + _("%s: %s: unsupported reloc %u against global symbol %s\n"), + program_name, object->name().c_str(), r_type, gsym->name()); + break; + + case elfcpp::R_386_GOTOFF: + case elfcpp::R_386_GOTPC: + // We need a GOT section. + target->got_section(symtab, layout); + break; + case elfcpp::R_386_COPY: case elfcpp::R_386_GLOB_DAT: case elfcpp::R_386_JUMP_SLOT: @@ -332,7 +447,7 @@ Target_i386::Scan::global(const General_options& options, case elfcpp::R_386_TLS_GOTDESC: case elfcpp::R_386_TLS_DESC_CALL: r_type = Target_i386::optimize_tls_reloc(&options, - !gsym->in_dynsym(), + gsym->is_resolved_locally(), r_type); switch (r_type) { @@ -357,10 +472,6 @@ Target_i386::Scan::global(const General_options& options, } break; - case elfcpp::R_386_GOT32: - case elfcpp::R_386_PLT32: - case elfcpp::R_386_GOTOFF: - case elfcpp::R_386_GOTPC: case elfcpp::R_386_32PLT: case elfcpp::R_386_TLS_GD_32: case elfcpp::R_386_TLS_GD_PUSH: @@ -384,6 +495,7 @@ Target_i386::Scan::global(const General_options& options, void Target_i386::scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Sized_object<32, false>* object, unsigned int sh_type, const unsigned char* prelocs, @@ -399,9 +511,12 @@ Target_i386::scan_relocs(const General_options& options, gold_exit(false); } - gold::scan_relocs<32, false, elfcpp::SHT_REL, Target_i386::Scan>( + gold::scan_relocs<32, false, Target_i386, elfcpp::SHT_REL, + Target_i386::Scan>( options, symtab, + layout, + this, object, prelocs, reloc_count, @@ -412,8 +527,9 @@ Target_i386::scan_relocs(const General_options& options, // Perform a relocation. -inline void +inline bool Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, + Target_i386* target, size_t relnum, const elfcpp::Rel<32, false>& rel, unsigned int r_type, @@ -423,6 +539,23 @@ Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, elfcpp::Elf_types<32>::Elf_Addr address, off_t view_size) { + if (this->skip_call_tls_get_addr_) + { + if (r_type != elfcpp::R_386_PLT32 + || gsym == NULL + || strcmp(gsym->name(), "___tls_get_addr") != 0) + { + fprintf(stderr, _("%s: %s: missing expected TLS relocation\n"), + program_name, + relinfo->location(relnum, rel.get_r_offset()).c_str()); + gold_exit(false); + } + + this->skip_call_tls_get_addr_ = false; + + return false; + } + switch (r_type) { case elfcpp::R_386_NONE: @@ -454,6 +587,34 @@ Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, Relocate_functions<32, false>::pcrel8(view, value, address); break; + case elfcpp::R_386_PLT32: + if (gsym->is_resolved_locally()) + Relocate_functions<32, false>::pcrel32(view, value, address); + else + fprintf(stderr, _("%s: %s: unsupported reloc %u\n"), + program_name, + relinfo->location(relnum, rel.get_r_offset()).c_str(), + r_type); + break; + + case elfcpp::R_386_GOT32: + // Local GOT offsets not yet supported. + assert(gsym); + assert(gsym->has_got_offset()); + value = gsym->got_offset(); + Relocate_functions<32, false>::rel32(view, value); + break; + + case elfcpp::R_386_GOTOFF: + value -= target->got_section(NULL, NULL)->address(); + Relocate_functions<32, false>::rel32(view, value); + break; + + case elfcpp::R_386_GOTPC: + value = target->got_section(NULL, NULL)->address(); + Relocate_functions<32, false>::pcrel32(view, value, address); + break; + case elfcpp::R_386_COPY: case elfcpp::R_386_GLOB_DAT: case elfcpp::R_386_JUMP_SLOT: @@ -480,15 +641,10 @@ Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, case elfcpp::R_386_TLS_LE_32: case elfcpp::R_386_TLS_GOTDESC: case elfcpp::R_386_TLS_DESC_CALL: - Target_i386::Relocate::relocate_tls(relinfo, relnum, rel, r_type, - gsym, value, view, address, - view_size); + this->relocate_tls(relinfo, relnum, rel, r_type, gsym, value, view, + address, view_size); break; - case elfcpp::R_386_GOT32: - case elfcpp::R_386_PLT32: - case elfcpp::R_386_GOTOFF: - case elfcpp::R_386_GOTPC: case elfcpp::R_386_32PLT: case elfcpp::R_386_TLS_GD_32: case elfcpp::R_386_TLS_GD_PUSH: @@ -507,6 +663,8 @@ Target_i386::Relocate::relocate(const Relocate_info<32, false>* relinfo, // gold_exit(false); break; } + + return true; } // Perform a TLS relocation. @@ -531,7 +689,7 @@ Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo, gold_exit(false); } - const bool is_local = gsym == NULL || !gsym->in_dynsym(); + const bool is_local = gsym == NULL || gsym->is_resolved_locally(); const unsigned int opt_r_type = Target_i386::optimize_tls_reloc(relinfo->options, is_local, r_type); switch (r_type) @@ -564,6 +722,20 @@ Target_i386::Relocate::relocate_tls(const Relocate_info<32, false>* relinfo, break; case elfcpp::R_386_TLS_GD: + if (opt_r_type == elfcpp::R_386_TLS_LE_32) + { + this->tls_gd_to_le(relinfo, relnum, tls_segment, + rel, r_type, value, view, + view_size); + break; + } + fprintf(stderr, _("%s: %s: unsupported reloc %u\n"), + program_name, + relinfo->location(relnum, rel.get_r_offset()).c_str(), + r_type); + // gold_exit(false); + break; + case elfcpp::R_386_TLS_LDM: case elfcpp::R_386_TLS_LDO_32: case elfcpp::R_386_TLS_GOTDESC: @@ -667,14 +839,79 @@ Target_i386::Relocate::tls_ie_to_le(const Relocate_info<32, false>* relinfo, Target_i386::Relocate::check_tls(relinfo, relnum, rel, 0); } - if (r_type == elfcpp::R_386_TLS_IE_32) - value = tls_segment->vaddr() + tls_segment->memsz() - value; - else // elfcpp::R_386_TLS_IE, elfcpp::R_386_TLS_GOTIE - value = value - (tls_segment->vaddr() + tls_segment->memsz()); + value = tls_segment->vaddr() + tls_segment->memsz() - value; + if (r_type == elfcpp::R_386_TLS_IE || r_type == elfcpp::R_386_TLS_GOTIE) + value = - value; Relocate_functions<32, false>::rel32(view, value); } +// Do a relocation in which we convert a TLS Global-Dynamic to a +// Local-Exec. + +inline void +Target_i386::Relocate::tls_gd_to_le(const Relocate_info<32, false>* relinfo, + size_t relnum, + Output_segment* tls_segment, + const elfcpp::Rel<32, false>& rel, + unsigned int, + elfcpp::Elf_types<32>::Elf_Addr value, + unsigned char* view, + off_t view_size) +{ + // leal foo(,%reg,1),%eax; call ___tls_get_addr + // ==> movl %gs,0,%eax; subl $foo@tpoff,%eax + // leal foo(%reg),%eax; call ___tls_get_addr + // ==> movl %gs:0,%eax; subl $foo@tpoff,%eax + + Target_i386::Relocate::check_range(relinfo, relnum, rel, view_size, -2); + Target_i386::Relocate::check_range(relinfo, relnum, rel, view_size, 9); + + unsigned char op1 = view[-1]; + unsigned char op2 = view[-2]; + + Target_i386::Relocate::check_tls(relinfo, relnum, rel, + op2 == 0x8d || op2 == 0x04); + Target_i386::Relocate::check_tls(relinfo, relnum, rel, + view[4] == 0xe8); + + int roff = 5; + + if (op2 == 0x04) + { + Target_i386::Relocate::check_range(relinfo, relnum, rel, view_size, -3); + Target_i386::Relocate::check_tls(relinfo, relnum, rel, + view[-3] == 0x8d); + Target_i386::Relocate::check_tls(relinfo, relnum, rel, + ((op1 & 0xc7) == 0x05 + && op1 != (4 << 3))); + memcpy(view - 3, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12); + } + else + { + Target_i386::Relocate::check_tls(relinfo, relnum, rel, + (op1 & 0xf8) == 0x80 && (op1 & 7) != 4); + if (rel.get_r_offset() + 9 < view_size && view[9] == 0x90) + { + // There is a trailing nop. Use the size byte subl. + memcpy(view - 2, "\x65\xa1\0\0\0\0\x81\xe8\0\0\0", 12); + roff = 6; + } + else + { + // Use the five byte subl. + memcpy(view - 2, "\x65\xa1\0\0\0\0\x2d\0\0\0", 11); + } + } + + value = tls_segment->vaddr() + tls_segment->memsz() - value; + Relocate_functions<32, false>::rel32(view + roff, value); + + // The next reloc should be a PLT32 reloc against __tls_get_addr. + // We can skip it. + this->skip_call_tls_get_addr_ = true; +} + // Check the range for a TLS relocation. inline void @@ -724,8 +961,10 @@ Target_i386::relocate_section(const Relocate_info<32, false>* relinfo, { assert(sh_type == elfcpp::SHT_REL); - gold::relocate_section<32, false, elfcpp::SHT_REL, Target_i386::Relocate>( + gold::relocate_section<32, false, Target_i386, elfcpp::SHT_REL, + Target_i386::Relocate>( relinfo, + this, prelocs, reloc_count, view, @@ -733,10 +972,6 @@ Target_i386::relocate_section(const Relocate_info<32, false>* relinfo, view_size); } -// The i386 target. - -Target_i386 target_i386; - // The selector for i386 object files. class Target_selector_i386 : public Target_selector @@ -747,16 +982,21 @@ public: { } Target* - recognize(int machine, int osabi, int abiversion) const; + recognize(int machine, int osabi, int abiversion); + + private: + Target_i386* target_; }; // Recognize an i386 object file when we already know that the machine // number is EM_386. Target* -Target_selector_i386::recognize(int, int, int) const +Target_selector_i386::recognize(int, int, int) { - return &target_i386; + if (this->target_ == NULL) + this->target_ = new Target_i386(); + return this->target_; } Target_selector_i386 target_selector_i386; diff --git a/gold/layout.cc b/gold/layout.cc index a81fd43..9e85f19 100644 --- a/gold/layout.cc +++ b/gold/layout.cc @@ -38,7 +38,7 @@ Layout_task_runner::run(Workqueue* workqueue) // Layout methods. Layout::Layout(const General_options& options) - : options_(options), last_shndx_(0), namepool_(), sympool_(), signatures_(), + : options_(options), namepool_(), sympool_(), signatures_(), section_name_map_(), segment_list_(), section_list_(), special_output_list_(), tls_segment_(NULL) { @@ -86,66 +86,114 @@ Layout::include_section(Object*, const char*, } } -// Return the output section to use for input section NAME, with -// header HEADER, from object OBJECT. Set *OFF to the offset of this -// input section without the output section. +// Return an output section named NAME, or NULL if there is none. -template<int size, bool big_endian> Output_section* -Layout::layout(Object* object, const char* name, - const elfcpp::Shdr<size, big_endian>& shdr, off_t* off) +Layout::find_output_section(const char* name) const { - // We discard empty input sections. - if (shdr.get_sh_size() == 0) - return NULL; - - if (!this->include_section(object, name, shdr)) - return NULL; - - // Unless we are doing a relocateable link, .gnu.linkonce sections - // are laid out as though they were named for the sections are - // placed into. - if (!this->options_.is_relocatable() && Layout::is_linkonce(name)) - name = Layout::linkonce_output_name(name); + for (Section_name_map::const_iterator p = this->section_name_map_.begin(); + p != this->section_name_map_.end(); + ++p) + if (strcmp(p->first.first, name) == 0) + return p->second; + return NULL; +} - // FIXME: Handle SHF_OS_NONCONFORMING here. +// Return an output segment of type TYPE, with segment flags SET set +// and segment flags CLEAR clear. Return NULL if there is none. - // Canonicalize the section name. - name = this->namepool_.add(name); +Output_segment* +Layout::find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set, + elfcpp::Elf_Word clear) const +{ + for (Segment_list::const_iterator p = this->segment_list_.begin(); + p != this->segment_list_.end(); + ++p) + if (static_cast<elfcpp::PT>((*p)->type()) == type + && ((*p)->flags() & set) == set + && ((*p)->flags() & clear) == 0) + return *p; + return NULL; +} - // Find the output section. The output section is selected based on - // the section name, type, and flags. +// Return the output section to use for section NAME with type TYPE +// and section flags FLAGS. - // FIXME: If we want to do relaxation, we need to modify this - // algorithm. We also build a list of input sections for each - // output section. Then we relax all the input sections. Then we - // walk down the list and adjust all the offsets. +Output_section* +Layout::get_output_section(const char* name, elfcpp::Elf_Word type, + elfcpp::Elf_Xword flags) +{ + // We should ignore some flags. + flags &= ~ (elfcpp::SHF_INFO_LINK + | elfcpp::SHF_LINK_ORDER + | elfcpp::SHF_GROUP); - elfcpp::Elf_Word type = shdr.get_sh_type(); - elfcpp::Elf_Xword flags = shdr.get_sh_flags(); const Key key(name, std::make_pair(type, flags)); const std::pair<Key, Output_section*> v(key, NULL); std::pair<Section_name_map::iterator, bool> ins( this->section_name_map_.insert(v)); - Output_section* os; if (!ins.second) - os = ins.first->second; + return ins.first->second; else { // This is the first time we've seen this name/type/flags // combination. - os = this->make_output_section(name, type, flags); + Output_section* os = this->make_output_section(name, type, flags); ins.first->second = os; + return os; } +} + +// Return the output section to use for input section SHNDX, with name +// NAME, with header HEADER, from object OBJECT. Set *OFF to the +// offset of this input section without the output section. + +template<int size, bool big_endian> +Output_section* +Layout::layout(Object* object, unsigned int shndx, const char* name, + const elfcpp::Shdr<size, big_endian>& shdr, off_t* off) +{ + if (!this->include_section(object, name, shdr)) + return NULL; + + // If we are not doing a relocateable link, choose the name to use + // for the output section. + size_t len = strlen(name); + if (!this->options_.is_relocatable()) + name = Layout::output_section_name(name, &len); + + // FIXME: Handle SHF_OS_NONCONFORMING here. + + // Canonicalize the section name. + name = this->namepool_.add(name, len); + + // Find the output section. The output section is selected based on + // the section name, type, and flags. + Output_section* os = this->get_output_section(name, shdr.get_sh_type(), + shdr.get_sh_flags()); // FIXME: Handle SHF_LINK_ORDER somewhere. - *off = os->add_input_section(object, name, shdr); + *off = os->add_input_section(object, shndx, name, shdr); return os; } +// Add POSD to an output section using NAME, TYPE, and FLAGS. + +void +Layout::add_output_section_data(const char* name, elfcpp::Elf_Word type, + elfcpp::Elf_Xword flags, + Output_section_data* posd) +{ + // Canonicalize the name. + name = this->namepool_.add(name); + + Output_section* os = this->get_output_section(name, type, flags); + os->add_output_section_data(posd); +} + // Map section flags to segment flags. elfcpp::Elf_Word @@ -166,9 +214,7 @@ Output_section* Layout::make_output_section(const char* name, elfcpp::Elf_Word type, elfcpp::Elf_Xword flags) { - ++this->last_shndx_; - Output_section* os = new Output_section(name, type, flags, - this->last_shndx_); + Output_section* os = new Output_section(name, type, flags, true); if ((flags & elfcpp::SHF_ALLOC) == 0) this->section_list_.push_back(os); @@ -339,8 +385,14 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab) load_seg->add_initial_output_data(file_header); this->special_output_list_.push_back(file_header); - // Set the file offsets of all the segments. - off_t off = this->set_segment_offsets(input_objects->target(), load_seg); + // We set the output section indexes in set_segment_offsets and + // set_section_offsets. + unsigned int shndx = 1; + + // Set the file offsets of all the segments, and all the sections + // they contain. + off_t off = this->set_segment_offsets(input_objects->target(), load_seg, + &shndx); // Create the symbol table sections. // FIXME: We don't need to do this if we are stripping symbols. @@ -354,7 +406,10 @@ Layout::finalize(const Input_objects* input_objects, Symbol_table* symtab) // Set the file offsets of all the sections not associated with // segments. - off = this->set_section_offsets(off); + off = this->set_section_offsets(off, &shndx); + + // Now the section index of OSTRTAB is set. + osymtab->set_link(ostrtab->out_shndx()); // Create the section table header. Output_section_headers* oshdrs = this->create_shdrs(size, big_endian, &off); @@ -450,12 +505,13 @@ Layout::segment_precedes(const Output_segment* seg1, return paddr1 < paddr2; } -// Set the file offsets of all the segments. They have all been -// created. LOAD_SEG must be be laid out first. Return the offset of -// the data to follow. +// Set the file offsets of all the segments, and all the sections they +// contain. They have all been created. LOAD_SEG must be be laid out +// first. Return the offset of the data to follow. off_t -Layout::set_segment_offsets(const Target* target, Output_segment* load_seg) +Layout::set_segment_offsets(const Target* target, Output_segment* load_seg, + unsigned int *pshndx) { // Sort them into the final order. std::sort(this->segment_list_.begin(), this->segment_list_.end(), @@ -489,16 +545,17 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg) uint64_t abi_pagesize = target->abi_pagesize(); if (was_readonly && ((*p)->flags() & elfcpp::PF_W) != 0) { - uint64_t align = (*p)->max_data_align(); + uint64_t align = (*p)->addralign(); - addr = (addr + align - 1) & ~ (align - 1); + addr = align_address(addr, align); aligned_addr = addr; if ((addr & (abi_pagesize - 1)) != 0) addr = addr + abi_pagesize; } + unsigned int shndx_hold = *pshndx; off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1)); - uint64_t new_addr = (*p)->set_section_addresses(addr, &off); + uint64_t new_addr = (*p)->set_section_addresses(addr, &off, pshndx); // Now that we know the size of this segment, we may be able // to save a page in memory, at the cost of wasting some @@ -519,10 +576,10 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg) != (new_addr & ~ (common_pagesize - 1))) && first_off + last_off <= common_pagesize) { - addr = ((aligned_addr + common_pagesize - 1) - & ~ (common_pagesize - 1)); + *pshndx = shndx_hold; + addr = align_address(aligned_addr, common_pagesize); off = orig_off + ((addr - orig_addr) & (abi_pagesize - 1)); - new_addr = (*p)->set_section_addresses(addr, &off); + new_addr = (*p)->set_section_addresses(addr, &off, pshndx); } } @@ -550,17 +607,17 @@ Layout::set_segment_offsets(const Target* target, Output_segment* load_seg) // segment. off_t -Layout::set_section_offsets(off_t off) +Layout::set_section_offsets(off_t off, unsigned int* pshndx) { for (Layout::Section_list::iterator p = this->section_list_.begin(); p != this->section_list_.end(); ++p) { + (*p)->set_out_shndx(*pshndx); + ++*pshndx; if ((*p)->offset() != -1) continue; - uint64_t addralign = (*p)->addralign(); - if (addralign != 0) - off = (off + addralign - 1) & ~ (addralign - 1); + off = align_address(off, (*p)->addralign()); (*p)->set_address(0, off); off += (*p)->data_size(); } @@ -592,7 +649,7 @@ Layout::create_symtab_sections(int size, const Input_objects* input_objects, abort(); off_t off = *poff; - off = (off + align - 1) & ~ (align - 1); + off = align_address(off, align); off_t startoff = off; // Save space for the dummy symbol at the start of the section. We @@ -614,23 +671,18 @@ Layout::create_symtab_sections(int size, const Input_objects* input_objects, this->sympool_.set_string_offsets(); - ++this->last_shndx_; const char* symtab_name = this->namepool_.add(".symtab"); Output_section* osymtab = new Output_section_symtab(symtab_name, - off - startoff, - this->last_shndx_); + off - startoff); this->section_list_.push_back(osymtab); - ++this->last_shndx_; const char* strtab_name = this->namepool_.add(".strtab"); Output_section *ostrtab = new Output_section_strtab(strtab_name, - &this->sympool_, - this->last_shndx_); + &this->sympool_); this->section_list_.push_back(ostrtab); this->special_output_list_.push_back(ostrtab); osymtab->set_address(0, startoff); - osymtab->set_link(ostrtab->shndx()); osymtab->set_info(local_symcount); osymtab->set_entsize(symsize); osymtab->set_addralign(align); @@ -654,10 +706,7 @@ Layout::create_shstrtab() this->namepool_.set_string_offsets(); - ++this->last_shndx_; - Output_section* os = new Output_section_strtab(name, - &this->namepool_, - this->last_shndx_); + Output_section* os = new Output_section_strtab(name, &this->namepool_); this->section_list_.push_back(os); this->special_output_list_.push_back(os); @@ -675,8 +724,7 @@ Layout::create_shdrs(int size, bool big_endian, off_t* poff) oshdrs = new Output_section_headers(size, big_endian, this->segment_list_, this->section_list_, &this->namepool_); - uint64_t addralign = oshdrs->addralign(); - off_t off = (*poff + addralign - 1) & ~ (addralign - 1); + off_t off = align_address(*poff, oshdrs->addralign()); oshdrs->set_address(0, off); off += oshdrs->data_size(); *poff = off; @@ -686,7 +734,7 @@ Layout::create_shdrs(int size, bool big_endian, off_t* poff) // The mapping of .gnu.linkonce section names to real section names. -#define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t } +#define MAPPING_INIT(f, t) { f, sizeof(f) - 1, t, sizeof(t) - 1 } const Layout::Linkonce_mapping Layout::linkonce_mapping[] = { MAPPING_INIT("d.rel.ro", ".data.rel.ro"), // Must be before "d". @@ -713,10 +761,11 @@ const int Layout::linkonce_mapping_count = // Return the name of the output section to use for a .gnu.linkonce // section. This is based on the default ELF linker script of the old // GNU linker. For example, we map a name like ".gnu.linkonce.t.foo" -// to ".text". +// to ".text". Set *PLEN to the length of the name. *PLEN is +// initialized to the length of NAME. const char* -Layout::linkonce_output_name(const char* name) +Layout::linkonce_output_name(const char* name, size_t *plen) { const char* s = name + sizeof(".gnu.linkonce") - 1; if (*s != '.') @@ -726,11 +775,67 @@ Layout::linkonce_output_name(const char* name) for (int i = 0; i < linkonce_mapping_count; ++i, ++plm) { if (strncmp(s, plm->from, plm->fromlen) == 0 && s[plm->fromlen] == '.') - return plm->to; + { + *plen = plm->tolen; + return plm->to; + } } return name; } +// Choose the output section name to use given an input section name. +// Set *PLEN to the length of the name. *PLEN is initialized to the +// length of NAME. + +const char* +Layout::output_section_name(const char* name, size_t* plen) +{ + if (Layout::is_linkonce(name)) + { + // .gnu.linkonce sections are laid out as though they were named + // for the sections are placed into. + return Layout::linkonce_output_name(name, plen); + } + + // If the section name has no '.', or only an initial '.', we use + // the name unchanged (i.e., ".text" is unchanged). + + // Otherwise, if the section name does not include ".rel", we drop + // the last '.' and everything that follows (i.e., ".text.XXX" + // becomes ".text"). + + // Otherwise, if the section name has zero or one '.' after the + // ".rel", we use the name unchanged (i.e., ".rel.text" is + // unchanged). + + // Otherwise, we drop the last '.' and everything that follows + // (i.e., ".rel.text.XXX" becomes ".rel.text"). + + const char* s = name; + if (*s == '.') + ++s; + const char* sdot = strchr(s, '.'); + if (sdot == NULL) + return name; + + const char* srel = strstr(s, ".rel"); + if (srel == NULL) + { + *plen = sdot - name; + return name; + } + + sdot = strchr(srel + 1, '.'); + if (sdot == NULL) + return name; + sdot = strchr(sdot + 1, '.'); + if (sdot == NULL) + return name; + + *plen = sdot - name; + return name; +} + // Record the signature of a comdat section, and return whether to // include it in the link. If GROUP is true, this is a regular // section group. If GROUP is false, this is a group signature @@ -743,7 +848,7 @@ Layout::add_comdat(const char* signature, bool group) { std::string sig(signature); std::pair<Signatures::iterator, bool> ins( - this->signatures_.insert(std::make_pair(signature, group))); + this->signatures_.insert(std::make_pair(sig, group))); if (ins.second) { @@ -851,22 +956,22 @@ Close_task_runner::run(Workqueue*) template Output_section* -Layout::layout<32, false>(Object* object, const char* name, +Layout::layout<32, false>(Object* object, unsigned int shndx, const char* name, const elfcpp::Shdr<32, false>& shdr, off_t*); template Output_section* -Layout::layout<32, true>(Object* object, const char* name, +Layout::layout<32, true>(Object* object, unsigned int shndx, const char* name, const elfcpp::Shdr<32, true>& shdr, off_t*); template Output_section* -Layout::layout<64, false>(Object* object, const char* name, +Layout::layout<64, false>(Object* object, unsigned int shndx, const char* name, const elfcpp::Shdr<64, false>& shdr, off_t*); template Output_section* -Layout::layout<64, true>(Object* object, const char* name, +Layout::layout<64, true>(Object* object, unsigned int shndx, const char* name, const elfcpp::Shdr<64, true>& shdr, off_t*); diff --git a/gold/layout.h b/gold/layout.h index 4ec2a4a..c96d47d 100644 --- a/gold/layout.h +++ b/gold/layout.h @@ -8,7 +8,6 @@ #include <utility> #include <vector> -#include "options.h" #include "workqueue.h" #include "object.h" #include "stringpool.h" @@ -16,8 +15,10 @@ namespace gold { +class General_options; class Input_objects; class Symbol_table; +class Output_section_data; class Output_section; class Output_section_symtab; class Output_section_headers; @@ -63,15 +64,22 @@ class Layout public: Layout(const General_options& options); - // Given an input section named NAME with data in SHDR from the - // object file OBJECT, return the output section where this input - // section should go. Set *OFFSET to the offset within the output - // section. + // Given an input section SHNDX, named NAME, with data in SHDR, from + // the object file OBJECT, return the output section where this + // input section should go. Set *OFFSET to the offset within the + // output section. template<int size, bool big_endian> Output_section* - layout(Object *object, const char* name, + layout(Object *object, unsigned int shndx, const char* name, const elfcpp::Shdr<size, big_endian>& shdr, off_t* offset); + // Add an Output_section_data to the layout. This is used for + // special sections like the GOT section. + void + add_output_section_data(const char* name, elfcpp::Elf_Word type, + elfcpp::Elf_Xword flags, + Output_section_data*); + // Return the Stringpool used for symbol names. const Stringpool* sympool() const @@ -104,6 +112,16 @@ class Layout void write_data(Output_file*) const; + // Return an output section named NAME, or NULL if there is none. + Output_section* + find_output_section(const char* name) const; + + // Return an output segment of type TYPE, with segment flags SET set + // and segment flags CLEAR clear. Return NULL if there is none. + Output_segment* + find_output_segment(elfcpp::PT type, elfcpp::Elf_Word set, + elfcpp::Elf_Word clear) const; + // The list of segments. typedef std::vector<Output_segment*> Segment_list; @@ -126,6 +144,7 @@ class Layout const char* from; int fromlen; const char* to; + int tolen; }; static const Linkonce_mapping linkonce_mapping[]; static const int linkonce_mapping_count; @@ -137,12 +156,12 @@ class Layout // Set the final file offsets of all the segments. off_t - set_segment_offsets(const Target*, Output_segment*); + set_segment_offsets(const Target*, Output_segment*, unsigned int* pshndx); - // Set the final file offsets of all the sections not associated - // with a segment. + // Set the final file offsets and section indices of all the + // sections not associated with a segment. off_t - set_section_offsets(off_t); + set_section_offsets(off_t, unsigned int *pshndx); // Create the output sections for the symbol table. void @@ -164,10 +183,21 @@ class Layout include_section(Object* object, const char* name, const elfcpp::Shdr<size, big_endian>&); + // Return the output section name to use given an input section + // name. Set *PLEN to the length of the name. *PLEN must be + // initialized to the length of NAME. + static const char* + output_section_name(const char* name, size_t* plen); + // Return the output section name to use for a linkonce section - // name. + // name. PLEN is as for output_section_name. static const char* - linkonce_output_name(const char* name); + linkonce_output_name(const char* name, size_t* plen); + + // Return the output section for NAME, TYPE and FLAGS. + Output_section* + get_output_section(const char* name, elfcpp::Elf_Word type, + elfcpp::Elf_Xword flags); // Create a new Output_section. Output_section* @@ -210,8 +240,6 @@ class Layout // A reference to the options on the command line. const General_options& options_; - // The index of the last output section. - unsigned int last_shndx_; // The output section names. Stringpool namepool_; // The output symbol names. @@ -308,6 +336,16 @@ class Close_task_runner : public Task_function_runner Output_file* of_; }; +// A small helper function to align an address. + +inline uint64_t +align_address(uint64_t address, uint64_t addralign) +{ + if (addralign != 0) + address = (address + addralign - 1) &~ (addralign - 1); + return address; +} + } // End namespace gold. #endif // !defined(GOLD_LAYOUT_H) diff --git a/gold/object.cc b/gold/object.cc index 5efb3cb..4e7f04c 100644 --- a/gold/object.cc +++ b/gold/object.cc @@ -16,25 +16,6 @@ namespace gold // Class Object. -const unsigned char* -Object::get_view(off_t start, off_t size) -{ - return this->input_file_->file().get_view(start + this->offset_, size); -} - -void -Object::read(off_t start, off_t size, void* p) -{ - this->input_file_->file().read(start + this->offset_, size, p); -} - -File_view* -Object::get_lasting_view(off_t start, off_t size) -{ - return this->input_file_->file().get_lasting_view(start + this->offset_, - size); -} - // Class Sized_object. template<int size, bool big_endian> @@ -79,7 +60,7 @@ Sized_object<size, big_endian>::~Sized_object() // Read the section header for section SHNUM. template<int size, bool big_endian> -const unsigned char* +inline const unsigned char* Sized_object<size, big_endian>::section_header(unsigned int shnum) { assert(shnum < this->shnum()); @@ -328,6 +309,32 @@ Sized_object<size, big_endian>::include_section_group( const char* signature = psymnames + sym.get_st_name(); + // It seems that some versions of gas will create a section group + // associated with a section symbol, and then fail to give a name to + // the section symbol. In such a case, use the name of the section. + // FIXME. + if (signature[0] == '\0' + && sym.get_st_type() == elfcpp::STT_SECTION + && sym.get_st_shndx() < this->shnum()) + { + typename This::Shdr shdrnames(this->section_header(this->shstrndx_)); + const unsigned char* pnamesu = this->get_view(shdrnames.get_sh_offset(), + shdrnames.get_sh_size()); + const char* pnames = reinterpret_cast<const char*>(pnamesu); + + typename This::Shdr sechdr(this->section_header(sym.get_st_shndx())); + if (sechdr.get_sh_name() >= shdrnames.get_sh_size()) + { + fprintf(stderr, + _("%s: %s: bad section name offset for section %u: %lu\n"), + program_name, this->name().c_str(), sym.get_st_shndx(), + static_cast<unsigned long>(sechdr.get_sh_name())); + gold_exit(false); + } + + signature = pnames + sechdr.get_sh_name(); + } + // Record this section group, and see whether we've already seen one // with the same signature. if (layout->add_comdat(signature, true)) @@ -446,7 +453,7 @@ Sized_object<size, big_endian>::do_layout(Layout* layout, } off_t offset; - Output_section* os = layout->layout(this, name, shdr, &offset); + Output_section* os = layout->layout(this, i, name, shdr, &offset); map_sections[i].output_section = os; map_sections[i].offset = offset; @@ -514,7 +521,7 @@ Sized_object<size, big_endian>::do_finalize_local_symbols(off_t off, return off; } - off = (off + (size >> 3) - 1) & ~ ((off_t) (size >> 3) - 1); + off = align_address(off, size >> 3); this->local_symbol_offset_ = off; @@ -587,6 +594,7 @@ Sized_object<size, big_endian>::do_finalize_local_symbols(off_t off, } this->values_[i] = (mo[shndx].output_section->address() + + mo[shndx].offset + sym.get_st_value()); } @@ -655,7 +663,7 @@ Sized_object<size, big_endian>::write_local_symbols(Output_file* of, assert(st_shndx < mo.size()); if (mo[st_shndx].output_section == NULL) continue; - st_shndx = mo[st_shndx].output_section->shndx(); + st_shndx = mo[st_shndx].output_section->out_shndx(); } osym.put_st_name(sympool->get_offset(pnames + isym.get_st_name())); diff --git a/gold/object.h b/gold/object.h index 49a1ce9..5e57039 100644 --- a/gold/object.h +++ b/gold/object.h @@ -154,8 +154,8 @@ class Object // Scan the relocs and adjust the symbol table. void scan_relocs(const General_options& options, Symbol_table* symtab, - Read_relocs_data* rd) - { return this->do_scan_relocs(options, symtab, rd); } + Layout* layout, Read_relocs_data* rd) + { return this->do_scan_relocs(options, symtab, layout, rd); } // Initial local symbol processing: set the offset where local // symbol information will be stored; add local symbol names to @@ -184,6 +184,14 @@ class Object inline Output_section* output_section(unsigned int shnum, off_t* poff); + // Set the offset of an input section within its output section. + void + set_section_offset(unsigned int shndx, off_t off) + { + assert(shndx < this->map_to_output_.size()); + this->map_to_output_[shndx].offset = off; + } + // Return the name of a section given a section index. This is only // used for error messages. std::string @@ -218,7 +226,8 @@ class Object // Scan the relocs--implemented by child class. virtual void - do_scan_relocs(const General_options&, Symbol_table*, Read_relocs_data*) = 0; + do_scan_relocs(const General_options&, Symbol_table*, Layout*, + Read_relocs_data*) = 0; // Lay out sections--implemented by child class. virtual void @@ -250,7 +259,8 @@ class Object // Get a view into the underlying file. const unsigned char* - get_view(off_t start, off_t size); + get_view(off_t start, off_t size) + { return this->input_file_->file().get_view(start + this->offset_, size); } // Get the number of sections. unsigned int @@ -269,11 +279,16 @@ class Object // Read data from the underlying file. void - read(off_t start, off_t size, void* p); + read(off_t start, off_t size, void* p) + { this->input_file_->file().read(start + this->offset_, size, p); } // Get a lasting view into the underlying file. File_view* - get_lasting_view(off_t start, off_t size); + get_lasting_view(off_t start, off_t size) + { + return this->input_file_->file().get_lasting_view(start + this->offset_, + size); + } // Return the vector mapping input sections to output sections. std::vector<Map_to_output>& @@ -353,7 +368,8 @@ class Sized_object : public Object // Scan the relocs and adjust the symbol table. void - do_scan_relocs(const General_options&, Symbol_table*, Read_relocs_data*); + do_scan_relocs(const General_options&, Symbol_table*, Layout*, + Read_relocs_data*); // Lay out the input sections. void diff --git a/gold/options.cc b/gold/options.cc index 8e0465f..397259e 100644 --- a/gold/options.cc +++ b/gold/options.cc @@ -89,6 +89,24 @@ library(int argc, char** argv, char* arg, gold::Command_line* cmdline) return cmdline->process_l_option(argc, argv, arg); } +// Handle the special --start-group option. + +int +start_group(int, char**, char* arg, gold::Command_line* cmdline) +{ + cmdline->start_group(arg); + return 1; +} + +// Handle the special --end-group option. + +int +end_group(int, char**, char* arg, gold::Command_line* cmdline) +{ + cmdline->end_group(arg); + return 1; +} + // Report usage information for ld --help, and exit. int @@ -209,6 +227,10 @@ options::Command_line_options::options[] = SPECIAL('l', "library", N_("Search for library LIBNAME"), N_("-lLIBNAME --library LIBNAME"), TWO_DASHES, &library), + SPECIAL('(', "start-group", N_("Start a library search group"), NULL, + TWO_DASHES, &start_group), + SPECIAL(')', "end-group", N_("End a library search group"), NULL, + TWO_DASHES, &end_group), GENERAL_ARG('L', "library-path", N_("Add directory to search path"), N_("-L DIR, --library-path DIR"), TWO_DASHES, &General_options::add_to_search_path), @@ -246,9 +268,10 @@ Position_dependent_options::Position_dependent_options() { } -// Construct a Command_line. +// Command_line options. Command_line::Command_line() + : options_(), position_options_(), inputs_(), in_group_(false) { } @@ -266,8 +289,7 @@ Command_line::process(int argc, char** argv) { if (argv[i][0] != '-' || no_more_options) { - this->inputs_.push_back(Input_argument(argv[i], false, - this->position_options_)); + this->add_file(argv[i], false); ++i; continue; } @@ -385,6 +407,12 @@ Command_line::process(int argc, char** argv) } } + if (this->in_group_) + { + fprintf(stderr, _("%s: missing group end"), program_name); + this->usage(); + } + // FIXME: We should only do this when configured in native mode. this->options_.add_to_search_path("/lib"); this->options_.add_to_search_path("/usr/lib"); @@ -416,6 +444,22 @@ Command_line::apply_option(const options::One_option& opt, } } +// Add an input file or library. + +void +Command_line::add_file(const char* name, bool is_lib) +{ + Input_file_argument file(name, is_lib, this->position_options_); + if (!this->in_group_) + this->inputs_.push_back(Input_argument(file)); + else + { + assert(!this->inputs_.empty()); + assert(this->inputs_.back().is_group()); + this->inputs_.back().group()->add_file(file); + } +} + // Handle the -l option, which requires special treatment. int @@ -436,12 +480,36 @@ Command_line::process_l_option(int argc, char** argv, char* arg) else this->usage(_("missing argument"), arg); - this->inputs_.push_back(Input_argument(libname, true, - this->position_options_)); + this->add_file(libname, true); return ret; } +// Handle the --start-group option. + +void +Command_line::start_group(const char* arg) +{ + if (this->in_group_) + this->usage(_("may not nest groups"), arg); + + // This object is leaked. + Input_file_group* group = new Input_file_group(); + this->inputs_.push_back(Input_argument(group)); + + this->in_group_ = true; +} + +// Handle the --end-group option. + +void +Command_line::end_group(const char* arg) +{ + if (!this->in_group_) + this->usage(_("group end without group start"), arg); + this->in_group_ = false; +} + // Report a usage error. */ void diff --git a/gold/options.h b/gold/options.h index 7e890fa..3b54c49 100644 --- a/gold/options.h +++ b/gold/options.h @@ -15,11 +15,13 @@ #include <list> #include <string> #include <vector> +#include <cassert> namespace gold { class Command_line; +class Input_file_group; namespace options { @@ -128,11 +130,15 @@ class Position_dependent_options // A single file or library argument from the command line. -class Input_argument +class Input_file_argument { public: - Input_argument(const char* name, bool is_lib, - const Position_dependent_options& options) + Input_file_argument() + : name_(NULL), is_lib_(false), options_() + { } + + Input_file_argument(const char* name, bool is_lib, + const Position_dependent_options& options) : name_(name), is_lib_(is_lib), options_(options) { } @@ -154,9 +160,90 @@ class Input_argument Position_dependent_options options_; }; -// A list of input files. -class Input_argument_list : public std::vector<Input_argument> +// A file or library, or a group, from the command line. + +class Input_argument +{ + public: + // Create a file or library argument. + explicit Input_argument(Input_file_argument file) + : is_file_(true), file_(file), group_(NULL) + { } + + // Create a group argument. + explicit Input_argument(Input_file_group* group) + : is_file_(false), group_(group) + { } + + // Return whether this is a file. + bool + is_file() const + { return this->is_file_; } + + // Return whether this is a group. + bool + is_group() const + { return !this->is_file_; } + + // Return the information about the file. + const Input_file_argument& + file() const + { + assert(this->is_file_); + return this->file_; + } + + // Return the information about the group. + const Input_file_group* + group() const + { + assert(!this->is_file_); + return this->group_; + } + + Input_file_group* + group() + { + assert(!this->is_file_); + return this->group_; + } + + private: + bool is_file_; + Input_file_argument file_; + Input_file_group* group_; +}; + +// A group from the command line. This is a set of arguments within +// --start-group ... --end-group. + +class Input_file_group { + public: + typedef std::vector<Input_argument> Files; + typedef Files::const_iterator const_iterator; + + Input_file_group() + : files_() + { } + + // Add a file to the end of the group. + void + add_file(const Input_file_argument& arg) + { this->files_.push_back(Input_argument(arg)); } + + // Iterators to iterate over the group contents. + + const_iterator + begin() const + { return this->files_.begin(); } + + const_iterator + end() const + { return this->files_.end(); } + + private: + Files files_; }; // All the information read from the command line. @@ -164,6 +251,9 @@ class Input_argument_list : public std::vector<Input_argument> class Command_line { public: + typedef std::vector<Input_argument> Input_arguments; + typedef Input_arguments::const_iterator const_iterator; + Command_line(); // Process the command line options. This will exit with an @@ -175,25 +265,53 @@ class Command_line int process_l_option(int, char**, char*); + // Handle a --start-group option. + void + start_group(const char* arg); + + // Handle a --end-group option. + void + end_group(const char* arg); + // Get the general options. const General_options& options() const { return this->options_; } - // Get the list of input files. - const Input_argument_list& - inputs() const - { return this->inputs_; } + // Iterators to iterate over the list of input files. + + const_iterator + begin() const + { return this->inputs_.begin(); } + + const_iterator + end() const + { return this->inputs_.end(); } private: - void usage() ATTRIBUTE_NORETURN; - void usage(const char* msg, const char* opt) ATTRIBUTE_NORETURN; - void usage(const char* msg, char opt) ATTRIBUTE_NORETURN; - void apply_option(const gold::options::One_option&, const char*); + Command_line(const Command_line&); + Command_line& operator=(const Command_line&); + + // Report usage error. + void + usage() ATTRIBUTE_NORETURN; + void + usage(const char* msg, const char* opt) ATTRIBUTE_NORETURN; + void + usage(const char* msg, char opt) ATTRIBUTE_NORETURN; + + // Apply a command line option. + void + apply_option(const gold::options::One_option&, const char*); + + // Add a file. + void + add_file(const char* name, bool is_lib); General_options options_; Position_dependent_options position_options_; - Input_argument_list inputs_; + Input_arguments inputs_; + bool in_group_; }; } // End namespace gold. diff --git a/gold/output.cc b/gold/output.cc index 82e2ca5..703a560 100644 --- a/gold/output.cc +++ b/gold/output.cc @@ -10,6 +10,8 @@ #include <algorithm> #include "object.h" +#include "symtab.h" +#include "reloc.h" #include "output.h" namespace gold @@ -74,7 +76,8 @@ Output_section_headers::Output_section_headers( for (Layout::Segment_list::const_iterator p = segment_list.begin(); p != segment_list.end(); ++p) - count += (*p)->output_section_count(); + if ((*p)->type() == elfcpp::PT_LOAD) + count += (*p)->output_section_count(); count += section_list.size(); int shdr_size; @@ -137,18 +140,22 @@ Output_section_headers::do_sized_write(Output_file* of) v += shdr_size; + unsigned shndx = 1; for (Layout::Segment_list::const_iterator p = this->segment_list_.begin(); p != this->segment_list_.end(); ++p) v = (*p)->write_section_headers SELECT_SIZE_ENDIAN_NAME ( - this->secnamepool_, v SELECT_SIZE_ENDIAN(size, big_endian)); + this->secnamepool_, v, &shndx + SELECT_SIZE_ENDIAN(size, big_endian)); for (Layout::Section_list::const_iterator p = this->section_list_.begin(); p != this->section_list_.end(); ++p) { + assert(shndx == (*p)->out_shndx()); elfcpp::Shdr_write<size, big_endian> oshdr(v); (*p)->write_header(this->secnamepool_, &oshdr); v += shdr_size; + ++shndx; } of->write_output_view(this->offset(), all_shdrs_size, view); @@ -318,6 +325,7 @@ Output_file_header::do_sized_write(Output_file* of) oehdr.put_e_machine(this->target_->machine_code()); oehdr.put_e_version(elfcpp::EV_CURRENT); + // FIXME: Need to support -e, and target specific entry symbol. Symbol* sym = this->symtab_->lookup("_start"); typename Sized_symbol<size>::Value_type v; if (sym == NULL) @@ -344,17 +352,137 @@ Output_file_header::do_sized_write(Output_file* of) oehdr.put_e_shentsize(elfcpp::Elf_sizes<size>::shdr_size); oehdr.put_e_shnum(this->section_header_->data_size() / elfcpp::Elf_sizes<size>::shdr_size); - oehdr.put_e_shstrndx(this->shstrtab_->shndx()); + oehdr.put_e_shstrndx(this->shstrtab_->out_shndx()); of->write_output_view(0, ehdr_size, view); } +// Output_section_got::Got_entry methods. + +// Write out the entry. + +template<int size, bool big_endian> +void +Output_section_got<size, big_endian>::Got_entry::write(unsigned char* pov) + const +{ + Valtype val = 0; + + switch (this->local_sym_index_) + { + case GSYM_CODE: + { + Symbol* gsym = this->u_.gsym; + + // If the symbol is resolved locally, we need to write out its + // value. Otherwise we just write zero. The target code is + // responsible for creating a relocation entry to fill in the + // value at runtime. + if (gsym->is_resolved_locally()) + { + Sized_symbol<size>* sgsym; + // This cast is a bit ugly. We don't want to put a + // virtual method in Symbol, because we want Symbol to be + // as small as possible. + sgsym = static_cast<Sized_symbol<size>*>(gsym); + val = sgsym->value(); + } + } + break; + + case CONSTANT_CODE: + val = this->u_.constant; + break; + + default: + abort(); + } + + Valtype* povv = reinterpret_cast<Valtype*>(pov); + Swap<size, big_endian>::writeval(povv, val); +} + +// Output_section_data methods. + +unsigned int +Output_section_data::do_out_shndx() const +{ + assert(this->output_section_ != NULL); + return this->output_section_->out_shndx(); +} + +// Output_section_got methods. + +// Write out the GOT. + +template<int size, bool big_endian> +void +Output_section_got<size, big_endian>::do_write(Output_file* of) +{ + const int add = size / 8; + + const off_t off = this->offset(); + const off_t oview_size = this->entries_.size() * add; + unsigned char* const oview = of->get_output_view(off, oview_size); + + unsigned char* pov = oview; + for (typename Got_entries::const_iterator p = this->entries_.begin(); + p != this->entries_.end(); + ++p) + { + p->write(pov); + pov += add; + } + + of->write_output_view(off, oview_size, oview); + + // We no longer need the GOT entries. + this->entries_.clear(); +} + +// Output_section::Input_section methods. + +// Return the data size. For an input section we store the size here. +// For an Output_section_data, we have to ask it for the size. + +off_t +Output_section::Input_section::data_size() const +{ + if (this->is_input_section()) + return this->data_size_; + else + return this->u_.posd->data_size(); +} + +// Set the address and file offset. + +void +Output_section::Input_section::set_address(uint64_t addr, off_t off, + off_t secoff) +{ + if (this->is_input_section()) + this->u_.object->set_section_offset(this->shndx_, off - secoff); + else + this->u_.posd->set_address(addr, off); +} + +// Write out the data. We don't have to do anything for an input +// section--they are handled via Object::relocate--but this is where +// we write out the data for an Output_section_data. + +void +Output_section::Input_section::write(Output_file* of) +{ + if (!this->is_input_section()) + this->u_.posd->write(of); +} + // Output_section methods. // Construct an Output_section. NAME will point into a Stringpool. Output_section::Output_section(const char* name, elfcpp::Elf_Word type, - elfcpp::Elf_Xword flags, unsigned int shndx) + elfcpp::Elf_Xword flags, bool may_add_data) : name_(name), addralign_(0), entsize_(0), @@ -362,7 +490,10 @@ Output_section::Output_section(const char* name, elfcpp::Elf_Word type, info_(0), type_(type), flags_(flags), - shndx_(shndx) + out_shndx_(0), + input_sections_(), + first_input_offset_(0), + may_add_data_(may_add_data) { } @@ -370,15 +501,20 @@ Output_section::~Output_section() { } -// Add an input section to an Output_section. We don't keep track of +// Add the input section SHNDX, with header SHDR, named SECNAME, in +// OBJECT, to the Output_section. Return the offset of the input +// section within the output section. We don't always keep track of // input sections for an Output_section. Instead, each Object keeps // track of the Output_section for each of its input sections. template<int size, bool big_endian> off_t -Output_section::add_input_section(Object* object, const char* secname, +Output_section::add_input_section(Object* object, unsigned int shndx, + const char* secname, const elfcpp::Shdr<size, big_endian>& shdr) { + assert(this->may_add_data_); + elfcpp::Elf_Xword addralign = shdr.get_sh_addralign(); if ((addralign & (addralign - 1)) != 0) { @@ -392,19 +528,56 @@ Output_section::add_input_section(Object* object, const char* secname, this->addralign_ = addralign; off_t ssize = this->data_size(); - ssize = (ssize + addralign - 1) &~ (addralign - 1); + ssize = align_address(ssize, addralign); + this->set_data_size(ssize + shdr.get_sh_size()); - // SHF_TLS/SHT_NOBITS sections are handled specially: they are - // treated as having no size and taking up no space. We only use - // the real size when setting the pt_memsz field of the PT_TLS - // segment. - if ((this->flags_ & elfcpp::SHF_TLS) == 0 - || this->type_ != elfcpp::SHT_NOBITS) - this->set_data_size(ssize + shdr.get_sh_size()); + // We need to keep track of this section if we are already keeping + // track of sections, or if we are relaxing. FIXME: Add test for + // relaxing. + if (! this->input_sections_.empty()) + this->input_sections_.push_back(Input_section(object, shndx, + shdr.get_sh_size(), + addralign)); return ssize; } +// Add arbitrary data to an output section. + +void +Output_section::add_output_section_data(Output_section_data* posd) +{ + if (this->input_sections_.empty()) + this->first_input_offset_ = this->data_size(); + this->input_sections_.push_back(Input_section(posd)); + uint64_t addralign = posd->addralign(); + if (addralign > this->addralign_) + this->addralign_ = addralign; + posd->set_output_section(this); +} + +// Set the address of an Output_section. This is where we handle +// setting the addresses of any Output_section_data objects. + +void +Output_section::do_set_address(uint64_t address, off_t startoff) +{ + if (this->input_sections_.empty()) + return; + + off_t off = startoff + this->first_input_offset_; + for (Input_section_list::iterator p = this->input_sections_.begin(); + p != this->input_sections_.end(); + ++p) + { + off = align_address(off, p->addralign()); + p->set_address(address + (off - startoff), off, startoff); + off += p->data_size(); + } + + this->set_data_size(off - startoff); +} + // Write the section header to *OSHDR. template<int size, bool big_endian> @@ -424,11 +597,23 @@ Output_section::write_header(const Stringpool* secnamepool, oshdr->put_sh_entsize(this->entsize_); } +// Write out the data. For input sections the data is written out by +// Object::relocate, but we have to handle Output_section_data objects +// here. + +void +Output_section::do_write(Output_file* of) +{ + for (Input_section_list::iterator p = this->input_sections_.begin(); + p != this->input_sections_.end(); + ++p) + p->write(of); +} + // Output_section_symtab methods. -Output_section_symtab::Output_section_symtab(const char* name, off_t size, - unsigned int shndx) - : Output_section(name, elfcpp::SHT_SYMTAB, 0, shndx) +Output_section_symtab::Output_section_symtab(const char* name, off_t size) + : Output_section(name, elfcpp::SHT_SYMTAB, 0, false) { this->set_data_size(size); } @@ -436,9 +621,8 @@ Output_section_symtab::Output_section_symtab(const char* name, off_t size, // Output_section_strtab methods. Output_section_strtab::Output_section_strtab(const char* name, - Stringpool* contents, - unsigned int shndx) - : Output_section(name, elfcpp::SHT_STRTAB, 0, shndx), + Stringpool* contents) + : Output_section(name, elfcpp::SHT_STRTAB, 0, false), contents_(contents) { this->set_data_size(contents->get_strtab_size()); @@ -462,7 +646,8 @@ Output_segment::Output_segment(elfcpp::Elf_Word type, elfcpp::Elf_Word flags) offset_(0), filesz_(0), type_(type), - flags_(flags) + flags_(flags), + is_align_known_(false) { } @@ -473,12 +658,10 @@ Output_segment::add_output_section(Output_section* os, elfcpp::Elf_Word seg_flags) { assert((os->flags() & elfcpp::SHF_ALLOC) != 0); + assert(!this->is_align_known_); - // Update the segment flags and alignment. + // Update the segment flags. this->flags_ |= seg_flags; - uint64_t addralign = os->addralign(); - if (addralign > this->align_) - this->align_ = addralign; Output_segment::Output_data_list* pdl; if (os->type() == elfcpp::SHT_NOBITS) @@ -524,12 +707,28 @@ Output_segment::add_output_section(Output_section* os, { pdl = &this->output_data_; bool nobits = os->type() == elfcpp::SHT_NOBITS; + bool sawtls = false; Layout::Data_list::iterator p = pdl->end(); do { --p; - if ((*p)->is_section_flag_set(elfcpp::SHF_TLS) - && (nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS))) + bool insert; + if ((*p)->is_section_flag_set(elfcpp::SHF_TLS)) + { + sawtls = true; + // Put a NOBITS section after the first TLS section. + // But a PROGBITS section after the first TLS/PROGBITS + // section. + insert = nobits || !(*p)->is_section_type(elfcpp::SHT_NOBITS); + } + else + { + // If we've gone past the TLS sections, but we've seen a + // TLS section, then we need to insert this section now. + insert = sawtls; + } + + if (insert) { ++p; pdl->insert(p, os); @@ -537,6 +736,9 @@ Output_segment::add_output_section(Output_section* os, } } while (p != pdl->begin()); + + // There are no TLS sections yet; put this one at the end of the + // section list. } pdl->push_back(os); @@ -548,28 +750,59 @@ Output_segment::add_output_section(Output_section* os, void Output_segment::add_initial_output_data(Output_data* od) { - uint64_t addralign = od->addralign(); - if (addralign > this->align_) - this->align_ = addralign; - + assert(!this->is_align_known_); this->output_data_.push_front(od); } // Return the maximum alignment of the Output_data in Output_segment. -// We keep this up to date as we add Output_sections and Output_data. +// Once we compute this, we prohibit new sections from being added. uint64_t -Output_segment::max_data_align() const +Output_segment::addralign() { + if (!this->is_align_known_) + { + uint64_t addralign; + + addralign = Output_segment::maximum_alignment(&this->output_data_); + if (addralign > this->align_) + this->align_ = addralign; + + addralign = Output_segment::maximum_alignment(&this->output_bss_); + if (addralign > this->align_) + this->align_ = addralign; + + this->is_align_known_ = true; + } + return this->align_; } +// Return the maximum alignment of a list of Output_data. + +uint64_t +Output_segment::maximum_alignment(const Output_data_list* pdl) +{ + uint64_t ret = 0; + for (Output_data_list::const_iterator p = pdl->begin(); + p != pdl->end(); + ++p) + { + uint64_t addralign = (*p)->addralign(); + if (addralign > ret) + ret = addralign; + } + return ret; +} + // Set the section addresses for an Output_segment. ADDR is the -// address and *POFF is the file offset. Return the address of the -// immediately following segment. Update *POFF. +// address and *POFF is the file offset. Set the section indexes +// starting with *PSHNDX. Return the address of the immediately +// following segment. Update *POFF and *PSHNDX. uint64_t -Output_segment::set_section_addresses(uint64_t addr, off_t* poff) +Output_segment::set_section_addresses(uint64_t addr, off_t* poff, + unsigned int* pshndx) { assert(this->type_ == elfcpp::PT_LOAD); @@ -579,13 +812,16 @@ Output_segment::set_section_addresses(uint64_t addr, off_t* poff) off_t orig_off = *poff; this->offset_ = orig_off; - addr = this->set_section_list_addresses(&this->output_data_, addr, poff); + *poff = align_address(*poff, this->addralign()); + + addr = this->set_section_list_addresses(&this->output_data_, addr, poff, + pshndx); this->filesz_ = *poff - orig_off; off_t off = *poff; uint64_t ret = this->set_section_list_addresses(&this->output_bss_, addr, - poff); + poff, pshndx); this->memsz_ = *poff - orig_off; // Ignore the file offset adjustments made by the BSS Output_data @@ -599,26 +835,36 @@ Output_segment::set_section_addresses(uint64_t addr, off_t* poff) uint64_t Output_segment::set_section_list_addresses(Output_data_list* pdl, - uint64_t addr, off_t* poff) + uint64_t addr, off_t* poff, + unsigned int* pshndx) { - off_t off = *poff; + off_t startoff = *poff; + off_t off = startoff; for (Output_data_list::iterator p = pdl->begin(); p != pdl->end(); ++p) { - uint64_t addralign = (*p)->addralign(); - addr = (addr + addralign - 1) & ~ (addralign - 1); - off = (off + addralign - 1) & ~ (addralign - 1); - (*p)->set_address(addr, off); + off = align_address(off, (*p)->addralign()); + (*p)->set_address(addr + (off - startoff), off); + + // Unless this is a PT_TLS segment, we want to ignore the size + // of a SHF_TLS/SHT_NOBITS section. Such a section does not + // affect the size of a PT_LOAD segment. + if (this->type_ == elfcpp::PT_TLS + || !(*p)->is_section_flag_set(elfcpp::SHF_TLS) + || !(*p)->is_section_type(elfcpp::SHT_NOBITS)) + off += (*p)->data_size(); - uint64_t size = (*p)->data_size(); - addr += size; - off += size; + if ((*p)->is_section()) + { + (*p)->set_out_shndx(*pshndx); + ++*pshndx; + } } *poff = off; - return addr; + return addr + (off - startoff); } // For a non-PT_LOAD segment, set the offset from the sections, if @@ -667,8 +913,6 @@ Output_segment::set_offset() this->memsz_ = (last->address() + last->data_size() - this->vaddr_); - - // this->align_ was set as we added items. } // Return the number of Output_sections in an Output_segment. @@ -700,7 +944,7 @@ Output_segment::output_section_count_list(const Output_data_list* pdl) const template<int size, bool big_endian> void -Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr) const +Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr) { ophdr->put_p_type(this->type_); ophdr->put_p_offset(this->offset_); @@ -709,7 +953,7 @@ Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr) const ophdr->put_p_filesz(this->filesz_); ophdr->put_p_memsz(this->memsz_); ophdr->put_p_flags(this->flags_); - ophdr->put_p_align(this->align_); + ophdr->put_p_align(this->addralign()); } // Write the section headers into V. @@ -717,13 +961,22 @@ Output_segment::write_header(elfcpp::Phdr_write<size, big_endian>* ophdr) const template<int size, bool big_endian> unsigned char* Output_segment::write_section_headers(const Stringpool* secnamepool, - unsigned char* v + unsigned char* v, + unsigned int *pshndx ACCEPT_SIZE_ENDIAN) const { + // Every section that is attached to a segment must be attached to a + // PT_LOAD segment, so we only write out section headers for PT_LOAD + // segments. + if (this->type_ != elfcpp::PT_LOAD) + return v; + v = this->write_section_headers_list SELECT_SIZE_ENDIAN_NAME ( - secnamepool, &this->output_data_, v SELECT_SIZE_ENDIAN(size, big_endian)); + secnamepool, &this->output_data_, v, pshndx + SELECT_SIZE_ENDIAN(size, big_endian)); v = this->write_section_headers_list SELECT_SIZE_ENDIAN_NAME ( - secnamepool, &this->output_bss_, v SELECT_SIZE_ENDIAN(size, big_endian)); + secnamepool, &this->output_bss_, v, pshndx + SELECT_SIZE_ENDIAN(size, big_endian)); return v; } @@ -731,7 +984,8 @@ template<int size, bool big_endian> unsigned char* Output_segment::write_section_headers_list(const Stringpool* secnamepool, const Output_data_list* pdl, - unsigned char* v + unsigned char* v, + unsigned int* pshndx ACCEPT_SIZE_ENDIAN) const { const int shdr_size = elfcpp::Elf_sizes<size>::shdr_size; @@ -742,9 +996,11 @@ Output_segment::write_section_headers_list(const Stringpool* secnamepool, if ((*p)->is_section()) { const Output_section* ps = static_cast<const Output_section*>(*p); + assert(*pshndx == ps->out_shndx()); elfcpp::Shdr_write<size, big_endian> oshdr(v); ps->write_header(secnamepool, &oshdr); v += shdr_size; + ++*pshndx; } } return v; @@ -834,6 +1090,7 @@ template off_t Output_section::add_input_section<32, false>( Object* object, + unsigned int shndx, const char* secname, const elfcpp::Shdr<32, false>& shdr); @@ -841,6 +1098,7 @@ template off_t Output_section::add_input_section<32, true>( Object* object, + unsigned int shndx, const char* secname, const elfcpp::Shdr<32, true>& shdr); @@ -848,6 +1106,7 @@ template off_t Output_section::add_input_section<64, false>( Object* object, + unsigned int shndx, const char* secname, const elfcpp::Shdr<64, false>& shdr); @@ -855,7 +1114,24 @@ template off_t Output_section::add_input_section<64, true>( Object* object, + unsigned int shndx, const char* secname, const elfcpp::Shdr<64, true>& shdr); +template +void +Output_section_got<32, false>::do_write(Output_file* of); + +template +void +Output_section_got<32, true>::do_write(Output_file* of); + +template +void +Output_section_got<64, false>::do_write(Output_file* of); + +template +void +Output_section_got<64, true>::do_write(Output_file* of); + } // End namespace gold. diff --git a/gold/output.h b/gold/output.h index e036b98..5c72c02 100644 --- a/gold/output.h +++ b/gold/output.h @@ -5,6 +5,7 @@ #include <cassert> #include <list> +#include <vector> #include "elfcpp.h" #include "layout.h" @@ -31,17 +32,21 @@ class Output_data virtual ~Output_data(); - // Return the address. + // Return the address. This is only valid after Layout::finalize is + // finished. uint64_t address() const { return this->address_; } - // Return the size of the data. + // Return the size of the data. This must be valid after + // Layout::finalize calls set_address, but need not be valid before + // then. off_t data_size() const { return this->data_size_; } - // Return the file offset. + // Return the file offset. This is only valid after + // Layout::finalize is finished. off_t offset() const { return this->offset_; } @@ -67,11 +72,23 @@ class Output_data is_section_flag_set(elfcpp::Elf_Xword shf) const { return this->do_is_section_flag_set(shf); } - // Set the address and file offset of this data. + // Return the output section index, if there is an output section. + unsigned int + out_shndx() const + { return this->do_out_shndx(); } + + // Set the output section index, if this is an output section. + void + set_out_shndx(unsigned int shndx) + { this->do_set_out_shndx(shndx); } + + // Set the address and file offset of this data. This is called + // during Layout::finalize. void set_address(uint64_t addr, off_t off); - // Write the data to the output file. + // Write the data to the output file. This is called after + // Layout::finalize is complete. void write(Output_file* file) { this->do_write(file); } @@ -104,6 +121,16 @@ class Output_data do_is_section_flag_set(elfcpp::Elf_Xword) const { return false; } + // Return the output section index, if there is an output section. + virtual unsigned int + do_out_shndx() const + { abort(); } + + // Set the output section index, if this is an output section. + virtual void + do_set_out_shndx(unsigned int) + { abort(); } + // Set the address and file offset of the data. This only needs to // be implemented if the child needs to know. virtual void @@ -270,6 +297,198 @@ class Output_file_header : public Output_data const Output_section* shstrtab_; }; +// Output sections are mainly comprised of input sections. However, +// there are cases where we have data to write out which is not in an +// input section. Output_section_data is used in such cases. This is +// an abstract base class. + +class Output_section_data : public Output_data +{ + public: + Output_section_data(off_t data_size, uint64_t addralign) + : Output_data(data_size), output_section_(NULL), addralign_(addralign) + { } + + Output_section_data(uint64_t addralign) + : Output_data(0), output_section_(NULL), addralign_(addralign) + { } + + // Record the output section. + void + set_output_section(Output_section* os) + { + assert(this->output_section_ == NULL); + this->output_section_ = os; + } + + protected: + // The child class must implement do_write. + + // Return the required alignment. + uint64_t + do_addralign() const + { return this->addralign_; } + + // Return the section index of the output section. + unsigned int + do_out_shndx() const; + + private: + // The output section for this section. + const Output_section* output_section_; + // The required alignment. + uint64_t addralign_; +}; + +// Output_section_common is used to handle the common symbols. This +// is quite simple. + +class Output_section_common : public Output_section_data +{ + public: + Output_section_common(uint64_t addralign) + : Output_section_data(addralign) + { } + + // Set the size. + void + set_common_size(off_t common_size) + { this->set_data_size(common_size); } + + // Write out the data--there is nothing to do, as common symbols are + // always zero and are stored in the BSS. + void + do_write(Output_file*) + { } +}; + +// Output_section_got is used to manage a GOT. Each entry in the GOT +// is for one symbol--either a global symbol or a local symbol in an +// object. The target specific code adds entries to the GOT as +// needed. The GOT code is then responsible for writing out the data +// and for generating relocs as required. + +template<int size, bool big_endian> +class Output_section_got : public Output_section_data +{ + public: + typedef typename elfcpp::Elf_types<size>::Elf_Addr Valtype; + + Output_section_got() + : Output_section_data(Output_data::default_alignment(size)), + entries_() + { } + + // Add an entry for a global symbol to the GOT. This returns the + // offset of the new entry from the start of the GOT. + unsigned int + add_global(Symbol* gsym) + { + this->entries_.push_back(Got_entry(gsym)); + this->set_got_size(); + return this->last_got_offset(); + } + + // Add an entry for a local symbol to the GOT. This returns the + // offset of the new entry from the start of the GOT. + unsigned int + add_local(Object* object, unsigned int sym_index) + { + this->entries_.push_back(Got_entry(object, sym_index)); + this->set_got_size(); + return this->last_got_offset(); + } + + // Add a constant to the GOT. This returns the offset of the new + // entry from the start of the GOT. + unsigned int + add_constant(Valtype constant) + { + this->entries_.push_back(Got_entry(constant)); + this->set_got_size(); + return this->last_got_offset(); + } + + // Write out the GOT table. + void + do_write(Output_file*); + + private: + // This POD class holds a single GOT entry. + class Got_entry + { + public: + // Create a zero entry. + Got_entry() + : local_sym_index_(CONSTANT_CODE) + { this->u_.constant = 0; } + + // Create a global symbol entry. + Got_entry(Symbol* gsym) + : local_sym_index_(GSYM_CODE) + { this->u_.gsym = gsym; } + + // Create a local symbol entry. + Got_entry(Object* object, unsigned int local_sym_index) + : local_sym_index_(local_sym_index) + { + assert(local_sym_index != GSYM_CODE + && local_sym_index != CONSTANT_CODE); + this->u_.object = object; + } + + // Create a constant entry. The constant is a host value--it will + // be swapped, if necessary, when it is written out. + Got_entry(Valtype constant) + : local_sym_index_(CONSTANT_CODE) + { this->u_.constant = constant; } + + // Write the GOT entry to an output view. + void + write(unsigned char* pov) const; + + private: + enum + { + GSYM_CODE = -1U, + CONSTANT_CODE = -2U + }; + + union + { + // For a local symbol, the object. + Object* object; + // For a global symbol, the symbol. + Symbol* gsym; + // For a constant, the constant. + Valtype constant; + } u_; + // For a local symbol, the local symbol index. This is -1U for a + // global symbol, or -2U for a constant. + unsigned int local_sym_index_; + }; + + typedef std::vector<Got_entry> Got_entries; + + // Return the offset into the GOT of GOT entry I. + unsigned int + got_offset(unsigned int i) const + { return i * (size / 8); } + + // Return the offset into the GOT of the last entry added. + unsigned int + last_got_offset() const + { return this->got_offset(this->entries_.size() - 1); } + + // Set the size of the section. + void + set_got_size() + { this->set_data_size(this->got_offset(this->entries_.size())); } + + // The list of GOT entries. + Got_entries entries_; +}; + // An output section. We don't expect to have too many output // sections, so we don't bother to do a template on the size. @@ -278,16 +497,20 @@ class Output_section : public Output_data public: // Create an output section, giving the name, type, and flags. Output_section(const char* name, elfcpp::Elf_Word, elfcpp::Elf_Xword, - unsigned int shndx); + bool may_add_data); virtual ~Output_section(); - // Add a new input section named NAME with header SHDR from object - // OBJECT. Return the offset within the output section. + // Add a new input section SHNDX, named NAME, with header SHDR, from + // object OBJECT. Return the offset within the output section. template<int size, bool big_endian> off_t - add_input_section(Object* object, const char *name, + add_input_section(Object* object, unsigned int shndx, const char *name, const elfcpp::Shdr<size, big_endian>& shdr); + // Add generated data ODATA to this output section. + virtual void + add_output_section_data(Output_section_data* posd); + // Return the section name. const char* name() const @@ -303,15 +526,15 @@ class Output_section : public Output_data flags() const { return this->flags_; } - // Return the address alignment. - uint64_t - addralign() const - { return this->addralign_; } - - // Return the section index. + // Return the section index in the output file. unsigned int - shndx() const - { return this->shndx_; } + do_out_shndx() const + { return this->out_shndx_; } + + // Set the output section index. + void + do_set_out_shndx(unsigned int shndx) + { this->out_shndx_ = shndx; } // Set the entsize field. void @@ -333,12 +556,19 @@ class Output_section : public Output_data set_addralign(uint64_t v) { this->addralign_ = v; } + // Set the address of the Output_section. For a typical + // Output_section, there is nothing to do, but if there are any + // Output_section_data objects we need to set the final addresses + // here. + void + do_set_address(uint64_t, off_t); + // Write the data to the file. For a typical Output_section, this - // does nothing. We write out the data by looping over all the - // input sections. + // does nothing: the data is written out by calling Object::Relocate + // on each input object. But if there are any Output_section_data + // objects we do need to write them out here. virtual void - do_write(Output_file*) - { } + do_write(Output_file*); // Return the address alignment--function required by parent class. uint64_t @@ -366,6 +596,83 @@ class Output_section : public Output_data write_header(const Stringpool*, elfcpp::Shdr_write<size, big_endian>*) const; private: + // In some cases we need to keep a list of the input sections + // associated with this output section. We only need the list if we + // might have to change the offsets of the input section within the + // output section after we add the input section. The ordinary + // input sections will be written out when we process the object + // file, and as such we don't need to track them here. We do need + // to track Output_section_data objects here. We store instances of + // this structure in a std::vector, so it must be a POD. There can + // be many instances of this structure, so we use a union to save + // some space. + class Input_section + { + public: + Input_section() + : shndx_(0), p2align_(0), data_size_(0) + { this->u_.object = NULL; } + + Input_section(Object* object, unsigned int shndx, off_t data_size, + uint64_t addralign) + : shndx_(shndx), + p2align_(ffsll(static_cast<long long>(addralign))), + data_size_(data_size) + { + assert(shndx != -1U); + this->u_.object = object; + } + + Input_section(Output_section_data* posd) + : shndx_(-1U), + p2align_(ffsll(static_cast<long long>(posd->addralign()))), + data_size_(0) + { this->u_.posd = posd; } + + // The required alignment. + uint64_t + addralign() const + { return static_cast<uint64_t>(1) << this->p2align_; } + + // Return the required size. + off_t + data_size() const; + + // Set the address and file offset. This is called during + // Layout::finalize. SECOFF is the file offset of the enclosing + // section. + void + set_address(uint64_t addr, off_t off, off_t secoff); + + // Write out the data. This does nothing for an input section. + void + write(Output_file*); + + private: + // Whether this is an input section. + bool + is_input_section() const + { return this->shndx_ != -1U; } + + // For an ordinary input section, this is the section index in + // the input file. For an Output_section_data, this is -1U. + unsigned int shndx_; + // The required alignment, stored as a power of 2. + unsigned int p2align_; + // For an ordinary input section, the section size. + off_t data_size_; + union + { + // If shndx_ != -1U, this points to the object which holds the + // input section. + Object* object; + // If shndx_ == -1U, this is the data to write out. + Output_section_data* posd; + } u_; + }; + + typedef std::vector<Input_section> Input_section_list; + // Most of these fields are only valid after layout. // The name of the section. This will point into a Stringpool. @@ -385,16 +692,35 @@ class Output_section : public Output_data // The section flags. elfcpp::Elf_Xword flags_; // The section index. - unsigned int shndx_; + unsigned int out_shndx_; + // The input sections. This will be empty in cases where we don't + // need to keep track of them. + Input_section_list input_sections_; + // The offset of the first entry in input_sections_. + off_t first_input_offset_; + // Whether we permit adding data. + bool may_add_data_; }; // A special Output_section which represents the symbol table -// (SHT_SYMTAB). +// (SHT_SYMTAB). The actual data is written out by +// Symbol_table::write_globals. class Output_section_symtab : public Output_section { public: - Output_section_symtab(const char* name, off_t size, unsigned int shndx); + Output_section_symtab(const char* name, off_t size); + + // The data is written out by Symbol_table::write_globals. We don't + // do anything here. + void + do_write(Output_file*) + { } + + // We don't expect to see any input sections or data here. + void + add_output_section_data(Output_section_data*) + { abort(); } }; // A special Output_section which holds a string table. @@ -402,13 +728,17 @@ class Output_section_symtab : public Output_section class Output_section_strtab : public Output_section { public: - Output_section_strtab(const char* name, Stringpool* contents, - unsigned int shndx); + Output_section_strtab(const char* name, Stringpool* contents); // Write out the data. void do_write(Output_file*); + // We don't expect to see any input sections or data here. + void + add_output_section_data(Output_section_data*) + { abort(); } + private: Stringpool* contents_; }; @@ -448,9 +778,14 @@ class Output_segment memsz() const { return this->memsz_; } + // Return the file size. + off_t + filesz() const + { return this->filesz_; } + // Return the maximum alignment of the Output_data. uint64_t - max_data_align() const; + addralign(); // Add an Output_section to this segment. void @@ -463,11 +798,12 @@ class Output_segment // Set the address of the segment to ADDR and the offset to *POFF // (aligned if necessary), and set the addresses and offsets of all - // contained output sections accordingly. Return the address of the - // immediately following segment. Update *POFF. This should only - // be called for a PT_LOAD segment. + // contained output sections accordingly. Set the section indexes + // of all contained output sections starting with *PSHNDX. Return + // the address of the immediately following segment. Update *POFF + // and *PSHNDX. This should only be called for a PT_LOAD segment. uint64_t - set_section_addresses(uint64_t addr, off_t* poff); + set_section_addresses(uint64_t addr, off_t* poff, unsigned int* pshndx); // Set the offset of this segment based on the section. This should // only be called for a non-PT_LOAD segment. @@ -481,13 +817,14 @@ class Output_segment // Write the segment header into *OPHDR. template<int size, bool big_endian> void - write_header(elfcpp::Phdr_write<size, big_endian>*) const; + write_header(elfcpp::Phdr_write<size, big_endian>*); // Write the section headers of associated sections into V. template<int size, bool big_endian> unsigned char* write_section_headers(const Stringpool*, - unsigned char* v ACCEPT_SIZE_ENDIAN) const; + unsigned char* v, + unsigned int* pshndx ACCEPT_SIZE_ENDIAN) const; private: Output_segment(const Output_segment&); @@ -495,9 +832,14 @@ class Output_segment typedef std::list<Output_data*> Output_data_list; + // Find the maximum alignment in an Output_data_list. + static uint64_t + maximum_alignment(const Output_data_list*); + // Set the section addresses in an Output_data_list. uint64_t - set_section_list_addresses(Output_data_list*, uint64_t addr, off_t* poff); + set_section_list_addresses(Output_data_list*, uint64_t addr, off_t* poff, + unsigned int* pshndx); // Return the number of Output_sections in an Output_data_list. unsigned int @@ -507,7 +849,8 @@ class Output_segment template<int size, bool big_endian> unsigned char* write_section_headers_list(const Stringpool*, const Output_data_list*, - unsigned char* v ACCEPT_SIZE_ENDIAN) const; + unsigned char* v, + unsigned int* pshdx ACCEPT_SIZE_ENDIAN) const; // The list of output data with contents attached to this segment. Output_data_list output_data_; @@ -529,6 +872,8 @@ class Output_segment elfcpp::Elf_Word type_; // The segment flags. elfcpp::Elf_Word flags_; + // Whether we have set align_. + bool is_align_known_; }; // This class represents the output file. diff --git a/gold/po/POTFILES.in b/gold/po/POTFILES.in index 76d60f9..5d4a4a0 100644 --- a/gold/po/POTFILES.in +++ b/gold/po/POTFILES.in @@ -1,5 +1,9 @@ archive.cc archive.h +common.cc +common.h +defstd.cc +defstd.h dirsearch.cc dirsearch.h fileread.cc diff --git a/gold/po/gold.pot b/gold/po/gold.pot index 66f9572..a62d946 100644 --- a/gold/po/gold.pot +++ b/gold/po/gold.pot @@ -8,7 +8,7 @@ msgid "" msgstr "" "Project-Id-Version: PACKAGE VERSION\n" "Report-Msgid-Bugs-To: \n" -"POT-Creation-Date: 2006-10-20 13:39-0700\n" +"POT-Creation-Date: 2006-11-03 10:04-0800\n" "PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n" "Last-Translator: FULL NAME <EMAIL@ADDRESS>\n" "Language-Team: LANGUAGE <LL@li.org>\n" @@ -16,42 +16,42 @@ msgstr "" "Content-Type: text/plain; charset=CHARSET\n" "Content-Transfer-Encoding: 8bit\n" -#: archive.cc:69 +#: archive.cc:62 #, c-format msgid "%s: %s: no archive symbol table (run ranlib)\n" msgstr "" -#: archive.cc:98 +#: archive.cc:91 #, c-format msgid "%s: %s: bad archive symbol table names\n" msgstr "" -#: archive.cc:132 +#: archive.cc:129 #, c-format msgid "%s; %s: malformed archive header at %ld\n" msgstr "" -#: archive.cc:153 +#: archive.cc:150 #, c-format msgid "%s: %s: malformed archive header size at %ld\n" msgstr "" -#: archive.cc:165 +#: archive.cc:162 #, c-format msgid "%s: %s: malformed archive header name at %ld\n" msgstr "" -#: archive.cc:191 +#: archive.cc:188 #, c-format msgid "%s: %s: bad extended name index at %ld\n" msgstr "" -#: archive.cc:202 +#: archive.cc:199 #, c-format msgid "%s: %s: bad extended name entry at header %ld\n" msgstr "" -#: archive.cc:284 archive.cc:297 +#: archive.cc:279 archive.cc:292 #, c-format msgid "%s: %s: member at %ld is not an ELF object" msgstr "" @@ -66,32 +66,32 @@ msgstr "" msgid "%s: warning: close(%s) failed: %s" msgstr "" -#: fileread.cc:131 +#: fileread.cc:129 #, c-format msgid "%s: %s: lseek to %lld failed: %s" msgstr "" -#: fileread.cc:141 +#: fileread.cc:139 #, c-format msgid "%s: %s: read failed: %s\n" msgstr "" -#: fileread.cc:151 +#: fileread.cc:149 fileread.cc:232 #, c-format msgid "%s: %s: file too short: read only %lld of %lld bytes at %lld\n" msgstr "" -#: fileread.cc:267 +#: fileread.cc:323 #, c-format msgid "%s: cannot find %s\n" msgstr "" -#: fileread.cc:275 +#: fileread.cc:331 #, c-format msgid "%s: cannot open %s: %s\n" msgstr "" -#: gold.cc:100 +#: gold.cc:102 msgid "no input files" msgstr "" @@ -139,319 +139,361 @@ msgstr "" msgid "pthread_cond_signal failed" msgstr "" -#: i386.cc:223 i386.cc:319 i386.cc:466 +#. FIXME: This needs to specify the location somehow. +#: i386.cc:88 +#, c-format +msgid "%s: missing expected TLS relocation\n" +msgstr "" + +#: i386.cc:306 i386.cc:434 i386.cc:627 #, c-format msgid "%s: %s: unexpected reloc %u in object file\n" msgstr "" -#: i386.cc:256 i386.cc:277 +#: i386.cc:339 i386.cc:358 #, c-format msgid "%s: %s: unsupported reloc %u against local symbol\n" msgstr "" -#: i386.cc:354 i386.cc:376 +#: i386.cc:415 i386.cc:469 i386.cc:487 #, c-format msgid "%s: %s: unsupported reloc %u against global symbol %s\n" msgstr "" -#: i386.cc:397 +#: i386.cc:509 #, c-format msgid "%s: %s: unsupported RELA reloc section\n" msgstr "" -#: i386.cc:503 i386.cc:571 +#: i386.cc:548 +#, c-format +msgid "%s: %s: missing expected TLS relocation\n" +msgstr "" + +#: i386.cc:594 i386.cc:659 i386.cc:732 i386.cc:743 #, c-format msgid "%s: %s: unsupported reloc %u\n" msgstr "" -#: i386.cc:528 +#: i386.cc:686 #, c-format msgid "%s: %s: TLS reloc but no TLS segment\n" msgstr "" -#: i386.cc:559 +#: i386.cc:717 #, c-format msgid "%s: %s: unsupported reloc type %u\n" msgstr "" -#: i386.cc:689 +#: i386.cc:926 #, c-format msgid "%s: %s: TLS relocation out of range\n" msgstr "" -#: i386.cc:707 +#: i386.cc:944 #, c-format msgid "%s: %s: TLS relocation against invalid instruction\n" msgstr "" -#: object.cc:60 +#: object.cc:41 #, c-format msgid "%s: %s: bad e_ehsize field (%d != %d)\n" msgstr "" -#: object.cc:67 +#: object.cc:48 #, c-format msgid "%s: %s: bad e_shentsize field (%d != %d)\n" msgstr "" -#: object.cc:108 object.cc:418 +#: object.cc:89 object.cc:329 object.cc:425 #, c-format msgid "%s: %s: bad section name offset for section %u: %lu\n" msgstr "" -#: object.cc:131 +#: object.cc:112 #, c-format msgid "%s: %s: unsupported ELF machine number %d\n" msgstr "" -#: object.cc:226 +#: object.cc:207 #, c-format msgid "%s: %s: invalid symbol table name index: %u\n" msgstr "" -#: object.cc:234 +#: object.cc:215 #, c-format msgid "%s: %s: symbol table name section has wrong type: %u\n" msgstr "" -#: object.cc:286 +#: object.cc:267 #, c-format msgid "%s: %s: section group %u link %u out of range\n" msgstr "" -#: object.cc:296 +#: object.cc:277 #, c-format msgid "%s: %s: section group %u info %u out of range\n" msgstr "" -#: object.cc:307 +#: object.cc:288 #, c-format msgid "%s; %s: symtab section %u link %u out of range\n" msgstr "" -#: object.cc:323 +#: object.cc:304 #, c-format msgid "%s: %s: symbol %u name offset %u out of range\n" msgstr "" -#: object.cc:345 +#: object.cc:352 #, c-format msgid "%s: %s: section %u in section group %u out of range" msgstr "" -#: object.cc:479 +#: object.cc:486 #, c-format msgid "%s: %s: size of symbols is not multiple of symbol size\n" msgstr "" -#: object.cc:566 +#: object.cc:573 #, c-format msgid "%s: %s: unknown section index %u for local symbol %u\n" msgstr "" -#: object.cc:577 +#: object.cc:584 #, c-format msgid "%s: %s: local symbol %u section index %u out of range\n" msgstr "" #. elfcpp::ET_DYN -#: object.cc:755 +#: object.cc:763 #, c-format msgid "%s: %s: dynamic objects are not yet supported\n" msgstr "" -#: object.cc:779 object.cc:832 object.cc:853 +#: object.cc:787 object.cc:840 object.cc:861 #, c-format msgid "%s: %s: ELF file too short\n" msgstr "" -#: object.cc:788 +#: object.cc:796 #, c-format msgid "%s: %s: invalid ELF version 0\n" msgstr "" -#: object.cc:791 +#: object.cc:799 #, c-format msgid "%s: %s: unsupported ELF version %d\n" msgstr "" -#: object.cc:799 +#: object.cc:807 #, c-format msgid "%s: %s: invalid ELF class 0\n" msgstr "" -#: object.cc:806 +#: object.cc:814 #, c-format msgid "%s: %s: unsupported ELF class %d\n" msgstr "" -#: object.cc:814 +#: object.cc:822 #, c-format msgid "%s: %s: invalid ELF data encoding\n" msgstr "" -#: object.cc:821 +#: object.cc:829 #, c-format msgid "%s: %s: unsupported ELF data encoding %d\n" msgstr "" -#: options.cc:97 +#: options.cc:115 #, c-format msgid "" "Usage: %s [options] file...\n" "Options:\n" msgstr "" -#: options.cc:209 +#: options.cc:227 msgid "Search for library LIBNAME" msgstr "" -#: options.cc:210 +#: options.cc:228 msgid "-lLIBNAME --library LIBNAME" msgstr "" -#: options.cc:212 +#: options.cc:230 +msgid "Start a library search group" +msgstr "" + +#: options.cc:232 +msgid "End a library search group" +msgstr "" + +#: options.cc:234 msgid "Add directory to search path" msgstr "" -#: options.cc:213 +#: options.cc:235 msgid "-L DIR, --library-path DIR" msgstr "" -#: options.cc:215 +#: options.cc:237 msgid "Set output file name" msgstr "" -#: options.cc:216 +#: options.cc:238 msgid "-o FILE, --output FILE" msgstr "" -#: options.cc:218 +#: options.cc:240 msgid "Generate relocatable output" msgstr "" -#: options.cc:220 +#: options.cc:242 msgid "Generate shared library" msgstr "" -#: options.cc:222 +#: options.cc:244 msgid "Do not link against shared libraries" msgstr "" -#: options.cc:224 +#: options.cc:246 msgid "Report usage information" msgstr "" -#: options.cc:322 options.cc:373 options.cc:437 +#: options.cc:344 options.cc:395 options.cc:481 msgid "missing argument" msgstr "" -#: options.cc:335 options.cc:382 +#: options.cc:357 options.cc:404 msgid "unknown option" msgstr "" -#: options.cc:451 +#: options.cc:412 +#, c-format +msgid "%s: missing group end" +msgstr "" + +#: options.cc:494 +msgid "may not nest groups" +msgstr "" + +#: options.cc:509 +msgid "group end without group start" +msgstr "" + +#: options.cc:519 #, c-format msgid "%s: use the --help option for usage information\n" msgstr "" -#: options.cc:460 +#: options.cc:528 #, c-format msgid "%s: %s: %s\n" msgstr "" -#: options.cc:469 +#: options.cc:537 #, c-format msgid "%s: -%c: %s\n" msgstr "" -#: output.cc:385 +#: output.cc:521 #, c-format msgid "%s: %s: invalid alignment %lu for section \"%s\"\n" msgstr "" -#: output.cc:775 +#: output.cc:1031 #, c-format msgid "%s: %s: open: %s\n" msgstr "" -#: output.cc:784 +#: output.cc:1040 #, c-format msgid "%s: %s: lseek: %s\n" msgstr "" -#: output.cc:791 +#: output.cc:1047 #, c-format msgid "%s: %s: write: %s\n" msgstr "" -#: output.cc:801 +#: output.cc:1057 #, c-format msgid "%s: %s: mmap: %s\n" msgstr "" -#: output.cc:815 +#: output.cc:1071 #, c-format msgid "%s: %s: munmap: %s\n" msgstr "" -#: output.cc:823 +#: output.cc:1079 #, c-format msgid "%s: %s: close: %s\n" msgstr "" +#: readsyms.cc:84 +#, c-format +msgid "%s: %s: ordinary object found in input group\n" +msgstr "" + #. Here we have to handle any other input file types we need. -#: readsyms.cc:109 +#: readsyms.cc:126 #, c-format msgid "%s: %s: not an object or archive\n" msgstr "" -#: reloc.cc:165 reloc.cc:392 +#: reloc.cc:168 reloc.cc:408 #, c-format msgid "%s: %s: relocation section %u has bad info %u\n" msgstr "" -#: reloc.cc:176 reloc.cc:409 +#: reloc.cc:187 reloc.cc:425 #, c-format msgid "%s: %s: relocation section %u uses unexpected symbol table %u\n" msgstr "" -#: reloc.cc:192 reloc.cc:428 +#: reloc.cc:203 reloc.cc:444 #, c-format msgid "%s: %s: unexpected entsize for reloc section %u: %lu != %u" msgstr "" -#: reloc.cc:203 reloc.cc:439 +#: reloc.cc:214 reloc.cc:455 #, c-format msgid "%s: %s: reloc section %u size %lu uneven" msgstr "" -#: resolve.cc:138 +#: resolve.cc:140 #, c-format msgid "%s: %s: invalid STB_LOCAL symbol %s in external symbols\n" msgstr "" -#: resolve.cc:144 +#: resolve.cc:146 #, c-format msgid "%s: %s: unsupported symbol binding %d for symbol %s\n" msgstr "" -#: symtab.cc:303 +#: symtab.cc:428 #, c-format msgid "%s: %s: mixing 32-bit and 64-bit ELF objects\n" msgstr "" -#: symtab.cc:320 +#: symtab.cc:445 #, c-format msgid "%s: %s: bad global symbol name offset %u at %lu\n" msgstr "" -#: target-reloc.h:145 +#: symtab.cc:840 symtab.cc:975 +#, c-format +msgid "%s: %s: unsupported symbol section 0x%x\n" +msgstr "" + +#: target-reloc.h:181 #, c-format msgid "%s: %s: reloc has bad offset %zu\n" msgstr "" -#: target-reloc.h:176 +#: target-reloc.h:191 #, c-format msgid "%s: %s: undefined reference to '%s'\n" msgstr "" diff --git a/gold/readsyms.cc b/gold/readsyms.cc index 3a5650a..9ff7ab7 100644 --- a/gold/readsyms.cc +++ b/gold/readsyms.cc @@ -22,15 +22,16 @@ Read_symbols::~Read_symbols() // Add_symbols task. } -// Return whether a Read_symbols task is runnable. We need write -// access to the symbol table. We can read an ordinary input file -// immediately. For an archive specified using -l, we have to wait -// until the search path is complete. +// Return whether a Read_symbols task is runnable. We can read an +// ordinary input file immediately. For an archive specified using +// -l, we have to wait until the search path is complete. Task::Is_runnable_type Read_symbols::is_runnable(Workqueue*) { - if (this->input_.is_lib() && this->dirpath_.token().is_blocked()) + if (this->input_.is_file() + && this->input_.file().is_lib() + && this->dirpath_.token().is_blocked()) return IS_BLOCKED; return IS_RUNNABLE; @@ -51,7 +52,14 @@ Read_symbols::locks(Workqueue*) void Read_symbols::run(Workqueue* workqueue) { - Input_file* input_file = new Input_file(this->input_); + if (this->input_.is_group()) + { + assert(this->input_group_ == NULL); + this->do_group(workqueue); + return; + } + + Input_file* input_file = new Input_file(this->input_.file()); input_file->open(this->options_, this->dirpath_); // Read enough of the file to pick up the entire ELF header. @@ -69,14 +77,22 @@ Read_symbols::run(Workqueue* workqueue) if (memcmp(p, elfmagic, 4) == 0) { // This is an ELF object. - Object* obj = make_elf_object(this->input_.name(), input_file, 0, - p, bytes); - this->input_objects_->add_object(obj); + if (this->input_group_ != NULL) + { + fprintf(stderr, + _("%s: %s: ordinary object found in input group\n"), + program_name, input_file->name()); + gold_exit(false); + } + + Object* obj = make_elf_object(this->input_.file().name(), + input_file, 0, p, bytes); Read_symbols_data* sd = new Read_symbols_data; obj->read_symbols(sd); - workqueue->queue_front(new Add_symbols(this->symtab_, this->layout_, + workqueue->queue_front(new Add_symbols(this->input_objects_, + this->symtab_, this->layout_, obj, sd, this->this_blocker_, this->next_blocker_)); @@ -93,12 +109,13 @@ Read_symbols::run(Workqueue* workqueue) if (memcmp(p, Archive::armag, Archive::sarmag) == 0) { // This is an archive. - Archive* arch = new Archive(this->input_.name(), input_file); + Archive* arch = new Archive(this->input_.file().name(), input_file); arch->setup(); workqueue->queue(new Add_archive_symbols(this->symtab_, this->layout_, this->input_objects_, arch, + this->input_group_, this->this_blocker_, this->next_blocker_)); return; @@ -111,6 +128,46 @@ Read_symbols::run(Workqueue* workqueue) gold_exit(false); } +// Handle a group. We need to walk through the arguments over and +// over until we don't see any new undefined symbols. We do this by +// setting off Read_symbols Tasks as usual, but recording the archive +// entries instead of deleting them. We also start a Finish_group +// Task which runs after we've read all the symbols. In that task we +// process the archives in a loop until we are done. + +void +Read_symbols::do_group(Workqueue* workqueue) +{ + Input_group* input_group = new Input_group(); + + const Input_file_group* group = this->input_.group(); + Task_token* this_blocker = this->this_blocker_; + for (Input_file_group::const_iterator p = group->begin(); + p != group->end(); + ++p) + { + const Input_argument& arg(*p); + assert(arg.is_file()); + + Task_token* next_blocker = new Task_token(); + next_blocker->add_blocker(); + workqueue->queue(new Read_symbols(this->options_, this->input_objects_, + this->symtab_, this->layout_, + this->dirpath_, arg, input_group, + this_blocker, next_blocker)); + this_blocker = next_blocker; + } + + const int saw_undefined = this->symtab_->saw_undefined(); + workqueue->queue(new Finish_group(this->input_objects_, + this->symtab_, + this->layout_, + input_group, + saw_undefined, + this_blocker, + this->next_blocker_)); +} + // Class Add_symbols. Add_symbols::~Add_symbols() @@ -154,13 +211,71 @@ Add_symbols::locks(Workqueue* workqueue) this->object_); } +// Add the symbols in the object to the symbol table. + void Add_symbols::run(Workqueue*) { + this->input_objects_->add_object(this->object_); this->object_->layout(this->layout_, this->sd_); this->object_->add_symbols(this->symtab_, this->sd_); delete this->sd_; this->sd_ = NULL; } +// Class Finish_group. + +Finish_group::~Finish_group() +{ + if (this->this_blocker_ != NULL) + delete this->this_blocker_; + // next_blocker_ is deleted by the task associated with the next + // input file following the group. +} + +// We need to wait for THIS_BLOCKER_ and unblock NEXT_BLOCKER_. + +Task::Is_runnable_type +Finish_group::is_runnable(Workqueue*) +{ + if (this->this_blocker_ != NULL && this->this_blocker_->is_blocked()) + return IS_BLOCKED; + return IS_RUNNABLE; +} + +Task_locker* +Finish_group::locks(Workqueue* workqueue) +{ + return new Task_locker_block(*this->next_blocker_, workqueue); +} + +// Loop over the archives until there are no new undefined symbols. + +void +Finish_group::run(Workqueue*) +{ + int saw_undefined = this->saw_undefined_; + while (saw_undefined != this->symtab_->saw_undefined()) + { + saw_undefined = this->symtab_->saw_undefined(); + + for (Input_group::const_iterator p = this->input_group_->begin(); + p != this->input_group_->end(); + ++p) + { + Task_lock_obj<Archive> tl(**p); + + (*p)->add_symbols(this->symtab_, this->layout_, + this->input_objects_); + } + } + + // Delete all the archives now that we no longer need them. + for (Input_group::const_iterator p = this->input_group_->begin(); + p != this->input_group_->end(); + ++p) + delete *p; + delete this->input_group_; +} + } // End namespace gold. diff --git a/gold/readsyms.h b/gold/readsyms.h index 2077d47..2348c32 100644 --- a/gold/readsyms.h +++ b/gold/readsyms.h @@ -3,6 +3,8 @@ #ifndef GOLD_READSYMS_H #define GOLD_READSYMS_H +#include <vector> + #include "workqueue.h" #include "object.h" @@ -11,6 +13,8 @@ namespace gold class Input_objects; class Symbol_table; +class Input_group; +class Archive; // This Task is responsible for reading the symbols from an input // file. This also includes reading the relocations so that we can @@ -24,17 +28,20 @@ class Read_symbols : public Task { public: // DIRPATH is the list of directories to search for libraries. - // INPUT is the file to read. THIS_BLOCKER is used to prevent the - // associated Add_symbols task from running before the previous one - // has completed; it will be NULL for the first task. NEXT_BLOCKER - // is used to block the next input file from adding symbols. + // INPUT is the file to read. INPUT_GROUP is not NULL if we are in + // the middle of an input group. THIS_BLOCKER is used to prevent + // the associated Add_symbols task from running before the previous + // one has completed; it will be NULL for the first task. + // NEXT_BLOCKER is used to block the next input file from adding + // symbols. Read_symbols(const General_options& options, Input_objects* input_objects, Symbol_table* symtab, Layout* layout, const Dirsearch& dirpath, - const Input_argument& input, + const Input_argument& input, Input_group* input_group, Task_token* this_blocker, Task_token* next_blocker) : options_(options), input_objects_(input_objects), symtab_(symtab), layout_(layout), dirpath_(dirpath), input_(input), - this_blocker_(this_blocker), next_blocker_(next_blocker) + input_group_(input_group), this_blocker_(this_blocker), + next_blocker_(next_blocker) { } ~Read_symbols(); @@ -51,12 +58,17 @@ class Read_symbols : public Task run(Workqueue*); private: + // Handle an archive group. + void + do_group(Workqueue*); + const General_options& options_; Input_objects* input_objects_; Symbol_table* symtab_; Layout* layout_; const Dirsearch& dirpath_; const Input_argument& input_; + Input_group* input_group_; Task_token* this_blocker_; Task_token* next_blocker_; }; @@ -71,11 +83,12 @@ class Add_symbols : public Task // THIS_BLOCKER is used to prevent this task from running before the // one for the previous input file. NEXT_BLOCKER is used to prevent // the next task from running. - Add_symbols(Symbol_table* symtab, Layout* layout, Object* object, - Read_symbols_data* sd, Task_token* this_blocker, - Task_token* next_blocker) - : symtab_(symtab), layout_(layout), object_(object), sd_(sd), - this_blocker_(this_blocker), next_blocker_(next_blocker) + Add_symbols(Input_objects* input_objects, Symbol_table* symtab, + Layout* layout, Object* object, Read_symbols_data* sd, + Task_token* this_blocker, Task_token* next_blocker) + : input_objects_(input_objects), symtab_(symtab), layout_(layout), + object_(object), sd_(sd), this_blocker_(this_blocker), + next_blocker_(next_blocker) { } ~Add_symbols(); @@ -94,6 +107,7 @@ class Add_symbols : public Task private: class Add_symbols_locker; + Input_objects* input_objects_; Symbol_table* symtab_; Layout* layout_; Object* object_; @@ -102,6 +116,75 @@ private: Task_token* next_blocker_; }; +// This class is used to track the archives in a group. + +class Input_group +{ + public: + typedef std::vector<Archive*> Archives; + typedef Archives::const_iterator const_iterator; + + Input_group() + : archives_() + { } + + // Add an archive to the group. + void + add_archive(Archive* arch) + { this->archives_.push_back(arch); } + + // Loop over the archives in the group. + + const_iterator + begin() const + { return this->archives_.begin(); } + + const_iterator + end() const + { return this->archives_.end(); } + + private: + Archives archives_; +}; + +// This class is used to finish up handling a group. It is just a +// closure. + +class Finish_group : public Task +{ + public: + Finish_group(Input_objects* input_objects, Symbol_table* symtab, + Layout* layout, Input_group* input_group, + int saw_undefined, Task_token* this_blocker, + Task_token* next_blocker) + : input_objects_(input_objects), symtab_(symtab), layout_(layout), + input_group_(input_group), saw_undefined_(saw_undefined), + this_blocker_(this_blocker), next_blocker_(next_blocker) + { } + + ~Finish_group(); + + // The standard Task methods. + + Is_runnable_type + is_runnable(Workqueue*); + + Task_locker* + locks(Workqueue*); + + void + run(Workqueue*); + + private: + Input_objects* input_objects_; + Symbol_table* symtab_; + Layout* layout_; + Input_group* input_group_; + int saw_undefined_; + Task_token* this_blocker_; + Task_token* next_blocker_; +}; + } // end namespace gold #endif // !defined(GOLD_READSYMS_H) diff --git a/gold/reloc.cc b/gold/reloc.cc index bb672e4..ca5e380 100644 --- a/gold/reloc.cc +++ b/gold/reloc.cc @@ -38,8 +38,8 @@ Read_relocs::run(Workqueue* workqueue) Read_relocs_data *rd = new Read_relocs_data; this->object_->read_relocs(rd); workqueue->queue_front(new Scan_relocs(this->options_, this->symtab_, - this->object_, rd, this->symtab_lock_, - this->blocker_)); + this->layout_, this->object_, rd, + this->symtab_lock_, this->blocker_)); } // Scan_relocs methods. @@ -52,7 +52,9 @@ Read_relocs::run(Workqueue* workqueue) Task::Is_runnable_type Scan_relocs::is_runnable(Workqueue*) { - return this->symtab_lock_->is_writable() ? IS_RUNNABLE : IS_LOCKED; + if (!this->symtab_lock_->is_writable() || this->object_->is_locked()) + return IS_LOCKED; + return IS_RUNNABLE; } // Return the locks we hold: one on the file, one on the symbol table @@ -85,7 +87,8 @@ Scan_relocs::locks(Workqueue* workqueue) void Scan_relocs::run(Workqueue*) { - this->object_->scan_relocs(this->options_, this->symtab_, this->rd_); + this->object_->scan_relocs(this->options_, this->symtab_, this->layout_, + this->rd_); delete this->rd_; this->rd_ = NULL; } @@ -170,6 +173,14 @@ Sized_object<size, big_endian>::do_read_relocs(Read_relocs_data* rd) if (!this->is_section_included(shndx)) continue; + // We are scanning relocations in order to fill out the GOT and + // PLT sections. Relocations for sections which are not + // allocated (typically debugging sections) should not add new + // GOT and PLT entries. So we skip them. + typename This::Shdr secshdr(pshdrs + shndx * This::shdr_size); + if ((secshdr.get_sh_flags() & elfcpp::SHF_ALLOC) == 0) + continue; + if (shdr.get_sh_link() != this->symtab_shnum_) { fprintf(stderr, @@ -239,6 +250,7 @@ template<int size, bool big_endian> void Sized_object<size, big_endian>::do_scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Read_relocs_data* rd) { Sized_target<size, big_endian>* target = this->sized_target(); @@ -253,7 +265,7 @@ Sized_object<size, big_endian>::do_scan_relocs(const General_options& options, p != rd->relocs.end(); ++p) { - target->scan_relocs(options, symtab, this, p->sh_type, + target->scan_relocs(options, symtab, layout, this, p->sh_type, p->contents->data(), p->reloc_count, this->local_symbol_count_, local_symbols, @@ -338,11 +350,15 @@ Sized_object<size, big_endian>::write_sections(const unsigned char* pshdrs, if (shdr.get_sh_type() == elfcpp::SHT_NOBITS) continue; - assert(map_sections[i].offset >= 0 - && map_sections[i].offset < os->data_size()); off_t start = os->offset() + map_sections[i].offset; off_t sh_size = shdr.get_sh_size(); + if (sh_size == 0) + continue; + + assert(map_sections[i].offset >= 0 + && map_sections[i].offset + sh_size <= os->data_size()); + unsigned char* view = of->get_output_view(start, sh_size); this->read(shdr.get_sh_offset(), sh_size, view); @@ -477,24 +493,28 @@ template void Sized_object<32, false>::do_scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Read_relocs_data* rd); template void Sized_object<32, true>::do_scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Read_relocs_data* rd); template void Sized_object<64, false>::do_scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Read_relocs_data* rd); template void Sized_object<64, true>::do_scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Read_relocs_data* rd); template diff --git a/gold/reloc.h b/gold/reloc.h index a2e9d54..f8f07b8 100644 --- a/gold/reloc.h +++ b/gold/reloc.h @@ -13,6 +13,7 @@ namespace gold class Object; class Read_relocs_data; class Stringpool; +class Layout; // A class to read the relocations for an object file, and then queue // up a task to see if they require any GOT/PLT/COPY relocations in @@ -24,9 +25,9 @@ class Read_relocs : public Task // SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be // unblocked when the Scan_relocs task completes. Read_relocs(const General_options& options, Symbol_table* symtab, - Object* object, Task_token* symtab_lock, + Layout* layout, Object* object, Task_token* symtab_lock, Task_token* blocker) - : options_(options), symtab_(symtab), object_(object), + : options_(options), symtab_(symtab), layout_(layout), object_(object), symtab_lock_(symtab_lock), blocker_(blocker) { } @@ -44,6 +45,7 @@ class Read_relocs : public Task private: const General_options& options_; Symbol_table* symtab_; + Layout* layout_; Object* object_; Task_token* symtab_lock_; Task_token* blocker_; @@ -58,10 +60,10 @@ class Scan_relocs : public Task // SYMTAB_LOCK is used to lock the symbol table. BLOCKER should be // unblocked when the task completes. Scan_relocs(const General_options& options, Symbol_table* symtab, - Object* object, Read_relocs_data* rd, Task_token* symtab_lock, - Task_token* blocker) - : options_(options), symtab_(symtab), object_(object), rd_(rd), - symtab_lock_(symtab_lock), blocker_(blocker) + Layout* layout, Object* object, Read_relocs_data* rd, + Task_token* symtab_lock, Task_token* blocker) + : options_(options), symtab_(symtab), layout_(layout), object_(object), + rd_(rd), symtab_lock_(symtab_lock), blocker_(blocker) { } // The standard Task methods. @@ -80,6 +82,7 @@ class Scan_relocs : public Task const General_options& options_; Symbol_table* symtab_; + Layout* layout_; Object* object_; Read_relocs_data* rd_; Task_token* symtab_lock_; diff --git a/gold/resolve.cc b/gold/resolve.cc index 6b8199c..83e616c 100644 --- a/gold/resolve.cc +++ b/gold/resolve.cc @@ -19,12 +19,14 @@ void Symbol::override_base(const elfcpp::Sym<size, big_endian>& sym, Object* object) { - this->object_ = object; - this->shnum_ = sym.get_st_shndx(); // FIXME: Handle SHN_XINDEX. + assert(this->source_ == FROM_OBJECT); + this->u_.from_object.object = object; + // FIXME: Handle SHN_XINDEX. + this->u_.from_object.shnum = sym.get_st_shndx(); this->type_ = sym.get_st_type(); this->binding_ = sym.get_st_bind(); this->visibility_ = sym.get_st_visibility(); - this->other_ = sym.get_st_nonvis(); + this->nonvis_ = sym.get_st_nonvis(); } // Override the fields in Sized_symbol. @@ -37,7 +39,7 @@ Sized_symbol<size>::override(const elfcpp::Sym<size, big_endian>& sym, { this->override_base(sym, object); this->value_ = sym.get_st_value(); - this->size_ = sym.get_st_size(); + this->symsize_ = sym.get_st_size(); } // Resolve a symbol. This is called the second and subsequent times @@ -315,9 +317,16 @@ Symbol_table::resolve(Sized_symbol<size>* to, case DYN_DEF * 16 + UNDEF: case DYN_WEAK_DEF * 16 + UNDEF: case UNDEF * 16 + UNDEF: + // A new undefined reference tells us nothing. + return; + case WEAK_UNDEF * 16 + UNDEF: case DYN_UNDEF * 16 + UNDEF: case DYN_WEAK_UNDEF * 16 + UNDEF: + // A strong undef overrides a dynamic or weak undef. + to->override(sym, object); + return; + case COMMON * 16 + UNDEF: case WEAK_COMMON * 16 + UNDEF: case DYN_COMMON * 16 + UNDEF: @@ -391,50 +400,100 @@ Symbol_table::resolve(Sized_symbol<size>* to, return; case COMMON * 16 + COMMON: + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; + case WEAK_COMMON * 16 + COMMON: + // I'm not sure just what a weak common symbol means, but + // presumably it can be overridden by a regular common symbol. + to->override(sym, object); + return; + case DYN_COMMON * 16 + COMMON: case DYN_WEAK_COMMON * 16 + COMMON: + { + // Use the real common symbol, but adjust the size if necessary. + typename Sized_symbol<size>::Size_type symsize = to->symsize(); + to->override(sym, object); + if (to->symsize() < symsize) + to->set_symsize(symsize); + } + return; case DEF * 16 + WEAK_COMMON: case WEAK_DEF * 16 + WEAK_COMMON: case DYN_DEF * 16 + WEAK_COMMON: case DYN_WEAK_DEF * 16 + WEAK_COMMON: + // Whatever a weak common symbol is, it won't override a + // definition. + return; + case UNDEF * 16 + WEAK_COMMON: case WEAK_UNDEF * 16 + WEAK_COMMON: case DYN_UNDEF * 16 + WEAK_COMMON: case DYN_WEAK_UNDEF * 16 + WEAK_COMMON: + // A weak common symbol is better than an undefined symbol. + to->override(sym, object); + return; + case COMMON * 16 + WEAK_COMMON: case WEAK_COMMON * 16 + WEAK_COMMON: case DYN_COMMON * 16 + WEAK_COMMON: case DYN_WEAK_COMMON * 16 + WEAK_COMMON: + // Ignore a weak common symbol in the presence of a real common + // symbol. + return; case DEF * 16 + DYN_COMMON: case WEAK_DEF * 16 + DYN_COMMON: case DYN_DEF * 16 + DYN_COMMON: case DYN_WEAK_DEF * 16 + DYN_COMMON: + // Ignore a dynamic common symbol in the presence of a + // definition. + return; + case UNDEF * 16 + DYN_COMMON: case WEAK_UNDEF * 16 + DYN_COMMON: case DYN_UNDEF * 16 + DYN_COMMON: case DYN_WEAK_UNDEF * 16 + DYN_COMMON: + // A dynamic common symbol is a definition of sorts. + to->override(sym, object); + return; + case COMMON * 16 + DYN_COMMON: case WEAK_COMMON * 16 + DYN_COMMON: case DYN_COMMON * 16 + DYN_COMMON: case DYN_WEAK_COMMON * 16 + DYN_COMMON: + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; case DEF * 16 + DYN_WEAK_COMMON: case WEAK_DEF * 16 + DYN_WEAK_COMMON: case DYN_DEF * 16 + DYN_WEAK_COMMON: case DYN_WEAK_DEF * 16 + DYN_WEAK_COMMON: + // A common symbol is ignored in the face of a definition. + return; + case UNDEF * 16 + DYN_WEAK_COMMON: case WEAK_UNDEF * 16 + DYN_WEAK_COMMON: case DYN_UNDEF * 16 + DYN_WEAK_COMMON: case DYN_WEAK_UNDEF * 16 + DYN_WEAK_COMMON: + // I guess a weak common symbol is better than a definition. + to->override(sym, object); + return; + case COMMON * 16 + DYN_WEAK_COMMON: case WEAK_COMMON * 16 + DYN_WEAK_COMMON: case DYN_COMMON * 16 + DYN_WEAK_COMMON: case DYN_WEAK_COMMON * 16 + DYN_WEAK_COMMON: - abort(); - break; + // Set the size to the maximum. + if (sym.get_st_size() > to->symsize()) + to->set_symsize(sym.get_st_size()); + return; default: abort(); diff --git a/gold/symtab.cc b/gold/symtab.cc index 748218d..0f43faa 100644 --- a/gold/symtab.cc +++ b/gold/symtab.cc @@ -17,28 +17,85 @@ namespace gold // Class Symbol. -// Initialize the fields in the base class Symbol. +// Initialize fields in Symbol. This initializes everything except u_ +// and source_. -template<int size, bool big_endian> void -Symbol::init_base(const char* name, const char* version, Object* object, - const elfcpp::Sym<size, big_endian>& sym) +Symbol::init_fields(const char* name, const char* version, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) { this->name_ = name; this->version_ = version; - this->object_ = object; - this->shnum_ = sym.get_st_shndx(); // FIXME: Handle SHN_XINDEX. - this->type_ = sym.get_st_type(); - this->binding_ = sym.get_st_bind(); - this->visibility_ = sym.get_st_visibility(); - this->other_ = sym.get_st_nonvis(); - this->is_special_ = false; + this->got_offset_ = 0; + this->type_ = type; + this->binding_ = binding; + this->visibility_ = visibility; + this->nonvis_ = nonvis; + this->is_target_special_ = false; this->is_def_ = false; this->is_forwarder_ = false; + this->in_dyn_ = false; + this->has_got_offset_ = false; +} + +// Initialize the fields in the base class Symbol for SYM in OBJECT. + +template<int size, bool big_endian> +void +Symbol::init_base(const char* name, const char* version, Object* object, + const elfcpp::Sym<size, big_endian>& sym) +{ + this->init_fields(name, version, sym.get_st_type(), sym.get_st_bind(), + sym.get_st_visibility(), sym.get_st_nonvis()); + this->u_.from_object.object = object; + // FIXME: Handle SHN_XINDEX. + this->u_.from_object.shnum = sym.get_st_shndx(); + this->source_ = FROM_OBJECT; this->in_dyn_ = object->is_dynamic(); } -// Initialize the fields in Sized_symbol. +// Initialize the fields in the base class Symbol for a symbol defined +// in an Output_data. + +void +Symbol::init_base(const char* name, Output_data* od, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis, bool offset_is_from_end) +{ + this->init_fields(name, NULL, type, binding, visibility, nonvis); + this->u_.in_output_data.output_data = od; + this->u_.in_output_data.offset_is_from_end = offset_is_from_end; + this->source_ = IN_OUTPUT_DATA; +} + +// Initialize the fields in the base class Symbol for a symbol defined +// in an Output_segment. + +void +Symbol::init_base(const char* name, Output_segment* os, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis, Segment_offset_base offset_base) +{ + this->init_fields(name, NULL, type, binding, visibility, nonvis); + this->u_.in_output_segment.output_segment = os; + this->u_.in_output_segment.offset_base = offset_base; + this->source_ = IN_OUTPUT_SEGMENT; +} + +// Initialize the fields in the base class Symbol for a symbol defined +// as a constant. + +void +Symbol::init_base(const char* name, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis) +{ + this->init_fields(name, NULL, type, binding, visibility, nonvis); + this->source_ = CONSTANT; +} + +// Initialize the fields in Sized_symbol for SYM in OBJECT. template<int size> template<bool big_endian> @@ -48,13 +105,61 @@ Sized_symbol<size>::init(const char* name, const char* version, Object* object, { this->init_base(name, version, object, sym); this->value_ = sym.get_st_value(); - this->size_ = sym.get_st_size(); + this->symsize_ = sym.get_st_size(); +} + +// Initialize the fields in Sized_symbol for a symbol defined in an +// Output_data. + +template<int size> +void +Sized_symbol<size>::init(const char* name, Output_data* od, + Value_type value, Size_type symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool offset_is_from_end) +{ + this->init_base(name, od, type, binding, visibility, nonvis, + offset_is_from_end); + this->value_ = value; + this->symsize_ = symsize; +} + +// Initialize the fields in Sized_symbol for a symbol defined in an +// Output_segment. + +template<int size> +void +Sized_symbol<size>::init(const char* name, Output_segment* os, + Value_type value, Size_type symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + Segment_offset_base offset_base) +{ + this->init_base(name, os, type, binding, visibility, nonvis, offset_base); + this->value_ = value; + this->symsize_ = symsize; +} + +// Initialize the fields in Sized_symbol for a symbol defined as a +// constant. + +template<int size> +void +Sized_symbol<size>::init(const char* name, Value_type value, Size_type symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis) +{ + this->init_base(name, type, binding, visibility, nonvis); + this->value_ = value; + this->symsize_ = symsize; } // Class Symbol_table. Symbol_table::Symbol_table() - : size_(0), offset_(0), table_(), namepool_(), forwarders_() + : size_(0), saw_undefined_(0), offset_(0), table_(), namepool_(), + forwarders_(), commons_() { } @@ -144,7 +249,7 @@ Symbol_table::resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from esym.put_st_value(from->value()); esym.put_st_size(from->symsize()); esym.put_st_info(from->binding(), from->type()); - esym.put_st_other(from->visibility(), from->other()); + esym.put_st_other(from->visibility(), from->nonvis()); esym.put_st_shndx(from->shnum()); Symbol_table::resolve(to, esym.sym(), from->object()); } @@ -198,12 +303,18 @@ Symbol_table::add_from_object(Sized_object<size, big_endian>* object, // ins.second: true if new entry was inserted, false if not. Sized_symbol<size>* ret; + bool was_undefined; + bool was_common; if (!ins.second) { // We already have an entry for NAME/VERSION. ret = this->get_sized_symbol SELECT_SIZE_NAME (ins.first->second SELECT_SIZE(size)); assert(ret != NULL); + + was_undefined = ret->is_undefined(); + was_common = ret->is_common(); + Symbol_table::resolve(ret, sym, object); if (def) @@ -233,6 +344,10 @@ Symbol_table::add_from_object(Sized_object<size, big_endian>* object, { // This is the first time we have seen NAME/VERSION. assert(ins.first->second == NULL); + + was_undefined = false; + was_common = false; + if (def && !insdef.second) { // We already have an entry for NAME/NULL. Make @@ -279,6 +394,16 @@ Symbol_table::add_from_object(Sized_object<size, big_endian>* object, } } + // Record every time we see a new undefined symbol, to speed up + // archive groups. + if (!was_undefined && ret->is_undefined()) + ++this->saw_undefined_; + + // Keep track of common symbols, to speed up common symbol + // allocation. + if (!was_common && ret->is_common()) + this->commons_.push_back(ret); + return ret; } @@ -369,6 +494,302 @@ Symbol_table::add_from_object( } } +// Create and return a specially defined symbol. If ONLY_IF_REF is +// true, then only create the symbol if there is a reference to it. + +template<int size, bool big_endian> +Sized_symbol<size>* +Symbol_table::define_special_symbol(Target* target, const char* name, + bool only_if_ref) +{ + assert(this->size_ == size); + + Symbol* oldsym; + Sized_symbol<size>* sym; + + if (only_if_ref) + { + oldsym = this->lookup(name, NULL); + if (oldsym == NULL) + return NULL; + sym = NULL; + + // Canonicalize NAME. + name = oldsym->name(); + } + else + { + // Canonicalize NAME. + name = this->namepool_.add(name); + + Symbol* const snull = NULL; + const char* const vnull = NULL; + std::pair<typename Symbol_table_type::iterator, bool> ins = + this->table_.insert(std::make_pair(std::make_pair(name, vnull), + snull)); + + if (!ins.second) + { + // We already have a symbol table entry for NAME. + oldsym = ins.first->second; + assert(oldsym != NULL); + sym = NULL; + } + else + { + // We haven't seen this symbol before. + assert(ins.first->second == NULL); + + if (!target->has_make_symbol()) + sym = new Sized_symbol<size>(); + else + { + assert(target->get_size() == size); + assert(target->is_big_endian() ? big_endian : !big_endian); + typedef Sized_target<size, big_endian> My_target; + My_target* sized_target = static_cast<My_target*>(target); + sym = sized_target->make_symbol(); + if (sym == NULL) + return NULL; + } + + ins.first->second = sym; + oldsym = NULL; + } + } + + if (oldsym != NULL) + { + assert(sym == NULL); + + sym = this->get_sized_symbol SELECT_SIZE_NAME (oldsym + SELECT_SIZE(size)); + assert(sym->source() == Symbol::FROM_OBJECT); + const int old_shnum = sym->shnum(); + if (old_shnum != elfcpp::SHN_UNDEF + && old_shnum != elfcpp::SHN_COMMON + && !sym->object()->is_dynamic()) + { + fprintf(stderr, "%s: linker defined: multiple definition of %s\n", + program_name, name); + // FIXME: Report old location. Record that we have seen an + // error. + return NULL; + } + + // Our new definition is going to override the old reference. + } + + return sym; +} + +// Define a symbol based on an Output_data. + +void +Symbol_table::define_in_output_data(Target* target, const char* name, + Output_data* od, + uint64_t value, uint64_t symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + bool offset_is_from_end, + bool only_if_ref) +{ + assert(target->get_size() == this->size_); + if (this->size_ == 32) + this->do_define_in_output_data<32>(target, name, od, value, symsize, + type, binding, visibility, nonvis, + offset_is_from_end, only_if_ref); + else if (this->size_ == 64) + this->do_define_in_output_data<64>(target, name, od, value, symsize, + type, binding, visibility, nonvis, + offset_is_from_end, only_if_ref); + else + abort(); +} + +// Define a symbol in an Output_data, sized version. + +template<int size> +void +Symbol_table::do_define_in_output_data( + Target* target, + const char* name, + Output_data* od, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword symsize, + elfcpp::STT type, + elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + bool offset_is_from_end, + bool only_if_ref) +{ + Sized_symbol<size>* sym; + + if (target->is_big_endian()) + sym = this->define_special_symbol<size, true>(target, name, only_if_ref); + else + sym = this->define_special_symbol<size, false>(target, name, only_if_ref); + + if (sym == NULL) + return; + + sym->init(name, od, value, symsize, type, binding, visibility, nonvis, + offset_is_from_end); +} + +// Define a symbol based on an Output_segment. + +void +Symbol_table::define_in_output_segment(Target* target, const char* name, + Output_segment* os, + uint64_t value, uint64_t symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + Symbol::Segment_offset_base offset_base, + bool only_if_ref) +{ + assert(target->get_size() == this->size_); + if (this->size_ == 32) + this->do_define_in_output_segment<32>(target, name, os, value, symsize, + type, binding, visibility, nonvis, + offset_base, only_if_ref); + else if (this->size_ == 64) + this->do_define_in_output_segment<64>(target, name, os, value, symsize, + type, binding, visibility, nonvis, + offset_base, only_if_ref); + else + abort(); +} + +// Define a symbol in an Output_segment, sized version. + +template<int size> +void +Symbol_table::do_define_in_output_segment( + Target* target, + const char* name, + Output_segment* os, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword symsize, + elfcpp::STT type, + elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + Symbol::Segment_offset_base offset_base, + bool only_if_ref) +{ + Sized_symbol<size>* sym; + + if (target->is_big_endian()) + sym = this->define_special_symbol<size, true>(target, name, only_if_ref); + else + sym = this->define_special_symbol<size, false>(target, name, only_if_ref); + + if (sym == NULL) + return; + + sym->init(name, os, value, symsize, type, binding, visibility, nonvis, + offset_base); +} + +// Define a special symbol with a constant value. It is a multiple +// definition error if this symbol is already defined. + +void +Symbol_table::define_as_constant(Target* target, const char* name, + uint64_t value, uint64_t symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool only_if_ref) +{ + assert(target->get_size() == this->size_); + if (this->size_ == 32) + this->do_define_as_constant<32>(target, name, value, symsize, + type, binding, visibility, nonvis, + only_if_ref); + else if (this->size_ == 64) + this->do_define_as_constant<64>(target, name, value, symsize, + type, binding, visibility, nonvis, + only_if_ref); + else + abort(); +} + +// Define a symbol as a constant, sized version. + +template<int size> +void +Symbol_table::do_define_as_constant( + Target* target, + const char* name, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword symsize, + elfcpp::STT type, + elfcpp::STB binding, + elfcpp::STV visibility, + unsigned char nonvis, + bool only_if_ref) +{ + Sized_symbol<size>* sym; + + if (target->is_big_endian()) + sym = this->define_special_symbol<size, true>(target, name, only_if_ref); + else + sym = this->define_special_symbol<size, false>(target, name, only_if_ref); + + if (sym == NULL) + return; + + sym->init(name, value, symsize, type, binding, visibility, nonvis); +} + +// Define a set of symbols in output sections. + +void +Symbol_table::define_symbols(const Layout* layout, Target* target, int count, + const Define_symbol_in_section* p) +{ + for (int i = 0; i < count; ++i, ++p) + { + Output_section* os = layout->find_output_section(p->output_section); + if (os != NULL) + this->define_in_output_data(target, p->name, os, p->value, p->size, + p->type, p->binding, p->visibility, + p->nonvis, p->offset_is_from_end, + p->only_if_ref); + else + this->define_as_constant(target, p->name, 0, p->size, p->type, + p->binding, p->visibility, p->nonvis, + p->only_if_ref); + } +} + +// Define a set of symbols in output segments. + +void +Symbol_table::define_symbols(const Layout* layout, Target* target, int count, + const Define_symbol_in_segment* p) +{ + for (int i = 0; i < count; ++i, ++p) + { + Output_segment* os = layout->find_output_segment(p->segment_type, + p->segment_flags_set, + p->segment_flags_clear); + if (os != NULL) + this->define_in_output_segment(target, p->name, os, p->value, p->size, + p->type, p->binding, p->visibility, + p->nonvis, p->offset_base, + p->only_if_ref); + else + this->define_as_constant(target, p->name, 0, p->size, p->type, + p->binding, p->visibility, p->nonvis, + p->only_if_ref); + } +} + // Set the final values for all the symbols. Record the file offset // OFF. Add their names to POOL. Return the new file offset. @@ -383,13 +804,15 @@ Symbol_table::finalize(off_t off, Stringpool* pool) abort(); } -// Set the final value for all the symbols. +// Set the final value for all the symbols. This is called after +// Layout::finalize, so all the output sections have their final +// address. template<int size> off_t Symbol_table::sized_finalize(off_t off, Stringpool* pool) { - off = (off + (size >> 3) - 1) & ~ ((size >> 3) - 1); + off = align_address(off, size >> 3); this->offset_ = off; const int sym_size = elfcpp::Elf_sizes<size>::sym_size; @@ -402,34 +825,91 @@ Symbol_table::sized_finalize(off_t off, Stringpool* pool) // FIXME: Here we need to decide which symbols should go into // the output file. - // FIXME: This is wrong. - if (sym->shnum() >= elfcpp::SHN_LORESERVE) - { - ++p; - continue; - } - - off_t secoff; - Output_section* os = sym->object()->output_section(sym->shnum(), - &secoff); + typename Sized_symbol<size>::Value_type value; - if (os == NULL) - { - // We should be able to erase this symbol from the symbol - // table, but at least with gcc 4.0.2 - // std::unordered_map::erase doesn't appear to return the - // new iterator. - // p = this->table_.erase(p); - ++p; - } - else + switch (sym->source()) { - sym->set_value(sym->value() + os->address() + secoff); - pool->add(sym->name()); - ++p; - ++count; - off += sym_size; + case Symbol::FROM_OBJECT: + { + unsigned int shnum = sym->shnum(); + + // FIXME: We need some target specific support here. + if (shnum >= elfcpp::SHN_LORESERVE + && shnum != elfcpp::SHN_ABS) + { + fprintf(stderr, _("%s: %s: unsupported symbol section 0x%x\n"), + program_name, sym->name(), shnum); + gold_exit(false); + } + + if (shnum == elfcpp::SHN_UNDEF) + value = 0; + else if (shnum == elfcpp::SHN_ABS) + value = sym->value(); + else + { + off_t secoff; + Output_section* os = sym->object()->output_section(shnum, + &secoff); + + if (os == NULL) + { + // We should be able to erase this symbol from the + // symbol table, but at least with gcc 4.0.2 + // std::unordered_map::erase doesn't appear to return + // the new iterator. + // p = this->table_.erase(p); + ++p; + continue; + } + + value = sym->value() + os->address() + secoff; + } + } + break; + + case Symbol::IN_OUTPUT_DATA: + { + Output_data* od = sym->output_data(); + value = sym->value() + od->address(); + if (sym->offset_is_from_end()) + value += od->data_size(); + } + break; + + case Symbol::IN_OUTPUT_SEGMENT: + { + Output_segment* os = sym->output_segment(); + value = sym->value() + os->vaddr(); + switch (sym->offset_base()) + { + case Symbol::SEGMENT_START: + break; + case Symbol::SEGMENT_END: + value += os->memsz(); + break; + case Symbol::SEGMENT_BSS: + value += os->filesz(); + break; + default: + abort(); + } + } + break; + + case Symbol::CONSTANT: + value = sym->value(); + break; + + default: + abort(); } + + sym->set_value(value); + pool->add(sym->name()); + ++count; + off += sym_size; + ++p; } this->output_count_ = count; @@ -481,23 +961,61 @@ Symbol_table::sized_write_globals(const Target*, // FIXME: This repeats sized_finalize(). - // FIXME: This is wrong. - if (sym->shnum() >= elfcpp::SHN_LORESERVE) - continue; - - off_t secoff; - Output_section* os = sym->object()->output_section(sym->shnum(), - &secoff); - if (os == NULL) - continue; + unsigned int shndx; + switch (sym->source()) + { + case Symbol::FROM_OBJECT: + { + unsigned int shnum = sym->shnum(); + + // FIXME: We need some target specific support here. + if (shnum >= elfcpp::SHN_LORESERVE + && shnum != elfcpp::SHN_ABS) + { + fprintf(stderr, _("%s: %s: unsupported symbol section 0x%x\n"), + program_name, sym->name(), sym->shnum()); + gold_exit(false); + } + + if (shnum == elfcpp::SHN_UNDEF || shnum == elfcpp::SHN_ABS) + shndx = shnum; + else + { + off_t secoff; + Output_section* os = sym->object()->output_section(shnum, + &secoff); + if (os == NULL) + continue; + + shndx = os->out_shndx(); + } + } + break; + + case Symbol::IN_OUTPUT_DATA: + shndx = sym->output_data()->out_shndx(); + break; + + case Symbol::IN_OUTPUT_SEGMENT: + shndx = elfcpp::SHN_ABS; + break; + + case Symbol::CONSTANT: + shndx = elfcpp::SHN_ABS; + break; + + default: + abort(); + } elfcpp::Sym_write<size, big_endian> osym(ps); osym.put_st_name(sympool->get_offset(sym->name())); osym.put_st_value(sym->value()); osym.put_st_size(sym->symsize()); osym.put_st_info(elfcpp::elf_st_info(sym->binding(), sym->type())); - osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), sym->other())); - osym.put_st_shndx(os->shndx()); + osym.put_st_other(elfcpp::elf_st_other(sym->visibility(), + sym->nonvis())); + osym.put_st_shndx(shndx); ps += sym_size; } diff --git a/gold/symtab.h b/gold/symtab.h index 2c5fbc9..40a9e57 100644 --- a/gold/symtab.h +++ b/gold/symtab.h @@ -5,6 +5,7 @@ #include <string> #include <utility> +#include <vector> #include <cassert> #include "elfcpp.h" @@ -17,6 +18,8 @@ namespace gold { class Object; +class Output_data; +class Output_segment; class Output_file; class Target; @@ -31,6 +34,37 @@ class Sized_object; class Symbol { public: + // Because we want the class to be small, we don't use any virtual + // functions. But because symbols can be defined in different + // places, we need to classify them. This enum is the different + // sources of symbols we support. + enum Source + { + // Symbol defined in an input file--this is the most common case. + FROM_OBJECT, + // Symbol defined in an Output_data, a special section created by + // the target. + IN_OUTPUT_DATA, + // Symbol defined in an Output_segment, with no associated + // section. + IN_OUTPUT_SEGMENT, + // Symbol value is constant. + CONSTANT + }; + + // When the source is IN_OUTPUT_SEGMENT, we need to describe what + // the offset means. + enum Segment_offset_base + { + // From the start of the segment. + SEGMENT_START, + // From the end of the segment. + SEGMENT_END, + // From the filesz of the segment--i.e., after the loaded bytes + // but before the bytes which are allocated but zeroed. + SEGMENT_BSS + }; + // Return the symbol name. const char* name() const @@ -42,10 +76,64 @@ class Symbol version() const { return this->version_; } + // Return the symbol source. + Source + source() const + { return this->source_; } + // Return the object with which this symbol is associated. Object* object() const - { return this->object_; } + { + assert(this->source_ == FROM_OBJECT); + return this->u_.from_object.object; + } + + // Return the index of the section in the input object file. + unsigned int + shnum() const + { + assert(this->source_ == FROM_OBJECT); + return this->u_.from_object.shnum; + } + + // Return the output data section with which this symbol is + // associated, if the symbol was specially defined with respect to + // an output data section. + Output_data* + output_data() const + { + assert(this->source_ == IN_OUTPUT_DATA); + return this->u_.in_output_data.output_data; + } + + // If this symbol was defined with respect to an output data + // section, return whether the value is an offset from end. + bool + offset_is_from_end() const + { + assert(this->source_ == IN_OUTPUT_DATA); + return this->u_.in_output_data.offset_is_from_end; + } + + // Return the output segment with which this symbol is associated, + // if the symbol was specially defined with respect to an output + // segment. + Output_segment* + output_segment() const + { + assert(this->source_ == IN_OUTPUT_SEGMENT); + return this->u_.in_output_segment.output_segment; + } + + // If this symbol was defined with respect to an output segment, + // return the offset base. + Segment_offset_base + offset_base() const + { + assert(this->source_ == IN_OUTPUT_SEGMENT); + return this->u_.in_output_segment.offset_base; + } // Return the symbol binding. elfcpp::STB @@ -64,13 +152,8 @@ class Symbol // Return the non-visibility part of the st_other field. unsigned char - other() const - { return this->other_; } - - // Return the section index. - unsigned int - shnum() const - { return this->shnum_; } + nonvis() const + { return this->nonvis_; } // Return whether this symbol is a forwarder. This will never be // true of a symbol found in the hash table, but may be true of @@ -94,11 +177,49 @@ class Symbol set_in_dyn() { this->in_dyn_ = true; } - // Return whether this symbol needs an entry in the dynamic symbol - // table. FIXME: Needs to be fleshed out. + // Return whether this symbol has an entry in the GOT section. bool - in_dynsym() const - { return this->in_dyn_; } + has_got_offset() const + { return this->has_got_offset_; } + + // Return the offset into the GOT section of this symbol. + unsigned int + got_offset() const + { + assert(this->has_got_offset()); + return this->got_offset_; + } + + // Set the GOT offset of this symbol. + void + set_got_offset(unsigned int got_offset) + { + this->has_got_offset_ = true; + this->got_offset_ = got_offset; + } + + // Return whether this symbol is resolved locally. This is always + // true when linking statically. It is true for a symbol defined in + // this object when using -Bsymbolic. It is true for a symbol + // marked local in a version file. FIXME: This needs to be + // completed. + bool + is_resolved_locally() const + { return !this->in_dyn_; } + + // Return whether this is an undefined symbol. + bool + is_undefined() const + { + return this->source_ == FROM_OBJECT && this->shnum() == elfcpp::SHN_UNDEF; + } + + // Return whether this is a common symbol. + bool + is_common() const + { + return this->source_ == FROM_OBJECT && this->shnum() == elfcpp::SHN_COMMON; + } protected: // Instances of this class should always be created at a specific @@ -106,12 +227,34 @@ class Symbol Symbol() { } + // Initialize the general fields. + void + init_fields(const char* name, const char* version, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis); + // Initialize fields from an ELF symbol in OBJECT. template<int size, bool big_endian> void init_base(const char *name, const char* version, Object* object, const elfcpp::Sym<size, big_endian>&); + // Initialize fields for an Output_data. + void + init_base(const char* name, Output_data*, elfcpp::STT, elfcpp::STB, + elfcpp::STV, unsigned char nonvis, bool offset_is_from_end); + + // Initialize fields for an Output_segment. + void + init_base(const char* name, Output_segment* os, elfcpp::STT type, + elfcpp::STB binding, elfcpp::STV visibility, + unsigned char nonvis, Segment_offset_base offset_base); + + // Initialize fields for a constant. + void + init_base(const char* name, elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis); + // Override existing symbol. template<int size, bool big_endian> void @@ -126,10 +269,45 @@ class Symbol // Symbol version (expected to point into a Stringpool). This may // be NULL. const char* version_; - // Object in which symbol is defined, or in which it was first seen. - Object* object_; - // Section number in object_ in which symbol is defined. - unsigned int shnum_; + + union + { + // This struct is used if SOURCE_ == FROM_OBJECT. + struct + { + // Object in which symbol is defined, or in which it was first + // seen. + Object* object; + // Section number in object_ in which symbol is defined. + unsigned int shnum; + } from_object; + + // This struct is used if SOURCE_ == IN_OUTPUT_DATA. + struct + { + // Output_data in which symbol is defined. Before + // Layout::finalize the symbol's value is an offset within the + // Output_data. + Output_data* output_data; + // True if the offset is from the end, false if the offset is + // from the beginning. + bool offset_is_from_end; + } in_output_data; + + // This struct is used if SOURCE_ == IN_OUTPUT_SEGMENT. + struct + { + // Output_segment in which the symbol is defined. Before + // Layout::finalize the symbol's value is an offset. + Output_segment* output_segment; + // The base to use for the offset before Layout::finalize. + Segment_offset_base offset_base; + } in_output_segment; + } u_; + + // If this symbol has an entry in the GOT section (has_got_offset_ + // is true), this is the offset. + unsigned int got_offset_; // Symbol type. elfcpp::STT type_ : 4; // Symbol binding. @@ -137,10 +315,12 @@ class Symbol // Symbol visibility. elfcpp::STV visibility_ : 2; // Rest of symbol st_other field. - unsigned int other_ : 6; + unsigned int nonvis_ : 6; + // The type of symbol. + Source source_ : 2; // True if this symbol always requires special target-specific // handling. - bool is_special_ : 1; + bool is_target_special_ : 1; // True if this is the default version of the symbol. bool is_def_ : 1; // True if this symbol really forwards to another symbol. This is @@ -153,6 +333,8 @@ class Symbol bool is_forwarder_ : 1; // True if we've seen this symbol in a dynamic object. bool in_dyn_ : 1; + // True if the symbol has an entry in the GOT section. + bool has_got_offset_ : 1; }; // The parts of a symbol which are size specific. Using a template @@ -174,6 +356,23 @@ class Sized_symbol : public Symbol init(const char *name, const char* version, Object* object, const elfcpp::Sym<size, big_endian>&); + // Initialize fields for an Output_data. + void + init(const char* name, Output_data*, Value_type value, Size_type symsize, + elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis, + bool offset_is_from_end); + + // Initialize fields for an Output_segment. + void + init(const char* name, Output_segment*, Value_type value, Size_type symsize, + elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis, + Segment_offset_base offset_base); + + // Initialize fields for a constant. + void + init(const char* name, Value_type value, Size_type symsize, + elfcpp::STT, elfcpp::STB, elfcpp::STV, unsigned char nonvis); + // Override existing symbol. template<bool big_endian> void @@ -188,7 +387,12 @@ class Sized_symbol : public Symbol // is a template parameter). Size_type symsize() const - { return this->size_; } + { return this->symsize_; } + + // Set the symbol size. This is used when resolving common symbols. + void + set_symsize(Size_type symsize) + { this->symsize_ = symsize; } // Set the symbol value. This is called when we store the final // values of the symbols into the symbol table. @@ -200,10 +404,84 @@ class Sized_symbol : public Symbol Sized_symbol(const Sized_symbol&); Sized_symbol& operator=(const Sized_symbol&); - // Symbol value. + // Symbol value. Before Layout::finalize this is the offset in the + // input section. This is set to the final value during + // Layout::finalize. Value_type value_; // Symbol size. - Size_type size_; + Size_type symsize_; +}; + +// A struct describing a symbol defined by the linker, where the value +// of the symbol is defined based on an output section. This is used +// for symbols defined by the linker, like "_init_array_start". + +struct Define_symbol_in_section +{ + // The symbol name. + const char* name; + // The name of the output section with which this symbol should be + // associated. If there is no output section with that name, the + // symbol will be defined as zero. + const char* output_section; + // The offset of the symbol within the output section. This is an + // offset from the start of the output section, unless start_at_end + // is true, in which case this is an offset from the end of the + // output section. + uint64_t value; + // The size of the symbol. + uint64_t size; + // The symbol type. + elfcpp::STT type; + // The symbol binding. + elfcpp::STB binding; + // The symbol visibility. + elfcpp::STV visibility; + // The rest of the st_other field. + unsigned char nonvis; + // If true, the value field is an offset from the end of the output + // section. + bool offset_is_from_end; + // If true, this symbol is defined only if we see a reference to it. + bool only_if_ref; +}; + +// A struct describing a symbol defined by the linker, where the value +// of the symbol is defined based on a segment. This is used for +// symbols defined by the linker, like "_end". We describe the +// segment with which the symbol should be associated by its +// characteristics. If no segment meets these characteristics, the +// symbol will be defined as zero. If there is more than one segment +// which meets these characteristics, we will use the first one. + +struct Define_symbol_in_segment +{ + // The symbol name. + const char* name; + // The segment type where the symbol should be defined, typically + // PT_LOAD. + elfcpp::PT segment_type; + // Bitmask of segment flags which must be set. + elfcpp::PF segment_flags_set; + // Bitmask of segment flags which must be clear. + elfcpp::PF segment_flags_clear; + // The offset of the symbol within the segment. The offset is + // calculated from the position set by offset_base. + uint64_t value; + // The size of the symbol. + uint64_t size; + // The symbol type. + elfcpp::STT type; + // The symbol binding. + elfcpp::STB binding; + // The symbol visibility. + elfcpp::STV visibility; + // The rest of the st_other field. + unsigned char nonvis; + // The base from which we compute the offset. + Symbol::Segment_offset_base offset_base; + // If true, this symbol is defined only if we see a reference to it. + bool only_if_ref; }; // The main linker symbol table. @@ -226,6 +504,47 @@ class Symbol_table size_t count, const char* sym_names, size_t sym_name_size, Symbol** sympointers); + // Define a special symbol. + template<int size, bool big_endian> + Sized_symbol<size>* + define_special_symbol(Target* target, const char* name, bool only_if_ref); + + // Define a special symbol based on an Output_data. It is a + // multiple definition error if this symbol is already defined. + void + define_in_output_data(Target*, const char* name, Output_data*, + uint64_t value, uint64_t symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool offset_is_from_end, bool only_if_ref); + + // Define a special symbol based on an Output_segment. It is a + // multiple definition error if this symbol is already defined. + void + define_in_output_segment(Target*, const char* name, Output_segment*, + uint64_t value, uint64_t symsize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + Symbol::Segment_offset_base, bool only_if_ref); + + // Define a special symbol with a constant value. It is a multiple + // definition error if this symbol is already defined. + void + define_as_constant(Target*, const char* name, uint64_t value, + uint64_t symsize, elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool only_if_ref); + + // Define a set of symbols in output sections. + void + define_symbols(const Layout*, Target*, int count, + const Define_symbol_in_section*); + + // Define a set of symbols in output segments. + void + define_symbols(const Layout*, Target*, int count, + const Define_symbol_in_segment*); + // Look up a symbol. Symbol* lookup(const char*, const char* version = NULL) const; @@ -248,6 +567,15 @@ class Symbol_table const Sized_symbol<size>* get_sized_symbol(const Symbol* ACCEPT_SIZE) const; + // Return the count of undefined symbols seen. + int + saw_undefined() const + { return this->saw_undefined_; } + + // Allocate the common symbols + void + allocate_commons(const General_options&, Layout*); + // Finalize the symbol table after we have set the final addresses // of all the input sections. This sets the final symbol values and // adds the names to *POOL. It records the file offset OFF, and @@ -291,6 +619,43 @@ class Symbol_table resolve(Sized_symbol<size>* to, const Sized_symbol<size>* from ACCEPT_SIZE_ENDIAN); + // Define a symbol in an Output_data, sized version. + template<int size> + void + do_define_in_output_data(Target*, const char* name, Output_data*, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword ssize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool offset_is_from_end, bool only_if_ref); + + // Define a symbol in an Output_segment, sized version. + template<int size> + void + do_define_in_output_segment( + Target*, const char* name, Output_segment* os, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword ssize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + Symbol::Segment_offset_base offset_base, bool only_if_ref); + + // Define a symbol as a constant, sized version. + template<int size> + void + do_define_as_constant( + Target*, const char* name, + typename elfcpp::Elf_types<size>::Elf_Addr value, + typename elfcpp::Elf_types<size>::Elf_WXword ssize, + elfcpp::STT type, elfcpp::STB binding, + elfcpp::STV visibility, unsigned char nonvis, + bool only_if_ref); + + // Allocate the common symbols, sized version. + template<int size> + void + do_allocate_commons(const General_options&, Layout*); + // Finalize symbols specialized for size. template<int size> off_t @@ -320,9 +685,17 @@ class Symbol_table typedef Unordered_map<Symbol_table_key, Symbol*, Symbol_table_hash, Symbol_table_eq> Symbol_table_type; + // The type of the list of common symbols. + + typedef std::vector<Symbol*> Commons_type; + // The size of the symbols in the symbol table (32 or 64). int size_; + // We increment this every time we see a new undefined symbol, for + // use in archive groups. + int saw_undefined_; + // The file offset within the output symtab section where we should // write the table. off_t offset_; @@ -339,6 +712,13 @@ class Symbol_table // Forwarding symbols. Unordered_map<Symbol*, Symbol*> forwarders_; + + // We don't expect there to be very many common symbols, so we keep + // a list of them. When we find a common symbol we add it to this + // list. It is possible that by the time we process the list the + // symbol is no longer a common symbol. It may also have become a + // forwarder. + Commons_type commons_; }; // We inline get_sized_symbol for efficiency. diff --git a/gold/target-reloc.h b/gold/target-reloc.h index 2d1fe30..ebaa827 100644 --- a/gold/target-reloc.h +++ b/gold/target-reloc.h @@ -36,11 +36,14 @@ struct Reloc_types<elfcpp::SHT_RELA, size, big_endian> // way to avoidmaking a function call for each relocation, and to // avoid repeating the generic code for each target. -template<int size, bool big_endian, int sh_type, typename Scan> +template<int size, bool big_endian, typename Target_type, int sh_type, + typename Scan> inline void scan_relocs( const General_options& options, Symbol_table* symtab, + Layout* layout, + Target_type* target, Sized_object<size, big_endian>* object, const unsigned char* prelocs, size_t reloc_count, @@ -68,6 +71,7 @@ scan_relocs( + r_sym * sym_size); const unsigned int shndx = lsym.get_st_shndx(); if (shndx < elfcpp::SHN_LORESERVE + && shndx != elfcpp::SHN_UNDEF && !object->is_section_included(lsym.get_st_shndx())) { // RELOC is a relocation against a local symbol in a @@ -88,7 +92,8 @@ scan_relocs( continue; } - scan.local(options, object, reloc, r_type, lsym); + scan.local(options, symtab, layout, target, object, reloc, r_type, + lsym); } else { @@ -97,7 +102,8 @@ scan_relocs( if (gsym->is_forwarder()) gsym = symtab->resolve_forwards(gsym); - scan.global(options, object, reloc, r_type, gsym); + scan.global(options, symtab, layout, target, object, reloc, r_type, + gsym); } } } @@ -117,10 +123,12 @@ scan_relocs( // of relocs. VIEW is the section data, VIEW_ADDRESS is its memory // address, and VIEW_SIZE is the size. -template<int size, bool big_endian, int sh_type, typename Relocate> +template<int size, bool big_endian, typename Target_type, int sh_type, + typename Relocate> inline void relocate_section( const Relocate_info<size, big_endian>* relinfo, + Target_type* target, const unsigned char* prelocs, size_t reloc_count, unsigned char* view, @@ -140,13 +148,6 @@ relocate_section( Reltype reloc(prelocs); off_t offset = reloc.get_r_offset(); - if (offset < 0 || offset >= view_size) - { - fprintf(stderr, _("%s: %s: reloc has bad offset %zu\n"), - program_name, relinfo->location(i, offset).c_str(), - static_cast<size_t>(offset)); - gold_exit(false); - } typename elfcpp::Elf_types<size>::Elf_WXword r_info = reloc.get_r_info(); unsigned int r_sym = elfcpp::elf_r_sym<size>(r_info); @@ -169,19 +170,29 @@ relocate_section( sym = static_cast<Sized_symbol<size>*>(gsym); value = sym->value(); + } - if (sym->shnum() == elfcpp::SHN_UNDEF - && sym->binding() != elfcpp::STB_WEAK) - { - fprintf(stderr, _("%s: %s: undefined reference to '%s'\n"), - program_name, relinfo->location(i, offset).c_str(), - sym->name()); - // gold_exit(false); - } + if (!relocate.relocate(relinfo, target, i, reloc, r_type, sym, value, + view + offset, view_address + offset, view_size)) + continue; + + if (offset < 0 || offset >= view_size) + { + fprintf(stderr, _("%s: %s: reloc has bad offset %zu\n"), + program_name, relinfo->location(i, offset).c_str(), + static_cast<size_t>(offset)); + gold_exit(false); } - relocate.relocate(relinfo, i, reloc, r_type, sym, value, view + offset, - view_address + offset, view_size); + if (sym != NULL + && sym->is_undefined() + && sym->binding() != elfcpp::STB_WEAK) + { + fprintf(stderr, _("%s: %s: undefined reference to '%s'\n"), + program_name, relinfo->location(i, offset).c_str(), + sym->name()); + // gold_exit(false); + } } } diff --git a/gold/target-select.cc b/gold/target-select.cc index 28b7527..d15d0e3 100644 --- a/gold/target-select.cc +++ b/gold/target-select.cc @@ -34,7 +34,7 @@ extern Target* select_target(int machine, int size, bool big_endian, int osabi, int abiversion) { - for (const Target_selector* p = target_selectors; p != NULL; p = p->next()) + for (Target_selector* p = target_selectors; p != NULL; p = p->next()) { int pmach = p->machine(); if ((pmach == machine || pmach == elfcpp::EM_NONE) diff --git a/gold/target-select.h b/gold/target-select.h index 0762d58..8ccd75f 100644 --- a/gold/target-select.h +++ b/gold/target-select.h @@ -29,7 +29,7 @@ class Target_selector // If we can handle this target, return a pointer to a target // structure. The size and endianness are known. - virtual Target* recognize(int machine, int osabi, int abiversion) const = 0; + virtual Target* recognize(int machine, int osabi, int abiversion) = 0; // Return the next Target_selector in the linked list. Target_selector* diff --git a/gold/target.h b/gold/target.h index 75f149e..b72998d 100644 --- a/gold/target.h +++ b/gold/target.h @@ -149,6 +149,7 @@ class Sized_target : public Target virtual void scan_relocs(const General_options& options, Symbol_table* symtab, + Layout* layout, Sized_object<size, big_endian>* object, unsigned int sh_type, const unsigned char* prelocs, diff --git a/gold/workqueue.h b/gold/workqueue.h index 5cce2d5..ed7a5b0 100644 --- a/gold/workqueue.h +++ b/gold/workqueue.h @@ -17,12 +17,12 @@ #define GOLD_WORKQUEUE_H #include "gold-threads.h" -#include "options.h" #include "fileread.h" namespace gold { +class General_options; class Task; class Workqueue; @@ -286,6 +286,10 @@ class Task // Run the task. virtual void run(Workqueue*) = 0; + + private: + Task(const Task&); + Task& operator=(const Task&); }; // A simple task which waits for a blocker and then runs a function. |