Use full path when loading SourceLevelDebugger library

Change-Id: I27f7ee2b8944b9890ab4b141c06e9c2f0a8dffb1
Signed-off-by: Mateusz Hoppe <mateusz.hoppe@intel.com>

opencl/source/dll/source_level_debugger_dll.cpp

@@ -10,6 +10,6 @@
 namespace NEO {
 
 OsLibrary *SourceLevelDebugger::loadDebugger() {
-    return OsLibrary::load(SourceLevelDebugger::dllName);
+    return OsLibrary::load(OsLibrary::createFullSystemPath(SourceLevelDebugger::dllName));
 }
 } // namespace NEO

opencl/test/unit_test/os_interface/linux/CMakeLists.txt

@@ -34,6 +34,7 @@ set(IGDRCL_SRCS_tests_os_interface_linux
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_performance_counters_linux.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/mock_performance_counters_linux.h
     ${CMAKE_CURRENT_SOURCE_DIR}/os_interface_linux_tests.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/os_library_linux_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/os_time_test.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/performance_counters_linux_tests.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/self_lib_lin.cpp

opencl/test/unit_test/os_interface/linux/os_library_linux_tests.cpp

@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "shared/source/os_interface/linux/os_library_linux.h"
+
+#include "gtest/gtest.h"
+
+namespace NEO {
+
+TEST(OsLibraryTest, WhenCreatingFullSystemPathThenProperPathIsConstructed) {
+    auto fullPath = OsLibrary::createFullSystemPath("test");
+    EXPECT_STREQ("test", fullPath.c_str());
+}
+
+} // namespace NEO

opencl/test/unit_test/os_interface/windows/os_library_win_tests.cpp

@@ -27,16 +27,21 @@ class OsLibraryBackup : public Windows::OsLibrary {
     using ModuleNameType = decltype(Windows::OsLibrary::getModuleFileNameA);
     using ModuleNameBackupType = typename VariableBackup<ModuleNameType>;
 
+    using SystemDirectoryType = decltype(Windows::OsLibrary::getSystemDirectoryA);
+    using SystemDirectoryBackupType = typename VariableBackup<SystemDirectoryType>;
+
     struct Backup {
         std::unique_ptr<BackupType> bkp1 = nullptr;
         std::unique_ptr<ModuleNameBackupType> bkp2 = nullptr;
+        std::unique_ptr<SystemDirectoryBackupType> bkp3 = nullptr;
     };
 
   public:
-    static std::unique_ptr<Backup> backup(Type newValue, ModuleNameType newModuleName) {
+    static std::unique_ptr<Backup> backup(Type newValue, ModuleNameType newModuleName, SystemDirectoryType newSystemDirectoryName) {
         std::unique_ptr<Backup> bkp(new Backup());
         bkp->bkp1.reset(new BackupType(&OsLibrary::loadLibraryExA, newValue));
         bkp->bkp2.reset(new ModuleNameBackupType(&OsLibrary::getModuleFileNameA, newModuleName));
+        bkp->bkp3.reset(new SystemDirectoryBackupType(&OsLibrary::getSystemDirectoryA, newSystemDirectoryName));
         return bkp;
     };
 };
@@ -69,17 +74,31 @@ HMODULE WINAPI LoadLibraryExAMock(LPCSTR lpFileName, HANDLE hFile, DWORD dwFlags
     return (HMODULE)1;
 }
 
+UINT WINAPI GetSystemDirectoryAMock(LPSTR lpBuffer, UINT uSize) {
+    const char path[] = "C:\\System";
+    strcpy_s(lpBuffer, sizeof(path), path);
+    return sizeof(path) - 1; // do not include terminating null
+}
+
 TEST(OSLibraryWinTest, WhenLoadDependencyFailsThenFallbackToNonDriverStore) {
-    auto bkp = OsLibraryBackup::backup(LoadLibraryExAMock, GetModuleFileNameAMock);
+    auto bkp = OsLibraryBackup::backup(LoadLibraryExAMock, GetModuleFileNameAMock, GetSystemDirectoryAMock);
 
     std::unique_ptr<OsLibrary> library(OsLibrary::load(Os::testDllName));
     EXPECT_NE(nullptr, library);
 }
 
 TEST(OSLibraryWinTest, WhenDependencyLoadsThenProperPathIsConstructed) {
-    auto bkp = OsLibraryBackup::backup(LoadLibraryExAMock, GetModuleFileNameAMock);
+    auto bkp = OsLibraryBackup::backup(LoadLibraryExAMock, GetModuleFileNameAMock, GetSystemDirectoryAMock);
     VariableBackup<bool> bkpM(&mockWillFail, false);
 
     std::unique_ptr<OsLibrary> library(OsLibrary::load(Os::testDllName));
     EXPECT_NE(nullptr, library);
 }
+
+TEST(OSLibraryWinTest, WhenCreatingFullSystemPathThenProperPathIsConstructed) {
+    auto bkp = OsLibraryBackup::backup(LoadLibraryExAMock, GetModuleFileNameAMock, GetSystemDirectoryAMock);
+    VariableBackup<bool> bkpM(&mockWillFail, false);
+
+    auto fullPath = OsLibrary::createFullSystemPath("test");
+    EXPECT_STREQ("C:\\System\\test", fullPath.c_str());
+}

shared/source/os_interface/linux/os_library_linux.cpp

@@ -23,6 +23,11 @@ OsLibrary *OsLibrary::load(const std::string &name) {
     }
     return ptr;
 }
+
+const std::string OsLibrary::createFullSystemPath(const std::string &name) {
+    return name;
+}
+
 namespace Linux {
 
 OsLibrary::OsLibrary(const std::string &name) {

shared/source/os_interface/os_library.h

@@ -32,6 +32,7 @@ class OsLibrary {
     virtual ~OsLibrary() = default;
 
     static OsLibrary *load(const std::string &name);
+    static const std::string createFullSystemPath(const std::string &name);
 
     ConvertibleProcAddr operator[](const std::string &name) {
         return ConvertibleProcAddr{getProcAddress(name)};

shared/source/os_interface/windows/os_library_win.cpp

@@ -19,9 +19,20 @@ OsLibrary *OsLibrary::load(const std::string &name) {
     return ptr;
 }
 
+const std::string OsLibrary::createFullSystemPath(const std::string &name) {
+    CHAR buff[MAX_PATH];
+    UINT ret = 0;
+    ret = Windows::OsLibrary::getSystemDirectoryA(buff, MAX_PATH);
+    buff[ret] = '\\';
+    buff[ret + 1] = 0;
+    strncat_s(&buff[0], sizeof(buff), name.c_str(), _TRUNCATE);
+    return std::string(buff);
+}
+
 namespace Windows {
 decltype(&LoadLibraryExA) OsLibrary::loadLibraryExA = LoadLibraryExA;
 decltype(&GetModuleFileNameA) OsLibrary::getModuleFileNameA = GetModuleFileNameA;
+decltype(&GetSystemDirectoryA) OsLibrary::getSystemDirectoryA = GetSystemDirectoryA;
 
 extern "C" IMAGE_DOS_HEADER __ImageBase;
 __inline HINSTANCE GetModuleHINSTANCE() { return (HINSTANCE)&__ImageBase; }

shared/source/os_interface/windows/os_library_win.h

@@ -24,6 +24,7 @@ class OsLibrary : public NEO::OsLibrary {
 
     bool isLoaded();
     void *getProcAddress(const std::string &procName);
+    static decltype(&GetSystemDirectoryA) getSystemDirectoryA;
 
   protected:
     HMODULE loadDependency(const std::string &dependencyFileName) const;