OMPContext.cpp

Go to the documentation of this file.

//===- OMPContext.cpp ------ Collection of helpers for OpenMP contexts ----===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
/// \file
///
/// This file implements helper functions and classes to deal with OpenMP
/// contexts as used by `[begin/end] declare variant` and `metadirective`.
///
//===----------------------------------------------------------------------===//
 
#include "llvm/Frontend/OpenMP/OMPContext.h"
#include "llvm/ADT/DenseSet.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/ADT/StringSwitch.h"
#include "llvm/Support/Debug.h"
#include "llvm/Support/raw_ostream.h"
#include "llvm/TargetParser/Triple.h"
#include <algorithm>
 
#define DEBUG_TYPE "openmp-ir-builder"
 
using namespace llvm;
using namespace omp;
 
OMPContext::OMPContext(bool IsDeviceCompilation, Triple TargetTriple,
                       Triple TargetOffloadTriple, int DeviceNum) {
  // Add the appropriate target device kind trait based on the target triple
  if (!TargetOffloadTriple.getTriple().empty() && DeviceNum > -1) {
    // If target triple is present, then target device is not a host
    ActiveTraits.set(unsigned(TraitProperty::target_device_kind_nohost));
    switch (TargetOffloadTriple.getArch()) {
    case Triple::arm:
    case Triple::armeb:
    case Triple::aarch64:
    case Triple::aarch64_be:
    case Triple::aarch64_32:
    case Triple::mips:
    case Triple::mipsel:
    case Triple::mips64:
    case Triple::mips64el:
    case Triple::ppc:
    case Triple::ppcle:
    case Triple::ppc64:
    case Triple::ppc64le:
    case Triple::systemz:
    case Triple::x86:
    case Triple::x86_64:
      ActiveTraits.set(unsigned(TraitProperty::target_device_kind_cpu));
      break;
    case Triple::amdgpu:
    case Triple::nvptx:
    case Triple::nvptx64:
    case Triple::spirv64:
      ActiveTraits.set(unsigned(TraitProperty::target_device_kind_gpu));
      break;
    default:
      break;
    }
    // Add the appropriate device architecture trait based on the triple.
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  if (TraitSelector::TraitSelectorEnum == TraitSelector::target_device_arch) { \
    if (TargetOffloadTriple.getArch() == Triple::parseArch(Str))               \
      ActiveTraits.set(unsigned(TraitProperty::Enum));                         \
  }
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  } else {
    // Add the appropriate device kind trait based on the triple and the
    // IsDeviceCompilation flag.
    ActiveTraits.set(unsigned(IsDeviceCompilation
                                  ? TraitProperty::device_kind_nohost
                                  : TraitProperty::device_kind_host));
    ActiveTraits.set(unsigned(TraitProperty::target_device_kind_host));
    switch (TargetTriple.getArch()) {
    case Triple::arm:
    case Triple::armeb:
    case Triple::aarch64:
    case Triple::aarch64_be:
    case Triple::aarch64_32:
    case Triple::mips:
    case Triple::mipsel:
    case Triple::mips64:
    case Triple::mips64el:
    case Triple::ppc:
    case Triple::ppcle:
    case Triple::ppc64:
    case Triple::ppc64le:
    case Triple::systemz:
    case Triple::x86:
    case Triple::x86_64:
      ActiveTraits.set(unsigned(TraitProperty::device_kind_cpu));
      ActiveTraits.set(unsigned(TraitProperty::target_device_kind_cpu));
      break;
    case Triple::amdgpu:
    case Triple::nvptx:
    case Triple::nvptx64:
    case Triple::spirv64:
      ActiveTraits.set(unsigned(TraitProperty::device_kind_gpu));
      ActiveTraits.set(unsigned(TraitProperty::target_device_kind_gpu));
      break;
    default:
      break;
    }
 
    // Add the appropriate device architecture trait based on the triple.
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  if (TraitSelector::TraitSelectorEnum == TraitSelector::device_arch ||        \
      TraitSelector::TraitSelectorEnum == TraitSelector::target_device_arch) { \
    if (TargetTriple.getArch() == Triple::parseArch(Str))                      \
      ActiveTraits.set(unsigned(TraitProperty::Enum));                         \
  }
#include "llvm/Frontend/OpenMP/OMPKinds.def"
 
    // TODO: What exactly do we want to see as device ISA trait?
    //       The discussion on the list did not seem to have come to an agreed
    //       upon solution.
 
    // LLVM is the "OpenMP vendor" but we could also interpret vendor as the
    // target vendor.
    ActiveTraits.set(unsigned(TraitProperty::implementation_vendor_llvm));
 
    // The user condition true is accepted but not false.
    ActiveTraits.set(unsigned(TraitProperty::user_condition_true));
 
    // This is for sure some device.
    ActiveTraits.set(unsigned(TraitProperty::device_kind_any));
 
    LLVM_DEBUG({
      dbgs() << "[" << DEBUG_TYPE
             << "] New OpenMP context with the following properties:\n";
      for (unsigned Bit : ActiveTraits.set_bits()) {
        TraitProperty Property = TraitProperty(Bit);
        dbgs() << "\t " << getOpenMPContextTraitPropertyFullName(Property)
               << "\n";
      }
    });
  }
}
 
/// Return true if \p C0 is an ordered subsequence of \p C1.
template <typename T>
static bool isOrderedSubset(ArrayRef<T> C0, ArrayRef<T> C1) {
  if (C0.size() > C1.size())
    return false;
  auto It0 = C0.begin(), End0 = C0.end();
  auto It1 = C1.begin(), End1 = C1.end();
  while (It0 != End0) {
    if (It1 == End1)
      return false;
    if (*It0 == *It1) {
      ++It0;
      ++It1;
      continue;
    }
    ++It1;
  }
  return true;
}
 
static bool isStrictSubset(const VariantMatchInfo &VMI0,
                           const VariantMatchInfo &VMI1) {
  // VMI0 is a strict subset if its required traits are a subset of VMI1's, its
  // construct traits are an ordered subsequence of VMI1's, and either relation
  // is strict.
  if (VMI0.RequiredTraits.count() > VMI1.RequiredTraits.count())
    return false;
  for (unsigned Bit : VMI0.RequiredTraits.set_bits())
    if (!VMI1.RequiredTraits.test(Bit))
      return false;
  if (!isOrderedSubset<TraitProperty>(VMI0.ConstructTraits,
                                      VMI1.ConstructTraits))
    return false;
  if (VMI0.RequiredTraits.count() < VMI1.RequiredTraits.count())
    return true;
  // With the same traits, only a repeated construct makes VMI0 strict.
  if (VMI0.ConstructTraits.size() == VMI1.ConstructTraits.size())
    return false;
  // Different conditions or ISA names share a trait, so they can't be compared.
  for (TraitProperty Property :
       {TraitProperty::user_condition_true, TraitProperty::user_condition_false,
        TraitProperty::user_condition_unknown})
    if (VMI0.RequiredTraits.test(unsigned(Property)))
      return false;
  return llvm::all_of(VMI0.ISATraits,
                      [&](const VariantMatchInfo::ISATrait &Trait) {
                        return llvm::is_contained(VMI1.ISATraits, Trait);
                      });
}
 
static int
isVariantApplicableInContextHelper(const VariantMatchInfo &VMI,
                                   const OMPContext &Ctx,
                                   SmallVectorImpl<unsigned> *ConstructMatches,
                                   bool DeviceOrImplementationSetOnly) {
 
  // The match kind determines if we need to match all traits, any of the
  // traits, or none of the traits for it to be an applicable context.
  enum MatchKind { MK_ALL, MK_ANY, MK_NONE };
 
  MatchKind MK = MK_ALL;
  // Determine the match kind the user wants, "all" is the default and provided
  // to the user only for completeness.
  if (VMI.RequiredTraits.test(
          unsigned(TraitProperty::implementation_extension_match_any)))
    MK = MK_ANY;
  if (VMI.RequiredTraits.test(
          unsigned(TraitProperty::implementation_extension_match_none)))
    MK = MK_NONE;
 
  bool AnyTraitMatched = false;
 
  // Apply the match kind selected by implementation={extension(...)} to
  // each property. Continue after match_any succeeds to record all construct
  // match positions needed for scoring.
  auto HandleTrait = [MK, &AnyTraitMatched](TraitProperty Property,
                                            bool WasFound) -> bool {
    AnyTraitMatched |= WasFound;
    if (MK == MK_ANY)
      return true;
 
    // In "all" or "none" mode we accept a matching or non-matching property
    // respectively and move on. We are not done yet!
    if ((WasFound && MK == MK_ALL) || (!WasFound && MK == MK_NONE))
      return true;
 
    // We missed a property, provide some debug output and indicate failure.
    LLVM_DEBUG({
      if (MK == MK_ALL)
        dbgs() << "[" << DEBUG_TYPE << "] Property "
               << getOpenMPContextTraitPropertyName(Property, "")
               << " was not in the OpenMP context but match kind is all.\n";
      if (MK == MK_NONE)
        dbgs() << "[" << DEBUG_TYPE << "] Property "
               << getOpenMPContextTraitPropertyName(Property, "")
               << " was in the OpenMP context but match kind is none.\n";
    });
    return false;
  };
 
  for (unsigned Bit : VMI.RequiredTraits.set_bits()) {
    TraitProperty Property = TraitProperty(Bit);
    if (DeviceOrImplementationSetOnly &&
        getOpenMPContextTraitSetForProperty(Property) != TraitSet::device &&
        getOpenMPContextTraitSetForProperty(Property) !=
            TraitSet::implementation)
      continue;
 
    // So far all extensions are handled elsewhere, we skip them here as they
    // are not part of the OpenMP context.
    if (getOpenMPContextTraitSelectorForProperty(Property) ==
        TraitSelector::implementation_extension)
      continue;
 
    bool IsActiveTrait = Ctx.ActiveTraits.test(unsigned(Property));
 
    // We overwrite the isa trait as it is actually up to the OMPContext hook to
    // check the raw string(s).
    if (Property == TraitProperty::device_isa___ANY ||
        Property == TraitProperty::target_device_isa___ANY)
      IsActiveTrait = llvm::all_of(VMI.ISATraits, [&](const auto &Trait) {
        return Trait.Property != Property || Ctx.matchesISATrait(Trait.Name);
      });
 
    if (!HandleTrait(Property, IsActiveTrait))
      return false;
    // The match_any result is known; skip ISA lookups, which can warn.
    if (MK == MK_ANY && AnyTraitMatched)
      break;
  }
 
  if (!DeviceOrImplementationSetOnly) {
    // Scan the construct sequence in order, recording matching context
    // positions for scoring.
    unsigned ConstructIdx = 0, NoConstructTraits = Ctx.ConstructTraits.size();
    for (TraitProperty Property : VMI.ConstructTraits) {
      assert(getOpenMPContextTraitSetForProperty(Property) ==
                 TraitSet::construct &&
             "Variant context is ill-formed!");
 
      // Verify the nesting. A failed match in match_any or match_none must not
      // consume the remaining context, since a later selector property can
      // still match.
      unsigned SearchStart = ConstructIdx;
      bool FoundInOrder = false;
      while (!FoundInOrder && ConstructIdx != NoConstructTraits)
        FoundInOrder = (Ctx.ConstructTraits[ConstructIdx++] == Property);
      if (!FoundInOrder && MK != MK_ALL)
        ConstructIdx = SearchStart;
      if (ConstructMatches && FoundInOrder)
        ConstructMatches->push_back(ConstructIdx - 1);
 
      if (!HandleTrait(Property, FoundInOrder)) {
        LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Construct property "
                          << getOpenMPContextTraitPropertyName(Property, "")
                          << " was not nested properly.\n");
        return false;
      }
 
      // TODO: Verify SIMD
    }
 
    // A complete ordered match can have several embeddings in the context.
    // Match backwards to choose the highest-valued one for scoring. Keep the
    // forward scan's partial matches for the match_any extension.
    if (ConstructMatches &&
        ConstructMatches->size() == VMI.ConstructTraits.size()) {
      ConstructIdx = NoConstructTraits;
      for (unsigned I = VMI.ConstructTraits.size(); I > 0; --I) {
        TraitProperty Property = VMI.ConstructTraits[I - 1];
        while (ConstructIdx > 0 &&
               Ctx.ConstructTraits[ConstructIdx - 1] != Property)
          --ConstructIdx;
        assert(ConstructIdx > 0 && "Previously matched construct not found!");
        (*ConstructMatches)[I - 1] = --ConstructIdx;
      }
    }
 
    if (MK == MK_ALL)
      assert(isOrderedSubset<TraitProperty>(VMI.ConstructTraits,
                                            Ctx.ConstructTraits) &&
             "Broken invariant!");
  }
 
  if (MK == MK_ANY && !AnyTraitMatched) {
    LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE
                      << "] None of the properties was in the OpenMP context "
                         "but match kind is any.\n");
    return false;
  }
 
  return true;
}
 
bool llvm::omp::isVariantApplicableInContext(
    const VariantMatchInfo &VMI, const OMPContext &Ctx,
    bool DeviceOrImplementationSetOnly) {
  return isVariantApplicableInContextHelper(
      VMI, Ctx, /* ConstructMatches */ nullptr, DeviceOrImplementationSetOnly);
}
 
static APInt getVariantMatchScore(const VariantMatchInfo &VMI,
                                  const OMPContext &Ctx,
                                  SmallVectorImpl<unsigned> &ConstructMatches) {
  APInt Score(1, 1);
 
  // A sum of valid scores can exceed the width of any individual score.
  // Retain all active bits and allow one more bit for each addition's carry.
  auto AddScore = [&](const APInt &Value) {
    unsigned Width = std::max(Score.getActiveBits(), Value.getActiveBits()) + 1;
    Score = Score.zextOrTrunc(Width);
    Score += Value.zextOrTrunc(Width);
  };
  auto AddPowerOfTwo = [&](unsigned Exponent) {
    AddScore(APInt::getOneBitSet(Exponent + 1, Exponent));
  };
 
  unsigned NoConstructTraits = Ctx.ConstructTraits.size();
  SmallDenseSet<TraitSelector, 8> ScoredSelectors;
  auto AddSelectorScore = [&](TraitSelector Selector, const APInt *UserScore) {
    // Scores belong to selectors, not to individual properties.
    if (!ScoredSelectors.insert(Selector).second)
      return;
    if (UserScore) {
      AddScore(*UserScore);
      return;
    }
    switch (Selector) {
    case TraitSelector::device_kind:
    case TraitSelector::target_device_kind:
      AddPowerOfTwo(NoConstructTraits);
      break;
    case TraitSelector::device_arch:
    case TraitSelector::target_device_arch:
      AddPowerOfTwo(NoConstructTraits + 1);
      break;
    case TraitSelector::device_isa:
    case TraitSelector::target_device_isa:
      AddPowerOfTwo(NoConstructTraits + 2);
      break;
    default:
      break;
    }
  };
  for (unsigned Bit : VMI.RequiredTraits.set_bits()) {
    TraitProperty Property = TraitProperty(Bit);
    // Construct scores use ordered positions below. kind(any) is treated as
    // if no kind selector were specified.
    if (getOpenMPContextTraitSetForProperty(Property) == TraitSet::construct ||
        Property == TraitProperty::device_kind_any ||
        Property == TraitProperty::target_device_kind_any)
      continue;
    auto It = VMI.ScoreMap.find(Property);
    AddSelectorScore(getOpenMPContextTraitSelectorForProperty(Property),
                     It == VMI.ScoreMap.end() ? nullptr : &It->second);
  }
 
  assert(VMI.ConstructTraits.size() >= ConstructMatches.size() &&
         "Mismatch in the construct traits!");
  for (unsigned Match : ConstructMatches) {
    // ConstructMatches is the position p - 1 and we need 2^(p-1).
    AddPowerOfTwo(Match);
  }
 
  LLVM_DEBUG({
    dbgs() << "[" << DEBUG_TYPE << "] Variant has a score of ";
    Score.print(dbgs(), /*isSigned=*/false);
    dbgs() << "\n";
  });
  return Score;
}
 
int llvm::omp::getBestVariantMatchForContext(
    const SmallVectorImpl<VariantMatchInfo> &VMIs, const OMPContext &Ctx) {
 
  APInt BestScore(1, 0);
  SmallVector<unsigned, 4> BestVMIIdxs;
 
  for (unsigned u = 0, e = VMIs.size(); u < e; ++u) {
    const VariantMatchInfo &VMI = VMIs[u];
 
    SmallVector<unsigned, 8> ConstructMatches;
    // If the variant is not applicable its not the best.
    if (!isVariantApplicableInContextHelper(
            VMI, Ctx, &ConstructMatches,
            /* DeviceOrImplementationSetOnly */ false))
      continue;
    // Check if its clearly not the best.
    APInt Score = getVariantMatchScore(VMI, Ctx, ConstructMatches);
    unsigned Width = std::max(Score.getBitWidth(), BestScore.getBitWidth());
    Score = Score.zextOrTrunc(Width);
    BestScore = BestScore.zextOrTrunc(Width);
    if (Score.ult(BestScore))
      continue;
    if (Score.ugt(BestScore)) {
      BestScore = Score;
      BestVMIIdxs.clear();
    }
    BestVMIIdxs.push_back(u);
  }
 
  // A strict subset of another tied variant is never best; otherwise the first
  // one wins. Tied variants often share a few supersets, so try the ones found
  // so far before scanning all of them.
  SmallVector<const VariantMatchInfo *, 4> Supersets;
  for (unsigned Idx : BestVMIIdxs) {
    const VariantMatchInfo &VMI = VMIs[Idx];
    if (llvm::any_of(Supersets, [&](const VariantMatchInfo *Superset) {
          return isStrictSubset(VMI, *Superset);
        }))
      continue;
    auto *It = llvm::find_if(BestVMIIdxs, [&](unsigned OtherIdx) {
      return isStrictSubset(VMI, VMIs[OtherIdx]);
    });
    if (It == BestVMIIdxs.end())
      return Idx;
    Supersets.push_back(&VMIs[*It]);
  }
  return -1;
}
 
TraitSet llvm::omp::getOpenMPContextTraitSetKind(StringRef S) {
  return StringSwitch<TraitSet>(S)
#define OMP_TRAIT_SET(Enum, Str) .Case(Str, TraitSet::Enum)
#include "llvm/Frontend/OpenMP/OMPKinds.def"
      .Default(TraitSet::invalid);
}
 
TraitSet
llvm::omp::getOpenMPContextTraitSetForSelector(TraitSelector Selector) {
  switch (Selector) {
#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp)                   \
  case TraitSelector::Enum:                                                    \
    return TraitSet::TraitSetEnum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait selector!");
}
TraitSet
llvm::omp::getOpenMPContextTraitSetForProperty(TraitProperty Property) {
  switch (Property) {
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  case TraitProperty::Enum:                                                    \
    return TraitSet::TraitSetEnum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait set!");
}
StringRef llvm::omp::getOpenMPContextTraitSetName(TraitSet Kind) {
  switch (Kind) {
#define OMP_TRAIT_SET(Enum, Str)                                               \
  case TraitSet::Enum:                                                         \
    return Str;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait set!");
}
 
TraitSelector llvm::omp::getOpenMPContextTraitSelectorKind(StringRef S,
                                                           TraitSet Set) {
  if (Set == TraitSet::target_device && S == "kind")
    return TraitSelector::target_device_kind;
  if (Set == TraitSet::target_device && S == "arch")
    return TraitSelector::target_device_arch;
  if (Set == TraitSet::target_device && S == "isa")
    return TraitSelector::target_device_isa;
  return StringSwitch<TraitSelector>(S)
#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp)                   \
  .Case(Str, TraitSelector::Enum)
#include "llvm/Frontend/OpenMP/OMPKinds.def"
      .Default(TraitSelector::invalid);
}
TraitSelector
llvm::omp::getOpenMPContextTraitSelectorForProperty(TraitProperty Property) {
  switch (Property) {
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  case TraitProperty::Enum:                                                    \
    return TraitSelector::TraitSelectorEnum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait set!");
}
StringRef llvm::omp::getOpenMPContextTraitSelectorName(TraitSelector Kind) {
  switch (Kind) {
#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp)                   \
  case TraitSelector::Enum:                                                    \
    return Str;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait selector!");
}
 
TraitProperty llvm::omp::getOpenMPContextTraitPropertyKind(
    TraitSet Set, TraitSelector Selector, StringRef S) {
  // Special handling for `device={isa(...)}` as we accept anything here. It is
  // up to the target to decide if the feature is available.
  if (Set == TraitSet::device && Selector == TraitSelector::device_isa)
    return TraitProperty::device_isa___ANY;
  if (Set == TraitSet::target_device &&
      Selector == TraitSelector::target_device_isa)
    return TraitProperty::target_device_isa___ANY;
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  if (Set == TraitSet::TraitSetEnum && Str == S)                               \
    return TraitProperty::Enum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  return TraitProperty::invalid;
}
TraitProperty
llvm::omp::getOpenMPContextTraitPropertyForSelector(TraitSelector Selector) {
  return StringSwitch<TraitProperty>(
             getOpenMPContextTraitSelectorName(Selector))
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  .Case(Str, Selector == TraitSelector::TraitSelectorEnum                      \
                 ? TraitProperty::Enum                                         \
                 : TraitProperty::invalid)
#include "llvm/Frontend/OpenMP/OMPKinds.def"
      .Default(TraitProperty::invalid);
}
StringRef llvm::omp::getOpenMPContextTraitPropertyName(TraitProperty Kind,
                                                       StringRef RawString) {
  if (Kind == TraitProperty::device_isa___ANY)
    return RawString;
  if (Kind == TraitProperty::target_device_isa___ANY)
    return RawString;
  switch (Kind) {
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  case TraitProperty::Enum:                                                    \
    return Str;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait property!");
}
StringRef llvm::omp::getOpenMPContextTraitPropertyFullName(TraitProperty Kind) {
  switch (Kind) {
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  case TraitProperty::Enum:                                                    \
    return "(" #TraitSetEnum "," #TraitSelectorEnum "," Str ")";
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait property!");
}
 
bool llvm::omp::isValidTraitSelectorForTraitSet(TraitSelector Selector,
                                                TraitSet Set,
                                                bool &AllowsTraitScore,
                                                bool &RequiresProperty) {
  AllowsTraitScore = Set != TraitSet::construct && Set != TraitSet::device &&
                     Set != TraitSet::target_device;
  switch (Selector) {
#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp)                   \
  case TraitSelector::Enum:                                                    \
    RequiresProperty = ReqProp;                                                \
    return Set == TraitSet::TraitSetEnum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait selector!");
}
 
bool llvm::omp::isValidTraitPropertyForTraitSetAndSelector(
    TraitProperty Property, TraitSelector Selector, TraitSet Set) {
  switch (Property) {
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  case TraitProperty::Enum:                                                    \
    return Set == TraitSet::TraitSetEnum &&                                    \
           Selector == TraitSelector::TraitSelectorEnum;
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  }
  llvm_unreachable("Unknown trait property!");
}
 
std::string llvm::omp::listOpenMPContextTraitSets() {
  std::string S;
#define OMP_TRAIT_SET(Enum, Str)                                               \
  if (StringRef(Str) != "invalid")                                             \
    S.append("'").append(Str).append("'").append(" ");
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  S.pop_back();
  return S;
}
 
std::string llvm::omp::listOpenMPContextTraitSelectors(TraitSet Set) {
  std::string S;
#define OMP_TRAIT_SELECTOR(Enum, TraitSetEnum, Str, ReqProp)                   \
  if (TraitSet::TraitSetEnum == Set && StringRef(Str) != "Invalid")            \
    S.append("'").append(Str).append("'").append(" ");
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  S.pop_back();
  return S;
}
 
std::string
llvm::omp::listOpenMPContextTraitProperties(TraitSet Set,
                                            TraitSelector Selector) {
  std::string S;
#define OMP_TRAIT_PROPERTY(Enum, TraitSetEnum, TraitSelectorEnum, Str)         \
  if (TraitSet::TraitSetEnum == Set &&                                         \
      TraitSelector::TraitSelectorEnum == Selector &&                          \
      StringRef(Str) != "invalid")                                             \
    S.append("'").append(Str).append("'").append(" ");
#include "llvm/Frontend/OpenMP/OMPKinds.def"
  if (S.empty())
    return "<none>";
  S.pop_back();
  return S;
}