+ // Build the lookup tables after all data have been read.
+ void
+ build_lookup_tables();
+
+ // Give an error if there are any unmatched names in the version
+ // script.
+ void
+ check_unmatched_names(const Symbol_table*) const;
+
+ // Print contents to the FILE. This is for debugging.
+ void
+ print(FILE*) const;
+
+ private:
+ void
+ print_expression_list(FILE* f, const Version_expression_list*) const;
+
+ bool
+ get_symbol_version_helper(const char* symbol,
+ bool check_global,
+ std::string* pversion) 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()
+ : expression(NULL), version(NULL), is_global(false)
+ { }
+
+ Glob(const Version_expression* e, const Version_tree* v, bool ig)
+ : expression(e), version(v), is_global(ig)
+ { }
+
+ // 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;
+ };
+
+ typedef std::vector<Glob> Globs;
+
+ bool
+ unquote(std::string*) const;
+
+ 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*, 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_;
+ // All the version expressions we allocate.
+ std::vector<Version_expression_list*> expression_lists_;
+ // The list of versions.
+ std::vector<Version_tree*> version_trees_;
+ // 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_;
+};
+
+// This class manages assignments to symbols. These can appear in
+// three different locations in scripts: outside of a SECTIONS clause,
+// within a SECTIONS clause, and within an output section definition
+// within a SECTIONS clause. This can also appear on the command line
+// via the --defsym command line option.
+
+class Symbol_assignment
+{
+ public:
+ Symbol_assignment(const char* name, size_t namelen, bool is_defsym,
+ Expression* val, bool provide, bool hidden)
+ : name_(name, namelen), val_(val), is_defsym_(is_defsym),
+ provide_(provide), hidden_(hidden), sym_(NULL)
+ { }
+
+ // Add the symbol to the symbol table.
+ void
+ add_to_table(Symbol_table*);
+
+ // Finalize the symbol value.
+ void
+ finalize(Symbol_table*, const Layout*);
+
+ // Finalize the symbol value when it can refer to the dot symbol.
+ void
+ finalize_with_dot(Symbol_table*, const Layout*, uint64_t dot_value,
+ Output_section* dot_section);
+
+ // Set the symbol value, but only if the value is absolute or relative to
+ // DOT_SECTION. This is used while processing a SECTIONS clause.
+ // We assume that dot is an absolute value here. We do not check assertions.
+ void
+ set_if_absolute(Symbol_table*, const Layout*, bool is_dot_available,
+ uint64_t dot_value, Output_section* dot_section);
+
+ const std::string&
+ name() const
+ { return this->name_; }
+
+ // Print the assignment to the FILE. This is for debugging.
+ void
+ print(FILE*) const;
+