The-Homebrew-Cloud/cemu-vcpkg
2
0
Fork 0
mirror of https://github.com/cemu-project/vcpkg.git synced 2025-02-24 03:27:12 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add checks for crt linkage (currently disabled)

Browse Source
This commit is contained in:
Alexander Karatarakis 2016-11-09 01:27:49 -08:00
parent a9d732f206
commit 89447c156d
3 changed files with 224 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
toolsrc/include/BuildInfo.h
View File

@ -16,6 +16,42 @@ namespace vcpkg
LinkageType linkage_type_value_of(const std::string& as_string);
std::string to_string(const LinkageType& build_info);
enum class ConfigurationType
{
DEBUG = 1,
RELEASE = 2
};
std::string to_string(const ConfigurationType& conf);
struct BuildType
{
static BuildType value_of(const ConfigurationType& config, const LinkageType& linkage);
static const BuildType DEBUG_STATIC;
static const BuildType DEBUG_DYNAMIC;
static const BuildType RELEASE_STATIC;
static const BuildType RELEASE_DYNAMIC;
const ConfigurationType config;
const LinkageType linkage;
BuildType() = delete;
std::string toString() const;
private:
BuildType(const ConfigurationType& config, const LinkageType& linkage) : config(config), linkage(linkage)
{
}
};
bool operator ==(const BuildType& lhs, const BuildType& rhs);
bool operator !=(const BuildType& lhs, const BuildType& rhs);
struct BuildInfo
{
static BuildInfo create(const std::unordered_map<std::string, std::string>& pgh);

72
toolsrc/src/BuildInfo.cpp
View File

@ -4,6 +4,21 @@
namespace vcpkg
{
std::string BuildType::toString() const
{
return Strings::format("[%s,%s]", to_string(config), to_string(linkage));
}
bool operator==(const BuildType& lhs, const BuildType& rhs)
{
return lhs.config == rhs.config && lhs.linkage == rhs.linkage;
}
bool operator!=(const BuildType& lhs, const BuildType& rhs)
{
return !(lhs == rhs);
}
//
namespace BuildInfoRequiredField
{
@ -20,6 +35,11 @@ namespace vcpkg
return build_info;
}
const BuildType BuildType::DEBUG_STATIC = BuildType(ConfigurationType::DEBUG, LinkageType::STATIC);
const BuildType BuildType::DEBUG_DYNAMIC = BuildType(ConfigurationType::DEBUG, LinkageType::DYNAMIC);
const BuildType BuildType::RELEASE_STATIC = BuildType(ConfigurationType::RELEASE, LinkageType::STATIC);
const BuildType BuildType::RELEASE_DYNAMIC = BuildType(ConfigurationType::RELEASE, LinkageType::DYNAMIC);
LinkageType linkage_type_value_of(const std::string& as_string)
{
@ -36,6 +56,58 @@ namespace vcpkg
return LinkageType::UNKNOWN;
}
std::string to_string(const LinkageType& build_info)
{
switch (build_info)
{
case LinkageType::STATIC:
return "static";
case LinkageType::DYNAMIC:
return "dynamic";
default:
Checks::unreachable();
}
}
std::string to_string(const ConfigurationType& conf)
{
switch (conf)
{
case ConfigurationType::DEBUG:
return "Debug";
case ConfigurationType::RELEASE:
return "Release";
default:
Checks::unreachable();
}
}
BuildType BuildType::value_of(const ConfigurationType& config, const LinkageType& linkage)
{
if (config == ConfigurationType::DEBUG && linkage == LinkageType::STATIC)
{
return DEBUG_STATIC;
}
if (config == ConfigurationType::DEBUG && linkage == LinkageType::DYNAMIC)
{
return DEBUG_DYNAMIC;
}
if (config == ConfigurationType::RELEASE && linkage == LinkageType::STATIC)
{
return RELEASE_STATIC;
}
if (config == ConfigurationType::RELEASE && linkage == LinkageType::DYNAMIC)
{
return RELEASE_DYNAMIC;
}
Checks::unreachable();
}
BuildInfo read_build_info(const fs::path& filepath)
{
const std::vector<std::unordered_map<std::string, std::string>> pghs = Paragraphs::get_paragraphs(filepath);

116
toolsrc/src/post_build_lint.cpp
View File

@ -6,6 +6,7 @@
#include "vcpkg_System.h"
#include "coff_file_reader.h"
#include "BuildInfo.h"
#include <regex>
namespace fs = std::tr2::sys;
@ -488,6 +489,116 @@ namespace vcpkg
return lint_status::SUCCESS;
}
struct BuildInfo_and_files
{
explicit BuildInfo_and_files(const BuildType& build_type) : build_type(build_type)
{
}
BuildType build_type;
std::vector<fs::path> files;
};
static lint_status check_crt_linkage_of_libs(const BuildType& expected_build_type, const std::vector<fs::path>& libs)
{
static const std::regex DEBUG_STATIC_CRT(R"(/DEFAULTLIB:LIBCMTD)");
static const std::regex DEBUG_DYNAMIC_CRT(R"(/DEFAULTLIB:MSVCRTD)");
static const std::regex RELEASE_STATIC_CRT(R"(/DEFAULTLIB:LIBCMT[^D])");
static const std::regex RELEASE_DYNAMIC_CRT(R"(/DEFAULTLIB:MSVCRT[^D])");
lint_status output_status = lint_status::SUCCESS;
std::vector<fs::path> libs_with_no_crts;
std::vector<fs::path> libs_with_multiple_crts;
BuildInfo_and_files libs_with_debug_static_crt(BuildType::DEBUG_STATIC);
BuildInfo_and_files libs_with_debug_dynamic_crt(BuildType::DEBUG_DYNAMIC);
BuildInfo_and_files libs_with_release_static_crt(BuildType::RELEASE_STATIC);
BuildInfo_and_files libs_with_release_dynamic_crt(BuildType::RELEASE_DYNAMIC);
for (const fs::path& lib : libs)
{
const std::wstring cmd_line = Strings::wformat(LR"("%s" /directives "%s")", DUMPBIN_EXE.native(), lib.native());
System::exit_code_and_output ec_data = System::cmd_execute_and_capture_output(cmd_line);
Checks::check_exit(ec_data.exit_code == 0, "Running command:\n %s\n failed", Strings::utf16_to_utf8(cmd_line));
bool found_debug_static_crt = std::regex_search(ec_data.output.cbegin(), ec_data.output.cend(), DEBUG_STATIC_CRT);
bool found_debug_dynamic_crt = std::regex_search(ec_data.output.cbegin(), ec_data.output.cend(), DEBUG_DYNAMIC_CRT);
bool found_release_static_crt = std::regex_search(ec_data.output.cbegin(), ec_data.output.cend(), RELEASE_STATIC_CRT);
bool found_release_dynamic_crt = std::regex_search(ec_data.output.cbegin(), ec_data.output.cend(), RELEASE_DYNAMIC_CRT);
const size_t crts_found_count = found_debug_static_crt + found_debug_dynamic_crt + found_release_static_crt + found_release_dynamic_crt;
if (crts_found_count == 0)
{
libs_with_no_crts.push_back(lib);
continue;
}
if (crts_found_count > 1)
{
libs_with_multiple_crts.push_back(lib);
continue;
}
// now we have exactly 1 crt
if (found_debug_static_crt)
{
libs_with_debug_static_crt.files.push_back(lib);
continue;
}
if (found_debug_dynamic_crt)
{
libs_with_debug_dynamic_crt.files.push_back(lib);
continue;
}
if (found_release_static_crt)
{
libs_with_release_static_crt.files.push_back(lib);
continue;
}
libs_with_release_dynamic_crt.files.push_back(lib);
}
if (!libs_with_no_crts.empty())
{
System::println(System::color::warning, "Could not detect the crt linkage in the following libs:");
print_vector_of_files(libs_with_no_crts);
output_status = lint_status::ERROR_DETECTED;
}
if (!libs_with_multiple_crts.empty())
{
System::println(System::color::warning, "Detected multiple crt linkages for the following libs:");
print_vector_of_files(libs_with_multiple_crts);
output_status = lint_status::ERROR_DETECTED;
}
std::vector<BuildInfo_and_files> group_for_iteration = {
libs_with_debug_static_crt, libs_with_debug_dynamic_crt,
libs_with_release_static_crt, libs_with_release_dynamic_crt};
for (const BuildInfo_and_files& bif : group_for_iteration)
{
if (!bif.files.empty() && bif.build_type != expected_build_type)
{
System::println(System::color::warning, "Expected %s crt linkage, but the following libs had %s crt linkage:", expected_build_type.toString(), bif.build_type.toString());
print_vector_of_files(bif.files);
output_status = lint_status::ERROR_DETECTED;
}
}
if (output_status == lint_status::ERROR_DETECTED)
{
System::println(System::color::warning, "To inspect the lib files, use:\n dumpbin.exe /directives mylibfile.lib");
}
return output_status;
}
static void operator +=(size_t& left, const lint_status& right)
{
left += static_cast<size_t>(right);
@ -546,6 +657,11 @@ namespace vcpkg
error_count += check_no_dlls_present(dlls);
error_count += check_bin_folders_are_not_present_in_static_build(spec, paths);
#if 0
error_count += check_crt_linkage_of_libs(BuildType::value_of(ConfigurationType::DEBUG, linkage_type_value_of(build_info.crt_linkage)), debug_libs);
error_count += check_crt_linkage_of_libs(BuildType::value_of(ConfigurationType::RELEASE, linkage_type_value_of(build_info.crt_linkage)), release_libs);
#endif
break;
}
case LinkageType::UNKNOWN: