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

[deliverable/binutils-gdb.git] / gold / script.h

diff --git a/gold/script.h b/gold/script.h
index 710afd0eea51adddd0c7d6f2c133ead08e784081..f4c3f22620be86b1025f4756d882fb0d550b91d9 100644 (file)
--- a/gold/script.h
+++ b/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_;
 };