+// Version_script_info stores information parsed from the version
+// script, either provided by --version-script or as part of a linker
+// script. A single Version_script_info object per target is owned by
+// Script_options.
+
+class Version_script_info
+{
+ public:
+ // The languages which can be specified in a versionn script.
+ enum Language
+ {
+ LANGUAGE_C, // No demangling.
+ LANGUAGE_CXX, // C++ demangling.
+ LANGUAGE_JAVA, // Java demangling.
+ LANGUAGE_COUNT
+ };
+
+ Version_script_info();
+
+ ~Version_script_info();
+
+ // Clear everything.
+ void
+ clear();
+
+ // Finalize the version control information.
+ void
+ finalize();
+
+ // Return whether the information is finalized.
+ bool
+ is_finalized() const
+ { return this->is_finalized_; }
+
+ // Return whether any version were defined in the version script.
+ bool
+ empty() const
+ { return this->version_trees_.empty(); }
+
+ // If there is a version associated with SYMBOL, return true, and
+ // 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,
+ bool* is_global) const;
+
+ // Return whether this symbol matches the local: section of some
+ // version.
+ bool
+ symbol_is_local(const char* symbol) const
+ {
+ 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>
+ get_versions() const;
+
+ // Return the list of dependencies for this version.
+ std::vector<std::string>
+ get_dependencies(const char* version) const;
+
+ // The following functions should only be used by the bison helper
+ // functions. They allocate new structs whose memory belongs to
+ // Version_script_info. The bison functions copy the information
+ // from the version script into these structs.
+ struct Version_dependency_list*
+ allocate_dependency_list();
+
+ struct Version_expression_list*
+ allocate_expression_list();
+
+ struct Version_tree*
+ allocate_version_tree();
+
+ // 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*);
+
+ bool
+ is_defsym() const
+ { return is_defsym_; }
+
+ Expression *
+ value() const
+ { return val_; }
+
+ // 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;
+
+ private:
+ // Shared by finalize and finalize_with_dot.
+ void
+ finalize_maybe_dot(Symbol_table*, const Layout*, bool is_dot_available,
+ uint64_t dot_value, Output_section* dot_section);
+
+ // Sized version of finalize.
+ template<int size>
+ void
+ sized_finalize(Symbol_table*, const Layout*, bool is_dot_available,
+ uint64_t dot_value, Output_section*);
+
+ // Symbol name.
+ std::string name_;
+ // Expression to assign to symbol.
+ Expression* val_;
+ // True if this symbol is defined by a --defsym, false if it is
+ // defined in a linker script.
+ bool is_defsym_;
+ // Whether the assignment should be provided (only set if there is
+ // an undefined reference to the symbol.
+ bool provide_;
+ // Whether the assignment should be hidden.
+ bool hidden_;
+ // The entry in the symbol table.
+ Symbol* sym_;
+};
+
+// This class manages assertions in linker scripts. These can appear
+// in all the places where a Symbol_assignment can appear.
+
+class Script_assertion
+{
+ public:
+ Script_assertion(Expression* check, const char* message,
+ size_t messagelen)
+ : check_(check), message_(message, messagelen)
+ { }
+
+ // Check the assertion.
+ void
+ check(const Symbol_table*, const Layout*);
+
+ // Print the assertion to the FILE. This is for debugging.
+ void
+ print(FILE*) const;
+
+ private:
+ // The expression to check.
+ Expression* check_;
+ // The message to issue if the expression fails.
+ std::string message_;
+};
+