clang  14.0.0git
TargetID.cpp
Go to the documentation of this file.
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 
20  llvm::StringRef Proc) {
21  // Entries in returned vector should be in alphabetical order.
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 
37 getAllPossibleTargetIDFeatures(const llvm::Triple &T,
38  llvm::StringRef Processor) {
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-.
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 
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 =
113  getCanonicalProcessorName(T, OptionalProcessor.getValue());
114  if (Processor.empty())
115  return llvm::None;
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 llvm::None;
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.
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 =
154  parseTargetIDWithFormatCheckingOnly(ID, &Features).getValue();
155  auto Loc = FeatureMap.find(Proc);
156  if (Loc == FeatureMap.end())
157  FeatureMap[Proc] = Info{ID, Features};
158  else {
159  auto &ExistingFeatures = Loc->second.Features;
160  if (llvm::any_of(Features, [&](auto &F) {
161  return ExistingFeatures.count(F.first()) == 0;
162  }))
163  return std::make_pair(Loc->second.TargetID, ID);
164  }
165  }
166  return llvm::None;
167 }
168 
169 } // namespace clang
clang::parseTargetIDWithFormatCheckingOnly
static llvm::Optional< llvm::StringRef > parseTargetIDWithFormatCheckingOnly(llvm::StringRef TargetID, llvm::StringMap< bool > *FeatureMap)
Definition: TargetID.cpp:66
string
string(SUBSTRING ${CMAKE_CURRENT_BINARY_DIR} 0 ${PATH_LIB_START} PATH_HEAD) string(SUBSTRING $
Definition: CMakeLists.txt:22
Ret
static bool Ret(InterpState &S, CodePtr &PC, APValue &Result)
Definition: Interp.cpp:34
llvm::SmallVector
Definition: LLVM.h:38
llvm::Optional
Definition: LLVM.h:40
clang::getProcessorFromTargetID
llvm::StringRef getProcessorFromTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch)
Get processor name from target ID.
Definition: TargetID.cpp:53
TargetID.h
clang::parseTargetID
llvm::Optional< llvm::StringRef > parseTargetID(const llvm::Triple &T, llvm::StringRef OffloadArch, llvm::StringMap< bool > *FeatureMap)
Parse a target ID to get processor and feature map.
Definition: TargetID.cpp:104
clang::getAllPossibleAMDGPUTargetIDFeatures
static const llvm::SmallVector< llvm::StringRef, 4 > getAllPossibleAMDGPUTargetIDFeatures(const llvm::Triple &T, llvm::StringRef Proc)
Definition: TargetID.cpp:19
clang::getAllPossibleTargetIDFeatures
const llvm::SmallVector< llvm::StringRef, 4 > getAllPossibleTargetIDFeatures(const llvm::Triple &T, llvm::StringRef Processor)
Get all feature strings that can be used in target ID for Processor.
Definition: TargetID.cpp:37
clang::getConflictTargetIDCombination
llvm::Optional< std::pair< llvm::StringRef, llvm::StringRef > > getConflictTargetIDCombination(const std::set< llvm::StringRef > &TargetIDs)
Get the conflicted pair of target IDs for a compilation or a bundled code object, assuming TargetIDs ...
Definition: TargetID.cpp:145
clang::getCanonicalTargetID
std::string getCanonicalTargetID(llvm::StringRef Processor, const llvm::StringMap< bool > &Features)
Returns canonical target ID, assuming Processor is canonical and all entries in Features are valid.
Definition: TargetID.cpp:130
DwarfFissionKind::Split
@ Split
clang::Builtin::ID
ID
Definition: Builtins.h:48
clang
Definition: CalledOnceCheck.h:17
clang::getCanonicalProcessorName
static llvm::StringRef getCanonicalProcessorName(const llvm::Triple &T, llvm::StringRef Processor)
Returns canonical processor name or empty string if Processor is invalid.
Definition: TargetID.cpp:46