* script.cc (class Lazy_demangler): Recreate--revert part of patch

	of 2009-12-30.
	(Version_script_info::Version_script_info): Initialize globs_,
	default_version_, default_is_global_, and exact_.  Don't
	initialize globals_ or locals_.
	(Version_script_info::build_lookup_tables): Build local symbols
	first.
	(Version_script_info::unquote): New function.
	(Version_script_info::add_exact_match): New function.
	(Version_script_info::build_expression_list_lookup): Remove lookup
	parameter.  Add is_global parameter.  Change all callers.  Handle
	wildcard pattern specially.  Unquote pattern.  Call
	add_exact_match.
	(Version_script_info::get_name_to_match): New function.
	(Version_script_info::get_symbol_version): New function.
	(Version_script_info::get_symbol_version_helper): Remove.
	(Version_script_info::check_unmatched_names): Call unquote.
	* script.h (class Version_script_info): Change get_symbol_version
	to be non-inline and add is_global parameter; change all callers.
	Rewrite symbol_is_local.  Update declarations.  Define struct
	Version_tree_match, Exact, Globs.  Don't define struct Lookup.
	Remove globals_ and locals_ members.  Add exact_, globs_,
	default_version_, is_global_.
	(Version_script_info::Glob): Remove pattern, add expression and
	is_global.  Update constructor.  Change all callers.
	* dynobj.cc (Versions::finalize): Mark the version symbol as the
	default version.
	(Versions::symbol_section_contents): If a symbol is undefined, or
	defined in a dynamic object, set the version index to
	VER_NDX_LOCAL.
	* symtab.cc (Symbol_table::add_from_relobj): Don't call
	symbol_is_local.
	(Symbol_table::add_from_pluginobj): Likewise.
	* testsuite/ver_matching_test.sh: blaza1 and blaza go into V2.

1 files changed, 329 insertions, 121 deletions

diff --git a/gold/script.cc b/gold/script.cc
index ce06052..839af3c 100644
--- a/gold/script.cc
+++ b/gold/script.cc
@@ -1839,17 +1839,59 @@ struct Version_tree
   const struct Version_dependency_list* dependencies;
 };
 
+// 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_;
+}
+
 // Class Version_script_info.
 
 Version_script_info::Version_script_info()
-  : dependency_lists_(), expression_lists_(), version_trees_(),
-    is_finalized_(false)
+  : dependency_lists_(), expression_lists_(), version_trees_(), globs_(),
+    default_version_(NULL), default_is_global_(false), is_finalized_(false)
 {
   for (int i = 0; i < LANGUAGE_COUNT; ++i)
-    {
-      this->globals_[i] = NULL;
-      this->locals_[i] = NULL;
-    }
+    this->exact_[i] = NULL;
 }
 
 Version_script_info::~Version_script_info()
@@ -1915,6 +1957,84 @@ Version_script_info::get_dependencies(const char* version) const
   return ret;
 }
 
+// A version script essentially maps a symbol name to a version tag
+// and an indication of whether symbol is global or local within that
+// version tag.  Each symbol maps to at most one version tag.
+// Unfortunately, in practice, version scripts are ambiguous, and list
+// symbols multiple times.  Thus, we have to document the matching
+// process.
+
+// This is a description of what the GNU linker does as of 2010-01-11.
+// It walks through the version tags in the order in which they appear
+// in the version script.  For each tag, it first walks through the
+// global patterns for that tag, then the local patterns.  When
+// looking at a single pattern, it first applies any language specific
+// demangling as specified for the pattern, and then matches the
+// resulting symbol name to the pattern.  If it finds an exact match
+// for a literal pattern (a pattern enclosed in quotes or with no
+// wildcard characters), then that is the match that it uses.  If
+// finds a match with a wildcard pattern, then it saves it and
+// continues searching.  Wildcard patterns that are exactly "*" are
+// saved separately.
+
+// If no exact match with a literal pattern is ever found, then if a
+// wildcard match with a global pattern was found it is used,
+// otherwise if a wildcard match with a local pattern was found it is
+// used.
+
+// This is the result:
+//   * If there is an exact match, then we use the first tag in the
+//     version script where it matches.
+//     + If the exact match in that tag is global, it is used.
+//     + Otherwise the exact match in that tag is local, and is used.
+//   * Otherwise, if there is any match with a global wildcard pattern:
+//     + If there is any match with a wildcard pattern which is not
+//       "*", then we use the tag in which the *last* such pattern
+//       appears.
+//     + Otherwise, we matched "*".  If there is no match with a local
+//       wildcard pattern which is not "*", then we use the *last*
+//       match with a global "*".  Otherwise, continue.
+//   * Otherwise, if there is any match with a local wildcard pattern:
+//     + If there is any match with a wildcard pattern which is not
+//       "*", then we use the tag in which the *last* such pattern
+//       appears.
+//     + Otherwise, we matched "*", and we use the tag in which the
+//       *last* such match occurred.
+
+// There is an additional wrinkle.  When the GNU linker finds a symbol
+// with a version defined in an object file due to a .symver
+// directive, it looks up that symbol name in that version tag.  If it
+// finds it, it matches the symbol name against the patterns for that
+// version.  If there is no match with a global pattern, but there is
+// a match with a local pattern, then the GNU linker marks the symbol
+// as local.
+
+// We want gold to be generally compatible, but we also want gold to
+// be fast.  These are the rules that gold implements:
+//   * If there is an exact match for the mangled name, we use it.
+//     + If there is more than one exact match, we give a warning, and
+//       we use the first tag in the script which matches.
+//     + If a symbol has an exact match as both global and local for
+//       the same version tag, we give an error.
+//   * Otherwise, we look for an extern C++ or an extern Java exact
+//     match.  If we find an exact match, we use it.
+//     + If there is more than one exact match, we give a warning, and
+//       we use the first tag in the script which matches.
+//     + If a symbol has an exact match as both global and local for
+//       the same version tag, we give an error.
+//   * Otherwise, we look through the wildcard patterns, ignoring "*"
+//     patterns.  We look through the version tags in reverse order.
+//     For each version tag, we look through the global patterns and
+//     then the local patterns.  We use the first match we find (i.e.,
+//     the last matching version tag in the file).
+//   * Otherwise, we use the "*" pattern if there is one.  We give an
+//     error if there are multiple "*" patterns.
+
+// At least for now, gold does not look up the version tag for a
+// symbol version found in an object file to see if it should be
+// forced local.  There are other ways to force a symbol to be local,
+// and I don't understand why this one is useful.
+
 // Build a set of fast lookup tables for a version script.
 
 void
@@ -1924,131 +2044,206 @@ Version_script_info::build_lookup_tables()
   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]);
+      this->build_expression_list_lookup(v->local, v, false);
+      this->build_expression_list_lookup(v->global, v, true);
+    }
+}
+
+// If a pattern has backlashes but no unquoted wildcard characters,
+// then we apply backslash unquoting and look for an exact match.
+// Otherwise we treat it as a wildcard pattern.  This function returns
+// true for a wildcard pattern.  Otherwise, it does backslash
+// unquoting on *PATTERN and returns false.  If this returns true,
+// *PATTERN may have been partially unquoted.
+
+bool
+Version_script_info::unquote(std::string* pattern) const
+{
+  bool saw_backslash = false;
+  size_t len = pattern->length();
+  size_t j = 0;
+  for (size_t i = 0; i < len; ++i)
+    {
+      if (saw_backslash)
+	saw_backslash = false;
+      else
+	{
+	  switch ((*pattern)[i])
+	    {
+	    case '?': case '[': case '*':
+	      return true;
+	    case '\\':
+	      saw_backslash = true;
+	      continue;
+	    default:
+	      break;
+	    }
+	}
+
+      if (i != j)
+	(*pattern)[j] = (*pattern)[i];
+      ++j;
+    }
+  return false;
+}
+
+// Add an exact match for MATCH to *PE.  The result of the match is
+// V/IS_GLOBAL.
+
+void
+Version_script_info::add_exact_match(const std::string& match,
+				     const Version_tree* v, bool is_global,
+				     const Version_expression* ve,
+				     Exact *pe)
+{
+  std::pair<Exact::iterator, bool> ins =
+    pe->insert(std::make_pair(match, Version_tree_match(v, is_global, ve)));
+  if (ins.second)
+    {
+      // This is the first time we have seen this match.
+      return;
+    }
+
+  Version_tree_match& vtm(ins.first->second);
+  if (vtm.real->tag != v->tag)
+    {
+      // This is an ambiguous match.  We still return the
+      // first version that we found in the script, but we
+      // record the new version to issue a warning if we
+      // wind up looking up this symbol.
+      if (vtm.ambiguous == NULL)
+	vtm.ambiguous = v;
+    }
+  else if (is_global != vtm.is_global)
+    {
+      // We have a match for both the global and local entries for a
+      // version tag.  That's got to be wrong.
+      gold_error(_("'%s' appears as both a global and a local symbol "
+		   "for version '%s' in script"),
+		 match.c_str(), v->tag.c_str());
     }
 }
 
 // Build fast lookup information for EXPLIST and store it in LOOKUP.
+// All matches go to V, and IS_GLOBAL is true if they are global
+// matches.
 
 void
 Version_script_info::build_expression_list_lookup(
     const Version_expression_list* explist,
     const Version_tree* v,
-    Lookup** lookup)
+    bool is_global)
 {
   if (explist == NULL)
     return;
   size_t size = explist->expressions.size();
-  for (size_t j = 0; j < size; ++j)
+  for (size_t i = 0; i < size; ++i)
     {
-      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
+      const Version_expression& exp(explist->expressions[i]);
+
+      if (exp.pattern.length() == 1 && exp.pattern[0] == '*')
+	{
+	  if (this->default_version_ != NULL
+	      && this->default_version_->tag != v->tag)
+	    gold_error(_("wildcard match appears in both version '%s' "
+			 "and '%s' in script"),
+		       this->default_version_->tag.c_str(), v->tag.c_str());
+	  else if (this->default_version_ != NULL
+		   && this->default_is_global_ != is_global)
+	    gold_error(_("wildcard match appears as both global and local "
+			 "in version '%s' in script"),
+		       v->tag.c_str());
+	  this->default_version_ = v;
+	  this->default_is_global_ = is_global;
+	  continue;
+	}
+
+      std::string pattern = exp.pattern;
+      if (!exp.exact_match)
 	{
-	  std::pair<Exact::iterator, bool> ins =
-	    p->exact.insert(std::make_pair(exp.pattern, v));
-	  if (!ins.second)
+	  if (this->unquote(&pattern))
 	    {
-	      const Version_tree* v1 = ins.first->second;
-	      if (v1 != NULL && v1->tag != v->tag)
-		{
-		  // This is an ambiguous match.  It's OK if it's just
-		  // documenting symbol versions, but not if we look
-		  // up this symbol.
-		  ins.first->second = NULL;
-		}
+	      this->globs_.push_back(Glob(&exp, v, is_global));
+	      continue;
 	    }
 	}
+
+      if (this->exact_[exp.language] == NULL)
+	this->exact_[exp.language] = new Exact();
+      this->add_exact_match(pattern, v, is_global, &exp,
+			    this->exact_[exp.language]);
     }
 }
 
-// Record that we have matched a name found in the version script.
+// Return the name to match given a name, a language code, and two
+// lazy demanglers.
 
-void
-Version_script_info::matched_symbol(const Version_tree* version_tree,
-				    const char* name) const
+const char*
+Version_script_info::get_name_to_match(const char* name,
+				       int language,
+				       Lazy_demangler* cpp_demangler,
+				       Lazy_demangler* java_demangler) const
 {
-  const struct Version_expression_list* global = version_tree->global;
-  for (size_t i = 0; i < global->expressions.size(); ++i)
+  switch (language)
     {
-      const Version_expression& expression(global->expressions[i]);
-      if (expression.pattern == name
-	  && (expression.exact_match
-	      || strpbrk(expression.pattern.c_str(), "?*[") == NULL))
-	{
-	  expression.was_matched_by_symbol = true;
-	  return;
-	}
+    case LANGUAGE_C:
+      return name;
+    case LANGUAGE_CXX:
+      return cpp_demangler->get();
+    case LANGUAGE_JAVA:
+      return java_demangler->get();
+    default:
+      gold_unreachable();
     }
-  gold_unreachable();
 }
 
-// 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,
-// false otherwise.  If the symbol is found, then if PVERSION is not
-// NULL, set *PVERSION to the version.
+// Look up SYMBOL_NAME in the list of versions.  Return true if the
+// symbol is found, false if not.  If the symbol is found, then if
+// PVERSION is not NULL, set *PVERSION to the version tag, and if
+// P_IS_GLOBAL is not NULL, set *P_IS_GLOBAL according to whether the
+// symbol is global or not.
 
 bool
-Version_script_info::get_symbol_version_helper(const char* symbol_name,
-                                               bool check_global,
-					       std::string* pversion) const
+Version_script_info::get_symbol_version(const char* symbol_name,
+					std::string* pversion,
+					bool* p_is_global) 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);
+
   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)
     {
-      const Lookup* lookup = pp[i];
-      if (lookup == NULL)
+      Exact* exact = this->exact_[i];
+      if (exact == NULL)
 	continue;
 
-      const char* name_to_match;
-      char* allocated;
-      switch (i)
+      const char* name_to_match = this->get_name_to_match(symbol_name, i,
+							  &cpp_demangled_name,
+							  &java_demangled_name);
+      if (name_to_match == NULL)
 	{
-	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();
+	  // If the name can not be demangled, the GNU linker goes
+	  // ahead and tries to match it anyhow.  That does not
+	  // make sense to me and I have not implemented it.
+	  continue;
 	}
 
-      Exact::const_iterator pe = lookup->exact.find(name_to_match);
-      if (pe != lookup->exact.end())
+      Exact::const_iterator pe = exact->find(name_to_match);
+      if (pe != exact->end())
 	{
+	  const Version_tree_match& vtm(pe->second);
+	  if (vtm.ambiguous != NULL)
+	    gold_warning(_("using '%s' as version for '%s' which is also "
+			   "named in version '%s' in script"),
+			 vtm.real->tag.c_str(), name_to_match,
+			 vtm.ambiguous->tag.c_str());
+
 	  if (pversion != NULL)
-	    {
-	      if (pe->second != NULL)
-		*pversion = pe->second->tag;
-	      else
-		{
-		  gold_error(_("'%s' has multiple versions in version script"),
-			     name_to_match);
-		  return false;
-		}
-	    }
+	    *pversion = vtm.real->tag;
+	  if (p_is_global != NULL)
+	    *p_is_global = vtm.is_global;
 
 	  // If we are using --no-undefined-version, and this is a
 	  // global symbol, we have to record that we have found this
@@ -2056,33 +2251,46 @@ Version_script_info::get_symbol_version_helper(const char* symbol_name,
 	  // this now, because otherwise we have no way to get from a
 	  // non-C language back to the demangled name that we
 	  // matched.
-	  if (check_global && !parameters->options().undefined_version())
-	    this->matched_symbol(pe->second, name_to_match);
-
-	  if (allocated != NULL)
-	    free (allocated);
+	  if (p_is_global != NULL && vtm.is_global)
+	    vtm.expression->was_matched_by_symbol = true;
 
 	  return true;
 	}
+    }
+
+  // Look through the glob patterns in reverse order.
+
+  for (Globs::const_reverse_iterator p = this->globs_.rbegin();
+       p != this->globs_.rend();
+       ++p)
+    {
+      int language = p->expression->language;
+      const char* name_to_match = this->get_name_to_match(symbol_name,
+							  language,
+							  &cpp_demangled_name,
+							  &java_demangled_name);
+      if (name_to_match == NULL)
+	continue;
 
-      for (std::vector<Glob>::const_iterator pg = lookup->globs.begin();
-	   pg != lookup->globs.end();
-	   ++pg)
+      if (fnmatch(p->expression->pattern.c_str(), name_to_match,
+		  FNM_NOESCAPE) == 0)
 	{
-	  // 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 (pversion != NULL)
+	    *pversion = p->version->tag;
+	  if (p_is_global != NULL)
+	    *p_is_global = p->is_global;
+	  return true;
 	}
+    }
 
-      if (allocated != NULL)
-	free (allocated);
+  // Finally, there may be a wildcard.
+  if (this->default_version_ != NULL)
+    {
+      if (pversion != NULL)
+	*pversion = this->default_version_->tag;
+      if (p_is_global != NULL)
+	*p_is_global = this->default_is_global_;
+      return true;
     }
 
   return false;
@@ -2116,18 +2324,18 @@ Version_script_info::check_unmatched_names(const Symbol_table* symtab) const
 	  if (expression.language != LANGUAGE_C)
 	    continue;
 
-	  // Ignore wildcard patterns.
-	  if (!expression.exact_match
-	      && strpbrk(expression.pattern.c_str(), "?*[") != NULL)
-	    continue;
-
-	  if (symtab->lookup(expression.pattern.c_str(),
-			     vt->tag.c_str()) == NULL)
+	  // Remove backslash quoting, and ignore wildcard patterns.
+	  std::string pattern = expression.pattern;
+	  if (!expression.exact_match)
 	    {
-	      gold_error(_("version script assignment of %s to symbol %s "
-			   "failed: symbol not defined"),
-			 vt->tag.c_str(), expression.pattern.c_str());
+	      if (this->unquote(&pattern))
+		continue;
 	    }
+
+	  if (symtab->lookup(pattern.c_str(), vt->tag.c_str()) == NULL)
+	    gold_error(_("version script assignment of %s to symbol %s "
+			 "failed: symbol not defined"),
+		       vt->tag.c_str(), pattern.c_str());
 	}
     }
 }