diff options
| -rw-r--r-- | gold/ChangeLog | 65 | ||||
| -rw-r--r-- | gold/archive.cc | 221 | ||||
| -rw-r--r-- | gold/archive.h | 235 | ||||
| -rw-r--r-- | gold/dynobj.cc | 26 | ||||
| -rw-r--r-- | gold/dynobj.h | 5 | ||||
| -rw-r--r-- | gold/incremental.cc | 49 | ||||
| -rw-r--r-- | gold/incremental.h | 9 | ||||
| -rw-r--r-- | gold/object.cc | 25 | ||||
| -rw-r--r-- | gold/object.h | 16 | ||||
| -rw-r--r-- | gold/plugin.cc | 16 | ||||
| -rw-r--r-- | gold/plugin.h | 5 |
11 files changed, 461 insertions, 211 deletions
diff --git a/gold/ChangeLog b/gold/ChangeLog index f44f97b..5319a63 100644 --- a/gold/ChangeLog +++ b/gold/ChangeLog @@ -1,3 +1,68 @@ +2011-03-29 Cary Coutant <ccoutant@google.com> + + * archive.cc (Library_base::should_include_member): Move + method here from class Archive. + (Archive::Archive): Initialize base class. + (Archive::should_include_member): Move to base class. + (Archive::do_for_all_unused_symbols): New function. + (Add_archive_symbols::run): Remove redundant access to + incremental_inputs. + (Lib_group::Lib_group): Initialize base class. + (Lib_group::do_filename): New function. + (Lib_group::include_member): Pass pointer to Lib_group to + report_object. + (Lib_group::do_for_all_unused_symbols): New function. + (Add_lib_group_symbols::run): Report archive information for + incremental links. + * archive.h (class Library_base): New base class. + (class Archive): Derive from Library_base. + (Archive::filename): Move to base class. + (Archive::set_incremental_info): Likewise. + (Archive::incremental_info): Likewise. + (Archive::Should_include): Likewise. + (Archive::should_include_member): Likewise. + (Archive::Armap_entry): Remove. + (Archive::Unused_symbol_iterator): Remove. + (Archive::unused_symbols_begin): Remove. + (Archive::unused_symbols_end): Remove. + (Archive::do_filename): New function. + (Archive::do_get_mtime): New function. + (Archive::do_for_all_unused_symbols): New function. + (Archive::task_): Move to base class. + (Archive::incremental_info_): Likewise. + (class Lib_group): Derive from Library_base. + (Lib_group::do_filename): New function. + (Lib_group::do_get_mtime): New function. + (Lib_group::do_for_all_unused_symbols): New function. + (Lib_group::task_): Move to base class. + * dynobj.cc (Sized_dynobj::do_for_all_global_symbols): New + function. + * dynobj.h (Sized_dynobj::do_for_all_global_symbols): New + function. + * incremental.cc (Incremental_inputs::report_archive_begin): + Use Library_base; call library's get_mtime; add incremental inputs + entry before members. + (class Unused_symbol_visitor): New class. + (Incremental_inputs::report_archive_end): Use Library_base; use + visitor class to record unused symbols; don't add incremental inputs + entry after members. + (Incremental_inputs::report_object): Use Library_base. + * incremental.h + (Incremental_archive_entry::Incremental_archive_entry): Remove + unused Archive parameter. + (Incremental_inputs::report_archive_begin): Use Library_base. + (Incremental_inputs::report_archive_end): Likewise. + (Incremental_inputs::report_object): Likewise. + * object.cc (Sized_relobj::do_for_all_global_symbols): New + function. + * object.h (Object::for_all_global_symbols): New function. + (Object::do_for_all_global_symbols): New function. + (Sized_relobj::do_for_all_global_symbols): New function. + * plugin.cc (Sized_pluginobj::do_for_all_global_symbols): New + function. + * plugin.h (Sized_pluginobj::do_for_all_global_symbols): New + function. + 2011-03-27 Ian Lance Taylor <iant@google.com> * archive.cc (Archive::interpret_header): Return -1 if something diff --git a/gold/archive.cc b/gold/archive.cc index b965709..4aafb71 100644 --- a/gold/archive.cc +++ b/gold/archive.cc @@ -44,6 +44,90 @@ namespace gold { +// Library_base methods. + +// Determine whether a definition of SYM_NAME should cause an archive +// library member to be included in the link. Returns SHOULD_INCLUDE_YES +// if the symbol is referenced but not defined, SHOULD_INCLUDE_NO if the +// symbol is already defined, and SHOULD_INCLUDE_UNKNOWN if the symbol is +// neither referenced nor defined. + +Library_base::Should_include +Library_base::should_include_member(Symbol_table* symtab, Layout* layout, + const char* sym_name, Symbol** symp, + std::string* why, char** tmpbufp, + size_t* tmpbuflen) +{ + // In an object file, and therefore in an archive map, an + // '@' in the name separates the symbol name from the + // version name. If there are two '@' characters, this is + // the default version. + char* tmpbuf = *tmpbufp; + const char* ver = strchr(sym_name, '@'); + bool def = false; + if (ver != NULL) + { + size_t symlen = ver - sym_name; + if (symlen + 1 > *tmpbuflen) + { + tmpbuf = static_cast<char*>(xrealloc(tmpbuf, symlen + 1)); + *tmpbufp = tmpbuf; + *tmpbuflen = symlen + 1; + } + memcpy(tmpbuf, sym_name, symlen); + tmpbuf[symlen] = '\0'; + sym_name = tmpbuf; + + ++ver; + if (*ver == '@') + { + ++ver; + def = true; + } + } + + Symbol* sym = symtab->lookup(sym_name, ver); + if (def + && ver != NULL + && (sym == NULL + || !sym->is_undefined() + || sym->binding() == elfcpp::STB_WEAK)) + sym = symtab->lookup(sym_name, NULL); + + *symp = sym; + + if (sym == NULL) + { + // Check whether the symbol was named in a -u option. + if (parameters->options().is_undefined(sym_name)) + { + *why = "-u "; + *why += sym_name; + } + else if (layout->script_options()->is_referenced(sym_name)) + { + size_t alc = 100 + strlen(sym_name); + char* buf = new char[alc]; + snprintf(buf, alc, _("script or expression reference to %s"), + sym_name); + *why = buf; + delete[] buf; + } + else + return Library_base::SHOULD_INCLUDE_UNKNOWN; + } + else if (!sym->is_undefined()) + return Library_base::SHOULD_INCLUDE_NO; + // PR 12001: Do not include an archive when the undefined + // symbol has actually been defined on the command line. + else if (layout->script_options()->is_pending_assignment(sym_name)) + return Library_base::SHOULD_INCLUDE_NO; + else if (sym->binding() == elfcpp::STB_WEAK) + return Library_base::SHOULD_INCLUDE_UNKNOWN; + + return Library_base::SHOULD_INCLUDE_YES; +} + // The header of an entry in the archive. This is all readable text, // padded with spaces where necessary. If the contents of an archive // are all text file, the entire archive is readable. @@ -87,11 +171,10 @@ const char Archive::arfmag[2] = { '`', '\n' }; Archive::Archive(const std::string& name, Input_file* input_file, bool is_thin_archive, Dirsearch* dirpath, Task* task) - : name_(name), input_file_(input_file), armap_(), armap_names_(), - extended_names_(), armap_checked_(), seen_offsets_(), members_(), - is_thin_archive_(is_thin_archive), included_member_(false), - nested_archives_(), dirpath_(dirpath), task_(task), num_members_(0), - incremental_info_(NULL) + : Library_base(task), name_(name), input_file_(input_file), armap_(), + armap_names_(), extended_names_(), armap_checked_(), seen_offsets_(), + members_(), is_thin_archive_(is_thin_archive), included_member_(false), + nested_archives_(), dirpath_(dirpath), num_members_(0) { this->no_export_ = parameters->options().check_excluded_libs(input_file->found_name()); @@ -619,82 +702,6 @@ Archive::read_symbols(off_t off) this->members_[off] = member; } -Archive::Should_include -Archive::should_include_member(Symbol_table* symtab, Layout* layout, - const char* sym_name, Symbol** symp, - std::string* why, char** tmpbufp, - size_t* tmpbuflen) -{ - // In an object file, and therefore in an archive map, an - // '@' in the name separates the symbol name from the - // version name. If there are two '@' characters, this is - // the default version. - char* tmpbuf = *tmpbufp; - const char* ver = strchr(sym_name, '@'); - bool def = false; - if (ver != NULL) - { - size_t symlen = ver - sym_name; - if (symlen + 1 > *tmpbuflen) - { - tmpbuf = static_cast<char*>(xrealloc(tmpbuf, symlen + 1)); - *tmpbufp = tmpbuf; - *tmpbuflen = symlen + 1; - } - memcpy(tmpbuf, sym_name, symlen); - tmpbuf[symlen] = '\0'; - sym_name = tmpbuf; - - ++ver; - if (*ver == '@') - { - ++ver; - def = true; - } - } - - Symbol* sym = symtab->lookup(sym_name, ver); - if (def - && ver != NULL - && (sym == NULL - || !sym->is_undefined() - || sym->binding() == elfcpp::STB_WEAK)) - sym = symtab->lookup(sym_name, NULL); - - *symp = sym; - - if (sym == NULL) - { - // Check whether the symbol was named in a -u option. - if (parameters->options().is_undefined(sym_name)) - { - *why = "-u "; - *why += sym_name; - } - else if (layout->script_options()->is_referenced(sym_name)) - { - size_t alc = 100 + strlen(sym_name); - char* buf = new char[alc]; - snprintf(buf, alc, _("script or expression reference to %s"), - sym_name); - *why = buf; - delete[] buf; - } - else - return Archive::SHOULD_INCLUDE_UNKNOWN; - } - else if (!sym->is_undefined()) - return Archive::SHOULD_INCLUDE_NO; - // PR 12001: Do not include an archive when the undefined - // symbol has actually been defined on the command line. - else if (layout->script_options()->is_pending_assignment(sym_name)) - return Archive::SHOULD_INCLUDE_NO; - else if (sym->binding() == elfcpp::STB_WEAK) - return Archive::SHOULD_INCLUDE_UNKNOWN; - - return Archive::SHOULD_INCLUDE_YES; -} - // Select members from the archive and add them to the link. We walk // through the elements in the archive map, and look each one up in // the symbol table. If it exists as a strong undefined symbol, we @@ -971,6 +978,21 @@ Archive::include_member(Symbol_table* symtab, Layout* layout, return true; } +// Iterate over all unused symbols, and call the visitor class V for each. + +void +Archive::do_for_all_unused_symbols(Symbol_visitor_base* v) const +{ + for (std::vector<Armap_entry>::const_iterator p = this->armap_.begin(); + p != this->armap_.end(); + ++p) + { + if (this->seen_offsets_.find(p->file_offset) + == this->seen_offsets_.end()) + v->visit(this->armap_names_.data() + p->name_offset); + } +} + // Print statistical information to stderr. This is used for --stats. void @@ -1047,7 +1069,6 @@ Add_archive_symbols::run(Workqueue* workqueue) else { // For an incremental link, finish recording the layout information. - Incremental_inputs* incremental_inputs = this->layout_->incremental_inputs(); if (incremental_inputs != NULL) incremental_inputs->report_archive_end(this->archive_); @@ -1073,11 +1094,18 @@ unsigned int Lib_group::total_members; unsigned int Lib_group::total_members_loaded; Lib_group::Lib_group(const Input_file_lib* lib, Task* task) - : lib_(lib), task_(task), members_() + : Library_base(task), lib_(lib), members_() { this->members_.resize(lib->size()); } +const std::string& +Lib_group::do_filename() const +{ + std::string *filename = new std::string("<group>"); + return *filename; +} + // Select members from the lib group and add them to the link. We walk // through the members, and check if each one up should be included. // If the object says it should be included, we do so. We have to do @@ -1167,9 +1195,8 @@ Lib_group::include_member(Symbol_table* symtab, Layout* layout, obj->lock(this->task_); if (input_objects->add_object(obj)) { - // FIXME: Record incremental link info for --start-lib/--end-lib. if (layout->incremental_inputs() != NULL) - layout->incremental_inputs()->report_object(obj, NULL); + layout->incremental_inputs()->report_object(obj, this); obj->layout(symtab, layout, sd); obj->add_symbols(symtab, sd, layout); } @@ -1178,6 +1205,22 @@ Lib_group::include_member(Symbol_table* symtab, Layout* layout, obj->unlock(this->task_); } +// Iterate over all unused symbols, and call the visitor class V for each. + +void +Lib_group::do_for_all_unused_symbols(Symbol_visitor_base* v) const +{ + // Files are removed from the members list when used, so all the + // files remaining on the list are unused. + for (std::vector<Archive_member>::const_iterator p = this->members_.begin(); + p != this->members_.end(); + ++p) + { + Object* obj = p->obj_; + obj->for_all_global_symbols(p->sd_, v); + } +} + // Print statistical information to stderr. This is used for --stats. void @@ -1210,9 +1253,15 @@ Add_lib_group_symbols::locks(Task_locker* tl) void Add_lib_group_symbols::run(Workqueue*) { + // For an incremental link, begin recording layout information. + Incremental_inputs* incremental_inputs = this->layout_->incremental_inputs(); + if (incremental_inputs != NULL) + incremental_inputs->report_archive_begin(this->lib_); + this->lib_->add_symbols(this->symtab_, this->layout_, this->input_objects_); - // FIXME: Record incremental link info for --start_lib/--end_lib. + if (incremental_inputs != NULL) + incremental_inputs->report_archive_end(this->lib_); } Add_lib_group_symbols::~Add_lib_group_symbols() diff --git a/gold/archive.h b/gold/archive.h index c5ba114..e428315 100644 --- a/gold/archive.h +++ b/gold/archive.h @@ -59,10 +59,105 @@ struct Archive_member Read_symbols_data* sd_; }; +// This class serves as a base class for Archive and Lib_group objects. + +class Library_base +{ + public: + Library_base(Task* task) + : task_(task), incremental_info_(NULL) + { } + + virtual + ~Library_base() + { } + + // The file name. + const std::string& + filename() const + { return this->do_filename(); } + + // The modification time of the archive file. + Timespec + get_mtime() + { return this->do_get_mtime(); } + + // When we see a symbol in an archive we might decide to include the member, + // not include the member or be undecided. This enum represents these + // possibilities. + + enum Should_include + { + SHOULD_INCLUDE_NO, + SHOULD_INCLUDE_YES, + SHOULD_INCLUDE_UNKNOWN + }; + + static Should_include + should_include_member(Symbol_table* symtab, Layout*, const char* sym_name, + Symbol** symp, std::string* why, char** tmpbufp, + size_t* tmpbuflen); + + // Store a pointer to the incremental link info for the library. + void + set_incremental_info(Incremental_archive_entry* info) + { this->incremental_info_ = info; } + + // Return the pointer to the incremental link info for the library. + Incremental_archive_entry* + incremental_info() const + { return this->incremental_info_; } + + // Abstract base class for processing unused symbols. + class Symbol_visitor_base + { + public: + Symbol_visitor_base() + { } + + virtual + ~Symbol_visitor_base() + { } + + // This function will be called for each unused global + // symbol in a library, with a pointer to the symbol name. + virtual void + visit(const char* /* name */) = 0; + }; + + // Iterator for unused global symbols in the library. + // Calls v->visit() for each global symbol defined + // in each unused library member, passing a pointer to + // the symbol name. + void + for_all_unused_symbols(Symbol_visitor_base* v) const + { this->do_for_all_unused_symbols(v); } + + protected: + // The task reading this archive. + Task *task_; + + private: + // The file name. + virtual const std::string& + do_filename() const = 0; + + // Return the modification time of the archive file. + virtual Timespec + do_get_mtime() = 0; + + // Iterator for unused global symbols in the library. + virtual void + do_for_all_unused_symbols(Symbol_visitor_base* v) const = 0; + + // The incremental link information for this archive. + Incremental_archive_entry* incremental_info_; +}; + // This class represents an archive--generally a libNAME.a file. // Archives have a symbol table and a list of objects. -class Archive +class Archive : public Library_base { public: Archive(const std::string& name, Input_file* input_file, @@ -90,11 +185,6 @@ class Archive input_file() const { return this->input_file_; } - // The file name. - const std::string& - filename() const - { return this->input_file_->filename(); } - // Set up the archive: read the symbol map. void setup(); @@ -169,99 +259,20 @@ class Archive no_export() { return this->no_export_; } - // Store a pointer to the incremental link info for the archive. - void - set_incremental_info(Incremental_archive_entry* info) - { this->incremental_info_ = info; } - - // Return the pointer to the incremental link info for the archive. - Incremental_archive_entry* - incremental_info() const - { return this->incremental_info_; } - - // When we see a symbol in an archive we might decide to include the member, - // not include the member or be undecided. This enum represents these - // possibilities. - - enum Should_include - { - SHOULD_INCLUDE_NO, - SHOULD_INCLUDE_YES, - SHOULD_INCLUDE_UNKNOWN - }; - - static Should_include - should_include_member(Symbol_table* symtab, Layout*, const char* sym_name, - Symbol** symp, std::string* why, char** tmpbufp, - size_t* tmpbuflen); - - private: - struct Armap_entry; - - public: - // Iterator class for unused global symbols. This iterator is used - // for incremental links. - - class Unused_symbol_iterator - { - public: - Unused_symbol_iterator(Archive* arch, - std::vector<Armap_entry>::const_iterator it) - : arch_(arch), it_(it) - { this->skip_used_symbols(); } - - const char* - operator*() const - { return this->arch_->armap_names_.data() + this->it_->name_offset; } - - Unused_symbol_iterator& - operator++() - { - ++this->it_; - this->skip_used_symbols(); - return *this; - } - - bool - operator==(const Unused_symbol_iterator p) const - { return this->it_ == p.it_; } - - bool - operator!=(const Unused_symbol_iterator p) const - { return this->it_ != p.it_; } - - private: - // Skip over symbols defined by members that have been included. - void - skip_used_symbols() - { - while (this->it_ != this->arch_->armap_.end() - && (this->arch_->seen_offsets_.find(this->it_->file_offset) - != this->arch_->seen_offsets_.end())) - ++it_; - } - - // The underlying archive. - Archive* arch_; - - // The underlying iterator over all entries in the archive map. - std::vector<Armap_entry>::const_iterator it_; - }; - - // Return an iterator referring to the first unused symbol. - Unused_symbol_iterator - unused_symbols_begin() - { return Unused_symbol_iterator(this, this->armap_.begin()); } - - // Return an iterator referring to the end of the unused symbols. - Unused_symbol_iterator - unused_symbols_end() - { return Unused_symbol_iterator(this, this->armap_.end()); } - private: Archive(const Archive&); Archive& operator=(const Archive&); + // The file name. + const std::string& + do_filename() const + { return this->input_file_->filename(); } + + // The modification time of the archive file. + Timespec + do_get_mtime() + { return this->file().get_mtime(); } + struct Archive_header; // Total number of archives seen. @@ -339,6 +350,10 @@ class Archive friend class const_iterator; + // Iterator for unused global symbols in the library. + void + do_for_all_unused_symbols(Symbol_visitor_base* v) const; + // An entry in the archive map of symbols to object files. struct Armap_entry { @@ -384,14 +399,10 @@ class Archive Nested_archive_table nested_archives_; // The directory search path. Dirsearch* dirpath_; - // The task reading this archive. - Task* task_; // Number of members in this archive; unsigned int num_members_; // True if we exclude this library archive from automatic export. bool no_export_; - // The incremental link information for this archive. - Incremental_archive_entry* incremental_info_; }; // This class is used to read an archive and pick out the desired @@ -451,7 +462,7 @@ class Add_archive_symbols : public Task // This class represents the files surrounded by a --start-lib ... --end-lib. -class Lib_group +class Lib_group : public Library_base { public: Lib_group(const Input_file_lib* lib, Task* task); @@ -470,10 +481,6 @@ class Lib_group return &this->members_[i]; } - // Dump statistical information to stderr. - static void - print_stats(); - // Total number of archives seen. static unsigned int total_lib_groups; // Total number of archive members seen. @@ -481,11 +488,27 @@ class Lib_group // Number of archive members loaded. static unsigned int total_members_loaded; + // Dump statistical information to stderr. + static void + print_stats(); + private: + // The file name. + const std::string& + do_filename() const; + + // A Lib_group does not have a modification time, since there is no + // real library file. + Timespec + do_get_mtime() + { return Timespec(0, 0); } + + // Iterator for unused global symbols in the library. + void + do_for_all_unused_symbols(Symbol_visitor_base*) const; + // For reading the files. const Input_file_lib* lib_; - // The task reading this lib group. - Task* task_; // Table of the objects in the group. std::vector<Archive_member> members_; }; diff --git a/gold/dynobj.cc b/gold/dynobj.cc index d2ba8ae..3b2031f 100644 --- a/gold/dynobj.cc +++ b/gold/dynobj.cc @@ -761,6 +761,32 @@ Sized_dynobj<size, big_endian>::do_should_include_member(Symbol_table*, return Archive::SHOULD_INCLUDE_YES; } +// Iterate over global symbols, calling a visitor class V for each. + +template<int size, bool big_endian> +void +Sized_dynobj<size, big_endian>::do_for_all_global_symbols( + Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v) +{ + const char* sym_names = + reinterpret_cast<const char*>(sd->symbol_names->data()); + const unsigned char* syms = + sd->symbols->data() + sd->external_symbols_offset; + const int sym_size = elfcpp::Elf_sizes<size>::sym_size; + size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) + / sym_size); + const unsigned char* p = syms; + + for (size_t i = 0; i < symcount; ++i, p += sym_size) + { + elfcpp::Sym<size, big_endian> sym(p); + if (sym.get_st_shndx() != elfcpp::SHN_UNDEF + && sym.get_st_bind() != elfcpp::STB_LOCAL) + v->visit(sym_names + sym.get_st_name()); + } +} + // Get symbol counts. template<int size, bool big_endian> diff --git a/gold/dynobj.h b/gold/dynobj.h index 8787ada..7f8576d 100644 --- a/gold/dynobj.h +++ b/gold/dynobj.h @@ -181,6 +181,11 @@ class Sized_dynobj : public Dynobj do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, std::string* why); + // Iterate over global symbols, calling a visitor class V for each. + void + do_for_all_global_symbols(Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v); + // Get the size of a section. uint64_t do_section_size(unsigned int shndx) diff --git a/gold/incremental.cc b/gold/incremental.cc index aa9d7d3..f7edf04 100644 --- a/gold/incremental.cc +++ b/gold/incremental.cc @@ -436,38 +436,59 @@ Incremental_inputs::report_command_line(int argc, const char* const* argv) // input objects until report_archive_end is called. void -Incremental_inputs::report_archive_begin(Archive* arch) +Incremental_inputs::report_archive_begin(Library_base* arch) { Stringpool::Key filename_key; - Timespec mtime = arch->file().get_mtime(); + Timespec mtime = arch->get_mtime(); this->strtab_->add(arch->filename().c_str(), false, &filename_key); Incremental_archive_entry* entry = - new Incremental_archive_entry(filename_key, arch, mtime); + new Incremental_archive_entry(filename_key, mtime); arch->set_incremental_info(entry); + this->inputs_.push_back(entry); } +// Visitor class for processing the unused global symbols in a library. +// An instance of this class is passed to the library's +// for_all_unused_symbols() iterator, which will call the visit() +// function for each global symbol defined in each unused library +// member. We add those symbol names to the incremental info for the +// library. + +class Unused_symbol_visitor : public Library_base::Symbol_visitor_base +{ + public: + Unused_symbol_visitor(Incremental_archive_entry* entry, Stringpool* strtab) + : entry_(entry), strtab_(strtab) + { } + + void + visit(const char* sym) + { + Stringpool::Key symbol_key; + this->strtab_->add(sym, true, &symbol_key); + this->entry_->add_unused_global_symbol(symbol_key); + } + + private: + Incremental_archive_entry* entry_; + Stringpool* strtab_; +}; + // Finish recording the input archive file ARCHIVE. This is called by the // Add_archive_symbols task after determining which archive members // to include. void -Incremental_inputs::report_archive_end(Archive* arch) +Incremental_inputs::report_archive_end(Library_base* arch) { Incremental_archive_entry* entry = arch->incremental_info(); gold_assert(entry != NULL); // Collect unused global symbols. - for (Archive::Unused_symbol_iterator p = arch->unused_symbols_begin(); - p != arch->unused_symbols_end(); - ++p) - { - Stringpool::Key symbol_key; - this->strtab_->add(*p, true, &symbol_key); - entry->add_unused_global_symbol(symbol_key); - } - this->inputs_.push_back(entry); + Unused_symbol_visitor v(entry, this->strtab_); + arch->for_all_unused_symbols(&v); } // Record the input object file OBJ. If ARCH is not NULL, attach @@ -475,7 +496,7 @@ Incremental_inputs::report_archive_end(Archive* arch) // Add_symbols task after finding out the type of the file. void -Incremental_inputs::report_object(Object* obj, Archive* arch) +Incremental_inputs::report_object(Object* obj, Library_base* arch) { Stringpool::Key filename_key; Timespec mtime = obj->input_file()->file().get_mtime(); diff --git a/gold/incremental.h b/gold/incremental.h index cc0e839..b55aa71 100644 --- a/gold/incremental.h +++ b/gold/incremental.h @@ -451,8 +451,7 @@ class Incremental_object_entry : public Incremental_input_entry class Incremental_archive_entry : public Incremental_input_entry { public: - Incremental_archive_entry(Stringpool::Key filename_key, Archive*, - Timespec mtime) + Incremental_archive_entry(Stringpool::Key filename_key, Timespec mtime) : Incremental_input_entry(filename_key, mtime), members_(), unused_syms_() { } @@ -531,16 +530,16 @@ class Incremental_inputs // Record the initial info for archive file ARCHIVE. void - report_archive_begin(Archive* arch); + report_archive_begin(Library_base* arch); // Record the final info for archive file ARCHIVE. void - report_archive_end(Archive* arch); + report_archive_end(Library_base* arch); // Record the info for object file OBJ. If ARCH is not NULL, // attach the object file to the archive. void - report_object(Object* obj, Archive* arch); + report_object(Object* obj, Library_base* arch); // Record an input section belonging to object file OBJ. void diff --git a/gold/object.cc b/gold/object.cc index e2c0113..dfe2258 100644 --- a/gold/object.cc +++ b/gold/object.cc @@ -1691,6 +1691,31 @@ Sized_relobj<size, big_endian>::do_should_include_member(Symbol_table* symtab, return Archive::SHOULD_INCLUDE_UNKNOWN; } +// Iterate over global defined symbols, calling a visitor class V for each. + +template<int size, bool big_endian> +void +Sized_relobj<size, big_endian>::do_for_all_global_symbols( + Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v) +{ + const char* sym_names = + reinterpret_cast<const char*>(sd->symbol_names->data()); + const unsigned char* syms = + sd->symbols->data() + sd->external_symbols_offset; + const int sym_size = elfcpp::Elf_sizes<size>::sym_size; + size_t symcount = ((sd->symbols_size - sd->external_symbols_offset) + / sym_size); + const unsigned char* p = syms; + + for (size_t i = 0; i < symcount; ++i, p += sym_size) + { + elfcpp::Sym<size, big_endian> sym(p); + if (sym.get_st_shndx() != elfcpp::SHN_UNDEF) + v->visit(sym_names + sym.get_st_name()); + } +} + // Return whether the local symbol SYMNDX has a PLT offset. template<int size, bool big_endian> diff --git a/gold/object.h b/gold/object.h index 8ee03a7..0b25b42 100644 --- a/gold/object.h +++ b/gold/object.h @@ -422,6 +422,12 @@ class Object Read_symbols_data* sd, std::string* why) { return this->do_should_include_member(symtab, layout, sd, why); } + // Iterate over global symbols, calling a visitor class V for each. + void + for_all_global_symbols(Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v) + { return this->do_for_all_global_symbols(sd, v); } + // Functions and types for the elfcpp::Elf_file interface. This // permit us to use Object as the File template parameter for // elfcpp::Elf_file. @@ -572,6 +578,11 @@ class Object do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, std::string* why) = 0; + // Iterate over global symbols, calling a visitor class V for each. + virtual void + do_for_all_global_symbols(Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v) = 0; + // Return the location of the contents of a section. Implemented by // child class. virtual Location @@ -1810,6 +1821,11 @@ class Sized_relobj : public Relobj do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, std::string* why); + // Iterate over global symbols, calling a visitor class V for each. + void + do_for_all_global_symbols(Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v); + // Read the relocs. void do_read_relocs(Read_relocs_data*); diff --git a/gold/plugin.cc b/gold/plugin.cc index 7e259e0..5701fd7 100644 --- a/gold/plugin.cc +++ b/gold/plugin.cc @@ -985,6 +985,22 @@ Sized_pluginobj<size, big_endian>::do_should_include_member( return Archive::SHOULD_INCLUDE_UNKNOWN; } +// Iterate over global symbols, calling a visitor class V for each. + +template<int size, bool big_endian> +void +Sized_pluginobj<size, big_endian>::do_for_all_global_symbols( + Read_symbols_data*, + Library_base::Symbol_visitor_base* v) +{ + for (int i = 0; i < this->nsyms_; ++i) + { + const struct ld_plugin_symbol& sym = this->syms_[i]; + if (sym.def != LDPK_UNDEF) + v->visit(sym.name); + } +} + // Get the size of a section. Not used for plugin objects. template<int size, bool big_endian> diff --git a/gold/plugin.h b/gold/plugin.h index 87747bf..04be82c 100644 --- a/gold/plugin.h +++ b/gold/plugin.h @@ -449,6 +449,11 @@ class Sized_pluginobj : public Pluginobj do_should_include_member(Symbol_table* symtab, Layout*, Read_symbols_data*, std::string* why); + // Iterate over global symbols, calling a visitor class V for each. + void + do_for_all_global_symbols(Read_symbols_data* sd, + Library_base::Symbol_visitor_base* v); + // Get the size of a section. uint64_t do_section_size(unsigned int shndx); |