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/ADT/Triple.h"
  12 #include "llvm/Support/TargetParser.h"
  13 #include "llvm/Support/raw_ostream.h"
  14 #include <map>
  15
  16 namespace clang {
  17
  18 static llvm::SmallVector<llvm::StringRef, 4>
  19 getAllPossibleAMDGPUTargetIDFeatures(const llvm::Triple &T,
  20                                      llvm::StringRef Proc) {
  21   // Entries in returned vector should be in alphabetical order.
  22   llvm::SmallVector<llvm::StringRef, 4> Ret;
  23   auto ProcKind = T.isAMDGCN() ? llvm::AMDGPU::parseArchAMDGCN(Proc)
  24                                : llvm::AMDGPU::parseArchR600(Proc);
  25   if (ProcKind == llvm::AMDGPU::GK_NONE)
  26     return Ret;
  27   auto Features = T.isAMDGCN() ? llvm::AMDGPU::getArchAttrAMDGCN(ProcKind)
  28                                : llvm::AMDGPU::getArchAttrR600(ProcKind);
  29   if (Features & llvm::AMDGPU::FEATURE_SRAMECC)
  30     Ret.push_back("sramecc");
  31   if (Features & llvm::AMDGPU::FEATURE_XNACK)
  32     Ret.push_back("xnack");
  33   return Ret;
  34 }
  35
  36 llvm::SmallVector<llvm::StringRef, 4>
  37 getAllPossibleTargetIDFeatures(const llvm::Triple &T,
  38                                llvm::StringRef Processor) {
  39   llvm::SmallVector<llvm::StringRef, 4> Ret;
  40   if (T.isAMDGPU())
  41     return getAllPossibleAMDGPUTargetIDFeatures(T, Processor);
  42   return Ret;
  43 }
  44
  45 /// Returns canonical processor name or empty string if \p Processor is invalid.
  46 static llvm::StringRef getCanonicalProcessorName(const llvm::Triple &T,
  47                                                  llvm::StringRef Processor) {
  48   if (T.isAMDGPU())
  49     return llvm::AMDGPU::getCanonicalArchName(T, Processor);
  50   return Processor;
  51 }
  52
  53 llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T,
  54                                          llvm::StringRef TargetID) {
  55   auto Split = TargetID.split(':');
  56   return getCanonicalProcessorName(T, Split.first);
  57 }
  58
  59 // Parse a target ID with format checking only. Do not check whether processor
  60 // name or features are valid for the processor.
  61 //
  62 // A target ID is a processor name followed by a list of target features
  63 // delimited by colon. Each target feature is a string post-fixed by a plus
  64 // or minus sign, e.g. gfx908:sramecc+:xnack-.
  65 static llvm::Optional<llvm::StringRef>
  66 parseTargetIDWithFormatCheckingOnly(llvm::StringRef TargetID,
  67                                     llvm::StringMap<bool> *FeatureMap) {
  68   llvm::StringRef Processor;
  69
  70   if (TargetID.empty())
  71     return llvm::StringRef();
  72
  73   auto Split = TargetID.split(':');
  74   Processor = Split.first;
  75   if (Processor.empty())
  76     return llvm::None;
  77
  78   auto Features = Split.second;
  79   if (Features.empty())
  80     return Processor;
  81
  82   llvm::StringMap<bool> LocalFeatureMap;
  83   if (!FeatureMap)
  84     FeatureMap = &LocalFeatureMap;
  85
  86   while (!Features.empty()) {
  87     auto Splits = Features.split(':');
  88     auto Sign = Splits.first.back();
  89     auto Feature = Splits.first.drop_back();
  90     if (Sign != '+' && Sign != '-')
  91       return llvm::None;
  92     bool IsOn = Sign == '+';
  93     auto Loc = FeatureMap->find(Feature);
  94     // Each feature can only show up at most once in target ID.
  95     if (Loc != FeatureMap->end())
  96       return llvm::None;
  97     (*FeatureMap)[Feature] = IsOn;
  98     Features = Splits.second;
  99   }
 100   return Processor;
 101 }
 102
 103 llvm::Optional<llvm::StringRef>
 104 parseTargetID(const llvm::Triple &T, llvm::StringRef TargetID,
 105               llvm::StringMap<bool> *FeatureMap) {
 106   auto OptionalProcessor =
 107       parseTargetIDWithFormatCheckingOnly(TargetID, FeatureMap);
 108
 109   if (!OptionalProcessor)
 110     return llvm::None;
 111
 112   llvm::StringRef Processor = getCanonicalProcessorName(T, *OptionalProcessor);
 113   if (Processor.empty())
 114     return llvm::None;
 115
 116   llvm::SmallSet<llvm::StringRef, 4> AllFeatures;
 117   for (auto &&F : getAllPossibleTargetIDFeatures(T, Processor))
 118     AllFeatures.insert(F);
 119
 120   for (auto &&F : *FeatureMap)
 121     if (!AllFeatures.count(F.first()))
 122       return llvm::None;
 123
 124   return Processor;
 125 }
 126
 127 // A canonical target ID is a target ID containing a canonical processor name
 128 // and features in alphabetical order.
 129 std::string getCanonicalTargetID(llvm::StringRef Processor,
 130                                  const llvm::StringMap<bool> &Features) {
 131   std::string TargetID = Processor.str();
 132   std::map<const llvm::StringRef, bool> OrderedMap;
 133   for (const auto &F : Features)
 134     OrderedMap[F.first()] = F.second;
 135   for (auto F : OrderedMap)
 136     TargetID = TargetID + ':' + F.first.str() + (F.second ? "+" : "-");
 137   return TargetID;
 138 }
 139
 140 // For a specific processor, a feature either shows up in all target IDs, or
 141 // does not show up in any target IDs. Otherwise the target ID combination
 142 // is invalid.
 143 llvm::Optional<std::pair<llvm::StringRef, llvm::StringRef>>
 144 getConflictTargetIDCombination(const std::set<llvm::StringRef> &TargetIDs) {
 145   struct Info {
 146     llvm::StringRef TargetID;
 147     llvm::StringMap<bool> Features;
 148   };
 149   llvm::StringMap<Info> FeatureMap;
 150   for (auto &&ID : TargetIDs) {
 151     llvm::StringMap<bool> Features;
 152     llvm::StringRef Proc = *parseTargetIDWithFormatCheckingOnly(ID, &Features);
 153     auto Loc = FeatureMap.find(Proc);
 154     if (Loc == FeatureMap.end())
 155       FeatureMap[Proc] = Info{ID, Features};
 156     else {
 157       auto &ExistingFeatures = Loc->second.Features;
 158       if (llvm::any_of(Features, [&](auto &F) {
 159             return ExistingFeatures.count(F.first()) == 0;
 160           }))
 161         return std::make_pair(Loc->second.TargetID, ID);
 162     }
 163   }
 164   return llvm::None;
 165 }
 166
 167 } // namespace clang