shishantbiswas/c3c
1
1
Fork 0
mirror of https://github.com/c3lang/c3c.git synced 2026-02-27 03:51:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Smarter windows library path detection (#339)

Browse Source 
add support for visual studio 2022 preview, switch to using smarter windows library path detection
This commit is contained in:
Theo
2021-11-30 00:44:51 -08:00
committed by GitHub
parent 3242bcabc0
commit 74fa81336f
4 changed files with 553 additions and 104 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@@ -175,7 +175,6 @@ target_include_directories(c3c_wrappers PRIVATE
message(STATUS "Found LLD ${lld_libs}")
if(UNIX)
message(STATUS "adding unix link params")
target_link_libraries(c3c_wrappers ${llvm_libs} ${lld_libs})
target_link_libraries(c3c m ${llvm_libs} c3c_wrappers ${lld_libs})
# target_link_libraries(c3c m ${llvm_libs} c3c_wrappers ${TB_LIB} ${lld_libs})
@@ -184,8 +183,8 @@ else()
set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -LIBPATH:C:\\llvm\\llvm\\build\\Release\\lib") # needed for lldCommon.lib
#set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -LIBPATH:${LLVM_LIBPATH}") # This doesn't seem to work for some reason
message(STATUS "${LLVM_LIBPATH}")
target_link_libraries(c3c debug ${llvm_libs} c3c_wrappers lldCommon lldCore lldCOFF lldWASM lldMinGW lldELF lldDriver lldReaderWriter lldMachO lldYAML)
target_link_libraries(c3c optimized ${llvm_libs} c3c_wrappers lldCommon lldCore lldCOFF lldWASM lldMinGW lldELF lldDriver lldReaderWriter lldMachO lldYAML)
target_link_libraries(c3c debug ${llvm_libs} c3c_wrappers lldCommon lldCore lldCOFF lldWASM lldMinGW lldELF lldDriver lldReaderWriter lldMachO lldYAML Advapi32)
target_link_libraries(c3c optimized ${llvm_libs} c3c_wrappers lldCommon lldCore lldCOFF lldWASM lldMinGW lldELF lldDriver lldReaderWriter lldMachO lldYAML Advapi32)
endif()
if (WIN32)

18
src/compiler/linker.c
View File

@@ -86,6 +86,8 @@ static bool link_exe(const char *output_file, const char **files_to_link, unsign
vec_add(args, active_target.link_args[i]);
}
const char *error = NULL;
// This isn't used in most cases, but its contents should get freed after linking.
WindowsLinkPathsUTF8 windows_paths = {0};
switch (platform_target.os)
{
@@ -105,12 +107,10 @@ static bool link_exe(const char *output_file, const char **files_to_link, unsign
// C:\\Program Files (x86)\\Windows Kits\\10\\Lib\\10.0.19041.0\\ucrt\\x64
// C:\\Program Files (x86)\\Windows Kits\\10\\Lib\\10.0.19041.0\\um\\x64
#ifdef _MSC_VER
PathPair msvc_paths = get_latest_available_vs_path();
PathPair windows_kit_paths = find_winkit_path();
vec_add(args, join_strings((const char* []) { "-libpath:C:", msvc_paths.first }, 2));
vec_add(args, join_strings((const char* []) { "-libpath:C:", msvc_paths.second }, 2));
vec_add(args, join_strings((const char* []) { "-libpath:C:", windows_kit_paths.first }, 2));
vec_add(args, join_strings((const char* []) { "-libpath:C:", windows_kit_paths.second }, 2));
windows_paths = get_windows_link_paths();
vec_add(args, join_strings((const char* []) { "-libpath:", windows_paths.windows_sdk_um_library_path }, 2));
vec_add(args, join_strings((const char* []) { "-libpath:", windows_paths.windows_sdk_ucrt_library_path }, 2));
vec_add(args, join_strings((const char* []) { "-libpath:", windows_paths.vs_library_path }, 2));
vec_add(args, "-defaultlib:libcmt");
vec_add(args, "-nologo");
@@ -217,6 +217,12 @@ static bool link_exe(const char *output_file, const char **files_to_link, unsign
{
case OBJ_FORMAT_COFF:
success = (platform_target.x64.is_mingw64 ? llvm_link_mingw : llvm_link_coff)(args, (int)vec_size(args), &error);
// This is only defined if compiling with MSVC
#ifdef _MSC_VER
if (windows_paths.windows_sdk_um_library_path) {
free_windows_link_paths(&windows_paths);
}
#endif
break;
case OBJ_FORMAT_ELF:
success = llvm_link_elf(args, (int)vec_size(args), &error);

623
src/utils/find_msvc.c
View File

@@ -1,110 +1,553 @@
#include "utils/common.h"
#ifdef _MSC_VER
#include "utils/find_msvc.h"
#include "find_msvc.h"
#include <windows.h>
#include <string.h>
#include <stdio.h>
#include <stdint.h>
#include <stdbool.h>
#include <io.h> // For _get_osfhandle
#include "utils/dirent.h"
#define MSVC_BASE_PATH "/Program Files (x86)/Microsoft Visual Studio/"
#define MSVC_22_BASE_PATH "/Program Files/Microsoft Visual Studio/"
#define WINKIT_BASE_PATH "/Program Files (x86)/Windows Kits/"
int is_numeric(const struct dirent *ent)
typedef struct
{
return atoi(ent->d_name); // don't use this function if you expect a file named "0" ?
int windows_sdk_version; // Zero if no Windows SDK found.
wchar_t* windows_sdk_root;
wchar_t* windows_sdk_um_library_path;
wchar_t* windows_sdk_ucrt_library_path;
int is_vs_2017;
wchar_t* vs_exe_path;
wchar_t* vs_library_path;
} Find_Result;
Find_Result find_visual_studio_and_windows_sdk();
void free_resources(Find_Result* result);
WindowsLinkPathsUTF8 get_windows_link_paths() {
Find_Result paths = find_visual_studio_and_windows_sdk();
WindowsLinkPathsUTF8 out = { 0 };
// note: WideCharToMultiByte doesn't seem to do null termination.
// I'm wary of manually adding a null terminator, so hopefully this is reliable.
// This wouldn't be a problem if windows used UTF-8 like the rest of the world >:(
out.windows_sdk_um_library_path = (char*)calloc(MAX_PATH, 1);
out.windows_sdk_ucrt_library_path = (char*)calloc(MAX_PATH, 1);
out.vs_library_path = (char*)calloc(MAX_PATH, 1);
int um_len = wcslen(paths.windows_sdk_um_library_path);
WideCharToMultiByte(
CP_UTF8, // UTF-8
0, // config flags- I don't think we need these
paths.windows_sdk_um_library_path,// in
um_len, // in len
out.windows_sdk_um_library_path, // out
MAX_PATH, // out len
NULL,
NULL
);
int ucrt_len = wcslen(paths.windows_sdk_ucrt_library_path);
WideCharToMultiByte(
CP_UTF8,
0,
paths.windows_sdk_ucrt_library_path,
ucrt_len,
out.windows_sdk_ucrt_library_path,
MAX_PATH,
NULL,
NULL
);
int vsl_len = wcslen(paths.vs_library_path);
WideCharToMultiByte(
CP_UTF8,
0,
paths.vs_library_path,
vsl_len,
out.vs_library_path,
MAX_PATH,
NULL,
NULL
);
free_resources(&paths);
return out;
}
char *get_highest_ver(char *directory, int (*filter)(const struct dirent *))
{
struct dirent **files;
int num_files = scandir(directory, &files, filter, versionsort);
if (num_files < 0)
{
return NULL;
}
char *path_ret = (char *)malloc(260);
if (path_ret == NULL)
error_exit("ERROR - malloc failed in get_highest_ver\n"); // visual studio doesn't like not checking this
strcpy_s(path_ret, 260, files[num_files - 1]->d_name);
for (int i = 0; i < num_files; i++) free(files[i]);
free(files);
return path_ret;
void free_windows_link_paths(WindowsLinkPathsUTF8* obj) {
free(obj->vs_library_path);
free(obj->windows_sdk_ucrt_library_path);
free(obj->windows_sdk_um_library_path);
}
/**
* @returns PathPair containing paths to .../MSVC/[version]/lib/x64 and .../MSVC/[v]/atlmfc/lib/x64
*/
PathPair get_latest_available_vs_path()
{
char ver_name[16] = "";
// Everything past here is taken from microsoft_craziness.h:
// https://gist.github.com/ActuallyaDeviloper/cd25b190743234d58079d6b08a8631e3
// Retrieved 2021-11-25
//
// Credit to Jonathan Blow, Kalinovcic, and ActuallyaDeviloper.
char *highest_ver;
char newpath[260];
// check x64 path first, then x86, if neither then exit
highest_ver = get_highest_ver(MSVC_22_BASE_PATH, is_numeric);
if (highest_ver == NULL)
{
//old code for older visual studio versions
highest_ver = get_highest_ver(MSVC_BASE_PATH, is_numeric);
if (highest_ver == NULL)
{
error_exit("ERROR - Failed to autodetect MSVC libpaths\n");
}
strncpy_s(ver_name, 16, highest_ver, 4);
snprintf(newpath, 260, "%s%s/BuildTools/VC/Tools/MSVC/", MSVC_BASE_PATH, ver_name);
}
else
{
strncpy_s(ver_name, 16, highest_ver, 4);
// This is probably going to break when VS2022 comes out of preview.
// I don't know what the file structure will look like then, so I'm just
// going to leave this as is for now.
// TODO: deal with non-preview path
snprintf(newpath, 260, "%s%s/Preview/VC/Tools/MSVC/", MSVC_22_BASE_PATH, ver_name);
}
free(highest_ver);
highest_ver = get_highest_ver(newpath, NULL);
strcat_s(newpath, 260, highest_ver);
free(highest_ver);
PathPair ret = { 0 };
snprintf(ret.first, 260, "%s/lib/x64", newpath);
snprintf(ret.second, 260, "%s/atlmfc/lib/x64", newpath);
return ret;
void free_resources(Find_Result* result) {
free(result->windows_sdk_root);
free(result->windows_sdk_um_library_path);
free(result->windows_sdk_ucrt_library_path);
free(result->vs_exe_path);
free(result->vs_library_path);
}
/**
* @returns PathPair containing paths to /Program Files (x86)/Windows Kits/[version]/Lib/[version]/ucrt/x64 and .../[version]/um/x64
*/
PathPair find_winkit_path()
#undef INTERFACE
#define INTERFACE ISetupInstance
DECLARE_INTERFACE_(ISetupInstance, IUnknown)
{
// windows version
char win_ver_major[16] = "";
char *highest_ver = get_highest_ver(WINKIT_BASE_PATH, is_numeric);
strcpy_s(win_ver_major, 16, highest_ver);
free(highest_ver);
BEGIN_INTERFACE
// windows kit version? or something
char newpath[260] = "";
sprintf_s(newpath, 260, "%s%s/Lib/", WINKIT_BASE_PATH, win_ver_major);
highest_ver = get_highest_ver(newpath, NULL);
strcat_s(newpath, 260, highest_ver);
free(highest_ver);
// IUnknown methods
STDMETHOD(QueryInterface) (THIS_ REFIID, void**) PURE;
STDMETHOD_(ULONG, AddRef) (THIS) PURE;
STDMETHOD_(ULONG, Release) (THIS) PURE;
PathPair ret = { 0 };
snprintf(ret.first, 260, "%s/ucrt/x64", newpath);
snprintf(ret.second, 260, "%s/um/x64", newpath);
// ISetupInstance methods
STDMETHOD(GetInstanceId)(THIS_ _Out_ BSTR * pbstrInstanceId) PURE;
STDMETHOD(GetInstallDate)(THIS_ _Out_ LPFILETIME pInstallDate) PURE;
STDMETHOD(GetInstallationName)(THIS_ _Out_ BSTR * pbstrInstallationName) PURE;
STDMETHOD(GetInstallationPath)(THIS_ _Out_ BSTR * pbstrInstallationPath) PURE;
STDMETHOD(GetInstallationVersion)(THIS_ _Out_ BSTR * pbstrInstallationVersion) PURE;
STDMETHOD(GetDisplayName)(THIS_ _In_ LCID lcid, _Out_ BSTR * pbstrDisplayName) PURE;
STDMETHOD(GetDescription)(THIS_ _In_ LCID lcid, _Out_ BSTR * pbstrDescription) PURE;
STDMETHOD(ResolvePath)(THIS_ _In_opt_z_ LPCOLESTR pwszRelativePath, _Out_ BSTR * pbstrAbsolutePath) PURE;
return ret;
END_INTERFACE
};
#undef INTERFACE
#define INTERFACE IEnumSetupInstances
DECLARE_INTERFACE_(IEnumSetupInstances, IUnknown)
{
BEGIN_INTERFACE
// IUnknown methods
STDMETHOD(QueryInterface) (THIS_ REFIID, void**) PURE;
STDMETHOD_(ULONG, AddRef) (THIS) PURE;
STDMETHOD_(ULONG, Release) (THIS) PURE;
// IEnumSetupInstances methods
STDMETHOD(Next)(THIS_ _In_ ULONG celt, _Out_writes_to_(celt, *pceltFetched) ISetupInstance * *rgelt, _Out_opt_ _Deref_out_range_(0, celt) ULONG * pceltFetched) PURE;
STDMETHOD(Skip)(THIS_ _In_ ULONG celt) PURE;
STDMETHOD(Reset)(THIS) PURE;
STDMETHOD(Clone)(THIS_ _Deref_out_opt_ IEnumSetupInstances * *ppenum) PURE;
END_INTERFACE
};
#undef INTERFACE
#define INTERFACE ISetupConfiguration
DECLARE_INTERFACE_(ISetupConfiguration, IUnknown)
{
BEGIN_INTERFACE
// IUnknown methods
STDMETHOD(QueryInterface) (THIS_ REFIID, void**) PURE;
STDMETHOD_(ULONG, AddRef) (THIS) PURE;
STDMETHOD_(ULONG, Release) (THIS) PURE;
// ISetupConfiguration methods
STDMETHOD(EnumInstances)(THIS_ _Out_ IEnumSetupInstances * *ppEnumInstances) PURE;
STDMETHOD(GetInstanceForCurrentProcess)(THIS_ _Out_ ISetupInstance * *ppInstance) PURE;
STDMETHOD(GetInstanceForPath)(THIS_ _In_z_ LPCWSTR wzPath, _Out_ ISetupInstance * *ppInstance) PURE;
END_INTERFACE
};
#define CALL_STDMETHOD(object, method, ...) object->lpVtbl->method(object, __VA_ARGS__)
#define CALL_STDMETHOD_(object, method) object->lpVtbl->method(object)
typedef struct {
int32_t best_version[4]; // For Windows 8 versions, only two of these numbers are used.
wchar_t* best_name;
} Version_Data;
bool os_file_exists(wchar_t* name) {
// @Robustness: What flags do we really want to check here?
auto attrib = GetFileAttributesW(name);
if (attrib == INVALID_FILE_ATTRIBUTES) return false;
if (attrib & FILE_ATTRIBUTE_DIRECTORY) return false;
return true;
}
#define concat2(a, b) concat(a, b, NULL, NULL)
#define concat3(a, b, c) concat(a, b, c, NULL)
#define concat4(a, b, c, d) concat(a, b, c, d)
wchar_t* concat(wchar_t* a, wchar_t* b, wchar_t* c, wchar_t* d) {
// Concatenate up to 4 wide strings together. Allocated with malloc.
// If you don't like that, use a programming language that actually
// helps you with using custom allocators. Or just edit the code.
auto len_a = wcslen(a);
auto len_b = wcslen(b);
auto len_c = 0;
if (c) len_c = wcslen(c);
auto len_d = 0;
if (d) len_d = wcslen(d);
wchar_t* result = (wchar_t*)malloc((len_a + len_b + len_c + len_d + 1) * 2);
memcpy(result, a, len_a * 2);
memcpy(result + len_a, b, len_b * 2);
if (c) memcpy(result + len_a + len_b, c, len_c * 2);
if (d) memcpy(result + len_a + len_b + len_c, d, len_d * 2);
result[len_a + len_b + len_c + len_d] = 0;
return result;
}
typedef void (*Visit_Proc_W)(wchar_t* short_name, wchar_t* full_name, Version_Data* data);
bool visit_files_w(wchar_t* dir_name, Version_Data* data, Visit_Proc_W proc) {
// Visit everything in one folder (non-recursively). If it's a directory
// that doesn't start with ".", call the visit proc on it. The visit proc
// will see if the filename conforms to the expected versioning pattern.
WIN32_FIND_DATAW find_data;
wchar_t* wildcard_name = concat2(dir_name, L"\\*");
HANDLE handle = FindFirstFileW(wildcard_name, &find_data);
free(wildcard_name);
if (handle == INVALID_HANDLE_VALUE) return false;
while (true) {
if ((find_data.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && (find_data.cFileName[0] != '.')) {
wchar_t* full_name = concat3(dir_name, L"\\", find_data.cFileName);
proc(find_data.cFileName, full_name, data);
free(full_name);
}
BOOL success = FindNextFileW(handle, &find_data);
if (!success) break;
}
FindClose(handle);
return true;
}
wchar_t* find_windows_kit_root_with_key(HKEY key, wchar_t* version) {
// Given a key to an already opened registry entry,
// get the value stored under the 'version' subkey.
// If that's not the right terminology, hey, I never do registry stuff.
DWORD required_length;
auto rc = RegQueryValueExW(key, version, NULL, NULL, NULL, &required_length);
if (rc != 0) return NULL;
DWORD length = required_length + 2; // The +2 is for the maybe optional zero later on. Probably we are over-allocating.
wchar_t* value = (wchar_t*)malloc(length);
if (!value) return NULL;
rc = RegQueryValueExW(key, version, NULL, NULL, (LPBYTE)value, &required_length); // We know that version is zero-terminated...
if (rc != 0) return NULL;
// The documentation says that if the string for some reason was not stored
// with zero-termination, we need to manually terminate it. Sigh!!
value[required_length / 2] = 0;
return value;
}
void win10_best(wchar_t* short_name, wchar_t* full_name, Version_Data* data) {
// Find the Windows 10 subdirectory with the highest version number.
int i0, i1, i2, i3;
auto success = swscanf_s(short_name, L"%d.%d.%d.%d", &i0, &i1, &i2, &i3);
if (success < 4) return;
if (i0 < data->best_version[0]) return;
else if (i0 == data->best_version[0]) {
if (i1 < data->best_version[1]) return;
else if (i1 == data->best_version[1]) {
if (i2 < data->best_version[2]) return;
else if (i2 == data->best_version[2]) {
if (i3 < data->best_version[3]) return;
}
}
}
// we have to copy_string and free here because visit_files free's the full_name string
// after we execute this function, so Win*_Data would contain an invalid pointer.
if (data->best_name) free(data->best_name);
data->best_name = _wcsdup(full_name);
if (data->best_name) {
data->best_version[0] = i0;
data->best_version[1] = i1;
data->best_version[2] = i2;
data->best_version[3] = i3;
}
}
void win8_best(wchar_t* short_name, wchar_t* full_name, Version_Data* data) {
// Find the Windows 8 subdirectory with the highest version number.
int i0, i1;
auto success = swscanf_s(short_name, L"winv%d.%d", &i0, &i1);
if (success < 2) return;
if (i0 < data->best_version[0]) return;
else if (i0 == data->best_version[0]) {
if (i1 < data->best_version[1]) return;
}
// we have to copy_string and free here because visit_files free's the full_name string
// after we execute this function, so Win*_Data would contain an invalid pointer.
if (data->best_name) free(data->best_name);
data->best_name = _wcsdup(full_name);
if (data->best_name) {
data->best_version[0] = i0;
data->best_version[1] = i1;
}
}
void find_windows_kit_root(Find_Result* result) {
// Information about the Windows 10 and Windows 8 development kits
// is stored in the same place in the registry. We open a key
// to that place, first checking preferntially for a Windows 10 kit,
// then, if that's not found, a Windows 8 kit.
HKEY main_key;
LSTATUS rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows Kits\\Installed Roots",
0, KEY_QUERY_VALUE | KEY_WOW64_32KEY | KEY_ENUMERATE_SUB_KEYS, &main_key);
if (rc != S_OK) return;
// Look for a Windows 10 entry.
wchar_t* windows10_root = find_windows_kit_root_with_key(main_key, L"KitsRoot10");
if (windows10_root) {
wchar_t* windows10_lib = concat2(windows10_root, L"Lib");
free(windows10_root);
Version_Data data = { 0 };
visit_files_w(windows10_lib, &data, win10_best);
free(windows10_lib);
if (data.best_name) {
result->windows_sdk_version = 10;
result->windows_sdk_root = data.best_name;
RegCloseKey(main_key);
return;
}
}
// Look for a Windows 8 entry.
wchar_t* windows8_root = find_windows_kit_root_with_key(main_key, L"KitsRoot81");
if (windows8_root) {
wchar_t* windows8_lib = concat2(windows8_root, L"Lib");
free(windows8_root);
Version_Data data = { 0 };
visit_files_w(windows8_lib, &data, win8_best);
free(windows8_lib);
if (data.best_name) {
result->windows_sdk_version = 8;
result->windows_sdk_root = data.best_name;
RegCloseKey(main_key);
return;
}
}
// If we get here, we failed to find anything.
RegCloseKey(main_key);
}
bool find_visual_studio_2017_by_fighting_through_microsoft_craziness(Find_Result* result) {
HRESULT rc = CoInitialize(NULL);
// "Subsequent valid calls return false." So ignore false.
// if rc != S_OK return false;
GUID my_uid = { 0x42843719, 0xDB4C, 0x46C2, {0x8E, 0x7C, 0x64, 0xF1, 0x81, 0x6E, 0xFD, 0x5B} };
GUID CLSID_SetupConfiguration = { 0x177F0C4A, 0x1CD3, 0x4DE7, {0xA3, 0x2C, 0x71, 0xDB, 0xBB, 0x9F, 0xA3, 0x6D} };
ISetupConfiguration* config = NULL;
// NOTE(Kalinovcic): This is so stupid... These functions take references, so the code is different for C and C++......
//#ifdef __cplusplus
// HRESULT hr = CoCreateInstance(CLSID_SetupConfiguration, NULL, CLSCTX_INPROC_SERVER, my_uid, (void**)&config);
//#else
HRESULT hr = CoCreateInstance(&CLSID_SetupConfiguration, NULL, CLSCTX_INPROC_SERVER, &my_uid, (void**)&config);
//#endif
if (hr != 0) return false;
IEnumSetupInstances* instances = NULL;
hr = CALL_STDMETHOD(config, EnumInstances, &instances);
CALL_STDMETHOD_(config, Release);
if (hr != 0) return false;
if (!instances) return false;
bool found_visual_studio_2017 = false;
while (1) {
ULONG found = 0;
ISetupInstance* instance = NULL;
HRESULT hr = CALL_STDMETHOD(instances, Next, 1, &instance, &found);
if (hr != S_OK) break;
BSTR bstr_inst_path;
hr = CALL_STDMETHOD(instance, GetInstallationPath, &bstr_inst_path);
CALL_STDMETHOD_(instance, Release);
if (hr != S_OK) continue;
wchar_t* tools_filename = concat2(bstr_inst_path, L"\\VC\\Auxiliary\\Build\\Microsoft.VCToolsVersion.default.txt");
SysFreeString(bstr_inst_path);
FILE* f;
errno_t open_result = _wfopen_s(&f, tools_filename, L"rt");
free(tools_filename);
if (open_result != 0) continue;
if (!f) continue;
LARGE_INTEGER tools_file_size;
HANDLE file_handle = (HANDLE)_get_osfhandle(_fileno(f));
BOOL success = GetFileSizeEx(file_handle, &tools_file_size);
if (!success) {
fclose(f);
continue;
}
size_t version_length = (size_t)(tools_file_size.QuadPart + 1); // Warning: This multiplication by 2 presumes there is no variable-length encoding in the wchars (wacky characters in the file could betray this expectation).
wchar_t* version = (wchar_t*)malloc(version_length * 2);
wchar_t* read_result = fgetws(version, version_length, f);
fclose(f);
if (!read_result) continue;
wchar_t* version_tail = wcschr(version, '\n');
if (version_tail) *version_tail = 0; // Stomp the data, because nobody cares about it.
wchar_t* library_path = concat4(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\lib\\x64");
wchar_t* library_file = concat2(library_path, L"\\vcruntime.lib"); // @Speed: Could have library_path point to this string, with a smaller count, to save on memory flailing!
if (os_file_exists(library_file)) {
wchar_t* link_exe_path = concat4(bstr_inst_path, L"\\VC\\Tools\\MSVC\\", version, L"\\bin\\Hostx64\\x64");
free(version);
result->vs_exe_path = link_exe_path;
result->vs_library_path = library_path;
result->is_vs_2017 = true;
found_visual_studio_2017 = true;
break;
}
free(version);
/*
Ryan Saunderson said:
"Clang uses the 'SetupInstance->GetInstallationVersion' / ISetupHelper->ParseVersion to find the newest version
and then reads the tools file to define the tools path - which is definitely better than what i did."
So... @Incomplete: Should probably pick the newest version...
*/
}
CALL_STDMETHOD_(instances, Release);
return found_visual_studio_2017;
}
void find_visual_studio_by_fighting_through_microsoft_craziness(Find_Result* result) {
// The name of this procedure is kind of cryptic. Its purpose is
// to fight through Microsoft craziness. The things that the fine
// Visual Studio team want you to do, JUST TO FIND A SINGLE FOLDER
// THAT EVERYONE NEEDS TO FIND, are ridiculous garbage.
// For earlier versions of Visual Studio, you'd find this information in the registry,
// similarly to the Windows Kits above. But no, now it's the future, so to ask the
// question "Where is the Visual Studio folder?" you have to do a bunch of COM object
// instantiation, enumeration, and querying. (For extra bonus points, try doing this in
// a new, underdeveloped programming language where you don't have COM routines up
// and running yet. So fun.)
//
// If all this COM object instantiation, enumeration, and querying doesn't give us
// a useful result, we drop back to the registry-checking method.
bool found_visual_studio_2017 = find_visual_studio_2017_by_fighting_through_microsoft_craziness(result);
if (found_visual_studio_2017) return;
// If we get here, we didn't find Visual Studio 2017. Try earlier versions.
HKEY vs7_key;
HRESULT rc = RegOpenKeyExA(HKEY_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\VisualStudio\\SxS\\VS7", 0, KEY_QUERY_VALUE | KEY_WOW64_32KEY, &vs7_key);
if (rc != S_OK) return;
// Hardcoded search for 4 prior Visual Studio versions. Is there something better to do here?
wchar_t* versions[] = { L"14.0", L"12.0", L"11.0", L"10.0" };
const int NUM_VERSIONS = sizeof(versions) / sizeof(versions[0]);
for (int i = 0; i < NUM_VERSIONS; i++) {
wchar_t* v = versions[i];
DWORD dw_type;
DWORD cb_data;
LSTATUS rc = RegQueryValueExW(vs7_key, v, NULL, &dw_type, NULL, &cb_data);
if ((rc == ERROR_FILE_NOT_FOUND) || (dw_type != REG_SZ)) {
continue;
}
wchar_t* buffer = (wchar_t*)malloc(cb_data);
if (!buffer) return;
rc = RegQueryValueExW(vs7_key, v, NULL, NULL, (LPBYTE)buffer, &cb_data);
if (rc != 0) continue;
// @Robustness: Do the zero-termination thing suggested in the RegQueryValue docs?
wchar_t* lib_path = concat2(buffer, L"VC\\Lib\\amd64");
// Check to see whether a vcruntime.lib actually exists here.
wchar_t* vcruntime_filename = concat2(lib_path, L"\\vcruntime.lib");
bool vcruntime_exists = os_file_exists(vcruntime_filename);
free(vcruntime_filename);
if (vcruntime_exists) {
result->vs_exe_path = concat2(buffer, L"VC\\bin\\amd64");
result->vs_library_path = lib_path;
free(buffer);
RegCloseKey(vs7_key);
return;
}
free(lib_path);
free(buffer);
}
RegCloseKey(vs7_key);
// If we get here, we failed to find anything.
}
Find_Result find_visual_studio_and_windows_sdk() {
Find_Result result = { 0 };
find_windows_kit_root(&result);
if (result.windows_sdk_root) {
result.windows_sdk_um_library_path = concat2(result.windows_sdk_root, L"\\um\\x64");
result.windows_sdk_ucrt_library_path = concat2(result.windows_sdk_root, L"\\ucrt\\x64");
}
find_visual_studio_by_fighting_through_microsoft_craziness(&result);
return result;
}
#endif //defined(_MSC_VER)

11
src/utils/find_msvc.h
View File

@@ -1,9 +1,10 @@
#pragma once
typedef struct {
char first[260];
char second[260];
} PathPair;
char* windows_sdk_um_library_path;
char* windows_sdk_ucrt_library_path;
char* vs_library_path;
} WindowsLinkPathsUTF8;
PathPair get_latest_available_vs_path();
PathPair find_winkit_path();
WindowsLinkPathsUTF8 get_windows_link_paths();
void free_windows_link_paths(WindowsLinkPathsUTF8* obj);