clang/lib/Basic/TargetID.cpp

   1 //===--- TargetID.cpp - Utilities for parsing target ID -------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "clang/Basic/TargetID.h"
  10 #include "llvm/ADT/SmallSet.h"
  11 #include "llvm/Support/raw_ostream.h"
  12 #include "llvm/TargetParser/TargetParser.h"
  13 #include "llvm/TargetParser/Triple.h"
  14 #include <map>
  15 #include <optional>
  16
  17 namespace clang {
  18
  19 static llvm::SmallVector<llvm::StringRef, 4>
  20 getAllPossibleAMDGPUTargetIDFeatures(const llvm::Triple &T,
  21                                      llvm::StringRef Proc) {
  22   // Entries in returned vector should be in alphabetical order.
  23   llvm::SmallVector<llvm::StringRef, 4> Ret;
  24   auto ProcKind = T.isAMDGCN() ? llvm::AMDGPU::parseArchAMDGCN(Proc)
  25                                : llvm::AMDGPU::parseArchR600(Proc);
  26   if (ProcKind == llvm::AMDGPU::GK_NONE)
  27     return Ret;
  28   auto Features = T.isAMDGCN() ? llvm::AMDGPU::getArchAttrAMDGCN(ProcKind)
  29                                : llvm::AMDGPU::getArchAttrR600(ProcKind);
  30   if (Features & llvm::AMDGPU::FEATURE_SRAMECC)
  31     Ret.push_back("sramecc");
  32   if (Features & llvm::AMDGPU::FEATURE_XNACK)
  33     Ret.push_back("xnack");
  34   return Ret;
  35 }
  36
  37 llvm::SmallVector<llvm::StringRef, 4>
  38 getAllPossibleTargetIDFeatures(const llvm::Triple &T,
  39                                llvm::StringRef Processor) {
  40   llvm::SmallVector<llvm::StringRef, 4> Ret;
  41   if (T.isAMDGPU())
  42     return getAllPossibleAMDGPUTargetIDFeatures(T, Processor);
  43   return Ret;
  44 }
  45
  46 /// Returns canonical processor name or empty string if \p Processor is invalid.
  47 static llvm::StringRef getCanonicalProcessorName(const llvm::Triple &T,
  48                                                  llvm::StringRef Processor) {
  49   if (T.isAMDGPU())
  50     return llvm::AMDGPU::getCanonicalArchName(T, Processor);
  51   return Processor;
  52 }
  53
  54 llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T,
  55                                          llvm::StringRef TargetID) {
  56   auto Split = TargetID.split(':');
  57   return getCanonicalProcessorName(T, Split.first);
  58 }
  59
  60 // Parse a target ID with format checking only. Do not check whether processor
  61 // name or features are valid for the processor.
  62 //
  63 // A target ID is a processor name followed by a list of target features
  64 // delimited by colon. Each target feature is a string post-fixed by a plus
  65 // or minus sign, e.g. gfx908:sramecc+:xnack-.
  66 static std::optional<llvm::StringRef>
  67 parseTargetIDWithFormatCheckingOnly(llvm::StringRef TargetID,
  68                                     llvm::StringMap<bool> *FeatureMap) {
  69   llvm::StringRef Processor;
  70
  71   if (TargetID.empty())
  72     return llvm::StringRef();
  73
  74   auto Split = TargetID.split(':');
  75   Processor = Split.first;
  76   if (Processor.empty())
  77     return std::nullopt;
  78
  79   auto Features = Split.second;
  80   if (Features.empty())
  81     return Processor;
  82
  83   llvm::StringMap<bool> LocalFeatureMap;
  84   if (!FeatureMap)
  85     FeatureMap = &LocalFeatureMap;
  86
  87   while (!Features.empty()) {
  88     auto Splits = Features.split(':');
  89     auto Sign = Splits.first.back();
  90     auto Feature = Splits.first.drop_back();
  91     if (Sign != '+' && Sign != '-')
  92       return std::nullopt;
  93     bool IsOn = Sign == '+';
  94     auto Loc = FeatureMap->find(Feature);
  95     // Each feature can only show up at most once in target ID.
  96     if (Loc != FeatureMap->end())
  97       return std::nullopt;
  98     (*FeatureMap)[Feature] = IsOn;
  99     Features = Splits.second;
 100   }
 101   return Processor;
 102 }
 103
 104 std::optional<llvm::StringRef>
 105 parseTargetID(const llvm::Triple &T, llvm::StringRef TargetID,
 106               llvm::StringMap<bool> *FeatureMap) {
 107   auto OptionalProcessor =
 108       parseTargetIDWithFormatCheckingOnly(TargetID, FeatureMap);
 109
 110   if (!OptionalProcessor)
 111     return std::nullopt;
 112
 113   llvm::StringRef Processor = getCanonicalProcessorName(T, *OptionalProcessor);
 114   if (Processor.empty())
 115     return std::nullopt;
 116
 117   llvm::SmallSet<llvm::StringRef, 4> AllFeatures;
 118   for (auto &&F : getAllPossibleTargetIDFeatures(T, Processor))
 119     AllFeatures.insert(F);
 120
 121   for (auto &&F : *FeatureMap)
 122     if (!AllFeatures.count(F.first()))
 123       return std::nullopt;
 124
 125   return Processor;
 126 }
 127
 128 // A canonical target ID is a target ID containing a canonical processor name
 129 // and features in alphabetical order.
 130 std::string getCanonicalTargetID(llvm::StringRef Processor,
 131                                  const llvm::StringMap<bool> &Features) {
 132   std::string TargetID = Processor.str();
 133   std::map<const llvm::StringRef, bool> OrderedMap;
 134   for (const auto &F : Features)
 135     OrderedMap[F.first()] = F.second;
 136   for (const auto &F : OrderedMap)
 137     TargetID = TargetID + ':' + F.first.str() + (F.second ? "+" : "-");
 138   return TargetID;
 139 }
 140
 141 // For a specific processor, a feature either shows up in all target IDs, or
 142 // does not show up in any target IDs. Otherwise the target ID combination
 143 // is invalid.
 144 std::optional<std::pair<llvm::StringRef, llvm::StringRef>>
 145 getConflictTargetIDCombination(const std::set<llvm::StringRef> &TargetIDs) {
 146   struct Info {
 147     llvm::StringRef TargetID;
 148     llvm::StringMap<bool> Features;
 149   };
 150   llvm::StringMap<Info> FeatureMap;
 151   for (auto &&ID : TargetIDs) {
 152     llvm::StringMap<bool> Features;
 153     llvm::StringRef Proc = *parseTargetIDWithFormatCheckingOnly(ID, &Features);
 154     auto Loc = FeatureMap.find(Proc);
 155     if (Loc == FeatureMap.end())
 156       FeatureMap[Proc] = Info{ID, Features};
 157     else {
 158       auto &ExistingFeatures = Loc->second.Features;
 159       if (llvm::any_of(Features, [&](auto &F) {
 160             return ExistingFeatures.count(F.first()) == 0;
 161           }))
 162         return std::make_pair(Loc->second.TargetID, ID);
 163     }
 164   }
 165   return std::nullopt;
 166 }
 167
 168 bool isCompatibleTargetID(llvm::StringRef Provided, llvm::StringRef Requested) {
 169   llvm::StringMap<bool> ProvidedFeatures, RequestedFeatures;
 170   llvm::StringRef ProvidedProc =
 171       *parseTargetIDWithFormatCheckingOnly(Provided, &ProvidedFeatures);
 172   llvm::StringRef RequestedProc =
 173       *parseTargetIDWithFormatCheckingOnly(Requested, &RequestedFeatures);
 174   if (ProvidedProc != RequestedProc)
 175     return false;
 176   for (const auto &F : ProvidedFeatures) {
 177     auto Loc = RequestedFeatures.find(F.first());
 178     // The default (unspecified) value of a feature is 'All', which can match
 179     // either 'On' or 'Off'.
 180     if (Loc == RequestedFeatures.end())
 181       return false;
 182     // If a feature is specified, it must have exact match.
 183     if (Loc->second != F.second)
 184       return false;
 185   }
 186   return true;
 187 }
 188
 189 } // namespace clang