| 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 |
#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 (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 |