* 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.

gold/script.h

@@ -55,6 +55,8 @@ class Workqueue;
 struct Version_dependency_list;
 struct Version_expression_list;
 struct Version_tree;
+struct Version_expression;
+class Lazy_demangler;
 
 // This class represents an expression in a linker script.
 
@@ -160,16 +162,21 @@ class Version_script_info
   { return this->version_trees_.empty(); }
 
   // If there is a version associated with SYMBOL, return true, and
-  // set *VERSION to the version.  Otherwise, return false.
+  // set *VERSION to the version, and *IS_GLOBAL to whether the symbol
+  // should be global.  Otherwise, return false.
   bool
-  get_symbol_version(const char* symbol, std::string* version) const
-  { return this->get_symbol_version_helper(symbol, true, version); }
+  get_symbol_version(const char* symbol, std::string* version,
+		     bool* is_global) const;
 
   // Return whether this symbol matches the local: section of some
   // version.
   bool
   symbol_is_local(const char* symbol) const
-  { return this->get_symbol_version_helper(symbol, false, NULL); }
+  {
+    bool is_global;
+    return (this->get_symbol_version(symbol, NULL, &is_global)
+	    && !is_global);
+  }
 
   // Return the names of versions defined in the version script.
   std::vector<std::string>
@@ -214,43 +221,72 @@ class Version_script_info
 			    bool check_global,
 			    std::string* pversion) const;
 
-  void
-  matched_symbol(const Version_tree*, const char*) const;
+  // Fast lookup information for a given language.
+
+  // We map from exact match strings to Version_tree's.  Historically
+  // version scripts sometimes have the same symbol multiple times,
+  // which is ambiguous.  We warn about that case by storing the
+  // second Version_tree we see.
+  struct Version_tree_match
+  {
+    Version_tree_match(const Version_tree* r, bool ig,
+		       const Version_expression* e)
+      : real(r), is_global(ig), expression(e), ambiguous(NULL)
+    { }
+
+    // The Version_tree that we return.
+    const Version_tree* real;
+    // True if this is a global match for the REAL member, false if it
+    // is a local match.
+    bool is_global;
+    // Point back to the Version_expression for which we created this
+    // match.
+    const Version_expression* expression;
+    // If not NULL, another Version_tree that defines the symbol.
+    const Version_tree* ambiguous;
+  };
+
+  // Map from an exact match string to a Version_tree.
+
+  typedef Unordered_map<std::string, Version_tree_match> Exact;
 
   // Fast lookup information for a glob pattern.
   struct Glob
   {
     Glob()
-      : pattern(NULL), version(NULL)
+      : expression(NULL), version(NULL), is_global(false)
     { }
 
-    Glob(const char* p, const Version_tree* v)
-      : pattern(p), version(v)
+    Glob(const Version_expression* e, const Version_tree* v, bool ig)
+      : expression(e), version(v), is_global(ig)
     { }
 
-    // A pointer to the glob pattern.  The pattern itself lives in a
-    // Version_expression structure.
-    const char* pattern;
+    // A pointer to the version expression holding the pattern to
+    // match and the language to use for demangling the symbol before
+    // doing the match.
+    const Version_expression* expression;
     // The Version_tree we use if this pattern matches.
     const Version_tree* version;
+    // True if this is a global symbol.
+    bool is_global;
   };
 
-  // Fast lookup information for a given language.
+  typedef std::vector<Glob> Globs;
 
-  typedef Unordered_map<std::string, const Version_tree*> Exact;
+  bool
+  unquote(std::string*) const;
 
-  struct Lookup
-  {
-    // A hash table of all exact match strings mapping to a
-    // Version_tree.
-    Exact exact;
-    // A vector of glob patterns mapping to Version_trees.
-    std::vector<Glob> globs;
-  };
+  void
+  add_exact_match(const std::string&, const Version_tree*, bool is_global,
+		  const Version_expression*, Exact*);
 
   void
   build_expression_list_lookup(const Version_expression_list*,
-			       const Version_tree*, Lookup**);
+			       const Version_tree*, bool);
+
+  const char*
+  get_name_to_match(const char*, int,
+		    Lazy_demangler*, Lazy_demangler*) const;
 
   // All the version dependencies we allocate.
   std::vector<Version_dependency_list*> dependency_lists_;
@@ -258,10 +294,15 @@ class Version_script_info
   std::vector<Version_expression_list*> expression_lists_;
   // The list of versions.
   std::vector<Version_tree*> version_trees_;
-  // Lookup information for global symbols, by language.
-  Lookup* globals_[LANGUAGE_COUNT];
-  // Lookup information for local symbols, by language.
-  Lookup* locals_[LANGUAGE_COUNT];
+  // Exact matches for global symbols, by language.
+  Exact* exact_[LANGUAGE_COUNT];
+  // A vector of glob patterns mapping to Version_trees.
+  Globs globs_;
+  // The default version to use, if there is one.  This is from a
+  // pattern of "*".
+  const Version_tree* default_version_;
+  // True if the default version is global.
+  bool default_is_global_;
   // Whether this has been finalized.
   bool is_finalized_;
 };