cmake/Source/cmBinUtilsWindowsPELinker.cxx

/* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   file LICENSE.rst or https://cmake.org/licensing for details.  */

#include "cmBinUtilsWindowsPELinker.h"

#include <algorithm>
#include <cstddef>
#include <iterator>
#include <sstream>
#include <utility>
#include <vector>

#include <cm/filesystem>
#include <cm/memory>

#include "cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool.h"
#include "cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool.h"
#include "cmRuntimeDependencyArchive.h"
#include "cmSystemTools.h"
#include "cmTargetTypes.h"

#ifdef _WIN32
#  include <windows.h>

#  include "cmsys/Encoding.hxx"

#  include "cmStringAlgorithms.h"
#else
#  include "cmsys/Directory.hxx"
#endif

namespace {

#ifdef _WIN32
std::string ReplaceWithActualNameCasing(std::string path)
{
  WIN32_FIND_DATAW findData;
  HANDLE hFind = ::FindFirstFileW(
    cmsys::Encoding::ToWindowsExtendedPath(path).c_str(), &findData);
  if (hFind != INVALID_HANDLE_VALUE) {
    auto onDiskName = cmsys::Encoding::ToNarrow(findData.cFileName);
    ::FindClose(hFind);
    path.replace(path.end() - onDiskName.size(), path.end(), onDiskName);
  }
  return path;
}
#else
bool FindCaseInsensitive(std::string const& dir, std::string const& lowerName,
                         std::string& foundPath)
{
  if (!cmSystemTools::FileIsDirectory(dir)) {
    return false;
  }
  cmsys::Directory directory;
  if (!directory.Load(dir)) {
    return false;
  }
  for (std::size_t i = 0; i < directory.GetNumberOfFiles(); ++i) {
    cm::filesystem::path fileName = directory.GetFile(i);

    if (cmSystemTools::LowerCase(fileName) == lowerName) {
      foundPath += dir / fileName;
      return true;
    }
  }

  return false;
}
#endif
}

cmBinUtilsWindowsPELinker::cmBinUtilsWindowsPELinker(
  cmRuntimeDependencyArchive* archive)
  : cmBinUtilsLinker(archive)
{
}

bool cmBinUtilsWindowsPELinker::Prepare()
{
  std::string tool = this->Archive->GetGetRuntimeDependenciesTool();
  if (tool.empty()) {
    std::vector<std::string> command;
    if (this->Archive->GetGetRuntimeDependenciesCommand("dumpbin", command)) {
      tool = "dumpbin";
    } else {
      tool = "objdump";
    }
  }
  if (tool == "dumpbin") {
    this->Tool =
      cm::make_unique<cmBinUtilsWindowsPEDumpbinGetRuntimeDependenciesTool>(
        this->Archive);
  } else if (tool == "objdump") {
    this->Tool =
      cm::make_unique<cmBinUtilsWindowsPEObjdumpGetRuntimeDependenciesTool>(
        this->Archive);
  } else {
    std::ostringstream e;
    e << "Invalid value for CMAKE_GET_RUNTIME_DEPENDENCIES_TOOL: " << tool;
    this->SetError(e.str());
    return false;
  }

  return true;
}

cmBinUtilsWindowsPELinker::Dependency::Dependency(std::string casedName)
  : CasedName(std::move(casedName))
  , LowerName(cmSystemTools::LowerCase(CasedName))
{
}

bool cmBinUtilsWindowsPELinker::ScanDependencies(std::string const& file,
                                                 cm::TargetType /* unused */)
{
  std::vector<std::string> needed;
  if (!this->Tool->GetFileInfo(file, needed)) {
    return false;
  }

  std::vector<Dependency> depends;
  depends.reserve(needed.size());
  std::move(needed.begin(), needed.end(), std::back_inserter(depends));
  std::string origin = cmSystemTools::GetFilenamePath(file);

  for (Dependency const& lib : depends) {
    if (this->Archive->IsPreExcluded(lib.LowerName)) {
      continue;
    }
    Dependency path;
    bool resolved = false;
    if (!this->ResolveDependency(lib, origin, path, resolved)) {
      return false;
    }
    if (resolved) {
      if (this->Archive->IsPostExcluded(path.LowerName, path.CasedName)) {
        continue;
      }
      bool unique;
      this->Archive->AddResolvedPath(lib.CasedName, path.CasedName, unique);
      if (unique &&
          !this->ScanDependencies(path.CasedName,
                                  cm::TargetType::SHARED_LIBRARY)) {
        return false;
      }
    } else {
      this->Archive->AddUnresolvedPath(lib.CasedName);
    }
  }

  return true;
}

bool cmBinUtilsWindowsPELinker::ResolveDependency(Dependency const& lib,
                                                  std::string const& origin,
                                                  Dependency& path,
                                                  bool& resolved)
{
  auto dirs = this->Archive->GetSearchDirectories();

#ifdef _WIN32
  char buf[MAX_PATH];
  unsigned int len;
  if ((len = GetWindowsDirectoryA(buf, MAX_PATH)) > 0) {
    dirs.insert(dirs.begin(), std::string(buf, len));
  }
  if ((len = GetSystemDirectoryA(buf, MAX_PATH)) > 0) {
    dirs.insert(dirs.begin(), std::string(buf, len));
  }
#endif

  dirs.insert(dirs.begin(), origin);

  for (auto const& searchPath : dirs) {
#ifdef _WIN32
    path.LowerName = cmStrCat(searchPath, '/', lib.LowerName);
    if (!cmSystemTools::PathExists(path.LowerName)) {
      continue;
    }
    this->NormalizePath(path.LowerName);
    path.CasedName = ReplaceWithActualNameCasing(path.LowerName);
#else
    if (!FindCaseInsensitive(searchPath, lib.LowerName, path.CasedName)) {
      continue;
    }
    this->NormalizePath(path.CasedName);
    path.LowerName = [&lib](std::string libPath) -> std::string {
      libPath.replace(libPath.end() - lib.LowerName.size(), libPath.end(),
                      lib.LowerName);
      return libPath;
    }(path.CasedName);
#endif
    resolved = true;
    return true;
  }

  resolved = false;
  return true;
}