cmake/Source/cmSbomBuilder.cxx

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

#include <algorithm>
#include <array>
#include <functional>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

#include <cm/optional>
#include <cmext/algorithm>
#include <cmext/string_view>

#include "cmArgumentParserTypes.h"
#include "cmDiagnostics.h"
#include "cmExportFileGenerator.h"
#include "cmExportSet.h"
#include "cmFindPackageStack.h"
#include "cmGeneratorExpression.h"
#include "cmGeneratorTarget.h"
#include "cmList.h"
#include "cmLocalGenerator.h"
#include "cmMakefile.h"
#include "cmMessageType.h"
#include "cmSbomArguments.h"
#include "cmSbomObject.h"
#include "cmSpdx.h"
#include "cmSpdxSerializer.h"
#include "cmStringAlgorithms.h"
#include "cmSystemTools.h"
#include "cmTarget.h"
#include "cmTargetExport.h"
#include "cmTargetTypes.h"
#include "cmValue.h"

cmSpdxPackage::PurposeId GetPurpose(cm::TargetType type)
{
  switch (type) {
    case cm::TargetType::EXECUTABLE:
      return cmSpdxPackage::PurposeId::APPLICATION;
    case cm::TargetType::STATIC_LIBRARY:
    case cm::TargetType::SHARED_LIBRARY:
    case cm::TargetType::MODULE_LIBRARY:
    case cm::TargetType::OBJECT_LIBRARY:
    case cm::TargetType::INTERFACE_LIBRARY:
      return cmSpdxPackage::PurposeId::LIBRARY;
    case cm::TargetType::UTILITY:
      return cmSpdxPackage::PurposeId::SOURCE;
    case cm::TargetType::GLOBAL_TARGET:
    case cm::TargetType::UNKNOWN_LIBRARY:
    default:
      return cmSpdxPackage::PurposeId::ARCHIVE;
  }
}

cmSbomBuilder::cmSbomBuilder(cmSbomArguments args,
                             std::vector<cmExportSet*> exportSets,
                             cmLocalGenerator* lg)
  : LocalGenerator(lg)
  , ExportSets(std::move(exportSets))
  , PackageName(std::move(args.PackageName))
  , Namespace(cmStrCat(this->PackageName, "::"_s))
  , PackageVersion(std::move(args.Version))
  , PackageDescription(std::move(args.Description))
  , PackageWebsite(std::move(args.Website))
  , PackageUrl(std::move(args.PackageUrl))
  , DataLicense(std::move(args.DataLicense))
  , DefaultLicense(std::move(args.DefaultLicense))
  , PackageFormat(args.GetFormat())
{
}

std::set<cmGeneratorTarget const*> cmSbomBuilder::CollectTargets() const
{
  std::set<cmGeneratorTarget const*> targets;
  for (cmExportSet* exportSet : this->ExportSets) {
    for (auto const& te : exportSet->GetTargetExports()) {
      if (cmGeneratorTarget const* gt =
            this->LocalGenerator->FindGeneratorTargetToUse(te->TargetName)) {
        targets.emplace(gt);
      }
    }
  }
  return targets;
}

void cmSbomBuilder::Compute(cmLocalGenerator* lg)
{
  this->LocalGenerator = lg;
  if (!lg) {
    return;
  }
  for (cmExportSet* es : this->ExportSets) {
    es->Compute(lg);
  }
  // Populate the cache now (rather than at Generate time) so peer SBOMs can
  // query CoversTarget() during their own NoteLinkedTarget walks.
  this->SbomTargets = this->CollectTargets();
}

bool cmSbomBuilder::CoversTarget(cmGeneratorTarget const* target) const
{
  return cm::contains(this->SbomTargets, target);
}

bool cmSbomBuilder::CoversExportSet(cmExportSet const* set) const
{
  return std::find(this->ExportSets.cbegin(), this->ExportSets.cend(), set) !=
    this->ExportSets.cend();
}

bool cmSbomBuilder::GenerateForTargets(
  std::ostream& os, std::string const& config,
  cmGeneratorExpression::PreprocessContext preprocessContext)
{
  cmSbomDocument doc;
  doc.Graph.reserve(512);

  cmSpdxCreationInfo const* ci =
    insert_back(doc.Graph, this->GenerateCreationInfo());
  cmSpdxDocument* project = insert_back(doc.Graph, this->GenerateSbom(ci));
  std::vector<TargetProperties> targetProps;
  targetProps.reserve(this->SbomTargets.size());

  for (cmGeneratorTarget const* target : this->SbomTargets) {
    ImportPropertyMap properties;
    this->PopulateLinkLibrariesProperty(target, preprocessContext, properties);
    this->PopulateInterfaceLinkLibrariesProperty(target, preprocessContext,
                                                 properties);
    targetProps.push_back(TargetProperties{
      insert_back(project->RootElements,
                  this->GenerateImportTarget(ci, target)),
      target,
      std::move(properties),
    });
  }

  bool status = true;
  for (TargetProperties const& target : targetProps) {
    status &=
      this->GenerateProperties(doc, project, ci, target, targetProps, config);
  }
  if (status) {
    this->WriteSbom(doc, os);
  }
  return status;
}

void cmSbomBuilder::WriteSbom(cmSbomDocument& doc, std::ostream& os) const
{
  switch (this->PackageFormat) {
    case cmSbomArguments::SbomFormat::SPDX_3_0_JSON:
      cmSpdxSerializer{}.WriteSbom(os, cmSbomObject(doc));
      break;
    case cmSbomArguments::SbomFormat::NONE:
      break;
  }
}

bool cmSbomBuilder::AddPackageInformation(
  cmSpdxPackage& artifact, std::string const& name,
  cmPackageInformation const& package) const
{
  if (name.empty()) {
    return false;
  }

  cmSpdxOrganization org;
  org.SpdxId = cmStrCat("urn:", name, "#Organization");
  org.Name = name;
  org.CreationInfo = artifact.CreationInfo;
  artifact.OriginatedBy.emplace_back(std::move(org));

  if (package.Description) {
    artifact.Description = *package.Description;
  }

  if (package.Version) {
    artifact.PackageVersion = *package.Version;
  }

  if (package.PackageUrl) {
    artifact.PackageUrl = *package.PackageUrl;
  }

  if (package.License) {
    artifact.CopyrightText = *package.License;
  }

  artifact.BuiltTime = cmSystemTools::GetCurrentDateTime("%FT%TZ");
  cmSpdxExternalRef externalRef;
  externalRef.Locator = cmStrCat("cmake:find_package(", name, ")");
  externalRef.ExternalRefType = "buildSystem";
  return true;
}

cmSpdxCreationInfo cmSbomBuilder::GenerateCreationInfo() const
{
  cmSpdxCreationInfo ci;
  ci.SpdxId = "_:Build#CreationInfo";
  ci.Created = cmSystemTools::GetCurrentDateTime("%FT%TZ");
  ci.CreatedBy = { "https://gitlab.kitware.com/cmake/cmake" };
  ci.Comment = "This SBOM was generated from the CMakeLists.txt File";
  ci.SpecVersion = "3.0.1";
  return ci;
}

cmSpdxDocument cmSbomBuilder::GenerateSbom(cmSpdxCreationInfo const* ci) const
{
  cmSpdxDocument proj;
  proj.Name = PackageName;
  proj.SpdxId = cmStrCat("urn:", PackageName, "#SPDXDocument");
  proj.ProfileConformance = { "core", "software" };
  proj.CreationInfo = ci;

  if (!this->PackageDescription.empty()) {
    proj.Description = this->PackageDescription;
  }

  if (!this->DataLicense.empty()) {
    cmSpdxLicenseExpression license;
    license.SpdxId = cmStrCat("urn:", PackageName, "#LicenseExpression");
    license.CreationInfo = ci;
    license.LicenseExpression = this->DataLicense;
    proj.DataLicense = license;
  }

  return proj;
}

cmSpdxPackage cmSbomBuilder::GenerateImportTarget(
  cmSpdxCreationInfo const* ci, cmGeneratorTarget const* target) const
{
  cmSpdxPackage package;
  package.SpdxId = cmStrCat("urn:", target->GetName(), "#Package");
  package.Name = target->GetName();
  package.PrimaryPurpose = GetPurpose(target->GetType());
  package.CreationInfo = ci;

  if (!this->PackageVersion.empty()) {
    package.PackageVersion = this->PackageVersion;
  }

  if (!this->PackageWebsite.empty()) {
    package.Homepage = this->PackageWebsite;
  }

  if (!this->PackageUrl.empty()) {
    package.DownloadLocation = this->PackageUrl;
  }

  return package;
}

bool cmSbomBuilder::GenerateLinkProperties(
  cmSbomDocument& doc, cmSpdxDocument* project, cmSpdxCreationInfo const* ci,
  std::string const& libraries, TargetProperties const& current,
  std::vector<TargetProperties> const& allTargets,
  std::string const& config) const
{
  auto itProp = current.Properties.find(libraries);
  if (itProp == current.Properties.end()) {
    return true;
  }

  cmGeneratorExpression ge(*current.Target->Makefile->GetCMakeInstance());
  std::unique_ptr<cmCompiledGeneratorExpression> cge =
    ge.Parse(itProp->second);
  std::string evaluatedLibraries =
    cge->Evaluate(current.Target->GetLocalGenerator(), config, current.Target);

  if (cge->GetHadHeadSensitiveCondition()) {
    current.Target->Makefile->IssueMessage(
      MessageType::FATAL_ERROR,
      cmStrCat("Property \"", libraries, "\" of target \"",
               current.Target->GetName(),
               "\" contains a generator expression that is not allowed for "
               "SBOM generation."));
    return false;
  }

  auto makeRel = [&](char const* id, char const* desc) {
    cmSpdxRelationship r;
    r.SpdxId = cmStrCat("urn:", id, "#Relationship");
    r.RelationshipType = cmSpdxRelationship::RelationshipTypeId::DEPENDS_ON;
    r.Description = desc;
    r.From = current.Package;
    r.CreationInfo = ci;
    return r;
  };

  auto linkLibraries = makeRel("Static", "Linked Libraries");
  auto linkRequires = makeRel("Dynamic", "Required Runtime Libraries");
  auto buildRequires = makeRel("Shared", "Required Build-Time Libraries");

  auto addArtifact =
    [&](std::string const& name) -> std::pair<bool, cmSpdxPackage const*> {
    auto it = this->LinkTargets.find(name);
    if (it != this->LinkTargets.end()) {
      LinkInfo const& linkInfo = it->second;
      if (linkInfo.Package.empty()) {
        for (auto const& t : allTargets) {
          if (t.Target->GetName() == linkInfo.Component) {
            return { true, t.Package };
          }
        }
      }
      std::string pkgName =
        cmStrCat(linkInfo.Package, ":", linkInfo.Component);
      cmSpdxPackage pkg;
      pkg.Name = pkgName;
      pkg.SpdxId = cmStrCat("urn:", pkgName, "#Package");
      pkg.CreationInfo = ci;
      if (!linkInfo.Package.empty()) {
        auto const& pkgIt = this->Requirements.find(linkInfo.Package);
        if (pkgIt != this->Requirements.end() &&
            pkgIt->second.Components.count(linkInfo.Component) > 0) {
          this->AddPackageInformation(pkg, pkgIt->first, pkgIt->second);
        }
      }

      cmSpdxPackage const* pkgPtr =
        insert_back(project->Elements, std::move(pkg));
      if (!linkInfo.License.empty() &&
          !cm::contains(this->GeneratedLinkLicenses, name)) {
        this->GeneratedLinkLicenses.emplace(name);

        cmSpdxLicenseExpression license;
        license.SpdxId = cmStrCat("urn:", name, "#LicenseExpression");
        license.CreationInfo = ci;
        license.LicenseExpression = linkInfo.License;

        cmSpdxRelationship relHasLicense;
        relHasLicense.SpdxId =
          cmStrCat("urn:", name, "#DeclaredLicenseRelationship");
        relHasLicense.CreationInfo = ci;
        relHasLicense.RelationshipType =
          cmSpdxRelationship::HAS_DECLARED_LICENSE;
        relHasLicense.From = pkgPtr;
        relHasLicense.To.emplace_back(std::move(license));

        insert_back(doc.Graph, std::move(relHasLicense));
      }

      return { true, pkgPtr };
    }

    cmSpdxPackage pkg;
    pkg.SpdxId = cmStrCat("urn:", name, "#Package");
    pkg.Name = name;
    pkg.CreationInfo = ci;
    return { false, insert_back(project->Elements, std::move(pkg)) };
  };

  cmList names{ evaluatedLibraries };
  names.sort();
  names.remove_duplicates();
  for (std::string const& n : names) {
    auto res = addArtifact(n);
    if (!res.second) {
      continue;
    }

    if (res.first) {
      linkLibraries.To.push_back(res.second);
    } else {
      buildRequires.To.push_back(res.second);
    }
  }

  if (!linkLibraries.To.empty()) {
    insert_back(doc.Graph, std::move(linkLibraries));
  }
  if (!linkRequires.To.empty()) {
    insert_back(doc.Graph, std::move(linkRequires));
  }
  if (!buildRequires.To.empty()) {
    insert_back(doc.Graph, std::move(buildRequires));
  }
  return true;
}

bool cmSbomBuilder::GenerateProperties(
  cmSbomDocument& doc, cmSpdxDocument* proj, cmSpdxCreationInfo const* ci,
  TargetProperties const& current,
  std::vector<TargetProperties> const& allTargets,
  std::string const& config) const
{
  bool status = true;
  status &= this->GenerateLinkProperties(doc, proj, ci, "LINK_LIBRARIES",
                                         current, allTargets, config);
  status &= this->GenerateLinkProperties(
    doc, proj, ci, "INTERFACE_LINK_LIBRARIES", current, allTargets, config);
  status &= this->GenerateMetaProperties(doc, proj, ci, current);
  return status;
}

bool cmSbomBuilder::GenerateMetaProperties(
  cmSbomDocument& doc, cmSpdxDocument* /*project*/,
  cmSpdxCreationInfo const* ci, TargetProperties const& current) const
{
  std::string licenseExpr = this->DefaultLicense;
  cmValue licenseExprProp = current.Target->GetProperty("SPDX_LICENSE");
  if (licenseExprProp) {
    licenseExpr = licenseExprProp;
  }
  if (!licenseExpr.empty()) {
    auto const& tgtName = current.Target->GetName();

    cmSpdxLicenseExpression license;
    license.SpdxId = cmStrCat("urn:", tgtName, "#LicenseExpression");
    license.CreationInfo = ci;
    license.LicenseExpression = std::move(licenseExpr);

    cmSpdxRelationship relHasLicense;
    relHasLicense.SpdxId =
      cmStrCat("urn:", tgtName, "#DeclaredLicenseRelationship");
    relHasLicense.CreationInfo = ci;
    relHasLicense.RelationshipType = cmSpdxRelationship::HAS_DECLARED_LICENSE;
    relHasLicense.From = current.Package;
    relHasLicense.To.emplace_back(std::move(license));

    insert_back(doc.Graph, std::move(relHasLicense));
  }
  return true;
}

bool cmSbomBuilder::PopulateLinkLibrariesProperty(
  cmGeneratorTarget const* target,
  cmGeneratorExpression::PreprocessContext preprocessRule,
  ImportPropertyMap& properties)
{
  static std::array<std::string, 3> const linkIfaceProps = { {
    "LINK_LIBRARIES",
    "LINK_LIBRARIES_DIRECT",
    "LINK_LIBRARIES_DIRECT_EXCLUDE",
  } };
  bool hadLINK_LIBRARIES = false;
  for (std::string const& linkIfaceProp : linkIfaceProps) {
    if (cmValue input = target->GetProperty(linkIfaceProp)) {
      std::string prepro =
        cmGeneratorExpression::Preprocess(*input, preprocessRule);
      if (!prepro.empty()) {
        this->ResolveTargetsInGeneratorExpressions(prepro, target);
        properties[linkIfaceProp] = prepro;
        hadLINK_LIBRARIES = true;
      }
    }
  }
  return hadLINK_LIBRARIES;
}

bool cmSbomBuilder::AddTargetNamespace(std::string& input,
                                       cmGeneratorTarget const* target,
                                       cmLocalGenerator const* lg)
{
  cmGeneratorTarget::TargetOrString resolved =
    target->ResolveTargetReference(input, lg);

  cmGeneratorTarget* tgt = resolved.Target;
  if (!tgt) {
    input = resolved.String;
    return false;
  }

  if (tgt->IsImported()) {
    input = tgt->GetName();
    return this->NoteLinkedTarget(target, input, tgt);
  }

  if (this->SbomTargets.find(tgt) != this->SbomTargets.end()) {
    input = this->Namespace + tgt->GetExportName();
  } else {
    input = tgt->GetName();
  }

  return this->NoteLinkedTarget(target, input, tgt);
}

bool cmSbomBuilder::NoteLinkedTarget(cmGeneratorTarget const* target,
                                     std::string const& linkedName,
                                     cmGeneratorTarget const* linkedTarget)
{
  auto linkedLicense = linkedTarget->GetSafeProperty("SPDX_LICENSE");

  if (cm::contains(this->SbomTargets, linkedTarget)) {
    this->LinkTargets.emplace(
      linkedName,
      LinkInfo{ "", linkedTarget->GetExportName(), linkedLicense });
    return true;
  }

  if (linkedTarget->IsImported()) {
    using Package = cm::optional<std::pair<std::string, cmPackageInformation>>;
    auto pkgInfo = [](cmTarget* t) -> Package {
      cmFindPackageStack pkgStack = t->GetFindPackageStack();
      if (!pkgStack.Empty()) {
        return std::make_pair(pkgStack.Top().Name,
                              *pkgStack.Top().PackageInfo);
      }
      std::string const pkgName =
        t->GetSafeProperty("EXPORT_FIND_PACKAGE_NAME");
      if (pkgName.empty()) {
        return cm::nullopt;
      }
      cmPackageInformation package;
      return std::make_pair(pkgName, package);
    }(linkedTarget->Target);

    if (!pkgInfo) {
      target->Makefile->IssueDiagnostic(
        cmDiagnostics::CMD_AUTHOR,
        cmStrCat("Target \"", target->GetName(),
                 "\" references imported target \"", linkedName,
                 "\" which does not come from any known package."));
      return false;
    }

    std::string const& pkgName = pkgInfo->first;
    auto const& prefix = cmStrCat(pkgName, "::");
    std::string component;
    if (!cmHasPrefix(linkedName, prefix)) {
      component = linkedName;
    } else {
      component = linkedName.substr(prefix.length());
    }
    this->LinkTargets.emplace(linkedName,
                              LinkInfo{ pkgName, component, linkedLicense });
    cmPackageInformation& req =
      this->Requirements.insert(std::move(*pkgInfo)).first->second;
    req.Components.emplace(std::move(component));
    return true;
  }

  // Target belongs to another export from this build or install.
  // The leaf class chooses which export map to consult.
  auto const& exportInfo = this->FindExportInfoFor(linkedTarget);
  if (exportInfo.Namespaces.size() == 1 && exportInfo.Sets.size() == 1) {
    auto const& linkNamespace = *exportInfo.Namespaces.begin();
    if (!cmHasSuffix(linkNamespace, "::")) {
      target->Makefile->IssueDiagnostic(
        cmDiagnostics::CMD_AUTHOR,
        cmStrCat("Target \"", target->GetName(), "\" references target \"",
                 linkedName,
                 "\", whose export does not use the standard namespace "
                 "separator.  The dependency will be recorded by its bare "
                 "target name without provenance."));
      return false;
    }

    std::string pkgName{ linkNamespace.data(), linkNamespace.size() - 2 };
    std::string component = linkedTarget->GetExportName();
    if (pkgName == this->GetPackageName()) {
      this->LinkTargets.emplace(linkedName,
                                LinkInfo{ "", component, linkedLicense });
    } else {
      this->LinkTargets.emplace(linkedName,
                                LinkInfo{ pkgName, component, linkedLicense });
      this->Requirements[pkgName].Components.emplace(std::move(component));
    }
    return true;
  }

  if (exportInfo.Sets.empty()) {
    // install(export) provenance is unavailable.  Fall back to SBOM-level
    // attribution: any peer SBOM (of the same build/install mode) that
    // covers this target lends its package name.  install(export) wins
    // when both are available; only reached here when install(export) is
    // absent.
    auto const& sbomInfo = this->FindSbomInfoFor(linkedTarget);
    if (sbomInfo.Packages.empty()) {
      target->Makefile->IssueMessage(
        MessageType::FATAL_ERROR,
        cmStrCat("Target \"", target->GetName(), "\" references target \"",
                 linkedName,
                 "\" which has no install(EXPORT)/export(EXPORT) namespace "
                 "and is not covered by any SBOM.  An SBOM cannot attribute "
                 "this dependency.  Give \"",
                 linkedTarget->GetName(),
                 "\" an install(EXPORT)/export(EXPORT) with a NAMESPACE, or "
                 "include it in an install(SBOM)/export(SBOM)."));
      return false;
    }
    std::string const& pkgName = sbomInfo.Packages.front();
    if (sbomInfo.Packages.size() > 1) {
      target->Makefile->IssueDiagnostic(
        cmDiagnostics::CMD_AUTHOR,
        cmStrCat(
          "Target \"", target->GetName(), "\" references target \"",
          linkedName,
          "\" which has no install(EXPORT)/export(EXPORT) namespace and is "
          "covered by multiple SBOMs: ",
          cmJoin(sbomInfo.Packages, ", "), ".  Attributing to \"", pkgName,
          "\" (first alphabetically)."));
    }
    std::string component = linkedTarget->GetExportName();
    this->LinkTargets.emplace(linkedName,
                              LinkInfo{ pkgName, component, linkedLicense });
    this->Requirements[pkgName].Components.emplace(std::move(component));
    return true;
  }

  std::ostringstream e;
  e << "Target \"" << target->GetName() << "\" references target \""
    << linkedName << "\" ";
  if (exportInfo.Sets.size() == 1) {
    e << "that is in an export set which is exported multiple times "
         "with different namespaces: ";
  } else {
    e << "that is in multiple export sets: ";
  }
  e << cmJoin(exportInfo.Files, ", ") << ".\n"
    << "An SBOM cannot attribute a dependency exported in more than one "
       "export set or with more than one namespace.  Consider "
       "consolidating the exports of the \""
    << linkedTarget->GetName() << "\" target to a single export.";
  target->Makefile->IssueMessage(MessageType::FATAL_ERROR, e.str());
  return false;
}

void cmSbomBuilder::ResolveTargetsInGeneratorExpression(
  std::string& input, cmGeneratorTarget const* target,
  cmLocalGenerator const* lg)
{
  auto err = cmResolveTargetsInGeneratorExpression(
    input, [this, target, lg](std::string& name) {
      return this->AddTargetNamespace(name, target, lg);
    });
  if (err) {
    target->GetLocalGenerator()->IssueMessage(MessageType::FATAL_ERROR, *err);
  }
}

void cmSbomBuilder::ResolveTargetsInGeneratorExpressions(
  std::string& input, cmGeneratorTarget const* target)
{
  cmLocalGenerator const* lg = target->GetLocalGenerator();
  std::vector<std::string> parts;
  cmGeneratorExpression::Split(input, parts);

  std::string sep;
  input.clear();
  for (std::string& li : parts) {
    if (target->IsLinkLookupScope(li, lg)) {
      continue;
    }
    if (cmGeneratorExpression::Find(li) == std::string::npos) {
      this->AddTargetNamespace(li, target, lg);
    } else {
      this->ResolveTargetsInGeneratorExpression(li, target, lg);
    }
    input += sep + li;
    sep = ";";
  }
}

bool cmSbomBuilder::PopulateInterfaceLinkLibrariesProperty(
  cmGeneratorTarget const* target,
  cmGeneratorExpression::PreprocessContext preprocessRule,
  ImportPropertyMap& properties)
{
  if (!target->IsLinkable()) {
    return false;
  }
  static std::array<std::string, 3> const linkIfaceProps = {
    { "INTERFACE_LINK_LIBRARIES", "INTERFACE_LINK_LIBRARIES_DIRECT",
      "INTERFACE_LINK_LIBRARIES_DIRECT_EXCLUDE" }
  };
  bool hadINTERFACE_LINK_LIBRARIES = false;
  for (std::string const& linkIfaceProp : linkIfaceProps) {
    if (cmValue input = target->GetProperty(linkIfaceProp)) {
      std::string prepro =
        cmGeneratorExpression::Preprocess(*input, preprocessRule);
      if (!prepro.empty()) {
        this->ResolveTargetsInGeneratorExpressions(prepro, target);
        properties[linkIfaceProp] = prepro;
        hadINTERFACE_LINK_LIBRARIES = true;
      }
    }
  }
  return hadINTERFACE_LINK_LIBRARIES;
}