kc3-lang/angle/src/common/system_utils_winuwp.cpp

• Show log

  Commit

• Hash : cac81f07
  Author :
  Date : 2021-12-14T22:56:15
  

  Return full error info when opening a library with dlopen
  
  This CL adds a parameter to OpenSharedLibrary and
  OpenSharedLibraryWithExtension which is used to
  return the full path of the library which was opened.
  If dlopen failed, the string also contains the result
  of dlerror which explains what the error was.
  
  Bug: chromium:1246171
  Change-Id: I374c7e2dfa18853c8137b4cbea06af8db3fdb501
  Reviewed-on: https://chromium-review.googlesource.com/c/angle/angle/+/3340020
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  Reviewed-by: Shahbaz Youssefi <syoussefi@chromium.org>
  Commit-Queue: Alexis Hétu <sugoi@chromium.org>
  

Download

• src/common/system_utils_winuwp.cpp

• //
  // Copyright 2019 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // system_utils_winuwp.cpp: Implementation of OS-specific functions for Windows UWP
  
  #include "common/debug.h"
  #include "system_utils.h"
  
  #include <stdarg.h>
  #include <windows.h>
  #include <array>
  #include <codecvt>
  #include <locale>
  #include <string>
  
  namespace angle
  {
  
  bool SetEnvironmentVar(const char *variableName, const char *value)
  {
      // Not supported for UWP
      return false;
  }
  
  std::string GetEnvironmentVar(const char *variableName)
  {
      // Not supported for UWP
      return "";
  }
  
  class UwpLibrary : public Library
  {
    public:
      UwpLibrary(const char *libraryName, SearchType searchType, std::string *errorOut)
      {
          std::wstring_convert<std::codecvt_utf8_utf16<wchar_t>> converter;
          std::wstring wideBuffer = converter.from_bytes(libraryName);
  
          switch (searchType)
          {
              case SearchType::ModuleDir:
                  if (errorOut)
                  {
                      *errorOut = libraryName;
                  }
                  mModule = LoadPackagedLibrary(wideBuffer.c_str(), 0);
                  break;
              case SearchType::SystemDir:
              case SearchType::AlreadyLoaded:
                  // Not supported in UWP
                  break;
          }
      }
  
      ~UwpLibrary() override
      {
          if (mModule)
          {
              FreeLibrary(mModule);
          }
      }
  
      void *getSymbol(const char *symbolName) override
      {
          if (!mModule)
          {
              return nullptr;
          }
  
          return reinterpret_cast<void *>(GetProcAddress(mModule, symbolName));
      }
  
      void *getNative() const override { return reinterpret_cast<void *>(mModule); }
  
      std::string getPath() const override
      {
          if (!mModule)
          {
              return "";
          }
  
          std::array<char, MAX_PATH> buffer;
          if (GetModuleFileNameA(mModule, buffer.data(), buffer.size()) == 0)
          {
              return "";
          }
  
          return std::string(buffer.data());
      }
  
    private:
      HMODULE mModule = nullptr;
  };
  
  Library *OpenSharedLibrary(const char *libraryName, SearchType searchType)
  {
      return OpenSharedLibraryAndGetError(libraryName, searchType, nullptr);
  }
  
  Library *OpenSharedLibraryWithExtension(const char *libraryName, SearchType searchType)
  {
      return OpenSharedLibraryWithExtensionAndGetError(libraryName, searchType, nullptr);
  }
  
  Library *OpenSharedLibraryAndGetError(const char *libraryName,
                                        SearchType searchType,
                                        std::string *errorOut)
  {
      char buffer[MAX_PATH];
      int ret = snprintf(buffer, MAX_PATH, "%s.%s", libraryName, GetSharedLibraryExtension());
  
      if (ret > 0 && ret < MAX_PATH)
      {
          return OpenSharedLibraryWithExtensionAndGetError(buffer, searchType, errorOut);
      }
      else
      {
          fprintf(stderr, "Error loading shared library: 0x%x", ret);
          return nullptr;
      }
  }
  
  Library *OpenSharedLibraryWithExtensionAndGetError(const char *libraryName,
                                                     SearchType searchType,
                                                     std::string *errorOut)
  {
      return new UwpLibrary(libraryName, searchType, errorOut);
  }
  
  namespace
  {
  class UwpPageFaultHandler : public PageFaultHandler
  {
    public:
      UwpPageFaultHandler(PageFaultCallback callback) : PageFaultHandler(callback) {}
      ~UwpPageFaultHandler() override {}
  
      bool enable() override;
      bool disable() override;
  };
  
  bool UwpPageFaultHandler::disable()
  {
      UNIMPLEMENTED();
      return true;
  }
  
  bool UwpPageFaultHandler::enable()
  {
      UNIMPLEMENTED();
      return true;
  }
  }  // namespace
  
  bool ProtectMemory(uintptr_t start, size_t size)
  {
      UNIMPLEMENTED();
      return true;
  }
  
  bool UnprotectMemory(uintptr_t start, size_t size)
  {
      UNIMPLEMENTED();
      return true;
  }
  
  size_t GetPageSize()
  {
      UNIMPLEMENTED();
      return 4096;
  }
  
  PageFaultHandler *CreatePageFaultHandler(PageFaultCallback callback)
  {
      return new UwpPageFaultHandler(callback);
  }
  }  // namespace angle
  

Download