vndk/tools/header-checker/src/repr/symbol/version_script_parser.cpp - platform/development - Git at Google

 // Copyright (C) 2017 The Android Open Source Project
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 //      http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.

 #include "repr/symbol/version_script_parser.h"

 #include "repr/symbol/exported_symbol_set.h"
 #include "utils/string_utils.h"

 #include <iostream>
 #include <memory>
 #include <optional>
 #include <regex>
 #include <set>
 #include <string>
 #include <vector>


 namespace header_checker {
 namespace repr {


 using ModeTagLevel = std::pair<std::string_view, utils::ApiLevel>;


 static constexpr char DEFAULT_ARCH[] = "arm64";
 static constexpr utils::ApiLevel MIN_MODE_TAG_LEVEL = 0;
 static constexpr utils::ApiLevel MAX_MODE_TAG_LEVEL = 1000000;
 static const std::set<std::string_view> KNOWN_MODE_TAGS{"apex", "llndk",
                                                         "systemapi"};

 inline std::string GetIntroducedArchTag(const std::string &arch) {
   return "introduced-" + arch + "=";
 }


 VersionScriptParser::VersionScriptParser()
     : arch_(DEFAULT_ARCH), introduced_arch_tag_(GetIntroducedArchTag(arch_)),
       api_level_(utils::FUTURE_API_LEVEL), api_level_map_(),
       stream_(nullptr), line_no_(0) {}


 void VersionScriptParser::SetArch(const std::string &arch) {
   arch_ = arch;
   introduced_arch_tag_ = GetIntroducedArchTag(arch);
 }


 void VersionScriptParser::SetApiLevelMap(utils::ApiLevelMap api_level_map) {
   api_level_map_ = std::move(api_level_map);
 }


 static std::optional<ModeTagLevel> ParseModeTag(std::string_view tag,
                                                 utils::ApiLevel default_level) {
   std::vector<std::string_view> split_tag = utils::Split(tag, "=");
   utils::ApiLevel level = default_level;
   if (split_tag.size() == 2) {
     auto level = utils::ParseInt(std::string(split_tag[1]));
     if (level.has_value()) {
       return {{split_tag[0], level.value()}};
     }
   } else if (split_tag.size() == 1) {
     return {{split_tag[0], default_level}};
   }
   return {};
 }


 bool VersionScriptParser::AddModeTag(std::string_view mode_tag) {
   auto parsed_mode_tag = ParseModeTag(mode_tag, MAX_MODE_TAG_LEVEL);
   if (parsed_mode_tag.has_value()) {
     included_mode_tags_[std::string(parsed_mode_tag->first)] =
         parsed_mode_tag->second;
     return true;
   }
   return false;
 }


 VersionScriptParser::ParsedTags VersionScriptParser::ParseSymbolTags(
     const std::string &line, const ParsedTags &initial_value) {
   static const char *const POSSIBLE_ARCHES[] = {
       "arm", "arm64", "x86", "x86_64", "mips", "mips64"};

   ParsedTags result = initial_value;

   std::string_view line_view(line);
   std::string::size_type comment_pos = line_view.find('#');
   if (comment_pos == std::string::npos) {
     return result;
   }

   std::string_view comment_line = line_view.substr(comment_pos + 1);
   std::vector<std::string_view> tags = utils::Split(comment_line, " \t");

   bool has_introduced_arch_tags = false;

   for (auto &&tag : tags) {
     // Check excluded tags.
     if (excluded_symbol_tags_.find(tag) != excluded_symbol_tags_.end()) {
       result.has_excluded_tags_ = true;
     }

     // Check the var tag.
     if (tag == "var") {
       result.has_var_tag_ = true;
       continue;
     }

     // Check arch tags.
     if (tag == arch_) {
       result.has_arch_tags_ = true;
       result.has_current_arch_tag_ = true;
       continue;
     }

     for (auto &&possible_arch : POSSIBLE_ARCHES) {
       if (tag == possible_arch) {
         result.has_arch_tags_ = true;
         break;
       }
     }

     // Check introduced tags.
     if (utils::StartsWith(tag, "introduced=")) {
       std::optional<utils::ApiLevel> intro = api_level_map_.Parse(
           std::string(tag.substr(sizeof("introduced=") - 1)));
       if (!intro) {
         ReportError("Bad introduced tag: " + std::string(tag));
       } else {
         if (!has_introduced_arch_tags) {
           result.has_introduced_tags_ = true;
           result.introduced_ = intro.value();
         }
       }
       continue;
     }

     if (utils::StartsWith(tag, introduced_arch_tag_)) {
       std::optional<utils::ApiLevel> intro = api_level_map_.Parse(
           std::string(tag.substr(introduced_arch_tag_.size())));
       if (!intro) {
         ReportError("Bad introduced tag " + std::string(tag));
       } else {
         has_introduced_arch_tags = true;
         result.has_introduced_tags_ = true;
         result.introduced_ = intro.value();
       }
       continue;
     }

     // Check the future tag.
     if (tag == "future") {
       result.has_future_tag_ = true;
       continue;
     }

     // Check the weak binding tag.
     if (tag == "weak") {
       result.has_weak_tag_ = true;
       continue;
     }

     auto mode_tag = ParseModeTag(tag, MIN_MODE_TAG_LEVEL);
     if (mode_tag.has_value() &&
         (KNOWN_MODE_TAGS.count(mode_tag->first) > 0 ||
          included_mode_tags_.count(mode_tag->first) > 0)) {
       result.mode_tags_[std::string(mode_tag->first)] = mode_tag->second;
     }
   }

   return result;
 }


 bool VersionScriptParser::MatchModeTags(const ParsedTags &tags) {
   if (included_mode_tags_.empty()) {
     // Include all tags if the user does not specify the option.
     return true;
   }
   for (const auto &mode_tag : tags.mode_tags_) {
     auto included_mode_tag = included_mode_tags_.find(mode_tag.first);
     if (included_mode_tag != included_mode_tags_.end() &&
         included_mode_tag->second >= mode_tag.second) {
       return true;
     }
   }
   return false;
 }


 bool VersionScriptParser::MatchIntroducedTags(const ParsedTags &tags) {
   if (tags.has_future_tag_ && api_level_ < utils::FUTURE_API_LEVEL) {
     return false;
   }
   if (tags.has_introduced_tags_ && api_level_ < tags.introduced_) {
     return false;
   }
   return true;
 }


 bool VersionScriptParser::IsSymbolExported(const ParsedTags &tags) {
   if (tags.has_excluded_tags_) {
     return false;
   }

   if (tags.has_arch_tags_ && !tags.has_current_arch_tag_) {
     return false;
   }

   if (tags.mode_tags_.empty()) {
     return MatchIntroducedTags(tags);
   }

   switch (mode_tag_policy_) {
     case MatchTagAndApi:
       return MatchModeTags(tags) && MatchIntroducedTags(tags);
     case MatchTagOnly:
       return MatchModeTags(tags);
   }
   // Unreachable
   return false;
 }


 bool VersionScriptParser::ParseSymbolLine(
     const std::string &line, bool is_in_extern_cpp,
     const ParsedTags &version_block_tags) {
   // The symbol name comes before the ';'.
   std::string::size_type pos = line.find(";");
   if (pos == std::string::npos) {
     ReportError("No semicolon at the end of the symbol line: " + line);
     return false;
   }

   std::string symbol(utils::Trim(line.substr(0, pos)));

   ParsedTags tags = ParseSymbolTags(line, version_block_tags);
   if (!IsSymbolExported(tags)) {
     return true;
   }

   if (is_in_extern_cpp) {
     if (utils::IsGlobPattern(symbol)) {
       exported_symbols_->AddDemangledCppGlobPattern(symbol);
     } else {
       exported_symbols_->AddDemangledCppSymbol(symbol);
     }
     return true;
   }

   if (utils::IsGlobPattern(symbol)) {
     exported_symbols_->AddGlobPattern(symbol);
     return true;
   }

   ElfSymbolIR::ElfSymbolBinding binding =
       tags.has_weak_tag_ ? ElfSymbolIR::ElfSymbolBinding::Weak
                          : ElfSymbolIR::ElfSymbolBinding::Global;

   if (tags.has_var_tag_) {
     exported_symbols_->AddVar(symbol, binding);
   } else {
     exported_symbols_->AddFunction(symbol, binding);
   }
   return true;
 }


 bool VersionScriptParser::ParseVersionBlock(bool ignore_symbols,
                                             const ParsedTags &tags) {
   static const std::regex EXTERN_CPP_PATTERN(R"(extern\s*"[Cc]\+\+"\s*\{)");

   LineScope scope = LineScope::GLOBAL;
   bool is_in_extern_cpp = false;

   while (true) {
     std::string line;
     if (!ReadLine(line)) {
       break;
     }

     if (line.find("}") != std::string::npos) {
       if (is_in_extern_cpp) {
         is_in_extern_cpp = false;
         continue;
       }
       return true;
     }

     // Check extern "c++"
     if (std::regex_match(line, EXTERN_CPP_PATTERN)) {
       is_in_extern_cpp = true;
       continue;
     }

     // Check symbol visibility label
     if (utils::StartsWith(line, "local:")) {
       scope = LineScope::LOCAL;
       continue;
     }
     if (utils::StartsWith(line, "global:")) {
       scope = LineScope::GLOBAL;
       continue;
     }
     if (scope != LineScope::GLOBAL) {
       continue;
     }

     // Parse symbol line
     if (!ignore_symbols) {
       if (!ParseSymbolLine(line, is_in_extern_cpp, tags)) {
         return false;
       }
     }
   }

   ReportError("No matching closing parenthesis");
   return false;
 }


 std::unique_ptr<ExportedSymbolSet> VersionScriptParser::Parse(
     std::istream &stream) {
   // Initialize the parser context
   stream_ = &stream;
   line_no_ = 0;
   exported_symbols_.reset(new ExportedSymbolSet());

   // Parse
   while (true) {
     std::string line;
     if (!ReadLine(line)) {
       break;
     }

     std::string::size_type lparen_pos = line.find("{");
     if (lparen_pos == std::string::npos) {
       ReportError("No version opening parenthesis" + line);
       return nullptr;
     }

     std::string version(utils::Trim(line.substr(0, lparen_pos - 1)));
     bool exclude_symbol_version = utils::HasMatchingGlobPattern(
         excluded_symbol_versions_, version.c_str());

     ParsedTags tags = ParseSymbolTags(line, ParsedTags());
     if (!ParseVersionBlock(exclude_symbol_version, tags)) {
       return nullptr;
     }
   }

   return std::move(exported_symbols_);
 }


 bool VersionScriptParser::ReadLine(std::string &line) {
   while (std::getline(*stream_, line)) {
     ++line_no_;
     line = std::string(utils::Trim(line));
     if (line.empty() || line[0] == '#') {
       continue;
     }
     return true;
   }
   return false;
 }


 VersionScriptParser::ErrorHandler::~ErrorHandler() {}


 }  // namespace repr
 }  // namespace header_checker
	// Copyright (C) 2017 The Android Open Source Project
	//
	// Licensed under the Apache License, Version 2.0 (the "License");
	// you may not use this file except in compliance with the License.
	// You may obtain a copy of the License at
	//
	// http://www.apache.org/licenses/LICENSE-2.0
	//
	// Unless required by applicable law or agreed to in writing, software
	// distributed under the License is distributed on an "AS IS" BASIS,
	// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	// See the License for the specific language governing permissions and
	// limitations under the License.

	#include "repr/symbol/version_script_parser.h"

	#include "repr/symbol/exported_symbol_set.h"
	#include "utils/string_utils.h"

	#include <iostream>
	#include <memory>
	#include <optional>
	#include <regex>
	#include <set>
	#include <string>
	#include <vector>


	namespace header_checker {
	namespace repr {


	using ModeTagLevel = std::pair<std::string_view, utils::ApiLevel>;


	static constexpr char DEFAULT_ARCH[] = "arm64";
	static constexpr utils::ApiLevel MIN_MODE_TAG_LEVEL = 0;
	static constexpr utils::ApiLevel MAX_MODE_TAG_LEVEL = 1000000;
	static const std::set<std::string_view> KNOWN_MODE_TAGS{"apex", "llndk",
	"systemapi"};

	inline std::string GetIntroducedArchTag(const std::string &arch) {
	return "introduced-" + arch + "=";
	}


	VersionScriptParser::VersionScriptParser()
	: arch_(DEFAULT_ARCH), introduced_arch_tag_(GetIntroducedArchTag(arch_)),
	api_level_(utils::FUTURE_API_LEVEL), api_level_map_(),
	stream_(nullptr), line_no_(0) {}


	void VersionScriptParser::SetArch(const std::string &arch) {
	arch_ = arch;
	introduced_arch_tag_ = GetIntroducedArchTag(arch);
	}


	void VersionScriptParser::SetApiLevelMap(utils::ApiLevelMap api_level_map) {
	api_level_map_ = std::move(api_level_map);
	}


	static std::optional<ModeTagLevel> ParseModeTag(std::string_view tag,
	utils::ApiLevel default_level) {
	std::vector<std::string_view> split_tag = utils::Split(tag, "=");
	utils::ApiLevel level = default_level;
	if (split_tag.size() == 2) {
	auto level = utils::ParseInt(std::string(split_tag[1]));
	if (level.has_value()) {
	return {{split_tag[0], level.value()}};
	}
	} else if (split_tag.size() == 1) {
	return {{split_tag[0], default_level}};
	}
	return {};
	}


	bool VersionScriptParser::AddModeTag(std::string_view mode_tag) {
	auto parsed_mode_tag = ParseModeTag(mode_tag, MAX_MODE_TAG_LEVEL);
	if (parsed_mode_tag.has_value()) {
	included_mode_tags_[std::string(parsed_mode_tag->first)] =
	parsed_mode_tag->second;
	return true;
	}
	return false;
	}


	VersionScriptParser::ParsedTags VersionScriptParser::ParseSymbolTags(
	const std::string &line, const ParsedTags &initial_value) {
	static const char *const POSSIBLE_ARCHES[] = {
	"arm", "arm64", "x86", "x86_64", "mips", "mips64"};

	ParsedTags result = initial_value;

	std::string_view line_view(line);
	std::string::size_type comment_pos = line_view.find('#');
	if (comment_pos == std::string::npos) {
	return result;
	}

	std::string_view comment_line = line_view.substr(comment_pos + 1);
	std::vector<std::string_view> tags = utils::Split(comment_line, " \t");

	bool has_introduced_arch_tags = false;

	for (auto &&tag : tags) {
	// Check excluded tags.
	if (excluded_symbol_tags_.find(tag) != excluded_symbol_tags_.end()) {
	result.has_excluded_tags_ = true;
	}

	// Check the var tag.
	if (tag == "var") {
	result.has_var_tag_ = true;
	continue;
	}

	// Check arch tags.
	if (tag == arch_) {
	result.has_arch_tags_ = true;
	result.has_current_arch_tag_ = true;
	continue;
	}

	for (auto &&possible_arch : POSSIBLE_ARCHES) {
	if (tag == possible_arch) {
	result.has_arch_tags_ = true;
	break;
	}
	}

	// Check introduced tags.
	if (utils::StartsWith(tag, "introduced=")) {
	std::optional<utils::ApiLevel> intro = api_level_map_.Parse(
	std::string(tag.substr(sizeof("introduced=") - 1)));
	if (!intro) {
	ReportError("Bad introduced tag: " + std::string(tag));
	} else {
	if (!has_introduced_arch_tags) {
	result.has_introduced_tags_ = true;
	result.introduced_ = intro.value();
	}
	}
	continue;
	}

	if (utils::StartsWith(tag, introduced_arch_tag_)) {
	std::optional<utils::ApiLevel> intro = api_level_map_.Parse(
	std::string(tag.substr(introduced_arch_tag_.size())));
	if (!intro) {
	ReportError("Bad introduced tag " + std::string(tag));
	} else {
	has_introduced_arch_tags = true;
	result.has_introduced_tags_ = true;
	result.introduced_ = intro.value();
	}
	continue;
	}

	// Check the future tag.
	if (tag == "future") {
	result.has_future_tag_ = true;
	continue;
	}

	// Check the weak binding tag.
	if (tag == "weak") {
	result.has_weak_tag_ = true;
	continue;
	}

	auto mode_tag = ParseModeTag(tag, MIN_MODE_TAG_LEVEL);
	if (mode_tag.has_value() &&
	(KNOWN_MODE_TAGS.count(mode_tag->first) > 0 \|\|
	included_mode_tags_.count(mode_tag->first) > 0)) {
	result.mode_tags_[std::string(mode_tag->first)] = mode_tag->second;
	}
	}

	return result;
	}


	bool VersionScriptParser::MatchModeTags(const ParsedTags &tags) {
	if (included_mode_tags_.empty()) {
	// Include all tags if the user does not specify the option.
	return true;
	}
	for (const auto &mode_tag : tags.mode_tags_) {
	auto included_mode_tag = included_mode_tags_.find(mode_tag.first);
	if (included_mode_tag != included_mode_tags_.end() &&
	included_mode_tag->second >= mode_tag.second) {
	return true;
	}
	}
	return false;
	}


	bool VersionScriptParser::MatchIntroducedTags(const ParsedTags &tags) {
	if (tags.has_future_tag_ && api_level_ < utils::FUTURE_API_LEVEL) {
	return false;
	}
	if (tags.has_introduced_tags_ && api_level_ < tags.introduced_) {
	return false;
	}
	return true;
	}


	bool VersionScriptParser::IsSymbolExported(const ParsedTags &tags) {
	if (tags.has_excluded_tags_) {
	return false;
	}

	if (tags.has_arch_tags_ && !tags.has_current_arch_tag_) {
	return false;
	}

	if (tags.mode_tags_.empty()) {
	return MatchIntroducedTags(tags);
	}

	switch (mode_tag_policy_) {
	case MatchTagAndApi:
	return MatchModeTags(tags) && MatchIntroducedTags(tags);
	case MatchTagOnly:
	return MatchModeTags(tags);
	}
	// Unreachable
	return false;
	}


	bool VersionScriptParser::ParseSymbolLine(
	const std::string &line, bool is_in_extern_cpp,
	const ParsedTags &version_block_tags) {
	// The symbol name comes before the ';'.
	std::string::size_type pos = line.find(";");
	if (pos == std::string::npos) {
	ReportError("No semicolon at the end of the symbol line: " + line);
	return false;
	}

	std::string symbol(utils::Trim(line.substr(0, pos)));

	ParsedTags tags = ParseSymbolTags(line, version_block_tags);
	if (!IsSymbolExported(tags)) {
	return true;
	}

	if (is_in_extern_cpp) {
	if (utils::IsGlobPattern(symbol)) {
	exported_symbols_->AddDemangledCppGlobPattern(symbol);
	} else {
	exported_symbols_->AddDemangledCppSymbol(symbol);
	}
	return true;
	}

	if (utils::IsGlobPattern(symbol)) {
	exported_symbols_->AddGlobPattern(symbol);
	return true;
	}

	ElfSymbolIR::ElfSymbolBinding binding =
	tags.has_weak_tag_ ? ElfSymbolIR::ElfSymbolBinding::Weak
	: ElfSymbolIR::ElfSymbolBinding::Global;

	if (tags.has_var_tag_) {
	exported_symbols_->AddVar(symbol, binding);
	} else {
	exported_symbols_->AddFunction(symbol, binding);
	}
	return true;
	}


	bool VersionScriptParser::ParseVersionBlock(bool ignore_symbols,
	const ParsedTags &tags) {
	static const std::regex EXTERN_CPP_PATTERN(R"(extern\s"[Cc]\+\+"\s\{)");

	LineScope scope = LineScope::GLOBAL;
	bool is_in_extern_cpp = false;

	while (true) {
	std::string line;
	if (!ReadLine(line)) {
	break;
	}

	if (line.find("}") != std::string::npos) {
	if (is_in_extern_cpp) {
	is_in_extern_cpp = false;
	continue;
	}
	return true;
	}

	// Check extern "c++"
	if (std::regex_match(line, EXTERN_CPP_PATTERN)) {
	is_in_extern_cpp = true;
	continue;
	}

	// Check symbol visibility label
	if (utils::StartsWith(line, "local:")) {
	scope = LineScope::LOCAL;
	continue;
	}
	if (utils::StartsWith(line, "global:")) {
	scope = LineScope::GLOBAL;
	continue;
	}
	if (scope != LineScope::GLOBAL) {
	continue;
	}

	// Parse symbol line
	if (!ignore_symbols) {
	if (!ParseSymbolLine(line, is_in_extern_cpp, tags)) {
	return false;
	}
	}
	}

	ReportError("No matching closing parenthesis");
	return false;
	}


	std::unique_ptr<ExportedSymbolSet> VersionScriptParser::Parse(
	std::istream &stream) {
	// Initialize the parser context
	stream_ = &stream;
	line_no_ = 0;
	exported_symbols_.reset(new ExportedSymbolSet());

	// Parse
	while (true) {
	std::string line;
	if (!ReadLine(line)) {
	break;
	}

	std::string::size_type lparen_pos = line.find("{");
	if (lparen_pos == std::string::npos) {
	ReportError("No version opening parenthesis" + line);
	return nullptr;
	}

	std::string version(utils::Trim(line.substr(0, lparen_pos - 1)));
	bool exclude_symbol_version = utils::HasMatchingGlobPattern(
	excluded_symbol_versions_, version.c_str());

	ParsedTags tags = ParseSymbolTags(line, ParsedTags());
	if (!ParseVersionBlock(exclude_symbol_version, tags)) {
	return nullptr;
	}
	}

	return std::move(exported_symbols_);
	}


	bool VersionScriptParser::ReadLine(std::string &line) {
	while (std::getline(*stream_, line)) {
	++line_no_;
	line = std::string(utils::Trim(line));
	if (line.empty() \|\| line[0] == '#') {
	continue;
	}
	return true;
	}
	return false;
	}


	VersionScriptParser::ErrorHandler::~ErrorHandler() {}


	} // namespace repr
	} // namespace header_checker