From 6affe781e430bbf2075faf6539fb020564b3a38f Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 30 Dec 2009 22:35:49 +0000 Subject: PR 10861 * script.h (class Version_script_info): Define Language enum. Update declarations. Define Glob, Exact, and Lookup types. Add new fields globals_, locals_, and is_finalized_. * script.cc: Various formatting fixes. (class Parser_closure): Change language_stack_ from a vector of std::string to one of Version_script_info::Language. Adjust all uses accordingly. (class Lazy_demangler): Remove. (struct Version_expression): Change language from std::string to Version_script_info::Language. (Version_script_info::Version_script_info): New function. (Version_script_info::~Version_script_info): Don't call clear. (Version_script_info::finalize): New function. (Version_script_info::build_lookup_tables): New function. (Version_script_info::build_expression_list_lookup): New function. (Version_script_info::get_symbol_version_helper): Rewrite to use lookup tables. (Version_script_info::print_expression_list): Adjust to use Version_script_info::Language. (script_push_lex_into_version_mode): Check that the version script has not been finalized. (version_script_push_lang): Change language string to Version_script_info::Language. * options.cc (Command_line::version_script): New function. * options.h (class General_options): Add finalize_dynamic_list function. Change version_script from declaration to definition. * testsuite/ver_test_4.script: Remove duplicate def of t2_2. * testsuite/version_script.map: Remove duplicate def of foo. * testsuite/Makefile.am (ver_matching_def.so): Depend upon version_script.map. * testsuite/Makefile.in: Rebuild. --- gold/script.cc | 343 ++++++++++++++++++++++++++++++++++++--------------------- 1 file changed, 220 insertions(+), 123 deletions(-) (limited to 'gold/script.cc') diff --git a/gold/script.cc b/gold/script.cc index fb35fb8..fb1b2e1 100644 --- a/gold/script.cc +++ b/gold/script.cc @@ -1183,8 +1183,8 @@ class Parser_closure lex_(lex), lineno_(0), charpos_(0), lex_mode_stack_(), inputs_(NULL) { // We start out processing C symbols in the default lex mode. - language_stack_.push_back(""); - lex_mode_stack_.push_back(lex->mode()); + this->language_stack_.push_back(Version_script_info::LANGUAGE_C); + this->lex_mode_stack_.push_back(lex->mode()); } // Return the file name. @@ -1314,16 +1314,18 @@ class Parser_closure // Return the current language being processed in a version script // (eg, "C++"). The empty string represents unmangled C names. - const std::string& + Version_script_info::Language get_current_language() const { return this->language_stack_.back(); } // Push a language onto the stack when entering an extern block. - void push_language(const std::string& lang) + void + push_language(Version_script_info::Language lang) { this->language_stack_.push_back(lang); } // Pop a language off of the stack when exiting an extern block. - void pop_language() + void + pop_language() { gold_assert(!this->language_stack_.empty()); this->language_stack_.pop_back(); @@ -1362,7 +1364,7 @@ class Parser_closure std::vector lex_mode_stack_; // A stack of which extern/language block we're inside. Can be C++, // java, or empty for C. - std::vector language_stack_; + std::vector language_stack_; // New input files found to add to the link. Input_arguments* inputs_; }; @@ -1776,90 +1778,49 @@ Keyword_to_parsecode::keyword_to_parsecode(const char* keyword, return ktt->parsecode; } -// Helper class that calls cplus_demangle when needed and takes care of freeing -// the result. - -class Lazy_demangler -{ - public: - Lazy_demangler(const char* symbol, int options) - : symbol_(symbol), options_(options), demangled_(NULL), did_demangle_(false) - { } - - ~Lazy_demangler() - { free(this->demangled_); } - - // Return the demangled name. The actual demangling happens on the first call, - // and the result is later cached. - - inline char* - get(); - - private: - // The symbol to demangle. - const char *symbol_; - // Option flags to pass to cplus_demagle. - const int options_; - // The cached demangled value, or NULL if demangling didn't happen yet or - // failed. - char *demangled_; - // Whether we already called cplus_demangle - bool did_demangle_; -}; - -// Return the demangled name. The actual demangling happens on the first call, -// and the result is later cached. Returns NULL if the symbol cannot be -// demangled. - -inline char* -Lazy_demangler::get() -{ - if (!this->did_demangle_) - { - this->demangled_ = cplus_demangle(this->symbol_, this->options_); - this->did_demangle_ = true; - } - return this->demangled_; -} - // The following structs are used within the VersionInfo class as well // as in the bison helper functions. They store the information // parsed from the version script. // A single version expression. // For example, pattern="std::map*" and language="C++". -// pattern and language should be from the stringpool -struct Version_expression { - Version_expression(const std::string& pattern, - const std::string& language, - bool exact_match) - : pattern(pattern), language(language), exact_match(exact_match) {} +// PATTERN should be from the stringpool. +struct +Version_expression +{ + Version_expression(const std::string& a_pattern, + Version_script_info::Language a_language, + bool a_exact_match) + : pattern(a_pattern), language(a_language), exact_match(a_exact_match) + { } std::string pattern; - std::string language; + Version_script_info::Language language; // If false, we use glob() to match pattern. If true, we use strcmp(). bool exact_match; }; // A list of expressions. -struct Version_expression_list { +struct Version_expression_list +{ std::vector expressions; }; - // A list of which versions upon which another version depends. // Strings should be from the Stringpool. -struct Version_dependency_list { +struct Version_dependency_list +{ std::vector dependencies; }; - // The total definition of a version. It includes the tag for the // version, its global and local expressions, and any dependencies. -struct Version_tree { +struct Version_tree +{ Version_tree() - : tag(), global(NULL), local(NULL), dependencies(NULL) {} + : tag(), global(NULL), local(NULL), dependencies(NULL) + { } std::string tag; const struct Version_expression_list* global; @@ -1867,44 +1828,74 @@ struct Version_tree { const struct Version_dependency_list* dependencies; }; +// Class Version_script_info. + +Version_script_info::Version_script_info() + : dependency_lists_(), expression_lists_(), version_trees_(), + is_finalized_(false) +{ + for (int i = 0; i < LANGUAGE_COUNT; ++i) + { + this->globals_[i] = NULL; + this->locals_[i] = NULL; + } +} + Version_script_info::~Version_script_info() { - this->clear(); } +// Forget all the known version script information. + void Version_script_info::clear() { - for (size_t k = 0; k < dependency_lists_.size(); ++k) - delete dependency_lists_[k]; + for (size_t k = 0; k < this->dependency_lists_.size(); ++k) + delete this->dependency_lists_[k]; this->dependency_lists_.clear(); - for (size_t k = 0; k < version_trees_.size(); ++k) - delete version_trees_[k]; + for (size_t k = 0; k < this->version_trees_.size(); ++k) + delete this->version_trees_[k]; this->version_trees_.clear(); - for (size_t k = 0; k < expression_lists_.size(); ++k) - delete expression_lists_[k]; + for (size_t k = 0; k < this->expression_lists_.size(); ++k) + delete this->expression_lists_[k]; this->expression_lists_.clear(); } +// Finalize the version script information. + +void +Version_script_info::finalize() +{ + if (!this->is_finalized_) + { + this->build_lookup_tables(); + this->is_finalized_ = true; + } +} + +// Return all the versions. + std::vector Version_script_info::get_versions() const { std::vector ret; - for (size_t j = 0; j < version_trees_.size(); ++j) + for (size_t j = 0; j < this->version_trees_.size(); ++j) if (!this->version_trees_[j]->tag.empty()) ret.push_back(this->version_trees_[j]->tag); return ret; } +// Return the dependencies of VERSION. + std::vector Version_script_info::get_dependencies(const char* version) const { std::vector ret; - for (size_t j = 0; j < version_trees_.size(); ++j) - if (version_trees_[j]->tag == version) + for (size_t j = 0; j < this->version_trees_.size(); ++j) + if (this->version_trees_[j]->tag == version) { const struct Version_dependency_list* deps = - version_trees_[j]->dependencies; + this->version_trees_[j]->dependencies; if (deps != NULL) for (size_t k = 0; k < deps->dependencies.size(); ++k) ret.push_back(deps->dependencies[k]); @@ -1913,6 +1904,58 @@ Version_script_info::get_dependencies(const char* version) const return ret; } +// Build a set of fast lookup tables for a version script. + +void +Version_script_info::build_lookup_tables() +{ + size_t size = this->version_trees_.size(); + for (size_t j = 0; j < size; ++j) + { + const Version_tree* v = this->version_trees_[j]; + this->build_expression_list_lookup(v->global, v, &this->globals_[0]); + this->build_expression_list_lookup(v->local, v, &this->locals_[0]); + } +} + +// Build fast lookup information for EXPLIST and store it in LOOKUP. + +void +Version_script_info::build_expression_list_lookup( + const Version_expression_list* explist, + const Version_tree* v, + Lookup** lookup) +{ + if (explist == NULL) + return; + size_t size = explist->expressions.size(); + for (size_t j = 0; j < size; ++j) + { + const Version_expression& exp(explist->expressions[j]); + Lookup **pp = &lookup[exp.language]; + if (*pp == NULL) + *pp = new Lookup(); + Lookup* p = *pp; + + if (!exp.exact_match && strpbrk(exp.pattern.c_str(), "?*[") != NULL) + p->globs.push_back(Glob(exp.pattern.c_str(), v)); + else + { + std::pair ins = + p->exact.insert(std::make_pair(exp.pattern, v)); + if (!ins.second) + { + const Version_tree* v1 = ins.first->second; + if (v1->tag != v->tag) + gold_error(_("'%s' appears in version script with both " + "versions '%s' and '%s'"), + exp.pattern.c_str(), v1->tag.c_str(), + v->tag.c_str()); + } + } + } +} + // Look up SYMBOL_NAME in the list of versions. If CHECK_GLOBAL is // true look at the globally visible symbols, otherwise look at the // symbols listed as "local:". Return true if the symbol is found, @@ -1924,47 +1967,70 @@ Version_script_info::get_symbol_version_helper(const char* symbol_name, bool check_global, std::string* pversion) const { - Lazy_demangler cpp_demangled_name(symbol_name, DMGL_ANSI | DMGL_PARAMS); - Lazy_demangler java_demangled_name(symbol_name, - DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA); - for (size_t j = 0; j < version_trees_.size(); ++j) + gold_assert(this->is_finalized_); + const Lookup* const * pp = (check_global + ? &this->globals_[0] + : &this->locals_[0]); + for (int i = 0; i < LANGUAGE_COUNT; ++i) { - // Is it a global symbol for this version? - const Version_expression_list* explist = - check_global ? version_trees_[j]->global : version_trees_[j]->local; - if (explist != NULL) - for (size_t k = 0; k < explist->expressions.size(); ++k) - { - const char* name_to_match = symbol_name; - const struct Version_expression& exp = explist->expressions[k]; - if (exp.language == "C++") - { - name_to_match = cpp_demangled_name.get(); - // This isn't a C++ symbol. - if (name_to_match == NULL) - continue; - } - else if (exp.language == "Java") - { - name_to_match = java_demangled_name.get(); - // This isn't a Java symbol. - if (name_to_match == NULL) - continue; - } - bool matched; - if (exp.exact_match) - matched = strcmp(exp.pattern.c_str(), name_to_match) == 0; - else - matched = fnmatch(exp.pattern.c_str(), name_to_match, - FNM_NOESCAPE) == 0; - if (matched) - { - if (pversion != NULL) - *pversion = this->version_trees_[j]->tag; - return true; - } - } + const Lookup* lookup = pp[i]; + if (lookup == NULL) + continue; + + const char* name_to_match; + char* allocated; + switch (i) + { + case LANGUAGE_C: + allocated = NULL; + name_to_match = symbol_name; + break; + case LANGUAGE_CXX: + allocated = cplus_demangle(symbol_name, DMGL_ANSI | DMGL_PARAMS); + if (allocated == NULL) + continue; + name_to_match = allocated; + break; + case LANGUAGE_JAVA: + allocated = cplus_demangle(symbol_name, + DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA); + if (allocated == NULL) + continue; + name_to_match = allocated; + default: + gold_unreachable(); + } + + Exact::const_iterator pe = lookup->exact.find(name_to_match); + if (pe != lookup->exact.end()) + { + if (pversion != NULL) + *pversion = pe->second->tag; + if (allocated != NULL) + free (allocated); + return true; + } + + for (std::vector::const_iterator pg = lookup->globs.begin(); + pg != lookup->globs.end(); + ++pg) + { + // Check for * specially since it is fairly common. + if ((pg->pattern[0] == '*' && pg->pattern[1] == '\0') + || fnmatch(pg->pattern, name_to_match, FNM_NOESCAPE) == 0) + { + if (pversion != NULL) + *pversion = pg->version->tag; + if (allocated != NULL) + free (allocated); + return true; + } + } + + if (allocated != NULL) + free (allocated); } + return false; } @@ -2042,21 +2108,33 @@ Version_script_info::print_expression_list( FILE* f, const Version_expression_list* vel) const { - std::string current_language; + Version_script_info::Language current_language = LANGUAGE_C; for (size_t i = 0; i < vel->expressions.size(); ++i) { const Version_expression& ve(vel->expressions[i]); if (ve.language != current_language) { - if (!current_language.empty()) + if (current_language != LANGUAGE_C) fprintf(f, " }\n"); - fprintf(f, " extern \"%s\" {\n", ve.language.c_str()); + switch (ve.language) + { + case LANGUAGE_C: + break; + case LANGUAGE_CXX: + fprintf(f, " extern \"C++\" {\n"); + break; + case LANGUAGE_JAVA: + fprintf(f, " extern \"Java\" {\n"); + break; + default: + gold_unreachable(); + } current_language = ve.language; } fprintf(f, " "); - if (!current_language.empty()) + if (current_language != LANGUAGE_C) fprintf(f, " "); if (ve.exact_match) @@ -2068,7 +2146,7 @@ Version_script_info::print_expression_list( fprintf(f, "\n"); } - if (!current_language.empty()) + if (current_language != LANGUAGE_C) fprintf(f, " }\n"); } @@ -2403,6 +2481,9 @@ extern "C" void script_push_lex_into_version_mode(void* closurev) { Parser_closure* closure = static_cast(closurev); + if (closure->version_script()->is_finalized()) + gold_error(_("%s:%d:%d: invalid use of VERSION in input file"), + closure->filename(), closure->lineno(), closure->charpos()); closure->push_lex_mode(Lex::VERSION_SCRIPT); } @@ -2454,8 +2535,6 @@ script_add_vers_depend(void* closurev, } // Add a pattern expression to an existing list of expressions, if any. -// TODO: In the old linker, the last argument used to be a bool, but I -// don't know what it meant. extern "C" struct Version_expression_list * script_new_vers_pattern(void* closurev, @@ -2507,7 +2586,25 @@ extern "C" void version_script_push_lang(void* closurev, const char* lang, int langlen) { Parser_closure* closure = static_cast(closurev); - closure->push_language(std::string(lang, langlen)); + std::string language(lang, langlen); + Version_script_info::Language code; + if (language.empty() || language == "C") + code = Version_script_info::LANGUAGE_C; + else if (language == "C++") + code = Version_script_info::LANGUAGE_CXX; + else if (language == "Java") + code = Version_script_info::LANGUAGE_JAVA; + else + { + char* buf = new char[langlen + 100]; + snprintf(buf, langlen + 100, + _("unrecognized version script language '%s'"), + language.c_str()); + yyerror(closurev, buf); + delete[] buf; + code = Version_script_info::LANGUAGE_C; + } + closure->push_language(code); } extern "C" void -- cgit v1.1